C++: Rename a few IR APIs

There are a few IR APIs that we've found to be confusingly named. This PR renames them to be more consistent within the IR and with the AST API:

`Instruction.getFunction` -> `Instruction.getEnclosingFunction`: This was especially confusing when you'd call `FunctionAddressInstruction.getFunction` to get the function whose address was taken, and wound up with the enclosing function instead.

`Instruction.getXXXOperand` -> `Instruction.getXXX`. Now that `Operand` is an exposed type, we want a way to get a specific `Operand` of an `Instruction`, but more often we want to get the definition instruction of that operand. Now, the pattern is that `getXXXOperand` returns the `Operand`, and `getXXX` is equivalent to `getXXXOperand().getDefinitionInstruction()`.

`Operand.getInstruction` -> `Operand.getUseInstruction`: More consistent with the existing `Operand.getDefinitionInstruction` predicate.

Author: dave-bartolomeo

cpp/ql/src/semmle/code/cpp/controlflow/IRGuards.qll

@@ -276,7 +276,7 @@ class IRGuardCondition extends Instruction {
         this.controlsBlock(controlled, testIsTrue)
         or
         exists (IRGuardCondition ne
-        | this =  ne.(LogicalNotInstruction).getOperand() and
+        | this =  ne.(LogicalNotInstruction).getUnary() and
           ne.controls(controlled, testIsTrue.booleanNot())) 
     }
 
@@ -359,7 +359,7 @@ private predicate is_condition(Instruction guard) {
     branch.getCondition() = guard
   )
   or
-  exists(LogicalNotInstruction cond | is_condition(cond) and cond.getOperand() = guard)
+  exists(LogicalNotInstruction cond | is_condition(cond) and cond.getUnary() = guard)
 }
 
 /**
@@ -383,7 +383,7 @@ private predicate compares_eq(Instruction test, Operand left, Operand right, int
     or
     /* (x is true => (left == right + k)) => (!x is false => (left == right + k)) */
     exists(boolean isFalse | testIsTrue = isFalse.booleanNot() |
-        compares_eq(test.(LogicalNotInstruction).getOperand(), left, right, k, areEqual, isFalse)
+        compares_eq(test.(LogicalNotInstruction).getUnary(), left, right, k, areEqual, isFalse)
     )
 }
 
@@ -421,7 +421,7 @@ private predicate compares_lt(Instruction test, Operand left, Operand right, int
     or
     /* (x is true => (left < right + k)) => (!x is false => (left < right + k)) */
     exists(boolean isFalse | testIsTrue = isFalse.booleanNot() |
-        compares_lt(test.(LogicalNotInstruction).getOperand(), left, right, k, isLt, isFalse)
+        compares_lt(test.(LogicalNotInstruction).getUnary(), left, right, k, isLt, isFalse)
     )
 }
 
@@ -452,12 +452,12 @@ private predicate complex_lt(CompareInstruction cmp, Operand left, Operand right
    left < (right - x) + c => left < right + (c-x) */
 private predicate sub_lt(CompareInstruction cmp, Operand left, Operand right, int k, boolean isLt, boolean testIsTrue) {
     exists(SubInstruction lhs, int c, int x | compares_lt(cmp, lhs.getAUse(), right, c, isLt, testIsTrue) and
-                                left = lhs.getAnOperand().(LeftOperand) and x = int_value(lhs.getRightOperand())
+                                left = lhs.getAnOperand().(LeftOperand) and x = int_value(lhs.getRight())
                                 and k = c + x
     )
     or
     exists(SubInstruction rhs, int c, int x | compares_lt(cmp, left, rhs.getAUse(), c, isLt, testIsTrue) and
-                                right = rhs.getAnOperand().(LeftOperand) and x = int_value(rhs.getRightOperand())
+                                right = rhs.getAnOperand().(LeftOperand) and x = int_value(rhs.getRight())
                                 and k = c - x
     )
 }
@@ -466,17 +466,17 @@ private predicate sub_lt(CompareInstruction cmp, Operand left, Operand right, in
    left < (right + x) + c => left < right + (c+x) */
 private predicate add_lt(CompareInstruction cmp, Operand left, Operand right, int k, boolean isLt, boolean testIsTrue) {
     exists(AddInstruction lhs, int c, int x | compares_lt(cmp, lhs.getAUse(), right, c, isLt, testIsTrue) and
-                                (left = lhs.getAnOperand().(LeftOperand) and x = int_value(lhs.getRightOperand())
+                                (left = lhs.getAnOperand().(LeftOperand) and x = int_value(lhs.getRight())
                                  or
-                                 left = lhs.getAnOperand().(RightOperand) and x = int_value(lhs.getLeftOperand())
+                                 left = lhs.getAnOperand().(RightOperand) and x = int_value(lhs.getLeft())
                                 )
                                 and k = c - x
     )
     or
     exists(AddInstruction rhs, int c, int x | compares_lt(cmp, left, rhs.getAUse(), c, isLt, testIsTrue) and
-                                (right = rhs.getAnOperand().(LeftOperand) and x = int_value(rhs.getRightOperand())
+                                (right = rhs.getAnOperand().(LeftOperand) and x = int_value(rhs.getRight())
                                  or
-                                 right = rhs.getAnOperand().(RightOperand) and x = int_value(rhs.getLeftOperand())
+                                 right = rhs.getAnOperand().(RightOperand) and x = int_value(rhs.getLeft())
                                 )
                                 and k = c + x
     )
@@ -487,12 +487,12 @@ private predicate add_lt(CompareInstruction cmp, Operand left, Operand right, in
    left == (right - x) + c => left == right + (c-x) */
 private predicate sub_eq(CompareInstruction cmp, Operand left, Operand right, int k, boolean areEqual, boolean testIsTrue) {
     exists(SubInstruction lhs, int c, int x | compares_eq(cmp, lhs.getAUse(), right, c, areEqual, testIsTrue) and
-                                left = lhs.getAnOperand().(LeftOperand) and x = int_value(lhs.getRightOperand())
+                                left = lhs.getAnOperand().(LeftOperand) and x = int_value(lhs.getRight())
                                 and k = c + x
     )
     or
     exists(SubInstruction rhs, int c, int x | compares_eq(cmp, left, rhs.getAUse(), c, areEqual, testIsTrue) and
-                                right = rhs.getAnOperand().(LeftOperand) and x = int_value(rhs.getRightOperand())
+                                right = rhs.getAnOperand().(LeftOperand) and x = int_value(rhs.getRight())
                                 and k = c - x
     )
 }
@@ -502,17 +502,17 @@ private predicate sub_eq(CompareInstruction cmp, Operand left, Operand right, in
    left == (right + x) + c => left == right + (c+x) */
 private predicate add_eq(CompareInstruction cmp, Operand left, Operand right, int k, boolean areEqual, boolean testIsTrue) {
     exists(AddInstruction lhs, int c, int x | compares_eq(cmp, lhs.getAUse(), right, c, areEqual, testIsTrue) and
-                                (left = lhs.getAnOperand().(LeftOperand) and x = int_value(lhs.getRightOperand())
+                                (left = lhs.getAnOperand().(LeftOperand) and x = int_value(lhs.getRight())
                                  or
-                                 left = lhs.getAnOperand().(RightOperand) and x = int_value(lhs.getLeftOperand())
+                                 left = lhs.getAnOperand().(RightOperand) and x = int_value(lhs.getLeft())
                                 )
                                 and k = c - x
     )
     or
     exists(AddInstruction rhs, int c, int x | compares_eq(cmp, left, rhs.getAUse(), c, areEqual, testIsTrue) and
-                                (right = rhs.getAnOperand().(LeftOperand) and x = int_value(rhs.getRightOperand())
+                                (right = rhs.getAnOperand().(LeftOperand) and x = int_value(rhs.getRight())
                                  or
-                                 right = rhs.getAnOperand().(RightOperand) and x = int_value(rhs.getLeftOperand())
+                                 right = rhs.getAnOperand().(RightOperand) and x = int_value(rhs.getLeft())
                                 )
                                 and k = c + x
     )

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

@@ -16,7 +16,7 @@ class Node extends Instruction {
    * INTERNAL: Do not use. Alternative name for `getFunction`.
    */
   Function getEnclosingCallable() {
-    result = this.getFunction()
+    result = this.getEnclosingFunction()
   }
 
   /** Gets the type of this node. */
@@ -155,7 +155,7 @@ predicate localFlowStep(Node nodeFrom, Node nodeTo) {
   nodeTo.(CopyInstruction).getSourceValue() = nodeFrom or
   nodeTo.(PhiInstruction).getAnOperand().getDefinitionInstruction() = nodeFrom or
   // Treat all conversions as flow, even conversions between different numeric types.
-  nodeTo.(ConvertInstruction).getOperand() = nodeFrom
+  nodeTo.(ConvertInstruction).getUnary() = nodeFrom
 }
 
 /**

cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/FunctionIR.qll

@@ -40,33 +40,33 @@ class FunctionIR extends TFunctionIR {
    */
   pragma[noinline]
   final EnterFunctionInstruction getEnterFunctionInstruction() {
-    result.getFunctionIR() = this
+    result.getEnclosingFunctionIR() = this
   }
 
   /**
    * Gets the exit point for this function.
    */
   pragma[noinline]
   final ExitFunctionInstruction getExitFunctionInstruction() {
-    result.getFunctionIR() = this
+    result.getEnclosingFunctionIR() = this
   }
 
   pragma[noinline]
   final UnmodeledDefinitionInstruction getUnmodeledDefinitionInstruction() {
-    result.getFunctionIR() = this
+    result.getEnclosingFunctionIR() = this
   }
 
   pragma[noinline]
   final UnmodeledUseInstruction getUnmodeledUseInstruction() {
-    result.getFunctionIR() = this
+    result.getEnclosingFunctionIR() = this
   }
 
   /**
    * Gets the single return instruction for this function.
    */
   pragma[noinline]
   final ReturnInstruction getReturnInstruction() {
-    result.getFunctionIR() = this
+    result.getEnclosingFunctionIR() = this
   }
 
   /**
@@ -75,7 +75,7 @@ class FunctionIR extends TFunctionIR {
    */
   pragma[noinline]
   final IRReturnVariable getReturnVariable() {
-    result.getFunctionIR() = this
+    result.getEnclosingFunctionIR() = this
   }
 
   /**
@@ -90,13 +90,13 @@ class FunctionIR extends TFunctionIR {
    * Gets all instructions in this function.
    */
   final Instruction getAnInstruction() {
-    result.getFunctionIR() = this
+    result.getEnclosingFunctionIR() = this
   }
 
   /**
    * Gets all blocks in this function.
    */
   final IRBlock getABlock() {
-    result.getFunctionIR() = this
+    result.getEnclosingFunctionIR() = this
   }
 }

cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/IRBlock.qll

@@ -33,7 +33,7 @@ class IRBlockBase extends TIRBlock {
    */
   int getDisplayIndex() {
     this = rank[result + 1](IRBlock funcBlock |
-      funcBlock.getFunction() = getFunction() |
+      funcBlock.getEnclosingFunction() = getEnclosingFunction() |
       funcBlock order by funcBlock.getUniqueId()
     )
   }
@@ -63,12 +63,12 @@ class IRBlockBase extends TIRBlock {
     result = strictcount(getInstruction(_))
   }
 
-  final FunctionIR getFunctionIR() {
-    result = getFirstInstruction(this).getFunctionIR()
+  final FunctionIR getEnclosingFunctionIR() {
+    result = getFirstInstruction(this).getEnclosingFunctionIR()
   }
 
-  final Function getFunction() {
-    result = getFirstInstruction(this).getFunction()
+  final Function getEnclosingFunction() {
+    result = getFirstInstruction(this).getEnclosingFunction()
   }
 }
 
@@ -116,7 +116,7 @@ class IRBlock extends IRBlockBase {
    * Holds if this block is reachable from the entry point of its function
    */
   final predicate isReachableFromFunctionEntry() {
-    this = getFunctionIR().getEntryBlock() or
+    this = getEnclosingFunctionIR().getEntryBlock() or
     getAPredecessor().isReachableFromFunctionEntry()
   }
 }

cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/IRVariable.qll

@@ -7,7 +7,7 @@ private import semmle.code.cpp.ir.internal.TIRVariable
 
 IRUserVariable getIRUserVariable(Function func, Variable var) {
   result.getVariable() = var and
-  result.getFunction() = func
+  result.getEnclosingFunction() = func
 }
 
 /**
@@ -47,14 +47,14 @@ abstract class IRVariable extends TIRVariable {
   /**
    * Gets the IR for the function that references this variable.
    */
-  final FunctionIR getFunctionIR() {
+  final FunctionIR getEnclosingFunctionIR() {
     result.getFunction() = func
   }
 
   /**
    * Gets the function that references this variable.
    */
-  final Function getFunction() {
+  final Function getEnclosingFunction() {
     result = func
   }
 }