void JSLexicalEnvironment::visitChildren(JSCell* cell, SlotVisitor& visitor) { JSLexicalEnvironment* thisObject = jsCast<JSLexicalEnvironment*>(cell); ASSERT_GC_OBJECT_INHERITS(thisObject, info()); Base::visitChildren(thisObject, visitor); for (int i = 0; i < thisObject->symbolTable()->captureCount(); ++i) visitor.append(&thisObject->storage()[i]); }
JSValue DebuggerScope::caughtValue(ExecState* exec) const { ASSERT(isCatchScope()); JSLexicalEnvironment* catchEnvironment = jsCast<JSLexicalEnvironment*>(m_scope.get()); SymbolTable* catchSymbolTable = catchEnvironment->symbolTable(); RELEASE_ASSERT(catchSymbolTable->size() == 1); PropertyName errorName(catchSymbolTable->begin(catchSymbolTable->m_lock)->key.get()); PropertySlot slot(m_scope.get()); bool success = catchEnvironment->getOwnPropertySlot(catchEnvironment, exec, errorName, slot); RELEASE_ASSERT(success && slot.isValue()); return slot.getValue(exec, errorName); }
void JSLexicalEnvironment::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot) { JSLexicalEnvironment* thisObject = jsCast<JSLexicalEnvironment*>(cell); ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(thisObject)); if (thisObject->symbolTablePut(exec, propertyName, value, slot.isStrictMode())) return; // We don't call through to JSObject because __proto__ and getter/setter // properties are non-standard extensions that other implementations do not // expose in the lexicalEnvironment object. ASSERT(!thisObject->hasGetterSetterProperties()); thisObject->putOwnDataProperty(exec->vm(), propertyName, value, slot); }
bool JSLexicalEnvironment::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot) { JSLexicalEnvironment* thisObject = jsCast<JSLexicalEnvironment*>(cell); ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(thisObject)); bool shouldThrowReadOnlyError = slot.isStrictMode() || thisObject->isLexicalScope(); bool ignoreReadOnlyErrors = false; bool putResult = false; if (symbolTablePutInvalidateWatchpointSet(thisObject, exec, propertyName, value, shouldThrowReadOnlyError, ignoreReadOnlyErrors, putResult)) return putResult; // We don't call through to JSObject because __proto__ and getter/setter // properties are non-standard extensions that other implementations do not // expose in the lexicalEnvironment object. ASSERT(!thisObject->hasGetterSetterProperties()); return thisObject->putOwnDataProperty(exec->vm(), propertyName, value, slot); }
void JSLexicalEnvironment::getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode) { JSLexicalEnvironment* thisObject = jsCast<JSLexicalEnvironment*>(object); { ConcurrentJITLocker locker(thisObject->symbolTable()->m_lock); SymbolTable::Map::iterator end = thisObject->symbolTable()->end(locker); for (SymbolTable::Map::iterator it = thisObject->symbolTable()->begin(locker); it != end; ++it) { if (it->value.getAttributes() & DontEnum && !shouldIncludeDontEnumProperties(mode)) continue; if (!thisObject->isValid(it->value)) continue; propertyNames.add(Identifier(exec, it->key.get())); } } // Skip the JSEnvironmentRecord implementation of getOwnNonIndexPropertyNames JSObject::getOwnNonIndexPropertyNames(thisObject, exec, propertyNames, mode); }
bool JSLexicalEnvironment::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot) { JSLexicalEnvironment* thisObject = jsCast<JSLexicalEnvironment*>(object); if (thisObject->symbolTableGet(propertyName, slot)) return true; unsigned attributes; if (JSValue value = thisObject->getDirect(exec->vm(), propertyName, attributes)) { slot.setValue(thisObject, attributes, value); return true; } // We don't call through to JSObject because there's no way to give a // lexical environment object getter properties or a prototype. ASSERT(!thisObject->hasGetterSetterProperties()); ASSERT(thisObject->prototype().isNull()); return false; }
// Returns true if we found enough information to terminate optimization. static inline bool abstractAccess(ExecState* exec, JSScope* scope, const Identifier& ident, GetOrPut getOrPut, size_t depth, bool& needsVarInjectionChecks, ResolveOp& op, InitializationMode initializationMode) { if (scope->isJSLexicalEnvironment()) { JSLexicalEnvironment* lexicalEnvironment = jsCast<JSLexicalEnvironment*>(scope); if (ident == exec->propertyNames().arguments) { // We know the property will be at this lexical environment scope, but we don't know how to cache it. op = ResolveOp(Dynamic, 0, 0, 0, 0, 0); return true; } SymbolTable* symbolTable = lexicalEnvironment->symbolTable(); { ConcurrentJSLocker locker(symbolTable->m_lock); auto iter = symbolTable->find(locker, ident.impl()); if (iter != symbolTable->end(locker)) { SymbolTableEntry& entry = iter->value; ASSERT(!entry.isNull()); if (entry.isReadOnly() && getOrPut == Put) { // We know the property will be at this lexical environment scope, but we don't know how to cache it. op = ResolveOp(Dynamic, 0, 0, 0, 0, 0); return true; } op = ResolveOp(makeType(ClosureVar, needsVarInjectionChecks), depth, 0, lexicalEnvironment, entry.watchpointSet(), entry.scopeOffset().offset()); return true; } } if (scope->type() == ModuleEnvironmentType) { JSModuleEnvironment* moduleEnvironment = jsCast<JSModuleEnvironment*>(scope); AbstractModuleRecord* moduleRecord = moduleEnvironment->moduleRecord(); AbstractModuleRecord::Resolution resolution = moduleRecord->resolveImport(exec, ident); if (resolution.type == AbstractModuleRecord::Resolution::Type::Resolved) { AbstractModuleRecord* importedRecord = resolution.moduleRecord; JSModuleEnvironment* importedEnvironment = importedRecord->moduleEnvironment(); SymbolTable* symbolTable = importedEnvironment->symbolTable(); ConcurrentJSLocker locker(symbolTable->m_lock); auto iter = symbolTable->find(locker, resolution.localName.impl()); ASSERT(iter != symbolTable->end(locker)); SymbolTableEntry& entry = iter->value; ASSERT(!entry.isNull()); op = ResolveOp(makeType(ModuleVar, needsVarInjectionChecks), depth, 0, importedEnvironment, entry.watchpointSet(), entry.scopeOffset().offset(), resolution.localName.impl()); return true; } } if (symbolTable->usesNonStrictEval()) needsVarInjectionChecks = true; return false; } if (scope->isGlobalLexicalEnvironment()) { JSGlobalLexicalEnvironment* globalLexicalEnvironment = jsCast<JSGlobalLexicalEnvironment*>(scope); SymbolTable* symbolTable = globalLexicalEnvironment->symbolTable(); ConcurrentJSLocker locker(symbolTable->m_lock); auto iter = symbolTable->find(locker, ident.impl()); if (iter != symbolTable->end(locker)) { SymbolTableEntry& entry = iter->value; ASSERT(!entry.isNull()); if (getOrPut == Put && entry.isReadOnly() && !isInitialization(initializationMode)) { // We know the property will be at global lexical environment, but we don't know how to cache it. op = ResolveOp(Dynamic, 0, 0, 0, 0, 0); return true; } // We can force const Initialization to always go down the fast path. It is provably impossible to construct // a program that needs a var injection check here. You can convince yourself of this as follows: // Any other let/const/class would be a duplicate of this in the global scope, so we would never get here in that situation. // Also, if we had an eval in the global scope that defined a const, it would also be a duplicate of this const, and so it would // also throw an error. Therefore, we're *the only* thing that can assign to this "const" slot for the first (and only) time. Also, // we will never have a Dynamic ResolveType here because if we were inside a "with" statement, that would mean the "const" definition // isn't a global, it would be a local to the "with" block. // We still need to make the slow path correct for when we need to fire a watchpoint. ResolveType resolveType = initializationMode == InitializationMode::ConstInitialization ? GlobalLexicalVar : makeType(GlobalLexicalVar, needsVarInjectionChecks); op = ResolveOp( resolveType, depth, 0, 0, entry.watchpointSet(), reinterpret_cast<uintptr_t>(globalLexicalEnvironment->variableAt(entry.scopeOffset()).slot())); return true; } return false; } if (scope->isGlobalObject()) { JSGlobalObject* globalObject = jsCast<JSGlobalObject*>(scope); { SymbolTable* symbolTable = globalObject->symbolTable(); ConcurrentJSLocker locker(symbolTable->m_lock); auto iter = symbolTable->find(locker, ident.impl()); if (iter != symbolTable->end(locker)) { SymbolTableEntry& entry = iter->value; ASSERT(!entry.isNull()); if (getOrPut == Put && entry.isReadOnly()) { // We know the property will be at global scope, but we don't know how to cache it. op = ResolveOp(Dynamic, 0, 0, 0, 0, 0); return true; } op = ResolveOp( makeType(GlobalVar, needsVarInjectionChecks), depth, 0, 0, entry.watchpointSet(), reinterpret_cast<uintptr_t>(globalObject->variableAt(entry.scopeOffset()).slot())); return true; } } PropertySlot slot(globalObject, PropertySlot::InternalMethodType::VMInquiry); bool hasOwnProperty = globalObject->getOwnPropertySlot(globalObject, exec, ident, slot); if (!hasOwnProperty) { op = ResolveOp(makeType(UnresolvedProperty, needsVarInjectionChecks), 0, 0, 0, 0, 0); return true; } if (!slot.isCacheableValue() || !globalObject->structure()->propertyAccessesAreCacheable() || (globalObject->structure()->hasReadOnlyOrGetterSetterPropertiesExcludingProto() && getOrPut == Put)) { // We know the property will be at global scope, but we don't know how to cache it. ASSERT(!scope->next()); op = ResolveOp(makeType(GlobalProperty, needsVarInjectionChecks), 0, 0, 0, 0, 0); return true; } WatchpointState state = globalObject->structure()->ensurePropertyReplacementWatchpointSet(exec->vm(), slot.cachedOffset())->state(); if (state == IsWatched && getOrPut == Put) { // The field exists, but because the replacement watchpoint is still intact. This is // kind of dangerous. We have two options: // 1) Invalidate the watchpoint set. That would work, but it's possible that this code // path never executes - in which case this would be unwise. // 2) Have the invalidation happen at run-time. All we have to do is leave the code // uncached. The only downside is slightly more work when this does execute. // We go with option (2) here because it seems less evil. op = ResolveOp(makeType(GlobalProperty, needsVarInjectionChecks), depth, 0, 0, 0, 0); } else op = ResolveOp(makeType(GlobalProperty, needsVarInjectionChecks), depth, globalObject->structure(), 0, 0, slot.cachedOffset()); return true; } op = ResolveOp(Dynamic, 0, 0, 0, 0, 0); return true; }