1b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Copyright 2014 the V8 project authors. All rights reserved. 2b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Use of this source code is governed by a BSD-style license that can be 3b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// found in the LICENSE file. 4b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 5b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#ifndef V8_TYPES_H_ 6b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#define V8_TYPES_H_ 7b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 8b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#include "src/conversions.h" 9b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#include "src/factory.h" 10b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#include "src/handles.h" 11b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#include "src/ostreams.h" 12b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 13b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochnamespace v8 { 14b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochnamespace internal { 15b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 16b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// SUMMARY 17b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 18b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// A simple type system for compiler-internal use. It is based entirely on 19b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// union types, and all subtyping hence amounts to set inclusion. Besides the 20b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// obvious primitive types and some predefined unions, the type language also 21b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// can express class types (a.k.a. specific maps) and singleton types (i.e., 22b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// concrete constants). 23b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 24b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Types consist of two dimensions: semantic (value range) and representation. 25b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Both are related through subtyping. 26b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 27b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 28b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// SEMANTIC DIMENSION 29b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 30b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// The following equations and inequations hold for the semantic axis: 31b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 32b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// None <= T 33b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// T <= Any 34b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 35b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Number = Signed32 \/ Unsigned32 \/ Double 36b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Smi <= Signed32 37b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Name = String \/ Symbol 38b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// UniqueName = InternalizedString \/ Symbol 39b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// InternalizedString < String 40b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 41b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Receiver = Object \/ Proxy 42b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Array < Object 43b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Function < Object 44b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// RegExp < Object 45b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Undetectable < Object 46b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Detectable = Receiver \/ Number \/ Name - Undetectable 47b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 48b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Class(map) < T iff instance_type(map) < T 49b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Constant(x) < T iff instance_type(map(x)) < T 50b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Array(T) < Array 51b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Function(R, S, T0, T1, ...) < Function 52b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Context(T) < Internal 53b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 54b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Both structural Array and Function types are invariant in all parameters; 55b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// relaxing this would make Union and Intersect operations more involved. 56b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// There is no subtyping relation between Array, Function, or Context types 57b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// and respective Constant types, since these types cannot be reconstructed 58b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// for arbitrary heap values. 59b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Note also that Constant(x) < Class(map(x)) does _not_ hold, since x's map can 60b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// change! (Its instance type cannot, however.) 61b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// TODO(rossberg): the latter is not currently true for proxies, because of fix, 62b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// but will hold once we implement direct proxies. 63b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// However, we also define a 'temporal' variant of the subtyping relation that 64b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// considers the _current_ state only, i.e., Constant(x) <_now Class(map(x)). 65b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 66b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 67b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// REPRESENTATIONAL DIMENSION 68b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 69b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// For the representation axis, the following holds: 70b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 71b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// None <= R 72b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// R <= Any 73b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 74b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// UntaggedInt = UntaggedInt1 \/ UntaggedInt8 \/ 75b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// UntaggedInt16 \/ UntaggedInt32 76b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// UntaggedFloat = UntaggedFloat32 \/ UntaggedFloat64 77b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// UntaggedNumber = UntaggedInt \/ UntaggedFloat 78b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Untagged = UntaggedNumber \/ UntaggedPtr 79b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Tagged = TaggedInt \/ TaggedPtr 80b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 81b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Subtyping relates the two dimensions, for example: 82b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 83b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Number <= Tagged \/ UntaggedNumber 84b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Object <= TaggedPtr \/ UntaggedPtr 85b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 86b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// That holds because the semantic type constructors defined by the API create 87b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// types that allow for all possible representations, and dually, the ones for 88b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// representation types initially include all semantic ranges. Representations 89b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// can then e.g. be narrowed for a given semantic type using intersection: 90b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 91b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// SignedSmall /\ TaggedInt (a 'smi') 92b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Number /\ TaggedPtr (a heap number) 93b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 94b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 95b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// RANGE TYPES 96b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 97b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// A range type represents a continuous integer interval by its minimum and 98b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// maximum value. Either value might be an infinity. 99b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 100b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Constant(v) is considered a subtype of Range(x..y) if v happens to be an 101b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// integer between x and y. 102b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 103b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 104b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// PREDICATES 105b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 106b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// There are two main functions for testing types: 107b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 108b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// T1->Is(T2) -- tests whether T1 is included in T2 (i.e., T1 <= T2) 109b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// T1->Maybe(T2) -- tests whether T1 and T2 overlap (i.e., T1 /\ T2 =/= 0) 110b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 111b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Typically, the former is to be used to select representations (e.g., via 112b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// T->Is(SignedSmall())), and the latter to check whether a specific case needs 113b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// handling (e.g., via T->Maybe(Number())). 114b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 115b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// There is no functionality to discover whether a type is a leaf in the 116b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// lattice. That is intentional. It should always be possible to refine the 117b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// lattice (e.g., splitting up number types further) without invalidating any 118b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// existing assumptions or tests. 119b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Consequently, do not normally use Equals for type tests, always use Is! 120b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 121b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// The NowIs operator implements state-sensitive subtying, as described above. 122b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Any compilation decision based on such temporary properties requires runtime 123b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// guarding! 124b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 125b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 126b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// PROPERTIES 127b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 128b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Various formal properties hold for constructors, operators, and predicates 129b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// over types. For example, constructors are injective and subtyping is a 130b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// complete partial order. 131b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 132b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// See test/cctest/test-types.cc for a comprehensive executable specification, 133b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// especially with respect to the properties of the more exotic 'temporal' 134b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// constructors and predicates (those prefixed 'Now'). 135b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 136b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 137b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// IMPLEMENTATION 138b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 139b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Internally, all 'primitive' types, and their unions, are represented as 140b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// bitsets. Bit 0 is reserved for tagging. Class is a heap pointer to the 141b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// respective map. Only structured types require allocation. 142b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Note that the bitset representation is closed under both Union and Intersect. 143b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 144b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// There are two type representations, using different allocation: 145b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 146b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// - class Type (zone-allocated, for compiler and concurrent compilation) 147b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// - class HeapType (heap-allocated, for persistent types) 148b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// 149b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Both provide the same API, and the Convert method can be used to interconvert 150b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// them. For zone types, no query method touches the heap, only constructors do. 151b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 152b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 153b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 154b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Values for bitset types 155b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 156b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#define MASK_BITSET_TYPE_LIST(V) \ 157b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Representation, 0xff800000u) \ 158b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Semantic, 0x007ffffeu) 159b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 160b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#define REPRESENTATION(k) ((k) & BitsetType::kRepresentation) 161b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#define SEMANTIC(k) ((k) & BitsetType::kSemantic) 162b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 163b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#define REPRESENTATION_BITSET_TYPE_LIST(V) \ 164b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(None, 0) \ 165b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UntaggedInt1, 1u << 23 | kSemantic) \ 166b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UntaggedInt8, 1u << 24 | kSemantic) \ 167b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UntaggedInt16, 1u << 25 | kSemantic) \ 168b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UntaggedInt32, 1u << 26 | kSemantic) \ 169b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UntaggedFloat32, 1u << 27 | kSemantic) \ 170b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UntaggedFloat64, 1u << 28 | kSemantic) \ 171b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UntaggedPtr, 1u << 29 | kSemantic) \ 172b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(TaggedInt, 1u << 30 | kSemantic) \ 173b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(TaggedPtr, 1u << 31 | kSemantic) \ 174b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch \ 175b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UntaggedInt, kUntaggedInt1 | kUntaggedInt8 | \ 176b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch kUntaggedInt16 | kUntaggedInt32) \ 177b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UntaggedFloat, kUntaggedFloat32 | kUntaggedFloat64) \ 178b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UntaggedNumber, kUntaggedInt | kUntaggedFloat) \ 179b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Untagged, kUntaggedNumber | kUntaggedPtr) \ 180b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Tagged, kTaggedInt | kTaggedPtr) 181b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 182b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#define SEMANTIC_BITSET_TYPE_LIST(V) \ 183b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Null, 1u << 1 | REPRESENTATION(kTaggedPtr)) \ 184b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Undefined, 1u << 2 | REPRESENTATION(kTaggedPtr)) \ 185b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Boolean, 1u << 3 | REPRESENTATION(kTaggedPtr)) \ 186b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UnsignedSmall, 1u << 4 | REPRESENTATION(kTagged | kUntaggedNumber)) \ 187b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(OtherSignedSmall, 1u << 5 | REPRESENTATION(kTagged | kUntaggedNumber)) \ 188b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(OtherUnsigned31, 1u << 6 | REPRESENTATION(kTagged | kUntaggedNumber)) \ 189b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(OtherUnsigned32, 1u << 7 | REPRESENTATION(kTagged | kUntaggedNumber)) \ 190b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(OtherSigned32, 1u << 8 | REPRESENTATION(kTagged | kUntaggedNumber)) \ 191b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(MinusZero, 1u << 9 | REPRESENTATION(kTagged | kUntaggedNumber)) \ 192b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(NaN, 1u << 10 | REPRESENTATION(kTagged | kUntaggedNumber)) \ 193b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(OtherNumber, 1u << 11 | REPRESENTATION(kTagged | kUntaggedNumber)) \ 194b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Symbol, 1u << 12 | REPRESENTATION(kTaggedPtr)) \ 195b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(InternalizedString, 1u << 13 | REPRESENTATION(kTaggedPtr)) \ 196b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(OtherString, 1u << 14 | REPRESENTATION(kTaggedPtr)) \ 197b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Undetectable, 1u << 15 | REPRESENTATION(kTaggedPtr)) \ 198b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Array, 1u << 16 | REPRESENTATION(kTaggedPtr)) \ 199b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Buffer, 1u << 17 | REPRESENTATION(kTaggedPtr)) \ 200b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Function, 1u << 18 | REPRESENTATION(kTaggedPtr)) \ 201b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(RegExp, 1u << 19 | REPRESENTATION(kTaggedPtr)) \ 202b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(OtherObject, 1u << 20 | REPRESENTATION(kTaggedPtr)) \ 203b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Proxy, 1u << 21 | REPRESENTATION(kTaggedPtr)) \ 204b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Internal, 1u << 22 | REPRESENTATION(kTagged | kUntagged)) \ 205b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch \ 206b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(SignedSmall, kUnsignedSmall | kOtherSignedSmall) \ 207b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Signed32, kSignedSmall | kOtherUnsigned31 | kOtherSigned32) \ 208b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Unsigned32, kUnsignedSmall | kOtherUnsigned31 | kOtherUnsigned32) \ 209b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Integral32, kSigned32 | kUnsigned32) \ 210b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(OrderedNumber, kIntegral32 | kMinusZero | kOtherNumber) \ 211b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Number, kOrderedNumber | kNaN) \ 212b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(String, kInternalizedString | kOtherString) \ 213b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(UniqueName, kSymbol | kInternalizedString) \ 214b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Name, kSymbol | kString) \ 215b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(NumberOrString, kNumber | kString) \ 216b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Primitive, kNumber | kName | kBoolean | kNull | kUndefined) \ 217b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(DetectableObject, kArray | kFunction | kRegExp | kOtherObject) \ 218b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(DetectableReceiver, kDetectableObject | kProxy) \ 219b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Detectable, kDetectableReceiver | kNumber | kName) \ 220b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Object, kDetectableObject | kUndetectable) \ 221b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Receiver, kObject | kProxy) \ 222b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(NonNumber, kBoolean | kName | kNull | kReceiver | \ 223b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch kUndefined | kInternal) \ 224b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch V(Any, 0xfffffffeu) 225b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 226b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch/* 227b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * The following diagrams show how integers (in the mathematical sense) are 228b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * divided among the different atomic numerical types. 229b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * 230b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * If SmiValuesAre31Bits(): 231b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * 232b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * ON OS32 OSS US OU31 OU32 ON 233b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * ______[_______[_______[_______[_______[_______[_______ 234b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * -2^31 -2^30 0 2^30 2^31 2^32 235b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * 236b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * Otherwise: 237b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * 238b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * ON OSS US OU32 ON 239b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * ______[_______________[_______________[_______[_______ 240b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * -2^31 0 2^31 2^32 241b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * 242b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * 243b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * E.g., OtherUnsigned32 (OU32) covers all integers from 2^31 to 2^32-1. 244b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch * 245b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch */ 246b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 247b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#define PROPER_BITSET_TYPE_LIST(V) \ 248b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch REPRESENTATION_BITSET_TYPE_LIST(V) \ 249b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch SEMANTIC_BITSET_TYPE_LIST(V) 250b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 251b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#define BITSET_TYPE_LIST(V) \ 252b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch MASK_BITSET_TYPE_LIST(V) \ 253b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch PROPER_BITSET_TYPE_LIST(V) 254b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 255b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 256b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 257b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// The abstract Type class, parameterized over the low-level representation. 258b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 259b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// struct Config { 260b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// typedef TypeImpl<Config> Type; 261b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// typedef Base; 262b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// typedef Struct; 263b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// typedef Region; 264b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// template<class> struct Handle { typedef type; } // No template typedefs... 265b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// template<class T> static Handle<T>::type handle(T* t); // !is_bitset(t) 266b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// template<class T> static Handle<T>::type cast(Handle<Type>::type); 267b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static bool is_bitset(Type*); 268b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static bool is_class(Type*); 269b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static bool is_struct(Type*, int tag); 270b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static bitset as_bitset(Type*); 271b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static i::Handle<i::Map> as_class(Type*); 272b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static Handle<Struct>::type as_struct(Type*); 273b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static Type* from_bitset(bitset); 274b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static Handle<Type>::type from_bitset(bitset, Region*); 275b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static Handle<Type>::type from_class(i::Handle<Map>, Region*); 276b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static Handle<Type>::type from_struct(Handle<Struct>::type, int tag); 277b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static Handle<Struct>::type struct_create(int tag, int length, Region*); 278b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static void struct_shrink(Handle<Struct>::type, int length); 279b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static int struct_tag(Handle<Struct>::type); 280b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static int struct_length(Handle<Struct>::type); 281b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static Handle<Type>::type struct_get(Handle<Struct>::type, int); 282b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static void struct_set(Handle<Struct>::type, int, Handle<Type>::type); 283b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// template<class V> 284b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static i::Handle<V> struct_get_value(Handle<Struct>::type, int); 285b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// template<class V> 286b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// static void struct_set_value(Handle<Struct>::type, int, i::Handle<V>); 287b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// } 288b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> 289b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochclass TypeImpl : public Config::Base { 290b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch public: 291b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Auxiliary types. 292b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 293b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef uint32_t bitset; // Internal 294b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch class BitsetType; // Internal 295b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch class StructuralType; // Internal 296b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch class UnionType; // Internal 297b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 298b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch class ClassType; 299b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch class ConstantType; 300b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch class RangeType; 301b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch class ContextType; 302b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch class ArrayType; 303b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch class FunctionType; 304b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 305b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef typename Config::template Handle<TypeImpl>::type TypeHandle; 306b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef typename Config::template Handle<ClassType>::type ClassHandle; 307b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef typename Config::template Handle<ConstantType>::type ConstantHandle; 308b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef typename Config::template Handle<RangeType>::type RangeHandle; 309b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef typename Config::template Handle<ContextType>::type ContextHandle; 310b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef typename Config::template Handle<ArrayType>::type ArrayHandle; 311b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef typename Config::template Handle<FunctionType>::type FunctionHandle; 312b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef typename Config::template Handle<UnionType>::type UnionHandle; 313b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef typename Config::Region Region; 314b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 315b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Constructors. 316b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 317b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch #define DEFINE_TYPE_CONSTRUCTOR(type, value) \ 318b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeImpl* type() { \ 319b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return BitsetType::New(BitsetType::k##type); \ 320b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } \ 321b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle type(Region* region) { \ 322b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return BitsetType::New(BitsetType::k##type, region); \ 323b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 324b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch PROPER_BITSET_TYPE_LIST(DEFINE_TYPE_CONSTRUCTOR) 325b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch #undef DEFINE_TYPE_CONSTRUCTOR 326b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 327b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Class(i::Handle<i::Map> map, Region* region) { 328b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return ClassType::New(map, region); 329b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 330b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Constant(i::Handle<i::Object> value, Region* region) { 331b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return ConstantType::New(value, region); 332b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 333b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Range( 334b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<i::Object> min, i::Handle<i::Object> max, Region* region) { 335b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return RangeType::New(min, max, region); 336b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 337b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Context(TypeHandle outer, Region* region) { 338b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return ContextType::New(outer, region); 339b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 340b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Array(TypeHandle element, Region* region) { 341b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return ArrayType::New(element, region); 342b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 343b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static FunctionHandle Function( 344b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle result, TypeHandle receiver, int arity, Region* region) { 345b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return FunctionType::New(result, receiver, arity, region); 346b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 347b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Function(TypeHandle result, Region* region) { 348b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Function(result, Any(region), 0, region); 349b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 350b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Function( 351b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle result, TypeHandle param0, Region* region) { 352b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch FunctionHandle function = Function(result, Any(region), 1, region); 353b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch function->InitParameter(0, param0); 354b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return function; 355b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 356b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Function( 357b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle result, TypeHandle param0, TypeHandle param1, Region* region) { 358b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch FunctionHandle function = Function(result, Any(region), 2, region); 359b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch function->InitParameter(0, param0); 360b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch function->InitParameter(1, param1); 361b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return function; 362b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 363b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Function( 364b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle result, TypeHandle param0, TypeHandle param1, 365b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle param2, Region* region) { 366b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch FunctionHandle function = Function(result, Any(region), 3, region); 367b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch function->InitParameter(0, param0); 368b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch function->InitParameter(1, param1); 369b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch function->InitParameter(2, param2); 370b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return function; 371b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 372b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 373b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Union(TypeHandle type1, TypeHandle type2, Region* reg); 374b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Intersect(TypeHandle type1, TypeHandle type2, Region* reg); 375b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 376b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Of(double value, Region* region) { 377b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::from_bitset(BitsetType::Lub(value), region); 378b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 379b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Of(i::Object* value, Region* region) { 380b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::from_bitset(BitsetType::Lub(value), region); 381b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 382b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Of(i::Handle<i::Object> value, Region* region) { 383b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Of(*value, region); 384b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 385b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 386b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Predicates. 387b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 388b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool IsInhabited() { return BitsetType::IsInhabited(this->BitsetLub()); } 389b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 390b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool Is(TypeImpl* that) { return this == that || this->SlowIs(that); } 391b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class TypeHandle> 392b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool Is(TypeHandle that) { return this->Is(*that); } 393b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 394b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool Maybe(TypeImpl* that); 395b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class TypeHandle> 396b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool Maybe(TypeHandle that) { return this->Maybe(*that); } 397b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 398b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool Equals(TypeImpl* that) { return this->Is(that) && that->Is(this); } 399b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class TypeHandle> 400b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool Equals(TypeHandle that) { return this->Equals(*that); } 401b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 402b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Equivalent to Constant(val)->Is(this), but avoiding allocation. 403b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool Contains(i::Object* val); 404b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool Contains(i::Handle<i::Object> val) { return this->Contains(*val); } 405b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 406b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // State-dependent versions of the above that consider subtyping between 407b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // a constant and its map class. 408b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch inline static TypeHandle NowOf(i::Object* value, Region* region); 409b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle NowOf(i::Handle<i::Object> value, Region* region) { 410b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return NowOf(*value, region); 411b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 412b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool NowIs(TypeImpl* that); 413b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class TypeHandle> 414b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool NowIs(TypeHandle that) { return this->NowIs(*that); } 415b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch inline bool NowContains(i::Object* val); 416b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool NowContains(i::Handle<i::Object> val) { return this->NowContains(*val); } 417b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 418b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool NowStable(); 419b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 420b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Inspection. 421b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 422b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool IsClass() { 423b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::is_class(this) 424b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch || Config::is_struct(this, StructuralType::kClassTag); 425b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 426b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool IsConstant() { 427b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::is_struct(this, StructuralType::kConstantTag); 428b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 429b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool IsRange() { 430b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::is_struct(this, StructuralType::kRangeTag); 431b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 432b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool IsContext() { 433b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::is_struct(this, StructuralType::kContextTag); 434b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 435b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool IsArray() { 436b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::is_struct(this, StructuralType::kArrayTag); 437b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 438b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool IsFunction() { 439b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::is_struct(this, StructuralType::kFunctionTag); 440b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 441b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 442b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ClassType* AsClass() { return ClassType::cast(this); } 443b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ConstantType* AsConstant() { return ConstantType::cast(this); } 444b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch RangeType* AsRange() { return RangeType::cast(this); } 445b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ContextType* AsContext() { return ContextType::cast(this); } 446b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ArrayType* AsArray() { return ArrayType::cast(this); } 447b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch FunctionType* AsFunction() { return FunctionType::cast(this); } 448b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 449b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Minimum and maximum of a numeric type. 450b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // These functions do not distinguish between -0 and +0. If the type equals 451b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // kNaN, they return NaN; otherwise kNaN is ignored. Only call these 452b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // functions on subtypes of Number. 453b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch double Min(); 454b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch double Max(); 455b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 456b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch int NumClasses(); 457b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch int NumConstants(); 458b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 459b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class T> class Iterator; 460b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Iterator<i::Map> Classes() { 461b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch if (this->IsBitset()) return Iterator<i::Map>(); 462b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Iterator<i::Map>(Config::handle(this)); 463b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 464b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Iterator<i::Object> Constants() { 465b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch if (this->IsBitset()) return Iterator<i::Object>(); 466b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Iterator<i::Object>(Config::handle(this)); 467b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 468b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 469b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Casting and conversion. 470b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 471b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline TypeImpl* cast(typename Config::Base* object); 472b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 473b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class OtherTypeImpl> 474b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle Convert( 475b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typename OtherTypeImpl::TypeHandle type, Region* region); 476b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 477b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Printing. 478b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 479b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch enum PrintDimension { BOTH_DIMS, SEMANTIC_DIM, REPRESENTATION_DIM }; 480b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 481b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void PrintTo(OStream& os, PrintDimension dim = BOTH_DIMS); // NOLINT 482b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 483b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#ifdef DEBUG 484b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void Print(); 485b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#endif 486b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 487b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch protected: 488b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Friends. 489b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 490b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class> friend class Iterator; 491b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class> friend class TypeImpl; 492b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 493b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Handle conversion. 494b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 495b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class T> 496b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static typename Config::template Handle<T>::type handle(T* type) { 497b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::handle(type); 498b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 499b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeImpl* unhandle() { return this; } 500b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 501b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Internal inspection. 502b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 503b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool IsNone() { return this == None(); } 504b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool IsAny() { return this == Any(); } 505b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool IsBitset() { return Config::is_bitset(this); } 506b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool IsUnion() { return Config::is_struct(this, StructuralType::kUnionTag); } 507b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 508b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bitset AsBitset() { 509b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(this->IsBitset()); 510b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return static_cast<BitsetType*>(this)->Bitset(); 511b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 512b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch UnionType* AsUnion() { return UnionType::cast(this); } 513b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 514b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Auxiliary functions. 515b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 516b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bitset BitsetGlb() { return BitsetType::Glb(this); } 517b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bitset BitsetLub() { return BitsetType::Lub(this); } 518b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 519b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool SlowIs(TypeImpl* that); 520b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 521b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bool IsInteger(double x) { 522b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return nearbyint(x) == x && !i::IsMinusZero(x); // Allows for infinities. 523b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 524b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bool IsInteger(i::Object* x) { 525b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return x->IsNumber() && IsInteger(x->Number()); 526b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 527b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 528b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch struct Limits { 529b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<i::Object> min; 530b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<i::Object> max; 531b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Limits(i::Handle<i::Object> min, i::Handle<i::Object> max) : 532b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch min(min), max(max) {} 533b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch explicit Limits(RangeType* range) : 534b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch min(range->Min()), max(range->Max()) {} 535b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch }; 536b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 537b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static Limits Intersect(Limits lhs, Limits rhs); 538b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static Limits Union(Limits lhs, Limits rhs); 539b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bool Overlap(RangeType* lhs, RangeType* rhs); 540b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bool Contains(RangeType* lhs, RangeType* rhs); 541b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bool Contains(RangeType* range, i::Object* val); 542b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 543b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch RangeType* GetRange(); 544b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static int UpdateRange( 545b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch RangeHandle type, UnionHandle result, int size, Region* region); 546b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 547b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool SimplyEquals(TypeImpl* that); 548b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class TypeHandle> 549b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool SimplyEquals(TypeHandle that) { return this->SimplyEquals(*that); } 550b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 551b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static int AddToUnion( 552b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle type, UnionHandle result, int size, Region* region); 553b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static int IntersectAux( 554b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle type, TypeHandle other, 555b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch UnionHandle result, int size, Region* region); 556b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle NormalizeUnion(UnionHandle unioned, int size); 557b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 558b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 559b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 560b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 561b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Bitset types (internal). 562b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 563b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> 564b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochclass TypeImpl<Config>::BitsetType : public TypeImpl<Config> { 565b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch protected: 566b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch friend class TypeImpl<Config>; 567b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 568b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch enum { 569b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch #define DECLARE_TYPE(type, value) k##type = (value), 570b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch BITSET_TYPE_LIST(DECLARE_TYPE) 571b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch #undef DECLARE_TYPE 572b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch kUnusedEOL = 0 573b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch }; 574b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 575b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bitset Bitset() { return Config::as_bitset(this); } 576b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 577b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeImpl* New(bitset bits) { 578b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(bits == kNone || IsInhabited(bits)); 579b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::from_bitset(bits); 580b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 581b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle New(bitset bits, Region* region) { 582b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(bits == kNone || IsInhabited(bits)); 583b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::from_bitset(bits, region); 584b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 585b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // TODO(neis): Eventually allow again for types with empty semantics 586b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // part and modify intersection and possibly subtyping accordingly. 587b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 588b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bool IsInhabited(bitset bits) { 589b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return bits & kSemantic; 590b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 591b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 592b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bool Is(bitset bits1, bitset bits2) { 593b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return (bits1 | bits2) == bits2; 594b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 595b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 596b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static double Min(bitset); 597b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static double Max(bitset); 598b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 599b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bitset Glb(TypeImpl* type); // greatest lower bound that's a bitset 600b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bitset Lub(TypeImpl* type); // least upper bound that's a bitset 601b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bitset Lub(i::Object* value); 602b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bitset Lub(double value); 603b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bitset Lub(int32_t value); 604b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bitset Lub(uint32_t value); 605b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bitset Lub(i::Map* map); 606b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static bitset Lub(Limits lim); 607b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 608b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static const char* Name(bitset); 609b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static void Print(OStream& os, bitset); // NOLINT 610b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#ifdef DEBUG 611b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static void Print(bitset); 612b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#endif 613b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 614b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch private: 615b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch struct BitsetMin{ 616b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bitset bits; 617b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch double min; 618b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch }; 619b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static const BitsetMin BitsetMins31[]; 620b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static const BitsetMin BitsetMins32[]; 621b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static const BitsetMin* BitsetMins() { 622b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return i::SmiValuesAre31Bits() ? BitsetMins31 : BitsetMins32; 623b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 624b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static size_t BitsetMinsSize() { 625b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return i::SmiValuesAre31Bits() ? 7 : 5; 626b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch /* arraysize(BitsetMins31) : arraysize(BitsetMins32); */ 627b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Using arraysize here doesn't compile on Windows. 628b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 629b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 630b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 631b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 632b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 633b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Superclass for non-bitset types (internal). 634b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Contains a tag and a variable number of type or value fields. 635b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 636b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> 637b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochclass TypeImpl<Config>::StructuralType : public TypeImpl<Config> { 638b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch protected: 639b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class> friend class TypeImpl; 640b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch friend struct ZoneTypeConfig; // For tags. 641b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch friend struct HeapTypeConfig; 642b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 643b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch enum Tag { 644b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch kClassTag, 645b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch kConstantTag, 646b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch kRangeTag, 647b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch kContextTag, 648b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch kArrayTag, 649b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch kFunctionTag, 650b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch kUnionTag 651b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch }; 652b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 653b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch int Length() { 654b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::struct_length(Config::as_struct(this)); 655b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 656b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle Get(int i) { 657b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(0 <= i && i < this->Length()); 658b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::struct_get(Config::as_struct(this), i); 659b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 660b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void Set(int i, TypeHandle type) { 661b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(0 <= i && i < this->Length()); 662b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Config::struct_set(Config::as_struct(this), i, type); 663b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 664b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void Shrink(int length) { 665b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(2 <= length && length <= this->Length()); 666b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Config::struct_shrink(Config::as_struct(this), length); 667b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 668b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class V> i::Handle<V> GetValue(int i) { 669b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(0 <= i && i < this->Length()); 670b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::template struct_get_value<V>(Config::as_struct(this), i); 671b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 672b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class V> void SetValue(int i, i::Handle<V> x) { 673b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(0 <= i && i < this->Length()); 674b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Config::struct_set_value(Config::as_struct(this), i, x); 675b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 676b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 677b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static TypeHandle New(Tag tag, int length, Region* region) { 678b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(1 <= length); 679b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::from_struct(Config::struct_create(tag, length, region)); 680b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 681b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 682b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 683b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 684b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 685b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Union types (internal). 686b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// A union is a structured type with the following invariants: 687b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// - its length is at least 2 688b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// - at most one field is a bitset, and it must go into index 0 689b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// - no field is a union 690b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// - no field is a subtype of any other field 691b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> 692b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochclass TypeImpl<Config>::UnionType : public StructuralType { 693b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch public: 694b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static UnionHandle New(int length, Region* region) { 695b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::template cast<UnionType>( 696b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch StructuralType::New(StructuralType::kUnionTag, length, region)); 697b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 698b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 699b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static UnionType* cast(TypeImpl* type) { 700b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(type->IsUnion()); 701b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return static_cast<UnionType*>(type); 702b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 703b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 704b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool Wellformed(); 705b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 706b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 707b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 708b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 709b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Class types. 710b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 711b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> 712b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochclass TypeImpl<Config>::ClassType : public StructuralType { 713b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch public: 714b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle Bound(Region* region) { 715b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::is_class(this) ? 716b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch BitsetType::New(BitsetType::Lub(*Config::as_class(this)), region) : 717b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch this->Get(0); 718b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 719b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<i::Map> Map() { 720b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return Config::is_class(this) ? Config::as_class(this) : 721b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch this->template GetValue<i::Map>(1); 722b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 723b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 724b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static ClassHandle New(i::Handle<i::Map> map, Region* region) { 725b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ClassHandle type = 726b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Config::template cast<ClassType>(Config::from_class(map, region)); 727b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch if (!type->IsClass()) { 728b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type = Config::template cast<ClassType>( 729b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch StructuralType::New(StructuralType::kClassTag, 2, region)); 730b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type->Set(0, BitsetType::New(BitsetType::Lub(*map), region)); 731b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type->SetValue(1, map); 732b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 733b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return type; 734b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 735b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 736b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static ClassType* cast(TypeImpl* type) { 737b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(type->IsClass()); 738b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return static_cast<ClassType*>(type); 739b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 740b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 741b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 742b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 743b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 744b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Constant types. 745b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 746b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> 747b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochclass TypeImpl<Config>::ConstantType : public StructuralType { 748b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch public: 749b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle Bound() { return this->Get(0); } 750b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<i::Object> Value() { return this->template GetValue<i::Object>(1); } 751b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 752b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static ConstantHandle New(i::Handle<i::Object> value, Region* region) { 753b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ConstantHandle type = Config::template cast<ConstantType>( 754b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch StructuralType::New(StructuralType::kConstantTag, 2, region)); 755b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type->Set(0, BitsetType::New(BitsetType::Lub(*value), region)); 756b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type->SetValue(1, value); 757b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return type; 758b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 759b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 760b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static ConstantType* cast(TypeImpl* type) { 761b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(type->IsConstant()); 762b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return static_cast<ConstantType*>(type); 763b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 764b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 765b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// TODO(neis): Also cache value if numerical. 766b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// TODO(neis): Allow restricting the representation. 767b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 768b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 769b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 770b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Range types. 771b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 772b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> 773b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochclass TypeImpl<Config>::RangeType : public StructuralType { 774b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch public: 775b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch int BitsetLub() { return this->Get(0)->AsBitset(); } 776b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<i::Object> Min() { return this->template GetValue<i::Object>(1); } 777b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<i::Object> Max() { return this->template GetValue<i::Object>(2); } 778b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 779b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static RangeHandle New( 780b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<i::Object> min, i::Handle<i::Object> max, Region* region) { 781b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(min->Number() <= max->Number()); 782b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch RangeHandle type = Config::template cast<RangeType>( 783b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch StructuralType::New(StructuralType::kRangeTag, 3, region)); 784b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type->Set(0, BitsetType::New(BitsetType::Lub(Limits(min, max)), region)); 785b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type->SetValue(1, min); 786b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type->SetValue(2, max); 787b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return type; 788b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 789b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 790b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static RangeHandle New(Limits lim, Region* region) { 791b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return New(lim.min, lim.max, region); 792b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 793b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 794b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static RangeType* cast(TypeImpl* type) { 795b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(type->IsRange()); 796b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return static_cast<RangeType*>(type); 797b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 798b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 799b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// TODO(neis): Also cache min and max values. 800b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// TODO(neis): Allow restricting the representation. 801b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 802b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 803b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 804b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Context types. 805b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 806b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> 807b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochclass TypeImpl<Config>::ContextType : public StructuralType { 808b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch public: 809b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle Outer() { return this->Get(0); } 810b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 811b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static ContextHandle New(TypeHandle outer, Region* region) { 812b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ContextHandle type = Config::template cast<ContextType>( 813b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch StructuralType::New(StructuralType::kContextTag, 1, region)); 814b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type->Set(0, outer); 815b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return type; 816b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 817b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 818b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static ContextType* cast(TypeImpl* type) { 819b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(type->IsContext()); 820b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return static_cast<ContextType*>(type); 821b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 822b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 823b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 824b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 825b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 826b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Array types. 827b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 828b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> 829b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochclass TypeImpl<Config>::ArrayType : public StructuralType { 830b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch public: 831b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle Element() { return this->Get(0); } 832b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 833b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static ArrayHandle New(TypeHandle element, Region* region) { 834b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch ArrayHandle type = Config::template cast<ArrayType>( 835b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch StructuralType::New(StructuralType::kArrayTag, 1, region)); 836b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type->Set(0, element); 837b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return type; 838b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 839b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 840b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static ArrayType* cast(TypeImpl* type) { 841b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(type->IsArray()); 842b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return static_cast<ArrayType*>(type); 843b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 844b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 845b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 846b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 847b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 848b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Function types. 849b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 850b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> 851b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochclass TypeImpl<Config>::FunctionType : public StructuralType { 852b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch public: 853b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch int Arity() { return this->Length() - 2; } 854b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle Result() { return this->Get(0); } 855b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle Receiver() { return this->Get(1); } 856b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle Parameter(int i) { return this->Get(2 + i); } 857b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 858b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void InitParameter(int i, TypeHandle type) { this->Set(2 + i, type); } 859b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 860b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static FunctionHandle New( 861b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle result, TypeHandle receiver, int arity, Region* region) { 862b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch FunctionHandle type = Config::template cast<FunctionType>( 863b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch StructuralType::New(StructuralType::kFunctionTag, 2 + arity, region)); 864b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type->Set(0, result); 865b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch type->Set(1, receiver); 866b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return type; 867b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 868b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 869b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static FunctionType* cast(TypeImpl* type) { 870b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(type->IsFunction()); 871b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return static_cast<FunctionType*>(type); 872b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 873b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 874b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 875b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 876b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 877b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Type iterators. 878b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 879b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> template<class T> 880b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochclass TypeImpl<Config>::Iterator { 881b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch public: 882b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool Done() const { return index_ < 0; } 883b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<T> Current(); 884b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch void Advance(); 885b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 886b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch private: 887b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class> friend class TypeImpl; 888b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 889b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Iterator() : index_(-1) {} 890b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch explicit Iterator(TypeHandle type) : type_(type), index_(-1) { 891b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Advance(); 892b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 893b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 894b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch inline bool matches(TypeHandle type); 895b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch inline TypeHandle get_type(); 896b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 897b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle type_; 898b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch int index_; 899b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 900b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 901b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 902b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 903b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Zone-allocated types; they are either (odd) integers to represent bitsets, or 904b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// (even) pointers to structures for everything else. 905b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 906b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochstruct ZoneTypeConfig { 907b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef TypeImpl<ZoneTypeConfig> Type; 908b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch class Base {}; 909b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef void* Struct; 910b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef i::Zone Region; 911b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class T> struct Handle { typedef T* type; }; 912b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 913b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class T> static inline T* handle(T* type); 914b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class T> static inline T* cast(Type* type); 915b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 916b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline bool is_bitset(Type* type); 917b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline bool is_class(Type* type); 918b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline bool is_struct(Type* type, int tag); 919b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 920b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline Type::bitset as_bitset(Type* type); 921b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline i::Handle<i::Map> as_class(Type* type); 922b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline Struct* as_struct(Type* type); 923b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 924b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline Type* from_bitset(Type::bitset); 925b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline Type* from_bitset(Type::bitset, Zone* zone); 926b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline Type* from_class(i::Handle<i::Map> map, Zone* zone); 927b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline Type* from_struct(Struct* structured); 928b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 929b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline Struct* struct_create(int tag, int length, Zone* zone); 930b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline void struct_shrink(Struct* structure, int length); 931b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline int struct_tag(Struct* structure); 932b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline int struct_length(Struct* structure); 933b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline Type* struct_get(Struct* structure, int i); 934b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline void struct_set(Struct* structure, int i, Type* type); 935b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class V> 936b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline i::Handle<V> struct_get_value(Struct* structure, int i); 937b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class V> static inline void struct_set_value( 938b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch Struct* structure, int i, i::Handle<V> x); 939b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 940b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 941b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtypedef TypeImpl<ZoneTypeConfig> Type; 942b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 943b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 944b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 945b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Heap-allocated types; either smis for bitsets, maps for classes, boxes for 946b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// constants, or fixed arrays for unions. 947b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 948b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochstruct HeapTypeConfig { 949b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef TypeImpl<HeapTypeConfig> Type; 950b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef i::Object Base; 951b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef i::FixedArray Struct; 952b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef i::Isolate Region; 953b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class T> struct Handle { typedef i::Handle<T> type; }; 954b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 955b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class T> static inline i::Handle<T> handle(T* type); 956b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class T> static inline i::Handle<T> cast(i::Handle<Type> type); 957b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 958b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline bool is_bitset(Type* type); 959b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline bool is_class(Type* type); 960b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline bool is_struct(Type* type, int tag); 961b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 962b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline Type::bitset as_bitset(Type* type); 963b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline i::Handle<i::Map> as_class(Type* type); 964b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline i::Handle<Struct> as_struct(Type* type); 965b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 966b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline Type* from_bitset(Type::bitset); 967b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline i::Handle<Type> from_bitset(Type::bitset, Isolate* isolate); 968b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline i::Handle<Type> from_class( 969b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<i::Map> map, Isolate* isolate); 970b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline i::Handle<Type> from_struct(i::Handle<Struct> structure); 971b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 972b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline i::Handle<Struct> struct_create( 973b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch int tag, int length, Isolate* isolate); 974b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline void struct_shrink(i::Handle<Struct> structure, int length); 975b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline int struct_tag(i::Handle<Struct> structure); 976b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline int struct_length(i::Handle<Struct> structure); 977b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline i::Handle<Type> struct_get(i::Handle<Struct> structure, int i); 978b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline void struct_set( 979b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<Struct> structure, int i, i::Handle<Type> type); 980b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class V> 981b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline i::Handle<V> struct_get_value( 982b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<Struct> structure, int i); 983b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch template<class V> 984b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static inline void struct_set_value( 985b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch i::Handle<Struct> structure, int i, i::Handle<V> x); 986b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 987b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 988b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtypedef TypeImpl<HeapTypeConfig> HeapType; 989b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 990b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 991b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// ----------------------------------------------------------------------------- 992b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch// Type bounds. A simple struct to represent a pair of lower/upper types. 993b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 994b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtemplate<class Config> 995b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochstruct BoundsImpl { 996b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef TypeImpl<Config> Type; 997b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef typename Type::TypeHandle TypeHandle; 998b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch typedef typename Type::Region Region; 999b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 1000b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle lower; 1001b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle upper; 1002b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 1003b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch BoundsImpl() {} 1004b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch explicit BoundsImpl(TypeHandle t) : lower(t), upper(t) {} 1005b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch BoundsImpl(TypeHandle l, TypeHandle u) : lower(l), upper(u) { 1006b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch DCHECK(lower->Is(upper)); 1007b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 1008b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 1009b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Unrestricted bounds. 1010b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static BoundsImpl Unbounded(Region* region) { 1011b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return BoundsImpl(Type::None(region), Type::Any(region)); 1012b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 1013b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 1014b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Meet: both b1 and b2 are known to hold. 1015b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static BoundsImpl Both(BoundsImpl b1, BoundsImpl b2, Region* region) { 1016b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle lower = Type::Union(b1.lower, b2.lower, region); 1017b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle upper = Type::Intersect(b1.upper, b2.upper, region); 1018b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Lower bounds are considered approximate, correct as necessary. 1019b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch lower = Type::Intersect(lower, upper, region); 1020b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return BoundsImpl(lower, upper); 1021b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 1022b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 1023b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Join: either b1 or b2 is known to hold. 1024b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static BoundsImpl Either(BoundsImpl b1, BoundsImpl b2, Region* region) { 1025b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle lower = Type::Intersect(b1.lower, b2.lower, region); 1026b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle upper = Type::Union(b1.upper, b2.upper, region); 1027b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return BoundsImpl(lower, upper); 1028b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 1029b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 1030b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static BoundsImpl NarrowLower(BoundsImpl b, TypeHandle t, Region* region) { 1031b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch // Lower bounds are considered approximate, correct as necessary. 1032b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch t = Type::Intersect(t, b.upper, region); 1033b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle lower = Type::Union(b.lower, t, region); 1034b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return BoundsImpl(lower, b.upper); 1035b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 1036b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch static BoundsImpl NarrowUpper(BoundsImpl b, TypeHandle t, Region* region) { 1037b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle lower = Type::Intersect(b.lower, t, region); 1038b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch TypeHandle upper = Type::Intersect(b.upper, t, region); 1039b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return BoundsImpl(lower, upper); 1040b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 1041b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 1042b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch bool Narrows(BoundsImpl that) { 1043b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch return that.lower->Is(this->lower) && this->upper->Is(that.upper); 1044b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch } 1045b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch}; 1046b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 1047b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdochtypedef BoundsImpl<ZoneTypeConfig> Bounds; 1048b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 1049b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch} } // namespace v8::internal 1050b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch 1051b8a8cc1952d61a2f3a2568848933943a543b5d3eBen Murdoch#endif // V8_TYPES_H_ 1052