| // Copyright (c) 2017, 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.optimize; | |
| import static com.android.tools.r8.utils.internal.MapUtils.ignoreKey; | |
| import com.android.tools.r8.graph.AccessControl; | |
| import com.android.tools.r8.graph.AppView; | |
| import com.android.tools.r8.graph.DefaultUseRegistry; | |
| import com.android.tools.r8.graph.DexClass; | |
| import com.android.tools.r8.graph.DexClassAndMethod; | |
| import com.android.tools.r8.graph.DexEncodedMethod; | |
| import com.android.tools.r8.graph.DexMethod; | |
| import com.android.tools.r8.graph.DexProgramClass; | |
| import com.android.tools.r8.graph.DexType; | |
| import com.android.tools.r8.graph.MethodResolutionResult.SingleResolutionResult; | |
| import com.android.tools.r8.graph.ProgramMethod; | |
| import com.android.tools.r8.ir.code.InvokeType; | |
| import com.android.tools.r8.shaking.AppInfoWithLiveness; | |
| import com.android.tools.r8.utils.ThreadUtils; | |
| import com.android.tools.r8.utils.collections.ProgramMethodSet; | |
| import com.android.tools.r8.utils.internal.OptionalBool; | |
| import com.android.tools.r8.utils.internal.TriConsumer; | |
| import com.android.tools.r8.utils.internal.collections.Pair; | |
| import java.util.ArrayList; | |
| import java.util.Comparator; | |
| import java.util.IdentityHashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.concurrent.ConcurrentHashMap; | |
| import java.util.concurrent.ExecutionException; | |
| import java.util.concurrent.ExecutorService; | |
| public class MemberRebindingAnalysis extends MemberRebindingHelper { | |
| private final MemberRebindingEventConsumer eventConsumer; | |
| private final MemberRebindingLens.Builder lensBuilder; | |
| public MemberRebindingAnalysis(AppView<AppInfoWithLiveness> appView) { | |
| super(appView); | |
| assert appView.graphLens().isContextFreeForMethods(appView.codeLens()); | |
| this.eventConsumer = MemberRebindingEventConsumer.create(appView); | |
| this.lensBuilder = MemberRebindingLens.builder(appView); | |
| } | |
| private Map<InvokeType, NonReboundMethodAccessCollection> | |
| computeNonReboundMethodAccessCollections(ExecutorService executorService) | |
| throws ExecutionException { | |
| Map<InvokeType, NonReboundMethodAccessCollection> nonReboundMethodAccessCollections = | |
| new ConcurrentHashMap<>(); | |
| ThreadUtils.processItems( | |
| appView.appInfo().classes(), | |
| clazz -> { | |
| Map<InvokeType, NonReboundMethodAccessCollection> classResult = | |
| computeNonReboundMethodAccessCollections(clazz); | |
| classResult.forEach( | |
| (invokeType, nonReboundMethodAccessCollection) -> | |
| nonReboundMethodAccessCollections | |
| .computeIfAbsent( | |
| invokeType, ignoreKey(NonReboundMethodAccessCollection::createConcurrent)) | |
| .mergeThreadLocalIntoShared(nonReboundMethodAccessCollection)); | |
| }, | |
| options.getThreadingModule(), | |
| executorService); | |
| return nonReboundMethodAccessCollections; | |
| } | |
| private Map<InvokeType, NonReboundMethodAccessCollection> | |
| computeNonReboundMethodAccessCollections(DexProgramClass clazz) { | |
| Map<InvokeType, NonReboundMethodAccessCollection> nonReboundMethodAccessCollections = | |
| new IdentityHashMap<>(); | |
| clazz.forEachProgramMethodMatching( | |
| DexEncodedMethod::hasCode, | |
| method -> | |
| method.registerCodeReferences( | |
| new DefaultUseRegistry<>(appView, method) { | |
| private final AppView<AppInfoWithLiveness> appViewWithLiveness = | |
| MemberRebindingAnalysis.this.appView; | |
| @Override | |
| public void registerInvokeDirect(DexMethod method) { | |
| // Intentionally empty. | |
| } | |
| @Override | |
| public void registerInvokeInterface(DexMethod method) { | |
| registerInvoke( | |
| InvokeType.INTERFACE, | |
| method, | |
| appViewWithLiveness | |
| .appInfo() | |
| .resolveMethodOnInterface(method.getHolderType(), method) | |
| .asSingleResolution()); | |
| } | |
| @Override | |
| public void registerInvokeStatic(DexMethod method) { | |
| registerInvoke( | |
| InvokeType.STATIC, | |
| method, | |
| appViewWithLiveness | |
| .appInfo() | |
| .unsafeResolveMethodDueToDexFormat(method) | |
| .asSingleResolution()); | |
| } | |
| @Override | |
| public void registerInvokeSuper(DexMethod method) { | |
| registerInvoke( | |
| InvokeType.SUPER, | |
| method, | |
| appViewWithLiveness | |
| .appInfo() | |
| .unsafeResolveMethodDueToDexFormat(method) | |
| .asSingleResolution()); | |
| } | |
| @Override | |
| public void registerInvokeVirtual(DexMethod method) { | |
| registerInvoke( | |
| InvokeType.VIRTUAL, | |
| method, | |
| appViewWithLiveness | |
| .appInfo() | |
| .resolveMethodOnClassHolder(method) | |
| .asSingleResolution()); | |
| } | |
| private void registerInvoke( | |
| InvokeType invokeType, | |
| DexMethod method, | |
| SingleResolutionResult<?> resolutionResult) { | |
| if (resolutionResult != null | |
| && resolutionResult | |
| .getResolvedMethod() | |
| .getReference() | |
| .isNotIdenticalTo(method)) { | |
| nonReboundMethodAccessCollections | |
| .computeIfAbsent( | |
| invokeType, ignoreKey(NonReboundMethodAccessCollection::create)) | |
| .add(method, resolutionResult, getContext()); | |
| } | |
| } | |
| })); | |
| return nonReboundMethodAccessCollections; | |
| } | |
| private void computeMethodRebinding( | |
| Map<InvokeType, NonReboundMethodAccessCollection> nonReboundMethodAccessCollections) { | |
| nonReboundMethodAccessCollections.forEach(this::computeMethodRebinding); | |
| } | |
| private void computeMethodRebinding( | |
| InvokeType invokeType, NonReboundMethodAccessCollection nonReboundMethodAccessCollection) { | |
| Map<DexProgramClass, List<Pair<DexMethod, DexClassAndMethod>>> bridges = | |
| new IdentityHashMap<>(); | |
| TriConsumer<DexProgramClass, DexMethod, DexClassAndMethod> addBridge = | |
| (bridgeHolder, method, target) -> | |
| bridges | |
| .computeIfAbsent(bridgeHolder, k -> new ArrayList<>()) | |
| .add(new Pair<>(method, target)); | |
| nonReboundMethodAccessCollection.forEach( | |
| (method, resolutionResult, contexts) -> { | |
| // TODO(b/128404854) Rebind to the lowest library class or program class. For now we allow | |
| // searching in library for methods, but this should be done on classpath instead. | |
| DexClassAndMethod resolvedMethod = resolutionResult.getResolutionPair(); | |
| DexClass initialResolutionHolder = resolutionResult.getInitialResolutionHolder(); | |
| DexMethod bridgeMethod = null; | |
| if (initialResolutionHolder.isProgramClass()) { | |
| // In Java bytecode, it is only possible to target interface methods that are in one of | |
| // the immediate super-interfaces via a super-invocation (see | |
| // IndirectSuperInterfaceTest). | |
| // To avoid introducing an IncompatibleClassChangeError at runtime we therefore insert a | |
| // bridge method when we are about to rebind to an interface method that is not the | |
| // original target. | |
| if (needsBridgeForInterfaceMethod( | |
| initialResolutionHolder, resolvedMethod, invokeType)) { | |
| bridgeMethod = | |
| insertBridgeForInterfaceMethod( | |
| method, resolvedMethod, initialResolutionHolder.asProgramClass(), addBridge); | |
| } else { | |
| // If the target class is not public but the targeted method is, we might run into | |
| // visibility problems when rebinding. | |
| if (contexts.stream() | |
| .anyMatch(context -> mayNeedBridgeForVisibility(context, resolutionResult))) { | |
| bridgeMethod = | |
| insertBridgeForVisibilityIfNeeded( | |
| method, resolvedMethod, initialResolutionHolder, addBridge); | |
| } | |
| } | |
| } | |
| if (bridgeMethod != null) { | |
| lensBuilder.map(method, bridgeMethod, invokeType); | |
| } else if (resolvedMethod.isProgramMethod()) { | |
| lensBuilder.map(method, resolvedMethod.getReference(), invokeType); | |
| } else { | |
| lensBuilder.map( | |
| method, | |
| validMemberRebindingTargetForNonProgramMethod( | |
| resolvedMethod, | |
| resolutionResult.asSingleResolution(), | |
| contexts, | |
| invokeType, | |
| method), | |
| invokeType); | |
| } | |
| }); | |
| bridges.forEach( | |
| (bridgeHolder, targets) -> { | |
| // Sorting the list of bridges within a class maintains a deterministic order of entries | |
| // in the method collection. | |
| targets.sort(Comparator.comparing(Pair::getFirst)); | |
| for (Pair<DexMethod, DexClassAndMethod> pair : targets) { | |
| DexMethod method = pair.getFirst(); | |
| DexClassAndMethod target = pair.getSecond(); | |
| DexMethod bridgeMethodReference = | |
| method.withHolder(bridgeHolder.getType(), appView.dexItemFactory()); | |
| if (bridgeHolder.getMethodCollection().getMethod(bridgeMethodReference) == null) { | |
| DexEncodedMethod targetDefinition = target.getDefinition(); | |
| DexEncodedMethod bridgeMethodDefinition = | |
| targetDefinition.toForwardingMethod( | |
| bridgeHolder, | |
| appView, | |
| builder -> { | |
| if (!targetDefinition.isAbstract() | |
| && targetDefinition.getApiLevelForCode().isNotSetApiLevel()) { | |
| assert !target.isProgramMethod() | |
| || !appView.options().apiModelingOptions().isApiModelingEnabled(); | |
| builder.setApiLevelForCode( | |
| appView | |
| .apiLevelCompute() | |
| .computeApiLevelForLibraryReference( | |
| targetDefinition.getReference(), | |
| appView.computedMinApiLevel())); | |
| } | |
| builder.setIsLibraryMethodOverrideIf( | |
| // Treat classpath override as library override. | |
| target.isLibraryMethod() || target.isClasspathMethod(), | |
| OptionalBool.TRUE); | |
| }); | |
| assert !bridgeMethodDefinition.belongsToVirtualPool() | |
| || !bridgeMethodDefinition.isLibraryMethodOverride().isUnknown(); | |
| bridgeHolder.addMethod(bridgeMethodDefinition); | |
| ProgramMethod bridgeMethod = bridgeMethodDefinition.asProgramMethod(bridgeHolder); | |
| appView.getKeepInfo().registerCompilerSynthesizedMethod(bridgeMethod); | |
| eventConsumer.acceptMemberRebindingBridgeMethod(bridgeMethod, target); | |
| } | |
| assert appView | |
| .appInfo() | |
| .unsafeResolveMethodDueToDexFormat(method) | |
| .getResolvedMethod() | |
| .getReference() | |
| .isIdenticalTo(bridgeMethodReference); | |
| } | |
| }); | |
| } | |
| @SuppressWarnings("ReferenceEquality") | |
| private boolean needsBridgeForInterfaceMethod( | |
| DexClass originalClass, DexClassAndMethod method, InvokeType invokeType) { | |
| return options.isGeneratingClassFiles() | |
| && invokeType == InvokeType.SUPER | |
| && method.getHolder() != originalClass | |
| && method.getHolder().isInterface(); | |
| } | |
| @SuppressWarnings("ReferenceEquality") | |
| private DexMethod insertBridgeForInterfaceMethod( | |
| DexMethod method, | |
| DexClassAndMethod target, | |
| DexProgramClass originalClass, | |
| TriConsumer<DexProgramClass, DexMethod, DexClassAndMethod> bridges) { | |
| // If `targetClass` is a class, then insert the bridge method on the upper-most super class that | |
| // implements the interface. Otherwise, if it is an interface, then insert the bridge method | |
| // directly on the interface (because that interface must be the immediate super type, assuming | |
| // that the super-invocation is not broken in advance). | |
| // | |
| // Note that, to support compiling from DEX to CF, we would need to rewrite the targets of | |
| // invoke-super instructions that hit indirect interface methods such that they always target | |
| // a method in an immediate super-interface, since this works on Art but not on the JVM. | |
| DexProgramClass bridgeHolder = | |
| findHolderForInterfaceMethodBridge(originalClass, target.getHolderType()); | |
| assert bridgeHolder != null; | |
| assert bridgeHolder != target.getHolder(); | |
| bridges.accept(bridgeHolder, method, target); | |
| return target.getReference().withHolder(bridgeHolder.getType(), appView.dexItemFactory()); | |
| } | |
| private DexProgramClass findHolderForInterfaceMethodBridge(DexProgramClass clazz, DexType iface) { | |
| if (clazz.accessFlags.isInterface()) { | |
| return clazz; | |
| } | |
| DexClass superClass = appView.definitionFor(clazz.superType); | |
| if (superClass == null | |
| || superClass.isNotProgramClass() | |
| || !appView.appInfo().isSubtype(superClass.type, iface)) { | |
| return clazz; | |
| } | |
| return findHolderForInterfaceMethodBridge(superClass.asProgramClass(), iface); | |
| } | |
| private boolean mayNeedBridgeForVisibility( | |
| ProgramMethod context, SingleResolutionResult<?> resolutionResult) { | |
| return resolutionResult.isAccessibleFrom(context, appView).isTrue() | |
| && AccessControl.isClassAccessible(resolutionResult.getResolvedHolder(), context, appView) | |
| .isPossiblyFalse(); | |
| } | |
| private DexMethod insertBridgeForVisibilityIfNeeded( | |
| DexMethod method, | |
| DexClassAndMethod target, | |
| DexClass originalClass, | |
| TriConsumer<DexProgramClass, DexMethod, DexClassAndMethod> bridges) { | |
| // If the original class is public and this method is public, it might have been called | |
| // from anywhere, so we need a bridge. Likewise, if the original is in a different | |
| // package, we might need a bridge, too. | |
| String packageDescriptor = | |
| originalClass.accessFlags.isPublic() ? null : method.holder.getPackageDescriptor(); | |
| if (packageDescriptor == null | |
| || !packageDescriptor.equals(target.getHolderType().getPackageDescriptor())) { | |
| DexClass bridgeHolder = | |
| findHolderForVisibilityBridge(originalClass, target.getHolder(), packageDescriptor); | |
| if (bridgeHolder == null) { | |
| // The original class does not have access to the target so we cannot insert a valid bridge. | |
| return target.getReference().withHolder(originalClass, appView.dexItemFactory()); | |
| } | |
| if (bridgeHolder.isClasspathClass()) { | |
| // Intentionally empty. We do not need to insert a bridge on a classpath class. | |
| } else if (bridgeHolder.isLibraryClass()) { | |
| // Caution is needed when member rebinding into the library. | |
| // This is handled by validMemberRebindingTargetForNonProgramMethod. | |
| return null; | |
| } else { | |
| // Insert a bridge on this program class. | |
| bridges.accept(bridgeHolder.asProgramClass(), method, target); | |
| } | |
| return target.getReference().withHolder(bridgeHolder, appView.dexItemFactory()); | |
| } | |
| return target.getReference(); | |
| } | |
| @SuppressWarnings("ReferenceEquality") | |
| private DexClass findHolderForVisibilityBridge( | |
| DexClass currentClass, DexClass resolvedHolder, String initialResolutionPackage) { | |
| if (currentClass == resolvedHolder) { | |
| return null; | |
| } | |
| DexClass newHolder = null; | |
| // Recurse through supertype chain. | |
| if (appView.appInfo().isSubtype(currentClass.superType, resolvedHolder.type)) { | |
| DexClass superClass = appView.definitionFor(currentClass.superType); | |
| newHolder = | |
| findHolderForVisibilityBridge(superClass, resolvedHolder, initialResolutionPackage); | |
| } else { | |
| for (DexType iface : currentClass.interfaces.values) { | |
| if (appView.appInfo().isSubtype(iface, resolvedHolder.type)) { | |
| DexClass interfaceClass = appView.definitionFor(iface); | |
| newHolder = | |
| findHolderForVisibilityBridge( | |
| interfaceClass, resolvedHolder, initialResolutionPackage); | |
| } | |
| } | |
| } | |
| if (newHolder != null) { | |
| // A supertype fulfills the visibility requirements. | |
| return newHolder; | |
| } else { | |
| boolean hasAccessToTarget = | |
| AccessControl.isClassAccessible(resolvedHolder, currentClass, appView).isTrue(); | |
| boolean isVisibleToCallers = | |
| currentClass.isPublic() | |
| || currentClass.type.getPackageDescriptor().equals(initialResolutionPackage); | |
| if (hasAccessToTarget && isVisibleToCallers) { | |
| // This class is visible and can access the target class. | |
| return currentClass; | |
| } | |
| } | |
| return null; | |
| } | |
| public void run(ExecutorService executorService) throws ExecutionException { | |
| Map<InvokeType, NonReboundMethodAccessCollection> nonReboundMethodAccessCollections = | |
| computeNonReboundMethodAccessCollections(executorService); | |
| computeMethodRebinding(nonReboundMethodAccessCollections); | |
| MemberRebindingLens memberRebindingLens = lensBuilder.build(); | |
| appView.setGraphLens(memberRebindingLens); | |
| eventConsumer.finished(appView, memberRebindingLens); | |
| appView.getTypeElementFactory().clearTypeElementsCache(); | |
| appView.notifyOptimizationFinished(); | |
| } | |
| static class NonReboundMethodAccessCollection { | |
| private final Map<DexMethod, NonReboundMethodAccessInfo> nonReboundMethodReferences; | |
| private NonReboundMethodAccessCollection( | |
| Map<DexMethod, NonReboundMethodAccessInfo> nonReboundMethodReferences) { | |
| this.nonReboundMethodReferences = nonReboundMethodReferences; | |
| } | |
| public static NonReboundMethodAccessCollection create() { | |
| return new NonReboundMethodAccessCollection(new IdentityHashMap<>()); | |
| } | |
| public static NonReboundMethodAccessCollection createConcurrent() { | |
| return new NonReboundMethodAccessCollection(new ConcurrentHashMap<>()); | |
| } | |
| public void add( | |
| DexMethod method, SingleResolutionResult<?> resolutionResult, ProgramMethod context) { | |
| nonReboundMethodReferences | |
| .computeIfAbsent( | |
| method, ignoreKey(() -> NonReboundMethodAccessInfo.create(resolutionResult))) | |
| .addContext(context); | |
| } | |
| public void forEach( | |
| TriConsumer<DexMethod, SingleResolutionResult<?>, ProgramMethodSet> consumer) { | |
| nonReboundMethodReferences.forEach( | |
| (reference, info) -> consumer.accept(reference, info.resolutionResult, info.contexts)); | |
| } | |
| public void mergeThreadLocalIntoShared( | |
| NonReboundMethodAccessCollection nonReboundMethodAccessCollection) { | |
| nonReboundMethodAccessCollection.forEach( | |
| (method, resolutionResult, contexts) -> | |
| nonReboundMethodReferences | |
| .computeIfAbsent( | |
| method, | |
| ignoreKey( | |
| () -> NonReboundMethodAccessInfo.createConcurrent(resolutionResult))) | |
| .addContexts(contexts)); | |
| } | |
| } | |
| static class NonReboundMethodAccessInfo { | |
| private final SingleResolutionResult<?> resolutionResult; | |
| private final ProgramMethodSet contexts; | |
| NonReboundMethodAccessInfo( | |
| SingleResolutionResult<?> resolutionResult, ProgramMethodSet contexts) { | |
| this.resolutionResult = resolutionResult; | |
| this.contexts = contexts; | |
| } | |
| public static NonReboundMethodAccessInfo create(SingleResolutionResult<?> resolutionResult) { | |
| return new NonReboundMethodAccessInfo(resolutionResult, ProgramMethodSet.create()); | |
| } | |
| public static NonReboundMethodAccessInfo createConcurrent( | |
| SingleResolutionResult<?> resolutionResult) { | |
| return new NonReboundMethodAccessInfo(resolutionResult, ProgramMethodSet.createConcurrent()); | |
| } | |
| public void addContext(ProgramMethod context) { | |
| this.contexts.add(context); | |
| } | |
| public void addContexts(ProgramMethodSet contexts) { | |
| this.contexts.addAll(contexts); | |
| } | |
| } | |
| } |