extern int stop_soon_quietly; /* for wait_for_inferior */
extern struct value *call_function_by_hand();
-static void udi_resume PARAMS ((int pid, int step, int sig));
+static void udi_resume PARAMS ((int pid, int step, enum target_signal sig));
static void udi_fetch_registers PARAMS ((int regno));
static void udi_load PARAMS ((char *args, int from_tty));
static void fetch_register PARAMS ((int regno));
/* malloc'd name of the program on the remote system. */
static char *prog_name = NULL;
-/* Number of SIGTRAPs we need to simulate. That is, the next
- NEED_ARTIFICIAL_TRAP calls to udi_wait should just return
- SIGTRAP without actually waiting for anything. */
-
/* This is called not only when we first attach, but also when the
user types "run" after having attached. */
if (udi_session_id < 0)
{
- printf("UDI connection not open yet.\n");
+ printf_unfiltered("UDI connection not open yet.\n");
return;
}
args1 = alloca (strlen(execfile) + strlen(args) + 2);
- strcpy (args1, execfile);
+ if (execfile[0] == '\0')
+
+ /* It is empty. We need to quote it somehow, or else the target
+ will think there is no argument being passed here. According
+ to the UDI spec it is quoted "according to TIP OS rules" which
+ I guess means quoting it like the Unix shell should work
+ (sounds pretty bogus to me...). In fact it doesn't work (with
+ isstip anyway), but passing in two quotes as the argument seems
+ like a reasonable enough behavior anyway (I guess). */
+
+ strcpy (args1, "''");
+ else
+ strcpy (args1, execfile);
strcat (args1, " ");
strcat (args1, args);
init_wait_for_inferior ();
clear_proceed_status ();
- proceed(-1,-1,0);
+ proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
}
static void
to work between "target udi" and "run", so why not now? */
pop_target (); /* Pop back to no-child state */
#endif
+ /* But if we're going to want to run it again, we better remove the
+ breakpoints... */
+ remove_breakpoints ();
generic_mourn_inferior ();
}
ChipVersions, &NumberOfChips))
error ("UDIGetTargetConfig() failed");
if (NumberOfChips > 2)
- fprintf(stderr,"Target has more than one processor\n");
+ fprintf_unfiltered(gdb_stderr,"Target has more than one processor\n");
for (cnt=0; cnt < NumberOfRanges; cnt++)
{
switch(KnownMemory[cnt].Space)
{
default:
- fprintf(stderr, "UDIGetTargetConfig() unknown memory space\n");
+ fprintf_unfiltered(gdb_stderr, "UDIGetTargetConfig() unknown memory space\n");
break;
case UDI29KCP_S:
break;
a29k_get_processor_type ();
if (UDICreateProcess (&PId))
- fprintf(stderr, "UDICreateProcess() failed\n");
+ fprintf_unfiltered(gdb_stderr, "UDICreateProcess() failed\n");
/* Print out some stuff, letting the user now what's going on */
if (UDICapabilities (&TIPId, &TargetId, DFEId, DFE, &TIP, &DFEIPCId,
return;
/* We should never get here if there isn't something valid in
- udi_session_id. */
+ udi_session_id. */
if (UDIDisconnect (udi_session_id, UDITerminateSession))
- error ("UDIDisconnect() failed in udi_close");
+ {
+ if (quitting)
+ warning ("UDIDisconnect() failed in udi_close");
+ else
+ error ("UDIDisconnect() failed in udi_close");
+ }
/* Do not try to close udi_session_id again, later in the program. */
udi_session_id = -1;
error ("UDI connection not opened yet, use the 'target udi' command.\n");
if (from_tty)
- printf ("Attaching to remote program %s...\n", prog_name);
+ printf_unfiltered ("Attaching to remote program %s...\n", prog_name);
UDIStop();
From.Space = UDI29KSpecialRegs;
From.Offset = 11;
if (err = UDIRead(From, &PC_adds, Count, Size, &CountDone, HostEndian))
error ("UDIRead failed in udi_attach");
- printf ("Remote process is now halted, pc1 = 0x%x.\n", PC_adds);
+ printf_unfiltered ("Remote process is now halted, pc1 = 0x%x.\n", PC_adds);
}
/************************************************************* UDI_DETACH */
/* Terminate the open connection to the TIP process.
if (UDIDisconnect (udi_session_id, UDIContinueSession))
error ("UDIDisconnect() failed in udi_detach");
- pop_target(); /* calls udi_close to do the real work */
+ /* calls udi_close to do the real work (which looks like it calls
+ UDIDisconnect with UDITerminateSession, FIXME). */
+ pop_target();
+ /* FIXME, message too similar to what udi_close prints. */
if (from_tty)
- printf ("Ending remote debugging\n");
+ printf_unfiltered ("Ending remote debugging\n");
}
static void
udi_resume (pid, step, sig)
- int pid, step, sig;
+ int pid, step;
+ enum target_signal sig;
{
UDIError tip_error;
UDIUInt32 Steps = 1;
if (!tip_error)
return;
- fprintf (stderr, "UDIStep() error = %d\n", tip_error);
+ fprintf_unfiltered (gdb_stderr, "UDIStep() error = %d\n", tip_error);
error ("failed in udi_resume");
}
static int
udi_wait (pid, status)
int pid;
- WAITTYPE *status;
+ struct target_waitstatus *status;
{
UDIInt32 MaxTime;
UDIPId PId;
int old_immediate_quit = immediate_quit;
int i;
- WSETEXIT ((*status), 0);
+ status->kind = TARGET_WAITKIND_EXITED;
+ status->value.integer = 0;
/* wait for message to arrive. It should be:
If the target stops executing, udi_wait() should return.
a whole bunch of output (more than SBUF_MAX, I would
guess). It doesn't seem to happen with the simulator. */
warning ("UDIGetStdout() failed in udi_wait");
- fwrite (sbuf, 1, CountDone, stdout);
- fflush(stdout);
+ fwrite (sbuf, 1, CountDone, gdb_stdout);
+ gdb_flush(gdb_stdout);
continue;
+
case UDIStderrReady:
UDIGetStderr (sbuf, (UDISizeT)SBUF_MAX, &CountDone);
- fwrite (sbuf, 1, CountDone, stderr);
- fflush(stderr);
+ fwrite (sbuf, 1, CountDone, gdb_stderr);
+ gdb_flush(gdb_stderr);
continue;
case UDIStdinNeeded:
switch (StopReason & UDIGrossState)
{
case UDITrapped:
- printf("Am290*0 received vector number %d\n", StopReason >> 24);
+ printf_unfiltered("Am290*0 received vector number %d\n", StopReason >> 24);
switch (StopReason >> 8)
{
case 0: /* Illegal opcode */
- printf(" (break point)\n");
- WSETSTOP ((*status), SIGTRAP);
+ printf_unfiltered(" (break point)\n");
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
case 1: /* Unaligned Access */
- WSETSTOP ((*status), SIGBUS);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_BUS;
break;
case 3:
case 4:
- WSETSTOP ((*status), SIGFPE);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_FPE;
break;
case 5: /* Protection Violation */
- WSETSTOP ((*status), SIGILL);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ /* Why not SEGV? What is a Protection Violation? */
+ status->value.sig = TARGET_SIGNAL_ILL;
break;
case 6:
case 7:
case 9: /* User Data Mapping Miss */
case 10: /* Supervisor Instruction Mapping Miss */
case 11: /* Supervisor Data Mapping Miss */
- WSETSTOP ((*status), SIGSEGV);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_SEGV;
break;
case 12:
case 13:
- WSETSTOP ((*status), SIGILL);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_ILL;
break;
case 14: /* Timer */
- WSETSTOP ((*status), SIGALRM);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_ALRM;
break;
case 15: /* Trace */
- WSETSTOP ((*status), SIGTRAP);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
case 16: /* INTR0 */
case 17: /* INTR1 */
case 19: /* INTR3/Internal */
case 20: /* TRAP0 */
case 21: /* TRAP1 */
- WSETSTOP ((*status), SIGINT);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_INT;
break;
case 22: /* Floating-Point Exception */
- WSETSTOP ((*status), SIGILL);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ /* Why not FPE? */
+ status->value.sig = TARGET_SIGNAL_ILL;
break;
case 77: /* assert 77 */
- WSETSTOP ((*status), SIGTRAP);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
default:
- WSETEXIT ((*status), 0);
+ status->kind = TARGET_WAITKIND_EXITED;
+ status->value.integer = 0;
}
break;
case UDINotExecuting:
- WSETSTOP ((*status), SIGTERM);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TERM;
break;
case UDIStopped:
- WSETSTOP ((*status), SIGTSTP);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TSTP;
break;
case UDIWarned:
- WSETSTOP ((*status), SIGURG);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_URG;
break;
case UDIStepped:
case UDIBreak:
- WSETSTOP ((*status), SIGTRAP);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
case UDIWaiting:
- WSETSTOP ((*status), SIGSTOP);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_STOP;
break;
case UDIHalted:
- WSETSTOP ((*status), SIGKILL);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_KILL;
break;
case UDIExited:
default:
- WSETEXIT ((*status), 0);
+ status->kind = TARGET_WAITKIND_EXITED;
+ status->value.integer = 0;
}
timeout = old_timeout; /* Restore original timeout value */
err = UDIRead(From, To, Count, Size, &CountDone, HostEndian);
- printf ("err = %d, CountDone = %d, pc[0] = 0x%x, pc[1] = 0x%x\n",
+ printf_unfiltered ("err = %d, CountDone = %d, pc[0] = 0x%x, pc[1] = 0x%x\n",
err, CountDone, pc[0], pc[1]);
udi_fetch_registers(-1);
- printf("other pc1 = 0x%x, pc0 = 0x%x\n", *(int *)®isters[4 * PC_REGNUM],
+ printf_unfiltered("other pc1 = 0x%x, pc0 = 0x%x\n", *(int *)®isters[4 * PC_REGNUM],
*(int *)®isters[4 * NPC_REGNUM]);
/* Now, read all the registers globally */
if (remote_debug)
{
- printf("Fetching all registers\n");
- printf("Fetching PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n",
+ printf_unfiltered("Fetching all registers\n");
+ printf_unfiltered("Fetching PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n",
read_register(NPC_REGNUM), read_register(PC_REGNUM),
read_register(PC2_REGNUM));
}
if (remote_debug)
{
- printf("Storing all registers\n");
- printf("PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n", read_register(NPC_REGNUM),
+ printf_unfiltered("Storing all registers\n");
+ printf_unfiltered("PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n", read_register(NPC_REGNUM),
read_register(PC_REGNUM), read_register(PC2_REGNUM));
}
static void
udi_files_info ()
{
- printf ("\tAttached to UDI socket to %s and running program %s.\n",
+ printf_unfiltered ("\tAttached to UDI socket to %s and running program %s.\n",
udi_config_id, prog_name);
}
inferior_pid = 0;
if (from_tty)
- printf("Target has been stopped.");
-#else
+ printf_unfiltered("Target has been stopped.");
+#endif /* 0 */
+#if 0
udi_close(0);
-#endif
pop_target();
+#endif /* 0 */
+
+ /* Keep the target around, e.g. so "run" can do the right thing when
+ we are already debugging something. FIXME-maybe: should we kill the
+ TIP with UDIDisconnect using UDITerminateSession, and then restart
+ it on the next "run"? */
+
+ inferior_pid = 0;
}
/*
below starts writing before it even checks the size. */
continue;
- printf("[Loading section %s at %x (%d bytes)]\n",
+ printf_unfiltered("[Loading section %s at %x (%d bytes)]\n",
section_name,
To.Offset,
section_size);
xerr = UDIGetErrorMsg(err, 100, message, &Count);
if (!xerr)
- fprintf (stderr, "Error is %s\n", message);
+ fprintf_unfiltered (gdb_stderr, "Error is %s\n", message);
else
- fprintf (stderr, "xerr is %d\n", xerr);
+ fprintf_unfiltered (gdb_stderr, "xerr is %d\n", xerr);
error ("UDICopy failed, error = %d", err);
}
}
supply_register(regno, (char *) &To);
if (remote_debug)
- printf("Fetching register %s = 0x%x\n", reg_names[regno], To);
+ printf_unfiltered("Fetching register %s = 0x%x\n", reg_names[regno], To);
}
/*****************************************************************************/
/* Store a single register indicated by 'regno'.
From = read_register (regno); /* get data value */
if (remote_debug)
- printf("Storing register %s = 0x%x\n", reg_names[regno], From);
+ printf_unfiltered("Storing register %s = 0x%x\n", reg_names[regno], From);
if (regno == GR1_REGNUM)
{
void convert16() {;}
void convert32() {;}
-FILE* EchoFile = 0; /* used for debugging */
+GDB_FILE * EchoFile = 0; /* used for debugging */
int QuietMode = 0; /* used for debugging */
\f
#ifdef NO_HIF_SUPPORT