Implement EssentialTypes2 package

c/common/src/codingstandards/c/TgMath.qll

@@ -0,0 +1,63 @@
+import cpp
+
+private string getATgMathMacroName(boolean allowComplex) {
+  allowComplex = true and
+  result =
+    [
+      "acos", "acosh", "asin", "asinh", "atan", "atanh", "carg", "cimag", "conj", "cos", "cosh",
+      "cproj", "creal", "exp", "fabs", "log", "pow", "sin", "sinh", "sqrt", "tan", "tanh"
+    ]
+  or
+  allowComplex = false and
+  result =
+    [
+      "atan2", "cbrt", "ceil", "copysign", "erf", "erfc", "exp2", "expm1", "fdim", "floor", "fma",
+      "fmax", "fmin", "fmod", "frexp", "hypot", "ilogb", "ldexp", "lgamma", "llrint", "llround",
+      "log10", "log1p", "log2", "logb", "lrint", "lround", "nearbyint", "nextafter", "nexttoward",
+      "remainder", "remquo", "rint", "round", "scalbn", "scalbln", "tgamma", "trunc",
+    ]
+}
+
+private predicate hasOutputArgument(string macroName, int index) {
+  macroName = "frexp" and index = 1
+  or
+  macroName = "remquo" and index = 2
+}
+
+class TgMathInvocation extends MacroInvocation {
+  Call call;
+  boolean allowComplex;
+
+  TgMathInvocation() {
+    this.getMacro().getName() = getATgMathMacroName(allowComplex) and
+    call = getBestCallInExpansion(this)
+  }
+
+  Expr getOperandArgument(int i) {
+    result = call.getArgument(i) and
+    not hasOutputArgument(call.getTarget().getName(), i)
+  }
+
+  int getNumberOfOperandArguments() {
+    result = call.getNumberOfArguments() - count(int i | hasOutputArgument(getMacroName(), i))
+  }
+
+  Expr getAnOperandArgument() { result = getOperandArgument(_) }
+
+  predicate allowsComplex() { allowComplex = true }
+}
+
+private Call getACallInExpansion(MacroInvocation mi) { result = mi.getAnExpandedElement() }
+
+private Call getNameMatchedCallInExpansion(MacroInvocation mi) {
+  result = getACallInExpansion(mi) and result.getTarget().getName() = mi.getMacroName()
+}
+
+private Call getBestCallInExpansion(MacroInvocation mi) {
+  count(getACallInExpansion(mi)) = 1 and result = getACallInExpansion(mi)
+  or
+  count(getNameMatchedCallInExpansion(mi)) = 1 and result = getNameMatchedCallInExpansion(mi)
+  or
+  count(getNameMatchedCallInExpansion(mi)) > 1 and
+  result = rank[1](Call c | c = getACallInExpansion(mi) | c order by c.getTarget().getName())
+}

c/misra/src/rules/RULE-21-22/TgMathArgumentWithInvalidEssentialType.ql

@@ -0,0 +1,47 @@
+/**
+ * @id c/misra/tg-math-argument-with-invalid-essential-type
+ * @name RULE-21-22: All operand arguments to type-generic macros in <tgmath.h> shall have an appropriate essential type
+ * @description All operand arguments to any type-generic macros in <tgmath.h> shall have an
+ *              appropriate essential type.
+ * @kind problem
+ * @precision high
+ * @problem.severity error
+ * @tags external/misra/id/rule-21-22
+ *       correctness
+ *       external/misra/c/2012/amendment3
+ *       external/misra/obligation/mandatory
+ */
+
+import cpp
+import codingstandards.c.misra
+import codingstandards.c.TgMath
+import codingstandards.c.misra.EssentialTypes
+
+EssentialTypeCategory getAnAllowedEssentialTypeCategory(TgMathInvocation call) {
+  result = EssentiallySignedType()
+  or
+  result = EssentiallyUnsignedType()
+  or
+  result = EssentiallyFloatingType(Real())
+  or
+  call.allowsComplex() and
+  result = EssentiallyFloatingType(Complex())
+}
+
+string getAllowedTypesString(TgMathInvocation call) {
+  if call.allowsComplex()
+  then result = "essentially signed, unsigned, or floating type"
+  else result = "essentially signed, unsigned, or real floating type"
+}
+
+from TgMathInvocation call, Expr arg, int argIndex, Type type, EssentialTypeCategory category
+where
+  not isExcluded(call, EssentialTypes2Package::tgMathArgumentWithInvalidEssentialTypeQuery()) and
+  arg = call.getOperandArgument(argIndex) and
+  type = getEssentialType(arg) and
+  category = getEssentialTypeCategory(type) and
+  not category = getAnAllowedEssentialTypeCategory(call)
+select arg,
+  "Argument " + (argIndex + 1) + " provided to type-generic macro '" + call.getMacroName() +
+    "' has " + category.toString().toLowerCase() + ", which is not " + getAllowedTypesString(call) +
+    "."

c/misra/src/rules/RULE-21-23/TgMathArgumentsWithDifferingStandardType.ql

@@ -0,0 +1,75 @@
+/**
+ * @id c/misra/tg-math-arguments-with-differing-standard-type
+ * @name RULE-21-23: Operand arguments for an invocation of a type-generic macro shall have the same standard type
+ * @description All operand arguments to any multi-argument type-generic macros in <tgmath.h> shall
+ *              have the same standard type.
+ * @kind problem
+ * @precision high
+ * @problem.severity error
+ * @tags external/misra/id/rule-21-23
+ *       correctness
+ *       external/misra/c/2012/amendment3
+ *       external/misra/obligation/required
+ */
+
+import cpp
+import codingstandards.c.misra
+import codingstandards.c.TgMath
+
+string argTypesString(TgMathInvocation call, int i) {
+  exists(string typeStr |
+    typeStr = getEffectiveStandardType(call.getOperandArgument(i)).toString() and
+    (
+      i = 0 and result = typeStr
+      or
+      i > 0 and result = argTypesString(call, i - 1) + ", " + typeStr
+    )
+  )
+}
+
+/**
+ * If the range of values can be represented as a signed int, it is promoted to signed int.
+ *
+ * A value may also promote to unsigned int but only if `int` cannot represent the range of
+ * values. Which basically means only an `unsigned int` promotes to `unsigned int`, so we don't
+ * need to do anything in this case.
+ *
+ * An unsigned int bitfield with fewer than 32 bits is promoted to `int`.
+ */
+predicate promotesToSignedInt(Expr e) {
+  exists(int intBits, int intBytes |
+    intBytes = any(IntType t).getSize() and
+    intBits = intBytes * 8 and
+    (
+      e.(FieldAccess).getTarget().(BitField).getNumBits() < intBits
+      or
+      e.getUnderlyingType().(IntegralType).getSize() < intBytes
+    )
+  )
+}
+
+Type getPromotedType(Expr e) {
+  if promotesToSignedInt(e) then result.(IntType).isSigned() else result = e.getUnderlyingType()
+}
+
+Type canonicalize(Type type) {
+  if type instanceof IntegralType
+  then result = type.(IntegralType).getCanonicalArithmeticType()
+  else result = type
+}
+
+Type getEffectiveStandardType(Expr e) {
+  result = canonicalize(getPromotedType(e.getExplicitlyConverted()))
+}
+
+from TgMathInvocation call, Type firstType
+where
+  not isExcluded(call, EssentialTypes2Package::tgMathArgumentsWithDifferingStandardTypeQuery()) and
+  firstType = getEffectiveStandardType(call.getAnOperandArgument()) and
+  not forall(Expr arg | arg = call.getAnOperandArgument() |
+    firstType = getEffectiveStandardType(arg)
+  )
+select call,
+  "Call to type-generic macro '" + call.getMacroName() +
+    "' has arguments with differing standard types (" +
+    argTypesString(call, call.getNumberOfOperandArguments() - 1) + ")."