[Isolates] Statics 7: ExternalReference*/Simulator/dtoa...

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 27 matching lines @@
 #include "frames-inl.h"
 #include "frames.h"
 #include "global-handles.h"
 #include "handles.h"
 #include "heap.h"
 #include "regexp-stack.h"
 #include "runtime.h"
 #include "zone.h"
 #include "../include/v8-debug.h"
 
+
+#if !defined(__arm__) && defined(V8_TARGET_ARCH_ARM)
+namespace assembler {
+namespace arm {
+class Redirection;
+}
+}
+#endif
+
+
 namespace v8 {
 namespace internal {
 
 class AstSentinels;
 class Bootstrapper;
 class CodeGenerator;
 class CompilationCache;
 class ContextSlotCache;
 class ContextSwitcher;
 class CodeRange;
 class Counters;
 class CpuFeatures;
 class CpuProfiler;
 class Deserializer;
 class EmptyStatement;
+class ExternalReferenceTable;
 class FunctionInfoListener;
 class HandleScopeImplementer;
 class HeapProfiler;
 class InlineRuntimeFunctionsTable;
 class NoAllocationStringAllocator;
 class PreallocatedMemoryThread;
 class ProducerHeapProfile;
 class RegExpStack;
 class SaveContext;
 class StubCache;
@@ skipping 117 matching lines @@
  private:
   Address try_catch_handler_address_;
 };
 
 #if defined(V8_TARGET_ARCH_ARM)
 
 #define ISOLATE_PLATFORM_INIT_LIST(V)                                          \
   /* VirtualFrame::SpilledScope state */                                       \
   V(bool, is_virtual_frame_in_spilled_scope, false)
 
+#if !defined(__arm__)
+class HashMap;
+#endif
+
 #else
 
 #define ISOLATE_PLATFORM_INIT_LIST(V)
 
 #endif
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 
 #define ISOLATE_DEBUGGER_INIT_LIST(V)                                          \
   V(v8::Debug::EventCallback, debug_event_callback, NULL)                      \
@@ skipping 59 matching lines @@
   /* State for Relocatable. */                                                 \
   V(Relocatable*, relocatable_top, NULL)                                       \
   /* State for CodeEntry in profile-generator. */                              \
   V(unsigned, code_entry_next_call_uid, NULL)                                  \
   V(CodeGenerator*, current_code_generator, NULL)                              \
   V(bool, jump_target_compiling_deferred_code, false)                          \
   V(DebugObjectCache*, string_stream_debug_object_cache, NULL)                 \
   V(Object*, string_stream_current_security_token, NULL)                       \
   /* TODO(isolates): Release this on destruction? */                           \
   V(int*, irregexp_interpreter_backtrack_stack_cache, NULL)                    \
+  /* Serializer state. */                                                      \
+  V(ExternalReferenceTable*, external_reference_table, NULL)                   \
   ISOLATE_PLATFORM_INIT_LIST(V)                                                \
   ISOLATE_LOGGING_INIT_LIST(V)                                                 \
   ISOLATE_DEBUGGER_INIT_LIST(V)
 
 class Isolate {
  public:
   ~Isolate();
 
   enum AddressId {
 #define C(name) k_##name,
@@ skipping 408 matching lines @@
 #ifdef DEBUG
   HistogramInfo* heap_histograms() { return heap_histograms_; }
 
   JSObject::SpillInformation* js_spill_information() {
     return &js_spill_information_;
   }
 
   int* code_kind_statistics() { return code_kind_statistics_; }
 #endif
 
+#if defined(V8_TARGET_ARCH_ARM) && !defined(__arm__)
+  v8::internal::Thread::LocalStorageKey* simulator_key() {
+    return &simulator_key_;
+  }
+
+  bool simulator_initialized() { return simulator_initialized_; }
+  void set_simulator_initialized(bool initialized) {
+    simulator_initialized_ = initialized;
+  }
+
+  HashMap* simulator_i_cache() { return simulator_i_cache_; }
+  void set_simulator_i_cache(HashMap* hash_map) {
+    simulator_i_cache_ = hash_map;
+  }
+
+  assembler::arm::Redirection* simulator_redirection() {
+    return simulator_redirection_;
+  }
+  void set_simulator_redirection(assembler::arm::Redirection* redirection) {
+    simulator_redirection_ = redirection;
+  }
+#endif
+
   bool IsDefaultIsolate() { return this == global_isolate_; }
 
   // SerializerDeserializer state.
   static const int kPartialSnapshotCacheCapacity = 1300;
 
   static const int kJSRegexpStaticOffsetsVectorSize = 50;
 
   static int number_of_isolates() { return number_of_isolates_; }
 
   // Initialize process-wide state. Generally called from a static initializer,
@@ skipping 84 matching lines @@
   StringInputBuffer objects_string_compare_buffer_a_;
   StringInputBuffer objects_string_compare_buffer_b_;
   StaticResource<StringInputBuffer> objects_string_input_buffer_;
   unibrow::Mapping<unibrow::Ecma262Canonicalize>
       regexp_macro_assembler_canonicalize_;
   RegExpStack* regexp_stack_;
   unibrow::Mapping<unibrow::Ecma262Canonicalize> interp_canonicalize_mapping_;
   ZoneObjectList frame_element_constant_list_;
   ZoneObjectList result_constant_list_;
 
+#if defined(V8_TARGET_ARCH_ARM) && !defined(__arm__)
+  // Create one simulator per thread and keep it in thread local storage.
+  v8::internal::Thread::LocalStorageKey simulator_key_;
+  bool simulator_initialized_;
+  HashMap* simulator_i_cache_;
+  assembler::arm::Redirection* simulator_redirection_;
+#endif
 
 #ifdef DEBUG
   // A static array of histogram info for each type.
   HistogramInfo heap_histograms_[LAST_TYPE + 1];
   JSObject::SpillInformation js_spill_information_;
   int code_kind_statistics_[Code::NUMBER_OF_KINDS];
 #endif
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   Debugger* debugger_;
@@ skipping 159 matching lines @@
 #define ISOLATED_CLASS class
 
 } }  // namespace v8::internal
 
 // TODO(isolates): Get rid of these -inl.h includes and place them only where
 //                 they're needed.
 #include "allocation-inl.h"
 #include "zone-inl.h"
 
 #endif  // V8_ISOLATE_H_