Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012 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 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 17 | #ifndef ART_COMPILER_DEX_QUICK_MIR_TO_LIR_H_ |
| 18 | #define ART_COMPILER_DEX_QUICK_MIR_TO_LIR_H_ |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 19 | |
| 20 | #include "invoke_type.h" |
| 21 | #include "compiled_method.h" |
| 22 | #include "dex/compiler_enums.h" |
| 23 | #include "dex/compiler_ir.h" |
Bill Buzbee | 00e1ec6 | 2014-02-27 23:44:13 +0000 | [diff] [blame] | 24 | #include "dex/reg_storage.h" |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 25 | #include "dex/backend.h" |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 26 | #include "driver/compiler_driver.h" |
Brian Carlstrom | a1ce1fe | 2014-02-24 23:23:58 -0800 | [diff] [blame] | 27 | #include "leb128.h" |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 28 | #include "safe_map.h" |
Nicolas Geoffray | 818f210 | 2014-02-18 16:43:35 +0000 | [diff] [blame] | 29 | #include "utils/arena_allocator.h" |
| 30 | #include "utils/growable_array.h" |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 31 | |
| 32 | namespace art { |
| 33 | |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 34 | /* |
| 35 | * TODO: refactoring pass to move these (and other) typdefs towards usage style of runtime to |
| 36 | * add type safety (see runtime/offsets.h). |
| 37 | */ |
| 38 | typedef uint32_t DexOffset; // Dex offset in code units. |
| 39 | typedef uint16_t NarrowDexOffset; // For use in structs, Dex offsets range from 0 .. 0xffff. |
| 40 | typedef uint32_t CodeOffset; // Native code offset in bytes. |
| 41 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 42 | // Set to 1 to measure cost of suspend check. |
| 43 | #define NO_SUSPEND 0 |
| 44 | |
| 45 | #define IS_BINARY_OP (1ULL << kIsBinaryOp) |
| 46 | #define IS_BRANCH (1ULL << kIsBranch) |
| 47 | #define IS_IT (1ULL << kIsIT) |
| 48 | #define IS_LOAD (1ULL << kMemLoad) |
| 49 | #define IS_QUAD_OP (1ULL << kIsQuadOp) |
| 50 | #define IS_QUIN_OP (1ULL << kIsQuinOp) |
| 51 | #define IS_SEXTUPLE_OP (1ULL << kIsSextupleOp) |
| 52 | #define IS_STORE (1ULL << kMemStore) |
| 53 | #define IS_TERTIARY_OP (1ULL << kIsTertiaryOp) |
| 54 | #define IS_UNARY_OP (1ULL << kIsUnaryOp) |
| 55 | #define NEEDS_FIXUP (1ULL << kPCRelFixup) |
| 56 | #define NO_OPERAND (1ULL << kNoOperand) |
| 57 | #define REG_DEF0 (1ULL << kRegDef0) |
| 58 | #define REG_DEF1 (1ULL << kRegDef1) |
Razvan A Lupusoru | 99ad723 | 2014-02-25 17:41:08 -0800 | [diff] [blame] | 59 | #define REG_DEF2 (1ULL << kRegDef2) |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 60 | #define REG_DEFA (1ULL << kRegDefA) |
| 61 | #define REG_DEFD (1ULL << kRegDefD) |
| 62 | #define REG_DEF_FPCS_LIST0 (1ULL << kRegDefFPCSList0) |
| 63 | #define REG_DEF_FPCS_LIST2 (1ULL << kRegDefFPCSList2) |
| 64 | #define REG_DEF_LIST0 (1ULL << kRegDefList0) |
| 65 | #define REG_DEF_LIST1 (1ULL << kRegDefList1) |
| 66 | #define REG_DEF_LR (1ULL << kRegDefLR) |
| 67 | #define REG_DEF_SP (1ULL << kRegDefSP) |
| 68 | #define REG_USE0 (1ULL << kRegUse0) |
| 69 | #define REG_USE1 (1ULL << kRegUse1) |
| 70 | #define REG_USE2 (1ULL << kRegUse2) |
| 71 | #define REG_USE3 (1ULL << kRegUse3) |
| 72 | #define REG_USE4 (1ULL << kRegUse4) |
| 73 | #define REG_USEA (1ULL << kRegUseA) |
| 74 | #define REG_USEC (1ULL << kRegUseC) |
| 75 | #define REG_USED (1ULL << kRegUseD) |
Vladimir Marko | 70b797d | 2013-12-03 15:25:24 +0000 | [diff] [blame] | 76 | #define REG_USEB (1ULL << kRegUseB) |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 77 | #define REG_USE_FPCS_LIST0 (1ULL << kRegUseFPCSList0) |
| 78 | #define REG_USE_FPCS_LIST2 (1ULL << kRegUseFPCSList2) |
| 79 | #define REG_USE_LIST0 (1ULL << kRegUseList0) |
| 80 | #define REG_USE_LIST1 (1ULL << kRegUseList1) |
| 81 | #define REG_USE_LR (1ULL << kRegUseLR) |
| 82 | #define REG_USE_PC (1ULL << kRegUsePC) |
| 83 | #define REG_USE_SP (1ULL << kRegUseSP) |
| 84 | #define SETS_CCODES (1ULL << kSetsCCodes) |
| 85 | #define USES_CCODES (1ULL << kUsesCCodes) |
Serguei Katkov | e90501d | 2014-03-12 15:56:54 +0700 | [diff] [blame] | 86 | #define USE_FP_STACK (1ULL << kUseFpStack) |
buzbee | 9da5c10 | 2014-03-28 12:59:18 -0700 | [diff] [blame] | 87 | #define REG_USE_LO (1ULL << kUseLo) |
| 88 | #define REG_USE_HI (1ULL << kUseHi) |
| 89 | #define REG_DEF_LO (1ULL << kDefLo) |
| 90 | #define REG_DEF_HI (1ULL << kDefHi) |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 91 | |
| 92 | // Common combo register usage patterns. |
| 93 | #define REG_DEF01 (REG_DEF0 | REG_DEF1) |
| 94 | #define REG_DEF01_USE2 (REG_DEF0 | REG_DEF1 | REG_USE2) |
| 95 | #define REG_DEF0_USE01 (REG_DEF0 | REG_USE01) |
| 96 | #define REG_DEF0_USE0 (REG_DEF0 | REG_USE0) |
| 97 | #define REG_DEF0_USE12 (REG_DEF0 | REG_USE12) |
Vladimir Marko | 3e5af82 | 2013-11-21 15:01:20 +0000 | [diff] [blame] | 98 | #define REG_DEF0_USE123 (REG_DEF0 | REG_USE123) |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 99 | #define REG_DEF0_USE1 (REG_DEF0 | REG_USE1) |
| 100 | #define REG_DEF0_USE2 (REG_DEF0 | REG_USE2) |
| 101 | #define REG_DEFAD_USEAD (REG_DEFAD_USEA | REG_USED) |
| 102 | #define REG_DEFAD_USEA (REG_DEFA_USEA | REG_DEFD) |
| 103 | #define REG_DEFA_USEA (REG_DEFA | REG_USEA) |
| 104 | #define REG_USE012 (REG_USE01 | REG_USE2) |
| 105 | #define REG_USE014 (REG_USE01 | REG_USE4) |
| 106 | #define REG_USE01 (REG_USE0 | REG_USE1) |
| 107 | #define REG_USE02 (REG_USE0 | REG_USE2) |
| 108 | #define REG_USE12 (REG_USE1 | REG_USE2) |
| 109 | #define REG_USE23 (REG_USE2 | REG_USE3) |
Vladimir Marko | 3e5af82 | 2013-11-21 15:01:20 +0000 | [diff] [blame] | 110 | #define REG_USE123 (REG_USE1 | REG_USE2 | REG_USE3) |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 111 | |
| 112 | struct BasicBlock; |
| 113 | struct CallInfo; |
| 114 | struct CompilationUnit; |
Vladimir Marko | 5816ed4 | 2013-11-27 17:04:20 +0000 | [diff] [blame] | 115 | struct InlineMethod; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 116 | struct MIR; |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 117 | struct LIR; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 118 | struct RegLocation; |
| 119 | struct RegisterInfo; |
Vladimir Marko | 5c96e6b | 2013-11-14 15:34:17 +0000 | [diff] [blame] | 120 | class DexFileMethodInliner; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 121 | class MIRGraph; |
| 122 | class Mir2Lir; |
| 123 | |
| 124 | typedef int (*NextCallInsn)(CompilationUnit*, CallInfo*, int, |
| 125 | const MethodReference& target_method, |
| 126 | uint32_t method_idx, uintptr_t direct_code, |
| 127 | uintptr_t direct_method, InvokeType type); |
| 128 | |
| 129 | typedef std::vector<uint8_t> CodeBuffer; |
| 130 | |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 131 | struct UseDefMasks { |
| 132 | uint64_t use_mask; // Resource mask for use. |
| 133 | uint64_t def_mask; // Resource mask for def. |
| 134 | }; |
| 135 | |
| 136 | struct AssemblyInfo { |
| 137 | LIR* pcrel_next; // Chain of LIR nodes needing pc relative fixups. |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 138 | }; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 139 | |
| 140 | struct LIR { |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 141 | CodeOffset offset; // Offset of this instruction. |
| 142 | NarrowDexOffset dalvik_offset; // Offset of Dalvik opcode in code units (16-bit words). |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 143 | int16_t opcode; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 144 | LIR* next; |
| 145 | LIR* prev; |
| 146 | LIR* target; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 147 | struct { |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 148 | unsigned int alias_info:17; // For Dalvik register disambiguation. |
| 149 | bool is_nop:1; // LIR is optimized away. |
| 150 | unsigned int size:4; // Note: size of encoded instruction is in bytes. |
| 151 | bool use_def_invalid:1; // If true, masks should not be used. |
| 152 | unsigned int generation:1; // Used to track visitation state during fixup pass. |
| 153 | unsigned int fixup:8; // Fixup kind. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 154 | } flags; |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 155 | union { |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 156 | UseDefMasks m; // Use & Def masks used during optimization. |
Vladimir Marko | 306f017 | 2014-01-07 18:21:20 +0000 | [diff] [blame] | 157 | AssemblyInfo a; // Instruction info used during assembly phase. |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 158 | } u; |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 159 | int32_t operands[5]; // [0..4] = [dest, src1, src2, extra, extra2]. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 160 | }; |
| 161 | |
| 162 | // Target-specific initialization. |
| 163 | Mir2Lir* ArmCodeGenerator(CompilationUnit* const cu, MIRGraph* const mir_graph, |
| 164 | ArenaAllocator* const arena); |
| 165 | Mir2Lir* MipsCodeGenerator(CompilationUnit* const cu, MIRGraph* const mir_graph, |
| 166 | ArenaAllocator* const arena); |
| 167 | Mir2Lir* X86CodeGenerator(CompilationUnit* const cu, MIRGraph* const mir_graph, |
| 168 | ArenaAllocator* const arena); |
| 169 | |
| 170 | // Utility macros to traverse the LIR list. |
| 171 | #define NEXT_LIR(lir) (lir->next) |
| 172 | #define PREV_LIR(lir) (lir->prev) |
| 173 | |
| 174 | // Defines for alias_info (tracks Dalvik register references). |
| 175 | #define DECODE_ALIAS_INFO_REG(X) (X & 0xffff) |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 176 | #define DECODE_ALIAS_INFO_WIDE_FLAG (0x10000) |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 177 | #define DECODE_ALIAS_INFO_WIDE(X) ((X & DECODE_ALIAS_INFO_WIDE_FLAG) ? 1 : 0) |
| 178 | #define ENCODE_ALIAS_INFO(REG, ISWIDE) (REG | (ISWIDE ? DECODE_ALIAS_INFO_WIDE_FLAG : 0)) |
| 179 | |
| 180 | // Common resource macros. |
| 181 | #define ENCODE_CCODE (1ULL << kCCode) |
| 182 | #define ENCODE_FP_STATUS (1ULL << kFPStatus) |
| 183 | |
| 184 | // Abstract memory locations. |
| 185 | #define ENCODE_DALVIK_REG (1ULL << kDalvikReg) |
| 186 | #define ENCODE_LITERAL (1ULL << kLiteral) |
| 187 | #define ENCODE_HEAP_REF (1ULL << kHeapRef) |
| 188 | #define ENCODE_MUST_NOT_ALIAS (1ULL << kMustNotAlias) |
| 189 | |
| 190 | #define ENCODE_ALL (~0ULL) |
| 191 | #define ENCODE_MEM (ENCODE_DALVIK_REG | ENCODE_LITERAL | \ |
| 192 | ENCODE_HEAP_REF | ENCODE_MUST_NOT_ALIAS) |
buzbee | c729a6b | 2013-09-14 16:04:31 -0700 | [diff] [blame] | 193 | |
Razvan A Lupusoru | 3bc0174 | 2014-02-06 13:18:43 -0800 | [diff] [blame] | 194 | #define ENCODE_REG_PAIR(low_reg, high_reg) ((low_reg & 0xff) | ((high_reg & 0xff) << 8)) |
| 195 | #define DECODE_REG_PAIR(both_regs, low_reg, high_reg) \ |
| 196 | do { \ |
| 197 | low_reg = both_regs & 0xff; \ |
| 198 | high_reg = (both_regs >> 8) & 0xff; \ |
| 199 | } while (false) |
| 200 | |
buzbee | c729a6b | 2013-09-14 16:04:31 -0700 | [diff] [blame] | 201 | // Mask to denote sreg as the start of a double. Must not interfere with low 16 bits. |
| 202 | #define STARTING_DOUBLE_SREG 0x10000 |
| 203 | |
Brian Carlstrom | 7934ac2 | 2013-07-26 10:54:15 -0700 | [diff] [blame] | 204 | // TODO: replace these macros |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 205 | #define SLOW_FIELD_PATH (cu_->enable_debug & (1 << kDebugSlowFieldPath)) |
| 206 | #define SLOW_INVOKE_PATH (cu_->enable_debug & (1 << kDebugSlowInvokePath)) |
| 207 | #define SLOW_STRING_PATH (cu_->enable_debug & (1 << kDebugSlowStringPath)) |
| 208 | #define SLOW_TYPE_PATH (cu_->enable_debug & (1 << kDebugSlowTypePath)) |
| 209 | #define EXERCISE_SLOWEST_STRING_PATH (cu_->enable_debug & (1 << kDebugSlowestStringPath)) |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 210 | |
| 211 | class Mir2Lir : public Backend { |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 212 | public: |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 213 | /* |
| 214 | * Auxiliary information describing the location of data embedded in the Dalvik |
| 215 | * byte code stream. |
| 216 | */ |
| 217 | struct EmbeddedData { |
| 218 | CodeOffset offset; // Code offset of data block. |
| 219 | const uint16_t* table; // Original dex data. |
| 220 | DexOffset vaddr; // Dalvik offset of parent opcode. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 221 | }; |
| 222 | |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 223 | struct FillArrayData : EmbeddedData { |
| 224 | int32_t size; |
| 225 | }; |
| 226 | |
| 227 | struct SwitchTable : EmbeddedData { |
| 228 | LIR* anchor; // Reference instruction for relative offsets. |
| 229 | LIR** targets; // Array of case targets. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 230 | }; |
| 231 | |
| 232 | /* Static register use counts */ |
| 233 | struct RefCounts { |
| 234 | int count; |
| 235 | int s_reg; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 236 | }; |
| 237 | |
| 238 | /* |
| 239 | * Data structure tracking the mapping between a Dalvik register (pair) and a |
| 240 | * native register (pair). The idea is to reuse the previously loaded value |
| 241 | * if possible, otherwise to keep the value in a native register as long as |
| 242 | * possible. |
| 243 | */ |
| 244 | struct RegisterInfo { |
| 245 | int reg; // Reg number |
| 246 | bool in_use; // Has it been allocated? |
| 247 | bool is_temp; // Can allocate as temp? |
| 248 | bool pair; // Part of a register pair? |
| 249 | int partner; // If pair, other reg of pair. |
| 250 | bool live; // Is there an associated SSA name? |
| 251 | bool dirty; // If live, is it dirty? |
| 252 | int s_reg; // Name of live value. |
| 253 | LIR *def_start; // Starting inst in last def sequence. |
| 254 | LIR *def_end; // Ending inst in last def sequence. |
| 255 | }; |
| 256 | |
Brian Carlstrom | 6f485c6 | 2013-07-18 15:35:35 -0700 | [diff] [blame] | 257 | struct RegisterPool { |
| 258 | int num_core_regs; |
| 259 | RegisterInfo *core_regs; |
| 260 | int next_core_reg; |
| 261 | int num_fp_regs; |
| 262 | RegisterInfo *FPRegs; |
| 263 | int next_fp_reg; |
| 264 | }; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 265 | |
| 266 | struct PromotionMap { |
| 267 | RegLocationType core_location:3; |
| 268 | uint8_t core_reg; |
| 269 | RegLocationType fp_location:3; |
| 270 | uint8_t FpReg; |
| 271 | bool first_in_pair; |
| 272 | }; |
| 273 | |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 274 | // |
| 275 | // Slow paths. This object is used generate a sequence of code that is executed in the |
| 276 | // slow path. For example, resolving a string or class is slow as it will only be executed |
| 277 | // once (after that it is resolved and doesn't need to be done again). We want slow paths |
| 278 | // to be placed out-of-line, and not require a (mispredicted, probably) conditional forward |
| 279 | // branch over them. |
| 280 | // |
| 281 | // If you want to create a slow path, declare a class derived from LIRSlowPath and provide |
| 282 | // the Compile() function that will be called near the end of the code generated by the |
| 283 | // method. |
| 284 | // |
| 285 | // The basic flow for a slow path is: |
| 286 | // |
| 287 | // CMP reg, #value |
| 288 | // BEQ fromfast |
| 289 | // cont: |
| 290 | // ... |
| 291 | // fast path code |
| 292 | // ... |
| 293 | // more code |
| 294 | // ... |
| 295 | // RETURN |
| 296 | /// |
| 297 | // fromfast: |
| 298 | // ... |
| 299 | // slow path code |
| 300 | // ... |
| 301 | // B cont |
| 302 | // |
| 303 | // So you see we need two labels and two branches. The first branch (called fromfast) is |
| 304 | // the conditional branch to the slow path code. The second label (called cont) is used |
| 305 | // as an unconditional branch target for getting back to the code after the slow path |
| 306 | // has completed. |
| 307 | // |
| 308 | |
| 309 | class LIRSlowPath { |
| 310 | public: |
| 311 | LIRSlowPath(Mir2Lir* m2l, const DexOffset dexpc, LIR* fromfast, |
| 312 | LIR* cont = nullptr) : |
| 313 | m2l_(m2l), current_dex_pc_(dexpc), fromfast_(fromfast), cont_(cont) { |
| 314 | } |
| 315 | virtual ~LIRSlowPath() {} |
| 316 | virtual void Compile() = 0; |
| 317 | |
| 318 | static void* operator new(size_t size, ArenaAllocator* arena) { |
Vladimir Marko | 83cc7ae | 2014-02-12 18:02:05 +0000 | [diff] [blame] | 319 | return arena->Alloc(size, kArenaAllocData); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 320 | } |
| 321 | |
| 322 | protected: |
| 323 | LIR* GenerateTargetLabel(); |
| 324 | |
| 325 | Mir2Lir* const m2l_; |
| 326 | const DexOffset current_dex_pc_; |
| 327 | LIR* const fromfast_; |
| 328 | LIR* const cont_; |
| 329 | }; |
| 330 | |
Brian Carlstrom | 9b7085a | 2013-07-18 15:15:21 -0700 | [diff] [blame] | 331 | virtual ~Mir2Lir() {} |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 332 | |
| 333 | int32_t s4FromSwitchData(const void* switch_data) { |
| 334 | return *reinterpret_cast<const int32_t*>(switch_data); |
| 335 | } |
| 336 | |
| 337 | RegisterClass oat_reg_class_by_size(OpSize size) { |
| 338 | return (size == kUnsignedHalf || size == kSignedHalf || size == kUnsignedByte || |
Brian Carlstrom | df62950 | 2013-07-17 22:39:56 -0700 | [diff] [blame] | 339 | size == kSignedByte) ? kCoreReg : kAnyReg; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 340 | } |
| 341 | |
| 342 | size_t CodeBufferSizeInBytes() { |
| 343 | return code_buffer_.size() / sizeof(code_buffer_[0]); |
| 344 | } |
| 345 | |
Vladimir Marko | 306f017 | 2014-01-07 18:21:20 +0000 | [diff] [blame] | 346 | static bool IsPseudoLirOp(int opcode) { |
buzbee | 409fe94 | 2013-10-11 10:49:56 -0700 | [diff] [blame] | 347 | return (opcode < 0); |
| 348 | } |
| 349 | |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 350 | /* |
| 351 | * LIR operands are 32-bit integers. Sometimes, (especially for managing |
| 352 | * instructions which require PC-relative fixups), we need the operands to carry |
| 353 | * pointers. To do this, we assign these pointers an index in pointer_storage_, and |
| 354 | * hold that index in the operand array. |
| 355 | * TUNING: If use of these utilities becomes more common on 32-bit builds, it |
| 356 | * may be worth conditionally-compiling a set of identity functions here. |
| 357 | */ |
| 358 | uint32_t WrapPointer(void* pointer) { |
| 359 | uint32_t res = pointer_storage_.Size(); |
| 360 | pointer_storage_.Insert(pointer); |
| 361 | return res; |
| 362 | } |
| 363 | |
| 364 | void* UnwrapPointer(size_t index) { |
| 365 | return pointer_storage_.Get(index); |
| 366 | } |
| 367 | |
| 368 | // strdup(), but allocates from the arena. |
| 369 | char* ArenaStrdup(const char* str) { |
| 370 | size_t len = strlen(str) + 1; |
Vladimir Marko | 83cc7ae | 2014-02-12 18:02:05 +0000 | [diff] [blame] | 371 | char* res = reinterpret_cast<char*>(arena_->Alloc(len, kArenaAllocMisc)); |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 372 | if (res != NULL) { |
| 373 | strncpy(res, str, len); |
| 374 | } |
| 375 | return res; |
| 376 | } |
| 377 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 378 | // Shared by all targets - implemented in codegen_util.cc |
| 379 | void AppendLIR(LIR* lir); |
| 380 | void InsertLIRBefore(LIR* current_lir, LIR* new_lir); |
| 381 | void InsertLIRAfter(LIR* current_lir, LIR* new_lir); |
| 382 | |
Razvan A Lupusoru | da7a69b | 2014-01-08 15:09:50 -0800 | [diff] [blame] | 383 | /** |
| 384 | * @brief Provides the maximum number of compiler temporaries that the backend can/wants |
| 385 | * to place in a frame. |
| 386 | * @return Returns the maximum number of compiler temporaries. |
| 387 | */ |
| 388 | size_t GetMaxPossibleCompilerTemps() const; |
| 389 | |
| 390 | /** |
| 391 | * @brief Provides the number of bytes needed in frame for spilling of compiler temporaries. |
| 392 | * @return Returns the size in bytes for space needed for compiler temporary spill region. |
| 393 | */ |
| 394 | size_t GetNumBytesForCompilerTempSpillRegion(); |
| 395 | |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 396 | DexOffset GetCurrentDexPc() const { |
| 397 | return current_dalvik_offset_; |
| 398 | } |
| 399 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 400 | int ComputeFrameSize(); |
| 401 | virtual void Materialize(); |
| 402 | virtual CompiledMethod* GetCompiledMethod(); |
| 403 | void MarkSafepointPC(LIR* inst); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 404 | void SetupResourceMasks(LIR* lir); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 405 | void SetMemRefType(LIR* lir, bool is_load, int mem_type); |
| 406 | void AnnotateDalvikRegAccess(LIR* lir, int reg_id, bool is_load, bool is64bit); |
| 407 | void SetupRegMask(uint64_t* mask, int reg); |
| 408 | void DumpLIRInsn(LIR* arg, unsigned char* base_addr); |
| 409 | void DumpPromotionMap(); |
| 410 | void CodegenDump(); |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 411 | LIR* RawLIR(DexOffset dalvik_offset, int opcode, int op0 = 0, int op1 = 0, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 412 | int op2 = 0, int op3 = 0, int op4 = 0, LIR* target = NULL); |
| 413 | LIR* NewLIR0(int opcode); |
| 414 | LIR* NewLIR1(int opcode, int dest); |
| 415 | LIR* NewLIR2(int opcode, int dest, int src1); |
Razvan A Lupusoru | 614c2b4 | 2014-01-28 17:05:21 -0800 | [diff] [blame] | 416 | LIR* NewLIR2NoDest(int opcode, int src, int info); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 417 | LIR* NewLIR3(int opcode, int dest, int src1, int src2); |
| 418 | LIR* NewLIR4(int opcode, int dest, int src1, int src2, int info); |
| 419 | LIR* NewLIR5(int opcode, int dest, int src1, int src2, int info1, int info2); |
| 420 | LIR* ScanLiteralPool(LIR* data_target, int value, unsigned int delta); |
| 421 | LIR* ScanLiteralPoolWide(LIR* data_target, int val_lo, int val_hi); |
| 422 | LIR* AddWordData(LIR* *constant_list_p, int value); |
| 423 | LIR* AddWideData(LIR* *constant_list_p, int val_lo, int val_hi); |
| 424 | void ProcessSwitchTables(); |
| 425 | void DumpSparseSwitchTable(const uint16_t* table); |
| 426 | void DumpPackedSwitchTable(const uint16_t* table); |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 427 | void MarkBoundary(DexOffset offset, const char* inst_str); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 428 | void NopLIR(LIR* lir); |
buzbee | 252254b | 2013-09-08 16:20:53 -0700 | [diff] [blame] | 429 | void UnlinkLIR(LIR* lir); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 430 | bool EvaluateBranch(Instruction::Code opcode, int src1, int src2); |
| 431 | bool IsInexpensiveConstant(RegLocation rl_src); |
| 432 | ConditionCode FlipComparisonOrder(ConditionCode before); |
Vladimir Marko | a1a7074 | 2014-03-03 10:28:05 +0000 | [diff] [blame] | 433 | ConditionCode NegateComparison(ConditionCode before); |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 434 | virtual void InstallLiteralPools(); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 435 | void InstallSwitchTables(); |
| 436 | void InstallFillArrayData(); |
| 437 | bool VerifyCatchEntries(); |
| 438 | void CreateMappingTables(); |
| 439 | void CreateNativeGcMap(); |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 440 | int AssignLiteralOffset(CodeOffset offset); |
| 441 | int AssignSwitchTablesOffset(CodeOffset offset); |
| 442 | int AssignFillArrayDataOffset(CodeOffset offset); |
| 443 | LIR* InsertCaseLabel(DexOffset vaddr, int keyVal); |
| 444 | void MarkPackedCaseLabels(Mir2Lir::SwitchTable* tab_rec); |
| 445 | void MarkSparseCaseLabels(Mir2Lir::SwitchTable* tab_rec); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 446 | // Handle bookkeeping to convert a wide RegLocation to a narow RegLocation. No code generated. |
| 447 | RegLocation NarrowRegLoc(RegLocation loc); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 448 | |
| 449 | // Shared by all targets - implemented in local_optimizations.cc |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 450 | void ConvertMemOpIntoMove(LIR* orig_lir, RegStorage dest, RegStorage src); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 451 | void ApplyLoadStoreElimination(LIR* head_lir, LIR* tail_lir); |
| 452 | void ApplyLoadHoisting(LIR* head_lir, LIR* tail_lir); |
| 453 | void ApplyLocalOptimizations(LIR* head_lir, LIR* tail_lir); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 454 | |
| 455 | // Shared by all targets - implemented in ralloc_util.cc |
| 456 | int GetSRegHi(int lowSreg); |
| 457 | bool oat_live_out(int s_reg); |
| 458 | int oatSSASrc(MIR* mir, int num); |
| 459 | void SimpleRegAlloc(); |
| 460 | void ResetRegPool(); |
| 461 | void CompilerInitPool(RegisterInfo* regs, int* reg_nums, int num); |
| 462 | void DumpRegPool(RegisterInfo* p, int num_regs); |
| 463 | void DumpCoreRegPool(); |
| 464 | void DumpFpRegPool(); |
| 465 | /* Mark a temp register as dead. Does not affect allocation state. */ |
| 466 | void Clobber(int reg) { |
| 467 | ClobberBody(GetRegInfo(reg)); |
| 468 | } |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 469 | void Clobber(RegStorage reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 470 | void ClobberSRegBody(RegisterInfo* p, int num_regs, int s_reg); |
| 471 | void ClobberSReg(int s_reg); |
| 472 | int SRegToPMap(int s_reg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 473 | void RecordCorePromotion(RegStorage reg, int s_reg); |
| 474 | RegStorage AllocPreservedCoreReg(int s_reg); |
| 475 | void RecordFpPromotion(RegStorage reg, int s_reg); |
| 476 | RegStorage AllocPreservedSingle(int s_reg); |
| 477 | RegStorage AllocPreservedDouble(int s_reg); |
| 478 | RegStorage AllocTempBody(RegisterInfo* p, int num_regs, int* next_temp, bool required); |
| 479 | virtual RegStorage AllocTempDouble(); |
| 480 | RegStorage AllocFreeTemp(); |
| 481 | RegStorage AllocTemp(); |
| 482 | RegStorage AllocTempFloat(); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 483 | RegisterInfo* AllocLiveBody(RegisterInfo* p, int num_regs, int s_reg); |
| 484 | RegisterInfo* AllocLive(int s_reg, int reg_class); |
| 485 | void FreeTemp(int reg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 486 | void FreeTemp(RegStorage reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 487 | RegisterInfo* IsLive(int reg); |
buzbee | 262b299 | 2014-03-27 11:22:43 -0700 | [diff] [blame] | 488 | bool IsLive(RegStorage reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 489 | RegisterInfo* IsTemp(int reg); |
buzbee | 262b299 | 2014-03-27 11:22:43 -0700 | [diff] [blame] | 490 | bool IsTemp(RegStorage reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 491 | RegisterInfo* IsPromoted(int reg); |
buzbee | 262b299 | 2014-03-27 11:22:43 -0700 | [diff] [blame] | 492 | bool IsPromoted(RegStorage reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 493 | bool IsDirty(int reg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 494 | bool IsDirty(RegStorage reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 495 | void LockTemp(int reg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 496 | void LockTemp(RegStorage reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 497 | void ResetDef(int reg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 498 | void ResetDef(RegStorage reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 499 | void NullifyRange(LIR *start, LIR *finish, int s_reg1, int s_reg2); |
| 500 | void MarkDef(RegLocation rl, LIR *start, LIR *finish); |
| 501 | void MarkDefWide(RegLocation rl, LIR *start, LIR *finish); |
| 502 | RegLocation WideToNarrow(RegLocation rl); |
| 503 | void ResetDefLoc(RegLocation rl); |
Bill Buzbee | d61ba4b | 2014-01-13 21:44:01 +0000 | [diff] [blame] | 504 | virtual void ResetDefLocWide(RegLocation rl); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 505 | void ResetDefTracking(); |
| 506 | void ClobberAllRegs(); |
Razvan A Lupusoru | 614c2b4 | 2014-01-28 17:05:21 -0800 | [diff] [blame] | 507 | void FlushSpecificReg(RegisterInfo* info); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 508 | void FlushAllRegsBody(RegisterInfo* info, int num_regs); |
| 509 | void FlushAllRegs(); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 510 | bool RegClassMatches(int reg_class, RegStorage reg); |
| 511 | void MarkLive(RegStorage reg, int s_reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 512 | void MarkTemp(int reg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 513 | void MarkTemp(RegStorage reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 514 | void UnmarkTemp(int reg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 515 | void UnmarkTemp(RegStorage reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 516 | void MarkPair(int low_reg, int high_reg); |
| 517 | void MarkClean(RegLocation loc); |
| 518 | void MarkDirty(RegLocation loc); |
| 519 | void MarkInUse(int reg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 520 | void MarkInUse(RegStorage reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 521 | void CopyRegInfo(int new_reg, int old_reg); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 522 | void CopyRegInfo(RegStorage new_reg, RegStorage old_reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 523 | bool CheckCorePoolSanity(); |
| 524 | RegLocation UpdateLoc(RegLocation loc); |
Bill Buzbee | d61ba4b | 2014-01-13 21:44:01 +0000 | [diff] [blame] | 525 | virtual RegLocation UpdateLocWide(RegLocation loc); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 526 | RegLocation UpdateRawLoc(RegLocation loc); |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 527 | |
| 528 | /** |
| 529 | * @brief Used to load register location into a typed temporary or pair of temporaries. |
| 530 | * @see EvalLoc |
| 531 | * @param loc The register location to load from. |
| 532 | * @param reg_class Type of register needed. |
| 533 | * @param update Whether the liveness information should be updated. |
| 534 | * @return Returns the properly typed temporary in physical register pairs. |
| 535 | */ |
Bill Buzbee | d61ba4b | 2014-01-13 21:44:01 +0000 | [diff] [blame] | 536 | virtual RegLocation EvalLocWide(RegLocation loc, int reg_class, bool update); |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 537 | |
| 538 | /** |
| 539 | * @brief Used to load register location into a typed temporary. |
| 540 | * @param loc The register location to load from. |
| 541 | * @param reg_class Type of register needed. |
| 542 | * @param update Whether the liveness information should be updated. |
| 543 | * @return Returns the properly typed temporary in physical register. |
| 544 | */ |
Bill Buzbee | d61ba4b | 2014-01-13 21:44:01 +0000 | [diff] [blame] | 545 | virtual RegLocation EvalLoc(RegLocation loc, int reg_class, bool update); |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 546 | |
buzbee | c729a6b | 2013-09-14 16:04:31 -0700 | [diff] [blame] | 547 | void CountRefs(RefCounts* core_counts, RefCounts* fp_counts, size_t num_regs); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 548 | void DumpCounts(const RefCounts* arr, int size, const char* msg); |
| 549 | void DoPromotion(); |
| 550 | int VRegOffset(int v_reg); |
| 551 | int SRegOffset(int s_reg); |
| 552 | RegLocation GetReturnWide(bool is_double); |
| 553 | RegLocation GetReturn(bool is_float); |
buzbee | bd663de | 2013-09-10 15:41:31 -0700 | [diff] [blame] | 554 | RegisterInfo* GetRegInfo(int reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 555 | |
| 556 | // Shared by all targets - implemented in gen_common.cc. |
Mingyao Yang | 3a74d15 | 2014-04-21 15:39:44 -0700 | [diff] [blame^] | 557 | void AddIntrinsicSlowPath(CallInfo* info, LIR* branch, LIR* resume = nullptr); |
buzbee | 11b63d1 | 2013-08-27 07:34:17 -0700 | [diff] [blame] | 558 | bool HandleEasyDivRem(Instruction::Code dalvik_opcode, bool is_div, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 559 | RegLocation rl_src, RegLocation rl_dest, int lit); |
| 560 | bool HandleEasyMultiply(RegLocation rl_src, RegLocation rl_dest, int lit); |
| 561 | void HandleSuspendLaunchPads(); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 562 | void HandleSlowPaths(); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 563 | void GenBarrier(); |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 564 | void GenDivZeroException(); |
| 565 | // c_code holds condition code that's generated from testing divisor against 0. |
| 566 | void GenDivZeroCheck(ConditionCode c_code); |
| 567 | // reg holds divisor. |
| 568 | void GenDivZeroCheck(RegStorage reg); |
Mingyao Yang | 80365d9 | 2014-04-18 12:10:58 -0700 | [diff] [blame] | 569 | void GenArrayBoundsCheck(RegStorage index, RegStorage length); |
| 570 | void GenArrayBoundsCheck(int32_t index, RegStorage length); |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 571 | LIR* GenNullCheck(RegStorage reg); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 572 | void MarkPossibleNullPointerException(int opt_flags); |
| 573 | void MarkPossibleStackOverflowException(); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 574 | void ForceImplicitNullCheck(RegStorage reg, int opt_flags); |
| 575 | LIR* GenImmedCheck(ConditionCode c_code, RegStorage reg, int imm_val, ThrowKind kind); |
| 576 | LIR* GenNullCheck(RegStorage m_reg, int opt_flags); |
Dave Allison | f943914 | 2014-03-27 15:10:22 -0700 | [diff] [blame] | 577 | LIR* GenExplicitNullCheck(RegStorage m_reg, int opt_flags); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 578 | void GenCompareAndBranch(Instruction::Code opcode, RegLocation rl_src1, |
| 579 | RegLocation rl_src2, LIR* taken, LIR* fall_through); |
| 580 | void GenCompareZeroAndBranch(Instruction::Code opcode, RegLocation rl_src, |
| 581 | LIR* taken, LIR* fall_through); |
| 582 | void GenIntToLong(RegLocation rl_dest, RegLocation rl_src); |
| 583 | void GenIntNarrowing(Instruction::Code opcode, RegLocation rl_dest, |
| 584 | RegLocation rl_src); |
| 585 | void GenNewArray(uint32_t type_idx, RegLocation rl_dest, |
| 586 | RegLocation rl_src); |
| 587 | void GenFilledNewArray(CallInfo* info); |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 588 | void GenSput(MIR* mir, RegLocation rl_src, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 589 | bool is_long_or_double, bool is_object); |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 590 | void GenSget(MIR* mir, RegLocation rl_dest, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 591 | bool is_long_or_double, bool is_object); |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 592 | void GenIGet(MIR* mir, int opt_flags, OpSize size, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 593 | RegLocation rl_dest, RegLocation rl_obj, bool is_long_or_double, bool is_object); |
Vladimir Marko | be0e546 | 2014-02-26 11:24:15 +0000 | [diff] [blame] | 594 | void GenIPut(MIR* mir, int opt_flags, OpSize size, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 595 | RegLocation rl_src, RegLocation rl_obj, bool is_long_or_double, bool is_object); |
Ian Rogers | a9a8254 | 2013-10-04 11:17:26 -0700 | [diff] [blame] | 596 | void GenArrayObjPut(int opt_flags, RegLocation rl_array, RegLocation rl_index, |
| 597 | RegLocation rl_src); |
| 598 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 599 | void GenConstClass(uint32_t type_idx, RegLocation rl_dest); |
| 600 | void GenConstString(uint32_t string_idx, RegLocation rl_dest); |
| 601 | void GenNewInstance(uint32_t type_idx, RegLocation rl_dest); |
| 602 | void GenThrow(RegLocation rl_src); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 603 | void GenInstanceof(uint32_t type_idx, RegLocation rl_dest, RegLocation rl_src); |
| 604 | void GenCheckCast(uint32_t insn_idx, uint32_t type_idx, RegLocation rl_src); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 605 | void GenLong3Addr(OpKind first_op, OpKind second_op, RegLocation rl_dest, |
| 606 | RegLocation rl_src1, RegLocation rl_src2); |
| 607 | void GenShiftOpLong(Instruction::Code opcode, RegLocation rl_dest, |
| 608 | RegLocation rl_src1, RegLocation rl_shift); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 609 | void GenArithOpIntLit(Instruction::Code opcode, RegLocation rl_dest, |
| 610 | RegLocation rl_src, int lit); |
| 611 | void GenArithOpLong(Instruction::Code opcode, RegLocation rl_dest, |
| 612 | RegLocation rl_src1, RegLocation rl_src2); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 613 | void GenConversionCall(ThreadOffset<4> func_offset, RegLocation rl_dest, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 614 | RegLocation rl_src); |
| 615 | void GenSuspendTest(int opt_flags); |
| 616 | void GenSuspendTestAndBranch(int opt_flags, LIR* target); |
Mark Mendell | feb2b4e | 2014-01-28 12:59:49 -0800 | [diff] [blame] | 617 | |
Bill Buzbee | d61ba4b | 2014-01-13 21:44:01 +0000 | [diff] [blame] | 618 | // This will be overridden by x86 implementation. |
| 619 | virtual void GenConstWide(RegLocation rl_dest, int64_t value); |
Mark Mendell | feb2b4e | 2014-01-28 12:59:49 -0800 | [diff] [blame] | 620 | virtual void GenArithOpInt(Instruction::Code opcode, RegLocation rl_dest, |
| 621 | RegLocation rl_src1, RegLocation rl_src2); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 622 | |
| 623 | // Shared by all targets - implemented in gen_invoke.cc. |
Dave Allison | d6ed642 | 2014-04-09 23:36:15 +0000 | [diff] [blame] | 624 | LIR* CallHelper(RegStorage r_tgt, ThreadOffset<4> helper_offset, bool safepoint_pc, |
| 625 | bool use_link = true); |
| 626 | RegStorage CallHelperSetup(ThreadOffset<4> helper_offset); |
Mingyao Yang | 4289456 | 2014-04-07 12:42:16 -0700 | [diff] [blame] | 627 | void CallRuntimeHelper(ThreadOffset<4> helper_offset, bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 628 | void CallRuntimeHelperImm(ThreadOffset<4> helper_offset, int arg0, bool safepoint_pc); |
| 629 | void CallRuntimeHelperReg(ThreadOffset<4> helper_offset, RegStorage arg0, bool safepoint_pc); |
| 630 | void CallRuntimeHelperRegLocation(ThreadOffset<4> helper_offset, RegLocation arg0, |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 631 | bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 632 | void CallRuntimeHelperImmImm(ThreadOffset<4> helper_offset, int arg0, int arg1, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 633 | bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 634 | void CallRuntimeHelperImmRegLocation(ThreadOffset<4> helper_offset, int arg0, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 635 | RegLocation arg1, bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 636 | void CallRuntimeHelperRegLocationImm(ThreadOffset<4> helper_offset, RegLocation arg0, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 637 | int arg1, bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 638 | void CallRuntimeHelperImmReg(ThreadOffset<4> helper_offset, int arg0, RegStorage arg1, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 639 | bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 640 | void CallRuntimeHelperRegImm(ThreadOffset<4> helper_offset, RegStorage arg0, int arg1, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 641 | bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 642 | void CallRuntimeHelperImmMethod(ThreadOffset<4> helper_offset, int arg0, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 643 | bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 644 | void CallRuntimeHelperRegMethod(ThreadOffset<4> helper_offset, RegStorage arg0, |
| 645 | bool safepoint_pc); |
| 646 | void CallRuntimeHelperRegMethodRegLocation(ThreadOffset<4> helper_offset, RegStorage arg0, |
Hiroshi Yamauchi | bb8f0ab | 2014-01-27 16:50:29 -0800 | [diff] [blame] | 647 | RegLocation arg2, bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 648 | void CallRuntimeHelperRegLocationRegLocation(ThreadOffset<4> helper_offset, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 649 | RegLocation arg0, RegLocation arg1, |
| 650 | bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 651 | void CallRuntimeHelperRegReg(ThreadOffset<4> helper_offset, RegStorage arg0, RegStorage arg1, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 652 | bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 653 | void CallRuntimeHelperRegRegImm(ThreadOffset<4> helper_offset, RegStorage arg0, RegStorage arg1, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 654 | int arg2, bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 655 | void CallRuntimeHelperImmMethodRegLocation(ThreadOffset<4> helper_offset, int arg0, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 656 | RegLocation arg2, bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 657 | void CallRuntimeHelperImmMethodImm(ThreadOffset<4> helper_offset, int arg0, int arg2, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 658 | bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 659 | void CallRuntimeHelperImmRegLocationRegLocation(ThreadOffset<4> helper_offset, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 660 | int arg0, RegLocation arg1, RegLocation arg2, |
| 661 | bool safepoint_pc); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 662 | void CallRuntimeHelperRegLocationRegLocationRegLocation(ThreadOffset<4> helper_offset, |
Ian Rogers | a9a8254 | 2013-10-04 11:17:26 -0700 | [diff] [blame] | 663 | RegLocation arg0, RegLocation arg1, |
| 664 | RegLocation arg2, |
| 665 | bool safepoint_pc); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 666 | void GenInvoke(CallInfo* info); |
Vladimir Marko | 3bc8615 | 2014-03-13 14:11:28 +0000 | [diff] [blame] | 667 | void GenInvokeNoInline(CallInfo* info); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 668 | void FlushIns(RegLocation* ArgLocs, RegLocation rl_method); |
| 669 | int GenDalvikArgsNoRange(CallInfo* info, int call_state, LIR** pcrLabel, |
| 670 | NextCallInsn next_call_insn, |
| 671 | const MethodReference& target_method, |
| 672 | uint32_t vtable_idx, |
| 673 | uintptr_t direct_code, uintptr_t direct_method, InvokeType type, |
| 674 | bool skip_this); |
| 675 | int GenDalvikArgsRange(CallInfo* info, int call_state, LIR** pcrLabel, |
| 676 | NextCallInsn next_call_insn, |
| 677 | const MethodReference& target_method, |
| 678 | uint32_t vtable_idx, |
| 679 | uintptr_t direct_code, uintptr_t direct_method, InvokeType type, |
| 680 | bool skip_this); |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 681 | |
| 682 | /** |
| 683 | * @brief Used to determine the register location of destination. |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 684 | * @details This is needed during generation of inline intrinsics because it finds destination |
| 685 | * of return, |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 686 | * either the physical register or the target of move-result. |
| 687 | * @param info Information about the invoke. |
| 688 | * @return Returns the destination location. |
| 689 | */ |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 690 | RegLocation InlineTarget(CallInfo* info); |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 691 | |
| 692 | /** |
| 693 | * @brief Used to determine the wide register location of destination. |
| 694 | * @see InlineTarget |
| 695 | * @param info Information about the invoke. |
| 696 | * @return Returns the destination location. |
| 697 | */ |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 698 | RegLocation InlineTargetWide(CallInfo* info); |
| 699 | |
| 700 | bool GenInlinedCharAt(CallInfo* info); |
| 701 | bool GenInlinedStringIsEmptyOrLength(CallInfo* info, bool is_empty); |
Vladimir Marko | 6bdf1ff | 2013-10-29 17:40:46 +0000 | [diff] [blame] | 702 | bool GenInlinedReverseBytes(CallInfo* info, OpSize size); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 703 | bool GenInlinedAbsInt(CallInfo* info); |
| 704 | bool GenInlinedAbsLong(CallInfo* info); |
Yixin Shou | dbb17e3 | 2014-02-07 05:09:30 -0800 | [diff] [blame] | 705 | bool GenInlinedAbsFloat(CallInfo* info); |
| 706 | bool GenInlinedAbsDouble(CallInfo* info); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 707 | bool GenInlinedFloatCvt(CallInfo* info); |
| 708 | bool GenInlinedDoubleCvt(CallInfo* info); |
Mark Mendell | 4028a6c | 2014-02-19 20:06:20 -0800 | [diff] [blame] | 709 | virtual bool GenInlinedIndexOf(CallInfo* info, bool zero_based); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 710 | bool GenInlinedStringCompareTo(CallInfo* info); |
| 711 | bool GenInlinedCurrentThread(CallInfo* info); |
| 712 | bool GenInlinedUnsafeGet(CallInfo* info, bool is_long, bool is_volatile); |
| 713 | bool GenInlinedUnsafePut(CallInfo* info, bool is_long, bool is_object, |
| 714 | bool is_volatile, bool is_ordered); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 715 | int LoadArgRegs(CallInfo* info, int call_state, |
| 716 | NextCallInsn next_call_insn, |
| 717 | const MethodReference& target_method, |
| 718 | uint32_t vtable_idx, |
| 719 | uintptr_t direct_code, uintptr_t direct_method, InvokeType type, |
| 720 | bool skip_this); |
| 721 | |
| 722 | // Shared by all targets - implemented in gen_loadstore.cc. |
| 723 | RegLocation LoadCurrMethod(); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 724 | void LoadCurrMethodDirect(RegStorage r_tgt); |
| 725 | LIR* LoadConstant(RegStorage r_dest, int value); |
| 726 | LIR* LoadWordDisp(RegStorage r_base, int displacement, RegStorage r_dest); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 727 | RegLocation LoadValue(RegLocation rl_src, RegisterClass op_kind); |
| 728 | RegLocation LoadValueWide(RegLocation rl_src, RegisterClass op_kind); |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 729 | void LoadValueDirect(RegLocation rl_src, RegStorage r_dest); |
| 730 | void LoadValueDirectFixed(RegLocation rl_src, RegStorage r_dest); |
| 731 | void LoadValueDirectWide(RegLocation rl_src, RegStorage r_dest); |
| 732 | void LoadValueDirectWideFixed(RegLocation rl_src, RegStorage r_dest); |
| 733 | LIR* StoreWordDisp(RegStorage r_base, int displacement, RegStorage r_src); |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 734 | |
| 735 | /** |
| 736 | * @brief Used to do the final store in the destination as per bytecode semantics. |
| 737 | * @param rl_dest The destination dalvik register location. |
| 738 | * @param rl_src The source register location. Can be either physical register or dalvik register. |
| 739 | */ |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 740 | void StoreValue(RegLocation rl_dest, RegLocation rl_src); |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 741 | |
| 742 | /** |
| 743 | * @brief Used to do the final store in a wide destination as per bytecode semantics. |
| 744 | * @see StoreValue |
| 745 | * @param rl_dest The destination dalvik register location. |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 746 | * @param rl_src The source register location. Can be either physical register or dalvik |
| 747 | * register. |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 748 | */ |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 749 | void StoreValueWide(RegLocation rl_dest, RegLocation rl_src); |
| 750 | |
Mark Mendell | e02d48f | 2014-01-15 11:19:23 -0800 | [diff] [blame] | 751 | /** |
Mark Mendell | feb2b4e | 2014-01-28 12:59:49 -0800 | [diff] [blame] | 752 | * @brief Used to do the final store to a destination as per bytecode semantics. |
| 753 | * @see StoreValue |
| 754 | * @param rl_dest The destination dalvik register location. |
| 755 | * @param rl_src The source register location. It must be kLocPhysReg |
| 756 | * |
| 757 | * This is used for x86 two operand computations, where we have computed the correct |
| 758 | * register value that now needs to be properly registered. This is used to avoid an |
| 759 | * extra register copy that would result if StoreValue was called. |
| 760 | */ |
| 761 | void StoreFinalValue(RegLocation rl_dest, RegLocation rl_src); |
| 762 | |
| 763 | /** |
Mark Mendell | e02d48f | 2014-01-15 11:19:23 -0800 | [diff] [blame] | 764 | * @brief Used to do the final store in a wide destination as per bytecode semantics. |
| 765 | * @see StoreValueWide |
| 766 | * @param rl_dest The destination dalvik register location. |
| 767 | * @param rl_src The source register location. It must be kLocPhysReg |
| 768 | * |
| 769 | * This is used for x86 two operand computations, where we have computed the correct |
| 770 | * register values that now need to be properly registered. This is used to avoid an |
| 771 | * extra pair of register copies that would result if StoreValueWide was called. |
| 772 | */ |
| 773 | void StoreFinalValueWide(RegLocation rl_dest, RegLocation rl_src); |
| 774 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 775 | // Shared by all targets - implemented in mir_to_lir.cc. |
| 776 | void CompileDalvikInstruction(MIR* mir, BasicBlock* bb, LIR* label_list); |
| 777 | void HandleExtendedMethodMIR(BasicBlock* bb, MIR* mir); |
| 778 | bool MethodBlockCodeGen(BasicBlock* bb); |
Razvan A Lupusoru | 3bc0174 | 2014-02-06 13:18:43 -0800 | [diff] [blame] | 779 | bool SpecialMIR2LIR(const InlineMethod& special); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 780 | void MethodMIR2LIR(); |
| 781 | |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 782 | /* |
| 783 | * @brief Load the address of the dex method into the register. |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 784 | * @param target_method The MethodReference of the method to be invoked. |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 785 | * @param type How the method will be invoked. |
| 786 | * @param register that will contain the code address. |
| 787 | * @note register will be passed to TargetReg to get physical register. |
| 788 | */ |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 789 | void LoadCodeAddress(const MethodReference& target_method, InvokeType type, |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 790 | SpecialTargetRegister symbolic_reg); |
| 791 | |
| 792 | /* |
| 793 | * @brief Load the Method* of a dex method into the register. |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 794 | * @param target_method The MethodReference of the method to be invoked. |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 795 | * @param type How the method will be invoked. |
| 796 | * @param register that will contain the code address. |
| 797 | * @note register will be passed to TargetReg to get physical register. |
| 798 | */ |
Jeff Hao | 49161ce | 2014-03-12 11:05:25 -0700 | [diff] [blame] | 799 | virtual void LoadMethodAddress(const MethodReference& target_method, InvokeType type, |
Mark Mendell | 55d0eac | 2014-02-06 11:02:52 -0800 | [diff] [blame] | 800 | SpecialTargetRegister symbolic_reg); |
| 801 | |
| 802 | /* |
| 803 | * @brief Load the Class* of a Dex Class type into the register. |
| 804 | * @param type How the method will be invoked. |
| 805 | * @param register that will contain the code address. |
| 806 | * @note register will be passed to TargetReg to get physical register. |
| 807 | */ |
| 808 | virtual void LoadClassType(uint32_t type_idx, SpecialTargetRegister symbolic_reg); |
| 809 | |
Mark Mendell | 766e929 | 2014-01-27 07:55:47 -0800 | [diff] [blame] | 810 | // Routines that work for the generic case, but may be overriden by target. |
| 811 | /* |
| 812 | * @brief Compare memory to immediate, and branch if condition true. |
| 813 | * @param cond The condition code that when true will branch to the target. |
| 814 | * @param temp_reg A temporary register that can be used if compare to memory is not |
| 815 | * supported by the architecture. |
| 816 | * @param base_reg The register holding the base address. |
| 817 | * @param offset The offset from the base. |
| 818 | * @param check_value The immediate to compare to. |
| 819 | * @returns The branch instruction that was generated. |
| 820 | */ |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 821 | virtual LIR* OpCmpMemImmBranch(ConditionCode cond, RegStorage temp_reg, RegStorage base_reg, |
Mark Mendell | 766e929 | 2014-01-27 07:55:47 -0800 | [diff] [blame] | 822 | int offset, int check_value, LIR* target); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 823 | |
| 824 | // Required for target - codegen helpers. |
buzbee | 11b63d1 | 2013-08-27 07:34:17 -0700 | [diff] [blame] | 825 | virtual bool SmallLiteralDivRem(Instruction::Code dalvik_opcode, bool is_div, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 826 | RegLocation rl_src, RegLocation rl_dest, int lit) = 0; |
Ian Rogers | e2143c0 | 2014-03-28 08:47:16 -0700 | [diff] [blame] | 827 | virtual bool EasyMultiply(RegLocation rl_src, RegLocation rl_dest, int lit) = 0; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 828 | virtual LIR* CheckSuspendUsingLoad() = 0; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 829 | virtual RegStorage LoadHelper(ThreadOffset<4> offset) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 830 | virtual LIR* LoadBaseDisp(RegStorage r_base, int displacement, RegStorage r_dest, OpSize size, |
| 831 | int s_reg) = 0; |
| 832 | virtual LIR* LoadBaseDispWide(RegStorage r_base, int displacement, RegStorage r_dest, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 833 | int s_reg) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 834 | virtual LIR* LoadBaseIndexed(RegStorage r_base, RegStorage r_index, RegStorage r_dest, |
| 835 | int scale, OpSize size) = 0; |
| 836 | virtual LIR* LoadBaseIndexedDisp(RegStorage r_base, RegStorage r_index, int scale, |
| 837 | int displacement, RegStorage r_dest, RegStorage r_dest_hi, |
| 838 | OpSize size, int s_reg) = 0; |
| 839 | virtual LIR* LoadConstantNoClobber(RegStorage r_dest, int value) = 0; |
| 840 | virtual LIR* LoadConstantWide(RegStorage r_dest, int64_t value) = 0; |
| 841 | virtual LIR* StoreBaseDisp(RegStorage r_base, int displacement, RegStorage r_src, |
| 842 | OpSize size) = 0; |
| 843 | virtual LIR* StoreBaseDispWide(RegStorage r_base, int displacement, RegStorage r_src) = 0; |
| 844 | virtual LIR* StoreBaseIndexed(RegStorage r_base, RegStorage r_index, RegStorage r_src, |
| 845 | int scale, OpSize size) = 0; |
| 846 | virtual LIR* StoreBaseIndexedDisp(RegStorage r_base, RegStorage r_index, int scale, |
| 847 | int displacement, RegStorage r_src, RegStorage r_src_hi, |
| 848 | OpSize size, int s_reg) = 0; |
| 849 | virtual void MarkGCCard(RegStorage val_reg, RegStorage tgt_addr_reg) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 850 | |
| 851 | // Required for target - register utilities. |
| 852 | virtual bool IsFpReg(int reg) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 853 | virtual bool IsFpReg(RegStorage reg) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 854 | virtual bool SameRegType(int reg1, int reg2) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 855 | virtual RegStorage AllocTypedTemp(bool fp_hint, int reg_class) = 0; |
Bill Buzbee | 00e1ec6 | 2014-02-27 23:44:13 +0000 | [diff] [blame] | 856 | virtual RegStorage AllocTypedTempWide(bool fp_hint, int reg_class) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 857 | // TODO: elminate S2d. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 858 | virtual int S2d(int low_reg, int high_reg) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 859 | virtual RegStorage TargetReg(SpecialTargetRegister reg) = 0; |
| 860 | virtual RegStorage GetArgMappingToPhysicalReg(int arg_num) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 861 | virtual RegLocation GetReturnAlt() = 0; |
| 862 | virtual RegLocation GetReturnWideAlt() = 0; |
| 863 | virtual RegLocation LocCReturn() = 0; |
| 864 | virtual RegLocation LocCReturnDouble() = 0; |
| 865 | virtual RegLocation LocCReturnFloat() = 0; |
| 866 | virtual RegLocation LocCReturnWide() = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 867 | // TODO: use to reduce/eliminate xx_FPREG() macro use. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 868 | virtual uint32_t FpRegMask() = 0; |
| 869 | virtual uint64_t GetRegMaskCommon(int reg) = 0; |
| 870 | virtual void AdjustSpillMask() = 0; |
Vladimir Marko | 31c2aac | 2013-12-09 16:31:19 +0000 | [diff] [blame] | 871 | virtual void ClobberCallerSave() = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 872 | virtual void FlushReg(RegStorage reg) = 0; |
| 873 | virtual void FlushRegWide(RegStorage reg) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 874 | virtual void FreeCallTemps() = 0; |
| 875 | virtual void FreeRegLocTemps(RegLocation rl_keep, RegLocation rl_free) = 0; |
| 876 | virtual void LockCallTemps() = 0; |
| 877 | virtual void MarkPreservedSingle(int v_reg, int reg) = 0; |
| 878 | virtual void CompilerInitializeRegAlloc() = 0; |
| 879 | |
| 880 | // Required for target - miscellaneous. |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 881 | virtual void AssembleLIR() = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 882 | virtual void DumpResourceMask(LIR* lir, uint64_t mask, const char* prefix) = 0; |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 883 | virtual void SetupTargetResourceMasks(LIR* lir, uint64_t flags) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 884 | virtual const char* GetTargetInstFmt(int opcode) = 0; |
| 885 | virtual const char* GetTargetInstName(int opcode) = 0; |
| 886 | virtual std::string BuildInsnString(const char* fmt, LIR* lir, unsigned char* base_addr) = 0; |
| 887 | virtual uint64_t GetPCUseDefEncoding() = 0; |
| 888 | virtual uint64_t GetTargetInstFlags(int opcode) = 0; |
| 889 | virtual int GetInsnSize(LIR* lir) = 0; |
| 890 | virtual bool IsUnconditionalBranch(LIR* lir) = 0; |
| 891 | |
| 892 | // Required for target - Dalvik-level generators. |
| 893 | virtual void GenArithImmOpLong(Instruction::Code opcode, RegLocation rl_dest, |
| 894 | RegLocation rl_src1, RegLocation rl_src2) = 0; |
Mark Mendell | e02d48f | 2014-01-15 11:19:23 -0800 | [diff] [blame] | 895 | virtual void GenMulLong(Instruction::Code, |
| 896 | RegLocation rl_dest, RegLocation rl_src1, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 897 | RegLocation rl_src2) = 0; |
Mark Mendell | e02d48f | 2014-01-15 11:19:23 -0800 | [diff] [blame] | 898 | virtual void GenAddLong(Instruction::Code, |
| 899 | RegLocation rl_dest, RegLocation rl_src1, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 900 | RegLocation rl_src2) = 0; |
Mark Mendell | e02d48f | 2014-01-15 11:19:23 -0800 | [diff] [blame] | 901 | virtual void GenAndLong(Instruction::Code, |
| 902 | RegLocation rl_dest, RegLocation rl_src1, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 903 | RegLocation rl_src2) = 0; |
| 904 | virtual void GenArithOpDouble(Instruction::Code opcode, |
| 905 | RegLocation rl_dest, RegLocation rl_src1, |
| 906 | RegLocation rl_src2) = 0; |
| 907 | virtual void GenArithOpFloat(Instruction::Code opcode, RegLocation rl_dest, |
| 908 | RegLocation rl_src1, RegLocation rl_src2) = 0; |
| 909 | virtual void GenCmpFP(Instruction::Code opcode, RegLocation rl_dest, |
| 910 | RegLocation rl_src1, RegLocation rl_src2) = 0; |
| 911 | virtual void GenConversion(Instruction::Code opcode, RegLocation rl_dest, |
| 912 | RegLocation rl_src) = 0; |
Vladimir Marko | 1c282e2 | 2013-11-21 14:49:47 +0000 | [diff] [blame] | 913 | virtual bool GenInlinedCas(CallInfo* info, bool is_long, bool is_object) = 0; |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 914 | |
| 915 | /** |
| 916 | * @brief Used to generate code for intrinsic java\.lang\.Math methods min and max. |
| 917 | * @details This is also applicable for java\.lang\.StrictMath since it is a simple algorithm |
| 918 | * that applies on integers. The generated code will write the smallest or largest value |
| 919 | * directly into the destination register as specified by the invoke information. |
| 920 | * @param info Information about the invoke. |
| 921 | * @param is_min If true generates code that computes minimum. Otherwise computes maximum. |
| 922 | * @return Returns true if successfully generated |
| 923 | */ |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 924 | virtual bool GenInlinedMinMaxInt(CallInfo* info, bool is_min) = 0; |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 925 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 926 | virtual bool GenInlinedSqrt(CallInfo* info) = 0; |
Vladimir Marko | e508a20 | 2013-11-04 15:24:22 +0000 | [diff] [blame] | 927 | virtual bool GenInlinedPeek(CallInfo* info, OpSize size) = 0; |
| 928 | virtual bool GenInlinedPoke(CallInfo* info, OpSize size) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 929 | virtual void GenNegLong(RegLocation rl_dest, RegLocation rl_src) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 930 | virtual void GenOrLong(Instruction::Code, RegLocation rl_dest, RegLocation rl_src1, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 931 | RegLocation rl_src2) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 932 | virtual void GenSubLong(Instruction::Code, RegLocation rl_dest, RegLocation rl_src1, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 933 | RegLocation rl_src2) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 934 | virtual void GenXorLong(Instruction::Code, RegLocation rl_dest, RegLocation rl_src1, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 935 | RegLocation rl_src2) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 936 | virtual RegLocation GenDivRem(RegLocation rl_dest, RegStorage reg_lo, RegStorage reg_hi, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 937 | bool is_div) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 938 | virtual RegLocation GenDivRemLit(RegLocation rl_dest, RegStorage reg_lo, int lit, |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 939 | bool is_div) = 0; |
Mark Mendell | 2bf31e6 | 2014-01-23 12:13:40 -0800 | [diff] [blame] | 940 | /* |
| 941 | * @brief Generate an integer div or rem operation by a literal. |
| 942 | * @param rl_dest Destination Location. |
| 943 | * @param rl_src1 Numerator Location. |
| 944 | * @param rl_src2 Divisor Location. |
| 945 | * @param is_div 'true' if this is a division, 'false' for a remainder. |
| 946 | * @param check_zero 'true' if an exception should be generated if the divisor is 0. |
| 947 | */ |
| 948 | virtual RegLocation GenDivRem(RegLocation rl_dest, RegLocation rl_src1, |
| 949 | RegLocation rl_src2, bool is_div, bool check_zero) = 0; |
| 950 | /* |
| 951 | * @brief Generate an integer div or rem operation by a literal. |
| 952 | * @param rl_dest Destination Location. |
| 953 | * @param rl_src Numerator Location. |
| 954 | * @param lit Divisor. |
| 955 | * @param is_div 'true' if this is a division, 'false' for a remainder. |
| 956 | */ |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 957 | virtual RegLocation GenDivRemLit(RegLocation rl_dest, RegLocation rl_src1, int lit, |
| 958 | bool is_div) = 0; |
| 959 | virtual void GenCmpLong(RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2) = 0; |
Razvan A Lupusoru | 090dd44 | 2013-12-20 14:35:03 -0800 | [diff] [blame] | 960 | |
| 961 | /** |
| 962 | * @brief Used for generating code that throws ArithmeticException if both registers are zero. |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 963 | * @details This is used for generating DivideByZero checks when divisor is held in two |
| 964 | * separate registers. |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 965 | * @param reg The register holding the pair of 32-bit values. |
Razvan A Lupusoru | 090dd44 | 2013-12-20 14:35:03 -0800 | [diff] [blame] | 966 | */ |
Mingyao Yang | e643a17 | 2014-04-08 11:02:52 -0700 | [diff] [blame] | 967 | virtual void GenDivZeroCheckWide(RegStorage reg) = 0; |
Razvan A Lupusoru | 090dd44 | 2013-12-20 14:35:03 -0800 | [diff] [blame] | 968 | |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 969 | virtual void GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 970 | virtual void GenExitSequence() = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 971 | virtual void GenFillArrayData(DexOffset table_offset, RegLocation rl_src) = 0; |
| 972 | virtual void GenFusedFPCmpBranch(BasicBlock* bb, MIR* mir, bool gt_bias, bool is_double) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 973 | virtual void GenFusedLongCmpBranch(BasicBlock* bb, MIR* mir) = 0; |
Razvan A Lupusoru | e27b3bf | 2014-01-23 09:41:45 -0800 | [diff] [blame] | 974 | |
| 975 | /** |
| 976 | * @brief Lowers the kMirOpSelect MIR into LIR. |
| 977 | * @param bb The basic block in which the MIR is from. |
| 978 | * @param mir The MIR whose opcode is kMirOpSelect. |
| 979 | */ |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 980 | virtual void GenSelect(BasicBlock* bb, MIR* mir) = 0; |
Razvan A Lupusoru | e27b3bf | 2014-01-23 09:41:45 -0800 | [diff] [blame] | 981 | |
Razvan A Lupusoru | 99ad723 | 2014-02-25 17:41:08 -0800 | [diff] [blame] | 982 | /** |
| 983 | * @brief Used to generate a memory barrier in an architecture specific way. |
| 984 | * @details The last generated LIR will be considered for use as barrier. Namely, |
| 985 | * if the last LIR can be updated in a way where it will serve the semantics of |
| 986 | * barrier, then it will be used as such. Otherwise, a new LIR will be generated |
| 987 | * that can keep the semantics. |
| 988 | * @param barrier_kind The kind of memory barrier to generate. |
| 989 | */ |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 990 | virtual void GenMemBarrier(MemBarrierKind barrier_kind) = 0; |
Razvan A Lupusoru | 99ad723 | 2014-02-25 17:41:08 -0800 | [diff] [blame] | 991 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 992 | virtual void GenMoveException(RegLocation rl_dest) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 993 | virtual void GenMultiplyByTwoBitMultiplier(RegLocation rl_src, RegLocation rl_result, int lit, |
| 994 | int first_bit, int second_bit) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 995 | virtual void GenNegDouble(RegLocation rl_dest, RegLocation rl_src) = 0; |
| 996 | virtual void GenNegFloat(RegLocation rl_dest, RegLocation rl_src) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 997 | virtual void GenPackedSwitch(MIR* mir, DexOffset table_offset, RegLocation rl_src) = 0; |
| 998 | virtual void GenSparseSwitch(MIR* mir, DexOffset table_offset, RegLocation rl_src) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 999 | virtual void GenArrayGet(int opt_flags, OpSize size, RegLocation rl_array, |
| 1000 | RegLocation rl_index, RegLocation rl_dest, int scale) = 0; |
| 1001 | virtual void GenArrayPut(int opt_flags, OpSize size, RegLocation rl_array, |
Ian Rogers | a9a8254 | 2013-10-04 11:17:26 -0700 | [diff] [blame] | 1002 | RegLocation rl_index, RegLocation rl_src, int scale, |
| 1003 | bool card_mark) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1004 | virtual void GenShiftImmOpLong(Instruction::Code opcode, RegLocation rl_dest, |
| 1005 | RegLocation rl_src1, RegLocation rl_shift) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1006 | |
| 1007 | // Required for target - single operation generators. |
| 1008 | virtual LIR* OpUnconditionalBranch(LIR* target) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1009 | virtual LIR* OpCmpBranch(ConditionCode cond, RegStorage src1, RegStorage src2, LIR* target) = 0; |
| 1010 | virtual LIR* OpCmpImmBranch(ConditionCode cond, RegStorage reg, int check_value, |
| 1011 | LIR* target) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1012 | virtual LIR* OpCondBranch(ConditionCode cc, LIR* target) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1013 | virtual LIR* OpDecAndBranch(ConditionCode c_code, RegStorage reg, LIR* target) = 0; |
| 1014 | virtual LIR* OpFpRegCopy(RegStorage r_dest, RegStorage r_src) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1015 | virtual LIR* OpIT(ConditionCode cond, const char* guide) = 0; |
Dave Allison | 3da67a5 | 2014-04-02 17:03:45 -0700 | [diff] [blame] | 1016 | virtual void OpEndIT(LIR* it) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1017 | virtual LIR* OpMem(OpKind op, RegStorage r_base, int disp) = 0; |
| 1018 | virtual LIR* OpPcRelLoad(RegStorage reg, LIR* target) = 0; |
| 1019 | virtual LIR* OpReg(OpKind op, RegStorage r_dest_src) = 0; |
| 1020 | virtual LIR* OpRegCopy(RegStorage r_dest, RegStorage r_src) = 0; |
| 1021 | virtual LIR* OpRegCopyNoInsert(RegStorage r_dest, RegStorage r_src) = 0; |
| 1022 | virtual LIR* OpRegImm(OpKind op, RegStorage r_dest_src1, int value) = 0; |
| 1023 | virtual LIR* OpRegMem(OpKind op, RegStorage r_dest, RegStorage r_base, int offset) = 0; |
| 1024 | virtual LIR* OpRegReg(OpKind op, RegStorage r_dest_src1, RegStorage r_src2) = 0; |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 1025 | |
| 1026 | /** |
Razvan A Lupusoru | 2c498d1 | 2014-01-29 16:02:57 -0800 | [diff] [blame] | 1027 | * @brief Used to generate an LIR that does a load from mem to reg. |
| 1028 | * @param r_dest The destination physical register. |
| 1029 | * @param r_base The base physical register for memory operand. |
| 1030 | * @param offset The displacement for memory operand. |
| 1031 | * @param move_type Specification on the move desired (size, alignment, register kind). |
| 1032 | * @return Returns the generate move LIR. |
| 1033 | */ |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1034 | virtual LIR* OpMovRegMem(RegStorage r_dest, RegStorage r_base, int offset, |
| 1035 | MoveType move_type) = 0; |
Razvan A Lupusoru | 2c498d1 | 2014-01-29 16:02:57 -0800 | [diff] [blame] | 1036 | |
| 1037 | /** |
| 1038 | * @brief Used to generate an LIR that does a store from reg to mem. |
| 1039 | * @param r_base The base physical register for memory operand. |
| 1040 | * @param offset The displacement for memory operand. |
| 1041 | * @param r_src The destination physical register. |
| 1042 | * @param bytes_to_move The number of bytes to move. |
| 1043 | * @param is_aligned Whether the memory location is known to be aligned. |
| 1044 | * @return Returns the generate move LIR. |
| 1045 | */ |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1046 | virtual LIR* OpMovMemReg(RegStorage r_base, int offset, RegStorage r_src, |
| 1047 | MoveType move_type) = 0; |
Razvan A Lupusoru | 2c498d1 | 2014-01-29 16:02:57 -0800 | [diff] [blame] | 1048 | |
| 1049 | /** |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 1050 | * @brief Used for generating a conditional register to register operation. |
| 1051 | * @param op The opcode kind. |
| 1052 | * @param cc The condition code that when true will perform the opcode. |
| 1053 | * @param r_dest The destination physical register. |
| 1054 | * @param r_src The source physical register. |
| 1055 | * @return Returns the newly created LIR or null in case of creation failure. |
| 1056 | */ |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1057 | virtual LIR* OpCondRegReg(OpKind op, ConditionCode cc, RegStorage r_dest, RegStorage r_src) = 0; |
Razvan A Lupusoru | bd288c2 | 2013-12-20 17:27:23 -0800 | [diff] [blame] | 1058 | |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1059 | virtual LIR* OpRegRegImm(OpKind op, RegStorage r_dest, RegStorage r_src1, int value) = 0; |
| 1060 | virtual LIR* OpRegRegReg(OpKind op, RegStorage r_dest, RegStorage r_src1, |
| 1061 | RegStorage r_src2) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1062 | virtual LIR* OpTestSuspend(LIR* target) = 0; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1063 | virtual LIR* OpThreadMem(OpKind op, ThreadOffset<4> thread_offset) = 0; |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1064 | virtual LIR* OpVldm(RegStorage r_base, int count) = 0; |
| 1065 | virtual LIR* OpVstm(RegStorage r_base, int count) = 0; |
| 1066 | virtual void OpLea(RegStorage r_base, RegStorage reg1, RegStorage reg2, int scale, |
| 1067 | int offset) = 0; |
| 1068 | virtual void OpRegCopyWide(RegStorage dest, RegStorage src) = 0; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1069 | virtual void OpTlsCmp(ThreadOffset<4> offset, int val) = 0; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1070 | virtual bool InexpensiveConstantInt(int32_t value) = 0; |
| 1071 | virtual bool InexpensiveConstantFloat(int32_t value) = 0; |
| 1072 | virtual bool InexpensiveConstantLong(int64_t value) = 0; |
| 1073 | virtual bool InexpensiveConstantDouble(int64_t value) = 0; |
| 1074 | |
Ian Rogers | d9c4fc9 | 2013-10-01 19:45:43 -0700 | [diff] [blame] | 1075 | // May be optimized by targets. |
| 1076 | virtual void GenMonitorEnter(int opt_flags, RegLocation rl_src); |
| 1077 | virtual void GenMonitorExit(int opt_flags, RegLocation rl_src); |
| 1078 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1079 | // Temp workaround |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1080 | void Workaround7250540(RegLocation rl_dest, RegStorage zero_reg); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1081 | |
| 1082 | protected: |
| 1083 | Mir2Lir(CompilationUnit* cu, MIRGraph* mir_graph, ArenaAllocator* arena); |
| 1084 | |
| 1085 | CompilationUnit* GetCompilationUnit() { |
| 1086 | return cu_; |
| 1087 | } |
Mark Mendell | 4708dcd | 2014-01-22 09:05:18 -0800 | [diff] [blame] | 1088 | /* |
| 1089 | * @brief Returns the index of the lowest set bit in 'x'. |
| 1090 | * @param x Value to be examined. |
| 1091 | * @returns The bit number of the lowest bit set in the value. |
| 1092 | */ |
| 1093 | int32_t LowestSetBit(uint64_t x); |
| 1094 | /* |
| 1095 | * @brief Is this value a power of two? |
| 1096 | * @param x Value to be examined. |
| 1097 | * @returns 'true' if only 1 bit is set in the value. |
| 1098 | */ |
| 1099 | bool IsPowerOfTwo(uint64_t x); |
| 1100 | /* |
| 1101 | * @brief Do these SRs overlap? |
| 1102 | * @param rl_op1 One RegLocation |
| 1103 | * @param rl_op2 The other RegLocation |
| 1104 | * @return 'true' if the VR pairs overlap |
| 1105 | * |
| 1106 | * Check to see if a result pair has a misaligned overlap with an operand pair. This |
| 1107 | * is not usual for dx to generate, but it is legal (for now). In a future rev of |
| 1108 | * dex, we'll want to make this case illegal. |
| 1109 | */ |
| 1110 | bool BadOverlap(RegLocation rl_op1, RegLocation rl_op2); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1111 | |
Mark Mendell | e02d48f | 2014-01-15 11:19:23 -0800 | [diff] [blame] | 1112 | /* |
| 1113 | * @brief Force a location (in a register) into a temporary register |
| 1114 | * @param loc location of result |
| 1115 | * @returns update location |
| 1116 | */ |
| 1117 | RegLocation ForceTemp(RegLocation loc); |
| 1118 | |
| 1119 | /* |
| 1120 | * @brief Force a wide location (in registers) into temporary registers |
| 1121 | * @param loc location of result |
| 1122 | * @returns update location |
| 1123 | */ |
| 1124 | RegLocation ForceTempWide(RegLocation loc); |
| 1125 | |
Mark Mendell | df8ee2e | 2014-01-27 16:37:47 -0800 | [diff] [blame] | 1126 | virtual void GenInstanceofFinal(bool use_declaring_class, uint32_t type_idx, |
| 1127 | RegLocation rl_dest, RegLocation rl_src); |
| 1128 | |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1129 | void AddSlowPath(LIRSlowPath* slowpath); |
| 1130 | |
Mark Mendell | 6607d97 | 2014-02-10 06:54:18 -0800 | [diff] [blame] | 1131 | virtual void GenInstanceofCallingHelper(bool needs_access_check, bool type_known_final, |
| 1132 | bool type_known_abstract, bool use_declaring_class, |
| 1133 | bool can_assume_type_is_in_dex_cache, |
| 1134 | uint32_t type_idx, RegLocation rl_dest, |
| 1135 | RegLocation rl_src); |
Mark Mendell | ae9fd93 | 2014-02-10 16:14:35 -0800 | [diff] [blame] | 1136 | /* |
| 1137 | * @brief Generate the debug_frame FDE information if possible. |
| 1138 | * @returns pointer to vector containg CFE information, or NULL. |
| 1139 | */ |
| 1140 | virtual std::vector<uint8_t>* ReturnCallFrameInformation(); |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1141 | |
Razvan A Lupusoru | 3bc0174 | 2014-02-06 13:18:43 -0800 | [diff] [blame] | 1142 | /** |
| 1143 | * @brief Used to insert marker that can be used to associate MIR with LIR. |
| 1144 | * @details Only inserts marker if verbosity is enabled. |
| 1145 | * @param mir The mir that is currently being generated. |
| 1146 | */ |
| 1147 | void GenPrintLabel(MIR* mir); |
| 1148 | |
| 1149 | /** |
| 1150 | * @brief Used to generate return sequence when there is no frame. |
| 1151 | * @details Assumes that the return registers have already been populated. |
| 1152 | */ |
| 1153 | virtual void GenSpecialExitSequence() = 0; |
| 1154 | |
| 1155 | /** |
| 1156 | * @brief Used to generate code for special methods that are known to be |
| 1157 | * small enough to work in frameless mode. |
| 1158 | * @param bb The basic block of the first MIR. |
| 1159 | * @param mir The first MIR of the special method. |
| 1160 | * @param special Information about the special method. |
| 1161 | * @return Returns whether or not this was handled successfully. Returns false |
| 1162 | * if caller should punt to normal MIR2LIR conversion. |
| 1163 | */ |
| 1164 | virtual bool GenSpecialCase(BasicBlock* bb, MIR* mir, const InlineMethod& special); |
| 1165 | |
Mark Mendell | 6607d97 | 2014-02-10 06:54:18 -0800 | [diff] [blame] | 1166 | private: |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1167 | void ClobberBody(RegisterInfo* p); |
| 1168 | void ResetDefBody(RegisterInfo* p) { |
| 1169 | p->def_start = NULL; |
| 1170 | p->def_end = NULL; |
| 1171 | } |
| 1172 | |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1173 | void SetCurrentDexPc(DexOffset dexpc) { |
| 1174 | current_dalvik_offset_ = dexpc; |
| 1175 | } |
| 1176 | |
Razvan A Lupusoru | 3bc0174 | 2014-02-06 13:18:43 -0800 | [diff] [blame] | 1177 | /** |
| 1178 | * @brief Used to lock register if argument at in_position was passed that way. |
| 1179 | * @details Does nothing if the argument is passed via stack. |
| 1180 | * @param in_position The argument number whose register to lock. |
| 1181 | * @param wide Whether the argument is wide. |
| 1182 | */ |
| 1183 | void LockArg(int in_position, bool wide = false); |
| 1184 | |
| 1185 | /** |
| 1186 | * @brief Used to load VR argument to a physical register. |
| 1187 | * @details The load is only done if the argument is not already in physical register. |
| 1188 | * LockArg must have been previously called. |
| 1189 | * @param in_position The argument number to load. |
| 1190 | * @param wide Whether the argument is 64-bit or not. |
| 1191 | * @return Returns the register (or register pair) for the loaded argument. |
| 1192 | */ |
buzbee | 2700f7e | 2014-03-07 09:46:20 -0800 | [diff] [blame] | 1193 | RegStorage LoadArg(int in_position, bool wide = false); |
Razvan A Lupusoru | 3bc0174 | 2014-02-06 13:18:43 -0800 | [diff] [blame] | 1194 | |
| 1195 | /** |
| 1196 | * @brief Used to load a VR argument directly to a specified register location. |
| 1197 | * @param in_position The argument number to place in register. |
| 1198 | * @param rl_dest The register location where to place argument. |
| 1199 | */ |
| 1200 | void LoadArgDirect(int in_position, RegLocation rl_dest); |
| 1201 | |
| 1202 | /** |
| 1203 | * @brief Used to generate LIR for special getter method. |
| 1204 | * @param mir The mir that represents the iget. |
| 1205 | * @param special Information about the special getter method. |
| 1206 | * @return Returns whether LIR was successfully generated. |
| 1207 | */ |
| 1208 | bool GenSpecialIGet(MIR* mir, const InlineMethod& special); |
| 1209 | |
| 1210 | /** |
| 1211 | * @brief Used to generate LIR for special setter method. |
| 1212 | * @param mir The mir that represents the iput. |
| 1213 | * @param special Information about the special setter method. |
| 1214 | * @return Returns whether LIR was successfully generated. |
| 1215 | */ |
| 1216 | bool GenSpecialIPut(MIR* mir, const InlineMethod& special); |
| 1217 | |
| 1218 | /** |
| 1219 | * @brief Used to generate LIR for special return-args method. |
| 1220 | * @param mir The mir that represents the return of argument. |
| 1221 | * @param special Information about the special return-args method. |
| 1222 | * @return Returns whether LIR was successfully generated. |
| 1223 | */ |
| 1224 | bool GenSpecialIdentity(MIR* mir, const InlineMethod& special); |
| 1225 | |
Mingyao Yang | 4289456 | 2014-04-07 12:42:16 -0700 | [diff] [blame] | 1226 | void AddDivZeroCheckSlowPath(LIR* branch); |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1227 | |
Mingyao Yang | 80365d9 | 2014-04-18 12:10:58 -0700 | [diff] [blame] | 1228 | // Copy arg0 and arg1 to kArg0 and kArg1 safely, possibly using |
| 1229 | // kArg2 as temp. |
| 1230 | void CopyToArgumentRegs(RegStorage arg0, RegStorage arg1); |
| 1231 | |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1232 | public: |
| 1233 | // TODO: add accessors for these. |
| 1234 | LIR* literal_list_; // Constants. |
| 1235 | LIR* method_literal_list_; // Method literals requiring patching. |
Hiroshi Yamauchi | be1ca55 | 2014-01-15 11:46:48 -0800 | [diff] [blame] | 1236 | LIR* class_literal_list_; // Class literals requiring patching. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1237 | LIR* code_literal_list_; // Code literals requiring patching. |
buzbee | b48819d | 2013-09-14 16:15:25 -0700 | [diff] [blame] | 1238 | LIR* first_fixup_; // Doubly-linked list of LIR nodes requiring fixups. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1239 | |
| 1240 | protected: |
| 1241 | CompilationUnit* const cu_; |
| 1242 | MIRGraph* const mir_graph_; |
| 1243 | GrowableArray<SwitchTable*> switch_tables_; |
| 1244 | GrowableArray<FillArrayData*> fill_array_data_; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1245 | GrowableArray<LIR*> suspend_launchpads_; |
buzbee | bd663de | 2013-09-10 15:41:31 -0700 | [diff] [blame] | 1246 | GrowableArray<RegisterInfo*> tempreg_info_; |
| 1247 | GrowableArray<RegisterInfo*> reginfo_map_; |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 1248 | GrowableArray<void*> pointer_storage_; |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 1249 | CodeOffset current_code_offset_; // Working byte offset of machine instructons. |
| 1250 | CodeOffset data_offset_; // starting offset of literal pool. |
| 1251 | size_t total_size_; // header + code size. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1252 | LIR* block_label_list_; |
| 1253 | PromotionMap* promotion_map_; |
| 1254 | /* |
| 1255 | * TODO: The code generation utilities don't have a built-in |
| 1256 | * mechanism to propagate the original Dalvik opcode address to the |
| 1257 | * associated generated instructions. For the trace compiler, this wasn't |
| 1258 | * necessary because the interpreter handled all throws and debugging |
| 1259 | * requests. For now we'll handle this by placing the Dalvik offset |
| 1260 | * in the CompilationUnit struct before codegen for each instruction. |
| 1261 | * The low-level LIR creation utilites will pull it from here. Rework this. |
| 1262 | */ |
buzbee | 0d82948 | 2013-10-11 15:24:55 -0700 | [diff] [blame] | 1263 | DexOffset current_dalvik_offset_; |
| 1264 | size_t estimated_native_code_size_; // Just an estimate; used to reserve code_buffer_ size. |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1265 | RegisterPool* reg_pool_; |
| 1266 | /* |
| 1267 | * Sanity checking for the register temp tracking. The same ssa |
| 1268 | * name should never be associated with one temp register per |
| 1269 | * instruction compilation. |
| 1270 | */ |
| 1271 | int live_sreg_; |
| 1272 | CodeBuffer code_buffer_; |
Ian Rogers | 96faf5b | 2013-08-09 22:05:32 -0700 | [diff] [blame] | 1273 | // The encoding mapping table data (dex -> pc offset and pc offset -> dex) with a size prefix. |
Vladimir Marko | 06606b9 | 2013-12-02 15:31:08 +0000 | [diff] [blame] | 1274 | std::vector<uint8_t> encoded_mapping_table_; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1275 | std::vector<uint32_t> core_vmap_table_; |
| 1276 | std::vector<uint32_t> fp_vmap_table_; |
| 1277 | std::vector<uint8_t> native_gc_map_; |
| 1278 | int num_core_spills_; |
| 1279 | int num_fp_spills_; |
| 1280 | int frame_size_; |
| 1281 | unsigned int core_spill_mask_; |
| 1282 | unsigned int fp_spill_mask_; |
| 1283 | LIR* first_lir_insn_; |
| 1284 | LIR* last_lir_insn_; |
Dave Allison | bcec6fb | 2014-01-17 12:52:22 -0800 | [diff] [blame] | 1285 | |
| 1286 | GrowableArray<LIRSlowPath*> slow_paths_; |
Brian Carlstrom | 7940e44 | 2013-07-12 13:46:57 -0700 | [diff] [blame] | 1287 | }; // Class Mir2Lir |
| 1288 | |
| 1289 | } // namespace art |
| 1290 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 1291 | #endif // ART_COMPILER_DEX_QUICK_MIR_TO_LIR_H_ |