/** * 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); }
/** Instrument the specified method to replace mapped calls. */ public void instrument_method(Method m, MethodGen mg) { // Loop through each instruction, making substitutions InstructionList il = mg.getInstructionList(); for (InstructionHandle ih = il.getStart(); ih != null; ) { if (debug_instrument_inst.enabled()) { debug_instrument_inst.log("instrumenting instruction %s%n", ih); // ih.getInstruction().toString(pool.getConstantPool())); } InstructionList new_il = null; // Remember the next instruction to process InstructionHandle next_ih = ih.getNext(); // Get the translation for this instruction (if any) new_il = xform_inst(mg, ih.getInstruction()); if (debug_instrument_inst.enabled()) debug_instrument_inst.log(" new inst: %s%n", new_il); // If this instruction was modified, replace it with the new // instruction list. If this instruction was the target of any // jumps or line numbers , replace them with the first // instruction in the new list replace_instructions(il, ih, new_il); ih = next_ih; } }
/** * 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); } }
/** * Processes each method in cg replacing any specified calls with static user calls. * * @param fullClassName must be packageName.className */ private boolean map_calls(ClassGen cg, String fullClassName, ClassLoader loader) { boolean transformed = false; try { pgen = cg.getConstantPool(); // Loop through each method in the class Method[] methods = cg.getMethods(); for (int i = 0; i < methods.length; i++) { MethodGen mg = new MethodGen(methods[i], cg.getClassName(), pgen); // Get the instruction list and skip methods with no instructions InstructionList il = mg.getInstructionList(); if (il == null) continue; if (debug) out.format("Original code: %s%n", mg.getMethod().getCode()); instrument_method(methods[i], mg); // Remove the Local variable type table attribute (if any). // Evidently, some changes we make require this to be updated, but // without BCEL support, that would be hard to do. Just delete it // for now (since it is optional, and we are unlikely to be used by // a debugger) for (Attribute a : mg.getCodeAttributes()) { if (is_local_variable_type_table(a)) { mg.removeCodeAttribute(a); } } // Update the instruction list mg.setInstructionList(il); mg.update(); // Update the max stack and Max Locals mg.setMaxLocals(); mg.setMaxStack(); mg.update(); // Update the method in the class cg.replaceMethod(methods[i], mg.getMethod()); if (debug) out.format("Modified code: %s%n", mg.getMethod().getCode()); // verify the new method // StackVer stackver = new StackVer(); // VerificationResult vr = stackver.do_stack_ver (mg); // log ("vr for method %s = %s%n", mg.getName(), vr); // if (vr.getStatus() != VerificationResult.VERIFIED_OK) { // System.out.printf ("Warning BCEL Verify failed for method %s: %s", // mg.getName(), vr); // System.out.printf ("Code: %n%s%n", mg.getMethod().getCode()); // System.exit(1); // } } cg.update(); } catch (Exception e) { out.format("Unexpected exception encountered: " + e); e.printStackTrace(); } return transformed; }