Remove excessive headers from JavaScriptCore
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGPromotedHeapLocation.h
1 /*
2  * Copyright (C) 2014-2016 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #pragma once
27
28 #if ENABLE(DFG_JIT)
29
30 #include "DFGEdge.h"
31 #include "DFGNodeOrigin.h"
32 #include <wtf/HashTable.h>
33 #include <wtf/PrintStream.h>
34
35 namespace JSC { namespace DFG {
36
37 struct Node;
38
39 // Promoted locations are like heap locations but are meant to be more precise. A heap location is
40 // applicable to CSE scenarios, where it makes sense to speak of a location very abstractly. A
41 // promoted heap location is for cases where we speak of a specific object and the compiler knows
42 // this object's identity - for example, the object allocation has been eliminated and we turned the
43 // fields into local variables. Because these two cases have subtly different needs, we use subtly
44 // different structures. One of the really significant differences is that promoted locations can be
45 // spoken of using either a descriptor which does not refer to any Node*'s or with a heap location,
46 // which is a descriptor with a Node* base.
47
48 enum PromotedLocationKind {
49     InvalidPromotedLocationKind,
50     
51     ActivationScopePLoc,
52     ActivationSymbolTablePLoc,
53     ArgumentCountPLoc,
54     ArgumentPLoc,
55     ArgumentsCalleePLoc,
56     ClosureVarPLoc,
57     FunctionActivationPLoc,
58     FunctionExecutablePLoc,
59     IndexedPropertyPLoc,
60     NamedPropertyPLoc,
61     PublicLengthPLoc,
62     StructurePLoc,
63     VectorLengthPLoc,
64     SpreadPLoc,
65     NewArrayWithSpreadArgumentPLoc,
66 };
67
68 class PromotedLocationDescriptor {
69 public:
70     PromotedLocationDescriptor(
71         PromotedLocationKind kind = InvalidPromotedLocationKind, unsigned info = 0)
72         : m_kind(kind)
73         , m_info(info)
74     {
75     }
76
77     PromotedLocationDescriptor(WTF::HashTableDeletedValueType)
78         : m_kind(InvalidPromotedLocationKind)
79         , m_info(1)
80     {
81     }
82
83     bool operator!() const { return m_kind == InvalidPromotedLocationKind; }
84
85     explicit operator bool() const { return !!*this; }
86     
87     PromotedLocationKind kind() const { return m_kind; }
88     unsigned info() const { return m_info; }
89     
90     unsigned imm1() const { return static_cast<uint32_t>(m_kind); }
91     unsigned imm2() const { return static_cast<uint32_t>(m_info); }
92     
93     unsigned hash() const
94     {
95         return m_kind + m_info;
96     }
97     
98     bool operator==(const PromotedLocationDescriptor& other) const
99     {
100         return m_kind == other.m_kind
101             && m_info == other.m_info;
102     }
103     
104     bool operator!=(const PromotedLocationDescriptor& other) const
105     {
106         return !(*this == other);
107     }
108
109     bool isHashTableDeletedValue() const
110     {
111         return m_kind == InvalidPromotedLocationKind && m_info;
112     }
113
114     bool neededForMaterialization() const
115     {
116         switch (kind()) {
117         case NamedPropertyPLoc:
118         case ClosureVarPLoc:
119             return false;
120
121         default:
122             return true;
123         }
124     }
125     
126     void dump(PrintStream& out) const;
127
128 private:
129     PromotedLocationKind m_kind;
130     unsigned m_info;
131 };
132
133 struct PromotedLocationDescriptorHash {
134     static unsigned hash(const PromotedLocationDescriptor& key) { return key.hash(); }
135     static bool equal(const PromotedLocationDescriptor& a, const PromotedLocationDescriptor& b) { return a == b; }
136     static const bool safeToCompareToEmptyOrDeleted = true;
137 };
138
139 class PromotedHeapLocation {
140 public:
141     PromotedHeapLocation(
142         PromotedLocationKind kind = InvalidPromotedLocationKind,
143         Node* base = nullptr, unsigned info = 0)
144         : m_base(base)
145         , m_meta(kind, info)
146     {
147     }
148     
149     PromotedHeapLocation(
150         PromotedLocationKind kind, Edge base, unsigned info = 0)
151         : PromotedHeapLocation(kind, base.node(), info)
152     {
153     }
154     
155     PromotedHeapLocation(Node* base, PromotedLocationDescriptor meta)
156         : m_base(base)
157         , m_meta(meta)
158     {
159     }
160     
161     PromotedHeapLocation(WTF::HashTableDeletedValueType)
162         : m_base(nullptr)
163         , m_meta(InvalidPromotedLocationKind, 1)
164     {
165     }
166     
167     Node* createHint(Graph&, NodeOrigin, Node* value);
168     
169     bool operator!() const { return kind() == InvalidPromotedLocationKind; }
170     
171     PromotedLocationKind kind() const { return m_meta.kind(); }
172     Node* base() const { return m_base; }
173     unsigned info() const { return m_meta.info(); }
174     PromotedLocationDescriptor descriptor() const { return m_meta; }
175     
176     unsigned hash() const
177     {
178         return m_meta.hash() + WTF::PtrHash<Node*>::hash(m_base);
179     }
180     
181     bool operator==(const PromotedHeapLocation& other) const
182     {
183         return m_base == other.m_base
184             && m_meta == other.m_meta;
185     }
186     
187     bool isHashTableDeletedValue() const
188     {
189         return m_meta.isHashTableDeletedValue();
190     }
191     
192     void dump(PrintStream& out) const;
193     
194 private:
195     Node* m_base;
196     PromotedLocationDescriptor m_meta;
197 };
198
199 struct PromotedHeapLocationHash {
200     static unsigned hash(const PromotedHeapLocation& key) { return key.hash(); }
201     static bool equal(const PromotedHeapLocation& a, const PromotedHeapLocation& b) { return a == b; }
202     static const bool safeToCompareToEmptyOrDeleted = true;
203 };
204
205 } } // namespace JSC::DFG
206
207 namespace WTF {
208
209 void printInternal(PrintStream&, JSC::DFG::PromotedLocationKind);
210
211 template<typename T> struct DefaultHash;
212 template<> struct DefaultHash<JSC::DFG::PromotedHeapLocation> {
213     typedef JSC::DFG::PromotedHeapLocationHash Hash;
214 };
215
216 template<typename T> struct HashTraits;
217 template<> struct HashTraits<JSC::DFG::PromotedHeapLocation> : SimpleClassHashTraits<JSC::DFG::PromotedHeapLocation> {
218     static const bool emptyValueIsZero = false;
219 };
220
221 template<typename T> struct DefaultHash;
222 template<> struct DefaultHash<JSC::DFG::PromotedLocationDescriptor> {
223     typedef JSC::DFG::PromotedLocationDescriptorHash Hash;
224 };
225
226 template<typename T> struct HashTraits;
227 template<> struct HashTraits<JSC::DFG::PromotedLocationDescriptor> : SimpleClassHashTraits<JSC::DFG::PromotedLocationDescriptor> {
228     static const bool emptyValueIsZero = false;
229 };
230
231 } // namespace WTF
232
233 #endif // ENABLE(DFG_JIT)