C#: Use shared SSA implementation for BaseSsa

Author: hvitved

config/identical-files.json

@@ -428,6 +428,7 @@
   ],
   "SSA C#": [
     "csharp/ql/src/semmle/code/csharp/dataflow/internal/SsaImplCommon.qll",
-    "csharp/ql/src/semmle/code/csharp/controlflow/internal/pressa/SsaImplCommon.qll"
+    "csharp/ql/src/semmle/code/csharp/controlflow/internal/pressa/SsaImplCommon.qll",
+    "csharp/ql/src/semmle/code/csharp/dataflow/internal/basessa/SsaImplCommon.qll"
   ]
 }

csharp/ql/src/semmle/code/csharp/dataflow/internal/BaseSSA.qll

@@ -1,125 +1,43 @@
 import csharp
 
 /**
- * INTERNAL: Do not use.
- *
  * Provides a simple SSA implementation for local scope variables.
  */
 module BaseSsa {
-  private import ControlFlow
-  private import AssignableDefinitions
+  import basessa.SsaImplSpecific
+  private import basessa.SsaImplCommon as SsaImpl
 
-  pragma[noinline]
-  Callable getAnAssigningCallable(LocalScopeVariable v) {
-    result = any(AssignableDefinition def | def.getTarget() = v).getEnclosingCallable()
-  }
-
-  private class SimpleLocalScopeVariable extends LocalScopeVariable {
-    SimpleLocalScopeVariable() { not getAnAssigningCallable(this) != getAnAssigningCallable(this) }
-  }
-
-  /**
-   * Holds if the `i`th node of basic block `bb` is assignable definition `def`,
-   * targeting local scope variable `v`.
-   */
-  private predicate defAt(BasicBlock bb, int i, AssignableDefinition def, SimpleLocalScopeVariable v) {
-    bb.getNode(i) = def.getAControlFlowNode() and
-    v = def.getTarget() and
-    // In cases like `(x, x) = (0, 1)`, we discard the first (dead) definition of `x`
-    not exists(TupleAssignmentDefinition first, TupleAssignmentDefinition second | first = def |
-      second.getAssignment() = first.getAssignment() and
-      second.getEvaluationOrder() > first.getEvaluationOrder() and
-      second.getTarget() = v
-    )
-  }
+  class Definition extends SsaImpl::Definition {
+    final AssignableRead getARead() {
+      exists(BasicBlock bb, int i |
+        SsaImpl::ssaDefReachesRead(_, this, bb, i) and
+        result.getAControlFlowNode() = bb.getNode(i)
+      )
+    }
 
-  /**
-   * Holds if basic block `bb` would need to start with a phi node for local scope
-   * variable `v` in an SSA representation.
-   */
-  private predicate needsPhiNode(BasicBlock bb, SimpleLocalScopeVariable v) {
-    exists(BasicBlock def | def.inDominanceFrontier(bb) |
-      defAt(def, _, _, v) or
-      needsPhiNode(def, v)
-    )
-  }
+    final AssignableDefinition getDefinition() {
+      exists(BasicBlock bb, int i, SourceVariable v |
+        this.definesAt(v, bb, i) and
+        definitionAt(result, bb, i, v)
+      )
+    }
 
-  private newtype SsaRefKind =
-    SsaRead() or
-    SsaDef()
+    private Definition getAPhiInputOrPriorDefinition() {
+      result = this.(PhiNode).getAnInput() or
+      SsaImpl::uncertainWriteDefinitionInput(this, result)
+    }
 
-  /**
-   * Holds if the `i`th node of basic block `bb` is a reference to `v`,
-   * either a read (when `k` is `SsaRead()`) or a write including phi nodes
-   * (when `k` is `SsaDef()`).
-   */
-  private predicate ssaRef(BasicBlock bb, int i, SimpleLocalScopeVariable v, SsaRefKind k) {
-    bb.getNode(i).getElement() = v.getAnAccess().(VariableRead) and
-    k = SsaRead()
-    or
-    defAt(bb, i, _, v) and
-    k = SsaDef()
-    or
-    needsPhiNode(bb, v) and
-    i = -1 and
-    k = SsaDef()
-  }
+    final Definition getAnUltimateDefinition() {
+      result = this.getAPhiInputOrPriorDefinition*() and
+      not result instanceof PhiNode
+    }
 
-  /**
-   * Gets the (1-based) rank of the reference to `v` at the `i`th node of basic
-   * block `bb`, which has the given reference kind `k`.
-   */
-  private int ssaRefRank(BasicBlock bb, int i, SimpleLocalScopeVariable v, SsaRefKind k) {
-    i = rank[result](int j | ssaRef(bb, j, v, _)) and
-    ssaRef(bb, i, v, k)
+    Location getLocation() { result = this.getDefinition().getLocation() }
   }
 
-  /**
-   * Holds if definition `def` of local scope variable `v` inside basic block
-   * `bb` reaches the reference at rank `rnk`, without passing through another
-   * definition of `v`, including phi nodes.
-   */
-  private predicate defReachesRank(
-    BasicBlock bb, AssignableDefinition def, SimpleLocalScopeVariable v, int rnk
-  ) {
-    exists(int i | rnk = ssaRefRank(bb, i, v, SsaDef()) | defAt(bb, i, def, v))
-    or
-    defReachesRank(bb, def, v, rnk - 1) and
-    rnk = ssaRefRank(bb, _, v, SsaRead())
-  }
-
-  /**
-   * Holds if definition `def` of local scope variable `v` reaches the end of
-   * basic block `bb` without passing through another definition of `v`, including
-   * phi nodes.
-   */
-  private predicate reachesEndOf(AssignableDefinition def, SimpleLocalScopeVariable v, BasicBlock bb) {
-    exists(int rnk |
-      defReachesRank(bb, def, v, rnk) and
-      rnk = max(ssaRefRank(bb, _, v, _))
-    )
-    or
-    exists(BasicBlock mid |
-      reachesEndOf(def, v, mid) and
-      not exists(ssaRefRank(bb, _, v, SsaDef())) and
-      bb = mid.getASuccessor()
-    )
-  }
+  class PhiNode extends SsaImpl::PhiNode, Definition {
+    override Location getLocation() { result = this.getBasicBlock().getLocation() }
 
-  /**
-   * Gets a read of the SSA definition for variable `v` at definition `def`. That is,
-   * a read that is guaranteed to read the value assigned at definition `def`.
-   */
-  cached
-  AssignableRead getARead(AssignableDefinition def, SimpleLocalScopeVariable v) {
-    exists(BasicBlock bb, int i, int rnk |
-      result.getAControlFlowNode() = bb.getNode(i) and
-      rnk = ssaRefRank(bb, i, v, SsaRead())
-    |
-      defReachesRank(bb, def, v, rnk)
-      or
-      reachesEndOf(def, v, bb.getAPredecessor()) and
-      not ssaRefRank(bb, _, v, SsaDef()) < rnk
-    )
+    final Definition getAnInput() { SsaImpl::phiHasInputFromBlock(this, result, _) }
   }
 }

csharp/ql/src/semmle/code/csharp/dataflow/internal/Steps.qll

@@ -16,7 +16,10 @@ module Steps {
    * Gets a read that is guaranteed to read the value assigned at definition `def`.
    */
   private AssignableRead getARead(AssignableDefinition def) {
-    result = BaseSsa::getARead(def, _)
+    exists(BaseSsa::Definition ssaDef |
+      ssaDef.getDefinition() = def and
+      result = ssaDef.getARead()
+    )
     or
     exists(LocalScopeVariable v | def.getTarget() = v |
       result = v.getAnAccess() and