/** * Extracts a list of exceptions of field or method names for which not to print notes, from the * keep configuration. */ private StringMatcher createClassMemberNoteExceptionMatcher( List noteExceptions, boolean isField) { if (noteExceptions != null) { List noteExceptionNames = new ArrayList(); for (int index = 0; index < noteExceptions.size(); index++) { KeepClassSpecification keepClassSpecification = (KeepClassSpecification) noteExceptions.get(index); List memberSpecifications = isField ? keepClassSpecification.fieldSpecifications : keepClassSpecification.methodSpecifications; if (memberSpecifications != null) { for (int index2 = 0; index2 < memberSpecifications.size(); index2++) { MemberSpecification memberSpecification = (MemberSpecification) memberSpecifications.get(index2); String memberName = memberSpecification.name; if (memberName != null) { noteExceptionNames.add(memberName); } } } } if (noteExceptionNames.size() > 0) { return new ListParser(new ClassNameParser()).parse(noteExceptionNames); } } return null; }
/** * Extracts a list of exceptions of classes for which not to print notes, from the keep * configuration. */ private StringMatcher createClassNoteExceptionMatcher(List noteExceptions) { if (noteExceptions != null) { List noteExceptionNames = new ArrayList(noteExceptions.size()); for (int index = 0; index < noteExceptions.size(); index++) { KeepClassSpecification keepClassSpecification = (KeepClassSpecification) noteExceptions.get(index); if (keepClassSpecification.markClasses) { // If the class itself is being kept, it's ok. String className = keepClassSpecification.className; if (className != null) { noteExceptionNames.add(className); } // If all of its extensions are being kept, it's ok too. String extendsClassName = keepClassSpecification.extendsClassName; if (extendsClassName != null) { noteExceptionNames.add(extendsClassName); } } } if (noteExceptionNames.size() > 0) { return new ListParser(new ClassNameParser()).parse(noteExceptionNames); } } return null; }
/** 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; }