| // 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; |
| |
| import com.android.tools.r8.dex.ApplicationReader; |
| import com.android.tools.r8.dex.code.DexConst; |
| import com.android.tools.r8.dex.code.DexConst16; |
| import com.android.tools.r8.dex.code.DexConst4; |
| import com.android.tools.r8.dex.code.DexConstHigh16; |
| import com.android.tools.r8.dex.code.DexConstString; |
| import com.android.tools.r8.dex.code.DexConstStringJumbo; |
| import com.android.tools.r8.dex.code.DexConstWide16; |
| import com.android.tools.r8.dex.code.DexConstWide32; |
| import com.android.tools.r8.dex.code.DexFillArrayData; |
| import com.android.tools.r8.dex.code.DexFillArrayDataPayload; |
| import com.android.tools.r8.dex.code.DexFormat35c; |
| import com.android.tools.r8.dex.code.DexFormat3rc; |
| import com.android.tools.r8.dex.code.DexInstruction; |
| import com.android.tools.r8.dex.code.DexInvokeDirect; |
| import com.android.tools.r8.dex.code.DexInvokeDirectRange; |
| import com.android.tools.r8.dex.code.DexInvokeInterface; |
| import com.android.tools.r8.dex.code.DexInvokeInterfaceRange; |
| import com.android.tools.r8.dex.code.DexInvokeStatic; |
| import com.android.tools.r8.dex.code.DexInvokeStaticRange; |
| import com.android.tools.r8.dex.code.DexInvokeSuper; |
| import com.android.tools.r8.dex.code.DexInvokeSuperRange; |
| import com.android.tools.r8.dex.code.DexInvokeVirtual; |
| import com.android.tools.r8.dex.code.DexInvokeVirtualRange; |
| import com.android.tools.r8.dex.code.DexNewArray; |
| import com.android.tools.r8.dex.code.DexSget; |
| import com.android.tools.r8.dex.code.DexSgetBoolean; |
| import com.android.tools.r8.dex.code.DexSgetByte; |
| import com.android.tools.r8.dex.code.DexSgetChar; |
| import com.android.tools.r8.dex.code.DexSgetObject; |
| import com.android.tools.r8.dex.code.DexSgetShort; |
| import com.android.tools.r8.dex.code.DexSgetWide; |
| import com.android.tools.r8.graph.Code; |
| import com.android.tools.r8.graph.DexAnnotation; |
| import com.android.tools.r8.graph.DexAnnotationElement; |
| import com.android.tools.r8.graph.DexApplication; |
| import com.android.tools.r8.graph.DexEncodedField; |
| import com.android.tools.r8.graph.DexEncodedMethod; |
| import com.android.tools.r8.graph.DexField; |
| import com.android.tools.r8.graph.DexMethod; |
| import com.android.tools.r8.graph.DexProgramClass; |
| import com.android.tools.r8.graph.DexValue; |
| import com.android.tools.r8.ir.code.SingleConstant; |
| import com.android.tools.r8.ir.code.WideConstant; |
| import com.android.tools.r8.keepanno.annotations.KeepForApi; |
| import com.android.tools.r8.references.ClassReference; |
| import com.android.tools.r8.references.MethodReference; |
| import com.android.tools.r8.utils.AndroidApp; |
| import com.android.tools.r8.utils.InternalOptions; |
| import com.android.tools.r8.utils.Timing; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Sets; |
| import com.google.common.collect.Streams; |
| import java.io.IOException; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.Set; |
| import java.util.concurrent.ExecutionException; |
| import java.util.stream.Stream; |
| |
| /** |
| * This class is deprecated and should not be used. It is a temporary solution to use R8 to analyze |
| * dex files and compute resource shrinker related bits. |
| * |
| * <p>Users or this API should implement {@link ReferenceChecker} interface, and through callbacks |
| * in that interface, they will be notified when element relevant for resource shrinking is found. |
| * |
| * <p>This class extracts all integer constants and string constants, which might refer to resource. |
| * More specifically, we look for the following while analyzing dex: |
| * |
| * <ul> |
| * <li>const instructions that might load integers or strings |
| * <li>static fields that have an initial value. This initial value might be integer, string, or |
| * array of integers. |
| * <li>integer array payloads. Only payloads referenced in fill-array-data instructions will be |
| * processed. More specifically, if a payload is referenced in fill-array-data, and we are |
| * able to determine that array is not array of integers, payload will be ignored. Otherwise, |
| * it will be processed once fill-array-data-payload instruction is encountered. |
| * <li>all annotations (class, field, method) that contain annotation element whose value is |
| * integer, string or array of integers are processed. |
| * </ul> |
| * |
| * <p>Please note that switch payloads are not analyzed. Although they might contain integer |
| * constants, ones referring to resource ids would have to be loaded in the code analyzed in list |
| * above. |
| * |
| * <p>Usage of this feature is intentionally not supported from the command line. |
| */ |
| |
| // TODO(b/121121779) Remove keep if possible. |
| @Deprecated |
| @KeepForApi |
| final public class ResourceShrinker { |
| |
| @KeepForApi |
| public final static class Command extends BaseCommand { |
| |
| Command(AndroidApp app) { |
| super(app); |
| } |
| |
| @Override |
| InternalOptions getInternalOptions() { |
| return new InternalOptions(); |
| } |
| } |
| |
| @KeepForApi |
| public final static class Builder extends BaseCommand.Builder<Command, Builder> { |
| |
| @Override |
| Builder self() { |
| return this; |
| } |
| |
| @Override |
| Command makeCommand() { |
| return new Command(getAppBuilder().build()); |
| } |
| } |
| |
| /** |
| * Classes that would like to process data relevant to resource shrinking should implement this |
| * interface. |
| */ |
| @KeepForApi |
| public interface ReferenceChecker { |
| |
| /** |
| * Returns if the class with specified internal name should be processed. Typically, |
| * resource type classes like R$drawable, R$styleable etc. should be skipped. |
| */ |
| boolean shouldProcess(String internalName); |
| |
| void referencedInt(int value); |
| |
| void referencedString(String value); |
| |
| void referencedStaticField(String internalName, String fieldName); |
| |
| void referencedMethod(String internalName, String methodName, String methodDescriptor); |
| |
| default void startMethodVisit(MethodReference methodReference) {} |
| |
| default void endMethodVisit(MethodReference methodReference) {} |
| |
| default void startClassVisit(ClassReference classReference) {} |
| |
| default void endClassVisit(ClassReference classReference) {} |
| } |
| |
| private static final class DexClassUsageVisitor { |
| |
| private final DexProgramClass classDef; |
| private final ReferenceChecker callback; |
| |
| DexClassUsageVisitor(DexProgramClass classDef, ReferenceChecker callback) { |
| this.classDef = classDef; |
| this.callback = callback; |
| } |
| |
| public void visit() { |
| callback.startClassVisit(classDef.getClassReference()); |
| if (!callback.shouldProcess(classDef.type.getInternalName())) { |
| return; |
| } |
| |
| for (DexEncodedField field : classDef.staticFields()) { |
| DexValue staticValue = field.getStaticValue(); |
| if (staticValue != null) { |
| processFieldValue(staticValue); |
| } |
| } |
| |
| for (DexEncodedMethod method : classDef.allMethodsSorted()) { |
| |
| callback.startMethodVisit(method.getReference().asMethodReference()); |
| processMethod(method); |
| callback.endMethodVisit(method.getReference().asMethodReference()); |
| } |
| |
| if (classDef.hasClassOrMemberAnnotations()) { |
| processAnnotations(classDef); |
| } |
| callback.endClassVisit(classDef.getClassReference()); |
| } |
| |
| private void processFieldValue(DexValue value) { |
| switch (value.getValueKind()) { |
| case ARRAY: |
| for (DexValue elementValue : value.asDexValueArray().getValues()) { |
| if (elementValue.isDexValueInt()) { |
| callback.referencedInt(elementValue.asDexValueInt().getValue()); |
| } |
| } |
| break; |
| |
| case INT: |
| callback.referencedInt(value.asDexValueInt().getValue()); |
| break; |
| |
| case STRING: |
| callback.referencedString(value.asDexValueString().value.toString()); |
| break; |
| |
| default: |
| // Intentionally empty. |
| } |
| } |
| |
| private void processMethod(DexEncodedMethod method) { |
| Code implementation = method.getCode(); |
| if (implementation != null) { |
| |
| // Tracks the offsets of integer array payloads. |
| final Set<Integer> methodIntArrayPayloadOffsets = Sets.newHashSet(); |
| // First we collect payloads, and then we process them because payload can be before the |
| // fill-array-data instruction referencing it. |
| final List<DexFillArrayDataPayload> payloads = Lists.newArrayList(); |
| |
| DexInstruction[] instructions = implementation.asDexCode().instructions; |
| int current = 0; |
| while (current < instructions.length) { |
| DexInstruction instruction = instructions[current]; |
| if (isIntConstInstruction(instruction)) { |
| processIntConstInstruction(instruction); |
| } else if (isStringConstInstruction(instruction)) { |
| processStringConstantInstruction(instruction); |
| } else if (isGetStatic(instruction)) { |
| processGetStatic(instruction); |
| } else if (isInvokeInstruction(instruction)) { |
| processInvokeInstruction(instruction); |
| } else if (isInvokeRangeInstruction(instruction)) { |
| processInvokeRangeInstruction(instruction); |
| } else if (instruction instanceof DexFillArrayData) { |
| processFillArray(instructions, current, methodIntArrayPayloadOffsets); |
| } else if (instruction instanceof DexFillArrayDataPayload) { |
| payloads.add((DexFillArrayDataPayload) instruction); |
| } |
| current++; |
| } |
| |
| for (DexFillArrayDataPayload payload : payloads) { |
| if (isIntArrayPayload(payload, methodIntArrayPayloadOffsets)) { |
| processIntArrayPayload(payload); |
| } |
| } |
| } |
| } |
| |
| private void processAnnotations(DexProgramClass classDef) { |
| Stream<DexAnnotation> classAnnotations = classDef.annotations().stream(); |
| Stream<DexAnnotation> fieldAnnotations = |
| Streams.stream(classDef.fields()) |
| .filter(DexEncodedField::hasAnnotations) |
| .flatMap(f -> f.annotations().stream()); |
| Stream<DexAnnotation> methodAnnotations = |
| Streams.stream(classDef.methods()) |
| .filter(DexEncodedMethod::hasAnyAnnotations) |
| .flatMap(m -> m.annotations().stream()); |
| |
| Streams.concat(classAnnotations, fieldAnnotations, methodAnnotations) |
| .forEach( |
| annotation -> { |
| for (DexAnnotationElement element : annotation.annotation.elements) { |
| DexValue value = element.value; |
| processAnnotationValue(value); |
| } |
| }); |
| } |
| |
| private void processIntArrayPayload(DexInstruction instruction) { |
| DexFillArrayDataPayload payload = (DexFillArrayDataPayload) instruction; |
| |
| for (int i = 0; i < payload.data.length / 2; i++) { |
| int intValue = payload.data[2 * i + 1] << 16 | payload.data[2 * i]; |
| callback.referencedInt(intValue); |
| } |
| } |
| |
| private boolean isIntArrayPayload( |
| DexInstruction instruction, Set<Integer> methodIntArrayPayloadOffsets) { |
| if (!(instruction instanceof DexFillArrayDataPayload)) { |
| return false; |
| } |
| |
| DexFillArrayDataPayload payload = (DexFillArrayDataPayload) instruction; |
| return methodIntArrayPayloadOffsets.contains(payload.getOffset()); |
| } |
| |
| private void processFillArray( |
| DexInstruction[] instructions, int current, Set<Integer> methodIntArrayPayloadOffsets) { |
| DexFillArrayData fillArrayData = (DexFillArrayData) instructions[current]; |
| if (current > 0 && instructions[current - 1] instanceof DexNewArray) { |
| DexNewArray newArray = (DexNewArray) instructions[current - 1]; |
| if (!Objects.equals(newArray.getType().descriptor.toString(), "[I")) { |
| return; |
| } |
| // Typically, new-array is right before fill-array-data. If not, assume referenced array is |
| // of integers. This can be improved later, but for now we make sure no ints are missed. |
| } |
| |
| methodIntArrayPayloadOffsets.add( |
| fillArrayData.getPayloadOffset() + fillArrayData.getOffset()); |
| } |
| |
| private void processAnnotationValue(DexValue value) { |
| switch (value.getValueKind()) { |
| case ANNOTATION: |
| for (DexAnnotationElement element : value.asDexValueAnnotation().value.elements) { |
| processAnnotationValue(element.value); |
| } |
| break; |
| |
| case ARRAY: |
| for (DexValue elementValue : value.asDexValueArray().getValues()) { |
| processAnnotationValue(elementValue); |
| } |
| break; |
| |
| case INT: |
| callback.referencedInt(value.asDexValueInt().value); |
| break; |
| |
| case STRING: |
| callback.referencedString(value.asDexValueString().value.toString()); |
| break; |
| |
| default: |
| // Intentionally empty. |
| } |
| } |
| |
| private boolean isIntConstInstruction(DexInstruction instruction) { |
| int opcode = instruction.getOpcode(); |
| return opcode == DexConst4.OPCODE |
| || opcode == DexConst16.OPCODE |
| || opcode == DexConst.OPCODE |
| || opcode == DexConstWide32.OPCODE |
| || opcode == DexConstHigh16.OPCODE |
| || opcode == DexConstWide16.OPCODE; |
| } |
| |
| private void processIntConstInstruction(DexInstruction instruction) { |
| assert isIntConstInstruction(instruction); |
| |
| int constantValue; |
| if (instruction instanceof SingleConstant) { |
| SingleConstant singleConstant = (SingleConstant) instruction; |
| constantValue = singleConstant.decodedValue(); |
| } else if (instruction instanceof WideConstant) { |
| WideConstant wideConstant = (WideConstant) instruction; |
| if (((int) wideConstant.decodedValue()) != wideConstant.decodedValue()) { |
| // We care only about values that fit in int range. |
| return; |
| } |
| constantValue = (int) wideConstant.decodedValue(); |
| } else { |
| throw new AssertionError("Not an int const instruction."); |
| } |
| |
| callback.referencedInt(constantValue); |
| } |
| |
| private boolean isStringConstInstruction(DexInstruction instruction) { |
| int opcode = instruction.getOpcode(); |
| return opcode == DexConstString.OPCODE || opcode == DexConstStringJumbo.OPCODE; |
| } |
| |
| private void processStringConstantInstruction(DexInstruction instruction) { |
| assert isStringConstInstruction(instruction); |
| |
| String constantValue; |
| if (instruction instanceof DexConstString) { |
| DexConstString constString = (DexConstString) instruction; |
| constantValue = constString.getString().toString(); |
| } else if (instruction instanceof DexConstStringJumbo) { |
| DexConstStringJumbo constStringJumbo = (DexConstStringJumbo) instruction; |
| constantValue = constStringJumbo.getString().toString(); |
| } else { |
| throw new AssertionError("Not a string constant instruction."); |
| } |
| |
| callback.referencedString(constantValue); |
| } |
| |
| private boolean isGetStatic(DexInstruction instruction) { |
| int opcode = instruction.getOpcode(); |
| return opcode == DexSget.OPCODE |
| || opcode == DexSgetBoolean.OPCODE |
| || opcode == DexSgetByte.OPCODE |
| || opcode == DexSgetChar.OPCODE |
| || opcode == DexSgetObject.OPCODE |
| || opcode == DexSgetShort.OPCODE |
| || opcode == DexSgetWide.OPCODE; |
| } |
| |
| private void processGetStatic(DexInstruction instruction) { |
| assert isGetStatic(instruction); |
| |
| DexField field; |
| if (instruction instanceof DexSget) { |
| DexSget sget = (DexSget) instruction; |
| field = sget.getField(); |
| } else if (instruction instanceof DexSgetBoolean) { |
| DexSgetBoolean sgetBoolean = (DexSgetBoolean) instruction; |
| field = sgetBoolean.getField(); |
| } else if (instruction instanceof DexSgetByte) { |
| DexSgetByte sgetByte = (DexSgetByte) instruction; |
| field = sgetByte.getField(); |
| } else if (instruction instanceof DexSgetChar) { |
| DexSgetChar sgetChar = (DexSgetChar) instruction; |
| field = sgetChar.getField(); |
| } else if (instruction instanceof DexSgetObject) { |
| DexSgetObject sgetObject = (DexSgetObject) instruction; |
| field = sgetObject.getField(); |
| } else if (instruction instanceof DexSgetShort) { |
| DexSgetShort sgetShort = (DexSgetShort) instruction; |
| field = sgetShort.getField(); |
| } else if (instruction instanceof DexSgetWide) { |
| DexSgetWide sgetWide = (DexSgetWide) instruction; |
| field = sgetWide.getField(); |
| } else { |
| throw new AssertionError("Not a get static instruction"); |
| } |
| |
| callback.referencedStaticField(field.holder.getInternalName(), field.name.toString()); |
| } |
| |
| private boolean isInvokeInstruction(DexInstruction instruction) { |
| int opcode = instruction.getOpcode(); |
| return opcode == DexInvokeVirtual.OPCODE |
| || opcode == DexInvokeSuper.OPCODE |
| || opcode == DexInvokeDirect.OPCODE |
| || opcode == DexInvokeStatic.OPCODE |
| || opcode == DexInvokeInterface.OPCODE; |
| } |
| |
| private void processInvokeInstruction(DexInstruction instruction) { |
| assert isInvokeInstruction(instruction); |
| |
| DexFormat35c ins35c = (DexFormat35c) instruction; |
| DexMethod method = (DexMethod) ins35c.BBBB; |
| |
| callback.referencedMethod( |
| method.holder.getInternalName(), |
| method.name.toString(), |
| method.proto.toDescriptorString()); |
| } |
| |
| private boolean isInvokeRangeInstruction(DexInstruction instruction) { |
| int opcode = instruction.getOpcode(); |
| return opcode == DexInvokeVirtualRange.OPCODE |
| || opcode == DexInvokeSuperRange.OPCODE |
| || opcode == DexInvokeDirectRange.OPCODE |
| || opcode == DexInvokeStaticRange.OPCODE |
| || opcode == DexInvokeInterfaceRange.OPCODE; |
| } |
| |
| private void processInvokeRangeInstruction(DexInstruction instruction) { |
| assert isInvokeRangeInstruction(instruction); |
| |
| DexFormat3rc ins3rc = (DexFormat3rc) instruction; |
| DexMethod method = (DexMethod) ins3rc.BBBB; |
| |
| callback.referencedMethod( |
| method.holder.getInternalName(), |
| method.name.toString(), |
| method.proto.toDescriptorString()); |
| } |
| } |
| |
| @SuppressWarnings("RedundantThrows") |
| public static void run(Command command, ReferenceChecker callback) |
| throws IOException, ExecutionException { |
| runForTesting(command.getInputApp(), command.getInternalOptions(), callback); |
| } |
| |
| public static void runForTesting( |
| AndroidApp inputApp, InternalOptions options, ReferenceChecker callback) |
| throws IOException, ExecutionException { |
| Timing timing = new Timing("resource shrinker analyzer"); |
| DexApplication dexApplication = new ApplicationReader(inputApp, options, timing).read(); |
| for (DexProgramClass programClass : dexApplication.classes()) { |
| new DexClassUsageVisitor(programClass, callback).visit(); |
| } |
| } |
| } |
