A64: Rename k<Y>RegSize to k<Y>RegSizeInBits, and k<Y>RegSizeInBytes to k<Y>RegSize.

test/cctest/test-assembler-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 7132 matching lines @@
   __ Mov(x0, reinterpret_cast<int64_t>(results_scvtf_x));
   __ Mov(x1, reinterpret_cast<int64_t>(results_ucvtf_x));
   __ Mov(x2, reinterpret_cast<int64_t>(results_scvtf_w));
   __ Mov(x3, reinterpret_cast<int64_t>(results_ucvtf_w));
 
   __ Mov(x10, s64);
 
   // Corrupt the top word, in case it is accidentally used during W-register
   // conversions.
   __ Mov(x11, 0x5555555555555555);
-  __ Bfi(x11, x10, 0, kWRegSize);
+  __ Bfi(x11, x10, 0, kWRegSizeInBits);
 
   // Test integer conversions.
   __ Scvtf(d0, x10);
   __ Ucvtf(d1, x10);
   __ Scvtf(d2, w11);
   __ Ucvtf(d3, w11);
   __ Str(d0, MemOperand(x0));
   __ Str(d1, MemOperand(x1));
   __ Str(d2, MemOperand(x2));
   __ Str(d3, MemOperand(x3));
 
   // Test all possible values of fbits.
   for (int fbits = 1; fbits <= 32; fbits++) {
     __ Scvtf(d0, x10, fbits);
     __ Ucvtf(d1, x10, fbits);
     __ Scvtf(d2, w11, fbits);
     __ Ucvtf(d3, w11, fbits);
-    __ Str(d0, MemOperand(x0, fbits * kDRegSizeInBytes));
-    __ Str(d1, MemOperand(x1, fbits * kDRegSizeInBytes));
-    __ Str(d2, MemOperand(x2, fbits * kDRegSizeInBytes));
-    __ Str(d3, MemOperand(x3, fbits * kDRegSizeInBytes));
+    __ Str(d0, MemOperand(x0, fbits * kDRegSize));
+    __ Str(d1, MemOperand(x1, fbits * kDRegSize));
+    __ Str(d2, MemOperand(x2, fbits * kDRegSize));
+    __ Str(d3, MemOperand(x3, fbits * kDRegSize));
   }
 
   // Conversions from W registers can only handle fbits values <= 32, so just
   // test conversions from X registers for 32 < fbits <= 64.
   for (int fbits = 33; fbits <= 64; fbits++) {
     __ Scvtf(d0, x10, fbits);
     __ Ucvtf(d1, x10, fbits);
-    __ Str(d0, MemOperand(x0, fbits * kDRegSizeInBytes));
-    __ Str(d1, MemOperand(x1, fbits * kDRegSizeInBytes));
+    __ Str(d0, MemOperand(x0, fbits * kDRegSize));
+    __ Str(d1, MemOperand(x1, fbits * kDRegSize));
   }
 
   END();
   RUN();
 
   // Check the results.
   double expected_scvtf_base = rawbits_to_double(expected_scvtf_bits);
   double expected_ucvtf_base = rawbits_to_double(expected_ucvtf_bits);
 
   for (int fbits = 0; fbits <= 32; fbits++) {
@@ skipping 104 matching lines @@
   __ Mov(x0, reinterpret_cast<int64_t>(results_scvtf_x));
   __ Mov(x1, reinterpret_cast<int64_t>(results_ucvtf_x));
   __ Mov(x2, reinterpret_cast<int64_t>(results_scvtf_w));
   __ Mov(x3, reinterpret_cast<int64_t>(results_ucvtf_w));
 
   __ Mov(x10, s64);
 
   // Corrupt the top word, in case it is accidentally used during W-register
   // conversions.
   __ Mov(x11, 0x5555555555555555);
-  __ Bfi(x11, x10, 0, kWRegSize);
+  __ Bfi(x11, x10, 0, kWRegSizeInBits);
 
   // Test integer conversions.
   __ Scvtf(s0, x10);
   __ Ucvtf(s1, x10);
   __ Scvtf(s2, w11);
   __ Ucvtf(s3, w11);
   __ Str(s0, MemOperand(x0));
   __ Str(s1, MemOperand(x1));
   __ Str(s2, MemOperand(x2));
   __ Str(s3, MemOperand(x3));
 
   // Test all possible values of fbits.
   for (int fbits = 1; fbits <= 32; fbits++) {
     __ Scvtf(s0, x10, fbits);
     __ Ucvtf(s1, x10, fbits);
     __ Scvtf(s2, w11, fbits);
     __ Ucvtf(s3, w11, fbits);
-    __ Str(s0, MemOperand(x0, fbits * kSRegSizeInBytes));
-    __ Str(s1, MemOperand(x1, fbits * kSRegSizeInBytes));
-    __ Str(s2, MemOperand(x2, fbits * kSRegSizeInBytes));
-    __ Str(s3, MemOperand(x3, fbits * kSRegSizeInBytes));
+    __ Str(s0, MemOperand(x0, fbits * kSRegSize));
+    __ Str(s1, MemOperand(x1, fbits * kSRegSize));
+    __ Str(s2, MemOperand(x2, fbits * kSRegSize));
+    __ Str(s3, MemOperand(x3, fbits * kSRegSize));
   }
 
   // Conversions from W registers can only handle fbits values <= 32, so just
   // test conversions from X registers for 32 < fbits <= 64.
   for (int fbits = 33; fbits <= 64; fbits++) {
     __ Scvtf(s0, x10, fbits);
     __ Ucvtf(s1, x10, fbits);
-    __ Str(s0, MemOperand(x0, fbits * kSRegSizeInBytes));
-    __ Str(s1, MemOperand(x1, fbits * kSRegSizeInBytes));
+    __ Str(s0, MemOperand(x0, fbits * kSRegSize));
+    __ Str(s1, MemOperand(x1, fbits * kSRegSize));
   }
 
   END();
   RUN();
 
   // Check the results.
   float expected_scvtf_base = rawbits_to_float(expected_scvtf_bits);
   float expected_ucvtf_base = rawbits_to_float(expected_ucvtf_bits);
 
   for (int fbits = 0; fbits <= 32; fbits++) {
@@ skipping 625 matching lines @@
   //    x6 should match x1[31:0]:x0[63:32]
   //    w7 should match x1[15:0]:x0[63:48]
   __ Poke(x1, 8);
   __ Poke(x0, 0);
   {
     ASSERT(__ StackPointer().Is(csp));
     __ Mov(x4, __ StackPointer());
     __ SetStackPointer(x4);
 
     __ Poke(wzr, 0);    // Clobber the space we're about to drop.
-    __ Drop(1, kWRegSizeInBytes);
+    __ Drop(1, kWRegSize);
     __ Peek(x6, 0);
     __ Claim(1);
     __ Peek(w7, 10);
     __ Poke(x3, 28);
     __ Poke(xzr, 0);    // Clobber the space we're about to drop.
     __ Drop(1);
     __ Poke(x2, 12);
     __ Push(w0);
 
     __ Mov(csp, __ StackPointer());
@@ skipping 161 matching lines @@
   }
 
   TEARDOWN();
 }
 
 
 TEST(push_pop_jssp_simple_32) {
   INIT_V8();
   for (int claim = 0; claim <= 8; claim++) {
     for (int count = 0; count <= 8; count++) {
-      PushPopJsspSimpleHelper(count, claim, kWRegSize,
+      PushPopJsspSimpleHelper(count, claim, kWRegSizeInBits,
                               PushPopByFour, PushPopByFour);
-      PushPopJsspSimpleHelper(count, claim, kWRegSize,
+      PushPopJsspSimpleHelper(count, claim, kWRegSizeInBits,
                               PushPopByFour, PushPopRegList);
-      PushPopJsspSimpleHelper(count, claim, kWRegSize,
+      PushPopJsspSimpleHelper(count, claim, kWRegSizeInBits,
                               PushPopRegList, PushPopByFour);
-      PushPopJsspSimpleHelper(count, claim, kWRegSize,
+      PushPopJsspSimpleHelper(count, claim, kWRegSizeInBits,
                               PushPopRegList, PushPopRegList);
     }
     // Test with the maximum number of registers.
-    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSize,
+    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSizeInBits,
                             PushPopByFour, PushPopByFour);
-    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSize,
+    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSizeInBits,
                             PushPopByFour, PushPopRegList);
-    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSize,
+    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSizeInBits,
                             PushPopRegList, PushPopByFour);
-    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSize,
+    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kWRegSizeInBits,
                             PushPopRegList, PushPopRegList);
   }
 }
 
 
 TEST(push_pop_jssp_simple_64) {
   INIT_V8();
   for (int claim = 0; claim <= 8; claim++) {
     for (int count = 0; count <= 8; count++) {
-      PushPopJsspSimpleHelper(count, claim, kXRegSize,
+      PushPopJsspSimpleHelper(count, claim, kXRegSizeInBits,
                               PushPopByFour, PushPopByFour);
-      PushPopJsspSimpleHelper(count, claim, kXRegSize,
+      PushPopJsspSimpleHelper(count, claim, kXRegSizeInBits,
                               PushPopByFour, PushPopRegList);
-      PushPopJsspSimpleHelper(count, claim, kXRegSize,
+      PushPopJsspSimpleHelper(count, claim, kXRegSizeInBits,
                               PushPopRegList, PushPopByFour);
-      PushPopJsspSimpleHelper(count, claim, kXRegSize,
+      PushPopJsspSimpleHelper(count, claim, kXRegSizeInBits,
                               PushPopRegList, PushPopRegList);
     }
     // Test with the maximum number of registers.
-    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kXRegSize,
+    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kXRegSizeInBits,
                             PushPopByFour, PushPopByFour);
-    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kXRegSize,
+    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kXRegSizeInBits,
                             PushPopByFour, PushPopRegList);
-    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kXRegSize,
+    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kXRegSizeInBits,
                             PushPopRegList, PushPopByFour);
-    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kXRegSize,
+    PushPopJsspSimpleHelper(kPushPopJsspMaxRegCount, claim, kXRegSizeInBits,
                             PushPopRegList, PushPopRegList);
   }
 }
 
 
 // The maximum number of registers that can be used by the PushPopFPJssp* tests,
 // where a reg_count field is provided.
 static int const kPushPopFPJsspMaxRegCount = -1;
 
 // Test a simple push-pop pattern:
@@ skipping 120 matching lines @@
   }
 
   TEARDOWN();
 }
 
 
 TEST(push_pop_fp_jssp_simple_32) {
   INIT_V8();
   for (int claim = 0; claim <= 8; claim++) {
     for (int count = 0; count <= 8; count++) {
-      PushPopFPJsspSimpleHelper(count, claim, kSRegSize,
+      PushPopFPJsspSimpleHelper(count, claim, kSRegSizeInBits,
                                 PushPopByFour, PushPopByFour);
-      PushPopFPJsspSimpleHelper(count, claim, kSRegSize,
+      PushPopFPJsspSimpleHelper(count, claim, kSRegSizeInBits,
                                 PushPopByFour, PushPopRegList);
-      PushPopFPJsspSimpleHelper(count, claim, kSRegSize,
+      PushPopFPJsspSimpleHelper(count, claim, kSRegSizeInBits,
                                 PushPopRegList, PushPopByFour);
-      PushPopFPJsspSimpleHelper(count, claim, kSRegSize,
+      PushPopFPJsspSimpleHelper(count, claim, kSRegSizeInBits,
                                 PushPopRegList, PushPopRegList);
     }
     // Test with the maximum number of registers.
-    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSize,
+    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSizeInBits,
                               PushPopByFour, PushPopByFour);
-    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSize,
+    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSizeInBits,
                               PushPopByFour, PushPopRegList);
-    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSize,
+    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSizeInBits,
                               PushPopRegList, PushPopByFour);
-    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSize,
+    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kSRegSizeInBits,
                               PushPopRegList, PushPopRegList);
   }
 }
 
 
 TEST(push_pop_fp_jssp_simple_64) {
   INIT_V8();
   for (int claim = 0; claim <= 8; claim++) {
     for (int count = 0; count <= 8; count++) {
-      PushPopFPJsspSimpleHelper(count, claim, kDRegSize,
+      PushPopFPJsspSimpleHelper(count, claim, kDRegSizeInBits,
                                 PushPopByFour, PushPopByFour);
-      PushPopFPJsspSimpleHelper(count, claim, kDRegSize,
+      PushPopFPJsspSimpleHelper(count, claim, kDRegSizeInBits,
                                 PushPopByFour, PushPopRegList);
-      PushPopFPJsspSimpleHelper(count, claim, kDRegSize,
+      PushPopFPJsspSimpleHelper(count, claim, kDRegSizeInBits,
                                 PushPopRegList, PushPopByFour);
-      PushPopFPJsspSimpleHelper(count, claim, kDRegSize,
+      PushPopFPJsspSimpleHelper(count, claim, kDRegSizeInBits,
                                 PushPopRegList, PushPopRegList);
     }
     // Test with the maximum number of registers.
-    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSize,
+    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSizeInBits,
                               PushPopByFour, PushPopByFour);
-    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSize,
+    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSizeInBits,
                               PushPopByFour, PushPopRegList);
-    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSize,
+    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSizeInBits,
                               PushPopRegList, PushPopByFour);
-    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSize,
+    PushPopFPJsspSimpleHelper(kPushPopFPJsspMaxRegCount, claim, kDRegSizeInBits,
                               PushPopRegList, PushPopRegList);
   }
 }
 
 
 // Push and pop data using an overlapping combination of Push/Pop and
 // RegList-based methods.
 static void PushPopJsspMixedMethodsHelper(int claim, int reg_size) {
   SETUP();
 
@@ skipping 77 matching lines @@
   ASSERT_EQUAL_64(literal_base * 1, x[5]);
   ASSERT_EQUAL_64(literal_base * 2, x[4]);
 
   TEARDOWN();
 }
 
 
 TEST(push_pop_jssp_mixed_methods_64) {
   INIT_V8();
   for (int claim = 0; claim <= 8; claim++) {
-    PushPopJsspMixedMethodsHelper(claim, kXRegSize);
+    PushPopJsspMixedMethodsHelper(claim, kXRegSizeInBits);
   }
 }
 
 
 TEST(push_pop_jssp_mixed_methods_32) {
   INIT_V8();
   for (int claim = 0; claim <= 8; claim++) {
-    PushPopJsspMixedMethodsHelper(claim, kWRegSize);
+    PushPopJsspMixedMethodsHelper(claim, kWRegSizeInBits);
   }
 }
 
 
 // Push and pop data using overlapping X- and W-sized quantities.
 static void PushPopJsspWXOverlapHelper(int reg_count, int claim) {
   // This test emits rather a lot of code.
   SETUP_SIZE(BUF_SIZE * 2);
 
   // Work out which registers to use, based on reg_size.
@@ skipping 118 matching lines @@
           } else {
             stack[active_w_slots++] = literal_base_hi * i;
             stack[active_w_slots++] = literal_base_lo * i;
           }
         }
       }
     }
     // Because we were pushing several registers at a time, we probably pushed
     // more than we needed to.
     if (active_w_slots > requested_w_slots) {
-      __ Drop(active_w_slots - requested_w_slots, kWRegSizeInBytes);
+      __ Drop(active_w_slots - requested_w_slots, kWRegSize);
       // Bump the number of active W-sized slots back to where it should be,
       // and fill the empty space with a dummy value.
       do {
         stack[active_w_slots--] = 0xdeadbeef;
       } while (active_w_slots > requested_w_slots);
     }
 
     // ---- Pop ----
 
     Clobber(&masm, list);
@@ skipping 194 matching lines @@
   __ Mov(w4, 0x12340004);
   __ Mov(w5, 0x12340005);
   __ Mov(w6, 0x12340006);
   __ Fmov(d0, 123400.0);
   __ Fmov(d1, 123401.0);
   __ Fmov(s2, 123402.0);
 
   // Actually push them.
   queue.PushQueued();
 
-  Clobber(&masm, CPURegList(CPURegister::kRegister, kXRegSize, 0, 6));
-  Clobber(&masm, CPURegList(CPURegister::kFPRegister, kDRegSize, 0, 2));
+  Clobber(&masm, CPURegList(CPURegister::kRegister, kXRegSizeInBits, 0, 6));
+  Clobber(&masm, CPURegList(CPURegister::kFPRegister, kDRegSizeInBits, 0, 2));
 
   // Pop them conventionally.
   __ Pop(s2);
   __ Pop(d1, d0);
   __ Pop(w6, w5, w4);
   __ Pop(x3, x2, x1, x0);
 
   __ Mov(csp, __ StackPointer());
   __ SetStackPointer(csp);
 
@@ skipping 56 matching lines @@
 
   queue.Queue(w6);
   queue.Queue(w5);
   queue.Queue(w4);
 
   queue.Queue(x3);
   queue.Queue(x2);
   queue.Queue(x1);
   queue.Queue(x0);
 
-  Clobber(&masm, CPURegList(CPURegister::kRegister, kXRegSize, 0, 6));
-  Clobber(&masm, CPURegList(CPURegister::kFPRegister, kDRegSize, 0, 2));
+  Clobber(&masm, CPURegList(CPURegister::kRegister, kXRegSizeInBits, 0, 6));
+  Clobber(&masm, CPURegList(CPURegister::kFPRegister, kDRegSizeInBits, 0, 2));
 
   // Actually pop them.
   queue.PopQueued();
 
   __ Mov(csp, __ StackPointer());
   __ SetStackPointer(csp);
 
   END();
 
   RUN();
@@ skipping 471 matching lines @@
 }
 
 
 TEST(cpureglist_utils_empty) {
   // This test doesn't generate any code, but it verifies the behaviour of
   // the CPURegList utility methods.
 
   // Test an empty list.
   // Empty lists can have type and size properties. Check that we can create
   // them, and that they are empty.
-  CPURegList reg32(CPURegister::kRegister, kWRegSize, 0);
-  CPURegList reg64(CPURegister::kRegister, kXRegSize, 0);
-  CPURegList fpreg32(CPURegister::kFPRegister, kSRegSize, 0);
-  CPURegList fpreg64(CPURegister::kFPRegister, kDRegSize, 0);
+  CPURegList reg32(CPURegister::kRegister, kWRegSizeInBits, 0);
+  CPURegList reg64(CPURegister::kRegister, kXRegSizeInBits, 0);
+  CPURegList fpreg32(CPURegister::kFPRegister, kSRegSizeInBits, 0);
+  CPURegList fpreg64(CPURegister::kFPRegister, kDRegSizeInBits, 0);
 
   CHECK(reg32.IsEmpty());
   CHECK(reg64.IsEmpty());
   CHECK(fpreg32.IsEmpty());
   CHECK(fpreg64.IsEmpty());
 
   CHECK(reg32.PopLowestIndex().IsNone());
   CHECK(reg64.PopLowestIndex().IsNone());
   CHECK(fpreg32.PopLowestIndex().IsNone());
   CHECK(fpreg64.PopLowestIndex().IsNone());
@@ skipping 587 matching lines @@
   AbsHelperX(-42);
   AbsHelperX(kXMinInt);
   AbsHelperX(kXMaxInt);
 
   AbsHelperW(0);
   AbsHelperW(42);
   AbsHelperW(-42);
   AbsHelperW(kWMinInt);
   AbsHelperW(kWMaxInt);
 }