1 /* GDB interface to ARM RDI library.
3 Copyright 1997, 1998, 1999, 2000, 2001, 2002 Free Software
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
33 #include "gdb-stabs.h"
34 #include "gdbthread.h"
36 #include "breakpoint.h"
37 #include "completer.h"
42 #include <sys/types.h>
47 #include "rdi-share/ardi.h"
48 #include "rdi-share/adp.h"
49 #include "rdi-share/hsys.h"
51 extern int isascii (int);
53 /* Prototypes for local functions */
55 static void arm_rdi_files_info (struct target_ops
*ignore
);
57 static int arm_rdi_xfer_memory (CORE_ADDR memaddr
, char *myaddr
,
58 int len
, int should_write
,
59 struct mem_attrib
*attrib
,
60 struct target_ops
*target
);
62 static void arm_rdi_prepare_to_store (void);
64 static void arm_rdi_fetch_registers (int regno
);
66 static void arm_rdi_resume (ptid_t pid
, int step
,
67 enum target_signal siggnal
);
69 static int arm_rdi_start_remote (char *dummy
);
71 static void arm_rdi_open (char *name
, int from_tty
);
73 static void arm_rdi_create_inferior (char *exec_file
, char *args
, char **env
);
75 static void arm_rdi_close (int quitting
);
77 static void arm_rdi_store_registers (int regno
);
79 static void arm_rdi_mourn (void);
81 static void arm_rdi_send (char *buf
);
83 static ptid_t
arm_rdi_wait (ptid_t ptid
, struct target_waitstatus
*status
);
85 static void arm_rdi_kill (void);
87 static void arm_rdi_detach (char *args
, int from_tty
);
89 static void arm_rdi_interrupt (int signo
);
91 static void arm_rdi_interrupt_twice (int signo
);
93 static void interrupt_query (void);
95 static int arm_rdi_insert_breakpoint (CORE_ADDR
, char *);
97 static int arm_rdi_remove_breakpoint (CORE_ADDR
, char *);
99 static char *rdi_error_message (int err
);
101 static enum target_signal
rdi_error_signal (int err
);
103 /* Global variables. */
105 struct target_ops arm_rdi_ops
;
107 static struct Dbg_ConfigBlock gdb_config
;
109 static struct Dbg_HostosInterface gdb_hostif
;
111 static int max_load_size
;
113 static int execute_status
;
115 /* Send heatbeat packets? */
116 static int rdi_heartbeat
= 0;
118 /* Target has ROM at address 0. */
119 static int rom_at_zero
= 0;
121 /* Enable logging? */
122 static int log_enable
= 0;
124 /* Name of the log file. Default is "rdi.log". */
125 static char *log_filename
;
127 /* A little list of breakpoints that have been set. */
129 static struct local_bp_list_entry
133 struct local_bp_list_entry
*next
;
138 /* Stub for catch_errors. */
141 arm_rdi_start_remote (char *dummy
)
146 /* Helper callbacks for the "host interface" structure. RDI functions call
147 these to forward output from the target system and so forth. */
150 voiddummy (void *dummy
)
152 fprintf_unfiltered (gdb_stdout
, "void dummy\n");
156 myprint (PTR arg
, const char *format
, va_list ap
)
158 vfprintf_unfiltered (gdb_stdout
, format
, ap
);
162 mywritec (PTR arg
, int c
)
165 fputc_unfiltered (c
, gdb_stdout
);
169 mywrite (PTR arg
, char const *buffer
, int len
)
175 for (i
= 0; i
< len
; i
++)
177 if (isascii ((int) *e
))
179 fputc_unfiltered ((int) *e
, gdb_stdout
);
192 /* These last two are tricky as we have to handle the special case of
193 being interrupted more carefully */
198 return fgetc (stdin
);
202 mygets (PTR arg
, char *buffer
, int len
)
204 return fgets (buffer
, len
, stdin
);
207 /* Prevent multiple calls to angel_RDI_close(). */
208 static int closed_already
= 1;
210 /* Open a connection to a remote debugger. NAME is the filename used
211 for communication. */
214 arm_rdi_open (char *name
, int from_tty
)
217 unsigned long arg1
, arg2
;
218 char *openArgs
= NULL
;
219 char *devName
= NULL
;
223 error ("To open an RDI connection, you need to specify what serial\n\
224 device is attached to the remote system (e.g. /dev/ttya).");
226 /* split name after whitespace, pass tail as arg to open command */
228 devName
= xstrdup (name
);
229 p
= strchr (devName
, ' ');
241 /* Make the basic low-level connection. */
244 rslt
= Adp_OpenDevice (devName
, openArgs
, rdi_heartbeat
);
247 error ("Could not open device \"%s\"", name
);
249 gdb_config
.bytesex
= 2 | (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? 1 : 0);
251 gdb_config
.rditype
= 2;
252 gdb_config
.heartbeat_on
= 1;
253 gdb_config
.flags
= 2;
255 gdb_hostif
.dbgprint
= myprint
;
256 gdb_hostif
.dbgpause
= mypause
;
257 gdb_hostif
.dbgarg
= NULL
;
258 gdb_hostif
.writec
= mywritec
;
259 gdb_hostif
.readc
= myreadc
;
260 gdb_hostif
.write
= mywrite
;
261 gdb_hostif
.gets
= mygets
;
262 gdb_hostif
.hostosarg
= NULL
;
263 gdb_hostif
.reset
= voiddummy
;
265 rslt
= angel_RDI_open (10, &gdb_config
, &gdb_hostif
, NULL
);
266 if (rslt
== RDIError_BigEndian
|| rslt
== RDIError_LittleEndian
)
267 ; /* do nothing, this is the expected return */
270 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
272 error ("RDI_open failed\n");
275 rslt
= angel_RDI_info (RDIInfo_Target
, &arg1
, &arg2
);
278 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
280 rslt
= angel_RDI_info (RDIInfo_Points
, &arg1
, &arg2
);
283 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
285 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
288 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
290 rslt
= angel_RDI_info (RDIInfo_CoPro
, &arg1
, &arg2
);
293 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
295 rslt
= angel_RDI_info (RDIInfo_SemiHosting
, &arg1
, &arg2
);
298 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
301 rslt
= angel_RDI_info (RDIInfo_GetLoadSize
, &arg1
, &arg2
);
304 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
306 max_load_size
= arg1
;
308 push_target (&arm_rdi_ops
);
310 target_fetch_registers (-1);
312 rslt
= angel_RDI_open (1, &gdb_config
, NULL
, NULL
);
315 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
318 arg1
= rom_at_zero
? 0x0 : 0x13b;
320 rslt
= angel_RDI_info (RDIVector_Catch
, &arg1
, &arg2
);
323 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
326 arg1
= (unsigned long) "";
327 rslt
= angel_RDI_info (RDISet_Cmdline
, &arg1
, &arg2
);
330 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
333 /* Clear out any existing records of breakpoints. */
335 struct local_bp_list_entry
*entry
, *preventry
= NULL
;
337 for (entry
= local_bp_list
; entry
!= NULL
; entry
= entry
->next
)
344 printf_filtered ("Connected to ARM RDI target.\n");
346 inferior_ptid
= pid_to_ptid (42);
349 /* Start an inferior process and set inferior_ptid to its pid.
350 EXEC_FILE is the file to run.
351 ARGS is a string containing the arguments to the program.
352 ENV is the environment vector to pass. Errors reported with error().
353 On VxWorks and various standalone systems, we ignore exec_file. */
354 /* This is called not only when we first attach, but also when the
355 user types "run" after having attached. */
358 arm_rdi_create_inferior (char *exec_file
, char *args
, char **env
)
361 unsigned long arg1
, arg2
;
363 CORE_ADDR entry_point
;
365 if (exec_file
== 0 || exec_bfd
== 0)
366 error ("No executable file specified.");
368 entry_point
= (CORE_ADDR
) bfd_get_start_address (exec_bfd
);
371 remove_breakpoints ();
372 init_wait_for_inferior ();
374 len
= strlen (exec_file
) + 1 + strlen (args
) + 1 + /*slop */ 10;
375 arg_buf
= (char *) alloca (len
);
377 strcat (arg_buf
, exec_file
);
378 strcat (arg_buf
, " ");
379 strcat (arg_buf
, args
);
381 inferior_ptid
= pid_to_ptid (42);
382 insert_breakpoints (); /* Needed to get correct instruction in cache */
388 if (strncmp (*env
, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
390 unsigned long top_of_memory
;
393 /* Set up memory limit */
394 top_of_memory
= strtoul (*env
+ sizeof ("MEMSIZE=") - 1,
396 printf_filtered ("Setting top-of-memory to 0x%lx\n",
399 rslt
= angel_RDI_info (RDIInfo_SetTopMem
, &top_of_memory
, &arg2
);
402 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
409 arg1
= (unsigned long) arg_buf
;
410 rslt
= angel_RDI_info (RDISet_Cmdline
, /* &arg1 */ (unsigned long *) arg_buf
, &arg2
);
413 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
416 proceed (entry_point
, TARGET_SIGNAL_DEFAULT
, 0);
419 /* This takes a program previously attached to and detaches it. After
420 this is done, GDB can be used to debug some other program. We
421 better not have left any breakpoints in the target program or it'll
422 die when it hits one. */
425 arm_rdi_detach (char *args
, int from_tty
)
430 /* Clean up connection to a remote debugger. */
433 arm_rdi_close (int quitting
)
439 rslt
= angel_RDI_close ();
442 printf_filtered ("RDI_close: %s\n", rdi_error_message (rslt
));
445 inferior_ptid
= null_ptid
;
447 generic_mourn_inferior ();
451 /* Tell the remote machine to resume. */
454 arm_rdi_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
459 if (0 /* turn on when hardware supports single-stepping */ )
461 rslt
= angel_RDI_step (1, &point
);
464 printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt
));
474 pc
= read_register (ARM_PC_REGNUM
);
475 pc
= arm_get_next_pc (pc
);
476 arm_rdi_insert_breakpoint (pc
, handle
);
478 execute_status
= rslt
= angel_RDI_execute (&point
);
479 if (rslt
== RDIError_BreakpointReached
)
483 printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt
));
487 arm_rdi_remove_breakpoint (pc
, handle
);
492 /* Send ^C to target to halt it. Target will respond, and send us a
496 arm_rdi_interrupt (int signo
)
500 static void (*ofunc
) ();
502 /* The user typed ^C twice. */
504 arm_rdi_interrupt_twice (int signo
)
508 /* Ask the user what to do when an interrupt is received. */
511 interrupt_query (void)
515 /* Wait until the remote machine stops, then return, storing status in
516 STATUS just as `wait' would. Returns "pid" (though it's not clear
517 what, if anything, that means in the case of this target). */
520 arm_rdi_wait (ptid_t ptid
, struct target_waitstatus
*status
)
522 status
->kind
= (execute_status
== RDIError_NoError
?
523 TARGET_WAITKIND_EXITED
: TARGET_WAITKIND_STOPPED
);
525 /* convert stopped code from target into right signal */
526 status
->value
.sig
= rdi_error_signal (execute_status
);
528 return inferior_ptid
;
531 /* Read the remote registers into the block REGS. */
535 arm_rdi_fetch_registers (int regno
)
537 int rslt
, rdi_regmask
;
538 unsigned long rawreg
, rawregs
[32];
543 rslt
= angel_RDI_CPUread (255, 0x27fff, rawregs
);
546 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
549 for (regno
= 0; regno
< 15; regno
++)
551 store_unsigned_integer (cookedreg
, 4, rawregs
[regno
]);
552 supply_register (regno
, (char *) cookedreg
);
554 store_unsigned_integer (cookedreg
, 4, rawregs
[15]);
555 supply_register (ARM_PS_REGNUM
, (char *) cookedreg
);
556 arm_rdi_fetch_registers (ARM_PC_REGNUM
);
560 if (regno
== ARM_PC_REGNUM
)
561 rdi_regmask
= RDIReg_PC
;
562 else if (regno
== ARM_PS_REGNUM
)
563 rdi_regmask
= RDIReg_CPSR
;
564 else if (regno
< 0 || regno
> 15)
567 supply_register (regno
, (char *) &rawreg
);
571 rdi_regmask
= 1 << regno
;
573 rslt
= angel_RDI_CPUread (255, rdi_regmask
, &rawreg
);
576 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
578 store_unsigned_integer (cookedreg
, 4, rawreg
);
579 supply_register (regno
, (char *) cookedreg
);
584 arm_rdi_prepare_to_store (void)
589 /* Store register REGNO, or all registers if REGNO == -1, from the contents
590 of REGISTERS. FIXME: ignores errors. */
593 arm_rdi_store_registers (int regno
)
595 int rslt
, rdi_regmask
;
597 /* These need to be able to take 'floating point register' contents */
598 unsigned long rawreg
[3], rawerreg
[3];
602 for (regno
= 0; regno
< NUM_REGS
; regno
++)
603 arm_rdi_store_registers (regno
);
607 read_register_gen (regno
, (char *) rawreg
);
608 /* RDI manipulates data in host byte order, so convert now. */
609 store_unsigned_integer (rawerreg
, 4, rawreg
[0]);
611 if (regno
== ARM_PC_REGNUM
)
612 rdi_regmask
= RDIReg_PC
;
613 else if (regno
== ARM_PS_REGNUM
)
614 rdi_regmask
= RDIReg_CPSR
;
615 else if (regno
< 0 || regno
> 15)
618 rdi_regmask
= 1 << regno
;
620 rslt
= angel_RDI_CPUwrite (255, rdi_regmask
, rawerreg
);
623 printf_filtered ("RDI_CPUwrite: %s\n", rdi_error_message (rslt
));
628 /* Read or write LEN bytes from inferior memory at MEMADDR,
629 transferring to or from debugger address MYADDR. Write to inferior
630 if SHOULD_WRITE is nonzero. Returns length of data written or
631 read; 0 for error. TARGET is unused. */
635 arm_rdi_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
636 int should_write
, struct mem_attrib
*attrib
,
637 struct target_ops
*target
)
643 rslt
= angel_RDI_write (myaddr
, memaddr
, &len
);
646 printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt
));
651 rslt
= angel_RDI_read (memaddr
, myaddr
, &len
);
654 printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt
));
661 /* Display random info collected from the target. */
664 arm_rdi_files_info (struct target_ops
*ignore
)
666 char *file
= "nothing";
668 unsigned long arg1
, arg2
;
670 rslt
= angel_RDI_info (RDIInfo_Target
, &arg1
, &arg2
);
673 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
675 if (arg1
& (1 << 15))
676 printf_filtered ("Target supports Thumb code.\n");
677 if (arg1
& (1 << 14))
678 printf_filtered ("Target can do profiling.\n");
680 printf_filtered ("Target is real hardware.\n");
682 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
685 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
687 printf_filtered ("Target can%s single-step.\n", (arg1
& 0x4 ? "" : "not"));
689 rslt
= angel_RDI_info (RDIInfo_Icebreaker
, &arg1
, &arg2
);
692 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
695 printf_filtered ("Target includes an EmbeddedICE.\n");
703 rslt
= angel_RDI_open (1, &gdb_config
, NULL
, NULL
);
706 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
711 arm_rdi_mourn_inferior (void)
713 /* We remove the inserted breakpoints in case the user wants to
714 issue another target and load commands to rerun his application;
715 This is something that wouldn't work on a native target, for instance,
716 as the process goes away when the inferior exits, but it works with
717 some remote targets like this one. That is why this is done here. */
718 remove_breakpoints();
719 unpush_target (&arm_rdi_ops
);
720 generic_mourn_inferior ();
723 /* While the RDI library keeps track of its own breakpoints, we need
724 to remember "handles" so that we can delete them later. Since
725 breakpoints get used for stepping, be careful not to leak memory
729 arm_rdi_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
733 struct local_bp_list_entry
*entry
;
734 int type
= RDIPoint_EQ
;
736 if (arm_pc_is_thumb (addr
) || arm_pc_is_thumb_dummy (addr
))
737 type
|= RDIPoint_16Bit
;
738 rslt
= angel_RDI_setbreak (addr
, type
, 0, &point
);
741 printf_filtered ("RDI_setbreak: %s\n", rdi_error_message (rslt
));
744 (struct local_bp_list_entry
*) xmalloc (sizeof (struct local_bp_list_entry
));
746 entry
->point
= point
;
747 entry
->next
= local_bp_list
;
748 local_bp_list
= entry
;
753 arm_rdi_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
757 struct local_bp_list_entry
*entry
, *preventry
;
759 for (entry
= local_bp_list
; entry
!= NULL
; entry
= entry
->next
)
761 if (entry
->addr
== addr
)
769 rslt
= angel_RDI_clearbreak (entry
->point
);
772 printf_filtered ("RDI_clearbreak: %s\n", rdi_error_message (rslt
));
774 /* Delete the breakpoint entry locally. */
775 if (entry
== local_bp_list
)
777 local_bp_list
= entry
->next
;
781 preventry
->next
= entry
->next
;
789 rdi_error_message (int err
)
793 case RDIError_NoError
:
796 return "debuggee reset";
797 case RDIError_UndefinedInstruction
:
798 return "undefined instruction";
799 case RDIError_SoftwareInterrupt
:
800 return "SWI trapped";
801 case RDIError_PrefetchAbort
:
802 return "prefetch abort, execution ran into unmapped memory?";
803 case RDIError_DataAbort
:
804 return "data abort, no memory at specified address?";
805 case RDIError_AddressException
:
806 return "address exception, access >26bit in 26bit mode";
808 return "IRQ, interrupt trapped";
810 return "FIQ, fast interrupt trapped";
812 return "a miscellaneous type of error";
813 case RDIError_BranchThrough0
:
814 return "branch through location 0";
815 case RDIError_NotInitialised
:
816 return "internal error, RDI_open not called first";
817 case RDIError_UnableToInitialise
:
818 return "internal error, target world is broken";
819 case RDIError_WrongByteSex
:
820 return "See Operator: WrongByteSex";
821 case RDIError_UnableToTerminate
:
822 return "See Operator: Unable to Terminate";
823 case RDIError_BadInstruction
:
824 return "bad instruction, illegal to execute this instruction";
825 case RDIError_IllegalInstruction
:
826 return "illegal instruction, the effect of executing it is undefined";
827 case RDIError_BadCPUStateSetting
:
828 return "internal error, tried to set SPSR of user mode";
829 case RDIError_UnknownCoPro
:
830 return "unknown co-processor";
831 case RDIError_UnknownCoProState
:
832 return "cannot execute co-processor request";
833 case RDIError_BadCoProState
:
834 return "recognizably broken co-processor request";
835 case RDIError_BadPointType
:
836 return "internal error, bad point yype";
837 case RDIError_UnimplementedType
:
838 return "internal error, unimplemented type";
839 case RDIError_BadPointSize
:
840 return "internal error, bad point size";
841 case RDIError_UnimplementedSize
:
842 return "internal error, unimplemented size";
843 case RDIError_NoMorePoints
:
844 return "last break/watch point was used";
845 case RDIError_BreakpointReached
:
846 return "breakpoint reached";
847 case RDIError_WatchpointAccessed
:
848 return "watchpoint accessed";
849 case RDIError_NoSuchPoint
:
850 return "attempted to clear non-existent break/watch point";
851 case RDIError_ProgramFinishedInStep
:
852 return "end of the program reached while stepping";
853 case RDIError_UserInterrupt
:
854 return "you pressed Escape";
855 case RDIError_CantSetPoint
:
856 return "no more break/watch points available";
857 case RDIError_IncompatibleRDILevels
:
858 return "incompatible RDI levels";
859 case RDIError_LittleEndian
:
860 return "debuggee is little endian";
861 case RDIError_BigEndian
:
862 return "debuggee is big endian";
863 case RDIError_SoftInitialiseError
:
864 return "recoverable error in RDI initialization";
865 case RDIError_InsufficientPrivilege
:
866 return "internal error, supervisor state not accessible to monitor";
867 case RDIError_UnimplementedMessage
:
868 return "internal error, unimplemented message";
869 case RDIError_UndefinedMessage
:
870 return "internal error, undefined message";
872 return "undefined error message, should reset target";
876 /* Convert the ARM error messages to signals that GDB knows about. */
878 static enum target_signal
879 rdi_error_signal (int err
)
883 case RDIError_NoError
:
886 return TARGET_SIGNAL_TERM
; /* ??? */
887 case RDIError_UndefinedInstruction
:
888 return TARGET_SIGNAL_ILL
;
889 case RDIError_SoftwareInterrupt
:
890 case RDIError_PrefetchAbort
:
891 case RDIError_DataAbort
:
892 return TARGET_SIGNAL_TRAP
;
893 case RDIError_AddressException
:
894 return TARGET_SIGNAL_SEGV
;
897 return TARGET_SIGNAL_TRAP
;
899 return TARGET_SIGNAL_TERM
;
900 case RDIError_BranchThrough0
:
901 return TARGET_SIGNAL_TRAP
;
902 case RDIError_NotInitialised
:
903 case RDIError_UnableToInitialise
:
904 case RDIError_WrongByteSex
:
905 case RDIError_UnableToTerminate
:
906 return TARGET_SIGNAL_UNKNOWN
;
907 case RDIError_BadInstruction
:
908 case RDIError_IllegalInstruction
:
909 return TARGET_SIGNAL_ILL
;
910 case RDIError_BadCPUStateSetting
:
911 case RDIError_UnknownCoPro
:
912 case RDIError_UnknownCoProState
:
913 case RDIError_BadCoProState
:
914 case RDIError_BadPointType
:
915 case RDIError_UnimplementedType
:
916 case RDIError_BadPointSize
:
917 case RDIError_UnimplementedSize
:
918 case RDIError_NoMorePoints
:
919 return TARGET_SIGNAL_UNKNOWN
;
920 case RDIError_BreakpointReached
:
921 case RDIError_WatchpointAccessed
:
922 return TARGET_SIGNAL_TRAP
;
923 case RDIError_NoSuchPoint
:
924 case RDIError_ProgramFinishedInStep
:
925 return TARGET_SIGNAL_UNKNOWN
;
926 case RDIError_UserInterrupt
:
927 return TARGET_SIGNAL_INT
;
928 case RDIError_IncompatibleRDILevels
:
929 case RDIError_LittleEndian
:
930 case RDIError_BigEndian
:
931 case RDIError_SoftInitialiseError
:
932 case RDIError_InsufficientPrivilege
:
933 case RDIError_UnimplementedMessage
:
934 case RDIError_UndefinedMessage
:
936 return TARGET_SIGNAL_UNKNOWN
;
943 angel_RDI_stop_request();
947 /* Define the target operations structure. */
952 arm_rdi_ops
.to_shortname
= "rdi";
953 arm_rdi_ops
.to_longname
= "ARM RDI";
954 arm_rdi_ops
.to_doc
= "Use a remote ARM-based computer; via the RDI library.\n\
955 Specify the serial device it is connected to (e.g. /dev/ttya).";
956 arm_rdi_ops
.to_open
= arm_rdi_open
;
957 arm_rdi_ops
.to_close
= arm_rdi_close
;
958 arm_rdi_ops
.to_detach
= arm_rdi_detach
;
959 arm_rdi_ops
.to_resume
= arm_rdi_resume
;
960 arm_rdi_ops
.to_wait
= arm_rdi_wait
;
961 arm_rdi_ops
.to_stop
= arm_rdi_stop
;
962 arm_rdi_ops
.to_fetch_registers
= arm_rdi_fetch_registers
;
963 arm_rdi_ops
.to_store_registers
= arm_rdi_store_registers
;
964 arm_rdi_ops
.to_prepare_to_store
= arm_rdi_prepare_to_store
;
965 arm_rdi_ops
.to_xfer_memory
= arm_rdi_xfer_memory
;
966 arm_rdi_ops
.to_files_info
= arm_rdi_files_info
;
967 arm_rdi_ops
.to_insert_breakpoint
= arm_rdi_insert_breakpoint
;
968 arm_rdi_ops
.to_remove_breakpoint
= arm_rdi_remove_breakpoint
;
969 arm_rdi_ops
.to_kill
= arm_rdi_kill
;
970 arm_rdi_ops
.to_load
= generic_load
;
971 arm_rdi_ops
.to_create_inferior
= arm_rdi_create_inferior
;
972 arm_rdi_ops
.to_mourn_inferior
= arm_rdi_mourn_inferior
;
973 arm_rdi_ops
.to_stratum
= process_stratum
;
974 arm_rdi_ops
.to_has_all_memory
= 1;
975 arm_rdi_ops
.to_has_memory
= 1;
976 arm_rdi_ops
.to_has_stack
= 1;
977 arm_rdi_ops
.to_has_registers
= 1;
978 arm_rdi_ops
.to_has_execution
= 1;
979 arm_rdi_ops
.to_magic
= OPS_MAGIC
;
983 rdilogfile_command (char *arg
, int from_tty
)
985 if (!arg
|| strlen (arg
) == 0)
987 printf_filtered ("rdi log file is '%s'\n", log_filename
);
992 xfree (log_filename
);
994 log_filename
= xstrdup (arg
);
996 Adp_SetLogfile (log_filename
);
1000 rdilogenable_command (char *args
, int from_tty
)
1002 if (!args
|| strlen (args
) == 0)
1004 printf_filtered ("rdi log is %s\n", log_enable
? "enabled" : "disabled");
1008 if (!strcasecmp (args
, "1") ||
1009 !strcasecmp (args
, "y") ||
1010 !strcasecmp (args
, "yes") ||
1011 !strcasecmp (args
, "on") ||
1012 !strcasecmp (args
, "t") ||
1013 !strcasecmp (args
, "true"))
1014 Adp_SetLogEnable (log_enable
= 1);
1015 else if (!strcasecmp (args
, "0") ||
1016 !strcasecmp (args
, "n") ||
1017 !strcasecmp (args
, "no") ||
1018 !strcasecmp (args
, "off") ||
1019 !strcasecmp (args
, "f") ||
1020 !strcasecmp (args
, "false"))
1021 Adp_SetLogEnable (log_enable
= 0);
1023 printf_filtered ("rdilogenable: unrecognized argument '%s'\n"
1024 " try y or n\n", args
);
1028 _initialize_remote_rdi (void)
1030 struct cmd_list_element
*c
;
1033 add_target (&arm_rdi_ops
);
1035 log_filename
= xstrdup ("rdi.log");
1036 Adp_SetLogfile (log_filename
);
1037 Adp_SetLogEnable (log_enable
);
1039 c
= add_cmd ("rdilogfile", class_maintenance
,
1041 "Set filename for ADP packet log.\n\
1042 This file is used to log Angel Debugger Protocol packets.\n\
1043 With a single argument, sets the logfile name to that value.\n\
1044 Without an argument, shows the current logfile name.\n\
1045 See also: rdilogenable\n",
1047 set_cmd_completer (c
, filename_completer
);
1049 add_cmd ("rdilogenable", class_maintenance
,
1050 rdilogenable_command
,
1051 "Set enable logging of ADP packets.\n\
1052 This will log ADP packets exchanged between gdb and the\n\
1053 rdi target device.\n\
1054 An argument of 1,t,true,y,yes will enable.\n\
1055 An argument of 0,f,false,n,no will disabled.\n\
1056 Withough an argument, it will display current state.\n",
1060 (add_set_cmd ("rdiromatzero", no_class
,
1061 var_boolean
, (char *) &rom_at_zero
,
1062 "Set target has ROM at addr 0.\n\
1063 A true value disables vector catching, false enables vector catching.\n\
1064 This is evaluated at the time the 'target rdi' command is executed\n",
1069 (add_set_cmd ("rdiheartbeat", no_class
,
1070 var_boolean
, (char *) &rdi_heartbeat
,
1071 "Set enable for ADP heartbeat packets.\n\
1072 I don't know why you would want this. If you enable them,\n\
1073 it will confuse ARM and EPI JTAG interface boxes as well\n\
1074 as the Angel Monitor.\n",
1079 /* A little dummy to make linking with the library succeed. */