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

runtime/vm/assembler_x64.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_X64_H_
 #define VM_ASSEMBLER_X64_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_x64.h directly; use assembler.h instead.
 #endif
@@ skipping 126 matching lines @@
   }
 
  private:
   uint8_t length_;
   uint8_t rex_;
   uint8_t encoding_[6];
 
   explicit Operand(Register reg) : rex_(REX_NONE) { 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 ((reg > 7 ? 1 : 0) == (rex_ & REX_B))  // REX.B match.
         && ((encoding_at(0) & 0xF8) == 0xC0)  // Addressing mode is register.
         && ((encoding_at(0) & 0x07) == reg);  // Register codes match.
@@ skipping 100 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();
   // x64 always has at least SSE2.
@@ skipping 420 matching lines @@
    */
   void SmiTag(Register reg) {
     addq(reg, reg);
   }
 
   void SmiUntag(Register reg) {
     sarq(reg, Immediate(kSmiTagSize));
   }
 
   int PreferredLoopAlignment() { return 16; }
-  void Align(int alignment, int offset);
+  void Align(int alignment, intptr_t offset);
   void Bind(Label* label);
 
   void Comment(const char* format, ...) PRINTF_ATTRIBUTE(2, 3);
   const Code::Comments& GetCodeComments() const;
 
-  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);
   }
 
   void LoadPoolPointer(Register pp);
 
@@ skipping 62 matching lines @@
                    bool near_jump,
                    Register instance_reg,
                    Register pp);
 
   // 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);
 
   static const char* RegisterName(Register reg);
 
   static const char* FpuRegisterName(FpuRegister reg);
 
  private:
   AssemblerBuffer buffer_;
 
   // Objects and jump targets.
   GrowableObjectArray& object_pool_;
@@ skipping 35 matching lines @@
     }
 
    private:
     Key key_;
     Value value_;
   };
 
   // Hashmap for fast lookup in object pool.
   DirectChainedHashMap<ObjIndexPair> object_pool_index_table_;
 
-  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:
@@ skipping 34 matching lines @@
                          uint8_t rex = REX_NONE);
   inline void EmitREX_RB(XmmRegister reg,
                          Register base,
                          uint8_t rex = REX_NONE);
   inline void EmitREX_RB(Register reg,
                          XmmRegister base,
                          uint8_t rex = REX_NONE);
   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(bool wide, int rm, Register reg, const Immediate& imm);
   void EmitGenericShift(bool wide, int rm, Register 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 76 matching lines @@
 }
 
 
 inline void Assembler::EmitOperandSizeOverride() {
   EmitUint8(0x66);
 }
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_X64_H_