Fixed compilation time measurement, restructure some code.

runtime/vm/object_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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 2364 matching lines @@
   EXPECT(str3.IsString());
   EXPECT(str3.IsOneByteString());
   str3 = OneByteString::null();
   EXPECT(str3.IsString());
   EXPECT(!str3.IsOneByteString());
 }
 
 
 // only ia32 and x64 can run execution tests.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
+
+static Function* CreateFunction(const char* name) {
+  const String& function_name = String::ZoneHandle(String::NewSymbol(name));
+  Function& function = Function::ZoneHandle(
+      Function::New(function_name, RawFunction::kFunction, true, false, 0));
+  return &function;
+}
+
 // Test for Code and Instruction object creation.
 TEST_CASE(Code) {
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
-  Code& code = Code::Handle(Code::FinalizeCode("Test_Code", &_assembler_));
+  Code& code = Code::Handle(Code::FinalizeCode(
+      *CreateFunction("Test_Code"), &_assembler_));
   Instructions& instructions = Instructions::Handle(code.instructions());
   typedef int (*IncrementCode)();
   EXPECT_EQ(2, reinterpret_cast<IncrementCode>(instructions.EntryPoint())());
   uword entry_point = instructions.EntryPoint();
   EXPECT_EQ(instructions.raw(), Instructions::FromEntryPoint(entry_point));
 }
 
 
 // Test for Embedded String object in the instructions.
 TEST_CASE(EmbedStringInCode) {
   extern void GenerateEmbedStringInCode(Assembler* assembler, const char* str);
   const char* kHello = "Hello World!";
   word expected_length = static_cast<word>(strlen(kHello));
   Assembler _assembler_;
   GenerateEmbedStringInCode(&_assembler_, kHello);
-  Code& code = Code::Handle(
-      Code::FinalizeCode("Test_EmbedStringInCode", &_assembler_));
+  Code& code = Code::Handle(Code::FinalizeCode(
+      *CreateFunction("Test_EmbedStringInCode"), &_assembler_));
   Instructions& instructions = Instructions::Handle(code.instructions());
   typedef uword (*EmbedStringCode)();
   uword retval = reinterpret_cast<EmbedStringCode>(instructions.EntryPoint())();
   EXPECT((retval & kSmiTagMask) == kHeapObjectTag);
   String& string_object = String::Handle();
   string_object ^= reinterpret_cast<RawInstructions*>(retval);
   EXPECT(string_object.Length() == expected_length);
   for (int i = 0; i < expected_length; i ++) {
     EXPECT(string_object.CharAt(i) == kHello[i]);
   }
 }
 
 
 // Test for Embedded Smi object in the instructions.
 TEST_CASE(EmbedSmiInCode) {
   extern void GenerateEmbedSmiInCode(Assembler* assembler, intptr_t value);
   const intptr_t kSmiTestValue = 5;
   Assembler _assembler_;
   GenerateEmbedSmiInCode(&_assembler_, kSmiTestValue);
-  Code& code = Code::Handle(
-      Code::FinalizeCode("Test_EmbedSmiInCode", &_assembler_));
+  Code& code = Code::Handle(Code::FinalizeCode(
+      *CreateFunction("Test_EmbedSmiInCode"), &_assembler_));
   Instructions& instructions = Instructions::Handle(code.instructions());
   typedef intptr_t (*EmbedSmiCode)();
   intptr_t retval =
       reinterpret_cast<EmbedSmiCode>(instructions.EntryPoint())();
   EXPECT((retval >> kSmiTagShift) == kSmiTestValue);
 }
 
 
 #if defined(ARCH_IS_64_BIT)
 // Test for Embedded Smi object in the instructions.
 TEST_CASE(EmbedSmiIn64BitCode) {
   extern void GenerateEmbedSmiInCode(Assembler* assembler, intptr_t value);
   const intptr_t kSmiTestValue = 5L << 32;
   Assembler _assembler_;
   GenerateEmbedSmiInCode(&_assembler_, kSmiTestValue);
-  Code& code = Code::Handle(
-      Code::FinalizeCode("Test_EmbedSmiIn64BitCode", &_assembler_));
+  Code& code = Code::Handle(Code::FinalizeCode(
+      *CreateFunction("Test_EmbedSmiIn64BitCode"), &_assembler_));
   Instructions& instructions = Instructions::Handle(code.instructions());
   typedef intptr_t (*EmbedSmiCode)();
   intptr_t retval =
       reinterpret_cast<EmbedSmiCode>(instructions.EntryPoint())();
   EXPECT((retval >> kSmiTagShift) == kSmiTestValue);
 }
 #endif
 
 
 TEST_CASE(ExceptionHandlers) {
   const int kNumEntries = 6;
   // Add an exception handler table to the code.
   ExceptionHandlers& exception_handlers = ExceptionHandlers::Handle();
   exception_handlers ^= ExceptionHandlers::New(kNumEntries);
   exception_handlers.SetHandlerEntry(0, 10, 20);
   exception_handlers.SetHandlerEntry(1, 20, 30);
   exception_handlers.SetHandlerEntry(2, 30, 40);
   exception_handlers.SetHandlerEntry(3, 10, 40);
   exception_handlers.SetHandlerEntry(4, 10, 80);
   exception_handlers.SetHandlerEntry(5, 80, 150);
 
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
-  Code& code = Code::Handle(Code::FinalizeCode("Test_Code", &_assembler_));
+  Code& code = Code::Handle(Code::FinalizeCode(
+      *CreateFunction("Test_Code"), &_assembler_));
   code.set_exception_handlers(exception_handlers);
 
   // Verify the exception handler table entries by accessing them.
   const ExceptionHandlers& handlers =
       ExceptionHandlers::Handle(code.exception_handlers());
   EXPECT_EQ(kNumEntries, handlers.Length());
   EXPECT_EQ(10, handlers.TryIndex(0));
   EXPECT_EQ(20, handlers.HandlerPC(0));
   EXPECT_EQ(80, handlers.TryIndex(5));
   EXPECT_EQ(150, handlers.HandlerPC(5));
 }
 
 
 TEST_CASE(PcDescriptors) {
   const int kNumEntries = 6;
   // Add PcDescriptors to the code.
   PcDescriptors& descriptors = PcDescriptors::Handle();
   descriptors ^= PcDescriptors::New(kNumEntries);
   descriptors.AddDescriptor(0, 10, PcDescriptors::kOther, 1, 20, 1);
   descriptors.AddDescriptor(1, 20, PcDescriptors::kDeopt, 2, 30, 0);
   descriptors.AddDescriptor(2, 30, PcDescriptors::kOther, 3, 40, 1);
   descriptors.AddDescriptor(3, 10, PcDescriptors::kOther, 4, 40, 2);
   descriptors.AddDescriptor(4, 10, PcDescriptors::kOther, 5, 80, 3);
   descriptors.AddDescriptor(5, 80, PcDescriptors::kOther, 6, 150, 3);
 
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
-  Code& code = Code::Handle(Code::FinalizeCode("Test_Code", &_assembler_));
+  Code& code = Code::Handle(Code::FinalizeCode(
+      *CreateFunction("Test_Code"), &_assembler_));
   code.set_pc_descriptors(descriptors);
 
   // Verify the PcDescriptor entries by accessing them.
   const PcDescriptors& pc_descs = PcDescriptors::Handle(code.pc_descriptors());
   EXPECT_EQ(kNumEntries, pc_descs.Length());
   EXPECT_EQ(1, pc_descs.TryIndex(0));
   EXPECT_EQ(static_cast<uword>(10), pc_descs.PC(0));
   EXPECT_EQ(1, pc_descs.NodeId(0));
   EXPECT_EQ(20, pc_descs.TokenIndex(0));
   EXPECT_EQ(3, pc_descs.TryIndex(5));
@@ skipping 135 matching lines @@
   cache.GetCheck(0, &test_class, &test_targ_0, &test_targ_1, &test_result);
   EXPECT_EQ(empty_class.raw(), test_class.raw());
   EXPECT_EQ(targ_0.raw(), test_targ_0.raw());
   EXPECT_EQ(targ_1.raw(), test_targ_1.raw());
   EXPECT_EQ(Bool::True(), test_result.raw());
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart