/* GDB interface to ARM RDI library.
Copyright 1997, 1998 Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
#include "defs.h"
#include "gdb_string.h"
/* Prototypes for local functions */
-static void arm_rdi_files_info PARAMS ((struct target_ops *ignore));
+static void arm_rdi_files_info PARAMS ((struct target_ops * ignore));
static int arm_rdi_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr,
- int len, int should_write,
- struct target_ops *target));
+ int len, int should_write,
+ struct target_ops * target));
static void arm_rdi_prepare_to_store PARAMS ((void));
static void arm_rdi_fetch_registers PARAMS ((int regno));
static void arm_rdi_resume PARAMS ((int pid, int step,
- enum target_signal siggnal));
+ enum target_signal siggnal));
static int arm_rdi_start_remote PARAMS ((char *dummy));
static void arm_rdi_send PARAMS ((char *buf));
-static int arm_rdi_wait PARAMS ((int pid, struct target_waitstatus *status));
+static int arm_rdi_wait PARAMS ((int pid, struct target_waitstatus * status));
static void arm_rdi_kill PARAMS ((void));
/* A little list of breakpoints that have been set. */
-static struct local_bp_list_entry {
- CORE_ADDR addr;
- PointHandle point;
- struct local_bp_list_entry *next;
-} *local_bp_list;
-
+static struct local_bp_list_entry
+ {
+ CORE_ADDR addr;
+ PointHandle point;
+ struct local_bp_list_entry *next;
+ }
+ *local_bp_list;
\f
+
/* Stub for catch_errors. */
static int
e = (char *) buffer;
for (i = 0; i < len; i++)
-{
+ {
if (isascii ((int) *e))
- {
- fputc_unfiltered ((int) *e, gdb_stdout);
- e++;
- }
-}
+ {
+ fputc_unfiltered ((int) *e, gdb_stdout);
+ e++;
+ }
+ }
return len;
}
static int
myreadc (arg)
PTR arg;
-{
+{
return fgetc (stdin);
}
char *buffer;
int len;
{
- return fgets(buffer, len, stdin);
+ return fgets (buffer, len, stdin);
}
/* Prevent multiple calls to angel_RDI_close(). */
rslt = angel_RDI_open (10, &gdb_config, &gdb_hostif, NULL);
if (rslt == RDIError_BigEndian || rslt == RDIError_LittleEndian)
- ; /* do nothing, this is the expected return */
+ ; /* do nothing, this is the expected return */
else if (rslt)
{
printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
CORE_ADDR entry_point;
if (exec_file == 0 || exec_bfd == 0)
- error ("No executable file specified.");
+ error ("No executable file specified.");
entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);
- arm_rdi_kill ();
+ arm_rdi_kill ();
remove_breakpoints ();
init_wait_for_inferior ();
- len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop*/ 10;
+ len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
arg_buf = (char *) alloca (len);
arg_buf[0] = '\0';
strcat (arg_buf, exec_file);
strcat (arg_buf, args);
inferior_pid = 42;
- insert_breakpoints (); /* Needed to get correct instruction in cache */
+ insert_breakpoints (); /* Needed to get correct instruction in cache */
if (env != NULL)
{
&end_of_num, 0);
printf_filtered ("Setting top-of-memory to 0x%x\n",
top_of_memory);
-
+
rslt = angel_RDI_info (RDIInfo_SetTopMem, &top_of_memory, &arg2);
if (rslt)
{
}
arg1 = (unsigned long) arg_buf;
- rslt = angel_RDI_info (RDISet_Cmdline, /* &arg1 */ (unsigned long *)arg_buf, &arg2);
+ rslt = angel_RDI_info (RDISet_Cmdline, /* &arg1 */ (unsigned long *) arg_buf, &arg2);
if (rslt)
{
printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
{
int rslt;
- if (! closed_already)
+ if (!closed_already)
{
rslt = angel_RDI_close ();
if (rslt)
int rslt;
PointHandle point;
- if (0 /* turn on when hardware supports single-stepping */)
+ if (0 /* turn on when hardware supports single-stepping */ )
{
rslt = angel_RDI_step (1, &point);
if (rslt)
{
}
-static void (*ofunc)();
+static void (*ofunc) ();
/* The user typed ^C twice. */
static void
struct target_waitstatus *status;
{
status->kind = (execute_status == RDIError_NoError ?
- TARGET_WAITKIND_EXITED : TARGET_WAITKIND_STOPPED);
+ TARGET_WAITKIND_EXITED : TARGET_WAITKIND_STOPPED);
/* convert stopped code from target into right signal */
status->value.sig = rdi_error_signal (execute_status);
unsigned long rawreg, rawregs[32];
char cookedreg[4];
- if (regno == -1)
+ if (regno == -1)
{
rslt = angel_RDI_CPUread (255, 0x27fff, rawregs);
if (rslt)
}
}
-static void
+static void
arm_rdi_prepare_to_store ()
{
/* Nothing to do. */
/* These need to be able to take 'floating point register' contents */
unsigned long rawreg[3], rawerreg[3];
- if (regno == -1)
+ if (regno == -1)
{
for (regno = 0; regno < NUM_REGS; regno++)
arm_rdi_store_registers (regno);
/* ARGSUSED */
static int
-arm_rdi_xfer_memory(memaddr, myaddr, len, should_write, target)
+arm_rdi_xfer_memory (memaddr, myaddr, len, should_write, target)
CORE_ADDR memaddr;
char *myaddr;
int len;
int should_write;
- struct target_ops *target; /* ignored */
+ struct target_ops *target; /* ignored */
{
int rslt, i;
printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt));
}
}
- else
+ else
{
rslt = angel_RDI_read (memaddr, myaddr, &len);
if (rslt)
printf_filtered ("Target can do profiling.\n");
if (arg1 & (1 << 4))
printf_filtered ("Target is real hardware.\n");
-
+
rslt = angel_RDI_info (RDIInfo_Step, &arg1, &arg2);
if (rslt)
{
{
switch (err)
{
- case RDIError_NoError:
+ case RDIError_NoError:
return "no error";
case RDIError_Reset:
return "debuggee reset";
case RDIError_UndefinedMessage:
return "internal error, undefined message";
default:
- return "undefined error message, should reset target";
+ return "undefined error message, should reset target";
}
}
case RDIError_NoError:
return 0;
case RDIError_Reset:
- return TARGET_SIGNAL_TERM; /* ??? */
+ return TARGET_SIGNAL_TERM; /* ??? */
case RDIError_UndefinedInstruction:
return TARGET_SIGNAL_ILL;
case RDIError_SoftwareInterrupt:
case RDIError_UnimplementedMessage:
case RDIError_UndefinedMessage:
default:
- return TARGET_SIGNAL_UNKNOWN;
+ return TARGET_SIGNAL_UNKNOWN;
}
}
\f
static void
init_rdi_ops ()
{
- arm_rdi_ops.to_shortname = "rdi";
+ arm_rdi_ops.to_shortname = "rdi";
arm_rdi_ops.to_longname = "ARM RDI";
arm_rdi_ops.to_doc = "Use a remote ARM-based computer; via the RDI library.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya)." ;
- arm_rdi_ops.to_open = arm_rdi_open;
- arm_rdi_ops.to_close = arm_rdi_close;
- arm_rdi_ops.to_detach = arm_rdi_detach;
- arm_rdi_ops.to_resume = arm_rdi_resume;
- arm_rdi_ops.to_wait = arm_rdi_wait;
+Specify the serial device it is connected to (e.g. /dev/ttya).";
+ arm_rdi_ops.to_open = arm_rdi_open;
+ arm_rdi_ops.to_close = arm_rdi_close;
+ arm_rdi_ops.to_detach = arm_rdi_detach;
+ arm_rdi_ops.to_resume = arm_rdi_resume;
+ arm_rdi_ops.to_wait = arm_rdi_wait;
arm_rdi_ops.to_fetch_registers = arm_rdi_fetch_registers;
arm_rdi_ops.to_store_registers = arm_rdi_store_registers;
arm_rdi_ops.to_prepare_to_store = arm_rdi_prepare_to_store;
arm_rdi_ops.to_xfer_memory = arm_rdi_xfer_memory;
arm_rdi_ops.to_files_info = arm_rdi_files_info;
arm_rdi_ops.to_insert_breakpoint = arm_rdi_insert_breakpoint;
- arm_rdi_ops.to_remove_breakpoint = arm_rdi_remove_breakpoint;
- arm_rdi_ops.to_kill = arm_rdi_kill;
- arm_rdi_ops.to_load = generic_load;
+ arm_rdi_ops.to_remove_breakpoint = arm_rdi_remove_breakpoint;
+ arm_rdi_ops.to_kill = arm_rdi_kill;
+ arm_rdi_ops.to_load = generic_load;
arm_rdi_ops.to_create_inferior = arm_rdi_create_inferior;
arm_rdi_ops.to_mourn_inferior = arm_rdi_mourn_inferior;
arm_rdi_ops.to_stratum = process_stratum;
- arm_rdi_ops.to_has_all_memory = 1;
- arm_rdi_ops.to_has_memory = 1;
- arm_rdi_ops.to_has_stack = 1;
- arm_rdi_ops.to_has_registers = 1;
- arm_rdi_ops.to_has_execution = 1;
- arm_rdi_ops.to_magic = OPS_MAGIC;
+ arm_rdi_ops.to_has_all_memory = 1;
+ arm_rdi_ops.to_has_memory = 1;
+ arm_rdi_ops.to_has_stack = 1;
+ arm_rdi_ops.to_has_registers = 1;
+ arm_rdi_ops.to_has_execution = 1;
+ arm_rdi_ops.to_magic = OPS_MAGIC;
}
void
_initialize_remote_rdi ()
{
- init_rdi_ops () ;
+ init_rdi_ops ();
add_target (&arm_rdi_ops);
}
/* A little dummy to make linking with the library succeed. */
-int Fail() { return 0; }
+int
+Fail ()
+{
+ return 0;
+}