clang-format runtime/vm

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"
@@ skipping 21 matching lines @@
 #include "vm/thread_interrupter.h"
 #include "vm/thread_pool.h"
 #include "vm/timeline.h"
 #include "vm/virtual_memory.h"
 #include "vm/zone.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, print_class_table);
 DECLARE_FLAG(bool, trace_time_all);
-DEFINE_FLAG(bool, keep_code, false,
-            "Keep deoptimized code for profiling.");
+DEFINE_FLAG(bool, keep_code, false, "Keep deoptimized code for profiling.");
 DEFINE_FLAG(bool, trace_shutdown, false, "Trace VM shutdown on stderr");
 
 Isolate* Dart::vm_isolate_ = NULL;
 int64_t Dart::start_time_ = 0;
 ThreadPool* Dart::thread_pool_ = NULL;
 DebugInfo* Dart::pprof_symbol_generator_ = NULL;
 ReadOnlyHandles* Dart::predefined_handles_ = NULL;
 Snapshot::Kind Dart::snapshot_kind_ = Snapshot::kInvalid;
 const uint8_t* Dart::instructions_snapshot_buffer_ = NULL;
 const uint8_t* Dart::data_snapshot_buffer_ = NULL;
@@ skipping 10 matching lines @@
 // stored in the vm isolate ensures that we don't constantly create and
 // destroy handles for read-only objects referred in the VM code
 // (e.g: symbols, null object, empty array etc.)
 // The ReadOnlyHandles C++ Wrapper around VMHandles which is a ValueObject is
 // to ensure that the handles area is not trashed by automatic running of C++
 // static destructors when 'exit()" is called by any isolate. There might be
 // other isolates running at the same time and trashing the handles area will
 // have unintended consequences.
 class ReadOnlyHandles {
  public:
-  ReadOnlyHandles() { }
+  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(), 36);
   CHECK_OFFSET(SingleTargetCache::upper_limit_offset(), 14);
   CHECK_OFFSET(Isolate::object_store_offset(), 28);
   NOT_IN_PRODUCT(CHECK_OFFSET(sizeof(ClassHeapStats), 120));
@@ skipping 41 matching lines @@
   }
   set_thread_exit_callback(thread_exit);
   SetFileCallbacks(file_open, file_read, file_write, file_close);
   set_entropy_source_callback(entropy_source);
   OS::InitOnce();
   VirtualMemory::InitOnce();
   OSThread::InitOnce();
   if (FLAG_support_timeline) {
     Timeline::InitOnce();
   }
-  NOT_IN_PRODUCT(TimelineDurationScope tds(Timeline::GetVMStream(),
-                                           "Dart::InitOnce"));
+  NOT_IN_PRODUCT(
+      TimelineDurationScope tds(Timeline::GetVMStream(), "Dart::InitOnce"));
   Isolate::InitOnce();
   PortMap::InitOnce();
   FreeListElement::InitOnce();
   ForwardingCorpse::InitOnce();
   Api::InitOnce();
   NOT_IN_PRODUCT(CodeObservers::InitOnce());
   if (FLAG_profiler) {
     ThreadInterrupter::InitOnce();
     Profiler::InitOnce();
   }
@@ skipping 71 matching lines @@
           return strdup("Unexpected instructions snapshot");
         }
         if (data_snapshot != NULL) {
           return strdup("Unexpected rodata snapshot");
         }
         StubCode::InitOnce();
 #endif
       } else {
         return strdup("Invalid vm isolate snapshot seen");
       }
-      VmIsolateSnapshotReader reader(snapshot->kind(),
-                                     snapshot->content(),
-                                     snapshot->length(),
-                                     instructions_snapshot,
-                                     data_snapshot,
-                                     T);
+      VmIsolateSnapshotReader reader(snapshot->kind(), snapshot->content(),
+                                     snapshot->length(), instructions_snapshot,
+                                     data_snapshot, T);
       const Error& error = Error::Handle(reader.ReadVmIsolateSnapshot());
       if (!error.IsNull()) {
         // Must copy before leaving the zone.
         return strdup(error.ToErrorCString());
       }
-      NOT_IN_PRODUCT(if (tds.enabled()) {
+#if !defined(PRODUCT)
+      if (tds.enabled()) {
         tds.SetNumArguments(2);
         tds.FormatArgument(0, "snapshotSize", "%" Pd, snapshot->length());
-        tds.FormatArgument(1, "heapSize", "%" Pd64,
-                           vm_isolate_->heap()->UsedInWords(Heap::kOld) *
-                           kWordSize);
-      });
+        tds.FormatArgument(
+            1, "heapSize", "%" Pd64,
+            vm_isolate_->heap()->UsedInWords(Heap::kOld) * kWordSize);
+      }
+#endif  // !defined(PRODUCT)
       if (FLAG_trace_isolates) {
         OS::Print("Size of vm isolate snapshot = %" Pd "\n",
                   snapshot->length());
         vm_isolate_->heap()->PrintSizes();
         MegamorphicCacheTable::PrintSizes(vm_isolate_);
         intptr_t size;
         intptr_t capacity;
         Symbols::GetStats(vm_isolate_, &size, &capacity);
         OS::Print("VM Isolate: Number of symbols : %" Pd "\n", size);
         OS::Print("VM Isolate: Symbol table capacity : %" Pd "\n", capacity);
@@ skipping 76 matching lines @@
 }
 
 
 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",
-                 timestamp());
+    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Starting shutdown\n", timestamp());
   }
 
   if (FLAG_profiler) {
     // Shut down profiling.
     if (FLAG_trace_shutdown) {
       OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Shutting down profiling\n",
                    timestamp());
     }
     Profiler::Shutdown();
   }
@@ skipping 86 matching lines @@
   TargetCPUFeatures::Cleanup();
   StoreBuffer::ShutDown();
 
   // Delete the current thread's TLS and set it's TLS to null.
   // If it is the last thread then the destructor would call
   // OSThread::Cleanup.
   OSThread* os_thread = OSThread::Current();
   OSThread::SetCurrent(NULL);
   delete os_thread;
   if (FLAG_trace_shutdown) {
-    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Deleted os_thread\n",
-                 timestamp());
+    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Deleted os_thread\n", timestamp());
   }
 
   if (FLAG_trace_shutdown) {
     OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Deleting code observers\n",
                  timestamp());
   }
   NOT_IN_PRODUCT(CodeObservers::DeleteAll());
   if (FLAG_support_timeline) {
     if (FLAG_trace_shutdown) {
       OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Shutting down timeline\n",
@@ skipping 14 matching lines @@
   // Create a new isolate.
   Isolate* isolate = Isolate::Init(name_prefix, api_flags);
   return isolate;
 }
 
 
 RawError* Dart::InitializeIsolate(const uint8_t* snapshot_buffer, void* data) {
   // Initialize the new isolate.
   Thread* T = Thread::Current();
   Isolate* I = T->isolate();
-  NOT_IN_PRODUCT(
-    TimelineDurationScope tds(T,
-                              Timeline::GetIsolateStream(),
-                              "InitializeIsolate");
-    tds.SetNumArguments(1);
-    tds.CopyArgument(0, "isolateName", I->name());
-  )
+  NOT_IN_PRODUCT(TimelineDurationScope tds(T, Timeline::GetIsolateStream(),
+                                           "InitializeIsolate");
+                 tds.SetNumArguments(1);
+                 tds.CopyArgument(0, "isolateName", I->name());)
   ASSERT(I != NULL);
   StackZone zone(T);
   HandleScope handle_scope(T);
   {
-    NOT_IN_PRODUCT(TimelineDurationScope tds(T,
-        Timeline::GetIsolateStream(), "ObjectStore::Init"));
+    NOT_IN_PRODUCT(TimelineDurationScope tds(T, Timeline::GetIsolateStream(),
+                                             "ObjectStore::Init"));
     ObjectStore::Init(I);
   }
 
   const Error& error = Error::Handle(Object::Init(I));
   if (!error.IsNull()) {
     return error.raw();
   }
   if (snapshot_buffer != NULL) {
     // Read the snapshot and setup the initial state.
-    NOT_IN_PRODUCT(TimelineDurationScope tds(T,
-        Timeline::GetIsolateStream(), "IsolateSnapshotReader"));
+    NOT_IN_PRODUCT(TimelineDurationScope tds(T, Timeline::GetIsolateStream(),
+                                             "IsolateSnapshotReader"));
     // TODO(turnidge): Remove once length is not part of the snapshot.
     const Snapshot* snapshot = Snapshot::SetupFromBuffer(snapshot_buffer);
     if (snapshot == NULL) {
-      const String& message = String::Handle(
-          String::New("Invalid snapshot"));
+      const String& message = String::Handle(String::New("Invalid snapshot"));
       return ApiError::New(message);
     }
     ASSERT(Snapshot::IsFull(snapshot->kind()));
     ASSERT(snapshot->kind() == snapshot_kind_);
     if (FLAG_trace_isolates) {
       OS::Print("Size of isolate snapshot = %" Pd "\n", snapshot->length());
     }
-    IsolateSnapshotReader reader(snapshot->kind(),
-                                 snapshot->content(),
-                                 snapshot->length(),
-                                 Dart::instructions_snapshot_buffer(),
-                                 Dart::data_snapshot_buffer(),
-                                 T);
+    IsolateSnapshotReader reader(
+        snapshot->kind(), snapshot->content(), snapshot->length(),
+        Dart::instructions_snapshot_buffer(), Dart::data_snapshot_buffer(), T);
     const Error& error = Error::Handle(reader.ReadFullSnapshot());
     if (!error.IsNull()) {
       return error.raw();
     }
-    NOT_IN_PRODUCT(if (tds.enabled()) {
+#if !defined(PRODUCT)
+    if (tds.enabled()) {
       tds.SetNumArguments(2);
       tds.FormatArgument(0, "snapshotSize", "%" Pd, snapshot->length());
       tds.FormatArgument(1, "heapSize", "%" Pd64,
                          I->heap()->UsedInWords(Heap::kOld) * kWordSize);
-    });
+    }
+#endif  // !defined(PRODUCT)
     if (FLAG_trace_isolates) {
       I->heap()->PrintSizes();
       MegamorphicCacheTable::PrintSizes(I);
     }
   } else {
     if (snapshot_kind_ != Snapshot::kNone) {
-      const String& message = String::Handle(
-          String::New("Missing isolate snapshot"));
+      const String& message =
+          String::Handle(String::New("Missing isolate snapshot"));
       return ApiError::New(message);
     }
   }
 
   Object::VerifyBuiltinVtables();
   DEBUG_ONLY(I->heap()->Verify(kForbidMarked));
 
   {
-    NOT_IN_PRODUCT(TimelineDurationScope tds(T,
-        Timeline::GetIsolateStream(), "StubCode::Init"));
+    NOT_IN_PRODUCT(TimelineDurationScope tds(T, Timeline::GetIsolateStream(),
+                                             "StubCode::Init"));
     StubCode::Init(I);
   }
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
   // When running precompiled, the megamorphic miss function/code comes from the
   // snapshot.
   if (!Snapshot::IncludesCode(Dart::snapshot_kind())) {
     MegamorphicCacheTable::InitMissHandler(I);
   }
 #endif
@@ skipping 13 matching lines @@
   I->set_init_callback_data(data);
   Api::SetupAcquiredError(I);
   if (FLAG_print_class_table) {
     I->class_table()->Print();
   }
 
   ServiceIsolate::MaybeMakeServiceIsolate(I);
   if (!ServiceIsolate::IsServiceIsolate(I)) {
     I->message_handler()->set_should_pause_on_start(
         FLAG_pause_isolates_on_start);
-    I->message_handler()->set_should_pause_on_exit(
-        FLAG_pause_isolates_on_exit);
+    I->message_handler()->set_should_pause_on_exit(FLAG_pause_isolates_on_exit);
   }
   ServiceIsolate::SendIsolateStartupMessage();
   if (FLAG_support_debugger) {
     I->debugger()->NotifyIsolateCreated();
   }
   // Create tag table.
   I->set_tag_table(GrowableObjectArray::Handle(GrowableObjectArray::New()));
   // Set up default UserTag.
   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(Snapshot::Kind kind) {
   TextBuffer buffer(64);
 
-  // Different fields are included for DEBUG/RELEASE/PRODUCT.
+// 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)) {
     // Checked mode affects deopt ids.
     buffer.AddString(FLAG_enable_asserts ? " asserts" : " no-asserts");
     buffer.AddString(FLAG_enable_type_checks ? " type-checks"
                                              : " no-type-checks");
 
-    // Generated code must match the host architecture and ABI.
+// Generated code must match the host architecture and ABI.
 #if defined(TARGET_ARCH_ARM)
 #if defined(TARGET_ABI_IOS)
     buffer.AddString(" arm-ios");
 #elif defined(TARGET_ABI_EABI)
     buffer.AddString(" arm-eabi");
 #else
 #error Unknown ABI
 #endif
     buffer.AddString(TargetCPUFeatures::hardfp_supported() ? " hardfp"
                                                            : " softfp");
@@ skipping 74 matching lines @@
   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