Change the zone allocation api.

runtime/vm/assembler.h

 // 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.
 
 #ifndef VM_ASSEMBLER_H_
 #define VM_ASSEMBLER_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/globals.h"
@@ skipping 90 matching lines @@
   void EmitObject(const Object& object);
 
   // Emit a fixup at the current location.
   void EmitFixup(AssemblerFixup* fixup) {
     fixup->set_previous(fixup_);
     fixup->set_position(Size());
     fixup_ = fixup;
   }
 
   // Get the size of the emitted code.
-  int Size() const { return cursor_ - contents_; }
+  intptr_t Size() const { return cursor_ - contents_; }
   uword contents() const { return contents_; }
 
   // Copy the assembled instructions into the specified memory block
   // and apply all fixups.
   void FinalizeInstructions(const MemoryRegion& region);
 
   // To emit an instruction to the assembler buffer, the EnsureCapacity helper
   // must be used to guarantee that the underlying data area is big enough to
   // hold the emitted instruction. Usage:
   //
   //     AssemblerBuffer buffer;
   //     AssemblerBuffer::EnsureCapacity ensured(&buffer);
   //     ... emit bytes for single instruction ...
 
 #if defined(DEBUG)
   class EnsureCapacity : public ValueObject {
    public:
     explicit EnsureCapacity(AssemblerBuffer* buffer);
     ~EnsureCapacity();
 
    private:
     AssemblerBuffer* buffer_;
-    int gap_;
+    intptr_t gap_;
 
-    int ComputeGap() { return buffer_->Capacity() - buffer_->Size(); }
+    intptr_t ComputeGap() { return buffer_->Capacity() - buffer_->Size(); }
   };
 
   bool has_ensured_capacity_;
   bool HasEnsuredCapacity() const { return has_ensured_capacity_; }
 #else
   class EnsureCapacity : public ValueObject {
    public:
     explicit EnsureCapacity(AssemblerBuffer* buffer) {
       if (buffer->cursor() >= buffer->limit()) buffer->ExtendCapacity();
     }
   };
 
   // When building the C++ tests, assertion code is enabled. To allow
   // asserting that the user of the assembler buffer has ensured the
   // capacity needed for emitting, we add a dummy method in non-debug mode.
   bool HasEnsuredCapacity() const { return true; }
 #endif
 
   // Returns the position in the instruction stream.
-  int GetPosition() const { return cursor_ - contents_; }
+  intptr_t GetPosition() const { return cursor_ - contents_; }
 
  private:
   // The limit is set to kMinimumGap bytes before the end of the data area.
   // This leaves enough space for the longest possible instruction and allows
   // for a single, fast space check per instruction.
-  static const int kMinimumGap = 32;
+  static const intptr_t kMinimumGap = 32;
 
   uword contents_;
   uword cursor_;
   uword limit_;
   AssemblerFixup* fixup_;
   ZoneGrowableArray<int>* pointer_offsets_;
 #if defined(DEBUG)
   bool fixups_processed_;
 #endif
 
   uword cursor() const { return cursor_; }
   uword limit() const { return limit_; }
-  int Capacity() const {
+  intptr_t Capacity() const {
     ASSERT(limit_ >= contents_);
     return (limit_ - contents_) + kMinimumGap;
   }
 
   // Process the fixup chain.
   void ProcessFixups(const MemoryRegion& region);
 
   // Compute the limit based on the data area and the capacity. See
   // description of kMinimumGap for the reasoning behind the value.
-  static uword ComputeLimit(uword data, int capacity) {
+  static uword ComputeLimit(uword data, intptr_t capacity) {
     return data + capacity - kMinimumGap;
   }
 
   void ExtendCapacity();
 
   friend class AssemblerFixup;
 };
 
 }  // namespace dart
 
 
 #if defined(TARGET_ARCH_IA32)
 #include "vm/assembler_ia32.h"
 #elif defined(TARGET_ARCH_X64)
 #include "vm/assembler_x64.h"
 #elif defined(TARGET_ARCH_ARM)
 #include "vm/assembler_arm.h"
 #else
 #error Unknown architecture.
 #endif
 
 #endif  // VM_ASSEMBLER_H_