Unreviewed, rolling out r144074.
[WebKit-https.git] / Source / JavaScriptCore / runtime / StructureInlines.h
1 /*
2  * Copyright (C) 2013 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 COMPUTER, 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 COMPUTER, 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 StructureInlines_h
27 #define StructureInlines_h
28
29 #include "Structure.h"
30
31 namespace JSC {
32
33 inline Structure* Structure::create(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype, const TypeInfo& typeInfo, const ClassInfo* classInfo, IndexingType indexingType, unsigned inlineCapacity)
34 {
35     ASSERT(globalData.structureStructure);
36     ASSERT(classInfo);
37     Structure* structure = new (NotNull, allocateCell<Structure>(globalData.heap)) Structure(globalData, globalObject, prototype, typeInfo, classInfo, indexingType, inlineCapacity);
38     structure->finishCreation(globalData);
39     return structure;
40 }
41
42 inline Structure* Structure::createStructure(JSGlobalData& globalData)
43 {
44     ASSERT(!globalData.structureStructure);
45     Structure* structure = new (NotNull, allocateCell<Structure>(globalData.heap)) Structure(globalData);
46     structure->finishCreation(globalData, CreatingEarlyCell);
47     return structure;
48 }
49
50 inline Structure* Structure::create(JSGlobalData& globalData, const Structure* structure)
51 {
52     ASSERT(globalData.structureStructure);
53     Structure* newStructure = new (NotNull, allocateCell<Structure>(globalData.heap)) Structure(globalData, structure);
54     newStructure->finishCreation(globalData);
55     if (structure->typeInfo().structureHasRareData())
56         newStructure->cloneRareDataFrom(globalData, structure);
57     return newStructure;
58 }
59
60 inline PropertyOffset Structure::get(JSGlobalData& globalData, PropertyName propertyName)
61 {
62     ASSERT(structure()->classInfo() == &s_info);
63     materializePropertyMapIfNecessary(globalData);
64     if (!m_propertyTable)
65         return invalidOffset;
66
67     PropertyMapEntry* entry = m_propertyTable->find(propertyName.uid()).first;
68     return entry ? entry->offset : invalidOffset;
69 }
70
71 inline PropertyOffset Structure::get(JSGlobalData& globalData, const WTF::String& name)
72 {
73     ASSERT(structure()->classInfo() == &s_info);
74     materializePropertyMapIfNecessary(globalData);
75     if (!m_propertyTable)
76         return invalidOffset;
77
78     PropertyMapEntry* entry = m_propertyTable->findWithString(name.impl()).first;
79     return entry ? entry->offset : invalidOffset;
80 }
81     
82 inline bool Structure::masqueradesAsUndefined(JSGlobalObject* lexicalGlobalObject)
83 {
84     return typeInfo().masqueradesAsUndefined() && globalObject() == lexicalGlobalObject;
85 }
86
87 ALWAYS_INLINE void SlotVisitor::internalAppend(JSCell* cell)
88 {
89     ASSERT(!m_isCheckingForDefaultMarkViolation);
90     if (!cell)
91         return;
92 #if ENABLE(GC_VALIDATION)
93     validate(cell);
94 #endif
95     if (Heap::testAndSetMarked(cell) || !cell->structure())
96         return;
97
98     m_visitCount++;
99         
100     MARK_LOG_CHILD(*this, cell);
101
102     // Should never attempt to mark something that is zapped.
103     ASSERT(!cell->isZapped());
104         
105     m_stack.append(cell);
106 }
107
108 inline bool Structure::transitivelyTransitionedFrom(Structure* structureToFind)
109 {
110     for (Structure* current = this; current; current = current->previousID()) {
111         if (current == structureToFind)
112             return true;
113     }
114     return false;
115 }
116
117 inline void Structure::setEnumerationCache(JSGlobalData& globalData, JSPropertyNameIterator* enumerationCache)
118 {
119     ASSERT(!isDictionary());
120     if (!typeInfo().structureHasRareData())
121         allocateRareData(globalData);
122     rareData()->setEnumerationCache(globalData, this, enumerationCache);
123 }
124
125 inline JSPropertyNameIterator* Structure::enumerationCache()
126 {
127     if (!typeInfo().structureHasRareData())
128         return 0;
129     return rareData()->enumerationCache();
130 }
131
132 inline JSValue Structure::prototypeForLookup(JSGlobalObject* globalObject) const
133 {
134     if (isObject())
135         return m_prototype.get();
136
137     ASSERT(typeInfo().type() == StringType);
138     return globalObject->stringPrototype();
139 }
140
141 inline JSValue Structure::prototypeForLookup(ExecState* exec) const
142 {
143     return prototypeForLookup(exec->lexicalGlobalObject());
144 }
145
146 inline StructureChain* Structure::prototypeChain(JSGlobalData& globalData, JSGlobalObject* globalObject) const
147 {
148     // We cache our prototype chain so our clients can share it.
149     if (!isValid(globalObject, m_cachedPrototypeChain.get())) {
150         JSValue prototype = prototypeForLookup(globalObject);
151         m_cachedPrototypeChain.set(globalData, this, StructureChain::create(globalData, prototype.isNull() ? 0 : asObject(prototype)->structure()));
152     }
153     return m_cachedPrototypeChain.get();
154 }
155
156 inline StructureChain* Structure::prototypeChain(ExecState* exec) const
157 {
158     return prototypeChain(exec->globalData(), exec->lexicalGlobalObject());
159 }
160
161 inline bool Structure::isValid(JSGlobalObject* globalObject, StructureChain* cachedPrototypeChain) const
162 {
163     if (!cachedPrototypeChain)
164         return false;
165
166     JSValue prototype = prototypeForLookup(globalObject);
167     WriteBarrier<Structure>* cachedStructure = cachedPrototypeChain->head();
168     while (*cachedStructure && !prototype.isNull()) {
169         if (asObject(prototype)->structure() != cachedStructure->get())
170             return false;
171         ++cachedStructure;
172         prototype = asObject(prototype)->prototype();
173     }
174     return prototype.isNull() && !*cachedStructure;
175 }
176
177 inline bool Structure::isValid(ExecState* exec, StructureChain* cachedPrototypeChain) const
178 {
179     return isValid(exec->lexicalGlobalObject(), cachedPrototypeChain);
180 }
181
182 } // namespace JSC
183
184 #endif // StructureInlines_h
185