1/* 2 * Copyright (C) 2008, 2009 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 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of 14 * its contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY 18 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 20 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY 21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 22 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 24 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29#include "config.h" 30#include "JSActivation.h" 31 32#include "Arguments.h" 33#include "Interpreter.h" 34#include "JSFunction.h" 35 36namespace JSC { 37 38ASSERT_CLASS_FITS_IN_CELL(JSActivation); 39 40const ClassInfo JSActivation::s_info = { "JSActivation", &Base::s_info, 0, 0 }; 41 42JSActivation::JSActivation(CallFrame* callFrame, FunctionExecutable* functionExecutable) 43 : Base(callFrame->globalData(), callFrame->globalData().activationStructure.get(), functionExecutable->symbolTable(), callFrame->registers()) 44 , m_numParametersMinusThis(static_cast<int>(functionExecutable->parameterCount())) 45 , m_numCapturedVars(functionExecutable->capturedVariableCount()) 46 , m_requiresDynamicChecks(functionExecutable->usesEval()) 47 , m_argumentsRegister(functionExecutable->generatedBytecode().argumentsRegister()) 48{ 49 ASSERT(inherits(&s_info)); 50 51 // We have to manually ref and deref the symbol table as JSVariableObject 52 // doesn't know about SharedSymbolTable 53 static_cast<SharedSymbolTable*>(m_symbolTable)->ref(); 54} 55 56JSActivation::~JSActivation() 57{ 58 static_cast<SharedSymbolTable*>(m_symbolTable)->deref(); 59} 60 61void JSActivation::markChildren(MarkStack& markStack) 62{ 63 Base::markChildren(markStack); 64 65 // No need to mark our registers if they're still in the RegisterFile. 66 WriteBarrier<Unknown>* registerArray = m_registerArray.get(); 67 if (!registerArray) 68 return; 69 70 markStack.appendValues(registerArray, m_numParametersMinusThis); 71 72 // Skip the call frame, which sits between the parameters and vars. 73 markStack.appendValues(registerArray + m_numParametersMinusThis + RegisterFile::CallFrameHeaderSize, m_numCapturedVars, MayContainNullValues); 74} 75 76inline bool JSActivation::symbolTableGet(const Identifier& propertyName, PropertySlot& slot) 77{ 78 SymbolTableEntry entry = symbolTable().inlineGet(propertyName.impl()); 79 if (entry.isNull()) 80 return false; 81 if (entry.getIndex() >= m_numCapturedVars) 82 return false; 83 84 slot.setValue(registerAt(entry.getIndex()).get()); 85 return true; 86} 87 88inline bool JSActivation::symbolTablePut(JSGlobalData& globalData, const Identifier& propertyName, JSValue value) 89{ 90 ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this)); 91 92 SymbolTableEntry entry = symbolTable().inlineGet(propertyName.impl()); 93 if (entry.isNull()) 94 return false; 95 if (entry.isReadOnly()) 96 return true; 97 if (entry.getIndex() >= m_numCapturedVars) 98 return false; 99 100 registerAt(entry.getIndex()).set(globalData, this, value); 101 return true; 102} 103 104void JSActivation::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode) 105{ 106 SymbolTable::const_iterator end = symbolTable().end(); 107 for (SymbolTable::const_iterator it = symbolTable().begin(); it != end; ++it) { 108 if (it->second.getAttributes() & DontEnum && mode != IncludeDontEnumProperties) 109 continue; 110 if (it->second.getIndex() >= m_numCapturedVars) 111 continue; 112 propertyNames.add(Identifier(exec, it->first.get())); 113 } 114 // Skip the JSVariableObject implementation of getOwnPropertyNames 115 JSObject::getOwnPropertyNames(exec, propertyNames, mode); 116} 117 118inline bool JSActivation::symbolTablePutWithAttributes(JSGlobalData& globalData, const Identifier& propertyName, JSValue value, unsigned attributes) 119{ 120 ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this)); 121 122 SymbolTable::iterator iter = symbolTable().find(propertyName.impl()); 123 if (iter == symbolTable().end()) 124 return false; 125 SymbolTableEntry& entry = iter->second; 126 ASSERT(!entry.isNull()); 127 if (entry.getIndex() >= m_numCapturedVars) 128 return false; 129 130 entry.setAttributes(attributes); 131 registerAt(entry.getIndex()).set(globalData, this, value); 132 return true; 133} 134 135bool JSActivation::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) 136{ 137 if (propertyName == exec->propertyNames().arguments) { 138 slot.setCustom(this, getArgumentsGetter()); 139 return true; 140 } 141 142 if (symbolTableGet(propertyName, slot)) 143 return true; 144 145 if (WriteBarrierBase<Unknown>* location = getDirectLocation(exec->globalData(), propertyName)) { 146 slot.setValue(location->get()); 147 return true; 148 } 149 150 // We don't call through to JSObject because there's no way to give an 151 // activation object getter properties or a prototype. 152 ASSERT(!hasGetterSetterProperties()); 153 ASSERT(prototype().isNull()); 154 return false; 155} 156 157void JSActivation::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot) 158{ 159 ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this)); 160 161 if (symbolTablePut(exec->globalData(), propertyName, value)) 162 return; 163 164 // We don't call through to JSObject because __proto__ and getter/setter 165 // properties are non-standard extensions that other implementations do not 166 // expose in the activation object. 167 ASSERT(!hasGetterSetterProperties()); 168 putDirect(exec->globalData(), propertyName, value, 0, true, slot); 169} 170 171// FIXME: Make this function honor ReadOnly (const) and DontEnum 172void JSActivation::putWithAttributes(ExecState* exec, const Identifier& propertyName, JSValue value, unsigned attributes) 173{ 174 ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this)); 175 176 if (symbolTablePutWithAttributes(exec->globalData(), propertyName, value, attributes)) 177 return; 178 179 // We don't call through to JSObject because __proto__ and getter/setter 180 // properties are non-standard extensions that other implementations do not 181 // expose in the activation object. 182 ASSERT(!hasGetterSetterProperties()); 183 PutPropertySlot slot; 184 JSObject::putWithAttributes(exec, propertyName, value, attributes, true, slot); 185} 186 187bool JSActivation::deleteProperty(ExecState* exec, const Identifier& propertyName) 188{ 189 if (propertyName == exec->propertyNames().arguments) 190 return false; 191 192 return Base::deleteProperty(exec, propertyName); 193} 194 195JSObject* JSActivation::toThisObject(ExecState* exec) const 196{ 197 return exec->globalThisValue(); 198} 199 200JSValue JSActivation::toStrictThisObject(ExecState*) const 201{ 202 return jsNull(); 203} 204 205bool JSActivation::isDynamicScope(bool& requiresDynamicChecks) const 206{ 207 requiresDynamicChecks = m_requiresDynamicChecks; 208 return false; 209} 210 211JSValue JSActivation::argumentsGetter(ExecState*, JSValue slotBase, const Identifier&) 212{ 213 JSActivation* activation = asActivation(slotBase); 214 CallFrame* callFrame = CallFrame::create(reinterpret_cast<Register*>(activation->m_registers)); 215 int argumentsRegister = activation->m_argumentsRegister; 216 if (JSValue arguments = callFrame->uncheckedR(argumentsRegister).jsValue()) 217 return arguments; 218 int realArgumentsRegister = unmodifiedArgumentsRegister(argumentsRegister); 219 220 JSValue arguments = JSValue(new (callFrame) Arguments(callFrame)); 221 callFrame->uncheckedR(argumentsRegister) = arguments; 222 callFrame->uncheckedR(realArgumentsRegister) = arguments; 223 224 ASSERT(callFrame->uncheckedR(realArgumentsRegister).jsValue().inherits(&Arguments::s_info)); 225 return callFrame->uncheckedR(realArgumentsRegister).jsValue(); 226} 227 228// These two functions serve the purpose of isolating the common case from a 229// PIC branch. 230 231PropertySlot::GetValueFunc JSActivation::getArgumentsGetter() 232{ 233 return argumentsGetter; 234} 235 236} // namespace JSC 237