org.aspectj.apache.bcel.generic.MethodGen Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aspectjweaver Show documentation
Show all versions of aspectjweaver Show documentation
The AspectJ weaver applies aspects to Java classes. It can be used as a Java agent in order to apply load-time
weaving (LTW) during class-loading and also contains the AspectJ runtime classes.
package org.aspectj.apache.bcel.generic;
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (https://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" and
* "Apache BCEL" must not be used to endorse or promote products
* derived from this software without prior written permission. For
* written permission, please contact [email protected].
*
* 5. Products derived from this software may not be called "Apache",
* "Apache BCEL", nor may "Apache" appear in their name, without
* prior written permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* localVariablesList = new ArrayList<>();
private List lineNumbersList = new ArrayList<>();
private ArrayList exceptionsList = new ArrayList<>();
private ArrayList exceptionsThrown = new ArrayList<>();
private List codeAttributesList = new ArrayList<>();
private List[] param_annotations; // Array of lists containing AnnotationGen objects
private boolean hasParameterAnnotations = false;
private boolean haveUnpackedParameterAnnotations = false;
/**
* Declare method. If the method is non-static the constructor automatically declares a local variable `$this' in slot 0. The
* actual code is contained in the `il' parameter, which may further manipulated by the user. But he must take care not to
* remove any instruction (handles) that are still referenced from this object.
*
* For example one may not add a local variable and later remove the instructions it refers to without causing havoc. It is safe
* however if you remove that local variable, too.
*
* @param access_flags access qualifiers
* @param return_type method type
* @param arg_types argument types
* @param arg_names argument names (if this is null, default names will be provided for them)
* @param method_name name of method
* @param class_name class name containing this method (may be null, if you don't care)
* @param il instruction list associated with this method, may be null only for abstract or native methods
* @param cp constant pool
*/
public MethodGen(int access_flags, Type return_type, Type[] arg_types, String[] arg_names, String method_name,
String class_name, InstructionList il, ConstantPool cp) {
this.modifiers = access_flags;
this.type = return_type;
this.parameterTypes = arg_types;
this.parameterNames = arg_names;
this.name = method_name;
this.classname = class_name;
this.il = il;
this.cp = cp;
// OPTIMIZE this code messes with the local variables - do we need it?
// boolean abstract_ = isAbstract() || isNative();
// InstructionHandle start = null;
// InstructionHandle end = null;
//
// if (!abstract_) {
// start = il.getStart();
// end = il.getEnd();
//
// /* Add local variables, namely the implicit `this' and the arguments
// */
// // if(!isStatic() && (class_name != null)) { // Instance method -> `this' is local var 0
// // addLocalVariable("this", new ObjectType(class_name), start, end);
// // }
// }
// if(arg_types != null) {
// int size = arg_types.length;
//
// for(int i=0; i < size; i++) {
// if(Type.VOID == arg_types[i]) {
// throw new ClassGenException("'void' is an illegal argument type for a method");
// }
// }
//
// if(arg_names != null) { // Names for variables provided?
// if(size != arg_names.length)
// throw new ClassGenException("Mismatch in argument array lengths: " +
// size + " vs. " + arg_names.length);
// } else { // Give them dummy names
// // arg_names = new String[size];
// //
// // for(int i=0; i < size; i++)
// // arg_names[i] = "arg" + i;
// //
// // setArgumentNames(arg_names);
// }
// if(!abstract_) {
// for(int i=0; i < size; i++) {
// // addLocalVariable(arg_names[i], arg_types[i], start, end);
// }
// }
// }
}
public int getHighestlinenumber() {
return highestLineNumber;
}
/**
* Instantiate from existing method.
*
* @param m method
* @param class_name class name containing this method
* @param cp constant pool
*/
public MethodGen(Method m, String class_name, ConstantPool cp) {
this(m, class_name, cp, false);
}
// OPTIMIZE should always use tags and never anything else!
public MethodGen(Method m, String class_name, ConstantPool cp, boolean useTags) {
this(m.getModifiers(),
// OPTIMIZE implementation of getReturnType() and getArgumentTypes() on Method seems weak
m.getReturnType(), m.getArgumentTypes(), null /* may be overridden anyway */, m.getName(), class_name, ((m
.getModifiers() & (Constants.ACC_ABSTRACT | Constants.ACC_NATIVE)) == 0) ? new InstructionList(m.getCode()
.getCode()) : null, cp);
Attribute[] attributes = m.getAttributes();
for (Attribute attribute : attributes) {
Attribute a = attribute;
if (a instanceof Code) {
Code code = (Code) a;
setMaxStack(code.getMaxStack());
setMaxLocals(code.getMaxLocals());
CodeException[] ces = code.getExceptionTable();
InstructionHandle[] arrayOfInstructions = il.getInstructionsAsArray();
// process the exception table
// -
if (ces != null) {
for (CodeException ce : ces) {
int type = ce.getCatchType();
ObjectType catchType = null;
if (type > 0) {
String cen = m.getConstantPool().getConstantString_CONSTANTClass(type);
catchType = new ObjectType(cen);
}
int end_pc = ce.getEndPC();
int length = m.getCode().getCode().length;
InstructionHandle end;
if (length == end_pc) { // May happen, because end_pc is exclusive
end = il.getEnd();
} else {
end = il.findHandle(end_pc, arrayOfInstructions);// il.findHandle(end_pc);
end = end.getPrev(); // Make it inclusive
}
addExceptionHandler(il.findHandle(ce.getStartPC(), arrayOfInstructions), end, il.findHandle(ce
.getHandlerPC(), arrayOfInstructions), catchType);
}
}
Attribute[] codeAttrs = code.getAttributes();
for (Attribute codeAttr : codeAttrs) {
a = codeAttr;
if (a instanceof LineNumberTable) {
LineNumber[] ln = ((LineNumberTable) a).getLineNumberTable();
if (useTags) {
// abracadabra, lets create tags rather than linenumbergens.
for (LineNumber l : ln) {
int lnum = l.getLineNumber();
if (lnum > highestLineNumber) {
highestLineNumber = lnum;
}
LineNumberTag lt = new LineNumberTag(lnum);
il.findHandle(l.getStartPC(), arrayOfInstructions, true).addTargeter(lt);
}
} else {
for (LineNumber l : ln) {
addLineNumber(il.findHandle(l.getStartPC(), arrayOfInstructions, true), l.getLineNumber());
}
}
} else if (a instanceof LocalVariableTable) {
// Lets have a go at creating Tags directly
if (useTags) {
LocalVariable[] lv = ((LocalVariableTable) a).getLocalVariableTable();
for (LocalVariable l : lv) {
Type t = Type.getType(l.getSignature());
LocalVariableTag lvt = new LocalVariableTag(t, l.getSignature(), l.getName(), l.getIndex(), l
.getStartPC());
InstructionHandle start = il.findHandle(l.getStartPC(), arrayOfInstructions, true);
byte b = t.getType();
if (b != Constants.T_ADDRESS) {
int increment = t.getSize();
if (l.getIndex() + increment > maxLocals) {
maxLocals = l.getIndex() + increment;
}
}
int end = l.getStartPC() + l.getLength();
do {
start.addTargeter(lvt);
start = start.getNext();
} while (start != null && start.getPosition() < end);
}
} else {
LocalVariable[] lv = ((LocalVariableTable) a).getLocalVariableTable();
removeLocalVariables();
for (LocalVariable l : lv) {
InstructionHandle start = il.findHandle(l.getStartPC(), arrayOfInstructions);
InstructionHandle end = il.findHandle(l.getStartPC() + l.getLength(), arrayOfInstructions);
// AMC, this actually gives us the first instruction AFTER the range,
// so move back one... (findHandle can't cope with mid-instruction indices)
if (end != null) {
end = end.getPrev();
}
// Repair malformed handles
if (null == start) {
start = il.getStart();
}
if (null == end) {
end = il.getEnd();
}
addLocalVariable(l.getName(), Type.getType(l.getSignature()), l.getIndex(), start, end);
}
}
} else {
addCodeAttribute(a);
}
}
} else if (a instanceof ExceptionTable) {
String[] names = ((ExceptionTable) a).getExceptionNames();
for (String s : names) {
addException(s);
}
} else if (a instanceof RuntimeAnnos) {
RuntimeAnnos runtimeAnnotations = (RuntimeAnnos) a;
List l = runtimeAnnotations.getAnnotations();
annotationList.addAll(l);
// for (Iterator it = l.iterator(); it.hasNext();) {
// AnnotationGen element = it.next();
// addAnnotation(new AnnotationGen(element, cp, false));
// }
} else {
addAttribute(a);
}
}
}
public LocalVariableGen addLocalVariable(String name, Type type, int slot, InstructionHandle start, InstructionHandle end) {
int size = type.getSize();
if (slot + size > maxLocals) {
maxLocals = slot + size;
}
LocalVariableGen l = new LocalVariableGen(slot, name, type, start, end);
int i = localVariablesList.indexOf(l);
if (i >= 0) {
localVariablesList.set(i, l); // Overwrite if necessary
} else {
localVariablesList.add(l);
}
return l;
}
/**
* Adds a local variable to this method and assigns an index automatically.
*
* @param name variable name
* @param type variable type
* @param start from where the variable is valid, if this is null, it is valid from the start
* @param end until where the variable is valid, if this is null, it is valid to the end
* @return new local variable object
* @see LocalVariable
*/
public LocalVariableGen addLocalVariable(String name, Type type, InstructionHandle start, InstructionHandle end) {
return addLocalVariable(name, type, maxLocals, start, end);
}
/**
* Remove a local variable, its slot will not be reused, if you do not use addLocalVariable with an explicit index argument.
*/
public void removeLocalVariable(LocalVariableGen l) {
localVariablesList.remove(l);
}
/**
* Remove all local variables.
*/
public void removeLocalVariables() {
localVariablesList.clear();
}
/**
* Sort local variables by index
*/
private static final void sort(LocalVariableGen[] vars, int l, int r) {
int i = l, j = r;
int m = vars[(l + r) / 2].getIndex();
LocalVariableGen h;
do {
while (vars[i].getIndex() < m) {
i++;
}
while (m < vars[j].getIndex()) {
j--;
}
if (i <= j) {
h = vars[i];
vars[i] = vars[j];
vars[j] = h; // Swap elements
i++;
j--;
}
} while (i <= j);
if (l < j) {
sort(vars, l, j);
}
if (i < r) {
sort(vars, i, r);
}
}
/*
* If the range of the variable has not been set yet, it will be set to be valid from the start to the end of the instruction
* list.
*
* @return array of declared local variables sorted by index
*/
public LocalVariableGen[] getLocalVariables() {
int size = localVariablesList.size();
LocalVariableGen[] lg = new LocalVariableGen[size];
localVariablesList.toArray(lg);
for (int i = 0; i < size; i++) {
if (lg[i].getStart() == null) {
lg[i].setStart(il.getStart());
}
if (lg[i].getEnd() == null) {
lg[i].setEnd(il.getEnd());
}
}
if (size > 1) {
sort(lg, 0, size - 1);
}
return lg;
}
/**
* @return `LocalVariableTable' attribute of all the local variables of this method.
*/
public LocalVariableTable getLocalVariableTable(ConstantPool cp) {
LocalVariableGen[] lg = getLocalVariables();
int size = lg.length;
LocalVariable[] lv = new LocalVariable[size];
for (int i = 0; i < size; i++) {
lv[i] = lg[i].getLocalVariable(cp);
}
return new LocalVariableTable(cp.addUtf8("LocalVariableTable"), 2 + lv.length * 10, lv, cp);
}
/**
* Give an instruction a line number corresponding to the source code line.
*
* @param ih instruction to tag
* @return new line number object
* @see LineNumber
*/
public LineNumberGen addLineNumber(InstructionHandle ih, int src_line) {
LineNumberGen l = new LineNumberGen(ih, src_line);
lineNumbersList.add(l);
return l;
}
/**
* Remove a line number.
*/
public void removeLineNumber(LineNumberGen l) {
lineNumbersList.remove(l);
}
/**
* Remove all line numbers.
*/
public void removeLineNumbers() {
lineNumbersList.clear();
}
/*
* @return array of line numbers
*/
public LineNumberGen[] getLineNumbers() {
LineNumberGen[] lg = new LineNumberGen[lineNumbersList.size()];
lineNumbersList.toArray(lg);
return lg;
}
/**
* @return 'LineNumberTable' attribute for all the local variables of this method.
*/
public LineNumberTable getLineNumberTable(ConstantPool cp) {
int size = lineNumbersList.size();
LineNumber[] ln = new LineNumber[size];
for (int i = 0; i < size; i++) {
ln[i] = lineNumbersList.get(i).getLineNumber();
}
return new LineNumberTable(cp.addUtf8("LineNumberTable"), 2 + ln.length * 4, ln, cp);
}
/**
* Add an exception handler, i.e., specify region where a handler is active and an instruction where the actual handling is
* done.
*
* @param start_pc Start of region (inclusive)
* @param end_pc End of region (inclusive)
* @param handler_pc Where handling is done
* @param catch_type class type of handled exception or null if any exception is handled
* @return new exception handler object
*/
public CodeExceptionGen addExceptionHandler(InstructionHandle start_pc, InstructionHandle end_pc, InstructionHandle handler_pc,
ObjectType catch_type) {
if ((start_pc == null) || (end_pc == null) || (handler_pc == null)) {
throw new ClassGenException("Exception handler target is null instruction");
}
CodeExceptionGen c = new CodeExceptionGen(start_pc, end_pc, handler_pc, catch_type);
exceptionsList.add(c);
return c;
}
/**
* Remove an exception handler.
*/
public void removeExceptionHandler(CodeExceptionGen c) {
exceptionsList.remove(c);
}
/**
* Remove all line numbers.
*/
public void removeExceptionHandlers() {
exceptionsList.clear();
}
/*
* @return array of declared exception handlers
*/
public CodeExceptionGen[] getExceptionHandlers() {
CodeExceptionGen[] cg = new CodeExceptionGen[exceptionsList.size()];
exceptionsList.toArray(cg);
return cg;
}
/**
* @return code exceptions for `Code' attribute
*/
private CodeException[] getCodeExceptions() {
int size = exceptionsList.size();
CodeException[] c_exc = new CodeException[size];
try {
for (int i = 0; i < size; i++) {
CodeExceptionGen c = exceptionsList.get(i);
c_exc[i] = c.getCodeException(cp);
}
} catch (ArrayIndexOutOfBoundsException e) {
}
return c_exc;
}
/**
* Add an exception possibly thrown by this method.
*
* @param class_name (fully qualified) name of exception
*/
public void addException(String class_name) {
exceptionsThrown.add(class_name);
}
/**
* Remove an exception.
*/
public void removeException(String c) {
exceptionsThrown.remove(c);
}
/**
* Remove all exceptions.
*/
public void removeExceptions() {
exceptionsThrown.clear();
}
/*
* @return array of thrown exceptions
*/
public String[] getExceptions() {
String[] e = new String[exceptionsThrown.size()];
exceptionsThrown.toArray(e);
return e;
}
/**
* @return `Exceptions' attribute of all the exceptions thrown by this method.
*/
private ExceptionTable getExceptionTable(ConstantPool cp) {
int size = exceptionsThrown.size();
int[] ex = new int[size];
try {
for (int i = 0; i < size; i++) {
ex[i] = cp.addClass(exceptionsThrown.get(i));
}
} catch (ArrayIndexOutOfBoundsException e) {
}
return new ExceptionTable(cp.addUtf8("Exceptions"), 2 + 2 * size, ex, cp);
}
/**
* Add an attribute to the code. Currently, the JVM knows about the LineNumberTable, LocalVariableTable and StackMap attributes,
* where the former two will be generated automatically and the latter is used for the MIDP only. Other attributes will be
* ignored by the JVM but do no harm.
*
* @param a attribute to be added
*/
public void addCodeAttribute(Attribute a) {
codeAttributesList.add(a);
}
public void addParameterAnnotationsAsAttribute(ConstantPool cp) {
if (!hasParameterAnnotations) {
return;
}
Attribute[] attrs = Utility.getParameterAnnotationAttributes(cp, param_annotations);
if (attrs != null) {
for (Attribute attr : attrs) {
addAttribute(attr);
}
}
}
/**
* Remove a code attribute.
*/
public void removeCodeAttribute(Attribute a) {
codeAttributesList.remove(a);
}
/**
* Remove all code attributes.
*/
public void removeCodeAttributes() {
codeAttributesList.clear();
}
/**
* @return all attributes of this method.
*/
public Attribute[] getCodeAttributes() {
Attribute[] attributes = new Attribute[codeAttributesList.size()];
codeAttributesList.toArray(attributes);
return attributes;
}
/**
* Get method object. Never forget to call setMaxStack() or setMaxStack(max), respectively, before calling this method (the same
* applies for max locals).
*
* @return method object
*/
public Method getMethod() {
String signature = getSignature();
int name_index = cp.addUtf8(name);
int signature_index = cp.addUtf8(signature);
/*
* Also updates positions of instructions, i.e., their indices
*/
byte[] byte_code = null;
if (il != null) {
try {
byte_code = il.getByteCode();
} catch (Exception e) {
throw new IllegalStateException("Unexpected problem whilst preparing bytecode for " + this.getClassName() + "."
+ this.getName() + this.getSignature(), e);
}
}
LineNumberTable lnt = null;
LocalVariableTable lvt = null;
// J5TODO: LocalVariableTypeTable support!
/*
* Create LocalVariableTable and LineNumberTable attributes (for debuggers, e.g.)
*/
if ((localVariablesList.size() > 0) && !stripAttributes) {
addCodeAttribute(lvt = getLocalVariableTable(cp));
}
if ((lineNumbersList.size() > 0) && !stripAttributes) {
addCodeAttribute(lnt = getLineNumberTable(cp));
}
Attribute[] code_attrs = getCodeAttributes();
/*
* Each attribute causes 6 additional header bytes
*/
int attrs_len = 0;
for (Attribute code_attr : code_attrs) {
attrs_len += (code_attr.getLength() + 6);
}
CodeException[] c_exc = getCodeExceptions();
int exc_len = c_exc.length * 8; // Every entry takes 8 bytes
Code code = null;
if ((il != null) && !isAbstract()) {
// Remove any stale code attribute
List attributes = getAttributes();
for (Attribute a : attributes) {
if (a instanceof Code) {
removeAttribute(a);
}
}
code = new Code(cp.addUtf8("Code"), 8 + byte_code.length + // prologue byte code
2 + exc_len + // exceptions
2 + attrs_len, // attributes
maxStack, maxLocals, byte_code, c_exc, code_attrs, cp);
addAttribute(code);
}
addAnnotationsAsAttribute(cp);
addParameterAnnotationsAsAttribute(cp);
ExceptionTable et = null;
if (exceptionsThrown.size() > 0) {
addAttribute(et = getExceptionTable(cp)); // Add `Exceptions' if there are "throws" clauses
}
Method m = new Method(modifiers, name_index, signature_index, getAttributesImmutable(), cp);
// Undo effects of adding attributes
// OPTIMIZE why redo this? is there a better way to clean up?
if (lvt != null) {
removeCodeAttribute(lvt);
}
if (lnt != null) {
removeCodeAttribute(lnt);
}
if (code != null) {
removeAttribute(code);
}
if (et != null) {
removeAttribute(et);
}
// J5TODO: Remove the annotation attributes that may have been added
return m;
}
/**
* Set maximum number of local variables.
*/
public void setMaxLocals(int m) {
maxLocals = m;
}
public int getMaxLocals() {
return maxLocals;
}
/**
* Set maximum stack size for this method.
*/
public void setMaxStack(int m) {
maxStack = m;
}
public int getMaxStack() {
return maxStack;
}
/**
* @return class that contains this method
*/
public String getClassName() {
return classname;
}
public void setClassName(String class_name) {
this.classname = class_name;
}
public void setReturnType(Type return_type) {
setType(return_type);
}
public Type getReturnType() {
return getType();
}
public void setArgumentTypes(Type[] arg_types) {
this.parameterTypes = arg_types;
}
public Type[] getArgumentTypes() {
return this.parameterTypes;
}// OPTIMIZE dont need clone here? (Type[])arg_types.clone(); }
public void setArgumentType(int i, Type type) {
parameterTypes[i] = type;
}
public Type getArgumentType(int i) {
return parameterTypes[i];
}
public void setArgumentNames(String[] arg_names) {
this.parameterNames = arg_names;
}
public String[] getArgumentNames() {
if (parameterNames != null) {
return parameterNames.clone();
} else {
return new String[0];
}
}
public void setArgumentName(int i, String name) {
parameterNames[i] = name;
}
public String getArgumentName(int i) {
return parameterNames[i];
}
public InstructionList getInstructionList() {
return il;
}
public void setInstructionList(InstructionList il) {
this.il = il;
}
@Override
public String getSignature() {
return Utility.toMethodSignature(type, parameterTypes);
}
/**
* Computes max. stack size by performing control flow analysis.
*/
public void setMaxStack() {
if (il != null) {
maxStack = getMaxStack(cp, il, getExceptionHandlers());
} else {
maxStack = 0;
}
}
/**
* Compute maximum number of local variables based on the parameter count and bytecode usage of variables.
*/
public void setMaxLocals() {
setMaxLocals(false);
}
/**
* Compute maximum number of local variables.
*
* @param respectLocalVariableTable if true and the local variable table indicates more are in use
* than the code suggests, respect the higher value from the local variable table data.
*/
public void setMaxLocals(boolean respectLocalVariableTable) {
if (il != null) {
int max = isStatic() ? 0 : 1;
if (parameterTypes != null) {
for (Type parameterType : parameterTypes) {
max += parameterType.getSize();
}
}
for (InstructionHandle ih = il.getStart(); ih != null; ih = ih.getNext()) {
Instruction ins = ih.getInstruction();
if ((ins instanceof InstructionLV) || (ins instanceof RET)) {
int index = ins.getIndex() + ins.getType(cp).getSize();
if (index > max) {
max = index;
}
}
}
if (!respectLocalVariableTable || max > maxLocals) {
maxLocals = max;
}
} else {
if (!respectLocalVariableTable) {
maxLocals = 0;
}
}
}
public void stripAttributes(boolean flag) {
stripAttributes = flag;
}
static final class BranchTarget {
InstructionHandle target;
int stackDepth;
BranchTarget(InstructionHandle target, int stackDepth) {
this.target = target;
this.stackDepth = stackDepth;
}
}
static final class BranchStack {
Stack branchTargets = new Stack<>();
Map visitedTargets = new Hashtable<>();
public void push(InstructionHandle target, int stackDepth) {
if (visited(target)) {
return;
}
branchTargets.push(visit(target, stackDepth));
}
public BranchTarget pop() {
if (!branchTargets.empty()) {
BranchTarget bt = branchTargets.pop();
return bt;
}
return null;
}
private final BranchTarget visit(InstructionHandle target, int stackDepth) {
BranchTarget bt = new BranchTarget(target, stackDepth);
visitedTargets.put(target, bt);
return bt;
}
private final boolean visited(InstructionHandle target) {
return (visitedTargets.get(target) != null);
}
}
/**
* Computes stack usage of an instruction list by performing control flow analysis.
*
* @return maximum stack depth used by method
*/
public static int getMaxStack(ConstantPool cp, InstructionList il, CodeExceptionGen[] et) {
BranchStack branchTargets = new BranchStack();
int stackDepth = 0;
int maxStackDepth = 0;
/*
* Initially, populate the branch stack with the exception handlers, because these aren't (necessarily) branched to
* explicitly. In each case, the stack will have depth 1, containing the exception object.
*/
for (CodeExceptionGen codeExceptionGen : et) {
InstructionHandle handlerPos = codeExceptionGen.getHandlerPC();
if (handlerPos != null) {
// it must be at least 1 since there is an exception handler
maxStackDepth = 1;
branchTargets.push(handlerPos, 1);
}
}
InstructionHandle ih = il.getStart();
while (ih != null) {
Instruction instruction = ih.getInstruction();
short opcode = instruction.opcode;
int prod = instruction.produceStack(cp);
int con = instruction.consumeStack(cp);
int delta = prod - con;
stackDepth += delta;
if (stackDepth > maxStackDepth) {
maxStackDepth = stackDepth;
}
// choose the next instruction based on whether current is a branch.
if (instruction instanceof InstructionBranch) {
InstructionBranch branch = (InstructionBranch) instruction;
if (instruction instanceof InstructionSelect) {
// explore all of the select's targets. the default target is handled below.
InstructionSelect select = (InstructionSelect) branch;
InstructionHandle[] targets = select.getTargets();
for (InstructionHandle target : targets) {
branchTargets.push(target, stackDepth);
}
// nothing to fall through to.
ih = null;
} else if (!(branch.isIfInstruction())) {
// if an instruction that comes back to following PC,
// push next instruction, with stack depth reduced by 1.
if (opcode == Constants.JSR || opcode == Constants.JSR_W) {
branchTargets.push(ih.getNext(), stackDepth - 1);
}
ih = null;
}
// for all branches, the target of the branch is pushed on the branch stack.
// conditional branches have a fall through case, selects don't, and
// jsr/jsr_w return to the next instruction.
branchTargets.push(branch.getTarget(), stackDepth);
} else {
// check for instructions that terminate the method.
if (opcode == Constants.ATHROW || opcode == Constants.RET
|| (opcode >= Constants.IRETURN && opcode <= Constants.RETURN)) {
ih = null;
}
}
// normal case, go to the next instruction.
if (ih != null) {
ih = ih.getNext();
}
// if we have no more instructions, see if there are any deferred branches to explore.
if (ih == null) {
BranchTarget bt = branchTargets.pop();
if (bt != null) {
ih = bt.target;
stackDepth = bt.stackDepth;
}
}
}
return maxStackDepth;
}
/**
* Return string representation close to declaration format, `public static void main(String[]) throws IOException', e.g.
*
* @return String representation of the method.
*/
@Override
public final String toString() {
String access = Utility.accessToString(modifiers);
String signature = Utility.toMethodSignature(type, parameterTypes);
signature = Utility.methodSignatureToString(signature, name, access, true, getLocalVariableTable(cp));
StringBuilder buf = new StringBuilder(signature);
if (exceptionsThrown.size() > 0) {
for (String s : exceptionsThrown) {
buf.append("\n\t\tthrows " + s);
}
}
return buf.toString();
}
// J5TODO: Should param_annotations be an array of arrays? Rather than an array of lists, this
// is more likely to suggest to the caller it is readonly (which a List does not).
/**
* Return a list of AnnotationGen objects representing parameter annotations
*/
public List getAnnotationsOnParameter(int i) {
ensureExistingParameterAnnotationsUnpacked();
if (!hasParameterAnnotations || i > parameterTypes.length) {
return null;
}
return param_annotations[i];
}
/**
* Goes through the attributes on the method and identifies any that are RuntimeParameterAnnotations, extracting their contents
* and storing them as parameter annotations. There are two kinds of parameter annotation - visible and invisible. Once they
* have been unpacked, these attributes are deleted. (The annotations will be rebuilt as attributes when someone builds a Method
* object out of this MethodGen object).
*/
private void ensureExistingParameterAnnotationsUnpacked() {
if (haveUnpackedParameterAnnotations) {
return;
}
// Find attributes that contain parameter annotation data
List attrs = getAttributes();
RuntimeParamAnnos paramAnnVisAttr = null;
RuntimeParamAnnos paramAnnInvisAttr = null;
for (Attribute attribute : attrs) {
if (attribute instanceof RuntimeParamAnnos) {
if (!hasParameterAnnotations) {
param_annotations = new List[parameterTypes.length];
for (int j = 0; j < parameterTypes.length; j++) {
param_annotations[j] = new ArrayList<>();
}
}
hasParameterAnnotations = true;
RuntimeParamAnnos rpa = (RuntimeParamAnnos) attribute;
if (rpa.areVisible()) {
paramAnnVisAttr = rpa;
} else {
paramAnnInvisAttr = rpa;
}
for (int j = 0; j < parameterTypes.length; j++) {
// This returns Annotation[] ...
AnnotationGen[] annos = rpa.getAnnotationsOnParameter(j);
// ... which needs transforming into an AnnotationGen[] ...
// List mutable = makeMutableVersion(immutableArray);
// ... then add these to any we already know about
for (AnnotationGen anAnnotation : annos) {
param_annotations[j].add(anAnnotation);
}
}
}
}
if (paramAnnVisAttr != null) {
removeAttribute(paramAnnVisAttr);
}
if (paramAnnInvisAttr != null) {
removeAttribute(paramAnnInvisAttr);
}
haveUnpackedParameterAnnotations = true;
}
private List /* AnnotationGen */ makeMutableVersion(AnnotationGen[] mutableArray) {
List result = new ArrayList<>();
for (AnnotationGen annotationGen : mutableArray) {
result.add(new AnnotationGen(annotationGen, getConstantPool(), false));
}
return result;
}
public void addParameterAnnotation(int parameterIndex, AnnotationGen annotation) {
ensureExistingParameterAnnotationsUnpacked();
if (!hasParameterAnnotations) {
param_annotations = new List[parameterTypes.length];
hasParameterAnnotations = true;
}
List existingAnnotations = param_annotations[parameterIndex];
if (existingAnnotations != null) {
existingAnnotations.add(annotation);
} else {
List l = new ArrayList<>();
l.add(annotation);
param_annotations[parameterIndex] = l;
}
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy