/** Checks the specific method for consistency. */
public static void checkMgen(MethodGen mgen) {
if (skip_checks) return;
try {
mgen.toString();
mgen.getLineNumberTable(mgen.getConstantPool());
InstructionList ilist = mgen.getInstructionList();
if (ilist == null || ilist.getStart() == null) return;
CodeExceptionGen[] exceptionHandlers = mgen.getExceptionHandlers();
for (CodeExceptionGen gen : exceptionHandlers) {
assert ilist.contains(gen.getStartPC())
: "exception handler "
+ gen
+ " has been forgotten in "
+ mgen.getClassName()
+ "."
+ mgen.getName();
}
MethodGen nmg = new MethodGen(mgen.getMethod(), mgen.getClassName(), mgen.getConstantPool());
nmg.getLineNumberTable(mgen.getConstantPool());
} catch (Throwable t) {
System.out.printf("failure in method %s.%s\n", mgen.getClassName(), mgen.getName());
t.printStackTrace();
throw new Error(t);
}
}
/**
* Returns true iff mgen is a constructor
*
* @return true iff mgen is a constructor
*/
private boolean is_constructor(MethodGen mgen) {
if (mgen.getName().equals("<init>") || mgen.getName().equals("")) {
// log ("method '%s' is a constructor%n", mgen.getName());
return (true);
} else return (false);
}
/**
* Returns whether or not this is a standard main method (static, name is 'main', and one argument
* of string array
*/
public static boolean is_main(MethodGen mg) {
Type[] arg_types = mg.getArgumentTypes();
return (mg.isStatic()
&& mg.getName().equals("main")
&& (arg_types.length == 1)
&& arg_types[0].equals(string_array));
}
public LockAnalysis(MethodGen methodGen, ValueNumberDataflow vnaDataflow, DepthFirstSearch dfs) {
super(dfs);
this.methodGen = methodGen;
this.vnaDataflow = vnaDataflow;
this.vna = vnaDataflow.getAnalysis();
this.isSynchronized = methodGen.isSynchronized();
this.isStatic = methodGen.isStatic();
if (DEBUG) {
System.out.println(
"Analyzing Locks in " + methodGen.getClassName() + "." + methodGen.getName());
}
}
private void lockOp(LockSet fact, int lockNumber, int delta) {
int value = fact.getLockCount(lockNumber);
if (value < 0) {
return;
}
value += delta;
if (value < 0) {
value = LockSet.BOTTOM;
}
if (DEBUG) {
System.out.println(
"Setting "
+ lockNumber
+ " to "
+ value
+ " in "
+ methodGen.getClassName()
+ "."
+ methodGen.getName());
}
fact.setLockCount(lockNumber, value);
}
byte[] counterAdaptClass(final InputStream is, final String name) throws Exception {
JavaClass jc = new ClassParser(is, name + ".class").parse();
ClassGen cg = new ClassGen(jc);
String cName = cg.getClassName();
ConstantPoolGen cp = cg.getConstantPool();
if (!cg.isInterface()) {
FieldGen fg = new FieldGen(ACC_PUBLIC, Type.getType("I"), "_counter", cp);
cg.addField(fg.getField());
}
Method[] ms = cg.getMethods();
for (int j = 0; j < ms.length; ++j) {
MethodGen mg = new MethodGen(ms[j], cg.getClassName(), cp);
if (!mg.getName().equals("<init>") && !mg.isStatic() && !mg.isAbstract() && !mg.isNative()) {
if (mg.getInstructionList() != null) {
InstructionList il = new InstructionList();
il.append(new ALOAD(0));
il.append(new ALOAD(0));
il.append(new GETFIELD(cp.addFieldref(name, "_counter", "I")));
il.append(new ICONST(1));
il.append(new IADD());
il.append(new PUTFIELD(cp.addFieldref(name, "_counter", "I")));
mg.getInstructionList().insert(il);
mg.setMaxStack(Math.max(mg.getMaxStack(), 2));
boolean lv = ms[j].getLocalVariableTable() == null;
boolean ln = ms[j].getLineNumberTable() == null;
if (lv) {
mg.removeLocalVariables();
}
if (ln) {
mg.removeLineNumbers();
}
cg.replaceMethod(ms[j], mg.getMethod());
}
}
}
return cg.getJavaClass().getBytes();
}
/**
* Constructor.
*
* @param rdfs the reverse depth-first-search (for the block order)
* @param cfg the CFG for the method
* @param methodGen the MethodGen for the method
* @param vnaDataflow
* @param assertionMethods AssertionMethods for the analyzed class
*/
public UnconditionalValueDerefAnalysis(
ReverseDepthFirstSearch rdfs,
DepthFirstSearch dfs,
CFG cfg,
Method method,
MethodGen methodGen,
ValueNumberDataflow vnaDataflow,
AssertionMethods assertionMethods) {
super(rdfs, dfs);
this.cfg = cfg;
this.methodGen = methodGen;
this.method = method;
this.vnaDataflow = vnaDataflow;
this.assertionMethods = assertionMethods;
if (DEBUG) {
System.out.println(
"UnconditionalValueDerefAnalysis analysis "
+ methodGen.getClassName()
+ "."
+ methodGen.getName()
+ " : "
+ methodGen.getSignature());
}
}
private static String getFullMethodName(MethodGen methodGen) {
String methodNameWithSignature = methodGen.getName() + methodGen.getSignature();
String slashedClassName = methodGen.getClassName().replace('.', '/');
return slashedClassName + "." + methodNameWithSignature;
}
private static void addTimer(ClassGen cgen, Method method) {
// set up the construction tools
InstructionFactory ifact = new InstructionFactory(cgen);
InstructionList ilist = new InstructionList();
ConstantPoolGen pgen = cgen.getConstantPool();
String cname = cgen.getClassName();
MethodGen wrapgen = new MethodGen(method, cname, pgen);
wrapgen.setInstructionList(ilist);
// rename a copy of the original method
MethodGen methgen = new MethodGen(method, cname, pgen);
cgen.removeMethod(method);
String iname = methgen.getName() + "_timing";
methgen.setName(iname);
cgen.addMethod(methgen.getMethod());
Type result = methgen.getReturnType();
// compute the size of the calling parameters
Type[] parameters = methgen.getArgumentTypes();
int stackIndex = methgen.isStatic() ? 0 : 1;
for (int i = 0; i < parameters.length; i++) {
stackIndex += parameters[i].getSize();
}
// save time prior to invocation
ilist.append(
ifact.createInvoke(
"java.lang.System",
"currentTimeMillis",
Type.LONG,
Type.NO_ARGS,
Constants.INVOKESTATIC));
ilist.append(InstructionFactory.createStore(Type.LONG, stackIndex));
// call the wrapped method
int offset = 0;
short invoke = Constants.INVOKESTATIC;
if (!methgen.isStatic()) {
ilist.append(InstructionFactory.createLoad(Type.OBJECT, 0));
offset = 1;
invoke = Constants.INVOKEVIRTUAL;
}
for (int i = 0; i < parameters.length; i++) {
Type type = parameters[i];
ilist.append(InstructionFactory.createLoad(type, offset));
offset += type.getSize();
}
ilist.append(ifact.createInvoke(cname, iname, result, parameters, invoke));
// store result for return later
if (result != Type.VOID) {
ilist.append(InstructionFactory.createStore(result, stackIndex + 2));
}
// print time required for method call
ilist.append(
ifact.createFieldAccess(
"java.lang.System", "out", new ObjectType("java.io.PrintStream"), Constants.GETSTATIC));
ilist.append(InstructionConstants.DUP);
ilist.append(InstructionConstants.DUP);
String text = "Call to method " + methgen.getName() + " took ";
ilist.append(new PUSH(pgen, text));
ilist.append(
ifact.createInvoke(
"java.io.PrintStream",
"print",
Type.VOID,
new Type[] {Type.STRING},
Constants.INVOKEVIRTUAL));
ilist.append(
ifact.createInvoke(
"java.lang.System",
"currentTimeMillis",
Type.LONG,
Type.NO_ARGS,
Constants.INVOKESTATIC));
ilist.append(InstructionFactory.createLoad(Type.LONG, stackIndex));
ilist.append(InstructionConstants.LSUB);
ilist.append(
ifact.createInvoke(
"java.io.PrintStream",
"print",
Type.VOID,
new Type[] {Type.LONG},
Constants.INVOKEVIRTUAL));
ilist.append(new PUSH(pgen, " ms."));
ilist.append(
ifact.createInvoke(
"java.io.PrintStream",
"println",
Type.VOID,
new Type[] {Type.STRING},
Constants.INVOKEVIRTUAL));
// return result from wrapped method call
if (result != Type.VOID) {
ilist.append(InstructionFactory.createLoad(result, stackIndex + 2));
}
ilist.append(InstructionFactory.createReturn(result));
// finalize the constructed method
wrapgen.stripAttributes(true);
wrapgen.setMaxStack();
wrapgen.setMaxLocals();
cgen.addMethod(wrapgen.getMethod());
ilist.dispose();
}
/**
* Transforms invoke instructions that match the specified list for this class to call the
* specified static call instead.
*/
private InstructionList xform_inst(MethodGen mg, Instruction inst) {
switch (inst.getOpcode()) {
case Constants.INVOKESTATIC:
{
InstructionList il = new InstructionList();
INVOKESTATIC is = (INVOKESTATIC) inst;
String cname = is.getClassName(pgen);
String mname = is.getMethodName(pgen);
Type[] args = is.getArgumentTypes(pgen);
MethodDef orig = new MethodDef(cname + "." + mname, args);
MethodInfo call = method_map.get(orig);
if (call != null) {
call.cnt++;
String classname = call.method_class;
String methodname = mname;
debug_map.log(
"%s.%s: Replacing method %s.%s (%s) with %s.%s%n",
mg.getClassName(),
mg.getName(),
cname,
mname,
UtilMDE.join(args, ", "),
classname,
methodname);
il.append(
ifact.createInvoke(
classname, methodname, is.getReturnType(pgen), args, Constants.INVOKESTATIC));
}
return (il);
}
case Constants.INVOKEVIRTUAL:
{
InstructionList il = new InstructionList();
INVOKEVIRTUAL iv = (INVOKEVIRTUAL) inst;
String cname = iv.getClassName(pgen);
String mname = iv.getMethodName(pgen);
Type[] args = iv.getArgumentTypes(pgen);
Type instance_type = iv.getReferenceType(pgen);
Type[] new_args = BCELUtil.insert_type(instance_type, args);
MethodDef orig = new MethodDef(cname + "." + mname, args);
if (debug_class) System.out.printf("looking for %s in map %s%n", orig, method_map);
MethodInfo call = method_map.get(orig);
if (call != null) {
call.cnt++;
String classname = call.method_class;
String methodname = mname;
debug_map.log(
"Replacing method %s.%s (%s) with %s.%s%n",
cname, mname, ArraysMDE.toString(args), classname, methodname);
il.append(
ifact.createInvoke(
classname,
methodname,
iv.getReturnType(pgen),
new_args,
Constants.INVOKESTATIC));
}
return (il);
}
default:
return (null);
}
}
/** returns whether or not the specified method is a class initializer */
public static boolean is_clinit(MethodGen mg) {
return (mg.getName().equals("<clinit>"));
}
/** returns whether or not the specified method is a constructor * */
public static boolean is_constructor(MethodGen mg) {
return (mg.getName().equals("<init>") || mg.getName().equals(""));
}
private void analyzeMethod(ClassContext classContext, Method method)
throws CFGBuilderException, DataflowAnalysisException {
if (isSynthetic(method) || !prescreen(classContext, method)) return;
XMethod xmethod = XFactory.createXMethod(classContext.getJavaClass(), method);
if (xmethod.isSynthetic()) return;
BugAccumulator accumulator = new BugAccumulator(bugReporter);
CFG cfg = classContext.getCFG(method);
TypeDataflow typeDataflow = classContext.getTypeDataflow(method);
ValueNumberDataflow vnDataflow = classContext.getValueNumberDataflow(method);
ConstantPoolGen cpg = classContext.getConstantPoolGen();
MethodGen methodGen = classContext.getMethodGen(method);
if (methodGen == null) return;
String fullMethodName = methodGen.getClassName() + "." + methodGen.getName();
String sourceFile = classContext.getJavaClass().getSourceFileName();
if (DEBUG) {
System.out.println("\n" + fullMethodName);
}
// Process each instruction
for (Iterator<Location> iter = cfg.locationIterator(); iter.hasNext(); ) {
Location location = iter.next();
InstructionHandle handle = location.getHandle();
Instruction ins = handle.getInstruction();
// Only consider invoke instructions
if (!(ins instanceof InvokeInstruction)) continue;
InvokeInstruction inv = (InvokeInstruction) ins;
XMethod invokedMethod = XFactory.createXMethod(inv, cpg);
String invokedMethodName = invokedMethod.getName();
String argSignature = invokedMethod.getSignature();
argSignature = argSignature.substring(0, argSignature.indexOf(')') + 1);
String call = invokedMethodName + argSignature;
SignatureParser sigParser = new SignatureParser(inv.getSignature(cpg));
Collection<Info> collection = callMap.get(call);
if (!callMap.containsKey(call)) continue;
for (Info info : collection) {
Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2();
if (DEBUG)
System.out.println(
"at "
+ handle.getPosition()
+ " Checking call to "
+ info.interfaceForCall
+ " : "
+ invokedMethod);
try {
if (!subtypes2.isSubtype(invokedMethod.getClassDescriptor(), info.interfaceForCall))
continue;
} catch (ClassNotFoundException e) {
if (info.interfaceForCall.getClassName().equals("java/util/Collection")
&& invokedMethod.getClassName().equals("com.google.common.collect.Multiset")) {
assert true;
// we know this is OK without needing to find definition of Multiset
} else {
AnalysisContext.reportMissingClass(e);
continue;
}
}
boolean allMethod;
int typeArgument;
if (info.typeIndex >= 0) {
allMethod = false;
typeArgument = info.typeIndex;
} else {
allMethod = true;
typeArgument = -(1 + info.typeIndex);
}
int pos = info.argumentIndex;
int lhsPos;
if (inv instanceof INVOKESTATIC) lhsPos = sigParser.getSlotsFromTopOfStackForParameter(0);
else lhsPos = sigParser.getTotalArgumentSize();
int stackPos = sigParser.getSlotsFromTopOfStackForParameter(pos);
TypeFrame frame = typeDataflow.getFactAtLocation(location);
if (!frame.isValid()) {
// This basic block is probably dead
continue;
}
Type operandType = frame.getStackValue(stackPos);
if (operandType.equals(TopType.instance())) {
// unreachable
continue;
}
if (operandType.equals(NullType.instance())) {
// ignore
continue;
}
ValueNumberFrame vnFrame = vnDataflow.getFactAtLocation(location);
if (!vnFrame.isValid()) {
AnalysisContext.logError("Invalid value number frame in " + xmethod);
continue;
}
ValueNumber objectVN = vnFrame.getStackValue(lhsPos);
ValueNumber argVN = vnFrame.getStackValue(stackPos);
if (objectVN.equals(argVN)) {
String bugPattern = "DMI_COLLECTIONS_SHOULD_NOT_CONTAIN_THEMSELVES";
int priority = HIGH_PRIORITY;
if (invokedMethodName.equals("removeAll")) {
bugPattern = "DMI_USING_REMOVEALL_TO_CLEAR_COLLECTION";
priority = NORMAL_PRIORITY;
} else if (invokedMethodName.endsWith("All")) {
bugPattern = "DMI_VACUOUS_SELF_COLLECTION_CALL";
priority = NORMAL_PRIORITY;
}
if (invokedMethodName.startsWith("contains")) {
InstructionHandle next = handle.getNext();
if (next != null) {
Instruction nextIns = next.getInstruction();
if (nextIns instanceof InvokeInstruction) {
XMethod nextMethod = XFactory.createXMethod((InvokeInstruction) nextIns, cpg);
if (nextMethod.getName().equals("assertFalse")) continue;
}
}
}
accumulator.accumulateBug(
new BugInstance(this, bugPattern, priority)
.addClassAndMethod(methodGen, sourceFile)
.addCalledMethod(methodGen, (InvokeInstruction) ins)
.addOptionalAnnotation(
ValueNumberSourceInfo.findAnnotationFromValueNumber(
method, location, objectVN, vnFrame, "INVOKED_ON")),
SourceLineAnnotation.fromVisitedInstruction(
classContext, methodGen, sourceFile, handle));
}
// Only consider generic...
Type objectType = frame.getStackValue(lhsPos);
if (!(objectType instanceof GenericObjectType)) continue;
GenericObjectType operand = (GenericObjectType) objectType;
int expectedTypeParameters = 1;
String simpleName = info.interfaceForCall.getSimpleName();
if (simpleName.toLowerCase().endsWith("map") || simpleName.equals("Hashtable"))
expectedTypeParameters = 2;
else if (simpleName.equals("Table")) expectedTypeParameters = 3;
// ... containers
if (!operand.hasParameters()) continue;
if (operand.getNumParameters() != expectedTypeParameters) continue;
ClassDescriptor operandClass = DescriptorFactory.getClassDescriptor(operand);
if (!isGenericCollection(operandClass)) continue;
if (expectedTypeParameters == 2
&& Subtypes2.instanceOf(operandClass, Map.class)
&& !TypeFrameModelingVisitor.isStraightGenericMap(operandClass)) continue;
Type expectedType;
if (allMethod) expectedType = operand;
else expectedType = operand.getParameterAt(typeArgument);
Type actualType = frame.getStackValue(stackPos);
Type equalsType = actualType;
if (allMethod) {
if (!(actualType instanceof GenericObjectType)) {
continue;
}
equalsType = ((GenericObjectType) actualType).getParameterAt(typeArgument);
}
IncompatibleTypes matchResult = compareTypes(expectedType, actualType, allMethod);
boolean parmIsObject = expectedType.getSignature().equals("Ljava/lang/Object;");
boolean selfOperation = !allMethod && operand.equals(actualType) && !parmIsObject;
if (!allMethod && !parmIsObject && actualType instanceof GenericObjectType) {
GenericObjectType p2 = (GenericObjectType) actualType;
List<? extends ReferenceType> parameters = p2.getParameters();
if (parameters != null && parameters.equals(operand.getParameters()))
selfOperation = true;
}
if (!selfOperation
&& (matchResult == IncompatibleTypes.SEEMS_OK
|| matchResult.getPriority() == Priorities.IGNORE_PRIORITY)) continue;
if (invokedMethodName.startsWith("contains") || invokedMethodName.equals("remove")) {
InstructionHandle next = handle.getNext();
if (next != null) {
Instruction nextIns = next.getInstruction();
if (nextIns instanceof InvokeInstruction) {
XMethod nextMethod = XFactory.createXMethod((InvokeInstruction) nextIns, cpg);
if (nextMethod.getName().equals("assertFalse")) continue;
}
}
} else if (invokedMethodName.equals("get") || invokedMethodName.equals("remove")) {
InstructionHandle next = handle.getNext();
if (next != null) {
Instruction nextIns = next.getInstruction();
if (nextIns instanceof InvokeInstruction) {
XMethod nextMethod = XFactory.createXMethod((InvokeInstruction) nextIns, cpg);
if (nextMethod.getName().equals("assertNull")) continue;
}
}
}
boolean noisy = false;
if (invokedMethodName.equals("get")) {
UnconditionalValueDerefDataflow unconditionalValueDerefDataflow =
classContext.getUnconditionalValueDerefDataflow(method);
UnconditionalValueDerefSet unconditionalDeref =
unconditionalValueDerefDataflow.getFactAtLocation(location);
ValueNumberFrame vnAfter = vnDataflow.getFactAfterLocation(location);
ValueNumber top = vnAfter.getTopValue();
noisy =
unconditionalDeref.getValueNumbersThatAreUnconditionallyDereferenced().contains(top);
}
// Prepare bug report
SourceLineAnnotation sourceLineAnnotation =
SourceLineAnnotation.fromVisitedInstruction(
classContext, methodGen, sourceFile, handle);
// Report a bug that mentions each of the failed arguments in
// matches
if (expectedType instanceof GenericObjectType)
expectedType = ((GenericObjectType) expectedType).getUpperBound();
int priority = matchResult.getPriority();
if (!operandClass.getClassName().startsWith("java/util")
&& priority == Priorities.HIGH_PRIORITY)
priority = Math.max(priority, Priorities.NORMAL_PRIORITY);
if (TestCaseDetector.likelyTestCase(xmethod))
priority = Math.max(priority, Priorities.NORMAL_PRIORITY);
else if (selfOperation) priority = Priorities.HIGH_PRIORITY;
ClassDescriptor expectedClassDescriptor =
DescriptorFactory.createClassOrObjectDescriptorFromSignature(
expectedType.getSignature());
ClassDescriptor actualClassDescriptor =
DescriptorFactory.createClassOrObjectDescriptorFromSignature(equalsType.getSignature());
ClassSummary classSummary = AnalysisContext.currentAnalysisContext().getClassSummary();
Set<XMethod> targets = null;
try {
targets =
Hierarchy2.resolveVirtualMethodCallTargets(
actualClassDescriptor, "equals", "(Ljava/lang/Object;)Z", false, false);
boolean allOk = targets.size() > 0;
for (XMethod m2 : targets)
if (!classSummary.mightBeEqualTo(m2.getClassDescriptor(), expectedClassDescriptor))
allOk = false;
if (allOk) priority += 2;
} catch (ClassNotFoundException e) {
AnalysisContext.reportMissingClass(e);
}
String bugPattern = "GC_UNRELATED_TYPES";
BugInstance bug =
new BugInstance(this, bugPattern, priority)
.addClassAndMethod(methodGen, sourceFile)
.addFoundAndExpectedType(actualType, expectedType)
.addCalledMethod(methodGen, (InvokeInstruction) ins)
.addOptionalAnnotation(
ValueNumberSourceInfo.findAnnotationFromValueNumber(
method, location, objectVN, vnFrame, "INVOKED_ON"))
.addOptionalAnnotation(
ValueNumberSourceInfo.findAnnotationFromValueNumber(
method, location, argVN, vnFrame, "ARGUMENT"))
.addEqualsMethodUsed(targets);
if (noisy) {
WarningPropertySet<WarningProperty> propertySet =
new WarningPropertySet<WarningProperty>();
propertySet.addProperty(GeneralWarningProperty.NOISY_BUG);
propertySet.decorateBugInstance(bug);
}
accumulator.accumulateBug(bug, sourceLineAnnotation);
}
}
accumulator.reportAccumulatedBugs();
}
/**
* Creates a proxy method for the original method specified. This method has the same signature as
* the original method and catches the invocation for further processing by the framework before
* redirecting to the original method.
*
* @todo pass the 'class' as a Class instance not a String to the join point. Add the class field
* to the class using BCEL (see AdviseStaticMethodTransformer.java)
* @param cp the ConstantPoolGen
* @param cg the ClassGen
* @param originalMethod the current method
* @param factory the objectfactory
* @param methodId the id of the current method in the lookup tabl
* @param methodSequence the methods sequence number
* @param accessFlags the access flags of the original method
* @param uuid the uuid for the weave model defining the pointcut
* @param controllerClassName the class name of the controller class to use
* @return the proxy method
*/
private Method createProxyMethod(
final ConstantPoolGen cp,
final ClassGen cg,
final MethodGen originalMethod,
final InstructionFactory factory,
final int methodId,
final int methodSequence,
final int accessFlags,
final String uuid,
final String controllerClassName) {
InstructionList il = new InstructionList();
String joinPoint = getJoinPointName(originalMethod.getMethod(), methodSequence);
final MethodGen method =
new MethodGen(
accessFlags,
Type.getReturnType(originalMethod.getSignature()),
Type.getArgumentTypes(originalMethod.getSignature()),
originalMethod.getArgumentNames(),
originalMethod.getName(),
cg.getClassName(),
il,
cp);
String[] exceptions = originalMethod.getExceptions();
for (int i = 0; i < exceptions.length; i++) {
method.addException(exceptions[i]);
}
int indexParam = 1;
int indexStack = 0;
int indexJoinPoint = Type.getArgumentTypes(originalMethod.getSignature()).length * 2 + 1;
// if (threadLocal == null) {
// threadLocal = new SerializableThreadLocal();
// }
il.append(factory.createLoad(Type.OBJECT, 0));
il.append(
factory.createFieldAccess(
cg.getClassName(),
joinPoint,
new ObjectType(TransformationUtil.THREAD_LOCAL_CLASS),
Constants.GETFIELD));
BranchInstruction ifNotNull = factory.createBranchInstruction(Constants.IFNONNULL, null);
il.append(ifNotNull);
il.append(factory.createLoad(Type.OBJECT, 0));
il.append(factory.createNew(TransformationUtil.THREAD_LOCAL_CLASS));
il.append(InstructionConstants.DUP);
il.append(
factory.createInvoke(
TransformationUtil.THREAD_LOCAL_CLASS,
"<init>",
Type.VOID,
Type.NO_ARGS,
Constants.INVOKESPECIAL));
il.append(
factory.createFieldAccess(
cg.getClassName(),
joinPoint.toString(),
new ObjectType(TransformationUtil.THREAD_LOCAL_CLASS),
Constants.PUTFIELD));
// Object joinPoint = ___jp.get();
BranchInstruction biIfNotNull = null;
InstructionHandle ihIfNotNull = null;
ifNotNull.setTarget(il.append(factory.createLoad(Type.OBJECT, 0)));
il.append(
factory.createFieldAccess(
cg.getClassName(),
joinPoint.toString(),
new ObjectType(TransformationUtil.THREAD_LOCAL_CLASS),
Constants.GETFIELD));
il.append(
factory.createInvoke(
TransformationUtil.THREAD_LOCAL_CLASS,
"get",
Type.OBJECT,
Type.NO_ARGS,
Constants.INVOKEVIRTUAL));
il.append(factory.createStore(Type.OBJECT, indexJoinPoint));
il.append(factory.createLoad(Type.OBJECT, indexJoinPoint));
// if (joinPoint == null) {
biIfNotNull = factory.createBranchInstruction(Constants.IFNONNULL, null);
il.append(biIfNotNull);
// joinPoint = new WeakReference(new MemberMethodJoinPoint(uuid, this, "foo.bar.Baz", 10));
// il.append(factory.createNew(TransformationUtil.WEAK_REFERENCE_CLASS));
// il.append(InstructionConstants.DUP);
il.append(factory.createNew(TransformationUtil.MEMBER_METHOD_JOIN_POINT_CLASS));
il.append(InstructionConstants.DUP);
il.append(new PUSH(cp, uuid));
il.append(factory.createLoad(Type.OBJECT, 0));
il.append(new PUSH(cp, cg.getClassName()));
il.append(new PUSH(cp, methodId));
il.append(new PUSH(cp, controllerClassName));
il.append(
factory.createInvoke(
TransformationUtil.MEMBER_METHOD_JOIN_POINT_CLASS,
"<init>",
Type.VOID,
new Type[] {Type.STRING, Type.OBJECT, Type.STRING, Type.INT, Type.STRING},
Constants.INVOKESPECIAL));
il.append(factory.createStore(Type.OBJECT, indexJoinPoint));
// threadLocal.set(joinPoint);
il.append(factory.createLoad(Type.OBJECT, 0));
il.append(
factory.createFieldAccess(
cg.getClassName(),
joinPoint.toString(),
new ObjectType(TransformationUtil.THREAD_LOCAL_CLASS),
Constants.GETFIELD));
il.append(factory.createLoad(Type.OBJECT, indexJoinPoint));
il.append(
factory.createInvoke(
TransformationUtil.THREAD_LOCAL_CLASS,
"set",
Type.VOID,
new Type[] {Type.OBJECT},
Constants.INVOKEVIRTUAL));
ihIfNotNull = il.append(factory.createLoad(Type.OBJECT, indexJoinPoint));
indexJoinPoint += 2;
il.append(factory.createCheckCast(TransformationUtil.MEMBER_METHOD_JOIN_POINT_TYPE));
il.append(factory.createStore(Type.OBJECT, indexJoinPoint));
biIfNotNull.setTarget(ihIfNotNull);
// if we have parameters, wrap them up
if (Type.getArgumentTypes(originalMethod.getSignature()).length != 0) {
// create and allocate the parameters array
il.append(new PUSH(cp, Type.getArgumentTypes(originalMethod.getSignature()).length));
il.append(factory.createNewArray(Type.OBJECT, (short) 1));
il.append(InstructionConstants.DUP);
il.append(new PUSH(cp, indexStack));
indexStack++;
// add all the parameters, wrap the primitive types in their object counterparts
for (int count = 0;
count < Type.getArgumentTypes(originalMethod.getSignature()).length;
count++) {
String wrapperClass = null;
BasicType type = null;
boolean hasLongOrDouble = false;
if (Type.getArgumentTypes(originalMethod.getSignature())[count] instanceof ObjectType
|| Type.getArgumentTypes(originalMethod.getSignature())[count] instanceof ArrayType) {
// we have an object or an array
il.append(factory.createLoad(Type.OBJECT, indexParam));
il.append(InstructionConstants.AASTORE);
indexParam++;
} else if (Type.getArgumentTypes(originalMethod.getSignature())[count]
instanceof ArrayType) {
// we have an array
il.append(factory.createLoad(Type.OBJECT, indexParam));
il.append(InstructionConstants.AASTORE);
indexParam++;
} else if (Type.getArgumentTypes(originalMethod.getSignature())[count]
instanceof BasicType) {
hasLongOrDouble = false;
// we have a primitive type
if ((Type.getArgumentTypes(originalMethod.getSignature())[count]).equals(Type.LONG)) {
wrapperClass = "java.lang.Long";
type = Type.LONG;
hasLongOrDouble = true;
} else if ((Type.getArgumentTypes(originalMethod.getSignature())[count])
.equals(Type.INT)) {
wrapperClass = "java.lang.Integer";
type = Type.INT;
} else if ((Type.getArgumentTypes(originalMethod.getSignature())[count])
.equals(Type.SHORT)) {
wrapperClass = "java.lang.Short";
type = Type.SHORT;
} else if ((Type.getArgumentTypes(originalMethod.getSignature())[count])
.equals(Type.DOUBLE)) {
wrapperClass = "java.lang.Double";
type = Type.DOUBLE;
hasLongOrDouble = true;
} else if ((Type.getArgumentTypes(originalMethod.getSignature())[count])
.equals(Type.FLOAT)) {
wrapperClass = "java.lang.Float";
type = Type.FLOAT;
} else if ((Type.getArgumentTypes(originalMethod.getSignature())[count])
.equals(Type.CHAR)) {
wrapperClass = "java.lang.Character";
type = Type.CHAR;
} else if ((Type.getArgumentTypes(originalMethod.getSignature())[count])
.equals(Type.BYTE)) {
wrapperClass = "java.lang.Byte";
type = Type.BYTE;
} else if ((Type.getArgumentTypes(originalMethod.getSignature())[count])
.equals(Type.BOOLEAN)) {
wrapperClass = "java.lang.Boolean";
type = Type.BOOLEAN;
} else {
throw new RuntimeException(
"unknown parameter type: "
+ Type.getArgumentTypes(originalMethod.getSignature())[count]);
}
il.append(factory.createNew(wrapperClass));
il.append(InstructionConstants.DUP);
il.append(factory.createLoad(type, indexParam));
il.append(
factory.createInvoke(
wrapperClass, "<init>", Type.VOID, new Type[] {type}, Constants.INVOKESPECIAL));
il.append(InstructionConstants.AASTORE);
indexParam++;
} // end handle basic or object type
if (count != Type.getArgumentTypes(originalMethod.getSignature()).length - 1) {
// if we don't have the last parameter, create the parameter on the stack
il.append(InstructionConstants.DUP);
il.append(new PUSH(cp, indexStack));
indexStack++;
// long or double needs two registers to fit
if (hasLongOrDouble) indexParam++;
}
}
// create the object array
il.append(factory.createStore(Type.OBJECT, indexParam));
// if threadsafe grab the newly retrieved local join point field from the stack
il.append(factory.createLoad(Type.OBJECT, indexJoinPoint));
// invoke joinPoint.setParameter(..)
il.append(factory.createLoad(Type.OBJECT, indexParam));
il.append(
factory.createInvoke(
TransformationUtil.MEMBER_METHOD_JOIN_POINT_CLASS,
"setParameters",
Type.VOID,
new Type[] {new ArrayType(Type.OBJECT, 1)},
Constants.INVOKEVIRTUAL));
indexParam++;
} // end - if parameters.length != 0
// if threadsafe grab the newly retrieved local join point field from the stack
il.append(factory.createLoad(Type.OBJECT, indexJoinPoint));
il.append(
factory.createInvoke(
TransformationUtil.MEMBER_METHOD_JOIN_POINT_CLASS,
"proceed",
Type.OBJECT,
Type.NO_ARGS,
Constants.INVOKEVIRTUAL));
if (!Type.getReturnType(originalMethod.getSignature()).equals(Type.VOID)) {
// create the result from the invocation
il.append(factory.createStore(Type.OBJECT, indexParam));
il.append(factory.createLoad(Type.OBJECT, indexParam));
// cast the result and return it, if the return type is a
// primitive type, retrieve it from the wrapped object first
// unless the return object is null (AW-100)
if (Type.getReturnType(originalMethod.getSignature()) instanceof BasicType) {
if (Type.getReturnType(originalMethod.getSignature()).equals(Type.VOID)) {; // skip
} else {
BranchInstruction ifNullBranch =
factory.createBranchInstruction(Constants.IFNONNULL, null);
InstructionHandle elseBranch = null;
il.append(ifNullBranch);
if (Type.getReturnType(originalMethod.getSignature()).equals(Type.LONG)) {
il.append(new PUSH(cp, 0L));
il.append(factory.createReturn(Type.LONG));
elseBranch = il.append(factory.createLoad(Type.OBJECT, indexParam));
il.append(factory.createCheckCast(new ObjectType("java.lang.Long")));
il.append(
factory.createInvoke(
"java.lang.Long",
"longValue",
Type.LONG,
Type.NO_ARGS,
Constants.INVOKEVIRTUAL));
} else if (Type.getReturnType(originalMethod.getSignature()).equals(Type.INT)) {
il.append(new PUSH(cp, 0));
il.append(factory.createReturn(Type.INT));
elseBranch = il.append(factory.createLoad(Type.OBJECT, indexParam));
il.append(factory.createCheckCast(new ObjectType("java.lang.Integer")));
il.append(
factory.createInvoke(
"java.lang.Integer",
"intValue",
Type.INT,
Type.NO_ARGS,
Constants.INVOKEVIRTUAL));
} else if (Type.getReturnType(originalMethod.getSignature()).equals(Type.SHORT)) {
il.append(new PUSH(cp, (short) 0));
il.append(factory.createReturn(Type.SHORT));
elseBranch = il.append(factory.createLoad(Type.OBJECT, indexParam));
il.append(factory.createCheckCast(new ObjectType("java.lang.Short")));
il.append(
factory.createInvoke(
"java.lang.Short",
"shortValue",
Type.SHORT,
Type.NO_ARGS,
Constants.INVOKEVIRTUAL));
} else if (Type.getReturnType(originalMethod.getSignature()).equals(Type.DOUBLE)) {
il.append(new PUSH(cp, 0.0d));
il.append(factory.createReturn(Type.DOUBLE));
elseBranch = il.append(factory.createLoad(Type.OBJECT, indexParam));
il.append(factory.createCheckCast(new ObjectType("java.lang.Double")));
il.append(
factory.createInvoke(
"java.lang.Double",
"doubleValue",
Type.DOUBLE,
Type.NO_ARGS,
Constants.INVOKEVIRTUAL));
} else if (Type.getReturnType(originalMethod.getSignature()).equals(Type.FLOAT)) {
il.append(new PUSH(cp, 0.0f));
il.append(factory.createReturn(Type.FLOAT));
elseBranch = il.append(factory.createLoad(Type.OBJECT, indexParam));
il.append(factory.createCheckCast(new ObjectType("java.lang.Float")));
il.append(
factory.createInvoke(
"java.lang.Float",
"floatValue",
Type.FLOAT,
Type.NO_ARGS,
Constants.INVOKEVIRTUAL));
} else if (Type.getReturnType(originalMethod.getSignature()).equals(Type.CHAR)) {
il.append(new PUSH(cp, '\u0000'));
il.append(factory.createReturn(Type.CHAR));
elseBranch = il.append(factory.createLoad(Type.OBJECT, indexParam));
il.append(factory.createCheckCast(new ObjectType("java.lang.Character")));
il.append(
factory.createInvoke(
"java.lang.Character",
"charValue",
Type.CHAR,
Type.NO_ARGS,
Constants.INVOKEVIRTUAL));
} else if (Type.getReturnType(originalMethod.getSignature()).equals(Type.BYTE)) {
il.append(new PUSH(cp, (byte) 0));
il.append(factory.createReturn(Type.BYTE));
elseBranch = il.append(factory.createLoad(Type.OBJECT, indexParam));
il.append(factory.createCheckCast(new ObjectType("java.lang.Byte")));
il.append(
factory.createInvoke(
"java.lang.Byte",
"byteValue",
Type.BYTE,
Type.NO_ARGS,
Constants.INVOKEVIRTUAL));
} else if (Type.getReturnType(originalMethod.getSignature()).equals(Type.BOOLEAN)) {
il.append(new PUSH(cp, false));
il.append(factory.createReturn(Type.BOOLEAN));
elseBranch = il.append(factory.createLoad(Type.OBJECT, indexParam));
il.append(factory.createCheckCast(new ObjectType("java.lang.Boolean")));
il.append(
factory.createInvoke(
"java.lang.Boolean",
"booleanValue",
Type.BOOLEAN,
Type.NO_ARGS,
Constants.INVOKEVIRTUAL));
} else {
throw new Error(
"unknown return type: " + Type.getReturnType(originalMethod.getSignature()));
}
ifNullBranch.setTarget(elseBranch);
}
} else {
// cast the result to the right type
il.append(
factory.createCast(Type.OBJECT, Type.getReturnType(originalMethod.getSignature())));
}
}
il.append(factory.createReturn(Type.getReturnType(originalMethod.getSignature())));
method.setMaxStack();
method.setMaxLocals();
return method.getMethod();
}
/**
* Pass 3b implements the data flow analysis as described in the Java Virtual Machine
* Specification, Second Edition. Later versions will use LocalVariablesInfo objects to verify if
* the verifier-inferred types and the class file's debug information (LocalVariables attributes)
* match [TODO].
*
* @see org.apache.bcel.verifier.statics.LocalVariablesInfo
* @see org.apache.bcel.verifier.statics.Pass2Verifier#getLocalVariablesInfo(int)
*/
@Override
public VerificationResult do_verify() {
if (!myOwner.doPass3a(method_no).equals(VerificationResult.VR_OK)) {
return VerificationResult.VR_NOTYET;
}
// Pass 3a ran before, so it's safe to assume the JavaClass object is
// in the BCEL repository.
JavaClass jc;
try {
jc = Repository.lookupClass(myOwner.getClassName());
} catch (ClassNotFoundException e) {
// FIXME: maybe not the best way to handle this
throw new AssertionViolatedException("Missing class: " + e, e);
}
ConstantPoolGen constantPoolGen = new ConstantPoolGen(jc.getConstantPool());
// Init Visitors
InstConstraintVisitor icv = new InstConstraintVisitor();
icv.setConstantPoolGen(constantPoolGen);
ExecutionVisitor ev = new ExecutionVisitor();
ev.setConstantPoolGen(constantPoolGen);
Method[] methods = jc.getMethods(); // Method no "method_no" exists, we ran Pass3a before on it!
try {
MethodGen mg = new MethodGen(methods[method_no], myOwner.getClassName(), constantPoolGen);
icv.setMethodGen(mg);
////////////// DFA BEGINS HERE ////////////////
if (!(mg.isAbstract() || mg.isNative())) { // IF mg HAS CODE (See pass 2)
ControlFlowGraph cfg = new ControlFlowGraph(mg);
// Build the initial frame situation for this method.
Frame f = new Frame(mg.getMaxLocals(), mg.getMaxStack());
if (!mg.isStatic()) {
if (mg.getName().equals(Constants.CONSTRUCTOR_NAME)) {
Frame._this = new UninitializedObjectType(ObjectType.getInstance(jc.getClassName()));
f.getLocals().set(0, Frame._this);
} else {
Frame._this = null;
f.getLocals().set(0, ObjectType.getInstance(jc.getClassName()));
}
}
Type[] argtypes = mg.getArgumentTypes();
int twoslotoffset = 0;
for (int j = 0; j < argtypes.length; j++) {
if (argtypes[j] == Type.SHORT
|| argtypes[j] == Type.BYTE
|| argtypes[j] == Type.CHAR
|| argtypes[j] == Type.BOOLEAN) {
argtypes[j] = Type.INT;
}
f.getLocals().set(twoslotoffset + j + (mg.isStatic() ? 0 : 1), argtypes[j]);
if (argtypes[j].getSize() == 2) {
twoslotoffset++;
f.getLocals().set(twoslotoffset + j + (mg.isStatic() ? 0 : 1), Type.UNKNOWN);
}
}
circulationPump(mg, cfg, cfg.contextOf(mg.getInstructionList().getStart()), f, icv, ev);
}
} catch (VerifierConstraintViolatedException ce) {
ce.extendMessage("Constraint violated in method '" + methods[method_no] + "':\n", "");
return new VerificationResult(VerificationResult.VERIFIED_REJECTED, ce.getMessage());
} catch (RuntimeException re) {
// These are internal errors
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
re.printStackTrace(pw);
throw new AssertionViolatedException(
"Some RuntimeException occured while verify()ing class '"
+ jc.getClassName()
+ "', method '"
+ methods[method_no]
+ "'. Original RuntimeException's stack trace:\n---\n"
+ sw
+ "---\n",
re);
}
return VerificationResult.VR_OK;
}
