| // Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| package com.android.tools.r8.graph; |
| |
| import com.android.build.shrinker.r8integration.R8ResourceShrinkerState; |
| import com.android.tools.r8.androidapi.AndroidApiLevelCompute; |
| import com.android.tools.r8.androidapi.ComputedApiLevel; |
| import com.android.tools.r8.classmerging.ClassMergerMode; |
| import com.android.tools.r8.contexts.CompilationContext; |
| import com.android.tools.r8.contexts.CompilationContext.ProcessorContext; |
| import com.android.tools.r8.errors.dontwarn.DontWarnConfiguration; |
| import com.android.tools.r8.features.ClassToFeatureSplitMap; |
| import com.android.tools.r8.graph.DexValue.DexValueString; |
| import com.android.tools.r8.graph.analysis.InitializedClassesInInstanceMethodsAnalysis.InitializedClassesInInstanceMethods; |
| import com.android.tools.r8.graph.classmerging.MergedClassesCollection; |
| import com.android.tools.r8.graph.lens.AppliedGraphLens; |
| import com.android.tools.r8.graph.lens.ClearCodeRewritingGraphLens; |
| import com.android.tools.r8.graph.lens.GraphLens; |
| import com.android.tools.r8.graph.lens.InitClassLens; |
| import com.android.tools.r8.graph.lens.NonIdentityGraphLens; |
| import com.android.tools.r8.horizontalclassmerging.HorizontallyMergedClasses; |
| import com.android.tools.r8.ir.analysis.inlining.SimpleInliningConstraintFactory; |
| import com.android.tools.r8.ir.analysis.proto.EnumLiteProtoShrinker; |
| import com.android.tools.r8.ir.analysis.proto.GeneratedExtensionRegistryShrinker; |
| import com.android.tools.r8.ir.analysis.proto.GeneratedMessageLiteBuilderShrinker; |
| import com.android.tools.r8.ir.analysis.proto.GeneratedMessageLiteShrinker; |
| import com.android.tools.r8.ir.analysis.proto.ProtoShrinker; |
| import com.android.tools.r8.ir.analysis.value.AbstractValueFactory; |
| import com.android.tools.r8.ir.analysis.value.AbstractValueJoiner.AbstractValueConstantPropagationJoiner; |
| import com.android.tools.r8.ir.analysis.value.AbstractValueJoiner.AbstractValueFieldJoiner; |
| import com.android.tools.r8.ir.analysis.value.AbstractValueJoiner.AbstractValueParameterJoiner; |
| import com.android.tools.r8.ir.desugar.TypeRewriter; |
| import com.android.tools.r8.ir.optimize.enums.EnumDataMap; |
| import com.android.tools.r8.ir.optimize.info.MethodResolutionOptimizationInfoCollection; |
| import com.android.tools.r8.ir.optimize.info.field.InstanceFieldInitializationInfoFactory; |
| import com.android.tools.r8.ir.optimize.library.LibraryMemberOptimizer; |
| import com.android.tools.r8.ir.optimize.library.LibraryMethodSideEffectModelCollection; |
| import com.android.tools.r8.naming.NamingLens; |
| import com.android.tools.r8.naming.SeedMapper; |
| import com.android.tools.r8.optimize.MemberRebindingIdentityLens; |
| import com.android.tools.r8.optimize.MemberRebindingIdentityLensFactory; |
| import com.android.tools.r8.optimize.argumentpropagation.ArgumentPropagator; |
| import com.android.tools.r8.optimize.compose.ComposeReferences; |
| import com.android.tools.r8.optimize.interfaces.collection.OpenClosedInterfacesCollection; |
| import com.android.tools.r8.profile.art.ArtProfileCollection; |
| import com.android.tools.r8.profile.startup.profile.StartupProfile; |
| import com.android.tools.r8.shaking.AppInfoWithLiveness; |
| import com.android.tools.r8.shaking.AssumeInfoCollection; |
| import com.android.tools.r8.shaking.KeepClassInfo; |
| import com.android.tools.r8.shaking.KeepFieldInfo; |
| import com.android.tools.r8.shaking.KeepInfo; |
| import com.android.tools.r8.shaking.KeepInfoCollection; |
| import com.android.tools.r8.shaking.KeepMemberInfo; |
| import com.android.tools.r8.shaking.KeepMethodInfo; |
| import com.android.tools.r8.shaking.LibraryModeledPredicate; |
| import com.android.tools.r8.shaking.MainDexInfo; |
| import com.android.tools.r8.shaking.ProguardCompatibilityActions; |
| import com.android.tools.r8.shaking.RootSetUtils.MainDexRootSet; |
| import com.android.tools.r8.shaking.RootSetUtils.RootSet; |
| import com.android.tools.r8.synthesis.SyntheticItems; |
| import com.android.tools.r8.synthesis.SyntheticItems.GlobalSyntheticsStrategy; |
| import com.android.tools.r8.utils.InternalOptions; |
| import com.android.tools.r8.utils.InternalOptions.TestingOptions; |
| import com.android.tools.r8.utils.OptionalBool; |
| import com.android.tools.r8.utils.Reporter; |
| import com.android.tools.r8.utils.ResourceShrinkerUtils; |
| import com.android.tools.r8.utils.ThrowingConsumer; |
| import com.android.tools.r8.utils.Timing; |
| import com.android.tools.r8.utils.threads.ThreadTask; |
| import com.android.tools.r8.utils.threads.ThreadTaskUtils; |
| import com.android.tools.r8.verticalclassmerging.VerticallyMergedClasses; |
| import com.google.common.base.Predicates; |
| import com.google.common.collect.ImmutableSet; |
| import java.io.IOException; |
| import java.util.IdentityHashMap; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.ExecutionException; |
| import java.util.concurrent.ExecutorService; |
| import java.util.function.Function; |
| import java.util.function.Predicate; |
| import java.util.function.Supplier; |
| |
| public class AppView<T extends AppInfo> implements DexDefinitionSupplier, LibraryModeledPredicate { |
| |
| public enum WholeProgramOptimizations { |
| ON, |
| OFF; |
| |
| public boolean isOn() { |
| return this == ON; |
| } |
| } |
| |
| private T appInfo; |
| private AppInfoWithClassHierarchy appInfoForDesugaring; |
| private AppServices appServices; |
| private ArtProfileCollection artProfileCollection; |
| private AssumeInfoCollection assumeInfoCollection = AssumeInfoCollection.builder().build(); |
| private final DontWarnConfiguration dontWarnConfiguration; |
| private final WholeProgramOptimizations wholeProgramOptimizations; |
| private GraphLens codeLens = GraphLens.getIdentityLens(); |
| private GraphLens graphLens = GraphLens.getIdentityLens(); |
| private GraphLens genericSignaturesLens = GraphLens.getIdentityLens(); |
| private InitClassLens initClassLens; |
| private GraphLens kotlinMetadataLens = GraphLens.getIdentityLens(); |
| private NamingLens namingLens = NamingLens.getIdentityLens(); |
| private ProguardCompatibilityActions proguardCompatibilityActions; |
| private RootSet rootSet; |
| private MethodResolutionOptimizationInfoCollection methodResolutionOptimizationInfoCollection = |
| MethodResolutionOptimizationInfoCollection.empty(); |
| private MainDexRootSet mainDexRootSet = null; |
| private StartupProfile startupProfile; |
| |
| // This should preferably always be obtained via AppInfoWithLiveness. |
| // Currently however the liveness may be downgraded thus loosing the computed keep info. |
| private KeepInfoCollection keepInfo = null; |
| |
| private ComposeReferences composeReferences = null; |
| |
| private final AbstractValueFactory abstractValueFactory; |
| private final AbstractValueConstantPropagationJoiner abstractValueConstantPropagationJoiner; |
| private final AbstractValueFieldJoiner abstractValueFieldJoiner; |
| private final AbstractValueParameterJoiner abstractValueParameterJoiner; |
| private final InstanceFieldInitializationInfoFactory instanceFieldInitializationInfoFactory = |
| new InstanceFieldInitializationInfoFactory(); |
| private final SimpleInliningConstraintFactory simpleInliningConstraintFactory = |
| new SimpleInliningConstraintFactory(); |
| |
| // Desugaring. |
| public final TypeRewriter typeRewriter; |
| |
| // Modeling. |
| private final LibraryMethodSideEffectModelCollection libraryMethodSideEffectModelCollection; |
| |
| // Optimizations. |
| private final ArgumentPropagator argumentPropagator; |
| private final LibraryMemberOptimizer libraryMemberOptimizer; |
| private final ProtoShrinker protoShrinker; |
| |
| // Optimization results. |
| private boolean allCodeProcessed = false; |
| private Predicate<DexType> classesEscapingIntoLibrary = Predicates.alwaysTrue(); |
| private InitializedClassesInInstanceMethods initializedClassesInInstanceMethods; |
| private HorizontallyMergedClasses horizontallyMergedClasses = HorizontallyMergedClasses.empty(); |
| private VerticallyMergedClasses verticallyMergedClasses; |
| private EnumDataMap unboxedEnums = null; |
| private OpenClosedInterfacesCollection openClosedInterfacesCollection = |
| OpenClosedInterfacesCollection.getDefault(); |
| // TODO(b/169115389): Remove |
| private Set<DexMethod> cfByteCodePassThrough = ImmutableSet.of(); |
| private final Map<DexType, DexValueString> sourceDebugExtensions = new IdentityHashMap<>(); |
| private final Map<DexType, String> sourceFileForPrunedTypes = new IdentityHashMap<>(); |
| |
| private SeedMapper applyMappingSeedMapper; |
| |
| private R8ResourceShrinkerState resourceShrinkerState = null; |
| |
| // When input has been (partially) desugared these are the classes which has been library |
| // desugared. This information is populated in the IR converter. |
| private Set<DexType> alreadyLibraryDesugared = null; |
| |
| private final CompilationContext context; |
| |
| private final Thread mainThread = Thread.currentThread(); |
| |
| private final AndroidApiLevelCompute apiLevelCompute; |
| private final ComputedApiLevel computedMinApiLevel; |
| |
| private AppView( |
| T appInfo, |
| ArtProfileCollection artProfileCollection, |
| StartupProfile startupProfile, |
| WholeProgramOptimizations wholeProgramOptimizations, |
| TypeRewriter mapper) { |
| this( |
| appInfo, |
| artProfileCollection, |
| startupProfile, |
| wholeProgramOptimizations, |
| mapper, |
| Timing.empty()); |
| } |
| |
| private AppView( |
| T appInfo, |
| ArtProfileCollection artProfileCollection, |
| StartupProfile startupProfile, |
| WholeProgramOptimizations wholeProgramOptimizations, |
| TypeRewriter mapper, |
| Timing timing) { |
| assert appInfo != null; |
| this.appInfo = appInfo; |
| this.context = |
| timing.time( |
| "Compilation context", () -> CompilationContext.createInitialContext(options())); |
| this.wholeProgramOptimizations = wholeProgramOptimizations; |
| abstractValueFactory = new AbstractValueFactory(); |
| abstractValueConstantPropagationJoiner = new AbstractValueConstantPropagationJoiner(this); |
| if (enableWholeProgramOptimizations()) { |
| abstractValueFieldJoiner = new AbstractValueFieldJoiner(withClassHierarchy()); |
| abstractValueParameterJoiner = new AbstractValueParameterJoiner(withClassHierarchy()); |
| } else { |
| abstractValueFieldJoiner = null; |
| abstractValueParameterJoiner = null; |
| } |
| this.artProfileCollection = artProfileCollection; |
| this.startupProfile = startupProfile; |
| this.dontWarnConfiguration = |
| timing.time( |
| "Dont warn config", |
| () -> DontWarnConfiguration.create(options().getProguardConfiguration())); |
| this.initClassLens = timing.time("Init class lens", InitClassLens::getThrowingInstance); |
| this.typeRewriter = mapper; |
| timing.begin("Create argument propagator"); |
| if (enableWholeProgramOptimizations() && options().callSiteOptimizationOptions().isEnabled()) { |
| this.argumentPropagator = new ArgumentPropagator(withLiveness()); |
| } else { |
| this.argumentPropagator = null; |
| } |
| if (enableWholeProgramOptimizations() && options().isOptimizedResourceShrinking()) { |
| resourceShrinkerState = ResourceShrinkerUtils.createResourceShrinkerState(this); |
| } |
| timing.end(); |
| this.libraryMethodSideEffectModelCollection = |
| timing.time("Library side-effects", () -> new LibraryMethodSideEffectModelCollection(this)); |
| this.libraryMemberOptimizer = |
| timing.time("Library optimizer", () -> new LibraryMemberOptimizer(this, timing)); |
| this.protoShrinker = timing.time("Proto shrinker", () -> ProtoShrinker.create(withLiveness())); |
| this.apiLevelCompute = |
| timing.time("ApiLevel compute", () -> AndroidApiLevelCompute.create(this)); |
| this.computedMinApiLevel = |
| timing.time( |
| "ApiLevel computed", () -> apiLevelCompute.computeInitialMinApiLevel(options())); |
| } |
| |
| public boolean verifyMainThread() { |
| assert mainThread == Thread.currentThread(); |
| return true; |
| } |
| |
| @Override |
| public boolean isModeled(DexType type) { |
| return libraryMemberOptimizer.isModeled(type); |
| } |
| |
| private static <T extends AppInfo> TypeRewriter defaultTypeRewriter(T appInfo) { |
| InternalOptions options = appInfo.options(); |
| return options.getTypeRewriter(); |
| } |
| |
| public static <T extends AppInfo> AppView<T> createForD8(T appInfo) { |
| return new AppView<>( |
| appInfo, |
| ArtProfileCollection.createInitialArtProfileCollection(appInfo, appInfo.options()), |
| StartupProfile.empty(), |
| WholeProgramOptimizations.OFF, |
| defaultTypeRewriter(appInfo)); |
| } |
| |
| public static AppView<AppInfoWithClassHierarchy> createForSimulatingR8InD8( |
| DirectMappedDexApplication application, MainDexInfo mainDexInfo) { |
| ClassToFeatureSplitMap classToFeatureSplitMap = |
| ClassToFeatureSplitMap.createInitialClassToFeatureSplitMap(application.options); |
| AppInfoWithClassHierarchy appInfo = |
| AppInfoWithClassHierarchy.createInitialAppInfoWithClassHierarchy( |
| application, |
| classToFeatureSplitMap, |
| mainDexInfo, |
| GlobalSyntheticsStrategy.forSingleOutputMode()); |
| return new AppView<>( |
| appInfo, |
| ArtProfileCollection.empty(), |
| StartupProfile.empty(), |
| WholeProgramOptimizations.ON, |
| defaultTypeRewriter(appInfo)); |
| } |
| |
| public static <T extends AppInfo> AppView<T> createForD8( |
| T appInfo, TypeRewriter mapper, Timing timing) { |
| return new AppView<>( |
| appInfo, |
| ArtProfileCollection.createInitialArtProfileCollection(appInfo, appInfo.options()), |
| StartupProfile.empty(), |
| WholeProgramOptimizations.OFF, |
| mapper, |
| timing); |
| } |
| |
| public static AppView<AppInfoWithClassHierarchy> createForR8(DexApplication application) { |
| return createForR8(application, MainDexInfo.none()); |
| } |
| |
| public static AppView<AppInfoWithClassHierarchy> createForR8( |
| DexApplication application, MainDexInfo mainDexInfo) { |
| ClassToFeatureSplitMap classToFeatureSplitMap = |
| ClassToFeatureSplitMap.createInitialClassToFeatureSplitMap(application.options); |
| AppInfoWithClassHierarchy appInfo = |
| AppInfoWithClassHierarchy.createInitialAppInfoWithClassHierarchy( |
| application, |
| classToFeatureSplitMap, |
| mainDexInfo, |
| GlobalSyntheticsStrategy.forSingleOutputMode()); |
| return new AppView<>( |
| appInfo, |
| ArtProfileCollection.createInitialArtProfileCollection(appInfo, appInfo.options()), |
| StartupProfile.createInitialStartupProfileForR8(application), |
| WholeProgramOptimizations.ON, |
| defaultTypeRewriter(appInfo)); |
| } |
| |
| public static <T extends AppInfo> AppView<T> createForL8(T appInfo, TypeRewriter mapper) { |
| return new AppView<>( |
| appInfo, |
| ArtProfileCollection.createInitialArtProfileCollection(appInfo, appInfo.options()), |
| StartupProfile.empty(), |
| WholeProgramOptimizations.OFF, |
| mapper); |
| } |
| |
| public static <T extends AppInfo> AppView<T> createForRelocator(T appInfo) { |
| return new AppView<>( |
| appInfo, |
| ArtProfileCollection.empty(), |
| StartupProfile.empty(), |
| WholeProgramOptimizations.OFF, |
| defaultTypeRewriter(appInfo)); |
| } |
| |
| public static AppView<AppInfoWithClassHierarchy> createForTracer( |
| AppInfoWithClassHierarchy appInfo) { |
| return new AppView<>( |
| appInfo, |
| ArtProfileCollection.empty(), |
| StartupProfile.empty(), |
| WholeProgramOptimizations.ON, |
| defaultTypeRewriter(appInfo)); |
| } |
| |
| public AbstractValueFactory abstractValueFactory() { |
| return abstractValueFactory; |
| } |
| |
| public AbstractValueConstantPropagationJoiner getAbstractValueConstantPropagationJoiner() { |
| return abstractValueConstantPropagationJoiner; |
| } |
| |
| public AbstractValueFieldJoiner getAbstractValueFieldJoiner() { |
| return abstractValueFieldJoiner; |
| } |
| |
| public AbstractValueParameterJoiner getAbstractValueParameterJoiner() { |
| return abstractValueParameterJoiner; |
| } |
| |
| public void clearMethodResolutionOptimizationInfoCollection() { |
| methodResolutionOptimizationInfoCollection = MethodResolutionOptimizationInfoCollection.empty(); |
| } |
| |
| public MethodResolutionOptimizationInfoCollection |
| getMethodResolutionOptimizationInfoCollection() { |
| return methodResolutionOptimizationInfoCollection; |
| } |
| |
| public void setMethodResolutionOptimizationInfoCollection( |
| MethodResolutionOptimizationInfoCollection getMethodResolutionOptimizationInfoCollection) { |
| this.methodResolutionOptimizationInfoCollection = getMethodResolutionOptimizationInfoCollection; |
| } |
| |
| public InstanceFieldInitializationInfoFactory instanceFieldInitializationInfoFactory() { |
| return instanceFieldInitializationInfoFactory; |
| } |
| |
| public SimpleInliningConstraintFactory simpleInliningConstraintFactory() { |
| return simpleInliningConstraintFactory; |
| } |
| |
| public DexApplication app() { |
| return appInfo().app(); |
| } |
| |
| public T appInfo() { |
| assert !appInfo.hasClassHierarchy() || enableWholeProgramOptimizations(); |
| return appInfo; |
| } |
| |
| public AppInfoWithClassHierarchy appInfoWithClassHierarchy() { |
| return hasClassHierarchy() ? appInfo.withClassHierarchy() : null; |
| } |
| |
| public AppInfoWithLiveness appInfoWithLiveness() { |
| return hasLiveness() ? appInfo.withLiveness() : null; |
| } |
| |
| public AppInfoWithClassHierarchy appInfoForDesugaring() { |
| if (enableWholeProgramOptimizations()) { |
| assert appInfo.hasClassHierarchy(); |
| return appInfo.withClassHierarchy(); |
| } |
| assert !appInfo.hasClassHierarchy(); |
| if (appInfoForDesugaring == null) { |
| appInfoForDesugaring = AppInfoWithClassHierarchy.createForDesugaring(appInfo()); |
| } |
| return appInfoForDesugaring; |
| } |
| |
| private void unsetAppInfoForDesugaring() { |
| appInfoForDesugaring = null; |
| } |
| |
| public <U extends T> AppView<U> setAppInfo(U appInfo) { |
| assert !appInfo.isObsolete(); |
| AppInfo previous = this.appInfo; |
| this.appInfo = appInfo; |
| unsetAppInfoForDesugaring(); |
| if (appInfo != previous) { |
| previous.markObsolete(); |
| } |
| if (appInfo.hasLiveness()) { |
| keepInfo = appInfo.withLiveness().getKeepInfo(); |
| } |
| @SuppressWarnings("unchecked") |
| AppView<U> appViewWithSpecializedAppInfo = (AppView<U>) this; |
| return appViewWithSpecializedAppInfo; |
| } |
| |
| public boolean isAllCodeProcessed() { |
| return allCodeProcessed; |
| } |
| |
| public void setAllCodeProcessed() { |
| allCodeProcessed = true; |
| } |
| |
| public void clearCodeRewritings(ExecutorService executorService, Timing timing) |
| throws ExecutionException { |
| timing.begin("Clear code rewritings"); |
| setGraphLens(new ClearCodeRewritingGraphLens(withClassHierarchy())); |
| |
| MemberRebindingIdentityLens memberRebindingIdentityLens = |
| MemberRebindingIdentityLensFactory.create(withClassHierarchy(), executorService); |
| setGraphLens(memberRebindingIdentityLens); |
| timing.end(); |
| } |
| |
| public void flattenGraphLenses() { |
| GraphLens graphLens = graphLens(); |
| setGraphLens(GraphLens.getIdentityLens()); |
| setGraphLens(new AppliedGraphLens(withClassHierarchy(), graphLens)); |
| } |
| |
| public AppServices appServices() { |
| return appServices; |
| } |
| |
| public void setAppServices(AppServices appServices) { |
| this.appServices = appServices; |
| } |
| |
| public ArtProfileCollection getArtProfileCollection() { |
| return artProfileCollection; |
| } |
| |
| public void setArtProfileCollection(ArtProfileCollection artProfileCollection) { |
| this.artProfileCollection = artProfileCollection; |
| } |
| |
| public StartupProfile getStartupProfile() { |
| return startupProfile; |
| } |
| |
| public void setStartupProfile(StartupProfile startupProfile) { |
| this.startupProfile = startupProfile; |
| } |
| |
| public AssumeInfoCollection getAssumeInfoCollection() { |
| return assumeInfoCollection; |
| } |
| |
| public void setAssumeInfoCollection(AssumeInfoCollection assumeInfoCollection) { |
| this.assumeInfoCollection = assumeInfoCollection; |
| } |
| |
| public DontWarnConfiguration getDontWarnConfiguration() { |
| return dontWarnConfiguration; |
| } |
| |
| public boolean isClassEscapingIntoLibrary(DexType type) { |
| assert type.isClassType(); |
| return classesEscapingIntoLibrary.test(type); |
| } |
| |
| public void setClassesEscapingIntoLibrary(Predicate<DexType> classesEscapingIntoLibrary) { |
| this.classesEscapingIntoLibrary = classesEscapingIntoLibrary; |
| } |
| |
| public void setSourceDebugExtensionForType(DexClass clazz, DexValueString sourceDebugExtension) { |
| sourceDebugExtensions.put(clazz.type, sourceDebugExtension); |
| } |
| |
| public DexValueString getSourceDebugExtensionForType(DexClass clazz) { |
| return sourceDebugExtensions.get(clazz.type); |
| } |
| |
| @Override |
| public ClassResolutionResult contextIndependentDefinitionForWithResolutionResult(DexType type) { |
| return appInfo().contextIndependentDefinitionForWithResolutionResult(type); |
| } |
| |
| @Override |
| public final DexClass definitionFor(DexType type) { |
| return appInfo().definitionFor(type); |
| } |
| |
| public OptionalBool isInterface(DexType type) { |
| assert type.isClassType(); |
| // Without whole program information we should not assume anything about any other class than |
| // the current holder in a given context. |
| if (enableWholeProgramOptimizations()) { |
| DexClass clazz = definitionFor(type); |
| if (clazz == null) { |
| return OptionalBool.unknown(); |
| } |
| return OptionalBool.of(clazz.isInterface()); |
| } |
| return OptionalBool.unknown(); |
| } |
| |
| @Override |
| public DexItemFactory dexItemFactory() { |
| return appInfo.dexItemFactory(); |
| } |
| |
| public ComposeReferences getComposeReferences() { |
| assert options().getJetpackComposeOptions().isAnyOptimizationsEnabled(); |
| if (composeReferences == null) { |
| composeReferences = new ComposeReferences(dexItemFactory()); |
| } |
| return composeReferences; |
| } |
| |
| public boolean enableWholeProgramOptimizations() { |
| return wholeProgramOptimizations == WholeProgramOptimizations.ON; |
| } |
| |
| public WholeProgramOptimizations getWholeProgramOptimizations() { |
| return wholeProgramOptimizations; |
| } |
| |
| /** |
| * Create a new processor context. |
| * |
| * <p>The order of processor contexts for a compilation must be deterministic so this is required |
| * to be called on the main thread only. |
| */ |
| public ProcessorContext createProcessorContext() { |
| assert verifyMainThread(); |
| return context.createProcessorContext(); |
| } |
| |
| public SyntheticItems getSyntheticItems() { |
| return appInfo.getSyntheticItems(); |
| } |
| |
| public <E extends Throwable> void withArgumentPropagator( |
| ThrowingConsumer<ArgumentPropagator, E> consumer) throws E { |
| if (argumentPropagator != null) { |
| consumer.accept(argumentPropagator); |
| } |
| } |
| |
| public LibraryMemberOptimizer libraryMethodOptimizer() { |
| return libraryMemberOptimizer; |
| } |
| |
| public LibraryMethodSideEffectModelCollection getLibraryMethodSideEffectModelCollection() { |
| return libraryMethodSideEffectModelCollection; |
| } |
| |
| public ProtoShrinker protoShrinker() { |
| return protoShrinker; |
| } |
| |
| public <E extends Throwable> void withProtoShrinker(ThrowingConsumer<ProtoShrinker, E> consumer) |
| throws E { |
| if (protoShrinker != null) { |
| consumer.accept(protoShrinker); |
| } |
| } |
| |
| public <U> U withProtoShrinker(Function<ProtoShrinker, U> consumer, U defaultValue) { |
| if (protoShrinker != null) { |
| return consumer.apply(protoShrinker); |
| } |
| return defaultValue; |
| } |
| |
| public <U> U withProtoEnumShrinker(Function<EnumLiteProtoShrinker, U> fn, U defaultValue) { |
| if (protoShrinker != null && options().protoShrinking().isEnumLiteProtoShrinkingEnabled()) { |
| return fn.apply(protoShrinker.enumLiteProtoShrinker); |
| } |
| return defaultValue; |
| } |
| |
| public <E extends Throwable> void withGeneratedExtensionRegistryShrinker( |
| ThrowingConsumer<GeneratedExtensionRegistryShrinker, E> consumer) throws E { |
| if (protoShrinker != null && protoShrinker.generatedExtensionRegistryShrinker != null) { |
| consumer.accept(protoShrinker.generatedExtensionRegistryShrinker); |
| } |
| } |
| |
| public <U> U withGeneratedExtensionRegistryShrinker( |
| Function<GeneratedExtensionRegistryShrinker, U> fn, U defaultValue) { |
| if (protoShrinker != null && protoShrinker.generatedExtensionRegistryShrinker != null) { |
| return fn.apply(protoShrinker.generatedExtensionRegistryShrinker); |
| } |
| return defaultValue; |
| } |
| |
| public <E extends Throwable> void withGeneratedMessageLiteShrinker( |
| ThrowingConsumer<GeneratedMessageLiteShrinker, E> consumer) throws E { |
| if (protoShrinker != null && protoShrinker.generatedMessageLiteShrinker != null) { |
| consumer.accept(protoShrinker.generatedMessageLiteShrinker); |
| } |
| } |
| |
| public <E extends Throwable> void withGeneratedMessageLiteBuilderShrinker( |
| ThrowingConsumer<GeneratedMessageLiteBuilderShrinker, E> consumer) throws E { |
| if (protoShrinker != null && protoShrinker.generatedMessageLiteBuilderShrinker != null) { |
| consumer.accept(protoShrinker.generatedMessageLiteBuilderShrinker); |
| } |
| } |
| |
| public <U> U withGeneratedMessageLiteShrinker( |
| Function<GeneratedMessageLiteShrinker, U> fn, U defaultValue) { |
| if (protoShrinker != null && protoShrinker.generatedMessageLiteShrinker != null) { |
| return fn.apply(protoShrinker.generatedMessageLiteShrinker); |
| } |
| return defaultValue; |
| } |
| |
| public <U> U withGeneratedMessageLiteBuilderShrinker( |
| Function<GeneratedMessageLiteBuilderShrinker, U> fn, U defaultValue) { |
| if (protoShrinker != null && protoShrinker.generatedMessageLiteBuilderShrinker != null) { |
| return fn.apply(protoShrinker.generatedMessageLiteBuilderShrinker); |
| } |
| return defaultValue; |
| } |
| |
| public GraphLens codeLens() { |
| return codeLens; |
| } |
| |
| public void setCodeLens(GraphLens codeLens) { |
| this.codeLens = codeLens; |
| } |
| |
| public GraphLens graphLens() { |
| return graphLens; |
| } |
| |
| /** @return true if the graph lens changed, otherwise false. */ |
| public boolean setGraphLens(GraphLens graphLens) { |
| if (graphLens != this.graphLens) { |
| this.graphLens = graphLens; |
| |
| // TODO(b/202368283): Currently, we always set an applied lens or a clear code rewriting lens |
| // when the graph lens has been fully applied to all code. Therefore, we implicitly update |
| // the code lens when these lenses are set. Now that we have an explicit code lens, the clear |
| // code rewriting lens is redundant and could be removed. |
| if (graphLens.isAppliedLens() || graphLens.isClearCodeRewritingLens()) { |
| setCodeLens(graphLens); |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| public GraphLens getGenericSignaturesLens() { |
| return genericSignaturesLens; |
| } |
| |
| public void setGenericSignaturesLens(GraphLens genericSignaturesLens) { |
| this.genericSignaturesLens = genericSignaturesLens; |
| } |
| |
| private boolean disallowFurtherInitClassUses = false; |
| |
| public void dissallowFurtherInitClassUses() { |
| disallowFurtherInitClassUses = true; |
| } |
| |
| public boolean canUseInitClass() { |
| return !disallowFurtherInitClassUses && options().isShrinking(); |
| } |
| |
| public InitClassLens initClassLens() { |
| return initClassLens; |
| } |
| |
| public boolean hasInitClassLens() { |
| return initClassLens != null; |
| } |
| |
| public void setInitClassLens(InitClassLens initClassLens) { |
| this.initClassLens = initClassLens; |
| } |
| |
| public GraphLens getKotlinMetadataLens() { |
| return kotlinMetadataLens; |
| } |
| |
| public void setKotlinMetadataLens(GraphLens kotlinMetadataLens) { |
| this.kotlinMetadataLens = kotlinMetadataLens; |
| } |
| |
| public boolean hasInitializedClassesInInstanceMethods() { |
| return initializedClassesInInstanceMethods != null; |
| } |
| |
| public InitializedClassesInInstanceMethods getInitializedClassesInInstanceMethods() { |
| return initializedClassesInInstanceMethods; |
| } |
| |
| public void setInitializedClassesInInstanceMethods( |
| InitializedClassesInInstanceMethods initializedClassesInInstanceMethods) { |
| this.initializedClassesInInstanceMethods = initializedClassesInInstanceMethods; |
| } |
| |
| public void setCfByteCodePassThrough(Set<DexMethod> cfByteCodePassThrough) { |
| assert options().enableCfByteCodePassThrough; |
| this.cfByteCodePassThrough = cfByteCodePassThrough; |
| } |
| |
| public <U> U withInitializedClassesInInstanceMethods( |
| Function<InitializedClassesInInstanceMethods, U> fn, U defaultValue) { |
| if (initializedClassesInInstanceMethods != null) { |
| return fn.apply(initializedClassesInInstanceMethods); |
| } |
| return defaultValue; |
| } |
| |
| public InternalOptions options() { |
| return appInfo.options(); |
| } |
| |
| public Reporter reporter() { |
| return options().reporter; |
| } |
| |
| public TestingOptions testing() { |
| return options().testing; |
| } |
| |
| public boolean hasRootSet() { |
| return rootSet != null; |
| } |
| |
| public RootSet rootSet() { |
| return rootSet; |
| } |
| |
| public void setRootSet(RootSet rootSet) { |
| this.rootSet = rootSet; |
| } |
| |
| public void setMainDexRootSet(MainDexRootSet mainDexRootSet) { |
| assert mainDexRootSet != null : "Root set should never be recomputed"; |
| this.mainDexRootSet = mainDexRootSet; |
| } |
| |
| public boolean hasMainDexRootSet() { |
| return mainDexRootSet != null; |
| } |
| |
| public MainDexRootSet getMainDexRootSet() { |
| return mainDexRootSet; |
| } |
| |
| public boolean hasKeepInfo() { |
| return keepInfo != null; |
| } |
| |
| public KeepInfoCollection getKeepInfo() { |
| assert hasKeepInfo(); |
| return keepInfo; |
| } |
| |
| public KeepInfo<?, ?> getKeepInfo(ProgramDefinition definition) { |
| return definition |
| .getReference() |
| .apply( |
| clazz -> getKeepInfo(definition.asProgramClass()), |
| field -> getKeepInfo(definition.asProgramField()), |
| method -> getKeepInfo(definition.asProgramMethod())); |
| } |
| |
| public KeepClassInfo getKeepInfo(DexProgramClass clazz) { |
| return getKeepInfo().getClassInfo(clazz); |
| } |
| |
| public KeepClassInfo getKeepInfoOrDefault(DexProgramClass clazz, KeepClassInfo defaultValue) { |
| return hasKeepInfo() ? getKeepInfo().getClassInfo(clazz) : defaultValue; |
| } |
| |
| public KeepFieldInfo getKeepInfo(ProgramField field) { |
| return getKeepInfo().getFieldInfo(field); |
| } |
| |
| public KeepMemberInfo<?, ?> getKeepInfo(ProgramMember<?, ?> member) { |
| return member.isField() |
| ? getKeepInfo(member.asProgramField()) |
| : getKeepInfo(member.asProgramMethod()); |
| } |
| |
| public KeepMethodInfo getKeepInfo(ProgramMethod method) { |
| return getKeepInfo().getMethodInfo(method); |
| } |
| |
| public NamingLens getNamingLens() { |
| return namingLens; |
| } |
| |
| public void setNamingLens(NamingLens namingLens) { |
| this.namingLens = namingLens; |
| } |
| |
| public boolean hasProguardCompatibilityActions() { |
| return proguardCompatibilityActions != null; |
| } |
| |
| public ProguardCompatibilityActions getProguardCompatibilityActions() { |
| return proguardCompatibilityActions; |
| } |
| |
| public void setProguardCompatibilityActions( |
| ProguardCompatibilityActions proguardCompatibilityActions) { |
| assert options().forceProguardCompatibility; |
| this.proguardCompatibilityActions = proguardCompatibilityActions; |
| } |
| |
| public MergedClassesCollection allMergedClasses() { |
| MergedClassesCollection collection = new MergedClassesCollection(); |
| if (hasHorizontallyMergedClasses()) { |
| collection.add(horizontallyMergedClasses); |
| } |
| if (verticallyMergedClasses != null) { |
| collection.add(verticallyMergedClasses); |
| } |
| return collection; |
| } |
| |
| public boolean hasHorizontallyMergedClasses() { |
| return !horizontallyMergedClasses.isEmpty(); |
| } |
| |
| /** |
| * Get the result of horizontal class merging. Returns null if horizontal class merging has not |
| * been run. |
| */ |
| public HorizontallyMergedClasses horizontallyMergedClasses() { |
| return horizontallyMergedClasses; |
| } |
| |
| public void setHorizontallyMergedClasses(HorizontallyMergedClasses horizontallyMergedClasses) { |
| assert !hasHorizontallyMergedClasses(); |
| this.horizontallyMergedClasses = horizontallyMergedClasses; |
| testing().horizontallyMergedClassesConsumer.accept(this, horizontallyMergedClasses); |
| } |
| |
| public boolean hasVerticallyMergedClasses() { |
| return verticallyMergedClasses != null; |
| } |
| |
| /** |
| * Get the result of vertical class merging. Returns null if vertical class merging has not been |
| * run. |
| */ |
| public VerticallyMergedClasses getVerticallyMergedClasses() { |
| return verticallyMergedClasses; |
| } |
| |
| public void setVerticallyMergedClasses( |
| VerticallyMergedClasses verticallyMergedClasses, ClassMergerMode mode) { |
| if (mode.isInitial()) { |
| assert this.verticallyMergedClasses == null; |
| this.verticallyMergedClasses = verticallyMergedClasses; |
| testing().verticallyMergedClassesConsumer.accept(dexItemFactory(), verticallyMergedClasses); |
| } else { |
| assert this.verticallyMergedClasses != null; |
| } |
| } |
| |
| public OpenClosedInterfacesCollection getOpenClosedInterfacesCollection() { |
| return openClosedInterfacesCollection; |
| } |
| |
| public void setOpenClosedInterfacesCollection( |
| OpenClosedInterfacesCollection openClosedInterfacesCollection) { |
| this.openClosedInterfacesCollection = openClosedInterfacesCollection; |
| } |
| |
| public boolean hasUnboxedEnums() { |
| return unboxedEnums != null; |
| } |
| |
| public EnumDataMap unboxedEnums() { |
| return hasUnboxedEnums() ? unboxedEnums : EnumDataMap.empty(); |
| } |
| |
| public void setUnboxedEnums(EnumDataMap unboxedEnums) { |
| assert !hasUnboxedEnums(); |
| this.unboxedEnums = unboxedEnums; |
| testing().unboxedEnumsConsumer.accept(dexItemFactory(), unboxedEnums); |
| } |
| |
| public R8ResourceShrinkerState getResourceShrinkerState() { |
| return resourceShrinkerState; |
| } |
| |
| public boolean validateUnboxedEnumsHaveBeenPruned() { |
| for (DexType unboxedEnum : unboxedEnums.computeAllUnboxedEnums()) { |
| assert appInfo.definitionForWithoutExistenceAssert(unboxedEnum) == null |
| : "Enum " + unboxedEnum + " has been unboxed but is still in the program."; |
| assert appInfo().withLiveness().wasPruned(unboxedEnum) |
| : "Enum " + unboxedEnum + " has been unboxed but was not pruned."; |
| } |
| return true; |
| } |
| |
| public boolean hasClassHierarchy() { |
| return appInfo().hasClassHierarchy(); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public AppView<AppInfoWithClassHierarchy> withClassHierarchy() { |
| return appInfo.hasClassHierarchy() |
| ? (AppView<AppInfoWithClassHierarchy>) this |
| : null; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public AppView<AppInfo> withoutClassHierarchy() { |
| assert !hasClassHierarchy(); |
| return (AppView<AppInfo>) this; |
| } |
| |
| public boolean hasLiveness() { |
| return appInfo().hasLiveness(); |
| } |
| |
| public AppView<AppInfoWithLiveness> withLiveness() { |
| @SuppressWarnings("unchecked") |
| AppView<AppInfoWithLiveness> appViewWithLiveness = (AppView<AppInfoWithLiveness>) this; |
| return appViewWithLiveness; |
| } |
| |
| @SuppressWarnings("ReferenceEquality") |
| public OptionalBool isSubtype(DexType subtype, DexType supertype) { |
| // Even if we can compute isSubtype by having class hierarchy we may not be allowed to ask the |
| // question for all code paths in D8. Having the check for liveness ensure that we are in R8 |
| // territory. |
| if (hasClassHierarchy()) { |
| return OptionalBool.of(appInfo().withClassHierarchy().isSubtype(subtype, supertype)); |
| } |
| if (subtype == supertype || supertype == dexItemFactory().objectType) { |
| return OptionalBool.TRUE; |
| } |
| return OptionalBool.unknown(); |
| } |
| |
| public boolean isCfByteCodePassThrough(DexEncodedMethod method) { |
| if (!options().enableCfByteCodePassThrough) { |
| return false; |
| } |
| assert options().isGeneratingClassFiles(); |
| if (cfByteCodePassThrough.contains(method.getReference())) { |
| return true; |
| } |
| return options().testing.cfByteCodePassThrough != null |
| && options().testing.cfByteCodePassThrough.test(method.getReference()); |
| } |
| |
| public boolean hasCfByteCodePassThroughMethods() { |
| return !cfByteCodePassThrough.isEmpty(); |
| } |
| |
| public void pruneItems(PrunedItems prunedItems, ExecutorService executorService, Timing timing) |
| throws ExecutionException { |
| if (prunedItems.isEmpty()) { |
| assert appInfo().app() == prunedItems.getPrunedApp(); |
| return; |
| } |
| timing.begin("Prune AppView"); |
| if (appInfo.hasLiveness()) { |
| AppView<AppInfoWithLiveness> self = withLiveness(); |
| self.setAppInfo(self.appInfo().prunedCopyFrom(prunedItems, executorService, timing)); |
| } else if (appInfo.hasClassHierarchy()) { |
| AppView<AppInfoWithClassHierarchy> self = withClassHierarchy(); |
| self.setAppInfo(self.appInfo().prunedCopyFrom(prunedItems, executorService, timing)); |
| } else { |
| pruneAppInfo(prunedItems, this, executorService, timing); |
| } |
| if (appServices() != null) { |
| setAppServices(appServices().prunedCopy(prunedItems, timing)); |
| } |
| setArtProfileCollection(getArtProfileCollection().withoutPrunedItems(prunedItems, timing)); |
| setAssumeInfoCollection(getAssumeInfoCollection().withoutPrunedItems(prunedItems, timing)); |
| if (hasProguardCompatibilityActions()) { |
| setProguardCompatibilityActions( |
| getProguardCompatibilityActions().withoutPrunedItems(prunedItems, timing)); |
| } |
| if (hasRootSet()) { |
| rootSet.pruneItems(prunedItems, timing); |
| } |
| setStartupProfile( |
| getStartupProfile().withoutPrunedItems(prunedItems, getSyntheticItems(), timing)); |
| if (hasMainDexRootSet()) { |
| setMainDexRootSet(mainDexRootSet.withoutPrunedItems(prunedItems, timing)); |
| } |
| setOpenClosedInterfacesCollection( |
| openClosedInterfacesCollection.withoutPrunedItems(prunedItems, timing)); |
| timing.end(); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private static void pruneAppInfo( |
| PrunedItems prunedItems, AppView<?> appView, ExecutorService executorService, Timing timing) |
| throws ExecutionException { |
| ((AppView<AppInfo>) appView) |
| .setAppInfo(appView.appInfo().prunedCopyFrom(prunedItems, executorService, timing)); |
| } |
| |
| public void rewriteWithLens( |
| NonIdentityGraphLens lens, ExecutorService executorService, Timing timing) |
| throws ExecutionException { |
| rewriteWithLensAndApplication(lens, app().asDirect(), executorService, timing); |
| } |
| |
| public void rewriteWithLensAndApplication( |
| NonIdentityGraphLens lens, |
| DirectMappedDexApplication application, |
| ExecutorService executorService, |
| Timing timing) |
| throws ExecutionException { |
| rewriteWithLensAndApplication( |
| lens, application, executorService, timing, withClassHierarchy(), lens.getPrevious()); |
| assert verifyMovedMethodsHaveOriginalMethodPosition(); |
| } |
| |
| private static void rewriteWithLensAndApplication( |
| NonIdentityGraphLens lens, |
| DirectMappedDexApplication application, |
| ExecutorService executorService, |
| Timing timing, |
| AppView<? extends AppInfoWithClassHierarchy> appView, |
| GraphLens appliedLens) |
| throws ExecutionException { |
| assert lens != null; |
| assert application != null; |
| |
| timing.begin("Rewrite AppView"); |
| |
| boolean changed = appView.setGraphLens(lens); |
| |
| // Verify that the lens changed, except in the horizontal class merger case, where we install |
| // the lens prior to lens rewriting AppView. |
| assert changed || lens.isHorizontalClassMergerGraphLens(); |
| assert application.verifyWithLens(appView.appInfo().app().asDirect(), lens); |
| |
| // The application has already been rewritten with the given applied lens. Therefore, we |
| // temporarily replace that lens with a lens that does not have any rewritings to avoid the |
| // overhead of traversing the entire lens chain upon each lookup during the rewriting. |
| NonIdentityGraphLens firstUnappliedLens = computeFirstUnappliedLens(appView, lens, appliedLens); |
| |
| // Insert a member rebinding lens above the first unapplied lens. |
| // TODO(b/182129249): Once the member rebinding phase has been removed, the MemberRebindingLens |
| // should be removed and all uses of FieldRebindingIdentityLens should be replaced by |
| // MemberRebindingIdentityLens. |
| GraphLens newMemberRebindingLens = |
| computeNewMemberRebindingLens(appView, appliedLens, firstUnappliedLens, timing); |
| firstUnappliedLens.withAlternativeParentLens( |
| newMemberRebindingLens, |
| () -> { |
| GraphLens appliedLensInModifiedLens = GraphLens.getIdentityLens(); |
| ThreadTaskUtils.processTasks( |
| executorService, |
| appView.options(), |
| timing |
| .beginMerger("Rewrite AppView concurrently", executorService) |
| .disableSlowestReporting(), |
| new ThreadTask() { |
| |
| private AppInfoWithClassHierarchy result; |
| |
| @Override |
| public void run(Timing timing) { |
| if (appView.hasLiveness()) { |
| result = |
| appView |
| .appInfoWithLiveness() |
| .rewrittenWithLens( |
| application, lens, appliedLensInModifiedLens, timing); |
| } else { |
| assert appView.hasClassHierarchy(); |
| AppView<AppInfoWithClassHierarchy> appViewWithClassHierarchy = |
| appView.withClassHierarchy(); |
| AppInfoWithClassHierarchy appInfo = appViewWithClassHierarchy.appInfo(); |
| MainDexInfo rewrittenMainDexInfo = |
| appInfo |
| .getMainDexInfo() |
| .rewrittenWithLens(appView.getSyntheticItems(), lens, timing); |
| result = appInfo.rebuildWithMainDexInfo(rewrittenMainDexInfo); |
| } |
| } |
| |
| @Override |
| public void onJoin() { |
| appView.withClassHierarchy().setAppInfo(result); |
| } |
| }, |
| new ThreadTask() { |
| @Override |
| public void run(Timing threadTiming) { |
| appView.setAppServices( |
| appView.appServices().rewrittenWithLens(lens, threadTiming)); |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| return !appView.appServices().isEmpty(); |
| } |
| }, |
| new ThreadTask() { |
| @Override |
| public void run(Timing threadTiming) { |
| appView.setArtProfileCollection( |
| appView |
| .getArtProfileCollection() |
| .rewrittenWithLens(appView, lens, threadTiming)); |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| return !appView.getArtProfileCollection().isEmpty(); |
| } |
| }, |
| new ThreadTask() { |
| @Override |
| public void run(Timing threadTiming) { |
| appView.setAssumeInfoCollection( |
| appView |
| .getAssumeInfoCollection() |
| .rewrittenWithLens( |
| appView, lens, appliedLensInModifiedLens, threadTiming)); |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| return !appView.getAssumeInfoCollection().isEmpty(); |
| } |
| }, |
| new ThreadTask() { |
| @Override |
| public void run(Timing threadTiming) { |
| appView.setInitClassLens( |
| appView.initClassLens().rewrittenWithLens(lens, threadTiming)); |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| return appView.hasInitClassLens(); |
| } |
| }, |
| new ThreadTask() { |
| @Override |
| public void run(Timing threadTiming) { |
| appView.setProguardCompatibilityActions( |
| appView |
| .getProguardCompatibilityActions() |
| .rewrittenWithLens(lens, threadTiming)); |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| return appView.hasProguardCompatibilityActions() |
| && !appView.getProguardCompatibilityActions().isEmpty(); |
| } |
| }, |
| new ThreadTask() { |
| @Override |
| public void run(Timing threadTiming) { |
| appView.setMainDexRootSet( |
| appView.getMainDexRootSet().rewrittenWithLens(lens, threadTiming)); |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| return appView.hasMainDexRootSet(); |
| } |
| }, |
| new ThreadTask() { |
| @Override |
| public void run(Timing threadTiming) { |
| appView.setOpenClosedInterfacesCollection( |
| appView |
| .getOpenClosedInterfacesCollection() |
| .rewrittenWithLens(lens, threadTiming)); |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| return !appView.getOpenClosedInterfacesCollection().isEmpty(); |
| } |
| }, |
| new ThreadTask() { |
| @Override |
| public void run(Timing threadTiming) { |
| appView.setRootSet(appView.rootSet().rewrittenWithLens(lens, threadTiming)); |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| return appView.hasRootSet(); |
| } |
| }, |
| new ThreadTask() { |
| @Override |
| public void run(Timing threadTiming) { |
| appView.setStartupProfile( |
| appView.getStartupProfile().rewrittenWithLens(lens, threadTiming)); |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| return !appView.getStartupProfile().isEmpty(); |
| } |
| }, |
| new ThreadTask() { |
| @Override |
| public void run(Timing timing) { |
| ImmutableSet.Builder<DexMethod> cfByteCodePassThroughBuilder = |
| ImmutableSet.builder(); |
| for (DexMethod method : appView.cfByteCodePassThrough) { |
| cfByteCodePassThroughBuilder.add( |
| lens.getRenamedMethodSignature(method, appliedLensInModifiedLens)); |
| } |
| appView.cfByteCodePassThrough = cfByteCodePassThroughBuilder.build(); |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| return !appView.cfByteCodePassThrough.isEmpty(); |
| } |
| }, |
| new ThreadTask() { |
| @Override |
| public void run(Timing timing) { |
| appView.setInitializedClassesInInstanceMethods( |
| appView |
| .getInitializedClassesInInstanceMethods() |
| .rewrittenWithLens(lens, appliedLens)); |
| } |
| |
| @Override |
| public boolean shouldRun() { |
| return appView.hasInitializedClassesInInstanceMethods(); |
| } |
| }); |
| }); |
| |
| timing.end(); // Rewrite AppView |
| } |
| |
| private static NonIdentityGraphLens computeFirstUnappliedLens( |
| AppView<? extends AppInfoWithClassHierarchy> appView, |
| NonIdentityGraphLens lens, |
| GraphLens appliedLens) { |
| NonIdentityGraphLens firstUnappliedLens = lens; |
| while (firstUnappliedLens.getPrevious() != appliedLens) { |
| GraphLens previousLens = firstUnappliedLens.getPrevious(); |
| assert previousLens.isNonIdentityLens(); |
| assert previousLens != appView.codeLens(); |
| firstUnappliedLens = previousLens.asNonIdentityLens(); |
| } |
| return firstUnappliedLens; |
| } |
| |
| private static GraphLens computeNewMemberRebindingLens( |
| AppView<? extends AppInfoWithClassHierarchy> appView, |
| GraphLens appliedLens, |
| NonIdentityGraphLens firstUnappliedLens, |
| Timing timing) { |
| timing.begin("Compute new member rebinding lens"); |
| GraphLens newMemberRebindingLens = GraphLens.getIdentityLens(); |
| if (!firstUnappliedLens.isMemberRebindingLens() |
| && !firstUnappliedLens.isMemberRebindingIdentityLens()) { |
| NonIdentityGraphLens appliedMemberRebindingLens = |
| firstUnappliedLens.findPrevious(GraphLens::isMemberRebindingIdentityLens); |
| if (appliedMemberRebindingLens != null) { |
| newMemberRebindingLens = |
| appliedMemberRebindingLens |
| .asMemberRebindingIdentityLens() |
| .toRewrittenMemberRebindingIdentityLens( |
| appView, appliedLens, appliedMemberRebindingLens); |
| } |
| } |
| timing.end(); |
| return newMemberRebindingLens; |
| } |
| |
| public void rewriteWithD8Lens(NonIdentityGraphLens lens, Timing timing) { |
| rewriteWithD8Lens(lens, timing, withoutClassHierarchy()); |
| } |
| |
| private static void rewriteWithD8Lens( |
| NonIdentityGraphLens lens, Timing timing, AppView<AppInfo> appView) { |
| boolean changed = appView.setGraphLens(lens); |
| |
| // Verify that the lens changed, except in the horizontal class merger case, where we install |
| // the lens prior to lens rewriting AppView. |
| assert changed || lens.isHorizontalClassMergerGraphLens(); |
| |
| appView.setArtProfileCollection( |
| appView.getArtProfileCollection().rewrittenWithLens(appView, lens, timing)); |
| } |
| |
| public void setAlreadyLibraryDesugared(Set<DexType> alreadyLibraryDesugared) { |
| assert this.alreadyLibraryDesugared == null; |
| this.alreadyLibraryDesugared = alreadyLibraryDesugared; |
| } |
| |
| /** |
| * Called when an optimization that changes the app has finished. This allows easier diagnosing |
| * some failures, e.g., finding which optimization pass that adds/removes a given method. |
| */ |
| public void notifyOptimizationFinishedForTesting() { |
| // Intentionally empty. |
| } |
| |
| public boolean isAlreadyLibraryDesugared(DexProgramClass clazz) { |
| if (!options().desugarSpecificOptions().allowAllDesugaredInput) { |
| return false; |
| } |
| assert alreadyLibraryDesugared != null; |
| return alreadyLibraryDesugared.contains(clazz.getType()); |
| } |
| |
| public void loadApplyMappingSeedMapper() throws IOException { |
| if (options().getProguardConfiguration().hasApplyMappingFile()) { |
| applyMappingSeedMapper = |
| SeedMapper.seedMapperFromFile( |
| options().reporter, options().getProguardConfiguration().getApplyMappingFile()); |
| } |
| } |
| |
| public SeedMapper getApplyMappingSeedMapper() { |
| return applyMappingSeedMapper; |
| } |
| |
| public void clearApplyMappingSeedMapper() { |
| applyMappingSeedMapper = null; |
| } |
| |
| public boolean checkForTesting(Supplier<Boolean> test) { |
| return testing().enableTestAssertions ? test.get() : true; |
| } |
| |
| public AndroidApiLevelCompute apiLevelCompute() { |
| return apiLevelCompute; |
| } |
| |
| public ComputedApiLevel computedMinApiLevel() { |
| return computedMinApiLevel; |
| } |
| |
| public void addPrunedClassSourceFile(DexType prunedType, String sourceFile) { |
| sourceFileForPrunedTypes.put(prunedType, sourceFile); |
| } |
| |
| public String getPrunedClassSourceFileInfo(DexType dexType) { |
| return sourceFileForPrunedTypes.get(dexType); |
| } |
| |
| public boolean verifyMovedMethodsHaveOriginalMethodPosition() { |
| DirectMappedDexApplication application = app().asDirect(); |
| application |
| .classesWithDeterministicOrder() |
| .forEach( |
| clazz -> |
| clazz.forEachProgramMethod( |
| method -> { |
| assert verifyOriginalMethodInPosition(method); |
| })); |
| return true; |
| } |
| |
| private static boolean verifyOriginalMethodInPosition(ProgramMethod context) { |
| Code code = context.getDefinition().getCode(); |
| if (code == null) { |
| return true; |
| } |
| DexMethod thisMethod = context.getReference(); |
| code.forEachPosition( |
| context.getReference(), |
| context.getDefinition().isD8R8Synthesized(), |
| position -> { |
| DexMethod outerCaller = position.getOutermostCaller().getMethod(); |
| assert thisMethod.isIdenticalTo(outerCaller); |
| }); |
| return true; |
| } |
| } |
