Add just enough state changes from EXTERNAL (outside V8) to OTHER...

src/api.cc

 // Copyright 2007-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 23 matching lines @@
 #include "execution.h"
 #include "global-handles.h"
 #include "platform.h"
 #include "serialize.h"
 #include "snapshot.h"
 #include "v8threads.h"
 
 
 #define LOG_API(expr) LOG(ApiEntryCall(expr))
 
+#ifdef ENABLE_HEAP_PROTECTION
+#define ENTER_V8 i::VMState __state__(i::OTHER)
+#else
+#define ENTER_V8 ((void) 0)
+#endif
+
 
 namespace v8 {
 
 
 #define ON_BAILOUT(location, code)              \
   if (IsDeadCheck(location)) {                  \
     code;                                       \
     UNREACHABLE();                              \
   }
 
@@ skipping 398 matching lines @@
 
 // --- N e a n d e r ---
 
 
 // A constructor cannot easily return an error value, therefore it is necessary
 // to check for a dead VM with ON_BAILOUT before constructing any Neander
 // objects.  To remind you about this there is no HandleScope in the
 // NeanderObject constructor.  When you add one to the site calling the
 // constructor you should check that you ensured the VM was not dead first.
 NeanderObject::NeanderObject(int size) {
+  ENTER_V8;
   EnsureInitialized("v8::Nowhere");
   value_ = i::Factory::NewNeanderObject();
   i::Handle<i::FixedArray> elements = i::Factory::NewFixedArray(size);
   value_->set_elements(*elements);
 }
 
 
 int NeanderObject::size() {
   return i::FixedArray::cast(value_->elements())->length();
 }
@@ skipping 44 matching lines @@
 // --- T e m p l a t e ---
 
 
 static void InitializeTemplate(i::Handle<i::TemplateInfo> that, int type) {
   that->set_tag(i::Smi::FromInt(type));
 }
 
 
 void Template::Set(v8::Handle<String> name, v8::Handle<Data> value,
                    v8::PropertyAttribute attribute) {
+  ENTER_V8;
   if (IsDeadCheck("v8::Template::SetProperty()")) return;
   HandleScope scope;
   i::Handle<i::Object> list(Utils::OpenHandle(this)->property_list());
   if (list->IsUndefined()) {
     list = NeanderArray().value();
     Utils::OpenHandle(this)->set_property_list(*list);
   }
   NeanderArray array(list);
   array.add(Utils::OpenHandle(*name));
   array.add(Utils::OpenHandle(*value));
@@ skipping 28 matching lines @@
 }
 
 
 // To distinguish the function templates, so that we can find them in the
 // function cache of the global context.
 static int next_serial_number = 0;
 
 
 Local<FunctionTemplate> FunctionTemplate::New(InvocationCallback callback,
     v8::Handle<Value> data, v8::Handle<Signature> signature) {
+  ENTER_V8;
   EnsureInitialized("v8::FunctionTemplate::New()");
   LOG_API("FunctionTemplate::New");
   i::Handle<i::Struct> struct_obj =
       i::Factory::NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE);
   i::Handle<i::FunctionTemplateInfo> obj =
       i::Handle<i::FunctionTemplateInfo>::cast(struct_obj);
   InitializeFunctionTemplate(obj);
   obj->set_serial_number(i::Smi::FromInt(next_serial_number++));
   if (callback != 0) {
     if (data.IsEmpty()) data = v8::Undefined();
@@ skipping 212 matching lines @@
 // --- O b j e c t T e m p l a t e ---
 
 
 Local<ObjectTemplate> ObjectTemplate::New() {
   return New(Local<FunctionTemplate>());
 }
 
 
 Local<ObjectTemplate> ObjectTemplate::New(
       v8::Handle<FunctionTemplate> constructor) {
+  ENTER_V8;
   if (IsDeadCheck("v8::ObjectTemplate::New()")) return Local<ObjectTemplate>();
   EnsureInitialized("v8::ObjectTemplate::New()");
   LOG_API("ObjectTemplate::New");
   i::Handle<i::Struct> struct_obj =
       i::Factory::NewStruct(i::OBJECT_TEMPLATE_INFO_TYPE);
   i::Handle<i::ObjectTemplateInfo> obj =
       i::Handle<i::ObjectTemplateInfo>::cast(struct_obj);
   InitializeTemplate(obj, Consts::OBJECT_TEMPLATE);
   if (!constructor.IsEmpty())
     obj->set_constructor(*Utils::OpenHandle(*constructor));
@@ skipping 165 matching lines @@
   return new i::ScriptDataImpl(i::Vector<unsigned>(data, length));
 }
 
 
 // --- S c r i p t ---
 
 
 Local<Script> Script::Compile(v8::Handle<String> source,
                               v8::ScriptOrigin* origin,
                               v8::ScriptData* script_data) {
+  ENTER_V8;
   ON_BAILOUT("v8::Script::Compile()", return Local<Script>());
   LOG_API("Script::Compile");
   i::Handle<i::String> str = Utils::OpenHandle(*source);
   i::Handle<i::Object> name_obj;
   int line_offset = 0;
   int column_offset = 0;
   if (origin != NULL) {
     if (!origin->ResourceName().IsEmpty()) {
       name_obj = Utils::OpenHandle(*origin->ResourceName());
     }
@@ skipping 1254 matching lines @@
     return;
   }
   i::Handle<i::Object> val = Utils::OpenHandle(*value);
   obj->SetInternalField(index, *val);
 }
 
 
 // --- E n v i r o n m e n t ---
 
 bool v8::V8::Initialize() {
+  ENTER_V8;
   if (i::V8::HasBeenSetup()) return true;
   HandleScope scope;
   if (i::Snapshot::Initialize()) {
     return true;
   } else {
     return i::V8::Initialize(NULL);
   }
 }
 
 
@@ skipping 17 matching lines @@
   }
   return i::Handle<i::FunctionTemplateInfo>(
     i::FunctionTemplateInfo::cast(templ->constructor()));
 }
 
 
 Persistent<Context> v8::Context::New(
     v8::ExtensionConfiguration* extensions,
     v8::Handle<ObjectTemplate> global_template,
     v8::Handle<Value> global_object) {
+  ENTER_V8;
   EnsureInitialized("v8::Context::New()");
   LOG_API("Context::New");
   ON_BAILOUT("v8::Context::New()", return Persistent<Context>());
 
   // Give the heap a chance to cleanup if we've disposed contexts.
   i::Heap::CollectAllGarbageIfContextDisposed();
 
   v8::Handle<ObjectTemplate> proxy_template = global_template;
   i::Handle<i::FunctionTemplateInfo> proxy_constructor;
   i::Handle<i::FunctionTemplateInfo> global_constructor;
@@ skipping 206 matching lines @@
 
 
 Local<String> v8::String::Empty() {
   EnsureInitialized("v8::String::Empty()");
   LOG_API("String::Empty()");
   return Utils::ToLocal(i::Factory::empty_symbol());
 }
 
 
 Local<String> v8::String::New(const char* data, int length) {
+  ENTER_V8;
   EnsureInitialized("v8::String::New()");
   LOG_API("String::New(char)");
   if (length == 0) return Empty();
   if (length == -1) length = strlen(data);
   i::Handle<i::String> result =
       i::Factory::NewStringFromUtf8(i::Vector<const char>(data, length));
   return Utils::ToLocal(result);
 }
 
 
@@ skipping 661 matching lines @@
       reinterpret_cast<HandleScopeImplementer*>(storage);
   List<void**>* blocks_of_archived_thread = thread_local->Blocks();
   v8::ImplementationUtilities::HandleScopeData* handle_data_of_archived_thread =
       &thread_local->handle_scope_data_;
   Iterate(v, blocks_of_archived_thread, handle_data_of_archived_thread);
 
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal