src/v8/test/cctest/test-macro-assembler-mips.cc

   1 // Copyright 2013 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #include <stdlib.h>
  29
  30 #include "src/v8.h"
  31 #include "test/cctest/cctest.h"
  32
  33 #include "src/macro-assembler.h"
  34 #include "src/mips/macro-assembler-mips.h"
  35 #include "src/mips/simulator-mips.h"
  36
  37
  38 using namespace v8::internal;
  39
  40 typedef void* (*F)(int x, int y, int p2, int p3, int p4);
  41
  42 #define __ masm->
  43
  44
  45 static byte to_non_zero(int n) {
  46   return static_cast<unsigned>(n) % 255 + 1;
  47 }
  48
  49
  50 static bool all_zeroes(const byte* beg, const byte* end) {
  51   CHECK(beg);
  52   CHECK(beg <= end);
  53   while (beg < end) {
  54     if (*beg++ != 0)
  55       return false;
  56   }
  57   return true;
  58 }
  59
  60
  61 TEST(CopyBytes) {
  62   CcTest::InitializeVM();
  63   Isolate* isolate = Isolate::Current();
  64   HandleScope handles(isolate);
  65
  66   const int data_size = 1 * KB;
  67   size_t act_size;
  68
  69   // Allocate two blocks to copy data between.
  70   byte* src_buffer =
  71       static_cast<byte*>(v8::base::OS::Allocate(data_size, &act_size, 0));
  72   CHECK(src_buffer);
  73   CHECK(act_size >= static_cast<size_t>(data_size));
  74   byte* dest_buffer =
  75       static_cast<byte*>(v8::base::OS::Allocate(data_size, &act_size, 0));
  76   CHECK(dest_buffer);
  77   CHECK(act_size >= static_cast<size_t>(data_size));
  78
  79   // Storage for a0 and a1.
  80   byte* a0_;
  81   byte* a1_;
  82
  83   MacroAssembler assembler(isolate, NULL, 0);
  84   MacroAssembler* masm = &assembler;
  85
  86   // Code to be generated: The stuff in CopyBytes followed by a store of a0 and
  87   // a1, respectively.
  88   __ CopyBytes(a0, a1, a2, a3);
  89   __ li(a2, Operand(reinterpret_cast<int>(&a0_)));
  90   __ li(a3, Operand(reinterpret_cast<int>(&a1_)));
  91   __ sw(a0, MemOperand(a2));
  92   __ jr(ra);
  93   __ sw(a1, MemOperand(a3));
  94
  95   CodeDesc desc;
  96   masm->GetCode(&desc);
  97   Handle<Code> code = isolate->factory()->NewCode(
  98       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
  99
 100   ::F f = FUNCTION_CAST< ::F>(code->entry());
 101
 102   // Initialise source data with non-zero bytes.
 103   for (int i = 0; i < data_size; i++) {
 104     src_buffer[i] = to_non_zero(i);
 105   }
 106
 107   const int fuzz = 11;
 108
 109   for (int size = 0; size < 600; size++) {
 110     for (const byte* src = src_buffer; src < src_buffer + fuzz; src++) {
 111       for (byte* dest = dest_buffer; dest < dest_buffer + fuzz; dest++) {
 112         memset(dest_buffer, 0, data_size);
 113         CHECK(dest + size < dest_buffer + data_size);
 114         (void) CALL_GENERATED_CODE(f, reinterpret_cast<int>(src),
 115                                       reinterpret_cast<int>(dest), size, 0, 0);
 116         // a0 and a1 should point at the first byte after the copied data.
 117         CHECK_EQ(src + size, a0_);
 118         CHECK_EQ(dest + size, a1_);
 119         // Check that we haven't written outside the target area.
 120         CHECK(all_zeroes(dest_buffer, dest));
 121         CHECK(all_zeroes(dest + size, dest_buffer + data_size));
 122         // Check the target area.
 123         CHECK_EQ(0, memcmp(src, dest, size));
 124       }
 125     }
 126   }
 127
 128   // Check that the source data hasn't been clobbered.
 129   for (int i = 0; i < data_size; i++) {
 130     CHECK(src_buffer[i] == to_non_zero(i));
 131   }
 132 }
 133
 134
 135 static void TestNaN(const char *code) {
 136   // NaN value is different on MIPS and x86 architectures, and TEST(NaNx)
 137   // tests checks the case where a x86 NaN value is serialized into the
 138   // snapshot on the simulator during cross compilation.
 139   v8::HandleScope scope(CcTest::isolate());
 140   v8::Local<v8::Context> context = CcTest::NewContext(PRINT_EXTENSION);
 141   v8::Context::Scope context_scope(context);
 142
 143   v8::Local<v8::Script> script = v8::Script::Compile(v8_str(code));
 144   v8::Local<v8::Object> result = v8::Local<v8::Object>::Cast(script->Run());
 145   // Have to populate the handle manually, as it's not Cast-able.
 146   i::Handle<i::JSObject> o =
 147       v8::Utils::OpenHandle<v8::Object, i::JSObject>(result);
 148   i::Handle<i::JSArray> array1(reinterpret_cast<i::JSArray*>(*o));
 149   i::FixedDoubleArray* a = i::FixedDoubleArray::cast(array1->elements());
 150   double value = a->get_scalar(0);
 151   CHECK(std::isnan(value) &&
 152         i::BitCast<uint64_t>(value) ==
 153         i::BitCast<uint64_t>(
 154             i::FixedDoubleArray::canonical_not_the_hole_nan_as_double()));
 155 }
 156
 157
 158 TEST(NaN0) {
 159   TestNaN(
 160           "var result;"
 161           "for (var i = 0; i < 2; i++) {"
 162           "  result = new Array(Number.NaN, Number.POSITIVE_INFINITY);"
 163           "}"
 164           "result;");
 165 }
 166
 167
 168 TEST(NaN1) {
 169   TestNaN(
 170           "var result;"
 171           "for (var i = 0; i < 2; i++) {"
 172           "  result = [NaN];"
 173           "}"
 174           "result;");
 175 }
 176
 177
 178 #undef __