Subversion Repositories openrisc

/*==========================================================================

//

//      dbg_gdb.c

//

//      GDB Debugging Interface

//

//==========================================================================

//####ECOSGPLCOPYRIGHTBEGIN####

// -------------------------------------------

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

//

// eCos is free software; you can redistribute it and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation; either version 2 or (at your option) any later version.

//

// eCos is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License along

// with eCos; if not, write to the Free Software Foundation, Inc.,

// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

//

// As a special exception, if other files instantiate templates or use macros

// or inline functions from this file, or you compile this file and link it

// with other works to produce a work based on this file, this file does not

// by itself cause the resulting work to be covered by the GNU General Public

// License. However the source code for this file must still be made available

// in accordance with section (3) of the GNU General Public License.

//

// This exception does not invalidate any other reasons why a work based on

// this file might be covered by the GNU General Public License.

//

// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

// at http://sources.redhat.com/ecos/ecos-license/

// -------------------------------------------

//####ECOSGPLCOPYRIGHTEND####

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):   nickg

// Contributors:        nickg

// Date:        1998-08-22

// Purpose:     GDB Debugging Interface

// Description: Interface for calls from GDB stubs into the OS. These

//              currently mostly support thread awareness.

//

//####DESCRIPTIONEND####

//

//========================================================================*/

#include <pkgconf/kernel.h>

#include <pkgconf/hal.h>                // CYG_HAL_USE_ROM_MONITOR_CYGMON

#ifdef CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT

#include <cyg/kernel/ktypes.h>

#include <cyg/kernel/thread.hxx>

#include <cyg/kernel/sched.hxx>

#include <cyg/kernel/thread.inl>

#include <cyg/kernel/sched.inl>

#include <cyg/hal/hal_arch.h>

#include <cyg/hal/hal_stub.h>

extern "C"

{

#include <cyg/hal/dbg-threads-api.h>

};

#define USE_ID 1

#if (CYG_BYTEORDER == CYG_LSBFIRST)

unsigned long swap32(unsigned long x)

{

    unsigned long r = 0;

    r |= (x>>24)&0xFF;

    r |= ((x>>16)&0xFF)<<8;

    r |= ((x>>8)&0xFF)<<16;

    r |= ((x)&0xFF)<<24;

    return r;

}

#else

#define swap32(x) ((unsigned long)(x))

#endif

//--------------------------------------------------------------------------

externC int dbg_thread_capabilities(struct dbg_capabilities * cpb)

{

    cpb->mask1 = has_thread_current     |

        has_thread_registers            |

        has_thread_reg_change           |

        has_thread_list                 |

        has_thread_info                 ;

    return 1 ;

}

//--------------------------------------------------------------------------

static void dbg_make_threadref(Cyg_Thread *thread, threadref *ref )

{

    // The following test tries to avoid accessing uninitialized pointers.

    // This can happen if we take a breakpoint before the data is copied

    // or the BSS zeroed. We currently assume that RAM will reset to zero

    // or 0xff. If it is random, we have no hope.

    if( (CYG_ADDRWORD)thread == 0 || (CYG_ADDRWORD)thread == 0xffffffff )

    {

        ((unsigned long *)ref)[0] = 0;

        ((unsigned long *)ref)[1] = 0;

    }

    else

    {

        cyg_uint16 id = thread->get_unique_id();

#if USE_ID

        ((unsigned long *)ref)[0] = (unsigned long)thread;

        ((unsigned long *)ref)[1] = (unsigned long)swap32(id);

#else    

        ((unsigned long *)ref)[1] = (unsigned long)thread;

        ((unsigned long *)ref)[0] = (unsigned long)id;

#endif

    }

}

static Cyg_Thread *dbg_get_thread( threadref *ref)

{

#if USE_ID

    cyg_uint16 id = 0;

    id = (cyg_uint16)swap32(((unsigned long *)ref)[1]);

    Cyg_Thread *th = Cyg_Thread::get_list_head();

    while( th != 0 )

    {

        if( th->get_unique_id() == id ) break;

        th = th->get_list_next();

    }

//    if( thread->get_unique_id() != id ) th = 0;

#else

    cyg_uint16 id = 0;

    Cyg_Thread *thread = (Cyg_Thread *)(((unsigned long *)ref)[1]);

    id = (cyg_uint16)(((unsigned long *)ref)[0]);

    // Validate the thread.

    Cyg_Thread *th = Cyg_Thread::get_list_head();

    while( th != 0 )

    {

        if( th == thread ) break;

        th = th->get_list_next();

    }

//    if( thread->get_unique_id() != id ) th = 0;

#endif

    return th;

}

//--------------------------------------------------------------------------

externC int dbg_currthread(threadref * varparm)

{

    Cyg_Thread *thread = Cyg_Scheduler::get_current_thread();

    dbg_make_threadref(thread, varparm );

    return 1 ;

}

//--------------------------------------------------------------------------

externC int dbg_thread_id(threadref *threadid)

{

    Cyg_Thread *thread = dbg_get_thread(threadid);

    if( thread == 0 ) return 0;

    return thread->get_unique_id ();

}

//--------------------------------------------------------------------------

externC int dbg_currthread_id(void)

{

    Cyg_Thread *thread = Cyg_Scheduler::get_current_thread();

    return thread->get_unique_id ();

}

//--------------------------------------------------------------------------

externC int dbg_threadlist(int startflag,

                   threadref * lastthreadid,

                   threadref * next_thread)

{

    Cyg_Thread *thread;

    if( startflag )

    {

        thread = Cyg_Thread::get_list_head();

        dbg_make_threadref(thread, next_thread);

    }

    else

    {

        thread = dbg_get_thread(lastthreadid);

        if( thread == 0 ) return 0;

        thread = thread->get_list_next();

        if( thread == 0 ) return 0;

        dbg_make_threadref(thread, next_thread);

    }

    return 1 ;

}

//--------------------------------------------------------------------------

// Some support routines for manufacturing thread info strings

static char *dbg_addstr(char *s, char *t)

{

    while( (*s++ = *t++) != 0 );

    return s-1;

}

static char *dbg_addint(char *s, int n, int base)

{

    char buf[16];

    char sign = '+';

    cyg_count8 bpos;

    char *digits = "0123456789ABCDEF";

    if( n < 0 ) n = -n, sign = '-';

    /* Set pos to start */

    bpos = 0;

    /* construct digits into buffer in reverse order */

    if( n == 0 ) buf[bpos++] = '0';

    else while( n != 0 )

    {

        cyg_ucount8 d = n % base;

        buf[bpos++] = digits[d];

        n /= base;

    }

    /* set sign if negative. */

    if( sign == '-' )

    {

        buf[bpos] = sign;

    }

    else bpos--;

    /* Now write it out in correct order. */

    while( bpos >= 0 )

        *s++ = buf[bpos--];

    *s = 0;

    return s;

}

static char *dbg_adddec(char *s, int x)

{

    return dbg_addint(s, x, 10);

}

//--------------------------------------------------------------------------

externC int dbg_threadinfo(

                   threadref * threadid,

                   struct cygmon_thread_debug_info * info)

{

    static char statebuf[60];

    Cyg_Thread *thread = dbg_get_thread(threadid);

    if( thread == 0 ) return 0;

    info->context_exists        = 1;

    char *sbp = statebuf;

    char *s;

    if( thread->get_state() & Cyg_Thread::SUSPENDED )

    {

        sbp = dbg_addstr( sbp, "suspended+");

    }

    switch( thread->get_state() & ~Cyg_Thread::SUSPENDED )

    {

    case Cyg_Thread::RUNNING:

        if ( Cyg_Scheduler::get_current_thread() == thread ) {

            s = "running";              break;

        }

        else if ( thread->get_state() & Cyg_Thread::SUSPENDED ) {

            s = ""; sbp--; /*kill '+'*/ break;

        }

        else {

            s = "ready";                break;

        }

    case Cyg_Thread::SLEEPING:

        s = "sleeping";                 break;

    case Cyg_Thread::COUNTSLEEP | Cyg_Thread::SLEEPING:

    case Cyg_Thread::COUNTSLEEP:

        s = "counted sleep";            break;

    case Cyg_Thread::CREATING:

        s = "creating"; sbp = statebuf; break;

    case Cyg_Thread::EXITED:

        s = "exited"; sbp = statebuf;   break;

    default:

        s = "unknown state";            break;

    }

    sbp = dbg_addstr( sbp, s );

    sbp = dbg_addstr( sbp, ", Priority: " );

    sbp = dbg_adddec( sbp, thread->get_priority() );

    info->thread_display        = statebuf;

#ifdef CYGVAR_KERNEL_THREADS_NAME

    info->unique_thread_name    = thread->get_name();

#else

    info->unique_thread_name    = 0;

#endif

    info->more_display          = 0;

    return 1 ;

}

//--------------------------------------------------------------------------

externC int dbg_getthreadreg(

                     threadref * osthreadid,

                     int regcount, /* count of registers in the array */

                     void * regval)  /* fillin this array */

{

    Cyg_Thread *thread = dbg_get_thread(osthreadid);

    if( thread == 0 ) return 0;

    if( thread == Cyg_Scheduler::get_current_thread() )

    {

#if defined(CYG_HAL_USE_ROM_MONITOR_CYGMON)

        // We have no state for the current thread, Cygmon has

        // got that and we cannot get at it.

        return 0;

#elif defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS)

        // registers hold the state of the current thread.

        __stub_copy_registers ((target_register_t *)regval, registers);

#else

        return 0;

#endif

    }

    else

    {

        HAL_SavedRegisters *regs = thread->get_saved_context();

        if( regs == 0 ) return 0;

        HAL_GET_GDB_REGISTERS (regval, regs);

    }

    return 1 ;

}

//--------------------------------------------------------------------------

externC int dbg_setthreadreg(

                            threadref * osthreadid,

                            int regcount , /* number of registers */

                            void * regval)

{

    Cyg_Thread *thread = dbg_get_thread(osthreadid);

    if( thread == 0 ) return 0;

    if( thread == Cyg_Scheduler::get_current_thread() )

    {

#if defined(CYG_HAL_USE_ROM_MONITOR_CYGMON)

        // We have no state for the current thread, Cygmon has

        // got that and we cannot get at it.

        return 0;

#elif defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS)

        // registers hold the state of the current thread.

        __stub_copy_registers (registers, (target_register_t *)regval);

#else

        return 0;

#endif

    }

    else

    {

        HAL_SavedRegisters *regs = thread->get_saved_context();

        if( regs == 0 ) return 0;

        HAL_SET_GDB_REGISTERS (regs, regval);

    }

    return 1;

}

//--------------------------------------------------------------------------

// Thread scheduler control for debugger.

// Arguments:

//      osthreadid      : must match currently executing thread.

//                        Future use: change the currently executing thread.

//      lock            : 0 == unlock scheduler, 1 == lock scheduler

//      mode            : 0 == single-instruction step, 1 == free running

//

// Return values:

// 1  == success

// 0  == failure

// -1 == request that the caller handle this itself

//       (eg.by disabling interrupts)

//

externC int dbg_scheduler(

                          threadref * osthreadid,

                          int lock,     /* 0 == unlock, 1 == lock */

                          int mode)     /* 0 == step,   1 == continue */

{

#if 0

    /* Minimal implementation: let stub do the work.  */

    return -1;                          // Stub will disable interrupts

#else

    Cyg_Thread *thread = dbg_get_thread(osthreadid);

    if( thread == 0 ) return 0;         // fail

    if( thread == Cyg_Scheduler::get_current_thread() )

    {

        // OK to proceed

        if (lock)

        {

            Cyg_Scheduler::lock();

        }

        else

        {

            if (Cyg_Scheduler::get_sched_lock() >= 1)

                Cyg_Scheduler::unlock_simple();

        }

        return 1;                       // success

    }

    else

    {

        // Cannot accept any thread other than current one

        return 0;                       // fail

    }

#endif

}

#endif // CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT

//--------------------------------------------------------------------------

// End of dbg_gdb.cxx