1 /* GDB interface to ARM RDI library.
3 Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2004 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 void arm_rdi_open (char *name, int from_tty);
71 static void arm_rdi_close (int quitting);
73 static void arm_rdi_store_registers (int regno);
75 static ptid_t arm_rdi_wait (ptid_t ptid, struct target_waitstatus *status);
77 static void arm_rdi_kill (void);
79 static void arm_rdi_detach (char *args, int from_tty);
81 static int arm_rdi_insert_breakpoint (CORE_ADDR, char *);
83 static int arm_rdi_remove_breakpoint (CORE_ADDR, char *);
85 static char *rdi_error_message (int err);
87 static enum target_signal rdi_error_signal (int err);
89 /* Global variables. */
91 struct target_ops arm_rdi_ops;
93 static struct Dbg_ConfigBlock gdb_config;
95 static struct Dbg_HostosInterface gdb_hostif;
97 static int max_load_size;
99 static int execute_status;
101 /* Send heatbeat packets? */
102 static int rdi_heartbeat = 0;
104 /* Target has ROM at address 0. */
105 static int rom_at_zero = 0;
107 /* Enable logging? */
108 static int log_enable = 0;
110 /* Name of the log file. Default is "rdi.log". */
111 static char *log_filename;
113 /* A little list of breakpoints that have been set. */
115 static struct local_bp_list_entry
119 struct local_bp_list_entry *next;
123 /* Helper callbacks for the "host interface" structure. RDI functions call
124 these to forward output from the target system and so forth. */
127 voiddummy (void *dummy)
129 fprintf_unfiltered (gdb_stdout, "void dummy\n");
133 myprint (void *arg, const char *format, va_list ap)
135 vfprintf_unfiltered (gdb_stdout, format, ap);
139 mywritec (void *arg, int c)
142 fputc_unfiltered (c, gdb_stdout);
146 mywrite (void *arg, char const *buffer, int len)
152 for (i = 0; i < len; i++)
154 if (isascii ((int) *e))
156 fputc_unfiltered ((int) *e, gdb_stdout);
169 /* These last two are tricky as we have to handle the special case of
170 being interrupted more carefully */
175 return fgetc (stdin);
179 mygets (void *arg, char *buffer, int len)
181 return fgets (buffer, len, stdin);
184 /* Prevent multiple calls to angel_RDI_close(). */
185 static int closed_already = 1;
187 /* Open a connection to a remote debugger. NAME is the filename used
188 for communication. */
191 arm_rdi_open (char *name, int from_tty)
194 unsigned long arg1, arg2;
195 char *openArgs = NULL;
196 char *devName = NULL;
200 error ("To open an RDI connection, you need to specify what serial\n\
201 device is attached to the remote system (e.g. /dev/ttya).");
203 /* split name after whitespace, pass tail as arg to open command */
205 devName = xstrdup (name);
206 p = strchr (devName, ' ');
218 /* Make the basic low-level connection. */
221 rslt = Adp_OpenDevice (devName, openArgs, rdi_heartbeat);
224 error ("Could not open device \"%s\"", name);
226 gdb_config.bytesex = 2 | (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? 1 : 0);
228 gdb_config.rditype = 2;
229 gdb_config.heartbeat_on = 1;
230 gdb_config.flags = 2;
232 gdb_hostif.dbgprint = myprint;
233 gdb_hostif.dbgpause = mypause;
234 gdb_hostif.dbgarg = NULL;
235 gdb_hostif.writec = mywritec;
236 gdb_hostif.readc = myreadc;
237 gdb_hostif.write = mywrite;
238 gdb_hostif.gets = mygets;
239 gdb_hostif.hostosarg = NULL;
240 gdb_hostif.reset = voiddummy;
242 rslt = angel_RDI_open (10, &gdb_config, &gdb_hostif, NULL);
243 if (rslt == RDIError_BigEndian || rslt == RDIError_LittleEndian)
244 ; /* do nothing, this is the expected return */
245 else if (rslt != RDIError_NoError)
247 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
249 error ("RDI_open failed\n");
252 rslt = angel_RDI_info (RDIInfo_Target, &arg1, &arg2);
253 if (rslt != RDIError_NoError)
255 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
257 rslt = angel_RDI_info (RDIInfo_Points, &arg1, &arg2);
258 if (rslt != RDIError_NoError)
260 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
262 rslt = angel_RDI_info (RDIInfo_Step, &arg1, &arg2);
263 if (rslt != RDIError_NoError)
265 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
267 rslt = angel_RDI_info (RDIInfo_CoPro, &arg1, &arg2);
268 if (rslt != RDIError_NoError)
270 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
272 rslt = angel_RDI_info (RDIInfo_SemiHosting, &arg1, &arg2);
273 if (rslt != RDIError_NoError)
275 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
278 rslt = angel_RDI_info (RDIInfo_GetLoadSize, &arg1, &arg2);
279 if (rslt != RDIError_NoError)
281 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
283 max_load_size = arg1;
285 push_target (&arm_rdi_ops);
287 target_fetch_registers (-1);
289 rslt = angel_RDI_open (1, &gdb_config, NULL, NULL);
290 if (rslt != RDIError_NoError)
292 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
295 arg1 = rom_at_zero ? 0x0 : 0x13b;
297 rslt = angel_RDI_info (RDIVector_Catch, &arg1, &arg2);
298 if (rslt != RDIError_NoError)
300 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
303 arg1 = (unsigned long) "";
304 rslt = angel_RDI_info (RDISet_Cmdline, &arg1, &arg2);
305 if (rslt != RDIError_NoError)
307 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
310 /* Clear out any existing records of breakpoints. */
312 struct local_bp_list_entry *entry, *preventry = NULL;
314 for (entry = local_bp_list; entry != NULL; entry = entry->next)
321 printf_filtered ("Connected to ARM RDI target.\n");
323 inferior_ptid = pid_to_ptid (42);
326 /* Start an inferior process and set inferior_ptid to its pid.
327 EXEC_FILE is the file to run.
328 ARGS is a string containing the arguments to the program.
329 ENV is the environment vector to pass. Errors reported with error().
330 On VxWorks and various standalone systems, we ignore exec_file. */
331 /* This is called not only when we first attach, but also when the
332 user types "run" after having attached. */
335 arm_rdi_create_inferior (char *exec_file, char *args, char **env, int from_tty)
338 unsigned long arg1, arg2;
340 CORE_ADDR entry_point;
342 if (exec_file == 0 || exec_bfd == 0)
343 error ("No executable file specified.");
345 entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);
348 remove_breakpoints ();
349 init_wait_for_inferior ();
351 len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
352 arg_buf = (char *) alloca (len);
354 strcat (arg_buf, exec_file);
355 strcat (arg_buf, " ");
356 strcat (arg_buf, args);
358 inferior_ptid = pid_to_ptid (42);
359 insert_breakpoints (); /* Needed to get correct instruction in cache */
365 if (strncmp (*env, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
367 unsigned long top_of_memory;
370 /* Set up memory limit */
371 top_of_memory = strtoul (*env + sizeof ("MEMSIZE=") - 1,
373 printf_filtered ("Setting top-of-memory to 0x%lx\n",
376 rslt = angel_RDI_info (RDIInfo_SetTopMem, &top_of_memory, &arg2);
377 if (rslt != RDIError_NoError)
379 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
386 arg1 = (unsigned long) arg_buf;
387 rslt = angel_RDI_info (RDISet_Cmdline, /* &arg1 */ (unsigned long *) arg_buf, &arg2);
388 if (rslt != RDIError_NoError)
390 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
393 proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
396 /* This takes a program previously attached to and detaches it. After
397 this is done, GDB can be used to debug some other program. We
398 better not have left any breakpoints in the target program or it'll
399 die when it hits one. */
402 arm_rdi_detach (char *args, int from_tty)
407 /* Clean up connection to a remote debugger. */
410 arm_rdi_close (int quitting)
416 rslt = angel_RDI_close ();
417 if (rslt != RDIError_NoError)
419 printf_filtered ("RDI_close: %s\n", rdi_error_message (rslt));
422 inferior_ptid = null_ptid;
424 generic_mourn_inferior ();
428 /* Tell the remote machine to resume. */
431 arm_rdi_resume (ptid_t ptid, int step, enum target_signal siggnal)
436 if (0 /* turn on when hardware supports single-stepping */ )
438 rslt = angel_RDI_step (1, &point);
439 if (rslt != RDIError_NoError)
440 printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt));
449 pc = read_register (ARM_PC_REGNUM);
450 pc = arm_get_next_pc (pc);
451 arm_rdi_insert_breakpoint (pc, handle);
454 execute_status = rslt = angel_RDI_execute (&point);
455 if (rslt != RDIError_NoError && rslt != RDIError_BreakpointReached)
456 printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt));
459 arm_rdi_remove_breakpoint (pc, handle);
463 /* Wait until the remote machine stops, then return, storing status in
464 STATUS just as `wait' would. Returns "pid" (though it's not clear
465 what, if anything, that means in the case of this target). */
468 arm_rdi_wait (ptid_t ptid, struct target_waitstatus *status)
470 status->kind = (execute_status == RDIError_NoError ?
471 TARGET_WAITKIND_EXITED : TARGET_WAITKIND_STOPPED);
473 /* convert stopped code from target into right signal */
474 status->value.sig = rdi_error_signal (execute_status);
476 return inferior_ptid;
479 /* Read the remote registers into the block REGS. */
482 arm_rdi_fetch_registers (int regno)
484 int rslt, rdi_regmask;
485 unsigned long rawreg, rawregs[32];
490 rslt = angel_RDI_CPUread (255, 0x27fff, rawregs);
491 if (rslt != RDIError_NoError)
493 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt));
496 for (regno = 0; regno < 15; regno++)
498 store_unsigned_integer (cookedreg, 4, rawregs[regno]);
499 regcache_raw_supply (current_regcache, regno, (char *) cookedreg);
501 store_unsigned_integer (cookedreg, 4, rawregs[15]);
502 regcache_raw_supply (current_regcache, ARM_PS_REGNUM, (char *) cookedreg);
503 arm_rdi_fetch_registers (ARM_PC_REGNUM);
507 if (regno == ARM_PC_REGNUM)
508 rdi_regmask = RDIReg_PC;
509 else if (regno == ARM_PS_REGNUM)
510 rdi_regmask = RDIReg_CPSR;
511 else if (regno < 0 || regno > 15)
514 regcache_raw_supply (current_regcache, regno, (char *) &rawreg);
518 rdi_regmask = 1 << regno;
520 rslt = angel_RDI_CPUread (255, rdi_regmask, &rawreg);
521 if (rslt != RDIError_NoError)
523 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt));
525 store_unsigned_integer (cookedreg, 4, rawreg);
526 regcache_raw_supply (current_regcache, regno, (char *) cookedreg);
531 arm_rdi_prepare_to_store (void)
536 /* Store register REGNO, or all registers if REGNO == -1, from the contents
537 of REGISTERS. FIXME: ignores errors. */
540 arm_rdi_store_registers (int regno)
542 int rslt, rdi_regmask;
544 /* These need to be able to take 'floating point register' contents */
545 unsigned long rawreg[3], rawerreg[3];
549 for (regno = 0; regno < NUM_REGS; regno++)
550 arm_rdi_store_registers (regno);
554 deprecated_read_register_gen (regno, (char *) rawreg);
555 /* RDI manipulates data in host byte order, so convert now. */
556 store_unsigned_integer (rawerreg, 4, rawreg[0]);
558 if (regno == ARM_PC_REGNUM)
559 rdi_regmask = RDIReg_PC;
560 else if (regno == ARM_PS_REGNUM)
561 rdi_regmask = RDIReg_CPSR;
562 else if (regno < 0 || regno > 15)
565 rdi_regmask = 1 << regno;
567 rslt = angel_RDI_CPUwrite (255, rdi_regmask, rawerreg);
568 if (rslt != RDIError_NoError)
570 printf_filtered ("RDI_CPUwrite: %s\n", rdi_error_message (rslt));
575 /* Read or write LEN bytes from inferior memory at MEMADDR,
576 transferring to or from debugger address MYADDR. Write to inferior
577 if SHOULD_WRITE is nonzero. Returns length of data written or
578 read; 0 for error. TARGET is unused. */
581 arm_rdi_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
582 int should_write, struct mem_attrib *attrib,
583 struct target_ops *target)
589 rslt = angel_RDI_write (myaddr, memaddr, &len);
590 if (rslt != RDIError_NoError)
592 printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt));
597 rslt = angel_RDI_read (memaddr, myaddr, &len);
598 if (rslt != RDIError_NoError)
600 printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt));
607 /* Display random info collected from the target. */
610 arm_rdi_files_info (struct target_ops *ignore)
612 char *file = "nothing";
614 unsigned long arg1, arg2;
616 rslt = angel_RDI_info (RDIInfo_Target, &arg1, &arg2);
617 if (rslt != RDIError_NoError)
619 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
621 if (arg1 & (1 << 15))
622 printf_filtered ("Target supports Thumb code.\n");
623 if (arg1 & (1 << 14))
624 printf_filtered ("Target can do profiling.\n");
626 printf_filtered ("Target is real hardware.\n");
628 rslt = angel_RDI_info (RDIInfo_Step, &arg1, &arg2);
629 if (rslt != RDIError_NoError)
631 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
633 printf_filtered ("Target can%s single-step.\n", (arg1 & 0x4 ? "" : "not"));
635 rslt = angel_RDI_info (RDIInfo_Icebreaker, &arg1, &arg2);
636 if (rslt != RDIError_NoError)
638 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
641 printf_filtered ("Target includes an EmbeddedICE.\n");
649 rslt = angel_RDI_open (1, &gdb_config, NULL, NULL);
650 if (rslt != RDIError_NoError)
652 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
657 arm_rdi_mourn_inferior (void)
659 /* We remove the inserted breakpoints in case the user wants to
660 issue another target and load commands to rerun his application;
661 This is something that wouldn't work on a native target, for instance,
662 as the process goes away when the inferior exits, but it works with
663 some remote targets like this one. That is why this is done here. */
664 remove_breakpoints();
665 unpush_target (&arm_rdi_ops);
666 generic_mourn_inferior ();
669 /* While the RDI library keeps track of its own breakpoints, we need
670 to remember "handles" so that we can delete them later. Since
671 breakpoints get used for stepping, be careful not to leak memory
675 arm_rdi_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
679 struct local_bp_list_entry *entry;
680 int type = RDIPoint_EQ;
682 if (arm_pc_is_thumb (addr) || arm_pc_is_thumb_dummy (addr))
683 type |= RDIPoint_16Bit;
684 rslt = angel_RDI_setbreak (addr, type, 0, &point);
685 if (rslt != RDIError_NoError)
687 printf_filtered ("RDI_setbreak: %s\n", rdi_error_message (rslt));
690 (struct local_bp_list_entry *) xmalloc (sizeof (struct local_bp_list_entry));
692 entry->point = point;
693 entry->next = local_bp_list;
694 local_bp_list = entry;
699 arm_rdi_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
703 struct local_bp_list_entry **entryp, *dead;
705 for (entryp = &local_bp_list; *entryp != NULL; entryp = &(*entryp)->next)
706 if ((*entryp)->addr == addr)
712 rslt = angel_RDI_clearbreak (dead->point);
713 if (rslt != RDIError_NoError)
714 printf_filtered ("RDI_clearbreak: %s\n", rdi_error_message (rslt));
716 /* Delete the breakpoint entry locally. */
717 *entryp = dead->next;
726 rdi_error_message (int err)
730 case RDIError_NoError:
733 return "debuggee reset";
734 case RDIError_UndefinedInstruction:
735 return "undefined instruction";
736 case RDIError_SoftwareInterrupt:
737 return "SWI trapped";
738 case RDIError_PrefetchAbort:
739 return "prefetch abort, execution ran into unmapped memory?";
740 case RDIError_DataAbort:
741 return "data abort, no memory at specified address?";
742 case RDIError_AddressException:
743 return "address exception, access >26bit in 26bit mode";
745 return "IRQ, interrupt trapped";
747 return "FIQ, fast interrupt trapped";
749 return "a miscellaneous type of error";
750 case RDIError_BranchThrough0:
751 return "branch through location 0";
752 case RDIError_NotInitialised:
753 return "internal error, RDI_open not called first";
754 case RDIError_UnableToInitialise:
755 return "internal error, target world is broken";
756 case RDIError_WrongByteSex:
757 return "See Operator: WrongByteSex";
758 case RDIError_UnableToTerminate:
759 return "See Operator: Unable to Terminate";
760 case RDIError_BadInstruction:
761 return "bad instruction, illegal to execute this instruction";
762 case RDIError_IllegalInstruction:
763 return "illegal instruction, the effect of executing it is undefined";
764 case RDIError_BadCPUStateSetting:
765 return "internal error, tried to set SPSR of user mode";
766 case RDIError_UnknownCoPro:
767 return "unknown co-processor";
768 case RDIError_UnknownCoProState:
769 return "cannot execute co-processor request";
770 case RDIError_BadCoProState:
771 return "recognizably broken co-processor request";
772 case RDIError_BadPointType:
773 return "internal error, bad point yype";
774 case RDIError_UnimplementedType:
775 return "internal error, unimplemented type";
776 case RDIError_BadPointSize:
777 return "internal error, bad point size";
778 case RDIError_UnimplementedSize:
779 return "internal error, unimplemented size";
780 case RDIError_NoMorePoints:
781 return "last break/watch point was used";
782 case RDIError_BreakpointReached:
783 return "breakpoint reached";
784 case RDIError_WatchpointAccessed:
785 return "watchpoint accessed";
786 case RDIError_NoSuchPoint:
787 return "attempted to clear non-existent break/watch point";
788 case RDIError_ProgramFinishedInStep:
789 return "end of the program reached while stepping";
790 case RDIError_UserInterrupt:
791 return "you pressed Escape";
792 case RDIError_CantSetPoint:
793 return "no more break/watch points available";
794 case RDIError_IncompatibleRDILevels:
795 return "incompatible RDI levels";
796 case RDIError_LittleEndian:
797 return "debuggee is little endian";
798 case RDIError_BigEndian:
799 return "debuggee is big endian";
800 case RDIError_SoftInitialiseError:
801 return "recoverable error in RDI initialization";
802 case RDIError_InsufficientPrivilege:
803 return "internal error, supervisor state not accessible to monitor";
804 case RDIError_UnimplementedMessage:
805 return "internal error, unimplemented message";
806 case RDIError_UndefinedMessage:
807 return "internal error, undefined message";
809 return "undefined error message, should reset target";
813 /* Convert the ARM error messages to signals that GDB knows about. */
815 static enum target_signal
816 rdi_error_signal (int err)
820 case RDIError_NoError:
823 return TARGET_SIGNAL_TERM; /* ??? */
824 case RDIError_UndefinedInstruction:
825 return TARGET_SIGNAL_ILL;
826 case RDIError_SoftwareInterrupt:
827 case RDIError_PrefetchAbort:
828 case RDIError_DataAbort:
829 return TARGET_SIGNAL_TRAP;
830 case RDIError_AddressException:
831 return TARGET_SIGNAL_SEGV;
834 return TARGET_SIGNAL_TRAP;
836 return TARGET_SIGNAL_TERM;
837 case RDIError_BranchThrough0:
838 return TARGET_SIGNAL_TRAP;
839 case RDIError_NotInitialised:
840 case RDIError_UnableToInitialise:
841 case RDIError_WrongByteSex:
842 case RDIError_UnableToTerminate:
843 return TARGET_SIGNAL_UNKNOWN;
844 case RDIError_BadInstruction:
845 case RDIError_IllegalInstruction:
846 return TARGET_SIGNAL_ILL;
847 case RDIError_BadCPUStateSetting:
848 case RDIError_UnknownCoPro:
849 case RDIError_UnknownCoProState:
850 case RDIError_BadCoProState:
851 case RDIError_BadPointType:
852 case RDIError_UnimplementedType:
853 case RDIError_BadPointSize:
854 case RDIError_UnimplementedSize:
855 case RDIError_NoMorePoints:
856 return TARGET_SIGNAL_UNKNOWN;
857 case RDIError_BreakpointReached:
858 case RDIError_WatchpointAccessed:
859 return TARGET_SIGNAL_TRAP;
860 case RDIError_NoSuchPoint:
861 case RDIError_ProgramFinishedInStep:
862 return TARGET_SIGNAL_UNKNOWN;
863 case RDIError_UserInterrupt:
864 return TARGET_SIGNAL_INT;
865 case RDIError_IncompatibleRDILevels:
866 case RDIError_LittleEndian:
867 case RDIError_BigEndian:
868 case RDIError_SoftInitialiseError:
869 case RDIError_InsufficientPrivilege:
870 case RDIError_UnimplementedMessage:
871 case RDIError_UndefinedMessage:
873 return TARGET_SIGNAL_UNKNOWN;
880 angel_RDI_stop_request();
884 /* Define the target operations structure. */
889 arm_rdi_ops.to_shortname = "rdi";
890 arm_rdi_ops.to_longname = "ARM RDI";
891 arm_rdi_ops.to_doc = "Use a remote ARM-based computer; via the RDI library.\n\
892 Specify the serial device it is connected to (e.g. /dev/ttya).";
893 arm_rdi_ops.to_open = arm_rdi_open;
894 arm_rdi_ops.to_close = arm_rdi_close;
895 arm_rdi_ops.to_detach = arm_rdi_detach;
896 arm_rdi_ops.to_resume = arm_rdi_resume;
897 arm_rdi_ops.to_wait = arm_rdi_wait;
898 arm_rdi_ops.to_stop = arm_rdi_stop;
899 arm_rdi_ops.to_fetch_registers = arm_rdi_fetch_registers;
900 arm_rdi_ops.to_store_registers = arm_rdi_store_registers;
901 arm_rdi_ops.to_prepare_to_store = arm_rdi_prepare_to_store;
902 arm_rdi_ops.to_xfer_memory = arm_rdi_xfer_memory;
903 arm_rdi_ops.to_files_info = arm_rdi_files_info;
904 arm_rdi_ops.to_insert_breakpoint = arm_rdi_insert_breakpoint;
905 arm_rdi_ops.to_remove_breakpoint = arm_rdi_remove_breakpoint;
906 arm_rdi_ops.to_kill = arm_rdi_kill;
907 arm_rdi_ops.to_load = generic_load;
908 arm_rdi_ops.to_create_inferior = arm_rdi_create_inferior;
909 arm_rdi_ops.to_mourn_inferior = arm_rdi_mourn_inferior;
910 arm_rdi_ops.to_stratum = process_stratum;
911 arm_rdi_ops.to_has_all_memory = 1;
912 arm_rdi_ops.to_has_memory = 1;
913 arm_rdi_ops.to_has_stack = 1;
914 arm_rdi_ops.to_has_registers = 1;
915 arm_rdi_ops.to_has_execution = 1;
916 arm_rdi_ops.to_magic = OPS_MAGIC;
920 rdilogfile_command (char *arg, int from_tty)
922 if (!arg || strlen (arg) == 0)
924 printf_filtered ("rdi log file is '%s'\n", log_filename);
929 xfree (log_filename);
931 log_filename = xstrdup (arg);
933 Adp_SetLogfile (log_filename);
937 rdilogenable_command (char *args, int from_tty)
939 if (!args || strlen (args) == 0)
941 printf_filtered ("rdi log is %s\n", log_enable ? "enabled" : "disabled");
945 if (!strcasecmp (args, "1") ||
946 !strcasecmp (args, "y") ||
947 !strcasecmp (args, "yes") ||
948 !strcasecmp (args, "on") ||
949 !strcasecmp (args, "t") ||
950 !strcasecmp (args, "true"))
951 Adp_SetLogEnable (log_enable = 1);
952 else if (!strcasecmp (args, "0") ||
953 !strcasecmp (args, "n") ||
954 !strcasecmp (args, "no") ||
955 !strcasecmp (args, "off") ||
956 !strcasecmp (args, "f") ||
957 !strcasecmp (args, "false"))
958 Adp_SetLogEnable (log_enable = 0);
960 printf_filtered ("rdilogenable: unrecognized argument '%s'\n"
961 " try y or n\n", args);
964 extern initialize_file_ftype _initialize_remote_rdi; /* -Wmissing-prototypes */
967 _initialize_remote_rdi (void)
969 struct cmd_list_element *c;
972 add_target (&arm_rdi_ops);
974 log_filename = xstrdup ("rdi.log");
975 Adp_SetLogfile (log_filename);
976 Adp_SetLogEnable (log_enable);
978 c = add_cmd ("rdilogfile", class_maintenance,
980 "Set filename for ADP packet log.\n"
981 "This file is used to log Angel Debugger Protocol packets.\n"
982 "With a single argument, sets the logfile name to that value.\n"
983 "Without an argument, shows the current logfile name.\n"
984 "See also: rdilogenable\n",
986 set_cmd_completer (c, filename_completer);
988 add_cmd ("rdilogenable", class_maintenance,
989 rdilogenable_command,
990 "Set enable logging of ADP packets.\n"
991 "This will log ADP packets exchanged between gdb and the\n"
992 "rdi target device.\n"
993 "An argument of 1, t, true, y or yes will enable.\n"
994 "An argument of 0, f, false, n or no will disabled.\n"
995 "Withough an argument, it will display current state.\n",
998 add_setshow_boolean_cmd ("rdiromatzero", no_class, &rom_at_zero, "\
999 Set target has ROM at addr 0.", "\
1000 Show if target has ROM at addr 0.", "\
1001 A true value disables vector catching, false enables vector catching.\n\
1002 This is evaluated at the time the 'target rdi' command is executed.", "\
1003 Target has ROM at addr 0 is %s.",
1005 &setlist, &showlist);
1007 add_setshow_boolean_cmd ("rdiheartbeat", no_class, &rdi_heartbeat, "\
1008 Set enable for ADP heartbeat packets.", "\
1009 Show enable for ADP heartbeat packets.", "\
1010 I don't know why you would want this. If you enable them,\n\
1011 it will confuse ARM and EPI JTAG interface boxes as well\n\
1012 as the Angel Monitor.", "\
1013 Enable for ADP heartbeat packets is %s.",
1015 &setlist, &showlist);
1018 /* A little dummy to make linking with the library succeed. */
1021 Fail (const char *ignored, ...)