lldb/source/Core/Disassembler.cpp

//===-- Disassembler.cpp ----------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "lldb/Core/Disassembler.h"

// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-private.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/Timer.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"

#define DEFAULT_DISASM_BYTE_SIZE 32

using namespace lldb;
using namespace lldb_private;


Disassembler*
Disassembler::FindPlugin (const ArchSpec &arch)
{
    Timer scoped_timer (__PRETTY_FUNCTION__,
                        "Disassembler::FindPlugin (arch = %s)",
                        arch.AsCString());

    std::auto_ptr<Disassembler> disassembler_ap;
    DisassemblerCreateInstance create_callback;
    for (uint32_t idx = 0; (create_callback = PluginManager::GetDisassemblerCreateCallbackAtIndex(idx)) != NULL; ++idx)
    {
        disassembler_ap.reset (create_callback(arch));

        if (disassembler_ap.get())
            return disassembler_ap.release();
    }
    return NULL;
}

bool
Disassembler::Disassemble
(
    const ArchSpec &arch,
    const ExecutionContext &exe_ctx,
    uint32_t mixed_context_lines,
    Stream &strm
)
{
    Disassembler *disassembler = Disassembler::FindPlugin(arch);

    if (disassembler)
    {
        lldb::addr_t addr = LLDB_INVALID_ADDRESS;
        size_t byte_size = 0;
        if (exe_ctx.frame)
        {
            SymbolContext sc(exe_ctx.frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol));
            if (sc.function)
            {
                addr = sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(exe_ctx.process);
                if (addr != LLDB_INVALID_ADDRESS)
                    byte_size = sc.function->GetAddressRange().GetByteSize();
            }
            else if (sc.symbol && sc.symbol->GetAddressRangePtr())
            {
                addr = sc.symbol->GetAddressRangePtr()->GetBaseAddress().GetLoadAddress(exe_ctx.process);
                if (addr != LLDB_INVALID_ADDRESS)
                {
                    byte_size = sc.symbol->GetAddressRangePtr()->GetByteSize();
                    if (byte_size == 0)
                        byte_size = DEFAULT_DISASM_BYTE_SIZE;
                }
            }
            else
            {
                addr = exe_ctx.frame->GetPC().GetLoadAddress(exe_ctx.process);
                if (addr != LLDB_INVALID_ADDRESS)
                    byte_size = DEFAULT_DISASM_BYTE_SIZE;
            }
        }

        if (byte_size)
        {
            DataExtractor data;
            size_t bytes_disassembled = disassembler->ParseInstructions (&exe_ctx, eAddressTypeLoad, addr, byte_size, data);
            if (bytes_disassembled == 0)
            {
                return false;
            }
            else
            {
                // We got some things disassembled...
                size_t num_instructions = disassembler->GetInstructionList().GetSize();
                uint32_t offset = 0;
                SymbolContext sc;
                SymbolContext prev_sc;
                AddressRange sc_range;
                if (mixed_context_lines)
                    strm.IndentMore ();

                for (size_t i=0; i<num_instructions; ++i)
                {
                    Disassembler::Instruction *inst = disassembler->GetInstructionList().GetInstructionAtIndex (i);
                    if (inst)
                    {
                        lldb::addr_t curr_addr = addr + offset;
                        if (mixed_context_lines)
                        {
                            if (!sc_range.ContainsLoadAddress (curr_addr, exe_ctx.process))
                            {
                                prev_sc = sc;
                                Address curr_so_addr;
                                Process *process = exe_ctx.process;
                                if (process && process->ResolveLoadAddress (curr_addr, curr_so_addr))
                                {
                                    if (curr_so_addr.GetSection())
                                    {
                                        Module *module = curr_so_addr.GetSection()->GetModule();
                                        uint32_t resolved_mask = module->ResolveSymbolContextForAddress(curr_so_addr, eSymbolContextEverything, sc);
                                        if (resolved_mask)
                                        {
                                            sc.GetAddressRange (eSymbolContextEverything, sc_range);
                                            if (sc != prev_sc)
                                            {
                                                if (offset != 0)
                                                    strm.EOL();

                                                sc.DumpStopContext(&strm, process, curr_so_addr);

                                                if (sc.comp_unit && sc.line_entry.IsValid())
                                                {
                                                    Debugger::GetSharedInstance().GetSourceManager().DisplaySourceLinesWithLineNumbers (
                                                            sc.line_entry.file,
                                                            sc.line_entry.line,
                                                            mixed_context_lines,
                                                            mixed_context_lines,
                                                            mixed_context_lines ? "->" : "",
                                                            &strm);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        if (mixed_context_lines)
                            strm.IndentMore ();
                        strm.Indent();
                        size_t inst_byte_size = inst->GetByteSize();
                        //inst->Dump(&strm, curr_addr, &data, offset);  // Do dump opcode bytes
                        inst->Dump(&strm, curr_addr, NULL, offset, exe_ctx, false); // Don't dump opcode bytes
                        strm.EOL();
                        offset += inst_byte_size;
                        if (mixed_context_lines)
                            strm.IndentLess ();
                    }
                    else
                    {
                        break;
                    }
                }
                if (mixed_context_lines)
                    strm.IndentLess ();

            }
        }
        return true;
    }
    return false;
}

Disassembler::Instruction::Instruction()
{
}

Disassembler::Instruction::~Instruction()
{
}


Disassembler::InstructionList::InstructionList() :
    m_instructions()
{
}

Disassembler::InstructionList::~InstructionList()
{
}

size_t
Disassembler::InstructionList::GetSize() const
{
    return m_instructions.size();
}


Disassembler::Instruction *
Disassembler::InstructionList::GetInstructionAtIndex (uint32_t idx)
{
    if (idx < m_instructions.size())
        return m_instructions[idx].get();
    return NULL;
}

const Disassembler::Instruction *
Disassembler::InstructionList::GetInstructionAtIndex (uint32_t idx) const
{
    if (idx < m_instructions.size())
        return m_instructions[idx].get();
    return NULL;
}

void
Disassembler::InstructionList::Clear()
{
  m_instructions.clear();
}

void
Disassembler::InstructionList::AppendInstruction (Instruction::shared_ptr &inst_sp)
{
    if (inst_sp)
        m_instructions.push_back(inst_sp);
}


size_t
Disassembler::ParseInstructions
(
    const ExecutionContext *exe_ctx,
    lldb::AddressType addr_type,
    lldb::addr_t addr,
    size_t byte_size,
    DataExtractor& data
)
{
    Process *process = exe_ctx->process;

    if (process == NULL)
        return 0;

    DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0'));

    Error error;
    if (process->GetTarget().ReadMemory (addr_type, addr, data_sp->GetBytes(), data_sp->GetByteSize(), error, NULL))
    {
        data.SetData(data_sp);
        data.SetByteOrder(process->GetByteOrder());
        data.SetAddressByteSize(process->GetAddressByteSize());
        return ParseInstructions (data, 0, UINT32_MAX, addr);
    }

    return 0;
}

//----------------------------------------------------------------------
// Disassembler copy constructor
//----------------------------------------------------------------------
Disassembler::Disassembler(const ArchSpec& arch) :
    m_arch (arch),
    m_instruction_list(),
    m_base_addr(LLDB_INVALID_ADDRESS)
{

}

//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
Disassembler::~Disassembler()
{
}

Disassembler::InstructionList &
Disassembler::GetInstructionList ()
{
    return m_instruction_list;
}

const Disassembler::InstructionList &
Disassembler::GetInstructionList () const
{
    return m_instruction_list;
}