2b15965f623edf7c7b79482805162d874e6ccd37
[WebKit-https.git] / Source / JavaScriptCore / bytecode / ObjectPropertyConditionSet.h
1 /*
2  * Copyright (C) 2015 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 #include "ObjectPropertyCondition.h"
29 #include <wtf/FastMalloc.h>
30 #include <wtf/RefCounted.h>
31 #include <wtf/Vector.h>
32
33 namespace JSC {
34
35 // An object property condition set is used to represent the set of additional conditions
36 // that need to be met for some heap access to be valid. The set can have the following
37 // interesting states:
38 //
39 // Empty: There are no special conditions that need to be met.
40 // Invalid: The heap access is never valid.
41 // Non-empty: The heap access is valid if all the ObjectPropertyConditions in the set are valid.
42
43 class ObjectPropertyConditionSet {
44 public:
45     ObjectPropertyConditionSet() { }
46     
47     static ObjectPropertyConditionSet invalid()
48     {
49         ObjectPropertyConditionSet result;
50         result.m_data = adoptRef(new Data());
51         return result;
52     }
53     
54     static ObjectPropertyConditionSet create(const Vector<ObjectPropertyCondition>& vector)
55     {
56         if (vector.isEmpty())
57             return ObjectPropertyConditionSet();
58         
59         ObjectPropertyConditionSet result;
60         result.m_data = adoptRef(new Data());
61         result.m_data->vector = vector;
62         return result;
63     }
64     
65     bool isValid() const
66     {
67         return !m_data || !m_data->vector.isEmpty();
68     }
69
70     bool isValidAndWatchable() const;
71     
72     bool isEmpty() const
73     {
74         return !m_data;
75     }
76     
77     typedef const ObjectPropertyCondition* iterator;
78     
79     iterator begin() const
80     {
81         if (!m_data)
82             return nullptr;
83         return m_data->vector.begin();
84     }
85     iterator end() const
86     {
87         if (!m_data)
88             return nullptr;
89         return m_data->vector.end();
90     }
91     
92     ObjectPropertyCondition forObject(JSObject*) const;
93     ObjectPropertyCondition forConditionKind(PropertyCondition::Kind) const;
94
95     unsigned numberOfConditionsWithKind(PropertyCondition::Kind) const;
96
97     bool hasOneSlotBaseCondition() const;
98     
99     // If this is a condition set for a prototype hit, then this is guaranteed to return the
100     // condition on the prototype itself. This allows you to get the object, offset, and
101     // attributes for the prototype. This will RELEASE_ASSERT that there is exactly one Presence
102     // in the set, and it will return that presence.
103     ObjectPropertyCondition slotBaseCondition() const;
104     
105     // Attempt to create a new condition set by merging this one with the other one. This will
106     // fail if any of the conditions are incompatible with each other. When if fails, it returns
107     // invalid().
108     ObjectPropertyConditionSet mergedWith(const ObjectPropertyConditionSet& other) const;
109     
110     bool structuresEnsureValidity() const;
111     bool structuresEnsureValidityAssumingImpurePropertyWatchpoint() const;
112     
113     bool needImpurePropertyWatchpoint() const;
114     bool areStillLive() const;
115     
116     void dumpInContext(PrintStream&, DumpContext*) const;
117     void dump(PrintStream&) const;
118     
119     // Helpers for using this in a union.
120     void* releaseRawPointer()
121     {
122         return static_cast<void*>(m_data.leakRef());
123     }
124     static ObjectPropertyConditionSet adoptRawPointer(void* rawPointer)
125     {
126         ObjectPropertyConditionSet result;
127         result.m_data = adoptRef(static_cast<Data*>(rawPointer));
128         return result;
129     }
130     static ObjectPropertyConditionSet fromRawPointer(void* rawPointer)
131     {
132         ObjectPropertyConditionSet result;
133         result.m_data = static_cast<Data*>(rawPointer);
134         return result;
135     }
136
137     // FIXME: Everything below here should be private, but cannot be because of a bug in VS.
138     
139     // Internally, this represents Invalid using a pointer to a Data that has an empty vector.
140     
141     // FIXME: This could be made more compact by having it internally use a vector that just has
142     // the non-uid portion of ObjectPropertyCondition, and then requiring that the callers of all
143     // of the APIs supply the uid.
144     
145     class Data : public ThreadSafeRefCounted<Data> {
146         WTF_MAKE_NONCOPYABLE(Data);
147         WTF_MAKE_FAST_ALLOCATED;
148         
149     public:
150         Data() { }
151         
152         Vector<ObjectPropertyCondition> vector;
153     };
154     
155 private:
156     RefPtr<Data> m_data;
157 };
158
159 ObjectPropertyCondition generateConditionForSelfEquivalence(
160     VM&, JSCell* owner, JSObject* object, UniquedStringImpl* uid);
161
162 ObjectPropertyConditionSet generateConditionsForPropertyMiss(
163     VM&, JSCell* owner, ExecState*, Structure* headStructure, UniquedStringImpl* uid);
164 ObjectPropertyConditionSet generateConditionsForPropertySetterMiss(
165     VM&, JSCell* owner, ExecState*, Structure* headStructure, UniquedStringImpl* uid);
166 ObjectPropertyConditionSet generateConditionsForPrototypePropertyHit(
167     VM&, JSCell* owner, ExecState*, Structure* headStructure, JSObject* prototype,
168     UniquedStringImpl* uid);
169 ObjectPropertyConditionSet generateConditionsForPrototypePropertyHitCustom(
170     VM&, JSCell* owner, ExecState*, Structure* headStructure, JSObject* prototype,
171     UniquedStringImpl* uid);
172
173 ObjectPropertyConditionSet generateConditionsForPrototypeEquivalenceConcurrently(
174     VM&, JSGlobalObject*, Structure* headStructure, JSObject* prototype,
175     UniquedStringImpl* uid);
176 ObjectPropertyConditionSet generateConditionsForPropertyMissConcurrently(
177     VM&, JSGlobalObject*, Structure* headStructure, UniquedStringImpl* uid);
178 ObjectPropertyConditionSet generateConditionsForPropertySetterMissConcurrently(
179     VM&, JSGlobalObject*, Structure* headStructure, UniquedStringImpl* uid);
180
181 } // namespace JSC