MIPS: Fixed a bug in CopyBytes() and new test cases for MIPS macro assembler.

test/cctest/test-macro-assembler-mips.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 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // 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 "v8.h"
 #include "macro-assembler.h"
-#include "arm/macro-assembler-arm.h"
-#include "arm/simulator-arm.h"
+#include "mips/macro-assembler-mips.h"
+#include "mips/simulator-mips.h"
 #include "cctest.h"
 
 
 using namespace v8::internal;
 
 typedef void* (*F)(int x, int y, int p2, int p3, int p4);
 
 #define __ masm->
 
 
@@ skipping 22 matching lines @@
   size_t act_size;
 
   // Allocate two blocks to copy data between.
   byte* src_buffer = static_cast<byte*>(OS::Allocate(data_size, &act_size, 0));
   CHECK(src_buffer);
   CHECK(act_size >= static_cast<size_t>(data_size));
   byte* dest_buffer = static_cast<byte*>(OS::Allocate(data_size, &act_size, 0));
   CHECK(dest_buffer);
   CHECK(act_size >= static_cast<size_t>(data_size));
 
-  // Storage for R0 and R1.
-  byte* r0_;
-  byte* r1_;
+  // 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 R0 and
-  // R1, respectively.
-  __ CopyBytes(r0, r1, r2, r3);
-  __ mov(r2, Operand(reinterpret_cast<int>(&r0_)));
-  __ mov(r3, Operand(reinterpret_cast<int>(&r1_)));
-  __ str(r0, MemOperand(r2));
-  __ str(r1, MemOperand(r3));
-  __ bx(lr);
+  // 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));
+  __ jr(ra);
+  __ sw(a1, MemOperand(a3));
 
   CodeDesc desc;
   masm->GetCode(&desc);
   Object* code = isolate->heap()->CreateCode(
       desc,
       Code::ComputeFlags(Code::STUB),
       Handle<Code>())->ToObjectChecked();
   CHECK(code->IsCode());
 
-  F f = FUNCTION_CAST<F>(Code::cast(code)->entry());
+  ::F f = FUNCTION_CAST< ::F>(Code::cast(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);
-        // R0 and R1 should point at the first byte after the copied data.
-        CHECK_EQ(src + size, r0_);
-        CHECK_EQ(dest + size, r1_);
+        // 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));
   }
 }
 
 
 
 #undef __