DFG should not load the property storage if it is inline.
[WebKit-https.git] / Source / JavaScriptCore / bytecode / StructureSet.h
1 /*
2  * Copyright (C) 2011 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 #ifndef StructureSet_h
27 #define StructureSet_h
28
29 #include "PredictedType.h"
30 #include "Structure.h"
31 #include <stdio.h>
32 #include <wtf/Vector.h>
33
34 namespace JSC {
35
36 namespace DFG {
37 class StructureAbstractValue;
38 }
39
40 class StructureSet {
41 public:
42     StructureSet() { }
43     
44     StructureSet(Structure* structure)
45     {
46         m_structures.append(structure);
47     }
48     
49     void clear()
50     {
51         m_structures.clear();
52     }
53     
54     void add(Structure* structure)
55     {
56         ASSERT(!contains(structure));
57         m_structures.append(structure);
58     }
59     
60     bool addAll(const StructureSet& other)
61     {
62         bool changed = false;
63         for (size_t i = 0; i < other.size(); ++i) {
64             if (contains(other[i]))
65                 continue;
66             add(other[i]);
67             changed = true;
68         }
69         return changed;
70     }
71     
72     void remove(Structure* structure)
73     {
74         for (size_t i = 0; i < m_structures.size(); ++i) {
75             if (m_structures[i] != structure)
76                 continue;
77             
78             m_structures[i] = m_structures.last();
79             m_structures.removeLast();
80             return;
81         }
82     }
83     
84     bool contains(Structure* structure) const
85     {
86         for (size_t i = 0; i < m_structures.size(); ++i) {
87             if (m_structures[i] == structure)
88                 return true;
89         }
90         return false;
91     }
92     
93     bool isSubsetOf(const StructureSet& other) const
94     {
95         for (size_t i = 0; i < m_structures.size(); ++i) {
96             if (!other.contains(m_structures[i]))
97                 return false;
98         }
99         return true;
100     }
101     
102     bool isSupersetOf(const StructureSet& other) const
103     {
104         return other.isSubsetOf(*this);
105     }
106     
107     size_t size() const { return m_structures.size(); }
108     
109     bool allAreUsingInlinePropertyStorage() const
110     {
111         for (size_t i = 0; i < m_structures.size(); ++i) {
112             if (!m_structures[i]->isUsingInlineStorage())
113                 return false;
114         }
115         return true;
116     }
117     
118     Structure* at(size_t i) const { return m_structures.at(i); }
119     
120     Structure* operator[](size_t i) const { return at(i); }
121     
122     Structure* last() const { return m_structures.last(); }
123
124     PredictedType predictionFromStructures() const
125     {
126         PredictedType result = PredictNone;
127         
128         for (size_t i = 0; i < m_structures.size(); ++i)
129             mergePrediction(result, predictionFromStructure(m_structures[i]));
130         
131         return result;
132     }
133     
134     bool operator==(const StructureSet& other) const
135     {
136         if (m_structures.size() != other.m_structures.size())
137             return false;
138         
139         for (size_t i = 0; i < m_structures.size(); ++i) {
140             if (!other.contains(m_structures[i]))
141                 return false;
142         }
143         
144         return true;
145     }
146     
147     void dump(FILE* out)
148     {
149         fprintf(out, "[");
150         for (size_t i = 0; i < m_structures.size(); ++i) {
151             if (i)
152                 fprintf(out, ", ");
153             fprintf(out, "%p", m_structures[i]);
154         }
155         fprintf(out, "]");
156     }
157     
158 private:
159     friend class DFG::StructureAbstractValue;
160     
161     Vector<Structure*, 2> m_structures;
162 };
163
164 } // namespace JSC
165
166 #endif // StructureSet_h