Port object tests to x64.

runtime/vm/object_test.cc

 // Copyright (c) 2011, 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/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 2047 matching lines @@
   EXPECT(!str3.IsOneByteString());
   str3 = String::New("Steep and Deep!");
   EXPECT(str3.IsString());
   EXPECT(str3.IsOneByteString());
   str3 = OneByteString::null();
   EXPECT(str3.IsString());
   EXPECT(!str3.IsOneByteString());
 }
 
 
-#if defined(TARGET_ARCH_IA32)  // only ia32 can run execution tests.
+// only ia32 and x64 can run execution tests.
+#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 // 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_));
   Instructions& instructions = Instructions::Handle(code.instructions());
   typedef int (*IncrementCode)();
   EXPECT_EQ(2, reinterpret_cast<IncrementCode>(instructions.EntryPoint())());
   uword entry_point = instructions.EntryPoint();
@@ skipping 18 matching lines @@
   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, int value);
-  const int kSmiTestValue = 5;
+  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_));
   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_));
+  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);
@@ skipping 80 matching lines @@
   int count = 0;
   Class& cls = Class::Handle();
   while (iterator.HasNext()) {
     cls = iterator.GetNextClass();
     ASSERT((cls.raw() == ae66.raw()) || (cls.raw() == re44.raw()));
     count++;
   }
   ASSERT(count == 2);
 }
 
-#endif  // TARGET_ARCH_IA32.
+#endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart