OLD | NEW |
| (Empty) |
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 // Flags: --allow-natives-syntax --smi-only-arrays | |
29 // Test element kind of objects. | |
30 // Since --smi-only-arrays affects builtins, its default setting at compile | |
31 // time sticks if built with snapshot. If --smi-only-arrays is deactivated | |
32 // by default, only a no-snapshot build actually has smi-only arrays enabled | |
33 // in this test case. Depending on whether smi-only arrays are actually | |
34 // enabled, this test takes the appropriate code path to check smi-only arrays. | |
35 | |
36 | |
37 support_smi_only_arrays = %HasFastSmiOnlyElements([]); | |
38 | |
39 if (support_smi_only_arrays) { | |
40 print("Tests include smi-only arrays."); | |
41 } else { | |
42 print("Tests do NOT include smi-only arrays."); | |
43 } | |
44 | |
45 var element_kind = { | |
46 fast_smi_only_elements : 0, | |
47 fast_elements : 1, | |
48 fast_double_elements : 2, | |
49 dictionary_elements : 3, | |
50 external_byte_elements : 4, | |
51 external_unsigned_byte_elements : 5, | |
52 external_short_elements : 6, | |
53 external_unsigned_short_elements : 7, | |
54 external_int_elements : 8, | |
55 external_unsigned_int_elements : 9, | |
56 external_float_elements : 10, | |
57 external_double_elements : 11, | |
58 external_pixel_elements : 12 | |
59 } | |
60 | |
61 // We expect an object to only be of one element kind. | |
62 function assertKind(expected, obj) { | |
63 if (support_smi_only_arrays) { | |
64 assertEquals(expected == element_kind.fast_smi_only_elements, | |
65 %HasFastSmiOnlyElements(obj)); | |
66 assertEquals(expected == element_kind.fast_elements, | |
67 %HasFastElements(obj)); | |
68 } else { | |
69 assertEquals(expected == element_kind.fast_elements || | |
70 expected == element_kind.fast_smi_only_elements, | |
71 %HasFastElements(obj)); | |
72 } | |
73 assertEquals(expected == element_kind.fast_double_elements, | |
74 %HasFastDoubleElements(obj)); | |
75 assertEquals(expected == element_kind.dictionary_elements, | |
76 %HasDictionaryElements(obj)); | |
77 assertEquals(expected == element_kind.external_byte_elements, | |
78 %HasExternalByteElements(obj)); | |
79 assertEquals(expected == element_kind.external_unsigned_byte_elements, | |
80 %HasExternalUnsignedByteElements(obj)); | |
81 assertEquals(expected == element_kind.external_short_elements, | |
82 %HasExternalShortElements(obj)); | |
83 assertEquals(expected == element_kind.external_unsigned_short_elements, | |
84 %HasExternalUnsignedShortElements(obj)); | |
85 assertEquals(expected == element_kind.external_int_elements, | |
86 %HasExternalIntElements(obj)); | |
87 assertEquals(expected == element_kind.external_unsigned_int_elements, | |
88 %HasExternalUnsignedIntElements(obj)); | |
89 assertEquals(expected == element_kind.external_float_elements, | |
90 %HasExternalFloatElements(obj)); | |
91 assertEquals(expected == element_kind.external_double_elements, | |
92 %HasExternalDoubleElements(obj)); | |
93 assertEquals(expected == element_kind.external_pixel_elements, | |
94 %HasExternalPixelElements(obj)); | |
95 // every external kind is also an external array | |
96 assertEquals(expected >= element_kind.external_byte_elements, | |
97 %HasExternalArrayElements(obj)); | |
98 } | |
99 | |
100 var me = {}; | |
101 assertKind(element_kind.fast_elements, me); | |
102 me.dance = 0xD15C0; | |
103 me.drink = 0xC0C0A; | |
104 assertKind(element_kind.fast_elements, me); | |
105 | |
106 var too = [1,2,3]; | |
107 assertKind(element_kind.fast_smi_only_elements, too); | |
108 too.dance = 0xD15C0; | |
109 too.drink = 0xC0C0A; | |
110 assertKind(element_kind.fast_smi_only_elements, too); | |
111 | |
112 // Make sure the element kind transitions from smionly when a non-smi is stored. | |
113 var you = new Array(); | |
114 assertKind(element_kind.fast_smi_only_elements, you); | |
115 for (var i = 0; i < 1337; i++) { | |
116 var val = i; | |
117 if (i == 1336) { | |
118 assertKind(element_kind.fast_smi_only_elements, you); | |
119 val = new Object(); | |
120 } | |
121 you[i] = val; | |
122 } | |
123 assertKind(element_kind.fast_elements, you); | |
124 | |
125 assertKind(element_kind.dictionary_elements, new Array(0xDECAF)); | |
126 | |
127 var fast_double_array = new Array(0xDECAF); | |
128 for (var i = 0; i < 0xDECAF; i++) fast_double_array[i] = i / 2; | |
129 assertKind(element_kind.fast_double_elements, fast_double_array); | |
130 | |
131 assertKind(element_kind.external_byte_elements, new Int8Array(9001)); | |
132 assertKind(element_kind.external_unsigned_byte_elements, new Uint8Array(007)); | |
133 assertKind(element_kind.external_short_elements, new Int16Array(666)); | |
134 assertKind(element_kind.external_unsigned_short_elements, new Uint16Array(42)); | |
135 assertKind(element_kind.external_int_elements, new Int32Array(0xF)); | |
136 assertKind(element_kind.external_unsigned_int_elements, new Uint32Array(23)); | |
137 assertKind(element_kind.external_float_elements, new Float32Array(7)); | |
138 assertKind(element_kind.external_double_elements, new Float64Array(0)); | |
139 assertKind(element_kind.external_pixel_elements, new PixelArray(512)); | |
140 | |
141 // Crankshaft support for smi-only array elements. | |
142 function monomorphic(array) { | |
143 for (var i = 0; i < 3; i++) { | |
144 array[i] = i + 10; | |
145 } | |
146 assertKind(element_kind.fast_smi_only_elements, array); | |
147 for (var i = 0; i < 3; i++) { | |
148 var a = array[i]; | |
149 assertEquals(i + 10, a); | |
150 } | |
151 } | |
152 var smi_only = [1, 2, 3]; | |
153 for (var i = 0; i < 3; i++) monomorphic(smi_only); | |
154 %OptimizeFunctionOnNextCall(monomorphic); | |
155 monomorphic(smi_only); | |
156 function polymorphic(array, expected_kind) { | |
157 array[1] = 42; | |
158 assertKind(expected_kind, array); | |
159 var a = array[1]; | |
160 assertEquals(42, a); | |
161 } | |
162 var smis = [1, 2, 3]; | |
163 var strings = ["one", "two", "three"]; | |
164 var doubles = [0, 0, 0]; doubles[0] = 1.5; doubles[1] = 2.5; doubles[2] = 3.5; | |
165 assertKind(support_smi_only_arrays | |
166 ? element_kind.fast_double_elements | |
167 : element_kind.fast_elements, | |
168 doubles); | |
169 for (var i = 0; i < 3; i++) { | |
170 polymorphic(smis, element_kind.fast_smi_only_elements); | |
171 polymorphic(strings, element_kind.fast_elements); | |
172 polymorphic(doubles, support_smi_only_arrays | |
173 ? element_kind.fast_double_elements | |
174 : element_kind.fast_elements); | |
175 } | |
176 %OptimizeFunctionOnNextCall(polymorphic); | |
177 polymorphic(smis, element_kind.fast_smi_only_elements); | |
178 polymorphic(strings, element_kind.fast_elements); | |
179 polymorphic(doubles, support_smi_only_arrays | |
180 ? element_kind.fast_double_elements | |
181 : element_kind.fast_elements); | |
182 | |
183 // Crankshaft support for smi-only elements in dynamic array literals. | |
184 function get(foo) { return foo; } // Used to generate dynamic values. | |
185 | |
186 function crankshaft_test() { | |
187 var a = [get(1), get(2), get(3)]; | |
188 assertKind(element_kind.fast_smi_only_elements, a); | |
189 var b = [get(1), get(2), get("three")]; | |
190 assertKind(element_kind.fast_elements, b); | |
191 var c = [get(1), get(2), get(3.5)]; | |
192 // The full code generator doesn't support conversion to fast_double_elements | |
193 // yet. Crankshaft does, but only with --smi-only-arrays support. | |
194 if ((%GetOptimizationStatus(crankshaft_test) & 1) && | |
195 support_smi_only_arrays) { | |
196 assertKind(element_kind.fast_double_elements, c); | |
197 } else { | |
198 assertKind(element_kind.fast_elements, c); | |
199 } | |
200 } | |
201 for (var i = 0; i < 3; i++) { | |
202 crankshaft_test(); | |
203 } | |
204 %OptimizeFunctionOnNextCall(crankshaft_test); | |
205 crankshaft_test(); | |
206 | |
207 // Elements_kind transitions for arrays. | |
208 | |
209 // A map can have three different elements_kind transitions: SMI->DOUBLE, | |
210 // DOUBLE->OBJECT, and SMI->OBJECT. No matter in which order these three are | |
211 // created, they must always end up with the same FAST map. | |
212 | |
213 // This test is meaningless without FAST_SMI_ONLY_ELEMENTS. | |
214 if (support_smi_only_arrays) { | |
215 // Preparation: create one pair of identical objects for each case. | |
216 var a = [1, 2, 3]; | |
217 var b = [1, 2, 3]; | |
218 assertTrue(%HaveSameMap(a, b)); | |
219 assertKind(element_kind.fast_smi_only_elements, a); | |
220 var c = [1, 2, 3]; | |
221 c["case2"] = true; | |
222 var d = [1, 2, 3]; | |
223 d["case2"] = true; | |
224 assertTrue(%HaveSameMap(c, d)); | |
225 assertFalse(%HaveSameMap(a, c)); | |
226 assertKind(element_kind.fast_smi_only_elements, c); | |
227 var e = [1, 2, 3]; | |
228 e["case3"] = true; | |
229 var f = [1, 2, 3]; | |
230 f["case3"] = true; | |
231 assertTrue(%HaveSameMap(e, f)); | |
232 assertFalse(%HaveSameMap(a, e)); | |
233 assertFalse(%HaveSameMap(c, e)); | |
234 assertKind(element_kind.fast_smi_only_elements, e); | |
235 // Case 1: SMI->DOUBLE, DOUBLE->OBJECT, SMI->OBJECT. | |
236 a[0] = 1.5; | |
237 assertKind(element_kind.fast_double_elements, a); | |
238 a[0] = "foo"; | |
239 assertKind(element_kind.fast_elements, a); | |
240 b[0] = "bar"; | |
241 assertTrue(%HaveSameMap(a, b)); | |
242 // Case 2: SMI->DOUBLE, SMI->OBJECT, DOUBLE->OBJECT. | |
243 c[0] = 1.5; | |
244 assertKind(element_kind.fast_double_elements, c); | |
245 assertFalse(%HaveSameMap(c, d)); | |
246 d[0] = "foo"; | |
247 assertKind(element_kind.fast_elements, d); | |
248 assertFalse(%HaveSameMap(c, d)); | |
249 c[0] = "bar"; | |
250 assertTrue(%HaveSameMap(c, d)); | |
251 // Case 3: SMI->OBJECT, SMI->DOUBLE, DOUBLE->OBJECT. | |
252 e[0] = "foo"; | |
253 assertKind(element_kind.fast_elements, e); | |
254 assertFalse(%HaveSameMap(e, f)); | |
255 f[0] = 1.5; | |
256 assertKind(element_kind.fast_double_elements, f); | |
257 assertFalse(%HaveSameMap(e, f)); | |
258 f[0] = "bar"; | |
259 assertKind(element_kind.fast_elements, f); | |
260 assertTrue(%HaveSameMap(e, f)); | |
261 } | |
OLD | NEW |