X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/14957cd040308e3eeec43d26bae5d76da13fcd85..ed1e77d3adeb83d26fd1dfb16dd84cabdcefd250:/runtime/Executable.h diff --git a/runtime/Executable.h b/runtime/Executable.h index e795fbf..1c7c800 100644 --- a/runtime/Executable.h +++ b/runtime/Executable.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009, 2010 Apple Inc. All rights reserved. + * Copyright (C) 2009, 2010, 2013-2015 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -26,439 +26,686 @@ #ifndef Executable_h #define Executable_h +#include "ArityCheckMode.h" #include "CallData.h" -#include "JSFunction.h" -#include "Interpreter.h" -#include "Nodes.h" +#include "CodeBlockHash.h" +#include "CodeSpecializationKind.h" +#include "CompilationResult.h" +#include "DFGPlan.h" +#include "HandlerInfo.h" +#include "InferredValue.h" +#include "JITCode.h" +#include "JSGlobalObject.h" +#include "RegisterPreservationMode.h" #include "SamplingTool.h" -#include +#include "SourceCode.h" +#include "TypeSet.h" +#include "UnlinkedCodeBlock.h" namespace JSC { - class CodeBlock; - class Debugger; - class EvalCodeBlock; - class FunctionCodeBlock; - class ProgramCodeBlock; - class ScopeChainNode; +class CodeBlock; +class Debugger; +class EvalCodeBlock; +class FunctionCodeBlock; +class LLIntOffsetsExtractor; +class ProgramCodeBlock; +class JSScope; + +enum CompilationKind { FirstCompilation, OptimizingCompilation }; + +inline bool isCall(CodeSpecializationKind kind) +{ + if (kind == CodeForCall) + return true; + ASSERT(kind == CodeForConstruct); + return false; +} - struct ExceptionInfo; +class ExecutableBase : public JSCell { + friend class JIT; - class ExecutableBase : public JSCell { - friend class JIT; +protected: + static const int NUM_PARAMETERS_IS_HOST = 0; + static const int NUM_PARAMETERS_NOT_COMPILED = -1; - protected: - static const int NUM_PARAMETERS_IS_HOST = 0; - static const int NUM_PARAMETERS_NOT_COMPILED = -1; - - public: - ExecutableBase(JSGlobalData& globalData, Structure* structure, int numParameters) - : JSCell(globalData, structure) - , m_numParametersForCall(numParameters) - , m_numParametersForConstruct(numParameters) - { -#if ENABLE(JIT) - Weak finalizer(globalData, this, executableFinalizer()); - finalizer.leakHandle(); -#endif - } + ExecutableBase(VM& vm, Structure* structure, int numParameters) + : JSCell(vm, structure) + , m_numParametersForCall(numParameters) + , m_numParametersForConstruct(numParameters) + { + } - bool isHostFunction() const - { - ASSERT((m_numParametersForCall == NUM_PARAMETERS_IS_HOST) == (m_numParametersForConstruct == NUM_PARAMETERS_IS_HOST)); - return m_numParametersForCall == NUM_PARAMETERS_IS_HOST; - } + void finishCreation(VM& vm) + { + Base::finishCreation(vm); + } - static Structure* createStructure(JSGlobalData& globalData, JSValue proto) { return Structure::create(globalData, proto, TypeInfo(CompoundType, StructureFlags), AnonymousSlotCount, &s_info); } +public: + typedef JSCell Base; + static const unsigned StructureFlags = Base::StructureFlags; + + static const bool needsDestruction = true; + static void destroy(JSCell*); - static const ClassInfo s_info; - - protected: - static const unsigned StructureFlags = 0; - int m_numParametersForCall; - int m_numParametersForConstruct; - -#if ENABLE(JIT) - public: - JITCode& generatedJITCodeForCall() - { - ASSERT(m_jitCodeForCall); - return m_jitCodeForCall; - } + CodeBlockHash hashFor(CodeSpecializationKind) const; - JITCode& generatedJITCodeForConstruct() - { - ASSERT(m_jitCodeForConstruct); - return m_jitCodeForConstruct; - } + bool isEvalExecutable() + { + return type() == EvalExecutableType; + } + bool isFunctionExecutable() + { + return type() == FunctionExecutableType; + } + bool isProgramExecutable() + { + return type() == ProgramExecutableType; + } - void clearExecutableCode() - { - m_jitCodeForCall.clear(); - m_jitCodeForConstruct.clear(); - } + bool isHostFunction() const + { + ASSERT((m_numParametersForCall == NUM_PARAMETERS_IS_HOST) == (m_numParametersForConstruct == NUM_PARAMETERS_IS_HOST)); + return m_numParametersForCall == NUM_PARAMETERS_IS_HOST; + } - protected: - JITCode m_jitCodeForCall; - JITCode m_jitCodeForConstruct; - MacroAssemblerCodePtr m_jitCodeForCallWithArityCheck; - MacroAssemblerCodePtr m_jitCodeForConstructWithArityCheck; + static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto) { return Structure::create(vm, globalObject, proto, TypeInfo(CellType, StructureFlags), info()); } - private: - static WeakHandleOwner* executableFinalizer(); -#endif - }; - - class NativeExecutable : public ExecutableBase { - friend class JIT; - public: -#if ENABLE(JIT) - static NativeExecutable* create(JSGlobalData& globalData, MacroAssemblerCodePtr callThunk, NativeFunction function, MacroAssemblerCodePtr constructThunk, NativeFunction constructor) - { - if (!callThunk) - return new (&globalData) NativeExecutable(globalData, JITCode(), function, JITCode(), constructor); - return new (&globalData) NativeExecutable(globalData, JITCode::HostFunction(callThunk), function, JITCode::HostFunction(constructThunk), constructor); - } -#else - static NativeExecutable* create(JSGlobalData& globalData, NativeFunction function, NativeFunction constructor) - { - return new (&globalData) NativeExecutable(globalData, function, constructor); - } -#endif + void clearCode(); + + DECLARE_EXPORT_INFO; - ~NativeExecutable(); +protected: + int m_numParametersForCall; + int m_numParametersForConstruct; - NativeFunction function() { return m_function; } +public: + static void clearCodeVirtual(ExecutableBase*); - static Structure* createStructure(JSGlobalData& globalData, JSValue proto) { return Structure::create(globalData, proto, TypeInfo(LeafType, StructureFlags), AnonymousSlotCount, &s_info); } + PassRefPtr generatedJITCodeForCall() + { + ASSERT(m_jitCodeForCall); + return m_jitCodeForCall; + } + + PassRefPtr generatedJITCodeForConstruct() + { + ASSERT(m_jitCodeForConstruct); + return m_jitCodeForConstruct; + } - static const ClassInfo s_info; + PassRefPtr generatedJITCodeFor(CodeSpecializationKind kind) + { + if (kind == CodeForCall) + return generatedJITCodeForCall(); + ASSERT(kind == CodeForConstruct); + return generatedJITCodeForConstruct(); + } - private: -#if ENABLE(JIT) - NativeExecutable(JSGlobalData& globalData, JITCode callThunk, NativeFunction function, JITCode constructThunk, NativeFunction constructor) - : ExecutableBase(globalData, globalData.nativeExecutableStructure.get(), NUM_PARAMETERS_IS_HOST) - , m_function(function) - , m_constructor(constructor) - { - m_jitCodeForCall = callThunk; - m_jitCodeForConstruct = constructThunk; - m_jitCodeForCallWithArityCheck = callThunk.addressForCall(); - m_jitCodeForConstructWithArityCheck = constructThunk.addressForCall(); - } -#else - NativeExecutable(JSGlobalData& globalData, NativeFunction function, NativeFunction constructor) - : ExecutableBase(globalData, globalData.nativeExecutableStructure.get(), NUM_PARAMETERS_IS_HOST) - , m_function(function) - , m_constructor(constructor) - { - } -#endif + MacroAssemblerCodePtr entrypointFor( + VM& vm, CodeSpecializationKind kind, ArityCheckMode arity, RegisterPreservationMode registers) + { + // Check if we have a cached result. We only have it for arity check because we use the + // no-arity entrypoint in non-virtual calls, which will "cache" this value directly in + // machine code. + if (arity == MustCheckArity) { + switch (kind) { + case CodeForCall: + switch (registers) { + case RegisterPreservationNotRequired: + if (MacroAssemblerCodePtr result = m_jitCodeForCallWithArityCheck) + return result; + break; + case MustPreserveRegisters: + if (MacroAssemblerCodePtr result = m_jitCodeForCallWithArityCheckAndPreserveRegs) + return result; + break; + } + break; + case CodeForConstruct: + switch (registers) { + case RegisterPreservationNotRequired: + if (MacroAssemblerCodePtr result = m_jitCodeForConstructWithArityCheck) + return result; + break; + case MustPreserveRegisters: + if (MacroAssemblerCodePtr result = m_jitCodeForConstructWithArityCheckAndPreserveRegs) + return result; + break; + } + break; + } + } + MacroAssemblerCodePtr result = + generatedJITCodeFor(kind)->addressForCall(vm, this, arity, registers); + if (arity == MustCheckArity) { + // Cache the result; this is necessary for the JIT's virtual call optimizations. + switch (kind) { + case CodeForCall: + switch (registers) { + case RegisterPreservationNotRequired: + m_jitCodeForCallWithArityCheck = result; + break; + case MustPreserveRegisters: + m_jitCodeForCallWithArityCheckAndPreserveRegs = result; + break; + } + break; + case CodeForConstruct: + switch (registers) { + case RegisterPreservationNotRequired: + m_jitCodeForConstructWithArityCheck = result; + break; + case MustPreserveRegisters: + m_jitCodeForConstructWithArityCheckAndPreserveRegs = result; + break; + } + break; + } + } + return result; + } - NativeFunction m_function; - // Probably should be a NativeConstructor, but this will currently require rewriting the JIT - // trampoline. It may be easier to make NativeFunction be passed 'this' as a part of the ArgList. - NativeFunction m_constructor; - }; - - class ScriptExecutable : public ExecutableBase { - public: - ScriptExecutable(Structure* structure, JSGlobalData* globalData, const SourceCode& source, bool isInStrictContext) - : ExecutableBase(*globalData, structure, NUM_PARAMETERS_NOT_COMPILED) - , m_source(source) - , m_features(isInStrictContext ? StrictModeFeature : 0) - { -#if ENABLE(CODEBLOCK_SAMPLING) - relaxAdoptionRequirement(); - if (SamplingTool* sampler = globalData->interpreter->sampler()) - sampler->notifyOfScope(this); -#else - UNUSED_PARAM(globalData); -#endif - } + static ptrdiff_t offsetOfJITCodeWithArityCheckFor( + CodeSpecializationKind kind, RegisterPreservationMode registers) + { + switch (kind) { + case CodeForCall: + switch (registers) { + case RegisterPreservationNotRequired: + return OBJECT_OFFSETOF(ExecutableBase, m_jitCodeForCallWithArityCheck); + case MustPreserveRegisters: + return OBJECT_OFFSETOF(ExecutableBase, m_jitCodeForCallWithArityCheckAndPreserveRegs); + } + case CodeForConstruct: + switch (registers) { + case RegisterPreservationNotRequired: + return OBJECT_OFFSETOF(ExecutableBase, m_jitCodeForConstructWithArityCheck); + case MustPreserveRegisters: + return OBJECT_OFFSETOF(ExecutableBase, m_jitCodeForConstructWithArityCheckAndPreserveRegs); + } + } + RELEASE_ASSERT_NOT_REACHED(); + return 0; + } + + static ptrdiff_t offsetOfNumParametersFor(CodeSpecializationKind kind) + { + if (kind == CodeForCall) + return OBJECT_OFFSETOF(ExecutableBase, m_numParametersForCall); + ASSERT(kind == CodeForConstruct); + return OBJECT_OFFSETOF(ExecutableBase, m_numParametersForConstruct); + } - ScriptExecutable(Structure* structure, ExecState* exec, const SourceCode& source, bool isInStrictContext) - : ExecutableBase(exec->globalData(), structure, NUM_PARAMETERS_NOT_COMPILED) - , m_source(source) - , m_features(isInStrictContext ? StrictModeFeature : 0) - { -#if ENABLE(CODEBLOCK_SAMPLING) - relaxAdoptionRequirement(); - if (SamplingTool* sampler = exec->globalData().interpreter->sampler()) - sampler->notifyOfScope(this); -#else - UNUSED_PARAM(exec); -#endif - } + bool hasJITCodeForCall() const + { + return m_numParametersForCall >= 0; + } + + bool hasJITCodeForConstruct() const + { + return m_numParametersForConstruct >= 0; + } + + bool hasJITCodeFor(CodeSpecializationKind kind) const + { + if (kind == CodeForCall) + return hasJITCodeForCall(); + ASSERT(kind == CodeForConstruct); + return hasJITCodeForConstruct(); + } - const SourceCode& source() { return m_source; } - intptr_t sourceID() const { return m_source.provider()->asID(); } - const UString& sourceURL() const { return m_source.provider()->url(); } - int lineNo() const { return m_firstLine; } - int lastLine() const { return m_lastLine; } + // Intrinsics are only for calls, currently. + Intrinsic intrinsic() const; + + Intrinsic intrinsicFor(CodeSpecializationKind kind) const + { + if (isCall(kind)) + return intrinsic(); + return NoIntrinsic; + } + + void dump(PrintStream&) const; + +protected: + RefPtr m_jitCodeForCall; + RefPtr m_jitCodeForConstruct; + MacroAssemblerCodePtr m_jitCodeForCallWithArityCheck; + MacroAssemblerCodePtr m_jitCodeForConstructWithArityCheck; + MacroAssemblerCodePtr m_jitCodeForCallWithArityCheckAndPreserveRegs; + MacroAssemblerCodePtr m_jitCodeForConstructWithArityCheckAndPreserveRegs; +}; + +class NativeExecutable final : public ExecutableBase { + friend class JIT; + friend class LLIntOffsetsExtractor; +public: + typedef ExecutableBase Base; + static const unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal; + + static NativeExecutable* create(VM& vm, PassRefPtr callThunk, NativeFunction function, PassRefPtr constructThunk, NativeFunction constructor, Intrinsic intrinsic) + { + NativeExecutable* executable; + executable = new (NotNull, allocateCell(vm.heap)) NativeExecutable(vm, function, constructor); + executable->finishCreation(vm, callThunk, constructThunk, intrinsic); + return executable; + } - bool usesEval() const { return m_features & EvalFeature; } - bool usesArguments() const { return m_features & ArgumentsFeature; } - bool needsActivation() const { return m_hasCapturedVariables || m_features & (EvalFeature | WithFeature | CatchFeature); } - bool isStrictMode() const { return m_features & StrictModeFeature; } + static void destroy(JSCell*); - virtual void unlinkCalls() = 0; + CodeBlockHash hashFor(CodeSpecializationKind) const; + + NativeFunction function() { return m_function; } + NativeFunction constructor() { return m_constructor; } - static const ClassInfo s_info; - protected: - void recordParse(CodeFeatures features, bool hasCapturedVariables, int firstLine, int lastLine) - { - m_features = features; - m_hasCapturedVariables = hasCapturedVariables; - m_firstLine = firstLine; - m_lastLine = lastLine; - } + NativeFunction nativeFunctionFor(CodeSpecializationKind kind) + { + if (kind == CodeForCall) + return function(); + ASSERT(kind == CodeForConstruct); + return constructor(); + } + + static ptrdiff_t offsetOfNativeFunctionFor(CodeSpecializationKind kind) + { + if (kind == CodeForCall) + return OBJECT_OFFSETOF(NativeExecutable, m_function); + ASSERT(kind == CodeForConstruct); + return OBJECT_OFFSETOF(NativeExecutable, m_constructor); + } - SourceCode m_source; - CodeFeatures m_features; - bool m_hasCapturedVariables; - int m_firstLine; - int m_lastLine; - }; - - class EvalExecutable : public ScriptExecutable { - public: - - ~EvalExecutable(); - - JSObject* compile(ExecState* exec, ScopeChainNode* scopeChainNode) - { - ASSERT(exec->globalData().dynamicGlobalObject); - JSObject* error = 0; - if (!m_evalCodeBlock) - error = compileInternal(exec, scopeChainNode); - ASSERT(!error == !!m_evalCodeBlock); - return error; - } + static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto) { return Structure::create(vm, globalObject, proto, TypeInfo(CellType, StructureFlags), info()); } + + DECLARE_INFO; - EvalCodeBlock& generatedBytecode() - { - ASSERT(m_evalCodeBlock); - return *m_evalCodeBlock; - } + Intrinsic intrinsic() const; - static EvalExecutable* create(ExecState* exec, const SourceCode& source, bool isInStrictContext) { return new (exec) EvalExecutable(exec, source, isInStrictContext); } +protected: + void finishCreation(VM& vm, PassRefPtr callThunk, PassRefPtr constructThunk, Intrinsic intrinsic) + { + Base::finishCreation(vm); + m_jitCodeForCall = callThunk; + m_jitCodeForConstruct = constructThunk; + m_intrinsic = intrinsic; + } -#if ENABLE(JIT) - JITCode& generatedJITCode() - { - return generatedJITCodeForCall(); - } -#endif - static Structure* createStructure(JSGlobalData& globalData, JSValue proto) - { - return Structure::create(globalData, proto, TypeInfo(CompoundType, StructureFlags), AnonymousSlotCount, &s_info); - } +private: + NativeExecutable(VM& vm, NativeFunction function, NativeFunction constructor) + : ExecutableBase(vm, vm.nativeExecutableStructure.get(), NUM_PARAMETERS_IS_HOST) + , m_function(function) + , m_constructor(constructor) + { + } + + NativeFunction m_function; + NativeFunction m_constructor; - static const ClassInfo s_info; - private: - static const unsigned StructureFlags = OverridesVisitChildren | ScriptExecutable::StructureFlags; - EvalExecutable(ExecState*, const SourceCode&, bool); - - JSObject* compileInternal(ExecState*, ScopeChainNode*); - virtual void visitChildren(SlotVisitor&); - void unlinkCalls(); - - OwnPtr m_evalCodeBlock; - }; - - class ProgramExecutable : public ScriptExecutable { - public: - static ProgramExecutable* create(ExecState* exec, const SourceCode& source) - { - return new (exec) ProgramExecutable(exec, source); - } + Intrinsic m_intrinsic; +}; - ~ProgramExecutable(); +class ScriptExecutable : public ExecutableBase { +public: + typedef ExecutableBase Base; + static const unsigned StructureFlags = Base::StructureFlags; - JSObject* compile(ExecState* exec, ScopeChainNode* scopeChainNode) - { - ASSERT(exec->globalData().dynamicGlobalObject); - JSObject* error = 0; - if (!m_programCodeBlock) - error = compileInternal(exec, scopeChainNode); - ASSERT(!error == !!m_programCodeBlock); - return error; - } + static void destroy(JSCell*); + + CodeBlockHash hashFor(CodeSpecializationKind) const; + + const SourceCode& source() const { return m_source; } + intptr_t sourceID() const { return m_source.providerID(); } + const String& sourceURL() const { return m_source.provider()->url(); } + int firstLine() const { return m_firstLine; } + void setOverrideLineNumber(int overrideLineNumber) { m_overrideLineNumber = overrideLineNumber; } + bool hasOverrideLineNumber() const { return m_overrideLineNumber != -1; } + int overrideLineNumber() const { return m_overrideLineNumber; } + int lastLine() const { return m_lastLine; } + unsigned startColumn() const { return m_startColumn; } + unsigned endColumn() const { return m_endColumn; } + unsigned typeProfilingStartOffset() const { return m_typeProfilingStartOffset; } + unsigned typeProfilingEndOffset() const { return m_typeProfilingEndOffset; } + + bool usesEval() const { return m_features & EvalFeature; } + bool usesArguments() const { return m_features & ArgumentsFeature; } + bool needsActivation() const { return m_hasCapturedVariables || m_features & (EvalFeature | WithFeature | CatchFeature); } + bool isStrictMode() const { return m_features & StrictModeFeature; } + ECMAMode ecmaMode() const { return isStrictMode() ? StrictMode : NotStrictMode; } + + void setNeverInline(bool value) { m_neverInline = value; } + void setDidTryToEnterInLoop(bool value) { m_didTryToEnterInLoop = value; } + bool neverInline() const { return m_neverInline; } + bool didTryToEnterInLoop() const { return m_didTryToEnterInLoop; } + bool isInliningCandidate() const { return !neverInline(); } + + bool* addressOfDidTryToEnterInLoop() { return &m_didTryToEnterInLoop; } - ProgramCodeBlock& generatedBytecode() - { - ASSERT(m_programCodeBlock); - return *m_programCodeBlock; - } + void unlinkCalls(); + + CodeFeatures features() const { return m_features; } + + DECLARE_INFO; - JSObject* checkSyntax(ExecState*); + void recordParse(CodeFeatures features, bool hasCapturedVariables, int firstLine, int lastLine, unsigned startColumn, unsigned endColumn) + { + m_features = features; + m_hasCapturedVariables = hasCapturedVariables; + m_firstLine = firstLine; + m_lastLine = lastLine; + ASSERT(startColumn != UINT_MAX); + m_startColumn = startColumn; + ASSERT(endColumn != UINT_MAX); + m_endColumn = endColumn; + } -#if ENABLE(JIT) - JITCode& generatedJITCode() - { - return generatedJITCodeForCall(); - } + void installCode(CodeBlock*); + RefPtr newCodeBlockFor(CodeSpecializationKind, JSFunction*, JSScope*, JSObject*& exception); + PassRefPtr newReplacementCodeBlockFor(CodeSpecializationKind); + + JSObject* prepareForExecution(ExecState* exec, JSFunction* function, JSScope* scope, CodeSpecializationKind kind) + { + if (hasJITCodeFor(kind)) + return 0; + return prepareForExecutionImpl(exec, function, scope, kind); + } + + template void forEachCodeBlock(Functor&&); + +private: + JSObject* prepareForExecutionImpl(ExecState*, JSFunction*, JSScope*, CodeSpecializationKind); + +protected: + ScriptExecutable(Structure* structure, VM& vm, const SourceCode& source, bool isInStrictContext); + + void finishCreation(VM& vm) + { + Base::finishCreation(vm); + vm.heap.addCompiledCode(this); // Balanced by Heap::deleteUnmarkedCompiledCode(). + +#if ENABLE(CODEBLOCK_SAMPLING) + if (SamplingTool* sampler = vm.interpreter->sampler()) + sampler->notifyOfScope(vm, this); #endif + } + + SourceCode m_source; + CodeFeatures m_features; + bool m_hasCapturedVariables; + bool m_neverInline; + bool m_didTryToEnterInLoop; + int m_overrideLineNumber; + int m_firstLine; + int m_lastLine; + unsigned m_startColumn; + unsigned m_endColumn; + unsigned m_typeProfilingStartOffset; + unsigned m_typeProfilingEndOffset; +}; + +class EvalExecutable final : public ScriptExecutable { + friend class LLIntOffsetsExtractor; +public: + typedef ScriptExecutable Base; + static const unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal; + + static void destroy(JSCell*); + + EvalCodeBlock* codeBlock() + { + return m_evalCodeBlock.get(); + } + + static EvalExecutable* create(ExecState*, const SourceCode&, bool isInStrictContext, ThisTDZMode); + + PassRefPtr generatedJITCode() + { + return generatedJITCodeForCall(); + } + + static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto) + { + return Structure::create(vm, globalObject, proto, TypeInfo(EvalExecutableType, StructureFlags), info()); + } - static Structure* createStructure(JSGlobalData& globalData, JSValue proto) - { - return Structure::create(globalData, proto, TypeInfo(CompoundType, StructureFlags), AnonymousSlotCount, &s_info); - } - - static const ClassInfo s_info; + DECLARE_INFO; - private: - static const unsigned StructureFlags = OverridesVisitChildren | ScriptExecutable::StructureFlags; - ProgramExecutable(ExecState*, const SourceCode&); + void unlinkCalls(); - JSObject* compileInternal(ExecState*, ScopeChainNode*); - virtual void visitChildren(SlotVisitor&); - void unlinkCalls(); + void clearCode(); - OwnPtr m_programCodeBlock; - }; + ExecutableInfo executableInfo() const { return ExecutableInfo(needsActivation(), usesEval(), isStrictMode(), false, false, ConstructorKind::None); } - class FunctionExecutable : public ScriptExecutable { - friend class JIT; - public: - static FunctionExecutable* create(ExecState* exec, const Identifier& name, const SourceCode& source, bool forceUsesArguments, FunctionParameters* parameters, bool isInStrictContext, int firstLine, int lastLine) - { - return new (exec) FunctionExecutable(exec, name, source, forceUsesArguments, parameters, isInStrictContext, firstLine, lastLine); - } + unsigned numVariables() { return m_unlinkedEvalCodeBlock->numVariables(); } + unsigned numberOfFunctionDecls() { return m_unlinkedEvalCodeBlock->numberOfFunctionDecls(); } - static FunctionExecutable* create(JSGlobalData* globalData, const Identifier& name, const SourceCode& source, bool forceUsesArguments, FunctionParameters* parameters, bool isInStrictContext, int firstLine, int lastLine) - { - return new (globalData) FunctionExecutable(globalData, name, source, forceUsesArguments, parameters, isInStrictContext, firstLine, lastLine); - } +private: + friend class ScriptExecutable; + EvalExecutable(ExecState*, const SourceCode&, bool); - JSFunction* make(ExecState* exec, ScopeChainNode* scopeChain) - { - return new (exec) JSFunction(exec, this, scopeChain); - } - - // Returns either call or construct bytecode. This can be appropriate - // for answering questions that that don't vary between call and construct -- - // for example, argumentsRegister(). - FunctionCodeBlock& generatedBytecode() - { - if (m_codeBlockForCall) - return *m_codeBlockForCall; - ASSERT(m_codeBlockForConstruct); - return *m_codeBlockForConstruct; - } + static void visitChildren(JSCell*, SlotVisitor&); - JSObject* compileForCall(ExecState* exec, ScopeChainNode* scopeChainNode) - { - ASSERT(exec->globalData().dynamicGlobalObject); - JSObject* error = 0; - if (!m_codeBlockForCall) - error = compileForCallInternal(exec, scopeChainNode); - ASSERT(!error == !!m_codeBlockForCall); - return error; - } + RefPtr m_evalCodeBlock; + WriteBarrier m_unlinkedEvalCodeBlock; +}; - bool isGeneratedForCall() const - { - return m_codeBlockForCall; - } +class ProgramExecutable final : public ScriptExecutable { + friend class LLIntOffsetsExtractor; +public: + typedef ScriptExecutable Base; + static const unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal; - FunctionCodeBlock& generatedBytecodeForCall() - { - ASSERT(m_codeBlockForCall); - return *m_codeBlockForCall; - } + static ProgramExecutable* create(ExecState* exec, const SourceCode& source) + { + ProgramExecutable* executable = new (NotNull, allocateCell(*exec->heap())) ProgramExecutable(exec, source); + executable->finishCreation(exec->vm()); + return executable; + } - JSObject* compileForConstruct(ExecState* exec, ScopeChainNode* scopeChainNode) - { - ASSERT(exec->globalData().dynamicGlobalObject); - JSObject* error = 0; - if (!m_codeBlockForConstruct) - error = compileForConstructInternal(exec, scopeChainNode); - ASSERT(!error == !!m_codeBlockForConstruct); - return error; - } - bool isGeneratedForConstruct() const - { - return m_codeBlockForConstruct; - } + JSObject* initializeGlobalProperties(VM&, CallFrame*, JSScope*); - FunctionCodeBlock& generatedBytecodeForConstruct() - { - ASSERT(m_codeBlockForConstruct); - return *m_codeBlockForConstruct; - } + static void destroy(JSCell*); - const Identifier& name() { return m_name; } - size_t parameterCount() const { return m_parameters->size(); } - unsigned capturedVariableCount() const { return m_numCapturedVariables; } - UString paramString() const; - SharedSymbolTable* symbolTable() const { return m_symbolTable; } - - void discardCode(); - void visitChildren(SlotVisitor&); - static FunctionExecutable* fromGlobalCode(const Identifier&, ExecState*, Debugger*, const SourceCode&, JSObject** exception); - static Structure* createStructure(JSGlobalData& globalData, JSValue proto) - { - return Structure::create(globalData, proto, TypeInfo(CompoundType, StructureFlags), AnonymousSlotCount, &s_info); - } + ProgramCodeBlock* codeBlock() + { + return m_programCodeBlock.get(); + } + + JSObject* checkSyntax(ExecState*); + + PassRefPtr generatedJITCode() + { + return generatedJITCodeForCall(); + } + + static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto) + { + return Structure::create(vm, globalObject, proto, TypeInfo(ProgramExecutableType, StructureFlags), info()); + } - static const ClassInfo s_info; + DECLARE_INFO; + + void unlinkCalls(); + + void clearCode(); + + ExecutableInfo executableInfo() const { return ExecutableInfo(needsActivation(), usesEval(), isStrictMode(), false, false, ConstructorKind::None); } + +private: + friend class ScriptExecutable; + + ProgramExecutable(ExecState*, const SourceCode&); + + static void visitChildren(JSCell*, SlotVisitor&); - private: - FunctionExecutable(JSGlobalData*, const Identifier& name, const SourceCode&, bool forceUsesArguments, FunctionParameters*, bool, int firstLine, int lastLine); - FunctionExecutable(ExecState*, const Identifier& name, const SourceCode&, bool forceUsesArguments, FunctionParameters*, bool, int firstLine, int lastLine); + WriteBarrier m_unlinkedProgramCodeBlock; + RefPtr m_programCodeBlock; +}; - JSObject* compileForCallInternal(ExecState*, ScopeChainNode*); - JSObject* compileForConstructInternal(ExecState*, ScopeChainNode*); +class FunctionExecutable final : public ScriptExecutable { + friend class JIT; + friend class LLIntOffsetsExtractor; +public: + typedef ScriptExecutable Base; + static const unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal; + + static FunctionExecutable* create( + VM& vm, const SourceCode& source, UnlinkedFunctionExecutable* unlinkedExecutable, + unsigned firstLine, unsigned lastLine, unsigned startColumn, unsigned endColumn) + { + FunctionExecutable* executable = new (NotNull, allocateCell(vm.heap)) FunctionExecutable(vm, source, unlinkedExecutable, firstLine, lastLine, startColumn, endColumn); + executable->finishCreation(vm); + return executable; + } + static FunctionExecutable* fromGlobalCode( + const Identifier& name, ExecState&, const SourceCode&, + JSObject*& exception, int overrideLineNumber); + + static void destroy(JSCell*); - static const unsigned StructureFlags = OverridesVisitChildren | ScriptExecutable::StructureFlags; - unsigned m_numCapturedVariables : 31; - bool m_forceUsesArguments : 1; - void unlinkCalls(); - - RefPtr m_parameters; - OwnPtr m_codeBlockForCall; - OwnPtr m_codeBlockForConstruct; - Identifier m_name; - SharedSymbolTable* m_symbolTable; - -#if ENABLE(JIT) - public: - MacroAssemblerCodePtr generatedJITCodeForCallWithArityCheck() - { - ASSERT(m_jitCodeForCall); - ASSERT(m_jitCodeForCallWithArityCheck); - return m_jitCodeForCallWithArityCheck; - } + UnlinkedFunctionExecutable* unlinkedExecutable() + { + return m_unlinkedExecutable.get(); + } - MacroAssemblerCodePtr generatedJITCodeForConstructWithArityCheck() - { - ASSERT(m_jitCodeForConstruct); - ASSERT(m_jitCodeForConstructWithArityCheck); - return m_jitCodeForConstructWithArityCheck; - } -#endif - }; + // Returns either call or construct bytecode. This can be appropriate + // for answering questions that that don't vary between call and construct -- + // for example, argumentsRegister(). + FunctionCodeBlock* eitherCodeBlock() + { + if (m_codeBlockForCall) + return m_codeBlockForCall.get(); + return m_codeBlockForConstruct.get(); + } + + bool isGeneratedForCall() const + { + return m_codeBlockForCall; + } + + FunctionCodeBlock* codeBlockForCall() + { + return m_codeBlockForCall.get(); + } - inline FunctionExecutable* JSFunction::jsExecutable() const + bool isGeneratedForConstruct() const { - ASSERT(!isHostFunctionNonInline()); - return static_cast(m_executable.get()); + return m_codeBlockForConstruct; } - inline bool JSFunction::isHostFunction() const + FunctionCodeBlock* codeBlockForConstruct() + { + return m_codeBlockForConstruct.get(); + } + + bool isGeneratedFor(CodeSpecializationKind kind) + { + if (kind == CodeForCall) + return isGeneratedForCall(); + ASSERT(kind == CodeForConstruct); + return isGeneratedForConstruct(); + } + + FunctionCodeBlock* codeBlockFor(CodeSpecializationKind kind) { - ASSERT(m_executable); - return m_executable->isHostFunction(); + if (kind == CodeForCall) + return codeBlockForCall(); + ASSERT(kind == CodeForConstruct); + return codeBlockForConstruct(); } - inline NativeFunction JSFunction::nativeFunction() + FunctionCodeBlock* baselineCodeBlockFor(CodeSpecializationKind); + + FunctionCodeBlock* profiledCodeBlockFor(CodeSpecializationKind kind) { - ASSERT(isHostFunction()); - return static_cast(m_executable.get())->function(); + return baselineCodeBlockFor(kind); } + + RefPtr returnStatementTypeSet() + { + if (!m_returnStatementTypeSet) + m_returnStatementTypeSet = TypeSet::create(); + + return m_returnStatementTypeSet; + } + + FunctionMode functionMode() { return m_unlinkedExecutable->functionMode(); } + bool isBuiltinFunction() const { return m_unlinkedExecutable->isBuiltinFunction(); } + bool isClassConstructorFunction() const { return m_unlinkedExecutable->isClassConstructorFunction(); } + const Identifier& name() { return m_unlinkedExecutable->name(); } + const Identifier& inferredName() { return m_unlinkedExecutable->inferredName(); } + JSString* nameValue() const { return m_unlinkedExecutable->nameValue(); } + size_t parameterCount() const { return m_unlinkedExecutable->parameterCount(); } // Excluding 'this'! + SymbolTable* symbolTable(CodeSpecializationKind); + + void clearUnlinkedCodeForRecompilation(); + static void visitChildren(JSCell*, SlotVisitor&); + static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto) + { + return Structure::create(vm, globalObject, proto, TypeInfo(FunctionExecutableType, StructureFlags), info()); + } + + unsigned parametersStartOffset() const { return m_parametersStartOffset; } + + void overrideParameterAndTypeProfilingStartEndOffsets(unsigned parametersStartOffset, unsigned typeProfilingStartOffset, unsigned typeProfilingEndOffset) + { + m_parametersStartOffset = parametersStartOffset; + m_typeProfilingStartOffset = typeProfilingStartOffset; + m_typeProfilingEndOffset = typeProfilingEndOffset; + } + + DECLARE_INFO; + + void unlinkCalls(); + + void clearCode(); + + InferredValue* singletonFunction() { return m_singletonFunction.get(); } + +private: + FunctionExecutable( + VM&, const SourceCode&, UnlinkedFunctionExecutable*, unsigned firstLine, + unsigned lastLine, unsigned startColumn, unsigned endColumn); + + void finishCreation(VM&); + + friend class ScriptExecutable; + + WriteBarrier m_unlinkedExecutable; + RefPtr m_codeBlockForCall; + RefPtr m_codeBlockForConstruct; + RefPtr m_returnStatementTypeSet; + unsigned m_parametersStartOffset; + WriteBarrier m_singletonFunction; +}; + +inline void ExecutableBase::clearCodeVirtual(ExecutableBase* executable) +{ + switch (executable->type()) { + case EvalExecutableType: + return jsCast(executable)->clearCode(); + case ProgramExecutableType: + return jsCast(executable)->clearCode(); + case FunctionExecutableType: + return jsCast(executable)->clearCode(); + default: + return jsCast(executable)->clearCode(); + } +} + +inline void ScriptExecutable::unlinkCalls() +{ + switch (type()) { + case EvalExecutableType: + return jsCast(this)->unlinkCalls(); + case ProgramExecutableType: + return jsCast(this)->unlinkCalls(); + case FunctionExecutableType: + return jsCast(this)->unlinkCalls(); + default: + RELEASE_ASSERT_NOT_REACHED(); + } +} + } #endif