/* Remote debugging interface for Am290*0 running MiniMON monitor, for GDB.
- Copyright (C) 1990, 1991 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
Originally written by Daniel Mann at AMD.
This file is part of GDB.
You should get tagged at compile time if you need to make any
changes/additions. */
-#include <stdio.h>
#include "defs.h"
#include "inferior.h"
#include "wait.h"
/* Offset of member MEMBER in a struct of type TYPE. */
#define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
-/* #define DEBUG 1 /* */
-#ifdef DEBUG
-# define DENTER(NAME) (printf("Entering %s\n",NAME), fflush(stdout))
-# define DEXIT(NAME) (printf("Exiting %s\n",NAME), fflush(stdout))
-#else
-# define DENTER(NAME)
-# define DEXIT(NAME)
-#endif
-
#define DRAIN_INPUT() (msg_recv_serial((union msg_t*)0))
extern int stop_soon_quietly; /* for wait_for_inferior */
-extern struct value *call_function_by_hand();
-
static void mm_resume();
static void mm_fetch_registers ();
static int fetch_register ();
-static int mm_store_registers ();
+static void mm_store_registers ();
static int store_register ();
static int regnum_to_srnum();
static void mm_close ();
char *token[MAX_TOKENS];
char cmd_line[BUFFER_SIZE];
- DENTER("mm_create_inferior()");
-
if (args && *args)
error ("Can't pass arguments to remote mm process (yet).");
Assuming you are at NYU debuging a kernel, i.e., no need to download.\n\n");
/* We will get a task spawn event immediately. */
-#ifdef NOTDEF /* start_remote() now does a wait without a resume
- so don't use it*/
- start_remote ();
-#else
init_wait_for_inferior ();
clear_proceed_status ();
stop_soon_quietly = 1;
proceed(-1,-1,0);
normal_stop ();
-#endif
- DEXIT("mm_create_inferior()");
}
/**************************************************** REMOTE_MOURN_INFERIOR */
static void
mm_mourn()
{
- DENTER("mm_mourn()");
pop_target (); /* Pop back to no-child state */
generic_mourn_inferior ();
- DEXIT("mm_mourn()");
}
/********************************************************************** damn_b
unsigned int prl;
char *p;
- DENTER("mm_open()");
-
/* Find the first whitespace character, it separates dev_name from
prog_name. */
for (p = name;
- *p != '\0' && !isspace (*p); p++)
+ p && *p && !isspace (*p); p++)
;
- if (*p == '\0')
+ if (p == 0 || *p == '\0')
erroid:
error ("Usage : <command> <serial-device> <baud-rate> [progname]");
dev_name = (char*)malloc (p - name + 1);
out_msg_buf->go_msg.length = 0;
msg_send_serial(out_msg_buf);
/* No message to expect after a GO */
-
- DEXIT("mm_open()");
}
/**************************************************************** REMOTE_CLOSE
mm_close (quitting) /*FIXME: how is quitting used */
int quitting;
{
- DENTER("mm_close()");
-
if (mm_desc < 0)
error ("Can't close remote connection: not debugging remotely.");
#endif
printf ("Ending remote debugging\n");
-
- DEXIT("mm_close()");
-
}
/************************************************************* REMOTE_ATACH */
int from_tty;
{
- DENTER("mm_attach()");
-
if (!mm_stream)
- printf ("MiniMon not opened yet, use the 'target minimon' command.\n");
+ error ("MiniMon not opened yet, use the 'target minimon' command.\n");
- dont_repeat();
-
if (from_tty)
printf ("Attaching to remote program %s...\n", prog_name);
-
/* Make sure the target is currently running, it is supposed to be. */
/* FIXME: is it ok to send MiniMon a BREAK if it is already stopped in
* the dbg core. If so, we don't need to send this GO.
out_msg_buf->break_msg.code = BREAK;
out_msg_buf->break_msg.length = 0;
msg_send_serial(out_msg_buf);
-
- mark_breakpoints_out ();
- init_wait_for_inferior ();
- clear_proceed_status ();
- stop_soon_quietly = 1;
- wait_for_inferior ();
- stop_soon_quietly = 0;
- normal_stop ();
-
- DEXIT("mm_attach()");
}
/********************************************************** REMOTE_DETACH */
/* Terminate the open connection to the remote debugger.
char *args;
int from_tty;
{
- DENTER("mm_dettach()");
remove_breakpoints(); /* Just in case there were any left in */
out_msg_buf->go_msg.code = GO;
out_msg_buf->go_msg.length = 0;
msg_send_serial(out_msg_buf);
pop_target(); /* calls mm_close to do the real work */
- DEXIT("mm_dettach()");
}
mm_resume (step, sig)
int step, sig;
{
- DENTER("mm_resume()");
-
if (sig)
error ("Can't send signals to a remote MiniMon system.");
out_msg_buf->go_msg.length = 0;
msg_send_serial(out_msg_buf);
}
-
- DEXIT("mm_resume()");
}
/***************************************************************** REMOTE_WAIT
int old_timeout = timeout;
int old_immediate_quit = immediate_quit;
- DENTER("mm_wait()");
WSETEXIT ((*status), 0);
timeout = old_timeout; /* Restore original timeout value */
immediate_quit = old_immediate_quit;
- DEXIT("mm_wait()");
return 0;
}
return;
}
- DENTER("mm_fetch_registers()");
-
/* Gr1/rsp */
out_msg_buf->read_req_msg.byte_count = 4*1;
out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
{
int val = -1;
supply_register (FPE_REGNUM, &val);
- supply_register (INT_REGNUM, &val);
+ supply_register (INTE_REGNUM, &val);
supply_register (FPS_REGNUM, &val);
supply_register (EXO_REGNUM, &val);
}
-
- DEXIT("mm_fetch_registerS()");
}
/****************************************************** REMOTE_STORE_REGISTERS
-** Store register regno into the target.
+ * Store register regno into the target.
* If regno==-1 then store all the registers.
+ * Result is 0 for success, -1 for failure.
*/
-static int
+static void
mm_store_registers (regno)
int regno;
{
+ int result;
- if (regno >= 0)
- return(store_register(regno));
+ if (regno >= 0) {
+ store_register(regno);
+ return;
+ }
- DENTER("mm_store_registers()");
+ result = 0;
out_msg_buf->write_r_msg.code= WRITE_REQ;
out_msg_buf->write_r_msg.data[0] = read_register (GR1_REGNUM);
msg_send_serial( out_msg_buf);
- expect_msg(WRITE_ACK,in_msg_buf,1);
+ if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
+ result = -1;
+ }
#if defined(GR64_REGNUM)
/* Global registers gr64-gr95 */
out_msg_buf->write_r_msg.data[regno-GR64_REGNUM] = read_register (regno);
}
msg_send_serial(out_msg_buf);
- expect_msg(WRITE_ACK,in_msg_buf,1);
+ if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
+ result = -1;
+ }
#endif /* GR64_REGNUM */
/* Global registers gr96-gr127 */
out_msg_buf->write_r_msg.data[regno-GR96_REGNUM] = read_register (regno);
}
msg_send_serial( out_msg_buf);
- expect_msg(WRITE_ACK,in_msg_buf,1);
+ if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
+ result = -1;
+ }
/* Local Registers */
out_msg_buf->write_r_msg.memory_space = LOCAL_REG;
out_msg_buf->write_r_msg.data[regno-LR0_REGNUM] = read_register (regno);
}
msg_send_serial( out_msg_buf);
- expect_msg(WRITE_ACK,in_msg_buf,1);
+ if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
+ result = -1;
+ }
/* Protected Special Registers */
/* VAB through TMR */
for (regno = 0 ; regno<=9 ; regno++) /* VAB through TMR */
out_msg_buf->write_r_msg.data[regno] = read_register (SR_REGNUM(regno));
msg_send_serial( out_msg_buf);
- expect_msg(WRITE_ACK,in_msg_buf,1);
+ if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
+ result = -1;
+ }
/* PC0, PC1, PC2 possibly as shadow registers */
out_msg_buf->write_r_msg.byte_count = 4* 3;
else
out_msg_buf->write_r_msg.address = 10; /* PC0 */
msg_send_serial( out_msg_buf);
- expect_msg(WRITE_ACK,in_msg_buf,1);
+ if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
+ result = -1;
+ }
/* LRU and MMU */
out_msg_buf->write_r_msg.byte_count = 4* 2;
for (regno=13 ; regno<=14 ; regno++) /* LRU and MMU */
out_msg_buf->write_r_msg.data[regno-13] = read_register (SR_REGNUM(regno));
msg_send_serial( out_msg_buf);
- expect_msg(WRITE_ACK,in_msg_buf,1);
+ if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
+ result = -1;
+ }
/* Unprotected Special Registers */
out_msg_buf->write_r_msg.byte_count = 4*8;
for (regno = 128 ; regno<=135 ; regno++)
out_msg_buf->write_r_msg.data[regno-128] = read_register(SR_REGNUM(regno));
msg_send_serial( out_msg_buf);
- expect_msg(WRITE_ACK,in_msg_buf,1);
+ if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
+ result = -1;
+ }
registers_changed ();
- DEXIT("mm_store_registers()");
}
/*************************************************** REMOTE_PREPARE_TO_STORE */
return(addr);
#endif
}
-/* FIXME! Merge these two. */
-static int
-mm_xfer_inferior_memory (memaddr, myaddr, len, write)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
-{
-
- memaddr = translate_addr(memaddr);
-
- if (write)
- return mm_write_inferior_memory (memaddr, myaddr, len);
- else
- return mm_read_inferior_memory (memaddr, myaddr, len);
-}
/******************************************************* REMOTE_FILES_INFO */
static void
CORE_ADDR addr;
char *contents_cache;
{
- DENTER("mm_insert_breakpoint()");
out_msg_buf->bkpt_set_msg.code = BKPT_SET;
out_msg_buf->bkpt_set_msg.length = 4*4;
out_msg_buf->bkpt_set_msg.memory_space = I_MEM;
out_msg_buf->bkpt_set_msg.bkpt_type = -1; /* use illop for 29000 */
msg_send_serial( out_msg_buf);
if (expect_msg(BKPT_SET_ACK,in_msg_buf,1)) {
- DEXIT("mm_insert_breakpoint() success");
return 0; /* Success */
} else {
- DEXIT("mm_insert_breakpoint() failure");
return 1; /* Failure */
}
}
CORE_ADDR addr;
char *contents_cache;
{
- DENTER("mm_remove_breakpoint()");
out_msg_buf->bkpt_rm_msg.code = BKPT_RM;
out_msg_buf->bkpt_rm_msg.length = 4*3;
out_msg_buf->bkpt_rm_msg.memory_space = I_MEM;
out_msg_buf->bkpt_rm_msg.bkpt_addr = (ADDR32) addr;
msg_send_serial( out_msg_buf);
if (expect_msg(BKPT_RM_ACK,in_msg_buf,1)) {
- DEXIT("mm_remove_breakpoint()");
return 0; /* Success */
} else {
- DEXIT("mm_remove_breakpoint()");
return 1; /* Failure */
}
}
{
char buf[4];
- DENTER("mm_kill()");
#if defined(KERNEL_DEBUGGING)
/* We don't ever kill the kernel */
if (from_tty) {
}
pop_target();
#endif
- DEXIT("mm_kill()");
}
/* You may need to do an init_target_mm() */
/* init_target_mm(?,?,?,?,?,?,?,?); */
immediate_quit--;
- symbol_file_add (arg_string, from_tty, text_addr, 0);
+ /* symbol_file_add (arg_string, from_tty, text_addr, 0, 0); */
#endif
}
{
int i,nwritten;
- /* DENTER("mm_write_inferior_memory()"); */
out_msg_buf->write_req_msg.code= WRITE_REQ;
out_msg_buf->write_req_msg.memory_space = mm_memory_space(memaddr);
break;
}
}
- /* DEXIT("mm_write_inferior_memory()"); */
return(nwritten);
}
{
int i,nread;
- /* DENTER("mm_read_inferior_memory()"); */
out_msg_buf->read_req_msg.code= READ_REQ;
out_msg_buf->read_req_msg.memory_space = mm_memory_space(memaddr);
return(nread);
}
+/* FIXME! Merge these two. */
+static int
+mm_xfer_inferior_memory (memaddr, myaddr, len, write)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+ int write;
+{
+
+ memaddr = translate_addr(memaddr);
+
+ if (write)
+ return mm_write_inferior_memory (memaddr, myaddr, len);
+ else
+ return mm_read_inferior_memory (memaddr, myaddr, len);
+}
+
+
/********************************************************** MSG_SEND_SERIAL
** This function is used to send a message over the
** serial line.
int regno;
{
int result;
- DENTER("mm_fetch_register()");
out_msg_buf->read_req_msg.code= READ_REQ;
out_msg_buf->read_req_msg.length = 4*3;
out_msg_buf->read_req_msg.byte_count = 4;
} else {
result = -1;
}
- DEXIT("mm_fetch_register()");
return result;
}
/*****************************************************************************/
{
int result;
- DENTER("store_register()");
out_msg_buf->write_req_msg.code= WRITE_REQ;
out_msg_buf->write_req_msg.length = 4*4;
out_msg_buf->write_req_msg.byte_count = 4;
} else {
result = -1;
}
- DEXIT("store_register()");
return result;
}
/****************************************************************************/
case FC_REGNUM: return(134);
case CR_REGNUM: return(135);
case FPE_REGNUM: return(160);
- case INT_REGNUM: return(161);
+ case INTE_REGNUM: return(161);
case FPS_REGNUM: return(162);
case EXO_REGNUM:return(164);
default:
union msg_t *msg_buf; /* Where to put the message received */
int from_tty; /* Print message on error if non-zero */
{
- /* DENTER("expect_msg()"); */
int retries=0;
while(msg_recv_serial(msg_buf) && (retries++<MAX_RETRIES));
if (retries >= MAX_RETRIES) {
printf("Expected msg %s, ",msg_str(msgcode));
printf("no message received!\n");
- /* DEXIT("expect_msg() failure"); */
return(0); /* Failure */
}
if (msg_buf->generic_msg.code == ERROR)
printf("%s\n",error_msg_str(msg_buf->error_msg.error_code));
}
- /* DEXIT("expect_msg() failure"); */
return(0); /* Failure */
}
- /* DEXIT("expect_msg() success"); */
return(1); /* Success */
}
/****************************************************************************/
mm_open, mm_close,
mm_attach, mm_detach, mm_resume, mm_wait,
mm_fetch_registers, mm_store_registers,
- mm_prepare_to_store, 0, 0, /* conv_to, conv_from */
+ mm_prepare_to_store,
mm_xfer_inferior_memory,
mm_files_info,
mm_insert_breakpoint, mm_remove_breakpoint, /* Breakpoints */
0, 0, 0, 0, 0, /* Terminal handling */
mm_kill, /* FIXME, kill */
mm_load,
- call_function_by_hand,
0, /* lookup_symbol */
mm_create_inferior, /* create_inferior */
mm_mourn, /* mourn_inferior FIXME */
+ 0, /* can_run */
+ 0, /* notice_signals */
process_stratum, 0, /* next */
1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
0,0, /* sections, sections_end */
projects / deliverable / binutils-gdb.git / blobdiff