clang-format runtime/vm

runtime/vm/native_arguments.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_VM_NATIVE_ARGUMENTS_H_
 #define RUNTIME_VM_NATIVE_ARGUMENTS_H_
 
 #include "platform/assert.h"
 #include "platform/memory_sanitizer.h"
 #include "vm/globals.h"
@@ skipping 10 matching lines @@
 class RawObject;
 class Simulator;
 class Thread;
 
 #if defined(TESTING) || defined(DEBUG)
 
 #if defined(TARGET_ARCH_DBC)
 // C-stack is always aligned on DBC because we don't have any native code.
 #define CHECK_STACK_ALIGNMENT
 #elif defined(USING_SIMULATOR)
-#define CHECK_STACK_ALIGNMENT {                                                \
-  uword current_sp = Simulator::Current()->get_register(SPREG);                \
-  ASSERT(Utils::IsAligned(current_sp, OS::ActivationFrameAlignment()));        \
-}
+#define CHECK_STACK_ALIGNMENT                                                  \
+  {                                                                            \
+    uword current_sp = Simulator::Current()->get_register(SPREG);              \
+    ASSERT(Utils::IsAligned(current_sp, OS::ActivationFrameAlignment()));      \
+  }
 #elif defined(TARGET_OS_WINDOWS)
 // The compiler may dynamically align the stack on Windows, so do not check.
-#define CHECK_STACK_ALIGNMENT { }
+#define CHECK_STACK_ALIGNMENT                                                  \
+  {}
 #else
-#define CHECK_STACK_ALIGNMENT {                                                \
-  uword (*func)() = reinterpret_cast<uword (*)()>(                             \
-      StubCode::GetStackPointer_entry()->EntryPoint());                        \
-  uword current_sp = func();                                                   \
-  ASSERT(Utils::IsAligned(current_sp, OS::ActivationFrameAlignment()));        \
-}
+#define CHECK_STACK_ALIGNMENT                                                  \
+  {                                                                            \
+    uword (*func)() = reinterpret_cast<uword (*)()>(                           \
+        StubCode::GetStackPointer_entry()->EntryPoint());                      \
+    uword current_sp = func();                                                 \
+    ASSERT(Utils::IsAligned(current_sp, OS::ActivationFrameAlignment()));      \
+  }
 #endif
 
 void VerifyOnTransition();
 
 #define VERIFY_ON_TRANSITION                                                   \
   if (FLAG_verify_on_transition) {                                             \
     VerifyOnTransition();                                                      \
   }
 #define DEOPTIMIZE_ALOT                                                        \
   if (FLAG_deoptimize_alot) {                                                  \
     DeoptimizeFunctionsOnStack();                                              \
   }
 
 #else
 
-#define CHECK_STACK_ALIGNMENT { }
-#define VERIFY_ON_TRANSITION { }
-#define DEOPTIMIZE_ALOT { }
+#define CHECK_STACK_ALIGNMENT                                                  \
+  {}
+#define VERIFY_ON_TRANSITION                                                   \
+  {}
+#define DEOPTIMIZE_ALOT                                                        \
+  {}
 
 #endif
 
 #ifndef PRODUCT
 #define TRACE_NATIVE_CALL(format, name)                                        \
   if (FLAG_trace_natives) {                                                    \
     OS::Print("Calling native: " format "\n", name);                           \
   }
 #else
 #define TRACE_NATIVE_CALL(format, name)                                        \
-  do { } while (0)
+  do {                                                                         \
+  } while (0)
 #endif
 
 // Class NativeArguments is used to access arguments passed in from
 // generated dart code to a runtime function or a dart library native
 // function. It is also used to set the return value if any at the slot
 // reserved for return values.
 // All runtime function/dart library native functions have the
 // following signature:
 //   void function_name(NativeArguments arguments);
 // Inside the function, arguments are accessed as follows:
@@ skipping 47 matching lines @@
   RawObject* NativeArgAt(int index) const {
     ASSERT((index >= 0) && (index < NativeArgCount()));
     if (index == 0) {
       return NativeArg0();
     }
     int function_bits = FunctionBits::decode(argc_tag_);
     const int actual_index = index + NumHiddenArgs(function_bits);
     return ArgAt(actual_index);
   }
 
-  void SetReturn(const Object& value) const {
-    *retval_ = value.raw();
-  }
+  void SetReturn(const Object& value) const { *retval_ = value.raw(); }
 
   RawObject* ReturnValue() const {
     // Tell MemorySanitizer the retval_ was initialized (by generated code).
     MSAN_UNPOISON(retval_, kWordSize);
     return *retval_;
   }
 
   static intptr_t thread_offset() {
     return OFFSET_OF(NativeArguments, thread_);
   }
@@ skipping 46 matching lines @@
     kClosureFunctionBit = 2,
   };
   enum ArgcTagBits {
     kArgcBit = 0,
     kArgcSize = 24,
     kFunctionBit = 24,
     kFunctionSize = 2,
     kAutoSetupScopeBit = 26,
   };
   class ArgcBits : public BitField<intptr_t, int32_t, kArgcBit, kArgcSize> {};
-  class FunctionBits :
-      public BitField<intptr_t, int, kFunctionBit, kFunctionSize> {};
-  class AutoSetupScopeBits :
-      public BitField<intptr_t, int, kAutoSetupScopeBit, 1> {};
+  class FunctionBits
+      : public BitField<intptr_t, int, kFunctionBit, kFunctionSize> {};
+  class AutoSetupScopeBits
+      : public BitField<intptr_t, int, kAutoSetupScopeBit, 1> {};
   friend class Api;
   friend class BootstrapNatives;
   friend class Simulator;
 
 #if defined(TARGET_ARCH_DBC)
   // Allow simulator to create NativeArguments on the stack.
   NativeArguments(Thread* thread,
                   int argc_tag,
                   RawObject** argv,
                   RawObject** retval)
-      : thread_(thread), argc_tag_(argc_tag), argv_(argv), retval_(retval) {
-  }
+      : thread_(thread), argc_tag_(argc_tag), argv_(argv), retval_(retval) {}
 #endif
 
   // Since this function is passed a RawObject directly, we need to be
   // exceedingly careful when we use it.  If there are any other side
   // effects in the statement that may cause GC, it could lead to
   // bugs.
-  void SetReturnUnsafe(RawObject* value) const {
-    *retval_ = value;
-  }
+  void SetReturnUnsafe(RawObject* value) const { *retval_ = value; }
 
   // Returns true if the arguments are those of an instance function call.
   bool ToInstanceFunction() const {
     return (FunctionBits::decode(argc_tag_) & kInstanceFunctionBit);
   }
 
   // Returns true if the arguments are those of a closure function call.
   bool ToClosureFunction() const {
     return (FunctionBits::decode(argc_tag_) & kClosureFunctionBit);
   }
 
   int NumHiddenArgs(int function_bits) const {
     // For static closure functions, the closure at index 0 is hidden.
     // In the instance closure function case, the receiver is accessed from
     // the context and the closure at index 0 is hidden, so the apparent
     // argument count remains unchanged.
     if (function_bits == kClosureFunctionBit) {
       return 1;
     }
     return 0;
   }
 
-  Thread* thread_;  // Current thread pointer.
-  intptr_t argc_tag_;  // Encodes argument count and invoked native call type.
-  RawObject** argv_;  // Pointer to an array of arguments to runtime call.
+  Thread* thread_;      // Current thread pointer.
+  intptr_t argc_tag_;   // Encodes argument count and invoked native call type.
+  RawObject** argv_;    // Pointer to an array of arguments to runtime call.
   RawObject** retval_;  // Pointer to the return value area.
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_NATIVE_ARGUMENTS_H_