clang-format runtime/vm

runtime/vm/assembler_ia32_test.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_ARCH_IA32)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/os.h"
@@ skipping 89 matching lines @@
 
 
 ASSEMBLER_TEST_RUN(AddressingModes, test) {
   // Avoid running the code since it is constructed to lead to crashes.
 }
 
 
 ASSEMBLER_TEST_GENERATE(JumpAroundCrash, assembler) {
   Label done;
   // Make sure all the condition jumps work.
-  for (Condition condition = OVERFLOW;
-       condition <= GREATER;
+  for (Condition condition = OVERFLOW; condition <= GREATER;
        condition = static_cast<Condition>(condition + 1)) {
     __ j(condition, &done);
   }
   // This isn't strictly necessary, but we do an unconditional
   // jump around the crashing code anyway.
   __ jmp(&done);
 
   // Be sure to skip this crashing code.
   __ movl(EAX, Immediate(0));
   __ movl(Address(EAX, 0), EAX);
 
   __ Bind(&done);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(JumpAroundCrash, test) {
   Instr* instr = Instr::At(test->entry());
   EXPECT(!instr->IsBreakPoint());
   typedef void (*JumpAroundCrashCode)();
   reinterpret_cast<JumpAroundCrashCode>(test->entry())();
 }
 
 
 ASSEMBLER_TEST_GENERATE(NearJumpAroundCrash, assembler) {
   Label done;
   // Make sure all the condition jumps work.
-  for (Condition condition = OVERFLOW;
-       condition <= GREATER;
+  for (Condition condition = OVERFLOW; condition <= GREATER;
        condition = static_cast<Condition>(condition + 1)) {
     __ j(condition, &done, Assembler::kNearJump);
   }
   // This isn't strictly necessary, but we do an unconditional
   // jump around the crashing code anyway.
   __ jmp(&done, Assembler::kNearJump);
 
   // Be sure to skip this crashing code.
   __ movl(EAX, Immediate(0));
   __ movl(Address(EAX, 0), EAX);
@@ skipping 201 matching lines @@
   EXPECT_EQ(1, call(3));
   EXPECT_EQ(2, call(4));
   EXPECT_EQ(5, call(42));
   EXPECT_EQ(31, call(-1));
 }
 
 
 ASSEMBLER_TEST_GENERATE(MoveExtend, assembler) {
   __ pushl(EBX);  // preserve EBX.
   __ movl(EDX, Immediate(0x1234ffff));
-  __ movzxb(EAX, DL);  // EAX = 0xff
+  __ movzxb(EAX, DL);   // EAX = 0xff
   __ movsxw(EBX, EDX);  // EBX = -1
   __ movzxw(ECX, EDX);  // ECX = 0xffff
   __ addl(EBX, ECX);
   __ addl(EAX, EBX);
   __ popl(EBX);  // restore EBX.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(MoveExtend, test) {
@@ skipping 29 matching lines @@
 ASSEMBLER_TEST_GENERATE(Bitwise, assembler) {
   __ movl(ECX, Immediate(42));
   __ xorl(ECX, ECX);
   __ orl(ECX, Immediate(0x100));
   __ movl(EAX, Immediate(0x648));
   __ orl(ECX, EAX);  // 0x748.
   __ movl(EAX, Immediate(0xfff0));
   __ andl(ECX, EAX);  // 0x740.
   __ pushl(Immediate(0xF6FF));
   __ andl(ECX, Address(ESP, 0));  // 0x640.
-  __ popl(EAX);  // Discard.
+  __ popl(EAX);                   // Discard.
   __ movl(EAX, Immediate(1));
   __ orl(ECX, EAX);  // 0x641.
   __ pushl(Immediate(0x7));
   __ orl(ECX, Address(ESP, 0));  // 0x647.
-  __ popl(EAX);  // Discard.
-  __ xorl(ECX, Immediate(0));  // 0x647.
+  __ popl(EAX);                  // Discard.
+  __ xorl(ECX, Immediate(0));    // 0x647.
   __ pushl(Immediate(0x1C));
   __ xorl(ECX, Address(ESP, 0));  // 0x65B.
-  __ popl(EAX);  // Discard.
+  __ popl(EAX);                   // Discard.
   __ movl(EAX, Address(ESP, kWordSize));
   __ movl(EDX, Immediate(0xB0));
   __ orl(Address(EAX, 0), EDX);
   __ movl(EAX, ECX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Bitwise, test) {
   typedef int (*Bitwise)(int* value);
@@ skipping 337 matching lines @@
 
 
 ASSEMBLER_TEST_RUN(Exchange, test) {
   typedef int (*Exchange)();
   EXPECT_EQ(987654321 - 123456789, reinterpret_cast<Exchange>(test->entry())());
 }
 
 
 static int ComputeStackSpaceReservation(int needed, int fixed) {
   return (OS::ActivationFrameAlignment() > 1)
-      ? Utils::RoundUp(needed + fixed, OS::ActivationFrameAlignment()) - fixed
-      : needed;
+             ? Utils::RoundUp(needed + fixed, OS::ActivationFrameAlignment()) -
+                   fixed
+             : needed;
 }
 
 
 static int LeafReturn42() {
   return 42;
 }
 
 
 static int LeafReturnArgument(int x) {
   return x + 87;
@@ skipping 82 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(SingleFPMoves, test) {
   typedef float (*SingleFPMovesCode)();
   float res = reinterpret_cast<SingleFPMovesCode>(test->entry())();
   EXPECT_EQ(234.0f, res);
 }
 
 
-
 ASSEMBLER_TEST_GENERATE(SingleFPMoves2, assembler) {
   __ pushl(EBX);  // preserve EBX.
   __ pushl(ECX);  // preserve ECX.
   __ movl(EBX, Immediate(bit_cast<int32_t, float>(234.0f)));
   __ movd(XMM0, EBX);
   __ movss(XMM1, XMM0);
   __ movd(ECX, XMM1);
   __ pushl(ECX);
   __ flds(Address(ESP, 0));
   __ popl(EAX);
@@ skipping 54 matching lines @@
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedFPOperations, assembler) {
   __ movl(EAX, Immediate(bit_cast<int32_t, float>(12.3f)));
   __ movd(XMM0, EAX);
   __ shufps(XMM0, XMM0, Immediate(0x0));
   __ movl(EAX, Immediate(bit_cast<int32_t, float>(3.4f)));
   __ movd(XMM1, EAX);
   __ shufps(XMM1, XMM1, Immediate(0x0));
-  __ addps(XMM0, XMM1);  // 15.7f
-  __ mulps(XMM0, XMM1);  // 53.38f
-  __ subps(XMM0, XMM1);  // 49.98f
-  __ divps(XMM0, XMM1);  // 14.7f
+  __ addps(XMM0, XMM1);                    // 15.7f
+  __ mulps(XMM0, XMM1);                    // 53.38f
+  __ subps(XMM0, XMM1);                    // 49.98f
+  __ divps(XMM0, XMM1);                    // 14.7f
   __ shufps(XMM0, XMM0, Immediate(0x55));  // Copy second lane into all 4 lanes.
   __ pushl(EAX);
   // Copy the low lane at ESP.
   __ movss(Address(ESP, 0), XMM0);
   __ flds(Address(ESP, 0));
   __ popl(EAX);
   __ ret();
 }
 
 
@@ skipping 27 matching lines @@
   uint32_t res = reinterpret_cast<PackedIntOperationsCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x5), res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedFPOperations2, assembler) {
   __ movl(EAX, Immediate(bit_cast<int32_t, float>(4.0f)));
   __ movd(XMM0, EAX);
   __ shufps(XMM0, XMM0, Immediate(0x0));
 
-  __ movaps(XMM1, XMM0);  // Copy XMM0
-  __ reciprocalps(XMM1);  // 0.25
-  __ sqrtps(XMM1);  // 0.5
-  __ rsqrtps(XMM0);  // ~0.5
-  __ subps(XMM0, XMM1);  // ~0.0
+  __ movaps(XMM1, XMM0);                   // Copy XMM0
+  __ reciprocalps(XMM1);                   // 0.25
+  __ sqrtps(XMM1);                         // 0.5
+  __ rsqrtps(XMM0);                        // ~0.5
+  __ subps(XMM0, XMM1);                    // ~0.0
   __ shufps(XMM0, XMM0, Immediate(0x00));  // Copy second lane into all 4 lanes.
   __ pushl(EAX);
   // Copy the low lane at ESP.
   __ movss(Address(ESP, 0), XMM0);
   __ flds(Address(ESP, 0));
   __ popl(EAX);
   __ ret();
 }
 
 
@@ skipping 227 matching lines @@
   EXPECT_FLOAT_EQ(4.0f, res, 0.001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedLogicalOr, assembler) {
   static const struct ALIGN16 {
     uint32_t a;
     uint32_t b;
     uint32_t c;
     uint32_t d;
-  } constant1 =
-      { 0xF0F0F0F0, 0xF0F0F0F0, 0xF0F0F0F0, 0xF0F0F0F0 };
+  } constant1 = {0xF0F0F0F0, 0xF0F0F0F0, 0xF0F0F0F0, 0xF0F0F0F0};
   static const struct ALIGN16 {
     uint32_t a;
     uint32_t b;
     uint32_t c;
     uint32_t d;
-  } constant2 =
-      { 0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F };
+  } constant2 = {0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant2)));
   __ orps(XMM0, XMM1);
   // Copy the low lane at ESP.
   __ pushl(EAX);
   __ movss(Address(ESP, 0), XMM0);
   __ flds(Address(ESP, 0));
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedLogicalOr, test) {
   typedef uint32_t (*PackedLogicalOrCode)();
   uint32_t res = reinterpret_cast<PackedLogicalOrCode>(test->entry())();
   EXPECT_EQ(0xFFFFFFFF, res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedLogicalAnd, assembler) {
   static const struct ALIGN16 {
     uint32_t a;
     uint32_t b;
     uint32_t c;
     uint32_t d;
-  } constant1 =
-      { 0xF0F0F0F0, 0xF0F0F0F0, 0xF0F0F0F0, 0xF0F0F0F0 };
+  } constant1 = {0xF0F0F0F0, 0xF0F0F0F0, 0xF0F0F0F0, 0xF0F0F0F0};
   static const struct ALIGN16 {
     uint32_t a;
     uint32_t b;
     uint32_t c;
     uint32_t d;
-  } constant2 =
-      { 0x0F0FFF0F, 0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F };
+  } constant2 = {0x0F0FFF0F, 0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   __ andps(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant2)));
   // Copy the low lane at ESP.
   __ pushl(EAX);
   __ movss(Address(ESP, 0), XMM0);
   __ flds(Address(ESP, 0));
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedLogicalAnd, test) {
   typedef uint32_t (*PackedLogicalAndCode)();
   uint32_t res = reinterpret_cast<PackedLogicalAndCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x0000F000), res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedLogicalNot, assembler) {
   static const struct ALIGN16 {
     uint32_t a;
     uint32_t b;
     uint32_t c;
     uint32_t d;
-  } constant1 =
-      { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
+  } constant1 = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   __ notps(XMM0);
   // Copy the low lane at ESP.
   __ pushl(EAX);
   __ movss(Address(ESP, 0), XMM0);
   __ flds(Address(ESP, 0));
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedLogicalNot, test) {
   typedef uint32_t (*PackedLogicalNotCode)();
   uint32_t res = reinterpret_cast<PackedLogicalNotCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x0), res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedMoveHighLow, assembler) {
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant0 = { 1.0, 2.0, 3.0, 4.0 };
+  } constant0 = {1.0, 2.0, 3.0, 4.0};
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant1 = { 5.0, 6.0, 7.0, 8.0 };
+  } constant1 = {5.0, 6.0, 7.0, 8.0};
   // XMM0 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   // XMM0 = 7.0f, 8.0f, 3.0f, 4.0f.
   __ movhlps(XMM0, XMM1);
   __ xorps(XMM1, XMM1);
   // XMM1 = 7.0f, 8.0f, 3.0f, 4.0f.
   __ movaps(XMM1, XMM0);
   __ shufps(XMM0, XMM0, Immediate(0x00));  // 7.0f.
   __ shufps(XMM1, XMM1, Immediate(0x55));  // 8.0f.
-  __ addss(XMM0, XMM1);  // 15.0f.
+  __ addss(XMM0, XMM1);                    // 15.0f.
   __ pushl(EAX);
   __ movss(Address(ESP, 0), XMM0);
   __ flds(Address(ESP, 0));
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedMoveHighLow, test) {
   typedef float (*PackedMoveHighLow)();
   float res = reinterpret_cast<PackedMoveHighLow>(test->entry())();
   EXPECT_FLOAT_EQ(15.0f, res, 0.001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedMoveLowHigh, assembler) {
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant0 = { 1.0, 2.0, 3.0, 4.0 };
+  } constant0 = {1.0, 2.0, 3.0, 4.0};
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant1 = { 5.0, 6.0, 7.0, 8.0 };
+  } constant1 = {5.0, 6.0, 7.0, 8.0};
   // XMM0 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   // XMM0 = 1.0f, 2.0f, 5.0f, 6.0f
   __ movlhps(XMM0, XMM1);
   __ xorps(XMM1, XMM1);
   // XMM1 = 1.0f, 2.0f, 5.0f, 6.0f
   __ movaps(XMM1, XMM0);
   __ shufps(XMM0, XMM0, Immediate(0xAA));  // 5.0f.
   __ shufps(XMM1, XMM1, Immediate(0xFF));  // 6.0f.
-  __ addss(XMM0, XMM1);  // 11.0f.
+  __ addss(XMM0, XMM1);                    // 11.0f.
   __ pushl(EAX);
   __ movss(Address(ESP, 0), XMM0);
   __ flds(Address(ESP, 0));
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedMoveLowHigh, test) {
   typedef float (*PackedMoveLowHigh)();
   float res = reinterpret_cast<PackedMoveLowHigh>(test->entry())();
   EXPECT_FLOAT_EQ(11.0f, res, 0.001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedUnpackLow, assembler) {
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant0 = { 1.0, 2.0, 3.0, 4.0 };
+  } constant0 = {1.0, 2.0, 3.0, 4.0};
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant1 = { 5.0, 6.0, 7.0, 8.0 };
+  } constant1 = {5.0, 6.0, 7.0, 8.0};
   // XMM0 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   // XMM0 = 1.0f, 5.0f, 2.0f, 6.0f.
   __ unpcklps(XMM0, XMM1);
   // XMM1 = 1.0f, 5.0f, 2.0f, 6.0f.
   __ movaps(XMM1, XMM0);
   __ shufps(XMM0, XMM0, Immediate(0x55));
   __ shufps(XMM1, XMM1, Immediate(0xFF));
@@ skipping 12 matching lines @@
   EXPECT_FLOAT_EQ(11.0f, res, 0.001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedUnpackHigh, assembler) {
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant0 = { 1.0, 2.0, 3.0, 4.0 };
+  } constant0 = {1.0, 2.0, 3.0, 4.0};
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant1 = { 5.0, 6.0, 7.0, 8.0 };
+  } constant1 = {5.0, 6.0, 7.0, 8.0};
   // XMM0 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   // XMM0 = 3.0f, 7.0f, 4.0f, 8.0f.
   __ unpckhps(XMM0, XMM1);
   // XMM1 = 3.0f, 7.0f, 4.0f, 8.0f.
   __ movaps(XMM1, XMM0);
   __ shufps(XMM0, XMM0, Immediate(0x00));
   __ shufps(XMM1, XMM1, Immediate(0xAA));
@@ skipping 12 matching lines @@
   EXPECT_FLOAT_EQ(7.0f, res, 0.001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedUnpackLowPair, assembler) {
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant0 = { 1.0, 2.0, 3.0, 4.0 };
+  } constant0 = {1.0, 2.0, 3.0, 4.0};
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant1 = { 5.0, 6.0, 7.0, 8.0 };
+  } constant1 = {5.0, 6.0, 7.0, 8.0};
   // XMM0 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   // XMM0 = 1.0f, 2.0f, 5.0f, 6.0f.
   __ unpcklpd(XMM0, XMM1);
   // XMM1 = 1.0f, 2.0f, 5.0f, 6.0f.
   __ movaps(XMM1, XMM0);
   __ shufps(XMM0, XMM0, Immediate(0x00));
   __ shufps(XMM1, XMM1, Immediate(0xAA));
@@ skipping 12 matching lines @@
   EXPECT_FLOAT_EQ(6.0f, res, 0.001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedUnpackHighPair, assembler) {
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant0 = { 1.0, 2.0, 3.0, 4.0 };
+  } constant0 = {1.0, 2.0, 3.0, 4.0};
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant1 = { 5.0, 6.0, 7.0, 8.0 };
+  } constant1 = {5.0, 6.0, 7.0, 8.0};
   // XMM0 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   // XMM0 = 3.0f, 4.0f, 7.0f, 8.0f.
   __ unpckhpd(XMM0, XMM1);
   // XMM1 = 3.0f, 4.0f, 7.0f, 8.0f.
   __ movaps(XMM1, XMM0);
   __ shufps(XMM0, XMM0, Immediate(0x55));
   __ shufps(XMM1, XMM1, Immediate(0xFF));
@@ skipping 10 matching lines @@
   typedef float (*PackedUnpackHighPair)();
   float res = reinterpret_cast<PackedUnpackHighPair>(test->entry())();
   EXPECT_FLOAT_EQ(12.0f, res, 0.001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleAdd, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { 1.0, 2.0 };
+  } constant0 = {1.0, 2.0};
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant1 = { 3.0, 4.0 };
+  } constant1 = {3.0, 4.0};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   __ addpd(XMM0, XMM1);
   __ pushl(EAX);
   __ pushl(EAX);
   __ movsd(Address(ESP, 0), XMM0);
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleAdd, test) {
   typedef double (*PackedDoubleAdd)();
   double res = reinterpret_cast<PackedDoubleAdd>(test->entry())();
   EXPECT_FLOAT_EQ(4.0, res, 0.000001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleSub, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { 1.0, 2.0 };
+  } constant0 = {1.0, 2.0};
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant1 = { 3.0, 4.0 };
+  } constant1 = {3.0, 4.0};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   __ subpd(XMM0, XMM1);
   __ pushl(EAX);
   __ pushl(EAX);
   __ movsd(Address(ESP, 0), XMM0);
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleSub, test) {
   typedef double (*PackedDoubleSub)();
   double res = reinterpret_cast<PackedDoubleSub>(test->entry())();
   EXPECT_FLOAT_EQ(-2.0, res, 0.000001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleNegate, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { 1.0, 2.0 };
+  } constant0 = {1.0, 2.0};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   __ negatepd(XMM0);
   __ pushl(EAX);
   __ pushl(EAX);
   __ movsd(Address(ESP, 0), XMM0);
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleNegate, test) {
   typedef double (*PackedDoubleNegate)();
   double res = reinterpret_cast<PackedDoubleNegate>(test->entry())();
   EXPECT_FLOAT_EQ(-1.0, res, 0.000001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleAbsolute, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { -1.0, 2.0 };
+  } constant0 = {-1.0, 2.0};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   __ abspd(XMM0);
   __ pushl(EAX);
   __ pushl(EAX);
   __ movsd(Address(ESP, 0), XMM0);
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleAbsolute, test) {
   typedef double (*PackedDoubleAbsolute)();
   double res = reinterpret_cast<PackedDoubleAbsolute>(test->entry())();
   EXPECT_FLOAT_EQ(1.0, res, 0.000001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleMul, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { 3.0, 2.0 };
+  } constant0 = {3.0, 2.0};
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant1 = { 3.0, 4.0 };
+  } constant1 = {3.0, 4.0};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   __ mulpd(XMM0, XMM1);
   __ pushl(EAX);
   __ pushl(EAX);
   __ movsd(Address(ESP, 0), XMM0);
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleMul, test) {
   typedef double (*PackedDoubleMul)();
   double res = reinterpret_cast<PackedDoubleMul>(test->entry())();
   EXPECT_FLOAT_EQ(9.0, res, 0.000001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleDiv, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { 9.0, 2.0 };
+  } constant0 = {9.0, 2.0};
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant1 = { 3.0, 4.0 };
+  } constant1 = {3.0, 4.0};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   __ divpd(XMM0, XMM1);
   __ pushl(EAX);
   __ pushl(EAX);
   __ movsd(Address(ESP, 0), XMM0);
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleDiv, test) {
   typedef double (*PackedDoubleDiv)();
   double res = reinterpret_cast<PackedDoubleDiv>(test->entry())();
   EXPECT_FLOAT_EQ(3.0, res, 0.000001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleSqrt, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { 16.0, 2.0 };
+  } constant0 = {16.0, 2.0};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   __ sqrtpd(XMM0);
   __ pushl(EAX);
   __ pushl(EAX);
   __ movsd(Address(ESP, 0), XMM0);
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleSqrt, test) {
   typedef double (*PackedDoubleSqrt)();
   double res = reinterpret_cast<PackedDoubleSqrt>(test->entry())();
   EXPECT_FLOAT_EQ(4.0, res, 0.000001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleMin, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { 9.0, 2.0 };
+  } constant0 = {9.0, 2.0};
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant1 = { 3.0, 4.0 };
+  } constant1 = {3.0, 4.0};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   __ minpd(XMM0, XMM1);
   __ pushl(EAX);
   __ pushl(EAX);
   __ movsd(Address(ESP, 0), XMM0);
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleMin, test) {
   typedef double (*PackedDoubleMin)();
   double res = reinterpret_cast<PackedDoubleMin>(test->entry())();
   EXPECT_FLOAT_EQ(3.0, res, 0.000001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleMax, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { 9.0, 2.0 };
+  } constant0 = {9.0, 2.0};
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant1 = { 3.0, 4.0 };
+  } constant1 = {3.0, 4.0};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant1)));
   __ maxpd(XMM0, XMM1);
   __ pushl(EAX);
   __ pushl(EAX);
   __ movsd(Address(ESP, 0), XMM0);
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleMax, test) {
   typedef double (*PackedDoubleMax)();
   double res = reinterpret_cast<PackedDoubleMax>(test->entry())();
   EXPECT_FLOAT_EQ(9.0, res, 0.000001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleShuffle, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { 2.0, 9.0 };
+  } constant0 = {2.0, 9.0};
   __ movups(XMM0, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   // Splat Y across all lanes.
   __ shufpd(XMM0, XMM0, Immediate(0x33));
   // Splat X across all lanes.
   __ shufpd(XMM0, XMM0, Immediate(0x0));
   // Set return value.
   __ pushl(EAX);
   __ pushl(EAX);
   __ movsd(Address(ESP, 0), XMM0);
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleShuffle, test) {
   typedef double (*PackedDoubleShuffle)();
   double res = reinterpret_cast<PackedDoubleShuffle>(test->entry())();
   EXPECT_FLOAT_EQ(9.0, res, 0.000001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleToSingle, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { 9.0, 2.0 };
+  } constant0 = {9.0, 2.0};
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   __ cvtpd2ps(XMM0, XMM1);
   __ pushl(EAX);
   __ movss(Address(ESP, 0), XMM0);
   __ flds(Address(ESP, 0));
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleToSingle, test) {
   typedef float (*PackedDoubleToSingle)();
   float res = reinterpret_cast<PackedDoubleToSingle>(test->entry())();
   EXPECT_FLOAT_EQ(9.0f, res, 0.000001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedSingleToDouble, assembler) {
   static const struct ALIGN16 {
     float a;
     float b;
     float c;
     float d;
-  } constant0 = { 9.0f, 2.0f, 3.0f, 4.0f };
+  } constant0 = {9.0f, 2.0f, 3.0f, 4.0f};
   __ movups(XMM1, Address::Absolute(reinterpret_cast<uword>(&constant0)));
   __ cvtps2pd(XMM0, XMM1);
   __ pushl(EAX);
   __ pushl(EAX);
   __ movsd(Address(ESP, 0), XMM0);
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
@@ skipping 731 matching lines @@
 ASSEMBLER_TEST_RUN(LongUnsignedMulReg, test) {
   typedef uint64_t (*LongUnsignedMulRegCode)(uint32_t a, uint32_t b);
   uint32_t a = 3;
   uint32_t b = 13;
   uint64_t mul_res = a * b;
   uint64_t res = reinterpret_cast<LongUnsignedMulRegCode>(test->entry())(a, b);
   EXPECT_EQ(mul_res, res);
   a = 4021288948u;
   b = 13;
   res = reinterpret_cast<LongUnsignedMulRegCode>(test->entry())(a, b);
-  mul_res =  static_cast<uint64_t>(a) * static_cast<uint64_t>(b);
+  mul_res = static_cast<uint64_t>(a) * static_cast<uint64_t>(b);
   EXPECT_EQ(mul_res, res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(LongUnsignedMulAddress, assembler) {
   __ movl(EAX, Address(ESP, 2 * kWordSize));
   __ mull(Address(ESP, kWordSize));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LongUnsignedMulAddress, test) {
   typedef uint64_t (*LongUnsignedMulAddressCode)(uint32_t a, uint32_t b);
   uint32_t a = 12;
   uint32_t b = 13;
   uint64_t mul_res = a * b;
   uint64_t res =
       reinterpret_cast<LongUnsignedMulAddressCode>(test->entry())(a, b);
   EXPECT_EQ(mul_res, res);
   a = 4294967284u;
   b = 13;
   res = reinterpret_cast<LongUnsignedMulAddressCode>(test->entry())(a, b);
-  mul_res =  static_cast<uint64_t>(a) * static_cast<uint64_t>(b);
+  mul_res = static_cast<uint64_t>(a) * static_cast<uint64_t>(b);
   EXPECT_EQ(mul_res, res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(LongAddReg, assembler) {
   // Preserve clobbered callee-saved register (EBX).
   __ pushl(EBX);
   __ movl(EAX, Address(ESP, 2 * kWordSize));  // left low.
   __ movl(EDX, Address(ESP, 3 * kWordSize));  // left high.
   __ movl(ECX, Address(ESP, 4 * kWordSize));  // right low.
@@ skipping 405 matching lines @@
   __ fldl(Address(ESP, 0));
   __ popl(EAX);
   __ popl(EAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(DoubleAbs, test) {
   typedef double (*DoubleAbsCode)(double d);
   double val = -12.45;
-  double res =  reinterpret_cast<DoubleAbsCode>(test->entry())(val);
+  double res = reinterpret_cast<DoubleAbsCode>(test->entry())(val);
   EXPECT_FLOAT_EQ(-val, res, 0.001);
   val = 12.45;
-  res =  reinterpret_cast<DoubleAbsCode>(test->entry())(val);
+  res = reinterpret_cast<DoubleAbsCode>(test->entry())(val);
   EXPECT_FLOAT_EQ(val, res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(ExtractSignBits, assembler) {
   __ movsd(XMM0, Address(ESP, kWordSize));
   __ movmskpd(EAX, XMM0);
   __ andl(EAX, Immediate(0x1));
   __ ret();
 }
@@ skipping 45 matching lines @@
   __ addl(EDX, Address(ESP, 2 * kWordSize));
   __ movl(EAX, Immediate(1));
   __ movl(ECX, Immediate(0));
   __ cmovno(EAX, ECX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(ConditionalMovesNoOverflow, test) {
   typedef int (*ConditionalMovesNoOverflowCode)(int i, int j);
-  int res = reinterpret_cast<ConditionalMovesNoOverflowCode>(
-      test->entry())(0x7fffffff, 2);
+  int res = reinterpret_cast<ConditionalMovesNoOverflowCode>(test->entry())(
+      0x7fffffff, 2);
   EXPECT_EQ(1, res);
   res = reinterpret_cast<ConditionalMovesNoOverflowCode>(test->entry())(1, 1);
   EXPECT_EQ(0, res);
 }
 
 
 // Return 1 if equal, 0 if not equal.
 ASSEMBLER_TEST_GENERATE(ConditionalMovesEqual, assembler) {
   __ xorl(EAX, EAX);
   __ movl(ECX, Immediate(1));
@@ skipping 27 matching lines @@
 ASSEMBLER_TEST_RUN(ConditionalMovesNotEqual, test) {
   typedef int (*ConditionalMovesNotEqualCode)(int i);
   int res = reinterpret_cast<ConditionalMovesNotEqualCode>(test->entry())(785);
   EXPECT_EQ(0, res);
   res = reinterpret_cast<ConditionalMovesNotEqualCode>(test->entry())(-12);
   EXPECT_EQ(1, res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(ConditionalMovesCompare, assembler) {
-  __ movl(EDX, Immediate(1));  // Greater equal.
+  __ movl(EDX, Immediate(1));   // Greater equal.
   __ movl(ECX, Immediate(-1));  // Less
   __ movl(EAX, Address(ESP, 1 * kWordSize));
   __ cmpl(EAX, Address(ESP, 2 * kWordSize));
   __ cmovlessl(EAX, ECX);
   __ cmovgel(EAX, EDX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(ConditionalMovesCompare, test) {
@@ skipping 164 matching lines @@
 
 ASSEMBLER_TEST_RUN(TestRepMovsBytes, test) {
   const char* from = "0123456789";
   const char* to = new char[10];
   typedef void (*TestRepMovsBytes)(const char* from, const char* to, int count);
   reinterpret_cast<TestRepMovsBytes>(test->entry())(from, to, 10);
   EXPECT_EQ(to[0], '0');
   for (int i = 0; i < 10; i++) {
     EXPECT_EQ(from[i], to[i]);
   }
-  delete [] to;
+  delete[] to;
 }
 
 
 // Called from assembler_test.cc.
 ASSEMBLER_TEST_GENERATE(StoreIntoObject, assembler) {
   __ pushl(THR);
   __ movl(EAX, Address(ESP, 2 * kWordSize));
   __ movl(ECX, Address(ESP, 3 * kWordSize));
   __ movl(THR, Address(ESP, 4 * kWordSize));
   __ pushl(EAX);
-  __ StoreIntoObject(ECX,
-                     FieldAddress(ECX, GrowableObjectArray::data_offset()),
+  __ StoreIntoObject(ECX, FieldAddress(ECX, GrowableObjectArray::data_offset()),
                      EAX);
   __ popl(EAX);
   __ popl(THR);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_GENERATE(BitTest, assembler) {
   __ movl(EAX, Immediate(4));
   __ movl(ECX, Immediate(2));
   __ bt(EAX, ECX);
   Label ok;
   __ j(CARRY, &ok);
   __ int3();
   __ Bind(&ok);
   __ movl(EAX, Immediate(1));
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(BitTest, test) {
   typedef int (*BitTest)();
   EXPECT_EQ(1, reinterpret_cast<BitTest>(test->entry())());
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32