clang-format runtime/vm

runtime/vm/assembler_dbc_test.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_ARCH_DBC)
 
 #include "vm/assembler.h"
 #include "vm/stack_frame.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 static RawObject* ExecuteTest(const Code& code) {
   Thread* thread = Thread::Current();
   TransitionToGenerated transition(thread);
-  return Simulator::Current()->Call(
-      code,
-      Array::Handle(ArgumentsDescriptor::New(0)),
-      Array::Handle(Array::New(0)),
-      thread);
+  return Simulator::Current()->Call(code,
+                                    Array::Handle(ArgumentsDescriptor::New(0)),
+                                    Array::Handle(Array::New(0)), thread);
 }
 
 
 #define EXECUTE_TEST_CODE_INTPTR(code)                                         \
-    Smi::Value(Smi::RawCast(ExecuteTest(code)))
+  Smi::Value(Smi::RawCast(ExecuteTest(code)))
 #define EXECUTE_TEST_CODE_BOOL(code)                                           \
-    (Bool::RawCast(ExecuteTest(code)) == Bool::True().raw())
-#define EXECUTE_TEST_CODE_OBJECT(code)                                         \
-    Object::Handle(ExecuteTest(code))
+  (Bool::RawCast(ExecuteTest(code)) == Bool::True().raw())
+#define EXECUTE_TEST_CODE_OBJECT(code) Object::Handle(ExecuteTest(code))
 #define EXECUTE_TEST_CODE_DOUBLE(code)                                         \
-    bit_cast<double, RawObject*>(ExecuteTest(code))
+  bit_cast<double, RawObject*>(ExecuteTest(code))
 
 #define __ assembler->
 
 
 static RawClass* CreateDummyClass(const String& class_name,
                                   const Script& script) {
   const Class& cls = Class::Handle(Class::New(
       Library::Handle(), class_name, script, TokenPosition::kNoSource));
   cls.set_is_synthesized_class();  // Dummy class for testing.
   return cls.raw();
 }
 
 
 static RawLibrary* CreateDummyLibrary(const String& library_name) {
   return Library::New(library_name);
 }
 
 
 static RawFunction* CreateFunction(const char* name) {
   Thread* thread = Thread::Current();
   const String& class_name = String::Handle(Symbols::New(thread, "ownerClass"));
   const String& lib_name = String::Handle(Symbols::New(thread, "ownerLibrary"));
   const Script& script = Script::Handle();
   const Class& owner_class =
       Class::Handle(CreateDummyClass(class_name, script));
-  const Library& owner_library =
-      Library::Handle(CreateDummyLibrary(lib_name));
+  const Library& owner_library = Library::Handle(CreateDummyLibrary(lib_name));
   owner_class.set_library(owner_library);
   const String& function_name = String::ZoneHandle(Symbols::New(thread, name));
-  return Function::New(function_name, RawFunction::kRegularFunction,
-                       true, false, false, false, false, owner_class,
+  return Function::New(function_name, RawFunction::kRegularFunction, true,
+                       false, false, false, false, owner_class,
                        TokenPosition::kMinSource);
 }
 
 
 static void GenerateDummyCode(Assembler* assembler, const Object& result) {
   __ PushConstant(result);
   __ ReturnTOS();
 }
 
 
 static void MakeDummyInstanceCall(Assembler* assembler, const Object& result) {
   // Make a dummy function.
   Assembler _assembler_;
   GenerateDummyCode(&_assembler_, result);
   const char* dummy_function_name = "dummy_instance_function";
   const Function& dummy_instance_function =
       Function::Handle(CreateFunction(dummy_function_name));
   Code& code =
       Code::Handle(Code::FinalizeCode(dummy_instance_function, &_assembler_));
   dummy_instance_function.AttachCode(code);
 
   // Make a dummy ICData.
   const Array& dummy_arguments_descriptor =
       Array::Handle(ArgumentsDescriptor::New(2));
   const ICData& ic_data = ICData::Handle(ICData::New(
-      dummy_instance_function,
-      String::Handle(dummy_instance_function.name()),
-      dummy_arguments_descriptor,
-      Thread::kNoDeoptId,
-      2,
+      dummy_instance_function, String::Handle(dummy_instance_function.name()),
+      dummy_arguments_descriptor, Thread::kNoDeoptId, 2,
       /* is_static_call= */ false));
 
   // Wire up the Function in the ICData.
   GrowableArray<intptr_t> cids(2);
   cids.Add(kSmiCid);
   cids.Add(kSmiCid);
   ic_data.AddCheck(cids, dummy_instance_function);
 
   // For the non-Smi tests.
   cids[0] = kBigintCid;
@@ skipping 1625 matching lines @@
   __ LoadConstant(1, Smi::Handle(Smi::New(2)));
   __ Return(1);
 }
 
 
 ASSEMBLER_TEST_RUN(TestCidsNoMatch, test) {
   EXPECT_EQ(2, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
-
 //  - CheckSmi rA
 //
 //    If FP[rA] is a Smi, then skip the next instruction.
 ASSEMBLER_TEST_GENERATE(CheckSmiPass, assembler) {
   __ Frame(1);
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ LoadConstant(0, Smi::Handle(Smi::New(0)));
   __ CheckSmi(0);
   __ PushConstant(Smi::Handle(Smi::New(-1)));
   __ ReturnTOS();
@@ skipping 1070 matching lines @@
 
 ASSEMBLER_TEST_RUN(DMax, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
 #endif  // defined(ARCH_IS_64_BIT)
 
 }  // namespace dart
 
 #endif  // defined(TARGET_ARCH_DBC)