diff options
Diffstat (limited to 'c/src/librdbg/src/servbkpt.c')
| -rw-r--r-- | c/src/librdbg/src/servbkpt.c | 853 |
1 files changed, 454 insertions, 399 deletions
diff --git a/c/src/librdbg/src/servbkpt.c b/c/src/librdbg/src/servbkpt.c index f6c76bb494..dce1b4fdf3 100644 --- a/c/src/librdbg/src/servbkpt.c +++ b/c/src/librdbg/src/servbkpt.c @@ -12,14 +12,14 @@ */ #include <sys/errno.h> -#include <assert.h> +#include <assert.h> #include <rdbg/rdbg.h> #include <rdbg/servrpc.h> /*----- Macros -----*/ #define BKPT0(plst) ((BASE_BREAK*)(plst)->break_list) -#define BKPT_INCR 5 /* how many bkpt slots alloc at a time */ +#define BKPT_INCR 5 /* how many bkpt slots alloc at a time */ #define BKPT_OVER(plst,idx,addr,size) \ ((plst)->break_list[idx].ee_loc + BREAK_SIZE > (UINT32) (addr) \ @@ -29,7 +29,6 @@ (sizeof ((xdr_break*) 0)->thread_list / \ sizeof ((xdr_break*) 0)->thread_list [0]) - /* * BreakAlloc - alloc a breakpoint entry. * @@ -38,45 +37,51 @@ * created. It returns -1 if failed. */ - static int -BreakAlloc (PID_LIST* plst, Boolean normal) + static int +BreakAlloc (PID_LIST * plst, Boolean normal) { - int idx, len; - xdr_break* blst; - - if (!normal) { /* want 0 entry */ - if (plst->break_list) { - return(0); /* already there */ - } - idx = 1; /* force alloc below */ - } else { - for (idx = 1; idx < (int)plst->break_alloc; idx++) { - if (plst->break_list[idx].type == BRKT_NONE) { - /* got a free one */ - memset(&plst->break_list[idx], 0, sizeof(xdr_break)); - return(idx); /* found one */ - } - } + int idx, len; + xdr_break *blst; + + if (!normal) { /* want 0 entry */ + if (plst->break_list) { + return (0); /* already there */ + } + idx = 1; /* force alloc below */ + } else { + for (idx = 1; idx < (int) plst->break_alloc; idx++) { + if (plst->break_list[idx].type == BRKT_NONE) { + /* + * got a free one + */ + memset (&plst->break_list[idx], 0, sizeof (xdr_break)); + return (idx); /* found one */ + } + } + } + /* + * idx is the requested entry + */ + + if (idx >= (int) plst->break_alloc) { /* need more space */ + len = plst->break_alloc + BKPT_INCR; + blst = (xdr_break *) Realloc (plst->break_list, len * sizeof (xdr_break)); + if (!blst) { + return (-1); /* failed, no space */ } - /* idx is the requested entry */ - - if (idx >= (int)plst->break_alloc) { /* need more space */ - len = plst->break_alloc + BKPT_INCR; - blst = (xdr_break*)Realloc(plst->break_list, len*sizeof(xdr_break)); - if (!blst) { - return(-1); /* failed, no space */ - } - plst->break_alloc = len; /* got more */ - plst->break_list = blst; - - /* Clear new space */ - memset(blst + len - BKPT_INCR, 0, BKPT_INCR * sizeof(xdr_break)); - idx = len - BKPT_INCR; /* next available */ - if (!idx) { - idx = 1; /* for normal cases */ - } + plst->break_alloc = len; /* got more */ + plst->break_list = blst; + + /* + * Clear new space + */ + memset (blst + len - BKPT_INCR, 0, BKPT_INCR * sizeof (xdr_break)); + idx = len - BKPT_INCR; /* next available */ + if (!idx) { + idx = 1; /* for normal cases */ } - return(normal ? idx : 0); /* return it */ + } + return (normal ? idx : 0); /* return it */ } /* @@ -86,237 +91,259 @@ BreakAlloc (PID_LIST* plst, Boolean normal) */ #ifdef DDEBUG -static const char* BreakTypes[] = { - "NONE", "INSTR", "READ", "WRITE", - "ACCESS", "EXEC", "OS_CALL", "OS_SWITCH", - "STEPEMUL" +static const char *BreakTypes[] = { + "NONE", "INSTR", "READ", "WRITE", + "ACCESS", "EXEC", "OS_CALL", "OS_SWITCH", + "STEPEMUL" }; #define BN_MAX (sizeof BreakTypes / sizeof BreakTypes[0]) #define BREAK_NAME(t) ((unsigned) (t) < BN_MAX ? BreakTypes[t] : "???") #endif - int -BreakSet (PID_LIST* plst, int conn_idx, xdr_break* bkpt) + int +BreakSet (PID_LIST * plst, int conn_idx, xdr_break * bkpt) { - int pid = plst->pid; - int type = bkpt->type; - void* addr = (void *) bkpt->ee_loc; - int idx; - int data; - - DPRINTF(("BreakSet: type %d (%s) at 0x%x th %d ee_type %d len %d " - "pass %d curr %d list %d %d %d %d\n", type, BREAK_NAME(type), - (int) addr, - bkpt->thread_spec, bkpt->ee_type, bkpt->length, bkpt->pass_count, - bkpt->curr_pass, bkpt->thread_list [0], bkpt->thread_list [1], - bkpt->thread_list [2], bkpt->thread_list [3])); - - idx = BreakAlloc(plst, True); /* get entry */ - if (idx < 0) { /* no memory */ - setErrno(ENOMEM); /* set for safety */ - return -1; /* return the error */ - } - - data = TgtPtrace(RPT_PEEKTEXT, pid, addr, 0, NULL); /* current */ - if (getErrno()) { - return -1; /* failed, return the error */ + int pid = plst->pid; + int type = bkpt->type; + void *addr = (void *) bkpt->ee_loc; + int idx; + int data; + + DPRINTF (("BreakSet: type %d (%s) at 0x%x th %d ee_type %d len %d " + "pass %d curr %d list %d %d %d %d\n", type, BREAK_NAME (type), + (int) addr, + bkpt->thread_spec, bkpt->ee_type, bkpt->length, bkpt->pass_count, + bkpt->curr_pass, bkpt->thread_list[0], bkpt->thread_list[1], + bkpt->thread_list[2], bkpt->thread_list[3])); + + idx = BreakAlloc (plst, True); /* get entry */ + if (idx < 0) { /* no memory */ + setErrno (ENOMEM); /* set for safety */ + return -1; /* return the error */ + } + + data = TgtPtrace (RPT_PEEKTEXT, pid, addr, 0, NULL); /* current */ + if (getErrno ()) { + return -1; /* failed, return the error */ + } + if (IS_BREAK (data)) { /* There is already a break here */ + DPRINTF (("BreakSet: already have soft bkpt at %x\n", addr)); + if (type == BRKT_STEPEMUL) { + ++BKPT0 (plst)->pad1; + return 1; /* Any non-error value is OK */ } - if (IS_BREAK(data)) { /* There is already a break here */ - DPRINTF(("BreakSet: already have soft bkpt at %x\n", addr)); - if (type == BRKT_STEPEMUL) { - ++BKPT0 (plst)->pad1; - return 1; /* Any non-error value is OK */ - } - setErrno(EBUSY); - return -1; - } - - TgtPtrace(RPT_POKETEXT, pid, addr, SET_BREAK(data), NULL); - - if (getErrno()) { - return -1; - } - - plst->break_list[idx] = *bkpt; - plst->break_list[idx].ee_type = data; /* saved data */ - - /* Inform other owners */ - if (type != BRKT_STEPEMUL) { - TgtNotifyAll (plst - pid_list, BMSG_BREAK, 1 /*added*/, idx, - conn_idx, False); - } else { - ++BKPT0 (plst)->pad1; - } - /* Return the number */ - setErrno(0); /* Just in case */ - return idx; + setErrno (EBUSY); + return -1; + } + + TgtPtrace (RPT_POKETEXT, pid, addr, SET_BREAK (data), NULL); + + if (getErrno ()) { + return -1; + } + + plst->break_list[idx] = *bkpt; + plst->break_list[idx].ee_type = data; /* saved data */ + + /* + * Inform other owners + */ + if (type != BRKT_STEPEMUL) { + TgtNotifyAll (plst - pid_list, BMSG_BREAK, 1 /*added */ , idx, + conn_idx, False); + } else { + ++BKPT0 (plst)->pad1; + } + /* + * Return the number + */ + setErrno (0); /* Just in case */ + return idx; } - int -BreakSetAt (PID_LIST* plst, int conn_idx, unsigned long addr, break_type type) + int +BreakSetAt (PID_LIST * plst, int conn_idx, unsigned long addr, + break_type type) { - xdr_break xb; + xdr_break xb; - memset (&xb, 0, sizeof xb); - xb.type = type; - xb.ee_loc = addr; - return BreakSet (plst, conn_idx, &xb); + memset (&xb, 0, sizeof xb); + xb.type = type; + xb.ee_loc = addr; + return BreakSet (plst, conn_idx, &xb); } /*----- Find a breakpoint by address -----*/ - int -BreakGetIndex(PID_LIST* plst, void* addr) + int +BreakGetIndex (PID_LIST * plst, void *addr) { - int idx; - int data = -1; - - if (!plst->break_alloc) { - setErrno(EFAULT); - return -1; - } - for (idx = 1; idx < (int)plst->break_alloc; idx++) { - if ((u_long) addr == plst->break_list [idx].ee_loc) { - data = idx; - break; - } + int idx; + int data = -1; + + if (!plst->break_alloc) { + setErrno (EFAULT); + return -1; + } + for (idx = 1; idx < (int) plst->break_alloc; idx++) { + if ((u_long) addr == plst->break_list[idx].ee_loc) { + data = idx; + break; } - return data; + } + return data; } /*----- Getting information about breakpoint -----*/ /* - * If data > 0, fill "bkpt" with information about breakpoint + * If data > 0, fill "bkpt" with information about breakpoint * and return the number of the next one. * If data == 0, return the count of breakpoints. */ - int -BreakGet (const PID_LIST* plst, int data, xdr_break* bkpt) + int +BreakGet (const PID_LIST * plst, int data, xdr_break * bkpt) { - int idx; - - if (!data) { /* just count them */ - for (idx = 1; idx < (int)plst->break_alloc; idx++) { - if (plst->break_list[idx].type != BRKT_NONE) { - data++; - } - } - return data; /* count */ - } - if ((unsigned) data >= plst->break_alloc) { - /* out of range */ - setErrno(EFAULT); /* closest match */ - return -1; + int idx; + + if (!data) { /* just count them */ + for (idx = 1; idx < (int) plst->break_alloc; idx++) { + if (plst->break_list[idx].type != BRKT_NONE) { + data++; + } } - /* get it and say which is next */ - *bkpt = plst->break_list[data]; - for (idx = (int)data+1; idx < (int)plst->break_alloc; idx++) { - if (plst->break_list[idx].type != BRKT_NONE) { - return idx; - } + return data; /* count */ + } + if ((unsigned) data >= plst->break_alloc) { + /* + * out of range + */ + setErrno (EFAULT); /* closest match */ + return -1; + } + /* + * get it and say which is next + */ + *bkpt = plst->break_list[data]; + for (idx = (int) data + 1; idx < (int) plst->break_alloc; idx++) { + if (plst->break_list[idx].type != BRKT_NONE) { + return idx; } - return 0; /* otherwise returns 0 for no more */ + } + return 0; /* otherwise returns 0 for no more */ } /*----- Clearing bkpts -----*/ /* - * BreakClear - clear one (if data != 0) or all breakpoints + * BreakClear - clear one (if data != 0) or all breakpoints * (if data == 0). Return the number of bkpts cleared. * If (data == -1), remove step-emulation breakpoints. */ - int -BreakClear (PID_LIST* plst, int conn_idx, int data) + int +BreakClear (PID_LIST * plst, int conn_idx, int data) { - int pid_idx = plst - pid_list; - int idx; - int cleared = 0; - int clearStepEmul = 0; - int terminated = PROC_TERMINATED (plst); - int stepEmulCount = 0; - - /* break handle in data */ - if (!plst->break_alloc) { /* there are no breaks */ - DPRINTF (("BreakClear: no bkpts defined.\n")); - setErrno(EFAULT); /* closest match */ - return -1; /* return error */ - } - if (!data) { /* clear all */ - idx = 1; - data = plst->break_alloc-1; - - /* Inform other owners */ - DPRINTF (("BreakClear: clearing all bkpts.\n")); - TgtNotifyAll (pid_idx, BMSG_BREAK, 0 /*clr*/, 0, conn_idx, False); - - } else if (data == -1) { /* clear all step-emul bkpts */ - DPRINTF(("BreakClear: removing %d step-emul bkpts\n", - BKPT0 (plst)->pad1)); - - stepEmulCount = BKPT0 (plst)->pad1; - BKPT0 (plst)->pad1 = 0; - - clearStepEmul = 1; - idx = 1; - data = plst->break_alloc-1; - } else if ((unsigned) data >= plst->break_alloc - || plst->break_list[data].type == BRKT_NONE) { - - /* out of range */ - DPRINTF (("BreakClear: invalid bkpt %d\n", data)); - setErrno(EFAULT); /* closest match */ - return -1; /* return error */ - } else { - idx = data; - /* Inform other owners */ - TgtNotifyAll (pid_idx, BMSG_BREAK, 0 /*clr*/, idx, conn_idx, False); - DPRINTF (("BreakClear: clearing bkpt %d\n", data)); - } + int pid_idx = plst - pid_list; + int idx; + int cleared = 0; + int clearStepEmul = 0; + int terminated = PROC_TERMINATED (plst); + int stepEmulCount = 0; + + /* + * break handle in data + */ + if (!plst->break_alloc) { /* there are no breaks */ + DPRINTF (("BreakClear: no bkpts defined.\n")); + setErrno (EFAULT); /* closest match */ + return -1; /* return error */ + } + if (!data) { /* clear all */ + idx = 1; + data = plst->break_alloc - 1; - for (; idx <= data; idx++) { /* clear each one */ - int type = plst->break_list[idx].type; - - if (clearStepEmul && type != BRKT_STEPEMUL) continue; - - if (type == BRKT_INSTR || (clearStepEmul && type == BRKT_STEPEMUL)) { - /* just patch back */ - char* addr = (char *)plst->break_list[idx].ee_loc; - int val; - - if (BKPT0 (plst)->clr_step && BKPT0 (plst)->last_break == idx) { - BKPT0 (plst)->clr_step = 0; /* not needed */ - } - /* Neighboring bytes can have breakpoints too... */ - if (! terminated) { - setErrno (0); - val = TgtPtrace(RPT_PEEKTEXT, plst->pid, addr, 0, NULL); - if (getErrno()) { - DPRINTF (("BreakClear: addr %x not readable!\n", addr)); - setErrno (0); /* Forget bkpt */ - } else { - assert (IS_BREAK (val)); - val = ORG_BREAK (val, (int)plst->break_list[idx].ee_type); - TgtPtrace(RPT_POKETEXT, plst->pid, addr, val, NULL); - if (getErrno()) { - DPRINTF (("BreakClear: addr %x not writable!\n", addr)); - setErrno (0); - } - } - } - ++cleared; /* indicate cleared */ - } - memset(&plst->break_list[idx], 0, sizeof(xdr_break)); - } - assert (!clearStepEmul || cleared <= stepEmulCount); - if (stepEmulCount && cleared == 0) { - DPRINTF (("BreakClear: all STEPEMUL bkpts were shared\n")); - return 1; + /* + * Inform other owners + */ + DPRINTF (("BreakClear: clearing all bkpts.\n")); + TgtNotifyAll (pid_idx, BMSG_BREAK, 0 /*clr */ , 0, conn_idx, False); + + } else if (data == -1) { /* clear all step-emul bkpts */ + DPRINTF (("BreakClear: removing %d step-emul bkpts\n", + BKPT0 (plst)->pad1)); + + stepEmulCount = BKPT0 (plst)->pad1; + BKPT0 (plst)->pad1 = 0; + + clearStepEmul = 1; + idx = 1; + data = plst->break_alloc - 1; + } else if ((unsigned) data >= plst->break_alloc + || plst->break_list[data].type == BRKT_NONE) { + + /* + * out of range + */ + DPRINTF (("BreakClear: invalid bkpt %d\n", data)); + setErrno (EFAULT); /* closest match */ + return -1; /* return error */ + } else { + idx = data; + /* + * Inform other owners + */ + TgtNotifyAll (pid_idx, BMSG_BREAK, 0 /*clr */ , idx, conn_idx, False); + DPRINTF (("BreakClear: clearing bkpt %d\n", data)); + } + + for (; idx <= data; idx++) { /* clear each one */ + int type = plst->break_list[idx].type; + + if (clearStepEmul && type != BRKT_STEPEMUL) + continue; + + if (type == BRKT_INSTR || (clearStepEmul && type == BRKT_STEPEMUL)) { + /* + * just patch back + */ + char *addr = (char *) plst->break_list[idx].ee_loc; + int val; + + if (BKPT0 (plst)->clr_step && BKPT0 (plst)->last_break == idx) { + BKPT0 (plst)->clr_step = 0; /* not needed */ + } + /* + * Neighboring bytes can have breakpoints too... + */ + if (!terminated) { + setErrno (0); + val = TgtPtrace (RPT_PEEKTEXT, plst->pid, addr, 0, NULL); + if (getErrno ()) { + DPRINTF (("BreakClear: addr %x not readable!\n", addr)); + setErrno (0); /* Forget bkpt */ + } else { + assert (IS_BREAK (val)); + val = ORG_BREAK (val, (int) plst->break_list[idx].ee_type); + TgtPtrace (RPT_POKETEXT, plst->pid, addr, val, NULL); + if (getErrno ()) { + DPRINTF (("BreakClear: addr %x not writable!\n", addr)); + setErrno (0); + } + } + } + ++cleared; /* indicate cleared */ } - return cleared; + memset (&plst->break_list[idx], 0, sizeof (xdr_break)); + } + assert (!clearStepEmul || cleared <= stepEmulCount); + if (stepEmulCount && cleared == 0) { + DPRINTF (("BreakClear: all STEPEMUL bkpts were shared\n")); + return 1; + } + return cleared; } /*----- Hiding of breakpoints -----*/ @@ -329,70 +356,84 @@ BreakClear (PID_LIST* plst, int conn_idx, int data) * buffer from a ptrace read/peek. */ - static void -PatchBreak (char* buff, UINT32 bstart, int bsize, UINT32 dstart, char* dvalue) + static void +PatchBreak (char *buff, UINT32 bstart, int bsize, UINT32 dstart, char *dvalue) { - int size = BREAK_SIZE; /* default size */ - - /* Must deal with all sorts of unalignments - * (3 full overlaps, 3 unaligns) - */ - if (bsize < BREAK_SIZE) { - /* case where buffer is smaller than data */ - memcpy(buff, dvalue+(bstart-dstart), bsize); /* copy over */ - return; - } - /* buffer larger than data. - * we need to see where break fits in buffer and whether - * we have part of it off the end. We set bstart to be the - * buffer offset, dtart to be the break data offset, and - * size to be the amount to copy - */ - if (dstart < bstart) { - /* break before actual buffer */ - dstart = bstart-dstart; /* offset in data */ - size -= dstart; /* amount to copy */ - bstart = 0; /* offset in buffer */ - - } else if (dstart + size > bstart + bsize) { - /* off end */ - bstart += bsize; /* end of buffer */ - size -= (dstart + size) - bstart; - bstart = bsize - size; /* come back into buffer enough */ - dstart = 0; /* start of data */ - - } else { /* normal case */ - bstart = dstart - bstart; /* offset in buffer */ - dstart = 0; - } - memcpy(buff+bstart, dvalue+dstart, size); + int size = BREAK_SIZE; /* default size */ + + /* + * Must deal with all sorts of unalignments + * * (3 full overlaps, 3 unaligns) + */ + if (bsize < BREAK_SIZE) { + /* + * case where buffer is smaller than data + */ + memcpy (buff, dvalue + (bstart - dstart), bsize); /* copy over */ + return; + } + /* + * buffer larger than data. + * * we need to see where break fits in buffer and whether + * * we have part of it off the end. We set bstart to be the + * * buffer offset, dtart to be the break data offset, and + * * size to be the amount to copy + */ + if (dstart < bstart) { + /* + * break before actual buffer + */ + dstart = bstart - dstart; /* offset in data */ + size -= dstart; /* amount to copy */ + bstart = 0; /* offset in buffer */ + + } else if (dstart + size > bstart + bsize) { + /* + * off end + */ + bstart += bsize; /* end of buffer */ + size -= (dstart + size) - bstart; + bstart = bsize - size; /* come back into buffer enough */ + dstart = 0; /* start of data */ + + } else { /* normal case */ + bstart = dstart - bstart; /* offset in buffer */ + dstart = 0; + } + memcpy (buff + bstart, dvalue + dstart, size); } - void -BreakHide (const PID_LIST* plst, void* addr, int data, void* addr2) + void +BreakHide (const PID_LIST * plst, void *addr, int data, void *addr2) { - int idx; - - if (!plst->break_list) /* no breaks exist, so skip this */ - return; + int idx; - /* if breakpoints, replace */ + if (!plst->break_list) /* no breaks exist, so skip this */ + return; - for (idx = 1; idx < (int)plst->break_alloc; idx++) { - int type = plst->break_list[idx].type; + /* + * if breakpoints, replace + */ - if (type != BRKT_INSTR && type != BRKT_STEPEMUL) { - continue; - } - /* break, see if overlaps */ - if (BKPT_OVER (plst, idx, addr, data)) { + for (idx = 1; idx < (int) plst->break_alloc; idx++) { + int type = plst->break_list[idx].type; - /* overlaps, patch in old value */ - PatchBreak((char *)addr2, (UINT32)addr, data, - plst->break_list[idx].ee_loc, - (char *)&plst->break_list[idx].ee_type); - } + if (type != BRKT_INSTR && type != BRKT_STEPEMUL) { + continue; + } + /* + * break, see if overlaps + */ + if (BKPT_OVER (plst, idx, addr, data)) { + + /* + * overlaps, patch in old value + */ + PatchBreak ((char *) addr2, (UINT32) addr, data, + plst->break_list[idx].ee_loc, + (char *) &plst->break_list[idx].ee_type); } + } } /*----- Checking of breakpoint overwrites -----*/ @@ -402,27 +443,29 @@ BreakHide (const PID_LIST* plst, void* addr, int data, void* addr2) * having software breakpoints. */ - int -BreakOverwrite (const PID_LIST* plst, const char* addr, unsigned int size) + int +BreakOverwrite (const PID_LIST * plst, const char *addr, unsigned int size) { - int idx; + int idx; - if (!plst->break_list) { /* No breaks exist */ - return 0; - } + if (!plst->break_list) { /* No breaks exist */ + return 0; + } - for (idx = 1; idx < (int)plst->break_alloc; idx++) { - int type = plst->break_list[idx].type; + for (idx = 1; idx < (int) plst->break_alloc; idx++) { + int type = plst->break_list[idx].type; - /* Consider only breakpoints involving modified memory */ - if (type != BRKT_INSTR && type != BRKT_STEPEMUL) { - continue; - } - if (BKPT_OVER (plst, idx, addr, size)) { - return -1; /* overlaps */ - } + /* + * Consider only breakpoints involving modified memory + */ + if (type != BRKT_INSTR && type != BRKT_STEPEMUL) { + continue; } - return 0; + if (BKPT_OVER (plst, idx, addr, size)) { + return -1; /* overlaps */ + } + } + return 0; } /*----- Execution support -----*/ @@ -433,19 +476,21 @@ BreakOverwrite (const PID_LIST* plst, const char* addr, unsigned int size) * Range is saved in breakpoint 0. */ - int -BreakStepRange (PID_LIST* plst, void* addr, int len) + int +BreakStepRange (PID_LIST * plst, void *addr, int len) { - if (!plst->break_list) { - /* get list */ - if (BreakAlloc (plst, False) == -1) { /* must not be any memory */ - setErrno(ENOMEM); /* to be safe */ - return -1; /* fails */ - } + if (!plst->break_list) { + /* + * get list + */ + if (BreakAlloc (plst, False) == -1) { /* must not be any memory */ + setErrno (ENOMEM); /* to be safe */ + return -1; /* fails */ } - BKPT0 (plst)->range_start = (UINT32)addr; - BKPT0 (plst)->range_end = (UINT32)addr+(len-1); - return 0; + } + BKPT0 (plst)->range_start = (UINT32) addr; + BKPT0 (plst)->range_end = (UINT32) addr + (len - 1); + return 0; } /* @@ -453,137 +498,147 @@ BreakStepRange (PID_LIST* plst, void* addr, int len) * current breakpoint has not been reached yet. */ - void -BreakPcChanged (PID_LIST* plst) + void +BreakPcChanged (PID_LIST * plst) { - if (plst->break_list) { - /* clear break stuff */ - BKPT0 (plst)->clr_step = False; - } + if (plst->break_list) { + /* + * clear break stuff + */ + BKPT0 (plst)->clr_step = False; + } } /* * BreakStepOff - prepare stepping off a breakpoint. */ - int -BreakStepOff (const PID_LIST* plst, void** paddr2) + int +BreakStepOff (const PID_LIST * plst, void **paddr2) { - if (plst->break_list && BKPT0 (plst)->clr_step) { + if (plst->break_list && BKPT0 (plst)->clr_step) { - /* need clear then step off break */ - int last = BKPT0 (plst)->last_break; + /* + * need clear then step off break + */ + int last = BKPT0 (plst)->last_break; - /* clear break, step, then do exec */ + /* + * clear break, step, then do exec + */ - *paddr2 = (void*) plst->break_list[last].ee_type; + *paddr2 = (void *) plst->break_list[last].ee_type; - /* Need to clr_step after TgtPtrace() when wait() returns */ - return 1; - } - return 0; + /* + * Need to clr_step after TgtPtrace() when wait() returns + */ + return 1; + } + return 0; } /* - * BreakSteppedOff - check if just stepped off a breakpoint + * BreakSteppedOff - check if just stepped off a breakpoint * and re-insert it into the code. */ - void -BreakSteppedOff (PID_LIST* plst) + void +BreakSteppedOff (PID_LIST * plst) { - if (plst->break_list && BKPT0 (plst)->clr_step) { - int idx = BKPT0 (plst)->last_break; - int data; - - BKPT0 (plst)->clr_step = 0; - - /* - * Re-insert the breakpoint. - */ - data = TgtPtrace (RPT_PEEKTEXT, plst->pid, - (char *)plst->break_list [idx].ee_loc, 0, NULL); - assert (! IS_BREAK (data)); - TgtPtrace (RPT_POKETEXT, plst->pid, - (char *)plst->break_list[idx].ee_loc, - (int) SET_BREAK (data), NULL); - } -} + if (plst->break_list && BKPT0 (plst)->clr_step) { + int idx = BKPT0 (plst)->last_break; + int data; + BKPT0 (plst)->clr_step = 0; + + /* + * Re-insert the breakpoint. + */ + data = TgtPtrace (RPT_PEEKTEXT, plst->pid, + (char *) plst->break_list[idx].ee_loc, 0, NULL); + assert (!IS_BREAK (data)); + TgtPtrace (RPT_POKETEXT, plst->pid, + (char *) plst->break_list[idx].ee_loc, + (int) SET_BREAK (data), NULL); + } +} /* * Returns whether a thread matches a breakpoint. */ - static int -BreakThreadMatch (xdr_break* xb, int thread) + static int +BreakThreadMatch (xdr_break * xb, int thread) { - int slot; + int slot; - if (thread < 0) return 1; /* Break existence check only */ + if (thread < 0) + return 1; /* Break existence check only */ - if (xb->thread_list [0] == 0) return 1; /* Universal break */ + if (xb->thread_list[0] == 0) + return 1; /* Universal break */ - for (slot = 0; slot < BKPT_SLOTS; ++slot) { - if (xb->thread_list [slot] == 0) return 0; /* End of list */ - if (xb->thread_list [slot] == thread) return 1; /* Match */ - } - return 0; /* No matches found */ + for (slot = 0; slot < BKPT_SLOTS; ++slot) { + if (xb->thread_list[slot] == 0) + return 0; /* End of list */ + if (xb->thread_list[slot] == thread) + return 1; /* Match */ + } + return 0; /* No matches found */ } - -int -BreakAdjustPC (PID_LIST* plst) + int +BreakAdjustPC (PID_LIST * plst) { - /* - * BREAK_ADJ is the value by which the Program Counter - * has to be decremented after a software breakpoint - * is hit. It must be defined and can be zero. - */ + /* + * BREAK_ADJ is the value by which the Program Counter + * has to be decremented after a software breakpoint + * is hit. It must be defined and can be zero. + */ #if BREAK_ADJ - /* subtract back if necessary */ - plst->regs.REG_PC -= BREAK_ADJ; /* now write back */ - TgtPtrace(RPT_SETREGS, plst->pid, (char *)&plst->regs, 0, NULL); + /* + * subtract back if necessary + */ + plst->regs.REG_PC -= BREAK_ADJ; /* now write back */ + TgtPtrace (RPT_SETREGS, plst->pid, (char *) &plst->regs, 0, NULL); #else - (void) plst; + (void) plst; #endif - return 0; + return 0; } - /* * Identify the current breakpoint. The process just stopped. */ - int -BreakIdentify (PID_LIST* plst, int adjust, int thread) + int +BreakIdentify (PID_LIST * plst, int adjust, int thread) { - int foreignBkpt = 0; - int bidx; - - for (bidx = 1; bidx < (int) plst->break_alloc; bidx++) { - int type = plst->break_list[bidx].type; - - if ((type == BRKT_INSTR || type == BRKT_STEPEMUL) - && plst->regs.REG_PC - BREAK_ADJ - == plst->break_list[bidx].ee_loc) { /* found matching */ - if (!BreakThreadMatch (&plst->break_list[bidx], thread)) { - if (foreignBkpt == 0) { - foreignBkpt = bidx; - } - continue; - } - if (adjust) { - BreakAdjustPC (plst); - } - return bidx; - } + int foreignBkpt = 0; + int bidx; + + for (bidx = 1; bidx < (int) plst->break_alloc; bidx++) { + int type = plst->break_list[bidx].type; + + if ((type == BRKT_INSTR || type == BRKT_STEPEMUL) + && plst->regs.REG_PC - BREAK_ADJ == plst->break_list[bidx].ee_loc) { /* found matching */ + if (!BreakThreadMatch (&plst->break_list[bidx], thread)) { + if (foreignBkpt == 0) { + foreignBkpt = bidx; + } + continue; + } + if (adjust) { + BreakAdjustPC (plst); + } + return bidx; } - if (foreignBkpt) { - if (adjust) { - BreakAdjustPC (plst); - } - return -foreignBkpt; + } + if (foreignBkpt) { + if (adjust) { + BreakAdjustPC (plst); } - return 0; + return -foreignBkpt; + } + return 0; } |