/*

* Copyright (C) 2008, 2009, 2010, 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

* 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.

* 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.

*

* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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.

*/

#include "config.h"

#include "CodeBlock.h"

#include "BytecodeGenerator.h"

#include "BytecodeUseDef.h"

#include "CallLinkStatus.h"

#include "DFGCapabilities.h"

#include "DFGCommon.h"

#include "DFGDriver.h"

#include "DFGJITCode.h"

#include "DFGWorklist.h"

#include "Debugger.h"

#include "Interpreter.h"

#include "JIT.h"

#include "JITStubs.h"

#include "JSActivation.h"

#include "JSCJSValue.h"

#include "JSFunction.h"

#include "JSNameScope.h"

#include "LLIntEntrypoint.h"

#include "LowLevelInterpreter.h"

#include "JSCInlines.h"

#include "PolymorphicGetByIdList.h"

#include "PolymorphicPutByIdList.h"

#include "ProfilerDatabase.h"

#include "ReduceWhitespace.h"

#include "Repatch.h"

#include "RepatchBuffer.h"

#include "SlotVisitorInlines.h"

#include "UnlinkedInstructionStream.h"

#include <wtf/BagToHashMap.h>

#include <wtf/CommaPrinter.h>

#include <wtf/StringExtras.h>

#include <wtf/StringPrintStream.h>

#if ENABLE(DFG_JIT)

#include "DFGOperations.h"

#endif

#if ENABLE(FTL_JIT)

#include "FTLJITCode.h"

#endif

namespace JSC {

CString CodeBlock::inferredName() const

{

switch (codeType()) {

case GlobalCode:

return "<global>";

case EvalCode:

return "<eval>";

case FunctionCode:

return jsCast<FunctionExecutable*>(ownerExecutable())->inferredName().utf8();

default:

CRASH();

return CString("", 0);

}

}

bool CodeBlock::hasHash() const

{

return !!m_hash;

}

bool CodeBlock::isSafeToComputeHash() const

{

return !isCompilationThread();

}

CodeBlockHash CodeBlock::hash() const

{

if (!m_hash) {

RELEASE_ASSERT(isSafeToComputeHash());

m_hash = CodeBlockHash(ownerExecutable()->source(), specializationKind());

}

return m_hash;

}

CString CodeBlock::sourceCodeForTools() const

{

if (codeType() != FunctionCode)

return ownerExecutable()->source().toUTF8();

SourceProvider* provider = source();

FunctionExecutable* executable = jsCast<FunctionExecutable*>(ownerExecutable());

UnlinkedFunctionExecutable* unlinked = executable->unlinkedExecutable();

unsigned unlinkedStartOffset = unlinked->startOffset();

unsigned linkedStartOffset = executable->source().startOffset();

int delta = linkedStartOffset - unlinkedStartOffset;

unsigned rangeStart = delta + unlinked->unlinkedFunctionNameStart();

unsigned rangeEnd = delta + unlinked->startOffset() + unlinked->sourceLength();

return toCString(

"function ",

provider->source().impl()->utf8ForRange(rangeStart, rangeEnd - rangeStart));

}

CString CodeBlock::sourceCodeOnOneLine() const

{

return reduceWhitespace(sourceCodeForTools());

}

CString CodeBlock::hashAsStringIfPossible() const

{

if (hasHash() || isSafeToComputeHash())

return toCString(hash());

return "<no-hash>";

}

void CodeBlock::dumpAssumingJITType(PrintStream& out, JITCode::JITType jitType) const

{

out.print(inferredName(), "#", hashAsStringIfPossible());

out.print(":[", RawPointer(this), "->");

if (!!m_alternative)

out.print(RawPointer(m_alternative.get()), "->");

out.print(RawPointer(ownerExecutable()), ", ", jitType, codeType());

if (codeType() == FunctionCode)

out.print(specializationKind());

out.print(", ", instructionCount());

if (this->jitType() == JITCode::BaselineJIT && m_shouldAlwaysBeInlined)

out.print(" (SABI)");

if (ownerExecutable()->neverInline())

out.print(" (NeverInline)");

if (ownerExecutable()->isStrictMode())

out.print(" (StrictMode)");

if (this->jitType() == JITCode::BaselineJIT && m_didFailFTLCompilation)

out.print(" (FTLFail)");

if (this->jitType() == JITCode::BaselineJIT && m_hasBeenCompiledWithFTL)

out.print(" (HadFTLReplacement)");

out.print("]");

}

void CodeBlock::dump(PrintStream& out) const

{

dumpAssumingJITType(out, jitType());

}

static CString constantName(int k, JSValue value)

{

return toCString(value, "(@k", k - FirstConstantRegisterIndex, ")");

}

static CString idName(int id0, const Identifier& ident)

{

return toCString(ident.impl(), "(@id", id0, ")");

}

CString CodeBlock::registerName(int r) const

{

if (r == missingThisObjectMarker())

return "<null>";

if (isConstantRegisterIndex(r))

return constantName(r, getConstant(r));

if (operandIsArgument(r)) {

if (!VirtualRegister(r).toArgument())

return "this";

return toCString("arg", VirtualRegister(r).toArgument());

}

return toCString("loc", VirtualRegister(r).toLocal());

}

static CString regexpToSourceString(RegExp* regExp)

{

char postfix[5] = { '/', 0, 0, 0, 0 };

int index = 1;

if (regExp->global())

postfix[index++] = 'g';

if (regExp->ignoreCase())

postfix[index++] = 'i';

if (regExp->multiline())

postfix[index] = 'm';

return toCString("/", regExp->pattern().impl(), postfix);

}

static CString regexpName(int re, RegExp* regexp)

{

return toCString(regexpToSourceString(regexp), "(@re", re, ")");

}

NEVER_INLINE static const char* debugHookName(int debugHookID)

{

switch (static_cast<DebugHookID>(debugHookID)) {

case DidEnterCallFrame:

return "didEnterCallFrame";

case WillLeaveCallFrame:

return "willLeaveCallFrame";

case WillExecuteStatement:

return "willExecuteStatement";

case WillExecuteProgram:

return "willExecuteProgram";

case DidExecuteProgram:

return "didExecuteProgram";

case DidReachBreakpoint:

return "didReachBreakpoint";

}

RELEASE_ASSERT_NOT_REACHED();

return "";

}

void CodeBlock::printUnaryOp(PrintStream& out, ExecState* exec, int location, const Instruction*& it, const char* op)

{

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, op);

out.printf("%s, %s", registerName(r0).data(), registerName(r1).data());

}

void CodeBlock::printBinaryOp(PrintStream& out, ExecState* exec, int location, const Instruction*& it, const char* op)

{

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

int r2 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, op);

out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data());

}

void CodeBlock::printConditionalJump(PrintStream& out, ExecState* exec, const Instruction*, const Instruction*& it, int location, const char* op)

{

int r0 = (++it)->u.operand;

int offset = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, op);

out.printf("%s, %d(->%d)", registerName(r0).data(), offset, location + offset);

}

void CodeBlock::printGetByIdOp(PrintStream& out, ExecState* exec, int location, const Instruction*& it)

{

const char* op;

switch (exec->interpreter()->getOpcodeID(it->u.opcode)) {

case op_get_by_id:

op = "get_by_id";

break;

case op_get_by_id_out_of_line:

op = "get_by_id_out_of_line";

break;

case op_get_array_length:

op = "array_length";

break;

default:

RELEASE_ASSERT_NOT_REACHED();

op = 0;

}

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

int id0 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, op);

out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), idName(id0, identifier(id0)).data());

it += 4; // Increment up to the value profiler.

}

static void dumpStructure(PrintStream& out, const char* name, ExecState* exec, Structure* structure, const Identifier& ident)

{

if (!structure)

return;

out.printf("%s = %p", name, structure);

PropertyOffset offset = structure->getConcurrently(exec->vm(), ident.impl());

if (offset != invalidOffset)

out.printf(" (offset = %d)", offset);

}

#if ENABLE(JIT) // unused when not ENABLE(JIT), leading to silly warnings

static void dumpChain(PrintStream& out, ExecState* exec, StructureChain* chain, const Identifier& ident)

{

out.printf("chain = %p: [", chain);

bool first = true;

for (WriteBarrier<Structure>* currentStructure = chain->head();

*currentStructure;

++currentStructure) {

if (first)

first = false;

else

out.printf(", ");

dumpStructure(out, "struct", exec, currentStructure->get(), ident);

}

out.printf("]");

}

#endif

void CodeBlock::printGetByIdCacheStatus(PrintStream& out, ExecState* exec, int location, const StubInfoMap& map)

{

Instruction* instruction = instructions().begin() + location;

const Identifier& ident = identifier(instruction[3].u.operand);

UNUSED_PARAM(ident); // tell the compiler to shut up in certain platform configurations.

if (exec->interpreter()->getOpcodeID(instruction[0].u.opcode) == op_get_array_length)

out.printf(" llint(array_length)");

else if (Structure* structure = instruction[4].u.structure.get()) {

out.printf(" llint(");

dumpStructure(out, "struct", exec, structure, ident);

out.printf(")");

}

#if ENABLE(JIT)

if (StructureStubInfo* stubPtr = map.get(CodeOrigin(location))) {

StructureStubInfo& stubInfo = *stubPtr;

if (stubInfo.resetByGC)

out.print(" (Reset By GC)");

if (stubInfo.seen) {

out.printf(" jit(");

Structure* baseStructure = 0;

Structure* prototypeStructure = 0;

StructureChain* chain = 0;

PolymorphicGetByIdList* list = 0;

switch (stubInfo.accessType) {

case access_get_by_id_self:

out.printf("self");

baseStructure = stubInfo.u.getByIdSelf.baseObjectStructure.get();

break;

case access_get_by_id_chain:

out.printf("chain");

baseStructure = stubInfo.u.getByIdChain.baseObjectStructure.get();

chain = stubInfo.u.getByIdChain.chain.get();

break;

case access_get_by_id_list:

out.printf("list");

list = stubInfo.u.getByIdList.list;

break;

case access_unset:

out.printf("unset");

break;

default:

RELEASE_ASSERT_NOT_REACHED();

break;

}

if (baseStructure) {

out.printf(", ");

dumpStructure(out, "struct", exec, baseStructure, ident);

}

if (prototypeStructure) {

out.printf(", ");

dumpStructure(out, "prototypeStruct", exec, baseStructure, ident);

}

if (chain) {

out.printf(", ");

dumpChain(out, exec, chain, ident);

}

if (list) {

out.printf(", list = %p: [", list);

for (unsigned i = 0; i < list->size(); ++i) {

if (i)

out.printf(", ");

out.printf("(");

dumpStructure(out, "base", exec, list->at(i).structure(), ident);

if (list->at(i).chain()) {

out.printf(", ");

dumpChain(out, exec, list->at(i).chain(), ident);

}

out.printf(")");

}

out.printf("]");

}

out.printf(")");

}

}

#else

UNUSED_PARAM(map);

#endif

}

void CodeBlock::printCallOp(PrintStream& out, ExecState* exec, int location, const Instruction*& it, const char* op, CacheDumpMode cacheDumpMode, bool& hasPrintedProfiling, const CallLinkInfoMap& map)

{

int dst = (++it)->u.operand;

int func = (++it)->u.operand;

int argCount = (++it)->u.operand;

int registerOffset = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, op);

out.printf("%s, %s, %d, %d", registerName(dst).data(), registerName(func).data(), argCount, registerOffset);

if (cacheDumpMode == DumpCaches) {

LLIntCallLinkInfo* callLinkInfo = it[1].u.callLinkInfo;

if (callLinkInfo->lastSeenCallee) {

out.printf(

" llint(%p, exec %p)",

callLinkInfo->lastSeenCallee.get(),

callLinkInfo->lastSeenCallee->executable());

}

#if ENABLE(JIT)

if (CallLinkInfo* info = map.get(CodeOrigin(location))) {

JSFunction* target = info->lastSeenCallee.get();

if (target)

out.printf(" jit(%p, exec %p)", target, target->executable());

}

out.print(" status(", CallLinkStatus::computeFor(this, location, map), ")");

#else

UNUSED_PARAM(map);

#endif

}

++it;

++it;

dumpArrayProfiling(out, it, hasPrintedProfiling);

dumpValueProfiling(out, it, hasPrintedProfiling);

}

void CodeBlock::printPutByIdOp(PrintStream& out, ExecState* exec, int location, const Instruction*& it, const char* op)

{

int r0 = (++it)->u.operand;

int id0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, op);

out.printf("%s, %s, %s", registerName(r0).data(), idName(id0, identifier(id0)).data(), registerName(r1).data());

it += 5;

}

void CodeBlock::dumpBytecode(PrintStream& out)

{

// We only use the ExecState* for things that don't actually lead to JS execution,

// like converting a JSString to a String. Hence the globalExec is appropriate.

ExecState* exec = m_globalObject->globalExec();

size_t instructionCount = 0;

for (size_t i = 0; i < instructions().size(); i += opcodeLengths[exec->interpreter()->getOpcodeID(instructions()[i].u.opcode)])

++instructionCount;

out.print(*this);

out.printf(

": %lu m_instructions; %lu bytes; %d parameter(s); %d callee register(s); %d variable(s)",

static_cast<unsigned long>(instructions().size()),

static_cast<unsigned long>(instructions().size() * sizeof(Instruction)),

m_numParameters, m_numCalleeRegisters, m_numVars);

if (symbolTable() && symbolTable()->captureCount()) {

out.printf(

"; %d captured var(s) (from r%d to r%d, inclusive)",

symbolTable()->captureCount(), symbolTable()->captureStart(), symbolTable()->captureEnd() + 1);

}

if (usesArguments()) {

out.printf(

"; uses arguments, in r%d, r%d",

argumentsRegister().offset(),

unmodifiedArgumentsRegister(argumentsRegister()).offset());

}

if (needsActivation() && codeType() == FunctionCode)

out.printf("; activation in r%d", activationRegister().offset());

out.printf("\n");

StubInfoMap stubInfos;

CallLinkInfoMap callLinkInfos;

getStubInfoMap(stubInfos);

getCallLinkInfoMap(callLinkInfos);

const Instruction* begin = instructions().begin();

const Instruction* end = instructions().end();

for (const Instruction* it = begin; it != end; ++it)

dumpBytecode(out, exec, begin, it, stubInfos, callLinkInfos);

if (numberOfIdentifiers()) {

out.printf("\nIdentifiers:\n");

size_t i = 0;

do {

out.printf(" id%u = %s\n", static_cast<unsigned>(i), identifier(i).string().utf8().data());

++i;

} while (i != numberOfIdentifiers());

}

if (!m_constantRegisters.isEmpty()) {

out.printf("\nConstants:\n");

size_t i = 0;

do {

out.printf(" k%u = %s\n", static_cast<unsigned>(i), toCString(m_constantRegisters[i].get()).data());

++i;

} while (i < m_constantRegisters.size());

}

if (size_t count = m_unlinkedCode->numberOfRegExps()) {

out.printf("\nm_regexps:\n");

size_t i = 0;

do {

out.printf(" re%u = %s\n", static_cast<unsigned>(i), regexpToSourceString(m_unlinkedCode->regexp(i)).data());

++i;

} while (i < count);

}

if (m_rareData && !m_rareData->m_exceptionHandlers.isEmpty()) {

out.printf("\nException Handlers:\n");

unsigned i = 0;

do {

out.printf("\t %d: { start: [%4d] end: [%4d] target: [%4d] depth: [%4d] }\n", i + 1, m_rareData->m_exceptionHandlers[i].start, m_rareData->m_exceptionHandlers[i].end, m_rareData->m_exceptionHandlers[i].target, m_rareData->m_exceptionHandlers[i].scopeDepth);

++i;

} while (i < m_rareData->m_exceptionHandlers.size());

}

if (m_rareData && !m_rareData->m_switchJumpTables.isEmpty()) {

out.printf("Switch Jump Tables:\n");

unsigned i = 0;

do {

out.printf(" %1d = {\n", i);

int entry = 0;

Vector<int32_t>::const_iterator end = m_rareData->m_switchJumpTables[i].branchOffsets.end();

for (Vector<int32_t>::const_iterator iter = m_rareData->m_switchJumpTables[i].branchOffsets.begin(); iter != end; ++iter, ++entry) {

if (!*iter)

continue;

out.printf("\t\t%4d => %04d\n", entry + m_rareData->m_switchJumpTables[i].min, *iter);

}

out.printf(" }\n");

++i;

} while (i < m_rareData->m_switchJumpTables.size());

}

if (m_rareData && !m_rareData->m_stringSwitchJumpTables.isEmpty()) {

out.printf("\nString Switch Jump Tables:\n");

unsigned i = 0;

do {

out.printf(" %1d = {\n", i);

StringJumpTable::StringOffsetTable::const_iterator end = m_rareData->m_stringSwitchJumpTables[i].offsetTable.end();

for (StringJumpTable::StringOffsetTable::const_iterator iter = m_rareData->m_stringSwitchJumpTables[i].offsetTable.begin(); iter != end; ++iter)

out.printf("\t\t\"%s\" => %04d\n", iter->key->utf8().data(), iter->value.branchOffset);

out.printf(" }\n");

++i;

} while (i < m_rareData->m_stringSwitchJumpTables.size());

}

out.printf("\n");

}

void CodeBlock::beginDumpProfiling(PrintStream& out, bool& hasPrintedProfiling)

{

if (hasPrintedProfiling) {

out.print("; ");

return;

}

out.print(" ");

hasPrintedProfiling = true;

}

void CodeBlock::dumpValueProfiling(PrintStream& out, const Instruction*& it, bool& hasPrintedProfiling)

{

ConcurrentJITLocker locker(m_lock);

++it;

CString description = it->u.profile->briefDescription(locker);

if (!description.length())

return;

beginDumpProfiling(out, hasPrintedProfiling);

out.print(description);

}

void CodeBlock::dumpArrayProfiling(PrintStream& out, const Instruction*& it, bool& hasPrintedProfiling)

{

ConcurrentJITLocker locker(m_lock);

++it;

if (!it->u.arrayProfile)

return;

CString description = it->u.arrayProfile->briefDescription(locker, this);

if (!description.length())

return;

beginDumpProfiling(out, hasPrintedProfiling);

out.print(description);

}

void CodeBlock::dumpRareCaseProfile(PrintStream& out, const char* name, RareCaseProfile* profile, bool& hasPrintedProfiling)

{

if (!profile || !profile->m_counter)

return;

beginDumpProfiling(out, hasPrintedProfiling);

out.print(name, profile->m_counter);

}

void CodeBlock::printLocationAndOp(PrintStream& out, ExecState*, int location, const Instruction*&, const char* op)

{

out.printf("[%4d] %-17s ", location, op);

}

void CodeBlock::printLocationOpAndRegisterOperand(PrintStream& out, ExecState* exec, int location, const Instruction*& it, const char* op, int operand)

{

printLocationAndOp(out, exec, location, it, op);

out.printf("%s", registerName(operand).data());

}

void CodeBlock::dumpBytecode(

PrintStream& out, ExecState* exec, const Instruction* begin, const Instruction*& it,

const StubInfoMap& stubInfos, const CallLinkInfoMap& callLinkInfos)

{

int location = it - begin;

bool hasPrintedProfiling = false;

OpcodeID opcode = exec->interpreter()->getOpcodeID(it->u.opcode);

switch (opcode) {

case op_enter: {

printLocationAndOp(out, exec, location, it, "enter");

break;

}

case op_touch_entry: {

printLocationAndOp(out, exec, location, it, "touch_entry");

break;

}

case op_create_activation: {

int r0 = (++it)->u.operand;

printLocationOpAndRegisterOperand(out, exec, location, it, "create_activation", r0);

break;

}

case op_create_arguments: {

int r0 = (++it)->u.operand;

printLocationOpAndRegisterOperand(out, exec, location, it, "create_arguments", r0);

break;

}

case op_init_lazy_reg: {

int r0 = (++it)->u.operand;

printLocationOpAndRegisterOperand(out, exec, location, it, "init_lazy_reg", r0);

break;

}

case op_get_callee: {

int r0 = (++it)->u.operand;

printLocationOpAndRegisterOperand(out, exec, location, it, "get_callee", r0);

++it;

break;

}

case op_create_this: {

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

unsigned inferredInlineCapacity = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "create_this");

out.printf("%s, %s, %u", registerName(r0).data(), registerName(r1).data(), inferredInlineCapacity);

break;

}

case op_to_this: {

int r0 = (++it)->u.operand;

printLocationOpAndRegisterOperand(out, exec, location, it, "to_this", r0);

Structure* structure = (++it)->u.structure.get();

if (structure)

out.print(" cache(struct = ", RawPointer(structure), ")");

break;

}

case op_new_object: {

int r0 = (++it)->u.operand;

unsigned inferredInlineCapacity = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "new_object");

out.printf("%s, %u", registerName(r0).data(), inferredInlineCapacity);

++it; // Skip object allocation profile.

break;

}

case op_new_array: {

int dst = (++it)->u.operand;

int argv = (++it)->u.operand;

int argc = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "new_array");

out.printf("%s, %s, %d", registerName(dst).data(), registerName(argv).data(), argc);

++it; // Skip array allocation profile.

break;

}

case op_new_array_with_size: {

int dst = (++it)->u.operand;

int length = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "new_array_with_size");

out.printf("%s, %s", registerName(dst).data(), registerName(length).data());

++it; // Skip array allocation profile.

break;

}

case op_new_array_buffer: {

int dst = (++it)->u.operand;

int argv = (++it)->u.operand;

int argc = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "new_array_buffer");

out.printf("%s, %d, %d", registerName(dst).data(), argv, argc);

++it; // Skip array allocation profile.

break;

}

case op_new_regexp: {

int r0 = (++it)->u.operand;

int re0 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "new_regexp");

out.printf("%s, ", registerName(r0).data());

if (r0 >=0 && r0 < (int)m_unlinkedCode->numberOfRegExps())

out.printf("%s", regexpName(re0, regexp(re0)).data());

else

out.printf("bad_regexp(%d)", re0);

break;

}

case op_mov: {

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "mov");

out.printf("%s, %s", registerName(r0).data(), registerName(r1).data());

break;

}

case op_captured_mov: {

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "captured_mov");

out.printf("%s, %s", registerName(r0).data(), registerName(r1).data());

++it;

break;

}

case op_not: {

printUnaryOp(out, exec, location, it, "not");

break;

}

case op_eq: {

printBinaryOp(out, exec, location, it, "eq");

break;

}

case op_eq_null: {

printUnaryOp(out, exec, location, it, "eq_null");

break;

}

case op_neq: {

printBinaryOp(out, exec, location, it, "neq");

break;

}

case op_neq_null: {

printUnaryOp(out, exec, location, it, "neq_null");

break;

}

case op_stricteq: {

printBinaryOp(out, exec, location, it, "stricteq");

break;

}

case op_nstricteq: {

printBinaryOp(out, exec, location, it, "nstricteq");

break;

}

case op_less: {

printBinaryOp(out, exec, location, it, "less");

break;

}

case op_lesseq: {

printBinaryOp(out, exec, location, it, "lesseq");

break;

}

case op_greater: {

printBinaryOp(out, exec, location, it, "greater");

break;

}

case op_greatereq: {

printBinaryOp(out, exec, location, it, "greatereq");

break;

}

case op_inc: {

int r0 = (++it)->u.operand;

printLocationOpAndRegisterOperand(out, exec, location, it, "inc", r0);

break;

}

case op_dec: {

int r0 = (++it)->u.operand;

printLocationOpAndRegisterOperand(out, exec, location, it, "dec", r0);

break;

}

case op_to_number: {

printUnaryOp(out, exec, location, it, "to_number");

break;

}

case op_negate: {

printUnaryOp(out, exec, location, it, "negate");

break;

}

case op_add: {

printBinaryOp(out, exec, location, it, "add");

++it;

break;

}

case op_mul: {

printBinaryOp(out, exec, location, it, "mul");

++it;

break;

}

case op_div: {

printBinaryOp(out, exec, location, it, "div");

++it;

break;

}

case op_mod: {

printBinaryOp(out, exec, location, it, "mod");

break;

}

case op_sub: {

printBinaryOp(out, exec, location, it, "sub");

++it;

break;

}

case op_lshift: {

printBinaryOp(out, exec, location, it, "lshift");

break;

}

case op_rshift: {

printBinaryOp(out, exec, location, it, "rshift");

break;

}

case op_urshift: {

printBinaryOp(out, exec, location, it, "urshift");

break;

}

case op_bitand: {

printBinaryOp(out, exec, location, it, "bitand");

++it;

break;

}

case op_bitxor: {

printBinaryOp(out, exec, location, it, "bitxor");

++it;

break;

}

case op_bitor: {

printBinaryOp(out, exec, location, it, "bitor");

++it;

break;

}

case op_check_has_instance: {

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

int r2 = (++it)->u.operand;

int offset = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "check_has_instance");

out.printf("%s, %s, %s, %d(->%d)", registerName(r0).data(), registerName(r1).data(), registerName(r2).data(), offset, location + offset);

break;

}

case op_instanceof: {

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

int r2 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "instanceof");

out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data());

break;

}

case op_unsigned: {

printUnaryOp(out, exec, location, it, "unsigned");

break;

}

case op_typeof: {

printUnaryOp(out, exec, location, it, "typeof");

break;

}

case op_is_undefined: {

printUnaryOp(out, exec, location, it, "is_undefined");

break;

}

case op_is_boolean: {

printUnaryOp(out, exec, location, it, "is_boolean");

break;

}

case op_is_number: {

printUnaryOp(out, exec, location, it, "is_number");

break;

}

case op_is_string: {

printUnaryOp(out, exec, location, it, "is_string");

break;

}

case op_is_object: {

printUnaryOp(out, exec, location, it, "is_object");

break;

}

case op_is_function: {

printUnaryOp(out, exec, location, it, "is_function");

break;

}

case op_in: {

printBinaryOp(out, exec, location, it, "in");

break;

}

case op_init_global_const_nop: {

printLocationAndOp(out, exec, location, it, "init_global_const_nop");

it++;

it++;

it++;

it++;

break;

}

case op_init_global_const: {

WriteBarrier<Unknown>* registerPointer = (++it)->u.registerPointer;

int r0 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "init_global_const");

out.printf("g%d(%p), %s", m_globalObject->findRegisterIndex(registerPointer), registerPointer, registerName(r0).data());

it++;

it++;

break;

}

case op_get_by_id:

case op_get_by_id_out_of_line:

case op_get_array_length: {

printGetByIdOp(out, exec, location, it);

printGetByIdCacheStatus(out, exec, location, stubInfos);

dumpValueProfiling(out, it, hasPrintedProfiling);

break;

}

case op_get_arguments_length: {

printUnaryOp(out, exec, location, it, "get_arguments_length");

it++;

break;

}

case op_put_by_id: {

printPutByIdOp(out, exec, location, it, "put_by_id");

break;

}

case op_put_by_id_out_of_line: {

printPutByIdOp(out, exec, location, it, "put_by_id_out_of_line");

break;

}

case op_put_by_id_transition_direct: {

printPutByIdOp(out, exec, location, it, "put_by_id_transition_direct");

break;

}

case op_put_by_id_transition_direct_out_of_line: {

printPutByIdOp(out, exec, location, it, "put_by_id_transition_direct_out_of_line");

break;

}

case op_put_by_id_transition_normal: {

printPutByIdOp(out, exec, location, it, "put_by_id_transition_normal");

break;

}

case op_put_by_id_transition_normal_out_of_line: {

printPutByIdOp(out, exec, location, it, "put_by_id_transition_normal_out_of_line");

break;

}

case op_put_getter_setter: {

int r0 = (++it)->u.operand;

int id0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

int r2 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "put_getter_setter");

out.printf("%s, %s, %s, %s", registerName(r0).data(), idName(id0, identifier(id0)).data(), registerName(r1).data(), registerName(r2).data());

break;

}

case op_del_by_id: {

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

int id0 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "del_by_id");

out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), idName(id0, identifier(id0)).data());

break;

}

case op_get_by_val: {

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

int r2 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "get_by_val");

out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data());

dumpArrayProfiling(out, it, hasPrintedProfiling);

dumpValueProfiling(out, it, hasPrintedProfiling);

break;

}

case op_get_argument_by_val: {

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

int r2 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "get_argument_by_val");

out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data());

++it;

dumpValueProfiling(out, it, hasPrintedProfiling);

break;

}

case op_get_by_pname: {

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;

int r2 = (++it)->u.operand;

int r3 = (++it)->u.operand;

int r4 = (++it)->u.operand;

int r5 = (++it)->u.operand;

printLocationAndOp(out, exec, location, it, "get_by_pname");

out.printf("%s, %s, %s, %s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data(), registerName(r3).data(), registerName(r4).data(), registerName(r5).data());

break;

}

case op_put_by_val: {

int r0 = (++it)->u.operand;

int r1 = (++it)->u.operand;