static inline bool UncachedInlineCall(VMFrame &f, InitialFrameFlags initial, void **pret, bool *unjittable, uint32_t argc) { AssertCanGC(); JSContext *cx = f.cx; CallArgs args = CallArgsFromSp(argc, f.regs.sp); RootedFunction newfun(cx, args.callee().toFunction()); RootedScript newscript(cx, newfun->getOrCreateScript(cx)); if (!newscript) return false; bool construct = InitialFrameFlagsAreConstructing(initial); RootedScript fscript(cx, f.script()); bool newType = construct && cx->typeInferenceEnabled() && types::UseNewType(cx, fscript, f.pc()); if (!types::TypeMonitorCall(cx, args, construct)) return false; /* Try to compile if not already compiled. */ if (ShouldJaegerCompileCallee(cx, f.script(), newscript, f.jit())) { CompileStatus status = CanMethodJIT(cx, newscript, newscript->code, construct, CompileRequest_JIT, f.fp()); if (status == Compile_Error) { /* A runtime exception was thrown, get out. */ return false; } if (status == Compile_Abort) *unjittable = true; } /* * Make sure we are not calling from an inline frame if we need to make a * call object for the callee, as doing so could trigger GC and cause * jitcode discarding / frame expansion. */ if (f.regs.inlined() && newfun->isHeavyweight()) { ExpandInlineFrames(cx->compartment); JS_ASSERT(!f.regs.inlined()); } /* * Preserve f.regs.fp while pushing the new frame, for the invariant that * f.regs reflects the state when we entered the stub call. This handoff is * tricky: we need to make sure that f.regs is not updated to the new * frame, and we also need to ensure that cx->regs still points to f.regs * when space is reserved, in case doing so throws an exception. */ FrameRegs regs = f.regs; /* Get pointer to new frame/slots, prepare arguments. */ if (!cx->stack.pushInlineFrame(cx, regs, args, *newfun, newscript, initial, &f.stackLimit)) return false; /* Finish the handoff to the new frame regs. */ PreserveRegsGuard regsGuard(cx, regs); /* * If newscript was successfully compiled, run it. Skip for calls which * will be constructing a new type object for 'this'. */ if (!newType) { if (JITScript *jit = newscript->getJIT(regs.fp()->isConstructing(), cx->compartment->compileBarriers())) { if (jit->invokeEntry) { *pret = jit->invokeEntry; /* Restore the old fp around and let the JIT code repush the new fp. */ regs.popFrame((Value *) regs.fp()); return true; } } } /* * Otherwise, run newscript in the interpreter. Expand any inlined frame we * are calling from, as the new frame is not associated with the VMFrame * and will not have its prevpc info updated if frame expansion is * triggered while interpreting. */ if (f.regs.inlined()) { ExpandInlineFrames(cx->compartment); JS_ASSERT(!f.regs.inlined()); regs.fp()->resetInlinePrev(f.fp(), f.regs.pc); } JS_CHECK_RECURSION(cx, return false); RootedScript script(cx, newscript); bool ok = RunScript(cx, script, cx->fp()); f.cx->stack.popInlineFrame(regs); if (ok) { RootedScript fscript(cx, f.script()); types::TypeScript::Monitor(f.cx, fscript, f.pc(), args.rval()); } *pret = NULL; return ok; }
/* * This helper function brings the ContextStack to the top of the thread stack * (so that it can be extended to push a frame and/or arguments) by potentially * pushing a StackSegment. The 'pushedSeg' outparam indicates whether such a * segment was pushed (and hence whether the caller needs to call popSegment). * * Additionally, to minimize calls to ensureSpace, ensureOnTop ensures that * there is space for nvars slots on top of the stack. */ Value * ContextStack::ensureOnTop(JSContext *cx, MaybeReportError report, unsigned nvars, MaybeExtend extend, bool *pushedSeg) { Value *firstUnused = space().firstUnused(); FrameRegs *regs = cx->maybeRegs(); #ifdef JS_METHODJIT /* * The only calls made by inlined methodjit frames can be to other JIT * frames associated with the same VMFrame. If we try to Invoke(), * Execute() or so forth, any topmost inline frame will need to be * expanded (along with other inline frames in the compartment). * To avoid pathological behavior here, make sure to mark any topmost * function as uninlineable, which will expand inline frames if there are * any and prevent the function from being inlined in the future. * * Note: When called from pushBailoutFrame, error = DONT_REPORT_ERROR. Use * this to deny potential invalidation, which would read from * runtime->ionTop. */ if (regs && report != DONT_REPORT_ERROR) { RootedFunction fun(cx); if (InlinedSite *site = regs->inlined()) { mjit::JITChunk *chunk = regs->fp()->jit()->chunk(regs->pc); fun = chunk->inlineFrames()[site->inlineIndex].fun; } else { StackFrame *fp = regs->fp(); if (fp->isFunctionFrame()) { JSFunction *f = fp->fun(); if (f->isInterpreted()) fun = f; } } if (fun) { AutoCompartment ac(cx, fun); fun->script()->uninlineable = true; types::MarkTypeObjectFlags(cx, fun, types::OBJECT_FLAG_UNINLINEABLE); } } JS_ASSERT_IF(cx->hasfp(), !cx->regs().inlined()); #endif if (onTop() && extend) { if (!space().ensureSpace(cx, report, firstUnused, nvars)) return NULL; return firstUnused; } if (!space().ensureSpace(cx, report, firstUnused, VALUES_PER_STACK_SEGMENT + nvars)) return NULL; CallArgsList *calls; if (seg_ && extend) { regs = seg_->maybeRegs(); calls = seg_->maybeCalls(); } else { regs = NULL; calls = NULL; } seg_ = new(firstUnused) StackSegment(seg_, space().seg_, regs, calls); space().seg_ = seg_; *pushedSeg = true; return seg_->slotsBegin(); }