开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
wdbBpLib.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：27k
源码类别：

VxWorks

开发平台：

C/C++

wdbBpLib.c：源码内容
  1. /* wdbBpLib.c - Break point handling for the target server */
  3. /* Copyright 1994-2001 Wind River Systems, Inc. */
  5. /*
  6. modification history
  7. --------------------
  8. 01u,14sep01,jhw  Fixed warnings from compiling with gnu -pedantic flag
  9. 01t,16nov98,cdp  enable Thumb support for all ARM CPUs with ARM_THUMB==TRUE.
  10. 01v,21apr99,dbt  removed TEXT_LOCK() and TEXT_UNLOCK() calls in wdbHwBpAdd()
  11.  routine (SPR #26927).
  12. 01t,19jan99,elg  Restore PC for MIPS (SPR 24356)
  13. 01s,10jul98,dbt  test if task mode agent is running before stepping or
  14.                  continue a task.
  15. 01r,11may98,dbt  removed useless wdbTaskLock() and wdbTaskUnlock() calls in 
  16.  wdbSysBpLibInit().
  17. 01q,29apr98,dbt  code cleanup.
  18. 01p,21apr98,dbt  fixed Thumb (ARM7TDMI_T) support.
  19. 01o,11jul97,cdp  added Thumb (ARM7TDMI_T) support.
  20. 01n,09mar98,dbt  fixed a problem with WDB_TASK_LOCK() and WDB_TASK_UNLOCK()
  21.                  defines.
  22. 01m,13feb98,dbt  fixed typo in wdbBpLibInit().
  23. 01l,26jan98,dbt  replaced wdbEventClassConnect() with wdbEvtptClassConnect().
  24.  replaced WDB_EVT_CLASS with WDB_EVTPT_CLASS
  25. 01k,05dec97,dbt  merge with target shell debugger. Added support for hardware
  26.  breakpoints.
  27. 01j,28aug96,tam  modified wdbCont() to fix SPR 7098.
  28. 01k,15jul96,ms   fixed problem with trace mode
  29. 01j,26jun96,ms   added target side code to support windview "e" command.
  30.  removed redundant call to wdbBpRemove().
  31.  2nd paramter to eventpoint call func is now a REG_SET *.
  32. 01i,03jun96,kkk  replaced _sigCtxLoad with WDB_CTX_LOAD.
  33.  replaced pRegister->pc with pRegister->reg_pc.
  34. 01h,24apr96,ms   support generalized eventPoint handling.
  35.  support multiple breakpoints at same address.
  36.  lots of cleanup.
  37. 01g,23jan96,tpr  added cast to compile with DIAB DATA toolkit.
  38. 01f,21sep95,ms   unprotect mem before check for valid BP address (SPR 4935)
  39. 01e,17jul95,ms  changed the boundry test on STEP_RANGE
  40. 01d,03jun95,ms  deleting BP id = -1 means remove all breapoints.
  41. 01c,01jun95,ms  check for WDB_CTX_ANY_TASK on BP add.
  42.  do a memProbe on BP add.
  43.  don't add task BP's in system mode.
  44.  deactivate system BP's when in task mode.
  45.  some cleanup.
  46. 01b,28mar95,ms  wdbBpAdd now uses contextType to determine task vs system BP.
  47. 01a,02nov94,rrr  written.
  48. */
  50. /*
  51. DESCPRIPTION
  53. This library contains break point handling for system mode debugging.
  54. It also contains code which is shared with wdbTaskBpLib.c.
  55. */
  57. /* includes */
  59. #include "vxWorks.h"
  60. #include "string.h"
  61. #include "regs.h"
  62. #include "wdb/wdb.h"
  63. #include "wdb/dll.h"
  64. #include "wdb/wdbLibP.h"
  65. #include "wdb/wdbLib.h"
  66. #include "wdb/wdbBpLib.h"
  67. #include "wdb/wdbSvcLib.h"
  68. #include "wdb/wdbEvtLib.h"
  69. #include "wdb/wdbEvtptLib.h"
  70. #include "wdb/wdbArchIfLib.h"
  71. #include "wdb/wdbDbgLib.h"
  73. /* externals */
  75. extern WDB_IU_REGS wdbExternSystemRegs;
  76. extern BOOL wdbOneShot;
  78. #if DBG_NO_SINGLE_STEP
  79. extern FUNCPTR  _func_trap;
  80. #else /* DBG_NO_SINGLE_STEP */
  81. extern FUNCPTR  _func_breakpoint;
  82. extern FUNCPTR  _func_trace;
  83. #endif /* DBG_NO_SINGLE_STEP */
  84. extern FUNCPTR  _func_wdbIsNowExternal;
  86. /* defines */
  88. #if     CPU_FAMILY==MC680X0
  89. #undef reg_pc
  90. #define reg_pc regSet.pc
  91. #undef reg_sp
  92. #define reg_sp regSet.addrReg[7]
  93. #undef reg_fp
  94. #define reg_fp regSet.addrReg[6]
  95. #endif  /* CPU_FAMILY==MC680X0 */
  97. /* globals */
  99. UINT32  (*_wdbTaskBpAdd) (WDB_EVTPT_ADD_DESC * pEv);
  100. UINT32  (*_wdbTaskStep) (UINT32 contextId, TGT_ADDR_T startAddr,
  101. TGT_ADDR_T endAddr);
  102. UINT32  (*_wdbTaskCont)         (UINT32 contextId); 
  103. #if DBG_NO_SINGLE_STEP
  104. void    (*_wdbTaskBpTrap)       (int level, INSTR * addr, void * pInfo, 
  105.     WDB_IU_REGS * pRegisters, void * pDbgRegs, 
  106.     BOOL hardware);
  107. #else /* DBG_NO_SINGLE_STEP */
  108. void    (*_wdbTaskBpBreakpoint) (int level, void * pInfo, 
  109.     WDB_IU_REGS * pRegisters, void * pDbgRegs,
  110.     BOOL hardware);
  111. void    (*_wdbTaskBpTrace)      (int level, void * pInfo, 
  112.     WDB_IU_REGS * pRegisters);
  113. #endif /* DBG_NO_SINGLE_STEP */
  115. /* locals */
  117. static int wdbBpData; /* store breakpoint informations */
  118. static UINT32 wdbBpAddr; /* store the address of the last */
  119. /* encountered breakpoint */
  120. static int wdbSysBpMode; /* mode of the system context */
  121. static INSTR * wdbSysStepStart; /* start address of step range */
  122. static INSTR * wdbSysStepEnd; /* end address of step range */
  124. #if DBG_NO_SINGLE_STEP
  125. static INSTR * wdbSysNpc;
  126. static INSTR wdbSysNpcInstr;
  127. #endif /* DBG_NO_SINGLE_STEP */
  129. static WDB_EVT_NODE eventSysBpNode; /* system mode breakpoint event node */
  130. static WDB_EVTPT_CLASS wdbEventClassBp;/* breakpoint event class */
  131. #if DBG_HARDWARE_BP
  132. static WDB_EVTPT_CLASS wdbEventClassHwBp;/* hardware breakpoint event class */
  133. #endif /* DBG_HARDWARE_BP */
  135. /* forward static declarations */
  137. static UINT32 wdbStep (WDB_CTX_STEP_DESC * pCtxStep);
  138. static UINT32 wdbCont (WDB_CTX * ctx);
  139. static UINT32 wdbBpAdd (WDB_EVTPT_ADD_DESC * pBp, UINT32 * pId);
  140. static UINT32 wdbBpDelete (TGT_ADDR_T *pId);
  141. static void wdbSysBpEventGet (void * arg, WDB_EVT_DATA * pEventMsg);
  142. static void wdbTrace (int level, void * pInfo, 
  143.     WDB_IU_REGS * pRegisters);
  144. static void wdbBreakpoint (int level, void * pInfo, 
  145.     WDB_IU_REGS * pRegisters, void * pDbgRegs, 
  146.     BOOL hardware);
  147. static void wdbSysBpPost (int addr);
  148. static void wdbTaskLock (void);
  149. static void wdbTaskUnlock (void);
  150. #if DBG_HARDWARE_BP
  151. static UINT32 wdbHwBpAdd (WDB_EVTPT_ADD_DESC * pBp, UINT32 * pId);
  152. #endif /* DBG_HARDWARE_BP */
  153. #if DBG_NO_SINGLE_STEP
  154. static void wdbTrap (int level, INSTR * addr, void * pInfo, 
  155.     WDB_IU_REGS * pRegisters, void * pDbgRegs, 
  156.     BOOL hardware);
  157. #endif /* DBG_NO_SINGLE_STEP */
  159. /******************************************************************************
  160. *
  161. * wdbSysBpLibInit - initialize the library.
  162. *
  163. * This routine initializes the agent debugger library : wdb services,
  164. * breakpoint lists, event nodes and some pointers used by the debugger.
  165. *
  166. * RETURNS : N/A 
  167. * 
  168. * NOMANUAL
  169. */
  171. void wdbSysBpLibInit
  172.     (
  173.     BRKPT * pBps, /* pointer on breakpoint structure */
  174.     int bpCnt /* number of breakpoints */
  175.     )
  176.     {
  177.     static int wdbBpInstalled = FALSE;
  179.     if (!wdbBpInstalled)
  180. {
  181. wdbSvcAdd (WDB_CONTEXT_STEP, wdbStep, xdr_WDB_CTX_STEP_DESC, xdr_void);
  182. wdbSvcAdd (WDB_CONTEXT_CONT, wdbCont, xdr_WDB_CTX, xdr_void);
  184. wdbEventClassBp.evtptType = WDB_EVT_BP;
  185. wdbEventClassBp.evtptAdd = wdbBpAdd;
  186. wdbEventClassBp.evtptDel = wdbBpDelete;
  187. wdbEvtptClassConnect (&wdbEventClassBp);
  189. #if DBG_HARDWARE_BP
  190. wdbEventClassHwBp.evtptType = WDB_EVT_HW_BP;
  191. wdbEventClassHwBp.evtptAdd = wdbHwBpAdd;
  192. wdbEventClassHwBp.evtptDel = wdbBpDelete;
  193. wdbEvtptClassConnect (&wdbEventClassHwBp);
  194. #endif /* DBG_HARDWARE_BP */
  196. #if DBG_NO_SINGLE_STEP
  197. _func_trap = (FUNCPTR) wdbTrap;
  198. #else   /* DBG_NO_SINGLE_STEP */
  199. _func_breakpoint = (FUNCPTR) wdbBreakpoint;
  200. _func_trace = (FUNCPTR) wdbTrace;
  201. #endif  /* DBG_NO_SINGLE_STEP */
  203. _func_wdbIsNowExternal = (FUNCPTR) wdbIsNowExternal;
  205. wdbDbgBpListInit();
  207. while (bpCnt)
  208.     {
  209.     dll_insert (&pBps->bp_chain, &bpFreeList);
  210.     ++pBps;
  211.     --bpCnt;
  212.     }
  214. wdbDbgArchInit();
  216. wdbEventNodeInit (&eventSysBpNode, wdbSysBpEventGet, NULL, 
  217. (void *) &eventSysBpNode);
  219. wdbBpInstalled = TRUE;
  220. }
  221.     }
  223. /******************************************************************************
  224. *
  225. * wdbBpInstall - install system mode breakpoints.
  226. *
  227. * Before the external agent transfers control back to the OS, this routine
  228. * is called to reinsert the breakpoints.
  229. * 
  230. * RETURNS : N/A
  231. *
  232. * NOMANUAL
  233. */ 
  235. void wdbBpInstall (void)
  236.     {
  237.     dll_t * pDll;
  238. #if DBG_HARDWARE_BP
  239.     DBG_REGS dbgRegs;
  240. #endif /* DBG_HARDWARE_BP */
  242.     /* don't install system BP's if we are not in system mode */
  244.     if (wdbIsNowTasking())
  245. return;
  247. #if DBG_HARDWARE_BP
  248.     memset (&dbgRegs, 0, sizeof (DBG_REGS));
  249.     wdbDbgRegsClear (); /* clean debug registers */
  250. #endif /* DBG_HARDWARE_BP */
  252.     /* if stepping, just set trace mode */
  254.     if (wdbSysBpMode != 0)
  255. {
  256. #if DBG_NO_SINGLE_STEP
  257. wdbSysNpc = wdbDbgGetNpc (&wdbExternSystemRegs);
  258. wdbSysNpcInstr = *wdbSysNpc;
  259. usrBreakpointSet (wdbSysNpc, DBG_BREAK_INST);
  260. #endif /* DBG_NO_SINGLE_STEP */
  261. wdbBpData = wdbDbgTraceModeSet ((REG_SET *) &wdbExternSystemRegs);
  262. }
  263.     else /* if not stepping, insert breakpoints */
  264. {
  265. for (pDll = dll_head(&bpList); pDll != dll_end(&bpList);
  266. pDll = dll_next(pDll))
  267.     {
  268.     if (BP_BASE(pDll)->bp_task ==  -1)
  269. {
  270. if ((BP_BASE(pDll)->bp_flags & BRK_HARDWARE) == 0)
  271.     usrBreakpointSet (BP_BASE(pDll)->bp_addr, DBG_BREAK_INST);
  272. #if DBG_HARDWARE_BP
  273. else
  274.     wdbDbgHwBpSet (&dbgRegs, 
  275.    BP_BASE(pDll)->bp_flags & BRK_HARDMASK, 
  276.    (UINT32) BP_BASE(pDll)->bp_addr);
  277. #endif /* DBG_HARDWARE_BP */
  278. BP_BASE(pDll)->bp_flags |= BP_INSTALLED;
  279. }
  280.     }
  282. #if DBG_HARDWARE_BP
  283. wdbDbgRegsSet (&dbgRegs); /* set debug registers. */
  284. #endif /* DBG_HARDWARE_BP */
  285. }
  286.     }
  288. /******************************************************************************
  289. *
  290. * wdbSysBpEventGet - upload a breakpoint event to the host.
  291. *
  292. * This routine upload a system breakpoint event to the host.
  293. *
  294. * RETURNS : N/A
  295. *
  296. * NOMANUAL
  297. */ 
  299. static void wdbSysBpEventGet
  300.     (
  301.     void *    pRegs,
  302.     WDB_EVT_DATA * pEvtData
  303.     )
  304.     {
  305.     WDB_BP_INFO * pBpInfo = (WDB_BP_INFO *)&pEvtData->eventInfo;
  307.     if ((TGT_ADDR_T) wdbExternSystemRegs.reg_pc != wdbBpAddr)
  308. {
  309. /* It should be a watch point */
  311. pEvtData->evtType = WDB_EVT_WP;
  312. pBpInfo->numInts = 6;
  313. pBpInfo->addr  = wdbBpAddr;
  314. }
  315.     else
  316. {
  317. /* It should be a break point */
  319. pEvtData->evtType    = WDB_EVT_BP;
  320. pBpInfo->numInts = 5;
  321. }
  323.     /* fill WDB_BP_INFO structure */
  325.     pBpInfo->context.contextType = WDB_CTX_SYSTEM;
  326.     pBpInfo->context.contextId  = -1;
  327.     pBpInfo->pc = (TGT_ADDR_T) wdbExternSystemRegs.reg_pc;
  328.     pBpInfo->fp = (TGT_ADDR_T) wdbExternSystemRegs.reg_fp;
  329.     pBpInfo->sp = (TGT_ADDR_T) wdbExternSystemRegs.reg_sp;
  330.     }
  332. /******************************************************************************
  333. *
  334. * wdbSysBpPost - post system mode breakpoint event  
  335. *
  336. * This routine posts an event to the host when a system mode breakpoint
  337. * is hit. It is called when the system is suspended.
  338. *
  339. * RETURNS : N/A
  340. *
  341. * NOMANUAL
  342. */ 
  344. static void wdbSysBpPost
  345.     (
  346.     int addr /* breakpoint addr */
  347.     )
  348.     {
  349.     wdbEventPost (&eventSysBpNode);
  350.     }
  352. /*******************************************************************************
  353. *
  354. * wdbStep - Handle a step request
  355. *
  356. * The wdbStep() function is used to step the system or a task.
  357. *
  358. * NOMANUAL
  359. */
  361. static UINT32 wdbStep
  362.     (
  363.     WDB_CTX_STEP_DESC * pCtxt
  364.     )
  365.     {
  366.     switch (pCtxt->context.contextType)
  367. {
  368. case WDB_CTX_SYSTEM:
  369.     if (!wdbIsNowExternal())
  370. return (WDB_ERR_AGENT_MODE);
  372.     if ((pCtxt->startAddr == 0) && (pCtxt->endAddr == 0))
  373. wdbSysBpMode = WDB_STEP;
  374.     else
  375. {
  376. wdbSysBpMode = WDB_STEP_RANGE;
  377. wdbSysStepStart = (INSTR *) pCtxt->startAddr;
  378. wdbSysStepEnd = (INSTR *) pCtxt->endAddr;
  379. }
  381.     wdbOneShot = TRUE;
  382.     return (WDB_OK);
  384. case WDB_CTX_TASK:
  385.     if (!wdbIsNowTasking())
  386. return (WDB_ERR_AGENT_MODE);
  388.     if (_wdbTaskStep != NULL)
  389. return ((*_wdbTaskStep) (pCtxt->context.contextId, 
  390.  pCtxt->startAddr, 
  391.  pCtxt->endAddr));
  393.     return (WDB_ERR_NO_RT_PROC);
  395. default:
  396.     return (WDB_ERR_INVALID_CONTEXT);
  397. }
  398.     }
  400. /*******************************************************************************
  401. *
  402. * wdbCont - Handle a continue request
  403. *
  404. * The wdbCont() function is used to continue the system or a task.
  405. *
  406. * NOMANUAL
  407. */
  409. static UINT32 wdbCont
  410.     (
  411.     WDB_CTX * pCtxt
  412.     )
  413.     {
  414.     switch (pCtxt->contextType)
  415. {
  416. case WDB_CTX_SYSTEM:
  417.     if (!wdbIsNowExternal())
  418. return (WDB_OK);
  420.     /* 
  421.      * Check for breakpoint at extern system pc or wdbBpAddr 
  422.      * (last breakpoint address). This last test is usefull for
  423.      * data breakpoints.
  424.      */
  426.     if ((wdbDbgBpFind 
  427. ((INSTR *) wdbExternSystemRegs.reg_pc, BP_SYS) == OK) ||
  428.          (wdbDbgBpFind ((INSTR *) wdbBpAddr, BP_SYS) == OK))
  429. {
  430.      wdbSysBpMode = WDB_STEP_OVER;
  431. }
  433.     wdbOneShot = TRUE;
  434.     return (WDB_OK);
  436. case WDB_CTX_TASK:
  437.     if (!wdbIsNowTasking())
  438. return (WDB_ERR_AGENT_MODE);
  440.     if (_wdbTaskCont != NULL)
  441. return ((*_wdbTaskCont) (pCtxt->contextId));
  443.     return (WDB_ERR_NO_RT_PROC);
  445. default:
  446.     return (WDB_ERR_INVALID_CONTEXT);
  447. }
  448.     }
  450. /*******************************************************************************
  451. *
  452. * wdbBpAdd - Handle a break point add request
  453. *
  454. * The wdbBpAdd() function is used to add break points from the agent.
  455. *
  456. * NOMANUAL
  457. */
  459. static UINT32 wdbBpAdd
  460.     (
  461.     WDB_EVTPT_ADD_DESC * pBreakPoint,
  462.     UINT32 * pId
  463.     )
  464.     {
  465.     INSTR val;
  466.     BRKPT * pBp;
  467.     INSTR * addr;
  469.     switch (pBreakPoint->numArgs)
  470. {
  471. default:
  472. case 1:
  473. #if ((CPU_FAMILY == ARM) && ARM_THUMB)
  474.     addr = (INSTR *) ((UINT32)((pBreakPoint->args[0]) & ~1));
  475. #else /* CPU_FAMILY == ARM */
  476.     addr = (INSTR *) pBreakPoint->args[0];
  477. #endif /* CPU_FAMILY == ARM */
  478.     break;
  479. case 0:
  480.     return (WDB_ERR_INVALID_PARAMS);
  481. }
  483.     /* check validity of breakpoint address */
  485.     TEXT_UNLOCK(addr);
  487.     if (((*pWdbRtIf->memProbe) ((char *)addr, VX_READ,
  488. sizeof(INSTR), (char *)&val) != OK) ||
  489.         ((*pWdbRtIf->memProbe) ((char *)addr, VX_WRITE,
  490. sizeof(INSTR), (char *)&val) != OK))
  491. {
  492. TEXT_LOCK(addr);
  493.         return (WDB_ERR_MEM_ACCES);
  494. }
  496.     TEXT_LOCK(addr);
  498.     /* check the agent mode */
  500.     switch (pBreakPoint->context.contextType)
  501. {
  502. case WDB_CTX_SYSTEM:
  503.     if (!wdbIsNowExternal())
  504. return (WDB_ERR_AGENT_MODE);
  505.     break;
  506. default:
  507.     if (!wdbIsNowTasking())
  508. return (WDB_ERR_AGENT_MODE);
  509. }
  513.     if (dll_empty (&bpFreeList))
  514. return (WDB_ERR_EVENTPOINT_TABLE_FULL);
  516.     wdbTaskLock (); /* disable task switching */
  517.     pBp = BP_BASE(dll_tail (&bpFreeList));
  518.     dll_remove (&pBp->bp_chain);
  519.     wdbTaskUnlock (); /* re-enable task switching */
  521.     pBp->bp_flags = BP_HOST;
  522.     pBp->bp_addr = addr;
  523.     pBp->bp_action = pBreakPoint->action.actionType;
  524. #if ((CPU_FAMILY == ARM) && ARM_THUMB)
  525.     pBp->bp_callRtn = (void (*)())((UINT32)pBreakPoint->action.callRtn | 1);
  526. #else /* CPU_FAMILY == ARM */
  527.     pBp->bp_callRtn = (void (*)())pBreakPoint->action.callRtn;
  528. #endif /* CPU_FAMILY == ARM */
  529.     pBp->bp_callArg = pBreakPoint->action.callArg;
  530.     pBp->bp_instr = *(INSTR *)addr;
  532.     if (pBreakPoint->numArgs > 1) /* second argument is count */
  533.     pBp->bp_count = pBreakPoint->args[1];
  534.     else
  535.     pBp->bp_count = 0;
  537.     /* XXX - hack because host tools pass wrong info */
  539.     if ((pBp->bp_action == 0) || (pBp->bp_action == WDB_ACTION_STOP))
  540. pBp->bp_action = WDB_ACTION_STOP | WDB_ACTION_NOTIFY;
  542.     /* set the context ID */
  544.     switch (pBreakPoint->context.contextType)
  545.         {
  546.         case WDB_CTX_SYSTEM:
  547.     pBp->bp_task = BP_SYS;
  548.             break;
  549.         case WDB_CTX_ANY_TASK:
  550.     pBp->bp_task = BP_ANY_TASK;
  551.             break;
  552.         case WDB_CTX_TASK:
  553.         default:
  554.     pBp->bp_task = pBreakPoint->context.contextId;
  555.         }
  557.     wdbTaskLock (); /* disable task switching */
  558.     dll_insert(&pBp->bp_chain, &bpList);
  559.     wdbTaskUnlock (); /* re-enable task switching */
  561.     if (pBreakPoint->context.contextType != WDB_CTX_SYSTEM)
  562. if (_wdbTaskBpAdd != NULL)
  563.     _wdbTaskBpAdd (pBreakPoint);
  565.     *pId = (UINT32)pBp;
  566.     return (WDB_OK);
  567.     }
  569. #if DBG_HARDWARE_BP
  570. /*******************************************************************************
  571. *
  572. * wdbHwBpAdd - Handle a hardware break point add request
  573. *
  574. * The wdbBpAdd() function is used to add break points form the agent.
  575. *
  576. * NOMANUAL
  577. */
  579. static UINT32 wdbHwBpAdd
  580.     (
  581.     WDB_EVTPT_ADD_DESC * pBreakPoint, /* breakpoint to add */
  582.     UINT32 * pId /* breakpoint ID */
  583.     )
  584.     {
  585.     BRKPT * pBp;
  586.     dll_t * pDll;
  587.     int status;
  588.     DBG_REGS dbgRegs; /* debug registers */
  589.     int contextId; /* context ID */
  590.     UINT32 addr; /* breakpoint address */
  591.     UINT32 count = 0; /* breakpoint count */
  592.     int type = DEFAULT_HW_BP; /* hardware type */
  594.     switch (pBreakPoint->numArgs)
  595. {
  596. default:
  597. case 3:
  598.     type = pBreakPoint->args[2];
  599.     /* FALL THROUGH */
  600. case 2:
  601.     count = pBreakPoint->args[1];
  602.     /* FALL THROUGH */
  603. case 1:
  604.     addr = pBreakPoint->args[0];
  605.     break;
  606. case 0:
  607.     return (WDB_ERR_INVALID_PARAMS);
  608. }
  610.     /* check validity of hardware breakpoint address */
  612.     if (wdbDbgHwAddrCheck (addr, type, (FUNCPTR) pWdbRtIf->memProbe) != OK)
  613.         return (WDB_ERR_MEM_ACCES);
  615.     /* check the agent mode */
  617.     switch (pBreakPoint->context.contextType)
  618. {
  619. case WDB_CTX_SYSTEM:
  620.     if (!wdbIsNowExternal())
  621. return (WDB_ERR_AGENT_MODE);
  622.     break;
  624. default:
  625.     if (!wdbIsNowTasking())
  626. return (WDB_ERR_AGENT_MODE);
  627. }
  629.     /* set the context ID */
  631.     switch (pBreakPoint->context.contextType)
  632.         {
  633.         case WDB_CTX_SYSTEM:
  634.             contextId = BP_SYS;
  635.             break;
  636.         case WDB_CTX_ANY_TASK:
  637.             contextId = BP_ANY_TASK;
  638.             break;
  639.         case WDB_CTX_TASK:
  640.         default:
  641.             contextId = pBreakPoint->context.contextId;
  642.         }
  644.     /* clean dbgRegs structure */
  646.     memset (&dbgRegs, 0, sizeof (DBG_REGS));
  648.     /* fill dbgRegs structure with all hardware breakpoints */
  650.     wdbTaskLock (); /* disable task switching */
  651.     for (pDll = dll_head(&bpList); pDll != dll_end(&bpList);
  652. pDll = dll_next(pDll))
  653. {
  654. pBp = BP_BASE(pDll);
  656. /* check if found breakpoint is applicable to new breakpoint context */
  658. if (((contextId == BP_SYS) && (pBp->bp_task == BP_SYS)) ||
  659. ((contextId == BP_ANY_TASK) && (pBp->bp_task != BP_SYS)) ||
  660. ((contextId != BP_SYS) && (pBp->bp_task == BP_ANY_TASK)))
  661.     {
  662.     if (pBp->bp_flags & BRK_HARDWARE)
  663. {
  664. if ((status = wdbDbgHwBpSet (&dbgRegs, 
  665. pBp->bp_flags & BRK_HARDMASK, 
  666. (UINT32) pBp->bp_addr)) != OK)
  667.     {
  668.     wdbTaskUnlock (); /* re-enable task switching */
  669.     return (status);
  670.     }
  671. }
  672.     }
  673. }
  674.     wdbTaskUnlock (); /* re-enable task switching */
  676.     if ((status = wdbDbgHwBpSet (&dbgRegs, type, addr)) != OK)
  677. return (status);
  679.     if (dll_empty (&bpFreeList))
  680. return (WDB_ERR_EVENTPOINT_TABLE_FULL);
  682.     wdbTaskLock (); /* disable task switching */
  683.     pBp = BP_BASE(dll_tail (&bpFreeList));
  684.     dll_remove (&pBp->bp_chain);
  685.     wdbTaskUnlock (); /* re-enable task switching */
  687.     pBp->bp_flags = BP_HOST | type | BRK_HARDWARE;
  688.     pBp->bp_addr = (INSTR *)addr;
  689.     pBp->bp_action = pBreakPoint->action.actionType;
  690.     pBp->bp_count = count;
  691.     pBp->bp_callRtn = (void (*)())pBreakPoint->action.callRtn;
  692.     pBp->bp_callArg = pBreakPoint->action.callArg;
  693.     pBp->bp_task = contextId;
  695.     /* 
  696.      * XXX - MS hack because host tools pass wrong info.
  697.      * XXX - DBT This has been corrected in tornado 2.0 host tools but we
  698.      * must keep this hack for backward compatibility.
  699.      */
  701.     if ((pBp->bp_action == 0) || (pBp->bp_action == WDB_ACTION_STOP))
  702. pBp->bp_action = WDB_ACTION_STOP | WDB_ACTION_NOTIFY;
  704.     wdbTaskLock (); /* disable task switching */
  705.     dll_insert(&pBp->bp_chain, &bpList);
  706.     wdbTaskUnlock (); /* re-enable task switching */
  708.     if (pBreakPoint->context.contextType != WDB_CTX_SYSTEM)
  709. if (_wdbTaskBpAdd != NULL)
  710.     _wdbTaskBpAdd (pBreakPoint);
  712.     *pId = (UINT32)pBp;
  713.     return (WDB_OK);
  714.     }
  715. #endif /* DBG_HARDWARE_BP */
  717. /*******************************************************************************
  718. *
  719. * wdbBpDelete - Handle a break point delete request
  720. *
  721. * The wdbBpDelete() function is used to delete break points.
  722. *
  723. * NOMANUAL
  724. */
  726. static UINT32 wdbBpDelete
  727.     (
  728.     TGT_ADDR_T * pId
  729.     )
  730.     {
  731.     dll_t * pDll;
  732.     dll_t * pNextDll;
  733.     BRKPT * pBp;
  735.     pBp = *(BRKPT **) pId;
  737.     /* 
  738.      * Breakpoint ID of -1 means remove all breakpoints. 
  739.      * We can only remove breakpoints set by the host tools. Breakpoints
  740.      * set from target shell can't be removed
  741.      */
  743.     wdbTaskLock (); /* disable task switching */
  744.     if ((int ) pBp == -1)
  745. {
  746. for (pDll = dll_head(&bpList);
  747.      pDll != dll_end(&bpList);
  748.      pDll = pNextDll)
  749.     {
  750.     pNextDll = dll_next(pDll);
  752.     if (BP_BASE(pDll)->bp_flags & BP_HOST)
  753. wdbDbgBpRemove (BP_BASE(pDll));
  754.     }
  756. wdbTaskUnlock (); /* re-enable task switching */
  757. return (WDB_OK);
  758. }
  760.     /* else just remove one breakpoint */
  762.     for (pDll = dll_head(&bpList); pDll != dll_end(&bpList);
  763.     pDll = dll_next(pDll))
  764. {
  765. if (BP_BASE(pDll) == pBp)
  766.     {
  767.     wdbDbgBpRemove (pBp);
  768.     wdbTaskUnlock (); /* re-enable task switching */
  769.     return (WDB_OK);
  770.     }
  771. }
  772.     wdbTaskUnlock (); /* re-enable task switching */
  774.     return (WDB_ERR_INVALID_EVENTPOINT);
  775.     }
  777.  
  778. #if DBG_NO_SINGLE_STEP
  779. /*******************************************************************************
  780. *
  781. * wdbTrap - handle hitting of breakpoint
  782. *
  783. * This routine handles the breakpoint trap.  It is called only from its 
  784. * special stub routine (usually in assembly language) which is connected
  785. * to the breakpoint trap. It is used by targets that have to multiplex
  786. * tracing and breakpoint.
  787. *
  788. * NOMANUAL
  789. */
  791. static void wdbTrap
  792.     (
  793.     int level,
  794.     INSTR * addr,
  795.     void * pInfo,
  796.     WDB_IU_REGS * pRegisters,
  797.     void * pDbgRegs,
  798.     BOOL hardware
  799.     )
  800.     {
  801.     /* check for task level breakpoint trap */
  803.     if (wdbIsNowTasking())
  804. {
  805. _wdbTaskBpTrap (level, (INSTR *) pRegisters->reg_pc, pInfo, pRegisters, 
  806.     pDbgRegs, hardware);
  807. /* NOTREACHED */
  808. }
  810.     /* first handle "step mode" (trace emulation) */
  812.     if (wdbSysBpMode != 0)
  813. {
  814. wdbTrace (level, pInfo, pRegisters);
  815. /* NOTREACHED */
  816. }
  818.     /* must be a system level breakpoint */
  820.     wdbDbgBpRemoveAll (); /* remove all breakpoints */
  821.     wdbBreakpoint (level, pInfo, pRegisters, pDbgRegs, hardware);
  822.     /* NOTREACHED */
  823.     }
  824. #endif /* DBG_NO_SINGLE_STEP */
  826. /*******************************************************************************
  827. *
  828. * wdbTrace - handle trace exception
  829. *
  830. * This routine handles the trace trap.  It is called only
  831. * from its special assembly language stub routine which is connected
  832. * to the trace trap.
  833. *
  834. * NOMANUAL
  835. */
  836. static void wdbTrace
  837.     (
  838.     int level,
  839.     void * pInfo,
  840.     WDB_IU_REGS * pRegisters
  841.     )
  842.     {
  843. #if !DBG_NO_SINGLE_STEP
  844.     /* check for task level breakpoint trace */
  846.     if (wdbIsNowTasking())
  847. {
  848. _wdbTaskBpTrace (level, pInfo, pRegisters);
  849. /* NOTREACHED */
  850. }
  851. #else /* !DBG_NO_SINGLE_STEP */
  852.     usrBreakpointSet (wdbSysNpc, wdbSysNpcInstr);
  853. #endif /* DBG_NO_SINGLE_STEP */
  855.     /* system mode step */
  857.     wdbDbgTraceModeClear ((REG_SET *) pRegisters, wdbBpData);
  859.     wdbBpAddr = (TGT_ADDR_T) pRegisters->reg_pc; /* update wdbBpAddr */
  861.     if (wdbSysBpMode == WDB_STEP_OVER)
  862. {
  863. wdbSysBpMode = 0;
  864. wdbBpInstall ();
  865. WDB_CTX_LOAD (pRegisters);
  866. /* NOTREACHED */
  867. }
  869.     if ((wdbSysBpMode == WDB_STEP_RANGE) &&
  870.    (wdbSysStepStart <= (INSTR *) wdbBpAddr) &&
  871.        ((INSTR * ) wdbBpAddr < wdbSysStepEnd))
  872. {
  873. #if DBG_NO_SINGLE_STEP
  874. wdbSysNpc = wdbDbgGetNpc (pRegisters);
  875. wdbSysNpcInstr = *wdbSysNpc;
  876. usrBreakpointSet (wdbSysNpc, DBG_BREAK_INST);
  877. #endif /* DBG_NO_SINGLE_STEP */
  878. wdbBpData = wdbDbgTraceModeSet((REG_SET *) pRegisters);
  879. WDB_CTX_LOAD (pRegisters);
  880. /* NOTREACHED */
  881. }
  883.     /* blindly assume WDB_STEP */
  885.     wdbSysBpMode = 0;
  886.     wdbSuspendSystem (pRegisters, wdbSysBpPost, 0);
  887.     /* NOTREACHED */
  888.     }
  890. /*******************************************************************************
  891. *
  892. * wdbBreakpoint - handle hitting of breakpoint
  893. *
  894. * This routine handles the breakpoint trap.  It is called only from its 
  895. * special stub routine (usually in assembly language) which is connected
  896. * to the breakpoint trap.
  897. *
  898. * NOMANUAL
  899. */
  901. static void wdbBreakpoint
  902.     (
  903.     int level,
  904.     void * pInfo,
  905.     WDB_IU_REGS * pRegisters,
  906.     void * pDbgRegs,
  907.     BOOL hardware
  908.     )
  909.     {
  910.     BRKPT bpInfo; /* breakpoint info structure */
  911.     UINT32 type = 0; /* breakpoint type */
  912.     void  (*callBack)() = NULL;
  914. #if !DBG_NO_SINGLE_STEP
  915.     /* check for task level breakpoint trap */
  917.     if (wdbIsNowTasking())
  918. {
  919. _wdbTaskBpBreakpoint (level, pInfo, pRegisters, pDbgRegs, hardware);
  920. /* NOTREACHED */
  921. }
  922. #endif /* !DBG_NO_SINGLE_STEP */
  924.     wdbBpAddr = (UINT32) pRegisters->reg_pc;
  926. #if DBG_HARDWARE_BP
  927.     /* If it is a hardware breakpoint, update type and addr variable. */
  929.     if (hardware)
  930. wdbDbgHwBpFind (pDbgRegs, &type, &wdbBpAddr);
  931. #endif  /* DBG_HARDWARE_BP */
  933.     /* must be a system level breakpoint */
  935.     wdbDbgBpGet ((INSTR *)wdbBpAddr, BP_SYS, type, &bpInfo);
  937.     /* 
  938.      * On some CPU (eg I960CX), the hardware breakpoint exception is sent only
  939.      * after the instruction was executed. In that case, we consider that
  940.      * the breakpoint address is the address where the processor is stopped,
  941.      * not the real breakpoint address.
  942.      */
  944. #if DBG_HARDWARE_BP && defined (BRK_INST)
  945.     if (type == (BRK_INST | BRK_HARDWARE))
  946. wdbBpAddr = (UINT32) pRegisters->reg_pc;
  947. #endif /* DBG_HARDWARE_BP && defined (BRK_INST) */
  949.     if (bpInfo.bp_action & WDB_ACTION_CALL)
  950. bpInfo.bp_callRtn (bpInfo.bp_callArg, pRegisters);
  952.     if (bpInfo.bp_action & WDB_ACTION_NOTIFY)
  953. callBack = wdbSysBpPost;
  955. #if     CPU_FAMILY == MIPS
  957.     /*
  958.      * On MIPS CPUs, when a breakpoint exception occurs in a branch delay slot,
  959.      * the PC has been changed in the breakpoint handler to match with the
  960.      * breakpoint address.
  961.      * Once the matching has been made, the PC is modified to have its normal
  962.      * value (the preceding jump instruction).
  963.      */
  965.     if (pRegisters->cause & CAUSE_BD)   /* Are we in a branch delay slot ? */
  966.         pRegisters->reg_pc--;
  967. #endif  /* CPU_FAMILY == MIPS */
  969.     if (bpInfo.bp_action & (WDB_ACTION_NOTIFY | WDB_ACTION_STOP))
  970. {
  971. if (!(bpInfo.bp_action & WDB_ACTION_STOP))
  972.     wdbOneShot = TRUE;
  974. wdbSuspendSystem (pRegisters, callBack, 0);
  975. /* NOTREACHED */
  976. }
  978.     /* !WDB_ACTION_STOP means continue (e.g., step over this breakpoint) */
  980. #if DBG_NO_SINGLE_STEP
  981.     wdbSysNpc = wdbDbgGetNpc (pRegisters);
  982.     wdbSysNpcInstr = *wdbSysNpc;
  983.     usrBreakpointSet (wdbSysNpc, DBG_BREAK_INST);
  984. #endif /* DBG_NO_SINGLE_STEP */
  985.     wdbSysBpMode = WDB_STEP_OVER;
  986.     wdbBpData = wdbDbgTraceModeSet((REG_SET *) pRegisters);
  987.     WDB_CTX_LOAD(pRegisters);
  988.     }
  990. /******************************************************************************
  991. *
  992. * wdbE - target side code to support the windview "e" command
  993. */ 
  995. void wdbE
  996.     (
  997.     int * pData,
  998.     WDB_IU_REGS * pRegisters
  999.     )
  1000.     {
  1001.     int (*conditionFunc)() = (int (*)())pData[0];
  1002.     int conditionArg = pData[1];
  1003.     int eventNum = pData[2];
  1005.     if ((conditionFunc == NULL) || (conditionFunc (conditionArg) == OK))
  1006.         EVT_CTX_BUF (eventNum, pRegisters->reg_pc, 0, NULL);
  1007.     }
  1009. /******************************************************************************
  1010. *
  1011. * wdbTaskLock - lock the current task if the agent is running in task mode
  1012. *
  1013. * This routine locks the current task is the agent is running in 
  1014. * task mode.
  1015. * 
  1016. * RETURNS : N/A
  1017. *
  1018. * NOMANUAL
  1019. */ 
  1021. LOCAL void wdbTaskLock (void)
  1022.     {
  1023.     if (wdbIsNowTasking() && (pWdbRtIf->taskLock != NULL))
  1024. (*pWdbRtIf->taskLock) ();
  1025.     }
  1027. /******************************************************************************
  1028. *
  1029. * wdbTaskUnlock - unlock the current task if the agent is running in task mode
  1030. *
  1031. * This routine unlocks the current task is the agent is running in 
  1032. * task mode.
  1033. * 
  1034. * RETURNS : N/A
  1035. *
  1036. * NOMANUAL
  1037. */ 
  1039. LOCAL void wdbTaskUnlock (void)
  1040.     {
  1041.     if (wdbIsNowTasking() && (pWdbRtIf->taskUnlock != NULL))
  1042. (*pWdbRtIf->taskUnlock) ();
  1043.     }