void initClass(ClassDependency cls, CallLocation callLocation) {
ClassReader reader = cls.getClassReader();
MethodReader method = reader.getMethod(new MethodDescriptor("<clinit>", void.class));
if (method != null) {
tasks.add(() -> linkMethod(method.getReference(), callLocation).use());
}
}
public MethodDependency linkMethod(MethodReference methodRef, CallLocation callLocation) {
if (methodRef == null) {
throw new IllegalArgumentException();
}
MethodReader methodReader = methodReaderCache.map(methodRef);
if (methodReader != null) {
methodRef = methodReader.getReference();
}
if (completing && getMethod(methodRef) == null) {
throw new IllegalStateException("Can't submit class during completion phase");
}
callGraph.getNode(methodRef);
boolean added = true;
if (callLocation != null && callLocation.getMethod() != null) {
added =
callGraph
.getNode(callLocation.getMethod())
.addCallSite(methodRef, callLocation.getSourceLocation());
} else {
added = methodsAddedByRoot.add(methodRef);
}
MethodDependency graph = methodCache.map(methodRef);
if (!graph.isMissing() && added) {
for (DependencyListener listener : listeners) {
listener.methodReached(agent, graph, callLocation);
}
activateDependencyPlugin(graph, callLocation);
}
return graph;
}
public void allocateRegisters(MethodReader method, Program program) {
insertJointArgumentsCopies(program);
insertPhiArgumentsCopies(program);
InterferenceGraphBuilder interferenceBuilder = new InterferenceGraphBuilder();
LivenessAnalyzer liveness = new LivenessAnalyzer();
liveness.analyze(program);
List<MutableGraphNode> interferenceGraph =
interferenceBuilder.build(program, method.parameterCount(), liveness);
DisjointSet congruenceClasses = buildPhiCongruenceClasses(program);
joinClassNodes(interferenceGraph, congruenceClasses);
removeRedundantCopies(program, interferenceGraph, congruenceClasses);
int[] classArray = congruenceClasses.pack(program.variableCount());
renameVariables(program, classArray);
int[] colors = new int[program.variableCount()];
Arrays.fill(colors, -1);
for (int i = 0; i <= method.parameterCount(); ++i) {
colors[i] = i;
}
renameInterferenceGraph(interferenceGraph, congruenceClasses, classArray);
GraphColorer colorer = new GraphColorer();
int maxClass = 0;
for (int cls : classArray) {
maxClass = Math.max(maxClass, cls + 1);
}
int[] categories = getVariableCategories(program, method.getReference());
int[] classCategories = new int[maxClass];
for (int i = 0; i < categories.length; ++i) {
classCategories[classArray[i]] = categories[i];
}
colorer.colorize(interferenceGraph, colors, classCategories);
for (int i = 0; i < colors.length; ++i) {
program.variableAt(i).setRegister(colors[i]);
}
for (int i = 0; i < program.basicBlockCount(); ++i) {
program.basicBlockAt(i).getPhis().clear();
program.basicBlockAt(i).getTryCatchJoints().clear();
}
}
@Override
public MethodDependency getMethodImplementation(MethodReference methodRef) {
MethodReader method = methodReaderCache.map(methodRef);
return method != null ? methodCache.getKnown(method.getReference()) : null;
}
