1// Copyright 2015, VIXL authors 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are met: 6// 7// * Redistributions of source code must retain the above copyright notice, 8// this list of conditions and the following disclaimer. 9// * Redistributions in binary form must reproduce the above copyright notice, 10// this list of conditions and the following disclaimer in the documentation 11// and/or other materials provided with the distribution. 12// * Neither the name of ARM Limited nor the names of its contributors may be 13// used to endorse or promote products derived from this software without 14// specific prior written permission. 15// 16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND 17// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 20// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 23// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 27 28#include "test-disasm-aarch64.h" 29 30#include <cstdio> 31#include <cstring> 32#include <string> 33 34#include "test-runner.h" 35 36#include "aarch64/disasm-aarch64.h" 37#include "aarch64/macro-assembler-aarch64.h" 38 39namespace vixl { 40namespace aarch64 { 41 42TEST(bootstrap) { 43 SETUP(); 44 45 // Instructions generated by C compiler, disassembled by objdump, and 46 // reformatted to suit our disassembly style. 47 COMPARE(dci(0xa9ba7bfd), "stp x29, x30, [sp, #-96]!"); 48 COMPARE(dci(0x910003fd), "mov x29, sp"); 49 COMPARE(dci(0x9100e3a0), "add x0, x29, #0x38 (56)"); 50 COMPARE(dci(0xb900001f), "str wzr, [x0]"); 51 COMPARE(dci(0x528000e1), "mov w1, #0x7"); 52 COMPARE(dci(0xb9001c01), "str w1, [x0, #28]"); 53 COMPARE(dci(0x390043a0), "strb w0, [x29, #16]"); 54 COMPARE(dci(0x790027a0), "strh w0, [x29, #18]"); 55 COMPARE(dci(0xb9400400), "ldr w0, [x0, #4]"); 56 COMPARE(dci(0x0b000021), "add w1, w1, w0"); 57 COMPARE(dci(0x531b6800), "lsl w0, w0, #5"); 58 COMPARE(dci(0x521e0400), "eor w0, w0, #0xc"); 59 COMPARE(dci(0x72af0f00), "movk w0, #0x7878, lsl #16"); 60 COMPARE(dci(0xd360fc00), "lsr x0, x0, #32"); 61 COMPARE(dci(0x13037c01), "asr w1, w0, #3"); 62 COMPARE(dci(0x4b000021), "sub w1, w1, w0"); 63 COMPARE(dci(0x2a0103e0), "mov w0, w1"); 64 COMPARE(dci(0x93407c00), "sxtw x0, w0"); 65 COMPARE(dci(0x2a000020), "orr w0, w1, w0"); 66 COMPARE(dci(0xa8c67bfd), "ldp x29, x30, [sp], #96"); 67 68 CLEANUP(); 69} 70 71 72TEST(mov_mvn) { 73 SETUP(); 74 75 COMPARE_MACRO(Mov(w0, Operand(0x1234)), "mov w0, #0x1234"); 76 COMPARE_MACRO(Mov(x1, Operand(0x1234)), "mov x1, #0x1234"); 77 COMPARE_MACRO(Mov(w2, Operand(w3)), "mov w2, w3"); 78 COMPARE_MACRO(Mov(x4, Operand(x5)), "mov x4, x5"); 79 COMPARE_MACRO(Mov(w6, Operand(w7, LSL, 5)), "lsl w6, w7, #5"); 80 COMPARE_MACRO(Mov(x8, Operand(x9, ASR, 42)), "asr x8, x9, #42"); 81 COMPARE_MACRO(Mov(w10, Operand(w11, UXTB)), "uxtb w10, w11"); 82 COMPARE_MACRO(Mov(x12, Operand(x13, UXTB, 1)), "ubfiz x12, x13, #1, #8"); 83 COMPARE_MACRO(Mov(w14, Operand(w15, SXTH, 2)), "sbfiz w14, w15, #2, #16"); 84 COMPARE_MACRO(Mov(x16, Operand(x17, SXTW, 3)), "sbfiz x16, x17, #3, #32"); 85 86 COMPARE_MACRO(Mvn(w0, Operand(0x101)), "mov w0, #0xfffffefe"); 87 COMPARE_MACRO(Mvn(x1, Operand(0xfff1)), "mov x1, #0xffffffffffff000e"); 88 COMPARE_MACRO(Mvn(w2, Operand(w3)), "mvn w2, w3"); 89 COMPARE_MACRO(Mvn(x4, Operand(x5)), "mvn x4, x5"); 90 COMPARE_MACRO(Mvn(w6, Operand(w7, LSL, 12)), "mvn w6, w7, lsl #12"); 91 COMPARE_MACRO(Mvn(x8, Operand(x9, ASR, 63)), "mvn x8, x9, asr #63"); 92 93 CLEANUP(); 94} 95 96TEST(mvn_macro) { 97 SETUP(); 98 99 // Mvn uses the destination register as a scratch if it can. This only occurs 100 // when `operand.IsExtendedRegister()`. 101 COMPARE_MACRO(Mvn(x0, Operand(w1, SXTW)), 102 "sxtw x0, w1\n" 103 "mvn x0, x0"); 104 COMPARE_MACRO(Mvn(x0, Operand(x0, SXTW)), 105 "sxtw x0, w0\n" 106 "mvn x0, x0"); 107} 108 109 110TEST(move_immediate) { 111 SETUP(); 112 113 COMPARE(movz(w0, 0x1234), "mov w0, #0x1234"); 114 COMPARE(movz(x1, 0xabcd0000), "mov x1, #0xabcd0000"); 115 COMPARE(movz(x2, 0x555500000000), "mov x2, #0x555500000000"); 116 COMPARE(movz(x3, 0xaaaa000000000000), "mov x3, #0xaaaa000000000000"); 117 COMPARE(movz(x4, 0xabcd, 16), "mov x4, #0xabcd0000"); 118 COMPARE(movz(x5, 0x5555, 32), "mov x5, #0x555500000000"); 119 COMPARE(movz(x6, 0xaaaa, 48), "mov x6, #0xaaaa000000000000"); 120 121 COMPARE(movk(w7, 0x1234), "movk w7, #0x1234"); 122 COMPARE(movk(x8, 0xabcd0000), "movk x8, #0xabcd, lsl #16"); 123 COMPARE(movk(x9, 0x555500000000), "movk x9, #0x5555, lsl #32"); 124 COMPARE(movk(x10, 0xaaaa000000000000), "movk x10, #0xaaaa, lsl #48"); 125 COMPARE(movk(w11, 0xabcd, 16), "movk w11, #0xabcd, lsl #16"); 126 COMPARE(movk(x12, 0x5555, 32), "movk x12, #0x5555, lsl #32"); 127 COMPARE(movk(x13, 0xaaaa, 48), "movk x13, #0xaaaa, lsl #48"); 128 129 COMPARE(movn(w14, 0x1234), "mov w14, #0xffffedcb"); 130 COMPARE(movn(x15, 0xabcd0000), "mov x15, #0xffffffff5432ffff"); 131 COMPARE(movn(x16, 0x555500000000), "mov x16, #0xffffaaaaffffffff"); 132 COMPARE(movn(x17, 0xaaaa000000000000), "mov x17, #0x5555ffffffffffff"); 133 COMPARE(movn(w18, 0xabcd, 16), "mov w18, #0x5432ffff"); 134 COMPARE(movn(x19, 0x5555, 32), "mov x19, #0xffffaaaaffffffff"); 135 COMPARE(movn(x20, 0xaaaa, 48), "mov x20, #0x5555ffffffffffff"); 136 137 COMPARE(mov(w14, 0x1234), "mov w14, #0x1234"); 138 COMPARE(mov(x15, 0xabcd0000), "mov x15, #0xabcd0000"); 139 COMPARE(mov(x16, 0xaaaa000000000000), "mov x16, #0xaaaa000000000000"); 140 COMPARE(mov(w17, 0xaaaaffff), "mov w17, #0xaaaaffff"); 141 COMPARE(mov(x18, 0xffffaaaaffffffff), "mov x18, #0xffffaaaaffffffff"); 142 COMPARE(mov(x19, 0xffffffffffffffff), "mov x19, #0xffffffffffffffff"); 143 COMPARE(mov(x20, 0xc001c001c001c001), "mov x20, #0xc001c001c001c001"); 144 COMPARE(mov(sp, 0xfefefefefefefefe), "mov sp, #0xfefefefefefefefe"); 145 146 COMPARE(movk(w21, 0), "movk w21, #0x0"); 147 COMPARE(movk(x22, 0, 0), "movk x22, #0x0"); 148 COMPARE(movk(w23, 0, 16), "movk w23, #0x0, lsl #16"); 149 COMPARE(movk(x24, 0, 32), "movk x24, #0x0, lsl #32"); 150 COMPARE(movk(x25, 0, 48), "movk x25, #0x0, lsl #48"); 151 152 COMPARE(movz(x26, 0, 48), "movz x26, #0x0"); 153 COMPARE(movn(x27, 0, 48), "movn x27, #0x0"); 154 COMPARE(movn(w28, 0xffff), "movn w28, #0xffff"); 155 156 CLEANUP(); 157} 158 159 160TEST(move_immediate_2) { 161 SETUP(); 162 163 // Move instructions expected for certain immediates. This is really a macro 164 // assembler test, to ensure it generates immediates efficiently. 165 COMPARE_MACRO(Mov(w0, 0), "mov w0, #0x0"); 166 COMPARE_MACRO(Mov(w0, 0x0000ffff), "mov w0, #0xffff"); 167 COMPARE_MACRO(Mov(w0, 0x00010000), "mov w0, #0x10000"); 168 COMPARE_MACRO(Mov(w0, 0xffff0000), "mov w0, #0xffff0000"); 169 COMPARE_MACRO(Mov(w0, 0x0001ffff), "mov w0, #0x1ffff"); 170 COMPARE_MACRO(Mov(w0, 0xffff8000), "mov w0, #0xffff8000"); 171 COMPARE_MACRO(Mov(w0, 0xfffffffe), "mov w0, #0xfffffffe"); 172 COMPARE_MACRO(Mov(w0, 0xffffffff), "mov w0, #0xffffffff"); 173 COMPARE_MACRO(Mov(w0, 0x00ffff00), "mov w0, #0xffff00"); 174 COMPARE_MACRO(Mov(w0, 0xfffe7fff), "mov w0, #0xfffe7fff"); 175 COMPARE_MACRO(Mov(w0, 0xfffeffff), "mov w0, #0xfffeffff"); 176 COMPARE_MACRO(Mov(w0, 0xffff7fff), "mov w0, #0xffff7fff"); 177 178 COMPARE_MACRO(Mov(x0, 0), "mov x0, #0x0"); 179 COMPARE_MACRO(Mov(x0, 0x0000ffff), "mov x0, #0xffff"); 180 COMPARE_MACRO(Mov(x0, 0x00010000), "mov x0, #0x10000"); 181 COMPARE_MACRO(Mov(x0, 0xffff0000), "mov x0, #0xffff0000"); 182 COMPARE_MACRO(Mov(x0, 0x0001ffff), "mov x0, #0x1ffff"); 183 COMPARE_MACRO(Mov(x0, 0xffff8000), "mov x0, #0xffff8000"); 184 COMPARE_MACRO(Mov(x0, 0xfffffffe), "mov x0, #0xfffffffe"); 185 COMPARE_MACRO(Mov(x0, 0xffffffff), "mov x0, #0xffffffff"); 186 COMPARE_MACRO(Mov(x0, 0x00ffff00), "mov x0, #0xffff00"); 187 COMPARE_MACRO(Mov(x0, 0xffff000000000000), "mov x0, #0xffff000000000000"); 188 COMPARE_MACRO(Mov(x0, 0x0000ffff00000000), "mov x0, #0xffff00000000"); 189 COMPARE_MACRO(Mov(x0, 0x00000000ffff0000), "mov x0, #0xffff0000"); 190 COMPARE_MACRO(Mov(x0, 0xffffffffffff0000), "mov x0, #0xffffffffffff0000"); 191 COMPARE_MACRO(Mov(x0, 0xffffffff0000ffff), "mov x0, #0xffffffff0000ffff"); 192 COMPARE_MACRO(Mov(x0, 0xffff0000ffffffff), "mov x0, #0xffff0000ffffffff"); 193 COMPARE_MACRO(Mov(x0, 0x0000ffffffffffff), "mov x0, #0xffffffffffff"); 194 COMPARE_MACRO(Mov(x0, 0xfffe7fffffffffff), "mov x0, #0xfffe7fffffffffff"); 195 COMPARE_MACRO(Mov(x0, 0xfffeffffffffffff), "mov x0, #0xfffeffffffffffff"); 196 COMPARE_MACRO(Mov(x0, 0xffff7fffffffffff), "mov x0, #0xffff7fffffffffff"); 197 COMPARE_MACRO(Mov(x0, 0xfffffffe7fffffff), "mov x0, #0xfffffffe7fffffff"); 198 COMPARE_MACRO(Mov(x0, 0xfffffffeffffffff), "mov x0, #0xfffffffeffffffff"); 199 COMPARE_MACRO(Mov(x0, 0xffffffff7fffffff), "mov x0, #0xffffffff7fffffff"); 200 COMPARE_MACRO(Mov(x0, 0xfffffffffffe7fff), "mov x0, #0xfffffffffffe7fff"); 201 COMPARE_MACRO(Mov(x0, 0xfffffffffffeffff), "mov x0, #0xfffffffffffeffff"); 202 COMPARE_MACRO(Mov(x0, 0xffffffffffff7fff), "mov x0, #0xffffffffffff7fff"); 203 COMPARE_MACRO(Mov(x0, 0xffffffffffffffff), "mov x0, #0xffffffffffffffff"); 204 205 COMPARE_MACRO(Movk(w0, 0x1234, 0), "movk w0, #0x1234"); 206 COMPARE_MACRO(Movk(x1, 0x2345, 0), "movk x1, #0x2345"); 207 COMPARE_MACRO(Movk(w2, 0x3456, 16), "movk w2, #0x3456, lsl #16"); 208 COMPARE_MACRO(Movk(x3, 0x4567, 16), "movk x3, #0x4567, lsl #16"); 209 COMPARE_MACRO(Movk(x4, 0x5678, 32), "movk x4, #0x5678, lsl #32"); 210 COMPARE_MACRO(Movk(x5, 0x6789, 48), "movk x5, #0x6789, lsl #48"); 211 212 CLEANUP(); 213} 214 215 216TEST(add_immediate) { 217 SETUP(); 218 219 COMPARE(add(w0, w1, Operand(0xff)), "add w0, w1, #0xff (255)"); 220 COMPARE(add(x2, x3, Operand(0x3ff)), "add x2, x3, #0x3ff (1023)"); 221 COMPARE(add(w4, w5, Operand(0xfff)), "add w4, w5, #0xfff (4095)"); 222 COMPARE(add(x6, x7, Operand(0x1000)), "add x6, x7, #0x1000 (4096)"); 223 COMPARE(add(w8, w9, Operand(0xff000)), "add w8, w9, #0xff000 (1044480)"); 224 COMPARE(add(x10, x11, Operand(0x3ff000)), 225 "add x10, x11, #0x3ff000 (4190208)"); 226 COMPARE(add(w12, w13, Operand(0xfff000)), 227 "add w12, w13, #0xfff000 (16773120)"); 228 COMPARE(adds(w14, w15, Operand(0xff)), "adds w14, w15, #0xff (255)"); 229 COMPARE(adds(x16, x17, Operand(0xaa000)), "adds x16, x17, #0xaa000 (696320)"); 230 231 COMPARE(cmn(w18, Operand(0xff)), "cmn w18, #0xff (255)"); 232 COMPARE(cmn(x19, Operand(0xff000)), "cmn x19, #0xff000 (1044480)"); 233 COMPARE(add(w0, wsp, Operand(0)), "mov w0, wsp"); 234 COMPARE(add(sp, x0, Operand(0)), "mov sp, x0"); 235 236 COMPARE(add(w1, wsp, Operand(8)), "add w1, wsp, #0x8 (8)"); 237 COMPARE(add(x2, sp, Operand(16)), "add x2, sp, #0x10 (16)"); 238 COMPARE(add(wsp, wsp, Operand(42)), "add wsp, wsp, #0x2a (42)"); 239 COMPARE(cmn(sp, Operand(24)), "cmn sp, #0x18 (24)"); 240 COMPARE(adds(wzr, wsp, Operand(9)), "cmn wsp, #0x9 (9)"); 241 242 CLEANUP(); 243} 244 245 246TEST(sub_immediate) { 247 SETUP(); 248 249 COMPARE(sub(w0, w1, Operand(0xff)), "sub w0, w1, #0xff (255)"); 250 COMPARE(sub(x2, x3, Operand(0x3ff)), "sub x2, x3, #0x3ff (1023)"); 251 COMPARE(sub(w4, w5, Operand(0xfff)), "sub w4, w5, #0xfff (4095)"); 252 COMPARE(sub(x6, x7, Operand(0x1000)), "sub x6, x7, #0x1000 (4096)"); 253 COMPARE(sub(w8, w9, Operand(0xff000)), "sub w8, w9, #0xff000 (1044480)"); 254 COMPARE(sub(x10, x11, Operand(0x3ff000)), 255 "sub x10, x11, #0x3ff000 (4190208)"); 256 COMPARE(sub(w12, w13, Operand(0xfff000)), 257 "sub w12, w13, #0xfff000 (16773120)"); 258 COMPARE(subs(w14, w15, Operand(0xff)), "subs w14, w15, #0xff (255)"); 259 COMPARE(subs(x16, x17, Operand(0xaa000)), "subs x16, x17, #0xaa000 (696320)"); 260 COMPARE(cmp(w18, Operand(0xff)), "cmp w18, #0xff (255)"); 261 COMPARE(cmp(x19, Operand(0xff000)), "cmp x19, #0xff000 (1044480)"); 262 263 COMPARE(sub(w1, wsp, Operand(8)), "sub w1, wsp, #0x8 (8)"); 264 COMPARE(sub(x2, sp, Operand(16)), "sub x2, sp, #0x10 (16)"); 265 COMPARE(sub(wsp, wsp, Operand(42)), "sub wsp, wsp, #0x2a (42)"); 266 COMPARE(cmp(sp, Operand(24)), "cmp sp, #0x18 (24)"); 267 COMPARE(subs(wzr, wsp, Operand(9)), "cmp wsp, #0x9 (9)"); 268 269 CLEANUP(); 270} 271 272 273TEST(add_shifted) { 274 SETUP(); 275 276 COMPARE(add(w0, w1, Operand(w2)), "add w0, w1, w2"); 277 COMPARE(add(x3, x4, Operand(x5)), "add x3, x4, x5"); 278 COMPARE(add(w6, w7, Operand(w8, LSL, 1)), "add w6, w7, w8, lsl #1"); 279 COMPARE(add(x9, x10, Operand(x11, LSL, 2)), "add x9, x10, x11, lsl #2"); 280 COMPARE(add(w12, w13, Operand(w14, LSR, 3)), "add w12, w13, w14, lsr #3"); 281 COMPARE(add(x15, x16, Operand(x17, LSR, 4)), "add x15, x16, x17, lsr #4"); 282 COMPARE(add(w18, w19, Operand(w20, ASR, 5)), "add w18, w19, w20, asr #5"); 283 COMPARE(add(x21, x22, Operand(x23, ASR, 6)), "add x21, x22, x23, asr #6"); 284 COMPARE(cmn(w24, Operand(w25)), "cmn w24, w25"); 285 COMPARE(cmn(x26, Operand(x27, LSL, 63)), "cmn x26, x27, lsl #63"); 286 287 COMPARE(add(x0, sp, Operand(x1)), "add x0, sp, x1"); 288 COMPARE(add(w2, wsp, Operand(w3)), "add w2, wsp, w3"); 289 COMPARE(add(x4, sp, Operand(x5, LSL, 1)), "add x4, sp, x5, lsl #1"); 290 COMPARE(add(x4, xzr, Operand(x5, LSL, 1)), "add x4, xzr, x5, lsl #1"); 291 COMPARE(add(w6, wsp, Operand(w7, LSL, 3)), "add w6, wsp, w7, lsl #3"); 292 COMPARE(adds(xzr, sp, Operand(x8, LSL, 4)), "cmn sp, x8, lsl #4"); 293 COMPARE(adds(xzr, xzr, Operand(x8, LSL, 5)), "cmn xzr, x8, lsl #5"); 294 295 CLEANUP(); 296} 297 298 299TEST(sub_shifted) { 300 SETUP(); 301 302 COMPARE(sub(w0, w1, Operand(w2)), "sub w0, w1, w2"); 303 COMPARE(sub(x3, x4, Operand(x5)), "sub x3, x4, x5"); 304 COMPARE(sub(w6, w7, Operand(w8, LSL, 1)), "sub w6, w7, w8, lsl #1"); 305 COMPARE(sub(x9, x10, Operand(x11, LSL, 2)), "sub x9, x10, x11, lsl #2"); 306 COMPARE(sub(w12, w13, Operand(w14, LSR, 3)), "sub w12, w13, w14, lsr #3"); 307 COMPARE(sub(x15, x16, Operand(x17, LSR, 4)), "sub x15, x16, x17, lsr #4"); 308 COMPARE(sub(w18, w19, Operand(w20, ASR, 5)), "sub w18, w19, w20, asr #5"); 309 COMPARE(sub(x21, x22, Operand(x23, ASR, 6)), "sub x21, x22, x23, asr #6"); 310 COMPARE(cmp(w24, Operand(w25)), "cmp w24, w25"); 311 COMPARE(cmp(x26, Operand(x27, LSL, 63)), "cmp x26, x27, lsl #63"); 312 COMPARE(neg(w28, Operand(w29)), "neg w28, w29"); 313 COMPARE(neg(x30, Operand(x0, LSR, 62)), "neg x30, x0, lsr #62"); 314 COMPARE(negs(w1, Operand(w2)), "negs w1, w2"); 315 COMPARE(negs(x3, Operand(x4, ASR, 61)), "negs x3, x4, asr #61"); 316 317 COMPARE(sub(x0, sp, Operand(x1)), "sub x0, sp, x1"); 318 COMPARE(sub(w2, wsp, Operand(w3)), "sub w2, wsp, w3"); 319 COMPARE(sub(x4, sp, Operand(x5, LSL, 1)), "sub x4, sp, x5, lsl #1"); 320 COMPARE(sub(x4, xzr, Operand(x5, LSL, 1)), "neg x4, x5, lsl #1"); 321 COMPARE(sub(w6, wsp, Operand(w7, LSL, 3)), "sub w6, wsp, w7, lsl #3"); 322 COMPARE(subs(xzr, sp, Operand(x8, LSL, 4)), "cmp sp, x8, lsl #4"); 323 COMPARE(subs(xzr, xzr, Operand(x8, LSL, 5)), "cmp xzr, x8, lsl #5"); 324 325 CLEANUP(); 326} 327 328 329TEST(add_extended) { 330 SETUP(); 331 332 COMPARE(add(w0, w1, Operand(w2, UXTB)), "add w0, w1, w2, uxtb"); 333 COMPARE(adds(x3, x4, Operand(w5, UXTB, 1)), "adds x3, x4, w5, uxtb #1"); 334 COMPARE(add(w6, w7, Operand(w8, UXTH, 2)), "add w6, w7, w8, uxth #2"); 335 COMPARE(adds(x9, x10, Operand(x11, UXTW, 3)), "adds x9, x10, w11, uxtw #3"); 336 COMPARE(add(x12, x13, Operand(x14, UXTX, 4)), "add x12, x13, x14, uxtx #4"); 337 COMPARE(adds(w15, w16, Operand(w17, SXTB, 4)), "adds w15, w16, w17, sxtb #4"); 338 COMPARE(add(x18, x19, Operand(x20, SXTB, 3)), "add x18, x19, w20, sxtb #3"); 339 COMPARE(adds(w21, w22, Operand(w23, SXTH, 2)), "adds w21, w22, w23, sxth #2"); 340 COMPARE(add(x24, x25, Operand(x26, SXTW, 1)), "add x24, x25, w26, sxtw #1"); 341 COMPARE(adds(x27, x28, Operand(x29, SXTX)), "adds x27, x28, x29, sxtx"); 342 COMPARE(cmn(w0, Operand(w1, UXTB, 2)), "cmn w0, w1, uxtb #2"); 343 COMPARE(cmn(x2, Operand(x3, SXTH, 4)), "cmn x2, w3, sxth #4"); 344 345 COMPARE(add(w0, wsp, Operand(w1, UXTB)), "add w0, wsp, w1, uxtb"); 346 COMPARE(add(x2, sp, Operand(x3, UXTH, 1)), "add x2, sp, w3, uxth #1"); 347 COMPARE(add(wsp, wsp, Operand(w4, UXTW, 2)), "add wsp, wsp, w4, lsl #2"); 348 COMPARE(cmn(sp, Operand(xzr, UXTX, 3)), "cmn sp, xzr, lsl #3"); 349 COMPARE(cmn(sp, Operand(xzr, LSL, 4)), "cmn sp, xzr, lsl #4"); 350 351 CLEANUP(); 352} 353 354 355TEST(sub_extended) { 356 SETUP(); 357 358 COMPARE(sub(w0, w1, Operand(w2, UXTB)), "sub w0, w1, w2, uxtb"); 359 COMPARE(subs(x3, x4, Operand(w5, UXTB, 1)), "subs x3, x4, w5, uxtb #1"); 360 COMPARE(sub(w6, w7, Operand(w8, UXTH, 2)), "sub w6, w7, w8, uxth #2"); 361 COMPARE(subs(x9, x10, Operand(x11, UXTW, 3)), "subs x9, x10, w11, uxtw #3"); 362 COMPARE(sub(x12, x13, Operand(x14, UXTX, 4)), "sub x12, x13, x14, uxtx #4"); 363 COMPARE(subs(w15, w16, Operand(w17, SXTB, 4)), "subs w15, w16, w17, sxtb #4"); 364 COMPARE(sub(x18, x19, Operand(x20, SXTB, 3)), "sub x18, x19, w20, sxtb #3"); 365 COMPARE(subs(w21, w22, Operand(w23, SXTH, 2)), "subs w21, w22, w23, sxth #2"); 366 COMPARE(sub(x24, x25, Operand(x26, SXTW, 1)), "sub x24, x25, w26, sxtw #1"); 367 COMPARE(subs(x27, x28, Operand(x29, SXTX)), "subs x27, x28, x29, sxtx"); 368 COMPARE(cmp(w0, Operand(w1, SXTB, 1)), "cmp w0, w1, sxtb #1"); 369 COMPARE(cmp(x2, Operand(x3, UXTH, 3)), "cmp x2, w3, uxth #3"); 370 371 COMPARE(sub(w0, wsp, Operand(w1, UXTB)), "sub w0, wsp, w1, uxtb"); 372 COMPARE(sub(x2, sp, Operand(x3, UXTH, 1)), "sub x2, sp, w3, uxth #1"); 373 COMPARE(sub(wsp, wsp, Operand(w4, UXTW, 2)), "sub wsp, wsp, w4, lsl #2"); 374 COMPARE(cmp(sp, Operand(xzr, UXTX, 3)), "cmp sp, xzr, lsl #3"); 375 COMPARE(cmp(sp, Operand(xzr, LSL, 4)), "cmp sp, xzr, lsl #4"); 376 377 CLEANUP(); 378} 379 380 381TEST(adc_subc_ngc) { 382 SETUP(); 383 384 COMPARE(adc(w0, w1, Operand(w2)), "adc w0, w1, w2"); 385 COMPARE(adc(x3, x4, Operand(x5)), "adc x3, x4, x5"); 386 COMPARE(adcs(w6, w7, Operand(w8)), "adcs w6, w7, w8"); 387 COMPARE(adcs(x9, x10, Operand(x11)), "adcs x9, x10, x11"); 388 COMPARE(sbc(w12, w13, Operand(w14)), "sbc w12, w13, w14"); 389 COMPARE(sbc(x15, x16, Operand(x17)), "sbc x15, x16, x17"); 390 COMPARE(sbcs(w18, w19, Operand(w20)), "sbcs w18, w19, w20"); 391 COMPARE(sbcs(x21, x22, Operand(x23)), "sbcs x21, x22, x23"); 392 COMPARE(ngc(w24, Operand(w25)), "ngc w24, w25"); 393 COMPARE(ngc(x26, Operand(x27)), "ngc x26, x27"); 394 COMPARE(ngcs(w28, Operand(w29)), "ngcs w28, w29"); 395 COMPARE(ngcs(x30, Operand(x0)), "ngcs x30, x0"); 396 397 CLEANUP(); 398} 399 400 401TEST(rmif) { 402 SETUP(); 403 404 COMPARE(rmif(x0, 3, ZCVFlag), "rmif x0, #3, #nZCV"); 405 COMPARE(rmif(x1, 63, NCFlag), "rmif x1, #63, #NzCv"); 406 407 CLEANUP(); 408} 409 410 411TEST(setf8_setf16) { 412 SETUP(); 413 414 COMPARE(setf8(w0), "setf8 w0"); 415 COMPARE(setf16(w1), "setf16 w1"); 416 417 CLEANUP(); 418} 419 420 421TEST(mul_and_div) { 422 SETUP(); 423 424 COMPARE(mul(w0, w1, w2), "mul w0, w1, w2"); 425 COMPARE(mul(x3, x4, x5), "mul x3, x4, x5"); 426 COMPARE(mul(w30, w0, w1), "mul w30, w0, w1"); 427 COMPARE(mul(x30, x0, x1), "mul x30, x0, x1"); 428 COMPARE(mneg(w0, w1, w2), "mneg w0, w1, w2"); 429 COMPARE(mneg(x3, x4, x5), "mneg x3, x4, x5"); 430 COMPARE(mneg(w30, w0, w1), "mneg w30, w0, w1"); 431 COMPARE(mneg(x30, x0, x1), "mneg x30, x0, x1"); 432 COMPARE(smull(x0, w0, w1), "smull x0, w0, w1"); 433 COMPARE(smull(x30, w30, w0), "smull x30, w30, w0"); 434 COMPARE(smulh(x0, x1, x2), "smulh x0, x1, x2"); 435 COMPARE(umulh(x0, x2, x1), "umulh x0, x2, x1"); 436 437 COMPARE(sdiv(w0, w1, w2), "sdiv w0, w1, w2"); 438 COMPARE(sdiv(x3, x4, x5), "sdiv x3, x4, x5"); 439 COMPARE(udiv(w6, w7, w8), "udiv w6, w7, w8"); 440 COMPARE(udiv(x9, x10, x11), "udiv x9, x10, x11"); 441 442 CLEANUP(); 443} 444 445 446TEST(madd) { 447 SETUP(); 448 449 COMPARE(madd(w0, w1, w2, w3), "madd w0, w1, w2, w3"); 450 COMPARE(madd(w30, w21, w22, w16), "madd w30, w21, w22, w16"); 451 COMPARE(madd(x0, x1, x2, x3), "madd x0, x1, x2, x3"); 452 COMPARE(madd(x30, x21, x22, x16), "madd x30, x21, x22, x16"); 453 454 COMPARE(smaddl(x0, w1, w2, x3), "smaddl x0, w1, w2, x3"); 455 COMPARE(smaddl(x30, w21, w22, x16), "smaddl x30, w21, w22, x16"); 456 COMPARE(umaddl(x0, w1, w2, x3), "umaddl x0, w1, w2, x3"); 457 COMPARE(umaddl(x30, w21, w22, x16), "umaddl x30, w21, w22, x16"); 458 COMPARE(umull(x0, w1, w2), "umull x0, w1, w2"); 459 COMPARE(umull(x30, w21, w22), "umull x30, w21, w22"); 460 461 CLEANUP(); 462} 463 464 465TEST(msub) { 466 SETUP(); 467 468 COMPARE(msub(w0, w1, w2, w3), "msub w0, w1, w2, w3"); 469 COMPARE(msub(w30, w21, w22, w16), "msub w30, w21, w22, w16"); 470 COMPARE(msub(x0, x1, x2, x3), "msub x0, x1, x2, x3"); 471 COMPARE(msub(x30, x21, x22, x16), "msub x30, x21, x22, x16"); 472 473 COMPARE(smsubl(x0, w1, w2, x3), "smsubl x0, w1, w2, x3"); 474 COMPARE(smsubl(x30, w21, w22, x16), "smsubl x30, w21, w22, x16"); 475 COMPARE(umsubl(x0, w1, w2, x3), "umsubl x0, w1, w2, x3"); 476 COMPARE(umsubl(x30, w21, w22, x16), "umsubl x30, w21, w22, x16"); 477 478 CLEANUP(); 479} 480 481 482TEST(dp_1_source) { 483 SETUP(); 484 485 COMPARE(rbit(w0, w1), "rbit w0, w1"); 486 COMPARE(rbit(x2, x3), "rbit x2, x3"); 487 COMPARE(rev16(w4, w5), "rev16 w4, w5"); 488 COMPARE(rev16(x6, x7), "rev16 x6, x7"); 489 COMPARE(rev32(x8, x9), "rev32 x8, x9"); 490 COMPARE(rev64(x10, x11), "rev x10, x11"); 491 COMPARE(rev(w12, w13), "rev w12, w13"); 492 COMPARE(rev(x14, x15), "rev x14, x15"); 493 COMPARE(clz(w16, w17), "clz w16, w17"); 494 COMPARE(clz(x18, x19), "clz x18, x19"); 495 COMPARE(cls(w20, w21), "cls w20, w21"); 496 COMPARE(cls(x22, x23), "cls x22, x23"); 497 COMPARE(pacia(x24, x25), "pacia x24, x25"); 498 COMPARE(pacia(x26, sp), "pacia x26, sp"); 499 COMPARE(pacib(x27, x28), "pacib x27, x28"); 500 COMPARE(pacib(x29, sp), "pacib x29, sp"); 501 COMPARE(pacda(x30, x0), "pacda x30, x0"); 502 COMPARE(pacda(x1, sp), "pacda x1, sp"); 503 COMPARE(pacdb(x2, x3), "pacdb x2, x3"); 504 COMPARE(pacdb(x4, sp), "pacdb x4, sp"); 505 COMPARE(paciza(x5), "paciza x5"); 506 COMPARE(pacizb(x6), "pacizb x6"); 507 COMPARE(pacdza(x7), "pacdza x7"); 508 COMPARE(pacdzb(x8), "pacdzb x8"); 509 COMPARE(autia(x9, x10), "autia x9, x10"); 510 COMPARE(autia(x11, sp), "autia x11, sp"); 511 COMPARE(autib(x12, x13), "autib x12, x13"); 512 COMPARE(autib(x14, sp), "autib x14, sp"); 513 COMPARE(autda(x15, x16), "autda x15, x16"); 514 COMPARE(autda(x17, sp), "autda x17, sp"); 515 COMPARE(autdb(x18, x19), "autdb x18, x19"); 516 COMPARE(autdb(x20, sp), "autdb x20, sp"); 517 COMPARE(autiza(x21), "autiza x21"); 518 COMPARE(autizb(x22), "autizb x22"); 519 COMPARE(autdza(x23), "autdza x23"); 520 521 CLEANUP(); 522} 523 524 525TEST(bitfield) { 526 SETUP(); 527 528 COMPARE(sxtb(w0, w1), "sxtb w0, w1"); 529 COMPARE(sxtb(x2, x3), "sxtb x2, w3"); 530 COMPARE(sxth(w4, w5), "sxth w4, w5"); 531 COMPARE(sxth(x6, x7), "sxth x6, w7"); 532 COMPARE(sxtw(x8, x9), "sxtw x8, w9"); 533 COMPARE(sxtb(x0, w1), "sxtb x0, w1"); 534 COMPARE(sxth(x2, w3), "sxth x2, w3"); 535 COMPARE(sxtw(x4, w5), "sxtw x4, w5"); 536 537 COMPARE(uxtb(w10, w11), "uxtb w10, w11"); 538 COMPARE(uxtb(x12, x13), "uxtb x12, w13"); 539 COMPARE(uxth(w14, w15), "uxth w14, w15"); 540 COMPARE(uxth(x16, x17), "uxth x16, w17"); 541 COMPARE(uxtw(x18, x19), "ubfx x18, x19, #0, #32"); 542 543 COMPARE(asr(w20, w21, 10), "asr w20, w21, #10"); 544 COMPARE(asr(x22, x23, 20), "asr x22, x23, #20"); 545 COMPARE(lsr(w24, w25, 10), "lsr w24, w25, #10"); 546 COMPARE(lsr(x26, x27, 20), "lsr x26, x27, #20"); 547 COMPARE(lsl(w28, w29, 10), "lsl w28, w29, #10"); 548 COMPARE(lsl(x30, x0, 20), "lsl x30, x0, #20"); 549 550 COMPARE(sbfiz(w1, w2, 1, 20), "sbfiz w1, w2, #1, #20"); 551 COMPARE(sbfiz(x3, x4, 2, 19), "sbfiz x3, x4, #2, #19"); 552 COMPARE(sbfx(w5, w6, 3, 18), "sbfx w5, w6, #3, #18"); 553 COMPARE(sbfx(x7, x8, 4, 17), "sbfx x7, x8, #4, #17"); 554 COMPARE(bfi(w9, w10, 5, 16), "bfi w9, w10, #5, #16"); 555 COMPARE(bfi(x11, x12, 6, 15), "bfi x11, x12, #6, #15"); 556 COMPARE(bfxil(w13, w14, 7, 14), "bfxil w13, w14, #7, #14"); 557 COMPARE(bfxil(x15, x16, 8, 13), "bfxil x15, x16, #8, #13"); 558 COMPARE(ubfiz(w17, w18, 9, 12), "ubfiz w17, w18, #9, #12"); 559 COMPARE(ubfiz(x19, x20, 10, 11), "ubfiz x19, x20, #10, #11"); 560 COMPARE(ubfx(w21, w22, 11, 10), "ubfx w21, w22, #11, #10"); 561 COMPARE(ubfx(x23, x24, 12, 9), "ubfx x23, x24, #12, #9"); 562 COMPARE(bfc(w25, 13, 8), "bfc w25, #13, #8"); 563 COMPARE(bfc(x26, 14, 7), "bfc x26, #14, #7"); 564 565 CLEANUP(); 566} 567 568TEST(bitfield_regression_test) { 569 SETUP(); 570 571 COMPARE(dci(0x533ae450), "unallocated (Unallocated)"); 572 COMPARE(dci(0x133c464c), "unallocated (Unallocated)"); 573 COMPARE(dci(0x133c4e6d), "unallocated (Unallocated)"); 574 COMPARE(dci(0x133c5e45), "unallocated (Unallocated)"); 575 COMPARE(dci(0x1335853c), "unallocated (Unallocated)"); 576 COMPARE(dci(0x1335a73d), "unallocated (Unallocated)"); 577 578 CLEANUP(); 579} 580 581 582TEST(crc32b) { 583 SETUP(); 584 585 COMPARE(crc32b(w0, w1, w2), "crc32b w0, w1, w2"); 586 COMPARE(crc32b(w0, w11, w22), "crc32b w0, w11, w22"); 587 COMPARE(crc32b(w10, w20, w30), "crc32b w10, w20, w30"); 588 589 CLEANUP(); 590} 591 592 593TEST(crc32h) { 594 SETUP(); 595 596 COMPARE(crc32h(w1, w2, w3), "crc32h w1, w2, w3"); 597 COMPARE(crc32h(w2, w13, w23), "crc32h w2, w13, w23"); 598 COMPARE(crc32h(w11, w12, w15), "crc32h w11, w12, w15"); 599 600 CLEANUP(); 601} 602 603 604TEST(crc32w) { 605 SETUP(); 606 607 COMPARE(crc32w(w2, w3, w4), "crc32w w2, w3, w4"); 608 COMPARE(crc32w(w3, w14, w24), "crc32w w3, w14, w24"); 609 COMPARE(crc32w(w13, w13, w16), "crc32w w13, w13, w16"); 610 611 CLEANUP(); 612} 613 614 615TEST(crc32x) { 616 SETUP(); 617 618 COMPARE(crc32x(w3, w4, x5), "crc32x w3, w4, x5"); 619 COMPARE(crc32x(w4, w15, x25), "crc32x w4, w15, x25"); 620 COMPARE(crc32x(w14, w14, x30), "crc32x w14, w14, x30"); 621 622 CLEANUP(); 623} 624 625 626TEST(crc32cb) { 627 SETUP(); 628 629 COMPARE(crc32cb(w4, w5, w6), "crc32cb w4, w5, w6"); 630 COMPARE(crc32cb(w5, w16, w26), "crc32cb w5, w16, w26"); 631 COMPARE(crc32cb(w15, w15, w5), "crc32cb w15, w15, w5"); 632 633 CLEANUP(); 634} 635 636 637TEST(crc32ch) { 638 SETUP(); 639 640 COMPARE(crc32ch(w5, w6, w7), "crc32ch w5, w6, w7"); 641 COMPARE(crc32ch(w6, w17, w27), "crc32ch w6, w17, w27"); 642 COMPARE(crc32ch(w16, w16, w2), "crc32ch w16, w16, w2"); 643 644 CLEANUP(); 645} 646 647 648TEST(crc32cw) { 649 SETUP(); 650 651 COMPARE(crc32cw(w6, w7, w8), "crc32cw w6, w7, w8"); 652 COMPARE(crc32cw(w7, w18, w28), "crc32cw w7, w18, w28"); 653 COMPARE(crc32cw(w17, w17, w3), "crc32cw w17, w17, w3"); 654 655 CLEANUP(); 656} 657 658 659TEST(crc32cx) { 660 SETUP(); 661 662 COMPARE(crc32cx(w7, w8, x9), "crc32cx w7, w8, x9"); 663 COMPARE(crc32cx(w8, w19, x29), "crc32cx w8, w19, x29"); 664 COMPARE(crc32cx(w18, w18, x4), "crc32cx w18, w18, x4"); 665 666 CLEANUP(); 667} 668 669 670TEST(extract) { 671 SETUP(); 672 673 COMPARE(extr(w0, w1, w2, 0), "extr w0, w1, w2, #0"); 674 COMPARE(extr(x3, x4, x5, 1), "extr x3, x4, x5, #1"); 675 COMPARE(extr(w6, w7, w8, 31), "extr w6, w7, w8, #31"); 676 COMPARE(extr(x9, x10, x11, 63), "extr x9, x10, x11, #63"); 677 COMPARE(extr(w12, w13, w13, 10), "ror w12, w13, #10"); 678 COMPARE(extr(x14, x15, x15, 42), "ror x14, x15, #42"); 679 680 CLEANUP(); 681} 682 683 684TEST(logical_immediate) { 685 SETUP(); 686#define RESULT_SIZE (256) 687 688 char result[RESULT_SIZE]; 689 690 // Test immediate encoding - 64-bit destination. 691 // 64-bit patterns. 692 uint64_t value = 0x7fffffff; 693 for (int i = 0; i < 64; i++) { 694 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); 695 COMPARE(and_(x0, x0, Operand(value)), result); 696 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. 697 } 698 699 // 32-bit patterns. 700 value = 0x00003fff00003fff; 701 for (int i = 0; i < 32; i++) { 702 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); 703 COMPARE(and_(x0, x0, Operand(value)), result); 704 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. 705 } 706 707 // 16-bit patterns. 708 value = 0x001f001f001f001f; 709 for (int i = 0; i < 16; i++) { 710 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); 711 COMPARE(and_(x0, x0, Operand(value)), result); 712 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. 713 } 714 715 // 8-bit patterns. 716 value = 0x0e0e0e0e0e0e0e0e; 717 for (int i = 0; i < 8; i++) { 718 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); 719 COMPARE(and_(x0, x0, Operand(value)), result); 720 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. 721 } 722 723 // 4-bit patterns. 724 value = 0x6666666666666666; 725 for (int i = 0; i < 4; i++) { 726 snprintf(result, RESULT_SIZE, "and x0, x0, #0x%" PRIx64, value); 727 COMPARE(and_(x0, x0, Operand(value)), result); 728 value = ((value & 1) << 63) | (value >> 1); // Rotate right 1 bit. 729 } 730 731 // 2-bit patterns. 732 COMPARE(and_(x0, x0, Operand(0x5555555555555555)), 733 "and x0, x0, #0x5555555555555555"); 734 COMPARE(and_(x0, x0, Operand(0xaaaaaaaaaaaaaaaa)), 735 "and x0, x0, #0xaaaaaaaaaaaaaaaa"); 736 737 // Test immediate encoding - 32-bit destination. 738 COMPARE(and_(w0, w0, Operand(0xff8007ff)), 739 "and w0, w0, #0xff8007ff"); // 32-bit pattern. 740 COMPARE(and_(w0, w0, Operand(0xf87ff87f)), 741 "and w0, w0, #0xf87ff87f"); // 16-bit pattern. 742 COMPARE(and_(w0, w0, Operand(0x87878787)), 743 "and w0, w0, #0x87878787"); // 8-bit pattern. 744 COMPARE(and_(w0, w0, Operand(0x66666666)), 745 "and w0, w0, #0x66666666"); // 4-bit pattern. 746 COMPARE(and_(w0, w0, Operand(0x55555555)), 747 "and w0, w0, #0x55555555"); // 2-bit pattern. 748 749 // Test other instructions. 750 COMPARE(tst(w1, Operand(0x11111111)), "tst w1, #0x11111111"); 751 COMPARE(tst(x2, Operand(0x8888888888888888)), "tst x2, #0x8888888888888888"); 752 COMPARE(orr(w7, w8, Operand(0xaaaaaaaa)), "orr w7, w8, #0xaaaaaaaa"); 753 COMPARE(orr(x9, x10, Operand(0x5555555555555555)), 754 "orr x9, x10, #0x5555555555555555"); 755 COMPARE(eor(w15, w16, Operand(0x00000001)), "eor w15, w16, #0x1"); 756 COMPARE(eor(x17, x18, Operand(0x0000000000000003)), "eor x17, x18, #0x3"); 757 COMPARE(ands(w23, w24, Operand(0x0000000f)), "ands w23, w24, #0xf"); 758 COMPARE(ands(x25, x26, Operand(0x800000000000000f)), 759 "ands x25, x26, #0x800000000000000f"); 760 761 // Test inverse. 762 COMPARE(bic(w3, w4, Operand(0x20202020)), "and w3, w4, #0xdfdfdfdf"); 763 COMPARE(bic(x5, x6, Operand(0x4040404040404040)), 764 "and x5, x6, #0xbfbfbfbfbfbfbfbf"); 765 COMPARE(orn(w11, w12, Operand(0x40004000)), "orr w11, w12, #0xbfffbfff"); 766 COMPARE(orn(x13, x14, Operand(0x8181818181818181)), 767 "orr x13, x14, #0x7e7e7e7e7e7e7e7e"); 768 COMPARE(eon(w19, w20, Operand(0x80000001)), "eor w19, w20, #0x7ffffffe"); 769 COMPARE(eon(x21, x22, Operand(0xc000000000000003)), 770 "eor x21, x22, #0x3ffffffffffffffc"); 771 COMPARE(bics(w27, w28, Operand(0xfffffff7)), "ands w27, w28, #0x8"); 772 COMPARE(bics(x29, x0, Operand(0xfffffffeffffffff)), 773 "ands x29, x0, #0x100000000"); 774 775 // Test stack pointer. 776 COMPARE(and_(wsp, wzr, Operand(7)), "and wsp, wzr, #0x7"); 777 COMPARE(ands(xzr, xzr, Operand(7)), "tst xzr, #0x7"); 778 COMPARE(orr(sp, xzr, Operand(15)), "orr sp, xzr, #0xf"); 779 COMPARE(eor(wsp, w0, Operand(31)), "eor wsp, w0, #0x1f"); 780 781 // Test move aliases. 782 COMPARE(orr(w0, wzr, Operand(0x00000780)), "orr w0, wzr, #0x780"); 783 COMPARE(orr(w1, wzr, Operand(0x00007800)), "orr w1, wzr, #0x7800"); 784 COMPARE(orr(w2, wzr, Operand(0x00078000)), "mov w2, #0x78000"); 785 COMPARE(orr(w3, wzr, Operand(0x00780000)), "orr w3, wzr, #0x780000"); 786 COMPARE(orr(w4, wzr, Operand(0x07800000)), "orr w4, wzr, #0x7800000"); 787 COMPARE(orr(x5, xzr, Operand(0xffffffffffffc001)), 788 "orr x5, xzr, #0xffffffffffffc001"); 789 COMPARE(orr(x6, xzr, Operand(0xfffffffffffc001f)), 790 "mov x6, #0xfffffffffffc001f"); 791 COMPARE(orr(x7, xzr, Operand(0xffffffffffc001ff)), 792 "mov x7, #0xffffffffffc001ff"); 793 COMPARE(orr(x8, xzr, Operand(0xfffffffffc001fff)), 794 "mov x8, #0xfffffffffc001fff"); 795 COMPARE(orr(x9, xzr, Operand(0xffffffffc001ffff)), 796 "orr x9, xzr, #0xffffffffc001ffff"); 797 798 CLEANUP(); 799} 800 801 802TEST(logical_shifted) { 803 SETUP(); 804 805 COMPARE(and_(w0, w1, Operand(w2)), "and w0, w1, w2"); 806 COMPARE(and_(x3, x4, Operand(x5, LSL, 1)), "and x3, x4, x5, lsl #1"); 807 COMPARE(and_(w6, w7, Operand(w8, LSR, 2)), "and w6, w7, w8, lsr #2"); 808 COMPARE(and_(x9, x10, Operand(x11, ASR, 3)), "and x9, x10, x11, asr #3"); 809 COMPARE(and_(w12, w13, Operand(w14, ROR, 4)), "and w12, w13, w14, ror #4"); 810 811 COMPARE(bic(w15, w16, Operand(w17)), "bic w15, w16, w17"); 812 COMPARE(bic(x18, x19, Operand(x20, LSL, 5)), "bic x18, x19, x20, lsl #5"); 813 COMPARE(bic(w21, w22, Operand(w23, LSR, 6)), "bic w21, w22, w23, lsr #6"); 814 COMPARE(bic(x24, x25, Operand(x26, ASR, 7)), "bic x24, x25, x26, asr #7"); 815 COMPARE(bic(w27, w28, Operand(w29, ROR, 8)), "bic w27, w28, w29, ror #8"); 816 817 COMPARE(orr(w0, w1, Operand(w2)), "orr w0, w1, w2"); 818 COMPARE(orr(x3, x4, Operand(x5, LSL, 9)), "orr x3, x4, x5, lsl #9"); 819 COMPARE(orr(w6, w7, Operand(w8, LSR, 10)), "orr w6, w7, w8, lsr #10"); 820 COMPARE(orr(x9, x10, Operand(x11, ASR, 11)), "orr x9, x10, x11, asr #11"); 821 COMPARE(orr(w12, w13, Operand(w14, ROR, 12)), "orr w12, w13, w14, ror #12"); 822 823 COMPARE(orn(w15, w16, Operand(w17)), "orn w15, w16, w17"); 824 COMPARE(orn(x18, x19, Operand(x20, LSL, 13)), "orn x18, x19, x20, lsl #13"); 825 COMPARE(orn(w21, w22, Operand(w23, LSR, 14)), "orn w21, w22, w23, lsr #14"); 826 COMPARE(orn(x24, x25, Operand(x26, ASR, 15)), "orn x24, x25, x26, asr #15"); 827 COMPARE(orn(w27, w28, Operand(w29, ROR, 16)), "orn w27, w28, w29, ror #16"); 828 829 COMPARE(eor(w0, w1, Operand(w2)), "eor w0, w1, w2"); 830 COMPARE(eor(x3, x4, Operand(x5, LSL, 17)), "eor x3, x4, x5, lsl #17"); 831 COMPARE(eor(w6, w7, Operand(w8, LSR, 18)), "eor w6, w7, w8, lsr #18"); 832 COMPARE(eor(x9, x10, Operand(x11, ASR, 19)), "eor x9, x10, x11, asr #19"); 833 COMPARE(eor(w12, w13, Operand(w14, ROR, 20)), "eor w12, w13, w14, ror #20"); 834 835 COMPARE(eon(w15, w16, Operand(w17)), "eon w15, w16, w17"); 836 COMPARE(eon(x18, x19, Operand(x20, LSL, 21)), "eon x18, x19, x20, lsl #21"); 837 COMPARE(eon(w21, w22, Operand(w23, LSR, 22)), "eon w21, w22, w23, lsr #22"); 838 COMPARE(eon(x24, x25, Operand(x26, ASR, 23)), "eon x24, x25, x26, asr #23"); 839 COMPARE(eon(w27, w28, Operand(w29, ROR, 24)), "eon w27, w28, w29, ror #24"); 840 841 COMPARE(ands(w0, w1, Operand(w2)), "ands w0, w1, w2"); 842 COMPARE(ands(x3, x4, Operand(x5, LSL, 1)), "ands x3, x4, x5, lsl #1"); 843 COMPARE(ands(w6, w7, Operand(w8, LSR, 2)), "ands w6, w7, w8, lsr #2"); 844 COMPARE(ands(x9, x10, Operand(x11, ASR, 3)), "ands x9, x10, x11, asr #3"); 845 COMPARE(ands(w12, w13, Operand(w14, ROR, 4)), "ands w12, w13, w14, ror #4"); 846 847 COMPARE(bics(w15, w16, Operand(w17)), "bics w15, w16, w17"); 848 COMPARE(bics(x18, x19, Operand(x20, LSL, 5)), "bics x18, x19, x20, lsl #5"); 849 COMPARE(bics(w21, w22, Operand(w23, LSR, 6)), "bics w21, w22, w23, lsr #6"); 850 COMPARE(bics(x24, x25, Operand(x26, ASR, 7)), "bics x24, x25, x26, asr #7"); 851 COMPARE(bics(w27, w28, Operand(w29, ROR, 8)), "bics w27, w28, w29, ror #8"); 852 853 COMPARE(tst(w0, Operand(w1)), "tst w0, w1"); 854 COMPARE(tst(w2, Operand(w3, ROR, 10)), "tst w2, w3, ror #10"); 855 COMPARE(tst(x0, Operand(x1)), "tst x0, x1"); 856 COMPARE(tst(x2, Operand(x3, ROR, 42)), "tst x2, x3, ror #42"); 857 858 COMPARE(orn(w0, wzr, Operand(w1)), "mvn w0, w1"); 859 COMPARE(orn(w2, wzr, Operand(w3, ASR, 5)), "mvn w2, w3, asr #5"); 860 COMPARE(orn(x0, xzr, Operand(x1)), "mvn x0, x1"); 861 COMPARE(orn(x2, xzr, Operand(x3, ASR, 42)), "mvn x2, x3, asr #42"); 862 863 COMPARE(orr(w0, wzr, Operand(w1)), "mov w0, w1"); 864 COMPARE(orr(x0, xzr, Operand(x1)), "mov x0, x1"); 865 COMPARE(orr(w16, wzr, Operand(w17, LSL, 1)), "orr w16, wzr, w17, lsl #1"); 866 COMPARE(orr(x16, xzr, Operand(x17, ASR, 2)), "orr x16, xzr, x17, asr #2"); 867 868 CLEANUP(); 869} 870 871 872TEST(dp_2_source) { 873 SETUP(); 874 875 COMPARE(lslv(w0, w1, w2), "lsl w0, w1, w2"); 876 COMPARE(lslv(x3, x4, x5), "lsl x3, x4, x5"); 877 COMPARE(lsrv(w6, w7, w8), "lsr w6, w7, w8"); 878 COMPARE(lsrv(x9, x10, x11), "lsr x9, x10, x11"); 879 COMPARE(asrv(w12, w13, w14), "asr w12, w13, w14"); 880 COMPARE(asrv(x15, x16, x17), "asr x15, x16, x17"); 881 COMPARE(rorv(w18, w19, w20), "ror w18, w19, w20"); 882 COMPARE(rorv(x21, x22, x23), "ror x21, x22, x23"); 883 COMPARE(pacga(x24, x25, x26), "pacga x24, x25, x26"); 884 COMPARE(pacga(x27, x28, sp), "pacga x27, x28, sp"); 885 886 CLEANUP(); 887} 888 889 890TEST(adr) { 891 SETUP(); 892 893 COMPARE_PREFIX(adr(x0, INT64_C(0)), "adr x0, #+0x0"); 894 COMPARE_PREFIX(adr(x1, 1), "adr x1, #+0x1"); 895 COMPARE_PREFIX(adr(x2, -1), "adr x2, #-0x1"); 896 COMPARE_PREFIX(adr(x3, 4), "adr x3, #+0x4"); 897 COMPARE_PREFIX(adr(x4, -4), "adr x4, #-0x4"); 898 COMPARE_PREFIX(adr(x5, 0x000fffff), "adr x5, #+0xfffff"); 899 COMPARE_PREFIX(adr(x6, -0x00100000), "adr x6, #-0x100000"); 900 COMPARE_PREFIX(adr(xzr, INT64_C(0)), "adr xzr, #+0x0"); 901 902 CLEANUP(); 903} 904 905 906TEST(adrp) { 907 SETUP(); 908 909 COMPARE_PREFIX(adrp(x0, INT64_C(0)), "adrp x0, #+0x0"); 910 COMPARE_PREFIX(adrp(x1, 1), "adrp x1, #+0x1000"); 911 COMPARE_PREFIX(adrp(x2, -1), "adrp x2, #-0x1000"); 912 COMPARE_PREFIX(adrp(x3, 4), "adrp x3, #+0x4000"); 913 COMPARE_PREFIX(adrp(x4, -4), "adrp x4, #-0x4000"); 914 COMPARE_PREFIX(adrp(x5, 0x000fffff), "adrp x5, #+0xfffff000"); 915 COMPARE_PREFIX(adrp(x6, -0x00100000), "adrp x6, #-0x100000000"); 916 COMPARE_PREFIX(adrp(xzr, INT64_C(0)), "adrp xzr, #+0x0"); 917 918 CLEANUP(); 919} 920 921 922TEST(branch) { 923 SETUP(); 924 925#define INST_OFF(x) (INT64_C(x) >> kInstructionSizeLog2) 926 COMPARE_PREFIX(b(INST_OFF(0x4)), "b #+0x4"); 927 COMPARE_PREFIX(b(INST_OFF(-0x4)), "b #-0x4"); 928 COMPARE_PREFIX(b(INST_OFF(0x7fffffc)), "b #+0x7fffffc"); 929 COMPARE_PREFIX(b(INST_OFF(-0x8000000)), "b #-0x8000000"); 930 COMPARE_PREFIX(b(INST_OFF(0xffffc), eq), "b.eq #+0xffffc"); 931 COMPARE_PREFIX(b(INST_OFF(-0x100000), mi), "b.mi #-0x100000"); 932 COMPARE_PREFIX(b(INST_OFF(0xffffc), al), "b.al #+0xffffc"); 933 COMPARE_PREFIX(b(INST_OFF(-0x100000), nv), "b.nv #-0x100000"); 934 COMPARE_PREFIX(bl(INST_OFF(0x4)), "bl #+0x4"); 935 COMPARE_PREFIX(bl(INST_OFF(-0x4)), "bl #-0x4"); 936 COMPARE_PREFIX(bl(INST_OFF(0xffffc)), "bl #+0xffffc"); 937 COMPARE_PREFIX(bl(INST_OFF(-0x100000)), "bl #-0x100000"); 938 COMPARE_PREFIX(cbz(w0, INST_OFF(0xffffc)), "cbz w0, #+0xffffc"); 939 COMPARE_PREFIX(cbz(x1, INST_OFF(-0x100000)), "cbz x1, #-0x100000"); 940 COMPARE_PREFIX(cbnz(w2, INST_OFF(0xffffc)), "cbnz w2, #+0xffffc"); 941 COMPARE_PREFIX(cbnz(x3, INST_OFF(-0x100000)), "cbnz x3, #-0x100000"); 942 COMPARE_PREFIX(tbz(w4, 0, INST_OFF(0x7ffc)), "tbz w4, #0, #+0x7ffc"); 943 COMPARE_PREFIX(tbz(x5, 63, INST_OFF(-0x8000)), "tbz x5, #63, #-0x8000"); 944 COMPARE_PREFIX(tbz(w6, 31, INST_OFF(0)), "tbz w6, #31, #+0x0"); 945 COMPARE_PREFIX(tbz(x7, 31, INST_OFF(0x4)), "tbz w7, #31, #+0x4"); 946 COMPARE_PREFIX(tbz(x8, 32, INST_OFF(0x8)), "tbz x8, #32, #+0x8"); 947 COMPARE_PREFIX(tbnz(w8, 0, INST_OFF(0x7ffc)), "tbnz w8, #0, #+0x7ffc"); 948 COMPARE_PREFIX(tbnz(x9, 63, INST_OFF(-0x8000)), "tbnz x9, #63, #-0x8000"); 949 COMPARE_PREFIX(tbnz(w10, 31, INST_OFF(0)), "tbnz w10, #31, #+0x0"); 950 COMPARE_PREFIX(tbnz(x11, 31, INST_OFF(0x4)), "tbnz w11, #31, #+0x4"); 951 COMPARE_PREFIX(tbnz(x12, 32, INST_OFF(0x8)), "tbnz x12, #32, #+0x8"); 952 COMPARE(br(x0), "br x0"); 953 COMPARE(blr(x1), "blr x1"); 954 COMPARE(ret(x2), "ret x2"); 955 COMPARE(ret(lr), "ret"); 956 957 COMPARE(braaz(x0), "braaz x0"); 958 COMPARE(brabz(x1), "brabz x1"); 959 COMPARE(blraaz(x2), "blraaz x2"); 960 COMPARE(blrabz(x3), "blrabz x3"); 961 COMPARE(retaa(), "retaa"); 962 COMPARE(retab(), "retab"); 963 COMPARE(braa(x4, x5), "braa x4, x5"); 964 COMPARE(braa(x6, sp), "braa x6, sp"); 965 COMPARE(brab(x7, x8), "brab x7, x8"); 966 COMPARE(brab(x9, sp), "brab x9, sp"); 967 COMPARE(blraa(x10, x11), "blraa x10, x11"); 968 COMPARE(blraa(x12, sp), "blraa x12, sp"); 969 COMPARE(blrab(x13, x14), "blrab x13, x14"); 970 COMPARE(blrab(x15, sp), "blrab x15, sp"); 971 972 CLEANUP(); 973} 974 975TEST(mte_load_store) { 976 SETUP(); 977 978 COMPARE(ldg(x0, MemOperand(sp)), "ldg x0, [sp]"); 979 COMPARE(ldg(x22, MemOperand(x3, 32)), "ldg x22, [x3, #32]"); 980 COMPARE(st2g(x3, MemOperand(sp)), "st2g x3, [sp]"); 981 COMPARE(st2g(sp, MemOperand(sp, -320)), "st2g sp, [sp, #-320]"); 982 COMPARE(st2g(x30, MemOperand(x4, 160, PreIndex)), "st2g x30, [x4, #160]!"); 983 COMPARE(st2g(x22, MemOperand(x24, 1600, PostIndex)), 984 "st2g x22, [x24], #1600"); 985 COMPARE(stg(x0, MemOperand(x1)), "stg x0, [x1]"); 986 COMPARE(stg(x2, MemOperand(x3, 16)), "stg x2, [x3, #16]"); 987 COMPARE(stg(sp, MemOperand(x1, -16, PreIndex)), "stg sp, [x1, #-16]!"); 988 COMPARE(stg(x4, MemOperand(sp, -256, PostIndex)), "stg x4, [sp], #-256"); 989 COMPARE(stgp(x29, x14, MemOperand(sp)), "stgp x29, x14, [sp]"); 990 COMPARE(stgp(x3, x4, MemOperand(x3, -1024)), "stgp x3, x4, [x3, #-1024]"); 991 COMPARE(stgp(x17, x7, MemOperand(x18, -64, PreIndex)), 992 "stgp x17, x7, [x18, #-64]!"); 993 COMPARE(stgp(x5, x21, MemOperand(sp, 1008, PostIndex)), 994 "stgp x5, x21, [sp], #1008"); 995 COMPARE(stzg(x20, MemOperand(x1)), "stzg x20, [x1]"); 996 COMPARE(stzg(x22, MemOperand(x3, -32)), "stzg x22, [x3, #-32]"); 997 COMPARE(stzg(sp, MemOperand(x1, 32, PreIndex)), "stzg sp, [x1, #32]!"); 998 COMPARE(stzg(x5, MemOperand(sp, -2560, PostIndex)), "stzg x5, [sp], #-2560"); 999 COMPARE(stz2g(x6, MemOperand(x21)), "stz2g x6, [x21]"); 1000 COMPARE(stz2g(x18, MemOperand(x13, 16)), "stz2g x18, [x13, #16]"); 1001 COMPARE(stz2g(sp, MemOperand(sp, -384, PreIndex)), "stz2g sp, [sp, #-384]!"); 1002 COMPARE(stz2g(sp, MemOperand(x7, -256, PostIndex)), "stz2g sp, [x7], #-256"); 1003 1004 COMPARE_MACRO(Ldg(x10, MemOperand(x17)), "ldg x10, [x17]"); 1005 COMPARE_MACRO(Ldg(x15, MemOperand(sp, -4096)), "ldg x15, [sp, #-4096]"); 1006 COMPARE_MACRO(St2g(x3, MemOperand(x15)), "st2g x3, [x15]"); 1007 COMPARE_MACRO(St2g(sp, MemOperand(sp, -1600)), "st2g sp, [sp, #-1600]"); 1008 COMPARE_MACRO(St2g(x30, MemOperand(x4, 3216, PreIndex)), 1009 "st2g x30, [x4, #3216]!"); 1010 COMPARE_MACRO(St2g(x18, MemOperand(x2, 352, PostIndex)), 1011 "st2g x18, [x2], #352"); 1012 COMPARE_MACRO(Stg(x10, MemOperand(x17)), "stg x10, [x17]"); 1013 COMPARE_MACRO(Stg(sp, MemOperand(x3, -4096)), "stg sp, [x3, #-4096]"); 1014 COMPARE_MACRO(Stg(sp, MemOperand(sp, 4080, PreIndex)), 1015 "stg sp, [sp, #4080]!"); 1016 COMPARE_MACRO(Stg(x14, MemOperand(x20, 1024, PostIndex)), 1017 "stg x14, [x20], #1024"); 1018 COMPARE_MACRO(Stgp(x3, x5, MemOperand(x7)), "stgp x3, x5, [x7]"); 1019 COMPARE_MACRO(Stgp(x8, x4, MemOperand(x2, -496)), "stgp x8, x4, [x2, #-496]"); 1020 COMPARE_MACRO(Stgp(x27, x7, MemOperand(sp, -672, PreIndex)), 1021 "stgp x27, x7, [sp, #-672]!"); 1022 COMPARE_MACRO(Stgp(x14, x16, MemOperand(x0, 576, PostIndex)), 1023 "stgp x14, x16, [x0], #576"); 1024 COMPARE_MACRO(Stz2g(x22, MemOperand(x12)), "stz2g x22, [x12]"); 1025 COMPARE_MACRO(Stz2g(sp, MemOperand(sp, -704)), "stz2g sp, [sp, #-704]"); 1026 COMPARE_MACRO(Stz2g(x3, MemOperand(x4, 272, PreIndex)), 1027 "stz2g x3, [x4, #272]!"); 1028 COMPARE_MACRO(Stz2g(sp, MemOperand(sp, 1024, PostIndex)), 1029 "stz2g sp, [sp], #1024"); 1030 COMPARE_MACRO(Stzg(x17, MemOperand(x11)), "stzg x17, [x11]"); 1031 COMPARE_MACRO(Stzg(x29, MemOperand(x3, -3552)), "stzg x29, [x3, #-3552]"); 1032 COMPARE_MACRO(Stzg(x2, MemOperand(x15, 784, PreIndex)), 1033 "stzg x2, [x15, #784]!"); 1034 COMPARE_MACRO(Stzg(x8, MemOperand(x3, 1488, PostIndex)), 1035 "stzg x8, [x3], #1488"); 1036 CLEANUP(); 1037} 1038 1039TEST(load_store) { 1040 SETUP(); 1041 1042 COMPARE(ldr(w0, MemOperand(x1)), "ldr w0, [x1]"); 1043 COMPARE(ldr(w2, MemOperand(x3, 4)), "ldr w2, [x3, #4]"); 1044 COMPARE(ldr(w4, MemOperand(x5, 16380)), "ldr w4, [x5, #16380]"); 1045 COMPARE(ldr(x6, MemOperand(x7)), "ldr x6, [x7]"); 1046 COMPARE(ldr(x8, MemOperand(x9, 8)), "ldr x8, [x9, #8]"); 1047 COMPARE(ldr(x10, MemOperand(x11, 32760)), "ldr x10, [x11, #32760]"); 1048 COMPARE(str(w12, MemOperand(x13)), "str w12, [x13]"); 1049 COMPARE(str(w14, MemOperand(x15, 4)), "str w14, [x15, #4]"); 1050 COMPARE(str(w16, MemOperand(x17, 16380)), "str w16, [x17, #16380]"); 1051 COMPARE(str(x18, MemOperand(x19)), "str x18, [x19]"); 1052 COMPARE(str(x20, MemOperand(x21, 8)), "str x20, [x21, #8]"); 1053 COMPARE(str(x22, MemOperand(x23, 32760)), "str x22, [x23, #32760]"); 1054 1055 COMPARE(ldr(w0, MemOperand(x1, 4, PreIndex)), "ldr w0, [x1, #4]!"); 1056 COMPARE(ldr(w2, MemOperand(x3, 255, PreIndex)), "ldr w2, [x3, #255]!"); 1057 COMPARE(ldr(w4, MemOperand(x5, -256, PreIndex)), "ldr w4, [x5, #-256]!"); 1058 COMPARE(ldr(x6, MemOperand(x7, 8, PreIndex)), "ldr x6, [x7, #8]!"); 1059 COMPARE(ldr(x8, MemOperand(x9, 255, PreIndex)), "ldr x8, [x9, #255]!"); 1060 COMPARE(ldr(x10, MemOperand(x11, -256, PreIndex)), "ldr x10, [x11, #-256]!"); 1061 COMPARE(str(w12, MemOperand(x13, 4, PreIndex)), "str w12, [x13, #4]!"); 1062 COMPARE(str(w14, MemOperand(x15, 255, PreIndex)), "str w14, [x15, #255]!"); 1063 COMPARE(str(w16, MemOperand(x17, -256, PreIndex)), "str w16, [x17, #-256]!"); 1064 COMPARE(str(x18, MemOperand(x19, 8, PreIndex)), "str x18, [x19, #8]!"); 1065 COMPARE(str(x20, MemOperand(x21, 255, PreIndex)), "str x20, [x21, #255]!"); 1066 COMPARE(str(x22, MemOperand(x23, -256, PreIndex)), "str x22, [x23, #-256]!"); 1067 COMPARE(str(x24, MemOperand(x25, 0, PreIndex)), "str x24, [x25, #0]!"); 1068 COMPARE(str(w26, MemOperand(x27, 0, PreIndex)), "str w26, [x27, #0]!"); 1069 1070 COMPARE(ldr(w0, MemOperand(x1, 4, PostIndex)), "ldr w0, [x1], #4"); 1071 COMPARE(ldr(w2, MemOperand(x3, 255, PostIndex)), "ldr w2, [x3], #255"); 1072 COMPARE(ldr(w4, MemOperand(x5, -256, PostIndex)), "ldr w4, [x5], #-256"); 1073 COMPARE(ldr(x6, MemOperand(x7, 8, PostIndex)), "ldr x6, [x7], #8"); 1074 COMPARE(ldr(x8, MemOperand(x9, 255, PostIndex)), "ldr x8, [x9], #255"); 1075 COMPARE(ldr(x10, MemOperand(x11, -256, PostIndex)), "ldr x10, [x11], #-256"); 1076 COMPARE(str(w12, MemOperand(x13, 4, PostIndex)), "str w12, [x13], #4"); 1077 COMPARE(str(w14, MemOperand(x15, 255, PostIndex)), "str w14, [x15], #255"); 1078 COMPARE(str(w16, MemOperand(x17, -256, PostIndex)), "str w16, [x17], #-256"); 1079 COMPARE(str(x18, MemOperand(x19, 8, PostIndex)), "str x18, [x19], #8"); 1080 COMPARE(str(x20, MemOperand(x21, 255, PostIndex)), "str x20, [x21], #255"); 1081 COMPARE(str(x22, MemOperand(x23, -256, PostIndex)), "str x22, [x23], #-256"); 1082 COMPARE(str(x24, MemOperand(x25, 0, PostIndex)), "str x24, [x25], #0"); 1083 COMPARE(str(w26, MemOperand(x27, 0, PostIndex)), "str w26, [x27], #0"); 1084 1085 COMPARE(ldr(w24, MemOperand(sp)), "ldr w24, [sp]"); 1086 COMPARE(ldr(x25, MemOperand(sp, 8)), "ldr x25, [sp, #8]"); 1087 COMPARE(str(w26, MemOperand(sp, 4, PreIndex)), "str w26, [sp, #4]!"); 1088 COMPARE(str(x27, MemOperand(sp, -8, PostIndex)), "str x27, [sp], #-8"); 1089 1090 COMPARE(ldrsw(x0, MemOperand(x1)), "ldrsw x0, [x1]"); 1091 COMPARE(ldrsw(x2, MemOperand(x3, 8)), "ldrsw x2, [x3, #8]"); 1092 COMPARE(ldrsw(x4, MemOperand(x5, 42, PreIndex)), "ldrsw x4, [x5, #42]!"); 1093 COMPARE(ldrsw(x6, MemOperand(x7, -11, PostIndex)), "ldrsw x6, [x7], #-11"); 1094 1095 CLEANUP(); 1096} 1097 1098 1099TEST(load_store_regoffset) { 1100 SETUP(); 1101 1102 COMPARE(ldr(w0, MemOperand(x1, w2, UXTW)), "ldr w0, [x1, w2, uxtw]"); 1103 COMPARE(ldr(w3, MemOperand(x4, w5, UXTW, 2)), "ldr w3, [x4, w5, uxtw #2]"); 1104 COMPARE(ldr(w6, MemOperand(x7, x8)), "ldr w6, [x7, x8]"); 1105 COMPARE(ldr(w9, MemOperand(x10, x11, LSL, 2)), "ldr w9, [x10, x11, lsl #2]"); 1106 COMPARE(ldr(w12, MemOperand(x13, w14, SXTW)), "ldr w12, [x13, w14, sxtw]"); 1107 COMPARE(ldr(w15, MemOperand(x16, w17, SXTW, 2)), 1108 "ldr w15, [x16, w17, sxtw #2]"); 1109 COMPARE(ldr(w18, MemOperand(x19, x20, SXTX)), "ldr w18, [x19, x20, sxtx]"); 1110 COMPARE(ldr(w21, MemOperand(x22, x23, SXTX, 2)), 1111 "ldr w21, [x22, x23, sxtx #2]"); 1112 COMPARE(ldr(x0, MemOperand(x1, w2, UXTW)), "ldr x0, [x1, w2, uxtw]"); 1113 COMPARE(ldr(x3, MemOperand(x4, w5, UXTW, 3)), "ldr x3, [x4, w5, uxtw #3]"); 1114 COMPARE(ldr(x6, MemOperand(x7, x8)), "ldr x6, [x7, x8]"); 1115 COMPARE(ldr(x9, MemOperand(x10, x11, LSL, 3)), "ldr x9, [x10, x11, lsl #3]"); 1116 COMPARE(ldr(x12, MemOperand(x13, w14, SXTW)), "ldr x12, [x13, w14, sxtw]"); 1117 COMPARE(ldr(x15, MemOperand(x16, w17, SXTW, 3)), 1118 "ldr x15, [x16, w17, sxtw #3]"); 1119 COMPARE(ldr(x18, MemOperand(x19, x20, SXTX)), "ldr x18, [x19, x20, sxtx]"); 1120 COMPARE(ldr(x21, MemOperand(x22, x23, SXTX, 3)), 1121 "ldr x21, [x22, x23, sxtx #3]"); 1122 1123 COMPARE(str(w0, MemOperand(x1, w2, UXTW)), "str w0, [x1, w2, uxtw]"); 1124 COMPARE(str(w3, MemOperand(x4, w5, UXTW, 2)), "str w3, [x4, w5, uxtw #2]"); 1125 COMPARE(str(w6, MemOperand(x7, x8)), "str w6, [x7, x8]"); 1126 COMPARE(str(w9, MemOperand(x10, x11, LSL, 2)), "str w9, [x10, x11, lsl #2]"); 1127 COMPARE(str(w12, MemOperand(x13, w14, SXTW)), "str w12, [x13, w14, sxtw]"); 1128 COMPARE(str(w15, MemOperand(x16, w17, SXTW, 2)), 1129 "str w15, [x16, w17, sxtw #2]"); 1130 COMPARE(str(w18, MemOperand(x19, x20, SXTX)), "str w18, [x19, x20, sxtx]"); 1131 COMPARE(str(w21, MemOperand(x22, x23, SXTX, 2)), 1132 "str w21, [x22, x23, sxtx #2]"); 1133 COMPARE(str(x0, MemOperand(x1, w2, UXTW)), "str x0, [x1, w2, uxtw]"); 1134 COMPARE(str(x3, MemOperand(x4, w5, UXTW, 3)), "str x3, [x4, w5, uxtw #3]"); 1135 COMPARE(str(x6, MemOperand(x7, x8)), "str x6, [x7, x8]"); 1136 COMPARE(str(x9, MemOperand(x10, x11, LSL, 3)), "str x9, [x10, x11, lsl #3]"); 1137 COMPARE(str(x12, MemOperand(x13, w14, SXTW)), "str x12, [x13, w14, sxtw]"); 1138 COMPARE(str(x15, MemOperand(x16, w17, SXTW, 3)), 1139 "str x15, [x16, w17, sxtw #3]"); 1140 COMPARE(str(x18, MemOperand(x19, x20, SXTX)), "str x18, [x19, x20, sxtx]"); 1141 COMPARE(str(x21, MemOperand(x22, x23, SXTX, 3)), 1142 "str x21, [x22, x23, sxtx #3]"); 1143 1144 COMPARE(ldrb(w0, MemOperand(x1, w2, UXTW)), "ldrb w0, [x1, w2, uxtw]"); 1145 COMPARE(ldrb(w6, MemOperand(x7, x8)), "ldrb w6, [x7, x8]"); 1146 COMPARE(ldrb(w12, MemOperand(x13, w14, SXTW)), "ldrb w12, [x13, w14, sxtw]"); 1147 COMPARE(ldrb(w18, MemOperand(x19, x20, SXTX)), "ldrb w18, [x19, x20, sxtx]"); 1148 COMPARE(strb(w0, MemOperand(x1, w2, UXTW)), "strb w0, [x1, w2, uxtw]"); 1149 COMPARE(strb(w6, MemOperand(x7, x8)), "strb w6, [x7, x8]"); 1150 COMPARE(strb(w12, MemOperand(x13, w14, SXTW)), "strb w12, [x13, w14, sxtw]"); 1151 COMPARE(strb(w18, MemOperand(x19, x20, SXTX)), "strb w18, [x19, x20, sxtx]"); 1152 1153 COMPARE(ldrh(w0, MemOperand(x1, w2, UXTW)), "ldrh w0, [x1, w2, uxtw]"); 1154 COMPARE(ldrh(w3, MemOperand(x4, w5, UXTW, 1)), "ldrh w3, [x4, w5, uxtw #1]"); 1155 COMPARE(ldrh(w6, MemOperand(x7, x8)), "ldrh w6, [x7, x8]"); 1156 COMPARE(ldrh(w9, MemOperand(x10, x11, LSL, 1)), 1157 "ldrh w9, [x10, x11, lsl #1]"); 1158 COMPARE(ldrh(w12, MemOperand(x13, w14, SXTW)), "ldrh w12, [x13, w14, sxtw]"); 1159 COMPARE(ldrh(w15, MemOperand(x16, w17, SXTW, 1)), 1160 "ldrh w15, [x16, w17, sxtw #1]"); 1161 COMPARE(ldrh(w18, MemOperand(x19, x20, SXTX)), "ldrh w18, [x19, x20, sxtx]"); 1162 COMPARE(ldrh(w21, MemOperand(x22, x23, SXTX, 1)), 1163 "ldrh w21, [x22, x23, sxtx #1]"); 1164 COMPARE(strh(w0, MemOperand(x1, w2, UXTW)), "strh w0, [x1, w2, uxtw]"); 1165 COMPARE(strh(w3, MemOperand(x4, w5, UXTW, 1)), "strh w3, [x4, w5, uxtw #1]"); 1166 COMPARE(strh(w6, MemOperand(x7, x8)), "strh w6, [x7, x8]"); 1167 COMPARE(strh(w9, MemOperand(x10, x11, LSL, 1)), 1168 "strh w9, [x10, x11, lsl #1]"); 1169 COMPARE(strh(w12, MemOperand(x13, w14, SXTW)), "strh w12, [x13, w14, sxtw]"); 1170 COMPARE(strh(w15, MemOperand(x16, w17, SXTW, 1)), 1171 "strh w15, [x16, w17, sxtw #1]"); 1172 COMPARE(strh(w18, MemOperand(x19, x20, SXTX)), "strh w18, [x19, x20, sxtx]"); 1173 COMPARE(strh(w21, MemOperand(x22, x23, SXTX, 1)), 1174 "strh w21, [x22, x23, sxtx #1]"); 1175 1176 COMPARE(ldr(x0, MemOperand(sp, wzr, SXTW)), "ldr x0, [sp, wzr, sxtw]"); 1177 COMPARE(str(x1, MemOperand(sp, xzr)), "str x1, [sp, xzr]"); 1178 1179 CLEANUP(); 1180} 1181 1182 1183TEST(load_store_byte) { 1184 SETUP(); 1185 1186 COMPARE(ldrb(w0, MemOperand(x1)), "ldrb w0, [x1]"); 1187 COMPARE(ldrb(x2, MemOperand(x3)), "ldrb w2, [x3]"); 1188 COMPARE(ldrb(w4, MemOperand(x5, 4095)), "ldrb w4, [x5, #4095]"); 1189 COMPARE(ldrb(w6, MemOperand(x7, 255, PreIndex)), "ldrb w6, [x7, #255]!"); 1190 COMPARE(ldrb(w8, MemOperand(x9, -256, PreIndex)), "ldrb w8, [x9, #-256]!"); 1191 COMPARE(ldrb(w10, MemOperand(x11, 255, PostIndex)), "ldrb w10, [x11], #255"); 1192 COMPARE(ldrb(w12, MemOperand(x13, -256, PostIndex)), 1193 "ldrb w12, [x13], #-256"); 1194 COMPARE(ldrb(w14, MemOperand(x15, 0, PreIndex)), "ldrb w14, [x15, #0]!"); 1195 COMPARE(ldrb(w16, MemOperand(x17, 0, PostIndex)), "ldrb w16, [x17], #0"); 1196 COMPARE(strb(w14, MemOperand(x15)), "strb w14, [x15]"); 1197 COMPARE(strb(x16, MemOperand(x17)), "strb w16, [x17]"); 1198 COMPARE(strb(w18, MemOperand(x19, 4095)), "strb w18, [x19, #4095]"); 1199 COMPARE(strb(w20, MemOperand(x21, 255, PreIndex)), "strb w20, [x21, #255]!"); 1200 COMPARE(strb(w22, MemOperand(x23, -256, PreIndex)), 1201 "strb w22, [x23, #-256]!"); 1202 COMPARE(strb(w24, MemOperand(x25, 255, PostIndex)), "strb w24, [x25], #255"); 1203 COMPARE(strb(w26, MemOperand(x27, -256, PostIndex)), 1204 "strb w26, [x27], #-256"); 1205 COMPARE(strb(w27, MemOperand(x28, 0, PreIndex)), "strb w27, [x28, #0]!"); 1206 COMPARE(strb(w29, MemOperand(x30, 0, PostIndex)), "strb w29, [x30], #0"); 1207 COMPARE(ldrb(w28, MemOperand(sp, 3, PostIndex)), "ldrb w28, [sp], #3"); 1208 COMPARE(strb(x29, MemOperand(sp, -42, PreIndex)), "strb w29, [sp, #-42]!"); 1209 COMPARE(ldrsb(w0, MemOperand(x1)), "ldrsb w0, [x1]"); 1210 COMPARE(ldrsb(x2, MemOperand(x3, 8)), "ldrsb x2, [x3, #8]"); 1211 COMPARE(ldrsb(w4, MemOperand(x5, 42, PreIndex)), "ldrsb w4, [x5, #42]!"); 1212 COMPARE(ldrsb(x6, MemOperand(x7, -11, PostIndex)), "ldrsb x6, [x7], #-11"); 1213 COMPARE(ldrsb(w8, MemOperand(x9, 0, PreIndex)), "ldrsb w8, [x9, #0]!"); 1214 COMPARE(ldrsb(x10, MemOperand(x11, 0, PostIndex)), "ldrsb x10, [x11], #0"); 1215 1216 CLEANUP(); 1217} 1218 1219 1220TEST(load_store_half) { 1221 SETUP(); 1222 1223 COMPARE(ldrh(w0, MemOperand(x1)), "ldrh w0, [x1]"); 1224 COMPARE(ldrh(x2, MemOperand(x3)), "ldrh w2, [x3]"); 1225 COMPARE(ldrh(w4, MemOperand(x5, 8190)), "ldrh w4, [x5, #8190]"); 1226 COMPARE(ldrh(w6, MemOperand(x7, 255, PreIndex)), "ldrh w6, [x7, #255]!"); 1227 COMPARE(ldrh(w8, MemOperand(x9, -256, PreIndex)), "ldrh w8, [x9, #-256]!"); 1228 COMPARE(ldrh(w10, MemOperand(x11, 255, PostIndex)), "ldrh w10, [x11], #255"); 1229 COMPARE(ldrh(w12, MemOperand(x13, -256, PostIndex)), 1230 "ldrh w12, [x13], #-256"); 1231 COMPARE(ldrh(w14, MemOperand(x15, 0, PreIndex)), "ldrh w14, [x15, #0]!"); 1232 COMPARE(ldrh(w16, MemOperand(x17, 0, PostIndex)), "ldrh w16, [x17], #0"); 1233 COMPARE(strh(w14, MemOperand(x15)), "strh w14, [x15]"); 1234 COMPARE(strh(x16, MemOperand(x17)), "strh w16, [x17]"); 1235 COMPARE(strh(w18, MemOperand(x19, 8190)), "strh w18, [x19, #8190]"); 1236 COMPARE(strh(w20, MemOperand(x21, 255, PreIndex)), "strh w20, [x21, #255]!"); 1237 COMPARE(strh(w22, MemOperand(x23, -256, PreIndex)), 1238 "strh w22, [x23, #-256]!"); 1239 COMPARE(strh(w24, MemOperand(x25, 255, PostIndex)), "strh w24, [x25], #255"); 1240 COMPARE(strh(w26, MemOperand(x27, -256, PostIndex)), 1241 "strh w26, [x27], #-256"); 1242 COMPARE(strh(w27, MemOperand(x28, 0, PreIndex)), "strh w27, [x28, #0]!"); 1243 COMPARE(strh(w29, MemOperand(x30, 0, PostIndex)), "strh w29, [x30], #0"); 1244 COMPARE(ldrh(w28, MemOperand(sp, 3, PostIndex)), "ldrh w28, [sp], #3"); 1245 COMPARE(strh(x29, MemOperand(sp, -42, PreIndex)), "strh w29, [sp, #-42]!"); 1246 COMPARE(ldrh(w30, MemOperand(x0, 255)), "ldurh w30, [x0, #255]"); 1247 COMPARE(ldrh(x1, MemOperand(x2, -256)), "ldurh w1, [x2, #-256]"); 1248 COMPARE(strh(w3, MemOperand(x4, 255)), "sturh w3, [x4, #255]"); 1249 COMPARE(strh(x5, MemOperand(x6, -256)), "sturh w5, [x6, #-256]"); 1250 COMPARE(ldrsh(w0, MemOperand(x1)), "ldrsh w0, [x1]"); 1251 COMPARE(ldrsh(w2, MemOperand(x3, 8)), "ldrsh w2, [x3, #8]"); 1252 COMPARE(ldrsh(w4, MemOperand(x5, 42, PreIndex)), "ldrsh w4, [x5, #42]!"); 1253 COMPARE(ldrsh(x6, MemOperand(x7, -11, PostIndex)), "ldrsh x6, [x7], #-11"); 1254 COMPARE(ldrsh(w8, MemOperand(x9, 0, PreIndex)), "ldrsh w8, [x9, #0]!"); 1255 COMPARE(ldrsh(x10, MemOperand(x11, 0, PostIndex)), "ldrsh x10, [x11], #0"); 1256 1257 CLEANUP(); 1258} 1259 1260TEST(load_store_unscaled) { 1261 SETUP(); 1262 1263 // If an unscaled-offset instruction is requested, it is used, even if the 1264 // offset could be encoded in a scaled-offset instruction. 1265 COMPARE(ldurb(w0, MemOperand(x1)), "ldurb w0, [x1]"); 1266 COMPARE(ldurb(x2, MemOperand(x3, 1)), "ldurb w2, [x3, #1]"); 1267 COMPARE(ldurb(w4, MemOperand(x5, 255)), "ldurb w4, [x5, #255]"); 1268 COMPARE(sturb(w14, MemOperand(x15)), "sturb w14, [x15]"); 1269 COMPARE(sturb(x16, MemOperand(x17, 1)), "sturb w16, [x17, #1]"); 1270 COMPARE(sturb(w18, MemOperand(x19, 255)), "sturb w18, [x19, #255]"); 1271 COMPARE(ldursb(w0, MemOperand(x1)), "ldursb w0, [x1]"); 1272 COMPARE(ldursb(w2, MemOperand(x3, 1)), "ldursb w2, [x3, #1]"); 1273 COMPARE(ldursb(x2, MemOperand(x3, 255)), "ldursb x2, [x3, #255]"); 1274 1275 COMPARE(ldurh(w0, MemOperand(x1)), "ldurh w0, [x1]"); 1276 COMPARE(ldurh(x2, MemOperand(x3, 2)), "ldurh w2, [x3, #2]"); 1277 COMPARE(ldurh(w4, MemOperand(x5, 254)), "ldurh w4, [x5, #254]"); 1278 COMPARE(sturh(w14, MemOperand(x15)), "sturh w14, [x15]"); 1279 COMPARE(sturh(x16, MemOperand(x17, 2)), "sturh w16, [x17, #2]"); 1280 COMPARE(sturh(w18, MemOperand(x19, 254)), "sturh w18, [x19, #254]"); 1281 COMPARE(ldursh(w0, MemOperand(x1)), "ldursh w0, [x1]"); 1282 COMPARE(ldursh(w2, MemOperand(x3, 2)), "ldursh w2, [x3, #2]"); 1283 COMPARE(ldursh(x4, MemOperand(x5, 254)), "ldursh x4, [x5, #254]"); 1284 1285 COMPARE(ldur(w0, MemOperand(x1)), "ldur w0, [x1]"); 1286 COMPARE(ldur(w2, MemOperand(x3, 4)), "ldur w2, [x3, #4]"); 1287 COMPARE(ldur(w4, MemOperand(x5, 248)), "ldur w4, [x5, #248]"); 1288 COMPARE(stur(w12, MemOperand(x13)), "stur w12, [x13]"); 1289 COMPARE(stur(w14, MemOperand(x15, 4)), "stur w14, [x15, #4]"); 1290 COMPARE(stur(w16, MemOperand(x17, 248)), "stur w16, [x17, #248]"); 1291 COMPARE(ldursw(x0, MemOperand(x1)), "ldursw x0, [x1]"); 1292 COMPARE(ldursw(x2, MemOperand(x3, 4)), "ldursw x2, [x3, #4]"); 1293 COMPARE(ldursw(x4, MemOperand(x5, 248)), "ldursw x4, [x5, #248]"); 1294 1295 COMPARE(ldur(x6, MemOperand(x7)), "ldur x6, [x7]"); 1296 COMPARE(ldur(x8, MemOperand(x9, 8)), "ldur x8, [x9, #8]"); 1297 COMPARE(ldur(x10, MemOperand(x11, 248)), "ldur x10, [x11, #248]"); 1298 COMPARE(stur(x18, MemOperand(x19)), "stur x18, [x19]"); 1299 COMPARE(stur(x20, MemOperand(x21, 8)), "stur x20, [x21, #8]"); 1300 COMPARE(stur(x22, MemOperand(x23, 248)), "stur x22, [x23, #248]"); 1301 1302 COMPARE(ldur(b0, MemOperand(x1)), "ldur b0, [x1]"); 1303 COMPARE(ldur(h2, MemOperand(x3, -1)), "ldur h2, [x3, #-1]"); 1304 COMPARE(ldur(s4, MemOperand(x5, 2)), "ldur s4, [x5, #2]"); 1305 COMPARE(ldur(d6, MemOperand(x7, -3)), "ldur d6, [x7, #-3]"); 1306 COMPARE(ldur(q8, MemOperand(x9, 4)), "ldur q8, [x9, #4]"); 1307 COMPARE(stur(b10, MemOperand(x11)), "stur b10, [x11]"); 1308 COMPARE(stur(h12, MemOperand(x13, -1)), "stur h12, [x13, #-1]"); 1309 COMPARE(stur(s14, MemOperand(x15, 2)), "stur s14, [x15, #2]"); 1310 COMPARE(stur(d16, MemOperand(x17, -3)), "stur d16, [x17, #-3]"); 1311 COMPARE(stur(q18, MemOperand(x19, 4)), "stur q18, [x19, #4]"); 1312 1313 // Normal loads and stores are converted to unscaled loads and stores if the 1314 // offset requires it. 1315 COMPARE(ldr(w0, MemOperand(x1, 1)), "ldur w0, [x1, #1]"); 1316 COMPARE(ldr(w2, MemOperand(x3, -1)), "ldur w2, [x3, #-1]"); 1317 COMPARE(ldr(w4, MemOperand(x5, 255)), "ldur w4, [x5, #255]"); 1318 COMPARE(ldr(w6, MemOperand(x7, -256)), "ldur w6, [x7, #-256]"); 1319 COMPARE(ldr(x8, MemOperand(x9, 1)), "ldur x8, [x9, #1]"); 1320 COMPARE(ldr(x10, MemOperand(x11, -1)), "ldur x10, [x11, #-1]"); 1321 COMPARE(ldr(x12, MemOperand(x13, 255)), "ldur x12, [x13, #255]"); 1322 COMPARE(ldr(x14, MemOperand(x15, -256)), "ldur x14, [x15, #-256]"); 1323 COMPARE(str(w16, MemOperand(x17, 1)), "stur w16, [x17, #1]"); 1324 COMPARE(str(w18, MemOperand(x19, -1)), "stur w18, [x19, #-1]"); 1325 COMPARE(str(w20, MemOperand(x21, 255)), "stur w20, [x21, #255]"); 1326 COMPARE(str(w22, MemOperand(x23, -256)), "stur w22, [x23, #-256]"); 1327 COMPARE(str(x24, MemOperand(x25, 1)), "stur x24, [x25, #1]"); 1328 COMPARE(str(x26, MemOperand(x27, -1)), "stur x26, [x27, #-1]"); 1329 COMPARE(str(x28, MemOperand(x29, 255)), "stur x28, [x29, #255]"); 1330 COMPARE(str(x30, MemOperand(x0, -256)), "stur x30, [x0, #-256]"); 1331 COMPARE(ldr(w0, MemOperand(sp, 1)), "ldur w0, [sp, #1]"); 1332 COMPARE(str(x1, MemOperand(sp, -1)), "stur x1, [sp, #-1]"); 1333 COMPARE(ldrb(w2, MemOperand(x3, -2)), "ldurb w2, [x3, #-2]"); 1334 COMPARE(ldrsb(w4, MemOperand(x5, -3)), "ldursb w4, [x5, #-3]"); 1335 COMPARE(ldrsb(x6, MemOperand(x7, -4)), "ldursb x6, [x7, #-4]"); 1336 COMPARE(ldrh(w8, MemOperand(x9, -5)), "ldurh w8, [x9, #-5]"); 1337 COMPARE(ldrsh(w10, MemOperand(x11, -6)), "ldursh w10, [x11, #-6]"); 1338 COMPARE(ldrsh(x12, MemOperand(x13, -7)), "ldursh x12, [x13, #-7]"); 1339 COMPARE(ldrsw(x14, MemOperand(x15, -8)), "ldursw x14, [x15, #-8]"); 1340 1341 CLEANUP(); 1342} 1343 1344 1345TEST(load_store_unscaled_option) { 1346 SETUP(); 1347 1348 // Just like load_store_unscaled, but specify the scaling option explicitly. 1349 LoadStoreScalingOption options[] = {PreferUnscaledOffset, 1350 RequireUnscaledOffset}; 1351 1352 for (size_t i = 0; i < sizeof(options) / sizeof(options[0]); i++) { 1353 LoadStoreScalingOption option = options[i]; 1354 1355 // If an unscaled-offset instruction is requested, it is used, even if the 1356 // offset could be encoded in a scaled-offset instruction. 1357 COMPARE(ldurb(w0, MemOperand(x1), option), "ldurb w0, [x1]"); 1358 COMPARE(ldurb(x2, MemOperand(x3, 1), option), "ldurb w2, [x3, #1]"); 1359 COMPARE(ldurb(w4, MemOperand(x5, 255), option), "ldurb w4, [x5, #255]"); 1360 COMPARE(sturb(w14, MemOperand(x15), option), "sturb w14, [x15]"); 1361 COMPARE(sturb(x16, MemOperand(x17, 1), option), "sturb w16, [x17, #1]"); 1362 COMPARE(sturb(w18, MemOperand(x19, 255), option), "sturb w18, [x19, #255]"); 1363 COMPARE(ldursb(w0, MemOperand(x1), option), "ldursb w0, [x1]"); 1364 COMPARE(ldursb(w2, MemOperand(x3, 1), option), "ldursb w2, [x3, #1]"); 1365 COMPARE(ldursb(x2, MemOperand(x3, 255), option), "ldursb x2, [x3, #255]"); 1366 1367 COMPARE(ldurh(w0, MemOperand(x1), option), "ldurh w0, [x1]"); 1368 COMPARE(ldurh(x2, MemOperand(x3, 2), option), "ldurh w2, [x3, #2]"); 1369 COMPARE(ldurh(w4, MemOperand(x5, 254), option), "ldurh w4, [x5, #254]"); 1370 COMPARE(sturh(w14, MemOperand(x15), option), "sturh w14, [x15]"); 1371 COMPARE(sturh(x16, MemOperand(x17, 2), option), "sturh w16, [x17, #2]"); 1372 COMPARE(sturh(w18, MemOperand(x19, 254), option), "sturh w18, [x19, #254]"); 1373 COMPARE(ldursh(w0, MemOperand(x1), option), "ldursh w0, [x1]"); 1374 COMPARE(ldursh(w2, MemOperand(x3, 2), option), "ldursh w2, [x3, #2]"); 1375 COMPARE(ldursh(x4, MemOperand(x5, 254), option), "ldursh x4, [x5, #254]"); 1376 1377 COMPARE(ldur(w0, MemOperand(x1), option), "ldur w0, [x1]"); 1378 COMPARE(ldur(w2, MemOperand(x3, 4), option), "ldur w2, [x3, #4]"); 1379 COMPARE(ldur(w4, MemOperand(x5, 248), option), "ldur w4, [x5, #248]"); 1380 COMPARE(stur(w12, MemOperand(x13), option), "stur w12, [x13]"); 1381 COMPARE(stur(w14, MemOperand(x15, 4), option), "stur w14, [x15, #4]"); 1382 COMPARE(stur(w16, MemOperand(x17, 248), option), "stur w16, [x17, #248]"); 1383 COMPARE(ldursw(x0, MemOperand(x1), option), "ldursw x0, [x1]"); 1384 COMPARE(ldursw(x2, MemOperand(x3, 4), option), "ldursw x2, [x3, #4]"); 1385 COMPARE(ldursw(x4, MemOperand(x5, 248), option), "ldursw x4, [x5, #248]"); 1386 1387 COMPARE(ldur(x6, MemOperand(x7), option), "ldur x6, [x7]"); 1388 COMPARE(ldur(x8, MemOperand(x9, 8), option), "ldur x8, [x9, #8]"); 1389 COMPARE(ldur(x10, MemOperand(x11, 248), option), "ldur x10, [x11, #248]"); 1390 COMPARE(stur(x18, MemOperand(x19), option), "stur x18, [x19]"); 1391 COMPARE(stur(x20, MemOperand(x21, 8), option), "stur x20, [x21, #8]"); 1392 COMPARE(stur(x22, MemOperand(x23, 248), option), "stur x22, [x23, #248]"); 1393 1394 COMPARE(ldur(b0, MemOperand(x1), option), "ldur b0, [x1]"); 1395 COMPARE(ldur(h2, MemOperand(x3, 2), option), "ldur h2, [x3, #2]"); 1396 COMPARE(ldur(s4, MemOperand(x5, 4), option), "ldur s4, [x5, #4]"); 1397 COMPARE(ldur(d6, MemOperand(x7, 8), option), "ldur d6, [x7, #8]"); 1398 COMPARE(ldur(q8, MemOperand(x9, 16), option), "ldur q8, [x9, #16]"); 1399 COMPARE(stur(b10, MemOperand(x11), option), "stur b10, [x11]"); 1400 COMPARE(stur(h12, MemOperand(x13, 2), option), "stur h12, [x13, #2]"); 1401 COMPARE(stur(s14, MemOperand(x15, 4), option), "stur s14, [x15, #4]"); 1402 COMPARE(stur(d16, MemOperand(x17, 8), option), "stur d16, [x17, #8]"); 1403 COMPARE(stur(q18, MemOperand(x19, 16), option), "stur q18, [x19, #16]"); 1404 } 1405 1406 // Normal loads and stores are converted to unscaled loads and stores if the 1407 // offset requires it. PreferScaledOffset is the default for these cases, so 1408 // the behaviour here is the same when no option is specified. 1409 LoadStoreScalingOption option = PreferScaledOffset; 1410 COMPARE(ldr(w0, MemOperand(x1, 1), option), "ldur w0, [x1, #1]"); 1411 COMPARE(ldr(w2, MemOperand(x3, -1), option), "ldur w2, [x3, #-1]"); 1412 COMPARE(ldr(w4, MemOperand(x5, 255), option), "ldur w4, [x5, #255]"); 1413 COMPARE(ldr(w6, MemOperand(x7, -256), option), "ldur w6, [x7, #-256]"); 1414 COMPARE(ldr(x8, MemOperand(x9, 1), option), "ldur x8, [x9, #1]"); 1415 COMPARE(ldr(x10, MemOperand(x11, -1), option), "ldur x10, [x11, #-1]"); 1416 COMPARE(ldr(x12, MemOperand(x13, 255), option), "ldur x12, [x13, #255]"); 1417 COMPARE(ldr(x14, MemOperand(x15, -256), option), "ldur x14, [x15, #-256]"); 1418 COMPARE(str(w16, MemOperand(x17, 1), option), "stur w16, [x17, #1]"); 1419 COMPARE(str(w18, MemOperand(x19, -1), option), "stur w18, [x19, #-1]"); 1420 COMPARE(str(w20, MemOperand(x21, 255), option), "stur w20, [x21, #255]"); 1421 COMPARE(str(w22, MemOperand(x23, -256), option), "stur w22, [x23, #-256]"); 1422 COMPARE(str(x24, MemOperand(x25, 1), option), "stur x24, [x25, #1]"); 1423 COMPARE(str(x26, MemOperand(x27, -1), option), "stur x26, [x27, #-1]"); 1424 COMPARE(str(x28, MemOperand(x29, 255), option), "stur x28, [x29, #255]"); 1425 COMPARE(str(x30, MemOperand(x0, -256), option), "stur x30, [x0, #-256]"); 1426 COMPARE(ldr(w0, MemOperand(sp, 1), option), "ldur w0, [sp, #1]"); 1427 COMPARE(str(x1, MemOperand(sp, -1), option), "stur x1, [sp, #-1]"); 1428 COMPARE(ldrb(w2, MemOperand(x3, -2), option), "ldurb w2, [x3, #-2]"); 1429 COMPARE(ldrsb(w4, MemOperand(x5, -3), option), "ldursb w4, [x5, #-3]"); 1430 COMPARE(ldrsb(x6, MemOperand(x7, -4), option), "ldursb x6, [x7, #-4]"); 1431 COMPARE(ldrh(w8, MemOperand(x9, -5), option), "ldurh w8, [x9, #-5]"); 1432 COMPARE(ldrsh(w10, MemOperand(x11, -6), option), "ldursh w10, [x11, #-6]"); 1433 COMPARE(ldrsh(x12, MemOperand(x13, -7), option), "ldursh x12, [x13, #-7]"); 1434 COMPARE(ldrsw(x14, MemOperand(x15, -8), option), "ldursw x14, [x15, #-8]"); 1435 COMPARE(ldr(b0, MemOperand(x1, 1), option), "ldr b0, [x1, #1]"); 1436 COMPARE(ldr(h2, MemOperand(x3, 1), option), "ldur h2, [x3, #1]"); 1437 COMPARE(ldr(s4, MemOperand(x5, 3), option), "ldur s4, [x5, #3]"); 1438 COMPARE(ldr(d6, MemOperand(x7, 7), option), "ldur d6, [x7, #7]"); 1439 COMPARE(ldr(q8, MemOperand(x9, 15), option), "ldur q8, [x9, #15]"); 1440 COMPARE(str(b10, MemOperand(x11, 1), option), "str b10, [x11, #1]"); 1441 COMPARE(str(h12, MemOperand(x13, 1), option), "stur h12, [x13, #1]"); 1442 COMPARE(str(s14, MemOperand(x15, 3), option), "stur s14, [x15, #3]"); 1443 COMPARE(str(d16, MemOperand(x17, 7), option), "stur d16, [x17, #7]"); 1444 COMPARE(str(q18, MemOperand(x19, 15), option), "stur q18, [x19, #15]"); 1445 1446 CLEANUP(); 1447} 1448 1449 1450TEST(load_store_pair) { 1451 SETUP(); 1452 1453 COMPARE(ldp(w0, w1, MemOperand(x2)), "ldp w0, w1, [x2]"); 1454 COMPARE(ldp(x3, x4, MemOperand(x5)), "ldp x3, x4, [x5]"); 1455 COMPARE(ldp(w6, w7, MemOperand(x8, 4)), "ldp w6, w7, [x8, #4]"); 1456 COMPARE(ldp(x9, x10, MemOperand(x11, 8)), "ldp x9, x10, [x11, #8]"); 1457 COMPARE(ldp(w12, w13, MemOperand(x14, 252)), "ldp w12, w13, [x14, #252]"); 1458 COMPARE(ldp(x15, x16, MemOperand(x17, 504)), "ldp x15, x16, [x17, #504]"); 1459 COMPARE(ldp(w18, w19, MemOperand(x20, -256)), "ldp w18, w19, [x20, #-256]"); 1460 COMPARE(ldp(x21, x22, MemOperand(x23, -512)), "ldp x21, x22, [x23, #-512]"); 1461 COMPARE(ldp(w24, w25, MemOperand(x26, 252, PreIndex)), 1462 "ldp w24, w25, [x26, #252]!"); 1463 COMPARE(ldp(x27, x28, MemOperand(x29, 504, PreIndex)), 1464 "ldp x27, x28, [x29, #504]!"); 1465 COMPARE(ldp(w30, w0, MemOperand(x1, -256, PreIndex)), 1466 "ldp w30, w0, [x1, #-256]!"); 1467 COMPARE(ldp(x2, x3, MemOperand(x4, -512, PreIndex)), 1468 "ldp x2, x3, [x4, #-512]!"); 1469 COMPARE(ldp(w5, w6, MemOperand(x7, 252, PostIndex)), 1470 "ldp w5, w6, [x7], #252"); 1471 COMPARE(ldp(x8, x9, MemOperand(x10, 504, PostIndex)), 1472 "ldp x8, x9, [x10], #504"); 1473 COMPARE(ldp(w11, w12, MemOperand(x13, -256, PostIndex)), 1474 "ldp w11, w12, [x13], #-256"); 1475 COMPARE(ldp(x14, x15, MemOperand(x16, -512, PostIndex)), 1476 "ldp x14, x15, [x16], #-512"); 1477 COMPARE(ldp(x0, x1, MemOperand(x2, 0, PostIndex)), "ldp x0, x1, [x2], #0"); 1478 COMPARE(ldp(w3, w4, MemOperand(x5, 0, PreIndex)), "ldp w3, w4, [x5, #0]!"); 1479 1480 COMPARE(ldp(s17, s18, MemOperand(x19)), "ldp s17, s18, [x19]"); 1481 COMPARE(ldp(s20, s21, MemOperand(x22, 252)), "ldp s20, s21, [x22, #252]"); 1482 COMPARE(ldp(s23, s24, MemOperand(x25, -256)), "ldp s23, s24, [x25, #-256]"); 1483 COMPARE(ldp(s26, s27, MemOperand(x28, 252, PreIndex)), 1484 "ldp s26, s27, [x28, #252]!"); 1485 COMPARE(ldp(s29, s30, MemOperand(x29, -256, PreIndex)), 1486 "ldp s29, s30, [x29, #-256]!"); 1487 COMPARE(ldp(s31, s0, MemOperand(x1, 252, PostIndex)), 1488 "ldp s31, s0, [x1], #252"); 1489 COMPARE(ldp(s2, s3, MemOperand(x4, -256, PostIndex)), 1490 "ldp s2, s3, [x4], #-256"); 1491 COMPARE(ldp(d17, d18, MemOperand(x19)), "ldp d17, d18, [x19]"); 1492 COMPARE(ldp(d20, d21, MemOperand(x22, 504)), "ldp d20, d21, [x22, #504]"); 1493 COMPARE(ldp(d23, d24, MemOperand(x25, -512)), "ldp d23, d24, [x25, #-512]"); 1494 COMPARE(ldp(d26, d27, MemOperand(x28, 504, PreIndex)), 1495 "ldp d26, d27, [x28, #504]!"); 1496 COMPARE(ldp(d29, d30, MemOperand(x29, -512, PreIndex)), 1497 "ldp d29, d30, [x29, #-512]!"); 1498 COMPARE(ldp(d31, d0, MemOperand(x1, 504, PostIndex)), 1499 "ldp d31, d0, [x1], #504"); 1500 COMPARE(ldp(d2, d3, MemOperand(x4, -512, PostIndex)), 1501 "ldp d2, d3, [x4], #-512"); 1502 COMPARE(ldp(s0, s1, MemOperand(x2, 0, PostIndex)), "ldp s0, s1, [x2], #0"); 1503 COMPARE(ldp(d3, d4, MemOperand(x5, 0, PreIndex)), "ldp d3, d4, [x5, #0]!"); 1504 1505 COMPARE(ldp(q5, q6, MemOperand(x7)), "ldp q5, q6, [x7]"); 1506 COMPARE(ldp(q8, q9, MemOperand(x10, 1008)), "ldp q8, q9, [x10, #1008]"); 1507 COMPARE(ldp(q11, q12, MemOperand(x13, -1024)), "ldp q11, q12, [x13, #-1024]"); 1508 COMPARE(ldp(q14, q15, MemOperand(x16, 1008, PreIndex)), 1509 "ldp q14, q15, [x16, #1008]!"); 1510 COMPARE(ldp(q17, q18, MemOperand(x19, -1024, PreIndex)), 1511 "ldp q17, q18, [x19, #-1024]!"); 1512 COMPARE(ldp(q20, q21, MemOperand(x22, 1008, PostIndex)), 1513 "ldp q20, q21, [x22], #1008"); 1514 COMPARE(ldp(q23, q24, MemOperand(x25, -1024, PostIndex)), 1515 "ldp q23, q24, [x25], #-1024"); 1516 COMPARE(ldp(q6, q7, MemOperand(x8, 0, PreIndex)), "ldp q6, q7, [x8, #0]!"); 1517 1518 COMPARE(stp(w0, w1, MemOperand(x2)), "stp w0, w1, [x2]"); 1519 COMPARE(stp(x3, x4, MemOperand(x5)), "stp x3, x4, [x5]"); 1520 COMPARE(stp(w6, w7, MemOperand(x8, 4)), "stp w6, w7, [x8, #4]"); 1521 COMPARE(stp(x9, x10, MemOperand(x11, 8)), "stp x9, x10, [x11, #8]"); 1522 COMPARE(stp(w12, w13, MemOperand(x14, 252)), "stp w12, w13, [x14, #252]"); 1523 COMPARE(stp(x15, x16, MemOperand(x17, 504)), "stp x15, x16, [x17, #504]"); 1524 COMPARE(stp(w18, w19, MemOperand(x20, -256)), "stp w18, w19, [x20, #-256]"); 1525 COMPARE(stp(x21, x22, MemOperand(x23, -512)), "stp x21, x22, [x23, #-512]"); 1526 COMPARE(stp(w24, w25, MemOperand(x26, 252, PreIndex)), 1527 "stp w24, w25, [x26, #252]!"); 1528 COMPARE(stp(x27, x28, MemOperand(x29, 504, PreIndex)), 1529 "stp x27, x28, [x29, #504]!"); 1530 COMPARE(stp(w30, w0, MemOperand(x1, -256, PreIndex)), 1531 "stp w30, w0, [x1, #-256]!"); 1532 COMPARE(stp(x2, x3, MemOperand(x4, -512, PreIndex)), 1533 "stp x2, x3, [x4, #-512]!"); 1534 COMPARE(stp(w5, w6, MemOperand(x7, 252, PostIndex)), 1535 "stp w5, w6, [x7], #252"); 1536 COMPARE(stp(x8, x9, MemOperand(x10, 504, PostIndex)), 1537 "stp x8, x9, [x10], #504"); 1538 COMPARE(stp(w11, w12, MemOperand(x13, -256, PostIndex)), 1539 "stp w11, w12, [x13], #-256"); 1540 COMPARE(stp(x14, x15, MemOperand(x16, -512, PostIndex)), 1541 "stp x14, x15, [x16], #-512"); 1542 COMPARE(stp(x0, x1, MemOperand(x2, 0, PostIndex)), "stp x0, x1, [x2], #0"); 1543 COMPARE(stp(w3, w4, MemOperand(x5, 0, PreIndex)), "stp w3, w4, [x5, #0]!"); 1544 1545 COMPARE(stp(s17, s18, MemOperand(x19)), "stp s17, s18, [x19]"); 1546 COMPARE(stp(s20, s21, MemOperand(x22, 252)), "stp s20, s21, [x22, #252]"); 1547 COMPARE(stp(s23, s24, MemOperand(x25, -256)), "stp s23, s24, [x25, #-256]"); 1548 COMPARE(stp(s26, s27, MemOperand(x28, 252, PreIndex)), 1549 "stp s26, s27, [x28, #252]!"); 1550 COMPARE(stp(s29, s30, MemOperand(x29, -256, PreIndex)), 1551 "stp s29, s30, [x29, #-256]!"); 1552 COMPARE(stp(s31, s0, MemOperand(x1, 252, PostIndex)), 1553 "stp s31, s0, [x1], #252"); 1554 COMPARE(stp(s2, s3, MemOperand(x4, -256, PostIndex)), 1555 "stp s2, s3, [x4], #-256"); 1556 COMPARE(stp(d17, d18, MemOperand(x19)), "stp d17, d18, [x19]"); 1557 COMPARE(stp(d20, d21, MemOperand(x22, 504)), "stp d20, d21, [x22, #504]"); 1558 COMPARE(stp(d23, d24, MemOperand(x25, -512)), "stp d23, d24, [x25, #-512]"); 1559 COMPARE(stp(d26, d27, MemOperand(x28, 504, PreIndex)), 1560 "stp d26, d27, [x28, #504]!"); 1561 COMPARE(stp(d29, d30, MemOperand(x29, -512, PreIndex)), 1562 "stp d29, d30, [x29, #-512]!"); 1563 COMPARE(stp(d31, d0, MemOperand(x1, 504, PostIndex)), 1564 "stp d31, d0, [x1], #504"); 1565 COMPARE(stp(d2, d3, MemOperand(x4, -512, PostIndex)), 1566 "stp d2, d3, [x4], #-512"); 1567 COMPARE(stp(s0, s1, MemOperand(x2, 0, PostIndex)), "stp s0, s1, [x2], #0"); 1568 COMPARE(stp(d3, d4, MemOperand(x5, 0, PreIndex)), "stp d3, d4, [x5, #0]!"); 1569 1570 COMPARE(stp(q5, q6, MemOperand(x7)), "stp q5, q6, [x7]"); 1571 COMPARE(stp(q8, q9, MemOperand(x10, 1008)), "stp q8, q9, [x10, #1008]"); 1572 COMPARE(stp(q11, q12, MemOperand(x13, -1024)), "stp q11, q12, [x13, #-1024]"); 1573 COMPARE(stp(q14, q15, MemOperand(x16, 1008, PreIndex)), 1574 "stp q14, q15, [x16, #1008]!"); 1575 COMPARE(stp(q17, q18, MemOperand(x19, -1024, PreIndex)), 1576 "stp q17, q18, [x19, #-1024]!"); 1577 COMPARE(stp(q20, q21, MemOperand(x22, 1008, PostIndex)), 1578 "stp q20, q21, [x22], #1008"); 1579 COMPARE(stp(q23, q24, MemOperand(x25, -1024, PostIndex)), 1580 "stp q23, q24, [x25], #-1024"); 1581 COMPARE(stp(q6, q7, MemOperand(x8, 0, PreIndex)), "stp q6, q7, [x8, #0]!"); 1582 1583 COMPARE(ldp(w16, w17, MemOperand(sp, 4, PostIndex)), 1584 "ldp w16, w17, [sp], #4"); 1585 COMPARE(stp(x18, x19, MemOperand(sp, -8, PreIndex)), 1586 "stp x18, x19, [sp, #-8]!"); 1587 COMPARE(ldp(s30, s31, MemOperand(sp, 12, PostIndex)), 1588 "ldp s30, s31, [sp], #12"); 1589 COMPARE(stp(d30, d31, MemOperand(sp, -16)), "stp d30, d31, [sp, #-16]"); 1590 COMPARE(ldp(q30, q31, MemOperand(sp, 32, PostIndex)), 1591 "ldp q30, q31, [sp], #32"); 1592 1593 COMPARE(ldpsw(x0, x1, MemOperand(x2)), "ldpsw x0, x1, [x2]"); 1594 COMPARE(ldpsw(x3, x4, MemOperand(x5, 16)), "ldpsw x3, x4, [x5, #16]"); 1595 COMPARE(ldpsw(x6, x7, MemOperand(x8, -32, PreIndex)), 1596 "ldpsw x6, x7, [x8, #-32]!"); 1597 COMPARE(ldpsw(x9, x10, MemOperand(x11, 128, PostIndex)), 1598 "ldpsw x9, x10, [x11], #128"); 1599 COMPARE(ldpsw(x0, x1, MemOperand(x10, 0, PreIndex)), 1600 "ldpsw x0, x1, [x10, #0]!"); 1601 COMPARE(ldpsw(x2, x3, MemOperand(x10, 0, PostIndex)), 1602 "ldpsw x2, x3, [x10], #0"); 1603 1604 CLEANUP(); 1605} 1606 1607 1608TEST(load_pauth) { 1609 SETUP(); 1610 1611 COMPARE(ldraa(x0, MemOperand(x1)), "ldraa x0, [x1]"); 1612 COMPARE(ldraa(x2, MemOperand(sp)), "ldraa x2, [sp]"); 1613 COMPARE(ldraa(x3, MemOperand(x4, 64)), "ldraa x3, [x4, #64]"); 1614 COMPARE(ldraa(x5, MemOperand(sp, 512)), "ldraa x5, [sp, #512]"); 1615 COMPARE(ldraa(x6, MemOperand(x7, -256)), "ldraa x6, [x7, #-256]"); 1616 COMPARE(ldraa(x8, MemOperand(sp, -1024)), "ldraa x8, [sp, #-1024]"); 1617 COMPARE(ldraa(x9, MemOperand(x10, 2048, PreIndex)), 1618 "ldraa x9, [x10, #2048]!"); 1619 1620 COMPARE(ldrab(x9, MemOperand(x10)), "ldrab x9, [x10]"); 1621 COMPARE(ldrab(x11, MemOperand(sp)), "ldrab x11, [sp]"); 1622 COMPARE(ldrab(x12, MemOperand(x13, 64)), "ldrab x12, [x13, #64]"); 1623 COMPARE(ldrab(x14, MemOperand(sp, 512)), "ldrab x14, [sp, #512]"); 1624 COMPARE(ldrab(x15, MemOperand(x16, -256)), "ldrab x15, [x16, #-256]"); 1625 COMPARE(ldrab(x17, MemOperand(sp, -1024)), "ldrab x17, [sp, #-1024]"); 1626 COMPARE(ldrab(x18, MemOperand(x19, 2048, PreIndex)), 1627 "ldrab x18, [x19, #2048]!"); 1628 1629 CLEANUP(); 1630} 1631 1632 1633TEST(load_store_exclusive) { 1634 SETUP(); 1635 1636 COMPARE(stxrb(w0, w1, MemOperand(x2)), "stxrb w0, w1, [x2]"); 1637 COMPARE(stxrb(x3, w4, MemOperand(sp)), "stxrb w3, w4, [sp]"); 1638 COMPARE(stxrb(w5, x6, MemOperand(x7)), "stxrb w5, w6, [x7]"); 1639 COMPARE(stxrb(x8, x9, MemOperand(sp)), "stxrb w8, w9, [sp]"); 1640 COMPARE(stxrh(w10, w11, MemOperand(x12)), "stxrh w10, w11, [x12]"); 1641 COMPARE(stxrh(x13, w14, MemOperand(sp)), "stxrh w13, w14, [sp]"); 1642 COMPARE(stxrh(w15, x16, MemOperand(x17)), "stxrh w15, w16, [x17]"); 1643 COMPARE(stxrh(x18, x19, MemOperand(sp)), "stxrh w18, w19, [sp]"); 1644 COMPARE(stxr(w20, w21, MemOperand(x22)), "stxr w20, w21, [x22]"); 1645 COMPARE(stxr(x23, w24, MemOperand(sp)), "stxr w23, w24, [sp]"); 1646 COMPARE(stxr(w25, x26, MemOperand(x27)), "stxr w25, x26, [x27]"); 1647 COMPARE(stxr(x28, x29, MemOperand(sp)), "stxr w28, x29, [sp]"); 1648 COMPARE(ldxrb(w30, MemOperand(x0)), "ldxrb w30, [x0]"); 1649 COMPARE(ldxrb(w1, MemOperand(sp)), "ldxrb w1, [sp]"); 1650 COMPARE(ldxrb(x2, MemOperand(x3)), "ldxrb w2, [x3]"); 1651 COMPARE(ldxrb(x4, MemOperand(sp)), "ldxrb w4, [sp]"); 1652 COMPARE(ldxrh(w5, MemOperand(x6)), "ldxrh w5, [x6]"); 1653 COMPARE(ldxrh(w7, MemOperand(sp)), "ldxrh w7, [sp]"); 1654 COMPARE(ldxrh(x8, MemOperand(x9)), "ldxrh w8, [x9]"); 1655 COMPARE(ldxrh(x10, MemOperand(sp)), "ldxrh w10, [sp]"); 1656 COMPARE(ldxr(w11, MemOperand(x12)), "ldxr w11, [x12]"); 1657 COMPARE(ldxr(w13, MemOperand(sp)), "ldxr w13, [sp]"); 1658 COMPARE(ldxr(x14, MemOperand(x15)), "ldxr x14, [x15]"); 1659 COMPARE(ldxr(x16, MemOperand(sp)), "ldxr x16, [sp]"); 1660 COMPARE(stxp(w17, w18, w19, MemOperand(x20)), "stxp w17, w18, w19, [x20]"); 1661 COMPARE(stxp(x21, w22, w23, MemOperand(sp)), "stxp w21, w22, w23, [sp]"); 1662 COMPARE(stxp(w24, x25, x26, MemOperand(x27)), "stxp w24, x25, x26, [x27]"); 1663 COMPARE(stxp(x28, x29, x30, MemOperand(sp)), "stxp w28, x29, x30, [sp]"); 1664 COMPARE(ldxp(w0, w1, MemOperand(x2)), "ldxp w0, w1, [x2]"); 1665 COMPARE(ldxp(w3, w4, MemOperand(sp)), "ldxp w3, w4, [sp]"); 1666 COMPARE(ldxp(x5, x6, MemOperand(x7)), "ldxp x5, x6, [x7]"); 1667 COMPARE(ldxp(x8, x9, MemOperand(sp)), "ldxp x8, x9, [sp]"); 1668 COMPARE(stlxrb(w10, w11, MemOperand(x12)), "stlxrb w10, w11, [x12]"); 1669 COMPARE(stlxrb(x13, w14, MemOperand(sp)), "stlxrb w13, w14, [sp]"); 1670 COMPARE(stlxrb(w15, x16, MemOperand(x17)), "stlxrb w15, w16, [x17]"); 1671 COMPARE(stlxrb(x18, x19, MemOperand(sp)), "stlxrb w18, w19, [sp]"); 1672 COMPARE(stlxrh(w20, w21, MemOperand(x22)), "stlxrh w20, w21, [x22]"); 1673 COMPARE(stlxrh(x23, w24, MemOperand(sp)), "stlxrh w23, w24, [sp]"); 1674 COMPARE(stlxrh(w25, x26, MemOperand(x27)), "stlxrh w25, w26, [x27]"); 1675 COMPARE(stlxrh(x28, x29, MemOperand(sp)), "stlxrh w28, w29, [sp]"); 1676 COMPARE(stlxr(w30, w0, MemOperand(x1)), "stlxr w30, w0, [x1]"); 1677 COMPARE(stlxr(x2, w3, MemOperand(sp)), "stlxr w2, w3, [sp]"); 1678 COMPARE(stlxr(w4, x5, MemOperand(x6)), "stlxr w4, x5, [x6]"); 1679 COMPARE(stlxr(x7, x8, MemOperand(sp)), "stlxr w7, x8, [sp]"); 1680 COMPARE(ldaxrb(w9, MemOperand(x10)), "ldaxrb w9, [x10]"); 1681 COMPARE(ldaxrb(w11, MemOperand(sp)), "ldaxrb w11, [sp]"); 1682 COMPARE(ldaxrb(x12, MemOperand(x13)), "ldaxrb w12, [x13]"); 1683 COMPARE(ldaxrb(x14, MemOperand(sp)), "ldaxrb w14, [sp]"); 1684 COMPARE(ldaxrh(w15, MemOperand(x16)), "ldaxrh w15, [x16]"); 1685 COMPARE(ldaxrh(w17, MemOperand(sp)), "ldaxrh w17, [sp]"); 1686 COMPARE(ldaxrh(x18, MemOperand(x19)), "ldaxrh w18, [x19]"); 1687 COMPARE(ldaxrh(x20, MemOperand(sp)), "ldaxrh w20, [sp]"); 1688 COMPARE(ldaxr(w21, MemOperand(x22)), "ldaxr w21, [x22]"); 1689 COMPARE(ldaxr(w23, MemOperand(sp)), "ldaxr w23, [sp]"); 1690 COMPARE(ldaxr(x24, MemOperand(x25)), "ldaxr x24, [x25]"); 1691 COMPARE(ldaxr(x26, MemOperand(sp)), "ldaxr x26, [sp]"); 1692 COMPARE(stlxp(w27, w28, w29, MemOperand(x30)), "stlxp w27, w28, w29, [x30]"); 1693 COMPARE(stlxp(x0, w1, w2, MemOperand(sp)), "stlxp w0, w1, w2, [sp]"); 1694 COMPARE(stlxp(w3, x4, x5, MemOperand(x6)), "stlxp w3, x4, x5, [x6]"); 1695 COMPARE(stlxp(x7, x8, x9, MemOperand(sp)), "stlxp w7, x8, x9, [sp]"); 1696 COMPARE(ldaxp(w10, w11, MemOperand(x12)), "ldaxp w10, w11, [x12]"); 1697 COMPARE(ldaxp(w13, w14, MemOperand(sp)), "ldaxp w13, w14, [sp]"); 1698 COMPARE(ldaxp(x15, x16, MemOperand(x17)), "ldaxp x15, x16, [x17]"); 1699 COMPARE(ldaxp(x18, x19, MemOperand(sp)), "ldaxp x18, x19, [sp]"); 1700 COMPARE(stlrb(w20, MemOperand(x21)), "stlrb w20, [x21]"); 1701 COMPARE(stlrb(w22, MemOperand(sp)), "stlrb w22, [sp]"); 1702 COMPARE(stlrb(x23, MemOperand(x24)), "stlrb w23, [x24]"); 1703 COMPARE(stlrb(x25, MemOperand(sp)), "stlrb w25, [sp]"); 1704 COMPARE(stlrh(w26, MemOperand(x27)), "stlrh w26, [x27]"); 1705 COMPARE(stlrh(w28, MemOperand(sp)), "stlrh w28, [sp]"); 1706 COMPARE(stlrh(x29, MemOperand(x30)), "stlrh w29, [x30]"); 1707 COMPARE(stlrh(x0, MemOperand(sp)), "stlrh w0, [sp]"); 1708 COMPARE(stlr(w1, MemOperand(x2)), "stlr w1, [x2]"); 1709 COMPARE(stlr(w3, MemOperand(sp)), "stlr w3, [sp]"); 1710 COMPARE(stlr(x4, MemOperand(x5)), "stlr x4, [x5]"); 1711 COMPARE(stlr(x6, MemOperand(sp)), "stlr x6, [sp]"); 1712 COMPARE(stllrb(w7, MemOperand(x8)), "stllrb w7, [x8]"); 1713 COMPARE(stllrb(w9, MemOperand(sp)), "stllrb w9, [sp]"); 1714 COMPARE(stllrb(x10, MemOperand(x11)), "stllrb w10, [x11]"); 1715 COMPARE(stllrb(x12, MemOperand(sp)), "stllrb w12, [sp]"); 1716 COMPARE(stllrh(w13, MemOperand(x14)), "stllrh w13, [x14]"); 1717 COMPARE(stllrh(w15, MemOperand(sp)), "stllrh w15, [sp]"); 1718 COMPARE(stllrh(x16, MemOperand(x17)), "stllrh w16, [x17]"); 1719 COMPARE(stllrh(x18, MemOperand(sp)), "stllrh w18, [sp]"); 1720 COMPARE(stllr(w19, MemOperand(x20)), "stllr w19, [x20]"); 1721 COMPARE(stllr(w21, MemOperand(sp)), "stllr w21, [sp]"); 1722 COMPARE(stllr(x22, MemOperand(x23)), "stllr x22, [x23]"); 1723 COMPARE(stllr(x24, MemOperand(sp)), "stllr x24, [sp]"); 1724 COMPARE(ldarb(w25, MemOperand(x26)), "ldarb w25, [x26]"); 1725 COMPARE(ldarb(w27, MemOperand(sp)), "ldarb w27, [sp]"); 1726 COMPARE(ldarb(x28, MemOperand(x29)), "ldarb w28, [x29]"); 1727 COMPARE(ldarb(x30, MemOperand(sp)), "ldarb w30, [sp]"); 1728 COMPARE(ldarh(w0, MemOperand(x1)), "ldarh w0, [x1]"); 1729 COMPARE(ldarh(w2, MemOperand(sp)), "ldarh w2, [sp]"); 1730 COMPARE(ldarh(x3, MemOperand(x4)), "ldarh w3, [x4]"); 1731 COMPARE(ldarh(x5, MemOperand(sp)), "ldarh w5, [sp]"); 1732 COMPARE(ldar(w6, MemOperand(x7)), "ldar w6, [x7]"); 1733 COMPARE(ldar(w8, MemOperand(sp)), "ldar w8, [sp]"); 1734 COMPARE(ldar(x9, MemOperand(x10)), "ldar x9, [x10]"); 1735 COMPARE(ldar(x11, MemOperand(sp)), "ldar x11, [sp]"); 1736 COMPARE(ldlarb(w12, MemOperand(x13)), "ldlarb w12, [x13]"); 1737 COMPARE(ldlarb(w14, MemOperand(sp)), "ldlarb w14, [sp]"); 1738 COMPARE(ldlarb(x15, MemOperand(x16)), "ldlarb w15, [x16]"); 1739 COMPARE(ldlarb(x17, MemOperand(sp)), "ldlarb w17, [sp]"); 1740 COMPARE(ldlarh(w18, MemOperand(x19)), "ldlarh w18, [x19]"); 1741 COMPARE(ldlarh(w20, MemOperand(sp)), "ldlarh w20, [sp]"); 1742 COMPARE(ldlarh(x21, MemOperand(x22)), "ldlarh w21, [x22]"); 1743 COMPARE(ldlarh(x23, MemOperand(sp)), "ldlarh w23, [sp]"); 1744 COMPARE(ldlar(w24, MemOperand(x25)), "ldlar w24, [x25]"); 1745 COMPARE(ldlar(w26, MemOperand(sp)), "ldlar w26, [sp]"); 1746 COMPARE(ldlar(x27, MemOperand(x28)), "ldlar x27, [x28]"); 1747 COMPARE(ldlar(x29, MemOperand(sp)), "ldlar x29, [sp]"); 1748 1749 COMPARE(cas(w30, w0, MemOperand(x1)), "cas w30, w0, [x1]"); 1750 COMPARE(cas(w2, w3, MemOperand(sp)), "cas w2, w3, [sp]"); 1751 COMPARE(cas(x4, x5, MemOperand(x6)), "cas x4, x5, [x6]"); 1752 COMPARE(cas(x7, x8, MemOperand(sp)), "cas x7, x8, [sp]"); 1753 COMPARE(casa(w9, w10, MemOperand(x11)), "casa w9, w10, [x11]"); 1754 COMPARE(casa(w12, w13, MemOperand(sp)), "casa w12, w13, [sp]"); 1755 COMPARE(casa(x14, x15, MemOperand(x16)), "casa x14, x15, [x16]"); 1756 COMPARE(casa(x17, x18, MemOperand(sp)), "casa x17, x18, [sp]"); 1757 COMPARE(casl(w19, w20, MemOperand(x21)), "casl w19, w20, [x21]"); 1758 COMPARE(casl(w22, w23, MemOperand(sp)), "casl w22, w23, [sp]"); 1759 COMPARE(casl(x24, x25, MemOperand(x26)), "casl x24, x25, [x26]"); 1760 COMPARE(casl(x27, x28, MemOperand(sp)), "casl x27, x28, [sp]"); 1761 COMPARE(casal(w29, w30, MemOperand(x0)), "casal w29, w30, [x0]"); 1762 COMPARE(casal(w1, w2, MemOperand(sp)), "casal w1, w2, [sp]"); 1763 COMPARE(casal(x3, x4, MemOperand(x5)), "casal x3, x4, [x5]"); 1764 COMPARE(casal(x6, x7, MemOperand(sp)), "casal x6, x7, [sp]"); 1765 COMPARE(casb(w8, w9, MemOperand(x10)), "casb w8, w9, [x10]"); 1766 COMPARE(casb(w11, w12, MemOperand(sp)), "casb w11, w12, [sp]"); 1767 COMPARE(casab(w13, w14, MemOperand(x15)), "casab w13, w14, [x15]"); 1768 COMPARE(casab(w16, w17, MemOperand(sp)), "casab w16, w17, [sp]"); 1769 COMPARE(caslb(w18, w19, MemOperand(x20)), "caslb w18, w19, [x20]"); 1770 COMPARE(caslb(w21, w22, MemOperand(sp)), "caslb w21, w22, [sp]"); 1771 COMPARE(casalb(w23, w24, MemOperand(x25)), "casalb w23, w24, [x25]"); 1772 COMPARE(casalb(w26, w27, MemOperand(sp)), "casalb w26, w27, [sp]"); 1773 COMPARE(cash(w28, w29, MemOperand(x30)), "cash w28, w29, [x30]"); 1774 COMPARE(cash(w0, w1, MemOperand(sp)), "cash w0, w1, [sp]"); 1775 COMPARE(casah(w2, w3, MemOperand(x4)), "casah w2, w3, [x4]"); 1776 COMPARE(casah(w5, w6, MemOperand(sp)), "casah w5, w6, [sp]"); 1777 COMPARE(caslh(w7, w8, MemOperand(x9)), "caslh w7, w8, [x9]"); 1778 COMPARE(caslh(w10, w11, MemOperand(sp)), "caslh w10, w11, [sp]"); 1779 COMPARE(casalh(w12, w13, MemOperand(x14)), "casalh w12, w13, [x14]"); 1780 COMPARE(casalh(w15, w16, MemOperand(sp)), "casalh w15, w16, [sp]"); 1781 COMPARE(casp(w18, w19, w20, w21, MemOperand(x22)), 1782 "casp w18, w19, w20, w21, [x22]"); 1783 COMPARE(casp(w24, w25, w26, w27, MemOperand(sp)), 1784 "casp w24, w25, w26, w27, [sp]"); 1785 COMPARE(casp(x28, x29, x0, x1, MemOperand(x2)), 1786 "casp x28, x29, x0, x1, [x2]"); 1787 COMPARE(casp(x4, x5, x6, x7, MemOperand(sp)), "casp x4, x5, x6, x7, [sp]"); 1788 COMPARE(caspa(w8, w9, w10, w11, MemOperand(x12)), 1789 "caspa w8, w9, w10, w11, [x12]"); 1790 COMPARE(caspa(w14, w15, w16, w17, MemOperand(sp)), 1791 "caspa w14, w15, w16, w17, [sp]"); 1792 COMPARE(caspa(x18, x19, x20, x21, MemOperand(x22)), 1793 "caspa x18, x19, x20, x21, [x22]"); 1794 COMPARE(caspa(x24, x25, x26, x27, MemOperand(sp)), 1795 "caspa x24, x25, x26, x27, [sp]"); 1796 COMPARE(caspl(w28, w29, w0, w1, MemOperand(x2)), 1797 "caspl w28, w29, w0, w1, [x2]"); 1798 COMPARE(caspl(w4, w5, w6, w7, MemOperand(sp)), "caspl w4, w5, w6, w7, [sp]"); 1799 COMPARE(caspl(x8, x9, x10, x11, MemOperand(x12)), 1800 "caspl x8, x9, x10, x11, [x12]"); 1801 COMPARE(caspl(x14, x15, x16, x17, MemOperand(sp)), 1802 "caspl x14, x15, x16, x17, [sp]"); 1803 COMPARE(caspal(w18, w19, w20, w21, MemOperand(x22)), 1804 "caspal w18, w19, w20, w21, [x22]"); 1805 COMPARE(caspal(w24, w25, w26, w27, MemOperand(sp)), 1806 "caspal w24, w25, w26, w27, [sp]"); 1807 COMPARE(caspal(x28, x29, x0, x1, MemOperand(x2)), 1808 "caspal x28, x29, x0, x1, [x2]"); 1809 COMPARE(caspal(x4, x5, x6, x7, MemOperand(sp)), 1810 "caspal x4, x5, x6, x7, [sp]"); 1811 1812 1813 CLEANUP(); 1814} 1815 1816// clang-format off 1817#define ATOMIC_MEMORY_DISASM_LIST(V, DEF) \ 1818 V(DEF, add, "add") \ 1819 V(DEF, clr, "clr") \ 1820 V(DEF, eor, "eor") \ 1821 V(DEF, set, "set") \ 1822 V(DEF, smax, "smax") \ 1823 V(DEF, smin, "smin") \ 1824 V(DEF, umax, "umax") \ 1825 V(DEF, umin, "umin") 1826 1827#define ATOMIC_MEMORY_DISASM_STORE_X_MODES(V, NAME, STR) \ 1828 V(NAME, STR) \ 1829 V(NAME##l, STR "l") 1830 1831 1832#define ATOMIC_MEMORY_DISASM_STORE_W_MODES(V, NAME, STR) \ 1833 ATOMIC_MEMORY_DISASM_STORE_X_MODES(V, NAME, STR) \ 1834 V(NAME##b, STR "b") \ 1835 V(NAME##lb, STR "lb") \ 1836 V(NAME##h, STR "h") \ 1837 V(NAME##lh, STR "lh") 1838 1839#define ATOMIC_MEMORY_DISASM_LOAD_X_MODES(V, NAME, STR) \ 1840 ATOMIC_MEMORY_DISASM_STORE_X_MODES(V, NAME, STR) \ 1841 V(NAME##a, STR "a") \ 1842 V(NAME##al, STR "al") 1843 1844#define ATOMIC_MEMORY_DISASM_LOAD_W_MODES(V, NAME, STR) \ 1845 ATOMIC_MEMORY_DISASM_LOAD_X_MODES(V, NAME, STR) \ 1846 V(NAME##ab, STR "ab") \ 1847 V(NAME##alb, STR "alb") \ 1848 V(NAME##ah, STR "ah") \ 1849 V(NAME##alh, STR "alh") 1850// clang-format on 1851 1852TEST(atomic_memory) { 1853 SETUP(); 1854 1855 // These macros generate tests for all the variations of the atomic memory 1856 // operations, e.g. ldadd, ldadda, ldaddb, staddl, etc. 1857 1858#define AM_LOAD_X_TESTS(N, MN) \ 1859 COMPARE(ld##N(x0, x1, MemOperand(x2)), "ld" MN " x0, x1, [x2]"); \ 1860 COMPARE(ld##N(x3, x4, MemOperand(sp)), "ld" MN " x3, x4, [sp]"); 1861#define AM_LOAD_W_TESTS(N, MN) \ 1862 COMPARE(ld##N(w0, w1, MemOperand(x2)), "ld" MN " w0, w1, [x2]"); \ 1863 COMPARE(ld##N(w3, w4, MemOperand(sp)), "ld" MN " w3, w4, [sp]"); 1864#define AM_STORE_X_TESTS(N, MN) \ 1865 COMPARE(st##N(x0, MemOperand(x1)), "st" MN " x0, [x1]"); \ 1866 COMPARE(st##N(x2, MemOperand(sp)), "st" MN " x2, [sp]"); 1867#define AM_STORE_W_TESTS(N, MN) \ 1868 COMPARE(st##N(w0, MemOperand(x1)), "st" MN " w0, [x1]"); \ 1869 COMPARE(st##N(w2, MemOperand(sp)), "st" MN " w2, [sp]"); 1870 1871 ATOMIC_MEMORY_DISASM_LIST(ATOMIC_MEMORY_DISASM_LOAD_X_MODES, AM_LOAD_X_TESTS) 1872 ATOMIC_MEMORY_DISASM_LIST(ATOMIC_MEMORY_DISASM_LOAD_W_MODES, AM_LOAD_W_TESTS) 1873 ATOMIC_MEMORY_DISASM_LIST(ATOMIC_MEMORY_DISASM_STORE_X_MODES, 1874 AM_STORE_X_TESTS) 1875 ATOMIC_MEMORY_DISASM_LIST(ATOMIC_MEMORY_DISASM_STORE_W_MODES, 1876 AM_STORE_W_TESTS) 1877 1878#define AM_SWP_X_TESTS(N, MN) \ 1879 COMPARE(N(x0, x1, MemOperand(x2)), MN " x0, x1, [x2]"); \ 1880 COMPARE(N(x3, x4, MemOperand(sp)), MN " x3, x4, [sp]"); 1881#define AM_SWP_W_TESTS(N, MN) \ 1882 COMPARE(N(w0, w1, MemOperand(x2)), MN " w0, w1, [x2]"); \ 1883 COMPARE(N(w3, w4, MemOperand(sp)), MN " w3, w4, [sp]"); 1884 1885 1886 ATOMIC_MEMORY_DISASM_LOAD_X_MODES(AM_SWP_X_TESTS, swp, "swp") 1887 ATOMIC_MEMORY_DISASM_LOAD_W_MODES(AM_SWP_W_TESTS, swp, "swp") 1888 1889#undef AM_LOAD_X_TESTS 1890#undef AM_LOAD_W_TESTS 1891#undef AM_STORE_X_TESTS 1892#undef AM_STORE_W_TESTS 1893#undef AM_SWP_X_TESTS 1894#undef AM_SWP_W_TESTS 1895 1896 COMPARE(ldaprb(w0, MemOperand(x1)), "ldaprb w0, [x1]"); 1897 COMPARE(ldaprb(w2, MemOperand(sp)), "ldaprb w2, [sp]"); 1898 COMPARE(ldaprh(w3, MemOperand(x4)), "ldaprh w3, [x4]"); 1899 COMPARE(ldaprh(w5, MemOperand(sp)), "ldaprh w5, [sp]"); 1900 COMPARE(ldapr(w6, MemOperand(x7)), "ldapr w6, [x7]"); 1901 COMPARE(ldapr(w8, MemOperand(sp)), "ldapr w8, [sp]"); 1902 COMPARE(ldapr(x9, MemOperand(x10)), "ldapr x9, [x10]"); 1903 COMPARE(ldapr(x11, MemOperand(sp)), "ldapr x11, [sp]"); 1904 1905 CLEANUP(); 1906} 1907 1908TEST(load_store_rcpc_unscaled_offset) { 1909 SETUP(); 1910 1911 COMPARE(ldapurb(w0, MemOperand(x1)), "ldapurb w0, [x1]"); 1912 COMPARE(ldapurb(w2, MemOperand(x3, 13)), "ldapurb w2, [x3, #13]"); 1913 COMPARE(ldapursb(w4, MemOperand(x5, 129)), "ldapursb w4, [x5, #129]"); 1914 COMPARE(ldapursb(x6, MemOperand(sp, 64)), "ldapursb x6, [sp, #64]"); 1915 COMPARE(ldapurh(w7, MemOperand(x8)), "ldapurh w7, [x8]"); 1916 COMPARE(ldapurh(w9, MemOperand(x10, 13)), "ldapurh w9, [x10, #13]"); 1917 COMPARE(ldapursh(w11, MemOperand(x12, 129)), "ldapursh w11, [x12, #129]"); 1918 COMPARE(ldapursh(x13, MemOperand(sp, 64)), "ldapursh x13, [sp, #64]"); 1919 COMPARE(ldapur(w14, MemOperand(x15)), "ldapur w14, [x15]"); 1920 COMPARE(ldapur(w16, MemOperand(x17, 13)), "ldapur w16, [x17, #13]"); 1921 COMPARE(ldapursw(x18, MemOperand(sp, 64)), "ldapursw x18, [sp, #64]"); 1922 COMPARE(ldapur(x19, MemOperand(x20)), "ldapur x19, [x20]"); 1923 COMPARE(ldapur(x21, MemOperand(sp, 64)), "ldapur x21, [sp, #64]"); 1924 1925 COMPARE(stlurb(w22, MemOperand(x23)), "stlurb w22, [x23]"); 1926 COMPARE(stlurb(w24, MemOperand(sp, 64)), "stlurb w24, [sp, #64]"); 1927 COMPARE(stlurh(w25, MemOperand(x26)), "stlurh w25, [x26]"); 1928 COMPARE(stlurh(w27, MemOperand(sp, 64)), "stlurh w27, [sp, #64]"); 1929 COMPARE(stlur(w28, MemOperand(x29)), "stlur w28, [x29]"); 1930 COMPARE(stlur(w0, MemOperand(sp, 64)), "stlur w0, [sp, #64]"); 1931 COMPARE(stlur(x1, MemOperand(x2)), "stlur x1, [x2]"); 1932 COMPARE(stlur(x3, MemOperand(sp, 64)), "stlur x3, [sp, #64]"); 1933 1934 1935 COMPARE_MACRO(Ldaprb(w0, MemOperand(x1)), "ldaprb w0, [x1]"); 1936 COMPARE_MACRO(Ldaprb(w2, MemOperand(x3, 13)), "ldapurb w2, [x3, #13]"); 1937 COMPARE_MACRO(Ldaprh(w4, MemOperand(x5)), "ldaprh w4, [x5]"); 1938 COMPARE_MACRO(Ldaprh(w6, MemOperand(x7, 13)), "ldapurh w6, [x7, #13]"); 1939 COMPARE_MACRO(Ldapr(w8, MemOperand(x9)), "ldapr w8, [x9]"); 1940 COMPARE_MACRO(Ldapr(w10, MemOperand(x11, 13)), "ldapur w10, [x11, #13]"); 1941 COMPARE_MACRO(Ldapr(x12, MemOperand(x13)), "ldapr x12, [x13]"); 1942 COMPARE_MACRO(Ldapr(x14, MemOperand(sp, 64)), "ldapur x14, [sp, #64]"); 1943 1944 COMPARE_MACRO(Stlrb(w15, MemOperand(x16)), "stlrb w15, [x16]"); 1945 COMPARE_MACRO(Stlrb(w17, MemOperand(sp, 64)), "stlurb w17, [sp, #64]"); 1946 COMPARE_MACRO(Stlrh(w18, MemOperand(x19)), "stlrh w18, [x19]"); 1947 COMPARE_MACRO(Stlrh(w20, MemOperand(sp, 64)), "stlurh w20, [sp, #64]"); 1948 COMPARE_MACRO(Stlr(w21, MemOperand(x22)), "stlr w21, [x22]"); 1949 COMPARE_MACRO(Stlr(w23, MemOperand(sp, 64)), "stlur w23, [sp, #64]"); 1950 COMPARE_MACRO(Stlr(x24, MemOperand(x25)), "stlr x24, [x25]"); 1951 COMPARE_MACRO(Stlr(x26, MemOperand(sp, 64)), "stlur x26, [sp, #64]"); 1952 1953 CLEANUP(); 1954} 1955 1956 1957TEST(load_store_pair_nontemp) { 1958 SETUP(); 1959 1960 COMPARE(ldnp(w0, w1, MemOperand(x2)), "ldnp w0, w1, [x2]"); 1961 COMPARE(stnp(w3, w4, MemOperand(x5, 252)), "stnp w3, w4, [x5, #252]"); 1962 COMPARE(ldnp(w6, w7, MemOperand(x8, -256)), "ldnp w6, w7, [x8, #-256]"); 1963 COMPARE(stnp(x9, x10, MemOperand(x11)), "stnp x9, x10, [x11]"); 1964 COMPARE(ldnp(x12, x13, MemOperand(x14, 504)), "ldnp x12, x13, [x14, #504]"); 1965 COMPARE(stnp(x15, x16, MemOperand(x17, -512)), "stnp x15, x16, [x17, #-512]"); 1966 COMPARE(ldnp(s18, s19, MemOperand(x20)), "ldnp s18, s19, [x20]"); 1967 COMPARE(stnp(s21, s22, MemOperand(x23, 252)), "stnp s21, s22, [x23, #252]"); 1968 COMPARE(ldnp(s24, s25, MemOperand(x26, -256)), "ldnp s24, s25, [x26, #-256]"); 1969 COMPARE(stnp(d27, d28, MemOperand(x29)), "stnp d27, d28, [x29]"); 1970 COMPARE(ldnp(d30, d31, MemOperand(x0, 504)), "ldnp d30, d31, [x0, #504]"); 1971 COMPARE(stnp(d1, d2, MemOperand(x3, -512)), "stnp d1, d2, [x3, #-512]"); 1972 COMPARE(ldnp(q4, q5, MemOperand(x6)), "ldnp q4, q5, [x6]"); 1973 COMPARE(stnp(q7, q8, MemOperand(x9, 1008)), "stnp q7, q8, [x9, #1008]"); 1974 COMPARE(ldnp(q10, q11, MemOperand(x12, -1024)), 1975 "ldnp q10, q11, [x12, #-1024]"); 1976 1977 CLEANUP(); 1978} 1979 1980 1981TEST(load_literal_macro) { 1982 SETUP(); 1983 1984 // In each case, the literal will be placed at PC+8: 1985 // ldr x10, pc+8 // Test instruction. 1986 // ldr xzr, pc+12 // Pool marker. 1987 // .word64 #0x1234567890abcdef // Test literal. 1988 1989 COMPARE_MACRO_PREFIX(Ldr(x10, 0x1234567890abcdef), "ldr x10, pc+8"); 1990 COMPARE_MACRO_PREFIX(Ldr(w20, 0xfedcba09), "ldr w20, pc+8"); 1991 COMPARE_MACRO_PREFIX(Ldr(d11, 1.234), "ldr d11, pc+8"); 1992 COMPARE_MACRO_PREFIX(Ldr(s22, 2.5f), "ldr s22, pc+8"); 1993 COMPARE_MACRO_PREFIX(Ldrsw(x21, 0x80000000), "ldrsw x21, pc+8"); 1994 1995 CLEANUP(); 1996} 1997 1998 1999TEST(load_literal) { 2000 SETUP(); 2001 2002 COMPARE_PREFIX(ldr(x20, INT64_C(0)), "ldr x20, pc+0"); 2003 COMPARE_PREFIX(ldr(x20, 1), "ldr x20, pc+4"); 2004 COMPARE_PREFIX(ldr(x20, -1), "ldr x20, pc-4"); 2005 COMPARE_PREFIX(ldr(x20, 0x3ffff), "ldr x20, pc+1048572"); 2006 COMPARE_PREFIX(ldr(x20, -0x40000), "ldr x20, pc-1048576"); 2007 COMPARE_PREFIX(ldr(w21, INT64_C(0)), "ldr w21, pc+0"); 2008 COMPARE_PREFIX(ldr(w21, 1), "ldr w21, pc+4"); 2009 COMPARE_PREFIX(ldr(w21, -1), "ldr w21, pc-4"); 2010 COMPARE_PREFIX(ldr(w21, 0x3ffff), "ldr w21, pc+1048572"); 2011 COMPARE_PREFIX(ldr(w21, -0x40000), "ldr w21, pc-1048576"); 2012 COMPARE_PREFIX(ldr(d22, INT64_C(0)), "ldr d22, pc+0"); 2013 COMPARE_PREFIX(ldr(d22, 1), "ldr d22, pc+4"); 2014 COMPARE_PREFIX(ldr(d22, -1), "ldr d22, pc-4"); 2015 COMPARE_PREFIX(ldr(d22, 0x3ffff), "ldr d22, pc+1048572"); 2016 COMPARE_PREFIX(ldr(d22, -0x40000), "ldr d22, pc-1048576"); 2017 COMPARE_PREFIX(ldr(s23, INT64_C(0)), "ldr s23, pc+0"); 2018 COMPARE_PREFIX(ldr(s23, 1), "ldr s23, pc+4"); 2019 COMPARE_PREFIX(ldr(s23, -1), "ldr s23, pc-4"); 2020 COMPARE_PREFIX(ldr(s23, 0x3ffff), "ldr s23, pc+1048572"); 2021 COMPARE_PREFIX(ldr(s23, -0x40000), "ldr s23, pc-1048576"); 2022 COMPARE_PREFIX(ldrsw(x24, INT64_C(0)), "ldrsw x24, pc+0"); 2023 COMPARE_PREFIX(ldrsw(x24, 1), "ldrsw x24, pc+4"); 2024 COMPARE_PREFIX(ldrsw(x24, -1), "ldrsw x24, pc-4"); 2025 COMPARE_PREFIX(ldrsw(x24, 0x3ffff), "ldrsw x24, pc+1048572"); 2026 COMPARE_PREFIX(ldrsw(x24, -0x40000), "ldrsw x24, pc-1048576"); 2027 2028 CLEANUP(); 2029} 2030 2031 2032TEST(prfm_operations) { 2033 SETUP(); 2034 2035 // Test every encodable prefetch operation. 2036 const char* expected[] = {"prfm pldl1keep, ", "prfm pldl1strm, ", 2037 "prfm pldl2keep, ", "prfm pldl2strm, ", 2038 "prfm pldl3keep, ", "prfm pldl3strm, ", 2039 "prfm #0b00110, ", "prfm #0b00111, ", 2040 "prfm plil1keep, ", "prfm plil1strm, ", 2041 "prfm plil2keep, ", "prfm plil2strm, ", 2042 "prfm plil3keep, ", "prfm plil3strm, ", 2043 "prfm #0b01110, ", "prfm #0b01111, ", 2044 "prfm pstl1keep, ", "prfm pstl1strm, ", 2045 "prfm pstl2keep, ", "prfm pstl2strm, ", 2046 "prfm pstl3keep, ", "prfm pstl3strm, ", 2047 "prfm #0b10110, ", "prfm #0b10111, "}; 2048 2049 for (int op = 0; op < (1 << ImmPrefetchOperation_width); op++) { 2050 // Prefetch operations of the form 0b11xxx are allocated to another 2051 // instruction. 2052 if (op >= 0b11000) continue; 2053 2054 COMPARE_PREFIX(prfm(op, INT64_C(0)), expected[op]); 2055 COMPARE_PREFIX(prfm(op, MemOperand(x0, 0)), expected[op]); 2056 COMPARE_PREFIX(prfm(op, MemOperand(x0, x1)), expected[op]); 2057 } 2058 2059 CLEANUP(); 2060} 2061 2062 2063TEST(prfum_operations) { 2064 SETUP(); 2065 2066 // Test every encodable prefetch operation. 2067 const char* expected[] = { 2068 "prfum pldl1keep, ", "prfum pldl1strm, ", "prfum pldl2keep, ", 2069 "prfum pldl2strm, ", "prfum pldl3keep, ", "prfum pldl3strm, ", 2070 "prfum #0b00110, ", "prfum #0b00111, ", "prfum plil1keep, ", 2071 "prfum plil1strm, ", "prfum plil2keep, ", "prfum plil2strm, ", 2072 "prfum plil3keep, ", "prfum plil3strm, ", "prfum #0b01110, ", 2073 "prfum #0b01111, ", "prfum pstl1keep, ", "prfum pstl1strm, ", 2074 "prfum pstl2keep, ", "prfum pstl2strm, ", "prfum pstl3keep, ", 2075 "prfum pstl3strm, ", "prfum #0b10110, ", "prfum #0b10111, ", 2076 "prfum #0b11000, ", "prfum #0b11001, ", "prfum #0b11010, ", 2077 "prfum #0b11011, ", "prfum #0b11100, ", "prfum #0b11101, ", 2078 "prfum #0b11110, ", "prfum #0b11111, ", 2079 }; 2080 const int expected_count = sizeof(expected) / sizeof(expected[0]); 2081 VIXL_STATIC_ASSERT((1 << ImmPrefetchOperation_width) == expected_count); 2082 2083 for (int op = 0; op < (1 << ImmPrefetchOperation_width); op++) { 2084 COMPARE_PREFIX(prfum(op, MemOperand(x0, 0)), expected[op]); 2085 } 2086 2087 CLEANUP(); 2088} 2089 2090 2091TEST(prfm_offset) { 2092 SETUP(); 2093 2094 COMPARE(prfm(PLDL1KEEP, MemOperand(x1)), "prfm pldl1keep, [x1]"); 2095 COMPARE(prfm(PLDL1STRM, MemOperand(x3, 8)), "prfm pldl1strm, [x3, #8]"); 2096 COMPARE(prfm(PLDL2KEEP, MemOperand(x5, 32760)), 2097 "prfm pldl2keep, [x5, #32760]"); 2098 2099 COMPARE(prfm(PLDL2STRM, MemOperand(sp)), "prfm pldl2strm, [sp]"); 2100 COMPARE(prfm(PLDL3KEEP, MemOperand(sp, 8)), "prfm pldl3keep, [sp, #8]"); 2101 COMPARE(prfm(PLDL3STRM, MemOperand(sp, 32760)), 2102 "prfm pldl3strm, [sp, #32760]"); 2103 2104 CLEANUP(); 2105} 2106 2107 2108TEST(prfm_regoffset) { 2109 SETUP(); 2110 2111 COMPARE(prfm(PLIL1KEEP, MemOperand(x1, x2)), "prfm plil1keep, [x1, x2]"); 2112 COMPARE(prfm(PLIL1STRM, MemOperand(x3, w4, SXTW)), 2113 "prfm plil1strm, [x3, w4, sxtw]"); 2114 COMPARE(prfm(PLIL2KEEP, MemOperand(x5, x6, LSL, 3)), 2115 "prfm plil2keep, [x5, x6, lsl #3]"); 2116 2117 COMPARE(prfm(PLIL2STRM, MemOperand(sp, xzr)), "prfm plil2strm, [sp, xzr]"); 2118 COMPARE(prfm(PLIL3KEEP, MemOperand(sp, wzr, SXTW)), 2119 "prfm plil3keep, [sp, wzr, sxtw]"); 2120 COMPARE(prfm(PLIL3STRM, MemOperand(sp, xzr, LSL, 3)), 2121 "prfm plil3strm, [sp, xzr, lsl #3]"); 2122 2123 CLEANUP(); 2124} 2125 2126 2127TEST(prfm_literal) { 2128 SETUP(); 2129 2130 COMPARE_PREFIX(prfm(PSTL1KEEP, INT64_C(0)), "prfm pstl1keep, pc+0"); 2131 COMPARE_PREFIX(prfm(PSTL1STRM, 1), "prfm pstl1strm, pc+4"); 2132 COMPARE_PREFIX(prfm(PSTL2KEEP, -1), "prfm pstl2keep, pc-4"); 2133 COMPARE_PREFIX(prfm(PSTL2STRM, 0x3ffff), "prfm pstl2strm, pc+1048572"); 2134 COMPARE_PREFIX(prfm(PSTL3KEEP, -0x3ffff), "prfm pstl3keep, pc-1048572"); 2135 COMPARE_PREFIX(prfm(PSTL3STRM, -0x40000), "prfm pstl3strm, pc-1048576"); 2136 2137 CLEANUP(); 2138} 2139 2140 2141TEST(prfm_unscaled) { 2142 SETUP(); 2143 2144 // If an unscaled-offset instruction is requested, it is used, even if the 2145 // offset could be encoded in a scaled-offset instruction. 2146 COMPARE(prfum(PLDL1KEEP, MemOperand(x1)), "prfum pldl1keep, [x1]"); 2147 COMPARE(prfum(PLDL1STRM, MemOperand(x1, 8)), "prfum pldl1strm, [x1, #8]"); 2148 COMPARE(prfum(PLDL2KEEP, MemOperand(x1, 248)), "prfum pldl2keep, [x1, #248]"); 2149 2150 // Normal offsets are converted to unscaled offsets if necssary. 2151 COMPARE(prfm(PLDL2STRM, MemOperand(x1, 1)), "prfum pldl2strm, [x1, #1]"); 2152 COMPARE(prfm(PLDL3KEEP, MemOperand(x1, -1)), "prfum pldl3keep, [x1, #-1]"); 2153 COMPARE(prfm(PLDL3STRM, MemOperand(x1, 255)), "prfum pldl3strm, [x1, #255]"); 2154 COMPARE(prfm(PLDL3STRM, MemOperand(x1, -256)), 2155 "prfum pldl3strm, [x1, #-256]"); 2156 2157 CLEANUP(); 2158} 2159 2160 2161TEST(prfm_unscaled_option) { 2162 SETUP(); 2163 2164 // Just like prfm_unscaled, but specify the scaling option explicitly. 2165 2166 // Require unscaled-offset forms. 2167 LoadStoreScalingOption option = RequireUnscaledOffset; 2168 2169 COMPARE(prfum(PLDL1KEEP, MemOperand(x1), option), "prfum pldl1keep, [x1]"); 2170 COMPARE(prfum(PLDL1STRM, MemOperand(x1, 8), option), 2171 "prfum pldl1strm, [x1, #8]"); 2172 COMPARE(prfum(PLDL2KEEP, MemOperand(x1, 248), option), 2173 "prfum pldl2keep, [x1, #248]"); 2174 COMPARE(prfum(PLDL2STRM, MemOperand(x1, 1), option), 2175 "prfum pldl2strm, [x1, #1]"); 2176 COMPARE(prfum(PLDL3KEEP, MemOperand(x1, -1), option), 2177 "prfum pldl3keep, [x1, #-1]"); 2178 COMPARE(prfum(PLDL3STRM, MemOperand(x1, 255), option), 2179 "prfum pldl3strm, [x1, #255]"); 2180 COMPARE(prfum(PLIL1KEEP, MemOperand(x1, -256), option), 2181 "prfum plil1keep, [x1, #-256]"); 2182 2183 // Require scaled-offset forms.. 2184 option = RequireScaledOffset; 2185 2186 COMPARE(prfm(PLDL1KEEP, MemOperand(x1), option), "prfm pldl1keep, [x1]"); 2187 COMPARE(prfm(PLDL1STRM, MemOperand(x1, 8), option), 2188 "prfm pldl1strm, [x1, #8]"); 2189 COMPARE(prfm(PLDL2KEEP, MemOperand(x1, 248), option), 2190 "prfm pldl2keep, [x1, #248]"); 2191 COMPARE(prfm(PLIL2STRM, MemOperand(x1, 256), option), 2192 "prfm plil2strm, [x1, #256]"); 2193 COMPARE(prfm(PLIL3KEEP, MemOperand(x1, 32760), option), 2194 "prfm plil3keep, [x1, #32760]"); 2195 2196 // Prefer unscaled-offset forms, but allow scaled-offset forms if necessary. 2197 option = PreferUnscaledOffset; 2198 2199 COMPARE(prfum(PLDL1KEEP, MemOperand(x1), option), "prfum pldl1keep, [x1]"); 2200 COMPARE(prfum(PLDL1STRM, MemOperand(x1, 8), option), 2201 "prfum pldl1strm, [x1, #8]"); 2202 COMPARE(prfum(PLDL2KEEP, MemOperand(x1, 248), option), 2203 "prfum pldl2keep, [x1, #248]"); 2204 COMPARE(prfum(PLDL2STRM, MemOperand(x1, 1), option), 2205 "prfum pldl2strm, [x1, #1]"); 2206 COMPARE(prfum(PLDL3KEEP, MemOperand(x1, -1), option), 2207 "prfum pldl3keep, [x1, #-1]"); 2208 COMPARE(prfum(PLDL3STRM, MemOperand(x1, 255), option), 2209 "prfum pldl3strm, [x1, #255]"); 2210 COMPARE(prfum(PLIL1KEEP, MemOperand(x1, -256), option), 2211 "prfum plil1keep, [x1, #-256]"); 2212 COMPARE(prfum(PLIL1STRM, MemOperand(x1, 256), option), 2213 "prfm plil1strm, [x1, #256]"); 2214 COMPARE(prfum(PLIL2KEEP, MemOperand(x1, 32760), option), 2215 "prfm plil2keep, [x1, #32760]"); 2216 2217 // Prefer scaled-offset forms, but allow unscaled-offset forms if necessary. 2218 option = PreferScaledOffset; 2219 2220 COMPARE(prfm(PLDL1KEEP, MemOperand(x1), option), "prfm pldl1keep, [x1]"); 2221 COMPARE(prfm(PLDL1STRM, MemOperand(x1, 8), option), 2222 "prfm pldl1strm, [x1, #8]"); 2223 COMPARE(prfm(PLDL2KEEP, MemOperand(x1, 248), option), 2224 "prfm pldl2keep, [x1, #248]"); 2225 COMPARE(prfm(PLDL2STRM, MemOperand(x1, 1), option), 2226 "prfum pldl2strm, [x1, #1]"); 2227 COMPARE(prfm(PLDL3KEEP, MemOperand(x1, -1), option), 2228 "prfum pldl3keep, [x1, #-1]"); 2229 COMPARE(prfm(PLDL3STRM, MemOperand(x1, 255), option), 2230 "prfum pldl3strm, [x1, #255]"); 2231 COMPARE(prfm(PLIL1KEEP, MemOperand(x1, -256), option), 2232 "prfum plil1keep, [x1, #-256]"); 2233 COMPARE(prfm(PLIL1STRM, MemOperand(x1, 256), option), 2234 "prfm plil1strm, [x1, #256]"); 2235 COMPARE(prfm(PLIL2KEEP, MemOperand(x1, 32760), option), 2236 "prfm plil2keep, [x1, #32760]"); 2237 2238 CLEANUP(); 2239} 2240 2241 2242TEST(cond_select) { 2243 SETUP(); 2244 2245 COMPARE(csel(w0, w1, w2, eq), "csel w0, w1, w2, eq"); 2246 COMPARE(csel(x3, x4, x5, ne), "csel x3, x4, x5, ne"); 2247 COMPARE(csinc(w6, w7, w8, hs), "csinc w6, w7, w8, hs"); 2248 COMPARE(csinc(x9, x10, x11, lo), "csinc x9, x10, x11, lo"); 2249 COMPARE(csinv(w12, w13, w14, mi), "csinv w12, w13, w14, mi"); 2250 COMPARE(csinv(x15, x16, x17, pl), "csinv x15, x16, x17, pl"); 2251 COMPARE(csneg(w18, w19, w20, vs), "csneg w18, w19, w20, vs"); 2252 COMPARE(csneg(x21, x22, x23, vc), "csneg x21, x22, x23, vc"); 2253 COMPARE(cset(w24, hi), "cset w24, hi"); 2254 COMPARE(cset(x25, ls), "cset x25, ls"); 2255 COMPARE(csetm(w26, ge), "csetm w26, ge"); 2256 COMPARE(csetm(x27, lt), "csetm x27, lt"); 2257 COMPARE(cinc(w28, w29, gt), "cinc w28, w29, gt"); 2258 COMPARE(cinc(x30, x0, le), "cinc x30, x0, le"); 2259 COMPARE(cinv(w1, w2, eq), "cinv w1, w2, eq"); 2260 COMPARE(cinv(x3, x4, ne), "cinv x3, x4, ne"); 2261 COMPARE(cneg(w5, w6, hs), "cneg w5, w6, hs"); 2262 COMPARE(cneg(x7, x8, lo), "cneg x7, x8, lo"); 2263 2264 COMPARE(csel(x0, x1, x2, al), "csel x0, x1, x2, al"); 2265 COMPARE(csel(x1, x2, x3, nv), "csel x1, x2, x3, nv"); 2266 COMPARE(csinc(x2, x3, x4, al), "csinc x2, x3, x4, al"); 2267 COMPARE(csinc(x3, x4, x5, nv), "csinc x3, x4, x5, nv"); 2268 COMPARE(csinv(x4, x5, x6, al), "csinv x4, x5, x6, al"); 2269 COMPARE(csinv(x5, x6, x7, nv), "csinv x5, x6, x7, nv"); 2270 COMPARE(csneg(x6, x7, x8, al), "csneg x6, x7, x8, al"); 2271 COMPARE(csneg(x7, x8, x9, nv), "csneg x7, x8, x9, nv"); 2272 2273 CLEANUP(); 2274} 2275 2276 2277TEST(cond_select_macro) { 2278 SETUP(); 2279 2280 // In the tests below we also test the `GetCselSynthesisInformation()` helper. 2281 // These tests are here (rather than in test-assembler-aarch64.cc) because the 2282 // disassembly makes it easy to see whether or not the inputs are synthesised. 2283 bool synthesises_left = false; 2284 bool synthesises_right = false; 2285 2286 COMPARE_MACRO(Csel(w0, w1, -1, eq), "csinv w0, w1, wzr, eq"); 2287 MacroAssembler::GetCselSynthesisInformation(w0, 2288 w1, 2289 -1, 2290 &synthesises_left, 2291 &synthesises_right); 2292 VIXL_CHECK(!synthesises_left && !synthesises_right); 2293 2294 COMPARE_MACRO(Csel(w2, w3, 0, ne), "csel w2, w3, wzr, ne"); 2295 MacroAssembler::GetCselSynthesisInformation(w2, 2296 w3, 2297 wzr, 2298 &synthesises_left, 2299 &synthesises_right); 2300 VIXL_CHECK(!synthesises_left && !synthesises_right); 2301 2302 COMPARE_MACRO(Csel(w4, w5, 1, hs), "csinc w4, w5, wzr, hs"); 2303 MacroAssembler::GetCselSynthesisInformation(w4, 2304 w5, 2305 1, 2306 &synthesises_left, 2307 &synthesises_right); 2308 VIXL_CHECK(!synthesises_left && !synthesises_right); 2309 2310 COMPARE_MACRO(Csel(x6, x7, -1, lo), "csinv x6, x7, xzr, lo"); 2311 MacroAssembler::GetCselSynthesisInformation(x6, 2312 x7, 2313 xzr, 2314 &synthesises_left, 2315 &synthesises_right); 2316 VIXL_CHECK(!synthesises_left && !synthesises_right); 2317 2318 COMPARE_MACRO(Csel(x8, x9, 0, mi), "csel x8, x9, xzr, mi"); 2319 MacroAssembler::GetCselSynthesisInformation(x8, 2320 x9, 2321 xzr, 2322 &synthesises_left, 2323 &synthesises_right); 2324 VIXL_CHECK(!synthesises_left && !synthesises_right); 2325 2326 COMPARE_MACRO(Csel(x10, x11, 1, pl), "csinc x10, x11, xzr, pl"); 2327 MacroAssembler::GetCselSynthesisInformation(x10, 2328 x11, 2329 xzr, 2330 &synthesises_left, 2331 &synthesises_right); 2332 VIXL_CHECK(!synthesises_left && !synthesises_right); 2333 2334 COMPARE_MACRO(Csel(x12, 0, 0, eq), "mov x12, #0x0"); 2335 MacroAssembler::GetCselSynthesisInformation(x12, 2336 0, 2337 0, 2338 &synthesises_left, 2339 &synthesises_right); 2340 VIXL_CHECK(!synthesises_left && !synthesises_right); 2341 2342 COMPARE_MACRO(Csel(w13, 0, 1, eq), "cset w13, ne"); 2343 MacroAssembler::GetCselSynthesisInformation(w13, 2344 0, 2345 1, 2346 &synthesises_left, 2347 &synthesises_right); 2348 VIXL_CHECK(!synthesises_left && !synthesises_right); 2349 2350 COMPARE_MACRO(Csel(x14, 1, 0, eq), "cset x14, eq"); 2351 MacroAssembler::GetCselSynthesisInformation(x14, 2352 1, 2353 0, 2354 &synthesises_left, 2355 &synthesises_right); 2356 VIXL_CHECK(!synthesises_left && !synthesises_right); 2357 2358 COMPARE_MACRO(Csel(w15, 0, -1, eq), "csetm w15, ne"); 2359 MacroAssembler::GetCselSynthesisInformation(w15, 2360 0, 2361 -1, 2362 &synthesises_left, 2363 &synthesises_right); 2364 VIXL_CHECK(!synthesises_left && !synthesises_right); 2365 2366 COMPARE_MACRO(Csel(x18, -1, 0, eq), "csetm x18, eq"); 2367 MacroAssembler::GetCselSynthesisInformation(x18, 2368 -1, 2369 0, 2370 &synthesises_left, 2371 &synthesises_right); 2372 VIXL_CHECK(!synthesises_left && !synthesises_right); 2373 2374 COMPARE_MACRO(Csel(w19, -1, 1, eq), 2375 "mov w19, #0x1\n" 2376 "cneg w19, w19, eq"); 2377 MacroAssembler::GetCselSynthesisInformation(w19, 2378 -1, 2379 1, 2380 &synthesises_left, 2381 &synthesises_right); 2382 VIXL_CHECK(!synthesises_left && synthesises_right); 2383 2384 COMPARE_MACRO(Csel(x20, 1, -1, eq), 2385 "mov x20, #0xffffffffffffffff\n" 2386 "cneg x20, x20, eq"); 2387 MacroAssembler::GetCselSynthesisInformation(x20, 2388 1, 2389 -1, 2390 &synthesises_left, 2391 &synthesises_right); 2392 VIXL_CHECK(!synthesises_left && synthesises_right); 2393 2394 COMPARE_MACRO(Csel(w21, 0xaa, 0xbb, eq), 2395 "mov w16, #0xaa\n" 2396 "mov w17, #0xbb\n" 2397 "csel w21, w16, w17, eq"); 2398 MacroAssembler::GetCselSynthesisInformation(w21, 2399 0xaa, 2400 0xbb, 2401 &synthesises_left, 2402 &synthesises_right); 2403 VIXL_CHECK(synthesises_left && synthesises_right); 2404 2405 COMPARE_MACRO(Csel(x22, 0xaa, -0xbb, eq), 2406 "mov x16, #0xaa\n" 2407 "mov x17, #0xffffffffffffff45\n" 2408 "csel x22, x16, x17, eq"); 2409 MacroAssembler::GetCselSynthesisInformation(x22, 2410 0xaa, 2411 -0xbb, 2412 &synthesises_left, 2413 &synthesises_right); 2414 VIXL_CHECK(synthesises_left && synthesises_right); 2415 2416 COMPARE_MACRO(Csel(w23, 0, 0xaa, eq), 2417 "mov w16, #0xaa\n" 2418 "csel w23, w16, wzr, ne"); 2419 MacroAssembler::GetCselSynthesisInformation(w23, 2420 0, 2421 0xaa, 2422 &synthesises_left, 2423 &synthesises_right); 2424 VIXL_CHECK(!synthesises_left && synthesises_right); 2425 2426 COMPARE_MACRO(Csel(x24, -0xaa, 0, eq), 2427 "mov x16, #0xffffffffffffff56\n" 2428 "csel x24, x16, xzr, eq"); 2429 MacroAssembler::GetCselSynthesisInformation(x24, 2430 -0xaa, 2431 0, 2432 &synthesises_left, 2433 &synthesises_right); 2434 VIXL_CHECK(synthesises_left && !synthesises_right); 2435 2436 COMPARE_MACRO(Csel(w25, 0xcc, -0xcc, eq), 2437 "mov w25, #0xffffff34\n" 2438 "cneg w25, w25, eq"); 2439 MacroAssembler::GetCselSynthesisInformation(w25, 2440 0xcc, 2441 -0xcc, 2442 &synthesises_left, 2443 &synthesises_right); 2444 VIXL_CHECK(!synthesises_left && synthesises_right); 2445 2446 COMPARE_MACRO(Csel(x26, -0xcc, 0xcc, eq), 2447 "mov x26, #0xcc\n" 2448 "cneg x26, x26, eq"); 2449 MacroAssembler::GetCselSynthesisInformation(w25, 2450 -0xcc, 2451 0xcc, 2452 &synthesises_left, 2453 &synthesises_right); 2454 VIXL_CHECK(!synthesises_left && synthesises_right); 2455 2456 // Test with `Operand` inputs. 2457 COMPARE_MACRO(Csel(x0, x1, Operand(x2, LSL, 3), eq), 2458 "lsl x16, x2, #3\n" 2459 "csel x0, x1, x16, eq"); 2460 MacroAssembler::GetCselSynthesisInformation(x0, 2461 x1, 2462 Operand(x2, LSL, 3), 2463 &synthesises_left, 2464 &synthesises_right); 2465 VIXL_CHECK(!synthesises_left && synthesises_right); 2466 2467 COMPARE_MACRO(Csel(x3, x4, Operand(x5, SXTH), eq), 2468 "sxth x16, w5\n" 2469 "csel x3, x4, x16, eq"); 2470 MacroAssembler::GetCselSynthesisInformation(x3, 2471 x4, 2472 Operand(x5, SXTH), 2473 &synthesises_left, 2474 &synthesises_right); 2475 VIXL_CHECK(!synthesises_left && synthesises_right); 2476 2477 COMPARE_MACRO(Csel(x6, Operand(x7, LSL, 7), x8, eq), 2478 "lsl x16, x7, #7\n" 2479 "csel x6, x16, x8, eq"); 2480 MacroAssembler::GetCselSynthesisInformation(x6, 2481 Operand(x7, LSL, 7), 2482 x8, 2483 &synthesises_left, 2484 &synthesises_right); 2485 VIXL_CHECK(synthesises_left && !synthesises_right); 2486 2487 COMPARE_MACRO(Csel(x9, Operand(x10, SXTH), x11, eq), 2488 "sxth x16, w10\n" 2489 "csel x9, x16, x11, eq"); 2490 MacroAssembler::GetCselSynthesisInformation(x9, 2491 Operand(x10, SXTH), 2492 x11, 2493 &synthesises_left, 2494 &synthesises_right); 2495 VIXL_CHECK(synthesises_left && !synthesises_right); 2496 2497 COMPARE_MACRO(Csel(x12, Operand(x13, LSL, 13), Operand(x14, SXTB), eq), 2498 "lsl x16, x13, #13\n" 2499 "sxtb x17, w14\n" 2500 "csel x12, x16, x17, eq"); 2501 MacroAssembler::GetCselSynthesisInformation(x12, 2502 Operand(x13, LSL, 13), 2503 Operand(x14, SXTB), 2504 &synthesises_left, 2505 &synthesises_right); 2506 VIXL_CHECK(synthesises_left && synthesises_right); 2507 2508 COMPARE_MACRO(Csel(x15, 0, Operand(x18, LSR, 18), eq), 2509 "lsr x16, x18, #18\n" 2510 "csel x15, x16, xzr, ne"); 2511 MacroAssembler::GetCselSynthesisInformation(x15, 2512 0, 2513 Operand(x18, LSR, 18), 2514 &synthesises_left, 2515 &synthesises_right); 2516 VIXL_CHECK(!synthesises_left && synthesises_right); 2517 2518 // Test with the zero register. 2519 COMPARE_MACRO(Csel(w19, wzr, wzr, eq), "mov w19, #0x0"); 2520 MacroAssembler::GetCselSynthesisInformation(w19, 2521 wzr, 2522 wzr, 2523 &synthesises_left, 2524 &synthesises_right); 2525 VIXL_CHECK(!synthesises_left && !synthesises_right); 2526 2527 COMPARE_MACRO(Csel(x20, x21, xzr, eq), "csel x20, x21, xzr, eq"); 2528 MacroAssembler::GetCselSynthesisInformation(x20, 2529 x21, 2530 xzr, 2531 &synthesises_left, 2532 &synthesises_right); 2533 VIXL_CHECK(!synthesises_left && !synthesises_right); 2534 2535 COMPARE_MACRO(Csel(w22, wzr, w23, eq), "csel w22, w23, wzr, ne"); 2536 MacroAssembler::GetCselSynthesisInformation(w22, 2537 wzr, 2538 w23, 2539 &synthesises_left, 2540 &synthesises_right); 2541 VIXL_CHECK(!synthesises_left && !synthesises_right); 2542 2543 COMPARE_MACRO(Csel(x24, xzr, 0, eq), "mov x24, #0x0"); 2544 MacroAssembler::GetCselSynthesisInformation(x24, 2545 xzr, 2546 0, 2547 &synthesises_left, 2548 &synthesises_right); 2549 VIXL_CHECK(!synthesises_left && !synthesises_right); 2550 2551 COMPARE_MACRO(Csel(w25, wzr, 1, eq), "cset w25, ne"); 2552 MacroAssembler::GetCselSynthesisInformation(w25, 2553 wzr, 2554 1, 2555 &synthesises_left, 2556 &synthesises_right); 2557 VIXL_CHECK(!synthesises_left && !synthesises_right); 2558 2559 2560 CLEANUP(); 2561} 2562 2563 2564TEST(cond_cmp) { 2565 SETUP(); 2566 2567 COMPARE(ccmn(w0, w1, NZCVFlag, eq), "ccmn w0, w1, #NZCV, eq"); 2568 COMPARE(ccmn(x2, x3, NZCFlag, ne), "ccmn x2, x3, #NZCv, ne"); 2569 COMPARE(ccmp(w4, w5, NZVFlag, hs), "ccmp w4, w5, #NZcV, hs"); 2570 COMPARE(ccmp(x6, x7, NZFlag, lo), "ccmp x6, x7, #NZcv, lo"); 2571 COMPARE(ccmn(w8, 31, NFlag, mi), "ccmn w8, #31, #Nzcv, mi"); 2572 COMPARE(ccmn(x9, 30, NCFlag, pl), "ccmn x9, #30, #NzCv, pl"); 2573 COMPARE(ccmp(w10, 29, NVFlag, vs), "ccmp w10, #29, #NzcV, vs"); 2574 COMPARE(ccmp(x11, 28, NFlag, vc), "ccmp x11, #28, #Nzcv, vc"); 2575 COMPARE(ccmn(w12, w13, NoFlag, al), "ccmn w12, w13, #nzcv, al"); 2576 COMPARE(ccmp(x14, 27, ZVFlag, nv), "ccmp x14, #27, #nZcV, nv"); 2577 2578 CLEANUP(); 2579} 2580 2581 2582TEST(cond_cmp_macro) { 2583 SETUP(); 2584 2585 COMPARE_MACRO(Ccmp(w0, -1, VFlag, hi), "ccmn w0, #1, #nzcV, hi"); 2586 COMPARE_MACRO(Ccmp(x1, -31, CFlag, ge), "ccmn x1, #31, #nzCv, ge"); 2587 COMPARE_MACRO(Ccmn(w2, -1, CVFlag, gt), "ccmp w2, #1, #nzCV, gt"); 2588 COMPARE_MACRO(Ccmn(x3, -31, ZCVFlag, ls), "ccmp x3, #31, #nZCV, ls"); 2589 2590 CLEANUP(); 2591} 2592 2593 2594TEST(system_clrex) { 2595 SETUP(); 2596 2597 COMPARE(clrex(0), "clrex #0x0"); 2598 COMPARE(clrex(14), "clrex #0xe"); 2599 COMPARE(clrex(15), "clrex"); 2600 COMPARE(clrex(), "clrex"); 2601 2602 CLEANUP(); 2603} 2604 2605 2606TEST(system_mrs) { 2607 SETUP(); 2608 2609 COMPARE(mrs(x0, NZCV), "mrs x0, nzcv"); 2610 COMPARE(mrs(x30, NZCV), "mrs x30, nzcv"); 2611 COMPARE(mrs(x15, FPCR), "mrs x15, fpcr"); 2612 COMPARE(mrs(x20, RNDR), "mrs x20, rndr"); 2613 COMPARE(mrs(x5, RNDRRS), "mrs x5, rndrrs"); 2614 2615 // Test mrs that use system registers we haven't named. 2616 COMPARE(dci(MRS | (0x5555 << 5)), "mrs x0, S3_2_c10_c10_5"); 2617 COMPARE(dci(0xd53e1000), "mrs x0, S3_6_c1_c0_0"); 2618 2619 CLEANUP(); 2620} 2621 2622 2623TEST(system_msr) { 2624 SETUP(); 2625 2626 COMPARE(msr(NZCV, x0), "msr nzcv, x0"); 2627 COMPARE(msr(NZCV, x30), "msr nzcv, x30"); 2628 COMPARE(msr(FPCR, x15), "msr fpcr, x15"); 2629 2630 // Test msr that use system registers we haven't named. 2631 COMPARE(dci(MSR | (0x1234 << 5)), "msr S2_2_c4_c6_4, x0"); 2632 COMPARE(dci(0xd51e1000), "msr S3_6_c1_c0_0, x0"); 2633 2634 CLEANUP(); 2635} 2636 2637 2638TEST(system_pstate) { 2639 SETUP(); 2640 2641 COMPARE(cfinv(), "cfinv"); 2642 COMPARE(axflag(), "axflag"); 2643 COMPARE(xaflag(), "xaflag"); 2644 2645 CLEANUP(); 2646} 2647 2648 2649TEST(system_sys) { 2650 SETUP(); 2651 2652 COMPARE(sys(0x3, 0x7, 0x5, 0x1, x1), "ic ivau, x1"); 2653 COMPARE(sys(0x3, 0x7, 0xa, 0x1, x2), "dc cvac, x2"); 2654 COMPARE(sys(0x3, 0x7, 0xb, 0x1, x3), "dc cvau, x3"); 2655 COMPARE(sys(0x3, 0x7, 0xe, 0x1, x4), "dc civac, x4"); 2656 COMPARE(sys(0x3, 0x7, 0xc, 0x1, x5), "dc cvap, x5"); 2657 COMPARE(sys(0x3, 0x7, 0xd, 0x1, x6), "dc cvadp, x6"); 2658 COMPARE(sys(0x3, 0x7, 0x4, 0x1, x0), "dc zva, x0"); 2659 COMPARE(sys(0x0, 0x0, 0x0, 0x0, x0), "sys #0, C0, C0, #0, x0"); 2660 COMPARE(sys(0x1, 0x2, 0x5, 0x2, x5), "sys #1, C2, C5, #2, x5"); 2661 COMPARE(sys(0x2, 0x8, 0xa, 0x3, x6), "sys #2, C8, C10, #3, x6"); 2662 COMPARE(sys(0x2, 0xf, 0xf, 0x1, xzr), "sys #2, C15, C15, #1"); 2663 COMPARE(sys(0x2, 0xf, 0xf, 0x1), "sys #2, C15, C15, #1"); 2664 2665 CLEANUP(); 2666} 2667 2668 2669TEST(system_ic) { 2670 SETUP(); 2671 2672 COMPARE(ic(IVAU, x0), "ic ivau, x0"); 2673 COMPARE(ic(IVAU, x1), "ic ivau, x1"); 2674 COMPARE(ic(IVAU, xzr), "ic ivau, xzr"); 2675 2676 CLEANUP(); 2677} 2678 2679 2680TEST(system_dc) { 2681 SETUP(); 2682 2683 COMPARE(dc(CVAC, x2), "dc cvac, x2"); 2684 COMPARE(dc(CVAU, x3), "dc cvau, x3"); 2685 COMPARE(dc(CVAP, x4), "dc cvap, x4"); 2686 COMPARE(dc(CIVAC, x5), "dc civac, x5"); 2687 COMPARE(dc(CVADP, x6), "dc cvadp, x6"); 2688 COMPARE(dc(ZVA, x0), "dc zva, x0"); 2689 COMPARE(dc(ZVA, xzr), "dc zva, xzr"); 2690 2691 CLEANUP(); 2692} 2693 2694TEST(system_dc_mte) { 2695 SETUP(); 2696 2697 COMPARE(dc(GVA, x0), "dc gva, x0"); 2698 COMPARE(dc(GZVA, x1), "dc gzva, x1"); 2699 COMPARE(dc(CGVAC, x2), "dc cgvac, x2"); 2700 COMPARE(dc(CGDVAC, x3), "dc cgdvac, x3"); 2701 COMPARE(dc(CGVAP, x3), "dc cgvap, x3"); 2702 COMPARE(dc(CGDVAP, x3), "dc cgdvap, x3"); 2703 COMPARE(dc(CIGVAC, x4), "dc cigvac, x4"); 2704 COMPARE(dc(CIGDVAC, x4), "dc cigdvac, x4"); 2705 2706 CLEANUP(); 2707} 2708 2709TEST(system_nop) { 2710 SETUP(); 2711 2712 COMPARE(nop(), "nop"); 2713 COMPARE_MACRO(Nop(), "nop"); 2714 2715 CLEANUP(); 2716} 2717 2718 2719TEST(system_pauth) { 2720 SETUP(); 2721 2722 COMPARE(pacia1716(), "pacia1716"); 2723 COMPARE(pacib1716(), "pacib1716"); 2724 COMPARE(paciaz(), "paciaz"); 2725 COMPARE(pacibz(), "pacibz"); 2726 COMPARE(paciasp(), "paciasp"); 2727 COMPARE(pacibsp(), "pacibsp"); 2728 COMPARE(autia1716(), "autia1716"); 2729 COMPARE(autib1716(), "autib1716"); 2730 COMPARE(autiaz(), "autiaz"); 2731 COMPARE(autibz(), "autibz"); 2732 COMPARE(autiasp(), "autiasp"); 2733 COMPARE(autibsp(), "autibsp"); 2734 COMPARE(xpaclri(), "xpaclri"); 2735 2736 CLEANUP(); 2737} 2738 2739 2740TEST(unreachable) { 2741 SETUP(); 2742 2743 VIXL_ASSERT(kUnreachableOpcode == 0xdeb0); 2744#ifdef VIXL_INCLUDE_SIMULATOR_AARCH64 2745 COMPARE_MACRO(Unreachable(), "hlt #0xdeb0"); 2746#else 2747 COMPARE_MACRO(Unreachable(), "udf #0xdeb0"); 2748#endif 2749 2750 CLEANUP(); 2751} 2752 2753 2754#ifdef VIXL_INCLUDE_SIMULATOR_AARCH64 2755TEST(trace) { 2756 SETUP(); 2757 2758 VIXL_ASSERT(kTraceOpcode == 0xdeb2); 2759 2760 // All Trace calls should produce the same instruction. 2761 COMPARE_MACRO_PREFIX(Trace(LOG_ALL, TRACE_ENABLE), "hlt #0xdeb2"); 2762 COMPARE_MACRO_PREFIX(Trace(LOG_REGS, TRACE_DISABLE), "hlt #0xdeb2"); 2763 2764 CLEANUP(); 2765} 2766#endif 2767 2768 2769#ifdef VIXL_INCLUDE_SIMULATOR_AARCH64 2770TEST(log) { 2771 SETUP(); 2772 2773 VIXL_ASSERT(kLogOpcode == 0xdeb3); 2774 2775 // All Log calls should produce the same instruction. 2776 COMPARE_MACRO_PREFIX(Log(LOG_ALL), "hlt #0xdeb3"); 2777 COMPARE_MACRO_PREFIX(Log(LOG_SYSREGS), "hlt #0xdeb3"); 2778 2779 CLEANUP(); 2780} 2781#endif 2782 2783 2784TEST(hlt) { 2785 SETUP(); 2786 2787 COMPARE(hlt(0), "hlt #0x0"); 2788 COMPARE(hlt(1), "hlt #0x1"); 2789 COMPARE(hlt(65535), "hlt #0xffff"); 2790 2791 CLEANUP(); 2792} 2793 2794 2795TEST(brk) { 2796 SETUP(); 2797 2798 COMPARE(brk(0), "brk #0x0"); 2799 COMPARE(brk(1), "brk #0x1"); 2800 COMPARE(brk(65535), "brk #0xffff"); 2801 2802 CLEANUP(); 2803} 2804 2805 2806TEST(svc) { 2807 SETUP(); 2808 2809 COMPARE(svc(0), "svc #0x0"); 2810 COMPARE(svc(1), "svc #0x1"); 2811 COMPARE(svc(65535), "svc #0xffff"); 2812 2813 CLEANUP(); 2814} 2815 2816 2817TEST(add_sub_negative) { 2818 SETUP(); 2819 2820 COMPARE_MACRO(Add(x10, x0, -42), "sub x10, x0, #0x2a (42)"); 2821 COMPARE_MACRO(Add(x11, x1, -687), "sub x11, x1, #0x2af (687)"); 2822 COMPARE_MACRO(Add(x12, x2, -0x88), "sub x12, x2, #0x88 (136)"); 2823 2824 COMPARE_MACRO(Sub(x13, x0, -600), "add x13, x0, #0x258 (600)"); 2825 COMPARE_MACRO(Sub(x14, x1, -313), "add x14, x1, #0x139 (313)"); 2826 COMPARE_MACRO(Sub(x15, x2, -0x555), "add x15, x2, #0x555 (1365)"); 2827 2828 COMPARE_MACRO(Add(w19, w3, -0x344), "sub w19, w3, #0x344 (836)"); 2829 COMPARE_MACRO(Add(w20, w4, -2000), "sub w20, w4, #0x7d0 (2000)"); 2830 2831 COMPARE_MACRO(Add(w0, w1, 5, LeaveFlags), "add w0, w1, #0x5 (5)"); 2832 COMPARE_MACRO(Add(w1, w2, 15, SetFlags), "adds w1, w2, #0xf (15)"); 2833 2834 COMPARE_MACRO(Sub(w0, w1, 5, LeaveFlags), "sub w0, w1, #0x5 (5)"); 2835 COMPARE_MACRO(Sub(w1, w2, 15, SetFlags), "subs w1, w2, #0xf (15)"); 2836 2837 COMPARE_MACRO(Sub(w21, w3, -0xbc), "add w21, w3, #0xbc (188)"); 2838 COMPARE_MACRO(Sub(w22, w4, -2000), "add w22, w4, #0x7d0 (2000)"); 2839 2840 COMPARE_MACRO(Cmp(w0, -1), "cmn w0, #0x1 (1)"); 2841 COMPARE_MACRO(Cmp(x1, -1), "cmn x1, #0x1 (1)"); 2842 COMPARE_MACRO(Cmp(w2, -4095), "cmn w2, #0xfff (4095)"); 2843 COMPARE_MACRO(Cmp(x3, -4095), "cmn x3, #0xfff (4095)"); 2844 2845 COMPARE_MACRO(Cmn(w0, -1), "cmp w0, #0x1 (1)"); 2846 COMPARE_MACRO(Cmn(x1, -1), "cmp x1, #0x1 (1)"); 2847 COMPARE_MACRO(Cmn(w2, -4095), "cmp w2, #0xfff (4095)"); 2848 COMPARE_MACRO(Cmn(x3, -4095), "cmp x3, #0xfff (4095)"); 2849 2850 CLEANUP(); 2851} 2852 2853TEST(add_sub_macro) { 2854 SETUP(); 2855 2856 // Add and Sub use their destination register as a scratch if they can. 2857 COMPARE_MACRO(Add(x0, x1, 0x4242), 2858 "mov x0, #0x4242\n" 2859 "add x0, x1, x0"); 2860 COMPARE_MACRO(Add(x0, x0, 0x4242), 2861 "mov x16, #0x4242\n" 2862 "add x0, x0, x16"); 2863 COMPARE_MACRO(Adds(x0, xzr, Operand(w1, SXTW)), 2864 "sxtw x0, w1\n" 2865 "adds x0, xzr, x0"); 2866 COMPARE_MACRO(Sub(x0, x1, 0x4242), 2867 "mov x0, #0x4242\n" 2868 "sub x0, x1, x0"); 2869 COMPARE_MACRO(Sub(x0, x0, 0x4242), 2870 "mov x16, #0x4242\n" 2871 "sub x0, x0, x16"); 2872 COMPARE_MACRO(Subs(x0, xzr, Operand(w1, SXTW)), 2873 "sxtw x0, w1\n" 2874 "negs x0, x0"); 2875} 2876 2877TEST(adc_sbc_macro) { 2878 SETUP(); 2879 2880 // Adc and Sbc use their destination register as a scratch if they can. 2881 COMPARE_MACRO(Adc(x0, x1, 0x4242), 2882 "mov x0, #0x4242\n" 2883 "adc x0, x1, x0"); 2884 COMPARE_MACRO(Adc(x0, x0, 0x4242), 2885 "mov x16, #0x4242\n" 2886 "adc x0, x0, x16"); 2887 COMPARE_MACRO(Adcs(x0, xzr, Operand(w1, SXTW)), 2888 "sxtw x0, w1\n" 2889 "adcs x0, xzr, x0"); 2890 COMPARE_MACRO(Sbc(x0, x1, 0x4242), 2891 "mov x0, #0x4242\n" 2892 "sbc x0, x1, x0"); 2893 COMPARE_MACRO(Sbc(x0, x0, 0x4242), 2894 "mov x16, #0x4242\n" 2895 "sbc x0, x0, x16"); 2896 COMPARE_MACRO(Sbcs(x0, xzr, Operand(w1, SXTW)), 2897 "sxtw x0, w1\n" 2898 "ngcs x0, x0"); 2899} 2900 2901TEST(logical_immediate_move) { 2902 SETUP(); 2903 2904 COMPARE_MACRO(And(w0, w1, 0), "mov w0, #0x0"); 2905 COMPARE_MACRO(And(x0, x1, 0), "mov x0, #0x0"); 2906 COMPARE_MACRO(Orr(w2, w3, 0), "mov w2, w3"); 2907 COMPARE_MACRO(Orr(x2, x3, 0), "mov x2, x3"); 2908 COMPARE_MACRO(Eor(w4, w5, 0), "mov w4, w5"); 2909 COMPARE_MACRO(Eor(x4, x5, 0), "mov x4, x5"); 2910 COMPARE_MACRO(Bic(w6, w7, 0), "mov w6, w7"); 2911 COMPARE_MACRO(Bic(x6, x7, 0), "mov x6, x7"); 2912 COMPARE_MACRO(Orn(w8, w9, 0), "mov w8, #0xffffffff"); 2913 COMPARE_MACRO(Orn(x8, x9, 0), "mov x8, #0xffffffffffffffff"); 2914 COMPARE_MACRO(Eon(w10, w11, 0), "mvn w10, w11"); 2915 COMPARE_MACRO(Eon(x10, x11, 0), "mvn x10, x11"); 2916 2917 COMPARE_MACRO(And(w12, w13, 0xffffffff), "mov w12, w13"); 2918 COMPARE_MACRO(And(x12, x13, 0xffffffff), "and x12, x13, #0xffffffff"); 2919 COMPARE_MACRO(And(x12, x13, 0xffffffffffffffff), "mov x12, x13"); 2920 COMPARE_MACRO(Orr(w14, w15, 0xffffffff), "mov w14, #0xffffffff"); 2921 COMPARE_MACRO(Orr(x14, x15, 0xffffffff), "orr x14, x15, #0xffffffff"); 2922 COMPARE_MACRO(Orr(x14, x15, 0xffffffffffffffff), 2923 "mov x14, #0xffffffffffffffff"); 2924 COMPARE_MACRO(Eor(w16, w17, 0xffffffff), "mvn w16, w17"); 2925 COMPARE_MACRO(Eor(x16, x17, 0xffffffff), "eor x16, x17, #0xffffffff"); 2926 COMPARE_MACRO(Eor(x16, x17, 0xffffffffffffffff), "mvn x16, x17"); 2927 COMPARE_MACRO(Bic(w18, w19, 0xffffffff), "mov w18, #0x0"); 2928 COMPARE_MACRO(Bic(x18, x19, 0xffffffff), "and x18, x19, #0xffffffff00000000"); 2929 COMPARE_MACRO(Bic(x18, x19, 0xffffffffffffffff), "mov x18, #0x0"); 2930 COMPARE_MACRO(Orn(w20, w21, 0xffffffff), "mov w20, w21"); 2931 COMPARE_MACRO(Orn(x20, x21, 0xffffffff), "orr x20, x21, #0xffffffff00000000"); 2932 COMPARE_MACRO(Orn(x20, x21, 0xffffffffffffffff), "mov x20, x21"); 2933 COMPARE_MACRO(Eon(w22, w23, 0xffffffff), "mov w22, w23"); 2934 COMPARE_MACRO(Eon(x22, x23, 0xffffffff), "eor x22, x23, #0xffffffff00000000"); 2935 COMPARE_MACRO(Eon(x22, x23, 0xffffffffffffffff), "mov x22, x23"); 2936 2937 // Test stack pointer with non encodable immediate. 2938 COMPARE_MACRO(Orr(wsp, w5, 0x1234), 2939 "mov w16, #0x1234\n" 2940 "orr w16, w5, w16\n" 2941 "mov wsp, w16"); 2942 COMPARE_MACRO(Orr(sp, x15, 0x123), 2943 "mov x16, #0x123\n" 2944 "orr x16, x15, x16\n" 2945 "mov sp, x16"); 2946 2947 CLEANUP(); 2948} 2949 2950TEST(logical_macro) { 2951 SETUP(); 2952 2953 // LogicalMacro uses the destination register as a scratch if it can. 2954 COMPARE_MACRO(And(x0, x1, 0x4242), 2955 "mov x0, #0x4242\n" 2956 "and x0, x1, x0"); 2957 COMPARE_MACRO(Bic(x0, x0, 0x4242), 2958 "mov x16, #0xffffffffffffbdbd\n" 2959 "and x0, x0, x16"); 2960 COMPARE_MACRO(Orn(x0, xzr, Operand(w1, SXTW)), 2961 "sxtw x0, w1\n" 2962 "mvn x0, x0"); 2963 COMPARE_MACRO(Orr(x0, x1, 0x4242), 2964 "mov x0, #0x4242\n" 2965 "orr x0, x1, x0"); 2966 COMPARE_MACRO(Ands(x0, x0, 0x4242), 2967 "mov x16, #0x4242\n" 2968 "ands x0, x0, x16"); 2969 COMPARE_MACRO(Tst(xzr, Operand(w1, SXTW)), 2970 "sxtw x16, w1\n" 2971 "tst xzr, x16"); 2972} 2973 2974TEST(barriers) { 2975 SETUP(); 2976 2977 // DMB 2978 COMPARE_MACRO(Dmb(FullSystem, BarrierAll), "dmb sy"); 2979 COMPARE_MACRO(Dmb(FullSystem, BarrierReads), "dmb ld"); 2980 COMPARE_MACRO(Dmb(FullSystem, BarrierWrites), "dmb st"); 2981 2982 COMPARE_MACRO(Dmb(InnerShareable, BarrierAll), "dmb ish"); 2983 COMPARE_MACRO(Dmb(InnerShareable, BarrierReads), "dmb ishld"); 2984 COMPARE_MACRO(Dmb(InnerShareable, BarrierWrites), "dmb ishst"); 2985 2986 COMPARE_MACRO(Dmb(NonShareable, BarrierAll), "dmb nsh"); 2987 COMPARE_MACRO(Dmb(NonShareable, BarrierReads), "dmb nshld"); 2988 COMPARE_MACRO(Dmb(NonShareable, BarrierWrites), "dmb nshst"); 2989 2990 COMPARE_MACRO(Dmb(OuterShareable, BarrierAll), "dmb osh"); 2991 COMPARE_MACRO(Dmb(OuterShareable, BarrierReads), "dmb oshld"); 2992 COMPARE_MACRO(Dmb(OuterShareable, BarrierWrites), "dmb oshst"); 2993 2994 COMPARE_MACRO(Dmb(FullSystem, BarrierOther), "dmb sy (0b1100)"); 2995 COMPARE_MACRO(Dmb(InnerShareable, BarrierOther), "dmb sy (0b1000)"); 2996 COMPARE_MACRO(Dmb(NonShareable, BarrierOther), "dmb sy (0b0100)"); 2997 COMPARE_MACRO(Dmb(OuterShareable, BarrierOther), "dmb sy (0b0000)"); 2998 2999 // DSB 3000 COMPARE_MACRO(Dsb(FullSystem, BarrierAll), "dsb sy"); 3001 COMPARE_MACRO(Dsb(FullSystem, BarrierReads), "dsb ld"); 3002 COMPARE_MACRO(Dsb(FullSystem, BarrierWrites), "dsb st"); 3003 3004 COMPARE_MACRO(Dsb(InnerShareable, BarrierAll), "dsb ish"); 3005 COMPARE_MACRO(Dsb(InnerShareable, BarrierReads), "dsb ishld"); 3006 COMPARE_MACRO(Dsb(InnerShareable, BarrierWrites), "dsb ishst"); 3007 3008 COMPARE_MACRO(Dsb(NonShareable, BarrierAll), "dsb nsh"); 3009 COMPARE_MACRO(Dsb(NonShareable, BarrierReads), "dsb nshld"); 3010 COMPARE_MACRO(Dsb(NonShareable, BarrierWrites), "dsb nshst"); 3011 3012 COMPARE_MACRO(Dsb(OuterShareable, BarrierAll), "dsb osh"); 3013 COMPARE_MACRO(Dsb(OuterShareable, BarrierReads), "dsb oshld"); 3014 COMPARE_MACRO(Dsb(OuterShareable, BarrierWrites), "dsb oshst"); 3015 3016 COMPARE_MACRO(Dsb(FullSystem, BarrierOther), "dsb sy (0b1100)"); 3017 COMPARE_MACRO(Dsb(InnerShareable, BarrierOther), "dsb sy (0b1000)"); 3018 COMPARE_MACRO(Dsb(NonShareable, BarrierOther), "pssbb"); 3019 COMPARE_MACRO(Dsb(OuterShareable, BarrierOther), "ssbb"); 3020 3021 // ISB 3022 COMPARE_MACRO(Isb(), "isb"); 3023 3024 // ESB 3025 COMPARE_MACRO(Esb(), "esb"); 3026 3027 // CSDB 3028 COMPARE_MACRO(Csdb(), "csdb"); 3029 3030 CLEANUP(); 3031} 3032 3033TEST(address_map) { 3034 // Check that we can disassemble from a fake base address. 3035 SETUP(); 3036 3037 disasm.MapCodeAddress(0, masm.GetBuffer()->GetStartAddress<Instruction*>()); 3038 COMPARE(ldr(x0, INT64_C(0)), "ldr x0, pc+0 (addr 0x0)"); 3039 COMPARE(ldr(x0, -1), "ldr x0, pc-4 (addr -0x4)"); 3040 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x4)"); 3041 COMPARE(prfm(PLIL1KEEP, INT64_C(0)), "prfm plil1keep, pc+0 (addr 0x0)"); 3042 COMPARE(prfm(PLIL1KEEP, -1), "prfm plil1keep, pc-4 (addr -0x4)"); 3043 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x4)"); 3044 COMPARE(adr(x0, INT64_C(0)), "adr x0, #+0x0 (addr 0x0)"); 3045 COMPARE(adr(x0, -1), "adr x0, #-0x1 (addr -0x1)"); 3046 COMPARE(adr(x0, 1), "adr x0, #+0x1 (addr 0x1)"); 3047 COMPARE(adrp(x0, INT64_C(0)), "adrp x0, #+0x0 (addr 0x0)"); 3048 COMPARE(adrp(x0, -1), "adrp x0, #-0x1000 (addr -0x1000)"); 3049 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x1000)"); 3050 COMPARE(b(INT64_C(0)), "b #+0x0 (addr 0x0)"); 3051 COMPARE(b(-1), "b #-0x4 (addr -0x4)"); 3052 COMPARE(b(1), "b #+0x4 (addr 0x4)"); 3053 3054 disasm.MapCodeAddress(0x1234, 3055 masm.GetBuffer()->GetStartAddress<Instruction*>()); 3056 COMPARE(ldr(x0, INT64_C(0)), "ldr x0, pc+0 (addr 0x1234)"); 3057 COMPARE(ldr(x0, -1), "ldr x0, pc-4 (addr 0x1230)"); 3058 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x1238)"); 3059 COMPARE(prfm(PLIL1KEEP, INT64_C(0)), "prfm plil1keep, pc+0 (addr 0x1234)"); 3060 COMPARE(prfm(PLIL1KEEP, -1), "prfm plil1keep, pc-4 (addr 0x1230)"); 3061 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x1238)"); 3062 COMPARE(adr(x0, INT64_C(0)), "adr x0, #+0x0 (addr 0x1234)"); 3063 COMPARE(adr(x0, -1), "adr x0, #-0x1 (addr 0x1233)"); 3064 COMPARE(adr(x0, 1), "adr x0, #+0x1 (addr 0x1235)"); 3065 COMPARE(adrp(x0, INT64_C(0)), "adrp x0, #+0x0 (addr 0x1000)"); 3066 COMPARE(adrp(x0, -1), "adrp x0, #-0x1000 (addr 0x0)"); 3067 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x2000)"); 3068 COMPARE(b(INT64_C(0)), "b #+0x0 (addr 0x1234)"); 3069 COMPARE(b(-1), "b #-0x4 (addr 0x1230)"); 3070 COMPARE(b(1), "b #+0x4 (addr 0x1238)"); 3071 3072 // Check that 64-bit addresses work. 3073 disasm.MapCodeAddress(UINT64_C(0x100000000), 3074 masm.GetBuffer()->GetStartAddress<Instruction*>()); 3075 COMPARE(ldr(x0, INT64_C(0)), "ldr x0, pc+0 (addr 0x100000000)"); 3076 COMPARE(ldr(x0, -1), "ldr x0, pc-4 (addr 0xfffffffc)"); 3077 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x100000004)"); 3078 COMPARE(prfm(PLIL1KEEP, INT64_C(0)), 3079 "prfm plil1keep, pc+0 (addr 0x100000000)"); 3080 COMPARE(prfm(PLIL1KEEP, -1), "prfm plil1keep, pc-4 (addr 0xfffffffc)"); 3081 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x100000004)"); 3082 COMPARE(adr(x0, INT64_C(0)), "adr x0, #+0x0 (addr 0x100000000)"); 3083 COMPARE(adr(x0, -1), "adr x0, #-0x1 (addr 0xffffffff)"); 3084 COMPARE(adr(x0, 1), "adr x0, #+0x1 (addr 0x100000001)"); 3085 COMPARE(adrp(x0, INT64_C(0)), "adrp x0, #+0x0 (addr 0x100000000)"); 3086 COMPARE(adrp(x0, -1), "adrp x0, #-0x1000 (addr 0xfffff000)"); 3087 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x100001000)"); 3088 COMPARE(b(INT64_C(0)), "b #+0x0 (addr 0x100000000)"); 3089 COMPARE(b(-1), "b #-0x4 (addr 0xfffffffc)"); 3090 COMPARE(b(1), "b #+0x4 (addr 0x100000004)"); 3091 3092 disasm.MapCodeAddress(0xfffffffc, 3093 masm.GetBuffer()->GetStartAddress<Instruction*>()); 3094 COMPARE(ldr(x0, 1), "ldr x0, pc+4 (addr 0x100000000)"); 3095 COMPARE(prfm(PLIL1KEEP, 1), "prfm plil1keep, pc+4 (addr 0x100000000)"); 3096 COMPARE(b(1), "b #+0x4 (addr 0x100000000)"); 3097 COMPARE(adr(x0, 4), "adr x0, #+0x4 (addr 0x100000000)"); 3098 COMPARE(adrp(x0, 1), "adrp x0, #+0x1000 (addr 0x100000000)"); 3099 3100 // Check that very large offsets are handled properly. This detects misuse of 3101 // the host's ptrdiff_t type when run on a 32-bit host. Only adrp is capable 3102 // of encoding such offsets. 3103 disasm.MapCodeAddress(0, masm.GetBuffer()->GetStartAddress<Instruction*>()); 3104 COMPARE(adrp(x0, 0x000fffff), "adrp x0, #+0xfffff000 (addr 0xfffff000)"); 3105 COMPARE(adrp(x0, -0x00100000), "adrp x0, #-0x100000000 (addr -0x100000000)"); 3106 3107 CLEANUP(); 3108} 3109 3110TEST(hint) { 3111 SETUP(); 3112 3113 // Test that we properly disassemble named and unnamed hints. 3114 COMPARE(hint(NOP), "nop"); 3115 COMPARE(hint(YIELD), "yield"); 3116 COMPARE(hint(WFE), "wfe"); 3117 COMPARE(hint(WFI), "wfi"); 3118 COMPARE(hint(SEV), "sev"); 3119 COMPARE(hint(SEVL), "sevl"); 3120 COMPARE(hint(6), "dgh"); 3121 COMPARE(hint(ESB), "esb"); 3122 COMPARE(hint(CSDB), "csdb"); 3123 COMPARE(hint(42), "hint #42"); 3124 COMPARE(hint(127), "hint #127"); 3125 3126 // The MacroAssembler should simply pass through to the Assembler. 3127 COMPARE_MACRO(Hint(NOP), "nop"); 3128 COMPARE_MACRO(Hint(CSDB), "csdb"); 3129 COMPARE_MACRO(Hint(42), "hint #42"); 3130 COMPARE_MACRO(Hint(127), "hint #127"); 3131 3132 CLEANUP(); 3133} 3134 3135TEST(bti) { 3136 SETUP(); 3137 3138 COMPARE(bti(EmitBTI), "bti"); 3139 COMPARE(bti(EmitBTI_c), "bti c"); 3140 COMPARE(bti(EmitBTI_j), "bti j"); 3141 COMPARE(bti(EmitBTI_jc), "bti jc"); 3142 COMPARE(hint(BTI), "bti"); 3143 COMPARE(hint(BTI_c), "bti c"); 3144 COMPARE(hint(BTI_j), "bti j"); 3145 COMPARE(hint(BTI_jc), "bti jc"); 3146 3147 Label placeholder1, placeholder2, placeholder3, placeholder4; 3148 COMPARE_MACRO(Bind(&placeholder1, EmitBTI), "bti"); 3149 COMPARE_MACRO(Bind(&placeholder2, EmitBTI_c), "bti c"); 3150 COMPARE_MACRO(Bind(&placeholder3, EmitBTI_j), "bti j"); 3151 COMPARE_MACRO(Bind(&placeholder4, EmitBTI_jc), "bti jc"); 3152 3153 CLEANUP(); 3154} 3155 3156TEST(udf) { 3157 SETUP(); 3158 3159 COMPARE(udf(0), "udf #0x0"); 3160 COMPARE(udf(0x1234), "udf #0x1234"); 3161 COMPARE(udf(0xffff), "udf #0xffff"); 3162 3163 // UDF gives the useful property that zero-initialised memory is guaranteed to 3164 // generate undefined instruction exceptions. 3165 COMPARE(dc(0), "udf #0x0"); 3166 3167 // Check related unallocated bit patterns from the reserved block. 3168 COMPARE(dc(0x00010000), "unallocated (Unallocated)"); 3169 COMPARE(dc(0x01000000), "unallocated (Unallocated)"); 3170 COMPARE(dc(0x20000000), "unallocated (Unallocated)"); 3171 COMPARE(dc(0x80000000), "unallocated (Unallocated)"); 3172 3173 CLEANUP(); 3174} 3175 3176TEST(mte) { 3177 SETUP(); 3178 3179#if 0 3180 COMPARE(ldg(x2, x2, int imm9), "ldg <Xt>, [<Xn|SP>{, #<simm>}]"); 3181 COMPARE(st2g(x3, int imm9), "st2g <Xt|SP>, [<Xn|SP>{, #<simm>}]"); 3182 COMPARE(st2g(x31, int imm9), "st2g <Xt|SP>, [<Xn|SP>], #<simm>"); 3183 COMPARE(st2g(x30, int imm9), "st2g <Xt|SP>, [<Xn|SP>, #<simm>]!"); 3184 COMPARE(stgp(x301, x302, x30, int imm7), "stgp <Xt1>, <Xt2>, [<Xn|SP>{, #<imm>}]"); 3185 COMPARE(stgp(x201, x202, x20, int imm7), "stgp <Xt1>, <Xt2>, [<Xn|SP>], #<imm>"); 3186 COMPARE(stgp(x161, x162, x16, int imm7), "stgp <Xt1>, <Xt2>, [<Xn|SP>, #<imm>]!"); 3187 COMPARE(stg(x9, int imm9), "stg <Xt|SP>, [<Xn|SP>{, #<simm>}]"); 3188 COMPARE(stg(x20, int imm9), "stg <Xt|SP>, [<Xn|SP>], #<simm>"); 3189 COMPARE(stg(x29, int imm9), "stg <Xt|SP>, [<Xn|SP>, #<simm>]!"); 3190 COMPARE(stz2g(x9, int imm9), "stz2g <Xt|SP>, [<Xn|SP>{, #<simm>}]"); 3191 COMPARE(stz2g(x28, int imm9), "stz2g <Xt|SP>, [<Xn|SP>], #<simm>"); 3192 COMPARE(stz2g(x7, int imm9), "stz2g <Xt|SP>, [<Xn|SP>, #<simm>]!"); 3193 COMPARE(stzg(x20, int imm9), "stzg <Xt|SP>, [<Xn|SP>{, #<simm>}]"); 3194 COMPARE(stzg(x6, int imm9), "stzg <Xt|SP>, [<Xn|SP>], #<simm>"); 3195 COMPARE(stzg(x28, int imm9), "stzg <Xt|SP>, [<Xn|SP>, #<simm>]!"); 3196#endif 3197 3198 CLEANUP(); 3199} 3200 3201TEST(mte_dp) { 3202 SETUP(); 3203 3204 COMPARE(addg(x26, x27, 0, 0), "addg x26, x27, #0, #0"); 3205 COMPARE(addg(x26, x27, 512, 2), "addg x26, x27, #512, #2"); 3206 COMPARE(addg(x26, x27, 1008, 15), "addg x26, x27, #1008, #15"); 3207 COMPARE(addg(sp, x27, 1008, 15), "addg sp, x27, #1008, #15"); 3208 COMPARE(addg(x26, sp, 1008, 15), "addg x26, sp, #1008, #15"); 3209 COMPARE(addg(sp, sp, 1008, 15), "addg sp, sp, #1008, #15"); 3210 COMPARE(subg(x6, x7, 0, 0), "subg x6, x7, #0, #0"); 3211 COMPARE(subg(x6, x7, 640, 9), "subg x6, x7, #640, #9"); 3212 COMPARE(subg(x6, x7, 1008, 15), "subg x6, x7, #1008, #15"); 3213 COMPARE(subg(sp, x7, 1008, 15), "subg sp, x7, #1008, #15"); 3214 COMPARE(subg(x6, sp, 1008, 15), "subg x6, sp, #1008, #15"); 3215 COMPARE(subg(sp, sp, 1008, 15), "subg sp, sp, #1008, #15"); 3216 COMPARE(gmi(x3, x5, x4), "gmi x3, x5, x4"); 3217 COMPARE(gmi(x3, sp, x4), "gmi x3, sp, x4"); 3218 COMPARE(gmi(xzr, sp, xzr), "gmi xzr, sp, xzr"); 3219 COMPARE(irg(x24, x23, x22), "irg x24, x23, x22"); 3220 COMPARE(irg(sp, x23, x22), "irg sp, x23, x22"); 3221 COMPARE(irg(x24, sp, x22), "irg x24, sp, x22"); 3222 COMPARE(irg(sp, sp, x22), "irg sp, sp, x22"); 3223 COMPARE(irg(x24, x23, xzr), "irg x24, x23"); 3224 COMPARE(irg(x24, x23), "irg x24, x23"); 3225 COMPARE(subp(x28, x29, x30), "subp x28, x29, x30"); 3226 COMPARE(subp(x28, sp, x30), "subp x28, sp, x30"); 3227 COMPARE(subp(x28, x29, sp), "subp x28, x29, sp"); 3228 COMPARE(subp(x28, sp, sp), "subp x28, sp, sp"); 3229 COMPARE(subp(xzr, sp, sp), "subp xzr, sp, sp"); 3230 COMPARE(subps(x2, x10, x0), "subps x2, x10, x0"); 3231 COMPARE(subps(x2, sp, x0), "subps x2, sp, x0"); 3232 COMPARE(subps(x2, x10, sp), "subps x2, x10, sp"); 3233 COMPARE(subps(x2, sp, sp), "subps x2, sp, sp"); 3234 COMPARE(subps(xzr, sp, sp), "cmpp sp, sp"); 3235 COMPARE(subps(xzr, x2, sp), "cmpp x2, sp"); 3236 COMPARE(cmpp(x6, x30), "cmpp x6, x30"); 3237 3238 CLEANUP(); 3239} 3240 3241TEST(mops) { 3242 SETUP(); 3243 3244 COMPARE_MACRO(Cpyen(x4, x5, x6), "cpyen [x4]!, [x5]!, x6!"); 3245 COMPARE_MACRO(Cpyern(x7, x6, x1), "cpyern [x7]!, [x6]!, x1!"); 3246 COMPARE_MACRO(Cpyewn(x26, x27, x28), "cpyewn [x26]!, [x27]!, x28!"); 3247 COMPARE_MACRO(Cpye(x14, x15, x19), "cpye [x14]!, [x15]!, x19!"); 3248 COMPARE_MACRO(Cpyfen(x13, x1, x9), "cpyfen [x13]!, [x1]!, x9!"); 3249 COMPARE_MACRO(Cpyfern(x24, x2, x10), "cpyfern [x24]!, [x2]!, x10!"); 3250 COMPARE_MACRO(Cpyfewn(x12, x2, x11), "cpyfewn [x12]!, [x2]!, x11!"); 3251 COMPARE_MACRO(Cpyfe(x3, x9, x12), "cpyfe [x3]!, [x9]!, x12!"); 3252 COMPARE_MACRO(Cpyfmn(x7, x27, x13), "cpyfmn [x7]!, [x27]!, x13!"); 3253 COMPARE_MACRO(Cpyfmrn(x19, x9, x14), "cpyfmrn [x19]!, [x9]!, x14!"); 3254 COMPARE_MACRO(Cpyfmwn(x1, x11, x15), "cpyfmwn [x1]!, [x11]!, x15!"); 3255 COMPARE_MACRO(Cpyfm(x1, x13, x16), "cpyfm [x1]!, [x13]!, x16!"); 3256 COMPARE_MACRO(Cpyfpn(x3, x13, x17), "cpyfpn [x3]!, [x13]!, x17!"); 3257 COMPARE_MACRO(Cpyfprn(x18, x8, x17), "cpyfprn [x18]!, [x8]!, x17!"); 3258 COMPARE_MACRO(Cpyfpwn(x9, x29, x18), "cpyfpwn [x9]!, [x29]!, x18!"); 3259 COMPARE_MACRO(Cpyfp(x4, x3, x19), "cpyfp [x4]!, [x3]!, x19!"); 3260 COMPARE_MACRO(Cpymn(x5, x15, x20), "cpymn [x5]!, [x15]!, x20!"); 3261 COMPARE_MACRO(Cpymrn(x12, x22, x21), "cpymrn [x12]!, [x22]!, x21!"); 3262 COMPARE_MACRO(Cpymwn(x12, x1, x22), "cpymwn [x12]!, [x1]!, x22!"); 3263 COMPARE_MACRO(Cpym(x1, x10, x23), "cpym [x1]!, [x10]!, x23!"); 3264 COMPARE_MACRO(Cpypn(x3, x26, x25), "cpypn [x3]!, [x26]!, x25!"); 3265 COMPARE_MACRO(Cpyprn(x4, x14, x24), "cpyprn [x4]!, [x14]!, x24!"); 3266 COMPARE_MACRO(Cpypwn(x9, x29, x26), "cpypwn [x9]!, [x29]!, x26!"); 3267 COMPARE_MACRO(Cpyp(x0, x30, x28), "cpyp [x0]!, [x30]!, x28!"); 3268 3269 COMPARE_MACRO(Seten(x6, x26, x27), "seten [x6]!, x26!, x27"); 3270 COMPARE_MACRO(Sete(x3, x23, x1), "sete [x3]!, x23!, x1"); 3271 COMPARE_MACRO(Setgen(x6, x16, x2), "setgen [x6]!, x16!, x2"); 3272 COMPARE_MACRO(Setge(x4, x24, x3), "setge [x4]!, x24!, x3"); 3273 COMPARE_MACRO(Setgmn(x9, x29, x4), "setgmn [x9]!, x29!, x4"); 3274 COMPARE_MACRO(Setgm(x30, x3, x5), "setgm [x30]!, x3!, x5"); 3275 COMPARE_MACRO(Setgpn(x11, x1, x6), "setgpn [x11]!, x1!, x6"); 3276 COMPARE_MACRO(Setgp(x1, x16, x7), "setgp [x1]!, x16!, x7"); 3277 COMPARE_MACRO(Setmn(x4, x14, x8), "setmn [x4]!, x14!, x8"); 3278 COMPARE_MACRO(Setm(x8, x7, x9), "setm [x8]!, x7!, x9"); 3279 COMPARE_MACRO(Setpn(x2, x22, x10), "setpn [x2]!, x22!, x10"); 3280 COMPARE_MACRO(Setp(x7, x17, x11), "setp [x7]!, x17!, x11"); 3281 3282 // Check unallocated bit patterns. 3283 COMPARE_PREFIX(dci(0x1d000422), "cpyp [x2]!, [x0]!, x1!"); 3284 COMPARE_PREFIX(dci(0xdd000422), "unallocated"); // sz != 0 3285 COMPARE_PREFIX(dci(0x1d000442), "unallocated"); // Xd == Xn 3286 COMPARE_PREFIX(dci(0x1d020422), "unallocated"); // Xd == Xs 3287 COMPARE_PREFIX(dci(0x1d000402), "unallocated"); // Xn == Xs 3288 COMPARE_PREFIX(dci(0x1d00043f), "unallocated"); // Xd == 31 3289 COMPARE_PREFIX(dci(0x1d0007e2), "unallocated"); // Xn == 31 3290 COMPARE_PREFIX(dci(0x1d1f0422), "unallocated"); // Xs == 31 3291 3292 COMPARE_PREFIX(dci(0x19c02424), "setpn [x4]!, x1!, x0"); 3293 COMPARE_PREFIX(dci(0xd9c02424), "unallocated"); // sz != 0 3294 COMPARE_PREFIX(dci(0x19c0e424), "unallocated"); // op2 == 0xe 3295 COMPARE_PREFIX(dci(0x19c02400), "unallocated"); // Xd == Xn 3296 COMPARE_PREFIX(dci(0x19c02420), "unallocated"); // Xd == Xs 3297 COMPARE_PREFIX(dci(0x19c02404), "unallocated"); // Xn == Xs 3298 COMPARE_PREFIX(dci(0x19c0243f), "unallocated"); // Xd == 31 3299 COMPARE_PREFIX(dci(0x19c027e4), "unallocated"); // Xn == 31 3300 3301 CLEANUP(); 3302} 3303 3304TEST(cssc) { 3305 SETUP(); 3306 3307 COMPARE_MACRO(Abs(w0, w22), "abs w0, w22"); 3308 COMPARE_MACRO(Abs(x0, x23), "abs x0, x23"); 3309 COMPARE_MACRO(Abs(wzr, wzr), "abs wzr, wzr"); 3310 COMPARE_MACRO(Cnt(w21, w30), "cnt w21, w30"); 3311 COMPARE_MACRO(Cnt(x19, x9), "cnt x19, x9"); 3312 COMPARE_MACRO(Cnt(xzr, x30), "cnt xzr, x30"); 3313 COMPARE_MACRO(Ctz(w3, w5), "ctz w3, w5"); 3314 COMPARE_MACRO(Ctz(x3, x28), "ctz x3, x28"); 3315 COMPARE_MACRO(Ctz(w0, wzr), "ctz w0, wzr"); 3316 3317 COMPARE_MACRO(Smax(w5, w9, w10), "smax w5, w9, w10"); 3318 COMPARE_MACRO(Smax(x6, x8, x9), "smax x6, x8, x9"); 3319 COMPARE_MACRO(Smin(w11, w8, w17), "smin w11, w8, w17"); 3320 COMPARE_MACRO(Smin(x12, x10, x20), "smin x12, x10, x20"); 3321 COMPARE_MACRO(Umax(w5, w9, w10), "umax w5, w9, w10"); 3322 COMPARE_MACRO(Umax(x6, x8, x9), "umax x6, x8, x9"); 3323 COMPARE_MACRO(Umin(w11, w8, w17), "umin w11, w8, w17"); 3324 COMPARE_MACRO(Umin(x12, x10, x20), "umin x12, x10, x20"); 3325 3326 COMPARE_MACRO(Smax(w5, w9, 127), "smax w5, w9, #127"); 3327 COMPARE_MACRO(Smax(x6, x8, -128), "smax x6, x8, #-128"); 3328 COMPARE_MACRO(Smin(w19, w20, -1), "smin w19, w20, #-1"); 3329 COMPARE_MACRO(Smin(x30, xzr, 0), "smin x30, xzr, #0"); 3330 COMPARE_MACRO(Umax(w5, w9, 255), "umax w5, w9, #255"); 3331 COMPARE_MACRO(Umax(x6, x8, 128), "umax x6, x8, #128"); 3332 COMPARE_MACRO(Umin(wzr, w20, 1), "umin wzr, w20, #1"); 3333 COMPARE_MACRO(Umin(x30, xzr, 0), "umin x30, xzr, #0"); 3334 3335 COMPARE_MACRO(Smax(w5, w6, 128), 3336 "mov w16, #0x80\n" 3337 "smax w5, w6, w16"); 3338 COMPARE_MACRO(Smax(x10, x11, -129), 3339 "mov x16, #0xffffffffffffff7f\n" 3340 "smax x10, x11, x16"); 3341 COMPARE_MACRO(Smin(w5, w6, 128), 3342 "mov w16, #0x80\n" 3343 "smin w5, w6, w16"); 3344 COMPARE_MACRO(Smin(x10, x11, -129), 3345 "mov x16, #0xffffffffffffff7f\n" 3346 "smin x10, x11, x16"); 3347 COMPARE_MACRO(Umax(w5, w6, 256), 3348 "mov w16, #0x100\n" 3349 "umax w5, w6, w16"); 3350 COMPARE_MACRO(Umax(x10, x11, 0x4242), 3351 "mov x16, #0x4242\n" 3352 "umax x10, x11, x16"); 3353 COMPARE_MACRO(Umin(w5, w6, 256), 3354 "mov w16, #0x100\n" 3355 "umin w5, w6, w16"); 3356 COMPARE_MACRO(Umin(x10, x11, 0x4242), 3357 "mov x16, #0x4242\n" 3358 "umin x10, x11, x16"); 3359 CLEANUP(); 3360} 3361 3362TEST(architecture_features) { 3363 SETUP(); 3364 3365 // ARMv8.1 - LOR 3366 COMPARE_PREFIX(dci(0x089f7c00), "stllrb"); // STLLRB_SL32_ldstexcl 3367 COMPARE_PREFIX(dci(0x08df7c00), "ldlarb"); // LDLARB_LR32_ldstexcl 3368 COMPARE_PREFIX(dci(0x489f7c00), "stllrh"); // STLLRH_SL32_ldstexcl 3369 COMPARE_PREFIX(dci(0x48df7c00), "ldlarh"); // LDLARH_LR32_ldstexcl 3370 COMPARE_PREFIX(dci(0x889f7c00), "stllr"); // STLLR_SL32_ldstexcl 3371 COMPARE_PREFIX(dci(0x88df7c00), "ldlar"); // LDLAR_LR32_ldstexcl 3372 COMPARE_PREFIX(dci(0xc89f7c00), "stllr"); // STLLR_SL64_ldstexcl 3373 COMPARE_PREFIX(dci(0xc8df7c00), "ldlar"); // LDLAR_LR64_ldstexcl 3374 3375 // ARMv8.1 - LSE 3376 COMPARE_PREFIX(dci(0x08207c00), "casp"); // CASP_CP32_ldstexcl 3377 COMPARE_PREFIX(dci(0x0820fc00), "caspl"); // CASPL_CP32_ldstexcl 3378 COMPARE_PREFIX(dci(0x08607c00), "caspa"); // CASPA_CP32_ldstexcl 3379 COMPARE_PREFIX(dci(0x0860fc00), "caspal"); // CASPAL_CP32_ldstexcl 3380 COMPARE_PREFIX(dci(0x08a07c00), "casb"); // CASB_C32_ldstexcl 3381 COMPARE_PREFIX(dci(0x08a0fc00), "caslb"); // CASLB_C32_ldstexcl 3382 COMPARE_PREFIX(dci(0x08e07c00), "casab"); // CASAB_C32_ldstexcl 3383 COMPARE_PREFIX(dci(0x08e0fc00), "casalb"); // CASALB_C32_ldstexcl 3384 COMPARE_PREFIX(dci(0x38200000), "ldaddb"); // LDADDB_32_memop 3385 COMPARE_PREFIX(dci(0x38201000), "ldclrb"); // LDCLRB_32_memop 3386 COMPARE_PREFIX(dci(0x38202000), "ldeorb"); // LDEORB_32_memop 3387 COMPARE_PREFIX(dci(0x38203000), "ldsetb"); // LDSETB_32_memop 3388 COMPARE_PREFIX(dci(0x38204000), "ldsmaxb"); // LDSMAXB_32_memop 3389 COMPARE_PREFIX(dci(0x38205000), "ldsminb"); // LDSMINB_32_memop 3390 COMPARE_PREFIX(dci(0x38206000), "ldumaxb"); // LDUMAXB_32_memop 3391 COMPARE_PREFIX(dci(0x38207000), "lduminb"); // LDUMINB_32_memop 3392 COMPARE_PREFIX(dci(0x38208000), "swpb"); // SWPB_32_memop 3393 COMPARE_PREFIX(dci(0x38600000), "ldaddlb"); // LDADDLB_32_memop 3394 COMPARE_PREFIX(dci(0x38601000), "ldclrlb"); // LDCLRLB_32_memop 3395 COMPARE_PREFIX(dci(0x38602000), "ldeorlb"); // LDEORLB_32_memop 3396 COMPARE_PREFIX(dci(0x38603000), "ldsetlb"); // LDSETLB_32_memop 3397 COMPARE_PREFIX(dci(0x38604000), "ldsmaxlb"); // LDSMAXLB_32_memop 3398 COMPARE_PREFIX(dci(0x38605000), "ldsminlb"); // LDSMINLB_32_memop 3399 COMPARE_PREFIX(dci(0x38606000), "ldumaxlb"); // LDUMAXLB_32_memop 3400 COMPARE_PREFIX(dci(0x38607000), "lduminlb"); // LDUMINLB_32_memop 3401 COMPARE_PREFIX(dci(0x38608000), "swplb"); // SWPLB_32_memop 3402 COMPARE_PREFIX(dci(0x38a00000), "ldaddab"); // LDADDAB_32_memop 3403 COMPARE_PREFIX(dci(0x38a01000), "ldclrab"); // LDCLRAB_32_memop 3404 COMPARE_PREFIX(dci(0x38a02000), "ldeorab"); // LDEORAB_32_memop 3405 COMPARE_PREFIX(dci(0x38a03000), "ldsetab"); // LDSETAB_32_memop 3406 COMPARE_PREFIX(dci(0x38a04000), "ldsmaxab"); // LDSMAXAB_32_memop 3407 COMPARE_PREFIX(dci(0x38a05000), "ldsminab"); // LDSMINAB_32_memop 3408 COMPARE_PREFIX(dci(0x38a06000), "ldumaxab"); // LDUMAXAB_32_memop 3409 COMPARE_PREFIX(dci(0x38a07000), "lduminab"); // LDUMINAB_32_memop 3410 COMPARE_PREFIX(dci(0x38a08000), "swpab"); // SWPAB_32_memop 3411 COMPARE_PREFIX(dci(0x38e00000), "ldaddalb"); // LDADDALB_32_memop 3412 COMPARE_PREFIX(dci(0x38e01000), "ldclralb"); // LDCLRALB_32_memop 3413 COMPARE_PREFIX(dci(0x38e02000), "ldeoralb"); // LDEORALB_32_memop 3414 COMPARE_PREFIX(dci(0x38e03000), "ldsetalb"); // LDSETALB_32_memop 3415 COMPARE_PREFIX(dci(0x38e04000), "ldsmaxalb"); // LDSMAXALB_32_memop 3416 COMPARE_PREFIX(dci(0x38e05000), "ldsminalb"); // LDSMINALB_32_memop 3417 COMPARE_PREFIX(dci(0x38e06000), "ldumaxalb"); // LDUMAXALB_32_memop 3418 COMPARE_PREFIX(dci(0x38e07000), "lduminalb"); // LDUMINALB_32_memop 3419 COMPARE_PREFIX(dci(0x38e08000), "swpalb"); // SWPALB_32_memop 3420 COMPARE_PREFIX(dci(0x48207c00), "casp"); // CASP_CP64_ldstexcl 3421 COMPARE_PREFIX(dci(0x4820fc00), "caspl"); // CASPL_CP64_ldstexcl 3422 COMPARE_PREFIX(dci(0x48607c00), "caspa"); // CASPA_CP64_ldstexcl 3423 COMPARE_PREFIX(dci(0x4860fc00), "caspal"); // CASPAL_CP64_ldstexcl 3424 COMPARE_PREFIX(dci(0x48a07c00), "cash"); // CASH_C32_ldstexcl 3425 COMPARE_PREFIX(dci(0x48a0fc00), "caslh"); // CASLH_C32_ldstexcl 3426 COMPARE_PREFIX(dci(0x48e07c00), "casah"); // CASAH_C32_ldstexcl 3427 COMPARE_PREFIX(dci(0x48e0fc00), "casalh"); // CASALH_C32_ldstexcl 3428 COMPARE_PREFIX(dci(0x78200000), "ldaddh"); // LDADDH_32_memop 3429 COMPARE_PREFIX(dci(0x78201000), "ldclrh"); // LDCLRH_32_memop 3430 COMPARE_PREFIX(dci(0x78202000), "ldeorh"); // LDEORH_32_memop 3431 COMPARE_PREFIX(dci(0x78203000), "ldseth"); // LDSETH_32_memop 3432 COMPARE_PREFIX(dci(0x78204000), "ldsmaxh"); // LDSMAXH_32_memop 3433 COMPARE_PREFIX(dci(0x78205000), "ldsminh"); // LDSMINH_32_memop 3434 COMPARE_PREFIX(dci(0x78206000), "ldumaxh"); // LDUMAXH_32_memop 3435 COMPARE_PREFIX(dci(0x78207000), "lduminh"); // LDUMINH_32_memop 3436 COMPARE_PREFIX(dci(0x78208000), "swph"); // SWPH_32_memop 3437 COMPARE_PREFIX(dci(0x78600000), "ldaddlh"); // LDADDLH_32_memop 3438 COMPARE_PREFIX(dci(0x78601000), "ldclrlh"); // LDCLRLH_32_memop 3439 COMPARE_PREFIX(dci(0x78602000), "ldeorlh"); // LDEORLH_32_memop 3440 COMPARE_PREFIX(dci(0x78603000), "ldsetlh"); // LDSETLH_32_memop 3441 COMPARE_PREFIX(dci(0x78604000), "ldsmaxlh"); // LDSMAXLH_32_memop 3442 COMPARE_PREFIX(dci(0x78605000), "ldsminlh"); // LDSMINLH_32_memop 3443 COMPARE_PREFIX(dci(0x78606000), "ldumaxlh"); // LDUMAXLH_32_memop 3444 COMPARE_PREFIX(dci(0x78607000), "lduminlh"); // LDUMINLH_32_memop 3445 COMPARE_PREFIX(dci(0x78608000), "swplh"); // SWPLH_32_memop 3446 COMPARE_PREFIX(dci(0x78a00000), "ldaddah"); // LDADDAH_32_memop 3447 COMPARE_PREFIX(dci(0x78a01000), "ldclrah"); // LDCLRAH_32_memop 3448 COMPARE_PREFIX(dci(0x78a02000), "ldeorah"); // LDEORAH_32_memop 3449 COMPARE_PREFIX(dci(0x78a03000), "ldsetah"); // LDSETAH_32_memop 3450 COMPARE_PREFIX(dci(0x78a04000), "ldsmaxah"); // LDSMAXAH_32_memop 3451 COMPARE_PREFIX(dci(0x78a05000), "ldsminah"); // LDSMINAH_32_memop 3452 COMPARE_PREFIX(dci(0x78a06000), "ldumaxah"); // LDUMAXAH_32_memop 3453 COMPARE_PREFIX(dci(0x78a07000), "lduminah"); // LDUMINAH_32_memop 3454 COMPARE_PREFIX(dci(0x78a08000), "swpah"); // SWPAH_32_memop 3455 COMPARE_PREFIX(dci(0x78e00000), "ldaddalh"); // LDADDALH_32_memop 3456 COMPARE_PREFIX(dci(0x78e01000), "ldclralh"); // LDCLRALH_32_memop 3457 COMPARE_PREFIX(dci(0x78e02000), "ldeoralh"); // LDEORALH_32_memop 3458 COMPARE_PREFIX(dci(0x78e03000), "ldsetalh"); // LDSETALH_32_memop 3459 COMPARE_PREFIX(dci(0x78e04000), "ldsmaxalh"); // LDSMAXALH_32_memop 3460 COMPARE_PREFIX(dci(0x78e05000), "ldsminalh"); // LDSMINALH_32_memop 3461 COMPARE_PREFIX(dci(0x78e06000), "ldumaxalh"); // LDUMAXALH_32_memop 3462 COMPARE_PREFIX(dci(0x78e07000), "lduminalh"); // LDUMINALH_32_memop 3463 COMPARE_PREFIX(dci(0x78e08000), "swpalh"); // SWPALH_32_memop 3464 COMPARE_PREFIX(dci(0x88a07c00), "cas"); // CAS_C32_ldstexcl 3465 COMPARE_PREFIX(dci(0x88a0fc00), "casl"); // CASL_C32_ldstexcl 3466 COMPARE_PREFIX(dci(0x88e07c00), "casa"); // CASA_C32_ldstexcl 3467 COMPARE_PREFIX(dci(0x88e0fc00), "casal"); // CASAL_C32_ldstexcl 3468 COMPARE_PREFIX(dci(0xb8200000), "ldadd"); // LDADD_32_memop 3469 COMPARE_PREFIX(dci(0xb8201000), "ldclr"); // LDCLR_32_memop 3470 COMPARE_PREFIX(dci(0xb8202000), "ldeor"); // LDEOR_32_memop 3471 COMPARE_PREFIX(dci(0xb8203000), "ldset"); // LDSET_32_memop 3472 COMPARE_PREFIX(dci(0xb8204000), "ldsmax"); // LDSMAX_32_memop 3473 COMPARE_PREFIX(dci(0xb8205000), "ldsmin"); // LDSMIN_32_memop 3474 COMPARE_PREFIX(dci(0xb8206000), "ldumax"); // LDUMAX_32_memop 3475 COMPARE_PREFIX(dci(0xb8207000), "ldumin"); // LDUMIN_32_memop 3476 COMPARE_PREFIX(dci(0xb8208000), "swp"); // SWP_32_memop 3477 COMPARE_PREFIX(dci(0xb8600000), "ldaddl"); // LDADDL_32_memop 3478 COMPARE_PREFIX(dci(0xb8601000), "ldclrl"); // LDCLRL_32_memop 3479 COMPARE_PREFIX(dci(0xb8602000), "ldeorl"); // LDEORL_32_memop 3480 COMPARE_PREFIX(dci(0xb8603000), "ldsetl"); // LDSETL_32_memop 3481 COMPARE_PREFIX(dci(0xb8604000), "ldsmaxl"); // LDSMAXL_32_memop 3482 COMPARE_PREFIX(dci(0xb8605000), "ldsminl"); // LDSMINL_32_memop 3483 COMPARE_PREFIX(dci(0xb8606000), "ldumaxl"); // LDUMAXL_32_memop 3484 COMPARE_PREFIX(dci(0xb8607000), "lduminl"); // LDUMINL_32_memop 3485 COMPARE_PREFIX(dci(0xb8608000), "swpl"); // SWPL_32_memop 3486 COMPARE_PREFIX(dci(0xb8a00000), "ldadda"); // LDADDA_32_memop 3487 COMPARE_PREFIX(dci(0xb8a01000), "ldclra"); // LDCLRA_32_memop 3488 COMPARE_PREFIX(dci(0xb8a02000), "ldeora"); // LDEORA_32_memop 3489 COMPARE_PREFIX(dci(0xb8a03000), "ldseta"); // LDSETA_32_memop 3490 COMPARE_PREFIX(dci(0xb8a04000), "ldsmaxa"); // LDSMAXA_32_memop 3491 COMPARE_PREFIX(dci(0xb8a05000), "ldsmina"); // LDSMINA_32_memop 3492 COMPARE_PREFIX(dci(0xb8a06000), "ldumaxa"); // LDUMAXA_32_memop 3493 COMPARE_PREFIX(dci(0xb8a07000), "ldumina"); // LDUMINA_32_memop 3494 COMPARE_PREFIX(dci(0xb8a08000), "swpa"); // SWPA_32_memop 3495 COMPARE_PREFIX(dci(0xb8e00000), "ldaddal"); // LDADDAL_32_memop 3496 COMPARE_PREFIX(dci(0xb8e01000), "ldclral"); // LDCLRAL_32_memop 3497 COMPARE_PREFIX(dci(0xb8e02000), "ldeoral"); // LDEORAL_32_memop 3498 COMPARE_PREFIX(dci(0xb8e03000), "ldsetal"); // LDSETAL_32_memop 3499 COMPARE_PREFIX(dci(0xb8e04000), "ldsmaxal"); // LDSMAXAL_32_memop 3500 COMPARE_PREFIX(dci(0xb8e05000), "ldsminal"); // LDSMINAL_32_memop 3501 COMPARE_PREFIX(dci(0xb8e06000), "ldumaxal"); // LDUMAXAL_32_memop 3502 COMPARE_PREFIX(dci(0xb8e07000), "lduminal"); // LDUMINAL_32_memop 3503 COMPARE_PREFIX(dci(0xb8e08000), "swpal"); // SWPAL_32_memop 3504 COMPARE_PREFIX(dci(0xc8a07c00), "cas"); // CAS_C64_ldstexcl 3505 COMPARE_PREFIX(dci(0xc8a0fc00), "casl"); // CASL_C64_ldstexcl 3506 COMPARE_PREFIX(dci(0xc8e07c00), "casa"); // CASA_C64_ldstexcl 3507 COMPARE_PREFIX(dci(0xc8e0fc00), "casal"); // CASAL_C64_ldstexcl 3508 COMPARE_PREFIX(dci(0xf8200000), "ldadd"); // LDADD_64_memop 3509 COMPARE_PREFIX(dci(0xf8201000), "ldclr"); // LDCLR_64_memop 3510 COMPARE_PREFIX(dci(0xf8202000), "ldeor"); // LDEOR_64_memop 3511 COMPARE_PREFIX(dci(0xf8203000), "ldset"); // LDSET_64_memop 3512 COMPARE_PREFIX(dci(0xf8204000), "ldsmax"); // LDSMAX_64_memop 3513 COMPARE_PREFIX(dci(0xf8205000), "ldsmin"); // LDSMIN_64_memop 3514 COMPARE_PREFIX(dci(0xf8206000), "ldumax"); // LDUMAX_64_memop 3515 COMPARE_PREFIX(dci(0xf8207000), "ldumin"); // LDUMIN_64_memop 3516 COMPARE_PREFIX(dci(0xf8208000), "swp"); // SWP_64_memop 3517 COMPARE_PREFIX(dci(0xf8600000), "ldaddl"); // LDADDL_64_memop 3518 COMPARE_PREFIX(dci(0xf8601000), "ldclrl"); // LDCLRL_64_memop 3519 COMPARE_PREFIX(dci(0xf8602000), "ldeorl"); // LDEORL_64_memop 3520 COMPARE_PREFIX(dci(0xf8603000), "ldsetl"); // LDSETL_64_memop 3521 COMPARE_PREFIX(dci(0xf8604000), "ldsmaxl"); // LDSMAXL_64_memop 3522 COMPARE_PREFIX(dci(0xf8605000), "ldsminl"); // LDSMINL_64_memop 3523 COMPARE_PREFIX(dci(0xf8606000), "ldumaxl"); // LDUMAXL_64_memop 3524 COMPARE_PREFIX(dci(0xf8607000), "lduminl"); // LDUMINL_64_memop 3525 COMPARE_PREFIX(dci(0xf8608000), "swpl"); // SWPL_64_memop 3526 COMPARE_PREFIX(dci(0xf8a00000), "ldadda"); // LDADDA_64_memop 3527 COMPARE_PREFIX(dci(0xf8a01000), "ldclra"); // LDCLRA_64_memop 3528 COMPARE_PREFIX(dci(0xf8a02000), "ldeora"); // LDEORA_64_memop 3529 COMPARE_PREFIX(dci(0xf8a03000), "ldseta"); // LDSETA_64_memop 3530 COMPARE_PREFIX(dci(0xf8a04000), "ldsmaxa"); // LDSMAXA_64_memop 3531 COMPARE_PREFIX(dci(0xf8a05000), "ldsmina"); // LDSMINA_64_memop 3532 COMPARE_PREFIX(dci(0xf8a06000), "ldumaxa"); // LDUMAXA_64_memop 3533 COMPARE_PREFIX(dci(0xf8a07000), "ldumina"); // LDUMINA_64_memop 3534 COMPARE_PREFIX(dci(0xf8a08000), "swpa"); // SWPA_64_memop 3535 COMPARE_PREFIX(dci(0xf8e00000), "ldaddal"); // LDADDAL_64_memop 3536 COMPARE_PREFIX(dci(0xf8e01000), "ldclral"); // LDCLRAL_64_memop 3537 COMPARE_PREFIX(dci(0xf8e02000), "ldeoral"); // LDEORAL_64_memop 3538 COMPARE_PREFIX(dci(0xf8e03000), "ldsetal"); // LDSETAL_64_memop 3539 COMPARE_PREFIX(dci(0xf8e04000), "ldsmaxal"); // LDSMAXAL_64_memop 3540 COMPARE_PREFIX(dci(0xf8e05000), "ldsminal"); // LDSMINAL_64_memop 3541 COMPARE_PREFIX(dci(0xf8e06000), "ldumaxal"); // LDUMAXAL_64_memop 3542 COMPARE_PREFIX(dci(0xf8e07000), "lduminal"); // LDUMINAL_64_memop 3543 COMPARE_PREFIX(dci(0xf8e08000), "swpal"); // SWPAL_64_memop 3544 3545 // ARMv8.1 - RDM 3546 COMPARE_PREFIX(dci(0x2e008400), "sqrdmlah"); // SQRDMLAH_asimdsame2_only 3547 COMPARE_PREFIX(dci(0x2e008c00), "sqrdmlsh"); // SQRDMLSH_asimdsame2_only 3548 COMPARE_PREFIX(dci(0x2f40d000), "sqrdmlah"); // SQRDMLAH_asimdelem_R 3549 COMPARE_PREFIX(dci(0x2f40f000), "sqrdmlsh"); // SQRDMLSH_asimdelem_R 3550 COMPARE_PREFIX(dci(0x7e008400), "sqrdmlah"); // SQRDMLAH_asisdsame2_only 3551 COMPARE_PREFIX(dci(0x7e008c00), "sqrdmlsh"); // SQRDMLSH_asisdsame2_only 3552 COMPARE_PREFIX(dci(0x7f40d000), "sqrdmlah"); // SQRDMLAH_asisdelem_R 3553 COMPARE_PREFIX(dci(0x7f40f000), "sqrdmlsh"); // SQRDMLSH_asisdelem_R 3554 3555 // ARMv8.2 - DotProd 3556 COMPARE_PREFIX(dci(0x0e009400), "sdot"); // SDOT_asimdsame2_D 3557 COMPARE_PREFIX(dci(0x0f00e000), "sdot"); // SDOT_asimdelem_D 3558 COMPARE_PREFIX(dci(0x2e009400), "udot"); // UDOT_asimdsame2_D 3559 COMPARE_PREFIX(dci(0x2f00e000), "udot"); // UDOT_asimdelem_D 3560 3561 // ARMv8.2 - FHM 3562 COMPARE_PREFIX(dci(0x0e20ec00), "fmlal"); // FMLAL_asimdsame_F 3563 COMPARE_PREFIX(dci(0x0ea0ec00), "fmlsl"); // FMLSL_asimdsame_F 3564 COMPARE_PREFIX(dci(0x0f800000), "fmlal"); // FMLAL_asimdelem_LH 3565 COMPARE_PREFIX(dci(0x0f804000), "fmlsl"); // FMLSL_asimdelem_LH 3566 COMPARE_PREFIX(dci(0x2e20cc00), "fmlal2"); // FMLAL2_asimdsame_F 3567 COMPARE_PREFIX(dci(0x2ea0cc00), "fmlsl2"); // FMLSL2_asimdsame_F 3568 COMPARE_PREFIX(dci(0x2f808000), "fmlal2"); // FMLAL2_asimdelem_LH 3569 COMPARE_PREFIX(dci(0x2f80c000), "fmlsl2"); // FMLSL2_asimdelem_LH 3570 3571 // ARMv8.2 - FP16 3572 COMPARE_PREFIX(dci(0x0e20c400), "fmaxnm"); // FMAXNM_asimdsame_only 3573 COMPARE_PREFIX(dci(0x0e20cc00), "fmla"); // FMLA_asimdsame_only 3574 COMPARE_PREFIX(dci(0x0e20d400), "fadd"); // FADD_asimdsame_only 3575 COMPARE_PREFIX(dci(0x0e20dc00), "fmulx"); // FMULX_asimdsame_only 3576 COMPARE_PREFIX(dci(0x0e20e400), "fcmeq"); // FCMEQ_asimdsame_only 3577 COMPARE_PREFIX(dci(0x0e20f400), "fmax"); // FMAX_asimdsame_only 3578 COMPARE_PREFIX(dci(0x0e20fc00), "frecps"); // FRECPS_asimdsame_only 3579 COMPARE_PREFIX(dci(0x0e218800), "frintn"); // FRINTN_asimdmisc_R 3580 COMPARE_PREFIX(dci(0x0e219800), "frintm"); // FRINTM_asimdmisc_R 3581 COMPARE_PREFIX(dci(0x0e21a800), "fcvtns"); // FCVTNS_asimdmisc_R 3582 COMPARE_PREFIX(dci(0x0e21b800), "fcvtms"); // FCVTMS_asimdmisc_R 3583 COMPARE_PREFIX(dci(0x0e21c800), "fcvtas"); // FCVTAS_asimdmisc_R 3584 COMPARE_PREFIX(dci(0x0e21d800), "scvtf"); // SCVTF_asimdmisc_R 3585 COMPARE_PREFIX(dci(0x0e30c800), "fmaxnmv"); // FMAXNMV_asimdall_only_H 3586 COMPARE_PREFIX(dci(0x0e30f800), "fmaxv"); // FMAXV_asimdall_only_H 3587 COMPARE_PREFIX(dci(0x0e400400), "fmaxnm"); // FMAXNM_asimdsamefp16_only 3588 COMPARE_PREFIX(dci(0x0e400c00), "fmla"); // FMLA_asimdsamefp16_only 3589 COMPARE_PREFIX(dci(0x0e401400), "fadd"); // FADD_asimdsamefp16_only 3590 COMPARE_PREFIX(dci(0x0e401c00), "fmulx"); // FMULX_asimdsamefp16_only 3591 COMPARE_PREFIX(dci(0x0e402400), "fcmeq"); // FCMEQ_asimdsamefp16_only 3592 COMPARE_PREFIX(dci(0x0e403400), "fmax"); // FMAX_asimdsamefp16_only 3593 COMPARE_PREFIX(dci(0x0e403c00), "frecps"); // FRECPS_asimdsamefp16_only 3594 COMPARE_PREFIX(dci(0x0e798800), "frintn"); // FRINTN_asimdmiscfp16_R 3595 COMPARE_PREFIX(dci(0x0e799800), "frintm"); // FRINTM_asimdmiscfp16_R 3596 COMPARE_PREFIX(dci(0x0e79a800), "fcvtns"); // FCVTNS_asimdmiscfp16_R 3597 COMPARE_PREFIX(dci(0x0e79b800), "fcvtms"); // FCVTMS_asimdmiscfp16_R 3598 COMPARE_PREFIX(dci(0x0e79c800), "fcvtas"); // FCVTAS_asimdmiscfp16_R 3599 COMPARE_PREFIX(dci(0x0e79d800), "scvtf"); // SCVTF_asimdmiscfp16_R 3600 COMPARE_PREFIX(dci(0x0ea0c400), "fminnm"); // FMINNM_asimdsame_only 3601 COMPARE_PREFIX(dci(0x0ea0cc00), "fmls"); // FMLS_asimdsame_only 3602 COMPARE_PREFIX(dci(0x0ea0d400), "fsub"); // FSUB_asimdsame_only 3603 COMPARE_PREFIX(dci(0x0ea0f400), "fmin"); // FMIN_asimdsame_only 3604 COMPARE_PREFIX(dci(0x0ea0fc00), "frsqrts"); // FRSQRTS_asimdsame_only 3605 COMPARE_PREFIX(dci(0x0ea0c800), "fcmgt"); // FCMGT_asimdmisc_FZ 3606 COMPARE_PREFIX(dci(0x0ea0d800), "fcmeq"); // FCMEQ_asimdmisc_FZ 3607 COMPARE_PREFIX(dci(0x0ea0e800), "fcmlt"); // FCMLT_asimdmisc_FZ 3608 COMPARE_PREFIX(dci(0x0ea0f800), "fabs"); // FABS_asimdmisc_R 3609 COMPARE_PREFIX(dci(0x0ea18800), "frintp"); // FRINTP_asimdmisc_R 3610 COMPARE_PREFIX(dci(0x0ea19800), "frintz"); // FRINTZ_asimdmisc_R 3611 COMPARE_PREFIX(dci(0x0ea1a800), "fcvtps"); // FCVTPS_asimdmisc_R 3612 COMPARE_PREFIX(dci(0x0ea1b800), "fcvtzs"); // FCVTZS_asimdmisc_R 3613 COMPARE_PREFIX(dci(0x0ea1d800), "frecpe"); // FRECPE_asimdmisc_R 3614 COMPARE_PREFIX(dci(0x0eb0c800), "fminnmv"); // FMINNMV_asimdall_only_H 3615 COMPARE_PREFIX(dci(0x0eb0f800), "fminv"); // FMINV_asimdall_only_H 3616 COMPARE_PREFIX(dci(0x0ec00400), "fminnm"); // FMINNM_asimdsamefp16_only 3617 COMPARE_PREFIX(dci(0x0ec00c00), "fmls"); // FMLS_asimdsamefp16_only 3618 COMPARE_PREFIX(dci(0x0ec01400), "fsub"); // FSUB_asimdsamefp16_only 3619 COMPARE_PREFIX(dci(0x0ec03400), "fmin"); // FMIN_asimdsamefp16_only 3620 COMPARE_PREFIX(dci(0x0ec03c00), "frsqrts"); // FRSQRTS_asimdsamefp16_only 3621 COMPARE_PREFIX(dci(0x0ef8c800), "fcmgt"); // FCMGT_asimdmiscfp16_FZ 3622 COMPARE_PREFIX(dci(0x0ef8d800), "fcmeq"); // FCMEQ_asimdmiscfp16_FZ 3623 COMPARE_PREFIX(dci(0x0ef8e800), "fcmlt"); // FCMLT_asimdmiscfp16_FZ 3624 COMPARE_PREFIX(dci(0x0ef8f800), "fabs"); // FABS_asimdmiscfp16_R 3625 COMPARE_PREFIX(dci(0x0ef98800), "frintp"); // FRINTP_asimdmiscfp16_R 3626 COMPARE_PREFIX(dci(0x0ef99800), "frintz"); // FRINTZ_asimdmiscfp16_R 3627 COMPARE_PREFIX(dci(0x0ef9a800), "fcvtps"); // FCVTPS_asimdmiscfp16_R 3628 COMPARE_PREFIX(dci(0x0ef9b800), "fcvtzs"); // FCVTZS_asimdmiscfp16_R 3629 COMPARE_PREFIX(dci(0x0ef9d800), "frecpe"); // FRECPE_asimdmiscfp16_R 3630 COMPARE_PREFIX(dci(0x0f001000), "fmla"); // FMLA_asimdelem_RH_H 3631 COMPARE_PREFIX(dci(0x0f005000), "fmls"); // FMLS_asimdelem_RH_H 3632 COMPARE_PREFIX(dci(0x0f009000), "fmul"); // FMUL_asimdelem_RH_H 3633 COMPARE_PREFIX(dci(0x0f00f400), "fmov"); // FMOV_asimdimm_S_s 3634 COMPARE_PREFIX(dci(0x0f00fc00), "fmov"); // FMOV_asimdimm_H_h 3635 COMPARE_PREFIX(dci(0x0f801000), "fmla"); // FMLA_asimdelem_R_SD 3636 COMPARE_PREFIX(dci(0x0f805000), "fmls"); // FMLS_asimdelem_R_SD 3637 COMPARE_PREFIX(dci(0x0f809000), "fmul"); // FMUL_asimdelem_R_SD 3638 COMPARE_PREFIX(dci(0x2e20c400), "fmaxnmp"); // FMAXNMP_asimdsame_only 3639 COMPARE_PREFIX(dci(0x2e20d400), "faddp"); // FADDP_asimdsame_only 3640 COMPARE_PREFIX(dci(0x2e20dc00), "fmul"); // FMUL_asimdsame_only 3641 COMPARE_PREFIX(dci(0x2e20e400), "fcmge"); // FCMGE_asimdsame_only 3642 COMPARE_PREFIX(dci(0x2e20ec00), "facge"); // FACGE_asimdsame_only 3643 COMPARE_PREFIX(dci(0x2e20f400), "fmaxp"); // FMAXP_asimdsame_only 3644 COMPARE_PREFIX(dci(0x2e20fc00), "fdiv"); // FDIV_asimdsame_only 3645 COMPARE_PREFIX(dci(0x2e218800), "frinta"); // FRINTA_asimdmisc_R 3646 COMPARE_PREFIX(dci(0x2e219800), "frintx"); // FRINTX_asimdmisc_R 3647 COMPARE_PREFIX(dci(0x2e21a800), "fcvtnu"); // FCVTNU_asimdmisc_R 3648 COMPARE_PREFIX(dci(0x2e21b800), "fcvtmu"); // FCVTMU_asimdmisc_R 3649 COMPARE_PREFIX(dci(0x2e21c800), "fcvtau"); // FCVTAU_asimdmisc_R 3650 COMPARE_PREFIX(dci(0x2e21d800), "ucvtf"); // UCVTF_asimdmisc_R 3651 COMPARE_PREFIX(dci(0x6e30c800), "fmaxnmv"); // FMAXNMV_asimdall_only_SD 3652 COMPARE_PREFIX(dci(0x6e30f800), "fmaxv"); // FMAXV_asimdall_only_SD 3653 COMPARE_PREFIX(dci(0x2e400400), "fmaxnmp"); // FMAXNMP_asimdsamefp16_only 3654 COMPARE_PREFIX(dci(0x2e401400), "faddp"); // FADDP_asimdsamefp16_only 3655 COMPARE_PREFIX(dci(0x2e401c00), "fmul"); // FMUL_asimdsamefp16_only 3656 COMPARE_PREFIX(dci(0x2e402400), "fcmge"); // FCMGE_asimdsamefp16_only 3657 COMPARE_PREFIX(dci(0x2e402c00), "facge"); // FACGE_asimdsamefp16_only 3658 COMPARE_PREFIX(dci(0x2e403400), "fmaxp"); // FMAXP_asimdsamefp16_only 3659 COMPARE_PREFIX(dci(0x2e403c00), "fdiv"); // FDIV_asimdsamefp16_only 3660 COMPARE_PREFIX(dci(0x2e798800), "frinta"); // FRINTA_asimdmiscfp16_R 3661 COMPARE_PREFIX(dci(0x2e799800), "frintx"); // FRINTX_asimdmiscfp16_R 3662 COMPARE_PREFIX(dci(0x2e79a800), "fcvtnu"); // FCVTNU_asimdmiscfp16_R 3663 COMPARE_PREFIX(dci(0x2e79b800), "fcvtmu"); // FCVTMU_asimdmiscfp16_R 3664 COMPARE_PREFIX(dci(0x2e79c800), "fcvtau"); // FCVTAU_asimdmiscfp16_R 3665 COMPARE_PREFIX(dci(0x2e79d800), "ucvtf"); // UCVTF_asimdmiscfp16_R 3666 COMPARE_PREFIX(dci(0x2ea0c400), "fminnmp"); // FMINNMP_asimdsame_only 3667 COMPARE_PREFIX(dci(0x2ea0d400), "fabd"); // FABD_asimdsame_only 3668 COMPARE_PREFIX(dci(0x2ea0e400), "fcmgt"); // FCMGT_asimdsame_only 3669 COMPARE_PREFIX(dci(0x2ea0ec00), "facgt"); // FACGT_asimdsame_only 3670 COMPARE_PREFIX(dci(0x2ea0f400), "fminp"); // FMINP_asimdsame_only 3671 COMPARE_PREFIX(dci(0x2ea0c800), "fcmge"); // FCMGE_asimdmisc_FZ 3672 COMPARE_PREFIX(dci(0x2ea0d800), "fcmle"); // FCMLE_asimdmisc_FZ 3673 COMPARE_PREFIX(dci(0x2ea0f800), "fneg"); // FNEG_asimdmisc_R 3674 COMPARE_PREFIX(dci(0x2ea19800), "frinti"); // FRINTI_asimdmisc_R 3675 COMPARE_PREFIX(dci(0x2ea1a800), "fcvtpu"); // FCVTPU_asimdmisc_R 3676 COMPARE_PREFIX(dci(0x2ea1b800), "fcvtzu"); // FCVTZU_asimdmisc_R 3677 COMPARE_PREFIX(dci(0x2ea1d800), "frsqrte"); // FRSQRTE_asimdmisc_R 3678 COMPARE_PREFIX(dci(0x2ea1f800), "fsqrt"); // FSQRT_asimdmisc_R 3679 COMPARE_PREFIX(dci(0x6eb0c800), "fminnmv"); // FMINNMV_asimdall_only_SD 3680 COMPARE_PREFIX(dci(0x6eb0f800), "fminv"); // FMINV_asimdall_only_SD 3681 COMPARE_PREFIX(dci(0x2ec00400), "fminnmp"); // FMINNMP_asimdsamefp16_only 3682 COMPARE_PREFIX(dci(0x2ec01400), "fabd"); // FABD_asimdsamefp16_only 3683 COMPARE_PREFIX(dci(0x2ec02400), "fcmgt"); // FCMGT_asimdsamefp16_only 3684 COMPARE_PREFIX(dci(0x2ec02c00), "facgt"); // FACGT_asimdsamefp16_only 3685 COMPARE_PREFIX(dci(0x2ec03400), "fminp"); // FMINP_asimdsamefp16_only 3686 COMPARE_PREFIX(dci(0x2ef8c800), "fcmge"); // FCMGE_asimdmiscfp16_FZ 3687 COMPARE_PREFIX(dci(0x2ef8d800), "fcmle"); // FCMLE_asimdmiscfp16_FZ 3688 COMPARE_PREFIX(dci(0x2ef8f800), "fneg"); // FNEG_asimdmiscfp16_R 3689 COMPARE_PREFIX(dci(0x2ef99800), "frinti"); // FRINTI_asimdmiscfp16_R 3690 COMPARE_PREFIX(dci(0x2ef9a800), "fcvtpu"); // FCVTPU_asimdmiscfp16_R 3691 COMPARE_PREFIX(dci(0x2ef9b800), "fcvtzu"); // FCVTZU_asimdmiscfp16_R 3692 COMPARE_PREFIX(dci(0x2ef9d800), "frsqrte"); // FRSQRTE_asimdmiscfp16_R 3693 COMPARE_PREFIX(dci(0x2ef9f800), "fsqrt"); // FSQRT_asimdmiscfp16_R 3694 COMPARE_PREFIX(dci(0x2f009000), "fmulx"); // FMULX_asimdelem_RH_H 3695 COMPARE_PREFIX(dci(0x2f809000), "fmulx"); // FMULX_asimdelem_R_SD 3696 COMPARE_PREFIX(dci(0x5e20dc00), "fmulx"); // FMULX_asisdsame_only 3697 COMPARE_PREFIX(dci(0x5e20e400), "fcmeq"); // FCMEQ_asisdsame_only 3698 COMPARE_PREFIX(dci(0x5e20fc00), "frecps"); // FRECPS_asisdsame_only 3699 COMPARE_PREFIX(dci(0x5e21a800), "fcvtns"); // FCVTNS_asisdmisc_R 3700 COMPARE_PREFIX(dci(0x5e21b800), "fcvtms"); // FCVTMS_asisdmisc_R 3701 COMPARE_PREFIX(dci(0x5e21c800), "fcvtas"); // FCVTAS_asisdmisc_R 3702 COMPARE_PREFIX(dci(0x5e21d800), "scvtf"); // SCVTF_asisdmisc_R 3703 COMPARE_PREFIX(dci(0x5e30c800), "fmaxnmp"); // FMAXNMP_asisdpair_only_H 3704 COMPARE_PREFIX(dci(0x5e30d800), "faddp"); // FADDP_asisdpair_only_H 3705 COMPARE_PREFIX(dci(0x5e30f800), "fmaxp"); // FMAXP_asisdpair_only_H 3706 COMPARE_PREFIX(dci(0x5e401c00), "fmulx"); // FMULX_asisdsamefp16_only 3707 COMPARE_PREFIX(dci(0x5e402400), "fcmeq"); // FCMEQ_asisdsamefp16_only 3708 COMPARE_PREFIX(dci(0x5e403c00), "frecps"); // FRECPS_asisdsamefp16_only 3709 COMPARE_PREFIX(dci(0x5e79a800), "fcvtns"); // FCVTNS_asisdmiscfp16_R 3710 COMPARE_PREFIX(dci(0x5e79b800), "fcvtms"); // FCVTMS_asisdmiscfp16_R 3711 COMPARE_PREFIX(dci(0x5e79c800), "fcvtas"); // FCVTAS_asisdmiscfp16_R 3712 COMPARE_PREFIX(dci(0x5e79d800), "scvtf"); // SCVTF_asisdmiscfp16_R 3713 COMPARE_PREFIX(dci(0x5ea0fc00), "frsqrts"); // FRSQRTS_asisdsame_only 3714 COMPARE_PREFIX(dci(0x5ea0c800), "fcmgt"); // FCMGT_asisdmisc_FZ 3715 COMPARE_PREFIX(dci(0x5ea0d800), "fcmeq"); // FCMEQ_asisdmisc_FZ 3716 COMPARE_PREFIX(dci(0x5ea0e800), "fcmlt"); // FCMLT_asisdmisc_FZ 3717 COMPARE_PREFIX(dci(0x5ea1a800), "fcvtps"); // FCVTPS_asisdmisc_R 3718 COMPARE_PREFIX(dci(0x5ea1b800), "fcvtzs"); // FCVTZS_asisdmisc_R 3719 COMPARE_PREFIX(dci(0x5ea1d800), "frecpe"); // FRECPE_asisdmisc_R 3720 COMPARE_PREFIX(dci(0x5ea1f800), "frecpx"); // FRECPX_asisdmisc_R 3721 COMPARE_PREFIX(dci(0x5eb0c800), "fminnmp"); // FMINNMP_asisdpair_only_H 3722 COMPARE_PREFIX(dci(0x5eb0f800), "fminp"); // FMINP_asisdpair_only_H 3723 COMPARE_PREFIX(dci(0x5ec03c00), "frsqrts"); // FRSQRTS_asisdsamefp16_only 3724 COMPARE_PREFIX(dci(0x5ef8c800), "fcmgt"); // FCMGT_asisdmiscfp16_FZ 3725 COMPARE_PREFIX(dci(0x5ef8d800), "fcmeq"); // FCMEQ_asisdmiscfp16_FZ 3726 COMPARE_PREFIX(dci(0x5ef8e800), "fcmlt"); // FCMLT_asisdmiscfp16_FZ 3727 COMPARE_PREFIX(dci(0x5ef9a800), "fcvtps"); // FCVTPS_asisdmiscfp16_R 3728 COMPARE_PREFIX(dci(0x5ef9b800), "fcvtzs"); // FCVTZS_asisdmiscfp16_R 3729 COMPARE_PREFIX(dci(0x5ef9d800), "frecpe"); // FRECPE_asisdmiscfp16_R 3730 COMPARE_PREFIX(dci(0x5ef9f800), "frecpx"); // FRECPX_asisdmiscfp16_R 3731 COMPARE_PREFIX(dci(0x5f001000), "fmla"); // FMLA_asisdelem_RH_H 3732 COMPARE_PREFIX(dci(0x5f005000), "fmls"); // FMLS_asisdelem_RH_H 3733 COMPARE_PREFIX(dci(0x5f009000), "fmul"); // FMUL_asisdelem_RH_H 3734 COMPARE_PREFIX(dci(0x5f801000), "fmla"); // FMLA_asisdelem_R_SD 3735 COMPARE_PREFIX(dci(0x5f805000), "fmls"); // FMLS_asisdelem_R_SD 3736 COMPARE_PREFIX(dci(0x5f809000), "fmul"); // FMUL_asisdelem_R_SD 3737 COMPARE_PREFIX(dci(0x6f00f400), "fmov"); // FMOV_asimdimm_D2_d 3738 COMPARE_PREFIX(dci(0x7e20e400), "fcmge"); // FCMGE_asisdsame_only 3739 COMPARE_PREFIX(dci(0x7e20ec00), "facge"); // FACGE_asisdsame_only 3740 COMPARE_PREFIX(dci(0x7e21a800), "fcvtnu"); // FCVTNU_asisdmisc_R 3741 COMPARE_PREFIX(dci(0x7e21b800), "fcvtmu"); // FCVTMU_asisdmisc_R 3742 COMPARE_PREFIX(dci(0x7e21c800), "fcvtau"); // FCVTAU_asisdmisc_R 3743 COMPARE_PREFIX(dci(0x7e21d800), "ucvtf"); // UCVTF_asisdmisc_R 3744 COMPARE_PREFIX(dci(0x7e30c800), "fmaxnmp"); // FMAXNMP_asisdpair_only_SD 3745 COMPARE_PREFIX(dci(0x7e30d800), "faddp"); // FADDP_asisdpair_only_SD 3746 COMPARE_PREFIX(dci(0x7e30f800), "fmaxp"); // FMAXP_asisdpair_only_SD 3747 COMPARE_PREFIX(dci(0x7e402400), "fcmge"); // FCMGE_asisdsamefp16_only 3748 COMPARE_PREFIX(dci(0x7e402c00), "facge"); // FACGE_asisdsamefp16_only 3749 COMPARE_PREFIX(dci(0x7e79a800), "fcvtnu"); // FCVTNU_asisdmiscfp16_R 3750 COMPARE_PREFIX(dci(0x7e79b800), "fcvtmu"); // FCVTMU_asisdmiscfp16_R 3751 COMPARE_PREFIX(dci(0x7e79c800), "fcvtau"); // FCVTAU_asisdmiscfp16_R 3752 COMPARE_PREFIX(dci(0x7e79d800), "ucvtf"); // UCVTF_asisdmiscfp16_R 3753 COMPARE_PREFIX(dci(0x7ea0d400), "fabd"); // FABD_asisdsame_only 3754 COMPARE_PREFIX(dci(0x7ea0e400), "fcmgt"); // FCMGT_asisdsame_only 3755 COMPARE_PREFIX(dci(0x7ea0ec00), "facgt"); // FACGT_asisdsame_only 3756 COMPARE_PREFIX(dci(0x7ea0c800), "fcmge"); // FCMGE_asisdmisc_FZ 3757 COMPARE_PREFIX(dci(0x7ea0d800), "fcmle"); // FCMLE_asisdmisc_FZ 3758 COMPARE_PREFIX(dci(0x7ea1a800), "fcvtpu"); // FCVTPU_asisdmisc_R 3759 COMPARE_PREFIX(dci(0x7ea1b800), "fcvtzu"); // FCVTZU_asisdmisc_R 3760 COMPARE_PREFIX(dci(0x7ea1d800), "frsqrte"); // FRSQRTE_asisdmisc_R 3761 COMPARE_PREFIX(dci(0x7eb0c800), "fminnmp"); // FMINNMP_asisdpair_only_SD 3762 COMPARE_PREFIX(dci(0x7eb0f800), "fminp"); // FMINP_asisdpair_only_SD 3763 COMPARE_PREFIX(dci(0x7ec01400), "fabd"); // FABD_asisdsamefp16_only 3764 COMPARE_PREFIX(dci(0x7ec02400), "fcmgt"); // FCMGT_asisdsamefp16_only 3765 COMPARE_PREFIX(dci(0x7ec02c00), "facgt"); // FACGT_asisdsamefp16_only 3766 COMPARE_PREFIX(dci(0x7ef8c800), "fcmge"); // FCMGE_asisdmiscfp16_FZ 3767 COMPARE_PREFIX(dci(0x7ef8d800), "fcmle"); // FCMLE_asisdmiscfp16_FZ 3768 COMPARE_PREFIX(dci(0x7ef9a800), "fcvtpu"); // FCVTPU_asisdmiscfp16_R 3769 COMPARE_PREFIX(dci(0x7ef9b800), "fcvtzu"); // FCVTZU_asisdmiscfp16_R 3770 COMPARE_PREFIX(dci(0x7ef9d800), "frsqrte"); // FRSQRTE_asisdmiscfp16_R 3771 COMPARE_PREFIX(dci(0x7f009000), "fmulx"); // FMULX_asisdelem_RH_H 3772 COMPARE_PREFIX(dci(0x7f809000), "fmulx"); // FMULX_asisdelem_R_SD 3773 3774 // ARMv8.2 - RAS 3775 COMPARE_PREFIX(dci(0xd503221f), "esb"); // ESB_HI_hints 3776 3777 // ARMv8.2 - SHA3 3778 // COMPARE_PREFIX(dci(0xce000000), "eor3"); // EOR3_VVV16_crypto4 3779 // COMPARE_PREFIX(dci(0xce200000), "bcax"); // BCAX_VVV16_crypto4 3780 // COMPARE_PREFIX(dci(0xce608c00), "rax1"); // RAX1_VVV2_cryptosha512_3 3781 // COMPARE_PREFIX(dci(0xce800000), "xar"); // XAR_VVV2_crypto3_imm6 3782 3783 // ARMv8.2 - SHA512 3784 // COMPARE_PREFIX(dci(0xce608000), "sha512h"); // SHA512H_QQV_cryptosha512_3 3785 // COMPARE_PREFIX(dci(0xce608400), "sha512h2"); // 3786 // SHA512H2_QQV_cryptosha512_3 3787 // COMPARE_PREFIX(dci(0xce608800), "sha512su1"); // 3788 // SHA512SU1_VVV2_cryptosha512_3 3789 // COMPARE_PREFIX(dci(0xcec08000), "sha512su0"); // 3790 // SHA512SU0_VV2_cryptosha512_2 3791 3792 // ARMv8.2 - SM3 3793 // COMPARE_PREFIX(dci(0xce400000), "sm3ss1"); // SM3SS1_VVV4_crypto4 3794 // COMPARE_PREFIX(dci(0xce408000), "sm3tt1a"); // SM3TT1A_VVV4_crypto3_imm2 3795 // COMPARE_PREFIX(dci(0xce408400), "sm3tt1b"); // SM3TT1B_VVV4_crypto3_imm2 3796 // COMPARE_PREFIX(dci(0xce408800), "sm3tt2a"); // SM3TT2A_VVV4_crypto3_imm2 3797 // COMPARE_PREFIX(dci(0xce408c00), "sm3tt2b"); // SM3TT2B_VVV_crypto3_imm2 3798 // COMPARE_PREFIX(dci(0xce60c000), "sm3partw1"); // 3799 // SM3PARTW1_VVV4_cryptosha512_3 3800 // COMPARE_PREFIX(dci(0xce60c400), "sm3partw2"); // 3801 // SM3PARTW2_VVV4_cryptosha512_3 3802 3803 // ARMv8.2 - SM4 3804 // COMPARE_PREFIX(dci(0xce60c800), "sm4ekey"); // 3805 // SM4EKEY_VVV4_cryptosha512_3 3806 // COMPARE_PREFIX(dci(0xcec08400), "sm4e"); // SM4E_VV4_cryptosha512_2 3807 3808 // ARMv8.2 - SPE 3809 // COMPARE_PREFIX(dci(0xd503223f), "psb"); // PSB_HC_hints 3810 3811 // ARMv8.3 - FCMA 3812 COMPARE_PREFIX(dci(0x2e40c400), "fcmla"); // FCMLA_asimdsame2_C 3813 COMPARE_PREFIX(dci(0x2e00e400), "fcadd"); // FCADD_asimdsame2_C 3814 COMPARE_PREFIX(dci(0x2f401000), "fcmla"); // FCMLA_asimdelem_C_H 3815 COMPARE_PREFIX(dci(0x6f801000), "fcmla"); // FCMLA_asimdelem_C_S 3816 3817 // ARMv8.3 - JSCVT 3818 COMPARE_PREFIX(dci(0x1e7e0000), "fjcvtzs"); // FJCVTZS_32D_float2int 3819 3820 // ARMv8.3 - LRCPC 3821 COMPARE_PREFIX(dci(0x38bfc000), "ldaprb"); // LDAPRB_32L_memop 3822 COMPARE_PREFIX(dci(0x78bfc000), "ldaprh"); // LDAPRH_32L_memop 3823 COMPARE_PREFIX(dci(0xb8bfc000), "ldapr"); // LDAPR_32L_memop 3824 COMPARE_PREFIX(dci(0xf8bfc000), "ldapr"); // LDAPR_64L_memop 3825 3826 // ARMv8.3 - PAuth 3827 COMPARE_PREFIX(dci(0x9ac03000), "pacga"); // PACGA_64P_dp_2src 3828 COMPARE_PREFIX(dci(0xd50320ff), "xpaclri"); // XPACLRI_HI_hints 3829 COMPARE_PREFIX(dci(0xd503211f), "pacia1716"); // PACIA1716_HI_hints 3830 COMPARE_PREFIX(dci(0xd503215f), "pacib1716"); // PACIB1716_HI_hints 3831 COMPARE_PREFIX(dci(0xd503219f), "autia1716"); // AUTIA1716_HI_hints 3832 COMPARE_PREFIX(dci(0xd50321df), "autib1716"); // AUTIB1716_HI_hints 3833 COMPARE_PREFIX(dci(0xd503231f), "paciaz"); // PACIAZ_HI_hints 3834 COMPARE_PREFIX(dci(0xd503233f), "paciasp"); // PACIASP_HI_hints 3835 COMPARE_PREFIX(dci(0xd503235f), "pacibz"); // PACIBZ_HI_hints 3836 COMPARE_PREFIX(dci(0xd503237f), "pacibsp"); // PACIBSP_HI_hints 3837 COMPARE_PREFIX(dci(0xd503239f), "autiaz"); // AUTIAZ_HI_hints 3838 COMPARE_PREFIX(dci(0xd50323bf), "autiasp"); // AUTIASP_HI_hints 3839 COMPARE_PREFIX(dci(0xd50323df), "autibz"); // AUTIBZ_HI_hints 3840 COMPARE_PREFIX(dci(0xd50323ff), "autibsp"); // AUTIBSP_HI_hints 3841 COMPARE_PREFIX(dci(0xd61f081f), "braaz"); // BRAAZ_64_branch_reg 3842 COMPARE_PREFIX(dci(0xd61f0c1f), "brabz"); // BRABZ_64_branch_reg 3843 COMPARE_PREFIX(dci(0xd63f081f), "blraaz"); // BLRAAZ_64_branch_reg 3844 COMPARE_PREFIX(dci(0xd63f0c1f), "blrabz"); // BLRABZ_64_branch_reg 3845 COMPARE_PREFIX(dci(0xd65f0bff), "retaa"); // RETAA_64E_branch_reg 3846 COMPARE_PREFIX(dci(0xd65f0fff), "retab"); // RETAB_64E_branch_reg 3847 // COMPARE_PREFIX(dci(0xd69f0bff), "eretaa"); // ERETAA_64E_branch_reg 3848 // COMPARE_PREFIX(dci(0xd69f0fff), "eretab"); // ERETAB_64E_branch_reg 3849 COMPARE_PREFIX(dci(0xd71f0800), "braa"); // BRAA_64P_branch_reg 3850 COMPARE_PREFIX(dci(0xd71f0c00), "brab"); // BRAB_64P_branch_reg 3851 COMPARE_PREFIX(dci(0xd73f0800), "blraa"); // BLRAA_64P_branch_reg 3852 COMPARE_PREFIX(dci(0xd73f0c00), "blrab"); // BLRAB_64P_branch_reg 3853 COMPARE_PREFIX(dci(0xdac10000), "pacia"); // PACIA_64P_dp_1src 3854 COMPARE_PREFIX(dci(0xdac10400), "pacib"); // PACIB_64P_dp_1src 3855 COMPARE_PREFIX(dci(0xdac10800), "pacda"); // PACDA_64P_dp_1src 3856 COMPARE_PREFIX(dci(0xdac10c00), "pacdb"); // PACDB_64P_dp_1src 3857 COMPARE_PREFIX(dci(0xdac11000), "autia"); // AUTIA_64P_dp_1src 3858 COMPARE_PREFIX(dci(0xdac11400), "autib"); // AUTIB_64P_dp_1src 3859 COMPARE_PREFIX(dci(0xdac11800), "autda"); // AUTDA_64P_dp_1src 3860 COMPARE_PREFIX(dci(0xdac11c00), "autdb"); // AUTDB_64P_dp_1src 3861 COMPARE_PREFIX(dci(0xdac123e0), "paciza"); // PACIZA_64Z_dp_1src 3862 COMPARE_PREFIX(dci(0xdac127e0), "pacizb"); // PACIZB_64Z_dp_1src 3863 COMPARE_PREFIX(dci(0xdac12be0), "pacdza"); // PACDZA_64Z_dp_1src 3864 COMPARE_PREFIX(dci(0xdac12fe0), "pacdzb"); // PACDZB_64Z_dp_1src 3865 COMPARE_PREFIX(dci(0xdac133e0), "autiza"); // AUTIZA_64Z_dp_1src 3866 COMPARE_PREFIX(dci(0xdac137e0), "autizb"); // AUTIZB_64Z_dp_1src 3867 COMPARE_PREFIX(dci(0xdac13be0), "autdza"); // AUTDZA_64Z_dp_1src 3868 COMPARE_PREFIX(dci(0xdac13fe0), "autdzb"); // AUTDZB_64Z_dp_1src 3869 COMPARE_PREFIX(dci(0xdac143e0), "xpaci"); // XPACI_64Z_dp_1src 3870 COMPARE_PREFIX(dci(0xdac147e0), "xpacd"); // XPACD_64Z_dp_1src 3871 COMPARE_PREFIX(dci(0xf8200400), "ldraa"); // LDRAA_64_ldst_pac 3872 COMPARE_PREFIX(dci(0xf8200c00), "ldraa"); // LDRAA_64W_ldst_pac 3873 COMPARE_PREFIX(dci(0xf8a00400), "ldrab"); // LDRAB_64_ldst_pac 3874 COMPARE_PREFIX(dci(0xf8a00c00), "ldrab"); // LDRAB_64W_ldst_pac 3875 3876 // ARMv8.4 - FlagM 3877 COMPARE_PREFIX(dci(0x3a00080d), "setf8"); // SETF8_only_setf 3878 COMPARE_PREFIX(dci(0x3a00480d), "setf16"); // SETF16_only_setf 3879 COMPARE_PREFIX(dci(0xba000400), "rmif"); // RMIF_only_rmif 3880 COMPARE_PREFIX(dci(0xd500401f), "cfinv"); // CFINV_M_pstate 3881 3882 // ARMv8.4 - LRCPC2 3883 COMPARE_PREFIX(dci(0x19000000), "stlurb"); // STLURB_32_ldapstl_unscaled 3884 COMPARE_PREFIX(dci(0x19400000), "ldapurb"); // LDAPURB_32_ldapstl_unscaled 3885 COMPARE_PREFIX(dci(0x19800000), "ldapursb"); // LDAPURSB_64_ldapstl_unscaled 3886 COMPARE_PREFIX(dci(0x19c00000), "ldapursb"); // LDAPURSB_32_ldapstl_unscaled 3887 COMPARE_PREFIX(dci(0x59000000), "stlurh"); // STLURH_32_ldapstl_unscaled 3888 COMPARE_PREFIX(dci(0x59400000), "ldapurh"); // LDAPURH_32_ldapstl_unscaled 3889 COMPARE_PREFIX(dci(0x59800000), "ldapursh"); // LDAPURSH_64_ldapstl_unscaled 3890 COMPARE_PREFIX(dci(0x59c00000), "ldapursh"); // LDAPURSH_32_ldapstl_unscaled 3891 COMPARE_PREFIX(dci(0x99000000), "stlur"); // STLUR_32_ldapstl_unscaled 3892 COMPARE_PREFIX(dci(0x99400000), "ldapur"); // LDAPUR_32_ldapstl_unscaled 3893 COMPARE_PREFIX(dci(0x99800000), "ldapursw"); // LDAPURSW_64_ldapstl_unscaled 3894 COMPARE_PREFIX(dci(0xd9000000), "stlur"); // STLUR_64_ldapstl_unscaled 3895 COMPARE_PREFIX(dci(0xd9400000), "ldapur"); // LDAPUR_64_ldapstl_unscaled 3896 3897 // ARMv8.4 - TRF 3898 // COMPARE_PREFIX(dci(0xd503225f), "tsb"); // TSB_HC_hints 3899 3900 // ARMv8.5 - BTI 3901 COMPARE_PREFIX(dci(0xd503241f), "bti"); // BTI_HB_hints 3902 3903 // ARMv8.5 - FRINTTS 3904 COMPARE_PREFIX(dci(0x0e21e800), "frint32z"); // FRINT32Z_asimdmisc_R 3905 COMPARE_PREFIX(dci(0x0e21f800), "frint64z"); // FRINT64Z_asimdmisc_R 3906 COMPARE_PREFIX(dci(0x2e21e800), "frint32x"); // FRINT32X_asimdmisc_R 3907 COMPARE_PREFIX(dci(0x2e21f800), "frint64x"); // FRINT64X_asimdmisc_R 3908 COMPARE_PREFIX(dci(0x1e284000), "frint32z"); // FRINT32Z_S_floatdp1 3909 COMPARE_PREFIX(dci(0x1e28c000), "frint32x"); // FRINT32X_S_floatdp1 3910 COMPARE_PREFIX(dci(0x1e294000), "frint64z"); // FRINT64Z_S_floatdp1 3911 COMPARE_PREFIX(dci(0x1e29c000), "frint64x"); // FRINT64X_S_floatdp1 3912 COMPARE_PREFIX(dci(0x1e684000), "frint32z"); // FRINT32Z_D_floatdp1 3913 COMPARE_PREFIX(dci(0x1e68c000), "frint32x"); // FRINT32X_D_floatdp1 3914 COMPARE_PREFIX(dci(0x1e694000), "frint64z"); // FRINT64Z_D_floatdp1 3915 COMPARE_PREFIX(dci(0x1e69c000), "frint64x"); // FRINT64X_D_floatdp1 3916 3917 // ARMv8.5 - FlagM2 3918 COMPARE_PREFIX(dci(0xd500403f), "xaflag"); // XAFLAG_M_pstate 3919 COMPARE_PREFIX(dci(0xd500405f), "axflag"); // AXFLAG_M_pstate 3920 3921 // ARMv8.5 - MTE 3922 // COMPARE_PREFIX(dci(0x68800000), "stgp"); // STGP_64_ldstpair_post 3923 // COMPARE_PREFIX(dci(0x69000000), "stgp"); // STGP_64_ldstpair_off 3924 // COMPARE_PREFIX(dci(0x69800000), "stgp"); // STGP_64_ldstpair_pre 3925 // COMPARE_PREFIX(dci(0x91800000), "addg"); // ADDG_64_addsub_immtags 3926 // COMPARE_PREFIX(dci(0x9ac00000), "subp"); // SUBP_64S_dp_2src 3927 // COMPARE_PREFIX(dci(0x9ac01000), "irg"); // IRG_64I_dp_2src 3928 // COMPARE_PREFIX(dci(0x9ac01400), "gmi"); // GMI_64G_dp_2src 3929 // COMPARE_PREFIX(dci(0xbac00000), "subps"); // SUBPS_64S_dp_2src 3930 // COMPARE_PREFIX(dci(0xd1800000), "subg"); // SUBG_64_addsub_immtags 3931 // COMPARE_PREFIX(dci(0xd9200400), "stg"); // STG_64Spost_ldsttags 3932 // COMPARE_PREFIX(dci(0xd9200800), "stg"); // STG_64Soffset_ldsttags 3933 // COMPARE_PREFIX(dci(0xd9200c00), "stg"); // STG_64Spre_ldsttags 3934 // COMPARE_PREFIX(dci(0xd9600000), "ldg"); // LDG_64Loffset_ldsttags 3935 // COMPARE_PREFIX(dci(0xd9600400), "stzg"); // STZG_64Spost_ldsttags 3936 // COMPARE_PREFIX(dci(0xd9600800), "stzg"); // STZG_64Soffset_ldsttags 3937 // COMPARE_PREFIX(dci(0xd9600c00), "stzg"); // STZG_64Spre_ldsttags 3938 // COMPARE_PREFIX(dci(0xd9a00400), "st2g"); // ST2G_64Spost_ldsttags 3939 // COMPARE_PREFIX(dci(0xd9a00800), "st2g"); // ST2G_64Soffset_ldsttags 3940 // COMPARE_PREFIX(dci(0xd9a00c00), "st2g"); // ST2G_64Spre_ldsttags 3941 // COMPARE_PREFIX(dci(0xd9e00400), "stz2g"); // STZ2G_64Spost_ldsttags 3942 // COMPARE_PREFIX(dci(0xd9e00800), "stz2g"); // STZ2G_64Soffset_ldsttags 3943 // COMPARE_PREFIX(dci(0xd9e00c00), "stz2g"); // STZ2G_64Spre_ldsttags 3944 3945 // ARMv8.5 - MTE2 3946 // COMPARE_PREFIX(dci(0xd9200000), "stzgm"); // STZGM_64bulk_ldsttags 3947 // COMPARE_PREFIX(dci(0xd9a00000), "stgm"); // STGM_64bulk_ldsttags 3948 // COMPARE_PREFIX(dci(0xd9e00000), "ldgm"); // LDGM_64bulk_ldsttags 3949 3950 // ARMv8.6 - BF16 3951 // COMPARE_PREFIX(dci(0x0ea16800), "bfcvtn"); // BFCVTN_asimdmisc_4S 3952 // COMPARE_PREFIX(dci(0x0f40f000), "bfdot"); // BFDOT_asimdelem_E 3953 // COMPARE_PREFIX(dci(0x0fc0f000), "bfmlal"); // BFMLAL_asimdelem_F 3954 // COMPARE_PREFIX(dci(0x2e40fc00), "bfdot"); // BFDOT_asimdsame2_D 3955 // COMPARE_PREFIX(dci(0x2ec0fc00), "bfmlal"); // BFMLAL_asimdsame2_F_ 3956 // COMPARE_PREFIX(dci(0x1e634000), "bfcvt"); // BFCVT_BS_floatdp1 3957 // COMPARE_PREFIX(dci(0x6e40ec00), "bfmmla"); // BFMMLA_asimdsame2_E 3958 3959 // ARMv8.6 - DGH 3960 // COMPARE_PREFIX(dci(0xd50320df), "dgh"); // DGH_HI_hints 3961 3962 // ARMv8.6 - I8MM 3963 COMPARE_PREFIX(dci(0x0e809c00), "usdot"); // USDOT_asimdsame2_D 3964 COMPARE_PREFIX(dci(0x0f00f000), "sudot"); // SUDOT_asimdelem_D 3965 COMPARE_PREFIX(dci(0x0f80f000), "usdot"); // USDOT_asimdelem_D 3966 COMPARE_PREFIX(dci(0x4e80a400), "smmla"); // SMMLA_asimdsame2_G 3967 COMPARE_PREFIX(dci(0x4e80ac00), "usmmla"); // USMMLA_asimdsame2_G 3968 COMPARE_PREFIX(dci(0x6e80a400), "ummla"); // UMMLA_asimdsame2_G 3969 3970 // ARMv8.7 - LS64 3971 // COMPARE_PREFIX(dci(0xf83f9000), "st64b"); // ST64B_64L_memop 3972 // COMPARE_PREFIX(dci(0xf83fd000), "ld64b"); // LD64B_64L_memop 3973 3974 // ARMv8.7 - LS64_V 3975 // COMPARE_PREFIX(dci(0xf820a000), "st64bv0"); // ST64BV0_64_memop 3976 // COMPARE_PREFIX(dci(0xf820b000), "st64bv"); // ST64BV_64_memop 3977 3978 // ARMv8.7 - WFxT 3979 // COMPARE_PREFIX(dci(0xd5031000), "wfet"); // WFET_only_systeminstrswithreg 3980 // COMPARE_PREFIX(dci(0xd5031020), "wfit"); // WFIT_only_systeminstrswithreg 3981 3982 // TME 3983 // COMPARE_PREFIX(dci(0xd4600000), "tcancel"); // TCANCEL_EX_exception 3984 // COMPARE_PREFIX(dci(0xd503307f), "tcommit"); // TCOMMIT_only_barriers 3985 // COMPARE_PREFIX(dci(0xd5233060), "tstart"); // TSTART_BR_systemresult 3986 // COMPARE_PREFIX(dci(0xd5233160), "ttest"); // TTEST_BR_systemresult 3987 3988 CLEANUP(); 3989} 3990 3991} // namespace aarch64 3992} // namespace vixl 3993