1 /* GNU/Linux/MIPS specific low level interface, for the remote server for GDB.
2 Copyright (C) 1995-2015 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 3 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, see <http://www.gnu.org/licenses/>. */
20 #include "linux-low.h"
22 #include "nat/gdb_ptrace.h"
25 #include "nat/mips-linux-watch.h"
26 #include "gdb_proc_service.h"
28 /* Defined in auto-generated file mips-linux.c. */
29 void init_registers_mips_linux (void);
30 extern const struct target_desc
*tdesc_mips_linux
;
32 /* Defined in auto-generated file mips-dsp-linux.c. */
33 void init_registers_mips_dsp_linux (void);
34 extern const struct target_desc
*tdesc_mips_dsp_linux
;
36 /* Defined in auto-generated file mips64-linux.c. */
37 void init_registers_mips64_linux (void);
38 extern const struct target_desc
*tdesc_mips64_linux
;
40 /* Defined in auto-generated file mips64-dsp-linux.c. */
41 void init_registers_mips64_dsp_linux (void);
42 extern const struct target_desc
*tdesc_mips64_dsp_linux
;
45 #define tdesc_mips_linux tdesc_mips64_linux
46 #define tdesc_mips_dsp_linux tdesc_mips64_dsp_linux
49 #ifndef PTRACE_GET_THREAD_AREA
50 #define PTRACE_GET_THREAD_AREA 25
57 #define mips_num_regs 73
58 #define mips_dsp_num_regs 80
60 #include <asm/ptrace.h>
64 #define DSP_CONTROL 77
71 /* Deliberately signed, for proper sign extension. */
76 /* Return the ptrace ``address'' of register REGNO. */
78 #define mips_base_regs \
79 -1, 1, 2, 3, 4, 5, 6, 7, \
80 8, 9, 10, 11, 12, 13, 14, 15, \
81 16, 17, 18, 19, 20, 21, 22, 23, \
82 24, 25, 26, 27, 28, 29, 30, 31, \
84 -1, MMLO, MMHI, BADVADDR, CAUSE, PC, \
86 FPR_BASE, FPR_BASE + 1, FPR_BASE + 2, FPR_BASE + 3, \
87 FPR_BASE + 4, FPR_BASE + 5, FPR_BASE + 6, FPR_BASE + 7, \
88 FPR_BASE + 8, FPR_BASE + 9, FPR_BASE + 10, FPR_BASE + 11, \
89 FPR_BASE + 12, FPR_BASE + 13, FPR_BASE + 14, FPR_BASE + 15, \
90 FPR_BASE + 16, FPR_BASE + 17, FPR_BASE + 18, FPR_BASE + 19, \
91 FPR_BASE + 20, FPR_BASE + 21, FPR_BASE + 22, FPR_BASE + 23, \
92 FPR_BASE + 24, FPR_BASE + 25, FPR_BASE + 26, FPR_BASE + 27, \
93 FPR_BASE + 28, FPR_BASE + 29, FPR_BASE + 30, FPR_BASE + 31, \
96 #define mips_dsp_regs \
97 DSP_BASE, DSP_BASE + 1, DSP_BASE + 2, DSP_BASE + 3, \
98 DSP_BASE + 4, DSP_BASE + 5, \
101 static int mips_regmap
[mips_num_regs
] = {
106 static int mips_dsp_regmap
[mips_dsp_num_regs
] = {
112 /* DSP registers are not in any regset and can only be accessed
115 static unsigned char mips_dsp_regset_bitmap
[(mips_dsp_num_regs
+ 7) / 8] = {
116 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x80
119 static int have_dsp
= -1;
121 /* Try peeking at an arbitrarily chosen DSP register and pick the available
122 user register set accordingly. */
124 static const struct target_desc
*
125 mips_read_description (void)
129 int pid
= lwpid_of (current_thread
);
132 ptrace (PTRACE_PEEKUSER
, pid
, DSP_CONTROL
, 0);
142 perror_with_name ("ptrace");
147 return have_dsp
? tdesc_mips_dsp_linux
: tdesc_mips_linux
;
151 mips_arch_setup (void)
153 current_process ()->tdesc
= mips_read_description ();
156 static struct usrregs_info
*
157 get_usrregs_info (void)
159 const struct regs_info
*regs_info
= the_low_target
.regs_info ();
161 return regs_info
->usrregs
;
164 /* Per-process arch-specific data we want to keep. */
166 struct arch_process_info
168 /* -1 if the kernel and/or CPU do not support watch registers.
169 1 if watch_readback is valid and we can read style, num_valid
171 0 if we need to read the watch_readback. */
173 int watch_readback_valid
;
175 /* Cached watch register read values. */
177 struct pt_watch_regs watch_readback
;
179 /* Current watchpoint requests for this process. */
181 struct mips_watchpoint
*current_watches
;
183 /* The current set of watch register values for writing the
186 struct pt_watch_regs watch_mirror
;
189 /* Per-thread arch-specific data we want to keep. */
193 /* Non-zero if our copy differs from what's recorded in the thread. */
194 int watch_registers_changed
;
197 /* From mips-linux-nat.c. */
199 /* Pseudo registers can not be read. ptrace does not provide a way to
200 read (or set) PS_REGNUM, and there's no point in reading or setting
201 ZERO_REGNUM. We also can not set BADVADDR, CAUSE, or FCRIR via
205 mips_cannot_fetch_register (int regno
)
207 const struct target_desc
*tdesc
;
209 if (get_usrregs_info ()->regmap
[regno
] == -1)
212 tdesc
= current_process ()->tdesc
;
214 if (find_regno (tdesc
, "r0") == regno
)
221 mips_cannot_store_register (int regno
)
223 const struct target_desc
*tdesc
;
225 if (get_usrregs_info ()->regmap
[regno
] == -1)
228 tdesc
= current_process ()->tdesc
;
230 if (find_regno (tdesc
, "r0") == regno
)
233 if (find_regno (tdesc
, "cause") == regno
)
236 if (find_regno (tdesc
, "badvaddr") == regno
)
239 if (find_regno (tdesc
, "fir") == regno
)
246 mips_get_pc (struct regcache
*regcache
)
248 union mips_register pc
;
249 collect_register_by_name (regcache
, "pc", pc
.buf
);
250 return register_size (regcache
->tdesc
, 0) == 4 ? pc
.reg32
: pc
.reg64
;
254 mips_set_pc (struct regcache
*regcache
, CORE_ADDR pc
)
256 union mips_register newpc
;
257 if (register_size (regcache
->tdesc
, 0) == 4)
262 supply_register_by_name (regcache
, "pc", newpc
.buf
);
265 /* Correct in either endianness. */
266 static const unsigned int mips_breakpoint
= 0x0005000d;
267 #define mips_breakpoint_len 4
269 /* Implementation of linux_target_ops method "sw_breakpoint_from_kind". */
271 static const gdb_byte
*
272 mips_sw_breakpoint_from_kind (int kind
, int *size
)
274 *size
= mips_breakpoint_len
;
275 return (const gdb_byte
*) &mips_breakpoint
;
278 /* We only place breakpoints in empty marker functions, and thread locking
279 is outside of the function. So rather than importing software single-step,
280 we can just run until exit. */
282 mips_reinsert_addr (void)
284 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
285 union mips_register ra
;
286 collect_register_by_name (regcache
, "r31", ra
.buf
);
287 return register_size (regcache
->tdesc
, 0) == 4 ? ra
.reg32
: ra
.reg64
;
291 mips_breakpoint_at (CORE_ADDR where
)
295 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
, 4);
296 if (insn
== mips_breakpoint
)
299 /* If necessary, recognize more trap instructions here. GDB only uses the
304 /* Mark the watch registers of lwp, represented by ENTRY, as changed,
305 if the lwp's process id is *PID_P. */
308 update_watch_registers_callback (struct inferior_list_entry
*entry
,
311 struct thread_info
*thread
= (struct thread_info
*) entry
;
312 struct lwp_info
*lwp
= get_thread_lwp (thread
);
313 int pid
= *(int *) pid_p
;
315 /* Only update the threads of this process. */
316 if (pid_of (thread
) == pid
)
318 /* The actual update is done later just before resuming the lwp,
319 we just mark that the registers need updating. */
320 lwp
->arch_private
->watch_registers_changed
= 1;
322 /* If the lwp isn't stopped, force it to momentarily pause, so
323 we can update its watch registers. */
325 linux_stop_lwp (lwp
);
331 /* This is the implementation of linux_target_ops method
334 static struct arch_process_info
*
335 mips_linux_new_process (void)
337 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
342 /* This is the implementation of linux_target_ops method new_thread.
343 Mark the watch registers as changed, so the threads' copies will
347 mips_linux_new_thread (struct lwp_info
*lwp
)
349 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
351 info
->watch_registers_changed
= 1;
353 lwp
->arch_private
= info
;
356 /* Create a new mips_watchpoint and add it to the list. */
359 mips_add_watchpoint (struct arch_process_info
*private, CORE_ADDR addr
,
360 int len
, int watch_type
)
362 struct mips_watchpoint
*new_watch
;
363 struct mips_watchpoint
**pw
;
365 new_watch
= XNEW (struct mips_watchpoint
);
366 new_watch
->addr
= addr
;
367 new_watch
->len
= len
;
368 new_watch
->type
= watch_type
;
369 new_watch
->next
= NULL
;
371 pw
= &private->current_watches
;
377 /* Hook to call when a new fork is attached. */
380 mips_linux_new_fork (struct process_info
*parent
,
381 struct process_info
*child
)
383 struct arch_process_info
*parent_private
;
384 struct arch_process_info
*child_private
;
385 struct mips_watchpoint
*wp
;
387 /* These are allocated by linux_add_process. */
388 gdb_assert (parent
->priv
!= NULL
389 && parent
->priv
->arch_private
!= NULL
);
390 gdb_assert (child
->priv
!= NULL
391 && child
->priv
->arch_private
!= NULL
);
393 /* Linux kernel before 2.6.33 commit
394 72f674d203cd230426437cdcf7dd6f681dad8b0d
395 will inherit hardware debug registers from parent
396 on fork/vfork/clone. Newer Linux kernels create such tasks with
397 zeroed debug registers.
399 GDB core assumes the child inherits the watchpoints/hw
400 breakpoints of the parent, and will remove them all from the
401 forked off process. Copy the debug registers mirrors into the
402 new process so that all breakpoints and watchpoints can be
403 removed together. The debug registers mirror will become zeroed
404 in the end before detaching the forked off process, thus making
405 this compatible with older Linux kernels too. */
407 parent_private
= parent
->priv
->arch_private
;
408 child_private
= child
->priv
->arch_private
;
410 child_private
->watch_readback_valid
= parent_private
->watch_readback_valid
;
411 child_private
->watch_readback
= parent_private
->watch_readback
;
413 for (wp
= parent_private
->current_watches
; wp
!= NULL
; wp
= wp
->next
)
414 mips_add_watchpoint (child_private
, wp
->addr
, wp
->len
, wp
->type
);
416 child_private
->watch_mirror
= parent_private
->watch_mirror
;
418 /* This is the implementation of linux_target_ops method
419 prepare_to_resume. If the watch regs have changed, update the
423 mips_linux_prepare_to_resume (struct lwp_info
*lwp
)
425 ptid_t ptid
= ptid_of (get_lwp_thread (lwp
));
426 struct process_info
*proc
= find_process_pid (ptid_get_pid (ptid
));
427 struct arch_process_info
*priv
= proc
->priv
->arch_private
;
429 if (lwp
->arch_private
->watch_registers_changed
)
431 /* Only update the watch registers if we have set or unset a
432 watchpoint already. */
433 if (mips_linux_watch_get_num_valid (&priv
->watch_mirror
) > 0)
435 /* Write the mirrored watch register values. */
436 int tid
= ptid_get_lwp (ptid
);
438 if (-1 == ptrace (PTRACE_SET_WATCH_REGS
, tid
,
439 &priv
->watch_mirror
, NULL
))
440 perror_with_name ("Couldn't write watch register");
443 lwp
->arch_private
->watch_registers_changed
= 0;
448 mips_supports_z_point_type (char z_type
)
452 case Z_PACKET_WRITE_WP
:
453 case Z_PACKET_READ_WP
:
454 case Z_PACKET_ACCESS_WP
:
461 /* This is the implementation of linux_target_ops method
465 mips_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
466 int len
, struct raw_breakpoint
*bp
)
468 struct process_info
*proc
= current_process ();
469 struct arch_process_info
*priv
= proc
->priv
->arch_private
;
470 struct pt_watch_regs regs
;
473 enum target_hw_bp_type watch_type
;
476 lwpid
= lwpid_of (current_thread
);
477 if (!mips_linux_read_watch_registers (lwpid
,
478 &priv
->watch_readback
,
479 &priv
->watch_readback_valid
,
486 regs
= priv
->watch_readback
;
487 /* Add the current watches. */
488 mips_linux_watch_populate_regs (priv
->current_watches
, ®s
);
490 /* Now try to add the new watch. */
491 watch_type
= raw_bkpt_type_to_target_hw_bp_type (type
);
492 irw
= mips_linux_watch_type_to_irw (watch_type
);
493 if (!mips_linux_watch_try_one_watch (®s
, addr
, len
, irw
))
496 /* It fit. Stick it on the end of the list. */
497 mips_add_watchpoint (priv
, addr
, len
, watch_type
);
499 priv
->watch_mirror
= regs
;
501 /* Only update the threads of this process. */
503 find_inferior (&all_threads
, update_watch_registers_callback
, &pid
);
508 /* This is the implementation of linux_target_ops method
512 mips_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
513 int len
, struct raw_breakpoint
*bp
)
515 struct process_info
*proc
= current_process ();
516 struct arch_process_info
*priv
= proc
->priv
->arch_private
;
520 enum target_hw_bp_type watch_type
;
522 struct mips_watchpoint
**pw
;
523 struct mips_watchpoint
*w
;
525 /* Search for a known watch that matches. Then unlink and free it. */
526 watch_type
= raw_bkpt_type_to_target_hw_bp_type (type
);
528 pw
= &priv
->current_watches
;
531 if (w
->addr
== addr
&& w
->len
== len
&& w
->type
== watch_type
)
542 return -1; /* We don't know about it, fail doing nothing. */
544 /* At this point watch_readback is known to be valid because we
545 could not have added the watch without reading it. */
546 gdb_assert (priv
->watch_readback_valid
== 1);
548 priv
->watch_mirror
= priv
->watch_readback
;
549 mips_linux_watch_populate_regs (priv
->current_watches
,
550 &priv
->watch_mirror
);
552 /* Only update the threads of this process. */
554 find_inferior (&all_threads
, update_watch_registers_callback
, &pid
);
558 /* This is the implementation of linux_target_ops method
559 stopped_by_watchpoint. The watchhi R and W bits indicate
560 the watch register triggered. */
563 mips_stopped_by_watchpoint (void)
565 struct process_info
*proc
= current_process ();
566 struct arch_process_info
*priv
= proc
->priv
->arch_private
;
569 long lwpid
= lwpid_of (current_thread
);
571 if (!mips_linux_read_watch_registers (lwpid
,
572 &priv
->watch_readback
,
573 &priv
->watch_readback_valid
,
577 num_valid
= mips_linux_watch_get_num_valid (&priv
->watch_readback
);
579 for (n
= 0; n
< MAX_DEBUG_REGISTER
&& n
< num_valid
; n
++)
580 if (mips_linux_watch_get_watchhi (&priv
->watch_readback
, n
)
587 /* This is the implementation of linux_target_ops method
588 stopped_data_address. */
591 mips_stopped_data_address (void)
593 struct process_info
*proc
= current_process ();
594 struct arch_process_info
*priv
= proc
->priv
->arch_private
;
597 long lwpid
= lwpid_of (current_thread
);
599 /* On MIPS we don't know the low order 3 bits of the data address.
600 GDB does not support remote targets that can't report the
601 watchpoint address. So, make our best guess; return the starting
602 address of a watchpoint request which overlaps the one that
605 if (!mips_linux_read_watch_registers (lwpid
,
606 &priv
->watch_readback
,
607 &priv
->watch_readback_valid
,
611 num_valid
= mips_linux_watch_get_num_valid (&priv
->watch_readback
);
613 for (n
= 0; n
< MAX_DEBUG_REGISTER
&& n
< num_valid
; n
++)
614 if (mips_linux_watch_get_watchhi (&priv
->watch_readback
, n
)
617 CORE_ADDR t_low
, t_hi
;
619 struct mips_watchpoint
*watch
;
621 t_low
= mips_linux_watch_get_watchlo (&priv
->watch_readback
, n
);
622 t_irw
= t_low
& IRW_MASK
;
623 t_hi
= (mips_linux_watch_get_watchhi (&priv
->watch_readback
, n
)
625 t_low
&= ~(CORE_ADDR
)t_hi
;
627 for (watch
= priv
->current_watches
;
631 CORE_ADDR addr
= watch
->addr
;
632 CORE_ADDR last_byte
= addr
+ watch
->len
- 1;
634 if ((t_irw
& mips_linux_watch_type_to_irw (watch
->type
)) == 0)
636 /* Different type. */
639 /* Check for overlap of even a single byte. */
640 if (last_byte
>= t_low
&& addr
<= t_low
+ t_hi
)
645 /* Shouldn't happen. */
649 /* Fetch the thread-local storage pointer for libthread_db. */
652 ps_get_thread_area (const struct ps_prochandle
*ph
,
653 lwpid_t lwpid
, int idx
, void **base
)
655 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
658 /* IDX is the bias from the thread pointer to the beginning of the
659 thread descriptor. It has to be subtracted due to implementation
660 quirks in libthread_db. */
661 *base
= (void *) ((char *)*base
- idx
);
666 #ifdef HAVE_PTRACE_GETREGS
669 mips_collect_register (struct regcache
*regcache
,
670 int use_64bit
, int regno
, union mips_register
*reg
)
672 union mips_register tmp_reg
;
676 collect_register (regcache
, regno
, &tmp_reg
.reg64
);
681 collect_register (regcache
, regno
, &tmp_reg
.reg32
);
682 reg
->reg64
= tmp_reg
.reg32
;
687 mips_supply_register (struct regcache
*regcache
,
688 int use_64bit
, int regno
, const union mips_register
*reg
)
692 /* For big-endian 32-bit targets, ignore the high four bytes of each
694 if (__BYTE_ORDER
== __BIG_ENDIAN
&& !use_64bit
)
697 supply_register (regcache
, regno
, reg
->buf
+ offset
);
701 mips_collect_register_32bit (struct regcache
*regcache
,
702 int use_64bit
, int regno
, unsigned char *buf
)
704 union mips_register tmp_reg
;
707 mips_collect_register (regcache
, use_64bit
, regno
, &tmp_reg
);
708 reg32
= tmp_reg
.reg64
;
709 memcpy (buf
, ®32
, 4);
713 mips_supply_register_32bit (struct regcache
*regcache
,
714 int use_64bit
, int regno
, const unsigned char *buf
)
716 union mips_register tmp_reg
;
719 memcpy (®32
, buf
, 4);
720 tmp_reg
.reg64
= reg32
;
721 mips_supply_register (regcache
, use_64bit
, regno
, &tmp_reg
);
725 mips_fill_gregset (struct regcache
*regcache
, void *buf
)
727 union mips_register
*regset
= buf
;
729 const struct target_desc
*tdesc
= regcache
->tdesc
;
731 use_64bit
= (register_size (tdesc
, 0) == 8);
733 for (i
= 1; i
< 32; i
++)
734 mips_collect_register (regcache
, use_64bit
, i
, regset
+ i
);
736 mips_collect_register (regcache
, use_64bit
,
737 find_regno (tdesc
, "lo"), regset
+ 32);
738 mips_collect_register (regcache
, use_64bit
,
739 find_regno (tdesc
, "hi"), regset
+ 33);
740 mips_collect_register (regcache
, use_64bit
,
741 find_regno (tdesc
, "pc"), regset
+ 34);
742 mips_collect_register (regcache
, use_64bit
,
743 find_regno (tdesc
, "badvaddr"), regset
+ 35);
744 mips_collect_register (regcache
, use_64bit
,
745 find_regno (tdesc
, "status"), regset
+ 36);
746 mips_collect_register (regcache
, use_64bit
,
747 find_regno (tdesc
, "cause"), regset
+ 37);
749 mips_collect_register (regcache
, use_64bit
,
750 find_regno (tdesc
, "restart"), regset
+ 0);
754 mips_store_gregset (struct regcache
*regcache
, const void *buf
)
756 const union mips_register
*regset
= buf
;
759 use_64bit
= (register_size (regcache
->tdesc
, 0) == 8);
761 for (i
= 0; i
< 32; i
++)
762 mips_supply_register (regcache
, use_64bit
, i
, regset
+ i
);
764 mips_supply_register (regcache
, use_64bit
,
765 find_regno (regcache
->tdesc
, "lo"), regset
+ 32);
766 mips_supply_register (regcache
, use_64bit
,
767 find_regno (regcache
->tdesc
, "hi"), regset
+ 33);
768 mips_supply_register (regcache
, use_64bit
,
769 find_regno (regcache
->tdesc
, "pc"), regset
+ 34);
770 mips_supply_register (regcache
, use_64bit
,
771 find_regno (regcache
->tdesc
, "badvaddr"), regset
+ 35);
772 mips_supply_register (regcache
, use_64bit
,
773 find_regno (regcache
->tdesc
, "status"), regset
+ 36);
774 mips_supply_register (regcache
, use_64bit
,
775 find_regno (regcache
->tdesc
, "cause"), regset
+ 37);
777 mips_supply_register (regcache
, use_64bit
,
778 find_regno (regcache
->tdesc
, "restart"), regset
+ 0);
782 mips_fill_fpregset (struct regcache
*regcache
, void *buf
)
784 union mips_register
*regset
= buf
;
785 int i
, use_64bit
, first_fp
, big_endian
;
787 use_64bit
= (register_size (regcache
->tdesc
, 0) == 8);
788 first_fp
= find_regno (regcache
->tdesc
, "f0");
789 big_endian
= (__BYTE_ORDER
== __BIG_ENDIAN
);
791 /* See GDB for a discussion of this peculiar layout. */
792 for (i
= 0; i
< 32; i
++)
794 collect_register (regcache
, first_fp
+ i
, regset
[i
].buf
);
796 collect_register (regcache
, first_fp
+ i
,
797 regset
[i
& ~1].buf
+ 4 * (big_endian
!= (i
& 1)));
799 mips_collect_register_32bit (regcache
, use_64bit
,
800 find_regno (regcache
->tdesc
, "fcsr"), regset
[32].buf
);
801 mips_collect_register_32bit (regcache
, use_64bit
,
802 find_regno (regcache
->tdesc
, "fir"),
807 mips_store_fpregset (struct regcache
*regcache
, const void *buf
)
809 const union mips_register
*regset
= buf
;
810 int i
, use_64bit
, first_fp
, big_endian
;
812 use_64bit
= (register_size (regcache
->tdesc
, 0) == 8);
813 first_fp
= find_regno (regcache
->tdesc
, "f0");
814 big_endian
= (__BYTE_ORDER
== __BIG_ENDIAN
);
816 /* See GDB for a discussion of this peculiar layout. */
817 for (i
= 0; i
< 32; i
++)
819 supply_register (regcache
, first_fp
+ i
, regset
[i
].buf
);
821 supply_register (regcache
, first_fp
+ i
,
822 regset
[i
& ~1].buf
+ 4 * (big_endian
!= (i
& 1)));
824 mips_supply_register_32bit (regcache
, use_64bit
,
825 find_regno (regcache
->tdesc
, "fcsr"),
827 mips_supply_register_32bit (regcache
, use_64bit
,
828 find_regno (regcache
->tdesc
, "fir"),
831 #endif /* HAVE_PTRACE_GETREGS */
833 static struct regset_info mips_regsets
[] = {
834 #ifdef HAVE_PTRACE_GETREGS
835 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0, 38 * 8, GENERAL_REGS
,
836 mips_fill_gregset
, mips_store_gregset
},
837 { PTRACE_GETFPREGS
, PTRACE_SETFPREGS
, 0, 33 * 8, FP_REGS
,
838 mips_fill_fpregset
, mips_store_fpregset
},
839 #endif /* HAVE_PTRACE_GETREGS */
843 static struct regsets_info mips_regsets_info
=
845 mips_regsets
, /* regsets */
847 NULL
, /* disabled_regsets */
850 static struct usrregs_info mips_dsp_usrregs_info
=
856 static struct usrregs_info mips_usrregs_info
=
862 static struct regs_info dsp_regs_info
=
864 mips_dsp_regset_bitmap
,
865 &mips_dsp_usrregs_info
,
869 static struct regs_info regs_info
=
871 NULL
, /* regset_bitmap */
876 static const struct regs_info
*
877 mips_regs_info (void)
880 return &dsp_regs_info
;
885 struct linux_target_ops the_low_target
= {
888 mips_cannot_fetch_register
,
889 mips_cannot_store_register
,
890 NULL
, /* fetch_register */
893 NULL
, /* breakpoint_kind_from_pc */
894 mips_sw_breakpoint_from_kind
,
898 mips_supports_z_point_type
,
901 mips_stopped_by_watchpoint
,
902 mips_stopped_data_address
,
905 NULL
, /* siginfo_fixup */
906 mips_linux_new_process
,
907 mips_linux_new_thread
,
909 mips_linux_prepare_to_resume
913 initialize_low_arch (void)
915 /* Initialize the Linux target descriptions. */
916 init_registers_mips_linux ();
917 init_registers_mips_dsp_linux ();
918 init_registers_mips64_linux ();
919 init_registers_mips64_dsp_linux ();
921 initialize_regsets_info (&mips_regsets_info
);