/*
* Copyright (C) 2009 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 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.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef Executable_h
#define Executable_h
#include "JSFunction.h"
#include "Interpreter.h"
#include "Nodes.h"
#include "SamplingTool.h"
namespace JSC {
class CodeBlock;
class Debugger;
class EvalCodeBlock;
class ProgramCodeBlock;
class ScopeChainNode;
struct ExceptionInfo;
class ExecutableBase : public RefCounted<ExecutableBase> {
friend class JIT;
protected:
static const int NUM_PARAMETERS_IS_HOST = 0;
static const int NUM_PARAMETERS_NOT_COMPILED = -1;
public:
ExecutableBase(int numParameters)
: m_numParameters(numParameters)
{
}
virtual ~ExecutableBase() {}
bool isHostFunction() const { return m_numParameters == NUM_PARAMETERS_IS_HOST; }
protected:
int m_numParameters;
#if ENABLE(JIT)
public:
JITCode& generatedJITCode()
{
ASSERT(m_jitCode);
return m_jitCode;
}
ExecutablePool* getExecutablePool()
{
return m_jitCode.getExecutablePool();
}
protected:
JITCode m_jitCode;
#endif
};
#if ENABLE(JIT)
class NativeExecutable : public ExecutableBase {
public:
NativeExecutable(ExecState* exec)
: ExecutableBase(NUM_PARAMETERS_IS_HOST)
{
m_jitCode = JITCode(JITCode::HostFunction(exec->globalData().jitStubs.ctiNativeCallThunk()));
}
~NativeExecutable();
};
#endif
class VPtrHackExecutable : public ExecutableBase {
public:
VPtrHackExecutable()
: ExecutableBase(NUM_PARAMETERS_IS_HOST)
{
}
~VPtrHackExecutable();
};
class ScriptExecutable : public ExecutableBase {
public:
ScriptExecutable(JSGlobalData* globalData, const SourceCode& source)
: ExecutableBase(NUM_PARAMETERS_NOT_COMPILED)
, m_source(source)
, m_features(0)
{
#if ENABLE(CODEBLOCK_SAMPLING)
if (SamplingTool* sampler = globalData->interpreter->sampler())
sampler->notifyOfScope(this);
#else
UNUSED_PARAM(globalData);
#endif
}
ScriptExecutable(ExecState* exec, const SourceCode& source)
: ExecutableBase(NUM_PARAMETERS_NOT_COMPILED)
, m_source(source)
, m_features(0)
{
#if ENABLE(CODEBLOCK_SAMPLING)
if (SamplingTool* sampler = exec->globalData().interpreter->sampler())
sampler->notifyOfScope(this);
#else
UNUSED_PARAM(exec);
#endif
}
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; }
bool usesEval() const { return m_features & EvalFeature; }
bool usesArguments() const { return m_features & ArgumentsFeature; }
bool needsActivation() const { return m_features & (EvalFeature | ClosureFeature | WithFeature | CatchFeature); }
virtual ExceptionInfo* reparseExceptionInfo(JSGlobalData*, ScopeChainNode*, CodeBlock*) = 0;
protected:
void recordParse(CodeFeatures features, int firstLine, int lastLine)
{
m_features = features;
m_firstLine = firstLine;
m_lastLine = lastLine;
}
SourceCode m_source;
CodeFeatures m_features;
int m_firstLine;
int m_lastLine;
};
class EvalExecutable : public ScriptExecutable {
public:
~EvalExecutable();
EvalCodeBlock& bytecode(ExecState* exec, ScopeChainNode* scopeChainNode)
{
if (!m_evalCodeBlock) {
JSObject* error = compile(exec, scopeChainNode);
ASSERT_UNUSED(!error, error);
}
return *m_evalCodeBlock;
}
JSObject* compile(ExecState*, ScopeChainNode*);
ExceptionInfo* reparseExceptionInfo(JSGlobalData*, ScopeChainNode*, CodeBlock*);
static PassRefPtr<EvalExecutable> create(ExecState* exec, const SourceCode& source) { return adoptRef(new EvalExecutable(exec, source)); }
private:
EvalExecutable(ExecState* exec, const SourceCode& source)
: ScriptExecutable(exec, source)
, m_evalCodeBlock(0)
{
}
EvalCodeBlock* m_evalCodeBlock;
#if ENABLE(JIT)
public:
JITCode& jitCode(ExecState* exec, ScopeChainNode* scopeChainNode)
{
if (!m_jitCode)
generateJITCode(exec, scopeChainNode);
return m_jitCode;
}
private:
void generateJITCode(ExecState*, ScopeChainNode*);
#endif
};
class ProgramExecutable : public ScriptExecutable {
public:
static PassRefPtr<ProgramExecutable> create(ExecState* exec, const SourceCode& source)
{
return adoptRef(new ProgramExecutable(exec, source));
}
~ProgramExecutable();
ProgramCodeBlock& bytecode(ExecState* exec, ScopeChainNode* scopeChainNode)
{
if (!m_programCodeBlock) {
JSObject* error = compile(exec, scopeChainNode);
ASSERT_UNUSED(!error, error);
}
return *m_programCodeBlock;
}
JSObject* checkSyntax(ExecState*);
JSObject* compile(ExecState*, ScopeChainNode*);
// CodeBlocks for program code are transient and therefore do not gain from from throwing out there exception information.
ExceptionInfo* reparseExceptionInfo(JSGlobalData*, ScopeChainNode*, CodeBlock*) { ASSERT_NOT_REACHED(); return 0; }
private:
ProgramExecutable(ExecState* exec, const SourceCode& source)
: ScriptExecutable(exec, source)
, m_programCodeBlock(0)
{
}
ProgramCodeBlock* m_programCodeBlock;
#if ENABLE(JIT)
public:
JITCode& jitCode(ExecState* exec, ScopeChainNode* scopeChainNode)
{
if (!m_jitCode)
generateJITCode(exec, scopeChainNode);
return m_jitCode;
}
private:
void generateJITCode(ExecState*, ScopeChainNode*);
#endif
};
class FunctionExecutable : public ScriptExecutable {
friend class JIT;
public:
static PassRefPtr<FunctionExecutable> create(ExecState* exec, const Identifier& name, const SourceCode& source, bool forceUsesArguments, FunctionParameters* parameters, int firstLine, int lastLine)
{
return adoptRef(new FunctionExecutable(exec, name, source, forceUsesArguments, parameters, firstLine, lastLine));
}
static PassRefPtr<FunctionExecutable> create(JSGlobalData* globalData, const Identifier& name, const SourceCode& source, bool forceUsesArguments, FunctionParameters* parameters, int firstLine, int lastLine)
{
return adoptRef(new FunctionExecutable(globalData, name, source, forceUsesArguments, parameters, firstLine, lastLine));
}
~FunctionExecutable();
JSFunction* make(ExecState* exec, ScopeChainNode* scopeChain)
{
return new (exec) JSFunction(exec, this, scopeChain);
}
CodeBlock& bytecode(ExecState* exec, ScopeChainNode* scopeChainNode)
{
ASSERT(scopeChainNode);
if (!m_codeBlock)
compile(exec, scopeChainNode);
return *m_codeBlock;
}
bool isGenerated() const
{
return m_codeBlock;
}
CodeBlock& generatedBytecode()
{
ASSERT(m_codeBlock);
return *m_codeBlock;
}
const Identifier& name() { return m_name; }
size_t parameterCount() const { return m_parameters->size(); }
size_t variableCount() const { return m_numVariables; }
UString paramString() const;
void recompile(ExecState*);
ExceptionInfo* reparseExceptionInfo(JSGlobalData*, ScopeChainNode*, CodeBlock*);
void markAggregate(MarkStack& markStack);
static PassRefPtr<FunctionExecutable> fromGlobalCode(const Identifier&, ExecState*, Debugger*, const SourceCode&, int* errLine = 0, UString* errMsg = 0);
private:
FunctionExecutable(JSGlobalData* globalData, const Identifier& name, const SourceCode& source, bool forceUsesArguments, FunctionParameters* parameters, int firstLine, int lastLine)
: ScriptExecutable(globalData, source)
, m_forceUsesArguments(forceUsesArguments)
, m_parameters(parameters)
, m_codeBlock(0)
, m_name(name)
, m_numVariables(0)
{
m_firstLine = firstLine;
m_lastLine = lastLine;
}
FunctionExecutable(ExecState* exec, const Identifier& name, const SourceCode& source, bool forceUsesArguments, FunctionParameters* parameters, int firstLine, int lastLine)
: ScriptExecutable(exec, source)
, m_forceUsesArguments(forceUsesArguments)
, m_parameters(parameters)
, m_codeBlock(0)
, m_name(name)
, m_numVariables(0)
{
m_firstLine = firstLine;
m_lastLine = lastLine;
}
void compile(ExecState*, ScopeChainNode*);
bool m_forceUsesArguments;
RefPtr<FunctionParameters> m_parameters;
CodeBlock* m_codeBlock;
Identifier m_name;
size_t m_numVariables;
#if ENABLE(JIT)
public:
JITCode& jitCode(ExecState* exec, ScopeChainNode* scopeChainNode)
{
if (!m_jitCode)
generateJITCode(exec, scopeChainNode);
return m_jitCode;
}
private:
void generateJITCode(ExecState*, ScopeChainNode*);
#endif
};
inline FunctionExecutable* JSFunction::jsExecutable() const
{
ASSERT(!isHostFunctionNonInline());
return static_cast<FunctionExecutable*>(m_executable.get());
}
inline bool JSFunction::isHostFunction() const
{
ASSERT(m_executable);
return m_executable->isHostFunction();
}
}
#endif