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
39using namespace v8::internal;
40
41typedef void* (*F)(int x, int y, int p2, int p3, int p4);
42
43#define __ masm->
44
45
46static byte to_non_zero(int n) {
47  return static_cast<unsigned>(n) % 255 + 1;
48}
49
50
51static 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
62TEST(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
136typedef int (*F5)(void*, void*, void*, void*, void*);
137
138
139TEST(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 __
228