haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/thirdparty/sentry-native/external/libunwindstack-ndk/DwarfOp.cpp

1941 lines
40 KiB
C++
Raw Blame History

/*
* 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 <stdint.h>
#include <deque>
#include <string>
#include <vector>
#include <android-base/stringprintf.h>
#include <unwindstack/DwarfError.h>
#include <unwindstack/DwarfMemory.h>
#include <unwindstack/Log.h>
#include <unwindstack/Memory.h>
#include <unwindstack/Regs.h>
#include "DwarfOp.h"
namespace unwindstack {
enum DwarfOpHandleFunc : uint8_t {
OP_ILLEGAL = 0,
OP_DEREF,
OP_DEREF_SIZE,
OP_PUSH,
OP_DUP,
OP_DROP,
OP_OVER,
OP_PICK,
OP_SWAP,
OP_ROT,
OP_ABS,
OP_AND,
OP_DIV,
OP_MINUS,
OP_MOD,
OP_MUL,
OP_NEG,
OP_NOT,
OP_OR,
OP_PLUS,
OP_PLUS_UCONST,
OP_SHL,
OP_SHR,
OP_SHRA,
OP_XOR,
OP_BRA,
OP_EQ,
OP_GE,
OP_GT,
OP_LE,
OP_LT,
OP_NE,
OP_SKIP,
OP_LIT,
OP_REG,
OP_REGX,
OP_BREG,
OP_BREGX,
OP_NOP,
OP_NOT_IMPLEMENTED,
};
struct OpCallback {
// It may seem tempting to "clean this up" by replacing "const char[26]" with
// "const char*", but doing so would place the entire callback table in
// .data.rel.ro section, instead of .rodata section, and thus increase
// dirty memory usage. Libunwindstack is used by the linker and therefore
// loaded for every running process, so every bit of memory counts.
// Unlike C standard, C++ standard guarantees this array is big enough to
// store the names, or else we would get a compilation error.
const char name[26];
// Similarily for this field, we do NOT want to directly store function
// pointers here. Not only would that cause the callback table to be placed
// in .data.rel.ro section, but it would be duplicated for each AddressType.
// Instead, we use DwarfOpHandleFunc enum to decouple the callback table from
// the function pointers.
DwarfOpHandleFunc handle_func;
uint8_t num_required_stack_values;
uint8_t num_operands;
uint8_t operands[2];
};
constexpr static OpCallback kCallbackTable[256] = {
{"", OP_ILLEGAL, 0, 0, {}}, // 0x00 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0x01 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0x02 illegal op
{
// 0x03 DW_OP_addr
"DW_OP_addr",
OP_PUSH,
0,
1,
{DW_EH_PE_absptr},
},
{"", OP_ILLEGAL, 0, 0, {}}, // 0x04 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0x05 illegal op
{
// 0x06 DW_OP_deref
"DW_OP_deref",
OP_DEREF,
1,
0,
{},
},
{"", OP_ILLEGAL, 0, 0, {}}, // 0x07 illegal op
{
// 0x08 DW_OP_const1u
"DW_OP_const1u",
OP_PUSH,
0,
1,
{DW_EH_PE_udata1},
},
{
// 0x09 DW_OP_const1s
"DW_OP_const1s",
OP_PUSH,
0,
1,
{DW_EH_PE_sdata1},
},
{
// 0x0a DW_OP_const2u
"DW_OP_const2u",
OP_PUSH,
0,
1,
{DW_EH_PE_udata2},
},
{
// 0x0b DW_OP_const2s
"DW_OP_const2s",
OP_PUSH,
0,
1,
{DW_EH_PE_sdata2},
},
{
// 0x0c DW_OP_const4u
"DW_OP_const4u",
OP_PUSH,
0,
1,
{DW_EH_PE_udata4},
},
{
// 0x0d DW_OP_const4s
"DW_OP_const4s",
OP_PUSH,
0,
1,
{DW_EH_PE_sdata4},
},
{
// 0x0e DW_OP_const8u
"DW_OP_const8u",
OP_PUSH,
0,
1,
{DW_EH_PE_udata8},
},
{
// 0x0f DW_OP_const8s
"DW_OP_const8s",
OP_PUSH,
0,
1,
{DW_EH_PE_sdata8},
},
{
// 0x10 DW_OP_constu
"DW_OP_constu",
OP_PUSH,
0,
1,
{DW_EH_PE_uleb128},
},
{
// 0x11 DW_OP_consts
"DW_OP_consts",
OP_PUSH,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x12 DW_OP_dup
"DW_OP_dup",
OP_DUP,
1,
0,
{},
},
{
// 0x13 DW_OP_drop
"DW_OP_drop",
OP_DROP,
1,
0,
{},
},
{
// 0x14 DW_OP_over
"DW_OP_over",
OP_OVER,
2,
0,
{},
},
{
// 0x15 DW_OP_pick
"DW_OP_pick",
OP_PICK,
0,
1,
{DW_EH_PE_udata1},
},
{
// 0x16 DW_OP_swap
"DW_OP_swap",
OP_SWAP,
2,
0,
{},
},
{
// 0x17 DW_OP_rot
"DW_OP_rot",
OP_ROT,
3,
0,
{},
},
{
// 0x18 DW_OP_xderef
"DW_OP_xderef",
OP_NOT_IMPLEMENTED,
2,
0,
{},
},
{
// 0x19 DW_OP_abs
"DW_OP_abs",
OP_ABS,
1,
0,
{},
},
{
// 0x1a DW_OP_and
"DW_OP_and",
OP_AND,
2,
0,
{},
},
{
// 0x1b DW_OP_div
"DW_OP_div",
OP_DIV,
2,
0,
{},
},
{
// 0x1c DW_OP_minus
"DW_OP_minus",
OP_MINUS,
2,
0,
{},
},
{
// 0x1d DW_OP_mod
"DW_OP_mod",
OP_MOD,
2,
0,
{},
},
{
// 0x1e DW_OP_mul
"DW_OP_mul",
OP_MUL,
2,
0,
{},
},
{
// 0x1f DW_OP_neg
"DW_OP_neg",
OP_NEG,
1,
0,
{},
},
{
// 0x20 DW_OP_not
"DW_OP_not",
OP_NOT,
1,
0,
{},
},
{
// 0x21 DW_OP_or
"DW_OP_or",
OP_OR,
2,
0,
{},
},
{
// 0x22 DW_OP_plus
"DW_OP_plus",
OP_PLUS,
2,
0,
{},
},
{
// 0x23 DW_OP_plus_uconst
"DW_OP_plus_uconst",
OP_PLUS_UCONST,
1,
1,
{DW_EH_PE_uleb128},
},
{
// 0x24 DW_OP_shl
"DW_OP_shl",
OP_SHL,
2,
0,
{},
},
{
// 0x25 DW_OP_shr
"DW_OP_shr",
OP_SHR,
2,
0,
{},
},
{
// 0x26 DW_OP_shra
"DW_OP_shra",
OP_SHRA,
2,
0,
{},
},
{
// 0x27 DW_OP_xor
"DW_OP_xor",
OP_XOR,
2,
0,
{},
},
{
// 0x28 DW_OP_bra
"DW_OP_bra",
OP_BRA,
1,
1,
{DW_EH_PE_sdata2},
},
{
// 0x29 DW_OP_eq
"DW_OP_eq",
OP_EQ,
2,
0,
{},
},
{
// 0x2a DW_OP_ge
"DW_OP_ge",
OP_GE,
2,
0,
{},
},
{
// 0x2b DW_OP_gt
"DW_OP_gt",
OP_GT,
2,
0,
{},
},
{
// 0x2c DW_OP_le
"DW_OP_le",
OP_LE,
2,
0,
{},
},
{
// 0x2d DW_OP_lt
"DW_OP_lt",
OP_LT,
2,
0,
{},
},
{
// 0x2e DW_OP_ne
"DW_OP_ne",
OP_NE,
2,
0,
{},
},
{
// 0x2f DW_OP_skip
"DW_OP_skip",
OP_SKIP,
0,
1,
{DW_EH_PE_sdata2},
},
{
// 0x30 DW_OP_lit0
"DW_OP_lit0",
OP_LIT,
0,
0,
{},
},
{
// 0x31 DW_OP_lit1
"DW_OP_lit1",
OP_LIT,
0,
0,
{},
},
{
// 0x32 DW_OP_lit2
"DW_OP_lit2",
OP_LIT,
0,
0,
{},
},
{
// 0x33 DW_OP_lit3
"DW_OP_lit3",
OP_LIT,
0,
0,
{},
},
{
// 0x34 DW_OP_lit4
"DW_OP_lit4",
OP_LIT,
0,
0,
{},
},
{
// 0x35 DW_OP_lit5
"DW_OP_lit5",
OP_LIT,
0,
0,
{},
},
{
// 0x36 DW_OP_lit6
"DW_OP_lit6",
OP_LIT,
0,
0,
{},
},
{
// 0x37 DW_OP_lit7
"DW_OP_lit7",
OP_LIT,
0,
0,
{},
},
{
// 0x38 DW_OP_lit8
"DW_OP_lit8",
OP_LIT,
0,
0,
{},
},
{
// 0x39 DW_OP_lit9
"DW_OP_lit9",
OP_LIT,
0,
0,
{},
},
{
// 0x3a DW_OP_lit10
"DW_OP_lit10",
OP_LIT,
0,
0,
{},
},
{
// 0x3b DW_OP_lit11
"DW_OP_lit11",
OP_LIT,
0,
0,
{},
},
{
// 0x3c DW_OP_lit12
"DW_OP_lit12",
OP_LIT,
0,
0,
{},
},
{
// 0x3d DW_OP_lit13
"DW_OP_lit13",
OP_LIT,
0,
0,
{},
},
{
// 0x3e DW_OP_lit14
"DW_OP_lit14",
OP_LIT,
0,
0,
{},
},
{
// 0x3f DW_OP_lit15
"DW_OP_lit15",
OP_LIT,
0,
0,
{},
},
{
// 0x40 DW_OP_lit16
"DW_OP_lit16",
OP_LIT,
0,
0,
{},
},
{
// 0x41 DW_OP_lit17
"DW_OP_lit17",
OP_LIT,
0,
0,
{},
},
{
// 0x42 DW_OP_lit18
"DW_OP_lit18",
OP_LIT,
0,
0,
{},
},
{
// 0x43 DW_OP_lit19
"DW_OP_lit19",
OP_LIT,
0,
0,
{},
},
{
// 0x44 DW_OP_lit20
"DW_OP_lit20",
OP_LIT,
0,
0,
{},
},
{
// 0x45 DW_OP_lit21
"DW_OP_lit21",
OP_LIT,
0,
0,
{},
},
{
// 0x46 DW_OP_lit22
"DW_OP_lit22",
OP_LIT,
0,
0,
{},
},
{
// 0x47 DW_OP_lit23
"DW_OP_lit23",
OP_LIT,
0,
0,
{},
},
{
// 0x48 DW_OP_lit24
"DW_OP_lit24",
OP_LIT,
0,
0,
{},
},
{
// 0x49 DW_OP_lit25
"DW_OP_lit25",
OP_LIT,
0,
0,
{},
},
{
// 0x4a DW_OP_lit26
"DW_OP_lit26",
OP_LIT,
0,
0,
{},
},
{
// 0x4b DW_OP_lit27
"DW_OP_lit27",
OP_LIT,
0,
0,
{},
},
{
// 0x4c DW_OP_lit28
"DW_OP_lit28",
OP_LIT,
0,
0,
{},
},
{
// 0x4d DW_OP_lit29
"DW_OP_lit29",
OP_LIT,
0,
0,
{},
},
{
// 0x4e DW_OP_lit30
"DW_OP_lit30",
OP_LIT,
0,
0,
{},
},
{
// 0x4f DW_OP_lit31
"DW_OP_lit31",
OP_LIT,
0,
0,
{},
},
{
// 0x50 DW_OP_reg0
"DW_OP_reg0",
OP_REG,
0,
0,
{},
},
{
// 0x51 DW_OP_reg1
"DW_OP_reg1",
OP_REG,
0,
0,
{},
},
{
// 0x52 DW_OP_reg2
"DW_OP_reg2",
OP_REG,
0,
0,
{},
},
{
// 0x53 DW_OP_reg3
"DW_OP_reg3",
OP_REG,
0,
0,
{},
},
{
// 0x54 DW_OP_reg4
"DW_OP_reg4",
OP_REG,
0,
0,
{},
},
{
// 0x55 DW_OP_reg5
"DW_OP_reg5",
OP_REG,
0,
0,
{},
},
{
// 0x56 DW_OP_reg6
"DW_OP_reg6",
OP_REG,
0,
0,
{},
},
{
// 0x57 DW_OP_reg7
"DW_OP_reg7",
OP_REG,
0,
0,
{},
},
{
// 0x58 DW_OP_reg8
"DW_OP_reg8",
OP_REG,
0,
0,
{},
},
{
// 0x59 DW_OP_reg9
"DW_OP_reg9",
OP_REG,
0,
0,
{},
},
{
// 0x5a DW_OP_reg10
"DW_OP_reg10",
OP_REG,
0,
0,
{},
},
{
// 0x5b DW_OP_reg11
"DW_OP_reg11",
OP_REG,
0,
0,
{},
},
{
// 0x5c DW_OP_reg12
"DW_OP_reg12",
OP_REG,
0,
0,
{},
},
{
// 0x5d DW_OP_reg13
"DW_OP_reg13",
OP_REG,
0,
0,
{},
},
{
// 0x5e DW_OP_reg14
"DW_OP_reg14",
OP_REG,
0,
0,
{},
},
{
// 0x5f DW_OP_reg15
"DW_OP_reg15",
OP_REG,
0,
0,
{},
},
{
// 0x60 DW_OP_reg16
"DW_OP_reg16",
OP_REG,
0,
0,
{},
},
{
// 0x61 DW_OP_reg17
"DW_OP_reg17",
OP_REG,
0,
0,
{},
},
{
// 0x62 DW_OP_reg18
"DW_OP_reg18",
OP_REG,
0,
0,
{},
},
{
// 0x63 DW_OP_reg19
"DW_OP_reg19",
OP_REG,
0,
0,
{},
},
{
// 0x64 DW_OP_reg20
"DW_OP_reg20",
OP_REG,
0,
0,
{},
},
{
// 0x65 DW_OP_reg21
"DW_OP_reg21",
OP_REG,
0,
0,
{},
},
{
// 0x66 DW_OP_reg22
"DW_OP_reg22",
OP_REG,
0,
0,
{},
},
{
// 0x67 DW_OP_reg23
"DW_OP_reg23",
OP_REG,
0,
0,
{},
},
{
// 0x68 DW_OP_reg24
"DW_OP_reg24",
OP_REG,
0,
0,
{},
},
{
// 0x69 DW_OP_reg25
"DW_OP_reg25",
OP_REG,
0,
0,
{},
},
{
// 0x6a DW_OP_reg26
"DW_OP_reg26",
OP_REG,
0,
0,
{},
},
{
// 0x6b DW_OP_reg27
"DW_OP_reg27",
OP_REG,
0,
0,
{},
},
{
// 0x6c DW_OP_reg28
"DW_OP_reg28",
OP_REG,
0,
0,
{},
},
{
// 0x6d DW_OP_reg29
"DW_OP_reg29",
OP_REG,
0,
0,
{},
},
{
// 0x6e DW_OP_reg30
"DW_OP_reg30",
OP_REG,
0,
0,
{},
},
{
// 0x6f DW_OP_reg31
"DW_OP_reg31",
OP_REG,
0,
0,
{},
},
{
// 0x70 DW_OP_breg0
"DW_OP_breg0",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x71 DW_OP_breg1
"DW_OP_breg1",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x72 DW_OP_breg2
"DW_OP_breg2",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x73 DW_OP_breg3
"DW_OP_breg3",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x74 DW_OP_breg4
"DW_OP_breg4",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x75 DW_OP_breg5
"DW_OP_breg5",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x76 DW_OP_breg6
"DW_OP_breg6",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x77 DW_OP_breg7
"DW_OP_breg7",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x78 DW_OP_breg8
"DW_OP_breg8",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x79 DW_OP_breg9
"DW_OP_breg9",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x7a DW_OP_breg10
"DW_OP_breg10",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x7b DW_OP_breg11
"DW_OP_breg11",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x7c DW_OP_breg12
"DW_OP_breg12",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x7d DW_OP_breg13
"DW_OP_breg13",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x7e DW_OP_breg14
"DW_OP_breg14",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x7f DW_OP_breg15
"DW_OP_breg15",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x80 DW_OP_breg16
"DW_OP_breg16",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x81 DW_OP_breg17
"DW_OP_breg17",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x82 DW_OP_breg18
"DW_OP_breg18",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x83 DW_OP_breg19
"DW_OP_breg19",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x84 DW_OP_breg20
"DW_OP_breg20",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x85 DW_OP_breg21
"DW_OP_breg21",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x86 DW_OP_breg22
"DW_OP_breg22",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x87 DW_OP_breg23
"DW_OP_breg23",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x88 DW_OP_breg24
"DW_OP_breg24",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x89 DW_OP_breg25
"DW_OP_breg25",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x8a DW_OP_breg26
"DW_OP_breg26",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x8b DW_OP_breg27
"DW_OP_breg27",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x8c DW_OP_breg28
"DW_OP_breg28",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x8d DW_OP_breg29
"DW_OP_breg29",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x8e DW_OP_breg30
"DW_OP_breg30",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x8f DW_OP_breg31
"DW_OP_breg31",
OP_BREG,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x90 DW_OP_regx
"DW_OP_regx",
OP_REGX,
0,
1,
{DW_EH_PE_uleb128},
},
{
// 0x91 DW_OP_fbreg
"DW_OP_fbreg",
OP_NOT_IMPLEMENTED,
0,
1,
{DW_EH_PE_sleb128},
},
{
// 0x92 DW_OP_bregx
"DW_OP_bregx",
OP_BREGX,
0,
2,
{DW_EH_PE_uleb128, DW_EH_PE_sleb128},
},
{
// 0x93 DW_OP_piece
"DW_OP_piece",
OP_NOT_IMPLEMENTED,
0,
1,
{DW_EH_PE_uleb128},
},
{
// 0x94 DW_OP_deref_size
"DW_OP_deref_size",
OP_DEREF_SIZE,
1,
1,
{DW_EH_PE_udata1},
},
{
// 0x95 DW_OP_xderef_size
"DW_OP_xderef_size",
OP_NOT_IMPLEMENTED,
0,
1,
{DW_EH_PE_udata1},
},
{
// 0x96 DW_OP_nop
"DW_OP_nop",
OP_NOP,
0,
0,
{},
},
{
// 0x97 DW_OP_push_object_address
"DW_OP_push_object_address",
OP_NOT_IMPLEMENTED,
0,
0,
{},
},
{
// 0x98 DW_OP_call2
"DW_OP_call2",
OP_NOT_IMPLEMENTED,
0,
1,
{DW_EH_PE_udata2},
},
{
// 0x99 DW_OP_call4
"DW_OP_call4",
OP_NOT_IMPLEMENTED,
0,
1,
{DW_EH_PE_udata4},
},
{
// 0x9a DW_OP_call_ref
"DW_OP_call_ref",
OP_NOT_IMPLEMENTED,
0,
0, // Has a different sized operand (4 bytes or 8 bytes).
{},
},
{
// 0x9b DW_OP_form_tls_address
"DW_OP_form_tls_address",
OP_NOT_IMPLEMENTED,
0,
0,
{},
},
{
// 0x9c DW_OP_call_frame_cfa
"DW_OP_call_frame_cfa",
OP_NOT_IMPLEMENTED,
0,
0,
{},
},
{
// 0x9d DW_OP_bit_piece
"DW_OP_bit_piece",
OP_NOT_IMPLEMENTED,
0,
2,
{DW_EH_PE_uleb128, DW_EH_PE_uleb128},
},
{
// 0x9e DW_OP_implicit_value
"DW_OP_implicit_value",
OP_NOT_IMPLEMENTED,
0,
1,
{DW_EH_PE_uleb128},
},
{
// 0x9f DW_OP_stack_value
"DW_OP_stack_value",
OP_NOT_IMPLEMENTED,
1,
0,
{},
},
{"", OP_ILLEGAL, 0, 0, {}}, // 0xa0 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xa1 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xa2 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xa3 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xa4 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xa5 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xa6 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xa7 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xa8 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xa9 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xaa illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xab illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xac illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xad illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xae illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xaf illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xb0 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xb1 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xb2 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xb3 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xb4 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xb5 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xb6 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xb7 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xb8 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xb9 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xba illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xbb illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xbc illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xbd illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xbe illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xbf illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xc0 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xc1 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xc2 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xc3 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xc4 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xc5 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xc6 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xc7 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xc8 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xc9 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xca illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xcb illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xcc illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xcd illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xce illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xcf illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xd0 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xd1 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xd2 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xd3 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xd4 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xd5 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xd6 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xd7 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xd8 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xd9 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xda illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xdb illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xdc illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xdd illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xde illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xdf illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xe0 DW_OP_lo_user
{"", OP_ILLEGAL, 0, 0, {}}, // 0xe1 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xe2 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xe3 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xe4 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xe5 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xe6 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xe7 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xe8 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xe9 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xea illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xeb illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xec illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xed illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xee illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xef illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xf0 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xf1 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xf2 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xf3 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xf4 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xf5 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xf6 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xf7 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xf8 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xf9 illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xfa illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xfb illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xfc illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xfd illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xfe illegal op
{"", OP_ILLEGAL, 0, 0, {}}, // 0xff DW_OP_hi_user
};
template <typename AddressType>
const typename DwarfOp<AddressType>::OpHandleFuncPtr DwarfOp<AddressType>::kOpHandleFuncList[] = {
[OP_ILLEGAL] = nullptr,
[OP_DEREF] = &DwarfOp<AddressType>::op_deref,
[OP_DEREF_SIZE] = &DwarfOp<AddressType>::op_deref_size,
[OP_PUSH] = &DwarfOp<AddressType>::op_push,
[OP_DUP] = &DwarfOp<AddressType>::op_dup,
[OP_DROP] = &DwarfOp<AddressType>::op_drop,
[OP_OVER] = &DwarfOp<AddressType>::op_over,
[OP_PICK] = &DwarfOp<AddressType>::op_pick,
[OP_SWAP] = &DwarfOp<AddressType>::op_swap,
[OP_ROT] = &DwarfOp<AddressType>::op_rot,
[OP_ABS] = &DwarfOp<AddressType>::op_abs,
[OP_AND] = &DwarfOp<AddressType>::op_and,
[OP_DIV] = &DwarfOp<AddressType>::op_div,
[OP_MINUS] = &DwarfOp<AddressType>::op_minus,
[OP_MOD] = &DwarfOp<AddressType>::op_mod,
[OP_MUL] = &DwarfOp<AddressType>::op_mul,
[OP_NEG] = &DwarfOp<AddressType>::op_neg,
[OP_NOT] = &DwarfOp<AddressType>::op_not,
[OP_OR] = &DwarfOp<AddressType>::op_or,
[OP_PLUS] = &DwarfOp<AddressType>::op_plus,
[OP_PLUS_UCONST] = &DwarfOp<AddressType>::op_plus_uconst,
[OP_SHL] = &DwarfOp<AddressType>::op_shl,
[OP_SHR] = &DwarfOp<AddressType>::op_shr,
[OP_SHRA] = &DwarfOp<AddressType>::op_shra,
[OP_XOR] = &DwarfOp<AddressType>::op_xor,
[OP_BRA] = &DwarfOp<AddressType>::op_bra,
[OP_EQ] = &DwarfOp<AddressType>::op_eq,
[OP_GE] = &DwarfOp<AddressType>::op_ge,
[OP_GT] = &DwarfOp<AddressType>::op_gt,
[OP_LE] = &DwarfOp<AddressType>::op_le,
[OP_LT] = &DwarfOp<AddressType>::op_lt,
[OP_NE] = &DwarfOp<AddressType>::op_ne,
[OP_SKIP] = &DwarfOp<AddressType>::op_skip,
[OP_LIT] = &DwarfOp<AddressType>::op_lit,
[OP_REG] = &DwarfOp<AddressType>::op_reg,
[OP_REGX] = &DwarfOp<AddressType>::op_regx,
[OP_BREG] = &DwarfOp<AddressType>::op_breg,
[OP_BREGX] = &DwarfOp<AddressType>::op_bregx,
[OP_NOP] = &DwarfOp<AddressType>::op_nop,
[OP_NOT_IMPLEMENTED] = &DwarfOp<AddressType>::op_not_implemented,
};
template <typename AddressType>
bool DwarfOp<AddressType>::Eval(uint64_t start, uint64_t end) {
is_register_ = false;
stack_.clear();
memory_->set_cur_offset(start);
dex_pc_set_ = false;
// Unroll the first Decode calls to be able to check for a special
// sequence of ops and values that indicate this is the dex pc.
// The pattern is:
// OP_const4u (0x0c) 'D' 'E' 'X' '1'
// OP_drop (0x13)
if (memory_->cur_offset() < end) {
if (!Decode()) {
return false;
}
} else {
return true;
}
bool check_for_drop;
if (cur_op_ == 0x0c && operands_.back() == 0x31584544) {
check_for_drop = true;
} else {
check_for_drop = false;
}
if (memory_->cur_offset() < end) {
if (!Decode()) {
return false;
}
} else {
return true;
}
if (check_for_drop && cur_op_ == 0x13) {
dex_pc_set_ = true;
}
uint32_t iterations = 2;
while (memory_->cur_offset() < end) {
if (!Decode()) {
return false;
}
// To protect against a branch that creates an infinite loop,
// terminate if the number of iterations gets too high.
if (iterations++ == 1000) {
last_error_.code = DWARF_ERROR_TOO_MANY_ITERATIONS;
return false;
}
}
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::Decode() {
last_error_.code = DWARF_ERROR_NONE;
if (!memory_->ReadBytes(&cur_op_, 1)) {
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
last_error_.address = memory_->cur_offset();
return false;
}
const auto* op = &kCallbackTable[cur_op_];
if (op->handle_func == OP_ILLEGAL) {
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
return false;
}
const auto handle_func = kOpHandleFuncList[op->handle_func];
// Make sure that the required number of stack elements is available.
if (stack_.size() < op->num_required_stack_values) {
last_error_.code = DWARF_ERROR_STACK_INDEX_NOT_VALID;
return false;
}
operands_.clear();
for (size_t i = 0; i < op->num_operands; i++) {
uint64_t value;
if (!memory_->ReadEncodedValue<AddressType>(op->operands[i], &value)) {
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
last_error_.address = memory_->cur_offset();
return false;
}
operands_.push_back(value);
}
return (this->*handle_func)();
}
template <typename AddressType>
void DwarfOp<AddressType>::GetLogInfo(uint64_t start, uint64_t end,
std::vector<std::string>* lines) {
memory_->set_cur_offset(start);
while (memory_->cur_offset() < end) {
uint8_t cur_op;
if (!memory_->ReadBytes(&cur_op, 1)) {
return;
}
std::string raw_string(android::base::StringPrintf("Raw Data: 0x%02x", cur_op));
std::string log_string;
const auto* op = &kCallbackTable[cur_op];
if (op->handle_func == OP_ILLEGAL) {
log_string = "Illegal";
} else {
log_string = op->name;
uint64_t start_offset = memory_->cur_offset();
for (size_t i = 0; i < op->num_operands; i++) {
uint64_t value;
if (!memory_->ReadEncodedValue<AddressType>(op->operands[i], &value)) {
return;
}
log_string += ' ' + std::to_string(value);
}
uint64_t end_offset = memory_->cur_offset();
memory_->set_cur_offset(start_offset);
for (size_t i = start_offset; i < end_offset; i++) {
uint8_t byte;
if (!memory_->ReadBytes(&byte, 1)) {
return;
}
raw_string += android::base::StringPrintf(" 0x%02x", byte);
}
memory_->set_cur_offset(end_offset);
}
lines->push_back(std::move(log_string));
lines->push_back(std::move(raw_string));
}
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_deref() {
// Read the address and dereference it.
AddressType addr = StackPop();
AddressType value;
if (!regular_memory()->ReadFully(addr, &value, sizeof(value))) {
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
last_error_.address = addr;
return false;
}
stack_.push_front(value);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_deref_size() {
AddressType bytes_to_read = OperandAt(0);
if (bytes_to_read > sizeof(AddressType) || bytes_to_read == 0) {
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
return false;
}
// Read the address and dereference it.
AddressType addr = StackPop();
AddressType value = 0;
if (!regular_memory()->ReadFully(addr, &value, bytes_to_read)) {
last_error_.code = DWARF_ERROR_MEMORY_INVALID;
last_error_.address = addr;
return false;
}
stack_.push_front(value);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_push() {
// Push all of the operands.
for (auto operand : operands_) {
stack_.push_front(operand);
}
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_dup() {
stack_.push_front(StackAt(0));
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_drop() {
StackPop();
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_over() {
stack_.push_front(StackAt(1));
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_pick() {
AddressType index = OperandAt(0);
if (index >= StackSize()) {
last_error_.code = DWARF_ERROR_STACK_INDEX_NOT_VALID;
return false;
}
stack_.push_front(StackAt(index));
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_swap() {
AddressType old_value = stack_[0];
stack_[0] = stack_[1];
stack_[1] = old_value;
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_rot() {
AddressType top = stack_[0];
stack_[0] = stack_[1];
stack_[1] = stack_[2];
stack_[2] = top;
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_abs() {
SignedType signed_value = static_cast<SignedType>(stack_[0]);
if (signed_value < 0) {
signed_value = -signed_value;
}
stack_[0] = static_cast<AddressType>(signed_value);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_and() {
AddressType top = StackPop();
stack_[0] &= top;
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_div() {
AddressType top = StackPop();
if (top == 0) {
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
return false;
}
SignedType signed_divisor = static_cast<SignedType>(top);
SignedType signed_dividend = static_cast<SignedType>(stack_[0]);
stack_[0] = static_cast<AddressType>(signed_dividend / signed_divisor);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_minus() {
AddressType top = StackPop();
stack_[0] -= top;
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_mod() {
AddressType top = StackPop();
if (top == 0) {
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
return false;
}
stack_[0] %= top;
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_mul() {
AddressType top = StackPop();
stack_[0] *= top;
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_neg() {
SignedType signed_value = static_cast<SignedType>(stack_[0]);
stack_[0] = static_cast<AddressType>(-signed_value);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_not() {
stack_[0] = ~stack_[0];
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_or() {
AddressType top = StackPop();
stack_[0] |= top;
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_plus() {
AddressType top = StackPop();
stack_[0] += top;
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_plus_uconst() {
stack_[0] += OperandAt(0);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_shl() {
AddressType top = StackPop();
stack_[0] <<= top;
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_shr() {
AddressType top = StackPop();
stack_[0] >>= top;
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_shra() {
AddressType top = StackPop();
SignedType signed_value = static_cast<SignedType>(stack_[0]) >> top;
stack_[0] = static_cast<AddressType>(signed_value);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_xor() {
AddressType top = StackPop();
stack_[0] ^= top;
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_bra() {
// Requires one stack element.
AddressType top = StackPop();
if (top == 0) {
return true;
}
int16_t offset = static_cast<int16_t>(OperandAt(0));
uint64_t cur_offset = memory_->cur_offset() + offset;
memory_->set_cur_offset(cur_offset);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_eq() {
AddressType top = StackPop();
stack_[0] = bool_to_dwarf_bool(stack_[0] == top);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_ge() {
AddressType top = StackPop();
stack_[0] = bool_to_dwarf_bool(stack_[0] >= top);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_gt() {
AddressType top = StackPop();
stack_[0] = bool_to_dwarf_bool(stack_[0] > top);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_le() {
AddressType top = StackPop();
stack_[0] = bool_to_dwarf_bool(stack_[0] <= top);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_lt() {
AddressType top = StackPop();
stack_[0] = bool_to_dwarf_bool(stack_[0] < top);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_ne() {
AddressType top = StackPop();
stack_[0] = bool_to_dwarf_bool(stack_[0] != top);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_skip() {
int16_t offset = static_cast<int16_t>(OperandAt(0));
uint64_t cur_offset = memory_->cur_offset() + offset;
memory_->set_cur_offset(cur_offset);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_lit() {
stack_.push_front(cur_op() - 0x30);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_reg() {
is_register_ = true;
stack_.push_front(cur_op() - 0x50);
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_regx() {
is_register_ = true;
stack_.push_front(OperandAt(0));
return true;
}
// It's not clear for breg/bregx, if this op should read the current
// value of the register, or where we think that register is located.
// For simplicity, the code will read the value before doing the unwind.
template <typename AddressType>
bool DwarfOp<AddressType>::op_breg() {
uint16_t reg = cur_op() - 0x70;
if (reg >= regs_info_->Total()) {
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
return false;
}
stack_.push_front(regs_info_->Get(reg) + OperandAt(0));
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_bregx() {
AddressType reg = OperandAt(0);
if (reg >= regs_info_->Total()) {
last_error_.code = DWARF_ERROR_ILLEGAL_VALUE;
return false;
}
stack_.push_front(regs_info_->Get(reg) + OperandAt(1));
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_nop() {
return true;
}
template <typename AddressType>
bool DwarfOp<AddressType>::op_not_implemented() {
last_error_.code = DWARF_ERROR_NOT_IMPLEMENTED;
return false;
}
// Explicitly instantiate DwarfOp.
template class DwarfOp<uint32_t>;
template class DwarfOp<uint64_t>;
} // namespace unwindstack
Reference in New Issue View Git Blame Copy Permalink