sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/classfile/editor/MemberReferenceFixer.java

@@ -0,0 +1,447 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.classfile.editor;
+
+import proguard.classfile.*;
+import proguard.classfile.attribute.*;
+import proguard.classfile.attribute.annotation.*;
+import proguard.classfile.attribute.annotation.visitor.*;
+import proguard.classfile.attribute.visitor.AttributeVisitor;
+import proguard.classfile.constant.*;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.util.*;
+import proguard.classfile.visitor.*;
+
+/**
+ * This ClassVisitor fixes constant pool field and method references to fields
+ * and methods whose names or descriptors have changed.
+ *
+ * @author Eric Lafortune
+ */
+public class MemberReferenceFixer
+extends      SimplifiedVisitor
+implements   ClassVisitor,
+             ConstantVisitor,
+             MemberVisitor,
+             AttributeVisitor,
+             AnnotationVisitor,
+             ElementValueVisitor
+{
+    private static final boolean DEBUG = false;
+
+
+    private final StackSizeUpdater stackSizeUpdater = new StackSizeUpdater();
+
+    // Parameter for the visitor methods.
+    private int constantIndex;
+
+    // Return values for the visitor methods.
+    private boolean isInterfaceMethod;
+    private boolean stackSizesMayHaveChanged;
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        stackSizesMayHaveChanged = false;
+
+        // Fix the constant pool entries.
+        for (int index = 1; index < programClass.u2constantPoolCount; index++)
+        {
+            Constant constant = programClass.constantPool[index];
+            if (constant != null)
+            {
+                // Fix the entry, replacing it entirely if needed.
+                this.constantIndex = index;
+
+                constant.accept(programClass, this);
+            }
+        }
+
+        // Fix the class members.
+        programClass.fieldsAccept(this);
+        programClass.methodsAccept(this);
+
+        // Fix the attributes.
+        programClass.attributesAccept(this);
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+
+    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
+    {
+        // Does the string refer to a class member, due to a
+        // Class.get[Declared]{Field,Method} construct?
+        Member referencedMember = stringConstant.referencedMember;
+        if (referencedMember != null)
+        {
+            Clazz referencedClass = stringConstant.referencedClass;
+
+            // Does it have a new name?
+            String newName = referencedMember.getName(referencedClass);
+
+            if (!stringConstant.getString(clazz).equals(newName))
+            {
+                if (DEBUG)
+                {
+                    debug(clazz, stringConstant, referencedClass, referencedMember);
+                }
+
+                // Update the name.
+                stringConstant.u2stringIndex =
+                    new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newName);
+            }
+        }
+    }
+
+
+    public void visitFieldrefConstant(Clazz clazz, FieldrefConstant fieldrefConstant)
+    {
+        // Do we know the referenced field?
+        Member referencedMember = fieldrefConstant.referencedMember;
+        if (referencedMember != null)
+        {
+            Clazz referencedClass = fieldrefConstant.referencedClass;
+
+            // Does it have a new name or type?
+            String newName = referencedMember.getName(referencedClass);
+            String newType = referencedMember.getDescriptor(referencedClass);
+
+            if (!fieldrefConstant.getName(clazz).equals(newName) ||
+                !fieldrefConstant.getType(clazz).equals(newType))
+            {
+                if (DEBUG)
+                {
+                    debug(clazz, fieldrefConstant, referencedClass, referencedMember);
+                }
+
+                // Update the name and type index.
+                fieldrefConstant.u2nameAndTypeIndex =
+                    new ConstantPoolEditor((ProgramClass)clazz).addNameAndTypeConstant(newName, newType);
+            }
+        }
+    }
+
+
+    public void visitInterfaceMethodrefConstant(Clazz clazz, InterfaceMethodrefConstant interfaceMethodrefConstant)
+    {
+        // Do we know the referenced interface method?
+        Member referencedMember = interfaceMethodrefConstant.referencedMember;
+        if (referencedMember != null)
+        {
+            Clazz referencedClass = interfaceMethodrefConstant.referencedClass;
+
+            // Does it have a new name or type?
+            String newName = referencedMember.getName(referencedClass);
+            String newType = referencedMember.getDescriptor(referencedClass);
+
+            if (!interfaceMethodrefConstant.getName(clazz).equals(newName) ||
+                !interfaceMethodrefConstant.getType(clazz).equals(newType))
+            {
+                if (DEBUG)
+                {
+                    debug(clazz, interfaceMethodrefConstant, referencedClass, referencedMember);
+                }
+
+                // Update the name and type index.
+                interfaceMethodrefConstant.u2nameAndTypeIndex =
+                    new ConstantPoolEditor((ProgramClass)clazz).addNameAndTypeConstant(newName, newType);
+
+                // Remember that the stack sizes of the methods in this class
+                // may have changed.
+                stackSizesMayHaveChanged = true;
+            }
+
+            // Check if this is an interface method.
+            isInterfaceMethod = true;
+            clazz.constantPoolEntryAccept(interfaceMethodrefConstant.u2classIndex, this);
+
+            // Has the method become a non-interface method?
+            if (!isInterfaceMethod)
+            {
+                if (DEBUG)
+                {
+                    System.out.println("MemberReferenceFixer:");
+                    System.out.println("  Class file     = "+clazz.getName());
+                    System.out.println("  Ref class      = "+referencedClass.getName());
+                    System.out.println("  Ref method     = "+interfaceMethodrefConstant.getName(clazz)+interfaceMethodrefConstant.getType(clazz));
+                    System.out.println("    -> ordinary method");
+                }
+
+                // Replace the interface method reference by a method reference.
+                ((ProgramClass)clazz).constantPool[this.constantIndex] =
+                    new MethodrefConstant(interfaceMethodrefConstant.u2classIndex,
+                                          interfaceMethodrefConstant.u2nameAndTypeIndex,
+                                          referencedClass,
+                                          referencedMember);
+            }
+        }
+    }
+
+
+    public void visitMethodrefConstant(Clazz clazz, MethodrefConstant methodrefConstant)
+    {
+        // Do we know the referenced method?
+        Member referencedMember = methodrefConstant.referencedMember;
+        if (referencedMember != null)
+        {
+            Clazz referencedClass = methodrefConstant.referencedClass;
+
+            // Does it have a new name or type?
+            String newName = referencedMember.getName(referencedClass);
+            String newType = referencedMember.getDescriptor(referencedClass);
+
+            if (!methodrefConstant.getName(clazz).equals(newName) ||
+                !methodrefConstant.getType(clazz).equals(newType))
+            {
+                if (DEBUG)
+                {
+                    debug(clazz, methodrefConstant, referencedClass, referencedMember);
+                }
+
+                // Update the name and type index.
+                methodrefConstant.u2nameAndTypeIndex =
+                    new ConstantPoolEditor((ProgramClass)clazz).addNameAndTypeConstant(newName, newType);
+
+                // Remember that the stack sizes of the methods in this class
+                // may have changed.
+                stackSizesMayHaveChanged = true;
+            }
+
+            // Check if this is an interface method.
+            isInterfaceMethod = false;
+            clazz.constantPoolEntryAccept(methodrefConstant.u2classIndex, this);
+
+            // Has the method become an interface method?
+            if (isInterfaceMethod)
+            {
+                if (DEBUG)
+                {
+                    System.out.println("MemberReferenceFixer:");
+                    System.out.println("  Class file     = "+clazz.getName());
+                    System.out.println("  Ref class      = "+referencedClass.getName());
+                    System.out.println("  Ref method     = "+methodrefConstant.getName(clazz)+methodrefConstant.getType(clazz));
+                    System.out.println("    -> interface method");
+                }
+
+                // Replace the method reference by an interface method reference.
+                ((ProgramClass)clazz).constantPool[this.constantIndex] =
+                    new InterfaceMethodrefConstant(methodrefConstant.u2classIndex,
+                                                   methodrefConstant.u2nameAndTypeIndex,
+                                                   referencedClass,
+                                                   referencedMember);
+            }
+        }
+    }
+
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        // Check if this class entry is an array type.
+        if (ClassUtil.isInternalArrayType(classConstant.getName(clazz)))
+        {
+            isInterfaceMethod = false;
+        }
+        else
+        {
+            // Check if this class entry refers to an interface class.
+            Clazz referencedClass = classConstant.referencedClass;
+            if (referencedClass != null)
+            {
+                isInterfaceMethod = (referencedClass.getAccessFlags() & ClassConstants.INTERNAL_ACC_INTERFACE) != 0;
+            }
+        }
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitProgramMember(ProgramClass programClass, ProgramMember programMember)
+    {
+        // Fix the attributes.
+        programMember.attributesAccept(programClass, this);
+    }
+
+
+    // Implementations for AttributeVisitor.
+
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+
+
+    public void visitEnclosingMethodAttribute(Clazz clazz, EnclosingMethodAttribute enclosingMethodAttribute)
+    {
+        Member referencedMember = enclosingMethodAttribute.referencedMethod;
+        if (referencedMember != null)
+        {
+            Clazz referencedClass = enclosingMethodAttribute.referencedClass;
+
+            // Does it have a new name or type?
+            String newName = referencedMember.getName(referencedClass);
+            String newType = referencedMember.getDescriptor(referencedClass);
+
+            if (!enclosingMethodAttribute.getName(clazz).equals(newName) ||
+                !enclosingMethodAttribute.getType(clazz).equals(newType))
+            {
+                // Update the name and type index.
+                enclosingMethodAttribute.u2nameAndTypeIndex =
+                    new ConstantPoolEditor((ProgramClass)clazz).addNameAndTypeConstant(newName,
+                                                                                       newType);
+            }
+        }
+    }
+
+
+    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
+    {
+        // Recompute the maximum stack size if necessary.
+        if (stackSizesMayHaveChanged)
+        {
+                stackSizeUpdater.visitCodeAttribute(clazz, method, codeAttribute);
+        }
+
+        // Fix the nested attributes.
+        codeAttribute.attributesAccept(clazz, method, this);
+    }
+
+
+    public void visitAnyAnnotationsAttribute(Clazz clazz, AnnotationsAttribute annotationsAttribute)
+    {
+        // Fix the annotations.
+        annotationsAttribute.annotationsAccept(clazz, this);
+    }
+
+
+    public void visitAnyParameterAnnotationsAttribute(Clazz clazz, Method method, ParameterAnnotationsAttribute parameterAnnotationsAttribute)
+    {
+        // Fix the annotations.
+        parameterAnnotationsAttribute.annotationsAccept(clazz, method, this);
+    }
+
+
+    public void visitAnnotationDefaultAttribute(Clazz clazz, Method method, AnnotationDefaultAttribute annotationDefaultAttribute)
+    {
+        // Fix the annotation.
+        annotationDefaultAttribute.defaultValueAccept(clazz, this);
+    }
+
+
+    // Implementations for AnnotationVisitor.
+
+    public void visitAnnotation(Clazz clazz, Annotation annotation)
+    {
+        // Fix the element values.
+        annotation.elementValuesAccept(clazz, this);
+    }
+
+
+    // Implementations for ElementValueVisitor.
+
+    public void visitConstantElementValue(Clazz clazz, Annotation annotation, ConstantElementValue constantElementValue)
+    {
+        fixElementValue(clazz, annotation, constantElementValue);
+    }
+
+
+    public void visitEnumConstantElementValue(Clazz clazz, Annotation annotation, EnumConstantElementValue enumConstantElementValue)
+    {
+        fixElementValue(clazz, annotation, enumConstantElementValue);
+    }
+
+
+    public void visitClassElementValue(Clazz clazz, Annotation annotation, ClassElementValue classElementValue)
+    {
+        fixElementValue(clazz, annotation, classElementValue);
+    }
+
+
+    public void visitAnnotationElementValue(Clazz clazz, Annotation annotation, AnnotationElementValue annotationElementValue)
+    {
+        fixElementValue(clazz, annotation, annotationElementValue);
+
+        // Fix the annotation.
+        annotationElementValue.annotationAccept(clazz, this);
+    }
+
+
+    public void visitArrayElementValue(Clazz clazz, Annotation annotation, ArrayElementValue arrayElementValue)
+    {
+        fixElementValue(clazz, annotation, arrayElementValue);
+
+        // Fix the element values.
+        arrayElementValue.elementValuesAccept(clazz, annotation, this);
+    }
+
+
+    // Small utility methods.
+
+    /**
+     * Fixes the method reference of the element value, if any.
+     */
+    private void fixElementValue(Clazz        clazz,
+                                 Annotation   annotation,
+                                 ElementValue elementValue)
+    {
+        // Do we know the referenced method?
+        Member referencedMember = elementValue.referencedMethod;
+        if (referencedMember != null)
+        {
+            // Does it have a new name or type?
+            String methodName    = elementValue.getMethodName(clazz);
+            String newMethodName = referencedMember.getName(elementValue.referencedClass);
+
+            if (!methodName.equals(newMethodName))
+            {
+                // Update the element name index.
+                elementValue.u2elementNameIndex =
+                    new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newMethodName);
+            }
+        }
+    }
+
+
+    private void debug(Clazz          clazz,
+                       StringConstant stringConstant,
+                       Clazz          referencedClass,
+                       Member         referencedMember)
+    {
+        System.out.println("MemberReferenceFixer:");
+        System.out.println("  ["+clazz.getName()+"]: String ["+
+                           stringConstant.getString(clazz)+"] -> ["+
+                           referencedClass.getName()+"."+referencedMember.getName(referencedClass)+" "+referencedMember.getDescriptor(referencedClass)+"]");
+    }
+
+
+    private void debug(Clazz       clazz,
+                       RefConstant refConstant,
+                       Clazz       referencedClass,
+                       Member      referencedMember)
+    {
+        System.out.println("MemberReferenceFixer:");
+        System.out.println("  ["+clazz.getName()+"]: ["+
+                           refConstant.getClassName(clazz)+"."+refConstant.getName(clazz)+" "+refConstant.getType(clazz)+"] -> ["+
+                           referencedClass.getName()+"."+referencedMember.getName(referencedClass)+" "+referencedMember.getDescriptor(referencedClass)+"]");
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/editor/MethodInvocationFixer.java

@@ -0,0 +1,243 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.classfile.editor;
+
+import proguard.classfile.*;
+import proguard.classfile.attribute.*;
+import proguard.classfile.attribute.visitor.AttributeVisitor;
+import proguard.classfile.constant.*;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.instruction.*;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+import proguard.classfile.util.*;
+
+/**
+ * This AttributeVisitor fixes all inappropriate special/virtual/static/interface
+ * invocations of the code attributes that it visits.
+ *
+ * @author Eric Lafortune
+ */
+public class MethodInvocationFixer
+extends      SimplifiedVisitor
+implements   AttributeVisitor,
+             InstructionVisitor,
+             ConstantVisitor
+{
+    private static final boolean DEBUG = false;
+
+
+    private final CodeAttributeEditor codeAttributeEditor = new CodeAttributeEditor();
+
+    // Return values for the visitor methods.
+    private Clazz  referencedClass;
+    private Clazz  referencedMethodClass;
+    private Member referencedMethod;
+
+
+    // Implementations for AttributeVisitor.
+
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+
+
+    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
+    {
+        // Reset the code attribute editor.
+        codeAttributeEditor.reset(codeAttribute.u4codeLength);
+
+        // Remap the variables of the instructions.
+        codeAttribute.instructionsAccept(clazz, method, this);
+
+        // Apply the code atribute editor.
+        codeAttributeEditor.visitCodeAttribute(clazz, method, codeAttribute);
+    }
+
+
+    // Implementations for InstructionVisitor.
+
+    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
+
+
+    public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction)
+    {
+        int constantIndex = constantInstruction.constantIndex;
+
+        // Get information on the called class and method, if present.
+        referencedMethod = null;
+
+        clazz.constantPoolEntryAccept(constantIndex, this);
+
+        // Did we find the called class and method?
+        if (referencedClass  != null &&
+            referencedMethod != null)
+        {
+            // Do we need to update the opcode?
+            byte opcode = constantInstruction.opcode;
+
+            // Is the method static?
+            if ((referencedMethod.getAccessFlags() & ClassConstants.INTERNAL_ACC_STATIC) != 0)
+            {
+                // But is it not a static invocation?
+                if (opcode != InstructionConstants.OP_INVOKESTATIC)
+                {
+                    // Replace the invocation by an invokestatic instruction.
+                    Instruction replacementInstruction =
+                        new ConstantInstruction(InstructionConstants.OP_INVOKESTATIC,
+                                                constantIndex).shrink();
+
+                    codeAttributeEditor.replaceInstruction(offset, replacementInstruction);
+
+                    if (DEBUG)
+                    {
+                        debug(clazz, method, offset, constantInstruction, replacementInstruction);
+                    }
+                }
+            }
+
+            // Is the method private, or an instance initializer?
+            else if ((referencedMethod.getAccessFlags() & ClassConstants.INTERNAL_ACC_PRIVATE) != 0 ||
+                     referencedMethod.getName(referencedMethodClass).equals(ClassConstants.INTERNAL_METHOD_NAME_INIT))
+            {
+                // But is it not a special invocation?
+                if (opcode != InstructionConstants.OP_INVOKESPECIAL)
+                {
+                    // Replace the invocation by an invokespecial instruction.
+                    Instruction replacementInstruction =
+                        new ConstantInstruction(InstructionConstants.OP_INVOKESPECIAL,
+                                                constantIndex).shrink();
+
+                    codeAttributeEditor.replaceInstruction(offset, replacementInstruction);
+
+                    if (DEBUG)
+                    {
+                        debug(clazz, method, offset, constantInstruction, replacementInstruction);
+                    }
+                }
+            }
+
+            // Is the method an interface method?
+            else if ((referencedClass.getAccessFlags() & ClassConstants.INTERNAL_ACC_INTERFACE) != 0)
+            {
+                int invokeinterfaceConstant =
+                    (ClassUtil.internalMethodParameterSize(referencedMethod.getDescriptor(referencedMethodClass), false)) << 8;
+
+                // But is it not an interface invocation, or is the parameter
+                // size incorrect?
+                if (opcode != InstructionConstants.OP_INVOKEINTERFACE ||
+                    constantInstruction.constant != invokeinterfaceConstant)
+                {
+                    // Fix the parameter size of the interface invocation.
+                    Instruction replacementInstruction =
+                        new ConstantInstruction(InstructionConstants.OP_INVOKEINTERFACE,
+                                                constantIndex,
+                                                invokeinterfaceConstant).shrink();
+
+                    codeAttributeEditor.replaceInstruction(offset, replacementInstruction);
+
+                    if (DEBUG)
+                    {
+                        debug(clazz, method, offset, constantInstruction, replacementInstruction);
+                    }
+                }
+            }
+
+            // The method is not static, private, an instance initializer, or
+            // an interface method.
+            else
+            {
+                // But is it not a virtual invocation (or a special invocation,
+                // but not a super call)?
+                if (opcode != InstructionConstants.OP_INVOKEVIRTUAL &&
+                    (opcode != InstructionConstants.OP_INVOKESPECIAL ||
+                     clazz.equals(referencedClass) ||
+                     !clazz.extends_(referencedClass)))
+                {
+                    // Replace the invocation by an invokevirtual instruction.
+                    Instruction replacementInstruction =
+                        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL,
+                                                constantIndex).shrink();
+
+                    codeAttributeEditor.replaceInstruction(offset, replacementInstruction);
+
+                    if (DEBUG)
+                    {
+                        debug(clazz, method, offset, constantInstruction, replacementInstruction);
+                    }
+                }
+            }
+        }
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+
+    public void visitAnyMethodrefConstant(Clazz clazz, RefConstant refConstant)
+    {
+        // Remember the referenced class. Note that we're interested in the
+        // class of the method reference, not in the class in which the
+        // method was actually found, unless it is an array type.
+        //
+        if (ClassUtil.isInternalArrayType(refConstant.getClassName(clazz)))
+        {
+            // For an array type, the class will be java.lang.Object.
+            referencedClass = refConstant.referencedClass;
+        }
+        else
+        {
+            clazz.constantPoolEntryAccept(refConstant.u2classIndex, this);
+        }
+
+        // Remember the referenced method.
+        referencedMethodClass = refConstant.referencedClass;
+        referencedMethod      = refConstant.referencedMember;
+    }
+
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        // Remember the referenced class.
+        referencedClass = classConstant.referencedClass;
+    }
+
+
+    // Small utility methods.
+
+    private void debug(Clazz               clazz,
+                       Method              method,
+                       int                 offset,
+                       ConstantInstruction constantInstruction,
+                       Instruction         replacementInstruction)
+    {
+        System.out.println("MethodInvocationFixer:");
+        System.out.println("  Class       = "+clazz.getName());
+        System.out.println("  Method      = "+method.getName(clazz)+method.getDescriptor(clazz));
+        System.out.println("  Instruction = "+constantInstruction.toString(offset));
+        System.out.println("  -> Class    = "+referencedClass);
+        System.out.println("     Method   = "+referencedMethod);
+        if ((referencedClass.getAccessFlags() & ClassConstants.INTERNAL_ACC_INTERFACE) != 0)
+        {
+            System.out.println("     Parameter size   = "+(ClassUtil.internalMethodParameterSize(referencedMethod.getDescriptor(referencedMethodClass), false)));
+        }
+        System.out.println("  Replacement instruction = "+replacementInstruction.toString(offset));
+    }
+}