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
));
253 rslt
= angel_RDI_info (RDIInfo_Target
, &arg1
, &arg2
);
256 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
258 rslt
= angel_RDI_info (RDIInfo_Points
, &arg1
, &arg2
);
261 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
263 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
266 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
268 rslt
= angel_RDI_info (RDIInfo_CoPro
, &arg1
, &arg2
);
271 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
273 rslt
= angel_RDI_info (RDIInfo_SemiHosting
, &arg1
, &arg2
);
276 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
279 rslt
= angel_RDI_info (RDIInfo_GetLoadSize
, &arg1
, &arg2
);
282 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
284 max_load_size
= arg1
;
286 push_target (&arm_rdi_ops
);
288 target_fetch_registers (-1);
290 rslt
= angel_RDI_open (1, &gdb_config
, NULL
, NULL
);
293 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
297 rslt
= angel_RDI_info (RDIVector_Catch
, &arg1
, &arg2
);
300 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
303 arg1
= (unsigned long) "";
304 rslt
= angel_RDI_info (RDISet_Cmdline
, &arg1
, &arg2
);
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");
326 /* Start an inferior process and set inferior_pid 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 (exec_file
, args
, env
)
341 unsigned long arg1
, arg2
;
343 CORE_ADDR entry_point
;
345 if (exec_file
== 0 || exec_bfd
== 0)
346 error ("No executable file specified.");
348 entry_point
= (CORE_ADDR
) bfd_get_start_address (exec_bfd
);
351 remove_breakpoints ();
352 init_wait_for_inferior ();
354 len
= strlen (exec_file
) + 1 + strlen (args
) + 1 + /*slop */ 10;
355 arg_buf
= (char *) alloca (len
);
357 strcat (arg_buf
, exec_file
);
358 strcat (arg_buf
, " ");
359 strcat (arg_buf
, args
);
362 insert_breakpoints (); /* Needed to get correct instruction in cache */
368 if (strncmp (*env
, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
370 unsigned long top_of_memory
;
373 /* Set up memory limit */
374 top_of_memory
= strtoul (*env
+ sizeof ("MEMSIZE=") - 1,
376 printf_filtered ("Setting top-of-memory to 0x%x\n",
379 rslt
= angel_RDI_info (RDIInfo_SetTopMem
, &top_of_memory
, &arg2
);
382 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
389 arg1
= (unsigned long) arg_buf
;
390 rslt
= angel_RDI_info (RDISet_Cmdline
, /* &arg1 */ (unsigned long *) arg_buf
, &arg2
);
393 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
396 proceed (entry_point
, TARGET_SIGNAL_DEFAULT
, 0);
399 /* This takes a program previously attached to and detaches it. After
400 this is done, GDB can be used to debug some other program. We
401 better not have left any breakpoints in the target program or it'll
402 die when it hits one. */
405 arm_rdi_detach (args
, from_tty
)
412 /* Clean up connection to a remote debugger. */
415 arm_rdi_close (quitting
)
422 rslt
= angel_RDI_close ();
425 printf_filtered ("RDI_close: %s\n", rdi_error_message (rslt
));
432 /* Tell the remote machine to resume. */
435 arm_rdi_resume (pid
, step
, siggnal
)
437 enum target_signal siggnal
;
442 if (0 /* turn on when hardware supports single-stepping */ )
444 rslt
= angel_RDI_step (1, &point
);
447 printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt
));
457 pc
= read_register (PC_REGNUM
);
458 pc
= arm_get_next_pc (pc
);
459 arm_rdi_insert_breakpoint (pc
, handle
);
461 execute_status
= rslt
= angel_RDI_execute (&point
);
462 if (rslt
== RDIError_BreakpointReached
)
466 printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt
));
470 arm_rdi_remove_breakpoint (pc
, handle
);
475 /* Send ^C to target to halt it. Target will respond, and send us a
479 arm_rdi_interrupt (signo
)
484 static void (*ofunc
) ();
486 /* The user typed ^C twice. */
488 arm_rdi_interrupt_twice (signo
)
493 /* Ask the user what to do when an interrupt is received. */
500 /* Wait until the remote machine stops, then return, storing status in
501 STATUS just as `wait' would. Returns "pid" (though it's not clear
502 what, if anything, that means in the case of this target). */
505 arm_rdi_wait (pid
, status
)
507 struct target_waitstatus
*status
;
509 status
->kind
= (execute_status
== RDIError_NoError
?
510 TARGET_WAITKIND_EXITED
: TARGET_WAITKIND_STOPPED
);
512 /* convert stopped code from target into right signal */
513 status
->value
.sig
= rdi_error_signal (execute_status
);
518 /* Read the remote registers into the block REGS. */
522 arm_rdi_fetch_registers (regno
)
525 int rslt
, rdi_regmask
;
526 unsigned long rawreg
, rawregs
[32];
531 rslt
= angel_RDI_CPUread (255, 0x27fff, rawregs
);
534 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
537 for (regno
= 0; regno
< 15; regno
++)
539 store_unsigned_integer (cookedreg
, 4, rawregs
[regno
]);
540 supply_register (regno
, (char *) cookedreg
);
542 store_unsigned_integer (cookedreg
, 4, rawregs
[15]);
543 supply_register (PS_REGNUM
, (char *) cookedreg
);
544 arm_rdi_fetch_registers (PC_REGNUM
);
548 if (regno
== PC_REGNUM
)
549 rdi_regmask
= RDIReg_PC
;
550 else if (regno
== PS_REGNUM
)
551 rdi_regmask
= RDIReg_CPSR
;
552 else if (regno
< 0 || regno
> 15)
555 supply_register (regno
, (char *) &rawreg
);
559 rdi_regmask
= 1 << regno
;
561 rslt
= angel_RDI_CPUread (255, rdi_regmask
, &rawreg
);
564 printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt
));
566 store_unsigned_integer (cookedreg
, 4, rawreg
);
567 supply_register (regno
, (char *) cookedreg
);
572 arm_rdi_prepare_to_store ()
577 /* Store register REGNO, or all registers if REGNO == -1, from the contents
578 of REGISTERS. FIXME: ignores errors. */
581 arm_rdi_store_registers (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 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
== PC_REGNUM
)
601 rdi_regmask
= RDIReg_PC
;
602 else if (regno
== 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
);
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. */
624 arm_rdi_xfer_memory (memaddr
, myaddr
, len
, should_write
, target
)
629 struct target_ops
*target
; /* ignored */
635 rslt
= angel_RDI_write (myaddr
, memaddr
, &len
);
638 printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt
));
643 rslt
= angel_RDI_read (memaddr
, myaddr
, &len
);
646 printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt
));
653 /* Display random info collected from the target. */
656 arm_rdi_files_info (ignore
)
657 struct target_ops
*ignore
;
659 char *file
= "nothing";
661 unsigned long arg1
, arg2
;
663 rslt
= angel_RDI_info (RDIInfo_Target
, &arg1
, &arg2
);
666 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
668 if (arg1
& (1 << 15))
669 printf_filtered ("Target supports Thumb code.\n");
670 if (arg1
& (1 << 14))
671 printf_filtered ("Target can do profiling.\n");
673 printf_filtered ("Target is real hardware.\n");
675 rslt
= angel_RDI_info (RDIInfo_Step
, &arg1
, &arg2
);
678 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
680 printf_filtered ("Target can%s single-step.\n", (arg1
& 0x4 ? "" : "not"));
682 rslt
= angel_RDI_info (RDIInfo_Icebreaker
, &arg1
, &arg2
);
685 printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt
));
688 printf_filtered ("Target includes an EmbeddedICE.\n");
696 rslt
= angel_RDI_open (1, &gdb_config
, NULL
, NULL
);
699 printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt
));
704 arm_rdi_mourn_inferior ()
706 unpush_target (&arm_rdi_ops
);
707 generic_mourn_inferior ();
710 /* While the RDI library keeps track of its own breakpoints, we need
711 to remember "handles" so that we can delete them later. Since
712 breakpoints get used for stepping, be careful not to leak memory
716 arm_rdi_insert_breakpoint (addr
, contents_cache
)
718 char *contents_cache
;
722 struct local_bp_list_entry
*entry
;
723 int type
= RDIPoint_EQ
;
725 if (arm_pc_is_thumb (addr
) || arm_pc_is_thumb_dummy (addr
))
726 type
|= RDIPoint_16Bit
;
727 rslt
= angel_RDI_setbreak (addr
, type
, 0, &point
);
730 printf_filtered ("RDI_setbreak: %s\n", rdi_error_message (rslt
));
733 (struct local_bp_list_entry
*) xmalloc (sizeof (struct local_bp_list_entry
));
735 entry
->point
= point
;
736 entry
->next
= local_bp_list
;
737 local_bp_list
= entry
;
742 arm_rdi_remove_breakpoint (addr
, contents_cache
)
744 char *contents_cache
;
748 struct local_bp_list_entry
*entry
, *preventry
;
750 for (entry
= local_bp_list
; entry
!= NULL
; entry
= entry
->next
)
752 if (entry
->addr
== addr
)
760 rslt
= angel_RDI_clearbreak (entry
->point
);
763 printf_filtered ("RDI_clearbreak: %s\n", rdi_error_message (rslt
));
765 /* Delete the breakpoint entry locally. */
766 if (entry
== local_bp_list
)
768 local_bp_list
= entry
->next
;
772 preventry
->next
= entry
->next
;
780 rdi_error_message (err
)
785 case RDIError_NoError
:
788 return "debuggee reset";
789 case RDIError_UndefinedInstruction
:
790 return "undefined instruction";
791 case RDIError_SoftwareInterrupt
:
792 return "SWI trapped";
793 case RDIError_PrefetchAbort
:
794 return "prefetch abort, execution ran into unmapped memory?";
795 case RDIError_DataAbort
:
796 return "data abort, no memory at specified address?";
797 case RDIError_AddressException
:
798 return "address exception, access >26bit in 26bit mode";
800 return "IRQ, interrupt trapped";
802 return "FIQ, fast interrupt trapped";
804 return "a miscellaneous type of error";
805 case RDIError_BranchThrough0
:
806 return "branch through location 0";
807 case RDIError_NotInitialised
:
808 return "internal error, RDI_open not called first";
809 case RDIError_UnableToInitialise
:
810 return "internal error, target world is broken";
811 case RDIError_WrongByteSex
:
812 return "See Operator: WrongByteSex";
813 case RDIError_UnableToTerminate
:
814 return "See Operator: Unable to Terminate";
815 case RDIError_BadInstruction
:
816 return "bad instruction, illegal to execute this instruction";
817 case RDIError_IllegalInstruction
:
818 return "illegal instruction, the effect of executing it is undefined";
819 case RDIError_BadCPUStateSetting
:
820 return "internal error, tried to set SPSR of user mode";
821 case RDIError_UnknownCoPro
:
822 return "unknown co-processor";
823 case RDIError_UnknownCoProState
:
824 return "cannot execute co-processor request";
825 case RDIError_BadCoProState
:
826 return "recognizably broken co-processor request";
827 case RDIError_BadPointType
:
828 return "internal error, bad point yype";
829 case RDIError_UnimplementedType
:
830 return "internal error, unimplemented type";
831 case RDIError_BadPointSize
:
832 return "internal error, bad point size";
833 case RDIError_UnimplementedSize
:
834 return "internal error, unimplemented size";
835 case RDIError_NoMorePoints
:
836 return "last break/watch point was used";
837 case RDIError_BreakpointReached
:
838 return "breakpoint reached";
839 case RDIError_WatchpointAccessed
:
840 return "watchpoint accessed";
841 case RDIError_NoSuchPoint
:
842 return "attempted to clear non-existent break/watch point";
843 case RDIError_ProgramFinishedInStep
:
844 return "end of the program reached while stepping";
845 case RDIError_UserInterrupt
:
846 return "you pressed Escape";
847 case RDIError_CantSetPoint
:
848 return "no more break/watch points available";
849 case RDIError_IncompatibleRDILevels
:
850 return "incompatible RDI levels";
851 case RDIError_LittleEndian
:
852 return "debuggee is little endian";
853 case RDIError_BigEndian
:
854 return "debuggee is big endian";
855 case RDIError_SoftInitialiseError
:
856 return "recoverable error in RDI initialization";
857 case RDIError_InsufficientPrivilege
:
858 return "internal error, supervisor state not accessible to monitor";
859 case RDIError_UnimplementedMessage
:
860 return "internal error, unimplemented message";
861 case RDIError_UndefinedMessage
:
862 return "internal error, undefined message";
864 return "undefined error message, should reset target";
868 /* Convert the ARM error messages to signals that GDB knows about. */
870 static enum target_signal
871 rdi_error_signal (err
)
876 case RDIError_NoError
:
879 return TARGET_SIGNAL_TERM
; /* ??? */
880 case RDIError_UndefinedInstruction
:
881 return TARGET_SIGNAL_ILL
;
882 case RDIError_SoftwareInterrupt
:
883 case RDIError_PrefetchAbort
:
884 case RDIError_DataAbort
:
885 return TARGET_SIGNAL_TRAP
;
886 case RDIError_AddressException
:
887 return TARGET_SIGNAL_SEGV
;
890 return TARGET_SIGNAL_TRAP
;
892 return TARGET_SIGNAL_TERM
;
893 case RDIError_BranchThrough0
:
894 return TARGET_SIGNAL_TRAP
;
895 case RDIError_NotInitialised
:
896 case RDIError_UnableToInitialise
:
897 case RDIError_WrongByteSex
:
898 case RDIError_UnableToTerminate
:
899 return TARGET_SIGNAL_UNKNOWN
;
900 case RDIError_BadInstruction
:
901 case RDIError_IllegalInstruction
:
902 return TARGET_SIGNAL_ILL
;
903 case RDIError_BadCPUStateSetting
:
904 case RDIError_UnknownCoPro
:
905 case RDIError_UnknownCoProState
:
906 case RDIError_BadCoProState
:
907 case RDIError_BadPointType
:
908 case RDIError_UnimplementedType
:
909 case RDIError_BadPointSize
:
910 case RDIError_UnimplementedSize
:
911 case RDIError_NoMorePoints
:
912 return TARGET_SIGNAL_UNKNOWN
;
913 case RDIError_BreakpointReached
:
914 case RDIError_WatchpointAccessed
:
915 return TARGET_SIGNAL_TRAP
;
916 case RDIError_NoSuchPoint
:
917 case RDIError_ProgramFinishedInStep
:
918 return TARGET_SIGNAL_UNKNOWN
;
919 case RDIError_UserInterrupt
:
920 return TARGET_SIGNAL_INT
;
921 case RDIError_IncompatibleRDILevels
:
922 case RDIError_LittleEndian
:
923 case RDIError_BigEndian
:
924 case RDIError_SoftInitialiseError
:
925 case RDIError_InsufficientPrivilege
:
926 case RDIError_UnimplementedMessage
:
927 case RDIError_UndefinedMessage
:
929 return TARGET_SIGNAL_UNKNOWN
;
933 /* Define the target operations structure. */
938 arm_rdi_ops
.to_shortname
= "rdi";
939 arm_rdi_ops
.to_longname
= "ARM RDI";
940 arm_rdi_ops
.to_doc
= "Use a remote ARM-based computer; via the RDI library.\n\
941 Specify the serial device it is connected to (e.g. /dev/ttya).";
942 arm_rdi_ops
.to_open
= arm_rdi_open
;
943 arm_rdi_ops
.to_close
= arm_rdi_close
;
944 arm_rdi_ops
.to_detach
= arm_rdi_detach
;
945 arm_rdi_ops
.to_resume
= arm_rdi_resume
;
946 arm_rdi_ops
.to_wait
= arm_rdi_wait
;
947 arm_rdi_ops
.to_fetch_registers
= arm_rdi_fetch_registers
;
948 arm_rdi_ops
.to_store_registers
= arm_rdi_store_registers
;
949 arm_rdi_ops
.to_prepare_to_store
= arm_rdi_prepare_to_store
;
950 arm_rdi_ops
.to_xfer_memory
= arm_rdi_xfer_memory
;
951 arm_rdi_ops
.to_files_info
= arm_rdi_files_info
;
952 arm_rdi_ops
.to_insert_breakpoint
= arm_rdi_insert_breakpoint
;
953 arm_rdi_ops
.to_remove_breakpoint
= arm_rdi_remove_breakpoint
;
954 arm_rdi_ops
.to_kill
= arm_rdi_kill
;
955 arm_rdi_ops
.to_load
= generic_load
;
956 arm_rdi_ops
.to_create_inferior
= arm_rdi_create_inferior
;
957 arm_rdi_ops
.to_mourn_inferior
= arm_rdi_mourn_inferior
;
958 arm_rdi_ops
.to_stratum
= process_stratum
;
959 arm_rdi_ops
.to_has_all_memory
= 1;
960 arm_rdi_ops
.to_has_memory
= 1;
961 arm_rdi_ops
.to_has_stack
= 1;
962 arm_rdi_ops
.to_has_registers
= 1;
963 arm_rdi_ops
.to_has_execution
= 1;
964 arm_rdi_ops
.to_magic
= OPS_MAGIC
;
968 _initialize_remote_rdi ()
971 add_target (&arm_rdi_ops
);
974 /* A little dummy to make linking with the library succeed. */