/*
 * Copyright (C) 2017 Yusuke Suzuki <utatane.tea@gmail.com>
 * Copyright (C) 2017 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. 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 INC. 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 "BytecodeDumper.h"

#include "ArithProfile.h"
#include "CallLinkStatus.h"
#include "CodeBlock.h"
#include "Error.h"
#include "HeapInlines.h"
#include "InterpreterInlines.h"
#include "PolymorphicAccess.h"
#include "PutByIdFlags.h"
#include "StructureInlines.h"
#include "ToThisStatus.h"
#include "UnlinkedCodeBlock.h"

namespace JSC {

static StructureID getStructureID(const Instruction& instruction)
{
    return instruction.u.structureID;
}

static StructureID getStructureID(const UnlinkedInstruction&)
{
    return 0;
}

static Special::Pointer getSpecialPointer(const Instruction& instruction)
{
    return instruction.u.specialPointer;
}

static Special::Pointer getSpecialPointer(const UnlinkedInstruction& instruction)
{
    return static_cast<Special::Pointer>(instruction.u.operand);
}

static PutByIdFlags getPutByIdFlags(const Instruction& instruction)
{
    return instruction.u.putByIdFlags;
}

static PutByIdFlags getPutByIdFlags(const UnlinkedInstruction& instruction)
{
    return static_cast<PutByIdFlags>(instruction.u.operand);
}

static ToThisStatus getToThisStatus(const Instruction& instruction)
{
    return instruction.u.toThisStatus;
}

static ToThisStatus getToThisStatus(const UnlinkedInstruction& instruction)
{
    return static_cast<ToThisStatus>(instruction.u.operand);
}

static void* getPointer(const Instruction& instruction)
{
    return instruction.u.pointer;
}

static void* getPointer(const UnlinkedInstruction&)
{
    return nullptr;
}

static StructureChain* getStructureChain(const Instruction& instruction)
{
    return instruction.u.structureChain.get();
}

static StructureChain* getStructureChain(const UnlinkedInstruction&)
{
    return nullptr;
}

static Structure* getStructure(const Instruction& instruction)
{
    return instruction.u.structure.get();
}

static Structure* getStructure(const UnlinkedInstruction&)
{
    return nullptr;
}

static LLIntCallLinkInfo* getCallLinkInfo(const Instruction& instruction)
{
    return instruction.u.callLinkInfo;
}

static LLIntCallLinkInfo* getCallLinkInfo(const UnlinkedInstruction&)
{
    return nullptr;
}

static BasicBlockLocation* getBasicBlockLocation(const Instruction& instruction)
{
    return instruction.u.basicBlockLocation;
}

static BasicBlockLocation* getBasicBlockLocation(const UnlinkedInstruction&)
{
    return nullptr;
}

template<class Block>
void* BytecodeDumper<Block>::actualPointerFor(Special::Pointer) const
{
    return nullptr;
}

template<>
void* BytecodeDumper<CodeBlock>::actualPointerFor(Special::Pointer pointer) const
{
    return block()->globalObject()->actualPointerFor(pointer);
}

static void beginDumpProfiling(PrintStream& out, bool& hasPrintedProfiling)
{
    if (hasPrintedProfiling) {
        out.print("; ");
        return;
    }

    out.print("    ");
    hasPrintedProfiling = true;
}

template<class Block>
void BytecodeDumper<Block>::dumpValueProfiling(PrintStream&, const typename Block::Instruction*& it, bool&)
{
    ++it;
}

template<>
void BytecodeDumper<CodeBlock>::dumpValueProfiling(PrintStream& out, const typename CodeBlock::Instruction*& it, bool& hasPrintedProfiling)
{
    ConcurrentJSLocker locker(block()->m_lock);

    ++it;
    CString description = it->u.profile->briefDescription(locker);
    if (!description.length())
        return;
    beginDumpProfiling(out, hasPrintedProfiling);
    out.print(description);
}

template<class Block>
void BytecodeDumper<Block>::dumpArrayProfiling(PrintStream&, const typename Block::Instruction*& it, bool&)
{
    ++it;
}

template<>
void BytecodeDumper<CodeBlock>::dumpArrayProfiling(PrintStream& out, const typename CodeBlock::Instruction*& it, bool& hasPrintedProfiling)
{
    ConcurrentJSLocker locker(block()->m_lock);

    ++it;
    if (!it->u.arrayProfile)
        return;
    CString description = it->u.arrayProfile->briefDescription(locker, block());
    if (!description.length())
        return;
    beginDumpProfiling(out, hasPrintedProfiling);
    out.print(description);
}

template<class Block>
void BytecodeDumper<Block>::dumpProfilesForBytecodeOffset(PrintStream&, unsigned, bool&)
{
}

static void 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);
}

static void dumpArithProfile(PrintStream& out, ArithProfile* profile, bool& hasPrintedProfiling)
{
    if (!profile)
        return;

    beginDumpProfiling(out, hasPrintedProfiling);
    out.print("results: ", *profile);
}

template<>
void BytecodeDumper<CodeBlock>::dumpProfilesForBytecodeOffset(PrintStream& out, unsigned location, bool& hasPrintedProfiling)
{
    dumpRareCaseProfile(out, "rare case: ", block()->rareCaseProfileForBytecodeOffset(location), hasPrintedProfiling);
    {
        dumpArithProfile(out, block()->arithProfileForBytecodeOffset(location), hasPrintedProfiling);
    }

#if ENABLE(DFG_JIT)
    Vector<DFG::FrequentExitSite> exitSites = block()->unlinkedCodeBlock()->exitProfile().exitSitesFor(location);
    if (!exitSites.isEmpty()) {
        out.print(" !! frequent exits: ");
        CommaPrinter comma;
        for (auto& exitSite : exitSites)
            out.print(comma, exitSite.kind(), " ", exitSite.jitType());
    }
#else // ENABLE(DFG_JIT)
    UNUSED_PARAM(location);
#endif // ENABLE(DFG_JIT)
}

template<class Block>
VM* BytecodeDumper<Block>::vm() const
{
    return block()->vm();
}

template<class Block>
const Identifier& BytecodeDumper<Block>::identifier(int index) const
{
    return block()->identifier(index);
}

static CString regexpToSourceString(RegExp* regExp)
{
    char postfix[7] = { '/', 0, 0, 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';
    if (regExp->dotAll())
        postfix[index++] = 's';
    if (regExp->unicode())
        postfix[index++] = 'u';
    if (regExp->sticky())
        postfix[index++] = 'y';

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

static CString regexpName(int re, RegExp* regexp)
{
    return toCString(regexpToSourceString(regexp), "(@re", re, ")");
}

template<class Instruction>
static void printLocationAndOp(PrintStream& out, int location, const Instruction*&, const char* op)
{
    out.printf("[%4d] %-17s ", location, op);
}

static ALWAYS_INLINE bool isConstantRegisterIndex(int index)
{
    return index >= FirstConstantRegisterIndex;
}

NEVER_INLINE static const char* debugHookName(int debugHookType)
{
    switch (static_cast<DebugHookType>(debugHookType)) {
    case DidEnterCallFrame:
        return "didEnterCallFrame";
    case WillLeaveCallFrame:
        return "willLeaveCallFrame";
    case WillExecuteStatement:
        return "willExecuteStatement";
    case WillExecuteExpression:
        return "willExecuteExpression";
    case WillExecuteProgram:
        return "willExecuteProgram";
    case DidExecuteProgram:
        return "didExecuteProgram";
    case DidReachBreakpoint:
        return "didReachBreakpoint";
    }

    RELEASE_ASSERT_NOT_REACHED();
    return "";
}

template<class Block>
CString BytecodeDumper<Block>::registerName(int r) const
{
    if (isConstantRegisterIndex(r))
        return constantName(r);

    return toCString(VirtualRegister(r));
}

static CString idName(int id0, const Identifier& ident)
{
    return toCString(ident.impl(), "(@id", id0, ")");
}

template<class Block>
CString BytecodeDumper<Block>::constantName(int index) const
{
    JSValue value = block()->getConstant(index);
    return toCString(value, "(", VirtualRegister(index), ")");
}

template<class Block>
void BytecodeDumper<Block>::printUnaryOp(PrintStream& out, int location, const typename Block::Instruction*& it, const char* op)
{
    int r0 = (++it)->u.operand;
    int r1 = (++it)->u.operand;

    printLocationAndOp(out, location, it, op);
    out.printf("%s, %s", registerName(r0).data(), registerName(r1).data());
}

template<class Block>
void BytecodeDumper<Block>::printBinaryOp(PrintStream& out, int location, const typename Block::Instruction*& it, const char* op)
{
    int r0 = (++it)->u.operand;
    int r1 = (++it)->u.operand;
    int r2 = (++it)->u.operand;
    printLocationAndOp(out, location, it, op);
    out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data());
}

template<class Block>
void BytecodeDumper<Block>::printConditionalJump(PrintStream& out, const typename Block::Instruction*, const typename Block::Instruction*& it, int location, const char* op)
{
    int r0 = (++it)->u.operand;
    int offset = (++it)->u.operand;
    printLocationAndOp(out, location, it, op);
    out.printf("%s, %d(->%d)", registerName(r0).data(), offset, location + offset);
}

template<class Block>
void BytecodeDumper<Block>::printCompareJump(PrintStream& out, const typename Block::Instruction*, const typename Block::Instruction*& it, int location, const char* op)
{
    int r0 = (++it)->u.operand;
    int r1 = (++it)->u.operand;
    int offset = (++it)->u.operand;
    printLocationAndOp(out, location, it, op);
    out.printf("%s, %s, %d(->%d)", registerName(r0).data(), registerName(r1).data(), offset, location + offset);
}

template<class Block>
void BytecodeDumper<Block>::printGetByIdOp(PrintStream& out, int location, const typename Block::Instruction*& it)
{
    const char* op;
    switch (Interpreter::getOpcodeID(*it)) {
    case op_get_by_id:
        op = "get_by_id";
        break;
    case op_get_by_id_proto_load:
        op = "get_by_id_proto_load";
        break;
    case op_get_by_id_unset:
        op = "get_by_id_unset";
        break;
    case op_get_array_length:
        op = "array_length";
        break;
    default:
        RELEASE_ASSERT_NOT_REACHED();
#if COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE)
        op = 0;
#endif
    }
    int r0 = (++it)->u.operand;
    int r1 = (++it)->u.operand;
    int id0 = (++it)->u.operand;
    printLocationAndOp(out, 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, Structure* structure, const Identifier& ident)
{
    if (!structure)
        return;

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

    PropertyOffset offset = structure->getConcurrently(ident.impl());
    if (offset != invalidOffset)
        out.printf(" (offset = %d)", offset);
}

static void dumpChain(PrintStream& out, 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", currentStructure->get(), ident);
    }
    out.printf("]");
}

template<class Block>
void BytecodeDumper<Block>::printGetByIdCacheStatus(PrintStream& out, int location, const StubInfoMap& map)
{
    const auto* instruction = instructionsBegin() + location;

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

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

    if (Interpreter::getOpcodeID(instruction[0]) == op_get_array_length)
        out.printf(" llint(array_length)");
    else if (StructureID structureID = getStructureID(instruction[4])) {
        Structure* structure = vm()->heap.structureIDTable().get(structureID);
        out.printf(" llint(");
        dumpStructure(out, "struct", structure, ident);
        out.printf(")");
        if (Interpreter::getOpcodeID(instruction[0]) == op_get_by_id_proto_load)
            out.printf(" proto(%p)", getPointer(instruction[6]));
    }

#if ENABLE(JIT)
    if (StructureStubInfo* stubPtr = map.get(CodeOrigin(location))) {
        StructureStubInfo& stubInfo = *stubPtr;
        if (stubInfo.resetByGC)
            out.print(" (Reset By GC)");

        out.printf(" jit(");

        Structure* baseStructure = nullptr;
        PolymorphicAccess* stub = nullptr;

        switch (stubInfo.cacheType) {
        case CacheType::GetByIdSelf:
            out.printf("self");
            baseStructure = stubInfo.u.byIdSelf.baseObjectStructure.get();
            break;
        case CacheType::Stub:
            out.printf("stub");
            stub = stubInfo.u.stub;
            break;
        case CacheType::Unset:
            out.printf("unset");
            break;
        case CacheType::ArrayLength:
            out.printf("ArrayLength");
            break;
        default:
            RELEASE_ASSERT_NOT_REACHED();
            break;
        }

        if (baseStructure) {
            out.printf(", ");
            dumpStructure(out, "struct", baseStructure, ident);
        }

        if (stub)
            out.print(", ", *stub);

        out.printf(")");
    }
#else
    UNUSED_PARAM(map);
#endif
}

template<class Block>
void BytecodeDumper<Block>::printPutByIdCacheStatus(PrintStream& out, int location, const StubInfoMap& map)
{
    const auto* instruction = instructionsBegin() + location;

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

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

    out.print(", ", getPutByIdFlags(instruction[8]));

    if (StructureID structureID = getStructureID(instruction[4])) {
        Structure* structure = vm()->heap.structureIDTable().get(structureID);
        out.print(" llint(");
        if (StructureID newStructureID = getStructureID(instruction[6])) {
            Structure* newStructure = vm()->heap.structureIDTable().get(newStructureID);
            dumpStructure(out, "prev", structure, ident);
            out.print(", ");
            dumpStructure(out, "next", newStructure, ident);
            if (StructureChain* chain = getStructureChain(instruction[7])) {
                out.print(", ");
                dumpChain(out, chain, ident);
            }
        } else
            dumpStructure(out, "struct", structure, ident);
        out.print(")");
    }

#if ENABLE(JIT)
    if (StructureStubInfo* stubPtr = map.get(CodeOrigin(location))) {
        StructureStubInfo& stubInfo = *stubPtr;
        if (stubInfo.resetByGC)
            out.print(" (Reset By GC)");

        out.printf(" jit(");

        switch (stubInfo.cacheType) {
        case CacheType::PutByIdReplace:
            out.print("replace, ");
            dumpStructure(out, "struct", stubInfo.u.byIdSelf.baseObjectStructure.get(), ident);
            break;
        case CacheType::Stub: {
            out.print("stub, ", *stubInfo.u.stub);
            break;
        }
        case CacheType::Unset:
            out.printf("unset");
            break;
        default:
            RELEASE_ASSERT_NOT_REACHED();
            break;
        }
        out.printf(")");
    }
#else
    UNUSED_PARAM(map);
#endif
}

#if ENABLE(JIT)
template<typename Block>
void BytecodeDumper<Block>::dumpCallLinkStatus(PrintStream&, unsigned, const CallLinkInfoMap&)
{
}

template<>
void BytecodeDumper<CodeBlock>::dumpCallLinkStatus(PrintStream& out, unsigned location, const CallLinkInfoMap& map)
{
    if (block()->jitType() != JITCode::FTLJIT)
        out.print(" status(", CallLinkStatus::computeFor(block(), location, map), ")");
}
#endif

template<class Block>
void BytecodeDumper<Block>::printCallOp(PrintStream& out, int location, const typename Block::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, location, it, op);
    out.print(registerName(dst), ", ", registerName(func), ", ", argCount, ", ", registerOffset);
    out.print(" (this at ", virtualRegisterForArgument(0, -registerOffset), ")");
    if (cacheDumpMode == DumpCaches) {
        LLIntCallLinkInfo* callLinkInfo = getCallLinkInfo(it[1]);
        if (callLinkInfo->lastSeenCallee) {
            JSObject* object = callLinkInfo->lastSeenCallee.get();
            if (auto* function = jsDynamicCast<JSFunction*>(*vm(), object))
                out.printf(" llint(%p, exec %p)", function, function->executable());
            else
                out.printf(" llint(%p)", object);
        }
#if ENABLE(JIT)
        if (CallLinkInfo* info = map.get(CodeOrigin(location))) {
            if (info->haveLastSeenCallee()) {
                JSObject* object = info->lastSeenCallee();
                if (auto* function = jsDynamicCast<JSFunction*>(*vm(), object))
                    out.printf(" jit(%p, exec %p)", function, function->executable());
                else
                    out.printf(" jit(%p)", object);
            }
        }

        dumpCallLinkStatus(out, location, map);
#else
        UNUSED_PARAM(map);
#endif
    }
    ++it;
    ++it;
    dumpArrayProfiling(out, it, hasPrintedProfiling);
    dumpValueProfiling(out, it, hasPrintedProfiling);
}

template<class Block>
void BytecodeDumper<Block>::printPutByIdOp(PrintStream& out, int location, const typename Block::Instruction*& it, const char* op)
{
    int r0 = (++it)->u.operand;
    int id0 = (++it)->u.operand;
    int r1 = (++it)->u.operand;
    printLocationAndOp(out, location, it, op);
    out.printf("%s, %s, %s", registerName(r0).data(), idName(id0, identifier(id0)).data(), registerName(r1).data());
    it += 5;
}

template<class Block>
void BytecodeDumper<Block>::printLocationOpAndRegisterOperand(PrintStream& out, int location, const typename Block::Instruction*& it, const char* op, int operand)
{
    printLocationAndOp(out, location, it, op);
    out.printf("%s", registerName(operand).data());
}

template<class Block>
void BytecodeDumper<Block>::dumpBytecode(PrintStream& out, const typename Block::Instruction* begin, const typename Block::Instruction*& it, const StubInfoMap& stubInfos, const CallLinkInfoMap& callLinkInfos)
{
    int location = it - begin;
    bool hasPrintedProfiling = false;
    OpcodeID opcode = Interpreter::getOpcodeID(*it);
    switch (opcode) {
    case op_enter: {
        printLocationAndOp(out, location, it, "enter");
        break;
    }
    case op_get_scope: {
        int r0 = (++it)->u.operand;
        printLocationOpAndRegisterOperand(out, location, it, "get_scope", r0);
        break;
    }
    case op_create_direct_arguments: {
        int r0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "create_direct_arguments");
        out.printf("%s", registerName(r0).data());
        break;
    }
    case op_create_scoped_arguments: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "create_scoped_arguments");
        out.printf("%s, %s", registerName(r0).data(), registerName(r1).data());
        break;
    }
    case op_create_cloned_arguments: {
        int r0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "create_cloned_arguments");
        out.printf("%s", registerName(r0).data());
        break;
    }
    case op_argument_count: {
        int r0 = (++it)->u.operand;
        printLocationOpAndRegisterOperand(out, location, it, "argument_count", r0);
        break;
    }
    case op_get_argument: {
        int r0 = (++it)->u.operand;
        int index = (++it)->u.operand;
        printLocationOpAndRegisterOperand(out, location, it, "argument", r0);
        out.printf(", %d", index);
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_create_rest: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        unsigned argumentOffset = (++it)->u.unsignedValue;
        printLocationAndOp(out, location, it, "create_rest");
        out.printf("%s, %s, ", registerName(r0).data(), registerName(r1).data());
        out.printf("ArgumentsOffset: %u", argumentOffset);
        break;
    }
    case op_get_rest_length: {
        int r0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "get_rest_length");
        out.printf("%s, ", registerName(r0).data());
        unsigned argumentOffset = (++it)->u.unsignedValue;
        out.printf("ArgumentsOffset: %u", argumentOffset);
        break;
    }
    case op_create_this: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        unsigned inferredInlineCapacity = (++it)->u.operand;
        unsigned cachedFunction = (++it)->u.operand;
        printLocationAndOp(out, location, it, "create_this");
        out.printf("%s, %s, %u, %u", registerName(r0).data(), registerName(r1).data(), inferredInlineCapacity, cachedFunction);
        break;
    }
    case op_to_this: {
        int r0 = (++it)->u.operand;
        printLocationOpAndRegisterOperand(out, location, it, "to_this", r0);
        Structure* structure = getStructure(*(++it));
        if (structure)
            out.print(", cache(struct = ", RawPointer(structure), ")");
        out.print(", ", getToThisStatus(*(++it)));
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_check_tdz: {
        int r0 = (++it)->u.operand;
        printLocationOpAndRegisterOperand(out, location, it, "op_check_tdz", r0);
        break;
    }
    case op_new_object: {
        int r0 = (++it)->u.operand;
        unsigned inferredInlineCapacity = (++it)->u.operand;
        printLocationAndOp(out, 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, 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_spread: {
        int dst = (++it)->u.operand;
        int argv = (++it)->u.operand;
        int argc = (++it)->u.operand;
        printLocationAndOp(out, location, it, "new_array_with_spread");
        out.printf("%s, %s, %d, ", registerName(dst).data(), registerName(argv).data(), argc);
        unsigned bitVectorIndex = (++it)->u.unsignedValue;
        const BitVector& bitVector = block()->bitVector(bitVectorIndex);
        out.print("BitVector:", bitVectorIndex, ":");
        for (unsigned i = 0; i < static_cast<unsigned>(argc); i++) {
            if (bitVector.get(i))
                out.print("1");
            else
                out.print("0");
        }
        break;
    }
    case op_spread: {
        int dst = (++it)->u.operand;
        int arg = (++it)->u.operand;
        printLocationAndOp(out, location, it, "spread");
        out.printf("%s, %s", registerName(dst).data(), registerName(arg).data());
        break;
    }
    case op_new_array_with_size: {
        int dst = (++it)->u.operand;
        int length = (++it)->u.operand;
        printLocationAndOp(out, 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 array = (++it)->u.operand;
        printLocationAndOp(out, location, it, "new_array_buffer");
        out.printf("%s, %s", registerName(dst).data(), registerName(array).data());
        ++it; // Skip array allocation profile.
        break;
    }
    case op_new_regexp: {
        int r0 = (++it)->u.operand;
        int re0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "new_regexp");
        out.printf("%s, ", registerName(r0).data());
        if (r0 >=0 && r0 < (int)block()->numberOfRegExps())
            out.printf("%s", regexpName(re0, block()->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, location, it, "mov");
        out.printf("%s, %s", registerName(r0).data(), registerName(r1).data());
        break;
    }
    case op_profile_type: {
        int r0 = (++it)->u.operand;
        ++it;
        ++it;
        ++it;
        ++it;
        printLocationAndOp(out, location, it, "op_profile_type");
        out.printf("%s", registerName(r0).data());
        break;
    }
    case op_profile_control_flow: {
        BasicBlockLocation* basicBlockLocation = getBasicBlockLocation(*(++it));
        printLocationAndOp(out, location, it, "profile_control_flow");
        if (basicBlockLocation)
            out.printf("[%d, %d]", basicBlockLocation->startOffset(), basicBlockLocation->endOffset());
        break;
    }
    case op_not: {
        printUnaryOp(out, location, it, "not");
        break;
    }
    case op_eq: {
        printBinaryOp(out, location, it, "eq");
        break;
    }
    case op_eq_null: {
        printUnaryOp(out, location, it, "eq_null");
        break;
    }
    case op_neq: {
        printBinaryOp(out, location, it, "neq");
        break;
    }
    case op_neq_null: {
        printUnaryOp(out, location, it, "neq_null");
        break;
    }
    case op_stricteq: {
        printBinaryOp(out, location, it, "stricteq");
        break;
    }
    case op_nstricteq: {
        printBinaryOp(out, location, it, "nstricteq");
        break;
    }
    case op_less: {
        printBinaryOp(out, location, it, "less");
        break;
    }
    case op_lesseq: {
        printBinaryOp(out, location, it, "lesseq");
        break;
    }
    case op_greater: {
        printBinaryOp(out, location, it, "greater");
        break;
    }
    case op_greatereq: {
        printBinaryOp(out, location, it, "greatereq");
        break;
    }
    case op_below: {
        printBinaryOp(out, location, it, "below");
        break;
    }
    case op_beloweq: {
        printBinaryOp(out, location, it, "beloweq");
        break;
    }
    case op_inc: {
        int r0 = (++it)->u.operand;
        printLocationOpAndRegisterOperand(out, location, it, "inc", r0);
        break;
    }
    case op_dec: {
        int r0 = (++it)->u.operand;
        printLocationOpAndRegisterOperand(out, location, it, "dec", r0);
        break;
    }
    case op_to_number: {
        printUnaryOp(out, location, it, "to_number");
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_to_string: {
        printUnaryOp(out, location, it, "to_string");
        break;
    }
    case op_to_object: {
        printUnaryOp(out, location, it, "to_object");
        int id0 = (++it)->u.operand;
        out.printf(" %s", idName(id0, identifier(id0)).data());
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_negate: {
        printUnaryOp(out, location, it, "negate");
        ++it; // op_negate has an extra operand for the ArithProfile.
        break;
    }
    case op_add: {
        printBinaryOp(out, location, it, "add");
        ++it;
        break;
    }
    case op_mul: {
        printBinaryOp(out, location, it, "mul");
        ++it;
        break;
    }
    case op_div: {
        printBinaryOp(out, location, it, "div");
        ++it;
        break;
    }
    case op_mod: {
        printBinaryOp(out, location, it, "mod");
        break;
    }
    case op_pow: {
        printBinaryOp(out, location, it, "pow");
        break;
    }
    case op_sub: {
        printBinaryOp(out, location, it, "sub");
        ++it;
        break;
    }
    case op_lshift: {
        printBinaryOp(out, location, it, "lshift");
        break;
    }
    case op_rshift: {
        printBinaryOp(out, location, it, "rshift");
        break;
    }
    case op_urshift: {
        printBinaryOp(out, location, it, "urshift");
        break;
    }
    case op_bitand: {
        printBinaryOp(out, location, it, "bitand");
        ++it;
        break;
    }
    case op_bitxor: {
        printBinaryOp(out, location, it, "bitxor");
        ++it;
        break;
    }
    case op_bitor: {
        printBinaryOp(out, location, it, "bitor");
        ++it;
        break;
    }
    case op_overrides_has_instance: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "overrides_has_instance");
        out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data());
        break;
    }
    case op_instanceof: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "instanceof");
        out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data());
        break;
    }
    case op_instanceof_custom: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        int r3 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "instanceof_custom");
        out.printf("%s, %s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data(), registerName(r3).data());
        break;
    }
    case op_unsigned: {
        printUnaryOp(out, location, it, "unsigned");
        break;
    }
    case op_typeof: {
        printUnaryOp(out, location, it, "typeof");
        break;
    }
    case op_is_empty: {
        printUnaryOp(out, location, it, "is_empty");
        break;
    }
    case op_is_undefined: {
        printUnaryOp(out, location, it, "is_undefined");
        break;
    }
    case op_is_boolean: {
        printUnaryOp(out, location, it, "is_boolean");
        break;
    }
    case op_is_number: {
        printUnaryOp(out, location, it, "is_number");
        break;
    }
    case op_is_cell_with_type: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int type = (++it)->u.operand;
        printLocationAndOp(out, location, it, "is_cell_with_type");
        out.printf("%s, %s, %d", registerName(r0).data(), registerName(r1).data(), type);
        break;
    }
    case op_is_object: {
        printUnaryOp(out, location, it, "is_object");
        break;
    }
    case op_is_object_or_null: {
        printUnaryOp(out, location, it, "is_object_or_null");
        break;
    }
    case op_is_function: {
        printUnaryOp(out, location, it, "is_function");
        break;
    }
    case op_in: {
        printBinaryOp(out, location, it, "in");
        dumpArrayProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_try_get_by_id: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int id0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "try_get_by_id");
        out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), idName(id0, identifier(id0)).data());
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_get_by_id:
    case op_get_by_id_proto_load:
    case op_get_by_id_unset:
    case op_get_array_length: {
        printGetByIdOp(out, location, it);
        printGetByIdCacheStatus(out, location, stubInfos);
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_get_by_id_with_this: {
        printLocationAndOp(out, location, it, "get_by_id_with_this");
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        int id0 = (++it)->u.operand;
        out.printf("%s, %s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data(), idName(id0, identifier(id0)).data());
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_get_by_val_with_this: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        int r3 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "get_by_val_with_this");
        out.printf("%s, %s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data(), registerName(r3).data());
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_put_by_id: {
        printPutByIdOp(out, location, it, "put_by_id");
        printPutByIdCacheStatus(out, location, stubInfos);
        break;
    }
    case op_put_by_id_with_this: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int id0 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "put_by_id_with_this");
        out.printf("%s, %s, %s, %s", registerName(r0).data(), registerName(r1).data(), idName(id0, identifier(id0)).data(), registerName(r2).data());
        break;
    }
    case op_put_by_val_with_this: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        int r3 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "put_by_val_with_this");
        out.printf("%s, %s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data(), registerName(r3).data());
        break;
    }
    case op_put_getter_by_id: {
        int r0 = (++it)->u.operand;
        int id0 = (++it)->u.operand;
        int n0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "put_getter_by_id");
        out.printf("%s, %s, %d, %s", registerName(r0).data(), idName(id0, identifier(id0)).data(), n0, registerName(r1).data());
        break;
    }
    case op_put_setter_by_id: {
        int r0 = (++it)->u.operand;
        int id0 = (++it)->u.operand;
        int n0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "put_setter_by_id");
        out.printf("%s, %s, %d, %s", registerName(r0).data(), idName(id0, identifier(id0)).data(), n0, registerName(r1).data());
        break;
    }
    case op_put_getter_setter_by_id: {
        int r0 = (++it)->u.operand;
        int id0 = (++it)->u.operand;
        int n0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "put_getter_setter_by_id");
        out.printf("%s, %s, %d, %s, %s", registerName(r0).data(), idName(id0, identifier(id0)).data(), n0, registerName(r1).data(), registerName(r2).data());
        break;
    }
    case op_put_getter_by_val: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int n0 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "put_getter_by_val");
        out.printf("%s, %s, %d, %s", registerName(r0).data(), registerName(r1).data(), n0, registerName(r2).data());
        break;
    }
    case op_put_setter_by_val: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int n0 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "put_setter_by_val");
        out.printf("%s, %s, %d, %s", registerName(r0).data(), registerName(r1).data(), n0, registerName(r2).data());
        break;
    }
    case op_define_data_property: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        int r3 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "define_data_property");
        out.printf("%s, %s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data(), registerName(r3).data());
        break;
    }
    case op_define_accessor_property: {
        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;
        printLocationAndOp(out, location, it, "define_accessor_property");
        out.printf("%s, %s, %s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data(), registerName(r3).data(), registerName(r4).data());
        break;
    }
    case op_del_by_id: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int id0 = (++it)->u.operand;
        printLocationAndOp(out, 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, 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_put_by_val: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "put_by_val");
        out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data());
        dumpArrayProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_put_by_val_direct: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "put_by_val_direct");
        out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data());
        dumpArrayProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_del_by_val: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int r2 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "del_by_val");
        out.printf("%s, %s, %s", registerName(r0).data(), registerName(r1).data(), registerName(r2).data());
        break;
    }
    case op_jmp: {
        int offset = (++it)->u.operand;
        printLocationAndOp(out, location, it, "jmp");
        out.printf("%d(->%d)", offset, location + offset);
        break;
    }
    case op_jtrue: {
        printConditionalJump(out, begin, it, location, "jtrue");
        break;
    }
    case op_jfalse: {
        printConditionalJump(out, begin, it, location, "jfalse");
        break;
    }
    case op_jeq_null: {
        printConditionalJump(out, begin, it, location, "jeq_null");
        break;
    }
    case op_jneq_null: {
        printConditionalJump(out, begin, it, location, "jneq_null");
        break;
    }
    case op_jneq_ptr: {
        int r0 = (++it)->u.operand;
        Special::Pointer pointer = getSpecialPointer(*(++it));
        int offset = (++it)->u.operand;
        printLocationAndOp(out, location, it, "jneq_ptr");
        out.printf("%s, %d (%p), %d(->%d)", registerName(r0).data(), pointer, actualPointerFor(pointer), offset, location + offset);
        ++it;
        break;
    }
    case op_jless: {
        printCompareJump(out, begin, it, location, "jless");
        break;
    }
    case op_jlesseq: {
        printCompareJump(out, begin, it, location, "jlesseq");
        break;
    }
    case op_jgreater: {
        printCompareJump(out, begin, it, location, "jgreater");
        break;
    }
    case op_jgreatereq: {
        printCompareJump(out, begin, it, location, "jgreatereq");
        break;
    }
    case op_jnless: {
        printCompareJump(out, begin, it, location, "jnless");
        break;
    }
    case op_jnlesseq: {
        printCompareJump(out, begin, it, location, "jnlesseq");
        break;
    }
    case op_jngreater: {
        printCompareJump(out, begin, it, location, "jngreater");
        break;
    }
    case op_jngreatereq: {
        printCompareJump(out, begin, it, location, "jngreatereq");
        break;
    }
    case op_jeq: {
        printCompareJump(out, begin, it, location, "jeq");
        break;
    }
    case op_jneq: {
        printCompareJump(out, begin, it, location, "jneq");
        break;
    }
    case op_jstricteq: {
        printCompareJump(out, begin, it, location, "jstricteq");
        break;
    }
    case op_jnstricteq: {
        printCompareJump(out, begin, it, location, "jnstricteq");
        break;
    }
    case op_jbelow: {
        printCompareJump(out, begin, it, location, "jbelow");
        break;
    }
    case op_jbeloweq: {
        printCompareJump(out, begin, it, location, "jbeloweq");
        break;
    }
    case op_loop_hint: {
        printLocationAndOp(out, location, it, "loop_hint");
        break;
    }
    case op_check_traps: {
        printLocationAndOp(out, location, it, "check_traps");
        break;
    }
    case op_nop: {
        printLocationAndOp(out, location, it, "nop");
        break;
    }
    case op_super_sampler_begin: {
        printLocationAndOp(out, location, it, "super_sampler_begin");
        break;
    }
    case op_super_sampler_end: {
        printLocationAndOp(out, location, it, "super_sampler_end");
        break;
    }
    case op_log_shadow_chicken_prologue: {
        int r0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "log_shadow_chicken_prologue");
        out.printf("%s", registerName(r0).data());
        break;
    }
    case op_log_shadow_chicken_tail: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "log_shadow_chicken_tail");
        out.printf("%s, %s", registerName(r0).data(), registerName(r1).data());
        break;
    }
    case op_switch_imm: {
        int tableIndex = (++it)->u.operand;
        int defaultTarget = (++it)->u.operand;
        int scrutineeRegister = (++it)->u.operand;
        printLocationAndOp(out, location, it, "switch_imm");
        out.printf("%d, %d(->%d), %s", tableIndex, defaultTarget, location + defaultTarget, registerName(scrutineeRegister).data());
        break;
    }
    case op_switch_char: {
        int tableIndex = (++it)->u.operand;
        int defaultTarget = (++it)->u.operand;
        int scrutineeRegister = (++it)->u.operand;
        printLocationAndOp(out, location, it, "switch_char");
        out.printf("%d, %d(->%d), %s", tableIndex, defaultTarget, location + defaultTarget, registerName(scrutineeRegister).data());
        break;
    }
    case op_switch_string: {
        int tableIndex = (++it)->u.operand;
        int defaultTarget = (++it)->u.operand;
        int scrutineeRegister = (++it)->u.operand;
        printLocationAndOp(out, location, it, "switch_string");
        out.printf("%d, %d(->%d), %s", tableIndex, defaultTarget, location + defaultTarget, registerName(scrutineeRegister).data());
        break;
    }
    case op_new_func: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int f0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "new_func");
        out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0);
        break;
    }
    case op_new_generator_func: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int f0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "new_generator_func");
        out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0);
        break;
    }
    case op_new_async_func: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int f0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "new_async_func");
        out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0);
        break;
    }
    case op_new_async_generator_func: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int f0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "new_async_generator_func");
        out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0);
        break;
    }
    case op_new_func_exp: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int f0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "new_func_exp");
        out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0);
        break;
    }
    case op_new_generator_func_exp: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int f0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "new_generator_func_exp");
        out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0);
        break;
    }
    case op_new_async_func_exp: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int f0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "new_async_func_exp");
        out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0);
        break;
    }
    case op_new_async_generator_func_exp: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int f0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "op_new_async_generator_func_exp");
        out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0);
        break;
    }
    case op_set_function_name: {
        int funcReg = (++it)->u.operand;
        int nameReg = (++it)->u.operand;
        printLocationAndOp(out, location, it, "set_function_name");
        out.printf("%s, %s", registerName(funcReg).data(), registerName(nameReg).data());
        break;
    }
    case op_call: {
        printCallOp(out, location, it, "call", DumpCaches, hasPrintedProfiling, callLinkInfos);
        break;
    }
    case op_tail_call: {
        printCallOp(out, location, it, "tail_call", DumpCaches, hasPrintedProfiling, callLinkInfos);
        break;
    }
    case op_call_eval: {
        printCallOp(out, location, it, "call_eval", DontDumpCaches, hasPrintedProfiling, callLinkInfos);
        break;
    }

    case op_construct_varargs:
    case op_call_varargs:
    case op_tail_call_varargs:
    case op_tail_call_forward_arguments: {
        int result = (++it)->u.operand;
        int callee = (++it)->u.operand;
        int thisValue = (++it)->u.operand;
        int arguments = (++it)->u.operand;
        int firstFreeRegister = (++it)->u.operand;
        int varArgOffset = (++it)->u.operand;
        ++it;
        const char* opName;
        if (opcode == op_call_varargs)
            opName = "call_varargs";
        else if (opcode == op_construct_varargs)
            opName = "construct_varargs";
        else if (opcode == op_tail_call_varargs)
            opName = "tail_call_varargs";
        else if (opcode == op_tail_call_forward_arguments)
            opName = "tail_call_forward_arguments";
        else
            RELEASE_ASSERT_NOT_REACHED();

        printLocationAndOp(out, location, it, opName);
        out.printf("%s, %s, %s, %s, %d, %d", registerName(result).data(), registerName(callee).data(), registerName(thisValue).data(), registerName(arguments).data(), firstFreeRegister, varArgOffset);
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;
    }

    case op_ret: {
        int r0 = (++it)->u.operand;
        printLocationOpAndRegisterOperand(out, location, it, "ret", r0);
        break;
    }
    case op_construct: {
        printCallOp(out, location, it, "construct", DumpCaches, hasPrintedProfiling, callLinkInfos);
        break;
    }
    case op_strcat: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int count = (++it)->u.operand;
        printLocationAndOp(out, location, it, "strcat");
        out.printf("%s, %s, %d", registerName(r0).data(), registerName(r1).data(), count);
        break;
    }
    case op_to_primitive: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "to_primitive");
        out.printf("%s, %s", registerName(r0).data(), registerName(r1).data());
        break;
    }
    case op_get_enumerable_length: {
        int dst = it[1].u.operand;
        int base = it[2].u.operand;
        printLocationAndOp(out, location, it, "op_get_enumerable_length");
        out.printf("%s, %s", registerName(dst).data(), registerName(base).data());
        it += OPCODE_LENGTH(op_get_enumerable_length) - 1;
        break;
    }
    case op_has_indexed_property: {
        int dst = (++it)->u.operand;
        int base = (++it)->u.operand;
        int propertyName = (++it)->u.operand;
        printLocationAndOp(out, location, it, "op_has_indexed_property");
        out.printf("%s, %s, %s", registerName(dst).data(), registerName(base).data(), registerName(propertyName).data());
        dumpArrayProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_has_structure_property: {
        int dst = it[1].u.operand;
        int base = it[2].u.operand;
        int propertyName = it[3].u.operand;
        int enumerator = it[4].u.operand;
        printLocationAndOp(out, location, it, "op_has_structure_property");
        out.printf("%s, %s, %s, %s", registerName(dst).data(), registerName(base).data(), registerName(propertyName).data(), registerName(enumerator).data());
        it += OPCODE_LENGTH(op_has_structure_property) - 1;
        break;
    }
    case op_has_generic_property: {
        int dst = it[1].u.operand;
        int base = it[2].u.operand;
        int propertyName = it[3].u.operand;
        printLocationAndOp(out, location, it, "op_has_generic_property");
        out.printf("%s, %s, %s", registerName(dst).data(), registerName(base).data(), registerName(propertyName).data());
        it += OPCODE_LENGTH(op_has_generic_property) - 1;
        break;
    }
    case op_get_direct_pname: {
        int dst = (++it)->u.operand;
        int base = (++it)->u.operand;
        int propertyName = (++it)->u.operand;
        int index = (++it)->u.operand;
        int enumerator = (++it)->u.operand;
        printLocationAndOp(out, location, it, "op_get_direct_pname");
        out.printf("%s, %s, %s, %s, %s", registerName(dst).data(), registerName(base).data(), registerName(propertyName).data(), registerName(index).data(), registerName(enumerator).data());
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;

    }
    case op_get_property_enumerator: {
        int dst = it[1].u.operand;
        int base = it[2].u.operand;
        printLocationAndOp(out, location, it, "op_get_property_enumerator");
        out.printf("%s, %s", registerName(dst).data(), registerName(base).data());
        it += OPCODE_LENGTH(op_get_property_enumerator) - 1;
        break;
    }
    case op_enumerator_structure_pname: {
        int dst = it[1].u.operand;
        int enumerator = it[2].u.operand;
        int index = it[3].u.operand;
        printLocationAndOp(out, location, it, "op_enumerator_structure_pname");
        out.printf("%s, %s, %s", registerName(dst).data(), registerName(enumerator).data(), registerName(index).data());
        it += OPCODE_LENGTH(op_enumerator_structure_pname) - 1;
        break;
    }
    case op_enumerator_generic_pname: {
        int dst = it[1].u.operand;
        int enumerator = it[2].u.operand;
        int index = it[3].u.operand;
        printLocationAndOp(out, location, it, "op_enumerator_generic_pname");
        out.printf("%s, %s, %s", registerName(dst).data(), registerName(enumerator).data(), registerName(index).data());
        it += OPCODE_LENGTH(op_enumerator_generic_pname) - 1;
        break;
    }
    case op_to_index_string: {
        int dst = it[1].u.operand;
        int index = it[2].u.operand;
        printLocationAndOp(out, location, it, "op_to_index_string");
        out.printf("%s, %s", registerName(dst).data(), registerName(index).data());
        it += OPCODE_LENGTH(op_to_index_string) - 1;
        break;
    }
    case op_push_with_scope: {
        int dst = (++it)->u.operand;
        int newScope = (++it)->u.operand;
        int currentScope = (++it)->u.operand;
        printLocationAndOp(out, location, it, "push_with_scope");
        out.printf("%s, %s, %s", registerName(dst).data(), registerName(newScope).data(), registerName(currentScope).data());
        break;
    }
    case op_get_parent_scope: {
        int dst = (++it)->u.operand;
        int parentScope = (++it)->u.operand;
        printLocationAndOp(out, location, it, "get_parent_scope");
        out.printf("%s, %s", registerName(dst).data(), registerName(parentScope).data());
        break;
    }
    case op_create_lexical_environment: {
        int dst = (++it)->u.operand;
        int scope = (++it)->u.operand;
        int symbolTable = (++it)->u.operand;
        int initialValue = (++it)->u.operand;
        printLocationAndOp(out, location, it, "create_lexical_environment");
        out.printf("%s, %s, %s, %s",
            registerName(dst).data(), registerName(scope).data(), registerName(symbolTable).data(), registerName(initialValue).data());
        break;
    }
    case op_catch: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        void* pointer = getPointer(*(++it));
        printLocationAndOp(out, location, it, "catch");
        out.printf("%s, %s, %p", registerName(r0).data(), registerName(r1).data(), pointer);
        break;
    }
    case op_throw: {
        int r0 = (++it)->u.operand;
        printLocationOpAndRegisterOperand(out, location, it, "throw", r0);
        break;
    }
    case op_throw_static_error: {
        int r0 = (++it)->u.operand;
        ErrorType k1 = static_cast<ErrorType>((++it)->u.unsignedValue);
        printLocationAndOp(out, location, it, "throw_static_error");
        out.printf("%s, ", registerName(r0).data());
        out.print(k1);
        break;
    }
    case op_debug: {
        int debugHookType = (++it)->u.operand;
        int hasBreakpointFlag = (++it)->u.operand;
        printLocationAndOp(out, location, it, "debug");
        out.printf("%s, %d", debugHookName(debugHookType), hasBreakpointFlag);
        break;
    }
    case op_identity_with_profile: {
        int r0 = (++it)->u.operand;
        ++it; // Profile top half
        ++it; // Profile bottom half
        printLocationAndOp(out, location, it, "identity_with_profile");
        out.printf("%s", registerName(r0).data());
        break;
    }
    case op_unreachable: {
        printLocationAndOp(out, location, it, "unreachable");
        break;
    }
    case op_end: {
        int r0 = (++it)->u.operand;
        printLocationOpAndRegisterOperand(out, location, it, "end", r0);
        break;
    }
    case op_resolve_scope_for_hoisting_func_decl_in_eval: {
        int r0 = (++it)->u.operand;
        int scope = (++it)->u.operand;
        int id0 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "resolve_scope_for_hoisting_func_decl_in_eval");
        out.printf("%s, %s, %s", registerName(r0).data(), registerName(scope).data(), idName(id0, identifier(id0)).data());
        break;
    }
    case op_resolve_scope: {
        int r0 = (++it)->u.operand;
        int scope = (++it)->u.operand;
        int id0 = (++it)->u.operand;
        ResolveType resolveType = static_cast<ResolveType>((++it)->u.operand);
        int depth = (++it)->u.operand;
        void* pointer = getPointer(*(++it));
        printLocationAndOp(out, location, it, "resolve_scope");
        out.printf("%s, %s, %s, <%s>, %d, %p", registerName(r0).data(), registerName(scope).data(), idName(id0, identifier(id0)).data(), resolveTypeName(resolveType), depth, pointer);
        break;
    }
    case op_get_from_scope: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int id0 = (++it)->u.operand;
        GetPutInfo getPutInfo = GetPutInfo((++it)->u.operand);
        ++it; // Structure
        int operand = (++it)->u.operand; // Operand
        printLocationAndOp(out, location, it, "get_from_scope");
        out.print(registerName(r0), ", ", registerName(r1));
        if (static_cast<unsigned>(id0) == UINT_MAX)
            out.print(", anonymous");
        else
            out.print(", ", idName(id0, identifier(id0)));
        out.print(", ", getPutInfo.operand(), "<", resolveModeName(getPutInfo.resolveMode()), "|", resolveTypeName(getPutInfo.resolveType()), "|", initializationModeName(getPutInfo.initializationMode()), ">, ", operand);
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_put_to_scope: {
        int r0 = (++it)->u.operand;
        int id0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        GetPutInfo getPutInfo = GetPutInfo((++it)->u.operand);
        ++it; // Structure
        int operand = (++it)->u.operand; // Operand
        printLocationAndOp(out, location, it, "put_to_scope");
        out.print(registerName(r0));
        if (static_cast<unsigned>(id0) == UINT_MAX)
            out.print(", anonymous");
        else
            out.print(", ", idName(id0, identifier(id0)));
        out.print(", ", registerName(r1), ", ", getPutInfo.operand(), "<", resolveModeName(getPutInfo.resolveMode()), "|", resolveTypeName(getPutInfo.resolveType()), "|", initializationModeName(getPutInfo.initializationMode()), ">, <structure>, ", operand);
        break;
    }
    case op_get_from_arguments: {
        int r0 = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        int offset = (++it)->u.operand;
        printLocationAndOp(out, location, it, "get_from_arguments");
        out.printf("%s, %s, %d", registerName(r0).data(), registerName(r1).data(), offset);
        dumpValueProfiling(out, it, hasPrintedProfiling);
        break;
    }
    case op_put_to_arguments: {
        int r0 = (++it)->u.operand;
        int offset = (++it)->u.operand;
        int r1 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "put_to_arguments");
        out.printf("%s, %d, %s", registerName(r0).data(), offset, registerName(r1).data());
        break;
    }
    case op_yield: {
        int r0 = (++it)->u.operand;
        unsigned yieldPoint = (++it)->u.unsignedValue;
        int r1 = (++it)->u.operand;
        printLocationAndOp(out, location, it, "yield");
        out.printf("%s, %u, %s", registerName(r0).data(), yieldPoint, registerName(r1).data());
        break;
    }
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
    dumpProfilesForBytecodeOffset(out, location, hasPrintedProfiling);
    out.print("\n");
}

template<class Block>
void BytecodeDumper<Block>::dumpBytecode(Block* block, PrintStream& out, const typename Block::Instruction* begin, const typename Block::Instruction*& it, const StubInfoMap& stubInfos, const CallLinkInfoMap& callLinkInfos)
{
    BytecodeDumper dumper(block, begin);
    dumper.dumpBytecode(out, begin, it, stubInfos, callLinkInfos);
}

template<class Block>
void BytecodeDumper<Block>::dumpIdentifiers(PrintStream& out)
{
    if (size_t count = block()->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 != count);
    }
}

template<class Block>
void BytecodeDumper<Block>::dumpConstants(PrintStream& out)
{
    if (!block()->constantRegisters().isEmpty()) {
        out.printf("\nConstants:\n");
        size_t i = 0;
        for (const auto& constant : block()->constantRegisters()) {
            const char* sourceCodeRepresentationDescription = nullptr;
            switch (block()->constantsSourceCodeRepresentation()[i]) {
            case SourceCodeRepresentation::Double:
                sourceCodeRepresentationDescription = ": in source as double";
                break;
            case SourceCodeRepresentation::Integer:
                sourceCodeRepresentationDescription = ": in source as integer";
                break;
            case SourceCodeRepresentation::Other:
                sourceCodeRepresentationDescription = "";
                break;
            }
            out.printf("   k%u = %s%s\n", static_cast<unsigned>(i), toCString(constant.get()).data(), sourceCodeRepresentationDescription);
            ++i;
        }
    }
}

template<class Block>
void BytecodeDumper<Block>::dumpRegExps(PrintStream& out)
{
    if (size_t count = block()->numberOfRegExps()) {
        out.printf("\nm_regexps:\n");
        size_t i = 0;
        do {
            out.printf("  re%u = %s\n", static_cast<unsigned>(i), regexpToSourceString(block()->regexp(i)).data());
            ++i;
        } while (i < count);
    }
}

template<class Block>
void BytecodeDumper<Block>::dumpExceptionHandlers(PrintStream& out)
{
    if (unsigned count = block()->numberOfExceptionHandlers()) {
        out.printf("\nException Handlers:\n");
        unsigned i = 0;
        do {
            const auto& handler = block()->exceptionHandler(i);
            out.printf("\t %d: { start: [%4d] end: [%4d] target: [%4d] } %s\n", i + 1, handler.start, handler.end, handler.target, handler.typeName());
            ++i;
        } while (i < count);
    }
}

template<class Block>
void BytecodeDumper<Block>::dumpSwitchJumpTables(PrintStream& out)
{
    if (unsigned count = block()->numberOfSwitchJumpTables()) {
        out.printf("Switch Jump Tables:\n");
        unsigned i = 0;
        do {
            out.printf("  %1d = {\n", i);
            const auto& switchJumpTable = block()->switchJumpTable(i);
            int entry = 0;
            auto end = switchJumpTable.branchOffsets.end();
            for (auto iter = switchJumpTable.branchOffsets.begin(); iter != end; ++iter, ++entry) {
                if (!*iter)
                    continue;
                out.printf("\t\t%4d => %04d\n", entry + switchJumpTable.min, *iter);
            }
            out.printf("      }\n");
            ++i;
        } while (i < count);
    }
}

template<class Block>
void BytecodeDumper<Block>::dumpStringSwitchJumpTables(PrintStream& out)
{
    if (unsigned count = block()->numberOfStringSwitchJumpTables()) {
        out.printf("\nString Switch Jump Tables:\n");
        unsigned i = 0;
        do {
            out.printf("  %1d = {\n", i);
            const auto& stringSwitchJumpTable = block()->stringSwitchJumpTable(i);
            auto end = stringSwitchJumpTable.offsetTable.end();
            for (auto iter = stringSwitchJumpTable.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 < count);
    }
}

template<class Block>
void BytecodeDumper<Block>::dumpBlock(Block* block, const typename Block::UnpackedInstructions& instructions, PrintStream& out, const StubInfoMap& stubInfos, const CallLinkInfoMap& callLinkInfos)
{
    size_t instructionCount = 0;

    for (size_t i = 0; i < instructions.size(); i += opcodeLengths[Interpreter::getOpcodeID(instructions[i])])
        ++instructionCount;

    out.print(*block);
    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)),
        block->numParameters(), block->numCalleeLocals(), block->m_numVars);
    out.print("; scope at ", block->scopeRegister());
    out.printf("\n");

    const auto* begin = instructions.begin();
    const auto* end = instructions.end();
    BytecodeDumper<Block> dumper(block, begin);
    for (const auto* it = begin; it != end; ++it)
        dumper.dumpBytecode(out, begin, it, stubInfos, callLinkInfos);

    dumper.dumpIdentifiers(out);
    dumper.dumpConstants(out);
    dumper.dumpRegExps(out);
    dumper.dumpExceptionHandlers(out);
    dumper.dumpSwitchJumpTables(out);
    dumper.dumpStringSwitchJumpTables(out);

    out.printf("\n");
}

template class BytecodeDumper<UnlinkedCodeBlock>;
template class BytecodeDumper<CodeBlock>;

}