codegen-coverage.js revision 402d937239b0e2fd11bf2f4fe972ad78aa9fd481 
1// Copyright 2009 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// Flags: --nofull-compiler --nofast-compiler
29
30// Test paths in the code generator where values in specific registers
31// get moved around.
32function identity(x) {
33  return x;
34}
35
36function cover_codegen_paths() {
37  var x = 1;
38
39  // This test depends on the fixed order of register allocation.  We try to
40  // get values in specific registers (ia32, x64):
41  var a;   // Register eax, rax.
42  var b;   // Register ebx, rbx.
43  var c;   // Register ecx, rcx.
44  var d;   // Register edx, rdx.
45  var di;  // Register edi, rdi.
46
47  while (x == 1) {
48    // The call will spill registers and leave x in {eax,rax}.
49    x = identity(1);
50    // The add will spill x and reuse {eax,rax} for the result.
51    a = x + 1;
52    // A fresh register {ebx,rbx} will be allocated for x, then reused for
53    // the result.
54    b = x + 1;
55    // Et cetera.
56    c = x + 1;
57    d = x + 1;
58    di = x + 1;
59    // Locals are in the corresponding registers here.
60    assertEquals(8, c << a);
61
62    x = identity(1);
63    a = x + 1;
64    b = x + 1;
65    c = x + 1;
66    d = x + 1;
67    di = x + 1;
68    assertEquals(8, a << c);
69
70    x = identity(1);
71    a = x + 1;
72    b = x + 1;
73    c = x + 1;
74    d = x + 1;
75    di = x + 1;
76    c = 0; // Free register ecx.
77    assertEquals(8, a << d);
78
79    x = identity(1);
80    a = x + 1;
81    b = x + 1;
82    c = x + 1;
83    d = x + 1;
84    di = x + 1;
85    b = 0; // Free register ebx.
86    assertEquals(8, a << d);
87
88    // Test the non-commutative subtraction operation with a smi on the
89    // left, all available registers on the right, and a non-smi result.
90    x = identity(-1073741824);  // Least (31-bit) smi.
91    a = x + 1;  // Still a smi, the greatest smi negated.
92    b = x + 1;
93    c = x + 1;
94    d = x + 1;
95    di = x + 1;
96    // Subtraction should overflow the 31-bit smi range.  The result
97    // (1073741824) is outside the 31-bit smi range so it doesn't hit the
98    // "unsafe smi" code that spills a register.
99    assertEquals(1073741824, 1 - a);
100
101    x = identity(-1073741824);
102    a = x + 1;
103    b = x + 1;
104    c = x + 1;
105    d = x + 1;
106    di = x + 1;
107    assertEquals(1073741824, 1 - b);
108
109    x = identity(-1073741824);
110    a = x + 1;
111    b = x + 1;
112    c = x + 1;
113    d = x + 1;
114    di = x + 1;
115    assertEquals(1073741824, 1 - c);
116
117    x = identity(-1073741824);
118    a = x + 1;
119    b = x + 1;
120    c = x + 1;
121    d = x + 1;
122    di = x + 1;
123    assertEquals(1073741824, 1 - d);
124
125    x = identity(-1073741824);
126    a = x + 1;
127    b = x + 1;
128    c = x + 1;
129    d = x + 1;
130    di = x + 1;
131    assertEquals(1073741824, 1 - di);
132
133    x = 3;
134  }
135}
136
137cover_codegen_paths();
138