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

runtime/vm/assembler_ia32.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_IA32)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/heap.h"
@@ skipping 56 matching lines @@
 #ifdef DEBUG
   initialized_ = true;
 #endif
 }
 
 #undef __
 
 
 class DirectCallRelocation : public AssemblerFixup {
  public:
-  void Process(const MemoryRegion& region, int position) {
+  void Process(const MemoryRegion& region, intptr_t position) {
     // Direct calls are relative to the following instruction on x86.
     int32_t pointer = region.Load<int32_t>(position);
     int32_t delta = region.start() + position + sizeof(int32_t);
     region.Store<int32_t>(position, pointer - delta);
   }
 };
 
 
-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_);
   EmitUint8(0xFF);
   EmitRegisterOperand(2, reg);
 }
 
@@ skipping 1694 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 21 matching lines @@
   EmitUint8(0xFF);
   EmitRegisterOperand(4, reg);
 }
 
 
 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 45 matching lines @@
   }
 }
 
 
 void Assembler::PopRegister(Register r) {
   popl(r);
 }
 
 
 void Assembler::AddImmediate(Register reg, const Immediate& imm) {
-  int value = imm.value();
+  intptr_t value = imm.value();
   if (value > 0) {
     if (value == 1) {
       incl(reg);
     } else if (value != 0) {
       addl(reg, imm);
     }
   } else if (value < 0) {
     value = -value;
     if (value == 1) {
       decl(reg);
@@ skipping 287 matching lines @@
   leave();
 }
 
 
 void Assembler::CallRuntime(const RuntimeEntry& entry,
                             intptr_t argument_count) {
   entry.Call(this, argument_count);
 }
 
 
-void Assembler::Align(int alignment, int offset) {
+void Assembler::Align(intptr_t alignment, intptr_t offset) {
   ASSERT(Utils::IsPowerOfTwo(alignment));
-  int pos = offset + buffer_.GetPosition();
-  int mod = pos & (alignment - 1);
+  intptr_t pos = offset + buffer_.GetPosition();
+  intptr_t 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::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::TryAllocate(const Class& cls,
                             Label* failure,
                             bool near_jump,
@@ skipping 81 matching lines @@
     // Emit the message address as immediate operand in the test instruction.
     testl(EAX, Immediate(reinterpret_cast<int32_t>(message)));
   }
   // Emit the int3 instruction.
   int3();  // Execution can be resumed with the 'cont' command in gdb.
 }
 
 
 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::EmitImmediate(const Immediate& imm) {
   EmitInt32(imm.value());
 }
 
 
@@ skipping 11 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(int rm,
                                  Register reg,
                                  const Immediate& imm) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   ASSERT(imm.is_int8());
@@ skipping 77 matching lines @@
 
 const char* Assembler::FpuRegisterName(FpuRegister reg) {
   ASSERT((0 <= reg) && (reg < kNumberOfXmmRegisters));
   return xmm_reg_names[reg];
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32