[ARM,MIPS] Skip slow tests
[WebKit-https.git] / JSTests / stress / get-by-val-on-undecided-array-type.js
1 "use strict"
2
3 // Test in-bounds access.
4 function opaqueGetByVal1(array, index) {
5     return array[index];
6 }
7 noInline(opaqueGetByVal1);
8
9 function testAccessInBounds() {
10     const target = new Array(100);
11
12     // We start with an original array. Those GetByVal can be eliminated.
13     for (let i = 0; i < 1e4; ++i) {
14         const value = opaqueGetByVal1(target, i % 100);
15         if (value !== undefined)
16             throw "opaqueGetByVal1() case 1 failed for i = " + i + " value = " + value;
17     }
18
19     // Adding non-indexed properties to change the kind of array we are dealing with.
20     target["webkit"] = "awesome!";
21     target[-5] = "Uh?";
22     for (let i = 0; i < 1e4; ++i) {
23         const value = opaqueGetByVal1(target, i % 100);
24         if (value !== undefined)
25             throw "opaqueGetByVal1() case 2 failed for i = " + i + " value = " + value;
26     }
27
28     if (target["webkit"] !== "awesome!")
29         throw "Failed to retrieve \"webkit\"";
30     if (opaqueGetByVal1(target, -5) !== "Uh?")
31         throw "Failed to retrive -5";
32 }
33 testAccessInBounds();
34
35 // Empty array access.
36 function opaqueGetByVal2(array, index) {
37     return array[index];
38 }
39 noInline(opaqueGetByVal2);
40
41 function testEmptyArrayAccess() {
42     const target = new Array();
43
44     // We start with an original array. Those GetByVal can be eliminated.
45     for (let i = 0; i < 1e4; ++i) {
46         const value = opaqueGetByVal2(target, i % 100);
47         if (value !== undefined)
48             throw "opaqueGetByVal2() case 1 failed for i = " + i + " value = " + value;
49     }
50
51     // Adding non-indexed properties to change the kind of array we are dealing with.
52     target["webkit"] = "awesome!";
53     target[-5] = "Uh?";
54     for (let i = 0; i < 1e4; ++i) {
55         const value = opaqueGetByVal2(target, i % 100);
56         if (value !== undefined)
57             throw "opaqueGetByVal2() case 2 failed for i = " + i + " value = " + value;
58     }
59     if (target["webkit"] !== "awesome!")
60         throw "Failed to retrieve \"webkit\"";
61     if (opaqueGetByVal2(target, -5) !== "Uh?")
62         throw "Failed to retrive -5";
63 }
64 testEmptyArrayAccess();
65
66 // Out of bounds array access.
67 function opaqueGetByVal3(array, index) {
68     return array[index];
69 }
70 noInline(opaqueGetByVal3);
71
72 function testOutOfBoundsArrayAccess() {
73     const target = new Array(42);
74
75     // We start with an original array. Those GetByVal can be eliminated.
76     for (let i = 0; i < 1e4; ++i) {
77         const value = opaqueGetByVal3(target, i + 43);
78         if (value !== undefined)
79             throw "opaqueGetByVal3() case 1 failed for i = " + i + " value = " + value;
80     }
81
82     // Adding non-indexed properties to change the kind of array we are dealing with.
83     target["webkit"] = "awesome!";
84     target[-5] = "Uh?";
85     for (let i = 0; i < 1e4; ++i) {
86         const value = opaqueGetByVal3(target, i + 43);
87         if (value !== undefined)
88             throw "opaqueGetByVal3() case 2 failed for i = " + i + " value = " + value;
89     }
90     if (target["webkit"] !== "awesome!")
91         throw "Failed to retrieve \"webkit\"";
92     if (opaqueGetByVal3(target, -5) !== "Uh?")
93         throw "Failed to retrive -5";
94 }
95 testOutOfBoundsArrayAccess();
96
97 // In-and-out of bounds.
98 function opaqueGetByVal4(array, index) {
99     return array[index];
100 }
101 noInline(opaqueGetByVal4);
102
103 function testInAndOutOfBoundsArrayAccess() {
104     const target = new Array(71);
105
106     // We start with an original array. Those GetByVal can be eliminated.
107     for (let i = 0; i < 1e4; ++i) {
108         const value = opaqueGetByVal4(target, i);
109         if (value !== undefined)
110             throw "opaqueGetByVal4() case 1 failed for i = " + i + " value = " + value;
111     }
112
113     // Adding non-indexed properties to change the kind of array we are dealing with.
114     target["webkit"] = "awesome!";
115     target[-5] = "Uh?";
116     for (let i = 0; i < 1e4; ++i) {
117         const value = opaqueGetByVal4(target, i);
118         if (value !== undefined)
119             throw "opaqueGetByVal4() case 2 failed for i = " + i + " value = " + value;
120     }
121     if (target["webkit"] !== "awesome!")
122         throw "Failed to retrieve \"webkit\"";
123     if (opaqueGetByVal4(target, -5) !== "Uh?")
124         throw "Failed to retrive -5";
125 }
126 testInAndOutOfBoundsArrayAccess();
127
128 // Negative index.
129 function opaqueGetByVal5(array, index) {
130     return array[index];
131 }
132 noInline(opaqueGetByVal5);
133
134 function testNegativeIndex() {
135     const target = new Array();
136
137     // We start with an original array. Those GetByVal can be eliminated.
138     for (let i = 0; i < 1e4; ++i) {
139         const value = opaqueGetByVal5(target, -1 - i);
140         if (value !== undefined)
141             throw "opaqueGetByVal5() case 1 failed for i = " + i + " value = " + value;
142     }
143
144     // Adding non-indexed properties to change the kind of array we are dealing with.
145     target["webkit"] = "awesome!";
146     target[-5] = "Uh?";
147     for (let i = 0; i < 1e4; ++i) {
148         const value = opaqueGetByVal5(target, -1 - i);
149         if (i === 4) {
150             if (value !== "Uh?")
151                 throw "opaqueGetByVal5() case 2 failed for i = " + i + " value = " + value;
152         } else if (value !== undefined)
153             throw "opaqueGetByVal5() case 2 failed for i = " + i + " value = " + value;
154     }
155     if (target["webkit"] !== "awesome!")
156         throw "Failed to retrieve \"webkit\"";
157     if (opaqueGetByVal5(target, -5) !== "Uh?")
158         throw "Failed to retrive -5";
159 }
160 testNegativeIndex();
161
162 // Test integer boundaries.
163 function opaqueGetByVal6(array, index) {
164     return array[index];
165 }
166 noInline(opaqueGetByVal6);
167
168 function testIntegerBoundaries() {
169     const target = new Array(42);
170
171     for (let i = 0; i < 1e4; ++i) {
172         // 2^31 - 1
173         let value = opaqueGetByVal6(target, 2147483647);
174         if (value !== undefined)
175             throw "opaqueGetByVal6() case 1 failed for 2147483647 value = " + value;
176
177         // 2^31
178         value = opaqueGetByVal6(target, 2147483648);
179         if (value !== undefined)
180             throw "opaqueGetByVal6() case 1 failed for 2147483648 value = " + value;
181
182         // 2^32 - 1
183         value = opaqueGetByVal6(target, 4294967295);
184         if (value !== undefined)
185             throw "opaqueGetByVal6() case 1 failed for 4294967295 value = " + value;
186
187         // 2^32
188         value = opaqueGetByVal6(target, 4294967296);
189         if (value !== undefined)
190             throw "opaqueGetByVal6() case 1 failed for 4294967296 value = " + value;
191
192         // 2^52
193         value = opaqueGetByVal6(target, 4503599627370496);
194         if (value !== undefined)
195             throw "opaqueGetByVal6() case 1 failed for 4503599627370496 value = " + value;
196     }
197 }
198 testIntegerBoundaries();
199
200 // Use a constant index.
201 function opaqueGetByVal7_zero(array) {
202     return array[0];
203 }
204 noInline(opaqueGetByVal7_zero);
205
206 function opaqueGetByVal7_doubleZero(array) {
207     return array[1.5 - 1.5];
208 }
209 noInline(opaqueGetByVal7_doubleZero);
210
211 function opaqueGetByVal7_101(array) {
212     return array[101];
213 }
214 noInline(opaqueGetByVal7_101);
215
216 function opaqueGetByVal7_double101(array) {
217     return array[101.0000];
218 }
219 noInline(opaqueGetByVal7_double101);
220
221 function opaqueGetByVal7_1038(array) {
222     return array[1038];
223 }
224 noInline(opaqueGetByVal7_1038);
225
226 function testContantIndex() {
227     const emptyArray = new Array();
228
229     for (let i = 0; i < 1e4; ++i) {
230         let value = opaqueGetByVal7_zero(emptyArray);
231         if (value !== undefined)
232             throw "opaqueGetByVal7() case 1 failed for 0 value = " + value;
233
234         value = opaqueGetByVal7_doubleZero(emptyArray);
235         if (value !== undefined)
236             throw "opaqueGetByVal7_doubleZero() case 1 failed for 0 value = " + value;
237
238         value = opaqueGetByVal7_101(emptyArray);
239         if (value !== undefined)
240             throw "opaqueGetByVal7() case 1 failed for 101 value = " + value;
241
242         value = opaqueGetByVal7_double101(emptyArray);
243         if (value !== undefined)
244             throw "opaqueGetByVal7() case 1 failed for 101 value = " + value;
245     }
246
247     const uninitializedArray = new Array(1038);
248
249     for (let i = 0; i < 1e4; ++i) {
250         let value = opaqueGetByVal7_zero(uninitializedArray);
251         if (value !== undefined)
252             throw "opaqueGetByVal7() case 2 failed for 0 value = " + value;
253
254         value = opaqueGetByVal7_doubleZero(uninitializedArray);
255         if (value !== undefined)
256             throw "opaqueGetByVal7_doubleZero() case 2 failed for 0 value = " + value;
257
258         value = opaqueGetByVal7_101(uninitializedArray);
259         if (value !== undefined)
260             throw "opaqueGetByVal7() case 2 failed for 101 value = " + value;
261
262         value = opaqueGetByVal7_double101(uninitializedArray);
263         if (value !== undefined)
264             throw "opaqueGetByVal7_double101() case 2 failed for 101 value = " + value;
265
266         value = opaqueGetByVal7_1038(uninitializedArray);
267         if (value !== undefined)
268             throw "opaqueGetByVal7() case 2 failed for 1038 value = " + value;
269     }
270
271 }
272 testContantIndex();
273
274 // Test natural integer proggression.
275 function testValueIsUndefinedInNaturalProgression(value) {
276     if (value !== undefined)
277         throw "Invalid value in natural progression test"
278 }
279 noInline(testValueIsUndefinedInNaturalProgression);
280
281 function testNaturalProgression() {
282     const target = new Array(42);
283
284     for (let i = 0; i < 10; ++i) {
285         const value = target[i];
286         testValueIsUndefinedInNaturalProgression(value);
287     }
288
289     const emptyTarget = new Array();
290     for (let i = 10; i--;) {
291         const value = emptyTarget[i];
292         testValueIsUndefinedInNaturalProgression(value);
293     }
294 }
295 noInline(testNaturalProgression);
296 for (let i = 0; i < 1e4; ++i)
297     testNaturalProgression();
298
299 // PutByVal changes the array type.
300 function getUndecidedArray()
301 {
302     return new Array(50);
303 }
304 noInline(getUndecidedArray);
305
306 for (let i = 0; i < 1e4; ++i) {
307     // Warm up getUndecidedArray() without any useful profiling information.
308     getUndecidedArray();
309 }
310
311 function getByValAfterPutByVal()
312 {
313     const array = getUndecidedArray();
314
315     for (let i = 0; i < array.length + 1; ++i) {
316         if (array[i] !== undefined)
317             throw "Invalid access on the empty array in getByValAfterPutByVal()";
318     }
319
320     array[5] = 42;
321
322     for (let i = array.length + 1; i--;) {
323         if (i === 5) {
324             if (array[i] !== 42)
325                 throw "array[5] !== 42"
326         } else if (array[i] !== undefined)
327             throw "Invalid access on the mostly empty array in getByValAfterPutByVal()";
328     }
329 }
330 noInline(getByValAfterPutByVal);
331
332 for (let i = 0; i < 1e4; ++i)
333     getByValAfterPutByVal();
334
335 // Push changes the array type.
336 function getByValAfterPush()
337 {
338     const array = getUndecidedArray();
339
340     for (let i = 0; i < array.length + 1; ++i) {
341         if (array[i] !== undefined)
342             throw "Invalid access on the empty array in getByValAfterPush()";
343     }
344
345     array.push(43);
346
347     for (let i = array.length + 1; i--;) {
348         if (i === 50) {
349             if (array[i] !== 43)
350                 throw "array[50] !== 43"
351         } else if (array[i] !== undefined)
352             throw "Invalid access on the mostly empty array in getByValAfterPush()";
353     }
354 }
355 noInline(getByValAfterPutByVal);
356
357 for (let i = 0; i < 1e4; ++i)
358     getByValAfterPush();