SootUp

https://soot-oss.github.io/SootUp/latest/
Admin
SootUp is a modernized static analysis framework that transforms JVM bytecode to Jimple IR and...
Tokens:128,120
Snippets:1,422
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### start()

Source: https://soot-oss.github.io/SootUp/latest/api/qilin/util/MemoryWatcher.html

Starts the memory monitoring process.

```APIDOC
### Method
`void start()`

### Description
Begins the periodic monitoring of the process memory usage.
```

--------------------------------

### getStartingStmts()

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/core/graph/BackwardsControlFlowGraph.html

Retrieves the list of starting statements.

```APIDOC
### Method

`public @NonNull List<Stmt> getStartingStmts()`

Returns a list of all starting statements in the graph.
```

--------------------------------

### Java Source for Monitor Example

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Original Java source code corresponding to the monitor statements example.

```Java
package target.exercise1;

public class DemoClass {
  private int counter = 0;
  public int updateCounter(){
    synchronized (this) {
      counter = counter + 1;
    }
    return counter;
  }
}
```

--------------------------------

### Java Source for Return Example

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Original Java source code for the return statements example.

```Java
package target.exercise1;

public class DemoClass {
  public int increment(int x){
    return x + 1;
  }
  public void print(){
    System.out.println("Inside method print");
  }
}
```

--------------------------------

### Parse MethodSignature Examples

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/java/core/JavaIdentifierFactory.html

Examples of parsing MethodSignature strings using Soot and JavaDoc-like syntax.

```text

 <de.upb.sootup.signatures.Remove: de.upb.sootup.signatures.MethodSignature parseMethodSignature(java.lang.String)>
 <de.upb.sootup.signatures.Remove: de.upb.sootup.signatures.MethodSignature getMethodSignature(java.lang.String, de.upb.sootup.types.JavaClassType)>
 
```

```text

 de.upb.sootup.signatures.Remove#parseMethodSignature(java.lang.String): de.upb.sootup.signatures.MethodSignature
 de.upb.sootup.signatures.Remove#getMethodSignature(java.lang.String, de.upb.sootup.types.JavaClassType): de.upb.sootup.signatures.MethodSignature
 
```

--------------------------------

### JInvokeStmt Examples in Jimple, Java, and Bytecode

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Examples showing how method invocations are represented across Jimple, Java source, and Java bytecode.

```Jimple
public class target.exercise1.DemoClass extends java.lang.Object
{
  public void <init>()
  {
    target.exercise1.DemoClass this;
    this := @this: target.exercise1.DemoClass;
    specialinvoke this.<java.lang.Object: void <init>()>();
    return;
  }

  public void print(int)
  {
    target.exercise1.DemoClass this;
    int x, a;
    java.io.PrintStream $stack4, $stack6;

    this := @this: target.exercise1.DemoClass;
    x := @parameter0: int;

    a = virtualinvoke this.<target.exercise1.DemoClass: int increment(int)>(x);
    $stack4 = <java.lang.System: java.io.PrintStream out>;
    virtualinvoke $stack4.<java.io.PrintStream: void println(int)>(a);

    a = virtualinvoke this.<target.exercise1.DemoClass: int increment(int)>(a);
    $stack6 = <java.lang.System: java.io.PrintStream out>;
    virtualinvoke $stack6.<java.io.PrintStream: void println(int)>(a);

    return;
  }

  public int increment(int)
  {
    int x, $stack2;
    target.exercise1.DemoClass this;

    this := @this: target.exercise1.DemoClass;
    x := @parameter0: int;

    $stack2 = x + 1;
    return $stack2;
  }
}
/*
  "specialinvoke this.<java.lang.Object: void <init>()>()", 
  "virtualinvoke this.<target.exercise1.DemoClass: int increment(int)>(x)", 
  "virtualinvoke this.<target.exercise1.DemoClass: int increment(int)>(a)" 
    are JInvokeStmts.
*/
```

```Java
package target.exercise1;

public class DemoClass {
  public void print(int x){
    int a = increment(x);
    System.out.println(a);
    a = increment(a);
    System.out.println(a);
  }
  public int increment(int x){
    return x + 1;
  }
}
```

```Bytecode
// class version 52.0 (52)
// access flags 0x21
public class target/exercise1/DemoClass {

// compiled from: DemoClass.java

// access flags 0x1
public <init>()V
  L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
  L1
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

// access flags 0x1
public print(I)V
  L0
    LINENUMBER 5 L0
    ALOAD 0
    ILOAD 1
    INVOKEVIRTUAL target/exercise1/DemoClass.increment (I)I
    ISTORE 2
  L1
    LINENUMBER 6 L1
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ILOAD 2
    INVOKEVIRTUAL java/io/PrintStream.println (I)V
  L2
    LINENUMBER 7 L2
    ALOAD 0
    ILOAD 2
    INVOKEVIRTUAL target/exercise1/DemoClass.increment (I)I
    ISTORE 2
  L3
    LINENUMBER 8 L3
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ILOAD 2
    INVOKEVIRTUAL java/io/PrintStream.println (I)V
  L4
    LINENUMBER 9 L4
    RETURN
  L5
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L5 0
    LOCALVARIABLE x I L0 L5 1
    LOCALVARIABLE a I L1 L5 2
    MAXSTACK = 2
    MAXLOCALS = 3

// access flags 0x1
public increment(I)I
  L0
    LINENUMBER 11 L0
    ILOAD 1
    ICONST_1
    IADD
    IRETURN
  L1
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L1 0
    LOCALVARIABLE x I L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2
}
```

--------------------------------

### Parse MethodSubSignature Examples

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/java/core/JavaIdentifierFactory.html

Examples of parsing MethodSubSignature strings using Soot and JavaDoc-like syntax.

```text

 >de.upb.sootup.signatures.MethodSignature parseMethodSignature(java.lang.String)>
 >de.upb.sootup.signatures.MethodSignature getMethodSignature(java.lang.String, de.upb.sootup.types.JavaClassType)>
 
```

```text

 #parseMethodSignature(java.lang.String): de.upb.sootup.signatures.MethodSignature
 #getMethodSignature(java.lang.String, de.upb.sootup.types.JavaClassType): de.upb.sootup.signatures.MethodSignature
 
```

--------------------------------

### Parse FieldSignature Examples

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/java/core/JavaIdentifierFactory.html

Examples of parsing FieldSignature strings using Soot and JavaDoc-like syntax.

```text

 <de.upb.sootup.signatures.Remove: de.upb.sootup.signatures.Remove INSTANCE>
 
```

```text

 de.upb.sootup.signatures.Remove#INSTANCE: de.upb.sootup.signatures.Remove
 
```

--------------------------------

### getStartingStmt()

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/core/graph/BackwardsControlFlowGraph.html

Retrieves the starting statement of the graph.

```APIDOC
### Method

`public Stmt getStartingStmt()`

Returns the starting statement of the backwards control flow graph.
```

--------------------------------

### JAssignStmt Example in Jimple

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Example demonstrating assignment statements in Jimple, including field references and local variable assignments.

```Jimple
public class target.exercise1.DemoClass extends java.lang.Object
{
  public void <init>()
  {
    target.exercise1.DemoClass this;
    this := @this: target.exercise1.DemoClass;
    specialinvoke this.<java.lang.Object: void <init>()>();
    this.<target.exercise1.DemoClass: int counter> = 0;
    return;
  }

  public int updateCounter()
  {
    target.exercise1.DemoClass this;
    int $stack1, $stack2, $stack3;

    this := @this: target.exercise1.DemoClass;

    $stack1 = this.<target.exercise1.DemoClass: int counter>;
    $stack2 = $stack1 + 1;
    this.<target.exercise1.DemoClass: int counter> = $stack2;
    $stack3 = this.<target.exercise1.DemoClass: int counter>;
```

--------------------------------

### Build SootUp from Source

Source: https://soot-oss.github.io/SootUp/latest/installation

Clone the repository and install it into your local Maven repository to use the latest changes.

```bash
git clone https://github.com/secure-software-engineering/SootUp.git
mvn install
```

--------------------------------

### Bytecode for Monitor Example

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Compiled Java bytecode showing monitor enter and exit instructions.

```Bytecode
// class version 52.0 (52)
// access flags 0x21
public class target/exercise1/DemoClass {

// compiled from: DemoClass.java

// access flags 0x2
private I counter

// access flags 0x1
public <init>()V
  L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
  L1
    LINENUMBER 4 L1
    ALOAD 0
    ICONST_0
    PUTFIELD target/exercise1/DemoClass.counter : I
    RETURN
  L2
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L2 0
    MAXSTACK = 2
    MAXLOCALS = 1

// access flags 0x1
public updateCounter()I
    TRYCATCHBLOCK L0 L1 L2 null
    TRYCATCHBLOCK L2 L3 L2 null
  L4
    LINENUMBER 6 L4
    ALOAD 0
    DUP
    ASTORE 1
    MONITORENTER
  L0
    LINENUMBER 7 L0
    ALOAD 0
    ALOAD 0
    GETFIELD target/exercise1/DemoClass.counter : I
    ICONST_1
    IADD
    PUTFIELD target/exercise1/DemoClass.counter : I
  L5
    LINENUMBER 8 L5
    ALOAD 1
    MONITOREXIT
  L1
    GOTO L6
  L2
    FRAME FULL [target/exercise1/DemoClass java/lang/Object] 
      [java/lang/Throwable]
    ASTORE 2
    ALOAD 1
    MONITOREXIT
  L3
    ALOAD 2
    ATHROW
  L6
    LINENUMBER 9 L6
    FRAME CHOP 1
    ALOAD 0
    GETFIELD target/exercise1/DemoClass.counter : I
    IRETURN
  L7
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L4 L7 0
    MAXSTACK = 3
    MAXLOCALS = 3
}
```

--------------------------------

### newAndStart(String name)

Source: https://soot-oss.github.io/SootUp/latest/api/qilin/util/Stopwatch.html

Creates a new Stopwatch instance and starts the timer immediately.

```APIDOC
### Method
`public static Stopwatch newAndStart(String name)`

### Description
Creates a new instance of Stopwatch and begins tracking time.

### Parameters
- **name** (String) - The identifier for the stopwatch instance.
```

--------------------------------

### initialize(List<MethodSignature> entryPoints)

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/callgraph/CallGraphAlgorithm.html

Initializes and starts the call graph algorithm using a provided list of entry points.

```APIDOC
## initialize(List<MethodSignature> entryPoints)

### Description
Initializes and starts the call graph algorithm with given entry points. The entry points define the start methods in the call graph algorithm.

### Parameters
- **entryPoints** (List<MethodSignature>) - Required - A list of entry points for the call graph algorithm.

### Returns
- **CallGraph** - A generated call graph with every entry point as a starting point.
```

--------------------------------

### Return Statements in Jimple

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Examples of JReturnStmt and JReturnVoidStmt in Jimple.

```Jimple
public class target.exercise1.DemoClass extends java.lang.Object
{
  public void <init>()
  {
    target.exercise1.DemoClass this;
    this := @this: target.exercise1.DemoClass;
    specialinvoke this.<java.lang.Object: void <init>()>();
    return;
  }

  public int increment(int)
  {
    int x, $stack2;
    target.exercise1.DemoClass this;

    this := @this: target.exercise1.DemoClass;
    x := @parameter0: int;

    $stack2 = x + 1;
    return $stack2;
  }

  public void print()
  {
    java.io.PrintStream $stack1;
    target.exercise1.DemoClass this;

    this := @this: target.exercise1.DemoClass;
    $stack1 = <java.lang.System: java.io.PrintStream out>;
    virtualinvoke $stack1.<java.io.PrintStream: 
      void println(java.lang.String)>("Inside method print");
    return;
  }
}
/*
  "return $stack2" is JReturnStmt.
  "return" is JReturnVoidStmt.
*/
```

--------------------------------

### JEnterMonitorStmt and JExitMonitorStmt Example

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Illustrates how synchronized blocks are marked using monitor statements in Jimple.

```jimple
public class target.exercise1.DemoClass extends java.lang.Object
{
  public void <init>()
  {
    target.exercise1.DemoClass this;
    this := @this: target.exercise1.DemoClass;
    specialinvoke this.<java.lang.Object: void <init>()>();
    this.<target.exercise1.DemoClass: int counter> = 0;
    return;
  }

  public int updateCounter()
  {
    target.exercise1.DemoClass this;
    int $stack4, $stack5, $stack7;
    java.lang.Throwable $stack8;

    this := @this: target.exercise1.DemoClass;

    entermonitor this;

    label1:
      $stack4 = this.<target.exercise1.DemoClass: int counter>;
      $stack5 = $stack4 + 1;
      this.<target.exercise1.DemoClass: int counter> = $stack5;

      exitmonitor this;

    label2:
      goto label5;
```

--------------------------------

### Initialize and Populate a MutableControlFlowGraph

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/core/graph/ControlFlowGraph.html

Demonstrates the basic setup of a mutable control flow graph by defining entry points, adding nodes, and creating edges between statements.

```java
  Stmt stmt1, stmt2;
  ...
  MutableControlFlowGraph graph = new MutableBlockControlFlowGraph();
  graph.setEntryPoint(stmt1);
  graph.addNode(stmt1);
  graph.addNode(stmt2);
  graph.putEdge(stmt1, stmt2);
```

--------------------------------

### JIdentityStmt Example

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Shows how JIdentityStmt handles implicit assignments like 'this' and method parameters.

```jimple
public class target.exercise1.DemoClass extends java.lang.Object
{
  public void <init>()
  {
    target.exercise1.DemoClass this;
    this := @this: target.exercise1.DemoClass;
    specialinvoke this.<java.lang.Object: void <init>()>();
    return;
  }

  public void DemoClass(int)
  {
    target.exercise1.DemoClass this;
    int counter;

    this := @this: target.exercise1.DemoClass;
    counter := @parameter0: int;
    this.<target.exercise1.DemoClass: int counter> = counter;
    return;
  }
}
/*
  "this := @this: target.exercise1.DemoClass" and 
    "counter := @parameter0: int" are JIdentityStmts
*/
```

```java
package target.exercise1;

public class DemoClass {
  private int counter;
  public void DemoClass(int counter){
    this.counter = counter;
  }
}
```

```bytecode
// class version 52.0 (52)
// access flags 0x21
public class target/exercise1/DemoClass {

// compiled from: DemoClass.java

// access flags 0x2
private I counter

// access flags 0x1
public <init>()V
  L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
  L1
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

// access flags 0x1
public DemoClass(I)V
  L0
    LINENUMBER 6 L0
    ALOAD 0
    ILOAD 1
    PUTFIELD target/exercise1/DemoClass.counter : I
  L1
    LINENUMBER 7 L1
    RETURN
  L2
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L2 0
    LOCALVARIABLE counter I L0 L2 1
    MAXSTACK = 2
    MAXLOCALS = 2
}
```

--------------------------------

### JAssignStmt Example

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Demonstrates JAssignStmt usage in Jimple, where assignments are explicitly represented.

```java
package target.exercise1;

public class DemoClass {
  private int counter = 0;
  public int updateCounter(){
    counter = counter + 1;
    return counter;
  }
}
```

```bytecode
// class version 52.0 (52)
// access flags 0x21
public class target/exercise1/DemoClass {

// compiled from: DemoClass.java

// access flags 0x2
private I counter

// access flags 0x1
public <init>()V
  L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
  L1
    LINENUMBER 4 L1
    ALOAD 0
    ICONST_0
    PUTFIELD target/exercise1/DemoClass.counter : I
    RETURN
  L2
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L2 0
    MAXSTACK = 2
    MAXLOCALS = 1

// access flags 0x1
public updateCounter()I
  L0
    LINENUMBER 6 L0
    ALOAD 0
    ALOAD 0
    GETFIELD target/exercise1/DemoClass.counter : I
    ICONST_1
    IADD
    PUTFIELD target/exercise1/DemoClass.counter : I
  L1
    LINENUMBER 7 L1
    ALOAD 0
    GETFIELD target/exercise1/DemoClass.counter : I
    IRETURN
  L2
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L2 0
    MAXSTACK = 3
    MAXLOCALS = 1
}
```

--------------------------------

### Global Copy Propagation Example

Source: https://soot-oss.github.io/SootUp/latest/bodyinterceptors

Demonstrates the structure of a code segment where copy propagation can be applied.

```text
1
2
3
```

```text
a = b;
...
c = use(a); // a, b, c are local variables
```

--------------------------------

### initialize()

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/callgraph/CallGraphAlgorithm.html

Initializes and starts the call graph algorithm without explicit entry points, defaulting to all main methods.

```APIDOC
## initialize()

### Description
Initializes and starts the call graph algorithm without given entry points. Before the algorithm is started, all main methods are searched and set as entry points.

### Returns
- **CallGraph** - A generated call graph with every main class as a starting point.
```

--------------------------------

### Constant Propagation Example

Source: https://soot-oss.github.io/SootUp/latest/bodyinterceptors

Demonstrates the structure of a code segment where constant propagation can be applied.

```text
1
2
3
```

```text
a = const;
...
b = use(a); // a, b are local variables, const is a constant
```

--------------------------------

### CastAndReturnInliner Transformation Example

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/interceptors/CastAndReturnInliner.html

Shows the transformation logic where a cast followed by a return is simplified to a direct return.

```java
 a = ...;
 goto label0;
 label0:
 b = (B) a;
 return b;
```

```java
 a = ...;
 return a;
```

--------------------------------

### Bytecode Representation of Switch

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

The compiled bytecode representation of the switch example.

```Bytecode
// class version 52.0 (52)
// access flags 0x21
public class target/exercise1/DemoClass {

// compiled from: DemoClass.java

// access flags 0x1
public <init>()V
  L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
  L1
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

// access flags 0x1
public switchExample(I)V
  L0
    LINENUMBER 5 L0
    ILOAD 1
    LOOKUPSWITCH
    1: L1
    2: L2
    default: L3
  L1
    LINENUMBER 7 L1
    FRAME SAME
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC "Input 1"
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
  L4
    LINENUMBER 8 L4
    GOTO L5
  L2
    LINENUMBER 11 L2
    FRAME SAME
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC "Input 2"
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
  L6
    LINENUMBER 12 L6
    GOTO L5
  L3
    LINENUMBER 15 L3
    FRAME SAME
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC "Input more than 2"
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
  L5
    LINENUMBER 19 L5
    FRAME SAME
    RETURN
  L7
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L7 0
    LOCALVARIABLE x I L0 L7 1
    MAXSTACK = 2
    MAXLOCALS = 2
}
```

--------------------------------

### HelloWorld Jimple Representation

Source: https://soot-oss.github.io/SootUp/latest/jimple

Example of a HelloWorld class represented in Jimple format.

```Jimple
public class HelloWorld extends java.lang.Object
{
  public void <init>()
  {
    HelloWorld r0;
    r0 := @this: HelloWorld;
    specialinvoke r0.<java.lang.Object: void <init>()>();
    return;
  }

  public static void main(java.lang.String[])
  {
    java.lang.String[] r0;
    java.io.PrintStream r1;

    r0 := @parameter0: java.lang.String[];
    r1 = <java.lang.System: java.io.PrintStream out>;
    virtualinvoke r1.<java.io.PrintStream: 
    void println(java.lang.String)>("Hello world!");
    return;
  }
}
```

--------------------------------

### Bytecode for voidMethod

Source: https://soot-oss.github.io/SootUp/latest/jimple-types

The compiled bytecode for the voidMethod example.

```Java Bytecode
// class version 52.0 (52)
// access flags 0x21
public class target/exercise1/DemoClass {

// compiled from: DemoClass.java

// access flags 0x1
public <init>()V
  L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
  L1
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

// access flags 0x1
public voidMethod()V
  L0
    LINENUMBER 5 L0
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC "In voidMethod()."
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
  L1
    LINENUMBER 6 L1
    RETURN
  L2
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L2 0
    MAXSTACK = 2
    MAXLOCALS = 1
}
```

--------------------------------

### JParameterRef Example

Source: https://soot-oss.github.io/SootUp/latest/jimple-values

Represents method parameters identified by index.

```text
1
2
```

```text
i0 := @parameter0
i1 := @parameter1
```

--------------------------------

### Define Entry Methods for Call Graph Analysis

Source: https://soot-oss.github.io/SootUp/latest/callgraphs

Methods for specifying the starting point of call graph construction using SootUp and Soot APIs.

```java
JavaClassType classTypeA = view.getIdentifierFactory().getClassType("packageNameA.A");

MethodSignature entryMethodSignature =
    view.getIdentifierFactory()
        .getMethodSignature(
            classTypeA,
            "calc",
            VoidType.getInstance(),
            Collections.singletonList(classTypeA)
        );
```

```java
String methodSigStr = "<packageNameA.A: void calc(packageNameA.A)";
MethodSignature entryMethodSignature = view
                    .getIdentifierFactory().parseMethodSignature(methodSigStr));
```

```java
String targetTestClassName = "packageNameA.A";
SootMethod src = Scene.v().getSootClass(targetTestClassName).getMethodByName("doStuff");
```

--------------------------------

### HelloWorld Java Source Code

Source: https://soot-oss.github.io/SootUp/latest/jimple

The original Java source code corresponding to the HelloWorld Jimple example.

```Java
public class HelloWorld {

  public HelloWorld() {

  }

  public static void main(String[] var0) {
    System.out.println("Hello World!");
  }

}
```

--------------------------------

### Analyze Android APKs with Platform Libraries

Source: https://soot-oss.github.io/SootUp/latest/analysisinput

Advanced setup that includes the specific android.jar for the target SDK version to ensure complete framework class resolution.

```java
// The androidPlatformsPath parameter points to the Android platforms directory
// containing Android system libraries (android.jar files) for different API levels.
// This directory is required to resolve method calls and class references that are not defined
// in the APK itself, but are part of the Android system libraries.
// 
// The Android platforms directory can be obtained from:
// https://github.com/Sable/android-platforms

String apkPath = "path/to/app.apk";
String androidPlatformsPath = "path/to/android-platforms";

// Create AndroidVersionInfo instance to detect the APK's target API level
AndroidVersionInfo androidVersionInfo = new AndroidVersionInfo(
    Paths.get(apkPath), 
    androidPlatformsPath);

ApkAnalysisInputLocation apkInputLocation = new ApkAnalysisInputLocation(
    Paths.get(apkPath),
    androidPlatformsPath,
    androidVersionInfo,
    DexBodyInterceptors.Default.bodyInterceptors());

// Additionally, include the specific android.jar for the APK's target SDK version
// to ensure all Android framework classes are available during analysis
int apiVersion = androidVersionInfo.getApi_version();
String androidJarPath = androidPlatformsPath 
    + File.separator + "android-" + apiVersion 
    + File.separator + "android.jar";

JavaClassPathAnalysisInputLocation androidJarInputLocation = 
    new JavaClassPathAnalysisInputLocation(androidJarPath);

// Combine both input locations for complete analysis
JavaView view = new JavaView(List.of(apkInputLocation, androidJarInputLocation));
```

--------------------------------

### Initialize and Use Spark Analysis

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/spark/Spark.html

Demonstrates how to build a Spark instance with specific options and retrieve the resulting points-to analysis and call graph.

```java
   Spark spark = Spark.builder()
       .view(view)
       .entryPoints(List.of(mainSig))
       .sparkOptions(SparkOptions.builder().onFlyCallGraph(true).build())
       .build();
   PointsToAnalysis pta = spark.getPointsToAnalysis();
   CallGraph cg = spark.getCallGraph();
```

--------------------------------

### JThrowStmt Example

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

An example of a JThrowStmt within a Jimple method body.

```Jimple
// access flags 0x1
public divideExample(II)V
  L0
    LINENUMBER 5 L0
    ILOAD 2
    IFNE L1
  L2
    LINENUMBER 6 L2
    NEW java/lang/RuntimeException
    DUP
    LDC "Divide by zero error"
    INVOKESPECIAL java/lang/RuntimeException.<init> 
      (Ljava/lang/String;)V
    ATHROW
  L1
    LINENUMBER 8 L1
    FRAME SAME
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    NEW java/lang/StringBuilder
    DUP
    INVOKESPECIAL java/lang/StringBuilder.<init> ()V
    LDC "Divide result : "
    INVOKEVIRTUAL java/lang/StringBuilder.append 
      (Ljava/lang/String;)Ljava/lang/StringBuilder;
    ILOAD 1
    ILOAD 2
    IDIV
    INVOKEVIRTUAL java/lang/StringBuilder.append 
      (I)Ljava/lang/StringBuilder;
    INVOKEVIRTUAL java/lang/StringBuilder.toString 
      ()Ljava/lang/String;
    INVOKEVIRTUAL java/io/PrintStream.println 
      (Ljava/lang/String;)V
  L3
    LINENUMBER 9 L3
    RETURN
  L4
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L4 0
    LOCALVARIABLE x I L0 L4 1
    LOCALVARIABLE y I L0 L4 2
    MAXSTACK = 4
    MAXLOCALS = 3
}
```

--------------------------------

### all()

Source: https://soot-oss.github.io/SootUp/latest/api/qilin/core/builder/FakeMainFactory.EntryPoints.html

Retrieves all entry points.

```APIDOC
### Method
public List<SootMethod> all()

### Description
Returns all the entry points.

### Returns
- List<SootMethod> - A list containing all entry points.
```

--------------------------------

### initializeDexFile(File file)

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/apk/frontend/dexpler/DexResolver.html

Initializes a DEX file and returns its corresponding wrapper.

```APIDOC
## DexLibWrapper initializeDexFile(File file)

### Description
Initializes the provided DEX file and returns a DexLibWrapper for further processing.

### Parameters
- **file** (File) - The DEX file to be initialized.

### Returns
- **DexLibWrapper** - The wrapper object for the initialized DEX file.
```

--------------------------------

### FakeMainFactory.EntryPoints.all()

Source: https://soot-oss.github.io/SootUp/latest/api/index-all.html

Retrieves all entry points defined in the factory.

```APIDOC
## all()

### Description
Returns all the entry points.
```

--------------------------------

### JCaughtExceptionRef Example

Source: https://soot-oss.github.io/SootUp/latest/jimple-values

Represents the value of a caught exception.

```text
1
```

```text
@caughtexception
```

--------------------------------

### JThisRef Example

Source: https://soot-oss.github.io/SootUp/latest/jimple-values

Represents the this pointer of the current class.

```text
1
```

```text
@this: package.fruit.Banana
```

--------------------------------

### JArrayRef Usage

Source: https://soot-oss.github.io/SootUp/latest/jimple-values

Examples of referencing array positions.

```text
1
2
```

```text
$arr[1] = 42;
$anotherLocal = arr[99];
```

--------------------------------

### removeAllEdgesOutOf

Source: https://soot-oss.github.io/SootUp/latest/api/qilin/core/builder/callgraph/OnFlyCallGraph.html

Removes all outgoing edges starting from a specific unit.

```APIDOC
## removeAllEdgesOutOf(Stmt u)

### Description
Removes all outgoing edges that start at the given unit.

### Parameters
- **u** (Stmt) - Required - The unit from which to remove all outgoing edges.
```

--------------------------------

### clinits()

Source: https://soot-oss.github.io/SootUp/latest/api/qilin/core/builder/FakeMainFactory.EntryPoints.html

Retrieves a list of all static initializers.

```APIDOC
### Method
public List<SootMethod> clinits()

### Description
Returns a list of all static initializers.

### Returns
- List<SootMethod> - A list of static initializers.
```

--------------------------------

### run()

Source: https://soot-oss.github.io/SootUp/latest/api/qilin/pta/toolkits/debloaterx/DebloaterX.html

Executes the debloating process.

```APIDOC
### Method
`void run()`

### Description
Executes the main debloating logic based on the PTA context provided during initialization.
```

--------------------------------

### JIfStmt Bytecode

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Compiled bytecode corresponding to the JIfStmt example.

```Bytecode
// class version 52.0 (52)
// access flags 0x21
public class target/exercise1/DemoClass {

// compiled from: DemoClass.java

// access flags 0x1
public <init>()V
  L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
  L1
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

// access flags 0x9
public static sampleMethod(I)V
  L0
    LINENUMBER 5 L0
    ILOAD 0
    ICONST_2
    IREM
    IFNE L1
  L2
    LINENUMBER 6 L2
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC "Even"
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
    GOTO L3
  L1
    LINENUMBER 8 L1
    FRAME SAME
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC "Odd"
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
  L3
    LINENUMBER 10 L3
    FRAME SAME
    RETURN
  L4
    LOCALVARIABLE x I L0 L4 0
    MAXSTACK = 2
    MAXLOCALS = 1
}
```

--------------------------------

### JGotoStmt Bytecode

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Compiled bytecode corresponding to the JGotoStmt example.

```Bytecode
// class version 52.0 (52)
// access flags 0x21
public class target/exercise1/DemoClass {

// compiled from: DemoClass.java

// access flags 0x1
public <init>()V
  L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
  L1
    LOCALVARIABLE this Ltarget/exercise1/DemoClass; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

// access flags 0x9
public static sampleMethod()V
  L0
    LINENUMBER 6 L0
    ICONST_0
    ISTORE 0
  L1
    FRAME APPEND [I]
    ILOAD 0
    ICONST_5
    IF_ICMPGE L2
  L3
    LINENUMBER 7 L3
    ILOAD 0
    ICONST_3
    IF_ICMPNE L4
  L5
    LINENUMBER 8 L5
    GOTO L2
  L4
    LINENUMBER 6 L4
    FRAME SAME
    IINC 0 1
    GOTO L1
  L2
    LINENUMBER 11 L2
    FRAME CHOP 1
    RETURN
    LOCALVARIABLE i I L1 L2 0
    MAXSTACK = 2
    MAXLOCALS = 1
}
```

--------------------------------

### application()

Source: https://soot-oss.github.io/SootUp/latest/api/qilin/core/builder/FakeMainFactory.EntryPoints.html

Retrieves a list of application entry points, excluding those invoked implicitly by the VM.

```APIDOC
### Method
public List<SootMethod> application()

### Description
Returns only the application entry points, not including entry points invoked implicitly by the VM.

### Returns
- List<SootMethod> - A list of application entry points.
```

--------------------------------

### Local Variable Example

Source: https://soot-oss.github.io/SootUp/latest/jimple-values

A simple representation of a local variable.

```text
1
```

```text
i0
```

--------------------------------

### initialize()

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/apk/frontend/dexpler/DexLibWrapper.html

Initializes the DexLibWrapper instance.

```APIDOC
### Method: initialize()

#### Description
Initializes the wrapper to prepare for class retrieval.
```

--------------------------------

### JIfStmt Jimple Representation

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Example of conditional jumps in Jimple code.

```Jimple
public class target.exercise1.DemoClass extends java.lang.Object
{
   public void <init>()
  {
    target.exercise1.DemoClass this;
    this := @this: target.exercise1.DemoClass;
    specialinvoke this.<java.lang.Object: void <init>()>();
    return;
  }

  public static void sampleMethod(int)
  {
    int x, $stack1;
    java.io.PrintStream $stack2, $stack3;

    x := @parameter0: int;

    $stack1 = x % 2;
    if $stack1 != 0 goto label1;

    $stack3 = <java.lang.System: java.io.PrintStream out>;
    virtualinvoke $stack3.<java.io.PrintStream: 
      void println(java.lang.String)>("Even");
    goto label2;

    label1:
      $stack2 = <java.lang.System: java.io.PrintStream out>;
      virtualinvoke $stack2.<java.io.PrintStream: 
        void println(java.lang.String)>("Odd");

    label2:
      return;
  }
}
/*
  For statement "if $stack1 != 0 goto label1;", 
  we have an instance of JIfStmt :
    "if $stack1 != 0 goto $stack2 
        = <java.lang.System:java.io.PrintStream out>".
*/
```

--------------------------------

### JGotoStmt Jimple Representation

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Example of unconditional jumps in Jimple code.

```Jimple
public class target.exercise1.DemoClass extends java.lang.Object
{
  public void <init>()
  {
    target.exercise1.DemoClass this;
    this := @this: target.exercise1.DemoClass;
    specialinvoke this.<java.lang.Object: void <init>()>();
    return;
  }
  public static void sampleMethod()
  {
    int i;
    i = 0;

    label1:
      if i >= 5 goto label3;
      if i != 3 goto label2;
      goto label3;

    label2:
      i = i + 1;
      goto label1;

    label3:
      return;
  }
}
/*
  Here for statements "goto label3;" and "goto label1;", 
  we have two instances of JGotoStmt : 
    "goto[?=return]" and "goto[?=(branch)]".
*/
```

--------------------------------

### getStaticInitializerSignature(ClassType declaringClassSignature)

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/java/core/JavaIdentifierFactory.html

Gets the static initializer method signature.

```APIDOC
## getStaticInitializerSignature(ClassType declaringClassSignature)

### Description
Gets the static initializer method signature.

### Parameters
- **declaringClassSignature** (ClassType) - The declaring class signature

### Returns
- **MethodSignature** - The static initializer method signature
```

--------------------------------

### create(@NonNull Path path, @NonNull List<BodyInterceptor> bodyInterceptors, @NonNull View view)

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/jimple/frontend/ClassVisitorFactory.html

Creates a new ClassVisitor instance based on the provided file path, body interceptors, and view configuration.

```APIDOC
## create

### Description
Creates a new ClassVisitor instance. This method is part of a functional interface and can be implemented via lambda expressions or method references.

### Signature
`@NonNull ClassVisitor create(@NonNull Path path, @NonNull List<BodyInterceptor> bodyInterceptors, @NonNull View view)`

### Parameters
- **path** (Path) - Required - The file path to the class.
- **bodyInterceptors** (List<BodyInterceptor>) - Required - A list of interceptors to apply to the class body.
- **view** (View) - Required - The view configuration for the class visitor.

### Returns
- **ClassVisitor** - A non-null ClassVisitor instance.
```

--------------------------------

### PostOrderBlockIterator(BasicBlock<?> startNode)

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/core/graph/PostOrderBlockIterator.html

Constructs a new PostOrderBlockIterator starting from the specified BasicBlock.

```APIDOC
## Constructor: PostOrderBlockIterator

### Description
Initializes a new instance of the PostOrderBlockIterator starting at the provided startNode.

### Signature
`public PostOrderBlockIterator(@NonNull BasicBlock<?> startNode)`

### Parameters
- **startNode** (BasicBlock<?>) - The starting block for the post-order iteration.
```

--------------------------------

### getOp()

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/core/jimple/javabytecode/stmt/JEnterMonitorStmt.html

Retrieves the immediate value associated with the monitor entry.

```APIDOC
## Method: getOp()

### Description
Returns the immediate value that is being synchronized on by this monitor entry statement.

### Returns
- **Immediate** - The immediate value.
```

--------------------------------

### ReversePostOrderBlockIterator(BasicBlock<?> startNode)

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/core/graph/ReversePostOrderBlockIterator.html

Constructs a new iterator starting from the specified block.

```APIDOC
## Constructor: ReversePostOrderBlockIterator

### Description
Initializes a new instance of the ReversePostOrderBlockIterator starting at the provided startNode.

### Signature
`public ReversePostOrderBlockIterator(@NonNull BasicBlock<?> startNode)`

### Parameters
- **startNode** (BasicBlock<?>) - The starting block for the iteration.
```

--------------------------------

### accept(ImmediateVisitor v)

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/core/jimple/common/Local.html

Accepts a visitor to process the local variable.

```APIDOC
## accept(ImmediateVisitor v)

### Description
Called when this object is visited by an ImmediateVisitor.

### Parameters
- **v** (ImmediateVisitor) - Required - The visitor processing this object.

### Returns
- **ImmediateVisitor** - The visitor after processing.
```

--------------------------------

### JSwitchStmt Representation

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Example of a JLookupSwitchStmt in Jimple and its corresponding Java source code.

```Jimple
public class target.exercise1.DemoClass extends java.lang.Object
{
  public void <init>()
  {
    target.exercise1.DemoClass this;
    this := @this: target.exercise1.DemoClass;
    specialinvoke this.<java.lang.Object: void <init>()>();
    return;
  }

  public void switchExample(int)
  {
    int x;
    java.io.PrintStream $stack2, $stack3, $stack4;
    target.exercise1.DemoClass this;

    this := @this: target.exercise1.DemoClass;
    x := @parameter0: int;

    lookupswitch(x)
    {
      case 1: goto label1;
      case 2: goto label2;
      default: goto label3;
    };

    label1:
      $stack3 = <java.lang.System: java.io.PrintStream out>;
      virtualinvoke $stack3.<java.io.PrintStream: 
        void println(java.lang.String)>("Input 1");
      goto label4;

    label2:
      $stack2 = <java.lang.System: java.io.PrintStream out>;
      virtualinvoke $stack2.<java.io.PrintStream: 
        void println(java.lang.String)>("Input 2");
      goto label4;

    label3:
      $stack4 = <java.lang.System: java.io.PrintStream out>;
      virtualinvoke $stack4.<java.io.PrintStream: 
        void println(java.lang.String)>("Input more than 2");

    label4:
      return;
  }
}
/*
  Here for below statement:
    lookupswitch(x)
      {
        case 1: goto label1;
        case 2: goto label2;
        default: goto label3;
      };

  we have an instance of JLookupSwitchStmt :
    lookupswitch(x) 
      {     
        case 1: goto $stack3 
                        = <java.lang.System: java.io.PrintStream out>;     
        case 2: goto $stack2 
                        = <java.lang.System: java.io.PrintStream out>;     
        default: goto $stack4 
                        = <java.lang.System: java.io.PrintStream out>; 
      }
*/
```

```Java
package target.exercise1;

public class DemoClass {
  public void switchExample(int x){
    switch (x){
      case 1:
        System.out.println("Input 1");
        break;

      case 2:
        System.out.println("Input 2");
        break;

      default:
        System.out.println("Input more than 2");
        break;

    }
  }
}
```

--------------------------------

### create(Path path, List<BodyInterceptor> bodyInterceptors, View view)

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/jimple/frontend/EagerClassVisitorFactory.html

Creates a ClassVisitor instance based on the provided path, body interceptors, and view.

```APIDOC
### Method
`create(@NonNull Path path, @NonNull List<BodyInterceptor> bodyInterceptors, @NonNull View view)`

### Description
Creates a `ClassVisitor` instance using the specified file path, a list of body interceptors, and the current view context.

### Parameters
- **path** (Path) - Required - The path to the class file.
- **bodyInterceptors** (List<BodyInterceptor>) - Required - A list of interceptors to apply to the method bodies.
- **view** (View) - Required - The view context for the visitor.

### Returns
- **ClassVisitor** - A new instance of a `ClassVisitor`.
```

--------------------------------

### Java Source for voidMethod

Source: https://soot-oss.github.io/SootUp/latest/jimple-types

The original Java source code for the voidMethod example.

```Java
package target.exercise1;

public class DemoClass {
  public void voidMethod(){
  System.out.println("In voidMethod().");
  }
}
```

--------------------------------

### getFieldSubSignature(String name, Type type)

Source: https://soot-oss.github.io/SootUp/latest/api/sootup/java/core/JavaIdentifierFactory.html

Gets the field sub signature.

```APIDOC
## getFieldSubSignature(String name, Type type)

### Description
Gets the field sub signature.

### Parameters
- **name** (String) - The name
- **type** (Type) - The type

### Returns
- **FieldSubSignature** - The field sub signature
```

--------------------------------

### select(AllocNode heap, Context context)

Source: https://soot-oss.github.io/SootUp/latest/api/qilin/pta/toolkits/dd/DataDrivenSelector.html

Selects a context for a given AllocNode.

```APIDOC
## Method: select(AllocNode heap, Context context)

### Description
Selects a context based on the provided AllocNode and existing context.

### Parameters
- **heap** (AllocNode) - The allocation node.
- **context** (Context) - The current context.

### Returns
- **Context** - The selected context.
```

--------------------------------

### JIfStmt Java Source

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Java source code corresponding to the JIfStmt Jimple example.

```Java
package target.exercise1;

public class DemoClass {
  public static void sampleMethod(int x){
    if(x % 2 == 0){
      System.out.println("Even");
    }else{
      System.out.println("Odd");
    }
  }
}
```

--------------------------------

### JGotoStmt Java Source

Source: https://soot-oss.github.io/SootUp/latest/jimple-stmts

Java source code corresponding to the JGotoStmt Jimple example.

```Java
package target.exercise1;

public class DemoClass {
  public static void sampleMethod(){
    label1:
    for (int i = 0; i < 5; i++){
      if(i == 3){
        break label1;
      }
    }
  }
}
```
Tokens:
Raw