Merge branch 'main' into exclude-rvaluerefs-a7-1-1

Author: lcartey

.github/workflows/upgrade_codeql_dependencies.yml

@@ -53,7 +53,7 @@ jobs:
           find c \( -name '*.ql' -or -name '*.qll' \) -print0 | xargs -0 --max-procs "$XARGS_MAX_PROCS" codeql query format --in-place
 
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@5e914681df9dc83aa4e4905692ca88beb2f9e91f # v7.0.5
+        uses: peter-evans/create-pull-request@67ccf781d68cd99b580ae25a5c18a1cc84ffff1f # v7.0.6
         with:
           title: "Upgrade `github/codeql` dependency to ${{ github.event.inputs.codeql_cli_version }}"
           body: |

c/cert/src/qlpack.yml

@@ -1,5 +1,5 @@
 name: codeql/cert-c-coding-standards
-version: 2.41.0-dev
+version: 2.42.0-dev
 description: CERT C 2016
 suites: codeql-suites
 license: MIT

c/cert/test/qlpack.yml

@@ -1,5 +1,5 @@
 name: codeql/cert-c-coding-standards-tests
-version: 2.41.0-dev
+version: 2.42.0-dev
 extractor: cpp
 license: MIT
 dependencies:

c/common/src/qlpack.yml

@@ -1,5 +1,5 @@
 name: codeql/common-c-coding-standards
-version: 2.41.0-dev
+version: 2.42.0-dev
 license: MIT
 dependencies:
   codeql/common-cpp-coding-standards: '*'

c/common/test/qlpack.yml

@@ -1,5 +1,5 @@
 name: codeql/common-c-coding-standards-tests
-version: 2.41.0-dev
+version: 2.42.0-dev
 extractor: cpp
 license: MIT
 dependencies:

c/misra/src/codeql-suites/misra-c-default.qls

@@ -7,4 +7,5 @@
 - exclude:
     tags contain:
     - external/misra/audit
+    - external/misra/strict
     - external/misra/default-disabled

c/misra/src/codeql-suites/misra-c-strict.qls

@@ -0,0 +1,8 @@
+- description: MISRA C 2012 (Strict)
+- qlpack: codeql/misra-c-coding-standards
+- include:
+    kind:
+    - problem
+    - path-problem
+    tags contain:
+    - external/misra/strict

c/misra/src/codingstandards/c/misra/EssentialTypes.qll

@@ -31,17 +31,19 @@ class EssentialTypeCategory extends TEssentialTypeCategory {
   }
 }
 
+class EssentiallySignedOrUnsignedType extends EssentialTypeCategory {
+  EssentiallySignedOrUnsignedType() {
+    this = EssentiallySignedType() or this = EssentiallyUnsignedType()
+  }
+}
+
 /**
  * An expression in the program that evaluates to a compile time constant signed or unsigned integer.
  */
 private class ConstantIntegerExpr extends Expr {
   pragma[noinline]
   ConstantIntegerExpr() {
-    getEssentialTypeCategory(this.getType()) =
-      [
-        EssentiallyUnsignedType().(EssentialTypeCategory),
-        EssentiallySignedType().(EssentialTypeCategory)
-      ] and
+    getEssentialTypeCategory(this.getType()) instanceof EssentiallySignedOrUnsignedType and
     exists(this.getValue().toFloat()) and
     not this instanceof Conversion
   }
@@ -192,8 +194,8 @@ class EssentialEqualityOperationExpr extends EssentialExpr, EqualityOperation {
   override Type getEssentialType() { result instanceof BoolType }
 }
 
-class EssentialBinaryBitwiseOperationExpr extends EssentialExpr, BinaryBitwiseOperation {
-  EssentialBinaryBitwiseOperationExpr() {
+class EssentialShiftOperationExpr extends EssentialExpr, BinaryBitwiseOperation {
+  EssentialShiftOperationExpr() {
     this instanceof LShiftExpr or
     this instanceof RShiftExpr
   }
@@ -235,9 +237,7 @@ class EssentialUnaryPlusExpr extends EssentialExpr, UnaryPlusExpr {
       operandEssentialType = getEssentialType(getOperand()) and
       operandEssentialTypeCategory = getEssentialTypeCategory(operandEssentialType)
     |
-      if
-        operandEssentialTypeCategory =
-          [EssentiallyUnsignedType().(TEssentialTypeCategory), EssentiallySignedType()]
+      if operandEssentialTypeCategory instanceof EssentiallySignedOrUnsignedType
       then result = operandEssentialType
       else result = getStandardType()
     )
@@ -257,6 +257,13 @@ class EssentialUnaryMinusExpr extends EssentialExpr, UnaryMinusExpr {
   }
 }
 
+bindingset[essentialTypeA, essentialTypeB]
+private Type maxRankType(Type essentialTypeA, Type essentialTypeB) {
+  if essentialTypeA.getSize() > essentialTypeB.getSize()
+  then result = essentialTypeA
+  else result = essentialTypeB
+}
+
 class EssentialConditionalExpr extends EssentialExpr, ConditionalExpr {
   override Type getEssentialType() {
     exists(Type thenEssentialType, Type elseEssentialType |
@@ -267,30 +274,34 @@ class EssentialConditionalExpr extends EssentialExpr, ConditionalExpr {
       then result = thenEssentialType
       else
         if
-          getEssentialTypeCategory(thenEssentialType) = EssentiallySignedType() and
-          getEssentialTypeCategory(elseEssentialType) = EssentiallySignedType()
-        then
-          if thenEssentialType.getSize() > elseEssentialType.getSize()
-          then result = thenEssentialType
-          else result = elseEssentialType
-        else
-          if
-            getEssentialTypeCategory(thenEssentialType) = EssentiallyUnsignedType() and
-            getEssentialTypeCategory(elseEssentialType) = EssentiallyUnsignedType()
-          then
-            if thenEssentialType.getSize() > elseEssentialType.getSize()
-            then result = thenEssentialType
-            else result = elseEssentialType
-          else result = this.getStandardType()
+          getEssentialTypeCategory(thenEssentialType) = getEssentialTypeCategory(elseEssentialType) and
+          getEssentialTypeCategory(thenEssentialType) instanceof EssentiallySignedOrUnsignedType
+        then result = maxRankType(thenEssentialType, elseEssentialType)
+        else result = this.getStandardType()
     )
   }
 }
 
-class EssentialBinaryArithmeticExpr extends EssentialExpr, BinaryArithmeticOperation {
-  EssentialBinaryArithmeticExpr() {
-    // GNU C extension has min/max which we can ignore
-    not this instanceof MinExpr and
-    not this instanceof MaxExpr
+/**
+ * A binary operation subject to usual conversions, with essential type behaviour as specified by D.7.9.
+ */
+class EssentialBinaryOperationSubjectToUsualConversions extends EssentialExpr, BinaryOperation {
+  EssentialBinaryOperationSubjectToUsualConversions() {
+    this instanceof MulExpr
+    or
+    this instanceof DivExpr
+    or
+    this instanceof RemExpr
+    or
+    this instanceof AddExpr
+    or
+    this instanceof SubExpr
+    or
+    this instanceof BitwiseAndExpr
+    or
+    this instanceof BitwiseOrExpr
+    or
+    this instanceof BitwiseXorExpr
   }
 
   override Type getEssentialType() {
@@ -305,50 +316,57 @@ class EssentialBinaryArithmeticExpr extends EssentialExpr, BinaryArithmeticOpera
       rightEssentialTypeCategory = getEssentialTypeCategory(rightEssentialType)
     |
       if
-        leftEssentialTypeCategory = EssentiallySignedType() and
-        rightEssentialTypeCategory = EssentiallySignedType()
+        leftEssentialTypeCategory = rightEssentialTypeCategory and
+        leftEssentialTypeCategory instanceof EssentiallySignedOrUnsignedType
       then
         if exists(getValue())
-        then result = stlr(this)
-        else (
-          if leftEssentialType.getSize() > rightEssentialType.getSize()
-          then result = leftEssentialType
-          else result = rightEssentialType
-        )
-      else
-        if
-          leftEssentialTypeCategory = EssentiallyUnsignedType() and
-          rightEssentialTypeCategory = EssentiallyUnsignedType()
         then
-          if exists(getValue())
-          then result = utlr(this)
-          else (
-            if leftEssentialType.getSize() > rightEssentialType.getSize()
-            then result = leftEssentialType
-            else result = rightEssentialType
-          )
-        else
-          if
-            this instanceof AddExpr and
-            (
-              leftEssentialTypeCategory = EssentiallyCharacterType()
-              or
-              rightEssentialTypeCategory = EssentiallyCharacterType()
-            ) and
-            (
-              leftEssentialTypeCategory =
-                [EssentiallySignedType(), EssentiallyUnsignedType().(TEssentialTypeCategory)]
-              or
-              rightEssentialTypeCategory =
-                [EssentiallySignedType(), EssentiallyUnsignedType().(TEssentialTypeCategory)]
-            )
-            or
-            this instanceof SubExpr and
-            leftEssentialTypeCategory = EssentiallyCharacterType() and
-            rightEssentialTypeCategory =
-              [EssentiallySignedType(), EssentiallyUnsignedType().(TEssentialTypeCategory)]
-          then result instanceof PlainCharType
-          else result = this.getStandardType()
+          leftEssentialTypeCategory = EssentiallySignedType() and result = stlr(this)
+          or
+          leftEssentialTypeCategory = EssentiallyUnsignedType() and result = utlr(this)
+        else result = maxRankType(leftEssentialType, rightEssentialType)
+      else result = this.getStandardType()
+    )
+  }
+}
+
+/**
+ * An add expression, with essential type behaviour as specified by D.7.9.
+ */
+class EssentialAddExpr extends EssentialBinaryOperationSubjectToUsualConversions, AddExpr {
+  override Type getEssentialType() {
+    exists(
+      EssentialTypeCategory operandTypeCategory, EssentialTypeCategory otherOperandTypeCategory
+    |
+      operandTypeCategory = getEssentialTypeCategory(getEssentialType(getAnOperand())) and
+      otherOperandTypeCategory = getEssentialTypeCategory(getEssentialType(getAnOperand()))
+    |
+      if
+        operandTypeCategory = EssentiallyCharacterType() and
+        otherOperandTypeCategory instanceof EssentiallySignedOrUnsignedType
+      then result instanceof PlainCharType
+      else result = super.getEssentialType()
+    )
+  }
+}
+
+/**
+ * A sub expression, with essential type behaviour as specified by D.7.9.
+ */
+class EssentialSubExpr extends EssentialBinaryOperationSubjectToUsualConversions, SubExpr {
+  override Type getEssentialType() {
+    exists(
+      EssentialTypeCategory leftEssentialTypeCategory,
+      EssentialTypeCategory rightEssentialTypeCategory
+    |
+      leftEssentialTypeCategory = getEssentialTypeCategory(getEssentialType(getLeftOperand())) and
+      rightEssentialTypeCategory = getEssentialTypeCategory(getEssentialType(getRightOperand()))
+    |
+      if
+        leftEssentialTypeCategory = EssentiallyCharacterType() and
+        rightEssentialTypeCategory instanceof EssentiallySignedOrUnsignedType
+      then result instanceof PlainCharType
+      else result = super.getEssentialType()
     )
   }
 }

c/misra/src/qlpack.yml

@@ -1,5 +1,5 @@
 name: codeql/misra-c-coding-standards
-version: 2.41.0-dev
+version: 2.42.0-dev
 description: MISRA C 2012
 suites: codeql-suites
 license: MIT

c/misra/src/rules/RULE-2-8/UnusedObjectDefinition.ql

@@ -0,0 +1,24 @@
+/**
+ * @id c/misra/unused-object-definition
+ * @name RULE-2-8: A project should not contain unused object definitions
+ * @description Object definitions which are unused should be removed.
+ * @kind problem
+ * @precision very-high
+ * @problem.severity recommendation
+ * @tags external/misra/id/rule-2-8
+ *       maintainability
+ *       performance
+ *       external/misra/c/2012/amendment4
+ *       external/misra/obligation/advisory
+ */
+
+import cpp
+import codingstandards.c.misra
+import codingstandards.cpp.deadcode.UnusedObjects
+
+from ReportDeadObject report
+where
+  not isExcluded(report.getPrimaryElement(), DeadCode2Package::unusedObjectDefinitionQuery()) and
+  not report.hasAttrUnused()
+select report.getPrimaryElement(), report.getMessage(), report.getOptionalPlaceholderLocation(),
+  report.getOptionalPlaceholderMessage()