Ignore:
Timestamp:
Oct 9, 2012, 12:12:56 AM (13 years ago)
Author:
[email protected]
Message:

Renamed RegisterFile to JSStack, and removed prototype of the
previously deleted Interpreter::privateExecute().
​https://bugs.webkit.org/show_bug.cgi?id=98717.

Reviewed by Filip Pizlo.

  • CMakeLists.txt:
  • GNUmakefile.list.am:
  • JavaScriptCore.order:
  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
  • JavaScriptCore.xcodeproj/project.pbxproj:
  • Target.pri:
  • bytecode/BytecodeConventions.h:
  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::nameForRegister):

  • bytecode/CodeBlock.h:

(CodeBlock):

  • bytecode/ValueRecovery.h:

(JSC::ValueRecovery::alreadyInJSStack):
(JSC::ValueRecovery::alreadyInJSStackAsUnboxedInt32):
(JSC::ValueRecovery::alreadyInJSStackAsUnboxedCell):
(JSC::ValueRecovery::alreadyInJSStackAsUnboxedBoolean):
(JSC::ValueRecovery::alreadyInJSStackAsUnboxedDouble):
(JSC::ValueRecovery::displacedInJSStack):
(JSC::ValueRecovery::isAlreadyInJSStack):
(JSC::ValueRecovery::virtualRegister):
(JSC::ValueRecovery::dump):

  • bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::resolveCallee):
(JSC::BytecodeGenerator::emitCall):
(JSC::BytecodeGenerator::emitConstruct):

  • bytecompiler/BytecodeGenerator.h:

(JSC::BytecodeGenerator::registerFor):

  • dfg/DFGAbstractState.h:

(AbstractState):

  • dfg/DFGAssemblyHelpers.h:

(JSC::DFG::AssemblyHelpers::emitGetFromCallFrameHeaderPtr):
(JSC::DFG::AssemblyHelpers::emitPutToCallFrameHeader):
(JSC::DFG::AssemblyHelpers::emitPutImmediateToCallFrameHeader):

  • dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::getDirect):
(JSC::DFG::ByteCodeParser::findArgumentPositionForLocal):
(JSC::DFG::ByteCodeParser::addCall):
(JSC::DFG::ByteCodeParser::InlineStackEntry::remapOperand):
(JSC::DFG::ByteCodeParser::handleInlining):
(JSC::DFG::ByteCodeParser::parseBlock):
(JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):

  • dfg/DFGGenerationInfo.h:

(GenerationInfo):
(JSC::DFG::GenerationInfo::needsSpill):

  • dfg/DFGGraph.h:
  • dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::compileEntry):
(JSC::DFG::JITCompiler::compileFunction):

  • dfg/DFGJITCompiler.h:

(JSC::DFG::JITCompiler::beginCall):

  • dfg/DFGOSREntry.cpp:

(JSC::DFG::prepareOSREntry):

  • dfg/DFGOSRExitCompiler32_64.cpp:

(JSC::DFG::OSRExitCompiler::compileExit):

  • dfg/DFGOSRExitCompiler64.cpp:

(JSC::DFG::OSRExitCompiler::compileExit):

  • dfg/DFGRepatch.cpp:

(JSC::DFG::tryBuildGetByIDList):

  • dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compile):
(JSC::DFG::SpeculativeJIT::checkArgumentTypes):
(JSC::DFG::SpeculativeJIT::computeValueRecoveryFor):

  • dfg/DFGSpeculativeJIT.h:

(SpeculativeJIT):
(JSC::DFG::SpeculativeJIT::spill):

  • dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::emitCall):
(JSC::DFG::SpeculativeJIT::compile):

  • dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::fillInteger):
(JSC::DFG::SpeculativeJIT::emitCall):
(JSC::DFG::SpeculativeJIT::compile):

  • dfg/DFGThunks.cpp:

(JSC::DFG::throwExceptionFromCallSlowPathGenerator):
(JSC::DFG::slowPathFor):
(JSC::DFG::virtualForThunkGenerator):

  • dfg/DFGValueSource.cpp:

(JSC::DFG::ValueSource::dump):

  • dfg/DFGValueSource.h:

(JSC::DFG::dataFormatToValueSourceKind):
(JSC::DFG::valueSourceKindToDataFormat):
(JSC::DFG::isInJSStack):
(JSC::DFG::ValueSource::forSpeculation):
(JSC::DFG::ValueSource::isInJSStack):
(JSC::DFG::ValueSource::valueRecovery):

  • dfg/DFGVariableEventStream.cpp:

(JSC::DFG::VariableEventStream::reconstruct):

  • heap/Heap.cpp:

(JSC::Heap::stack):
(JSC::Heap::getConservativeRegisterRoots):
(JSC::Heap::markRoots):

  • heap/Heap.h:

(JSC):
(Heap):

  • interpreter/CallFrame.cpp:

(JSC::CallFrame::stack):

  • interpreter/CallFrame.h:

(JSC::ExecState::calleeAsValue):
(JSC::ExecState::callee):
(JSC::ExecState::codeBlock):
(JSC::ExecState::scope):
(JSC::ExecState::callerFrame):
(JSC::ExecState::returnPC):
(JSC::ExecState::hasReturnPC):
(JSC::ExecState::clearReturnPC):
(JSC::ExecState::bytecodeOffsetForNonDFGCode):
(JSC::ExecState::setBytecodeOffsetForNonDFGCode):
(JSC::ExecState::inlineCallFrame):
(JSC::ExecState::codeOriginIndexForDFG):
(JSC::ExecState::currentVPC):
(JSC::ExecState::setCurrentVPC):
(JSC::ExecState::setCallerFrame):
(JSC::ExecState::setScope):
(JSC::ExecState::init):
(JSC::ExecState::argumentCountIncludingThis):
(JSC::ExecState::offsetFor):
(JSC::ExecState::setArgumentCountIncludingThis):
(JSC::ExecState::setCallee):
(JSC::ExecState::setCodeBlock):
(JSC::ExecState::setReturnPC):
(JSC::ExecState::setInlineCallFrame):
(ExecState):

  • interpreter/Interpreter.cpp:

(JSC::Interpreter::slideRegisterWindowForCall):
(JSC::eval):
(JSC::loadVarargs):
(JSC::Interpreter::dumpRegisters):
(JSC::Interpreter::throwException):
(JSC::Interpreter::execute):
(JSC::Interpreter::executeCall):
(JSC::Interpreter::executeConstruct):
(JSC::Interpreter::prepareForRepeatCall):
(JSC::Interpreter::endRepeatCall):

  • interpreter/Interpreter.h:

(JSC::Interpreter::stack):
(Interpreter):
(JSC::Interpreter::execute):
(JSC):

  • interpreter/JSStack.cpp: Copied from Source/JavaScriptCore/interpreter/RegisterFile.cpp.

(JSC::stackStatisticsMutex):
(JSC::JSStack::~JSStack):
(JSC::JSStack::growSlowCase):
(JSC::JSStack::gatherConservativeRoots):
(JSC::JSStack::releaseExcessCapacity):
(JSC::JSStack::initializeThreading):
(JSC::JSStack::committedByteCount):
(JSC::JSStack::addToCommittedByteCount):

  • interpreter/JSStack.h: Copied from Source/JavaScriptCore/interpreter/RegisterFile.h.

(JSStack):
(JSC::JSStack::JSStack):
(JSC::JSStack::shrink):
(JSC::JSStack::grow):

  • interpreter/RegisterFile.cpp: Removed.
  • interpreter/RegisterFile.h: Removed.
  • interpreter/VMInspector.cpp:

(JSC::VMInspector::dumpFrame):

  • jit/JIT.cpp:

(JSC::JIT::JIT):
(JSC::JIT::privateCompile):

  • jit/JIT.h:

(JSC):
(JIT):

  • jit/JITCall.cpp:

(JSC::JIT::compileLoadVarargs):
(JSC::JIT::compileCallEval):
(JSC::JIT::compileCallEvalSlowCase):
(JSC::JIT::compileOpCall):

  • jit/JITCall32_64.cpp:

(JSC::JIT::emit_op_ret):
(JSC::JIT::emit_op_ret_object_or_this):
(JSC::JIT::compileLoadVarargs):
(JSC::JIT::compileCallEval):
(JSC::JIT::compileCallEvalSlowCase):
(JSC::JIT::compileOpCall):

  • jit/JITCode.h:

(JSC):
(JSC::JITCode::execute):

  • jit/JITInlineMethods.h:

(JSC::JIT::emitPutToCallFrameHeader):
(JSC::JIT::emitPutCellToCallFrameHeader):
(JSC::JIT::emitPutIntToCallFrameHeader):
(JSC::JIT::emitPutImmediateToCallFrameHeader):
(JSC::JIT::emitGetFromCallFrameHeaderPtr):
(JSC::JIT::emitGetFromCallFrameHeader32):
(JSC::JIT::updateTopCallFrame):
(JSC::JIT::unmap):

  • jit/JITOpcodes.cpp:

(JSC::JIT::privateCompileCTIMachineTrampolines):
(JSC::JIT::privateCompileCTINativeCall):
(JSC::JIT::emit_op_end):
(JSC::JIT::emit_op_ret):
(JSC::JIT::emit_op_ret_object_or_this):
(JSC::JIT::emit_op_create_this):
(JSC::JIT::emit_op_get_arguments_length):
(JSC::JIT::emit_op_get_argument_by_val):
(JSC::JIT::emit_op_resolve_global_dynamic):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::privateCompileCTIMachineTrampolines):
(JSC::JIT::privateCompileCTINativeCall):
(JSC::JIT::emit_op_end):
(JSC::JIT::emit_op_create_this):
(JSC::JIT::emit_op_get_arguments_length):
(JSC::JIT::emit_op_get_argument_by_val):

  • jit/JITPropertyAccess.cpp:

(JSC::JIT::emit_op_get_scoped_var):
(JSC::JIT::emit_op_put_scoped_var):

  • jit/JITPropertyAccess32_64.cpp:

(JSC::JIT::emit_op_get_scoped_var):
(JSC::JIT::emit_op_put_scoped_var):

  • jit/JITStubs.cpp:

(JSC::ctiTrampoline):
(JSC::JITThunks::JITThunks):
(JSC):
(JSC::DEFINE_STUB_FUNCTION):

  • jit/JITStubs.h:

(JSC):
(JITStackFrame):

  • jit/JSInterfaceJIT.h:
  • jit/SpecializedThunkJIT.h:

(JSC::SpecializedThunkJIT::SpecializedThunkJIT):
(JSC::SpecializedThunkJIT::returnJSValue):
(JSC::SpecializedThunkJIT::returnDouble):
(JSC::SpecializedThunkJIT::returnInt32):
(JSC::SpecializedThunkJIT::returnJSCell):

  • llint/LLIntData.cpp:

(JSC::LLInt::Data::performAssertions):

  • llint/LLIntOffsetsExtractor.cpp:
  • llint/LLIntSlowPaths.cpp:

(JSC::LLInt::LLINT_SLOW_PATH_DECL):
(JSC::LLInt::genericCall):

  • llint/LLIntSlowPaths.h:

(LLInt):

  • llint/LowLevelInterpreter.asm:
  • runtime/Arguments.cpp:

(JSC::Arguments::tearOffForInlineCallFrame):

  • runtime/CommonSlowPaths.h:

(JSC::CommonSlowPaths::arityCheckFor):

  • runtime/InitializeThreading.cpp:

(JSC::initializeThreadingOnce):

  • runtime/JSActivation.cpp:

(JSC::JSActivation::visitChildren):

  • runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::globalExec):

  • runtime/JSGlobalObject.h:

(JSC):
(JSGlobalObject):

  • runtime/JSLock.cpp:

(JSC):

  • runtime/JSVariableObject.h:

(JSVariableObject):

  • runtime/MemoryStatistics.cpp:

(JSC::globalMemoryStatistics):

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/interpreter/Interpreter.cpp

    r129453 r130726  
    8989}
    9090
    91 ALWAYS_INLINE CallFrame* Interpreter::slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, CallFrame* callFrame, size_t registerOffset, int argumentCountIncludingThis)
     91ALWAYS_INLINE CallFrame* Interpreter::slideRegisterWindowForCall(CodeBlock* newCodeBlock, JSStack* stack, CallFrame* callFrame, size_t registerOffset, int argumentCountIncludingThis)
    9292{
    9393    // This ensures enough space for the worst case scenario of zero arguments passed by the caller.
    94     if (!registerFile->grow(callFrame->registers() + registerOffset + newCodeBlock->numParameters() + newCodeBlock->m_numCalleeRegisters))
     94    if (!stack->grow(callFrame->registers() + registerOffset + newCodeBlock->numParameters() + newCodeBlock->m_numCalleeRegisters))
    9595        return 0;
    9696
    … …  
    164164    ASSERT(isValidThisObject(thisValue, callFrame));
    165165    Interpreter* interpreter = callFrame->globalData().interpreter;
    166     return interpreter->execute(eval, callFrame, thisValue, callerScopeChain, callFrame->registers() - interpreter->registerFile().begin() + 1 + RegisterFile::CallFrameHeaderSize);
    167 }
    168 
    169 CallFrame* loadVarargs(CallFrame* callFrame, RegisterFile* registerFile, JSValue thisValue, JSValue arguments, int firstFreeRegister)
     166    return interpreter->execute(eval, callFrame, thisValue, callerScopeChain, callFrame->registers() - interpreter->stack().begin() + 1 + JSStack::CallFrameHeaderSize);
     167}
     168
     169CallFrame* loadVarargs(CallFrame* callFrame, JSStack* stack, JSValue thisValue, JSValue arguments, int firstFreeRegister)
    170170{
    171171    if (!arguments) { // f.apply(x, arguments), with arguments unmodified.
    172172        unsigned argumentCountIncludingThis = callFrame->argumentCountIncludingThis();
    173         CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + argumentCountIncludingThis + RegisterFile::CallFrameHeaderSize);
    174         if (argumentCountIncludingThis > Arguments::MaxArguments + 1 || !registerFile->grow(newCallFrame->registers())) {
     173        CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + argumentCountIncludingThis + JSStack::CallFrameHeaderSize);
     174        if (argumentCountIncludingThis > Arguments::MaxArguments + 1 || !stack->grow(newCallFrame->registers())) {
    175175            callFrame->globalData().exception = createStackOverflowError(callFrame);
    176176            return 0;
    … …  
    185185
    186186    if (arguments.isUndefinedOrNull()) {
    187         CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + 1 + RegisterFile::CallFrameHeaderSize);
    188         if (!registerFile->grow(newCallFrame->registers())) {
     187        CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + 1 + JSStack::CallFrameHeaderSize);
     188        if (!stack->grow(newCallFrame->registers())) {
    189189            callFrame->globalData().exception = createStackOverflowError(callFrame);
    190190            return 0;
    … …  
    204204        unsigned argCount = argsObject->length(callFrame);
    205205        CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + CallFrame::offsetFor(argCount + 1));
    206         if (argCount > Arguments::MaxArguments || !registerFile->grow(newCallFrame->registers())) {
     206        if (argCount > Arguments::MaxArguments || !stack->grow(newCallFrame->registers())) {
    207207            callFrame->globalData().exception = createStackOverflowError(callFrame);
    208208            return 0;
    … …  
    218218        unsigned argCount = array->length();
    219219        CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + CallFrame::offsetFor(argCount + 1));
    220         if (argCount > Arguments::MaxArguments || !registerFile->grow(newCallFrame->registers())) {
     220        if (argCount > Arguments::MaxArguments || !stack->grow(newCallFrame->registers())) {
    221221            callFrame->globalData().exception = createStackOverflowError(callFrame);
    222222            return 0;
    … …  
    231231    unsigned argCount = argObject->get(callFrame, callFrame->propertyNames().length).toUInt32(callFrame);
    232232    CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + firstFreeRegister + CallFrame::offsetFor(argCount + 1));
    233     if (argCount > Arguments::MaxArguments || !registerFile->grow(newCallFrame->registers())) {
     233    if (argCount > Arguments::MaxArguments || !stack->grow(newCallFrame->registers())) {
    234234        callFrame->globalData().exception = createStackOverflowError(callFrame);
    235235        return 0;
    … …  
    302302    const Register* end;
    303303
    304     it = callFrame->registers() - RegisterFile::CallFrameHeaderSize - callFrame->argumentCountIncludingThis();
    305     end = callFrame->registers() - RegisterFile::CallFrameHeaderSize;
     304    it = callFrame->registers() - JSStack::CallFrameHeaderSize - callFrame->argumentCountIncludingThis();
     305    end = callFrame->registers() - JSStack::CallFrameHeaderSize;
    306306    while (it < end) {
    307307        JSValue v = it->jsValue();
    … …  
    711711        highWaterMark = max(highWaterMark, callerHighWaterMark);
    712712    }
    713     m_registerFile.shrink(highWaterMark);
     713    m_stack.shrink(highWaterMark);
    714714
    715715    // Unwind the scope chain within the exception handler's call frame.
    … …  
    864864
    865865    // Reserve stack space for this invocation:
    866     Register* oldEnd = m_registerFile.end();
    867     Register* newEnd = oldEnd + codeBlock->numParameters() + RegisterFile::CallFrameHeaderSize + codeBlock->m_numCalleeRegisters;
    868     if (!m_registerFile.grow(newEnd))
     866    Register* oldEnd = m_stack.end();
     867    Register* newEnd = oldEnd + codeBlock->numParameters() + JSStack::CallFrameHeaderSize + codeBlock->m_numCalleeRegisters;
     868    if (!m_stack.grow(newEnd))
    869869        return checkedReturn(throwStackOverflowError(callFrame));
    870870
    871871    // Push the call frame for this invocation:
    872     CallFrame* newCallFrame = CallFrame::create(oldEnd + codeBlock->numParameters() + RegisterFile::CallFrameHeaderSize);
     872    CallFrame* newCallFrame = CallFrame::create(oldEnd + codeBlock->numParameters() + JSStack::CallFrameHeaderSize);
    873873    ASSERT(codeBlock->numParameters() == 1); // 1 parameter for 'this'.
    874874    newCallFrame->init(codeBlock, 0, scope, CallFrame::noCaller(), codeBlock->numParameters(), 0);
    … …  
    884884        SamplingTool::CallRecord callRecord(m_sampler.get());
    885885
    886         m_reentryDepth++; 
     886        m_reentryDepth++;
    887887#if ENABLE(LLINT_C_LOOP)
    888888        result = LLInt::CLoop::execute(newCallFrame, llint_program_prologue);
    889889#elif ENABLE(JIT)
    890         result = program->generatedJITCode().execute(&m_registerFile, newCallFrame, scope->globalData());
     890        result = program->generatedJITCode().execute(&m_stack, newCallFrame, scope->globalData());
    891891#endif // ENABLE(JIT)
    892892
    … …  
    897897        profiler->didExecute(callFrame, program->sourceURL(), program->lineNo());
    898898
    899     m_registerFile.shrink(oldEnd);
     899    m_stack.shrink(oldEnd);
    900900
    901901    return checkedReturn(result);
    … …  
    913913        return checkedReturn(throwStackOverflowError(callFrame));
    914914
    915     Register* oldEnd = m_registerFile.end();
     915    Register* oldEnd = m_stack.end();
    916916    ASSERT(callFrame->frameExtent() <= oldEnd || callFrame == callFrame->scope()->globalObject()->globalExec());
    917917    int argCount = 1 + args.size(); // implicit "this" parameter
    918     size_t registerOffset = argCount + RegisterFile::CallFrameHeaderSize;
     918    size_t registerOffset = argCount + JSStack::CallFrameHeaderSize;
    919919
    920920    CallFrame* newCallFrame = CallFrame::create(oldEnd + registerOffset);
    921     if (!m_registerFile.grow(newCallFrame->registers()))
     921    if (!m_stack.grow(newCallFrame->registers()))
    922922        return checkedReturn(throwStackOverflowError(callFrame));
    923923
    … …  
    933933        JSObject* compileError = callData.js.functionExecutable->compileForCall(callFrame, callDataScope);
    934934        if (UNLIKELY(!!compileError)) {
    935             m_registerFile.shrink(oldEnd);
     935            m_stack.shrink(oldEnd);
    936936            return checkedReturn(throwError(callFrame, compileError));
    937937        }
    938938
    939939        CodeBlock* newCodeBlock = &callData.js.functionExecutable->generatedBytecodeForCall();
    940         newCallFrame = slideRegisterWindowForCall(newCodeBlock, &m_registerFile, newCallFrame, 0, argCount);
     940        newCallFrame = slideRegisterWindowForCall(newCodeBlock, &m_stack, newCallFrame, 0, argCount);
    941941        if (UNLIKELY(!newCallFrame)) {
    942             m_registerFile.shrink(oldEnd);
     942            m_stack.shrink(oldEnd);
    943943            return checkedReturn(throwStackOverflowError(callFrame));
    944944        }
    … …  
    959959            result = LLInt::CLoop::execute(newCallFrame, llint_function_for_call_prologue);
    960960#elif ENABLE(JIT)
    961             result = callData.js.functionExecutable->generatedJITCodeForCall().execute(&m_registerFile, newCallFrame, callDataScope->globalData());
     961            result = callData.js.functionExecutable->generatedJITCodeForCall().execute(&m_stack, newCallFrame, callDataScope->globalData());
    962962#endif // ENABLE(JIT)
    963963
    … …  
    968968            profiler->didExecute(callFrame, function);
    969969
    970         m_registerFile.shrink(oldEnd);
     970        m_stack.shrink(oldEnd);
    971971        return checkedReturn(result);
    972972    }
    … …  
    992992        profiler->didExecute(callFrame, function);
    993993
    994     m_registerFile.shrink(oldEnd);
     994    m_stack.shrink(oldEnd);
    995995    return checkedReturn(result);
    996996}
    … …  
    10081008        return checkedReturn(throwStackOverflowError(callFrame));
    10091009
    1010     Register* oldEnd = m_registerFile.end();
     1010    Register* oldEnd = m_stack.end();
    10111011    int argCount = 1 + args.size(); // implicit "this" parameter
    1012     size_t registerOffset = argCount + RegisterFile::CallFrameHeaderSize;
    1013 
    1014     if (!m_registerFile.grow(oldEnd + registerOffset))
     1012    size_t registerOffset = argCount + JSStack::CallFrameHeaderSize;
     1013
     1014    if (!m_stack.grow(oldEnd + registerOffset))
    10151015        return checkedReturn(throwStackOverflowError(callFrame));
    10161016
    … …  
    10271027        JSObject* compileError = constructData.js.functionExecutable->compileForConstruct(callFrame, constructDataScope);
    10281028        if (UNLIKELY(!!compileError)) {
    1029             m_registerFile.shrink(oldEnd);
     1029            m_stack.shrink(oldEnd);
    10301030            return checkedReturn(throwError(callFrame, compileError));
    10311031        }
    10321032
    10331033        CodeBlock* newCodeBlock = &constructData.js.functionExecutable->generatedBytecodeForConstruct();
    1034         newCallFrame = slideRegisterWindowForCall(newCodeBlock, &m_registerFile, newCallFrame, 0, argCount);
     1034        newCallFrame = slideRegisterWindowForCall(newCodeBlock, &m_stack, newCallFrame, 0, argCount);
    10351035        if (UNLIKELY(!newCallFrame)) {
    1036             m_registerFile.shrink(oldEnd);
     1036            m_stack.shrink(oldEnd);
    10371037            return checkedReturn(throwStackOverflowError(callFrame));
    10381038        }
    … …  
    10531053            result = LLInt::CLoop::execute(newCallFrame, llint_function_for_construct_prologue);
    10541054#elif ENABLE(JIT)
    1055             result = constructData.js.functionExecutable->generatedJITCodeForConstruct().execute(&m_registerFile, newCallFrame, constructDataScope->globalData());
     1055            result = constructData.js.functionExecutable->generatedJITCodeForConstruct().execute(&m_stack, newCallFrame, constructDataScope->globalData());
    10561056#endif // ENABLE(JIT)
    10571057            m_reentryDepth--;
    … …  
    10611061            profiler->didExecute(callFrame, constructor);
    10621062
    1063         m_registerFile.shrink(oldEnd);
     1063        m_stack.shrink(oldEnd);
    10641064        if (callFrame->hadException())
    10651065            return 0;
    … …  
    10881088        profiler->didExecute(callFrame, constructor);
    10891089
    1090     m_registerFile.shrink(oldEnd);
     1090    m_stack.shrink(oldEnd);
    10911091    if (callFrame->hadException())
    10921092        return 0;
    … …  
    11071107    }
    11081108
    1109     Register* oldEnd = m_registerFile.end();
    1110     size_t registerOffset = argumentCountIncludingThis + RegisterFile::CallFrameHeaderSize;
     1109    Register* oldEnd = m_stack.end();
     1110    size_t registerOffset = argumentCountIncludingThis + JSStack::CallFrameHeaderSize;
    11111111
    11121112    CallFrame* newCallFrame = CallFrame::create(oldEnd + registerOffset);
    1113     if (!m_registerFile.grow(newCallFrame->registers())) {
     1113    if (!m_stack.grow(newCallFrame->registers())) {
    11141114        throwStackOverflowError(callFrame);
    11151115        return CallFrameClosure();
    … …  
    11191119    if (error) {
    11201120        throwError(callFrame, error);
    1121         m_registerFile.shrink(oldEnd);
     1121        m_stack.shrink(oldEnd);
    11221122        return CallFrameClosure();
    11231123    }
    11241124    CodeBlock* codeBlock = &functionExecutable->generatedBytecodeForCall();
    11251125
    1126     newCallFrame = slideRegisterWindowForCall(codeBlock, &m_registerFile, newCallFrame, 0, argumentCountIncludingThis);
     1126    newCallFrame = slideRegisterWindowForCall(codeBlock, &m_stack, newCallFrame, 0, argumentCountIncludingThis);
    11271127    if (UNLIKELY(!newCallFrame)) {
    11281128        throwStackOverflowError(callFrame);
    1129         m_registerFile.shrink(oldEnd);
     1129        m_stack.shrink(oldEnd);
    11301130        return CallFrameClosure();
    11311131    }
    … …  
    11551155        result = LLInt::CLoop::execute(closure.newCallFrame, llint_function_for_call_prologue);
    11561156#elif ENABLE(JIT)
    1157         result = closure.functionExecutable->generatedJITCodeForCall().execute(&m_registerFile, closure.newCallFrame, closure.globalData);
     1157        result = closure.functionExecutable->generatedJITCodeForCall().execute(&m_stack, closure.newCallFrame, closure.globalData);
    11581158#endif // ENABLE(JIT)
    11591159        m_reentryDepth--;
    … …  
    11681168{
    11691169    closure.globalData->topCallFrame = closure.oldCallFrame;
    1170     m_registerFile.shrink(closure.oldEnd);
     1170    m_stack.shrink(closure.oldEnd);
    11711171}
    11721172
    … …  
    12231223    }
    12241224
    1225     Register* oldEnd = m_registerFile.end();
    1226     Register* newEnd = m_registerFile.begin() + globalRegisterOffset + codeBlock->m_numCalleeRegisters;
    1227     if (!m_registerFile.grow(newEnd))
     1225    Register* oldEnd = m_stack.end();
     1226    Register* newEnd = m_stack.begin() + globalRegisterOffset + codeBlock->m_numCalleeRegisters;
     1227    if (!m_stack.grow(newEnd))
    12281228        return checkedReturn(throwStackOverflowError(callFrame));
    12291229
    1230     CallFrame* newCallFrame = CallFrame::create(m_registerFile.begin() + globalRegisterOffset);
     1230    CallFrame* newCallFrame = CallFrame::create(m_stack.begin() + globalRegisterOffset);
    12311231
    12321232    ASSERT(codeBlock->numParameters() == 1); // 1 parameter for 'this'.
    … …  
    12481248        result = LLInt::CLoop::execute(newCallFrame, llint_eval_prologue);
    12491249#elif ENABLE(JIT)
    1250         result = eval->generatedJITCode().execute(&m_registerFile, newCallFrame, scope->globalData());
     1250        result = eval->generatedJITCode().execute(&m_stack, newCallFrame, scope->globalData());
    12511251#endif // ENABLE(JIT)
    12521252        m_reentryDepth--;
    … …  
    12561256        profiler->didExecute(callFrame, eval->sourceURL(), eval->lineNo());
    12571257
    1258     m_registerFile.shrink(oldEnd);
     1258    m_stack.shrink(oldEnd);
    12591259    return checkedReturn(result);
    12601260}
Note: See TracChangeset for help on using the changeset viewer.