Binary/JVM: Autoformat.

Author: MathiasVP

binary/ql/lib/semmle/code/binary/ast/internal/JvmInstructions.qll

@@ -595,15 +595,13 @@ private string opcodeToMnemonic(int opcode) {
 // ============================================================================
 // Instruction Categories
 // ============================================================================
-
 /** A no-operation instruction. */
 class JvmNop extends @jvm_nop, JvmInstruction { }
 
 /** Pushes null onto the stack. */
 class JvmAconstNull extends @jvm_aconst_null, JvmLoadConstant { }
 
 // Load local variable instructions (abstract base classes)
-
 /** An instruction that loads a local variable onto the stack. */
 abstract class JvmLoadLocal extends JvmInstruction {
   abstract int getLocalVariableIndex();
@@ -998,11 +996,9 @@ class JvmLxor extends @jvm_lxor, JvmBitwiseInstruction { }
 
 // iinc
 class JvmIinc extends @jvm_iinc, JvmInstruction {
-  int getLocalVariableIndex() {
-    exists(int idx | jvm_operand_iinc(this, idx, _) | result = idx)
-  }
+  int getLocalVariableIndex() { jvm_operand_iinc(this, result, _) }
 
-  int getIncrement() { exists(int inc | jvm_operand_iinc(this, _, inc) | result = inc) }
+  int getIncrement() { jvm_operand_iinc(this, _, result) }
 }
 
 // Type conversions (abstract hierarchy)
@@ -1185,15 +1181,11 @@ class JvmReturnVoid extends @jvm_return, JvmReturn { }
 // Field access (abstract hierarchy)
 /** An instruction that accesses a field. */
 abstract class JvmFieldAccess extends JvmInstruction {
-  string getFieldClassName() {
-    exists(string cn | jvm_field_operand(this, cn, _, _) | result = cn)
-  }
+  string getFieldClassName() { jvm_field_operand(this, result, _, _) }
 
-  string getFieldName() { exists(string fn | jvm_field_operand(this, _, fn, _) | result = fn) }
+  string getFieldName() { jvm_field_operand(this, _, result, _) }
 
-  string getFieldDescriptor() {
-    exists(string fd | jvm_field_operand(this, _, _, fd) | result = fd)
-  }
+  string getFieldDescriptor() { jvm_field_operand(this, _, _, result) }
 
   /** Holds if this is a static field access. */
   predicate isStatic() { this instanceof JvmGetstatic or this instanceof JvmPutstatic }

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

@@ -29,13 +29,17 @@ module StagedConsistencyInput<InstructionSig Input> {
     not exists(i.getASuccessor())
   }
 
-  query predicate nonLocalSuccessor(Input::Function f1, Input::Function f2, Input::Instruction i, SuccessorType t) {
+  query predicate nonLocalSuccessor(
+    Input::Function f1, Input::Function f2, Input::Instruction i, SuccessorType t
+  ) {
     i.getEnclosingFunction() = f1 and
     i.getSuccessor(t).getEnclosingFunction() = f2 and
     f1 != f2
   }
 
-  query predicate successorMissingFunction(Input::Function f, Input::Instruction i1, Input::Instruction i2, SuccessorType t) {
+  query predicate successorMissingFunction(
+    Input::Function f, Input::Instruction i1, Input::Instruction i2, SuccessorType t
+  ) {
     i1.getEnclosingFunction() = f and
     i1.getSuccessor(t) = i2 and
     not exists(i2.getEnclosingFunction())

binary/ql/lib/semmle/code/binary/ast/ir/internal/Instruction0/TranslatedFunction.qll

@@ -110,7 +110,9 @@ class TranslatedX86Function extends TranslatedFunction, TTranslatedX86Function {
       else result = "Function_" + entry.getIndex()
   }
 
-  final override predicate isProgramEntryPoint() { entry instanceof Raw::X86ProgramEntryInstruction }
+  final override predicate isProgramEntryPoint() {
+    entry instanceof Raw::X86ProgramEntryInstruction
+  }
 
   final override predicate isPublic() { entry instanceof Raw::X86ExportedEntryInstruction }
 
@@ -234,7 +236,6 @@ class TranslatedCilMethod extends TranslatedFunction, TTranslatedCilMethod {
 // ============================================================================
 // JVM Translated Elements
 // ============================================================================
-
 class TranslatedJvmParameter extends TranslatedElement, TTranslatedJvmParameter {
   Raw::JvmParameter p;
 

binary/ql/lib/semmle/code/binary/ast/ir/internal/Instruction0/TranslatedInstruction.qll

@@ -2683,7 +2683,6 @@ class TranslatedCilLoadField extends TranslatedCilInstruction, TTranslatedCilLoa
 // ============================================================================
 // JVM Translated Instructions
 // ============================================================================
-
 /**
  * Base class for all translated JVM instructions.
  */
@@ -2773,9 +2772,7 @@ class TranslatedJvmInvoke extends TranslatedJvmInstruction, TTranslatedJvmInvoke
   override Instruction getEntry() { result = this.getInstruction(JvmCallTargetTag()) }
 
   override Variable getResultVariable() {
-    if instr.hasReturnValue()
-    then result = this.getTempVariable(JvmCallResultVarTag())
-    else none()
+    if instr.hasReturnValue() then result = this.getTempVariable(JvmCallResultVarTag()) else none()
   }
 
   final override Variable getStackElement(int i) {
@@ -2786,14 +2783,16 @@ class TranslatedJvmInvoke extends TranslatedJvmInstruction, TTranslatedJvmInvoke
     or
     // Rest of the stack has the arguments removed
     i > 0 and
-    result = getTranslatedJvmInstruction(instr.getABackwardPredecessor())
-        .getStackElement(i - 1 + instr.getNumberOfArguments())
+    result =
+      getTranslatedJvmInstruction(instr.getABackwardPredecessor())
+          .getStackElement(i - 1 + instr.getNumberOfArguments())
     or
     // If no return value, shift the indices
     i >= 0 and
     not instr.hasReturnValue() and
-    result = getTranslatedJvmInstruction(instr.getABackwardPredecessor())
-        .getStackElement(i + instr.getNumberOfArguments())
+    result =
+      getTranslatedJvmInstruction(instr.getABackwardPredecessor())
+          .getStackElement(i + instr.getNumberOfArguments())
   }
 }
 
@@ -2873,7 +2872,9 @@ class TranslatedJvmLoadLocal extends TranslatedJvmInstruction, TTranslatedJvmLoa
 
   override Instruction getEntry() { result = this.getInstruction(JvmLoadLocalTag()) }
 
-  override Variable getResultVariable() { result = this.getTempVariable(JvmLoadLocalResultVarTag()) }
+  override Variable getResultVariable() {
+    result = this.getTempVariable(JvmLoadLocalResultVarTag())
+  }
 
   final override Variable getStackElement(int i) {
     i = 0 and

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

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

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

@@ -9,7 +9,10 @@ newtype LocalVariableTag =
   X86RegisterTag(X86Register r) or
   StlocVarTag(int index) { any(CilStoreLocal stloc).getLocalVariableIndex() = index } or
   CilParameterVarTag(int index) { any(CilParameter p).getIndex() = index } or
-  JvmLocalVarTag(int index) { any(JvmLoadLocal load).getLocalVariableIndex() = index or any(JvmStoreLocal store).getLocalVariableIndex() = index } or
+  JvmLocalVarTag(int index) {
+    any(JvmLoadLocal load).getLocalVariableIndex() = index or
+    any(JvmStoreLocal store).getLocalVariableIndex() = index
+  } or
   JvmParameterVarTag(int index) { any(JvmParameter p).getSlotIndex() = index }
 
 string stringOfLocalVariableTag(LocalVariableTag tag) {

binary/ql/lib/semmle/code/binary/dataflow/DataFlow.qll

@@ -44,4 +44,4 @@ module DataFlow {
   predicate localFlow(Node::Node source, Node::Node sink) { localFlowStep*(source, sink) }
 
   import DataFlowMake<Location, DataFlowImpl::BinaryDataFlow>
-}
+}

binary/ql/src/VulnerableCalls/VulnerableCalls.qll

@@ -51,12 +51,12 @@ Function getADirectlyVulnerableMethod(string id) {
 /**
  * Holds if `stub` is an iterator/async stub method and `stateMachine` is its
  * corresponding state machine implementation (the MoveNext method).
- * 
+ *
  * Iterator/async methods in C# are compiled to:
  * 1. A stub method that creates a state machine object
  * 2. A nested class with a MoveNext method containing the actual implementation
- * 
- * The pattern is: method `Foo` in class `Bar` creates `Bar.<Foo>d__N` 
+ *
+ * The pattern is: method `Foo` in class `Bar` creates `Bar.<Foo>d__N`
  * and the impl is in `Bar.<Foo>d__N.MoveNext`
  */
 private predicate isStateMachineImplementation(Function stub, Function stateMachine) {
@@ -67,7 +67,7 @@ private predicate isStateMachineImplementation(Function stub, Function stateMach
     // The state machine type is nested in the same type as the stub
     // and named <MethodName>d__N
     stateMachineTypeName = stateMachine.getDeclaringType().getName() and
-    stateMachineTypeName.matches("<" + stubName + ">d__%" ) and
+    stateMachineTypeName.matches("<" + stubName + ">d__%") and
     // The state machine's declaring type's namespace should be the stub's type full name
     stateMachine.getDeclaringType().getNamespace() = stubType.getFullName()
   )
@@ -76,14 +76,12 @@ private predicate isStateMachineImplementation(Function stub, Function stateMach
 /**
  * Gets the state machine implementation for an iterator/async stub method.
  */
-Function getStateMachineImplementation(Function stub) {
-  isStateMachineImplementation(stub, result)
-}
+Function getStateMachineImplementation(Function stub) { isStateMachineImplementation(stub, result) }
 
 /**
  * Gets a method that transitively calls a vulnerable method.
  * This computes the transitive closure of the call graph.
- * 
+ *
  * Also handles iterator/async methods by linking stub methods to their
  * state machine implementations.
  */
@@ -105,7 +103,7 @@ Function getAVulnerableMethod(string id) {
     call.getStaticTarget() = getAVulnerableMethod(id)
   )
   or
-  // Iterator/async: if a state machine's MoveNext is vulnerable, 
+  // Iterator/async: if a state machine's MoveNext is vulnerable,
   // the stub method that creates it is also vulnerable
   exists(Function stateMachine |
     stateMachine = getAVulnerableMethod(id) and

binary/ql/src/VulnerableCalls/VulnerableCallsSummarize.ql

@@ -13,9 +13,7 @@ import semmle.code.binary.ast.ir.IR
  * Exports all methods that can reach vulnerable calls.
  * Output format matches the vulnerableCallModel extensible predicate for iterative analysis.
  */
-query predicate vulnerableCallModel(
-  string namespace, string className, string methodName, string id
-) {
+query predicate vulnerableCallModel(string namespace, string className, string methodName, string id) {
   ExportedVulnerableCalls::pathToVulnerableMethod(namespace, className, methodName, id)
 }
 
@@ -32,14 +30,11 @@ query predicate publicVulnerableCallModel(
  * Lists the direct vulnerable call sites with their enclosing method context.
  */
 query predicate vulnerableCallLocations(
-  VulnerableMethodCall call,
-  string callerNamespace,
-  string callerClassName,
-  string callerMethodName,
-  string targetFqn,
-  string id
+  VulnerableMethodCall call, string callerNamespace, string callerClassName,
+  string callerMethodName, string targetFqn, string id
 ) {
   call.getVulnerabilityId() = id and
-  call.getEnclosingFunction().hasFullyQualifiedName(callerNamespace, callerClassName, callerMethodName) and
+  call.getEnclosingFunction()
+      .hasFullyQualifiedName(callerNamespace, callerClassName, callerMethodName) and
   targetFqn = call.getTargetOperand().getAnyDef().(ExternalRefInstruction).getFullyQualifiedName()
 }

binary/ql/src/test.ql

@@ -1,4 +1,4 @@
 import semmle.code.binary.ast.ir.IR
 
 from Instruction i
-select i
+select i