Change the zone allocation api.

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 158 matching lines @@
     success = isolate->object_store()->PreallocateObjects();
     if (success) {
       return NULL;
     }
   }
   // Make a copy of the error message as the original message string
   // may get deallocated when we return back from the Dart API call.
   const Error& err = Error::Handle(isolate->object_store()->sticky_error());
   const char* errmsg = err.ToErrorCString();
   intptr_t errlen = strlen(errmsg) + 1;
-  char* msg = reinterpret_cast<char*>(Api::Allocate(isolate, errlen));
+  char* msg = Api::TopScope(isolate)->zone()->Alloc<char>(errlen);
   OS::SNPrint(msg, errlen, "%s", errmsg);
   return msg;
 }
 
 
 void SetupErrorResult(Isolate* isolate, Dart_Handle* handle) {
   *handle = Api::NewHandle(
       isolate, Isolate::Current()->object_store()->sticky_error());
 }
 
 
 Dart_Handle Api::NewHandle(Isolate* isolate, RawObject* raw) {
-  ASSERT(isolate != NULL);
-  ApiState* state = isolate->api_state();
-  ASSERT(state != NULL);
-  ApiLocalScope* scope = state->top_scope();
-  ASSERT(scope != NULL);
-  LocalHandles* local_handles = scope->local_handles();
+  LocalHandles* local_handles = Api::TopScope(isolate)->local_handles();
   ASSERT(local_handles != NULL);
   LocalHandle* ref = local_handles->AllocateHandle();
   ref->set_raw(raw);
   return reinterpret_cast<Dart_Handle>(ref);
 }
 
 RawObject* Api::UnwrapHandle(Dart_Handle object) {
 #if defined(DEBUG)
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
@@ skipping 69 matching lines @@
 
 Dart_Handle Api::NewError(const char* format, ...) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE_NOCHECKS(isolate);
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
-  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);
 
   const String& message = String::Handle(isolate, String::New(buffer));
   return Api::NewHandle(isolate, ApiError::New(message));
 }
 
 
@@ skipping 17 matching lines @@
 
 Dart_Handle Api::False(Isolate* isolate) {
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* false_handle = state->False();
   return reinterpret_cast<Dart_Handle>(false_handle);
 }
 
 
-uword Api::Allocate(Isolate* isolate, intptr_t size) {
+ApiLocalScope* Api::TopScope(Isolate* isolate) {
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
-  return scope->zone()->Allocate(size);
-}
-
-
-uword Api::Reallocate(Isolate* isolate,
-                      uword ptr,
-                      intptr_t old_size,
-                      intptr_t new_size) {
-  ASSERT(isolate != NULL);
-  ApiState* state = isolate->api_state();
-  ASSERT(state != NULL);
-  ApiLocalScope* scope = state->top_scope();
-  ASSERT(scope != NULL);
-  return scope->zone()->Reallocate(ptr, old_size, new_size);
+  return scope;
 }
 
 
 void Api::InitOnce() {
   ASSERT(api_native_key_ == Thread::kUnsetThreadLocalKey);
   api_native_key_ = Thread::CreateThreadLocal();
   ASSERT(api_native_key_ != Thread::kUnsetThreadLocalKey);
 }
 
 
@@ skipping 26 matching lines @@
 
 
 DART_EXPORT const char* Dart_GetError(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsError()) {
     const Error& error = Error::Cast(obj);
     const char* str = error.ToErrorCString();
     intptr_t len = strlen(str) + 1;
-    char* str_copy = reinterpret_cast<char*>(Api::Allocate(isolate, len));
+    char* str_copy = Api::TopScope(isolate)->zone()->Alloc<char>(len);
     strncpy(str_copy, str, len);
     // Strip a possible trailing '\n'.
     if ((len > 1) && (str_copy[len - 2] == '\n')) {
       str_copy[len - 2] = '\0';
     }
     return str_copy;
   } else {
     return "";
   }
 }
@@ skipping 41 matching lines @@
 // TODO(turnidge): Remove all uses and delete.
 DART_EXPORT Dart_Handle Dart_Error(const char* format, ...) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
-  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);
 
   const String& message = String::Handle(isolate, String::New(buffer));
   return Api::NewHandle(isolate, ApiError::New(message));
 }
 
 
 // TODO(turnidge): This clones Api::NewError.  I need to use va_copy to
 // fix this but not sure if it available on all of our builds.
 DART_EXPORT Dart_Handle Dart_NewApiError(const char* format, ...) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
-  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);
 
   const String& message = String::Handle(isolate, String::New(buffer));
   return Api::NewHandle(isolate, ApiError::New(message));
 }
 
 
@@ skipping 398 matching lines @@
 
 DART_EXPORT void Dart_ExitIsolate() {
   CHECK_ISOLATE(Isolate::Current());
   Isolate::SetCurrent(NULL);
 }
 
 
 static uint8_t* ApiReallocate(uint8_t* ptr,
                               intptr_t old_size,
                               intptr_t new_size) {
-  uword new_ptr = Api::Reallocate(Isolate::Current(),
-                                  reinterpret_cast<uword>(ptr),
-                                  old_size,
-                                  new_size);
-  return reinterpret_cast<uint8_t*>(new_ptr);
+  return Api::TopScope(Isolate::Current())->zone()->Realloc<uint8_t>(
+      ptr, old_size, new_size);
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateSnapshot(uint8_t** buffer,
                                             intptr_t* size) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   TIMERSCOPE(time_creating_snapshot);
   if (buffer == NULL) {
     RETURN_NULL_ERROR(buffer);
@@ skipping 279 matching lines @@
   if (isolate != NULL) {
     ApiState* state = isolate->api_state();
     if (state == NULL) return NULL;
     ApiLocalScope* scope = state->top_scope();
     zone = scope->zone();
   } else {
     ApiNativeScope* scope = ApiNativeScope::Current();
     if (scope == NULL) return NULL;
     zone = scope->zone();
   }
-  return reinterpret_cast<uint8_t*>(zone->Allocate(size));
+  return reinterpret_cast<uint8_t*>(zone->AllocUnsafe(size));
 }
 
 
 // --- Objects ----
 
 
 DART_EXPORT Dart_Handle Dart_Null() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   return Api::Null(isolate);
@@ skipping 232 matching lines @@
     if (BigintOperations::FitsIntoUint64(bigint)) {
       *value = BigintOperations::ToUint64(bigint);
       return Api::Success(isolate);
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as a uint64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
 
 
-static uword ApiAllocate(intptr_t size) {
-  return Api::Allocate(Isolate::Current(), size);
+static uword BigintAllocate(intptr_t size) {
+  return Api::TopScope(Isolate::Current())->zone()->AllocUnsafe(size);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToHexCString(Dart_Handle integer,
                                                  const char** value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     const Bigint& bigint = Bigint::Handle(isolate,
         BigintOperations::NewFromInt64(int_obj.AsInt64Value()));
-    *value = BigintOperations::ToHexCString(bigint, ApiAllocate);
+    *value = BigintOperations::ToHexCString(bigint, BigintAllocate);
   } else {
-    *value = BigintOperations::ToHexCString(Bigint::Cast(int_obj), ApiAllocate);
+    *value = BigintOperations::ToHexCString(Bigint::Cast(int_obj),
+                                            BigintAllocate);
   }
   return Api::Success(isolate);
 }
 
 
 // --- Booleans ----
 
 
 DART_EXPORT Dart_Handle Dart_True() {
   Isolate* isolate = Isolate::Current();
@@ skipping 275 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_StringToCString(Dart_Handle object,
                                              const char** result) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& str_obj = Api::UnwrapStringHandle(isolate, object);
   if (str_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, object, String);
   }
   intptr_t string_length = Utf8::Length(str_obj);
-  char* res =
-      reinterpret_cast<char*>(Api::Allocate(isolate, string_length + 1));
+  char* res = Api::TopScope(isolate)->zone()->Alloc<char>(string_length + 1);
   if (res == NULL) {
     return Api::NewError("Unable to allocate memory");
   }
   const char* string_value = str_obj.ToCString();
   memmove(res, string_value, string_length + 1);
   ASSERT(res[string_length] == '\0');
   *result = res;
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringToBytes(Dart_Handle object,
                                            const uint8_t** bytes,
                                            intptr_t *length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& str = Api::UnwrapStringHandle(isolate, object);
   if (str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, object, String);
   }
   if (bytes == NULL) {
     RETURN_NULL_ERROR(bytes);
   }
   if (length == NULL) {
     RETURN_NULL_ERROR(length);
   }
   const char* cstring = str.ToCString();
   *length = Utf8::Length(str);
-  uint8_t* result = reinterpret_cast<uint8_t*>(Api::Allocate(isolate, *length));
+  uint8_t* result = Api::TopScope(isolate)->zone()->Alloc<uint8_t>(*length);
   if (result == NULL) {
     return Api::NewError("Unable to allocate memory");
   }
   memmove(result, cstring, *length);
   *bytes = result;
   return Api::Success(isolate);
 }
 
 
 // --- Lists ---
@@ skipping 2372 matching lines @@
 
 DART_EXPORT void Dart_GetPprofSymbolInfo(void** buffer, int* buffer_size) {
   Isolate* isolate = Isolate::Current();
   DebugInfo* pprof_symbol_generator = Dart::pprof_symbol_generator();
   if (pprof_symbol_generator != NULL) {
     DebugInfo::ByteBuffer* debug_region = new DebugInfo::ByteBuffer();
     ASSERT(debug_region != NULL);
     pprof_symbol_generator->WriteToMemory(debug_region);
     *buffer_size = debug_region->size();
     if (*buffer_size != 0) {
-      *buffer = reinterpret_cast<void*>(Api::Allocate(isolate, *buffer_size));
+      ApiZone* zone = Api::TopScope(isolate)->zone();
+      *buffer = reinterpret_cast<void*>(zone->AllocUnsafe(*buffer_size));
       memmove(*buffer, debug_region->data(), *buffer_size);
     } else {
       *buffer = NULL;
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 
 DART_EXPORT void Dart_InitPerfEventsSupport(Dart_FileWriterFunction function) {
   Dart::set_perf_events_writer(function);
 }
 
 
 DART_EXPORT void Dart_InitFlowGraphPrinting(Dart_FileWriterFunction function) {
   Dart::set_flow_graph_writer(function);
 }
 
 }  // namespace dart