URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [kernel/] [v2_0/] [src/] [debug/] [dbg_gdb.cxx] - Rev 174
Compare with Previous | Blame | View Log
/*========================================================================== // // 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