Change the zone allocation api.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 2178 matching lines @@
 }
 
 
 const char* Class::ToCString() const {
   const char* format = is_interface()
       ? "%s Interface: %s" : "%s Class: %s";
   const Library& lib = Library::Handle(library());
   const char* library_name = lib.IsNull() ? "" : lib.ToCString();
   const char* class_name = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, library_name, class_name) + 1;
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, library_name, class_name);
   return chars;
 }
 
 
 void Class::InsertCanonicalConstant(intptr_t index,
                                     const Instance& constant) const {
   // The constant needs to be added to the list. Grow the list if it is full.
   Array& canonical_list = Array::Handle(constants());
   const intptr_t list_len = canonical_list.Length();
@@ skipping 708 matching lines @@
 
 const char* Type::ToCString() const {
   if (IsResolved()) {
     const AbstractTypeArguments& type_arguments =
         AbstractTypeArguments::Handle(arguments());
     if (type_arguments.IsNull()) {
       const char* format = "Type: class '%s'";
       const char* class_name =
           String::Handle(Class::Handle(type_class()).Name()).ToCString();
       intptr_t len = OS::SNPrint(NULL, 0, format, class_name) + 1;
-      char* chars = reinterpret_cast<char*>(
-          Isolate::Current()->current_zone()->Allocate(len));
+      char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
       OS::SNPrint(chars, len, format, class_name);
       return chars;
     } else {
       const char* format = "Type: class '%s', args:[%s]";
       const char* class_name =
           String::Handle(Class::Handle(type_class()).Name()).ToCString();
       const char* args_cstr =
           AbstractTypeArguments::Handle(arguments()).ToCString();
       intptr_t len = OS::SNPrint(NULL, 0, format, class_name, args_cstr) + 1;
-      char* chars = reinterpret_cast<char*>(
-          Isolate::Current()->current_zone()->Allocate(len));
+      char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
       OS::SNPrint(chars, len, format, class_name, args_cstr);
       return chars;
     }
   } else {
     return "Unresolved Type";
   }
 }
 
 
 void TypeParameter::set_is_finalized() const {
@@ skipping 125 matching lines @@
          (state == RawTypeParameter::kBeingFinalized) ||
          (state == RawTypeParameter::kFinalizedUninstantiated));
   raw_ptr()->type_state_ = state;
 }
 
 
 const char* TypeParameter::ToCString() const {
   const char* format = "TypeParameter: name %s; index: %d";
   const char* name_cstr = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, name_cstr, index()) + 1;
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, name_cstr, index());
   return chars;
 }
 
 
 intptr_t AbstractTypeArguments::Length() const  {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return -1;
 }
@@ skipping 434 matching lines @@
 const char* TypeArguments::ToCString() const {
   if (IsNull()) {
     return "NULL TypeArguments";
   }
   const char* format = "%s [%s]";
   const char* prev_cstr = "TypeArguments:";
   for (int i = 0; i < Length(); i++) {
     const AbstractType& type_at = AbstractType::Handle(TypeAt(i));
     const char* type_cstr = type_at.IsNull() ? "null" : type_at.ToCString();
     intptr_t len = OS::SNPrint(NULL, 0, format, prev_cstr, type_cstr) + 1;
-    char* chars = reinterpret_cast<char*>(
-        Isolate::Current()->current_zone()->Allocate(len));
+    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, prev_cstr, type_cstr);
     prev_cstr = chars;
   }
   return prev_cstr;
 }
 
 
 intptr_t InstantiatedTypeArguments::Length() const {
   return AbstractTypeArguments::Handle(
       uninstantiated_type_arguments()).Length();
@@ skipping 58 matching lines @@
     return "NULL InstantiatedTypeArguments";
   }
   const char* format = "InstantiatedTypeArguments: [%s] instantiator: [%s]";
   const char* arg_cstr =
       AbstractTypeArguments::Handle(
           uninstantiated_type_arguments()).ToCString();
   const char* instantiator_cstr =
       AbstractTypeArguments::Handle(instantiator_type_arguments()).ToCString();
   intptr_t len =
       OS::SNPrint(NULL, 0, format, arg_cstr, instantiator_cstr) + 1;
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, arg_cstr, instantiator_cstr);
   return chars;
 }
 
 
 void Function::SetCode(const Code& value) const {
   StorePointer(&raw_ptr()->code_, value.raw());
   ASSERT(Function::Handle(value.function()).IsNull() ||
     (value.function() == this->raw()));
   value.set_function(*this);
@@ skipping 286 matching lines @@
     ASSERT(class_name != NULL);
     const Library& library = Library::Handle(function_class.library());
     ASSERT(!library.IsNull());
     const char* library_name = String::Handle(library.url()).ToCString();
     ASSERT(library_name != NULL);
     const char* lib_class_format =
         (library_name[0] == '\0') ? "%s%s_" : "%s_%s_";
     reserve_len +=
         OS::SNPrint(NULL, 0, lib_class_format, library_name, class_name);
     ASSERT(chars != NULL);
-    *chars = reinterpret_cast<char*>(
-        Isolate::Current()->current_zone()->Allocate(reserve_len + 1));
+    *chars = Isolate::Current()->current_zone()->Alloc<char>(reserve_len + 1);
     written = OS::SNPrint(
         *chars, reserve_len, lib_class_format, library_name, class_name);
   } else {
     written = ConstructFunctionFullyQualifiedCString(parent,
                                                      chars,
                                                      reserve_len);
   }
   ASSERT(*chars != NULL);
   char* next = *chars + written;
   written += OS::SNPrint(next, reserve_len + 1, function_format, name);
@@ skipping 439 matching lines @@
       break;
     case RawFunction::kConstImplicitGetter:
       f1 = " const-getter";
       break;
     default:
       UNREACHABLE();
   }
   const char* kFormat = "Function '%s':%s%s%s.";
   const char* function_name = String::Handle(name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, f0, f1, f2) + 1;
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, f0, f1, f2);
   return chars;
 }
 
 
 RawString* Field::GetterName(const String& field_name) {
   String& str = String::Handle();
   str = String::New(kGetterPrefix);
   str = String::Concat(str, field_name);
   return str.raw();
@@ skipping 104 matching lines @@
 const char* Field::ToCString() const {
   const char* kF0 = is_static() ? " static" : "";
   const char* kF1 = is_final() ? " final" : "";
   const char* kF2 = is_const() ? " const" : "";
   const char* kFormat = "Field <%s.%s>:%s%s%s";
   const char* field_name = String::Handle(name()).ToCString();
   const Class& cls = Class::Handle(owner());
   const char* cls_name = String::Handle(cls.Name()).ToCString();
   intptr_t len =
       OS::SNPrint(NULL, 0, kFormat, cls_name, field_name, kF0, kF1, kF2) + 1;
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, cls_name, field_name, kF0, kF1, kF2);
   return chars;
 }
 
 
 void LiteralToken::set_literal(const String& literal) const {
   StorePointer(&raw_ptr()->literal_, literal.raw());
 }
 
 
@@ skipping 1730 matching lines @@
 
 RawLibrary* Library::NativeWrappersLibrary() {
   return Isolate::Current()->object_store()->native_wrappers_library();
 }
 
 
 const char* Library::ToCString() const {
   const char* kFormat = "Library:'%s'";
   const String& name = String::Handle(url());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString()) + 1;
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, name.ToCString());
   return chars;
 }
 
 
 RawLibrary* LibraryPrefix::GetLibrary(int index) const {
   Library& lib = Library::Handle();
   if ((index >= 0) || (index < num_libs())) {
     Array& libs = Array::Handle(libraries());
     lib ^= libs.At(index);
@@ skipping 73 matching lines @@
   result.set_num_libs(0);
   result.AddLibrary(lib);
   return result.raw();
 }
 
 
 const char* LibraryPrefix::ToCString() const {
   const char* kFormat = "LibraryPrefix:'%s'";
   const String& prefix = String::Handle(name());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, prefix.ToCString()) + 1;
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, prefix.ToCString());
   return chars;
 }
 
 
 RawString* LibraryPrefix::CheckForDuplicateDefinition() const {
   Library& lib = Library::Handle();
   Library& conflicting_lib = Library::Handle();
   Object& obj = Object::Handle();
   Class& cls = Class::Handle();
@@ skipping 209 matching lines @@
     return "No pc descriptors\n";
   }
   const char* kFormat = "0x%x\t%s\t%ld\t%ld\t%ld\n";
   // First compute the buffer size required.
   intptr_t len = 0;
   for (intptr_t i = 0; i < Length(); i++) {
     len += OS::SNPrint(NULL, 0, kFormat,
         PC(i), KindAsStr(i), NodeId(i), TryIndex(i), TokenIndex(i));
   }
   // Allocate the buffer.
-  char* buffer = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len + 1));
+  char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   // Layout the fields in the buffer.
   intptr_t index = 0;
   for (intptr_t i = 0; i < Length(); i++) {
     index += OS::SNPrint((buffer + index), (len - index), kFormat,
         PC(i), KindAsStr(i), NodeId(i), TryIndex(i), TokenIndex(i));
   }
   return buffer;
 }
 
 
@@ skipping 96 matching lines @@
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   raw_ptr()->bitmap_size_in_bytes_ = Smi::New(value);
 }
 
 
 const char* Stackmap::ToCString() const {
   if (IsNull()) {
     return "{null}";
   } else {
+    // Guard against integer overflow, though it is highly unlikely.
+    if (MaximumBitIndex() > kIntptrMax / 4) {
+      FATAL1("MaximumBitIndex() is unexpectedly large (%ld)",
+             MaximumBitIndex());
+    }
     intptr_t index = OS::SNPrint(NULL, 0, "0x%lx { ", PC());
     intptr_t alloc_size =
         index + ((MaximumBitIndex() + 1) * 2) + 2;  // "{ 1 0 .... }".
     Isolate* isolate = Isolate::Current();
-    char* chars = reinterpret_cast<char*>(
-        isolate->current_zone()->Allocate(alloc_size));
+    char* chars = isolate->current_zone()->Alloc<char>(alloc_size);
     index = OS::SNPrint(chars, alloc_size, "0x%lx { ", PC());
     for (intptr_t i = 0; i <= MaximumBitIndex(); i++) {
       index += OS::SNPrint((chars + index),
                            (alloc_size - index),
                            "%d ",
                            IsObject(i) ? 1 : 0);
     }
     OS::SNPrint((chars + index), (alloc_size - index), "}");
     return chars;
   }
@@ skipping 109 matching lines @@
   if (Length() == 0) {
     return "No exception handlers\n";
   }
   // First compute the buffer size required.
   intptr_t len = 0;
   for (intptr_t i = 0; i < Length(); i++) {
     len += OS::SNPrint(NULL, 0, "%ld => 0x%x\n",
                        TryIndex(i), HandlerPC(i));
   }
   // Allocate the buffer.
-  char* buffer = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len + 1));
+  char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   // Layout the fields in the buffer.
   intptr_t index = 0;
   for (intptr_t i = 0; i < Length(); i++) {
     index += OS::SNPrint((buffer + index),
                          (len - index),
                          "%ld => 0x%x\n",
                          TryIndex(i),
                          HandlerPC(i));
   }
   return buffer;
@@ skipping 90 matching lines @@
   // Embedded pointers are still in handles at this point.
   MemoryRegion region(reinterpret_cast<void*>(instrs.EntryPoint()),
                       instrs.size());
   assembler->FinalizeInstructions(region);
   Dart_FileWriterFunction perf_events_writer = Dart::perf_events_writer();
   if (perf_events_writer != NULL) {
     const char* format = "%x %x %s\n";
     uword addr = instrs.EntryPoint();
     uword size = instrs.size();
     intptr_t len = OS::SNPrint(NULL, 0, format, addr, size, name);
-    char* buffer = reinterpret_cast<char*>(
-        Isolate::Current()->current_zone()->Allocate(len + 1));
+    char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
     OS::SNPrint(buffer, len + 1, format, addr, size, name);
     (*perf_events_writer)(buffer, len);
   }
   DebugInfo* pprof_symbol_generator = Dart::pprof_symbol_generator();
   if (pprof_symbol_generator != NULL) {
     ASSERT(strlen(name) != 0);
     pprof_symbol_generator->AddCode(instrs.EntryPoint(), instrs.size());
     pprof_symbol_generator->AddCodeRegion(name,
                                           instrs.EntryPoint(),
                                           instrs.size());
   }
   if (FLAG_generate_gdb_symbols) {
     ASSERT(strlen(name) != 0);
     intptr_t prolog_offset = assembler->prolog_offset();
     if (prolog_offset > 0) {
       // In order to ensure that gdb sees the first instruction of a function
       // as the prolog sequence we register two symbols for the cases when
       // the prolog sequence is not the first instruction:
       // <name>_entry is used for code preceding the prolog sequence.
       // <name> for rest of the code (first instruction is prolog sequence).
       const char* kFormat = "%s_%s";
       intptr_t len = OS::SNPrint(NULL, 0, kFormat, name, "entry");
-      char* pname = reinterpret_cast<char*>(
-          Isolate::Current()->current_zone()->Allocate(len + 1));
+      char* pname = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
       OS::SNPrint(pname, (len + 1), kFormat, name, "entry");
       DebugInfo::RegisterSection(pname, instrs.EntryPoint(), prolog_offset);
       DebugInfo::RegisterSection(name,
                                  (instrs.EntryPoint() + prolog_offset),
                                  (instrs.size() - prolog_offset));
     } else {
       DebugInfo::RegisterSection(name, instrs.EntryPoint(), instrs.size());
     }
   }
 
@@ skipping 75 matching lines @@
       return descriptors.PC(i);
     }
   }
   return 0;
 }
 
 
 const char* Code::ToCString() const {
   const char* kFormat = "Code entry:0x%d";
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, EntryPoint());
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, EntryPoint());
   return chars;
 }
 
 
 uword Code::GetPatchCodePc() const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     if (descriptors.DescriptorKind(i) == PcDescriptors::kPatchCode) {
       return descriptors.PC(i);
@@ skipping 169 matching lines @@
 
 const char* ContextScope::ToCString() const {
   return "ContextScope";
 }
 
 
 const char* ICData::ToCString() const {
   const char* kFormat = "ICData target:%s";
   const String& name = String::Handle(target_name());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString()) + 1;
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, name.ToCString());
   return chars;
 }
 
 
 void ICData::set_function(const Function& value) const {
   StorePointer(&raw_ptr()->function_, value.raw());
 }
 
 
@@ skipping 399 matching lines @@
   const char* stack_str =
       "<Received error while converting stack trace to string>";
   if (!strtmp.IsError()) {
     stack_str = strtmp.ToCString();
   }
 
   const char* format = "Unhandled exception:\n%s\n%s";
   int len = (strlen(exc_str) + strlen(stack_str) + strlen(format)
              - 4    // Two '%s'
              + 1);  // '\0'
-  char* chars = reinterpret_cast<char*>(isolate->current_zone()->Allocate(len));
+  char* chars = isolate->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, exc_str, stack_str);
   return chars;
 }
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
@@ skipping 263 matching lines @@
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
     if (num_type_arguments > 0) {
       type_arguments = GetTypeArguments();
     }
     const Type& type =
         Type::Handle(Type::New(cls, type_arguments, Scanner::kDummyTokenIndex));
     const String& type_name = String::Handle(type.Name());
     // Calculate the size of the string.
     intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
-    char* chars = reinterpret_cast<char*>(
-        Isolate::Current()->current_zone()->Allocate(len));
+    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, kFormat, type_name.ToCString());
     return chars;
   }
 }
 
 
 const char* Number::ToCString() const {
   // Number is an interface. No instances of Number should exist.
   UNREACHABLE();
   return "Number";
@@ skipping 103 matching lines @@
   }
   UNREACHABLE();
   return 0;
 }
 
 
 const char* Smi::ToCString() const {
   const char* kFormat = "%ld";
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, Value()) + 1;
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, Value());
   return chars;
 }
 
 
 RawClass* Smi::Class() {
   return Isolate::Current()->object_store()->smi_class();
 }
 
 
@@ skipping 93 matching lines @@
   }
   UNREACHABLE();
   return 0;
 }
 
 
 const char* Mint::ToCString() const {
   const char* kFormat = "%lld";
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, value()) + 1;
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, value());
   return chars;
 }
 
 
 void Double::set_value(double value) const {
   raw_ptr()->value_ = value;
 }
 
 
@@ skipping 99 matching lines @@
 
 
 const char* Double::ToCString() const {
   if (isnan(value())) {
     return "NaN";
   }
   if (isinf(value())) {
     return value() < 0 ? "-Infinity" : "Infinity";
   }
   const int kBufferSize = 128;
-  char* buffer = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(kBufferSize));
+  char* buffer = Isolate::Current()->current_zone()->Alloc<char>(kBufferSize);
   buffer[kBufferSize - 1] = '\0';
   DoubleToCString(value(), buffer, kBufferSize);
   return buffer;
 }
 
 
 bool Bigint::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     // Both handles point to the same raw instance.
     return true;
@@ skipping 66 matching lines @@
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.raw_ptr()->allocated_length_ = length;  // Chunk length allocated.
     result.raw_ptr()->signed_length_ = length;  // Chunk length in use.
   }
   return result.raw();
 }
 
 
-static uword ZoneAllocator(intptr_t size) {
+static uword BigintAllocator(intptr_t size) {
   Zone* zone = Isolate::Current()->current_zone();
-  return zone->Allocate(size);
+  return zone->AllocUnsafe(size);
 }
 
 
 const char* Bigint::ToCString() const {
-  return BigintOperations::ToDecimalCString(*this, &ZoneAllocator);
+  return BigintOperations::ToDecimalCString(*this, &BigintAllocator);
 }
 
 
 class StringHasher : ValueObject {
  public:
   StringHasher() : hash_(0) {}
   void Add(int32_t ch) {
     hash_ += ch;
     hash_ += hash_ << 10;
     hash_ ^= hash_ >> 6;
@@ skipping 476 matching lines @@
 }
 
 
 RawString* String::NewFormatted(const char* format, ...) {
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   Zone* zone = Isolate::Current()->current_zone();
-  char* buffer = reinterpret_cast<char*>(zone->Allocate(len + 1));
+  char* buffer = zone->Alloc<char>(len + 1);
   va_list args2;
   va_start(args2, format);
   OS::VSNPrint(buffer, (len + 1), format, args2);
   va_end(args2);
 
   return String::New(buffer);
 }
 
 
 RawString* String::Concat(const String& str1,
@@ skipping 84 matching lines @@
     result ^= FourByteString::New(length, space);
   }
   String::Copy(result, 0, str, begin_index, length);
   return result.raw();
 }
 
 
 const char* String::ToCString() const {
   intptr_t len = Utf8::Length(*this);
   Zone* zone = Isolate::Current()->current_zone();
-  char* result = reinterpret_cast<char*>(zone->Allocate(len + 1));
+  char* result = zone->Alloc<char>(len + 1);
   Utf8::Encode(*this, result, len);
   result[len] = 0;
   return result;
 }
 
 
 RawString* String::Transform(int32_t (*mapping)(int32_t ch),
                              const String& str,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
@@ skipping 1543 matching lines @@
 
 
 const char* Closure::ToCString() const {
   const Function& fun = Function::Handle(function());
   const bool is_implicit_closure = fun.IsImplicitClosureFunction();
   const char* fun_sig = String::Handle(fun.Signature()).ToCString();
   const char* from = is_implicit_closure ? " from " : "";
   const char* fun_desc = is_implicit_closure ? fun.ToCString() : "";
   const char* format = "Closure: %s%s%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, fun_sig, from, fun_desc) + 1;
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, fun_sig, from, fun_desc);
   return chars;
 }
 
 
 intptr_t Stacktrace::Length() const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   return code_array.Length();
 }
 
@@ skipping 132 matching lines @@
     }
     intptr_t len = OS::SNPrint(NULL, 0, kFormat,
                                i,
                                class_name.ToCString(),
                                function_class.IsTopLevel() ? "" : ".",
                                function_name.ToCString(),
                                url.ToCString(),
                                line, column,
                                code.EntryPoint());
     total_len += len;
-    char* chars = reinterpret_cast<char*>(
-        Isolate::Current()->current_zone()->Allocate(len + 1));
+    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
     OS::SNPrint(chars, (len + 1), kFormat,
                 i,
                 class_name.ToCString(),
                 function_class.IsTopLevel() ? "" : ".",
                 function_name.ToCString(),
                 url.ToCString(),
                 line, column,
                 code.EntryPoint());
     frame_strings.Add(chars);
   }
 
   // Now concatentate the frame descriptions into a single C string.
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(total_len + 1));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(total_len + 1);
   intptr_t index = 0;
   for (intptr_t i = 0; i < frame_strings.length(); i++) {
     index += OS::SNPrint((chars + index),
                          (total_len + 1 - index),
                          "%s",
                          frame_strings[i]);
   }
   return chars;
 }
 
@@ skipping 84 matching lines @@
     return false;
   }
   return true;
 }
 
 
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
-  char* chars = reinterpret_cast<char*>(
-      Isolate::Current()->current_zone()->Allocate(len + 1));
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart