[Isolates] Remove even more statics.

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 159 matching lines @@
   V(bool, is_virtual_frame_in_spilled_scope, false)
 
 #else
 
 #define ISOLATE_PLATFORM_INIT_LIST(V)
 
 #endif
 
 #define ISOLATE_INIT_ARRAY_LIST(V)                                             \
   /* SerializerDeserializer state. */                                          \
-  V(Object*, serialize_partial_snapshot_cache, kPartialSnapshotCacheCapacity)
+  V(Object*, serialize_partial_snapshot_cache, kPartialSnapshotCacheCapacity)  \
+  V(int, jsregexp_static_offsets_vector, kJSRegexpStaticOffsetsVectorSize)
 
 #define ISOLATE_INIT_LIST(V)                                                   \
   /* AssertNoZoneAllocation state. */                                          \
   V(bool, zone_allow_allocation, true)                                         \
   /* SerializerDeserializer state. */                                          \
   V(int, serialize_partial_snapshot_cache_length, 0)                           \
   /* 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)                                                \
+  /* 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();
 
   enum AddressId {
 #define C(name) k_##name,
     ISOLATE_ADDRESS_LIST(C)
     ISOLATE_ADDRESS_LIST_PROF(C)
@@ skipping 315 matching lines @@
   ThreadManager* thread_manager() { return thread_manager_; }
 
   ContextSwitcher* context_switcher() { return context_switcher_; }
 
   void set_context_switcher(ContextSwitcher* switcher) {
     context_switcher_ = switcher;
   }
 
   StringTracker* string_tracker() { return string_tracker_; }
 
+  unibrow::Mapping<unibrow::Ecma262UnCanonicalize>* jsregexp_uncanonicalize() {
+    return &jsregexp_uncanonicalize_;
+  }
+
+  unibrow::Mapping<unibrow::CanonicalizationRange>* jsregexp_canonrange() {
+    return &jsregexp_canonrange_;
+  }
+
+  StringInputBuffer* objects_string_compare_buffer_a() {
+    return &objects_string_compare_buffer_a_;
+  }
+
+  StringInputBuffer* objects_string_compare_buffer_b() {
+    return &objects_string_compare_buffer_b_;
+  }
+
+  StaticResource<StringInputBuffer>* objects_string_input_buffer() {
+    return &objects_string_input_buffer_;
+  }
+
   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_; }
 
   JSObject::SpillInformation* js_spill_information() {
     return &js_spill_information_;
   }
 
   int* code_kind_statistics() { return code_kind_statistics_; }
 #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,
   // but may be called manually if necessary. Not thread-safe; should ideally
   // be called by the same thread responsible for static initialization.
   static void InitOnce();
 
  private:
   Isolate();
 
@@ skipping 57 matching lines @@
   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_;
   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];
   JSObject::SpillInformation js_spill_information_;
   int code_kind_statistics_[Code::NUMBER_OF_KINDS];
 #endif
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   Debugger* debugger_;
@@ skipping 151 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_