/** Performs obfuscation of the given program class pool. */
  public void execute(ClassPool programClassPool, ClassPool libraryClassPool) throws IOException {
    // Check if we have at least some keep commands.
    if (configuration.keep == null
        && configuration.applyMapping == null
        && configuration.printMapping == null) {
      throw new IOException("You have to specify '-keep' options for the obfuscation step.");
    }

    // Clean up any old visitor info.
    programClassPool.classesAccept(new ClassCleaner());
    libraryClassPool.classesAccept(new ClassCleaner());

    // If the class member names have to correspond globally,
    // link all class members in all classes, otherwise
    // link all non-private methods in all class hierarchies.
    ClassVisitor memberInfoLinker =
        configuration.useUniqueClassMemberNames
            ? (ClassVisitor) new AllMemberVisitor(new MethodLinker())
            : (ClassVisitor) new BottomClassFilter(new MethodLinker());

    programClassPool.classesAccept(memberInfoLinker);
    libraryClassPool.classesAccept(memberInfoLinker);

    // Create a visitor for marking the seeds.
    NameMarker nameMarker = new NameMarker();
    ClassPoolVisitor classPoolvisitor =
        ClassSpecificationVisitorFactory.createClassPoolVisitor(
            configuration.keep, nameMarker, nameMarker, false, false, true);
    // Mark the seeds.
    programClassPool.accept(classPoolvisitor);
    libraryClassPool.accept(classPoolvisitor);

    // All library classes and library class members keep their names.
    libraryClassPool.classesAccept(nameMarker);
    libraryClassPool.classesAccept(new AllMemberVisitor(nameMarker));

    // Mark attributes that have to be kept.
    AttributeUsageMarker requiredAttributeUsageMarker = new AttributeUsageMarker();

    AttributeVisitor optionalAttributeUsageMarker =
        configuration.keepAttributes == null
            ? null
            : new AttributeNameFilter(
                new ListParser(new NameParser()).parse(configuration.keepAttributes),
                requiredAttributeUsageMarker);

    programClassPool.classesAccept(
        new AllAttributeVisitor(
            true,
            new RequiredAttributeFilter(
                requiredAttributeUsageMarker, optionalAttributeUsageMarker)));

    // Remove the attributes that can be discarded. Note that the attributes
    // may only be discarded after the seeds have been marked, since the
    // configuration may rely on annotations.
    programClassPool.classesAccept(new AttributeShrinker());

    // Apply the mapping, if one has been specified. The mapping can
    // override the names of library classes and of library class members.
    if (configuration.applyMapping != null) {
      WarningPrinter warningPrinter = new WarningPrinter(System.err, configuration.warn);

      MappingReader reader = new MappingReader(configuration.applyMapping);

      MappingProcessor keeper =
          new MultiMappingProcessor(
              new MappingProcessor[] {
                new MappingKeeper(programClassPool, warningPrinter),
                new MappingKeeper(libraryClassPool, null),
              });

      reader.pump(keeper);

      // Print out a summary of the warnings if necessary.
      int mappingWarningCount = warningPrinter.getWarningCount();
      if (mappingWarningCount > 0) {
        System.err.println(
            "Warning: there were "
                + mappingWarningCount
                + " kept classes and class members that were remapped anyway.");
        System.err.println(
            "         You should adapt your configuration or edit the mapping file.");

        if (!configuration.ignoreWarnings) {
          System.err.println("         If you are sure this remapping won't hurt,");
          System.err.println(
              "         you could try your luck using the '-ignorewarnings' option.");
          throw new IOException("Please correct the above warnings first.");
        }
      }
    }

    // Come up with new names for all classes.
    DictionaryNameFactory classNameFactory =
        configuration.classObfuscationDictionary != null
            ? new DictionaryNameFactory(configuration.classObfuscationDictionary, null)
            : null;

    DictionaryNameFactory packageNameFactory =
        configuration.packageObfuscationDictionary != null
            ? new DictionaryNameFactory(configuration.packageObfuscationDictionary, null)
            : null;

    programClassPool.classesAccept(
        new ClassObfuscator(
            programClassPool,
            classNameFactory,
            packageNameFactory,
            configuration.useMixedCaseClassNames,
            configuration.keepPackageNames,
            configuration.flattenPackageHierarchy,
            configuration.repackageClasses,
            configuration.allowAccessModification));

    // Come up with new names for all class members.
    NameFactory nameFactory = new SimpleNameFactory();

    if (configuration.obfuscationDictionary != null) {
      nameFactory = new DictionaryNameFactory(configuration.obfuscationDictionary, nameFactory);
    }

    WarningPrinter warningPrinter = new WarningPrinter(System.err, configuration.warn);

    // Maintain a map of names to avoid [descriptor - new name - old name].
    Map descriptorMap = new HashMap();

    // Do the class member names have to be globally unique?
    if (configuration.useUniqueClassMemberNames) {
      // Collect all member names in all classes.
      programClassPool.classesAccept(
          new AllMemberVisitor(
              new MemberNameCollector(configuration.overloadAggressively, descriptorMap)));

      // Assign new names to all members in all classes.
      programClassPool.classesAccept(
          new AllMemberVisitor(
              new MemberObfuscator(
                  configuration.overloadAggressively, nameFactory, descriptorMap)));
    } else {
      // Come up with new names for all non-private class members.
      programClassPool.classesAccept(
          new MultiClassVisitor(
              new ClassVisitor[] {
                // Collect all private member names in this class and down
                // the hierarchy.
                new ClassHierarchyTraveler(
                    true,
                    false,
                    false,
                    true,
                    new AllMemberVisitor(
                        new MemberAccessFilter(
                            ClassConstants.INTERNAL_ACC_PRIVATE,
                            0,
                            new MemberNameCollector(
                                configuration.overloadAggressively, descriptorMap)))),

                // Collect all non-private member names anywhere in the hierarchy.
                new ClassHierarchyTraveler(
                    true,
                    true,
                    true,
                    true,
                    new AllMemberVisitor(
                        new MemberAccessFilter(
                            0,
                            ClassConstants.INTERNAL_ACC_PRIVATE,
                            new MemberNameCollector(
                                configuration.overloadAggressively, descriptorMap)))),

                // Assign new names to all non-private members in this class.
                new AllMemberVisitor(
                    new MemberAccessFilter(
                        0,
                        ClassConstants.INTERNAL_ACC_PRIVATE,
                        new MemberObfuscator(
                            configuration.overloadAggressively, nameFactory, descriptorMap))),

                // Clear the collected names.
                new MapCleaner(descriptorMap)
              }));

      // Come up with new names for all private class members.
      programClassPool.classesAccept(
          new MultiClassVisitor(
              new ClassVisitor[] {
                // Collect all member names in this class.
                new AllMemberVisitor(
                    new MemberNameCollector(configuration.overloadAggressively, descriptorMap)),

                // Collect all non-private member names higher up the hierarchy.
                new ClassHierarchyTraveler(
                    false,
                    true,
                    true,
                    false,
                    new AllMemberVisitor(
                        new MemberAccessFilter(
                            0,
                            ClassConstants.INTERNAL_ACC_PRIVATE,
                            new MemberNameCollector(
                                configuration.overloadAggressively, descriptorMap)))),

                // Assign new names to all private members in this class.
                new AllMemberVisitor(
                    new MemberAccessFilter(
                        ClassConstants.INTERNAL_ACC_PRIVATE,
                        0,
                        new MemberObfuscator(
                            configuration.overloadAggressively, nameFactory, descriptorMap))),

                // Clear the collected names.
                new MapCleaner(descriptorMap)
              }));
    }

    // Some class members may have ended up with conflicting names.
    // Come up with new, globally unique names for them.
    NameFactory specialNameFactory = new SpecialNameFactory(new SimpleNameFactory());

    // Collect a map of special names to avoid
    // [descriptor - new name - old name].
    Map specialDescriptorMap = new HashMap();

    programClassPool.classesAccept(
        new AllMemberVisitor(
            new MemberSpecialNameFilter(
                new MemberNameCollector(
                    configuration.overloadAggressively, specialDescriptorMap))));

    libraryClassPool.classesAccept(
        new AllMemberVisitor(
            new MemberSpecialNameFilter(
                new MemberNameCollector(
                    configuration.overloadAggressively, specialDescriptorMap))));

    // Replace conflicting non-private member names with special names.
    programClassPool.classesAccept(
        new MultiClassVisitor(
            new ClassVisitor[] {
              // Collect all private member names in this class and down
              // the hierarchy.
              new ClassHierarchyTraveler(
                  true,
                  false,
                  false,
                  true,
                  new AllMemberVisitor(
                      new MemberAccessFilter(
                          ClassConstants.INTERNAL_ACC_PRIVATE,
                          0,
                          new MemberNameCollector(
                              configuration.overloadAggressively, descriptorMap)))),

              // Collect all non-private member names in this class and
              // higher up the hierarchy.
              new ClassHierarchyTraveler(
                  true,
                  true,
                  true,
                  false,
                  new AllMemberVisitor(
                      new MemberAccessFilter(
                          0,
                          ClassConstants.INTERNAL_ACC_PRIVATE,
                          new MemberNameCollector(
                              configuration.overloadAggressively, descriptorMap)))),

              // Assign new names to all conflicting non-private members
              // in this class and higher up the hierarchy.
              new ClassHierarchyTraveler(
                  true,
                  true,
                  true,
                  false,
                  new AllMemberVisitor(
                      new MemberAccessFilter(
                          0,
                          ClassConstants.INTERNAL_ACC_PRIVATE,
                          new MemberNameConflictFixer(
                              configuration.overloadAggressively,
                              descriptorMap,
                              warningPrinter,
                              new MemberObfuscator(
                                  configuration.overloadAggressively,
                                  specialNameFactory,
                                  specialDescriptorMap))))),

              // Clear the collected names.
              new MapCleaner(descriptorMap)
            }));

    // Replace conflicting private member names with special names.
    // This is only possible if those names were kept or mapped.
    programClassPool.classesAccept(
        new MultiClassVisitor(
            new ClassVisitor[] {
              // Collect all member names in this class.
              new AllMemberVisitor(
                  new MemberNameCollector(configuration.overloadAggressively, descriptorMap)),

              // Collect all non-private member names higher up the hierarchy.
              new ClassHierarchyTraveler(
                  false,
                  true,
                  true,
                  false,
                  new AllMemberVisitor(
                      new MemberAccessFilter(
                          0,
                          ClassConstants.INTERNAL_ACC_PRIVATE,
                          new MemberNameCollector(
                              configuration.overloadAggressively, descriptorMap)))),

              // Assign new names to all conflicting private members in this
              // class.
              new AllMemberVisitor(
                  new MemberAccessFilter(
                      ClassConstants.INTERNAL_ACC_PRIVATE,
                      0,
                      new MemberNameConflictFixer(
                          configuration.overloadAggressively,
                          descriptorMap,
                          warningPrinter,
                          new MemberObfuscator(
                              configuration.overloadAggressively,
                              specialNameFactory,
                              specialDescriptorMap)))),

              // Clear the collected names.
              new MapCleaner(descriptorMap)
            }));

    // Print out any warnings about member name conflicts.
    int warningCount = warningPrinter.getWarningCount();
    if (warningCount > 0) {
      System.err.println(
          "Warning: there were " + warningCount + " conflicting class member name mappings.");
      System.err.println("         Your configuration may be inconsistent.");

      if (!configuration.ignoreWarnings) {
        System.err.println("         If you are sure the conflicts are harmless,");
        System.err.println("         you could try your luck using the '-ignorewarnings' option.");
        throw new IOException("Please correct the above warnings first.");
      }
    }

    // Print out the mapping, if requested.
    if (configuration.printMapping != null) {
      PrintStream ps =
          isFile(configuration.printMapping)
              ? new PrintStream(
                  new BufferedOutputStream(new FileOutputStream(configuration.printMapping)))
              : System.out;

      // Print out items that will be removed.
      programClassPool.classesAcceptAlphabetically(new MappingPrinter(ps));

      if (ps != System.out) {
        ps.close();
      }
    }

    // Actually apply the new names.
    programClassPool.classesAccept(new ClassRenamer());
    libraryClassPool.classesAccept(new ClassRenamer());

    // Update all references to these new names.
    programClassPool.classesAccept(new ClassReferenceFixer(false));
    libraryClassPool.classesAccept(new ClassReferenceFixer(false));
    programClassPool.classesAccept(new MemberReferenceFixer());

    // Make package visible elements public or protected, if obfuscated
    // classes are being repackaged aggressively.
    if (configuration.repackageClasses != null && configuration.allowAccessModification) {
      programClassPool.classesAccept(new AllConstantVisitor(new AccessFixer()));
    }

    // Rename the source file attributes, if requested.
    if (configuration.newSourceFileAttribute != null) {
      programClassPool.classesAccept(new SourceFileRenamer(configuration.newSourceFileAttribute));
    }

    // Mark NameAndType constant pool entries that have to be kept
    // and remove the other ones.
    programClassPool.classesAccept(new NameAndTypeUsageMarker());
    programClassPool.classesAccept(new NameAndTypeShrinker());

    // Mark Utf8 constant pool entries that have to be kept
    // and remove the other ones.
    programClassPool.classesAccept(new Utf8UsageMarker());
    programClassPool.classesAccept(new Utf8Shrinker());
  }
Example #2
0
  /** Performs optimization of the given program class pool. */
  public boolean execute(ClassPool programClassPool, ClassPool libraryClassPool)
      throws IOException {
    // Check if we have at least some keep commands.
    if (configuration.keep == null
        && configuration.applyMapping == null
        && configuration.printMapping == null) {
      throw new IOException("You have to specify '-keep' options for the optimization step.");
    }

    // Create a matcher for filtering optimizations.
    StringMatcher filter =
        configuration.optimizations != null
            ? new ListParser(new NameParser()).parse(configuration.optimizations)
            : new ConstantMatcher(true);

    boolean classMarkingFinal = StringMatcherUtil.matchesString(filter, CLASS_MARKING_FINAL);
    boolean classUnboxingEnum = StringMatcherUtil.matchesString(filter, CLASS_UNBOXING_ENUM);
    boolean classMergingVertical = StringMatcherUtil.matchesString(filter, CLASS_MERGING_VERTICAL);
    boolean classMergingHorizontal =
        StringMatcherUtil.matchesString(filter, CLASS_MERGING_HORIZONTAL);
    boolean fieldRemovalWriteonly =
        StringMatcherUtil.matchesString(filter, FIELD_REMOVAL_WRITEONLY);
    boolean fieldMarkingPrivate = StringMatcherUtil.matchesString(filter, FIELD_MARKING_PRIVATE);
    boolean fieldPropagationValue =
        StringMatcherUtil.matchesString(filter, FIELD_PROPAGATION_VALUE);
    boolean methodMarkingPrivate = StringMatcherUtil.matchesString(filter, METHOD_MARKING_PRIVATE);
    boolean methodMarkingStatic = StringMatcherUtil.matchesString(filter, METHOD_MARKING_STATIC);
    boolean methodMarkingFinal = StringMatcherUtil.matchesString(filter, METHOD_MARKING_FINAL);
    boolean methodRemovalParameter =
        StringMatcherUtil.matchesString(filter, METHOD_REMOVAL_PARAMETER);
    boolean methodPropagationParameter =
        StringMatcherUtil.matchesString(filter, METHOD_PROPAGATION_PARAMETER);
    boolean methodPropagationReturnvalue =
        StringMatcherUtil.matchesString(filter, METHOD_PROPAGATION_RETURNVALUE);
    boolean methodInliningShort = StringMatcherUtil.matchesString(filter, METHOD_INLINING_SHORT);
    boolean methodInliningUnique = StringMatcherUtil.matchesString(filter, METHOD_INLINING_UNIQUE);
    boolean methodInliningTailrecursion =
        StringMatcherUtil.matchesString(filter, METHOD_INLINING_TAILRECURSION);
    boolean codeMerging = StringMatcherUtil.matchesString(filter, CODE_MERGING);
    boolean codeSimplificationVariable =
        StringMatcherUtil.matchesString(filter, CODE_SIMPLIFICATION_VARIABLE);
    boolean codeSimplificationArithmetic =
        StringMatcherUtil.matchesString(filter, CODE_SIMPLIFICATION_ARITHMETIC);
    boolean codeSimplificationCast =
        StringMatcherUtil.matchesString(filter, CODE_SIMPLIFICATION_CAST);
    boolean codeSimplificationField =
        StringMatcherUtil.matchesString(filter, CODE_SIMPLIFICATION_FIELD);
    boolean codeSimplificationBranch =
        StringMatcherUtil.matchesString(filter, CODE_SIMPLIFICATION_BRANCH);
    boolean codeSimplificationString =
        StringMatcherUtil.matchesString(filter, CODE_SIMPLIFICATION_STRING);
    boolean codeSimplificationAdvanced =
        StringMatcherUtil.matchesString(filter, CODE_SIMPLIFICATION_ADVANCED);
    boolean codeRemovalAdvanced = StringMatcherUtil.matchesString(filter, CODE_REMOVAL_ADVANCED);
    boolean codeRemovalSimple = StringMatcherUtil.matchesString(filter, CODE_REMOVAL_SIMPLE);
    boolean codeRemovalVariable = StringMatcherUtil.matchesString(filter, CODE_REMOVAL_VARIABLE);
    boolean codeRemovalException = StringMatcherUtil.matchesString(filter, CODE_REMOVAL_EXCEPTION);
    boolean codeAllocationVariable =
        StringMatcherUtil.matchesString(filter, CODE_ALLOCATION_VARIABLE);

    // Create counters to count the numbers of optimizations.
    ClassCounter classMarkingFinalCounter = new ClassCounter();
    ClassCounter classUnboxingEnumCounter = new ClassCounter();
    ClassCounter classMergingVerticalCounter = new ClassCounter();
    ClassCounter classMergingHorizontalCounter = new ClassCounter();
    MemberCounter fieldRemovalWriteonlyCounter = new MemberCounter();
    MemberCounter fieldMarkingPrivateCounter = new MemberCounter();
    MemberCounter fieldPropagationValueCounter = new MemberCounter();
    MemberCounter methodMarkingPrivateCounter = new MemberCounter();
    MemberCounter methodMarkingStaticCounter = new MemberCounter();
    MemberCounter methodMarkingFinalCounter = new MemberCounter();
    MemberCounter methodRemovalParameterCounter = new MemberCounter();
    MemberCounter methodPropagationParameterCounter = new MemberCounter();
    MemberCounter methodPropagationReturnvalueCounter = new MemberCounter();
    InstructionCounter methodInliningShortCounter = new InstructionCounter();
    InstructionCounter methodInliningUniqueCounter = new InstructionCounter();
    InstructionCounter methodInliningTailrecursionCounter = new InstructionCounter();
    InstructionCounter codeMergingCounter = new InstructionCounter();
    InstructionCounter codeSimplificationVariableCounter = new InstructionCounter();
    InstructionCounter codeSimplificationArithmeticCounter = new InstructionCounter();
    InstructionCounter codeSimplificationCastCounter = new InstructionCounter();
    InstructionCounter codeSimplificationFieldCounter = new InstructionCounter();
    InstructionCounter codeSimplificationBranchCounter = new InstructionCounter();
    InstructionCounter codeSimplificationStringCounter = new InstructionCounter();
    InstructionCounter codeSimplificationAdvancedCounter = new InstructionCounter();
    InstructionCounter deletedCounter = new InstructionCounter();
    InstructionCounter addedCounter = new InstructionCounter();
    MemberCounter codeRemovalVariableCounter = new MemberCounter();
    ExceptionCounter codeRemovalExceptionCounter = new ExceptionCounter();
    MemberCounter codeAllocationVariableCounter = new MemberCounter();
    MemberCounter initializerFixCounter1 = new MemberCounter();
    MemberCounter initializerFixCounter2 = new MemberCounter();

    // Some optimizations are required by other optimizations.
    codeSimplificationAdvanced =
        codeSimplificationAdvanced
            || fieldPropagationValue
            || methodPropagationParameter
            || methodPropagationReturnvalue;

    codeRemovalAdvanced =
        codeRemovalAdvanced
            || fieldRemovalWriteonly
            || methodMarkingStatic
            || methodRemovalParameter;

    codeRemovalSimple = codeRemovalSimple || codeSimplificationBranch;

    codeRemovalException = codeRemovalException || codeRemovalAdvanced || codeRemovalSimple;

    // Clean up any old visitor info.
    programClassPool.classesAccept(new ClassCleaner());
    libraryClassPool.classesAccept(new ClassCleaner());

    // Link all methods that should get the same optimization info.
    programClassPool.classesAccept(new BottomClassFilter(new MethodLinker()));
    libraryClassPool.classesAccept(new BottomClassFilter(new MethodLinker()));

    // Create a visitor for marking the seeds.
    KeepMarker keepMarker = new KeepMarker();
    ClassPoolVisitor classPoolvisitor =
        ClassSpecificationVisitorFactory.createClassPoolVisitor(
            configuration.keep, keepMarker, keepMarker, false, true, false);
    // Mark the seeds.
    programClassPool.accept(classPoolvisitor);
    libraryClassPool.accept(classPoolvisitor);

    // All library classes and library class members remain unchanged.
    libraryClassPool.classesAccept(keepMarker);
    libraryClassPool.classesAccept(new AllMemberVisitor(keepMarker));

    // We also keep all classes that are involved in .class constructs.
    // We're not looking at enum classes though, so they can be simplified.
    programClassPool.classesAccept(
        new ClassAccessFilter(
            0,
            ClassConstants.ACC_ENUM,
            new AllMethodVisitor(
                new AllAttributeVisitor(
                    new AllInstructionVisitor(new DotClassClassVisitor(keepMarker))))));

    // We also keep all classes that are accessed dynamically.
    programClassPool.classesAccept(
        new AllConstantVisitor(
            new ConstantTagFilter(
                ClassConstants.CONSTANT_String, new ReferencedClassVisitor(keepMarker))));

    // We also keep all class members that are accessed dynamically.
    programClassPool.classesAccept(
        new AllConstantVisitor(
            new ConstantTagFilter(
                ClassConstants.CONSTANT_String, new ReferencedMemberVisitor(keepMarker))));

    // We also keep all bootstrap method signatures.
    programClassPool.classesAccept(
        new ClassVersionFilter(
            ClassConstants.CLASS_VERSION_1_7,
            new AllAttributeVisitor(
                new AttributeNameFilter(
                    ClassConstants.ATTR_BootstrapMethods,
                    new AllBootstrapMethodInfoVisitor(
                        new BootstrapMethodHandleTraveler(
                            new MethodrefTraveler(new ReferencedMemberVisitor(keepMarker))))))));

    // We also keep all bootstrap method arguments that point to methods.
    // These arguments are typically the method handles for
    // java.lang.invoke.LambdaMetafactory#metafactory, which provides the
    // implementations for closures.
    programClassPool.classesAccept(
        new ClassVersionFilter(
            ClassConstants.CLASS_VERSION_1_7,
            new AllAttributeVisitor(
                new AttributeNameFilter(
                    ClassConstants.ATTR_BootstrapMethods,
                    new AllBootstrapMethodInfoVisitor(
                        new BootstrapMethodArgumentVisitor(
                            new MethodrefTraveler(new ReferencedMemberVisitor(keepMarker))))))));

    // We also keep all classes (and their methods) returned by dynamic
    // method invocations. They may return dynamic implementations of
    // interfaces that otherwise appear unused.
    programClassPool.classesAccept(
        new ClassVersionFilter(
            ClassConstants.CLASS_VERSION_1_7,
            new AllConstantVisitor(
                new DynamicReturnedClassVisitor(
                    new MultiClassVisitor(
                        new ClassVisitor[] {keepMarker, new AllMemberVisitor(keepMarker)})))));

    // Attach some optimization info to all classes and class members, so
    // it can be filled out later.
    programClassPool.classesAccept(new ClassOptimizationInfoSetter());

    programClassPool.classesAccept(new AllMemberVisitor(new MemberOptimizationInfoSetter()));

    if (configuration.assumeNoSideEffects != null) {
      // Create a visitor for marking methods that don't have any side effects.
      NoSideEffectMethodMarker noSideEffectMethodMarker = new NoSideEffectMethodMarker();
      ClassPoolVisitor noClassPoolvisitor =
          ClassSpecificationVisitorFactory.createClassPoolVisitor(
              configuration.assumeNoSideEffects, null, noSideEffectMethodMarker);

      // Mark the seeds.
      programClassPool.accept(noClassPoolvisitor);
      libraryClassPool.accept(noClassPoolvisitor);
    }

    if (classMarkingFinal) {
      // Make classes final, whereever possible.
      programClassPool.classesAccept(new ClassFinalizer(classMarkingFinalCounter));
    }

    if (methodMarkingFinal) {
      // Make methods final, whereever possible.
      programClassPool.classesAccept(
          new ClassAccessFilter(
              0,
              ClassConstants.ACC_INTERFACE,
              new AllMethodVisitor(new MethodFinalizer(methodMarkingFinalCounter))));
    }

    if (fieldRemovalWriteonly) {
      // Mark all fields that are write-only.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(new AllInstructionVisitor(new ReadWriteFieldMarker()))));

      // Count the write-only fields.
      programClassPool.classesAccept(
          new AllFieldVisitor(new WriteOnlyFieldFilter(fieldRemovalWriteonlyCounter)));
    } else {
      // Mark all fields as read/write.
      programClassPool.classesAccept(new AllFieldVisitor(new ReadWriteFieldMarker()));
    }

    if (classUnboxingEnum) {
      ClassCounter counter = new ClassCounter();

      // Mark all final enums that qualify as simple enums.
      programClassPool.classesAccept(
          new ClassAccessFilter(
              ClassConstants.ACC_FINAL | ClassConstants.ACC_ENUM, 0, new SimpleEnumClassChecker()));

      // Count the preliminary number of simple enums.
      programClassPool.classesAccept(new SimpleEnumFilter(counter));

      // Only continue checking simple enums if there are any candidates.
      if (counter.getCount() > 0) {
        // Unmark all simple enums that are explicitly used as objects.
        programClassPool.classesAccept(new SimpleEnumUseChecker());

        // Count the definitive number of simple enums.
        programClassPool.classesAccept(new SimpleEnumFilter(classUnboxingEnumCounter));

        // Only start handling simple enums if there are any.
        if (classUnboxingEnumCounter.getCount() > 0) {
          // Simplify the use of the enum classes in code.
          programClassPool.classesAccept(
              new AllMethodVisitor(new AllAttributeVisitor(new SimpleEnumUseSimplifier())));

          // Simplify the static initializers of simple enum classes.
          programClassPool.classesAccept(new SimpleEnumFilter(new SimpleEnumClassSimplifier()));

          // Simplify the use of the enum classes in descriptors.
          programClassPool.classesAccept(new SimpleEnumDescriptorSimplifier());

          // Update references to class members with simple enum classes.
          programClassPool.classesAccept(new MemberReferenceFixer());
        }
      }
    }

    // Mark all used parameters, including the 'this' parameters.
    programClassPool.classesAccept(
        new AllMethodVisitor(
            new OptimizationInfoMemberFilter(
                new ParameterUsageMarker(!methodMarkingStatic, !methodRemovalParameter))));

    // Mark all classes that have static initializers.
    programClassPool.classesAccept(new StaticInitializerContainingClassMarker());

    // Mark all methods that have side effects.
    programClassPool.accept(new SideEffectMethodMarker());

    //        System.out.println("Optimizer.execute: before evaluation simplification");
    //        programClassPool.classAccept("abc/Def", new NamedMethodVisitor("abc", null, new
    // ClassPrinter()));

    // Perform partial evaluation for filling out fields, method parameters,
    // and method return values, so they can be propagated.
    if (fieldPropagationValue || methodPropagationParameter || methodPropagationReturnvalue) {
      // We'll create values to be stored with fields, method parameters,
      // and return values.
      ValueFactory valueFactory = new ParticularValueFactory();
      ValueFactory detailedValueFactory = new DetailedValueFactory();

      InvocationUnit storingInvocationUnit =
          new StoringInvocationUnit(
              valueFactory,
              fieldPropagationValue,
              methodPropagationParameter,
              methodPropagationReturnvalue);

      // Evaluate synthetic classes in more detail, notably to propagate
      // the arrays of the classes generated for enum switch statements.
      programClassPool.classesAccept(
          new ClassAccessFilter(
              ClassConstants.ACC_SYNTHETIC,
              0,
              new AllMethodVisitor(
                  new AllAttributeVisitor(
                      new PartialEvaluator(detailedValueFactory, storingInvocationUnit, false)))));

      // Evaluate non-synthetic classes.
      programClassPool.classesAccept(
          new ClassAccessFilter(
              0,
              ClassConstants.ACC_SYNTHETIC,
              new AllMethodVisitor(
                  new AllAttributeVisitor(
                      new PartialEvaluator(valueFactory, storingInvocationUnit, false)))));

      if (fieldPropagationValue) {
        // Count the constant fields.
        programClassPool.classesAccept(
            new AllFieldVisitor(new ConstantMemberFilter(fieldPropagationValueCounter)));
      }

      if (methodPropagationParameter) {
        // Count the constant method parameters.
        programClassPool.classesAccept(
            new AllMethodVisitor(new ConstantParameterFilter(methodPropagationParameterCounter)));
      }

      if (methodPropagationReturnvalue) {
        // Count the constant method return values.
        programClassPool.classesAccept(
            new AllMethodVisitor(new ConstantMemberFilter(methodPropagationReturnvalueCounter)));
      }

      if (classUnboxingEnumCounter.getCount() > 0) {
        // Propagate the simple enum constant counts.
        programClassPool.classesAccept(new SimpleEnumFilter(new SimpleEnumArrayPropagator()));
      }

      if (codeSimplificationAdvanced) {
        // Fill out constants into the arrays of synthetic classes,
        // notably the arrays of the classes generated for enum switch
        // statements.
        InvocationUnit loadingInvocationUnit =
            new LoadingInvocationUnit(
                valueFactory,
                fieldPropagationValue,
                methodPropagationParameter,
                methodPropagationReturnvalue);

        programClassPool.classesAccept(
            new ClassAccessFilter(
                ClassConstants.ACC_SYNTHETIC,
                0,
                new AllMethodVisitor(
                    new AllAttributeVisitor(
                        new PartialEvaluator(valueFactory, loadingInvocationUnit, false)))));
      }
    }

    // Perform partial evaluation again, now loading any previously stored
    // values for fields, method parameters, and method return values.
    ValueFactory valueFactory = new IdentifiedValueFactory();

    InvocationUnit loadingInvocationUnit =
        new LoadingInvocationUnit(
            valueFactory,
            fieldPropagationValue,
            methodPropagationParameter,
            methodPropagationReturnvalue);

    if (codeSimplificationAdvanced) {
      // Simplify based on partial evaluation, propagating constant
      // field values, method parameter values, and return values.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(
                  new EvaluationSimplifier(
                      new PartialEvaluator(valueFactory, loadingInvocationUnit, false),
                      codeSimplificationAdvancedCounter))));
    }

    if (codeRemovalAdvanced) {
      // Remove code based on partial evaluation, also removing unused
      // parameters from method invocations, and making methods static
      // if possible.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(
                  new EvaluationShrinker(
                      new PartialEvaluator(
                          valueFactory, loadingInvocationUnit, !codeSimplificationAdvanced),
                      deletedCounter,
                      addedCounter))));
    }

    if (methodRemovalParameter) {
      // Shrink the parameters in the method descriptors.
      programClassPool.classesAccept(
          new AllMethodVisitor(new OptimizationInfoMemberFilter(new MethodDescriptorShrinker())));
    }

    if (methodMarkingStatic) {
      // Make all non-static methods that don't require the 'this'
      // parameter static.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new OptimizationInfoMemberFilter(
                  new MemberAccessFilter(
                      0,
                      ClassConstants.ACC_STATIC,
                      new MethodStaticizer(methodMarkingStaticCounter)))));
    }

    if (methodRemovalParameter) {
      // Fix all references to class members.
      // This operation also updates the stack sizes.
      programClassPool.classesAccept(new MemberReferenceFixer());

      // Remove unused bootstrap method arguments.
      programClassPool.classesAccept(
          new AllAttributeVisitor(
              new AllBootstrapMethodInfoVisitor(new BootstrapMethodArgumentShrinker())));
    }

    if (methodRemovalParameter || methodMarkingPrivate || methodMarkingStatic) {
      // Remove all unused parameters from the byte code, shifting all
      // remaining variables.
      // This operation also updates the local variable frame sizes.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(new ParameterShrinker(methodRemovalParameterCounter))));
    } else if (codeRemovalAdvanced) {
      // Just update the local variable frame sizes.
      programClassPool.classesAccept(
          new AllMethodVisitor(new AllAttributeVisitor(new StackSizeUpdater())));
    }

    if (methodRemovalParameter && methodRemovalParameterCounter.getCount() > 0) {
      // Tweak the descriptors of duplicate initializers, due to removed
      // method parameters.
      programClassPool.classesAccept(
          new AllMethodVisitor(new DuplicateInitializerFixer(initializerFixCounter1)));

      if (initializerFixCounter1.getCount() > 0) {
        // Fix all invocations of tweaked initializers.
        programClassPool.classesAccept(
            new AllMethodVisitor(
                new AllAttributeVisitor(new DuplicateInitializerInvocationFixer(addedCounter))));

        // Fix all references to tweaked initializers.
        programClassPool.classesAccept(new MemberReferenceFixer());
      }
    }

    //// Specializing the class member descriptors seems to increase the
    //// class file size, on average.
    //// Specialize all class member descriptors.
    // programClassPool.classesAccept(new AllMemberVisitor(
    //                               new OptimizationInfoMemberFilter(
    //                               new MemberDescriptorSpecializer())));
    //
    //// Fix all references to classes, for MemberDescriptorSpecializer.
    // programClassPool.classesAccept(new AllMemberVisitor(
    //                               new OptimizationInfoMemberFilter(
    //                               new ClassReferenceFixer(true))));

    // Mark all classes with package visible members.
    // Mark all exception catches of methods.
    // Count all method invocations.
    // Mark super invocations and other access of methods.
    programClassPool.classesAccept(
        new MultiClassVisitor(
            new ClassVisitor[] {
              new PackageVisibleMemberContainingClassMarker(),
              new AllConstantVisitor(new PackageVisibleMemberInvokingClassMarker()),
              new AllMethodVisitor(
                  new MultiMemberVisitor(
                      new MemberVisitor[] {
                        new AllAttributeVisitor(
                            new MultiAttributeVisitor(
                                new AttributeVisitor[] {
                                  new CatchExceptionMarker(),
                                  new AllInstructionVisitor(
                                      new MultiInstructionVisitor(
                                          new InstructionVisitor[] {
                                            new InstantiationClassMarker(),
                                            new InstanceofClassMarker(),
                                            new DotClassMarker(),
                                            new MethodInvocationMarker(),
                                            new SuperInvocationMarker(),
                                            new DynamicInvocationMarker(),
                                            new BackwardBranchMarker(),
                                            new AccessMethodMarker(),
                                          })),
                                  new AllExceptionInfoVisitor(
                                      new ExceptionHandlerConstantVisitor(
                                          new ReferencedClassVisitor(new CaughtClassMarker()))),
                                })),
                      })),
            }));

    if (classMergingVertical) {
      // Merge subclasses up into their superclasses or
      // merge interfaces down into their implementing classes.
      programClassPool.classesAccept(
          new VerticalClassMerger(
              configuration.allowAccessModification,
              configuration.mergeInterfacesAggressively,
              classMergingVerticalCounter));
    }

    if (classMergingHorizontal) {
      // Merge classes into their sibling classes.
      programClassPool.classesAccept(
          new HorizontalClassMerger(
              configuration.allowAccessModification,
              configuration.mergeInterfacesAggressively,
              classMergingHorizontalCounter));
    }

    if (classMergingVerticalCounter.getCount() > 0
        || classMergingHorizontalCounter.getCount() > 0) {
      // Clean up inner class attributes to avoid loops.
      programClassPool.classesAccept(new RetargetedInnerClassAttributeRemover());

      // Update references to merged classes.
      programClassPool.classesAccept(new TargetClassChanger());
      programClassPool.classesAccept(new ClassReferenceFixer(true));
      programClassPool.classesAccept(new MemberReferenceFixer());

      if (configuration.allowAccessModification) {
        // Fix the access flags of referenced merged classes and their
        // class members.
        programClassPool.classesAccept(new AccessFixer());
      }

      // Fix the access flags of the inner classes information.
      programClassPool.classesAccept(
          new AllAttributeVisitor(new AllInnerClassesInfoVisitor(new InnerClassesAccessFixer())));

      // Tweak the descriptors of duplicate initializers, due to merged
      // parameter classes.
      programClassPool.classesAccept(
          new AllMethodVisitor(new DuplicateInitializerFixer(initializerFixCounter2)));

      if (initializerFixCounter2.getCount() > 0) {
        // Fix all invocations of tweaked initializers.
        programClassPool.classesAccept(
            new AllMethodVisitor(
                new AllAttributeVisitor(new DuplicateInitializerInvocationFixer(addedCounter))));

        // Fix all references to tweaked initializers.
        programClassPool.classesAccept(new MemberReferenceFixer());
      }
    }

    if (methodInliningUnique) {
      // Inline methods that are only invoked once.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(
                  new MethodInliner(
                      configuration.microEdition,
                      configuration.allowAccessModification,
                      true,
                      methodInliningUniqueCounter))));
    }

    if (methodInliningShort) {
      // Inline short methods.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(
                  new MethodInliner(
                      configuration.microEdition,
                      configuration.allowAccessModification,
                      false,
                      methodInliningShortCounter))));
    }

    if (methodInliningTailrecursion) {
      // Simplify tail recursion calls.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(
                  new TailRecursionSimplifier(methodInliningTailrecursionCounter))));
    }

    if (fieldMarkingPrivate || methodMarkingPrivate) {
      // Mark all class members that can not be made private.
      programClassPool.classesAccept(new NonPrivateMemberMarker());
    }

    if (fieldMarkingPrivate) {
      // Make all non-private fields private, whereever possible.
      programClassPool.classesAccept(
          new ClassAccessFilter(
              0,
              ClassConstants.ACC_INTERFACE,
              new AllFieldVisitor(
                  new MemberAccessFilter(
                      0,
                      ClassConstants.ACC_PRIVATE,
                      new MemberPrivatizer(fieldMarkingPrivateCounter)))));
    }

    if (methodMarkingPrivate) {
      // Make all non-private methods private, whereever possible.
      programClassPool.classesAccept(
          new ClassAccessFilter(
              0,
              ClassConstants.ACC_INTERFACE,
              new AllMethodVisitor(
                  new MemberAccessFilter(
                      0,
                      ClassConstants.ACC_PRIVATE,
                      new MemberPrivatizer(methodMarkingPrivateCounter)))));
    }

    if ((methodInliningUniqueCounter.getCount() > 0
            || methodInliningShortCounter.getCount() > 0
            || methodInliningTailrecursionCounter.getCount() > 0)
        && configuration.allowAccessModification) {
      // Fix the access flags of referenced classes and class members,
      // for MethodInliner.
      programClassPool.classesAccept(new AccessFixer());
    }

    if (methodRemovalParameterCounter.getCount() > 0
        || classMergingVerticalCounter.getCount() > 0
        || classMergingHorizontalCounter.getCount() > 0
        || methodMarkingPrivateCounter.getCount() > 0) {
      // Fix invocations of interface methods, of methods that have become
      // non-abstract or private, and of methods that have moved to a
      // different package.
      programClassPool.classesAccept(
          new AllMemberVisitor(new AllAttributeVisitor(new MethodInvocationFixer())));
    }

    if (codeMerging) {
      // Share common blocks of code at branches.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(new GotoCommonCodeReplacer(codeMergingCounter))));
    }

    // Create a branch target marker and a code attribute editor that can
    // be reused for all code attributes.
    BranchTargetFinder branchTargetFinder = new BranchTargetFinder();
    CodeAttributeEditor codeAttributeEditor = new CodeAttributeEditor();

    List peepholeOptimizations = new ArrayList();
    if (codeSimplificationVariable) {
      // Peephole optimizations involving local variables.
      peepholeOptimizations.add(
          new InstructionSequencesReplacer(
              InstructionSequenceConstants.CONSTANTS,
              InstructionSequenceConstants.VARIABLE,
              branchTargetFinder,
              codeAttributeEditor,
              codeSimplificationVariableCounter));
    }

    if (codeSimplificationArithmetic) {
      // Peephole optimizations involving arithmetic operations.
      peepholeOptimizations.add(
          new InstructionSequencesReplacer(
              InstructionSequenceConstants.CONSTANTS,
              InstructionSequenceConstants.ARITHMETIC,
              branchTargetFinder,
              codeAttributeEditor,
              codeSimplificationArithmeticCounter));
    }

    if (codeSimplificationCast) {
      // Peephole optimizations involving cast operations.
      peepholeOptimizations.add(
          new InstructionSequencesReplacer(
              InstructionSequenceConstants.CONSTANTS,
              InstructionSequenceConstants.CAST,
              branchTargetFinder,
              codeAttributeEditor,
              codeSimplificationCastCounter));
    }

    if (codeSimplificationField) {
      // Peephole optimizations involving fields.
      peepholeOptimizations.add(
          new InstructionSequencesReplacer(
              InstructionSequenceConstants.CONSTANTS,
              InstructionSequenceConstants.FIELD,
              branchTargetFinder,
              codeAttributeEditor,
              codeSimplificationFieldCounter));
    }

    if (codeSimplificationBranch) {
      // Peephole optimizations involving branches.
      peepholeOptimizations.add(
          new InstructionSequencesReplacer(
              InstructionSequenceConstants.CONSTANTS,
              InstructionSequenceConstants.BRANCH,
              branchTargetFinder,
              codeAttributeEditor,
              codeSimplificationBranchCounter));

      // Include optimization of branches to branches and returns.
      peepholeOptimizations.add(
          new GotoGotoReplacer(codeAttributeEditor, codeSimplificationBranchCounter));
      peepholeOptimizations.add(
          new GotoReturnReplacer(codeAttributeEditor, codeSimplificationBranchCounter));
    }

    if (codeSimplificationString) {
      // Peephole optimizations involving branches.
      peepholeOptimizations.add(
          new InstructionSequencesReplacer(
              InstructionSequenceConstants.CONSTANTS,
              InstructionSequenceConstants.STRING,
              branchTargetFinder,
              codeAttributeEditor,
              codeSimplificationStringCounter));
    }

    if (!peepholeOptimizations.isEmpty()) {
      // Convert the list into an array.
      InstructionVisitor[] peepholeOptimizationsArray =
          new InstructionVisitor[peepholeOptimizations.size()];
      peepholeOptimizations.toArray(peepholeOptimizationsArray);

      // Perform the peephole optimisations.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(
                  new PeepholeOptimizer(
                      branchTargetFinder,
                      codeAttributeEditor,
                      new MultiInstructionVisitor(peepholeOptimizationsArray)))));
    }

    if (codeRemovalException) {
      // Remove unnecessary exception handlers.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(
                  new UnreachableExceptionRemover(codeRemovalExceptionCounter))));
    }

    if (codeRemovalSimple) {
      // Remove unreachable code.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(new UnreachableCodeRemover(deletedCounter))));
    }

    if (codeRemovalVariable) {
      // Remove all unused local variables.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(new VariableShrinker(codeRemovalVariableCounter))));
    }

    if (codeAllocationVariable) {
      // Optimize the variables.
      programClassPool.classesAccept(
          new AllMethodVisitor(
              new AllAttributeVisitor(
                  new VariableOptimizer(false, codeAllocationVariableCounter))));
    }

    // Remove unused constants.
    programClassPool.classesAccept(new ConstantPoolShrinker());

    int classMarkingFinalCount = classMarkingFinalCounter.getCount();
    int classUnboxingEnumCount = classUnboxingEnumCounter.getCount();
    int classMergingVerticalCount = classMergingVerticalCounter.getCount();
    int classMergingHorizontalCount = classMergingHorizontalCounter.getCount();
    int fieldRemovalWriteonlyCount = fieldRemovalWriteonlyCounter.getCount();
    int fieldMarkingPrivateCount = fieldMarkingPrivateCounter.getCount();
    int fieldPropagationValueCount = fieldPropagationValueCounter.getCount();
    int methodMarkingPrivateCount = methodMarkingPrivateCounter.getCount();
    int methodMarkingStaticCount = methodMarkingStaticCounter.getCount();
    int methodMarkingFinalCount = methodMarkingFinalCounter.getCount();
    int methodRemovalParameterCount =
        methodRemovalParameterCounter.getCount()
            - methodMarkingStaticCounter.getCount()
            - initializerFixCounter1.getCount()
            - initializerFixCounter2.getCount();
    int methodPropagationParameterCount = methodPropagationParameterCounter.getCount();
    int methodPropagationReturnvalueCount = methodPropagationReturnvalueCounter.getCount();
    int methodInliningShortCount = methodInliningShortCounter.getCount();
    int methodInliningUniqueCount = methodInliningUniqueCounter.getCount();
    int methodInliningTailrecursionCount = methodInliningTailrecursionCounter.getCount();
    int codeMergingCount = codeMergingCounter.getCount();
    int codeSimplificationVariableCount = codeSimplificationVariableCounter.getCount();
    int codeSimplificationArithmeticCount = codeSimplificationArithmeticCounter.getCount();
    int codeSimplificationCastCount = codeSimplificationCastCounter.getCount();
    int codeSimplificationFieldCount = codeSimplificationFieldCounter.getCount();
    int codeSimplificationBranchCount = codeSimplificationBranchCounter.getCount();
    int codeSimplificationStringCount = codeSimplificationStringCounter.getCount();
    int codeSimplificationAdvancedCount = codeSimplificationAdvancedCounter.getCount();
    int codeRemovalCount = deletedCounter.getCount() - addedCounter.getCount();
    int codeRemovalVariableCount = codeRemovalVariableCounter.getCount();
    int codeRemovalExceptionCount = codeRemovalExceptionCounter.getCount();
    int codeAllocationVariableCount = codeAllocationVariableCounter.getCount();

    // Forget about constant fields, parameters, and return values, if they
    // didn't lead to any useful optimizations. We want to avoid fruitless
    // additional optimization passes.
    if (codeSimplificationAdvancedCount == 0) {
      fieldPropagationValueCount = 0;
      methodPropagationParameterCount = 0;
      methodPropagationReturnvalueCount = 0;
    }

    if (configuration.verbose) {
      System.out.println(
          "  Number of finalized classes:                 "
              + classMarkingFinalCount
              + disabled(classMarkingFinal));
      System.out.println(
          "  Number of unboxed enum classes:              "
              + classUnboxingEnumCount
              + disabled(classUnboxingEnum));
      System.out.println(
          "  Number of vertically merged classes:         "
              + classMergingVerticalCount
              + disabled(classMergingVertical));
      System.out.println(
          "  Number of horizontally merged classes:       "
              + classMergingHorizontalCount
              + disabled(classMergingHorizontal));
      System.out.println(
          "  Number of removed write-only fields:         "
              + fieldRemovalWriteonlyCount
              + disabled(fieldRemovalWriteonly));
      System.out.println(
          "  Number of privatized fields:                 "
              + fieldMarkingPrivateCount
              + disabled(fieldMarkingPrivate));
      System.out.println(
          "  Number of inlined constant fields:           "
              + fieldPropagationValueCount
              + disabled(fieldPropagationValue));
      System.out.println(
          "  Number of privatized methods:                "
              + methodMarkingPrivateCount
              + disabled(methodMarkingPrivate));
      System.out.println(
          "  Number of staticized methods:                "
              + methodMarkingStaticCount
              + disabled(methodMarkingStatic));
      System.out.println(
          "  Number of finalized methods:                 "
              + methodMarkingFinalCount
              + disabled(methodMarkingFinal));
      System.out.println(
          "  Number of removed method parameters:         "
              + methodRemovalParameterCount
              + disabled(methodRemovalParameter));
      System.out.println(
          "  Number of inlined constant parameters:       "
              + methodPropagationParameterCount
              + disabled(methodPropagationParameter));
      System.out.println(
          "  Number of inlined constant return values:    "
              + methodPropagationReturnvalueCount
              + disabled(methodPropagationReturnvalue));
      System.out.println(
          "  Number of inlined short method calls:        "
              + methodInliningShortCount
              + disabled(methodInliningShort));
      System.out.println(
          "  Number of inlined unique method calls:       "
              + methodInliningUniqueCount
              + disabled(methodInliningUnique));
      System.out.println(
          "  Number of inlined tail recursion calls:      "
              + methodInliningTailrecursionCount
              + disabled(methodInliningTailrecursion));
      System.out.println(
          "  Number of merged code blocks:                "
              + codeMergingCount
              + disabled(codeMerging));
      System.out.println(
          "  Number of variable peephole optimizations:   "
              + codeSimplificationVariableCount
              + disabled(codeSimplificationVariable));
      System.out.println(
          "  Number of arithmetic peephole optimizations: "
              + codeSimplificationArithmeticCount
              + disabled(codeSimplificationArithmetic));
      System.out.println(
          "  Number of cast peephole optimizations:       "
              + codeSimplificationCastCount
              + disabled(codeSimplificationCast));
      System.out.println(
          "  Number of field peephole optimizations:      "
              + codeSimplificationFieldCount
              + disabled(codeSimplificationField));
      System.out.println(
          "  Number of branch peephole optimizations:     "
              + codeSimplificationBranchCount
              + disabled(codeSimplificationBranch));
      System.out.println(
          "  Number of string peephole optimizations:     "
              + codeSimplificationStringCount
              + disabled(codeSimplificationString));
      System.out.println(
          "  Number of simplified instructions:           "
              + codeSimplificationAdvancedCount
              + disabled(codeSimplificationAdvanced));
      System.out.println(
          "  Number of removed instructions:              "
              + codeRemovalCount
              + disabled(codeRemovalAdvanced));
      System.out.println(
          "  Number of removed local variables:           "
              + codeRemovalVariableCount
              + disabled(codeRemovalVariable));
      System.out.println(
          "  Number of removed exception blocks:          "
              + codeRemovalExceptionCount
              + disabled(codeRemovalException));
      System.out.println(
          "  Number of optimized local variable frames:   "
              + codeAllocationVariableCount
              + disabled(codeAllocationVariable));
    }

    return classMarkingFinalCount > 0
        || classUnboxingEnumCount > 0
        || classMergingVerticalCount > 0
        || classMergingHorizontalCount > 0
        || fieldRemovalWriteonlyCount > 0
        || fieldMarkingPrivateCount > 0
        || methodMarkingPrivateCount > 0
        || methodMarkingStaticCount > 0
        || methodMarkingFinalCount > 0
        || fieldPropagationValueCount > 0
        || methodRemovalParameterCount > 0
        || methodPropagationParameterCount > 0
        || methodPropagationReturnvalueCount > 0
        || methodInliningShortCount > 0
        || methodInliningUniqueCount > 0
        || methodInliningTailrecursionCount > 0
        || codeMergingCount > 0
        || codeSimplificationVariableCount > 0
        || codeSimplificationArithmeticCount > 0
        || codeSimplificationCastCount > 0
        || codeSimplificationFieldCount > 0
        || codeSimplificationBranchCount > 0
        || codeSimplificationStringCount > 0
        || codeSimplificationAdvancedCount > 0
        || codeRemovalCount > 0
        || codeRemovalVariableCount > 0
        || codeRemovalExceptionCount > 0
        || codeAllocationVariableCount > 0;
  }