[Isolates] Moved more compilation-related globals (builtins, runtime, &c.)...

src/debug.cc

 // Copyright 2006-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 665 matching lines @@
   obj.Dispose();
   obj.Clear();
 }
 
 
 void Debug::Setup(bool create_heap_objects) {
   ThreadInit();
   if (create_heap_objects) {
     // Get code to handle debug break on return.
     debug_break_return_ =
-        Builtins::builtin(Builtins::Return_DebugBreak);
+        Isolate::Current()->builtins()->builtin(Builtins::Return_DebugBreak);
     ASSERT(debug_break_return_->IsCode());
     // Get code to handle debug break in debug break slots.
     debug_break_slot_ =
-        Builtins::builtin(Builtins::Slot_DebugBreak);
+        Isolate::Current()->builtins()->builtin(Builtins::Slot_DebugBreak);
     ASSERT(debug_break_slot_->IsCode());
   }
 }
 
 
 void Debug::HandleWeakDebugInfo(v8::Persistent<v8::Value> obj, void* data) {
   DebugInfoListNode* node = reinterpret_cast<DebugInfoListNode*>(data);
   RemoveDebugInfo(node->debug_info());
 #ifdef DEBUG
   node = Debug::debug_info_list_;
@@ skipping 248 matching lines @@
 
     // Clear all current stepping setup.
     ClearStepping();
 
     // Set up for the remaining steps.
     PrepareStep(step_action, step_count);
   }
 
   if (thread_local_.frames_are_dropped_) {
     // We must have been calling IC stub. Do not return there anymore.
-    Code* plain_return = Builtins::builtin(Builtins::PlainReturn_LiveEdit);
+    Code* plain_return =
+        Isolate::Current()->builtins()->builtin(Builtins::PlainReturn_LiveEdit);
     thread_local_.after_break_target_ = plain_return->entry();
   } else {
     SetAfterBreakTarget(frame);
   }
 
   return HEAP->undefined_value();
 }
 
 
 // Check the break point objects for whether one or more are actually
@@ skipping 45 matching lines @@
   Handle<Object> break_id = Factory::NewNumberFromInt(Debug::break_id());
 
   // Call HandleBreakPointx.
   bool caught_exception = false;
   const int argc = 2;
   Object** argv[argc] = {
     break_id.location(),
     reinterpret_cast<Object**>(break_point_object.location())
   };
   Handle<Object> result = Execution::TryCall(check_break_point,
-                                             Isolate::Current()->builtins(),
-                                             argc, argv, &caught_exception);
+      Isolate::Current()->js_builtins_object(), argc, argv, &caught_exception);
 
   // If exception or non boolean result handle as not triggered
   if (caught_exception || !result->IsBoolean()) {
     return false;
   }
 
   // Return whether the break point is triggered.
   return *result == HEAP->true_value();
 }
 
@@ skipping 382 matching lines @@
 Handle<Code> Debug::FindDebugBreak(Handle<Code> code, RelocInfo::Mode mode) {
   // Find the builtin debug break function matching the calling convention
   // used by the call site.
   if (code->is_inline_cache_stub()) {
     switch (code->kind()) {
       case Code::CALL_IC:
       case Code::KEYED_CALL_IC:
         return ComputeCallDebugBreak(code->arguments_count(), code->kind());
 
       case Code::LOAD_IC:
-        return Handle<Code>(Builtins::builtin(Builtins::LoadIC_DebugBreak));
+        return Handle<Code>(Isolate::Current()->builtins()->builtin(
+            Builtins::LoadIC_DebugBreak));
 
       case Code::STORE_IC:
-        return Handle<Code>(Builtins::builtin(Builtins::StoreIC_DebugBreak));
+        return Handle<Code>(Isolate::Current()->builtins()->builtin(
+            Builtins::StoreIC_DebugBreak));
 
       case Code::KEYED_LOAD_IC:
         return Handle<Code>(
-            Builtins::builtin(Builtins::KeyedLoadIC_DebugBreak));
+            Isolate::Current()->builtins()->builtin(
+                Builtins::KeyedLoadIC_DebugBreak));
 
       case Code::KEYED_STORE_IC:
         return Handle<Code>(
-            Builtins::builtin(Builtins::KeyedStoreIC_DebugBreak));
+            Isolate::Current()->builtins()->builtin(
+                Builtins::KeyedStoreIC_DebugBreak));
 
       default:
         UNREACHABLE();
     }
   }
   if (RelocInfo::IsConstructCall(mode)) {
     Handle<Code> result =
-        Handle<Code>(Builtins::builtin(Builtins::ConstructCall_DebugBreak));
+        Handle<Code>(Isolate::Current()->builtins()->builtin(
+            Builtins::ConstructCall_DebugBreak));
     return result;
   }
   if (code->kind() == Code::STUB) {
     ASSERT(code->major_key() == CodeStub::CallFunction ||
            code->major_key() == CodeStub::StackCheck);
     Handle<Code> result =
-        Handle<Code>(Builtins::builtin(Builtins::StubNoRegisters_DebugBreak));
+        Handle<Code>(Isolate::Current()->builtins()->builtin(
+            Builtins::StubNoRegisters_DebugBreak));
     return result;
   }
 
   UNREACHABLE();
   return Handle<Code>::null();
 }
 
 
 // Simple function for returning the source positions for active break points.
 Handle<Object> Debug::GetSourceBreakLocations(
@@ skipping 47 matching lines @@
     }
     fp = it.frame()->fp();
   }
 
   // Flood the function with one-shot break points if it is called from where
   // step into was requested.
   if (fp == Debug::step_in_fp()) {
     // Don't allow step into functions in the native context.
     if (!function->IsBuiltin()) {
       if (function->shared()->code() ==
-          Builtins::builtin(Builtins::FunctionApply) ||
+          Isolate::Current()->builtins()->builtin(Builtins::FunctionApply) ||
           function->shared()->code() ==
-          Builtins::builtin(Builtins::FunctionCall)) {
+          Isolate::Current()->builtins()->builtin(Builtins::FunctionCall)) {
         // Handle function.apply and function.call separately to flood the
         // function to be called and not the code for Builtins::FunctionApply or
         // Builtins::FunctionCall. The receiver of call/apply is the target
         // function.
         if (!holder.is_null() && holder->IsJSFunction() &&
             !JSFunction::cast(*holder)->IsBuiltin()) {
           Handle<SharedFunctionInfo> shared_info(
               JSFunction::cast(*holder)->shared());
           Debug::FloodWithOneShot(shared_info);
         }
@@ skipping 617 matching lines @@
   // Wrap the script object in a proper JS object before passing it
   // to JavaScript.
   Handle<JSValue> wrapper = GetScriptWrapper(script);
 
   // Call UpdateScriptBreakPoints expect no exceptions.
   bool caught_exception = false;
   const int argc = 1;
   Object** argv[argc] = { reinterpret_cast<Object**>(wrapper.location()) };
   Handle<Object> result = Execution::TryCall(
       Handle<JSFunction>::cast(update_script_break_points),
-      Isolate::Current()->builtins(), argc, argv,
+      Isolate::Current()->js_builtins_object(), argc, argv,
       &caught_exception);
   if (caught_exception) {
     return;
   }
   // Bail out based on state or if there is no listener for this event
   if (in_debugger && (after_compile_flags & SEND_WHEN_DEBUGGING) == 0) return;
   if (!Debugger::EventActive(v8::AfterCompile)) return;
 
   // Create the compile state object.
   Handle<Object> event_data = MakeCompileEvent(script,
@@ skipping 816 matching lines @@
     {
       Locker locker;
       Isolate::Current()->debugger()->CallMessageDispatchHandler();
     }
   }
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal