Revert "Remove fields from Isolate in Product mode"

runtime/vm/isolate.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_ISOLATE_H_
 #define RUNTIME_VM_ISOLATE_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/atomic.h"
@@ skipping 205 matching lines @@
   Thread* mutator_thread() const;
 
   // Mutator thread is not scheduled if NULL or no heap is attached
   // to it. The latter only occurs when the mutator thread object
   // is unscheduled by the isolate (or never scheduled).
   bool IsMutatorThreadScheduled() {
     return mutator_thread_ != NULL && mutator_thread_->heap() != NULL;
   }
 
   const char* name() const { return name_; }
-
-#if !defined(PRODUCT)
   const char* debugger_name() const { return debugger_name_; }
   void set_debugger_name(const char* name);
+
   int64_t UptimeMicros() const;
-#endif  // !defined(PRODUCT)
 
   Dart_Port main_port() const { return main_port_; }
   void set_main_port(Dart_Port port) {
     ASSERT(main_port_ == 0);  // Only set main port once.
     main_port_ = port;
   }
   Dart_Port origin_id() const { return origin_id_; }
   void set_origin_id(Dart_Port id) {
     ASSERT((id == main_port_ && origin_id_ == 0) || (origin_id_ == main_port_));
     origin_id_ = id;
@@ skipping 178 matching lines @@
     return shutdown_callback_;
   }
 
   static void SetCleanupCallback(Dart_IsolateCleanupCallback cb) {
     cleanup_callback_ = cb;
   }
   static Dart_IsolateCleanupCallback CleanupCallback() {
     return cleanup_callback_;
   }
 
-#if !defined(PRODUCT)
   void set_object_id_ring(ObjectIdRing* ring) { object_id_ring_ = ring; }
   ObjectIdRing* object_id_ring() { return object_id_ring_; }
-#endif  // !defined(PRODUCT)
 
   void AddPendingDeopt(uword fp, uword pc);
   uword FindPendingDeopt(uword fp) const;
   void ClearPendingDeoptsAtOrBelow(uword fp) const;
   MallocGrowableArray<PendingLazyDeopt>* pending_deopts() const {
     return pending_deopts_;
   }
   bool IsDeoptimizing() const { return deopt_context_ != NULL; }
   DeoptContext* deopt_context() const { return deopt_context_; }
   void set_deopt_context(DeoptContext* value) {
@@ skipping 18 matching lines @@
           "enable_background_compiler.");
     }
   }
 
   void disable_background_compiler() { background_compiler_disabled_depth_++; }
 
   bool is_background_compiler_disabled() const {
     return background_compiler_disabled_depth_ > 0;
   }
 
-#if !defined(PRODUCT)
   void UpdateLastAllocationProfileAccumulatorResetTimestamp() {
     last_allocationprofile_accumulator_reset_timestamp_ =
         OS::GetCurrentTimeMillis();
   }
 
   int64_t last_allocationprofile_accumulator_reset_timestamp() const {
     return last_allocationprofile_accumulator_reset_timestamp_;
   }
 
   void UpdateLastAllocationProfileGCTimestamp() {
     last_allocationprofile_gc_timestamp_ = OS::GetCurrentTimeMillis();
   }
 
   int64_t last_allocationprofile_gc_timestamp() const {
     return last_allocationprofile_gc_timestamp_;
   }
-#endif  // !defined(PRODUCT)
 
   intptr_t BlockClassFinalization() {
     ASSERT(defer_finalization_count_ >= 0);
     return defer_finalization_count_++;
   }
 
   intptr_t UnblockClassFinalization() {
     ASSERT(defer_finalization_count_ > 0);
     return defer_finalization_count_--;
   }
 
   bool AllowClassFinalization() {
     ASSERT(defer_finalization_count_ >= 0);
     return defer_finalization_count_ == 0;
   }
 
 #ifndef PRODUCT
   void PrintJSON(JSONStream* stream, bool ref = true);
 #endif
 
   // Mutator thread is used to aggregate compiler stats.
   CompilerStats* aggregate_compiler_stats() {
     return mutator_thread()->compiler_stats();
   }
 
-#if !defined(PRODUCT)
   VMTagCounters* vm_tag_counters() { return &vm_tag_counters_; }
 
   bool IsReloading() const { return reload_context_ != NULL; }
 
   IsolateReloadContext* reload_context() { return reload_context_; }
 
   void DeleteReloadContext();
 
   bool HasAttemptedReload() const { return has_attempted_reload_; }
 
   bool CanReload() const;
 
   void set_last_reload_timestamp(int64_t value) {
     last_reload_timestamp_ = value;
   }
   int64_t last_reload_timestamp() const { return last_reload_timestamp_; }
-#endif  // !defined(PRODUCT)
 
   bool IsPaused() const;
 
-#if !defined(PRODUCT)
   bool should_pause_post_service_request() const {
     return should_pause_post_service_request_;
   }
   void set_should_pause_post_service_request(
       bool should_pause_post_service_request) {
     should_pause_post_service_request_ = should_pause_post_service_request;
   }
-#endif  // !defined(PRODUCT)
 
   RawError* PausePostRequest();
 
   uword user_tag() const { return user_tag_; }
   static intptr_t user_tag_offset() { return OFFSET_OF(Isolate, user_tag_); }
   static intptr_t current_tag_offset() {
     return OFFSET_OF(Isolate, current_tag_);
   }
   static intptr_t default_tag_offset() {
     return OFFSET_OF(Isolate, default_tag_);
   }
 
-#if !defined(PRODUCT)
 #define ISOLATE_METRIC_ACCESSOR(type, variable, name, unit)                    \
   type* Get##variable##Metric() { return &metric_##variable##_; }
   ISOLATE_METRIC_LIST(ISOLATE_METRIC_ACCESSOR);
 #undef ISOLATE_METRIC_ACCESSOR
-#endif  // !defined(PRODUCT)
 
   static intptr_t IsolateListLength();
 
   RawGrowableObjectArray* tag_table() const { return tag_table_; }
   void set_tag_table(const GrowableObjectArray& value);
 
   RawUserTag* current_tag() const { return current_tag_; }
   void set_current_tag(const UserTag& tag);
 
   RawUserTag* default_tag() const { return default_tag_; }
   void set_default_tag(const UserTag& tag);
 
   void set_ic_miss_code(const Code& code);
 
-#if !defined(PRODUCT)
   Metric* metrics_list_head() { return metrics_list_head_; }
+
   void set_metrics_list_head(Metric* metric) { metrics_list_head_ = metric; }
-#endif  // !defined(PRODUCT)
 
   RawGrowableObjectArray* deoptimized_code_array() const {
     return deoptimized_code_array_;
   }
   void set_deoptimized_code_array(const GrowableObjectArray& value);
   void TrackDeoptimizedCode(const Code& code);
 
   // Also sends a paused at exit event over the service protocol.
   void SetStickyError(RawError* sticky_error);
 
@@ skipping 91 matching lines @@
 
   static void KillAllIsolates(LibMsgId msg_id);
   static void KillIfExists(Isolate* isolate, LibMsgId msg_id);
 
   static void DisableIsolateCreation();
   static void EnableIsolateCreation();
   static bool IsolateCreationEnabled();
 
   void StopBackgroundCompiler();
 
-#if !defined(PRODUCT)
   intptr_t reload_every_n_stack_overflow_checks() const {
     return reload_every_n_stack_overflow_checks_;
   }
-#endif  // !defined(PRODUCT)
 
   HandlerInfoCache* handler_info_cache() { return &handler_info_cache_; }
 
   CatchEntryStateCache* catch_entry_state_cache() {
     return &catch_entry_state_cache_;
   }
 
   void MaybeIncreaseReloadEveryNStackOverflowChecks();
 
  private:
@@ skipping 17 matching lines @@
 
   void ProfileIdle();
 
   // Visit all object pointers. Caller must ensure concurrent sweeper is not
   // running, and the visitor must not allocate.
   void VisitObjectPointers(ObjectPointerVisitor* visitor, bool validate_frames);
   void VisitStackPointers(ObjectPointerVisitor* visitor, bool validate_frames);
 
   void set_user_tag(uword tag) { user_tag_ = tag; }
 
-#if !defined(PRODUCT)
   RawGrowableObjectArray* GetAndClearPendingServiceExtensionCalls();
   RawGrowableObjectArray* pending_service_extension_calls() const {
     return pending_service_extension_calls_;
   }
   void set_pending_service_extension_calls(const GrowableObjectArray& value);
   RawGrowableObjectArray* registered_service_extension_handlers() const {
     return registered_service_extension_handlers_;
   }
   void set_registered_service_extension_handlers(
       const GrowableObjectArray& value);
-#endif  // !defined(PRODUCT)
 
   Monitor* threads_lock() const;
   Thread* ScheduleThread(bool is_mutator, bool bypass_safepoint = false);
   void UnscheduleThread(Thread* thread,
                         bool is_mutator,
                         bool bypass_safepoint = false);
 
   // DEPRECATED: Use Thread's methods instead. During migration, these default
   // to using the mutator thread (which must also be the current thread).
   Zone* current_zone() const {
@@ skipping 10 matching lines @@
   StoreBuffer* store_buffer_;
   Heap* heap_;
   uword user_tag_;
   RawUserTag* current_tag_;
   RawUserTag* default_tag_;
   RawCode* ic_miss_code_;
   ObjectStore* object_store_;
   ClassTable class_table_;
   bool single_step_;
 
-  // Try to keep boolean fields together.
-  bool errors_fatal_;
-  bool is_runnable_;
-  bool is_service_isolate_;
-  bool compilation_allowed_;
-  bool all_classes_finalized_;
-  bool remapping_cids_;
-
-// Fields that aren't needed in a product build go here with boolean flags at
-// the top.
-#if !defined(PRODUCT)
-  bool resume_request_;
-  bool has_attempted_reload_;  // Has a reload ever been attempted?
-  // Should we pause in the debug message loop after this request?
-  bool should_pause_post_service_request_;
-
+  ThreadRegistry* thread_registry_;
+  SafepointHandler* safepoint_handler_;
+  Dart_MessageNotifyCallback message_notify_callback_;
+  char* name_;
   char* debugger_name_;
   int64_t start_time_micros_;
-  Debugger* debugger_;
-  int64_t last_resume_timestamp_;
+  Dart_Port main_port_;
+  Dart_Port origin_id_;  // Isolates created by spawnFunc have some origin id.
+  uint64_t pause_capability_;
+  uint64_t terminate_capability_;
+  bool errors_fatal_;
+  void* init_callback_data_;
+  Dart_EnvironmentCallback environment_callback_;
+  Dart_LibraryTagHandler library_tag_handler_;
+  ApiState* api_state_;
+  NOT_IN_PRODUCT(Debugger* debugger_);
+  NOT_IN_PRODUCT(bool resume_request_);
+  NOT_IN_PRODUCT(int64_t last_resume_timestamp_);
+  Random random_;
+  Simulator* simulator_;
+  Mutex* mutex_;          // Protects compiler stats.
+  Mutex* symbols_mutex_;  // Protects concurrent access to the symbol table.
+  Mutex* type_canonicalization_mutex_;      // Protects type canonicalization.
+  Mutex* constant_canonicalization_mutex_;  // Protects const canonicalization.
+  Mutex* megamorphic_lookup_mutex_;  // Protects megamorphic table lookup.
+  MessageHandler* message_handler_;
+  IsolateSpawnState* spawn_state_;
+  bool is_runnable_;
+  Dart_GcPrologueCallback gc_prologue_callback_;
+  Dart_GcEpilogueCallback gc_epilogue_callback_;
+  intptr_t defer_finalization_count_;
+  MallocGrowableArray<PendingLazyDeopt>* pending_deopts_;
+  DeoptContext* deopt_context_;
+
+  bool is_service_isolate_;
 
 // Isolate-specific flags.
+#if !defined(PRODUCT)
 #define DECLARE_FIELD(name, isolate_flag_name, flag_name) bool name##_;
   ISOLATE_FLAG_LIST(DECLARE_FIELD)
 #undef DECLARE_FIELD
+#endif  // !defined(PRODUCT)
 
   // Timestamps of last operation via service.
   int64_t last_allocationprofile_accumulator_reset_timestamp_;
   int64_t last_allocationprofile_gc_timestamp_;
 
+  // Ring buffer of objects assigned an id.
+  ObjectIdRing* object_id_ring_;
+
   VMTagCounters vm_tag_counters_;
+  RawGrowableObjectArray* tag_table_;
+
+  RawGrowableObjectArray* deoptimized_code_array_;
+
+  RawError* sticky_error_;
+
+  // Background compilation.
+  BackgroundCompiler* background_compiler_;
+  intptr_t background_compiler_disabled_depth_;
 
   // We use 6 list entries for each pending service extension calls.
   enum {
     kPendingHandlerIndex = 0,
     kPendingMethodNameIndex,
     kPendingKeysIndex,
     kPendingValuesIndex,
     kPendingReplyPortIndex,
     kPendingIdIndex,
     kPendingEntrySize
   };
   RawGrowableObjectArray* pending_service_extension_calls_;
 
   // We use 2 list entries for each registered extension handler.
   enum {
     kRegisteredNameIndex = 0,
     kRegisteredHandlerIndex,
     kRegisteredEntrySize
   };
   RawGrowableObjectArray* registered_service_extension_handlers_;
 
   Metric* metrics_list_head_;
 
+  bool compilation_allowed_;
+  bool all_classes_finalized_;
+  bool remapping_cids_;
+
+  // Isolate list next pointer.
+  Isolate* next_;
+
   // Used to wake the isolate when it is in the pause event loop.
   Monitor* pause_loop_monitor_;
 
-#define ISOLATE_METRIC_VARIABLE(type, variable, name, unit)                    \
-  type metric_##variable##_;
-  ISOLATE_METRIC_LIST(ISOLATE_METRIC_VARIABLE);
-#undef ISOLATE_METRIC_VARIABLE
-
-  intptr_t no_reload_scope_depth_;  // we can only reload when this is 0.
-  // Per-isolate copy of FLAG_reload_every.
-  intptr_t reload_every_n_stack_overflow_checks_;
-  IsolateReloadContext* reload_context_;
-  int64_t last_reload_timestamp_;
-  // Ring buffer of objects assigned an id.
-  ObjectIdRing* object_id_ring_;
-#endif  // !defined(PRODUCT)
-
-  // All other fields go here.
-  ThreadRegistry* thread_registry_;
-  SafepointHandler* safepoint_handler_;
-  Dart_MessageNotifyCallback message_notify_callback_;
-  char* name_;
-  Dart_Port main_port_;
-  Dart_Port origin_id_;  // Isolates created by spawnFunc have some origin id.
-  uint64_t pause_capability_;
-  uint64_t terminate_capability_;
-  void* init_callback_data_;
-  Dart_EnvironmentCallback environment_callback_;
-  Dart_LibraryTagHandler library_tag_handler_;
-  ApiState* api_state_;
-  Random random_;
-  Simulator* simulator_;
-  Mutex* mutex_;          // Protects compiler stats.
-  Mutex* symbols_mutex_;  // Protects concurrent access to the symbol table.
-  Mutex* type_canonicalization_mutex_;      // Protects type canonicalization.
-  Mutex* constant_canonicalization_mutex_;  // Protects const canonicalization.
-  Mutex* megamorphic_lookup_mutex_;  // Protects megamorphic table lookup.
-  MessageHandler* message_handler_;
-  IsolateSpawnState* spawn_state_;
-  Dart_GcPrologueCallback gc_prologue_callback_;
-  Dart_GcEpilogueCallback gc_epilogue_callback_;
-  intptr_t defer_finalization_count_;
-  MallocGrowableArray<PendingLazyDeopt>* pending_deopts_;
-  DeoptContext* deopt_context_;
-
-  RawGrowableObjectArray* tag_table_;
-
-  RawGrowableObjectArray* deoptimized_code_array_;
-
-  RawError* sticky_error_;
-
-  // Background compilation.
-  BackgroundCompiler* background_compiler_;
-  intptr_t background_compiler_disabled_depth_;
-
-  // Isolate list next pointer.
-  Isolate* next_;
-
   // Invalidation generations; used to track events occurring in parallel
   // to background compilation. The counters may overflow, which is OK
   // since we check for equality to detect if an event occured.
   intptr_t loading_invalidation_gen_;
   intptr_t top_level_parsing_count_;
 
   // Protect access to boxed_field_list_.
   Mutex* field_list_mutex_;
   // List of fields that became boxed and that trigger deoptimization.
   RawGrowableObjectArray* boxed_field_list_;
 
   // This guards spawn_count_. An isolate cannot complete shutdown and be
   // destroyed while there are child isolates in the midst of a spawn.
   Monitor* spawn_count_monitor_;
   intptr_t spawn_count_;
 
+#define ISOLATE_METRIC_VARIABLE(type, variable, name, unit)                    \
+  type metric_##variable##_;
+  ISOLATE_METRIC_LIST(ISOLATE_METRIC_VARIABLE);
+#undef ISOLATE_METRIC_VARIABLE
+
+  // Has a reload ever been attempted?
+  bool has_attempted_reload_;
+  intptr_t no_reload_scope_depth_;  // we can only reload when this is 0.
+  // Per-isolate copy of FLAG_reload_every.
+  intptr_t reload_every_n_stack_overflow_checks_;
+  IsolateReloadContext* reload_context_;
+  int64_t last_reload_timestamp_;
+  // Should we pause in the debug message loop after this request?
+  bool should_pause_post_service_request_;
+
   HandlerInfoCache handler_info_cache_;
   CatchEntryStateCache catch_entry_state_cache_;
 
   static Dart_IsolateCreateCallback create_callback_;
   static Dart_IsolateShutdownCallback shutdown_callback_;
   static Dart_IsolateCleanupCallback cleanup_callback_;
 
 #if !defined(PRODUCT)
   static void WakePauseEventHandler(Dart_Isolate isolate);
 #endif
@@ skipping 146 matching lines @@
   intptr_t* spawn_count_;
 
   Dart_IsolateFlags isolate_flags_;
   bool paused_;
   bool errors_are_fatal_;
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_ISOLATE_H_