runtime/dex_instruction_utils.h

   1 /*
   2  * Copyright (C) 2014 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 #ifndef ART_RUNTIME_DEX_INSTRUCTION_UTILS_H_
  18 #define ART_RUNTIME_DEX_INSTRUCTION_UTILS_H_
  19
  20 #include "dex_instruction.h"
  21
  22 namespace art {
  23
  24 // Dex invoke type corresponds to the ordering of INVOKE instructions;
  25 // this order is the same for range and non-range invokes.
  26 enum DexInvokeType : uint8_t {
  27   kDexInvokeVirtual = 0,  // invoke-virtual, invoke-virtual-range
  28   kDexInvokeSuper,        // invoke-super, invoke-super-range
  29   kDexInvokeDirect,       // invoke-direct, invoke-direct-range
  30   kDexInvokeStatic,       // invoke-static, invoke-static-range
  31   kDexInvokeInterface,    // invoke-interface, invoke-interface-range
  32   kDexInvokeTypeCount
  33 };
  34
  35 // Dex instruction memory access types correspond to the ordering of GET/PUT instructions;
  36 // this order is the same for IGET, IPUT, SGET, SPUT, AGET and APUT.
  37 enum DexMemAccessType : uint8_t {
  38   kDexMemAccessWord = 0,  // op         0; int or float, the actual type is not encoded.
  39   kDexMemAccessWide,      // op_WIDE    1; long or double, the actual type is not encoded.
  40   kDexMemAccessObject,    // op_OBJECT  2; the actual reference type is not encoded.
  41   kDexMemAccessBoolean,   // op_BOOLEAN 3
  42   kDexMemAccessByte,      // op_BYTE    4
  43   kDexMemAccessChar,      // op_CHAR    5
  44   kDexMemAccessShort,     // op_SHORT   6
  45   kDexMemAccessTypeCount
  46 };
  47
  48 std::ostream& operator<<(std::ostream& os, const DexMemAccessType& type);
  49
  50 // NOTE: The following functions disregard quickened instructions.
  51
  52 // By "direct" const we mean to exclude const-string and const-class
  53 // which load data from somewhere else, i.e. indirectly.
  54 constexpr bool IsInstructionDirectConst(Instruction::Code opcode) {
  55   return Instruction::CONST_4 <= opcode && opcode <= Instruction::CONST_WIDE_HIGH16;
  56 }
  57
  58 constexpr bool IsInstructionConstWide(Instruction::Code opcode) {
  59   return Instruction::CONST_WIDE_16 <= opcode && opcode <= Instruction::CONST_WIDE_HIGH16;
  60 }
  61
  62 constexpr bool IsInstructionReturn(Instruction::Code opcode) {
  63   return Instruction::RETURN_VOID <= opcode && opcode <= Instruction::RETURN_OBJECT;
  64 }
  65
  66 constexpr bool IsInstructionInvoke(Instruction::Code opcode) {
  67   return Instruction::INVOKE_VIRTUAL <= opcode && opcode <= Instruction::INVOKE_INTERFACE_RANGE &&
  68       opcode != Instruction::RETURN_VOID_NO_BARRIER;
  69 }
  70
  71 constexpr bool IsInstructionQuickInvoke(Instruction::Code opcode) {
  72   return opcode == Instruction::INVOKE_VIRTUAL_QUICK ||
  73       opcode == Instruction::INVOKE_VIRTUAL_RANGE_QUICK;
  74 }
  75
  76 constexpr bool IsInstructionInvokeStatic(Instruction::Code opcode) {
  77   return opcode == Instruction::INVOKE_STATIC || opcode == Instruction::INVOKE_STATIC_RANGE;
  78 }
  79
  80 constexpr bool IsInstructionGoto(Instruction::Code opcode) {
  81   return Instruction::GOTO <= opcode && opcode <= Instruction::GOTO_32;
  82 }
  83
  84 constexpr bool IsInstructionIfCc(Instruction::Code opcode) {
  85   return Instruction::IF_EQ <= opcode && opcode <= Instruction::IF_LE;
  86 }
  87
  88 constexpr bool IsInstructionIfCcZ(Instruction::Code opcode) {
  89   return Instruction::IF_EQZ <= opcode && opcode <= Instruction::IF_LEZ;
  90 }
  91
  92 constexpr bool IsInstructionIGet(Instruction::Code code) {
  93   return Instruction::IGET <= code && code <= Instruction::IGET_SHORT;
  94 }
  95
  96 constexpr bool IsInstructionIPut(Instruction::Code code) {
  97   return Instruction::IPUT <= code && code <= Instruction::IPUT_SHORT;
  98 }
  99
 100 constexpr bool IsInstructionSGet(Instruction::Code code) {
 101   return Instruction::SGET <= code && code <= Instruction::SGET_SHORT;
 102 }
 103
 104 constexpr bool IsInstructionSPut(Instruction::Code code) {
 105   return Instruction::SPUT <= code && code <= Instruction::SPUT_SHORT;
 106 }
 107
 108 constexpr bool IsInstructionAGet(Instruction::Code code) {
 109   return Instruction::AGET <= code && code <= Instruction::AGET_SHORT;
 110 }
 111
 112 constexpr bool IsInstructionAPut(Instruction::Code code) {
 113   return Instruction::APUT <= code && code <= Instruction::APUT_SHORT;
 114 }
 115
 116 constexpr bool IsInstructionIGetOrIPut(Instruction::Code code) {
 117   return Instruction::IGET <= code && code <= Instruction::IPUT_SHORT;
 118 }
 119
 120 constexpr bool IsInstructionIGetQuickOrIPutQuick(Instruction::Code code) {
 121   return (code >= Instruction::IGET_QUICK && code <= Instruction::IPUT_OBJECT_QUICK) ||
 122       (code >= Instruction::IPUT_BOOLEAN_QUICK && code <= Instruction::IGET_SHORT_QUICK);
 123 }
 124
 125 constexpr bool IsInstructionSGetOrSPut(Instruction::Code code) {
 126   return Instruction::SGET <= code && code <= Instruction::SPUT_SHORT;
 127 }
 128
 129 constexpr bool IsInstructionAGetOrAPut(Instruction::Code code) {
 130   return Instruction::AGET <= code && code <= Instruction::APUT_SHORT;
 131 }
 132
 133 constexpr bool IsInstructionBinOp2Addr(Instruction::Code code) {
 134   return Instruction::ADD_INT_2ADDR <= code && code <= Instruction::REM_DOUBLE_2ADDR;
 135 }
 136
 137 // TODO: Remove the #if guards below when we fully migrate to C++14.
 138
 139 constexpr bool IsInvokeInstructionRange(Instruction::Code opcode) {
 140 #if __cplusplus >= 201402  // C++14 allows the DCHECK() in constexpr functions.
 141   DCHECK(IsInstructionInvoke(opcode));
 142 #endif
 143   return opcode >= Instruction::INVOKE_VIRTUAL_RANGE;
 144 }
 145
 146 constexpr DexInvokeType InvokeInstructionType(Instruction::Code opcode) {
 147 #if __cplusplus >= 201402  // C++14 allows the DCHECK() in constexpr functions.
 148   DCHECK(IsInstructionInvoke(opcode));
 149 #endif
 150   return static_cast<DexInvokeType>(IsInvokeInstructionRange(opcode)
 151                                     ? (opcode - Instruction::INVOKE_VIRTUAL_RANGE)
 152                                     : (opcode - Instruction::INVOKE_VIRTUAL));
 153 }
 154
 155 constexpr DexMemAccessType IGetMemAccessType(Instruction::Code code) {
 156 #if __cplusplus >= 201402  // C++14 allows the DCHECK() in constexpr functions.
 157   DCHECK(IsInstructionIGet(code));
 158 #endif
 159   return static_cast<DexMemAccessType>(code - Instruction::IGET);
 160 }
 161
 162 constexpr DexMemAccessType IPutMemAccessType(Instruction::Code code) {
 163 #if __cplusplus >= 201402  // C++14 allows the DCHECK() in constexpr functions.
 164   DCHECK(IsInstructionIPut(code));
 165 #endif
 166   return static_cast<DexMemAccessType>(code - Instruction::IPUT);
 167 }
 168
 169 constexpr DexMemAccessType SGetMemAccessType(Instruction::Code code) {
 170 #if __cplusplus >= 201402  // C++14 allows the DCHECK() in constexpr functions.
 171   DCHECK(IsInstructionSGet(code));
 172 #endif
 173   return static_cast<DexMemAccessType>(code - Instruction::SGET);
 174 }
 175
 176 constexpr DexMemAccessType SPutMemAccessType(Instruction::Code code) {
 177 #if __cplusplus >= 201402  // C++14 allows the DCHECK() in constexpr functions.
 178   DCHECK(IsInstructionSPut(code));
 179 #endif
 180   return static_cast<DexMemAccessType>(code - Instruction::SPUT);
 181 }
 182
 183 constexpr DexMemAccessType AGetMemAccessType(Instruction::Code code) {
 184 #if __cplusplus >= 201402  // C++14 allows the DCHECK() in constexpr functions.
 185   DCHECK(IsInstructionAGet(code));
 186 #endif
 187   return static_cast<DexMemAccessType>(code - Instruction::AGET);
 188 }
 189
 190 constexpr DexMemAccessType APutMemAccessType(Instruction::Code code) {
 191 #if __cplusplus >= 201402  // C++14 allows the DCHECK() in constexpr functions.
 192   DCHECK(IsInstructionAPut(code));
 193 #endif
 194   return static_cast<DexMemAccessType>(code - Instruction::APUT);
 195 }
 196
 197 constexpr DexMemAccessType IGetOrIPutMemAccessType(Instruction::Code code) {
 198 #if __cplusplus >= 201402  // C++14 allows the DCHECK() in constexpr functions.
 199   DCHECK(IsInstructionIGetOrIPut(code));
 200 #endif
 201   return (code >= Instruction::IPUT) ? IPutMemAccessType(code) : IGetMemAccessType(code);
 202 }
 203
 204 static inline DexMemAccessType IGetQuickOrIPutQuickMemAccessType(Instruction::Code code) {
 205   DCHECK(IsInstructionIGetQuickOrIPutQuick(code));
 206   switch (code) {
 207     case Instruction::IGET_QUICK: case Instruction::IPUT_QUICK:
 208       return kDexMemAccessWord;
 209     case Instruction::IGET_WIDE_QUICK: case Instruction::IPUT_WIDE_QUICK:
 210       return kDexMemAccessWide;
 211     case Instruction::IGET_OBJECT_QUICK: case Instruction::IPUT_OBJECT_QUICK:
 212       return kDexMemAccessObject;
 213     case Instruction::IGET_BOOLEAN_QUICK: case Instruction::IPUT_BOOLEAN_QUICK:
 214       return kDexMemAccessBoolean;
 215     case Instruction::IGET_BYTE_QUICK: case Instruction::IPUT_BYTE_QUICK:
 216       return kDexMemAccessByte;
 217     case Instruction::IGET_CHAR_QUICK: case Instruction::IPUT_CHAR_QUICK:
 218       return kDexMemAccessChar;
 219     case Instruction::IGET_SHORT_QUICK: case Instruction::IPUT_SHORT_QUICK:
 220       return kDexMemAccessShort;
 221     default:
 222       LOG(FATAL) << code;
 223       UNREACHABLE();
 224   }
 225 }
 226
 227 constexpr DexMemAccessType SGetOrSPutMemAccessType(Instruction::Code code) {
 228 #if __cplusplus >= 201402  // C++14 allows the DCHECK() in constexpr functions.
 229   DCHECK(IsInstructionSGetOrSPut(code));
 230 #endif
 231   return (code >= Instruction::SPUT) ? SPutMemAccessType(code) : SGetMemAccessType(code);
 232 }
 233
 234 constexpr DexMemAccessType AGetOrAPutMemAccessType(Instruction::Code code) {
 235 #if __cplusplus >= 201402  // C++14 allows the DCHECK() in constexpr functions.
 236   DCHECK(IsInstructionAGetOrAPut(code));
 237 #endif
 238   return (code >= Instruction::APUT) ? APutMemAccessType(code) : AGetMemAccessType(code);
 239 }
 240
 241 }  // namespace art
 242
 243 #endif  // ART_RUNTIME_DEX_INSTRUCTION_UTILS_H_