public void visitCodeAttribute0(Clazz clazz, Method method, CodeAttribute codeAttribute) {
if (DEBUG) {
System.out.println(
"StackSizeComputer: "
+ clazz.getName()
+ "."
+ method.getName(clazz)
+ method.getDescriptor(clazz));
}
// Try to reuse the previous array.
int codeLength = codeAttribute.u4codeLength;
if (evaluated.length < codeLength) {
evaluated = new boolean[codeLength];
stackSizes = new int[codeLength];
} else {
Arrays.fill(evaluated, 0, codeLength, false);
}
// The initial stack is always empty.
stackSize = 0;
maxStackSize = 0;
// Evaluate the instruction block starting at the entry point of the method.
evaluateInstructionBlock(clazz, method, codeAttribute, 0);
// Evaluate the exception handlers.
codeAttribute.exceptionsAccept(clazz, method, this);
}
/** Appends the specified subroutine. */
private void inlineSubroutine(
Clazz clazz,
Method method,
CodeAttribute codeAttribute,
int subroutineInvocationOffset,
int subroutineStart) {
int subroutineEnd = branchTargetFinder.subroutineEnd(subroutineStart);
if (DEBUG) {
System.out.println(
" Inlining subroutine ["
+ subroutineStart
+ " -> "
+ subroutineEnd
+ "] at ["
+ subroutineInvocationOffset
+ "]");
}
// Don't go inlining exceptions that are already applicable to this
// subroutine invocation.
ExceptionInfoVisitor oldSubroutineExceptionInliner = subroutineExceptionInliner;
int oldClipStart = clipStart;
int oldClipEnd = clipEnd;
subroutineExceptionInliner =
new ExceptionExcludedOffsetFilter(subroutineInvocationOffset, subroutineExceptionInliner);
clipStart = subroutineStart;
clipEnd = subroutineEnd;
codeAttributeComposer.beginCodeFragment(codeAttribute.u4codeLength);
// Copy the subroutine instructions, inlining any subroutine calls
// recursively.
codeAttribute.instructionsAccept(clazz, method, subroutineStart, subroutineEnd, this);
if (DEBUG) {
System.out.println(" Appending label after inlined subroutine at [" + subroutineEnd + "]");
}
// Append a label just after the code.
codeAttributeComposer.appendLabel(subroutineEnd);
// Inline the subroutine exceptions.
codeAttribute.exceptionsAccept(
clazz, method, subroutineStart, subroutineEnd, subroutineExceptionInliner);
// We can again inline exceptions that are applicable to this
// subroutine invocation.
subroutineExceptionInliner = oldSubroutineExceptionInliner;
clipStart = oldClipStart;
clipEnd = oldClipEnd;
codeAttributeComposer.endCodeFragment();
}
public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute) {
markAsUsed(codeAttribute);
markConstant(clazz, codeAttribute.u2attributeNameIndex);
// Mark the constant pool entries referenced by the instructions,
// by the exceptions, and by the attributes.
codeAttribute.instructionsAccept(clazz, method, this);
codeAttribute.exceptionsAccept(clazz, method, this);
codeAttribute.attributesAccept(clazz, method, this);
}
public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute) {
// Make sure there is a sufficiently large array.
int codeLength = codeAttribute.u4codeLength;
if (isReachable.length < codeLength) {
// Create a new array.
isReachable = new boolean[codeLength];
} else {
// Reset the array.
for (int index = 0; index < codeLength; index++) {
isReachable[index] = false;
}
}
// Mark the code, starting at the entry point.
markCode(clazz, method, codeAttribute, 0);
// Mark the exception handlers, iterating as long as necessary.
do {
evaluateExceptions = false;
codeAttribute.exceptionsAccept(clazz, method, this);
} while (evaluateExceptions);
}
public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute) {
// DEBUG =
// clazz.getName().equals("abc/Def") &&
// method.getName(clazz).equals("abc");
if (DEBUG) {
method.accept(clazz, new ClassPrinter());
}
branchTargetFinder.visitCodeAttribute(clazz, method, codeAttribute);
// Don't bother if there aren't any subroutines anyway.
if (!containsSubroutines(codeAttribute)) {
return;
}
if (DEBUG) {
System.out.println(
"SubroutineInliner: processing ["
+ clazz.getName()
+ "."
+ method.getName(clazz)
+ method.getDescriptor(clazz)
+ "]");
}
// Append the body of the code.
codeAttributeComposer.reset();
codeAttributeComposer.beginCodeFragment(codeAttribute.u4codeLength);
// Copy the non-subroutine instructions.
int offset = 0;
while (offset < codeAttribute.u4codeLength) {
Instruction instruction = InstructionFactory.create(codeAttribute.code, offset);
int instructionLength = instruction.length(offset);
// Is this returning subroutine?
if (branchTargetFinder.isSubroutine(offset)
&& branchTargetFinder.isSubroutineReturning(offset)) {
// Skip the subroutine.
if (DEBUG) {
System.out.println(
" Skipping original subroutine instruction " + instruction.toString(offset));
}
// Append a label at this offset instead.
codeAttributeComposer.appendLabel(offset);
} else {
// Copy the instruction, inlining any subroutine call recursively.
instruction.accept(clazz, method, codeAttribute, offset, this);
}
offset += instructionLength;
}
// Copy the exceptions. Note that exceptions with empty try blocks
// are automatically removed.
codeAttribute.exceptionsAccept(clazz, method, subroutineExceptionInliner);
if (DEBUG) {
System.out.println(" Appending label after code at [" + offset + "]");
}
// Append a label just after the code.
codeAttributeComposer.appendLabel(codeAttribute.u4codeLength);
// End and update the code attribute.
codeAttributeComposer.endCodeFragment();
codeAttributeComposer.visitCodeAttribute(clazz, method, codeAttribute);
if (DEBUG) {
method.accept(clazz, new ClassPrinter());
}
}