clang-format runtime/vm

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 55 matching lines @@
 class StackResource;
 class StackZone;
 class StoreBuffer;
 class StubCode;
 class ThreadRegistry;
 class UserTag;
 
 
 class PendingLazyDeopt {
  public:
-  PendingLazyDeopt(uword fp, uword pc) : fp_(fp), pc_(pc) { }
+  PendingLazyDeopt(uword fp, uword pc) : fp_(fp), pc_(pc) {}
   uword fp() { return fp_; }
   uword pc() { return pc_; }
   void set_pc(uword pc) { pc_ = pc; }
 
  private:
   uword fp_;
   uword pc_;
 };
 
 
 class IsolateVisitor {
  public:
   IsolateVisitor() {}
   virtual ~IsolateVisitor() {}
 
   virtual void VisitIsolate(Isolate* isolate) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IsolateVisitor);
 };
 
 
 // Disallow OOB message handling within this scope.
 class NoOOBMessageScope : public StackResource {
  public:
   explicit NoOOBMessageScope(Thread* thread);
   ~NoOOBMessageScope();
+
  private:
   DISALLOW_COPY_AND_ASSIGN(NoOOBMessageScope);
 };
 
 
 // Disallow isolate reload.
 class NoReloadScope : public StackResource {
  public:
   NoReloadScope(Isolate* isolate, Thread* thread);
   ~NoReloadScope();
@@ skipping 85 matching lines @@
 
   int64_t start_time() const { return start_time_; }
 
   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_));
+    ASSERT((id == main_port_ && origin_id_ == 0) || (origin_id_ == main_port_));
     origin_id_ = id;
   }
   void set_pause_capability(uint64_t value) { pause_capability_ = value; }
   uint64_t pause_capability() const { return pause_capability_; }
   void set_terminate_capability(uint64_t value) {
     terminate_capability_ = value;
   }
   uint64_t terminate_capability() const { return terminate_capability_; }
 
   void SendInternalLibMessage(LibMsgId msg_id, uint64_t capability);
 
   Heap* heap() const { return heap_; }
   void set_heap(Heap* value) { heap_ = value; }
 
   ObjectStore* object_store() const { return object_store_; }
   void set_object_store(ObjectStore* value) { object_store_ = value; }
   static intptr_t object_store_offset() {
     return OFFSET_OF(Isolate, object_store_);
   }
 
   ApiState* api_state() const { return api_state_; }
   void set_api_state(ApiState* value) { api_state_ = value; }
 
-  void set_init_callback_data(void* value) {
-    init_callback_data_ = value;
-  }
-  void* init_callback_data() const {
-    return init_callback_data_;
-  }
+  void set_init_callback_data(void* value) { init_callback_data_ = value; }
+  void* init_callback_data() const { return init_callback_data_; }
 
   Dart_EnvironmentCallback environment_callback() const {
     return environment_callback_;
   }
   void set_environment_callback(Dart_EnvironmentCallback value) {
     environment_callback_ = value;
   }
 
   Dart_LibraryTagHandler library_tag_handler() const {
     return library_tag_handler_;
   }
   void set_library_tag_handler(Dart_LibraryTagHandler value) {
     library_tag_handler_ = value;
   }
 
   void SetupInstructionsSnapshotPage(
       const uint8_t* instructions_snapshot_buffer);
-  void SetupDataSnapshotPage(
-      const uint8_t* instructions_snapshot_buffer);
+  void SetupDataSnapshotPage(const uint8_t* instructions_snapshot_buffer);
 
   void ScheduleMessageInterrupts();
 
   // Marks all libraries as loaded.
   void DoneLoading();
   void DoneFinalizing();
 
   // By default the reload context is deleted. This parameter allows
   // the caller to delete is separately if it is still needed.
   bool ReloadSources(JSONStream* js,
@@ skipping 18 matching lines @@
   void set_spawn_state(IsolateSpawnState* value) { spawn_state_ = value; }
 
   Mutex* mutex() const { return mutex_; }
   Mutex* symbols_mutex() const { return symbols_mutex_; }
   Mutex* type_canonicalization_mutex() const {
     return type_canonicalization_mutex_;
   }
   Mutex* constant_canonicalization_mutex() const {
     return constant_canonicalization_mutex_;
   }
-  Mutex* megamorphic_lookup_mutex() const {
-    return megamorphic_lookup_mutex_;
-  }
+  Mutex* megamorphic_lookup_mutex() const { return megamorphic_lookup_mutex_; }
 
   Debugger* debugger() const {
     if (!FLAG_support_debugger) {
       return NULL;
     }
     ASSERT(debugger_ != NULL);
     return debugger_;
   }
 
   void set_single_step(bool value) { single_step_ = value; }
   bool single_step() const { return single_step_; }
   static intptr_t single_step_offset() {
     return OFFSET_OF(Isolate, single_step_);
   }
 
   void set_has_compiled_code(bool value) { has_compiled_code_ = value; }
   bool has_compiled_code() const { return has_compiled_code_; }
 
   // Lets the embedder know that a service message resulted in a resume request.
   void SetResumeRequest() {
     resume_request_ = true;
     set_last_resume_timestamp();
   }
 
   void set_last_resume_timestamp() {
     last_resume_timestamp_ = OS::GetCurrentTimeMillis();
   }
 
-  int64_t last_resume_timestamp() const {
-    return last_resume_timestamp_;
-  }
+  int64_t last_resume_timestamp() const { return last_resume_timestamp_; }
 
   // Returns whether the vm service has requested that the debugger
   // resume execution.
   bool GetAndClearResumeRequest() {
     bool resume_request = resume_request_;
     resume_request_ = false;
     return resume_request;
   }
 
   // Verify that the sender has the capability to pause or terminate the
@@ skipping 51 matching lines @@
     return create_callback_;
   }
 
   static void SetShutdownCallback(Dart_IsolateShutdownCallback cb) {
     shutdown_callback_ = cb;
   }
   static Dart_IsolateShutdownCallback ShutdownCallback() {
     return shutdown_callback_;
   }
 
-  void set_object_id_ring(ObjectIdRing* ring) {
-    object_id_ring_ = ring;
-  }
-  ObjectIdRing* object_id_ring() {
-    return object_id_ring_;
-  }
+  void set_object_id_ring(ObjectIdRing* ring) { object_id_ring_ = ring; }
+  ObjectIdRing* object_id_ring() { return object_id_ring_; }
 
   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) {
     ASSERT(value == NULL || deopt_context_ == NULL);
     deopt_context_ = value;
   }
 
   BackgroundCompiler* background_compiler() const {
     return background_compiler_;
   }
   void set_background_compiler(BackgroundCompiler* value) {
     // Do not overwrite a background compiler (memory leak).
     ASSERT((value == NULL) || (background_compiler_ == NULL));
     background_compiler_ = value;
   }
 
   void enable_background_compiler() {
     background_compiler_disabled_depth_--;
     if (background_compiler_disabled_depth_ < 0) {
-      FATAL("Mismatched number of calls to disable_background_compiler and "
-            "enable_background_compiler.");
+      FATAL(
+          "Mismatched number of calls to disable_background_compiler and "
+          "enable_background_compiler.");
     }
   }
 
-  void disable_background_compiler() {
-    background_compiler_disabled_depth_++;
-  }
+  void disable_background_compiler() { background_compiler_disabled_depth_++; }
 
   bool is_background_compiler_disabled() const {
     return background_compiler_disabled_depth_ > 0;
   }
 
   void UpdateLastAllocationProfileAccumulatorResetTimestamp() {
     last_allocationprofile_accumulator_reset_timestamp_ =
         OS::GetCurrentTimeMillis();
   }
 
@@ skipping 26 matching lines @@
 
 #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();
   }
 
-  VMTagCounters* vm_tag_counters() {
-    return &vm_tag_counters_;
-  }
+  VMTagCounters* vm_tag_counters() { return &vm_tag_counters_; }
 
-  bool IsReloading() const {
-    return reload_context_ != NULL;
-  }
+  bool IsReloading() const { return reload_context_ != NULL; }
 
-  IsolateReloadContext* reload_context() {
-    return reload_context_;
-  }
+  IsolateReloadContext* reload_context() { return reload_context_; }
 
   void DeleteReloadContext();
 
-  bool HasAttemptedReload() const {
-    return has_attempted_reload_;
-  }
+  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_;
-  }
+  int64_t last_reload_timestamp() const { return last_reload_timestamp_; }
 
   bool IsPaused() const;
 
   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;
   }
 
   void PausePostRequest();
 
-  uword user_tag() const {
-    return user_tag_;
-  }
-  static intptr_t user_tag_offset() {
-    return OFFSET_OF(Isolate, user_tag_);
-  }
+  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_);
   }
 
 #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
 
   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);
 
-  Metric* metrics_list_head() {
-    return metrics_list_head_;
-  }
+  Metric* metrics_list_head() { return metrics_list_head_; }
 
-  void set_metrics_list_head(Metric* metric) {
-    metrics_list_head_ = metric;
-  }
+  void set_metrics_list_head(Metric* metric) { metrics_list_head_ = metric; }
 
   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);
 
   RawError* sticky_error() const { return sticky_error_; }
   void clear_sticky_error();
 
   bool compilation_allowed() const { return compilation_allowed_; }
-  void set_compilation_allowed(bool allowed) {
-    compilation_allowed_ = allowed;
-  }
+  void set_compilation_allowed(bool allowed) { compilation_allowed_ = allowed; }
 
   // In precompilation we finalize all regular classes before compiling.
   bool all_classes_finalized() const { return all_classes_finalized_; }
-  void set_all_classes_finalized(bool value) {
-    all_classes_finalized_ = value;
-  }
+  void set_all_classes_finalized(bool value) { all_classes_finalized_ = value; }
 
   // True during top level parsing.
   bool IsTopLevelParsing() {
     const intptr_t value =
         AtomicOperations::LoadRelaxed(&top_level_parsing_count_);
     ASSERT(value >= 0);
     return value > 0;
   }
 
   void IncrTopLevelParsingCount() {
@@ skipping 17 matching lines @@
 
   // Used by background compiler which field became boxed and must trigger
   // deoptimization in the mutator thread.
   void AddDeoptimizingBoxedField(const Field& field);
   // Returns Field::null() if none available in the list.
   RawField* GetDeoptimizingBoxedField();
 
 #ifndef PRODUCT
   RawObject* InvokePendingServiceExtensionCalls();
   void AppendServiceExtensionCall(const Instance& closure,
-                           const String& method_name,
-                           const Array& parameter_keys,
-                           const Array& parameter_values,
-                           const Instance& reply_port,
-                           const Instance& id);
+                                  const String& method_name,
+                                  const Array& parameter_keys,
+                                  const Array& parameter_values,
+                                  const Instance& reply_port,
+                                  const Instance& id);
   void RegisterServiceExtensionHandler(const String& name,
                                        const Instance& closure);
   RawInstance* LookupServiceExtensionHandler(const String& name);
 #endif
 
   static void VisitIsolates(IsolateVisitor* visitor);
 
   // Handle service messages until we are told to resume execution.
   void PauseEventHandler();
 
   void AddClosureFunction(const Function& function) const;
   RawFunction* LookupClosureFunction(const Function& parent,
                                      TokenPosition token_pos) const;
   intptr_t FindClosureIndex(const Function& needle) const;
   RawFunction* ClosureFunctionFromIndex(intptr_t idx) const;
 
   bool is_service_isolate() const { return is_service_isolate_; }
 
   // Isolate-specific flag handling.
   static void FlagsInitialize(Dart_IsolateFlags* api_flags);
   void FlagsCopyTo(Dart_IsolateFlags* api_flags) const;
   void FlagsCopyFrom(const Dart_IsolateFlags& api_flags);
 
 #if defined(PRODUCT)
   bool type_checks() const { return FLAG_enable_type_checks; }
   bool asserts() const { return FLAG_enable_asserts; }
   bool error_on_bad_type() const { return FLAG_error_on_bad_type; }
   bool error_on_bad_override() const { return FLAG_error_on_bad_override; }
-#else  // defined(PRODUCT)
+#else   // defined(PRODUCT)
   bool type_checks() const { return type_checks_; }
   bool asserts() const { return asserts_; }
   bool error_on_bad_type() const { return error_on_bad_type_; }
   bool error_on_bad_override() const { return error_on_bad_override_; }
 #endif  // defined(PRODUCT)
 
   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();
 
   intptr_t reload_every_n_stack_overflow_checks() const {
     return reload_every_n_stack_overflow_checks_;
   }
 
   void MaybeIncreaseReloadEveryNStackOverflowChecks();
 
  private:
-  friend class Dart;  // Init, InitOnce, Shutdown.
+  friend class Dart;                  // Init, InitOnce, Shutdown.
   friend class IsolateKillerVisitor;  // Kill().
 
   explicit Isolate(const Dart_IsolateFlags& api_flags);
 
   static void InitOnce();
   static Isolate* Init(const char* name_prefix,
                        const Dart_IsolateFlags& api_flags,
                        bool is_vm_isolate = false);
 
   // The isolates_list_monitor_ should be held when calling Kill().
   void KillLocked(LibMsgId msg_id);
 
   void LowLevelShutdown();
   void Shutdown();
 
   void BuildName(const char* name_prefix);
 
   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 set_user_tag(uword tag) {
-    user_tag_ = tag;
-  }
+  void set_user_tag(uword tag) { user_tag_ = tag; }
 
   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);
 
   Monitor* threads_lock() const;
   Thread* ScheduleThread(bool is_mutator, bool bypass_safepoint = false);
-  void UnscheduleThread(
-      Thread* thread, 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 {
     ASSERT(Thread::Current() == mutator_thread());
     return mutator_thread()->zone();
   }
 
   // Accessed from generated code:
   StoreBuffer* store_buffer_;
@@ skipping 20 matching lines @@
   void* init_callback_data_;
   Dart_EnvironmentCallback environment_callback_;
   Dart_LibraryTagHandler library_tag_handler_;
   ApiState* api_state_;
   Debugger* debugger_;
   bool resume_request_;
   int64_t last_resume_timestamp_;
   bool has_compiled_code_;  // Can check that no compilation occured.
   Random random_;
   Simulator* simulator_;
-  Mutex* mutex_;  // Protects compiler stats.
+  Mutex* mutex_;          // Protects compiler stats.
   Mutex* symbols_mutex_;  // Protects concurrent access to the symbol table.
-  Mutex* type_canonicalization_mutex_;  // Protects type canonicalization.
+  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.
-  NOT_IN_PRODUCT(
-    bool type_checks_;
-    bool asserts_;
-    bool error_on_bad_type_;
-    bool error_on_bad_override_;
-  )
+// Isolate-specific flags.
+#if !defined(PRODUCT)
+  bool type_checks_;
+  bool asserts_;
+  bool error_on_bad_type_;
+  bool error_on_bad_override_;
+#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_;
@@ skipping 77 matching lines @@
   static bool AddIsolateToList(Isolate* isolate);
   static void RemoveIsolateFromList(Isolate* isolate);
 
   // This monitor protects isolates_list_head_, and creation_enabled_.
   static Monitor* isolates_list_monitor_;
   static Isolate* isolates_list_head_;
   static bool creation_enabled_;
 
 #define REUSABLE_FRIEND_DECLARATION(name)                                      \
   friend class Reusable##name##HandleScope;
-REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
+  REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
 #undef REUSABLE_FRIEND_DECLARATION
 
-  friend class Become;  // VisitObjectPointers
+  friend class Become;    // VisitObjectPointers
   friend class GCMarker;  // VisitObjectPointers
   friend class SafepointHandler;
   friend class Scavenger;  // VisitObjectPointers
   friend class ServiceIsolate;
   friend class Thread;
   friend class Timeline;
   friend class NoReloadScope;  // reload_block
 
 
   DISALLOW_COPY_AND_ASSIGN(Isolate);
@@ skipping 122 matching lines @@
   intptr_t* spawn_count_;
 
   Dart_IsolateFlags isolate_flags_;
   bool paused_;
   bool errors_are_fatal_;
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_ISOLATE_H_