Merge parameter 'arg' node into 'param-init'

Each parameter previously created two additional nodes: an 'arg:i'
node (ReadArgumentInstruction) holding the incoming argument value, and
a 'param-init:i' node (InitParameterInstruction) writing it to the
parameter's SSA variable. The 'arg' node existed only to be the RHS of
the param-init write; the ParameterNode and inter-procedural flow are
already anchored on param-init.

Make InitParameterInstruction its own RHS and drop the 'arg:i' node,
halving the per-parameter node count. DeadStoreOfLocal now excludes
InitParameterInstruction (instead of ReadArgumentInstruction). The
data-flow changes are pure relabelings (arg -> param-init) with no flow
loss.

Author: owen-mc

go/ql/lib/semmle/go/controlflow/ControlFlowGraphShared.qll

@@ -561,12 +561,12 @@ module GoCfg {
           tag = "result-read:" + i.toString()
         )
         or
-        // Parameter init + argument nodes (on the function body)
+        // Parameter init nodes (on the function body)
         exists(int i, Go::FuncDef fd |
           n = fd.getBody() and
           exists(fd.getBody()) and
           exists(fd.getParameter(i)) and
-          (tag = "param-init:" + i.toString() or tag = "arg:" + i.toString())
+          tag = "param-init:" + i.toString()
         )
         or
         // Result variable init (on the function body)
@@ -1729,8 +1729,8 @@ module GoCfg {
 
     /**
      * Function definition prologue and epilogue:
-     * - Prologue: Before(body) → arg:-1 → param-init:-1 → arg:0 → param-init:0 → ...
-     *             when a receiver exists; otherwise it starts at arg:0. Then
+     * - Prologue: Before(body) → param-init:-1 → param-init:0 → ... when a
+     *             receiver exists; otherwise it starts at param-init:0. Then
      *             result-zero-init:0 → result-init:0 → ... → first statement
      * - Epilogue: return → result-read:0 → result-read:1 → ... → result-read:last
      *
@@ -1773,13 +1773,13 @@ module GoCfg {
         // Before(body) → first prologue node, or first body statement if no prologue
         n1.isBefore(fd.getBody()) and
         (
-          // Has receiver: start with arg:-1
-          exists(fd.getParameter(-1)) and n2.isAdditional(fd.getBody(), "arg:-1")
+          // Has receiver: start with param-init:-1
+          exists(fd.getParameter(-1)) and n2.isAdditional(fd.getBody(), "param-init:-1")
           or
-          // Has ordinary parameters: start with arg:0
+          // Has ordinary parameters: start with param-init:0
           not exists(fd.getParameter(-1)) and
           exists(fd.getParameter(0)) and
-          n2.isAdditional(fd.getBody(), "arg:0")
+          n2.isAdditional(fd.getBody(), "param-init:0")
           or
           // No parameters, has result vars: start with result-zero-init:0
           not exists(fd.getParameter(_)) and
@@ -1792,19 +1792,13 @@ module GoCfg {
           funcDefBodyStart(fd, n2)
         )
         or
-        // arg:i → param-init:i (for each parameter)
-        exists(int i | exists(fd.getParameter(i)) |
-          n1.isAdditional(fd.getBody(), "arg:" + i.toString()) and
-          n2.isAdditional(fd.getBody(), "param-init:" + i.toString())
-        )
-        or
-        // param-init:i → next: arg:(i+1), or result-zero-init:0, or Before(body)
+        // param-init:i → next: param-init:(i+1), or result-zero-init:0, or Before(body)
         exists(int i | exists(fd.getParameter(i)) |
           n1.isAdditional(fd.getBody(), "param-init:" + i.toString()) and
           (
             // Next parameter exists
             exists(fd.getParameter(i + 1)) and
-            n2.isAdditional(fd.getBody(), "arg:" + (i + 1).toString())
+            n2.isAdditional(fd.getBody(), "param-init:" + (i + 1).toString())
             or
             // No next parameter, has result vars: go to result-zero-init:0
             not exists(fd.getParameter(i + 1)) and

go/ql/lib/semmle/go/controlflow/IR.qll

@@ -191,8 +191,6 @@ module IR {
       or
       this instanceof InitParameterInstruction and result = "parameter initialization"
       or
-      this instanceof ReadArgumentInstruction and result = "argument"
-      or
       this instanceof InitResultInstruction and result = "result initialization"
       or
       this instanceof GetNextEntryInstruction and result = "next key-value pair"
@@ -1026,23 +1024,7 @@ module IR {
       parm = fd.getParameter(idx)
     }
 
-    override Instruction getRhs() {
-      result.(ReadArgumentInstruction).isAdditional(fd.getBody(), "arg:" + idx.toString())
-    }
-
-    override ControlFlow::Root getRoot() { result = parm.getFunction() }
-  }
-
-  /** An instruction reading the value of a function argument. */
-  class ReadArgumentInstruction extends Instruction {
-    Parameter parm;
-    int idx;
-    FuncDef fd;
-
-    ReadArgumentInstruction() {
-      this.isAdditional(fd.getBody(), "arg:" + idx.toString()) and
-      parm = fd.getParameter(idx)
-    }
+    override Instruction getRhs() { result = this }
 
     override Type getResultType() { result = parm.getType() }
 

go/ql/src/RedundantCode/DeadStoreOfLocal.ql

@@ -26,7 +26,7 @@ predicate isSimple(IR::Instruction nd) {
   nd = IR::implicitInitInstruction(_)
   or
   // don't flag parameters
-  nd instanceof IR::ReadArgumentInstruction
+  nd instanceof IR::InitParameterInstruction
 }
 
 from IR::Instruction def, SsaSourceVariable target, IR::Instruction rhs

go/ql/test/example-tests/snippets/typeinfo.expected

@@ -3,6 +3,6 @@
 | file://:0:0:0:0 | [summary param] -1 in Write |
 | file://:0:0:0:0 | [summary param] -1 in WriteProxy |
 | main.go:18:103:26:1 | SSA def(req) |
-| main.go:18:103:26:1 | arg:0 block statement |
+| main.go:18:103:26:1 | param-init:0 block statement |
 | main.go:20:5:20:7 | req |
 | main.go:20:5:20:7 | req [postupdate] |

go/ql/test/extractor-tests/go1.17/CFG.expected

@@ -13,8 +13,7 @@ edges
 | conversions.go:5:1:5:29 | Normal Exit | conversions.go:5:1:5:29 | Exit |
 | conversions.go:5:1:5:29 | function declaration | conversions.go:5:1:5:29 | After function declaration |
 | conversions.go:5:28:5:29 | After block statement | conversions.go:5:1:5:29 | Normal Exit |
-| conversions.go:5:28:5:29 | arg:0 block statement | conversions.go:5:28:5:29 | param-init:0 block statement |
-| conversions.go:5:28:5:29 | block statement | conversions.go:5:28:5:29 | arg:0 block statement |
+| conversions.go:5:28:5:29 | block statement | conversions.go:5:28:5:29 | param-init:0 block statement |
 | conversions.go:5:28:5:29 | param-init:0 block statement | conversions.go:5:28:5:29 | After block statement |
 | conversions.go:7:1:26:1 | After function declaration | conversions.go:0:0:0:0 | After conversions.go |
 | conversions.go:7:1:26:1 | Before function declaration | conversions.go:7:1:26:1 | function declaration |