1 /* GDB interface to ARM RDI library.
2 Copyright 1997, 1998 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"
32 #include "gdb-stabs.h"
33 #include "gdbthread.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
PARAMS ((int));
48 /* Prototypes for local functions */
50 static void arm_rdi_files_info
PARAMS ((struct target_ops
* ignore
));
52 static int arm_rdi_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
,
53 int len
, int should_write
,
54 struct target_ops
* target
));
56 static void arm_rdi_prepare_to_store
PARAMS ((void));
58 static void arm_rdi_fetch_registers
PARAMS ((int regno
));
60 static void arm_rdi_resume
PARAMS ((int pid
, int step
,
61 enum target_signal siggnal
));
63 static int arm_rdi_start_remote
PARAMS ((char *dummy
));
65 static void arm_rdi_open
PARAMS ((char *name
, int from_tty
));
67 static void arm_rdi_create_inferior
PARAMS ((char *exec_file
, char *args
,
70 static void arm_rdi_close
PARAMS ((int quitting
));
72 static void arm_rdi_store_registers
PARAMS ((int regno
));
74 static void arm_rdi_mourn
PARAMS ((void));
76 static void arm_rdi_send
PARAMS ((char *buf
));
78 static int arm_rdi_wait
PARAMS ((int pid
, struct target_waitstatus
* status
));
80 static void arm_rdi_kill
PARAMS ((void));
82 static void arm_rdi_detach
PARAMS ((char *args
, int from_tty
));
84 static void arm_rdi_interrupt
PARAMS ((int signo
));
86 static void arm_rdi_interrupt_twice
PARAMS ((int signo
));
88 static void interrupt_query
PARAMS ((void));
90 static int arm_rdi_insert_breakpoint
PARAMS ((CORE_ADDR
, char *));
92 static int arm_rdi_remove_breakpoint
PARAMS ((CORE_ADDR
, char *));
94 static char *rdi_error_message
PARAMS ((int err
));
96 static enum target_signal rdi_error_signal
PARAMS ((int err
));
98 /* Global variables. */
100 struct target_ops arm_rdi_ops
;
102 static struct Dbg_ConfigBlock gdb_config
;
104 static struct Dbg_HostosInterface gdb_hostif
;
106 static int max_load_size
;
108 static int execute_status
;
110 /* A little list of breakpoints that have been set. */
112 static struct local_bp_list_entry
116 struct local_bp_list_entry
*next
;
121 /* Stub for catch_errors. */
124 arm_rdi_start_remote (dummy
)
130 /* Helper callbacks for the "host interface" structure. RDI functions call
131 these to forward output from the target system and so forth. */
136 fprintf_unfiltered (gdb_stdout
, "void dummy\n");
140 myprint (arg
, format
, ap
)
145 vfprintf_unfiltered (gdb_stdout
, format
, ap
);
154 fputc_unfiltered (c
, gdb_stdout
);
158 mywrite (arg
, buffer
, len
)
167 for (i
= 0; i
< len
; i
++)
169 if (isascii ((int) *e
))
171 fputc_unfiltered ((int) *e
, gdb_stdout
);
185 /* These last two are tricky as we have to handle the special case of
186 being interrupted more carefully */
192 return fgetc (stdin
);
196 mygets (arg
, buffer
, len
)
201 return fgets (buffer
, len
, stdin
);
204 /* Prevent multiple calls to angel_RDI_close(). */
205 static int closed_already
= 1;
207 /* Open a connection to a remote debugger. NAME is the filename used
208 for communication. */
211 arm_rdi_open (name
, from_tty
)
216 unsigned long arg1
, arg2
;
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 /* Make the basic low-level connection. */
224 rslt
= Adp_OpenDevice (name
, NULL
, 1);
227 error ("Could not open device \"%s\"", name
);
229 gdb_config
.bytesex
= 2 | (TARGET_BYTE_ORDER
== BIG_ENDIAN
? 1 : 0);
231 gdb_config
.rditype
= 2;
232 gdb_config
.heartbeat_on
= 1;
233 gdb_config
.flags
= 2;
235 gdb_hostif
.dbgprint
= myprint
;
236 gdb_hostif
.dbgpause
= mypause
;
237 gdb_hostif
.dbgarg
= NULL
;
238 gdb_hostif
.writec
= mywritec
;
239 gdb_hostif
.readc
= myreadc
;
240 gdb_hostif
.write
= mywrite
;
241 gdb_hostif
.gets
= mygets
;
242 gdb_hostif
.hostosarg
= NULL
;
243 gdb_hostif
.reset
= voiddummy
;
245 rslt
= angel_RDI_open (10, &gdb_config
, &gdb_hostif
, NULL
);
246 if (rslt
== RDIError_BigEndian
|| rslt
== RDIError_LittleEndian
)
247 ; /* do nothing, this is the expected return */
250 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
252 error("RID_open failed\n");
255 rslt
= angel_RDI_info (RDIInfo_Target
, &arg1
, &arg2
);
258 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
260 rslt
= angel_RDI_info (RDIInfo_Points
, &arg1
, &arg2
);
263 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
265 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
268 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
270 rslt
= angel_RDI_info (RDIInfo_CoPro
, &arg1
, &arg2
);
273 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
275 rslt
= angel_RDI_info (RDIInfo_SemiHosting
, &arg1
, &arg2
);
278 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
281 rslt
= angel_RDI_info (RDIInfo_GetLoadSize
, &arg1
, &arg2
);
284 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
286 max_load_size
= arg1
;
288 push_target (&arm_rdi_ops
);
290 target_fetch_registers (-1);
292 rslt
= angel_RDI_open (1, &gdb_config
, NULL
, NULL
);
295 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
299 rslt
= angel_RDI_info (RDIVector_Catch
, &arg1
, &arg2
);
302 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
305 arg1
= (unsigned long) "";
306 rslt
= angel_RDI_info (RDISet_Cmdline
, &arg1
, &arg2
);
309 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
312 /* Clear out any existing records of breakpoints. */
314 struct local_bp_list_entry
*entry
, *preventry
= NULL
;
316 for (entry
= local_bp_list
; entry
!= NULL
; entry
= entry
->next
)
323 printf_filtered ("Connected to ARM RDI target.\n");
328 /* Start an inferior process and set inferior_pid to its pid.
329 EXEC_FILE is the file to run.
330 ARGS is a string containing the arguments to the program.
331 ENV is the environment vector to pass. Errors reported with error().
332 On VxWorks and various standalone systems, we ignore exec_file. */
333 /* This is called not only when we first attach, but also when the
334 user types "run" after having attached. */
337 arm_rdi_create_inferior (exec_file
, args
, env
)
343 unsigned long arg1
, arg2
;
345 CORE_ADDR entry_point
;
347 if (exec_file
== 0 || exec_bfd
== 0)
348 error ("No executable file specified.");
350 entry_point
= (CORE_ADDR
) bfd_get_start_address (exec_bfd
);
353 remove_breakpoints ();
354 init_wait_for_inferior ();
356 len
= strlen (exec_file
) + 1 + strlen (args
) + 1 + /*slop */ 10;
357 arg_buf
= (char *) alloca (len
);
359 strcat (arg_buf
, exec_file
);
360 strcat (arg_buf
, " ");
361 strcat (arg_buf
, args
);
364 insert_breakpoints (); /* Needed to get correct instruction in cache */
370 if (strncmp (*env
, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
372 unsigned long top_of_memory
;
375 /* Set up memory limit */
376 top_of_memory
= strtoul (*env
+ sizeof ("MEMSIZE=") - 1,
378 printf_filtered ("Setting top-of-memory to 0x%lx\n",
381 rslt
= angel_RDI_info (RDIInfo_SetTopMem
, &top_of_memory
, &arg2
);
384 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
391 arg1
= (unsigned long) arg_buf
;
392 rslt
= angel_RDI_info (RDISet_Cmdline
, /* &arg1 */ (unsigned long *) arg_buf
, &arg2
);
395 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
398 proceed (entry_point
, TARGET_SIGNAL_DEFAULT
, 0);
401 /* This takes a program previously attached to and detaches it. After
402 this is done, GDB can be used to debug some other program. We
403 better not have left any breakpoints in the target program or it'll
404 die when it hits one. */
407 arm_rdi_detach (args
, from_tty
)
414 /* Clean up connection to a remote debugger. */
417 arm_rdi_close (quitting
)
424 rslt
= angel_RDI_close ();
427 printf_filtered ("RDI_close: %s\n", rdi_error_message (rslt
));
435 /* Tell the remote machine to resume. */
438 arm_rdi_resume (pid
, step
, siggnal
)
440 enum target_signal siggnal
;
445 if (0 /* turn on when hardware supports single-stepping */ )
447 rslt
= angel_RDI_step (1, &point
);
450 printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt
));
460 pc
= read_register (PC_REGNUM
);
461 pc
= arm_get_next_pc (pc
);
462 arm_rdi_insert_breakpoint (pc
, handle
);
464 execute_status
= rslt
= angel_RDI_execute (&point
);
465 if (rslt
== RDIError_BreakpointReached
)
469 printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt
));
473 arm_rdi_remove_breakpoint (pc
, handle
);
478 /* Send ^C to target to halt it. Target will respond, and send us a
482 arm_rdi_interrupt (signo
)
487 static void (*ofunc
) ();
489 /* The user typed ^C twice. */
491 arm_rdi_interrupt_twice (signo
)
496 /* Ask the user what to do when an interrupt is received. */
503 /* Wait until the remote machine stops, then return, storing status in
504 STATUS just as `wait' would. Returns "pid" (though it's not clear
505 what, if anything, that means in the case of this target). */
508 arm_rdi_wait (pid
, status
)
510 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
);
521 /* Read the remote registers into the block REGS. */
525 arm_rdi_fetch_registers (regno
)
528 int rslt
, rdi_regmask
;
529 unsigned long rawreg
, rawregs
[32];
534 rslt
= angel_RDI_CPUread (255, 0x27fff, rawregs
);
537 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
540 for (regno
= 0; regno
< 15; regno
++)
542 store_unsigned_integer (cookedreg
, 4, rawregs
[regno
]);
543 supply_register (regno
, (char *) cookedreg
);
545 store_unsigned_integer (cookedreg
, 4, rawregs
[15]);
546 supply_register (PS_REGNUM
, (char *) cookedreg
);
547 arm_rdi_fetch_registers (PC_REGNUM
);
551 if (regno
== PC_REGNUM
)
552 rdi_regmask
= RDIReg_PC
;
553 else if (regno
== PS_REGNUM
)
554 rdi_regmask
= RDIReg_CPSR
;
555 else if (regno
< 0 || regno
> 15)
558 supply_register (regno
, (char *) &rawreg
);
562 rdi_regmask
= 1 << regno
;
564 rslt
= angel_RDI_CPUread (255, rdi_regmask
, &rawreg
);
567 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
569 store_unsigned_integer (cookedreg
, 4, rawreg
);
570 supply_register (regno
, (char *) cookedreg
);
575 arm_rdi_prepare_to_store ()
580 /* Store register REGNO, or all registers if REGNO == -1, from the contents
581 of REGISTERS. FIXME: ignores errors. */
584 arm_rdi_store_registers (regno
)
587 int rslt
, rdi_regmask
;
589 /* These need to be able to take 'floating point register' contents */
590 unsigned long rawreg
[3], rawerreg
[3];
594 for (regno
= 0; regno
< NUM_REGS
; regno
++)
595 arm_rdi_store_registers (regno
);
599 read_register_gen (regno
, (char *) rawreg
);
600 /* RDI manipulates data in host byte order, so convert now. */
601 store_unsigned_integer (rawerreg
, 4, rawreg
[0]);
603 if (regno
== PC_REGNUM
)
604 rdi_regmask
= RDIReg_PC
;
605 else if (regno
== PS_REGNUM
)
606 rdi_regmask
= RDIReg_CPSR
;
607 else if (regno
< 0 || regno
> 15)
610 rdi_regmask
= 1 << regno
;
612 rslt
= angel_RDI_CPUwrite (255, rdi_regmask
, rawerreg
);
615 printf_filtered ("RDI_CPUwrite: %s\n", rdi_error_message (rslt
));
620 /* Read or write LEN bytes from inferior memory at MEMADDR,
621 transferring to or from debugger address MYADDR. Write to inferior
622 if SHOULD_WRITE is nonzero. Returns length of data written or
623 read; 0 for error. */
627 arm_rdi_xfer_memory (memaddr
, myaddr
, len
, should_write
, target
)
632 struct target_ops
*target
; /* ignored */
638 rslt
= angel_RDI_write (myaddr
, memaddr
, &len
);
641 printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt
));
646 rslt
= angel_RDI_read (memaddr
, myaddr
, &len
);
649 printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt
));
656 /* Display random info collected from the target. */
659 arm_rdi_files_info (ignore
)
660 struct target_ops
*ignore
;
662 char *file
= "nothing";
664 unsigned long arg1
, arg2
;
666 rslt
= angel_RDI_info (RDIInfo_Target
, &arg1
, &arg2
);
669 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
671 if (arg1
& (1 << 15))
672 printf_filtered ("Target supports Thumb code.\n");
673 if (arg1
& (1 << 14))
674 printf_filtered ("Target can do profiling.\n");
676 printf_filtered ("Target is real hardware.\n");
678 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
681 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
683 printf_filtered ("Target can%s single-step.\n", (arg1
& 0x4 ? "" : "not"));
685 rslt
= angel_RDI_info (RDIInfo_Icebreaker
, &arg1
, &arg2
);
688 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
691 printf_filtered ("Target includes an EmbeddedICE.\n");
699 rslt
= angel_RDI_open (1, &gdb_config
, NULL
, NULL
);
702 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
707 arm_rdi_mourn_inferior ()
709 unpush_target (&arm_rdi_ops
);
710 generic_mourn_inferior ();
713 /* While the RDI library keeps track of its own breakpoints, we need
714 to remember "handles" so that we can delete them later. Since
715 breakpoints get used for stepping, be careful not to leak memory
719 arm_rdi_insert_breakpoint (addr
, contents_cache
)
721 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
);
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 (addr
, contents_cache
)
747 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 (err
)
788 case RDIError_NoError
:
791 return "debuggee reset";
792 case RDIError_UndefinedInstruction
:
793 return "undefined instruction";
794 case RDIError_SoftwareInterrupt
:
795 return "SWI trapped";
796 case RDIError_PrefetchAbort
:
797 return "prefetch abort, execution ran into unmapped memory?";
798 case RDIError_DataAbort
:
799 return "data abort, no memory at specified address?";
800 case RDIError_AddressException
:
801 return "address exception, access >26bit in 26bit mode";
803 return "IRQ, interrupt trapped";
805 return "FIQ, fast interrupt trapped";
807 return "a miscellaneous type of error";
808 case RDIError_BranchThrough0
:
809 return "branch through location 0";
810 case RDIError_NotInitialised
:
811 return "internal error, RDI_open not called first";
812 case RDIError_UnableToInitialise
:
813 return "internal error, target world is broken";
814 case RDIError_WrongByteSex
:
815 return "See Operator: WrongByteSex";
816 case RDIError_UnableToTerminate
:
817 return "See Operator: Unable to Terminate";
818 case RDIError_BadInstruction
:
819 return "bad instruction, illegal to execute this instruction";
820 case RDIError_IllegalInstruction
:
821 return "illegal instruction, the effect of executing it is undefined";
822 case RDIError_BadCPUStateSetting
:
823 return "internal error, tried to set SPSR of user mode";
824 case RDIError_UnknownCoPro
:
825 return "unknown co-processor";
826 case RDIError_UnknownCoProState
:
827 return "cannot execute co-processor request";
828 case RDIError_BadCoProState
:
829 return "recognizably broken co-processor request";
830 case RDIError_BadPointType
:
831 return "internal error, bad point yype";
832 case RDIError_UnimplementedType
:
833 return "internal error, unimplemented type";
834 case RDIError_BadPointSize
:
835 return "internal error, bad point size";
836 case RDIError_UnimplementedSize
:
837 return "internal error, unimplemented size";
838 case RDIError_NoMorePoints
:
839 return "last break/watch point was used";
840 case RDIError_BreakpointReached
:
841 return "breakpoint reached";
842 case RDIError_WatchpointAccessed
:
843 return "watchpoint accessed";
844 case RDIError_NoSuchPoint
:
845 return "attempted to clear non-existent break/watch point";
846 case RDIError_ProgramFinishedInStep
:
847 return "end of the program reached while stepping";
848 case RDIError_UserInterrupt
:
849 return "you pressed Escape";
850 case RDIError_CantSetPoint
:
851 return "no more break/watch points available";
852 case RDIError_IncompatibleRDILevels
:
853 return "incompatible RDI levels";
854 case RDIError_LittleEndian
:
855 return "debuggee is little endian";
856 case RDIError_BigEndian
:
857 return "debuggee is big endian";
858 case RDIError_SoftInitialiseError
:
859 return "recoverable error in RDI initialization";
860 case RDIError_InsufficientPrivilege
:
861 return "internal error, supervisor state not accessible to monitor";
862 case RDIError_UnimplementedMessage
:
863 return "internal error, unimplemented message";
864 case RDIError_UndefinedMessage
:
865 return "internal error, undefined message";
867 return "undefined error message, should reset target";
871 /* Convert the ARM error messages to signals that GDB knows about. */
873 static enum target_signal
874 rdi_error_signal (err
)
879 case RDIError_NoError
:
882 return TARGET_SIGNAL_TERM
; /* ??? */
883 case RDIError_UndefinedInstruction
:
884 return TARGET_SIGNAL_ILL
;
885 case RDIError_SoftwareInterrupt
:
886 case RDIError_PrefetchAbort
:
887 case RDIError_DataAbort
:
888 return TARGET_SIGNAL_TRAP
;
889 case RDIError_AddressException
:
890 return TARGET_SIGNAL_SEGV
;
893 return TARGET_SIGNAL_TRAP
;
895 return TARGET_SIGNAL_TERM
;
896 case RDIError_BranchThrough0
:
897 return TARGET_SIGNAL_TRAP
;
898 case RDIError_NotInitialised
:
899 case RDIError_UnableToInitialise
:
900 case RDIError_WrongByteSex
:
901 case RDIError_UnableToTerminate
:
902 return TARGET_SIGNAL_UNKNOWN
;
903 case RDIError_BadInstruction
:
904 case RDIError_IllegalInstruction
:
905 return TARGET_SIGNAL_ILL
;
906 case RDIError_BadCPUStateSetting
:
907 case RDIError_UnknownCoPro
:
908 case RDIError_UnknownCoProState
:
909 case RDIError_BadCoProState
:
910 case RDIError_BadPointType
:
911 case RDIError_UnimplementedType
:
912 case RDIError_BadPointSize
:
913 case RDIError_UnimplementedSize
:
914 case RDIError_NoMorePoints
:
915 return TARGET_SIGNAL_UNKNOWN
;
916 case RDIError_BreakpointReached
:
917 case RDIError_WatchpointAccessed
:
918 return TARGET_SIGNAL_TRAP
;
919 case RDIError_NoSuchPoint
:
920 case RDIError_ProgramFinishedInStep
:
921 return TARGET_SIGNAL_UNKNOWN
;
922 case RDIError_UserInterrupt
:
923 return TARGET_SIGNAL_INT
;
924 case RDIError_IncompatibleRDILevels
:
925 case RDIError_LittleEndian
:
926 case RDIError_BigEndian
:
927 case RDIError_SoftInitialiseError
:
928 case RDIError_InsufficientPrivilege
:
929 case RDIError_UnimplementedMessage
:
930 case RDIError_UndefinedMessage
:
932 return TARGET_SIGNAL_UNKNOWN
;
936 /* Define the target operations structure. */
941 arm_rdi_ops
.to_shortname
= "rdi";
942 arm_rdi_ops
.to_longname
= "ARM RDI";
943 arm_rdi_ops
.to_doc
= "Use a remote ARM-based computer; via the RDI library.\n\
944 Specify the serial device it is connected to (e.g. /dev/ttya).";
945 arm_rdi_ops
.to_open
= arm_rdi_open
;
946 arm_rdi_ops
.to_close
= arm_rdi_close
;
947 arm_rdi_ops
.to_detach
= arm_rdi_detach
;
948 arm_rdi_ops
.to_resume
= arm_rdi_resume
;
949 arm_rdi_ops
.to_wait
= arm_rdi_wait
;
950 arm_rdi_ops
.to_fetch_registers
= arm_rdi_fetch_registers
;
951 arm_rdi_ops
.to_store_registers
= arm_rdi_store_registers
;
952 arm_rdi_ops
.to_prepare_to_store
= arm_rdi_prepare_to_store
;
953 arm_rdi_ops
.to_xfer_memory
= arm_rdi_xfer_memory
;
954 arm_rdi_ops
.to_files_info
= arm_rdi_files_info
;
955 arm_rdi_ops
.to_insert_breakpoint
= arm_rdi_insert_breakpoint
;
956 arm_rdi_ops
.to_remove_breakpoint
= arm_rdi_remove_breakpoint
;
957 arm_rdi_ops
.to_kill
= arm_rdi_kill
;
958 arm_rdi_ops
.to_load
= generic_load
;
959 arm_rdi_ops
.to_create_inferior
= arm_rdi_create_inferior
;
960 arm_rdi_ops
.to_mourn_inferior
= arm_rdi_mourn_inferior
;
961 arm_rdi_ops
.to_stratum
= process_stratum
;
962 arm_rdi_ops
.to_has_all_memory
= 1;
963 arm_rdi_ops
.to_has_memory
= 1;
964 arm_rdi_ops
.to_has_stack
= 1;
965 arm_rdi_ops
.to_has_registers
= 1;
966 arm_rdi_ops
.to_has_execution
= 1;
967 arm_rdi_ops
.to_magic
= OPS_MAGIC
;
971 _initialize_remote_rdi ()
974 add_target (&arm_rdi_ops
);
977 /* A little dummy to make linking with the library succeed. */