MDefinition *
MIRGraph::parSlice() {
// Search the entry block to find a par slice instruction. If we do not
// find one, add one after the Start instruction.
//
// Note: the original design used a field in MIRGraph to cache the
// parSlice rather than searching for it again. However, this
// could become out of date due to DCE. Given that we do not
// generally have to search very far to find the par slice
// instruction if it exists, and that we don't look for it that
// often, I opted to simply eliminate the cache and search anew
// each time, so that it is that much easier to keep the IR
// coherent. - nmatsakis
MBasicBlock *entry = entryBlock();
JS_ASSERT(entry->info().executionMode() == ParallelExecution);
MInstruction *start = NULL;
for (MInstructionIterator ins(entry->begin()); ins != entry->end(); ins++) {
if (ins->isParSlice())
return *ins;
else if (ins->isStart())
start = *ins;
}
JS_ASSERT(start);
MParSlice *parSlice = new MParSlice();
entry->insertAfter(start, parSlice);
return parSlice;
}
MDefinition *
MIRGraph::forkJoinContext()
{
// Search the entry block to find a ForkJoinContext instruction. If we do
// not find one, add one after the Start instruction.
//
// Note: the original design used a field in MIRGraph to cache the
// forkJoinContext rather than searching for it again. However, this
// could become out of date due to DCE. Given that we do not generally
// have to search very far to find the ForkJoinContext instruction if it
// exists, and that we don't look for it that often, I opted to simply
// eliminate the cache and search anew each time, so that it is that much
// easier to keep the IR coherent. - nmatsakis
MBasicBlock *entry = entryBlock();
JS_ASSERT(entry->info().executionMode() == ParallelExecution);
MInstruction *start = nullptr;
for (MInstructionIterator ins(entry->begin()); ins != entry->end(); ins++) {
if (ins->isForkJoinContext())
return *ins;
else if (ins->isStart())
start = *ins;
}
JS_ASSERT(start);
MForkJoinContext *cx = MForkJoinContext::New(alloc());
entry->insertAfter(start, cx);
return cx;
}
bool
MResumePoint::writeRecoverData(CompactBufferWriter &writer) const
{
writer.writeUnsigned(uint32_t(RInstruction::Recover_ResumePoint));
MBasicBlock *bb = block();
JSFunction *fun = bb->info().funMaybeLazy();
JSScript *script = bb->info().script();
uint32_t exprStack = stackDepth() - bb->info().ninvoke();
#ifdef DEBUG
// Ensure that all snapshot which are encoded can safely be used for
// bailouts.
if (GetIonContext()->cx) {
uint32_t stackDepth;
bool reachablePC;
jsbytecode *bailPC = pc();
if (mode() == MResumePoint::ResumeAfter)
bailPC = GetNextPc(pc());
if (!ReconstructStackDepth(GetIonContext()->cx, script,
bailPC, &stackDepth, &reachablePC))
{
return false;
}
if (reachablePC) {
if (JSOp(*bailPC) == JSOP_FUNCALL) {
// For fun.call(this, ...); the reconstructStackDepth will
// include the this. When inlining that is not included. So the
// exprStackSlots will be one less.
MOZ_ASSERT(stackDepth - exprStack <= 1);
} else if (JSOp(*bailPC) != JSOP_FUNAPPLY &&
!IsGetPropPC(bailPC) && !IsSetPropPC(bailPC))
{
// For fun.apply({}, arguments) the reconstructStackDepth will
// have stackdepth 4, but it could be that we inlined the
// funapply. In that case exprStackSlots, will have the real
// arguments in the slots and not be 4.
// With accessors, we have different stack depths depending on
// whether or not we inlined the accessor, as the inlined stack
// contains a callee function that should never have been there
// and we might just be capturing an uneventful property site,
// in which case there won't have been any violence.
MOZ_ASSERT(exprStack == stackDepth);
}
}
}
#endif
// Test if we honor the maximum of arguments at all times. This is a sanity
// check and not an algorithm limit. So check might be a bit too loose. +4
// to account for scope chain, return value, this value and maybe
// arguments_object.
MOZ_ASSERT(CountArgSlots(script, fun) < SNAPSHOT_MAX_NARGS + 4);
uint32_t implicit = StartArgSlot(script);
uint32_t formalArgs = CountArgSlots(script, fun);
uint32_t nallocs = formalArgs + script->nfixed() + exprStack;
JitSpew(JitSpew_IonSnapshots, "Starting frame; implicit %u, formals %u, fixed %u, exprs %u",
implicit, formalArgs - implicit, script->nfixed(), exprStack);
uint32_t pcoff = script->pcToOffset(pc());
JitSpew(JitSpew_IonSnapshots, "Writing pc offset %u, nslots %u", pcoff, nallocs);
writer.writeUnsigned(pcoff);
writer.writeUnsigned(nallocs);
return true;
}
