src/v8/test/cctest/test-macro-assembler-arm.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
  35 #include "src/arm/macro-assembler-arm.h"
  36 #include "src/arm/simulator-arm.h"
  37
  38
  39 using namespace v8::internal;
  40
  41 typedef void* (*F)(int x, int y, int p2, int p3, int p4);
  42
  43 #define __ masm->
  44
  45
  46 static byte to_non_zero(int n) {
  47   return static_cast<unsigned>(n) % 255 + 1;
  48 }
  49
  50
  51 static bool all_zeroes(const byte* beg, const byte* end) {
  52   CHECK(beg);
  53   CHECK(beg <= end);
  54   while (beg < end) {
  55     if (*beg++ != 0)
  56       return false;
  57   }
  58   return true;
  59 }
  60
  61
  62 TEST(CopyBytes) {
  63   CcTest::InitializeVM();
  64   Isolate* isolate = Isolate::Current();
  65   HandleScope handles(isolate);
  66
  67   const int data_size = 1 * KB;
  68   size_t act_size;
  69
  70   // Allocate two blocks to copy data between.
  71   byte* src_buffer =
  72       static_cast<byte*>(v8::base::OS::Allocate(data_size, &act_size, 0));
  73   CHECK(src_buffer);
  74   CHECK(act_size >= static_cast<size_t>(data_size));
  75   byte* dest_buffer =
  76       static_cast<byte*>(v8::base::OS::Allocate(data_size, &act_size, 0));
  77   CHECK(dest_buffer);
  78   CHECK(act_size >= static_cast<size_t>(data_size));
  79
  80   // Storage for R0 and R1.
  81   byte* r0_;
  82   byte* r1_;
  83
  84   MacroAssembler assembler(isolate, NULL, 0);
  85   MacroAssembler* masm = &assembler;
  86
  87   // Code to be generated: The stuff in CopyBytes followed by a store of R0 and
  88   // R1, respectively.
  89   __ CopyBytes(r0, r1, r2, r3);
  90   __ mov(r2, Operand(reinterpret_cast<int>(&r0_)));
  91   __ mov(r3, Operand(reinterpret_cast<int>(&r1_)));
  92   __ str(r0, MemOperand(r2));
  93   __ str(r1, MemOperand(r3));
  94   __ bx(lr);
  95
  96   CodeDesc desc;
  97   masm->GetCode(&desc);
  98   Handle<Code> code = isolate->factory()->NewCode(
  99       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 100
 101   F f = FUNCTION_CAST<F>(code->entry());
 102
 103   // Initialise source data with non-zero bytes.
 104   for (int i = 0; i < data_size; i++) {
 105     src_buffer[i] = to_non_zero(i);
 106   }
 107
 108   const int fuzz = 11;
 109
 110   for (int size = 0; size < 600; size++) {
 111     for (const byte* src = src_buffer; src < src_buffer + fuzz; src++) {
 112       for (byte* dest = dest_buffer; dest < dest_buffer + fuzz; dest++) {
 113         memset(dest_buffer, 0, data_size);
 114         CHECK(dest + size < dest_buffer + data_size);
 115         (void) CALL_GENERATED_CODE(f, reinterpret_cast<int>(src),
 116                                       reinterpret_cast<int>(dest), size, 0, 0);
 117         // R0 and R1 should point at the first byte after the copied data.
 118         CHECK_EQ(src + size, r0_);
 119         CHECK_EQ(dest + size, r1_);
 120         // Check that we haven't written outside the target area.
 121         CHECK(all_zeroes(dest_buffer, dest));
 122         CHECK(all_zeroes(dest + size, dest_buffer + data_size));
 123         // Check the target area.
 124         CHECK_EQ(0, memcmp(src, dest, size));
 125       }
 126     }
 127   }
 128
 129   // Check that the source data hasn't been clobbered.
 130   for (int i = 0; i < data_size; i++) {
 131     CHECK(src_buffer[i] == to_non_zero(i));
 132   }
 133 }
 134
 135
 136 typedef int (*F5)(void*, void*, void*, void*, void*);
 137
 138
 139 TEST(LoadAndStoreWithRepresentation) {
 140   // Allocate an executable page of memory.
 141   size_t actual_size;
 142   byte* buffer = static_cast<byte*>(v8::base::OS::Allocate(
 143       Assembler::kMinimalBufferSize, &actual_size, true));
 144   CHECK(buffer);
 145   Isolate* isolate = CcTest::i_isolate();
 146   HandleScope handles(isolate);
 147   MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size));
 148   MacroAssembler* masm = &assembler;  // Create a pointer for the __ macro.
 149   __ sub(sp, sp, Operand(1 * kPointerSize));
 150   Label exit;
 151
 152   // Test 1.
 153   __ mov(r0, Operand(1));  // Test number.
 154   __ mov(r1, Operand(0));
 155   __ str(r1, MemOperand(sp, 0 * kPointerSize));
 156   __ mov(r2, Operand(-1));
 157   __ Store(r2, MemOperand(sp, 0 * kPointerSize), Representation::UInteger8());
 158   __ ldr(r3, MemOperand(sp, 0 * kPointerSize));
 159   __ mov(r2, Operand(255));
 160   __ cmp(r3, r2);
 161   __ b(ne, &exit);
 162   __ mov(r2, Operand(255));
 163   __ Load(r3, MemOperand(sp, 0 * kPointerSize), Representation::UInteger8());
 164   __ cmp(r3, r2);
 165   __ b(ne, &exit);
 166
 167   // Test 2.
 168   __ mov(r0, Operand(2));  // Test number.
 169   __ mov(r1, Operand(0));
 170   __ str(r1, MemOperand(sp, 0 * kPointerSize));
 171   __ mov(r2, Operand(-1));
 172   __ Store(r2, MemOperand(sp, 0 * kPointerSize), Representation::Integer8());
 173   __ ldr(r3, MemOperand(sp, 0 * kPointerSize));
 174   __ mov(r2, Operand(255));
 175   __ cmp(r3, r2);
 176   __ b(ne, &exit);
 177   __ mov(r2, Operand(-1));
 178   __ Load(r3, MemOperand(sp, 0 * kPointerSize), Representation::Integer8());
 179   __ cmp(r3, r2);
 180   __ b(ne, &exit);
 181
 182   // Test 3.
 183   __ mov(r0, Operand(3));  // Test number.
 184   __ mov(r1, Operand(0));
 185   __ str(r1, MemOperand(sp, 0 * kPointerSize));
 186   __ mov(r2, Operand(-1));
 187   __ Store(r2, MemOperand(sp, 0 * kPointerSize), Representation::UInteger16());
 188   __ ldr(r3, MemOperand(sp, 0 * kPointerSize));
 189   __ mov(r2, Operand(65535));
 190   __ cmp(r3, r2);
 191   __ b(ne, &exit);
 192   __ mov(r2, Operand(65535));
 193   __ Load(r3, MemOperand(sp, 0 * kPointerSize), Representation::UInteger16());
 194   __ cmp(r3, r2);
 195   __ b(ne, &exit);
 196
 197   // Test 4.
 198   __ mov(r0, Operand(4));  // Test number.
 199   __ mov(r1, Operand(0));
 200   __ str(r1, MemOperand(sp, 0 * kPointerSize));
 201   __ mov(r2, Operand(-1));
 202   __ Store(r2, MemOperand(sp, 0 * kPointerSize), Representation::Integer16());
 203   __ ldr(r3, MemOperand(sp, 0 * kPointerSize));
 204   __ mov(r2, Operand(65535));
 205   __ cmp(r3, r2);
 206   __ b(ne, &exit);
 207   __ mov(r2, Operand(-1));
 208   __ Load(r3, MemOperand(sp, 0 * kPointerSize), Representation::Integer16());
 209   __ cmp(r3, r2);
 210   __ b(ne, &exit);
 211
 212   __ mov(r0, Operand(0));  // Success.
 213   __ bind(&exit);
 214   __ add(sp, sp, Operand(1 * kPointerSize));
 215   __ bx(lr);
 216
 217   CodeDesc desc;
 218   masm->GetCode(&desc);
 219   Handle<Code> code = isolate->factory()->NewCode(
 220       desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
 221
 222   // Call the function from C++.
 223   F5 f = FUNCTION_CAST<F5>(code->entry());
 224   CHECK_EQ(0, CALL_GENERATED_CODE(f, 0, 0, 0, 0, 0));
 225 }
 226
 227 #undef __