C++: Stub 'VariableGroup' and 'GroupedMemoryLocation' in unaliased SSA so that the pyrameterized files compile.

cpp/ql/lib/semmle/code/cpp/ir/implementation/internal/TInstruction.qll

@@ -31,6 +31,7 @@ newtype TInstruction =
   TUnaliasedSsaUnreachedInstruction(IRFunctionBase irFunc) {
     UnaliasedSsa::Ssa::hasUnreachedInstruction(irFunc)
   } or
+  TUnaliasedSsaInitializeGroupInstruction(UnaliasedSsa::Ssa::VariableGroup vg) or
   TAliasedSsaPhiInstruction(
     TRawInstruction blockStartInstr, AliasedSsa::Ssa::MemoryLocation memoryLocation
   ) {
@@ -72,6 +73,16 @@ module UnaliasedSsaInstructions {
   TUnreachedInstruction unreachedInstruction(IRFunctionBase irFunc) {
     result = TUnaliasedSsaUnreachedInstruction(irFunc)
   }
+
+  class VariableGroup = UnaliasedSsa::Ssa::VariableGroup;
+
+  class TInitializeGroupInstruction = TUnaliasedSsaInitializeGroupInstruction;
+
+  class TRawOrInitializeGroupInstruction = TRawInstruction or TInitializeGroupInstruction;
+
+  // This really should just be `TUnaliasedSsaInitializeGroupInstruction`, but that makes the
+  // compiler realize that certain expressions in `SSAConstruction` are unsatisfiable.
+  TRawOrInitializeGroupInstruction initializeGroup(VariableGroup vg) { none() }
 }
 
 /**

cpp/ql/lib/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/SimpleSSA.qll

@@ -2,6 +2,7 @@ import AliasAnalysis
 private import SimpleSSAImports
 import SimpleSSAPublicImports
 private import AliasConfiguration
+private import codeql.util.Unit
 
 private predicate isTotalAccess(Allocation var, AddressOperand addrOperand, IRType type) {
   exists(Instruction constantBase, int bitOffset |
@@ -77,6 +78,40 @@ class MemoryLocation extends TMemoryLocation {
 
 predicate canReuseSsaForOldResult(Instruction instr) { none() }
 
+abstract class VariableGroup extends Unit {
+  abstract Allocation getAnAllocation();
+
+  string toString() { result = "{" + strictconcat(this.getAnAllocation().toString(), ", ") + "}" }
+
+  abstract Language::Location getLocation();
+
+  abstract IRFunction getIRFunction();
+
+  abstract Language::LanguageType getType();
+
+  abstract int getInitializationOrder();
+}
+
+class GroupedMemoryLocation extends MemoryLocation {
+  VariableGroup vg;
+
+  GroupedMemoryLocation() { none() }
+
+  /** Gets an allocation of this memory location. */
+  Allocation getAnAllocation() { result = vg.getAnAllocation() }
+
+  /** Gets the set of allocations associated with this memory location. */
+  VariableGroup getGroup() { result = vg }
+
+  predicate isMayAccess() { none() }
+
+  /** Holds if this memory location represents all the enclosing allocations. */
+  predicate isAll() { none() }
+
+  /** Holds if this memory location represents one or more of the enclosing allocations. */
+  predicate isSome() { none() }
+}
+
 /**
  * Represents a set of `MemoryLocation`s that cannot overlap with
  * `MemoryLocation`s outside of the set. The `VirtualVariable` will be