Add .clang-format and run clang-format on runtime/platform.

runtime/platform/globals.h

 // 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.
 
 #ifndef RUNTIME_PLATFORM_GLOBALS_H_
 #define RUNTIME_PLATFORM_GLOBALS_H_
 
 // __STDC_FORMAT_MACROS has to be defined before including <inttypes.h> to
 // enable platform independent printf format specifiers.
 #ifndef __STDC_FORMAT_MACROS
@@ skipping 177 matching lines @@
   void writeTo(int32_t* v) {
     v[0] = int_storage[0];
     v[1] = int_storage[1];
     v[2] = int_storage[2];
     v[3] = int_storage[3];
   }
   void writeTo(double* v) {
     v[0] = double_storage[0];
     v[1] = double_storage[1];
   }
-  void writeTo(simd128_value_t* v) {
-    *v = *this;
-  }
+  void writeTo(simd128_value_t* v) { *v = *this; }
 };
 
 // Processor architecture detection.  For more info on what's defined, see:
 //   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
 //   http://www.agner.org/optimize/calling_conventions.pdf
 //   or with gcc, run: "echo | gcc -E -dM -"
 #if defined(_M_X64) || defined(__x86_64__)
 #define HOST_ARCH_X64 1
 #define ARCH_IS_64_BIT 1
 #define kFpuRegisterSize 16
@@ skipping 10 matching lines @@
 #endif
 #elif defined(__ARMEL__)
 #define HOST_ARCH_ARM 1
 #define ARCH_IS_32_BIT 1
 #define kFpuRegisterSize 16
 // Mark the fact that we have defined simd_value_t.
 #define SIMD_VALUE_T_
 typedef struct {
   union {
     uint32_t u;
-    float    f;
+    float f;
   } data_[4];
 } simd_value_t;
 typedef simd_value_t fpu_register_t;
-#define simd_value_safe_load(addr)                                             \
-  (*reinterpret_cast<simd_value_t *>(addr))
+#define simd_value_safe_load(addr) (*reinterpret_cast<simd_value_t*>(addr))
 #define simd_value_safe_store(addr, value)                                     \
   do {                                                                         \
-    reinterpret_cast<simd_value_t *>(addr)->data_[0] = value.data_[0];         \
-    reinterpret_cast<simd_value_t *>(addr)->data_[1] = value.data_[1];         \
-    reinterpret_cast<simd_value_t *>(addr)->data_[2] = value.data_[2];         \
-    reinterpret_cast<simd_value_t *>(addr)->data_[3] = value.data_[3];         \
+    reinterpret_cast<simd_value_t*>(addr)->data_[0] = value.data_[0];          \
+    reinterpret_cast<simd_value_t*>(addr)->data_[1] = value.data_[1];          \
+    reinterpret_cast<simd_value_t*>(addr)->data_[2] = value.data_[2];          \
+    reinterpret_cast<simd_value_t*>(addr)->data_[3] = value.data_[3];          \
   } while (0)
 
 #elif defined(__MIPSEL__)
 #define HOST_ARCH_MIPS 1
 #define ARCH_IS_32_BIT 1
 #define kFpuRegisterSize 8
 typedef double fpu_register_t;
 #elif defined(__aarch64__)
 #define HOST_ARCH_ARM64 1
 #define ARCH_IS_64_BIT 1
@@ skipping 75 matching lines @@
 #endif
 #endif
 #endif
 #endif
 #endif
 #endif
 #endif
 
 // Verify that host and target architectures match, we cannot
 // have a 64 bit Dart VM generating 32 bit code or vice-versa.
-#if defined(TARGET_ARCH_X64) ||                                                \
-    defined(TARGET_ARCH_ARM64)
+#if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_ARM64)
 #if !defined(ARCH_IS_64_BIT)
 #error Mismatched Host/Target architectures.
 #endif
-#elif defined(TARGET_ARCH_IA32) ||                                             \
-      defined(TARGET_ARCH_ARM) ||                                              \
-      defined(TARGET_ARCH_MIPS)
+#elif defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_ARM) ||                 \
+    defined(TARGET_ARCH_MIPS)
 #if !defined(ARCH_IS_32_BIT)
 #error Mismatched Host/Target architectures.
 #endif
 #endif
 
 // Determine whether we will be using the simulator.
 #if defined(TARGET_ARCH_IA32)
-  // No simulator used.
+// No simulator used.
 #elif defined(TARGET_ARCH_X64)
-  // No simulator used.
+// No simulator used.
 #elif defined(TARGET_ARCH_ARM)
 #if !defined(HOST_ARCH_ARM)
 #define USING_SIMULATOR 1
 #endif
 
 #elif defined(TARGET_ARCH_ARM64)
 #if !defined(HOST_ARCH_ARM64)
 #define USING_SIMULATOR 1
 #endif
 
@@ skipping 56 matching lines @@
 
 // Replace calls to strtoll with _strtoi64 on Windows.
 #ifdef _MSC_VER
 #define strtoll _strtoi64
 #endif
 
 // The following macro works on both 32 and 64-bit platforms.
 // Usage: instead of writing 0x1234567890123456ULL
 //      write DART_2PART_UINT64_C(0x12345678,90123456);
 #define DART_2PART_UINT64_C(a, b)                                              \
-                 (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
+  (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
 
 // Integer constants.
 const int32_t kMinInt32 = 0x80000000;
 const int32_t kMaxInt32 = 0x7FFFFFFF;
 const uint32_t kMaxUint32 = 0xFFFFFFFF;
 const int64_t kMinInt64 = DART_INT64_C(0x8000000000000000);
 const int64_t kMaxInt64 = DART_INT64_C(0x7FFFFFFFFFFFFFFF);
 const uint64_t kMaxUint64 = DART_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF);
 const int64_t kSignBitDouble = DART_INT64_C(0x8000000000000000);
 
 // Types for native machine words. Guaranteed to be able to hold pointers and
 // integers.
 typedef intptr_t word;
 typedef uintptr_t uword;
 
 // Size of a class id.
 #if defined(ARCH_IS_32_BIT)
 typedef uint16_t classid_t;
 #elif defined(ARCH_IS_64_BIT)
 typedef uint32_t classid_t;
 #else
 #error Unexpected architecture word size
 #endif
 
 // Byte sizes.
 const int kWordSize = sizeof(word);
 const int kDoubleSize = sizeof(double);  // NOLINT
-const int kFloatSize = sizeof(float);  // NOLINT
+const int kFloatSize = sizeof(float);    // NOLINT
 const int kQuadSize = 4 * kFloatSize;
 const int kSimd128Size = sizeof(simd128_value_t);  // NOLINT
-const int kInt32Size = sizeof(int32_t);  // NOLINT
-const int kInt16Size = sizeof(int16_t);  // NOLINT
+const int kInt32Size = sizeof(int32_t);            // NOLINT
+const int kInt16Size = sizeof(int16_t);            // NOLINT
 #ifdef ARCH_IS_32_BIT
 const int kWordSizeLog2 = 2;
 const uword kUwordMax = kMaxUint32;
 #else
 const int kWordSizeLog2 = 3;
 const uword kUwordMax = kMaxUint64;
 #endif
 
 // Bit sizes.
 const int kBitsPerByte = 8;
@@ skipping 28 matching lines @@
   return (size_in_words + (GBInWords >> 1)) >> GBInWordsLog2;
 }
 
 const intptr_t kIntptrOne = 1;
 const intptr_t kIntptrMin = (kIntptrOne << (kBitsPerWord - 1));
 const intptr_t kIntptrMax = ~kIntptrMin;
 
 // Time constants.
 const int kMillisecondsPerSecond = 1000;
 const int kMicrosecondsPerMillisecond = 1000;
-const int kMicrosecondsPerSecond = (kMicrosecondsPerMillisecond *
-                                    kMillisecondsPerSecond);
+const int kMicrosecondsPerSecond =
+    (kMicrosecondsPerMillisecond * kMillisecondsPerSecond);
 const int kNanosecondsPerMicrosecond = 1000;
-const int kNanosecondsPerMillisecond = (kNanosecondsPerMicrosecond *
-                                        kMicrosecondsPerMillisecond);
-const int kNanosecondsPerSecond = (kNanosecondsPerMicrosecond *
-                                   kMicrosecondsPerSecond);
+const int kNanosecondsPerMillisecond =
+    (kNanosecondsPerMicrosecond * kMicrosecondsPerMillisecond);
+const int kNanosecondsPerSecond =
+    (kNanosecondsPerMicrosecond * kMicrosecondsPerSecond);
 
 // Helpers to scale micro second times to human understandable values.
 inline double MicrosecondsToSeconds(int64_t micros) {
   return static_cast<double>(micros) / kMicrosecondsPerSecond;
 }
 inline double MicrosecondsToMilliseconds(int64_t micros) {
   return static_cast<double>(micros) / kMicrosecondsPerMillisecond;
 }
 
 // A macro to disallow the copy constructor and operator= functions.
 // This should be used in the private: declarations for a class.
 #if !defined(DISALLOW_COPY_AND_ASSIGN)
 #define DISALLOW_COPY_AND_ASSIGN(TypeName)                                     \
-private:                                                                       \
+ private:                                                                      \
   TypeName(const TypeName&);                                                   \
   void operator=(const TypeName&)
 #endif  // !defined(DISALLOW_COPY_AND_ASSIGN)
 
 // A macro to disallow all the implicit constructors, namely the default
 // constructor, copy constructor and operator= functions. This should be
 // used in the private: declarations for a class that wants to prevent
 // anyone from instantiating it. This is especially useful for classes
 // containing only static methods.
 #if !defined(DISALLOW_IMPLICIT_CONSTRUCTORS)
 #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName)                               \
-private:                                                                       \
+ private:                                                                      \
   TypeName();                                                                  \
   DISALLOW_COPY_AND_ASSIGN(TypeName)
 #endif  // !defined(DISALLOW_IMPLICIT_CONSTRUCTORS)
 
 // Macro to disallow allocation in the C++ heap. This should be used
 // in the private section for a class. Don't use UNREACHABLE here to
 // avoid circular dependencies between platform/globals.h and
 // platform/assert.h.
 #if !defined(DISALLOW_ALLOCATION)
 #define DISALLOW_ALLOCATION()                                                  \
-public:                                                                        \
+ public:                                                                       \
   void operator delete(void* pointer) {                                        \
     fprintf(stderr, "unreachable code\n");                                     \
     abort();                                                                   \
   }                                                                            \
-private:                                                                       \
+                                                                               \
+ private:                                                                      \
   void* operator new(size_t size);
 #endif  // !defined(DISALLOW_ALLOCATION)
 
 // The USE(x) template is used to silence C++ compiler warnings issued
 // for unused variables.
 template <typename T>
-static inline void USE(T) { }
+static inline void USE(T) {}
 
 
 // Use implicit_cast as a safe version of static_cast or const_cast
 // for upcasting in the type hierarchy (i.e. casting a pointer to Foo
 // to a pointer to SuperclassOfFoo or casting a pointer to Foo to
 // a const pointer to Foo).
 // When you use implicit_cast, the compiler checks that the cast is safe.
 // Such explicit implicit_casts are necessary in surprisingly many
 // situations where C++ demands an exact type match instead of an
 // argument type convertable to a target type.
 //
 // The From type can be inferred, so the preferred syntax for using
 // implicit_cast is the same as for static_cast etc.:
 //
 //   implicit_cast<ToType>(expr)
 //
 // implicit_cast would have been part of the C++ standard library,
 // but the proposal was submitted too late.  It will probably make
 // its way into the language in the future.
-template<typename To, typename From>
-inline To implicit_cast(From const &f) {
+template <typename To, typename From>
+inline To implicit_cast(From const& f) {
   return f;
 }
 
 
 // Use like this: down_cast<T*>(foo);
-template<typename To, typename From>  // use like this: down_cast<T*>(foo);
-inline To down_cast(From* f) {  // so we only accept pointers
+template <typename To, typename From>  // use like this: down_cast<T*>(foo);
+inline To down_cast(From* f) {         // so we only accept pointers
   // Ensures that To is a sub-type of From *.  This test is here only
   // for compile-time type checking, and has no overhead in an
   // optimized build at run-time, as it will be optimized away completely.
   if (false) {
     implicit_cast<From, To>(0);
   }
   return static_cast<To>(f);
 }
 
 
@@ skipping 33 matching lines @@
   memcpy(&destination, &source, sizeof(destination));
   return destination;
 }
 
 
 // Similar to bit_cast, but allows copying from types of unrelated
 // sizes. This method was introduced to enable the strict aliasing
 // optimizations of GCC 4.4. Basically, GCC mindlessly relies on
 // obscure details in the C++ standard that make reinterpret_cast
 // virtually useless.
-template<class D, class S>
+template <class D, class S>
 inline D bit_copy(const S& source) {
   D destination;
   // This use of memcpy is safe: source and destination cannot overlap.
-  memcpy(&destination,
-         reinterpret_cast<const void*>(&source),
+  memcpy(&destination, reinterpret_cast<const void*>(&source),
          sizeof(destination));
   return destination;
 }
 
 
 // Similar to bit_copy and bit_cast, but does take the type from the argument.
 template <typename T>
 static inline T ReadUnaligned(const T* ptr) {
   T value;
   memcpy(&value, ptr, sizeof(value));
@@ skipping 18 matching lines @@
 #endif  // !defined(TARGET_OS_WINDOWS)
 
 #if defined(TARGET_OS_LINUX) || defined(TARGET_OS_MACOS)
 // Tell the compiler to do printf format string checking if the
 // compiler supports it; see the 'format' attribute in
 // <http://gcc.gnu.org/onlinedocs/gcc-4.3.0/gcc/Function-Attributes.html>.
 //
 // N.B.: As the GCC manual states, "[s]ince non-static C++ methods
 // have an implicit 'this' argument, the arguments of such methods
 // should be counted from two, not one."
-#define PRINTF_ATTRIBUTE(string_index, first_to_check) \
+#define PRINTF_ATTRIBUTE(string_index, first_to_check)                         \
   __attribute__((__format__(__printf__, string_index, first_to_check)))
 #else
 #define PRINTF_ATTRIBUTE(string_index, first_to_check)
 #endif
 
 #if defined(_WIN32)
 #define STDIN_FILENO 0
 #define STDOUT_FILENO 1
 #define STDERR_FILENO 2
 #endif
 
 // For checking deterministic graph generation, we can store instruction
 // tag in the ICData and check it when recreating the flow graph in
 // optimizing compiler. Enable it for other modes (product, release) if needed
 // for debugging.
 #if defined(DEBUG)
 #define TAG_IC_DATA
 #endif
 
 }  // namespace dart
 
 #endif  // RUNTIME_PLATFORM_GLOBALS_H_