| // Copyright (c) 2022, 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.lightir; |
| |
| import com.android.tools.r8.cf.code.CfNumberConversion; |
| import com.android.tools.r8.errors.Unimplemented; |
| import com.android.tools.r8.errors.Unreachable; |
| import com.android.tools.r8.graph.DexCallSite; |
| import com.android.tools.r8.graph.DexField; |
| import com.android.tools.r8.graph.DexItem; |
| import com.android.tools.r8.graph.DexMethod; |
| import com.android.tools.r8.graph.DexMethodHandle; |
| import com.android.tools.r8.graph.DexProto; |
| import com.android.tools.r8.graph.DexReference; |
| import com.android.tools.r8.graph.DexString; |
| import com.android.tools.r8.graph.DexType; |
| import com.android.tools.r8.ir.code.IfType; |
| import com.android.tools.r8.ir.code.MemberType; |
| import com.android.tools.r8.ir.code.NumericType; |
| import com.android.tools.r8.lightir.LirBuilder.FillArrayPayload; |
| import com.android.tools.r8.lightir.LirBuilder.IntSwitchPayload; |
| import com.android.tools.r8.lightir.LirBuilder.NameComputationPayload; |
| import com.android.tools.r8.lightir.LirBuilder.RecordFieldValuesPayload; |
| import com.android.tools.r8.naming.dexitembasedstring.NameComputationInfo; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * Structured callbacks for interpreting LIR. |
| * |
| * <p>This callback parses the actual instructions and dispatches to instruction specific methods |
| * where the parsed data is provided as arguments. Instructions that are part of a family of |
| * instructions have a default implementation that will call the "instruction family" methods (e.g., |
| * onInvokeVirtual will default dispatch to onInvokedMethodInstruction). |
| * |
| * <p>Due to the parsing of the individual instructions, this parser has a higher overhead than |
| * using the basic {@link LirInstructionView}. |
| */ |
| public abstract class LirParsedInstructionCallback<EV> implements LirInstructionCallback { |
| |
| private final LirCode<EV> code; |
| |
| public LirParsedInstructionCallback(LirCode<EV> code) { |
| this.code = code; |
| } |
| |
| /** Returns the index for the value associated with the current argument/instruction. */ |
| public abstract int getCurrentValueIndex(); |
| |
| public final int getCurrentInstructionIndex() { |
| return getCurrentValueIndex() - code.getArgumentCount(); |
| } |
| |
| private EV getActualValueIndex(int relativeValueIndex) { |
| return code.decodeValueIndex(relativeValueIndex, getCurrentValueIndex()); |
| } |
| |
| private EV getNextValueOperand(LirInstructionView view) { |
| return getActualValueIndex(view.getNextValueOperand()); |
| } |
| |
| private DexType getNextDexTypeOperand(LirInstructionView view) { |
| return (DexType) getConstantItem(view.getNextConstantOperand()); |
| } |
| |
| public void onInstruction() {} |
| |
| public void onConstNull() { |
| onInstruction(); |
| } |
| |
| public void onConstNumber(NumericType type, long value) { |
| onInstruction(); |
| } |
| |
| public void onConstInt(int value) { |
| onConstNumber(NumericType.INT, value); |
| } |
| |
| public void onConstFloat(int value) { |
| onConstNumber(NumericType.FLOAT, value); |
| } |
| |
| public void onConstLong(long value) { |
| onConstNumber(NumericType.LONG, value); |
| } |
| |
| public void onConstDouble(long value) { |
| onConstNumber(NumericType.DOUBLE, value); |
| } |
| |
| public void onConstString(DexString string) { |
| onInstruction(); |
| } |
| |
| public void onDexItemBasedConstString( |
| DexReference item, NameComputationInfo<?> nameComputationInfo) { |
| onInstruction(); |
| } |
| |
| public void onConstClass(DexType type) { |
| onInstruction(); |
| } |
| |
| public void onConstMethodHandle(DexMethodHandle methodHandle) { |
| onInstruction(); |
| } |
| |
| public void onConstMethodType(DexProto methodType) { |
| onInstruction(); |
| } |
| |
| private void onArrayGetInternal(MemberType type, LirInstructionView view) { |
| if (type.isObject()) { |
| DexType destType = (DexType) getConstantItem(view.getNextConstantOperand()); |
| EV array = getNextValueOperand(view); |
| EV index = getNextValueOperand(view); |
| onArrayGetObject(destType, array, index); |
| } else { |
| EV array = getNextValueOperand(view); |
| EV index = getNextValueOperand(view); |
| onArrayGetPrimitive(type, array, index); |
| } |
| } |
| |
| public void onArrayGetPrimitive(MemberType type, EV array, EV index) { |
| onInstruction(); |
| } |
| |
| public void onArrayGetObject(DexType type, EV array, EV index) { |
| onInstruction(); |
| } |
| |
| private void onArrayPutInternal(MemberType type, LirInstructionView view) { |
| EV array = getNextValueOperand(view); |
| EV index = getNextValueOperand(view); |
| EV value = getNextValueOperand(view); |
| onArrayPut(type, array, index, value); |
| } |
| |
| public void onArrayPut(MemberType type, EV array, EV index, EV value) { |
| onInstruction(); |
| } |
| |
| public void onBinop(NumericType type, EV left, EV right) { |
| onInstruction(); |
| } |
| |
| public void onArithmeticBinop(NumericType type, EV left, EV right) { |
| onBinop(type, left, right); |
| } |
| |
| public void onAdd(NumericType type, EV leftValueIndex, EV rightValueIndex) { |
| onArithmeticBinop(type, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onAddInt(EV leftValueIndex, EV rightValueIndex) { |
| onAdd(NumericType.INT, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onAddLong(EV leftValueIndex, EV rightValueIndex) { |
| onAdd(NumericType.LONG, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onAddFloat(EV leftValueIndex, EV rightValueIndex) { |
| onAdd(NumericType.FLOAT, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onAddDouble(EV leftValueIndex, EV rightValueIndex) { |
| onAdd(NumericType.DOUBLE, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onSub(NumericType type, EV leftValueIndex, EV rightValueIndex) { |
| onArithmeticBinop(type, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onSubInt(EV leftValueIndex, EV rightValueIndex) { |
| onSub(NumericType.INT, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onSubLong(EV leftValueIndex, EV rightValueIndex) { |
| onSub(NumericType.LONG, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onSubFloat(EV leftValueIndex, EV rightValueIndex) { |
| onSub(NumericType.FLOAT, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onSubDouble(EV leftValueIndex, EV rightValueIndex) { |
| onSub(NumericType.DOUBLE, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onMul(NumericType type, EV leftValueIndex, EV rightValueIndex) { |
| onArithmeticBinop(type, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onMulInt(EV leftValueIndex, EV rightValueIndex) { |
| onMul(NumericType.INT, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onMulLong(EV leftValueIndex, EV rightValueIndex) { |
| onMul(NumericType.LONG, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onMulFloat(EV leftValueIndex, EV rightValueIndex) { |
| onMul(NumericType.FLOAT, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onMulDouble(EV leftValueIndex, EV rightValueIndex) { |
| onMul(NumericType.DOUBLE, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onDiv(NumericType type, EV leftValueIndex, EV rightValueIndex) { |
| onArithmeticBinop(type, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onDivInt(EV leftValueIndex, EV rightValueIndex) { |
| onDiv(NumericType.INT, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onDivLong(EV leftValueIndex, EV rightValueIndex) { |
| onDiv(NumericType.LONG, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onDivFloat(EV leftValueIndex, EV rightValueIndex) { |
| onDiv(NumericType.FLOAT, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onDivDouble(EV leftValueIndex, EV rightValueIndex) { |
| onDiv(NumericType.DOUBLE, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onRem(NumericType type, EV leftValueIndex, EV rightValueIndex) { |
| onArithmeticBinop(type, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onRemInt(EV leftValueIndex, EV rightValueIndex) { |
| onRem(NumericType.INT, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onRemLong(EV leftValueIndex, EV rightValueIndex) { |
| onRem(NumericType.LONG, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onRemFloat(EV leftValueIndex, EV rightValueIndex) { |
| onRem(NumericType.FLOAT, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onRemDouble(EV leftValueIndex, EV rightValueIndex) { |
| onRem(NumericType.DOUBLE, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onNeg(NumericType type, EV value) { |
| onInstruction(); |
| } |
| |
| public void onNot(NumericType type, EV value) { |
| onInstruction(); |
| } |
| |
| private void onLogicalBinopInternal(int opcode, LirInstructionView view) { |
| EV left = getNextValueOperand(view); |
| EV right = getNextValueOperand(view); |
| switch (opcode) { |
| case LirOpcodes.ISHL: |
| onShl(NumericType.INT, left, right); |
| return; |
| case LirOpcodes.LSHL: |
| onShl(NumericType.LONG, left, right); |
| return; |
| case LirOpcodes.ISHR: |
| onShr(NumericType.INT, left, right); |
| return; |
| case LirOpcodes.LSHR: |
| onShr(NumericType.LONG, left, right); |
| return; |
| case LirOpcodes.IUSHR: |
| onUshr(NumericType.INT, left, right); |
| return; |
| case LirOpcodes.LUSHR: |
| onUshr(NumericType.LONG, left, right); |
| return; |
| case LirOpcodes.IAND: |
| onAnd(NumericType.INT, left, right); |
| return; |
| case LirOpcodes.LAND: |
| onAnd(NumericType.LONG, left, right); |
| return; |
| case LirOpcodes.IOR: |
| onOr(NumericType.INT, left, right); |
| return; |
| case LirOpcodes.LOR: |
| onOr(NumericType.LONG, left, right); |
| return; |
| case LirOpcodes.IXOR: |
| onXor(NumericType.INT, left, right); |
| return; |
| case LirOpcodes.LXOR: |
| onXor(NumericType.LONG, left, right); |
| return; |
| default: |
| throw new Unreachable("Unexpected logical binop: " + opcode); |
| } |
| } |
| |
| public void onLogicalBinop(NumericType type, EV left, EV right) { |
| onBinop(type, left, right); |
| } |
| |
| public void onShl(NumericType type, EV left, EV right) { |
| onLogicalBinop(type, left, right); |
| } |
| |
| public void onShr(NumericType type, EV left, EV right) { |
| onLogicalBinop(type, left, right); |
| } |
| |
| public void onUshr(NumericType type, EV left, EV right) { |
| onLogicalBinop(type, left, right); |
| } |
| |
| public void onAnd(NumericType type, EV left, EV right) { |
| onLogicalBinop(type, left, right); |
| } |
| |
| public void onOr(NumericType type, EV left, EV right) { |
| onLogicalBinop(type, left, right); |
| } |
| |
| public void onXor(NumericType type, EV left, EV right) { |
| onLogicalBinop(type, left, right); |
| } |
| |
| public void onNumberConversion(int opcode, EV value) { |
| assert LirOpcodes.I2L <= opcode; |
| assert opcode <= LirOpcodes.I2S; |
| CfNumberConversion insn = CfNumberConversion.fromAsm(opcode); |
| onNumberConversion(insn.getFromType(), insn.getToType(), value); |
| } |
| |
| public void onNumberConversion(NumericType from, NumericType to, EV value) { |
| onInstruction(); |
| } |
| |
| private void onIfInternal(IfType ifKind, LirInstructionView view) { |
| int blockIndex = view.getNextBlockOperand(); |
| EV valueIndex = getNextValueOperand(view); |
| onIf(ifKind, blockIndex, valueIndex); |
| } |
| |
| public void onIf(IfType ifKind, int blockIndex, EV valueIndex) { |
| onInstruction(); |
| } |
| |
| private void onIfCmpInternal(IfType ifKind, LirInstructionView view) { |
| int blockIndex = view.getNextBlockOperand(); |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onIfCmp(ifKind, blockIndex, leftValueIndex, rightValueIndex); |
| } |
| |
| public void onIfCmp(IfType ifKind, int blockIndex, EV leftValueIndex, EV rightValueIndex) { |
| onInstruction(); |
| } |
| |
| public void onGoto(int blockIndex) { |
| onInstruction(); |
| } |
| |
| public void onIntSwitch(EV value, IntSwitchPayload payload) { |
| onInstruction(); |
| } |
| |
| public void onFallthrough() { |
| onInstruction(); |
| } |
| |
| public void onMoveException(DexType exceptionType) { |
| onInstruction(); |
| } |
| |
| public void onDebugLocalWrite(EV srcIndex) { |
| onInstruction(); |
| } |
| |
| public void onDebugLocalRead() { |
| onInstruction(); |
| } |
| |
| public void onInvokeMultiNewArray(DexType type, List<EV> arguments) { |
| onInstruction(); |
| } |
| |
| public void onInvokeNewArray(DexType type, List<EV> arguments) { |
| onInstruction(); |
| } |
| |
| public void onNewArrayFilledData(int elementWidth, long size, short[] data, EV src) { |
| onInstruction(); |
| } |
| |
| public void onInvokeMethodInstruction(DexMethod method, List<EV> arguments) { |
| onInstruction(); |
| } |
| |
| public void onInvokeDirect(DexMethod method, List<EV> arguments, boolean isInterface) { |
| onInvokeMethodInstruction(method, arguments); |
| } |
| |
| public void onInvokeSuper(DexMethod method, List<EV> arguments, boolean isInterface) { |
| onInvokeMethodInstruction(method, arguments); |
| } |
| |
| public void onInvokeVirtual(DexMethod method, List<EV> arguments) { |
| onInvokeMethodInstruction(method, arguments); |
| } |
| |
| public void onInvokeStatic(DexMethod method, List<EV> arguments, boolean isInterface) { |
| onInvokeMethodInstruction(method, arguments); |
| } |
| |
| public void onInvokeInterface(DexMethod method, List<EV> arguments) { |
| onInvokeMethodInstruction(method, arguments); |
| } |
| |
| public void onInvokeCustom(DexCallSite callSite, List<EV> arguments) { |
| onInstruction(); |
| } |
| |
| public void onInvokePolymorphic(DexMethod target, DexProto proto, List<EV> arguments) { |
| onInstruction(); |
| } |
| |
| public void onNewInstance(DexType clazz) { |
| onInstruction(); |
| } |
| |
| public void onFieldInstruction(DexField field) { |
| onInstruction(); |
| } |
| |
| public void onStaticGet(DexField field) { |
| onFieldInstruction(field); |
| } |
| |
| public void onStaticPut(DexField field, EV value) { |
| onFieldInstruction(field); |
| } |
| |
| public abstract void onInstanceGet(DexField field, EV object); |
| |
| public abstract void onInstancePut(DexField field, EV object, EV value); |
| |
| public abstract void onNewArrayEmpty(DexType type, EV size); |
| |
| public abstract void onThrow(EV exception); |
| |
| public void onReturnVoid() { |
| onInstruction(); |
| } |
| |
| public void onReturn(EV value) { |
| onInstruction(); |
| } |
| |
| public void onArrayLength(EV arrayValueIndex) { |
| onInstruction(); |
| } |
| |
| public void onCheckCast(DexType type, EV value) { |
| onInstruction(); |
| } |
| |
| public void onSafeCheckCast(DexType type, EV value) { |
| onInstruction(); |
| } |
| |
| public void onInstanceOf(DexType type, EV value) { |
| onInstruction(); |
| } |
| |
| public void onDebugPosition() { |
| onInstruction(); |
| } |
| |
| public void onPhi(DexType type, List<EV> operands) { |
| onInstruction(); |
| } |
| |
| public void onCmpInstruction(int opcode, EV leftValue, EV rightValue) { |
| assert LirOpcodes.LCMP <= opcode && opcode <= LirOpcodes.DCMPG; |
| onInstruction(); |
| } |
| |
| public abstract void onMonitorEnter(EV value); |
| |
| public abstract void onMonitorExit(EV value); |
| |
| public void onNewUnboxedEnumInstance(DexType type, int ordinal) { |
| onInstruction(); |
| } |
| |
| public void onInitClass(DexType clazz) { |
| onInstruction(); |
| } |
| |
| public void onRecordFieldValues(DexField[] fields, List<EV> values) { |
| onInstruction(); |
| } |
| |
| private DexItem getConstantItem(int index) { |
| return code.getConstantItem(index); |
| } |
| |
| @Override |
| public void onInstructionView(LirInstructionView view) { |
| int opcode = view.getOpcode(); |
| switch (opcode) { |
| case LirOpcodes.ACONST_NULL: |
| { |
| onConstNull(); |
| return; |
| } |
| case LirOpcodes.LDC: |
| { |
| DexItem item = getConstantItem(view.getNextConstantOperand()); |
| if (item instanceof DexString) { |
| onConstString((DexString) item); |
| return; |
| } |
| if (item instanceof DexType) { |
| onConstClass((DexType) item); |
| return; |
| } |
| if (item instanceof DexMethodHandle) { |
| onConstMethodHandle((DexMethodHandle) item); |
| return; |
| } |
| if (item instanceof DexProto) { |
| onConstMethodType((DexProto) item); |
| return; |
| } |
| throw new Unimplemented(); |
| } |
| case LirOpcodes.ICONST_M1: |
| case LirOpcodes.ICONST_0: |
| case LirOpcodes.ICONST_1: |
| case LirOpcodes.ICONST_2: |
| case LirOpcodes.ICONST_3: |
| case LirOpcodes.ICONST_4: |
| case LirOpcodes.ICONST_5: |
| { |
| int value = opcode - LirOpcodes.ICONST_0; |
| onConstInt(value); |
| return; |
| } |
| case LirOpcodes.ICONST: |
| { |
| int value = view.getNextIntegerOperand(); |
| onConstInt(value); |
| return; |
| } |
| case LirOpcodes.FCONST_0: |
| case LirOpcodes.FCONST_1: |
| case LirOpcodes.FCONST_2: |
| { |
| float value = opcode - LirOpcodes.FCONST_0; |
| onConstFloat(Float.floatToRawIntBits(value)); |
| return; |
| } |
| case LirOpcodes.FCONST: |
| { |
| int value = view.getNextIntegerOperand(); |
| onConstFloat(value); |
| return; |
| } |
| case LirOpcodes.LCONST_0: |
| { |
| onConstLong(0); |
| return; |
| } |
| case LirOpcodes.LCONST_1: |
| { |
| onConstLong(1); |
| return; |
| } |
| case LirOpcodes.LCONST: |
| { |
| long value = view.getNextLongOperand(); |
| onConstLong(value); |
| return; |
| } |
| case LirOpcodes.DCONST_0: |
| { |
| onConstDouble(Double.doubleToRawLongBits(0)); |
| return; |
| } |
| case LirOpcodes.DCONST_1: |
| { |
| onConstDouble(Double.doubleToRawLongBits(1)); |
| return; |
| } |
| case LirOpcodes.DCONST: |
| { |
| long value = view.getNextLongOperand(); |
| onConstDouble(value); |
| return; |
| } |
| case LirOpcodes.IALOAD: |
| { |
| onArrayGetInternal(MemberType.INT, view); |
| break; |
| } |
| case LirOpcodes.LALOAD: |
| { |
| onArrayGetInternal(MemberType.LONG, view); |
| break; |
| } |
| case LirOpcodes.FALOAD: |
| { |
| onArrayGetInternal(MemberType.FLOAT, view); |
| break; |
| } |
| case LirOpcodes.DALOAD: |
| { |
| onArrayGetInternal(MemberType.DOUBLE, view); |
| break; |
| } |
| case LirOpcodes.AALOAD: |
| { |
| onArrayGetInternal(MemberType.OBJECT, view); |
| break; |
| } |
| case LirOpcodes.BALOAD: |
| { |
| onArrayGetInternal(MemberType.BOOLEAN_OR_BYTE, view); |
| break; |
| } |
| case LirOpcodes.CALOAD: |
| { |
| onArrayGetInternal(MemberType.CHAR, view); |
| break; |
| } |
| case LirOpcodes.SALOAD: |
| { |
| onArrayGetInternal(MemberType.SHORT, view); |
| break; |
| } |
| case LirOpcodes.IASTORE: |
| { |
| onArrayPutInternal(MemberType.INT, view); |
| break; |
| } |
| case LirOpcodes.LASTORE: |
| { |
| onArrayPutInternal(MemberType.LONG, view); |
| break; |
| } |
| case LirOpcodes.FASTORE: |
| { |
| onArrayPutInternal(MemberType.FLOAT, view); |
| break; |
| } |
| |
| case LirOpcodes.DASTORE: |
| { |
| onArrayPutInternal(MemberType.DOUBLE, view); |
| break; |
| } |
| |
| case LirOpcodes.AASTORE: |
| { |
| onArrayPutInternal(MemberType.OBJECT, view); |
| break; |
| } |
| |
| case LirOpcodes.BASTORE: |
| { |
| onArrayPutInternal(MemberType.BOOLEAN_OR_BYTE, view); |
| break; |
| } |
| |
| case LirOpcodes.CASTORE: |
| { |
| onArrayPutInternal(MemberType.CHAR, view); |
| break; |
| } |
| |
| case LirOpcodes.SASTORE: |
| { |
| onArrayPutInternal(MemberType.SHORT, view); |
| break; |
| } |
| |
| case LirOpcodes.IADD: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onAddInt(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.LADD: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onAddLong(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.FADD: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onAddFloat(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.DADD: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onAddDouble(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.ISUB: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onSubInt(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.LSUB: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onSubLong(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.FSUB: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onSubFloat(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.DSUB: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onSubDouble(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.IMUL: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onMulInt(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.LMUL: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onMulLong(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.FMUL: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onMulFloat(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.DMUL: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onMulDouble(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.IDIV: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onDivInt(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.LDIV: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onDivLong(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.FDIV: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onDivFloat(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.DDIV: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onDivDouble(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.IREM: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onRemInt(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.LREM: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onRemLong(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.FREM: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onRemFloat(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.DREM: |
| { |
| EV leftValueIndex = getNextValueOperand(view); |
| EV rightValueIndex = getNextValueOperand(view); |
| onRemDouble(leftValueIndex, rightValueIndex); |
| return; |
| } |
| case LirOpcodes.INEG: |
| { |
| EV value = getNextValueOperand(view); |
| onNeg(NumericType.INT, value); |
| return; |
| } |
| case LirOpcodes.LNEG: |
| { |
| EV value = getNextValueOperand(view); |
| onNeg(NumericType.LONG, value); |
| return; |
| } |
| case LirOpcodes.FNEG: |
| { |
| EV value = getNextValueOperand(view); |
| onNeg(NumericType.FLOAT, value); |
| return; |
| } |
| case LirOpcodes.DNEG: |
| { |
| EV value = getNextValueOperand(view); |
| onNeg(NumericType.DOUBLE, value); |
| return; |
| } |
| case LirOpcodes.ISHL: |
| case LirOpcodes.LSHL: |
| case LirOpcodes.ISHR: |
| case LirOpcodes.LSHR: |
| case LirOpcodes.IUSHR: |
| case LirOpcodes.LUSHR: |
| case LirOpcodes.IAND: |
| case LirOpcodes.LAND: |
| case LirOpcodes.IOR: |
| case LirOpcodes.LOR: |
| case LirOpcodes.IXOR: |
| case LirOpcodes.LXOR: |
| { |
| onLogicalBinopInternal(opcode, view); |
| return; |
| } |
| case LirOpcodes.I2L: |
| case LirOpcodes.I2F: |
| case LirOpcodes.I2D: |
| case LirOpcodes.L2I: |
| case LirOpcodes.L2F: |
| case LirOpcodes.L2D: |
| case LirOpcodes.F2I: |
| case LirOpcodes.F2L: |
| case LirOpcodes.F2D: |
| case LirOpcodes.D2I: |
| case LirOpcodes.D2L: |
| case LirOpcodes.D2F: |
| case LirOpcodes.I2B: |
| case LirOpcodes.I2C: |
| case LirOpcodes.I2S: |
| { |
| EV value = getNextValueOperand(view); |
| onNumberConversion(opcode, value); |
| return; |
| } |
| case LirOpcodes.IFEQ: |
| { |
| onIfInternal(IfType.EQ, view); |
| return; |
| } |
| case LirOpcodes.IFNE: |
| { |
| onIfInternal(IfType.NE, view); |
| return; |
| } |
| case LirOpcodes.IFLT: |
| { |
| onIfInternal(IfType.LT, view); |
| return; |
| } |
| case LirOpcodes.IFGE: |
| { |
| onIfInternal(IfType.GE, view); |
| return; |
| } |
| case LirOpcodes.IFGT: |
| { |
| onIfInternal(IfType.GT, view); |
| return; |
| } |
| case LirOpcodes.IFLE: |
| { |
| onIfInternal(IfType.LE, view); |
| return; |
| } |
| case LirOpcodes.IFNULL: |
| { |
| onIfInternal(IfType.EQ, view); |
| return; |
| } |
| case LirOpcodes.IFNONNULL: |
| { |
| onIfInternal(IfType.NE, view); |
| return; |
| } |
| case LirOpcodes.IF_ICMPEQ: |
| { |
| onIfCmpInternal(IfType.EQ, view); |
| return; |
| } |
| case LirOpcodes.IF_ICMPNE: |
| { |
| onIfCmpInternal(IfType.NE, view); |
| return; |
| } |
| case LirOpcodes.IF_ICMPLT: |
| { |
| onIfCmpInternal(IfType.LT, view); |
| return; |
| } |
| case LirOpcodes.IF_ICMPGE: |
| { |
| onIfCmpInternal(IfType.GE, view); |
| return; |
| } |
| case LirOpcodes.IF_ICMPGT: |
| { |
| onIfCmpInternal(IfType.GT, view); |
| return; |
| } |
| case LirOpcodes.IF_ICMPLE: |
| { |
| onIfCmpInternal(IfType.LE, view); |
| return; |
| } |
| case LirOpcodes.IF_ACMPEQ: |
| { |
| onIfCmpInternal(IfType.EQ, view); |
| return; |
| } |
| case LirOpcodes.IF_ACMPNE: |
| { |
| onIfCmpInternal(IfType.NE, view); |
| return; |
| } |
| case LirOpcodes.GOTO: |
| { |
| int blockIndex = view.getNextBlockOperand(); |
| onGoto(blockIndex); |
| return; |
| } |
| case LirOpcodes.TABLESWITCH: |
| { |
| IntSwitchPayload payload = |
| (IntSwitchPayload) getConstantItem(view.getNextConstantOperand()); |
| EV value = getNextValueOperand(view); |
| onIntSwitch(value, payload); |
| return; |
| } |
| case LirOpcodes.INVOKEDIRECT: |
| case LirOpcodes.INVOKEDIRECT_ITF: |
| { |
| DexMethod target = getInvokeInstructionTarget(view); |
| List<EV> arguments = getInvokeInstructionArguments(view); |
| onInvokeDirect(target, arguments, opcode == LirOpcodes.INVOKEDIRECT_ITF); |
| return; |
| } |
| case LirOpcodes.INVOKESUPER: |
| case LirOpcodes.INVOKESUPER_ITF: |
| { |
| DexMethod target = getInvokeInstructionTarget(view); |
| List<EV> arguments = getInvokeInstructionArguments(view); |
| onInvokeSuper(target, arguments, opcode == LirOpcodes.INVOKESUPER_ITF); |
| return; |
| } |
| case LirOpcodes.INVOKEVIRTUAL: |
| { |
| DexMethod target = getInvokeInstructionTarget(view); |
| List<EV> arguments = getInvokeInstructionArguments(view); |
| onInvokeVirtual(target, arguments); |
| return; |
| } |
| case LirOpcodes.INVOKESTATIC: |
| case LirOpcodes.INVOKESTATIC_ITF: |
| { |
| DexMethod target = getInvokeInstructionTarget(view); |
| List<EV> arguments = getInvokeInstructionArguments(view); |
| onInvokeStatic(target, arguments, opcode == LirOpcodes.INVOKESTATIC_ITF); |
| return; |
| } |
| case LirOpcodes.INVOKEINTERFACE: |
| { |
| DexMethod target = getInvokeInstructionTarget(view); |
| List<EV> arguments = getInvokeInstructionArguments(view); |
| onInvokeInterface(target, arguments); |
| return; |
| } |
| case LirOpcodes.INVOKEDYNAMIC: |
| { |
| DexCallSite callSite = (DexCallSite) getConstantItem(view.getNextConstantOperand()); |
| List<EV> arguments = getInvokeInstructionArguments(view); |
| onInvokeCustom(callSite, arguments); |
| return; |
| } |
| case LirOpcodes.INVOKEPOLYMORPHIC: |
| { |
| DexMethod target = getInvokeInstructionTarget(view); |
| DexProto proto = (DexProto) getConstantItem(view.getNextConstantOperand()); |
| List<EV> arguments = getInvokeInstructionArguments(view); |
| onInvokePolymorphic(target, proto, arguments); |
| return; |
| } |
| case LirOpcodes.NEW: |
| { |
| DexItem item = getConstantItem(view.getNextConstantOperand()); |
| if (item instanceof DexType) { |
| onNewInstance((DexType) item); |
| return; |
| } |
| throw new Unimplemented(); |
| } |
| case LirOpcodes.GETSTATIC: |
| { |
| DexField field = (DexField) getConstantItem(view.getNextConstantOperand()); |
| onStaticGet(field); |
| return; |
| } |
| case LirOpcodes.PUTSTATIC: |
| { |
| DexField field = (DexField) getConstantItem(view.getNextConstantOperand()); |
| EV value = getNextValueOperand(view); |
| onStaticPut(field, value); |
| return; |
| } |
| case LirOpcodes.GETFIELD: |
| { |
| DexField field = (DexField) getConstantItem(view.getNextConstantOperand()); |
| EV object = getNextValueOperand(view); |
| onInstanceGet(field, object); |
| return; |
| } |
| case LirOpcodes.PUTFIELD: |
| { |
| DexField field = (DexField) getConstantItem(view.getNextConstantOperand()); |
| EV object = getNextValueOperand(view); |
| EV value = getNextValueOperand(view); |
| onInstancePut(field, object, value); |
| return; |
| } |
| case LirOpcodes.NEWARRAY: |
| { |
| DexType type = getNextDexTypeOperand(view); |
| EV size = getNextValueOperand(view); |
| onNewArrayEmpty(type, size); |
| return; |
| } |
| case LirOpcodes.ATHROW: |
| { |
| EV exception = getNextValueOperand(view); |
| onThrow(exception); |
| return; |
| } |
| case LirOpcodes.RETURN: |
| { |
| onReturnVoid(); |
| return; |
| } |
| case LirOpcodes.ARETURN: |
| { |
| EV value = getNextValueOperand(view); |
| onReturn(value); |
| return; |
| } |
| case LirOpcodes.ARRAYLENGTH: |
| { |
| onArrayLength(getNextValueOperand(view)); |
| return; |
| } |
| case LirOpcodes.CHECKCAST: |
| { |
| DexType type = getNextDexTypeOperand(view); |
| EV value = getNextValueOperand(view); |
| onCheckCast(type, value); |
| return; |
| } |
| case LirOpcodes.CHECKCAST_SAFE: |
| { |
| DexType type = getNextDexTypeOperand(view); |
| EV value = getNextValueOperand(view); |
| onSafeCheckCast(type, value); |
| return; |
| } |
| case LirOpcodes.INSTANCEOF: |
| { |
| DexType type = getNextDexTypeOperand(view); |
| EV value = getNextValueOperand(view); |
| onInstanceOf(type, value); |
| return; |
| } |
| case LirOpcodes.DEBUGPOS: |
| { |
| onDebugPosition(); |
| return; |
| } |
| case LirOpcodes.PHI: |
| { |
| DexType type = getNextDexTypeOperand(view); |
| List<EV> operands = new ArrayList<>(); |
| while (view.hasMoreOperands()) { |
| operands.add(getNextValueOperand(view)); |
| } |
| onPhi(type, operands); |
| return; |
| } |
| case LirOpcodes.FALLTHROUGH: |
| { |
| onFallthrough(); |
| return; |
| } |
| case LirOpcodes.MOVEEXCEPTION: |
| { |
| DexType type = getNextDexTypeOperand(view); |
| onMoveException(type); |
| return; |
| } |
| case LirOpcodes.MONITORENTER: |
| { |
| EV value = getNextValueOperand(view); |
| onMonitorEnter(value); |
| return; |
| } |
| case LirOpcodes.MONITOREXIT: |
| { |
| EV value = getNextValueOperand(view); |
| onMonitorExit(value); |
| return; |
| } |
| case LirOpcodes.DEBUGLOCALWRITE: |
| { |
| EV srcIndex = getNextValueOperand(view); |
| onDebugLocalWrite(srcIndex); |
| return; |
| } |
| case LirOpcodes.DEBUGLOCALREAD: |
| { |
| onDebugLocalRead(); |
| return; |
| } |
| case LirOpcodes.MULTIANEWARRAY: |
| { |
| DexType type = getNextDexTypeOperand(view); |
| List<EV> arguments = getInvokeInstructionArguments(view); |
| onInvokeMultiNewArray(type, arguments); |
| return; |
| } |
| case LirOpcodes.INVOKENEWARRAY: |
| { |
| DexType type = getNextDexTypeOperand(view); |
| List<EV> arguments = getInvokeInstructionArguments(view); |
| onInvokeNewArray(type, arguments); |
| return; |
| } |
| case LirOpcodes.NEWARRAYFILLEDDATA: |
| { |
| FillArrayPayload payload = |
| (FillArrayPayload) getConstantItem(view.getNextConstantOperand()); |
| EV src = getNextValueOperand(view); |
| onNewArrayFilledData(payload.element_width, payload.size, payload.data, src); |
| return; |
| } |
| case LirOpcodes.LCMP: |
| case LirOpcodes.FCMPL: |
| case LirOpcodes.FCMPG: |
| case LirOpcodes.DCMPL: |
| case LirOpcodes.DCMPG: |
| { |
| EV leftValue = getNextValueOperand(view); |
| EV rightValue = getNextValueOperand(view); |
| onCmpInstruction(opcode, leftValue, rightValue); |
| return; |
| } |
| case LirOpcodes.ITEMBASEDCONSTSTRING: |
| { |
| DexReference item = (DexReference) getConstantItem(view.getNextConstantOperand()); |
| NameComputationPayload payload = |
| (NameComputationPayload) getConstantItem(view.getNextConstantOperand()); |
| onDexItemBasedConstString(item, payload.nameComputationInfo); |
| return; |
| } |
| case LirOpcodes.NEWUNBOXEDENUMINSTANCE: |
| { |
| DexType type = getNextDexTypeOperand(view); |
| int ordinal = view.getNextIntegerOperand(); |
| onNewUnboxedEnumInstance(type, ordinal); |
| return; |
| } |
| case LirOpcodes.INOT: |
| case LirOpcodes.LNOT: |
| { |
| EV value = getNextValueOperand(view); |
| onNot(opcode == LirOpcodes.INOT ? NumericType.INT : NumericType.LONG, value); |
| return; |
| } |
| case LirOpcodes.INITCLASS: |
| { |
| DexType clazz = getNextDexTypeOperand(view); |
| onInitClass(clazz); |
| return; |
| } |
| case LirOpcodes.RECORDFIELDVALUES: |
| { |
| RecordFieldValuesPayload payload = |
| (RecordFieldValuesPayload) getConstantItem(view.getNextConstantOperand()); |
| List<EV> values = getInvokeInstructionArguments(view); |
| onRecordFieldValues(payload.fields, values); |
| return; |
| } |
| default: |
| throw new Unimplemented("No dispatch for opcode " + LirOpcodes.toString(opcode)); |
| } |
| } |
| |
| private DexMethod getInvokeInstructionTarget(LirInstructionView view) { |
| return (DexMethod) getConstantItem(view.getNextConstantOperand()); |
| } |
| |
| private List<EV> getInvokeInstructionArguments(LirInstructionView view) { |
| List<EV> arguments = new ArrayList<>(); |
| while (view.hasMoreOperands()) { |
| arguments.add(getNextValueOperand(view)); |
| } |
| return arguments; |
| } |
| } |
