Shared CFG: Add includeCallableEntry hook

Author: owen-mc

shared/controlflow/codeql/controlflow/ControlFlowGraph.qll

@@ -1204,6 +1204,14 @@ module Make0<LocationSig Location, AstSig<Location> Ast> {
     }
 
     signature module InputSig2 {
+      /**
+       * Holds if control flow is constructed and reachability starts at the
+       * entry of `callable` in this stage.
+       * By default, all callable entries are included. Restricting this is useful
+       * for auxiliary CFG stages that are only needed for selected callables.
+       */
+      default predicate includeCallableEntry(Callable callable) { any() }
+
       /**
        * Holds if `ast` may result in an abrupt completion `c` originating at
        * `n`. The boolean `always` indicates whether the abrupt completion
@@ -1938,6 +1946,7 @@ module Make0<LocationSig Location, AstSig<Location> Ast> {
        */
       private predicate defaultCfg(AstNode ast) {
         hasCfg(ast) and
+        Input2::includeCallableEntry(getEnclosingCallable(ast)) and
         not explicitStep(any(PreControlFlowNode n | n.isBefore(ast)), _)
       }
 
@@ -1989,7 +1998,8 @@ module Make0<LocationSig Location, AstSig<Location> Ast> {
 
       /** Holds if there is a local non-abrupt step from `n1` to `n2`. */
       private predicate step(PreControlFlowNode n1, PreControlFlowNode n2) {
-        explicitStep(n1, n2) or defaultStep(n1, n2)
+        Input2::includeCallableEntry(n1.getEnclosingCallable()) and
+        (explicitStep(n1, n2) or defaultStep(n1, n2))
       }
 
       /**
@@ -2023,25 +2033,28 @@ module Make0<LocationSig Location, AstSig<Location> Ast> {
       }
 
       private predicate preSucc(PreControlFlowNode n1, PreControlFlowNode n2, SuccessorType t) {
-        step(n1, n2) and n2 = TAfterValueNode(_, t)
-        or
-        step(n1, n2) and n2.(AdditionalNode).getSuccessorType() = t
-        or
-        step(n1, n2) and
-        not n2 instanceof AfterValueNode and
-        not n2 instanceof AdditionalNode and
-        t instanceof DirectSuccessor
-        or
-        exists(AstNode ast, AbruptCompletion c |
-          last(ast, n1, c) and endAbruptCompletion(ast, n2, c) and t = c.getSuccessorType()
+        Input2::includeCallableEntry(n1.getEnclosingCallable()) and
+        (
+          step(n1, n2) and n2 = TAfterValueNode(_, t)
+          or
+          step(n1, n2) and n2.(AdditionalNode).getSuccessorType() = t
+          or
+          step(n1, n2) and
+          not n2 instanceof AfterValueNode and
+          not n2 instanceof AdditionalNode and
+          t instanceof DirectSuccessor
+          or
+          exists(AstNode ast, AbruptCompletion c |
+            last(ast, n1, c) and endAbruptCompletion(ast, n2, c) and t = c.getSuccessorType()
+          )
         )
       }
 
       /** Holds if `n` is reachable from an entry node. */
       cached
       private predicate reachable(PreControlFlowNode n) {
         Input1::cfgCachedStageRef() and
-        n instanceof EntryNodeImpl
+        Input2::includeCallableEntry(n.(EntryNodeImpl).getEnclosingCallable())
         or
         exists(PreControlFlowNode mid | reachable(mid) and preSucc(mid, n, _))
       }