cc007d3c379a6da36ceb60723a652beca61c6938
[WebKit-https.git] / Source / JavaScriptCore / interpreter / Interpreter.cpp
1 /*
2  * Copyright (C) 2008, 2009, 2010, 2012, 2013 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 "CallFrameInlines.h"
38 #include "CodeBlock.h"
39 #include "Heap.h"
40 #include "Debugger.h"
41 #include "DebuggerCallFrame.h"
42 #include "ErrorInstance.h"
43 #include "EvalCodeCache.h"
44 #include "ExceptionHelpers.h"
45 #include "GetterSetter.h"
46 #include "JSActivation.h"
47 #include "JSArray.h"
48 #include "JSBoundFunction.h"
49 #include "JSNameScope.h"
50 #include "JSNotAnObject.h"
51 #include "JSPropertyNameIterator.h"
52 #include "JSStackInlines.h"
53 #include "JSString.h"
54 #include "JSWithScope.h"
55 #include "LLIntCLoop.h"
56 #include "LegacyProfiler.h"
57 #include "LiteralParser.h"
58 #include "NameInstance.h"
59 #include "ObjectPrototype.h"
60 #include "Operations.h"
61 #include "Parser.h"
62 #include "RegExpObject.h"
63 #include "RegExpPrototype.h"
64 #include "Register.h"
65 #include "SamplingTool.h"
66 #include "StackIterator.h"
67 #include "StrictEvalActivation.h"
68 #include "StrongInlines.h"
69 #include "VMStackBounds.h"
70 #include <limits.h>
71 #include <stdio.h>
72 #include <wtf/StackStats.h>
73 #include <wtf/StringPrintStream.h>
74 #include <wtf/Threading.h>
75 #include <wtf/WTFThreadData.h>
76 #include <wtf/text/StringBuilder.h>
77
78 #if ENABLE(JIT)
79 #include "JIT.h"
80 #endif
81
82 #define WTF_USE_GCC_COMPUTED_GOTO_WORKAROUND (ENABLE(LLINT) && !defined(__llvm__))
83
84 using namespace std;
85
86 namespace JSC {
87
88 Interpreter::ErrorHandlingMode::ErrorHandlingMode(ExecState *exec)
89     : m_interpreter(*exec->interpreter())
90 {
91     if (!m_interpreter.m_errorHandlingModeReentry)
92         m_interpreter.stack().enableErrorStackReserve();
93     m_interpreter.m_errorHandlingModeReentry++;
94 }
95
96 Interpreter::ErrorHandlingMode::~ErrorHandlingMode()
97 {
98     m_interpreter.m_errorHandlingModeReentry--;
99     ASSERT(m_interpreter.m_errorHandlingModeReentry >= 0);
100     if (!m_interpreter.m_errorHandlingModeReentry)
101         m_interpreter.stack().disableErrorStackReserve();
102 }
103
104 JSValue eval(CallFrame* callFrame)
105 {
106     if (!callFrame->argumentCount())
107         return jsUndefined();
108
109     JSValue program = callFrame->argument(0);
110     if (!program.isString())
111         return program;
112     
113     TopCallFrameSetter topCallFrame(callFrame->vm(), callFrame);
114     String programSource = asString(program)->value(callFrame);
115     if (callFrame->hadException())
116         return JSValue();
117     
118     CallFrame* callerFrame = callFrame->callerFrame();
119     CodeBlock* callerCodeBlock = callerFrame->codeBlock();
120     JSScope* callerScopeChain = callerFrame->scope();
121     EvalExecutable* eval = callerCodeBlock->evalCodeCache().tryGet(callerCodeBlock->isStrictMode(), programSource, callerScopeChain);
122
123     if (!eval) {
124         if (!callerCodeBlock->isStrictMode()) {
125             // FIXME: We can use the preparser in strict mode, we just need additional logic
126             // to prevent duplicates.
127             if (programSource.is8Bit()) {
128                 LiteralParser<LChar> preparser(callFrame, programSource.characters8(), programSource.length(), NonStrictJSON);
129                 if (JSValue parsedObject = preparser.tryLiteralParse())
130                     return parsedObject;
131             } else {
132                 LiteralParser<UChar> preparser(callFrame, programSource.characters16(), programSource.length(), NonStrictJSON);
133                 if (JSValue parsedObject = preparser.tryLiteralParse())
134                     return parsedObject;                
135             }
136         }
137         
138         // If the literal parser bailed, it should not have thrown exceptions.
139         ASSERT(!callFrame->vm().exception);
140
141         eval = callerCodeBlock->evalCodeCache().getSlow(callFrame, callerCodeBlock->ownerExecutable(), callerCodeBlock->isStrictMode(), programSource, callerScopeChain);
142         if (!eval)
143             return jsUndefined();
144     }
145
146     JSValue thisValue = callerFrame->thisValue();
147     Interpreter* interpreter = callFrame->vm().interpreter;
148     return interpreter->execute(eval, callFrame, thisValue, callerScopeChain);
149 }
150
151 CallFrame* loadVarargs(CallFrame* callFrame, JSStack* stack, JSValue thisValue, JSValue arguments, int firstFreeRegister)
152 {
153     if (!arguments) { // f.apply(x, arguments), with arguments unmodified.
154         unsigned argumentCountIncludingThis = callFrame->argumentCountIncludingThis();
155         CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + argumentCountIncludingThis + JSStack::CallFrameHeaderSize);
156         if (argumentCountIncludingThis > Arguments::MaxArguments + 1 || !stack->grow(newCallFrame->registers())) {
157             callFrame->vm().exception = createStackOverflowError(callFrame);
158             return 0;
159         }
160
161         newCallFrame->setArgumentCountIncludingThis(argumentCountIncludingThis);
162         newCallFrame->setThisValue(thisValue);
163         for (size_t i = 0; i < callFrame->argumentCount(); ++i)
164             newCallFrame->setArgument(i, callFrame->argumentAfterCapture(i));
165         return newCallFrame;
166     }
167
168     if (arguments.isUndefinedOrNull()) {
169         CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + 1 + JSStack::CallFrameHeaderSize);
170         if (!stack->grow(newCallFrame->registers())) {
171             callFrame->vm().exception = createStackOverflowError(callFrame);
172             return 0;
173         }
174         newCallFrame->setArgumentCountIncludingThis(1);
175         newCallFrame->setThisValue(thisValue);
176         return newCallFrame;
177     }
178
179     if (!arguments.isObject()) {
180         callFrame->vm().exception = createInvalidParameterError(callFrame, "Function.prototype.apply", arguments);
181         return 0;
182     }
183
184     if (asObject(arguments)->classInfo() == Arguments::info()) {
185         Arguments* argsObject = asArguments(arguments);
186         unsigned argCount = argsObject->length(callFrame);
187         CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + CallFrame::offsetFor(argCount + 1));
188         if (argCount > Arguments::MaxArguments || !stack->grow(newCallFrame->registers())) {
189             callFrame->vm().exception = createStackOverflowError(callFrame);
190             return 0;
191         }
192         newCallFrame->setArgumentCountIncludingThis(argCount + 1);
193         newCallFrame->setThisValue(thisValue);
194         argsObject->copyToArguments(callFrame, newCallFrame, argCount);
195         return newCallFrame;
196     }
197
198     if (isJSArray(arguments)) {
199         JSArray* array = asArray(arguments);
200         unsigned argCount = array->length();
201         CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + CallFrame::offsetFor(argCount + 1));
202         if (argCount > Arguments::MaxArguments || !stack->grow(newCallFrame->registers())) {
203             callFrame->vm().exception = createStackOverflowError(callFrame);
204             return 0;
205         }
206         newCallFrame->setArgumentCountIncludingThis(argCount + 1);
207         newCallFrame->setThisValue(thisValue);
208         array->copyToArguments(callFrame, newCallFrame, argCount);
209         return newCallFrame;
210     }
211
212     JSObject* argObject = asObject(arguments);
213     unsigned argCount = argObject->get(callFrame, callFrame->propertyNames().length).toUInt32(callFrame);
214     CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + CallFrame::offsetFor(argCount + 1));
215     if (argCount > Arguments::MaxArguments || !stack->grow(newCallFrame->registers())) {
216         callFrame->vm().exception = createStackOverflowError(callFrame);
217         return 0;
218     }
219     newCallFrame->setArgumentCountIncludingThis(argCount + 1);
220     newCallFrame->setThisValue(thisValue);
221     for (size_t i = 0; i < argCount; ++i) {
222         newCallFrame->setArgument(i, asObject(arguments)->get(callFrame, i));
223         if (UNLIKELY(callFrame->vm().exception))
224             return 0;
225     }
226     return newCallFrame;
227 }
228
229 Interpreter::Interpreter(VM& vm)
230     : m_sampleEntryDepth(0)
231     , m_vm(vm)
232     , m_stack(vm)
233     , m_errorHandlingModeReentry(0)
234 #if !ASSERT_DISABLED
235     , m_initialized(false)
236 #endif
237 {
238 }
239
240 Interpreter::~Interpreter()
241 {
242 }
243
244 void Interpreter::initialize(bool canUseJIT)
245 {
246     UNUSED_PARAM(canUseJIT);
247
248 #if ENABLE(COMPUTED_GOTO_OPCODES) && ENABLE(LLINT)
249     m_opcodeTable = LLInt::opcodeMap();
250     for (int i = 0; i < numOpcodeIDs; ++i)
251         m_opcodeIDTable.add(m_opcodeTable[i], static_cast<OpcodeID>(i));
252 #endif
253
254 #if !ASSERT_DISABLED
255     m_initialized = true;
256 #endif
257
258 #if ENABLE(OPCODE_SAMPLING)
259     enableSampler();
260 #endif
261 }
262
263 #ifdef NDEBUG
264
265 void Interpreter::dumpCallFrame(CallFrame*)
266 {
267 }
268
269 #else
270
271 void Interpreter::dumpCallFrame(CallFrame* callFrame)
272 {
273     callFrame->codeBlock()->dumpBytecode();
274     dumpRegisters(callFrame);
275 }
276
277 void Interpreter::dumpRegisters(CallFrame* callFrame)
278 {
279     dataLogF("Register frame: \n\n");
280     dataLogF("-----------------------------------------------------------------------------\n");
281     dataLogF("            use            |   address  |                value               \n");
282     dataLogF("-----------------------------------------------------------------------------\n");
283
284     CodeBlock* codeBlock = callFrame->codeBlock();
285     const Register* it;
286     const Register* end;
287
288     it = callFrame->registers() - JSStack::CallFrameHeaderSize - callFrame->argumentCountIncludingThis();
289     end = callFrame->registers() - JSStack::CallFrameHeaderSize;
290     while (it < end) {
291         JSValue v = it->jsValue();
292         int registerNumber = it - callFrame->registers();
293         String name = codeBlock->nameForRegister(registerNumber);
294         dataLogF("[r% 3d %14s]      | %10p | %-16s 0x%lld \n", registerNumber, name.ascii().data(), it, toCString(v).data(), (long long)JSValue::encode(v));
295         it++;
296     }
297     
298     dataLogF("-----------------------------------------------------------------------------\n");
299     dataLogF("[ArgumentCount]            | %10p | %lu \n", it, (unsigned long) callFrame->argumentCount());
300     ++it;
301     dataLogF("[CallerFrame]              | %10p | %p \n", it, callFrame->callerFrame());
302     ++it;
303     dataLogF("[Callee]                   | %10p | %p \n", it, callFrame->callee());
304     ++it;
305     dataLogF("[ScopeChain]               | %10p | %p \n", it, callFrame->scope());
306     ++it;
307 #if ENABLE(JIT)
308     AbstractPC pc = callFrame->abstractReturnPC(callFrame->vm());
309     if (pc.hasJITReturnAddress())
310         dataLogF("[ReturnJITPC]              | %10p | %p \n", it, pc.jitReturnAddress().value());
311 #endif
312     StackIterator iter = callFrame->begin();
313     ++iter;
314     if (iter != callFrame->end()) {
315         unsigned line = 0;
316         unsigned unusedColumn = 0;
317         iter->computeLineAndColumn(line, unusedColumn);
318         dataLogF("[ReturnVPC]                | %10p | %d (line %d)\n", it, iter->bytecodeOffset(), line);
319         ++it;
320     }
321     dataLogF("[CodeBlock]                | %10p | %p \n", it, callFrame->codeBlock());
322     ++it;
323     dataLogF("-----------------------------------------------------------------------------\n");
324
325     int registerCount = 0;
326
327     end = it + codeBlock->m_numVars;
328     if (it != end) {
329         do {
330             JSValue v = it->jsValue();
331             int registerNumber = it - callFrame->registers();
332             String name = codeBlock->nameForRegister(registerNumber);
333             dataLogF("[r% 3d %14s]      | %10p | %-16s 0x%lld \n", registerNumber, name.ascii().data(), it, toCString(v).data(), (long long)JSValue::encode(v));
334             ++it;
335             ++registerCount;
336         } while (it != end);
337     }
338     dataLogF("-----------------------------------------------------------------------------\n");
339
340     end = it + codeBlock->m_numCalleeRegisters - codeBlock->m_numVars;
341     if (it != end) {
342         do {
343             JSValue v = (*it).jsValue();
344             dataLogF("[r% 3d]                     | %10p | %-16s 0x%lld \n", registerCount, it, toCString(v).data(), (long long)JSValue::encode(v));
345             ++it;
346             ++registerCount;
347         } while (it != end);
348     }
349     dataLogF("-----------------------------------------------------------------------------\n");
350 }
351
352 #endif
353
354 bool Interpreter::isOpcode(Opcode opcode)
355 {
356 #if ENABLE(COMPUTED_GOTO_OPCODES)
357 #if !ENABLE(LLINT)
358     return static_cast<OpcodeID>(bitwise_cast<uintptr_t>(opcode)) <= op_end;
359 #else
360     return opcode != HashTraits<Opcode>::emptyValue()
361         && !HashTraits<Opcode>::isDeletedValue(opcode)
362         && m_opcodeIDTable.contains(opcode);
363 #endif
364 #else
365     return opcode >= 0 && opcode <= op_end;
366 #endif
367 }
368
369 NEVER_INLINE bool Interpreter::unwindCallFrame(StackIterator& iter, JSValue exceptionValue)
370 {
371     CallFrame* callFrame = iter->callFrame();
372     CodeBlock* codeBlock = iter->codeBlock();
373     CodeBlock* oldCodeBlock = codeBlock;
374     JSScope* scope = callFrame->scope();
375
376     if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {
377         DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);
378         if (callFrame->callee())
379             debugger->returnEvent(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine(), 0);
380         else
381             debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->ownerExecutable()->lastLine(), 0);
382     }
383
384     JSValue activation;
385     if (oldCodeBlock->codeType() == FunctionCode && oldCodeBlock->needsActivation()) {
386         activation = callFrame->uncheckedR(oldCodeBlock->activationRegister()).jsValue();
387         if (activation)
388             jsCast<JSActivation*>(activation)->tearOff(*scope->vm());
389     }
390
391     if (oldCodeBlock->codeType() == FunctionCode && oldCodeBlock->usesArguments()) {
392         if (JSValue arguments = callFrame->uncheckedR(unmodifiedArgumentsRegister(oldCodeBlock->argumentsRegister())).jsValue()) {
393             if (activation)
394                 jsCast<Arguments*>(arguments)->didTearOffActivation(callFrame, jsCast<JSActivation*>(activation));
395             else
396                 jsCast<Arguments*>(arguments)->tearOff(callFrame);
397         }
398     }
399
400     CallFrame* callerFrame = callFrame->callerFrame();
401     callFrame->vm().topCallFrame = callerFrame->removeHostCallFrameFlag();
402     return !callerFrame->hasHostCallFrameFlag();
403 }
404
405 static void appendSourceToError(CallFrame* callFrame, ErrorInstance* exception, unsigned bytecodeOffset)
406 {
407     exception->clearAppendSourceToMessage();
408
409     if (!callFrame->codeBlock()->hasExpressionInfo())
410         return;
411
412     int startOffset = 0;
413     int endOffset = 0;
414     int divotPoint = 0;
415     unsigned line = 0;
416     unsigned column = 0;
417
418     CodeBlock* codeBlock = callFrame->codeBlock();
419     codeBlock->expressionRangeForBytecodeOffset(bytecodeOffset, divotPoint, startOffset, endOffset, line, column);
420
421     int expressionStart = divotPoint - startOffset;
422     int expressionStop = divotPoint + endOffset;
423
424     const String& sourceString = codeBlock->source()->source();
425     if (!expressionStop || expressionStart > static_cast<int>(sourceString.length()))
426         return;
427
428     VM* vm = &callFrame->vm();
429     JSValue jsMessage = exception->getDirect(*vm, vm->propertyNames->message);
430     if (!jsMessage || !jsMessage.isString())
431         return;
432
433     String message = asString(jsMessage)->value(callFrame);
434
435     if (expressionStart < expressionStop)
436         message =  makeString(message, " (evaluating '", codeBlock->source()->getRange(expressionStart, expressionStop), "')");
437     else {
438         // No range information, so give a few characters of context
439         const StringImpl* data = sourceString.impl();
440         int dataLength = sourceString.length();
441         int start = expressionStart;
442         int stop = expressionStart;
443         // Get up to 20 characters of context to the left and right of the divot, clamping to the line.
444         // then strip whitespace.
445         while (start > 0 && (expressionStart - start < 20) && (*data)[start - 1] != '\n')
446             start--;
447         while (start < (expressionStart - 1) && isStrWhiteSpace((*data)[start]))
448             start++;
449         while (stop < dataLength && (stop - expressionStart < 20) && (*data)[stop] != '\n')
450             stop++;
451         while (stop > expressionStart && isStrWhiteSpace((*data)[stop - 1]))
452             stop--;
453         message = makeString(message, " (near '...", codeBlock->source()->getRange(start, stop), "...')");
454     }
455
456     exception->putDirect(*vm, vm->propertyNames->message, jsString(vm, message));
457 }
458
459 static ALWAYS_INLINE const String getSourceURLFromCallFrame(CallFrame* callFrame)
460 {
461     ASSERT(!callFrame->hasHostCallFrameFlag());
462     return callFrame->codeBlock()->ownerExecutable()->sourceURL();
463 }
464
465 static StackFrameCodeType getStackFrameCodeType(StackIterator iter)
466 {
467     switch (iter->codeType()) {
468     case StackIterator::Frame::Eval:
469         return StackFrameEvalCode;
470     case StackIterator::Frame::Function:
471         return StackFrameFunctionCode;
472     case StackIterator::Frame::Global:
473         return StackFrameGlobalCode;
474     case StackIterator::Frame::Native:
475         ASSERT_NOT_REACHED();
476         return StackFrameNativeCode;
477     }
478     RELEASE_ASSERT_NOT_REACHED();
479     return StackFrameGlobalCode;
480 }
481
482 void StackFrame::computeLineAndColumn(unsigned& line, unsigned& column)
483 {
484     if (!codeBlock) {
485         line = 0;
486         column = 0;
487         return;
488     }
489
490     int divot = 0;
491     int unusedStartOffset = 0;
492     int unusedEndOffset = 0;
493     unsigned divotLine = 0;
494     unsigned divotColumn = 0;
495     expressionInfo(divot, unusedStartOffset, unusedEndOffset, divotLine, divotColumn);
496
497     line = divotLine + lineOffset;
498     column = divotColumn + (divotLine ? 1 : firstLineColumnOffset);
499 }
500
501 void StackFrame::expressionInfo(int& divot, int& startOffset, int& endOffset, unsigned& line, unsigned& column)
502 {
503     codeBlock->expressionRangeForBytecodeOffset(bytecodeOffset, divot, startOffset, endOffset, line, column);
504     divot += characterOffset;
505 }
506
507 String StackFrame::toString(CallFrame* callFrame)
508 {
509     StringBuilder traceBuild;
510     String functionName = friendlyFunctionName(callFrame);
511     String sourceURL = friendlySourceURL();
512     traceBuild.append(functionName);
513     if (!sourceURL.isEmpty()) {
514         if (!functionName.isEmpty())
515             traceBuild.append('@');
516         traceBuild.append(sourceURL);
517         if (codeType != StackFrameNativeCode) {
518             unsigned line;
519             unsigned column;
520             computeLineAndColumn(line, column);
521
522             traceBuild.append(':');
523             traceBuild.appendNumber(line);
524             traceBuild.append(':');
525             traceBuild.appendNumber(column);
526         }
527     }
528     return traceBuild.toString().impl();
529 }
530
531 void Interpreter::getStackTrace(Vector<StackFrame>& results, size_t maxStackSize)
532 {
533     VM& vm = m_vm;
534     ASSERT(!vm.topCallFrame->hasHostCallFrameFlag());
535     CallFrame* callFrame = vm.topCallFrame;
536     if (!callFrame)
537         return;
538     StackIterator iter = callFrame->begin();
539     for (; iter != callFrame->end() && maxStackSize--; ++iter) {
540         if (iter->isJSFrame()) {
541             CodeBlock* codeBlock = iter->codeBlock();
542             StackFrame s = {
543                 Strong<JSObject>(vm, iter->callee()),
544                 getStackFrameCodeType(iter),
545                 Strong<ExecutableBase>(vm, codeBlock->ownerExecutable()),
546                 Strong<UnlinkedCodeBlock>(vm, codeBlock->unlinkedCodeBlock()),
547                 codeBlock->source(),
548                 codeBlock->ownerExecutable()->lineNo(),
549                 codeBlock->firstLineColumnOffset(),
550                 codeBlock->sourceOffset(),
551                 iter->bytecodeOffset(),
552                 iter->sourceURL()
553             };
554             results.append(s);
555         } else {
556             StackFrame s = { Strong<JSObject>(vm, iter->callee()), StackFrameNativeCode, Strong<ExecutableBase>(), Strong<UnlinkedCodeBlock>(), 0, 0, 0, 0, 0, String()};
557             results.append(s);
558         }
559     }
560 }
561 JSString* Interpreter:: stackTraceAsString(ExecState* exec, Vector<StackFrame> stackTrace)
562 {
563     // FIXME: JSStringJoiner could be more efficient than StringBuilder here.
564     StringBuilder builder;
565     for (unsigned i = 0; i < stackTrace.size(); i++) {
566         builder.append(String(stackTrace[i].toString(exec)));
567         if (i != stackTrace.size() - 1)
568             builder.append('\n');
569     }
570     return jsString(&exec->vm(), builder.toString());
571 }
572     
573 void Interpreter::addStackTraceIfNecessary(CallFrame* callFrame, JSValue error)
574 {
575     VM* vm = &callFrame->vm();
576     ASSERT(callFrame == vm->topCallFrame || callFrame == callFrame->lexicalGlobalObject()->globalExec() || callFrame == callFrame->dynamicGlobalObject()->globalExec());
577
578     Vector<StackFrame> stackTrace;
579     vm->interpreter->getStackTrace(stackTrace);
580     vm->exceptionStack() = RefCountedArray<StackFrame>(stackTrace);
581     if (stackTrace.isEmpty() || !error.isObject())
582         return;
583
584     if (asObject(error)->hasProperty(callFrame, vm->propertyNames->stack))
585         return;
586     
587     asObject(error)->putDirect(*vm, vm->propertyNames->stack, vm->interpreter->stackTraceAsString(vm->topCallFrame, stackTrace), None);
588
589 }
590
591 NEVER_INLINE HandlerInfo* Interpreter::throwException(CallFrame*& callFrame, JSValue& exceptionValue, unsigned bytecodeOffset)
592 {
593     CodeBlock* codeBlock = callFrame->codeBlock();
594     bool isTermination = false;
595
596     ASSERT(!exceptionValue.isEmpty());
597     ASSERT(!exceptionValue.isCell() || exceptionValue.asCell());
598     // This shouldn't be possible (hence the assertions), but we're already in the slowest of
599     // slow cases, so let's harden against it anyway to be safe.
600     if (exceptionValue.isEmpty() || (exceptionValue.isCell() && !exceptionValue.asCell()))
601         exceptionValue = jsNull();
602
603     // Set up the exception object
604     if (exceptionValue.isObject()) {
605         JSObject* exception = asObject(exceptionValue);
606
607         if (exception->isErrorInstance() && static_cast<ErrorInstance*>(exception)->appendSourceToMessage())
608             appendSourceToError(callFrame, static_cast<ErrorInstance*>(exception), bytecodeOffset);
609
610         if (!hasErrorInfo(callFrame, exception)) {
611             // FIXME: should only really be adding these properties to VM generated exceptions,
612             // but the inspector currently requires these for all thrown objects.
613             addErrorInfo(callFrame, exception, codeBlock->lineNumberForBytecodeOffset(bytecodeOffset), codeBlock->ownerExecutable()->source());
614         }
615
616         isTermination = isTerminatedExecutionException(exception);
617     } else {
618         if (!callFrame->vm().exceptionStack().size()) {
619             Vector<StackFrame> stack;
620             callFrame->vm().interpreter->getStackTrace(stack);
621             callFrame->vm().exceptionStack() = RefCountedArray<StackFrame>(stack);
622         }
623     }
624
625     if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {
626         DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);
627         bool hasHandler = codeBlock->handlerForBytecodeOffset(bytecodeOffset);
628         debugger->exception(debuggerCallFrame, codeBlock->ownerExecutable()->sourceID(), codeBlock->lineNumberForBytecodeOffset(bytecodeOffset), 0, hasHandler);
629     }
630
631     // Calculate an exception handler vPC, unwinding call frames as necessary.
632     HandlerInfo* handler = 0;
633     VM& vm = callFrame->vm();
634     ASSERT(callFrame == vm.topCallFrame);
635     for (StackIterator iter = callFrame->begin(); iter != callFrame->end(); ++iter) {
636         callFrame = iter->callFrame();
637         codeBlock = iter->codeBlock();
638         bytecodeOffset = iter->bytecodeOffset();
639
640         if (isTermination || !(handler = codeBlock->handlerForBytecodeOffset(bytecodeOffset))) {
641             if (!unwindCallFrame(iter, exceptionValue)) {
642                 if (LegacyProfiler* profiler = vm.enabledProfiler())
643                     profiler->exceptionUnwind(callFrame);
644                 return 0;
645             }
646         } else
647             break;
648     }
649
650     if (LegacyProfiler* profiler = callFrame->vm().enabledProfiler())
651         profiler->exceptionUnwind(callFrame);
652
653     // Unwind the scope chain within the exception handler's call frame.
654     int targetScopeDepth = handler->scopeDepth;
655     if (codeBlock->needsActivation() && callFrame->uncheckedR(codeBlock->activationRegister()).jsValue())
656         ++targetScopeDepth;
657
658     JSScope* scope = callFrame->scope();
659     int scopeDelta = scope->depth() - targetScopeDepth;
660     RELEASE_ASSERT(scopeDelta >= 0);
661
662     while (scopeDelta--)
663         scope = scope->next();
664     callFrame->setScope(scope);
665
666     return handler;
667 }
668
669 static inline JSValue checkedReturn(JSValue returnValue)
670 {
671     ASSERT(returnValue);
672     return returnValue;
673 }
674
675 static inline JSObject* checkedReturn(JSObject* returnValue)
676 {
677     ASSERT(returnValue);
678     return returnValue;
679 }
680
681 class SamplingScope {
682 public:
683     SamplingScope(Interpreter* interpreter)
684         : m_interpreter(interpreter)
685     {
686         interpreter->startSampling();
687     }
688     ~SamplingScope()
689     {
690         m_interpreter->stopSampling();
691     }
692 private:
693     Interpreter* m_interpreter;
694 };
695
696 JSValue Interpreter::execute(ProgramExecutable* program, CallFrame* callFrame, JSObject* thisObj)
697 {
698     SamplingScope samplingScope(this);
699     
700     JSScope* scope = callFrame->scope();
701     VM& vm = *scope->vm();
702
703     ASSERT(!vm.exception);
704     ASSERT(!vm.isCollectorBusy());
705     if (vm.isCollectorBusy())
706         return jsNull();
707
708     StackStats::CheckPoint stackCheckPoint;
709     const VMStackBounds vmStackBounds(vm, wtfThreadData().stack());
710     if (!vmStackBounds.isSafeToRecurse())
711         return checkedReturn(throwStackOverflowError(callFrame));
712
713     // First check if the "program" is actually just a JSON object. If so,
714     // we'll handle the JSON object here. Else, we'll handle real JS code
715     // below at failedJSONP.
716     DynamicGlobalObjectScope globalObjectScope(vm, scope->globalObject());
717     Vector<JSONPData> JSONPData;
718     bool parseResult;
719     const String programSource = program->source().toString();
720     if (programSource.isNull())
721         return jsUndefined();
722     if (programSource.is8Bit()) {
723         LiteralParser<LChar> literalParser(callFrame, programSource.characters8(), programSource.length(), JSONP);
724         parseResult = literalParser.tryJSONPParse(JSONPData, scope->globalObject()->globalObjectMethodTable()->supportsRichSourceInfo(scope->globalObject()));
725     } else {
726         LiteralParser<UChar> literalParser(callFrame, programSource.characters16(), programSource.length(), JSONP);
727         parseResult = literalParser.tryJSONPParse(JSONPData, scope->globalObject()->globalObjectMethodTable()->supportsRichSourceInfo(scope->globalObject()));
728     }
729
730     if (parseResult) {
731         JSGlobalObject* globalObject = scope->globalObject();
732         JSValue result;
733         for (unsigned entry = 0; entry < JSONPData.size(); entry++) {
734             Vector<JSONPPathEntry> JSONPPath;
735             JSONPPath.swap(JSONPData[entry].m_path);
736             JSValue JSONPValue = JSONPData[entry].m_value.get();
737             if (JSONPPath.size() == 1 && JSONPPath[0].m_type == JSONPPathEntryTypeDeclare) {
738                 globalObject->addVar(callFrame, JSONPPath[0].m_pathEntryName);
739                 PutPropertySlot slot;
740                 globalObject->methodTable()->put(globalObject, callFrame, JSONPPath[0].m_pathEntryName, JSONPValue, slot);
741                 result = jsUndefined();
742                 continue;
743             }
744             JSValue baseObject(globalObject);
745             for (unsigned i = 0; i < JSONPPath.size() - 1; i++) {
746                 ASSERT(JSONPPath[i].m_type != JSONPPathEntryTypeDeclare);
747                 switch (JSONPPath[i].m_type) {
748                 case JSONPPathEntryTypeDot: {
749                     if (i == 0) {
750                         PropertySlot slot(globalObject);
751                         if (!globalObject->getPropertySlot(callFrame, JSONPPath[i].m_pathEntryName, slot)) {
752                             if (entry)
753                                 return throwError(callFrame, createUndefinedVariableError(globalObject->globalExec(), JSONPPath[i].m_pathEntryName));
754                             goto failedJSONP;
755                         }
756                         baseObject = slot.getValue(callFrame, JSONPPath[i].m_pathEntryName);
757                     } else
758                         baseObject = baseObject.get(callFrame, JSONPPath[i].m_pathEntryName);
759                     if (callFrame->hadException())
760                         return jsUndefined();
761                     continue;
762                 }
763                 case JSONPPathEntryTypeLookup: {
764                     baseObject = baseObject.get(callFrame, JSONPPath[i].m_pathIndex);
765                     if (callFrame->hadException())
766                         return jsUndefined();
767                     continue;
768                 }
769                 default:
770                     RELEASE_ASSERT_NOT_REACHED();
771                     return jsUndefined();
772                 }
773             }
774             PutPropertySlot slot;
775             switch (JSONPPath.last().m_type) {
776             case JSONPPathEntryTypeCall: {
777                 JSValue function = baseObject.get(callFrame, JSONPPath.last().m_pathEntryName);
778                 if (callFrame->hadException())
779                     return jsUndefined();
780                 CallData callData;
781                 CallType callType = getCallData(function, callData);
782                 if (callType == CallTypeNone)
783                     return throwError(callFrame, createNotAFunctionError(callFrame, function));
784                 MarkedArgumentBuffer jsonArg;
785                 jsonArg.append(JSONPValue);
786                 JSValue thisValue = JSONPPath.size() == 1 ? jsUndefined(): baseObject;
787                 JSONPValue = JSC::call(callFrame, function, callType, callData, thisValue, jsonArg);
788                 if (callFrame->hadException())
789                     return jsUndefined();
790                 break;
791             }
792             case JSONPPathEntryTypeDot: {
793                 baseObject.put(callFrame, JSONPPath.last().m_pathEntryName, JSONPValue, slot);
794                 if (callFrame->hadException())
795                     return jsUndefined();
796                 break;
797             }
798             case JSONPPathEntryTypeLookup: {
799                 baseObject.putByIndex(callFrame, JSONPPath.last().m_pathIndex, JSONPValue, slot.isStrictMode());
800                 if (callFrame->hadException())
801                     return jsUndefined();
802                 break;
803             }
804             default:
805                 RELEASE_ASSERT_NOT_REACHED();
806                     return jsUndefined();
807             }
808             result = JSONPValue;
809         }
810         return result;
811     }
812 failedJSONP:
813     // If we get here, then we have already proven that the script is not a JSON
814     // object.
815
816     // Compile source to bytecode if necessary:
817     if (JSObject* error = program->initializeGlobalProperties(vm, callFrame, scope))
818         return checkedReturn(throwError(callFrame, error));
819
820     if (JSObject* error = program->compile(callFrame, scope))
821         return checkedReturn(throwError(callFrame, error));
822
823     ProgramCodeBlock* codeBlock = &program->generatedBytecode();
824
825     if (UNLIKELY(vm.watchdog.didFire(callFrame)))
826         return throwTerminatedExecutionException(callFrame);
827
828     // Push the call frame for this invocation:
829     ASSERT(codeBlock->numParameters() == 1); // 1 parameter for 'this'.
830     CallFrame* newCallFrame = m_stack.pushFrame(callFrame, codeBlock, scope, 1, 0);
831     if (UNLIKELY(!newCallFrame))
832         return checkedReturn(throwStackOverflowError(callFrame));
833
834     // Set the arguments for the callee:
835     newCallFrame->setThisValue(thisObj);
836
837     if (LegacyProfiler* profiler = vm.enabledProfiler())
838         profiler->willExecute(callFrame, program->sourceURL(), program->lineNo());
839
840     // Execute the code:
841     JSValue result;
842     {
843         SamplingTool::CallRecord callRecord(m_sampler.get());
844         Watchdog::Scope watchdogScope(vm.watchdog);
845
846 #if ENABLE(LLINT_C_LOOP)
847         result = LLInt::CLoop::execute(newCallFrame, llint_program_prologue);
848 #elif ENABLE(JIT)
849         result = program->generatedJITCode()->execute(&m_stack, newCallFrame, &vm);
850 #endif // ENABLE(JIT)
851     }
852
853     if (LegacyProfiler* profiler = vm.enabledProfiler())
854         profiler->didExecute(callFrame, program->sourceURL(), program->lineNo());
855
856     m_stack.popFrame(newCallFrame);
857
858     return checkedReturn(result);
859 }
860
861 JSValue Interpreter::executeCall(CallFrame* callFrame, JSObject* function, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args)
862 {
863     VM& vm = callFrame->vm();
864     ASSERT(!callFrame->hadException());
865     ASSERT(!vm.isCollectorBusy());
866     if (vm.isCollectorBusy())
867         return jsNull();
868
869     StackStats::CheckPoint stackCheckPoint;
870     const VMStackBounds vmStackBounds(vm, wtfThreadData().stack());
871     if (!vmStackBounds.isSafeToRecurse())
872         return checkedReturn(throwStackOverflowError(callFrame));
873
874     bool isJSCall = (callType == CallTypeJS);
875     JSScope* scope;
876     CodeBlock* newCodeBlock;
877     size_t argsCount = 1 + args.size(); // implicit "this" parameter
878
879     if (isJSCall)
880         scope = callData.js.scope;
881     else {
882         ASSERT(callType == CallTypeHost);
883         scope = callFrame->scope();
884     }
885     DynamicGlobalObjectScope globalObjectScope(vm, scope->globalObject());
886
887     if (isJSCall) {
888         // Compile the callee:
889         JSObject* compileError = callData.js.functionExecutable->compileForCall(callFrame, scope);
890         if (UNLIKELY(!!compileError)) {
891             return checkedReturn(throwError(callFrame, compileError));
892         }
893         newCodeBlock = &callData.js.functionExecutable->generatedBytecodeForCall();
894         ASSERT(!!newCodeBlock);
895         newCodeBlock->m_shouldAlwaysBeInlined = false;
896     } else
897         newCodeBlock = 0;
898
899     if (UNLIKELY(vm.watchdog.didFire(callFrame)))
900         return throwTerminatedExecutionException(callFrame);
901
902     CallFrame* newCallFrame = m_stack.pushFrame(callFrame, newCodeBlock, scope, argsCount, function);
903     if (UNLIKELY(!newCallFrame))
904         return checkedReturn(throwStackOverflowError(callFrame));
905
906     // Set the arguments for the callee:
907     newCallFrame->setThisValue(thisValue);
908     for (size_t i = 0; i < args.size(); ++i)
909         newCallFrame->setArgument(i, args.at(i));
910
911     if (LegacyProfiler* profiler = vm.enabledProfiler())
912         profiler->willExecute(callFrame, function);
913
914     JSValue result;
915     {
916         SamplingTool::CallRecord callRecord(m_sampler.get(), !isJSCall);
917         Watchdog::Scope watchdogScope(vm.watchdog);
918
919         // Execute the code:
920         if (isJSCall) {
921 #if ENABLE(LLINT_C_LOOP)
922             result = LLInt::CLoop::execute(newCallFrame, llint_function_for_call_prologue);
923 #elif ENABLE(JIT)
924             result = callData.js.functionExecutable->generatedJITCodeForCall()->execute(&m_stack, newCallFrame, &vm);
925 #endif // ENABLE(JIT)
926         } else
927             result = JSValue::decode(callData.native.function(newCallFrame));
928     }
929
930     if (LegacyProfiler* profiler = vm.enabledProfiler())
931         profiler->didExecute(callFrame, function);
932
933     m_stack.popFrame(newCallFrame);
934     return checkedReturn(result);
935 }
936
937 JSObject* Interpreter::executeConstruct(CallFrame* callFrame, JSObject* constructor, ConstructType constructType, const ConstructData& constructData, const ArgList& args)
938 {
939     VM& vm = callFrame->vm();
940     ASSERT(!callFrame->hadException());
941     ASSERT(!vm.isCollectorBusy());
942     // We throw in this case because we have to return something "valid" but we're
943     // already in an invalid state.
944     if (vm.isCollectorBusy())
945         return checkedReturn(throwStackOverflowError(callFrame));
946
947     StackStats::CheckPoint stackCheckPoint;
948     const VMStackBounds vmStackBounds(vm, wtfThreadData().stack());
949     if (!vmStackBounds.isSafeToRecurse())
950         return checkedReturn(throwStackOverflowError(callFrame));
951
952     bool isJSConstruct = (constructType == ConstructTypeJS);
953     JSScope* scope;
954     CodeBlock* newCodeBlock;
955     size_t argsCount = 1 + args.size(); // implicit "this" parameter
956
957     if (isJSConstruct)
958         scope = constructData.js.scope;
959     else {
960         ASSERT(constructType == ConstructTypeHost);
961         scope = callFrame->scope();
962     }
963
964     DynamicGlobalObjectScope globalObjectScope(vm, scope->globalObject());
965
966     if (isJSConstruct) {
967         // Compile the callee:
968         JSObject* compileError = constructData.js.functionExecutable->compileForConstruct(callFrame, scope);
969         if (UNLIKELY(!!compileError)) {
970             return checkedReturn(throwError(callFrame, compileError));
971         }
972         newCodeBlock = &constructData.js.functionExecutable->generatedBytecodeForConstruct();
973         ASSERT(!!newCodeBlock);
974         newCodeBlock->m_shouldAlwaysBeInlined = false;
975     } else
976         newCodeBlock = 0;
977
978     if (UNLIKELY(vm.watchdog.didFire(callFrame)))
979         return throwTerminatedExecutionException(callFrame);
980
981     CallFrame* newCallFrame = m_stack.pushFrame(callFrame, newCodeBlock, scope, argsCount, constructor);
982     if (UNLIKELY(!newCallFrame))
983         return checkedReturn(throwStackOverflowError(callFrame));
984
985     // Set the arguments for the callee:
986     newCallFrame->setThisValue(jsUndefined());
987     for (size_t i = 0; i < args.size(); ++i)
988         newCallFrame->setArgument(i, args.at(i));
989
990     if (LegacyProfiler* profiler = vm.enabledProfiler())
991         profiler->willExecute(callFrame, constructor);
992
993     JSValue result;
994     {
995         SamplingTool::CallRecord callRecord(m_sampler.get(), !isJSConstruct);
996         Watchdog::Scope watchdogScope(vm.watchdog);
997
998         // Execute the code.
999         if (isJSConstruct) {
1000 #if ENABLE(LLINT_C_LOOP)
1001             result = LLInt::CLoop::execute(newCallFrame, llint_function_for_construct_prologue);
1002 #elif ENABLE(JIT)
1003             result = constructData.js.functionExecutable->generatedJITCodeForConstruct()->execute(&m_stack, newCallFrame, &vm);
1004 #endif // ENABLE(JIT)
1005         } else {
1006             result = JSValue::decode(constructData.native.function(newCallFrame));
1007             if (!callFrame->hadException()) {
1008                 ASSERT_WITH_MESSAGE(result.isObject(), "Host constructor returned non object.");
1009                 if (!result.isObject())
1010                     throwTypeError(newCallFrame);
1011             }
1012         }
1013     }
1014
1015     if (LegacyProfiler* profiler = vm.enabledProfiler())
1016         profiler->didExecute(callFrame, constructor);
1017
1018     m_stack.popFrame(newCallFrame);
1019
1020     if (callFrame->hadException())
1021         return 0;
1022     ASSERT(result.isObject());
1023     return checkedReturn(asObject(result));
1024 }
1025
1026 CallFrameClosure Interpreter::prepareForRepeatCall(FunctionExecutable* functionExecutable, CallFrame* callFrame, JSFunction* function, int argumentCountIncludingThis, JSScope* scope)
1027 {
1028     VM& vm = *scope->vm();
1029     ASSERT(!vm.exception);
1030     
1031     if (vm.isCollectorBusy())
1032         return CallFrameClosure();
1033
1034     StackStats::CheckPoint stackCheckPoint;
1035     const VMStackBounds vmStackBounds(vm, wtfThreadData().stack());
1036     if (!vmStackBounds.isSafeToRecurse()) {
1037         throwStackOverflowError(callFrame);
1038         return CallFrameClosure();
1039     }
1040
1041     // Compile the callee:
1042     JSObject* error = functionExecutable->compileForCall(callFrame, scope);
1043     if (error) {
1044         throwError(callFrame, error);
1045         return CallFrameClosure();
1046     }
1047     CodeBlock* newCodeBlock = &functionExecutable->generatedBytecodeForCall();
1048     newCodeBlock->m_shouldAlwaysBeInlined = false;
1049
1050     size_t argsCount = argumentCountIncludingThis;
1051
1052     CallFrame* newCallFrame = m_stack.pushFrame(callFrame, newCodeBlock, scope, argsCount, function);  
1053     if (UNLIKELY(!newCallFrame)) {
1054         throwStackOverflowError(callFrame);
1055         return CallFrameClosure();
1056     }
1057
1058     if (UNLIKELY(!newCallFrame)) {
1059         throwStackOverflowError(callFrame);
1060         return CallFrameClosure();
1061     }
1062
1063     // Return the successful closure:
1064     CallFrameClosure result = { callFrame, newCallFrame, function, functionExecutable, &vm, scope, newCodeBlock->numParameters(), argumentCountIncludingThis };
1065     return result;
1066 }
1067
1068 JSValue Interpreter::execute(CallFrameClosure& closure) 
1069 {
1070     VM& vm = *closure.vm;
1071     SamplingScope samplingScope(this);
1072     
1073     ASSERT(!vm.isCollectorBusy());
1074     if (vm.isCollectorBusy())
1075         return jsNull();
1076
1077     StackStats::CheckPoint stackCheckPoint;
1078     m_stack.validateFence(closure.newCallFrame, "BEFORE");
1079     closure.resetCallFrame();
1080     m_stack.validateFence(closure.newCallFrame, "STEP 1");
1081
1082     if (LegacyProfiler* profiler = vm.enabledProfiler())
1083         profiler->willExecute(closure.oldCallFrame, closure.function);
1084
1085     if (UNLIKELY(vm.watchdog.didFire(closure.oldCallFrame)))
1086         return throwTerminatedExecutionException(closure.oldCallFrame);
1087
1088     // The code execution below may push more frames and point the topCallFrame
1089     // to those newer frames, or it may pop to the top frame to the caller of
1090     // the current repeat frame, or it may leave the top frame pointing to the
1091     // current repeat frame.
1092     //
1093     // Hence, we need to preserve the topCallFrame here ourselves before
1094     // repeating this call on a second callback function.
1095
1096     TopCallFrameSetter topCallFrame(vm, closure.newCallFrame);
1097
1098     // Execute the code:
1099     JSValue result;
1100     {
1101         SamplingTool::CallRecord callRecord(m_sampler.get());
1102         Watchdog::Scope watchdogScope(vm.watchdog);
1103
1104 #if ENABLE(LLINT_C_LOOP)
1105         result = LLInt::CLoop::execute(closure.newCallFrame, llint_function_for_call_prologue);
1106 #elif ENABLE(JIT)
1107         result = closure.functionExecutable->generatedJITCodeForCall()->execute(&m_stack, closure.newCallFrame, &vm);
1108 #endif // ENABLE(JIT)
1109     }
1110
1111     if (LegacyProfiler* profiler = vm.enabledProfiler())
1112         profiler->didExecute(closure.oldCallFrame, closure.function);
1113
1114     m_stack.validateFence(closure.newCallFrame, "AFTER");
1115     return checkedReturn(result);
1116 }
1117
1118 void Interpreter::endRepeatCall(CallFrameClosure& closure)
1119 {
1120     m_stack.popFrame(closure.newCallFrame);
1121 }
1122
1123 JSValue Interpreter::execute(EvalExecutable* eval, CallFrame* callFrame, JSValue thisValue, JSScope* scope)
1124 {
1125     VM& vm = *scope->vm();
1126     SamplingScope samplingScope(this);
1127     
1128     ASSERT(scope->vm() == &callFrame->vm());
1129     ASSERT(!vm.exception);
1130     ASSERT(!vm.isCollectorBusy());
1131     if (vm.isCollectorBusy())
1132         return jsNull();
1133
1134     DynamicGlobalObjectScope globalObjectScope(vm, scope->globalObject());
1135
1136     StackStats::CheckPoint stackCheckPoint;
1137     const VMStackBounds vmStackBounds(vm, wtfThreadData().stack());
1138     if (!vmStackBounds.isSafeToRecurse())
1139         return checkedReturn(throwStackOverflowError(callFrame));
1140
1141     unsigned numVariables = eval->numVariables();
1142     int numFunctions = eval->numberOfFunctionDecls();
1143
1144     JSScope* variableObject;
1145     if ((numVariables || numFunctions) && eval->isStrictMode()) {
1146         scope = StrictEvalActivation::create(callFrame);
1147         variableObject = scope;
1148     } else {
1149         for (JSScope* node = scope; ; node = node->next()) {
1150             RELEASE_ASSERT(node);
1151             if (node->isVariableObject() && !node->isNameScopeObject()) {
1152                 variableObject = node;
1153                 break;
1154             }
1155         }
1156     }
1157
1158     JSObject* compileError = eval->compile(callFrame, scope);
1159     if (UNLIKELY(!!compileError))
1160         return checkedReturn(throwError(callFrame, compileError));
1161     EvalCodeBlock* codeBlock = &eval->generatedBytecode();
1162
1163     if (numVariables || numFunctions) {
1164         BatchedTransitionOptimizer optimizer(vm, variableObject);
1165         if (variableObject->next())
1166             variableObject->globalObject()->varInjectionWatchpoint()->notifyWrite();
1167
1168         for (unsigned i = 0; i < numVariables; ++i) {
1169             const Identifier& ident = codeBlock->variable(i);
1170             if (!variableObject->hasProperty(callFrame, ident)) {
1171                 PutPropertySlot slot;
1172                 variableObject->methodTable()->put(variableObject, callFrame, ident, jsUndefined(), slot);
1173             }
1174         }
1175
1176         for (int i = 0; i < numFunctions; ++i) {
1177             FunctionExecutable* function = codeBlock->functionDecl(i);
1178             PutPropertySlot slot;
1179             variableObject->methodTable()->put(variableObject, callFrame, function->name(), JSFunction::create(callFrame, function, scope), slot);
1180         }
1181     }
1182
1183     if (UNLIKELY(vm.watchdog.didFire(callFrame)))
1184         return throwTerminatedExecutionException(callFrame);
1185
1186     // Push the frame:
1187     ASSERT(codeBlock->numParameters() == 1); // 1 parameter for 'this'.
1188     CallFrame* newCallFrame = m_stack.pushFrame(callFrame, codeBlock, scope, 1, 0);
1189     if (UNLIKELY(!newCallFrame))
1190         return checkedReturn(throwStackOverflowError(callFrame));
1191
1192     // Set the arguments for the callee:
1193     newCallFrame->setThisValue(thisValue);
1194
1195     if (LegacyProfiler* profiler = vm.enabledProfiler())
1196         profiler->willExecute(callFrame, eval->sourceURL(), eval->lineNo());
1197
1198     // Execute the code:
1199     JSValue result;
1200     {
1201         SamplingTool::CallRecord callRecord(m_sampler.get());
1202         Watchdog::Scope watchdogScope(vm.watchdog);
1203
1204 #if ENABLE(LLINT_C_LOOP)
1205         result = LLInt::CLoop::execute(newCallFrame, llint_eval_prologue);
1206 #elif ENABLE(JIT)
1207         result = eval->generatedJITCode()->execute(&m_stack, newCallFrame, &vm);
1208 #endif // ENABLE(JIT)
1209     }
1210
1211     if (LegacyProfiler* profiler = vm.enabledProfiler())
1212         profiler->didExecute(callFrame, eval->sourceURL(), eval->lineNo());
1213
1214     m_stack.popFrame(newCallFrame);
1215     return checkedReturn(result);
1216 }
1217
1218 NEVER_INLINE void Interpreter::debug(CallFrame* callFrame, DebugHookID debugHookID, int firstLine, int lastLine, int column)
1219 {
1220     Debugger* debugger = callFrame->dynamicGlobalObject()->debugger();
1221     if (!debugger)
1222         return;
1223
1224     switch (debugHookID) {
1225         case DidEnterCallFrame:
1226             debugger->callEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine, column);
1227             return;
1228         case WillLeaveCallFrame:
1229             debugger->returnEvent(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine, column);
1230             return;
1231         case WillExecuteStatement:
1232             debugger->atStatement(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine, column);
1233             return;
1234         case WillExecuteProgram:
1235             debugger->willExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), firstLine, column);
1236             return;
1237         case DidExecuteProgram:
1238             debugger->didExecuteProgram(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine, column);
1239             return;
1240         case DidReachBreakpoint:
1241             debugger->didReachBreakpoint(callFrame, callFrame->codeBlock()->ownerExecutable()->sourceID(), lastLine, column);
1242             return;
1243     }
1244 }    
1245
1246 void Interpreter::enableSampler()
1247 {
1248 #if ENABLE(OPCODE_SAMPLING)
1249     if (!m_sampler) {
1250         m_sampler = adoptPtr(new SamplingTool(this));
1251         m_sampler->setup();
1252     }
1253 #endif
1254 }
1255 void Interpreter::dumpSampleData(ExecState* exec)
1256 {
1257 #if ENABLE(OPCODE_SAMPLING)
1258     if (m_sampler)
1259         m_sampler->dump(exec);
1260 #else
1261     UNUSED_PARAM(exec);
1262 #endif
1263 }
1264 void Interpreter::startSampling()
1265 {
1266 #if ENABLE(SAMPLING_THREAD)
1267     if (!m_sampleEntryDepth)
1268         SamplingThread::start();
1269
1270     m_sampleEntryDepth++;
1271 #endif
1272 }
1273 void Interpreter::stopSampling()
1274 {
1275 #if ENABLE(SAMPLING_THREAD)
1276     m_sampleEntryDepth--;
1277     if (!m_sampleEntryDepth)
1278         SamplingThread::stop();
1279 #endif
1280 }
1281
1282 } // namespace JSC