Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 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_COMPILER_DEX_QUICK_ARM64_ARM64_LIR_H_ |
| 18 | #define ART_COMPILER_DEX_QUICK_ARM64_ARM64_LIR_H_ |
| 19 | |
| 20 | #include "dex/compiler_internals.h" |
| 21 | |
| 22 | namespace art { |
| 23 | |
| 24 | /* |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 25 | * TODO(Arm64): the comments below are outdated. |
| 26 | * |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 27 | * Runtime register usage conventions. |
| 28 | * |
| 29 | * r0-r3: Argument registers in both Dalvik and C/C++ conventions. |
| 30 | * However, for Dalvik->Dalvik calls we'll pass the target's Method* |
| 31 | * pointer in r0 as a hidden arg0. Otherwise used as codegen scratch |
| 32 | * registers. |
| 33 | * r0-r1: As in C/C++ r0 is 32-bit return register and r0/r1 is 64-bit |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 34 | * r4 : (rA64_SUSPEND) is reserved (suspend check/debugger assist) |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 35 | * r5 : Callee save (promotion target) |
| 36 | * r6 : Callee save (promotion target) |
| 37 | * r7 : Callee save (promotion target) |
| 38 | * r8 : Callee save (promotion target) |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 39 | * r9 : (rA64_SELF) is reserved (pointer to thread-local storage) |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 40 | * r10 : Callee save (promotion target) |
| 41 | * r11 : Callee save (promotion target) |
| 42 | * r12 : Scratch, may be trashed by linkage stubs |
| 43 | * r13 : (sp) is reserved |
| 44 | * r14 : (lr) is reserved |
| 45 | * r15 : (pc) is reserved |
| 46 | * |
| 47 | * 5 core temps that codegen can use (r0, r1, r2, r3, r12) |
| 48 | * 7 core registers that can be used for promotion |
| 49 | * |
| 50 | * Floating pointer registers |
| 51 | * s0-s31 |
| 52 | * d0-d15, where d0={s0,s1}, d1={s2,s3}, ... , d15={s30,s31} |
| 53 | * |
| 54 | * s16-s31 (d8-d15) preserved across C calls |
| 55 | * s0-s15 (d0-d7) trashed across C calls |
| 56 | * |
| 57 | * s0-s15/d0-d7 used as codegen temp/scratch |
| 58 | * s16-s31/d8-d31 can be used for promotion. |
| 59 | * |
| 60 | * Calling convention |
| 61 | * o On a call to a Dalvik method, pass target's Method* in r0 |
| 62 | * o r1-r3 will be used for up to the first 3 words of arguments |
| 63 | * o Arguments past the first 3 words will be placed in appropriate |
| 64 | * out slots by the caller. |
| 65 | * o If a 64-bit argument would span the register/memory argument |
| 66 | * boundary, it will instead be fully passed in the frame. |
| 67 | * o Maintain a 16-byte stack alignment |
| 68 | * |
| 69 | * Stack frame diagram (stack grows down, higher addresses at top): |
| 70 | * |
| 71 | * +------------------------+ |
| 72 | * | IN[ins-1] | {Note: resides in caller's frame} |
| 73 | * | . | |
| 74 | * | IN[0] | |
| 75 | * | caller's Method* | |
| 76 | * +========================+ {Note: start of callee's frame} |
| 77 | * | spill region | {variable sized - will include lr if non-leaf.} |
| 78 | * +------------------------+ |
| 79 | * | ...filler word... | {Note: used as 2nd word of V[locals-1] if long] |
| 80 | * +------------------------+ |
| 81 | * | V[locals-1] | |
| 82 | * | V[locals-2] | |
| 83 | * | . | |
| 84 | * | . | |
| 85 | * | V[1] | |
| 86 | * | V[0] | |
| 87 | * +------------------------+ |
| 88 | * | 0 to 3 words padding | |
| 89 | * +------------------------+ |
| 90 | * | OUT[outs-1] | |
| 91 | * | OUT[outs-2] | |
| 92 | * | . | |
| 93 | * | OUT[0] | |
| 94 | * | cur_method* | <<== sp w/ 16-byte alignment |
| 95 | * +========================+ |
| 96 | */ |
| 97 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 98 | #if 1 |
| 99 | #define A64_PTR_SIZE 4 |
| 100 | #define A64_GET_INT_OFFS(offs) ((offs).Int32Value()) |
| 101 | #else |
| 102 | // Not yet ready for this. |
| 103 | #define A64_PTR_SIZE 8 |
| 104 | #define A64_GET_INT_OFFS(offs) ((offs).Int32Value()) |
| 105 | #endif |
| 106 | |
| 107 | #define A64_QUICK_ENTRYPOINT_OFFSET(name) QUICK_ENTRYPOINT_OFFSET(A64_PTR_SIZE, name) |
| 108 | #define A64_QUICK_ENTRYPOINT_INT_OFFS(name) A64_GET_INT_OFFS(A64_QUICK_ENTRYPOINT_OFFSET(name)) |
| 109 | #define A64_THREAD_THIN_LOCK_ID_OFFSET A64_GET_INT_OFFS(Thread::ThinLockIdOffset<A64_PTR_SIZE>()) |
| 110 | #define A64_THREAD_EXCEPTION_INT_OFFS A64_GET_INT_OFFS(Thread::ExceptionOffset<A64_PTR_SIZE>()) |
| 111 | #define A64_THREAD_CARD_TABLE_INT_OFFS A64_GET_INT_OFFS(Thread::CardTableOffset<A64_PTR_SIZE>()) |
| 112 | #define A64_THREAD_STACK_END_INT_OFFS A64_GET_INT_OFFS(Thread::StackEndOffset<A64_PTR_SIZE>()) |
| 113 | #define A64_THREAD_SUSPEND_TRIGGER_OFFSET \ |
| 114 | A64_GET_INT_OFFS(Thread::ThreadSuspendTriggerOffset<A64_PTR_SIZE>()) |
| 115 | typedef ThreadOffset<A64_PTR_SIZE> A64ThreadOffset; |
| 116 | |
| 117 | // Offset to distinguish FP regs. |
| 118 | #define ARM_FP_REG_OFFSET 32 |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 119 | // First FP callee save. |
| 120 | #define ARM_FP_CALLEE_SAVE_BASE 16 |
| 121 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 122 | // Mask to strip off fp flags. |
| 123 | #define ARM_FP_REG_MASK (ARM_FP_REG_OFFSET - 1) |
| 124 | |
| 125 | // Temporary macros, used to mark code which wants to distinguish betweek zr/sp. |
| 126 | #define A64_REG_IS_SP(reg_num) ((reg_num) == rwsp || (reg_num) == rsp) |
| 127 | #define A64_REG_IS_ZR(reg_num) ((reg_num) == rwzr || (reg_num) == rxzr) |
| 128 | |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 129 | enum ArmResourceEncodingPos { |
| 130 | kArmGPReg0 = 0, |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 131 | kArmRegLR = 30, |
| 132 | kArmRegSP = 31, |
| 133 | kArmFPReg0 = 32, |
| 134 | kArmRegEnd = 64, |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 135 | }; |
| 136 | |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 137 | #define ENCODE_ARM_REG_SP (1ULL << kArmRegSP) |
| 138 | #define ENCODE_ARM_REG_LR (1ULL << kArmRegLR) |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 139 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 140 | #define IS_SIGNED_IMM(size, value) \ |
| 141 | ((value) >= -(1 << ((size) - 1)) && (value) < (1 << ((size) - 1))) |
| 142 | #define IS_SIGNED_IMM7(value) IS_SIGNED_IMM(7, value) |
| 143 | #define IS_SIGNED_IMM9(value) IS_SIGNED_IMM(9, value) |
| 144 | #define IS_SIGNED_IMM12(value) IS_SIGNED_IMM(12, value) |
| 145 | #define IS_SIGNED_IMM19(value) IS_SIGNED_IMM(19, value) |
| 146 | #define IS_SIGNED_IMM21(value) IS_SIGNED_IMM(21, value) |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 147 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 148 | // Quick macro used to define the registers. |
| 149 | #define A64_REGISTER_CODE_LIST(R) \ |
| 150 | R(0) R(1) R(2) R(3) R(4) R(5) R(6) R(7) \ |
| 151 | R(8) R(9) R(10) R(11) R(12) R(13) R(14) R(15) \ |
| 152 | R(16) R(17) R(18) R(19) R(20) R(21) R(22) R(23) \ |
| 153 | R(24) R(25) R(26) R(27) R(28) R(29) R(30) R(31) |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 154 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 155 | // Registers (integer) values. |
| 156 | // TODO(Arm64): for now we define rx##nr identically to rw##nr. We should rather define rx##nr as |
| 157 | // a k64BitSolo. We should do this once the register allocator is ready. |
| 158 | enum A64NativeRegisterPool { |
| 159 | # define A64_DEFINE_REGISTERS(nr) \ |
| 160 | rw##nr = RegStorage::k32BitSolo | RegStorage::kCoreRegister | nr, \ |
| 161 | rx##nr = RegStorage::k32BitSolo | RegStorage::kCoreRegister | nr, \ |
| 162 | rf##nr = RegStorage::k32BitSolo | RegStorage::kFloatingPoint | nr, \ |
| 163 | rd##nr = RegStorage::k64BitSolo | RegStorage::kFloatingPoint | nr, |
| 164 | A64_REGISTER_CODE_LIST(A64_DEFINE_REGISTERS) |
| 165 | #undef A64_DEFINE_REGISTERS |
| 166 | |
| 167 | // TODO(Arm64): can we change the lines below such that rwzr != rwsp && rxzr != rsp? |
| 168 | // This would be desirable to allow detecting usage-errors in the assembler. |
| 169 | rwzr = rw31, |
| 170 | rxzr = rx31, |
| 171 | rwsp = rw31, |
| 172 | rsp = rx31, |
| 173 | rA64_SUSPEND = rx4, |
| 174 | rA64_SELF = rx18, |
| 175 | rA64_SP = rx31, |
| 176 | rA64_LR = rx30 |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 177 | }; |
| 178 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 179 | #define A64_DEFINE_REGSTORAGES(nr) \ |
| 180 | constexpr RegStorage rs_w##nr(RegStorage::kValid | rw##nr); \ |
| 181 | constexpr RegStorage rs_x##nr(RegStorage::kValid | rx##nr); \ |
| 182 | constexpr RegStorage rs_f##nr(RegStorage::kValid | rf##nr); \ |
| 183 | constexpr RegStorage rs_d##nr(RegStorage::kValid | rd##nr); |
| 184 | A64_REGISTER_CODE_LIST(A64_DEFINE_REGSTORAGES) |
| 185 | #undef A64_DEFINE_REGSTORAGES |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 186 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 187 | constexpr RegStorage rs_wzr(RegStorage::kValid | rwzr); |
| 188 | constexpr RegStorage rs_xzr(RegStorage::kValid | rxzr); |
| 189 | constexpr RegStorage rs_rA64_SUSPEND(RegStorage::kValid | rA64_SUSPEND); |
| 190 | constexpr RegStorage rs_rA64_SELF(RegStorage::kValid | rA64_SELF); |
| 191 | constexpr RegStorage rs_rA64_SP(RegStorage::kValid | rA64_SP); |
| 192 | constexpr RegStorage rs_rA64_LR(RegStorage::kValid | rA64_LR); |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 193 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 194 | // RegisterLocation templates return values (following the hard-float calling convention). |
| 195 | const RegLocation arm_loc_c_return = |
| 196 | {kLocPhysReg, 0, 0, 0, 0, 0, 0, 0, 1, rs_w0, INVALID_SREG, INVALID_SREG}; |
| 197 | const RegLocation arm_loc_c_return_wide = |
| 198 | {kLocPhysReg, 1, 0, 0, 0, 0, 0, 0, 1, rs_x0, INVALID_SREG, INVALID_SREG}; |
| 199 | const RegLocation arm_loc_c_return_float = |
| 200 | {kLocPhysReg, 0, 0, 0, 0, 0, 0, 0, 1, rs_f0, INVALID_SREG, INVALID_SREG}; |
| 201 | const RegLocation arm_loc_c_return_double = |
| 202 | {kLocPhysReg, 1, 0, 0, 0, 0, 0, 0, 1, rs_d0, INVALID_SREG, INVALID_SREG}; |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 203 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 204 | /** |
| 205 | * @brief Shift-type to be applied to a register via EncodeShift(). |
| 206 | */ |
| 207 | enum A64ShiftEncodings { |
| 208 | kA64Lsl = 0x0, |
| 209 | kA64Lsr = 0x1, |
| 210 | kA64Asr = 0x2, |
| 211 | kA64Ror = 0x3 |
| 212 | }; |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 213 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 214 | /** |
| 215 | * @brief Extend-type to be applied to a register via EncodeExtend(). |
| 216 | */ |
| 217 | enum A64RegExtEncodings { |
| 218 | kA64Uxtb = 0x0, |
| 219 | kA64Uxth = 0x1, |
| 220 | kA64Uxtw = 0x2, |
| 221 | kA64Uxtx = 0x3, |
| 222 | kA64Sxtb = 0x4, |
| 223 | kA64Sxth = 0x5, |
| 224 | kA64Sxtw = 0x6, |
| 225 | kA64Sxtx = 0x7 |
| 226 | }; |
| 227 | |
| 228 | #define ENCODE_NO_SHIFT (EncodeShift(kA64Lsl, 0)) |
| 229 | |
| 230 | /* |
| 231 | * The following enum defines the list of supported A64 instructions by the |
| 232 | * assembler. Their corresponding EncodingMap positions will be defined in |
| 233 | * assemble_arm64.cc. |
| 234 | */ |
| 235 | enum ArmOpcode { |
| 236 | kA64First = 0, |
| 237 | kA64Adc3rrr = kA64First, // adc [00011010000] rm[20-16] [000000] rn[9-5] rd[4-0]. |
| 238 | kA64Add4RRdT, // add [s001000100] imm_12[21-10] rn[9-5] rd[4-0]. |
| 239 | kA64Add4rrro, // add [00001011000] rm[20-16] option[15-13] imm_3[12-10] rn[9-5] rd[4-0]. |
| 240 | kA64Adr2xd, // adr [0] immlo[30-29] [10000] immhi[23-5] rd[4-0]. |
| 241 | kA64And3Rrl, // and [00010010] N[22] imm_r[21-16] imm_s[15-10] rn[9-5] rd[4-0]. |
| 242 | kA64And4rrro, // and [00001010] shift[23-22] [N=0] rm[20-16] imm_6[15-10] rn[9-5] rd[4-0]. |
| 243 | kA64Asr3rrd, // asr [0001001100] immr[21-16] imms[15-10] rn[9-5] rd[4-0]. |
| 244 | kA64Asr3rrr, // asr alias of "sbfm arg0, arg1, arg2, {#31/#63}". |
| 245 | kA64B2ct, // b.cond [01010100] imm_19[23-5] [0] cond[3-0]. |
| 246 | kA64Blr1x, // blr [1101011000111111000000] rn[9-5] [00000]. |
| 247 | kA64Br1x, // br [1101011000011111000000] rn[9-5] [00000]. |
| 248 | kA64Brk1d, // brk [11010100001] imm_16[20-5] [00000]. |
| 249 | kA64B1t, // b [00010100] offset_26[25-0]. |
| 250 | kA64Cbnz2rt, // cbnz[00110101] imm_19[23-5] rt[4-0]. |
| 251 | kA64Cbz2rt, // cbz [00110100] imm_19[23-5] rt[4-0]. |
| 252 | kA64Cmn3Rro, // cmn [s0101011001] rm[20-16] option[15-13] imm_3[12-10] rn[9-5] [11111]. |
| 253 | kA64Cmn3RdT, // cmn [00110001] shift[23-22] imm_12[21-10] rn[9-5] [11111]. |
| 254 | kA64Cmp3Rro, // cmp [s1101011001] rm[20-16] option[15-13] imm_3[12-10] rn[9-5] [11111]. |
| 255 | kA64Cmp3RdT, // cmp [01110001] shift[23-22] imm_12[21-10] rn[9-5] [11111]. |
| 256 | kA64Csel4rrrc, // csel[s0011010100] rm[20-16] cond[15-12] [00] rn[9-5] rd[4-0]. |
| 257 | kA64Csinc4rrrc, // csinc [s0011010100] rm[20-16] cond[15-12] [01] rn[9-5] rd[4-0]. |
| 258 | kA64Csneg4rrrc, // csneg [s1011010100] rm[20-16] cond[15-12] [01] rn[9-5] rd[4-0]. |
| 259 | kA64Dmb1B, // dmb [11010101000000110011] CRm[11-8] [10111111]. |
| 260 | kA64Eor3Rrl, // eor [s10100100] N[22] imm_r[21-16] imm_s[15-10] rn[9-5] rd[4-0]. |
| 261 | kA64Eor4rrro, // eor [s1001010] shift[23-22] [0] rm[20-16] imm_6[15-10] rn[9-5] rd[4-0]. |
| 262 | kA64Extr4rrrd, // extr[s00100111N0] rm[20-16] imm_s[15-10] rn[9-5] rd[4-0]. |
| 263 | kA64Fabs2ff, // fabs[000111100s100000110000] rn[9-5] rd[4-0]. |
| 264 | kA64Fadd3fff, // fadd[000111100s1] rm[20-16] [001010] rn[9-5] rd[4-0]. |
| 265 | kA64Fcmp1f, // fcmp[000111100s100000001000] rn[9-5] [01000]. |
| 266 | kA64Fcmp2ff, // fcmp[000111100s1] rm[20-16] [001000] rn[9-5] [00000]. |
| 267 | kA64Fcvtzs2wf, // fcvtzs [000111100s111000000000] rn[9-5] rd[4-0]. |
| 268 | kA64Fcvtzs2xf, // fcvtzs [100111100s111000000000] rn[9-5] rd[4-0]. |
| 269 | kA64Fcvt2Ss, // fcvt [0001111000100010110000] rn[9-5] rd[4-0]. |
| 270 | kA64Fcvt2sS, // fcvt [0001111001100010010000] rn[9-5] rd[4-0]. |
| 271 | kA64Fdiv3fff, // fdiv[000111100s1] rm[20-16] [000110] rn[9-5] rd[4-0]. |
| 272 | kA64Fmov2ff, // fmov[000111100s100000010000] rn[9-5] rd[4-0]. |
| 273 | kA64Fmov2fI, // fmov[000111100s1] imm_8[20-13] [10000000] rd[4-0]. |
| 274 | kA64Fmov2sw, // fmov[0001111000100111000000] rn[9-5] rd[4-0]. |
| 275 | kA64Fmov2Sx, // fmov[1001111001100111000000] rn[9-5] rd[4-0]. |
| 276 | kA64Fmov2ws, // fmov[0001111001101110000000] rn[9-5] rd[4-0]. |
| 277 | kA64Fmov2xS, // fmov[1001111001101111000000] rn[9-5] rd[4-0]. |
| 278 | kA64Fmul3fff, // fmul[000111100s1] rm[20-16] [000010] rn[9-5] rd[4-0]. |
| 279 | kA64Fneg2ff, // fneg[000111100s100001010000] rn[9-5] rd[4-0]. |
| 280 | kA64Frintz2ff, // frintz [000111100s100101110000] rn[9-5] rd[4-0]. |
| 281 | kA64Fsqrt2ff, // fsqrt[000111100s100001110000] rn[9-5] rd[4-0]. |
| 282 | kA64Fsub3fff, // fsub[000111100s1] rm[20-16] [001110] rn[9-5] rd[4-0]. |
| 283 | kA64Ldrb3wXd, // ldrb[0011100101] imm_12[21-10] rn[9-5] rt[4-0]. |
| 284 | kA64Ldrb3wXx, // ldrb[00111000011] rm[20-16] [011] S[12] [10] rn[9-5] rt[4-0]. |
| 285 | kA64Ldrsb3rXd, // ldrsb[001110011s] imm_12[21-10] rn[9-5] rt[4-0]. |
| 286 | kA64Ldrsb3rXx, // ldrsb[0011 1000 1s1] rm[20-16] [011] S[12] [10] rn[9-5] rt[4-0]. |
| 287 | kA64Ldrh3wXF, // ldrh[0111100101] imm_12[21-10] rn[9-5] rt[4-0]. |
| 288 | kA64Ldrh4wXxd, // ldrh[01111000011] rm[20-16] [011] S[12] [10] rn[9-5] rt[4-0]. |
| 289 | kA64Ldrsh3rXF, // ldrsh[011110011s] imm_12[21-10] rn[9-5] rt[4-0]. |
| 290 | kA64Ldrsh4rXxd, // ldrsh[011110001s1] rm[20-16] [011] S[12] [10] rn[9-5] rt[4-0] |
| 291 | kA64Ldr2fp, // ldr [0s011100] imm_19[23-5] rt[4-0]. |
| 292 | kA64Ldr2rp, // ldr [0s011000] imm_19[23-5] rt[4-0]. |
| 293 | kA64Ldr3fXD, // ldr [1s11110100] imm_12[21-10] rn[9-5] rt[4-0]. |
| 294 | kA64Ldr3rXD, // ldr [1s111000010] imm_9[20-12] [01] rn[9-5] rt[4-0]. |
| 295 | kA64Ldr4fXxG, // ldr [1s111100011] rm[20-16] [011] S[12] [10] rn[9-5] rt[4-0]. |
| 296 | kA64Ldr4rXxG, // ldr [1s111000011] rm[20-16] [011] S[12] [10] rn[9-5] rt[4-0]. |
| 297 | kA64LdrPost3rXd, // ldr [1s111000010] imm_9[20-12] [01] rn[9-5] rt[4-0]. |
| 298 | kA64Ldp4rrXD, // ldp [s010100101] imm_7[21-15] rt2[14-10] rn[9-5] rt[4-0]. |
| 299 | kA64LdpPost4rrXD, // ldp [s010100011] imm_7[21-15] rt2[14-10] rn[9-5] rt[4-0]. |
| 300 | kA64Ldur3fXd, // ldur[1s111100010] imm_9[20-12] [00] rn[9-5] rt[4-0]. |
| 301 | kA64Ldur3rXd, // ldur[1s111000010] imm_9[20-12] [00] rn[9-5] rt[4-0]. |
| 302 | kA64Ldxr2rX, // ldxr[1s00100001011111011111] rn[9-5] rt[4-0]. |
| 303 | kA64Lsl3rrr, // lsl [s0011010110] rm[20-16] [001000] rn[9-5] rd[4-0]. |
| 304 | kA64Lsr3rrd, // lsr alias of "ubfm arg0, arg1, arg2, #{31/63}". |
| 305 | kA64Lsr3rrr, // lsr [s0011010110] rm[20-16] [001001] rn[9-5] rd[4-0]. |
| 306 | kA64Movk3rdM, // mov [010100101] hw[22-21] imm_16[20-5] rd[4-0]. |
| 307 | kA64Movn3rdM, // mov [000100101] hw[22-21] imm_16[20-5] rd[4-0]. |
| 308 | kA64Movz3rdM, // mov [011100101] hw[22-21] imm_16[20-5] rd[4-0]. |
| 309 | kA64Mov2rr, // mov [00101010000] rm[20-16] [000000] [11111] rd[4-0]. |
| 310 | kA64Mvn2rr, // mov [00101010001] rm[20-16] [000000] [11111] rd[4-0]. |
| 311 | kA64Mul3rrr, // mul [00011011000] rm[20-16] [011111] rn[9-5] rd[4-0]. |
| 312 | kA64Neg3rro, // neg alias of "sub arg0, rzr, arg1, arg2". |
| 313 | kA64Orr3Rrl, // orr [s01100100] N[22] imm_r[21-16] imm_s[15-10] rn[9-5] rd[4-0]. |
| 314 | kA64Orr4rrro, // orr [s0101010] shift[23-22] [0] rm[20-16] imm_6[15-10] rn[9-5] rd[4-0]. |
| 315 | kA64Ret, // ret [11010110010111110000001111000000]. |
| 316 | kA64Rev2rr, // rev [s10110101100000000001x] rn[9-5] rd[4-0]. |
| 317 | kA64Rev162rr, // rev16[s101101011000000000001] rn[9-5] rd[4-0]. |
| 318 | kA64Ror3rrr, // ror [s0011010110] rm[20-16] [001011] rn[9-5] rd[4-0]. |
| 319 | kA64Sbc3rrr, // sbc [s0011010000] rm[20-16] [000000] rn[9-5] rd[4-0]. |
| 320 | kA64Sbfm4rrdd, // sbfm[0001001100] imm_r[21-16] imm_s[15-10] rn[9-5] rd[4-0]. |
| 321 | kA64Scvtf2fw, // scvtf [000111100s100010000000] rn[9-5] rd[4-0]. |
| 322 | kA64Scvtf2fx, // scvtf [100111100s100010000000] rn[9-5] rd[4-0]. |
| 323 | kA64Sdiv3rrr, // sdiv[s0011010110] rm[20-16] [000011] rn[9-5] rd[4-0]. |
| 324 | kA64Smaddl4xwwx, // smaddl [10011011001] rm[20-16] [0] ra[14-10] rn[9-5] rd[4-0]. |
| 325 | kA64Stp4rrXD, // stp [s010100101] imm_7[21-15] rt2[14-10] rn[9-5] rt[4-0]. |
| 326 | kA64StpPost4rrXD, // stp [s010100010] imm_7[21-15] rt2[14-10] rn[9-5] rt[4-0]. |
| 327 | kA64StpPre4rrXD, // stp [s010100110] imm_7[21-15] rt2[14-10] rn[9-5] rt[4-0]. |
| 328 | kA64Str3fXD, // str [1s11110100] imm_12[21-10] rn[9-5] rt[4-0]. |
| 329 | kA64Str4fXxG, // str [1s111100001] rm[20-16] [011] S[12] [10] rn[9-5] rt[4-0]. |
| 330 | kA64Str3rXD, // str [1s11100100] imm_12[21-10] rn[9-5] rt[4-0]. |
| 331 | kA64Str4rXxG, // str [1s111000001] rm[20-16] option[15-13] S[12-12] [10] rn[9-5] rt[4-0]. |
| 332 | kA64Strb3wXd, // strb[0011100100] imm_12[21-10] rn[9-5] rt[4-0]. |
| 333 | kA64Strb3wXx, // strb[00111000001] rm[20-16] [011] S[12] [10] rn[9-5] rt[4-0]. |
| 334 | kA64Strh3wXF, // strh[0111100100] imm_12[21-10] rn[9-5] rt[4-0]. |
| 335 | kA64Strh4wXxd, // strh[01111000001] rm[20-16] [011] S[12] [10] rn[9-5] rt[4-0]. |
| 336 | kA64StrPost3rXd, // str [1s111000000] imm_9[20-12] [01] rn[9-5] rt[4-0]. |
| 337 | kA64Stur3fXd, // stur[1s111100000] imm_9[20-12] [00] rn[9-5] rt[4-0]. |
| 338 | kA64Stur3rXd, // stur[1s111000000] imm_9[20-12] [00] rn[9-5] rt[4-0]. |
| 339 | kA64Stxr3wrX, // stxr[11001000000] rs[20-16] [011111] rn[9-5] rt[4-0]. |
| 340 | kA64Sub4RRdT, // sub [s101000100] imm_12[21-10] rn[9-5] rd[4-0]. |
| 341 | kA64Sub4rrro, // sub [s1001011001] rm[20-16] option[15-13] imm_3[12-10] rn[9-5] rd[4-0]. |
| 342 | kA64Subs3rRd, // subs[s111000100] imm_12[21-10] rn[9-5] rd[4-0]. |
| 343 | kA64Tst3rro, // tst alias of "ands rzr, arg1, arg2, arg3". |
| 344 | kA64Ubfm4rrdd, // ubfm[s10100110] N[22] imm_r[21-16] imm_s[15-10] rn[9-5] rd[4-0]. |
| 345 | kA64Last, |
| 346 | kA64NotWide = 0, // Flag used to select the first instruction variant. |
| 347 | kA64Wide = 0x1000 // Flag used to select the second instruction variant. |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 348 | }; |
| 349 | |
| 350 | /* |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 351 | * The A64 instruction set provides two variants for many instructions. For example, "mov wN, wM" |
| 352 | * and "mov xN, xM" or - for floating point instructions - "mov sN, sM" and "mov dN, dM". |
| 353 | * It definitely makes sense to exploit this symmetries of the instruction set. We do this via the |
| 354 | * WIDE, UNWIDE macros. For opcodes that allow it, the wide variant can be obtained by applying the |
| 355 | * WIDE macro to the non-wide opcode. E.g. WIDE(kA64Sub4RRdT). |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 356 | */ |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 357 | |
| 358 | // Return the wide and no-wide variants of the given opcode. |
| 359 | #define WIDE(op) ((ArmOpcode)((op) | kA64Wide)) |
| 360 | #define UNWIDE(op) ((ArmOpcode)((op) & ~kA64Wide)) |
| 361 | |
| 362 | // Whether the given opcode is wide. |
| 363 | #define IS_WIDE(op) (((op) & kA64Wide) != 0) |
| 364 | |
| 365 | /* |
| 366 | * Floating point variants. These are just aliases of the macros above which we use for floating |
| 367 | * point instructions, just for readibility reasons. |
| 368 | * TODO(Arm64): should we remove these and use the original macros? |
| 369 | */ |
| 370 | #define FWIDE WIDE |
| 371 | #define FUNWIDE UNWIDE |
| 372 | #define IS_FWIDE IS_WIDE |
| 373 | |
| 374 | #define OP_KIND_UNWIDE(opcode) (opcode) |
| 375 | #define OP_KIND_IS_WIDE(opcode) (false) |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 376 | |
| 377 | enum ArmOpDmbOptions { |
| 378 | kSY = 0xf, |
| 379 | kST = 0xe, |
| 380 | kISH = 0xb, |
| 381 | kISHST = 0xa, |
| 382 | kNSH = 0x7, |
| 383 | kNSHST = 0x6 |
| 384 | }; |
| 385 | |
| 386 | // Instruction assembly field_loc kind. |
| 387 | enum ArmEncodingKind { |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 388 | // All the formats below are encoded in the same way (as a kFmtBitBlt). |
| 389 | // These are grouped together, for fast handling (e.g. "if (LIKELY(fmt <= kFmtBitBlt)) ..."). |
| 390 | kFmtRegW = 0, // Word register (w) or wzr. |
| 391 | kFmtRegX, // Extended word register (x) or xzr. |
| 392 | kFmtRegR, // Register with same width as the instruction or zr. |
| 393 | kFmtRegWOrSp, // Word register (w) or wsp. |
| 394 | kFmtRegXOrSp, // Extended word register (x) or sp. |
| 395 | kFmtRegROrSp, // Register with same width as the instruction or sp. |
| 396 | kFmtRegS, // Single FP reg. |
| 397 | kFmtRegD, // Double FP reg. |
| 398 | kFmtRegF, // Single/double FP reg depending on the instruction width. |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 399 | kFmtBitBlt, // Bit string using end/start. |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 400 | |
| 401 | // Less likely formats. |
| 402 | kFmtUnused, // Unused field and marks end of formats. |
| 403 | kFmtImm21, // Sign-extended immediate using [23..5,30..29]. |
| 404 | kFmtShift, // Register shift, 9-bit at [23..21, 15..10].. |
| 405 | kFmtExtend, // Register extend, 9-bit at [23..21, 15..10]. |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 406 | kFmtSkip, // Unused field, but continue to next. |
| 407 | }; |
| 408 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 409 | // Struct used to define the snippet positions for each A64 opcode. |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 410 | struct ArmEncodingMap { |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 411 | uint32_t wskeleton; |
| 412 | uint32_t xskeleton; |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 413 | struct { |
| 414 | ArmEncodingKind kind; |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 415 | int end; // end for kFmtBitBlt, 1-bit slice end for FP regs. |
| 416 | int start; // start for kFmtBitBlt, 4-bit slice end for FP regs. |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 417 | } field_loc[4]; |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 418 | ArmOpcode opcode; // can be WIDE()-ned to indicate it has a wide variant. |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 419 | uint64_t flags; |
| 420 | const char* name; |
| 421 | const char* fmt; |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 422 | int size; // Note: size is in bytes. |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 423 | FixupKind fixup; |
| 424 | }; |
| 425 | |
Matteo Franchin | e45fb9e | 2014-05-06 10:10:30 +0100 | [diff] [blame] | 426 | #if 0 |
| 427 | // TODO(Arm64): try the following alternative, which fits exactly in one cache line (64 bytes). |
| 428 | struct ArmEncodingMap { |
| 429 | uint32_t wskeleton; |
| 430 | uint32_t xskeleton; |
| 431 | uint64_t flags; |
| 432 | const char* name; |
| 433 | const char* fmt; |
| 434 | struct { |
| 435 | uint8_t kind; |
| 436 | int8_t end; // end for kFmtBitBlt, 1-bit slice end for FP regs. |
| 437 | int8_t start; // start for kFmtBitBlt, 4-bit slice end for FP regs. |
| 438 | } field_loc[4]; |
| 439 | uint32_t fixup; |
| 440 | uint32_t opcode; // can be WIDE()-ned to indicate it has a wide variant. |
| 441 | uint32_t padding[3]; |
| 442 | }; |
| 443 | #endif |
| 444 | |
Matteo Franchin | 43ec873 | 2014-03-31 15:00:14 +0100 | [diff] [blame] | 445 | } // namespace art |
| 446 | |
| 447 | #endif // ART_COMPILER_DEX_QUICK_ARM64_ARM64_LIR_H_ |