test-disasm-ia32.cc revision 1e0659c275bb392c045087af4f6b0d7565cb3d77 
1// Copyright 2007-2008 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 "v8.h"
31
32#include "debug.h"
33#include "disasm.h"
34#include "disassembler.h"
35#include "macro-assembler.h"
36#include "serialize.h"
37#include "cctest.h"
38
39using namespace v8::internal;
40
41static v8::Persistent<v8::Context> env;
42
43static void InitializeVM() {
44  if (env.IsEmpty()) {
45    env = v8::Context::New();
46  }
47}
48
49
50#define __ assm.
51
52
53static void DummyStaticFunction(Object* result) {
54}
55
56
57TEST(DisasmIa320) {
58  InitializeVM();
59  v8::HandleScope scope;
60  v8::internal::byte buffer[2048];
61  Assembler assm(buffer, sizeof buffer);
62  DummyStaticFunction(NULL);  // just bloody use it (DELETE; debugging)
63
64  // Short immediate instructions
65  __ adc(eax, 12345678);
66  __ add(Operand(eax), Immediate(12345678));
67  __ or_(eax, 12345678);
68  __ sub(Operand(eax), Immediate(12345678));
69  __ xor_(eax, 12345678);
70  __ and_(eax, 12345678);
71  Handle<FixedArray> foo = Factory::NewFixedArray(10, TENURED);
72  __ cmp(eax, foo);
73
74  // ---- This one caused crash
75  __ mov(ebx,  Operand(esp, ecx, times_2, 0));  // [esp+ecx*4]
76
77  // ---- All instructions that I can think of
78  __ add(edx, Operand(ebx));
79  __ add(edx, Operand(12, RelocInfo::NONE));
80  __ add(edx, Operand(ebx, 0));
81  __ add(edx, Operand(ebx, 16));
82  __ add(edx, Operand(ebx, 1999));
83  __ add(edx, Operand(esp, 0));
84  __ add(edx, Operand(esp, 16));
85  __ add(edx, Operand(esp, 1999));
86  __ nop();
87  __ add(edi, Operand(ebp, ecx, times_4, 0));
88  __ add(edi, Operand(ebp, ecx, times_4, 12));
89  __ add(Operand(ebp, ecx, times_4, 12), Immediate(12));
90
91  __ nop();
92  __ add(Operand(ebx), Immediate(12));
93  __ nop();
94  __ adc(ecx, 12);
95  __ adc(ecx, 1000);
96  __ nop();
97  __ and_(edx, 3);
98  __ and_(edx, Operand(esp, 4));
99  __ cmp(edx, 3);
100  __ cmp(edx, Operand(esp, 4));
101  __ cmp(Operand(ebp, ecx, times_4, 0), Immediate(1000));
102  Handle<FixedArray> foo2 = Factory::NewFixedArray(10, TENURED);
103  __ cmp(ebx, foo2);
104  __ cmpb(ebx, Operand(ebp, ecx, times_2, 0));
105  __ cmpb(Operand(ebp, ecx, times_2, 0), ebx);
106  __ or_(edx, 3);
107  __ xor_(edx, 3);
108  __ nop();
109  {
110    CHECK(CpuFeatures::IsSupported(CPUID));
111    CpuFeatures::Scope fscope(CPUID);
112    __ cpuid();
113  }
114  {
115    CHECK(CpuFeatures::IsSupported(RDTSC));
116    CpuFeatures::Scope fscope(RDTSC);
117    __ rdtsc();
118  }
119  __ movsx_b(edx, Operand(ecx));
120  __ movsx_w(edx, Operand(ecx));
121  __ movzx_b(edx, Operand(ecx));
122  __ movzx_w(edx, Operand(ecx));
123
124  __ nop();
125  __ imul(edx, Operand(ecx));
126  __ shld(edx, Operand(ecx));
127  __ shrd(edx, Operand(ecx));
128  __ bts(Operand(edx), ecx);
129  __ bts(Operand(ebx, ecx, times_4, 0), ecx);
130  __ nop();
131  __ pushad();
132  __ popad();
133  __ pushfd();
134  __ popfd();
135  __ push(Immediate(12));
136  __ push(Immediate(23456));
137  __ push(ecx);
138  __ push(esi);
139  __ push(Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
140  __ push(Operand(ebx, ecx, times_4, 0));
141  __ push(Operand(ebx, ecx, times_4, 0));
142  __ push(Operand(ebx, ecx, times_4, 10000));
143  __ pop(edx);
144  __ pop(eax);
145  __ pop(Operand(ebx, ecx, times_4, 0));
146  __ nop();
147
148  __ add(edx, Operand(esp, 16));
149  __ add(edx, Operand(ecx));
150  __ mov_b(edx, Operand(ecx));
151  __ mov_b(Operand(ecx), 6);
152  __ mov_b(Operand(ebx, ecx, times_4, 10000), 6);
153  __ mov_b(Operand(esp, 16), edx);
154  __ mov_w(edx, Operand(esp, 16));
155  __ mov_w(Operand(esp, 16), edx);
156  __ nop();
157  __ movsx_w(edx, Operand(esp, 12));
158  __ movsx_b(edx, Operand(esp, 12));
159  __ movzx_w(edx, Operand(esp, 12));
160  __ movzx_b(edx, Operand(esp, 12));
161  __ nop();
162  __ mov(edx, 1234567);
163  __ mov(edx, Operand(esp, 12));
164  __ mov(Operand(ebx, ecx, times_4, 10000), Immediate(12345));
165  __ mov(Operand(ebx, ecx, times_4, 10000), edx);
166  __ nop();
167  __ dec_b(edx);
168  __ dec_b(Operand(eax, 10));
169  __ dec_b(Operand(ebx, ecx, times_4, 10000));
170  __ dec(edx);
171  __ cdq();
172
173  __ nop();
174  __ idiv(edx);
175  __ mul(edx);
176  __ neg(edx);
177  __ not_(edx);
178  __ test(Operand(ebx, ecx, times_4, 10000), Immediate(123456));
179
180  __ imul(edx, Operand(ebx, ecx, times_4, 10000));
181  __ imul(edx, ecx, 12);
182  __ imul(edx, ecx, 1000);
183
184  __ inc(edx);
185  __ inc(Operand(ebx, ecx, times_4, 10000));
186  __ push(Operand(ebx, ecx, times_4, 10000));
187  __ pop(Operand(ebx, ecx, times_4, 10000));
188  __ call(Operand(ebx, ecx, times_4, 10000));
189  __ jmp(Operand(ebx, ecx, times_4, 10000));
190
191  __ lea(edx, Operand(ebx, ecx, times_4, 10000));
192  __ or_(edx, 12345);
193  __ or_(edx, Operand(ebx, ecx, times_4, 10000));
194
195  __ nop();
196
197  __ rcl(edx, 1);
198  __ rcl(edx, 7);
199  __ rcr(edx, 1);
200  __ rcr(edx, 7);
201  __ sar(edx, 1);
202  __ sar(edx, 6);
203  __ sar_cl(edx);
204  __ sbb(edx, Operand(ebx, ecx, times_4, 10000));
205  __ shld(edx, Operand(ebx, ecx, times_4, 10000));
206  __ shl(edx, 1);
207  __ shl(edx, 6);
208  __ shl_cl(edx);
209  __ shrd(edx, Operand(ebx, ecx, times_4, 10000));
210  __ shr(edx, 1);
211  __ shr(edx, 7);
212  __ shr_cl(edx);
213
214
215  // Immediates
216
217  __ adc(edx, 12345);
218
219  __ add(Operand(ebx), Immediate(12));
220  __ add(Operand(edx, ecx, times_4, 10000), Immediate(12));
221
222  __ and_(ebx, 12345);
223
224  __ cmp(ebx, 12345);
225  __ cmp(Operand(ebx), Immediate(12));
226  __ cmp(Operand(edx, ecx, times_4, 10000), Immediate(12));
227
228  __ or_(ebx, 12345);
229
230  __ sub(Operand(ebx), Immediate(12));
231  __ sub(Operand(edx, ecx, times_4, 10000), Immediate(12));
232  __ subb(Operand(edx, ecx, times_4, 10000), 100);
233  __ subb(Operand(eax), 100);
234  __ subb(eax, Operand(edx, ecx, times_4, 10000));
235
236  __ xor_(ebx, 12345);
237
238  __ imul(edx, ecx, 12);
239  __ imul(edx, ecx, 1000);
240
241  __ cld();
242  __ rep_movs();
243  __ rep_stos();
244  __ stos();
245
246  __ sub(edx, Operand(ebx, ecx, times_4, 10000));
247  __ sub(edx, Operand(ebx));
248
249  __ test(edx, Immediate(12345));
250  __ test(edx, Operand(ebx, ecx, times_8, 10000));
251  __ test(Operand(esi, edi, times_1, -20000000), Immediate(300000000));
252  __ test_b(edx, Operand(ecx, ebx, times_2, 1000));
253  __ test_b(Operand(eax, -20), 0x9A);
254  __ nop();
255
256  __ xor_(edx, 12345);
257  __ xor_(edx, Operand(ebx, ecx, times_8, 10000));
258  __ bts(Operand(ebx, ecx, times_8, 10000), edx);
259  __ hlt();
260  __ int3();
261  __ ret(0);
262  __ ret(8);
263
264  // Calls
265
266  Label L1, L2;
267  __ bind(&L1);
268  __ nop();
269  __ call(&L1);
270  __ call(&L2);
271  __ nop();
272  __ bind(&L2);
273  __ call(Operand(ebx, ecx, times_4, 10000));
274  __ nop();
275  Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
276  __ call(ic, RelocInfo::CODE_TARGET);
277  __ nop();
278  __ call(FUNCTION_ADDR(DummyStaticFunction), RelocInfo::RUNTIME_ENTRY);
279  __ nop();
280
281  __ jmp(&L1);
282  __ jmp(Operand(ebx, ecx, times_4, 10000));
283#ifdef ENABLE_DEBUGGER_SUPPORT
284  ExternalReference after_break_target =
285      ExternalReference(Debug_Address::AfterBreakTarget());
286  __ jmp(Operand::StaticVariable(after_break_target));
287#endif  // ENABLE_DEBUGGER_SUPPORT
288  __ jmp(ic, RelocInfo::CODE_TARGET);
289  __ nop();
290
291
292  Label Ljcc;
293  __ nop();
294  // long jumps
295  __ j(overflow, &Ljcc);
296  __ j(no_overflow, &Ljcc);
297  __ j(below, &Ljcc);
298  __ j(above_equal, &Ljcc);
299  __ j(equal, &Ljcc);
300  __ j(not_equal, &Ljcc);
301  __ j(below_equal, &Ljcc);
302  __ j(above, &Ljcc);
303  __ j(sign, &Ljcc);
304  __ j(not_sign, &Ljcc);
305  __ j(parity_even, &Ljcc);
306  __ j(parity_odd, &Ljcc);
307  __ j(less, &Ljcc);
308  __ j(greater_equal, &Ljcc);
309  __ j(less_equal, &Ljcc);
310  __ j(greater, &Ljcc);
311  __ nop();
312  __ bind(&Ljcc);
313  // short jumps
314  __ j(overflow, &Ljcc);
315  __ j(no_overflow, &Ljcc);
316  __ j(below, &Ljcc);
317  __ j(above_equal, &Ljcc);
318  __ j(equal, &Ljcc);
319  __ j(not_equal, &Ljcc);
320  __ j(below_equal, &Ljcc);
321  __ j(above, &Ljcc);
322  __ j(sign, &Ljcc);
323  __ j(not_sign, &Ljcc);
324  __ j(parity_even, &Ljcc);
325  __ j(parity_odd, &Ljcc);
326  __ j(less, &Ljcc);
327  __ j(greater_equal, &Ljcc);
328  __ j(less_equal, &Ljcc);
329  __ j(greater, &Ljcc);
330
331  // checking hints
332  __ j(zero, &Ljcc, taken);
333  __ j(zero, &Ljcc, not_taken);
334
335  // __ mov(Operand::StaticVariable(Top::handler_address()), eax);
336  // 0xD9 instructions
337  __ nop();
338
339  __ fld(1);
340  __ fld1();
341  __ fldz();
342  __ fldpi();
343  __ fabs();
344  __ fchs();
345  __ fprem();
346  __ fprem1();
347  __ fincstp();
348  __ ftst();
349  __ fxch(3);
350  __ fld_s(Operand(ebx, ecx, times_4, 10000));
351  __ fstp_s(Operand(ebx, ecx, times_4, 10000));
352  __ ffree(3);
353  __ fld_d(Operand(ebx, ecx, times_4, 10000));
354  __ fstp_d(Operand(ebx, ecx, times_4, 10000));
355  __ nop();
356
357  __ fild_s(Operand(ebx, ecx, times_4, 10000));
358  __ fistp_s(Operand(ebx, ecx, times_4, 10000));
359  __ fild_d(Operand(ebx, ecx, times_4, 10000));
360  __ fistp_d(Operand(ebx, ecx, times_4, 10000));
361  __ fnstsw_ax();
362  __ nop();
363  __ fadd(3);
364  __ fsub(3);
365  __ fmul(3);
366  __ fdiv(3);
367
368  __ faddp(3);
369  __ fsubp(3);
370  __ fmulp(3);
371  __ fdivp(3);
372  __ fcompp();
373  __ fwait();
374  __ nop();
375  {
376    if (CpuFeatures::IsSupported(SSE2)) {
377      CpuFeatures::Scope fscope(SSE2);
378      __ cvttss2si(edx, Operand(ebx, ecx, times_4, 10000));
379      __ cvtsi2sd(xmm1, Operand(ebx, ecx, times_4, 10000));
380      __ addsd(xmm1, xmm0);
381      __ mulsd(xmm1, xmm0);
382      __ subsd(xmm1, xmm0);
383      __ divsd(xmm1, xmm0);
384      __ movdbl(xmm1, Operand(ebx, ecx, times_4, 10000));
385      __ movdbl(Operand(ebx, ecx, times_4, 10000), xmm1);
386      __ ucomisd(xmm0, xmm1);
387
388      // 128 bit move instructions.
389      __ movdqa(xmm0, Operand(ebx, ecx, times_4, 10000));
390      __ movdqa(Operand(ebx, ecx, times_4, 10000), xmm0);
391      __ movdqu(xmm0, Operand(ebx, ecx, times_4, 10000));
392      __ movdqu(Operand(ebx, ecx, times_4, 10000), xmm0);
393    }
394  }
395
396  // cmov.
397  {
398    if (CpuFeatures::IsSupported(CMOV)) {
399      CpuFeatures::Scope use_cmov(CMOV);
400      __ cmov(overflow, eax, Operand(eax, 0));
401      __ cmov(no_overflow, eax, Operand(eax, 1));
402      __ cmov(below, eax, Operand(eax, 2));
403      __ cmov(above_equal, eax, Operand(eax, 3));
404      __ cmov(equal, eax, Operand(ebx, 0));
405      __ cmov(not_equal, eax, Operand(ebx, 1));
406      __ cmov(below_equal, eax, Operand(ebx, 2));
407      __ cmov(above, eax, Operand(ebx, 3));
408      __ cmov(sign, eax, Operand(ecx, 0));
409      __ cmov(not_sign, eax, Operand(ecx, 1));
410      __ cmov(parity_even, eax, Operand(ecx, 2));
411      __ cmov(parity_odd, eax, Operand(ecx, 3));
412      __ cmov(less, eax, Operand(edx, 0));
413      __ cmov(greater_equal, eax, Operand(edx, 1));
414      __ cmov(less_equal, eax, Operand(edx, 2));
415      __ cmov(greater, eax, Operand(edx, 3));
416    }
417  }
418
419  // andpd, cmpltsd, movaps, psllq, psrlq, por.
420  {
421    if (CpuFeatures::IsSupported(SSE2)) {
422      CpuFeatures::Scope fscope(SSE2);
423      __ andpd(xmm0, xmm1);
424      __ andpd(xmm1, xmm2);
425
426      __ cmpltsd(xmm0, xmm1);
427      __ cmpltsd(xmm1, xmm2);
428
429      __ movaps(xmm0, xmm1);
430      __ movaps(xmm1, xmm2);
431
432      __ psllq(xmm0, 17);
433      __ psllq(xmm1, 42);
434
435      __ psllq(xmm0, xmm1);
436      __ psllq(xmm1, xmm2);
437
438      __ psrlq(xmm0, 17);
439      __ psrlq(xmm1, 42);
440
441      __ psrlq(xmm0, xmm1);
442      __ psrlq(xmm1, xmm2);
443
444      __ por(xmm0, xmm1);
445      __ por(xmm1, xmm2);
446    }
447  }
448
449  {
450    if (CpuFeatures::IsSupported(SSE4_1)) {
451      CpuFeatures::Scope scope(SSE4_1);
452      __ pextrd(Operand(eax), xmm0, 1);
453      __ pinsrd(xmm1, Operand(eax), 0);
454    }
455  }
456
457  __ ret(0);
458
459  CodeDesc desc;
460  assm.GetCode(&desc);
461  Object* code = Heap::CreateCode(
462      desc,
463      Code::ComputeFlags(Code::STUB),
464      Handle<Object>(Heap::undefined_value()))->ToObjectChecked();
465  CHECK(code->IsCode());
466#ifdef OBJECT_PRINT
467  Code::cast(code)->Print();
468  byte* begin = Code::cast(code)->instruction_start();
469  byte* end = begin + Code::cast(code)->instruction_size();
470  disasm::Disassembler::Disassemble(stdout, begin, end);
471#endif
472}
473
474#undef __
475