Binary: Consistency queries for all stages.

Author: MathiasVP

binary/ql/lib/semmle/code/binary/ast/ir/internal/Consistency.qll

@@ -0,0 +1,25 @@
+private import semmle.code.binary.ast.ir.internal.Tags
+private import codeql.controlflow.SuccessorType
+private import semmle.code.binary.ast.ir.internal.InstructionSig
+
+module StagedConsistencyInput<InstructionSig Input> {
+  query predicate nonUniqueSuccessor(Input::Function f, Input::Instruction i, SuccessorType t, int k) {
+    i.getEnclosingFunction() = f and
+    k = strictcount(i.getSuccessor(t)) and
+    k > 1
+  }
+
+  query predicate nonUniqueResultVariable(Input::Function f, Input::Instruction i, int k) {
+    i.getEnclosingFunction() = f and
+    strictcount(i.getResultVariable()) = k and
+    k > 1
+  }
+
+  query predicate missingSuccessor(Input::Function f, Input::Instruction i) {
+    i.getEnclosingFunction() = f and
+    not i instanceof Input::RetInstruction and
+    not i instanceof Input::RetValueInstruction and
+    exists(i.getAPredecessor()) and
+    not exists(i.getASuccessor())
+  }
+}

binary/ql/lib/semmle/code/binary/ast/ir/internal/Instruction0/Consistency.ql

@@ -1,27 +1,32 @@
-private import TranslatedElement
+private import Instruction0
+import semmle.code.binary.ast.ir.internal.Consistency
+import StagedConsistencyInput<Instruction0>
 private import TranslatedInstruction
-private import semmle.code.binary.ast.ir.internal.InstructionTag
-private import Instruction0::Instruction0
-private import codeql.controlflow.SuccessorType
-
-query predicate nonUniqueSuccessor(Instruction i, SuccessorType t, int k) {
-  k = strictcount(i.getSuccessor(t)) and
-  k > 1
-}
-
-query predicate nonUniqueResultVariable(Instruction i, int k) {
-  strictcount(i.getResultVariable()) = k and
-  k > 1
-}
+private import TranslatedFunction
+private import semmle.code.binary.ast.ir.internal.Opcode
+private import semmle.code.binary.ast.ir.internal.Tags
+private import InstructionTag
 
 query predicate nonUniqueOpcode(TranslatedInstruction ti, InstructionTag tag, int k) {
   strictcount(Opcode opcode | ti.hasInstruction(opcode, tag, _)) = k and
   k > 1
 }
 
 query predicate nonUniqueVariableOperand(
-  TranslatedInstruction ti, InstructionTag tag, OperandTag operandTag, int k
+  TranslatedFunction tf, TranslatedInstruction ti, string s, InstructionTag tag,
+  OperandTag operandTag, int k
 ) {
+  tf = ti.getEnclosingFunction() and
+  s = concat(ti.getAQlClass().toString(), ", ") and
   strictcount(ti.getVariableOperand(tag, operandTag)) = k and
   k > 1
 }
+
+query predicate nonUniqueResultVariable0(
+  TranslatedFunction tf, TranslatedInstruction ti, string s, int k
+) {
+  tf = ti.getEnclosingFunction() and
+  s = concat(ti.getAQlClass().toString(), ", ") and
+  strictcount(ti.getResultVariable()) = k and
+  k > 1
+}

binary/ql/lib/semmle/code/binary/ast/ir/internal/Instruction1/Consistency.ql

@@ -0,0 +1,3 @@
+private import Instruction1
+import semmle.code.binary.ast.ir.internal.Consistency
+import StagedConsistencyInput<Instruction1>

binary/ql/lib/semmle/code/binary/ast/ir/internal/Instruction2/Consistency.ql

@@ -0,0 +1,3 @@
+private import Instruction2
+import semmle.code.binary.ast.ir.internal.Consistency
+import StagedConsistencyInput<Instruction2>