Changeset 243232 in webkit

Timestamp:

Mar 20, 2019 1:24:36 PM (5 years ago)

Author:

rmorisset@apple.com

Message:

Compress CodeOrigin into a single word in the common case
​https://bugs.webkit.org/show_bug.cgi?id=195928

Reviewed by Saam Barati.

The trick is that pointers only take 48 bits on x86_64 in practice (and we can even use the bottom three bits of that thanks to alignment), and even less on ARM64.
So we can shove the bytecode index in the top bits almost all the time.
If the bytecodeIndex is too ginormous (1<<16 in practice on x86_64), we just set one bit at the bottom and store a pointer to some out-of-line storage instead.
Finally we represent an invalid bytecodeIndex (which used to be represented by UINT_MAX) by setting the second least signifcant bit.

The patch looks very long, but most of it is just replacing direct accesses to inlineCallFrame and bytecodeIndex by the relevant getters.

End result: CodeOrigin in the common case moves from 16 bytes (8 for InlineCallFrame*, 4 for unsigned bytecodeIndex, 4 of padding) to 8.
As a reference, during running JetStream2 we allocate more than 35M CodeOrigins. While they won't all be alive at the same time, it is still quite a lot of objects, so I am hoping for some small
improvement to RAMification from this work.

The one slightly tricky part is that we must implement copy and move assignment operators and constructors to make sure that any out-of-line storage belongs to a single CodeOrigin and is destroyed exactly once.

• bytecode/ByValInfo.h:
• bytecode/CallLinkStatus.cpp:

(JSC::CallLinkStatus::computeFor):

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::globalObjectFor):
(JSC::CodeBlock::updateOSRExitCounterAndCheckIfNeedToReoptimize):
(JSC::CodeBlock::bytecodeOffsetFromCallSiteIndex):

• bytecode/CodeOrigin.cpp:

(JSC::CodeOrigin::inlineDepth const):
(JSC::CodeOrigin::isApproximatelyEqualTo const):
(JSC::CodeOrigin::approximateHash const):
(JSC::CodeOrigin::inlineStack const):
(JSC::CodeOrigin::codeOriginOwner const):
(JSC::CodeOrigin::stackOffset const):
(JSC::CodeOrigin::dump const):
(JSC::CodeOrigin::inlineDepthForCallFrame): Deleted.

• bytecode/CodeOrigin.h:

(JSC::OutOfLineCodeOrigin::OutOfLineCodeOrigin):
(JSC::CodeOrigin::CodeOrigin):
(JSC::CodeOrigin::~CodeOrigin):
(JSC::CodeOrigin::isSet const):
(JSC::CodeOrigin::isHashTableDeletedValue const):
(JSC::CodeOrigin::bytecodeIndex const):
(JSC::CodeOrigin::inlineCallFrame const):
(JSC::CodeOrigin::buildCompositeValue):
(JSC::CodeOrigin::hash const):
(JSC::CodeOrigin::operator== const):
(JSC::CodeOrigin::exitingInlineKind const): Deleted.

• bytecode/DeferredSourceDump.h:
• bytecode/GetByIdStatus.cpp:

(JSC::GetByIdStatus::computeForStubInfo):
(JSC::GetByIdStatus::computeFor):

• bytecode/ICStatusMap.cpp:

(JSC::ICStatusContext::isInlined const):

• bytecode/InByIdStatus.cpp:

(JSC::InByIdStatus::computeFor):
(JSC::InByIdStatus::computeForStubInfo):

• bytecode/InlineCallFrame.cpp:

(JSC::InlineCallFrame::dumpInContext const):

• bytecode/InlineCallFrame.h:

(JSC::InlineCallFrame::computeCallerSkippingTailCalls):
(JSC::InlineCallFrame::getCallerInlineFrameSkippingTailCalls):
(JSC::baselineCodeBlockForOriginAndBaselineCodeBlock):
(JSC::CodeOrigin::walkUpInlineStack):

• bytecode/InstanceOfStatus.h:
• bytecode/PutByIdStatus.cpp:

(JSC::PutByIdStatus::computeForStubInfo):
(JSC::PutByIdStatus::computeFor):

• dfg/DFGAbstractInterpreterInlines.h:

(JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):

• dfg/DFGArgumentsEliminationPhase.cpp:
• dfg/DFGArgumentsUtilities.cpp:

(JSC::DFG::argumentsInvolveStackSlot):
(JSC::DFG::emitCodeToGetArgumentsArrayLength):

• dfg/DFGArrayMode.h:
• dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::injectLazyOperandSpeculation):
(JSC::DFG::ByteCodeParser::setLocal):
(JSC::DFG::ByteCodeParser::setArgument):
(JSC::DFG::ByteCodeParser::flushForTerminalImpl):
(JSC::DFG::ByteCodeParser::getPredictionWithoutOSRExit):
(JSC::DFG::ByteCodeParser::parseBlock):
(JSC::DFG::ByteCodeParser::parseCodeBlock):
(JSC::DFG::ByteCodeParser::handlePutByVal):

• dfg/DFGClobberize.h:

(JSC::DFG::clobberize):

• dfg/DFGConstantFoldingPhase.cpp:

(JSC::DFG::ConstantFoldingPhase::foldConstants):

• dfg/DFGFixupPhase.cpp:

(JSC::DFG::FixupPhase::attemptToMakeGetArrayLength):

• dfg/DFGForAllKills.h:

(JSC::DFG::forAllKilledOperands):

• dfg/DFGGraph.cpp:

(JSC::DFG::Graph::dumpCodeOrigin):
(JSC::DFG::Graph::dump):
(JSC::DFG::Graph::isLiveInBytecode):
(JSC::DFG::Graph::methodOfGettingAValueProfileFor):
(JSC::DFG::Graph::willCatchExceptionInMachineFrame):

• dfg/DFGGraph.h:

(JSC::DFG::Graph::executableFor):
(JSC::DFG::Graph::isStrictModeFor):
(JSC::DFG::Graph::hasExitSite):
(JSC::DFG::Graph::forAllLocalsLiveInBytecode):

• dfg/DFGLiveCatchVariablePreservationPhase.cpp:

(JSC::DFG::LiveCatchVariablePreservationPhase::handleBlockForTryCatch):

• dfg/DFGMinifiedNode.cpp:

(JSC::DFG::MinifiedNode::fromNode):

• dfg/DFGOSRAvailabilityAnalysisPhase.cpp:

(JSC::DFG::LocalOSRAvailabilityCalculator::executeNode):

• dfg/DFGOSRExit.cpp:

(JSC::DFG::OSRExit::executeOSRExit):
(JSC::DFG::reifyInlinedCallFrames):
(JSC::DFG::adjustAndJumpToTarget):
(JSC::DFG::printOSRExit):
(JSC::DFG::OSRExit::compileExit):

• dfg/DFGOSRExitBase.cpp:

(JSC::DFG::OSRExitBase::considerAddingAsFrequentExitSiteSlow):

• dfg/DFGOSRExitCompilerCommon.cpp:

(JSC::DFG::handleExitCounts):
(JSC::DFG::reifyInlinedCallFrames):
(JSC::DFG::adjustAndJumpToTarget):

• dfg/DFGOSRExitPreparation.cpp:

(JSC::DFG::prepareCodeOriginForOSRExit):

• dfg/DFGObjectAllocationSinkingPhase.cpp:
• dfg/DFGOperations.cpp:
• dfg/DFGPreciseLocalClobberize.h:

(JSC::DFG::PreciseLocalClobberizeAdaptor::readTop):

• dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::emitGetLength):
(JSC::DFG::SpeculativeJIT::emitGetCallee):
(JSC::DFG::SpeculativeJIT::compileCurrentBlock):
(JSC::DFG::SpeculativeJIT::compileValueAdd):
(JSC::DFG::SpeculativeJIT::compileValueSub):
(JSC::DFG::SpeculativeJIT::compileValueNegate):
(JSC::DFG::SpeculativeJIT::compileValueMul):
(JSC::DFG::SpeculativeJIT::compileForwardVarargs):
(JSC::DFG::SpeculativeJIT::compileCreateDirectArguments):

• dfg/DFGSpeculativeJIT32_64.cpp:

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

• dfg/DFGSpeculativeJIT64.cpp:

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

• dfg/DFGTierUpCheckInjectionPhase.cpp:

(JSC::DFG::TierUpCheckInjectionPhase::run):
(JSC::DFG::TierUpCheckInjectionPhase::canOSREnterAtLoopHint):
(JSC::DFG::TierUpCheckInjectionPhase::buildNaturalLoopToLoopHintMap):

• dfg/DFGTypeCheckHoistingPhase.cpp:

(JSC::DFG::TypeCheckHoistingPhase::run):

• dfg/DFGVariableEventStream.cpp:

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

• ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::compileValueAdd):
(JSC::FTL::DFG::LowerDFGToB3::compileValueSub):
(JSC::FTL::DFG::LowerDFGToB3::compileValueMul):
(JSC::FTL::DFG::LowerDFGToB3::compileArithAddOrSub):
(JSC::FTL::DFG::LowerDFGToB3::compileValueNegate):
(JSC::FTL::DFG::LowerDFGToB3::compileGetMyArgumentByVal):
(JSC::FTL::DFG::LowerDFGToB3::compileNewArrayWithSpread):
(JSC::FTL::DFG::LowerDFGToB3::compileSpread):
(JSC::FTL::DFG::LowerDFGToB3::compileCallOrConstructVarargsSpread):
(JSC::FTL::DFG::LowerDFGToB3::compileCallOrConstructVarargs):
(JSC::FTL::DFG::LowerDFGToB3::compileForwardVarargs):
(JSC::FTL::DFG::LowerDFGToB3::compileForwardVarargsWithSpread):
(JSC::FTL::DFG::LowerDFGToB3::getArgumentsLength):
(JSC::FTL::DFG::LowerDFGToB3::getCurrentCallee):
(JSC::FTL::DFG::LowerDFGToB3::getArgumentsStart):
(JSC::FTL::DFG::LowerDFGToB3::codeOriginDescriptionOfCallSite const):

• ftl/FTLOSRExitCompiler.cpp:

(JSC::FTL::compileStub):

• ftl/FTLOperations.cpp:

(JSC::FTL::operationMaterializeObjectInOSR):

• interpreter/CallFrame.cpp:

(JSC::CallFrame::bytecodeOffset):

• interpreter/StackVisitor.cpp:

(JSC::StackVisitor::unwindToMachineCodeBlockFrame):
(JSC::StackVisitor::readFrame):
(JSC::StackVisitor::readNonInlinedFrame):
(JSC::inlinedFrameOffset):
(JSC::StackVisitor::readInlinedFrame):

• interpreter/StackVisitor.h:
• jit/AssemblyHelpers.cpp:

(JSC::AssemblyHelpers::executableFor):

• jit/AssemblyHelpers.h:

(JSC::AssemblyHelpers::isStrictModeFor):
(JSC::AssemblyHelpers::argumentsStart):
(JSC::AssemblyHelpers::argumentCount):

• jit/PCToCodeOriginMap.cpp:

(JSC::PCToCodeOriginMap::PCToCodeOriginMap):
(JSC::PCToCodeOriginMap::findPC const):

• profiler/ProfilerOriginStack.cpp:

(JSC::Profiler::OriginStack::OriginStack):

• profiler/ProfilerOriginStack.h:
• runtime/ErrorInstance.cpp:

(JSC::appendSourceToError):

• runtime/SamplingProfiler.cpp:

(JSC::SamplingProfiler::processUnverifiedStackTraces):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• bytecode/ByValInfo.h (modified) (1 diff)
• bytecode/CallLinkStatus.cpp (modified) (3 diffs)
• bytecode/CodeBlock.cpp (modified) (3 diffs)
• bytecode/CodeOrigin.cpp (modified) (9 diffs)
• bytecode/CodeOrigin.h (modified) (4 diffs)
• bytecode/DeferredSourceDump.h (modified) (1 diff)
• bytecode/GetByIdStatus.cpp (modified) (4 diffs)
• bytecode/ICStatusMap.cpp (modified) (1 diff)
• bytecode/InByIdStatus.cpp (modified) (4 diffs)
• bytecode/InlineCallFrame.cpp (modified) (1 diff)
• bytecode/InlineCallFrame.h (modified) (4 diffs)
• bytecode/InstanceOfStatus.h (modified) (1 diff)
• bytecode/PutByIdStatus.cpp (modified) (4 diffs)
• dfg/DFGAbstractInterpreterInlines.h (modified) (1 diff)
• dfg/DFGArgumentsEliminationPhase.cpp (modified) (9 diffs)
• dfg/DFGArgumentsUtilities.cpp (modified) (2 diffs)
• dfg/DFGArrayMode.h (modified) (1 diff)
• dfg/DFGByteCodeParser.cpp (modified) (9 diffs)
• dfg/DFGClobberize.h (modified) (3 diffs)
• dfg/DFGConstantFoldingPhase.cpp (modified) (1 diff)
• dfg/DFGFixupPhase.cpp (modified) (1 diff)
• dfg/DFGForAllKills.h (modified) (1 diff)
• dfg/DFGGraph.cpp (modified) (11 diffs)
• dfg/DFGGraph.h (modified) (5 diffs)
• dfg/DFGLiveCatchVariablePreservationPhase.cpp (modified) (3 diffs)
• dfg/DFGMinifiedNode.cpp (modified) (1 diff)
• dfg/DFGOSRAvailabilityAnalysisPhase.cpp (modified) (1 diff)
• dfg/DFGOSRExit.cpp (modified) (11 diffs)
• dfg/DFGOSRExitBase.cpp (modified) (2 diffs)
• dfg/DFGOSRExitCompilerCommon.cpp (modified) (7 diffs)
• dfg/DFGOSRExitPreparation.cpp (modified) (1 diff)
• dfg/DFGObjectAllocationSinkingPhase.cpp (modified) (1 diff)
• dfg/DFGOperations.cpp (modified) (2 diffs)
• dfg/DFGPreciseLocalClobberize.h (modified) (4 diffs)
• dfg/DFGSpeculativeJIT.cpp (modified) (9 diffs)
• dfg/DFGSpeculativeJIT32_64.cpp (modified) (2 diffs)
• dfg/DFGSpeculativeJIT64.cpp (modified) (4 diffs)
• dfg/DFGTierUpCheckInjectionPhase.cpp (modified) (3 diffs)
• dfg/DFGTypeCheckHoistingPhase.cpp (modified) (1 diff)
• dfg/DFGVariableEventStream.cpp (modified) (1 diff)
• ftl/FTLLowerDFGToB3.cpp (modified) (18 diffs)
• ftl/FTLOSRExitCompiler.cpp (modified) (1 diff)
• ftl/FTLOperations.cpp (modified) (5 diffs)
• interpreter/CallFrame.cpp (modified) (1 diff)
• interpreter/StackVisitor.cpp (modified) (6 diffs)
• interpreter/StackVisitor.h (modified) (1 diff)
• jit/AssemblyHelpers.cpp (modified) (1 diff)
• jit/AssemblyHelpers.h (modified) (3 diffs)
• jit/PCToCodeOriginMap.cpp (modified) (5 diffs)
• profiler/ProfilerOriginStack.cpp (modified) (1 diff)
• profiler/ProfilerOriginStack.h (modified) (1 diff)
• runtime/ErrorInstance.cpp (modified) (1 diff)
• runtime/SamplingProfiler.cpp (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2019-03-20  Robin Morisset  <rmorisset@apple.com>
+
+        Compress CodeOrigin into a single word in the common case
+        https://bugs.webkit.org/show_bug.cgi?id=195928
+
+        Reviewed by Saam Barati.
+
+        The trick is that pointers only take 48 bits on x86_64 in practice (and we can even use the bottom three bits of that thanks to alignment), and even less on ARM64.
+        So we can shove the bytecode index in the top bits almost all the time.
+        If the bytecodeIndex is too ginormous (1<<16 in practice on x86_64), we just set one bit at the bottom and store a pointer to some out-of-line storage instead.
+        Finally we represent an invalid bytecodeIndex (which used to be represented by UINT_MAX) by setting the second least signifcant bit.
+
+        The patch looks very long, but most of it is just replacing direct accesses to inlineCallFrame and bytecodeIndex by the relevant getters.
+
+        End result: CodeOrigin in the common case moves from 16 bytes (8 for InlineCallFrame*, 4 for unsigned bytecodeIndex, 4 of padding) to 8.
+        As a reference, during running JetStream2 we allocate more than 35M CodeOrigins. While they won't all be alive at the same time, it is still quite a lot of objects, so I am hoping for some small
+        improvement to RAMification from this work.
+
+        The one slightly tricky part is that we must implement copy and move assignment operators and constructors to make sure that any out-of-line storage belongs to a single CodeOrigin and is destroyed exactly once.
+
+        * bytecode/ByValInfo.h:
+        * bytecode/CallLinkStatus.cpp:
+        (JSC::CallLinkStatus::computeFor):
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::globalObjectFor):
+        (JSC::CodeBlock::updateOSRExitCounterAndCheckIfNeedToReoptimize):
+        (JSC::CodeBlock::bytecodeOffsetFromCallSiteIndex):
+        * bytecode/CodeOrigin.cpp:
+        (JSC::CodeOrigin::inlineDepth const):
+        (JSC::CodeOrigin::isApproximatelyEqualTo const):
+        (JSC::CodeOrigin::approximateHash const):
+        (JSC::CodeOrigin::inlineStack const):
+        (JSC::CodeOrigin::codeOriginOwner const):
+        (JSC::CodeOrigin::stackOffset const):
+        (JSC::CodeOrigin::dump const):
+        (JSC::CodeOrigin::inlineDepthForCallFrame): Deleted.
+        * bytecode/CodeOrigin.h:
+        (JSC::OutOfLineCodeOrigin::OutOfLineCodeOrigin):
+        (JSC::CodeOrigin::CodeOrigin):
+        (JSC::CodeOrigin::~CodeOrigin):
+        (JSC::CodeOrigin::isSet const):
+        (JSC::CodeOrigin::isHashTableDeletedValue const):
+        (JSC::CodeOrigin::bytecodeIndex const):
+        (JSC::CodeOrigin::inlineCallFrame const):
+        (JSC::CodeOrigin::buildCompositeValue):
+        (JSC::CodeOrigin::hash const):
+        (JSC::CodeOrigin::operator== const):
+        (JSC::CodeOrigin::exitingInlineKind const): Deleted.
+        * bytecode/DeferredSourceDump.h:
+        * bytecode/GetByIdStatus.cpp:
+        (JSC::GetByIdStatus::computeForStubInfo):
+        (JSC::GetByIdStatus::computeFor):
+        * bytecode/ICStatusMap.cpp:
+        (JSC::ICStatusContext::isInlined const):
+        * bytecode/InByIdStatus.cpp:
+        (JSC::InByIdStatus::computeFor):
+        (JSC::InByIdStatus::computeForStubInfo):
+        * bytecode/InlineCallFrame.cpp:
+        (JSC::InlineCallFrame::dumpInContext const):
+        * bytecode/InlineCallFrame.h:
+        (JSC::InlineCallFrame::computeCallerSkippingTailCalls):
+        (JSC::InlineCallFrame::getCallerInlineFrameSkippingTailCalls):
+        (JSC::baselineCodeBlockForOriginAndBaselineCodeBlock):
+        (JSC::CodeOrigin::walkUpInlineStack):
+        * bytecode/InstanceOfStatus.h:
+        * bytecode/PutByIdStatus.cpp:
+        (JSC::PutByIdStatus::computeForStubInfo):
+        (JSC::PutByIdStatus::computeFor):
+        * dfg/DFGAbstractInterpreterInlines.h:
+        (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
+        * dfg/DFGArgumentsEliminationPhase.cpp:
+        * dfg/DFGArgumentsUtilities.cpp:
+        (JSC::DFG::argumentsInvolveStackSlot):
+        (JSC::DFG::emitCodeToGetArgumentsArrayLength):
+        * dfg/DFGArrayMode.h:
+        * dfg/DFGByteCodeParser.cpp:
+        (JSC::DFG::ByteCodeParser::injectLazyOperandSpeculation):
+        (JSC::DFG::ByteCodeParser::setLocal):
+        (JSC::DFG::ByteCodeParser::setArgument):
+        (JSC::DFG::ByteCodeParser::flushForTerminalImpl):
+        (JSC::DFG::ByteCodeParser::getPredictionWithoutOSRExit):
+        (JSC::DFG::ByteCodeParser::parseBlock):
+        (JSC::DFG::ByteCodeParser::parseCodeBlock):
+        (JSC::DFG::ByteCodeParser::handlePutByVal):
+        * dfg/DFGClobberize.h:
+        (JSC::DFG::clobberize):
+        * dfg/DFGConstantFoldingPhase.cpp:
+        (JSC::DFG::ConstantFoldingPhase::foldConstants):
+        * dfg/DFGFixupPhase.cpp:
+        (JSC::DFG::FixupPhase::attemptToMakeGetArrayLength):
+        * dfg/DFGForAllKills.h:
+        (JSC::DFG::forAllKilledOperands):
+        * dfg/DFGGraph.cpp:
+        (JSC::DFG::Graph::dumpCodeOrigin):
+        (JSC::DFG::Graph::dump):
+        (JSC::DFG::Graph::isLiveInBytecode):
+        (JSC::DFG::Graph::methodOfGettingAValueProfileFor):
+        (JSC::DFG::Graph::willCatchExceptionInMachineFrame):
+        * dfg/DFGGraph.h:
+        (JSC::DFG::Graph::executableFor):
+        (JSC::DFG::Graph::isStrictModeFor):
+        (JSC::DFG::Graph::hasExitSite):
+        (JSC::DFG::Graph::forAllLocalsLiveInBytecode):
+        * dfg/DFGLiveCatchVariablePreservationPhase.cpp:
+        (JSC::DFG::LiveCatchVariablePreservationPhase::handleBlockForTryCatch):
+        * dfg/DFGMinifiedNode.cpp:
+        (JSC::DFG::MinifiedNode::fromNode):
+        * dfg/DFGOSRAvailabilityAnalysisPhase.cpp:
+        (JSC::DFG::LocalOSRAvailabilityCalculator::executeNode):
+        * dfg/DFGOSRExit.cpp:
+        (JSC::DFG::OSRExit::executeOSRExit):
+        (JSC::DFG::reifyInlinedCallFrames):
+        (JSC::DFG::adjustAndJumpToTarget):
+        (JSC::DFG::printOSRExit):
+        (JSC::DFG::OSRExit::compileExit):
+        * dfg/DFGOSRExitBase.cpp:
+        (JSC::DFG::OSRExitBase::considerAddingAsFrequentExitSiteSlow):
+        * dfg/DFGOSRExitCompilerCommon.cpp:
+        (JSC::DFG::handleExitCounts):
+        (JSC::DFG::reifyInlinedCallFrames):
+        (JSC::DFG::adjustAndJumpToTarget):
+        * dfg/DFGOSRExitPreparation.cpp:
+        (JSC::DFG::prepareCodeOriginForOSRExit):
+        * dfg/DFGObjectAllocationSinkingPhase.cpp:
+        * dfg/DFGOperations.cpp:
+        * dfg/DFGPreciseLocalClobberize.h:
+        (JSC::DFG::PreciseLocalClobberizeAdaptor::readTop):
+        * dfg/DFGSpeculativeJIT.cpp:
+        (JSC::DFG::SpeculativeJIT::emitGetLength):
+        (JSC::DFG::SpeculativeJIT::emitGetCallee):
+        (JSC::DFG::SpeculativeJIT::compileCurrentBlock):
+        (JSC::DFG::SpeculativeJIT::compileValueAdd):
+        (JSC::DFG::SpeculativeJIT::compileValueSub):
+        (JSC::DFG::SpeculativeJIT::compileValueNegate):
+        (JSC::DFG::SpeculativeJIT::compileValueMul):
+        (JSC::DFG::SpeculativeJIT::compileForwardVarargs):
+        (JSC::DFG::SpeculativeJIT::compileCreateDirectArguments):
+        * dfg/DFGSpeculativeJIT32_64.cpp:
+        (JSC::DFG::SpeculativeJIT::emitCall):
+        * dfg/DFGSpeculativeJIT64.cpp:
+        (JSC::DFG::SpeculativeJIT::emitCall):
+        (JSC::DFG::SpeculativeJIT::compile):
+        * dfg/DFGTierUpCheckInjectionPhase.cpp:
+        (JSC::DFG::TierUpCheckInjectionPhase::run):
+        (JSC::DFG::TierUpCheckInjectionPhase::canOSREnterAtLoopHint):
+        (JSC::DFG::TierUpCheckInjectionPhase::buildNaturalLoopToLoopHintMap):
+        * dfg/DFGTypeCheckHoistingPhase.cpp:
+        (JSC::DFG::TypeCheckHoistingPhase::run):
+        * dfg/DFGVariableEventStream.cpp:
+        (JSC::DFG::VariableEventStream::reconstruct const):
+        * ftl/FTLLowerDFGToB3.cpp:
+        (JSC::FTL::DFG::LowerDFGToB3::compileValueAdd):
+        (JSC::FTL::DFG::LowerDFGToB3::compileValueSub):
+        (JSC::FTL::DFG::LowerDFGToB3::compileValueMul):
+        (JSC::FTL::DFG::LowerDFGToB3::compileArithAddOrSub):
+        (JSC::FTL::DFG::LowerDFGToB3::compileValueNegate):
+        (JSC::FTL::DFG::LowerDFGToB3::compileGetMyArgumentByVal):
+        (JSC::FTL::DFG::LowerDFGToB3::compileNewArrayWithSpread):
+        (JSC::FTL::DFG::LowerDFGToB3::compileSpread):
+        (JSC::FTL::DFG::LowerDFGToB3::compileCallOrConstructVarargsSpread):
+        (JSC::FTL::DFG::LowerDFGToB3::compileCallOrConstructVarargs):
+        (JSC::FTL::DFG::LowerDFGToB3::compileForwardVarargs):
+        (JSC::FTL::DFG::LowerDFGToB3::compileForwardVarargsWithSpread):
+        (JSC::FTL::DFG::LowerDFGToB3::getArgumentsLength):
+        (JSC::FTL::DFG::LowerDFGToB3::getCurrentCallee):
+        (JSC::FTL::DFG::LowerDFGToB3::getArgumentsStart):
+        (JSC::FTL::DFG::LowerDFGToB3::codeOriginDescriptionOfCallSite const):
+        * ftl/FTLOSRExitCompiler.cpp:
+        (JSC::FTL::compileStub):
+        * ftl/FTLOperations.cpp:
+        (JSC::FTL::operationMaterializeObjectInOSR):
+        * interpreter/CallFrame.cpp:
+        (JSC::CallFrame::bytecodeOffset):
+        * interpreter/StackVisitor.cpp:
+        (JSC::StackVisitor::unwindToMachineCodeBlockFrame):
+        (JSC::StackVisitor::readFrame):
+        (JSC::StackVisitor::readNonInlinedFrame):
+        (JSC::inlinedFrameOffset):
+        (JSC::StackVisitor::readInlinedFrame):
+        * interpreter/StackVisitor.h:
+        * jit/AssemblyHelpers.cpp:
+        (JSC::AssemblyHelpers::executableFor):
+        * jit/AssemblyHelpers.h:
+        (JSC::AssemblyHelpers::isStrictModeFor):
+        (JSC::AssemblyHelpers::argumentsStart):
+        (JSC::AssemblyHelpers::argumentCount):
+        * jit/PCToCodeOriginMap.cpp:
+        (JSC::PCToCodeOriginMap::PCToCodeOriginMap):
+        (JSC::PCToCodeOriginMap::findPC const):
+        * profiler/ProfilerOriginStack.cpp:
+        (JSC::Profiler::OriginStack::OriginStack):
+        * profiler/ProfilerOriginStack.h:
+        * runtime/ErrorInstance.cpp:
+        (JSC::appendSourceToError):
+        * runtime/SamplingProfiler.cpp:
+        (JSC::SamplingProfiler::processUnverifiedStackTraces):
+
 2019-03-20  Devin Rousso  <drousso@apple.com>
 

trunk/Source/JavaScriptCore/bytecode/ByValInfo.h

@@ -28 +28 @@
 #include "ClassInfo.h"
 #include "CodeLocation.h"
-#include "CodeOrigin.h"
 #include "IndexingType.h"
 #include "JITStubRoutine.h"

trunk/Source/JavaScriptCore/bytecode/CallLinkStatus.cpp

@@ -303 +303 @@
     if (CallLinkStatusInternal::verbose)
         dataLog("Figuring out call profiling for ", codeOrigin, "\n");
-    ExitSiteData exitSiteData = computeExitSiteData(profiledBlock, codeOrigin.bytecodeIndex);
+    ExitSiteData exitSiteData = computeExitSiteData(profiledBlock, codeOrigin.bytecodeIndex());
     if (CallLinkStatusInternal::verbose) {
         dataLog("takesSlowPath = ", exitSiteData.takesSlowPath, "\n");
@@ -347 +347 @@
         auto bless = [&] (CallLinkStatus& result) {
             if (!context->isInlined(codeOrigin))
-                result.merge(computeFor(profiledBlock, codeOrigin.bytecodeIndex, baselineMap, exitSiteData));
+                result.merge(computeFor(profiledBlock, codeOrigin.bytecodeIndex(), baselineMap, exitSiteData));
         };
         
@@ -394 +394 @@
     }
     
-    return computeFor(profiledBlock, codeOrigin.bytecodeIndex, baselineMap, exitSiteData);
+    return computeFor(profiledBlock, codeOrigin.bytecodeIndex(), baselineMap, exitSiteData);
 }
 #endif

trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

@@ -2057 +2057 @@
 JSGlobalObject* CodeBlock::globalObjectFor(CodeOrigin codeOrigin)
 {
-    if (!codeOrigin.inlineCallFrame)
+    auto* inlineCallFrame = codeOrigin.inlineCallFrame();
+    if (!inlineCallFrame)
         return globalObject();
-    return codeOrigin.inlineCallFrame->baselineCodeBlock->globalObject();
+    return inlineCallFrame->baselineCodeBlock->globalObject();
 }
 
@@ -2404 +2405 @@
 
     bool didTryToEnterInLoop = false;
-    for (InlineCallFrame* inlineCallFrame = exit.m_codeOrigin.inlineCallFrame; inlineCallFrame; inlineCallFrame = inlineCallFrame->directCaller.inlineCallFrame) {
+    for (InlineCallFrame* inlineCallFrame = exit.m_codeOrigin.inlineCallFrame(); inlineCallFrame; inlineCallFrame = inlineCallFrame->directCaller.inlineCallFrame()) {
         if (inlineCallFrame->baselineCodeBlock->ownerExecutable()->didTryToEnterInLoop()) {
             didTryToEnterInLoop = true;
@@ -3176 +3177 @@
         RELEASE_ASSERT(canGetCodeOrigin(callSiteIndex));
         CodeOrigin origin = codeOrigin(callSiteIndex);
-        bytecodeOffset = origin.bytecodeIndex;
+        bytecodeOffset = origin.bytecodeIndex();
 #else
         RELEASE_ASSERT_NOT_REACHED();

trunk/Source/JavaScriptCore/bytecode/CodeOrigin.cpp

@@ -34 +34 @@
 namespace JSC {
 
-unsigned CodeOrigin::inlineDepthForCallFrame(InlineCallFrame* inlineCallFrame)
+unsigned CodeOrigin::inlineDepth() const
 {
     unsigned result = 1;
-    for (InlineCallFrame* current = inlineCallFrame; current; current = current->directCaller.inlineCallFrame)
+    for (InlineCallFrame* current = inlineCallFrame(); current; current = current->directCaller.inlineCallFrame())
         result++;
     return result;
-}
-
-unsigned CodeOrigin::inlineDepth() const
-{
-    return inlineDepthForCallFrame(inlineCallFrame);
 }
 
@@ -66 +61 @@
         ASSERT(b.isSet());
         
-        if (a.bytecodeIndex != b.bytecodeIndex)
+        if (a.bytecodeIndex() != b.bytecodeIndex())
             return false;
-        
-        bool aHasInlineCallFrame = !!a.inlineCallFrame && a.inlineCallFrame != terminal;
-        bool bHasInlineCallFrame = !!b.inlineCallFrame;
+
+        auto* aInlineCallFrame = a.inlineCallFrame();
+        auto* bInlineCallFrame = b.inlineCallFrame();
+        bool aHasInlineCallFrame = !!aInlineCallFrame && aInlineCallFrame != terminal;
+        bool bHasInlineCallFrame = !!bInlineCallFrame;
         if (aHasInlineCallFrame != bHasInlineCallFrame)
             return false;
@@ -77 +74 @@
             return true;
         
-        if (a.inlineCallFrame->baselineCodeBlock.get() != b.inlineCallFrame->baselineCodeBlock.get())
+        if (aInlineCallFrame->baselineCodeBlock.get() != bInlineCallFrame->baselineCodeBlock.get())
             return false;
         
-        a = a.inlineCallFrame->directCaller;
-        b = b.inlineCallFrame->directCaller;
+        a = aInlineCallFrame->directCaller;
+        b = bInlineCallFrame->directCaller;
     }
 }
@@ -95 +92 @@
     CodeOrigin codeOrigin = *this;
     for (;;) {
-        result += codeOrigin.bytecodeIndex;
-        
-        if (!codeOrigin.inlineCallFrame)
+        result += codeOrigin.bytecodeIndex();
+
+        auto* inlineCallFrame = codeOrigin.inlineCallFrame();
+
+        if (!inlineCallFrame)
             return result;
         
-        if (codeOrigin.inlineCallFrame == terminal)
+        if (inlineCallFrame == terminal)
             return result;
         
-        result += WTF::PtrHash<JSCell*>::hash(codeOrigin.inlineCallFrame->baselineCodeBlock.get());
+        result += WTF::PtrHash<JSCell*>::hash(inlineCallFrame->baselineCodeBlock.get());
         
-        codeOrigin = codeOrigin.inlineCallFrame->directCaller;
+        codeOrigin = inlineCallFrame->directCaller;
     }
 }
@@ -114 +113 @@
     result.last() = *this;
     unsigned index = result.size() - 2;
-    for (InlineCallFrame* current = inlineCallFrame; current; current = current->directCaller.inlineCallFrame)
+    for (InlineCallFrame* current = inlineCallFrame(); current; current = current->directCaller.inlineCallFrame())
         result[index--] = current->directCaller;
-    RELEASE_ASSERT(!result[0].inlineCallFrame);
+    RELEASE_ASSERT(!result[0].inlineCallFrame());
     return result;
 }
@@ -122 +121 @@
 CodeBlock* CodeOrigin::codeOriginOwner() const
 {
+    auto* inlineCallFrame = this->inlineCallFrame();
     if (!inlineCallFrame)
-        return 0;
+        return nullptr;
     return inlineCallFrame->baselineCodeBlock.get();
 }
@@ -129 +129 @@
 int CodeOrigin::stackOffset() const
 {
+    auto* inlineCallFrame = this->inlineCallFrame();
     if (!inlineCallFrame)
         return 0;
-    
     return inlineCallFrame->stackOffset;
 }
@@ -147 +147 @@
             out.print(" --> ");
         
-        if (InlineCallFrame* frame = stack[i].inlineCallFrame) {
+        if (InlineCallFrame* frame = stack[i].inlineCallFrame()) {
             out.print(frame->briefFunctionInformation(), ":<", RawPointer(frame->baselineCodeBlock.get()), "> ");
             if (frame->isClosureCall)
@@ -153 +153 @@
         }
         
-        out.print("bc#", stack[i].bytecodeIndex);
+        out.print("bc#", stack[i].bytecodeIndex());
     }
 }

trunk/Source/JavaScriptCore/bytecode/CodeOrigin.h

@@ -26 +26 @@
 #pragma once
 
-#include "CodeBlockHash.h"
-#include "ExitingInlineKind.h"
 #include <limits.h>
 #include <wtf/HashMap.h>
@@ -40 +38 @@
 struct InlineCallFrame;
 
-struct CodeOrigin {
-    static const unsigned invalidBytecodeIndex = UINT_MAX;
-    
-    // Bytecode offset that you'd use to re-execute this instruction, and the
-    // bytecode index of the bytecode instruction that produces some result that
-    // you're interested in (used for mapping Nodes whose values you're using
-    // to bytecode instructions that have the appropriate value profile).
-    unsigned bytecodeIndex;
-    
-    InlineCallFrame* inlineCallFrame;
-    
+class CodeOrigin {
+public:
     CodeOrigin()
-        : bytecodeIndex(invalidBytecodeIndex)
-        , inlineCallFrame(0)
+#if CPU(ADDRESS64)
+        : m_compositeValue(buildCompositeValue(nullptr, s_invalidBytecodeIndex))
+#else
+        : m_bytecodeIndex(s_invalidBytecodeIndex)
+        , m_inlineCallFrame(nullptr)
+#endif
     {
     }
     
     CodeOrigin(WTF::HashTableDeletedValueType)
-        : bytecodeIndex(invalidBytecodeIndex)
-        , inlineCallFrame(deletedMarker())
-    {
-    }
-    
-    explicit CodeOrigin(unsigned bytecodeIndex, InlineCallFrame* inlineCallFrame = 0)
-        : bytecodeIndex(bytecodeIndex)
-        , inlineCallFrame(inlineCallFrame)
-    {
-        ASSERT(bytecodeIndex < invalidBytecodeIndex);
-    }
-    
-    bool isSet() const { return bytecodeIndex != invalidBytecodeIndex; }
+#if CPU(ADDRESS64)
+        : m_compositeValue(buildCompositeValue(deletedMarker(), s_invalidBytecodeIndex))
+#else
+        : m_bytecodeIndex(s_invalidBytecodeIndex)
+        , m_inlineCallFrame(deletedMarker())
+#endif
+    {
+    }
+    
+    explicit CodeOrigin(unsigned bytecodeIndex, InlineCallFrame* inlineCallFrame = nullptr)
+#if CPU(ADDRESS64)
+        : m_compositeValue(buildCompositeValue(inlineCallFrame, bytecodeIndex))
+#else
+        : m_bytecodeIndex(bytecodeIndex)
+        , m_inlineCallFrame(inlineCallFrame)
+#endif
+    {
+        ASSERT(bytecodeIndex < s_invalidBytecodeIndex);
+#if CPU(ADDRESS64)
+        ASSERT(!(bitwise_cast<uintptr_t>(inlineCallFrame) & ~s_maskCompositeValueForPointer));
+#endif
+    }
+    
+#if CPU(ADDRESS64)
+    CodeOrigin& operator=(const CodeOrigin& other)
+    {
+        if (this != &other) {
+            if (UNLIKELY(isOutOfLine()))
+                delete outOfLineCodeOrigin();
+            
+            if (UNLIKELY(other.isOutOfLine()))
+                m_compositeValue = buildCompositeValue(other.inlineCallFrame(), other.bytecodeIndex());
+            else
+                m_compositeValue = other.m_compositeValue;
+        }
+        return *this;
+    }
+    CodeOrigin& operator=(CodeOrigin&& other)
+    {
+        if (this != &other) {
+            if (UNLIKELY(isOutOfLine()))
+                delete outOfLineCodeOrigin();
+
+            m_compositeValue = std::exchange(other.m_compositeValue, 0);
+        }
+        return *this;
+    }
+
+    CodeOrigin(const CodeOrigin& other)
+    {
+        // We don't use the member initializer list because it would not let us optimize the common case where there is no out-of-line storage
+        // (in which case we don't have to extract the components of the composite value just to reassemble it).
+        if (UNLIKELY(other.isOutOfLine()))
+            m_compositeValue = buildCompositeValue(other.inlineCallFrame(), other.bytecodeIndex());
+        else
+            m_compositeValue = other.m_compositeValue;
+    }
+    CodeOrigin(CodeOrigin&& other)
+        : m_compositeValue(std::exchange(other.m_compositeValue, 0))
+    {
+    }
+
+    ~CodeOrigin()
+    {
+        if (UNLIKELY(isOutOfLine()))
+            delete outOfLineCodeOrigin();
+    }
+#endif
+    
+    bool isSet() const
+    {
+#if CPU(ADDRESS64)
+        return !(m_compositeValue & s_maskIsBytecodeIndexInvalid);
+#else
+        return m_bytecodeIndex != s_invalidBytecodeIndex;
+#endif
+    }
     explicit operator bool() const { return isSet(); }
     
     bool isHashTableDeletedValue() const
     {
-        return bytecodeIndex == invalidBytecodeIndex && !!inlineCallFrame;
+#if CPU(ADDRESS64)
+        return !isSet() && (m_compositeValue & s_maskCompositeValueForPointer);
+#else
+        return m_bytecodeIndex == s_invalidBytecodeIndex && !!m_inlineCallFrame;
+#endif
     }
     
@@ -88 +149 @@
     int stackOffset() const;
     
-    static unsigned inlineDepthForCallFrame(InlineCallFrame*);
-    
-    ExitingInlineKind exitingInlineKind() const
-    {
-        return inlineCallFrame ? ExitFromInlined : ExitFromNotInlined;
-    }
-    
     unsigned hash() const;
     bool operator==(const CodeOrigin& other) const;
@@ -113 +167 @@
     JS_EXPORT_PRIVATE void dump(PrintStream&) const;
     void dumpInContext(PrintStream&, DumpContext*) const;
-    
+
+    unsigned bytecodeIndex() const
+    {
+#if CPU(ADDRESS64)
+        if (!isSet())
+            return s_invalidBytecodeIndex;
+        if (UNLIKELY(isOutOfLine()))
+            return outOfLineCodeOrigin()->bytecodeIndex;
+        return m_compositeValue >> (64 - s_freeBitsAtTop);
+#else
+        return m_bytecodeIndex;
+#endif
+    }
+
+    InlineCallFrame* inlineCallFrame() const
+    {
+#if CPU(ADDRESS64)
+        if (UNLIKELY(isOutOfLine()))
+            return outOfLineCodeOrigin()->inlineCallFrame;
+        return bitwise_cast<InlineCallFrame*>(m_compositeValue & s_maskCompositeValueForPointer);
+#else
+        return m_inlineCallFrame;
+#endif
+    }
+
 private:
+    static constexpr unsigned s_invalidBytecodeIndex = UINT_MAX;
+
+#if CPU(ADDRESS64)
+    static constexpr uintptr_t s_maskIsOutOfLine = 1;
+    static constexpr uintptr_t s_maskIsBytecodeIndexInvalid = 2;
+
+    struct OutOfLineCodeOrigin {
+        WTF_MAKE_FAST_ALLOCATED;
+    public:
+        InlineCallFrame* inlineCallFrame;
+        unsigned bytecodeIndex;
+        
+        OutOfLineCodeOrigin(InlineCallFrame* inlineCallFrame, unsigned bytecodeIndex)
+            : inlineCallFrame(inlineCallFrame)
+            , bytecodeIndex(bytecodeIndex)
+        {
+        }
+    };
+    
+    bool isOutOfLine() const
+    {
+        return m_compositeValue & s_maskIsOutOfLine;
+    }
+    OutOfLineCodeOrigin* outOfLineCodeOrigin() const
+    {
+        ASSERT(isOutOfLine());
+        return bitwise_cast<OutOfLineCodeOrigin*>(m_compositeValue & s_maskCompositeValueForPointer);
+    }
+#endif
+
     static InlineCallFrame* deletedMarker()
     {
-        return bitwise_cast<InlineCallFrame*>(static_cast<uintptr_t>(1));
-    }
+        auto value = static_cast<uintptr_t>(1 << 3);
+#if CPU(ADDRESS64)
+        ASSERT(value & s_maskCompositeValueForPointer);
+        ASSERT(!(value & ~s_maskCompositeValueForPointer));
+#endif
+        return bitwise_cast<InlineCallFrame*>(value);
+    }
+
+#if CPU(X86_64) && CPU(ADDRESS64)
+    static constexpr unsigned s_freeBitsAtTop = 16;
+    static constexpr uintptr_t s_maskCompositeValueForPointer = 0x0000fffffffffff8;
+#elif CPU(ARM64) && CPU(ADDRESS64)
+    static constexpr unsigned s_freeBitsAtTop = 28;
+    static constexpr uintptr_t s_maskCompositeValueForPointer = 0x0000000ffffffff8;
+#endif
+#if CPU(ADDRESS64)
+    static uintptr_t buildCompositeValue(InlineCallFrame* inlineCallFrame, unsigned bytecodeIndex)
+    {
+        if (bytecodeIndex == s_invalidBytecodeIndex)
+            return bitwise_cast<uintptr_t>(inlineCallFrame) | s_maskIsBytecodeIndexInvalid;
+
+        if (UNLIKELY(bytecodeIndex >= 1 << s_freeBitsAtTop)) {
+            auto* outOfLine = new OutOfLineCodeOrigin(inlineCallFrame, bytecodeIndex);
+            return bitwise_cast<uintptr_t>(outOfLine) | s_maskIsOutOfLine;
+        }
+
+        uintptr_t encodedBytecodeIndex = static_cast<uintptr_t>(bytecodeIndex) << (64 - s_freeBitsAtTop);
+        ASSERT(!(encodedBytecodeIndex & bitwise_cast<uintptr_t>(inlineCallFrame)));
+        return encodedBytecodeIndex | bitwise_cast<uintptr_t>(inlineCallFrame);
+    }
+
+    // The bottom bit indicates whether to look at an out-of-line implementation (because of a bytecode index which is too big for us to store).
+    // The next bit indicates whether this is an invalid bytecode (which depending on the InlineCallFrame* can either indicate an unset CodeOrigin,
+    // or a deletion marker for a hash table).
+    // The next bit is free
+    // The next 64-s_freeBitsAtTop-3 are the InlineCallFrame* or the OutOfLineCodeOrigin*
+    // Finally the last s_freeBitsAtTop are the bytecodeIndex if it is inline
+    uintptr_t m_compositeValue;
+#else
+    unsigned m_bytecodeIndex;
+    InlineCallFrame* m_inlineCallFrame;
+#endif
 };
 
 inline unsigned CodeOrigin::hash() const
 {
-    return WTF::IntHash<unsigned>::hash(bytecodeIndex) +
-        WTF::PtrHash<InlineCallFrame*>::hash(inlineCallFrame);
+    return WTF::IntHash<unsigned>::hash(bytecodeIndex()) +
+        WTF::PtrHash<InlineCallFrame*>::hash(inlineCallFrame());
 }
 
 inline bool CodeOrigin::operator==(const CodeOrigin& other) const
 {
-    return bytecodeIndex == other.bytecodeIndex
-        && inlineCallFrame == other.inlineCallFrame;
+#if CPU(ADDRESS64)
+    if (m_compositeValue == other.m_compositeValue)
+        return true;
+#endif
+    return bytecodeIndex() == other.bytecodeIndex()
+        && inlineCallFrame() == other.inlineCallFrame();
 }
 

trunk/Source/JavaScriptCore/bytecode/DeferredSourceDump.h

@@ -26 +26 @@
 #pragma once
 
-#include "CodeOrigin.h"
 #include "JITCode.h"
 #include "Strong.h"

trunk/Source/JavaScriptCore/bytecode/GetByIdStatus.cpp

@@ -131 +131 @@
 GetByIdStatus GetByIdStatus::computeForStubInfo(const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, StructureStubInfo* stubInfo, CodeOrigin codeOrigin, UniquedStringImpl* uid)
 {
+    unsigned bytecodeIndex = codeOrigin.bytecodeIndex();
     GetByIdStatus result = GetByIdStatus::computeForStubInfoWithoutExitSiteFeedback(
         locker, profiledBlock, stubInfo, uid,
-        CallLinkStatus::computeExitSiteData(profiledBlock, codeOrigin.bytecodeIndex));
-
-    if (!result.takesSlowPath() && hasBadCacheExitSite(profiledBlock, codeOrigin.bytecodeIndex))
+        CallLinkStatus::computeExitSiteData(profiledBlock, bytecodeIndex));
+
+    if (!result.takesSlowPath() && hasBadCacheExitSite(profiledBlock, bytecodeIndex))
         return result.slowVersion();
     return result;
@@ -303 +304 @@
     ICStatusContextStack& icContextStack, CodeOrigin codeOrigin, UniquedStringImpl* uid)
 {
-    CallLinkStatus::ExitSiteData callExitSiteData =
-        CallLinkStatus::computeExitSiteData(profiledBlock, codeOrigin.bytecodeIndex);
-    ExitFlag didExit = hasBadCacheExitSite(profiledBlock, codeOrigin.bytecodeIndex);
+    unsigned bytecodeIndex = codeOrigin.bytecodeIndex();
+    CallLinkStatus::ExitSiteData callExitSiteData = CallLinkStatus::computeExitSiteData(profiledBlock, bytecodeIndex);
+    ExitFlag didExit = hasBadCacheExitSite(profiledBlock, bytecodeIndex);
     
     for (ICStatusContext* context : icContextStack) {
@@ -315 +316 @@
                 // inlined and not-inlined.
                 GetByIdStatus baselineResult = computeFor(
-                    profiledBlock, baselineMap, codeOrigin.bytecodeIndex, uid, didExit,
+                    profiledBlock, baselineMap, bytecodeIndex, uid, didExit,
                     callExitSiteData);
                 baselineResult.merge(result);
@@ -340 +341 @@
     }
     
-    return computeFor(profiledBlock, baselineMap, codeOrigin.bytecodeIndex, uid, didExit, callExitSiteData);
+    return computeFor(profiledBlock, baselineMap, bytecodeIndex, uid, didExit, callExitSiteData);
 }
 

trunk/Source/JavaScriptCore/bytecode/ICStatusMap.cpp

@@ -40 +40 @@
 bool ICStatusContext::isInlined(CodeOrigin codeOrigin) const
 {
-    return codeOrigin.inlineCallFrame && codeOrigin.inlineCallFrame != inlineCallFrame;
+    auto* originInlineCallFrame = codeOrigin.inlineCallFrame();
+    return originInlineCallFrame && originInlineCallFrame != inlineCallFrame;
 }
 

trunk/Source/JavaScriptCore/bytecode/InByIdStatus.cpp

@@ -74 +74 @@
     ICStatusContextStack& contextStack, CodeOrigin codeOrigin, UniquedStringImpl* uid)
 {
-    ExitFlag didExit = hasBadCacheExitSite(profiledBlock, codeOrigin.bytecodeIndex);
+    unsigned bytecodeIndex = codeOrigin.bytecodeIndex();
+    ExitFlag didExit = hasBadCacheExitSite(profiledBlock, bytecodeIndex);
     
     for (ICStatusContext* context : contextStack) {
@@ -82 +83 @@
             if (!context->isInlined(codeOrigin)) {
                 InByIdStatus baselineResult = computeFor(
-                    profiledBlock, baselineMap, codeOrigin.bytecodeIndex, uid, didExit);
+                    profiledBlock, baselineMap, bytecodeIndex, uid, didExit);
                 baselineResult.merge(result);
                 return baselineResult;
@@ -107 +108 @@
     }
     
-    return computeFor(profiledBlock, baselineMap, codeOrigin.bytecodeIndex, uid, didExit);
+    return computeFor(profiledBlock, baselineMap, bytecodeIndex, uid, didExit);
 }
 #endif // ENABLE(JIT)
@@ -116 +117 @@
     InByIdStatus result = InByIdStatus::computeForStubInfoWithoutExitSiteFeedback(locker, stubInfo, uid);
 
-    if (!result.takesSlowPath() && hasBadCacheExitSite(profiledBlock, codeOrigin.bytecodeIndex))
+    if (!result.takesSlowPath() && hasBadCacheExitSite(profiledBlock, codeOrigin.bytecodeIndex()))
         return InByIdStatus(TakesSlowPath);
     return result;

trunk/Source/JavaScriptCore/bytecode/InlineCallFrame.cpp

@@ -70 +70 @@
     if (isStrictMode())
         out.print(" (StrictMode)");
-    out.print(", bc#", directCaller.bytecodeIndex, ", ", static_cast<Kind>(kind));
+    out.print(", bc#", directCaller.bytecodeIndex(), ", ", static_cast<Kind>(kind));
     if (isClosureCall)
         out.print(", closure call");

trunk/Source/JavaScriptCore/bytecode/InlineCallFrame.h

@@ -153 +153 @@
             callKind = inlineCallFrame->kind;
             codeOrigin = &inlineCallFrame->directCaller;
-            inlineCallFrame = codeOrigin->inlineCallFrame;
+            inlineCallFrame = codeOrigin->inlineCallFrame();
         } while (inlineCallFrame && tailCallee);
 
@@ -173 +173 @@
     {
         CodeOrigin* caller = getCallerSkippingTailCalls();
-        return caller ? caller->inlineCallFrame : nullptr;
+        return caller ? caller->inlineCallFrame() : nullptr;
     }
     
@@ -242 +242 @@
 {
     ASSERT(baselineCodeBlock->jitType() == JITCode::BaselineJIT);
-    if (codeOrigin.inlineCallFrame)
-        return baselineCodeBlockForInlineCallFrame(codeOrigin.inlineCallFrame);
+    auto* inlineCallFrame = codeOrigin.inlineCallFrame();
+    if (inlineCallFrame)
+        return baselineCodeBlockForInlineCallFrame(inlineCallFrame);
     return baselineCodeBlock;
 }
 
+// This function is defined here and not in CodeOrigin because it needs access to the directCaller field in InlineCallFrame
 template <typename Function>
 inline void CodeOrigin::walkUpInlineStack(const Function& function)
@@ -253 +255 @@
     while (true) {
         function(codeOrigin);
-        if (!codeOrigin.inlineCallFrame)
+        auto* inlineCallFrame = codeOrigin.inlineCallFrame();
+        if (!inlineCallFrame)
             break;
-        codeOrigin = codeOrigin.inlineCallFrame->directCaller;
+        codeOrigin = inlineCallFrame->directCaller;
     }
 }

trunk/Source/JavaScriptCore/bytecode/InstanceOfStatus.h

@@ -26 +26 @@
 #pragma once
 
-#include "CodeOrigin.h"
 #include "ConcurrentJSLock.h"
 #include "ICStatusMap.h"

trunk/Source/JavaScriptCore/bytecode/PutByIdStatus.cpp

@@ -123 +123 @@
     return computeForStubInfo(
         locker, baselineBlock, stubInfo, uid,
-        CallLinkStatus::computeExitSiteData(baselineBlock, codeOrigin.bytecodeIndex));
+        CallLinkStatus::computeExitSiteData(baselineBlock, codeOrigin.bytecodeIndex()));
 }
 
@@ -238 +238 @@
 PutByIdStatus PutByIdStatus::computeFor(CodeBlock* baselineBlock, ICStatusMap& baselineMap, ICStatusContextStack& contextStack, CodeOrigin codeOrigin, UniquedStringImpl* uid)
 {
-    CallLinkStatus::ExitSiteData callExitSiteData =
-        CallLinkStatus::computeExitSiteData(baselineBlock, codeOrigin.bytecodeIndex);
-    ExitFlag didExit = hasBadCacheExitSite(baselineBlock, codeOrigin.bytecodeIndex);
+    unsigned bytecodeIndex = codeOrigin.bytecodeIndex();
+    CallLinkStatus::ExitSiteData callExitSiteData = CallLinkStatus::computeExitSiteData(baselineBlock, bytecodeIndex);
+    ExitFlag didExit = hasBadCacheExitSite(baselineBlock, bytecodeIndex);
 
     for (ICStatusContext* context : contextStack) {
@@ -248 +248 @@
             if (!context->isInlined(codeOrigin)) {
                 PutByIdStatus baselineResult = computeFor(
-                    baselineBlock, baselineMap, codeOrigin.bytecodeIndex, uid, didExit,
+                    baselineBlock, baselineMap, bytecodeIndex, uid, didExit,
                     callExitSiteData);
                 baselineResult.merge(result);
@@ -273 +273 @@
     }
     
-    return computeFor(baselineBlock, baselineMap, codeOrigin.bytecodeIndex, uid, didExit, callExitSiteData);
+    return computeFor(baselineBlock, baselineMap, bytecodeIndex, uid, didExit, callExitSiteData);
 }
 

trunk/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h

@@ -2214 +2214 @@
     case GetMyArgumentByValOutOfBounds: {
         JSValue index = forNode(node->child2()).m_value;
-        InlineCallFrame* inlineCallFrame = node->child1()->origin.semantic.inlineCallFrame;
+        InlineCallFrame* inlineCallFrame = node->child1()->origin.semantic.inlineCallFrame();
 
         if (index && index.isUInt32()) {

trunk/Source/JavaScriptCore/dfg/DFGArgumentsEliminationPhase.cpp

@@ -530 +530 @@
                     Operands<bool>& clobberedByThisBlock = clobberedByBlock[block];
                     
-                    if (InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame) {
+                    if (InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame()) {
                         if (inlineCallFrame->isVarargs()) {
                             isClobberedByBlock |= clobberedByThisBlock.operand(
@@ -760 +760 @@
                     if (m_graph.varArgChild(node, 1)->isInt32Constant()) {
                         unsigned index = m_graph.varArgChild(node, 1)->asUInt32();
-                        InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame;
+                        InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame();
                         index += numberOfArgumentsToSkip;
                         
@@ -862 +862 @@
 
                             ASSERT(candidate->op() == PhantomCreateRest);
-                            InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame;
+                            InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame();
                             return inlineCallFrame && !inlineCallFrame->isVarargs();
                         });
@@ -888 +888 @@
                                 ASSERT(candidate->op() == PhantomCreateRest);
                                 unsigned numberOfArgumentsToSkip = candidate->numberOfArgumentsToSkip();
-                                InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame;
+                                InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame();
                                 unsigned frameArgumentCount = inlineCallFrame->argumentCountIncludingThis - 1;
                                 if (frameArgumentCount >= numberOfArgumentsToSkip)
@@ -936 +936 @@
                                     ASSERT(candidate->op() == PhantomCreateRest);
                                     unsigned numberOfArgumentsToSkip = candidate->numberOfArgumentsToSkip();
-                                    InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame;
+                                    InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame();
                                     unsigned frameArgumentCount = inlineCallFrame->argumentCountIncludingThis - 1;
                                     for (unsigned loadIndex = numberOfArgumentsToSkip; loadIndex < frameArgumentCount; ++loadIndex) {
@@ -971 +971 @@
                         varargsData->offset += numberOfArgumentsToSkip;
 
-                        InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame;
+                        InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame();
 
                         if (inlineCallFrame
@@ -1112 +1112 @@
 
                             ASSERT(candidate->op() == PhantomCreateRest);
-                            InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame;
+                            InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame();
                             return inlineCallFrame && !inlineCallFrame->isVarargs();
                         });
@@ -1151 +1151 @@
 
                                 ASSERT(candidate->op() == PhantomCreateRest);
-                                InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame;
+                                InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame();
                                 unsigned numberOfArgumentsToSkip = candidate->numberOfArgumentsToSkip();
                                 for (unsigned i = 1 + numberOfArgumentsToSkip; i < inlineCallFrame->argumentCountIncludingThis; ++i) {
@@ -1176 +1176 @@
                         varargsData->firstVarArgOffset += numberOfArgumentsToSkip;
 
-                        InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame;
+                        InlineCallFrame* inlineCallFrame = candidate->origin.semantic.inlineCallFrame();
                         if (inlineCallFrame && !inlineCallFrame->isVarargs()) {
                             Vector<Node*> arguments;

trunk/Source/JavaScriptCore/dfg/DFGArgumentsUtilities.cpp

@@ -55 +55 @@
 bool argumentsInvolveStackSlot(Node* candidate, VirtualRegister reg)
 {
-    return argumentsInvolveStackSlot(candidate->origin.semantic.inlineCallFrame, reg);
+    return argumentsInvolveStackSlot(candidate->origin.semantic.inlineCallFrame(), reg);
 }
 
@@ -107 +107 @@
     }
     
-    InlineCallFrame* inlineCallFrame = arguments->origin.semantic.inlineCallFrame;
+    InlineCallFrame* inlineCallFrame = arguments->origin.semantic.inlineCallFrame();
 
     unsigned numberOfArgumentsToSkip = 0;

trunk/Source/JavaScriptCore/dfg/DFGArrayMode.h

@@ -33 +33 @@
 namespace JSC {
 
-struct CodeOrigin;
+class CodeOrigin;
 
 namespace DFG {

trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp

@@ -386 +386 @@
     {
         ASSERT(node->op() == GetLocal);
-        ASSERT(node->origin.semantic.bytecodeIndex == m_currentIndex);
+        ASSERT(node->origin.semantic.bytecodeIndex() == m_currentIndex);
         ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
         LazyOperandValueProfileKey key(m_currentIndex, node->local());
@@ -443 +443 @@
         VariableAccessData* variableAccessData = newVariableAccessData(operand);
         variableAccessData->mergeStructureCheckHoistingFailed(
-            m_inlineStackTop->m_exitProfile.hasExitSite(semanticOrigin.bytecodeIndex, BadCache));
+            m_inlineStackTop->m_exitProfile.hasExitSite(semanticOrigin.bytecodeIndex(), BadCache));
         variableAccessData->mergeCheckArrayHoistingFailed(
-            m_inlineStackTop->m_exitProfile.hasExitSite(semanticOrigin.bytecodeIndex, BadIndexingType));
+            m_inlineStackTop->m_exitProfile.hasExitSite(semanticOrigin.bytecodeIndex(), BadIndexingType));
         Node* node = addToGraph(SetLocal, OpInfo(variableAccessData), value);
         m_currentBlock->variablesAtTail.local(local) = node;
@@ -499 +499 @@
         
         variableAccessData->mergeStructureCheckHoistingFailed(
-            m_inlineStackTop->m_exitProfile.hasExitSite(semanticOrigin.bytecodeIndex, BadCache));
+            m_inlineStackTop->m_exitProfile.hasExitSite(semanticOrigin.bytecodeIndex(), BadCache));
         variableAccessData->mergeCheckArrayHoistingFailed(
-            m_inlineStackTop->m_exitProfile.hasExitSite(semanticOrigin.bytecodeIndex, BadIndexingType));
+            m_inlineStackTop->m_exitProfile.hasExitSite(semanticOrigin.bytecodeIndex(), BadIndexingType));
         Node* node = addToGraph(SetLocal, OpInfo(variableAccessData), value);
         m_currentBlock->variablesAtTail.argument(argument) = node;
@@ -564 +564 @@
         origin.walkUpInlineStack(
             [&] (CodeOrigin origin) {
-                unsigned bytecodeIndex = origin.bytecodeIndex;
-                InlineCallFrame* inlineCallFrame = origin.inlineCallFrame;
+                unsigned bytecodeIndex = origin.bytecodeIndex();
+                InlineCallFrame* inlineCallFrame = origin.inlineCallFrame();
                 flushImpl(inlineCallFrame, addFlushDirect);
 
@@ -869 +869 @@
 
             InlineStackEntry* stack = m_inlineStackTop;
-            while (stack->m_inlineCallFrame != codeOrigin->inlineCallFrame)
+            while (stack->m_inlineCallFrame != codeOrigin->inlineCallFrame())
                 stack = stack->m_caller;
 
-            bytecodeIndex = codeOrigin->bytecodeIndex;
+            bytecodeIndex = codeOrigin->bytecodeIndex();
             CodeBlock* profiledBlock = stack->m_profiledBlock;
             ConcurrentJSLocker locker(profiledBlock->m_lock);
@@ -5397 +5397 @@
             {
                 ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
-                ByValInfo* byValInfo = m_inlineStackTop->m_baselineMap.get(CodeOrigin(currentCodeOrigin().bytecodeIndex)).byValInfo;
+                ByValInfo* byValInfo = m_inlineStackTop->m_baselineMap.get(CodeOrigin(currentCodeOrigin().bytecodeIndex())).byValInfo;
                 // FIXME: When the bytecode is not compiled in the baseline JIT, byValInfo becomes null.
                 // At that time, there is no information.
@@ -6027 +6027 @@
 
                     Node* setArgument = addToGraph(SetArgument, OpInfo(variable));
-                    setArgument->origin.forExit.bytecodeIndex = exitBytecodeIndex;
+                    setArgument->origin.forExit = CodeOrigin(exitBytecodeIndex, setArgument->origin.forExit.inlineCallFrame());
                     m_currentBlock->variablesAtTail.setArgumentFirstTime(argument, setArgument);
                     entrypointArguments[argument] = setArgument;
@@ -7089 +7089 @@
         Vector<DeferredSourceDump>& deferredSourceDump = m_graph.m_plan.callback()->ensureDeferredSourceDump();
         if (inlineCallFrame()) {
-            DeferredSourceDump dump(codeBlock->baselineVersion(), m_codeBlock, JITCode::DFGJIT, inlineCallFrame()->directCaller.bytecodeIndex);
+            DeferredSourceDump dump(codeBlock->baselineVersion(), m_codeBlock, JITCode::DFGJIT, inlineCallFrame()->directCaller.bytecodeIndex());
             deferredSourceDump.append(dump);
         } else
@@ -7177 +7177 @@
         {
             ConcurrentJSLocker locker(m_inlineStackTop->m_profiledBlock->m_lock);
-            ByValInfo* byValInfo = m_inlineStackTop->m_baselineMap.get(CodeOrigin(currentCodeOrigin().bytecodeIndex)).byValInfo;
+            ByValInfo* byValInfo = m_inlineStackTop->m_baselineMap.get(CodeOrigin(currentCodeOrigin().bytecodeIndex())).byValInfo;
             // FIXME: When the bytecode is not compiled in the baseline JIT, byValInfo becomes null.
             // At that time, there is no information.

trunk/Source/JavaScriptCore/dfg/DFGClobberize.h

@@ -111 +111 @@
     // to the runtime, and that call may walk stack. Therefore, each node must read() anything that a stack
     // scan would read. That's what this does.
-    for (InlineCallFrame* inlineCallFrame = node->origin.semantic.inlineCallFrame; inlineCallFrame; inlineCallFrame = inlineCallFrame->directCaller.inlineCallFrame) {
+    for (InlineCallFrame* inlineCallFrame = node->origin.semantic.inlineCallFrame(); inlineCallFrame; inlineCallFrame = inlineCallFrame->directCaller.inlineCallFrame()) {
         if (inlineCallFrame->isClosureCall)
             read(AbstractHeap(Stack, inlineCallFrame->stackOffset + CallFrameSlot::callee));
@@ -124 +124 @@
     // a scope which is expected to be flushed to the stack.
     if (graph.hasDebuggerEnabled()) {
-        ASSERT(!node->origin.semantic.inlineCallFrame);
+        ASSERT(!node->origin.semantic.inlineCallFrame());
         read(AbstractHeap(Stack, graph.m_codeBlock->scopeRegister()));
     }
@@ -711 +711 @@
 
     case CallEval:
-        ASSERT(!node->origin.semantic.inlineCallFrame);
+        ASSERT(!node->origin.semantic.inlineCallFrame());
         read(AbstractHeap(Stack, graph.m_codeBlock->scopeRegister()));
         read(AbstractHeap(Stack, virtualRegisterForArgument(0)));

trunk/Source/JavaScriptCore/dfg/DFGConstantFoldingPhase.cpp

@@ -364 +364 @@
                 unsigned index = checkedIndex.unsafeGet();
                 Node* arguments = node->child1().node();
-                InlineCallFrame* inlineCallFrame = arguments->origin.semantic.inlineCallFrame;
+                InlineCallFrame* inlineCallFrame = arguments->origin.semantic.inlineCallFrame();
                 
                 // Don't try to do anything if the index is known to be outside our static bounds. Note

trunk/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp

@@ -3431 +3431 @@
         CodeBlock* profiledBlock = m_graph.baselineCodeBlockFor(node->origin.semantic);
         ArrayProfile* arrayProfile = 
-            profiledBlock->getArrayProfile(node->origin.semantic.bytecodeIndex);
+            profiledBlock->getArrayProfile(node->origin.semantic.bytecodeIndex());
         ArrayMode arrayMode = ArrayMode(Array::SelectUsingPredictions, Array::Read);
         if (arrayProfile) {

trunk/Source/JavaScriptCore/dfg/DFGForAllKills.h

@@ -69 +69 @@
     // It's easier to do this if the inline call frames are the same. This is way faster than the
     // other loop, below.
-    if (before.inlineCallFrame == after.inlineCallFrame) {
-        int stackOffset = before.inlineCallFrame ? before.inlineCallFrame->stackOffset : 0;
-        CodeBlock* codeBlock = graph.baselineCodeBlockFor(before.inlineCallFrame);
+    auto* beforeInlineCallFrame = before.inlineCallFrame();
+    if (beforeInlineCallFrame == after.inlineCallFrame()) {
+        int stackOffset = beforeInlineCallFrame ? beforeInlineCallFrame->stackOffset : 0;
+        CodeBlock* codeBlock = graph.baselineCodeBlockFor(beforeInlineCallFrame);
         FullBytecodeLiveness& fullLiveness = graph.livenessFor(codeBlock);
-        const FastBitVector& liveBefore = fullLiveness.getLiveness(before.bytecodeIndex);
-        const FastBitVector& liveAfter = fullLiveness.getLiveness(after.bytecodeIndex);
+        const FastBitVector& liveBefore = fullLiveness.getLiveness(before.bytecodeIndex());
+        const FastBitVector& liveAfter = fullLiveness.getLiveness(after.bytecodeIndex());
         
         (liveBefore & ~liveAfter).forEachSetBit(

trunk/Source/JavaScriptCore/dfg/DFGGraph.cpp

@@ -121 +121 @@
         return false;
     
-    if (previousNode->origin.semantic.inlineCallFrame == currentNode->origin.semantic.inlineCallFrame)
+    if (previousNode->origin.semantic.inlineCallFrame() == currentNode->origin.semantic.inlineCallFrame())
         return false;
     
@@ -129 +129 @@
     unsigned indexOfDivergence = commonSize;
     for (unsigned i = 0; i < commonSize; ++i) {
-        if (previousInlineStack[i].inlineCallFrame != currentInlineStack[i].inlineCallFrame) {
+        if (previousInlineStack[i].inlineCallFrame() != currentInlineStack[i].inlineCallFrame()) {
             indexOfDivergence = i;
             break;
@@ -141 +141 @@
         out.print(prefix);
         printWhiteSpace(out, i * 2);
-        out.print("<-- ", inContext(*previousInlineStack[i].inlineCallFrame, context), "\n");
+        out.print("<-- ", inContext(*previousInlineStack[i].inlineCallFrame(), context), "\n");
         hasPrinted = true;
     }
@@ -149 +149 @@
         out.print(prefix);
         printWhiteSpace(out, i * 2);
-        out.print("--> ", inContext(*currentInlineStack[i].inlineCallFrame, context), "\n");
+        out.print("--> ", inContext(*currentInlineStack[i].inlineCallFrame(), context), "\n");
         hasPrinted = true;
     }
@@ -395 +395 @@
         out.print(comma, "ClobbersExit");
     if (node->origin.isSet()) {
-        out.print(comma, "bc#", node->origin.semantic.bytecodeIndex);
+        out.print(comma, "bc#", node->origin.semantic.bytecodeIndex());
         if (node->origin.semantic != node->origin.forExit && node->origin.forExit.isSet())
             out.print(comma, "exit: ", node->origin.forExit);
@@ -1124 +1124 @@
         if (verbose)
             dataLog("reg = ", reg, "\n");
-        
+
+        auto* inlineCallFrame = codeOriginPtr->inlineCallFrame();
         if (operand.offset() < codeOriginPtr->stackOffset() + CallFrame::headerSizeInRegisters) {
             if (reg.isArgument()) {
                 RELEASE_ASSERT(reg.offset() < CallFrame::headerSizeInRegisters);
-                
-                if (codeOriginPtr->inlineCallFrame->isClosureCall
+
+
+                if (inlineCallFrame->isClosureCall
                     && reg.offset() == CallFrameSlot::callee) {
                     if (verbose)
@@ -1136 +1138 @@
                 }
                 
-                if (codeOriginPtr->inlineCallFrame->isVarargs()
+                if (inlineCallFrame->isVarargs()
                     && reg.offset() == CallFrameSlot::argumentCount) {
                     if (verbose)
@@ -1148 +1150 @@
             if (verbose)
                 dataLog("Asking the bytecode liveness.\n");
-            return livenessFor(codeOriginPtr->inlineCallFrame).operandIsLive(
-                reg.offset(), codeOriginPtr->bytecodeIndex);
-        }
-        
-        InlineCallFrame* inlineCallFrame = codeOriginPtr->inlineCallFrame;
+            return livenessFor(inlineCallFrame).operandIsLive(reg.offset(), codeOriginPtr->bytecodeIndex());
+        }
+
         if (!inlineCallFrame) {
             if (verbose)
@@ -1623 +1623 @@
                         profiledBlock,
                         LazyOperandValueProfileKey(
-                            node->origin.semantic.bytecodeIndex, node->local()));
+                            node->origin.semantic.bytecodeIndex(), node->local()));
                 }
             }
 
             if (node->hasHeapPrediction())
-                return &profiledBlock->valueProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
+                return &profiledBlock->valueProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex());
 
             if (profiledBlock->hasBaselineJITProfiling()) {
-                if (ArithProfile* result = profiledBlock->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex))
+                if (ArithProfile* result = profiledBlock->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex()))
                     return result;
             }
@@ -1729 +1729 @@
         return false;
 
-    unsigned bytecodeIndexToCheck = codeOrigin.bytecodeIndex;
+    unsigned bytecodeIndexToCheck = codeOrigin.bytecodeIndex();
     while (1) {
-        InlineCallFrame* inlineCallFrame = codeOrigin.inlineCallFrame;
+        InlineCallFrame* inlineCallFrame = codeOrigin.inlineCallFrame();
         CodeBlock* codeBlock = baselineCodeBlockFor(inlineCallFrame);
         if (HandlerInfo* handler = codeBlock->handlerForBytecodeOffset(bytecodeIndexToCheck)) {
@@ -1742 +1742 @@
             return false;
 
-        bytecodeIndexToCheck = inlineCallFrame->directCaller.bytecodeIndex;
-        codeOrigin = codeOrigin.inlineCallFrame->directCaller;
+        bytecodeIndexToCheck = inlineCallFrame->directCaller.bytecodeIndex();
+        codeOrigin = inlineCallFrame->directCaller;
     }
 

trunk/Source/JavaScriptCore/dfg/DFGGraph.h

@@ -425 +425 @@
     ScriptExecutable* executableFor(const CodeOrigin& codeOrigin)
     {
-        return executableFor(codeOrigin.inlineCallFrame);
+        return executableFor(codeOrigin.inlineCallFrame());
     }
     
@@ -442 +442 @@
     bool isStrictModeFor(CodeOrigin codeOrigin)
     {
-        if (!codeOrigin.inlineCallFrame)
+        if (!codeOrigin.inlineCallFrame())
             return m_codeBlock->isStrictMode();
-        return codeOrigin.inlineCallFrame->isStrictMode();
+        return codeOrigin.inlineCallFrame()->isStrictMode();
     }
     
@@ -464 +464 @@
     bool hasExitSite(const CodeOrigin& codeOrigin, ExitKind exitKind)
     {
-        return baselineCodeBlockFor(codeOrigin)->unlinkedCodeBlock()->hasExitSite(FrequentExitSite(codeOrigin.bytecodeIndex, exitKind));
+        return baselineCodeBlockFor(codeOrigin)->unlinkedCodeBlock()->hasExitSite(FrequentExitSite(codeOrigin.bytecodeIndex(), exitKind));
     }
     
@@ -828 +828 @@
         
         for (;;) {
-            InlineCallFrame* inlineCallFrame = codeOriginPtr->inlineCallFrame;
+            InlineCallFrame* inlineCallFrame = codeOriginPtr->inlineCallFrame();
             VirtualRegister stackOffset(inlineCallFrame ? inlineCallFrame->stackOffset : 0);
             
@@ -840 +840 @@
             CodeBlock* codeBlock = baselineCodeBlockFor(inlineCallFrame);
             FullBytecodeLiveness& fullLiveness = livenessFor(codeBlock);
-            const FastBitVector& liveness = fullLiveness.getLiveness(codeOriginPtr->bytecodeIndex);
+            const FastBitVector& liveness = fullLiveness.getLiveness(codeOriginPtr->bytecodeIndex());
             for (unsigned relativeLocal = codeBlock->numCalleeLocals(); relativeLocal--;) {
                 VirtualRegister reg = stackOffset + virtualRegisterForLocal(relativeLocal);

trunk/Source/JavaScriptCore/dfg/DFGLiveCatchVariablePreservationPhase.cpp

@@ -126 +126 @@
                 return cachedHandlerResult;
 
-            unsigned bytecodeIndexToCheck = origin.bytecodeIndex;
+            unsigned bytecodeIndexToCheck = origin.bytecodeIndex();
 
             cachedCodeOrigin = origin;
 
             while (1) {
-                InlineCallFrame* inlineCallFrame = origin.inlineCallFrame;
+                InlineCallFrame* inlineCallFrame = origin.inlineCallFrame();
                 CodeBlock* codeBlock = m_graph.baselineCodeBlockFor(inlineCallFrame);
                 if (HandlerInfo* handler = codeBlock->handlerForBytecodeOffset(bytecodeIndexToCheck)) {
@@ -150 +150 @@
                 }
 
-                bytecodeIndexToCheck = inlineCallFrame->directCaller.bytecodeIndex;
+                bytecodeIndexToCheck = inlineCallFrame->directCaller.bytecodeIndex();
                 origin = inlineCallFrame->directCaller;
             }
@@ -200 +200 @@
 
             if (currentExceptionHandler && (node->op() == SetLocal || node->op() == SetArgument)) {
-                InlineCallFrame* inlineCallFrame = node->origin.semantic.inlineCallFrame;
+                InlineCallFrame* inlineCallFrame = node->origin.semantic.inlineCallFrame();
                 if (inlineCallFrame)
                     seenInlineCallFrames.add(inlineCallFrame);

trunk/Source/JavaScriptCore/dfg/DFGMinifiedNode.cpp

@@ -44 +44 @@
     else {
         ASSERT(node->op() == PhantomDirectArguments || node->op() == PhantomClonedArguments);
-        result.m_info = bitwise_cast<uintptr_t>(node->origin.semantic.inlineCallFrame);
+        result.m_info = bitwise_cast<uintptr_t>(node->origin.semantic.inlineCallFrame());
     }
     return result;

trunk/Source/JavaScriptCore/dfg/DFGOSRAvailabilityAnalysisPhase.cpp

@@ -259 +259 @@
     case PhantomDirectArguments:
     case PhantomClonedArguments: {
-        InlineCallFrame* inlineCallFrame = node->origin.semantic.inlineCallFrame;
+        InlineCallFrame* inlineCallFrame = node->origin.semantic.inlineCallFrame();
         if (!inlineCallFrame) {
             // We don't need to record anything about how the arguments are to be recovered. It's just a

trunk/Source/JavaScriptCore/dfg/DFGOSRExit.cpp

@@ -394 +394 @@
                 CodeOrigin codeOrigin = exit.m_codeOriginForExitProfile;
                 CodeBlock* profiledCodeBlock = baselineCodeBlockForOriginAndBaselineCodeBlock(codeOrigin, baselineCodeBlock);
-                arrayProfile = profiledCodeBlock->getArrayProfile(codeOrigin.bytecodeIndex);
+                arrayProfile = profiledCodeBlock->getArrayProfile(codeOrigin.bytecodeIndex());
                 if (arrayProfile)
                     extraInitializationLevel = std::max(extraInitializationLevel, ExtraInitializationLevel::ArrayProfileUpdate);
@@ -407 +407 @@
         CodeBlock* codeBlockForExit = baselineCodeBlockForOriginAndBaselineCodeBlock(exit.m_codeOrigin, baselineCodeBlock);
         const JITCodeMap& codeMap = codeBlockForExit->jitCodeMap();
-        CodeLocationLabel<JSEntryPtrTag> codeLocation = codeMap.find(exit.m_codeOrigin.bytecodeIndex);
+        CodeLocationLabel<JSEntryPtrTag> codeLocation = codeMap.find(exit.m_codeOrigin.bytecodeIndex());
         ASSERT(codeLocation);
 
@@ -749 +749 @@
 
     const CodeOrigin* codeOrigin;
-    for (codeOrigin = &exit.m_codeOrigin; codeOrigin && codeOrigin->inlineCallFrame; codeOrigin = codeOrigin->inlineCallFrame->getCallerSkippingTailCalls()) {
-        InlineCallFrame* inlineCallFrame = codeOrigin->inlineCallFrame;
+    for (codeOrigin = &exit.m_codeOrigin; codeOrigin && codeOrigin->inlineCallFrame(); codeOrigin = codeOrigin->inlineCallFrame()->getCallerSkippingTailCalls()) {
+        InlineCallFrame* inlineCallFrame = codeOrigin->inlineCallFrame();
         CodeBlock* baselineCodeBlock = baselineCodeBlockForOriginAndBaselineCodeBlock(*codeOrigin, outermostBaselineCodeBlock);
         InlineCallFrame::Kind trueCallerCallKind;
@@ -768 +768 @@
         } else {
             CodeBlock* baselineCodeBlockForCaller = baselineCodeBlockForOriginAndBaselineCodeBlock(*trueCaller, outermostBaselineCodeBlock);
-            unsigned callBytecodeIndex = trueCaller->bytecodeIndex;
+            unsigned callBytecodeIndex = trueCaller->bytecodeIndex();
             MacroAssemblerCodePtr<JSInternalPtrTag> jumpTarget;
 
@@ -800 +800 @@
             }
 
-            if (trueCaller->inlineCallFrame)
-                callerFrame = cpu.fp<uint8_t*>() + trueCaller->inlineCallFrame->stackOffset * sizeof(EncodedJSValue);
+            if (trueCaller->inlineCallFrame())
+                callerFrame = cpu.fp<uint8_t*>() + trueCaller->inlineCallFrame()->stackOffset * sizeof(EncodedJSValue);
 
             void* targetAddress = jumpTarget.executableAddress();
@@ -823 +823 @@
         frame.set<void*>(inlineCallFrame->callerFrameOffset(), callerFrame);
 #if USE(JSVALUE64)
-        uint32_t locationBits = CallSiteIndex(codeOrigin->bytecodeIndex).bits();
+        uint32_t locationBits = CallSiteIndex(codeOrigin->bytecodeIndex()).bits();
         frame.setOperand<uint32_t>(inlineCallFrame->stackOffset + CallFrameSlot::argumentCount, TagOffset, locationBits);
         if (!inlineCallFrame->isClosureCall)
@@ -840 +840 @@
     if (codeOrigin) {
 #if USE(JSVALUE64)
-        uint32_t locationBits = CallSiteIndex(codeOrigin->bytecodeIndex).bits();
+        uint32_t locationBits = CallSiteIndex(codeOrigin->bytecodeIndex()).bits();
 #else
         const Instruction* instruction = outermostBaselineCodeBlock->instructions().at(codeOrigin->bytecodeIndex).ptr();
@@ -869 +869 @@
     }
 
-    if (exit.m_codeOrigin.inlineCallFrame)
-        context.fp() = context.fp<uint8_t*>() + exit.m_codeOrigin.inlineCallFrame->stackOffset * sizeof(EncodedJSValue);
+    auto* exitInlineCallFrame = exit.m_codeOrigin.inlineCallFrame();
+    if (exitInlineCallFrame)
+        context.fp() = context.fp<uint8_t*>() + exitInlineCallFrame->stackOffset * sizeof(EncodedJSValue);
 
     void* jumpTarget = exitState->jumpTarget;
@@ -890 +891 @@
     CodeBlock* alternative = codeBlock->alternative();
     ExitKind kind = exit.m_kind;
-    unsigned bytecodeOffset = exit.m_codeOrigin.bytecodeIndex;
+    unsigned bytecodeOffset = exit.m_codeOrigin.bytecodeIndex();
 
     dataLog("Speculation failure in ", *codeBlock);
@@ -1100 +1101 @@
         debugInfo->codeBlock = jit.codeBlock();
         debugInfo->kind = exit.m_kind;
-        debugInfo->bytecodeOffset = exit.m_codeOrigin.bytecodeIndex;
+        debugInfo->bytecodeOffset = exit.m_codeOrigin.bytecodeIndex();
 
         jit.debugCall(vm, debugOperationPrintSpeculationFailure, debugInfo);
@@ -1149 +1150 @@
 
             CodeOrigin codeOrigin = exit.m_codeOriginForExitProfile;
-            if (ArrayProfile* arrayProfile = jit.baselineCodeBlockFor(codeOrigin)->getArrayProfile(codeOrigin.bytecodeIndex)) {
+            if (ArrayProfile* arrayProfile = jit.baselineCodeBlockFor(codeOrigin)->getArrayProfile(codeOrigin.bytecodeIndex())) {
 #if USE(JSVALUE64)
                 GPRReg usedRegister;

trunk/Source/JavaScriptCore/dfg/DFGOSRExitBase.cpp

@@ -44 +44 @@
     if (sourceProfiledCodeBlock) {
         ExitingInlineKind inlineKind;
-        if (m_codeOriginForExitProfile.inlineCallFrame)
+        if (m_codeOriginForExitProfile.inlineCallFrame())
             inlineKind = ExitFromInlined;
         else
@@ -53 +53 @@
             site = FrequentExitSite(HoistingFailed, jitType, inlineKind);
         else
-            site = FrequentExitSite(m_codeOriginForExitProfile.bytecodeIndex, m_kind, jitType, inlineKind);
+            site = FrequentExitSite(m_codeOriginForExitProfile.bytecodeIndex(), m_kind, jitType, inlineKind);
         ExitProfile::add(sourceProfiledCodeBlock, site);
     }

trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp

@@ -74 +74 @@
     AssemblyHelpers::JumpList loopThreshold;
     
-    for (InlineCallFrame* inlineCallFrame = exit.m_codeOrigin.inlineCallFrame; inlineCallFrame; inlineCallFrame = inlineCallFrame->directCaller.inlineCallFrame) {
+    for (InlineCallFrame* inlineCallFrame = exit.m_codeOrigin.inlineCallFrame(); inlineCallFrame; inlineCallFrame = inlineCallFrame->directCaller.inlineCallFrame()) {
         loopThreshold.append(
             jit.branchTest8(
@@ -146 +146 @@
 
     const CodeOrigin* codeOrigin;
-    for (codeOrigin = &exit.m_codeOrigin; codeOrigin && codeOrigin->inlineCallFrame; codeOrigin = codeOrigin->inlineCallFrame->getCallerSkippingTailCalls()) {
-        InlineCallFrame* inlineCallFrame = codeOrigin->inlineCallFrame;
+    for (codeOrigin = &exit.m_codeOrigin; codeOrigin && codeOrigin->inlineCallFrame(); codeOrigin = codeOrigin->inlineCallFrame()->getCallerSkippingTailCalls()) {
+        InlineCallFrame* inlineCallFrame = codeOrigin->inlineCallFrame();
         CodeBlock* baselineCodeBlock = jit.baselineCodeBlockFor(*codeOrigin);
         InlineCallFrame::Kind trueCallerCallKind;
@@ -167 +167 @@
         } else {
             CodeBlock* baselineCodeBlockForCaller = jit.baselineCodeBlockFor(*trueCaller);
-            unsigned callBytecodeIndex = trueCaller->bytecodeIndex;
+            unsigned callBytecodeIndex = trueCaller->bytecodeIndex();
             void* jumpTarget = nullptr;
 
@@ -199 +199 @@
             }
 
-            if (trueCaller->inlineCallFrame) {
+            if (trueCaller->inlineCallFrame()) {
                 jit.addPtr(
-                    AssemblyHelpers::TrustedImm32(trueCaller->inlineCallFrame->stackOffset * sizeof(EncodedJSValue)),
+                    AssemblyHelpers::TrustedImm32(trueCaller->inlineCallFrame()->stackOffset * sizeof(EncodedJSValue)),
                     GPRInfo::callFrameRegister,
                     GPRInfo::regT3);
@@ -232 +232 @@
 #if USE(JSVALUE64)
         jit.storePtr(callerFrameGPR, AssemblyHelpers::addressForByteOffset(inlineCallFrame->callerFrameOffset()));
-        uint32_t locationBits = CallSiteIndex(codeOrigin->bytecodeIndex).bits();
+        uint32_t locationBits = CallSiteIndex(codeOrigin->bytecodeIndex()).bits();
         jit.store32(AssemblyHelpers::TrustedImm32(locationBits), AssemblyHelpers::tagFor((VirtualRegister)(inlineCallFrame->stackOffset + CallFrameSlot::argumentCount)));
         if (!inlineCallFrame->isClosureCall)
@@ -250 +250 @@
     if (codeOrigin) {
 #if USE(JSVALUE64)
-        uint32_t locationBits = CallSiteIndex(codeOrigin->bytecodeIndex).bits();
+        uint32_t locationBits = CallSiteIndex(codeOrigin->bytecodeIndex()).bits();
 #else
         const Instruction* instruction = jit.baselineCodeBlock()->instructions().at(codeOrigin->bytecodeIndex).ptr();
@@ -305 +305 @@
     }
 
-    if (exit.m_codeOrigin.inlineCallFrame)
-        jit.addPtr(AssemblyHelpers::TrustedImm32(exit.m_codeOrigin.inlineCallFrame->stackOffset * sizeof(EncodedJSValue)), GPRInfo::callFrameRegister);
+    auto* exitInlineCallFrame = exit.m_codeOrigin.inlineCallFrame();
+    if (exitInlineCallFrame)
+        jit.addPtr(AssemblyHelpers::TrustedImm32(exitInlineCallFrame->stackOffset * sizeof(EncodedJSValue)), GPRInfo::callFrameRegister);
 
     CodeBlock* codeBlockForExit = jit.baselineCodeBlockFor(exit.m_codeOrigin);
     ASSERT(codeBlockForExit == codeBlockForExit->baselineVersion());
     ASSERT(codeBlockForExit->jitType() == JITCode::BaselineJIT);
-    CodeLocationLabel<JSEntryPtrTag> codeLocation = codeBlockForExit->jitCodeMap().find(exit.m_codeOrigin.bytecodeIndex);
+    CodeLocationLabel<JSEntryPtrTag> codeLocation = codeBlockForExit->jitCodeMap().find(exit.m_codeOrigin.bytecodeIndex());
     ASSERT(codeLocation);
 

trunk/Source/JavaScriptCore/dfg/DFGOSRExitPreparation.cpp

@@ -42 +42 @@
     DeferGC deferGC(vm.heap);
     
-    for (; codeOrigin.inlineCallFrame; codeOrigin = codeOrigin.inlineCallFrame->directCaller) {
-        CodeBlock* codeBlock = codeOrigin.inlineCallFrame->baselineCodeBlock.get();
+    for (; codeOrigin.inlineCallFrame(); codeOrigin = codeOrigin.inlineCallFrame()->directCaller) {
+        CodeBlock* codeBlock = codeOrigin.inlineCallFrame()->baselineCodeBlock.get();
         JITWorklist::ensureGlobalWorklist().compileNow(codeBlock);
     }

trunk/Source/JavaScriptCore/dfg/DFGObjectAllocationSinkingPhase.cpp

@@ -1269 +1269 @@
             forEachEscapee([&] (HashMap<Node*, Allocation>& escapees, Node* where) {
                 for (Node* allocation : escapees.keys()) {
-                    InlineCallFrame* inlineCallFrame = allocation->origin.semantic.inlineCallFrame;
+                    InlineCallFrame* inlineCallFrame = allocation->origin.semantic.inlineCallFrame();
                     if (!inlineCallFrame)
                         continue;
-                    if ((inlineCallFrame->isClosureCall || inlineCallFrame->isVarargs()) && inlineCallFrame != where->origin.semantic.inlineCallFrame)
+                    if ((inlineCallFrame->isClosureCall || inlineCallFrame->isVarargs()) && inlineCallFrame != where->origin.semantic.inlineCallFrame())
                         m_sinkCandidates.remove(allocation);
                 }

trunk/Source/JavaScriptCore/dfg/DFGOperations.cpp

@@ -2896 +2896 @@
 
     CodeOrigin origin = exec->codeOrigin();
+    auto* inlineCallFrame = origin.inlineCallFrame();
     bool strictMode;
-    if (origin.inlineCallFrame)
-        strictMode = origin.inlineCallFrame->baselineCodeBlock->isStrictMode();
+    if (inlineCallFrame)
+        strictMode = inlineCallFrame->baselineCodeBlock->isStrictMode();
     else
         strictMode = exec->codeBlock()->isStrictMode();
@@ -3045 +3046 @@
     
     bool didTryToEnterIntoInlinedLoops = false;
-    for (InlineCallFrame* inlineCallFrame = exit->m_codeOrigin.inlineCallFrame; inlineCallFrame; inlineCallFrame = inlineCallFrame->directCaller.inlineCallFrame) {
+    for (InlineCallFrame* inlineCallFrame = exit->m_codeOrigin.inlineCallFrame(); inlineCallFrame; inlineCallFrame = inlineCallFrame->directCaller.inlineCallFrame()) {
         if (inlineCallFrame->baselineCodeBlock->ownerExecutable()->didTryToEnterInLoop()) {
             didTryToEnterIntoInlinedLoops = true;

trunk/Source/JavaScriptCore/dfg/DFGPreciseLocalClobberize.h

@@ -131 +131 @@
                 return;
             }
-            InlineCallFrame* inlineCallFrame = spread->child1()->origin.semantic.inlineCallFrame;
+            InlineCallFrame* inlineCallFrame = spread->child1()->origin.semantic.inlineCallFrame();
             unsigned numberOfArgumentsToSkip = spread->child1()->numberOfArgumentsToSkip();
             readFrame(inlineCallFrame, numberOfArgumentsToSkip);
@@ -193 +193 @@
                 InlineCallFrame* inlineCallFrame;
                 if (m_node->hasArgumentsChild() && m_node->argumentsChild())
-                    inlineCallFrame = m_node->argumentsChild()->origin.semantic.inlineCallFrame;
+                    inlineCallFrame = m_node->argumentsChild()->origin.semantic.inlineCallFrame();
                 else
-                    inlineCallFrame = m_node->origin.semantic.inlineCallFrame;
+                    inlineCallFrame = m_node->origin.semantic.inlineCallFrame();
 
                 unsigned numberOfArgumentsToSkip = 0;
@@ -221 +221 @@
 
         case GetArgument: {
-            InlineCallFrame* inlineCallFrame = m_node->origin.semantic.inlineCallFrame;
+            InlineCallFrame* inlineCallFrame = m_node->origin.semantic.inlineCallFrame();
             unsigned indexIncludingThis = m_node->argumentIndex();
             if (!inlineCallFrame) {
@@ -249 +249 @@
         
             // Read all of the inline arguments and call frame headers that we didn't already capture.
-            for (InlineCallFrame* inlineCallFrame = m_node->origin.semantic.inlineCallFrame; inlineCallFrame; inlineCallFrame = inlineCallFrame->getCallerInlineFrameSkippingTailCalls()) {
+            for (InlineCallFrame* inlineCallFrame = m_node->origin.semantic.inlineCallFrame(); inlineCallFrame; inlineCallFrame = inlineCallFrame->getCallerInlineFrameSkippingTailCalls()) {
                 if (!inlineCallFrame->isStrictMode()) {
                     for (unsigned i = inlineCallFrame->argumentsWithFixup.size(); i--;)

trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

@@ -188 +188 @@
 void SpeculativeJIT::emitGetLength(CodeOrigin origin, GPRReg lengthGPR, bool includeThis)
 {
-    emitGetLength(origin.inlineCallFrame, lengthGPR, includeThis);
+    emitGetLength(origin.inlineCallFrame(), lengthGPR, includeThis);
 }
 
 void SpeculativeJIT::emitGetCallee(CodeOrigin origin, GPRReg calleeGPR)
 {
-    if (origin.inlineCallFrame) {
-        if (origin.inlineCallFrame->isClosureCall) {
+    auto* inlineCallFrame = origin.inlineCallFrame();
+    if (inlineCallFrame) {
+        if (inlineCallFrame->isClosureCall) {
             m_jit.loadPtr(
-                JITCompiler::addressFor(origin.inlineCallFrame->calleeRecovery.virtualRegister()),
+                JITCompiler::addressFor(inlineCallFrame->calleeRecovery.virtualRegister()),
                 calleeGPR);
         } else {
             m_jit.move(
-                TrustedImmPtr::weakPointer(m_jit.graph(), origin.inlineCallFrame->calleeRecovery.constant().asCell()),
+                TrustedImmPtr::weakPointer(m_jit.graph(), inlineCallFrame->calleeRecovery.constant().asCell()),
                 calleeGPR);
         }
@@ -1864 +1865 @@
                 "SpeculativeJIT generating Node @%d (bc#%u) at JIT offset 0x%x",
                 (int)m_currentNode->index(),
-                m_currentNode->origin.semantic.bytecodeIndex, m_jit.debugOffset());
+                m_currentNode->origin.semantic.bytecodeIndex(), m_jit.debugOffset());
             dataLog("\n");
         }
@@ -3938 +3939 @@
 
     CodeBlock* baselineCodeBlock = m_jit.graph().baselineCodeBlockFor(node->origin.semantic);
-    ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
-    const Instruction* instruction = baselineCodeBlock->instructions().at(node->origin.semantic.bytecodeIndex).ptr();
+    unsigned bytecodeIndex = node->origin.semantic.bytecodeIndex();
+    ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(bytecodeIndex);
+    const Instruction* instruction = baselineCodeBlock->instructions().at(bytecodeIndex).ptr();
     JITAddIC* addIC = m_jit.codeBlock()->addJITAddIC(arithProfile, instruction);
     auto repatchingFunction = operationValueAddOptimize;
@@ -3962 +3964 @@
 
         CodeBlock* baselineCodeBlock = m_jit.graph().baselineCodeBlockFor(node->origin.semantic);
-        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
-        const Instruction* instruction = baselineCodeBlock->instructions().at(node->origin.semantic.bytecodeIndex).ptr();
+        unsigned bytecodeIndex = node->origin.semantic.bytecodeIndex();
+        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(bytecodeIndex);
+        const Instruction* instruction = baselineCodeBlock->instructions().at(bytecodeIndex).ptr();
         JITSubIC* subIC = m_jit.codeBlock()->addJITSubIC(arithProfile, instruction);
         auto repatchingFunction = operationValueSubOptimize;
@@ -4554 +4557 @@
 {
     CodeBlock* baselineCodeBlock = m_jit.graph().baselineCodeBlockFor(node->origin.semantic);
-    ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
-    const Instruction* instruction = baselineCodeBlock->instructions().at(node->origin.semantic.bytecodeIndex).ptr();
+    unsigned bytecodeIndex = node->origin.semantic.bytecodeIndex();
+    ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(bytecodeIndex);
+    const Instruction* instruction = baselineCodeBlock->instructions().at(bytecodeIndex).ptr();
     JITNegIC* negIC = m_jit.codeBlock()->addJITNegIC(arithProfile, instruction);
     auto repatchingFunction = operationArithNegateOptimize;
@@ -4777 +4781 @@
 
     CodeBlock* baselineCodeBlock = m_jit.graph().baselineCodeBlockFor(node->origin.semantic);
-    ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(node->origin.semantic.bytecodeIndex);
-    const Instruction* instruction = baselineCodeBlock->instructions().at(node->origin.semantic.bytecodeIndex).ptr();
+    unsigned bytecodeIndex = node->origin.semantic.bytecodeIndex();
+    ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(bytecodeIndex);
+    const Instruction* instruction = baselineCodeBlock->instructions().at(bytecodeIndex).ptr();
     JITMulIC* mulIC = m_jit.codeBlock()->addJITMulIC(arithProfile, instruction);
     auto repatchingFunction = operationValueMulOptimize;
@@ -7232 +7237 @@
     InlineCallFrame* inlineCallFrame;
     if (node->child1())
-        inlineCallFrame = node->child1()->origin.semantic.inlineCallFrame;
+        inlineCallFrame = node->child1()->origin.semantic.inlineCallFrame();
     else
-        inlineCallFrame = node->origin.semantic.inlineCallFrame;
+        inlineCallFrame = node->origin.semantic.inlineCallFrame();
 
     GPRTemporary length(this);
@@ -7397 +7402 @@
     unsigned knownLength;
     bool lengthIsKnown; // if false, lengthGPR will have the length.
-    if (node->origin.semantic.inlineCallFrame
-        && !node->origin.semantic.inlineCallFrame->isVarargs()) {
-        knownLength = node->origin.semantic.inlineCallFrame->argumentCountIncludingThis - 1;
+    auto* inlineCallFrame = node->origin.semantic.inlineCallFrame();
+    if (inlineCallFrame
+        && !inlineCallFrame->isVarargs()) {
+        knownLength = inlineCallFrame->argumentCountIncludingThis - 1;
         lengthIsKnown = true;
     } else {
@@ -7472 +7478 @@
         addSlowPathGenerator(WTFMove(generator));
     }
-        
-    if (node->origin.semantic.inlineCallFrame) {
-        if (node->origin.semantic.inlineCallFrame->isClosureCall) {
+
+    if (inlineCallFrame) {
+        if (inlineCallFrame->isClosureCall) {
             m_jit.loadPtr(
                 JITCompiler::addressFor(
-                    node->origin.semantic.inlineCallFrame->calleeRecovery.virtualRegister()),
+                    inlineCallFrame->calleeRecovery.virtualRegister()),
                 scratch1GPR);
         } else {
             m_jit.move(
                 TrustedImmPtr::weakPointer(
-                    m_jit.graph(), node->origin.semantic.inlineCallFrame->calleeRecovery.constant().asCell()),
+                    m_jit.graph(), inlineCallFrame->calleeRecovery.constant().asCell()),
                 scratch1GPR);
         }

trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp

@@ -619 +619 @@
             InlineCallFrame* inlineCallFrame;
             if (node->child3())
-                inlineCallFrame = node->child3()->origin.semantic.inlineCallFrame;
+                inlineCallFrame = node->child3()->origin.semantic.inlineCallFrame();
             else
-                inlineCallFrame = node->origin.semantic.inlineCallFrame;
+                inlineCallFrame = node->origin.semantic.inlineCallFrame();
             // emitSetupVarargsFrameFastCase modifies the stack pointer if it succeeds.
             emitSetupVarargsFrameFastCase(*m_jit.vm(), m_jit, scratchGPR2, scratchGPR1, scratchGPR2, scratchGPR3, inlineCallFrame, data->firstVarArgOffset, slowCase);
@@ -769 +769 @@
 
     CodeOrigin staticOrigin = node->origin.semantic;
-    ASSERT(!isTail || !staticOrigin.inlineCallFrame || !staticOrigin.inlineCallFrame->getCallerSkippingTailCalls());
-    ASSERT(!isEmulatedTail || (staticOrigin.inlineCallFrame && staticOrigin.inlineCallFrame->getCallerSkippingTailCalls()));
+    InlineCallFrame* staticInlineCallFrame = staticOrigin.inlineCallFrame();
+    ASSERT(!isTail || !staticInlineCallFrame || !staticInlineCallFrame->getCallerSkippingTailCalls());
+    ASSERT(!isEmulatedTail || (staticInlineCallFrame && staticInlineCallFrame->getCallerSkippingTailCalls()));
     CodeOrigin dynamicOrigin =
-        isEmulatedTail ? *staticOrigin.inlineCallFrame->getCallerSkippingTailCalls() : staticOrigin;
+        isEmulatedTail ? *staticInlineCallFrame->getCallerSkippingTailCalls() : staticOrigin;
     CallSiteIndex callSite = m_jit.recordCallSiteAndGenerateExceptionHandlingOSRExitIfNeeded(dynamicOrigin, m_stream->size());
     

trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp

@@ -580 +580 @@
             InlineCallFrame* inlineCallFrame;
             if (node->child3())
-                inlineCallFrame = node->child3()->origin.semantic.inlineCallFrame;
+                inlineCallFrame = node->child3()->origin.semantic.inlineCallFrame();
             else
-                inlineCallFrame = node->origin.semantic.inlineCallFrame;
+                inlineCallFrame = node->origin.semantic.inlineCallFrame();
             // emitSetupVarargsFrameFastCase modifies the stack pointer if it succeeds.
             emitSetupVarargsFrameFastCase(*m_jit.vm(), m_jit, scratchGPR2, scratchGPR1, scratchGPR2, scratchGPR3, inlineCallFrame, data->firstVarArgOffset, slowCase);
@@ -721 +721 @@
 
     CodeOrigin staticOrigin = node->origin.semantic;
-    ASSERT(!isTail || !staticOrigin.inlineCallFrame || !staticOrigin.inlineCallFrame->getCallerSkippingTailCalls());
-    ASSERT(!isEmulatedTail || (staticOrigin.inlineCallFrame && staticOrigin.inlineCallFrame->getCallerSkippingTailCalls()));
+    InlineCallFrame* staticInlineCallFrame = staticOrigin.inlineCallFrame();
+    ASSERT(!isTail || !staticInlineCallFrame || !staticInlineCallFrame->getCallerSkippingTailCalls());
+    ASSERT(!isEmulatedTail || (staticInlineCallFrame && staticInlineCallFrame->getCallerSkippingTailCalls()));
     CodeOrigin dynamicOrigin =
-        isEmulatedTail ? *staticOrigin.inlineCallFrame->getCallerSkippingTailCalls() : staticOrigin;
+        isEmulatedTail ? *staticInlineCallFrame->getCallerSkippingTailCalls() : staticOrigin;
 
     CallSiteIndex callSite = m_jit.recordCallSiteAndGenerateExceptionHandlingOSRExitIfNeeded(dynamicOrigin, m_stream->size());
@@ -5015 +5016 @@
         Vector<SilentRegisterSavePlan> savePlans;
         silentSpillAllRegistersImpl(false, savePlans, InvalidGPRReg);
-        unsigned bytecodeIndex = node->origin.semantic.bytecodeIndex;
+        unsigned bytecodeIndex = node->origin.semantic.bytecodeIndex();
 
         addSlowPathGeneratorLambda([=]() {
@@ -5044 +5045 @@
         
     case CheckTierUpAndOSREnter: {
-        ASSERT(!node->origin.semantic.inlineCallFrame);
+        ASSERT(!node->origin.semantic.inlineCallFrame());
 
         GPRTemporary temp(this);
         GPRReg tempGPR = temp.gpr();
 
-        unsigned bytecodeIndex = node->origin.semantic.bytecodeIndex;
+        unsigned bytecodeIndex = node->origin.semantic.bytecodeIndex();
         auto triggerIterator = m_jit.jitCode()->tierUpEntryTriggers.find(bytecodeIndex);
         DFG_ASSERT(m_jit.graph(), node, triggerIterator != m_jit.jitCode()->tierUpEntryTriggers.end());

trunk/Source/JavaScriptCore/dfg/DFGTierUpCheckInjectionPhase.cpp

@@ -109 +109 @@
                 insertionSet.insertNode(nodeIndex + 1, SpecNone, tierUpType, origin);
 
-                unsigned bytecodeIndex = origin.semantic.bytecodeIndex;
+                unsigned bytecodeIndex = origin.semantic.bytecodeIndex();
                 if (canOSREnter)
                     m_graph.m_plan.tierUpAndOSREnterBytecodes().append(bytecodeIndex);
@@ -171 +171 @@
 
         NodeOrigin origin = node->origin;
-        if (level != FTL::CanCompileAndOSREnter || origin.semantic.inlineCallFrame)
+        if (level != FTL::CanCompileAndOSREnter || origin.semantic.inlineCallFrame())
             return false;
 
@@ -195 +195 @@
 
                 if (const NaturalLoop* loop = naturalLoops.innerMostLoopOf(block)) {
-                    unsigned bytecodeIndex = node->origin.semantic.bytecodeIndex;
+                    unsigned bytecodeIndex = node->origin.semantic.bytecodeIndex();
                     naturalLoopsToLoopHint.add(loop, bytecodeIndex);
                 }

trunk/Source/JavaScriptCore/dfg/DFGTypeCheckHoistingPhase.cpp

@@ -148 +148 @@
                         if (SpecCellCheck & SpecEmpty) {
                             VirtualRegister local = node->variableAccessData()->local();
-                            auto* inlineCallFrame = node->origin.semantic.inlineCallFrame;
+                            auto* inlineCallFrame = node->origin.semantic.inlineCallFrame();
                             if ((local - (inlineCallFrame ? inlineCallFrame->stackOffset : 0)) == virtualRegisterForArgument(0)) {
                                 // |this| can be the TDZ value. The call entrypoint won't have |this| as TDZ,

trunk/Source/JavaScriptCore/dfg/DFGVariableEventStream.cpp

@@ -148 +148 @@
     };
 
-    if (codeOrigin.inlineCallFrame)
-        numVariables = baselineCodeBlockForInlineCallFrame(codeOrigin.inlineCallFrame)->numCalleeLocals() + VirtualRegister(codeOrigin.inlineCallFrame->stackOffset).toLocal() + 1;
+    auto* inlineCallFrame = codeOrigin.inlineCallFrame();
+    if (inlineCallFrame)
+        numVariables = baselineCodeBlockForInlineCallFrame(inlineCallFrame)->numCalleeLocals() + VirtualRegister(inlineCallFrame->stackOffset).toLocal() + 1;
     else
         numVariables = baselineCodeBlock->numCalleeLocals();

trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp

@@ -1903 +1903 @@
 
         CodeBlock* baselineCodeBlock = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic);
-        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
-        const Instruction* instruction = baselineCodeBlock->instructions().at(m_node->origin.semantic.bytecodeIndex).ptr();
+        unsigned bytecodeIndex = m_node->origin.semantic.bytecodeIndex();
+        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(bytecodeIndex);
+        const Instruction* instruction = baselineCodeBlock->instructions().at(bytecodeIndex).ptr();
         auto repatchingFunction = operationValueAddOptimize;
         auto nonRepatchingFunction = operationValueAdd;
@@ -1922 +1923 @@
 
         CodeBlock* baselineCodeBlock = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic);
-        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
-        const Instruction* instruction = baselineCodeBlock->instructions().at(m_node->origin.semantic.bytecodeIndex).ptr();
+        unsigned bytecodeIndex = m_node->origin.semantic.bytecodeIndex();
+        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(bytecodeIndex);
+        const Instruction* instruction = baselineCodeBlock->instructions().at(bytecodeIndex).ptr();
         auto repatchingFunction = operationValueSubOptimize;
         auto nonRepatchingFunction = operationValueSub;
@@ -1941 +1943 @@
 
         CodeBlock* baselineCodeBlock = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic);
-        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
-        const Instruction* instruction = baselineCodeBlock->instructions().at(m_node->origin.semantic.bytecodeIndex).ptr();
+        unsigned bytecodeIndex = m_node->origin.semantic.bytecodeIndex();
+        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(bytecodeIndex);
+        const Instruction* instruction = baselineCodeBlock->instructions().at(bytecodeIndex).ptr();
         auto repatchingFunction = operationValueMulOptimize;
         auto nonRepatchingFunction = operationValueMul;
@@ -2202 +2205 @@
 
             CodeBlock* baselineCodeBlock = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic);
-            ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
-            const Instruction* instruction = baselineCodeBlock->instructions().at(m_node->origin.semantic.bytecodeIndex).ptr();
+            unsigned bytecodeIndex = m_node->origin.semantic.bytecodeIndex();
+            ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(bytecodeIndex);
+            const Instruction* instruction = baselineCodeBlock->instructions().at(bytecodeIndex).ptr();
             auto repatchingFunction = operationValueSubOptimize;
             auto nonRepatchingFunction = operationValueSub;
@@ -2834 +2838 @@
         DFG_ASSERT(m_graph, m_node, m_node->child1().useKind() == UntypedUse);
         CodeBlock* baselineCodeBlock = m_ftlState.graph.baselineCodeBlockFor(m_node->origin.semantic);
-        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(m_node->origin.semantic.bytecodeIndex);
-        const Instruction* instruction = baselineCodeBlock->instructions().at(m_node->origin.semantic.bytecodeIndex).ptr();
+        unsigned bytecodeIndex = m_node->origin.semantic.bytecodeIndex();
+        ArithProfile* arithProfile = baselineCodeBlock->arithProfileForBytecodeOffset(bytecodeIndex);
+        const Instruction* instruction = baselineCodeBlock->instructions().at(bytecodeIndex).ptr();
         auto repatchingFunction = operationArithNegateOptimize;
         auto nonRepatchingFunction = operationArithNegate;
@@ -4243 +4248 @@
     void compileGetMyArgumentByVal()
     {
-        InlineCallFrame* inlineCallFrame = m_node->child1()->origin.semantic.inlineCallFrame;
+        InlineCallFrame* inlineCallFrame = m_node->child1()->origin.semantic.inlineCallFrame();
         
         LValue originalIndex = lowInt32(m_node->child2());
@@ -5817 +5822 @@
                     if (use->op() == PhantomSpread) {
                         if (use->child1()->op() == PhantomCreateRest) {
-                            InlineCallFrame* inlineCallFrame = use->child1()->origin.semantic.inlineCallFrame;
+                            InlineCallFrame* inlineCallFrame = use->child1()->origin.semantic.inlineCallFrame();
                             unsigned numberOfArgumentsToSkip = use->child1()->numberOfArgumentsToSkip();
                             LValue spreadLength = cachedSpreadLengths.ensure(inlineCallFrame, [&] () {
@@ -5858 +5863 @@
                         } else {
                             RELEASE_ASSERT(use->child1()->op() == PhantomCreateRest);
-                            InlineCallFrame* inlineCallFrame = use->child1()->origin.semantic.inlineCallFrame;
+                            InlineCallFrame* inlineCallFrame = use->child1()->origin.semantic.inlineCallFrame();
                             unsigned numberOfArgumentsToSkip = use->child1()->numberOfArgumentsToSkip();
 
@@ -6050 +6055 @@
             LBasicBlock lastNext = m_out.insertNewBlocksBefore(loopHeader);
 
-            InlineCallFrame* inlineCallFrame = m_node->child1()->origin.semantic.inlineCallFrame;
+            InlineCallFrame* inlineCallFrame = m_node->child1()->origin.semantic.inlineCallFrame();
             unsigned numberOfArgumentsToSkip = m_node->child1()->numberOfArgumentsToSkip();
             LValue sourceStart = getArgumentsStart(inlineCallFrame, numberOfArgumentsToSkip);
@@ -8046 +8051 @@
 
             RELEASE_ASSERT(target->op() == PhantomCreateRest);
-            InlineCallFrame* inlineCallFrame = target->origin.semantic.inlineCallFrame;
+            InlineCallFrame* inlineCallFrame = target->origin.semantic.inlineCallFrame();
             unsigned numberOfArgumentsToSkip = target->numberOfArgumentsToSkip();
             LValue length = cachedSpreadLengths.ensure(inlineCallFrame, [&] () {
@@ -8209 +8214 @@
 
                         RELEASE_ASSERT(target->op() == PhantomCreateRest);
-                        InlineCallFrame* inlineCallFrame = target->origin.semantic.inlineCallFrame;
+                        InlineCallFrame* inlineCallFrame = target->origin.semantic.inlineCallFrame();
 
                         unsigned numberOfArgumentsToSkip = target->numberOfArgumentsToSkip();
@@ -8489 +8494 @@
                     InlineCallFrame* inlineCallFrame;
                     if (node->child3())
-                        inlineCallFrame = node->child3()->origin.semantic.inlineCallFrame;
+                        inlineCallFrame = node->child3()->origin.semantic.inlineCallFrame();
                     else
-                        inlineCallFrame = node->origin.semantic.inlineCallFrame;
+                        inlineCallFrame = node->origin.semantic.inlineCallFrame();
 
                     // emitSetupVarargsFrameFastCase modifies the stack pointer if it succeeds.
@@ -8735 +8740 @@
         InlineCallFrame* inlineCallFrame;
         if (m_node->child1())
-            inlineCallFrame = m_node->child1()->origin.semantic.inlineCallFrame;
+            inlineCallFrame = m_node->child1()->origin.semantic.inlineCallFrame();
         else
-            inlineCallFrame = m_node->origin.semantic.inlineCallFrame;
+            inlineCallFrame = m_node->origin.semantic.inlineCallFrame();
 
         LValue length = nullptr; 
@@ -8884 +8889 @@
 
             ASSERT(target->op() == PhantomCreateRest);
-            InlineCallFrame* inlineCallFrame = target->origin.semantic.inlineCallFrame;
+            InlineCallFrame* inlineCallFrame = target->origin.semantic.inlineCallFrame();
             unsigned numberOfArgumentsToSkip = target->numberOfArgumentsToSkip();
             spreadLengths.append(cachedSpreadLengths.ensure(inlineCallFrame, [&] () {
@@ -8935 +8940 @@
 
             RELEASE_ASSERT(target->op() == PhantomCreateRest);
-            InlineCallFrame* inlineCallFrame = target->origin.semantic.inlineCallFrame;
+            InlineCallFrame* inlineCallFrame = target->origin.semantic.inlineCallFrame();
 
             LValue sourceStart = this->getArgumentsStart(inlineCallFrame, target->numberOfArgumentsToSkip());
@@ -11468 +11473 @@
     ArgumentsLength getArgumentsLength()
     {
-        return getArgumentsLength(m_node->origin.semantic.inlineCallFrame);
+        return getArgumentsLength(m_node->origin.semantic.inlineCallFrame());
     }
     
     LValue getCurrentCallee()
     {
-        if (InlineCallFrame* frame = m_node->origin.semantic.inlineCallFrame) {
+        if (InlineCallFrame* frame = m_node->origin.semantic.inlineCallFrame()) {
             if (frame->isClosureCall)
                 return m_out.loadPtr(addressFor(frame->calleeRecovery.virtualRegister()));
@@ -11489 +11494 @@
     LValue getArgumentsStart()
     {
-        return getArgumentsStart(m_node->origin.semantic.inlineCallFrame);
+        return getArgumentsStart(m_node->origin.semantic.inlineCallFrame());
     }
     
@@ -16538 +16543 @@
             // and jaz is inlined in baz. We want the callframe for jaz to appear to 
             // have caller be bar.
-            codeOrigin = *codeOrigin.inlineCallFrame->getCallerSkippingTailCalls();
+            codeOrigin = *codeOrigin.inlineCallFrame()->getCallerSkippingTailCalls();
         }
 

trunk/Source/JavaScriptCore/ftl/FTLOSRExitCompiler.cpp

@@ -287 +287 @@
         if (exit.m_kind == BadCache || exit.m_kind == BadIndexingType) {
             CodeOrigin codeOrigin = exit.m_codeOriginForExitProfile;
-            if (ArrayProfile* arrayProfile = jit.baselineCodeBlockFor(codeOrigin)->getArrayProfile(codeOrigin.bytecodeIndex)) {
+            if (ArrayProfile* arrayProfile = jit.baselineCodeBlockFor(codeOrigin)->getArrayProfile(codeOrigin.bytecodeIndex())) {
                 jit.load32(MacroAssembler::Address(GPRInfo::regT0, JSCell::structureIDOffset()), GPRInfo::regT1);
                 jit.store32(GPRInfo::regT1, arrayProfile->addressOfLastSeenStructureID());

trunk/Source/JavaScriptCore/ftl/FTLOperations.cpp

@@ -279 +279 @@
     case PhantomDirectArguments:
     case PhantomClonedArguments: {
-        if (!materialization->origin().inlineCallFrame) {
+        if (!materialization->origin().inlineCallFrame()) {
             switch (materialization->type()) {
             case PhantomDirectArguments:
@@ -304 +304 @@
         // First figure out the argument count. If there isn't one then we represent the machine frame.
         unsigned argumentCount = 0;
-        if (materialization->origin().inlineCallFrame->isVarargs()) {
+        if (materialization->origin().inlineCallFrame()->isVarargs()) {
             for (unsigned i = materialization->properties().size(); i--;) {
                 const ExitPropertyValue& property = materialization->properties()[i];
@@ -313 +313 @@
             }
         } else
-            argumentCount = materialization->origin().inlineCallFrame->argumentCountIncludingThis;
+            argumentCount = materialization->origin().inlineCallFrame()->argumentCountIncludingThis;
         RELEASE_ASSERT(argumentCount);
         
         JSFunction* callee = nullptr;
-        if (materialization->origin().inlineCallFrame->isClosureCall) {
+        if (materialization->origin().inlineCallFrame()->isClosureCall) {
             for (unsigned i = materialization->properties().size(); i--;) {
                 const ExitPropertyValue& property = materialization->properties()[i];
@@ -327 +327 @@
             }
         } else
-            callee = materialization->origin().inlineCallFrame->calleeConstant();
+            callee = materialization->origin().inlineCallFrame()->calleeConstant();
         RELEASE_ASSERT(callee);
         
@@ -475 +475 @@
         // and PhantomNewArrayBuffer are always bound to a specific op_new_array_buffer.
         CodeBlock* codeBlock = baselineCodeBlockForOriginAndBaselineCodeBlock(materialization->origin(), exec->codeBlock()->baselineAlternative());
-        const Instruction* currentInstruction = codeBlock->instructions().at(materialization->origin().bytecodeIndex).ptr();
+        const Instruction* currentInstruction = codeBlock->instructions().at(materialization->origin().bytecodeIndex()).ptr();
         if (!currentInstruction->is<OpNewArrayBuffer>()) {
             // This case can happen if Object.keys, an OpCall is first converted into a NewArrayBuffer which is then converted into a PhantomNewArrayBuffer.

trunk/Source/JavaScriptCore/interpreter/CallFrame.cpp

@@ -157 +157 @@
         ASSERT(codeBlock());
         CodeOrigin codeOrigin = this->codeOrigin();
-        for (InlineCallFrame* inlineCallFrame = codeOrigin.inlineCallFrame; inlineCallFrame;) {
+        for (InlineCallFrame* inlineCallFrame = codeOrigin.inlineCallFrame(); inlineCallFrame;) {
             codeOrigin = inlineCallFrame->directCaller;
-            inlineCallFrame = codeOrigin.inlineCallFrame;
+            inlineCallFrame = codeOrigin.inlineCallFrame();
         }
-        return codeOrigin.bytecodeIndex;
+        return codeOrigin.bytecodeIndex();
     }
 #endif

trunk/Source/JavaScriptCore/interpreter/StackVisitor.cpp

@@ -97 +97 @@
     if (m_frame.isInlinedFrame()) {
         CodeOrigin codeOrigin = m_frame.inlineCallFrame()->directCaller;
-        while (codeOrigin.inlineCallFrame)
-            codeOrigin = codeOrigin.inlineCallFrame->directCaller;
+        while (codeOrigin.inlineCallFrame())
+            codeOrigin = codeOrigin.inlineCallFrame()->directCaller;
         readNonInlinedFrame(m_frame.callFrame(), &codeOrigin);
     }
@@ -145 +145 @@
 
     CodeOrigin codeOrigin = codeBlock->codeOrigin(index);
-    if (!codeOrigin.inlineCallFrame) {
+    if (!codeOrigin.inlineCallFrame()) {
         readNonInlinedFrame(callFrame, &codeOrigin);
         return;
@@ -178 +178 @@
         m_frame.m_codeBlock = callFrame->codeBlock();
         m_frame.m_bytecodeOffset = !m_frame.codeBlock() ? 0
-            : codeOrigin ? codeOrigin->bytecodeIndex
+            : codeOrigin ? codeOrigin->bytecodeIndex()
             : callFrame->bytecodeOffset();
 
@@ -191 +191 @@
 static int inlinedFrameOffset(CodeOrigin* codeOrigin)
 {
-    InlineCallFrame* inlineCallFrame = codeOrigin->inlineCallFrame;
+    InlineCallFrame* inlineCallFrame = codeOrigin->inlineCallFrame();
     int frameOffset = inlineCallFrame ? inlineCallFrame->stackOffset : 0;
     return frameOffset;
@@ -204 +204 @@
     bool isInlined = !!frameOffset;
     if (isInlined) {
-        InlineCallFrame* inlineCallFrame = codeOrigin->inlineCallFrame;
+        InlineCallFrame* inlineCallFrame = codeOrigin->inlineCallFrame();
 
         m_frame.m_callFrame = callFrame;
@@ -213 +213 @@
             m_frame.m_argumentCountIncludingThis = inlineCallFrame->argumentCountIncludingThis;
         m_frame.m_codeBlock = inlineCallFrame->baselineCodeBlock.get();
-        m_frame.m_bytecodeOffset = codeOrigin->bytecodeIndex;
+        m_frame.m_bytecodeOffset = codeOrigin->bytecodeIndex();
 
         JSFunction* callee = inlineCallFrame->calleeForCallFrame(callFrame);

trunk/Source/JavaScriptCore/interpreter/StackVisitor.h

@@ -34 +34 @@
 namespace JSC {
 
-struct CodeOrigin;
 struct EntryFrame;
 struct InlineCallFrame;
 
 class CodeBlock;
+class CodeOrigin;
 class ExecState;
 class JSCell;

trunk/Source/JavaScriptCore/jit/AssemblyHelpers.cpp

@@ -45 +45 @@
 ExecutableBase* AssemblyHelpers::executableFor(const CodeOrigin& codeOrigin)
 {
-    if (!codeOrigin.inlineCallFrame)
+    auto* inlineCallFrame = codeOrigin.inlineCallFrame();
+    if (!inlineCallFrame)
         return m_codeBlock->ownerExecutable();
-    
-    return codeOrigin.inlineCallFrame->baselineCodeBlock->ownerExecutable();
+    return inlineCallFrame->baselineCodeBlock->ownerExecutable();
 }
 

trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h

@@ -1433 +1433 @@
     bool isStrictModeFor(CodeOrigin codeOrigin)
     {
-        if (!codeOrigin.inlineCallFrame)
+        auto* inlineCallFrame = codeOrigin.inlineCallFrame();
+        if (!inlineCallFrame)
             return codeBlock()->isStrictMode();
-        return codeOrigin.inlineCallFrame->isStrictMode();
+        return inlineCallFrame->isStrictMode();
     }
     
@@ -1475 +1476 @@
     static VirtualRegister argumentsStart(const CodeOrigin& codeOrigin)
     {
-        return argumentsStart(codeOrigin.inlineCallFrame);
+        return argumentsStart(codeOrigin.inlineCallFrame());
     }
 
@@ -1488 +1489 @@
     static VirtualRegister argumentCount(const CodeOrigin& codeOrigin)
     {
-        return argumentCount(codeOrigin.inlineCallFrame);
+        return argumentCount(codeOrigin.inlineCallFrame());
     }
     

trunk/Source/JavaScriptCore/jit/PCToCodeOriginMap.cpp

@@ -192 +192 @@
     CodeOrigin lastCodeOrigin(0, nullptr);
     auto buildCodeOriginTable = [&] (const CodeOrigin& codeOrigin) {
-        intptr_t delta = static_cast<intptr_t>(codeOrigin.bytecodeIndex) - static_cast<intptr_t>(lastCodeOrigin.bytecodeIndex);
+        intptr_t delta = static_cast<intptr_t>(codeOrigin.bytecodeIndex()) - static_cast<intptr_t>(lastCodeOrigin.bytecodeIndex());
         lastCodeOrigin = codeOrigin;
         if (delta > std::numeric_limits<int8_t>::max() || delta < std::numeric_limits<int8_t>::min() || delta == sentinelBytecodeDelta) {
@@ -200 +200 @@
             codeOriginCompressor.write<int8_t>(static_cast<int8_t>(delta));
 
-        int8_t hasInlineCallFrameByte = codeOrigin.inlineCallFrame ? 1 : 0;
+        int8_t hasInlineCallFrameByte = codeOrigin.inlineCallFrame() ? 1 : 0;
         codeOriginCompressor.write<int8_t>(hasInlineCallFrameByte);
         if (hasInlineCallFrameByte)
-            codeOriginCompressor.write<uintptr_t>(bitwise_cast<uintptr_t>(codeOrigin.inlineCallFrame));
+            codeOriginCompressor.write<uintptr_t>(bitwise_cast<uintptr_t>(codeOrigin.inlineCallFrame()));
     };
 
@@ -255 +255 @@
 
     uintptr_t currentPC = 0;
-    CodeOrigin currentCodeOrigin(0, nullptr);
+    unsigned currentBytecodeIndex = 0;
+    InlineCallFrame* currentInlineCallFrame = nullptr;
 
     DeltaCompresseionReader pcReader(m_compressedPCs, m_compressedPCBufferSize);
@@ -271 +272 @@
         }
 
-        CodeOrigin previousOrigin = currentCodeOrigin;
+        CodeOrigin previousOrigin = CodeOrigin(currentBytecodeIndex, currentInlineCallFrame);
         {
             int8_t value = codeOriginReader.read<int8_t>();
@@ -280 +281 @@
                 delta = static_cast<intptr_t>(value);
 
-            currentCodeOrigin.bytecodeIndex = static_cast<unsigned>(static_cast<intptr_t>(currentCodeOrigin.bytecodeIndex) + delta);
+            currentBytecodeIndex = static_cast<unsigned>(static_cast<intptr_t>(currentBytecodeIndex) + delta);
 
             int8_t hasInlineFrame = codeOriginReader.read<int8_t>();
             ASSERT(hasInlineFrame == 0 || hasInlineFrame == 1);
             if (hasInlineFrame)
-                currentCodeOrigin.inlineCallFrame = bitwise_cast<InlineCallFrame*>(codeOriginReader.read<uintptr_t>());
+                currentInlineCallFrame = bitwise_cast<InlineCallFrame*>(codeOriginReader.read<uintptr_t>());
             else
-                currentCodeOrigin.inlineCallFrame = nullptr;
+                currentInlineCallFrame = nullptr;
         }
 

trunk/Source/JavaScriptCore/profiler/ProfilerOriginStack.cpp

@@ -49 +49 @@
     Vector<CodeOrigin> stack = codeOrigin.inlineStack();
     
-    append(Origin(database, codeBlock, stack[0].bytecodeIndex));
+    append(Origin(database, codeBlock, stack[0].bytecodeIndex()));
     
     for (unsigned i = 1; i < stack.size(); ++i) {
         append(Origin(
-            database.ensureBytecodesFor(stack[i].inlineCallFrame->baselineCodeBlock.get()),
-            stack[i].bytecodeIndex));
+            database.ensureBytecodesFor(stack[i].inlineCallFrame()->baselineCodeBlock.get()),
+            stack[i].bytecodeIndex()));
     }
 }

trunk/Source/JavaScriptCore/profiler/ProfilerOriginStack.h

@@ -34 +34 @@
 
 class CodeBlock;
-struct CodeOrigin;
+class CodeOrigin;
 
 namespace Profiler {

trunk/Source/JavaScriptCore/runtime/ErrorInstance.cpp

@@ -67 +67 @@
     CodeBlock* codeBlock;
     CodeOrigin codeOrigin = callFrame->codeOrigin();
-    if (codeOrigin && codeOrigin.inlineCallFrame)
-        codeBlock = baselineCodeBlockForInlineCallFrame(codeOrigin.inlineCallFrame);
+    if (codeOrigin && codeOrigin.inlineCallFrame())
+        codeBlock = baselineCodeBlockForInlineCallFrame(codeOrigin.inlineCallFrame());
     else
         codeBlock = callFrame->codeBlock();

trunk/Source/JavaScriptCore/runtime/SamplingProfiler.cpp

@@ -557 +557 @@
             origin.walkUpInlineStack([&] (const CodeOrigin& codeOrigin) {
                 machineOrigin = codeOrigin;
-                appendCodeBlock(codeOrigin.inlineCallFrame ? codeOrigin.inlineCallFrame->baselineCodeBlock.get() : machineCodeBlock, codeOrigin.bytecodeIndex);
+                auto* inlineCallFrame = codeOrigin.inlineCallFrame();
+                appendCodeBlock(inlineCallFrame ? inlineCallFrame->baselineCodeBlock.get() : machineCodeBlock, codeOrigin.bytecodeIndex());
             });
 
             if (Options::collectSamplingProfilerDataForJSCShell()) {
                 RELEASE_ASSERT(machineOrigin.isSet());
-                RELEASE_ASSERT(!machineOrigin.inlineCallFrame);
+                RELEASE_ASSERT(!machineOrigin.inlineCallFrame());
 
                 StackFrame::CodeLocation machineLocation = stackTrace.frames.last().semanticLocation;