OLD | NEW |
1 // Copyright 2011 the V8 project authors. All rights reserved. | 1 // Copyright 2011 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
11 // with the distribution. | 11 // with the distribution. |
12 // * Neither the name of Google Inc. nor the names of its | 12 // * Neither the name of Google Inc. nor the names of its |
13 // contributors may be used to endorse or promote products derived | 13 // contributors may be used to endorse or promote products derived |
14 // from this software without specific prior written permission. | 14 // from this software without specific prior written permission. |
15 // | 15 // |
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | 17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | 18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | 19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | 20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | 21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | 22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | 23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | 24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | 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. | 26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
27 | 27 |
28 // Flags: --allow-natives-syntax --smi-only-arrays | 28 // Flags: --allow-natives-syntax --smi-only-arrays --expose-gc |
| 29 |
29 // Test element kind of objects. | 30 // Test element kind of objects. |
30 // Since --smi-only-arrays affects builtins, its default setting at compile | 31 // 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 // 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 // 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 // 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 // enabled, this test takes the appropriate code path to check smi-only arrays. |
35 | 36 |
36 | |
37 support_smi_only_arrays = %HasFastSmiOnlyElements([]); | 37 support_smi_only_arrays = %HasFastSmiOnlyElements([]); |
38 | 38 |
39 if (support_smi_only_arrays) { | 39 if (support_smi_only_arrays) { |
40 print("Tests include smi-only arrays."); | 40 print("Tests include smi-only arrays."); |
41 } else { | 41 } else { |
42 print("Tests do NOT include smi-only arrays."); | 42 print("Tests do NOT include smi-only arrays."); |
43 } | 43 } |
44 | 44 |
45 var element_kind = { | 45 var elements_kind = { |
46 fast_smi_only_elements : 0, | 46 fast_smi_only : 'fast smi only elements', |
47 fast_elements : 1, | 47 fast : 'fast elements', |
48 fast_double_elements : 2, | 48 fast_double : 'fast double elements', |
49 dictionary_elements : 3, | 49 dictionary : 'dictionary elements', |
50 external_byte_elements : 4, | 50 external_byte : 'external byte elements', |
51 external_unsigned_byte_elements : 5, | 51 external_unsigned_byte : 'external unsigned byte elements', |
52 external_short_elements : 6, | 52 external_short : 'external short elements', |
53 external_unsigned_short_elements : 7, | 53 external_unsigned_short : 'external unsigned short elements', |
54 external_int_elements : 8, | 54 external_int : 'external int elements', |
55 external_unsigned_int_elements : 9, | 55 external_unsigned_int : 'external unsigned int elements', |
56 external_float_elements : 10, | 56 external_float : 'external float elements', |
57 external_double_elements : 11, | 57 external_double : 'external double elements', |
58 external_pixel_elements : 12 | 58 external_pixel : 'external pixel elements' |
59 } | 59 } |
60 | 60 |
61 // We expect an object to only be of one element kind. | 61 function getKind(obj) { |
62 function assertKind(expected, obj) { | 62 if (%HasFastSmiOnlyElements(obj)) return elements_kind.fast_smi_only; |
63 if (support_smi_only_arrays) { | 63 if (%HasFastElements(obj)) return elements_kind.fast; |
64 assertEquals(expected == element_kind.fast_smi_only_elements, | 64 if (%HasFastDoubleElements(obj)) return elements_kind.fast_double; |
65 %HasFastSmiOnlyElements(obj)); | 65 if (%HasDictionaryElements(obj)) return elements_kind.dictionary; |
66 assertEquals(expected == element_kind.fast_elements, | 66 // Every external kind is also an external array. |
67 %HasFastElements(obj)); | 67 assertTrue(%HasExternalArrayElements(obj)); |
68 } else { | 68 if (%HasExternalByteElements(obj)) { |
69 assertEquals(expected == element_kind.fast_elements || | 69 return elements_kind.external_byte; |
70 expected == element_kind.fast_smi_only_elements, | |
71 %HasFastElements(obj)); | |
72 } | 70 } |
73 assertEquals(expected == element_kind.fast_double_elements, | 71 if (%HasExternalUnsignedByteElements(obj)) { |
74 %HasFastDoubleElements(obj)); | 72 return elements_kind.external_unsigned_byte; |
75 assertEquals(expected == element_kind.dictionary_elements, | 73 } |
76 %HasDictionaryElements(obj)); | 74 if (%HasExternalShortElements(obj)) { |
77 assertEquals(expected == element_kind.external_byte_elements, | 75 return elements_kind.external_short; |
78 %HasExternalByteElements(obj)); | 76 } |
79 assertEquals(expected == element_kind.external_unsigned_byte_elements, | 77 if (%HasExternalUnsignedShortElements(obj)) { |
80 %HasExternalUnsignedByteElements(obj)); | 78 return elements_kind.external_unsigned_short; |
81 assertEquals(expected == element_kind.external_short_elements, | 79 } |
82 %HasExternalShortElements(obj)); | 80 if (%HasExternalIntElements(obj)) { |
83 assertEquals(expected == element_kind.external_unsigned_short_elements, | 81 return elements_kind.external_int; |
84 %HasExternalUnsignedShortElements(obj)); | 82 } |
85 assertEquals(expected == element_kind.external_int_elements, | 83 if (%HasExternalUnsignedIntElements(obj)) { |
86 %HasExternalIntElements(obj)); | 84 return elements_kind.external_unsigned_int; |
87 assertEquals(expected == element_kind.external_unsigned_int_elements, | 85 } |
88 %HasExternalUnsignedIntElements(obj)); | 86 if (%HasExternalFloatElements(obj)) { |
89 assertEquals(expected == element_kind.external_float_elements, | 87 return elements_kind.external_float; |
90 %HasExternalFloatElements(obj)); | 88 } |
91 assertEquals(expected == element_kind.external_double_elements, | 89 if (%HasExternalDoubleElements(obj)) { |
92 %HasExternalDoubleElements(obj)); | 90 return elements_kind.external_double; |
93 assertEquals(expected == element_kind.external_pixel_elements, | 91 } |
94 %HasExternalPixelElements(obj)); | 92 if (%HasExternalPixelElements(obj)) { |
95 // every external kind is also an external array | 93 return elements_kind.external_pixel; |
96 assertEquals(expected >= element_kind.external_byte_elements, | 94 } |
97 %HasExternalArrayElements(obj)); | 95 } |
| 96 |
| 97 function assertKind(expected, obj, name_opt) { |
| 98 if (!support_smi_only_arrays && |
| 99 expected == elements_kind.fast_smi_only) { |
| 100 expected = elements_kind.fast; |
| 101 } |
| 102 assertEquals(expected, getKind(obj), name_opt); |
98 } | 103 } |
99 | 104 |
100 var me = {}; | 105 var me = {}; |
101 assertKind(element_kind.fast_elements, me); | 106 assertKind(elements_kind.fast, me); |
102 me.dance = 0xD15C0; | 107 me.dance = 0xD15C0; |
103 me.drink = 0xC0C0A; | 108 me.drink = 0xC0C0A; |
104 assertKind(element_kind.fast_elements, me); | 109 assertKind(elements_kind.fast, me); |
105 | 110 |
106 var too = [1,2,3]; | 111 var too = [1,2,3]; |
107 assertKind(element_kind.fast_smi_only_elements, too); | 112 assertKind(elements_kind.fast_smi_only, too); |
108 too.dance = 0xD15C0; | 113 too.dance = 0xD15C0; |
109 too.drink = 0xC0C0A; | 114 too.drink = 0xC0C0A; |
110 assertKind(element_kind.fast_smi_only_elements, too); | 115 assertKind(elements_kind.fast_smi_only, too); |
111 | 116 |
112 // Make sure the element kind transitions from smionly when a non-smi is stored. | 117 // Make sure the element kind transitions from smionly when a non-smi is stored. |
113 var you = new Array(); | 118 var you = new Array(); |
114 assertKind(element_kind.fast_smi_only_elements, you); | 119 assertKind(elements_kind.fast_smi_only, you); |
115 for (var i = 0; i < 1337; i++) { | 120 for (var i = 0; i < 1337; i++) { |
116 var val = i; | 121 var val = i; |
117 if (i == 1336) { | 122 if (i == 1336) { |
118 assertKind(element_kind.fast_smi_only_elements, you); | 123 assertKind(elements_kind.fast_smi_only, you); |
119 val = new Object(); | 124 val = new Object(); |
120 } | 125 } |
121 you[i] = val; | 126 you[i] = val; |
122 } | 127 } |
123 assertKind(element_kind.fast_elements, you); | 128 assertKind(elements_kind.fast, you); |
124 | 129 |
125 assertKind(element_kind.dictionary_elements, new Array(0xDECAF)); | 130 assertKind(elements_kind.dictionary, new Array(0xDECAF)); |
126 | 131 |
127 var fast_double_array = new Array(0xDECAF); | 132 var fast_double_array = new Array(0xDECAF); |
128 for (var i = 0; i < 0xDECAF; i++) fast_double_array[i] = i / 2; | 133 for (var i = 0; i < 0xDECAF; i++) fast_double_array[i] = i / 2; |
129 assertKind(element_kind.fast_double_elements, fast_double_array); | 134 assertKind(elements_kind.fast_double, fast_double_array); |
130 | 135 |
131 assertKind(element_kind.external_byte_elements, new Int8Array(9001)); | 136 assertKind(elements_kind.external_byte, new Int8Array(9001)); |
132 assertKind(element_kind.external_unsigned_byte_elements, new Uint8Array(007)); | 137 assertKind(elements_kind.external_unsigned_byte, new Uint8Array(007)); |
133 assertKind(element_kind.external_short_elements, new Int16Array(666)); | 138 assertKind(elements_kind.external_short, new Int16Array(666)); |
134 assertKind(element_kind.external_unsigned_short_elements, new Uint16Array(42)); | 139 assertKind(elements_kind.external_unsigned_short, new Uint16Array(42)); |
135 assertKind(element_kind.external_int_elements, new Int32Array(0xF)); | 140 assertKind(elements_kind.external_int, new Int32Array(0xF)); |
136 assertKind(element_kind.external_unsigned_int_elements, new Uint32Array(23)); | 141 assertKind(elements_kind.external_unsigned_int, new Uint32Array(23)); |
137 assertKind(element_kind.external_float_elements, new Float32Array(7)); | 142 assertKind(elements_kind.external_float, new Float32Array(7)); |
138 assertKind(element_kind.external_double_elements, new Float64Array(0)); | 143 assertKind(elements_kind.external_double, new Float64Array(0)); |
139 assertKind(element_kind.external_pixel_elements, new PixelArray(512)); | 144 assertKind(elements_kind.external_pixel, new PixelArray(512)); |
140 | 145 |
141 // Crankshaft support for smi-only array elements. | 146 // Crankshaft support for smi-only array elements. |
142 function monomorphic(array) { | 147 function monomorphic(array) { |
143 for (var i = 0; i < 3; i++) { | 148 for (var i = 0; i < 3; i++) { |
144 array[i] = i + 10; | 149 array[i] = i + 10; |
145 } | 150 } |
146 assertKind(element_kind.fast_smi_only_elements, array); | 151 assertKind(elements_kind.fast_smi_only, array); |
147 for (var i = 0; i < 3; i++) { | 152 for (var i = 0; i < 3; i++) { |
148 var a = array[i]; | 153 var a = array[i]; |
149 assertEquals(i + 10, a); | 154 assertEquals(i + 10, a); |
150 } | 155 } |
151 } | 156 } |
152 var smi_only = [1, 2, 3]; | 157 var smi_only = [1, 2, 3]; |
153 for (var i = 0; i < 3; i++) monomorphic(smi_only); | 158 for (var i = 0; i < 3; i++) monomorphic(smi_only); |
154 %OptimizeFunctionOnNextCall(monomorphic); | 159 %OptimizeFunctionOnNextCall(monomorphic); |
155 monomorphic(smi_only); | 160 monomorphic(smi_only); |
156 function polymorphic(array, expected_kind) { | 161 function polymorphic(array, expected_kind) { |
157 array[1] = 42; | 162 array[1] = 42; |
158 assertKind(expected_kind, array); | 163 assertKind(expected_kind, array); |
159 var a = array[1]; | 164 var a = array[1]; |
160 assertEquals(42, a); | 165 assertEquals(42, a); |
161 } | 166 } |
162 var smis = [1, 2, 3]; | 167 var smis = [1, 2, 3]; |
163 var strings = ["one", "two", "three"]; | 168 var strings = [0, 0, 0]; strings[0] = "one"; |
164 var doubles = [0, 0, 0]; doubles[0] = 1.5; doubles[1] = 2.5; doubles[2] = 3.5; | 169 var doubles = [0, 0, 0]; doubles[0] = 1.5; |
165 assertKind(support_smi_only_arrays | 170 assertKind(support_smi_only_arrays |
166 ? element_kind.fast_double_elements | 171 ? elements_kind.fast_double |
167 : element_kind.fast_elements, | 172 : elements_kind.fast, |
168 doubles); | 173 doubles); |
169 for (var i = 0; i < 3; i++) { | 174 for (var i = 0; i < 3; i++) { |
170 polymorphic(smis, element_kind.fast_smi_only_elements); | 175 polymorphic(smis, elements_kind.fast_smi_only); |
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 } |
| 177 for (var i = 0; i < 3; i++) { |
| 178 polymorphic(strings, elements_kind.fast); |
| 179 } |
| 180 for (var i = 0; i < 3; i++) { |
| 181 polymorphic(doubles, i == 0 && support_smi_only_arrays |
| 182 ? elements_kind.fast_double |
| 183 : elements_kind.fast); |
| 184 } |
| 185 |
| 186 /* Element transitions have not been implemented in crankshaft yet. |
176 %OptimizeFunctionOnNextCall(polymorphic); | 187 %OptimizeFunctionOnNextCall(polymorphic); |
177 polymorphic(smis, element_kind.fast_smi_only_elements); | 188 polymorphic(smis, elements_kind.fast_smi_only); |
178 polymorphic(strings, element_kind.fast_elements); | 189 polymorphic(strings, elements_kind.fast); |
179 polymorphic(doubles, support_smi_only_arrays | 190 polymorphic(doubles, elements_kind.fast); |
180 ? element_kind.fast_double_elements | |
181 : element_kind.fast_elements); | |
182 | 191 |
183 // Crankshaft support for smi-only elements in dynamic array literals. | 192 // Crankshaft support for smi-only elements in dynamic array literals. |
184 function get(foo) { return foo; } // Used to generate dynamic values. | 193 function get(foo) { return foo; } // Used to generate dynamic values. |
185 | 194 |
186 function crankshaft_test() { | 195 function crankshaft_test() { |
187 var a = [get(1), get(2), get(3)]; | 196 var a = [get(1), get(2), get(3)]; |
188 assertKind(element_kind.fast_smi_only_elements, a); | 197 assertKind(elements_kind.fast_smi_only, a); |
189 var b = [get(1), get(2), get("three")]; | 198 var b = [get(1), get(2), get("three")]; |
190 assertKind(element_kind.fast_elements, b); | 199 assertKind(elements_kind.fast, b); |
191 var c = [get(1), get(2), get(3.5)]; | 200 var c = [get(1), get(2), get(3.5)]; |
192 // The full code generator doesn't support conversion to fast_double_elements | 201 // The full code generator doesn't support conversion to fast_double |
193 // yet. Crankshaft does, but only with --smi-only-arrays support. | 202 // yet. Crankshaft does, but only with --smi-only-arrays support. |
194 if ((%GetOptimizationStatus(crankshaft_test) & 1) && | 203 if ((%GetOptimizationStatus(crankshaft_test) & 1) && |
195 support_smi_only_arrays) { | 204 support_smi_only_arrays) { |
196 assertKind(element_kind.fast_double_elements, c); | 205 assertKind(elements_kind.fast_double, c); |
197 } else { | 206 } else { |
198 assertKind(element_kind.fast_elements, c); | 207 assertKind(elements_kind.fast, c); |
199 } | 208 } |
200 } | 209 } |
201 for (var i = 0; i < 3; i++) { | 210 for (var i = 0; i < 3; i++) { |
202 crankshaft_test(); | 211 crankshaft_test(); |
203 } | 212 } |
204 %OptimizeFunctionOnNextCall(crankshaft_test); | 213 %OptimizeFunctionOnNextCall(crankshaft_test); |
205 crankshaft_test(); | 214 crankshaft_test(); |
| 215 */ |
206 | 216 |
207 // Elements_kind transitions for arrays. | 217 // Elements_kind transitions for arrays. |
208 | 218 |
209 // A map can have three different elements_kind transitions: SMI->DOUBLE, | 219 // 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 | 220 // 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. | 221 // created, they must always end up with the same FAST map. |
212 | 222 |
213 // This test is meaningless without FAST_SMI_ONLY_ELEMENTS. | 223 // This test is meaningless without FAST_SMI_ONLY_ELEMENTS. |
214 if (support_smi_only_arrays) { | 224 if (support_smi_only_arrays) { |
215 // Preparation: create one pair of identical objects for each case. | 225 // Preparation: create one pair of identical objects for each case. |
216 var a = [1, 2, 3]; | 226 var a = [1, 2, 3]; |
217 var b = [1, 2, 3]; | 227 var b = [1, 2, 3]; |
218 assertTrue(%HaveSameMap(a, b)); | 228 assertTrue(%HaveSameMap(a, b)); |
219 assertKind(element_kind.fast_smi_only_elements, a); | 229 assertKind(elements_kind.fast_smi_only, a); |
220 var c = [1, 2, 3]; | 230 var c = [1, 2, 3]; |
221 c["case2"] = true; | 231 c["case2"] = true; |
222 var d = [1, 2, 3]; | 232 var d = [1, 2, 3]; |
223 d["case2"] = true; | 233 d["case2"] = true; |
224 assertTrue(%HaveSameMap(c, d)); | 234 assertTrue(%HaveSameMap(c, d)); |
225 assertFalse(%HaveSameMap(a, c)); | 235 assertFalse(%HaveSameMap(a, c)); |
226 assertKind(element_kind.fast_smi_only_elements, c); | 236 assertKind(elements_kind.fast_smi_only, c); |
227 var e = [1, 2, 3]; | 237 var e = [1, 2, 3]; |
228 e["case3"] = true; | 238 e["case3"] = true; |
229 var f = [1, 2, 3]; | 239 var f = [1, 2, 3]; |
230 f["case3"] = true; | 240 f["case3"] = true; |
231 assertTrue(%HaveSameMap(e, f)); | 241 assertTrue(%HaveSameMap(e, f)); |
232 assertFalse(%HaveSameMap(a, e)); | 242 assertFalse(%HaveSameMap(a, e)); |
233 assertFalse(%HaveSameMap(c, e)); | 243 assertFalse(%HaveSameMap(c, e)); |
234 assertKind(element_kind.fast_smi_only_elements, e); | 244 assertKind(elements_kind.fast_smi_only, e); |
235 // Case 1: SMI->DOUBLE, DOUBLE->OBJECT, SMI->OBJECT. | 245 // Case 1: SMI->DOUBLE, DOUBLE->OBJECT, SMI->OBJECT. |
236 a[0] = 1.5; | 246 a[0] = 1.5; |
237 assertKind(element_kind.fast_double_elements, a); | 247 assertKind(elements_kind.fast_double, a); |
238 a[0] = "foo"; | 248 a[0] = "foo"; |
239 assertKind(element_kind.fast_elements, a); | 249 assertKind(elements_kind.fast, a); |
240 b[0] = "bar"; | 250 b[0] = "bar"; |
241 assertTrue(%HaveSameMap(a, b)); | 251 assertTrue(%HaveSameMap(a, b)); |
242 // Case 2: SMI->DOUBLE, SMI->OBJECT, DOUBLE->OBJECT. | 252 // Case 2: SMI->DOUBLE, SMI->OBJECT, DOUBLE->OBJECT. |
243 c[0] = 1.5; | 253 c[0] = 1.5; |
244 assertKind(element_kind.fast_double_elements, c); | 254 assertKind(elements_kind.fast_double, c); |
245 assertFalse(%HaveSameMap(c, d)); | 255 assertFalse(%HaveSameMap(c, d)); |
246 d[0] = "foo"; | 256 d[0] = "foo"; |
247 assertKind(element_kind.fast_elements, d); | 257 assertKind(elements_kind.fast, d); |
248 assertFalse(%HaveSameMap(c, d)); | 258 assertFalse(%HaveSameMap(c, d)); |
249 c[0] = "bar"; | 259 c[0] = "bar"; |
250 assertTrue(%HaveSameMap(c, d)); | 260 assertTrue(%HaveSameMap(c, d)); |
251 // Case 3: SMI->OBJECT, SMI->DOUBLE, DOUBLE->OBJECT. | 261 // Case 3: SMI->OBJECT, SMI->DOUBLE, DOUBLE->OBJECT. |
252 e[0] = "foo"; | 262 e[0] = "foo"; |
253 assertKind(element_kind.fast_elements, e); | 263 assertKind(elements_kind.fast, e); |
254 assertFalse(%HaveSameMap(e, f)); | 264 assertFalse(%HaveSameMap(e, f)); |
255 f[0] = 1.5; | 265 f[0] = 1.5; |
256 assertKind(element_kind.fast_double_elements, f); | 266 assertKind(elements_kind.fast_double, f); |
257 assertFalse(%HaveSameMap(e, f)); | 267 assertFalse(%HaveSameMap(e, f)); |
258 f[0] = "bar"; | 268 f[0] = "bar"; |
259 assertKind(element_kind.fast_elements, f); | 269 assertKind(elements_kind.fast, f); |
260 assertTrue(%HaveSameMap(e, f)); | 270 assertTrue(%HaveSameMap(e, f)); |
261 } | 271 } |
| 272 |
| 273 // Throw away type information in the ICs for next stress run. |
| 274 gc(); |
OLD | NEW |