Cleanups: int -> intptr_t for "array" lengths, memory sizes.

runtime/vm/assembler_x64.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/assembler.h"
 #include "vm/heap.h"
 #include "vm/memory_region.h"
@@ skipping 90 matching lines @@
     if (StubCode::CallToRuntime_entry() != NULL) {
       FindExternalLabel(&StubCode::CallToRuntimeLabel(), kNotPatchable);
     } else {
       object_pool_.Add(Object::null_object(), Heap::kOld);
       patchable_pool_entries_.Add(kNotPatchable);
     }
   }
 }
 
 
-void Assembler::InitializeMemoryWithBreakpoints(uword data, int length) {
+void Assembler::InitializeMemoryWithBreakpoints(uword data, intptr_t length) {
   memset(reinterpret_cast<void*>(data), Instr::kBreakPointInstruction, length);
 }
 
 
 void Assembler::call(Register reg) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   Operand operand(reg);
   EmitOperandREX(2, operand, REX_NONE);
   EmitUint8(0xFF);
   EmitOperand(2, operand);
@@ skipping 1970 matching lines @@
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xF4);
 }
 
 
 void Assembler::j(Condition condition, Label* label, bool near) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   if (label->IsBound()) {
     static const int kShortSize = 2;
     static const int kLongSize = 6;
-    int offset = label->Position() - buffer_.Size();
+    intptr_t offset = label->Position() - buffer_.Size();
     ASSERT(offset <= 0);
     if (Utils::IsInt(8, offset - kShortSize)) {
       EmitUint8(0x70 + condition);
       EmitUint8((offset - kShortSize) & 0xFF);
     } else {
       EmitUint8(0x0F);
       EmitUint8(0x80 + condition);
       EmitInt32(offset - kLongSize);
     }
   } else if (near) {
@@ skipping 31 matching lines @@
   EmitUint8(0xFF);
   EmitOperand(4, operand);
 }
 
 
 void Assembler::jmp(Label* label, bool near) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   if (label->IsBound()) {
     static const int kShortSize = 2;
     static const int kLongSize = 5;
-    int offset = label->Position() - buffer_.Size();
+    intptr_t offset = label->Position() - buffer_.Size();
     ASSERT(offset <= 0);
     if (Utils::IsInt(8, offset - kShortSize)) {
       EmitUint8(0xEB);
       EmitUint8((offset - kShortSize) & 0xFF);
     } else {
       EmitUint8(0xE9);
       EmitInt32(offset - kLongSize);
     }
   } else if (near) {
     EmitUint8(0xEB);
@@ skipping 447 matching lines @@
     // immediate operands in the test rax instructions.
     testl(RAX, Immediate(Utils::Low32Bits(message_address)));
     testl(RAX, Immediate(Utils::High32Bits(message_address)));
   }
   // Emit the int3 instruction.
   int3();  // Execution can be resumed with the 'cont' command in gdb.
 }
 
 
 void Assembler::Bind(Label* label) {
-  int bound = buffer_.Size();
+  intptr_t bound = buffer_.Size();
   ASSERT(!label->IsBound());  // Labels can only be bound once.
   while (label->IsLinked()) {
-    int position = label->LinkPosition();
-    int next = buffer_.Load<int32_t>(position);
+    intptr_t position = label->LinkPosition();
+    intptr_t next = buffer_.Load<int32_t>(position);
     buffer_.Store<int32_t>(position, bound - (position + 4));
     label->position_ = next;
   }
   while (label->HasNear()) {
-    int position = label->NearPosition();
-    int offset = bound - (position + 1);
+    intptr_t position = label->NearPosition();
+    intptr_t offset = bound - (position + 1);
     ASSERT(Utils::IsInt(8, offset));
     buffer_.Store<int8_t>(position, offset);
   }
   label->BindTo(bound);
 }
 
 
 void Assembler::EnterFrame(intptr_t frame_size) {
   if (prologue_offset_ == -1) {
     prologue_offset_ = CodeSize();
@@ skipping 249 matching lines @@
     ASSERT(cls.id() != kIllegalCid);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
     LoadImmediate(FieldAddress(instance_reg, Object::tags_offset()),
                   Immediate(tags), pp);
   } else {
     jmp(failure);
   }
 }
 
 
-void Assembler::Align(int alignment, int offset) {
+void Assembler::Align(int alignment, intptr_t offset) {
   ASSERT(Utils::IsPowerOfTwo(alignment));
-  int pos = offset + buffer_.GetPosition();
+  intptr_t pos = offset + buffer_.GetPosition();
   int mod = pos & (alignment - 1);
   if (mod == 0) {
     return;
   }
-  int bytes_needed = alignment - mod;
+  intptr_t bytes_needed = alignment - mod;
   while (bytes_needed > MAX_NOP_SIZE) {
     nop(MAX_NOP_SIZE);
     bytes_needed -= MAX_NOP_SIZE;
   }
   if (bytes_needed) {
     nop(bytes_needed);
   }
   ASSERT(((offset + buffer_.GetPosition()) & (alignment-1)) == 0);
 }
 
 
 void Assembler::EmitOperand(int rm, const Operand& operand) {
   ASSERT(rm >= 0 && rm < 8);
-  const int length = operand.length_;
+  const intptr_t length = operand.length_;
   ASSERT(length > 0);
   // Emit the ModRM byte updated with the given RM value.
   ASSERT((operand.encoding_[0] & 0x38) == 0);
   EmitUint8(operand.encoding_[0] + (rm << 3));
   // Emit the rest of the encoded operand.
-  for (int i = 1; i < length; i++) {
+  for (intptr_t i = 1; i < length; i++) {
     EmitUint8(operand.encoding_[i]);
   }
 }
 
 
 void Assembler::EmitXmmRegisterOperand(int rm, XmmRegister xmm_reg) {
   Operand operand;
   operand.SetModRM(3, static_cast<Register>(xmm_reg));
   EmitOperand(rm, operand);
 }
@@ skipping 23 matching lines @@
     EmitUint8(0x05 + (rm << 3));
     EmitImmediate(immediate);
   } else {
     EmitUint8(0x81);
     EmitOperand(rm, operand);
     EmitImmediate(immediate);
   }
 }
 
 
-void Assembler::EmitLabel(Label* label, int instruction_size) {
+void Assembler::EmitLabel(Label* label, intptr_t instruction_size) {
   if (label->IsBound()) {
-    int offset = label->Position() - buffer_.Size();
+    intptr_t offset = label->Position() - buffer_.Size();
     ASSERT(offset <= 0);
     EmitInt32(offset - instruction_size);
   } else {
     EmitLabelLink(label);
   }
 }
 
 
 void Assembler::EmitLabelLink(Label* label) {
   ASSERT(!label->IsBound());
-  int position = buffer_.Size();
+  intptr_t position = buffer_.Size();
   EmitInt32(label->position_);
   label->LinkTo(position);
 }
 
 
 void Assembler::EmitNearLabelLink(Label* label) {
   ASSERT(!label->IsBound());
-  int position = buffer_.Size();
+  intptr_t position = buffer_.Size();
   EmitUint8(0);
   label->NearLinkTo(position);
 }
 
 
 void Assembler::EmitGenericShift(bool wide,
                                  int rm,
                                  Register reg,
                                  const Immediate& imm) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
@@ skipping 80 matching lines @@
 
 
 const char* Assembler::FpuRegisterName(FpuRegister reg) {
   ASSERT((0 <= reg) && (reg < kNumberOfXmmRegisters));
   return xmm_reg_names[reg];
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64