7dd52424e06e8dccdaf8c4fa706ae75ede022f8c
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSScope.cpp
1 /*
2  * Copyright (C) 2012, 2013, 2014 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 #include "config.h"
27 #include "JSScope.h"
28
29 #include "JSActivation.h"
30 #include "JSGlobalObject.h"
31 #include "JSNameScope.h"
32 #include "JSWithScope.h"
33 #include "JSCInlines.h"
34
35 namespace JSC {
36
37 STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(JSScope);
38
39 void JSScope::visitChildren(JSCell* cell, SlotVisitor& visitor)
40 {
41     JSScope* thisObject = jsCast<JSScope*>(cell);
42     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
43     Base::visitChildren(thisObject, visitor);
44     visitor.append(&thisObject->m_next);
45 }
46
47 // Returns true if we found enough information to terminate optimization.
48 static inline bool abstractAccess(ExecState* exec, JSScope* scope, const Identifier& ident, GetOrPut getOrPut, size_t depth, bool& needsVarInjectionChecks, ResolveOp& op)
49 {
50     if (JSActivation* activation = jsDynamicCast<JSActivation*>(scope)) {
51         if (ident == exec->propertyNames().arguments) {
52             // We know the property will be at this activation scope, but we don't know how to cache it.
53             op = ResolveOp(Dynamic, 0, 0, 0, 0, 0);
54             return true;
55         }
56
57         SymbolTableEntry entry = activation->symbolTable()->get(ident.impl());
58         if (entry.isReadOnly() && getOrPut == Put) {
59             // We know the property will be at this activation scope, but we don't know how to cache it.
60             op = ResolveOp(Dynamic, 0, 0, 0, 0, 0);
61             return true;
62         }
63
64         if (!entry.isNull()) {
65             op = ResolveOp(makeType(ClosureVar, needsVarInjectionChecks), depth, 0, activation, entry.watchpointSet(), entry.getIndex());
66             return true;
67         }
68
69         if (activation->symbolTable()->usesNonStrictEval())
70             needsVarInjectionChecks = true;
71         return false;
72     }
73
74     if (JSGlobalObject* globalObject = jsDynamicCast<JSGlobalObject*>(scope)) {
75         SymbolTableEntry entry = globalObject->symbolTable()->get(ident.impl());
76         if (!entry.isNull()) {
77             if (getOrPut == Put && entry.isReadOnly()) {
78                 // We know the property will be at global scope, but we don't know how to cache it.
79                 op = ResolveOp(Dynamic, 0, 0, 0, 0, 0);
80                 return true;
81             }
82
83             op = ResolveOp(
84                 makeType(GlobalVar, needsVarInjectionChecks), depth, 0, 0, entry.watchpointSet(),
85                 reinterpret_cast<uintptr_t>(globalObject->registerAt(entry.getIndex()).slot()));
86             return true;
87         }
88
89         PropertySlot slot(globalObject);
90         if (!globalObject->getOwnPropertySlot(globalObject, exec, ident, slot)
91             || !slot.isCacheableValue()
92             || !globalObject->structure()->propertyAccessesAreCacheable()
93             || (globalObject->structure()->hasReadOnlyOrGetterSetterPropertiesExcludingProto() && getOrPut == Put)) {
94             // We know the property will be at global scope, but we don't know how to cache it.
95             ASSERT(!scope->next());
96             op = ResolveOp(makeType(GlobalProperty, needsVarInjectionChecks), depth, 0, 0, 0, 0);
97             return true;
98         }
99         
100         WatchpointState state = globalObject->structure()->ensurePropertyReplacementWatchpointSet(exec->vm(), slot.cachedOffset())->state();
101         if (state == IsWatched && getOrPut == Put) {
102             // The field exists, but because the replacement watchpoint is still intact. This is
103             // kind of dangerous. We have two options:
104             // 1) Invalidate the watchpoint set. That would work, but it's possible that this code
105             //    path never executes - in which case this would be unwise.
106             // 2) Have the invalidation happen at run-time. All we have to do is leave the code
107             //    uncached. The only downside is slightly more work when this does execute.
108             // We go with option (2) here because it seems less evil.
109             op = ResolveOp(makeType(GlobalProperty, needsVarInjectionChecks), depth, 0, 0, 0, 0);
110         } else
111             op = ResolveOp(makeType(GlobalProperty, needsVarInjectionChecks), depth, globalObject->structure(), 0, 0, slot.cachedOffset());
112         return true;
113     }
114
115     op = ResolveOp(Dynamic, 0, 0, 0, 0, 0);
116     return true;
117 }
118
119 JSObject* JSScope::objectAtScope(JSScope* scope)
120 {
121     JSObject* object = scope;
122     if (object->type() == WithScopeType)
123         return jsCast<JSWithScope*>(object)->object();
124
125     return object;
126 }
127
128 int JSScope::depth()
129 {
130     int depth = 0;
131     for (JSScope* scope = this; scope; scope = scope->next())
132         ++depth;
133     return depth;
134 }
135
136 JSValue JSScope::resolve(ExecState* exec, JSScope* scope, const Identifier& ident)
137 {
138     ScopeChainIterator end = scope->end();
139     ScopeChainIterator it = scope->begin();
140     while (1) {
141         JSObject* object = it.get();
142
143         if (++it == end) // Global scope.
144             return object;
145
146         if (object->hasProperty(exec, ident))
147             return object;
148     }
149 }
150
151 ResolveOp JSScope::abstractResolve(ExecState* exec, bool hasTopActivation, JSScope* scope, const Identifier& ident, GetOrPut getOrPut, ResolveType unlinkedType)
152 {
153     ResolveOp op(Dynamic, 0, 0, 0, 0, 0);
154     if (unlinkedType == Dynamic)
155         return op;
156
157     size_t depth = hasTopActivation ? 1 : 0;
158     bool needsVarInjectionChecks = JSC::needsVarInjectionChecks(unlinkedType);
159     for (; scope; scope = scope->next()) {
160         if (abstractAccess(exec, scope, ident, getOrPut, depth, needsVarInjectionChecks, op))
161             break;
162         ++depth;
163     }
164
165     return op;
166 }
167
168 const char* resolveModeName(ResolveMode mode)
169 {
170     static const char* const names[] = {
171         "ThrowIfNotFound",
172         "DoNotThrowIfNotFound"
173     };
174     return names[mode];
175 }
176
177 const char* resolveTypeName(ResolveType type)
178 {
179     static const char* const names[] = {
180         "GlobalProperty",
181         "GlobalVar",
182         "ClosureVar",
183         "GlobalPropertyWithVarInjectionChecks",
184         "GlobalVarWithVarInjectionChecks",
185         "ClosureVarWithVarInjectionChecks",
186         "Dynamic"
187     };
188     ASSERT(type < sizeof(names) / sizeof(names[0]));
189     return names[type];
190 }
191
192 } // namespace JSC