wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 988475 - Rename IonFrame_* enum to JitFrame_*. r=nbp

Browse Source 
--HG--
extra : rebase_source : 597e04cf1c6bcd2a177d1bc1386d222f8cb62a6d
This commit is contained in:
Jan de Mooij 2014-03-27 10:11:55 -04:00
parent 8f72b31966
commit 74d82bcb98
32 changed files with 194 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
js/src/jit/AsmJS.cpp
View File

@ -6521,7 +6521,7 @@ GenerateFFIIonExit(ModuleCompiler &m, const ModuleCompiler::ExitDescriptor &exit
masm.reserveStack(stackDec - extraBytes);
// 1. Descriptor
uint32_t descriptor = MakeFrameDescriptor(masm.framePushed() + extraBytes, IonFrame_Entry);
uint32_t descriptor = MakeFrameDescriptor(masm.framePushed() + extraBytes, JitFrame_Entry);
masm.storePtr(ImmWord(uintptr_t(descriptor)), Address(StackPointer, 0));
// 2. Callee

4
js/src/jit/Bailouts.cpp
View File

@ -50,7 +50,7 @@ SnapshotIterator::SnapshotIterator(const IonBailoutIterator &iter)
void
IonBailoutIterator::dump() const
{
if (type_ == IonFrame_OptimizedJS) {
if (type_ == JitFrame_IonJS) {
InlineFrameIterator frames(GetJSContextFromJitCode(), this);
for (;;) {
frames.dump();
@ -150,7 +150,7 @@ IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &activations,
const OsiIndex *osiIndex = frame.osiIndex();
current_ = (uint8_t *) frame.fp();
type_ = IonFrame_OptimizedJS;
type_ = JitFrame_IonJS;
topFrameSize_ = frame.frameSize();
snapshotOffset_ = osiIndex->snapshotOffset();
}

34
js/src/jit/BaselineBailouts.cpp
View File

@ -317,23 +317,23 @@ struct BaselineStackBuilder
BufferPointer<IonJSFrameLayout> topFrame = topFrameAddress();
FrameType type = topFrame->prevType();
// For OptimizedJS and Entry frames, the "saved" frame pointer in the baseline
// For IonJS and Entry frames, the "saved" frame pointer in the baseline
// frame is meaningless, since Ion saves all registers before calling other ion
// frames, and the entry frame saves all registers too.
if (type == IonFrame_OptimizedJS || type == IonFrame_Entry)
if (type == JitFrame_IonJS || type == JitFrame_Entry)
return nullptr;
// BaselineStub - Baseline calling into Ion.
// PrevFramePtr needs to point to the BaselineStubFrame's saved frame pointer.
// STACK_START_ADDR + IonJSFrameLayout::Size() + PREV_FRAME_SIZE
// - IonBaselineStubFrameLayout::reverseOffsetOfSavedFramePtr()
if (type == IonFrame_BaselineStub) {
if (type == JitFrame_BaselineStub) {
size_t offset = IonJSFrameLayout::Size() + topFrame->prevFrameLocalSize() +
IonBaselineStubFrameLayout::reverseOffsetOfSavedFramePtr();
return virtualPointerAtStackOffset(offset);
}
JS_ASSERT(type == IonFrame_Rectifier);
JS_ASSERT(type == JitFrame_Rectifier);
// Rectifier - behaviour depends on the frame preceding the rectifier frame, and
// whether the arch is x86 or not. The x86 rectifier frame saves the frame pointer,
// so we can calculate it directly. For other archs, the previous frame pointer
@ -350,11 +350,11 @@ struct BaselineStackBuilder
BufferPointer<IonRectifierFrameLayout> priorFrame =
pointerAtStackOffset<IonRectifierFrameLayout>(priorOffset);
FrameType priorType = priorFrame->prevType();
JS_ASSERT(priorType == IonFrame_OptimizedJS || priorType == IonFrame_BaselineStub);
JS_ASSERT(priorType == JitFrame_IonJS || priorType == JitFrame_BaselineStub);
// If the frame preceding the rectifier is an OptimizedJS frame, then once again
// If the frame preceding the rectifier is an IonJS frame, then once again
// the frame pointer does not matter.
if (priorType == IonFrame_OptimizedJS)
if (priorType == JitFrame_IonJS)
return nullptr;
// Otherwise, the frame preceding the rectifier is a BaselineStub frame.
@ -1045,7 +1045,7 @@ InitFromBailout(JSContext *cx, HandleScript caller, jsbytecode *callerPC,
// Write out descriptor of BaselineJS frame.
size_t baselineFrameDescr = MakeFrameDescriptor((uint32_t) builder.framePushed(),
IonFrame_BaselineJS);
JitFrame_BaselineJS);
if (!builder.writeWord(baselineFrameDescr, "Descriptor"))
return false;
@ -1134,7 +1134,7 @@ InitFromBailout(JSContext *cx, HandleScript caller, jsbytecode *callerPC,
// Calculate frame size for descriptor.
size_t baselineStubFrameSize = builder.framePushed() - startOfBaselineStubFrame;
size_t baselineStubFrameDescr = MakeFrameDescriptor((uint32_t) baselineStubFrameSize,
IonFrame_BaselineStub);
JitFrame_BaselineStub);
// Push actual argc
if (!builder.writeWord(actualArgc, "ActualArgc"))
@ -1228,7 +1228,7 @@ InitFromBailout(JSContext *cx, HandleScript caller, jsbytecode *callerPC,
// Calculate frame size for descriptor.
size_t rectifierFrameSize = builder.framePushed() - startOfRectifierFrame;
size_t rectifierFrameDescr = MakeFrameDescriptor((uint32_t) rectifierFrameSize,
IonFrame_Rectifier);
JitFrame_Rectifier);
// Push actualArgc
if (!builder.writeWord(actualArgc, "ActualArgc"))
@ -1265,16 +1265,16 @@ jit::BailoutIonToBaseline(JSContext *cx, JitActivation *activation, IonBailoutIt
#endif
// The caller of the top frame must be one of the following:
// OptimizedJS - Ion calling into Ion.
// IonJS - Ion calling into Ion.
// BaselineStub - Baseline calling into Ion.
// Entry - Interpreter or other calling into Ion.
// Rectifier - Arguments rectifier calling into Ion.
JS_ASSERT(iter.isOptimizedJS());
JS_ASSERT(iter.isIonJS());
FrameType prevFrameType = iter.prevType();
JS_ASSERT(prevFrameType == IonFrame_OptimizedJS ||
prevFrameType == IonFrame_BaselineStub ||
prevFrameType == IonFrame_Entry ||
prevFrameType == IonFrame_Rectifier);
JS_ASSERT(prevFrameType == JitFrame_IonJS ||
prevFrameType == JitFrame_BaselineStub ||
prevFrameType == JitFrame_Entry ||
prevFrameType == JitFrame_Rectifier);
// All incoming frames are going to look like this:
//
@ -1523,7 +1523,7 @@ jit::FinishBailoutToBaseline(BaselineBailoutInfo *bailoutInfo)
uint32_t frameno = 0;
while (frameno < numFrames) {
JS_ASSERT(!iter.isOptimizedJS());
JS_ASSERT(!iter.isIonJS());
if (iter.isBaselineJS()) {
BaselineFrame *frame = iter.baselineFrame();

4
js/src/jit/BaselineIC.cpp
View File

@ -751,10 +751,10 @@ IsTopFrameConstructing(JSContext *cx)
JS_ASSERT(cx->currentlyRunningInJit());
JitActivationIterator activations(cx->runtime());
IonFrameIterator iter(activations);
JS_ASSERT(iter.type() == IonFrame_Exit);
JS_ASSERT(iter.type() == JitFrame_Exit);
++iter;
JS_ASSERT(iter.type() == IonFrame_BaselineStub);
JS_ASSERT(iter.type() == JitFrame_BaselineStub);
++iter;
JS_ASSERT(iter.isBaselineJS());

4
js/src/jit/BaselineJIT.cpp
View File

@ -932,10 +932,10 @@ MarkActiveBaselineScripts(JSRuntime *rt, const JitActivationIterator &activation
{
for (jit::IonFrameIterator iter(activation); !iter.done(); ++iter) {
switch (iter.type()) {
case IonFrame_BaselineJS:
case JitFrame_BaselineJS:
iter.script()->baselineScript()->setActive();
break;
case IonFrame_OptimizedJS: {
case JitFrame_IonJS: {
// Keep the baseline script around, since bailouts from the ion
// jitcode might need to re-enter into the baseline jitcode.
iter.script()->baselineScript()->setActive();

6
js/src/jit/CodeGenerator.cpp
View File

@ -2114,7 +2114,7 @@ CodeGenerator::visitCallGeneric(LCallGeneric *call)
masm.freeStack(unusedStack);
// Construct the IonFramePrefix.
uint32_t descriptor = MakeFrameDescriptor(masm.framePushed(), IonFrame_OptimizedJS);
uint32_t descriptor = MakeFrameDescriptor(masm.framePushed(), JitFrame_IonJS);
masm.Push(Imm32(call->numActualArgs()));
masm.Push(calleereg);
masm.Push(Imm32(descriptor));
@ -2235,7 +2235,7 @@ CodeGenerator::visitCallKnown(LCallKnown *call)
masm.freeStack(unusedStack);
// Construct the IonFramePrefix.
uint32_t descriptor = MakeFrameDescriptor(masm.framePushed(), IonFrame_OptimizedJS);
uint32_t descriptor = MakeFrameDescriptor(masm.framePushed(), JitFrame_IonJS);
masm.Push(Imm32(call->numActualArgs()));
masm.Push(calleereg);
masm.Push(Imm32(descriptor));
@ -2442,7 +2442,7 @@ CodeGenerator::visitApplyArgsGeneric(LApplyArgsGeneric *apply)
// Create the frame descriptor.
unsigned pushed = masm.framePushed();
masm.addPtr(Imm32(pushed), copyreg);
masm.makeFrameDescriptor(copyreg, IonFrame_OptimizedJS);
masm.makeFrameDescriptor(copyreg, JitFrame_IonJS);
masm.Push(argcreg);
masm.Push(calleereg);

24
js/src/jit/Ion.cpp
View File

@ -2464,42 +2464,42 @@ InvalidateActivation(FreeOp *fop, uint8_t *ionTop, bool invalidateAll)
size_t frameno = 1;
for (IonFrameIterator it(ionTop, SequentialExecution); !it.done(); ++it, ++frameno) {
JS_ASSERT_IF(frameno == 1, it.type() == IonFrame_Exit);
JS_ASSERT_IF(frameno == 1, it.type() == JitFrame_Exit);
#ifdef DEBUG
switch (it.type()) {
case IonFrame_Exit:
case JitFrame_Exit:
IonSpew(IonSpew_Invalidate, "#%d exit frame @ %p", frameno, it.fp());
break;
case IonFrame_BaselineJS:
case IonFrame_OptimizedJS:
case JitFrame_BaselineJS:
case JitFrame_IonJS:
{
JS_ASSERT(it.isScripted());
const char *type = it.isOptimizedJS() ? "Optimized" : "Baseline";
const char *type = it.isIonJS() ? "Optimized" : "Baseline";
IonSpew(IonSpew_Invalidate, "#%d %s JS frame @ %p, %s:%d (fun: %p, script: %p, pc %p)",
frameno, type, it.fp(), it.script()->filename(), it.script()->lineno(),
it.maybeCallee(), (JSScript *)it.script(), it.returnAddressToFp());
break;
}
case IonFrame_BaselineStub:
case JitFrame_BaselineStub:
IonSpew(IonSpew_Invalidate, "#%d baseline stub frame @ %p", frameno, it.fp());
break;
case IonFrame_Rectifier:
case JitFrame_Rectifier:
IonSpew(IonSpew_Invalidate, "#%d rectifier frame @ %p", frameno, it.fp());
break;
case IonFrame_Unwound_OptimizedJS:
case IonFrame_Unwound_BaselineStub:
case JitFrame_Unwound_IonJS:
case JitFrame_Unwound_BaselineStub:
MOZ_ASSUME_UNREACHABLE("invalid");
case IonFrame_Unwound_Rectifier:
case JitFrame_Unwound_Rectifier:
IonSpew(IonSpew_Invalidate, "#%d unwound rectifier frame @ %p", frameno, it.fp());
break;
case IonFrame_Entry:
case JitFrame_Entry:
IonSpew(IonSpew_Invalidate, "#%d entry frame @ %p", frameno, it.fp());
break;
}
#endif
if (!it.isOptimizedJS())
if (!it.isIonJS())
continue;
// See if the frame has already been invalidated.

42
js/src/jit/IonFrameIterator.h
View File

@ -26,40 +26,40 @@ namespace jit {
enum FrameType
{
// A JS frame is analagous to a js::InterpreterFrame, representing one scripted
// functon activation. OptimizedJS frames are used by the optimizing compiler.
IonFrame_OptimizedJS,
// functon activation. IonJS frames are used by the optimizing compiler.
JitFrame_IonJS,
// JS frame used by the baseline JIT.
IonFrame_BaselineJS,
JitFrame_BaselineJS,
// Frame pushed for baseline JIT stubs that make non-tail calls, so that the
// return address -> ICEntry mapping works.
IonFrame_BaselineStub,
JitFrame_BaselineStub,
// The entry frame is the initial prologue block transitioning from the VM
// into the Ion world.
IonFrame_Entry,
JitFrame_Entry,
// A rectifier frame sits in between two JS frames, adapting argc != nargs
// mismatches in calls.
IonFrame_Rectifier,
JitFrame_Rectifier,
// An unwound JS frame is a JS frame signalling that its callee frame has been
// turned into an exit frame (see EnsureExitFrame). Used by Ion bailouts and
// Baseline exception unwinding.
IonFrame_Unwound_OptimizedJS,
JitFrame_Unwound_IonJS,
// Like Unwound_OptimizedJS, but the caller is a baseline stub frame.
IonFrame_Unwound_BaselineStub,
// Like Unwound_IonJS, but the caller is a baseline stub frame.
JitFrame_Unwound_BaselineStub,
// An unwound rectifier frame is a rectifier frame signalling that its callee
// frame has been turned into an exit frame (see EnsureExitFrame).
IonFrame_Unwound_Rectifier,
JitFrame_Unwound_Rectifier,
// An exit frame is necessary for transitioning from a JS frame into C++.
// From within C++, an exit frame is always the last frame in any
// JitActivation.
IonFrame_Exit
JitFrame_Exit
};
enum ReadFrameArgsBehavior {
@ -99,7 +99,7 @@ class IonFrameIterator
public:
explicit IonFrameIterator(uint8_t *top, ExecutionMode mode)
: current_(top),
type_(IonFrame_Exit),
type_(JitFrame_Exit),
returnAddressToFp_(nullptr),
frameSize_(0),
cachedSafepointIndex_(nullptr),
@ -141,16 +141,16 @@ class IonFrameIterator
bool checkInvalidation() const;
bool isScripted() const {
return type_ == IonFrame_BaselineJS || type_ == IonFrame_OptimizedJS;
return type_ == JitFrame_BaselineJS || type_ == JitFrame_IonJS;
}
bool isBaselineJS() const {
return type_ == IonFrame_BaselineJS;
return type_ == JitFrame_BaselineJS;
}
bool isOptimizedJS() const {
return type_ == IonFrame_OptimizedJS;
bool isIonJS() const {
return type_ == JitFrame_IonJS;
}
bool isBaselineStub() const {
return type_ == IonFrame_BaselineStub;
return type_ == JitFrame_BaselineStub;
}
bool isNative() const;
bool isOOLNative() const;
@ -158,7 +158,7 @@ class IonFrameIterator
bool isOOLProxy() const;
bool isDOMExit() const;
bool isEntry() const {
return type_ == IonFrame_Entry;
return type_ == JitFrame_Entry;
}
bool isFunctionFrame() const;
@ -186,14 +186,14 @@ class IonFrameIterator
// Returns the stack space used by the current frame, in bytes. This does
// not include the size of its fixed header.
size_t frameSize() const {
JS_ASSERT(type_ != IonFrame_Exit);
JS_ASSERT(type_ != JitFrame_Exit);
return frameSize_;
}
// Functions used to iterate on frames. When prevType is IonFrame_Entry,
// Functions used to iterate on frames. When prevType is JitFrame_Entry,
// the current frame is the last frame.
inline bool done() const {
return type_ == IonFrame_Entry;
return type_ == JitFrame_Entry;
}
IonFrameIterator &operator++();

12
js/src/jit/IonFrames-inl.h
View File

@ -54,17 +54,17 @@ IonFrameIterator::prevType() const
inline bool
IonFrameIterator::isFakeExitFrame() const
{
bool res = (prevType() == IonFrame_Unwound_Rectifier ||
prevType() == IonFrame_Unwound_OptimizedJS ||
prevType() == IonFrame_Unwound_BaselineStub);
JS_ASSERT_IF(res, type() == IonFrame_Exit || type() == IonFrame_BaselineJS);
bool res = (prevType() == JitFrame_Unwound_Rectifier ||
prevType() == JitFrame_Unwound_IonJS ||
prevType() == JitFrame_Unwound_BaselineStub);
JS_ASSERT_IF(res, type() == JitFrame_Exit || type() == JitFrame_BaselineJS);
return res;
}
inline IonExitFrameLayout *
IonFrameIterator::exitFrame() const
{
JS_ASSERT(type() == IonFrame_Exit);
JS_ASSERT(type() == JitFrame_Exit);
JS_ASSERT(!isFakeExitFrame());
return (IonExitFrameLayout *) fp();
}
@ -73,7 +73,7 @@ inline BaselineFrame *
GetTopBaselineFrame(JSContext *cx)
{
IonFrameIterator iter(cx);
JS_ASSERT(iter.type() == IonFrame_Exit);
JS_ASSERT(iter.type() == JitFrame_Exit);
++iter;
if (iter.isBaselineStub())
++iter;

128
js/src/jit/IonFrames.cpp
View File

@ -73,7 +73,7 @@ ReadFrameBooleanSlot(IonJSFrameLayout *fp, int32_t slot)
IonFrameIterator::IonFrameIterator(JSContext *cx)
: current_(cx->mainThread().ionTop),
type_(IonFrame_Exit),
type_(JitFrame_Exit),
returnAddressToFp_(nullptr),
frameSize_(0),
cachedSafepointIndex_(nullptr),
@ -84,7 +84,7 @@ IonFrameIterator::IonFrameIterator(JSContext *cx)
IonFrameIterator::IonFrameIterator(const ActivationIterator &activations)
: current_(activations.jitTop()),
type_(IonFrame_Exit),
type_(JitFrame_Exit),
returnAddressToFp_(nullptr),
frameSize_(0),
cachedSafepointIndex_(nullptr),
@ -95,7 +95,7 @@ IonFrameIterator::IonFrameIterator(const ActivationIterator &activations)
IonFrameIterator::IonFrameIterator(IonJSFrameLayout *fp, ExecutionMode mode)
: current_((uint8_t *)fp),
type_(IonFrame_OptimizedJS),
type_(JitFrame_IonJS),
returnAddressToFp_(fp->returnAddress()),
frameSize_(fp->prevFrameLocalSize()),
mode_(mode)
@ -160,7 +160,7 @@ IonFrameIterator::maybeCallee() const
bool
IonFrameIterator::isNative() const
{
if (type_ != IonFrame_Exit || isFakeExitFrame())
if (type_ != JitFrame_Exit || isFakeExitFrame())
return false;
return exitFrame()->footer()->jitCode() == nullptr;
}
@ -168,7 +168,7 @@ IonFrameIterator::isNative() const
bool
IonFrameIterator::isOOLNative() const
{
if (type_ != IonFrame_Exit)
if (type_ != JitFrame_Exit)
return false;
return exitFrame()->footer()->jitCode() == ION_FRAME_OOL_NATIVE;
}
@ -176,7 +176,7 @@ IonFrameIterator::isOOLNative() const
bool
IonFrameIterator::isOOLPropertyOp() const
{
if (type_ != IonFrame_Exit)
if (type_ != JitFrame_Exit)
return false;
return exitFrame()->footer()->jitCode() == ION_FRAME_OOL_PROPERTY_OP;
}
@ -184,7 +184,7 @@ IonFrameIterator::isOOLPropertyOp() const
bool
IonFrameIterator::isOOLProxy() const
{
if (type_ != IonFrame_Exit)
if (type_ != JitFrame_Exit)
return false;
return exitFrame()->footer()->jitCode() == ION_FRAME_OOL_PROXY;
}
@ -192,7 +192,7 @@ IonFrameIterator::isOOLProxy() const
bool
IonFrameIterator::isDOMExit() const
{
if (type_ != IonFrame_Exit)
if (type_ != JitFrame_Exit)
return false;
return exitFrame()->isDomExit();
}
@ -254,19 +254,19 @@ static inline size_t
SizeOfFramePrefix(FrameType type)
{
switch (type) {
case IonFrame_Entry:
case JitFrame_Entry:
return IonEntryFrameLayout::Size();
case IonFrame_BaselineJS:
case IonFrame_OptimizedJS:
case IonFrame_Unwound_OptimizedJS:
case JitFrame_BaselineJS:
case JitFrame_IonJS:
case JitFrame_Unwound_IonJS:
return IonJSFrameLayout::Size();
case IonFrame_BaselineStub:
case JitFrame_BaselineStub:
return IonBaselineStubFrameLayout::Size();
case IonFrame_Rectifier:
case JitFrame_Rectifier:
return IonRectifierFrameLayout::Size();
case IonFrame_Unwound_Rectifier:
case JitFrame_Unwound_Rectifier:
return IonUnwoundRectifierFrameLayout::Size();
case IonFrame_Exit:
case JitFrame_Exit:
return IonExitFrameLayout::Size();
default:
MOZ_ASSUME_UNREACHABLE("unknown frame type");
@ -281,9 +281,9 @@ IonFrameIterator::prevFp() const
// needed because the descriptor size of JS-to-JS frame which is just after
// a Rectifier frame should not change. (cf EnsureExitFrame function)
if (isFakeExitFrame()) {
JS_ASSERT(SizeOfFramePrefix(IonFrame_BaselineJS) ==
SizeOfFramePrefix(IonFrame_OptimizedJS));
currentSize = SizeOfFramePrefix(IonFrame_OptimizedJS);
JS_ASSERT(SizeOfFramePrefix(JitFrame_BaselineJS) ==
SizeOfFramePrefix(JitFrame_IonJS));
currentSize = SizeOfFramePrefix(JitFrame_IonJS);
}
currentSize += current()->prevFrameLocalSize();
return current_ + currentSize;
@ -292,15 +292,15 @@ IonFrameIterator::prevFp() const
IonFrameIterator &
IonFrameIterator::operator++()
{
JS_ASSERT(type_ != IonFrame_Entry);
JS_ASSERT(type_ != JitFrame_Entry);
frameSize_ = prevFrameLocalSize();
cachedSafepointIndex_ = nullptr;
// If the next frame is the entry frame, just exit. Don't update current_,
// since the entry and first frames overlap.
if (current()->prevType() == IonFrame_Entry) {
type_ = IonFrame_Entry;
if (current()->prevType() == JitFrame_Entry) {
type_ = JitFrame_Entry;
return *this;
}
@ -308,10 +308,10 @@ IonFrameIterator::operator++()
// next frame.
uint8_t *prev = prevFp();
type_ = current()->prevType();
if (type_ == IonFrame_Unwound_OptimizedJS)
type_ = IonFrame_OptimizedJS;
else if (type_ == IonFrame_Unwound_BaselineStub)
type_ = IonFrame_BaselineStub;
if (type_ == JitFrame_Unwound_IonJS)
type_ = JitFrame_IonJS;
else if (type_ == JitFrame_Unwound_BaselineStub)
type_ = JitFrame_BaselineStub;
returnAddressToFp_ = current()->returnAddress();
current_ = prev;
return *this;
@ -585,7 +585,7 @@ HandleException(ResumeFromException *rfe)
IonFrameIterator iter(cx);
while (!iter.isEntry()) {
bool overrecursed = false;
if (iter.isOptimizedJS()) {
if (iter.isIonJS()) {
// Search each inlined frame for live iterator objects, and close
// them.
InlineFrameIterator frames(cx, &iter);
@ -718,36 +718,36 @@ HandleParallelFailure(ResumeFromException *rfe)
void
EnsureExitFrame(IonCommonFrameLayout *frame)
{
if (frame->prevType() == IonFrame_Unwound_OptimizedJS ||
frame->prevType() == IonFrame_Unwound_BaselineStub ||
frame->prevType() == IonFrame_Unwound_Rectifier)
if (frame->prevType() == JitFrame_Unwound_IonJS ||
frame->prevType() == JitFrame_Unwound_BaselineStub ||
frame->prevType() == JitFrame_Unwound_Rectifier)
{
// Already an exit frame, nothing to do.
return;
}
if (frame->prevType() == IonFrame_Entry) {
if (frame->prevType() == JitFrame_Entry) {
// The previous frame type is the entry frame, so there's no actual
// need for an exit frame.
return;
}
if (frame->prevType() == IonFrame_Rectifier) {
if (frame->prevType() == JitFrame_Rectifier) {
// The rectifier code uses the frame descriptor to discard its stack,
// so modifying its descriptor size here would be dangerous. Instead,
// we change the frame type, and teach the stack walking code how to
// deal with this edge case. bug 717297 would obviate the need
frame->changePrevType(IonFrame_Unwound_Rectifier);
frame->changePrevType(JitFrame_Unwound_Rectifier);
return;
}
if (frame->prevType() == IonFrame_BaselineStub) {
frame->changePrevType(IonFrame_Unwound_BaselineStub);
if (frame->prevType() == JitFrame_BaselineStub) {
frame->changePrevType(JitFrame_Unwound_BaselineStub);
return;
}
JS_ASSERT(frame->prevType() == IonFrame_OptimizedJS);
frame->changePrevType(IonFrame_Unwound_OptimizedJS);
JS_ASSERT(frame->prevType() == JitFrame_IonJS);
frame->changePrevType(JitFrame_Unwound_IonJS);
}
CalleeToken
@ -945,7 +945,7 @@ MarkBaselineStubFrame(JSTracer *trc, const IonFrameIterator &frame)
// Mark the ICStub pointer stored in the stub frame. This is necessary
// so that we don't destroy the stub code after unlinking the stub.
JS_ASSERT(frame.type() == IonFrame_BaselineStub);
JS_ASSERT(frame.type() == JitFrame_BaselineStub);
IonBaselineStubFrameLayout *layout = (IonBaselineStubFrameLayout *)frame.fp();
if (ICStub *stub = layout->maybeStubPtr()) {
@ -1158,24 +1158,24 @@ MarkJitActivation(JSTracer *trc, const JitActivationIterator &activations)
for (IonFrameIterator frames(activations); !frames.done(); ++frames) {
switch (frames.type()) {
case IonFrame_Exit:
case JitFrame_Exit:
MarkJitExitFrame(trc, frames);
break;
case IonFrame_BaselineJS:
case JitFrame_BaselineJS:
frames.baselineFrame()->trace(trc, frames);
break;
case IonFrame_BaselineStub:
case JitFrame_BaselineStub:
MarkBaselineStubFrame(trc, frames);
break;
case IonFrame_OptimizedJS:
case JitFrame_IonJS:
MarkIonJSFrame(trc, frames);
break;
case IonFrame_Unwound_OptimizedJS:
case JitFrame_Unwound_IonJS:
MOZ_ASSUME_UNREACHABLE("invalid");
case IonFrame_Rectifier:
case JitFrame_Rectifier:
MarkRectifierFrame(trc, frames);
break;
case IonFrame_Unwound_Rectifier:
case JitFrame_Unwound_Rectifier:
break;
default:
MOZ_ASSUME_UNREACHABLE("unexpected frame type");
@ -1197,7 +1197,7 @@ UpdateJitActivationsForMinorGC(JSRuntime *rt, JSTracer *trc)
JS_ASSERT(trc->runtime->isHeapMinorCollecting());
for (JitActivationIterator activations(rt); !activations.done(); ++activations) {
for (IonFrameIterator frames(activations); !frames.done(); ++frames) {
if (frames.type() == IonFrame_OptimizedJS)
if (frames.type() == JitFrame_IonJS)
UpdateIonJSFrameForMinorGC(trc, frames);
}
}
@ -1223,19 +1223,19 @@ GetPcScript(JSContext *cx, JSScript **scriptRes, jsbytecode **pcRes)
// If the previous frame is a rectifier frame (maybe unwound),
// skip past it.
if (it.prevType() == IonFrame_Rectifier || it.prevType() == IonFrame_Unwound_Rectifier) {
if (it.prevType() == JitFrame_Rectifier || it.prevType() == JitFrame_Unwound_Rectifier) {
++it;
JS_ASSERT(it.prevType() == IonFrame_BaselineStub ||
it.prevType() == IonFrame_BaselineJS ||
it.prevType() == IonFrame_OptimizedJS);
JS_ASSERT(it.prevType() == JitFrame_BaselineStub ||
it.prevType() == JitFrame_BaselineJS ||
it.prevType() == JitFrame_IonJS);
}
// If the previous frame is a stub frame, skip the exit frame so that
// returnAddress below gets the return address into the BaselineJS
// frame.
if (it.prevType() == IonFrame_BaselineStub || it.prevType() == IonFrame_Unwound_BaselineStub) {
if (it.prevType() == JitFrame_BaselineStub || it.prevType() == JitFrame_Unwound_BaselineStub) {
++it;
JS_ASSERT(it.prevType() == IonFrame_BaselineJS);
JS_ASSERT(it.prevType() == JitFrame_BaselineJS);
}
uint8_t *retAddr = it.returnAddress();
@ -1257,7 +1257,7 @@ GetPcScript(JSContext *cx, JSScript **scriptRes, jsbytecode **pcRes)
++it; // Skip exit frame.
jsbytecode *pc = nullptr;
if (it.isOptimizedJS()) {
if (it.isIonJS()) {
InlineFrameIterator ifi(cx, &it);
*scriptRes = ifi.script();
pc = ifi.pc();
@ -1494,7 +1494,7 @@ SnapshotIterator::allocationValue(const RValueAllocation &alloc)
IonScript *
IonFrameIterator::ionScript() const
{
JS_ASSERT(type() == IonFrame_OptimizedJS);
JS_ASSERT(type() == JitFrame_IonJS);
IonScript *ionScript = nullptr;
if (checkInvalidation(&ionScript))
@ -1659,7 +1659,7 @@ IonFrameIterator::isConstructing() const
++parent;
} while (!parent.done() && !parent.isScripted());
if (parent.isOptimizedJS()) {
if (parent.isIonJS()) {
// In the case of a JS frame, look up the pc from the snapshot.
InlineFrameIterator inlinedParent(GetJSContextFromJitCode(), &parent);
@ -1832,19 +1832,19 @@ void
IonFrameIterator::dump() const
{
switch (type_) {
case IonFrame_Entry:
case JitFrame_Entry:
fprintf(stderr, " Entry frame\n");
fprintf(stderr, " Frame size: %u\n", unsigned(current()->prevFrameLocalSize()));
break;
case IonFrame_BaselineJS:
case JitFrame_BaselineJS:
dumpBaseline();
break;
case IonFrame_BaselineStub:
case IonFrame_Unwound_BaselineStub:
case JitFrame_BaselineStub:
case JitFrame_Unwound_BaselineStub:
fprintf(stderr, " Baseline stub frame\n");
fprintf(stderr, " Frame size: %u\n", unsigned(current()->prevFrameLocalSize()));
break;
case IonFrame_OptimizedJS:
case JitFrame_IonJS:
{
InlineFrameIterator frames(GetJSContextFromJitCode(), this);
for (;;) {
@ -1855,15 +1855,15 @@ IonFrameIterator::dump() const
}
break;
}
case IonFrame_Rectifier:
case IonFrame_Unwound_Rectifier:
case JitFrame_Rectifier:
case JitFrame_Unwound_Rectifier:
fprintf(stderr, " Rectifier frame\n");
fprintf(stderr, " Frame size: %u\n", unsigned(current()->prevFrameLocalSize()));
break;
case IonFrame_Unwound_OptimizedJS:
case JitFrame_Unwound_IonJS:
fprintf(stderr, "Warning! Unwound JS frames are not observable.\n");
break;
case IonFrame_Exit:
case JitFrame_Exit:
break;
};
fputc('\n', stderr);

2
js/src/jit/IonFrames.h
View File

@ -283,7 +283,7 @@ inline JSScript *
GetTopIonJSScript(uint8_t *ionTop, void **returnAddrOut, ExecutionMode mode)
{
IonFrameIterator iter(ionTop, mode);
JS_ASSERT(iter.type() == IonFrame_Exit);
JS_ASSERT(iter.type() == JitFrame_Exit);
++iter;
JS_ASSERT(iter.returnAddressToFp() != nullptr);

2
js/src/jit/IonMacroAssembler.cpp
View File

@ -1000,7 +1000,7 @@ MacroAssembler::generateBailoutTail(Register scratch, Register bailoutInfo)
// Enter exit frame for the FinishBailoutToBaseline call.
loadPtr(Address(bailoutInfo, offsetof(BaselineBailoutInfo, resumeFramePtr)), temp);
load32(Address(temp, BaselineFrame::reverseOffsetOfFrameSize()), temp);
makeFrameDescriptor(temp, IonFrame_BaselineJS);
makeFrameDescriptor(temp, JitFrame_BaselineJS);
push(temp);
push(Address(bailoutInfo, offsetof(BaselineBailoutInfo, resumeAddr)));
enterFakeExitFrame();

2
js/src/jit/VMFunctions.cpp
View File

@ -1020,7 +1020,7 @@ Recompile(JSContext *cx)
JitActivationIterator activations(cx->runtime());
IonFrameIterator iter(activations);
JS_ASSERT(iter.type() == IonFrame_Exit);
JS_ASSERT(iter.type() == JitFrame_Exit);
++iter;
bool isConstructing = iter.isConstructing();

4
js/src/jit/arm/Bailouts-arm.cpp
View File

@ -77,7 +77,7 @@ IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &activations,
uint8_t *fp = sp + bailout->frameSize();
current_ = fp;
type_ = IonFrame_OptimizedJS;
type_ = JitFrame_IonJS;
topFrameSize_ = current_ - sp;
topIonScript_ = script()->ionScript();
@ -113,7 +113,7 @@ IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &activations,
const OsiIndex *osiIndex = topIonScript_->getOsiIndex(returnAddressToFp_);
current_ = (uint8_t*) bailout->fp();
type_ = IonFrame_OptimizedJS;
type_ = JitFrame_IonJS;
topFrameSize_ = current_ - bailout->sp();
snapshotOffset_ = osiIndex->snapshotOffset();
}

6
js/src/jit/arm/BaselineHelpers-arm.h
View File

@ -100,7 +100,7 @@ EmitTailCallVM(JitCode *target, MacroAssembler &masm, uint32_t argSize)
// the stub calls), but the VMWrapper code being called expects the return address to also
// be pushed on the stack.
JS_ASSERT(BaselineTailCallReg == lr);
masm.makeFrameDescriptor(r0, IonFrame_BaselineJS);
masm.makeFrameDescriptor(r0, JitFrame_BaselineJS);
masm.push(r0);
masm.push(lr);
masm.branch(target);
@ -115,7 +115,7 @@ EmitCreateStubFrameDescriptor(MacroAssembler &masm, Register reg)
masm.ma_add(Imm32(sizeof(void *) * 2), reg);
masm.ma_sub(BaselineStackReg, reg);
masm.makeFrameDescriptor(reg, IonFrame_BaselineStub);
masm.makeFrameDescriptor(reg, JitFrame_BaselineStub);
}
inline void
@ -146,7 +146,7 @@ EmitEnterStubFrame(MacroAssembler &masm, Register scratch)
// if needed.
// Push frame descriptor and return address.
masm.makeFrameDescriptor(scratch, IonFrame_BaselineJS);
masm.makeFrameDescriptor(scratch, JitFrame_BaselineJS);
masm.push(scratch);
masm.push(BaselineTailCallReg);

8
js/src/jit/arm/MacroAssembler-arm.cpp
View File

@ -1713,7 +1713,7 @@ bool
MacroAssemblerARMCompat::buildFakeExitFrame(const Register &scratch, uint32_t *offset)
{
DebugOnly<uint32_t> initialDepth = framePushed();
uint32_t descriptor = MakeFrameDescriptor(framePushed(), IonFrame_OptimizedJS);
uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
Push(Imm32(descriptor)); // descriptor_
@ -1739,7 +1739,7 @@ bool
MacroAssemblerARMCompat::buildOOLFakeExitFrame(void *fakeReturnAddr)
{
DebugOnly<uint32_t> initialDepth = framePushed();
uint32_t descriptor = MakeFrameDescriptor(framePushed(), IonFrame_OptimizedJS);
uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
Push(Imm32(descriptor)); // descriptor_
@ -1753,7 +1753,7 @@ MacroAssemblerARMCompat::buildOOLFakeExitFrame(void *fakeReturnAddr)
void
MacroAssemblerARMCompat::callWithExitFrame(JitCode *target)
{
uint32_t descriptor = MakeFrameDescriptor(framePushed(), IonFrame_OptimizedJS);
uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
Push(Imm32(descriptor)); // descriptor
addPendingJump(m_buffer.nextOffset(), ImmPtr(target->raw()), Relocation::JITCODE);
@ -1771,7 +1771,7 @@ void
MacroAssemblerARMCompat::callWithExitFrame(JitCode *target, Register dynStack)
{
ma_add(Imm32(framePushed()), dynStack);
makeFrameDescriptor(dynStack, IonFrame_OptimizedJS);
makeFrameDescriptor(dynStack, JitFrame_IonJS);
Push(dynStack); // descriptor
addPendingJump(m_buffer.nextOffset(), ImmPtr(target->raw()), Relocation::JITCODE);

6
js/src/jit/arm/Trampoline-arm.cpp
View File

@ -176,7 +176,7 @@ JitRuntime::generateEnterJIT(JSContext *cx, EnterJitType type)
}
masm.ma_sub(r8, sp, r8);
masm.makeFrameDescriptor(r8, IonFrame_Entry);
masm.makeFrameDescriptor(r8, JitFrame_Entry);
masm.startDataTransferM(IsStore, sp, IB, NoWriteBack);
// [sp] = return address (written later)
@ -253,7 +253,7 @@ JitRuntime::generateEnterJIT(JSContext *cx, EnterJitType type)
// Enter exit frame.
masm.addPtr(Imm32(BaselineFrame::Size() + BaselineFrame::FramePointerOffset), scratch);
masm.makeFrameDescriptor(scratch, IonFrame_BaselineJS);
masm.makeFrameDescriptor(scratch, JitFrame_BaselineJS);
masm.push(scratch);
masm.push(Imm32(0)); // Fake return address.
masm.enterFakeExitFrame();
@ -451,7 +451,7 @@ JitRuntime::generateArgumentsRectifier(JSContext *cx, ExecutionMode mode, void *
masm.ma_lsl(Imm32(3), r6, r6);
// Construct sizeDescriptor.
masm.makeFrameDescriptor(r6, IonFrame_Rectifier);
masm.makeFrameDescriptor(r6, JitFrame_Rectifier);
// Construct IonJSFrameLayout.
masm.ma_push(r0); // actual arguments.

6
js/src/jit/mips/BaselineHelpers-mips.h
View File

@ -99,7 +99,7 @@ EmitTailCallVM(JitCode *target, MacroAssembler &masm, uint32_t argSize)
// keep it there through the stub calls), but the VMWrapper code being
// called expects the return address to also be pushed on the stack.
MOZ_ASSERT(BaselineTailCallReg == ra);
masm.makeFrameDescriptor(t6, IonFrame_BaselineJS);
masm.makeFrameDescriptor(t6, JitFrame_BaselineJS);
masm.subPtr(Imm32(sizeof(IonCommonFrameLayout)), StackPointer);
masm.storePtr(t6, Address(StackPointer, IonCommonFrameLayout::offsetOfDescriptor()));
masm.storePtr(ra, Address(StackPointer, IonCommonFrameLayout::offsetOfReturnAddress()));
@ -116,7 +116,7 @@ EmitCreateStubFrameDescriptor(MacroAssembler &masm, Register reg)
masm.addPtr(Imm32(sizeof(intptr_t) * 2), reg);
masm.subPtr(BaselineStackReg, reg);
masm.makeFrameDescriptor(reg, IonFrame_BaselineStub);
masm.makeFrameDescriptor(reg, JitFrame_BaselineStub);
}
inline void
@ -153,7 +153,7 @@ EmitEnterStubFrame(MacroAssembler &masm, Register scratch)
// BaselineStubFrame if needed.
// Push frame descriptor and return address.
masm.makeFrameDescriptor(scratch, IonFrame_BaselineJS);
masm.makeFrameDescriptor(scratch, JitFrame_BaselineJS);
masm.subPtr(Imm32(STUB_FRAME_SIZE), StackPointer);
masm.storePtr(scratch, Address(StackPointer, offsetof(BaselineStubFrame, descriptor)));
masm.storePtr(BaselineTailCallReg, Address(StackPointer,

8
js/src/jit/mips/MacroAssembler-mips.cpp
View File

@ -1458,7 +1458,7 @@ MacroAssemblerMIPSCompat::buildFakeExitFrame(const Register &scratch, uint32_t *
CodeLabel cl;
ma_li(scratch, cl.dest());
uint32_t descriptor = MakeFrameDescriptor(framePushed(), IonFrame_OptimizedJS);
uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
Push(Imm32(descriptor));
Push(scratch);
@ -1473,7 +1473,7 @@ bool
MacroAssemblerMIPSCompat::buildOOLFakeExitFrame(void *fakeReturnAddr)
{
DebugOnly<uint32_t> initialDepth = framePushed();
uint32_t descriptor = MakeFrameDescriptor(framePushed(), IonFrame_OptimizedJS);
uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
Push(Imm32(descriptor)); // descriptor_
Push(ImmPtr(fakeReturnAddr));
@ -1484,7 +1484,7 @@ MacroAssemblerMIPSCompat::buildOOLFakeExitFrame(void *fakeReturnAddr)
void
MacroAssemblerMIPSCompat::callWithExitFrame(JitCode *target)
{
uint32_t descriptor = MakeFrameDescriptor(framePushed(), IonFrame_OptimizedJS);
uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
Push(Imm32(descriptor)); // descriptor
addPendingJump(m_buffer.nextOffset(), ImmPtr(target->raw()), Relocation::JITCODE);
@ -1496,7 +1496,7 @@ void
MacroAssemblerMIPSCompat::callWithExitFrame(JitCode *target, Register dynStack)
{
ma_addu(dynStack, dynStack, Imm32(framePushed()));
makeFrameDescriptor(dynStack, IonFrame_OptimizedJS);
makeFrameDescriptor(dynStack, JitFrame_IonJS);
Push(dynStack); // descriptor
addPendingJump(m_buffer.nextOffset(), ImmPtr(target->raw()), Relocation::JITCODE);

6
js/src/jit/shared/BaselineCompiler-shared.cpp
View File

@ -57,12 +57,12 @@ BaselineCompilerShared::callVM(const VMFunction &fun, CallVMPhase phase)
uint32_t frameFullSize = frameBaseSize + (frameVals * sizeof(Value));
if (phase == POST_INITIALIZE) {
masm.store32(Imm32(frameFullSize), frameSizeAddress);
uint32_t descriptor = MakeFrameDescriptor(frameFullSize + argSize, IonFrame_BaselineJS);
uint32_t descriptor = MakeFrameDescriptor(frameFullSize + argSize, JitFrame_BaselineJS);
masm.push(Imm32(descriptor));
} else if (phase == PRE_INITIALIZE) {
masm.store32(Imm32(frameBaseSize), frameSizeAddress);
uint32_t descriptor = MakeFrameDescriptor(frameBaseSize + argSize, IonFrame_BaselineJS);
uint32_t descriptor = MakeFrameDescriptor(frameBaseSize + argSize, JitFrame_BaselineJS);
masm.push(Imm32(descriptor));
} else {
@ -85,7 +85,7 @@ BaselineCompilerShared::callVM(const VMFunction &fun, CallVMPhase phase)
masm.bind(&afterWrite);
masm.store32(BaselineTailCallReg, frameSizeAddress);
masm.add32(Imm32(argSize), BaselineTailCallReg);
masm.makeFrameDescriptor(BaselineTailCallReg, IonFrame_BaselineJS);
masm.makeFrameDescriptor(BaselineTailCallReg, JitFrame_BaselineJS);
masm.push(BaselineTailCallReg);
}

6
js/src/jit/shared/MacroAssembler-x86-shared.h
View File

@ -664,7 +664,7 @@ class MacroAssemblerX86Shared : public Assembler
CodeLabel cl;
mov(cl.dest(), scratch);
uint32_t descriptor = MakeFrameDescriptor(framePushed(), IonFrame_OptimizedJS);
uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
Push(Imm32(descriptor));
Push(scratch);
@ -676,7 +676,7 @@ class MacroAssemblerX86Shared : public Assembler
}
void callWithExitFrame(JitCode *target) {
uint32_t descriptor = MakeFrameDescriptor(framePushed(), IonFrame_OptimizedJS);
uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
Push(Imm32(descriptor));
call(target);
}
@ -698,7 +698,7 @@ class MacroAssemblerX86Shared : public Assembler
protected:
bool buildOOLFakeExitFrame(void *fakeReturnAddr) {
uint32_t descriptor = MakeFrameDescriptor(framePushed(), IonFrame_OptimizedJS);
uint32_t descriptor = MakeFrameDescriptor(framePushed(), JitFrame_IonJS);
Push(Imm32(descriptor));
Push(ImmPtr(fakeReturnAddr));
return true;

4
js/src/jit/x64/Bailouts-x64.cpp
View File

@ -54,7 +54,7 @@ IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &activations,
uint8_t *fp = sp + bailout->frameSize();
current_ = fp;
type_ = IonFrame_OptimizedJS;
type_ = JitFrame_IonJS;
topFrameSize_ = current_ - sp;
topIonScript_ = script()->ionScript();
snapshotOffset_ = bailout->snapshotOffset();
@ -70,7 +70,7 @@ IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &activations,
const OsiIndex *osiIndex = topIonScript_->getOsiIndex(returnAddressToFp_);
current_ = (uint8_t*) bailout->fp();
type_ = IonFrame_OptimizedJS;
type_ = JitFrame_IonJS;
topFrameSize_ = current_ - bailout->sp();
snapshotOffset_ = osiIndex->snapshotOffset();
}

6
js/src/jit/x64/BaselineHelpers-x64.h
View File

@ -84,7 +84,7 @@ EmitTailCallVM(JitCode *target, MacroAssembler &masm, uint32_t argSize)
masm.store32(rdx, Address(BaselineFrameReg, BaselineFrame::reverseOffsetOfFrameSize()));
// Push frame descriptor and perform the tail call.
masm.makeFrameDescriptor(ScratchReg, IonFrame_BaselineJS);
masm.makeFrameDescriptor(ScratchReg, JitFrame_BaselineJS);
masm.push(ScratchReg);
masm.push(BaselineTailCallReg);
masm.jmp(target);
@ -99,7 +99,7 @@ EmitCreateStubFrameDescriptor(MacroAssembler &masm, Register reg)
masm.addq(Imm32(sizeof(void *) * 2), reg);
masm.subq(BaselineStackReg, reg);
masm.makeFrameDescriptor(reg, IonFrame_BaselineStub);
masm.makeFrameDescriptor(reg, JitFrame_BaselineStub);
}
inline void
@ -130,7 +130,7 @@ EmitEnterStubFrame(MacroAssembler &masm, Register)
// if needed.
// Push frame descriptor and return address.
masm.makeFrameDescriptor(ScratchReg, IonFrame_BaselineJS);
masm.makeFrameDescriptor(ScratchReg, JitFrame_BaselineJS);
masm.push(ScratchReg);
masm.push(BaselineTailCallReg);

2
js/src/jit/x64/MacroAssembler-x64.h
View File

@ -1221,7 +1221,7 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
void callWithExitFrame(JitCode *target, Register dynStack) {
addPtr(Imm32(framePushed()), dynStack);
makeFrameDescriptor(dynStack, IonFrame_OptimizedJS);
makeFrameDescriptor(dynStack, JitFrame_IonJS);
Push(dynStack);
call(target);
}

6
js/src/jit/x64/Trampoline-x64.cpp
View File

@ -139,7 +139,7 @@ JitRuntime::generateEnterJIT(JSContext *cx, EnterJitType type)
masm.subq(rsp, r14);
// Create a frame descriptor.
masm.makeFrameDescriptor(r14, IonFrame_Entry);
masm.makeFrameDescriptor(r14, JitFrame_Entry);
masm.push(r14);
CodeLabel returnLabel;
@ -201,7 +201,7 @@ JitRuntime::generateEnterJIT(JSContext *cx, EnterJitType type)
// Enter exit frame.
masm.addPtr(Imm32(BaselineFrame::Size() + BaselineFrame::FramePointerOffset), valuesSize);
masm.makeFrameDescriptor(valuesSize, IonFrame_BaselineJS);
masm.makeFrameDescriptor(valuesSize, JitFrame_BaselineJS);
masm.push(valuesSize);
masm.push(Imm32(0)); // Fake return address.
masm.enterFakeExitFrame();
@ -401,7 +401,7 @@ JitRuntime::generateArgumentsRectifier(JSContext *cx, ExecutionMode mode, void *
// Construct descriptor.
masm.subq(rsp, r9);
masm.makeFrameDescriptor(r9, IonFrame_Rectifier);
masm.makeFrameDescriptor(r9, JitFrame_Rectifier);
// Construct IonJSFrameLayout.
masm.push(rdx); // numActualArgs

4
js/src/jit/x86/Bailouts-x86.cpp
View File

@ -74,7 +74,7 @@ IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &activations,
uint8_t *fp = sp + bailout->frameSize();
current_ = fp;
type_ = IonFrame_OptimizedJS;
type_ = JitFrame_IonJS;
topFrameSize_ = current_ - sp;
topIonScript_ = script()->ionScript();
@ -110,7 +110,7 @@ IonBailoutIterator::IonBailoutIterator(const JitActivationIterator &activations,
const OsiIndex *osiIndex = topIonScript_->getOsiIndex(returnAddressToFp_);
current_ = (uint8_t*) bailout->fp();
type_ = IonFrame_OptimizedJS;
type_ = JitFrame_IonJS;
topFrameSize_ = current_ - bailout->sp();
snapshotOffset_ = osiIndex->snapshotOffset();
}

6
js/src/jit/x86/BaselineHelpers-x86.h
View File

@ -87,7 +87,7 @@ EmitTailCallVM(JitCode *target, MacroAssembler &masm, uint32_t argSize)
masm.store32(ebx, Address(BaselineFrameReg, BaselineFrame::reverseOffsetOfFrameSize()));
// Push frame descriptor and perform the tail call.
masm.makeFrameDescriptor(eax, IonFrame_BaselineJS);
masm.makeFrameDescriptor(eax, JitFrame_BaselineJS);
masm.push(eax);
masm.push(BaselineTailCallReg);
masm.jmp(target);
@ -102,7 +102,7 @@ EmitCreateStubFrameDescriptor(MacroAssembler &masm, Register reg)
masm.addl(Imm32(sizeof(void *) * 2), reg);
masm.subl(BaselineStackReg, reg);
masm.makeFrameDescriptor(reg, IonFrame_BaselineStub);
masm.makeFrameDescriptor(reg, JitFrame_BaselineStub);
}
inline void
@ -135,7 +135,7 @@ EmitEnterStubFrame(MacroAssembler &masm, Register scratch)
// if needed.
// Push frame descriptor and return address.
masm.makeFrameDescriptor(scratch, IonFrame_BaselineJS);
masm.makeFrameDescriptor(scratch, JitFrame_BaselineJS);
masm.push(scratch);
masm.push(BaselineTailCallReg);

2
js/src/jit/x86/MacroAssembler-x86.h
View File

@ -1067,7 +1067,7 @@ class MacroAssemblerX86 : public MacroAssemblerX86Shared
void callWithExitFrame(JitCode *target, Register dynStack) {
addPtr(Imm32(framePushed()), dynStack);
makeFrameDescriptor(dynStack, IonFrame_OptimizedJS);
makeFrameDescriptor(dynStack, JitFrame_IonJS);
Push(dynStack);
call(target);
}

6
js/src/jit/x86/Trampoline-x86.cpp
View File

@ -132,7 +132,7 @@ JitRuntime::generateEnterJIT(JSContext *cx, EnterJitType type)
*****************************************************************/
// Create a frame descriptor.
masm.subl(esp, esi);
masm.makeFrameDescriptor(esi, IonFrame_Entry);
masm.makeFrameDescriptor(esi, JitFrame_Entry);
masm.push(esi);
CodeLabel returnLabel;
@ -193,7 +193,7 @@ JitRuntime::generateEnterJIT(JSContext *cx, EnterJitType type)
// Enter exit frame.
masm.addPtr(Imm32(BaselineFrame::Size() + BaselineFrame::FramePointerOffset), scratch);
masm.makeFrameDescriptor(scratch, IonFrame_BaselineJS);
masm.makeFrameDescriptor(scratch, JitFrame_BaselineJS);
masm.push(scratch);
masm.push(Imm32(0)); // Fake return address.
masm.enterFakeExitFrame();
@ -401,7 +401,7 @@ JitRuntime::generateArgumentsRectifier(JSContext *cx, ExecutionMode mode, void *
// Construct descriptor, accounting for pushed frame pointer above
masm.lea(Operand(FramePointer, sizeof(void*)), ebx);
masm.subl(esp, ebx);
masm.makeFrameDescriptor(ebx, IonFrame_Rectifier);
masm.makeFrameDescriptor(ebx, JitFrame_Rectifier);
// Construct IonJSFrameLayout.
masm.push(edx); // number of actual arguments

2
js/src/vm/Stack-inl.h
View File

@ -338,7 +338,7 @@ FrameIter::unaliasedForEachActual(JSContext *cx, Op op)
return;
case JIT:
#ifdef JS_ION
if (data_.ionFrames_.isOptimizedJS()) {
if (data_.ionFrames_.isIonJS()) {
ionInlineFrames_.unaliasedForEachActual(cx, op, jit::ReadFrame_Actuals);
} else {
JS_ASSERT(data_.ionFrames_.isBaselineJS());

30
js/src/vm/Stack.cpp
View File

@ -659,7 +659,7 @@ FrameIter::Data::Data(const FrameIter::Data &other)
FrameIter::FrameIter(JSContext *cx, SavedOption savedOption)
: data_(cx, savedOption, CURRENT_CONTEXT, nullptr)
#ifdef JS_ION
, ionInlineFrames_(cx, (js::jit::IonFrameIterator*) nullptr)
, ionInlineFrames_(cx, (js::jit::IonFrameIterator*) nullptr)
#endif
{
settleOnActivation();
@ -669,7 +669,7 @@ FrameIter::FrameIter(JSContext *cx, ContextOption contextOption,
SavedOption savedOption, JSPrincipals *principals)
: data_(cx, savedOption, contextOption, principals)
#ifdef JS_ION
, ionInlineFrames_(cx, (js::jit::IonFrameIterator*) nullptr)
, ionInlineFrames_(cx, (js::jit::IonFrameIterator*) nullptr)
#endif
{
settleOnActivation();
@ -678,8 +678,8 @@ FrameIter::FrameIter(JSContext *cx, ContextOption contextOption,
FrameIter::FrameIter(const FrameIter &other)
: data_(other.data_)
#ifdef JS_ION
, ionInlineFrames_(other.data_.cx_,
data_.ionFrames_.isScripted() ? &other.ionInlineFrames_ : nullptr)
, ionInlineFrames_(other.data_.cx_,
data_.ionFrames_.isScripted() ? &other.ionInlineFrames_ : nullptr)
#endif
{
}
@ -687,7 +687,7 @@ FrameIter::FrameIter(const FrameIter &other)
FrameIter::FrameIter(const Data &data)
: data_(data)
#ifdef JS_ION
, ionInlineFrames_(data.cx_, data_.ionFrames_.isOptimizedJS() ? &data_.ionFrames_ : nullptr)
, ionInlineFrames_(data.cx_, data_.ionFrames_.isIonJS() ? &data_.ionFrames_ : nullptr)
#endif
{
JS_ASSERT(data.cx_);
@ -697,7 +697,7 @@ FrameIter::FrameIter(const Data &data)
void
FrameIter::nextJitFrame()
{
if (data_.ionFrames_.isOptimizedJS()) {
if (data_.ionFrames_.isIonJS()) {
ionInlineFrames_.resetOn(&data_.ionFrames_);
data_.pc_ = ionInlineFrames_.pc();
} else {
@ -711,7 +711,7 @@ FrameIter::popJitFrame()
{
JS_ASSERT(data_.state_ == JIT);
if (data_.ionFrames_.isOptimizedJS() && ionInlineFrames_.more()) {
if (data_.ionFrames_.isIonJS() && ionInlineFrames_.more()) {
++ionInlineFrames_;
data_.pc_ = ionInlineFrames_.pc();
return;
@ -795,7 +795,7 @@ FrameIter::copyData() const
* not copied.
*/
JS_ASSERT(data_.state_ != ASMJS);
JS_ASSERT(data_.ionFrames_.type() != jit::IonFrame_OptimizedJS);
JS_ASSERT(data_.ionFrames_.type() != jit::JitFrame_IonJS);
#endif
return data_.cx_->new_<Data>(data_);
}
@ -1044,7 +1044,7 @@ FrameIter::isConstructing() const
break;
case JIT:
#ifdef JS_ION
if (data_.ionFrames_.isOptimizedJS())
if (data_.ionFrames_.isIonJS())
return ionInlineFrames_.isConstructing();
JS_ASSERT(data_.ionFrames_.isBaselineJS());
return data_.ionFrames_.isConstructing();
@ -1140,7 +1140,7 @@ FrameIter::callee() const
#ifdef JS_ION
if (data_.ionFrames_.isBaselineJS())
return data_.ionFrames_.callee();
JS_ASSERT(data_.ionFrames_.isOptimizedJS());
JS_ASSERT(data_.ionFrames_.isIonJS());
return ionInlineFrames_.callee();
#else
break;
@ -1181,7 +1181,7 @@ FrameIter::numActualArgs() const
return interpFrame()->numActualArgs();
case JIT:
#ifdef JS_ION
if (data_.ionFrames_.isOptimizedJS())
if (data_.ionFrames_.isIonJS())
return ionInlineFrames_.numActualArgs();
JS_ASSERT(data_.ionFrames_.isBaselineJS());
@ -1228,7 +1228,7 @@ FrameIter::scopeChain() const
break;
case JIT:
#ifdef JS_ION
if (data_.ionFrames_.isOptimizedJS())
if (data_.ionFrames_.isIonJS())
return ionInlineFrames_.scopeChain();
return data_.ionFrames_.baselineFrame()->scopeChain();
#else
@ -1313,7 +1313,7 @@ FrameIter::thisv() const
break;
case JIT:
#ifdef JS_ION
if (data_.ionFrames_.isOptimizedJS())
if (data_.ionFrames_.isIonJS())
return ObjectValue(*ionInlineFrames_.thisObject());
return data_.ionFrames_.baselineFrame()->thisValue();
#else
@ -1375,7 +1375,7 @@ FrameIter::numFrameSlots() const
break;
case JIT: {
#ifdef JS_ION
if (data_.ionFrames_.isOptimizedJS()) {
if (data_.ionFrames_.isIonJS()) {
return ionInlineFrames_.snapshotIterator().allocations() -
ionInlineFrames_.script()->nfixed();
}
@ -1401,7 +1401,7 @@ FrameIter::frameSlotValue(size_t index) const
break;
case JIT:
#ifdef JS_ION
if (data_.ionFrames_.isOptimizedJS()) {
if (data_.ionFrames_.isIonJS()) {
jit::SnapshotIterator si(ionInlineFrames_.snapshotIterator());
index += ionInlineFrames_.script()->nfixed();
return si.maybeReadAllocByIndex(index);

4
js/src/vm/Stack.h
View File

@ -1748,7 +1748,7 @@ FrameIter::script() const
return interpFrame()->script();
#ifdef JS_ION
JS_ASSERT(data_.state_ == JIT);
if (data_.ionFrames_.isOptimizedJS())
if (data_.ionFrames_.isIonJS())
return ionInlineFrames_.script();
return data_.ionFrames_.script();
#else
@ -1760,7 +1760,7 @@ inline bool
FrameIter::isIon() const
{
#ifdef JS_ION
return isJit() && data_.ionFrames_.isOptimizedJS();
return isJit() && data_.ionFrames_.isIonJS();
#else
return false;
#endif