clang-format runtime/vm

runtime/vm/assembler_x64_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_X64)
 
 #include "vm/assembler.h"
 #include "vm/os.h"
 #include "vm/unit_test.h"
@@ skipping 215 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.
   __ movq(RAX, Immediate(0));
   __ movq(Address(RAX, 0), RAX);
@@ skipping 158 matching lines @@
 
 ASSEMBLER_TEST_RUN(SignedMultiply, test) {
   typedef int (*SignedMultiply)();
   EXPECT_EQ(8000, reinterpret_cast<SignedMultiply>(test->entry())());
 }
 
 
 ASSEMBLER_TEST_GENERATE(UnsignedMultiply, assembler) {
   __ movl(RAX, Immediate(-1));  // RAX = 0xFFFFFFFF
   __ movl(RCX, Immediate(16));  // RCX = 0x10
-  __ mull(RCX);  // RDX:RAX = RAX * RCX = 0x0FFFFFFFF0
-  __ movq(RAX, RDX);  // Return high32(0x0FFFFFFFF0) == 0x0F
+  __ mull(RCX);                 // RDX:RAX = RAX * RCX = 0x0FFFFFFFF0
+  __ movq(RAX, RDX);            // Return high32(0x0FFFFFFFF0) == 0x0F
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(UnsignedMultiply, test) {
   typedef int (*UnsignedMultiply)();
   EXPECT_EQ(15, reinterpret_cast<UnsignedMultiply>(test->entry())());
 }
 
 
@@ skipping 99 matching lines @@
 
 ASSEMBLER_TEST_RUN(SignedMultiply2, test) {
   typedef int (*SignedMultiply2)();
   EXPECT_EQ(2000, reinterpret_cast<SignedMultiply2>(test->entry())());
 }
 
 
 ASSEMBLER_TEST_GENERATE(UnsignedMultiplyLong, assembler) {
   __ movq(RAX, Immediate(-1));  // RAX = 0xFFFFFFFFFFFFFFFF
   __ movq(RCX, Immediate(16));  // RCX = 0x10
-  __ mulq(RCX);  // RDX:RAX = RAX * RCX = 0x0FFFFFFFFFFFFFFFF0
-  __ movq(RAX, RDX);  // Return high64(0x0FFFFFFFFFFFFFFFF0) == 0x0F
+  __ mulq(RCX);                 // RDX:RAX = RAX * RCX = 0x0FFFFFFFFFFFFFFFF0
+  __ movq(RAX, RDX);            // Return high64(0x0FFFFFFFFFFFFFFFF0) == 0x0F
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(UnsignedMultiplyLong, test) {
   typedef int64_t (*UnsignedMultiplyLong)();
   EXPECT_EQ(15, reinterpret_cast<UnsignedMultiplyLong>(test->entry())());
 }
 
 
@@ skipping 245 matching lines @@
   b = 600000;
   res = reinterpret_cast<LongAddRegCode>(test->entry())(a, b);
   EXPECT_EQ((a + b), res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(LongAddImmediate, assembler) {
   __ pushq(CallingConventions::kArg1Reg);
   __ movl(RAX, Address(RSP, 0));  // left low.
   __ movl(RDX, Address(RSP, 4));  // left high.
-  __ addl(RAX, Immediate(12));  // right low immediate.
-  __ adcl(RDX, Immediate(11));  // right high immediate.
+  __ addl(RAX, Immediate(12));    // right low immediate.
+  __ adcl(RDX, Immediate(11));    // right high immediate.
   // Result is in RAX/RDX.
   __ movl(Address(RSP, 0), RAX);  // result low.
   __ movl(Address(RSP, 4), RDX);  // result high.
   __ popq(RAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LongAddImmediate, test) {
   typedef int64_t (*LongAddImmediateCode)(int64_t a);
   int64_t a = (13LL << 32) + 14;
   int64_t b = (11LL << 32) + 12;
   int64_t res = reinterpret_cast<LongAddImmediateCode>(test->entry())(a);
   EXPECT_EQ((a + b), res);
   a = (13LL << 32) - 1;
   res = reinterpret_cast<LongAddImmediateCode>(test->entry())(a);
   EXPECT_EQ((a + b), res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(LongAddAddress, assembler) {
   __ pushq(CallingConventions::kArg2Reg);
   __ pushq(CallingConventions::kArg1Reg);
-  __ movl(RAX, Address(RSP, 0));  // left low.
-  __ movl(RDX, Address(RSP, 4));  // left high.
-  __ addl(RAX, Address(RSP, 8));  // low.
+  __ movl(RAX, Address(RSP, 0));   // left low.
+  __ movl(RDX, Address(RSP, 4));   // left high.
+  __ addl(RAX, Address(RSP, 8));   // low.
   __ adcl(RDX, Address(RSP, 12));  // high.
   // Result is in RAX/RDX.
   __ movl(Address(RSP, 0), RAX);  // result low.
   __ movl(Address(RSP, 4), RDX);  // result high.
   __ popq(RAX);
   __ popq(RDX);
   __ ret();
 }
 
 
@@ skipping 38 matching lines @@
   b = 2147483647;
   res = reinterpret_cast<LongSubRegCode>(test->entry())(a, b);
   EXPECT_EQ((a - b), res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(LongSubImmediate, assembler) {
   __ pushq(CallingConventions::kArg1Reg);
   __ movl(RAX, Address(RSP, 0));  // left low.
   __ movl(RDX, Address(RSP, 4));  // left high.
-  __ subl(RAX, Immediate(12));  // right low immediate.
-  __ sbbl(RDX, Immediate(11));  // right high immediate.
+  __ subl(RAX, Immediate(12));    // right low immediate.
+  __ sbbl(RDX, Immediate(11));    // right high immediate.
   // Result is in RAX/RDX.
   __ movl(Address(RSP, 0), RAX);  // result low.
   __ movl(Address(RSP, 4), RDX);  // result high.
   __ popq(RAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LongSubImmediate, test) {
   typedef int64_t (*LongSubImmediateCode)(int64_t a);
   int64_t a = (13LL << 32) + 14;
   int64_t b = (11LL << 32) + 12;
   int64_t res = reinterpret_cast<LongSubImmediateCode>(test->entry())(a);
   EXPECT_EQ((a - b), res);
   a = (13LL << 32) + 10;
   res = reinterpret_cast<LongSubImmediateCode>(test->entry())(a);
   EXPECT_EQ((a - b), res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(LongSubAddress, assembler) {
   __ pushq(CallingConventions::kArg2Reg);
   __ pushq(CallingConventions::kArg1Reg);
-  __ movl(RAX, Address(RSP, 0));  // left low.
-  __ movl(RDX, Address(RSP, 4));  // left high.
-  __ subl(RAX, Address(RSP, 8));  // low.
+  __ movl(RAX, Address(RSP, 0));   // left low.
+  __ movl(RDX, Address(RSP, 4));   // left high.
+  __ subl(RAX, Address(RSP, 8));   // low.
   __ sbbl(RDX, Address(RSP, 12));  // high.
   // Result is in RAX/RDX.
   __ movl(Address(RSP, 0), RAX);  // result low.
   __ movl(Address(RSP, 4), RDX);  // result high.
   __ popq(RAX);
   __ popq(RDX);
   __ ret();
 }
 
 
@@ skipping 29 matching lines @@
   int64_t res = reinterpret_cast<AddRegCode>(test->entry())(al, ah, bl, bh);
   EXPECT_EQ((ah + bh), res);
   al = -1;
   res = reinterpret_cast<AddRegCode>(test->entry())(al, ah, bl, bh);
   EXPECT_EQ((ah + bh + 1), res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(AddImmediate, assembler) {
   __ movq(R10, CallingConventions::kArg1Reg);  // al.
-  __ addq(R10, Immediate(13));  // bl.
+  __ addq(R10, Immediate(13));                 // bl.
   __ movq(RAX, CallingConventions::kArg2Reg);  // ah.
-  __ adcq(RAX, Immediate(14));  // bh.
+  __ adcq(RAX, Immediate(14));                 // bh.
   // RAX = high64(ah:al + bh:bl).
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(AddImmediate, test) {
   typedef int64_t (*AddImmediateCode)(int64_t al, int64_t ah);
   int64_t al = 11;
   int64_t ah = 12;
   int64_t bh = 14;
@@ skipping 53 matching lines @@
   int64_t res = reinterpret_cast<SubRegCode>(test->entry())(al, ah, bl, bh);
   EXPECT_EQ((ah - bh), res);
   al = 10;
   res = reinterpret_cast<SubRegCode>(test->entry())(al, ah, bl, bh);
   EXPECT_EQ((ah - bh - 1), res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(SubImmediate, assembler) {
   __ movq(R10, CallingConventions::kArg1Reg);  // al.
-  __ subq(R10, Immediate(12));  // bl.
+  __ subq(R10, Immediate(12));                 // bl.
   __ movq(RAX, CallingConventions::kArg2Reg);  // ah.
-  __ sbbq(RAX, Immediate(11));  // bh.
+  __ sbbq(RAX, Immediate(11));                 // bh.
   // RAX = high64(ah:al - bh:bl).
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(SubImmediate, test) {
   typedef int64_t (*SubImmediateCode)(int64_t al, int64_t ah);
   int64_t al = 14;
   int64_t ah = 13;
   int64_t bh = 11;
@@ skipping 748 matching lines @@
 
 ASSEMBLER_TEST_RUN(LargeConstant, test) {
   typedef int64_t (*LargeConstantCode)();
   EXPECT_EQ(kLargeConstant,
             reinterpret_cast<LargeConstantCode>(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 139 matching lines @@
 ASSEMBLER_TEST_RUN(SingleFPMoves2, test) {
   typedef float (*SingleFPMoves2Code)();
   EXPECT_EQ(234, reinterpret_cast<SingleFPMoves2Code>(test->entry())());
 }
 
 
 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};
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM10, Address(RAX, 0));
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant1)));
   __ movups(XMM11, Address(RAX, 0));
   __ addpd(XMM10, XMM11);
   __ movaps(XMM0, XMM10);
   __ 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};
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM10, Address(RAX, 0));
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant1)));
   __ movups(XMM11, Address(RAX, 0));
   __ subpd(XMM10, XMM11);
   __ movaps(XMM0, XMM10);
   __ ret();
 }
 
 
@@ skipping 23 matching lines @@
   __ popq(PP);
   __ popq(CODE_REG);
   __ LeaveFrame();
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedDoubleNegate, assembler) {
   static const struct ALIGN16 {
     double a;
     double b;
-  } constant0 = { 1.0, 2.0 };
+  } constant0 = {1.0, 2.0};
   EnterTestFrame(assembler);
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM10, Address(RAX, 0));
   __ negatepd(XMM10);
   __ movaps(XMM0, XMM10);
   LeaveTestFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleNegate, test) {
   double res = test->InvokeWithCodeAndThread<double>();
   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};
   EnterTestFrame(assembler);
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM10, Address(RAX, 0));
   __ abspd(XMM10);
   __ movaps(XMM0, XMM10);
   LeaveTestFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedDoubleAbsolute, test) {
   double res = test->InvokeWithCodeAndThread<double>();
   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};
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM10, Address(RAX, 0));
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant1)));
   __ movups(XMM11, Address(RAX, 0));
   __ mulpd(XMM10, XMM11);
   __ movaps(XMM0, XMM10);
   __ 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};
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM10, Address(RAX, 0));
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant1)));
   __ movups(XMM11, Address(RAX, 0));
   __ divpd(XMM10, XMM11);
   __ movaps(XMM0, XMM10);
   __ 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};
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM10, Address(RAX, 0));
   __ sqrtpd(XMM10);
   __ movaps(XMM0, XMM10);
   __ 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};
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM10, Address(RAX, 0));
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant1)));
   __ movups(XMM11, Address(RAX, 0));
   __ minpd(XMM10, XMM11);
   __ movaps(XMM0, XMM10);
   __ 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};
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM10, Address(RAX, 0));
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant1)));
   __ movups(XMM11, Address(RAX, 0));
   __ maxpd(XMM10, XMM11);
   __ movaps(XMM0, XMM10);
   __ 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};
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM10, Address(RAX, 0));
   // Splat Y across all lanes.
   __ shufpd(XMM10, XMM10, Immediate(0x33));
   // Splat X across all lanes.
   __ shufpd(XMM10, XMM10, Immediate(0x0));
   // Set return value.
   __ movaps(XMM0, XMM10);
   __ 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};
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM11, Address(RAX, 0));
   __ cvtpd2ps(XMM10, XMM11);
   __ movaps(XMM0, XMM10);
   __ 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};
   __ movq(RAX, Immediate(reinterpret_cast<uword>(&constant0)));
   __ movups(XMM11, Address(RAX, 0));
   __ cvtps2pd(XMM10, XMM11);
   __ movaps(XMM0, XMM10);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedSingleToDouble, test) {
   typedef double (*PackedSingleToDouble)();
@@ skipping 108 matching lines @@
   uint32_t res = reinterpret_cast<PackedIntOperationsCode>(test->entry())();
   EXPECT_EQ(static_cast<uword>(0x5), res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(PackedFPOperations2, assembler) {
   __ movq(RAX, Immediate(bit_cast<int32_t, float>(4.0f)));
   __ movd(XMM0, RAX);
   __ shufps(XMM0, XMM0, Immediate(0x0));
 
-  __ movaps(XMM11, XMM0);  // Copy XMM0
-  __ reciprocalps(XMM11);  // 0.25
-  __ sqrtps(XMM11);  // 0.5
-  __ rsqrtps(XMM0);  // ~0.5
-  __ subps(XMM0, XMM11);  // ~0.0
+  __ movaps(XMM11, XMM0);                  // Copy XMM0
+  __ reciprocalps(XMM11);                  // 0.25
+  __ sqrtps(XMM11);                        // 0.5
+  __ rsqrtps(XMM0);                        // ~0.5
+  __ subps(XMM0, XMM11);                   // ~0.0
   __ shufps(XMM0, XMM0, Immediate(0x00));  // Copy second lane into all 4 lanes.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedFPOperations2, test) {
   typedef float (*PackedFPOperations2Code)();
   float res = reinterpret_cast<PackedFPOperations2Code>(test->entry())();
   EXPECT_FLOAT_EQ(0.0f, res, 0.001f);
 }
@@ skipping 188 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};
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant1)));
   __ movups(XMM0, Address(RAX, 0));
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant2)));
   __ movups(XMM1, Address(RAX, 0));
   __ orps(XMM0, XMM1);
   __ pushq(RAX);
   __ movss(Address(RSP, 0), XMM0);
   __ popq(RAX);
   __ 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};
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant1)));
   __ movups(XMM0, Address(RAX, 0));
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant2)));
   __ andps(XMM0, Address(RAX, 0));
   __ pushq(RAX);
   __ movss(Address(RSP, 0), XMM0);
   __ popq(RAX);
   __ 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};
   EnterTestFrame(assembler);
   __ LoadImmediate(RAX, Immediate(reinterpret_cast<intptr_t>(&constant1)));
   __ movups(XMM9, Address(RAX, 0));
   __ notps(XMM9);
   __ movaps(XMM0, XMM9);
   __ pushq(RAX);
   __ movss(Address(RSP, 0), XMM0);
   __ popq(RAX);
   LeaveTestFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(PackedLogicalNot, test) {
   uint32_t res = test->InvokeWithCodeAndThread<uint32_t>();
   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};
   // XMM9 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant0)));
   __ movups(XMM9, Address(RAX, 0));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant1)));
   __ movups(XMM1, Address(RAX, 0));
   // XMM9 = 7.0f, 8.0f, 3.0f, 4.0f.
   __ movhlps(XMM9, XMM1);
   __ xorps(XMM1, XMM1);
   // XMM1 = 7.0f, 8.0f, 3.0f, 4.0f.
   __ movaps(XMM1, XMM9);
   __ shufps(XMM9, XMM9, Immediate(0x00));  // 7.0f.
   __ shufps(XMM1, XMM1, Immediate(0x55));  // 8.0f.
-  __ addss(XMM9, XMM1);  // 15.0f.
+  __ addss(XMM9, XMM1);                    // 15.0f.
   __ movaps(XMM0, XMM9);
   __ 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};
   // XMM9 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant0)));
   __ movups(XMM9, Address(RAX, 0));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant1)));
   __ movups(XMM1, Address(RAX, 0));
   // XMM9 = 1.0f, 2.0f, 5.0f, 6.0f
   __ movlhps(XMM9, XMM1);
   __ xorps(XMM1, XMM1);
   // XMM1 = 1.0f, 2.0f, 5.0f, 6.0f
   __ movaps(XMM1, XMM9);
   __ shufps(XMM9, XMM9, Immediate(0xAA));  // 5.0f.
   __ shufps(XMM1, XMM1, Immediate(0xFF));  // 6.0f.
-  __ addss(XMM9, XMM1);  // 11.0f.
+  __ addss(XMM9, XMM1);                    // 11.0f.
   __ movaps(XMM0, XMM9);
   __ 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};
   // XMM9 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant0)));
   __ movups(XMM9, Address(RAX, 0));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant1)));
   __ movups(XMM1, Address(RAX, 0));
   // XMM9 = 1.0f, 5.0f, 2.0f, 6.0f.
   __ unpcklps(XMM9, XMM1);
   // XMM1 = 1.0f, 5.0f, 2.0f, 6.0f.
   __ movaps(XMM1, XMM9);
@@ skipping 11 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};
   // XMM9 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant0)));
   __ movups(XMM9, Address(RAX, 0));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant1)));
   __ movups(XMM1, Address(RAX, 0));
   // XMM9 = 3.0f, 7.0f, 4.0f, 8.0f.
   __ unpckhps(XMM9, XMM1);
   // XMM1 = 3.0f, 7.0f, 4.0f, 8.0f.
   __ movaps(XMM1, XMM9);
@@ skipping 11 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};
   // XMM9 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant0)));
   __ movups(XMM9, Address(RAX, 0));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant1)));
   __ movups(XMM1, Address(RAX, 0));
   // XMM9 = 1.0f, 2.0f, 5.0f, 6.0f.
   __ unpcklpd(XMM9, XMM1);
   // XMM1 = 1.0f, 2.0f, 5.0f, 6.0f.
   __ movaps(XMM1, XMM9);
@@ skipping 11 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};
   // XMM9 = 1.0f, 2.0f, 3.0f, 4.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant0)));
   __ movups(XMM9, Address(RAX, 0));
   // XMM1 = 5.0f, 6.0f, 7.0f, 8.0f.
   __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(&constant1)));
   __ movups(XMM1, Address(RAX, 0));
   // XMM9 = 3.0f, 4.0f, 7.0f, 8.0f.
   __ unpckhpd(XMM9, XMM1);
   // XMM1 = 3.0f, 4.0f, 7.0f, 8.0f.
   __ movaps(XMM1, XMM9);
@@ skipping 62 matching lines @@
   __ movaps(XMM1, XMM2);
   __ movaps(XMM0, XMM1);
   __ popq(RAX);
   __ popq(R15);  // Callee saved.
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(DoubleFPMoves, test) {
   typedef double (*DoubleFPMovesCode)();
-  EXPECT_FLOAT_EQ(1024.67,
-                  reinterpret_cast<DoubleFPMovesCode>(test->entry())(), 0.001);
+  EXPECT_FLOAT_EQ(1024.67, reinterpret_cast<DoubleFPMovesCode>(test->entry())(),
+                  0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(DoubleFPOperations, assembler) {
   __ movq(RAX, Immediate(bit_cast<int64_t, double>(12.3)));
   __ pushq(RAX);
   __ movsd(XMM0, Address(RSP, 0));
   __ movsd(XMM8, Address(RSP, 0));
   __ movq(RAX, Immediate(bit_cast<int64_t, double>(3.4)));
   __ movq(Address(RSP, 0), RAX);
   __ movsd(XMM12, Address(RSP, 0));
   __ addsd(XMM8, XMM12);  // 15.7
   __ mulsd(XMM8, XMM12);  // 53.38
   __ subsd(XMM8, XMM12);  // 49.98
   __ divsd(XMM8, XMM12);  // 14.7
   __ sqrtsd(XMM8, XMM8);  // 3.834
   __ movsd(XMM1, Address(RSP, 0));
-  __ addsd(XMM0, XMM1);  // 15.7
-  __ mulsd(XMM0, XMM1);  // 53.38
-  __ subsd(XMM0, XMM1);  // 49.98
-  __ divsd(XMM0, XMM1);  // 14.7
+  __ addsd(XMM0, XMM1);   // 15.7
+  __ mulsd(XMM0, XMM1);   // 53.38
+  __ subsd(XMM0, XMM1);   // 49.98
+  __ divsd(XMM0, XMM1);   // 14.7
   __ sqrtsd(XMM0, XMM0);  // 3.834057902
-  __ addsd(XMM0, XMM8);  // 7.6681
+  __ addsd(XMM0, XMM8);   // 7.6681
   __ popq(RAX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(DoubleFPOperations, test) {
   typedef double (*SingleFPOperationsCode)();
   double res = reinterpret_cast<SingleFPOperationsCode>(test->entry())();
   EXPECT_FLOAT_EQ(7.668, res, 0.001);
 }
@@ skipping 15 matching lines @@
   typedef double (*Int32ToDoubleConversion)();
   double res = reinterpret_cast<Int32ToDoubleConversion>(test->entry())();
   EXPECT_FLOAT_EQ(-2.0, res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(Int64ToDoubleConversion, assembler) {
   __ movq(RDX, Immediate(12LL << 32));
   __ cvtsi2sdq(XMM0, RDX);
   __ movsd(XMM15, XMM0);  // Move to high register
-  __ addsd(XMM0, XMM0);  // Stomp XMM0
+  __ addsd(XMM0, XMM0);   // Stomp XMM0
   __ movsd(XMM0, XMM15);  // Move back to XMM0
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(Int64ToDoubleConversion, test) {
   typedef double (*Int64ToDoubleConversionCode)();
   double res = reinterpret_cast<Int64ToDoubleConversionCode>(test->entry())();
   EXPECT_FLOAT_EQ(static_cast<double>(12LL << 32), res, 0.001);
 }
@@ skipping 379 matching lines @@
   // independently.
   __ DoubleAbs(XMM0);
 #endif
   LeaveTestFrame(assembler);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(DoubleAbs, test) {
   double val = -12.45;
-  double res =  test->InvokeWithCodeAndThread<double, double>(val);
+  double res = test->InvokeWithCodeAndThread<double, double>(val);
   EXPECT_FLOAT_EQ(-val, res, 0.001);
   val = 12.45;
   res = test->InvokeWithCodeAndThread<double, double>(val);
   EXPECT_FLOAT_EQ(val, res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(ExtractSignBits, assembler) {
   __ movmskpd(RAX, XMM0);
   __ andq(RAX, Immediate(0x1));
@@ skipping 23 matching lines @@
 ASSEMBLER_TEST_RUN(TestSetCC, test) {
   typedef uword (*TestSetCC)();
   uword res = reinterpret_cast<TestSetCC>(test->entry())();
   EXPECT_EQ(0xFFFFFF00, res);
 }
 
 
 ASSEMBLER_TEST_GENERATE(TestRepMovsBytes, assembler) {
   __ pushq(RSI);
   __ pushq(RDI);
-  __ pushq(CallingConventions::kArg1Reg);  // from.
-  __ pushq(CallingConventions::kArg2Reg);  // to.
-  __ pushq(CallingConventions::kArg3Reg);  // count.
+  __ pushq(CallingConventions::kArg1Reg);     // from.
+  __ pushq(CallingConventions::kArg2Reg);     // to.
+  __ pushq(CallingConventions::kArg3Reg);     // count.
   __ movq(RSI, Address(RSP, 2 * kWordSize));  // from.
   __ movq(RDI, Address(RSP, 1 * kWordSize));  // to.
   __ movq(RCX, Address(RSP, 0 * kWordSize));  // count.
   __ rep_movsb();
   // Remove saved arguments.
   __ popq(RAX);
   __ popq(RAX);
   __ popq(RAX);
   __ popq(RDI);
   __ popq(RSI);
   __ ret();
 }
 
 
 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;
 }
 
 
 ASSEMBLER_TEST_GENERATE(ConditionalMovesCompare, assembler) {
   __ cmpq(CallingConventions::kArg1Reg, CallingConventions::kArg2Reg);
-  __ movq(RDX, Immediate(1));  // Greater equal.
+  __ movq(RDX, Immediate(1));   // Greater equal.
   __ movq(RCX, Immediate(-1));  // Less
   __ cmovlessq(RAX, RCX);
   __ cmovgeq(RAX, RDX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(ConditionalMovesCompare, test) {
   typedef int (*ConditionalMovesCompareCode)(int i, int j);
   int res = reinterpret_cast<ConditionalMovesCompareCode>(test->entry())(10, 5);
@@ skipping 50 matching lines @@
   __ addq(RDX, CallingConventions::kArg2Reg);
   __ movq(RAX, Immediate(1));
   __ movq(RCX, Immediate(0));
   __ cmovnoq(RAX, RCX);
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(ConditionalMovesNoOverflow, test) {
   typedef int (*ConditionalMovesNoOverflowCode)(int64_t i, int64_t j);
-  int res = reinterpret_cast<ConditionalMovesNoOverflowCode>(
-      test->entry())(0x7fffffffffffffff, 2);
+  int res = reinterpret_cast<ConditionalMovesNoOverflowCode>(test->entry())(
+      0x7fffffffffffffff, 2);
   EXPECT_EQ(1, res);
   res = reinterpret_cast<ConditionalMovesNoOverflowCode>(test->entry())(1, 1);
   EXPECT_EQ(0, res);
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64