public void visitLibraryClass(LibraryClass libraryClass) {
if (shouldBeMarkedAsUsed(libraryClass)) {
markAsUsed(libraryClass);
// We're not going to analyze all library code. We're assuming that
// if this class is being used, all of its methods will be used as
// well. We'll mark them as such (here and in all subclasses).
// Mark the superclass.
Clazz superClass = libraryClass.superClass;
if (superClass != null) {
superClass.accept(this);
}
// Mark the interfaces.
Clazz[] interfaceClasses = libraryClass.interfaceClasses;
if (interfaceClasses != null) {
for (int index = 0; index < interfaceClasses.length; index++) {
if (interfaceClasses[index] != null) {
interfaceClasses[index].accept(this);
}
}
}
// Mark all methods.
libraryClass.methodsAccept(this);
}
}
public void visitInnerClassesInfo(Clazz clazz, InnerClassesInfo innerClassesInfo) {
// At this point, we only mark outer classes of this class.
// Inner class can be marked later, by InnerUsageMarker.
if (innerClassesInfo.u2innerClassIndex != 0
&& clazz.getName().equals(clazz.getClassName(innerClassesInfo.u2innerClassIndex))) {
markAsUsed(innerClassesInfo);
innerClassesInfo.innerClassConstantAccept(clazz, this);
innerClassesInfo.outerClassConstantAccept(clazz, this);
innerClassesInfo.innerNameConstantAccept(clazz, this);
}
}
public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute) {
// DEBUG =
// clazz.getName().equals("abc/Def") &&
// method.getName(clazz).equals("abc");
// TODO: Remove this when the code has stabilized.
// Catch any unexpected exceptions from the actual visiting method.
try {
// Process the code.
visitCodeAttribute0(clazz, method, codeAttribute);
} catch (RuntimeException ex) {
System.err.println("Unexpected error while computing stack sizes:");
System.err.println(" Class = [" + clazz.getName() + "]");
System.err.println(
" Method = [" + method.getName(clazz) + method.getDescriptor(clazz) + "]");
System.err.println(
" Exception = [" + ex.getClass().getName() + "] (" + ex.getMessage() + ")");
if (DEBUG) {
method.accept(clazz, new ClassPrinter());
}
throw ex;
}
}
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);
}
public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute) {
// DEBUG =
// clazz.getName().equals("abc/Def") &&
// method.getName(clazz).equals("abc");
// The minimum variable size is determined by the arguments.
codeAttribute.u2maxLocals =
ClassUtil.internalMethodParameterSize(method.getDescriptor(clazz), method.getAccessFlags());
if (DEBUG) {
System.out.println(
"VariableSizeUpdater: "
+ clazz.getName()
+ "."
+ method.getName(clazz)
+ method.getDescriptor(clazz));
System.out.println(" Max locals: " + codeAttribute.u2maxLocals + " <- parameters");
}
// Go over all instructions.
codeAttribute.instructionsAccept(clazz, method, this);
// Remove the unused variables of the attributes.
codeAttribute.attributesAccept(clazz, method, variableCleaner);
}
/**
* Marks the hierarchy of implementing or overriding methods corresponding to the given method, if
* any.
*/
protected void markMethodHierarchy(Clazz clazz, Method method) {
int accessFlags = method.getAccessFlags();
if ((accessFlags & (ClassConstants.ACC_PRIVATE | ClassConstants.ACC_STATIC)) == 0
&& !ClassUtil.isInitializer(method.getName(clazz))) {
// We can skip private and static methods in the hierarchy, and
// also abstract methods, unless they might widen a current
// non-public access.
int requiredUnsetAccessFlags =
ClassConstants.ACC_PRIVATE
| ClassConstants.ACC_STATIC
| ((accessFlags & ClassConstants.ACC_PUBLIC) == 0 ? 0 : ClassConstants.ACC_ABSTRACT);
clazz.accept(
new ConcreteClassDownTraveler(
new ClassHierarchyTraveler(
true,
true,
false,
true,
new NamedMethodVisitor(
method.getName(clazz),
method.getDescriptor(clazz),
new MemberAccessFilter(0, requiredUnsetAccessFlags, this)))));
}
}
/**
* Marks the hierarchy of implementing or overriding methods corresponding to the given method, if
* any.
*/
protected void markMethodHierarchy(Clazz clazz, Method method) {
int accessFlags = method.getAccessFlags();
if ((accessFlags & (ClassConstants.ACC_PRIVATE | ClassConstants.ACC_STATIC)) == 0
&& !ClassUtil.isInitializer(method.getName(clazz))) {
// We can skip private and static methods in the hierarchy, and
// also abstract methods, unless they might widen a current
// non-public access.
int requiredUnsetAccessFlags =
ClassConstants.ACC_PRIVATE
| ClassConstants.ACC_STATIC
| ((accessFlags & ClassConstants.ACC_PUBLIC) == 0 ? 0 : ClassConstants.ACC_ABSTRACT);
// Mark default implementations in interfaces down the hierarchy.
// TODO: This may be premature if there aren't any concrete implementing classes.
clazz.accept(
new ClassAccessFilter(
ClassConstants.ACC_ABSTRACT,
0,
new ClassHierarchyTraveler(
false,
false,
false,
true,
new ProgramClassFilter(
new ClassAccessFilter(
ClassConstants.ACC_ABSTRACT,
0,
new NamedMethodVisitor(
method.getName(clazz),
method.getDescriptor(clazz),
new MemberAccessFilter(
0, requiredUnsetAccessFlags, defaultMethodUsageMarker)))))));
// Mark other implementations.
clazz.accept(
new ConcreteClassDownTraveler(
new ClassHierarchyTraveler(
true,
true,
false,
true,
new NamedMethodVisitor(
method.getName(clazz),
method.getDescriptor(clazz),
new MemberAccessFilter(0, requiredUnsetAccessFlags, this)))));
}
}
public void visitSignatureAttribute(Clazz clazz, SignatureAttribute signatureAttribute) {
// Process the generic definitions, superclass, and implemented
// interfaces.
String signature = clazz.getString(signatureAttribute.u2signatureIndex);
// Count the signature types.
InternalTypeEnumeration internalTypeEnumeration = new InternalTypeEnumeration(signature);
int count = 0;
int interfacesCount = -1;
while (internalTypeEnumeration.hasMoreTypes()) {
String internalType = internalTypeEnumeration.nextType();
count++;
if (ClassUtil.isInternalClassType(internalType)) {
interfacesCount++;
}
}
// Put the signature types in an array.
internalTypeEnumeration = new InternalTypeEnumeration(signature);
String[] internalTypes = new String[count];
for (int index = 0; index < count; index++) {
String internalType = internalTypeEnumeration.nextType();
internalTypes[index] = internalType;
}
// Sort the interface types in the array.
Arrays.sort(internalTypes, count - interfacesCount, count);
// Recompose the signature types in a string.
StringBuffer newSignatureBuffer = new StringBuffer();
for (int index = 0; index < count; index++) {
// Is this not an interface type, or an interface type that isn't
// a duplicate of the previous interface type?
if (index < count - interfacesCount
|| !internalTypes[index].equals(internalTypes[index - 1])) {
newSignatureBuffer.append(internalTypes[index]);
}
}
String newSignature = newSignatureBuffer.toString();
// Did the signature change?
if (!newSignature.equals(signature)) {
// Update the signature.
((Utf8Constant) ((ProgramClass) clazz).constantPool[signatureAttribute.u2signatureIndex])
.setString(newSignatureBuffer.toString());
// Clear the referenced classes.
// TODO: Properly update the referenced classes.
signatureAttribute.referencedClasses = null;
}
}
public void visitInvokeDynamicConstant(Clazz clazz, InvokeDynamicConstant invokeDynamicConstant) {
if (shouldBeMarkedAsUsed(invokeDynamicConstant)) {
markAsUsed(invokeDynamicConstant);
markConstant(clazz, invokeDynamicConstant.u2nameAndTypeIndex);
// Mark the bootstrap methods attribute.
clazz.attributesAccept(
new MyBootStrapMethodUsageMarker(invokeDynamicConstant.u2bootstrapMethodAttributeIndex));
}
}
public void visitSignatureAttribute(
Clazz clazz, Method method, SignatureAttribute signatureAttribute) {
// Compute the new signature.
String signature = clazz.getString(signatureAttribute.u2signatureIndex);
String newSignature = shrinkDescriptor(method, signature);
// Update the signature.
signatureAttribute.u2signatureIndex =
new ConstantPoolEditor((ProgramClass) clazz).addUtf8Constant(newSignature);
// Update the referenced classes.
signatureAttribute.referencedClasses =
shrinkReferencedClasses(method, signature, signatureAttribute.referencedClasses);
}
public void visitConstantInstruction(
Clazz clazz,
Method method,
CodeAttribute codeAttribute,
int offset,
ConstantInstruction constantInstruction) {
markConstant(clazz, constantInstruction.constantIndex);
// Also mark the parameterless constructor of the class, in case the
// string constant or class constant is being used in a Class.forName
// or a .class construct.
clazz.constantPoolEntryAccept(
constantInstruction.constantIndex, parameterlessConstructorMarker);
}
/**
* Marks the hierarchy of implementing or overriding methods corresponding to the given method, if
* any.
*/
protected void markMethodHierarchy(Clazz clazz, Method method) {
if ((method.getAccessFlags()
& (ClassConstants.INTERNAL_ACC_PRIVATE | ClassConstants.INTERNAL_ACC_STATIC))
== 0) {
clazz.accept(
new ConcreteClassDownTraveler(
new ClassHierarchyTraveler(
true,
true,
false,
true,
new NamedMethodVisitor(
method.getName(clazz),
method.getDescriptor(clazz),
new MemberAccessFilter(
0,
ClassConstants.INTERNAL_ACC_PRIVATE
| ClassConstants.INTERNAL_ACC_STATIC
| ClassConstants.INTERNAL_ACC_ABSTRACT,
this)))));
}
}
/**
* Evaluates a block of instructions that hasn't been handled before, starting at the given offset
* and ending at a branch instruction, a return instruction, or a throw instruction. Branch
* instructions are handled recursively.
*/
private void evaluateInstructionBlock(
Clazz clazz, Method method, CodeAttribute codeAttribute, int instructionOffset) {
if (DEBUG) {
if (evaluated[instructionOffset]) {
System.out.println("-- (instruction block at " + instructionOffset + " already evaluated)");
} else {
System.out.println("-- instruction block:");
}
}
// Remember the initial stack size.
int initialStackSize = stackSize;
// Remember the maximum stack size.
if (maxStackSize < stackSize) {
maxStackSize = stackSize;
}
// Evaluate any instructions that haven't been evaluated before.
while (!evaluated[instructionOffset]) {
// Mark the instruction as evaluated.
evaluated[instructionOffset] = true;
Instruction instruction = InstructionFactory.create(codeAttribute.code, instructionOffset);
if (DEBUG) {
int stackPushCount = instruction.stackPushCount(clazz);
int stackPopCount = instruction.stackPopCount(clazz);
System.out.println(
"["
+ instructionOffset
+ "]: "
+ stackSize
+ " - "
+ stackPopCount
+ " + "
+ stackPushCount
+ " = "
+ (stackSize + stackPushCount - stackPopCount)
+ ": "
+ instruction.toString(instructionOffset));
}
// Compute the instruction's effect on the stack size.
stackSize -= instruction.stackPopCount(clazz);
if (stackSize < 0) {
throw new IllegalArgumentException(
"Stack size becomes negative after instruction "
+ instruction.toString(instructionOffset)
+ " in ["
+ clazz.getName()
+ "."
+ method.getName(clazz)
+ method.getDescriptor(clazz)
+ "]");
}
stackSizes[instructionOffset] = stackSize += instruction.stackPushCount(clazz);
// Remember the maximum stack size.
if (maxStackSize < stackSize) {
maxStackSize = stackSize;
}
// Remember the next instruction offset.
int nextInstructionOffset = instructionOffset + instruction.length(instructionOffset);
// Visit the instruction, in order to handle branches.
instruction.accept(clazz, method, codeAttribute, instructionOffset, this);
// Stop evaluating after a branch.
if (exitInstructionBlock) {
break;
}
// Continue with the next instruction.
instructionOffset = nextInstructionOffset;
if (DEBUG) {
if (evaluated[instructionOffset]) {
System.out.println("-- (instruction at " + instructionOffset + " already evaluated)");
}
}
}
// Restore the stack size for possible subsequent instruction blocks.
this.stackSize = initialStackSize;
}
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());
}
}
/**
* Marks the given constant pool entry of the given class. This includes visiting any referenced
* objects.
*/
private void markConstant(Clazz clazz, int index) {
clazz.constantPoolEntryAccept(index, this);
}
public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute) {
// Get the original parameter size that was saved.
int oldParameterSize = ParameterUsageMarker.getParameterSize(method);
// Compute the new parameter size from the shrunk descriptor.
int newParameterSize =
ClassUtil.internalMethodParameterSize(method.getDescriptor(clazz), method.getAccessFlags());
if (oldParameterSize > newParameterSize) {
// Get the total size of the local variable frame.
int maxLocals = codeAttribute.u2maxLocals;
if (DEBUG) {
System.out.println(
"ParameterShrinker: "
+ clazz.getName()
+ "."
+ method.getName(clazz)
+ method.getDescriptor(clazz));
System.out.println(" Old parameter size = " + oldParameterSize);
System.out.println(" New parameter size = " + newParameterSize);
System.out.println(" Max locals = " + maxLocals);
}
// Create a variable map.
int[] variableMap = new int[maxLocals];
// Move unused parameters right after the parameter block.
int usedParameterIndex = 0;
int unusedParameterIndex = newParameterSize;
for (int parameterIndex = 0; parameterIndex < oldParameterSize; parameterIndex++) {
// Is the variable required as a parameter?
if (ParameterUsageMarker.isParameterUsed(method, parameterIndex)) {
// Keep the variable as a parameter.
variableMap[parameterIndex] = usedParameterIndex++;
} else {
if (DEBUG) {
System.out.println(" Deleting parameter #" + parameterIndex);
}
// Shift the variable to the unused parameter block,
// in case it is still used as a variable.
variableMap[parameterIndex] = unusedParameterIndex++;
// Visit the method, if required.
if (extraVariableMemberVisitor != null) {
method.accept(clazz, extraVariableMemberVisitor);
}
}
}
// Fill out the remainder of the map.
for (int variableIndex = oldParameterSize; variableIndex < maxLocals; variableIndex++) {
variableMap[variableIndex] = variableIndex;
}
// Set the map.
variableRemapper.setVariableMap(variableMap);
// Remap the variables.
variableRemapper.visitCodeAttribute(clazz, method, codeAttribute);
}
}