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

src/a64/full-codegen-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 130 matching lines @@
       info->function()->name()->IsUtf8EqualTo(CStrVector(FLAG_stop_at))) {
     __ Debug("stop-at", __LINE__, BREAK);
   }
 #endif
 
   // Classic mode functions and builtins need to replace the receiver with the
   // global proxy when called as functions (without an explicit receiver
   // object).
   if (info->is_classic_mode() && !info->is_native()) {
     Label ok;
-    int receiver_offset = info->scope()->num_parameters() * kXRegSizeInBytes;
+    int receiver_offset = info->scope()->num_parameters() * kXRegSize;
     __ Peek(x10, receiver_offset);
     __ JumpIfNotRoot(x10, Heap::kUndefinedValueRootIndex, &ok);
 
     __ Ldr(x10, GlobalObjectMemOperand());
     __ Ldr(x10, FieldMemOperand(x10, GlobalObject::kGlobalReceiverOffset));
     __ Poke(x10, receiver_offset);
 
     __ Bind(&ok);
   }
 
@@ skipping 256 matching lines @@
       CodeGenerator::RecordPositions(masm_, function()->end_position() - 1);
       __ RecordJSReturn();
       // This code is generated using Assembler methods rather than Macro
       // Assembler methods because it will be patched later on, and so the size
       // of the generated code must be consistent.
       const Register& current_sp = __ StackPointer();
       // Nothing ensures 16 bytes alignment here.
       ASSERT(!current_sp.Is(csp));
       __ mov(current_sp, fp);
       int no_frame_start = masm_->pc_offset();
-      __ ldp(fp, lr, MemOperand(current_sp, 2 * kXRegSizeInBytes, PostIndex));
+      __ ldp(fp, lr, MemOperand(current_sp, 2 * kXRegSize, PostIndex));
       // Drop the arguments and receiver and return.
       // TODO(all): This implementation is overkill as it supports 2**31+1
       // arguments, consider how to improve it without creating a security
       // hole.
       __ LoadLiteral(ip0, 3 * kInstructionSize);
       __ add(current_sp, current_sp, ip0);
       __ ret();
-      __ dc64(kXRegSizeInBytes * (info_->scope()->num_parameters() + 1));
+      __ dc64(kXRegSize * (info_->scope()->num_parameters() + 1));
       info_->AddNoFrameRange(no_frame_start, masm_->pc_offset());
     }
   }
 }
 
 
 void FullCodeGenerator::EffectContext::Plug(Variable* var) const {
   ASSERT(var->IsStackAllocated() || var->IsContextSlot());
 }
 
@@ skipping 238 matching lines @@
     __ B(InvertCondition(cond), if_false);
   } else {
     __ B(cond, if_true);
     __ B(if_false);
   }
 }
 
 
 MemOperand FullCodeGenerator::StackOperand(Variable* var) {
   // Offset is negative because higher indexes are at lower addresses.
-  int offset = -var->index() * kXRegSizeInBytes;
+  int offset = -var->index() * kXRegSize;
   // Adjust by a (parameter or local) base offset.
   if (var->IsParameter()) {
     offset += (info_->scope()->num_parameters() + 1) * kPointerSize;
   } else {
     offset += JavaScriptFrameConstants::kLocal0Offset;
   }
   return MemOperand(fp, offset);
 }
 
 
@@ skipping 471 matching lines @@
 
   // Generate code for doing the condition check.
   PrepareForBailoutForId(stmt->BodyId(), NO_REGISTERS);
   __ Bind(&loop);
   // Load the current count to x0, load the length to x1.
   __ PeekPair(x0, x1, 0);
   __ Cmp(x0, x1);  // Compare to the array length.
   __ B(hs, loop_statement.break_label());
 
   // Get the current entry of the array into register r3.
-  __ Peek(x10, 2 * kXRegSizeInBytes);
+  __ Peek(x10, 2 * kXRegSize);
   __ Add(x10, x10, Operand::UntagSmiAndScale(x0, kPointerSizeLog2));
   __ Ldr(x3, MemOperand(x10, FixedArray::kHeaderSize - kHeapObjectTag));
 
   // Get the expected map from the stack or a smi in the
   // permanent slow case into register x10.
-  __ Peek(x2, 3 * kXRegSizeInBytes);
+  __ Peek(x2, 3 * kXRegSize);
 
   // Check if the expected map still matches that of the enumerable.
   // If not, we may have to filter the key.
   Label update_each;
-  __ Peek(x1, 4 * kXRegSizeInBytes);
+  __ Peek(x1, 4 * kXRegSize);
   __ Ldr(x11, FieldMemOperand(x1, HeapObject::kMapOffset));
   __ Cmp(x11, x2);
   __ B(eq, &update_each);
 
   // For proxies, no filtering is done.
   // TODO(rossberg): What if only a prototype is a proxy? Not specified yet.
   STATIC_ASSERT(kSmiTag == 0);
   __ Cbz(x2, &update_each);
 
   // Convert the entry to a string or (smi) 0 if it isn't a property
@@ skipping 838 matching lines @@
       Label not_minus_zero, done;
       __ Smulh(x10, left, right);
       __ Cbnz(x10, &not_minus_zero);
       __ Eor(x11, left, right);
       __ Tbnz(x11, kXSignBit, &stub_call);
       STATIC_ASSERT(kSmiTag == 0);
       __ Mov(result, x10);
       __ B(&done);
       __ Bind(&not_minus_zero);
       __ Cls(x11, x10);
-      __ Cmp(x11, kXRegSize - kSmiShift);
+      __ Cmp(x11, kXRegSizeInBits - kSmiShift);
       __ B(lt, &stub_call);
       __ SmiTag(result, x10);
       __ Bind(&done);
       break;
     }
     case Token::BIT_OR:
       __ Orr(result, left, right);
       break;
     case Token::BIT_AND:
       __ And(result, left, right);
@@ skipping 339 matching lines @@
     }
   }
   // Record source position for debugger.
   SetSourcePosition(expr->position());
 
   __ LoadObject(x2, FeedbackVector());
   __ Mov(x3, Operand(Smi::FromInt(expr->CallFeedbackSlot())));
 
   // Record call targets in unoptimized code.
   CallFunctionStub stub(arg_count, RECORD_CALL_TARGET);
-  __ Peek(x1, (arg_count + 1) * kXRegSizeInBytes);
+  __ Peek(x1, (arg_count + 1) * kXRegSize);
   __ CallStub(&stub);
   RecordJSReturnSite(expr);
   // Restore context register.
   __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
   context()->DropAndPlug(1, x0);
 }
 
 
 void FullCodeGenerator::EmitResolvePossiblyDirectEval(int arg_count) {
   ASM_LOCATION("FullCodeGenerator::EmitResolvePossiblyDirectEval");
   // Prepare to push a copy of the first argument or undefined if it doesn't
   // exist.
   if (arg_count > 0) {
-    __ Peek(x10, arg_count * kXRegSizeInBytes);
+    __ Peek(x10, arg_count * kXRegSize);
   } else {
     __ LoadRoot(x10, Heap::kUndefinedValueRootIndex);
   }
 
   // Prepare to push the receiver of the enclosing function.
   int receiver_offset = 2 + info_->scope()->num_parameters();
   __ Ldr(x11, MemOperand(fp, receiver_offset * kPointerSize));
 
   // Push.
   __ Push(x10, x11);
@@ skipping 50 matching lines @@
       // The runtime call returns a pair of values in x0 (function) and
       // x1 (receiver). Touch up the stack with the right values.
       __ PokePair(x1, x0, arg_count * kPointerSize);
     }
 
     // Record source position for debugger.
     SetSourcePosition(expr->position());
 
     // Call the evaluated function.
     CallFunctionStub stub(arg_count, NO_CALL_FUNCTION_FLAGS);
-    __ Peek(x1, (arg_count + 1) * kXRegSizeInBytes);
+    __ Peek(x1, (arg_count + 1) * kXRegSize);
     __ CallStub(&stub);
     RecordJSReturnSite(expr);
     // Restore context register.
     __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
     context()->DropAndPlug(1, x0);
 
   } else if (call_type == Call::GLOBAL_CALL) {
     EmitCallWithIC(expr);
 
   } else if (call_type == Call::LOOKUP_SLOT_CALL) {
@@ skipping 82 matching lines @@
   for (int i = 0; i < arg_count; i++) {
     VisitForStackValue(args->at(i));
   }
 
   // Call the construct call builtin that handles allocation and
   // constructor invocation.
   SetSourcePosition(expr->position());
 
   // Load function and argument count into x1 and x0.
   __ Mov(x0, arg_count);
-  __ Peek(x1, arg_count * kXRegSizeInBytes);
+  __ Peek(x1, arg_count * kXRegSize);
 
   // Record call targets in unoptimized code.
   __ LoadObject(x2, FeedbackVector());
   __ Mov(x3, Operand(Smi::FromInt(expr->CallNewFeedbackSlot())));
 
   CallConstructStub stub(RECORD_CALL_TARGET);
   __ Call(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL);
   PrepareForBailoutForId(expr->ReturnId(), TOS_REG);
   context()->Plug(x0);
 }
@@ skipping 1463 matching lines @@
   if (expr->is_postfix()) {
     if (!context()->IsEffect()) {
       // Save the result on the stack. If we have a named or keyed property
       // we store the result under the receiver that is currently on top
       // of the stack.
       switch (assign_type) {
         case VARIABLE:
           __ Push(x0);
           break;
         case NAMED_PROPERTY:
-          __ Poke(x0, kXRegSizeInBytes);
+          __ Poke(x0, kXRegSize);
           break;
         case KEYED_PROPERTY:
-          __ Poke(x0, 2 * kXRegSizeInBytes);
+          __ Poke(x0, 2 * kXRegSize);
           break;
       }
     }
   }
 
   __ Bind(&stub_call);
   __ Mov(x1, x0);
   __ Mov(x0, Operand(Smi::FromInt(count_value)));
 
   // Record position before stub call.
@@ skipping 867 matching lines @@
   return previous_;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64