/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- * vim: set ts=8 sts=4 et sw=4 tw=99: * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #ifndef jit_BaselineFrame_h #define jit_BaselineFrame_h #include "jit/JitFrames.h" #include "vm/Stack.h" namespace js { namespace jit { struct BaselineDebugModeOSRInfo; // The stack looks like this, fp is the frame pointer: // // fp+y arguments // fp+x JitFrameLayout (frame header) // fp => saved frame pointer // fp-x BaselineFrame // locals // stack values class BaselineFrame { public: enum Flags : uint32_t { // The frame has a valid return value. See also InterpreterFrame::HAS_RVAL. HAS_RVAL = 1 << 0, // An initial environment has been pushed on the environment chain for // function frames that need a CallObject or eval frames that need a // VarEnvironmentObject. HAS_INITIAL_ENV = 1 << 2, // Frame has an arguments object, argsObj_. HAS_ARGS_OBJ = 1 << 4, // See InterpreterFrame::PREV_UP_TO_DATE. PREV_UP_TO_DATE = 1 << 5, // Frame has execution observed by a Debugger. // // See comment above 'isDebuggee' in jscompartment.h for explanation of // invariants of debuggee compartments, scripts, and frames. DEBUGGEE = 1 << 6, // (1 << 7 and 1 << 8 are unused) // Frame has over-recursed on an early check. OVER_RECURSED = 1 << 9, // Frame has a BaselineRecompileInfo stashed in the scratch value // slot. See PatchBaselineFramesForDebugMode. HAS_DEBUG_MODE_OSR_INFO = 1 << 10, // This flag is intended for use whenever the frame is settled on a // native code address without a corresponding ICEntry. In this case, // the frame contains an explicit bytecode offset for frame iterators. // // There can also be an override pc if the frame has had its // environment chain unwound to a pc during exception handling that is // different from its current pc. // // This flag should never be set when we're executing JIT code. HAS_OVERRIDE_PC = 1 << 11, // If set, we're handling an exception for this frame. This is set for // debug mode OSR sanity checking when it handles corner cases which // only arise during exception handling. HANDLING_EXCEPTION = 1 << 12, // If set, this frame has been on the stack when // |js::SavedStacks::saveCurrentStack| was called, and so there is a // |js::SavedFrame| object cached for this frame. HAS_CACHED_SAVED_FRAME = 1 << 13 }; protected: // Silence Clang warning about unused private fields. // We need to split the Value into 2 fields of 32 bits, otherwise the C++ // compiler may add some padding between the fields. union { struct { uint32_t loScratchValue_; uint32_t hiScratchValue_; }; BaselineDebugModeOSRInfo* debugModeOSRInfo_; }; uint32_t loReturnValue_; // If HAS_RVAL, the frame's return value. uint32_t hiReturnValue_; uint32_t frameSize_; JSObject* envChain_; // Environment chain (always initialized). ArgumentsObject* argsObj_; // If HAS_ARGS_OBJ, the arguments object. uint32_t overrideOffset_; // If HAS_OVERRIDE_PC, the bytecode offset. uint32_t flags_; public: // Distance between the frame pointer and the frame header (return address). // This is the old frame pointer saved in the prologue. static const uint32_t FramePointerOffset = sizeof(void*); MOZ_MUST_USE bool initForOsr(InterpreterFrame* fp, uint32_t numStackValues); uint32_t frameSize() const { return frameSize_; } void setFrameSize(uint32_t frameSize) { frameSize_ = frameSize; } inline uint32_t* addressOfFrameSize() { return &frameSize_; } JSObject* environmentChain() const { return envChain_; } void setEnvironmentChain(JSObject* envChain) { envChain_ = envChain; } inline JSObject** addressOfEnvironmentChain() { return &envChain_; } inline Value* addressOfScratchValue() { return reinterpret_cast<Value*>(&loScratchValue_); } template <typename SpecificEnvironment> inline void pushOnEnvironmentChain(SpecificEnvironment& env); template <typename SpecificEnvironment> inline void popOffEnvironmentChain(); inline void replaceInnermostEnvironment(EnvironmentObject& env); CalleeToken calleeToken() const { uint8_t* pointer = (uint8_t*)this + Size() + offsetOfCalleeToken(); return *(CalleeToken*)pointer; } void replaceCalleeToken(CalleeToken token) { uint8_t* pointer = (uint8_t*)this + Size() + offsetOfCalleeToken(); *(CalleeToken*)pointer = token; } bool isConstructing() const { return CalleeTokenIsConstructing(calleeToken()); } JSScript* script() const { return ScriptFromCalleeToken(calleeToken()); } JSFunction* callee() const { return CalleeTokenToFunction(calleeToken()); } Value calleev() const { return ObjectValue(*callee()); } size_t numValueSlots() const { size_t size = frameSize(); MOZ_ASSERT(size >= BaselineFrame::FramePointerOffset + BaselineFrame::Size()); size -= BaselineFrame::FramePointerOffset + BaselineFrame::Size(); MOZ_ASSERT((size % sizeof(Value)) == 0); return size / sizeof(Value); } Value* valueSlot(size_t slot) const { MOZ_ASSERT(slot < numValueSlots()); return (Value*)this - (slot + 1); } Value& unaliasedFormal(unsigned i, MaybeCheckAliasing checkAliasing = CHECK_ALIASING) const { MOZ_ASSERT(i < numFormalArgs()); MOZ_ASSERT_IF(checkAliasing, !script()->argsObjAliasesFormals() && !script()->formalIsAliased(i)); return argv()[i]; } Value& unaliasedActual(unsigned i, MaybeCheckAliasing checkAliasing = CHECK_ALIASING) const { MOZ_ASSERT(i < numActualArgs()); MOZ_ASSERT_IF(checkAliasing, !script()->argsObjAliasesFormals()); MOZ_ASSERT_IF(checkAliasing && i < numFormalArgs(), !script()->formalIsAliased(i)); return argv()[i]; } Value& unaliasedLocal(uint32_t i) const { MOZ_ASSERT(i < script()->nfixed()); return *valueSlot(i); } unsigned numActualArgs() const { return *(size_t*)(reinterpret_cast<const uint8_t*>(this) + BaselineFrame::Size() + offsetOfNumActualArgs()); } unsigned numFormalArgs() const { return script()->functionNonDelazifying()->nargs(); } Value& thisArgument() const { MOZ_ASSERT(isFunctionFrame()); return *(Value*)(reinterpret_cast<const uint8_t*>(this) + BaselineFrame::Size() + offsetOfThis()); } Value* argv() const { return (Value*)(reinterpret_cast<const uint8_t*>(this) + BaselineFrame::Size() + offsetOfArg(0)); } private: Value* evalNewTargetAddress() const { MOZ_ASSERT(isEvalFrame()); MOZ_ASSERT(script()->isDirectEvalInFunction()); return (Value*)(reinterpret_cast<const uint8_t*>(this) + BaselineFrame::Size() + offsetOfEvalNewTarget()); } public: Value newTarget() const { if (isEvalFrame()) return *evalNewTargetAddress(); MOZ_ASSERT(isFunctionFrame()); if (callee()->isArrow()) return callee()->getExtendedSlot(FunctionExtended::ARROW_NEWTARGET_SLOT); if (isConstructing()) { return *(Value*)(reinterpret_cast<const uint8_t*>(this) + BaselineFrame::Size() + offsetOfArg(Max(numFormalArgs(), numActualArgs()))); } return UndefinedValue(); } bool hasReturnValue() const { return flags_ & HAS_RVAL; } MutableHandleValue returnValue() { if (!hasReturnValue()) addressOfReturnValue()->setUndefined(); return MutableHandleValue::fromMarkedLocation(addressOfReturnValue()); } void setReturnValue(const Value& v) { returnValue().set(v); flags_ |= HAS_RVAL; } inline Value* addressOfReturnValue() { return reinterpret_cast<Value*>(&loReturnValue_); } bool hasInitialEnvironment() const { return flags_ & HAS_INITIAL_ENV; } inline CallObject& callObj() const; void setFlags(uint32_t flags) { flags_ = flags; } uint32_t* addressOfFlags() { return &flags_; } inline MOZ_MUST_USE bool pushLexicalEnvironment(JSContext* cx, Handle<LexicalScope*> scope); inline MOZ_MUST_USE bool freshenLexicalEnvironment(JSContext* cx); inline MOZ_MUST_USE bool recreateLexicalEnvironment(JSContext* cx); MOZ_MUST_USE bool initFunctionEnvironmentObjects(JSContext* cx); MOZ_MUST_USE bool pushVarEnvironment(JSContext* cx, HandleScope scope); void initArgsObjUnchecked(ArgumentsObject& argsobj) { flags_ |= HAS_ARGS_OBJ; argsObj_ = &argsobj; } void initArgsObj(ArgumentsObject& argsobj) { MOZ_ASSERT(script()->needsArgsObj()); initArgsObjUnchecked(argsobj); } bool hasArgsObj() const { return flags_ & HAS_ARGS_OBJ; } ArgumentsObject& argsObj() const { MOZ_ASSERT(hasArgsObj()); MOZ_ASSERT(script()->needsArgsObj()); return *argsObj_; } bool prevUpToDate() const { return flags_ & PREV_UP_TO_DATE; } void setPrevUpToDate() { flags_ |= PREV_UP_TO_DATE; } void unsetPrevUpToDate() { flags_ &= ~PREV_UP_TO_DATE; } bool isDebuggee() const { return flags_ & DEBUGGEE; } void setIsDebuggee() { flags_ |= DEBUGGEE; } inline void unsetIsDebuggee(); bool isHandlingException() const { return flags_ & HANDLING_EXCEPTION; } void setIsHandlingException() { flags_ |= HANDLING_EXCEPTION; } void unsetIsHandlingException() { flags_ &= ~HANDLING_EXCEPTION; } bool hasCachedSavedFrame() const { return flags_ & HAS_CACHED_SAVED_FRAME; } void setHasCachedSavedFrame() { flags_ |= HAS_CACHED_SAVED_FRAME; } bool overRecursed() const { return flags_ & OVER_RECURSED; } void setOverRecursed() { flags_ |= OVER_RECURSED; } BaselineDebugModeOSRInfo* debugModeOSRInfo() { MOZ_ASSERT(flags_ & HAS_DEBUG_MODE_OSR_INFO); return debugModeOSRInfo_; } BaselineDebugModeOSRInfo* getDebugModeOSRInfo() { if (flags_ & HAS_DEBUG_MODE_OSR_INFO) return debugModeOSRInfo(); return nullptr; } void setDebugModeOSRInfo(BaselineDebugModeOSRInfo* info) { flags_ |= HAS_DEBUG_MODE_OSR_INFO; debugModeOSRInfo_ = info; } void deleteDebugModeOSRInfo(); // See the HAS_OVERRIDE_PC comment. bool hasOverridePc() const { return flags_ & HAS_OVERRIDE_PC; } jsbytecode* overridePc() const { MOZ_ASSERT(hasOverridePc()); return script()->offsetToPC(overrideOffset_); } jsbytecode* maybeOverridePc() const { if (hasOverridePc()) return overridePc(); return nullptr; } void setOverridePc(jsbytecode* pc) { flags_ |= HAS_OVERRIDE_PC; overrideOffset_ = script()->pcToOffset(pc); } void clearOverridePc() { flags_ &= ~HAS_OVERRIDE_PC; } void trace(JSTracer* trc, JitFrameIterator& frame); bool isGlobalFrame() const { return script()->isGlobalCode(); } bool isModuleFrame() const { return script()->module(); } bool isEvalFrame() const { return script()->isForEval(); } bool isStrictEvalFrame() const { return isEvalFrame() && script()->strict(); } bool isNonStrictEvalFrame() const { return isEvalFrame() && !script()->strict(); } bool isNonGlobalEvalFrame() const; bool isNonStrictDirectEvalFrame() const { return isNonStrictEvalFrame() && isNonGlobalEvalFrame(); } bool isFunctionFrame() const { return CalleeTokenIsFunction(calleeToken()); } bool isDebuggerEvalFrame() const { return false; } JitFrameLayout* framePrefix() const { uint8_t* fp = (uint8_t*)this + Size() + FramePointerOffset; return (JitFrameLayout*)fp; } // Methods below are used by the compiler. static size_t offsetOfCalleeToken() { return FramePointerOffset + js::jit::JitFrameLayout::offsetOfCalleeToken(); } static size_t offsetOfThis() { return FramePointerOffset + js::jit::JitFrameLayout::offsetOfThis(); } static size_t offsetOfEvalNewTarget() { return FramePointerOffset + js::jit::JitFrameLayout::offsetOfEvalNewTarget(); } static size_t offsetOfArg(size_t index) { return FramePointerOffset + js::jit::JitFrameLayout::offsetOfActualArg(index); } static size_t offsetOfNumActualArgs() { return FramePointerOffset + js::jit::JitFrameLayout::offsetOfNumActualArgs(); } static size_t Size() { return sizeof(BaselineFrame); } // The reverseOffsetOf methods below compute the offset relative to the // frame's base pointer. Since the stack grows down, these offsets are // negative. static int reverseOffsetOfFrameSize() { return -int(Size()) + offsetof(BaselineFrame, frameSize_); } static int reverseOffsetOfScratchValue() { return -int(Size()) + offsetof(BaselineFrame, loScratchValue_); } static int reverseOffsetOfEnvironmentChain() { return -int(Size()) + offsetof(BaselineFrame, envChain_); } static int reverseOffsetOfArgsObj() { return -int(Size()) + offsetof(BaselineFrame, argsObj_); } static int reverseOffsetOfFlags() { return -int(Size()) + offsetof(BaselineFrame, flags_); } static int reverseOffsetOfReturnValue() { return -int(Size()) + offsetof(BaselineFrame, loReturnValue_); } static int reverseOffsetOfLocal(size_t index) { return -int(Size()) - (index + 1) * sizeof(Value); } }; // Ensure the frame is 8-byte aligned (required on ARM). JS_STATIC_ASSERT(((sizeof(BaselineFrame) + BaselineFrame::FramePointerOffset) % 8) == 0); } // namespace jit } // namespace js #endif /* jit_BaselineFrame_h */