#include "config.h"

#include "Executable.h"

#include "BatchedTransitionOptimizer.h"

#include "BytecodeGenerator.h"

#include "CodeBlock.h"

#include "DFGDriver.h"

#include "JIT.h"

#include "LLIntEntrypoint.h"

#include "JSCInlines.h"

#include "Parser.h"

#include "ProfilerDatabase.h"

#include <wtf/CommaPrinter.h>

#include <wtf/Vector.h>

#include <wtf/text/StringBuilder.h>

namespace JSC {

const ClassInfo ExecutableBase::s_info = { "Executable", 0, 0, 0, CREATE_METHOD_TABLE(ExecutableBase) };

#if ENABLE(JIT)

void ExecutableBase::destroy(JSCell* cell)

{

static_cast<ExecutableBase*>(cell)->ExecutableBase::~ExecutableBase();

}

#endif

void ExecutableBase::clearCode()

}

#if ENABLE(DFG_JIT)

Intrinsic ExecutableBase::intrinsic() const

}

#else

Intrinsic ExecutableBase::intrinsic() const

{

return NoIntrinsic;

}

#endif

const ClassInfo NativeExecutable::s_info = { "NativeExecutable", &ExecutableBase::s_info, 0, 0, CREATE_METHOD_TABLE(NativeExecutable) };

#if ENABLE(JIT)

void NativeExecutable::destroy(JSCell* cell)

{

static_cast<NativeExecutable*>(cell)->NativeExecutable::~NativeExecutable();

}

#endif

#if ENABLE(DFG_JIT)

Intrinsic NativeExecutable::intrinsic() const

{

return m_intrinsic;

}

#endif

const ClassInfo ScriptExecutable::s_info = { "ScriptExecutable", &ExecutableBase::s_info, 0, 0, CREATE_METHOD_TABLE(ScriptExecutable) };

#if ENABLE(JIT)

void ScriptExecutable::destroy(JSCell* cell)

{

static_cast<ScriptExecutable*>(cell)->ScriptExecutable::~ScriptExecutable();

}

#endif

void ScriptExecutable::installCode(CodeBlock* genericCodeBlock)

}

PassRefPtr<CodeBlock> ScriptExecutable::newCodeBlockFor(

}

PassRefPtr<CodeBlock> ScriptExecutable::newReplacementCodeBlockFor(

}

static void setupLLInt(VM& vm, CodeBlock* codeBlock)

{

LLInt::setEntrypoint(vm, codeBlock);

}

static void setupJIT(VM& vm, CodeBlock* codeBlock)

}

JSObject* ScriptExecutable::prepareForExecutionImpl(

ExecState* exec, JSFunction* function, JSScope** scope, CodeSpecializationKind kind)

{

VM& vm = exec->vm();

DeferGC deferGC(vm.heap);

JSObject* exception = 0;

RefPtr<CodeBlock> codeBlock = newCodeBlockFor(kind, function, scope, exception);

if (!codeBlock) {

RELEASE_ASSERT(exception);

return exception;

}

if (Options::validateBytecode())

codeBlock->validate();

if (Options::useLLInt())

setupLLInt(vm, codeBlock.get());

else

setupJIT(vm, codeBlock.get());

installCode(codeBlock.get());

return 0;

}

const ClassInfo EvalExecutable::s_info = { "EvalExecutable", &ScriptExecutable::s_info, 0, 0, CREATE_METHOD_TABLE(EvalExecutable) };

EvalExecutable* EvalExecutable::create(ExecState* exec, const SourceCode& source, bool isInStrictContext)

{

JSGlobalObject* globalObject = exec->lexicalGlobalObject();

if (!globalObject->evalEnabled()) {

exec->vm().throwException(exec, createEvalError(exec, globalObject->evalDisabledErrorMessage()));

return 0;

}

EvalExecutable* executable = new (NotNull, allocateCell<EvalExecutable>(*exec->heap())) EvalExecutable(exec, source, isInStrictContext);

executable->finishCreation(exec->vm());

UnlinkedEvalCodeBlock* unlinkedEvalCode = globalObject->createEvalCodeBlock(exec, executable);

if (!unlinkedEvalCode)

return 0;

executable->m_unlinkedEvalCodeBlock.set(exec->vm(), executable, unlinkedEvalCode);

return executable;

}

EvalExecutable::EvalExecutable(ExecState* exec, const SourceCode& source, bool inStrictContext)

: ScriptExecutable(exec->vm().evalExecutableStructure.get(), exec, source, inStrictContext)

{

}

void EvalExecutable::destroy(JSCell* cell)

{

static_cast<EvalExecutable*>(cell)->EvalExecutable::~EvalExecutable();

}

const ClassInfo ProgramExecutable::s_info = { "ProgramExecutable", &ScriptExecutable::s_info, 0, 0, CREATE_METHOD_TABLE(ProgramExecutable) };

ProgramExecutable::ProgramExecutable(ExecState* exec, const SourceCode& source)

: ScriptExecutable(exec->vm().programExecutableStructure.get(), exec, source, false)

{

}

void ProgramExecutable::destroy(JSCell* cell)

{

static_cast<ProgramExecutable*>(cell)->ProgramExecutable::~ProgramExecutable();

}

const ClassInfo FunctionExecutable::s_info = { "FunctionExecutable", &ScriptExecutable::s_info, 0, 0, CREATE_METHOD_TABLE(FunctionExecutable) };

FunctionExecutable::FunctionExecutable(VM& vm, const SourceCode& source, UnlinkedFunctionExecutable* unlinkedExecutable, unsigned firstLine, unsigned lastLine, unsigned startColumn, unsigned endColumn, bool bodyIncludesBraces)

}

void FunctionExecutable::destroy(JSCell* cell)

{

static_cast<FunctionExecutable*>(cell)->FunctionExecutable::~FunctionExecutable();

}

inline const char* samplingDescription(JITCode::JITType jitType)

{

switch (jitType) {

case JITCode::InterpreterThunk:

return "Interpreter Compilation (TOTAL)";

case JITCode::BaselineJIT:

return "Baseline Compilation (TOTAL)";

case JITCode::DFGJIT:

return "DFG Compilation (TOTAL)";

case JITCode::FTLJIT:

return "FTL Compilation (TOTAL)";

default:

RELEASE_ASSERT_NOT_REACHED();

return 0;

}

}

void EvalExecutable::visitChildren(JSCell* cell, SlotVisitor& visitor)

}

void EvalExecutable::unlinkCalls()

}

void EvalExecutable::clearCode()

}

JSObject* ProgramExecutable::checkSyntax(ExecState* exec)

{

ParserError error;

VM* vm = &exec->vm();

JSGlobalObject* lexicalGlobalObject = exec->lexicalGlobalObject();

RefPtr<ProgramNode> programNode = parse<ProgramNode>(vm, m_source, 0, Identifier(), JSParseNormal, ProgramNode::isFunctionNode ? JSParseFunctionCode : JSParseProgramCode, error);

if (programNode)

return 0;

ASSERT(error.m_type != ParserError::ErrorNone);

return error.toErrorObject(lexicalGlobalObject, m_source);

}

void ProgramExecutable::unlinkCalls()

}

JSObject* ProgramExecutable::initializeGlobalProperties(VM& vm, CallFrame* callFrame, JSScope* scope)

{

RELEASE_ASSERT(scope);

JSGlobalObject* globalObject = scope->globalObject();

RELEASE_ASSERT(globalObject);

ASSERT(&globalObject->vm() == &vm);

JSObject* exception = 0;

UnlinkedProgramCodeBlock* unlinkedCodeBlock = globalObject->createProgramCodeBlock(callFrame, this, &exception);

if (exception)

return exception;

m_unlinkedProgramCodeBlock.set(vm, this, unlinkedCodeBlock);

BatchedTransitionOptimizer optimizer(vm, globalObject);

const UnlinkedProgramCodeBlock::VariableDeclations& variableDeclarations = unlinkedCodeBlock->variableDeclarations();

const UnlinkedProgramCodeBlock::FunctionDeclations& functionDeclarations = unlinkedCodeBlock->functionDeclarations();

for (size_t i = 0; i < functionDeclarations.size(); ++i) {

UnlinkedFunctionExecutable* unlinkedFunctionExecutable = functionDeclarations[i].second.get();

JSValue value = JSFunction::create(vm, unlinkedFunctionExecutable->link(vm, m_source, lineNo()), scope);

globalObject->addFunction(callFrame, functionDeclarations[i].first, value);

}

for (size_t i = 0; i < variableDeclarations.size(); ++i) {

if (variableDeclarations[i].second & DeclarationStacks::IsConstant)

globalObject->addConst(callFrame, variableDeclarations[i].first);

else

globalObject->addVar(callFrame, variableDeclarations[i].first);

}

return 0;

}

void ProgramExecutable::visitChildren(JSCell* cell, SlotVisitor& visitor)

}

void ProgramExecutable::clearCode()

}

FunctionCodeBlock* FunctionExecutable::baselineCodeBlockFor(CodeSpecializationKind kind)

{

FunctionCodeBlock* result;

if (kind == CodeForCall)

result = m_codeBlockForCall.get();

else {

RELEASE_ASSERT(kind == CodeForConstruct);

result = m_codeBlockForConstruct.get();

}

if (!result)

return 0;

return static_cast<FunctionCodeBlock*>(result->baselineAlternative());

}

void FunctionExecutable::visitChildren(JSCell* cell, SlotVisitor& visitor)

}

SymbolTable* FunctionExecutable::symbolTable(CodeSpecializationKind kind)

{

return codeBlockFor(kind)->symbolTable();

}

void FunctionExecutable::clearCodeIfNotCompiling()

}

void FunctionExecutable::clearUnlinkedCodeForRecompilationIfNotCompiling()

}

void FunctionExecutable::clearCode()

}

void FunctionExecutable::unlinkCalls()

}

FunctionExecutable* FunctionExecutable::fromGlobalCode(const Identifier& name, ExecState* exec, Debugger* debugger, const SourceCode& source, JSObject** exception)

{

UnlinkedFunctionExecutable* unlinkedExecutable = UnlinkedFunctionExecutable::fromGlobalCode(name, exec, debugger, source, exception);

if (!unlinkedExecutable)

return 0;

unsigned lineCount = unlinkedExecutable->lineCount();

unsigned firstLine = source.firstLine() + unlinkedExecutable->firstLineOffset();

unsigned startOffset = source.startOffset() + unlinkedExecutable->startOffset();

// We don't have any owner executable. The source string is effectively like a global

// string (like in the handling of eval). Hence, the startColumn is always 1.

unsigned startColumn = 1;

unsigned sourceLength = unlinkedExecutable->sourceLength();

bool endColumnIsOnStartLine = !lineCount;

// The unlinkedBodyEndColumn is based-0. Hence, we need to add 1 to it. But if the

// endColumn is on the startLine, then we need to subtract back the adjustment for

// the open brace resulting in an adjustment of 0.

unsigned endColumnExcludingBraces = unlinkedExecutable->unlinkedBodyEndColumn() + (endColumnIsOnStartLine ? 0 : 1);

unsigned startOffsetExcludingOpenBrace = startOffset + 1;

unsigned endOffsetExcludingCloseBrace = startOffset + sourceLength - 1;

SourceCode bodySource(source.provider(), startOffsetExcludingOpenBrace, endOffsetExcludingCloseBrace, firstLine, startColumn);

return FunctionExecutable::create(exec->vm(), bodySource, unlinkedExecutable, firstLine, firstLine + lineCount, startColumn, endColumnExcludingBraces, false);

}

String FunctionExecutable::paramString() const

{

return m_unlinkedExecutable->paramString();

}

void ExecutableBase::dump(PrintStream& out) const

}

CodeBlockHash ExecutableBase::hashFor(CodeSpecializationKind kind) const

}

CodeBlockHash NativeExecutable::hashFor(CodeSpecializationKind kind) const

}

CodeBlockHash ScriptExecutable::hashFor(CodeSpecializationKind kind) const

{

return CodeBlockHash(source(), kind);

}

}