clang-format runtime/vm

runtime/vm/os_linux.cc

 // Copyright (c) 2012, 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_LINUX)
 
 #include "vm/os.h"
 
-#include <errno.h>  // NOLINT
-#include <limits.h>  // NOLINT
-#include <malloc.h>  // NOLINT
-#include <time.h>  // NOLINT
+#include <errno.h>         // NOLINT
+#include <limits.h>        // NOLINT
+#include <malloc.h>        // NOLINT
+#include <time.h>          // NOLINT
 #include <sys/resource.h>  // NOLINT
-#include <sys/time.h>  // NOLINT
-#include <sys/types.h>  // NOLINT
-#include <sys/syscall.h>  // NOLINT
-#include <sys/stat.h>  // NOLINT
-#include <fcntl.h>  // NOLINT
-#include <unistd.h>  // NOLINT
+#include <sys/time.h>      // NOLINT
+#include <sys/types.h>     // NOLINT
+#include <sys/syscall.h>   // NOLINT
+#include <sys/stat.h>      // NOLINT
+#include <fcntl.h>         // NOLINT
+#include <unistd.h>        // NOLINT
 
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 #include "vm/code_observers.h"
 #include "vm/dart.h"
 #include "vm/flags.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/os_thread.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");
 
 // Linux CodeObservers.
 class PerfCodeObserver : public CodeObserver {
  public:
   PerfCodeObserver() : out_file_(NULL) {
     Dart_FileOpenCallback file_open = Dart::file_open_callback();
     if (file_open == NULL) {
       return;
     }
     intptr_t pid = getpid();
@@ skipping 17 matching lines @@
   virtual void Notify(const char* name,
                       uword base,
                       uword prologue_offset,
                       uword size,
                       bool optimized) {
     Dart_FileWriteCallback file_write = Dart::file_write_callback();
     if ((file_write == NULL) || (out_file_ == NULL)) {
       return;
     }
     const char* marker = optimized ? "*" : "";
-    char* buffer = OS::SCreate(Thread::Current()->zone(),
-        "%" Px " %" Px " %s%s\n", base, size, marker, name);
+    char* buffer =
+        OS::SCreate(Thread::Current()->zone(), "%" Px " %" Px " %s%s\n", base,
+                    size, marker, name);
     {
       MutexLocker ml(CodeObservers::mutex());
       (*file_write)(buffer, strlen(buffer), out_file_);
     }
   }
 
  private:
   void* out_file_;
 
   DISALLOW_COPY_AND_ASSIGN(PerfCodeObserver);
@@ skipping 97 matching lines @@
   int64_t result = ts.tv_sec;
   result *= kMicrosecondsPerSecond;
   result += (ts.tv_nsec / kNanosecondsPerMicrosecond);
   return result;
 }
 
 
 // TODO(5411554):  May need to hoist these architecture dependent code
 // into a architecture specific file e.g: os_ia32_linux.cc
 intptr_t OS::ActivationFrameAlignment() {
-#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 = 16;
 #elif defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_MIPS)
   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 135 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) {
   exit(code);
 }
 
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_LINUX)