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 (void *arg
, const char *format
, va_list ap
)
158 vfprintf_unfiltered (gdb_stdout
, format
, ap
);
162 mywritec (void *arg
, int c
)
165 fputc_unfiltered (c
, gdb_stdout
);
169 mywrite (void *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 (void *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 */
268 else if (rslt
!= RDIError_NoError
)
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
);
276 if (rslt
!= RDIError_NoError
)
278 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
280 rslt
= angel_RDI_info (RDIInfo_Points
, &arg1
, &arg2
);
281 if (rslt
!= RDIError_NoError
)
283 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
285 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
286 if (rslt
!= RDIError_NoError
)
288 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
290 rslt
= angel_RDI_info (RDIInfo_CoPro
, &arg1
, &arg2
);
291 if (rslt
!= RDIError_NoError
)
293 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
295 rslt
= angel_RDI_info (RDIInfo_SemiHosting
, &arg1
, &arg2
);
296 if (rslt
!= RDIError_NoError
)
298 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
301 rslt
= angel_RDI_info (RDIInfo_GetLoadSize
, &arg1
, &arg2
);
302 if (rslt
!= RDIError_NoError
)
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
);
313 if (rslt
!= RDIError_NoError
)
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
);
321 if (rslt
!= RDIError_NoError
)
323 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
326 arg1
= (unsigned long) "";
327 rslt
= angel_RDI_info (RDISet_Cmdline
, &arg1
, &arg2
);
328 if (rslt
!= RDIError_NoError
)
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
);
400 if (rslt
!= RDIError_NoError
)
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
);
411 if (rslt
!= RDIError_NoError
)
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 ();
440 if (rslt
!= RDIError_NoError
)
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
);
462 if (rslt
!= RDIError_NoError
)
463 printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt
));
472 pc
= read_register (ARM_PC_REGNUM
);
473 pc
= arm_get_next_pc (pc
);
474 arm_rdi_insert_breakpoint (pc
, handle
);
477 execute_status
= rslt
= angel_RDI_execute (&point
);
478 if (rslt
!= RDIError_NoError
&& rslt
!= RDIError_BreakpointReached
)
479 printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt
));
482 arm_rdi_remove_breakpoint (pc
, handle
);
486 /* Send ^C to target to halt it. Target will respond, and send us a
490 arm_rdi_interrupt (int signo
)
494 static void (*ofunc
) ();
496 /* The user typed ^C twice. */
498 arm_rdi_interrupt_twice (int signo
)
502 /* Ask the user what to do when an interrupt is received. */
505 interrupt_query (void)
509 /* Wait until the remote machine stops, then return, storing status in
510 STATUS just as `wait' would. Returns "pid" (though it's not clear
511 what, if anything, that means in the case of this target). */
514 arm_rdi_wait (ptid_t ptid
, struct target_waitstatus
*status
)
516 status
->kind
= (execute_status
== RDIError_NoError
?
517 TARGET_WAITKIND_EXITED
: TARGET_WAITKIND_STOPPED
);
519 /* convert stopped code from target into right signal */
520 status
->value
.sig
= rdi_error_signal (execute_status
);
522 return inferior_ptid
;
525 /* Read the remote registers into the block REGS. */
528 arm_rdi_fetch_registers (int regno
)
530 int rslt
, rdi_regmask
;
531 unsigned long rawreg
, rawregs
[32];
536 rslt
= angel_RDI_CPUread (255, 0x27fff, rawregs
);
537 if (rslt
!= RDIError_NoError
)
539 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
542 for (regno
= 0; regno
< 15; regno
++)
544 store_unsigned_integer (cookedreg
, 4, rawregs
[regno
]);
545 supply_register (regno
, (char *) cookedreg
);
547 store_unsigned_integer (cookedreg
, 4, rawregs
[15]);
548 supply_register (ARM_PS_REGNUM
, (char *) cookedreg
);
549 arm_rdi_fetch_registers (ARM_PC_REGNUM
);
553 if (regno
== ARM_PC_REGNUM
)
554 rdi_regmask
= RDIReg_PC
;
555 else if (regno
== ARM_PS_REGNUM
)
556 rdi_regmask
= RDIReg_CPSR
;
557 else if (regno
< 0 || regno
> 15)
560 supply_register (regno
, (char *) &rawreg
);
564 rdi_regmask
= 1 << regno
;
566 rslt
= angel_RDI_CPUread (255, rdi_regmask
, &rawreg
);
567 if (rslt
!= RDIError_NoError
)
569 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
571 store_unsigned_integer (cookedreg
, 4, rawreg
);
572 supply_register (regno
, (char *) cookedreg
);
577 arm_rdi_prepare_to_store (void)
582 /* Store register REGNO, or all registers if REGNO == -1, from the contents
583 of REGISTERS. FIXME: ignores errors. */
586 arm_rdi_store_registers (int regno
)
588 int rslt
, rdi_regmask
;
590 /* These need to be able to take 'floating point register' contents */
591 unsigned long rawreg
[3], rawerreg
[3];
595 for (regno
= 0; regno
< NUM_REGS
; regno
++)
596 arm_rdi_store_registers (regno
);
600 deprecated_read_register_gen (regno
, (char *) rawreg
);
601 /* RDI manipulates data in host byte order, so convert now. */
602 store_unsigned_integer (rawerreg
, 4, rawreg
[0]);
604 if (regno
== ARM_PC_REGNUM
)
605 rdi_regmask
= RDIReg_PC
;
606 else if (regno
== ARM_PS_REGNUM
)
607 rdi_regmask
= RDIReg_CPSR
;
608 else if (regno
< 0 || regno
> 15)
611 rdi_regmask
= 1 << regno
;
613 rslt
= angel_RDI_CPUwrite (255, rdi_regmask
, rawerreg
);
614 if (rslt
!= RDIError_NoError
)
616 printf_filtered ("RDI_CPUwrite: %s\n", rdi_error_message (rslt
));
621 /* Read or write LEN bytes from inferior memory at MEMADDR,
622 transferring to or from debugger address MYADDR. Write to inferior
623 if SHOULD_WRITE is nonzero. Returns length of data written or
624 read; 0 for error. TARGET is unused. */
627 arm_rdi_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
628 int should_write
, struct mem_attrib
*attrib
,
629 struct target_ops
*target
)
635 rslt
= angel_RDI_write (myaddr
, memaddr
, &len
);
636 if (rslt
!= RDIError_NoError
)
638 printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt
));
643 rslt
= angel_RDI_read (memaddr
, myaddr
, &len
);
644 if (rslt
!= RDIError_NoError
)
646 printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt
));
653 /* Display random info collected from the target. */
656 arm_rdi_files_info (struct target_ops
*ignore
)
658 char *file
= "nothing";
660 unsigned long arg1
, arg2
;
662 rslt
= angel_RDI_info (RDIInfo_Target
, &arg1
, &arg2
);
663 if (rslt
!= RDIError_NoError
)
665 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
667 if (arg1
& (1 << 15))
668 printf_filtered ("Target supports Thumb code.\n");
669 if (arg1
& (1 << 14))
670 printf_filtered ("Target can do profiling.\n");
672 printf_filtered ("Target is real hardware.\n");
674 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
675 if (rslt
!= RDIError_NoError
)
677 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
679 printf_filtered ("Target can%s single-step.\n", (arg1
& 0x4 ? "" : "not"));
681 rslt
= angel_RDI_info (RDIInfo_Icebreaker
, &arg1
, &arg2
);
682 if (rslt
!= RDIError_NoError
)
684 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
687 printf_filtered ("Target includes an EmbeddedICE.\n");
695 rslt
= angel_RDI_open (1, &gdb_config
, NULL
, NULL
);
696 if (rslt
!= RDIError_NoError
)
698 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
703 arm_rdi_mourn_inferior (void)
705 /* We remove the inserted breakpoints in case the user wants to
706 issue another target and load commands to rerun his application;
707 This is something that wouldn't work on a native target, for instance,
708 as the process goes away when the inferior exits, but it works with
709 some remote targets like this one. That is why this is done here. */
710 remove_breakpoints();
711 unpush_target (&arm_rdi_ops
);
712 generic_mourn_inferior ();
715 /* While the RDI library keeps track of its own breakpoints, we need
716 to remember "handles" so that we can delete them later. Since
717 breakpoints get used for stepping, be careful not to leak memory
721 arm_rdi_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
725 struct local_bp_list_entry
*entry
;
726 int type
= RDIPoint_EQ
;
728 if (arm_pc_is_thumb (addr
) || arm_pc_is_thumb_dummy (addr
))
729 type
|= RDIPoint_16Bit
;
730 rslt
= angel_RDI_setbreak (addr
, type
, 0, &point
);
731 if (rslt
!= RDIError_NoError
)
733 printf_filtered ("RDI_setbreak: %s\n", rdi_error_message (rslt
));
736 (struct local_bp_list_entry
*) xmalloc (sizeof (struct local_bp_list_entry
));
738 entry
->point
= point
;
739 entry
->next
= local_bp_list
;
740 local_bp_list
= entry
;
745 arm_rdi_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
749 struct local_bp_list_entry
**entryp
, *dead
;
751 for (entryp
= &local_bp_list
; *entryp
!= NULL
; entryp
= &(*entryp
)->next
)
752 if ((*entryp
)->addr
== addr
)
758 rslt
= angel_RDI_clearbreak (dead
->point
);
759 if (rslt
!= RDIError_NoError
)
760 printf_filtered ("RDI_clearbreak: %s\n", rdi_error_message (rslt
));
762 /* Delete the breakpoint entry locally. */
763 *entryp
= dead
->next
;
772 rdi_error_message (int err
)
776 case RDIError_NoError
:
779 return "debuggee reset";
780 case RDIError_UndefinedInstruction
:
781 return "undefined instruction";
782 case RDIError_SoftwareInterrupt
:
783 return "SWI trapped";
784 case RDIError_PrefetchAbort
:
785 return "prefetch abort, execution ran into unmapped memory?";
786 case RDIError_DataAbort
:
787 return "data abort, no memory at specified address?";
788 case RDIError_AddressException
:
789 return "address exception, access >26bit in 26bit mode";
791 return "IRQ, interrupt trapped";
793 return "FIQ, fast interrupt trapped";
795 return "a miscellaneous type of error";
796 case RDIError_BranchThrough0
:
797 return "branch through location 0";
798 case RDIError_NotInitialised
:
799 return "internal error, RDI_open not called first";
800 case RDIError_UnableToInitialise
:
801 return "internal error, target world is broken";
802 case RDIError_WrongByteSex
:
803 return "See Operator: WrongByteSex";
804 case RDIError_UnableToTerminate
:
805 return "See Operator: Unable to Terminate";
806 case RDIError_BadInstruction
:
807 return "bad instruction, illegal to execute this instruction";
808 case RDIError_IllegalInstruction
:
809 return "illegal instruction, the effect of executing it is undefined";
810 case RDIError_BadCPUStateSetting
:
811 return "internal error, tried to set SPSR of user mode";
812 case RDIError_UnknownCoPro
:
813 return "unknown co-processor";
814 case RDIError_UnknownCoProState
:
815 return "cannot execute co-processor request";
816 case RDIError_BadCoProState
:
817 return "recognizably broken co-processor request";
818 case RDIError_BadPointType
:
819 return "internal error, bad point yype";
820 case RDIError_UnimplementedType
:
821 return "internal error, unimplemented type";
822 case RDIError_BadPointSize
:
823 return "internal error, bad point size";
824 case RDIError_UnimplementedSize
:
825 return "internal error, unimplemented size";
826 case RDIError_NoMorePoints
:
827 return "last break/watch point was used";
828 case RDIError_BreakpointReached
:
829 return "breakpoint reached";
830 case RDIError_WatchpointAccessed
:
831 return "watchpoint accessed";
832 case RDIError_NoSuchPoint
:
833 return "attempted to clear non-existent break/watch point";
834 case RDIError_ProgramFinishedInStep
:
835 return "end of the program reached while stepping";
836 case RDIError_UserInterrupt
:
837 return "you pressed Escape";
838 case RDIError_CantSetPoint
:
839 return "no more break/watch points available";
840 case RDIError_IncompatibleRDILevels
:
841 return "incompatible RDI levels";
842 case RDIError_LittleEndian
:
843 return "debuggee is little endian";
844 case RDIError_BigEndian
:
845 return "debuggee is big endian";
846 case RDIError_SoftInitialiseError
:
847 return "recoverable error in RDI initialization";
848 case RDIError_InsufficientPrivilege
:
849 return "internal error, supervisor state not accessible to monitor";
850 case RDIError_UnimplementedMessage
:
851 return "internal error, unimplemented message";
852 case RDIError_UndefinedMessage
:
853 return "internal error, undefined message";
855 return "undefined error message, should reset target";
859 /* Convert the ARM error messages to signals that GDB knows about. */
861 static enum target_signal
862 rdi_error_signal (int err
)
866 case RDIError_NoError
:
869 return TARGET_SIGNAL_TERM
; /* ??? */
870 case RDIError_UndefinedInstruction
:
871 return TARGET_SIGNAL_ILL
;
872 case RDIError_SoftwareInterrupt
:
873 case RDIError_PrefetchAbort
:
874 case RDIError_DataAbort
:
875 return TARGET_SIGNAL_TRAP
;
876 case RDIError_AddressException
:
877 return TARGET_SIGNAL_SEGV
;
880 return TARGET_SIGNAL_TRAP
;
882 return TARGET_SIGNAL_TERM
;
883 case RDIError_BranchThrough0
:
884 return TARGET_SIGNAL_TRAP
;
885 case RDIError_NotInitialised
:
886 case RDIError_UnableToInitialise
:
887 case RDIError_WrongByteSex
:
888 case RDIError_UnableToTerminate
:
889 return TARGET_SIGNAL_UNKNOWN
;
890 case RDIError_BadInstruction
:
891 case RDIError_IllegalInstruction
:
892 return TARGET_SIGNAL_ILL
;
893 case RDIError_BadCPUStateSetting
:
894 case RDIError_UnknownCoPro
:
895 case RDIError_UnknownCoProState
:
896 case RDIError_BadCoProState
:
897 case RDIError_BadPointType
:
898 case RDIError_UnimplementedType
:
899 case RDIError_BadPointSize
:
900 case RDIError_UnimplementedSize
:
901 case RDIError_NoMorePoints
:
902 return TARGET_SIGNAL_UNKNOWN
;
903 case RDIError_BreakpointReached
:
904 case RDIError_WatchpointAccessed
:
905 return TARGET_SIGNAL_TRAP
;
906 case RDIError_NoSuchPoint
:
907 case RDIError_ProgramFinishedInStep
:
908 return TARGET_SIGNAL_UNKNOWN
;
909 case RDIError_UserInterrupt
:
910 return TARGET_SIGNAL_INT
;
911 case RDIError_IncompatibleRDILevels
:
912 case RDIError_LittleEndian
:
913 case RDIError_BigEndian
:
914 case RDIError_SoftInitialiseError
:
915 case RDIError_InsufficientPrivilege
:
916 case RDIError_UnimplementedMessage
:
917 case RDIError_UndefinedMessage
:
919 return TARGET_SIGNAL_UNKNOWN
;
926 angel_RDI_stop_request();
930 /* Define the target operations structure. */
935 arm_rdi_ops
.to_shortname
= "rdi";
936 arm_rdi_ops
.to_longname
= "ARM RDI";
937 arm_rdi_ops
.to_doc
= "Use a remote ARM-based computer; via the RDI library.\n\
938 Specify the serial device it is connected to (e.g. /dev/ttya).";
939 arm_rdi_ops
.to_open
= arm_rdi_open
;
940 arm_rdi_ops
.to_close
= arm_rdi_close
;
941 arm_rdi_ops
.to_detach
= arm_rdi_detach
;
942 arm_rdi_ops
.to_resume
= arm_rdi_resume
;
943 arm_rdi_ops
.to_wait
= arm_rdi_wait
;
944 arm_rdi_ops
.to_stop
= arm_rdi_stop
;
945 arm_rdi_ops
.to_fetch_registers
= arm_rdi_fetch_registers
;
946 arm_rdi_ops
.to_store_registers
= arm_rdi_store_registers
;
947 arm_rdi_ops
.to_prepare_to_store
= arm_rdi_prepare_to_store
;
948 arm_rdi_ops
.to_xfer_memory
= arm_rdi_xfer_memory
;
949 arm_rdi_ops
.to_files_info
= arm_rdi_files_info
;
950 arm_rdi_ops
.to_insert_breakpoint
= arm_rdi_insert_breakpoint
;
951 arm_rdi_ops
.to_remove_breakpoint
= arm_rdi_remove_breakpoint
;
952 arm_rdi_ops
.to_kill
= arm_rdi_kill
;
953 arm_rdi_ops
.to_load
= generic_load
;
954 arm_rdi_ops
.to_create_inferior
= arm_rdi_create_inferior
;
955 arm_rdi_ops
.to_mourn_inferior
= arm_rdi_mourn_inferior
;
956 arm_rdi_ops
.to_stratum
= process_stratum
;
957 arm_rdi_ops
.to_has_all_memory
= 1;
958 arm_rdi_ops
.to_has_memory
= 1;
959 arm_rdi_ops
.to_has_stack
= 1;
960 arm_rdi_ops
.to_has_registers
= 1;
961 arm_rdi_ops
.to_has_execution
= 1;
962 arm_rdi_ops
.to_magic
= OPS_MAGIC
;
966 rdilogfile_command (char *arg
, int from_tty
)
968 if (!arg
|| strlen (arg
) == 0)
970 printf_filtered ("rdi log file is '%s'\n", log_filename
);
975 xfree (log_filename
);
977 log_filename
= xstrdup (arg
);
979 Adp_SetLogfile (log_filename
);
983 rdilogenable_command (char *args
, int from_tty
)
985 if (!args
|| strlen (args
) == 0)
987 printf_filtered ("rdi log is %s\n", log_enable
? "enabled" : "disabled");
991 if (!strcasecmp (args
, "1") ||
992 !strcasecmp (args
, "y") ||
993 !strcasecmp (args
, "yes") ||
994 !strcasecmp (args
, "on") ||
995 !strcasecmp (args
, "t") ||
996 !strcasecmp (args
, "true"))
997 Adp_SetLogEnable (log_enable
= 1);
998 else if (!strcasecmp (args
, "0") ||
999 !strcasecmp (args
, "n") ||
1000 !strcasecmp (args
, "no") ||
1001 !strcasecmp (args
, "off") ||
1002 !strcasecmp (args
, "f") ||
1003 !strcasecmp (args
, "false"))
1004 Adp_SetLogEnable (log_enable
= 0);
1006 printf_filtered ("rdilogenable: unrecognized argument '%s'\n"
1007 " try y or n\n", args
);
1010 extern initialize_file_ftype _initialize_remote_rdi
; /* -Wmissing-prototypes */
1013 _initialize_remote_rdi (void)
1015 struct cmd_list_element
*c
;
1018 add_target (&arm_rdi_ops
);
1020 log_filename
= xstrdup ("rdi.log");
1021 Adp_SetLogfile (log_filename
);
1022 Adp_SetLogEnable (log_enable
);
1024 c
= add_cmd ("rdilogfile", class_maintenance
,
1026 "Set filename for ADP packet log.\n"
1027 "This file is used to log Angel Debugger Protocol packets.\n"
1028 "With a single argument, sets the logfile name to that value.\n"
1029 "Without an argument, shows the current logfile name.\n"
1030 "See also: rdilogenable\n",
1032 set_cmd_completer (c
, filename_completer
);
1034 add_cmd ("rdilogenable", class_maintenance
,
1035 rdilogenable_command
,
1036 "Set enable logging of ADP packets.\n"
1037 "This will log ADP packets exchanged between gdb and the\n"
1038 "rdi target device.\n"
1039 "An argument of 1, t, true, y or yes will enable.\n"
1040 "An argument of 0, f, false, n or no will disabled.\n"
1041 "Withough an argument, it will display current state.\n",
1044 add_setshow_boolean_cmd
1045 ("rdiromatzero", no_class
, &rom_at_zero
,
1046 "Set target has ROM at addr 0.\n"
1047 "A true value disables vector catching, false enables vector catching.\n"
1048 "This is evaluated at the time the 'target rdi' command is executed\n",
1049 "Show if target has ROM at addr 0.\n",
1051 &setlist
, &showlist
);
1053 add_setshow_boolean_cmd
1054 ("rdiheartbeat", no_class
, &rdi_heartbeat
,
1055 "Set enable for ADP heartbeat packets.\n"
1056 "I don't know why you would want this. If you enable them,\n"
1057 "it will confuse ARM and EPI JTAG interface boxes as well\n"
1058 "as the Angel Monitor.\n",
1059 "Show enable for ADP heartbeat packets.\n",
1061 &setlist
, &showlist
);
1064 /* A little dummy to make linking with the library succeed. */
1067 Fail (const char *ignored
, ...)