Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 1 | // Copyright 2013 the V8 project authors. All rights reserved. |
| 2 | // Redistribution and use in source and binary forms, with or without |
| 3 | // modification, are permitted provided that the following conditions are |
| 4 | // met: |
| 5 | // |
| 6 | // * Redistributions of source code must retain the above copyright |
| 7 | // notice, this list of conditions and the following disclaimer. |
| 8 | // * Redistributions in binary form must reproduce the above |
| 9 | // copyright notice, this list of conditions and the following |
| 10 | // disclaimer in the documentation and/or other materials provided |
| 11 | // with the distribution. |
| 12 | // * Neither the name of Google Inc. nor the names of its |
| 13 | // contributors may be used to endorse or promote products derived |
| 14 | // from this software without specific prior written permission. |
| 15 | // |
| 16 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 17 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 18 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 19 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 20 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 21 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 22 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 23 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 24 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 25 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 26 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 27 | |
| 28 | #include <stdio.h> |
| 29 | #include <cstring> |
| 30 | |
| 31 | #include "src/v8.h" |
| 32 | #include "test/cctest/cctest.h" |
| 33 | |
| 34 | #include "src/macro-assembler.h" |
| 35 | |
| 36 | #include "src/arm64/assembler-arm64.h" |
| 37 | #include "src/arm64/decoder-arm64-inl.h" |
| 38 | #include "src/arm64/disasm-arm64.h" |
| 39 | #include "src/arm64/macro-assembler-arm64.h" |
| 40 | #include "src/arm64/utils-arm64.h" |
| 41 | |
| 42 | using namespace v8::internal; |
| 43 | |
| 44 | #define TEST_(name) TEST(DISASM_##name) |
| 45 | |
| 46 | #define EXP_SIZE (256) |
| 47 | #define INSTR_SIZE (1024) |
| 48 | #define SET_UP_CLASS(ASMCLASS) \ |
| 49 | InitializeVM(); \ |
| 50 | Isolate* isolate = Isolate::Current(); \ |
| 51 | HandleScope scope(isolate); \ |
| 52 | byte* buf = static_cast<byte*>(malloc(INSTR_SIZE)); \ |
| 53 | uint32_t encoding = 0; \ |
| 54 | ASMCLASS* assm = new ASMCLASS(isolate, buf, INSTR_SIZE); \ |
| 55 | Decoder<DispatchingDecoderVisitor>* decoder = \ |
| 56 | new Decoder<DispatchingDecoderVisitor>(); \ |
| 57 | Disassembler* disasm = new Disassembler(); \ |
| 58 | decoder->AppendVisitor(disasm) |
| 59 | |
| 60 | #define SET_UP() SET_UP_CLASS(Assembler) |
| 61 | |
| 62 | #define COMPARE(ASM, EXP) \ |
| 63 | assm->Reset(); \ |
| 64 | assm->ASM; \ |
| 65 | assm->GetCode(NULL); \ |
| 66 | decoder->Decode(reinterpret_cast<Instruction*>(buf)); \ |
| 67 | encoding = *reinterpret_cast<uint32_t*>(buf); \ |
| 68 | if (strcmp(disasm->GetOutput(), EXP) != 0) { \ |
| 69 | printf("%u : Encoding: %08" PRIx32 "\nExpected: %s\nFound: %s\n", \ |
| 70 | __LINE__, encoding, EXP, disasm->GetOutput()); \ |
| 71 | abort(); \ |
| 72 | } |
| 73 | |
| 74 | #define COMPARE_PREFIX(ASM, EXP) \ |
| 75 | assm->Reset(); \ |
| 76 | assm->ASM; \ |
| 77 | assm->GetCode(NULL); \ |
| 78 | decoder->Decode(reinterpret_cast<Instruction*>(buf)); \ |
| 79 | encoding = *reinterpret_cast<uint32_t*>(buf); \ |
| 80 | if (strncmp(disasm->GetOutput(), EXP, strlen(EXP)) != 0) { \ |
| 81 | printf("%u : Encoding: %08" PRIx32 "\nExpected: %s\nFound: %s\n", \ |
| 82 | __LINE__, encoding, EXP, disasm->GetOutput()); \ |
| 83 | abort(); \ |
| 84 | } |
| 85 | |
| 86 | #define CLEANUP() \ |
| 87 | delete disasm; \ |
| 88 | delete decoder; \ |
| 89 | delete assm |
| 90 | |
| 91 | |
| 92 | static bool vm_initialized = false; |
| 93 | |
| 94 | |
| 95 | static void InitializeVM() { |
| 96 | if (!vm_initialized) { |
| 97 | CcTest::InitializeVM(); |
| 98 | vm_initialized = true; |
| 99 | } |
| 100 | } |
| 101 | |
| 102 | |
| 103 | TEST_(bootstrap) { |
| 104 | SET_UP(); |
| 105 | |
| 106 | // Instructions generated by C compiler, disassembled by objdump, and |
| 107 | // reformatted to suit our disassembly style. |
| 108 | COMPARE(dci(0xa9ba7bfd), "stp fp, lr, [csp, #-96]!"); |
| 109 | COMPARE(dci(0x910003fd), "mov fp, csp"); |
| 110 | COMPARE(dci(0x9100e3a0), "add x0, fp, #0x38 (56)"); |
| 111 | COMPARE(dci(0xb900001f), "str wzr, [x0]"); |
| 112 | COMPARE(dci(0x528000e1), "movz w1, #0x7"); |
| 113 | COMPARE(dci(0xb9001c01), "str w1, [x0, #28]"); |
| 114 | COMPARE(dci(0x390043a0), "strb w0, [fp, #16]"); |
| 115 | COMPARE(dci(0x790027a0), "strh w0, [fp, #18]"); |
| 116 | COMPARE(dci(0xb9400400), "ldr w0, [x0, #4]"); |
| 117 | COMPARE(dci(0x0b000021), "add w1, w1, w0"); |
| 118 | COMPARE(dci(0x531b6800), "lsl w0, w0, #5"); |
| 119 | COMPARE(dci(0x521e0400), "eor w0, w0, #0xc"); |
| 120 | COMPARE(dci(0x72af0f00), "movk w0, #0x7878, lsl #16"); |
| 121 | COMPARE(dci(0xd360fc00), "lsr x0, x0, #32"); |
| 122 | COMPARE(dci(0x13037c01), "asr w1, w0, #3"); |
| 123 | COMPARE(dci(0x4b000021), "sub w1, w1, w0"); |
| 124 | COMPARE(dci(0x2a0103e0), "mov w0, w1"); |
| 125 | COMPARE(dci(0x93407c00), "sxtw x0, w0"); |
| 126 | COMPARE(dci(0x2a000020), "orr w0, w1, w0"); |
| 127 | COMPARE(dci(0xa8c67bfd), "ldp fp, lr, [csp], #96"); |
| 128 | |
| 129 | CLEANUP(); |
| 130 | } |
| 131 | |
| 132 | |
| 133 | TEST_(mov_mvn) { |
| 134 | SET_UP_CLASS(MacroAssembler); |
| 135 | |
| 136 | COMPARE(Mov(w0, Operand(0x1234)), "movz w0, #0x1234"); |
| 137 | COMPARE(Mov(x1, Operand(0x1234)), "movz x1, #0x1234"); |
| 138 | COMPARE(Mov(w2, Operand(w3)), "mov w2, w3"); |
| 139 | COMPARE(Mov(x4, Operand(x5)), "mov x4, x5"); |
| 140 | COMPARE(Mov(w6, Operand(w7, LSL, 5)), "lsl w6, w7, #5"); |
| 141 | COMPARE(Mov(x8, Operand(x9, ASR, 42)), "asr x8, x9, #42"); |
| 142 | COMPARE(Mov(w10, Operand(w11, UXTB)), "uxtb w10, w11"); |
| 143 | COMPARE(Mov(x12, Operand(x13, UXTB, 1)), "ubfiz x12, x13, #1, #8"); |
| 144 | COMPARE(Mov(w14, Operand(w15, SXTH, 2)), "sbfiz w14, w15, #2, #16"); |
| 145 | COMPARE(Mov(x16, Operand(x20, SXTW, 3)), "sbfiz x16, x20, #3, #32"); |
| 146 | |
| 147 | COMPARE(Mov(x0, csp), "mov x0, csp"); |
| 148 | COMPARE(Mov(w0, wcsp), "mov w0, wcsp"); |
| 149 | COMPARE(Mov(x0, xzr), "mov x0, xzr"); |
| 150 | COMPARE(Mov(w0, wzr), "mov w0, wzr"); |
| 151 | COMPARE(mov(x0, csp), "mov x0, csp"); |
| 152 | COMPARE(mov(w0, wcsp), "mov w0, wcsp"); |
| 153 | COMPARE(mov(x0, xzr), "mov x0, xzr"); |
| 154 | COMPARE(mov(w0, wzr), "mov w0, wzr"); |
| 155 | |
| 156 | COMPARE(Mvn(w0, Operand(0x1)), "movn w0, #0x1"); |
| 157 | COMPARE(Mvn(x1, Operand(0xfff)), "movn x1, #0xfff"); |
| 158 | COMPARE(Mvn(w2, Operand(w3)), "mvn w2, w3"); |
| 159 | COMPARE(Mvn(x4, Operand(x5)), "mvn x4, x5"); |
| 160 | COMPARE(Mvn(w6, Operand(w7, LSL, 12)), "mvn w6, w7, lsl #12"); |
| 161 | COMPARE(Mvn(x8, Operand(x9, ASR, 63)), "mvn x8, x9, asr #63"); |
| 162 | |
| 163 | CLEANUP(); |
| 164 | } |
| 165 | |
| 166 | |
| 167 | TEST_(move_immediate) { |
| 168 | SET_UP(); |
| 169 | |
| 170 | COMPARE(movz(w0, 0x1234), "movz w0, #0x1234"); |
| 171 | COMPARE(movz(x1, 0xabcd0000), "movz x1, #0xabcd0000"); |
| 172 | COMPARE(movz(x2, 0x555500000000), "movz x2, #0x555500000000"); |
| 173 | COMPARE(movz(x3, 0xaaaa000000000000), "movz x3, #0xaaaa000000000000"); |
| 174 | COMPARE(movz(x4, 0xabcd, 16), "movz x4, #0xabcd0000"); |
| 175 | COMPARE(movz(x5, 0x5555, 32), "movz x5, #0x555500000000"); |
| 176 | COMPARE(movz(x6, 0xaaaa, 48), "movz x6, #0xaaaa000000000000"); |
| 177 | |
| 178 | COMPARE(movk(w7, 0x1234), "movk w7, #0x1234"); |
| 179 | COMPARE(movk(x8, 0xabcd0000), "movk x8, #0xabcd, lsl #16"); |
| 180 | COMPARE(movk(x9, 0x555500000000), "movk x9, #0x5555, lsl #32"); |
| 181 | COMPARE(movk(x10, 0xaaaa000000000000), "movk x10, #0xaaaa, lsl #48"); |
| 182 | COMPARE(movk(w11, 0xabcd, 16), "movk w11, #0xabcd, lsl #16"); |
| 183 | COMPARE(movk(x12, 0x5555, 32), "movk x12, #0x5555, lsl #32"); |
| 184 | COMPARE(movk(x13, 0xaaaa, 48), "movk x13, #0xaaaa, lsl #48"); |
| 185 | |
| 186 | COMPARE(movn(w14, 0x1234), "movn w14, #0x1234"); |
| 187 | COMPARE(movn(x15, 0xabcd0000), "movn x15, #0xabcd0000"); |
| 188 | COMPARE(movn(x16, 0x555500000000), "movn x16, #0x555500000000"); |
| 189 | COMPARE(movn(x17, 0xaaaa000000000000), "movn x17, #0xaaaa000000000000"); |
| 190 | COMPARE(movn(w18, 0xabcd, 16), "movn w18, #0xabcd0000"); |
| 191 | COMPARE(movn(x19, 0x5555, 32), "movn x19, #0x555500000000"); |
| 192 | COMPARE(movn(x20, 0xaaaa, 48), "movn x20, #0xaaaa000000000000"); |
| 193 | |
| 194 | COMPARE(movk(w21, 0), "movk w21, #0x0"); |
| 195 | COMPARE(movk(x22, 0, 0), "movk x22, #0x0"); |
| 196 | COMPARE(movk(w23, 0, 16), "movk w23, #0x0, lsl #16"); |
| 197 | COMPARE(movk(x24, 0, 32), "movk x24, #0x0, lsl #32"); |
| 198 | COMPARE(movk(x25, 0, 48), "movk x25, #0x0, lsl #48"); |
| 199 | |
| 200 | CLEANUP(); |
| 201 | } |
| 202 | |
| 203 | |
| 204 | TEST(move_immediate_2) { |
| 205 | SET_UP_CLASS(MacroAssembler); |
| 206 | |
| 207 | // Move instructions expected for certain immediates. This is really a macro |
| 208 | // assembler test, to ensure it generates immediates efficiently. |
| 209 | COMPARE(Mov(w0, 0), "movz w0, #0x0"); |
| 210 | COMPARE(Mov(w0, 0x0000ffff), "movz w0, #0xffff"); |
| 211 | COMPARE(Mov(w0, 0x00010000), "movz w0, #0x10000"); |
| 212 | COMPARE(Mov(w0, 0xffff0000), "movz w0, #0xffff0000"); |
| 213 | COMPARE(Mov(w0, 0x0001ffff), "movn w0, #0xfffe0000"); |
| 214 | COMPARE(Mov(w0, 0xffff8000), "movn w0, #0x7fff"); |
| 215 | COMPARE(Mov(w0, 0xfffffffe), "movn w0, #0x1"); |
| 216 | COMPARE(Mov(w0, 0xffffffff), "movn w0, #0x0"); |
| 217 | COMPARE(Mov(w0, 0x00ffff00), "mov w0, #0xffff00"); |
| 218 | COMPARE(Mov(w0, 0xfffe7fff), "mov w0, #0xfffe7fff"); |
| 219 | COMPARE(Mov(w0, 0xfffeffff), "movn w0, #0x10000"); |
| 220 | COMPARE(Mov(w0, 0xffff7fff), "movn w0, #0x8000"); |
| 221 | |
| 222 | COMPARE(Mov(x0, 0), "movz x0, #0x0"); |
| 223 | COMPARE(Mov(x0, 0x0000ffff), "movz x0, #0xffff"); |
| 224 | COMPARE(Mov(x0, 0x00010000), "movz x0, #0x10000"); |
| 225 | COMPARE(Mov(x0, 0xffff0000), "movz x0, #0xffff0000"); |
| 226 | COMPARE(Mov(x0, 0x0001ffff), "mov x0, #0x1ffff"); |
| 227 | COMPARE(Mov(x0, 0xffff8000), "mov x0, #0xffff8000"); |
| 228 | COMPARE(Mov(x0, 0xfffffffe), "mov x0, #0xfffffffe"); |
| 229 | COMPARE(Mov(x0, 0xffffffff), "mov x0, #0xffffffff"); |
| 230 | COMPARE(Mov(x0, 0x00ffff00), "mov x0, #0xffff00"); |
| 231 | COMPARE(Mov(x0, 0xffff000000000000), "movz x0, #0xffff000000000000"); |
| 232 | COMPARE(Mov(x0, 0x0000ffff00000000), "movz x0, #0xffff00000000"); |
| 233 | COMPARE(Mov(x0, 0x00000000ffff0000), "movz x0, #0xffff0000"); |
| 234 | COMPARE(Mov(x0, 0xffffffffffff0000), "movn x0, #0xffff"); |
| 235 | COMPARE(Mov(x0, 0xffffffff0000ffff), "movn x0, #0xffff0000"); |
| 236 | COMPARE(Mov(x0, 0xffff0000ffffffff), "movn x0, #0xffff00000000"); |
| 237 | COMPARE(Mov(x0, 0x0000ffffffffffff), "movn x0, #0xffff000000000000"); |
| 238 | COMPARE(Mov(x0, 0xfffe7fffffffffff), "mov x0, #0xfffe7fffffffffff"); |
| 239 | COMPARE(Mov(x0, 0xfffeffffffffffff), "movn x0, #0x1000000000000"); |
| 240 | COMPARE(Mov(x0, 0xffff7fffffffffff), "movn x0, #0x800000000000"); |
| 241 | COMPARE(Mov(x0, 0xfffffffe7fffffff), "mov x0, #0xfffffffe7fffffff"); |
| 242 | COMPARE(Mov(x0, 0xfffffffeffffffff), "movn x0, #0x100000000"); |
| 243 | COMPARE(Mov(x0, 0xffffffff7fffffff), "movn x0, #0x80000000"); |
| 244 | COMPARE(Mov(x0, 0xfffffffffffe7fff), "mov x0, #0xfffffffffffe7fff"); |
| 245 | COMPARE(Mov(x0, 0xfffffffffffeffff), "movn x0, #0x10000"); |
| 246 | COMPARE(Mov(x0, 0xffffffffffff7fff), "movn x0, #0x8000"); |
| 247 | COMPARE(Mov(x0, 0xffffffffffffffff), "movn x0, #0x0"); |
| 248 | |
| 249 | COMPARE(Movk(w0, 0x1234, 0), "movk w0, #0x1234"); |
| 250 | COMPARE(Movk(x1, 0x2345, 0), "movk x1, #0x2345"); |
| 251 | COMPARE(Movk(w2, 0x3456, 16), "movk w2, #0x3456, lsl #16"); |
| 252 | COMPARE(Movk(x3, 0x4567, 16), "movk x3, #0x4567, lsl #16"); |
| 253 | COMPARE(Movk(x4, 0x5678, 32), "movk x4, #0x5678, lsl #32"); |
| 254 | COMPARE(Movk(x5, 0x6789, 48), "movk x5, #0x6789, lsl #48"); |
| 255 | |
| 256 | CLEANUP(); |
| 257 | } |
| 258 | |
| 259 | |
| 260 | TEST_(add_immediate) { |
| 261 | SET_UP(); |
| 262 | |
| 263 | COMPARE(add(w0, w1, Operand(0xff)), "add w0, w1, #0xff (255)"); |
| 264 | COMPARE(add(x2, x3, Operand(0x3ff)), "add x2, x3, #0x3ff (1023)"); |
| 265 | COMPARE(add(w4, w5, Operand(0xfff)), "add w4, w5, #0xfff (4095)"); |
| 266 | COMPARE(add(x6, x7, Operand(0x1000)), "add x6, x7, #0x1000 (4096)"); |
| 267 | COMPARE(add(w8, w9, Operand(0xff000)), "add w8, w9, #0xff000 (1044480)"); |
| 268 | COMPARE(add(x10, x11, Operand(0x3ff000)), |
| 269 | "add x10, x11, #0x3ff000 (4190208)"); |
| 270 | COMPARE(add(w12, w13, Operand(0xfff000)), |
| 271 | "add w12, w13, #0xfff000 (16773120)"); |
| 272 | COMPARE(adds(w14, w15, Operand(0xff)), "adds w14, w15, #0xff (255)"); |
| 273 | COMPARE(adds(x16, x17, Operand(0xaa000)), |
| 274 | "adds x16, x17, #0xaa000 (696320)"); |
| 275 | COMPARE(cmn(w18, Operand(0xff)), "cmn w18, #0xff (255)"); |
| 276 | COMPARE(cmn(x19, Operand(0xff000)), "cmn x19, #0xff000 (1044480)"); |
| 277 | COMPARE(add(w0, wcsp, Operand(0)), "mov w0, wcsp"); |
| 278 | COMPARE(add(csp, x0, Operand(0)), "mov csp, x0"); |
| 279 | |
| 280 | COMPARE(add(w1, wcsp, Operand(8)), "add w1, wcsp, #0x8 (8)"); |
| 281 | COMPARE(add(x2, csp, Operand(16)), "add x2, csp, #0x10 (16)"); |
| 282 | COMPARE(add(wcsp, wcsp, Operand(42)), "add wcsp, wcsp, #0x2a (42)"); |
| 283 | COMPARE(cmn(csp, Operand(24)), "cmn csp, #0x18 (24)"); |
| 284 | COMPARE(adds(wzr, wcsp, Operand(9)), "cmn wcsp, #0x9 (9)"); |
| 285 | |
| 286 | CLEANUP(); |
| 287 | } |
| 288 | |
| 289 | |
| 290 | TEST_(sub_immediate) { |
| 291 | SET_UP(); |
| 292 | |
| 293 | COMPARE(sub(w0, w1, Operand(0xff)), "sub w0, w1, #0xff (255)"); |
| 294 | COMPARE(sub(x2, x3, Operand(0x3ff)), "sub x2, x3, #0x3ff (1023)"); |
| 295 | COMPARE(sub(w4, w5, Operand(0xfff)), "sub w4, w5, #0xfff (4095)"); |
| 296 | COMPARE(sub(x6, x7, Operand(0x1000)), "sub x6, x7, #0x1000 (4096)"); |
| 297 | COMPARE(sub(w8, w9, Operand(0xff000)), "sub w8, w9, #0xff000 (1044480)"); |
| 298 | COMPARE(sub(x10, x11, Operand(0x3ff000)), |
| 299 | "sub x10, x11, #0x3ff000 (4190208)"); |
| 300 | COMPARE(sub(w12, w13, Operand(0xfff000)), |
| 301 | "sub w12, w13, #0xfff000 (16773120)"); |
| 302 | COMPARE(subs(w14, w15, Operand(0xff)), "subs w14, w15, #0xff (255)"); |
| 303 | COMPARE(subs(x16, x17, Operand(0xaa000)), |
| 304 | "subs x16, x17, #0xaa000 (696320)"); |
| 305 | COMPARE(cmp(w18, Operand(0xff)), "cmp w18, #0xff (255)"); |
| 306 | COMPARE(cmp(x19, Operand(0xff000)), "cmp x19, #0xff000 (1044480)"); |
| 307 | |
| 308 | COMPARE(add(w1, wcsp, Operand(8)), "add w1, wcsp, #0x8 (8)"); |
| 309 | COMPARE(add(x2, csp, Operand(16)), "add x2, csp, #0x10 (16)"); |
| 310 | COMPARE(add(wcsp, wcsp, Operand(42)), "add wcsp, wcsp, #0x2a (42)"); |
| 311 | COMPARE(cmn(csp, Operand(24)), "cmn csp, #0x18 (24)"); |
| 312 | COMPARE(adds(wzr, wcsp, Operand(9)), "cmn wcsp, #0x9 (9)"); |
| 313 | |
| 314 | CLEANUP(); |
| 315 | } |
| 316 | |
| 317 | |
| 318 | TEST_(add_shifted) { |
| 319 | SET_UP(); |
| 320 | |
| 321 | COMPARE(add(w0, w1, Operand(w2)), "add w0, w1, w2"); |
| 322 | COMPARE(add(x3, x4, Operand(x5)), "add x3, x4, x5"); |
| 323 | COMPARE(add(w6, w7, Operand(w8, LSL, 1)), "add w6, w7, w8, lsl #1"); |
| 324 | COMPARE(add(x9, x10, Operand(x11, LSL, 2)), "add x9, x10, x11, lsl #2"); |
| 325 | COMPARE(add(w12, w13, Operand(w14, LSR, 3)), "add w12, w13, w14, lsr #3"); |
| 326 | COMPARE(add(x15, x16, Operand(x17, LSR, 4)), "add x15, x16, x17, lsr #4"); |
| 327 | COMPARE(add(w18, w19, Operand(w20, ASR, 5)), "add w18, w19, w20, asr #5"); |
| 328 | COMPARE(add(x21, x22, Operand(x23, ASR, 6)), "add x21, x22, x23, asr #6"); |
| 329 | COMPARE(cmn(w24, Operand(w25)), "cmn w24, w25"); |
| 330 | COMPARE(cmn(x26, Operand(cp, LSL, 63)), "cmn x26, cp, lsl #63"); |
| 331 | |
| 332 | COMPARE(add(x0, csp, Operand(x1)), "add x0, csp, x1"); |
| 333 | COMPARE(add(w2, wcsp, Operand(w3)), "add w2, wcsp, w3"); |
| 334 | COMPARE(add(x4, csp, Operand(x5, LSL, 1)), "add x4, csp, x5, lsl #1"); |
| 335 | COMPARE(add(x4, xzr, Operand(x5, LSL, 1)), "add x4, xzr, x5, lsl #1"); |
| 336 | COMPARE(add(w6, wcsp, Operand(w7, LSL, 3)), "add w6, wcsp, w7, lsl #3"); |
| 337 | COMPARE(adds(xzr, csp, Operand(x8, LSL, 4)), "cmn csp, x8, lsl #4"); |
| 338 | COMPARE(adds(xzr, xzr, Operand(x8, LSL, 5)), "cmn xzr, x8, lsl #5"); |
| 339 | |
| 340 | CLEANUP(); |
| 341 | } |
| 342 | |
| 343 | |
| 344 | TEST_(sub_shifted) { |
| 345 | SET_UP(); |
| 346 | |
| 347 | COMPARE(sub(w0, w1, Operand(w2)), "sub w0, w1, w2"); |
| 348 | COMPARE(sub(x3, x4, Operand(x5)), "sub x3, x4, x5"); |
| 349 | COMPARE(sub(w6, w7, Operand(w8, LSL, 1)), "sub w6, w7, w8, lsl #1"); |
| 350 | COMPARE(sub(x9, x10, Operand(x11, LSL, 2)), "sub x9, x10, x11, lsl #2"); |
| 351 | COMPARE(sub(w12, w13, Operand(w14, LSR, 3)), "sub w12, w13, w14, lsr #3"); |
| 352 | COMPARE(sub(x15, x16, Operand(x17, LSR, 4)), "sub x15, x16, x17, lsr #4"); |
| 353 | COMPARE(sub(w18, w19, Operand(w20, ASR, 5)), "sub w18, w19, w20, asr #5"); |
| 354 | COMPARE(sub(x21, x22, Operand(x23, ASR, 6)), "sub x21, x22, x23, asr #6"); |
| 355 | COMPARE(cmp(w24, Operand(w25)), "cmp w24, w25"); |
| 356 | COMPARE(cmp(x26, Operand(cp, LSL, 63)), "cmp x26, cp, lsl #63"); |
| 357 | COMPARE(neg(w28, Operand(w29)), "neg w28, w29"); |
| 358 | COMPARE(neg(lr, Operand(x0, LSR, 62)), "neg lr, x0, lsr #62"); |
| 359 | COMPARE(negs(w1, Operand(w2)), "negs w1, w2"); |
| 360 | COMPARE(negs(x3, Operand(x4, ASR, 61)), "negs x3, x4, asr #61"); |
| 361 | |
| 362 | COMPARE(sub(x0, csp, Operand(x1)), "sub x0, csp, x1"); |
| 363 | COMPARE(sub(w2, wcsp, Operand(w3)), "sub w2, wcsp, w3"); |
| 364 | COMPARE(sub(x4, csp, Operand(x5, LSL, 1)), "sub x4, csp, x5, lsl #1"); |
| 365 | COMPARE(sub(x4, xzr, Operand(x5, LSL, 1)), "neg x4, x5, lsl #1"); |
| 366 | COMPARE(sub(w6, wcsp, Operand(w7, LSL, 3)), "sub w6, wcsp, w7, lsl #3"); |
| 367 | COMPARE(subs(xzr, csp, Operand(x8, LSL, 4)), "cmp csp, x8, lsl #4"); |
| 368 | COMPARE(subs(xzr, xzr, Operand(x8, LSL, 5)), "cmp xzr, x8, lsl #5"); |
| 369 | |
| 370 | CLEANUP(); |
| 371 | } |
| 372 | |
| 373 | |
| 374 | TEST_(add_extended) { |
| 375 | SET_UP(); |
| 376 | |
| 377 | COMPARE(add(w0, w1, Operand(w2, UXTB)), "add w0, w1, w2, uxtb"); |
| 378 | COMPARE(adds(x3, x4, Operand(w5, UXTB, 1)), "adds x3, x4, w5, uxtb #1"); |
| 379 | COMPARE(add(w6, w7, Operand(w8, UXTH, 2)), "add w6, w7, w8, uxth #2"); |
| 380 | COMPARE(adds(x9, x10, Operand(x11, UXTW, 3)), "adds x9, x10, w11, uxtw #3"); |
| 381 | COMPARE(add(x12, x13, Operand(x14, UXTX, 4)), "add x12, x13, x14, uxtx #4"); |
| 382 | COMPARE(adds(w15, w16, Operand(w17, SXTB, 4)), "adds w15, w16, w17, sxtb #4"); |
| 383 | COMPARE(add(x18, x19, Operand(x20, SXTB, 3)), "add x18, x19, w20, sxtb #3"); |
| 384 | COMPARE(adds(w21, w22, Operand(w23, SXTH, 2)), "adds w21, w22, w23, sxth #2"); |
| 385 | COMPARE(add(x24, x25, Operand(x26, SXTW, 1)), "add x24, x25, w26, sxtw #1"); |
| 386 | COMPARE(adds(cp, jssp, Operand(fp, SXTX)), "adds cp, jssp, fp, sxtx"); |
| 387 | COMPARE(cmn(w0, Operand(w1, UXTB, 2)), "cmn w0, w1, uxtb #2"); |
| 388 | COMPARE(cmn(x2, Operand(x3, SXTH, 4)), "cmn x2, w3, sxth #4"); |
| 389 | |
| 390 | COMPARE(add(w0, wcsp, Operand(w1, UXTB)), "add w0, wcsp, w1, uxtb"); |
| 391 | COMPARE(add(x2, csp, Operand(x3, UXTH, 1)), "add x2, csp, w3, uxth #1"); |
| 392 | COMPARE(add(wcsp, wcsp, Operand(w4, UXTW, 2)), "add wcsp, wcsp, w4, lsl #2"); |
| 393 | COMPARE(cmn(csp, Operand(xzr, UXTX, 3)), "cmn csp, xzr, lsl #3"); |
| 394 | COMPARE(cmn(csp, Operand(xzr, LSL, 4)), "cmn csp, xzr, lsl #4"); |
| 395 | |
| 396 | CLEANUP(); |
| 397 | } |
| 398 | |
| 399 | |
| 400 | TEST_(sub_extended) { |
| 401 | SET_UP(); |
| 402 | |
| 403 | COMPARE(sub(w0, w1, Operand(w2, UXTB)), "sub w0, w1, w2, uxtb"); |
| 404 | COMPARE(subs(x3, x4, Operand(w5, UXTB, 1)), "subs x3, x4, w5, uxtb #1"); |
| 405 | COMPARE(sub(w6, w7, Operand(w8, UXTH, 2)), "sub w6, w7, w8, uxth #2"); |
| 406 | COMPARE(subs(x9, x10, Operand(x11, UXTW, 3)), "subs x9, x10, w11, uxtw #3"); |
| 407 | COMPARE(sub(x12, x13, Operand(x14, UXTX, 4)), "sub x12, x13, x14, uxtx #4"); |
| 408 | COMPARE(subs(w15, w16, Operand(w17, SXTB, 4)), "subs w15, w16, w17, sxtb #4"); |
| 409 | COMPARE(sub(x18, x19, Operand(x20, SXTB, 3)), "sub x18, x19, w20, sxtb #3"); |
| 410 | COMPARE(subs(w21, w22, Operand(w23, SXTH, 2)), "subs w21, w22, w23, sxth #2"); |
| 411 | COMPARE(sub(x24, x25, Operand(x26, SXTW, 1)), "sub x24, x25, w26, sxtw #1"); |
| 412 | COMPARE(subs(cp, jssp, Operand(fp, SXTX)), "subs cp, jssp, fp, sxtx"); |
| 413 | COMPARE(cmp(w0, Operand(w1, SXTB, 1)), "cmp w0, w1, sxtb #1"); |
| 414 | COMPARE(cmp(x2, Operand(x3, UXTH, 3)), "cmp x2, w3, uxth #3"); |
| 415 | |
| 416 | COMPARE(sub(w0, wcsp, Operand(w1, UXTB)), "sub w0, wcsp, w1, uxtb"); |
| 417 | COMPARE(sub(x2, csp, Operand(x3, UXTH, 1)), "sub x2, csp, w3, uxth #1"); |
| 418 | COMPARE(sub(wcsp, wcsp, Operand(w4, UXTW, 2)), "sub wcsp, wcsp, w4, lsl #2"); |
| 419 | COMPARE(cmp(csp, Operand(xzr, UXTX, 3)), "cmp csp, xzr, lsl #3"); |
| 420 | COMPARE(cmp(csp, Operand(xzr, LSL, 4)), "cmp csp, xzr, lsl #4"); |
| 421 | |
| 422 | CLEANUP(); |
| 423 | } |
| 424 | |
| 425 | |
| 426 | TEST_(adc_subc_ngc) { |
| 427 | SET_UP(); |
| 428 | |
| 429 | COMPARE(adc(w0, w1, Operand(w2)), "adc w0, w1, w2"); |
| 430 | COMPARE(adc(x3, x4, Operand(x5)), "adc x3, x4, x5"); |
| 431 | COMPARE(adcs(w6, w7, Operand(w8)), "adcs w6, w7, w8"); |
| 432 | COMPARE(adcs(x9, x10, Operand(x11)), "adcs x9, x10, x11"); |
| 433 | COMPARE(sbc(w12, w13, Operand(w14)), "sbc w12, w13, w14"); |
| 434 | COMPARE(sbc(x15, x16, Operand(x17)), "sbc x15, x16, x17"); |
| 435 | COMPARE(sbcs(w18, w19, Operand(w20)), "sbcs w18, w19, w20"); |
| 436 | COMPARE(sbcs(x21, x22, Operand(x23)), "sbcs x21, x22, x23"); |
| 437 | COMPARE(ngc(w24, Operand(w25)), "ngc w24, w25"); |
| 438 | COMPARE(ngc(x26, Operand(cp)), "ngc x26, cp"); |
| 439 | COMPARE(ngcs(w28, Operand(w29)), "ngcs w28, w29"); |
| 440 | COMPARE(ngcs(lr, Operand(x0)), "ngcs lr, x0"); |
| 441 | |
| 442 | CLEANUP(); |
| 443 | } |
| 444 | |
| 445 | |
| 446 | TEST_(mul_and_div) { |
| 447 | SET_UP(); |
| 448 | |
| 449 | COMPARE(mul(w0, w1, w2), "mul w0, w1, w2"); |
| 450 | COMPARE(mul(x3, x4, x5), "mul x3, x4, x5"); |
| 451 | COMPARE(mul(w30, w0, w1), "mul w30, w0, w1"); |
| 452 | COMPARE(mul(lr, x0, x1), "mul lr, x0, x1"); |
| 453 | COMPARE(mneg(w0, w1, w2), "mneg w0, w1, w2"); |
| 454 | COMPARE(mneg(x3, x4, x5), "mneg x3, x4, x5"); |
| 455 | COMPARE(mneg(w30, w0, w1), "mneg w30, w0, w1"); |
| 456 | COMPARE(mneg(lr, x0, x1), "mneg lr, x0, x1"); |
| 457 | COMPARE(smull(x0, w0, w1), "smull x0, w0, w1"); |
| 458 | COMPARE(smull(lr, w30, w0), "smull lr, w30, w0"); |
| 459 | COMPARE(smulh(x0, x1, x2), "smulh x0, x1, x2"); |
| 460 | |
| 461 | COMPARE(madd(w0, w1, w2, w3), "madd w0, w1, w2, w3"); |
| 462 | COMPARE(madd(x4, x5, x6, x7), "madd x4, x5, x6, x7"); |
| 463 | COMPARE(madd(w8, w9, w10, wzr), "mul w8, w9, w10"); |
| 464 | COMPARE(madd(x11, x12, x13, xzr), "mul x11, x12, x13"); |
| 465 | COMPARE(msub(w14, w15, w16, w17), "msub w14, w15, w16, w17"); |
| 466 | COMPARE(msub(x18, x19, x20, x21), "msub x18, x19, x20, x21"); |
| 467 | COMPARE(msub(w22, w23, w24, wzr), "mneg w22, w23, w24"); |
| 468 | COMPARE(msub(x25, x26, x0, xzr), "mneg x25, x26, x0"); |
| 469 | |
| 470 | COMPARE(sdiv(w0, w1, w2), "sdiv w0, w1, w2"); |
| 471 | COMPARE(sdiv(x3, x4, x5), "sdiv x3, x4, x5"); |
| 472 | COMPARE(udiv(w6, w7, w8), "udiv w6, w7, w8"); |
| 473 | COMPARE(udiv(x9, x10, x11), "udiv x9, x10, x11"); |
| 474 | |
| 475 | CLEANUP(); |
| 476 | } |
| 477 | |
| 478 | |
| 479 | TEST(maddl_msubl) { |
| 480 | SET_UP(); |
| 481 | |
| 482 | COMPARE(smaddl(x0, w1, w2, x3), "smaddl x0, w1, w2, x3"); |
| 483 | COMPARE(smaddl(x25, w21, w22, x16), "smaddl x25, w21, w22, x16"); |
| 484 | COMPARE(umaddl(x0, w1, w2, x3), "umaddl x0, w1, w2, x3"); |
| 485 | COMPARE(umaddl(x25, w21, w22, x16), "umaddl x25, w21, w22, x16"); |
| 486 | |
| 487 | COMPARE(smsubl(x0, w1, w2, x3), "smsubl x0, w1, w2, x3"); |
| 488 | COMPARE(smsubl(x25, w21, w22, x16), "smsubl x25, w21, w22, x16"); |
| 489 | COMPARE(umsubl(x0, w1, w2, x3), "umsubl x0, w1, w2, x3"); |
| 490 | COMPARE(umsubl(x25, w21, w22, x16), "umsubl x25, w21, w22, x16"); |
| 491 | |
| 492 | CLEANUP(); |
| 493 | } |
| 494 | |
| 495 | |
| 496 | TEST_(dp_1_source) { |
| 497 | SET_UP(); |
| 498 | |
| 499 | COMPARE(rbit(w0, w1), "rbit w0, w1"); |
| 500 | COMPARE(rbit(x2, x3), "rbit x2, x3"); |
| 501 | COMPARE(rev16(w4, w5), "rev16 w4, w5"); |
| 502 | COMPARE(rev16(x6, x7), "rev16 x6, x7"); |
| 503 | COMPARE(rev32(x8, x9), "rev32 x8, x9"); |
| 504 | COMPARE(rev(w10, w11), "rev w10, w11"); |
| 505 | COMPARE(rev(x12, x13), "rev x12, x13"); |
| 506 | COMPARE(clz(w14, w15), "clz w14, w15"); |
| 507 | COMPARE(clz(x16, x17), "clz x16, x17"); |
| 508 | COMPARE(cls(w18, w19), "cls w18, w19"); |
| 509 | COMPARE(cls(x20, x21), "cls x20, x21"); |
| 510 | |
| 511 | CLEANUP(); |
| 512 | } |
| 513 | |
| 514 | |
| 515 | TEST_(bitfield) { |
| 516 | SET_UP(); |
| 517 | |
| 518 | COMPARE(sxtb(w0, w1), "sxtb w0, w1"); |
| 519 | COMPARE(sxtb(x2, x3), "sxtb x2, w3"); |
| 520 | COMPARE(sxth(w4, w5), "sxth w4, w5"); |
| 521 | COMPARE(sxth(x6, x7), "sxth x6, w7"); |
| 522 | COMPARE(sxtw(x8, x9), "sxtw x8, w9"); |
| 523 | COMPARE(sxtb(x0, w1), "sxtb x0, w1"); |
| 524 | COMPARE(sxth(x2, w3), "sxth x2, w3"); |
| 525 | COMPARE(sxtw(x4, w5), "sxtw x4, w5"); |
| 526 | |
| 527 | COMPARE(uxtb(w10, w11), "uxtb w10, w11"); |
| 528 | COMPARE(uxtb(x12, x13), "uxtb x12, w13"); |
| 529 | COMPARE(uxth(w14, w15), "uxth w14, w15"); |
| 530 | COMPARE(uxth(x16, x17), "uxth x16, w17"); |
| 531 | COMPARE(uxtw(x18, x19), "ubfx x18, x19, #0, #32"); |
| 532 | |
| 533 | COMPARE(asr(w20, w21, 10), "asr w20, w21, #10"); |
| 534 | COMPARE(asr(x22, x23, 20), "asr x22, x23, #20"); |
| 535 | COMPARE(lsr(w24, w25, 10), "lsr w24, w25, #10"); |
| 536 | COMPARE(lsr(x26, cp, 20), "lsr x26, cp, #20"); |
| 537 | COMPARE(lsl(w28, w29, 10), "lsl w28, w29, #10"); |
| 538 | COMPARE(lsl(lr, x0, 20), "lsl lr, x0, #20"); |
| 539 | |
| 540 | COMPARE(sbfiz(w1, w2, 1, 20), "sbfiz w1, w2, #1, #20"); |
| 541 | COMPARE(sbfiz(x3, x4, 2, 19), "sbfiz x3, x4, #2, #19"); |
| 542 | COMPARE(sbfx(w5, w6, 3, 18), "sbfx w5, w6, #3, #18"); |
| 543 | COMPARE(sbfx(x7, x8, 4, 17), "sbfx x7, x8, #4, #17"); |
| 544 | COMPARE(bfi(w9, w10, 5, 16), "bfi w9, w10, #5, #16"); |
| 545 | COMPARE(bfi(x11, x12, 6, 15), "bfi x11, x12, #6, #15"); |
| 546 | COMPARE(bfxil(w13, w14, 7, 14), "bfxil w13, w14, #7, #14"); |
| 547 | COMPARE(bfxil(x15, x16, 8, 13), "bfxil x15, x16, #8, #13"); |
| 548 | COMPARE(ubfiz(w17, w18, 9, 12), "ubfiz w17, w18, #9, #12"); |
| 549 | COMPARE(ubfiz(x19, x20, 10, 11), "ubfiz x19, x20, #10, #11"); |
| 550 | COMPARE(ubfx(w21, w22, 11, 10), "ubfx w21, w22, #11, #10"); |
| 551 | COMPARE(ubfx(x23, x24, 12, 9), "ubfx x23, x24, #12, #9"); |
| 552 | |
| 553 | CLEANUP(); |
| 554 | } |
| 555 | |
| 556 | |
| 557 | TEST_(extract) { |
| 558 | SET_UP(); |
| 559 | |
| 560 | COMPARE(extr(w0, w1, w2, 0), "extr w0, w1, w2, #0"); |
| 561 | COMPARE(extr(x3, x4, x5, 1), "extr x3, x4, x5, #1"); |
| 562 | COMPARE(extr(w6, w7, w8, 31), "extr w6, w7, w8, #31"); |
| 563 | COMPARE(extr(x9, x10, x11, 63), "extr x9, x10, x11, #63"); |
| 564 | COMPARE(extr(w12, w13, w13, 10), "ror w12, w13, #10"); |
| 565 | COMPARE(extr(x14, x15, x15, 42), "ror x14, x15, #42"); |
| 566 | |
| 567 | CLEANUP(); |
| 568 | } |
| 569 | |
| 570 | |
| 571 | TEST_(logical_immediate) { |
| 572 | SET_UP(); |
| 573 | #define RESULT_SIZE (256) |
| 574 | |
| 575 | char result[RESULT_SIZE]; |
| 576 | |
| 577 | // Test immediate encoding - 64-bit destination. |
| 578 | // 64-bit patterns. |
| 579 | uint64_t value = 0x7fffffff; |
| 580 | for (int i = 0; i < 64; i++) { |
| 581 | snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); |
| 582 | COMPARE(and_(x0, x0, Operand(value)), result); |
| 583 | value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. |
| 584 | } |
| 585 | |
| 586 | // 32-bit patterns. |
| 587 | value = 0x00003fff00003fffL; |
| 588 | for (int i = 0; i < 32; i++) { |
| 589 | snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); |
| 590 | COMPARE(and_(x0, x0, Operand(value)), result); |
| 591 | value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. |
| 592 | } |
| 593 | |
| 594 | // 16-bit patterns. |
| 595 | value = 0x001f001f001f001fL; |
| 596 | for (int i = 0; i < 16; i++) { |
| 597 | snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); |
| 598 | COMPARE(and_(x0, x0, Operand(value)), result); |
| 599 | value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. |
| 600 | } |
| 601 | |
| 602 | // 8-bit patterns. |
| 603 | value = 0x0e0e0e0e0e0e0e0eL; |
| 604 | for (int i = 0; i < 8; i++) { |
| 605 | snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); |
| 606 | COMPARE(and_(x0, x0, Operand(value)), result); |
| 607 | value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. |
| 608 | } |
| 609 | |
| 610 | // 4-bit patterns. |
| 611 | value = 0x6666666666666666L; |
| 612 | for (int i = 0; i < 4; i++) { |
| 613 | snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); |
| 614 | COMPARE(and_(x0, x0, Operand(value)), result); |
| 615 | value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. |
| 616 | } |
| 617 | |
| 618 | // 2-bit patterns. |
| 619 | COMPARE(and_(x0, x0, Operand(0x5555555555555555L)), |
| 620 | "and x0, x0, #0x5555555555555555"); |
| 621 | COMPARE(and_(x0, x0, Operand(0xaaaaaaaaaaaaaaaaL)), |
| 622 | "and x0, x0, #0xaaaaaaaaaaaaaaaa"); |
| 623 | |
| 624 | // Test immediate encoding - 32-bit destination. |
| 625 | COMPARE(and_(w0, w0, Operand(0xff8007ff)), |
| 626 | "and w0, w0, #0xff8007ff"); // 32-bit pattern. |
| 627 | COMPARE(and_(w0, w0, Operand(0xf87ff87f)), |
| 628 | "and w0, w0, #0xf87ff87f"); // 16-bit pattern. |
| 629 | COMPARE(and_(w0, w0, Operand(0x87878787)), |
| 630 | "and w0, w0, #0x87878787"); // 8-bit pattern. |
| 631 | COMPARE(and_(w0, w0, Operand(0x66666666)), |
| 632 | "and w0, w0, #0x66666666"); // 4-bit pattern. |
| 633 | COMPARE(and_(w0, w0, Operand(0x55555555)), |
| 634 | "and w0, w0, #0x55555555"); // 2-bit pattern. |
| 635 | |
| 636 | // Test other instructions. |
| 637 | COMPARE(tst(w1, Operand(0x11111111)), |
| 638 | "tst w1, #0x11111111"); |
| 639 | COMPARE(tst(x2, Operand(0x8888888888888888L)), |
| 640 | "tst x2, #0x8888888888888888"); |
| 641 | COMPARE(orr(w7, w8, Operand(0xaaaaaaaa)), |
| 642 | "orr w7, w8, #0xaaaaaaaa"); |
| 643 | COMPARE(orr(x9, x10, Operand(0x5555555555555555L)), |
| 644 | "orr x9, x10, #0x5555555555555555"); |
| 645 | COMPARE(eor(w15, w16, Operand(0x00000001)), |
| 646 | "eor w15, w16, #0x1"); |
| 647 | COMPARE(eor(x17, x18, Operand(0x0000000000000003L)), |
| 648 | "eor x17, x18, #0x3"); |
| 649 | COMPARE(ands(w23, w24, Operand(0x0000000f)), "ands w23, w24, #0xf"); |
| 650 | COMPARE(ands(x25, x26, Operand(0x800000000000000fL)), |
| 651 | "ands x25, x26, #0x800000000000000f"); |
| 652 | |
| 653 | // Test inverse. |
| 654 | COMPARE(bic(w3, w4, Operand(0x20202020)), |
| 655 | "and w3, w4, #0xdfdfdfdf"); |
| 656 | COMPARE(bic(x5, x6, Operand(0x4040404040404040L)), |
| 657 | "and x5, x6, #0xbfbfbfbfbfbfbfbf"); |
| 658 | COMPARE(orn(w11, w12, Operand(0x40004000)), |
| 659 | "orr w11, w12, #0xbfffbfff"); |
| 660 | COMPARE(orn(x13, x14, Operand(0x8181818181818181L)), |
| 661 | "orr x13, x14, #0x7e7e7e7e7e7e7e7e"); |
| 662 | COMPARE(eon(w19, w20, Operand(0x80000001)), |
| 663 | "eor w19, w20, #0x7ffffffe"); |
| 664 | COMPARE(eon(x21, x22, Operand(0xc000000000000003L)), |
| 665 | "eor x21, x22, #0x3ffffffffffffffc"); |
| 666 | COMPARE(bics(w27, w28, Operand(0xfffffff7)), "ands w27, w28, #0x8"); |
| 667 | COMPARE(bics(fp, x0, Operand(0xfffffffeffffffffL)), |
| 668 | "ands fp, x0, #0x100000000"); |
| 669 | |
| 670 | // Test stack pointer. |
| 671 | COMPARE(and_(wcsp, wzr, Operand(7)), "and wcsp, wzr, #0x7"); |
| 672 | COMPARE(ands(xzr, xzr, Operand(7)), "tst xzr, #0x7"); |
| 673 | COMPARE(orr(csp, xzr, Operand(15)), "orr csp, xzr, #0xf"); |
| 674 | COMPARE(eor(wcsp, w0, Operand(31)), "eor wcsp, w0, #0x1f"); |
| 675 | |
| 676 | // Test move aliases. |
| 677 | COMPARE(orr(w0, wzr, Operand(0x00000780)), "orr w0, wzr, #0x780"); |
| 678 | COMPARE(orr(w1, wzr, Operand(0x00007800)), "orr w1, wzr, #0x7800"); |
| 679 | COMPARE(orr(w2, wzr, Operand(0x00078000)), "mov w2, #0x78000"); |
| 680 | COMPARE(orr(w3, wzr, Operand(0x00780000)), "orr w3, wzr, #0x780000"); |
| 681 | COMPARE(orr(w4, wzr, Operand(0x07800000)), "orr w4, wzr, #0x7800000"); |
| 682 | COMPARE(orr(x5, xzr, Operand(0xffffffffffffc001UL)), |
| 683 | "orr x5, xzr, #0xffffffffffffc001"); |
| 684 | COMPARE(orr(x6, xzr, Operand(0xfffffffffffc001fUL)), |
| 685 | "mov x6, #0xfffffffffffc001f"); |
| 686 | COMPARE(orr(x7, xzr, Operand(0xffffffffffc001ffUL)), |
| 687 | "mov x7, #0xffffffffffc001ff"); |
| 688 | COMPARE(orr(x8, xzr, Operand(0xfffffffffc001fffUL)), |
| 689 | "mov x8, #0xfffffffffc001fff"); |
| 690 | COMPARE(orr(x9, xzr, Operand(0xffffffffc001ffffUL)), |
| 691 | "orr x9, xzr, #0xffffffffc001ffff"); |
| 692 | |
| 693 | CLEANUP(); |
| 694 | } |
| 695 | |
| 696 | |
| 697 | TEST_(logical_shifted) { |
| 698 | SET_UP(); |
| 699 | |
| 700 | COMPARE(and_(w0, w1, Operand(w2)), "and w0, w1, w2"); |
| 701 | COMPARE(and_(x3, x4, Operand(x5, LSL, 1)), "and x3, x4, x5, lsl #1"); |
| 702 | COMPARE(and_(w6, w7, Operand(w8, LSR, 2)), "and w6, w7, w8, lsr #2"); |
| 703 | COMPARE(and_(x9, x10, Operand(x11, ASR, 3)), "and x9, x10, x11, asr #3"); |
| 704 | COMPARE(and_(w12, w13, Operand(w14, ROR, 4)), "and w12, w13, w14, ror #4"); |
| 705 | |
| 706 | COMPARE(bic(w15, w16, Operand(w17)), "bic w15, w16, w17"); |
| 707 | COMPARE(bic(x18, x19, Operand(x20, LSL, 5)), "bic x18, x19, x20, lsl #5"); |
| 708 | COMPARE(bic(w21, w22, Operand(w23, LSR, 6)), "bic w21, w22, w23, lsr #6"); |
| 709 | COMPARE(bic(x24, x25, Operand(x26, ASR, 7)), "bic x24, x25, x26, asr #7"); |
| 710 | COMPARE(bic(w27, w28, Operand(w29, ROR, 8)), "bic w27, w28, w29, ror #8"); |
| 711 | |
| 712 | COMPARE(orr(w0, w1, Operand(w2)), "orr w0, w1, w2"); |
| 713 | COMPARE(orr(x3, x4, Operand(x5, LSL, 9)), "orr x3, x4, x5, lsl #9"); |
| 714 | COMPARE(orr(w6, w7, Operand(w8, LSR, 10)), "orr w6, w7, w8, lsr #10"); |
| 715 | COMPARE(orr(x9, x10, Operand(x11, ASR, 11)), "orr x9, x10, x11, asr #11"); |
| 716 | COMPARE(orr(w12, w13, Operand(w14, ROR, 12)), "orr w12, w13, w14, ror #12"); |
| 717 | |
| 718 | COMPARE(orn(w15, w16, Operand(w17)), "orn w15, w16, w17"); |
| 719 | COMPARE(orn(x18, x19, Operand(x20, LSL, 13)), "orn x18, x19, x20, lsl #13"); |
| 720 | COMPARE(orn(w21, w22, Operand(w23, LSR, 14)), "orn w21, w22, w23, lsr #14"); |
| 721 | COMPARE(orn(x24, x25, Operand(x26, ASR, 15)), "orn x24, x25, x26, asr #15"); |
| 722 | COMPARE(orn(w27, w28, Operand(w29, ROR, 16)), "orn w27, w28, w29, ror #16"); |
| 723 | |
| 724 | COMPARE(eor(w0, w1, Operand(w2)), "eor w0, w1, w2"); |
| 725 | COMPARE(eor(x3, x4, Operand(x5, LSL, 17)), "eor x3, x4, x5, lsl #17"); |
| 726 | COMPARE(eor(w6, w7, Operand(w8, LSR, 18)), "eor w6, w7, w8, lsr #18"); |
| 727 | COMPARE(eor(x9, x10, Operand(x11, ASR, 19)), "eor x9, x10, x11, asr #19"); |
| 728 | COMPARE(eor(w12, w13, Operand(w14, ROR, 20)), "eor w12, w13, w14, ror #20"); |
| 729 | |
| 730 | COMPARE(eon(w15, w16, Operand(w17)), "eon w15, w16, w17"); |
| 731 | COMPARE(eon(x18, x19, Operand(x20, LSL, 21)), "eon x18, x19, x20, lsl #21"); |
| 732 | COMPARE(eon(w21, w22, Operand(w23, LSR, 22)), "eon w21, w22, w23, lsr #22"); |
| 733 | COMPARE(eon(x24, x25, Operand(x26, ASR, 23)), "eon x24, x25, x26, asr #23"); |
| 734 | COMPARE(eon(w27, w28, Operand(w29, ROR, 24)), "eon w27, w28, w29, ror #24"); |
| 735 | |
| 736 | COMPARE(ands(w0, w1, Operand(w2)), "ands w0, w1, w2"); |
| 737 | COMPARE(ands(x3, x4, Operand(x5, LSL, 1)), "ands x3, x4, x5, lsl #1"); |
| 738 | COMPARE(ands(w6, w7, Operand(w8, LSR, 2)), "ands w6, w7, w8, lsr #2"); |
| 739 | COMPARE(ands(x9, x10, Operand(x11, ASR, 3)), "ands x9, x10, x11, asr #3"); |
| 740 | COMPARE(ands(w12, w13, Operand(w14, ROR, 4)), "ands w12, w13, w14, ror #4"); |
| 741 | |
| 742 | COMPARE(bics(w15, w16, Operand(w17)), "bics w15, w16, w17"); |
| 743 | COMPARE(bics(x18, x19, Operand(x20, LSL, 5)), "bics x18, x19, x20, lsl #5"); |
| 744 | COMPARE(bics(w21, w22, Operand(w23, LSR, 6)), "bics w21, w22, w23, lsr #6"); |
| 745 | COMPARE(bics(x24, x25, Operand(x26, ASR, 7)), "bics x24, x25, x26, asr #7"); |
| 746 | COMPARE(bics(w27, w28, Operand(w29, ROR, 8)), "bics w27, w28, w29, ror #8"); |
| 747 | |
| 748 | COMPARE(tst(w0, Operand(w1)), "tst w0, w1"); |
| 749 | COMPARE(tst(w2, Operand(w3, ROR, 10)), "tst w2, w3, ror #10"); |
| 750 | COMPARE(tst(x0, Operand(x1)), "tst x0, x1"); |
| 751 | COMPARE(tst(x2, Operand(x3, ROR, 42)), "tst x2, x3, ror #42"); |
| 752 | |
| 753 | COMPARE(orn(w0, wzr, Operand(w1)), "mvn w0, w1"); |
| 754 | COMPARE(orn(w2, wzr, Operand(w3, ASR, 5)), "mvn w2, w3, asr #5"); |
| 755 | COMPARE(orn(x0, xzr, Operand(x1)), "mvn x0, x1"); |
| 756 | COMPARE(orn(x2, xzr, Operand(x3, ASR, 42)), "mvn x2, x3, asr #42"); |
| 757 | |
| 758 | COMPARE(orr(w0, wzr, Operand(w1)), "mov w0, w1"); |
| 759 | COMPARE(orr(x0, xzr, Operand(x1)), "mov x0, x1"); |
| 760 | COMPARE(orr(w16, wzr, Operand(w17, LSL, 1)), "orr w16, wzr, w17, lsl #1"); |
| 761 | COMPARE(orr(x16, xzr, Operand(x17, ASR, 2)), "orr x16, xzr, x17, asr #2"); |
| 762 | |
| 763 | CLEANUP(); |
| 764 | } |
| 765 | |
| 766 | |
| 767 | TEST_(dp_2_source) { |
| 768 | SET_UP(); |
| 769 | |
| 770 | COMPARE(lslv(w0, w1, w2), "lsl w0, w1, w2"); |
| 771 | COMPARE(lslv(x3, x4, x5), "lsl x3, x4, x5"); |
| 772 | COMPARE(lsrv(w6, w7, w8), "lsr w6, w7, w8"); |
| 773 | COMPARE(lsrv(x9, x10, x11), "lsr x9, x10, x11"); |
| 774 | COMPARE(asrv(w12, w13, w14), "asr w12, w13, w14"); |
| 775 | COMPARE(asrv(x15, x16, x17), "asr x15, x16, x17"); |
| 776 | COMPARE(rorv(w18, w19, w20), "ror w18, w19, w20"); |
| 777 | COMPARE(rorv(x21, x22, x23), "ror x21, x22, x23"); |
| 778 | |
| 779 | CLEANUP(); |
| 780 | } |
| 781 | |
| 782 | |
| 783 | TEST_(adr) { |
| 784 | SET_UP(); |
| 785 | |
| 786 | COMPARE_PREFIX(adr(x0, 0), "adr x0, #+0x0"); |
| 787 | COMPARE_PREFIX(adr(x1, 1), "adr x1, #+0x1"); |
| 788 | COMPARE_PREFIX(adr(x2, -1), "adr x2, #-0x1"); |
| 789 | COMPARE_PREFIX(adr(x3, 4), "adr x3, #+0x4"); |
| 790 | COMPARE_PREFIX(adr(x4, -4), "adr x4, #-0x4"); |
| 791 | COMPARE_PREFIX(adr(x5, 0x000fffff), "adr x5, #+0xfffff"); |
| 792 | COMPARE_PREFIX(adr(x6, -0x00100000), "adr x6, #-0x100000"); |
| 793 | COMPARE_PREFIX(adr(xzr, 0), "adr xzr, #+0x0"); |
| 794 | |
| 795 | CLEANUP(); |
| 796 | } |
| 797 | |
| 798 | |
| 799 | TEST_(branch) { |
| 800 | SET_UP(); |
| 801 | |
| 802 | #define INST_OFF(x) ((x) >> kInstructionSizeLog2) |
| 803 | COMPARE_PREFIX(b(INST_OFF(0x4)), "b #+0x4"); |
| 804 | COMPARE_PREFIX(b(INST_OFF(-0x4)), "b #-0x4"); |
| 805 | COMPARE_PREFIX(b(INST_OFF(0x7fffffc)), "b #+0x7fffffc"); |
| 806 | COMPARE_PREFIX(b(INST_OFF(-0x8000000)), "b #-0x8000000"); |
| 807 | COMPARE_PREFIX(b(INST_OFF(0xffffc), eq), "b.eq #+0xffffc"); |
| 808 | COMPARE_PREFIX(b(INST_OFF(-0x100000), mi), "b.mi #-0x100000"); |
| 809 | COMPARE_PREFIX(bl(INST_OFF(0x4)), "bl #+0x4"); |
| 810 | COMPARE_PREFIX(bl(INST_OFF(-0x4)), "bl #-0x4"); |
| 811 | COMPARE_PREFIX(bl(INST_OFF(0xffffc)), "bl #+0xffffc"); |
| 812 | COMPARE_PREFIX(bl(INST_OFF(-0x100000)), "bl #-0x100000"); |
| 813 | COMPARE_PREFIX(cbz(w0, INST_OFF(0xffffc)), "cbz w0, #+0xffffc"); |
| 814 | COMPARE_PREFIX(cbz(x1, INST_OFF(-0x100000)), "cbz x1, #-0x100000"); |
| 815 | COMPARE_PREFIX(cbnz(w2, INST_OFF(0xffffc)), "cbnz w2, #+0xffffc"); |
| 816 | COMPARE_PREFIX(cbnz(x3, INST_OFF(-0x100000)), "cbnz x3, #-0x100000"); |
| 817 | COMPARE_PREFIX(tbz(w4, 0, INST_OFF(0x7ffc)), "tbz w4, #0, #+0x7ffc"); |
| 818 | COMPARE_PREFIX(tbz(x5, 63, INST_OFF(-0x8000)), "tbz x5, #63, #-0x8000"); |
| 819 | COMPARE_PREFIX(tbz(w6, 31, INST_OFF(0)), "tbz w6, #31, #+0x0"); |
| 820 | COMPARE_PREFIX(tbz(x7, 31, INST_OFF(0x4)), "tbz w7, #31, #+0x4"); |
| 821 | COMPARE_PREFIX(tbz(x8, 32, INST_OFF(0x8)), "tbz x8, #32, #+0x8"); |
| 822 | COMPARE_PREFIX(tbnz(w8, 0, INST_OFF(0x7ffc)), "tbnz w8, #0, #+0x7ffc"); |
| 823 | COMPARE_PREFIX(tbnz(x9, 63, INST_OFF(-0x8000)), "tbnz x9, #63, #-0x8000"); |
| 824 | COMPARE_PREFIX(tbnz(w10, 31, INST_OFF(0)), "tbnz w10, #31, #+0x0"); |
| 825 | COMPARE_PREFIX(tbnz(x11, 31, INST_OFF(0x4)), "tbnz w11, #31, #+0x4"); |
| 826 | COMPARE_PREFIX(tbnz(x12, 32, INST_OFF(0x8)), "tbnz x12, #32, #+0x8"); |
| 827 | COMPARE(br(x0), "br x0"); |
| 828 | COMPARE(blr(x1), "blr x1"); |
| 829 | COMPARE(ret(x2), "ret x2"); |
| 830 | COMPARE(ret(lr), "ret") |
| 831 | |
| 832 | CLEANUP(); |
| 833 | } |
| 834 | |
| 835 | |
| 836 | TEST_(load_store) { |
| 837 | SET_UP(); |
| 838 | |
| 839 | COMPARE(ldr(w0, MemOperand(x1)), "ldr w0, [x1]"); |
| 840 | COMPARE(ldr(w2, MemOperand(x3, 4)), "ldr w2, [x3, #4]"); |
| 841 | COMPARE(ldr(w4, MemOperand(x5, 16380)), "ldr w4, [x5, #16380]"); |
| 842 | COMPARE(ldr(x6, MemOperand(x7)), "ldr x6, [x7]"); |
| 843 | COMPARE(ldr(x8, MemOperand(x9, 8)), "ldr x8, [x9, #8]"); |
| 844 | COMPARE(ldr(x10, MemOperand(x11, 32760)), "ldr x10, [x11, #32760]"); |
| 845 | COMPARE(str(w12, MemOperand(x13)), "str w12, [x13]"); |
| 846 | COMPARE(str(w14, MemOperand(x15, 4)), "str w14, [x15, #4]"); |
| 847 | COMPARE(str(w16, MemOperand(x17, 16380)), "str w16, [x17, #16380]"); |
| 848 | COMPARE(str(x18, MemOperand(x19)), "str x18, [x19]"); |
| 849 | COMPARE(str(x20, MemOperand(x21, 8)), "str x20, [x21, #8]"); |
| 850 | COMPARE(str(x22, MemOperand(x23, 32760)), "str x22, [x23, #32760]"); |
| 851 | |
| 852 | COMPARE(ldr(w0, MemOperand(x1, 4, PreIndex)), "ldr w0, [x1, #4]!"); |
| 853 | COMPARE(ldr(w2, MemOperand(x3, 255, PreIndex)), "ldr w2, [x3, #255]!"); |
| 854 | COMPARE(ldr(w4, MemOperand(x5, -256, PreIndex)), "ldr w4, [x5, #-256]!"); |
| 855 | COMPARE(ldr(x6, MemOperand(x7, 8, PreIndex)), "ldr x6, [x7, #8]!"); |
| 856 | COMPARE(ldr(x8, MemOperand(x9, 255, PreIndex)), "ldr x8, [x9, #255]!"); |
| 857 | COMPARE(ldr(x10, MemOperand(x11, -256, PreIndex)), "ldr x10, [x11, #-256]!"); |
| 858 | COMPARE(str(w12, MemOperand(x13, 4, PreIndex)), "str w12, [x13, #4]!"); |
| 859 | COMPARE(str(w14, MemOperand(x15, 255, PreIndex)), "str w14, [x15, #255]!"); |
| 860 | COMPARE(str(w16, MemOperand(x17, -256, PreIndex)), "str w16, [x17, #-256]!"); |
| 861 | COMPARE(str(x18, MemOperand(x19, 8, PreIndex)), "str x18, [x19, #8]!"); |
| 862 | COMPARE(str(x20, MemOperand(x21, 255, PreIndex)), "str x20, [x21, #255]!"); |
| 863 | COMPARE(str(x22, MemOperand(x23, -256, PreIndex)), "str x22, [x23, #-256]!"); |
| 864 | |
| 865 | COMPARE(ldr(w0, MemOperand(x1, 4, PostIndex)), "ldr w0, [x1], #4"); |
| 866 | COMPARE(ldr(w2, MemOperand(x3, 255, PostIndex)), "ldr w2, [x3], #255"); |
| 867 | COMPARE(ldr(w4, MemOperand(x5, -256, PostIndex)), "ldr w4, [x5], #-256"); |
| 868 | COMPARE(ldr(x6, MemOperand(x7, 8, PostIndex)), "ldr x6, [x7], #8"); |
| 869 | COMPARE(ldr(x8, MemOperand(x9, 255, PostIndex)), "ldr x8, [x9], #255"); |
| 870 | COMPARE(ldr(x10, MemOperand(x11, -256, PostIndex)), "ldr x10, [x11], #-256"); |
| 871 | COMPARE(str(w12, MemOperand(x13, 4, PostIndex)), "str w12, [x13], #4"); |
| 872 | COMPARE(str(w14, MemOperand(x15, 255, PostIndex)), "str w14, [x15], #255"); |
| 873 | COMPARE(str(w16, MemOperand(x17, -256, PostIndex)), "str w16, [x17], #-256"); |
| 874 | COMPARE(str(x18, MemOperand(x19, 8, PostIndex)), "str x18, [x19], #8"); |
| 875 | COMPARE(str(x20, MemOperand(x21, 255, PostIndex)), "str x20, [x21], #255"); |
| 876 | COMPARE(str(x22, MemOperand(x23, -256, PostIndex)), "str x22, [x23], #-256"); |
| 877 | |
| 878 | // TODO(all): Fix this for jssp. |
| 879 | COMPARE(ldr(w24, MemOperand(jssp)), "ldr w24, [jssp]"); |
| 880 | COMPARE(ldr(x25, MemOperand(jssp, 8)), "ldr x25, [jssp, #8]"); |
| 881 | COMPARE(str(w26, MemOperand(jssp, 4, PreIndex)), "str w26, [jssp, #4]!"); |
| 882 | COMPARE(str(cp, MemOperand(jssp, -8, PostIndex)), "str cp, [jssp], #-8"); |
| 883 | |
| 884 | COMPARE(ldrsw(x0, MemOperand(x1)), "ldrsw x0, [x1]"); |
| 885 | COMPARE(ldrsw(x2, MemOperand(x3, 8)), "ldrsw x2, [x3, #8]"); |
| 886 | COMPARE(ldrsw(x4, MemOperand(x5, 42, PreIndex)), "ldrsw x4, [x5, #42]!"); |
| 887 | COMPARE(ldrsw(x6, MemOperand(x7, -11, PostIndex)), "ldrsw x6, [x7], #-11"); |
| 888 | |
| 889 | CLEANUP(); |
| 890 | } |
| 891 | |
| 892 | |
| 893 | TEST_(load_store_regoffset) { |
| 894 | SET_UP(); |
| 895 | |
| 896 | COMPARE(ldr(w0, MemOperand(x1, w2, UXTW)), "ldr w0, [x1, w2, uxtw]"); |
| 897 | COMPARE(ldr(w3, MemOperand(x4, w5, UXTW, 2)), "ldr w3, [x4, w5, uxtw #2]"); |
| 898 | COMPARE(ldr(w6, MemOperand(x7, x8)), "ldr w6, [x7, x8]"); |
| 899 | COMPARE(ldr(w9, MemOperand(x10, x11, LSL, 2)), "ldr w9, [x10, x11, lsl #2]"); |
| 900 | COMPARE(ldr(w12, MemOperand(x13, w14, SXTW)), "ldr w12, [x13, w14, sxtw]"); |
| 901 | COMPARE(ldr(w15, MemOperand(x16, w17, SXTW, 2)), |
| 902 | "ldr w15, [x16, w17, sxtw #2]"); |
| 903 | COMPARE(ldr(w18, MemOperand(x19, x20, SXTX)), "ldr w18, [x19, x20, sxtx]"); |
| 904 | COMPARE(ldr(w21, MemOperand(x22, x23, SXTX, 2)), |
| 905 | "ldr w21, [x22, x23, sxtx #2]"); |
| 906 | COMPARE(ldr(x0, MemOperand(x1, w2, UXTW)), "ldr x0, [x1, w2, uxtw]"); |
| 907 | COMPARE(ldr(x3, MemOperand(x4, w5, UXTW, 3)), "ldr x3, [x4, w5, uxtw #3]"); |
| 908 | COMPARE(ldr(x6, MemOperand(x7, x8)), "ldr x6, [x7, x8]"); |
| 909 | COMPARE(ldr(x9, MemOperand(x10, x11, LSL, 3)), "ldr x9, [x10, x11, lsl #3]"); |
| 910 | COMPARE(ldr(x12, MemOperand(x13, w14, SXTW)), "ldr x12, [x13, w14, sxtw]"); |
| 911 | COMPARE(ldr(x15, MemOperand(x16, w17, SXTW, 3)), |
| 912 | "ldr x15, [x16, w17, sxtw #3]"); |
| 913 | COMPARE(ldr(x18, MemOperand(x19, x20, SXTX)), "ldr x18, [x19, x20, sxtx]"); |
| 914 | COMPARE(ldr(x21, MemOperand(x22, x23, SXTX, 3)), |
| 915 | "ldr x21, [x22, x23, sxtx #3]"); |
| 916 | |
| 917 | COMPARE(str(w0, MemOperand(x1, w2, UXTW)), "str w0, [x1, w2, uxtw]"); |
| 918 | COMPARE(str(w3, MemOperand(x4, w5, UXTW, 2)), "str w3, [x4, w5, uxtw #2]"); |
| 919 | COMPARE(str(w6, MemOperand(x7, x8)), "str w6, [x7, x8]"); |
| 920 | COMPARE(str(w9, MemOperand(x10, x11, LSL, 2)), "str w9, [x10, x11, lsl #2]"); |
| 921 | COMPARE(str(w12, MemOperand(x13, w14, SXTW)), "str w12, [x13, w14, sxtw]"); |
| 922 | COMPARE(str(w15, MemOperand(x16, w17, SXTW, 2)), |
| 923 | "str w15, [x16, w17, sxtw #2]"); |
| 924 | COMPARE(str(w18, MemOperand(x19, x20, SXTX)), "str w18, [x19, x20, sxtx]"); |
| 925 | COMPARE(str(w21, MemOperand(x22, x23, SXTX, 2)), |
| 926 | "str w21, [x22, x23, sxtx #2]"); |
| 927 | COMPARE(str(x0, MemOperand(x1, w2, UXTW)), "str x0, [x1, w2, uxtw]"); |
| 928 | COMPARE(str(x3, MemOperand(x4, w5, UXTW, 3)), "str x3, [x4, w5, uxtw #3]"); |
| 929 | COMPARE(str(x6, MemOperand(x7, x8)), "str x6, [x7, x8]"); |
| 930 | COMPARE(str(x9, MemOperand(x10, x11, LSL, 3)), "str x9, [x10, x11, lsl #3]"); |
| 931 | COMPARE(str(x12, MemOperand(x13, w14, SXTW)), "str x12, [x13, w14, sxtw]"); |
| 932 | COMPARE(str(x15, MemOperand(x16, w17, SXTW, 3)), |
| 933 | "str x15, [x16, w17, sxtw #3]"); |
| 934 | COMPARE(str(x18, MemOperand(x19, x20, SXTX)), "str x18, [x19, x20, sxtx]"); |
| 935 | COMPARE(str(x21, MemOperand(x22, x23, SXTX, 3)), |
| 936 | "str x21, [x22, x23, sxtx #3]"); |
| 937 | |
| 938 | COMPARE(ldrb(w0, MemOperand(x1, w2, UXTW)), "ldrb w0, [x1, w2, uxtw]"); |
| 939 | COMPARE(ldrb(w6, MemOperand(x7, x8)), "ldrb w6, [x7, x8]"); |
| 940 | COMPARE(ldrb(w12, MemOperand(x13, w14, SXTW)), "ldrb w12, [x13, w14, sxtw]"); |
| 941 | COMPARE(ldrb(w18, MemOperand(x19, x20, SXTX)), "ldrb w18, [x19, x20, sxtx]"); |
| 942 | COMPARE(strb(w0, MemOperand(x1, w2, UXTW)), "strb w0, [x1, w2, uxtw]"); |
| 943 | COMPARE(strb(w6, MemOperand(x7, x8)), "strb w6, [x7, x8]"); |
| 944 | COMPARE(strb(w12, MemOperand(x13, w14, SXTW)), "strb w12, [x13, w14, sxtw]"); |
| 945 | COMPARE(strb(w18, MemOperand(x19, x20, SXTX)), "strb w18, [x19, x20, sxtx]"); |
| 946 | |
| 947 | COMPARE(ldrh(w0, MemOperand(x1, w2, UXTW)), "ldrh w0, [x1, w2, uxtw]"); |
| 948 | COMPARE(ldrh(w3, MemOperand(x4, w5, UXTW, 1)), "ldrh w3, [x4, w5, uxtw #1]"); |
| 949 | COMPARE(ldrh(w6, MemOperand(x7, x8)), "ldrh w6, [x7, x8]"); |
| 950 | COMPARE(ldrh(w9, MemOperand(x10, x11, LSL, 1)), |
| 951 | "ldrh w9, [x10, x11, lsl #1]"); |
| 952 | COMPARE(ldrh(w12, MemOperand(x13, w14, SXTW)), "ldrh w12, [x13, w14, sxtw]"); |
| 953 | COMPARE(ldrh(w15, MemOperand(x16, w17, SXTW, 1)), |
| 954 | "ldrh w15, [x16, w17, sxtw #1]"); |
| 955 | COMPARE(ldrh(w18, MemOperand(x19, x20, SXTX)), "ldrh w18, [x19, x20, sxtx]"); |
| 956 | COMPARE(ldrh(w21, MemOperand(x22, x23, SXTX, 1)), |
| 957 | "ldrh w21, [x22, x23, sxtx #1]"); |
| 958 | COMPARE(strh(w0, MemOperand(x1, w2, UXTW)), "strh w0, [x1, w2, uxtw]"); |
| 959 | COMPARE(strh(w3, MemOperand(x4, w5, UXTW, 1)), "strh w3, [x4, w5, uxtw #1]"); |
| 960 | COMPARE(strh(w6, MemOperand(x7, x8)), "strh w6, [x7, x8]"); |
| 961 | COMPARE(strh(w9, MemOperand(x10, x11, LSL, 1)), |
| 962 | "strh w9, [x10, x11, lsl #1]"); |
| 963 | COMPARE(strh(w12, MemOperand(x13, w14, SXTW)), "strh w12, [x13, w14, sxtw]"); |
| 964 | COMPARE(strh(w15, MemOperand(x16, w17, SXTW, 1)), |
| 965 | "strh w15, [x16, w17, sxtw #1]"); |
| 966 | COMPARE(strh(w18, MemOperand(x19, x20, SXTX)), "strh w18, [x19, x20, sxtx]"); |
| 967 | COMPARE(strh(w21, MemOperand(x22, x23, SXTX, 1)), |
| 968 | "strh w21, [x22, x23, sxtx #1]"); |
| 969 | |
| 970 | // TODO(all): Fix this for jssp. |
| 971 | COMPARE(ldr(x0, MemOperand(jssp, wzr, SXTW)), "ldr x0, [jssp, wzr, sxtw]"); |
| 972 | COMPARE(str(x1, MemOperand(jssp, xzr)), "str x1, [jssp, xzr]"); |
| 973 | |
| 974 | CLEANUP(); |
| 975 | } |
| 976 | |
| 977 | |
| 978 | TEST_(load_store_byte) { |
| 979 | SET_UP(); |
| 980 | |
| 981 | COMPARE(ldrb(w0, MemOperand(x1)), "ldrb w0, [x1]"); |
| 982 | COMPARE(ldrb(x2, MemOperand(x3)), "ldrb w2, [x3]"); |
| 983 | COMPARE(ldrb(w4, MemOperand(x5, 4095)), "ldrb w4, [x5, #4095]"); |
| 984 | COMPARE(ldrb(w6, MemOperand(x7, 255, PreIndex)), "ldrb w6, [x7, #255]!"); |
| 985 | COMPARE(ldrb(w8, MemOperand(x9, -256, PreIndex)), "ldrb w8, [x9, #-256]!"); |
| 986 | COMPARE(ldrb(w10, MemOperand(x11, 255, PostIndex)), "ldrb w10, [x11], #255"); |
| 987 | COMPARE(ldrb(w12, MemOperand(x13, -256, PostIndex)), |
| 988 | "ldrb w12, [x13], #-256"); |
| 989 | COMPARE(strb(w14, MemOperand(x15)), "strb w14, [x15]"); |
| 990 | COMPARE(strb(x16, MemOperand(x17)), "strb w16, [x17]"); |
| 991 | COMPARE(strb(w18, MemOperand(x19, 4095)), "strb w18, [x19, #4095]"); |
| 992 | COMPARE(strb(w20, MemOperand(x21, 255, PreIndex)), "strb w20, [x21, #255]!"); |
| 993 | COMPARE(strb(w22, MemOperand(x23, -256, PreIndex)), |
| 994 | "strb w22, [x23, #-256]!"); |
| 995 | COMPARE(strb(w24, MemOperand(x25, 255, PostIndex)), "strb w24, [x25], #255"); |
| 996 | COMPARE(strb(w26, MemOperand(cp, -256, PostIndex)), |
| 997 | "strb w26, [cp], #-256"); |
| 998 | // TODO(all): Fix this for jssp. |
| 999 | COMPARE(ldrb(w28, MemOperand(jssp, 3, PostIndex)), "ldrb w28, [jssp], #3"); |
| 1000 | COMPARE(strb(fp, MemOperand(jssp, -42, PreIndex)), "strb w29, [jssp, #-42]!"); |
| 1001 | COMPARE(ldrsb(w0, MemOperand(x1)), "ldrsb w0, [x1]"); |
| 1002 | COMPARE(ldrsb(x2, MemOperand(x3, 8)), "ldrsb x2, [x3, #8]"); |
| 1003 | COMPARE(ldrsb(w4, MemOperand(x5, 42, PreIndex)), "ldrsb w4, [x5, #42]!"); |
| 1004 | COMPARE(ldrsb(x6, MemOperand(x7, -11, PostIndex)), "ldrsb x6, [x7], #-11"); |
| 1005 | |
| 1006 | CLEANUP(); |
| 1007 | } |
| 1008 | |
| 1009 | |
| 1010 | TEST_(load_store_half) { |
| 1011 | SET_UP(); |
| 1012 | |
| 1013 | COMPARE(ldrh(w0, MemOperand(x1)), "ldrh w0, [x1]"); |
| 1014 | COMPARE(ldrh(x2, MemOperand(x3)), "ldrh w2, [x3]"); |
| 1015 | COMPARE(ldrh(w4, MemOperand(x5, 8190)), "ldrh w4, [x5, #8190]"); |
| 1016 | COMPARE(ldrh(w6, MemOperand(x7, 255, PreIndex)), "ldrh w6, [x7, #255]!"); |
| 1017 | COMPARE(ldrh(w8, MemOperand(x9, -256, PreIndex)), "ldrh w8, [x9, #-256]!"); |
| 1018 | COMPARE(ldrh(w10, MemOperand(x11, 255, PostIndex)), "ldrh w10, [x11], #255"); |
| 1019 | COMPARE(ldrh(w12, MemOperand(x13, -256, PostIndex)), |
| 1020 | "ldrh w12, [x13], #-256"); |
| 1021 | COMPARE(strh(w14, MemOperand(x15)), "strh w14, [x15]"); |
| 1022 | COMPARE(strh(x16, MemOperand(x17)), "strh w16, [x17]"); |
| 1023 | COMPARE(strh(w18, MemOperand(x19, 8190)), "strh w18, [x19, #8190]"); |
| 1024 | COMPARE(strh(w20, MemOperand(x21, 255, PreIndex)), "strh w20, [x21, #255]!"); |
| 1025 | COMPARE(strh(w22, MemOperand(x23, -256, PreIndex)), |
| 1026 | "strh w22, [x23, #-256]!"); |
| 1027 | COMPARE(strh(w24, MemOperand(x25, 255, PostIndex)), "strh w24, [x25], #255"); |
| 1028 | COMPARE(strh(w26, MemOperand(cp, -256, PostIndex)), |
| 1029 | "strh w26, [cp], #-256"); |
| 1030 | // TODO(all): Fix this for jssp. |
| 1031 | COMPARE(ldrh(w28, MemOperand(jssp, 3, PostIndex)), "ldrh w28, [jssp], #3"); |
| 1032 | COMPARE(strh(fp, MemOperand(jssp, -42, PreIndex)), "strh w29, [jssp, #-42]!"); |
| 1033 | COMPARE(ldrh(w30, MemOperand(x0, 255)), "ldurh w30, [x0, #255]"); |
| 1034 | COMPARE(ldrh(x1, MemOperand(x2, -256)), "ldurh w1, [x2, #-256]"); |
| 1035 | COMPARE(strh(w3, MemOperand(x4, 255)), "sturh w3, [x4, #255]"); |
| 1036 | COMPARE(strh(x5, MemOperand(x6, -256)), "sturh w5, [x6, #-256]"); |
| 1037 | COMPARE(ldrsh(w0, MemOperand(x1)), "ldrsh w0, [x1]"); |
| 1038 | COMPARE(ldrsh(w2, MemOperand(x3, 8)), "ldrsh w2, [x3, #8]"); |
| 1039 | COMPARE(ldrsh(w4, MemOperand(x5, 42, PreIndex)), "ldrsh w4, [x5, #42]!"); |
| 1040 | COMPARE(ldrsh(x6, MemOperand(x7, -11, PostIndex)), "ldrsh x6, [x7], #-11"); |
| 1041 | |
| 1042 | CLEANUP(); |
| 1043 | } |
| 1044 | |
| 1045 | |
| 1046 | TEST_(load_store_fp) { |
| 1047 | SET_UP(); |
| 1048 | |
| 1049 | COMPARE(ldr(s0, MemOperand(x1)), "ldr s0, [x1]"); |
| 1050 | COMPARE(ldr(s2, MemOperand(x3, 4)), "ldr s2, [x3, #4]"); |
| 1051 | COMPARE(ldr(s4, MemOperand(x5, 16380)), "ldr s4, [x5, #16380]"); |
| 1052 | COMPARE(ldr(d6, MemOperand(x7)), "ldr d6, [x7]"); |
| 1053 | COMPARE(ldr(d8, MemOperand(x9, 8)), "ldr d8, [x9, #8]"); |
| 1054 | COMPARE(ldr(d10, MemOperand(x11, 32760)), "ldr d10, [x11, #32760]"); |
| 1055 | COMPARE(str(s12, MemOperand(x13)), "str s12, [x13]"); |
| 1056 | COMPARE(str(s14, MemOperand(x15, 4)), "str s14, [x15, #4]"); |
| 1057 | COMPARE(str(s16, MemOperand(x17, 16380)), "str s16, [x17, #16380]"); |
| 1058 | COMPARE(str(d18, MemOperand(x19)), "str d18, [x19]"); |
| 1059 | COMPARE(str(d20, MemOperand(x21, 8)), "str d20, [x21, #8]"); |
| 1060 | COMPARE(str(d22, MemOperand(x23, 32760)), "str d22, [x23, #32760]"); |
| 1061 | |
| 1062 | COMPARE(ldr(s0, MemOperand(x1, 4, PreIndex)), "ldr s0, [x1, #4]!"); |
| 1063 | COMPARE(ldr(s2, MemOperand(x3, 255, PreIndex)), "ldr s2, [x3, #255]!"); |
| 1064 | COMPARE(ldr(s4, MemOperand(x5, -256, PreIndex)), "ldr s4, [x5, #-256]!"); |
| 1065 | COMPARE(ldr(d6, MemOperand(x7, 8, PreIndex)), "ldr d6, [x7, #8]!"); |
| 1066 | COMPARE(ldr(d8, MemOperand(x9, 255, PreIndex)), "ldr d8, [x9, #255]!"); |
| 1067 | COMPARE(ldr(d10, MemOperand(x11, -256, PreIndex)), "ldr d10, [x11, #-256]!"); |
| 1068 | COMPARE(str(s12, MemOperand(x13, 4, PreIndex)), "str s12, [x13, #4]!"); |
| 1069 | COMPARE(str(s14, MemOperand(x15, 255, PreIndex)), "str s14, [x15, #255]!"); |
| 1070 | COMPARE(str(s16, MemOperand(x17, -256, PreIndex)), "str s16, [x17, #-256]!"); |
| 1071 | COMPARE(str(d18, MemOperand(x19, 8, PreIndex)), "str d18, [x19, #8]!"); |
| 1072 | COMPARE(str(d20, MemOperand(x21, 255, PreIndex)), "str d20, [x21, #255]!"); |
| 1073 | COMPARE(str(d22, MemOperand(x23, -256, PreIndex)), "str d22, [x23, #-256]!"); |
| 1074 | |
| 1075 | COMPARE(ldr(s0, MemOperand(x1, 4, PostIndex)), "ldr s0, [x1], #4"); |
| 1076 | COMPARE(ldr(s2, MemOperand(x3, 255, PostIndex)), "ldr s2, [x3], #255"); |
| 1077 | COMPARE(ldr(s4, MemOperand(x5, -256, PostIndex)), "ldr s4, [x5], #-256"); |
| 1078 | COMPARE(ldr(d6, MemOperand(x7, 8, PostIndex)), "ldr d6, [x7], #8"); |
| 1079 | COMPARE(ldr(d8, MemOperand(x9, 255, PostIndex)), "ldr d8, [x9], #255"); |
| 1080 | COMPARE(ldr(d10, MemOperand(x11, -256, PostIndex)), "ldr d10, [x11], #-256"); |
| 1081 | COMPARE(str(s12, MemOperand(x13, 4, PostIndex)), "str s12, [x13], #4"); |
| 1082 | COMPARE(str(s14, MemOperand(x15, 255, PostIndex)), "str s14, [x15], #255"); |
| 1083 | COMPARE(str(s16, MemOperand(x17, -256, PostIndex)), "str s16, [x17], #-256"); |
| 1084 | COMPARE(str(d18, MemOperand(x19, 8, PostIndex)), "str d18, [x19], #8"); |
| 1085 | COMPARE(str(d20, MemOperand(x21, 255, PostIndex)), "str d20, [x21], #255"); |
| 1086 | COMPARE(str(d22, MemOperand(x23, -256, PostIndex)), "str d22, [x23], #-256"); |
| 1087 | |
| 1088 | // TODO(all): Fix this for jssp. |
| 1089 | COMPARE(ldr(s24, MemOperand(jssp)), "ldr s24, [jssp]"); |
| 1090 | COMPARE(ldr(d25, MemOperand(jssp, 8)), "ldr d25, [jssp, #8]"); |
| 1091 | COMPARE(str(s26, MemOperand(jssp, 4, PreIndex)), "str s26, [jssp, #4]!"); |
| 1092 | COMPARE(str(d27, MemOperand(jssp, -8, PostIndex)), "str d27, [jssp], #-8"); |
| 1093 | |
| 1094 | CLEANUP(); |
| 1095 | } |
| 1096 | |
| 1097 | |
| 1098 | TEST_(load_store_unscaled) { |
| 1099 | SET_UP(); |
| 1100 | |
| 1101 | COMPARE(ldr(w0, MemOperand(x1, 1)), "ldur w0, [x1, #1]"); |
| 1102 | COMPARE(ldr(w2, MemOperand(x3, -1)), "ldur w2, [x3, #-1]"); |
| 1103 | COMPARE(ldr(w4, MemOperand(x5, 255)), "ldur w4, [x5, #255]"); |
| 1104 | COMPARE(ldr(w6, MemOperand(x7, -256)), "ldur w6, [x7, #-256]"); |
| 1105 | COMPARE(ldr(x8, MemOperand(x9, 1)), "ldur x8, [x9, #1]"); |
| 1106 | COMPARE(ldr(x10, MemOperand(x11, -1)), "ldur x10, [x11, #-1]"); |
| 1107 | COMPARE(ldr(x12, MemOperand(x13, 255)), "ldur x12, [x13, #255]"); |
| 1108 | COMPARE(ldr(x14, MemOperand(x15, -256)), "ldur x14, [x15, #-256]"); |
| 1109 | COMPARE(str(w16, MemOperand(x17, 1)), "stur w16, [x17, #1]"); |
| 1110 | COMPARE(str(w18, MemOperand(x19, -1)), "stur w18, [x19, #-1]"); |
| 1111 | COMPARE(str(w20, MemOperand(x21, 255)), "stur w20, [x21, #255]"); |
| 1112 | COMPARE(str(w22, MemOperand(x23, -256)), "stur w22, [x23, #-256]"); |
| 1113 | COMPARE(str(x24, MemOperand(x25, 1)), "stur x24, [x25, #1]"); |
| 1114 | COMPARE(str(x26, MemOperand(cp, -1)), "stur x26, [cp, #-1]"); |
| 1115 | COMPARE(str(jssp, MemOperand(fp, 255)), "stur jssp, [fp, #255]"); |
| 1116 | COMPARE(str(lr, MemOperand(x0, -256)), "stur lr, [x0, #-256]"); |
| 1117 | COMPARE(ldr(w0, MemOperand(csp, 1)), "ldur w0, [csp, #1]"); |
| 1118 | COMPARE(str(x1, MemOperand(csp, -1)), "stur x1, [csp, #-1]"); |
| 1119 | COMPARE(ldrb(w2, MemOperand(x3, -2)), "ldurb w2, [x3, #-2]"); |
| 1120 | COMPARE(ldrsb(w4, MemOperand(x5, -3)), "ldursb w4, [x5, #-3]"); |
| 1121 | COMPARE(ldrsb(x6, MemOperand(x7, -4)), "ldursb x6, [x7, #-4]"); |
| 1122 | COMPARE(ldrh(w8, MemOperand(x9, -5)), "ldurh w8, [x9, #-5]"); |
| 1123 | COMPARE(ldrsh(w10, MemOperand(x11, -6)), "ldursh w10, [x11, #-6]"); |
| 1124 | COMPARE(ldrsh(x12, MemOperand(x13, -7)), "ldursh x12, [x13, #-7]"); |
| 1125 | COMPARE(ldrsw(x14, MemOperand(x15, -8)), "ldursw x14, [x15, #-8]"); |
| 1126 | |
| 1127 | CLEANUP(); |
| 1128 | } |
| 1129 | |
| 1130 | |
| 1131 | TEST_(load_store_pair) { |
| 1132 | SET_UP(); |
| 1133 | |
| 1134 | COMPARE(ldp(w0, w1, MemOperand(x2)), "ldp w0, w1, [x2]"); |
| 1135 | COMPARE(ldp(x3, x4, MemOperand(x5)), "ldp x3, x4, [x5]"); |
| 1136 | COMPARE(ldp(w6, w7, MemOperand(x8, 4)), "ldp w6, w7, [x8, #4]"); |
| 1137 | COMPARE(ldp(x9, x10, MemOperand(x11, 8)), "ldp x9, x10, [x11, #8]"); |
| 1138 | COMPARE(ldp(w12, w13, MemOperand(x14, 252)), "ldp w12, w13, [x14, #252]"); |
| 1139 | COMPARE(ldp(x15, x16, MemOperand(x17, 504)), "ldp x15, x16, [x17, #504]"); |
| 1140 | COMPARE(ldp(w18, w19, MemOperand(x20, -256)), "ldp w18, w19, [x20, #-256]"); |
| 1141 | COMPARE(ldp(x21, x22, MemOperand(x23, -512)), "ldp x21, x22, [x23, #-512]"); |
| 1142 | COMPARE(ldp(w24, w25, MemOperand(x26, 252, PreIndex)), |
| 1143 | "ldp w24, w25, [x26, #252]!"); |
| 1144 | COMPARE(ldp(cp, jssp, MemOperand(fp, 504, PreIndex)), |
| 1145 | "ldp cp, jssp, [fp, #504]!"); |
| 1146 | COMPARE(ldp(w30, w0, MemOperand(x1, -256, PreIndex)), |
| 1147 | "ldp w30, w0, [x1, #-256]!"); |
| 1148 | COMPARE(ldp(x2, x3, MemOperand(x4, -512, PreIndex)), |
| 1149 | "ldp x2, x3, [x4, #-512]!"); |
| 1150 | COMPARE(ldp(w5, w6, MemOperand(x7, 252, PostIndex)), |
| 1151 | "ldp w5, w6, [x7], #252"); |
| 1152 | COMPARE(ldp(x8, x9, MemOperand(x10, 504, PostIndex)), |
| 1153 | "ldp x8, x9, [x10], #504"); |
| 1154 | COMPARE(ldp(w11, w12, MemOperand(x13, -256, PostIndex)), |
| 1155 | "ldp w11, w12, [x13], #-256"); |
| 1156 | COMPARE(ldp(x14, x15, MemOperand(x16, -512, PostIndex)), |
| 1157 | "ldp x14, x15, [x16], #-512"); |
| 1158 | |
| 1159 | COMPARE(ldp(s17, s18, MemOperand(x19)), "ldp s17, s18, [x19]"); |
| 1160 | COMPARE(ldp(s20, s21, MemOperand(x22, 252)), "ldp s20, s21, [x22, #252]"); |
| 1161 | COMPARE(ldp(s23, s24, MemOperand(x25, -256)), "ldp s23, s24, [x25, #-256]"); |
| 1162 | COMPARE(ldp(s26, s27, MemOperand(jssp, 252, PreIndex)), |
| 1163 | "ldp s26, s27, [jssp, #252]!"); |
| 1164 | COMPARE(ldp(s29, s30, MemOperand(fp, -256, PreIndex)), |
| 1165 | "ldp s29, s30, [fp, #-256]!"); |
| 1166 | COMPARE(ldp(s31, s0, MemOperand(x1, 252, PostIndex)), |
| 1167 | "ldp s31, s0, [x1], #252"); |
| 1168 | COMPARE(ldp(s2, s3, MemOperand(x4, -256, PostIndex)), |
| 1169 | "ldp s2, s3, [x4], #-256"); |
| 1170 | COMPARE(ldp(d17, d18, MemOperand(x19)), "ldp d17, d18, [x19]"); |
| 1171 | COMPARE(ldp(d20, d21, MemOperand(x22, 504)), "ldp d20, d21, [x22, #504]"); |
| 1172 | COMPARE(ldp(d23, d24, MemOperand(x25, -512)), "ldp d23, d24, [x25, #-512]"); |
| 1173 | COMPARE(ldp(d26, d27, MemOperand(jssp, 504, PreIndex)), |
| 1174 | "ldp d26, d27, [jssp, #504]!"); |
| 1175 | COMPARE(ldp(d29, d30, MemOperand(fp, -512, PreIndex)), |
| 1176 | "ldp d29, d30, [fp, #-512]!"); |
| 1177 | COMPARE(ldp(d31, d0, MemOperand(x1, 504, PostIndex)), |
| 1178 | "ldp d31, d0, [x1], #504"); |
| 1179 | COMPARE(ldp(d2, d3, MemOperand(x4, -512, PostIndex)), |
| 1180 | "ldp d2, d3, [x4], #-512"); |
| 1181 | |
| 1182 | COMPARE(stp(w0, w1, MemOperand(x2)), "stp w0, w1, [x2]"); |
| 1183 | COMPARE(stp(x3, x4, MemOperand(x5)), "stp x3, x4, [x5]"); |
| 1184 | COMPARE(stp(w6, w7, MemOperand(x8, 4)), "stp w6, w7, [x8, #4]"); |
| 1185 | COMPARE(stp(x9, x10, MemOperand(x11, 8)), "stp x9, x10, [x11, #8]"); |
| 1186 | COMPARE(stp(w12, w13, MemOperand(x14, 252)), "stp w12, w13, [x14, #252]"); |
| 1187 | COMPARE(stp(x15, x16, MemOperand(x17, 504)), "stp x15, x16, [x17, #504]"); |
| 1188 | COMPARE(stp(w18, w19, MemOperand(x20, -256)), "stp w18, w19, [x20, #-256]"); |
| 1189 | COMPARE(stp(x21, x22, MemOperand(x23, -512)), "stp x21, x22, [x23, #-512]"); |
| 1190 | COMPARE(stp(w24, w25, MemOperand(x26, 252, PreIndex)), |
| 1191 | "stp w24, w25, [x26, #252]!"); |
| 1192 | COMPARE(stp(cp, jssp, MemOperand(fp, 504, PreIndex)), |
| 1193 | "stp cp, jssp, [fp, #504]!"); |
| 1194 | COMPARE(stp(w30, w0, MemOperand(x1, -256, PreIndex)), |
| 1195 | "stp w30, w0, [x1, #-256]!"); |
| 1196 | COMPARE(stp(x2, x3, MemOperand(x4, -512, PreIndex)), |
| 1197 | "stp x2, x3, [x4, #-512]!"); |
| 1198 | COMPARE(stp(w5, w6, MemOperand(x7, 252, PostIndex)), |
| 1199 | "stp w5, w6, [x7], #252"); |
| 1200 | COMPARE(stp(x8, x9, MemOperand(x10, 504, PostIndex)), |
| 1201 | "stp x8, x9, [x10], #504"); |
| 1202 | COMPARE(stp(w11, w12, MemOperand(x13, -256, PostIndex)), |
| 1203 | "stp w11, w12, [x13], #-256"); |
| 1204 | COMPARE(stp(x14, x15, MemOperand(x16, -512, PostIndex)), |
| 1205 | "stp x14, x15, [x16], #-512"); |
| 1206 | |
| 1207 | COMPARE(stp(s17, s18, MemOperand(x19)), "stp s17, s18, [x19]"); |
| 1208 | COMPARE(stp(s20, s21, MemOperand(x22, 252)), "stp s20, s21, [x22, #252]"); |
| 1209 | COMPARE(stp(s23, s24, MemOperand(x25, -256)), "stp s23, s24, [x25, #-256]"); |
| 1210 | COMPARE(stp(s26, s27, MemOperand(jssp, 252, PreIndex)), |
| 1211 | "stp s26, s27, [jssp, #252]!"); |
| 1212 | COMPARE(stp(s29, s30, MemOperand(fp, -256, PreIndex)), |
| 1213 | "stp s29, s30, [fp, #-256]!"); |
| 1214 | COMPARE(stp(s31, s0, MemOperand(x1, 252, PostIndex)), |
| 1215 | "stp s31, s0, [x1], #252"); |
| 1216 | COMPARE(stp(s2, s3, MemOperand(x4, -256, PostIndex)), |
| 1217 | "stp s2, s3, [x4], #-256"); |
| 1218 | COMPARE(stp(d17, d18, MemOperand(x19)), "stp d17, d18, [x19]"); |
| 1219 | COMPARE(stp(d20, d21, MemOperand(x22, 504)), "stp d20, d21, [x22, #504]"); |
| 1220 | COMPARE(stp(d23, d24, MemOperand(x25, -512)), "stp d23, d24, [x25, #-512]"); |
| 1221 | COMPARE(stp(d26, d27, MemOperand(jssp, 504, PreIndex)), |
| 1222 | "stp d26, d27, [jssp, #504]!"); |
| 1223 | COMPARE(stp(d29, d30, MemOperand(fp, -512, PreIndex)), |
| 1224 | "stp d29, d30, [fp, #-512]!"); |
| 1225 | COMPARE(stp(d31, d0, MemOperand(x1, 504, PostIndex)), |
| 1226 | "stp d31, d0, [x1], #504"); |
| 1227 | COMPARE(stp(d2, d3, MemOperand(x4, -512, PostIndex)), |
| 1228 | "stp d2, d3, [x4], #-512"); |
| 1229 | |
| 1230 | // TODO(all): Update / Restore this test. |
| 1231 | COMPARE(ldp(w16, w17, MemOperand(jssp, 4, PostIndex)), |
| 1232 | "ldp w16, w17, [jssp], #4"); |
| 1233 | COMPARE(stp(x18, x19, MemOperand(jssp, -8, PreIndex)), |
| 1234 | "stp x18, x19, [jssp, #-8]!"); |
| 1235 | COMPARE(ldp(s30, s31, MemOperand(jssp, 12, PostIndex)), |
| 1236 | "ldp s30, s31, [jssp], #12"); |
| 1237 | COMPARE(stp(d30, d31, MemOperand(jssp, -16)), |
| 1238 | "stp d30, d31, [jssp, #-16]"); |
| 1239 | |
| 1240 | COMPARE(ldpsw(x0, x1, MemOperand(x2)), "ldpsw x0, x1, [x2]"); |
| 1241 | COMPARE(ldpsw(x3, x4, MemOperand(x5, 16)), "ldpsw x3, x4, [x5, #16]"); |
| 1242 | COMPARE(ldpsw(x6, x7, MemOperand(x8, -32, PreIndex)), |
| 1243 | "ldpsw x6, x7, [x8, #-32]!"); |
| 1244 | COMPARE(ldpsw(x9, x10, MemOperand(x11, 128, PostIndex)), |
| 1245 | "ldpsw x9, x10, [x11], #128"); |
| 1246 | |
| 1247 | CLEANUP(); |
| 1248 | } |
| 1249 | |
| 1250 | |
| 1251 | TEST_(load_store_pair_nontemp) { |
| 1252 | SET_UP(); |
| 1253 | |
| 1254 | COMPARE(ldnp(w0, w1, MemOperand(x2)), "ldnp w0, w1, [x2]"); |
| 1255 | COMPARE(stnp(w3, w4, MemOperand(x5, 252)), "stnp w3, w4, [x5, #252]"); |
| 1256 | COMPARE(ldnp(w6, w7, MemOperand(x8, -256)), "ldnp w6, w7, [x8, #-256]"); |
| 1257 | COMPARE(stnp(x9, x10, MemOperand(x11)), "stnp x9, x10, [x11]"); |
| 1258 | COMPARE(ldnp(x12, x13, MemOperand(x14, 504)), "ldnp x12, x13, [x14, #504]"); |
| 1259 | COMPARE(stnp(x15, x16, MemOperand(x17, -512)), "stnp x15, x16, [x17, #-512]"); |
| 1260 | COMPARE(ldnp(s18, s19, MemOperand(x20)), "ldnp s18, s19, [x20]"); |
| 1261 | COMPARE(stnp(s21, s22, MemOperand(x23, 252)), "stnp s21, s22, [x23, #252]"); |
| 1262 | COMPARE(ldnp(s24, s25, MemOperand(x26, -256)), "ldnp s24, s25, [x26, #-256]"); |
| 1263 | COMPARE(stnp(d27, d28, MemOperand(fp)), "stnp d27, d28, [fp]"); |
| 1264 | COMPARE(ldnp(d30, d31, MemOperand(x0, 504)), "ldnp d30, d31, [x0, #504]"); |
| 1265 | COMPARE(stnp(d1, d2, MemOperand(x3, -512)), "stnp d1, d2, [x3, #-512]"); |
| 1266 | |
| 1267 | CLEANUP(); |
| 1268 | } |
| 1269 | |
| 1270 | #if 0 // TODO(all): enable. |
| 1271 | TEST_(load_literal) { |
| 1272 | SET_UP(); |
| 1273 | |
| 1274 | COMPARE_PREFIX(ldr(x10, 0x1234567890abcdefUL), "ldr x10, pc+8"); |
| 1275 | COMPARE_PREFIX(ldr(w20, 0xfedcba09), "ldr w20, pc+8"); |
| 1276 | COMPARE_PREFIX(ldr(d11, 1.234), "ldr d11, pc+8"); |
| 1277 | COMPARE_PREFIX(ldr(s22, 2.5f), "ldr s22, pc+8"); |
| 1278 | |
| 1279 | CLEANUP(); |
| 1280 | } |
| 1281 | #endif |
| 1282 | |
| 1283 | TEST_(cond_select) { |
| 1284 | SET_UP(); |
| 1285 | |
| 1286 | COMPARE(csel(w0, w1, w2, eq), "csel w0, w1, w2, eq"); |
| 1287 | COMPARE(csel(x3, x4, x5, ne), "csel x3, x4, x5, ne"); |
| 1288 | COMPARE(csinc(w6, w7, w8, hs), "csinc w6, w7, w8, hs"); |
| 1289 | COMPARE(csinc(x9, x10, x11, lo), "csinc x9, x10, x11, lo"); |
| 1290 | COMPARE(csinv(w12, w13, w14, mi), "csinv w12, w13, w14, mi"); |
| 1291 | COMPARE(csinv(x15, x16, x17, pl), "csinv x15, x16, x17, pl"); |
| 1292 | COMPARE(csneg(w18, w19, w20, vs), "csneg w18, w19, w20, vs"); |
| 1293 | COMPARE(csneg(x21, x22, x23, vc), "csneg x21, x22, x23, vc"); |
| 1294 | COMPARE(cset(w24, hi), "cset w24, hi"); |
| 1295 | COMPARE(cset(x25, ls), "cset x25, ls"); |
| 1296 | COMPARE(csetm(w26, ge), "csetm w26, ge"); |
| 1297 | COMPARE(csetm(cp, lt), "csetm cp, lt"); |
| 1298 | COMPARE(cinc(w28, w29, gt), "cinc w28, w29, gt"); |
| 1299 | COMPARE(cinc(lr, x0, le), "cinc lr, x0, le"); |
| 1300 | COMPARE(cinv(w1, w2, eq), "cinv w1, w2, eq"); |
| 1301 | COMPARE(cinv(x3, x4, ne), "cinv x3, x4, ne"); |
| 1302 | COMPARE(cneg(w5, w6, hs), "cneg w5, w6, hs"); |
| 1303 | COMPARE(cneg(x7, x8, lo), "cneg x7, x8, lo"); |
| 1304 | |
| 1305 | COMPARE(csel(x0, x1, x2, al), "csel x0, x1, x2, al"); |
| 1306 | COMPARE(csel(x1, x2, x3, nv), "csel x1, x2, x3, nv"); |
| 1307 | COMPARE(csinc(x2, x3, x4, al), "csinc x2, x3, x4, al"); |
| 1308 | COMPARE(csinc(x3, x4, x5, nv), "csinc x3, x4, x5, nv"); |
| 1309 | COMPARE(csinv(x4, x5, x6, al), "csinv x4, x5, x6, al"); |
| 1310 | COMPARE(csinv(x5, x6, x7, nv), "csinv x5, x6, x7, nv"); |
| 1311 | COMPARE(csneg(x6, x7, x8, al), "csneg x6, x7, x8, al"); |
| 1312 | COMPARE(csneg(x7, x8, x9, nv), "csneg x7, x8, x9, nv"); |
| 1313 | |
| 1314 | CLEANUP(); |
| 1315 | } |
| 1316 | |
| 1317 | |
| 1318 | TEST(cond_select_macro) { |
| 1319 | SET_UP_CLASS(MacroAssembler); |
| 1320 | |
| 1321 | COMPARE(Csel(w0, w1, -1, eq), "csinv w0, w1, wzr, eq"); |
| 1322 | COMPARE(Csel(w2, w3, 0, ne), "csel w2, w3, wzr, ne"); |
| 1323 | COMPARE(Csel(w4, w5, 1, hs), "csinc w4, w5, wzr, hs"); |
| 1324 | COMPARE(Csel(x6, x7, -1, lo), "csinv x6, x7, xzr, lo"); |
| 1325 | COMPARE(Csel(x8, x9, 0, mi), "csel x8, x9, xzr, mi"); |
| 1326 | COMPARE(Csel(x10, x11, 1, pl), "csinc x10, x11, xzr, pl"); |
| 1327 | |
| 1328 | CLEANUP(); |
| 1329 | } |
| 1330 | |
| 1331 | |
| 1332 | TEST_(cond_cmp) { |
| 1333 | SET_UP(); |
| 1334 | |
| 1335 | COMPARE(ccmn(w0, w1, NZCVFlag, eq), "ccmn w0, w1, #NZCV, eq"); |
| 1336 | COMPARE(ccmn(x2, x3, NZCFlag, ne), "ccmn x2, x3, #NZCv, ne"); |
| 1337 | COMPARE(ccmp(w4, w5, NZVFlag, hs), "ccmp w4, w5, #NZcV, hs"); |
| 1338 | COMPARE(ccmp(x6, x7, NZFlag, lo), "ccmp x6, x7, #NZcv, lo"); |
| 1339 | COMPARE(ccmn(w8, 31, NFlag, mi), "ccmn w8, #31, #Nzcv, mi"); |
| 1340 | COMPARE(ccmn(x9, 30, NCFlag, pl), "ccmn x9, #30, #NzCv, pl"); |
| 1341 | COMPARE(ccmp(w10, 29, NVFlag, vs), "ccmp w10, #29, #NzcV, vs"); |
| 1342 | COMPARE(ccmp(x11, 28, NFlag, vc), "ccmp x11, #28, #Nzcv, vc"); |
| 1343 | COMPARE(ccmn(w12, w13, NoFlag, al), "ccmn w12, w13, #nzcv, al"); |
| 1344 | COMPARE(ccmp(x14, 27, ZVFlag, nv), "ccmp x14, #27, #nZcV, nv"); |
| 1345 | |
| 1346 | CLEANUP(); |
| 1347 | } |
| 1348 | |
| 1349 | |
| 1350 | TEST_(cond_cmp_macro) { |
| 1351 | SET_UP_CLASS(MacroAssembler); |
| 1352 | |
| 1353 | COMPARE(Ccmp(w0, -1, VFlag, hi), "ccmn w0, #1, #nzcV, hi"); |
| 1354 | COMPARE(Ccmp(x1, -31, CFlag, ge), "ccmn x1, #31, #nzCv, ge"); |
| 1355 | COMPARE(Ccmn(w2, -1, CVFlag, gt), "ccmp w2, #1, #nzCV, gt"); |
| 1356 | COMPARE(Ccmn(x3, -31, ZCVFlag, ls), "ccmp x3, #31, #nZCV, ls"); |
| 1357 | |
| 1358 | CLEANUP(); |
| 1359 | } |
| 1360 | |
| 1361 | |
| 1362 | TEST_(fmov_imm) { |
| 1363 | SET_UP(); |
| 1364 | |
| 1365 | COMPARE(fmov(s0, 1.0f), "fmov s0, #0x70 (1.0000)"); |
| 1366 | COMPARE(fmov(s31, -13.0f), "fmov s31, #0xaa (-13.0000)"); |
| 1367 | COMPARE(fmov(d1, 1.0), "fmov d1, #0x70 (1.0000)"); |
| 1368 | COMPARE(fmov(d29, -13.0), "fmov d29, #0xaa (-13.0000)"); |
| 1369 | |
| 1370 | CLEANUP(); |
| 1371 | } |
| 1372 | |
| 1373 | |
| 1374 | TEST_(fmov_reg) { |
| 1375 | SET_UP(); |
| 1376 | |
| 1377 | COMPARE(fmov(w3, s13), "fmov w3, s13"); |
| 1378 | COMPARE(fmov(x6, d26), "fmov x6, d26"); |
| 1379 | COMPARE(fmov(s11, w30), "fmov s11, w30"); |
| 1380 | COMPARE(fmov(d31, x2), "fmov d31, x2"); |
| 1381 | COMPARE(fmov(s12, s13), "fmov s12, s13"); |
| 1382 | COMPARE(fmov(d22, d23), "fmov d22, d23"); |
| 1383 | |
| 1384 | CLEANUP(); |
| 1385 | } |
| 1386 | |
| 1387 | |
| 1388 | TEST_(fp_dp1) { |
| 1389 | SET_UP(); |
| 1390 | |
| 1391 | COMPARE(fabs(s0, s1), "fabs s0, s1"); |
| 1392 | COMPARE(fabs(s31, s30), "fabs s31, s30"); |
| 1393 | COMPARE(fabs(d2, d3), "fabs d2, d3"); |
| 1394 | COMPARE(fabs(d31, d30), "fabs d31, d30"); |
| 1395 | COMPARE(fneg(s4, s5), "fneg s4, s5"); |
| 1396 | COMPARE(fneg(s31, s30), "fneg s31, s30"); |
| 1397 | COMPARE(fneg(d6, d7), "fneg d6, d7"); |
| 1398 | COMPARE(fneg(d31, d30), "fneg d31, d30"); |
| 1399 | COMPARE(fsqrt(s8, s9), "fsqrt s8, s9"); |
| 1400 | COMPARE(fsqrt(s31, s30), "fsqrt s31, s30"); |
| 1401 | COMPARE(fsqrt(d10, d11), "fsqrt d10, d11"); |
| 1402 | COMPARE(fsqrt(d31, d30), "fsqrt d31, d30"); |
| 1403 | COMPARE(frinta(s10, s11), "frinta s10, s11"); |
| 1404 | COMPARE(frinta(s31, s30), "frinta s31, s30"); |
| 1405 | COMPARE(frinta(d12, d13), "frinta d12, d13"); |
| 1406 | COMPARE(frinta(d31, d30), "frinta d31, d30"); |
| 1407 | COMPARE(frintn(s10, s11), "frintn s10, s11"); |
| 1408 | COMPARE(frintn(s31, s30), "frintn s31, s30"); |
| 1409 | COMPARE(frintn(d12, d13), "frintn d12, d13"); |
| 1410 | COMPARE(frintn(d31, d30), "frintn d31, d30"); |
| 1411 | COMPARE(frintz(s10, s11), "frintz s10, s11"); |
| 1412 | COMPARE(frintz(s31, s30), "frintz s31, s30"); |
| 1413 | COMPARE(frintz(d12, d13), "frintz d12, d13"); |
| 1414 | COMPARE(frintz(d31, d30), "frintz d31, d30"); |
| 1415 | COMPARE(fcvt(d14, s15), "fcvt d14, s15"); |
| 1416 | COMPARE(fcvt(d31, s31), "fcvt d31, s31"); |
| 1417 | |
| 1418 | CLEANUP(); |
| 1419 | } |
| 1420 | |
| 1421 | |
| 1422 | TEST_(fp_dp2) { |
| 1423 | SET_UP(); |
| 1424 | |
| 1425 | COMPARE(fadd(s0, s1, s2), "fadd s0, s1, s2"); |
| 1426 | COMPARE(fadd(d3, d4, d5), "fadd d3, d4, d5"); |
| 1427 | COMPARE(fsub(s31, s30, s29), "fsub s31, s30, s29"); |
| 1428 | COMPARE(fsub(d31, d30, d29), "fsub d31, d30, d29"); |
| 1429 | COMPARE(fmul(s7, s8, s9), "fmul s7, s8, s9"); |
| 1430 | COMPARE(fmul(d10, d11, d12), "fmul d10, d11, d12"); |
| 1431 | COMPARE(fdiv(s13, s14, s15), "fdiv s13, s14, s15"); |
| 1432 | COMPARE(fdiv(d16, d17, d18), "fdiv d16, d17, d18"); |
| 1433 | COMPARE(fmax(s19, s20, s21), "fmax s19, s20, s21"); |
| 1434 | COMPARE(fmax(d22, d23, d24), "fmax d22, d23, d24"); |
| 1435 | COMPARE(fmin(s25, s26, s27), "fmin s25, s26, s27"); |
| 1436 | COMPARE(fmin(d28, d29, d30), "fmin d28, d29, d30"); |
| 1437 | COMPARE(fmaxnm(s31, s0, s1), "fmaxnm s31, s0, s1"); |
| 1438 | COMPARE(fmaxnm(d2, d3, d4), "fmaxnm d2, d3, d4"); |
| 1439 | COMPARE(fminnm(s5, s6, s7), "fminnm s5, s6, s7"); |
| 1440 | COMPARE(fminnm(d8, d9, d10), "fminnm d8, d9, d10"); |
| 1441 | |
| 1442 | CLEANUP(); |
| 1443 | } |
| 1444 | |
| 1445 | |
| 1446 | TEST(fp_dp3) { |
| 1447 | SET_UP(); |
| 1448 | |
| 1449 | COMPARE(fmadd(s7, s8, s9, s10), "fmadd s7, s8, s9, s10"); |
| 1450 | COMPARE(fmadd(d10, d11, d12, d10), "fmadd d10, d11, d12, d10"); |
| 1451 | COMPARE(fmsub(s7, s8, s9, s10), "fmsub s7, s8, s9, s10"); |
| 1452 | COMPARE(fmsub(d10, d11, d12, d10), "fmsub d10, d11, d12, d10"); |
| 1453 | |
| 1454 | COMPARE(fnmadd(s7, s8, s9, s10), "fnmadd s7, s8, s9, s10"); |
| 1455 | COMPARE(fnmadd(d10, d11, d12, d10), "fnmadd d10, d11, d12, d10"); |
| 1456 | COMPARE(fnmsub(s7, s8, s9, s10), "fnmsub s7, s8, s9, s10"); |
| 1457 | COMPARE(fnmsub(d10, d11, d12, d10), "fnmsub d10, d11, d12, d10"); |
| 1458 | |
| 1459 | CLEANUP(); |
| 1460 | } |
| 1461 | |
| 1462 | |
| 1463 | TEST_(fp_compare) { |
| 1464 | SET_UP(); |
| 1465 | |
| 1466 | COMPARE(fcmp(s0, s1), "fcmp s0, s1"); |
| 1467 | COMPARE(fcmp(s31, s30), "fcmp s31, s30"); |
| 1468 | COMPARE(fcmp(d0, d1), "fcmp d0, d1"); |
| 1469 | COMPARE(fcmp(d31, d30), "fcmp d31, d30"); |
| 1470 | COMPARE(fcmp(s12, 0), "fcmp s12, #0.0"); |
| 1471 | COMPARE(fcmp(d12, 0), "fcmp d12, #0.0"); |
| 1472 | |
| 1473 | CLEANUP(); |
| 1474 | } |
| 1475 | |
| 1476 | |
| 1477 | TEST_(fp_cond_compare) { |
| 1478 | SET_UP(); |
| 1479 | |
| 1480 | COMPARE(fccmp(s0, s1, NoFlag, eq), "fccmp s0, s1, #nzcv, eq"); |
| 1481 | COMPARE(fccmp(s2, s3, ZVFlag, ne), "fccmp s2, s3, #nZcV, ne"); |
| 1482 | COMPARE(fccmp(s30, s16, NCFlag, pl), "fccmp s30, s16, #NzCv, pl"); |
| 1483 | COMPARE(fccmp(s31, s31, NZCVFlag, le), "fccmp s31, s31, #NZCV, le"); |
| 1484 | COMPARE(fccmp(d4, d5, VFlag, gt), "fccmp d4, d5, #nzcV, gt"); |
| 1485 | COMPARE(fccmp(d6, d7, NFlag, vs), "fccmp d6, d7, #Nzcv, vs"); |
| 1486 | COMPARE(fccmp(d30, d0, NZFlag, vc), "fccmp d30, d0, #NZcv, vc"); |
| 1487 | COMPARE(fccmp(d31, d31, ZFlag, hs), "fccmp d31, d31, #nZcv, hs"); |
| 1488 | COMPARE(fccmp(s14, s15, CVFlag, al), "fccmp s14, s15, #nzCV, al"); |
| 1489 | COMPARE(fccmp(d16, d17, CFlag, nv), "fccmp d16, d17, #nzCv, nv"); |
| 1490 | |
| 1491 | CLEANUP(); |
| 1492 | } |
| 1493 | |
| 1494 | |
| 1495 | TEST_(fp_select) { |
| 1496 | SET_UP(); |
| 1497 | |
| 1498 | COMPARE(fcsel(s0, s1, s2, eq), "fcsel s0, s1, s2, eq") |
| 1499 | COMPARE(fcsel(s31, s31, s30, ne), "fcsel s31, s31, s30, ne"); |
| 1500 | COMPARE(fcsel(d0, d1, d2, mi), "fcsel d0, d1, d2, mi"); |
| 1501 | COMPARE(fcsel(d31, d30, d31, pl), "fcsel d31, d30, d31, pl"); |
| 1502 | COMPARE(fcsel(s14, s15, s16, al), "fcsel s14, s15, s16, al"); |
| 1503 | COMPARE(fcsel(d17, d18, d19, nv), "fcsel d17, d18, d19, nv"); |
| 1504 | |
| 1505 | CLEANUP(); |
| 1506 | } |
| 1507 | |
| 1508 | |
| 1509 | TEST_(fcvt_scvtf_ucvtf) { |
| 1510 | SET_UP(); |
| 1511 | |
| 1512 | COMPARE(fcvtas(w0, s1), "fcvtas w0, s1"); |
| 1513 | COMPARE(fcvtas(x2, s3), "fcvtas x2, s3"); |
| 1514 | COMPARE(fcvtas(w4, d5), "fcvtas w4, d5"); |
| 1515 | COMPARE(fcvtas(x6, d7), "fcvtas x6, d7"); |
| 1516 | COMPARE(fcvtau(w8, s9), "fcvtau w8, s9"); |
| 1517 | COMPARE(fcvtau(x10, s11), "fcvtau x10, s11"); |
| 1518 | COMPARE(fcvtau(w12, d13), "fcvtau w12, d13"); |
| 1519 | COMPARE(fcvtau(x14, d15), "fcvtau x14, d15"); |
| 1520 | COMPARE(fcvtns(w0, s1), "fcvtns w0, s1"); |
| 1521 | COMPARE(fcvtns(x2, s3), "fcvtns x2, s3"); |
| 1522 | COMPARE(fcvtns(w4, d5), "fcvtns w4, d5"); |
| 1523 | COMPARE(fcvtns(x6, d7), "fcvtns x6, d7"); |
| 1524 | COMPARE(fcvtnu(w8, s9), "fcvtnu w8, s9"); |
| 1525 | COMPARE(fcvtnu(x10, s11), "fcvtnu x10, s11"); |
| 1526 | COMPARE(fcvtnu(w12, d13), "fcvtnu w12, d13"); |
| 1527 | COMPARE(fcvtnu(x14, d15), "fcvtnu x14, d15"); |
| 1528 | COMPARE(fcvtzu(x16, d17), "fcvtzu x16, d17"); |
| 1529 | COMPARE(fcvtzu(w18, d19), "fcvtzu w18, d19"); |
| 1530 | COMPARE(fcvtzs(x20, d21), "fcvtzs x20, d21"); |
| 1531 | COMPARE(fcvtzs(w22, d23), "fcvtzs w22, d23"); |
| 1532 | COMPARE(fcvtzu(x16, s17), "fcvtzu x16, s17"); |
| 1533 | COMPARE(fcvtzu(w18, s19), "fcvtzu w18, s19"); |
| 1534 | COMPARE(fcvtzs(x20, s21), "fcvtzs x20, s21"); |
| 1535 | COMPARE(fcvtzs(w22, s23), "fcvtzs w22, s23"); |
| 1536 | COMPARE(scvtf(d24, w25), "scvtf d24, w25"); |
| 1537 | COMPARE(scvtf(s24, w25), "scvtf s24, w25"); |
| 1538 | COMPARE(scvtf(d26, x0), "scvtf d26, x0"); |
| 1539 | COMPARE(scvtf(s26, x0), "scvtf s26, x0"); |
| 1540 | COMPARE(ucvtf(d28, w29), "ucvtf d28, w29"); |
| 1541 | COMPARE(ucvtf(s28, w29), "ucvtf s28, w29"); |
| 1542 | COMPARE(ucvtf(d0, x1), "ucvtf d0, x1"); |
| 1543 | COMPARE(ucvtf(s0, x1), "ucvtf s0, x1"); |
| 1544 | COMPARE(ucvtf(d0, x1, 0), "ucvtf d0, x1"); |
| 1545 | COMPARE(ucvtf(s0, x1, 0), "ucvtf s0, x1"); |
| 1546 | COMPARE(scvtf(d1, x2, 1), "scvtf d1, x2, #1"); |
| 1547 | COMPARE(scvtf(s1, x2, 1), "scvtf s1, x2, #1"); |
| 1548 | COMPARE(scvtf(d3, x4, 15), "scvtf d3, x4, #15"); |
| 1549 | COMPARE(scvtf(s3, x4, 15), "scvtf s3, x4, #15"); |
| 1550 | COMPARE(scvtf(d5, x6, 32), "scvtf d5, x6, #32"); |
| 1551 | COMPARE(scvtf(s5, x6, 32), "scvtf s5, x6, #32"); |
| 1552 | COMPARE(ucvtf(d7, x8, 2), "ucvtf d7, x8, #2"); |
| 1553 | COMPARE(ucvtf(s7, x8, 2), "ucvtf s7, x8, #2"); |
| 1554 | COMPARE(ucvtf(d9, x10, 16), "ucvtf d9, x10, #16"); |
| 1555 | COMPARE(ucvtf(s9, x10, 16), "ucvtf s9, x10, #16"); |
| 1556 | COMPARE(ucvtf(d11, x12, 33), "ucvtf d11, x12, #33"); |
| 1557 | COMPARE(ucvtf(s11, x12, 33), "ucvtf s11, x12, #33"); |
| 1558 | COMPARE(fcvtms(w0, s1), "fcvtms w0, s1"); |
| 1559 | COMPARE(fcvtms(x2, s3), "fcvtms x2, s3"); |
| 1560 | COMPARE(fcvtms(w4, d5), "fcvtms w4, d5"); |
| 1561 | COMPARE(fcvtms(x6, d7), "fcvtms x6, d7"); |
| 1562 | COMPARE(fcvtmu(w8, s9), "fcvtmu w8, s9"); |
| 1563 | COMPARE(fcvtmu(x10, s11), "fcvtmu x10, s11"); |
| 1564 | COMPARE(fcvtmu(w12, d13), "fcvtmu w12, d13"); |
| 1565 | COMPARE(fcvtmu(x14, d15), "fcvtmu x14, d15"); |
| 1566 | |
| 1567 | CLEANUP(); |
| 1568 | } |
| 1569 | |
| 1570 | |
| 1571 | TEST_(system_mrs) { |
| 1572 | SET_UP(); |
| 1573 | |
| 1574 | COMPARE(mrs(x0, NZCV), "mrs x0, nzcv"); |
| 1575 | COMPARE(mrs(lr, NZCV), "mrs lr, nzcv"); |
| 1576 | COMPARE(mrs(x15, FPCR), "mrs x15, fpcr"); |
| 1577 | |
| 1578 | CLEANUP(); |
| 1579 | } |
| 1580 | |
| 1581 | |
| 1582 | TEST_(system_msr) { |
| 1583 | SET_UP(); |
| 1584 | |
| 1585 | COMPARE(msr(NZCV, x0), "msr nzcv, x0"); |
| 1586 | COMPARE(msr(NZCV, x30), "msr nzcv, lr"); |
| 1587 | COMPARE(msr(FPCR, x15), "msr fpcr, x15"); |
| 1588 | |
| 1589 | CLEANUP(); |
| 1590 | } |
| 1591 | |
| 1592 | |
| 1593 | TEST_(system_nop) { |
| 1594 | SET_UP(); |
| 1595 | |
| 1596 | COMPARE(nop(), "nop"); |
| 1597 | |
| 1598 | CLEANUP(); |
| 1599 | } |
| 1600 | |
| 1601 | |
| 1602 | TEST_(debug) { |
| 1603 | SET_UP(); |
| 1604 | |
| 1605 | DCHECK(kImmExceptionIsDebug == 0xdeb0); |
| 1606 | |
| 1607 | // All debug codes should produce the same instruction, and the debug code |
| 1608 | // can be any uint32_t. |
| 1609 | COMPARE(debug("message", 0, BREAK), "hlt #0xdeb0"); |
| 1610 | COMPARE(debug("message", 1, BREAK), "hlt #0xdeb0"); |
| 1611 | COMPARE(debug("message", 0xffff, BREAK), "hlt #0xdeb0"); |
| 1612 | COMPARE(debug("message", 0x10000, BREAK), "hlt #0xdeb0"); |
| 1613 | COMPARE(debug("message", 0x7fffffff, BREAK), "hlt #0xdeb0"); |
| 1614 | COMPARE(debug("message", 0x80000000u, BREAK), "hlt #0xdeb0"); |
| 1615 | COMPARE(debug("message", 0xffffffffu, BREAK), "hlt #0xdeb0"); |
| 1616 | |
| 1617 | CLEANUP(); |
| 1618 | } |
| 1619 | |
| 1620 | |
| 1621 | TEST_(hlt) { |
| 1622 | SET_UP(); |
| 1623 | |
| 1624 | COMPARE(hlt(0), "hlt #0x0"); |
| 1625 | COMPARE(hlt(1), "hlt #0x1"); |
| 1626 | COMPARE(hlt(65535), "hlt #0xffff"); |
| 1627 | |
| 1628 | CLEANUP(); |
| 1629 | } |
| 1630 | |
| 1631 | |
| 1632 | TEST_(brk) { |
| 1633 | SET_UP(); |
| 1634 | |
| 1635 | COMPARE(brk(0), "brk #0x0"); |
| 1636 | COMPARE(brk(1), "brk #0x1"); |
| 1637 | COMPARE(brk(65535), "brk #0xffff"); |
| 1638 | |
| 1639 | CLEANUP(); |
| 1640 | } |
| 1641 | |
| 1642 | |
| 1643 | TEST_(add_sub_negative) { |
| 1644 | SET_UP_CLASS(MacroAssembler); |
| 1645 | |
| 1646 | COMPARE(Add(x10, x0, -42), "sub x10, x0, #0x2a (42)"); |
| 1647 | COMPARE(Add(x11, x1, -687), "sub x11, x1, #0x2af (687)"); |
| 1648 | COMPARE(Add(x12, x2, -0x88), "sub x12, x2, #0x88 (136)"); |
| 1649 | |
| 1650 | COMPARE(Sub(x13, x0, -600), "add x13, x0, #0x258 (600)"); |
| 1651 | COMPARE(Sub(x14, x1, -313), "add x14, x1, #0x139 (313)"); |
| 1652 | COMPARE(Sub(x15, x2, -0x555), "add x15, x2, #0x555 (1365)"); |
| 1653 | |
| 1654 | COMPARE(Add(w19, w3, -0x344), "sub w19, w3, #0x344 (836)"); |
| 1655 | COMPARE(Add(w20, w4, -2000), "sub w20, w4, #0x7d0 (2000)"); |
| 1656 | |
| 1657 | COMPARE(Sub(w21, w3, -0xbc), "add w21, w3, #0xbc (188)"); |
| 1658 | COMPARE(Sub(w22, w4, -2000), "add w22, w4, #0x7d0 (2000)"); |
| 1659 | |
| 1660 | COMPARE(Cmp(w0, -1), "cmn w0, #0x1 (1)"); |
| 1661 | COMPARE(Cmp(x1, -1), "cmn x1, #0x1 (1)"); |
| 1662 | COMPARE(Cmp(w2, -4095), "cmn w2, #0xfff (4095)"); |
| 1663 | COMPARE(Cmp(x3, -4095), "cmn x3, #0xfff (4095)"); |
| 1664 | |
| 1665 | COMPARE(Cmn(w0, -1), "cmp w0, #0x1 (1)"); |
| 1666 | COMPARE(Cmn(x1, -1), "cmp x1, #0x1 (1)"); |
| 1667 | COMPARE(Cmn(w2, -4095), "cmp w2, #0xfff (4095)"); |
| 1668 | COMPARE(Cmn(x3, -4095), "cmp x3, #0xfff (4095)"); |
| 1669 | |
| 1670 | CLEANUP(); |
| 1671 | } |
| 1672 | |
| 1673 | |
| 1674 | TEST_(logical_immediate_move) { |
| 1675 | SET_UP_CLASS(MacroAssembler); |
| 1676 | |
| 1677 | COMPARE(And(w0, w1, 0), "movz w0, #0x0"); |
| 1678 | COMPARE(And(x0, x1, 0), "movz x0, #0x0"); |
| 1679 | COMPARE(Orr(w2, w3, 0), "mov w2, w3"); |
| 1680 | COMPARE(Orr(x2, x3, 0), "mov x2, x3"); |
| 1681 | COMPARE(Eor(w4, w5, 0), "mov w4, w5"); |
| 1682 | COMPARE(Eor(x4, x5, 0), "mov x4, x5"); |
| 1683 | COMPARE(Bic(w6, w7, 0), "mov w6, w7"); |
| 1684 | COMPARE(Bic(x6, x7, 0), "mov x6, x7"); |
| 1685 | COMPARE(Orn(w8, w9, 0), "movn w8, #0x0"); |
| 1686 | COMPARE(Orn(x8, x9, 0), "movn x8, #0x0"); |
| 1687 | COMPARE(Eon(w10, w11, 0), "mvn w10, w11"); |
| 1688 | COMPARE(Eon(x10, x11, 0), "mvn x10, x11"); |
| 1689 | |
| 1690 | COMPARE(And(w12, w13, 0xffffffff), "mov w12, w13"); |
| 1691 | COMPARE(And(x12, x13, 0xffffffff), "and x12, x13, #0xffffffff"); |
| 1692 | COMPARE(And(x12, x13, 0xffffffffffffffff), "mov x12, x13"); |
| 1693 | COMPARE(Orr(w14, w15, 0xffffffff), "movn w14, #0x0"); |
| 1694 | COMPARE(Orr(x14, x15, 0xffffffff), "orr x14, x15, #0xffffffff"); |
| 1695 | COMPARE(Orr(x14, x15, 0xffffffffffffffff), "movn x14, #0x0"); |
| 1696 | COMPARE(Eor(w16, w17, 0xffffffff), "mvn w16, w17"); |
| 1697 | COMPARE(Eor(x16, x17, 0xffffffff), "eor x16, x17, #0xffffffff"); |
| 1698 | COMPARE(Eor(x16, x17, 0xffffffffffffffff), "mvn x16, x17"); |
| 1699 | COMPARE(Bic(w18, w19, 0xffffffff), "movz w18, #0x0"); |
| 1700 | COMPARE(Bic(x18, x19, 0xffffffff), "and x18, x19, #0xffffffff00000000"); |
| 1701 | COMPARE(Bic(x18, x19, 0xffffffffffffffff), "movz x18, #0x0"); |
| 1702 | COMPARE(Orn(w20, w21, 0xffffffff), "mov w20, w21"); |
| 1703 | COMPARE(Orn(x20, x21, 0xffffffff), "orr x20, x21, #0xffffffff00000000"); |
| 1704 | COMPARE(Orn(x20, x21, 0xffffffffffffffff), "mov x20, x21"); |
| 1705 | COMPARE(Eon(w22, w23, 0xffffffff), "mov w22, w23"); |
| 1706 | COMPARE(Eon(x22, x23, 0xffffffff), "eor x22, x23, #0xffffffff00000000"); |
| 1707 | COMPARE(Eon(x22, x23, 0xffffffffffffffff), "mov x22, x23"); |
| 1708 | |
| 1709 | CLEANUP(); |
| 1710 | } |
| 1711 | |
| 1712 | |
| 1713 | TEST_(barriers) { |
| 1714 | SET_UP_CLASS(MacroAssembler); |
| 1715 | |
| 1716 | // DMB |
| 1717 | COMPARE(Dmb(FullSystem, BarrierAll), "dmb sy"); |
| 1718 | COMPARE(Dmb(FullSystem, BarrierReads), "dmb ld"); |
| 1719 | COMPARE(Dmb(FullSystem, BarrierWrites), "dmb st"); |
| 1720 | |
| 1721 | COMPARE(Dmb(InnerShareable, BarrierAll), "dmb ish"); |
| 1722 | COMPARE(Dmb(InnerShareable, BarrierReads), "dmb ishld"); |
| 1723 | COMPARE(Dmb(InnerShareable, BarrierWrites), "dmb ishst"); |
| 1724 | |
| 1725 | COMPARE(Dmb(NonShareable, BarrierAll), "dmb nsh"); |
| 1726 | COMPARE(Dmb(NonShareable, BarrierReads), "dmb nshld"); |
| 1727 | COMPARE(Dmb(NonShareable, BarrierWrites), "dmb nshst"); |
| 1728 | |
| 1729 | COMPARE(Dmb(OuterShareable, BarrierAll), "dmb osh"); |
| 1730 | COMPARE(Dmb(OuterShareable, BarrierReads), "dmb oshld"); |
| 1731 | COMPARE(Dmb(OuterShareable, BarrierWrites), "dmb oshst"); |
| 1732 | |
| 1733 | COMPARE(Dmb(FullSystem, BarrierOther), "dmb sy (0b1100)"); |
| 1734 | COMPARE(Dmb(InnerShareable, BarrierOther), "dmb sy (0b1000)"); |
| 1735 | COMPARE(Dmb(NonShareable, BarrierOther), "dmb sy (0b0100)"); |
| 1736 | COMPARE(Dmb(OuterShareable, BarrierOther), "dmb sy (0b0000)"); |
| 1737 | |
| 1738 | // DSB |
| 1739 | COMPARE(Dsb(FullSystem, BarrierAll), "dsb sy"); |
| 1740 | COMPARE(Dsb(FullSystem, BarrierReads), "dsb ld"); |
| 1741 | COMPARE(Dsb(FullSystem, BarrierWrites), "dsb st"); |
| 1742 | |
| 1743 | COMPARE(Dsb(InnerShareable, BarrierAll), "dsb ish"); |
| 1744 | COMPARE(Dsb(InnerShareable, BarrierReads), "dsb ishld"); |
| 1745 | COMPARE(Dsb(InnerShareable, BarrierWrites), "dsb ishst"); |
| 1746 | |
| 1747 | COMPARE(Dsb(NonShareable, BarrierAll), "dsb nsh"); |
| 1748 | COMPARE(Dsb(NonShareable, BarrierReads), "dsb nshld"); |
| 1749 | COMPARE(Dsb(NonShareable, BarrierWrites), "dsb nshst"); |
| 1750 | |
| 1751 | COMPARE(Dsb(OuterShareable, BarrierAll), "dsb osh"); |
| 1752 | COMPARE(Dsb(OuterShareable, BarrierReads), "dsb oshld"); |
| 1753 | COMPARE(Dsb(OuterShareable, BarrierWrites), "dsb oshst"); |
| 1754 | |
| 1755 | COMPARE(Dsb(FullSystem, BarrierOther), "dsb sy (0b1100)"); |
| 1756 | COMPARE(Dsb(InnerShareable, BarrierOther), "dsb sy (0b1000)"); |
| 1757 | COMPARE(Dsb(NonShareable, BarrierOther), "dsb sy (0b0100)"); |
| 1758 | COMPARE(Dsb(OuterShareable, BarrierOther), "dsb sy (0b0000)"); |
| 1759 | |
| 1760 | // ISB |
| 1761 | COMPARE(Isb(), "isb"); |
| 1762 | |
| 1763 | CLEANUP(); |
| 1764 | } |