1 /*

     2  * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.

     3  * Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>

     4  *

     5  * Redistribution and use in source and binary forms, with or without

     6  * modification, are permitted provided that the following conditions

     7  * are met:

     8  *

     9  * 1.  Redistributions of source code must retain the above copyright

    10  *     notice, this list of conditions and the following disclaimer.

    11  * 2.  Redistributions in binary form must reproduce the above copyright

    12  *     notice, this list of conditions and the following disclaimer in the

    13  *     documentation and/or other materials provided with the distribution.

    14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

    15  *     its contributors may be used to endorse or promote products derived

    16  *     from this software without specific prior written permission.

    17  *

    18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

    19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

    22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

    27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    28  */

    29 

    30 #include "config.h"

    31 #include "Interpreter.h"

    32 

    33 #include "Arguments.h"

    34 #include "BatchedTransitionOptimizer.h"

    35 #include "CallFrame.h"

    36 #include "CallFrameClosure.h"

    37 #include "CodeBlock.h"

    38 #include "Collector.h"

    39 #include "Debugger.h"

    40 #include "DebuggerCallFrame.h"

    41 #include "EvalCodeCache.h"

    42 #include "ExceptionHelpers.h"

    43 #include "GetterSetter.h"

    44 #include "GlobalEvalFunction.h"

    45 #include "JSActivation.h"

    46 #include "JSArray.h"

    47 #include "JSByteArray.h"

    48 #include "JSFunction.h"

    49 #include "JSNotAnObject.h"

    50 #include "JSPropertyNameIterator.h"

    51 #include "LiteralParser.h"

    52 #include "JSStaticScopeObject.h"

    53 #include "JSString.h"

    54 #include "ObjectPrototype.h"

    55 #include "Operations.h"

    56 #include "Parser.h"

    57 #include "Profiler.h"

    58 #include "RegExpObject.h"

    59 #include "RegExpPrototype.h"

    60 #include "Register.h"

    61 #include "SamplingTool.h"

    62 #include <limits.h>

    63 #include <stdio.h>

    64 #include <wtf/Threading.h>

    65 

    66 #if ENABLE(JIT)

    67 #include "JIT.h"

    68 #endif

    69 

    70 using namespace std;

    71 

    72 namespace JSC {

    73 

    74 // Returns the depth of the scope chain within a given call frame.

    75 static int depth(CodeBlock* codeBlock, ScopeChain& sc)

    76 {

    77     if (!codeBlock->needsFullScopeChain())

    78         return 0;

    79     return sc.localDepth();

    80 }

    81 

    82 #if ENABLE(INTERPRETER) 

    83 NEVER_INLINE bool Interpreter::resolve(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

    84 {

    85     int dst = vPC[1].u.operand;

    86     int property = vPC[2].u.operand;

    87 

    88     ScopeChainNode* scopeChain = callFrame->scopeChain();

    89     ScopeChainIterator iter = scopeChain->begin();

    90     ScopeChainIterator end = scopeChain->end();

    91     ASSERT(iter != end);

    92 

    93     CodeBlock* codeBlock = callFrame->codeBlock();

    94     Identifier& ident = codeBlock->identifier(property);

    95     do {

    96         JSObject* o = *iter;

    97         PropertySlot slot(o);

    98         if (o->getPropertySlot(callFrame, ident, slot)) {

    99             JSValue result = slot.getValue(callFrame, ident);

   100             exceptionValue = callFrame->globalData().exception;

   101             if (exceptionValue)

   102                 return false;

   103             callFrame->r(dst) = JSValue(result);

   104             return true;

   105         }

   106     } while (++iter != end);

   107     exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

   108     return false;

   109 }

   110 

   111 NEVER_INLINE bool Interpreter::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

   112 {

   113     CodeBlock* codeBlock = callFrame->codeBlock();

   114 

   115     int dst = vPC[1].u.operand;

   116     int property = vPC[2].u.operand;

   117     int skip = vPC[3].u.operand;

   118 

   119     ScopeChainNode* scopeChain = callFrame->scopeChain();

   120     ScopeChainIterator iter = scopeChain->begin();

   121     ScopeChainIterator end = scopeChain->end();

   122     ASSERT(iter != end);

   123     while (skip--) {

   124         ++iter;

   125         ASSERT(iter != end);

   126     }

   127     Identifier& ident = codeBlock->identifier(property);

   128     do {

   129         JSObject* o = *iter;

   130         PropertySlot slot(o);

   131         if (o->getPropertySlot(callFrame, ident, slot)) {

   132             JSValue result = slot.getValue(callFrame, ident);

   133             exceptionValue = callFrame->globalData().exception;

   134             if (exceptionValue)

   135                 return false;

   136             callFrame->r(dst) = JSValue(result);

   137             return true;

   138         }

   139     } while (++iter != end);

   140     exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

   141     return false;

   142 }

   143 

   144 NEVER_INLINE bool Interpreter::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

   145 {

   146     int dst = vPC[1].u.operand;

   147     JSGlobalObject* globalObject = static_cast<JSGlobalObject*>(vPC[2].u.jsCell);

   148     ASSERT(globalObject->isGlobalObject());

   149     int property = vPC[3].u.operand;

   150     Structure* structure = vPC[4].u.structure;

   151     int offset = vPC[5].u.operand;

   152 

   153     if (structure == globalObject->structure()) {

   154         callFrame->r(dst) = JSValue(globalObject->getDirectOffset(offset));

   155         return true;

   156     }

   157 

   158     CodeBlock* codeBlock = callFrame->codeBlock();

   159     Identifier& ident = codeBlock->identifier(property);

   160     PropertySlot slot(globalObject);

   161     if (globalObject->getPropertySlot(callFrame, ident, slot)) {

   162         JSValue result = slot.getValue(callFrame, ident);

   163         if (slot.isCacheableValue() && !globalObject->structure()->isUncacheableDictionary() && slot.slotBase() == globalObject) {

   164             if (vPC[4].u.structure)

   165                 vPC[4].u.structure->deref();

   166             globalObject->structure()->ref();

   167             vPC[4] = globalObject->structure();

   168             vPC[5] = slot.cachedOffset();

   169             callFrame->r(dst) = JSValue(result);

   170             return true;

   171         }

   172 

   173         exceptionValue = callFrame->globalData().exception;

   174         if (exceptionValue)

   175             return false;

   176         callFrame->r(dst) = JSValue(result);

   177         return true;

   178     }

   179 

   180     exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

   181     return false;

   182 }

   183 

   184 NEVER_INLINE bool Interpreter::resolveGlobalDynamic(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

   185 {

   186     int dst = vPC[1].u.operand;

   187     JSGlobalObject* globalObject = static_cast<JSGlobalObject*>(vPC[2].u.jsCell);

   188     ASSERT(globalObject->isGlobalObject());

   189     int property = vPC[3].u.operand;

   190     Structure* structure = vPC[4].u.structure;

   191     int offset = vPC[5].u.operand;

   192     CodeBlock* codeBlock = callFrame->codeBlock();

   193     int skip = vPC[6].u.operand;

   194     

   195     ScopeChainNode* scopeChain = callFrame->scopeChain();

   196     ScopeChainIterator iter = scopeChain->begin();

   197     ScopeChainIterator end = scopeChain->end();

   198     ASSERT(iter != end);

   199     while (skip--) {

   200         JSObject* o = *iter;

   201         if (o->hasCustomProperties()) {

   202             Identifier& ident = codeBlock->identifier(property);

   203             do {

   204                 PropertySlot slot(o);

   205                 if (o->getPropertySlot(callFrame, ident, slot)) {

   206                     JSValue result = slot.getValue(callFrame, ident);

   207                     exceptionValue = callFrame->globalData().exception;

   208                     if (exceptionValue)

   209                         return false;

   210                     callFrame->r(dst) = JSValue(result);

   211                     return true;

   212                 }

   213                 if (iter == end)

   214                     break;

   215                 o = *iter;

   216                 ++iter;

   217             } while (true);

   218             exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

   219             return false;

   220         }

   221         ++iter;

   222     }

   223     

   224     if (structure == globalObject->structure()) {

   225         callFrame->r(dst) = JSValue(globalObject->getDirectOffset(offset));

   226         return true;

   227     }

   228 

   229     Identifier& ident = codeBlock->identifier(property);

   230     PropertySlot slot(globalObject);

   231     if (globalObject->getPropertySlot(callFrame, ident, slot)) {

   232         JSValue result = slot.getValue(callFrame, ident);

   233         if (slot.isCacheableValue() && !globalObject->structure()->isUncacheableDictionary() && slot.slotBase() == globalObject) {

   234             if (vPC[4].u.structure)

   235                 vPC[4].u.structure->deref();

   236             globalObject->structure()->ref();

   237             vPC[4] = globalObject->structure();

   238             vPC[5] = slot.cachedOffset();

   239             callFrame->r(dst) = JSValue(result);

   240             return true;

   241         }

   242         

   243         exceptionValue = callFrame->globalData().exception;

   244         if (exceptionValue)

   245             return false;

   246         callFrame->r(dst) = JSValue(result);

   247         return true;

   248     }

   249     

   250     exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

   251     return false;

   252 }

   253 

   254 NEVER_INLINE void Interpreter::resolveBase(CallFrame* callFrame, Instruction* vPC)

   255 {

   256     int dst = vPC[1].u.operand;

   257     int property = vPC[2].u.operand;

   258     callFrame->r(dst) = JSValue(JSC::resolveBase(callFrame, callFrame->codeBlock()->identifier(property), callFrame->scopeChain()));

   259 }

   260 

   261 NEVER_INLINE bool Interpreter::resolveBaseAndProperty(CallFrame* callFrame, Instruction* vPC, JSValue& exceptionValue)

   262 {

   263     int baseDst = vPC[1].u.operand;

   264     int propDst = vPC[2].u.operand;

   265     int property = vPC[3].u.operand;

   266 

   267     ScopeChainNode* scopeChain = callFrame->scopeChain();

   268     ScopeChainIterator iter = scopeChain->begin();

   269     ScopeChainIterator end = scopeChain->end();

   270 

   271     // FIXME: add scopeDepthIsZero optimization

   272 

   273     ASSERT(iter != end);

   274 

   275     CodeBlock* codeBlock = callFrame->codeBlock();

   276     Identifier& ident = codeBlock->identifier(property);

   277     JSObject* base;

   278     do {

   279         base = *iter;

   280         PropertySlot slot(base);

   281         if (base->getPropertySlot(callFrame, ident, slot)) {

   282             JSValue result = slot.getValue(callFrame, ident);

   283             exceptionValue = callFrame->globalData().exception;

   284             if (exceptionValue)

   285                 return false;

   286             callFrame->r(propDst) = JSValue(result);

   287             callFrame->r(baseDst) = JSValue(base);

   288             return true;

   289         }

   290         ++iter;

   291     } while (iter != end);

   292 

   293     exceptionValue = createUndefinedVariableError(callFrame, ident, vPC - codeBlock->instructions().begin(), codeBlock);

   294     return false;

   295 }

   296 

   297 #endif // ENABLE(INTERPRETER)

   298 

   299 ALWAYS_INLINE CallFrame* Interpreter::slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, CallFrame* callFrame, size_t registerOffset, int argc)

   300 {

   301     Register* r = callFrame->registers();

   302     Register* newEnd = r + registerOffset + newCodeBlock->m_numCalleeRegisters;

   303 

   304     if (LIKELY(argc == newCodeBlock->m_numParameters)) { // correct number of arguments

   305         if (UNLIKELY(!registerFile->grow(newEnd)))

   306             return 0;

   307         r += registerOffset;

   308     } else if (argc < newCodeBlock->m_numParameters) { // too few arguments -- fill in the blanks

   309         size_t omittedArgCount = newCodeBlock->m_numParameters - argc;

   310         registerOffset += omittedArgCount;

   311         newEnd += omittedArgCount;

   312         if (!registerFile->grow(newEnd))

   313             return 0;

   314         r += registerOffset;

   315 

   316         Register* argv = r - RegisterFile::CallFrameHeaderSize - omittedArgCount;

   317         for (size_t i = 0; i < omittedArgCount; ++i)

   318             argv[i] = jsUndefined();

   319     } else { // too many arguments -- copy expected arguments, leaving the extra arguments behind

   320         size_t numParameters = newCodeBlock->m_numParameters;

   321         registerOffset += numParameters;

   322         newEnd += numParameters;

   323 

   324         if (!registerFile->grow(newEnd))

   325             return 0;

   326         r += registerOffset;

   327 

   328         Register* argv = r - RegisterFile::CallFrameHeaderSize - numParameters - argc;

   329         for (size_t i = 0; i < numParameters; ++i)

   330             argv[i + argc] = argv[i];

   331     }

   332 

   333     return CallFrame::create(r);

   334 }

   335 

   336 #if ENABLE(INTERPRETER)

   337 static NEVER_INLINE bool isInvalidParamForIn(CallFrame* callFrame, CodeBlock* codeBlock, const Instruction* vPC, JSValue value, JSValue& exceptionData)

   338 {

   339     if (value.isObject())

   340         return false;

   341     exceptionData = createInvalidParamError(callFrame, "in" , value, vPC - codeBlock->instructions().begin(), codeBlock);

   342     return true;

   343 }

   344 

   345 static NEVER_INLINE bool isInvalidParamForInstanceOf(CallFrame* callFrame, CodeBlock* codeBlock, const Instruction* vPC, JSValue value, JSValue& exceptionData)

   346 {

   347     if (value.isObject() && asObject(value)->structure()->typeInfo().implementsHasInstance())

   348         return false;

   349     exceptionData = createInvalidParamError(callFrame, "instanceof" , value, vPC - codeBlock->instructions().begin(), codeBlock);

   350     return true;

   351 }

   352 #endif

   353 

   354 NEVER_INLINE JSValue Interpreter::callEval(CallFrame* callFrame, RegisterFile* registerFile, Register* argv, int argc, int registerOffset, JSValue& exceptionValue)

   355 {

   356     if (argc < 2)

   357         return jsUndefined();

   358 

   359     JSValue program = argv[1].jsValue();

   360 

   361     if (!program.isString())

   362         return program;

   363 

   364     UString programSource = asString(program)->value(callFrame);

   365     if (callFrame->hadException())

   366         return JSValue();

   367 

   368     LiteralParser preparser(callFrame, programSource, LiteralParser::NonStrictJSON);

   369     if (JSValue parsedObject = preparser.tryLiteralParse())

   370         return parsedObject;

   371 

   372     ScopeChainNode* scopeChain = callFrame->scopeChain();

   373     CodeBlock* codeBlock = callFrame->codeBlock();

   374     RefPtr<EvalExecutable> eval = codeBlock->evalCodeCache().get(callFrame, programSource, scopeChain, exceptionValue);

   375 

   376     JSValue result = jsUndefined();

   377     if (eval)

   378         result = callFrame->globalData().interpreter->execute(eval.get(), callFrame, callFrame->r(codeBlock->thisRegister()).jsValue().toThisObject(callFrame), callFrame->registers() - registerFile->start() + registerOffset, scopeChain, &exceptionValue);

   379 

   380     return result;

   381 }

   382 

   383 Interpreter::Interpreter()

   384     : m_sampleEntryDepth(0)

   385     , m_reentryDepth(0)

   386 {

   387 #if ENABLE(COMPUTED_GOTO_INTERPRETER)

   388     privateExecute(InitializeAndReturn, 0, 0, 0);

   389 

   390     for (int i = 0; i < numOpcodeIDs; ++i)

   391         m_opcodeIDTable.add(m_opcodeTable[i], static_cast<OpcodeID>(i));

   392 #endif // ENABLE(COMPUTED_GOTO_INTERPRETER)

   393 

   394 #if ENABLE(OPCODE_SAMPLING)

   395     enableSampler();

   396 #endif

   397 }

   398 

   399 #ifndef NDEBUG

   400 

   401 void Interpreter::dumpCallFrame(CallFrame* callFrame)

   402 {

   403     callFrame->codeBlock()->dump(callFrame);

   404     dumpRegisters(callFrame);

   405 }

   406 

   407 void Interpreter::dumpRegisters(CallFrame* callFrame)

   408 {

   409     printf("Register frame: \n\n");

   410     printf("-----------------------------------------------------------------------------\n");

   411     printf("            use            |   address  |                value               \n");

   412     printf("-----------------------------------------------------------------------------\n");

   413 

   414     CodeBlock* codeBlock = callFrame->codeBlock();

   415     RegisterFile* registerFile = &callFrame->scopeChain()->globalObject->globalData()->interpreter->registerFile();

   416     const Register* it;

   417     const Register* end;

   418     JSValue v;

   419 

   420     if (codeBlock->codeType() == GlobalCode) {

   421         it = registerFile->lastGlobal();

   422         end = it + registerFile->numGlobals();

   423         while (it != end) {

   424             v = (*it).jsValue();

   425 #if USE(JSVALUE32_64)

   426             printf("[global var]               | %10p | %-16s 0x%llx \n", it, v.description(), JSValue::encode(v));

   427 #else

   428             printf("[global var]               | %10p | %-16s %p \n", it, v.description(), JSValue::encode(v));

   429 #endif

   430             ++it;

   431         }

   432         printf("-----------------------------------------------------------------------------\n");

   433     }

   434     

   435     it = callFrame->registers() - RegisterFile::CallFrameHeaderSize - codeBlock->m_numParameters;

   436     v = (*it).jsValue();

   437 #if USE(JSVALUE32_64)

   438     printf("[this]                     | %10p | %-16s 0x%llx \n", it, v.description(), JSValue::encode(v)); ++it;

   439 #else

   440     printf("[this]                     | %10p | %-16s %p \n", it, v.description(), JSValue::encode(v)); ++it;

   441 #endif

   442     end = it + max(codeBlock->m_numParameters - 1, 0); // - 1 to skip "this"

   443     if (it != end) {

   444         do {

   445             v = (*it).jsValue();

   446 #if USE(JSVALUE32_64)

   447             printf("[param]                    | %10p | %-16s 0x%llx \n", it, v.description(), JSValue::encode(v));

   448 #else

   449             printf("[param]                    | %10p | %-16s %p \n", it, v.description(), JSValue::encode(v));

   450 #endif

   451             ++it;

   452         } while (it != end);

   453     }

   454     printf("-----------------------------------------------------------------------------\n");

   455     printf("[CodeBlock]                | %10p | %p \n", it, (*it).codeBlock()); ++it;

   456     printf("[ScopeChain]               | %10p | %p \n", it, (*it).scopeChain()); ++it;

   457     printf("[CallerRegisters]          | %10p | %d \n", it, (*it).i()); ++it;

   458     printf("[ReturnPC]                 | %10p | %p \n", it, (*it).vPC()); ++it;

   459     printf("[ArgumentCount]            | %10p | %d \n", it, (*it).i()); ++it;

   460     printf("[Callee]                   | %10p | %p \n", it, (*it).function()); ++it;

   461     printf("-----------------------------------------------------------------------------\n");

   462 

   463     int registerCount = 0;

   464 

   465     end = it + codeBlock->m_numVars;

   466     if (it != end) {

   467         do {

   468             v = (*it).jsValue();

   469 #if USE(JSVALUE32_64)

   470             printf("[r%2d]                      | %10p | %-16s 0x%llx \n", registerCount, it, v.description(), JSValue::encode(v));

   471 #else

   472             printf("[r%2d]                      | %10p | %-16s %p \n", registerCount, it, v.description(), JSValue::encode(v));

   473 #endif

   474             ++it;

   475             ++registerCount;

   476         } while (it != end);

   477     }

   478     printf("-----------------------------------------------------------------------------\n");

   479 

   480     end = it + codeBlock->m_numCalleeRegisters - codeBlock->m_numVars;

   481     if (it != end) {

   482         do {

   483             v = (*it).jsValue();

   484 #if USE(JSVALUE32_64)

   485             printf("[r%2d]                      | %10p | %-16s 0x%llx \n", registerCount, it, v.description(), JSValue::encode(v));

   486 #else

   487             printf("[r%2d]                      | %10p | %-16s %p \n", registerCount, it, v.description(), JSValue::encode(v));

   488 #endif

   489             ++it;

   490             ++registerCount;

   491         } while (it != end);

   492     }

   493     printf("-----------------------------------------------------------------------------\n");

   494 }

   495 

   496 #endif

   497 

   498 bool Interpreter::isOpcode(Opcode opcode)

   499 {

   500 #if ENABLE(COMPUTED_GOTO_INTERPRETER)

   501     return opcode != HashTraits<Opcode>::emptyValue()

   502         && !HashTraits<Opcode>::isDeletedValue(opcode)

   503         && m_opcodeIDTable.contains(opcode);

   504 #else

   505     return opcode >= 0 && opcode <= op_end;

   506 #endif

   507 }

   508 

   509 NEVER_INLINE bool Interpreter::unwindCallFrame(CallFrame*& callFrame, JSValue exceptionValue, unsigned& bytecodeOffset, CodeBlock*& codeBlock)

   510 {

   511     CodeBlock* oldCodeBlock = codeBlock;

   512     ScopeChainNode* scopeChain = callFrame->scopeChain();

   513 

   514     if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {

   515         DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);

   516         if (callFrame->callee())

   517             debugger->returnEvent(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine());

   518         else

   519             debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine());

   520     }

   521 

   522     if (Profiler* profiler = *Profiler::enabledProfilerReference()) {

   523         if (callFrame->callee())

   524             profiler->didExecute(callFrame, callFrame->callee());

   525         else

   526             profiler->didExecute(callFrame, codeBlock->ownerExecutable()->sourceURL(), codeBlock->ownerExecutable()->lineNo());

   527     }

   528 

   529     // If this call frame created an activation or an 'arguments' object, tear it off.

   530     if (oldCodeBlock->codeType() == FunctionCode && oldCodeBlock->needsFullScopeChain()) {

   531         while (!scopeChain->object->inherits(&JSActivation::info))

   532             scopeChain = scopeChain->pop();

   533         JSActivation* activation = asActivation(scopeChain->object);

   534         activation->copyRegisters();

   535         if (JSValue arguments = callFrame->r(unmodifiedArgumentsRegister(oldCodeBlock->argumentsRegister())).jsValue())

   536             asArguments(arguments)->setActivation(activation);

   537     } else if (oldCodeBlock->usesArguments()) {

   538         if (JSValue arguments = callFrame->r(unmodifiedArgumentsRegister(oldCodeBlock->argumentsRegister())).jsValue())

   539             asArguments(arguments)->copyRegisters();

   540     }

   541 

   542     if (oldCodeBlock->needsFullScopeChain())

   543         scopeChain->deref();

   544 

   545     CallFrame* callerFrame = callFrame->callerFrame();

   546     if (callerFrame->hasHostCallFrameFlag())

   547         return false;

   548 

   549     codeBlock = callerFrame->codeBlock();

   550 #if ENABLE(JIT) && ENABLE(INTERPRETER)

   551     if (callerFrame->globalData().canUseJIT())

   552         bytecodeOffset = codeBlock->bytecodeOffset(callerFrame, callFrame->returnPC());

   553     else

   554         bytecodeOffset = codeBlock->bytecodeOffset(callerFrame, callFrame->returnVPC());

   555 #elif ENABLE(JIT)

   556     bytecodeOffset = codeBlock->bytecodeOffset(callerFrame, callFrame->returnPC());

   557 #else

   558     bytecodeOffset = codeBlock->bytecodeOffset(callerFrame, callFrame->returnVPC());

   559 #endif

   560 

   561     callFrame = callerFrame;

   562     return true;

   563 }

   564 

   565 NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSValue& exceptionValue, unsigned bytecodeOffset, bool explicitThrow)

   566 {

   567     // Set up the exception object

   568 

   569     CodeBlock* codeBlock = callFrame->codeBlock();

   570     if (exceptionValue.isObject()) {

   571         JSObject* exception = asObject(exceptionValue);

   572         if (exception->isNotAnObjectErrorStub()) {

   573             exception = createNotAnObjectError(callFrame, static_cast<JSNotAnObjectErrorStub*>(exception), bytecodeOffset, codeBlock);

   574             exceptionValue = exception;

   575         } else {

   576             if (!hasErrorInfo(callFrame, exception)) {

   577                 if (explicitThrow) {

   578                     int startOffset = 0;

   579                     int endOffset = 0;

   580                     int divotPoint = 0;

   581                     int line = codeBlock->expressionRangeForBytecodeOffset(callFrame, bytecodeOffset, divotPoint, startOffset, endOffset);

   582                     addErrorInfo(callFrame, exception, line, codeBlock->ownerExecutable()->source(), divotPoint, startOffset, endOffset, false);

   583                 } else

   584                     addErrorInfo(callFrame, exception, codeBlock->lineNumberForBytecodeOffset(callFrame, bytecodeOffset), codeBlock->ownerExecutable()->source());

   585             }

   586 

   587             ComplType exceptionType = exception->exceptionType();

   588             if (exceptionType == Interrupted || exceptionType == Terminated) {

   589                 while (unwindCallFrame(callFrame, exceptionValue, bytecodeOffset, codeBlock)) {

   590                     // Don't need handler checks or anything, we just want to unroll all the JS callframes possible.

   591                 }

   592                 return 0;

   593             }

   594         }

   595     }

   596 

   597     if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {

   598         DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);

   599         bool hasHandler = codeBlock->handlerForBytecodeOffset(bytecodeOffset);

   600         debugger->exception(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->lineNumberForBytecodeOffset(callFrame, bytecodeOffset), hasHandler);

   601     }

   602 

   603     // If we throw in the middle of a call instruction, we need to notify

   604     // the profiler manually that the call instruction has returned, since

   605     // we'll never reach the relevant op_profile_did_call.

   606     if (Profiler* profiler = *Profiler::enabledProfilerReference()) {

   607 #if ENABLE(INTERPRETER)

   608         if (!callFrame->globalData().canUseJIT()) {

   609             // FIXME: Why 8? - work out what this magic value is, replace the constant with something more helpful.

   610             if (isCallBytecode(codeBlock->instructions()[bytecodeOffset].u.opcode))

   611                 profiler->didExecute(callFrame, callFrame->r(codeBlock->instructions()[bytecodeOffset + 1].u.operand).jsValue());

   612             else if (codeBlock->instructions().size() > (bytecodeOffset + 8) && codeBlock->instructions()[bytecodeOffset + 8].u.opcode == getOpcode(op_construct))

   613                 profiler->didExecute(callFrame, callFrame->r(codeBlock->instructions()[bytecodeOffset + 9].u.operand).jsValue());

   614         }

   615 #if ENABLE(JIT)

   616         else

   617 #endif

   618 #endif

   619 #if ENABLE(JIT)

   620         {

   621             int functionRegisterIndex;

   622             if (codeBlock->functionRegisterForBytecodeOffset(bytecodeOffset, functionRegisterIndex))

   623                 profiler->didExecute(callFrame, callFrame->r(functionRegisterIndex).jsValue());

   624         }

   625 #endif

   626     }

   627 

   628     // Calculate an exception handler vPC, unwinding call frames as necessary.

   629 

   630     HandlerInfo* handler = 0;

   631     while (!(handler = codeBlock->handlerForBytecodeOffset(bytecodeOffset))) {

   632         if (!unwindCallFrame(callFrame, exceptionValue, bytecodeOffset, codeBlock))

   633             return 0;

   634     }

   635 

   636     // Shrink the JS stack, in case stack overflow made it huge.

   637     m_registerFile.shrink(callFrame->registers() + callFrame->codeBlock()->m_numCalleeRegisters);

   638 

   639     // Unwind the scope chain within the exception handler's call frame.

   640     ScopeChainNode* scopeChain = callFrame->scopeChain();

   641     ScopeChain sc(scopeChain);

   642     int scopeDelta = depth(codeBlock, sc) - handler->scopeDepth;

   643     ASSERT(scopeDelta >= 0);

   644     while (scopeDelta--)

   645         scopeChain = scopeChain->pop();

   646     callFrame->setScopeChain(scopeChain);

   647 

   648     return handler;

   649 }

   650 

   651 JSValue Interpreter::execute(ProgramExecutable* program, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj, JSValue* exception)

   652 {

   653     ASSERT(!scopeChain->globalData->exception);

   654 

   655     if (m_reentryDepth >= MaxSmallThreadReentryDepth) {

   656         if (m_reentryDepth >= callFrame->globalData().maxReentryDepth) {

   657             *exception = createStackOverflowError(callFrame);

   658             return jsNull();

   659         }

   660     }

   661 

   662     JSObject* error = program->compile(callFrame, scopeChain);

   663     if (error) {

   664         *exception = error;

   665         return jsNull();

   666     }

   667     CodeBlock* codeBlock = &program->generatedBytecode();

   668 

   669     Register* oldEnd = m_registerFile.end();

   670     Register* newEnd = oldEnd + codeBlock->m_numParameters + RegisterFile::CallFrameHeaderSize + codeBlock->m_numCalleeRegisters;

   671     if (!m_registerFile.grow(newEnd)) {

   672         *exception = createStackOverflowError(callFrame);

   673         return jsNull();

   674     }

   675 

   676     JSGlobalObject* lastGlobalObject = m_registerFile.globalObject();

   677     JSGlobalObject* globalObject = callFrame->dynamicGlobalObject();

   678     globalObject->copyGlobalsTo(m_registerFile);

   679 

   680     CallFrame* newCallFrame = CallFrame::create(oldEnd + codeBlock->m_numParameters + RegisterFile::CallFrameHeaderSize);

   681     ASSERT(codeBlock->m_numParameters == 1); // 1 parameter for 'this'.

   682     newCallFrame->init(codeBlock, 0, scopeChain, CallFrame::noCaller(), codeBlock->m_numParameters, 0);

   683     newCallFrame->r(newCallFrame->hostThisRegister()) = JSValue(thisObj);

   684 

   685     if (codeBlock->needsFullScopeChain())

   686         scopeChain->ref();

   687 

   688     DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject);

   689 

   690     Profiler** profiler = Profiler::enabledProfilerReference();

   691     if (*profiler)

   692         (*profiler)->willExecute(newCallFrame, program->sourceURL(), program->lineNo());

   693 

   694     JSValue result;

   695     {

   696         SamplingTool::CallRecord callRecord(m_sampler.get());

   697 

   698         m_reentryDepth++;  

   699 #if ENABLE(JIT)

   700         if (callFrame->globalData().canUseJIT())

   701             result = program->generatedJITCode().execute(&m_registerFile, newCallFrame, scopeChain->globalData, exception);

   702         else

   703 #endif

   704             result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);

   705 

   706         m_reentryDepth--;

   707     }

   708 

   709     if (*profiler)

   710         (*profiler)->didExecute(callFrame, program->sourceURL(), program->lineNo());

   711 

   712     if (m_reentryDepth && lastGlobalObject && globalObject != lastGlobalObject)

   713         lastGlobalObject->copyGlobalsTo(m_registerFile);

   714 

   715     m_registerFile.shrink(oldEnd);

   716 

   717     return result;

   718 }

   719 

   720 JSValue Interpreter::executeCall(CallFrame* callFrame, JSObject* function, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args, JSValue* exception)

   721 {

   722     ASSERT(!callFrame->hadException());

   723 

   724     if (m_reentryDepth >= MaxSmallThreadReentryDepth) {

   725         if (m_reentryDepth >= callFrame->globalData().maxReentryDepth) {

   726             *exception = createStackOverflowError(callFrame);

   727             return jsNull();

   728         }

   729     }

   730 

   731     Register* oldEnd = m_registerFile.end();

   732     int argCount = 1 + args.size(); // implicit "this" parameter

   733     size_t registerOffset = argCount + RegisterFile::CallFrameHeaderSize;

   734 

   735     if (!m_registerFile.grow(oldEnd + registerOffset)) {

   736         *exception = createStackOverflowError(callFrame);

   737         return jsNull();

   738     }

   739 

   740     CallFrame* newCallFrame = CallFrame::create(oldEnd);

   741     size_t dst = 0;

   742     newCallFrame->r(0) = thisValue;

   743     ArgList::const_iterator end = args.end();

   744     for (ArgList::const_iterator it = args.begin(); it != end; ++it)

   745         newCallFrame->r(++dst) = *it;

   746 

   747     if (callType == CallTypeJS) {

   748         ScopeChainNode* callDataScopeChain = callData.js.scopeChain;

   749 

   750         JSObject* compileError = callData.js.functionExecutable->compileForCall(callFrame, callDataScopeChain);

   751         if (UNLIKELY(!!compileError)) {

   752             *exception = compileError;

   753             m_registerFile.shrink(oldEnd);

   754             return jsNull();

   755         }

   756 

   757         CodeBlock* newCodeBlock = &callData.js.functionExecutable->generatedBytecodeForCall();

   758         newCallFrame = slideRegisterWindowForCall(newCodeBlock, &m_registerFile, newCallFrame, registerOffset, argCount);

   759         if (UNLIKELY(!newCallFrame)) {

   760             *exception = createStackOverflowError(callFrame);

   761             m_registerFile.shrink(oldEnd);

   762             return jsNull();

   763         }

   764 

   765         newCallFrame->init(newCodeBlock, 0, callDataScopeChain, callFrame->addHostCallFrameFlag(), argCount, function);

   766 

   767         DynamicGlobalObjectScope globalObjectScope(newCallFrame, callDataScopeChain->globalObject);

   768 

   769         Profiler** profiler = Profiler::enabledProfilerReference();

   770         if (*profiler)

   771             (*profiler)->willExecute(newCallFrame, function);

   772 

   773         JSValue result;

   774         {

   775             SamplingTool::CallRecord callRecord(m_sampler.get());

   776 

   777             m_reentryDepth++;  

   778 #if ENABLE(JIT)

   779             if (callFrame->globalData().canUseJIT())

   780                 result = callData.js.functionExecutable->generatedJITCodeForCall().execute(&m_registerFile, newCallFrame, callDataScopeChain->globalData, exception);

   781             else

   782 #endif

   783                 result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);

   784             m_reentryDepth--;

   785         }

   786 

   787         if (*profiler)

   788             (*profiler)->didExecute(newCallFrame, function);

   789 

   790         m_registerFile.shrink(oldEnd);

   791         return result;

   792     }

   793 

   794     ASSERT(callType == CallTypeHost);

   795     ScopeChainNode* scopeChain = callFrame->scopeChain();

   796     newCallFrame = CallFrame::create(newCallFrame->registers() + registerOffset);

   797     newCallFrame->init(0, 0, scopeChain, callFrame->addHostCallFrameFlag(), argCount, function);

   798 

   799     DynamicGlobalObjectScope globalObjectScope(newCallFrame, scopeChain->globalObject);

   800 

   801     Profiler** profiler = Profiler::enabledProfilerReference();

   802     if (*profiler)

   803         (*profiler)->willExecute(newCallFrame, function);

   804 

   805     JSValue result;

   806     {

   807         SamplingTool::HostCallRecord callRecord(m_sampler.get());

   808         result = JSValue::decode(callData.native.function(newCallFrame));

   809     }

   810 

   811     if (*profiler)

   812         (*profiler)->didExecute(newCallFrame, function);

   813 

   814     m_registerFile.shrink(oldEnd);

   815     return result;

   816 }

   817 

   818 JSObject* Interpreter::executeConstruct(CallFrame* callFrame, JSObject* constructor, ConstructType constructType, const ConstructData& constructData, const ArgList& args, JSValue* exception)

   819 {

   820     ASSERT(!callFrame->hadException());

   821 

   822     if (m_reentryDepth >= MaxSmallThreadReentryDepth) {

   823         if (m_reentryDepth >= callFrame->globalData().maxReentryDepth) {

   824             *exception = createStackOverflowError(callFrame);

   825             return 0;

   826         }

   827     }

   828 

   829     Register* oldEnd = m_registerFile.end();

   830     int argCount = 1 + args.size(); // implicit "this" parameter

   831     size_t registerOffset = argCount + RegisterFile::CallFrameHeaderSize;

   832 

   833     if (!m_registerFile.grow(oldEnd + registerOffset)) {

   834         *exception = createStackOverflowError(callFrame);

   835         return 0;

   836     }

   837 

   838     CallFrame* newCallFrame = CallFrame::create(oldEnd);

   839     size_t dst = 0;

   840     ArgList::const_iterator end = args.end();

   841     for (ArgList::const_iterator it = args.begin(); it != end; ++it)

   842         newCallFrame->r(++dst) = *it;

   843 

   844     if (constructType == ConstructTypeJS) {

   845         ScopeChainNode* constructDataScopeChain = constructData.js.scopeChain;

   846 

   847         JSObject* compileError = constructData.js.functionExecutable->compileForConstruct(callFrame, constructDataScopeChain);

   848         if (UNLIKELY(!!compileError)) {

   849             *exception = compileError;

   850             m_registerFile.shrink(oldEnd);

   851             return 0;

   852         }

   853 

   854         CodeBlock* newCodeBlock = &constructData.js.functionExecutable->generatedBytecodeForConstruct();

   855         newCallFrame = slideRegisterWindowForCall(newCodeBlock, &m_registerFile, newCallFrame, registerOffset, argCount);

   856         if (UNLIKELY(!newCallFrame)) {

   857             *exception = createStackOverflowError(callFrame);

   858             m_registerFile.shrink(oldEnd);

   859             return 0;

   860         }

   861 

   862         newCallFrame->init(newCodeBlock, 0, constructDataScopeChain, callFrame->addHostCallFrameFlag(), argCount, constructor);

   863 

   864         DynamicGlobalObjectScope globalObjectScope(newCallFrame, constructDataScopeChain->globalObject);

   865 

   866         Profiler** profiler = Profiler::enabledProfilerReference();

   867         if (*profiler)

   868             (*profiler)->willExecute(newCallFrame, constructor);

   869 

   870         JSValue result;

   871         {

   872             SamplingTool::CallRecord callRecord(m_sampler.get());

   873 

   874             m_reentryDepth++;  

   875 #if ENABLE(JIT)

   876             if (callFrame->globalData().canUseJIT())

   877                 result = constructData.js.functionExecutable->generatedJITCodeForConstruct().execute(&m_registerFile, newCallFrame, constructDataScopeChain->globalData, exception);

   878             else

   879 #endif

   880                 result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);

   881             m_reentryDepth--;

   882         }

   883 

   884         if (*profiler)

   885             (*profiler)->didExecute(newCallFrame, constructor);

   886 

   887         m_registerFile.shrink(oldEnd);

   888         if (callFrame->hadException())

   889             return 0;

   890         ASSERT(result.isObject());

   891         return asObject(result);

   892     }

   893 

   894     ASSERT(constructType == ConstructTypeHost);

   895     ScopeChainNode* scopeChain = callFrame->scopeChain();

   896     newCallFrame = CallFrame::create(newCallFrame->registers() + registerOffset);

   897     newCallFrame->init(0, 0, scopeChain, callFrame->addHostCallFrameFlag(), argCount, constructor);

   898 

   899     DynamicGlobalObjectScope globalObjectScope(newCallFrame, scopeChain->globalObject);

   900 

   901     Profiler** profiler = Profiler::enabledProfilerReference();

   902     if (*profiler)

   903         (*profiler)->willExecute(newCallFrame, constructor);

   904 

   905     JSValue result;

   906     {

   907         SamplingTool::HostCallRecord callRecord(m_sampler.get());

   908         result = JSValue::decode(constructData.native.function(newCallFrame));

   909     }

   910 

   911     if (*profiler)

   912         (*profiler)->didExecute(newCallFrame, constructor);

   913 

   914     m_registerFile.shrink(oldEnd);

   915     if (callFrame->hadException())

   916         return 0;

   917     ASSERT(result.isObject());

   918     return asObject(result);

   919 }

   920 

   921 CallFrameClosure Interpreter::prepareForRepeatCall(FunctionExecutable* FunctionExecutable, CallFrame* callFrame, JSFunction* function, int argCount, ScopeChainNode* scopeChain, JSValue* exception)

   922 {

   923     ASSERT(!scopeChain->globalData->exception);

   924     

   925     if (m_reentryDepth >= MaxSmallThreadReentryDepth) {

   926         if (m_reentryDepth >= callFrame->globalData().maxReentryDepth) {

   927             *exception = createStackOverflowError(callFrame);

   928             return CallFrameClosure();

   929         }

   930     }

   931     

   932     Register* oldEnd = m_registerFile.end();

   933     int argc = 1 + argCount; // implicit "this" parameter

   934     

   935     if (!m_registerFile.grow(oldEnd + argc)) {

   936         *exception = createStackOverflowError(callFrame);

   937         return CallFrameClosure();

   938     }

   939 

   940     CallFrame* newCallFrame = CallFrame::create(oldEnd);

   941     size_t dst = 0;

   942     for (int i = 0; i < argc; ++i)

   943         newCallFrame->r(++dst) = jsUndefined();

   944     

   945     JSObject* error = FunctionExecutable->compileForCall(callFrame, scopeChain);

   946     if (error) {

   947         *exception = error;

   948         m_registerFile.shrink(oldEnd);

   949         return CallFrameClosure();

   950     }

   951     CodeBlock* codeBlock = &FunctionExecutable->generatedBytecodeForCall();

   952 

   953     newCallFrame = slideRegisterWindowForCall(codeBlock, &m_registerFile, newCallFrame, argc + RegisterFile::CallFrameHeaderSize, argc);

   954     if (UNLIKELY(!newCallFrame)) {

   955         *exception = createStackOverflowError(callFrame);

   956         m_registerFile.shrink(oldEnd);

   957         return CallFrameClosure();

   958     }

   959     // a 0 codeBlock indicates a built-in caller

   960     newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), argc, function);  

   961     CallFrameClosure result = { callFrame, newCallFrame, function, FunctionExecutable, scopeChain->globalData, oldEnd, scopeChain, codeBlock->m_numParameters, argc };

   962     return result;

   963 }

   964 

   965 JSValue Interpreter::execute(CallFrameClosure& closure, JSValue* exception) 

   966 {

   967     closure.resetCallFrame();

   968     Profiler** profiler = Profiler::enabledProfilerReference();

   969     if (*profiler)

   970         (*profiler)->willExecute(closure.oldCallFrame, closure.function);

   971     

   972     JSValue result;

   973     {

   974         SamplingTool::CallRecord callRecord(m_sampler.get());

   975         

   976         m_reentryDepth++;  

   977 #if ENABLE(JIT)

   978 #if ENABLE(INTERPRETER)

   979         if (closure.newCallFrame->globalData().canUseJIT())

   980 #endif

   981             result = closure.functionExecutable->generatedJITCodeForCall().execute(&m_registerFile, closure.newCallFrame, closure.globalData, exception);

   982 #if ENABLE(INTERPRETER)

   983         else

   984 #endif

   985 #endif

   986 #if ENABLE(INTERPRETER)

   987             result = privateExecute(Normal, &m_registerFile, closure.newCallFrame, exception);

   988 #endif

   989         m_reentryDepth--;

   990     }

   991     

   992     if (*profiler)

   993         (*profiler)->didExecute(closure.oldCallFrame, closure.function);

   994     return result;

   995 }

   996 

   997 void Interpreter::endRepeatCall(CallFrameClosure& closure)

   998 {

   999     m_registerFile.shrink(closure.oldEnd);

  1000 }

  1001 

  1002 JSValue Interpreter::execute(EvalExecutable* eval, CallFrame* callFrame, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue* exception)

  1003 {

  1004     JSObject* compileError = eval->compile(callFrame, scopeChain);

  1005     if (UNLIKELY(!!compileError)) {

  1006         *exception = compileError;

  1007         return jsNull();

  1008     }

  1009     return execute(eval, callFrame, thisObj, m_registerFile.size() + eval->generatedBytecode().m_numParameters + RegisterFile::CallFrameHeaderSize, scopeChain, exception);

  1010 }

  1011 

  1012 JSValue Interpreter::execute(EvalExecutable* eval, CallFrame* callFrame, JSObject* thisObj, int globalRegisterOffset, ScopeChainNode* scopeChain, JSValue* exception)

  1013 {

  1014     ASSERT(!scopeChain->globalData->exception);

  1015 

  1016     if (m_reentryDepth >= MaxSmallThreadReentryDepth) {

  1017         if (m_reentryDepth >= callFrame->globalData().maxReentryDepth) {

  1018             *exception = createStackOverflowError(callFrame);

  1019             return jsNull();

  1020         }

  1021     }

  1022 

  1023     DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject);

  1024 

  1025     JSObject* compileError = eval->compile(callFrame, scopeChain);

  1026     if (UNLIKELY(!!compileError)) {

  1027         *exception = compileError;

  1028         return jsNull();

  1029     }

  1030     EvalCodeBlock* codeBlock = &eval->generatedBytecode();

  1031 

  1032     JSVariableObject* variableObject;

  1033     for (ScopeChainNode* node = scopeChain; ; node = node->next) {

  1034         ASSERT(node);

  1035         if (node->object->isVariableObject()) {

  1036             variableObject = static_cast<JSVariableObject*>(node->object);

  1037             break;

  1038         }

  1039     }

  1040 

  1041     unsigned numVariables = codeBlock->numVariables();

  1042     int numFunctions = codeBlock->numberOfFunctionDecls();

  1043     if (numVariables || numFunctions) {

  1044         // Scope for BatchedTransitionOptimizer

  1045         BatchedTransitionOptimizer optimizer(variableObject);

  1046 

  1047         for (unsigned i = 0; i < numVariables; ++i) {

  1048             const Identifier& ident = codeBlock->variable(i);

  1049             if (!variableObject->hasProperty(callFrame, ident)) {

  1050                 PutPropertySlot slot;

  1051                 variableObject->put(callFrame, ident, jsUndefined(), slot);

  1052             }

  1053         }

  1054 

  1055         for (int i = 0; i < numFunctions; ++i) {

  1056             FunctionExecutable* function = codeBlock->functionDecl(i);

  1057             PutPropertySlot slot;

  1058             variableObject->put(callFrame, function->name(), function->make(callFrame, scopeChain), slot);

  1059         }

  1060     }

  1061 

  1062     Register* oldEnd = m_registerFile.end();

  1063     Register* newEnd = m_registerFile.start() + globalRegisterOffset + codeBlock->m_numCalleeRegisters;

  1064     if (!m_registerFile.grow(newEnd)) {

  1065         *exception = createStackOverflowError(callFrame);

  1066         return jsNull();

  1067     }

  1068 

  1069     CallFrame* newCallFrame = CallFrame::create(m_registerFile.start() + globalRegisterOffset);

  1070 

  1071     // a 0 codeBlock indicates a built-in caller

  1072     ASSERT(codeBlock->m_numParameters == 1); // 1 parameter for 'this'.

  1073     newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), codeBlock->m_numParameters, 0);

  1074     newCallFrame->r(newCallFrame->hostThisRegister()) = JSValue(thisObj);

  1075 

  1076     if (codeBlock->needsFullScopeChain())

  1077         scopeChain->ref();

  1078 

  1079     Profiler** profiler = Profiler::enabledProfilerReference();

  1080     if (*profiler)

  1081         (*profiler)->willExecute(newCallFrame, eval->sourceURL(), eval->lineNo());

  1082 

  1083     JSValue result;

  1084     {

  1085         SamplingTool::CallRecord callRecord(m_sampler.get());

  1086 

  1087         m_reentryDepth++;

  1088         

  1089 #if ENABLE(JIT)

  1090 #if ENABLE(INTERPRETER)

  1091         if (callFrame->globalData().canUseJIT())

  1092 #endif

  1093             result = eval->generatedJITCode().execute(&m_registerFile, newCallFrame, scopeChain->globalData, exception);

  1094 #if ENABLE(INTERPRETER)

  1095         else

  1096 #endif

  1097 #endif

  1098 #if ENABLE(INTERPRETER)

  1099             result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);

  1100 #endif

  1101         m_reentryDepth--;

  1102     }

  1103 

  1104     if (*profiler)

  1105         (*profiler)->didExecute(callFrame, eval->sourceURL(), eval->lineNo());

  1106 

  1107     m_registerFile.shrink(oldEnd);

  1108     return result;

  1109 }

  1110 

  1111 NEVER_INLINE void Interpreter::debug(CallFrame* callFrame, DebugHookID debugHookID, int firstLine, int lastLine)

  1112 {

  1113     Debugger* debugger = callFrame->dynamicGlobalObject()->debugger();

  1114     if (!debugger)

  1115         return;

  1116 

  1117     switch (debugHookID) {

  1118         case DidEnterCallFrame:

  1119             debugger->callEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine);

  1120             return;

  1121         case WillLeaveCallFrame:

  1122             debugger->returnEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine);

  1123             return;

  1124         case WillExecuteStatement:

  1125             debugger->atStatement(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine);

  1126             return;

  1127         case WillExecuteProgram:

  1128             debugger->willExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine);

  1129             return;

  1130         case DidExecuteProgram:

  1131             debugger->didExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine);

  1132             return;

  1133         case DidReachBreakpoint:

  1134             debugger->didReachBreakpoint(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine);

  1135             return;