C++: Add support for C23 _BitInts

Author: jketema

cpp/ql/lib/semmle/code/cpp/Print.qll

@@ -148,8 +148,8 @@ private class BuiltInDumpType extends DumpType, BuiltInType {
   override string getTypeSpecifier() { result = this.toString() }
 }
 
-private class IntegralDumpType extends BuiltInDumpType, IntegralType {
-  override string getTypeSpecifier() { result = this.getCanonicalArithmeticType().toString() }
+private class IntegralDumpType extends BuiltInDumpType instanceof IntegralType {
+  override string getTypeSpecifier() { result = super.getCanonicalArithmeticType().toString() }
 }
 
 private class DerivedDumpType extends DumpType, DerivedType {

cpp/ql/lib/semmle/code/cpp/Type.qll

@@ -349,7 +349,7 @@ class UnknownType extends BuiltInType {
   override string getAPrimaryQlClass() { result = "UnknownType" }
 }
 
-private predicate isArithmeticType(@builtintype type, int kind) {
+private predicate isBuiltInArithmeticType(@builtintype type, int kind) {
   builtintypes(type, _, kind, _, _, _) and
   kind >= 4 and
   kind != 34 and // Exclude decltype(nullptr)
@@ -378,14 +378,50 @@ class ScalableVectorCount extends BuiltInType {
  * operations may be performed.  Examples of arithmetic types include
  * `char`, `int`, `float`, and `bool`.
  */
-class ArithmeticType extends BuiltInType {
-  ArithmeticType() { isArithmeticType(underlyingElement(this), _) }
+abstract private class ArithmeticTypeImpl extends Type { }
 
-  override string getAPrimaryQlClass() { result = "ArithmeticType" }
+final class ArithmeticType = ArithmeticTypeImpl;
+
+/**
+ * A C/C++ arithmetic type that is not a bit-precise integer.
+ */
+class BuiltInArithmeticType extends ArithmeticTypeImpl, BuiltInType {
+  BuiltInArithmeticType() { isBuiltInArithmeticType(underlyingElement(this), _) }
+
+  override string getAPrimaryQlClass() { result = "BuiltInArithmeticType" }
+}
+
+/**
+ * A C23 bit-precise integer (`_BitInt`).
+ */
+class BitPreciseArithmeticType extends ArithmeticTypeImpl {
+  boolean isSigned;
+  boolean isExplicitlySigned;
+  int bitWidth;
+
+  BitPreciseArithmeticType() {
+    bit_precise_types(underlyingElement(this), isSigned, isExplicitlySigned, bitWidth)
+  }
+
+  override string toString() { result = this.getName() }
+
+  override string getName() {
+    isSigned = true and isExplicitlySigned = true and result = "signed _BitInt(" + bitWidth + ")"
+    or
+    isSigned = true and isExplicitlySigned = false and result = "_BitInt(" + bitWidth + ")"
+    or
+    isSigned = false and result = "unsigned _BitInt(" + bitWidth + ")"
+  }
+
+  override string explain() { result = this.getName() }
+
+  override predicate isDeeplyConstBelow() { any() } // No subparts
+
+  override string getAPrimaryQlClass() { result = "BitPreciseArithmeticType" }
 }
 
-private predicate isIntegralType(@builtintype type, int kind) {
-  isArithmeticType(type, kind) and
+private predicate isBuiltInIntegralType(@builtintype type, int kind) {
+  isBuiltInArithmeticType(type, kind) and
   (
     kind < 24
     or
@@ -420,10 +456,13 @@ private predicate isIntegralType(@builtintype type, int kind) {
 class IntegralOrEnumType extends Type {
   IntegralOrEnumType() {
     // Integral type
-    isIntegralType(underlyingElement(this), _)
+    isBuiltInIntegralType(underlyingElement(this), _)
     or
     // Enum type
     usertypes(underlyingElement(this), _, [4, 13])
+    or
+    // Bit-precise integer type (`_BitInt`)
+    bit_precise_types(underlyingElement(this), _, _, _)
   }
 }
 
@@ -499,19 +538,54 @@ private predicate integralTypeMapping(int original, int canonical, int unsigned,
  * char c;
  * ```
  */
-class IntegralType extends ArithmeticType, IntegralOrEnumType {
-  int kind;
-
-  IntegralType() { isIntegralType(underlyingElement(this), kind) }
-
+abstract private class IntegralTypeImpl extends ArithmeticTypeImpl, IntegralOrEnumType {
   /** Holds if this integral type is signed. */
-  predicate isSigned() { builtintypes(underlyingElement(this), _, _, _, -1, _) }
+  abstract predicate isSigned();
 
   /** Holds if this integral type is unsigned. */
-  predicate isUnsigned() { builtintypes(underlyingElement(this), _, _, _, 1, _) }
+  abstract predicate isUnsigned();
 
   /** Holds if this integral type is explicitly signed. */
-  predicate isExplicitlySigned() {
+  abstract predicate isExplicitlySigned();
+
+  /** Holds if this integral type is explicitly unsigned. */
+  abstract predicate isExplicitlyUnsigned();
+
+  /** Holds if this integral type is implicitly signed. */
+  abstract predicate isImplicitlySigned();
+
+  /**
+   * Gets the unsigned type corresponding to this integral type.  For
+   * example on a `short`, this would give the type `unsigned short`.
+   */
+  abstract IntegralType getUnsigned();
+
+  /**
+   * Gets the canonical type corresponding to this integral type.
+   *
+   * For a plain type, this gives the same type (e.g. `short` -> `short`).
+   * For an explicitly unsigned type, this gives the same type (e.g. `unsigned short` -> `unsigned short`).
+   * For an explicitly signed type, this gives the plain version of that type (e.g. `signed short` -> `short`), except
+   * that `signed char` -> `signed char`.
+   */
+  abstract IntegralType getCanonicalArithmeticType();
+}
+
+final class IntegralType = IntegralTypeImpl;
+
+/**
+ * A C/C++ integral type that is not a bit-precise integer.
+ */
+class BuiltInIntegralType extends IntegralTypeImpl, BuiltInArithmeticType {
+  int kind;
+
+  BuiltInIntegralType() { isBuiltInIntegralType(underlyingElement(this), kind) }
+
+  override predicate isSigned() { builtintypes(underlyingElement(this), _, _, _, -1, _) }
+
+  override predicate isUnsigned() { builtintypes(underlyingElement(this), _, _, _, 1, _) }
+
+  override predicate isExplicitlySigned() {
     builtintypes(underlyingElement(this), _, 7, _, _, _) or
     builtintypes(underlyingElement(this), _, 10, _, _, _) or
     builtintypes(underlyingElement(this), _, 13, _, _, _) or
@@ -520,8 +594,7 @@ class IntegralType extends ArithmeticType, IntegralOrEnumType {
     builtintypes(underlyingElement(this), _, 37, _, _, _)
   }
 
-  /** Holds if this integral type is explicitly unsigned. */
-  predicate isExplicitlyUnsigned() {
+  override predicate isExplicitlyUnsigned() {
     builtintypes(underlyingElement(this), _, 6, _, _, _) or
     builtintypes(underlyingElement(this), _, 9, _, _, _) or
     builtintypes(underlyingElement(this), _, 12, _, _, _) or
@@ -530,8 +603,7 @@ class IntegralType extends ArithmeticType, IntegralOrEnumType {
     builtintypes(underlyingElement(this), _, 36, _, _, _)
   }
 
-  /** Holds if this integral type is implicitly signed. */
-  predicate isImplicitlySigned() {
+  override predicate isImplicitlySigned() {
     builtintypes(underlyingElement(this), _, 5, _, -1, _) or
     builtintypes(underlyingElement(this), _, 8, _, -1, _) or
     builtintypes(underlyingElement(this), _, 11, _, -1, _) or
@@ -540,33 +612,44 @@ class IntegralType extends ArithmeticType, IntegralOrEnumType {
     builtintypes(underlyingElement(this), _, 35, _, -1, _)
   }
 
-  /**
-   * Gets the unsigned type corresponding to this integral type.  For
-   * example on a `short`, this would give the type `unsigned short`.
-   */
-  IntegralType getUnsigned() {
+  override IntegralType getUnsigned() {
     exists(int unsignedKind |
       integralTypeMapping(kind, _, unsignedKind, _) and
       builtintypes(unresolveElement(result), _, unsignedKind, _, _, _)
     )
   }
 
-  /**
-   * Gets the canonical type corresponding to this integral type.
-   *
-   * For a plain type, this gives the same type (e.g. `short` -> `short`).
-   * For an explicitly unsigned type, this gives the same type (e.g. `unsigned short` -> `unsigned short`).
-   * For an explicitly signed type, this gives the plain version of that type (e.g. `signed short` -> `short`), except
-   * that `signed char` -> `signed char`.
-   */
-  IntegralType getCanonicalArithmeticType() {
+  override IntegralType getCanonicalArithmeticType() {
     exists(int canonicalKind |
       integralTypeMapping(kind, canonicalKind, _, _) and
       builtintypes(unresolveElement(result), _, canonicalKind, _, _, _)
     )
   }
 }
 
+/**
+ * A C23 bit-precise integer (`_BitInt`).
+ */
+class BitPreciseType extends IntegralTypeImpl, BitPreciseArithmeticType {
+  override predicate isSigned() { isSigned = true }
+
+  override predicate isUnsigned() { not this.isSigned() }
+
+  override predicate isExplicitlySigned() { isExplicitlySigned = true }
+
+  override predicate isExplicitlyUnsigned() { this.isUnsigned() }
+
+  override predicate isImplicitlySigned() { not this.isExplicitlySigned() }
+
+  override IntegralType getUnsigned() {
+    bit_precise_types(unresolveElement(result), false, false, bitWidth)
+  }
+
+  override IntegralType getCanonicalArithmeticType() {
+    bit_precise_types(unresolveElement(result), isSigned, false, bitWidth)
+  }
+}
+
 /**
  * The C/C++ boolean type. See 4.2.  This is the C `_Bool` type
  * or the C++ `bool` type.  For example:
@@ -575,7 +658,7 @@ class IntegralType extends ArithmeticType, IntegralOrEnumType {
  * _Bool c, d;         // C
  * ```
  */
-class BoolType extends IntegralType {
+class BoolType extends BuiltInIntegralType {
   BoolType() { builtintypes(underlyingElement(this), _, 4, _, _, _) }
 
   override string getAPrimaryQlClass() { result = "BoolType" }
@@ -591,7 +674,7 @@ class BoolType extends IntegralType {
  * unsigned char e, f;
  * ```
  */
-class CharType extends IntegralType {
+class CharType extends BuiltInIntegralType {
   CharType() { builtintypes(underlyingElement(this), _, [5, 6, 7], _, _, _) }
 }
 
@@ -641,7 +724,7 @@ class SignedCharType extends CharType {
  * signed short ss;
  * ```
  */
-class ShortType extends IntegralType {
+class ShortType extends BuiltInIntegralType {
   ShortType() {
     builtintypes(underlyingElement(this), _, 8, _, _, _) or
     builtintypes(underlyingElement(this), _, 9, _, _, _) or
@@ -658,7 +741,7 @@ class ShortType extends IntegralType {
  * unsigned int ui;
  * ```
  */
-class IntType extends IntegralType {
+class IntType extends BuiltInIntegralType {
   IntType() {
     builtintypes(underlyingElement(this), _, 11, _, _, _) or
     builtintypes(underlyingElement(this), _, 12, _, _, _) or
@@ -675,7 +758,7 @@ class IntType extends IntegralType {
  * long l;
  * ```
  */
-class LongType extends IntegralType {
+class LongType extends BuiltInIntegralType {
   LongType() {
     builtintypes(underlyingElement(this), _, 14, _, _, _) or
     builtintypes(underlyingElement(this), _, 15, _, _, _) or
@@ -692,7 +775,7 @@ class LongType extends IntegralType {
  * signed long long sll;
  * ```
  */
-class LongLongType extends IntegralType {
+class LongLongType extends BuiltInIntegralType {
   LongLongType() {
     builtintypes(underlyingElement(this), _, 17, _, _, _) or
     builtintypes(underlyingElement(this), _, 18, _, _, _) or
@@ -710,7 +793,7 @@ class LongLongType extends IntegralType {
  * unsigned __int128 ui128;
  * ```
  */
-class Int128Type extends IntegralType {
+class Int128Type extends BuiltInIntegralType {
   Int128Type() {
     builtintypes(underlyingElement(this), _, 35, _, _, _) or
     builtintypes(underlyingElement(this), _, 36, _, _, _) or
@@ -865,7 +948,7 @@ private predicate floatingPointTypeMapping(
  * fixed-size floating-point types like `_Float32`, and the extended-precision floating-point types
  * like `_Float64x`. It also includes the complex and imaginary versions of all of these types.
  */
-class FloatingPointType extends ArithmeticType {
+class FloatingPointType extends BuiltInArithmeticType {
   final int base;
   final TypeDomain domain;
   final int realKind;
@@ -1003,7 +1086,7 @@ class VoidType extends BuiltInType {
  * wchar_t wc;
  * ```
  */
-class WideCharType extends IntegralType {
+class WideCharType extends BuiltInIntegralType {
   WideCharType() { builtintypes(underlyingElement(this), _, 33, _, _, _) }
 
   override string getAPrimaryQlClass() { result = "WideCharType" }
@@ -1015,7 +1098,7 @@ class WideCharType extends IntegralType {
  * char8_t c8;
  * ```
  */
-class Char8Type extends IntegralType {
+class Char8Type extends BuiltInIntegralType {
   Char8Type() { builtintypes(underlyingElement(this), _, 51, _, _, _) }
 
   override string getAPrimaryQlClass() { result = "Char8Type" }
@@ -1027,7 +1110,7 @@ class Char8Type extends IntegralType {
  * char16_t c16;
  * ```
  */
-class Char16Type extends IntegralType {
+class Char16Type extends BuiltInIntegralType {
   Char16Type() { builtintypes(underlyingElement(this), _, 43, _, _, _) }
 
   override string getAPrimaryQlClass() { result = "Char16Type" }
@@ -1039,7 +1122,7 @@ class Char16Type extends IntegralType {
  * char32_t c32;
  * ```
  */
-class Char32Type extends IntegralType {
+class Char32Type extends BuiltInIntegralType {
   Char32Type() { builtintypes(underlyingElement(this), _, 44, _, _, _) }
 
   override string getAPrimaryQlClass() { result = "Char32Type" }

cpp/ql/lib/semmle/code/cpp/commons/CommonType.qll

@@ -372,7 +372,7 @@ class Wchar_t extends Type {
  *
  * This class is meaningless if a Microsoft compiler was not used.
  */
-class MicrosoftInt8Type extends IntegralType {
+class MicrosoftInt8Type extends BuiltInIntegralType {
   MicrosoftInt8Type() {
     this instanceof CharType and
     not this.isExplicitlyUnsigned() and
@@ -388,7 +388,7 @@ class MicrosoftInt8Type extends IntegralType {
  *
  * This class is meaningless if a Microsoft compiler was not used.
  */
-class MicrosoftInt16Type extends IntegralType {
+class MicrosoftInt16Type extends BuiltInIntegralType {
   MicrosoftInt16Type() {
     this instanceof ShortType and
     not this.isExplicitlyUnsigned() and
@@ -404,7 +404,7 @@ class MicrosoftInt16Type extends IntegralType {
  *
  * This class is meaningless if a Microsoft compiler was not used.
  */
-class MicrosoftInt32Type extends IntegralType {
+class MicrosoftInt32Type extends BuiltInIntegralType {
   MicrosoftInt32Type() {
     this instanceof IntType and
     not this.isExplicitlyUnsigned() and
@@ -420,7 +420,7 @@ class MicrosoftInt32Type extends IntegralType {
  *
  * This class is meaningless if a Microsoft compiler was not used.
  */
-class MicrosoftInt64Type extends IntegralType {
+class MicrosoftInt64Type extends BuiltInIntegralType {
   MicrosoftInt64Type() {
     this instanceof LongLongType and
     not this.isExplicitlyUnsigned() and