Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(38)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: test/cctest/test-types.cc

Issue 143633007: A64: Synchronize with r18764. (Closed) Base URL: https://v8.googlecode.com/svn/branches/experimental/a64
Patch Set: Created 6 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « test/cctest/test-profile-generator.cc ('k') | test/cctest/trace-extension.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2013 the V8 project authors. All rights reserved. 1 // Copyright 2013 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
(...skipping 12 matching lines...) Expand all
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 #include "cctest.h" 28 #include "cctest.h"
29 #include "types.h" 29 #include "types.h"
30 30
31 using namespace v8::internal; 31 using namespace v8::internal;
32 32
33 // Testing auxiliaries (breaking the Type abstraction). 33 template<class Type, class TypeHandle, class Region>
34 static bool IsBitset(Handle<Type> t) { return t->IsSmi(); } 34 class Types {
35 static bool IsClass(Handle<Type> t) { return t->IsMap(); }
36 static bool IsConstant(Handle<Type> t) { return t->IsBox(); }
37 static bool IsUnion(Handle<Type> t) { return t->IsFixedArray(); }
38
39 static int AsBitset(Handle<Type> t) { return Smi::cast(*t)->value(); }
40 static Map* AsClass(Handle<Type> t) { return Map::cast(*t); }
41 static Object* AsConstant(Handle<Type> t) { return Box::cast(*t)->value(); }
42 static FixedArray* AsUnion(Handle<Type> t) { return FixedArray::cast(*t); }
43
44
45 static void CheckEqual(Handle<Type> type1, Handle<Type> type2) {
46 CHECK_EQ(IsBitset(type1), IsBitset(type2));
47 CHECK_EQ(IsClass(type1), IsClass(type2));
48 CHECK_EQ(IsConstant(type1), IsConstant(type2));
49 CHECK_EQ(IsUnion(type1), IsUnion(type2));
50 CHECK_EQ(type1->NumClasses(), type2->NumClasses());
51 CHECK_EQ(type1->NumConstants(), type2->NumConstants());
52 if (IsBitset(type1)) {
53 CHECK_EQ(AsBitset(type1), AsBitset(type2));
54 } else if (IsClass(type1)) {
55 CHECK_EQ(AsClass(type1), AsClass(type2));
56 } else if (IsConstant(type1)) {
57 CHECK_EQ(AsConstant(type1), AsConstant(type2));
58 } else if (IsUnion(type1)) {
59 CHECK_EQ(AsUnion(type1)->length(), AsUnion(type2)->length());
60 }
61 CHECK(type1->Is(type2));
62 CHECK(type2->Is(type1));
63 }
64
65
66 static void CheckSub(Handle<Type> type1, Handle<Type> type2) {
67 CHECK(type1->Is(type2));
68 CHECK(!type2->Is(type1));
69 if (IsBitset(type1) && IsBitset(type2)) {
70 CHECK_NE(AsBitset(type1), AsBitset(type2));
71 }
72 }
73
74
75 static void CheckUnordered(Handle<Type> type1, Handle<Type> type2) {
76 CHECK(!type1->Is(type2));
77 CHECK(!type2->Is(type1));
78 if (IsBitset(type1) && IsBitset(type2)) {
79 CHECK_NE(AsBitset(type1), AsBitset(type2));
80 }
81 }
82
83
84 static void CheckOverlap(Handle<Type> type1, Handle<Type> type2) {
85 CHECK(type1->Maybe(type2));
86 CHECK(type2->Maybe(type1));
87 if (IsBitset(type1) && IsBitset(type2)) {
88 CHECK_NE(0, AsBitset(type1) & AsBitset(type2));
89 }
90 }
91
92
93 static void CheckDisjoint(Handle<Type> type1, Handle<Type> type2) {
94 CHECK(!type1->Is(type2));
95 CHECK(!type2->Is(type1));
96 CHECK(!type1->Maybe(type2));
97 CHECK(!type2->Maybe(type1));
98 if (IsBitset(type1) && IsBitset(type2)) {
99 CHECK_EQ(0, AsBitset(type1) & AsBitset(type2));
100 }
101 }
102
103
104 class HandlifiedTypes {
105 public: 35 public:
106 explicit HandlifiedTypes(Isolate* isolate) : 36 Types(Region* region, Isolate* isolate) :
107 None(Type::None(isolate)), 37 None(Type::None(region)),
108 Any(Type::Any(isolate)), 38 Any(Type::Any(region)),
109 Oddball(Type::Oddball(isolate)), 39 Oddball(Type::Oddball(region)),
110 Boolean(Type::Boolean(isolate)), 40 Boolean(Type::Boolean(region)),
111 Null(Type::Null(isolate)), 41 Null(Type::Null(region)),
112 Undefined(Type::Undefined(isolate)), 42 Undefined(Type::Undefined(region)),
113 Number(Type::Number(isolate)), 43 Number(Type::Number(region)),
114 Smi(Type::Smi(isolate)), 44 Smi(Type::Smi(region)),
115 Signed32(Type::Signed32(isolate)), 45 Signed32(Type::Signed32(region)),
116 Double(Type::Double(isolate)), 46 Double(Type::Double(region)),
117 Name(Type::Name(isolate)), 47 Name(Type::Name(region)),
118 UniqueName(Type::UniqueName(isolate)), 48 UniqueName(Type::UniqueName(region)),
119 String(Type::String(isolate)), 49 String(Type::String(region)),
120 InternalizedString(Type::InternalizedString(isolate)), 50 InternalizedString(Type::InternalizedString(region)),
121 Symbol(Type::Symbol(isolate)), 51 Symbol(Type::Symbol(region)),
122 Receiver(Type::Receiver(isolate)), 52 Receiver(Type::Receiver(region)),
123 Object(Type::Object(isolate)), 53 Object(Type::Object(region)),
124 Array(Type::Array(isolate)), 54 Array(Type::Array(region)),
125 Function(Type::Function(isolate)), 55 Function(Type::Function(region)),
126 Proxy(Type::Proxy(isolate)), 56 Proxy(Type::Proxy(region)),
127 object_map(isolate->factory()->NewMap(JS_OBJECT_TYPE, 3 * kPointerSize)), 57 object_map(isolate->factory()->NewMap(JS_OBJECT_TYPE, 3 * kPointerSize)),
128 array_map(isolate->factory()->NewMap(JS_ARRAY_TYPE, 4 * kPointerSize)), 58 array_map(isolate->factory()->NewMap(JS_ARRAY_TYPE, 4 * kPointerSize)),
129 isolate_(isolate) { 59 region_(region) {
130 smi = handle(Smi::FromInt(666), isolate); 60 smi = handle(Smi::FromInt(666), isolate);
131 signed32 = isolate->factory()->NewHeapNumber(0x40000000); 61 signed32 = isolate->factory()->NewHeapNumber(0x40000000);
132 object1 = isolate->factory()->NewJSObjectFromMap(object_map); 62 object1 = isolate->factory()->NewJSObjectFromMap(object_map);
133 object2 = isolate->factory()->NewJSObjectFromMap(object_map); 63 object2 = isolate->factory()->NewJSObjectFromMap(object_map);
134 array = isolate->factory()->NewJSArray(20); 64 array = isolate->factory()->NewJSArray(20);
135 ObjectClass = Type::Class(object_map, isolate); 65 ObjectClass = Type::Class(object_map, region);
136 ArrayClass = Type::Class(array_map, isolate); 66 ArrayClass = Type::Class(array_map, region);
137 SmiConstant = Type::Constant(smi, isolate); 67 SmiConstant = Type::Constant(smi, region);
138 Signed32Constant = Type::Constant(signed32, isolate); 68 Signed32Constant = Type::Constant(signed32, region);
139 ObjectConstant1 = Type::Constant(object1, isolate); 69 ObjectConstant1 = Type::Constant(object1, region);
140 ObjectConstant2 = Type::Constant(object2, isolate); 70 ObjectConstant2 = Type::Constant(object2, region);
141 ArrayConstant1 = Type::Constant(array, isolate); 71 ArrayConstant1 = Type::Constant(array, region);
142 ArrayConstant2 = Type::Constant(array, isolate); 72 ArrayConstant2 = Type::Constant(array, region);
143 } 73 }
144 74
145 Handle<Type> None; 75 TypeHandle None;
146 Handle<Type> Any; 76 TypeHandle Any;
147 Handle<Type> Oddball; 77 TypeHandle Oddball;
148 Handle<Type> Boolean; 78 TypeHandle Boolean;
149 Handle<Type> Null; 79 TypeHandle Null;
150 Handle<Type> Undefined; 80 TypeHandle Undefined;
151 Handle<Type> Number; 81 TypeHandle Number;
152 Handle<Type> Smi; 82 TypeHandle Smi;
153 Handle<Type> Signed32; 83 TypeHandle Signed32;
154 Handle<Type> Double; 84 TypeHandle Double;
155 Handle<Type> Name; 85 TypeHandle Name;
156 Handle<Type> UniqueName; 86 TypeHandle UniqueName;
157 Handle<Type> String; 87 TypeHandle String;
158 Handle<Type> InternalizedString; 88 TypeHandle InternalizedString;
159 Handle<Type> Symbol; 89 TypeHandle Symbol;
160 Handle<Type> Receiver; 90 TypeHandle Receiver;
161 Handle<Type> Object; 91 TypeHandle Object;
162 Handle<Type> Array; 92 TypeHandle Array;
163 Handle<Type> Function; 93 TypeHandle Function;
164 Handle<Type> Proxy; 94 TypeHandle Proxy;
165 95
166 Handle<Type> ObjectClass; 96 TypeHandle ObjectClass;
167 Handle<Type> ArrayClass; 97 TypeHandle ArrayClass;
168 98
169 Handle<Type> SmiConstant; 99 TypeHandle SmiConstant;
170 Handle<Type> Signed32Constant; 100 TypeHandle Signed32Constant;
171 Handle<Type> ObjectConstant1; 101 TypeHandle ObjectConstant1;
172 Handle<Type> ObjectConstant2; 102 TypeHandle ObjectConstant2;
173 Handle<Type> ArrayConstant1; 103 TypeHandle ArrayConstant1;
174 Handle<Type> ArrayConstant2; 104 TypeHandle ArrayConstant2;
175 105
176 Handle<Map> object_map; 106 Handle<i::Map> object_map;
177 Handle<Map> array_map; 107 Handle<i::Map> array_map;
178 108
179 Handle<i::Smi> smi; 109 Handle<i::Smi> smi;
180 Handle<HeapNumber> signed32; 110 Handle<i::HeapNumber> signed32;
181 Handle<JSObject> object1; 111 Handle<i::JSObject> object1;
182 Handle<JSObject> object2; 112 Handle<i::JSObject> object2;
183 Handle<JSArray> array; 113 Handle<i::JSArray> array;
184 114
185 Handle<Type> Union(Handle<Type> t1, Handle<Type> t2) { 115 TypeHandle Union(TypeHandle t1, TypeHandle t2) {
186 return Type::Union(t1, t2, isolate_); 116 return Type::Union(t1, t2, region_);
187 } 117 }
188 Handle<Type> Intersect(Handle<Type> t1, Handle<Type> t2) { 118 TypeHandle Intersect(TypeHandle t1, TypeHandle t2) {
189 return Type::Intersect(t1, t2, isolate_); 119 return Type::Intersect(t1, t2, region_);
190 } 120 }
191 121
192 private: 122 private:
193 Isolate* isolate_; 123 Region* region_;
194 }; 124 };
195 125
196 126
127 // Testing auxiliaries (breaking the Type abstraction).
128 struct ZoneRep {
129 static bool IsTagged(Type* t, int tag) {
130 return !IsBitset(t)
131 && reinterpret_cast<intptr_t>(AsTagged(t)->at(0)) == tag;
132 }
133 static bool IsBitset(Type* t) { return reinterpret_cast<intptr_t>(t) & 1; }
134 static bool IsClass(Type* t) { return IsTagged(t, 0); }
135 static bool IsConstant(Type* t) { return IsTagged(t, 1); }
136 static bool IsUnion(Type* t) { return IsTagged(t, 2); }
137
138 static ZoneList<void*>* AsTagged(Type* t) {
139 return reinterpret_cast<ZoneList<void*>*>(t);
140 }
141 static int AsBitset(Type* t) {
142 return static_cast<int>(reinterpret_cast<intptr_t>(t) >> 1);
143 }
144 static Map* AsClass(Type* t) {
145 return *reinterpret_cast<Map**>(AsTagged(t)->at(1));
146 }
147 static Object* AsConstant(Type* t) {
148 return *reinterpret_cast<Object**>(AsTagged(t)->at(1));
149 }
150 static ZoneList<Type*>* AsUnion(Type* t) {
151 return reinterpret_cast<ZoneList<Type*>*>(AsTagged(t));
152 }
153
154 static Zone* ToRegion(Zone* zone, Isolate* isolate) { return zone; }
155 };
156
157
158 struct HeapRep {
159 static bool IsBitset(Handle<HeapType> t) { return t->IsSmi(); }
160 static bool IsClass(Handle<HeapType> t) { return t->IsMap(); }
161 static bool IsConstant(Handle<HeapType> t) { return t->IsBox(); }
162 static bool IsUnion(Handle<HeapType> t) { return t->IsFixedArray(); }
163
164 static int AsBitset(Handle<HeapType> t) { return Smi::cast(*t)->value(); }
165 static Map* AsClass(Handle<HeapType> t) { return Map::cast(*t); }
166 static Object* AsConstant(Handle<HeapType> t) {
167 return Box::cast(*t)->value();
168 }
169 static FixedArray* AsUnion(Handle<HeapType> t) {
170 return FixedArray::cast(*t);
171 }
172
173 static Isolate* ToRegion(Zone* zone, Isolate* isolate) { return isolate; }
174 };
175
176
177 template<class Type, class TypeHandle, class Region, class Rep>
178 struct Tests : Rep {
179 Isolate* isolate;
180 HandleScope scope;
181 Zone zone;
182 Types<Type, TypeHandle, Region> T;
183
184 Tests() :
185 isolate(CcTest::i_isolate()),
186 scope(isolate),
187 zone(isolate),
188 T(Rep::ToRegion(&zone, isolate), isolate) {
189 }
190
191 static void CheckEqual(TypeHandle type1, TypeHandle type2) {
192 CHECK_EQ(Rep::IsBitset(type1), Rep::IsBitset(type2));
193 CHECK_EQ(Rep::IsClass(type1), Rep::IsClass(type2));
194 CHECK_EQ(Rep::IsConstant(type1), Rep::IsConstant(type2));
195 CHECK_EQ(Rep::IsUnion(type1), Rep::IsUnion(type2));
196 CHECK_EQ(type1->NumClasses(), type2->NumClasses());
197 CHECK_EQ(type1->NumConstants(), type2->NumConstants());
198 if (Rep::IsBitset(type1)) {
199 CHECK_EQ(Rep::AsBitset(type1), Rep::AsBitset(type2));
200 } else if (Rep::IsClass(type1)) {
201 CHECK_EQ(Rep::AsClass(type1), Rep::AsClass(type2));
202 } else if (Rep::IsConstant(type1)) {
203 CHECK_EQ(Rep::AsConstant(type1), Rep::AsConstant(type2));
204 } else if (Rep::IsUnion(type1)) {
205 CHECK_EQ(Rep::AsUnion(type1)->length(), Rep::AsUnion(type2)->length());
206 }
207 CHECK(type1->Is(type2));
208 CHECK(type2->Is(type1));
209 }
210
211 static void CheckSub(TypeHandle type1, TypeHandle type2) {
212 CHECK(type1->Is(type2));
213 CHECK(!type2->Is(type1));
214 if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
215 CHECK_NE(Rep::AsBitset(type1), Rep::AsBitset(type2));
216 }
217 }
218
219 static void CheckUnordered(TypeHandle type1, TypeHandle type2) {
220 CHECK(!type1->Is(type2));
221 CHECK(!type2->Is(type1));
222 if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
223 CHECK_NE(Rep::AsBitset(type1), Rep::AsBitset(type2));
224 }
225 }
226
227 static void CheckOverlap(TypeHandle type1, TypeHandle type2) {
228 CHECK(type1->Maybe(type2));
229 CHECK(type2->Maybe(type1));
230 if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
231 CHECK_NE(0, Rep::AsBitset(type1) & Rep::AsBitset(type2));
232 }
233 }
234
235 static void CheckDisjoint(TypeHandle type1, TypeHandle type2) {
236 CHECK(!type1->Is(type2));
237 CHECK(!type2->Is(type1));
238 CHECK(!type1->Maybe(type2));
239 CHECK(!type2->Maybe(type1));
240 if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
241 CHECK_EQ(0, Rep::AsBitset(type1) & Rep::AsBitset(type2));
242 }
243 }
244
245 void Bitset() {
246 CHECK(this->IsBitset(T.None));
247 CHECK(this->IsBitset(T.Any));
248 CHECK(this->IsBitset(T.String));
249 CHECK(this->IsBitset(T.Object));
250
251 CHECK(this->IsBitset(T.Union(T.String, T.Number)));
252 CHECK(this->IsBitset(T.Union(T.String, T.Receiver)));
253
254 CHECK_EQ(0, this->AsBitset(T.None));
255 CHECK_EQ(this->AsBitset(T.Number) | this->AsBitset(T.String),
256 this->AsBitset(T.Union(T.String, T.Number)));
257 CHECK_EQ(this->AsBitset(T.Receiver),
258 this->AsBitset(T.Union(T.Receiver, T.Object)));
259 }
260
261 void Class() {
262 CHECK(this->IsClass(T.ObjectClass));
263 CHECK(this->IsClass(T.ArrayClass));
264
265 CHECK(*T.object_map == this->AsClass(T.ObjectClass));
266 CHECK(*T.array_map == this->AsClass(T.ArrayClass));
267 }
268
269 void Constant() {
270 CHECK(this->IsConstant(T.SmiConstant));
271 CHECK(this->IsConstant(T.ObjectConstant1));
272 CHECK(this->IsConstant(T.ObjectConstant2));
273 CHECK(this->IsConstant(T.ArrayConstant1));
274 CHECK(this->IsConstant(T.ArrayConstant2));
275
276 CHECK(*T.smi == this->AsConstant(T.SmiConstant));
277 CHECK(*T.object1 == this->AsConstant(T.ObjectConstant1));
278 CHECK(*T.object2 == this->AsConstant(T.ObjectConstant2));
279 CHECK(*T.object1 != this->AsConstant(T.ObjectConstant2));
280 CHECK(*T.array == this->AsConstant(T.ArrayConstant1));
281 CHECK(*T.array == this->AsConstant(T.ArrayConstant2));
282 }
283
284 void Is() {
285 // Reflexivity
286 CHECK(T.None->Is(T.None));
287 CHECK(T.Any->Is(T.Any));
288 CHECK(T.Object->Is(T.Object));
289
290 CHECK(T.ObjectClass->Is(T.ObjectClass));
291 CHECK(T.ObjectConstant1->Is(T.ObjectConstant1));
292 CHECK(T.ArrayConstant1->Is(T.ArrayConstant2));
293
294 // Symmetry and Transitivity
295 CheckSub(T.None, T.Number);
296 CheckSub(T.None, T.Any);
297
298 CheckSub(T.Oddball, T.Any);
299 CheckSub(T.Boolean, T.Oddball);
300 CheckSub(T.Null, T.Oddball);
301 CheckSub(T.Undefined, T.Oddball);
302 CheckUnordered(T.Boolean, T.Null);
303 CheckUnordered(T.Undefined, T.Null);
304 CheckUnordered(T.Boolean, T.Undefined);
305
306 CheckSub(T.Number, T.Any);
307 CheckSub(T.Smi, T.Number);
308 CheckSub(T.Signed32, T.Number);
309 CheckSub(T.Double, T.Number);
310 CheckSub(T.Smi, T.Signed32);
311 CheckUnordered(T.Smi, T.Double);
312 CheckUnordered(T.Signed32, T.Double);
313
314 CheckSub(T.Name, T.Any);
315 CheckSub(T.UniqueName, T.Any);
316 CheckSub(T.UniqueName, T.Name);
317 CheckSub(T.String, T.Name);
318 CheckSub(T.InternalizedString, T.String);
319 CheckSub(T.InternalizedString, T.UniqueName);
320 CheckSub(T.InternalizedString, T.Name);
321 CheckSub(T.Symbol, T.UniqueName);
322 CheckSub(T.Symbol, T.Name);
323 CheckUnordered(T.String, T.UniqueName);
324 CheckUnordered(T.String, T.Symbol);
325 CheckUnordered(T.InternalizedString, T.Symbol);
326
327 CheckSub(T.Receiver, T.Any);
328 CheckSub(T.Object, T.Any);
329 CheckSub(T.Object, T.Receiver);
330 CheckSub(T.Array, T.Object);
331 CheckSub(T.Function, T.Object);
332 CheckSub(T.Proxy, T.Receiver);
333 CheckUnordered(T.Object, T.Proxy);
334 CheckUnordered(T.Array, T.Function);
335
336 // Structured subtyping
337 CheckSub(T.None, T.ObjectClass);
338 CheckSub(T.None, T.ObjectConstant1);
339 CheckSub(T.ObjectClass, T.Any);
340 CheckSub(T.ObjectConstant1, T.Any);
341
342 CheckSub(T.ObjectClass, T.Object);
343 CheckSub(T.ArrayClass, T.Object);
344 CheckUnordered(T.ObjectClass, T.ArrayClass);
345
346 CheckSub(T.SmiConstant, T.Smi);
347 CheckSub(T.SmiConstant, T.Signed32);
348 CheckSub(T.SmiConstant, T.Number);
349 CheckSub(T.ObjectConstant1, T.Object);
350 CheckSub(T.ObjectConstant2, T.Object);
351 CheckSub(T.ArrayConstant1, T.Object);
352 CheckSub(T.ArrayConstant1, T.Array);
353 CheckUnordered(T.ObjectConstant1, T.ObjectConstant2);
354 CheckUnordered(T.ObjectConstant1, T.ArrayConstant1);
355
356 CheckUnordered(T.ObjectConstant1, T.ObjectClass);
357 CheckUnordered(T.ObjectConstant2, T.ObjectClass);
358 CheckUnordered(T.ObjectConstant1, T.ArrayClass);
359 CheckUnordered(T.ObjectConstant2, T.ArrayClass);
360 CheckUnordered(T.ArrayConstant1, T.ObjectClass);
361 }
362
363 void Maybe() {
364 CheckOverlap(T.Any, T.Any);
365 CheckOverlap(T.Object, T.Object);
366
367 CheckOverlap(T.Oddball, T.Any);
368 CheckOverlap(T.Boolean, T.Oddball);
369 CheckOverlap(T.Null, T.Oddball);
370 CheckOverlap(T.Undefined, T.Oddball);
371 CheckDisjoint(T.Boolean, T.Null);
372 CheckDisjoint(T.Undefined, T.Null);
373 CheckDisjoint(T.Boolean, T.Undefined);
374
375 CheckOverlap(T.Number, T.Any);
376 CheckOverlap(T.Smi, T.Number);
377 CheckOverlap(T.Double, T.Number);
378 CheckDisjoint(T.Signed32, T.Double);
379
380 CheckOverlap(T.Name, T.Any);
381 CheckOverlap(T.UniqueName, T.Any);
382 CheckOverlap(T.UniqueName, T.Name);
383 CheckOverlap(T.String, T.Name);
384 CheckOverlap(T.InternalizedString, T.String);
385 CheckOverlap(T.InternalizedString, T.UniqueName);
386 CheckOverlap(T.InternalizedString, T.Name);
387 CheckOverlap(T.Symbol, T.UniqueName);
388 CheckOverlap(T.Symbol, T.Name);
389 CheckOverlap(T.String, T.UniqueName);
390 CheckDisjoint(T.String, T.Symbol);
391 CheckDisjoint(T.InternalizedString, T.Symbol);
392
393 CheckOverlap(T.Receiver, T.Any);
394 CheckOverlap(T.Object, T.Any);
395 CheckOverlap(T.Object, T.Receiver);
396 CheckOverlap(T.Array, T.Object);
397 CheckOverlap(T.Function, T.Object);
398 CheckOverlap(T.Proxy, T.Receiver);
399 CheckDisjoint(T.Object, T.Proxy);
400 CheckDisjoint(T.Array, T.Function);
401
402 CheckOverlap(T.ObjectClass, T.Any);
403 CheckOverlap(T.ObjectConstant1, T.Any);
404
405 CheckOverlap(T.ObjectClass, T.Object);
406 CheckOverlap(T.ArrayClass, T.Object);
407 CheckOverlap(T.ObjectClass, T.ObjectClass);
408 CheckOverlap(T.ArrayClass, T.ArrayClass);
409 CheckDisjoint(T.ObjectClass, T.ArrayClass);
410
411 CheckOverlap(T.SmiConstant, T.Smi);
412 CheckOverlap(T.SmiConstant, T.Signed32);
413 CheckOverlap(T.SmiConstant, T.Number);
414 CheckDisjoint(T.SmiConstant, T.Double);
415 CheckOverlap(T.ObjectConstant1, T.Object);
416 CheckOverlap(T.ObjectConstant2, T.Object);
417 CheckOverlap(T.ArrayConstant1, T.Object);
418 CheckOverlap(T.ArrayConstant1, T.Array);
419 CheckOverlap(T.ArrayConstant1, T.ArrayConstant2);
420 CheckOverlap(T.ObjectConstant1, T.ObjectConstant1);
421 CheckDisjoint(T.ObjectConstant1, T.ObjectConstant2);
422 CheckDisjoint(T.ObjectConstant1, T.ArrayConstant1);
423
424 CheckDisjoint(T.ObjectConstant1, T.ObjectClass);
425 CheckDisjoint(T.ObjectConstant2, T.ObjectClass);
426 CheckDisjoint(T.ObjectConstant1, T.ArrayClass);
427 CheckDisjoint(T.ObjectConstant2, T.ArrayClass);
428 CheckDisjoint(T.ArrayConstant1, T.ObjectClass);
429 }
430
431 void Union() {
432 // Bitset-bitset
433 CHECK(this->IsBitset(T.Union(T.Object, T.Number)));
434 CHECK(this->IsBitset(T.Union(T.Object, T.Object)));
435 CHECK(this->IsBitset(T.Union(T.Any, T.None)));
436
437 CheckEqual(T.Union(T.None, T.Number), T.Number);
438 CheckEqual(T.Union(T.Object, T.Proxy), T.Receiver);
439 CheckEqual(T.Union(T.Number, T.String), T.Union(T.String, T.Number));
440 CheckSub(T.Union(T.Number, T.String), T.Any);
441
442 // Class-class
443 CHECK(this->IsClass(T.Union(T.ObjectClass, T.ObjectClass)));
444 CHECK(this->IsUnion(T.Union(T.ObjectClass, T.ArrayClass)));
445
446 CheckEqual(T.Union(T.ObjectClass, T.ObjectClass), T.ObjectClass);
447 CheckSub(T.None, T.Union(T.ObjectClass, T.ArrayClass));
448 CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Any);
449 CheckSub(T.ObjectClass, T.Union(T.ObjectClass, T.ArrayClass));
450 CheckSub(T.ArrayClass, T.Union(T.ObjectClass, T.ArrayClass));
451 CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Object);
452 CheckUnordered(T.Union(T.ObjectClass, T.ArrayClass), T.Array);
453 CheckOverlap(T.Union(T.ObjectClass, T.ArrayClass), T.Array);
454 CheckDisjoint(T.Union(T.ObjectClass, T.ArrayClass), T.Number);
455
456 // Constant-constant
457 CHECK(this->IsConstant(T.Union(T.ObjectConstant1, T.ObjectConstant1)));
458 CHECK(this->IsConstant(T.Union(T.ArrayConstant1, T.ArrayConstant1)));
459 CHECK(this->IsUnion(T.Union(T.ObjectConstant1, T.ObjectConstant2)));
460
461 CheckEqual(
462 T.Union(T.ObjectConstant1, T.ObjectConstant1),
463 T.ObjectConstant1);
464 CheckEqual(T.Union(T.ArrayConstant1, T.ArrayConstant1), T.ArrayConstant1);
465 CheckEqual(T.Union(T.ArrayConstant1, T.ArrayConstant1), T.ArrayConstant2);
466 CheckSub(T.None, T.Union(T.ObjectConstant1, T.ObjectConstant2));
467 CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Any);
468 CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2));
469 CheckSub(T.ObjectConstant2, T.Union(T.ObjectConstant1, T.ObjectConstant2));
470 CheckSub(T.ArrayConstant2, T.Union(T.ArrayConstant1, T.ObjectConstant2));
471 CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Object);
472 CheckUnordered(
473 T.Union(T.ObjectConstant1, T.ObjectConstant2), T.ObjectClass);
474 CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Array);
475 CheckOverlap(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Array);
476 CheckOverlap(
477 T.Union(T.ObjectConstant1, T.ArrayConstant1), T.ArrayConstant2);
478 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Number);
479 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.ObjectClass);
480
481 // Bitset-class
482 CHECK(this->IsBitset(T.Union(T.ObjectClass, T.Object)));
483 CHECK(this->IsUnion(T.Union(T.ObjectClass, T.Number)));
484
485 CheckEqual(T.Union(T.ObjectClass, T.Object), T.Object);
486 CheckSub(T.None, T.Union(T.ObjectClass, T.Number));
487 CheckSub(T.Union(T.ObjectClass, T.Number), T.Any);
488 CheckSub(T.Union(T.ObjectClass, T.Smi), T.Union(T.Object, T.Number));
489 CheckSub(T.Union(T.ObjectClass, T.Array), T.Object);
490 CheckUnordered(T.Union(T.ObjectClass, T.String), T.Array);
491 CheckOverlap(T.Union(T.ObjectClass, T.String), T.Object);
492 CheckDisjoint(T.Union(T.ObjectClass, T.String), T.Number);
493
494 // Bitset-constant
495 CHECK(this->IsBitset(T.Union(T.SmiConstant, T.Number)));
496 CHECK(this->IsBitset(T.Union(T.ObjectConstant1, T.Object)));
497 CHECK(this->IsUnion(T.Union(T.ObjectConstant2, T.Number)));
498
499 CheckEqual(T.Union(T.SmiConstant, T.Number), T.Number);
500 CheckEqual(T.Union(T.ObjectConstant1, T.Object), T.Object);
501 CheckSub(T.None, T.Union(T.ObjectConstant1, T.Number));
502 CheckSub(T.Union(T.ObjectConstant1, T.Number), T.Any);
503 CheckSub(
504 T.Union(T.ObjectConstant1, T.Signed32), T.Union(T.Object, T.Number));
505 CheckSub(T.Union(T.ObjectConstant1, T.Array), T.Object);
506 CheckUnordered(T.Union(T.ObjectConstant1, T.String), T.Array);
507 CheckOverlap(T.Union(T.ObjectConstant1, T.String), T.Object);
508 CheckDisjoint(T.Union(T.ObjectConstant1, T.String), T.Number);
509 CheckEqual(T.Union(T.Signed32, T.Signed32Constant), T.Signed32);
510
511 // Class-constant
512 CHECK(this->IsUnion(T.Union(T.ObjectConstant1, T.ObjectClass)));
513 CHECK(this->IsUnion(T.Union(T.ArrayClass, T.ObjectConstant2)));
514
515 CheckSub(T.None, T.Union(T.ObjectConstant1, T.ArrayClass));
516 CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Any);
517 CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Object);
518 CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ArrayClass));
519 CheckSub(T.ArrayClass, T.Union(T.ObjectConstant1, T.ArrayClass));
520 CheckUnordered(T.ObjectClass, T.Union(T.ObjectConstant1, T.ArrayClass));
521 CheckSub(
522 T.Union(T.ObjectConstant1, T.ArrayClass), T.Union(T.Array, T.Object));
523 CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayClass), T.ArrayConstant1);
524 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayClass), T.ObjectConstant2);
525 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayClass), T.ObjectClass);
526
527 // Bitset-union
528 CHECK(this->IsBitset(
529 T.Union(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass))));
530 CHECK(this->IsUnion(
531 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.Number)));
532
533 CheckEqual(
534 T.Union(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)),
535 T.Object);
536 CheckEqual(
537 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number),
538 T.Union(T.ObjectConstant1, T.Union(T.Number, T.ArrayClass)));
539 CheckSub(
540 T.Double,
541 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number));
542 CheckSub(
543 T.ObjectConstant1,
544 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double));
545 CheckSub(
546 T.None,
547 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double));
548 CheckSub(
549 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double),
550 T.Any);
551 CheckSub(
552 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double),
553 T.Union(T.ObjectConstant1, T.Union(T.Number, T.ArrayClass)));
554
555 // Class-union
556 CHECK(this->IsUnion(
557 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass)));
558 CHECK(this->IsUnion(
559 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ObjectClass)));
560
561 CheckEqual(
562 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
563 T.Union(T.ObjectClass, T.ObjectConstant1));
564 CheckSub(
565 T.None,
566 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)));
567 CheckSub(
568 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
569 T.Any);
570 CheckSub(
571 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
572 T.Object);
573 CheckEqual(
574 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass),
575 T.Union(T.ArrayClass, T.ObjectConstant2));
576
577 // Constant-union
578 CHECK(this->IsUnion(T.Union(
579 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2))));
580 CHECK(this->IsUnion(T.Union(
581 T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1)));
582 CHECK(this->IsUnion(T.Union(
583 T.Union(T.ArrayConstant1, T.ObjectConstant2), T.ObjectConstant1)));
584
585 CheckEqual(
586 T.Union(
587 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)),
588 T.Union(T.ObjectConstant2, T.ObjectConstant1));
589 CheckEqual(
590 T.Union(
591 T.Union(T.ArrayConstant1, T.ObjectConstant2), T.ObjectConstant1),
592 T.Union(
593 T.ObjectConstant2, T.Union(T.ArrayConstant1, T.ObjectConstant1)));
594
595 // Union-union
596 CHECK(this->IsBitset(T.Union(
597 T.Union(T.Number, T.ArrayClass),
598 T.Union(T.Signed32, T.Array))));
599 CHECK(this->IsUnion(T.Union(
600 T.Union(T.Number, T.ArrayClass),
601 T.Union(T.ObjectClass, T.ArrayClass))));
602
603 CheckEqual(
604 T.Union(
605 T.Union(T.ObjectConstant2, T.ObjectConstant1),
606 T.Union(T.ObjectConstant1, T.ObjectConstant2)),
607 T.Union(T.ObjectConstant2, T.ObjectConstant1));
608 CheckEqual(
609 T.Union(
610 T.Union(T.ObjectConstant2, T.ArrayConstant1),
611 T.Union(T.ObjectConstant1, T.ArrayConstant2)),
612 T.Union(
613 T.Union(T.ObjectConstant1, T.ObjectConstant2),
614 T.ArrayConstant1));
615 CheckEqual(
616 T.Union(T.Union(T.Number, T.ArrayClass), T.Union(T.Smi, T.Array)),
617 T.Union(T.Number, T.Array));
618 }
619
620 void Intersect() {
621 // Bitset-bitset
622 CHECK(this->IsBitset(T.Intersect(T.Object, T.Number)));
623 CHECK(this->IsBitset(T.Intersect(T.Object, T.Object)));
624 CHECK(this->IsBitset(T.Intersect(T.Any, T.None)));
625
626 CheckEqual(T.Intersect(T.None, T.Number), T.None);
627 CheckEqual(T.Intersect(T.Object, T.Proxy), T.None);
628 CheckEqual(T.Intersect(T.Name, T.String), T.Intersect(T.String, T.Name));
629 CheckEqual(T.Intersect(T.UniqueName, T.String), T.InternalizedString);
630
631 // Class-class
632 CHECK(this->IsClass(T.Intersect(T.ObjectClass, T.ObjectClass)));
633 CHECK(this->IsBitset(T.Intersect(T.ObjectClass, T.ArrayClass)));
634
635 CheckEqual(T.Intersect(T.ObjectClass, T.ObjectClass), T.ObjectClass);
636 CheckEqual(T.Intersect(T.ObjectClass, T.ArrayClass), T.None);
637
638 // Constant-constant
639 CHECK(this->IsConstant(T.Intersect(T.ObjectConstant1, T.ObjectConstant1)));
640 CHECK(this->IsConstant(T.Intersect(T.ArrayConstant1, T.ArrayConstant2)));
641 CHECK(this->IsBitset(T.Intersect(T.ObjectConstant1, T.ObjectConstant2)));
642
643 CheckEqual(
644 T.Intersect(T.ObjectConstant1, T.ObjectConstant1), T.ObjectConstant1);
645 CheckEqual(
646 T.Intersect(T.ArrayConstant1, T.ArrayConstant2), T.ArrayConstant1);
647 CheckEqual(T.Intersect(T.ObjectConstant1, T.ObjectConstant2), T.None);
648
649 // Bitset-class
650 CHECK(this->IsClass(T.Intersect(T.ObjectClass, T.Object)));
651 CHECK(this->IsBitset(T.Intersect(T.ObjectClass, T.Number)));
652
653 CheckEqual(T.Intersect(T.ObjectClass, T.Object), T.ObjectClass);
654 CheckEqual(T.Intersect(T.ObjectClass, T.Array), T.None);
655 CheckEqual(T.Intersect(T.ObjectClass, T.Number), T.None);
656
657 // Bitset-constant
658 CHECK(this->IsBitset(T.Intersect(T.Smi, T.Number)));
659 CHECK(this->IsConstant(T.Intersect(T.SmiConstant, T.Number)));
660 CHECK(this->IsConstant(T.Intersect(T.ObjectConstant1, T.Object)));
661
662 CheckEqual(T.Intersect(T.Smi, T.Number), T.Smi);
663 CheckEqual(T.Intersect(T.SmiConstant, T.Number), T.SmiConstant);
664 CheckEqual(T.Intersect(T.ObjectConstant1, T.Object), T.ObjectConstant1);
665
666 // Class-constant
667 CHECK(this->IsBitset(T.Intersect(T.ObjectConstant1, T.ObjectClass)));
668 CHECK(this->IsBitset(T.Intersect(T.ArrayClass, T.ObjectConstant2)));
669
670 CheckEqual(T.Intersect(T.ObjectConstant1, T.ObjectClass), T.None);
671 CheckEqual(T.Intersect(T.ArrayClass, T.ObjectConstant2), T.None);
672
673 // Bitset-union
674 CHECK(this->IsUnion(
675 T.Intersect(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass))));
676 CHECK(this->IsBitset(
677 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant2), T.Number)));
678
679 CheckEqual(
680 T.Intersect(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)),
681 T.Union(T.ObjectConstant1, T.ObjectClass));
682 CheckEqual(
683 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number),
684 T.None);
685
686 // Class-union
687 CHECK(this->IsClass(
688 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass)));
689 CHECK(this->IsClass(
690 T.Intersect(T.Union(T.Object, T.SmiConstant), T.ArrayClass)));
691 CHECK(this->IsBitset(
692 T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant1), T.ArrayClass)));
693
694 CheckEqual(
695 T.Intersect(T.ArrayClass, T.Union(T.ObjectConstant2, T.ArrayClass)),
696 T.ArrayClass);
697 CheckEqual(
698 T.Intersect(T.ArrayClass, T.Union(T.Object, T.SmiConstant)),
699 T.ArrayClass);
700 CheckEqual(
701 T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant1), T.ArrayClass),
702 T.None);
703
704 // Constant-union
705 CHECK(this->IsConstant(T.Intersect(
706 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2))));
707 CHECK(this->IsConstant(T.Intersect(
708 T.Union(T.Number, T.ObjectClass), T.SmiConstant)));
709 CHECK(this->IsBitset(T.Intersect(
710 T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1)));
711
712 CheckEqual(
713 T.Intersect(
714 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)),
715 T.ObjectConstant1);
716 CheckEqual(
717 T.Intersect(T.SmiConstant, T.Union(T.Number, T.ObjectConstant2)),
718 T.SmiConstant);
719 CheckEqual(
720 T.Intersect(
721 T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1),
722 T.None);
723
724 // Union-union
725 CHECK(this->IsUnion(T.Intersect(
726 T.Union(T.Number, T.ArrayClass), T.Union(T.Signed32, T.Array))));
727 CHECK(this->IsBitset(T.Intersect(
728 T.Union(T.Number, T.ObjectClass), T.Union(T.Signed32, T.Array))));
729
730 CheckEqual(
731 T.Intersect(
732 T.Union(T.Number, T.ArrayClass),
733 T.Union(T.Smi, T.Array)),
734 T.Union(T.Smi, T.ArrayClass));
735 CheckEqual(
736 T.Intersect(
737 T.Union(T.Number, T.ObjectClass),
738 T.Union(T.Signed32, T.Array)),
739 T.Signed32);
740 CheckEqual(
741 T.Intersect(
742 T.Union(T.ObjectConstant2, T.ObjectConstant1),
743 T.Union(T.ObjectConstant1, T.ObjectConstant2)),
744 T.Union(T.ObjectConstant2, T.ObjectConstant1));
745 CheckEqual(
746 T.Intersect(
747 T.Union(
748 T.Union(T.ObjectConstant2, T.ObjectConstant1), T.ArrayClass),
749 T.Union(
750 T.ObjectConstant1,
751 T.Union(T.ArrayConstant1, T.ObjectConstant2))),
752 T.Union(T.ObjectConstant2, T.ObjectConstant1));
753 CheckEqual(
754 T.Intersect(
755 T.Union(T.ObjectConstant2, T.ArrayConstant1),
756 T.Union(T.ObjectConstant1, T.ArrayConstant2)),
757 T.ArrayConstant1);
758 }
759 };
760
761 typedef Tests<Type, Type*, Zone, ZoneRep> ZoneTests;
762 typedef Tests<HeapType, Handle<HeapType>, Isolate, HeapRep> HeapTests;
763
764
197 TEST(Bitset) { 765 TEST(Bitset) {
198 CcTest::InitializeVM(); 766 CcTest::InitializeVM();
199 Isolate* isolate = CcTest::i_isolate(); 767 ZoneTests().Bitset();
200 HandleScope scope(isolate); 768 HeapTests().Bitset();
201 HandlifiedTypes T(isolate);
202
203 CHECK(IsBitset(T.None));
204 CHECK(IsBitset(T.Any));
205 CHECK(IsBitset(T.String));
206 CHECK(IsBitset(T.Object));
207
208 CHECK(IsBitset(T.Union(T.String, T.Number)));
209 CHECK(IsBitset(T.Union(T.String, T.Receiver)));
210
211 CHECK_EQ(0, AsBitset(T.None));
212 CHECK_EQ(AsBitset(T.Number) | AsBitset(T.String),
213 AsBitset(T.Union(T.String, T.Number)));
214 CHECK_EQ(AsBitset(T.Receiver),
215 AsBitset(T.Union(T.Receiver, T.Object)));
216 } 769 }
217 770
218 771
219 TEST(Class) { 772 TEST(Class) {
220 CcTest::InitializeVM(); 773 CcTest::InitializeVM();
221 Isolate* isolate = CcTest::i_isolate(); 774 ZoneTests().Class();
222 HandleScope scope(isolate); 775 HeapTests().Class();
223 HandlifiedTypes T(isolate);
224
225 CHECK(IsClass(T.ObjectClass));
226 CHECK(IsClass(T.ArrayClass));
227
228 CHECK(*T.object_map == AsClass(T.ObjectClass));
229 CHECK(*T.array_map == AsClass(T.ArrayClass));
230 } 776 }
231 777
232 778
233 TEST(Constant) { 779 TEST(Constant) {
234 CcTest::InitializeVM(); 780 CcTest::InitializeVM();
235 Isolate* isolate = CcTest::i_isolate(); 781 ZoneTests().Constant();
236 HandleScope scope(isolate); 782 HeapTests().Constant();
237 HandlifiedTypes T(isolate);
238
239 CHECK(IsConstant(T.SmiConstant));
240 CHECK(IsConstant(T.ObjectConstant1));
241 CHECK(IsConstant(T.ObjectConstant2));
242 CHECK(IsConstant(T.ArrayConstant1));
243 CHECK(IsConstant(T.ArrayConstant2));
244
245 CHECK(*T.smi == AsConstant(T.SmiConstant));
246 CHECK(*T.object1 == AsConstant(T.ObjectConstant1));
247 CHECK(*T.object2 == AsConstant(T.ObjectConstant2));
248 CHECK(*T.object1 != AsConstant(T.ObjectConstant2));
249 CHECK(*T.array == AsConstant(T.ArrayConstant1));
250 CHECK(*T.array == AsConstant(T.ArrayConstant2));
251 } 783 }
252 784
253 785
254 TEST(Is) { 786 TEST(Is) {
255 CcTest::InitializeVM(); 787 CcTest::InitializeVM();
256 Isolate* isolate = CcTest::i_isolate(); 788 ZoneTests().Is();
257 HandleScope scope(isolate); 789 HeapTests().Is();
258 HandlifiedTypes T(isolate);
259
260 // Reflexivity
261 CHECK(T.None->Is(T.None));
262 CHECK(T.Any->Is(T.Any));
263 CHECK(T.Object->Is(T.Object));
264
265 CHECK(T.ObjectClass->Is(T.ObjectClass));
266 CHECK(T.ObjectConstant1->Is(T.ObjectConstant1));
267 CHECK(T.ArrayConstant1->Is(T.ArrayConstant2));
268
269 // Symmetry and Transitivity
270 CheckSub(T.None, T.Number);
271 CheckSub(T.None, T.Any);
272
273 CheckSub(T.Oddball, T.Any);
274 CheckSub(T.Boolean, T.Oddball);
275 CheckSub(T.Null, T.Oddball);
276 CheckSub(T.Undefined, T.Oddball);
277 CheckUnordered(T.Boolean, T.Null);
278 CheckUnordered(T.Undefined, T.Null);
279 CheckUnordered(T.Boolean, T.Undefined);
280
281 CheckSub(T.Number, T.Any);
282 CheckSub(T.Smi, T.Number);
283 CheckSub(T.Signed32, T.Number);
284 CheckSub(T.Double, T.Number);
285 CheckSub(T.Smi, T.Signed32);
286 CheckUnordered(T.Smi, T.Double);
287 CheckUnordered(T.Signed32, T.Double);
288
289 CheckSub(T.Name, T.Any);
290 CheckSub(T.UniqueName, T.Any);
291 CheckSub(T.UniqueName, T.Name);
292 CheckSub(T.String, T.Name);
293 CheckSub(T.InternalizedString, T.String);
294 CheckSub(T.InternalizedString, T.UniqueName);
295 CheckSub(T.InternalizedString, T.Name);
296 CheckSub(T.Symbol, T.UniqueName);
297 CheckSub(T.Symbol, T.Name);
298 CheckUnordered(T.String, T.UniqueName);
299 CheckUnordered(T.String, T.Symbol);
300 CheckUnordered(T.InternalizedString, T.Symbol);
301
302 CheckSub(T.Receiver, T.Any);
303 CheckSub(T.Object, T.Any);
304 CheckSub(T.Object, T.Receiver);
305 CheckSub(T.Array, T.Object);
306 CheckSub(T.Function, T.Object);
307 CheckSub(T.Proxy, T.Receiver);
308 CheckUnordered(T.Object, T.Proxy);
309 CheckUnordered(T.Array, T.Function);
310
311 // Structured subtyping
312 CheckSub(T.None, T.ObjectClass);
313 CheckSub(T.None, T.ObjectConstant1);
314 CheckSub(T.ObjectClass, T.Any);
315 CheckSub(T.ObjectConstant1, T.Any);
316
317 CheckSub(T.ObjectClass, T.Object);
318 CheckSub(T.ArrayClass, T.Object);
319 CheckUnordered(T.ObjectClass, T.ArrayClass);
320
321 CheckSub(T.SmiConstant, T.Smi);
322 CheckSub(T.SmiConstant, T.Signed32);
323 CheckSub(T.SmiConstant, T.Number);
324 CheckSub(T.ObjectConstant1, T.Object);
325 CheckSub(T.ObjectConstant2, T.Object);
326 CheckSub(T.ArrayConstant1, T.Object);
327 CheckSub(T.ArrayConstant1, T.Array);
328 CheckUnordered(T.ObjectConstant1, T.ObjectConstant2);
329 CheckUnordered(T.ObjectConstant1, T.ArrayConstant1);
330
331 CheckUnordered(T.ObjectConstant1, T.ObjectClass);
332 CheckUnordered(T.ObjectConstant2, T.ObjectClass);
333 CheckUnordered(T.ObjectConstant1, T.ArrayClass);
334 CheckUnordered(T.ObjectConstant2, T.ArrayClass);
335 CheckUnordered(T.ArrayConstant1, T.ObjectClass);
336 } 790 }
337 791
338 792
339 TEST(Maybe) { 793 TEST(Maybe) {
340 CcTest::InitializeVM(); 794 CcTest::InitializeVM();
341 Isolate* isolate = CcTest::i_isolate(); 795 ZoneTests().Maybe();
342 HandleScope scope(isolate); 796 HeapTests().Maybe();
343 HandlifiedTypes T(isolate);
344
345 CheckOverlap(T.Any, T.Any);
346 CheckOverlap(T.Object, T.Object);
347
348 CheckOverlap(T.Oddball, T.Any);
349 CheckOverlap(T.Boolean, T.Oddball);
350 CheckOverlap(T.Null, T.Oddball);
351 CheckOverlap(T.Undefined, T.Oddball);
352 CheckDisjoint(T.Boolean, T.Null);
353 CheckDisjoint(T.Undefined, T.Null);
354 CheckDisjoint(T.Boolean, T.Undefined);
355
356 CheckOverlap(T.Number, T.Any);
357 CheckOverlap(T.Smi, T.Number);
358 CheckOverlap(T.Double, T.Number);
359 CheckDisjoint(T.Signed32, T.Double);
360
361 CheckOverlap(T.Name, T.Any);
362 CheckOverlap(T.UniqueName, T.Any);
363 CheckOverlap(T.UniqueName, T.Name);
364 CheckOverlap(T.String, T.Name);
365 CheckOverlap(T.InternalizedString, T.String);
366 CheckOverlap(T.InternalizedString, T.UniqueName);
367 CheckOverlap(T.InternalizedString, T.Name);
368 CheckOverlap(T.Symbol, T.UniqueName);
369 CheckOverlap(T.Symbol, T.Name);
370 CheckOverlap(T.String, T.UniqueName);
371 CheckDisjoint(T.String, T.Symbol);
372 CheckDisjoint(T.InternalizedString, T.Symbol);
373
374 CheckOverlap(T.Receiver, T.Any);
375 CheckOverlap(T.Object, T.Any);
376 CheckOverlap(T.Object, T.Receiver);
377 CheckOverlap(T.Array, T.Object);
378 CheckOverlap(T.Function, T.Object);
379 CheckOverlap(T.Proxy, T.Receiver);
380 CheckDisjoint(T.Object, T.Proxy);
381 CheckDisjoint(T.Array, T.Function);
382
383 CheckOverlap(T.ObjectClass, T.Any);
384 CheckOverlap(T.ObjectConstant1, T.Any);
385
386 CheckOverlap(T.ObjectClass, T.Object);
387 CheckOverlap(T.ArrayClass, T.Object);
388 CheckOverlap(T.ObjectClass, T.ObjectClass);
389 CheckOverlap(T.ArrayClass, T.ArrayClass);
390 CheckDisjoint(T.ObjectClass, T.ArrayClass);
391
392 CheckOverlap(T.SmiConstant, T.Smi);
393 CheckOverlap(T.SmiConstant, T.Signed32);
394 CheckOverlap(T.SmiConstant, T.Number);
395 CheckDisjoint(T.SmiConstant, T.Double);
396 CheckOverlap(T.ObjectConstant1, T.Object);
397 CheckOverlap(T.ObjectConstant2, T.Object);
398 CheckOverlap(T.ArrayConstant1, T.Object);
399 CheckOverlap(T.ArrayConstant1, T.Array);
400 CheckOverlap(T.ArrayConstant1, T.ArrayConstant2);
401 CheckOverlap(T.ObjectConstant1, T.ObjectConstant1);
402 CheckDisjoint(T.ObjectConstant1, T.ObjectConstant2);
403 CheckDisjoint(T.ObjectConstant1, T.ArrayConstant1);
404
405 CheckDisjoint(T.ObjectConstant1, T.ObjectClass);
406 CheckDisjoint(T.ObjectConstant2, T.ObjectClass);
407 CheckDisjoint(T.ObjectConstant1, T.ArrayClass);
408 CheckDisjoint(T.ObjectConstant2, T.ArrayClass);
409 CheckDisjoint(T.ArrayConstant1, T.ObjectClass);
410 } 797 }
411 798
412 799
413 TEST(Union) { 800 TEST(Union) {
414 CcTest::InitializeVM(); 801 CcTest::InitializeVM();
415 Isolate* isolate = CcTest::i_isolate(); 802 ZoneTests().Union();
416 HandleScope scope(isolate); 803 HeapTests().Union();
417 HandlifiedTypes T(isolate);
418
419 // Bitset-bitset
420 CHECK(IsBitset(T.Union(T.Object, T.Number)));
421 CHECK(IsBitset(T.Union(T.Object, T.Object)));
422 CHECK(IsBitset(T.Union(T.Any, T.None)));
423
424 CheckEqual(T.Union(T.None, T.Number), T.Number);
425 CheckEqual(T.Union(T.Object, T.Proxy), T.Receiver);
426 CheckEqual(T.Union(T.Number, T.String), T.Union(T.String, T.Number));
427 CheckSub(T.Union(T.Number, T.String), T.Any);
428
429 // Class-class
430 CHECK(IsClass(T.Union(T.ObjectClass, T.ObjectClass)));
431 CHECK(IsUnion(T.Union(T.ObjectClass, T.ArrayClass)));
432
433 CheckEqual(T.Union(T.ObjectClass, T.ObjectClass), T.ObjectClass);
434 CheckSub(T.None, T.Union(T.ObjectClass, T.ArrayClass));
435 CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Any);
436 CheckSub(T.ObjectClass, T.Union(T.ObjectClass, T.ArrayClass));
437 CheckSub(T.ArrayClass, T.Union(T.ObjectClass, T.ArrayClass));
438 CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Object);
439 CheckUnordered(T.Union(T.ObjectClass, T.ArrayClass), T.Array);
440 CheckOverlap(T.Union(T.ObjectClass, T.ArrayClass), T.Array);
441 CheckDisjoint(T.Union(T.ObjectClass, T.ArrayClass), T.Number);
442
443 // Constant-constant
444 CHECK(IsConstant(T.Union(T.ObjectConstant1, T.ObjectConstant1)));
445 CHECK(IsConstant(T.Union(T.ArrayConstant1, T.ArrayConstant1)));
446 CHECK(IsUnion(T.Union(T.ObjectConstant1, T.ObjectConstant2)));
447
448 CheckEqual(T.Union(T.ObjectConstant1, T.ObjectConstant1), T.ObjectConstant1);
449 CheckEqual(T.Union(T.ArrayConstant1, T.ArrayConstant1), T.ArrayConstant1);
450 CheckEqual(T.Union(T.ArrayConstant1, T.ArrayConstant1), T.ArrayConstant2);
451 CheckSub(T.None, T.Union(T.ObjectConstant1, T.ObjectConstant2));
452 CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Any);
453 CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2));
454 CheckSub(T.ObjectConstant2, T.Union(T.ObjectConstant1, T.ObjectConstant2));
455 CheckSub(T.ArrayConstant2, T.Union(T.ArrayConstant1, T.ObjectConstant2));
456 CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Object);
457 CheckUnordered(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.ObjectClass);
458 CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Array);
459 CheckOverlap(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Array);
460 CheckOverlap(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.ArrayConstant2);
461 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Number);
462 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.ObjectClass);
463
464 // Bitset-class
465 CHECK(IsBitset(T.Union(T.ObjectClass, T.Object)));
466 CHECK(IsUnion(T.Union(T.ObjectClass, T.Number)));
467
468 CheckEqual(T.Union(T.ObjectClass, T.Object), T.Object);
469 CheckSub(T.None, T.Union(T.ObjectClass, T.Number));
470 CheckSub(T.Union(T.ObjectClass, T.Number), T.Any);
471 CheckSub(T.Union(T.ObjectClass, T.Smi), T.Union(T.Object, T.Number));
472 CheckSub(T.Union(T.ObjectClass, T.Array), T.Object);
473 CheckUnordered(T.Union(T.ObjectClass, T.String), T.Array);
474 CheckOverlap(T.Union(T.ObjectClass, T.String), T.Object);
475 CheckDisjoint(T.Union(T.ObjectClass, T.String), T.Number);
476
477 // Bitset-constant
478 CHECK(IsBitset(T.Union(T.SmiConstant, T.Number)));
479 CHECK(IsBitset(T.Union(T.ObjectConstant1, T.Object)));
480 CHECK(IsUnion(T.Union(T.ObjectConstant2, T.Number)));
481
482 CheckEqual(T.Union(T.SmiConstant, T.Number), T.Number);
483 CheckEqual(T.Union(T.ObjectConstant1, T.Object), T.Object);
484 CheckSub(T.None, T.Union(T.ObjectConstant1, T.Number));
485 CheckSub(T.Union(T.ObjectConstant1, T.Number), T.Any);
486 CheckSub(T.Union(T.ObjectConstant1, T.Signed32), T.Union(T.Object, T.Number));
487 CheckSub(T.Union(T.ObjectConstant1, T.Array), T.Object);
488 CheckUnordered(T.Union(T.ObjectConstant1, T.String), T.Array);
489 CheckOverlap(T.Union(T.ObjectConstant1, T.String), T.Object);
490 CheckDisjoint(T.Union(T.ObjectConstant1, T.String), T.Number);
491 CheckEqual(T.Union(T.Signed32, T.Signed32Constant), T.Signed32);
492
493 // Class-constant
494 CHECK(IsUnion(T.Union(T.ObjectConstant1, T.ObjectClass)));
495 CHECK(IsUnion(T.Union(T.ArrayClass, T.ObjectConstant2)));
496
497 CheckSub(T.None, T.Union(T.ObjectConstant1, T.ArrayClass));
498 CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Any);
499 CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Object);
500 CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ArrayClass));
501 CheckSub(T.ArrayClass, T.Union(T.ObjectConstant1, T.ArrayClass));
502 CheckUnordered(T.ObjectClass, T.Union(T.ObjectConstant1, T.ArrayClass));
503 CheckSub(
504 T.Union(T.ObjectConstant1, T.ArrayClass), T.Union(T.Array, T.Object));
505 CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayClass), T.ArrayConstant1);
506 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayClass), T.ObjectConstant2);
507 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayClass), T.ObjectClass);
508
509 // Bitset-union
510 CHECK(IsBitset(T.Union(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass))));
511 CHECK(IsUnion(T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.Number)));
512
513 CheckEqual(
514 T.Union(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)),
515 T.Object);
516 CheckEqual(
517 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number),
518 T.Union(T.ObjectConstant1, T.Union(T.Number, T.ArrayClass)));
519 CheckSub(
520 T.Double,
521 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number));
522 CheckSub(
523 T.ObjectConstant1,
524 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double));
525 CheckSub(
526 T.None,
527 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double));
528 CheckSub(
529 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double),
530 T.Any);
531 CheckSub(
532 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double),
533 T.Union(T.ObjectConstant1, T.Union(T.Number, T.ArrayClass)));
534
535 // Class-union
536 CHECK(IsUnion(
537 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass)));
538 CHECK(IsUnion(
539 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ObjectClass)));
540
541 CheckEqual(
542 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
543 T.Union(T.ObjectClass, T.ObjectConstant1));
544 CheckSub(
545 T.None,
546 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)));
547 CheckSub(
548 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
549 T.Any);
550 CheckSub(
551 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
552 T.Object);
553 CheckEqual(
554 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass),
555 T.Union(T.ArrayClass, T.ObjectConstant2));
556
557 // Constant-union
558 CHECK(IsUnion(T.Union(
559 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2))));
560 CHECK(IsUnion(T.Union(
561 T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1)));
562 CHECK(IsUnion(T.Union(
563 T.Union(T.ArrayConstant1, T.ObjectConstant2), T.ObjectConstant1)));
564
565 CheckEqual(
566 T.Union(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)),
567 T.Union(T.ObjectConstant2, T.ObjectConstant1));
568 CheckEqual(
569 T.Union(T.Union(T.ArrayConstant1, T.ObjectConstant2), T.ObjectConstant1),
570 T.Union(T.ObjectConstant2, T.Union(T.ArrayConstant1, T.ObjectConstant1)));
571
572 // Union-union
573 CHECK(IsBitset(T.Union(
574 T.Union(T.Number, T.ArrayClass), T.Union(T.Signed32, T.Array))));
575 CHECK(IsUnion(T.Union(
576 T.Union(T.Number, T.ArrayClass), T.Union(T.ObjectClass, T.ArrayClass))));
577
578 CheckEqual(
579 T.Union(
580 T.Union(T.ObjectConstant2, T.ObjectConstant1),
581 T.Union(T.ObjectConstant1, T.ObjectConstant2)),
582 T.Union(T.ObjectConstant2, T.ObjectConstant1));
583 CheckEqual(
584 T.Union(
585 T.Union(T.ObjectConstant2, T.ArrayConstant1),
586 T.Union(T.ObjectConstant1, T.ArrayConstant2)),
587 T.Union(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.ArrayConstant1));
588 CheckEqual(
589 T.Union(T.Union(T.Number, T.ArrayClass), T.Union(T.Smi, T.Array)),
590 T.Union(T.Number, T.Array));
591 } 804 }
592 805
593 806
594 TEST(Intersect) { 807 TEST(Intersect) {
595 CcTest::InitializeVM(); 808 CcTest::InitializeVM();
596 Isolate* isolate = CcTest::i_isolate(); 809 ZoneTests().Intersect();
597 HandleScope scope(isolate); 810 HeapTests().Intersect();
598 HandlifiedTypes T(isolate);
599
600 // Bitset-bitset
601 CHECK(IsBitset(T.Intersect(T.Object, T.Number)));
602 CHECK(IsBitset(T.Intersect(T.Object, T.Object)));
603 CHECK(IsBitset(T.Intersect(T.Any, T.None)));
604
605 CheckEqual(T.Intersect(T.None, T.Number), T.None);
606 CheckEqual(T.Intersect(T.Object, T.Proxy), T.None);
607 CheckEqual(T.Intersect(T.Name, T.String), T.Intersect(T.String, T.Name));
608 CheckEqual(T.Intersect(T.UniqueName, T.String), T.InternalizedString);
609
610 // Class-class
611 CHECK(IsClass(T.Intersect(T.ObjectClass, T.ObjectClass)));
612 CHECK(IsBitset(T.Intersect(T.ObjectClass, T.ArrayClass)));
613
614 CheckEqual(T.Intersect(T.ObjectClass, T.ObjectClass), T.ObjectClass);
615 CheckEqual(T.Intersect(T.ObjectClass, T.ArrayClass), T.None);
616
617 // Constant-constant
618 CHECK(IsConstant(T.Intersect(T.ObjectConstant1, T.ObjectConstant1)));
619 CHECK(IsConstant(T.Intersect(T.ArrayConstant1, T.ArrayConstant2)));
620 CHECK(IsBitset(T.Intersect(T.ObjectConstant1, T.ObjectConstant2)));
621
622 CheckEqual(
623 T.Intersect(T.ObjectConstant1, T.ObjectConstant1), T.ObjectConstant1);
624 CheckEqual(
625 T.Intersect(T.ArrayConstant1, T.ArrayConstant2), T.ArrayConstant1);
626 CheckEqual(T.Intersect(T.ObjectConstant1, T.ObjectConstant2), T.None);
627
628 // Bitset-class
629 CHECK(IsClass(T.Intersect(T.ObjectClass, T.Object)));
630 CHECK(IsBitset(T.Intersect(T.ObjectClass, T.Number)));
631
632 CheckEqual(T.Intersect(T.ObjectClass, T.Object), T.ObjectClass);
633 CheckEqual(T.Intersect(T.ObjectClass, T.Array), T.None);
634 CheckEqual(T.Intersect(T.ObjectClass, T.Number), T.None);
635
636 // Bitset-constant
637 CHECK(IsBitset(T.Intersect(T.Smi, T.Number)));
638 CHECK(IsConstant(T.Intersect(T.SmiConstant, T.Number)));
639 CHECK(IsConstant(T.Intersect(T.ObjectConstant1, T.Object)));
640
641 CheckEqual(T.Intersect(T.Smi, T.Number), T.Smi);
642 CheckEqual(T.Intersect(T.SmiConstant, T.Number), T.SmiConstant);
643 CheckEqual(T.Intersect(T.ObjectConstant1, T.Object), T.ObjectConstant1);
644
645 // Class-constant
646 CHECK(IsBitset(T.Intersect(T.ObjectConstant1, T.ObjectClass)));
647 CHECK(IsBitset(T.Intersect(T.ArrayClass, T.ObjectConstant2)));
648
649 CheckEqual(T.Intersect(T.ObjectConstant1, T.ObjectClass), T.None);
650 CheckEqual(T.Intersect(T.ArrayClass, T.ObjectConstant2), T.None);
651
652 // Bitset-union
653 CHECK(IsUnion(
654 T.Intersect(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass))));
655 CHECK(IsBitset(
656 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant2), T.Number)));
657
658 CheckEqual(
659 T.Intersect(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)),
660 T.Union(T.ObjectConstant1, T.ObjectClass));
661 CheckEqual(
662 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number),
663 T.None);
664
665 // Class-union
666 CHECK(IsClass(
667 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass)));
668 CHECK(IsClass(
669 T.Intersect(T.Union(T.Object, T.SmiConstant), T.ArrayClass)));
670 CHECK(IsBitset(
671 T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant1), T.ArrayClass)));
672
673 CheckEqual(
674 T.Intersect(T.ArrayClass, T.Union(T.ObjectConstant2, T.ArrayClass)),
675 T.ArrayClass);
676 CheckEqual(
677 T.Intersect(T.ArrayClass, T.Union(T.Object, T.SmiConstant)),
678 T.ArrayClass);
679 CheckEqual(
680 T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant1), T.ArrayClass),
681 T.None);
682
683 // Constant-union
684 CHECK(IsConstant(T.Intersect(
685 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2))));
686 CHECK(IsConstant(T.Intersect(
687 T.Union(T.Number, T.ObjectClass), T.SmiConstant)));
688 CHECK(IsBitset(T.Intersect(
689 T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1)));
690
691 CheckEqual(
692 T.Intersect(
693 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)),
694 T.ObjectConstant1);
695 CheckEqual(
696 T.Intersect(T.SmiConstant, T.Union(T.Number, T.ObjectConstant2)),
697 T.SmiConstant);
698 CheckEqual(
699 T.Intersect(T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1),
700 T.None);
701
702 // Union-union
703 CHECK(IsUnion(T.Intersect(
704 T.Union(T.Number, T.ArrayClass), T.Union(T.Signed32, T.Array))));
705 CHECK(IsBitset(T.Intersect(
706 T.Union(T.Number, T.ObjectClass), T.Union(T.Signed32, T.Array))));
707
708 CheckEqual(
709 T.Intersect(
710 T.Union(T.Number, T.ArrayClass),
711 T.Union(T.Smi, T.Array)),
712 T.Union(T.Smi, T.ArrayClass));
713 CheckEqual(
714 T.Intersect(
715 T.Union(T.Number, T.ObjectClass),
716 T.Union(T.Signed32, T.Array)),
717 T.Signed32);
718 CheckEqual(
719 T.Intersect(
720 T.Union(T.ObjectConstant2, T.ObjectConstant1),
721 T.Union(T.ObjectConstant1, T.ObjectConstant2)),
722 T.Union(T.ObjectConstant2, T.ObjectConstant1));
723 CheckEqual(
724 T.Intersect(
725 T.Union(T.Union(T.ObjectConstant2, T.ObjectConstant1), T.ArrayClass),
726 T.Union(
727 T.ObjectConstant1, T.Union(T.ArrayConstant1, T.ObjectConstant2))),
728 T.Union(T.ObjectConstant2, T.ObjectConstant1));
729 CheckEqual(
730 T.Intersect(
731 T.Union(T.ObjectConstant2, T.ArrayConstant1),
732 T.Union(T.ObjectConstant1, T.ArrayConstant2)),
733 T.ArrayConstant1);
734 } 811 }
OLDNEW
« no previous file with comments | « test/cctest/test-profile-generator.cc ('k') | test/cctest/trace-extension.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698