diff --git a/c/misra/src/rules/RULE-7-5/IncorrectlySizedIntegerConstantMacroArgument.ql b/c/misra/src/rules/RULE-7-5/IncorrectlySizedIntegerConstantMacroArgument.ql
new file mode 100644
index 0000000000..87c945d6b6
--- /dev/null
+++ b/c/misra/src/rules/RULE-7-5/IncorrectlySizedIntegerConstantMacroArgument.ql
@@ -0,0 +1,45 @@
+/**
+ * @id c/misra/incorrectly-sized-integer-constant-macro-argument
+ * @name RULE-7-5: The argument of an integer constant macro shall have an appropriate size
+ * @description Integer constant macros argument values should be values of a compatible size.
+ * @kind problem
+ * @precision very-high
+ * @problem.severity error
+ * @tags external/misra/id/rule-7-5
+ *       correctness
+ *       external/misra/c/2012/amendment3
+ *       external/misra/obligation/required
+ */
+
+import cpp
+import codingstandards.c.misra
+import codingstandards.cpp.IntegerConstantMacro
+import codingstandards.cpp.Literals
+
+predicate matchesSign(IntegerConstantMacro macro, PossiblyNegativeLiteral literal) {
+  literal.isNegative() implies macro.isSigned()
+}
+
+predicate matchesSize(IntegerConstantMacro macro, PossiblyNegativeLiteral literal) {
+  literal.getRawValue() <= macro.maxValue() and
+  literal.getRawValue() >= macro.minValue()
+}
+
+from
+  PossiblyNegativeLiteral literal, MacroInvocation invoke, IntegerConstantMacro macro,
+  string explanation
+where
+  not isExcluded(invoke, Types2Package::incorrectlySizedIntegerConstantMacroArgumentQuery()) and
+  invoke.getMacro() = macro and
+  literal = invoke.getExpr() and
+  (
+    not matchesSign(macro, literal) and
+    explanation = " cannot be negative"
+    or
+    matchesSign(macro, literal) and
+    // Wait for BigInt support to check 64 bit macro types.
+    macro.getSize() < 64 and
+    not matchesSize(macro, literal) and
+    explanation = " is outside of the allowed range " + macro.getRangeString()
+  )
+select literal, "Value provided to integer constant macro " + macro.getName() + explanation
diff --git a/c/misra/src/rules/RULE-7-5/IntegerConstantMacroArgumentUsesSuffix.ql b/c/misra/src/rules/RULE-7-5/IntegerConstantMacroArgumentUsesSuffix.ql
new file mode 100644
index 0000000000..84fb1a9872
--- /dev/null
+++ b/c/misra/src/rules/RULE-7-5/IntegerConstantMacroArgumentUsesSuffix.ql
@@ -0,0 +1,35 @@
+/**
+ * @id c/misra/integer-constant-macro-argument-uses-suffix
+ * @name RULE-7-5: The argument of an integer constant macro shall not use literal suffixes u, l, or ul
+ * @description Integer constant macros should be used integer literal values with no u/l suffix.
+ * @kind problem
+ * @precision high
+ * @problem.severity warning
+ * @tags external/misra/id/rule-7-5
+ *       readability
+ *       maintainability
+ *       external/misra/c/2012/amendment3
+ *       external/misra/obligation/required
+ */
+
+import cpp
+import codingstandards.c.misra
+import codingstandards.cpp.IntegerConstantMacro
+import codingstandards.cpp.Literals
+
+string argumentSuffix(MacroInvocation invoke) {
+  // Extractor strips the suffix unless we look at the unexpanded argument text.
+  // Unexpanded argument text can be malformed in all sorts of ways, so make
+  // this match relatively strict, to be safe.
+  result = invoke.getUnexpandedArgument(0).regexpCapture("([0-9]+|0[xX][0-9A-F]+)([uUlL]+)$", 2)
+}
+
+from MacroInvocation invoke, PossiblyNegativeLiteral argument, string suffix
+where
+  not isExcluded(invoke, Types2Package::integerConstantMacroArgumentUsesSuffixQuery()) and
+  invoke.getMacro() instanceof IntegerConstantMacro and
+  invoke.getExpr() = argument and
+  suffix = argumentSuffix(invoke)
+select argument,
+  "Value suffix '" + suffix + "' is not allowed on provided argument to integer constant macro " +
+    invoke.getMacroName() + "."
diff --git a/c/misra/src/rules/RULE-7-5/InvalidIntegerConstantMacroArgument.ql b/c/misra/src/rules/RULE-7-5/InvalidIntegerConstantMacroArgument.ql
new file mode 100644
index 0000000000..4c750e32d8
--- /dev/null
+++ b/c/misra/src/rules/RULE-7-5/InvalidIntegerConstantMacroArgument.ql
@@ -0,0 +1,30 @@
+/**
+ * @id c/misra/invalid-integer-constant-macro-argument
+ * @name RULE-7-5: The argument of an integer constant macro shall be a literal
+ * @description Integer constant macros should be given a literal value as an argument.
+ * @kind problem
+ * @precision very-high
+ * @problem.severity warning
+ * @tags external/misra/id/rule-7-5
+ *       correctness
+ *       external/misra/c/2012/amendment3
+ *       external/misra/obligation/required
+ */
+
+import cpp
+import codingstandards.c.misra
+import codingstandards.cpp.IntegerConstantMacro
+import codingstandards.cpp.Literals
+import semmle.code.cpp.rangeanalysis.SimpleRangeAnalysis
+
+from MacroInvocation invoke, IntegerConstantMacro macro
+where
+  not isExcluded(invoke, Types2Package::invalidIntegerConstantMacroArgumentQuery()) and
+  invoke.getMacro() = macro and
+  (
+    not invoke.getExpr() instanceof PossiblyNegativeLiteral
+    or
+    any(MacroInvocation inner).getParentInvocation() = invoke
+  )
+select invoke.getExpr(),
+  "Argument to integer constant macro " + macro.getName() + " must be an integer literal."
diff --git a/c/misra/src/rules/RULE-7-5/InvalidLiteralForIntegerConstantMacroArgument.ql b/c/misra/src/rules/RULE-7-5/InvalidLiteralForIntegerConstantMacroArgument.ql
new file mode 100644
index 0000000000..e4e660c628
--- /dev/null
+++ b/c/misra/src/rules/RULE-7-5/InvalidLiteralForIntegerConstantMacroArgument.ql
@@ -0,0 +1,77 @@
+/**
+ * @id c/misra/invalid-literal-for-integer-constant-macro-argument
+ * @name RULE-7-5: The argument of an integer constant macro shall be a decimal, hex, or octal literal
+ * @description Integer constant macro arguments should be a decimal, hex, or octal literal.
+ * @kind problem
+ * @precision very-high
+ * @problem.severity error
+ * @tags external/misra/id/rule-7-5
+ *       correctness
+ *       external/misra/c/2012/amendment3
+ *       external/misra/obligation/required
+ */
+
+import cpp
+import codingstandards.c.misra
+import codingstandards.cpp.IntegerConstantMacro
+import codingstandards.cpp.Literals
+
+/**
+ * Floating point literals are not allowed. Neither are char or string
+ * literals, although those are not `NumericLiteral`s and therefore detected in
+ * `InvalidIntegerConstantMacroArgument.ql`.
+ */
+predicate validLiteralType(PossiblyNegativeLiteral literal) {
+  literal.getBaseLiteral() instanceof Cpp14Literal::DecimalLiteral or
+  literal.getBaseLiteral() instanceof Cpp14Literal::OctalLiteral or
+  literal.getBaseLiteral() instanceof Cpp14Literal::HexLiteral or
+  // Ignore cases where the AST/extractor don't give us enough information:
+  literal.getBaseLiteral() instanceof Cpp14Literal::UnrecognizedNumericLiteral
+}
+
+/**
+ * Clang accepts `xINTsize_C(0b01)`, and expands the argument into a decimal
+ * literal. Binary literals are not standard c nor are they allowed by rule 7-5.
+ * Detect this pattern before macro expansion.
+ */
+predicate seemsBinaryLiteral(MacroInvocation invoke) {
+  invoke.getUnexpandedArgument(0).regexpMatch("-?0[bB][01]+")
+}
+
+/**
+ * Extractor converts `xINTsize_C('a')` to a decimal literal. Therefore, detect
+ * this pattern before macro expansion.
+ */
+predicate seemsCharLiteral(MacroInvocation invoke) {
+  invoke.getUnexpandedArgument(0).regexpMatch("-?'\\\\?.'")
+}
+
+string explainIncorrectArgument(MacroInvocation invoke) {
+  if seemsBinaryLiteral(invoke)
+  then result = "binary literal"
+  else
+    if seemsCharLiteral(invoke)
+    then result = "char literal"
+    else
+      exists(PossiblyNegativeLiteral literal |
+        literal = invoke.getExpr() and
+        if literal.getBaseLiteral() instanceof Cpp14Literal::FloatingLiteral
+        then result = "floating point literal"
+        else result = "invalid literal"
+      )
+}
+
+from MacroInvocation invoke, PossiblyNegativeLiteral literal
+where
+  not isExcluded(invoke, Types2Package::invalidLiteralForIntegerConstantMacroArgumentQuery()) and
+  invoke.getMacro() instanceof IntegerConstantMacro and
+  literal = invoke.getExpr() and
+  (
+    not validLiteralType(literal) or
+    seemsBinaryLiteral(invoke) or
+    seemsCharLiteral(invoke)
+  )
+select literal,
+  "Integer constant macro " + invoke.getMacroName() + " used with " +
+    explainIncorrectArgument(invoke) +
+    " argument, only decimal, octal, or hex integer literal allowed."
diff --git a/c/misra/src/rules/RULE-7-6/UseOfBannedSmallIntegerConstantMacro.ql b/c/misra/src/rules/RULE-7-6/UseOfBannedSmallIntegerConstantMacro.ql
new file mode 100644
index 0000000000..47e88196d5
--- /dev/null
+++ b/c/misra/src/rules/RULE-7-6/UseOfBannedSmallIntegerConstantMacro.ql
@@ -0,0 +1,24 @@
+/**
+ * @id c/misra/use-of-banned-small-integer-constant-macro
+ * @name RULE-7-6: The small integer variants of the minimum-width integer constant macros shall not be used
+ * @description Small integer constant macros expression are promoted to type int, which can lead to
+ *              unexpected results.
+ * @kind problem
+ * @precision very-high
+ * @problem.severity warning
+ * @tags external/misra/id/rule-7-6
+ *       readability
+ *       external/misra/c/2012/amendment3
+ *       external/misra/obligation/required
+ */
+
+import cpp
+import codingstandards.c.misra
+import codingstandards.cpp.IntegerConstantMacro
+
+from MacroInvocation macroInvoke, IntegerConstantMacro macro
+where
+  not isExcluded(macroInvoke, Types2Package::useOfBannedSmallIntegerConstantMacroQuery()) and
+  macroInvoke.getMacro() = macro and
+  macro.isSmall()
+select macroInvoke, "Usage of small integer constant macro " + macro.getName() + " is not allowed."
diff --git a/c/misra/test/rules/RULE-7-5/IncorrectlySizedIntegerConstantMacroArgument.expected b/c/misra/test/rules/RULE-7-5/IncorrectlySizedIntegerConstantMacroArgument.expected
new file mode 100644
index 0000000000..d3724e21a4
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-5/IncorrectlySizedIntegerConstantMacroArgument.expected
@@ -0,0 +1,31 @@
+| test.c:17:13:17:16 | - ... | Value provided to integer constant macro UINT8_C cannot be negative |
+| test.c:19:13:19:18 | - ... | Value provided to integer constant macro UINT8_C cannot be negative |
+| test.c:21:13:21:16 | - ... | Value provided to integer constant macro UINT8_C cannot be negative |
+| test.c:37:13:37:15 | 256 | Value provided to integer constant macro UINT8_C is outside of the allowed range 0..255 |
+| test.c:38:13:38:16 | 256 | Value provided to integer constant macro UINT8_C is outside of the allowed range 0..255 |
+| test.c:39:13:39:17 | 256 | Value provided to integer constant macro UINT8_C is outside of the allowed range 0..255 |
+| test.c:42:13:42:14 | - ... | Value provided to integer constant macro UINT8_C cannot be negative |
+| test.c:43:13:43:15 | - ... | Value provided to integer constant macro UINT8_C cannot be negative |
+| test.c:44:13:44:15 | - ... | Value provided to integer constant macro UINT8_C cannot be negative |
+| test.c:45:13:45:17 | - ... | Value provided to integer constant macro UINT8_C cannot be negative |
+| test.c:70:12:70:14 | 128 | Value provided to integer constant macro INT8_C is outside of the allowed range -128..127 |
+| test.c:71:12:71:15 | 128 | Value provided to integer constant macro INT8_C is outside of the allowed range -128..127 |
+| test.c:72:12:72:15 | 128 | Value provided to integer constant macro INT8_C is outside of the allowed range -128..127 |
+| test.c:76:12:76:15 | - ... | Value provided to integer constant macro INT8_C is outside of the allowed range -128..127 |
+| test.c:77:12:77:16 | - ... | Value provided to integer constant macro INT8_C is outside of the allowed range -128..127 |
+| test.c:78:12:78:16 | - ... | Value provided to integer constant macro INT8_C is outside of the allowed range -128..127 |
+| test.c:91:14:91:18 | 65536 | Value provided to integer constant macro UINT16_C is outside of the allowed range 0..65535 |
+| test.c:92:14:92:20 | 65536 | Value provided to integer constant macro UINT16_C is outside of the allowed range 0..65535 |
+| test.c:93:14:93:20 | 65536 | Value provided to integer constant macro UINT16_C is outside of the allowed range 0..65535 |
+| test.c:106:13:106:17 | 32768 | Value provided to integer constant macro INT16_C is outside of the allowed range -32768..32767 |
+| test.c:107:13:107:19 | 32768 | Value provided to integer constant macro INT16_C is outside of the allowed range -32768..32767 |
+| test.c:108:13:108:18 | 32768 | Value provided to integer constant macro INT16_C is outside of the allowed range -32768..32767 |
+| test.c:112:13:112:18 | - ... | Value provided to integer constant macro INT16_C is outside of the allowed range -32768..32767 |
+| test.c:113:13:113:20 | - ... | Value provided to integer constant macro INT16_C is outside of the allowed range -32768..32767 |
+| test.c:114:13:114:19 | - ... | Value provided to integer constant macro INT16_C is outside of the allowed range -32768..32767 |
+| test.c:124:14:124:24 | 4294967296 | Value provided to integer constant macro UINT32_C is outside of the allowed range 0..4294967295 |
+| test.c:125:14:125:25 | 4294967296 | Value provided to integer constant macro UINT32_C is outside of the allowed range 0..4294967295 |
+| test.c:135:13:135:22 | 2147483648 | Value provided to integer constant macro INT32_C is outside of the allowed range -2147483648..2147483647 |
+| test.c:136:13:136:22 | 2147483648 | Value provided to integer constant macro INT32_C is outside of the allowed range -2147483648..2147483647 |
+| test.c:139:13:139:23 | - ... | Value provided to integer constant macro INT32_C is outside of the allowed range -2147483648..2147483647 |
+| test.c:140:13:140:23 | - ... | Value provided to integer constant macro INT32_C is outside of the allowed range -2147483648..2147483647 |
diff --git a/c/misra/test/rules/RULE-7-5/IncorrectlySizedIntegerConstantMacroArgument.qlref b/c/misra/test/rules/RULE-7-5/IncorrectlySizedIntegerConstantMacroArgument.qlref
new file mode 100644
index 0000000000..ca6959acec
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-5/IncorrectlySizedIntegerConstantMacroArgument.qlref
@@ -0,0 +1 @@
+rules/RULE-7-5/IncorrectlySizedIntegerConstantMacroArgument.ql
\ No newline at end of file
diff --git a/c/misra/test/rules/RULE-7-5/IntegerConstantMacroArgumentUsesSuffix.expected b/c/misra/test/rules/RULE-7-5/IntegerConstantMacroArgumentUsesSuffix.expected
new file mode 100644
index 0000000000..97a35dd977
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-5/IntegerConstantMacroArgumentUsesSuffix.expected
@@ -0,0 +1,7 @@
+| test.c:25:13:25:14 | 1 | Value suffix 'u' is not allowed on provided argument to integer constant macro UINT8_C. |
+| test.c:26:13:26:14 | 2 | Value suffix 'U' is not allowed on provided argument to integer constant macro UINT8_C. |
+| test.c:27:13:27:14 | 3 | Value suffix 'l' is not allowed on provided argument to integer constant macro UINT8_C. |
+| test.c:28:13:28:14 | 4 | Value suffix 'L' is not allowed on provided argument to integer constant macro UINT8_C. |
+| test.c:29:13:29:15 | 5 | Value suffix 'ul' is not allowed on provided argument to integer constant macro UINT8_C. |
+| test.c:30:13:30:15 | 5 | Value suffix 'll' is not allowed on provided argument to integer constant macro UINT8_C. |
+| test.c:31:13:31:16 | 5 | Value suffix 'ull' is not allowed on provided argument to integer constant macro UINT8_C. |
diff --git a/c/misra/test/rules/RULE-7-5/IntegerConstantMacroArgumentUsesSuffix.qlref b/c/misra/test/rules/RULE-7-5/IntegerConstantMacroArgumentUsesSuffix.qlref
new file mode 100644
index 0000000000..afadb6e34b
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-5/IntegerConstantMacroArgumentUsesSuffix.qlref
@@ -0,0 +1 @@
+rules/RULE-7-5/IntegerConstantMacroArgumentUsesSuffix.ql
\ No newline at end of file
diff --git a/c/misra/test/rules/RULE-7-5/InvalidIntegerConstantMacroArgument.expected b/c/misra/test/rules/RULE-7-5/InvalidIntegerConstantMacroArgument.expected
new file mode 100644
index 0000000000..b29228b6df
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-5/InvalidIntegerConstantMacroArgument.expected
@@ -0,0 +1,8 @@
+| test.c:48:13:48:17 | ... + ... | Argument to integer constant macro UINT8_C must be an integer literal. |
+| test.c:49:13:49:18 | access to array | Argument to integer constant macro UINT8_C must be an integer literal. |
+| test.c:50:13:50:19 | access to array | Argument to integer constant macro UINT8_C must be an integer literal. |
+| test.c:51:5:51:22 | 255 | Argument to integer constant macro UINT8_C must be an integer literal. |
+| test.c:52:5:52:17 | 1 | Argument to integer constant macro UINT8_C must be an integer literal. |
+| test.c:53:5:53:18 | 0 | Argument to integer constant macro UINT8_C must be an integer literal. |
+| test.c:54:5:54:17 | 0 | Argument to integer constant macro UINT8_C must be an integer literal. |
+| test.c:55:5:55:20 | 0 | Argument to integer constant macro UINT8_C must be an integer literal. |
diff --git a/c/misra/test/rules/RULE-7-5/InvalidIntegerConstantMacroArgument.qlref b/c/misra/test/rules/RULE-7-5/InvalidIntegerConstantMacroArgument.qlref
new file mode 100644
index 0000000000..802f415bc9
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-5/InvalidIntegerConstantMacroArgument.qlref
@@ -0,0 +1 @@
+rules/RULE-7-5/InvalidIntegerConstantMacroArgument.ql
\ No newline at end of file
diff --git a/c/misra/test/rules/RULE-7-5/InvalidLiteralForIntegerConstantMacroArgument.expected b/c/misra/test/rules/RULE-7-5/InvalidLiteralForIntegerConstantMacroArgument.expected
new file mode 100644
index 0000000000..ee5b75cb91
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-5/InvalidLiteralForIntegerConstantMacroArgument.expected
@@ -0,0 +1,7 @@
+| test.c:16:13:16:15 | 1.0 | Integer constant macro UINT8_C used with floating point literal argument, only decimal, octal, or hex integer literal allowed. |
+| test.c:17:13:17:16 | - ... | Integer constant macro UINT8_C used with floating point literal argument, only decimal, octal, or hex integer literal allowed. |
+| test.c:18:13:18:17 | 7 | Integer constant macro UINT8_C used with binary literal argument, only decimal, octal, or hex integer literal allowed. |
+| test.c:19:13:19:18 | - ... | Integer constant macro UINT8_C used with binary literal argument, only decimal, octal, or hex integer literal allowed. |
+| test.c:20:13:20:15 | 97 | Integer constant macro UINT8_C used with char literal argument, only decimal, octal, or hex integer literal allowed. |
+| test.c:21:13:21:16 | - ... | Integer constant macro UINT8_C used with char literal argument, only decimal, octal, or hex integer literal allowed. |
+| test.c:22:13:22:16 | 10 | Integer constant macro UINT8_C used with char literal argument, only decimal, octal, or hex integer literal allowed. |
diff --git a/c/misra/test/rules/RULE-7-5/InvalidLiteralForIntegerConstantMacroArgument.qlref b/c/misra/test/rules/RULE-7-5/InvalidLiteralForIntegerConstantMacroArgument.qlref
new file mode 100644
index 0000000000..5584fe8d46
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-5/InvalidLiteralForIntegerConstantMacroArgument.qlref
@@ -0,0 +1 @@
+rules/RULE-7-5/InvalidLiteralForIntegerConstantMacroArgument.ql
\ No newline at end of file
diff --git a/c/misra/test/rules/RULE-7-5/test.c b/c/misra/test/rules/RULE-7-5/test.c
new file mode 100644
index 0000000000..a3fb4b60e4
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-5/test.c
@@ -0,0 +1,179 @@
+#include "stdbool.h"
+#include "stdint.h"
+
+#define NULL 0
+#define NULLPTR ((void *)NULL)
+
+uint_least8_t g1[] = {
+    // Basic valid
+    UINT8_C(0),    // COMPLIANT
+    UINT8_C(1),    // COMPLIANT
+    UINT8_C(8),    // COMPLIANT
+    UINT8_C(0x23), // COMPLIANT
+    UINT8_C(034),  // COMPLIANT
+
+    // Incorrect literal types
+    UINT8_C(1.0),    // NON-COMPLIANT
+    UINT8_C(-1.0),   // NON-COMPLIANT
+    UINT8_C(0b111),  // NON-COMPLIANT
+    UINT8_C(-0b111), // NON-COMPLIANT
+    UINT8_C('a'),    // NON-COMPLIANT
+    UINT8_C(-'$'),   // NON-COMPLIANT
+    UINT8_C('\n'),   // NON-COMPLIANT
+
+    // Suffixes disallowed
+    UINT8_C(1u),   // NON-COMPLIANT
+    UINT8_C(2U),   // NON-COMPLIANT
+    UINT8_C(3l),   // NON-COMPLIANT
+    UINT8_C(4L),   // NON-COMPLIANT
+    UINT8_C(5ul),  // NON-COMPLIANT
+    UINT8_C(5ll),  // NON-COMPLIANT
+    UINT8_C(5ull), // NON-COMPLIANT
+
+    // Range tests
+    UINT8_C(255),   // COMPLIANT
+    UINT8_C(0xFF),  // COMPLIANT
+    UINT8_C(0377),  // COMPLIANT
+    UINT8_C(256),   // NON-COMPLIANT
+    UINT8_C(0400),  // NON-COMPLIANT
+    UINT8_C(0x100), // NON-COMPLIANT
+
+    // Signage tests
+    UINT8_C(-1),    // NON-COMPLIANT
+    UINT8_C(-20),   // NON-COMPLIANT
+    UINT8_C(-33),   // NON-COMPLIANT
+    UINT8_C(-0x44), // NON-COMPLIANT
+
+    // Invalid nonliteral expressions
+    UINT8_C(0 + 0),     // NON-COMPLIANT
+    UINT8_C("a"[0]),    // NON-COMPLIANT
+    UINT8_C(0 ["a"]),   // NON-COMPLIANT
+    UINT8_C(UINT8_MAX), // NON-COMPLIANT
+    UINT8_C(true),      // NON-COMPLIANT
+    UINT8_C(false),     // NON-COMPLIANT
+    UINT8_C(NULL),      // NON-COMPLIANT
+    UINT8_C(NULLPTR),   // NON-COMPLIANT
+};
+
+int_least8_t g2[] = {
+    // Basic valid
+    INT8_C(0),    // COMPLIANT
+    INT8_C(1),    // COMPLIANT
+    INT8_C(8),    // COMPLIANT
+    INT8_C(0x23), // COMPLIANT
+    INT8_C(034),  // COMPLIANT
+
+    // Range tests
+    INT8_C(127),   // COMPLIANT
+    INT8_C(0x79),  // COMPLIANT
+    INT8_C(0177),  // COMPLIANT
+    INT8_C(128),   // NON-COMPLIANT
+    INT8_C(0200),  // NON-COMPLIANT
+    INT8_C(0x80),  // NON-COMPLIANT
+    INT8_C(-128),  // COMPLIANT
+    INT8_C(-0x80), // COMPLIANT
+    INT8_C(-0200), // COMPLIANT
+    INT8_C(-129),  // NON-COMPLIANT
+    INT8_C(-0201), // NON-COMPLIANT
+    INT8_C(-0x81), // NON-COMPLIANT
+};
+
+uint_least16_t g3[] = {
+    // Basic valid
+    UINT16_C(0),    // COMPLIANT
+    UINT16_C(0x23), // COMPLIANT
+    UINT16_C(034),  // COMPLIANT
+
+    // Range tests
+    UINT16_C(65535),   // COMPLIANT
+    UINT16_C(0xFFFF),  // COMPLIANT
+    UINT16_C(0177777), // COMPLIANT
+    UINT16_C(65536),   // NON-COMPLIANT
+    UINT16_C(0200000), // NON-COMPLIANT
+    UINT16_C(0x10000), // NON-COMPLIANT
+};
+
+int_least16_t g4[] = {
+    // Basic valid
+    INT16_C(0),    // COMPLIANT
+    INT16_C(0x23), // COMPLIANT
+    INT16_C(034),  // COMPLIANT
+
+    // Range tests
+    INT16_C(32767),    // COMPLIANT
+    INT16_C(0x7FFF),   // COMPLIANT
+    INT16_C(077777),   // COMPLIANT
+    INT16_C(32768),    // NON-COMPLIANT
+    INT16_C(0100000),  // NON-COMPLIANT
+    INT16_C(0x8000),   // NON-COMPLIANT
+    INT16_C(-32768),   // COMPLIANT
+    INT16_C(-0100000), // COMPLIANT
+    INT16_C(-0x8000),  // COMPLIANT
+    INT16_C(-32769),   // NON-COMPLIANT
+    INT16_C(-0100001), // NON-COMPLIANT
+    INT16_C(-0x8001),  // NON-COMPLIANT
+};
+
+uint_least32_t g5[] = {
+    // Basic valid
+    UINT32_C(0), // COMPLIANT
+
+    // Range tests
+    UINT32_C(4294967295),  // COMPLIANT
+    UINT32_C(0xFFFFFFFF),  // COMPLIANT
+    UINT32_C(4294967296),  // NON-COMPLIANT
+    UINT32_C(0x100000000), // NON-COMPLIANT
+};
+
+int_least32_t g6[] = {
+    // Basic valid
+    INT32_C(0), // COMPLIANT
+
+    // Range tests
+    INT32_C(2147483647),  // COMPLIANT
+    INT32_C(0x7FFFFFFF),  // COMPLIANT
+    INT32_C(2147483648),  // NON-COMPLIANT
+    INT32_C(0x80000000),  // NON-COMPLIANT
+    INT32_C(-2147483648), // COMPLIANT
+    INT32_C(-0x80000000), // COMPLIANT
+    INT32_C(-2147483649), // NON-COMPLIANT
+    INT32_C(-0x80000001), // NON-COMPLIANT
+};
+
+uint_least64_t g7[] = {
+    // Basic valid
+    UINT64_C(0), // COMPLIANT
+
+    // Range tests
+    UINT64_C(18446744073709551615), // COMPLIANT
+    UINT64_C(0xFFFFFFFFFFFFFFFF),   // COMPLIANT
+    // Compile time error if we try to create integer literals beyond this.
+};
+
+int_least64_t g8[] = {
+    // Basic valid
+    INT64_C(0), // COMPLIANT
+
+    // Range tests
+    INT64_C(9223372036854775807), // COMPLIANT
+    // INT64_C(9223372036854775808) is a compile-time error
+
+    INT64_C(-9223372036854775807), // COMPLIANT
+    // -9223372036854775808 is correctly sized, but not a valid decimal literal
+    // value.
+    // -9223372036854775809 is not correctly sized, and not a valid decimal
+    // literal value.
+
+    INT64_C(0x7FFFFFFFFFFFFFFF),  // COMPLIANT
+    INT64_C(0x8000000000000000),  // NON-COMPLIANT[FALSE NEGATIVE]
+    INT64_C(-0x8000000000000000), // COMPLIANT
+    INT64_C(-0x8000000000000001), // NON-COMPLIANT[FALSE NEGATIVE]
+    INT64_C(-0x8001000000000000), // NON-COMPLIANT[FALSE NEGATIVE]
+};
+
+// Other edge cases:
+void f(void) {
+  uint32_t l1 = 1;
+  // `UnrecognizedNumericLiteral` case:
+  int64_t l2 = ((int32_t)UINT64_C(0x1b2) * (l1)); // COMPLIANT
+}
\ No newline at end of file
diff --git a/c/misra/test/rules/RULE-7-6/UseOfBannedSmallIntegerConstantMacro.expected b/c/misra/test/rules/RULE-7-6/UseOfBannedSmallIntegerConstantMacro.expected
new file mode 100644
index 0000000000..ddf517ed9e
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-6/UseOfBannedSmallIntegerConstantMacro.expected
@@ -0,0 +1,4 @@
+| test.c:3:13:3:24 | INT8_C(c) | Usage of small integer constant macro INT8_C is not allowed. |
+| test.c:4:14:4:26 | UINT8_C(c) | Usage of small integer constant macro UINT8_C is not allowed. |
+| test.c:5:14:5:28 | INT16_C(c) | Usage of small integer constant macro INT16_C is not allowed. |
+| test.c:6:15:6:30 | UINT16_C(c) | Usage of small integer constant macro UINT16_C is not allowed. |
diff --git a/c/misra/test/rules/RULE-7-6/UseOfBannedSmallIntegerConstantMacro.qlref b/c/misra/test/rules/RULE-7-6/UseOfBannedSmallIntegerConstantMacro.qlref
new file mode 100644
index 0000000000..e41e2912d8
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-6/UseOfBannedSmallIntegerConstantMacro.qlref
@@ -0,0 +1 @@
+rules/RULE-7-6/UseOfBannedSmallIntegerConstantMacro.ql
\ No newline at end of file
diff --git a/c/misra/test/rules/RULE-7-6/test.c b/c/misra/test/rules/RULE-7-6/test.c
new file mode 100644
index 0000000000..9832cdf251
--- /dev/null
+++ b/c/misra/test/rules/RULE-7-6/test.c
@@ -0,0 +1,10 @@
+#include "stdint.h"
+
+int8_t g1 = INT8_C(0x12);       // NON-COMPLIANT
+uint8_t g2 = UINT8_C(0x12);     // NON-COMPLIANT
+int16_t g3 = INT16_C(0x1234);   // NON-COMPLIANT
+uint16_t g4 = UINT16_C(0x1234); // NON-COMPLIANT
+int32_t g5 = INT32_C(0x1234);   // COMPLIANT
+uint32_t g6 = UINT32_C(0x1234); // COMPLIANT
+int64_t g7 = INT64_C(0x1234);   // COMPLIANT
+uint64_t g8 = UINT64_C(0x1234); // COMPLIANT
\ No newline at end of file
diff --git a/cpp/common/src/codingstandards/cpp/Cpp14Literal.qll b/cpp/common/src/codingstandards/cpp/Cpp14Literal.qll
index c974ec7eb8..ca3a7fb251 100644
--- a/cpp/common/src/codingstandards/cpp/Cpp14Literal.qll
+++ b/cpp/common/src/codingstandards/cpp/Cpp14Literal.qll
@@ -9,6 +9,9 @@ module Cpp14Literal {
   /** An numeric literal. */
   abstract class NumericLiteral extends StandardLibrary::Literal { }
 
+  /** Convenience for implementing class `UnrecognizedNumericLiteral` */
+  abstract private class RecognizedNumericLiteral extends StandardLibrary::Literal { }
+
   /** An integer literal. */
   abstract class IntegerLiteral extends NumericLiteral {
     predicate isSigned() { not isUnsigned() }
@@ -23,7 +26,7 @@ module Cpp14Literal {
    * ```
    * Octal literals must always start with the digit `0`.
    */
-  class OctalLiteral extends IntegerLiteral {
+  class OctalLiteral extends IntegerLiteral, RecognizedNumericLiteral {
     OctalLiteral() { getValueText().regexpMatch("\\s*0[0-7']*[uUlL]*\\s*") }
 
     override string getAPrimaryQlClass() { result = "OctalLiteral" }
@@ -35,7 +38,7 @@ module Cpp14Literal {
    * unsigned int32_t minus2 = 0xfffffffe;
    * ```
    */
-  class HexLiteral extends IntegerLiteral {
+  class HexLiteral extends IntegerLiteral, RecognizedNumericLiteral {
     HexLiteral() { getValueText().regexpMatch("\\s*0[xX][0-9a-fA-F']+[uUlL]*\\s*") }
 
     override string getAPrimaryQlClass() { result = "HexLiteral" }
@@ -47,7 +50,7 @@ module Cpp14Literal {
    * unsigned int32_t binary = 0b101010;
    * ```
    */
-  class BinaryLiteral extends IntegerLiteral {
+  class BinaryLiteral extends IntegerLiteral, RecognizedNumericLiteral {
     BinaryLiteral() { getValueText().regexpMatch("\\s*0[bB][0-1']*[uUlL]*\\s*") }
 
     override string getAPrimaryQlClass() { result = "BinaryLiteral" }
@@ -59,7 +62,7 @@ module Cpp14Literal {
    * unsigned int32_t decimal = 10340923;
    * ```
    */
-  class DecimalLiteral extends IntegerLiteral {
+  class DecimalLiteral extends IntegerLiteral, RecognizedNumericLiteral {
     DecimalLiteral() { getValueText().regexpMatch("\\s*[1-9][0-9']*[uUlL]*\\s*") }
 
     override string getAPrimaryQlClass() { result = "DecimalLiteral" }
@@ -71,7 +74,7 @@ module Cpp14Literal {
    * double floating = 1.340923e-19;
    * ```
    */
-  class FloatingLiteral extends NumericLiteral {
+  class FloatingLiteral extends NumericLiteral, RecognizedNumericLiteral {
     FloatingLiteral() {
       getValueText().regexpMatch("\\s*[0-9][0-9']*(\\.[0-9']+)?([eE][\\+\\-]?[0-9']+)?[flFL]?\\s*") and
       // A decimal literal takes precedent
@@ -83,6 +86,21 @@ module Cpp14Literal {
     override string getAPrimaryQlClass() { result = "FloatingLiteral" }
   }
 
+  /**
+   * Literal values with conversions and macros cannot always be trivially
+   * parsed from `Literal.getValueText()`, and have loss of required
+   * information in `Literal.getValue()`. This class covers cases that appear
+   * to be `NumericLiteral`s but cannot be determined to be a hex, decimal,
+   * octal, binary, or float literal, but still are parsed as a Literal with a
+   * number value.
+   */
+  class UnrecognizedNumericLiteral extends NumericLiteral {
+    UnrecognizedNumericLiteral() {
+      this.getValue().regexpMatch("[0-9.e]+") and
+      not this instanceof RecognizedNumericLiteral
+    }
+  }
+
   /**
    * A character literal.  For example:
    * ```
diff --git a/cpp/common/src/codingstandards/cpp/IntegerConstantMacro.qll b/cpp/common/src/codingstandards/cpp/IntegerConstantMacro.qll
new file mode 100644
index 0000000000..ce72033ecc
--- /dev/null
+++ b/cpp/common/src/codingstandards/cpp/IntegerConstantMacro.qll
@@ -0,0 +1,37 @@
+import cpp
+
+/**
+ * The family of macros `xINTsize_C(arg)` (e.g. `UINT16_C(123)`) which are used
+ * to create an integer constant of type `Xint_leastSIZE_t` (e.g.
+ * `uint_least16_t).
+ */
+class IntegerConstantMacro extends Macro {
+  boolean signed;
+  int size;
+
+  IntegerConstantMacro() {
+    signed = true and size = getName().regexpCapture("INT(8|16|32|64)_C", 1).toInt()
+    or
+    signed = false and size = getName().regexpCapture("UINT(8|16|32|64)_C", 1).toInt()
+  }
+
+  predicate isSmall() { size < any(IntType it | it.isSigned()).getSize() * 8 }
+
+  int getSize() { result = size }
+
+  predicate isSigned() { signed = true }
+
+  float maxValue() {
+    signed = true and result = 2.pow(size - 1 * 1.0) - 1
+    or
+    signed = false and result = 2.pow(size) - 1
+  }
+
+  float minValue() {
+    signed = true and result = -2.pow(size - 1)
+    or
+    signed = false and result = 0
+  }
+
+  string getRangeString() { result = minValue().toString() + ".." + maxValue().toString() }
+}
diff --git a/cpp/common/src/codingstandards/cpp/Literals.qll b/cpp/common/src/codingstandards/cpp/Literals.qll
index 66e15b28dc..edec04152e 100644
--- a/cpp/common/src/codingstandards/cpp/Literals.qll
+++ b/cpp/common/src/codingstandards/cpp/Literals.qll
@@ -70,3 +70,46 @@ class BoolLiteral extends Literal {
     this.getValue() = "0" and this.getValueText() = "false"
   }
 }
+
+/**
+ * Abstract case to handle positive and negative "literal" expressions.
+ *
+ * All numeric literals in c/cpp are positive. To create a negative constant
+ * value in a program means applying the unary- operator to a positive literal.
+ * This class effectively describes positive or negative literals.
+ */
+abstract class PossiblyNegativeLiteral extends Expr {
+  /* The syntactic literal, stripped of potential negation */
+  abstract Cpp14Literal::NumericLiteral getBaseLiteral();
+
+  /* The value as a literal reads, without potential underflows from negation */
+  abstract float getRawValue();
+
+  predicate isNegative() { this instanceof NegativeLiteral }
+}
+
+/**
+ * A negation of a positive literal, creating what can be thought of as a
+ * "negative literal."
+ */
+class NegativeLiteral extends PossiblyNegativeLiteral, UnaryMinusExpr {
+  Cpp14Literal::NumericLiteral literal;
+
+  NegativeLiteral() { literal = getOperand() }
+
+  override Cpp14Literal::NumericLiteral getBaseLiteral() { result = literal }
+
+  override float getRawValue() { result = -literal.getValue().toFloat() }
+}
+
+/**
+ * A literal which is not immediately negated by a parent unary- expression,
+ * which can be thought of as a "positive literal."
+ */
+class PositiveLiteral extends PossiblyNegativeLiteral, Cpp14Literal::NumericLiteral {
+  PositiveLiteral() { not exists(UnaryMinusExpr l | l.getOperand() = this) }
+
+  override Cpp14Literal::NumericLiteral getBaseLiteral() { result = this }
+
+  override float getRawValue() { result = getValue().toFloat() }
+}
diff --git a/cpp/common/src/codingstandards/cpp/exclusions/c/RuleMetadata.qll b/cpp/common/src/codingstandards/cpp/exclusions/c/RuleMetadata.qll
index b10fbf0a2f..e4b7c88563 100644
--- a/cpp/common/src/codingstandards/cpp/exclusions/c/RuleMetadata.qll
+++ b/cpp/common/src/codingstandards/cpp/exclusions/c/RuleMetadata.qll
@@ -72,6 +72,7 @@ import Strings2
 import Strings3
 import Syntax
 import Types1
+import Types2
 
 /** The TQuery type representing this language * */
 newtype TCQuery =
@@ -144,7 +145,8 @@ newtype TCQuery =
   TStrings2PackageQuery(Strings2Query q) or
   TStrings3PackageQuery(Strings3Query q) or
   TSyntaxPackageQuery(SyntaxQuery q) or
-  TTypes1PackageQuery(Types1Query q)
+  TTypes1PackageQuery(Types1Query q) or
+  TTypes2PackageQuery(Types2Query q)
 
 /** The metadata predicate * */
 predicate isQueryMetadata(Query query, string queryId, string ruleId, string category) {
@@ -217,5 +219,6 @@ predicate isQueryMetadata(Query query, string queryId, string ruleId, string cat
   isStrings2QueryMetadata(query, queryId, ruleId, category) or
   isStrings3QueryMetadata(query, queryId, ruleId, category) or
   isSyntaxQueryMetadata(query, queryId, ruleId, category) or
-  isTypes1QueryMetadata(query, queryId, ruleId, category)
+  isTypes1QueryMetadata(query, queryId, ruleId, category) or
+  isTypes2QueryMetadata(query, queryId, ruleId, category)
 }
diff --git a/cpp/common/src/codingstandards/cpp/exclusions/c/Types2.qll b/cpp/common/src/codingstandards/cpp/exclusions/c/Types2.qll
new file mode 100644
index 0000000000..3b2d3a4342
--- /dev/null
+++ b/cpp/common/src/codingstandards/cpp/exclusions/c/Types2.qll
@@ -0,0 +1,95 @@
+//** THIS FILE IS AUTOGENERATED, DO NOT MODIFY DIRECTLY.  **/
+import cpp
+import RuleMetadata
+import codingstandards.cpp.exclusions.RuleMetadata
+
+newtype Types2Query =
+  TInvalidIntegerConstantMacroArgumentQuery() or
+  TInvalidLiteralForIntegerConstantMacroArgumentQuery() or
+  TIntegerConstantMacroArgumentUsesSuffixQuery() or
+  TIncorrectlySizedIntegerConstantMacroArgumentQuery() or
+  TUseOfBannedSmallIntegerConstantMacroQuery()
+
+predicate isTypes2QueryMetadata(Query query, string queryId, string ruleId, string category) {
+  query =
+    // `Query` instance for the `invalidIntegerConstantMacroArgument` query
+    Types2Package::invalidIntegerConstantMacroArgumentQuery() and
+  queryId =
+    // `@id` for the `invalidIntegerConstantMacroArgument` query
+    "c/misra/invalid-integer-constant-macro-argument" and
+  ruleId = "RULE-7-5" and
+  category = "required"
+  or
+  query =
+    // `Query` instance for the `invalidLiteralForIntegerConstantMacroArgument` query
+    Types2Package::invalidLiteralForIntegerConstantMacroArgumentQuery() and
+  queryId =
+    // `@id` for the `invalidLiteralForIntegerConstantMacroArgument` query
+    "c/misra/invalid-literal-for-integer-constant-macro-argument" and
+  ruleId = "RULE-7-5" and
+  category = "required"
+  or
+  query =
+    // `Query` instance for the `integerConstantMacroArgumentUsesSuffix` query
+    Types2Package::integerConstantMacroArgumentUsesSuffixQuery() and
+  queryId =
+    // `@id` for the `integerConstantMacroArgumentUsesSuffix` query
+    "c/misra/integer-constant-macro-argument-uses-suffix" and
+  ruleId = "RULE-7-5" and
+  category = "required"
+  or
+  query =
+    // `Query` instance for the `incorrectlySizedIntegerConstantMacroArgument` query
+    Types2Package::incorrectlySizedIntegerConstantMacroArgumentQuery() and
+  queryId =
+    // `@id` for the `incorrectlySizedIntegerConstantMacroArgument` query
+    "c/misra/incorrectly-sized-integer-constant-macro-argument" and
+  ruleId = "RULE-7-5" and
+  category = "required"
+  or
+  query =
+    // `Query` instance for the `useOfBannedSmallIntegerConstantMacro` query
+    Types2Package::useOfBannedSmallIntegerConstantMacroQuery() and
+  queryId =
+    // `@id` for the `useOfBannedSmallIntegerConstantMacro` query
+    "c/misra/use-of-banned-small-integer-constant-macro" and
+  ruleId = "RULE-7-6" and
+  category = "required"
+}
+
+module Types2Package {
+  Query invalidIntegerConstantMacroArgumentQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `invalidIntegerConstantMacroArgument` query
+      TQueryC(TTypes2PackageQuery(TInvalidIntegerConstantMacroArgumentQuery()))
+  }
+
+  Query invalidLiteralForIntegerConstantMacroArgumentQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `invalidLiteralForIntegerConstantMacroArgument` query
+      TQueryC(TTypes2PackageQuery(TInvalidLiteralForIntegerConstantMacroArgumentQuery()))
+  }
+
+  Query integerConstantMacroArgumentUsesSuffixQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `integerConstantMacroArgumentUsesSuffix` query
+      TQueryC(TTypes2PackageQuery(TIntegerConstantMacroArgumentUsesSuffixQuery()))
+  }
+
+  Query incorrectlySizedIntegerConstantMacroArgumentQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `incorrectlySizedIntegerConstantMacroArgument` query
+      TQueryC(TTypes2PackageQuery(TIncorrectlySizedIntegerConstantMacroArgumentQuery()))
+  }
+
+  Query useOfBannedSmallIntegerConstantMacroQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `useOfBannedSmallIntegerConstantMacro` query
+      TQueryC(TTypes2PackageQuery(TUseOfBannedSmallIntegerConstantMacroQuery()))
+  }
+}
diff --git a/rule_packages/c/Types2.json b/rule_packages/c/Types2.json
new file mode 100644
index 0000000000..7e4c0827fe
--- /dev/null
+++ b/rule_packages/c/Types2.json
@@ -0,0 +1,84 @@
+{
+  "MISRA-C-2012": {
+    "RULE-7-5": {
+      "properties": {
+        "obligation": "required"
+      },
+      "queries": [
+        {
+          "description": "Integer constant macros should be given a literal value as an argument.",
+          "kind": "problem",
+          "name": "The argument of an integer constant macro shall be a literal",
+          "precision": "very-high",
+          "severity": "warning",
+          "short_name": "InvalidIntegerConstantMacroArgument",
+          "tags": [
+            "correctness",
+            "external/misra/c/2012/amendment3"
+          ]
+        },
+        {
+          "description": "Integer constant macro arguments should be a decimal, hex, or octal literal.",
+          "kind": "problem",
+          "name": "The argument of an integer constant macro shall be a decimal, hex, or octal literal",
+          "precision": "very-high",
+          "severity": "error",
+          "short_name": "InvalidLiteralForIntegerConstantMacroArgument",
+          "tags": [
+            "correctness",
+            "external/misra/c/2012/amendment3"
+          ]
+        },
+        {
+          "description": "Integer constant macros should be used integer literal values with no u/l suffix.",
+          "kind": "problem",
+          "name": "The argument of an integer constant macro shall not use literal suffixes u, l, or ul",
+          "precision": "high",
+          "severity": "warning",
+          "short_name": "IntegerConstantMacroArgumentUsesSuffix",
+          "tags": [
+            "readability",
+            "maintainability",
+            "external/misra/c/2012/amendment3"
+          ]
+        },
+        {
+          "description": "Integer constant macros argument values should be values of a compatible size.",
+          "kind": "problem",
+          "name": "The argument of an integer constant macro shall have an appropriate size",
+          "precision": "very-high",
+          "severity": "error",
+          "short_name": "IncorrectlySizedIntegerConstantMacroArgument",
+          "tags": [
+            "correctness",
+            "external/misra/c/2012/amendment3"
+          ],
+          "implementation_scope": {
+            "description": "This rule can validate integers sized 32 or smaller. When the CodeQL runtime supports big ints, this will be expanded to include 64 bit integer types."
+          }
+        }
+      ],
+      "title": "The argument of an integer constant macro shall have an appropriate form"
+    },
+    "RULE-7-6": {
+      "properties": {
+        "obligation": "required"
+      },
+      "queries": [
+        {
+          "description": "Small integer constant macros expression are promoted to type int, which can lead to unexpected results.",
+          "kind": "problem",
+          "name": "The small integer variants of the minimum-width integer constant macros shall not be used",
+          "precision": "very-high",
+          "severity": "warning",
+          "short_name": "UseOfBannedSmallIntegerConstantMacro",
+          "tags": [
+            "readability",
+            "external/misra/c/2012/amendment3"
+          ]
+        }
+      ],
+      "title": "The small integer variants of the minimum-width integer constant macros shall not be used"
+    }
+  }
+}
\ No newline at end of file