A64: Synchronize with r15545.

test/cctest/test-disasm-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 264 matching lines @@
 
   COMPARE(add(w1, wcsp, Operand(8)), "add w1, wcsp, #0x8 (8)");
   COMPARE(add(x2, csp, Operand(16)), "add x2, csp, #0x10 (16)");
   COMPARE(add(wcsp, wcsp, Operand(42)), "add wcsp, wcsp, #0x2a (42)");
   COMPARE(cmn(csp, Operand(24)), "cmn csp, #0x18 (24)");
   COMPARE(adds(wzr, wcsp, Operand(9)), "cmn wcsp, #0x9 (9)");
 
   CLEANUP();
 }
 
+
 TEST_(sub_immediate) {
   SET_UP();
 
   COMPARE(sub(w0, w1, Operand(0xff)), "sub w0, w1, #0xff (255)");
   COMPARE(sub(x2, x3, Operand(0x3ff)), "sub x2, x3, #0x3ff (1023)");
   COMPARE(sub(w4, w5, Operand(0xfff)), "sub w4, w5, #0xfff (4095)");
   COMPARE(sub(x6, x7, Operand(0x1000)), "sub x6, x7, #0x1000 (4096)");
   COMPARE(sub(w8, w9, Operand(0xff000)), "sub w8, w9, #0xff000 (1044480)");
   COMPARE(sub(x10, x11, Operand(0x3ff000)),
           "sub x10, x11, #0x3ff000 (4190208)");
@@ skipping 472 matching lines @@
   COMPARE(lsrv(w6, w7, w8), "lsr w6, w7, w8");
   COMPARE(lsrv(x9, x10, x11), "lsr x9, x10, x11");
   COMPARE(asrv(w12, w13, w14), "asr w12, w13, w14");
   COMPARE(asrv(x15, x16, x17), "asr x15, x16, x17");
   COMPARE(rorv(w18, w19, w20), "ror w18, w19, w20");
   COMPARE(rorv(x21, x22, x23), "ror x21, x22, x23");
 
   CLEANUP();
 }
 
+
 TEST_(adr) {
   SET_UP();
 
   COMPARE(adr(x0, 0), "adr x0, #+0x0");
   COMPARE(adr(x1, 1), "adr x1, #+0x1");
   COMPARE(adr(x2, -1), "adr x2, #-0x1");
   COMPARE(adr(x3, 4), "adr x3, #+0x4");
   COMPARE(adr(x4, -4), "adr x4, #-0x4");
   COMPARE(adr(x5, 0x000fffff), "adr x5, #+0xfffff");
   COMPARE(adr(x6, -0x00100000), "adr x6, #-0x100000");
   COMPARE(adr(xzr, 0), "adr xzr, #+0x0");
 
   CLEANUP();
 }
 
+
 TEST_(branch) {
   SET_UP();
 
   #define INST_OFF(x) ((x) >> kInstructionSizeLog2)
   COMPARE(b(INST_OFF(0x4)), "b #+0x4");
   COMPARE(b(INST_OFF(-0x4)), "b #-0x4");
   COMPARE(b(INST_OFF(0x7fffffc)), "b #+0x7fffffc");
   COMPARE(b(INST_OFF(-0x8000000)), "b #-0x8000000");
   COMPARE(b(INST_OFF(0xffffc), eq), "b.eq #+0xffffc");
   COMPARE(b(INST_OFF(-0x100000), mi), "b.mi #-0x100000");
@@ skipping 16 matching lines @@
   COMPARE(tbnz(x11, 31, INST_OFF(0x4)), "tbnz w11, #31, #+0x4");
   COMPARE(tbnz(x12, 32, INST_OFF(0x8)), "tbnz x12, #32, #+0x8");
   COMPARE(br(x0), "br x0");
   COMPARE(blr(x1), "blr x1");
   COMPARE(ret(x2), "ret x2");
   COMPARE(ret(lr), "ret")
 
   CLEANUP();
 }
 
+
 TEST_(load_store) {
   SET_UP();
 
   COMPARE(ldr(w0, MemOperand(x1)), "ldr w0, [x1]");
   COMPARE(ldr(w2, MemOperand(x3, 4)), "ldr w2, [x3, #4]");
   COMPARE(ldr(w4, MemOperand(x5, 16380)), "ldr w4, [x5, #16380]");
   COMPARE(ldr(x6, MemOperand(x7)), "ldr x6, [x7]");
   COMPARE(ldr(x8, MemOperand(x9, 8)), "ldr x8, [x9, #8]");
   COMPARE(ldr(x10, MemOperand(x11, 32760)), "ldr x10, [x11, #32760]");
   COMPARE(str(w12, MemOperand(x13)), "str w12, [x13]");
@@ skipping 274 matching lines @@
   COMPARE(ldrsb(w4, MemOperand(x5, -3)), "ldursb w4, [x5, #-3]");
   COMPARE(ldrsb(x6, MemOperand(x7, -4)), "ldursb x6, [x7, #-4]");
   COMPARE(ldrh(w8, MemOperand(x9, -5)), "ldurh w8, [x9, #-5]");
   COMPARE(ldrsh(w10, MemOperand(x11, -6)), "ldursh w10, [x11, #-6]");
   COMPARE(ldrsh(x12, MemOperand(x13, -7)), "ldursh x12, [x13, #-7]");
   COMPARE(ldrsw(x14, MemOperand(x15, -8)), "ldursw x14, [x15, #-8]");
 
   CLEANUP();
 }
 
+
 TEST_(load_store_pair) {
   SET_UP();
 
   COMPARE(ldp(w0, w1, MemOperand(x2)), "ldp w0, w1, [x2]");
   COMPARE(ldp(x3, x4, MemOperand(x5)), "ldp x3, x4, [x5]");
   COMPARE(ldp(w6, w7, MemOperand(x8, 4)), "ldp w6, w7, [x8, #4]");
   COMPARE(ldp(x9, x10, MemOperand(x11, 8)), "ldp x9, x10, [x11, #8]");
   COMPARE(ldp(w12, w13, MemOperand(x14, 252)), "ldp w12, w13, [x14, #252]");
   COMPARE(ldp(x15, x16, MemOperand(x17, 504)), "ldp x15, x16, [x17, #504]");
   COMPARE(ldp(w18, w19, MemOperand(x20, -256)), "ldp w18, w19, [x20, #-256]");
@@ skipping 99 matching lines @@
   COMPARE(ldpsw(x0, x1, MemOperand(x2)), "ldpsw x0, x1, [x2]");
   COMPARE(ldpsw(x3, x4, MemOperand(x5, 16)), "ldpsw x3, x4, [x5, #16]");
   COMPARE(ldpsw(x6, x7, MemOperand(x8, -32, PreIndex)),
           "ldpsw x6, x7, [x8, #-32]!");
   COMPARE(ldpsw(x9, x10, MemOperand(x11, 128, PostIndex)),
           "ldpsw x9, x10, [x11], #128");
 
   CLEANUP();
 }
 
+
 TEST_(load_store_pair_nontemp) {
   SET_UP();
 
   COMPARE(ldnp(w0, w1, MemOperand(x2)), "ldnp w0, w1, [x2]");
   COMPARE(stnp(w3, w4, MemOperand(x5, 252)), "stnp w3, w4, [x5, #252]");
   COMPARE(ldnp(w6, w7, MemOperand(x8, -256)), "ldnp w6, w7, [x8, #-256]");
   COMPARE(stnp(x9, x10, MemOperand(x11)), "stnp x9, x10, [x11]");
   COMPARE(ldnp(x12, x13, MemOperand(x14, 504)), "ldnp x12, x13, [x14, #504]");
   COMPARE(stnp(x15, x16, MemOperand(x17, -512)), "stnp x15, x16, [x17, #-512]");
   COMPARE(ldnp(s18, s19, MemOperand(x20)), "ldnp s18, s19, [x20]");
@@ skipping 46 matching lines @@
   COMPARE(csinc(x2, x3, x4, al), "csinc x2, x3, x4, al");
   COMPARE(csinc(x3, x4, x5, nv), "csinc x3, x4, x5, nv");
   COMPARE(csinv(x4, x5, x6, al), "csinv x4, x5, x6, al");
   COMPARE(csinv(x5, x6, x7, nv), "csinv x5, x6, x7, nv");
   COMPARE(csneg(x6, x7, x8, al), "csneg x6, x7, x8, al");
   COMPARE(csneg(x7, x8, x9, nv), "csneg x7, x8, x9, nv");
 
   CLEANUP();
 }
 
+
 TEST(cond_select_macro) {
   SET_UP_CLASS(MacroAssembler);
 
   COMPARE(Csel(w0, w1, -1, eq), "csinv w0, w1, wzr, eq");
   COMPARE(Csel(w2, w3, 0, ne), "csel w2, w3, wzr, ne");
   COMPARE(Csel(w4, w5, 1, hs), "csinc w4, w5, wzr, hs");
   COMPARE(Csel(x6, x7, -1, lo), "csinv x6, x7, xzr, lo");
   COMPARE(Csel(x8, x9, 0, mi), "csel x8, x9, xzr, mi");
   COMPARE(Csel(x10, x11, 1, pl), "csinc x10, x11, xzr, pl");
 
   CLEANUP();
 }
 
+
 TEST_(cond_cmp) {
   SET_UP();
 
   COMPARE(ccmn(w0, w1, NZCVFlag, eq), "ccmn w0, w1, #NZCV, eq");
   COMPARE(ccmn(x2, x3, NZCFlag, ne), "ccmn x2, x3, #NZCv, ne");
   COMPARE(ccmp(w4, w5, NZVFlag, hs), "ccmp w4, w5, #NZcV, hs");
   COMPARE(ccmp(x6, x7, NZFlag, lo), "ccmp x6, x7, #NZcv, lo");
   COMPARE(ccmn(w8, 31, NFlag, mi), "ccmn w8, #31, #Nzcv, mi");
   COMPARE(ccmn(x9, 30, NCFlag, pl), "ccmn x9, #30, #NzCv, pl");
   COMPARE(ccmp(w10, 29, NVFlag, vs), "ccmp w10, #29, #NzcV, vs");
   COMPARE(ccmp(x11, 28, NFlag, vc), "ccmp x11, #28, #Nzcv, vc");
   COMPARE(ccmn(w12, w13, NoFlag, al), "ccmn w12, w13, #nzcv, al");
   COMPARE(ccmp(x14, 27, ZVFlag, nv), "ccmp x14, #27, #nZcV, nv");
 
   CLEANUP();
 }
 
+
 TEST_(cond_cmp_macro) {
   SET_UP_CLASS(MacroAssembler);
 
   COMPARE(Ccmp(w0, -1, VFlag, hi), "ccmn w0, #1, #nzcV, hi");
   COMPARE(Ccmp(x1, -31, CFlag, ge), "ccmn x1, #31, #nzCv, ge");
   COMPARE(Ccmn(w2, -1, CVFlag, gt), "ccmp w2, #1, #nzCV, gt");
   COMPARE(Ccmn(x3, -31, ZCVFlag, ls), "ccmp x3, #31, #nZCV, ls");
 
   CLEANUP();
 }
 
+
 TEST_(fmov_imm) {
   SET_UP();
 
   COMPARE(fmov(s0, 1.0), "fmov s0, #0x70 (1.0000)");
   COMPARE(fmov(s31, -13.0), "fmov s31, #0xaa (-13.0000)");
   COMPARE(fmov(d1, 1.0), "fmov d1, #0x70 (1.0000)");
   COMPARE(fmov(d29, -13.0), "fmov d29, #0xaa (-13.0000)");
 
   CLEANUP();
 }
 
+
 TEST_(fmov_reg) {
   SET_UP();
 
   COMPARE(fmov(w3, s13), "fmov w3, s13");
   COMPARE(fmov(x6, d26), "fmov x6, d26");
   COMPARE(fmov(s11, w30), "fmov s11, w30");
   COMPARE(fmov(d31, x2), "fmov d31, x2");
   COMPARE(fmov(s12, s13), "fmov s12, s13");
   COMPARE(fmov(d22, d23), "fmov d22, d23");
 
@@ skipping 248 matching lines @@
 TEST_(brk) {
   SET_UP();
 
   COMPARE(brk(0), "brk #0x0");
   COMPARE(brk(1), "brk #0x1");
   COMPARE(brk(65535), "brk #0xffff");
 
   CLEANUP();
 }
 
+
 TEST_(add_sub_negative) {
   SET_UP_CLASS(MacroAssembler);
 
   COMPARE(Add(x10, x0, -42), "sub x10, x0, #0x2a (42)");
   COMPARE(Add(x11, x1, -687), "sub x11, x1, #0x2af (687)");
   COMPARE(Add(x12, x2, -0x88), "sub x12, x2, #0x88 (136)");
 
   COMPARE(Sub(x13, x0, -600), "add x13, x0, #0x258 (600)");
   COMPARE(Sub(x14, x1, -313), "add x14, x1, #0x139 (313)");
   COMPARE(Sub(x15, x2, -0x555), "add x15, x2, #0x555 (1365)");
@@ skipping 103 matching lines @@
   COMPARE(Dsb(InnerShareable, BarrierOther), "dsb sy (0b1000)");
   COMPARE(Dsb(NonShareable, BarrierOther), "dsb sy (0b0100)");
   COMPARE(Dsb(OuterShareable, BarrierOther), "dsb sy (0b0000)");
 
   // ISB
   COMPARE(Isb(), "isb");
 
   CLEANUP();
 }