1// Copyright 2011 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
32#include "src/base/platform/platform.h"
33#include "src/disassembler.h"
34#include "src/factory.h"
35#include "src/macro-assembler.h"
36#include "src/ostreams.h"
37#include "src/serialize.h"
38#include "test/cctest/cctest.h"
39
40using namespace v8::internal;
41
42
43typedef int (*F0)();
44typedef int (*F1)(int x);
45typedef int (*F2)(int x, int y);
46
47
48#define __ assm.
49
50TEST(AssemblerIa320) {
51  CcTest::InitializeVM();
52  Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());
53  HandleScope scope(isolate);
54
55  v8::internal::byte buffer[256];
56  Assembler assm(isolate, buffer, sizeof buffer);
57
58  __ mov(eax, Operand(esp, 4));
59  __ add(eax, Operand(esp, 8));
60  __ ret(0);
61
62  CodeDesc desc;
63  assm.GetCode(&desc);
64  Handle<Code> code = isolate->factory()->NewCode(
65      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
66#ifdef OBJECT_PRINT
67  OFStream os(stdout);
68  code->Print(os);
69#endif
70  F2 f = FUNCTION_CAST<F2>(code->entry());
71  int res = f(3, 4);
72  ::printf("f() = %d\n", res);
73  CHECK_EQ(7, res);
74}
75
76
77TEST(AssemblerIa321) {
78  CcTest::InitializeVM();
79  Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());
80  HandleScope scope(isolate);
81
82  v8::internal::byte buffer[256];
83  Assembler assm(isolate, buffer, sizeof buffer);
84  Label L, C;
85
86  __ mov(edx, Operand(esp, 4));
87  __ xor_(eax, eax);  // clear eax
88  __ jmp(&C);
89
90  __ bind(&L);
91  __ add(eax, edx);
92  __ sub(edx, Immediate(1));
93
94  __ bind(&C);
95  __ test(edx, edx);
96  __ j(not_zero, &L);
97  __ ret(0);
98
99  CodeDesc desc;
100  assm.GetCode(&desc);
101  Handle<Code> code = isolate->factory()->NewCode(
102      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
103#ifdef OBJECT_PRINT
104  OFStream os(stdout);
105  code->Print(os);
106#endif
107  F1 f = FUNCTION_CAST<F1>(code->entry());
108  int res = f(100);
109  ::printf("f() = %d\n", res);
110  CHECK_EQ(5050, res);
111}
112
113
114TEST(AssemblerIa322) {
115  CcTest::InitializeVM();
116  Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());
117  HandleScope scope(isolate);
118
119  v8::internal::byte buffer[256];
120  Assembler assm(isolate, buffer, sizeof buffer);
121  Label L, C;
122
123  __ mov(edx, Operand(esp, 4));
124  __ mov(eax, 1);
125  __ jmp(&C);
126
127  __ bind(&L);
128  __ imul(eax, edx);
129  __ sub(edx, Immediate(1));
130
131  __ bind(&C);
132  __ test(edx, edx);
133  __ j(not_zero, &L);
134  __ ret(0);
135
136  // some relocated stuff here, not executed
137  __ mov(eax, isolate->factory()->true_value());
138  __ jmp(NULL, RelocInfo::RUNTIME_ENTRY);
139
140  CodeDesc desc;
141  assm.GetCode(&desc);
142  Handle<Code> code = isolate->factory()->NewCode(
143      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
144#ifdef OBJECT_PRINT
145  OFStream os(stdout);
146  code->Print(os);
147#endif
148  F1 f = FUNCTION_CAST<F1>(code->entry());
149  int res = f(10);
150  ::printf("f() = %d\n", res);
151  CHECK_EQ(3628800, res);
152}
153
154
155typedef int (*F3)(float x);
156
157typedef int (*F4)(double x);
158
159static int baz = 42;
160TEST(AssemblerIa325) {
161  CcTest::InitializeVM();
162  Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());
163  HandleScope scope(isolate);
164
165  v8::internal::byte buffer[256];
166  Assembler assm(isolate, buffer, sizeof buffer);
167
168  __ mov(eax, Operand(reinterpret_cast<intptr_t>(&baz), RelocInfo::NONE32));
169  __ ret(0);
170
171  CodeDesc desc;
172  assm.GetCode(&desc);
173  Handle<Code> code = isolate->factory()->NewCode(
174      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
175  F0 f = FUNCTION_CAST<F0>(code->entry());
176  int res = f();
177  CHECK_EQ(42, res);
178}
179
180
181typedef int (*F7)(double x, double y);
182
183TEST(AssemblerIa329) {
184  CcTest::InitializeVM();
185  Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());
186  HandleScope scope(isolate);
187  v8::internal::byte buffer[256];
188  MacroAssembler assm(isolate, buffer, sizeof buffer);
189  enum { kEqual = 0, kGreater = 1, kLess = 2, kNaN = 3, kUndefined = 4 };
190  Label equal_l, less_l, greater_l, nan_l;
191  __ fld_d(Operand(esp, 3 * kPointerSize));
192  __ fld_d(Operand(esp, 1 * kPointerSize));
193  __ FCmp();
194  __ j(parity_even, &nan_l);
195  __ j(equal, &equal_l);
196  __ j(below, &less_l);
197  __ j(above, &greater_l);
198
199  __ mov(eax, kUndefined);
200  __ ret(0);
201
202  __ bind(&equal_l);
203  __ mov(eax, kEqual);
204  __ ret(0);
205
206  __ bind(&greater_l);
207  __ mov(eax, kGreater);
208  __ ret(0);
209
210  __ bind(&less_l);
211  __ mov(eax, kLess);
212  __ ret(0);
213
214  __ bind(&nan_l);
215  __ mov(eax, kNaN);
216  __ ret(0);
217
218
219  CodeDesc desc;
220  assm.GetCode(&desc);
221  Handle<Code> code = isolate->factory()->NewCode(
222      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
223#ifdef OBJECT_PRINT
224  OFStream os(stdout);
225  code->Print(os);
226#endif
227
228  F7 f = FUNCTION_CAST<F7>(code->entry());
229  CHECK_EQ(kLess, f(1.1, 2.2));
230  CHECK_EQ(kEqual, f(2.2, 2.2));
231  CHECK_EQ(kGreater, f(3.3, 2.2));
232  CHECK_EQ(kNaN, f(v8::base::OS::nan_value(), 1.1));
233}
234
235
236TEST(AssemblerIa3210) {
237  // Test chaining of label usages within instructions (issue 1644).
238  CcTest::InitializeVM();
239  Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());
240  HandleScope scope(isolate);
241  Assembler assm(isolate, NULL, 0);
242
243  Label target;
244  __ j(equal, &target);
245  __ j(not_equal, &target);
246  __ bind(&target);
247  __ nop();
248}
249
250
251TEST(AssemblerMultiByteNop) {
252  CcTest::InitializeVM();
253  Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());
254  HandleScope scope(isolate);
255  v8::internal::byte buffer[1024];
256  Assembler assm(isolate, buffer, sizeof(buffer));
257  __ push(ebx);
258  __ push(ecx);
259  __ push(edx);
260  __ push(edi);
261  __ push(esi);
262  __ mov(eax, 1);
263  __ mov(ebx, 2);
264  __ mov(ecx, 3);
265  __ mov(edx, 4);
266  __ mov(edi, 5);
267  __ mov(esi, 6);
268  for (int i = 0; i < 16; i++) {
269    int before = assm.pc_offset();
270    __ Nop(i);
271    CHECK_EQ(assm.pc_offset() - before, i);
272  }
273
274  Label fail;
275  __ cmp(eax, 1);
276  __ j(not_equal, &fail);
277  __ cmp(ebx, 2);
278  __ j(not_equal, &fail);
279  __ cmp(ecx, 3);
280  __ j(not_equal, &fail);
281  __ cmp(edx, 4);
282  __ j(not_equal, &fail);
283  __ cmp(edi, 5);
284  __ j(not_equal, &fail);
285  __ cmp(esi, 6);
286  __ j(not_equal, &fail);
287  __ mov(eax, 42);
288  __ pop(esi);
289  __ pop(edi);
290  __ pop(edx);
291  __ pop(ecx);
292  __ pop(ebx);
293  __ ret(0);
294  __ bind(&fail);
295  __ mov(eax, 13);
296  __ pop(esi);
297  __ pop(edi);
298  __ pop(edx);
299  __ pop(ecx);
300  __ pop(ebx);
301  __ ret(0);
302
303  CodeDesc desc;
304  assm.GetCode(&desc);
305  Handle<Code> code = isolate->factory()->NewCode(
306      desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
307  CHECK(code->IsCode());
308
309  F0 f = FUNCTION_CAST<F0>(code->entry());
310  int res = f();
311  CHECK_EQ(42, res);
312}
313
314
315#undef __
316