VM: Re-format to use at most one newline between functions

runtime/vm/dart.cc

 // 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.
 
 #include "vm/dart.h"
 
 #include "vm/become.h"
 #include "vm/clustered_snapshot.h"
 #include "vm/code_observers.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/flags.h"
 #include "vm/freelist.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/kernel_isolate.h"
 #include "vm/malloc_hooks.h"
 #include "vm/message_handler.h"
 #include "vm/metrics.h"
 #include "vm/object.h"
+#include "vm/object_id_ring.h"
 #include "vm/object_store.h"
-#include "vm/object_id_ring.h"
 #include "vm/port.h"
 #include "vm/profiler.h"
 #include "vm/service_isolate.h"
 #include "vm/simulator.h"
 #include "vm/snapshot.h"
 #include "vm/store_buffer.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/thread_interrupter.h"
 #include "vm/thread_pool.h"
@@ skipping 37 matching lines @@
   ReadOnlyHandles() {}
 
  private:
   VMHandles handles_;
   LocalHandles api_handles_;
 
   friend class Dart;
   DISALLOW_COPY_AND_ASSIGN(ReadOnlyHandles);
 };
 
-
 static void CheckOffsets() {
 #define CHECK_OFFSET(expr, offset)                                             \
   if ((expr) != (offset)) {                                                    \
     FATAL2("%s == %" Pd, #expr, (expr));                                       \
   }
 
 #if defined(TARGET_ARCH_ARM)
   // These offsets are embedded in precompiled instructions. We need simarm
   // (compiler) and arm (runtime) to agree.
   CHECK_OFFSET(Heap::TopOffset(Heap::kNew), 8);
   CHECK_OFFSET(Thread::stack_limit_offset(), 4);
   CHECK_OFFSET(Thread::object_null_offset(), 40);
   CHECK_OFFSET(SingleTargetCache::upper_limit_offset(), 14);
   CHECK_OFFSET(Isolate::object_store_offset(), 28);
   NOT_IN_PRODUCT(CHECK_OFFSET(sizeof(ClassHeapStats), 120));
 #endif
 #if defined(TARGET_ARCH_ARM64)
   // These offsets are embedded in precompiled instructions. We need simarm64
   // (compiler) and arm64 (runtime) to agree.
   CHECK_OFFSET(Heap::TopOffset(Heap::kNew), 8);
   CHECK_OFFSET(Thread::stack_limit_offset(), 8);
   CHECK_OFFSET(Thread::object_null_offset(), 80);
   CHECK_OFFSET(SingleTargetCache::upper_limit_offset(), 26);
   CHECK_OFFSET(Isolate::object_store_offset(), 56);
   NOT_IN_PRODUCT(CHECK_OFFSET(sizeof(ClassHeapStats), 208));
 #endif
 #undef CHECK_OFFSET
 }
 
-
 char* Dart::InitOnce(const uint8_t* vm_isolate_snapshot,
                      const uint8_t* instructions_snapshot,
                      Dart_IsolateCreateCallback create,
                      Dart_IsolateShutdownCallback shutdown,
                      Dart_IsolateCleanupCallback cleanup,
                      Dart_ThreadExitCallback thread_exit,
                      Dart_FileOpenCallback file_open,
                      Dart_FileReadCallback file_read,
                      Dart_FileWriteCallback file_write,
                      Dart_FileCloseCallback file_close,
@@ skipping 188 matching lines @@
 
   ServiceIsolate::Run();
 
 #ifndef DART_PRECOMPILED_RUNTIME
   KernelIsolate::Run();
 #endif  // DART_PRECOMPILED_RUNTIME
 
   return NULL;
 }
 
-
 // This waits until only the VM isolate and the service isolate remains in the
 // list, i.e. list length == 2.
 void Dart::WaitForApplicationIsolateShutdown() {
   ASSERT(!Isolate::creation_enabled_);
   MonitorLocker ml(Isolate::isolates_list_monitor_);
   while ((Isolate::isolates_list_head_ != NULL) &&
          (Isolate::isolates_list_head_->next_ != NULL) &&
          (Isolate::isolates_list_head_->next_->next_ != NULL)) {
     ml.Wait();
   }
   ASSERT(
       ((Isolate::isolates_list_head_ == Dart::vm_isolate()) &&
        ServiceIsolate::IsServiceIsolate(Isolate::isolates_list_head_->next_)) ||
       ((Isolate::isolates_list_head_->next_ == Dart::vm_isolate()) &&
        ServiceIsolate::IsServiceIsolate(Isolate::isolates_list_head_)));
 }
 
-
 // This waits until only the VM isolate remains in the list.
 void Dart::WaitForIsolateShutdown() {
   ASSERT(!Isolate::creation_enabled_);
   MonitorLocker ml(Isolate::isolates_list_monitor_);
   while ((Isolate::isolates_list_head_ != NULL) &&
          (Isolate::isolates_list_head_->next_ != NULL)) {
     ml.Wait();
   }
   ASSERT(Isolate::isolates_list_head_ == Dart::vm_isolate());
 }
 
-
 const char* Dart::Cleanup() {
   ASSERT(Isolate::Current() == NULL);
   if (vm_isolate_ == NULL) {
     return "VM already terminated.";
   }
 
   if (FLAG_trace_shutdown) {
     OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Starting shutdown\n",
                  UptimeMillis());
   }
 
   if (FLAG_profiler) {
     // Shut down profiling.
     if (FLAG_trace_shutdown) {
       OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Shutting down profiling\n",
                    UptimeMillis());
     }
     Profiler::Shutdown();
   }
 
-
   {
     // Set the VM isolate as current isolate when shutting down
     // Metrics so that we can use a StackZone.
     if (FLAG_trace_shutdown) {
       OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Entering vm isolate\n",
                    UptimeMillis());
     }
     bool result = Thread::EnterIsolate(vm_isolate_);
     ASSERT(result);
     Metric::Cleanup();
@@ skipping 97 matching lines @@
     }
     Timeline::Shutdown();
   }
   if (FLAG_trace_shutdown) {
     OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Done\n", UptimeMillis());
   }
   MallocHooks::TearDown();
   return NULL;
 }
 
-
 Isolate* Dart::CreateIsolate(const char* name_prefix,
                              const Dart_IsolateFlags& api_flags) {
   // Create a new isolate.
   Isolate* isolate = Isolate::Init(name_prefix, api_flags);
   return isolate;
 }
 
-
 static bool IsSnapshotCompatible(Snapshot::Kind vm_kind,
                                  Snapshot::Kind isolate_kind) {
   if (vm_kind == isolate_kind) return true;
   if (vm_kind == Snapshot::kFull && isolate_kind == Snapshot::kFullJIT)
     return true;
   return Snapshot::IsFull(isolate_kind);
 }
 
-
 RawError* Dart::InitializeIsolate(const uint8_t* snapshot_data,
                                   const uint8_t* snapshot_instructions,
                                   intptr_t snapshot_length,
                                   kernel::Program* kernel_program,
                                   void* data) {
   // Initialize the new isolate.
   Thread* T = Thread::Current();
   Isolate* I = T->isolate();
   NOT_IN_PRODUCT(TimelineDurationScope tds(T, Timeline::GetIsolateStream(),
                                            "InitializeIsolate");
@@ skipping 118 matching lines @@
   const UserTag& default_tag = UserTag::Handle(UserTag::DefaultTag());
   I->set_current_tag(default_tag);
 
   if (FLAG_keep_code) {
     I->set_deoptimized_code_array(
         GrowableObjectArray::Handle(GrowableObjectArray::New()));
   }
   return Error::null();
 }
 
-
 const char* Dart::FeaturesString(Isolate* isolate, Snapshot::Kind kind) {
   TextBuffer buffer(64);
 
 // Different fields are included for DEBUG/RELEASE/PRODUCT.
 #if defined(DEBUG)
   buffer.AddString("debug");
 #elif defined(PRODUCT)
   buffer.AddString("product");
 #else
   buffer.AddString("release");
 #endif
 
   if (Snapshot::IncludesCode(kind)) {
     if (FLAG_support_debugger) {
       buffer.AddString(" support-debugger");
     }
 
-    // Checked mode affects deopt ids.
+// Checked mode affects deopt ids.
 #define ADD_FLAG(name, isolate_flag, flag)                                     \
   do {                                                                         \
     const bool name = (isolate != NULL) ? isolate->name() : flag;              \
     buffer.AddString(name ? (" " #name) : (" no-" #name));                     \
   } while (0);
     ADD_FLAG(type_checks, enable_type_checks, FLAG_enable_type_checks);
     ADD_FLAG(asserts, enable_asserts, FLAG_enable_asserts);
     ADD_FLAG(error_on_bad_type, enable_error_on_bad_type,
              FLAG_error_on_bad_type);
     ADD_FLAG(error_on_bad_override, enable_error_on_bad_override,
@@ skipping 30 matching lines @@
 #endif
   }
 
   if (FLAG_precompiled_mode && FLAG_dwarf_stack_traces) {
     buffer.AddString(" dwarf-stack-traces");
   }
 
   return buffer.Steal();
 }
 
-
 void Dart::RunShutdownCallback() {
   Isolate* isolate = Isolate::Current();
   void* callback_data = isolate->init_callback_data();
   Dart_IsolateShutdownCallback callback = Isolate::ShutdownCallback();
   if (callback != NULL) {
     (callback)(callback_data);
   }
 }
 
-
 void Dart::ShutdownIsolate(Isolate* isolate) {
   ASSERT(Isolate::Current() == NULL);
   // We need to enter the isolate in order to shut it down.
   bool result = Thread::EnterIsolate(isolate);
   ASSERT(result);
   ShutdownIsolate();
   // Since the isolate is shutdown and deleted, there is no need to
   // exit the isolate here.
   ASSERT(Isolate::Current() == NULL);
 }
 
-
 void Dart::ShutdownIsolate() {
   Isolate* isolate = Isolate::Current();
   isolate->Shutdown();
   delete isolate;
 }
 
-
 int64_t Dart::UptimeMicros() {
   return OS::GetCurrentMonotonicMicros() - Dart::start_time_micros_;
 }
 
-
 uword Dart::AllocateReadOnlyHandle() {
   ASSERT(Isolate::Current() == Dart::vm_isolate());
   ASSERT(predefined_handles_ != NULL);
   return predefined_handles_->handles_.AllocateScopedHandle();
 }
 
-
 LocalHandle* Dart::AllocateReadOnlyApiHandle() {
   ASSERT(Isolate::Current() == Dart::vm_isolate());
   ASSERT(predefined_handles_ != NULL);
   return predefined_handles_->api_handles_.AllocateHandle();
 }
 
-
 bool Dart::IsReadOnlyHandle(uword address) {
   ASSERT(predefined_handles_ != NULL);
   return predefined_handles_->handles_.IsValidScopedHandle(address);
 }
 
-
 bool Dart::IsReadOnlyApiHandle(Dart_Handle handle) {
   ASSERT(predefined_handles_ != NULL);
   return predefined_handles_->api_handles_.IsValidHandle(handle);
 }
 
 }  // namespace dart