clang-format runtime/vm

runtime/vm/os_fuchsia.cc

 // Copyright (c) 2016, 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/globals.h"
 #if defined(TARGET_OS_FUCHSIA)
 
 #include "vm/os.h"
 
 #include <errno.h>
 #include <magenta/syscalls.h>
 #include <magenta/types.h>
 
 #include "platform/assert.h"
 #include "vm/zone.h"
 
 namespace dart {
 
 #ifndef PRODUCT
 
-DEFINE_FLAG(bool, generate_perf_events_symbols, false,
-    "Generate events symbols for profiling with perf");
+DEFINE_FLAG(bool,
+            generate_perf_events_symbols,
+            false,
+            "Generate events symbols for profiling with perf");
 
 #endif  // !PRODUCT
 
 const char* OS::Name() {
   return "fuchsia";
 }
 
 
 intptr_t OS::ProcessId() {
   return static_cast<intptr_t>(getpid());
@@ skipping 65 matching lines @@
 
 int64_t OS::GetCurrentThreadCPUMicros() {
   UNIMPLEMENTED();
   return 0;
 }
 
 
 // TODO(5411554):  May need to hoist these architecture dependent code
 // into a architecture specific file e.g: os_ia32_fuchsia.cc
 intptr_t OS::ActivationFrameAlignment() {
-#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64) || \
+#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64) ||                   \
     defined(TARGET_ARCH_ARM64)
   const int kMinimumAlignment = 16;
 #elif defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_DBC)
   const int kMinimumAlignment = 8;
 #else
 #error Unsupported architecture.
 #endif
   intptr_t alignment = kMinimumAlignment;
   // TODO(5411554): Allow overriding default stack alignment for
   // testing purposes.
   // Flags::DebugIsInt("stackalign", &alignment);
   ASSERT(Utils::IsPowerOfTwo(alignment));
   ASSERT(alignment >= kMinimumAlignment);
   return alignment;
 }
 
 
 intptr_t OS::PreferredCodeAlignment() {
-#if defined(TARGET_ARCH_IA32) ||                                               \
-    defined(TARGET_ARCH_X64) ||                                                \
-    defined(TARGET_ARCH_ARM64) ||                                              \
-    defined(TARGET_ARCH_DBC)
+#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64) ||                   \
+    defined(TARGET_ARCH_ARM64) || defined(TARGET_ARCH_DBC)
   const int kMinimumAlignment = 32;
 #elif defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_MIPS)
   const int kMinimumAlignment = 16;
 #else
 #error Unsupported architecture.
 #endif
   intptr_t alignment = kMinimumAlignment;
   // TODO(5411554): Allow overriding default code alignment for
   // testing purposes.
   // Flags::DebugIsInt("codealign", &alignment);
@@ skipping 15 matching lines @@
 }
 
 
 uintptr_t OS::MaxRSS() {
   UNIMPLEMENTED();
   return 0;
 }
 
 
 void OS::Sleep(int64_t millis) {
-  mx_nanosleep(
-      millis * kMicrosecondsPerMillisecond * kNanosecondsPerMicrosecond);
+  mx_nanosleep(millis * kMicrosecondsPerMillisecond *
+               kNanosecondsPerMicrosecond);
 }
 
 
 void OS::SleepMicros(int64_t micros) {
-  mx_nanosleep(
-      micros * kNanosecondsPerMicrosecond);
+  mx_nanosleep(micros * kNanosecondsPerMicrosecond);
 }
 
 
 void OS::DebugBreak() {
   UNIMPLEMENTED();
 }
 
 
 char* OS::StrNDup(const char* s, intptr_t n) {
   return strndup(s, n);
@@ skipping 71 matching lines @@
 
 
 bool OS::StringToInt64(const char* str, int64_t* value) {
   ASSERT(str != NULL && strlen(str) > 0 && value != NULL);
   int32_t base = 10;
   char* endptr;
   int i = 0;
   if (str[0] == '-') {
     i = 1;
   }
-  if ((str[i] == '0') &&
-      (str[i + 1] == 'x' || str[i + 1] == 'X') &&
+  if ((str[i] == '0') && (str[i + 1] == 'x' || str[i + 1] == 'X') &&
       (str[i + 2] != '\0')) {
     base = 16;
   }
   errno = 0;
   *value = strtoll(str, &endptr, base);
   return ((errno == 0) && (endptr != str) && (*endptr == 0));
 }
 
 
 void OS::RegisterCodeObservers() {
@@ skipping 16 matching lines @@
 void OS::InitOnce() {
   // TODO(5411554): For now we check that initonce is called only once,
   // Once there is more formal mechanism to call InitOnce we can move
   // this check there.
   static bool init_once_called = false;
   ASSERT(init_once_called == false);
   init_once_called = true;
 }
 
 
-void OS::Shutdown() {
-}
+void OS::Shutdown() {}
 
 
 void OS::Abort() {
   abort();
 }
 
 
 void OS::Exit(int code) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_FUCHSIA)