VM: Re-format to use at most one newline between functions

runtime/vm/assembler_dbc_test.cc

Index: runtime/vm/assembler_dbc_test.cc
diff --git a/runtime/vm/assembler_dbc_test.cc b/runtime/vm/assembler_dbc_test.cc
index 8ae05185a37c4ffbb8e415845cec2104346b3114..2d545df1c1bc363fdd8ef010c6735aa996b22541 100644
--- a/runtime/vm/assembler_dbc_test.cc
+++ b/runtime/vm/assembler_dbc_test.cc
@@ -21,7 +21,6 @@ static RawObject* ExecuteTest(const Code& code) {
       Array::Handle(Array::New(0)), thread);
 }
 
-
 #define EXECUTE_TEST_CODE_INTPTR(code)                                         \
   Smi::Value(Smi::RawCast(ExecuteTest(code)))
 #define EXECUTE_TEST_CODE_BOOL(code)                                           \
@@ -32,7 +31,6 @@ static RawObject* ExecuteTest(const Code& code) {
 
 #define __ assembler->
 
-
 static RawClass* CreateDummyClass(const String& class_name,
                                   const Script& script) {
   const Class& cls = Class::Handle(Class::New(
@@ -41,12 +39,10 @@ static RawClass* CreateDummyClass(const String& class_name,
   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"));
@@ -62,13 +58,11 @@ static RawFunction* CreateFunction(const char* name) {
                        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_;
@@ -106,18 +100,15 @@ static void MakeDummyInstanceCall(Assembler* assembler, const Object& result) {
   __ InstanceCall2(2, call_ic_data_kidx);
 }
 
-
 ASSEMBLER_TEST_GENERATE(Simple, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(Simple, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(Nop, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ Nop(0);
@@ -128,12 +119,10 @@ ASSEMBLER_TEST_GENERATE(Nop, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(Nop, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 // Called from assembler_test.cc.
 // FP[-kParamEndSlotFromFp - 1]: growable array
 // FP[-kParamEndSlotFromFp - 2]: value
@@ -145,7 +134,6 @@ ASSEMBLER_TEST_GENERATE(StoreIntoObject, assembler) {
   __ Return(0);
 }
 
-
 //  - OneByteStringFromCharCode rA, rX
 //
 //    Load the one-character symbol with the char code given by the Smi
@@ -157,13 +145,11 @@ ASSEMBLER_TEST_GENERATE(OneByteStringFromCharCode, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(OneByteStringFromCharCode, test) {
   EXPECT_EQ(Symbols::New(Thread::Current(), "A"),
             EXECUTE_TEST_CODE_OBJECT(test->code()).raw());
 }
 
-
 //  - StringToCharCode rA, rX
 //
 //    Load and smi-encode the single char code of the string in FP[rX] into
@@ -176,12 +162,10 @@ ASSEMBLER_TEST_GENERATE(StringToCharCode, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(StringToCharCode, test) {
   EXPECT_EQ(65, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(StringToCharCodeIllegalLength, assembler) {
   __ Frame(2);
   __ LoadConstant(0, String::ZoneHandle(String::New("AAA", Heap::kOld)));
@@ -189,12 +173,10 @@ ASSEMBLER_TEST_GENERATE(StringToCharCodeIllegalLength, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(StringToCharCodeIllegalLength, test) {
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - AddTOS; SubTOS; MulTOS; BitOrTOS; BitAndTOS; EqualTOS; LessThanTOS;
 //    GreaterThanTOS;
 //
@@ -211,12 +193,10 @@ ASSEMBLER_TEST_GENERATE(AddTOS, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(AddTOS, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(AddTOSOverflow, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(Smi::kMaxValue)));
   __ PushConstant(Smi::Handle(Smi::New(1)));
@@ -226,12 +206,10 @@ ASSEMBLER_TEST_GENERATE(AddTOSOverflow, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(AddTOSOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(AddTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
@@ -243,12 +221,10 @@ ASSEMBLER_TEST_GENERATE(AddTOSNonSmi, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(AddTOSNonSmi, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(SubTOS, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(30)));
   __ PushConstant(Smi::Handle(Smi::New(-12)));
@@ -258,12 +234,10 @@ ASSEMBLER_TEST_GENERATE(SubTOS, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(SubTOS, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(SubTOSOverflow, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(Smi::kMinValue)));
   __ PushConstant(Smi::Handle(Smi::New(1)));
@@ -273,12 +247,10 @@ ASSEMBLER_TEST_GENERATE(SubTOSOverflow, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(SubTOSOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(SubTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
@@ -290,12 +262,10 @@ ASSEMBLER_TEST_GENERATE(SubTOSNonSmi, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(SubTOSNonSmi, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(MulTOS, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(-6)));
   __ PushConstant(Smi::Handle(Smi::New(-7)));
@@ -305,12 +275,10 @@ ASSEMBLER_TEST_GENERATE(MulTOS, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(MulTOS, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(MulTOSOverflow, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(Smi::kMaxValue)));
   __ PushConstant(Smi::Handle(Smi::New(-8)));
@@ -320,12 +288,10 @@ ASSEMBLER_TEST_GENERATE(MulTOSOverflow, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(MulTOSOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(MulTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
@@ -337,12 +303,10 @@ ASSEMBLER_TEST_GENERATE(MulTOSNonSmi, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(MulTOSNonSmi, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(BitOrTOS, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(0x22)));
   __ PushConstant(Smi::Handle(Smi::New(0x08)));
@@ -352,12 +316,10 @@ ASSEMBLER_TEST_GENERATE(BitOrTOS, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(BitOrTOS, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(BitOrTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
@@ -369,12 +331,10 @@ ASSEMBLER_TEST_GENERATE(BitOrTOSNonSmi, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(BitOrTOSNonSmi, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(BitAndTOS, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(0x2a)));
   __ PushConstant(Smi::Handle(Smi::New(0xaa)));
@@ -384,12 +344,10 @@ ASSEMBLER_TEST_GENERATE(BitAndTOS, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(BitAndTOS, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(BitAndTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
@@ -401,12 +359,10 @@ ASSEMBLER_TEST_GENERATE(BitAndTOSNonSmi, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(BitAndTOSNonSmi, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(EqualTOSTrue, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ PushConstant(Smi::Handle(Smi::New(42)));
@@ -416,12 +372,10 @@ ASSEMBLER_TEST_GENERATE(EqualTOSTrue, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(EqualTOSTrue, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(EqualTOSFalse, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ PushConstant(Smi::Handle(Smi::New(-42)));
@@ -431,12 +385,10 @@ ASSEMBLER_TEST_GENERATE(EqualTOSFalse, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(EqualTOSFalse, test) {
   EXPECT(!EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(EqualTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
@@ -448,12 +400,10 @@ ASSEMBLER_TEST_GENERATE(EqualTOSNonSmi, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(EqualTOSNonSmi, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(LessThanTOSTrue, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(-42)));
   __ PushConstant(Smi::Handle(Smi::New(42)));
@@ -463,12 +413,10 @@ ASSEMBLER_TEST_GENERATE(LessThanTOSTrue, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(LessThanTOSTrue, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(LessThanTOSFalse, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ PushConstant(Smi::Handle(Smi::New(-42)));
@@ -478,12 +426,10 @@ ASSEMBLER_TEST_GENERATE(LessThanTOSFalse, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(LessThanTOSFalse, test) {
   EXPECT(!EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(LessThanTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
@@ -495,12 +441,10 @@ ASSEMBLER_TEST_GENERATE(LessThanTOSNonSmi, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(LessThanTOSNonSmi, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(GreaterThanTOSTrue, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ PushConstant(Smi::Handle(Smi::New(-42)));
@@ -510,12 +454,10 @@ ASSEMBLER_TEST_GENERATE(GreaterThanTOSTrue, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(GreaterThanTOSTrue, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(GreaterThanTOSFalse, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(-42)));
   __ PushConstant(Smi::Handle(Smi::New(42)));
@@ -525,12 +467,10 @@ ASSEMBLER_TEST_GENERATE(GreaterThanTOSFalse, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(GreaterThanTOSFalse, test) {
   EXPECT(!EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(GreaterThanTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
@@ -542,12 +482,10 @@ ASSEMBLER_TEST_GENERATE(GreaterThanTOSNonSmi, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(GreaterThanTOSNonSmi, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 //  - Add, Sub, Mul, Div, Mod, Shl, Shr rA, rB, rC
 //
 //    Arithmetic operations on Smis. FP[rA] <- FP[rB] op FP[rC].
@@ -564,12 +502,10 @@ ASSEMBLER_TEST_GENERATE(AddNoOverflow, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(AddNoOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(AddOverflow, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(Smi::kMaxValue)));
@@ -580,12 +516,10 @@ ASSEMBLER_TEST_GENERATE(AddOverflow, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(AddOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(SubNoOverflow, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(64)));
@@ -596,12 +530,10 @@ ASSEMBLER_TEST_GENERATE(SubNoOverflow, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(SubNoOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(SubOverflow, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(Smi::kMinValue)));
@@ -612,12 +544,10 @@ ASSEMBLER_TEST_GENERATE(SubOverflow, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(SubOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(MulNoOverflow, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-6)));
@@ -628,12 +558,10 @@ ASSEMBLER_TEST_GENERATE(MulNoOverflow, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(MulNoOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(MulOverflow, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(Smi::kMaxValue)));
@@ -644,12 +572,10 @@ ASSEMBLER_TEST_GENERATE(MulOverflow, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(MulOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DivNoDeopt, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(27)));
@@ -660,12 +586,10 @@ ASSEMBLER_TEST_GENERATE(DivNoDeopt, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(DivNoDeopt, test) {
   EXPECT_EQ(9, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DivZero, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(3)));
@@ -676,12 +600,10 @@ ASSEMBLER_TEST_GENERATE(DivZero, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(DivZero, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DivCornerCase, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(Smi::kMinValue)));
@@ -692,12 +614,10 @@ ASSEMBLER_TEST_GENERATE(DivCornerCase, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(DivCornerCase, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(ModPosPos, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -708,12 +628,10 @@ ASSEMBLER_TEST_GENERATE(ModPosPos, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(ModPosPos, test) {
   EXPECT_EQ(2, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(ModNegPos, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-42)));
@@ -724,12 +642,10 @@ ASSEMBLER_TEST_GENERATE(ModNegPos, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(ModNegPos, test) {
   EXPECT_EQ(2, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(ModPosNeg, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -740,12 +656,10 @@ ASSEMBLER_TEST_GENERATE(ModPosNeg, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(ModPosNeg, test) {
   EXPECT_EQ(2, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(ModZero, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(3)));
@@ -756,12 +670,10 @@ ASSEMBLER_TEST_GENERATE(ModZero, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(ModZero, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(ShlNoDeopt, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(21)));
@@ -772,12 +684,10 @@ ASSEMBLER_TEST_GENERATE(ShlNoDeopt, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(ShlNoDeopt, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(ShlOverflow, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(Smi::kMaxValue)));
@@ -788,12 +698,10 @@ ASSEMBLER_TEST_GENERATE(ShlOverflow, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(ShlOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(ShlNegShift, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(21)));
@@ -804,12 +712,10 @@ ASSEMBLER_TEST_GENERATE(ShlNegShift, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(ShlNegShift, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(ShrNoDeopt, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(84)));
@@ -820,12 +726,10 @@ ASSEMBLER_TEST_GENERATE(ShrNoDeopt, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(ShrNoDeopt, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(ShrNegShift, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(21)));
@@ -836,12 +740,10 @@ ASSEMBLER_TEST_GENERATE(ShrNegShift, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(ShrNegShift, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - Neg rA , rD
 //
 //    FP[rA] <- -FP[rD]. Assumes FP[rD] is a Smi. If there is no overflow the
@@ -855,12 +757,10 @@ ASSEMBLER_TEST_GENERATE(NegPos, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(NegPos, test) {
   EXPECT_EQ(-42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(NegNeg, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Smi::Handle(Smi::New(-42)));
@@ -870,12 +770,10 @@ ASSEMBLER_TEST_GENERATE(NegNeg, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(NegNeg, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(NegOverflow, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Smi::Handle(Smi::New(Smi::kMinValue)));
@@ -885,12 +783,10 @@ ASSEMBLER_TEST_GENERATE(NegOverflow, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(NegOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - BitOr, BitAnd, BitXor rA, rB, rC
 //
 //    FP[rA] <- FP[rB] op FP[rC]
@@ -903,12 +799,10 @@ ASSEMBLER_TEST_GENERATE(BitOr, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(BitOr, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(BitAnd, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(0x2b)));
@@ -918,12 +812,10 @@ ASSEMBLER_TEST_GENERATE(BitAnd, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(BitAnd, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(BitXor, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(0x37)));
@@ -933,12 +825,10 @@ ASSEMBLER_TEST_GENERATE(BitXor, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(BitXor, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - BitNot rA, rD
 //
 //    FP[rA] <- ~FP[rD]. As above, assumes FP[rD] is a Smi.
@@ -950,7 +840,6 @@ ASSEMBLER_TEST_GENERATE(BitNot, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(BitNot, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
@@ -980,12 +869,10 @@ ASSEMBLER_TEST_GENERATE(IfNeStrictTOSTaken, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(IfNeStrictTOSTaken, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfNeStrictTOSNotTaken, assembler) {
   Label branch_taken;
   const Array& array1 = Array::Handle(Array::New(1, Heap::kOld));
@@ -1004,7 +891,6 @@ ASSEMBLER_TEST_RUN(IfNeStrictTOSNotTaken, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 // TODO(zra): Also add tests that use Mint, Bignum.
 ASSEMBLER_TEST_GENERATE(IfNeStrictNumTOSTaken, assembler) {
   Label branch_taken;
@@ -1019,12 +905,10 @@ ASSEMBLER_TEST_GENERATE(IfNeStrictNumTOSTaken, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(IfNeStrictNumTOSTaken, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfNeStrictNumTOSNotTaken, assembler) {
   Label branch_taken;
   __ PushConstant(Smi::Handle(Smi::New(1)));
@@ -1042,7 +926,6 @@ ASSEMBLER_TEST_RUN(IfNeStrictNumTOSNotTaken, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfNeStrictNumTOSTakenDouble, assembler) {
   Label branch_taken;
   __ PushConstant(Double::Handle(Double::New(-1.0, Heap::kOld)));
@@ -1056,12 +939,10 @@ ASSEMBLER_TEST_GENERATE(IfNeStrictNumTOSTakenDouble, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(IfNeStrictNumTOSTakenDouble, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfNeStrictNumTOSNotTakenDouble, assembler) {
   Label branch_taken;
   __ PushConstant(Double::Handle(Double::New(1.0, Heap::kOld)));
@@ -1079,7 +960,6 @@ ASSEMBLER_TEST_RUN(IfNeStrictNumTOSNotTakenDouble, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfEqStrictTOSTaken, assembler) {
   Label branch_taken;
   const Array& array1 = Array::Handle(Array::New(1, Heap::kOld));
@@ -1094,12 +974,10 @@ ASSEMBLER_TEST_GENERATE(IfEqStrictTOSTaken, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(IfEqStrictTOSTaken, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfEqStrictTOSNotTaken, assembler) {
   Label branch_taken;
   const Array& array1 = Array::Handle(Array::New(1, Heap::kOld));
@@ -1119,7 +997,6 @@ ASSEMBLER_TEST_RUN(IfEqStrictTOSNotTaken, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 // TODO(zra): Also add tests that use Mint, Bignum.
 ASSEMBLER_TEST_GENERATE(IfEqStrictNumTOSTaken, assembler) {
   Label branch_taken;
@@ -1134,12 +1011,10 @@ ASSEMBLER_TEST_GENERATE(IfEqStrictNumTOSTaken, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(IfEqStrictNumTOSTaken, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfEqStrictNumTOSNotTaken, assembler) {
   Label branch_taken;
   __ PushConstant(Smi::Handle(Smi::New(-1)));
@@ -1153,12 +1028,10 @@ ASSEMBLER_TEST_GENERATE(IfEqStrictNumTOSNotTaken, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(IfEqStrictNumTOSNotTaken, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfEqStrictNumTOSTakenDouble, assembler) {
   Label branch_taken;
   __ PushConstant(Double::Handle(Double::New(1.0, Heap::kOld)));
@@ -1172,12 +1045,10 @@ ASSEMBLER_TEST_GENERATE(IfEqStrictNumTOSTakenDouble, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(IfEqStrictNumTOSTakenDouble, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfEqStrictNumTOSNotTakenDouble, assembler) {
   Label branch_taken;
   __ PushConstant(Double::Handle(Double::New(-1.0, Heap::kOld)));
@@ -1191,12 +1062,10 @@ ASSEMBLER_TEST_GENERATE(IfEqStrictNumTOSNotTakenDouble, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(IfEqStrictNumTOSNotTakenDouble, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - BooleanNegateTOS
 //
 //    SP[0] = !SP[0]
@@ -1206,24 +1075,20 @@ ASSEMBLER_TEST_GENERATE(BooleanNegateTOSTrue, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(BooleanNegateTOSTrue, test) {
   EXPECT(!EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(BooleanNegateTOSFalse, assembler) {
   __ PushConstant(Bool::False());
   __ BooleanNegateTOS();
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(BooleanNegateTOSFalse, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 //  - AssertBoolean A
 //
 //    Assert that TOS is a boolean (A = 1) or that TOS is not null (A = 0).
@@ -1233,60 +1098,50 @@ ASSEMBLER_TEST_GENERATE(AssertBooleanTrue, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(AssertBooleanTrue, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(AssertBooleanFalse, assembler) {
   __ PushConstant(Bool::False());
   __ AssertBoolean(1);
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(AssertBooleanFalse, test) {
   EXPECT(!EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(AssertBooleanNotNull, assembler) {
   __ PushConstant(Bool::True());
   __ AssertBoolean(0);
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(AssertBooleanNotNull, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(AssertBooleanFail1, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(37)));
   __ AssertBoolean(1);
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(AssertBooleanFail1, test) {
   EXPECT(EXECUTE_TEST_CODE_OBJECT(test->code()).IsError());
 }
 
-
 ASSEMBLER_TEST_GENERATE(AssertBooleanFail2, assembler) {
   __ PushConstant(Object::null_object());
   __ AssertBoolean(0);
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(AssertBooleanFail2, test) {
   EXPECT(EXECUTE_TEST_CODE_OBJECT(test->code()).IsError());
 }
 
-
 //  - Drop1; DropR n; Drop n
 //
 //    Drop 1 or n values from the stack, if instruction is DropR push the first
@@ -1299,12 +1154,10 @@ ASSEMBLER_TEST_GENERATE(Drop1, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(Drop1, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(Drop, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(0)));
   __ PushConstant(Smi::Handle(Smi::New(42)));
@@ -1323,12 +1176,10 @@ ASSEMBLER_TEST_GENERATE(Drop, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(Drop, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DropR, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(0)));
   __ PushConstant(Smi::Handle(Smi::New(1)));
@@ -1350,12 +1201,10 @@ ASSEMBLER_TEST_GENERATE(DropR, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(DropR, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - Frame D
 //
 //    Reserve and initialize with null space for D local variables.
@@ -1364,12 +1213,10 @@ ASSEMBLER_TEST_GENERATE(FrameInitialized1, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(FrameInitialized1, test) {
   EXPECT(EXECUTE_TEST_CODE_OBJECT(test->code()).IsNull());
 }
 
-
 ASSEMBLER_TEST_GENERATE(FrameInitialized, assembler) {
   Label error;
   __ PushConstant(Smi::Handle(Smi::New(42)));
@@ -1394,12 +1241,10 @@ ASSEMBLER_TEST_GENERATE(FrameInitialized, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(FrameInitialized, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - StoreLocal rX; PopLocal rX
 //
 //    Store top of the stack into FP[rX] and pop it if needed.
@@ -1419,12 +1264,10 @@ ASSEMBLER_TEST_GENERATE(StoreLocalPush, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(StoreLocalPush, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(PopLocalPush, assembler) {
   __ Frame(1);
   __ PushConstant(Smi::Handle(Smi::New(21)));
@@ -1437,12 +1280,10 @@ ASSEMBLER_TEST_GENERATE(PopLocalPush, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(PopLocalPush, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(LoadConstantPush, assembler) {
   __ Frame(1);
   __ LoadConstant(0, Smi::Handle(Smi::New(21)));
@@ -1454,12 +1295,10 @@ ASSEMBLER_TEST_GENERATE(LoadConstantPush, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(LoadConstantPush, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - Move rA, rX
 //
 //    FP[rA] <- FP[rX]
@@ -1478,12 +1317,10 @@ ASSEMBLER_TEST_GENERATE(MoveLocalLocal, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(MoveLocalLocal, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - Return R; ReturnTOS
 //
 //    Return to the caller using either a value from the given register or a
@@ -1495,12 +1332,10 @@ ASSEMBLER_TEST_GENERATE(Return1, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(Return1, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(Return2, assembler) {
   __ Frame(2);
   __ PushConstant(Smi::Handle(Smi::New(42)));
@@ -1508,12 +1343,10 @@ ASSEMBLER_TEST_GENERATE(Return2, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(Return2, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(Loop, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -1549,12 +1382,10 @@ ASSEMBLER_TEST_GENERATE(Loop, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(Loop, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - LoadClassIdTOS, LoadClassId rA, D
 //
 //    LoadClassIdTOS loads the class id from the object at SP[0] and stores it
@@ -1566,12 +1397,10 @@ ASSEMBLER_TEST_GENERATE(LoadClassIdTOS, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(LoadClassIdTOS, test) {
   EXPECT_EQ(kSmiCid, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(LoadClassId, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -1579,12 +1408,10 @@ ASSEMBLER_TEST_GENERATE(LoadClassId, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(LoadClassId, test) {
   EXPECT_EQ(kSmiCid, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - CreateArrayTOS
 //
 //    Allocate array of length SP[0] with type arguments SP[-1].
@@ -1595,7 +1422,6 @@ ASSEMBLER_TEST_GENERATE(CreateArrayTOS, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(CreateArrayTOS, test) {
   const Object& obj = EXECUTE_TEST_CODE_OBJECT(test->code());
   EXPECT(obj.IsArray());
@@ -1604,7 +1430,6 @@ ASSEMBLER_TEST_RUN(CreateArrayTOS, test) {
   EXPECT_EQ(10, array.Length());
 }
 
-
 //  - TestSmi rA, rD
 //
 //    If FP[rA] & FP[rD] != 0, then skip the next instruction. FP[rA] and FP[rD]
@@ -1623,12 +1448,10 @@ ASSEMBLER_TEST_GENERATE(TestSmiTrue, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(TestSmiTrue, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(TestSmiFalse, assembler) {
   Label branch_taken;
   __ Frame(2);
@@ -1643,12 +1466,10 @@ ASSEMBLER_TEST_GENERATE(TestSmiFalse, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(TestSmiFalse, test) {
   EXPECT(!EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 //  - TestCids rA, D
 //
 //    The next D instructions must be Nops whose D field encodes a class id. If
@@ -1675,12 +1496,10 @@ ASSEMBLER_TEST_GENERATE(TestCidsTrue, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(TestCidsTrue, test) {
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(TestCidsFalse, assembler) {
   Label true_branch, no_match_branch;
   __ Frame(2);
@@ -1701,12 +1520,10 @@ ASSEMBLER_TEST_GENERATE(TestCidsFalse, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(TestCidsFalse, test) {
   EXPECT_EQ(0, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(TestCidsNoMatch, assembler) {
   Label true_branch, no_match_branch;
   __ Frame(2);
@@ -1727,12 +1544,10 @@ ASSEMBLER_TEST_GENERATE(TestCidsNoMatch, assembler) {
   __ 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.
@@ -1745,12 +1560,10 @@ ASSEMBLER_TEST_GENERATE(CheckSmiPass, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(CheckSmiPass, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(CheckSmiFail, assembler) {
   __ Frame(1);
   __ PushConstant(Smi::Handle(Smi::New(-1)));
@@ -1760,12 +1573,10 @@ ASSEMBLER_TEST_GENERATE(CheckSmiFail, assembler) {
   __ ReturnTOS();
 }
 
-
 ASSEMBLER_TEST_RUN(CheckSmiFail, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - CheckClassId rA, D
 //
 //    If the object at FP[rA]'s class id matches the class id in PP[D], then
@@ -1779,12 +1590,10 @@ ASSEMBLER_TEST_GENERATE(CheckClassIdSmiPass, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(CheckClassIdSmiPass, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(CheckClassIdNonSmiPass, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Bool::True());
@@ -1794,12 +1603,10 @@ ASSEMBLER_TEST_GENERATE(CheckClassIdNonSmiPass, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(CheckClassIdNonSmiPass, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(CheckClassIdFail, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -1809,12 +1616,10 @@ ASSEMBLER_TEST_GENERATE(CheckClassIdFail, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(CheckClassIdFail, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - If<Cond>Null rA
 //
 //    Cond is Eq or Ne. Skips the next instruction unless the given condition
@@ -1828,12 +1633,10 @@ ASSEMBLER_TEST_GENERATE(IfEqNullNotNull, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(IfEqNullNotNull, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfEqNullIsNull, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Object::null_object());
@@ -1843,12 +1646,10 @@ ASSEMBLER_TEST_GENERATE(IfEqNullIsNull, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(IfEqNullIsNull, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfNeNullIsNull, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Object::null_object());
@@ -1858,12 +1659,10 @@ ASSEMBLER_TEST_GENERATE(IfNeNullIsNull, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(IfNeNullIsNull, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfNeNullNotNull, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -1873,7 +1672,6 @@ ASSEMBLER_TEST_GENERATE(IfNeNullNotNull, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(IfNeNullNotNull, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
@@ -1894,12 +1692,10 @@ ASSEMBLER_TEST_GENERATE(IfLeTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfLeTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfLeFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -1910,12 +1706,10 @@ ASSEMBLER_TEST_GENERATE(IfLeFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfLeFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfLtTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -1926,12 +1720,10 @@ ASSEMBLER_TEST_GENERATE(IfLtTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfLtTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfLtFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -1942,12 +1734,10 @@ ASSEMBLER_TEST_GENERATE(IfLtFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfLtFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfGeTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -1958,12 +1748,10 @@ ASSEMBLER_TEST_GENERATE(IfGeTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfGeTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfGeFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -1974,12 +1762,10 @@ ASSEMBLER_TEST_GENERATE(IfGeFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfGeFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfGtTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -1990,12 +1776,10 @@ ASSEMBLER_TEST_GENERATE(IfGtTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfGtTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfGtFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2006,12 +1790,10 @@ ASSEMBLER_TEST_GENERATE(IfGtFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfGtFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 #if defined(ARCH_IS_64_BIT)
 ASSEMBLER_TEST_GENERATE(IfDNeTrue, assembler) {
   __ Frame(3);
@@ -2025,12 +1807,10 @@ ASSEMBLER_TEST_GENERATE(IfDNeTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDNeTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDNeFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2043,12 +1823,10 @@ ASSEMBLER_TEST_GENERATE(IfDNeFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDNeFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDNeNan, assembler) {
   const double not_a_number = bit_cast<double, intptr_t>(0x7FF8000000000000LL);
   __ Frame(3);
@@ -2062,12 +1840,10 @@ ASSEMBLER_TEST_GENERATE(IfDNeNan, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDNeNan, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDEqTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -2080,12 +1856,10 @@ ASSEMBLER_TEST_GENERATE(IfDEqTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDEqTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDEqFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2098,12 +1872,10 @@ ASSEMBLER_TEST_GENERATE(IfDEqFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDEqFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDEqNan, assembler) {
   const double not_a_number = bit_cast<double, intptr_t>(0x7FF8000000000000LL);
   __ Frame(3);
@@ -2117,12 +1889,10 @@ ASSEMBLER_TEST_GENERATE(IfDEqNan, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDEqNan, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDLeTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -2135,12 +1905,10 @@ ASSEMBLER_TEST_GENERATE(IfDLeTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDLeTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDLeFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2153,12 +1921,10 @@ ASSEMBLER_TEST_GENERATE(IfDLeFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDLeFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDLeNan, assembler) {
   const double not_a_number = bit_cast<double, intptr_t>(0x7FF8000000000000LL);
   __ Frame(3);
@@ -2172,12 +1938,10 @@ ASSEMBLER_TEST_GENERATE(IfDLeNan, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDLeNan, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDLtTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -2190,12 +1954,10 @@ ASSEMBLER_TEST_GENERATE(IfDLtTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDLtTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDLtFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2208,12 +1970,10 @@ ASSEMBLER_TEST_GENERATE(IfDLtFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDLtFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDLtNan, assembler) {
   const double not_a_number = bit_cast<double, intptr_t>(0x7FF8000000000000LL);
   __ Frame(3);
@@ -2227,12 +1987,10 @@ ASSEMBLER_TEST_GENERATE(IfDLtNan, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDLtNan, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDGeTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -2245,12 +2003,10 @@ ASSEMBLER_TEST_GENERATE(IfDGeTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDGeTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDGeFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2263,12 +2019,10 @@ ASSEMBLER_TEST_GENERATE(IfDGeFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDGeFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDGeNan, assembler) {
   const double not_a_number = bit_cast<double, intptr_t>(0x7FF8000000000000LL);
   __ Frame(3);
@@ -2282,12 +2036,10 @@ ASSEMBLER_TEST_GENERATE(IfDGeNan, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDGeNan, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDGtTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -2300,12 +2052,10 @@ ASSEMBLER_TEST_GENERATE(IfDGtTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDGtTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDGtFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2318,12 +2068,10 @@ ASSEMBLER_TEST_GENERATE(IfDGtFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDGtFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfDGtNan, assembler) {
   const double not_a_number = bit_cast<double, intptr_t>(0x7FF8000000000000LL);
   __ Frame(3);
@@ -2337,13 +2085,11 @@ ASSEMBLER_TEST_GENERATE(IfDGtNan, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfDGtNan, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 #endif  // defined(ARCH_IS_64_BIT)
 
-
 ASSEMBLER_TEST_GENERATE(IfULeTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -2354,12 +2100,10 @@ ASSEMBLER_TEST_GENERATE(IfULeTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfULeTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfULeFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2370,12 +2114,10 @@ ASSEMBLER_TEST_GENERATE(IfULeFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfULeFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfULeNegTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -2386,12 +2128,10 @@ ASSEMBLER_TEST_GENERATE(IfULeNegTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfULeNegTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfULtTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -2402,12 +2142,10 @@ ASSEMBLER_TEST_GENERATE(IfULtTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfULtTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfULtFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2418,12 +2156,10 @@ ASSEMBLER_TEST_GENERATE(IfULtFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfULtFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfUGeTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -2434,12 +2170,10 @@ ASSEMBLER_TEST_GENERATE(IfUGeTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfUGeTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfUGeFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2450,12 +2184,10 @@ ASSEMBLER_TEST_GENERATE(IfUGeFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfUGeFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfUGtTrue, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(-1)));
@@ -2466,12 +2198,10 @@ ASSEMBLER_TEST_GENERATE(IfUGtTrue, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfUGtTrue, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(IfUGtFalse, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2482,12 +2212,10 @@ ASSEMBLER_TEST_GENERATE(IfUGtFalse, assembler) {
   __ Return(0);
 }
 
-
 ASSEMBLER_TEST_RUN(IfUGtFalse, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - Min, Max rA, rB, rC
 //
 //    FP[rA] <- {min, max}(FP[rB], FP[rC]). Assumes that FP[rB], and FP[rC] are
@@ -2500,12 +2228,10 @@ ASSEMBLER_TEST_GENERATE(Min, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(Min, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(Max, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2514,12 +2240,10 @@ ASSEMBLER_TEST_GENERATE(Max, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(Max, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 #if defined(ARCH_IS_64_BIT)
 //  - UnboxDouble rA, rD
 //
@@ -2537,12 +2261,10 @@ ASSEMBLER_TEST_GENERATE(Unbox, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(Unbox, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(CheckedUnboxDouble, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Double::Handle(Double::New(42.0, Heap::kOld)));
@@ -2551,12 +2273,10 @@ ASSEMBLER_TEST_GENERATE(CheckedUnboxDouble, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(CheckedUnboxDouble, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(CheckedUnboxSmi, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
@@ -2565,12 +2285,10 @@ ASSEMBLER_TEST_GENERATE(CheckedUnboxSmi, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(CheckedUnboxSmi, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(CheckedUnboxFail, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Bool::True());
@@ -2580,12 +2298,10 @@ ASSEMBLER_TEST_GENERATE(CheckedUnboxFail, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(CheckedUnboxFail, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 //  - DAdd, DSub, DMul, DDiv rA, rB, rC
 //
 //    Arithmetic operations on unboxed doubles. FP[rA] <- FP[rB] op FP[rC].
@@ -2599,12 +2315,10 @@ ASSEMBLER_TEST_GENERATE(DAdd, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(DAdd, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DSub, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Double::Handle(Double::New(1.0, Heap::kOld)));
@@ -2615,12 +2329,10 @@ ASSEMBLER_TEST_GENERATE(DSub, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(DSub, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DMul, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Double::Handle(Double::New(6.0, Heap::kOld)));
@@ -2631,12 +2343,10 @@ ASSEMBLER_TEST_GENERATE(DMul, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(DMul, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DDiv, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Double::Handle(Double::New(2.0, Heap::kOld)));
@@ -2647,12 +2357,10 @@ ASSEMBLER_TEST_GENERATE(DDiv, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(DDiv, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DNeg, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Double::Handle(Double::New(-42.0, Heap::kOld)));
@@ -2661,12 +2369,10 @@ ASSEMBLER_TEST_GENERATE(DNeg, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(DNeg, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DSqrt, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Double::Handle(Double::New(36.0, Heap::kOld)));
@@ -2675,12 +2381,10 @@ ASSEMBLER_TEST_GENERATE(DSqrt, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(DSqrt, test) {
   EXPECT_EQ(6.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
-
 //  - SmiToDouble rA, rD
 //
 //    Convert the Smi in FP[rD] to an unboxed double in FP[rA].
@@ -2697,12 +2401,10 @@ ASSEMBLER_TEST_GENERATE(SmiToDouble, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(SmiToDouble, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DoubleToSmi, assembler) {
   __ Frame(2);
   __ LoadConstant(0, Double::Handle(Double::New(42.0, Heap::kOld)));
@@ -2713,12 +2415,10 @@ ASSEMBLER_TEST_GENERATE(DoubleToSmi, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(DoubleToSmi, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DoubleToSmiNearMax, assembler) {
   const double m = static_cast<double>(Smi::kMaxValue - 1000);
   __ Frame(2);
@@ -2730,12 +2430,10 @@ ASSEMBLER_TEST_GENERATE(DoubleToSmiNearMax, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(DoubleToSmiNearMax, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DoubleToSmiNearMin, assembler) {
   const double m = static_cast<double>(Smi::kMinValue);
   __ Frame(2);
@@ -2747,12 +2445,10 @@ ASSEMBLER_TEST_GENERATE(DoubleToSmiNearMin, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(DoubleToSmiNearMin, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DoubleToSmiFailPos, assembler) {
   const double pos_overflow = static_cast<double>(Smi::kMaxValue + 1);
   __ Frame(2);
@@ -2764,12 +2460,10 @@ ASSEMBLER_TEST_GENERATE(DoubleToSmiFailPos, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(DoubleToSmiFailPos, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DoubleToSmiFailNeg, assembler) {
   const double neg_overflow = static_cast<double>(Smi::kMinValue - 1000);
   __ Frame(2);
@@ -2781,12 +2475,10 @@ ASSEMBLER_TEST_GENERATE(DoubleToSmiFailNeg, assembler) {
   __ Return(1);
 }
 
-
 ASSEMBLER_TEST_RUN(DoubleToSmiFailNeg, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DMin, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Double::Handle(Double::New(42.0, Heap::kOld)));
@@ -2797,12 +2489,10 @@ ASSEMBLER_TEST_GENERATE(DMin, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(DMin, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }
 
-
 ASSEMBLER_TEST_GENERATE(DMax, assembler) {
   __ Frame(3);
   __ LoadConstant(0, Double::Handle(Double::New(42.0, Heap::kOld)));
@@ -2813,7 +2503,6 @@ ASSEMBLER_TEST_GENERATE(DMax, assembler) {
   __ Return(2);
 }
 
-
 ASSEMBLER_TEST_RUN(DMax, test) {
   EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(test->code()));
 }