1 /* GDB interface to ARM RDI library.
2 Copyright 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 #include "gdb_string.h"
31 #include "gdb-stabs.h"
32 #include "gdbthread.h"
34 #include "breakpoint.h"
35 #include "completer.h"
39 #include <sys/types.h>
44 #include "rdi-share/ardi.h"
45 #include "rdi-share/adp.h"
46 #include "rdi-share/hsys.h"
48 extern int isascii (int);
50 /* Prototypes for local functions */
52 static void arm_rdi_files_info (struct target_ops
*ignore
);
54 static int arm_rdi_xfer_memory (CORE_ADDR memaddr
, char *myaddr
,
55 int len
, int should_write
,
56 struct mem_attrib
*attrib
,
57 struct target_ops
*target
);
59 static void arm_rdi_prepare_to_store (void);
61 static void arm_rdi_fetch_registers (int regno
);
63 static void arm_rdi_resume (ptid_t pid
, int step
,
64 enum target_signal siggnal
);
66 static int arm_rdi_start_remote (char *dummy
);
68 static void arm_rdi_open (char *name
, int from_tty
);
70 static void arm_rdi_create_inferior (char *exec_file
, char *args
, char **env
);
72 static void arm_rdi_close (int quitting
);
74 static void arm_rdi_store_registers (int regno
);
76 static void arm_rdi_mourn (void);
78 static void arm_rdi_send (char *buf
);
80 static ptid_t
arm_rdi_wait (ptid_t ptid
, struct target_waitstatus
*status
);
82 static void arm_rdi_kill (void);
84 static void arm_rdi_detach (char *args
, int from_tty
);
86 static void arm_rdi_interrupt (int signo
);
88 static void arm_rdi_interrupt_twice (int signo
);
90 static void interrupt_query (void);
92 static int arm_rdi_insert_breakpoint (CORE_ADDR
, char *);
94 static int arm_rdi_remove_breakpoint (CORE_ADDR
, char *);
96 static char *rdi_error_message (int err
);
98 static enum target_signal
rdi_error_signal (int err
);
100 /* Global variables. */
102 struct target_ops arm_rdi_ops
;
104 static struct Dbg_ConfigBlock gdb_config
;
106 static struct Dbg_HostosInterface gdb_hostif
;
108 static int max_load_size
;
110 static int execute_status
;
112 /* Send heatbeat packets? */
113 static int rdi_heartbeat
= 0;
115 /* Target has ROM at address 0. */
116 static int rom_at_zero
= 0;
118 /* Enable logging? */
119 static int log_enable
= 0;
121 /* Name of the log file. Default is "rdi.log". */
122 static char *log_filename
;
124 /* A little list of breakpoints that have been set. */
126 static struct local_bp_list_entry
130 struct local_bp_list_entry
*next
;
135 /* Stub for catch_errors. */
138 arm_rdi_start_remote (char *dummy
)
143 /* Helper callbacks for the "host interface" structure. RDI functions call
144 these to forward output from the target system and so forth. */
147 voiddummy (void *dummy
)
149 fprintf_unfiltered (gdb_stdout
, "void dummy\n");
153 myprint (PTR arg
, const char *format
, va_list ap
)
155 vfprintf_unfiltered (gdb_stdout
, format
, ap
);
159 mywritec (PTR arg
, int c
)
162 fputc_unfiltered (c
, gdb_stdout
);
166 mywrite (PTR arg
, char const *buffer
, int len
)
172 for (i
= 0; i
< len
; i
++)
174 if (isascii ((int) *e
))
176 fputc_unfiltered ((int) *e
, gdb_stdout
);
189 /* These last two are tricky as we have to handle the special case of
190 being interrupted more carefully */
195 return fgetc (stdin
);
199 mygets (PTR arg
, char *buffer
, int len
)
201 return fgets (buffer
, len
, stdin
);
204 /* Prevent multiple calls to angel_RDI_close(). */
205 static int closed_already
= 1;
207 /* Open a connection to a remote debugger. NAME is the filename used
208 for communication. */
211 arm_rdi_open (char *name
, int from_tty
)
214 unsigned long arg1
, arg2
;
215 char *openArgs
= NULL
;
216 char *devName
= NULL
;
220 error ("To open an RDI connection, you need to specify what serial\n\
221 device is attached to the remote system (e.g. /dev/ttya).");
223 /* split name after whitespace, pass tail as arg to open command */
225 devName
= xstrdup (name
);
226 p
= strchr (devName
, ' ');
238 /* Make the basic low-level connection. */
241 rslt
= Adp_OpenDevice (devName
, openArgs
, rdi_heartbeat
);
244 error ("Could not open device \"%s\"", name
);
246 gdb_config
.bytesex
= 2 | (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? 1 : 0);
248 gdb_config
.rditype
= 2;
249 gdb_config
.heartbeat_on
= 1;
250 gdb_config
.flags
= 2;
252 gdb_hostif
.dbgprint
= myprint
;
253 gdb_hostif
.dbgpause
= mypause
;
254 gdb_hostif
.dbgarg
= NULL
;
255 gdb_hostif
.writec
= mywritec
;
256 gdb_hostif
.readc
= myreadc
;
257 gdb_hostif
.write
= mywrite
;
258 gdb_hostif
.gets
= mygets
;
259 gdb_hostif
.hostosarg
= NULL
;
260 gdb_hostif
.reset
= voiddummy
;
262 rslt
= angel_RDI_open (10, &gdb_config
, &gdb_hostif
, NULL
);
263 if (rslt
== RDIError_BigEndian
|| rslt
== RDIError_LittleEndian
)
264 ; /* do nothing, this is the expected return */
267 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
269 error ("RDI_open failed\n");
272 rslt
= angel_RDI_info (RDIInfo_Target
, &arg1
, &arg2
);
275 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
277 rslt
= angel_RDI_info (RDIInfo_Points
, &arg1
, &arg2
);
280 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
282 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
285 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
287 rslt
= angel_RDI_info (RDIInfo_CoPro
, &arg1
, &arg2
);
290 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
292 rslt
= angel_RDI_info (RDIInfo_SemiHosting
, &arg1
, &arg2
);
295 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
298 rslt
= angel_RDI_info (RDIInfo_GetLoadSize
, &arg1
, &arg2
);
301 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
303 max_load_size
= arg1
;
305 push_target (&arm_rdi_ops
);
307 target_fetch_registers (-1);
309 rslt
= angel_RDI_open (1, &gdb_config
, NULL
, NULL
);
312 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
315 arg1
= rom_at_zero
? 0x0 : 0x13b;
317 rslt
= angel_RDI_info (RDIVector_Catch
, &arg1
, &arg2
);
320 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
323 arg1
= (unsigned long) "";
324 rslt
= angel_RDI_info (RDISet_Cmdline
, &arg1
, &arg2
);
327 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
330 /* Clear out any existing records of breakpoints. */
332 struct local_bp_list_entry
*entry
, *preventry
= NULL
;
334 for (entry
= local_bp_list
; entry
!= NULL
; entry
= entry
->next
)
341 printf_filtered ("Connected to ARM RDI target.\n");
343 inferior_ptid
= pid_to_ptid (42);
346 /* Start an inferior process and set inferior_ptid to its pid.
347 EXEC_FILE is the file to run.
348 ARGS is a string containing the arguments to the program.
349 ENV is the environment vector to pass. Errors reported with error().
350 On VxWorks and various standalone systems, we ignore exec_file. */
351 /* This is called not only when we first attach, but also when the
352 user types "run" after having attached. */
355 arm_rdi_create_inferior (char *exec_file
, char *args
, char **env
)
358 unsigned long arg1
, arg2
;
360 CORE_ADDR entry_point
;
362 if (exec_file
== 0 || exec_bfd
== 0)
363 error ("No executable file specified.");
365 entry_point
= (CORE_ADDR
) bfd_get_start_address (exec_bfd
);
368 remove_breakpoints ();
369 init_wait_for_inferior ();
371 len
= strlen (exec_file
) + 1 + strlen (args
) + 1 + /*slop */ 10;
372 arg_buf
= (char *) alloca (len
);
374 strcat (arg_buf
, exec_file
);
375 strcat (arg_buf
, " ");
376 strcat (arg_buf
, args
);
378 inferior_ptid
= pid_to_ptid (42);
379 insert_breakpoints (); /* Needed to get correct instruction in cache */
385 if (strncmp (*env
, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
387 unsigned long top_of_memory
;
390 /* Set up memory limit */
391 top_of_memory
= strtoul (*env
+ sizeof ("MEMSIZE=") - 1,
393 printf_filtered ("Setting top-of-memory to 0x%lx\n",
396 rslt
= angel_RDI_info (RDIInfo_SetTopMem
, &top_of_memory
, &arg2
);
399 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
406 arg1
= (unsigned long) arg_buf
;
407 rslt
= angel_RDI_info (RDISet_Cmdline
, /* &arg1 */ (unsigned long *) arg_buf
, &arg2
);
410 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
413 proceed (entry_point
, TARGET_SIGNAL_DEFAULT
, 0);
416 /* This takes a program previously attached to and detaches it. After
417 this is done, GDB can be used to debug some other program. We
418 better not have left any breakpoints in the target program or it'll
419 die when it hits one. */
422 arm_rdi_detach (char *args
, int from_tty
)
427 /* Clean up connection to a remote debugger. */
430 arm_rdi_close (int quitting
)
436 rslt
= angel_RDI_close ();
439 printf_filtered ("RDI_close: %s\n", rdi_error_message (rslt
));
442 inferior_ptid
= null_ptid
;
444 generic_mourn_inferior ();
448 /* Tell the remote machine to resume. */
451 arm_rdi_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
456 if (0 /* turn on when hardware supports single-stepping */ )
458 rslt
= angel_RDI_step (1, &point
);
461 printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt
));
471 pc
= read_register (PC_REGNUM
);
472 pc
= arm_get_next_pc (pc
);
473 arm_rdi_insert_breakpoint (pc
, handle
);
475 execute_status
= rslt
= angel_RDI_execute (&point
);
476 if (rslt
== RDIError_BreakpointReached
)
480 printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt
));
484 arm_rdi_remove_breakpoint (pc
, handle
);
489 /* Send ^C to target to halt it. Target will respond, and send us a
493 arm_rdi_interrupt (int signo
)
497 static void (*ofunc
) ();
499 /* The user typed ^C twice. */
501 arm_rdi_interrupt_twice (int signo
)
505 /* Ask the user what to do when an interrupt is received. */
508 interrupt_query (void)
512 /* Wait until the remote machine stops, then return, storing status in
513 STATUS just as `wait' would. Returns "pid" (though it's not clear
514 what, if anything, that means in the case of this target). */
517 arm_rdi_wait (ptid_t ptid
, struct target_waitstatus
*status
)
519 status
->kind
= (execute_status
== RDIError_NoError
?
520 TARGET_WAITKIND_EXITED
: TARGET_WAITKIND_STOPPED
);
522 /* convert stopped code from target into right signal */
523 status
->value
.sig
= rdi_error_signal (execute_status
);
525 return inferior_ptid
;
528 /* Read the remote registers into the block REGS. */
532 arm_rdi_fetch_registers (int regno
)
534 int rslt
, rdi_regmask
;
535 unsigned long rawreg
, rawregs
[32];
540 rslt
= angel_RDI_CPUread (255, 0x27fff, rawregs
);
543 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
546 for (regno
= 0; regno
< 15; regno
++)
548 store_unsigned_integer (cookedreg
, 4, rawregs
[regno
]);
549 supply_register (regno
, (char *) cookedreg
);
551 store_unsigned_integer (cookedreg
, 4, rawregs
[15]);
552 supply_register (PS_REGNUM
, (char *) cookedreg
);
553 arm_rdi_fetch_registers (PC_REGNUM
);
557 if (regno
== PC_REGNUM
)
558 rdi_regmask
= RDIReg_PC
;
559 else if (regno
== PS_REGNUM
)
560 rdi_regmask
= RDIReg_CPSR
;
561 else if (regno
< 0 || regno
> 15)
564 supply_register (regno
, (char *) &rawreg
);
568 rdi_regmask
= 1 << regno
;
570 rslt
= angel_RDI_CPUread (255, rdi_regmask
, &rawreg
);
573 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
575 store_unsigned_integer (cookedreg
, 4, rawreg
);
576 supply_register (regno
, (char *) cookedreg
);
581 arm_rdi_prepare_to_store (void)
586 /* Store register REGNO, or all registers if REGNO == -1, from the contents
587 of REGISTERS. FIXME: ignores errors. */
590 arm_rdi_store_registers (int regno
)
592 int rslt
, rdi_regmask
;
594 /* These need to be able to take 'floating point register' contents */
595 unsigned long rawreg
[3], rawerreg
[3];
599 for (regno
= 0; regno
< NUM_REGS
; regno
++)
600 arm_rdi_store_registers (regno
);
604 read_register_gen (regno
, (char *) rawreg
);
605 /* RDI manipulates data in host byte order, so convert now. */
606 store_unsigned_integer (rawerreg
, 4, rawreg
[0]);
608 if (regno
== PC_REGNUM
)
609 rdi_regmask
= RDIReg_PC
;
610 else if (regno
== PS_REGNUM
)
611 rdi_regmask
= RDIReg_CPSR
;
612 else if (regno
< 0 || regno
> 15)
615 rdi_regmask
= 1 << regno
;
617 rslt
= angel_RDI_CPUwrite (255, rdi_regmask
, rawerreg
);
620 printf_filtered ("RDI_CPUwrite: %s\n", rdi_error_message (rslt
));
625 /* Read or write LEN bytes from inferior memory at MEMADDR,
626 transferring to or from debugger address MYADDR. Write to inferior
627 if SHOULD_WRITE is nonzero. Returns length of data written or
628 read; 0 for error. TARGET is unused. */
632 arm_rdi_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int should_write
,
633 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
634 struct target_ops
*target ATTRIBUTE_UNUSED
)
640 rslt
= angel_RDI_write (myaddr
, memaddr
, &len
);
643 printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt
));
648 rslt
= angel_RDI_read (memaddr
, myaddr
, &len
);
651 printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt
));
658 /* Display random info collected from the target. */
661 arm_rdi_files_info (struct target_ops
*ignore
)
663 char *file
= "nothing";
665 unsigned long arg1
, arg2
;
667 rslt
= angel_RDI_info (RDIInfo_Target
, &arg1
, &arg2
);
670 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
672 if (arg1
& (1 << 15))
673 printf_filtered ("Target supports Thumb code.\n");
674 if (arg1
& (1 << 14))
675 printf_filtered ("Target can do profiling.\n");
677 printf_filtered ("Target is real hardware.\n");
679 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
682 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
684 printf_filtered ("Target can%s single-step.\n", (arg1
& 0x4 ? "" : "not"));
686 rslt
= angel_RDI_info (RDIInfo_Icebreaker
, &arg1
, &arg2
);
689 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
692 printf_filtered ("Target includes an EmbeddedICE.\n");
700 rslt
= angel_RDI_open (1, &gdb_config
, NULL
, NULL
);
703 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
708 arm_rdi_mourn_inferior (void)
710 /* We remove the inserted breakpoints in case the user wants to
711 issue another target and load commands to rerun his application;
712 This is something that wouldn't work on a native target, for instance,
713 as the process goes away when the inferior exits, but it works with
714 some remote targets like this one. That is why this is done here. */
715 remove_breakpoints();
716 unpush_target (&arm_rdi_ops
);
717 generic_mourn_inferior ();
720 /* While the RDI library keeps track of its own breakpoints, we need
721 to remember "handles" so that we can delete them later. Since
722 breakpoints get used for stepping, be careful not to leak memory
726 arm_rdi_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
730 struct local_bp_list_entry
*entry
;
731 int type
= RDIPoint_EQ
;
733 if (arm_pc_is_thumb (addr
) || arm_pc_is_thumb_dummy (addr
))
734 type
|= RDIPoint_16Bit
;
735 rslt
= angel_RDI_setbreak (addr
, type
, 0, &point
);
738 printf_filtered ("RDI_setbreak: %s\n", rdi_error_message (rslt
));
741 (struct local_bp_list_entry
*) xmalloc (sizeof (struct local_bp_list_entry
));
743 entry
->point
= point
;
744 entry
->next
= local_bp_list
;
745 local_bp_list
= entry
;
750 arm_rdi_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
754 struct local_bp_list_entry
*entry
, *preventry
;
756 for (entry
= local_bp_list
; entry
!= NULL
; entry
= entry
->next
)
758 if (entry
->addr
== addr
)
766 rslt
= angel_RDI_clearbreak (entry
->point
);
769 printf_filtered ("RDI_clearbreak: %s\n", rdi_error_message (rslt
));
771 /* Delete the breakpoint entry locally. */
772 if (entry
== local_bp_list
)
774 local_bp_list
= entry
->next
;
778 preventry
->next
= entry
->next
;
786 rdi_error_message (int err
)
790 case RDIError_NoError
:
793 return "debuggee reset";
794 case RDIError_UndefinedInstruction
:
795 return "undefined instruction";
796 case RDIError_SoftwareInterrupt
:
797 return "SWI trapped";
798 case RDIError_PrefetchAbort
:
799 return "prefetch abort, execution ran into unmapped memory?";
800 case RDIError_DataAbort
:
801 return "data abort, no memory at specified address?";
802 case RDIError_AddressException
:
803 return "address exception, access >26bit in 26bit mode";
805 return "IRQ, interrupt trapped";
807 return "FIQ, fast interrupt trapped";
809 return "a miscellaneous type of error";
810 case RDIError_BranchThrough0
:
811 return "branch through location 0";
812 case RDIError_NotInitialised
:
813 return "internal error, RDI_open not called first";
814 case RDIError_UnableToInitialise
:
815 return "internal error, target world is broken";
816 case RDIError_WrongByteSex
:
817 return "See Operator: WrongByteSex";
818 case RDIError_UnableToTerminate
:
819 return "See Operator: Unable to Terminate";
820 case RDIError_BadInstruction
:
821 return "bad instruction, illegal to execute this instruction";
822 case RDIError_IllegalInstruction
:
823 return "illegal instruction, the effect of executing it is undefined";
824 case RDIError_BadCPUStateSetting
:
825 return "internal error, tried to set SPSR of user mode";
826 case RDIError_UnknownCoPro
:
827 return "unknown co-processor";
828 case RDIError_UnknownCoProState
:
829 return "cannot execute co-processor request";
830 case RDIError_BadCoProState
:
831 return "recognizably broken co-processor request";
832 case RDIError_BadPointType
:
833 return "internal error, bad point yype";
834 case RDIError_UnimplementedType
:
835 return "internal error, unimplemented type";
836 case RDIError_BadPointSize
:
837 return "internal error, bad point size";
838 case RDIError_UnimplementedSize
:
839 return "internal error, unimplemented size";
840 case RDIError_NoMorePoints
:
841 return "last break/watch point was used";
842 case RDIError_BreakpointReached
:
843 return "breakpoint reached";
844 case RDIError_WatchpointAccessed
:
845 return "watchpoint accessed";
846 case RDIError_NoSuchPoint
:
847 return "attempted to clear non-existent break/watch point";
848 case RDIError_ProgramFinishedInStep
:
849 return "end of the program reached while stepping";
850 case RDIError_UserInterrupt
:
851 return "you pressed Escape";
852 case RDIError_CantSetPoint
:
853 return "no more break/watch points available";
854 case RDIError_IncompatibleRDILevels
:
855 return "incompatible RDI levels";
856 case RDIError_LittleEndian
:
857 return "debuggee is little endian";
858 case RDIError_BigEndian
:
859 return "debuggee is big endian";
860 case RDIError_SoftInitialiseError
:
861 return "recoverable error in RDI initialization";
862 case RDIError_InsufficientPrivilege
:
863 return "internal error, supervisor state not accessible to monitor";
864 case RDIError_UnimplementedMessage
:
865 return "internal error, unimplemented message";
866 case RDIError_UndefinedMessage
:
867 return "internal error, undefined message";
869 return "undefined error message, should reset target";
873 /* Convert the ARM error messages to signals that GDB knows about. */
875 static enum target_signal
876 rdi_error_signal (int err
)
880 case RDIError_NoError
:
883 return TARGET_SIGNAL_TERM
; /* ??? */
884 case RDIError_UndefinedInstruction
:
885 return TARGET_SIGNAL_ILL
;
886 case RDIError_SoftwareInterrupt
:
887 case RDIError_PrefetchAbort
:
888 case RDIError_DataAbort
:
889 return TARGET_SIGNAL_TRAP
;
890 case RDIError_AddressException
:
891 return TARGET_SIGNAL_SEGV
;
894 return TARGET_SIGNAL_TRAP
;
896 return TARGET_SIGNAL_TERM
;
897 case RDIError_BranchThrough0
:
898 return TARGET_SIGNAL_TRAP
;
899 case RDIError_NotInitialised
:
900 case RDIError_UnableToInitialise
:
901 case RDIError_WrongByteSex
:
902 case RDIError_UnableToTerminate
:
903 return TARGET_SIGNAL_UNKNOWN
;
904 case RDIError_BadInstruction
:
905 case RDIError_IllegalInstruction
:
906 return TARGET_SIGNAL_ILL
;
907 case RDIError_BadCPUStateSetting
:
908 case RDIError_UnknownCoPro
:
909 case RDIError_UnknownCoProState
:
910 case RDIError_BadCoProState
:
911 case RDIError_BadPointType
:
912 case RDIError_UnimplementedType
:
913 case RDIError_BadPointSize
:
914 case RDIError_UnimplementedSize
:
915 case RDIError_NoMorePoints
:
916 return TARGET_SIGNAL_UNKNOWN
;
917 case RDIError_BreakpointReached
:
918 case RDIError_WatchpointAccessed
:
919 return TARGET_SIGNAL_TRAP
;
920 case RDIError_NoSuchPoint
:
921 case RDIError_ProgramFinishedInStep
:
922 return TARGET_SIGNAL_UNKNOWN
;
923 case RDIError_UserInterrupt
:
924 return TARGET_SIGNAL_INT
;
925 case RDIError_IncompatibleRDILevels
:
926 case RDIError_LittleEndian
:
927 case RDIError_BigEndian
:
928 case RDIError_SoftInitialiseError
:
929 case RDIError_InsufficientPrivilege
:
930 case RDIError_UnimplementedMessage
:
931 case RDIError_UndefinedMessage
:
933 return TARGET_SIGNAL_UNKNOWN
;
940 angel_RDI_stop_request();
944 /* Define the target operations structure. */
949 arm_rdi_ops
.to_shortname
= "rdi";
950 arm_rdi_ops
.to_longname
= "ARM RDI";
951 arm_rdi_ops
.to_doc
= "Use a remote ARM-based computer; via the RDI library.\n\
952 Specify the serial device it is connected to (e.g. /dev/ttya).";
953 arm_rdi_ops
.to_open
= arm_rdi_open
;
954 arm_rdi_ops
.to_close
= arm_rdi_close
;
955 arm_rdi_ops
.to_detach
= arm_rdi_detach
;
956 arm_rdi_ops
.to_resume
= arm_rdi_resume
;
957 arm_rdi_ops
.to_wait
= arm_rdi_wait
;
958 arm_rdi_ops
.to_stop
= arm_rdi_stop
;
959 arm_rdi_ops
.to_fetch_registers
= arm_rdi_fetch_registers
;
960 arm_rdi_ops
.to_store_registers
= arm_rdi_store_registers
;
961 arm_rdi_ops
.to_prepare_to_store
= arm_rdi_prepare_to_store
;
962 arm_rdi_ops
.to_xfer_memory
= arm_rdi_xfer_memory
;
963 arm_rdi_ops
.to_files_info
= arm_rdi_files_info
;
964 arm_rdi_ops
.to_insert_breakpoint
= arm_rdi_insert_breakpoint
;
965 arm_rdi_ops
.to_remove_breakpoint
= arm_rdi_remove_breakpoint
;
966 arm_rdi_ops
.to_kill
= arm_rdi_kill
;
967 arm_rdi_ops
.to_load
= generic_load
;
968 arm_rdi_ops
.to_create_inferior
= arm_rdi_create_inferior
;
969 arm_rdi_ops
.to_mourn_inferior
= arm_rdi_mourn_inferior
;
970 arm_rdi_ops
.to_stratum
= process_stratum
;
971 arm_rdi_ops
.to_has_all_memory
= 1;
972 arm_rdi_ops
.to_has_memory
= 1;
973 arm_rdi_ops
.to_has_stack
= 1;
974 arm_rdi_ops
.to_has_registers
= 1;
975 arm_rdi_ops
.to_has_execution
= 1;
976 arm_rdi_ops
.to_magic
= OPS_MAGIC
;
980 rdilogfile_command (char *arg
, int from_tty
)
982 if (!arg
|| strlen (arg
) == 0)
984 printf_filtered ("rdi log file is '%s'\n", log_filename
);
989 xfree (log_filename
);
991 log_filename
= xstrdup (arg
);
993 Adp_SetLogfile (log_filename
);
997 rdilogenable_command (char *args
, int from_tty
)
999 if (!args
|| strlen (args
) == 0)
1001 printf_filtered ("rdi log is %s\n", log_enable
? "enabled" : "disabled");
1005 if (!strcasecmp (args
, "1") ||
1006 !strcasecmp (args
, "y") ||
1007 !strcasecmp (args
, "yes") ||
1008 !strcasecmp (args
, "on") ||
1009 !strcasecmp (args
, "t") ||
1010 !strcasecmp (args
, "true"))
1011 Adp_SetLogEnable (log_enable
= 1);
1012 else if (!strcasecmp (args
, "0") ||
1013 !strcasecmp (args
, "n") ||
1014 !strcasecmp (args
, "no") ||
1015 !strcasecmp (args
, "off") ||
1016 !strcasecmp (args
, "f") ||
1017 !strcasecmp (args
, "false"))
1018 Adp_SetLogEnable (log_enable
= 0);
1020 printf_filtered ("rdilogenable: unrecognized argument '%s'\n"
1021 " try y or n\n", args
);
1025 _initialize_remote_rdi (void)
1027 struct cmd_list_element
*c
;
1030 add_target (&arm_rdi_ops
);
1032 log_filename
= xstrdup ("rdi.log");
1033 Adp_SetLogfile (log_filename
);
1034 Adp_SetLogEnable (log_enable
);
1036 c
= add_cmd ("rdilogfile", class_maintenance
,
1038 "Set filename for ADP packet log.\n\
1039 This file is used to log Angel Debugger Protocol packets.\n\
1040 With a single argument, sets the logfile name to that value.\n\
1041 Without an argument, shows the current logfile name.\n\
1042 See also: rdilogenable\n",
1044 c
->completer
= filename_completer
;
1046 add_cmd ("rdilogenable", class_maintenance
,
1047 rdilogenable_command
,
1048 "Set enable logging of ADP packets.\n\
1049 This will log ADP packets exchanged between gdb and the\n\
1050 rdi target device.\n\
1051 An argument of 1,t,true,y,yes will enable.\n\
1052 An argument of 0,f,false,n,no will disabled.\n\
1053 Withough an argument, it will display current state.\n",
1057 (add_set_cmd ("rdiromatzero", no_class
,
1058 var_boolean
, (char *) &rom_at_zero
,
1059 "Set target has ROM at addr 0.\n\
1060 A true value disables vector catching, false enables vector catching.\n\
1061 This is evaluated at the time the 'target rdi' command is executed\n",
1066 (add_set_cmd ("rdiheartbeat", no_class
,
1067 var_boolean
, (char *) &rdi_heartbeat
,
1068 "Set enable for ADP heartbeat packets.\n\
1069 I don't know why you would want this. If you enable them,\n\
1070 it will confuse ARM and EPI JTAG interface boxes as well\n\
1071 as the Angel Monitor.\n",
1076 /* A little dummy to make linking with the library succeed. */