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

src/isolate.h

 // Copyright 2010 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 14 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_ISOLATE_H_
 #define V8_ISOLATE_H_
 
 #define V8_USE_TLS_FOR_GLOBAL_ISOLATE
 
 #include "allocation.h"
 #include "apiutils.h"
+#include "builtins.h"
 #include "contexts.h"
 #include "execution.h"
 #include "frames-inl.h"
 #include "frames.h"
 #include "global-handles.h"
 #include "handles.h"
 #include "heap.h"
+#include "runtime.h"
 #include "zone.h"
 #include "../include/v8-debug.h"
 
 namespace v8 {
 namespace internal {
 
+class AstSentinels;
 class Bootstrapper;
 class CompilationCache;
 class ContextSlotCache;
 class ContextSwitcher;
 class CodeRange;
 class CpuFeatures;
 class Deserializer;
+class EmptyStatement;
+class FunctionInfoListener;
 class HandleScopeImplementer;
 class NoAllocationStringAllocator;
 class PreallocatedMemoryThread;
 class SaveContext;
 class StubCache;
 class StringInputBuffer;
 class StringTracker;
 class ScannerCharacterClasses;
 class ThreadVisitor;  // Defined in v8threads.h
 class ThreadManager;
+class VMState;
+
+typedef void* ExternalReferenceRedirector(void* original, bool fp_return);
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 class Debugger;
 #endif
 
 #define RETURN_IF_SCHEDULED_EXCEPTION()              \
   if (Isolate::Current()->has_scheduled_exception()) \
       return Isolate::Current()->PromoteScheduledException()
 
@@ skipping 113 matching lines @@
   /* Assembler state. */                                                       \
   /* A previously allocated buffer of kMinimalBufferSize bytes, or NULL. */    \
   V(byte*, assembler_spare_buffer, NULL)                                       \
   /*This static counter ensures that NativeAllocationCheckers can be nested.*/ \
   V(int, allocation_disallowed, 0)                                             \
   V(FatalErrorCallback, exception_behavior, NULL)                              \
   V(v8::Debug::MessageHandler, message_handler, NULL)                          \
   /* To distinguish the function templates, so that we can find them in the */ \
   /* function cache of the global context. */                                  \
   V(int, next_serial_number, 0)                                                \
+  V(ExternalReferenceRedirector*, external_reference_redirector, NULL)         \
+  V(bool, always_allow_natives_syntax, false)                                  \
+  /* A stack of VM states. */                                                  \
+  V(VMState*, vm_state, NULL)                                                  \
+  /* Part of the state of liveedit. */                                         \
+  V(FunctionInfoListener*, active_function_info_listener, NULL)                \
   /* State for Relocatable. */                                                 \
   V(Relocatable*, relocatable_top, NULL)                                       \
   /* State for CodeEntry in profile-generator. */                              \
   V(unsigned, code_entry_next_call_uid, NULL)                                  \
   ISOLATE_PLATFORM_INIT_LIST(V)
 
 class Isolate {
  public:
   ~Isolate();
 
@@ skipping 139 matching lines @@
   // a builtin object, or a js global object.
   Handle<GlobalObject> global() {
     return Handle<GlobalObject>(context()->global());
   }
 
   // Returns the global proxy object of the current context.
   Object* global_proxy() {
     return context()->global_proxy();
   }
 
-  Handle<JSBuiltinsObject> builtins() {
+  Handle<JSBuiltinsObject> js_builtins_object() {
     return Handle<JSBuiltinsObject>(thread_local_top_.context_->builtins());
   }
 
   static int ArchiveSpacePerThread() { return sizeof(ThreadLocalTop); }
   void FreeThreadResources() { thread_local_top_.Free(); }
 
   // This method is called by the api after operations that may throw
   // exceptions.  If an exception was thrown and not handled by an external
   // handler the exception is scheduled to be rethrown when we return to running
   // JavaScript code.  If an exception is scheduled true is returned.
@@ skipping 179 matching lines @@
   }
 
   StringInputBuffer* objects_string_compare_buffer_b() {
     return &objects_string_compare_buffer_b_;
   }
 
   StaticResource<StringInputBuffer>* objects_string_input_buffer() {
     return &objects_string_input_buffer_;
   }
 
+  AstSentinels* ast_sentinels() { return ast_sentinels_; }
+
+  InlineRuntimeFunctionsTable* inline_runtime_functions_table() {
+    return &inline_runtime_functions_table_;
+  }
+
+  RuntimeState* runtime_state() { return &runtime_state_; }
+
+  StringInputBuffer* liveedit_compare_substrings_buf1() {
+    return &liveedit_compare_substrings_buf1_;
+  }
+
+  StringInputBuffer* liveedit_compare_substrings_buf2() {
+    return &liveedit_compare_substrings_buf2_;
+  }
+
+  StaticResource<SafeStringInputBuffer>* compiler_safe_string_input_buffer() {
+    return &compiler_safe_string_input_buffer_;
+  }
+
+  Builtins* builtins() { return &builtins_; }
+
   void* PreallocatedStorageNew(size_t size);
   void PreallocatedStorageDelete(void* p);
   void PreallocatedStorageInit(size_t size);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   Debugger* debugger() { return debugger_; }
 #endif
 
 #ifdef DEBUG
   HistogramInfo* heap_histograms() { return heap_histograms_; }
@@ skipping 81 matching lines @@
   HandleScopeImplementer* handle_scope_implementer_;
   ScannerCharacterClasses* scanner_character_classes_;
   Zone zone_;
   PreallocatedStorage in_use_list_;
   PreallocatedStorage free_list_;
   bool preallocated_storage_preallocated_;
   StringInputBuffer* write_input_buffer_;
   GlobalHandles* global_handles_;
   ContextSwitcher* context_switcher_;
   ThreadManager* thread_manager_;
+  AstSentinels* ast_sentinels_;
+  InlineRuntimeFunctionsTable inline_runtime_functions_table_;
+  RuntimeState runtime_state_;
+  StringInputBuffer liveedit_compare_substrings_buf1_;
+  StringInputBuffer liveedit_compare_substrings_buf2_;
+  StaticResource<SafeStringInputBuffer> compiler_safe_string_input_buffer_;
+  Builtins builtins_;
   StringTracker* string_tracker_;
   unibrow::Mapping<unibrow::Ecma262UnCanonicalize> jsregexp_uncanonicalize_;
   unibrow::Mapping<unibrow::CanonicalizationRange> jsregexp_canonrange_;
   StringInputBuffer objects_string_compare_buffer_a_;
   StringInputBuffer objects_string_compare_buffer_b_;
   StaticResource<StringInputBuffer> objects_string_input_buffer_;
 
 #ifdef DEBUG
   // A static array of histogram info for each type.
   HistogramInfo heap_histograms_[LAST_TYPE + 1];
@@ skipping 157 matching lines @@
 // Temporary macro to be used to flag classes that are completely converted
 // to be isolate-friendly. Their mix of static/nonstatic methods/fields is
 // correct.
 #define ISOLATED_CLASS class
 
 } }  // namespace v8::internal
 
 #include "allocation-inl.h"
 
 #endif  // V8_ISOLATE_H_