EssentialTypes: Implement Rule 21.16

Adds a query to find uses of memcmp with pointer types which are
prohibited by MISRA C.

Author: lcartey

c/misra/src/rules/RULE-21-16/MemcmpOnInappropriateEssentialTypeArgs.ql

@@ -0,0 +1,44 @@
+/**
+ * @id c/misra/memcmp-on-inappropriate-essential-type-args
+ * @name RULE-21-16: The pointer arguments to the Standard Library function memcmp shall point to either a pointer type,
+ * @description The pointer arguments to the Standard Library function memcmp shall point to either
+ *              a pointer type, an essentially signed type, an essentially unsigned type, an
+ *              essentially Boolean type or an essentially enum type
+ * @kind problem
+ * @precision very-high
+ * @problem.severity error
+ * @tags external/misra/id/rule-21-16
+ *       external/misra/obligation/required
+ */
+
+import cpp
+import codingstandards.c.misra
+import codingstandards.c.misra.EssentialTypes
+
+from FunctionCall memcmp, Expr arg, Type argBaseType
+where
+  not isExcluded(arg, EssentialTypesPackage::memcmpOnInappropriateEssentialTypeArgsQuery()) and
+  memcmp.getTarget().hasGlobalName("memcmp") and
+  // Pointer arguments
+  arg = memcmp.getArgument([0, 1]) and
+  exists(DerivedType pt |
+    // Must be a pointer type or array type
+    (
+      pt instanceof PointerType or
+      pt instanceof ArrayType
+    ) and
+    pt = arg.getType() and
+    argBaseType = pt.getBaseType() and
+    // Doesn't point to a pointer type
+    not argBaseType instanceof PointerType and
+    // Doesn't point to a type which is essentially signed, unsigned, boolean or enum
+    not exists(EssentialTypeCategory typeCategory |
+      typeCategory = getEssentialTypeCategory(argBaseType)
+    |
+      typeCategory = EssentiallySignedType() or
+      typeCategory = EssentiallyUnsignedType() or
+      typeCategory = EssentiallyBooleanType() or
+      typeCategory = EssentiallyEnumType()
+    )
+  )
+select arg, "Argument is a pointer to " + argBaseType + "."

c/misra/test/rules/RULE-21-16/MemcmpOnInappropriateEssentialTypeArgs.expected

@@ -0,0 +1,10 @@
+| test.c:23:10:23:10 | p | Argument is a pointer to float. |
+| test.c:23:13:23:13 | q | Argument is a pointer to float. |
+| test.c:35:10:35:10 | p | Argument is a pointer to S1. |
+| test.c:35:13:35:13 | q | Argument is a pointer to S1. |
+| test.c:41:10:41:10 | p | Argument is a pointer to U. |
+| test.c:41:13:41:13 | q | Argument is a pointer to U. |
+| test.c:45:10:45:10 | p | Argument is a pointer to char. |
+| test.c:45:13:45:13 | q | Argument is a pointer to char. |
+| test.c:49:10:49:10 | p | Argument is a pointer to char. |
+| test.c:49:13:49:13 | q | Argument is a pointer to char. |

c/misra/test/rules/RULE-21-16/MemcmpOnInappropriateEssentialTypeArgs.qlref

@@ -0,0 +1 @@
+rules/RULE-21-16/MemcmpOnInappropriateEssentialTypeArgs.ql

c/misra/test/rules/RULE-21-16/test.c

@@ -0,0 +1,54 @@
+#include <stdbool.h>
+#include <string.h>
+
+void testMemcmpSignedInt(signed int *p, signed int *q, size_t size) {
+  memcmp(p, q, size); // COMPLIANT
+}
+
+void testMemcmpUnsignedInt(unsigned int *p, unsigned int *q, size_t size) {
+  memcmp(p, q, size); // COMPLIANT
+}
+
+enum E1 { E1_1, E1_2 };
+
+void testMemcmpEnum(enum E1 *p, enum E1 *q, size_t size) {
+  memcmp(p, q, size); // COMPLIANT
+}
+
+void testMemcmpBool(bool *p, bool *q, size_t size) {
+  memcmp(p, q, size); // COMPLIANT
+}
+
+void testMemcmpFloat(float *p, float *q, size_t size) {
+  memcmp(p, q, size); // NON_COMPLIANT
+}
+
+void testMemcmpPointerToPointer(void **p, void **q, size_t size) {
+  memcmp(p, q, size); // COMPLIANT
+}
+
+struct S1 {
+  int i;
+};
+
+void testMemcmpStruct(struct S1 *p, struct S1 *q, size_t size) {
+  memcmp(p, q, size); // NON_COMPLIANT
+}
+
+union U;
+
+void testMemcmpUnion(union U *p, union U *q, size_t size) {
+  memcmp(p, q, size); // NON_COMPLIANT
+}
+
+void testMemcmpChar(char *p, char *q, size_t size) {
+  memcmp(p, q, size); // NON_COMPLIANT
+}
+
+void testMemcmpCharArray(char p[10], char q[10], size_t size) {
+  memcmp(p, q, size); // NON_COMPLIANT
+}
+
+void testMemcmpIntArray(int p[10], int q[10], size_t size) {
+  memcmp(p, q, size); // COMPLIANT
+}