/* implementation of dump/restore commands */
-extern long pointer_size;
extern p_tree get_from_item_list();
+extern t_addr get_dump();
struct dump {
char *globals, *stack;
error("could not allocate enough memory");
return;
}
- if (! get_dump(&d->mglobal, &d->globals, &d->mstack, &d->stack)) {
+ p->t_address = get_dump(&d->mglobal, &d->globals, &d->mstack, &d->stack);
+ if (! p->t_address) {
free((char *) d);
return;
}
p->t_args[0] = (struct tree *) d;
- p->t_address = (t_addr) get_int(d->mglobal.m_buf+PC_OFF*pointer_size, pointer_size, T_UNSIGNED);
add_to_item_list(p);
d->next = last_dump;
last_dump = d;
}
fprintf(db_out, "EM registers %d levels back:\n", n);
fprintf(db_out, "\tLocalBase =\t0x%lx\n\tArgumentBase =\t0x%lx\n",
- (long) buf[LB_OFF], (long) buf[AB_OFF]);
+ (long) buf[0], (long) buf[1]);
fprintf(db_out, "\tProgramCounter=\t0x%lx\n\tHeapPointer = \t0x%lx\n",
- (long) buf[PC_OFF],
- (long) buf[HP_OFF]);
- fprintf(db_out, "\tStackPointer =\t0x%lx\n", (long) buf[SP_OFF]);
+ (long) buf[2],
+ (long) buf[3]);
+ fprintf(db_out, "\tStackPointer =\t0x%lx\n", (long) buf[4]);
}
/* ------------------------------------------------------------- */
if (p && p->t_ival < 0) {
for (;;) {
buf = get_EM_regs(i++);
- if (! buf || ! buf[AB_OFF]) break;
- PC = buf[PC_OFF];
+ if (! buf || ! buf[1]) break;
+ PC = buf[2];
sc = base_scope(get_scope_from_addr(PC));
if (! sc || sc->sc_start > PC) break;
if (interrupted) return;
if (interrupted) return;
if (! (buf = get_EM_regs(i++))) break;
- AB = buf[AB_OFF];
- PC = buf[PC_OFF];
+ AB = buf[1];
+ PC = buf[2];
if (! AB) break;
sc = base_scope(get_scope_from_addr(PC));
if (! sc || sc->sc_start > PC) break;
/* $Header$ */
-#define BUFLEN 24 /* size of buffer in message header */
+#define BUFLEN 32 /* size of buffer in message header */
+
+#define M_DB_RUN 0100 /* set for commands that cause child to run */
+#define M_DB_SS 0200 /* debugger wants single stepping (to be orred
+ with SETSS(F) or CONT
+ */
+
+#define m_type m_buf[0]
+
+#ifdef DEBUGGEE
+#define PS sizeof(char *)
+#define LS sizeof(long)
+#else
+#define PS pointer_size
+#define LS long_size
+#endif
struct message_hdr {
- int m_type;
-/* Possible values of m_type: */
-#define M_DB_RUN 020000 /* set for commands that cause child to run */
-#define M_SETBP 0 /* set breakpoint at address in m_size */
-#define M_CLRBP 1 /* clear breakpoint at address in m_size */
-#define M_SETSS (2|M_DB_RUN) /* set single stepping, # of steps in m_size */
-#define M_SETSSF (3|M_DB_RUN) /* set single stepping, counting calls as one step */
-#define M_GETEMREGS 4 /* get EM registers, m_size contains level */
-#define M_GETBYTES 5 /* get data; m_size contains size, m_buf contains address */
-#define M_GETSTR 6 /* get string; m_buf contains address */
-#define M_SETBYTES 7 /* set data; m_buf contains address, m_size contains size */
-#define M_CALL 8 /* call function;
- m_size contains size of parameter buffer,
- m_buf contains address + size of function result
- */
-#define M_CONT (9|M_DB_RUN) /* continue */
-#define M_SETEMREGS 10 /* set EM registers, m_size contains level
- Actually, only the program counter is set.
- */
-#define M_DB_SS 040000 /* debugger wants single stepping (to be orred with
- SETSS(F) or CONT
- */
-#define M_CLRSS 12 /* clear single stepping */
-#define M_DUMP 13 /* dump command */
-#define M_DGLOB 14 /* data area */
+ char m_buf[BUFLEN];
+/* Possible values of m_buf[0]: */
+#define M_SETBP 0 /* set breakpoint at address in next PS bytes */
+#define M_CLRBP 1 /* clear breakpoint at address in next PS bytes */
+#define M_SETSS (2|M_DB_RUN)
+ /* set single stepping, # of steps in next LS bytes */
+#define M_SETSSF (3|M_DB_RUN)
+ /* set single stepping,
+ counting calls as one step
+ */
+#define M_GETEMREGS 4 /* get EM registers, level in next LS bytes */
+#define M_GETBYTES 5 /* get data; size in next LS bytes,
+ address in next PS bytes
+ */
+#define M_GETSTR 6 /* get string; max size in next LS bytes,
+ address in next PS bytes
+ */
+#define M_SETBYTES 7 /* get data; size in next LS bytes,
+ address in next PS bytes
+ */
+/* #define M_CALL 8 /* call function; not implemented */
+#define M_CONT (9|M_DB_RUN)
+ /* continue */
+#define M_SETEMREGS 10 /* set EM registers, level in next LS bytes;
+ Actually, only the program counter is set.
+ */
+#define M_CLRSS 12 /* clear single stepping */
+#define M_DUMP 13 /* dump command */
+#define M_DGLOB 14 /* data area */
#define M_DSTACK 15 /* stack area */
-#define M_SETTRACE 16 /* start tracing; range in m_mes */
-#define M_CLRTRACE 17 /* end tracing */
+#define M_SETTRACE 16 /* start tracing; range in next two PS bytes */
+#define M_CLRTRACE 17 /* end tracing */
-#define M_OK 50 /* answer of child to most messages */
-#define M_FAIL 51 /* answer of child when something goes wrong */
-#define M_DATA 52 /* answer of child when data requested */
-#define M_END_SS 53 /* when stopped because of user single stepping */
-#define M_INTR 54 /* sent on interrupt */
- long m_size; /* size */
- char m_buf[BUFLEN]; /* some of the data required included in message */
+#define M_OK 50 /* answer of child to most messages */
+#define M_FAIL 51 /* answer of child when something goes wrong */
+#define M_DATA 52 /* answer of child when data requested */
+#define M_END_SS 53 /* stopped because of user single stepping */
+#define M_INTR 54 /* sent on interrupt */
};
-#define LB_OFF 0
-#define AB_OFF 1
-#define PC_OFF 2
-#define HP_OFF 3
-#define SP_OFF 4
-
-#define IN_FD 3
-#define OUT_FD 6
+#define LB_OFF (0*PS+LS+1)
+#define AB_OFF (1*PS+LS+1)
+#define PC_OFF (2*PS+LS+1)
+#define HP_OFF (3*PS+LS+1)
+#define SP_OFF (4*PS+LS+1)
static t_addr curr_stop;
p_tree run_command;
+static
+ITOBUF(p, l, sz)
+ register char *p;
+ long l;
+ int sz;
+{
+ register int i;
+
+ p +=sz;
+ for (i = sz; i > 0; i--) {
+ *--p = l;
+ l >>= 8;
+ }
+}
+
+static long
+BUFTOI(p, sz)
+ register char *p;
+ int sz;
+{
+ register long l = 0;
+ register int i;
+
+ for (i = sz; i>0; i--) {
+ l = (l << 8) | (*p++ & 0377);
+ }
+ return l;
+}
+
int
init_run()
{
/* take file descriptors so that listing cannot take them */
int i;
- for (i = IN_FD; i <= OUT_FD; i++) close(i);
+ for (i = 3; i <= 6; i++) close(i);
if (pipe(fild1) < 0 ||
pipe(fild2) < 0 ||
- fild1[0] != IN_FD ||
- fild2[1] != OUT_FD) {
+ fild1[0] != 3 ||
+ fild2[1] != 6) {
return 0;
}
to_child = fild1[1];
init_run();
return 0;
}
- curr_stop = m.m_size;
+ curr_stop = BUFTOI(m.m_buf+1, (int) PS);
CurrentScope = get_scope_from_addr(curr_stop);
}
perform_items();
if (! level) {
child_interrupted = 0;
interrupted = 0;
- stopped("interrupted", (t_addr) answer.m_size);
+ stopped("interrupted", (t_addr) BUFTOI(answer.m_buf+1, (int)PS));
}
return 1;
}
level--;
return 1;
}
- a = answer.m_size;
- type = answer.m_type;
+ a = BUFTOI(answer.m_buf+1, (int)PS);
+ type = answer.m_type & 0377;
if (m->m_type & M_DB_RUN) {
/* run command */
CurrentScope = get_scope_from_addr((t_addr) a);
have gotten END_SS.
So, continue.
*/
- if ((m->m_type & ~ M_DB_SS) != M_CONT) {
+ if ((m->m_type & 0177) != M_CONT) {
m->m_type = M_CONT | (m->m_type & M_DB_SS);
}
continue;
struct message_hdr m;
m.m_type = kind;
- m.m_size = size;
- put_int(m.m_buf, pointer_size, (long)from);
+ ITOBUF(m.m_buf+1, size, (int) LS);
+ ITOBUF(m.m_buf+LS+1, (long)from, (int) PS);
if (! could_send(&m, 0)) {
return 0;
error("interrupted");
return 0;
case M_DATA:
- return ureceive(to, answer.m_size);
+ return ureceive(to, BUFTOI(answer.m_buf+1, (int)LS));
default:
assert(0);
}
{
int retval = getbytes(size, from, to, M_GETSTR);
- to[(int)answer.m_size] = 0;
+ to[(int)BUFTOI(answer.m_buf+1, (int)LS)] = 0;
return retval;
}
struct message_hdr m;
m.m_type = M_SETBYTES;
- m.m_size = size;
- put_int(m.m_buf, pointer_size, (long) to);
+ ITOBUF(m.m_buf+1, size, (int) LS);
+ ITOBUF(m.m_buf+LS+1, (long) to, (int) PS);
if (! uputm(&m) || ! usend(from, size) || ! ugetm(&m)) {
return;
}
}
-int
+t_addr
get_dump(globmessage, globbuf, stackmessage, stackbuf)
struct message_hdr *globmessage, *stackmessage;
char **globbuf, **stackbuf;
{
struct message_hdr m;
+ long sz;
m.m_type = M_DUMP;
if (! could_send(&m, 0)) {
}
*globmessage = answer;
- *globbuf = malloc((unsigned) answer.m_size);
- if (! ureceive(*globbuf, answer.m_size) || ! ugetm(stackmessage)) {
+ sz = BUFTOI(answer.m_buf+1, (int)LS);
+ *globbuf = malloc((unsigned) sz);
+ if (! ureceive(*globbuf, sz) || ! ugetm(stackmessage)) {
if (*globbuf) free(*globbuf);
return 0;
}
assert(stackmessage->m_type == M_DSTACK);
- *stackbuf = malloc((unsigned) stackmessage->m_size);
- if (! ureceive(*stackbuf, stackmessage->m_size)) {
+ sz = BUFTOI(stackmessage->m_buf+1, (int)LS);
+ *stackbuf = malloc((unsigned) sz);
+ if (! ureceive(*stackbuf, sz)) {
if (*globbuf) free(*globbuf);
if (*stackbuf) free(*stackbuf);
return 0;
}
- put_int(globmessage->m_buf+SP_OFF*pointer_size, pointer_size,
- get_int(stackmessage->m_buf+SP_OFF*pointer_size, pointer_size, T_UNSIGNED));
+ ITOBUF(globmessage->m_buf+SP_OFF, BUFTOI(stackmessage->m_buf+SP_OFF, (int)PS), (int) PS);
if (! *globbuf || ! *stackbuf) {
error("could not allocate enough memory");
if (*globbuf) free(*globbuf);
if (*stackbuf) free(*stackbuf);
return 0;
}
- return 1;
+ return BUFTOI(globmessage->m_buf+PC_OFF, (int)PS);
}
int
start_child(run_command);
restoring = 0;
}
- retval = uputm(globmessage) && usend(globbuf, globmessage->m_size) &&
- uputm(stackmessage) && usend(stackbuf, stackmessage->m_size) &&
- ugetm(&m) && stopped("restored", m.m_size);
+ retval = uputm(globmessage)
+ && usend(globbuf, BUFTOI(globmessage->m_buf+1, (int) LS))
+ && uputm(stackmessage)
+ && usend(stackbuf, BUFTOI(stackmessage->m_buf+1, (int) LS))
+ && ugetm(&m)
+ && stopped("restored", BUFTOI(m.m_buf+1, (int) PS));
return retval;
}
register t_addr *to = &buf[0];
m.m_type = M_GETEMREGS;
- m.m_size = level;
+ ITOBUF(m.m_buf+1, (long) level, (int) LS);
if (! could_send(&m, 0)) {
return 0;
default:
assert(0);
}
- *to++ = (t_addr) get_int(answer.m_buf, pointer_size, T_UNSIGNED);
- *to++ = (t_addr) get_int(answer.m_buf+pointer_size, pointer_size, T_UNSIGNED);
- *to++ = (t_addr) get_int(answer.m_buf+2*pointer_size, pointer_size, T_UNSIGNED);
- *to++ = (t_addr) get_int(answer.m_buf+3*pointer_size, pointer_size, T_UNSIGNED);
- *to++ = (t_addr) get_int(answer.m_buf+4*pointer_size, pointer_size, T_UNSIGNED);
+ *to++ = (t_addr) BUFTOI(answer.m_buf+LB_OFF, (int)PS);
+ *to++ = (t_addr) BUFTOI(answer.m_buf+AB_OFF, (int)PS);
+ *to++ = (t_addr) BUFTOI(answer.m_buf+PC_OFF, (int)PS);
+ *to++ = (t_addr) BUFTOI(answer.m_buf+HP_OFF, (int)PS);
+ *to++ = (t_addr) BUFTOI(answer.m_buf+PC_OFF, (int)PS);
return buf;
}
struct message_hdr m;
m.m_type = M_SETEMREGS;
- m.m_size = 0;
- put_int(m.m_buf+PC_OFF*pointer_size, pointer_size, (long)PC);
+ ITOBUF(m.m_buf+PC_OFF, (long)PC, (int)PS);
if (! could_send(&m, 0)) return 0;
switch(answer.m_type) {
case M_FAIL:
struct message_hdr m;
m.m_type = (M_CONT | (db_ss ? M_DB_SS : 0));
- m.m_size = 0;
return could_send(&m, stop_message) && child_pid;
}
struct message_hdr m;
m.m_type = type | (db_ss ? M_DB_SS : 0);
- m.m_size = count;
+ ITOBUF(m.m_buf+1, count, (int) LS);
single_stepping = 1;
if (could_send(&m, 1) && child_pid) return 1;
single_stepping = 0;
struct message_hdr m;
m.m_type = type;
- m.m_size = a;
+ ITOBUF(m.m_buf+1, (long) a, (int) PS);
if (debug) printf("%s breakpoint at 0x%lx\n", type == M_SETBP ? "setting" : "clearing", (long) a);
if (child_pid && ! could_send(&m, 0)) {
}
struct message_hdr m;
m.m_type = type;
- put_int(m.m_buf, pointer_size, (long)start);
- put_int(m.m_buf+pointer_size, pointer_size, (long)end);
+ ITOBUF(m.m_buf+1, (long)start, (int) PS);
+ ITOBUF(m.m_buf+PS+1, (long)end, (int) PS);
if (debug) printf("%s trace at [0x%lx,0x%lx]\n", type == M_SETTRACE ? "setting" : "clearing", (long) start, (long) end);
if (child_pid && ! could_send(&m, 0)) {
return 0;
public / ack.git / commitdiff