* So many patches have been posted recently on the mailing list and

	because we were unable to find correct solution to compile on various
	linux distros (due to rpcgen incompatibilities), and because the coding
	style of rdbg was rather inconsistant among various pieces of code, I
	decided to:
	    1) make some cleaning regarding global coding style (using
	       indent + manual edits),
	    2) incorporate/review the paches send by various people
	       (S. Holford, T. Strauman),
	    3) Fix the bug due to varying rpcgen code generation
	       in remdeb_svc.c,
	    4) Remove some dead code,
	    5) Apply a patches enabling to call enterRdbg imediately
	       after rdbg initialization is done,

	NB : the paches is huge but it is mainly due to coding styke chnages.
	Only few lines of codes have been really changed and they do not impact
	rdbg functionnality (AFAIKT).

	* include/rdbg/servrpc.h, include/rdbg/i386/rdbg_f.h,
	include/rdbg/m68k/rdbg_f.h, include/rdbg/powerpc/rdbg_f.h,
	src/_servtgt.c, src/awk.svc, src/excep.c, src/ptrace.c, src/rdbg.c,
	src/remdeb.x, src/servbkpt.c, src/servcon.c, src/servrpc.c,
	src/servtgt.c, src/servtsp.c, src/servutil.c, src/i386/excep_f.c,
	src/i386/rdbg_f.c, src/i386/any/Makefile.am, src/i386/any/remdeb.h,
	src/i386/any/remdeb_svc.c, src/i386/any/remdeb_xdr.c,
	src/m68k/excep_f.c, src/m68k/rdbg_f.c, src/m68k/any/Makefile.am,
	src/m68k/any/remdeb.h, src/m68k/any/remdeb_svc.c,
	src/m68k/any/remdeb_xdr.c, src/powerpc/excep_f.c, src/powerpc/rdbg_f.c,
	src/powerpc/new_exception_processing/Makefile.am,
	src/powerpc/new_exception_processing/remdeb.h,
	src/powerpc/new_exception_processing/remdeb_svc.c,
	src/powerpc/new_exception_processing/remdeb_xdr.c: Modified.

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;
 }