1 /* GDB interface to ARM RDI library.
2 Copyright 1997, 1998, 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"
37 #include <sys/types.h>
42 #include "rdi-share/ardi.h"
43 #include "rdi-share/adp.h"
44 #include "rdi-share/hsys.h"
46 extern int isascii (int);
48 /* Prototypes for local functions */
50 static void arm_rdi_files_info (struct target_ops *ignore);
52 static int arm_rdi_xfer_memory (CORE_ADDR memaddr, char *myaddr,
53 int len, int should_write,
54 struct mem_attrib *attrib,
55 struct target_ops *target);
57 static void arm_rdi_prepare_to_store (void);
59 static void arm_rdi_fetch_registers (int regno);
61 static void arm_rdi_resume (int pid, int step, enum target_signal siggnal);
63 static int arm_rdi_start_remote (char *dummy);
65 static void arm_rdi_open (char *name, int from_tty);
67 static void arm_rdi_create_inferior (char *exec_file, char *args, char **env);
69 static void arm_rdi_close (int quitting);
71 static void arm_rdi_store_registers (int regno);
73 static void arm_rdi_mourn (void);
75 static void arm_rdi_send (char *buf);
77 static int arm_rdi_wait (int pid, struct target_waitstatus *status);
79 static void arm_rdi_kill (void);
81 static void arm_rdi_detach (char *args, int from_tty);
83 static void arm_rdi_interrupt (int signo);
85 static void arm_rdi_interrupt_twice (int signo);
87 static void interrupt_query (void);
89 static int arm_rdi_insert_breakpoint (CORE_ADDR, char *);
91 static int arm_rdi_remove_breakpoint (CORE_ADDR, char *);
93 static char *rdi_error_message (int err);
95 static enum target_signal rdi_error_signal (int err);
97 /* Global variables. */
99 struct target_ops arm_rdi_ops;
101 static struct Dbg_ConfigBlock gdb_config;
103 static struct Dbg_HostosInterface gdb_hostif;
105 static int max_load_size;
107 static int execute_status;
109 /* Send heatbeat packets? */
110 static int rdi_heartbeat = 0;
112 /* Target has ROM at address 0. */
113 static int rom_at_zero = 0;
115 /* Enable logging? */
116 static int log_enable = 0;
118 /* Name of the log file. Default is "rdi.log". */
119 static char *log_filename;
121 /* A little list of breakpoints that have been set. */
123 static struct local_bp_list_entry
127 struct local_bp_list_entry *next;
132 /* Stub for catch_errors. */
135 arm_rdi_start_remote (char *dummy)
140 /* Helper callbacks for the "host interface" structure. RDI functions call
141 these to forward output from the target system and so forth. */
144 voiddummy (void *dummy)
146 fprintf_unfiltered (gdb_stdout, "void dummy\n");
150 myprint (PTR arg, const char *format, va_list ap)
152 vfprintf_unfiltered (gdb_stdout, format, ap);
156 mywritec (PTR arg, int c)
159 fputc_unfiltered (c, gdb_stdout);
163 mywrite (PTR arg, char const *buffer, int len)
169 for (i = 0; i < len; i++)
171 if (isascii ((int) *e))
173 fputc_unfiltered ((int) *e, gdb_stdout);
186 /* These last two are tricky as we have to handle the special case of
187 being interrupted more carefully */
192 return fgetc (stdin);
196 mygets (PTR arg, char *buffer, int len)
198 return fgets (buffer, len, stdin);
201 /* Prevent multiple calls to angel_RDI_close(). */
202 static int closed_already = 1;
204 /* Open a connection to a remote debugger. NAME is the filename used
205 for communication. */
208 arm_rdi_open (char *name, int from_tty)
211 unsigned long arg1, arg2;
212 char *openArgs = NULL;
213 char *devName = NULL;
217 error ("To open an RDI connection, you need to specify what serial\n\
218 device is attached to the remote system (e.g. /dev/ttya).");
220 /* split name after whitespace, pass tail as arg to open command */
222 devName = xstrdup (name);
223 p = strchr (devName, ' ');
235 /* Make the basic low-level connection. */
238 rslt = Adp_OpenDevice (devName, openArgs, rdi_heartbeat);
241 error ("Could not open device \"%s\"", name);
243 gdb_config.bytesex = 2 | (TARGET_BYTE_ORDER == BIG_ENDIAN ? 1 : 0);
245 gdb_config.rditype = 2;
246 gdb_config.heartbeat_on = 1;
247 gdb_config.flags = 2;
249 gdb_hostif.dbgprint = myprint;
250 gdb_hostif.dbgpause = mypause;
251 gdb_hostif.dbgarg = NULL;
252 gdb_hostif.writec = mywritec;
253 gdb_hostif.readc = myreadc;
254 gdb_hostif.write = mywrite;
255 gdb_hostif.gets = mygets;
256 gdb_hostif.hostosarg = NULL;
257 gdb_hostif.reset = voiddummy;
259 rslt = angel_RDI_open (10, &gdb_config, &gdb_hostif, NULL);
260 if (rslt == RDIError_BigEndian || rslt == RDIError_LittleEndian)
261 ; /* do nothing, this is the expected return */
264 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
266 error ("RDI_open failed\n");
269 rslt = angel_RDI_info (RDIInfo_Target, &arg1, &arg2);
272 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
274 rslt = angel_RDI_info (RDIInfo_Points, &arg1, &arg2);
277 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
279 rslt = angel_RDI_info (RDIInfo_Step, &arg1, &arg2);
282 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
284 rslt = angel_RDI_info (RDIInfo_CoPro, &arg1, &arg2);
287 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
289 rslt = angel_RDI_info (RDIInfo_SemiHosting, &arg1, &arg2);
292 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
295 rslt = angel_RDI_info (RDIInfo_GetLoadSize, &arg1, &arg2);
298 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
300 max_load_size = arg1;
302 push_target (&arm_rdi_ops);
304 target_fetch_registers (-1);
306 rslt = angel_RDI_open (1, &gdb_config, NULL, NULL);
309 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
312 arg1 = rom_at_zero ? 0x0 : 0x13b;
314 rslt = angel_RDI_info (RDIVector_Catch, &arg1, &arg2);
317 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
320 arg1 = (unsigned long) "";
321 rslt = angel_RDI_info (RDISet_Cmdline, &arg1, &arg2);
324 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
327 /* Clear out any existing records of breakpoints. */
329 struct local_bp_list_entry *entry, *preventry = NULL;
331 for (entry = local_bp_list; entry != NULL; entry = entry->next)
338 printf_filtered ("Connected to ARM RDI target.\n");
343 /* Start an inferior process and set inferior_pid to its pid.
344 EXEC_FILE is the file to run.
345 ARGS is a string containing the arguments to the program.
346 ENV is the environment vector to pass. Errors reported with error().
347 On VxWorks and various standalone systems, we ignore exec_file. */
348 /* This is called not only when we first attach, but also when the
349 user types "run" after having attached. */
352 arm_rdi_create_inferior (char *exec_file, char *args, char **env)
355 unsigned long arg1, arg2;
357 CORE_ADDR entry_point;
359 if (exec_file == 0 || exec_bfd == 0)
360 error ("No executable file specified.");
362 entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);
365 remove_breakpoints ();
366 init_wait_for_inferior ();
368 len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
369 arg_buf = (char *) alloca (len);
371 strcat (arg_buf, exec_file);
372 strcat (arg_buf, " ");
373 strcat (arg_buf, args);
376 insert_breakpoints (); /* Needed to get correct instruction in cache */
382 if (strncmp (*env, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
384 unsigned long top_of_memory;
387 /* Set up memory limit */
388 top_of_memory = strtoul (*env + sizeof ("MEMSIZE=") - 1,
390 printf_filtered ("Setting top-of-memory to 0x%lx\n",
393 rslt = angel_RDI_info (RDIInfo_SetTopMem, &top_of_memory, &arg2);
396 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
403 arg1 = (unsigned long) arg_buf;
404 rslt = angel_RDI_info (RDISet_Cmdline, /* &arg1 */ (unsigned long *) arg_buf, &arg2);
407 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
410 proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
413 /* This takes a program previously attached to and detaches it. After
414 this is done, GDB can be used to debug some other program. We
415 better not have left any breakpoints in the target program or it'll
416 die when it hits one. */
419 arm_rdi_detach (char *args, int from_tty)
424 /* Clean up connection to a remote debugger. */
427 arm_rdi_close (int quitting)
433 rslt = angel_RDI_close ();
436 printf_filtered ("RDI_close: %s\n", rdi_error_message (rslt));
441 generic_mourn_inferior ();
445 /* Tell the remote machine to resume. */
448 arm_rdi_resume (int pid, int step, enum target_signal siggnal)
453 if (0 /* turn on when hardware supports single-stepping */ )
455 rslt = angel_RDI_step (1, &point);
458 printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt));
468 pc = read_register (PC_REGNUM);
469 pc = arm_get_next_pc (pc);
470 arm_rdi_insert_breakpoint (pc, handle);
472 execute_status = rslt = angel_RDI_execute (&point);
473 if (rslt == RDIError_BreakpointReached)
477 printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt));
481 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 (int pid, 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);
525 /* Read the remote registers into the block REGS. */
529 arm_rdi_fetch_registers (int regno)
531 int rslt, rdi_regmask;
532 unsigned long rawreg, rawregs[32];
537 rslt = angel_RDI_CPUread (255, 0x27fff, rawregs);
540 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt));
543 for (regno = 0; regno < 15; regno++)
545 store_unsigned_integer (cookedreg, 4, rawregs[regno]);
546 supply_register (regno, (char *) cookedreg);
548 store_unsigned_integer (cookedreg, 4, rawregs[15]);
549 supply_register (PS_REGNUM, (char *) cookedreg);
550 arm_rdi_fetch_registers (PC_REGNUM);
554 if (regno == PC_REGNUM)
555 rdi_regmask = RDIReg_PC;
556 else if (regno == PS_REGNUM)
557 rdi_regmask = RDIReg_CPSR;
558 else if (regno < 0 || regno > 15)
561 supply_register (regno, (char *) &rawreg);
565 rdi_regmask = 1 << regno;
567 rslt = angel_RDI_CPUread (255, rdi_regmask, &rawreg);
570 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt));
572 store_unsigned_integer (cookedreg, 4, rawreg);
573 supply_register (regno, (char *) cookedreg);
578 arm_rdi_prepare_to_store (void)
583 /* Store register REGNO, or all registers if REGNO == -1, from the contents
584 of REGISTERS. FIXME: ignores errors. */
587 arm_rdi_store_registers (int regno)
589 int rslt, rdi_regmask;
591 /* These need to be able to take 'floating point register' contents */
592 unsigned long rawreg[3], rawerreg[3];
596 for (regno = 0; regno < NUM_REGS; regno++)
597 arm_rdi_store_registers (regno);
601 read_register_gen (regno, (char *) rawreg);
602 /* RDI manipulates data in host byte order, so convert now. */
603 store_unsigned_integer (rawerreg, 4, rawreg[0]);
605 if (regno == PC_REGNUM)
606 rdi_regmask = RDIReg_PC;
607 else if (regno == PS_REGNUM)
608 rdi_regmask = RDIReg_CPSR;
609 else if (regno < 0 || regno > 15)
612 rdi_regmask = 1 << regno;
614 rslt = angel_RDI_CPUwrite (255, rdi_regmask, rawerreg);
617 printf_filtered ("RDI_CPUwrite: %s\n", rdi_error_message (rslt));
622 /* Read or write LEN bytes from inferior memory at MEMADDR,
623 transferring to or from debugger address MYADDR. Write to inferior
624 if SHOULD_WRITE is nonzero. Returns length of data written or
625 read; 0 for error. TARGET is unused. */
629 arm_rdi_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int should_write,
630 struct mem_attrib *attrib ATTRIBUTE_UNUSED,
631 struct target_ops *target ATTRIBUTE_UNUSED)
637 rslt = angel_RDI_write (myaddr, memaddr, &len);
640 printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt));
645 rslt = angel_RDI_read (memaddr, myaddr, &len);
648 printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt));
655 /* Display random info collected from the target. */
658 arm_rdi_files_info (struct target_ops *ignore)
660 char *file = "nothing";
662 unsigned long arg1, arg2;
664 rslt = angel_RDI_info (RDIInfo_Target, &arg1, &arg2);
667 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
669 if (arg1 & (1 << 15))
670 printf_filtered ("Target supports Thumb code.\n");
671 if (arg1 & (1 << 14))
672 printf_filtered ("Target can do profiling.\n");
674 printf_filtered ("Target is real hardware.\n");
676 rslt = angel_RDI_info (RDIInfo_Step, &arg1, &arg2);
679 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
681 printf_filtered ("Target can%s single-step.\n", (arg1 & 0x4 ? "" : "not"));
683 rslt = angel_RDI_info (RDIInfo_Icebreaker, &arg1, &arg2);
686 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
689 printf_filtered ("Target includes an EmbeddedICE.\n");
697 rslt = angel_RDI_open (1, &gdb_config, NULL, NULL);
700 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
705 arm_rdi_mourn_inferior (void)
707 /* We remove the inserted breakpoints in case the user wants to
708 issue another target and load commands to rerun his application;
709 This is something that wouldn't work on a native target, for instance,
710 as the process goes away when the inferior exits, but it works with
711 some remote targets like this one. That is why this is done here. */
712 remove_breakpoints();
713 unpush_target (&arm_rdi_ops);
714 generic_mourn_inferior ();
717 /* While the RDI library keeps track of its own breakpoints, we need
718 to remember "handles" so that we can delete them later. Since
719 breakpoints get used for stepping, be careful not to leak memory
723 arm_rdi_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
727 struct local_bp_list_entry *entry;
728 int type = RDIPoint_EQ;
730 if (arm_pc_is_thumb (addr) || arm_pc_is_thumb_dummy (addr))
731 type |= RDIPoint_16Bit;
732 rslt = angel_RDI_setbreak (addr, type, 0, &point);
735 printf_filtered ("RDI_setbreak: %s\n", rdi_error_message (rslt));
738 (struct local_bp_list_entry *) xmalloc (sizeof (struct local_bp_list_entry));
740 entry->point = point;
741 entry->next = local_bp_list;
742 local_bp_list = entry;
747 arm_rdi_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
751 struct local_bp_list_entry *entry, *preventry;
753 for (entry = local_bp_list; entry != NULL; entry = entry->next)
755 if (entry->addr == addr)
763 rslt = angel_RDI_clearbreak (entry->point);
766 printf_filtered ("RDI_clearbreak: %s\n", rdi_error_message (rslt));
768 /* Delete the breakpoint entry locally. */
769 if (entry == local_bp_list)
771 local_bp_list = entry->next;
775 preventry->next = entry->next;
783 rdi_error_message (int err)
787 case RDIError_NoError:
790 return "debuggee reset";
791 case RDIError_UndefinedInstruction:
792 return "undefined instruction";
793 case RDIError_SoftwareInterrupt:
794 return "SWI trapped";
795 case RDIError_PrefetchAbort:
796 return "prefetch abort, execution ran into unmapped memory?";
797 case RDIError_DataAbort:
798 return "data abort, no memory at specified address?";
799 case RDIError_AddressException:
800 return "address exception, access >26bit in 26bit mode";
802 return "IRQ, interrupt trapped";
804 return "FIQ, fast interrupt trapped";
806 return "a miscellaneous type of error";
807 case RDIError_BranchThrough0:
808 return "branch through location 0";
809 case RDIError_NotInitialised:
810 return "internal error, RDI_open not called first";
811 case RDIError_UnableToInitialise:
812 return "internal error, target world is broken";
813 case RDIError_WrongByteSex:
814 return "See Operator: WrongByteSex";
815 case RDIError_UnableToTerminate:
816 return "See Operator: Unable to Terminate";
817 case RDIError_BadInstruction:
818 return "bad instruction, illegal to execute this instruction";
819 case RDIError_IllegalInstruction:
820 return "illegal instruction, the effect of executing it is undefined";
821 case RDIError_BadCPUStateSetting:
822 return "internal error, tried to set SPSR of user mode";
823 case RDIError_UnknownCoPro:
824 return "unknown co-processor";
825 case RDIError_UnknownCoProState:
826 return "cannot execute co-processor request";
827 case RDIError_BadCoProState:
828 return "recognizably broken co-processor request";
829 case RDIError_BadPointType:
830 return "internal error, bad point yype";
831 case RDIError_UnimplementedType:
832 return "internal error, unimplemented type";
833 case RDIError_BadPointSize:
834 return "internal error, bad point size";
835 case RDIError_UnimplementedSize:
836 return "internal error, unimplemented size";
837 case RDIError_NoMorePoints:
838 return "last break/watch point was used";
839 case RDIError_BreakpointReached:
840 return "breakpoint reached";
841 case RDIError_WatchpointAccessed:
842 return "watchpoint accessed";
843 case RDIError_NoSuchPoint:
844 return "attempted to clear non-existent break/watch point";
845 case RDIError_ProgramFinishedInStep:
846 return "end of the program reached while stepping";
847 case RDIError_UserInterrupt:
848 return "you pressed Escape";
849 case RDIError_CantSetPoint:
850 return "no more break/watch points available";
851 case RDIError_IncompatibleRDILevels:
852 return "incompatible RDI levels";
853 case RDIError_LittleEndian:
854 return "debuggee is little endian";
855 case RDIError_BigEndian:
856 return "debuggee is big endian";
857 case RDIError_SoftInitialiseError:
858 return "recoverable error in RDI initialization";
859 case RDIError_InsufficientPrivilege:
860 return "internal error, supervisor state not accessible to monitor";
861 case RDIError_UnimplementedMessage:
862 return "internal error, unimplemented message";
863 case RDIError_UndefinedMessage:
864 return "internal error, undefined message";
866 return "undefined error message, should reset target";
870 /* Convert the ARM error messages to signals that GDB knows about. */
872 static enum target_signal
873 rdi_error_signal (int err)
877 case RDIError_NoError:
880 return TARGET_SIGNAL_TERM; /* ??? */
881 case RDIError_UndefinedInstruction:
882 return TARGET_SIGNAL_ILL;
883 case RDIError_SoftwareInterrupt:
884 case RDIError_PrefetchAbort:
885 case RDIError_DataAbort:
886 return TARGET_SIGNAL_TRAP;
887 case RDIError_AddressException:
888 return TARGET_SIGNAL_SEGV;
891 return TARGET_SIGNAL_TRAP;
893 return TARGET_SIGNAL_TERM;
894 case RDIError_BranchThrough0:
895 return TARGET_SIGNAL_TRAP;
896 case RDIError_NotInitialised:
897 case RDIError_UnableToInitialise:
898 case RDIError_WrongByteSex:
899 case RDIError_UnableToTerminate:
900 return TARGET_SIGNAL_UNKNOWN;
901 case RDIError_BadInstruction:
902 case RDIError_IllegalInstruction:
903 return TARGET_SIGNAL_ILL;
904 case RDIError_BadCPUStateSetting:
905 case RDIError_UnknownCoPro:
906 case RDIError_UnknownCoProState:
907 case RDIError_BadCoProState:
908 case RDIError_BadPointType:
909 case RDIError_UnimplementedType:
910 case RDIError_BadPointSize:
911 case RDIError_UnimplementedSize:
912 case RDIError_NoMorePoints:
913 return TARGET_SIGNAL_UNKNOWN;
914 case RDIError_BreakpointReached:
915 case RDIError_WatchpointAccessed:
916 return TARGET_SIGNAL_TRAP;
917 case RDIError_NoSuchPoint:
918 case RDIError_ProgramFinishedInStep:
919 return TARGET_SIGNAL_UNKNOWN;
920 case RDIError_UserInterrupt:
921 return TARGET_SIGNAL_INT;
922 case RDIError_IncompatibleRDILevels:
923 case RDIError_LittleEndian:
924 case RDIError_BigEndian:
925 case RDIError_SoftInitialiseError:
926 case RDIError_InsufficientPrivilege:
927 case RDIError_UnimplementedMessage:
928 case RDIError_UndefinedMessage:
930 return TARGET_SIGNAL_UNKNOWN;
937 angel_RDI_stop_request();
941 /* Define the target operations structure. */
946 arm_rdi_ops.to_shortname = "rdi";
947 arm_rdi_ops.to_longname = "ARM RDI";
948 arm_rdi_ops.to_doc = "Use a remote ARM-based computer; via the RDI library.\n\
949 Specify the serial device it is connected to (e.g. /dev/ttya).";
950 arm_rdi_ops.to_open = arm_rdi_open;
951 arm_rdi_ops.to_close = arm_rdi_close;
952 arm_rdi_ops.to_detach = arm_rdi_detach;
953 arm_rdi_ops.to_resume = arm_rdi_resume;
954 arm_rdi_ops.to_wait = arm_rdi_wait;
955 arm_rdi_ops.to_stop = arm_rdi_stop;
956 arm_rdi_ops.to_fetch_registers = arm_rdi_fetch_registers;
957 arm_rdi_ops.to_store_registers = arm_rdi_store_registers;
958 arm_rdi_ops.to_prepare_to_store = arm_rdi_prepare_to_store;
959 arm_rdi_ops.to_xfer_memory = arm_rdi_xfer_memory;
960 arm_rdi_ops.to_files_info = arm_rdi_files_info;
961 arm_rdi_ops.to_insert_breakpoint = arm_rdi_insert_breakpoint;
962 arm_rdi_ops.to_remove_breakpoint = arm_rdi_remove_breakpoint;
963 arm_rdi_ops.to_kill = arm_rdi_kill;
964 arm_rdi_ops.to_load = generic_load;
965 arm_rdi_ops.to_create_inferior = arm_rdi_create_inferior;
966 arm_rdi_ops.to_mourn_inferior = arm_rdi_mourn_inferior;
967 arm_rdi_ops.to_stratum = process_stratum;
968 arm_rdi_ops.to_has_all_memory = 1;
969 arm_rdi_ops.to_has_memory = 1;
970 arm_rdi_ops.to_has_stack = 1;
971 arm_rdi_ops.to_has_registers = 1;
972 arm_rdi_ops.to_has_execution = 1;
973 arm_rdi_ops.to_magic = OPS_MAGIC;
977 rdilogfile_command (char *arg, int from_tty)
979 if (!arg || strlen (arg) == 0)
981 printf_filtered ("rdi log file is '%s'\n", log_filename);
986 xfree (log_filename);
988 log_filename = xstrdup (arg);
990 Adp_SetLogfile (log_filename);
994 rdilogenable_command (char *args, int from_tty)
996 if (!args || strlen (args) == 0)
998 printf_filtered ("rdi log is %s\n", log_enable ? "enabled" : "disabled");
1002 if (!strcasecmp (args, "1") ||
1003 !strcasecmp (args, "y") ||
1004 !strcasecmp (args, "yes") ||
1005 !strcasecmp (args, "on") ||
1006 !strcasecmp (args, "t") ||
1007 !strcasecmp (args, "true"))
1008 Adp_SetLogEnable (log_enable = 1);
1009 else if (!strcasecmp (args, "0") ||
1010 !strcasecmp (args, "n") ||
1011 !strcasecmp (args, "no") ||
1012 !strcasecmp (args, "off") ||
1013 !strcasecmp (args, "f") ||
1014 !strcasecmp (args, "false"))
1015 Adp_SetLogEnable (log_enable = 0);
1017 printf_filtered ("rdilogenable: unrecognized argument '%s'\n"
1018 " try y or n\n", args);
1022 _initialize_remote_rdi (void)
1025 add_target (&arm_rdi_ops);
1027 log_filename = xstrdup ("rdi.log");
1028 Adp_SetLogfile (log_filename);
1029 Adp_SetLogEnable (log_enable);
1031 add_cmd ("rdilogfile", class_maintenance,
1033 "Set filename for ADP packet log.\n\
1034 This file is used to log Angel Debugger Protocol packets.\n\
1035 With a single argument, sets the logfile name to that value.\n\
1036 Without an argument, shows the current logfile name.\n\
1037 See also: rdilogenable\n",
1040 add_cmd ("rdilogenable", class_maintenance,
1041 rdilogenable_command,
1042 "Set enable logging of ADP packets.\n\
1043 This will log ADP packets exchanged between gdb and the\n\
1044 rdi target device.\n\
1045 An argument of 1,t,true,y,yes will enable.\n\
1046 An argument of 0,f,false,n,no will disabled.\n\
1047 Withough an argument, it will display current state.\n",
1051 (add_set_cmd ("rdiromatzero", no_class,
1052 var_boolean, (char *) &rom_at_zero,
1053 "Set target has ROM at addr 0.\n\
1054 A true value disables vector catching, false enables vector catching.\n\
1055 This is evaluated at the time the 'target rdi' command is executed\n",
1060 (add_set_cmd ("rdiheartbeat", no_class,
1061 var_boolean, (char *) &rdi_heartbeat,
1062 "Set enable for ADP heartbeat packets.\n\
1063 I don't know why you would want this. If you enable them,\n\
1064 it will confuse ARM and EPI JTAG interface boxes as well\n\
1065 as the Angel Monitor.\n",
1070 /* A little dummy to make linking with the library succeed. */