DwarfCfiAutomaton.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/DwarfCfiAutomaton.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/debugger/DwarfUnwinder.h"

DwarfCfiAutomaton::DwarfCfiAutomaton()
    : m_InitialState(), m_CurrentState(), m_nCodeAlignmentFactor(),
      m_nDataAlignmentFactor(), m_nStartingPc()
{
}

DwarfCfiAutomaton::~DwarfCfiAutomaton()
{
}

void DwarfCfiAutomaton::initialise(
    const DwarfState &startingState, uintptr_t nCodeLocation, size_t nCodeLen,
    int32_t nCodeAlignmentFactor, int32_t nDataAlignmentFactor,
    uintptr_t nStartingPc)
{
    //   NOTICE("CfiAutomaton starting up at PC=" << Hex << nStartingPc);
    m_nCodeAlignmentFactor = nCodeAlignmentFactor;
    m_nDataAlignmentFactor = nDataAlignmentFactor;
    m_nStartingPc = nStartingPc;

    // Set up our states, initially.
    m_InitialState = startingState;
    m_CurrentState = startingState;

    // Execute the preamble instructions.
    execute(nCodeLocation, nCodeLen, static_cast<uintptr_t>(~0));

    // Save the state.
    m_InitialState = m_CurrentState;
}

DwarfState *DwarfCfiAutomaton::execute(
    uintptr_t nCodeLocation, size_t nCodeLen, uintptr_t nBreakAt)
{
    uintptr_t nCurrentCodeLocation = nCodeLocation;
    uintptr_t nProgramCounter = m_nStartingPc;
    while ((nCurrentCodeLocation < nCodeLocation + nCodeLen) &&
           (nProgramCounter <= nBreakAt))
    {
        executeInstruction(nCurrentCodeLocation, nProgramCounter);
    }
    // If we reached the end of the instruction stream, this state just
    // continues.
    return &m_CurrentState;
}

void DwarfCfiAutomaton::executeInstruction(uintptr_t &nLocation, uintptr_t &nPc)
{
    uint8_t *pLocation = reinterpret_cast<uint8_t *>(nLocation);
    nLocation++;  // nLocation will always increase by at least one.

    if ((pLocation[0] & 0xc0) == DW_CFA_advance_loc)
    {
        uint8_t nDelta = pLocation[0] & 0x3f;
        nPc += nDelta * m_nCodeAlignmentFactor;
        //     NOTICE("DW_CFA_advance_loc (" << Hex << nDelta << ")");
    }
    else if ((pLocation[0] & 0xc0) == DW_CFA_offset)
    {
        uint8_t nRegister = pLocation[0] & 0x3f;
        uint32_t nLocationOffset = 0;
        pLocation = reinterpret_cast<uint8_t *>(nLocation);
        int32_t nOffset = static_cast<int32_t>(
            DwarfUnwinder::decodeUleb128(pLocation, nLocationOffset));
        nLocation += nLocationOffset;
        m_CurrentState.m_RegisterStates[nRegister] = DwarfState::Offset;
        m_CurrentState.m_R[nRegister] = nOffset * m_nDataAlignmentFactor;
        //     NOTICE("DW_CFA_offset (r" << Dec << nRegister << ", " << Hex <<
        //     nOffset * m_nDataAlignmentFactor << ")");
    }
    else if ((pLocation[0] & 0xc0) == DW_CFA_restore)
    {
        //     WARNING("DW_CFA_restore not implemented!");
    }
    else
        switch (pLocation[0])
        {
            case DW_CFA_nop:
            {
                //       NOTICE("DW_CFA_nop");
                break;
            }
            case DW_CFA_set_loc:
            {
                processor_register_t *pAddress =
                    reinterpret_cast<processor_register_t *>(nLocation);
                nPc = *pAddress;
                nLocation += sizeof(processor_register_t);
                //       NOTICE("DW_CFA_set_loc (" << Hex << nPc << ")");
                break;
            }
            case DW_CFA_advance_loc1:
            {
                uint8_t nDelta = *reinterpret_cast<uint8_t *>(nLocation);
                nLocation += 1;
                nPc += nDelta * m_nCodeAlignmentFactor;
                //       NOTICE("DW_CFA_advance_loc1 (" << Hex << nDelta <<
                //       ")");
                break;
            }
            case DW_CFA_advance_loc2:
            {
                uint16_t nDelta = *reinterpret_cast<uint16_t *>(nLocation);
                nLocation += 2;
                nPc += nDelta * m_nCodeAlignmentFactor;
                //       NOTICE("DW_CFA_advance_loc2 (" << Hex << nDelta <<
                //       ")");
                break;
            }
            case DW_CFA_advance_loc4:
            {
                uint32_t nDelta = *reinterpret_cast<uint32_t *>(nLocation);
                nLocation += 4;
                nPc += nDelta * m_nCodeAlignmentFactor;
                //       NOTICE("DW_CFA_advance_loc4 (" << Hex << nDelta <<
                //       ")");
                break;
            }
            //     case DW_CFA_offset_extended:
            //     {
            //     }
            //     case DW_CFA_restore_extended:
            //     {
            //     }
            //     case DW_CFA_undefined:
            //     {
            //     }
            //     case DW_CFA_same_value:
            //     {
            //     }
            //     case DW_CFA_register:
            //     {
            //     }
            //     case DW_CFA_remember_state:
            //     {
            //     }
            //     case DW_CFA_restore_state:
            //     {
            //     }
            case DW_CFA_def_cfa:
            {
                uint32_t nOffset = 0;
                pLocation = reinterpret_cast<uint8_t *>(nLocation);
                m_CurrentState.m_CfaState = DwarfState::ValOffset;
                m_CurrentState.m_CfaRegister =
                    DwarfUnwinder::decodeUleb128(pLocation, nOffset);
                m_CurrentState.m_CfaOffset = static_cast<ssize_t>(
                    DwarfUnwinder::decodeUleb128(pLocation, nOffset));
                nLocation += nOffset;
                //       NOTICE("DW_CFA_def_cfa (" << Hex <<
                //       m_CurrentState.m_CfaRegister << ", " <<
                //       m_CurrentState.m_CfaOffset << ")");
                break;
            }
            case DW_CFA_def_cfa_register:
            {
                uint32_t nOffset = 0;
                pLocation = reinterpret_cast<uint8_t *>(nLocation);
                m_CurrentState.m_CfaRegister =
                    DwarfUnwinder::decodeUleb128(pLocation, nOffset);
                nLocation += nOffset;
                //       NOTICE("DW_CFA_def_cfa_reg (" << Hex <<
                //       m_CurrentState.m_CfaRegister << ")");
                break;
            }
            case DW_CFA_def_cfa_offset:
            {
                uint32_t nOffset = 0;
                pLocation = reinterpret_cast<uint8_t *>(nLocation);
                m_CurrentState.m_CfaOffset = static_cast<ssize_t>(
                    DwarfUnwinder::decodeUleb128(pLocation, nOffset));
                nLocation += nOffset;
                //       NOTICE("DW_CFA_def_cfa_offset (" << Hex <<
                //       m_CurrentState.m_CfaOffset << ")");
                break;
            }
            //     case DW_CFA_def_cfa_expression:
            //     {
            //     }
            //     case DW_CFA_expression:
            //     {
            //     }
            case DW_CFA_offset_extended_sf:
            {
                uint32_t nLocationOffset = 0;
                pLocation = reinterpret_cast<uint8_t *>(nLocation);
                uint32_t nRegister =
                    DwarfUnwinder::decodeUleb128(pLocation, nLocationOffset);
                nLocation += nLocationOffset;

                nLocationOffset = 0;
                pLocation = reinterpret_cast<uint8_t *>(nLocation);
                int32_t nOffset =
                    DwarfUnwinder::decodeSleb128(pLocation, nLocationOffset);

                nLocation += nLocationOffset;

                m_CurrentState.m_RegisterStates[nRegister] = DwarfState::Offset;
                m_CurrentState.m_R[nRegister] =
                    nOffset * m_nDataAlignmentFactor;
                //      NOTICE("DW_CFA_offset_extended_sf (r" << Dec <<
                //      nRegister << ", " << Hex << nOffset *
                //      m_nDataAlignmentFactor << ")");
                break;
            }
            //     case DW_CFA_def_cfa_sf:
            //     {
            //     }
            //     case DW_CFA_def_cfa_offset_sf:
            //     {
            //     }
            //     case DW_CFA_val_offset:
            //     {
            //     }
            //     case DW_CFA_val_offset_sf:
            //     {
            //     }
            //     case DW_CFA_val_expression:
            //     {
            //     }
            //     case DW_CFA_lo_user:
            //     {
            //     }
            //     case DW_CFA_hi_user:
            //     {
            //     }
            case DW_CFA_GNU_args_size:
            {
                uint32_t nLocationOffset = 0;
                pLocation = reinterpret_cast<uint8_t *>(nLocation);
                DwarfUnwinder::decodeUleb128(pLocation, nLocationOffset);
                nLocation += nLocationOffset;
                break;
            }
            default:
                ERROR(
                    "Unrecognised DWARF CFA instruction: " << Hex
                                                           << pLocation[0]);
                nPc++;
        }
}