/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "slicer/dex_bytecode.h"
#include "slicer/common.h"
#include <assert.h>
#include <array>
namespace dex {
Opcode OpcodeFromBytecode(u2 bytecode) {
Opcode opcode = Opcode(bytecode & 0xff);
SLICER_CHECK(opcode != OP_UNUSED_FF);
return opcode;
}
// Table that maps each opcode to the index type implied by that opcode
static constexpr std::array<InstructionIndexType, kNumPackedOpcodes>
gInstructionIndexTypeTable = {
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexStringRef,
kIndexStringRef, kIndexTypeRef, kIndexNone,
kIndexNone, kIndexTypeRef, kIndexTypeRef,
kIndexNone, kIndexTypeRef, kIndexTypeRef,
kIndexTypeRef, kIndexTypeRef, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexMethodRef,
kIndexMethodRef, kIndexMethodRef, kIndexMethodRef,
kIndexMethodRef, kIndexUnknown, kIndexMethodRef,
kIndexMethodRef, kIndexMethodRef, kIndexMethodRef,
kIndexMethodRef, kIndexUnknown, kIndexUnknown,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexUnknown,
kIndexVaries, kIndexInlineMethod, kIndexInlineMethod,
kIndexMethodRef, kIndexNone, kIndexFieldOffset,
kIndexFieldOffset, kIndexFieldOffset, kIndexFieldOffset,
kIndexFieldOffset, kIndexFieldOffset, kIndexVtableOffset,
kIndexVtableOffset, kIndexVtableOffset, kIndexVtableOffset,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexUnknown,
};
InstructionIndexType GetIndexTypeFromOpcode(Opcode opcode) {
return gInstructionIndexTypeTable[opcode];
}
// Table that maps each opcode to the full width of instructions that
// use that opcode, in (16-bit) code units. Unimplemented opcodes as
// well as the "breakpoint" opcode have a width of zero.
static constexpr std::array<u1, kNumPackedOpcodes> gInstructionWidthTable = {
1, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 2, 3,
5, 2, 2, 3, 2, 1, 1, 2, 2, 1, 2, 2, 3, 3, 3, 1, 1, 2, 3, 3, 3, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3,
3, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 3, 3,
3, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 0,
};
size_t GetWidthFromOpcode(Opcode opcode) {
return gInstructionWidthTable[opcode];
}
size_t GetWidthFromBytecode(const u2* bytecode) {
size_t width = 0;
if (*bytecode == kPackedSwitchSignature) {
width = 4 + bytecode[1] * 2;
} else if (*bytecode == kSparseSwitchSignature) {
width = 2 + bytecode[1] * 4;
} else if (*bytecode == kArrayDataSignature) {
u2 elemWidth = bytecode[1];
u4 len = bytecode[2] | (((u4)bytecode[3]) << 16);
// The plus 1 is to round up for odd size and width.
width = 4 + (elemWidth * len + 1) / 2;
} else {
width = GetWidthFromOpcode(OpcodeFromBytecode(bytecode[0]));
}
return width;
}
// Table that maps each opcode to the instruction flags
static constexpr std::array<OpcodeFlags, kNumPackedOpcodes> gOpcodeFlagsTable = {
/* NOP */ kInstrCanContinue,
/* MOVE */ kInstrCanContinue,
/* MOVE_FROM16 */ kInstrCanContinue,
/* MOVE_16 */ kInstrCanContinue,
/* MOVE_WIDE */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* MOVE_WIDE_FROM16 */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* MOVE_WIDE_16 */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* MOVE_OBJECT */ kInstrCanContinue,
/* MOVE_OBJECT_FROM16 */ kInstrCanContinue,
/* MOVE_OBJECT_16 */ kInstrCanContinue,
/* MOVE_RESULT */ kInstrCanContinue,
/* MOVE_RESULT_WIDE */ kInstrCanContinue|kInstrWideRegA,
/* MOVE_RESULT_OBJECT */ kInstrCanContinue,
/* MOVE_EXCEPTION */ kInstrCanContinue,
/* RETURN_VOID */ kInstrCanReturn,
/* RETURN */ kInstrCanReturn,
/* RETURN_WIDE */ kInstrCanReturn|kInstrWideRegA,
/* RETURN_OBJECT */ kInstrCanReturn,
/* CONST_4 */ kInstrCanContinue,
/* CONST_16 */ kInstrCanContinue,
/* CONST */ kInstrCanContinue,
/* CONST_HIGH16 */ kInstrCanContinue,
/* CONST_WIDE_16 */ kInstrCanContinue|kInstrWideRegA,
/* CONST_WIDE_32 */ kInstrCanContinue|kInstrWideRegA,
/* CONST_WIDE */ kInstrCanContinue|kInstrWideRegA,
/* CONST_WIDE_HIGH16 */ kInstrCanContinue|kInstrWideRegA,
/* CONST_STRING */ kInstrCanContinue|kInstrCanThrow,
/* CONST_STRING_JUMBO */ kInstrCanContinue|kInstrCanThrow,
/* CONST_CLASS */ kInstrCanContinue|kInstrCanThrow,
/* MONITOR_ENTER */ kInstrCanContinue|kInstrCanThrow,
/* MONITOR_EXIT */ kInstrCanContinue|kInstrCanThrow,
/* SLICER_CHECK_CAST */ kInstrCanContinue|kInstrCanThrow,
/* INSTANCE_OF */ kInstrCanContinue|kInstrCanThrow,
/* ARRAY_LENGTH */ kInstrCanContinue|kInstrCanThrow,
/* NEW_INSTANCE */ kInstrCanContinue|kInstrCanThrow,
/* NEW_ARRAY */ kInstrCanContinue|kInstrCanThrow,
/* FILLED_NEW_ARRAY */ kInstrCanContinue|kInstrCanThrow,
/* FILLED_NEW_ARRAY_RANGE */ kInstrCanContinue|kInstrCanThrow,
/* FILL_ARRAY_DATA */ kInstrCanContinue,
/* THROW */ kInstrCanThrow,
/* GOTO */ kInstrCanBranch,
/* GOTO_16 */ kInstrCanBranch,
/* GOTO_32 */ kInstrCanBranch,
/* PACKED_SWITCH */ kInstrCanContinue|kInstrCanSwitch,
/* SPARSE_SWITCH */ kInstrCanContinue|kInstrCanSwitch,
/* CMPL_FLOAT */ kInstrCanContinue,
/* CMPG_FLOAT */ kInstrCanContinue,
/* CMPL_DOUBLE */ kInstrCanContinue|kInstrWideRegB|kInstrWideRegC,
/* CMPG_DOUBLE */ kInstrCanContinue|kInstrWideRegB|kInstrWideRegC,
/* CMP_LONG */ kInstrCanContinue|kInstrWideRegB|kInstrWideRegC,
/* IF_EQ */ kInstrCanContinue|kInstrCanBranch,
/* IF_NE */ kInstrCanContinue|kInstrCanBranch,
/* IF_LT */ kInstrCanContinue|kInstrCanBranch,
/* IF_GE */ kInstrCanContinue|kInstrCanBranch,
/* IF_GT */ kInstrCanContinue|kInstrCanBranch,
/* IF_LE */ kInstrCanContinue|kInstrCanBranch,
/* IF_EQZ */ kInstrCanContinue|kInstrCanBranch,
/* IF_NEZ */ kInstrCanContinue|kInstrCanBranch,
/* IF_LTZ */ kInstrCanContinue|kInstrCanBranch,
/* IF_GEZ */ kInstrCanContinue|kInstrCanBranch,
/* IF_GTZ */ kInstrCanContinue|kInstrCanBranch,
/* IF_LEZ */ kInstrCanContinue|kInstrCanBranch,
/* UNUSED_3E */ 0,
/* UNUSED_3F */ 0,
/* UNUSED_40 */ 0,
/* UNUSED_41 */ 0,
/* UNUSED_42 */ 0,
/* UNUSED_43 */ 0,
/* AGET */ kInstrCanContinue|kInstrCanThrow,
/* AGET_WIDE */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* AGET_OBJECT */ kInstrCanContinue|kInstrCanThrow,
/* AGET_BOOLEAN */ kInstrCanContinue|kInstrCanThrow,
/* AGET_BYTE */ kInstrCanContinue|kInstrCanThrow,
/* AGET_CHAR */ kInstrCanContinue|kInstrCanThrow,
/* AGET_SHORT */ kInstrCanContinue|kInstrCanThrow,
/* APUT */ kInstrCanContinue|kInstrCanThrow,
/* APUT_WIDE */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* APUT_OBJECT */ kInstrCanContinue|kInstrCanThrow,
/* APUT_BOOLEAN */ kInstrCanContinue|kInstrCanThrow,
/* APUT_BYTE */ kInstrCanContinue|kInstrCanThrow,
/* APUT_CHAR */ kInstrCanContinue|kInstrCanThrow,
/* APUT_SHORT */ kInstrCanContinue|kInstrCanThrow,
/* IGET */ kInstrCanContinue|kInstrCanThrow,
/* IGET_WIDE */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* IGET_OBJECT */ kInstrCanContinue|kInstrCanThrow,
/* IGET_BOOLEAN */ kInstrCanContinue|kInstrCanThrow,
/* IGET_BYTE */ kInstrCanContinue|kInstrCanThrow,
/* IGET_CHAR */ kInstrCanContinue|kInstrCanThrow,
/* IGET_SHORT */ kInstrCanContinue|kInstrCanThrow,
/* IPUT */ kInstrCanContinue|kInstrCanThrow,
/* IPUT_WIDE */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* IPUT_OBJECT */ kInstrCanContinue|kInstrCanThrow,
/* IPUT_BOOLEAN */ kInstrCanContinue|kInstrCanThrow,
/* IPUT_BYTE */ kInstrCanContinue|kInstrCanThrow,
/* IPUT_CHAR */ kInstrCanContinue|kInstrCanThrow,
/* IPUT_SHORT */ kInstrCanContinue|kInstrCanThrow,
/* SGET */ kInstrCanContinue|kInstrCanThrow,
/* SGET_WIDE */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* SGET_OBJECT */ kInstrCanContinue|kInstrCanThrow,
/* SGET_BOOLEAN */ kInstrCanContinue|kInstrCanThrow,
/* SGET_BYTE */ kInstrCanContinue|kInstrCanThrow,
/* SGET_CHAR */ kInstrCanContinue|kInstrCanThrow,
/* SGET_SHORT */ kInstrCanContinue|kInstrCanThrow,
/* SPUT */ kInstrCanContinue|kInstrCanThrow,
/* SPUT_WIDE */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* SPUT_OBJECT */ kInstrCanContinue|kInstrCanThrow,
/* SPUT_BOOLEAN */ kInstrCanContinue|kInstrCanThrow,
/* SPUT_BYTE */ kInstrCanContinue|kInstrCanThrow,
/* SPUT_CHAR */ kInstrCanContinue|kInstrCanThrow,
/* SPUT_SHORT */ kInstrCanContinue|kInstrCanThrow,
/* INVOKE_VIRTUAL */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* INVOKE_SUPER */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* INVOKE_DIRECT */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* INVOKE_STATIC */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* INVOKE_INTERFACE */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* UNUSED_73 */ 0,
/* INVOKE_VIRTUAL_RANGE */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* INVOKE_SUPER_RANGE */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* INVOKE_DIRECT_RANGE */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* INVOKE_STATIC_RANGE */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* INVOKE_INTERFACE_RANGE */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* UNUSED_79 */ 0,
/* UNUSED_7A */ 0,
/* NEG_INT */ kInstrCanContinue,
/* NOT_INT */ kInstrCanContinue,
/* NEG_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* NOT_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* NEG_FLOAT */ kInstrCanContinue,
/* NEG_DOUBLE */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* INT_TO_LONG */ kInstrCanContinue|kInstrWideRegA,
/* INT_TO_FLOAT */ kInstrCanContinue,
/* INT_TO_DOUBLE */ kInstrCanContinue|kInstrWideRegA,
/* LONG_TO_INT */ kInstrCanContinue|kInstrWideRegB,
/* LONG_TO_FLOAT */ kInstrCanContinue|kInstrWideRegB,
/* LONG_TO_DOUBLE */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* FLOAT_TO_INT */ kInstrCanContinue,
/* FLOAT_TO_LONG */ kInstrCanContinue|kInstrWideRegA,
/* FLOAT_TO_DOUBLE */ kInstrCanContinue|kInstrWideRegA,
/* DOUBLE_TO_INT */ kInstrCanContinue|kInstrWideRegB,
/* DOUBLE_TO_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* DOUBLE_TO_FLOAT */ kInstrCanContinue|kInstrWideRegB,
/* INT_TO_BYTE */ kInstrCanContinue,
/* INT_TO_CHAR */ kInstrCanContinue,
/* INT_TO_SHORT */ kInstrCanContinue,
/* ADD_INT */ kInstrCanContinue,
/* SUB_INT */ kInstrCanContinue,
/* MUL_INT */ kInstrCanContinue,
/* DIV_INT */ kInstrCanContinue|kInstrCanThrow,
/* REM_INT */ kInstrCanContinue|kInstrCanThrow,
/* AND_INT */ kInstrCanContinue,
/* OR_INT */ kInstrCanContinue,
/* XOR_INT */ kInstrCanContinue,
/* SHL_INT */ kInstrCanContinue,
/* SHR_INT */ kInstrCanContinue,
/* USHR_INT */ kInstrCanContinue,
/* ADD_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* SUB_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* MUL_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* DIV_LONG */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* REM_LONG */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* AND_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* OR_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* XOR_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* SHL_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* SHR_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* USHR_LONG */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* ADD_FLOAT */ kInstrCanContinue,
/* SUB_FLOAT */ kInstrCanContinue,
/* MUL_FLOAT */ kInstrCanContinue,
/* DIV_FLOAT */ kInstrCanContinue,
/* REM_FLOAT */ kInstrCanContinue,
/* ADD_DOUBLE */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* SUB_DOUBLE */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* MUL_DOUBLE */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* DIV_DOUBLE */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* REM_DOUBLE */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB|kInstrWideRegC,
/* ADD_INT_2ADDR */ kInstrCanContinue,
/* SUB_INT_2ADDR */ kInstrCanContinue,
/* MUL_INT_2ADDR */ kInstrCanContinue,
/* DIV_INT_2ADDR */ kInstrCanContinue|kInstrCanThrow,
/* REM_INT_2ADDR */ kInstrCanContinue|kInstrCanThrow,
/* AND_INT_2ADDR */ kInstrCanContinue,
/* OR_INT_2ADDR */ kInstrCanContinue,
/* XOR_INT_2ADDR */ kInstrCanContinue,
/* SHL_INT_2ADDR */ kInstrCanContinue,
/* SHR_INT_2ADDR */ kInstrCanContinue,
/* USHR_INT_2ADDR */ kInstrCanContinue,
/* ADD_LONG_2ADDR */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* SUB_LONG_2ADDR */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* MUL_LONG_2ADDR */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* DIV_LONG_2ADDR */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA|kInstrWideRegB,
/* REM_LONG_2ADDR */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA|kInstrWideRegB,
/* AND_LONG_2ADDR */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* OR_LONG_2ADDR */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* XOR_LONG_2ADDR */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* SHL_LONG_2ADDR */ kInstrCanContinue|kInstrWideRegA,
/* SHR_LONG_2ADDR */ kInstrCanContinue|kInstrWideRegA,
/* USHR_LONG_2ADDR */ kInstrCanContinue|kInstrWideRegA,
/* ADD_FLOAT_2ADDR */ kInstrCanContinue,
/* SUB_FLOAT_2ADDR */ kInstrCanContinue,
/* MUL_FLOAT_2ADDR */ kInstrCanContinue,
/* DIV_FLOAT_2ADDR */ kInstrCanContinue,
/* REM_FLOAT_2ADDR */ kInstrCanContinue,
/* ADD_DOUBLE_2ADDR */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* SUB_DOUBLE_2ADDR */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* MUL_DOUBLE_2ADDR */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* DIV_DOUBLE_2ADDR */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* REM_DOUBLE_2ADDR */ kInstrCanContinue|kInstrWideRegA|kInstrWideRegB,
/* ADD_INT_LIT16 */ kInstrCanContinue,
/* RSUB_INT */ kInstrCanContinue,
/* MUL_INT_LIT16 */ kInstrCanContinue,
/* DIV_INT_LIT16 */ kInstrCanContinue|kInstrCanThrow,
/* REM_INT_LIT16 */ kInstrCanContinue|kInstrCanThrow,
/* AND_INT_LIT16 */ kInstrCanContinue,
/* OR_INT_LIT16 */ kInstrCanContinue,
/* XOR_INT_LIT16 */ kInstrCanContinue,
/* ADD_INT_LIT8 */ kInstrCanContinue,
/* RSUB_INT_LIT8 */ kInstrCanContinue,
/* MUL_INT_LIT8 */ kInstrCanContinue,
/* DIV_INT_LIT8 */ kInstrCanContinue|kInstrCanThrow,
/* REM_INT_LIT8 */ kInstrCanContinue|kInstrCanThrow,
/* AND_INT_LIT8 */ kInstrCanContinue,
/* OR_INT_LIT8 */ kInstrCanContinue,
/* XOR_INT_LIT8 */ kInstrCanContinue,
/* SHL_INT_LIT8 */ kInstrCanContinue,
/* SHR_INT_LIT8 */ kInstrCanContinue,
/* USHR_INT_LIT8 */ kInstrCanContinue,
/* IGET_VOLATILE */ kInstrCanContinue|kInstrCanThrow,
/* IPUT_VOLATILE */ kInstrCanContinue|kInstrCanThrow,
/* SGET_VOLATILE */ kInstrCanContinue|kInstrCanThrow,
/* SPUT_VOLATILE */ kInstrCanContinue|kInstrCanThrow,
/* IGET_OBJECT_VOLATILE */ kInstrCanContinue|kInstrCanThrow,
/* IGET_WIDE_VOLATILE */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* IPUT_WIDE_VOLATILE */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* SGET_WIDE_VOLATILE */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* SPUT_WIDE_VOLATILE */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* BREAKPOINT */ 0,
/* THROW_VERIFICATION_ERROR */ kInstrCanThrow,
/* EXECUTE_INLINE */ kInstrCanContinue|kInstrCanThrow,
/* EXECUTE_INLINE_RANGE */ kInstrCanContinue|kInstrCanThrow,
/* INVOKE_OBJECT_INIT_RANGE */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* RETURN_VOID_BARRIER */ kInstrCanReturn,
/* IGET_QUICK */ kInstrCanContinue|kInstrCanThrow,
/* IGET_WIDE_QUICK */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* IGET_OBJECT_QUICK */ kInstrCanContinue|kInstrCanThrow,
/* IPUT_QUICK */ kInstrCanContinue|kInstrCanThrow,
/* IPUT_WIDE_QUICK */ kInstrCanContinue|kInstrCanThrow|kInstrWideRegA,
/* IPUT_OBJECT_QUICK */ kInstrCanContinue|kInstrCanThrow,
/* INVOKE_VIRTUAL_QUICK */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* INVOKE_VIRTUAL_QUICK_RANGE */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* INVOKE_SUPER_QUICK */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* INVOKE_SUPER_QUICK_RANGE */ kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
/* IPUT_OBJECT_VOLATILE */ kInstrCanContinue|kInstrCanThrow,
/* SGET_OBJECT_VOLATILE */ kInstrCanContinue|kInstrCanThrow,
/* SPUT_OBJECT_VOLATILE */ kInstrCanContinue|kInstrCanThrow,
/* UNUSED_FF */ 0,
};
// Table that maps each opcode to the instruction format
static constexpr std::array<InstructionFormat, kNumPackedOpcodes> gInstructionFormatTable = {
kFmt10x, kFmt12x, kFmt22x, kFmt32x, kFmt12x, kFmt22x, kFmt32x,
kFmt12x, kFmt22x, kFmt32x, kFmt11x, kFmt11x, kFmt11x, kFmt11x,
kFmt10x, kFmt11x, kFmt11x, kFmt11x, kFmt11n, kFmt21s, kFmt31i,
kFmt21h, kFmt21s, kFmt31i, kFmt51l, kFmt21h, kFmt21c, kFmt31c,
kFmt21c, kFmt11x, kFmt11x, kFmt21c, kFmt22c, kFmt12x, kFmt21c,
kFmt22c, kFmt35c, kFmt3rc, kFmt31t, kFmt11x, kFmt10t, kFmt20t,
kFmt30t, kFmt31t, kFmt31t, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt22t, kFmt22t, kFmt22t, kFmt22t, kFmt22t, kFmt22t,
kFmt21t, kFmt21t, kFmt21t, kFmt21t, kFmt21t, kFmt21t, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt22c, kFmt22c,
kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c,
kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt21c, kFmt21c,
kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c,
kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt35c, kFmt35c,
kFmt35c, kFmt35c, kFmt35c, kFmt00x, kFmt3rc, kFmt3rc, kFmt3rc,
kFmt3rc, kFmt3rc, kFmt00x, kFmt00x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt22s, kFmt22s,
kFmt22s, kFmt22s, kFmt22s, kFmt22s, kFmt22s, kFmt22s, kFmt22b,
kFmt22b, kFmt22b, kFmt22b, kFmt22b, kFmt22b, kFmt22b, kFmt22b,
kFmt22b, kFmt22b, kFmt22b, kFmt22c, kFmt22c, kFmt21c, kFmt21c,
kFmt22c, kFmt22c, kFmt22c, kFmt21c, kFmt21c, kFmt00x, kFmt20bc,
kFmt35mi, kFmt3rmi, kFmt35c, kFmt10x, kFmt22cs, kFmt22cs, kFmt22cs,
kFmt22cs, kFmt22cs, kFmt22cs, kFmt35ms, kFmt3rms, kFmt35ms, kFmt3rms,
kFmt22c, kFmt21c, kFmt21c, kFmt00x,
};
InstructionFormat GetFormatFromOpcode(Opcode opcode) {
return gInstructionFormatTable[opcode];
}
OpcodeFlags GetFlagsFromOpcode(Opcode opcode) {
return gOpcodeFlagsTable[opcode];
}
// Dalvik opcode names.
static constexpr std::array<const char*, kNumPackedOpcodes> gOpcodeNames = {
"nop",
"move",
"move/from16",
"move/16",
"move-wide",
"move-wide/from16",
"move-wide/16",
"move-object",
"move-object/from16",
"move-object/16",
"move-result",
"move-result-wide",
"move-result-object",
"move-exception",
"return-void",
"return",
"return-wide",
"return-object",
"const/4",
"const/16",
"const",
"const/high16",
"const-wide/16",
"const-wide/32",
"const-wide",
"const-wide/high16",
"const-string",
"const-string/jumbo",
"const-class",
"monitor-enter",
"monitor-exit",
"check-cast",
"instance-of",
"array-length",
"new-instance",
"new-array",
"filled-new-array",
"filled-new-array/range",
"fill-array-data",
"throw",
"goto",
"goto/16",
"goto/32",
"packed-switch",
"sparse-switch",
"cmpl-float",
"cmpg-float",
"cmpl-double",
"cmpg-double",
"cmp-long",
"if-eq",
"if-ne",
"if-lt",
"if-ge",
"if-gt",
"if-le",
"if-eqz",
"if-nez",
"if-ltz",
"if-gez",
"if-gtz",
"if-lez",
"unused-3e",
"unused-3f",
"unused-40",
"unused-41",
"unused-42",
"unused-43",
"aget",
"aget-wide",
"aget-object",
"aget-boolean",
"aget-byte",
"aget-char",
"aget-short",
"aput",
"aput-wide",
"aput-object",
"aput-boolean",
"aput-byte",
"aput-char",
"aput-short",
"iget",
"iget-wide",
"iget-object",
"iget-boolean",
"iget-byte",
"iget-char",
"iget-short",
"iput",
"iput-wide",
"iput-object",
"iput-boolean",
"iput-byte",
"iput-char",
"iput-short",
"sget",
"sget-wide",
"sget-object",
"sget-boolean",
"sget-byte",
"sget-char",
"sget-short",
"sput",
"sput-wide",
"sput-object",
"sput-boolean",
"sput-byte",
"sput-char",
"sput-short",
"invoke-virtual",
"invoke-super",
"invoke-direct",
"invoke-static",
"invoke-interface",
"unused-73",
"invoke-virtual/range",
"invoke-super/range",
"invoke-direct/range",
"invoke-static/range",
"invoke-interface/range",
"unused-79",
"unused-7a",
"neg-int",
"not-int",
"neg-long",
"not-long",
"neg-float",
"neg-double",
"int-to-long",
"int-to-float",
"int-to-double",
"long-to-int",
"long-to-float",
"long-to-double",
"float-to-int",
"float-to-long",
"float-to-double",
"double-to-int",
"double-to-long",
"double-to-float",
"int-to-byte",
"int-to-char",
"int-to-short",
"add-int",
"sub-int",
"mul-int",
"div-int",
"rem-int",
"and-int",
"or-int",
"xor-int",
"shl-int",
"shr-int",
"ushr-int",
"add-long",
"sub-long",
"mul-long",
"div-long",
"rem-long",
"and-long",
"or-long",
"xor-long",
"shl-long",
"shr-long",
"ushr-long",
"add-float",
"sub-float",
"mul-float",
"div-float",
"rem-float",
"add-double",
"sub-double",
"mul-double",
"div-double",
"rem-double",
"add-int/2addr",
"sub-int/2addr",
"mul-int/2addr",
"div-int/2addr",
"rem-int/2addr",
"and-int/2addr",
"or-int/2addr",
"xor-int/2addr",
"shl-int/2addr",
"shr-int/2addr",
"ushr-int/2addr",
"add-long/2addr",
"sub-long/2addr",
"mul-long/2addr",
"div-long/2addr",
"rem-long/2addr",
"and-long/2addr",
"or-long/2addr",
"xor-long/2addr",
"shl-long/2addr",
"shr-long/2addr",
"ushr-long/2addr",
"add-float/2addr",
"sub-float/2addr",
"mul-float/2addr",
"div-float/2addr",
"rem-float/2addr",
"add-double/2addr",
"sub-double/2addr",
"mul-double/2addr",
"div-double/2addr",
"rem-double/2addr",
"add-int/lit16",
"rsub-int",
"mul-int/lit16",
"div-int/lit16",
"rem-int/lit16",
"and-int/lit16",
"or-int/lit16",
"xor-int/lit16",
"add-int/lit8",
"rsub-int/lit8",
"mul-int/lit8",
"div-int/lit8",
"rem-int/lit8",
"and-int/lit8",
"or-int/lit8",
"xor-int/lit8",
"shl-int/lit8",
"shr-int/lit8",
"ushr-int/lit8",
"+iget-volatile",
"+iput-volatile",
"+sget-volatile",
"+sput-volatile",
"+iget-object-volatile",
"+iget-wide-volatile",
"+iput-wide-volatile",
"+sget-wide-volatile",
"+sput-wide-volatile",
"^breakpoint",
"^throw-verification-error",
"+execute-inline",
"+execute-inline/range",
"+invoke-object-init/range",
"+return-void-barrier",
"+iget-quick",
"+iget-wide-quick",
"+iget-object-quick",
"+iput-quick",
"+iput-wide-quick",
"+iput-object-quick",
"+invoke-virtual-quick",
"+invoke-virtual-quick/range",
"+invoke-super-quick",
"+invoke-super-quick/range",
"+iput-object-volatile",
"+sget-object-volatile",
"+sput-object-volatile",
"unused-ff",
};
const char* GetOpcodeName(Opcode opcode) { return gOpcodeNames[opcode]; }
// Helpers for DecodeInstruction()
static u4 InstA(u2 inst) { return (inst >> 8) & 0x0f; }
static u4 InstB(u2 inst) { return inst >> 12; }
static u4 InstAA(u2 inst) { return inst >> 8; }
// Helper for DecodeInstruction()
static u4 FetchU4(const u2* ptr) {
return ptr[0] | (u4(ptr[1]) << 16);
}
// Helper for DecodeInstruction()
static u8 FetchU8(const u2* ptr) {
return FetchU4(ptr) | (u8(FetchU4(ptr + 2)) << 32);
}
// Decode a Dalvik bytecode and extract the individual fields
Instruction DecodeInstruction(const u2* bytecode) {
u2 inst = bytecode[0];
Opcode opcode = OpcodeFromBytecode(inst);
InstructionFormat format = GetFormatFromOpcode(opcode);
Instruction dec = {};
dec.opcode = opcode;
switch (format) {
case kFmt10x: // op
break;
case kFmt12x: // op vA, vB
dec.vA = InstA(inst);
dec.vB = InstB(inst);
break;
case kFmt11n: // op vA, #+B
dec.vA = InstA(inst);
dec.vB = s4(InstB(inst) << 28) >> 28; // sign extend 4-bit value
break;
case kFmt11x: // op vAA
dec.vA = InstAA(inst);
break;
case kFmt10t: // op +AA
dec.vA = s1(InstAA(inst)); // sign-extend 8-bit value
break;
case kFmt20t: // op +AAAA
dec.vA = s2(bytecode[1]); // sign-extend 16-bit value
break;
case kFmt20bc: // [opt] op AA, thing@BBBB
case kFmt21c: // op vAA, thing@BBBB
case kFmt22x: // op vAA, vBBBB
dec.vA = InstAA(inst);
dec.vB = bytecode[1];
break;
case kFmt21s: // op vAA, #+BBBB
case kFmt21t: // op vAA, +BBBB
dec.vA = InstAA(inst);
dec.vB = s2(bytecode[1]); // sign-extend 16-bit value
break;
case kFmt21h: // op vAA, #+BBBB0000[00000000]
dec.vA = InstAA(inst);
// The value should be treated as right-zero-extended, but we don't
// actually do that here. Among other things, we don't know if it's
// the top bits of a 32- or 64-bit value.
dec.vB = bytecode[1];
break;
case kFmt23x: // op vAA, vBB, vCC
dec.vA = InstAA(inst);
dec.vB = bytecode[1] & 0xff;
dec.vC = bytecode[1] >> 8;
break;
case kFmt22b: // op vAA, vBB, #+CC
dec.vA = InstAA(inst);
dec.vB = bytecode[1] & 0xff;
dec.vC = s1(bytecode[1] >> 8); // sign-extend 8-bit value
break;
case kFmt22s: // op vA, vB, #+CCCC
case kFmt22t: // op vA, vB, +CCCC
dec.vA = InstA(inst);
dec.vB = InstB(inst);
dec.vC = s2(bytecode[1]); // sign-extend 16-bit value
break;
case kFmt22c: // op vA, vB, thing@CCCC
case kFmt22cs: // [opt] op vA, vB, field offset CCCC
dec.vA = InstA(inst);
dec.vB = InstB(inst);
dec.vC = bytecode[1];
break;
case kFmt30t: // op +AAAAAAAA
dec.vA = FetchU4(bytecode + 1);
break;
case kFmt31t: // op vAA, +BBBBBBBB
case kFmt31c: // op vAA, string@BBBBBBBB
dec.vA = InstAA(inst);
dec.vB = FetchU4(bytecode + 1);
break;
case kFmt32x: // op vAAAA, vBBBB
dec.vA = bytecode[1];
dec.vB = bytecode[2];
break;
case kFmt31i: // op vAA, #+BBBBBBBB
dec.vA = InstAA(inst);
dec.vB = FetchU4(bytecode + 1);
break;
case kFmt35c: // op {vC, vD, vE, vF, vG}, thing@BBBB
case kFmt35ms: // [opt] invoke-virtual+super
case kFmt35mi: // [opt] inline invoke
{
dec.vA = InstB(inst); // This is labeled A in the spec.
dec.vB = bytecode[1];
u2 regList = bytecode[2];
// Copy the argument registers into the arg[] array, and
// also copy the first argument (if any) into vC. (The
// Instruction structure doesn't have separate
// fields for {vD, vE, vF, vG}, so there's no need to make
// copies of those.) Note that cases 5..2 fall through.
switch (dec.vA) {
case 5:
// A fifth arg is verboten for inline invokes
SLICER_CHECK(format != kFmt35mi);
// Per note at the top of this format decoder, the
// fifth argument comes from the A field in the
// instruction, but it's labeled G in the spec.
dec.arg[4] = InstA(inst);
// fallthrough
case 4:
dec.arg[3] = (regList >> 12) & 0x0f;
// fallthrough
case 3:
dec.arg[2] = (regList >> 8) & 0x0f;
// fallthrough
case 2:
dec.arg[1] = (regList >> 4) & 0x0f;
// fallthrough
case 1:
dec.vC = dec.arg[0] = regList & 0x0f;
// fallthrough
case 0:
// Valid, but no need to do anything
break;
default:
SLICER_CHECK(!"Invalid arg count in 35c/35ms/35mi");
break;
}
} break;
case kFmt3rc: // op {vCCCC .. v(CCCC+AA-1)}, meth@BBBB
case kFmt3rms: // [opt] invoke-virtual+super/range
case kFmt3rmi: // [opt] execute-inline/range
dec.vA = InstAA(inst);
dec.vB = bytecode[1];
dec.vC = bytecode[2];
break;
case kFmt51l: // op vAA, #+BBBBBBBBBBBBBBBB
dec.vA = InstAA(inst);
dec.vB_wide = FetchU8(bytecode + 1);
break;
default:
SLICER_FATAL("Can't decode unexpected format 0x%02x", format);
}
return dec;
}
} // namespace dex