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

runtime/vm/assembler.cc

 // Copyright (c) 2012, 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/assembler.h"
 
 #include "platform/utils.h"
 #include "vm/cpu.h"
 #include "vm/heap.h"
 #include "vm/memory_region.h"
@@ skipping 44 matching lines @@
   buffer_->has_ensured_capacity_ = false;
   // Make sure the generated instruction doesn't take up more
   // space than the minimum gap.
   intptr_t delta = gap_ - ComputeGap();
   ASSERT(delta <= kMinimumGap);
 }
 #endif
 
 
 AssemblerBuffer::AssemblerBuffer()
-    : pointer_offsets_(new ZoneGrowableArray<int>(16)) {
+    : pointer_offsets_(new ZoneGrowableArray<intptr_t>(16)) {
   static const intptr_t kInitialBufferCapacity = 4 * KB;
   contents_ = NewContents(kInitialBufferCapacity);
   cursor_ = contents_;
   limit_ = ComputeLimit(contents_, kInitialBufferCapacity);
   fixup_ = NULL;
 #if defined(DEBUG)
   has_ensured_capacity_ = false;
   fixups_processed_ = false;
 #endif
 
@@ skipping 53 matching lines @@
   limit_ = ComputeLimit(new_contents, new_capacity);
 
   // Verify internal state.
   ASSERT(Capacity() == new_capacity);
   ASSERT(Size() == old_size);
 }
 
 
 class PatchCodeWithHandle : public AssemblerFixup {
  public:
-  PatchCodeWithHandle(ZoneGrowableArray<int>* pointer_offsets,
+  PatchCodeWithHandle(ZoneGrowableArray<intptr_t>* pointer_offsets,
                       const Object& object)
       : pointer_offsets_(pointer_offsets), object_(object) {
   }
 
-  void Process(const MemoryRegion& region, int position) {
+  void Process(const MemoryRegion& region, intptr_t position) {
     // Patch the handle into the code. Once the instructions are installed into
     // a raw code object and the pointer offsets are setup, the handle is
     // resolved.
     region.Store<const Object*>(position, &object_);
     pointer_offsets_->Add(position);
   }
 
  private:
-  ZoneGrowableArray<int>* pointer_offsets_;
+  ZoneGrowableArray<intptr_t>* pointer_offsets_;
   const Object& object_;
 };
 
 
 void AssemblerBuffer::EmitObject(const Object& object) {
   // Since we are going to store the handle as part of the fixup information
   // the handle needs to be a zone handle.
   ASSERT(object.IsNotTemporaryScopedHandle());
   ASSERT(object.IsOld());
   EmitFixup(new PatchCodeWithHandle(pointer_offsets_, object));
@@ skipping 49 matching lines @@
 
   for (intptr_t i = 0; i < comments_.length(); i++) {
     comments.SetPCOffsetAt(i, comments_[i]->pc_offset());
     comments.SetCommentAt(i, comments_[i]->comment());
   }
 
   return comments;
 }
 
 }  // namespace dart