debughwi.c

ARM入门的好帮手.包含了从简单到相对较复杂的程序.

    count = unpack_message(BUFFERDATA(*buffer), "%w%w%w%w%w%b%b", &reason,
                           &debugID, &OSinfo1, &OSinfo2, &spv.pointAddress,
                           &spv.pointType, &spv.pointDatatype);

    if ((spv.pointType & 0x7) > 4)
        unpack_message(BUFFERDATA(*buffer) + count, "%w", &spv.pointBound);

    status = angelOS_SetWatch(OSinfo1, OSinfo2, &spv, &pvr);

    return msgsend(CI_HADP, "%w%w%w%w%w%w%w%w",
                   (ADP_SetWatch | TtoH), debugID, OSinfo1, OSinfo2, status,
                   pvr.pointHandle, pvr.pointRaddress, pvr.pointRbound);
}

static int 
gendbg_clearwatch(p_Buffer * buffer, void *stateptr)
{
    /* Clears a watch point. */
    int reason, debugID, OSinfo1, OSinfo2;
    word handle;
    word status;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_clearwatch:\n"));
    unpack_message(BUFFERDATA(*buffer), "%w%w%w%w%w", &reason, &debugID,
                   &OSinfo1, &OSinfo2, &handle);

    status = angelOS_ClearWatch(OSinfo1, OSinfo2, handle);

    return msgsend(CI_HADP, "%w%w%w%w%w", (ADP_ClearWatch | TtoH),
                   debugID, OSinfo1, OSinfo2, status);
}

static int 
gendbg_execute(p_Buffer * buffer, void *stateptr)
{
    /* Start executing from the stored CPU state. */
    int debugID, OSinfo1, OSinfo2;
    word status = RDIError_NoError;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_execute:\n"));
    unpack_message(BUFFERDATA(*buffer) + 4, "%w%w%w", &debugID, &OSinfo1,
                   &OSinfo2);

#if DEBUG == 1
    angelOS_PrintState(OSinfo1, OSinfo2);
#endif

    status = RDIError_NoError;

    if (!msgsend(CI_HADP, "%w%w%w%w%w", (ADP_Execute | TtoH), debugID,
                 OSinfo1, OSinfo2, status))
    {
        angelOS_Execute(OSinfo1, OSinfo2);
        return 0;
    }
    else
        return -1;
}

static int 
gendbg_step(p_Buffer * buffer, void *stateptr)
{
    /* Step through program. */
    int debugID, OSinfo1, OSinfo2;
    word ninstr, status = RDIError_NoError;
    void *handle;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_step:\n"));
    unpack_message(BUFFERDATA(*buffer) + 4, "%w%w%w%w", &debugID, &OSinfo1,
                   &OSinfo2, &ninstr);

    status = angelOS_SetupStep(OSinfo1, OSinfo2, ninstr, &handle);

    if (!msgsend(CI_HADP, "%w%w%w%w%w", (ADP_Step | TtoH), debugID, OSinfo1,
                 OSinfo2, status))
    {
        if (status == RDIError_NoError)
        {
            (void)angelOS_DoStep(handle);
            return 0;
        }
    }

    return -1;
}

static int 
gendbg_interruptrequest(p_Buffer * buffer, void *stateptr)
{
    /* Stop program execution. */
    int debugID, OSinfo1, OSinfo2;
    word status, send_status;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_interruptrequest:\n"));
    unpack_message(BUFFERDATA(*buffer) + 4, "%w%w%w", &debugID, &OSinfo1,
                   &OSinfo2);

    status = angelOS_InterruptExecution(OSinfo1, OSinfo2);

    /* send the reply */
    send_status = msgsend(CI_HADP, "%w%w%w%w%w", (ADP_InterruptRequest | TtoH),
                          debugID, OSinfo1, OSinfo2, status);

#ifndef ICEMAN2
    if (status == RDIError_NoError && send_status == RDIError_NoError)
    {
        /* send the stopped message and await a reply */
        debug_ThreadStopped(OSinfo1, OSinfo2, ADP_Stopped_UserInterruption, 0);
    }
#endif

    return RDIError_NoError;
}

/**********************************************************************/

/*
 * Hardware emulation message handler functions
 */
static int 
gendbg_hw_emul(p_Buffer * buffer, void *stateptr)
{
    unsigned int subreason;
    int err;

    LogInfo(LOG_DEBUGHWI, ( "gendbg_hw_emul:\n"));
    subreason = PREAD(LE, BUFFERDATA(*buffer) + 16);
    subreason &= 0xFFFF;        /* Mask out channel information. */

    /* Range check subreason code. */
    if (subreason < hwemul_hfptr_max)
        err = hwemul_hfptr[subreason] (buffer, stateptr);
    else
        err = -1;

    return err;
}

static int 
hwemul_supported(p_Buffer * buffer, void *stateptr)
{
    IGNORE(buffer);
    IGNORE(stateptr);

    return -1;
}

static int 
hwemul_memoryaccess(p_Buffer * buffer, void *stateptr)
{
    IGNORE(buffer);
    IGNORE(stateptr);

    return -1;
}

static int 
hwemul_memorymap(p_Buffer * buffer, void *stateptr)
{
    IGNORE(buffer);
    IGNORE(stateptr);

    return -1;
}

static int 
hwemul_setcpuspeed(p_Buffer * buffer, void *stateptr)
{
    IGNORE(buffer);
    IGNORE(stateptr);

    return -1;
}

static int 
hwemul_readclock(p_Buffer * buffer, void *stateptr)
{
    IGNORE(buffer);
    IGNORE(stateptr);

    return -1;
}

/**********************************************************************/

/*
 * ICEbreaker message handler functions
 */
static int 
gendbg_iceb(p_Buffer * buffer, void *stateptr)
{
    unsigned int subreason;
    int err;

    LogInfo(LOG_DEBUGHWI, ( "gendbg_iceb:\n"));
    subreason = PREAD(LE, BUFFERDATA(*buffer) + 16);
    subreason &= 0xFFFF;        /* Mask out channel information. */

#ifdef ICEMAN2
    /* Range check subreason code. */
    if (subreason < iceb_hfptr_max)
        err = iceb_hfptr[subreason] (buffer, stateptr);
    else
        err = -1;
#else
    /* No iceb support in Angel */
    IGNORE(stateptr);
    err = -1;
#endif

    return err;
}

/**********************************************************************/

/*
 * ICEman message handler functions
 */
static int 
gendbg_icem(p_Buffer * buffer, void *stateptr)
{
    unsigned int subreason;
    int err;

    LogInfo(LOG_DEBUGHWI, ( "gendbg_icem:\n"));
    subreason = PREAD(LE, BUFFERDATA(*buffer) + 16);
    subreason &= 0xFFFF;        /* Mask out channel information. */

#ifdef ICEMAN2
    /* Range check subreason code. */
    if (subreason < icem_hfptr_max)
        err = icem_hfptr[subreason] (buffer, stateptr);
    else
        err = -1;
#else
    /* No icem support in Angel */
    IGNORE(stateptr);
    err = -1;
#endif

    return err;
}

/**********************************************************************/

/*
 * Profiling message handler functions
 */
static int 
gendbg_profile(p_Buffer * buffer, void *stateptr)
{
    unsigned int subreason;
    int err;

    LogInfo(LOG_DEBUGHWI, ( "DEBUG: Entered function gendbg_profile.\n"));
    subreason = PREAD(LE, BUFFERDATA(*buffer) + 16);
    subreason &= 0xFFFF;        /* Mask out channel information. */

#if PROFILE_SUPPORTED
    /* Range check subreason code. */
    if (subreason < profile_hfptr_max)
        err = profile_hfptr[subreason] (buffer, stateptr);
    else
        err = -1;
#else
    IGNORE(stateptr);
    IGNORE(buffer);
    err = -1;
#endif

    return err;
}

static int 
gendbg_initialiseapp(p_Buffer * buffer, void *stateptr)
{
    /* Initialise Application */
    int debugID, OSinfo1, OSinfo2;
    int status;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_initialiseapp:\n"));
    unpack_message(BUFFERDATA(*buffer) + 4, "%w%w%w", &debugID, &OSinfo1,
                   &OSinfo2);

    status = angelOS_InitialiseApplication(OSinfo1, OSinfo2);

    return msgsend(CI_HADP, "%w%w%w%w%w",
                   (ADP_InitialiseApplication | TtoH),
                   debugID, OSinfo1, OSinfo2, status);
}

static int 
gendbg_end(p_Buffer * buffer, void *stateptr)
{
    int debugID, OSinfo1, OSinfo2;
    word status = RDIError_NoError;

    IGNORE(stateptr);

    LogInfo(LOG_DEBUGHWI, ( "gendbg_end:\n"));
    unpack_message(BUFFERDATA(*buffer) + 4, "%w%w%w", &debugID, &OSinfo1,
                   &OSinfo2);

    status = msgsend(CI_HADP, "%w%w%w%w%w", (ADP_End | TtoH),
                     debugID, OSinfo1, OSinfo2, status);

    (void)angelOS_End(debugID);
    
    return status;
}

/* HADP message handlers */
const handler_function_pointer hfptr[] =
{
    gendbg_unrecognised,
    gendbg_info,
    gendbg_ctrl,
    gendbg_read,
    gendbg_write,
    gendbg_cpuread,
    gendbg_cpuwrite,
    gendbg_cpread,
    gendbg_cpwrite,
    gendbg_setbreak,
    gendbg_clearbreak,
    gendbg_setwatch,
    gendbg_clearwatch,
    gendbg_execute,
    gendbg_step,
    gendbg_interruptrequest,
    gendbg_hw_emul,
    gendbg_iceb,
    gendbg_icem,
    gendbg_profile,
    gendbg_initialiseapp,
    gendbg_end
};

const handler_function_pointer hwemul_hfptr[] =
{
    hwemul_supported,
    hwemul_memoryaccess,
    hwemul_memorymap,
    hwemul_setcpuspeed,
    hwemul_readclock
};

const int hfptr_max =
sizeof(hfptr) / sizeof(handler_function_pointer);

const int hwemul_hfptr_max =
sizeof(hwemul_hfptr) / sizeof(handler_function_pointer);

/**********************************************************************/

/* EOF debughwi.c */