C++: Rename 'Ssa' to 'SsaInternals' and move definitions from 'SSaImplSpecific' to 'SsaInternals'. Now we can avoid cyclic imports.

cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowUtil.qll

@@ -11,7 +11,7 @@ private import semmle.code.cpp.ir.IR
 private import semmle.code.cpp.controlflow.IRGuards
 private import semmle.code.cpp.models.interfaces.DataFlow
 private import DataFlowPrivate
-private import Ssa as Ssa
+private import SsaInternals as Ssa
 
 cached
 private module Cached {

cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/SsaImplSpecific.qll

@@ -1,11 +1,10 @@
 private import semmle.code.cpp.ir.IR
-private import DataFlowUtil
-private import DataFlowPrivate
-private import DataFlowImplCommon as DataFlowImplCommon
-private import Ssa as Ssa
+private import SsaInternals as Ssa
 
 class BasicBlock = IRBlock;
 
+class SourceVariable = Ssa::SourceVariable;
+
 BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) { result.immediatelyDominates(bb) }
 
 BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }
@@ -14,51 +13,6 @@ class ExitBasicBlock extends IRBlock {
   ExitBasicBlock() { this.getLastInstruction() instanceof ExitFunctionInstruction }
 }
 
-private newtype TSourceVariable =
-  TSourceIRVariable(IRVariable var) or
-  TSourceIRVariableIndirection(InitializeIndirectionInstruction init)
+predicate variableWrite = Ssa::variableWrite/4;
 
-abstract class SourceVariable extends TSourceVariable {
-  IRVariable var;
-
-  IRVariable getIRVariable() { result = var }
-
-  abstract string toString();
-
-  predicate isIndirection() { none() }
-}
-
-class SourceIRVariable extends SourceVariable, TSourceIRVariable {
-  SourceIRVariable() { this = TSourceIRVariable(var) }
-
-  override string toString() { result = this.getIRVariable().toString() }
-}
-
-class SourceIRVariableIndirection extends SourceVariable, TSourceIRVariableIndirection {
-  InitializeIndirectionInstruction init;
-
-  SourceIRVariableIndirection() {
-    this = TSourceIRVariableIndirection(init) and var = init.getIRVariable()
-  }
-
-  override string toString() { result = "*" + this.getIRVariable().toString() }
-
-  override predicate isIndirection() { any() }
-}
-
-predicate variableWrite(BasicBlock bb, int i, SourceVariable v, boolean certain) {
-  DataFlowImplCommon::forceCachingInSameStage() and
-  exists(Ssa::Def def |
-    def.hasRankInBlock(bb, i) and
-    v = def.getSourceVariable() and
-    (if def.isCertain() then certain = true else certain = false)
-  )
-}
-
-predicate variableRead(BasicBlock bb, int i, SourceVariable v, boolean certain) {
-  exists(Ssa::Use use |
-    use.hasRankInBlock(bb, i) and
-    v = use.getSourceVariable() and
-    certain = true
-  )
-}
+predicate variableRead = Ssa::variableRead/4;

cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/SsaInternals.qll

@@ -1,12 +1,47 @@
 import SsaImplCommon
-import SsaImplSpecific
 private import cpp as Cpp
 private import semmle.code.cpp.ir.IR
 private import DataFlowUtil
-private import DataFlowPrivate
+private import DataFlowImplCommon as DataFlowImplCommon
 private import semmle.code.cpp.models.interfaces.Allocation as Alloc
 private import semmle.code.cpp.models.interfaces.DataFlow as DataFlow
 
+private module SourceVariables {
+  private newtype TSourceVariable =
+    TSourceIRVariable(IRVariable var) or
+    TSourceIRVariableIndirection(InitializeIndirectionInstruction init)
+
+  abstract class SourceVariable extends TSourceVariable {
+    IRVariable var;
+
+    IRVariable getIRVariable() { result = var }
+
+    abstract string toString();
+
+    predicate isIndirection() { none() }
+  }
+
+  private class SourceIRVariable extends SourceVariable, TSourceIRVariable {
+    SourceIRVariable() { this = TSourceIRVariable(var) }
+
+    override string toString() { result = this.getIRVariable().toString() }
+  }
+
+  private class SourceIRVariableIndirection extends SourceVariable, TSourceIRVariableIndirection {
+    InitializeIndirectionInstruction init;
+
+    SourceIRVariableIndirection() {
+      this = TSourceIRVariableIndirection(init) and var = init.getIRVariable()
+    }
+
+    override string toString() { result = "*" + this.getIRVariable().toString() }
+
+    override predicate isIndirection() { any() }
+  }
+}
+
+import SourceVariables
+
 cached
 private newtype TDefOrUse =
   TExplicitDef(Instruction store) { explicitWrite(_, store, _) } or
@@ -509,3 +544,28 @@ private module Cached {
 }
 
 import Cached
+
+/**
+ * Holds if the `i`'th write in block `bb` writes to the variable `v`.
+ * `certain` is `true` if the write is guaranteed to overwrite the entire variable.
+ */
+predicate variableWrite(IRBlock bb, int i, SourceVariable v, boolean certain) {
+  DataFlowImplCommon::forceCachingInSameStage() and
+  exists(Def def |
+    def.hasRankInBlock(bb, i) and
+    v = def.getSourceVariable() and
+    (if def.isCertain() then certain = true else certain = false)
+  )
+}
+
+/**
+ * Holds if the `i`'th read in block `bb` reads to the variable `v`.
+ * `certain` is `true` if the read is guaranteed. For C++, this is always the case.
+ */
+predicate variableRead(IRBlock bb, int i, SourceVariable v, boolean certain) {
+  exists(Use use |
+    use.hasRankInBlock(bb, i) and
+    v = use.getSourceVariable() and
+    certain = true
+  )
+}