/*
- * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Apple Inc. All rights reserved.
* Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
*
* Redistribution and use in source and binary forms, with or without
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
- * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ * 3. Neither the name of Apple Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
#ifndef CodeBlock_h
#define CodeBlock_h
+#include "ArrayProfile.h"
+#include "ByValInfo.h"
+#include "BytecodeConventions.h"
+#include "BytecodeLivenessAnalysis.h"
+#include "CallLinkInfo.h"
+#include "CallReturnOffsetToBytecodeOffset.h"
+#include "CodeBlockHash.h"
+#include "CodeBlockSet.h"
+#include "ConcurrentJITLock.h"
+#include "CodeOrigin.h"
+#include "CodeType.h"
+#include "CompactJITCodeMap.h"
+#include "DFGCommon.h"
+#include "DFGCommonData.h"
+#include "DFGExitProfile.h"
+#include "DeferredCompilationCallback.h"
#include "EvalCodeCache.h"
+#include "ExecutionCounter.h"
+#include "ExpressionRangeInfo.h"
+#include "HandlerInfo.h"
+#include "ObjectAllocationProfile.h"
+#include "Options.h"
+#include "PutPropertySlot.h"
#include "Instruction.h"
#include "JITCode.h"
#include "JITWriteBarrier.h"
#include "JSGlobalObject.h"
#include "JumpTable.h"
-#include "Nodes.h"
+#include "LLIntCallLinkInfo.h"
+#include "LazyOperandValueProfile.h"
+#include "ProfilerCompilation.h"
+#include "ProfilerJettisonReason.h"
#include "RegExpObject.h"
-#include "UString.h"
-#include <wtf/FastAllocBase.h>
+#include "StructureStubInfo.h"
+#include "UnconditionalFinalizer.h"
+#include "ValueProfile.h"
+#include "VirtualRegister.h"
+#include "Watchpoint.h"
+#include <wtf/Bag.h>
+#include <wtf/FastMalloc.h>
#include <wtf/PassOwnPtr.h>
+#include <wtf/RefCountedArray.h>
#include <wtf/RefPtr.h>
+#include <wtf/SegmentedVector.h>
#include <wtf/Vector.h>
+#include <wtf/text/WTFString.h>
-#if ENABLE(JIT)
-#include "StructureStubInfo.h"
-#endif
+namespace JSC {
-// Register numbers used in bytecode operations have different meaning according to their ranges:
-// 0x80000000-0xFFFFFFFF Negative indices from the CallFrame pointer are entries in the call frame, see RegisterFile.h.
-// 0x00000000-0x3FFFFFFF Forwards indices from the CallFrame pointer are local vars and temporaries with the function's callframe.
-// 0x40000000-0x7FFFFFFF Positive indices from 0x40000000 specify entries in the constant pool on the CodeBlock.
-static const int FirstConstantRegisterIndex = 0x40000000;
+class ExecState;
+class LLIntOffsetsExtractor;
+class RepatchBuffer;
-namespace JSC {
+inline VirtualRegister unmodifiedArgumentsRegister(VirtualRegister argumentsRegister) { return VirtualRegister(argumentsRegister.offset() + 1); }
- enum HasSeenShouldRepatch {
- hasSeenShouldRepatch
- };
+static ALWAYS_INLINE int missingThisObjectMarker() { return std::numeric_limits<int>::max(); }
- class ExecState;
+enum ReoptimizationMode { DontCountReoptimization, CountReoptimization };
- enum CodeType { GlobalCode, EvalCode, FunctionCode };
+class CodeBlock : public ThreadSafeRefCounted<CodeBlock>, public UnconditionalFinalizer, public WeakReferenceHarvester {
+ WTF_MAKE_FAST_ALLOCATED;
+ friend class BytecodeLivenessAnalysis;
+ friend class JIT;
+ friend class LLIntOffsetsExtractor;
+public:
+ enum CopyParsedBlockTag { CopyParsedBlock };
+protected:
+ CodeBlock(CopyParsedBlockTag, CodeBlock& other);
+
+ CodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock*, JSScope*, PassRefPtr<SourceProvider>, unsigned sourceOffset, unsigned firstLineColumnOffset);
- inline int unmodifiedArgumentsRegister(int argumentsRegister) { return argumentsRegister - 1; }
+ WriteBarrier<JSGlobalObject> m_globalObject;
+ Heap* m_heap;
- static ALWAYS_INLINE int missingThisObjectMarker() { return std::numeric_limits<int>::max(); }
+public:
+ JS_EXPORT_PRIVATE virtual ~CodeBlock();
- struct HandlerInfo {
- uint32_t start;
- uint32_t end;
- uint32_t target;
- uint32_t scopeDepth;
-#if ENABLE(JIT)
- CodeLocationLabel nativeCode;
-#endif
- };
+ UnlinkedCodeBlock* unlinkedCodeBlock() const { return m_unlinkedCode.get(); }
- struct ExpressionRangeInfo {
- enum {
- MaxOffset = (1 << 7) - 1,
- MaxDivot = (1 << 25) - 1
- };
- uint32_t instructionOffset : 25;
- uint32_t divotPoint : 25;
- uint32_t startOffset : 7;
- uint32_t endOffset : 7;
- };
+ CString inferredName() const;
+ CodeBlockHash hash() const;
+ bool hasHash() const;
+ bool isSafeToComputeHash() const;
+ CString hashAsStringIfPossible() const;
+ CString sourceCodeForTools() const; // Not quite the actual source we parsed; this will do things like prefix the source for a function with a reified signature.
+ CString sourceCodeOnOneLine() const; // As sourceCodeForTools(), but replaces all whitespace runs with a single space.
+ void dumpAssumingJITType(PrintStream&, JITCode::JITType) const;
+ void dump(PrintStream&) const;
- struct LineInfo {
- uint32_t instructionOffset;
- int32_t lineNumber;
- };
+ int numParameters() const { return m_numParameters; }
+ void setNumParameters(int newValue);
-#if ENABLE(JIT)
- struct CallLinkInfo {
- CallLinkInfo()
- : hasSeenShouldRepatch(false)
- , isCall(false)
- {
- }
+ int* addressOfNumParameters() { return &m_numParameters; }
+ static ptrdiff_t offsetOfNumParameters() { return OBJECT_OFFSETOF(CodeBlock, m_numParameters); }
- CodeLocationNearCall callReturnLocation;
- CodeLocationDataLabelPtr hotPathBegin;
- CodeLocationNearCall hotPathOther;
- JITWriteBarrier<JSFunction> callee;
- bool hasSeenShouldRepatch : 1;
- bool isCall : 1;
+ CodeBlock* alternative() { return m_alternative.get(); }
+ PassRefPtr<CodeBlock> releaseAlternative() { return m_alternative.release(); }
+ void setAlternative(PassRefPtr<CodeBlock> alternative) { m_alternative = alternative; }
- bool isLinked() { return callee; }
- void unlink()
- {
- hasSeenShouldRepatch = false;
- callee.clear();
+ template <typename Functor> void forEachRelatedCodeBlock(Functor&& functor)
+ {
+ Functor f(std::forward<Functor>(functor));
+ Vector<CodeBlock*, 4> codeBlocks;
+ codeBlocks.append(this);
+
+ while (!codeBlocks.isEmpty()) {
+ CodeBlock* currentCodeBlock = codeBlocks.takeLast();
+ f(currentCodeBlock);
+
+ if (CodeBlock* alternative = currentCodeBlock->alternative())
+ codeBlocks.append(alternative);
+ if (CodeBlock* osrEntryBlock = currentCodeBlock->specialOSREntryBlockOrNull())
+ codeBlocks.append(osrEntryBlock);
}
+ }
+
+ CodeSpecializationKind specializationKind() const
+ {
+ return specializationFromIsConstruct(m_isConstructor);
+ }
+
+ CodeBlock* baselineAlternative();
+
+ // FIXME: Get rid of this.
+ // https://bugs.webkit.org/show_bug.cgi?id=123677
+ CodeBlock* baselineVersion();
- bool seenOnce()
- {
- return hasSeenShouldRepatch;
- }
+ void visitAggregate(SlotVisitor&);
- void setSeen()
- {
- hasSeenShouldRepatch = true;
- }
- };
+ void dumpBytecode(PrintStream& = WTF::dataFile());
+ void dumpBytecode(
+ PrintStream&, unsigned bytecodeOffset,
+ const StubInfoMap& = StubInfoMap(), const CallLinkInfoMap& = CallLinkInfoMap());
+ void printStructures(PrintStream&, const Instruction*);
+ void printStructure(PrintStream&, const char* name, const Instruction*, int operand);
- struct MethodCallLinkInfo {
- MethodCallLinkInfo()
- {
- }
+ bool isStrictMode() const { return m_isStrictMode; }
+ ECMAMode ecmaMode() const { return isStrictMode() ? StrictMode : NotStrictMode; }
- bool seenOnce()
- {
- ASSERT(!cachedStructure);
- return cachedPrototypeStructure.isFlagged();
- }
+ inline bool isKnownNotImmediate(int index)
+ {
+ if (index == m_thisRegister.offset() && !m_isStrictMode)
+ return true;
- void setSeen()
- {
- ASSERT(!cachedStructure && !cachedPrototypeStructure);
- // We use the values of cachedStructure & cachedPrototypeStructure to indicate the
- // current state.
- // - In the initial state, both are null.
- // - Once this transition has been taken once, cachedStructure is
- // null and cachedPrototypeStructure is set to a nun-null value.
- // - Once the call is linked both structures are set to non-null values.
- cachedPrototypeStructure.setFlagOnBarrier();
- }
+ if (isConstantRegisterIndex(index))
+ return getConstant(index).isCell();
- CodeLocationCall callReturnLocation;
- JITWriteBarrier<Structure> cachedStructure;
- JITWriteBarrier<Structure> cachedPrototypeStructure;
- // We'd like this to actually be JSFunction, but InternalFunction and JSFunction
- // don't have a common parent class and we allow specialisation on both
- JITWriteBarrier<JSObjectWithGlobalObject> cachedFunction;
- JITWriteBarrier<JSObject> cachedPrototype;
- };
+ return false;
+ }
- struct GlobalResolveInfo {
- GlobalResolveInfo(unsigned bytecodeOffset)
- : offset(0)
- , bytecodeOffset(bytecodeOffset)
- {
- }
+ ALWAYS_INLINE bool isTemporaryRegisterIndex(int index)
+ {
+ return index >= m_numVars;
+ }
- WriteBarrier<Structure> structure;
- unsigned offset;
- unsigned bytecodeOffset;
- };
+ HandlerInfo* handlerForBytecodeOffset(unsigned bytecodeOffset);
+ unsigned lineNumberForBytecodeOffset(unsigned bytecodeOffset);
+ unsigned columnNumberForBytecodeOffset(unsigned bytecodeOffset);
+ void expressionRangeForBytecodeOffset(unsigned bytecodeOffset, int& divot,
+ int& startOffset, int& endOffset, unsigned& line, unsigned& column);
- // This structure is used to map from a call return location
- // (given as an offset in bytes into the JIT code) back to
- // the bytecode index of the corresponding bytecode operation.
- // This is then used to look up the corresponding handler.
- struct CallReturnOffsetToBytecodeOffset {
- CallReturnOffsetToBytecodeOffset(unsigned callReturnOffset, unsigned bytecodeOffset)
- : callReturnOffset(callReturnOffset)
- , bytecodeOffset(bytecodeOffset)
- {
- }
+ void getStubInfoMap(const ConcurrentJITLocker&, StubInfoMap& result);
+ void getStubInfoMap(StubInfoMap& result);
+
+ void getCallLinkInfoMap(const ConcurrentJITLocker&, CallLinkInfoMap& result);
+ void getCallLinkInfoMap(CallLinkInfoMap& result);
+
+#if ENABLE(JIT)
+ StructureStubInfo* addStubInfo();
+ Bag<StructureStubInfo>::iterator stubInfoBegin() { return m_stubInfos.begin(); }
+ Bag<StructureStubInfo>::iterator stubInfoEnd() { return m_stubInfos.end(); }
- unsigned callReturnOffset;
- unsigned bytecodeOffset;
- };
+ void resetStub(StructureStubInfo&);
+
+ ByValInfo& getByValInfo(unsigned bytecodeIndex)
+ {
+ return *(binarySearch<ByValInfo, unsigned>(m_byValInfos, m_byValInfos.size(), bytecodeIndex, getByValInfoBytecodeIndex));
+ }
+
+ CallLinkInfo* addCallLinkInfo();
+ Bag<CallLinkInfo>::iterator callLinkInfosBegin() { return m_callLinkInfos.begin(); }
+ Bag<CallLinkInfo>::iterator callLinkInfosEnd() { return m_callLinkInfos.end(); }
- // valueAtPosition helpers for the binarySearch algorithm.
+ // This is a slow function call used primarily for compiling OSR exits in the case
+ // that there had been inlining. Chances are if you want to use this, you're really
+ // looking for a CallLinkInfoMap to amortize the cost of calling this.
+ CallLinkInfo* getCallLinkInfoForBytecodeIndex(unsigned bytecodeIndex);
+#endif // ENABLE(JIT)
- inline void* getStructureStubInfoReturnLocation(StructureStubInfo* structureStubInfo)
+ void unlinkIncomingCalls();
+
+#if ENABLE(JIT)
+ void unlinkCalls();
+
+ void linkIncomingCall(ExecState* callerFrame, CallLinkInfo*);
+
+ bool isIncomingCallAlreadyLinked(CallLinkInfo* incoming)
{
- return structureStubInfo->callReturnLocation.executableAddress();
+ return m_incomingCalls.isOnList(incoming);
}
+#endif // ENABLE(JIT)
+
+ void linkIncomingCall(ExecState* callerFrame, LLIntCallLinkInfo*);
- inline void* getCallLinkInfoReturnLocation(CallLinkInfo* callLinkInfo)
+ void setJITCodeMap(PassOwnPtr<CompactJITCodeMap> jitCodeMap)
+ {
+ m_jitCodeMap = jitCodeMap;
+ }
+ CompactJITCodeMap* jitCodeMap()
+ {
+ return m_jitCodeMap.get();
+ }
+
+ unsigned bytecodeOffset(Instruction* returnAddress)
{
- return callLinkInfo->callReturnLocation.executableAddress();
+ RELEASE_ASSERT(returnAddress >= instructions().begin() && returnAddress < instructions().end());
+ return static_cast<Instruction*>(returnAddress) - instructions().begin();
}
- inline void* getMethodCallLinkInfoReturnLocation(MethodCallLinkInfo* methodCallLinkInfo)
+ bool isNumericCompareFunction() { return m_unlinkedCode->isNumericCompareFunction(); }
+
+ unsigned numberOfInstructions() const { return m_instructions.size(); }
+ RefCountedArray<Instruction>& instructions() { return m_instructions; }
+ const RefCountedArray<Instruction>& instructions() const { return m_instructions; }
+
+ size_t predictedMachineCodeSize();
+
+ bool usesOpcode(OpcodeID);
+
+ unsigned instructionCount() const { return m_instructions.size(); }
+
+ int argumentIndexAfterCapture(size_t argument);
+
+ bool hasSlowArguments();
+ const SlowArgument* machineSlowArguments();
+
+ // Exactly equivalent to codeBlock->ownerExecutable()->installCode(codeBlock);
+ void install();
+
+ // Exactly equivalent to codeBlock->ownerExecutable()->newReplacementCodeBlockFor(codeBlock->specializationKind())
+ PassRefPtr<CodeBlock> newReplacement();
+
+ void setJITCode(PassRefPtr<JITCode> code)
+ {
+ ASSERT(m_heap->isDeferred());
+ m_heap->reportExtraMemoryCost(code->size());
+ ConcurrentJITLocker locker(m_lock);
+ WTF::storeStoreFence(); // This is probably not needed because the lock will also do something similar, but it's good to be paranoid.
+ m_jitCode = code;
+ }
+ PassRefPtr<JITCode> jitCode() { return m_jitCode; }
+ JITCode::JITType jitType() const
{
- return methodCallLinkInfo->callReturnLocation.executableAddress();
+ JITCode* jitCode = m_jitCode.get();
+ WTF::loadLoadFence();
+ JITCode::JITType result = JITCode::jitTypeFor(jitCode);
+ WTF::loadLoadFence(); // This probably isn't needed. Oh well, paranoia is good.
+ return result;
}
- inline unsigned getCallReturnOffset(CallReturnOffsetToBytecodeOffset* pc)
+ bool hasBaselineJITProfiling() const
{
- return pc->callReturnOffset;
+ return jitType() == JITCode::BaselineJIT;
}
+
+#if ENABLE(JIT)
+ virtual CodeBlock* replacement() = 0;
+
+ virtual DFG::CapabilityLevel capabilityLevelInternal() = 0;
+ DFG::CapabilityLevel capabilityLevel();
+ DFG::CapabilityLevel capabilityLevelState() { return m_capabilityLevelState; }
+
+ bool hasOptimizedReplacement(JITCode::JITType typeToReplace);
+ bool hasOptimizedReplacement(); // the typeToReplace is my JITType
#endif
- class CodeBlock {
- WTF_MAKE_FAST_ALLOCATED;
- friend class JIT;
- protected:
- CodeBlock(ScriptExecutable* ownerExecutable, CodeType, JSGlobalObject*, PassRefPtr<SourceProvider>, unsigned sourceOffset, SymbolTable* symbolTable, bool isConstructor);
+ void jettison(Profiler::JettisonReason, ReoptimizationMode = DontCountReoptimization);
+
+ ScriptExecutable* ownerExecutable() const { return m_ownerExecutable.get(); }
- WriteBarrier<JSGlobalObject> m_globalObject;
- Heap* m_heap;
+ void setVM(VM* vm) { m_vm = vm; }
+ VM* vm() { return m_vm; }
- public:
- virtual ~CodeBlock();
+ void setThisRegister(VirtualRegister thisRegister) { m_thisRegister = thisRegister; }
+ VirtualRegister thisRegister() const { return m_thisRegister; }
- void visitAggregate(SlotVisitor&);
+ bool usesEval() const { return m_unlinkedCode->usesEval(); }
- static void dumpStatistics();
+ void setArgumentsRegister(VirtualRegister argumentsRegister)
+ {
+ ASSERT(argumentsRegister.isValid());
+ m_argumentsRegister = argumentsRegister;
+ ASSERT(usesArguments());
+ }
+ VirtualRegister argumentsRegister() const
+ {
+ ASSERT(usesArguments());
+ return m_argumentsRegister;
+ }
+ VirtualRegister uncheckedArgumentsRegister()
+ {
+ if (!usesArguments())
+ return VirtualRegister();
+ return argumentsRegister();
+ }
+ void setActivationRegister(VirtualRegister activationRegister)
+ {
+ m_activationRegister = activationRegister;
+ }
-#if !defined(NDEBUG) || ENABLE_OPCODE_SAMPLING
- void dump(ExecState*) const;
- void printStructures(const Instruction*) const;
- void printStructure(const char* name, const Instruction*, int operand) const;
-#endif
+ VirtualRegister activationRegister() const
+ {
+ ASSERT(m_activationRegister.isValid());
+ return m_activationRegister;
+ }
- bool isStrictMode() const { return m_isStrictMode; }
+ VirtualRegister uncheckedActivationRegister()
+ {
+ return m_activationRegister;
+ }
- inline bool isKnownNotImmediate(int index)
- {
- if (index == m_thisRegister && !m_isStrictMode)
- return true;
+ bool usesArguments() const { return m_argumentsRegister.isValid(); }
- if (isConstantRegisterIndex(index))
- return getConstant(index).isCell();
+ bool needsActivation() const
+ {
+ ASSERT(m_activationRegister.isValid() == m_needsActivation);
+ return m_needsActivation;
+ }
+
+ unsigned captureCount() const
+ {
+ if (!symbolTable())
+ return 0;
+ return symbolTable()->captureCount();
+ }
+
+ int captureStart() const
+ {
+ if (!symbolTable())
+ return 0;
+ return symbolTable()->captureStart();
+ }
+
+ int captureEnd() const
+ {
+ if (!symbolTable())
+ return 0;
+ return symbolTable()->captureEnd();
+ }
- return false;
- }
+ bool isCaptured(VirtualRegister operand, InlineCallFrame* = 0) const;
+
+ int framePointerOffsetToGetActivationRegisters(int machineCaptureStart);
+ int framePointerOffsetToGetActivationRegisters();
- ALWAYS_INLINE bool isTemporaryRegisterIndex(int index)
- {
- return index >= m_numVars;
- }
+ CodeType codeType() const { return m_unlinkedCode->codeType(); }
+ PutPropertySlot::Context putByIdContext() const
+ {
+ if (codeType() == EvalCode)
+ return PutPropertySlot::PutByIdEval;
+ return PutPropertySlot::PutById;
+ }
+
+ SourceProvider* source() const { return m_source.get(); }
+ unsigned sourceOffset() const { return m_sourceOffset; }
+ unsigned firstLineColumnOffset() const { return m_firstLineColumnOffset; }
+
+ size_t numberOfJumpTargets() const { return m_unlinkedCode->numberOfJumpTargets(); }
+ unsigned jumpTarget(int index) const { return m_unlinkedCode->jumpTarget(index); }
+
+ void clearEvalCache();
- HandlerInfo* handlerForBytecodeOffset(unsigned bytecodeOffset);
- int lineNumberForBytecodeOffset(unsigned bytecodeOffset);
- void expressionRangeForBytecodeOffset(unsigned bytecodeOffset, int& divot, int& startOffset, int& endOffset);
+ String nameForRegister(VirtualRegister);
#if ENABLE(JIT)
+ void setNumberOfByValInfos(size_t size) { m_byValInfos.resizeToFit(size); }
+ size_t numberOfByValInfos() const { return m_byValInfos.size(); }
+ ByValInfo& byValInfo(size_t index) { return m_byValInfos[index]; }
+#endif
- StructureStubInfo& getStubInfo(ReturnAddressPtr returnAddress)
- {
- return *(binarySearch<StructureStubInfo, void*, getStructureStubInfoReturnLocation>(m_structureStubInfos.begin(), m_structureStubInfos.size(), returnAddress.value()));
- }
+ unsigned numberOfArgumentValueProfiles()
+ {
+ ASSERT(m_numParameters >= 0);
+ ASSERT(m_argumentValueProfiles.size() == static_cast<unsigned>(m_numParameters));
+ return m_argumentValueProfiles.size();
+ }
+ ValueProfile* valueProfileForArgument(unsigned argumentIndex)
+ {
+ ValueProfile* result = &m_argumentValueProfiles[argumentIndex];
+ ASSERT(result->m_bytecodeOffset == -1);
+ return result;
+ }
- CallLinkInfo& getCallLinkInfo(ReturnAddressPtr returnAddress)
- {
- return *(binarySearch<CallLinkInfo, void*, getCallLinkInfoReturnLocation>(m_callLinkInfos.begin(), m_callLinkInfos.size(), returnAddress.value()));
- }
+ unsigned numberOfValueProfiles() { return m_valueProfiles.size(); }
+ ValueProfile* valueProfile(int index) { return &m_valueProfiles[index]; }
+ ValueProfile* valueProfileForBytecodeOffset(int bytecodeOffset)
+ {
+ ValueProfile* result = binarySearch<ValueProfile, int>(
+ m_valueProfiles, m_valueProfiles.size(), bytecodeOffset,
+ getValueProfileBytecodeOffset<ValueProfile>);
+ ASSERT(result->m_bytecodeOffset != -1);
+ ASSERT(instructions()[bytecodeOffset + opcodeLength(
+ m_vm->interpreter->getOpcodeID(
+ instructions()[bytecodeOffset].u.opcode)) - 1].u.profile == result);
+ return result;
+ }
+ SpeculatedType valueProfilePredictionForBytecodeOffset(const ConcurrentJITLocker& locker, int bytecodeOffset)
+ {
+ return valueProfileForBytecodeOffset(bytecodeOffset)->computeUpdatedPrediction(locker);
+ }
- MethodCallLinkInfo& getMethodCallLinkInfo(ReturnAddressPtr returnAddress)
- {
- return *(binarySearch<MethodCallLinkInfo, void*, getMethodCallLinkInfoReturnLocation>(m_methodCallLinkInfos.begin(), m_methodCallLinkInfos.size(), returnAddress.value()));
- }
+ unsigned totalNumberOfValueProfiles()
+ {
+ return numberOfArgumentValueProfiles() + numberOfValueProfiles();
+ }
+ ValueProfile* getFromAllValueProfiles(unsigned index)
+ {
+ if (index < numberOfArgumentValueProfiles())
+ return valueProfileForArgument(index);
+ return valueProfile(index - numberOfArgumentValueProfiles());
+ }
- unsigned bytecodeOffset(ReturnAddressPtr returnAddress)
- {
- if (!m_rareData)
- return 1;
- Vector<CallReturnOffsetToBytecodeOffset>& callIndices = m_rareData->m_callReturnIndexVector;
- if (!callIndices.size())
- return 1;
- return binarySearch<CallReturnOffsetToBytecodeOffset, unsigned, getCallReturnOffset>(callIndices.begin(), callIndices.size(), getJITCode().offsetOf(returnAddress.value()))->bytecodeOffset;
- }
+ RareCaseProfile* addRareCaseProfile(int bytecodeOffset)
+ {
+ m_rareCaseProfiles.append(RareCaseProfile(bytecodeOffset));
+ return &m_rareCaseProfiles.last();
+ }
+ unsigned numberOfRareCaseProfiles() { return m_rareCaseProfiles.size(); }
+ RareCaseProfile* rareCaseProfile(int index) { return &m_rareCaseProfiles[index]; }
+ RareCaseProfile* rareCaseProfileForBytecodeOffset(int bytecodeOffset);
- void unlinkCalls();
-#endif
+ bool likelyToTakeSlowCase(int bytecodeOffset)
+ {
+ if (!hasBaselineJITProfiling())
+ return false;
+ unsigned value = rareCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
+ return value >= Options::likelyToTakeSlowCaseMinimumCount();
+ }
-#if ENABLE(INTERPRETER)
- unsigned bytecodeOffset(Instruction* returnAddress)
- {
- return static_cast<Instruction*>(returnAddress) - instructions().begin();
- }
-#endif
+ bool couldTakeSlowCase(int bytecodeOffset)
+ {
+ if (!hasBaselineJITProfiling())
+ return false;
+ unsigned value = rareCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
+ return value >= Options::couldTakeSlowCaseMinimumCount();
+ }
- void setIsNumericCompareFunction(bool isNumericCompareFunction) { m_isNumericCompareFunction = isNumericCompareFunction; }
- bool isNumericCompareFunction() { return m_isNumericCompareFunction; }
+ RareCaseProfile* addSpecialFastCaseProfile(int bytecodeOffset)
+ {
+ m_specialFastCaseProfiles.append(RareCaseProfile(bytecodeOffset));
+ return &m_specialFastCaseProfiles.last();
+ }
+ unsigned numberOfSpecialFastCaseProfiles() { return m_specialFastCaseProfiles.size(); }
+ RareCaseProfile* specialFastCaseProfile(int index) { return &m_specialFastCaseProfiles[index]; }
+ RareCaseProfile* specialFastCaseProfileForBytecodeOffset(int bytecodeOffset)
+ {
+ return tryBinarySearch<RareCaseProfile, int>(
+ m_specialFastCaseProfiles, m_specialFastCaseProfiles.size(), bytecodeOffset,
+ getRareCaseProfileBytecodeOffset);
+ }
- Vector<Instruction>& instructions() { return m_instructions; }
- void discardBytecode() { m_instructions.clear(); }
+ bool likelyToTakeSpecialFastCase(int bytecodeOffset)
+ {
+ if (!hasBaselineJITProfiling())
+ return false;
+ unsigned specialFastCaseCount = specialFastCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
+ return specialFastCaseCount >= Options::likelyToTakeSlowCaseMinimumCount();
+ }
-#ifndef NDEBUG
- unsigned instructionCount() { return m_instructionCount; }
- void setInstructionCount(unsigned instructionCount) { m_instructionCount = instructionCount; }
-#endif
+ bool couldTakeSpecialFastCase(int bytecodeOffset)
+ {
+ if (!hasBaselineJITProfiling())
+ return false;
+ unsigned specialFastCaseCount = specialFastCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
+ return specialFastCaseCount >= Options::couldTakeSlowCaseMinimumCount();
+ }
-#if ENABLE(JIT)
- JITCode& getJITCode() { return m_isConstructor ? ownerExecutable()->generatedJITCodeForConstruct() : ownerExecutable()->generatedJITCodeForCall(); }
- ExecutablePool* executablePool() { return getJITCode().getExecutablePool(); }
-#endif
+ bool likelyToTakeDeepestSlowCase(int bytecodeOffset)
+ {
+ if (!hasBaselineJITProfiling())
+ return false;
+ unsigned slowCaseCount = rareCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
+ unsigned specialFastCaseCount = specialFastCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
+ unsigned value = slowCaseCount - specialFastCaseCount;
+ return value >= Options::likelyToTakeSlowCaseMinimumCount();
+ }
+
+ bool likelyToTakeAnySlowCase(int bytecodeOffset)
+ {
+ if (!hasBaselineJITProfiling())
+ return false;
+ unsigned slowCaseCount = rareCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
+ unsigned specialFastCaseCount = specialFastCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
+ unsigned value = slowCaseCount + specialFastCaseCount;
+ return value >= Options::likelyToTakeSlowCaseMinimumCount();
+ }
+
+ unsigned numberOfArrayProfiles() const { return m_arrayProfiles.size(); }
+ const ArrayProfileVector& arrayProfiles() { return m_arrayProfiles; }
+ ArrayProfile* addArrayProfile(unsigned bytecodeOffset)
+ {
+ m_arrayProfiles.append(ArrayProfile(bytecodeOffset));
+ return &m_arrayProfiles.last();
+ }
+ ArrayProfile* getArrayProfile(unsigned bytecodeOffset);
+ ArrayProfile* getOrAddArrayProfile(unsigned bytecodeOffset);
- ScriptExecutable* ownerExecutable() const { return m_ownerExecutable.get(); }
+ // Exception handling support
- void setGlobalData(JSGlobalData* globalData) { m_globalData = globalData; }
+ size_t numberOfExceptionHandlers() const { return m_rareData ? m_rareData->m_exceptionHandlers.size() : 0; }
+ HandlerInfo& exceptionHandler(int index) { RELEASE_ASSERT(m_rareData); return m_rareData->m_exceptionHandlers[index]; }
- void setThisRegister(int thisRegister) { m_thisRegister = thisRegister; }
- int thisRegister() const { return m_thisRegister; }
+ bool hasExpressionInfo() { return m_unlinkedCode->hasExpressionInfo(); }
- void setNeedsFullScopeChain(bool needsFullScopeChain) { m_needsFullScopeChain = needsFullScopeChain; }
- bool needsFullScopeChain() const { return m_needsFullScopeChain; }
- void setUsesEval(bool usesEval) { m_usesEval = usesEval; }
- bool usesEval() const { return m_usesEval; }
+#if ENABLE(DFG_JIT)
+ Vector<CodeOrigin, 0, UnsafeVectorOverflow>& codeOrigins()
+ {
+ return m_jitCode->dfgCommon()->codeOrigins;
+ }
+
+ // Having code origins implies that there has been some inlining.
+ bool hasCodeOrigins()
+ {
+ return JITCode::isOptimizingJIT(jitType());
+ }
- void setArgumentsRegister(int argumentsRegister)
- {
- ASSERT(argumentsRegister != -1);
- m_argumentsRegister = argumentsRegister;
- ASSERT(usesArguments());
- }
- int argumentsRegister()
- {
- ASSERT(usesArguments());
- return m_argumentsRegister;
- }
- void setActivationRegister(int activationRegister)
- {
- m_activationRegister = activationRegister;
- }
- int activationRegister()
- {
- ASSERT(needsFullScopeChain());
- return m_activationRegister;
- }
- bool usesArguments() const { return m_argumentsRegister != -1; }
+ bool canGetCodeOrigin(unsigned index)
+ {
+ if (!hasCodeOrigins())
+ return false;
+ return index < codeOrigins().size();
+ }
- CodeType codeType() const { return m_codeType; }
+ CodeOrigin codeOrigin(unsigned index)
+ {
+ return codeOrigins()[index];
+ }
- SourceProvider* source() const { return m_source.get(); }
- unsigned sourceOffset() const { return m_sourceOffset; }
+ bool addFrequentExitSite(const DFG::FrequentExitSite& site)
+ {
+ ASSERT(JITCode::isBaselineCode(jitType()));
+ ConcurrentJITLocker locker(m_lock);
+ return m_exitProfile.add(locker, site);
+ }
- size_t numberOfJumpTargets() const { return m_jumpTargets.size(); }
- void addJumpTarget(unsigned jumpTarget) { m_jumpTargets.append(jumpTarget); }
- unsigned jumpTarget(int index) const { return m_jumpTargets[index]; }
- unsigned lastJumpTarget() const { return m_jumpTargets.last(); }
+ bool hasExitSite(const ConcurrentJITLocker& locker, const DFG::FrequentExitSite& site) const
+ {
+ return m_exitProfile.hasExitSite(locker, site);
+ }
+ bool hasExitSite(const DFG::FrequentExitSite& site) const
+ {
+ ConcurrentJITLocker locker(m_lock);
+ return hasExitSite(locker, site);
+ }
- void createActivation(CallFrame*);
+ DFG::ExitProfile& exitProfile() { return m_exitProfile; }
- void clearEvalCache();
+ CompressedLazyOperandValueProfileHolder& lazyOperandValueProfiles()
+ {
+ return m_lazyOperandValueProfiles;
+ }
+#endif // ENABLE(DFG_JIT)
-#if ENABLE(INTERPRETER)
- void addPropertyAccessInstruction(unsigned propertyAccessInstruction)
- {
- if (!m_globalData->canUseJIT())
- m_propertyAccessInstructions.append(propertyAccessInstruction);
- }
- void addGlobalResolveInstruction(unsigned globalResolveInstruction)
- {
- if (!m_globalData->canUseJIT())
- m_globalResolveInstructions.append(globalResolveInstruction);
- }
- bool hasGlobalResolveInstructionAtBytecodeOffset(unsigned bytecodeOffset);
+ // Constant Pool
+#if ENABLE(DFG_JIT)
+ size_t numberOfIdentifiers() const { return m_unlinkedCode->numberOfIdentifiers() + numberOfDFGIdentifiers(); }
+ size_t numberOfDFGIdentifiers() const
+ {
+ if (!JITCode::isOptimizingJIT(jitType()))
+ return 0;
+
+ return m_jitCode->dfgCommon()->dfgIdentifiers.size();
+ }
+
+ const Identifier& identifier(int index) const
+ {
+ size_t unlinkedIdentifiers = m_unlinkedCode->numberOfIdentifiers();
+ if (static_cast<unsigned>(index) < unlinkedIdentifiers)
+ return m_unlinkedCode->identifier(index);
+ ASSERT(JITCode::isOptimizingJIT(jitType()));
+ return m_jitCode->dfgCommon()->dfgIdentifiers[index - unlinkedIdentifiers];
+ }
+#else
+ size_t numberOfIdentifiers() const { return m_unlinkedCode->numberOfIdentifiers(); }
+ const Identifier& identifier(int index) const { return m_unlinkedCode->identifier(index); }
#endif
-#if ENABLE(JIT)
- size_t numberOfStructureStubInfos() const { return m_structureStubInfos.size(); }
- void addStructureStubInfo(const StructureStubInfo& stubInfo)
- {
- if (m_globalData->canUseJIT())
- m_structureStubInfos.append(stubInfo);
- }
- StructureStubInfo& structureStubInfo(int index) { return m_structureStubInfos[index]; }
- void addGlobalResolveInfo(unsigned globalResolveInstruction)
- {
- if (m_globalData->canUseJIT())
- m_globalResolveInfos.append(GlobalResolveInfo(globalResolveInstruction));
- }
- GlobalResolveInfo& globalResolveInfo(int index) { return m_globalResolveInfos[index]; }
- bool hasGlobalResolveInfoAtBytecodeOffset(unsigned bytecodeOffset);
+ Vector<WriteBarrier<Unknown>>& constants() { return m_constantRegisters; }
+ size_t numberOfConstantRegisters() const { return m_constantRegisters.size(); }
+ unsigned addConstant(JSValue v)
+ {
+ unsigned result = m_constantRegisters.size();
+ m_constantRegisters.append(WriteBarrier<Unknown>());
+ m_constantRegisters.last().set(m_globalObject->vm(), m_ownerExecutable.get(), v);
+ return result;
+ }
+
+ unsigned addConstantLazily()
+ {
+ unsigned result = m_constantRegisters.size();
+ m_constantRegisters.append(WriteBarrier<Unknown>());
+ return result;
+ }
- size_t numberOfCallLinkInfos() const { return m_callLinkInfos.size(); }
- void addCallLinkInfo() { m_callLinkInfos.append(CallLinkInfo()); }
- CallLinkInfo& callLinkInfo(int index) { return m_callLinkInfos[index]; }
+ bool findConstant(JSValue, unsigned& result);
+ unsigned addOrFindConstant(JSValue);
+ WriteBarrier<Unknown>& constantRegister(int index) { return m_constantRegisters[index - FirstConstantRegisterIndex]; }
+ ALWAYS_INLINE bool isConstantRegisterIndex(int index) const { return index >= FirstConstantRegisterIndex; }
+ ALWAYS_INLINE JSValue getConstant(int index) const { return m_constantRegisters[index - FirstConstantRegisterIndex].get(); }
- void addMethodCallLinkInfos(unsigned n) { ASSERT(m_globalData->canUseJIT()); m_methodCallLinkInfos.grow(n); }
- MethodCallLinkInfo& methodCallLinkInfo(int index) { return m_methodCallLinkInfos[index]; }
-#endif
- unsigned globalResolveInfoCount() const
- {
-#if ENABLE(JIT)
- if (m_globalData->canUseJIT())
- return m_globalResolveInfos.size();
-#endif
+ FunctionExecutable* functionDecl(int index) { return m_functionDecls[index].get(); }
+ int numberOfFunctionDecls() { return m_functionDecls.size(); }
+ FunctionExecutable* functionExpr(int index) { return m_functionExprs[index].get(); }
+
+ RegExp* regexp(int index) const { return m_unlinkedCode->regexp(index); }
+
+ unsigned numberOfConstantBuffers() const
+ {
+ if (!m_rareData)
return 0;
- }
+ return m_rareData->m_constantBuffers.size();
+ }
+ unsigned addConstantBuffer(const Vector<JSValue>& buffer)
+ {
+ createRareDataIfNecessary();
+ unsigned size = m_rareData->m_constantBuffers.size();
+ m_rareData->m_constantBuffers.append(buffer);
+ return size;
+ }
- // Exception handling support
+ Vector<JSValue>& constantBufferAsVector(unsigned index)
+ {
+ ASSERT(m_rareData);
+ return m_rareData->m_constantBuffers[index];
+ }
+ JSValue* constantBuffer(unsigned index)
+ {
+ return constantBufferAsVector(index).data();
+ }
- size_t numberOfExceptionHandlers() const { return m_rareData ? m_rareData->m_exceptionHandlers.size() : 0; }
- void addExceptionHandler(const HandlerInfo& hanler) { createRareDataIfNecessary(); return m_rareData->m_exceptionHandlers.append(hanler); }
- HandlerInfo& exceptionHandler(int index) { ASSERT(m_rareData); return m_rareData->m_exceptionHandlers[index]; }
+ Heap* heap() const { return m_heap; }
+ JSGlobalObject* globalObject() { return m_globalObject.get(); }
- void addExpressionInfo(const ExpressionRangeInfo& expressionInfo)
- {
- createRareDataIfNecessary();
- m_rareData->m_expressionInfo.append(expressionInfo);
- }
+ JSGlobalObject* globalObjectFor(CodeOrigin);
- void addLineInfo(unsigned bytecodeOffset, int lineNo)
+ BytecodeLivenessAnalysis& livenessAnalysis()
+ {
{
- createRareDataIfNecessary();
- Vector<LineInfo>& lineInfo = m_rareData->m_lineInfo;
- if (!lineInfo.size() || lineInfo.last().lineNumber != lineNo) {
- LineInfo info = { bytecodeOffset, lineNo };
- lineInfo.append(info);
- }
+ ConcurrentJITLocker locker(m_lock);
+ if (!!m_livenessAnalysis)
+ return *m_livenessAnalysis;
}
-
- bool hasExpressionInfo() { return m_rareData && m_rareData->m_expressionInfo.size(); }
- bool hasLineInfo() { return m_rareData && m_rareData->m_lineInfo.size(); }
- // We only generate exception handling info if the user is debugging
- // (and may want line number info), or if the function contains exception handler.
- bool needsCallReturnIndices()
+ std::unique_ptr<BytecodeLivenessAnalysis> analysis =
+ std::make_unique<BytecodeLivenessAnalysis>(this);
{
- return m_rareData &&
- (m_rareData->m_expressionInfo.size() || m_rareData->m_lineInfo.size() || m_rareData->m_exceptionHandlers.size());
+ ConcurrentJITLocker locker(m_lock);
+ if (!m_livenessAnalysis)
+ m_livenessAnalysis = WTF::move(analysis);
+ return *m_livenessAnalysis;
}
+ }
+
+ void validate();
-#if ENABLE(JIT)
- Vector<CallReturnOffsetToBytecodeOffset>& callReturnIndexVector()
- {
- createRareDataIfNecessary();
- return m_rareData->m_callReturnIndexVector;
- }
-#endif
+ // Jump Tables
- // Constant Pool
+ size_t numberOfSwitchJumpTables() const { return m_rareData ? m_rareData->m_switchJumpTables.size() : 0; }
+ SimpleJumpTable& addSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_switchJumpTables.append(SimpleJumpTable()); return m_rareData->m_switchJumpTables.last(); }
+ SimpleJumpTable& switchJumpTable(int tableIndex) { RELEASE_ASSERT(m_rareData); return m_rareData->m_switchJumpTables[tableIndex]; }
+ void clearSwitchJumpTables()
+ {
+ if (!m_rareData)
+ return;
+ m_rareData->m_switchJumpTables.clear();
+ }
- size_t numberOfIdentifiers() const { return m_identifiers.size(); }
- void addIdentifier(const Identifier& i) { return m_identifiers.append(i); }
- Identifier& identifier(int index) { return m_identifiers[index]; }
+ size_t numberOfStringSwitchJumpTables() const { return m_rareData ? m_rareData->m_stringSwitchJumpTables.size() : 0; }
+ StringJumpTable& addStringSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_stringSwitchJumpTables.append(StringJumpTable()); return m_rareData->m_stringSwitchJumpTables.last(); }
+ StringJumpTable& stringSwitchJumpTable(int tableIndex) { RELEASE_ASSERT(m_rareData); return m_rareData->m_stringSwitchJumpTables[tableIndex]; }
- size_t numberOfConstantRegisters() const { return m_constantRegisters.size(); }
- void addConstant(JSValue v)
- {
- m_constantRegisters.append(WriteBarrier<Unknown>());
- m_constantRegisters.last().set(m_globalObject->globalData(), m_ownerExecutable.get(), v);
- }
- WriteBarrier<Unknown>& constantRegister(int index) { return m_constantRegisters[index - FirstConstantRegisterIndex]; }
- ALWAYS_INLINE bool isConstantRegisterIndex(int index) const { return index >= FirstConstantRegisterIndex; }
- ALWAYS_INLINE JSValue getConstant(int index) const { return m_constantRegisters[index - FirstConstantRegisterIndex].get(); }
- unsigned addFunctionDecl(FunctionExecutable* n)
- {
- unsigned size = m_functionDecls.size();
- m_functionDecls.append(WriteBarrier<FunctionExecutable>());
- m_functionDecls.last().set(m_globalObject->globalData(), m_ownerExecutable.get(), n);
- return size;
- }
- FunctionExecutable* functionDecl(int index) { return m_functionDecls[index].get(); }
- int numberOfFunctionDecls() { return m_functionDecls.size(); }
- unsigned addFunctionExpr(FunctionExecutable* n)
- {
- unsigned size = m_functionExprs.size();
- m_functionExprs.append(WriteBarrier<FunctionExecutable>());
- m_functionExprs.last().set(m_globalObject->globalData(), m_ownerExecutable.get(), n);
- return size;
- }
- FunctionExecutable* functionExpr(int index) { return m_functionExprs[index].get(); }
+ SymbolTable* symbolTable() const { return m_symbolTable.get(); }
- unsigned addRegExp(RegExp* r)
- {
- createRareDataIfNecessary();
- unsigned size = m_rareData->m_regexps.size();
- m_rareData->m_regexps.append(WriteBarrier<RegExp>(*m_globalData, ownerExecutable(), r));
- return size;
- }
- RegExp* regexp(int index) const { ASSERT(m_rareData); return m_rareData->m_regexps[index].get(); }
+ EvalCodeCache& evalCodeCache() { createRareDataIfNecessary(); return m_rareData->m_evalCodeCache; }
- unsigned addConstantBuffer(unsigned length)
- {
- createRareDataIfNecessary();
- unsigned size = m_rareData->m_constantBuffers.size();
- m_rareData->m_constantBuffers.append(Vector<JSValue>(length));
- return size;
- }
+ enum ShrinkMode {
+ // Shrink prior to generating machine code that may point directly into vectors.
+ EarlyShrink,
- JSValue* constantBuffer(unsigned index)
- {
- ASSERT(m_rareData);
- return m_rareData->m_constantBuffers[index].data();
- }
+ // Shrink after generating machine code, and after possibly creating new vectors
+ // and appending to others. At this time it is not safe to shrink certain vectors
+ // because we would have generated machine code that references them directly.
+ LateShrink
+ };
+ void shrinkToFit(ShrinkMode);
- JSGlobalObject* globalObject() { return m_globalObject.get(); }
+ // Functions for controlling when JITting kicks in, in a mixed mode
+ // execution world.
- // Jump Tables
+ bool checkIfJITThresholdReached()
+ {
+ return m_llintExecuteCounter.checkIfThresholdCrossedAndSet(this);
+ }
+
+ void dontJITAnytimeSoon()
+ {
+ m_llintExecuteCounter.deferIndefinitely();
+ }
+
+ void jitAfterWarmUp()
+ {
+ m_llintExecuteCounter.setNewThreshold(Options::thresholdForJITAfterWarmUp(), this);
+ }
- size_t numberOfImmediateSwitchJumpTables() const { return m_rareData ? m_rareData->m_immediateSwitchJumpTables.size() : 0; }
- SimpleJumpTable& addImmediateSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_immediateSwitchJumpTables.append(SimpleJumpTable()); return m_rareData->m_immediateSwitchJumpTables.last(); }
- SimpleJumpTable& immediateSwitchJumpTable(int tableIndex) { ASSERT(m_rareData); return m_rareData->m_immediateSwitchJumpTables[tableIndex]; }
+ void jitSoon()
+ {
+ m_llintExecuteCounter.setNewThreshold(Options::thresholdForJITSoon(), this);
+ }
- size_t numberOfCharacterSwitchJumpTables() const { return m_rareData ? m_rareData->m_characterSwitchJumpTables.size() : 0; }
- SimpleJumpTable& addCharacterSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_characterSwitchJumpTables.append(SimpleJumpTable()); return m_rareData->m_characterSwitchJumpTables.last(); }
- SimpleJumpTable& characterSwitchJumpTable(int tableIndex) { ASSERT(m_rareData); return m_rareData->m_characterSwitchJumpTables[tableIndex]; }
+ const BaselineExecutionCounter& llintExecuteCounter() const
+ {
+ return m_llintExecuteCounter;
+ }
- size_t numberOfStringSwitchJumpTables() const { return m_rareData ? m_rareData->m_stringSwitchJumpTables.size() : 0; }
- StringJumpTable& addStringSwitchJumpTable() { createRareDataIfNecessary(); m_rareData->m_stringSwitchJumpTables.append(StringJumpTable()); return m_rareData->m_stringSwitchJumpTables.last(); }
- StringJumpTable& stringSwitchJumpTable(int tableIndex) { ASSERT(m_rareData); return m_rareData->m_stringSwitchJumpTables[tableIndex]; }
+ // Functions for controlling when tiered compilation kicks in. This
+ // controls both when the optimizing compiler is invoked and when OSR
+ // entry happens. Two triggers exist: the loop trigger and the return
+ // trigger. In either case, when an addition to m_jitExecuteCounter
+ // causes it to become non-negative, the optimizing compiler is
+ // invoked. This includes a fast check to see if this CodeBlock has
+ // already been optimized (i.e. replacement() returns a CodeBlock
+ // that was optimized with a higher tier JIT than this one). In the
+ // case of the loop trigger, if the optimized compilation succeeds
+ // (or has already succeeded in the past) then OSR is attempted to
+ // redirect program flow into the optimized code.
+
+ // These functions are called from within the optimization triggers,
+ // and are used as a single point at which we define the heuristics
+ // for how much warm-up is mandated before the next optimization
+ // trigger files. All CodeBlocks start out with optimizeAfterWarmUp(),
+ // as this is called from the CodeBlock constructor.
+
+ // When we observe a lot of speculation failures, we trigger a
+ // reoptimization. But each time, we increase the optimization trigger
+ // to avoid thrashing.
+ JS_EXPORT_PRIVATE unsigned reoptimizationRetryCounter() const;
+ void countReoptimization();
+#if ENABLE(JIT)
+ unsigned numberOfDFGCompiles();
+ int32_t codeTypeThresholdMultiplier() const;
- SymbolTable* symbolTable() { return m_symbolTable; }
- SharedSymbolTable* sharedSymbolTable() { ASSERT(m_codeType == FunctionCode); return static_cast<SharedSymbolTable*>(m_symbolTable); }
+ int32_t adjustedCounterValue(int32_t desiredThreshold);
- EvalCodeCache& evalCodeCache() { createRareDataIfNecessary(); return m_rareData->m_evalCodeCache; }
+ int32_t* addressOfJITExecuteCounter()
+ {
+ return &m_jitExecuteCounter.m_counter;
+ }
- void shrinkToFit();
+ static ptrdiff_t offsetOfJITExecuteCounter() { return OBJECT_OFFSETOF(CodeBlock, m_jitExecuteCounter) + OBJECT_OFFSETOF(BaselineExecutionCounter, m_counter); }
+ static ptrdiff_t offsetOfJITExecutionActiveThreshold() { return OBJECT_OFFSETOF(CodeBlock, m_jitExecuteCounter) + OBJECT_OFFSETOF(BaselineExecutionCounter, m_activeThreshold); }
+ static ptrdiff_t offsetOfJITExecutionTotalCount() { return OBJECT_OFFSETOF(CodeBlock, m_jitExecuteCounter) + OBJECT_OFFSETOF(BaselineExecutionCounter, m_totalCount); }
+
+ const BaselineExecutionCounter& jitExecuteCounter() const { return m_jitExecuteCounter; }
+
+ unsigned optimizationDelayCounter() const { return m_optimizationDelayCounter; }
+
+ // Check if the optimization threshold has been reached, and if not,
+ // adjust the heuristics accordingly. Returns true if the threshold has
+ // been reached.
+ bool checkIfOptimizationThresholdReached();
+
+ // Call this to force the next optimization trigger to fire. This is
+ // rarely wise, since optimization triggers are typically more
+ // expensive than executing baseline code.
+ void optimizeNextInvocation();
+
+ // Call this to prevent optimization from happening again. Note that
+ // optimization will still happen after roughly 2^29 invocations,
+ // so this is really meant to delay that as much as possible. This
+ // is called if optimization failed, and we expect it to fail in
+ // the future as well.
+ void dontOptimizeAnytimeSoon();
+
+ // Call this to reinitialize the counter to its starting state,
+ // forcing a warm-up to happen before the next optimization trigger
+ // fires. This is called in the CodeBlock constructor. It also
+ // makes sense to call this if an OSR exit occurred. Note that
+ // OSR exit code is code generated, so the value of the execute
+ // counter that this corresponds to is also available directly.
+ void optimizeAfterWarmUp();
+
+ // Call this to force an optimization trigger to fire only after
+ // a lot of warm-up.
+ void optimizeAfterLongWarmUp();
+
+ // Call this to cause an optimization trigger to fire soon, but
+ // not necessarily the next one. This makes sense if optimization
+ // succeeds. Successfuly optimization means that all calls are
+ // relinked to the optimized code, so this only affects call
+ // frames that are still executing this CodeBlock. The value here
+ // is tuned to strike a balance between the cost of OSR entry
+ // (which is too high to warrant making every loop back edge to
+ // trigger OSR immediately) and the cost of executing baseline
+ // code (which is high enough that we don't necessarily want to
+ // have a full warm-up). The intuition for calling this instead of
+ // optimizeNextInvocation() is for the case of recursive functions
+ // with loops. Consider that there may be N call frames of some
+ // recursive function, for a reasonably large value of N. The top
+ // one triggers optimization, and then returns, and then all of
+ // the others return. We don't want optimization to be triggered on
+ // each return, as that would be superfluous. It only makes sense
+ // to trigger optimization if one of those functions becomes hot
+ // in the baseline code.
+ void optimizeSoon();
+
+ void forceOptimizationSlowPathConcurrently();
+
+ void setOptimizationThresholdBasedOnCompilationResult(CompilationResult);
+
+ uint32_t osrExitCounter() const { return m_osrExitCounter; }
- // FIXME: Make these remaining members private.
+ void countOSRExit() { m_osrExitCounter++; }
- int m_numCalleeRegisters;
- int m_numVars;
- int m_numCapturedVars;
- int m_numParameters;
- bool m_isConstructor;
+ uint32_t* addressOfOSRExitCounter() { return &m_osrExitCounter; }
- private:
-#if !defined(NDEBUG) || ENABLE(OPCODE_SAMPLING)
- void dump(ExecState*, const Vector<Instruction>::const_iterator& begin, Vector<Instruction>::const_iterator&) const;
+ static ptrdiff_t offsetOfOSRExitCounter() { return OBJECT_OFFSETOF(CodeBlock, m_osrExitCounter); }
- CString registerName(ExecState*, int r) const;
- void printUnaryOp(ExecState*, int location, Vector<Instruction>::const_iterator&, const char* op) const;
- void printBinaryOp(ExecState*, int location, Vector<Instruction>::const_iterator&, const char* op) const;
- void printConditionalJump(ExecState*, const Vector<Instruction>::const_iterator&, Vector<Instruction>::const_iterator&, int location, const char* op) const;
- void printGetByIdOp(ExecState*, int location, Vector<Instruction>::const_iterator&, const char* op) const;
- void printPutByIdOp(ExecState*, int location, Vector<Instruction>::const_iterator&, const char* op) const;
+ uint32_t adjustedExitCountThreshold(uint32_t desiredThreshold);
+ uint32_t exitCountThresholdForReoptimization();
+ uint32_t exitCountThresholdForReoptimizationFromLoop();
+ bool shouldReoptimizeNow();
+ bool shouldReoptimizeFromLoopNow();
+#else // No JIT
+ void optimizeAfterWarmUp() { }
+ unsigned numberOfDFGCompiles() { return 0; }
#endif
- void visitStructures(SlotVisitor&, Instruction* vPC) const;
- void createRareDataIfNecessary()
- {
- if (!m_rareData)
- m_rareData = adoptPtr(new RareData);
- }
+ bool shouldOptimizeNow();
+ void updateAllValueProfilePredictions();
+ void updateAllArrayPredictions();
+ void updateAllPredictions();
- WriteBarrier<ScriptExecutable> m_ownerExecutable;
- JSGlobalData* m_globalData;
+ unsigned frameRegisterCount();
+ int stackPointerOffset();
- Vector<Instruction> m_instructions;
-#ifndef NDEBUG
- unsigned m_instructionCount;
-#endif
+ bool hasOpDebugForLineAndColumn(unsigned line, unsigned column);
- int m_thisRegister;
- int m_argumentsRegister;
- int m_activationRegister;
+ bool hasDebuggerRequests() const { return m_debuggerRequests; }
+ void* debuggerRequestsAddress() { return &m_debuggerRequests; }
- bool m_needsFullScopeChain;
- bool m_usesEval;
- bool m_isNumericCompareFunction;
- bool m_isStrictMode;
+ void addBreakpoint(unsigned numBreakpoints);
+ void removeBreakpoint(unsigned numBreakpoints)
+ {
+ ASSERT(m_numBreakpoints >= numBreakpoints);
+ m_numBreakpoints -= numBreakpoints;
+ }
- CodeType m_codeType;
+ enum SteppingMode {
+ SteppingModeDisabled,
+ SteppingModeEnabled
+ };
+ void setSteppingMode(SteppingMode);
- RefPtr<SourceProvider> m_source;
- unsigned m_sourceOffset;
+ void clearDebuggerRequests()
+ {
+ m_steppingMode = SteppingModeDisabled;
+ m_numBreakpoints = 0;
+ }
+
+ // FIXME: Make these remaining members private.
-#if ENABLE(INTERPRETER)
- Vector<unsigned> m_propertyAccessInstructions;
- Vector<unsigned> m_globalResolveInstructions;
-#endif
-#if ENABLE(JIT)
- Vector<StructureStubInfo> m_structureStubInfos;
- Vector<GlobalResolveInfo> m_globalResolveInfos;
- Vector<CallLinkInfo> m_callLinkInfos;
- Vector<MethodCallLinkInfo> m_methodCallLinkInfos;
-#endif
+ int m_numCalleeRegisters;
+ int m_numVars;
+ bool m_isConstructor : 1;
+
+ // This is intentionally public; it's the responsibility of anyone doing any
+ // of the following to hold the lock:
+ //
+ // - Modifying any inline cache in this code block.
+ //
+ // - Quering any inline cache in this code block, from a thread other than
+ // the main thread.
+ //
+ // Additionally, it's only legal to modify the inline cache on the main
+ // thread. This means that the main thread can query the inline cache without
+ // locking. This is crucial since executing the inline cache is effectively
+ // "querying" it.
+ //
+ // Another exception to the rules is that the GC can do whatever it wants
+ // without holding any locks, because the GC is guaranteed to wait until any
+ // concurrent compilation threads finish what they're doing.
+ mutable ConcurrentJITLock m_lock;
+
+ bool m_shouldAlwaysBeInlined; // Not a bitfield because the JIT wants to store to it.
+ bool m_allTransitionsHaveBeenMarked : 1; // Initialized and used on every GC.
+
+ bool m_didFailFTLCompilation : 1;
+ bool m_hasBeenCompiledWithFTL : 1;
+
+ // Internal methods for use by validation code. It would be private if it wasn't
+ // for the fact that we use it from anonymous namespaces.
+ void beginValidationDidFail();
+ NO_RETURN_DUE_TO_CRASH void endValidationDidFail();
- Vector<unsigned> m_jumpTargets;
+ bool isKnownToBeLiveDuringGC(); // Will only return valid results when called during GC. Assumes that you've already established that the owner executable is live.
- // Constant Pool
- Vector<Identifier> m_identifiers;
- COMPILE_ASSERT(sizeof(Register) == sizeof(WriteBarrier<Unknown>), Register_must_be_same_size_as_WriteBarrier_Unknown);
- Vector<WriteBarrier<Unknown> > m_constantRegisters;
- Vector<WriteBarrier<FunctionExecutable> > m_functionDecls;
- Vector<WriteBarrier<FunctionExecutable> > m_functionExprs;
+protected:
+ virtual void visitWeakReferences(SlotVisitor&) override;
+ virtual void finalizeUnconditionally() override;
- SymbolTable* m_symbolTable;
+#if ENABLE(DFG_JIT)
+ void tallyFrequentExitSites();
+#else
+ void tallyFrequentExitSites() { }
+#endif
- struct RareData {
- WTF_MAKE_FAST_ALLOCATED;
- public:
- Vector<HandlerInfo> m_exceptionHandlers;
+private:
+ friend class CodeBlockSet;
+
+ CodeBlock* specialOSREntryBlockOrNull();
+
+ void noticeIncomingCall(ExecState* callerFrame);
+
+ double optimizationThresholdScalingFactor();
- // Rare Constants
- Vector<WriteBarrier<RegExp> > m_regexps;
+#if ENABLE(JIT)
+ ClosureCallStubRoutine* findClosureCallForReturnPC(ReturnAddressPtr);
+#endif
+
+ void updateAllPredictionsAndCountLiveness(unsigned& numberOfLiveNonArgumentValueProfiles, unsigned& numberOfSamplesInProfiles);
- // Buffers used for large array literals
- Vector<Vector<JSValue> > m_constantBuffers;
-
- // Jump Tables
- Vector<SimpleJumpTable> m_immediateSwitchJumpTables;
- Vector<SimpleJumpTable> m_characterSwitchJumpTables;
- Vector<StringJumpTable> m_stringSwitchJumpTables;
+ void setConstantRegisters(const Vector<WriteBarrier<Unknown>>& constants)
+ {
+ size_t count = constants.size();
+ m_constantRegisters.resize(count);
+ for (size_t i = 0; i < count; i++)
+ m_constantRegisters[i].set(*m_vm, ownerExecutable(), constants[i].get());
+ }
- EvalCodeCache m_evalCodeCache;
+ void dumpBytecode(
+ PrintStream&, ExecState*, const Instruction* begin, const Instruction*&,
+ const StubInfoMap& = StubInfoMap(), const CallLinkInfoMap& = CallLinkInfoMap());
+
+ CString registerName(int r) const;
+ void printUnaryOp(PrintStream&, ExecState*, int location, const Instruction*&, const char* op);
+ void printBinaryOp(PrintStream&, ExecState*, int location, const Instruction*&, const char* op);
+ void printConditionalJump(PrintStream&, ExecState*, const Instruction*, const Instruction*&, int location, const char* op);
+ void printGetByIdOp(PrintStream&, ExecState*, int location, const Instruction*&);
+ void printGetByIdCacheStatus(PrintStream&, ExecState*, int location, const StubInfoMap&);
+ enum CacheDumpMode { DumpCaches, DontDumpCaches };
+ void printCallOp(PrintStream&, ExecState*, int location, const Instruction*&, const char* op, CacheDumpMode, bool& hasPrintedProfiling, const CallLinkInfoMap&);
+ void printPutByIdOp(PrintStream&, ExecState*, int location, const Instruction*&, const char* op);
+ void printLocationAndOp(PrintStream&, ExecState*, int location, const Instruction*&, const char* op);
+ void printLocationOpAndRegisterOperand(PrintStream&, ExecState*, int location, const Instruction*& it, const char* op, int operand);
+
+ void beginDumpProfiling(PrintStream&, bool& hasPrintedProfiling);
+ void dumpValueProfiling(PrintStream&, const Instruction*&, bool& hasPrintedProfiling);
+ void dumpArrayProfiling(PrintStream&, const Instruction*&, bool& hasPrintedProfiling);
+ void dumpRareCaseProfile(PrintStream&, const char* name, RareCaseProfile*, bool& hasPrintedProfiling);
+
+ bool shouldImmediatelyAssumeLivenessDuringScan();
+
+ void propagateTransitions(SlotVisitor&);
+ void determineLiveness(SlotVisitor&);
+
+ void stronglyVisitStrongReferences(SlotVisitor&);
+ void stronglyVisitWeakReferences(SlotVisitor&);
- // Expression info - present if debugging.
- Vector<ExpressionRangeInfo> m_expressionInfo;
- // Line info - present if profiling or debugging.
- Vector<LineInfo> m_lineInfo;
+ void createRareDataIfNecessary()
+ {
+ if (!m_rareData)
+ m_rareData = adoptPtr(new RareData);
+ }
+
#if ENABLE(JIT)
- Vector<CallReturnOffsetToBytecodeOffset> m_callReturnIndexVector;
+ void resetStubInternal(RepatchBuffer&, StructureStubInfo&);
+ void resetStubDuringGCInternal(RepatchBuffer&, StructureStubInfo&);
#endif
+ WriteBarrier<UnlinkedCodeBlock> m_unlinkedCode;
+ int m_numParameters;
+ union {
+ unsigned m_debuggerRequests;
+ struct {
+ unsigned m_hasDebuggerStatement : 1;
+ unsigned m_steppingMode : 1;
+ unsigned m_numBreakpoints : 30;
};
-#if COMPILER(MSVC)
- friend void WTF::deleteOwnedPtr<RareData>(RareData*);
-#endif
- OwnPtr<RareData> m_rareData;
};
+ WriteBarrier<ScriptExecutable> m_ownerExecutable;
+ VM* m_vm;
+
+ RefCountedArray<Instruction> m_instructions;
+ WriteBarrier<SymbolTable> m_symbolTable;
+ VirtualRegister m_thisRegister;
+ VirtualRegister m_argumentsRegister;
+ VirtualRegister m_activationRegister;
+
+ bool m_isStrictMode;
+ bool m_needsActivation;
+ bool m_mayBeExecuting;
+ uint8_t m_visitAggregateHasBeenCalled;
+
+ RefPtr<SourceProvider> m_source;
+ unsigned m_sourceOffset;
+ unsigned m_firstLineColumnOffset;
+ unsigned m_codeType;
+
+ Vector<LLIntCallLinkInfo> m_llintCallLinkInfos;
+ SentinelLinkedList<LLIntCallLinkInfo, BasicRawSentinelNode<LLIntCallLinkInfo>> m_incomingLLIntCalls;
+ RefPtr<JITCode> m_jitCode;
+#if ENABLE(JIT)
+ Bag<StructureStubInfo> m_stubInfos;
+ Vector<ByValInfo> m_byValInfos;
+ Bag<CallLinkInfo> m_callLinkInfos;
+ SentinelLinkedList<CallLinkInfo, BasicRawSentinelNode<CallLinkInfo>> m_incomingCalls;
+#endif
+ OwnPtr<CompactJITCodeMap> m_jitCodeMap;
+#if ENABLE(DFG_JIT)
+ // This is relevant to non-DFG code blocks that serve as the profiled code block
+ // for DFG code blocks.
+ DFG::ExitProfile m_exitProfile;
+ CompressedLazyOperandValueProfileHolder m_lazyOperandValueProfiles;
+#endif
+ Vector<ValueProfile> m_argumentValueProfiles;
+ Vector<ValueProfile> m_valueProfiles;
+ SegmentedVector<RareCaseProfile, 8> m_rareCaseProfiles;
+ SegmentedVector<RareCaseProfile, 8> m_specialFastCaseProfiles;
+ Vector<ArrayAllocationProfile> m_arrayAllocationProfiles;
+ ArrayProfileVector m_arrayProfiles;
+ Vector<ObjectAllocationProfile> m_objectAllocationProfiles;
+
+ // Constant Pool
+ COMPILE_ASSERT(sizeof(Register) == sizeof(WriteBarrier<Unknown>), Register_must_be_same_size_as_WriteBarrier_Unknown);
+ // TODO: This could just be a pointer to m_unlinkedCodeBlock's data, but the DFG mutates
+ // it, so we're stuck with it for now.
+ Vector<WriteBarrier<Unknown>> m_constantRegisters;
+ Vector<WriteBarrier<FunctionExecutable>> m_functionDecls;
+ Vector<WriteBarrier<FunctionExecutable>> m_functionExprs;
+
+ RefPtr<CodeBlock> m_alternative;
+
+ BaselineExecutionCounter m_llintExecuteCounter;
+
+ BaselineExecutionCounter m_jitExecuteCounter;
+ int32_t m_totalJITExecutions;
+ uint32_t m_osrExitCounter;
+ uint16_t m_optimizationDelayCounter;
+ uint16_t m_reoptimizationRetryCounter;
+
+ mutable CodeBlockHash m_hash;
- // Program code is not marked by any function, so we make the global object
- // responsible for marking it.
+ std::unique_ptr<BytecodeLivenessAnalysis> m_livenessAnalysis;
- class GlobalCodeBlock : public CodeBlock {
+ struct RareData {
+ WTF_MAKE_FAST_ALLOCATED;
public:
- GlobalCodeBlock(ScriptExecutable* ownerExecutable, CodeType codeType, JSGlobalObject* globalObject, PassRefPtr<SourceProvider> sourceProvider, unsigned sourceOffset)
- : CodeBlock(ownerExecutable, codeType, globalObject, sourceProvider, sourceOffset, &m_unsharedSymbolTable, false)
- {
- }
+ Vector<HandlerInfo> m_exceptionHandlers;
- private:
- SymbolTable m_unsharedSymbolTable;
- };
+ // Buffers used for large array literals
+ Vector<Vector<JSValue>> m_constantBuffers;
- class ProgramCodeBlock : public GlobalCodeBlock {
- public:
- ProgramCodeBlock(ProgramExecutable* ownerExecutable, CodeType codeType, JSGlobalObject* globalObject, PassRefPtr<SourceProvider> sourceProvider)
- : GlobalCodeBlock(ownerExecutable, codeType, globalObject, sourceProvider, 0)
- {
- }
+ // Jump Tables
+ Vector<SimpleJumpTable> m_switchJumpTables;
+ Vector<StringJumpTable> m_stringSwitchJumpTables;
+
+ EvalCodeCache m_evalCodeCache;
};
+#if COMPILER(MSVC)
+ friend void WTF::deleteOwnedPtr<RareData>(RareData*);
+#endif
+ OwnPtr<RareData> m_rareData;
+#if ENABLE(JIT)
+ DFG::CapabilityLevel m_capabilityLevelState;
+#endif
+};
- class EvalCodeBlock : public GlobalCodeBlock {
- public:
- EvalCodeBlock(EvalExecutable* ownerExecutable, JSGlobalObject* globalObject, PassRefPtr<SourceProvider> sourceProvider, int baseScopeDepth)
- : GlobalCodeBlock(ownerExecutable, EvalCode, globalObject, sourceProvider, 0)
- , m_baseScopeDepth(baseScopeDepth)
- {
- }
+// Program code is not marked by any function, so we make the global object
+// responsible for marking it.
- int baseScopeDepth() const { return m_baseScopeDepth; }
+class GlobalCodeBlock : public CodeBlock {
+protected:
+ GlobalCodeBlock(CopyParsedBlockTag, GlobalCodeBlock& other)
+ : CodeBlock(CopyParsedBlock, other)
+ {
+ }
+
+ GlobalCodeBlock(ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlinkedCodeBlock, JSScope* scope, PassRefPtr<SourceProvider> sourceProvider, unsigned sourceOffset, unsigned firstLineColumnOffset)
+ : CodeBlock(ownerExecutable, unlinkedCodeBlock, scope, sourceProvider, sourceOffset, firstLineColumnOffset)
+ {
+ }
+};
- const Identifier& variable(unsigned index) { return m_variables[index]; }
- unsigned numVariables() { return m_variables.size(); }
- void adoptVariables(Vector<Identifier>& variables)
- {
- ASSERT(m_variables.isEmpty());
- m_variables.swap(variables);
- }
+class ProgramCodeBlock : public GlobalCodeBlock {
+public:
+ ProgramCodeBlock(CopyParsedBlockTag, ProgramCodeBlock& other)
+ : GlobalCodeBlock(CopyParsedBlock, other)
+ {
+ }
- private:
- int m_baseScopeDepth;
- Vector<Identifier> m_variables;
- };
+ ProgramCodeBlock(ProgramExecutable* ownerExecutable, UnlinkedProgramCodeBlock* unlinkedCodeBlock, JSScope* scope, PassRefPtr<SourceProvider> sourceProvider, unsigned firstLineColumnOffset)
+ : GlobalCodeBlock(ownerExecutable, unlinkedCodeBlock, scope, sourceProvider, 0, firstLineColumnOffset)
+ {
+ }
- class FunctionCodeBlock : public CodeBlock {
- public:
- // Rather than using the usual RefCounted::create idiom for SharedSymbolTable we just use new
- // as we need to initialise the CodeBlock before we could initialise any RefPtr to hold the shared
- // symbol table, so we just pass as a raw pointer with a ref count of 1. We then manually deref
- // in the destructor.
- FunctionCodeBlock(FunctionExecutable* ownerExecutable, CodeType codeType, JSGlobalObject* globalObject, PassRefPtr<SourceProvider> sourceProvider, unsigned sourceOffset, bool isConstructor)
- : CodeBlock(ownerExecutable, codeType, globalObject, sourceProvider, sourceOffset, SharedSymbolTable::create().leakRef(), isConstructor)
- {
- }
- ~FunctionCodeBlock()
- {
- sharedSymbolTable()->deref();
- }
- };
+#if ENABLE(JIT)
+protected:
+ virtual CodeBlock* replacement() override;
+ virtual DFG::CapabilityLevel capabilityLevelInternal() override;
+#endif
+};
- inline Register& ExecState::r(int index)
+class EvalCodeBlock : public GlobalCodeBlock {
+public:
+ EvalCodeBlock(CopyParsedBlockTag, EvalCodeBlock& other)
+ : GlobalCodeBlock(CopyParsedBlock, other)
+ {
+ }
+
+ EvalCodeBlock(EvalExecutable* ownerExecutable, UnlinkedEvalCodeBlock* unlinkedCodeBlock, JSScope* scope, PassRefPtr<SourceProvider> sourceProvider)
+ : GlobalCodeBlock(ownerExecutable, unlinkedCodeBlock, scope, sourceProvider, 0, 1)
+ {
+ }
+
+ const Identifier& variable(unsigned index) { return unlinkedEvalCodeBlock()->variable(index); }
+ unsigned numVariables() { return unlinkedEvalCodeBlock()->numVariables(); }
+
+#if ENABLE(JIT)
+protected:
+ virtual CodeBlock* replacement() override;
+ virtual DFG::CapabilityLevel capabilityLevelInternal() override;
+#endif
+
+private:
+ UnlinkedEvalCodeBlock* unlinkedEvalCodeBlock() const { return jsCast<UnlinkedEvalCodeBlock*>(unlinkedCodeBlock()); }
+};
+
+class FunctionCodeBlock : public CodeBlock {
+public:
+ FunctionCodeBlock(CopyParsedBlockTag, FunctionCodeBlock& other)
+ : CodeBlock(CopyParsedBlock, other)
{
- CodeBlock* codeBlock = this->codeBlock();
- if (codeBlock->isConstantRegisterIndex(index))
- return *reinterpret_cast<Register*>(&codeBlock->constantRegister(index));
- return this[index];
}
- inline Register& ExecState::uncheckedR(int index)
+ FunctionCodeBlock(FunctionExecutable* ownerExecutable, UnlinkedFunctionCodeBlock* unlinkedCodeBlock, JSScope* scope, PassRefPtr<SourceProvider> sourceProvider, unsigned sourceOffset, unsigned firstLineColumnOffset)
+ : CodeBlock(ownerExecutable, unlinkedCodeBlock, scope, sourceProvider, sourceOffset, firstLineColumnOffset)
{
- ASSERT(index < FirstConstantRegisterIndex);
- return this[index];
}
+#if ENABLE(JIT)
+protected:
+ virtual CodeBlock* replacement() override;
+ virtual DFG::CapabilityLevel capabilityLevelInternal() override;
+#endif
+};
+
+inline CodeBlock* baselineCodeBlockForInlineCallFrame(InlineCallFrame* inlineCallFrame)
+{
+ RELEASE_ASSERT(inlineCallFrame);
+ ExecutableBase* executable = inlineCallFrame->executable.get();
+ RELEASE_ASSERT(executable->structure()->classInfo() == FunctionExecutable::info());
+ return static_cast<FunctionExecutable*>(executable)->baselineCodeBlockFor(inlineCallFrame->isCall ? CodeForCall : CodeForConstruct);
+}
+
+inline CodeBlock* baselineCodeBlockForOriginAndBaselineCodeBlock(const CodeOrigin& codeOrigin, CodeBlock* baselineCodeBlock)
+{
+ if (codeOrigin.inlineCallFrame)
+ return baselineCodeBlockForInlineCallFrame(codeOrigin.inlineCallFrame);
+ return baselineCodeBlock;
+}
+
+inline int CodeBlock::argumentIndexAfterCapture(size_t argument)
+{
+ if (argument >= static_cast<size_t>(symbolTable()->parameterCount()))
+ return CallFrame::argumentOffset(argument);
+
+ const SlowArgument* slowArguments = symbolTable()->slowArguments();
+ if (!slowArguments || slowArguments[argument].status == SlowArgument::Normal)
+ return CallFrame::argumentOffset(argument);
+
+ ASSERT(slowArguments[argument].status == SlowArgument::Captured);
+ return slowArguments[argument].index;
+}
+
+inline bool CodeBlock::hasSlowArguments()
+{
+ return !!symbolTable()->slowArguments();
+}
+
+inline Register& ExecState::r(int index)
+{
+ CodeBlock* codeBlock = this->codeBlock();
+ if (codeBlock->isConstantRegisterIndex(index))
+ return *reinterpret_cast<Register*>(&codeBlock->constantRegister(index));
+ return this[index];
+}
+
+inline Register& ExecState::uncheckedR(int index)
+{
+ RELEASE_ASSERT(index < FirstConstantRegisterIndex);
+ return this[index];
+}
+
+inline JSValue ExecState::argumentAfterCapture(size_t argument)
+{
+ if (argument >= argumentCount())
+ return jsUndefined();
+
+ if (!codeBlock())
+ return this[argumentOffset(argument)].jsValue();
+
+ return this[codeBlock()->argumentIndexAfterCapture(argument)].jsValue();
+}
+
+inline void CodeBlockSet::mark(void* candidateCodeBlock)
+{
+ // We have to check for 0 and -1 because those are used by the HashMap as markers.
+ uintptr_t value = reinterpret_cast<uintptr_t>(candidateCodeBlock);
+
+ // This checks for both of those nasty cases in one go.
+ // 0 + 1 = 1
+ // -1 + 1 = 0
+ if (value + 1 <= 1)
+ return;
+
+ CodeBlock* codeBlock = static_cast<CodeBlock*>(candidateCodeBlock);
+ if (!m_oldCodeBlocks.contains(codeBlock) && !m_newCodeBlocks.contains(codeBlock))
+ return;
+
+ mark(codeBlock);
+}
+
+inline void CodeBlockSet::mark(CodeBlock* codeBlock)
+{
+ if (!codeBlock)
+ return;
+
+ if (codeBlock->m_mayBeExecuting)
+ return;
+
+ codeBlock->m_mayBeExecuting = true;
+ // We might not have cleared the marks for this CodeBlock, but we need to visit it.
+ codeBlock->m_visitAggregateHasBeenCalled = false;
+#if ENABLE(GGC)
+ m_currentlyExecuting.append(codeBlock);
+#endif
+}
+
+template <typename Functor> inline void ScriptExecutable::forEachCodeBlock(Functor&& functor)
+{
+ switch (type()) {
+ case ProgramExecutableType: {
+ if (CodeBlock* codeBlock = jsCast<ProgramExecutable*>(this)->m_programCodeBlock.get())
+ codeBlock->forEachRelatedCodeBlock(std::forward<Functor>(functor));
+ break;
+ }
+
+ case EvalExecutableType: {
+ if (CodeBlock* codeBlock = jsCast<EvalExecutable*>(this)->m_evalCodeBlock.get())
+ codeBlock->forEachRelatedCodeBlock(std::forward<Functor>(functor));
+ break;
+ }
+
+ case FunctionExecutableType: {
+ Functor f(std::forward<Functor>(functor));
+ FunctionExecutable* executable = jsCast<FunctionExecutable*>(this);
+ if (CodeBlock* codeBlock = executable->m_codeBlockForCall.get())
+ codeBlock->forEachRelatedCodeBlock(f);
+ if (CodeBlock* codeBlock = executable->m_codeBlockForConstruct.get())
+ codeBlock->forEachRelatedCodeBlock(f);
+ break;
+ }
+ default:
+ RELEASE_ASSERT_NOT_REACHED();
+ }
+}
+
} // namespace JSC
#endif // CodeBlock_h