Add mips64 port.

test/cctest/test-macro-assembler-mips64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <stdlib.h>
 
 #include "src/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/macro-assembler.h"
-#include "src/mips/macro-assembler-mips.h"
-#include "src/mips/simulator-mips.h"
+#include "src/mips64/macro-assembler-mips64.h"
+#include "src/mips64/simulator-mips64.h"
 
 
 using namespace v8::internal;
 
-typedef void* (*F)(int x, int y, int p2, int p3, int p4);
+typedef void* (*F)(int64_t x, int64_t y, int p2, int p3, int p4);
 
 #define __ masm->
 
 
 static byte to_non_zero(int n) {
   return static_cast<unsigned>(n) % 255 + 1;
 }
 
 
 static bool all_zeroes(const byte* beg, const byte* end) {
@@ skipping 28 matching lines @@
   // Storage for a0 and a1.
   byte* a0_;
   byte* a1_;
 
   MacroAssembler assembler(isolate, NULL, 0);
   MacroAssembler* masm = &assembler;
 
   // Code to be generated: The stuff in CopyBytes followed by a store of a0 and
   // a1, respectively.
   __ CopyBytes(a0, a1, a2, a3);
-  __ li(a2, Operand(reinterpret_cast<int>(&a0_)));
-  __ li(a3, Operand(reinterpret_cast<int>(&a1_)));
-  __ sw(a0, MemOperand(a2));
+  __ li(a2, Operand(reinterpret_cast<int64_t>(&a0_)));
+  __ li(a3, Operand(reinterpret_cast<int64_t>(&a1_)));
+  __ sd(a0, MemOperand(a2));
   __ jr(ra);
-  __ sw(a1, MemOperand(a3));
+  __ sd(a1, MemOperand(a3));
 
   CodeDesc desc;
   masm->GetCode(&desc);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 
   ::F f = FUNCTION_CAST< ::F>(code->entry());
 
   // Initialise source data with non-zero bytes.
   for (int i = 0; i < data_size; i++) {
     src_buffer[i] = to_non_zero(i);
   }
 
   const int fuzz = 11;
 
   for (int size = 0; size < 600; size++) {
     for (const byte* src = src_buffer; src < src_buffer + fuzz; src++) {
       for (byte* dest = dest_buffer; dest < dest_buffer + fuzz; dest++) {
         memset(dest_buffer, 0, data_size);
         CHECK(dest + size < dest_buffer + data_size);
-        (void) CALL_GENERATED_CODE(f, reinterpret_cast<int>(src),
-                                      reinterpret_cast<int>(dest), size, 0, 0);
+        (void) CALL_GENERATED_CODE(f, reinterpret_cast<int64_t>(src),
+                                      reinterpret_cast<int64_t>(dest),
+                                      size, 0, 0);
         // a0 and a1 should point at the first byte after the copied data.
         CHECK_EQ(src + size, a0_);
         CHECK_EQ(dest + size, a1_);
         // Check that we haven't written outside the target area.
         CHECK(all_zeroes(dest_buffer, dest));
         CHECK(all_zeroes(dest + size, dest_buffer + data_size));
         // Check the target area.
         CHECK_EQ(0, memcmp(src, dest, size));
       }
     }
   }
 
   // Check that the source data hasn't been clobbered.
   for (int i = 0; i < data_size; i++) {
     CHECK(src_buffer[i] == to_non_zero(i));
   }
 }
 
 
-static void TestNaN(const char *code) {
-  // NaN value is different on MIPS and x86 architectures, and TEST(NaNx)
-  // tests checks the case where a x86 NaN value is serialized into the
-  // snapshot on the simulator during cross compilation.
-  v8::HandleScope scope(CcTest::isolate());
-  v8::Local<v8::Context> context = CcTest::NewContext(PRINT_EXTENSION);
-  v8::Context::Scope context_scope(context);
+TEST(LoadConstants) {
+  CcTest::InitializeVM();
+  Isolate* isolate = Isolate::Current();
+  HandleScope handles(isolate);
 
-  v8::Local<v8::Script> script = v8::Script::Compile(v8_str(code));
-  v8::Local<v8::Object> result = v8::Local<v8::Object>::Cast(script->Run());
-  // Have to populate the handle manually, as it's not Cast-able.
-  i::Handle<i::JSObject> o =
-      v8::Utils::OpenHandle<v8::Object, i::JSObject>(result);
-  i::Handle<i::JSArray> array1(reinterpret_cast<i::JSArray*>(*o));
-  i::FixedDoubleArray* a = i::FixedDoubleArray::cast(array1->elements());
-  double value = a->get_scalar(0);
-  CHECK(std::isnan(value) &&
-        i::BitCast<uint64_t>(value) ==
-        i::BitCast<uint64_t>(
-            i::FixedDoubleArray::canonical_not_the_hole_nan_as_double()));
+  int64_t refConstants[64];
+  int64_t result[64];
+
+  int64_t mask = 1;
+  for (int i = 0; i < 64; i++) {
+    refConstants[i] = ~(mask << i);
+  }
+
+  MacroAssembler assembler(isolate, NULL, 0);
+  MacroAssembler* masm = &assembler;
+
+  __ mov(a4, a0);
+  for (int i = 0; i < 64; i++) {
+    // Load constant.
+    __ li(a5, Operand(refConstants[i]));
+    __ sd(a5, MemOperand(a4));
+    __ Daddu(a4, a4, Operand(kPointerSize));
+  }
+
+  __ jr(ra);
+  __ nop();
+
+  CodeDesc desc;
+  masm->GetCode(&desc);
+  Handle<Code> code = isolate->factory()->NewCode(
+      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+  ::F f = FUNCTION_CAST< ::F>(code->entry());
+     (void) CALL_GENERATED_CODE(f, reinterpret_cast<int64_t>(result),
+                                0, 0, 0, 0);
+  // Check results.
+  for (int i = 0; i < 64; i++) {
+    CHECK(refConstants[i] == result[i]);
+  }
 }
 
 
-TEST(NaN0) {
-  TestNaN(
-          "var result;"
-          "for (var i = 0; i < 2; i++) {"
-          "  result = new Array(Number.NaN, Number.POSITIVE_INFINITY);"
-          "}"
-          "result;");
+TEST(LoadAddress) {
+  CcTest::InitializeVM();
+  Isolate* isolate = Isolate::Current();
+  HandleScope handles(isolate);
+
+  MacroAssembler assembler(isolate, NULL, 0);
+  MacroAssembler* masm = &assembler;
+  Label to_jump, skip;
+  __ mov(a4, a0);
+
+  __ Branch(&skip);
+  __ bind(&to_jump);
+  __ nop();
+  __ nop();
+  __ jr(ra);
+  __ nop();
+  __ bind(&skip);
+  __ li(a4, Operand(masm->jump_address(&to_jump)), ADDRESS_LOAD);
+  int check_size = masm->InstructionsGeneratedSince(&skip);
+  CHECK_EQ(check_size, 4);
+  __ jr(a4);
+  __ nop();
+  __ stop("invalid");
+  __ stop("invalid");
+  __ stop("invalid");
+  __ stop("invalid");
+  __ stop("invalid");
+
+
+  CodeDesc desc;
+  masm->GetCode(&desc);
+  Handle<Code> code = isolate->factory()->NewCode(
+      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+
+  ::F f = FUNCTION_CAST< ::F>(code->entry());
+     (void) CALL_GENERATED_CODE(f, 0, 0, 0, 0, 0);
+  // Check results.
 }
 
-
-TEST(NaN1) {
-  TestNaN(
-          "var result;"
-          "for (var i = 0; i < 2; i++) {"
-          "  result = [NaN];"
-          "}"
-          "result;");
-}
-
-
 #undef __