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 ptid_t
arm_rdi_wait (ptid_t ptid
, struct target_waitstatus
*status
);
81 static void arm_rdi_kill (void);
83 static void arm_rdi_detach (char *args
, int from_tty
);
85 static void arm_rdi_interrupt (int signo
);
87 static void arm_rdi_interrupt_twice (int signo
);
89 static void interrupt_query (void);
91 static int arm_rdi_insert_breakpoint (CORE_ADDR
, char *);
93 static int arm_rdi_remove_breakpoint (CORE_ADDR
, char *);
95 static char *rdi_error_message (int err
);
97 static enum target_signal
rdi_error_signal (int err
);
99 /* Global variables. */
101 struct target_ops arm_rdi_ops
;
103 static struct Dbg_ConfigBlock gdb_config
;
105 static struct Dbg_HostosInterface gdb_hostif
;
107 static int max_load_size
;
109 static int execute_status
;
111 /* Send heatbeat packets? */
112 static int rdi_heartbeat
= 0;
114 /* Target has ROM at address 0. */
115 static int rom_at_zero
= 0;
117 /* Enable logging? */
118 static int log_enable
= 0;
120 /* Name of the log file. Default is "rdi.log". */
121 static char *log_filename
;
123 /* A little list of breakpoints that have been set. */
125 static struct local_bp_list_entry
129 struct local_bp_list_entry
*next
;
134 /* Stub for catch_errors. */
137 arm_rdi_start_remote (char *dummy
)
142 /* Helper callbacks for the "host interface" structure. RDI functions call
143 these to forward output from the target system and so forth. */
146 voiddummy (void *dummy
)
148 fprintf_unfiltered (gdb_stdout
, "void dummy\n");
152 myprint (void *arg
, const char *format
, va_list ap
)
154 vfprintf_unfiltered (gdb_stdout
, format
, ap
);
158 mywritec (void *arg
, int c
)
161 fputc_unfiltered (c
, gdb_stdout
);
165 mywrite (void *arg
, char const *buffer
, int len
)
171 for (i
= 0; i
< len
; i
++)
173 if (isascii ((int) *e
))
175 fputc_unfiltered ((int) *e
, gdb_stdout
);
188 /* These last two are tricky as we have to handle the special case of
189 being interrupted more carefully */
194 return fgetc (stdin
);
198 mygets (void *arg
, char *buffer
, int len
)
200 return fgets (buffer
, len
, stdin
);
203 /* Prevent multiple calls to angel_RDI_close(). */
204 static int closed_already
= 1;
206 /* Open a connection to a remote debugger. NAME is the filename used
207 for communication. */
210 arm_rdi_open (char *name
, int from_tty
)
213 unsigned long arg1
, arg2
;
214 char *openArgs
= NULL
;
215 char *devName
= NULL
;
219 error ("To open an RDI connection, you need to specify what serial\n\
220 device is attached to the remote system (e.g. /dev/ttya).");
222 /* split name after whitespace, pass tail as arg to open command */
224 devName
= xstrdup (name
);
225 p
= strchr (devName
, ' ');
237 /* Make the basic low-level connection. */
240 rslt
= Adp_OpenDevice (devName
, openArgs
, rdi_heartbeat
);
243 error ("Could not open device \"%s\"", name
);
245 gdb_config
.bytesex
= 2 | (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? 1 : 0);
247 gdb_config
.rditype
= 2;
248 gdb_config
.heartbeat_on
= 1;
249 gdb_config
.flags
= 2;
251 gdb_hostif
.dbgprint
= myprint
;
252 gdb_hostif
.dbgpause
= mypause
;
253 gdb_hostif
.dbgarg
= NULL
;
254 gdb_hostif
.writec
= mywritec
;
255 gdb_hostif
.readc
= myreadc
;
256 gdb_hostif
.write
= mywrite
;
257 gdb_hostif
.gets
= mygets
;
258 gdb_hostif
.hostosarg
= NULL
;
259 gdb_hostif
.reset
= voiddummy
;
261 rslt
= angel_RDI_open (10, &gdb_config
, &gdb_hostif
, NULL
);
262 if (rslt
== RDIError_BigEndian
|| rslt
== RDIError_LittleEndian
)
263 ; /* do nothing, this is the expected return */
264 else if (rslt
!= RDIError_NoError
)
266 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
268 error ("RDI_open failed\n");
271 rslt
= angel_RDI_info (RDIInfo_Target
, &arg1
, &arg2
);
272 if (rslt
!= RDIError_NoError
)
274 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
276 rslt
= angel_RDI_info (RDIInfo_Points
, &arg1
, &arg2
);
277 if (rslt
!= RDIError_NoError
)
279 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
281 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
282 if (rslt
!= RDIError_NoError
)
284 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
286 rslt
= angel_RDI_info (RDIInfo_CoPro
, &arg1
, &arg2
);
287 if (rslt
!= RDIError_NoError
)
289 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
291 rslt
= angel_RDI_info (RDIInfo_SemiHosting
, &arg1
, &arg2
);
292 if (rslt
!= RDIError_NoError
)
294 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
297 rslt
= angel_RDI_info (RDIInfo_GetLoadSize
, &arg1
, &arg2
);
298 if (rslt
!= RDIError_NoError
)
300 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
302 max_load_size
= arg1
;
304 push_target (&arm_rdi_ops
);
306 target_fetch_registers (-1);
308 rslt
= angel_RDI_open (1, &gdb_config
, NULL
, NULL
);
309 if (rslt
!= RDIError_NoError
)
311 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
314 arg1
= rom_at_zero
? 0x0 : 0x13b;
316 rslt
= angel_RDI_info (RDIVector_Catch
, &arg1
, &arg2
);
317 if (rslt
!= RDIError_NoError
)
319 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
322 arg1
= (unsigned long) "";
323 rslt
= angel_RDI_info (RDISet_Cmdline
, &arg1
, &arg2
);
324 if (rslt
!= RDIError_NoError
)
326 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
329 /* Clear out any existing records of breakpoints. */
331 struct local_bp_list_entry
*entry
, *preventry
= NULL
;
333 for (entry
= local_bp_list
; entry
!= NULL
; entry
= entry
->next
)
340 printf_filtered ("Connected to ARM RDI target.\n");
342 inferior_ptid
= pid_to_ptid (42);
345 /* Start an inferior process and set inferior_ptid to its pid.
346 EXEC_FILE is the file to run.
347 ARGS is a string containing the arguments to the program.
348 ENV is the environment vector to pass. Errors reported with error().
349 On VxWorks and various standalone systems, we ignore exec_file. */
350 /* This is called not only when we first attach, but also when the
351 user types "run" after having attached. */
354 arm_rdi_create_inferior (char *exec_file
, char *args
, char **env
)
357 unsigned long arg1
, arg2
;
359 CORE_ADDR entry_point
;
361 if (exec_file
== 0 || exec_bfd
== 0)
362 error ("No executable file specified.");
364 entry_point
= (CORE_ADDR
) bfd_get_start_address (exec_bfd
);
367 remove_breakpoints ();
368 init_wait_for_inferior ();
370 len
= strlen (exec_file
) + 1 + strlen (args
) + 1 + /*slop */ 10;
371 arg_buf
= (char *) alloca (len
);
373 strcat (arg_buf
, exec_file
);
374 strcat (arg_buf
, " ");
375 strcat (arg_buf
, args
);
377 inferior_ptid
= pid_to_ptid (42);
378 insert_breakpoints (); /* Needed to get correct instruction in cache */
384 if (strncmp (*env
, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
386 unsigned long top_of_memory
;
389 /* Set up memory limit */
390 top_of_memory
= strtoul (*env
+ sizeof ("MEMSIZE=") - 1,
392 printf_filtered ("Setting top-of-memory to 0x%lx\n",
395 rslt
= angel_RDI_info (RDIInfo_SetTopMem
, &top_of_memory
, &arg2
);
396 if (rslt
!= RDIError_NoError
)
398 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
405 arg1
= (unsigned long) arg_buf
;
406 rslt
= angel_RDI_info (RDISet_Cmdline
, /* &arg1 */ (unsigned long *) arg_buf
, &arg2
);
407 if (rslt
!= RDIError_NoError
)
409 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
412 proceed (entry_point
, TARGET_SIGNAL_DEFAULT
, 0);
415 /* This takes a program previously attached to and detaches it. After
416 this is done, GDB can be used to debug some other program. We
417 better not have left any breakpoints in the target program or it'll
418 die when it hits one. */
421 arm_rdi_detach (char *args
, int from_tty
)
426 /* Clean up connection to a remote debugger. */
429 arm_rdi_close (int quitting
)
435 rslt
= angel_RDI_close ();
436 if (rslt
!= RDIError_NoError
)
438 printf_filtered ("RDI_close: %s\n", rdi_error_message (rslt
));
441 inferior_ptid
= null_ptid
;
443 generic_mourn_inferior ();
447 /* Tell the remote machine to resume. */
450 arm_rdi_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
455 if (0 /* turn on when hardware supports single-stepping */ )
457 rslt
= angel_RDI_step (1, &point
);
458 if (rslt
!= RDIError_NoError
)
459 printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt
));
468 pc
= read_register (ARM_PC_REGNUM
);
469 pc
= arm_get_next_pc (pc
);
470 arm_rdi_insert_breakpoint (pc
, handle
);
473 execute_status
= rslt
= angel_RDI_execute (&point
);
474 if (rslt
!= RDIError_NoError
&& rslt
!= RDIError_BreakpointReached
)
475 printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt
));
478 arm_rdi_remove_breakpoint (pc
, handle
);
482 /* Send ^C to target to halt it. Target will respond, and send us a
486 arm_rdi_interrupt (int signo
)
490 static void (*ofunc
) ();
492 /* The user typed ^C twice. */
494 arm_rdi_interrupt_twice (int signo
)
498 /* Ask the user what to do when an interrupt is received. */
501 interrupt_query (void)
505 /* Wait until the remote machine stops, then return, storing status in
506 STATUS just as `wait' would. Returns "pid" (though it's not clear
507 what, if anything, that means in the case of this target). */
510 arm_rdi_wait (ptid_t ptid
, struct target_waitstatus
*status
)
512 status
->kind
= (execute_status
== RDIError_NoError
?
513 TARGET_WAITKIND_EXITED
: TARGET_WAITKIND_STOPPED
);
515 /* convert stopped code from target into right signal */
516 status
->value
.sig
= rdi_error_signal (execute_status
);
518 return inferior_ptid
;
521 /* Read the remote registers into the block REGS. */
524 arm_rdi_fetch_registers (int regno
)
526 int rslt
, rdi_regmask
;
527 unsigned long rawreg
, rawregs
[32];
532 rslt
= angel_RDI_CPUread (255, 0x27fff, rawregs
);
533 if (rslt
!= RDIError_NoError
)
535 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
538 for (regno
= 0; regno
< 15; regno
++)
540 store_unsigned_integer (cookedreg
, 4, rawregs
[regno
]);
541 supply_register (regno
, (char *) cookedreg
);
543 store_unsigned_integer (cookedreg
, 4, rawregs
[15]);
544 supply_register (ARM_PS_REGNUM
, (char *) cookedreg
);
545 arm_rdi_fetch_registers (ARM_PC_REGNUM
);
549 if (regno
== ARM_PC_REGNUM
)
550 rdi_regmask
= RDIReg_PC
;
551 else if (regno
== ARM_PS_REGNUM
)
552 rdi_regmask
= RDIReg_CPSR
;
553 else if (regno
< 0 || regno
> 15)
556 supply_register (regno
, (char *) &rawreg
);
560 rdi_regmask
= 1 << regno
;
562 rslt
= angel_RDI_CPUread (255, rdi_regmask
, &rawreg
);
563 if (rslt
!= RDIError_NoError
)
565 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
567 store_unsigned_integer (cookedreg
, 4, rawreg
);
568 supply_register (regno
, (char *) cookedreg
);
573 arm_rdi_prepare_to_store (void)
578 /* Store register REGNO, or all registers if REGNO == -1, from the contents
579 of REGISTERS. FIXME: ignores errors. */
582 arm_rdi_store_registers (int regno
)
584 int rslt
, rdi_regmask
;
586 /* These need to be able to take 'floating point register' contents */
587 unsigned long rawreg
[3], rawerreg
[3];
591 for (regno
= 0; regno
< NUM_REGS
; regno
++)
592 arm_rdi_store_registers (regno
);
596 deprecated_read_register_gen (regno
, (char *) rawreg
);
597 /* RDI manipulates data in host byte order, so convert now. */
598 store_unsigned_integer (rawerreg
, 4, rawreg
[0]);
600 if (regno
== ARM_PC_REGNUM
)
601 rdi_regmask
= RDIReg_PC
;
602 else if (regno
== ARM_PS_REGNUM
)
603 rdi_regmask
= RDIReg_CPSR
;
604 else if (regno
< 0 || regno
> 15)
607 rdi_regmask
= 1 << regno
;
609 rslt
= angel_RDI_CPUwrite (255, rdi_regmask
, rawerreg
);
610 if (rslt
!= RDIError_NoError
)
612 printf_filtered ("RDI_CPUwrite: %s\n", rdi_error_message (rslt
));
617 /* Read or write LEN bytes from inferior memory at MEMADDR,
618 transferring to or from debugger address MYADDR. Write to inferior
619 if SHOULD_WRITE is nonzero. Returns length of data written or
620 read; 0 for error. TARGET is unused. */
623 arm_rdi_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
624 int should_write
, struct mem_attrib
*attrib
,
625 struct target_ops
*target
)
631 rslt
= angel_RDI_write (myaddr
, memaddr
, &len
);
632 if (rslt
!= RDIError_NoError
)
634 printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt
));
639 rslt
= angel_RDI_read (memaddr
, myaddr
, &len
);
640 if (rslt
!= RDIError_NoError
)
642 printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt
));
649 /* Display random info collected from the target. */
652 arm_rdi_files_info (struct target_ops
*ignore
)
654 char *file
= "nothing";
656 unsigned long arg1
, arg2
;
658 rslt
= angel_RDI_info (RDIInfo_Target
, &arg1
, &arg2
);
659 if (rslt
!= RDIError_NoError
)
661 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
663 if (arg1
& (1 << 15))
664 printf_filtered ("Target supports Thumb code.\n");
665 if (arg1
& (1 << 14))
666 printf_filtered ("Target can do profiling.\n");
668 printf_filtered ("Target is real hardware.\n");
670 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
671 if (rslt
!= RDIError_NoError
)
673 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
675 printf_filtered ("Target can%s single-step.\n", (arg1
& 0x4 ? "" : "not"));
677 rslt
= angel_RDI_info (RDIInfo_Icebreaker
, &arg1
, &arg2
);
678 if (rslt
!= RDIError_NoError
)
680 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
683 printf_filtered ("Target includes an EmbeddedICE.\n");
691 rslt
= angel_RDI_open (1, &gdb_config
, NULL
, NULL
);
692 if (rslt
!= RDIError_NoError
)
694 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
699 arm_rdi_mourn_inferior (void)
701 /* We remove the inserted breakpoints in case the user wants to
702 issue another target and load commands to rerun his application;
703 This is something that wouldn't work on a native target, for instance,
704 as the process goes away when the inferior exits, but it works with
705 some remote targets like this one. That is why this is done here. */
706 remove_breakpoints();
707 unpush_target (&arm_rdi_ops
);
708 generic_mourn_inferior ();
711 /* While the RDI library keeps track of its own breakpoints, we need
712 to remember "handles" so that we can delete them later. Since
713 breakpoints get used for stepping, be careful not to leak memory
717 arm_rdi_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
721 struct local_bp_list_entry
*entry
;
722 int type
= RDIPoint_EQ
;
724 if (arm_pc_is_thumb (addr
) || arm_pc_is_thumb_dummy (addr
))
725 type
|= RDIPoint_16Bit
;
726 rslt
= angel_RDI_setbreak (addr
, type
, 0, &point
);
727 if (rslt
!= RDIError_NoError
)
729 printf_filtered ("RDI_setbreak: %s\n", rdi_error_message (rslt
));
732 (struct local_bp_list_entry
*) xmalloc (sizeof (struct local_bp_list_entry
));
734 entry
->point
= point
;
735 entry
->next
= local_bp_list
;
736 local_bp_list
= entry
;
741 arm_rdi_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
745 struct local_bp_list_entry
**entryp
, *dead
;
747 for (entryp
= &local_bp_list
; *entryp
!= NULL
; entryp
= &(*entryp
)->next
)
748 if ((*entryp
)->addr
== addr
)
754 rslt
= angel_RDI_clearbreak (dead
->point
);
755 if (rslt
!= RDIError_NoError
)
756 printf_filtered ("RDI_clearbreak: %s\n", rdi_error_message (rslt
));
758 /* Delete the breakpoint entry locally. */
759 *entryp
= dead
->next
;
768 rdi_error_message (int err
)
772 case RDIError_NoError
:
775 return "debuggee reset";
776 case RDIError_UndefinedInstruction
:
777 return "undefined instruction";
778 case RDIError_SoftwareInterrupt
:
779 return "SWI trapped";
780 case RDIError_PrefetchAbort
:
781 return "prefetch abort, execution ran into unmapped memory?";
782 case RDIError_DataAbort
:
783 return "data abort, no memory at specified address?";
784 case RDIError_AddressException
:
785 return "address exception, access >26bit in 26bit mode";
787 return "IRQ, interrupt trapped";
789 return "FIQ, fast interrupt trapped";
791 return "a miscellaneous type of error";
792 case RDIError_BranchThrough0
:
793 return "branch through location 0";
794 case RDIError_NotInitialised
:
795 return "internal error, RDI_open not called first";
796 case RDIError_UnableToInitialise
:
797 return "internal error, target world is broken";
798 case RDIError_WrongByteSex
:
799 return "See Operator: WrongByteSex";
800 case RDIError_UnableToTerminate
:
801 return "See Operator: Unable to Terminate";
802 case RDIError_BadInstruction
:
803 return "bad instruction, illegal to execute this instruction";
804 case RDIError_IllegalInstruction
:
805 return "illegal instruction, the effect of executing it is undefined";
806 case RDIError_BadCPUStateSetting
:
807 return "internal error, tried to set SPSR of user mode";
808 case RDIError_UnknownCoPro
:
809 return "unknown co-processor";
810 case RDIError_UnknownCoProState
:
811 return "cannot execute co-processor request";
812 case RDIError_BadCoProState
:
813 return "recognizably broken co-processor request";
814 case RDIError_BadPointType
:
815 return "internal error, bad point yype";
816 case RDIError_UnimplementedType
:
817 return "internal error, unimplemented type";
818 case RDIError_BadPointSize
:
819 return "internal error, bad point size";
820 case RDIError_UnimplementedSize
:
821 return "internal error, unimplemented size";
822 case RDIError_NoMorePoints
:
823 return "last break/watch point was used";
824 case RDIError_BreakpointReached
:
825 return "breakpoint reached";
826 case RDIError_WatchpointAccessed
:
827 return "watchpoint accessed";
828 case RDIError_NoSuchPoint
:
829 return "attempted to clear non-existent break/watch point";
830 case RDIError_ProgramFinishedInStep
:
831 return "end of the program reached while stepping";
832 case RDIError_UserInterrupt
:
833 return "you pressed Escape";
834 case RDIError_CantSetPoint
:
835 return "no more break/watch points available";
836 case RDIError_IncompatibleRDILevels
:
837 return "incompatible RDI levels";
838 case RDIError_LittleEndian
:
839 return "debuggee is little endian";
840 case RDIError_BigEndian
:
841 return "debuggee is big endian";
842 case RDIError_SoftInitialiseError
:
843 return "recoverable error in RDI initialization";
844 case RDIError_InsufficientPrivilege
:
845 return "internal error, supervisor state not accessible to monitor";
846 case RDIError_UnimplementedMessage
:
847 return "internal error, unimplemented message";
848 case RDIError_UndefinedMessage
:
849 return "internal error, undefined message";
851 return "undefined error message, should reset target";
855 /* Convert the ARM error messages to signals that GDB knows about. */
857 static enum target_signal
858 rdi_error_signal (int err
)
862 case RDIError_NoError
:
865 return TARGET_SIGNAL_TERM
; /* ??? */
866 case RDIError_UndefinedInstruction
:
867 return TARGET_SIGNAL_ILL
;
868 case RDIError_SoftwareInterrupt
:
869 case RDIError_PrefetchAbort
:
870 case RDIError_DataAbort
:
871 return TARGET_SIGNAL_TRAP
;
872 case RDIError_AddressException
:
873 return TARGET_SIGNAL_SEGV
;
876 return TARGET_SIGNAL_TRAP
;
878 return TARGET_SIGNAL_TERM
;
879 case RDIError_BranchThrough0
:
880 return TARGET_SIGNAL_TRAP
;
881 case RDIError_NotInitialised
:
882 case RDIError_UnableToInitialise
:
883 case RDIError_WrongByteSex
:
884 case RDIError_UnableToTerminate
:
885 return TARGET_SIGNAL_UNKNOWN
;
886 case RDIError_BadInstruction
:
887 case RDIError_IllegalInstruction
:
888 return TARGET_SIGNAL_ILL
;
889 case RDIError_BadCPUStateSetting
:
890 case RDIError_UnknownCoPro
:
891 case RDIError_UnknownCoProState
:
892 case RDIError_BadCoProState
:
893 case RDIError_BadPointType
:
894 case RDIError_UnimplementedType
:
895 case RDIError_BadPointSize
:
896 case RDIError_UnimplementedSize
:
897 case RDIError_NoMorePoints
:
898 return TARGET_SIGNAL_UNKNOWN
;
899 case RDIError_BreakpointReached
:
900 case RDIError_WatchpointAccessed
:
901 return TARGET_SIGNAL_TRAP
;
902 case RDIError_NoSuchPoint
:
903 case RDIError_ProgramFinishedInStep
:
904 return TARGET_SIGNAL_UNKNOWN
;
905 case RDIError_UserInterrupt
:
906 return TARGET_SIGNAL_INT
;
907 case RDIError_IncompatibleRDILevels
:
908 case RDIError_LittleEndian
:
909 case RDIError_BigEndian
:
910 case RDIError_SoftInitialiseError
:
911 case RDIError_InsufficientPrivilege
:
912 case RDIError_UnimplementedMessage
:
913 case RDIError_UndefinedMessage
:
915 return TARGET_SIGNAL_UNKNOWN
;
922 angel_RDI_stop_request();
926 /* Define the target operations structure. */
931 arm_rdi_ops
.to_shortname
= "rdi";
932 arm_rdi_ops
.to_longname
= "ARM RDI";
933 arm_rdi_ops
.to_doc
= "Use a remote ARM-based computer; via the RDI library.\n\
934 Specify the serial device it is connected to (e.g. /dev/ttya).";
935 arm_rdi_ops
.to_open
= arm_rdi_open
;
936 arm_rdi_ops
.to_close
= arm_rdi_close
;
937 arm_rdi_ops
.to_detach
= arm_rdi_detach
;
938 arm_rdi_ops
.to_resume
= arm_rdi_resume
;
939 arm_rdi_ops
.to_wait
= arm_rdi_wait
;
940 arm_rdi_ops
.to_stop
= arm_rdi_stop
;
941 arm_rdi_ops
.to_fetch_registers
= arm_rdi_fetch_registers
;
942 arm_rdi_ops
.to_store_registers
= arm_rdi_store_registers
;
943 arm_rdi_ops
.to_prepare_to_store
= arm_rdi_prepare_to_store
;
944 arm_rdi_ops
.to_xfer_memory
= arm_rdi_xfer_memory
;
945 arm_rdi_ops
.to_files_info
= arm_rdi_files_info
;
946 arm_rdi_ops
.to_insert_breakpoint
= arm_rdi_insert_breakpoint
;
947 arm_rdi_ops
.to_remove_breakpoint
= arm_rdi_remove_breakpoint
;
948 arm_rdi_ops
.to_kill
= arm_rdi_kill
;
949 arm_rdi_ops
.to_load
= generic_load
;
950 arm_rdi_ops
.to_create_inferior
= arm_rdi_create_inferior
;
951 arm_rdi_ops
.to_mourn_inferior
= arm_rdi_mourn_inferior
;
952 arm_rdi_ops
.to_stratum
= process_stratum
;
953 arm_rdi_ops
.to_has_all_memory
= 1;
954 arm_rdi_ops
.to_has_memory
= 1;
955 arm_rdi_ops
.to_has_stack
= 1;
956 arm_rdi_ops
.to_has_registers
= 1;
957 arm_rdi_ops
.to_has_execution
= 1;
958 arm_rdi_ops
.to_magic
= OPS_MAGIC
;
962 rdilogfile_command (char *arg
, int from_tty
)
964 if (!arg
|| strlen (arg
) == 0)
966 printf_filtered ("rdi log file is '%s'\n", log_filename
);
971 xfree (log_filename
);
973 log_filename
= xstrdup (arg
);
975 Adp_SetLogfile (log_filename
);
979 rdilogenable_command (char *args
, int from_tty
)
981 if (!args
|| strlen (args
) == 0)
983 printf_filtered ("rdi log is %s\n", log_enable
? "enabled" : "disabled");
987 if (!strcasecmp (args
, "1") ||
988 !strcasecmp (args
, "y") ||
989 !strcasecmp (args
, "yes") ||
990 !strcasecmp (args
, "on") ||
991 !strcasecmp (args
, "t") ||
992 !strcasecmp (args
, "true"))
993 Adp_SetLogEnable (log_enable
= 1);
994 else if (!strcasecmp (args
, "0") ||
995 !strcasecmp (args
, "n") ||
996 !strcasecmp (args
, "no") ||
997 !strcasecmp (args
, "off") ||
998 !strcasecmp (args
, "f") ||
999 !strcasecmp (args
, "false"))
1000 Adp_SetLogEnable (log_enable
= 0);
1002 printf_filtered ("rdilogenable: unrecognized argument '%s'\n"
1003 " try y or n\n", args
);
1006 extern initialize_file_ftype _initialize_remote_rdi
; /* -Wmissing-prototypes */
1009 _initialize_remote_rdi (void)
1011 struct cmd_list_element
*c
;
1014 add_target (&arm_rdi_ops
);
1016 log_filename
= xstrdup ("rdi.log");
1017 Adp_SetLogfile (log_filename
);
1018 Adp_SetLogEnable (log_enable
);
1020 c
= add_cmd ("rdilogfile", class_maintenance
,
1022 "Set filename for ADP packet log.\n"
1023 "This file is used to log Angel Debugger Protocol packets.\n"
1024 "With a single argument, sets the logfile name to that value.\n"
1025 "Without an argument, shows the current logfile name.\n"
1026 "See also: rdilogenable\n",
1028 set_cmd_completer (c
, filename_completer
);
1030 add_cmd ("rdilogenable", class_maintenance
,
1031 rdilogenable_command
,
1032 "Set enable logging of ADP packets.\n"
1033 "This will log ADP packets exchanged between gdb and the\n"
1034 "rdi target device.\n"
1035 "An argument of 1, t, true, y or yes will enable.\n"
1036 "An argument of 0, f, false, n or no will disabled.\n"
1037 "Withough an argument, it will display current state.\n",
1040 add_setshow_boolean_cmd
1041 ("rdiromatzero", no_class
, &rom_at_zero
,
1042 "Set target has ROM at addr 0.\n"
1043 "A true value disables vector catching, false enables vector catching.\n"
1044 "This is evaluated at the time the 'target rdi' command is executed\n",
1045 "Show if target has ROM at addr 0.\n",
1047 &setlist
, &showlist
);
1049 add_setshow_boolean_cmd
1050 ("rdiheartbeat", no_class
, &rdi_heartbeat
,
1051 "Set enable for ADP heartbeat packets.\n"
1052 "I don't know why you would want this. If you enable them,\n"
1053 "it will confuse ARM and EPI JTAG interface boxes as well\n"
1054 "as the Angel Monitor.\n",
1055 "Show enable for ADP heartbeat packets.\n",
1057 &setlist
, &showlist
);
1060 /* A little dummy to make linking with the library succeed. */
1063 Fail (const char *ignored
, ...)