libdex/InstrUtils.h

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * Dalvik instruction utility functions.
  19  */
  20 #ifndef _LIBDEX_INSTRUTILS
  21 #define _LIBDEX_INSTRUTILS
  22
  23 #include "DexFile.h"
  24 #include "DexOpcodes.h"
  25
  26 /*
  27  * Possible instruction formats associated with Dalvik opcodes.
  28  *
  29  * See the file opcode-gen/README.txt for information about updating
  30  * opcodes and instruction formats.
  31  */
  32 typedef enum {
  33     kFmt00x = 0,    // unknown format (also used for "breakpoint" opcode)
  34     kFmt10x,        // op
  35     kFmt12x,        // op vA, vB
  36     kFmt11n,        // op vA, #+B
  37     kFmt11x,        // op vAA
  38     kFmt10t,        // op +AA
  39     kFmt20bc,       // [opt] op AA, thing@BBBB
  40     kFmt20t,        // op +AAAA
  41     kFmt22x,        // op vAA, vBBBB
  42     kFmt21t,        // op vAA, +BBBB
  43     kFmt21s,        // op vAA, #+BBBB
  44     kFmt21h,        // op vAA, #+BBBB00000[00000000]
  45     kFmt21c,        // op vAA, thing@BBBB
  46     kFmt23x,        // op vAA, vBB, vCC
  47     kFmt22b,        // op vAA, vBB, #+CC
  48     kFmt22t,        // op vA, vB, +CCCC
  49     kFmt22s,        // op vA, vB, #+CCCC
  50     kFmt22c,        // op vA, vB, thing@CCCC
  51     kFmt22cs,       // [opt] op vA, vB, field offset CCCC
  52     kFmt30t,        // op +AAAAAAAA
  53     kFmt32x,        // op vAAAA, vBBBB
  54     kFmt31i,        // op vAA, #+BBBBBBBB
  55     kFmt31t,        // op vAA, +BBBBBBBB
  56     kFmt31c,        // op vAA, string@BBBBBBBB
  57     kFmt35c,        // op {vC,vD,vE,vF,vG}, thing@BBBB
  58     kFmt35ms,       // [opt] invoke-virtual+super
  59     kFmt3rc,        // op {vCCCC .. v(CCCC+AA-1)}, thing@BBBB
  60     kFmt3rms,       // [opt] invoke-virtual+super/range
  61     kFmt51l,        // op vAA, #+BBBBBBBBBBBBBBBB
  62     kFmt35mi,       // [opt] inline invoke
  63     kFmt3rmi,       // [opt] inline invoke/range
  64     kFmt33x,        // exop vAA, vBB, vCCCC
  65     kFmt32s,        // exop vAA, vBB, #+CCCC
  66     kFmt41c,        // exop vAAAA, thing@BBBBBBBB
  67     kFmt52c,        // exop vAAAA, vBBBB, thing@CCCCCCCC
  68     kFmt5rc,        // exop {vCCCC .. v(CCCC+AAAA-1)}, thing@BBBBBBBB
  69 } InstructionFormat;
  70
  71 /*
  72  * Types of indexed reference that are associated with opcodes whose
  73  * formats include such an indexed reference (e.g., 21c and 35c).
  74  */
  75 typedef enum {
  76     kIndexUnknown = 0,
  77     kIndexNone,         // has no index
  78     kIndexVaries,       // "It depends." Used for throw-verification-error
  79     kIndexTypeRef,      // type reference index
  80     kIndexStringRef,    // string reference index
  81     kIndexMethodRef,    // method reference index
  82     kIndexFieldRef,     // field reference index
  83     kIndexInlineMethod, // inline method index (for inline linked methods)
  84     kIndexVtableOffset, // vtable offset (for static linked methods)
  85     kIndexFieldOffset   // field offset (for static linked fields)
  86 } InstructionIndexType;
  87
  88 /*
  89  * Instruction width implied by an opcode's format; a value in the
  90  * range 0 to 5. Note that there are special "pseudo-instructions"
  91  * which are used to encode switch and data tables, and these don't
  92  * have a fixed width. See dexGetWidthFromInstruction(), below.
  93  */
  94 typedef u1 InstructionWidth;
  95
  96 /*
  97  * Opcode control flow flags, used by the verifier and JIT.
  98  */
  99 typedef u1 OpcodeFlags;
 100 enum OpcodeFlagsBits {
 101     kInstrCanBranch     = 1,        // conditional or unconditional branch
 102     kInstrCanContinue   = 1 << 1,   // flow can continue to next statement
 103     kInstrCanSwitch     = 1 << 2,   // switch statement
 104     kInstrCanThrow      = 1 << 3,   // could cause an exception to be thrown
 105     kInstrCanReturn     = 1 << 4,   // returns, no additional statements
 106     kInstrInvoke        = 1 << 5,   // a flavor of invoke
 107 };
 108
 109 /*
 110  * Struct that includes a pointer to each of the opcode information
 111  * tables.
 112  *
 113  * Note: We use "u1*" here instead of the names of the enumerated
 114  * types to guarantee that elements don't use much space. We hold out
 115  * hope for a standard way to indicate the size of an enumerated type
 116  * that works for both C and C++, but in the mean time, this will
 117  * suffice.
 118  */
 119 typedef struct InstructionInfoTables {
 120     u1*                formats;    /* InstructionFormat elements */
 121     u1*                indexTypes; /* InstructionIndexType elements */
 122     OpcodeFlags*       flags;
 123     InstructionWidth*  widths;
 124 } InstructionInfoTables;
 125
 126 /*
 127  * Global InstructionInfoTables struct.
 128  */
 129 extern InstructionInfoTables gDexOpcodeInfo;
 130
 131 /*
 132  * Holds the contents of a decoded instruction.
 133  */
 134 typedef struct DecodedInstruction {
 135     u4      vA;
 136     u4      vB;
 137     u8      vB_wide;        /* for kFmt51l */
 138     u4      vC;
 139     u4      arg[5];         /* vC/D/E/F/G in invoke or filled-new-array */
 140     Opcode  opcode;
 141     InstructionIndexType indexType;
 142 } DecodedInstruction;
 143
 144 /*
 145  * Return the instruction width of the specified opcode, or 0 if not defined.
 146  */
 147 DEX_INLINE size_t dexGetWidthFromOpcode(Opcode opcode)
 148 {
 149     //assert(/*opcode >= 0 &&*/ opcode < kNumPackedOpcodes);
 150     return gDexOpcodeInfo.widths[opcode];
 151 }
 152
 153 /*
 154  * Return the width of the specified instruction, or 0 if not defined.  Also
 155  * works for special OP_NOP entries, including switch statement data tables
 156  * and array data.
 157  */
 158 size_t dexGetWidthFromInstruction(const u2* insns);
 159
 160 /*
 161  * Returns the flags for the specified opcode.
 162  */
 163 DEX_INLINE OpcodeFlags dexGetFlagsFromOpcode(Opcode opcode)
 164 {
 165     //assert(/*opcode >= 0 &&*/ opcode < kNumPackedOpcodes);
 166     return gDexOpcodeInfo.flags[opcode];
 167 }
 168
 169 /*
 170  * Returns true if the given flags represent a goto (unconditional branch).
 171  */
 172 DEX_INLINE bool dexIsGoto(OpcodeFlags flags)
 173 {
 174     return (flags & (kInstrCanBranch | kInstrCanContinue)) == kInstrCanBranch;
 175 }
 176
 177 /*
 178  * Return the instruction format for the specified opcode.
 179  */
 180 DEX_INLINE InstructionFormat dexGetFormatFromOpcode(Opcode opcode)
 181 {
 182     //assert(/*opcode >= 0 &&*/ opcode < kNumPackedOpcodes);
 183     return (InstructionFormat) gDexOpcodeInfo.formats[opcode];
 184 }
 185
 186 /*
 187  * Return the instruction index type for the specified opcode.
 188  */
 189 DEX_INLINE InstructionIndexType dexGetIndexTypeFromOpcode(Opcode opcode)
 190 {
 191     //assert(/*opcode >= 0 &&*/ opcode < kNumPackedOpcodes);
 192     return (InstructionIndexType) gDexOpcodeInfo.indexTypes[opcode];
 193 }
 194
 195 /*
 196  * Decode the instruction pointed to by "insns".
 197  */
 198 void dexDecodeInstruction(const u2* insns, DecodedInstruction* pDec);
 199
 200 #endif /*_LIBDEX_INSTRUTILS*/