Miscellaneous profile-driven Isolate plumbing.

src/d8.cc

 // Copyright 2012 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 250 matching lines @@
     Handle<String> str_obj = args[i]->ToString();
     if (try_catch.HasCaught()) return try_catch.ReThrow();
 
     v8::String::Utf8Value str(str_obj);
     int n = static_cast<int>(fwrite(*str, sizeof(**str), str.length(), stdout));
     if (n != str.length()) {
       printf("Error in fwrite\n");
       Exit(1);
     }
   }
-  return Undefined();
+  return Undefined(args.GetIsolate());
 }
 
 
 Handle<Value> Shell::EnableProfiler(const Arguments& args) {
   V8::ResumeProfiler();
-  return Undefined();
+  return Undefined(args.GetIsolate());
 }
 
 
 Handle<Value> Shell::DisableProfiler(const Arguments& args) {
   V8::PauseProfiler();
-  return Undefined();
+  return Undefined(args.GetIsolate());
 }
 
 
 Handle<Value> Shell::Read(const Arguments& args) {
   String::Utf8Value file(args[0]);
   if (*file == NULL) {
     return Throw("Error loading file");
   }
   Handle<String> source = ReadFile(args.GetIsolate(), *file);
   if (source.IsEmpty()) {
@@ skipping 41 matching lines @@
       return Throw("Error loading file");
     }
     Handle<String> source = ReadFile(args.GetIsolate(), *file);
     if (source.IsEmpty()) {
       return Throw("Error loading file");
     }
     if (!ExecuteString(source, String::New(*file), false, true)) {
       return Throw("Error executing file");
     }
   }
-  return Undefined();
+  return Undefined(args.GetIsolate());
 }
 
 static int32_t convertToInt(Local<Value> value_in, TryCatch* try_catch) {
   if (value_in->IsInt32()) {
     return value_in->Int32Value();
   }
 
   Local<Value> number = value_in->ToNumber();
   if (try_catch->HasCaught()) return 0;
 
@@ skipping 44 matching lines @@
 
   buffer->SetHiddenValue(Symbols::ArrayBufferMarkerPropName(isolate), True());
   Persistent<Object> persistent_array =
       Persistent<Object>::New(isolate, buffer);
   persistent_array.MakeWeak(isolate, data, ExternalArrayWeakCallback);
   persistent_array.MarkIndependent(isolate);
   V8::AdjustAmountOfExternalAllocatedMemory(length);
 
   buffer->SetIndexedPropertiesToExternalArrayData(
       data, v8::kExternalByteArray, length);
-  buffer->Set(Symbols::byteLength(isolate), Int32::New(length), ReadOnly);
+  buffer->Set(Symbols::byteLength(isolate),
+              Int32::New(length, isolate),
+              ReadOnly);
 
   return buffer;
 }
 
 
 Handle<Value> Shell::ArrayBuffer(const Arguments& args) {
   if (!args.IsConstructCall()) {
     Handle<Value>* rec_args = new Handle<Value>[args.Length()];
     for (int i = 0; i < args.Length(); ++i) rec_args[i] = args[i];
     Handle<Value> result = args.Callee()->NewInstance(args.Length(), rec_args);
@@ skipping 23 matching lines @@
   ASSERT(element_size == 1 || element_size == 2 ||
          element_size == 4 || element_size == 8);
   ASSERT(byteLength == length * element_size);
 
   void* data = buffer->GetIndexedPropertiesExternalArrayData();
   ASSERT(data != NULL);
 
   array->SetIndexedPropertiesToExternalArrayData(
       static_cast<uint8_t*>(data) + byteOffset, type, length);
   array->SetHiddenValue(Symbols::ArrayMarkerPropName(isolate),
-                        Int32::New(type));
-  array->Set(Symbols::byteLength(isolate), Int32::New(byteLength), ReadOnly);
-  array->Set(Symbols::byteOffset(isolate), Int32::New(byteOffset), ReadOnly);
-  array->Set(Symbols::length(isolate), Int32::New(length), ReadOnly);
-  array->Set(Symbols::BYTES_PER_ELEMENT(isolate), Int32::New(element_size));
-  array->Set(Symbols::buffer(isolate), buffer, ReadOnly);
+                        Int32::New(type, isolate));
+  array->Set(Symbols::byteLength(isolate),
+             Int32::New(byteLength, isolate),
+             ReadOnly);
+  array->Set(Symbols::byteOffset(isolate),
+             Int32::New(byteOffset, isolate),
+             ReadOnly);
+  array->Set(Symbols::length(isolate),
+             Int32::New(length, isolate),
+             ReadOnly);
+  array->Set(Symbols::BYTES_PER_ELEMENT(isolate),
+             Int32::New(element_size, isolate));
+  array->Set(Symbols::buffer(isolate),
+             buffer,
+             ReadOnly);
 
   return array;
 }
 
 
 Handle<Value> Shell::CreateExternalArray(const Arguments& args,
                                          ExternalArrayType type,
                                          int32_t element_size) {
   Isolate* isolate = args.GetIsolate();
   if (!args.IsConstructCall()) {
@@ skipping 72 matching lines @@
       // Construct from size.
       length = convertToUint(args[0], &try_catch);
       if (try_catch.HasCaught()) return try_catch.ReThrow();
     }
     byteLength = length * element_size;
     byteOffset = 0;
 
     Handle<Object> global = Context::GetCurrent()->Global();
     Handle<Value> array_buffer = global->Get(Symbols::ArrayBuffer(isolate));
     ASSERT(!try_catch.HasCaught() && array_buffer->IsFunction());
-    Handle<Value> buffer_args[] = { Uint32::New(byteLength) };
+    Handle<Value> buffer_args[] = { Uint32::New(byteLength, isolate) };
     Handle<Value> result = Handle<Function>::Cast(array_buffer)->NewInstance(
         1, buffer_args);
     if (try_catch.HasCaught()) return result;
     buffer = result->ToObject();
   }
 
   Handle<Object> array =
       CreateExternalArray(isolate, args.This(), buffer, type, length,
                           byteLength, byteOffset, element_size);
 
@@ skipping 44 matching lines @@
   } else {
     end = convertToInt(args[1], &try_catch);
     if (try_catch.HasCaught()) return try_catch.ReThrow();
     if (end < 0) end += length;
     if (end < 0) end = 0;
     if (end > length) end = length;
     if (end < begin) end = begin;
   }
 
   Local<Function> constructor = Local<Function>::Cast(self->GetConstructor());
-  Handle<Value> new_args[] = { Uint32::New(end - begin) };
+  Handle<Value> new_args[] = { Uint32::New(end - begin, isolate) };
   Handle<Value> result = constructor->NewInstance(1, new_args);
   if (try_catch.HasCaught()) return result;
   Handle<Object> buffer = result->ToObject();
   uint8_t* dest =
       static_cast<uint8_t*>(buffer->GetIndexedPropertiesExternalArrayData());
   uint8_t* src = begin + static_cast<uint8_t*>(
       self->GetIndexedPropertiesExternalArrayData());
   memcpy(dest, src, end - begin);
 
   return buffer;
@@ skipping 46 matching lines @@
     if (end < 0) end = 0;
     if (end > length) end = length;
     if (end < begin) end = begin;
   }
 
   length = end - begin;
   byteOffset += begin * element_size;
 
   Local<Function> constructor = Local<Function>::Cast(self->GetConstructor());
   Handle<Value> construct_args[] = {
-    buffer, Uint32::New(byteOffset), Uint32::New(length)
+    buffer, Uint32::New(byteOffset, isolate), Uint32::New(length, isolate)
   };
   return constructor->NewInstance(3, construct_args);
 }
 
 
 Handle<Value> Shell::ArraySet(const Arguments& args) {
   TryCatch try_catch;
 
   if (!args.This()->IsObject()) {
     return Throw("'set' invoked on non-object receiver");
@@ skipping 121 matching lines @@
       for (int k = i; k <= j; ++k) {
         self->Set(offset + k, temp[k - i]);
       }
     } else {
       // Different backing stores, safe to copy element-wise sequentially.
       for (int i = 0; i < source_length; ++i)
         self->Set(offset + i, source->Get(i));
     }
   }
 
-  return Undefined();
+  return Undefined(args.GetIsolate());
 }
 
 
 void Shell::ExternalArrayWeakCallback(v8::Isolate* isolate,
                                       Persistent<Value> object,
                                       void* data) {
   HandleScope scope;
   int32_t length =
       object->ToObject()->Get(Symbols::byteLength(isolate))->Uint32Value();
   V8::AdjustAmountOfExternalAllocatedMemory(-length);
@@ skipping 45 matching lines @@
 }
 
 
 Handle<Value> Shell::Uint8ClampedArray(const Arguments& args) {
   return CreateExternalArray(args, kExternalPixelArray, sizeof(uint8_t));
 }
 
 
 Handle<Value> Shell::Yield(const Arguments& args) {
   v8::Unlocker unlocker(args.GetIsolate());
-  return Undefined();
+  return Undefined(args.GetIsolate());
 }
 
 
 Handle<Value> Shell::Quit(const Arguments& args) {
   int exit_code = args[0]->Int32Value();
   OnExit();
   exit(exit_code);
-  return Undefined();
+  return Undefined(args.GetIsolate());
 }
 
 
 Handle<Value> Shell::Version(const Arguments& args) {
   return String::New(V8::GetVersion());
 }
 
 
 void Shell::ReportException(v8::TryCatch* try_catch) {
   HandleScope handle_scope;
@@ skipping 182 matching lines @@
   Counter* counter = reinterpret_cast<Counter*>(histogram);
   counter->AddSample(sample);
 }
 
 
 void Shell::InstallUtilityScript(Isolate* isolate) {
   Locker lock(isolate);
   HandleScope scope;
   // If we use the utility context, we have to set the security tokens so that
   // utility, evaluation and debug context can all access each other.
-  utility_context_->SetSecurityToken(Undefined());
-  evaluation_context_->SetSecurityToken(Undefined());
+  utility_context_->SetSecurityToken(Undefined(isolate));
+  evaluation_context_->SetSecurityToken(Undefined(isolate));
   Context::Scope utility_scope(utility_context_);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   if (i::FLAG_debugger) printf("JavaScript debugger enabled\n");
   // Install the debugger object in the utility scope
   i::Debug* debug = i::Isolate::Current()->debug();
   debug->Load();
   i::Handle<i::JSObject> js_debug
       = i::Handle<i::JSObject>(debug->debug_context()->global_object());
   utility_context_->Global()->Set(String::New("$debug"),
@@ skipping 332 matching lines @@
   buffer->SetHiddenValue(Symbols::ArrayBufferMarkerPropName(isolate), True());
   Persistent<Object> persistent_buffer =
       Persistent<Object>::New(isolate, buffer);
   persistent_buffer.MakeWeak(isolate, data, ExternalArrayWeakCallback);
   persistent_buffer.MarkIndependent(isolate);
   V8::AdjustAmountOfExternalAllocatedMemory(length);
 
   buffer->SetIndexedPropertiesToExternalArrayData(
       data, kExternalUnsignedByteArray, length);
   buffer->Set(Symbols::byteLength(isolate),
-      Int32::New(static_cast<int32_t>(length)), ReadOnly);
+      Int32::New(static_cast<int32_t>(length), isolate), ReadOnly);
   return buffer;
 }
 
 
 #ifndef V8_SHARED
 static char* ReadToken(char* data, char token) {
   char* next = i::OS::StrChr(data, token);
   if (next != NULL) {
     *next = '\0';
     return (next + 1);
@@ skipping 497 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif