Changeset 130726 in webkit


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):

Location:
trunk/Source/JavaScriptCore
Files:
67 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/CMakeLists.txt

    r130520 r130726  
    134134    interpreter/CallFrame.cpp
    135135    interpreter/Interpreter.cpp
    136     interpreter/RegisterFile.cpp
     136    interpreter/JSStack.cpp
    137137    interpreter/VMInspector.cpp
    138138

  • trunk/Source/JavaScriptCore/ChangeLog

    r130720 r130726  
     12012-10-08  Mark Lam  <[email protected]>
     2
     3        Renamed RegisterFile to JSStack, and removed prototype of the
     4        previously deleted Interpreter::privateExecute().
     5        https://bugs.webkit.org/show_bug.cgi?id=98717.
     6
     7        Reviewed by Filip Pizlo.
     8
     9        * CMakeLists.txt:
     10        * GNUmakefile.list.am:
     11        * JavaScriptCore.order:
     12        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
     13        * JavaScriptCore.xcodeproj/project.pbxproj:
     14        * Target.pri:
     15        * bytecode/BytecodeConventions.h:
     16        * bytecode/CodeBlock.cpp:
     17        (JSC::CodeBlock::nameForRegister):
     18        * bytecode/CodeBlock.h:
     19        (CodeBlock):
     20        * bytecode/ValueRecovery.h:
     21        (JSC::ValueRecovery::alreadyInJSStack):
     22        (JSC::ValueRecovery::alreadyInJSStackAsUnboxedInt32):
     23        (JSC::ValueRecovery::alreadyInJSStackAsUnboxedCell):
     24        (JSC::ValueRecovery::alreadyInJSStackAsUnboxedBoolean):
     25        (JSC::ValueRecovery::alreadyInJSStackAsUnboxedDouble):
     26        (JSC::ValueRecovery::displacedInJSStack):
     27        (JSC::ValueRecovery::isAlreadyInJSStack):
     28        (JSC::ValueRecovery::virtualRegister):
     29        (JSC::ValueRecovery::dump):
     30        * bytecompiler/BytecodeGenerator.cpp:
     31        (JSC::BytecodeGenerator::resolveCallee):
     32        (JSC::BytecodeGenerator::emitCall):
     33        (JSC::BytecodeGenerator::emitConstruct):
     34        * bytecompiler/BytecodeGenerator.h:
     35        (JSC::BytecodeGenerator::registerFor):
     36        * dfg/DFGAbstractState.h:
     37        (AbstractState):
     38        * dfg/DFGAssemblyHelpers.h:
     39        (JSC::DFG::AssemblyHelpers::emitGetFromCallFrameHeaderPtr):
     40        (JSC::DFG::AssemblyHelpers::emitPutToCallFrameHeader):
     41        (JSC::DFG::AssemblyHelpers::emitPutImmediateToCallFrameHeader):
     42        * dfg/DFGByteCodeParser.cpp:
     43        (JSC::DFG::ByteCodeParser::getDirect):
     44        (JSC::DFG::ByteCodeParser::findArgumentPositionForLocal):
     45        (JSC::DFG::ByteCodeParser::addCall):
     46        (JSC::DFG::ByteCodeParser::InlineStackEntry::remapOperand):
     47        (JSC::DFG::ByteCodeParser::handleInlining):
     48        (JSC::DFG::ByteCodeParser::parseBlock):
     49        (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
     50        * dfg/DFGGenerationInfo.h:
     51        (GenerationInfo):
     52        (JSC::DFG::GenerationInfo::needsSpill):
     53        * dfg/DFGGraph.h:
     54        * dfg/DFGJITCompiler.cpp:
     55        (JSC::DFG::JITCompiler::compileEntry):
     56        (JSC::DFG::JITCompiler::compileFunction):
     57        * dfg/DFGJITCompiler.h:
     58        (JSC::DFG::JITCompiler::beginCall):
     59        * dfg/DFGOSREntry.cpp:
     60        (JSC::DFG::prepareOSREntry):
     61        * dfg/DFGOSRExitCompiler32_64.cpp:
     62        (JSC::DFG::OSRExitCompiler::compileExit):
     63        * dfg/DFGOSRExitCompiler64.cpp:
     64        (JSC::DFG::OSRExitCompiler::compileExit):
     65        * dfg/DFGRepatch.cpp:
     66        (JSC::DFG::tryBuildGetByIDList):
     67        * dfg/DFGSpeculativeJIT.cpp:
     68        (JSC::DFG::SpeculativeJIT::compile):
     69        (JSC::DFG::SpeculativeJIT::checkArgumentTypes):
     70        (JSC::DFG::SpeculativeJIT::computeValueRecoveryFor):
     71        * dfg/DFGSpeculativeJIT.h:
     72        (SpeculativeJIT):
     73        (JSC::DFG::SpeculativeJIT::spill):
     74        * dfg/DFGSpeculativeJIT32_64.cpp:
     75        (JSC::DFG::SpeculativeJIT::emitCall):
     76        (JSC::DFG::SpeculativeJIT::compile):
     77        * dfg/DFGSpeculativeJIT64.cpp:
     78        (JSC::DFG::SpeculativeJIT::fillInteger):
     79        (JSC::DFG::SpeculativeJIT::emitCall):
     80        (JSC::DFG::SpeculativeJIT::compile):
     81        * dfg/DFGThunks.cpp:
     82        (JSC::DFG::throwExceptionFromCallSlowPathGenerator):
     83        (JSC::DFG::slowPathFor):
     84        (JSC::DFG::virtualForThunkGenerator):
     85        * dfg/DFGValueSource.cpp:
     86        (JSC::DFG::ValueSource::dump):
     87        * dfg/DFGValueSource.h:
     88        (JSC::DFG::dataFormatToValueSourceKind):
     89        (JSC::DFG::valueSourceKindToDataFormat):
     90        (JSC::DFG::isInJSStack):
     91        (JSC::DFG::ValueSource::forSpeculation):
     92        (JSC::DFG::ValueSource::isInJSStack):
     93        (JSC::DFG::ValueSource::valueRecovery):
     94        * dfg/DFGVariableEventStream.cpp:
     95        (JSC::DFG::VariableEventStream::reconstruct):
     96        * heap/Heap.cpp:
     97        (JSC::Heap::stack):
     98        (JSC::Heap::getConservativeRegisterRoots):
     99        (JSC::Heap::markRoots):
     100        * heap/Heap.h:
     101        (JSC):
     102        (Heap):
     103        * interpreter/CallFrame.cpp:
     104        (JSC::CallFrame::stack):
     105        * interpreter/CallFrame.h:
     106        (JSC::ExecState::calleeAsValue):
     107        (JSC::ExecState::callee):
     108        (JSC::ExecState::codeBlock):
     109        (JSC::ExecState::scope):
     110        (JSC::ExecState::callerFrame):
     111        (JSC::ExecState::returnPC):
     112        (JSC::ExecState::hasReturnPC):
     113        (JSC::ExecState::clearReturnPC):
     114        (JSC::ExecState::bytecodeOffsetForNonDFGCode):
     115        (JSC::ExecState::setBytecodeOffsetForNonDFGCode):
     116        (JSC::ExecState::inlineCallFrame):
     117        (JSC::ExecState::codeOriginIndexForDFG):
     118        (JSC::ExecState::currentVPC):
     119        (JSC::ExecState::setCurrentVPC):
     120        (JSC::ExecState::setCallerFrame):
     121        (JSC::ExecState::setScope):
     122        (JSC::ExecState::init):
     123        (JSC::ExecState::argumentCountIncludingThis):
     124        (JSC::ExecState::offsetFor):
     125        (JSC::ExecState::setArgumentCountIncludingThis):
     126        (JSC::ExecState::setCallee):
     127        (JSC::ExecState::setCodeBlock):
     128        (JSC::ExecState::setReturnPC):
     129        (JSC::ExecState::setInlineCallFrame):
     130        (ExecState):
     131        * interpreter/Interpreter.cpp:
     132        (JSC::Interpreter::slideRegisterWindowForCall):
     133        (JSC::eval):
     134        (JSC::loadVarargs):
     135        (JSC::Interpreter::dumpRegisters):
     136        (JSC::Interpreter::throwException):
     137        (JSC::Interpreter::execute):
     138        (JSC::Interpreter::executeCall):
     139        (JSC::Interpreter::executeConstruct):
     140        (JSC::Interpreter::prepareForRepeatCall):
     141        (JSC::Interpreter::endRepeatCall):
     142        * interpreter/Interpreter.h:
     143        (JSC::Interpreter::stack):
     144        (Interpreter):
     145        (JSC::Interpreter::execute):
     146        (JSC):
     147        * interpreter/JSStack.cpp: Copied from Source/JavaScriptCore/interpreter/RegisterFile.cpp.
     148        (JSC::stackStatisticsMutex):
     149        (JSC::JSStack::~JSStack):
     150        (JSC::JSStack::growSlowCase):
     151        (JSC::JSStack::gatherConservativeRoots):
     152        (JSC::JSStack::releaseExcessCapacity):
     153        (JSC::JSStack::initializeThreading):
     154        (JSC::JSStack::committedByteCount):
     155        (JSC::JSStack::addToCommittedByteCount):
     156        * interpreter/JSStack.h: Copied from Source/JavaScriptCore/interpreter/RegisterFile.h.
     157        (JSStack):
     158        (JSC::JSStack::JSStack):
     159        (JSC::JSStack::shrink):
     160        (JSC::JSStack::grow):
     161        * interpreter/RegisterFile.cpp: Removed.
     162        * interpreter/RegisterFile.h: Removed.
     163        * interpreter/VMInspector.cpp:
     164        (JSC::VMInspector::dumpFrame):
     165        * jit/JIT.cpp:
     166        (JSC::JIT::JIT):
     167        (JSC::JIT::privateCompile):
     168        * jit/JIT.h:
     169        (JSC):
     170        (JIT):
     171        * jit/JITCall.cpp:
     172        (JSC::JIT::compileLoadVarargs):
     173        (JSC::JIT::compileCallEval):
     174        (JSC::JIT::compileCallEvalSlowCase):
     175        (JSC::JIT::compileOpCall):
     176        * jit/JITCall32_64.cpp:
     177        (JSC::JIT::emit_op_ret):
     178        (JSC::JIT::emit_op_ret_object_or_this):
     179        (JSC::JIT::compileLoadVarargs):
     180        (JSC::JIT::compileCallEval):
     181        (JSC::JIT::compileCallEvalSlowCase):
     182        (JSC::JIT::compileOpCall):
     183        * jit/JITCode.h:
     184        (JSC):
     185        (JSC::JITCode::execute):
     186        * jit/JITInlineMethods.h:
     187        (JSC::JIT::emitPutToCallFrameHeader):
     188        (JSC::JIT::emitPutCellToCallFrameHeader):
     189        (JSC::JIT::emitPutIntToCallFrameHeader):
     190        (JSC::JIT::emitPutImmediateToCallFrameHeader):
     191        (JSC::JIT::emitGetFromCallFrameHeaderPtr):
     192        (JSC::JIT::emitGetFromCallFrameHeader32):
     193        (JSC::JIT::updateTopCallFrame):
     194        (JSC::JIT::unmap):
     195        * jit/JITOpcodes.cpp:
     196        (JSC::JIT::privateCompileCTIMachineTrampolines):
     197        (JSC::JIT::privateCompileCTINativeCall):
     198        (JSC::JIT::emit_op_end):
     199        (JSC::JIT::emit_op_ret):
     200        (JSC::JIT::emit_op_ret_object_or_this):
     201        (JSC::JIT::emit_op_create_this):
     202        (JSC::JIT::emit_op_get_arguments_length):
     203        (JSC::JIT::emit_op_get_argument_by_val):
     204        (JSC::JIT::emit_op_resolve_global_dynamic):
     205        * jit/JITOpcodes32_64.cpp:
     206        (JSC::JIT::privateCompileCTIMachineTrampolines):
     207        (JSC::JIT::privateCompileCTINativeCall):
     208        (JSC::JIT::emit_op_end):
     209        (JSC::JIT::emit_op_create_this):
     210        (JSC::JIT::emit_op_get_arguments_length):
     211        (JSC::JIT::emit_op_get_argument_by_val):
     212        * jit/JITPropertyAccess.cpp:
     213        (JSC::JIT::emit_op_get_scoped_var):
     214        (JSC::JIT::emit_op_put_scoped_var):
     215        * jit/JITPropertyAccess32_64.cpp:
     216        (JSC::JIT::emit_op_get_scoped_var):
     217        (JSC::JIT::emit_op_put_scoped_var):
     218        * jit/JITStubs.cpp:
     219        (JSC::ctiTrampoline):
     220        (JSC::JITThunks::JITThunks):
     221        (JSC):
     222        (JSC::DEFINE_STUB_FUNCTION):
     223        * jit/JITStubs.h:
     224        (JSC):
     225        (JITStackFrame):
     226        * jit/JSInterfaceJIT.h:
     227        * jit/SpecializedThunkJIT.h:
     228        (JSC::SpecializedThunkJIT::SpecializedThunkJIT):
     229        (JSC::SpecializedThunkJIT::returnJSValue):
     230        (JSC::SpecializedThunkJIT::returnDouble):
     231        (JSC::SpecializedThunkJIT::returnInt32):
     232        (JSC::SpecializedThunkJIT::returnJSCell):
     233        * llint/LLIntData.cpp:
     234        (JSC::LLInt::Data::performAssertions):
     235        * llint/LLIntOffsetsExtractor.cpp:
     236        * llint/LLIntSlowPaths.cpp:
     237        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
     238        (JSC::LLInt::genericCall):
     239        * llint/LLIntSlowPaths.h:
     240        (LLInt):
     241        * llint/LowLevelInterpreter.asm:
     242        * runtime/Arguments.cpp:
     243        (JSC::Arguments::tearOffForInlineCallFrame):
     244        * runtime/CommonSlowPaths.h:
     245        (JSC::CommonSlowPaths::arityCheckFor):
     246        * runtime/InitializeThreading.cpp:
     247        (JSC::initializeThreadingOnce):
     248        * runtime/JSActivation.cpp:
     249        (JSC::JSActivation::visitChildren):
     250        * runtime/JSGlobalObject.cpp:
     251        (JSC::JSGlobalObject::globalExec):
     252        * runtime/JSGlobalObject.h:
     253        (JSC):
     254        (JSGlobalObject):
     255        * runtime/JSLock.cpp:
     256        (JSC):
     257        * runtime/JSVariableObject.h:
     258        (JSVariableObject):
     259        * runtime/MemoryStatistics.cpp:
     260        (JSC::globalMemoryStatistics):
     261
    12622012-10-08  Kiran Muppala  <[email protected]>
    2263

  • trunk/Source/JavaScriptCore/GNUmakefile.list.am

    r130520 r130726  
    368368        Source/JavaScriptCore/interpreter/Interpreter.cpp \
    369369        Source/JavaScriptCore/interpreter/Interpreter.h \
    370         Source/JavaScriptCore/interpreter/RegisterFile.cpp \
    371         Source/JavaScriptCore/interpreter/RegisterFile.h \
     370        Source/JavaScriptCore/interpreter/JSStack.cpp \
     371        Source/JavaScriptCore/interpreter/JSStack.h \
    372372        Source/JavaScriptCore/interpreter/Register.h \
    373373        Source/JavaScriptCore/interpreter/VMInspector.cpp \

  • trunk/Source/JavaScriptCore/JavaScriptCore.order

    r123878 r130726  
    3030__ZN3WTF11currentTimeEv
    3131__ZN3WTF8msToYearEd
    32 __ZN3JSC12RegisterFile19initializeThreadingEv
     32__ZN3JSC12JSStack19initializeThreadingEv
    3333__ZN3WTF39initializeMainThreadToProcessMainThreadEv
    3434__ZN3WTF36lockAtomicallyInitializedStaticMutexEv
    … …  
    159159__ZN3JSC11InterpreterC1ERNS_12JSGlobalDataE
    160160__ZN3JSC10HandleHeap12writeBarrierEPNS_7JSValueERKS1_
    161 __ZN3JSC12RegisterFile23addToCommittedByteCountEl
     161__ZN3JSC12JSStack23addToCommittedByteCountEl
    162162__ZN3JSC11MarkedSpace21allocateFromSizeClassERNS0_9SizeClassE
    163163__ZN3JSC11MarkedSpace13allocateBlockERNS0_9SizeClassE
    … …  
    371371__ZN3JSC14MachineThreads23gatherFromCurrentThreadERNS_17ConservativeRootsEPv
    372372__ZN3JSC17ConservativeRoots3addEPvS1_
    373 __ZN3JSC12RegisterFile23gatherConservativeRootsERNS_17ConservativeRootsE
     373__ZN3JSC12JSStack23gatherConservativeRootsERNS_17ConservativeRootsE
    374374__ZN3JSC11MarkedSpace10clearMarksEv
    375375__ZN3JSC9MarkStack6appendERNS_17ConservativeRootsE
    … …  
    512512__ZThn16_N3JSC11ProgramNodeD0Ev
    513513__ZN3JSC11ProgramNodeD0Ev
    514 __ZN3JSC12RegisterFile12globalObjectEv
    515 __ZN3JSC14JSGlobalObject13copyGlobalsToERNS_12RegisterFileE
    516 __ZN3JSC12RegisterFile15setGlobalObjectEPNS_14JSGlobalObjectE
     514__ZN3JSC12JSStack12globalObjectEv
     515__ZN3JSC14JSGlobalObject13copyGlobalsToERNS_12JSStackE
     516__ZN3JSC12JSStack15setGlobalObjectEPNS_14JSGlobalObjectE
    517517_ctiTrampoline
    518518__ZN3WTF15SegmentedVectorIN3JSC10IdentifierELm64EE6appendIS2_EEvRKT_
    … …  
    683683__ZN3JSC9CodeBlockD2Ev
    684684__ZN3JSC15WeakHandleOwner26isReachableFromOpaqueRootsENS_6HandleINS_7UnknownEEEPvRNS_9MarkStackE
    685 __ZN3JSC12RegisterFile17GlobalObjectOwner8finalizeENS_6HandleINS_7UnknownEEEPv
     685__ZN3JSC12JSStack17GlobalObjectOwner8finalizeENS_6HandleINS_7UnknownEEEPv
    686686__ZN3JSC13ErrorInstanceD1Ev
    687687__ZN3JSC12StringObjectD1Ev
    … …  
    785785__ZN3JSC18FunctionExecutableC1EPNS_9ExecStateERKNS_10IdentifierERKNS_10SourceCodeEbPNS_18FunctionParametersEbii
    786786__ZN3JSC12FuncDeclNode12emitBytecodeERNS_17BytecodeGeneratorEPNS_10RegisterIDE
    787 __ZN3JSC14JSGlobalObject15copyGlobalsFromERNS_12RegisterFileE
     787__ZN3JSC14JSGlobalObject15copyGlobalsFromERNS_12JSStackE
    788788__ZNK3WTF12AtomicString5lowerEv
    789789__ZN3JSC41constructFunctionSkippingEvalEnabledCheckEPNS_9ExecStateEPNS_14JSGlobalObjectERKNS_7ArgListERKNS_10IdentifierERKNS_7UStringEi
    … …  
    811811__ZN3JSC17AssignResolveNode12emitBytecodeERNS_17BytecodeGeneratorEPNS_10RegisterIDE
    812812__ZN3JSC17BytecodeGenerator15isLocalConstantERKNS_10IdentifierE
    813 _cti_register_file_check
     813_cti_stack_check
    814814__ZN3JSC16JSCallbackObjectINS_24JSObjectWithGlobalObjectEE17staticValueGetterEPNS_9ExecStateENS_7JSValueERKNS_10IdentifierE
    815815__ZN3WTF9HashTableISt4pairINS_6RefPtrINS_10StringImplEEEjES1_IS5_PN3JSC7JSValueEENS_18PairFirstExtractorIS9_EENS6_24StructureTransitionTable4HashENS_14PairHashTraitsINSC_10HashTraitsENS_10HashTraitsIS8_EEEESF_E6rehashEi
    … …  
    980980__ZN3JSC12JSActivation18getOwnPropertySlotEPNS_9ExecStateERKNS_10IdentifierERNS_12PropertySlotE
    981981_cti_op_call_eval
    982 __ZN3JSC11Interpreter8callEvalEPNS_9ExecStateEPNS_12RegisterFileEPNS_8RegisterEii
     982__ZN3JSC11Interpreter8callEvalEPNS_9ExecStateEPNS_12JSStackEPNS_8RegisterEii
    983983__ZN3JSC14EvalExecutableC1EPNS_9ExecStateERKNS_10SourceCodeEb
    984984__ZN3JSC14EvalExecutable15compileInternalEPNS_9ExecStateEPNS_14ScopeChainNodeE
    … …  
    17141714__ZN3JSC12JSGlobalDataD1Ev
    17151715__ZN3JSC12JSGlobalDataD2Ev
    1716 __ZN3JSC12RegisterFileD1Ev
    1717 __ZN3JSC12RegisterFileD2Ev
     1716__ZN3JSC12JSStackD1Ev
     1717__ZN3JSC12JSStackD2Ev
    17181718__ZNK3JSC9HashTable11deleteTableEv
    17191719__ZN3JSC5LexerD1Ev
    … …  
    18361836__ZN3JSC16createRangeErrorEPNS_9ExecStateERKNS_7UStringE
    18371837_cti_op_mul
    1838 __ZN3JSC12RegisterFile21releaseExcessCapacityEv
     1838__ZN3JSC12JSStack21releaseExcessCapacityEv
    18391839__ZN3JSC16JSCallbackObjectINS_14JSGlobalObjectEED1Ev
    18401840_JSObjectHasProperty
    … …  
    24832483__ZN3WTF20fastMallocStatisticsEv
    24842484__ZN3JSC22globalMemoryStatisticsEv
    2485 __ZN3JSC12RegisterFile18committedByteCountEv
     2485__ZN3JSC12JSStack18committedByteCountEv
    24862486__ZN3JSC19ExecutableAllocator18committedByteCountEv
    24872487__ZN3WTF9HashTableINS_6RefPtrINS_10StringImplEEESt4pairIS3_N3JSC14OffsetLocationEENS_18PairFirstExtractorIS7_EENS_10StringHashENS_14PairHashTraitsINS_10HashTraitsIS3_EENSC_IS6_EEEESD_E4findIPS2_NS_29RefPtrHashMapRawKeyTranslatorISI_S7_SF_SA_EEEENS_17HashTableIteratorIS3_S7_S9_SA_SF_SD_EERKT_

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj

    r130520 r130726  
    21432143                        </File>
    21442144                        <File
     2145                                RelativePath="..\..\interpreter\JSStack.cpp"
     2146                                >
     2147                        </File>
     2148                        <File
     2149                                RelativePath="..\..\interpreter\JSStack.h"
     2150                                >
     2151                        </File>
     2152                        <File
    21452153                                RelativePath="..\..\interpreter\Register.h"
    2146                                 >
    2147                         </File>
    2148                         <File
    2149                                 RelativePath="..\..\interpreter\RegisterFile.cpp"
    2150                                 >
    2151                         </File>
    2152                         <File
    2153                                 RelativePath="..\..\interpreter\RegisterFile.h"
    21542154                                >
    21552155                        </File>

  • trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r130520 r130726  
    280280                1428082D107EC0570013E7B2 /* CallData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCA62DFE0E2826230004F30D /* CallData.cpp */; };
    281281                1428082E107EC0570013E7B2 /* ConstructData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCA62DFF0E2826310004F30D /* ConstructData.cpp */; };
    282                 1428083A107EC0750013E7B2 /* RegisterFile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1429D85B0ED218E900B89619 /* RegisterFile.cpp */; };
     282                1428083A107EC0750013E7B2 /* JSStack.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1429D85B0ED218E900B89619 /* JSStack.cpp */; };
    283283                14280841107EC0930013E7B2 /* RegExp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F692A87D0255597D01FF60F7 /* RegExp.cpp */; };
    284284                14280842107EC0930013E7B2 /* RegExpConstructor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCD202BD0E1706A7002C7E82 /* RegExpConstructor.cpp */; };
    … …  
    667667                BC18C45B0E16F5CD00B34460 /* RegExpObject.h in Headers */ = {isa = PBXBuildFile; fileRef = F692A87C0255597D01FF60F7 /* RegExpObject.h */; settings = {ATTRIBUTES = (Private, ); }; };
    668668                BC18C45D0E16F5CD00B34460 /* Register.h in Headers */ = {isa = PBXBuildFile; fileRef = 149B24FF0D8AF6D1009CB8C7 /* Register.h */; settings = {ATTRIBUTES = (Private, ); }; };
    669                 BC18C45E0E16F5CD00B34460 /* RegisterFile.h in Headers */ = {isa = PBXBuildFile; fileRef = 14D792640DAA03FB001A9F05 /* RegisterFile.h */; settings = {ATTRIBUTES = (Private, ); }; };
     669                BC18C45E0E16F5CD00B34460 /* JSStack.h in Headers */ = {isa = PBXBuildFile; fileRef = 14D792640DAA03FB001A9F05 /* JSStack.h */; settings = {ATTRIBUTES = (Private, ); }; };
    670670                BC18C4630E16F5CD00B34460 /* SourceProvider.h in Headers */ = {isa = PBXBuildFile; fileRef = 65E866ED0DD59AFA00A2B2A1 /* SourceProvider.h */; settings = {ATTRIBUTES = (Private, ); }; };
    671671                BC18C4640E16F5CD00B34460 /* SourceCode.h in Headers */ = {isa = PBXBuildFile; fileRef = 65E866EE0DD59AFA00A2B2A1 /* SourceCode.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    10561056                1429D77B0ED20D7300B89619 /* Interpreter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Interpreter.h; sourceTree = "<group>"; };
    10571057                1429D7D30ED2128200B89619 /* Interpreter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Interpreter.cpp; sourceTree = "<group>"; };
    1058                 1429D85B0ED218E900B89619 /* RegisterFile.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RegisterFile.cpp; sourceTree = "<group>"; };
     1058                1429D85B0ED218E900B89619 /* JSStack.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSStack.cpp; sourceTree = "<group>"; };
    10591059                1429D8770ED21ACD00B89619 /* ExceptionHelpers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ExceptionHelpers.cpp; sourceTree = "<group>"; };
    10601060                1429D8830ED21C3D00B89619 /* SamplingTool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SamplingTool.cpp; sourceTree = "<group>"; };
    … …  
    11441144                14D2F3D8139F4BE200491031 /* MarkedSpace.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MarkedSpace.cpp; sourceTree = "<group>"; };
    11451145                14D2F3D9139F4BE200491031 /* MarkedSpace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MarkedSpace.h; sourceTree = "<group>"; };
    1146                 14D792640DAA03FB001A9F05 /* RegisterFile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RegisterFile.h; sourceTree = "<group>"; };
     1146                14D792640DAA03FB001A9F05 /* JSStack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSStack.h; sourceTree = "<group>"; };
    11471147                14D857740A4696C80032146C /* testapi.js */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.javascript; name = testapi.js; path = API/tests/testapi.js; sourceTree = "<group>"; };
    11481148                14DA818E0D99FD2000B0A4FB /* JSActivation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSActivation.h; sourceTree = "<group>"; };
    … …  
    17681768                                1429D77B0ED20D7300B89619 /* Interpreter.h */,
    17691769                                149B24FF0D8AF6D1009CB8C7 /* Register.h */,
    1770                                 1429D85B0ED218E900B89619 /* RegisterFile.cpp */,
    1771                                 14D792640DAA03FB001A9F05 /* RegisterFile.h */,
     1770                                1429D85B0ED218E900B89619 /* JSStack.cpp */,
     1771                                14D792640DAA03FB001A9F05 /* JSStack.h */,
    17721772                        );
    17731773                        path = interpreter;
    … …  
    27132713                                9534AAFB0E5B7A9600B8A45B /* JSProfilerPrivate.h in Headers */,
    27142714                                BC18C4260E16F5CD00B34460 /* JSRetainPtr.h in Headers */,
     2715                                BC18C45E0E16F5CD00B34460 /* JSStack.h in Headers */,
    27152716                                BC18C4270E16F5CD00B34460 /* JSString.h in Headers */,
    27162717                                86E85539111B9968001AF51E /* JSStringBuilder.h in Headers */,
    … …  
    27942795                                BCD202C40E1706A7002C7E82 /* RegExpPrototype.h in Headers */,
    27952796                                BC18C45D0E16F5CD00B34460 /* Register.h in Headers */,
    2796                                 BC18C45E0E16F5CD00B34460 /* RegisterFile.h in Headers */,
    27972797                                969A072B0ED1CE6900F1F681 /* RegisterID.h in Headers */,
    27982798                                86D3B3C410159D7F002865E7 /* RepatchBuffer.h in Headers */,
    … …  
    34203420                                95F6E6950E5B5F970091E860 /* JSProfilerPrivate.cpp in Sources */,
    34213421                                A727FF6B0DA3092200E548D7 /* JSPropertyNameIterator.cpp in Sources */,
     3422                                1428083A107EC0750013E7B2 /* JSStack.cpp in Sources */,
    34223423                                147F39D5107EC37600427A48 /* JSString.cpp in Sources */,
    34233424                                2600B5A6152BAAA70091EE5F /* JSStringJoiner.cpp in Sources */,
    … …  
    34693470                                14280843107EC0930013E7B2 /* RegExpObject.cpp in Sources */,
    34703471                                14280844107EC0930013E7B2 /* RegExpPrototype.cpp in Sources */,
    3471                                 1428083A107EC0750013E7B2 /* RegisterFile.cpp in Sources */,
    34723472                                0F7700921402FF3C0078EB39 /* SamplingCounter.cpp in Sources */,
    34733473                                1429D8850ED21C3D00B89619 /* SamplingTool.cpp in Sources */,

  • trunk/Source/JavaScriptCore/Target.pri

    r130520 r130726  
    139139    interpreter/CallFrame.cpp \
    140140    interpreter/Interpreter.cpp \
    141     interpreter/RegisterFile.cpp \
     141    interpreter/JSStack.cpp \
    142142    jit/ExecutableAllocatorFixedVMPool.cpp \
    143143    jit/ExecutableAllocator.cpp \

  • trunk/Source/JavaScriptCore/bytecode/BytecodeConventions.h

    r108444 r130726  
    2828
    2929// Register numbers used in bytecode operations have different meaning according to their ranges:
    30 //      0x80000000-0xFFFFFFFF  Negative indices from the CallFrame pointer are entries in the call frame, see RegisterFile.h.
     30//      0x80000000-0xFFFFFFFF  Negative indices from the CallFrame pointer are entries in the call frame, see JSStack.h.
    3131//      0x00000000-0x3FFFFFFF  Forwards indices from the CallFrame pointer are local vars and temporaries with the function's callframe.
    3232//      0x40000000-0x7FFFFFFF  Positive indices from 0x40000000 specify entries in the constant pool on the CodeBlock.

  • trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

    r130612 r130726  
    30183018    if (registerNumber < 0) {
    30193019        int argumentPosition = -registerNumber;
    3020         argumentPosition -= RegisterFile::CallFrameHeaderSize + 1;
     3020        argumentPosition -= JSStack::CallFrameHeaderSize + 1;
    30213021        return String::format("arguments[%3d]", argumentPosition - 1).impl();
    30223022    }

  • trunk/Source/JavaScriptCore/bytecode/CodeBlock.h

    r129297 r130726  
    160160        }
    161161#endif
    162        
     162
    163163        void visitAggregate(SlotVisitor&);
    164164

  • trunk/Source/JavaScriptCore/bytecode/ValueRecovery.h

    r124404 r130726  
    3939// code point.
    4040enum ValueRecoveryTechnique {
    41     // It's already in the register file at the right location.
    42     AlreadyInRegisterFile,
    43     // It's already in the register file but unboxed.
    44     AlreadyInRegisterFileAsUnboxedInt32,
    45     AlreadyInRegisterFileAsUnboxedCell,
    46     AlreadyInRegisterFileAsUnboxedBoolean,
    47     AlreadyInRegisterFileAsUnboxedDouble,
     41    // It's already in the stack at the right location.
     42    AlreadyInJSStack,
     43    // It's already in the stack but unboxed.
     44    AlreadyInJSStackAsUnboxedInt32,
     45    AlreadyInJSStackAsUnboxedCell,
     46    AlreadyInJSStackAsUnboxedBoolean,
     47    AlreadyInJSStackAsUnboxedDouble,
    4848    // It's in a register.
    4949    InGPR,
    … …  
    5555    InFPR,
    5656    UInt32InGPR,
    57     // It's in the register file, but at a different location.
    58     DisplacedInRegisterFile,
    59     // It's in the register file, at a different location, and it's unboxed.
    60     Int32DisplacedInRegisterFile,
    61     DoubleDisplacedInRegisterFile,
    62     CellDisplacedInRegisterFile,
    63     BooleanDisplacedInRegisterFile,
     57    // It's in the stack, but at a different location.
     58    DisplacedInJSStack,
     59    // It's in the stack, at a different location, and it's unboxed.
     60    Int32DisplacedInJSStack,
     61    DoubleDisplacedInJSStack,
     62    CellDisplacedInJSStack,
     63    BooleanDisplacedInJSStack,
    6464    // It's an Arguments object.
    6565    ArgumentsThatWereNotCreated,
    … …  
    8080    bool operator!() const { return !isSet(); }
    8181   
    82     static ValueRecovery alreadyInRegisterFile()
    83     {
    84         ValueRecovery result;
    85         result.m_technique = AlreadyInRegisterFile;
    86         return result;
    87     }
    88    
    89     static ValueRecovery alreadyInRegisterFileAsUnboxedInt32()
    90     {
    91         ValueRecovery result;
    92         result.m_technique = AlreadyInRegisterFileAsUnboxedInt32;
    93         return result;
    94     }
    95    
    96     static ValueRecovery alreadyInRegisterFileAsUnboxedCell()
    97     {
    98         ValueRecovery result;
    99         result.m_technique = AlreadyInRegisterFileAsUnboxedCell;
    100         return result;
    101     }
    102    
    103     static ValueRecovery alreadyInRegisterFileAsUnboxedBoolean()
    104     {
    105         ValueRecovery result;
    106         result.m_technique = AlreadyInRegisterFileAsUnboxedBoolean;
    107         return result;
    108     }
    109    
    110     static ValueRecovery alreadyInRegisterFileAsUnboxedDouble()
    111     {
    112         ValueRecovery result;
    113         result.m_technique = AlreadyInRegisterFileAsUnboxedDouble;
     82    static ValueRecovery alreadyInJSStack()
     83    {
     84        ValueRecovery result;
     85        result.m_technique = AlreadyInJSStack;
     86        return result;
     87    }
     88   
     89    static ValueRecovery alreadyInJSStackAsUnboxedInt32()
     90    {
     91        ValueRecovery result;
     92        result.m_technique = AlreadyInJSStackAsUnboxedInt32;
     93        return result;
     94    }
     95   
     96    static ValueRecovery alreadyInJSStackAsUnboxedCell()
     97    {
     98        ValueRecovery result;
     99        result.m_technique = AlreadyInJSStackAsUnboxedCell;
     100        return result;
     101    }
     102   
     103    static ValueRecovery alreadyInJSStackAsUnboxedBoolean()
     104    {
     105        ValueRecovery result;
     106        result.m_technique = AlreadyInJSStackAsUnboxedBoolean;
     107        return result;
     108    }
     109   
     110    static ValueRecovery alreadyInJSStackAsUnboxedDouble()
     111    {
     112        ValueRecovery result;
     113        result.m_technique = AlreadyInJSStackAsUnboxedDouble;
    114114        return result;
    115115    }
    … …  
    159159    }
    160160   
    161     static ValueRecovery displacedInRegisterFile(VirtualRegister virtualReg, DataFormat dataFormat)
     161    static ValueRecovery displacedInJSStack(VirtualRegister virtualReg, DataFormat dataFormat)
    162162    {
    163163        ValueRecovery result;
    164164        switch (dataFormat) {
    165165        case DataFormatInteger:
    166             result.m_technique = Int32DisplacedInRegisterFile;
     166            result.m_technique = Int32DisplacedInJSStack;
    167167            break;
    168168           
    169169        case DataFormatDouble:
    170             result.m_technique = DoubleDisplacedInRegisterFile;
     170            result.m_technique = DoubleDisplacedInJSStack;
    171171            break;
    172172
    173173        case DataFormatCell:
    174             result.m_technique = CellDisplacedInRegisterFile;
     174            result.m_technique = CellDisplacedInJSStack;
    175175            break;
    176176           
    177177        case DataFormatBoolean:
    178             result.m_technique = BooleanDisplacedInRegisterFile;
     178            result.m_technique = BooleanDisplacedInJSStack;
    179179            break;
    180180           
    181181        default:
    182182            ASSERT(dataFormat != DataFormatNone && dataFormat != DataFormatStorage);
    183             result.m_technique = DisplacedInRegisterFile;
     183            result.m_technique = DisplacedInJSStack;
    184184            break;
    185185        }
    … …  
    223223    }
    224224   
    225     bool isAlreadyInRegisterFile() const
     225    bool isAlreadyInJSStack() const
    226226    {
    227227        switch (technique()) {
    228         case AlreadyInRegisterFile:
    229         case AlreadyInRegisterFileAsUnboxedInt32:
    230         case AlreadyInRegisterFileAsUnboxedCell:
    231         case AlreadyInRegisterFileAsUnboxedBoolean:
    232         case AlreadyInRegisterFileAsUnboxedDouble:
     228        case AlreadyInJSStack:
     229        case AlreadyInJSStackAsUnboxedInt32:
     230        case AlreadyInJSStackAsUnboxedCell:
     231        case AlreadyInJSStackAsUnboxedBoolean:
     232        case AlreadyInJSStackAsUnboxedDouble:
    233233            return true;
    234234        default:
    … …  
    265265    VirtualRegister virtualRegister() const
    266266    {
    267         ASSERT(m_technique == DisplacedInRegisterFile || m_technique == Int32DisplacedInRegisterFile || m_technique == DoubleDisplacedInRegisterFile || m_technique == CellDisplacedInRegisterFile || m_technique == BooleanDisplacedInRegisterFile);
     267        ASSERT(m_technique == DisplacedInJSStack || m_technique == Int32DisplacedInJSStack || m_technique == DoubleDisplacedInJSStack || m_technique == CellDisplacedInJSStack || m_technique == BooleanDisplacedInJSStack);
    268268        return m_source.virtualReg;
    269269    }
    … …  
    278278    {
    279279        switch (technique()) {
    280         case AlreadyInRegisterFile:
     280        case AlreadyInJSStack:
    281281            fprintf(out, "-");
    282282            break;
    283         case AlreadyInRegisterFileAsUnboxedInt32:
     283        case AlreadyInJSStackAsUnboxedInt32:
    284284            fprintf(out, "(int32)");
    285285            break;
    286         case AlreadyInRegisterFileAsUnboxedCell:
     286        case AlreadyInJSStackAsUnboxedCell:
    287287            fprintf(out, "(cell)");
    288288            break;
    289         case AlreadyInRegisterFileAsUnboxedBoolean:
     289        case AlreadyInJSStackAsUnboxedBoolean:
    290290            fprintf(out, "(bool)");
    291291            break;
    292         case AlreadyInRegisterFileAsUnboxedDouble:
     292        case AlreadyInJSStackAsUnboxedDouble:
    293293            fprintf(out, "(double)");
    294294            break;
    … …  
    313313            break;
    314314#endif
    315         case DisplacedInRegisterFile:
     315        case DisplacedInJSStack:
    316316            fprintf(out, "*%d", virtualRegister());
    317317            break;
    318         case Int32DisplacedInRegisterFile:
     318        case Int32DisplacedInJSStack:
    319319            fprintf(out, "*int32(%d)", virtualRegister());
    320320            break;
    321         case DoubleDisplacedInRegisterFile:
     321        case DoubleDisplacedInJSStack:
    322322            fprintf(out, "*double(%d)", virtualRegister());
    323323            break;
    324         case CellDisplacedInRegisterFile:
     324        case CellDisplacedInJSStack:
    325325            fprintf(out, "*cell(%d)", virtualRegister());
    326326            break;
    327         case BooleanDisplacedInRegisterFile:
     327        case BooleanDisplacedInJSStack:
    328328            fprintf(out, "*bool(%d)", virtualRegister());
    329329            break;

  • trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

    r130612 r130726  
    630630        return 0;
    631631
    632     m_calleeRegister.setIndex(RegisterFile::Callee);
     632    m_calleeRegister.setIndex(JSStack::Callee);
    633633
    634634    // If non-strict eval is in play, we use a separate object in the scope chain for the callee's name.
    … …  
    20662066
    20672067    // Reserve space for call frame.
    2068     Vector<RefPtr<RegisterID>, RegisterFile::CallFrameHeaderSize> callFrame;
    2069     for (int i = 0; i < RegisterFile::CallFrameHeaderSize; ++i)
     2068    Vector<RefPtr<RegisterID>, JSStack::CallFrameHeaderSize> callFrame;
     2069    for (int i = 0; i < JSStack::CallFrameHeaderSize; ++i)
    20702070        callFrame.append(newTemporary());
    20712071
    … …  
    21832183
    21842184    // Reserve space for call frame.
    2185     Vector<RefPtr<RegisterID>, RegisterFile::CallFrameHeaderSize> callFrame;
    2186     for (int i = 0; i < RegisterFile::CallFrameHeaderSize; ++i)
     2185    Vector<RefPtr<RegisterID>, JSStack::CallFrameHeaderSize> callFrame;
     2186    for (int i = 0; i < JSStack::CallFrameHeaderSize; ++i)
    21872187        callFrame.append(newTemporary());
    21882188

  • trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h

    r129287 r130726  
    630630                return m_calleeRegisters[index];
    631631
    632             if (index == RegisterFile::Callee)
     632            if (index == JSStack::Callee)
    633633                return m_calleeRegister;
    634634
    635635            ASSERT(m_parameters.size());
    636             return m_parameters[index + m_parameters.size() + RegisterFile::CallFrameHeaderSize];
     636            return m_parameters[index + m_parameters.size() + JSStack::CallFrameHeaderSize];
    637637        }
    638638

  • trunk/Source/JavaScriptCore/dfg/DFGAbstractState.h

    r124404 r130726  
    186186   
    187187    // Abstractly executes the given node. The new abstract state is stored into an
    188     // abstract register file stored in *this. Loads of local variables (that span
     188    // abstract stack stored in *this. Loads of local variables (that span
    189189    // basic blocks) interrogate the basic block's notion of the state at the head.
    190190    // Stores to local variables are handled in endBasicBlock(). This returns true

  • trunk/Source/JavaScriptCore/dfg/DFGAssemblyHelpers.h

    r129156 r130726  
    9494#endif
    9595
    96     void emitGetFromCallFrameHeaderPtr(RegisterFile::CallFrameHeaderEntry entry, GPRReg to)
     96    void emitGetFromCallFrameHeaderPtr(JSStack::CallFrameHeaderEntry entry, GPRReg to)
    9797    {
    9898        loadPtr(Address(GPRInfo::callFrameRegister, entry * sizeof(Register)), to);
    9999    }
    100     void emitPutToCallFrameHeader(GPRReg from, RegisterFile::CallFrameHeaderEntry entry)
     100    void emitPutToCallFrameHeader(GPRReg from, JSStack::CallFrameHeaderEntry entry)
    101101    {
    102102        storePtr(from, Address(GPRInfo::callFrameRegister, entry * sizeof(Register)));
    103103    }
    104104
    105     void emitPutImmediateToCallFrameHeader(void* value, RegisterFile::CallFrameHeaderEntry entry)
     105    void emitPutImmediateToCallFrameHeader(void* value, JSStack::CallFrameHeaderEntry entry)
    106106    {
    107107        storePtr(TrustedImmPtr(value), Address(GPRInfo::callFrameRegister, entry * sizeof(Register)));

  • trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp

    r130612 r130726  
    143143        }
    144144
    145         if (operand == RegisterFile::Callee)
     145        if (operand == JSStack::Callee)
    146146            return getCallee();
    147147
    … …  
    370370            if (!inlineCallFrame)
    371371                break;
    372             if (operand >= static_cast<int>(inlineCallFrame->stackOffset - RegisterFile::CallFrameHeaderSize))
     372            if (operand >= static_cast<int>(inlineCallFrame->stackOffset - JSStack::CallFrameHeaderSize))
    373373                continue;
    374374            if (operand == inlineCallFrame->stackOffset + CallFrame::thisArgumentOffset())
    375375                continue;
    376             if (operand < static_cast<int>(inlineCallFrame->stackOffset - RegisterFile::CallFrameHeaderSize - inlineCallFrame->arguments.size()))
     376            if (operand < static_cast<int>(inlineCallFrame->stackOffset - JSStack::CallFrameHeaderSize - inlineCallFrame->arguments.size()))
    377377                continue;
    378378            int argument = operandToArgument(operand - inlineCallFrame->stackOffset);
    … …  
    762762        addVarArgChild(get(currentInstruction[1].u.operand));
    763763        int argCount = currentInstruction[2].u.operand;
    764         if (RegisterFile::CallFrameHeaderSize + (unsigned)argCount > m_parameterSlots)
    765             m_parameterSlots = RegisterFile::CallFrameHeaderSize + argCount;
     764        if (JSStack::CallFrameHeaderSize + (unsigned)argCount > m_parameterSlots)
     765            m_parameterSlots = JSStack::CallFrameHeaderSize + argCount;
    766766
    767767        int registerOffset = currentInstruction[3].u.operand;
    … …  
    11431143            }
    11441144
    1145             if (operand == RegisterFile::Callee)
     1145            if (operand == JSStack::Callee)
    11461146                return m_calleeVR;
    11471147
    … …  
    13651365    // FIXME: Don't flush constants!
    13661366   
    1367     int inlineCallFrameStart = m_inlineStackTop->remapOperand(registerOffset) - RegisterFile::CallFrameHeaderSize;
     1367    int inlineCallFrameStart = m_inlineStackTop->remapOperand(registerOffset) - JSStack::CallFrameHeaderSize;
    13681368   
    13691369    // Make sure that the area used by the call frame is reserved.
    1370     for (int arg = inlineCallFrameStart + RegisterFile::CallFrameHeaderSize + codeBlock->m_numVars; arg-- > inlineCallFrameStart;)
     1370    for (int arg = inlineCallFrameStart + JSStack::CallFrameHeaderSize + codeBlock->m_numVars; arg-- > inlineCallFrameStart;)
    13711371        m_preservedVars.set(arg);
    13721372   
    13731373    // Make sure that we have enough locals.
    1374     unsigned newNumLocals = inlineCallFrameStart + RegisterFile::CallFrameHeaderSize + codeBlock->m_numCalleeRegisters;
     1374    unsigned newNumLocals = inlineCallFrameStart + JSStack::CallFrameHeaderSize + codeBlock->m_numCalleeRegisters;
    13751375    if (newNumLocals > m_numLocals) {
    13761376        m_numLocals = newNumLocals;
    … …  
    18721872
    18731873        case op_create_this: {
    1874             set(currentInstruction[1].u.operand, addToGraph(CreateThis, get(RegisterFile::Callee)));
     1874            set(currentInstruction[1].u.operand, addToGraph(CreateThis, get(JSStack::Callee)));
    18751875            NEXT_OPCODE(op_create_this);
    18761876        }
    … …  
    27572757           
    27582758            unsigned argCount = m_inlineStackTop->m_inlineCallFrame->arguments.size();
    2759             if (RegisterFile::CallFrameHeaderSize + argCount > m_parameterSlots)
    2760                 m_parameterSlots = RegisterFile::CallFrameHeaderSize + argCount;
     2759            if (JSStack::CallFrameHeaderSize + argCount > m_parameterSlots)
     2760                m_parameterSlots = JSStack::CallFrameHeaderSize + argCount;
    27612761           
    27622762            addVarArgChild(get(currentInstruction[1].u.operand)); // callee
    … …  
    32113211        InlineCallFrame inlineCallFrame;
    32123212        inlineCallFrame.executable.set(*byteCodeParser->m_globalData, byteCodeParser->m_codeBlock->ownerExecutable(), codeBlock->ownerExecutable());
    3213         inlineCallFrame.stackOffset = inlineCallFrameStart + RegisterFile::CallFrameHeaderSize;
     3213        inlineCallFrame.stackOffset = inlineCallFrameStart + JSStack::CallFrameHeaderSize;
    32143214        inlineCallFrame.callee.set(*byteCodeParser->m_globalData, byteCodeParser->m_codeBlock->ownerExecutable(), callee);
    32153215        inlineCallFrame.caller = byteCodeParser->currentCodeOrigin();

  • trunk/Source/JavaScriptCore/dfg/DFGGenerationInfo.h

    r121717 r130726  
    202202    // Get the format of the value in machine registers (or 'none').
    203203    DataFormat registerFormat() { return m_registerFormat; }
    204     // Get the format of the value as it is spilled in the RegisterFile (or 'none').
     204    // Get the format of the value as it is spilled in the JSStack (or 'none').
    205205    DataFormat spillFormat() { return m_spillFormat; }
    206206   
    … …  
    256256        ASSERT(m_registerFormat != DataFormatNone);
    257257        // Constants do not need spilling, nor do values that have already been
    258         // spilled to the RegisterFile.
     258        // spilled to the JSStack.
    259259        return !m_canFill;
    260260    }
    261261
    262     // Called when a VirtualRegister is being spilled to the RegisterFile for the first time.
     262    // Called when a VirtualRegister is being spilled to the JSStack for the first time.
    263263    void spill(VariableEventStream& stream, VirtualRegister virtualRegister, DataFormat spillFormat)
    264264    {

  • trunk/Source/JavaScriptCore/dfg/DFGGraph.h

    r129266 r130726  
    3737#include "DFGDominators.h"
    3838#include "DFGNode.h"
     39#include "JSStack.h"
    3940#include "MethodOfGettingAValueProfile.h"
    40 #include "RegisterFile.h"
    4141#include <wtf/BitVector.h>
    4242#include <wtf/HashMap.h>

  • trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp

    r123042 r130726  
    6969    // This code currently matches the old JIT. In the function header we need to
    7070    // pop the return address (since we do not allow any recursion on the machine
    71     // stack), and perform a fast register file check.
     71    // stack), and perform a fast stack check.
    7272    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=56292
    73     // We'll need to convert the remaining cti_ style calls (specifically the register file
     73    // We'll need to convert the remaining cti_ style calls (specifically the stack
    7474    // check) which will be dependent on stack layout. (We'd need to account for this in
    7575    // both normal return code and when jumping to an exception handler).
    7676    preserveReturnAddressAfterCall(GPRInfo::regT2);
    77     emitPutToCallFrameHeader(GPRInfo::regT2, RegisterFile::ReturnPC);
    78     emitPutImmediateToCallFrameHeader(m_codeBlock, RegisterFile::CodeBlock);
     77    emitPutToCallFrameHeader(GPRInfo::regT2, JSStack::ReturnPC);
     78    emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
    7979}
    8080
    … …  
    257257    // so enter after this.
    258258    Label fromArityCheck(this);
    259     // Plant a check that sufficient space is available in the RegisterFile.
     259    // Plant a check that sufficient space is available in the JSStack.
    260260    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=56291
    261261    addPtr(TrustedImm32(m_codeBlock->m_numCalleeRegisters * sizeof(Register)), GPRInfo::callFrameRegister, GPRInfo::regT1);
    262     Jump registerFileCheck = branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->registerFile().addressOfEnd()), GPRInfo::regT1);
    263     // Return here after register file check.
    264     Label fromRegisterFileCheck = label();
     262    Jump stackCheck = branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->stack().addressOfEnd()), GPRInfo::regT1);
     263    // Return here after stack check.
     264    Label fromStackCheck = label();
    265265
    266266
    … …  
    272272    // === Function footer code generation ===
    273273    //
    274     // Generate code to perform the slow register file check (if the fast one in
     274    // Generate code to perform the slow stack check (if the fast one in
    275275    // the function header fails), and generate the entry point with arity check.
    276276    //
    277     // Generate the register file check; if the fast check in the function head fails,
     277    // Generate the stack check; if the fast check in the function head fails,
    278278    // we need to call out to a helper function to check whether more space is available.
    279279    // FIXME: change this from a cti call to a DFG style operation (normal C calling conventions).
    280     registerFileCheck.link(this);
     280    stackCheck.link(this);
    281281    move(stackPointerRegister, GPRInfo::argumentGPR0);
    282282    poke(GPRInfo::callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
    … …  
    284284    CallBeginToken token;
    285285    beginCall(CodeOrigin(0), token);
    286     Call callRegisterFileCheck = call();
    287     notifyCall(callRegisterFileCheck, CodeOrigin(0), token);
    288     jump(fromRegisterFileCheck);
     286    Call callStackCheck = call();
     287    notifyCall(callStackCheck, CodeOrigin(0), token);
     288    jump(fromStackCheck);
    289289   
    290290    // The fast entry point into a function does not check the correct number of arguments
    … …  
    296296    compileEntry();
    297297
    298     load32(AssemblyHelpers::payloadFor((VirtualRegister)RegisterFile::ArgumentCount), GPRInfo::regT1);
     298    load32(AssemblyHelpers::payloadFor((VirtualRegister)JSStack::ArgumentCount), GPRInfo::regT1);
    299299    branch32(AboveOrEqual, GPRInfo::regT1, TrustedImm32(m_codeBlock->numParameters())).linkTo(fromArityCheck, this);
    300300    move(stackPointerRegister, GPRInfo::argumentGPR0);
    … …  
    323323    speculative.linkOSREntries(linkBuffer);
    324324   
    325     // FIXME: switch the register file check & arity check over to DFGOpertaion style calls, not JIT stubs.
    326     linkBuffer.link(callRegisterFileCheck, cti_register_file_check);
     325    // FIXME: switch the stack check & arity check over to DFGOpertaion style calls, not JIT stubs.
     326    linkBuffer.link(callStackCheck, cti_stack_check);
    327327    linkBuffer.link(callArityCheck, m_codeBlock->m_isConstructor ? cti_op_construct_arityCheck : cti_op_call_arityCheck);
    328328   

  • trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.h

    r122768 r130726  
    298298    {
    299299        unsigned index = m_exceptionChecks.size();
    300         store32(TrustedImm32(index), tagFor(static_cast<VirtualRegister>(RegisterFile::ArgumentCount)));
     300        store32(TrustedImm32(index), tagFor(static_cast<VirtualRegister>(JSStack::ArgumentCount)));
    301301        token.set(codeOrigin, index);
    302302    }

  • trunk/Source/JavaScriptCore/dfg/DFGOSREntry.cpp

    r125999 r130726  
    137137    //    would have otherwise just kept running albeit less quickly.
    138138   
    139     if (!globalData->interpreter->registerFile().grow(&exec->registers()[codeBlock->m_numCalleeRegisters])) {
     139    if (!globalData->interpreter->stack().grow(&exec->registers()[codeBlock->m_numCalleeRegisters])) {
    140140#if ENABLE(JIT_VERBOSE_OSR)
    141141        dataLog("    OSR failed because stack growth failed.\n");

  • trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp

    r129089 r130726  
    126126    // expect most of them to be jsUndefined(); if that's true then we handle that
    127127    // specially to minimize code size and execution time.
    128     bool haveUnboxedInt32InRegisterFile = false;
    129     bool haveUnboxedCellInRegisterFile = false;
    130     bool haveUnboxedBooleanInRegisterFile = false;
     128    bool haveUnboxedInt32InJSStack = false;
     129    bool haveUnboxedCellInJSStack = false;
     130    bool haveUnboxedBooleanInJSStack = false;
    131131    bool haveUInt32s = false;
    132132    bool haveFPRs = false;
    … …  
    138138        const ValueRecovery& recovery = operands[index];
    139139        switch (recovery.technique()) {
    140         case DisplacedInRegisterFile:
    141         case Int32DisplacedInRegisterFile:
    142         case CellDisplacedInRegisterFile:
    143         case BooleanDisplacedInRegisterFile:
     140        case DisplacedInJSStack:
     141        case Int32DisplacedInJSStack:
     142        case CellDisplacedInJSStack:
     143        case BooleanDisplacedInJSStack:
    144144            numberOfDisplacedVirtualRegisters++;
    145145            ASSERT((int)recovery.virtualRegister() >= 0);
    … …  
    175175            break;
    176176
    177         case AlreadyInRegisterFileAsUnboxedInt32:
    178             haveUnboxedInt32InRegisterFile = true;
    179             break;
    180            
    181         case AlreadyInRegisterFileAsUnboxedCell:
    182             haveUnboxedCellInRegisterFile = true;
    183             break;
    184            
    185         case AlreadyInRegisterFileAsUnboxedBoolean:
    186             haveUnboxedBooleanInRegisterFile = true;
     177        case AlreadyInJSStackAsUnboxedInt32:
     178            haveUnboxedInt32InJSStack = true;
     179            break;
     180           
     181        case AlreadyInJSStackAsUnboxedCell:
     182            haveUnboxedCellInJSStack = true;
     183            break;
     184           
     185        case AlreadyInJSStackAsUnboxedBoolean:
     186            haveUnboxedBooleanInJSStack = true;
    187187            break;
    188188           
    … …  
    215215    // 5) Perform all reboxing of integers and cells, except for those in registers.
    216216
    217     if (haveUnboxedInt32InRegisterFile || haveUnboxedCellInRegisterFile || haveUnboxedBooleanInRegisterFile) {
     217    if (haveUnboxedInt32InJSStack || haveUnboxedCellInJSStack || haveUnboxedBooleanInJSStack) {
    218218        for (size_t index = 0; index < operands.size(); ++index) {
    219219            const ValueRecovery& recovery = operands[index];
    220220            switch (recovery.technique()) {
    221             case AlreadyInRegisterFileAsUnboxedInt32:
     221            case AlreadyInJSStackAsUnboxedInt32:
    222222                m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::Int32Tag), AssemblyHelpers::tagFor(static_cast<VirtualRegister>(operands.operandForIndex(index))));
    223223                break;
    224224
    225             case AlreadyInRegisterFileAsUnboxedCell:
     225            case AlreadyInJSStackAsUnboxedCell:
    226226                m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::CellTag), AssemblyHelpers::tagFor(static_cast<VirtualRegister>(operands.operandForIndex(index))));
    227227                break;
    228228
    229             case AlreadyInRegisterFileAsUnboxedBoolean:
     229            case AlreadyInJSStackAsUnboxedBoolean:
    230230                m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::BooleanTag), AssemblyHelpers::tagFor(static_cast<VirtualRegister>(operands.operandForIndex(index))));
    231231                break;
    … …  
    328328    }
    329329   
    330     // 7) Dump all doubles into the register file, or to the scratch storage if the
     330    // 7) Dump all doubles into the stack, or to the scratch storage if the
    331331    //    destination virtual register is poisoned.
    332332    if (haveFPRs) {
    … …  
    361361                const ValueRecovery& recovery = operands[index];
    362362                switch (recovery.technique()) {
    363                 case DisplacedInRegisterFile:
     363                case DisplacedInJSStack:
    364364                    m_jit.load32(AssemblyHelpers::payloadFor(recovery.virtualRegister()), GPRInfo::toRegister(displacementIndex++));
    365365                    m_jit.load32(AssemblyHelpers::tagFor(recovery.virtualRegister()), GPRInfo::toRegister(displacementIndex++));
    366366                    break;
    367                 case Int32DisplacedInRegisterFile:
     367                case Int32DisplacedInJSStack:
    368368                    m_jit.load32(AssemblyHelpers::payloadFor(recovery.virtualRegister()), GPRInfo::toRegister(displacementIndex++));
    369369                    m_jit.move(AssemblyHelpers::TrustedImm32(JSValue::Int32Tag), GPRInfo::toRegister(displacementIndex++));
    370370                    break;
    371                 case CellDisplacedInRegisterFile:
     371                case CellDisplacedInJSStack:
    372372                    m_jit.load32(AssemblyHelpers::payloadFor(recovery.virtualRegister()), GPRInfo::toRegister(displacementIndex++));
    373373                    m_jit.move(AssemblyHelpers::TrustedImm32(JSValue::CellTag), GPRInfo::toRegister(displacementIndex++));
    374374                    break;
    375                 case BooleanDisplacedInRegisterFile:
     375                case BooleanDisplacedInJSStack:
    376376                    m_jit.load32(AssemblyHelpers::payloadFor(recovery.virtualRegister()), GPRInfo::toRegister(displacementIndex++));
    377377                    m_jit.move(AssemblyHelpers::TrustedImm32(JSValue::BooleanTag), GPRInfo::toRegister(displacementIndex++));
    … …  
    386386                const ValueRecovery& recovery = operands[index];
    387387                switch (recovery.technique()) {
    388                 case DisplacedInRegisterFile:
    389                 case Int32DisplacedInRegisterFile:
    390                 case CellDisplacedInRegisterFile:
    391                 case BooleanDisplacedInRegisterFile:
     388                case DisplacedInJSStack:
     389                case Int32DisplacedInJSStack:
     390                case CellDisplacedInJSStack:
     391                case BooleanDisplacedInJSStack:
    392392                    m_jit.store32(GPRInfo::toRegister(displacementIndex++), AssemblyHelpers::payloadFor((VirtualRegister)operands.operandForIndex(index)));
    393393                    m_jit.store32(GPRInfo::toRegister(displacementIndex++), AssemblyHelpers::tagFor((VirtualRegister)operands.operandForIndex(index)));
    … …  
    419419                const ValueRecovery& recovery = operands[index];
    420420                switch (recovery.technique()) {
    421                 case DisplacedInRegisterFile:
     421                case DisplacedInJSStack:
    422422                    m_jit.load32(AssemblyHelpers::payloadFor(recovery.virtualRegister()), GPRInfo::regT0);
    423423                    m_jit.load32(AssemblyHelpers::tagFor(recovery.virtualRegister()), GPRInfo::regT1);
    … …  
    426426                    scratchIndex++;
    427427                    break;
    428                 case Int32DisplacedInRegisterFile:
    429                 case CellDisplacedInRegisterFile:
    430                 case BooleanDisplacedInRegisterFile:
     428                case Int32DisplacedInJSStack:
     429                case CellDisplacedInJSStack:
     430                case BooleanDisplacedInJSStack:
    431431                    m_jit.load32(AssemblyHelpers::payloadFor(recovery.virtualRegister()), GPRInfo::regT0);
    432432                    m_jit.store32(GPRInfo::regT0, reinterpret_cast<char*>(scratchDataBuffer + scratchIndex++) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload));
    … …  
    441441                const ValueRecovery& recovery = operands[index];
    442442                switch (recovery.technique()) {
    443                 case DisplacedInRegisterFile:
     443                case DisplacedInJSStack:
    444444                    m_jit.load32(reinterpret_cast<char*>(scratchDataBuffer + scratchIndex) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload), GPRInfo::regT0);
    445445                    m_jit.load32(reinterpret_cast<char*>(scratchDataBuffer + scratchIndex) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag), GPRInfo::regT1);
    … …  
    448448                    scratchIndex++;
    449449                    break;
    450                 case Int32DisplacedInRegisterFile:
     450                case Int32DisplacedInJSStack:
    451451                    m_jit.load32(reinterpret_cast<char*>(scratchDataBuffer + scratchIndex++) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload), GPRInfo::regT0);
    452452                    m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::Int32Tag), AssemblyHelpers::tagFor((VirtualRegister)operands.operandForIndex(index)));
    453453                    m_jit.store32(GPRInfo::regT0, AssemblyHelpers::payloadFor((VirtualRegister)operands.operandForIndex(index)));
    454454                    break;
    455                 case CellDisplacedInRegisterFile:
     455                case CellDisplacedInJSStack:
    456456                    m_jit.load32(reinterpret_cast<char*>(scratchDataBuffer + scratchIndex++) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload), GPRInfo::regT0);
    457457                    m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::CellTag), AssemblyHelpers::tagFor((VirtualRegister)operands.operandForIndex(index)));
    458458                    m_jit.store32(GPRInfo::regT0, AssemblyHelpers::payloadFor((VirtualRegister)operands.operandForIndex(index)));
    459459                    break;
    460                 case BooleanDisplacedInRegisterFile:
     460                case BooleanDisplacedInJSStack:
    461461                    m_jit.load32(reinterpret_cast<char*>(scratchDataBuffer + scratchIndex++) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload), GPRInfo::regT0);
    462462                    m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::BooleanTag), AssemblyHelpers::tagFor((VirtualRegister)operands.operandForIndex(index)));
    … …  
    576576   
    577577    ASSERT(m_jit.baselineCodeBlock()->getJITType() == JITCode::BaselineJIT);
    578     m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(m_jit.baselineCodeBlock()), AssemblyHelpers::addressFor((VirtualRegister)RegisterFile::CodeBlock));
     578    m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(m_jit.baselineCodeBlock()), AssemblyHelpers::addressFor((VirtualRegister)JSStack::CodeBlock));
    579579   
    580580    for (CodeOrigin codeOrigin = exit.m_codeOrigin; codeOrigin.inlineCallFrame; codeOrigin = codeOrigin.inlineCallFrame->caller) {
    … …  
    598598            callerFrameGPR = GPRInfo::callFrameRegister;
    599599       
    600         m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(baselineCodeBlock), AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::CodeBlock)));
    601         m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::CellTag), AssemblyHelpers::tagFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::ScopeChain)));
    602         m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(inlineCallFrame->callee->scope()), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::ScopeChain)));
    603         m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::CellTag), AssemblyHelpers::tagFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::CallerFrame)));
    604         m_jit.storePtr(callerFrameGPR, AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::CallerFrame)));
    605         m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(jumpTarget), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::ReturnPC)));
    606         m_jit.store32(AssemblyHelpers::TrustedImm32(inlineCallFrame->arguments.size()), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::ArgumentCount)));
    607         m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::CellTag), AssemblyHelpers::tagFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::Callee)));
    608         m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(inlineCallFrame->callee.get()), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::Callee)));
     600        m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(baselineCodeBlock), AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::CodeBlock)));
     601        m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::CellTag), AssemblyHelpers::tagFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ScopeChain)));
     602        m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(inlineCallFrame->callee->scope()), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ScopeChain)));
     603        m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::CellTag), AssemblyHelpers::tagFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::CallerFrame)));
     604        m_jit.storePtr(callerFrameGPR, AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::CallerFrame)));
     605        m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(jumpTarget), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ReturnPC)));
     606        m_jit.store32(AssemblyHelpers::TrustedImm32(inlineCallFrame->arguments.size()), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ArgumentCount)));
     607        m_jit.store32(AssemblyHelpers::TrustedImm32(JSValue::CellTag), AssemblyHelpers::tagFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::Callee)));
     608        m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(inlineCallFrame->callee.get()), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::Callee)));
    609609    }
    610610   

  • trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompiler64.cpp

    r129089 r130726  
    134134        const ValueRecovery& recovery = operands[index];
    135135        switch (recovery.technique()) {
    136         case Int32DisplacedInRegisterFile:
    137         case DoubleDisplacedInRegisterFile:
    138         case DisplacedInRegisterFile:
     136        case Int32DisplacedInJSStack:
     137        case DoubleDisplacedInJSStack:
     138        case DisplacedInJSStack:
    139139            numberOfDisplacedVirtualRegisters++;
    140140            ASSERT((int)recovery.virtualRegister() >= 0);
    … …  
    165165           
    166166        case UnboxedInt32InGPR:
    167         case AlreadyInRegisterFileAsUnboxedInt32:
     167        case AlreadyInJSStackAsUnboxedInt32:
    168168            haveUnboxedInt32s = true;
    169169            break;
    170170           
    171         case AlreadyInRegisterFileAsUnboxedDouble:
     171        case AlreadyInJSStackAsUnboxedDouble:
    172172            haveUnboxedDoubles = true;
    173173            break;
    … …  
    234234                break;
    235235               
    236             case AlreadyInRegisterFileAsUnboxedInt32:
     236            case AlreadyInJSStackAsUnboxedInt32:
    237237                m_jit.store32(AssemblyHelpers::TrustedImm32(static_cast<uint32_t>(TagTypeNumber >> 32)), AssemblyHelpers::tagFor(static_cast<VirtualRegister>(operands.operandForIndex(index))));
    238238                break;
    … …  
    322322        }
    323323       
    324         // 8) Dump all doubles into the register file, or to the scratch storage if
     324        // 8) Dump all doubles into the stack, or to the scratch storage if
    325325        //    the destination virtual register is poisoned.
    326326       
    … …  
    341341    // At this point all GPRs and FPRs are available for scratch use.
    342342   
    343     // 9) Box all unboxed doubles in the register file.
     343    // 9) Box all unboxed doubles in the stack.
    344344    if (haveUnboxedDoubles) {
    345345        for (size_t index = 0; index < operands.size(); ++index) {
    346346            const ValueRecovery& recovery = operands[index];
    347             if (recovery.technique() != AlreadyInRegisterFileAsUnboxedDouble)
     347            if (recovery.technique() != AlreadyInJSStackAsUnboxedDouble)
    348348                continue;
    349349            m_jit.loadDouble(AssemblyHelpers::addressFor((VirtualRegister)operands.operandForIndex(index)), FPRInfo::fpRegT0);
    … …  
    368368                const ValueRecovery& recovery = operands[index];
    369369                switch (recovery.technique()) {
    370                 case DisplacedInRegisterFile:
     370                case DisplacedInJSStack:
    371371                    m_jit.loadPtr(AssemblyHelpers::addressFor(recovery.virtualRegister()), GPRInfo::toRegister(displacementIndex++));
    372372                    break;
    373373                   
    374                 case Int32DisplacedInRegisterFile: {
     374                case Int32DisplacedInJSStack: {
    375375                    GPRReg gpr = GPRInfo::toRegister(displacementIndex++);
    376376                    m_jit.load32(AssemblyHelpers::addressFor(recovery.virtualRegister()), gpr);
    … …  
    379379                }
    380380                   
    381                 case DoubleDisplacedInRegisterFile: {
     381                case DoubleDisplacedInJSStack: {
    382382                    GPRReg gpr = GPRInfo::toRegister(displacementIndex++);
    383383                    m_jit.loadPtr(AssemblyHelpers::addressFor(recovery.virtualRegister()), gpr);
    … …  
    395395                const ValueRecovery& recovery = operands[index];
    396396                switch (recovery.technique()) {
    397                 case DisplacedInRegisterFile:
    398                 case Int32DisplacedInRegisterFile:
    399                 case DoubleDisplacedInRegisterFile:
     397                case DisplacedInJSStack:
     398                case Int32DisplacedInJSStack:
     399                case DoubleDisplacedInJSStack:
    400400                    m_jit.storePtr(GPRInfo::toRegister(displacementIndex++), AssemblyHelpers::addressFor((VirtualRegister)operands.operandForIndex(index)));
    401401                    break;
    … …  
    428428               
    429429                switch (recovery.technique()) {
    430                 case DisplacedInRegisterFile:
     430                case DisplacedInJSStack:
    431431                    m_jit.loadPtr(AssemblyHelpers::addressFor(recovery.virtualRegister()), GPRInfo::regT0);
    432432                    m_jit.storePtr(GPRInfo::regT0, scratchDataBuffer + scratchIndex++);
    433433                    break;
    434434                   
    435                 case Int32DisplacedInRegisterFile: {
     435                case Int32DisplacedInJSStack: {
    436436                    m_jit.load32(AssemblyHelpers::addressFor(recovery.virtualRegister()), GPRInfo::regT0);
    437437                    m_jit.orPtr(GPRInfo::tagTypeNumberRegister, GPRInfo::regT0);
    … …  
    440440                }
    441441                   
    442                 case DoubleDisplacedInRegisterFile: {
     442                case DoubleDisplacedInJSStack: {
    443443                    m_jit.loadPtr(AssemblyHelpers::addressFor(recovery.virtualRegister()), GPRInfo::regT0);
    444444                    m_jit.subPtr(GPRInfo::tagTypeNumberRegister, GPRInfo::regT0);
    … …  
    456456                const ValueRecovery& recovery = operands[index];
    457457                switch (recovery.technique()) {
    458                 case DisplacedInRegisterFile:
    459                 case Int32DisplacedInRegisterFile:
    460                 case DoubleDisplacedInRegisterFile:
     458                case DisplacedInJSStack:
     459                case Int32DisplacedInJSStack:
     460                case DoubleDisplacedInJSStack:
    461461                    m_jit.loadPtr(scratchDataBuffer + scratchIndex++, GPRInfo::regT0);
    462462                    m_jit.storePtr(GPRInfo::regT0, AssemblyHelpers::addressFor((VirtualRegister)operands.operandForIndex(index)));
    … …  
    554554   
    555555    ASSERT(m_jit.baselineCodeBlock()->getJITType() == JITCode::BaselineJIT);
    556     m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(m_jit.baselineCodeBlock()), AssemblyHelpers::addressFor((VirtualRegister)RegisterFile::CodeBlock));
     556    m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(m_jit.baselineCodeBlock()), AssemblyHelpers::addressFor((VirtualRegister)JSStack::CodeBlock));
    557557   
    558558    for (CodeOrigin codeOrigin = exit.m_codeOrigin; codeOrigin.inlineCallFrame; codeOrigin = codeOrigin.inlineCallFrame->caller) {
    … …  
    576576            callerFrameGPR = GPRInfo::callFrameRegister;
    577577       
    578         m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(baselineCodeBlock), AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::CodeBlock)));
    579         m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(inlineCallFrame->callee->scope()), AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::ScopeChain)));
    580         m_jit.storePtr(callerFrameGPR, AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::CallerFrame)));
    581         m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(jumpTarget), AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::ReturnPC)));
    582         m_jit.store32(AssemblyHelpers::TrustedImm32(inlineCallFrame->arguments.size()), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::ArgumentCount)));
    583         m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(inlineCallFrame->callee.get()), AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + RegisterFile::Callee)));
     578        m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(baselineCodeBlock), AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::CodeBlock)));
     579        m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(inlineCallFrame->callee->scope()), AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ScopeChain)));
     580        m_jit.storePtr(callerFrameGPR, AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::CallerFrame)));
     581        m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(jumpTarget), AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ReturnPC)));
     582        m_jit.store32(AssemblyHelpers::TrustedImm32(inlineCallFrame->arguments.size()), AssemblyHelpers::payloadFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::ArgumentCount)));
     583        m_jit.storePtr(AssemblyHelpers::TrustedImmPtr(inlineCallFrame->callee.get()), AssemblyHelpers::addressFor((VirtualRegister)(inlineCallFrame->stackOffset + JSStack::Callee)));
    584584    }
    585585   

  • trunk/Source/JavaScriptCore/dfg/DFGRepatch.cpp

    r129272 r130726  
    449449            stubJit.store32(
    450450                MacroAssembler::TrustedImm32(exec->codeOriginIndexForDFG()),
    451                 CCallHelpers::tagFor(static_cast<VirtualRegister>(RegisterFile::ArgumentCount)));
     451                CCallHelpers::tagFor(static_cast<VirtualRegister>(JSStack::ArgumentCount)));
    452452           
    453453            operationCall = stubJit.call();

  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

    r129435 r130726  
    13681368    ASSERT(m_arguments.size() == block.variablesAtHead.numberOfArguments());
    13691369    for (size_t i = 0; i < m_arguments.size(); ++i) {
    1370         ValueSource valueSource = ValueSource(ValueInRegisterFile);
     1370        ValueSource valueSource = ValueSource(ValueInJSStack);
    13711371        m_arguments[i] = valueSource;
    13721372        m_stream->appendAndLog(VariableEvent::setLocal(argumentToOperand(i), valueSource.dataFormat()));
    … …  
    13851385            valueSource = ValueSource(ArgumentsSource);
    13861386        else if (at(nodeIndex).variableAccessData()->isCaptured())
    1387             valueSource = ValueSource(ValueInRegisterFile);
     1387            valueSource = ValueSource(ValueInJSStack);
    13881388        else if (!at(nodeIndex).refCount())
    13891389            valueSource = ValueSource(SourceIsDead);
    13901390        else if (at(nodeIndex).variableAccessData()->shouldUseDoubleFormat())
    1391             valueSource = ValueSource(DoubleInRegisterFile);
     1391            valueSource = ValueSource(DoubleInJSStack);
    13921392        else
    13931393            valueSource = ValueSource::forSpeculation(at(nodeIndex).variableAccessData()->argumentAwarePrediction());
    … …  
    14411441                    ValueRecovery recovery;
    14421442                    if (codeBlock->isCaptured(argumentToOperand(i)))
    1443                         recovery = ValueRecovery::alreadyInRegisterFile();
     1443                        recovery = ValueRecovery::alreadyInJSStack();
    14441444                    else {
    14451445                        ArgumentPosition& argumentPosition =
    … …  
    14471447                        ValueSource valueSource;
    14481448                        if (argumentPosition.shouldUseDoubleFormat())
    1449                             valueSource = ValueSource(DoubleInRegisterFile);
     1449                            valueSource = ValueSource(DoubleInJSStack);
    14501450                        else if (isInt32Speculation(argumentPosition.prediction()))
    1451                             valueSource = ValueSource(Int32InRegisterFile);
     1451                            valueSource = ValueSource(Int32InJSStack);
    14521452                        else if (isCellSpeculation(argumentPosition.prediction()))
    1453                             valueSource = ValueSource(CellInRegisterFile);
     1453                            valueSource = ValueSource(CellInJSStack);
    14541454                        else if (isBooleanSpeculation(argumentPosition.prediction()))
    1455                             valueSource = ValueSource(BooleanInRegisterFile);
     1455                            valueSource = ValueSource(BooleanInJSStack);
    14561456                        else
    1457                             valueSource = ValueSource(ValueInRegisterFile);
     1457                            valueSource = ValueSource(ValueInJSStack);
    14581458                        recovery = computeValueRecoveryFor(valueSource);
    14591459                    }
    14601460                    // The recovery should refer either to something that has already been
    1461                     // stored into the register file at the right place, or to a constant,
     1461                    // stored into the stack at the right place, or to a constant,
    14621462                    // since the Arguments code isn't smart enough to handle anything else.
    14631463                    // The exception is the this argument, which we don't really need to be
    … …  
    15511551
    15521552    for (size_t i = 0; i < m_arguments.size(); ++i)
    1553         m_arguments[i] = ValueSource(ValueInRegisterFile);
     1553        m_arguments[i] = ValueSource(ValueInJSStack);
    15541554    for (size_t i = 0; i < m_variables.size(); ++i)
    1555         m_variables[i] = ValueSource(ValueInRegisterFile);
     1555        m_variables[i] = ValueSource(ValueInJSStack);
    15561556   
    15571557    for (int i = 0; i < m_jit.codeBlock()->numParameters(); ++i) {
    … …  
    16501650ValueRecovery SpeculativeJIT::computeValueRecoveryFor(const ValueSource& valueSource)
    16511651{
    1652     if (valueSource.isInRegisterFile())
     1652    if (valueSource.isInJSStack())
    16531653        return valueSource.valueRecovery();
    16541654       

  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h

    r130303 r130726  
    326326    // calls out from JIT code to C++ helper routines -
    327327    // they spill all live values to the appropriate
    328     // slots in the RegisterFile without changing any state
     328    // slots in the JSStack without changing any state
    329329    // in the GenerationInfo.
    330330    SilentRegisterSavePlan silentSavePlanForGPR(VirtualRegister spillMe, GPRReg source)
    … …  
    705705#endif
    706706
    707     // Spill a VirtualRegister to the RegisterFile.
     707    // Spill a VirtualRegister to the JSStack.
    708708    void spill(VirtualRegister spillMe)
    709709    {
    … …  
    715715#endif
    716716        // Check the GenerationInfo to see if this value need writing
    717         // to the RegisterFile - if not, mark it as spilled & return.
     717        // to the JSStack - if not, mark it as spilled & return.
    718718        if (!info.needsSpill()) {
    719719            info.setSpilled(*m_stream, spillMe);
    … …  
    830830    }
    831831
    832     // Spill all VirtualRegisters back to the RegisterFile.
     832    // Spill all VirtualRegisters back to the JSStack.
    833833    void flushRegisters()
    834834    {

  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp

    r130359 r130726  
    10161016    int numPassedArgs = node.numChildren() - 1;
    10171017
    1018     m_jit.store32(MacroAssembler::TrustedImm32(numPassedArgs + dummyThisArgument), callFramePayloadSlot(RegisterFile::ArgumentCount));
    1019     m_jit.storePtr(GPRInfo::callFrameRegister, callFramePayloadSlot(RegisterFile::CallerFrame));
    1020     m_jit.store32(calleePayloadGPR, callFramePayloadSlot(RegisterFile::Callee));
    1021     m_jit.store32(calleeTagGPR, callFrameTagSlot(RegisterFile::Callee));
     1018    m_jit.store32(MacroAssembler::TrustedImm32(numPassedArgs + dummyThisArgument), callFramePayloadSlot(JSStack::ArgumentCount));
     1019    m_jit.storePtr(GPRInfo::callFrameRegister, callFramePayloadSlot(JSStack::CallerFrame));
     1020    m_jit.store32(calleePayloadGPR, callFramePayloadSlot(JSStack::Callee));
     1021    m_jit.store32(calleeTagGPR, callFrameTagSlot(JSStack::Callee));
    10221022
    10231023    for (int i = 0; i < numPassedArgs; i++) {
    … …  
    10501050    slowPath.append(m_jit.branch32(MacroAssembler::NotEqual, calleeTagGPR, TrustedImm32(JSValue::CellTag)));
    10511051    m_jit.loadPtr(MacroAssembler::Address(calleePayloadGPR, OBJECT_OFFSETOF(JSFunction, m_scope)), resultPayloadGPR);
    1052     m_jit.storePtr(resultPayloadGPR, MacroAssembler::Address(GPRInfo::callFrameRegister, static_cast<ptrdiff_t>(sizeof(Register)) * RegisterFile::ScopeChain + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)));
    1053     m_jit.store32(MacroAssembler::TrustedImm32(JSValue::CellTag), MacroAssembler::Address(GPRInfo::callFrameRegister, static_cast<ptrdiff_t>(sizeof(Register)) * RegisterFile::ScopeChain + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)));
     1052    m_jit.storePtr(resultPayloadGPR, MacroAssembler::Address(GPRInfo::callFrameRegister, static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ScopeChain + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)));
     1053    m_jit.store32(MacroAssembler::TrustedImm32(JSValue::CellTag), MacroAssembler::Address(GPRInfo::callFrameRegister, static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ScopeChain + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)));
    10541054
    10551055    CodeOrigin codeOrigin = at(m_compileIndex).codeOrigin;
    … …  
    21622162        // as a speculation point. So before we speculate make sure that we
    21632163        // know where the child of this node needs to go in the virtual
    2164         // register file.
     2164        // stack.
    21652165        compileMovHint(node);
    21662166       
    … …  
    21912191        // fine, because this SetLocal's local (i.e. the LHS in a x = y++
    21922192        // statement) would be dead anyway - so the fact that DFG would have
    2193         // already made the assignment, and baked it into the register file during
     2193        // already made the assignment, and baked it into the stack during
    21942194        // OSR exit, would not be visible to the old JIT in any way.
    21952195        m_codeOriginForOSR = nextNode->codeOrigin;
    … …  
    22012201                noResult(m_compileIndex);
    22022202                // Indicate that it's no longer necessary to retrieve the value of
    2203                 // this bytecode variable from registers or other locations in the register file,
     2203                // this bytecode variable from registers or other locations in the stack,
    22042204                // but that it is stored as a double.
    2205                 recordSetLocal(node.local(), ValueSource(DoubleInRegisterFile));
     2205                recordSetLocal(node.local(), ValueSource(DoubleInJSStack));
    22062206                break;
    22072207            }
    … …  
    22112211                m_jit.storeDouble(value.fpr(), JITCompiler::addressFor(node.local()));
    22122212                noResult(m_compileIndex);
    2213                 recordSetLocal(node.local(), ValueSource(DoubleInRegisterFile));
     2213                recordSetLocal(node.local(), ValueSource(DoubleInJSStack));
    22142214                break;
    22152215            }
    … …  
    22182218                m_jit.store32(value.gpr(), JITCompiler::payloadFor(node.local()));
    22192219                noResult(m_compileIndex);
    2220                 recordSetLocal(node.local(), ValueSource(Int32InRegisterFile));
     2220                recordSetLocal(node.local(), ValueSource(Int32InJSStack));
    22212221                break;
    22222222            }
    … …  
    22262226                m_jit.storePtr(cellGPR, JITCompiler::payloadFor(node.local()));
    22272227                noResult(m_compileIndex);
    2228                 recordSetLocal(node.local(), ValueSource(CellInRegisterFile));
     2228                recordSetLocal(node.local(), ValueSource(CellInJSStack));
    22292229                break;
    22302230            }
    … …  
    22332233                m_jit.store32(value.gpr(), JITCompiler::payloadFor(node.local()));
    22342234                noResult(m_compileIndex);
    2235                 recordSetLocal(node.local(), ValueSource(BooleanInRegisterFile));
     2235                recordSetLocal(node.local(), ValueSource(BooleanInJSStack));
    22362236                break;
    22372237            }
    … …  
    22412241        m_jit.store32(value.tagGPR(), JITCompiler::tagFor(node.local()));
    22422242        noResult(m_compileIndex);
    2243         recordSetLocal(node.local(), ValueSource(ValueInRegisterFile));
     2243        recordSetLocal(node.local(), ValueSource(ValueInJSStack));
    22442244
    22452245        // If we're storing an arguments object that has been optimized away,
    … …  
    30523052
    30533053        // Grab the return address.
    3054         m_jit.emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, GPRInfo::regT2);
     3054        m_jit.emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, GPRInfo::regT2);
    30553055        // Restore our caller's "r".
    3056         m_jit.emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, GPRInfo::callFrameRegister);
     3056        m_jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, GPRInfo::callFrameRegister);
    30573057        // Return.
    30583058        m_jit.restoreReturnAddressBeforeReturn(GPRInfo::regT2);
    … …  
    33673367    case GetCallee: {
    33683368        GPRTemporary result(this);
    3369         m_jit.loadPtr(JITCompiler::addressFor(static_cast<VirtualRegister>(RegisterFile::Callee)), result.gpr());
     3369        m_jit.loadPtr(JITCompiler::addressFor(static_cast<VirtualRegister>(JSStack::Callee)), result.gpr());
    33703370        cellResult(result.gpr(), m_compileIndex);
    33713371        break;
    … …  
    33763376        GPRReg resultGPR = result.gpr();
    33773377
    3378         m_jit.loadPtr(JITCompiler::addressFor(static_cast<VirtualRegister>(RegisterFile::ScopeChain)), resultGPR);
     3378        m_jit.loadPtr(JITCompiler::addressFor(static_cast<VirtualRegister>(JSStack::ScopeChain)), resultGPR);
    33793379        bool checkTopLevel = m_jit.codeBlock()->codeType() == FunctionCode && m_jit.codeBlock()->needsFullScopeChain();
    33803380        int skip = node.scopeChainDepth();
    … …  
    41624162       
    41634163        ASSERT(!node.codeOrigin.inlineCallFrame);
    4164         m_jit.load32(JITCompiler::payloadFor(RegisterFile::ArgumentCount), resultGPR);
     4164        m_jit.load32(JITCompiler::payloadFor(JSStack::ArgumentCount), resultGPR);
    41654165        m_jit.sub32(TrustedImm32(1), resultGPR);
    41664166        integerResult(resultGPR, m_compileIndex);
    … …  
    41844184                resultPayloadGPR);
    41854185        } else {
    4186             m_jit.load32(JITCompiler::payloadFor(RegisterFile::ArgumentCount), resultPayloadGPR);
     4186            m_jit.load32(JITCompiler::payloadFor(JSStack::ArgumentCount), resultPayloadGPR);
    41874187            m_jit.sub32(TrustedImm32(1), resultPayloadGPR);
    41884188        }
    … …  
    42374237                    JITCompiler::AboveOrEqual,
    42384238                    resultPayloadGPR,
    4239                     JITCompiler::payloadFor(RegisterFile::ArgumentCount)));
     4239                    JITCompiler::payloadFor(JSStack::ArgumentCount)));
    42404240        }
    42414241       
    … …  
    43144314                    JITCompiler::AboveOrEqual,
    43154315                    resultPayloadGPR,
    4316                     JITCompiler::payloadFor(RegisterFile::ArgumentCount)));
     4316                    JITCompiler::payloadFor(JSStack::ArgumentCount)));
    43174317        }
    43184318       

  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp

    r130359 r130726  
    7373
    7474        // Since we statically know that we're filling an integer, and values
    75         // in the RegisterFile are boxed, this must be DataFormatJSInteger.
     75        // in the JSStack are boxed, this must be DataFormatJSInteger.
    7676        // We will check this with a jitAssert below.
    7777        info.fillJSValue(*m_stream, gpr, DataFormatJSInteger);
    … …  
    10061006    int numPassedArgs = node.numChildren() - 1;
    10071007   
    1008     m_jit.store32(MacroAssembler::TrustedImm32(numPassedArgs + dummyThisArgument), callFramePayloadSlot(RegisterFile::ArgumentCount));
    1009     m_jit.storePtr(GPRInfo::callFrameRegister, callFrameSlot(RegisterFile::CallerFrame));
    1010     m_jit.storePtr(calleeGPR, callFrameSlot(RegisterFile::Callee));
     1008    m_jit.store32(MacroAssembler::TrustedImm32(numPassedArgs + dummyThisArgument), callFramePayloadSlot(JSStack::ArgumentCount));
     1009    m_jit.storePtr(GPRInfo::callFrameRegister, callFrameSlot(JSStack::CallerFrame));
     1010    m_jit.storePtr(calleeGPR, callFrameSlot(JSStack::Callee));
    10111011   
    10121012    for (int i = 0; i < numPassedArgs; i++) {
    … …  
    10341034    slowPath = m_jit.branchPtrWithPatch(MacroAssembler::NotEqual, calleeGPR, targetToCheck, MacroAssembler::TrustedImmPtr(JSValue::encode(JSValue())));
    10351035    m_jit.loadPtr(MacroAssembler::Address(calleeGPR, OBJECT_OFFSETOF(JSFunction, m_scope)), resultGPR);
    1036     m_jit.storePtr(resultGPR, MacroAssembler::Address(GPRInfo::callFrameRegister, static_cast<ptrdiff_t>(sizeof(Register)) * RegisterFile::ScopeChain));
     1036    m_jit.storePtr(resultGPR, MacroAssembler::Address(GPRInfo::callFrameRegister, static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ScopeChain));
    10371037
    10381038    CodeOrigin codeOrigin = at(m_compileIndex).codeOrigin;
    … …  
    22032203        // as a speculation point. So before we speculate make sure that we
    22042204        // know where the child of this node needs to go in the virtual
    2205         // register file.
     2205        // stack.
    22062206        compileMovHint(node);
    22072207       
    … …  
    22322232        // fine, because this SetLocal's local (i.e. the LHS in a x = y++
    22332233        // statement) would be dead anyway - so the fact that DFG would have
    2234         // already made the assignment, and baked it into the register file during
     2234        // already made the assignment, and baked it into the stack during
    22352235        // OSR exit, would not be visible to the old JIT in any way.
    22362236        m_codeOriginForOSR = nextNode->codeOrigin;
    … …  
    22422242                noResult(m_compileIndex);
    22432243                // Indicate that it's no longer necessary to retrieve the value of
    2244                 // this bytecode variable from registers or other locations in the register file,
     2244                // this bytecode variable from registers or other locations in the stack,
    22452245                // but that it is stored as a double.
    2246                 recordSetLocal(node.local(), ValueSource(DoubleInRegisterFile));
     2246                recordSetLocal(node.local(), ValueSource(DoubleInJSStack));
    22472247                break;
    22482248            }
    … …  
    22532253                m_jit.store32(value.gpr(), JITCompiler::payloadFor(node.local()));
    22542254                noResult(m_compileIndex);
    2255                 recordSetLocal(node.local(), ValueSource(Int32InRegisterFile));
     2255                recordSetLocal(node.local(), ValueSource(Int32InJSStack));
    22562256                break;
    22572257            }
    … …  
    22612261                m_jit.storePtr(cellGPR, JITCompiler::addressFor(node.local()));
    22622262                noResult(m_compileIndex);
    2263                 recordSetLocal(node.local(), ValueSource(CellInRegisterFile));
     2263                recordSetLocal(node.local(), ValueSource(CellInJSStack));
    22642264                break;
    22652265            }
    … …  
    22682268                m_jit.storePtr(boolean.gpr(), JITCompiler::addressFor(node.local()));
    22692269                noResult(m_compileIndex);
    2270                 recordSetLocal(node.local(), ValueSource(BooleanInRegisterFile));
     2270                recordSetLocal(node.local(), ValueSource(BooleanInJSStack));
    22712271                break;
    22722272            }
    … …  
    22772277        noResult(m_compileIndex);
    22782278
    2279         recordSetLocal(node.local(), ValueSource(ValueInRegisterFile));
     2279        recordSetLocal(node.local(), ValueSource(ValueInJSStack));
    22802280
    22812281        // If we're storing an arguments object that has been optimized away,
    … …  
    30883088
    30893089        // Grab the return address.
    3090         m_jit.emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, GPRInfo::regT1);
     3090        m_jit.emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, GPRInfo::regT1);
    30913091        // Restore our caller's "r".
    3092         m_jit.emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, GPRInfo::callFrameRegister);
     3092        m_jit.emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, GPRInfo::callFrameRegister);
    30933093        // Return.
    30943094        m_jit.restoreReturnAddressBeforeReturn(GPRInfo::regT1);
    … …  
    33763376    case GetCallee: {
    33773377        GPRTemporary result(this);
    3378         m_jit.loadPtr(JITCompiler::addressFor(static_cast<VirtualRegister>(RegisterFile::Callee)), result.gpr());
     3378        m_jit.loadPtr(JITCompiler::addressFor(static_cast<VirtualRegister>(JSStack::Callee)), result.gpr());
    33793379        cellResult(result.gpr(), m_compileIndex);
    33803380        break;
    … …  
    33853385        GPRReg resultGPR = result.gpr();
    33863386
    3387         m_jit.loadPtr(JITCompiler::addressFor(static_cast<VirtualRegister>(RegisterFile::ScopeChain)), resultGPR);
     3387        m_jit.loadPtr(JITCompiler::addressFor(static_cast<VirtualRegister>(JSStack::ScopeChain)), resultGPR);
    33883388        bool checkTopLevel = m_jit.codeBlock()->codeType() == FunctionCode && m_jit.codeBlock()->needsFullScopeChain();
    33893389        int skip = node.scopeChainDepth();
    … …  
    41074107       
    41084108        ASSERT(!node.codeOrigin.inlineCallFrame);
    4109         m_jit.load32(JITCompiler::payloadFor(RegisterFile::ArgumentCount), resultGPR);
     4109        m_jit.load32(JITCompiler::payloadFor(JSStack::ArgumentCount), resultGPR);
    41104110        m_jit.sub32(TrustedImm32(1), resultGPR);
    41114111        integerResult(resultGPR, m_compileIndex);
    … …  
    41304130                resultGPR);
    41314131        } else {
    4132             m_jit.load32(JITCompiler::payloadFor(RegisterFile::ArgumentCount), resultGPR);
     4132            m_jit.load32(JITCompiler::payloadFor(JSStack::ArgumentCount), resultGPR);
    41334133            m_jit.sub32(TrustedImm32(1), resultGPR);
    41344134            m_jit.orPtr(GPRInfo::tagTypeNumberRegister, resultGPR);
    … …  
    41794179                    JITCompiler::AboveOrEqual,
    41804180                    resultGPR,
    4181                     JITCompiler::payloadFor(RegisterFile::ArgumentCount)));
     4181                    JITCompiler::payloadFor(JSStack::ArgumentCount)));
    41824182        }
    41834183
    … …  
    42444244                    JITCompiler::AboveOrEqual,
    42454245                    resultGPR,
    4246                     JITCompiler::payloadFor(RegisterFile::ArgumentCount)));
     4246                    JITCompiler::payloadFor(JSStack::ArgumentCount)));
    42474247        }
    42484248       

  • trunk/Source/JavaScriptCore/dfg/DFGThunks.cpp

    r127625 r130726  
    114114        CCallHelpers::Address(
    115115            GPRInfo::callFrameRegister,
    116             static_cast<ptrdiff_t>(sizeof(Register)) * RegisterFile::CallerFrame),
     116            static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::CallerFrame),
    117117        GPRInfo::callFrameRegister);
    118118    jit.peek(GPRInfo::nonPreservedNonReturnGPR, JITSTACKFRAME_ARGS_INDEX);
    … …  
    137137        CCallHelpers::Address(
    138138            GPRInfo::callFrameRegister,
    139             static_cast<ptrdiff_t>(sizeof(Register)) * RegisterFile::ReturnPC));
     139            static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ReturnPC));
    140140    jit.storePtr(GPRInfo::callFrameRegister, &globalData->topCallFrame);
    141141    jit.poke(GPRInfo::nonPreservedNonReturnGPR, JITSTACKFRAME_ARGS_INDEX);
    … …  
    152152        CCallHelpers::Address(
    153153            GPRInfo::callFrameRegister,
    154             static_cast<ptrdiff_t>(sizeof(Register)) * RegisterFile::ReturnPC),
     154            static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ReturnPC),
    155155        GPRInfo::nonPreservedNonReturnGPR);
    156156    jit.storePtr(
    … …  
    158158        CCallHelpers::Address(
    159159            GPRInfo::callFrameRegister,
    160             static_cast<ptrdiff_t>(sizeof(Register)) * RegisterFile::ReturnPC));
     160            static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ReturnPC));
    161161    emitPointerValidation(jit, GPRInfo::nonPreservedNonReturnGPR);
    162162    jit.restoreReturnAddressBeforeReturn(GPRInfo::nonPreservedNonReturnGPR);
    … …  
    250250        CCallHelpers::Address(
    251251            GPRInfo::callFrameRegister,
    252             static_cast<ptrdiff_t>(sizeof(Register)) * RegisterFile::ScopeChain));
     252            static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ScopeChain));
    253253#else
    254254    jit.storePtr(
    … …  
    256256        CCallHelpers::Address(
    257257            GPRInfo::callFrameRegister,
    258             static_cast<ptrdiff_t>(sizeof(Register)) * RegisterFile::ScopeChain +
     258            static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ScopeChain +
    259259            OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)));
    260260    jit.store32(
    … …  
    262262        CCallHelpers::Address(
    263263            GPRInfo::callFrameRegister,
    264             static_cast<ptrdiff_t>(sizeof(Register)) * RegisterFile::ScopeChain +
     264            static_cast<ptrdiff_t>(sizeof(Register)) * JSStack::ScopeChain +
    265265            OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)));
    266266#endif

  • trunk/Source/JavaScriptCore/dfg/DFGValueSource.cpp

    r121717 r130726  
    4040        fprintf(out, "IsDead");
    4141        break;
    42     case ValueInRegisterFile:
    43         fprintf(out, "InRegFile");
     42    case ValueInJSStack:
     43        fprintf(out, "InStack");
    4444        break;
    45     case Int32InRegisterFile:
     45    case Int32InJSStack:
    4646        fprintf(out, "Int32");
    4747        break;
    48     case CellInRegisterFile:
     48    case CellInJSStack:
    4949        fprintf(out, "Cell");
    5050        break;
    51     case BooleanInRegisterFile:
     51    case BooleanInJSStack:
    5252        fprintf(out, "Bool");
    5353        break;
    54     case DoubleInRegisterFile:
     54    case DoubleInJSStack:
    5555        fprintf(out, "Double");
    5656        break;

  • trunk/Source/JavaScriptCore/dfg/DFGValueSource.h

    r123169 r130726  
    4040enum ValueSourceKind {
    4141    SourceNotSet,
    42     ValueInRegisterFile,
    43     Int32InRegisterFile,
    44     CellInRegisterFile,
    45     BooleanInRegisterFile,
    46     DoubleInRegisterFile,
     42    ValueInJSStack,
     43    Int32InJSStack,
     44    CellInJSStack,
     45    BooleanInJSStack,
     46    DoubleInJSStack,
    4747    ArgumentsSource,
    4848    SourceIsDead,
    … …  
    5454    switch (dataFormat) {
    5555    case DataFormatInteger:
    56         return Int32InRegisterFile;
     56        return Int32InJSStack;
    5757    case DataFormatDouble:
    58         return DoubleInRegisterFile;
     58        return DoubleInJSStack;
    5959    case DataFormatBoolean:
    60         return BooleanInRegisterFile;
     60        return BooleanInJSStack;
    6161    case DataFormatCell:
    62         return CellInRegisterFile;
     62        return CellInJSStack;
    6363    case DataFormatDead:
    6464        return SourceIsDead;
    … …  
    6767    default:
    6868        ASSERT(dataFormat & DataFormatJS);
    69         return ValueInRegisterFile;
     69        return ValueInJSStack;
    7070    }
    7171}
    … …  
    7474{
    7575    switch (kind) {
    76     case ValueInRegisterFile:
     76    case ValueInJSStack:
    7777        return DataFormatJS;
    78     case Int32InRegisterFile:
     78    case Int32InJSStack:
    7979        return DataFormatInteger;
    80     case CellInRegisterFile:
     80    case CellInJSStack:
    8181        return DataFormatCell;
    82     case BooleanInRegisterFile:
     82    case BooleanInJSStack:
    8383        return DataFormatBoolean;
    84     case DoubleInRegisterFile:
     84    case DoubleInJSStack:
    8585        return DataFormatDouble;
    8686    case ArgumentsSource:
    … …  
    9393}
    9494
    95 static inline bool isInRegisterFile(ValueSourceKind kind)
     95static inline bool isInJSStack(ValueSourceKind kind)
    9696{
    9797    DataFormat format = valueSourceKindToDataFormat(kind);
    … …  
    130130    {
    131131        if (isInt32Speculation(prediction))
    132             return ValueSource(Int32InRegisterFile);
     132            return ValueSource(Int32InJSStack);
    133133        if (isArraySpeculation(prediction) || isCellSpeculation(prediction))
    134             return ValueSource(CellInRegisterFile);
     134            return ValueSource(CellInJSStack);
    135135        if (isBooleanSpeculation(prediction))
    136             return ValueSource(BooleanInRegisterFile);
    137         return ValueSource(ValueInRegisterFile);
     136            return ValueSource(BooleanInJSStack);
     137        return ValueSource(ValueInJSStack);
    138138    }
    139139   
    … …  
    153153    }
    154154   
    155     bool isInRegisterFile() const { return JSC::DFG::isInRegisterFile(kind()); }
     155    bool isInJSStack() const { return JSC::DFG::isInJSStack(kind()); }
    156156    bool isTriviallyRecoverable() const { return JSC::DFG::isTriviallyRecoverable(kind()); }
    157157   
    … …  
    165165        ASSERT(isTriviallyRecoverable());
    166166        switch (kind()) {
    167         case ValueInRegisterFile:
    168             return ValueRecovery::alreadyInRegisterFile();
    169            
    170         case Int32InRegisterFile:
    171             return ValueRecovery::alreadyInRegisterFileAsUnboxedInt32();
    172            
    173         case CellInRegisterFile:
    174             return ValueRecovery::alreadyInRegisterFileAsUnboxedCell();
    175            
    176         case BooleanInRegisterFile:
    177             return ValueRecovery::alreadyInRegisterFileAsUnboxedBoolean();
    178            
    179         case DoubleInRegisterFile:
    180             return ValueRecovery::alreadyInRegisterFileAsUnboxedDouble();
     167        case ValueInJSStack:
     168            return ValueRecovery::alreadyInJSStack();
     169           
     170        case Int32InJSStack:
     171            return ValueRecovery::alreadyInJSStackAsUnboxedInt32();
     172           
     173        case CellInJSStack:
     174            return ValueRecovery::alreadyInJSStackAsUnboxedCell();
     175           
     176        case BooleanInJSStack:
     177            return ValueRecovery::alreadyInJSStackAsUnboxedBoolean();
     178           
     179        case DoubleInJSStack:
     180            return ValueRecovery::alreadyInJSStackAsUnboxedDouble();
    181181           
    182182        case SourceIsDead:

  • trunk/Source/JavaScriptCore/dfg/DFGVariableEventStream.cpp

    r122541 r130726  
    9494        valueRecoveries = Operands<ValueRecovery>(codeBlock->numParameters(), numVariables);
    9595        for (size_t i = 0; i < valueRecoveries.size(); ++i)
    96             valueRecoveries[i] = ValueRecovery::alreadyInRegisterFile();
     96            valueRecoveries[i] = ValueRecovery::alreadyInJSStack();
    9797        return;
    9898    }
    … …  
    281281       
    282282        valueRecoveries[i] =
    283             ValueRecovery::displacedInRegisterFile(static_cast<VirtualRegister>(info->u.virtualReg), info->format);
     283            ValueRecovery::displacedInJSStack(static_cast<VirtualRegister>(info->u.virtualReg), info->format);
    284284    }
    285285}

  • trunk/Source/JavaScriptCore/heap/Heap.cpp

    r130612 r130726  
    396396}
    397397
    398 inline RegisterFile& Heap::registerFile()
    399 {
    400     return m_globalData->interpreter->registerFile();
     398inline JSStack& Heap::stack()
     399{
     400    return m_globalData->interpreter->stack();
    401401}
    402402
    … …  
    404404{
    405405    ASSERT(isValidThreadState(m_globalData));
    406     ConservativeRoots registerFileRoots(&m_objectSpace.blocks(), &m_storageSpace);
    407     registerFile().gatherConservativeRoots(registerFileRoots);
    408     size_t registerFileRootCount = registerFileRoots.size();
    409     JSCell** registerRoots = registerFileRoots.roots();
    410     for (size_t i = 0; i < registerFileRootCount; i++) {
     406    ConservativeRoots stackRoots(&m_objectSpace.blocks(), &m_storageSpace);
     407    stack().gatherConservativeRoots(stackRoots);
     408    size_t stackRootCount = stackRoots.size();
     409    JSCell** registerRoots = stackRoots.roots();
     410    for (size_t i = 0; i < stackRootCount; i++) {
    411411        setMarked(registerRoots[i]);
    412412        roots.add(registerRoots[i]);
    … …  
    437437    }
    438438
    439     ConservativeRoots registerFileRoots(&m_objectSpace.blocks(), &m_storageSpace);
     439    ConservativeRoots stackRoots(&m_objectSpace.blocks(), &m_storageSpace);
    440440    m_dfgCodeBlocks.clearMarks();
    441441    {
    442         GCPHASE(GatherRegisterFileRoots);
    443         registerFile().gatherConservativeRoots(
    444             registerFileRoots, m_jitStubRoutines, m_dfgCodeBlocks);
     442        GCPHASE(GatherStackRoots);
     443        stack().gatherConservativeRoots(
     444            stackRoots, m_jitStubRoutines, m_dfgCodeBlocks);
    445445    }
    446446
    … …  
    497497        }
    498498        {
    499             GCPHASE(VisitRegisterFileRoots);
    500             MARK_LOG_ROOT(visitor, "Register File");
    501             visitor.append(registerFileRoots);
     499            GCPHASE(VisitStackRoots);
     500            MARK_LOG_ROOT(visitor, "Stack");
     501            visitor.append(stackRoots);
    502502            visitor.donateAndDrain();
    503503        }

  • trunk/Source/JavaScriptCore/heap/Heap.h

    r130612 r130726  
    5656    class JSCell;
    5757    class JSGlobalData;
     58    class JSStack;
    5859    class JSValue;
    5960    class LiveObjectIterator;
    6061    class LLIntOffsetsExtractor;
    6162    class MarkedArgumentBuffer;
    62     class RegisterFile;
    6363    class WeakGCHandlePool;
    6464    class SlotVisitor;
    … …  
    211211        void markDeadObjects();
    212212
    213         RegisterFile& registerFile();
     213        JSStack& stack();
    214214        BlockAllocator& blockAllocator();
    215215

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

    r127202 r130726  
    4444}
    4545
    46 RegisterFile* CallFrame::registerFile()
    47 {
    48     return &interpreter()->registerFile();
     46JSStack* CallFrame::stack()
     47{
     48    return &interpreter()->stack();
    4949}
    5050

  • trunk/Source/JavaScriptCore/interpreter/CallFrame.h

    r129827 r130726  
    2626#include "AbstractPC.h"
    2727#include "JSGlobalData.h"
     28#include "JSStack.h"
    2829#include "MacroAssemblerCodeRef.h"
    29 #include "RegisterFile.h"
    3030
    3131namespace JSC  {
    … …  
    4040    class ExecState : private Register {
    4141    public:
    42         JSValue calleeAsValue() const { return this[RegisterFile::Callee].jsValue(); }
    43         JSObject* callee() const { return this[RegisterFile::Callee].function(); }
    44         CodeBlock* codeBlock() const { return this[RegisterFile::CodeBlock].Register::codeBlock(); }
     42        JSValue calleeAsValue() const { return this[JSStack::Callee].jsValue(); }
     43        JSObject* callee() const { return this[JSStack::Callee].function(); }
     44        CodeBlock* codeBlock() const { return this[JSStack::CodeBlock].Register::codeBlock(); }
    4545        JSScope* scope() const
    4646        {
    47             ASSERT(this[RegisterFile::ScopeChain].Register::scope());
    48             return this[RegisterFile::ScopeChain].Register::scope();
     47            ASSERT(this[JSStack::ScopeChain].Register::scope());
     48            return this[JSStack::ScopeChain].Register::scope();
    4949        }
    5050
    … …  
    103103        CallFrame& operator=(const Register& r) { *static_cast<Register*>(this) = r; return *this; }
    104104
    105         CallFrame* callerFrame() const { return this[RegisterFile::CallerFrame].callFrame(); }
     105        CallFrame* callerFrame() const { return this[JSStack::CallerFrame].callFrame(); }
    106106#if ENABLE(JIT) || ENABLE(LLINT)
    107         ReturnAddressPtr returnPC() const { return ReturnAddressPtr(this[RegisterFile::ReturnPC].vPC()); }
    108         bool hasReturnPC() const { return !!this[RegisterFile::ReturnPC].vPC(); }
    109         void clearReturnPC() { registers()[RegisterFile::ReturnPC] = static_cast<Instruction*>(0); }
     107        ReturnAddressPtr returnPC() const { return ReturnAddressPtr(this[JSStack::ReturnPC].vPC()); }
     108        bool hasReturnPC() const { return !!this[JSStack::ReturnPC].vPC(); }
     109        void clearReturnPC() { registers()[JSStack::ReturnPC] = static_cast<Instruction*>(0); }
    110110#endif
    111111        AbstractPC abstractReturnPC(JSGlobalData& globalData) { return AbstractPC(globalData, this); }
    … …  
    117117        {
    118118            ASSERT(codeBlock());
    119             return this[RegisterFile::ArgumentCount].tag();
     119            return this[JSStack::ArgumentCount].tag();
    120120        }
    121121       
    … …  
    123123        {
    124124            ASSERT(codeBlock());
    125             this[RegisterFile::ArgumentCount].tag() = static_cast<int32_t>(offset);
     125            this[JSStack::ArgumentCount].tag() = static_cast<int32_t>(offset);
    126126        }
    127127#endif
    … …  
    137137   
    138138#if ENABLE(DFG_JIT)
    139         InlineCallFrame* inlineCallFrame() const { return this[RegisterFile::ReturnPC].asInlineCallFrame(); }
    140         unsigned codeOriginIndexForDFG() const { return this[RegisterFile::ArgumentCount].tag(); }
     139        InlineCallFrame* inlineCallFrame() const { return this[JSStack::ReturnPC].asInlineCallFrame(); }
     140        unsigned codeOriginIndexForDFG() const { return this[JSStack::ArgumentCount].tag(); }
    141141#else
    142142        // This will never be called if !ENABLE(DFG_JIT) since all calls should be guarded by
    … …  
    152152        Instruction* currentVPC() const
    153153        {
    154             return bitwise_cast<Instruction*>(this[RegisterFile::ArgumentCount].tag());
     154            return bitwise_cast<Instruction*>(this[JSStack::ArgumentCount].tag());
    155155        }
    156156        void setCurrentVPC(Instruction* vpc)
    157157        {
    158             this[RegisterFile::ArgumentCount].tag() = bitwise_cast<int32_t>(vpc);
     158            this[JSStack::ArgumentCount].tag() = bitwise_cast<int32_t>(vpc);
    159159        }
    160160#else
    … …  
    163163#endif
    164164
    165         void setCallerFrame(CallFrame* callerFrame) { static_cast<Register*>(this)[RegisterFile::CallerFrame] = callerFrame; }
    166         void setScope(JSScope* scope) { static_cast<Register*>(this)[RegisterFile::ScopeChain] = scope; }
     165        void setCallerFrame(CallFrame* callerFrame) { static_cast<Register*>(this)[JSStack::CallerFrame] = callerFrame; }
     166        void setScope(JSScope* scope) { static_cast<Register*>(this)[JSStack::ScopeChain] = scope; }
    167167
    168168        ALWAYS_INLINE void init(CodeBlock* codeBlock, Instruction* vPC, JSScope* scope,
    … …  
    170170        {
    171171            ASSERT(callerFrame); // Use noCaller() rather than 0 for the outer host call frame caller.
    172             ASSERT(callerFrame == noCaller() || callerFrame->removeHostCallFrameFlag()->registerFile()->end() >= this);
     172            ASSERT(callerFrame == noCaller() || callerFrame->removeHostCallFrameFlag()->stack()->end() >= this);
    173173
    174174            setCodeBlock(codeBlock);
    … …  
    187187        // Access to arguments as passed. (After capture, arguments may move to a different location.)
    188188        size_t argumentCount() const { return argumentCountIncludingThis() - 1; }
    189         size_t argumentCountIncludingThis() const { return this[RegisterFile::ArgumentCount].payload(); }
     189        size_t argumentCountIncludingThis() const { return this[JSStack::ArgumentCount].payload(); }
    190190        static int argumentOffset(int argument) { return s_firstArgumentOffset - argument; }
    191191        static int argumentOffsetIncludingThis(int argument) { return s_thisArgumentOffset - argument; }
    … …  
    217217        JSValue argumentAfterCapture(size_t argument);
    218218
    219         static int offsetFor(size_t argumentCountIncludingThis) { return argumentCountIncludingThis + RegisterFile::CallFrameHeaderSize; }
     219        static int offsetFor(size_t argumentCountIncludingThis) { return argumentCountIncludingThis + JSStack::CallFrameHeaderSize; }
    220220
    221221        // FIXME: Remove these.
    … …  
    229229        CallFrame* removeHostCallFrameFlag() { return reinterpret_cast<CallFrame*>(reinterpret_cast<intptr_t>(this) & ~HostCallFrameFlag); }
    230230
    231         void setArgumentCountIncludingThis(int count) { static_cast<Register*>(this)[RegisterFile::ArgumentCount].payload() = count; }
    232         void setCallee(JSObject* callee) { static_cast<Register*>(this)[RegisterFile::Callee] = Register::withCallee(callee); }
    233         void setCodeBlock(CodeBlock* codeBlock) { static_cast<Register*>(this)[RegisterFile::CodeBlock] = codeBlock; }
    234         void setReturnPC(void* value) { static_cast<Register*>(this)[RegisterFile::ReturnPC] = (Instruction*)value; }
     231        void setArgumentCountIncludingThis(int count) { static_cast<Register*>(this)[JSStack::ArgumentCount].payload() = count; }
     232        void setCallee(JSObject* callee) { static_cast<Register*>(this)[JSStack::Callee] = Register::withCallee(callee); }
     233        void setCodeBlock(CodeBlock* codeBlock) { static_cast<Register*>(this)[JSStack::CodeBlock] = codeBlock; }
     234        void setReturnPC(void* value) { static_cast<Register*>(this)[JSStack::ReturnPC] = (Instruction*)value; }
    235235       
    236236#if ENABLE(DFG_JIT)
    237237        bool isInlineCallFrame();
    238238       
    239         void setInlineCallFrame(InlineCallFrame* inlineCallFrame) { static_cast<Register*>(this)[RegisterFile::ReturnPC] = inlineCallFrame; }
     239        void setInlineCallFrame(InlineCallFrame* inlineCallFrame) { static_cast<Register*>(this)[JSStack::ReturnPC] = inlineCallFrame; }
    240240       
    241241        // Call this to get the semantically correct JS CallFrame* for the
    … …  
    270270    private:
    271271        static const intptr_t HostCallFrameFlag = 1;
    272         static const int s_thisArgumentOffset = -1 - RegisterFile::CallFrameHeaderSize;
     272        static const int s_thisArgumentOffset = -1 - JSStack::CallFrameHeaderSize;
    273273        static const int s_firstArgumentOffset = s_thisArgumentOffset - 1;
    274274
    275275#ifndef NDEBUG
    276         RegisterFile* registerFile();
     276        JSStack* stack();
    277277#endif
    278278#if ENABLE(DFG_JIT)

  • 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}

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

    r129453 r130726  
    3636#include "JSValue.h"
    3737#include "JSObject.h"
     38#include "JSStack.h"
    3839#include "LLIntData.h"
    3940#include "Opcode.h"
    40 #include "RegisterFile.h"
    4141
    4242#include <wtf/HashMap.h>
    … …  
    190190        void initialize(bool canUseJIT);
    191191
    192         RegisterFile& registerFile() { return m_registerFile; }
     192        JSStack& stack() { return m_stack; }
    193193       
    194194        Opcode getOpcode(OpcodeID id)
    … …  
    250250        NEVER_INLINE bool unwindCallFrame(CallFrame*&, JSValue, unsigned& bytecodeOffset, CodeBlock*&);
    251251
    252         static ALWAYS_INLINE CallFrame* slideRegisterWindowForCall(CodeBlock*, RegisterFile*, CallFrame*, size_t registerOffset, int argc);
     252        static ALWAYS_INLINE CallFrame* slideRegisterWindowForCall(CodeBlock*, JSStack*, CallFrame*, size_t registerOffset, int argc);
    253253
    254254        static CallFrame* findFunctionCallFrameFromVMCode(CallFrame*, JSFunction*);
    255 
    256 #if !ENABLE(LLINT_C_LOOP)
    257         JSValue privateExecute(ExecutionFlag, RegisterFile*, CallFrame*);
    258 #endif
    259255
    260256        void dumpRegisters(CallFrame*);
    … …  
    268264        int m_reentryDepth;
    269265
    270         RegisterFile m_registerFile;
     266        JSStack m_stack;
    271267       
    272268#if ENABLE(COMPUTED_GOTO_OPCODES) && ENABLE(LLINT)
    … …  
    288284    inline JSValue Interpreter::execute(EvalExecutable* eval, CallFrame* callFrame, JSValue thisValue, JSScope* scope)
    289285    {
    290         return execute(eval, callFrame, thisValue, scope, m_registerFile.size() + 1 + RegisterFile::CallFrameHeaderSize);
     286        return execute(eval, callFrame, thisValue, scope, m_stack.size() + 1 + JSStack::CallFrameHeaderSize);
    291287    }
    292288
    293289    JSValue eval(CallFrame*);
    294     CallFrame* loadVarargs(CallFrame*, RegisterFile*, JSValue thisValue, JSValue arguments, int firstFreeRegister);
     290    CallFrame* loadVarargs(CallFrame*, JSStack*, JSValue thisValue, JSValue arguments, int firstFreeRegister);
    295291
    296292} // namespace JSC

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

    r130715 r130726  
    2828
    2929#include "config.h"
    30 #include "RegisterFile.h"
     30#include "JSStack.h"
    3131
    3232#include "ConservativeRoots.h"
    … …  
    3737static size_t committedBytesCount = 0;
    3838
    39 static Mutex& registerFileStatisticsMutex()
     39static Mutex& stackStatisticsMutex()
    4040{
    4141    DEFINE_STATIC_LOCAL(Mutex, staticMutex, ());
    … …  
    4343}   
    4444   
    45 RegisterFile::~RegisterFile()
     45JSStack::~JSStack()
    4646{
    4747    void* base = m_reservation.base();
    … …  
    5151}
    5252
    53 bool RegisterFile::growSlowCase(Register* newEnd)
     53bool JSStack::growSlowCase(Register* newEnd)
    5454{
    5555    if (newEnd <= m_commitEnd) {
    … …  
    6969}
    7070
    71 void RegisterFile::gatherConservativeRoots(ConservativeRoots& conservativeRoots)
     71void JSStack::gatherConservativeRoots(ConservativeRoots& conservativeRoots)
    7272{
    7373    conservativeRoots.add(begin(), end());
    7474}
    7575
    76 void RegisterFile::gatherConservativeRoots(ConservativeRoots& conservativeRoots, JITStubRoutineSet& jitStubRoutines, DFGCodeBlocks& dfgCodeBlocks)
     76void JSStack::gatherConservativeRoots(ConservativeRoots& conservativeRoots, JITStubRoutineSet& jitStubRoutines, DFGCodeBlocks& dfgCodeBlocks)
    7777{
    7878    conservativeRoots.add(begin(), end(), jitStubRoutines, dfgCodeBlocks);
    7979}
    8080
    81 void RegisterFile::releaseExcessCapacity()
     81void JSStack::releaseExcessCapacity()
    8282{
    8383    ptrdiff_t delta = reinterpret_cast<uintptr_t>(m_commitEnd) - reinterpret_cast<uintptr_t>(m_reservation.base());
    … …  
    8787}
    8888
    89 void RegisterFile::initializeThreading()
     89void JSStack::initializeThreading()
    9090{
    91     registerFileStatisticsMutex();
     91    stackStatisticsMutex();
    9292}
    9393
    94 size_t RegisterFile::committedByteCount()
     94size_t JSStack::committedByteCount()
    9595{
    96     MutexLocker locker(registerFileStatisticsMutex());
     96    MutexLocker locker(stackStatisticsMutex());
    9797    return committedBytesCount;
    9898}
    9999
    100 void RegisterFile::addToCommittedByteCount(long byteCount)
     100void JSStack::addToCommittedByteCount(long byteCount)
    101101{
    102     MutexLocker locker(registerFileStatisticsMutex());
     102    MutexLocker locker(stackStatisticsMutex());
    103103    ASSERT(static_cast<long>(committedBytesCount) + byteCount > -1);
    104104    committedBytesCount += byteCount;

  • trunk/Source/JavaScriptCore/interpreter/JSStack.h

    r130715 r130726  
    2727 */
    2828
    29 #ifndef RegisterFile_h
    30 #define RegisterFile_h
     29#ifndef JSStack_h
     30#define JSStack_h
    3131
    3232#include "ExecutableAllocator.h"
    … …  
    4343    class LLIntOffsetsExtractor;
    4444
    45     class RegisterFile {
    46         WTF_MAKE_NONCOPYABLE(RegisterFile);
     45    class JSStack {
     46        WTF_MAKE_NONCOPYABLE(JSStack);
    4747    public:
    4848        enum CallFrameHeaderEntry {
    … …  
    5959        static const size_t defaultCapacity = 512 * 1024;
    6060        static const size_t commitSize = 16 * 1024;
    61         // Allow 8k of excess registers before we start trying to reap the registerfile
     61        // Allow 8k of excess registers before we start trying to reap the stack
    6262        static const ptrdiff_t maxExcessCapacity = 8 * 1024;
    6363
    64         RegisterFile(size_t capacity = defaultCapacity);
    65         ~RegisterFile();
     64        JSStack(size_t capacity = defaultCapacity);
     65        ~JSStack();
    6666       
    6767        void gatherConservativeRoots(ConservativeRoots&);
    … …  
    8585    private:
    8686        friend class LLIntOffsetsExtractor;
    87        
     87
    8888        bool growSlowCase(Register*);
    8989        void releaseExcessCapacity();
    … …  
    9494    };
    9595
    96     inline RegisterFile::RegisterFile(size_t capacity)
     96    inline JSStack::JSStack(size_t capacity)
    9797        : m_end(0)
    9898    {
    … …  
    104104    }
    105105
    106     inline void RegisterFile::shrink(Register* newEnd)
     106    inline void JSStack::shrink(Register* newEnd)
    107107    {
    108108        if (newEnd >= m_end)
    … …  
    113113    }
    114114
    115     inline bool RegisterFile::grow(Register* newEnd)
     115    inline bool JSStack::grow(Register* newEnd)
    116116    {
    117117        if (newEnd <= m_end)
    … …  
    122122} // namespace JSC
    123123
    124 #endif // RegisterFile_h
     124#endif // JSStack_h

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

    r126228 r130726  
    7070
    7171    printf("frame [%d] %p { cb %p:%s, retPC %p:%s, scope %p:%s, callee %p:%s, callerFrame %p:%s, argc %d, vPC %p }",
    72            frameCount, frame,
    73 
    74            CAST<void*>(frame[RegisterFile::CodeBlock].payload()),
    75            getTypeName(frame[RegisterFile::CodeBlock].jsValue()),
    76 
    77            CAST<void*>(frame[RegisterFile::ReturnPC].payload()),
    78            getTypeName(frame[RegisterFile::ReturnPC].jsValue()),
    79 
    80            CAST<void*>(frame[RegisterFile::ScopeChain].payload()),
    81            getTypeName(frame[RegisterFile::ScopeChain].jsValue()),
    82 
    83            CAST<void*>(frame[RegisterFile::Callee].payload()),
    84            getTypeName(frame[RegisterFile::Callee].jsValue()),
    85 
    86            CAST<void*>(frame[RegisterFile::CallerFrame].payload()),
    87            getTypeName(frame[RegisterFile::CallerFrame].jsValue()),
    88 
    89            frame[RegisterFile::ArgumentCount].payload(),
    90            vPC);
     72        frameCount, frame,
     73        CAST<void*>(frame[JSStack::CodeBlock].payload()),
     74        getTypeName(frame[JSStack::CodeBlock].jsValue()),
     75        CAST<void*>(frame[JSStack::ReturnPC].payload()),
     76        getTypeName(frame[JSStack::ReturnPC].jsValue()),
     77        CAST<void*>(frame[JSStack::ScopeChain].payload()),
     78        getTypeName(frame[JSStack::ScopeChain].jsValue()),
     79        CAST<void*>(frame[JSStack::Callee].payload()),
     80        getTypeName(frame[JSStack::Callee].jsValue()),
     81        CAST<void*>(frame[JSStack::CallerFrame].callFrame()),
     82        getTypeName(frame[JSStack::CallerFrame].jsValue()),
     83        frame[JSStack::ArgumentCount].payload(),
     84        vPC);
    9185
    9286    if (funcName || file || (line >= 0)) {

  • trunk/Source/JavaScriptCore/jit/JIT.cpp

    r130612 r130726  
    7979    , m_jumpTargetIndex(0)
    8080    , m_mappedBytecodeOffset((unsigned)-1)
    81     , m_mappedVirtualRegisterIndex(RegisterFile::ReturnPC)
     81    , m_mappedVirtualRegisterIndex(JSStack::ReturnPC)
    8282    , m_mappedTag((RegisterID)-1)
    8383    , m_mappedPayload((RegisterID)-1)
    … …  
    607607
    608608    preserveReturnAddressAfterCall(regT2);
    609     emitPutToCallFrameHeader(regT2, RegisterFile::ReturnPC);
    610     emitPutImmediateToCallFrameHeader(m_codeBlock, RegisterFile::CodeBlock);
     609    emitPutToCallFrameHeader(regT2, JSStack::ReturnPC);
     610    emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
    611611
    612612    Label beginLabel(this);
    … …  
    617617#endif
    618618
    619     Jump registerFileCheck;
     619    Jump stackCheck;
    620620    if (m_codeBlock->codeType() == FunctionCode) {
    621621#if ENABLE(DFG_JIT)
    … …  
    647647
    648648        addPtr(TrustedImm32(m_codeBlock->m_numCalleeRegisters * sizeof(Register)), callFrameRegister, regT1);
    649         registerFileCheck = branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->registerFile().addressOfEnd()), regT1);
     649        stackCheck = branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->stack().addressOfEnd()), regT1);
    650650    }
    651651
    … …  
    663663    Label arityCheck;
    664664    if (m_codeBlock->codeType() == FunctionCode) {
    665         registerFileCheck.link(this);
     665        stackCheck.link(this);
    666666        m_bytecodeOffset = 0;
    667         JITStubCall(this, cti_register_file_check).call();
     667        JITStubCall(this, cti_stack_check).call();
    668668#ifndef NDEBUG
    669669        m_bytecodeOffset = (unsigned)-1; // Reset this, in order to guard its use with ASSERTs.
    … …  
    673673        arityCheck = label();
    674674        preserveReturnAddressAfterCall(regT2);
    675         emitPutToCallFrameHeader(regT2, RegisterFile::ReturnPC);
    676         emitPutImmediateToCallFrameHeader(m_codeBlock, RegisterFile::CodeBlock);
    677 
    678         load32(payloadFor(RegisterFile::ArgumentCount), regT1);
     675        emitPutToCallFrameHeader(regT2, JSStack::ReturnPC);
     676        emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
     677
     678        load32(payloadFor(JSStack::ArgumentCount), regT1);
    679679        branch32(AboveOrEqual, regT1, TrustedImm32(m_codeBlock->m_numParameters)).linkTo(beginLabel, this);
    680680

  • trunk/Source/JavaScriptCore/jit/JIT.h

    r130303 r130726  
    5959    class JSPropertyNameIterator;
    6060    class Interpreter;
     61    class JSScope;
     62    class JSStack;
    6163    class Register;
    62     class RegisterFile;
    63     class JSScope;
    6464    class StructureChain;
    6565
    … …  
    779779        void emitInitRegister(unsigned dst);
    780780
    781         void emitPutToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry);
    782         void emitPutCellToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry);
    783         void emitPutIntToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry);
    784         void emitPutImmediateToCallFrameHeader(void* value, RegisterFile::CallFrameHeaderEntry entry);
    785         void emitGetFromCallFrameHeaderPtr(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from = callFrameRegister);
    786         void emitGetFromCallFrameHeader32(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from = callFrameRegister);
     781        void emitPutToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry);
     782        void emitPutCellToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry);
     783        void emitPutIntToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry);
     784        void emitPutImmediateToCallFrameHeader(void* value, JSStack::CallFrameHeaderEntry);
     785        void emitGetFromCallFrameHeaderPtr(JSStack::CallFrameHeaderEntry, RegisterID to, RegisterID from = callFrameRegister);
     786        void emitGetFromCallFrameHeader32(JSStack::CallFrameHeaderEntry, RegisterID to, RegisterID from = callFrameRegister);
    787787
    788788        JSValue getConstantOperand(unsigned src);

  • trunk/Source/JavaScriptCore/jit/JITCall.cpp

    r129156 r130726  
    7575        slowCase.append(branchPtr(NotEqual, regT0, TrustedImmPtr(JSValue::encode(JSValue()))));
    7676
    77         emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
     77        emitGetFromCallFrameHeader32(JSStack::ArgumentCount, regT0);
    7878        slowCase.append(branch32(Above, regT0, TrustedImm32(Arguments::MaxArguments + 1)));
    7979        // regT0: argumentCountIncludingThis
    8080
    8181        move(regT0, regT1);
    82         add32(TrustedImm32(firstFreeRegister + RegisterFile::CallFrameHeaderSize), regT1);
     82        add32(TrustedImm32(firstFreeRegister + JSStack::CallFrameHeaderSize), regT1);
    8383        lshift32(TrustedImm32(3), regT1);
    8484        addPtr(callFrameRegister, regT1);
    8585        // regT1: newCallFrame
    8686
    87         slowCase.append(branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->registerFile().addressOfEnd()), regT1));
     87        slowCase.append(branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->stack().addressOfEnd()), regT1));
    8888
    8989        // Initialize ArgumentCount.
    90         store32(regT0, Address(regT1, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register)) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)));
     90        store32(regT0, Address(regT1, JSStack::ArgumentCount * static_cast<int>(sizeof(Register)) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)));
    9191
    9292        // Initialize 'this'.
    … …  
    126126    stubCall.call();
    127127    addSlowCase(branchPtr(Equal, regT0, TrustedImmPtr(JSValue::encode(JSValue()))));
    128     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     128    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    129129
    130130    sampleCodeBlock(m_codeBlock);
    … …  
    135135    linkSlowCase(iter);
    136136
    137     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT0);
     137    emitGetFromCallFrameHeaderPtr(JSStack::Callee, regT0);
    138138    emitNakedCall(m_globalData->jitStubs->ctiVirtualCall());
    139139
    … …  
    174174   
    175175        addPtr(TrustedImm32(registerOffset * sizeof(Register)), callFrameRegister, regT1);
    176         store32(TrustedImm32(argCount), Address(regT1, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register)) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)));
     176        store32(TrustedImm32(argCount), Address(regT1, JSStack::ArgumentCount * static_cast<int>(sizeof(Register)) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)));
    177177    } // regT1 holds newCallFrame with ArgumentCount initialized.
    178178   
    179     store32(TrustedImm32(instruction - m_codeBlock->instructions().begin()), Address(callFrameRegister, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register)) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)));
     179    store32(TrustedImm32(instruction - m_codeBlock->instructions().begin()), Address(callFrameRegister, JSStack::ArgumentCount * static_cast<int>(sizeof(Register)) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)));
    180180    emitGetVirtualRegister(callee, regT0); // regT0 holds callee.
    181181
    182     storePtr(callFrameRegister, Address(regT1, RegisterFile::CallerFrame * static_cast<int>(sizeof(Register))));
    183     storePtr(regT0, Address(regT1, RegisterFile::Callee * static_cast<int>(sizeof(Register))));
     182    storePtr(callFrameRegister, Address(regT1, JSStack::CallerFrame * static_cast<int>(sizeof(Register))));
     183    storePtr(regT0, Address(regT1, JSStack::Callee * static_cast<int>(sizeof(Register))));
    184184    move(regT1, callFrameRegister);
    185185
    … …  
    202202
    203203    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scope)), regT1);
    204     emitPutToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     204    emitPutToCallFrameHeader(regT1, JSStack::ScopeChain);
    205205    m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathOther = emitNakedCall();
    206206

  • trunk/Source/JavaScriptCore/jit/JITCall32_64.cpp

    r129156 r130726  
    6060
    6161    emitLoad(dst, regT1, regT0);
    62     emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT2);
    63     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     62    emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT2);
     63    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    6464
    6565    restoreReturnAddressBeforeReturn(regT2);
    … …  
    7777    Jump notObject = emitJumpIfNotObject(regT2);
    7878
    79     emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT2);
    80     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     79    emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT2);
     80    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    8181
    8282    restoreReturnAddressBeforeReturn(regT2);
    … …  
    8787    emitLoad(thisReg, regT1, regT0);
    8888
    89     emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT2);
    90     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     89    emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT2);
     90    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    9191
    9292    restoreReturnAddressBeforeReturn(regT2);
    … …  
    150150        slowCase.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::EmptyValueTag)));
    151151
    152         load32(payloadFor(RegisterFile::ArgumentCount), regT2);
     152        load32(payloadFor(JSStack::ArgumentCount), regT2);
    153153        slowCase.append(branch32(Above, regT2, TrustedImm32(Arguments::MaxArguments + 1)));
    154154        // regT2: argumentCountIncludingThis
    155155
    156156        move(regT2, regT3);
    157         add32(TrustedImm32(firstFreeRegister + RegisterFile::CallFrameHeaderSize), regT3);
     157        add32(TrustedImm32(firstFreeRegister + JSStack::CallFrameHeaderSize), regT3);
    158158        lshift32(TrustedImm32(3), regT3);
    159159        addPtr(callFrameRegister, regT3);
    160160        // regT3: newCallFrame
    161161
    162         slowCase.append(branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->registerFile().addressOfEnd()), regT3));
     162        slowCase.append(branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->stack().addressOfEnd()), regT3));
    163163
    164164        // Initialize ArgumentCount.
    165         store32(regT2, payloadFor(RegisterFile::ArgumentCount, regT3));
     165        store32(regT2, payloadFor(JSStack::ArgumentCount, regT3));
    166166
    167167        // Initialize 'this'.
    … …  
    203203    stubCall.call();
    204204    addSlowCase(branch32(Equal, regT1, TrustedImm32(JSValue::EmptyValueTag)));
    205     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     205    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    206206
    207207    sampleCodeBlock(m_codeBlock);
    … …  
    212212    linkSlowCase(iter);
    213213
    214     emitLoad(RegisterFile::Callee, regT1, regT0);
     214    emitLoad(JSStack::Callee, regT1, regT0);
    215215    emitNakedCall(m_globalData->jitStubs->ctiVirtualCall());
    216216
    … …  
    252252        addPtr(TrustedImm32(registerOffset * sizeof(Register)), callFrameRegister, regT3);
    253253
    254         store32(TrustedImm32(argCount), payloadFor(RegisterFile::ArgumentCount, regT3));
     254        store32(TrustedImm32(argCount), payloadFor(JSStack::ArgumentCount, regT3));
    255255    } // regT3 holds newCallFrame with ArgumentCount initialized.
    256256   
    257     storePtr(TrustedImmPtr(instruction), tagFor(RegisterFile::ArgumentCount, callFrameRegister));
     257    storePtr(TrustedImmPtr(instruction), tagFor(JSStack::ArgumentCount, callFrameRegister));
    258258    emitLoad(callee, regT1, regT0); // regT1, regT0 holds callee.
    259259
    260     storePtr(callFrameRegister, Address(regT3, RegisterFile::CallerFrame * static_cast<int>(sizeof(Register))));
    261     emitStore(RegisterFile::Callee, regT1, regT0, regT3);
     260    storePtr(callFrameRegister, Address(regT3, JSStack::CallerFrame * static_cast<int>(sizeof(Register))));
     261    emitStore(JSStack::Callee, regT1, regT0, regT3);
    262262    move(regT3, callFrameRegister);
    263263
    … …  
    282282
    283283    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scope)), regT1);
    284     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     284    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    285285    m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathOther = emitNakedCall();
    286286

  • trunk/Source/JavaScriptCore/jit/JITCode.h

    r127199 r130726  
    3939#if ENABLE(JIT)
    4040    class JSGlobalData;
    41     class RegisterFile;
     41    class JSStack;
    4242#endif
    4343   
    … …  
    130130#if ENABLE(JIT)
    131131        // Execute the code!
    132         inline JSValue execute(RegisterFile* registerFile, CallFrame* callFrame, JSGlobalData* globalData)
     132        inline JSValue execute(JSStack* stack, CallFrame* callFrame, JSGlobalData* globalData)
    133133        {
    134             JSValue result = JSValue::decode(ctiTrampoline(m_ref.code().executableAddress(), registerFile, callFrame, 0, 0, globalData));
     134            JSValue result = JSValue::decode(ctiTrampoline(m_ref.code().executableAddress(), stack, callFrame, 0, 0, globalData));
    135135            return globalData->exception ? jsNull() : result;
    136136        }

  • trunk/Source/JavaScriptCore/jit/JITInlineMethods.h

    r130303 r130726  
    5151}
    5252
    53 ALWAYS_INLINE void JIT::emitPutToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
     53ALWAYS_INLINE void JIT::emitPutToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry entry)
    5454{
    5555    storePtr(from, payloadFor(entry, callFrameRegister));
    5656}
    5757
    58 ALWAYS_INLINE void JIT::emitPutCellToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
     58ALWAYS_INLINE void JIT::emitPutCellToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry entry)
    5959{
    6060#if USE(JSVALUE32_64)
    … …  
    6464}
    6565
    66 ALWAYS_INLINE void JIT::emitPutIntToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
     66ALWAYS_INLINE void JIT::emitPutIntToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry entry)
    6767{
    6868    store32(TrustedImm32(Int32Tag), intTagFor(entry, callFrameRegister));
    … …  
    7070}
    7171
    72 ALWAYS_INLINE void JIT::emitPutImmediateToCallFrameHeader(void* value, RegisterFile::CallFrameHeaderEntry entry)
     72ALWAYS_INLINE void JIT::emitPutImmediateToCallFrameHeader(void* value, JSStack::CallFrameHeaderEntry entry)
    7373{
    7474    storePtr(TrustedImmPtr(value), Address(callFrameRegister, entry * sizeof(Register)));
    7575}
    7676
    77 ALWAYS_INLINE void JIT::emitGetFromCallFrameHeaderPtr(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from)
     77ALWAYS_INLINE void JIT::emitGetFromCallFrameHeaderPtr(JSStack::CallFrameHeaderEntry entry, RegisterID to, RegisterID from)
    7878{
    7979    loadPtr(Address(from, entry * sizeof(Register)), to);
    … …  
    102102}
    103103
    104 ALWAYS_INLINE void JIT::emitGetFromCallFrameHeader32(RegisterFile::CallFrameHeaderEntry entry, RegisterID to, RegisterID from)
     104ALWAYS_INLINE void JIT::emitGetFromCallFrameHeader32(JSStack::CallFrameHeaderEntry entry, RegisterID to, RegisterID from)
    105105{
    106106    load32(Address(from, entry * sizeof(Register)), to);
    … …  
    266266    if (m_bytecodeOffset) {
    267267#if USE(JSVALUE32_64)
    268         storePtr(TrustedImmPtr(m_codeBlock->instructions().begin() + m_bytecodeOffset + 1), intTagFor(RegisterFile::ArgumentCount));
    269 #else
    270         store32(TrustedImm32(m_bytecodeOffset + 1), intTagFor(RegisterFile::ArgumentCount));
     268        storePtr(TrustedImmPtr(m_codeBlock->instructions().begin() + m_bytecodeOffset + 1), intTagFor(JSStack::ArgumentCount));
     269#else
     270        store32(TrustedImm32(m_bytecodeOffset + 1), intTagFor(JSStack::ArgumentCount));
    271271#endif
    272272    }
    … …  
    758758{
    759759    m_mappedBytecodeOffset = (unsigned)-1;
    760     m_mappedVirtualRegisterIndex = RegisterFile::ReturnPC;
     760    m_mappedVirtualRegisterIndex = JSStack::ReturnPC;
    761761    m_mappedTag = (RegisterID)-1;
    762762    m_mappedPayload = (RegisterID)-1;

  • trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

    r129713 r130726  
    7777    // Finish canonical initialization before JS function call.
    7878    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scope)), regT1);
    79     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     79    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    8080
    8181    // Also initialize ReturnPC for use by lazy linking and exceptions.
    8282    preserveReturnAddressAfterCall(regT3);
    83     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     83    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    8484   
    8585    storePtr(callFrameRegister, &m_globalData->topCallFrame);
    … …  
    9797    // Finish canonical initialization before JS function call.
    9898    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scope)), regT1);
    99     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     99    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    100100
    101101    // Also initialize ReturnPC for use by lazy linking and exeptions.
    102102    preserveReturnAddressAfterCall(regT3);
    103     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     103    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    104104   
    105105    storePtr(callFrameRegister, &m_globalData->topCallFrame);
    … …  
    117117    // Finish canonical initialization before JS function call.
    118118    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scope)), regT1);
    119     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     119    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    120120
    121121    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    … …  
    140140    // Finish canonical initialization before JS function call.
    141141    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scope)), regT1);
    142     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     142    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    143143
    144144    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    … …  
    157157    callSlowCase.link(this);
    158158    // Finish canonical initialization before JS function call.
    159     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    160     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT2, regT2);
    161     emitPutCellToCallFrameHeader(regT2, RegisterFile::ScopeChain);
     159    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT2);
     160    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT2, regT2);
     161    emitPutCellToCallFrameHeader(regT2, JSStack::ScopeChain);
    162162
    163163    // Also initialize ReturnPC and CodeBlock, like a JS function would.
    164164    preserveReturnAddressAfterCall(regT3);
    165     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
    166     emitPutImmediateToCallFrameHeader(0, RegisterFile::CodeBlock);
     165    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
     166    emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
    167167
    168168    storePtr(callFrameRegister, &m_globalData->topCallFrame);
    169169    restoreArgumentReference();
    170170    Call callCallNotJSFunction = call();
    171     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     171    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    172172    restoreReturnAddressBeforeReturn(regT3);
    173173    ret();
    … …  
    175175    constructSlowCase.link(this);
    176176    // Finish canonical initialization before JS function call.
    177     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    178     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT2, regT2);
    179     emitPutCellToCallFrameHeader(regT2, RegisterFile::ScopeChain);
     177    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT2);
     178    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT2, regT2);
     179    emitPutCellToCallFrameHeader(regT2, JSStack::ScopeChain);
    180180
    181181    // Also initialize ReturnPC and CodeBlock, like a JS function would.
    182182    preserveReturnAddressAfterCall(regT3);
    183     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
    184     emitPutImmediateToCallFrameHeader(0, RegisterFile::CodeBlock);
     183    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
     184    emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
    185185
    186186    storePtr(callFrameRegister, &m_globalData->topCallFrame);
    187187    restoreArgumentReference();
    188188    Call callConstructNotJSFunction = call();
    189     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     189    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    190190    restoreReturnAddressBeforeReturn(regT3);
    191191    ret();
    … …  
    232232    Label nativeCallThunk = align();
    233233   
    234     emitPutImmediateToCallFrameHeader(0, RegisterFile::CodeBlock);
     234    emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
    235235    storePtr(callFrameRegister, &m_globalData->topCallFrame);
    236236
    … …  
    238238    // Load caller frame's scope chain into this callframe so that whatever we call can
    239239    // get to its global data.
    240     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    241     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    242     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     240    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT0);
     241    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT0);
     242    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    243243
    244244    peek(regT1);
    245     emitPutToCallFrameHeader(regT1, RegisterFile::ReturnPC);
     245    emitPutToCallFrameHeader(regT1, JSStack::ReturnPC);
    246246
    247247    // Calling convention:      f(edi, esi, edx, ecx, ...);
    … …  
    251251    subPtr(TrustedImm32(16 - sizeof(void*)), stackPointerRegister); // Align stack after call.
    252252
    253     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, X86Registers::esi);
     253    emitGetFromCallFrameHeaderPtr(JSStack::Callee, X86Registers::esi);
    254254    loadPtr(Address(X86Registers::esi, OBJECT_OFFSETOF(JSFunction, m_executable)), X86Registers::r9);
    255255    move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    … …  
    261261    // Load caller frame's scope chain into this callframe so that whatever we call can
    262262    // get to its global data.
    263     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    264     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT2);
    265     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     263    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT2);
     264    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT2);
     265    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    266266
    267267    preserveReturnAddressAfterCall(regT3); // Callee preserved
    268     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     268    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    269269
    270270    // Calling convention:      f(r0 == regT0, r1 == regT1, ...);
    … …  
    272272    move(callFrameRegister, ARMRegisters::r0);
    273273
    274     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, ARMRegisters::r1);
     274    emitGetFromCallFrameHeaderPtr(JSStack::Callee, ARMRegisters::r1);
    275275    move(regT2, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    276276    loadPtr(Address(ARMRegisters::r1, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    … …  
    282282    // Load caller frame's scope chain into this callframe so that whatever we call can
    283283    // get to its global data.
    284     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    285     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    286     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     284    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT0);
     285    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT0);
     286    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    287287
    288288    preserveReturnAddressAfterCall(regT3); // Callee preserved
    289     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     289    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    290290
    291291    // Calling convention:      f(a0, a1, a2, a3);
    … …  
    300300
    301301    // Call
    302     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, MIPSRegisters::a2);
     302    emitGetFromCallFrameHeaderPtr(JSStack::Callee, MIPSRegisters::a2);
    303303    loadPtr(Address(MIPSRegisters::a2, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    304304    move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    … …  
    383383    ASSERT(returnValueRegister != callFrameRegister);
    384384    emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueRegister);
    385     restoreReturnAddressBeforeReturn(Address(callFrameRegister, RegisterFile::ReturnPC * static_cast<int>(sizeof(Register))));
     385    restoreReturnAddressBeforeReturn(Address(callFrameRegister, JSStack::ReturnPC * static_cast<int>(sizeof(Register))));
    386386    ret();
    387387}
    … …  
    584584
    585585    // Grab the return address.
    586     emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
     586    emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT1);
    587587
    588588    // Restore our caller's "r".
    589     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     589    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    590590
    591591    // Return.
    … …  
    607607
    608608    // Grab the return address.
    609     emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
     609    emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT1);
    610610
    611611    // Restore our caller's "r".
    612     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     612    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    613613
    614614    // Return.
    … …  
    622622
    623623    // Grab the return address.
    624     emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
     624    emitGetFromCallFrameHeaderPtr(JSStack::ReturnPC, regT1);
    625625
    626626    // Restore our caller's "r".
    627     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     627    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    628628
    629629    // Return.
    … …  
    12861286void JIT::emit_op_create_this(Instruction* currentInstruction)
    12871287{
    1288     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT0);
     1288    emitGetFromCallFrameHeaderPtr(JSStack::Callee, regT0);
    12891289    loadPtr(Address(regT0, JSFunction::offsetOfCachedInheritorID()), regT2);
    12901290    addSlowCase(branchTestPtr(Zero, regT2));
    … …  
    15101510    int argumentsRegister = currentInstruction[2].u.operand;
    15111511    addSlowCase(branchTestPtr(NonZero, addressFor(argumentsRegister)));
    1512     emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT0);
     1512    emitGetFromCallFrameHeader32(JSStack::ArgumentCount, regT0);
    15131513    sub32(TrustedImm32(1), regT0);
    15141514    emitFastArithReTagImmediate(regT0, regT0);
    … …  
    15401540    add32(TrustedImm32(1), regT1);
    15411541    // regT1 now contains the integer index of the argument we want, including this
    1542     emitGetFromCallFrameHeader32(RegisterFile::ArgumentCount, regT2);
     1542    emitGetFromCallFrameHeader32(JSStack::ArgumentCount, regT2);
    15431543    addSlowCase(branch32(AboveOrEqual, regT1, regT2));
    15441544
    … …  
    15781578    int skip = currentInstruction[5].u.operand;
    15791579   
    1580     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT0);
     1580    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT0);
    15811581   
    15821582    bool checkTopLevel = m_codeBlock->codeType() == FunctionCode && m_codeBlock->needsFullScopeChain();

  • trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

    r129713 r130726  
    7171    // Finish canonical initialization before JS function call.
    7272    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scope)), regT1);
    73     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     73    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    7474
    7575    // Also initialize ReturnPC for use by lazy linking and exceptions.
    7676    preserveReturnAddressAfterCall(regT3);
    77     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     77    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    7878   
    7979    storePtr(callFrameRegister, &m_globalData->topCallFrame);
    … …  
    9191    // Finish canonical initialization before JS function call.
    9292    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scope)), regT1);
    93     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     93    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    9494
    9595    // Also initialize ReturnPC for use by lazy linking and exeptions.
    9696    preserveReturnAddressAfterCall(regT3);
    97     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     97    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    9898   
    9999    storePtr(callFrameRegister, &m_globalData->topCallFrame);
    … …  
    111111    // Finish canonical initialization before JS function call.
    112112    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scope)), regT1);
    113     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     113    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    114114
    115115    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    … …  
    135135    // Finish canonical initialization before JS function call.
    136136    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scope)), regT1);
    137     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     137    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    138138
    139139    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    … …  
    153153    callSlowCase.link(this);
    154154    // Finish canonical initialization before JS function call.
    155     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    156     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT2, regT2);
    157     emitPutCellToCallFrameHeader(regT2, RegisterFile::ScopeChain);
     155    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT2);
     156    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT2, regT2);
     157    emitPutCellToCallFrameHeader(regT2, JSStack::ScopeChain);
    158158
    159159    // Also initialize ReturnPC and CodeBlock, like a JS function would.
    160160    preserveReturnAddressAfterCall(regT3);
    161     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
    162     emitPutImmediateToCallFrameHeader(0, RegisterFile::CodeBlock);
     161    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
     162    emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
    163163
    164164    storePtr(callFrameRegister, &m_globalData->topCallFrame);
    165165    restoreArgumentReference();
    166166    Call callCallNotJSFunction = call();
    167     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     167    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    168168    restoreReturnAddressBeforeReturn(regT3);
    169169    ret();
    … …  
    171171    constructSlowCase.link(this);
    172172    // Finish canonical initialization before JS function call.
    173     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    174     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT2, regT2);
    175     emitPutCellToCallFrameHeader(regT2, RegisterFile::ScopeChain);
     173    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT2);
     174    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT2, regT2);
     175    emitPutCellToCallFrameHeader(regT2, JSStack::ScopeChain);
    176176
    177177    // Also initialize ReturnPC and CodeBlock, like a JS function would.
    178178    preserveReturnAddressAfterCall(regT3);
    179     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
    180     emitPutImmediateToCallFrameHeader(0, RegisterFile::CodeBlock);
     179    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
     180    emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
    181181
    182182    storePtr(callFrameRegister, &m_globalData->topCallFrame);
    183183    restoreArgumentReference();
    184184    Call callConstructNotJSFunction = call();
    185     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     185    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, callFrameRegister);
    186186    restoreReturnAddressBeforeReturn(regT3);
    187187    ret();
    … …  
    228228    Label nativeCallThunk = align();
    229229
    230     emitPutImmediateToCallFrameHeader(0, RegisterFile::CodeBlock);
     230    emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
    231231    storePtr(callFrameRegister, &m_globalData->topCallFrame);
    232232
    … …  
    234234    // Load caller frame's scope chain into this callframe so that whatever we call can
    235235    // get to its global data.
    236     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    237     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    238     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     236    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT0);
     237    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT0);
     238    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    239239
    240240    peek(regT1);
    241     emitPutToCallFrameHeader(regT1, RegisterFile::ReturnPC);
     241    emitPutToCallFrameHeader(regT1, JSStack::ReturnPC);
    242242
    243243    // Calling convention:      f(ecx, edx, ...);
    … …  
    248248
    249249    // call the function
    250     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT1);
     250    emitGetFromCallFrameHeaderPtr(JSStack::Callee, regT1);
    251251    loadPtr(Address(regT1, OBJECT_OFFSETOF(JSFunction, m_executable)), regT1);
    252252    move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    … …  
    258258    // Load caller frame's scope chain into this callframe so that whatever we call can
    259259    // get to its global data.
    260     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    261     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT2);
    262     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     260    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT2);
     261    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT2);
     262    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    263263
    264264    preserveReturnAddressAfterCall(regT3); // Callee preserved
    265     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     265    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    266266
    267267    // Calling convention:      f(r0 == regT0, r1 == regT1, ...);
    … …  
    270270
    271271    // call the function
    272     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, ARMRegisters::r1);
     272    emitGetFromCallFrameHeaderPtr(JSStack::Callee, ARMRegisters::r1);
    273273    move(regT2, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    274274    loadPtr(Address(ARMRegisters::r1, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    … …  
    279279    // Load caller frame's scope chain into this callframe so that whatever we call can
    280280    // get to its global data.
    281     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    282     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT2);
    283     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     281    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT2);
     282    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT2);
     283    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    284284
    285285    preserveReturnAddressAfterCall(regT3); // Callee preserved
    286     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     286    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    287287
    288288    // Calling convention: f(r0 == regT4, r1 == regT5, ...);
    … …  
    290290    move(callFrameRegister, regT4);
    291291
    292     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT5);
     292    emitGetFromCallFrameHeaderPtr(JSStack::Callee, regT5);
    293293    move(regT2, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    294294    loadPtr(Address(regT5, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    … …  
    299299    // Load caller frame's scope chain into this callframe so that whatever we call can
    300300    // get to its global data.
    301     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    302     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    303     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     301    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT0);
     302    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT0);
     303    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    304304
    305305    preserveReturnAddressAfterCall(regT3); // Callee preserved
    306     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     306    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    307307
    308308    // Calling convention:      f(a0, a1, a2, a3);
    … …  
    317317
    318318    // Call
    319     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, MIPSRegisters::a2);
     319    emitGetFromCallFrameHeaderPtr(JSStack::Callee, MIPSRegisters::a2);
    320320    loadPtr(Address(MIPSRegisters::a2, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    321321    move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    … …  
    363363    Call nativeCall;
    364364
    365     emitPutImmediateToCallFrameHeader(0, RegisterFile::CodeBlock);
     365    emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
    366366    storePtr(callFrameRegister, &m_globalData->topCallFrame);
    367367
    … …  
    369369    // Load caller frame's scope chain into this callframe so that whatever we call can
    370370    // get to its global data.
    371     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    372     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    373     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     371    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT0);
     372    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT0);
     373    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    374374
    375375    peek(regT1);
    376     emitPutToCallFrameHeader(regT1, RegisterFile::ReturnPC);
     376    emitPutToCallFrameHeader(regT1, JSStack::ReturnPC);
    377377
    378378    // Calling convention:      f(ecx, edx, ...);
    … …  
    392392    // Load caller frame's scope chain into this callframe so that whatever we call can
    393393    // get to its global data.
    394     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    395     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT2);
    396     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     394    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT2);
     395    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT2);
     396    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    397397
    398398    preserveReturnAddressAfterCall(regT3); // Callee preserved
    399     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     399    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    400400
    401401    // Calling convention:      f(r0 == regT0, r1 == regT1, ...);
    … …  
    403403    move(callFrameRegister, ARMRegisters::r0);
    404404
    405     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, ARMRegisters::r1);
     405    emitGetFromCallFrameHeaderPtr(JSStack::Callee, ARMRegisters::r1);
    406406    move(regT2, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    407407    loadPtr(Address(ARMRegisters::r1, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    … …  
    415415    // Load caller frame's scope chain into this callframe so that whatever we call can
    416416    // get to its global data.
    417     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT0);
    418     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT0);
    419     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     417    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT0);
     418    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT0);
     419    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    420420
    421421    preserveReturnAddressAfterCall(regT3); // Callee preserved
    422     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     422    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    423423
    424424    // Calling convention:      f(a0, a1, a2, a3);
    … …  
    433433
    434434    // Call
    435     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, MIPSRegisters::a2);
     435    emitGetFromCallFrameHeaderPtr(JSStack::Callee, MIPSRegisters::a2);
    436436    loadPtr(Address(MIPSRegisters::a2, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    437437    move(regT0, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    … …  
    447447    // Load caller frame's scope chain into this callframe so that whatever we call can
    448448    // get to its global data.
    449     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, regT2);
    450     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1, regT2);
    451     emitPutCellToCallFrameHeader(regT1, RegisterFile::ScopeChain);
     449    emitGetFromCallFrameHeaderPtr(JSStack::CallerFrame, regT2);
     450    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT2);
     451    emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    452452
    453453    preserveReturnAddressAfterCall(regT3); // Callee preserved
    454     emitPutToCallFrameHeader(regT3, RegisterFile::ReturnPC);
     454    emitPutToCallFrameHeader(regT3, JSStack::ReturnPC);
    455455
    456456    // Calling convention: f(r0 == regT4, r1 == regT5, ...);
    … …  
    458458    move(callFrameRegister, regT4);
    459459
    460     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT5);
     460    emitGetFromCallFrameHeaderPtr(JSStack::Callee, regT5);
    461461    move(regT2, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    462462    loadPtr(Address(regT5, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    … …  
    519519    ASSERT(returnValueRegister != callFrameRegister);
    520520    emitLoad(currentInstruction[1].u.operand, regT1, regT0);
    521     restoreReturnAddressBeforeReturn(Address(callFrameRegister, RegisterFile::ReturnPC * static_cast<int>(sizeof(Register))));
     521    restoreReturnAddressBeforeReturn(Address(callFrameRegister, JSStack::ReturnPC * static_cast<int>(sizeof(Register))));
    522522    ret();
    523523}
    … …  
    15451545void JIT::emit_op_create_this(Instruction* currentInstruction)
    15461546{
    1547     emitGetFromCallFrameHeaderPtr(RegisterFile::Callee, regT0);
     1547    emitGetFromCallFrameHeaderPtr(JSStack::Callee, regT0);
    15481548    loadPtr(Address(regT0, JSFunction::offsetOfCachedInheritorID()), regT2);
    15491549    addSlowCase(branchTestPtr(Zero, regT2));
    … …  
    16271627    int argumentsRegister = currentInstruction[2].u.operand;
    16281628    addSlowCase(branch32(NotEqual, tagFor(argumentsRegister), TrustedImm32(JSValue::EmptyValueTag)));
    1629     load32(payloadFor(RegisterFile::ArgumentCount), regT0);
     1629    load32(payloadFor(JSStack::ArgumentCount), regT0);
    16301630    sub32(TrustedImm32(1), regT0);
    16311631    emitStoreInt32(dst, regT0);
    … …  
    16551655    add32(TrustedImm32(1), regT2);
    16561656    // regT2 now contains the integer index of the argument we want, including this
    1657     load32(payloadFor(RegisterFile::ArgumentCount), regT3);
     1657    load32(payloadFor(JSStack::ArgumentCount), regT3);
    16581658    addSlowCase(branch32(AboveOrEqual, regT2, regT3));
    16591659   

  • trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp

    r130359 r130726  
    10641064    int skip = currentInstruction[3].u.operand;
    10651065
    1066     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT0);
     1066    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT0);
    10671067    bool checkTopLevel = m_codeBlock->codeType() == FunctionCode && m_codeBlock->needsFullScopeChain();
    10681068    ASSERT(skip || !checkTopLevel);
    … …  
    10891089    emitGetVirtualRegister(currentInstruction[3].u.operand, regT0);
    10901090
    1091     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT1);
     1091    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1);
    10921092    bool checkTopLevel = m_codeBlock->codeType() == FunctionCode && m_codeBlock->needsFullScopeChain();
    10931093    ASSERT(skip || !checkTopLevel);

  • trunk/Source/JavaScriptCore/jit/JITPropertyAccess32_64.cpp

    r130359 r130726  
    11021102    int skip = currentInstruction[3].u.operand;
    11031103
    1104     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT2);
     1104    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT2);
    11051105    bool checkTopLevel = m_codeBlock->codeType() == FunctionCode && m_codeBlock->needsFullScopeChain();
    11061106    ASSERT(skip || !checkTopLevel);
    … …  
    11311131    emitLoad(value, regT1, regT0);
    11321132
    1133     emitGetFromCallFrameHeaderPtr(RegisterFile::ScopeChain, regT2);
     1133    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT2);
    11341134    bool checkTopLevel = m_codeBlock->codeType() == FunctionCode && m_codeBlock->needsFullScopeChain();
    11351135    ASSERT(skip || !checkTopLevel);

  • trunk/Source/JavaScriptCore/jit/JITStubs.cpp

    r130612 r130726  
    225225extern "C" {
    226226
    227     __declspec(naked) EncodedJSValue ctiTrampoline(void* code, RegisterFile*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*)
     227    __declspec(naked) EncodedJSValue ctiTrampoline(void* code, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*)
    228228    {
    229229        __asm {
    … …  
    286286#elif CPU(SH4)
    287287#define SYMBOL_STRING(name) #name
    288 /* code (r4), RegisterFile* (r5), CallFrame* (r6), void* unused1 (r7), void* unused2(sp), JSGlobalData (sp)*/
     288/* code (r4), JSStack* (r5), CallFrame* (r6), void* unused1 (r7), void* unused2(sp), JSGlobalData (sp)*/
    289289
    290290asm volatile (
    … …  
    459459    "li    $17,512      # set timeoutCheckRegister" "\n"
    460460    "move  $25,$4       # move executableAddress to t9" "\n"
    461     "sw    $5," STRINGIZE_VALUE_OF(REGISTER_FILE_OFFSET) "($29) # store registerFile to current stack" "\n"
     461    "sw    $5," STRINGIZE_VALUE_OF(REGISTER_FILE_OFFSET) "($29) # store JSStack to current stack" "\n"
    462462    "lw    $9," STRINGIZE_VALUE_OF(STACK_LENGTH + 20) "($29)    # load globalData from previous stack" "\n"
    463463    "jalr  $25" "\n"
    … …  
    660660#elif COMPILER(RVCT) && CPU(ARM_THUMB2)
    661661
    662 __asm EncodedJSValue ctiTrampoline(void*, RegisterFile*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*)
     662__asm EncodedJSValue ctiTrampoline(void*, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*)
    663663{
    664664    PRESERVE8
    … …  
    728728#elif COMPILER(RVCT) && CPU(ARM_TRADITIONAL)
    729729
    730 __asm EncodedJSValue ctiTrampoline(void*, RegisterFile*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*)
     730__asm EncodedJSValue ctiTrampoline(void*, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*)
    731731{
    732732    ARM
    … …  
    797797    ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedR11) == PRESERVED_R11_OFFSET);
    798798
    799     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, registerFile) == REGISTER_FILE_OFFSET);
     799    ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, JSStack) == REGISTER_FILE_OFFSET);
    800800    // The fifth argument is the first item already on the stack.
    801801    ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, unused1) == FIRST_STACK_ARGUMENT);
    … …  
    816816    ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, preservedReturnAddress) == PRESERVED_RETURN_ADDRESS_OFFSET);
    817817    ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, thunkReturnAddress) == THUNK_RETURN_ADDRESS_OFFSET);
    818     ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, registerFile) == REGISTER_FILE_OFFSET);
     818    ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, JSStack) == REGISTER_FILE_OFFSET);
    819819    ASSERT(OBJECT_OFFSETOF(struct JITStackFrame, globalData) == GLOBAL_DATA_OFFSET);
    820820
    … …  
    10501050
    10511051// Helper function for JIT stubs that may throw an exception in the middle of
    1052 // processing a function call. This function rolls back the register file to
     1052// processing a function call. This function rolls back the stack to
    10531053// our caller, so exception processing can proceed from a valid state.
    10541054template<typename T> static T throwExceptionFromOpCall(JITStackFrame& jitStackFrame, CallFrame* newCallFrame, ReturnAddressPtr& returnAddressSlot)
    … …  
    13601360}
    13611361
    1362 DEFINE_STUB_FUNCTION(void*, register_file_check)
    1363 {
    1364     STUB_INIT_STACK_FRAME(stackFrame);
    1365     CallFrame* callFrame = stackFrame.callFrame;
    1366 
    1367     if (UNLIKELY(!stackFrame.registerFile->grow(&callFrame->registers()[callFrame->codeBlock()->m_numCalleeRegisters])))
     1362DEFINE_STUB_FUNCTION(void*, stack_check)
     1363{
     1364    STUB_INIT_STACK_FRAME(stackFrame);
     1365    CallFrame* callFrame = stackFrame.callFrame;
     1366
     1367    if (UNLIKELY(!stackFrame.stack->grow(&callFrame->registers()[callFrame->codeBlock()->m_numCalleeRegisters])))
    13681368        return throwExceptionFromOpCall<void*>(stackFrame, callFrame, STUB_RETURN_ADDRESS, createStackOverflowError(callFrame->callerFrame()));
    13691369
    … …  
    21922192    CallFrame* callFrame = stackFrame.callFrame;
    21932193
    2194     CallFrame* newCallFrame = CommonSlowPaths::arityCheckFor(callFrame, stackFrame.registerFile, CodeForCall);
     2194    CallFrame* newCallFrame = CommonSlowPaths::arityCheckFor(callFrame, stackFrame.stack, CodeForCall);
    21952195    if (!newCallFrame)
    21962196        return throwExceptionFromOpCall<void*>(stackFrame, callFrame, STUB_RETURN_ADDRESS, createStackOverflowError(callFrame->callerFrame()));
    … …  
    22052205    CallFrame* callFrame = stackFrame.callFrame;
    22062206
    2207     CallFrame* newCallFrame = CommonSlowPaths::arityCheckFor(callFrame, stackFrame.registerFile, CodeForConstruct);
     2207    CallFrame* newCallFrame = CommonSlowPaths::arityCheckFor(callFrame, stackFrame.stack, CodeForConstruct);
    22082208    if (!newCallFrame)
    22092209        return throwExceptionFromOpCall<void*>(stackFrame, callFrame, STUB_RETURN_ADDRESS, createStackOverflowError(callFrame->callerFrame()));
    … …  
    25832583
    25842584    CallFrame* callFrame = stackFrame.callFrame;
    2585     RegisterFile* registerFile = stackFrame.registerFile;
     2585    JSStack* stack = stackFrame.stack;
    25862586    JSValue thisValue = stackFrame.args[0].jsValue();
    25872587    JSValue arguments = stackFrame.args[1].jsValue();
    25882588    int firstFreeRegister = stackFrame.args[2].int32();
    25892589
    2590     CallFrame* newCallFrame = loadVarargs(callFrame, registerFile, thisValue, arguments, firstFreeRegister);
     2590    CallFrame* newCallFrame = loadVarargs(callFrame, stack, thisValue, arguments, firstFreeRegister);
    25912591    if (!newCallFrame)
    25922592        VM_THROW_EXCEPTION();

  • trunk/Source/JavaScriptCore/jit/JITStubs.h

    r129281 r130726  
    5353    class JSObject;
    5454    class JSPropertyNameIterator;
     55    class JSStack;
    5556    class JSValue;
    5657    class JSValueEncodedAsPointer;
    … …  
    5960    class PropertySlot;
    6061    class PutPropertySlot;
    61     class RegisterFile;
    6262    class RegExp;
    6363    class Structure;
    … …  
    102102
    103103        void* code;
    104         RegisterFile* registerFile;
     104        JSStack* stack;
    105105        CallFrame* callFrame;
    106106        void* unused1;
    … …  
    138138
    139139        void* code;
    140         RegisterFile* registerFile;
     140        JSStack* stack;
    141141        CallFrame* callFrame;
    142142        void* unused1;
    … …  
    168168
    169169        // These arguments passed in r1..r3 (r0 contained the entry code pointed, which is not preserved)
    170         RegisterFile* registerFile;
     170        JSStack* stack;
    171171        CallFrame* callFrame;
    172172
    … …  
    197197        void* preservedLink;
    198198
    199         RegisterFile* registerFile;
     199        JSStack* stack;
    200200        CallFrame* callFrame;
    201201        void* unused1;
    … …  
    229229
    230230        // These arguments passed in a1..a3 (a0 contained the entry code pointed, which is not preserved)
    231         RegisterFile* registerFile;
     231        JSStack* stack;
    232232        CallFrame* callFrame;
    233233        void* unused1;
    … …  
    252252        void* savedTimeoutReg;
    253253
    254         RegisterFile* registerFile;
     254        JSStack* stack;
    255255        CallFrame* callFrame;
    256256        JSValue* exception;
    … …  
    285285    extern "C" void ctiVMThrowTrampoline();
    286286    extern "C" void ctiOpThrowNotCaught();
    287     extern "C" EncodedJSValue ctiTrampoline(void* code, RegisterFile*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*);
     287    extern "C" EncodedJSValue ctiTrampoline(void* code, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, JSGlobalData*);
    288288#if ENABLE(DFG_JIT)
    289289    extern "C" void ctiTrampolineEnd();
    … …  
    463463    void* JIT_STUB cti_op_switch_string(STUB_ARGS_DECLARATION) WTF_INTERNAL;
    464464    void* JIT_STUB cti_op_throw(STUB_ARGS_DECLARATION) WTF_INTERNAL;
    465     void* JIT_STUB cti_register_file_check(STUB_ARGS_DECLARATION) WTF_INTERNAL;
     465    void* JIT_STUB cti_stack_check(STUB_ARGS_DECLARATION) WTF_INTERNAL;
    466466    void* JIT_STUB cti_vm_lazyLinkCall(STUB_ARGS_DECLARATION) WTF_INTERNAL;
    467467    void* JIT_STUB cti_vm_lazyLinkConstruct(STUB_ARGS_DECLARATION) WTF_INTERNAL;

  • trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h

    r127199 r130726  
    3030#include "JITCode.h"
    3131#include "JITStubs.h"
     32#include "JSStack.h"
    3233#include "JSString.h"
    3334#include "JSValue.h"
    3435#include "MacroAssembler.h"
    35 #include "RegisterFile.h"
    3636#include <wtf/AlwaysInline.h>
    3737#include <wtf/Vector.h>

  • trunk/Source/JavaScriptCore/jit/SpecializedThunkJIT.h

    r124476 r130726  
    4141        {
    4242            // Check that we have the expected number of arguments
    43             m_failures.append(branch32(NotEqual, payloadFor(RegisterFile::ArgumentCount), TrustedImm32(expectedArgCount + 1)));
     43            m_failures.append(branch32(NotEqual, payloadFor(JSStack::ArgumentCount), TrustedImm32(expectedArgCount + 1)));
    4444        }
    4545       
    … …  
    8484            if (src != regT0)
    8585                move(src, regT0);
    86             loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
     86            loadPtr(payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);
    8787            ret();
    8888        }
    … …  
    109109            highNonZero.link(this);
    110110#endif
    111             loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
     111            loadPtr(payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);
    112112            ret();
    113113        }
    … …  
    118118                move(src, regT0);
    119119            tagReturnAsInt32();
    120             loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
     120            loadPtr(payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);
    121121            ret();
    122122        }
    … …  
    127127                move(src, regT0);
    128128            tagReturnAsJSCell();
    129             loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
     129            loadPtr(payloadFor(JSStack::CallerFrame, callFrameRegister), callFrameRegister);
    130130            ret();
    131131        }

  • trunk/Source/JavaScriptCore/llint/LLIntData.cpp

    r127374 r130726  
    6969    // Assertions to match LowLevelInterpreter.asm.  If you change any of this code, be
    7070    // prepared to change LowLevelInterpreter.asm as well!!
    71     ASSERT(RegisterFile::CallFrameHeaderSize * 8 == 48);
    72     ASSERT(RegisterFile::ArgumentCount * 8 == -48);
    73     ASSERT(RegisterFile::CallerFrame * 8 == -40);
    74     ASSERT(RegisterFile::Callee * 8 == -32);
    75     ASSERT(RegisterFile::ScopeChain * 8 == -24);
    76     ASSERT(RegisterFile::ReturnPC * 8 == -16);
    77     ASSERT(RegisterFile::CodeBlock * 8 == -8);
    78     ASSERT(CallFrame::argumentOffsetIncludingThis(0) == -RegisterFile::CallFrameHeaderSize - 1);
     71    ASSERT(JSStack::CallFrameHeaderSize * 8 == 48);
     72    ASSERT(JSStack::ArgumentCount * 8 == -48);
     73    ASSERT(JSStack::CallerFrame * 8 == -40);
     74    ASSERT(JSStack::Callee * 8 == -32);
     75    ASSERT(JSStack::ScopeChain * 8 == -24);
     76    ASSERT(JSStack::ReturnPC * 8 == -16);
     77    ASSERT(JSStack::CodeBlock * 8 == -8);
     78    ASSERT(CallFrame::argumentOffsetIncludingThis(0) == -JSStack::CallFrameHeaderSize - 1);
    7979#if CPU(BIG_ENDIAN)
    8080    ASSERT(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag) == 0);

  • trunk/Source/JavaScriptCore/llint/LLIntOffsetsExtractor.cpp

    r127202 r130726  
    3939#include "JSObject.h"
    4040#include "JSPropertyNameIterator.h"
     41#include "JSStack.h"
    4142#include "JSString.h"
    4243#include "JSTypeInfo.h"
    … …  
    4546#include "LLIntOfflineAsmConfig.h"
    4647#include "MarkedSpace.h"
    47 #include "RegisterFile.h"
    4848
    4949#include "Structure.h"

  • trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp

    r129319 r130726  
    397397#endif // ENABLE(JIT)
    398398
    399 LLINT_SLOW_PATH_DECL(register_file_check)
     399LLINT_SLOW_PATH_DECL(stack_check)
    400400{
    401401    LLINT_BEGIN();
    … …  
    405405    dataLog("Num callee registers = %u.\n", exec->codeBlock()->m_numCalleeRegisters);
    406406    dataLog("Num vars = %u.\n", exec->codeBlock()->m_numVars);
    407     dataLog("Current end is at %p.\n", exec->globalData().interpreter->registerFile().end());
    408 #endif
    409     ASSERT(&exec->registers()[exec->codeBlock()->m_numCalleeRegisters] > exec->globalData().interpreter->registerFile().end());
    410     if (UNLIKELY(!globalData.interpreter->registerFile().grow(&exec->registers()[exec->codeBlock()->m_numCalleeRegisters]))) {
     407    dataLog("Current end is at %p.\n", exec->globalData().interpreter->stack().end());
     408#endif
     409    ASSERT(&exec->registers()[exec->codeBlock()->m_numCalleeRegisters] > exec->globalData().interpreter->stack().end());
     410    if (UNLIKELY(!globalData.interpreter->stack().grow(&exec->registers()[exec->codeBlock()->m_numCalleeRegisters]))) {
    411411        ReturnAddressPtr returnPC = exec->returnPC();
    412412        exec = exec->callerFrame();
    … …  
    421421{
    422422    LLINT_BEGIN();
    423     ExecState* newExec = CommonSlowPaths::arityCheckFor(exec, &globalData.interpreter->registerFile(), CodeForCall);
     423    ExecState* newExec = CommonSlowPaths::arityCheckFor(exec, &globalData.interpreter->stack(), CodeForCall);
    424424    if (!newExec) {
    425425        ReturnAddressPtr returnPC = exec->returnPC();
    … …  
    435435{
    436436    LLINT_BEGIN();
    437     ExecState* newExec = CommonSlowPaths::arityCheckFor(exec, &globalData.interpreter->registerFile(), CodeForConstruct);
     437    ExecState* newExec = CommonSlowPaths::arityCheckFor(exec, &globalData.interpreter->stack(), CodeForConstruct);
    438438    if (!newExec) {
    439439        ReturnAddressPtr returnPC = exec->returnPC();
    … …  
    14091409   
    14101410    execCallee->setArgumentCountIncludingThis(pc[2].u.operand);
    1411     execCallee->uncheckedR(RegisterFile::Callee) = calleeAsValue;
     1411    execCallee->uncheckedR(JSStack::Callee) = calleeAsValue;
    14121412    execCallee->setCallerFrame(exec);
    14131413   
    … …  
    14391439   
    14401440    ExecState* execCallee = loadVarargs(
    1441         exec, &globalData.interpreter->registerFile(),
     1441        exec, &globalData.interpreter->stack(),
    14421442        LLINT_OP_C(2).jsValue(), LLINT_OP_C(3).jsValue(), pc[4].u.operand);
    14431443    LLINT_CALL_CHECK_EXCEPTION(exec, pc);
    14441444   
    1445     execCallee->uncheckedR(RegisterFile::Callee) = calleeAsValue;
     1445    execCallee->uncheckedR(JSStack::Callee) = calleeAsValue;
    14461446    execCallee->setCallerFrame(exec);
    14471447    exec->setCurrentVPC(pc + OPCODE_LENGTH(op_call_varargs));
    … …  
    14591459    execCallee->setArgumentCountIncludingThis(pc[2].u.operand);
    14601460    execCallee->setCallerFrame(exec);
    1461     execCallee->uncheckedR(RegisterFile::Callee) = calleeAsValue;
     1461    execCallee->uncheckedR(JSStack::Callee) = calleeAsValue;
    14621462    execCallee->setScope(exec->scope());
    14631463    execCallee->setReturnPC(LLInt::getCodePtr(llint_generic_return_point));

  • trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.h

    r127393 r130726  
    113113LLINT_SLOW_PATH_HIDDEN_DECL(loop_osr);
    114114LLINT_SLOW_PATH_HIDDEN_DECL(replace);
    115 LLINT_SLOW_PATH_HIDDEN_DECL(register_file_check);
     115LLINT_SLOW_PATH_HIDDEN_DECL(stack_check);
    116116LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_call_arityCheck);
    117117LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_construct_arityCheck);

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

    r130359 r130726  
    2525# of these must have an ASSERT() in LLIntData.cpp
    2626
    27 # These declarations must match interpreter/RegisterFile.h.
     27# These declarations must match interpreter/JSStack.h.
    2828const CallFrameHeaderSize = 48
    2929const ArgumentCount = -48
    … …  
    3939if JSVALUE64
    4040    # - Use a pair of registers to represent the PC: one register for the
    41     #   base of the register file, and one register for the index.
     41    #   base of the stack, and one register for the index.
    4242    # - The PC base (or PB for short) should be stored in the csr. It will
    4343    #   get clobbered on calls to other JS code, but will get saved on calls
    … …  
    316316    loadi CodeBlock::m_numCalleeRegisters[t1], t0
    317317    loadp CodeBlock::m_globalData[t1], t2
    318     loadp JSGlobalData::interpreter[t2], t2   # FIXME: Can get to the RegisterFile from the JITStackFrame
     318    loadp JSGlobalData::interpreter[t2], t2   # FIXME: Can get to the JSStack from the JITStackFrame
    319319    lshifti 3, t0
    320320    addp t0, cfr, t0
    321     bpaeq Interpreter::m_registerFile + RegisterFile::m_end[t2], t0, .stackHeightOK
     321    bpaeq Interpreter::m_stack + JSStack::m_end[t2], t0, .stackHeightOK
    322322
    323323    # Stack height check failed - need to call a slow_path.
    324     callSlowPath(_llint_register_file_check)
     324    callSlowPath(_llint_stack_check)
    325325.stackHeightOK:
    326326end

  • trunk/Source/JavaScriptCore/runtime/Arguments.cpp

    r130303 r130726  
    407407        Register* location = &registers[CallFrame::argumentOffset(i)];
    408408        switch (recovery.technique()) {
    409         case AlreadyInRegisterFile:
     409        case AlreadyInJSStack:
    410410            value = location->jsValue();
    411411            break;
    412         case AlreadyInRegisterFileAsUnboxedInt32:
     412        case AlreadyInJSStackAsUnboxedInt32:
    413413            value = jsNumber(location->unboxedInt32());
    414414            break;
    415         case AlreadyInRegisterFileAsUnboxedCell:
     415        case AlreadyInJSStackAsUnboxedCell:
    416416            value = location->unboxedCell();
    417417            break;
    418         case AlreadyInRegisterFileAsUnboxedBoolean:
     418        case AlreadyInJSStackAsUnboxedBoolean:
    419419            value = jsBoolean(location->unboxedBoolean());
    420420            break;
    421         case AlreadyInRegisterFileAsUnboxedDouble:
     421        case AlreadyInJSStackAsUnboxedDouble:
    422422#if USE(JSVALUE64)
    423423            value = jsNumber(*bitwise_cast<double*>(location));

  • trunk/Source/JavaScriptCore/runtime/CommonSlowPaths.h

    r129281 r130726  
    4444namespace CommonSlowPaths {
    4545
    46 ALWAYS_INLINE ExecState* arityCheckFor(ExecState* exec, RegisterFile* registerFile, CodeSpecializationKind kind)
     46ALWAYS_INLINE ExecState* arityCheckFor(ExecState* exec, JSStack* stack, CodeSpecializationKind kind)
    4747{
    4848    JSFunction* callee = jsCast<JSFunction*>(exec->callee());
    … …  
    5252
    5353    // This ensures enough space for the worst case scenario of zero arguments passed by the caller.
    54     if (!registerFile->grow(exec->registers() + newCodeBlock->numParameters() + newCodeBlock->m_numCalleeRegisters))
     54    if (!stack->grow(exec->registers() + newCodeBlock->numParameters() + newCodeBlock->m_numCalleeRegisters))
    5555        return 0;
    5656
    … …  
    7272
    7373    ExecState* newExec = ExecState::create(dst);
    74     ASSERT((void*)newExec <= registerFile->end());
     74    ASSERT((void*)newExec <= stack->end());
    7575    return newExec;
    7676}

  • trunk/Source/JavaScriptCore/runtime/InitializeThreading.cpp

    r130520 r130726  
    6666    ExecutableAllocator::initializeAllocator();
    6767#endif
    68     RegisterFile::initializeThreading();
     68    JSStack::initializeThreading();
    6969#if ENABLE(LLINT)
    7070    LLInt::initialize();

  • trunk/Source/JavaScriptCore/runtime/JSActivation.cpp

    r130612 r130726  
    5050    Base::visitChildren(thisObject, visitor);
    5151
    52     // No need to mark our registers if they're still in the RegisterFile.
     52    // No need to mark our registers if they're still in the JSStack.
    5353    if (!thisObject->isTornOff())
    5454        return;

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp

    r130303 r130726  
    513513ExecState* JSGlobalObject::globalExec()
    514514{
    515     return CallFrame::create(m_globalCallFrame + RegisterFile::CallFrameHeaderSize);
     515    return CallFrame::create(m_globalCallFrame + JSStack::CallFrameHeaderSize);
    516516}
    517517

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.h

    r130303 r130726  
    4747    class GetterSetter;
    4848    class GlobalCodeBlock;
     49    class JSStack;
    4950    class LLIntOffsetsExtractor;
    5051    class NativeErrorConstructor;
    … …  
    5253    class RegExpConstructor;
    5354    class RegExpPrototype;
    54     class RegisterFile;
    5555
    5656    struct ActivationStackNode;
    … …  
    9292    protected:
    9393
    94         Register m_globalCallFrame[RegisterFile::CallFrameHeaderSize];
     94        Register m_globalCallFrame[JSStack::CallFrameHeaderSize];
    9595
    9696        WriteBarrier<JSObject> m_globalThis;

  • trunk/Source/JavaScriptCore/runtime/JSLock.cpp

    r128704 r130726  
    141141// function through a callback.
    142142//
    143 // All threads using the context share the same JS stack (the RegisterFile).
    144 // Whenever a thread calls into JSC it starts using the RegisterFile from the
     143// All threads using the context share the same JS stack (the JSStack).
     144// Whenever a thread calls into JSC it starts using the JSStack from the
    145145// previous 'high water mark' - the maximum point the stack has ever grown to
    146 // (returned by RegisterFile::end()).  So if a first thread calls out to a
     146// (returned by JSStack::end()).  So if a first thread calls out to a
    147147// callback, and a second thread enters JSC, then also exits by calling out
    148148// to a callback, we can be left with stackframes from both threads in the
    149 // RegisterFile.  As such, a problem may occur should the first thread's
     149// JSStack.  As such, a problem may occur should the first thread's
    150150// callback complete first, and attempt to return to JSC.  Were we to allow
    151151// this to happen, and were its stack to grow further, then it may potentially

  • trunk/Source/JavaScriptCore/runtime/JSVariableObject.h

    r128260 r130726  
    6969        }
    7070
    71         WriteBarrierBase<Unknown>* m_registers; // "r" in the register file.
     71        WriteBarrierBase<Unknown>* m_registers; // "r" in the stack.
    7272    };
    7373

  • trunk/Source/JavaScriptCore/runtime/MemoryStatistics.cpp

    r128071 r130726  
    2929#include "ExecutableAllocator.h"
    3030#include "JSGlobalData.h"
    31 #include "RegisterFile.h"
     31#include "JSStack.h"
    3232
    3333namespace JSC {
    … …  
    3737    GlobalMemoryStatistics stats;
    3838
    39     stats.stackBytes = RegisterFile::committedByteCount();
     39    stats.stackBytes = JSStack::committedByteCount();
    4040#if ENABLE(EXECUTABLE_ALLOCATOR_FIXED) || ((PLATFORM(BLACKBERRY) || PLATFORM(EFL)) && ENABLE(JIT))
    4141    stats.JITBytes = ExecutableAllocator::committedByteCount();
Note: See TracChangeset for help on using the changeset viewer.