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

runtime/vm/assembler_ia32.h

 // 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.
 
 #ifndef VM_ASSEMBLER_IA32_H_
 #define VM_ASSEMBLER_IA32_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_ia32.h directly; use assembler.h instead.
 #endif
@@ skipping 94 matching lines @@
     length_ = 2;
   }
 
   void SetDisp8(int8_t disp) {
     ASSERT(length_ == 1 || length_ == 2);
     encoding_[length_++] = static_cast<uint8_t>(disp);
   }
 
   void SetDisp32(int32_t disp) {
     ASSERT(length_ == 1 || length_ == 2);
-    int disp_size = sizeof(disp);
+    intptr_t disp_size = sizeof(disp);
     memmove(&encoding_[length_], &disp, disp_size);
     length_ += disp_size;
   }
 
  private:
   uint8_t length_;
   uint8_t encoding_[6];
   uint8_t padding_;
 
   explicit Operand(Register reg) { SetModRM(3, reg); }
 
   // Get the operand encoding byte at the given index.
-  uint8_t encoding_at(int index) const {
+  uint8_t encoding_at(intptr_t index) const {
     ASSERT(index >= 0 && index < length_);
     return encoding_[index];
   }
 
   // Returns whether or not this operand is really the given register in
   // disguise. Used from the assembler to generate better encodings.
   bool IsRegister(Register reg) const {
     return ((encoding_[0] & 0xF8) == 0xC0)  // Addressing mode is register only.
         && ((encoding_[0] & 0x07) == reg);  // Register codes match.
   }
@@ skipping 89 matching lines @@
   }
 
   ~Label() {
     // Assert if label is being destroyed with unresolved branches pending.
     ASSERT(!IsLinked());
     ASSERT(!HasNear());
   }
 
   // Returns the position for bound labels. Cannot be used for unused or linked
   // labels.
-  int Position() const {
+  intptr_t Position() const {
     ASSERT(IsBound());
     return -position_ - kWordSize;
   }
 
-  int LinkPosition() const {
+  intptr_t LinkPosition() const {
     ASSERT(IsLinked());
     return position_ - kWordSize;
   }
 
-  int NearPosition() {
+  intptr_t NearPosition() {
     ASSERT(HasNear());
     return unresolved_near_positions_[--unresolved_];
   }
 
   bool IsBound() const { return position_ < 0; }
   bool IsUnused() const { return (position_ == 0) && (unresolved_ == 0); }
   bool IsLinked() const { return position_ > 0; }
   bool HasNear() const { return unresolved_ != 0; }
 
  private:
-  void BindTo(int position) {
+  void BindTo(intptr_t position) {
     ASSERT(!IsBound());
     ASSERT(!HasNear());
     position_ = -position - kWordSize;
     ASSERT(IsBound());
   }
 
-  void LinkTo(int position) {
+  void LinkTo(intptr_t position) {
     ASSERT(!IsBound());
     position_ = position + kWordSize;
     ASSERT(IsLinked());
   }
 
-  void NearLinkTo(int position) {
+  void NearLinkTo(intptr_t position) {
     ASSERT(!IsBound());
     ASSERT(unresolved_ < kMaxUnresolvedBranches);
     unresolved_near_positions_[unresolved_++] = position;
   }
 
   static const int kMaxUnresolvedBranches = 20;
 
-  int position_;
-  int unresolved_;
-  int unresolved_near_positions_[kMaxUnresolvedBranches];
+  intptr_t position_;
+  intptr_t unresolved_;
+  intptr_t unresolved_near_positions_[kMaxUnresolvedBranches];
 
   friend class Assembler;
   DISALLOW_COPY_AND_ASSIGN(Label);
 };
 
 
 class CPUFeatures : public AllStatic {
  public:
   static void InitOnce();
   static bool sse2_supported();
@@ skipping 396 matching lines @@
    * Misc. functionality
    */
   void SmiTag(Register reg) {
     addl(reg, reg);
   }
 
   void SmiUntag(Register reg) {
     sarl(reg, Immediate(kSmiTagSize));
   }
 
-  int PreferredLoopAlignment() { return 16; }
-  void Align(int alignment, int offset);
+  intptr_t PreferredLoopAlignment() { return 16; }
+  void Align(intptr_t alignment, intptr_t offset);
   void Bind(Label* label);
 
-  int CodeSize() const { return buffer_.Size(); }
-  int prologue_offset() const { return prologue_offset_; }
-  const ZoneGrowableArray<int>& GetPointerOffsets() const {
+  intptr_t CodeSize() const { return buffer_.Size(); }
+  intptr_t prologue_offset() const { return prologue_offset_; }
+  const ZoneGrowableArray<intptr_t>& GetPointerOffsets() const {
     return buffer_.pointer_offsets();
   }
   const GrowableObjectArray& object_pool() const { return object_pool_; }
 
   void FinalizeInstructions(const MemoryRegion& region) {
     buffer_.FinalizeInstructions(region);
   }
 
   // Set up a Dart frame on entry with a frame pointer and PC information to
   // enable easy access to the RawInstruction object of code corresponding
@@ skipping 51 matching lines @@
                           Label* failure,
                           bool near_jump,
                           Register instance_reg);
 
   // Debugging and bringup support.
   void Stop(const char* message);
   void Unimplemented(const char* message);
   void Untested(const char* message);
   void Unreachable(const char* message);
 
-  static void InitializeMemoryWithBreakpoints(uword data, int length);
+  static void InitializeMemoryWithBreakpoints(uword data, intptr_t length);
 
   void Comment(const char* format, ...) PRINTF_ATTRIBUTE(2, 3);
   const Code::Comments& GetCodeComments() const;
 
   static const char* RegisterName(Register reg);
   static const char* FpuRegisterName(FpuRegister reg);
 
  private:
   AssemblerBuffer buffer_;
   GrowableObjectArray& object_pool_;  // Object pool is not used on ia32.
-  int prologue_offset_;
+  intptr_t prologue_offset_;
 
   class CodeComment : public ZoneAllocated {
    public:
     CodeComment(intptr_t pc_offset, const String& comment)
         : pc_offset_(pc_offset), comment_(comment) { }
 
     intptr_t pc_offset() const { return pc_offset_; }
     const String& comment() const { return comment_; }
 
    private:
     intptr_t pc_offset_;
     const String& comment_;
 
     DISALLOW_COPY_AND_ASSIGN(CodeComment);
   };
 
   GrowableArray<CodeComment*> comments_;
 
   inline void EmitUint8(uint8_t value);
   inline void EmitInt32(int32_t value);
   inline void EmitRegisterOperand(int rm, int reg);
   inline void EmitXmmRegisterOperand(int rm, XmmRegister reg);
   inline void EmitFixup(AssemblerFixup* fixup);
   inline void EmitOperandSizeOverride();
 
   void EmitOperand(int rm, const Operand& operand);
   void EmitImmediate(const Immediate& imm);
   void EmitComplex(int rm, const Operand& operand, const Immediate& immediate);
-  void EmitLabel(Label* label, int instruction_size);
+  void EmitLabel(Label* label, intptr_t instruction_size);
   void EmitLabelLink(Label* label);
   void EmitNearLabelLink(Label* label);
 
   void EmitGenericShift(int rm, Register reg, const Immediate& imm);
   void EmitGenericShift(int rm, const Operand& operand, Register shifter);
 
   void StoreIntoObjectFilter(Register object, Register value, Label* no_update);
 
   // Shorter filtering sequence that assumes that value is not a smi.
   void StoreIntoObjectFilterNoSmi(Register object,
@@ skipping 31 matching lines @@
 }
 
 
 inline void Assembler::EmitOperandSizeOverride() {
   EmitUint8(0x66);
 }
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_IA32_H_