sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/shrink/Shrinker.java

@@ -0,0 +1,181 @@
+/*
+ * 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.shrink;
+
+import proguard.*;
+import proguard.classfile.*;
+import proguard.classfile.attribute.visitor.*;
+import proguard.classfile.visitor.*;
+
+import java.io.*;
+
+/**
+ * This class shrinks class pools according to a given configuration.
+ *
+ * @author Eric Lafortune
+ */
+public class Shrinker
+{
+    private final Configuration configuration;
+
+
+    /**
+     * Creates a new Shrinker.
+     */
+    public Shrinker(Configuration configuration)
+    {
+        this.configuration = configuration;
+    }
+
+
+    /**
+     * Performs shrinking of the given program class pool.
+     */
+    public ClassPool execute(ClassPool programClassPool,
+                             ClassPool libraryClassPool) throws IOException
+    {
+        // Check if we have at least some keep commands.
+        if (configuration.keep == null)
+        {
+            throw new IOException("You have to specify '-keep' options for the shrinking step.");
+        }
+
+        // Clean up any old visitor info.
+        programClassPool.classesAccept(new ClassCleaner());
+        libraryClassPool.classesAccept(new ClassCleaner());
+
+        // Create a visitor for marking the seeds.
+        UsageMarker usageMarker = configuration.whyAreYouKeeping == null ?
+            new UsageMarker() :
+            new ShortestUsageMarker();
+
+        // Automatically mark the parameterless constructors of seed classes,
+        // mainly for convenience and for backward compatibility.
+        ClassVisitor classUsageMarker =
+            new MultiClassVisitor(new ClassVisitor[]
+            {
+                usageMarker,
+                new NamedMethodVisitor(ClassConstants.INTERNAL_METHOD_NAME_INIT,
+                                       ClassConstants.INTERNAL_METHOD_TYPE_INIT,
+                                       usageMarker)
+            });
+
+        ClassPoolVisitor classPoolvisitor =
+            ClassSpecificationVisitorFactory.createClassPoolVisitor(configuration.keep,
+                                                                    classUsageMarker,
+                                                                    usageMarker,
+                                                                    true,
+                                                                    false,
+                                                                    false);
+        // Mark the seeds.
+        programClassPool.accept(classPoolvisitor);
+        libraryClassPool.accept(classPoolvisitor);
+
+        // Mark interfaces that have to be kept.
+        programClassPool.classesAccept(new InterfaceUsageMarker(usageMarker));
+
+        // Mark the inner class and annotation information that has to be kept.
+        programClassPool.classesAccept(
+            new UsedClassFilter(usageMarker,
+            new AllAttributeVisitor(true,
+            new MultiAttributeVisitor(new AttributeVisitor[]
+            {
+                new InnerUsageMarker(usageMarker),
+                new AnnotationUsageMarker(usageMarker),
+            }))));
+
+        // Should we explain ourselves?
+        if (configuration.whyAreYouKeeping != null)
+        {
+            System.out.println();
+
+            // Create a visitor for explaining classes and class members.
+            ShortestUsagePrinter shortestUsagePrinter =
+                new ShortestUsagePrinter((ShortestUsageMarker)usageMarker,
+                                         configuration.verbose);
+
+            ClassPoolVisitor whyClassPoolvisitor =
+                ClassSpecificationVisitorFactory.createClassPoolVisitor(configuration.whyAreYouKeeping,
+                                                                        shortestUsagePrinter,
+                                                                        shortestUsagePrinter);
+
+            // Mark the seeds.
+            programClassPool.accept(whyClassPoolvisitor);
+            libraryClassPool.accept(whyClassPoolvisitor);
+        }
+
+        if (configuration.printUsage != null)
+        {
+            PrintStream ps = isFile(configuration.printUsage) ?
+                new PrintStream(new BufferedOutputStream(new FileOutputStream(configuration.printUsage))) :
+                System.out;
+
+            // Print out items that will be removed.
+            programClassPool.classesAcceptAlphabetically(
+                new UsagePrinter(usageMarker, true, ps));
+
+            if (ps != System.out)
+            {
+                ps.close();
+            }
+        }
+
+        // Discard unused program classes.
+        int originalProgramClassPoolSize = programClassPool.size();
+
+        ClassPool newProgramClassPool = new ClassPool();
+        programClassPool.classesAccept(
+            new UsedClassFilter(usageMarker,
+            new MultiClassVisitor(
+            new ClassVisitor[] {
+                new ClassShrinker(usageMarker),
+                new ClassPoolFiller(newProgramClassPool)
+            })));
+
+        programClassPool.clear();
+
+        // Check if we have at least some output classes.
+        int newProgramClassPoolSize = newProgramClassPool.size();
+        if (newProgramClassPoolSize == 0)
+        {
+            throw new IOException("The output jar is empty. Did you specify the proper '-keep' options?");
+        }
+
+        if (configuration.verbose)
+        {
+            System.out.println("Removing unused program classes and class elements...");
+            System.out.println("  Original number of program classes: " + originalProgramClassPoolSize);
+            System.out.println("  Final number of program classes:    " + newProgramClassPoolSize);
+        }
+
+        return newProgramClassPool;
+    }
+
+
+    /**
+     * Returns whether the given file is actually a file, or just a placeholder
+     * for the standard output.
+     */
+    private boolean isFile(File file)
+    {
+        return file.getPath().length() > 0;
+    }
+}

data/lib/proguard4.7/src/proguard/shrink/UsageMarker.java

@@ -0,0 +1,1036 @@
+/*
+ * 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.shrink;
+
+import proguard.classfile.*;
+import proguard.classfile.attribute.*;
+import proguard.classfile.attribute.annotation.*;
+import proguard.classfile.attribute.preverification.*;
+import proguard.classfile.attribute.preverification.visitor.*;
+import proguard.classfile.attribute.visitor.*;
+import proguard.classfile.constant.*;
+import proguard.classfile.constant.visitor.*;
+import proguard.classfile.instruction.*;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+import proguard.classfile.util.*;
+import proguard.classfile.visitor.*;
+
+
+/**
+ * This ClassVisitor and MemberVisitor recursively marks all classes and class
+ * elements that are being used.
+ *
+ * @see ClassShrinker
+ *
+ * @author Eric Lafortune
+ */
+class      UsageMarker
+extends    SimplifiedVisitor
+implements ClassVisitor,
+           MemberVisitor,
+           ConstantVisitor,
+           AttributeVisitor,
+           InnerClassesInfoVisitor,
+           ExceptionInfoVisitor,
+           StackMapFrameVisitor,
+           VerificationTypeVisitor,
+           LocalVariableInfoVisitor,
+           LocalVariableTypeInfoVisitor,
+//         AnnotationVisitor,
+//         ElementValueVisitor,
+           InstructionVisitor
+{
+    // A visitor info flag to indicate the ProgramMember object is being used,
+    // if its Clazz can be determined as being used as well.
+    private static final Object POSSIBLY_USED = new Object();
+    // A visitor info flag to indicate the visitor accepter is being used.
+    private static final Object USED          = new Object();
+
+
+    private final MyInterfaceUsageMarker          interfaceUsageMarker           = new MyInterfaceUsageMarker();
+    private final MyPossiblyUsedMemberUsageMarker possiblyUsedMemberUsageMarker  = new MyPossiblyUsedMemberUsageMarker();
+    private final MemberVisitor                   nonEmptyMethodUsageMarker      = new AllAttributeVisitor(
+                                                                                   new MyNonEmptyMethodUsageMarker());
+    private final ConstantVisitor                 parameterlessConstructorMarker = new ConstantTagFilter(new int[] { ClassConstants.CONSTANT_String, ClassConstants.CONSTANT_Class },
+                                                                                   new ReferencedClassVisitor(
+                                                                                   new NamedMethodVisitor(ClassConstants.INTERNAL_METHOD_NAME_INIT,
+                                                                                                          ClassConstants.INTERNAL_METHOD_TYPE_INIT,
+                                                                                                          this)));
+
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        if (shouldBeMarkedAsUsed(programClass))
+        {
+            // Mark this class.
+            markAsUsed(programClass);
+
+            markProgramClassBody(programClass);
+        }
+    }
+
+
+    protected void markProgramClassBody(ProgramClass programClass)
+    {
+        // Mark this class's name.
+        markConstant(programClass, programClass.u2thisClass);
+
+        // Mark the superclass.
+        if (programClass.u2superClass != 0)
+        {
+            markConstant(programClass, programClass.u2superClass);
+        }
+
+        // Give the interfaces preliminary marks.
+        programClass.hierarchyAccept(false, false, true, false,
+                                     interfaceUsageMarker);
+
+        // Explicitly mark the <clinit> method, if it's not empty.
+        programClass.methodAccept(ClassConstants.INTERNAL_METHOD_NAME_CLINIT,
+                                  ClassConstants.INTERNAL_METHOD_TYPE_CLINIT,
+                                  nonEmptyMethodUsageMarker);
+
+        // Process all class members that have already been marked as possibly used.
+        programClass.fieldsAccept(possiblyUsedMemberUsageMarker);
+        programClass.methodsAccept(possiblyUsedMemberUsageMarker);
+
+        // Mark the attributes.
+        programClass.attributesAccept(this);
+    }
+
+
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        if (shouldBeMarkedAsUsed(libraryClass))
+        {
+            markAsUsed(libraryClass);
+
+            // We're not going to analyze all library code. We're assuming that
+            // if this class is being used, all of its methods will be used as
+            // well. We'll mark them as such (here and in all subclasses).
+
+            // Mark the superclass.
+            Clazz superClass = libraryClass.superClass;
+            if (superClass != null)
+            {
+                superClass.accept(this);
+            }
+
+            // Mark the interfaces.
+            Clazz[] interfaceClasses = libraryClass.interfaceClasses;
+            if (interfaceClasses != null)
+            {
+                for (int index = 0; index < interfaceClasses.length; index++)
+                {
+                    if (interfaceClasses[index] != null)
+                    {
+                        interfaceClasses[index].accept(this);
+                    }
+                }
+            }
+
+            // Mark all methods.
+            libraryClass.methodsAccept(this);
+        }
+    }
+
+
+    /**
+     * This ClassVisitor marks ProgramClass objects as possibly used,
+     * and it visits LibraryClass objects with its outer UsageMarker.
+     */
+    private class MyInterfaceUsageMarker
+    implements    ClassVisitor
+    {
+        public void visitProgramClass(ProgramClass programClass)
+        {
+            if (shouldBeMarkedAsPossiblyUsed(programClass))
+            {
+                // We can't process the interface yet, because it might not
+                // be required. Give it a preliminary mark.
+                markAsPossiblyUsed(programClass);
+            }
+        }
+
+        public void visitLibraryClass(LibraryClass libraryClass)
+        {
+            // Make sure all library interface methods are marked.
+            UsageMarker.this.visitLibraryClass(libraryClass);
+        }
+    }
+
+
+    /**
+     * This MemberVisitor marks ProgramField and ProgramMethod objects that
+     * have already been marked as possibly used.
+     */
+    private class MyPossiblyUsedMemberUsageMarker
+    extends       SimplifiedVisitor
+    implements    MemberVisitor
+    {
+        // Implementations for MemberVisitor.
+
+        public void visitProgramField(ProgramClass programClass, ProgramField programField)
+        {
+            // Has the method already been referenced?
+            if (isPossiblyUsed(programField))
+            {
+                markAsUsed(programField);
+
+                // Mark the name and descriptor.
+                markConstant(programClass, programField.u2nameIndex);
+                markConstant(programClass, programField.u2descriptorIndex);
+
+                // Mark the attributes.
+                programField.attributesAccept(programClass, UsageMarker.this);
+
+                // Mark the classes referenced in the descriptor string.
+                programField.referencedClassesAccept(UsageMarker.this);
+            }
+        }
+
+
+        public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+        {
+            // Has the method already been referenced?
+            if (isPossiblyUsed(programMethod))
+            {
+                markAsUsed(programMethod);
+
+                // Mark the method body.
+                markProgramMethodBody(programClass, programMethod);
+
+                // Note that, if the method has been marked as possibly used,
+                // the method hierarchy has already been marked (cfr. below).
+            }
+        }
+    }
+
+
+    /**
+     * This AttributeVisitor marks ProgramMethod objects of non-empty methods.
+     */
+    private class MyNonEmptyMethodUsageMarker
+    extends       SimplifiedVisitor
+    implements    AttributeVisitor
+    {
+        // Implementations for AttributeVisitor.
+
+        public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+
+
+        public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
+        {
+            if (codeAttribute.u4codeLength > 1)
+            {
+                method.accept(clazz, UsageMarker.this);
+            }
+        }
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitProgramField(ProgramClass programClass, ProgramField programField)
+    {
+        if (shouldBeMarkedAsUsed(programField))
+        {
+            // Is the field's class used?
+            if (isUsed(programClass))
+            {
+                markAsUsed(programField);
+
+                // Mark the field body.
+                markProgramFieldBody(programClass, programField);
+            }
+
+            // Hasn't the field been marked as possibly being used yet?
+            else if (shouldBeMarkedAsPossiblyUsed(programField))
+            {
+                // We can't process the field yet, because the class isn't
+                // marked as being used (yet). Give it a preliminary mark.
+                markAsPossiblyUsed(programField);
+            }
+        }
+    }
+
+
+    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+    {
+        if (shouldBeMarkedAsUsed(programMethod))
+        {
+            // Is the method's class used?
+            if (isUsed(programClass))
+            {
+                markAsUsed(programMethod);
+
+                // Mark the method body.
+                markProgramMethodBody(programClass, programMethod);
+
+                // Mark the method hierarchy.
+                markMethodHierarchy(programClass, programMethod);
+            }
+
+            // Hasn't the method been marked as possibly being used yet?
+            else if (shouldBeMarkedAsPossiblyUsed(programMethod))
+            {
+                // We can't process the method yet, because the class isn't
+                // marked as being used (yet). Give it a preliminary mark.
+                markAsPossiblyUsed(programMethod);
+
+                // Mark the method hierarchy.
+                markMethodHierarchy(programClass, programMethod);
+            }
+        }
+    }
+
+
+    public void visitLibraryField(LibraryClass programClass, LibraryField programField) {}
+
+
+    public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
+    {
+        if (shouldBeMarkedAsUsed(libraryMethod))
+        {
+            markAsUsed(libraryMethod);
+
+            // Mark the method hierarchy.
+            markMethodHierarchy(libraryClass, libraryMethod);
+        }
+    }
+
+
+    protected void markProgramFieldBody(ProgramClass programClass, ProgramField programField)
+    {
+        // Mark the name and descriptor.
+        markConstant(programClass, programField.u2nameIndex);
+        markConstant(programClass, programField.u2descriptorIndex);
+
+        // Mark the attributes.
+        programField.attributesAccept(programClass, this);
+
+        // Mark the classes referenced in the descriptor string.
+        programField.referencedClassesAccept(this);
+    }
+
+
+    protected void markProgramMethodBody(ProgramClass programClass, ProgramMethod programMethod)
+    {
+        // Mark the name and descriptor.
+        markConstant(programClass, programMethod.u2nameIndex);
+        markConstant(programClass, programMethod.u2descriptorIndex);
+
+        // Mark the attributes.
+        programMethod.attributesAccept(programClass, this);
+
+        // Mark the classes referenced in the descriptor string.
+        programMethod.referencedClassesAccept(this);
+    }
+
+
+    /**
+     * Marks the hierarchy of implementing or overriding methods corresponding
+     * to the given method, if any.
+     */
+    protected void markMethodHierarchy(Clazz clazz, Method method)
+    {
+        if ((method.getAccessFlags() &
+             (ClassConstants.INTERNAL_ACC_PRIVATE |
+              ClassConstants.INTERNAL_ACC_STATIC)) == 0 &&
+            !ClassUtil.isInitializer(method.getName(clazz)))
+        {
+            clazz.accept(new ConcreteClassDownTraveler(
+                         new ClassHierarchyTraveler(true, true, false, true,
+                         new NamedMethodVisitor(method.getName(clazz),
+                                                method.getDescriptor(clazz),
+                         new MemberAccessFilter(0, ClassConstants.INTERNAL_ACC_PRIVATE | ClassConstants.INTERNAL_ACC_STATIC | ClassConstants.INTERNAL_ACC_ABSTRACT,
+                         this)))));
+        }
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitIntegerConstant(Clazz clazz, IntegerConstant integerConstant)
+    {
+        if (shouldBeMarkedAsUsed(integerConstant))
+        {
+            markAsUsed(integerConstant);
+        }
+    }
+
+
+    public void visitLongConstant(Clazz clazz, LongConstant longConstant)
+    {
+        if (shouldBeMarkedAsUsed(longConstant))
+        {
+            markAsUsed(longConstant);
+        }
+    }
+
+
+    public void visitFloatConstant(Clazz clazz, FloatConstant floatConstant)
+    {
+        if (shouldBeMarkedAsUsed(floatConstant))
+        {
+            markAsUsed(floatConstant);
+        }
+    }
+
+
+    public void visitDoubleConstant(Clazz clazz, DoubleConstant doubleConstant)
+    {
+        if (shouldBeMarkedAsUsed(doubleConstant))
+        {
+            markAsUsed(doubleConstant);
+        }
+    }
+
+
+    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
+    {
+        if (shouldBeMarkedAsUsed(stringConstant))
+        {
+            markAsUsed(stringConstant);
+
+            markConstant(clazz, stringConstant.u2stringIndex);
+
+            // Mark the referenced class and class member, if any.
+            stringConstant.referencedClassAccept(this);
+            stringConstant.referencedMemberAccept(this);
+        }
+    }
+
+
+    public void visitUtf8Constant(Clazz clazz, Utf8Constant utf8Constant)
+    {
+        if (shouldBeMarkedAsUsed(utf8Constant))
+        {
+            markAsUsed(utf8Constant);
+        }
+    }
+
+
+    public void visitInvokeDynamicConstant(Clazz clazz, InvokeDynamicConstant invokeDynamicConstant)
+    {
+        if (shouldBeMarkedAsUsed(invokeDynamicConstant))
+        {
+            markAsUsed(invokeDynamicConstant);
+
+            markConstant(clazz, invokeDynamicConstant.u2nameAndTypeIndex);
+
+            // Mark the bootstrap methods attribute.
+            clazz.attributesAccept(new MyBootStrapMethodUsageMarker(invokeDynamicConstant.u2bootstrapMethodAttributeIndex));
+        }
+    }
+
+
+    public void visitMethodHandleConstant(Clazz clazz, MethodHandleConstant methodHandleConstant)
+    {
+        if (shouldBeMarkedAsUsed(methodHandleConstant))
+        {
+            markAsUsed(methodHandleConstant);
+
+            markConstant(clazz, methodHandleConstant.u2referenceIndex);
+        }
+    }
+
+
+    public void visitAnyRefConstant(Clazz clazz, RefConstant refConstant)
+    {
+        if (shouldBeMarkedAsUsed(refConstant))
+        {
+            markAsUsed(refConstant);
+
+            markConstant(clazz, refConstant.u2classIndex);
+            markConstant(clazz, refConstant.u2nameAndTypeIndex);
+
+            // When compiled with "-target 1.2" or higher, the class or
+            // interface actually containing the referenced class member may
+            // be higher up the hierarchy. Make sure it's marked, in case it
+            // isn't used elsewhere.
+            refConstant.referencedClassAccept(this);
+
+            // Mark the referenced class member itself.
+            refConstant.referencedMemberAccept(this);
+        }
+    }
+
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        if (shouldBeMarkedAsUsed(classConstant))
+        {
+            markAsUsed(classConstant);
+
+            markConstant(clazz, classConstant.u2nameIndex);
+
+            // Mark the referenced class itself.
+            classConstant.referencedClassAccept(this);
+        }
+    }
+
+
+    public void visitMethodTypeConstant(Clazz clazz, MethodTypeConstant methodTypeConstant)
+    {
+        if (shouldBeMarkedAsUsed(methodTypeConstant))
+        {
+            markAsUsed(methodTypeConstant);
+
+            markConstant(clazz, methodTypeConstant.u2descriptorIndex);
+        }
+    }
+
+
+    public void visitNameAndTypeConstant(Clazz clazz, NameAndTypeConstant nameAndTypeConstant)
+    {
+        if (shouldBeMarkedAsUsed(nameAndTypeConstant))
+        {
+            markAsUsed(nameAndTypeConstant);
+
+            markConstant(clazz, nameAndTypeConstant.u2nameIndex);
+            markConstant(clazz, nameAndTypeConstant.u2descriptorIndex);
+        }
+    }
+
+
+    /**
+     * This AttributeVisitor marks the bootstrap methods attributes, their
+     * method entries, their method handles, and their arguments.
+     */
+    private class MyBootStrapMethodUsageMarker
+    extends       SimplifiedVisitor
+    implements    AttributeVisitor,
+                  BootstrapMethodInfoVisitor
+    {
+        private int bootstrapMethodIndex;
+
+
+        private MyBootStrapMethodUsageMarker(int bootstrapMethodIndex)
+        {
+            this.bootstrapMethodIndex = bootstrapMethodIndex;
+        }
+
+
+        // Implementations for AttributeVisitor.
+
+        public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+
+
+        public void visitBootstrapMethodsAttribute(Clazz clazz, BootstrapMethodsAttribute bootstrapMethodsAttribute)
+        {
+            if (shouldBeMarkedAsUsed(bootstrapMethodsAttribute))
+            {
+                markAsUsed(bootstrapMethodsAttribute);
+
+                markConstant(clazz, bootstrapMethodsAttribute.u2attributeNameIndex);
+
+                bootstrapMethodsAttribute.bootstrapMethodEntryAccept(clazz,
+                                                                     bootstrapMethodIndex,
+                                                                     this);
+            }
+        }
+
+
+        // Implementations for BootstrapMethodInfoVisitor.
+
+        public void visitBootstrapMethodInfo(Clazz clazz, BootstrapMethodInfo bootstrapMethodInfo)
+        {
+            markAsUsed(bootstrapMethodInfo);
+
+            markConstant(clazz, bootstrapMethodInfo.u2methodHandleIndex);
+
+            // Mark the constant pool entries referenced by the arguments.
+            bootstrapMethodInfo.methodArgumentsAccept(clazz, UsageMarker.this);
+        }
+    }
+
+
+    // Implementations for AttributeVisitor.
+    // Note that attributes are typically only referenced once, so we don't
+    // test if they have been marked already.
+
+    public void visitUnknownAttribute(Clazz clazz, UnknownAttribute unknownAttribute)
+    {
+        // This is the best we can do for unknown attributes.
+        markAsUsed(unknownAttribute);
+
+        markConstant(clazz, unknownAttribute.u2attributeNameIndex);
+    }
+
+
+    public void visitBootstrapMethodsAttribute(Clazz clazz, BootstrapMethodsAttribute bootstrapMethodsAttribute)
+    {
+        // Don't mark the attribute and its name here. We may mark it in
+        // MyBootStrapMethodsAttributeUsageMarker.
+    }
+
+
+    public void visitSourceFileAttribute(Clazz clazz, SourceFileAttribute sourceFileAttribute)
+    {
+        markAsUsed(sourceFileAttribute);
+
+        markConstant(clazz, sourceFileAttribute.u2attributeNameIndex);
+        markConstant(clazz, sourceFileAttribute.u2sourceFileIndex);
+    }
+
+
+    public void visitSourceDirAttribute(Clazz clazz, SourceDirAttribute sourceDirAttribute)
+    {
+        markAsUsed(sourceDirAttribute);
+
+        markConstant(clazz, sourceDirAttribute.u2attributeNameIndex);
+        markConstant(clazz, sourceDirAttribute.u2sourceDirIndex);
+    }
+
+
+    public void visitInnerClassesAttribute(Clazz clazz, InnerClassesAttribute innerClassesAttribute)
+    {
+        // Don't mark the attribute and its name yet. We may mark it later, in
+        // InnerUsageMarker.
+        //markAsUsed(innerClassesAttribute);
+
+        //markConstant(clazz, innerClassesAttribute.u2attrNameIndex);
+
+        // Do mark the outer class entries.
+        innerClassesAttribute.innerClassEntriesAccept(clazz, this);
+    }
+
+
+    public void visitEnclosingMethodAttribute(Clazz clazz, EnclosingMethodAttribute enclosingMethodAttribute)
+    {
+        markAsUsed(enclosingMethodAttribute);
+
+        markConstant(clazz, enclosingMethodAttribute.u2attributeNameIndex);
+        markConstant(clazz, enclosingMethodAttribute.u2classIndex);
+
+        if (enclosingMethodAttribute.u2nameAndTypeIndex != 0)
+        {
+            markConstant(clazz, enclosingMethodAttribute.u2nameAndTypeIndex);
+        }
+    }
+
+
+    public void visitDeprecatedAttribute(Clazz clazz, DeprecatedAttribute deprecatedAttribute)
+    {
+        markAsUsed(deprecatedAttribute);
+
+        markConstant(clazz, deprecatedAttribute.u2attributeNameIndex);
+    }
+
+
+    public void visitSyntheticAttribute(Clazz clazz, SyntheticAttribute syntheticAttribute)
+    {
+        markAsUsed(syntheticAttribute);
+
+        markConstant(clazz, syntheticAttribute.u2attributeNameIndex);
+    }
+
+
+    public void visitSignatureAttribute(Clazz clazz, SignatureAttribute signatureAttribute)
+    {
+        markAsUsed(signatureAttribute);
+
+        markConstant(clazz, signatureAttribute.u2attributeNameIndex);
+        markConstant(clazz, signatureAttribute.u2signatureIndex);
+    }
+
+
+    public void visitConstantValueAttribute(Clazz clazz, Field field, ConstantValueAttribute constantValueAttribute)
+    {
+        markAsUsed(constantValueAttribute);
+
+        markConstant(clazz, constantValueAttribute.u2attributeNameIndex);
+        markConstant(clazz, constantValueAttribute.u2constantValueIndex);
+    }
+
+
+    public void visitExceptionsAttribute(Clazz clazz, Method method, ExceptionsAttribute exceptionsAttribute)
+    {
+        markAsUsed(exceptionsAttribute);
+
+        markConstant(clazz, exceptionsAttribute.u2attributeNameIndex);
+
+        // Mark the constant pool entries referenced by the exceptions.
+        exceptionsAttribute.exceptionEntriesAccept((ProgramClass)clazz, this);
+    }
+
+
+    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
+    {
+        markAsUsed(codeAttribute);
+
+        markConstant(clazz, codeAttribute.u2attributeNameIndex);
+
+        // Mark the constant pool entries referenced by the instructions,
+        // by the exceptions, and by the attributes.
+        codeAttribute.instructionsAccept(clazz, method, this);
+        codeAttribute.exceptionsAccept(clazz, method, this);
+        codeAttribute.attributesAccept(clazz, method, this);
+    }
+
+
+    public void visitStackMapAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, StackMapAttribute stackMapAttribute)
+    {
+        markAsUsed(stackMapAttribute);
+
+        markConstant(clazz, stackMapAttribute.u2attributeNameIndex);
+
+        // Mark the constant pool entries referenced by the stack map frames.
+        stackMapAttribute.stackMapFramesAccept(clazz, method, codeAttribute, this);
+    }
+
+
+    public void visitStackMapTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, StackMapTableAttribute stackMapTableAttribute)
+    {
+        markAsUsed(stackMapTableAttribute);
+
+        markConstant(clazz, stackMapTableAttribute.u2attributeNameIndex);
+
+        // Mark the constant pool entries referenced by the stack map frames.
+        stackMapTableAttribute.stackMapFramesAccept(clazz, method, codeAttribute, this);
+    }
+
+
+    public void visitLineNumberTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LineNumberTableAttribute lineNumberTableAttribute)
+    {
+        markAsUsed(lineNumberTableAttribute);
+
+        markConstant(clazz, lineNumberTableAttribute.u2attributeNameIndex);
+    }
+
+
+    public void visitLocalVariableTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTableAttribute localVariableTableAttribute)
+    {
+        markAsUsed(localVariableTableAttribute);
+
+        markConstant(clazz, localVariableTableAttribute.u2attributeNameIndex);
+
+        // Mark the constant pool entries referenced by the local variables.
+        localVariableTableAttribute.localVariablesAccept(clazz, method, codeAttribute, this);
+    }
+
+
+    public void visitLocalVariableTypeTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTypeTableAttribute localVariableTypeTableAttribute)
+    {
+        markAsUsed(localVariableTypeTableAttribute);
+
+        markConstant(clazz, localVariableTypeTableAttribute.u2attributeNameIndex);
+
+        // Mark the constant pool entries referenced by the local variable types.
+        localVariableTypeTableAttribute.localVariablesAccept(clazz, method, codeAttribute, this);
+    }
+
+
+    public void visitAnyAnnotationsAttribute(Clazz clazz, AnnotationsAttribute annotationsAttribute)
+    {
+        // Don't mark the attribute and its contents yet. We may mark them later,
+        // in AnnotationUsageMarker.
+//        markAsUsed(annotationsAttribute);
+//
+//        markConstant(clazz, annotationsAttribute.u2attributeNameIndex);
+//
+//        // Mark the constant pool entries referenced by the annotations.
+//        annotationsAttribute.annotationsAccept(clazz, this);
+    }
+
+
+    public void visitAnyParameterAnnotationsAttribute(Clazz clazz, Method method, ParameterAnnotationsAttribute parameterAnnotationsAttribute)
+    {
+        // Don't mark the attribute and its contents yet. We may mark them later,
+        // in AnnotationUsageMarker.
+//        markAsUsed(parameterAnnotationsAttribute);
+//
+//        markConstant(clazz, parameterAnnotationsAttribute.u2attributeNameIndex);
+//
+//        // Mark the constant pool entries referenced by the annotations.
+//        parameterAnnotationsAttribute.annotationsAccept(clazz, method, this);
+    }
+
+
+    public void visitAnnotationDefaultAttribute(Clazz clazz, Method method, AnnotationDefaultAttribute annotationDefaultAttribute)
+    {
+        // Don't mark the attribute and its contents yet. We may mark them later,
+        // in AnnotationUsageMarker.
+//        markAsUsed(annotationDefaultAttribute);
+//
+//        markConstant(clazz, annotationDefaultAttribute.u2attributeNameIndex);
+//
+//        // Mark the constant pool entries referenced by the element value.
+//        annotationDefaultAttribute.defaultValueAccept(clazz, this);
+    }
+
+
+    // Implementations for ExceptionInfoVisitor.
+
+    public void visitExceptionInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, ExceptionInfo exceptionInfo)
+    {
+        markAsUsed(exceptionInfo);
+
+        if (exceptionInfo.u2catchType != 0)
+        {
+            markConstant(clazz, exceptionInfo.u2catchType);
+        }
+    }
+
+
+    // Implementations for InnerClassesInfoVisitor.
+
+    public void visitInnerClassesInfo(Clazz clazz, InnerClassesInfo innerClassesInfo)
+    {
+        // At this point, we only mark outer classes of this class.
+        // Inner class can be marked later, by InnerUsageMarker.
+        if (innerClassesInfo.u2innerClassIndex != 0 &&
+            clazz.getName().equals(clazz.getClassName(innerClassesInfo.u2innerClassIndex)))
+        {
+            markAsUsed(innerClassesInfo);
+
+            innerClassesInfo.innerClassConstantAccept(clazz, this);
+            innerClassesInfo.outerClassConstantAccept(clazz, this);
+            innerClassesInfo.innerNameConstantAccept(clazz, this);
+        }
+    }
+
+
+    // Implementations for StackMapFrameVisitor.
+
+    public void visitAnyStackMapFrame(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, StackMapFrame stackMapFrame) {}
+
+
+    public void visitSameOneFrame(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, SameOneFrame sameOneFrame)
+    {
+        // Mark the constant pool entries referenced by the verification types.
+        sameOneFrame.stackItemAccept(clazz, method, codeAttribute, offset, this);
+    }
+
+
+    public void visitMoreZeroFrame(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, MoreZeroFrame moreZeroFrame)
+    {
+        // Mark the constant pool entries referenced by the verification types.
+        moreZeroFrame.additionalVariablesAccept(clazz, method, codeAttribute, offset, this);
+    }
+
+
+    public void visitFullFrame(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, FullFrame fullFrame)
+    {
+        // Mark the constant pool entries referenced by the verification types.
+        fullFrame.variablesAccept(clazz, method, codeAttribute, offset, this);
+        fullFrame.stackAccept(clazz, method, codeAttribute, offset, this);
+    }
+
+
+    // Implementations for VerificationTypeVisitor.
+
+    public void visitAnyVerificationType(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, VerificationType verificationType) {}
+
+
+    public void visitObjectType(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ObjectType objectType)
+    {
+        markConstant(clazz, objectType.u2classIndex);
+    }
+
+
+    // Implementations for LocalVariableInfoVisitor.
+
+    public void visitLocalVariableInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableInfo localVariableInfo)
+    {
+        markConstant(clazz, localVariableInfo.u2nameIndex);
+        markConstant(clazz, localVariableInfo.u2descriptorIndex);
+    }
+
+
+    // Implementations for LocalVariableTypeInfoVisitor.
+
+    public void visitLocalVariableTypeInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTypeInfo localVariableTypeInfo)
+    {
+        markConstant(clazz, localVariableTypeInfo.u2nameIndex);
+        markConstant(clazz, localVariableTypeInfo.u2signatureIndex);
+    }
+
+
+//    // Implementations for AnnotationVisitor.
+//
+//    public void visitAnnotation(Clazz clazz, Annotation annotation)
+//    {
+//        markConstant(clazz, annotation.u2typeIndex);
+//
+//        // Mark the constant pool entries referenced by the element values.
+//        annotation.elementValuesAccept(clazz, this);
+//    }
+//
+//
+//    // Implementations for ElementValueVisitor.
+//
+//    public void visitConstantElementValue(Clazz clazz, Annotation annotation, ConstantElementValue constantElementValue)
+//    {
+//        if (constantElementValue.u2elementNameIndex != 0)
+//        {
+//            markConstant(clazz, constantElementValue.u2elementNameIndex);
+//        }
+//
+//        markConstant(clazz, constantElementValue.u2constantValueIndex);
+//    }
+//
+//
+//    public void visitEnumConstantElementValue(Clazz clazz, Annotation annotation, EnumConstantElementValue enumConstantElementValue)
+//    {
+//        if (enumConstantElementValue.u2elementNameIndex != 0)
+//        {
+//            markConstant(clazz, enumConstantElementValue.u2elementNameIndex);
+//        }
+//
+//        markConstant(clazz, enumConstantElementValue.u2typeNameIndex);
+//        markConstant(clazz, enumConstantElementValue.u2constantNameIndex);
+//    }
+//
+//
+//    public void visitClassElementValue(Clazz clazz, Annotation annotation, ClassElementValue classElementValue)
+//    {
+//        if (classElementValue.u2elementNameIndex != 0)
+//        {
+//            markConstant(clazz, classElementValue.u2elementNameIndex);
+//        }
+//
+//        // Mark the referenced class constant pool entry.
+//        markConstant(clazz, classElementValue.u2classInfoIndex);
+//    }
+//
+//
+//    public void visitAnnotationElementValue(Clazz clazz, Annotation annotation, AnnotationElementValue annotationElementValue)
+//    {
+//        if (annotationElementValue.u2elementNameIndex != 0)
+//        {
+//            markConstant(clazz, annotationElementValue.u2elementNameIndex);
+//        }
+//
+//        // Mark the constant pool entries referenced by the annotation.
+//        annotationElementValue.annotationAccept(clazz, this);
+//    }
+//
+//
+//    public void visitArrayElementValue(Clazz clazz, Annotation annotation, ArrayElementValue arrayElementValue)
+//    {
+//        if (arrayElementValue.u2elementNameIndex != 0)
+//        {
+//            markConstant(clazz, arrayElementValue.u2elementNameIndex);
+//        }
+//
+//        // Mark the constant pool entries referenced by the element values.
+//        arrayElementValue.elementValuesAccept(clazz, annotation, this);
+//    }
+
+
+    // 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)
+    {
+        markConstant(clazz, constantInstruction.constantIndex);
+
+        // Also mark the parameterless constructor of the class, in case the
+        // string constant or class constant is being used in a Class.forName
+        // or a .class construct.
+        clazz.constantPoolEntryAccept(constantInstruction.constantIndex,
+                                      parameterlessConstructorMarker);
+    }
+
+
+    // Small utility methods.
+
+    /**
+     * Marks the given visitor accepter as being used.
+     */
+    protected void markAsUsed(VisitorAccepter visitorAccepter)
+    {
+        visitorAccepter.setVisitorInfo(USED);
+    }
+
+
+    /**
+     * Returns whether the given visitor accepter should still be marked as
+     * being used.
+     */
+    protected boolean shouldBeMarkedAsUsed(VisitorAccepter visitorAccepter)
+    {
+        return visitorAccepter.getVisitorInfo() != USED;
+    }
+
+
+    /**
+     * Returns whether the given visitor accepter has been marked as being used.
+     */
+    protected boolean isUsed(VisitorAccepter visitorAccepter)
+    {
+        return visitorAccepter.getVisitorInfo() == USED;
+    }
+
+
+    /**
+     * Marks the given visitor accepter as possibly being used.
+     */
+    protected void markAsPossiblyUsed(VisitorAccepter visitorAccepter)
+    {
+        visitorAccepter.setVisitorInfo(POSSIBLY_USED);
+    }
+
+
+    /**
+     * Returns whether the given visitor accepter should still be marked as
+     * possibly being used.
+     */
+    protected boolean shouldBeMarkedAsPossiblyUsed(VisitorAccepter visitorAccepter)
+    {
+        return visitorAccepter.getVisitorInfo() != USED &&
+               visitorAccepter.getVisitorInfo() != POSSIBLY_USED;
+    }
+
+
+    /**
+     * Returns whether the given visitor accepter has been marked as possibly
+     * being used.
+     */
+    protected boolean isPossiblyUsed(VisitorAccepter visitorAccepter)
+    {
+        return visitorAccepter.getVisitorInfo() == POSSIBLY_USED;
+    }
+
+
+    /**
+     * Clears any usage marks from the given visitor accepter.
+     */
+    protected void markAsUnused(VisitorAccepter visitorAccepter)
+    {
+        visitorAccepter.setVisitorInfo(null);
+    }
+
+
+    /**
+     * Marks the given constant pool entry of the given class. This includes
+     * visiting any referenced objects.
+     */
+    private void markConstant(Clazz clazz, int index)
+    {
+        clazz.constantPoolEntryAccept(index, this);
+    }
+}