diff options
Diffstat (limited to 'gdb/remote-rdi.c')
| -rw-r--r-- | gdb/remote-rdi.c | 973 |
1 files changed, 973 insertions, 0 deletions
diff --git a/gdb/remote-rdi.c b/gdb/remote-rdi.c new file mode 100644 index 00000000000..dba920e36f2 --- /dev/null +++ b/gdb/remote-rdi.c @@ -0,0 +1,973 @@ +/* GDB interface to ARM RDI library. + Copyright 1997, 1998 Free Software Foundation, Inc. + +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 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. */ + +#include "defs.h" +#include "gdb_string.h" +#include <fcntl.h> +#include "frame.h" +#include "inferior.h" +#include "bfd.h" +#include "symfile.h" +#include "target.h" +#include "wait.h" +#include "gdbcmd.h" +#include "objfiles.h" +#include "gdb-stabs.h" +#include "gdbthread.h" +#include "gdbcore.h" + +#ifdef USG +#include <sys/types.h> +#endif + +#include <signal.h> + +#include "rdi-share/ardi.h" +#include "rdi-share/adp.h" +#include "rdi-share/hsys.h" + +extern int isascii PARAMS ((int)); + +/* Prototypes for local functions */ + +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)); + +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)); + +static int arm_rdi_start_remote PARAMS ((char *dummy)); + +static void arm_rdi_open PARAMS ((char *name, int from_tty)); + +static void arm_rdi_create_inferior PARAMS ((char *exec_file, char *args, + char **env)); + +static void arm_rdi_close PARAMS ((int quitting)); + +static void arm_rdi_store_registers PARAMS ((int regno)); + +static void arm_rdi_mourn PARAMS ((void)); + +static void arm_rdi_send PARAMS ((char *buf)); + +static int arm_rdi_wait PARAMS ((int pid, struct target_waitstatus *status)); + +static void arm_rdi_kill PARAMS ((void)); + +static void arm_rdi_detach PARAMS ((char *args, int from_tty)); + +static void arm_rdi_interrupt PARAMS ((int signo)); + +static void arm_rdi_interrupt_twice PARAMS ((int signo)); + +static void interrupt_query PARAMS ((void)); + +static int arm_rdi_insert_breakpoint PARAMS ((CORE_ADDR, char *)); + +static int arm_rdi_remove_breakpoint PARAMS ((CORE_ADDR, char *)); + +static char *rdi_error_message PARAMS ((int err)); + +static enum target_signal rdi_error_signal PARAMS ((int err)); + +/* Global variables. */ + +struct target_ops arm_rdi_ops; + +static struct Dbg_ConfigBlock gdb_config; + +static struct Dbg_HostosInterface gdb_hostif; + +static int max_load_size; + +static int execute_status; + +/* 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; + + +/* Stub for catch_errors. */ + +static int +arm_rdi_start_remote (dummy) + char *dummy; +{ + return 1; +} + +/* Helper callbacks for the "host interface" structure. RDI functions call + these to forward output from the target system and so forth. */ + +void +voiddummy () +{ + fprintf_unfiltered (gdb_stdout, "void dummy\n"); +} + +static void +myprint (arg, format, ap) + PTR arg; + const char *format; + va_list ap; +{ + vfprintf_unfiltered (gdb_stdout, format, ap); +} + +static void +mywritec (arg, c) + PTR arg; + int c; +{ + if (isascii (c)) + fputc_unfiltered (c, gdb_stdout); +} + +static int +mywrite (arg, buffer, len) + PTR arg; + char const *buffer; + int len; +{ + int i; + char *e; + + e = (char *) buffer; + for (i = 0; i < len; i++) +{ + if (isascii ((int) *e)) + { + fputc_unfiltered ((int) *e, gdb_stdout); + e++; + } +} + + return len; +} + +static void +mypause (arg) + PTR arg; +{ +} + +/* These last two are tricky as we have to handle the special case of + being interrupted more carefully */ + +static int +myreadc (arg) + PTR arg; +{ + return fgetc (stdin); +} + +static char * +mygets (arg, buffer, len) + PTR arg; + char *buffer; + int len; +{ + return fgets(buffer, len, stdin); +} + +/* Prevent multiple calls to angel_RDI_close(). */ +static int closed_already = 1; + +/* Open a connection to a remote debugger. NAME is the filename used + for communication. */ + +static void +arm_rdi_open (name, from_tty) + char *name; + int from_tty; +{ + int rslt, i; + unsigned long arg1, arg2; + + if (name == NULL) + error ("To open an RDI connection, you need to specify what serial\n\ +device is attached to the remote system (e.g. /dev/ttya)."); + + /* Make the basic low-level connection. */ + + rslt = Adp_OpenDevice (name, NULL, 1); + + if (rslt != adp_ok) + error ("Could not open device \"%s\"", name); + + gdb_config.bytesex = 2 | (TARGET_BYTE_ORDER == BIG_ENDIAN ? 1 : 0); + gdb_config.fpe = 1; + gdb_config.rditype = 2; + gdb_config.heartbeat_on = 1; + gdb_config.flags = 2; + + gdb_hostif.dbgprint = myprint; + gdb_hostif.dbgpause = mypause; + gdb_hostif.dbgarg = NULL; + gdb_hostif.writec = mywritec; + gdb_hostif.readc = myreadc; + gdb_hostif.write = mywrite; + gdb_hostif.gets = mygets; + gdb_hostif.hostosarg = NULL; + gdb_hostif.reset = voiddummy; + + rslt = angel_RDI_open (10, &gdb_config, &gdb_hostif, NULL); + if (rslt == RDIError_BigEndian || rslt == RDIError_LittleEndian) + ; /* do nothing, this is the expected return */ + else if (rslt) + { + printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt)); + } + + rslt = angel_RDI_info (RDIInfo_Target, &arg1, &arg2); + if (rslt) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + rslt = angel_RDI_info (RDIInfo_Points, &arg1, &arg2); + if (rslt) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + rslt = angel_RDI_info (RDIInfo_Step, &arg1, &arg2); + if (rslt) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + rslt = angel_RDI_info (RDIInfo_CoPro, &arg1, &arg2); + if (rslt) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + rslt = angel_RDI_info (RDIInfo_SemiHosting, &arg1, &arg2); + if (rslt) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + + rslt = angel_RDI_info (RDIInfo_GetLoadSize, &arg1, &arg2); + if (rslt) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + max_load_size = arg1; + + push_target (&arm_rdi_ops); + + target_fetch_registers (-1); + + rslt = angel_RDI_open (1, &gdb_config, NULL, NULL); + if (rslt) + { + printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt)); + } + + arg1 = 0x13b; + rslt = angel_RDI_info (RDIVector_Catch, &arg1, &arg2); + if (rslt) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + + arg1 = (unsigned long) ""; + rslt = angel_RDI_info (RDISet_Cmdline, &arg1, &arg2); + if (rslt) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + + /* Clear out any existing records of breakpoints. */ + { + struct local_bp_list_entry *entry, *preventry = NULL; + + for (entry = local_bp_list; entry != NULL; entry = entry->next) + { + if (preventry) + free (preventry); + } + } + + printf_filtered ("Connected to ARM RDI target.\n"); + closed_already = 0; + inferior_pid = 42; +} + +/* Start an inferior process and set inferior_pid to its pid. + EXEC_FILE is the file to run. + ARGS is a string containing the arguments to the program. + ENV is the environment vector to pass. Errors reported with error(). + On VxWorks and various standalone systems, we ignore exec_file. */ +/* This is called not only when we first attach, but also when the + user types "run" after having attached. */ + +static void +arm_rdi_create_inferior (exec_file, args, env) + char *exec_file; + char *args; + char **env; +{ + int len, rslt; + unsigned long arg1, arg2; + char *arg_buf; + CORE_ADDR entry_point; + + if (exec_file == 0 || exec_bfd == 0) + error ("No executable file specified."); + + entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd); + + arm_rdi_kill (); + remove_breakpoints (); + init_wait_for_inferior (); + + 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, " "); + strcat (arg_buf, args); + + inferior_pid = 42; + insert_breakpoints (); /* Needed to get correct instruction in cache */ + + if (env != NULL) + { + while (*env) + { + if (strncmp (*env, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0) + { + unsigned long top_of_memory; + char *end_of_num; + + /* Set up memory limit */ + top_of_memory = strtoul (*env + sizeof ("MEMSIZE=") - 1, + &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) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + } + env++; + } + } + + arg1 = (unsigned long) arg_buf; + rslt = angel_RDI_info (RDISet_Cmdline, /* &arg1 */ (unsigned long *)arg_buf, &arg2); + if (rslt) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + + proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0); +} + +/* This takes a program previously attached to and detaches it. After + this is done, GDB can be used to debug some other program. We + better not have left any breakpoints in the target program or it'll + die when it hits one. */ + +static void +arm_rdi_detach (args, from_tty) + char *args; + int from_tty; +{ + pop_target (); +} + +/* Clean up connection to a remote debugger. */ + +static void +arm_rdi_close (quitting) + int quitting; +{ + int rslt; + + if (! closed_already) + { + rslt = angel_RDI_close (); + if (rslt) + { + printf_filtered ("RDI_close: %s\n", rdi_error_message (rslt)); + } + closed_already = 1; + inferior_pid = 0; + } +} + +/* Tell the remote machine to resume. */ + +static void +arm_rdi_resume (pid, step, siggnal) + int pid, step; + enum target_signal siggnal; +{ + int rslt; + PointHandle point; + + if (0 /* turn on when hardware supports single-stepping */) + { + rslt = angel_RDI_step (1, &point); + if (rslt) + { + printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt)); + } + } + else + { + char handle[4]; + CORE_ADDR pc; + + if (step) + { + pc = read_register (PC_REGNUM); + pc = arm_get_next_pc (pc); + arm_rdi_insert_breakpoint (pc, handle); + } + execute_status = rslt = angel_RDI_execute (&point); + if (rslt == RDIError_BreakpointReached) + ; + else if (rslt) + { + printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt)); + } + if (step) + { + arm_rdi_remove_breakpoint (pc, handle); + } + } +} + +/* Send ^C to target to halt it. Target will respond, and send us a + packet. */ + +static void +arm_rdi_interrupt (signo) + int signo; +{ +} + +static void (*ofunc)(); + +/* The user typed ^C twice. */ +static void +arm_rdi_interrupt_twice (signo) + int signo; +{ +} + +/* Ask the user what to do when an interrupt is received. */ + +static void +interrupt_query () +{ +} + +/* Wait until the remote machine stops, then return, storing status in + STATUS just as `wait' would. Returns "pid" (though it's not clear + what, if anything, that means in the case of this target). */ + +static int +arm_rdi_wait (pid, status) + int pid; + struct target_waitstatus *status; +{ + status->kind = (execute_status == RDIError_NoError ? + TARGET_WAITKIND_EXITED : TARGET_WAITKIND_STOPPED); + + /* convert stopped code from target into right signal */ + status->value.sig = rdi_error_signal (execute_status); + + return inferior_pid; +} + +/* Read the remote registers into the block REGS. */ + +/* ARGSUSED */ +static void +arm_rdi_fetch_registers (regno) + int regno; +{ + int rslt, rdi_regmask; + unsigned long rawreg, rawregs[32]; + char cookedreg[4]; + + if (regno == -1) + { + rslt = angel_RDI_CPUread (255, 0x27fff, rawregs); + if (rslt) + { + printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt)); + } + + for (regno = 0; regno < 15; regno++) + { + store_unsigned_integer (cookedreg, 4, rawregs[regno]); + supply_register (regno, (char *) cookedreg); + } + store_unsigned_integer (cookedreg, 4, rawregs[15]); + supply_register (PS_REGNUM, (char *) cookedreg); + arm_rdi_fetch_registers (PC_REGNUM); + } + else + { + if (regno == PC_REGNUM) + rdi_regmask = RDIReg_PC; + else if (regno == PS_REGNUM) + rdi_regmask = RDIReg_CPSR; + else if (regno < 0 || regno > 15) + { + rawreg = 0; + supply_register (regno, (char *) &rawreg); + return; + } + else + rdi_regmask = 1 << regno; + + rslt = angel_RDI_CPUread (255, rdi_regmask, &rawreg); + if (rslt) + { + printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt)); + } + store_unsigned_integer (cookedreg, 4, rawreg); + supply_register (regno, (char *) cookedreg); + } +} + +static void +arm_rdi_prepare_to_store () +{ + /* Nothing to do. */ +} + +/* Store register REGNO, or all registers if REGNO == -1, from the contents + of REGISTERS. FIXME: ignores errors. */ + +static void +arm_rdi_store_registers (regno) + int regno; +{ + int rslt, rdi_regmask; + + /* These need to be able to take 'floating point register' contents */ + unsigned long rawreg[3], rawerreg[3]; + + if (regno == -1) + { + for (regno = 0; regno < NUM_REGS; regno++) + arm_rdi_store_registers (regno); + } + else + { + read_register_gen (regno, (char *) rawreg); + /* RDI manipulates data in host byte order, so convert now. */ + store_unsigned_integer (rawerreg, 4, rawreg[0]); + + if (regno == PC_REGNUM) + rdi_regmask = RDIReg_PC; + else if (regno == PS_REGNUM) + rdi_regmask = RDIReg_CPSR; + else if (regno < 0 || regno > 15) + return; + else + rdi_regmask = 1 << regno; + + rslt = angel_RDI_CPUwrite (255, rdi_regmask, rawerreg); + if (rslt) + { + printf_filtered ("RDI_CPUwrite: %s\n", rdi_error_message (rslt)); + } + } +} + +/* Read or write LEN bytes from inferior memory at MEMADDR, + transferring to or from debugger address MYADDR. Write to inferior + if SHOULD_WRITE is nonzero. Returns length of data written or + read; 0 for error. */ + +/* ARGSUSED */ +static int +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 */ +{ + int rslt, i; + + if (should_write) + { + rslt = angel_RDI_write (myaddr, memaddr, &len); + if (rslt) + { + printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt)); + } + } + else + { + rslt = angel_RDI_read (memaddr, myaddr, &len); + if (rslt) + { + printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt)); + len = 0; + } + } + return len; +} + +/* Display random info collected from the target. */ + +static void +arm_rdi_files_info (ignore) + struct target_ops *ignore; +{ + char *file = "nothing"; + int rslt; + unsigned long arg1, arg2; + + rslt = angel_RDI_info (RDIInfo_Target, &arg1, &arg2); + if (rslt) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + if (arg1 & (1 << 15)) + printf_filtered ("Target supports Thumb code.\n"); + if (arg1 & (1 << 14)) + 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) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + printf_filtered ("Target can%s single-step.\n", (arg1 & 0x4 ? "" : "not")); + + rslt = angel_RDI_info (RDIInfo_Icebreaker, &arg1, &arg2); + if (rslt) + { + printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt)); + } + else + printf_filtered ("Target includes an EmbeddedICE.\n"); +} + +static void +arm_rdi_kill () +{ + int rslt; + + rslt = angel_RDI_open (1, &gdb_config, NULL, NULL); + if (rslt) + { + printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt)); + } +} + +static void +arm_rdi_mourn_inferior () +{ + unpush_target (&arm_rdi_ops); + generic_mourn_inferior (); +} + +/* While the RDI library keeps track of its own breakpoints, we need + to remember "handles" so that we can delete them later. Since + breakpoints get used for stepping, be careful not to leak memory + here. */ + +static int +arm_rdi_insert_breakpoint (addr, contents_cache) + CORE_ADDR addr; + char *contents_cache; +{ + int rslt; + PointHandle point; + struct local_bp_list_entry *entry; + int type = RDIPoint_EQ; + + if (arm_pc_is_thumb (addr) || arm_pc_is_thumb_dummy (addr)) + type |= RDIPoint_16Bit; + rslt = angel_RDI_setbreak (addr, type, 0, &point); + if (rslt) + { + printf_filtered ("RDI_setbreak: %s\n", rdi_error_message (rslt)); + } + entry = + (struct local_bp_list_entry *) xmalloc (sizeof (struct local_bp_list_entry)); + entry->addr = addr; + entry->point = point; + entry->next = local_bp_list; + local_bp_list = entry; + return rslt; +} + +static int +arm_rdi_remove_breakpoint (addr, contents_cache) + CORE_ADDR addr; + char *contents_cache; +{ + int rslt; + PointHandle point; + struct local_bp_list_entry *entry, *preventry; + + for (entry = local_bp_list; entry != NULL; entry = entry->next) + { + if (entry->addr == addr) + { + break; + } + preventry = entry; + } + if (entry) + { + rslt = angel_RDI_clearbreak (entry->point); + if (rslt) + { + printf_filtered ("RDI_clearbreak: %s\n", rdi_error_message (rslt)); + } + /* Delete the breakpoint entry locally. */ + if (entry == local_bp_list) + { + local_bp_list = entry->next; + } + else + { + preventry->next = entry->next; + } + free (entry); + } + return 0; +} + +static char * +rdi_error_message (err) + int err; +{ + switch (err) + { + case RDIError_NoError: + return "no error"; + case RDIError_Reset: + return "debuggee reset"; + case RDIError_UndefinedInstruction: + return "undefined instruction"; + case RDIError_SoftwareInterrupt: + return "SWI trapped"; + case RDIError_PrefetchAbort: + return "prefetch abort, execution ran into unmapped memory?"; + case RDIError_DataAbort: + return "data abort, no memory at specified address?"; + case RDIError_AddressException: + return "address exception, access >26bit in 26bit mode"; + case RDIError_IRQ: + return "IRQ, interrupt trapped"; + case RDIError_FIQ: + return "FIQ, fast interrupt trapped"; + case RDIError_Error: + return "a miscellaneous type of error"; + case RDIError_BranchThrough0: + return "branch through location 0"; + case RDIError_NotInitialised: + return "internal error, RDI_open not called first"; + case RDIError_UnableToInitialise: + return "internal error, target world is broken"; + case RDIError_WrongByteSex: + return "See Operator: WrongByteSex"; + case RDIError_UnableToTerminate: + return "See Operator: Unable to Terminate"; + case RDIError_BadInstruction: + return "bad instruction, illegal to execute this instruction"; + case RDIError_IllegalInstruction: + return "illegal instruction, the effect of executing it is undefined"; + case RDIError_BadCPUStateSetting: + return "internal error, tried to set SPSR of user mode"; + case RDIError_UnknownCoPro: + return "unknown co-processor"; + case RDIError_UnknownCoProState: + return "cannot execute co-processor request"; + case RDIError_BadCoProState: + return "recognizably broken co-processor request"; + case RDIError_BadPointType: + return "internal error, bad point yype"; + case RDIError_UnimplementedType: + return "internal error, unimplemented type"; + case RDIError_BadPointSize: + return "internal error, bad point size"; + case RDIError_UnimplementedSize: + return "internal error, unimplemented size"; + case RDIError_NoMorePoints: + return "last break/watch point was used"; + case RDIError_BreakpointReached: + return "breakpoint reached"; + case RDIError_WatchpointAccessed: + return "watchpoint accessed"; + case RDIError_NoSuchPoint: + return "attempted to clear non-existent break/watch point"; + case RDIError_ProgramFinishedInStep: + return "end of the program reached while stepping"; + case RDIError_UserInterrupt: + return "you pressed Escape"; + case RDIError_CantSetPoint: + return "no more break/watch points available"; + case RDIError_IncompatibleRDILevels: + return "incompatible RDI levels"; + case RDIError_LittleEndian: + return "debuggee is little endian"; + case RDIError_BigEndian: + return "debuggee is big endian"; + case RDIError_SoftInitialiseError: + return "recoverable error in RDI initialization"; + case RDIError_InsufficientPrivilege: + return "internal error, supervisor state not accessible to monitor"; + case RDIError_UnimplementedMessage: + return "internal error, unimplemented message"; + case RDIError_UndefinedMessage: + return "internal error, undefined message"; + default: + return "undefined error message, should reset target"; + } +} + +/* Convert the ARM error messages to signals that GDB knows about. */ + +static enum target_signal +rdi_error_signal (err) + int err; +{ + switch (err) + { + case RDIError_NoError: + return 0; + case RDIError_Reset: + return TARGET_SIGNAL_TERM; /* ??? */ + case RDIError_UndefinedInstruction: + return TARGET_SIGNAL_ILL; + case RDIError_SoftwareInterrupt: + case RDIError_PrefetchAbort: + case RDIError_DataAbort: + return TARGET_SIGNAL_TRAP; + case RDIError_AddressException: + return TARGET_SIGNAL_SEGV; + case RDIError_IRQ: + case RDIError_FIQ: + return TARGET_SIGNAL_TRAP; + case RDIError_Error: + return TARGET_SIGNAL_TERM; + case RDIError_BranchThrough0: + return TARGET_SIGNAL_TRAP; + case RDIError_NotInitialised: + case RDIError_UnableToInitialise: + case RDIError_WrongByteSex: + case RDIError_UnableToTerminate: + return TARGET_SIGNAL_UNKNOWN; + case RDIError_BadInstruction: + case RDIError_IllegalInstruction: + return TARGET_SIGNAL_ILL; + case RDIError_BadCPUStateSetting: + case RDIError_UnknownCoPro: + case RDIError_UnknownCoProState: + case RDIError_BadCoProState: + case RDIError_BadPointType: + case RDIError_UnimplementedType: + case RDIError_BadPointSize: + case RDIError_UnimplementedSize: + case RDIError_NoMorePoints: + return TARGET_SIGNAL_UNKNOWN; + case RDIError_BreakpointReached: + case RDIError_WatchpointAccessed: + return TARGET_SIGNAL_TRAP; + case RDIError_NoSuchPoint: + case RDIError_ProgramFinishedInStep: + return TARGET_SIGNAL_UNKNOWN; + case RDIError_UserInterrupt: + return TARGET_SIGNAL_INT; + case RDIError_IncompatibleRDILevels: + case RDIError_LittleEndian: + case RDIError_BigEndian: + case RDIError_SoftInitialiseError: + case RDIError_InsufficientPrivilege: + case RDIError_UnimplementedMessage: + case RDIError_UndefinedMessage: + default: + return TARGET_SIGNAL_UNKNOWN; + } +} + +/* Define the target operations structure. */ + +static void +init_rdi_ops () +{ + 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; + 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_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; +} + +void +_initialize_remote_rdi () +{ + init_rdi_ops () ; + add_target (&arm_rdi_ops); +} + +/* A little dummy to make linking with the library succeed. */ + +int Fail() { return 0; } |