TraceCommand.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "pedigree/kernel/debugger/commands/TraceCommand.h"
#include "pedigree/kernel/debugger/DebuggerIO.h"
#include "pedigree/kernel/linker/KernelElf.h"
#include "pedigree/kernel/processor/Disassembler.h"
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/processor/state.h"
#include "pedigree/kernel/utilities/demangle.h"

TraceCommand::TraceCommand() : DebuggerCommand(), m_nExec(-1), m_nInterface(-1)
{
}

TraceCommand::~TraceCommand()
{
}

void TraceCommand::autocomplete(
    const HugeStaticString &input, HugeStaticString &output)
{
}

void TraceCommand::setInterface(int nInterface)
{
    m_nInterface = nInterface;
}

bool TraceCommand::execute(
    const HugeStaticString &input, HugeStaticString &output,
    InterruptState &state, DebuggerIO *pScreen)
{
    m_nExec = -1;
    // Let's enter 'raw' screen mode.
    pScreen->disableCli();

    // Work out where the split will be between the disassembler, reg dump and
    // stacktrace. Give the reg dump 25 columns, hardcoded.
    int nCols = pScreen->getWidth() - 25;
    // Give the disassembler 3/4 of the available lines.
    int nLines = ((pScreen->getHeight() - 2) * 3) / 4;

    static Disassembly disassembly(state);
    disassembly.move(0, 1);
    disassembly.resize(nCols, nLines);
    disassembly.setScrollKeys('o', 'p');

    static Registers registers(state);
    registers.move(nCols + 1, 1);
    registers.resize(24, nLines);
    registers.setScrollKeys('j', 'k');

    static Stacktrace stacktrace(state);
    stacktrace.move(0, nLines + 2);
    stacktrace.resize(pScreen->getWidth(), pScreen->getHeight() - nLines - 3);
    stacktrace.setScrollKeys('n', 'm');

    size_t nInstruction = 0;

    // find the first instruction for the function that we're in right now
    uintptr_t nIp = state.getInstructionPointer();
    uintptr_t nSymStart = 0;
    KernelElf::instance().globalLookupSymbol(nIp, &nSymStart);

    static Disassembler disassembler;
#ifdef BITS_64
    disassembler.setMode(64);
#endif
    disassembler.setLocation(nSymStart);

    uintptr_t nLocation;
    LargeStaticString text;
    while (nInstruction < disassembly.getLineCount())
    {
        nLocation = disassembler.getLocation();
        text.clear();
        disassembler.disassemble(text);
        nInstruction++;
        if (nLocation == state.getInstructionPointer())
            break;
    }

    disassembly.centreOn(nInstruction);

    pScreen->disableRefreshes();
    drawBackground(nCols, nLines, pScreen);
    registers.refresh(pScreen);
    disassembly.refresh(pScreen);
    stacktrace.refresh(pScreen);
    pScreen->enableRefreshes();

    // Here we enter our main runloop.
    bool bContinue = true;
    while (bContinue)
    {
        char c;
        while ((c = pScreen->getChar()) == 0)
            ;
        if (c == 'q')
            break;
        else if (c == 's')
        {
            m_nExec = m_nInterface;
            Processor::setSingleStep(true, state);
            return false;
        }
        else if (c == 'o')
        {
            disassembly.scroll(-1);
            disassembly.refresh(pScreen);
        }
        else if (c == 'p')
        {
            disassembly.scroll(1);
            disassembly.refresh(pScreen);
        }
        else if (c == 'j')
        {
            registers.scroll(-1);
            registers.refresh(pScreen);
        }
        else if (c == 'k')
        {
            registers.scroll(1);
            registers.refresh(pScreen);
        }
        else if (c == 'n')
        {
            stacktrace.scroll(-1);
            stacktrace.refresh(pScreen);
        }
        else if (c == 'm')
        {
            stacktrace.scroll(1);
            stacktrace.refresh(pScreen);
        }
    }

    // Let's enter CLI screen mode again.
    pScreen->enableCli();
    return true;  // Return control to the debugger.
}

void TraceCommand::drawBackground(
    size_t nCols, size_t nLines, DebuggerIO *pScreen)
{
    // Destroy all text.
    pScreen->cls();

    // Clear the top and bottom status lines.
    pScreen->drawHorizontalLine(
        ' ', 0, 0, pScreen->getWidth() - 1, DebuggerIO::White,
        DebuggerIO::Green);
    pScreen->drawHorizontalLine(
        ' ', pScreen->getHeight() - 1, 0, pScreen->getWidth() - 1,
        DebuggerIO::White, DebuggerIO::Green);
    // Write the correct text in the upper status line.
    pScreen->drawString(
        "Pedigree debugger - Execution Tracer", 0, 0, DebuggerIO::White,
        DebuggerIO::Green);
    // Write some helper text in the lower status line.
    pScreen->drawString(
        "s: Step. c: Continue. q: Quit. ?: Current instruction. ?: Breakpoint.",
        pScreen->getHeight() - 1, 0, DebuggerIO::White, DebuggerIO::Green);
    pScreen->drawString(
        "s", pScreen->getHeight() - 1, 0, DebuggerIO::Yellow,
        DebuggerIO::Green);
    pScreen->drawString(
        "c", pScreen->getHeight() - 1, 9, DebuggerIO::Yellow,
        DebuggerIO::Green);
    pScreen->drawString(
        "q", pScreen->getHeight() - 1, 22, DebuggerIO::Yellow,
        DebuggerIO::Green);
    pScreen->drawString(
        " ", pScreen->getHeight() - 1, 31, DebuggerIO::Yellow,
        DebuggerIO::Blue);
    pScreen->drawString(
        " ", pScreen->getHeight() - 1, 55, DebuggerIO::Yellow, DebuggerIO::Red);

    pScreen->drawHorizontalLine(
        '-', nLines + 1, 0, pScreen->getWidth(), DebuggerIO::DarkGrey,
        DebuggerIO::Black);
    pScreen->drawVerticalLine(
        '|', nCols, 1, nLines, DebuggerIO::DarkGrey, DebuggerIO::Black);
}

TraceCommand::Disassembly::Disassembly(InterruptState &state)
    : m_nInstructions(0), m_nFirstInstruction(0), m_nIp(0),
      m_LastLine(0xFFFFFFFF), m_LastInstructionLocation(0)
{
    // Try and count how many lines of instructions we have.
    m_nIp = state.getInstructionPointer();
    uintptr_t nSymStart = 0;
    KernelElf::instance().globalLookupSymbol(m_nIp, &nSymStart);

    Disassembler disassembler;
#ifdef BITS_64
    disassembler.setMode(64);
#endif
    disassembler.setLocation(nSymStart);

    m_nFirstInstruction = nSymStart;
    uintptr_t nLocation = 0;
    LargeStaticString text;
    while (true)
    {
        nLocation = disassembler.getLocation();
        text.clear();
        disassembler.disassemble(text);
        uintptr_t nSym;
        KernelElf::instance().globalLookupSymbol(nLocation, &nSym);
        if (nSym == nLocation && nSym != nSymStart)  // New symbol. Quit.
            break;
        m_nInstructions++;
    }
}

const char *TraceCommand::Disassembly::getLine1(
    size_t index, DebuggerIO::Colour &colour, DebuggerIO::Colour &bgColour)
{
    static LargeStaticString sym;
    if (index == 0)
    {
        // We treat index == 0 slightly differently - it's the symbol name.
        colour = DebuggerIO::Yellow;
        uintptr_t nSym;
        const char *pSym = KernelElf::instance().globalLookupSymbol(
            m_nFirstInstruction, &nSym);
        sym.clear();
        demangle_full(LargeStaticString(pSym), sym);
        sym += ":";
        return sym;
    }
    index--;  // Get rid of index 0.

    size_t nInstruction = 0;

    Disassembler disassembler;
#ifdef BITS_64
    disassembler.setMode(64);
#endif
    LargeStaticString text;
    uintptr_t nLocation = 0;
    // If the stored line counter is the one before ours, we can just take that
    // and advance by one.
    if (index > 0 && m_LastLine == index - 1)
    {
        disassembler.setLocation(m_LastInstructionLocation);
        // Disassemble the (last) instruction.
        disassembler.disassemble(text);
        // Disassemble this instruction.
        nLocation = disassembler.getLocation();
        disassembler.disassemble(text);
    }
    else
    {
        // Disassemble this instruction.
        disassembler.setLocation(m_nFirstInstruction);

        while (nInstruction <= index)
        {
            nLocation = disassembler.getLocation();
            disassembler.disassemble(text);
            nInstruction++;
        }
    }
    // Set the stored line counter.
    m_LastLine = index;
    m_LastInstructionLocation = nLocation;

    // If this is our actual instruction location, put a blue background over
    // it.
    if (nLocation == m_nIp)
        bgColour = DebuggerIO::Blue;

    // We want grey text.
    colour = DebuggerIO::DarkGrey;

    // The text being...
    sym.clear();
    sym.append(nLocation, 16, sizeof(uintptr_t) * 2, '0');
    sym += ' ';
    return sym;
}

const char *TraceCommand::Disassembly::getLine2(
    size_t index, size_t &colOffset, DebuggerIO::Colour &colour,
    DebuggerIO::Colour &bgColour)
{
    static LargeStaticString sym;
    if (index == 0)
    {
        // We treat index == 0 slightly differently - it's the symbol name.
        return 0;
    }
    index--;  // Get rid of index 0.

    size_t nInstruction = 0;

    Disassembler disassembler;
#ifdef BITS_64
    disassembler.setMode(64);
#endif

    uintptr_t nLocation = 0;
    LargeStaticString text;
    if (index == m_LastLine)
    {
        disassembler.setLocation(m_LastInstructionLocation);
        nLocation = m_LastInstructionLocation;
        disassembler.disassemble(text);
    }
    else
    {
        disassembler.setLocation(m_nFirstInstruction);
        while (nInstruction <= index)
        {
            text.clear();
            nLocation = disassembler.getLocation();
            disassembler.disassemble(text);
            nInstruction++;
        }
    }

    // If this is our actual instruction location, put a blue background over
    // it.
    if (nLocation == m_nIp)
        bgColour = DebuggerIO::Blue;

    // We want white text.
    colour = DebuggerIO::White;

    // At offset...
    colOffset = sizeof(uintptr_t) * 2 + 1;

    // The text being...
    sym.clear();
    sym += text;
    uint32_t nLen = sym.length() + colOffset;
    while (nLen++ < width())
        sym += ' ';
    return sym;
}

size_t TraceCommand::Disassembly::getLineCount()
{
    return m_nInstructions + 1;
}

TraceCommand::Registers::Registers(InterruptState &state) : m_State(state)
{
}

const char *TraceCommand::Registers::getLine1(
    size_t index, DebuggerIO::Colour &colour, DebuggerIO::Colour &bgColour)
{
    static LargeStaticString str;
    colour = DebuggerIO::Yellow;
    // We treat index 0 slightly differently.
    if (index == 0)
    {
        str.clear();
        if (m_State.kernelMode())
            str = "Kernel mode";
        else
            str = "User mode";
        return str;
    }
    else
    {
        int nRegister = index - 1;
        str.clear();
        str = m_State.getRegisterName(nRegister);
        return str;
    }
}

const char *TraceCommand::Registers::getLine2(
    size_t index, size_t &colOffset, DebuggerIO::Colour &colour,
    DebuggerIO::Colour &bgColour)
{
    static LargeStaticString str;
    // We treat index 0 slightly differently.
    if (index == 0)
    {
        return 0;
    }
    else
    {
        int nRegister = index - 1;
        str.clear();
        uintptr_t nValue = m_State.getRegister(nRegister);
        str = "0x";
        str.append(nValue, 16, sizeof(uintptr_t) * 2, '0');
        colOffset = width() - 2 * sizeof(uintptr_t) - 2;
        return str;
    }
}

size_t TraceCommand::Registers::getLineCount()
{
    return m_State.getRegisterCount() + 1;
}

TraceCommand::Stacktrace::Stacktrace(InterruptState &state) : m_Bt()
{
    m_Bt.performBacktrace(state);
}

const char *TraceCommand::Stacktrace::getLine1(
    size_t index, DebuggerIO::Colour &colour, DebuggerIO::Colour &bgColour)
{
    static HugeStaticString str;
    str.clear();
    m_Bt.prettyPrint(str, 1, index);
    if (str.length())
        str = str.left(str.length() - 1);
    return str;
}

const char *TraceCommand::Stacktrace::getLine2(
    size_t index, size_t &colOffset, DebuggerIO::Colour &colour,
    DebuggerIO::Colour &bgColour)
{
    return 0;
}

size_t TraceCommand::Stacktrace::getLineCount()
{
    return m_Bt.numStackFrames();
}