/*---------------------------------------------------------------------*
 *  Copyright (C) 2004 BroadOn Communications Corp.
 *                 
 *  $RCSfile: gdbbrk.c,v $ (derived from rmonbrk.c)
 *  $Revision: 1.2 $
 *  $Date: 2004/02/17 23:20:02 $
 *---------------------------------------------------------------------*/

/* 
 * This file provides the functions for handling breakpoints for the GDB stub
 * for debugging the BBPlayer
 */

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

Program: GDB Stub for the BBPlayer 
File:    gdbbrk.c (derived from rmonbrk.c with RSP functionality removed)
Author:  Angel Chang
Purpose: The breakpoint access functions

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

#ifndef _FINALROM

#include "ultragdb.h"

#define __GDB_NBREAKS         16    /* number of breakpoints */
#define GDB_MSG_EXCEPTION 0x8004

/*
    The following macro defines a breakpoint instruction with a
    built in breakpoint number. Thus, we always know which
    breakpoint was hit as soon as the break occurs, saving the
    time and trouble of actually looking it up. We add 16 to the
    break number to stay away from compiler-defined breaks and
    user set breaks.
*/

#define __GDB_BREAKINST(n) (0x0d | (((n+16) & 0xfffff) << 6))

/*
    The following structure holds information about active breakpoints.
    The 0th entry is the temproary breakpoint, inserted when the user
    specifies "run to location" and removed when ANY breakpoint is
    encountered. There are also (__GDB_NBREAKS - 1) persistent breakpoints.
    These must be manually set and cleared. On encountering one, it
    remains set, although the original contents of memory may be
    requested from time to time.

    An alternate breakpoint is used for single stepping the CPU.
    Since we may step over a conditional branch, we don't know which
    way the branch will go. Thus, we set breakpoints at both locations
    and run until either is hit. This means that sometimes we need two
    breaks to single step, in which case we use break 0 and break alt.

    The RSP breakpoints use the same structure. Since single step
    is implemented in hardware, we don't need the temp breaks.
*/

/* TODO: What happens if the temp/permanent breakpoints overlap? */

typedef struct {
    u32 * breakAddress;
    u32 oldInstruction;
} BREAKINFO;

static BREAKINFO __gdbBreakpoints[__GDB_NBREAKS];    /* the CPU breaks */
static BREAKINFO __gdbTmpBreaks[2];   /* temporary breaks for stepping */

/************************************************************************
Function: (static) __gdbSetBreakpoint
Args: BREAKINFO* brk - Pointer to breakpoint to set
      u32*           - Address of breakpoint
Purpose: This function sets a breakpoint at the specified address (addr)
         and stores the old instruction and the address in brk.
************************************************************************/
static void __gdbSetBreakpoint(BREAKINFO* brk, u32* addr)
{
    if (addr == NULL) return;
    if (brk == NULL) return;

    brk->oldInstruction = *addr;
    *addr = __GDB_BREAKINST( 0 );
    gdbWritebackDCache( addr, 4 );
    gdbInvalICache( addr, 4 );
    brk->breakAddress = addr;

}

/************************************************************************
Function: (static) __gdbClearBreakpoint
Args: BREAKINFO* brk - Pointer to breakpoint to clear
Purpose: This function clears the breakpoint by restoring the old 
         instruction and clearoing the remembered breakpoint address.
************************************************************************/
static void __gdbClearBreakpoint(BREAKINFO* brk)
{
    u32 inst;

    if (brk && brk->breakAddress)
    {
        if (gdbDebug & GDB_DEBUG_SHOW_INFO)
            GDB_PRINTF( "%s: Clear Break @ 0x%x\n", 
                        gdb_module_name, brk->breakAddress );

        /* Check to make sure one was really there */
        inst = *brk->breakAddress;
        if ( (inst & GDB_BREAKMASK) == 0xd )
        {
            *(brk->breakAddress) = brk->oldInstruction;
            gdbWritebackDCache( brk->breakAddress, 4 );
            gdbInvalICache( brk->breakAddress, 4 );
        }
        brk->breakAddress = 0;
    }
}

/************************************************************************
Function: (static) __gdbFindBreak
Args: addr - Address of breakpoint
Returns: int  - Returns breakpoint index, otherwise error type (<0)
         0 to __GDB_NBREAK (breakpoint index) on success
         GDB_ERROR_INVALID_ADDRESS if the address does not 
                                   correspond to a breakpoint
Purpose: This function finds the breakpoint at the given address
         permanent breakpoint was set.
************************************************************************/
static BREAKINFO* __gdbFindBreak(u32* addr)
{
    register BREAKINFO * whichBreak;
    u32 i;

    for (i = 0; i < __GDB_NBREAKS; i++)
    {
        whichBreak = &__gdbBreakpoints[i];
        if (whichBreak->breakAddress == addr)
            return whichBreak;
    }

    return NULL; /* break not set at this address */
}

/************************************************************************
Function: (static) __gdbSetTempBreakpoint
Args:  u32 * addr1 - the address where the breakpoint is to be set
       u32 * addr2 - the address of the optional second location
Type: void
Purpose: This function sets a temporary breakpoint. The temporary
    breakpoint will be removed when ANY breakpoint is encountered.
    Setting the temporary breakpoint is not a response to a user
    set break command, but is a side effect of other commands like
    step over line. The debugger sets a breakpoint at the location
    corresponding to the next source line, runs the application, 
    and removes the breakpoint as soon as it is hit. This command
    is also used to implement single-step, since the MIPS CPU has 
    no trace bit. If single stepping over a conditional jump, then
    we need two breakpoints (one at each target).

TODO:   See if there is a permanent break at this address.
************************************************************************/
static void __gdbSetTempBreakpoint( u32 * addr1, u32 * addr2 )
{
    if (gdbDebug & GDB_DEBUG_SHOW_INFO)
    {
        GDB_PRINTF("%s: Set temp BP at 0x%x and 0x%x\n", 
                   gdb_module_name, addr1, addr2);
    }

    __gdbSetBreakpoint(&__gdbTmpBreaks[0], addr1);
    __gdbSetBreakpoint(&__gdbTmpBreaks[1], addr2);
}


/************************************************************************
Function: (static) __gdbClearTempBreakpoint
Args: none
Type: void
Purpose: This function restores the contents of memory where the
    temporary breakpoint was set. Note that the breakinfo does not
    really need to be cleared. This function should be called by
    the break ISR when any breakpoint is encountered. Since the
    alternate break may be set from a single step of a branch,
    we clear it too if it was set.

TODO:   See if there is a permanent break at this address.
************************************************************************/
static void __gdbClearTempBreakpoint( void )
{
    if (gdbDebug & GDB_DEBUG_SHOW_INFO)
        GDB_PRINTF( "%s: Clearing temp breakpoints\n", gdb_module_name);
    __gdbClearBreakpoint(&__gdbTmpBreaks[0]);
    __gdbClearBreakpoint(&__gdbTmpBreaks[1]);
}

/************************************************************************
Function: gdbRemoveBreakpoint
Args: type   - The type of the breakpoint to insert (NOT USED)
      addr   - The address at which to insert a breakpoint
      length - How many bytes the breakpoint should cover (NOT USED)
Type: int - returns 0 if successful, otherwise error type (<0)
Purpose: This function removes a permanent breakpoint.
************************************************************************/
int gdbRemoveBreakpoint(int type, u32* addr, int length)
{
    BREAKINFO* br;

    if (gdbDebug & GDB_DEBUG_SHOW_INFO)
        GDB_PRINTF( "%s: Remove breakpoint at 0x%x\n",
                    gdb_module_name, addr);

    br = __gdbFindBreak(addr);
    if (br)
    {
        __gdbClearBreakpoint(br);
        return GDB_ERROR_NO_ERROR;
    }
    return GDB_ERROR_INVALID_ADDRESS;
}

/************************************************************************
Function: gdbRemoveAllBreakpoints
Type:     int - returns number of breakpoints cleared
Purpose:  This function removes all permanent breakpoints.
************************************************************************/
int gdbRemoveAllBreakpoints()
{
    BREAKINFO* br;
    u32 i, cnt;

    if (gdbDebug & GDB_DEBUG_SHOW_INFO)
        GDB_PRINTF( "%s: Removing all breakpoints\n", gdb_module_name);

    cnt = 0;
    for (i = 0; i < __GDB_NBREAKS; i++)
    {
        br = &__gdbBreakpoints[i];
        if (br->breakAddress)
        {
            __gdbClearBreakpoint(br);
            cnt++;
        }        
    }

    return cnt;
}

/************************************************************************
Function: gdbInsertBreakpoint
Args: type   - The type of the breakpoint to insert (NOT USED)
      addr   - The address at which to insert a breakpoint
      length - How many bytes the breakpoint should cover (NOT USED)
Type: int - returns 0 if successful, otherwise error type (<0)
Purpose: This function sets a permanent breakpoint. The permanent
         breakpoint will remain set until explicitly cleared.

TODO:   See if there is already a temporary break at this address.
************************************************************************/
int gdbInsertBreakpoint(int type, u32* addr, int length)
{
    BREAKINFO* brk;

    if (gdbDebug & GDB_DEBUG_SHOW_INFO)
        GDB_PRINTF( "%s: Insert breakpoint at 0x%x\n",
                    gdb_module_name, addr);

    /* Check to see if breakpoint already set */
    brk = __gdbFindBreak(addr);
    if (brk) 
    {
        /* Break already exists - no need to set it */
        return GDB_ERROR_NO_ERROR;
    }

    /* Find empty slot */
    brk = __gdbFindBreak(NULL);
    if (brk) 
    {
        /* Empty spot found */
        __gdbSetBreakpoint(brk, addr);
        return GDB_ERROR_NO_ERROR;
    }
    else return GDB_ERROR_NO_MORE_IDS;
}

/************************************************************************
Function: (static) __gdbGetBranchTarget
Args: OSThread* thread - which thread is of interest
      u32 * addr - address of an instruction to analyze
Type: u32 - The target address of the branch, or -1 if none
Purpose: This function examines an instruction and (if it is some kind of 
    jump or branch) returns the target address from register, calculated
    relative address, or whatever.

???: Why is the addr a char*?
************************************************************************/
static u32 __gdbGetBranchTarget(OSThread* thread, char* addr )
{
    int inst;

    inst = *(int *) addr;

    switch ((inst >> 26) & 0x3f) 
    {
    case 0x0:       /* jump register */
        if ((((inst >> 5) & 0x7fff) == 0) &&
            ((inst & 0x3f) == 8))
                return __gdbGetRegisterContents(thread, (inst>>21) & 0x1f );

            /* jump and link register */
        if ((((inst >> 16) & 0x1f) == 0) && ((inst & 0x7ff) == 9))
            return __gdbGetRegisterContents( thread, (inst>>21) & 0x1f );
        break;

    case 0x1:
        switch ((inst >> 16) & 0x1f) 
        {
        case 0:     /* branch on less than zero */
        case 1:     /* branch on greater than or equal to zero */
        case 2:     /* branch on less than zero likely */
        case 3:     /* branch on greater than or equal to zero likely */
        case 0x10:  /* branch on less than zero and link */
        case 0x11:  /* branch on greater than or equal to zero and link */
        case 0x12:  /* branch on less than zero and link likely */
        case 0x13: /* branch on greater than or equal to zero and link likely */
            return (u32) (((inst << 16) >> 14) + addr + 4);
        }
        break;
    
    case 0x2:       /* jump */
    case 0x3:       /* jump and link */
        return ((u32)(((unsigned int)(inst << 6) >> 4) +
                ((((int) addr + 4) >> 28) << 28)));

    case 0x4:       /* branch on equal */
    case 0x5:       /* branch on not equal */
    case 0x14:      /* branch on equal likely */
    case 0x15:      /* branch on not equal likely */
        return (u32)(((inst << 16) >> 14) + addr + 4);

    case 0x6:       /* branch on less than or equal to zero */
    case 0x7:       /* branch on greater than zero */
    case 0x16:      /* branch on less than or equal to zero likely */
    case 0x17:      /* branch on greater than zero likely */
        if (((inst>>16) & 0x1f) == 0)
            return (u32)(((inst << 16) >> 14) + addr + 4);
        break;

    case 0x10:      /* branch on coprocessor instructions */
    case 0x11:
    case 0x12:
    case 0x13:
        if (((inst>>21) & 0x1f) == 8) 
        {   /* bc */
            switch ((inst>>16) & 0x1f)
            {
                case 0:         /* bcf */
                case 2:     /* bcfl */
                case 1:     /* bct */
                case 3:     /* bctl */
                    return (u32)(((inst << 16) >> 14) + addr + 4);
            }
        }
        break;
    }

    /*
     * XXX - didn't figure out the target, either is wasn't jump/branch
     * or it could be branch on coprocessor (not implemented yet)
     * since these had better be valid values for the program counter
     * returning anything with the lower two bits means it didn't work.
     */
    return (u32) -1;
}

/************************************************************************
Function: (static) __gdbIsJump
Args: u32 inst - an instruction to analyze
Type: int - returns boolean value
Purpose: This function examines an instruction and returns true if it is
    a jump, false otherwise
************************************************************************/
static int __gdbIsJump( u32 inst )
{
    switch ((inst >> 26) & 0x3f)
    {
    case 0x0:   /* jump register */
        if ((((inst >> 5) & 0x7fff) == 0) && ((inst & 0x3f) == 8))
            return 1;

        /* jump and link register */
        if ((((inst >> 16) & 0x1f) == 0) && ((inst & 0x7ff) == 9))
            return 1;
        break;

    case 0x2:       /* jump */
    case 0x3:       /* jump and link */
        return 1;

    }
    return 0;
}

/************************************************************************
Function: __gdbSetSingleStep
Args:
    int thread - which thread is of interest
    u32 * instptr - current PC for thread
Type: int - returns 1 if OK, 0 otherwise
Purpose: This function sets a temporary breakpoint for single stepping, 
    since the MIPS CPU has no trace bit. It must also check to see if
    the instruction is a jump (in which case it must set the breakpoint
    at the jump target) or a conditional branch (in which case it must
    set TWO breakpoints). Otherwise, it just sets the breakpoint at
    the next instruction.
TODO:   Check to see if it is a break instruction; if so, put the real
    instruction back, step over it, then put the breakpoint back.
************************************************************************/
int __gdbSetSingleStep( OSThread* thread, u32 * instptr )
{
    u32 branchTarget;

    if (gdbDebug & GDB_DEBUG_SHOW_INFO)
        GDB_PRINTF( "%s: Single step for thead %d at 0x%x\n", 
                    gdb_module_name, thread, instptr);

    /*
        Fetch the instruction and see what it is. Set breaks
        accordingly. WARNING! If you were not paying sufficient
        attention, you did not notice that the arg instptr
        is a pointer to INSTRUCTIONS here, not chars or void.
        Thus, incrementing it increases its numeric value by
        four, not by one. Just like real life, only better.

        We fetch the branch target, which will be invalid if
        the instruction is not a branch.
    */
    
    branchTarget = __gdbGetBranchTarget( thread, (char *) instptr );
    if ( branchTarget & 3 )     /* then it wasn't a branch at all */
    {
        __gdbSetTempBreakpoint( instptr + 1, 0 );
    }

    /*
        OK, it was some kind of branch, either a jump or a
        conditional branch. If it is a jump, then just set
        the breakpoint at the target. If it was a conditional
        branch, set it at both possible targets. Of course,
        you can't really set it in both places if they are
        the same, so be careful about that possibility. Also,
        you can't set a breakpoint on a jump to yourself,
        because you wouldn't have an instruction to execute
        after you substituted the breakpoint instruction for
        the instruction you wanted to step through. Confusing,
        but true. For now, we just do nothing in that case.
    */

    else if ( branchTarget == (u32) instptr )   /* uh-oh, can't do this */
        return 0;
    else if ( __gdbIsJump( *instptr ) || (branchTarget == (u32) (instptr+2)) )
        __gdbSetTempBreakpoint( (u32 *) branchTarget, 0 );
    else
        __gdbSetTempBreakpoint( (u32 *) branchTarget, instptr + 2 );
    return 1;
}

/************************************************************************
Function: __gdbHitBreak
Args: int breakNumber - an indicator of which breakpoint was encountered.
Type: void
Purpose: This function is called whenever a breakpoint is hit. It clears
    all temporary breakpoints, creates an exception packet for the
    debugger, and sends it to the host.
************************************************************************/
void __gdbHitBreak( void )
{
    __gdbClearTempBreakpoint();
    gdbStopUserThread(GDB_ALL_THREADS);
    gdbFindFaultedThreads();
}

/************************************************************************
Function: __gdbHitCpuFault
Args: none
Type: void
Purpose: This function is called whenever the CPU faults. It kills all
    user threads, disables all interrupts except its own in the idle
    thread, creates an exception packet for the
    debugger, and sends it to the host.
************************************************************************/
void __gdbHitCpuFault( void )
{
    __gdbMaskIdleThreadInts();
    gdbStopUserThread(GDB_ALL_THREADS);
    gdbFindFaultedThreads();    /* will send fault message */
}

#endif /* #ifndef _FINALROM */