Adds object pool, LoadImmediate, and LoadObject to ARM64.

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.
 
 // TODO(zra): Remove when tests are ready to enable.
 #include "platform/globals.h"
-#if !defined(TARGET_ARCH_ARM64)
 
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 2473 matching lines @@
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
   Code& code = Code::Handle(Code::FinalizeCode(
       *CreateFunction("Test_Code"), &_assembler_));
   Instructions& instructions = Instructions::Handle(code.instructions());
   uword entry_point = instructions.EntryPoint();
   intptr_t retval = 0;
 #if defined(USING_SIMULATOR)
   retval = bit_copy<intptr_t, int64_t>(Simulator::Current()->Call(
-      static_cast<int32_t>(entry_point), 0, 0, 0, 0));
+      static_cast<intptr_t>(entry_point), 0, 0, 0, 0));
 #else
   typedef intptr_t (*IncrementCode)();
   retval = reinterpret_cast<IncrementCode>(entry_point)();
 #endif
   EXPECT_EQ(2, retval);
   EXPECT_EQ(instructions.raw(), Instructions::FromEntryPoint(entry_point));
 }
 
 
 // Test for immutability of generated instructions. The test crashes with a
 // segmentation fault when writing into it.
 TEST_CASE(CodeImmutability) {
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
   Code& code = Code::Handle(Code::FinalizeCode(
       *CreateFunction("Test_Code"), &_assembler_));
   Instructions& instructions = Instructions::Handle(code.instructions());
   uword entry_point = instructions.EntryPoint();
   // Try writing into the generated code, expected to crash.
   *(reinterpret_cast<char*>(entry_point) + 1) = 1;
   intptr_t retval = 0;
 #if defined(USING_SIMULATOR)
   retval = bit_copy<intptr_t, int64_t>(Simulator::Current()->Call(
-      static_cast<int32_t>(entry_point), 0, 0, 0, 0));
+      static_cast<intptr_t>(entry_point), 0, 0, 0, 0));
 #else
   typedef intptr_t (*IncrementCode)();
   retval = reinterpret_cast<IncrementCode>(entry_point)();
 #endif
   EXPECT_EQ(3, retval);
   EXPECT_EQ(instructions.raw(), Instructions::FromEntryPoint(entry_point));
   if (!FLAG_write_protect_code) {
     // Since this test is expected to crash, crash if write protection of code
     // is switched off.
     OS::DebugBreak();
   }
 }
 
 
 // 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(
       *CreateFunction("Test_EmbedStringInCode"), &_assembler_));
   Instructions& instructions = Instructions::Handle(code.instructions());
   uword retval = 0;
 #if defined(USING_SIMULATOR)
   retval = bit_copy<uword, int64_t>(Simulator::Current()->Call(
-      static_cast<int32_t>(instructions.EntryPoint()), 0, 0, 0, 0));
+      static_cast<intptr_t>(instructions.EntryPoint()), 0, 0, 0, 0));
 #else
   typedef uword (*EmbedStringCode)();
   retval = reinterpret_cast<EmbedStringCode>(instructions.EntryPoint())();
 #endif
   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(
       *CreateFunction("Test_EmbedSmiInCode"), &_assembler_));
   Instructions& instructions = Instructions::Handle(code.instructions());
   intptr_t retval = 0;
 #if defined(USING_SIMULATOR)
   retval = bit_copy<intptr_t, int64_t>(Simulator::Current()->Call(
-      static_cast<int32_t>(instructions.EntryPoint()), 0, 0, 0, 0));
+      static_cast<intptr_t>(instructions.EntryPoint()), 0, 0, 0, 0));
 #else
   typedef intptr_t (*EmbedSmiCode)();
   retval = reinterpret_cast<EmbedSmiCode>(instructions.EntryPoint())();
 #endif
   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(
       *CreateFunction("Test_EmbedSmiIn64BitCode"), &_assembler_));
   Instructions& instructions = Instructions::Handle(code.instructions());
   intptr_t retval = 0;
 #if defined(USING_SIMULATOR)
   retval = bit_copy<intptr_t, int64_t>(Simulator::Current()->Call(
-      static_cast<int32_t>(instructions.EntryPoint()), 0, 0, 0, 0));
+      static_cast<intptr_t>(instructions.EntryPoint()), 0, 0, 0, 0));
 #else
   typedef intptr_t (*EmbedSmiCode)();
   retval = reinterpret_cast<EmbedSmiCode>(instructions.EntryPoint())();
 #endif
   EXPECT((retval >> kSmiTagShift) == kSmiTestValue);
 }
 #endif  // ARCH_IS_64_BIT
 
 
 TEST_CASE(ExceptionHandlers) {
@@ skipping 372 matching lines @@
   EXPECT(!String::EqualsIgnoringPrivateKey(ext_mangled_name,
                                            ext_bad_bare_name));
 }
 
 
 TEST_CASE(ArrayNew_Overflow_Crash) {
   Array::Handle(Array::New(Array::kMaxElements + 1));
 }
 
 
+#if !defined(TARGET_ARCH_ARM64)

[regis, 2014/04/15 23:37:04]

I would add a TODO(zra) here and below

[zra, 2014/04/16 15:48:16]

Done.

+
 TEST_CASE(StackTraceFormat) {
   const char* kScriptChars =
       "void baz() {\n"
       "  throw 'MyException';\n"
       "}\n"
       "\n"
       "class _OtherClass {\n"
       "  _OtherClass._named() {\n"
       "    baz();\n"
       "  }\n"
@@ skipping 40 matching lines @@
       "#3      _bar (dart:test-lib:16:3)\n"
       "#4      MyClass.field (dart:test-lib:25:9)\n"
       "#5      MyClass.foo.fooHelper (dart:test-lib:30:7)\n"
       "#6      MyClass.foo (dart:test-lib:32:14)\n"
       "#7      MyClass.MyClass.<anonymous closure> (dart:test-lib:21:15)\n"
       "#8      MyClass.MyClass (dart:test-lib:21:18)\n"
       "#9      main.<anonymous closure> (dart:test-lib:37:14)\n"
       "#10     main (dart:test-lib:37:24)");
 }
 
+#endif  // !defined(TARGET_ARCH_ARM64)
 
 TEST_CASE(WeakProperty_PreserveCrossGen) {
   Isolate* isolate = Isolate::Current();
   WeakProperty& weak = WeakProperty::Handle();
   {
     // Weak property and value in new. Key in old.
     HANDLESCOPE(isolate);
     String& key = String::Handle();
     key ^= OneByteString::New("key", Heap::kOld);
     String& value = String::Handle();
@@ skipping 388 matching lines @@
   EXPECT_NE(reference.raw(), other_reference.raw());
   other_reference.set_referent(library);
   EXPECT_NE(reference.raw(), other_reference.raw());
   EXPECT_EQ(reference.referent(), other_reference.referent());
 
   Object& obj = Object::Handle(reference.raw());
   EXPECT(obj.IsMirrorReference());
 }
 
 
+#if !defined(TARGET_ARCH_ARM64)
+
 static RawFunction* GetFunction(const Class& cls, const char* name) {
   const Function& result = Function::Handle(cls.LookupDynamicFunction(
       String::Handle(String::New(name))));
   EXPECT(!result.IsNull());
   return result.raw();
 }
 
 
 static RawFunction* GetStaticFunction(const Class& cls, const char* name) {
   const Function& result = Function::Handle(cls.LookupStaticFunction(
@@ skipping 119 matching lines @@
   func_b_from_index ^= class_a.FunctionFromIndex(func_b_index);
   EXPECT(!func_b_from_index.IsNull());
   // Same function.
   EXPECT_EQ(func_b.raw(), func_b_from_index.raw());
   // Retrieve implicit closure function.
   Function& func_x_from_index = Function::Handle();
   func_x_from_index ^= class_a.ImplicitClosureFunctionFromIndex(func_x_index);
   EXPECT_EQ(func_x.raw(), func_x_from_index.raw());
 }
 
+#endif  // !defined(TARGET_ARCH_ARM64)
+
 
 TEST_CASE(FindClosureIndex) {
   // Allocate the class first.
   const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
   const Array& functions = Array::Handle(Array::New(1));
 
   Function& parent = Function::Handle();
   const String& parent_name = String::Handle(Symbols::New("foo_papa"));
@@ skipping 60 matching lines @@
   EXPECT_EQ(invocation_dispatcher.raw(),
             invocation_dispatcher_from_index.raw());
   // Test function not found case.
   const Function& bad_function = Function::Handle(Function::null());
   intptr_t bad_invocation_dispatcher_index =
       cls.FindInvocationDispatcherFunctionIndex(bad_function);
   EXPECT_EQ(bad_invocation_dispatcher_index, -1);
 }
 
 
+#if  !defined(TARGET_ARCH_ARM64)
+
 static void PrintMetadata(const char* name, const Object& data) {
   if (data.IsError()) {
     OS::Print("Error in metadata evaluation for %s: '%s'\n",
               name,
               Error::Cast(data).ToErrorCString());
   }
   EXPECT(data.IsArray());
   const Array& metadata = Array::Cast(data);
   OS::Print("Metadata for %s has %" Pd " values:\n", name, metadata.Length());
   Object& elem = Object::Handle();
@@ skipping 185 matching lines @@
   EXPECT(func_b.IsInlineable());
 
   // After setting a breakpoint in a function A.b, it is no longer inlineable.
   SourceBreakpoint* bpt =
       Isolate::Current()->debugger()->SetBreakpointAtLine(name,
                                                           kBreakpointLine);
   ASSERT(bpt != NULL);
   EXPECT(!func_b.IsInlineable());
 }
 
+#endif  // !defined(TARGET_ARCH_ARM64)
+
 
 TEST_CASE(SpecialClassesHaveEmptyArrays) {
   ObjectStore* object_store = Isolate::Current()->object_store();
   Class& cls = Class::Handle();
   Object& array = Object::Handle();
 
   cls = object_store->null_class();
   array = cls.fields();
   EXPECT(!array.IsNull());
   EXPECT(array.IsArray());
@@ skipping 12 matching lines @@
   cls = Object::dynamic_class();
   array = cls.fields();
   EXPECT(!array.IsNull());
   EXPECT(array.IsArray());
   array = cls.functions();
   EXPECT(!array.IsNull());
   EXPECT(array.IsArray());
 }
 
 
+#if !defined(TARGET_ARCH_ARM64)
+
 TEST_CASE(ToUserCString) {
   const char* kScriptChars =
       "var simple = 'simple';\n"
       "var escapes = 'stuff\\n\\r\\f\\b\\t\\v\\'\"\\$stuff';\n"
       "var uescapes = 'stuff\\u0001\\u0002stuff';\n"
       "var toolong = "
       "'01234567890123456789012345678901234567890123456789howdy';\n"
       "var toolong2 = "
       "'0123456789012345678901234567890123\\t567890123456789howdy';\n"
       "var toolong3 = "
@@ skipping 75 matching lines @@
 };
 
 
 TEST_CASE(PrintToJSONStream) {
   Heap* heap = Isolate::Current()->heap();
   heap->CollectAllGarbage();
   JSONTypeVerifier verifier;
   heap->IterateObjects(&verifier);
 }
 
+#endif  // !defined(TARGET_ARCH_ARM64)
+
 }  // namespace dart
-
-#endif  // !defined(TARGET_ARCH_ARM64)