[Feature]: Prune unnecessary <clinit> calls

[jecisc]

What happened?

Hi,

I tried to build the call graph of this project:

Operation.java

/**
 * A simple enum that represents arithmetic operations.
 * Each constant overrides {@link #apply(int,int)}.
 * The enum also provides a static helper {@code execute} that
 * demonstrates invoking the enum methods from client code.
 */
public enum Operation {

    /** Addition */
    ADD {
        @Override
        public int apply(int a, int b) {
            return a + b;
        }
    },

    /** Subtraction */
    SUBTRACT {
        @Override
        public int apply(int a, int b) {
            return a - b;
        }
    },

    /** Multiplication */
    MULTIPLY {
        @Override
        public int apply(int a, int b) {
            return a * b;
        }
    },

    /** Division – integer division, guards against divide‑by‑zero */
    DIVIDE {
        @Override
        public int apply(int a, int b) {
            if (b == 0) {
                throw new ArithmeticException("Division by zero");
            }
            return a / b;
        }
    };

    /** Abstract method each constant must implement */
    public abstract int apply(int a, int b);

    /**
     * Utility that parses a textual operator and forwards the call
     * to the corresponding enum constant.
     *
     * @param opSymbol one of "+", "-", "*", "/"
     * @param left     left operand
     * @param right    right operand
     * @return result of the operation
     */
    public static int execute(String opSymbol, int left, int right) {
        switch (opSymbol) {
            case "+":
                return ADD.apply(left, right);
            case "-":
                return SUBTRACT.apply(left, right);
            case "*":
                return MULTIPLY.apply(left, right);
            case "/":
                return DIVIDE.apply(left, right);
            default:
                throw new IllegalArgumentException("Unsupported operator: " + opSymbol);
        }
    }
}

Main.java

/**
 * Simple driver that exercises the {@link Operation} enum.
 * Run it with:  java com.example.Main
 */
public class Main {

    public static void main(String[] args) {
        // Hard‑coded sample data
        int a = 12;
        int b = 4;

        // Direct enum method calls
        System.out.println("Direct enum calls:");
        System.out.printf("%d + %d = %d%n", a, b, Operation.ADD.apply(a, b));
        System.out.printf("%d - %d = %d%n", a, b, Operation.SUBTRACT.apply(a, b));
        System.out.printf("%d * %d = %d%n", a, b, Operation.MULTIPLY.apply(a, b));
        System.out.printf("%d / %d = %d%n", a, b, Operation.DIVIDE.apply(a, b));

        // Calls via the static helper
        System.out.println("\nCalls via Operation.execute(...):");
        System.out.printf("%d + %d = %d%n", a, b, Operation.execute("+", a, b));
        System.out.printf("%d - %d = %d%n", a, b, Operation.execute("-", a, b));
        System.out.printf("%d * %d = %d%n", a, b, Operation.execute("*", a, b));
        System.out.printf("%d / %d = %d%n", a, b, Operation.execute("/", a, b));

        // Demonstrate exception handling (optional)
        try {
            Operation.execute("/", a, 0);
        } catch (ArithmeticException ex) {
            System.out.println("\nCaught expected exception: " + ex.getMessage());
        }
    }
}

I built it this way:

package com.example;


import sootup.callgraph.CallGraph;
import sootup.callgraph.CallGraphAlgorithm;
import sootup.callgraph.ClassHierarchyAnalysisAlgorithm;
import sootup.core.inputlocation.AnalysisInputLocation;
import sootup.core.signatures.MethodSignature;
import sootup.core.types.VoidType;
import sootup.java.bytecode.frontend.inputlocation.DefaultRuntimeAnalysisInputLocation;
import sootup.java.bytecode.frontend.inputlocation.JavaClassPathAnalysisInputLocation;
import sootup.java.core.types.JavaClassType;
import sootup.java.core.views.JavaView;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CallGraphDemo {
    public static void main(String[] args) {
        String cpString = "/Users/cyril/Library/Preferences/pharo/GitRepositories/jecisc/Famix-CallGraphs/resources/sources/example5/out/production/example5/";

        List<AnalysisInputLocation> inputLocations = new ArrayList<>();
        inputLocations.add(new JavaClassPathAnalysisInputLocation(cpString));
        inputLocations.add(new DefaultRuntimeAnalysisInputLocation());

        JavaView view = new JavaView(inputLocations);

        JavaClassType classTypeA = view.getIdentifierFactory().getClassType("Main");
        System.out.println(classTypeA);

        MethodSignature entryMethodSignature =
                view.getIdentifierFactory()
                        .getMethodSignature(
                                classTypeA,
                                "main",
                                "void",
                                Collections.singletonList("java.lang.String[]")
                        );

        System.out.println(entryMethodSignature);

        CallGraphAlgorithm cha = new ClassHierarchyAnalysisAlgorithm(view);

        CallGraph cg = cha.initialize(Collections.singletonList(entryMethodSignature));
        System.out.println(cg);
        //cg.callsFrom(entryMethodSignature).forEach(System.out::println);
    }
}

In the result I got this:

<Main: void main(java.lang.String[])>:
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: int execute(java.lang.String,int,int)>
	to <Operation: int execute(java.lang.String,int,int)>
	to <Operation: int execute(java.lang.String,int,int)>
	to <Operation: int execute(java.lang.String,int,int)>
	to <Operation: int execute(java.lang.String,int,int)>
	to <Operation$1: int apply(int,int)>
	to <Operation$1: int apply(int,int)>
	to <Operation$1: int apply(int,int)>
	to <Operation$1: int apply(int,int)>
	to <Operation$2: int apply(int,int)>
	to <Operation$2: int apply(int,int)>
	to <Operation$2: int apply(int,int)>
	to <Operation$2: int apply(int,int)>
	to <Operation$3: int apply(int,int)>
	to <Operation$3: int apply(int,int)>
	to <Operation$3: int apply(int,int)>
	to <Operation$3: int apply(int,int)>
	to <Operation$4: int apply(int,int)>
	to <Operation$4: int apply(int,int)>
	to <Operation$4: int apply(int,int)>
	to <Operation$4: int apply(int,int)>
	to <java.io.PrintStream: java.io.PrintStream printf(java.lang.String,java.lang.Object[])>
	to <java.io.PrintStream: java.io.PrintStream printf(java.lang.String,java.lang.Object[])>
	to <java.io.PrintStream: java.io.PrintStream printf(java.lang.String,java.lang.Object[])>
	to <java.io.PrintStream: java.io.PrintStream printf(java.lang.String,java.lang.Object[])>
	to <java.io.PrintStream: java.io.PrintStream printf(java.lang.String,java.lang.Object[])>
	to <java.io.PrintStream: java.io.PrintStream printf(java.lang.String,java.lang.Object[])>
	to <java.io.PrintStream: java.io.PrintStream printf(java.lang.String,java.lang.Object[])>
	to <java.io.PrintStream: java.io.PrintStream printf(java.lang.String,java.lang.Object[])>
	to <java.io.PrintStream: void println(java.lang.String)>
	to <java.io.PrintStream: void println(java.lang.String)>
	to <java.io.PrintStream: void println(java.lang.String)>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: void <clinit>()>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.Integer: java.lang.Integer valueOf(int)>
	to <java.lang.System: void <clinit>()>
	to <java.lang.System: void <clinit>()>
	to <java.lang.System: void <clinit>()>
	to <java.lang.System: void <clinit>()>
	to <java.lang.System: void <clinit>()>
	to <java.lang.System: void <clinit>()>
	to <java.lang.System: void <clinit>()>
	to <java.lang.System: void <clinit>()>
	to <java.lang.System: void <clinit>()>
	to <java.lang.System: void <clinit>()>
	to <java.lang.System: void <clinit>()>
	to <java.lang.Throwable: java.lang.String getMessage()>

First I am surprised to find so many static initialization. I would have expected only one time the line to <Operation: void <clinit>()>.

But my biggest surpprize is to find 16 times a call to apply.

	to <Operation$1: int apply(int,int)>
	to <Operation$1: int apply(int,int)>
	to <Operation$1: int apply(int,int)>
	to <Operation$1: int apply(int,int)>
	to <Operation$2: int apply(int,int)>
	to <Operation$2: int apply(int,int)>
	to <Operation$2: int apply(int,int)>
	to <Operation$2: int apply(int,int)>
	to <Operation$3: int apply(int,int)>
	to <Operation$3: int apply(int,int)>
	to <Operation$3: int apply(int,int)>
	to <Operation$3: int apply(int,int)>
	to <Operation$4: int apply(int,int)>
	to <Operation$4: int apply(int,int)>
	to <Operation$4: int apply(int,int)>
	to <Operation$4: int apply(int,int)>

I have 4 calls to apply. Is it because with the CHA we consider that one call could lead to any of the possible enum values?

I'm tagging this as a bug, but it might be right and me wrong. I'd just like to understand the logic :)

Version used: <sootup.version>develop-19a4ac63ff-1</sootup.version>

Version

Latest develop branch

Relevant log output

[jecisc]

Also I am surprised to see this:

<Operation: Operation[] $values()>:
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	from <Operation: void <clinit>()>

<Operation: void <clinit>()>:
	to <Operation: Operation[] $values()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation: void <clinit>()>
	to <Operation$1: void <init>(java.lang.String,int)>
	to <Operation$2: void <init>(java.lang.String,int)>
	to <Operation$3: void <init>(java.lang.String,int)>
	to <Operation$4: void <init>(java.lang.String,int)>
	from <Main: void main(java.lang.String[])>
	from <Main: void main(java.lang.String[])>
	from <Main: void main(java.lang.String[])>
	from <Main: void main(java.lang.String[])>
	from <Main: void main(java.lang.String[])>
	from <Main: void main(java.lang.String[])>
	from <Main: void main(java.lang.String[])>
	from <Main: void main(java.lang.String[])>
	from <Main: void main(java.lang.String[])>
	from <Operation: Operation[] $values()>
	from <Operation: Operation[] $values()>
	from <Operation: Operation[] $values()>
	from <Operation: Operation[] $values()>
	from <Operation: Operation[] $values()>
	from <Operation: void <clinit>()>
	from <Operation: void <clinit>()>
	from <Operation: void <clinit>()>
	from <Operation: void <clinit>()>
	from <Operation: void <clinit>()>
	from <Operation: void <clinit>()>
	from <Operation: void <clinit>()>
	from <Operation: void <clinit>()>
	from <Operation: void <clinit>()>
	from <Operation: void <clinit>()>
	from <Operation: int execute(java.lang.String,int,int)>
	from <Operation: int execute(java.lang.String,int,int)>
	from <Operation: int execute(java.lang.String,int,int)>
	from <Operation: int execute(java.lang.String,int,int)>

I am not really sure what is Operation[] $values(). But I see that Operation[] $values() is calling Operation . And Operation is calling Operation[] $values()? Isn't that a cycle?

[jecisc]

I also tried a simpler case with this file:

public enum Directions {

    NORTH,
    EAST,
    SOUTH,
    WEST;

    /** Prints the name of *this* direction. */
    public void print() {
        // `name()` returns the identifier used for the enum constant
        System.out.println(name());
    }

    /** Prints all directions, one per line. */
    public static void printAll() {
        for (Directions d : Directions.values()) {
            d.print();          // re‑uses the same `print()` implementation
        }
    }
}

And I see this:

<Directions: void <clinit>()>:
	to <Directions: Directions[] $values()>
	to <Directions: void <clinit>()>
	to <Directions: void <clinit>()>
	to <Directions: void <clinit>()>
	to <Directions: void <clinit>()>
	to <Directions: void <clinit>()>
	to <Directions: void <clinit>()>
	to <Directions: void <clinit>()>
	to <Directions: void <clinit>()>
	to <Directions: void <clinit>()>
	to <Directions: void <clinit>()>
	to <Directions: void <init>(java.lang.String,int)>
	to <Directions: void <init>(java.lang.String,int)>
	to <Directions: void <init>(java.lang.String,int)>
	to <Directions: void <init>(java.lang.String,int)>
	from <Directions: Directions[] $values()>
	from <Directions: Directions[] $values()>
	from <Directions: Directions[] $values()>
	from <Directions: Directions[] $values()>
	from <Directions: Directions[] $values()>
	from <Directions: void <clinit>()>
	from <Directions: void <clinit>()>
	from <Directions: void <clinit>()>
	from <Directions: void <clinit>()>
	from <Directions: void <clinit>()>
	from <Directions: void <clinit>()>
	from <Directions: void <clinit>()>
	from <Directions: void <clinit>()>
	from <Directions: void <clinit>()>
	from <Directions: void <clinit>()>
	from <Directions: void printAll()>
	from <Directions: Directions[] values()>
	from <Main: void main(java.lang.String[])>
	from <Main: void main(java.lang.String[])>

This seems like a lot of calls. Are they all really needed?

[jecisc]

I tried with the development branch and my last comment is fixed in this branch. But the first comments still applies

[JonasKlauke]

Hi,

First, I am surprised to find so many static initializations. I would have expected to see the line `<Operation: void <clinit>()>` only once.

Our current <clinit> solution is sound but conservative. Every static field access, every constructor, and every static method call causes a <clinit> edge. The Integer <clinit> entries come from Integer.valueOf(...) calls that the compiler adds for autoboxing.

I have 4 calls to apply. Is it because with CHA we consider that one call could lead to any of the possible enum values?

Your enum uses an abstract method that is implemented by all enum values. From the call names Operation$1, Operation$2, … it looks like the compiler creates anonymous classes for each enum constant. Each apply call invokes the abstract method, so all possible subclasses are considered as targets. You get 16 edges because there are 4 different targets and 4 call sites. I suggest using callGraph.exportAsDot(...); it produces a cleaner export of the call graph and also includes the statements.

I am not really sure what Operation[] $values() is. But I see that Operation[] $values() is calling Operation. And Operation is calling Operation[] $values()? Isn't that a cycle?

<clinit> calls are always implicit; they are not actually present in the source code. The synthetic values() method likely constructs the enum array, which involves four static field accesses that trigger <clinit> edges because the analysis is conservative.

The recursive-looking <clinit> calls have already been addressed, as you noted.

So yes — this is expected behavior. I’m not certain my explanation about the enum apply calls is completely correct (I’m making some assumptions), but you can inspect the bytecode to see how the compiler implements these features. Run:

javap -verbose -l -c -p path/to/Operation.class

on the class files to view the bytecode in a human-readable form.

You’re essentially requesting smarter <clinit> handling. That could be implemented with a flow-sensitive analysis after the call graph is created to eliminate unnecessary <clinit> edges, since these classes are typically initialized once to set up static fields and run static blocks.

[jecisc]

Thanks for the feedback!

I'm trying to understand how call graphs are working on edge cases in java and this is very insightful.

In the work I will do, I plan to just ensure that each nodes call only once a certain to reduce the noise.

If I understood correctly, will be called only on the first access (static field access, constructor, and static method call). We cannot know if a node if the first one to do the access, so it's alright to add it for each nodes accessing it. But it seems useless to add more than one edge for the same . For example, here main calls 9 times <Operation: void ()>, but in reality it will be called 0 or 1 time (depending if it's the first method that could trigger the cinit or not). So I would add only 1 cinit?

[JonasKlauke]

yeah that could be easily implemented.
there is only one problem, that needs to be handled if the first statement causing the clinit call is in an if branch and might not be the first call that is executed in the method.

[jecisc]

Is that a big problem? In what I see in the results, the edges are not ordered (or maybe it's just the printing?). So it should not impact much if it's not the first one?

[JonasKlauke]

no but in an implementation this needs to be adressed. but this could also be adressed by a post processing flow-analysis which might be the cleaner implementation of the clinit pruning.

[jecisc]

I renamed the issue to point only what is relevant in this issue after discussion