Home | History | Annotate | Download | only in runtime 
      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_
    244