1 /* GNU/Linux/MIPS specific low level interface, for the remote server for GDB.
2 Copyright (C) 1995-2020 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 /* Linux target op definitions for the MIPS architecture. */
30 class mips_target
: public linux_process_target
34 const regs_info
*get_regs_info () override
;
38 void low_arch_setup () override
;
40 bool low_cannot_fetch_register (int regno
) override
;
42 bool low_cannot_store_register (int regno
) override
;
44 bool low_fetch_register (regcache
*regcache
, int regno
) override
;
46 bool low_supports_breakpoints () override
;
48 CORE_ADDR
low_get_pc (regcache
*regcache
) override
;
50 void low_set_pc (regcache
*regcache
, CORE_ADDR newpc
) override
;
53 /* The singleton target ops object. */
55 static mips_target the_mips_target
;
57 /* Defined in auto-generated file mips-linux.c. */
58 void init_registers_mips_linux (void);
59 extern const struct target_desc
*tdesc_mips_linux
;
61 /* Defined in auto-generated file mips-dsp-linux.c. */
62 void init_registers_mips_dsp_linux (void);
63 extern const struct target_desc
*tdesc_mips_dsp_linux
;
65 /* Defined in auto-generated file mips64-linux.c. */
66 void init_registers_mips64_linux (void);
67 extern const struct target_desc
*tdesc_mips64_linux
;
69 /* Defined in auto-generated file mips64-dsp-linux.c. */
70 void init_registers_mips64_dsp_linux (void);
71 extern const struct target_desc
*tdesc_mips64_dsp_linux
;
74 #define tdesc_mips_linux tdesc_mips64_linux
75 #define tdesc_mips_dsp_linux tdesc_mips64_dsp_linux
78 #ifndef PTRACE_GET_THREAD_AREA
79 #define PTRACE_GET_THREAD_AREA 25
86 #define mips_num_regs 73
87 #define mips_dsp_num_regs 80
89 #include <asm/ptrace.h>
93 #define DSP_CONTROL 77
100 /* Deliberately signed, for proper sign extension. */
105 /* Return the ptrace ``address'' of register REGNO. */
107 #define mips_base_regs \
108 -1, 1, 2, 3, 4, 5, 6, 7, \
109 8, 9, 10, 11, 12, 13, 14, 15, \
110 16, 17, 18, 19, 20, 21, 22, 23, \
111 24, 25, 26, 27, 28, 29, 30, 31, \
113 -1, MMLO, MMHI, BADVADDR, CAUSE, PC, \
115 FPR_BASE, FPR_BASE + 1, FPR_BASE + 2, FPR_BASE + 3, \
116 FPR_BASE + 4, FPR_BASE + 5, FPR_BASE + 6, FPR_BASE + 7, \
117 FPR_BASE + 8, FPR_BASE + 9, FPR_BASE + 10, FPR_BASE + 11, \
118 FPR_BASE + 12, FPR_BASE + 13, FPR_BASE + 14, FPR_BASE + 15, \
119 FPR_BASE + 16, FPR_BASE + 17, FPR_BASE + 18, FPR_BASE + 19, \
120 FPR_BASE + 20, FPR_BASE + 21, FPR_BASE + 22, FPR_BASE + 23, \
121 FPR_BASE + 24, FPR_BASE + 25, FPR_BASE + 26, FPR_BASE + 27, \
122 FPR_BASE + 28, FPR_BASE + 29, FPR_BASE + 30, FPR_BASE + 31, \
125 #define mips_dsp_regs \
126 DSP_BASE, DSP_BASE + 1, DSP_BASE + 2, DSP_BASE + 3, \
127 DSP_BASE + 4, DSP_BASE + 5, \
130 static int mips_regmap
[mips_num_regs
] = {
135 static int mips_dsp_regmap
[mips_dsp_num_regs
] = {
141 /* DSP registers are not in any regset and can only be accessed
144 static unsigned char mips_dsp_regset_bitmap
[(mips_dsp_num_regs
+ 7) / 8] = {
145 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x80
148 static int have_dsp
= -1;
150 /* Try peeking at an arbitrarily chosen DSP register and pick the available
151 user register set accordingly. */
153 static const struct target_desc
*
154 mips_read_description (void)
158 int pid
= lwpid_of (current_thread
);
161 ptrace (PTRACE_PEEKUSER
, pid
, DSP_CONTROL
, 0);
171 perror_with_name ("ptrace");
176 return have_dsp
? tdesc_mips_dsp_linux
: tdesc_mips_linux
;
180 mips_target::low_arch_setup ()
182 current_process ()->tdesc
= mips_read_description ();
185 /* Per-process arch-specific data we want to keep. */
187 struct arch_process_info
189 /* -1 if the kernel and/or CPU do not support watch registers.
190 1 if watch_readback is valid and we can read style, num_valid
192 0 if we need to read the watch_readback. */
194 int watch_readback_valid
;
196 /* Cached watch register read values. */
198 struct pt_watch_regs watch_readback
;
200 /* Current watchpoint requests for this process. */
202 struct mips_watchpoint
*current_watches
;
204 /* The current set of watch register values for writing the
207 struct pt_watch_regs watch_mirror
;
210 /* Per-thread arch-specific data we want to keep. */
214 /* Non-zero if our copy differs from what's recorded in the thread. */
215 int watch_registers_changed
;
218 /* From mips-linux-nat.c. */
220 /* Pseudo registers can not be read. ptrace does not provide a way to
221 read (or set) PS_REGNUM, and there's no point in reading or setting
222 ZERO_REGNUM, it's always 0. We also can not set BADVADDR, CAUSE,
223 or FCRIR via ptrace(). */
226 mips_target::low_cannot_fetch_register (int regno
)
228 const struct target_desc
*tdesc
;
230 if (get_regs_info ()->usrregs
->regmap
[regno
] == -1)
233 tdesc
= current_process ()->tdesc
;
235 /* On n32 we can't access 64-bit registers via PTRACE_PEEKUSR. */
236 if (register_size (tdesc
, regno
) > sizeof (PTRACE_XFER_TYPE
))
239 if (find_regno (tdesc
, "r0") == regno
)
246 mips_target::low_cannot_store_register (int regno
)
248 const struct target_desc
*tdesc
;
250 if (get_regs_info ()->usrregs
->regmap
[regno
] == -1)
253 tdesc
= current_process ()->tdesc
;
255 /* On n32 we can't access 64-bit registers via PTRACE_POKEUSR. */
256 if (register_size (tdesc
, regno
) > sizeof (PTRACE_XFER_TYPE
))
259 if (find_regno (tdesc
, "r0") == regno
)
262 if (find_regno (tdesc
, "cause") == regno
)
265 if (find_regno (tdesc
, "badvaddr") == regno
)
268 if (find_regno (tdesc
, "fir") == regno
)
275 mips_target::low_fetch_register (regcache
*regcache
, int regno
)
277 const struct target_desc
*tdesc
= current_process ()->tdesc
;
279 if (find_regno (tdesc
, "r0") == regno
)
281 supply_register_zeroed (regcache
, regno
);
289 mips_target::low_supports_breakpoints ()
295 mips_target::low_get_pc (regcache
*regcache
)
297 union mips_register pc
;
298 collect_register_by_name (regcache
, "pc", pc
.buf
);
299 return register_size (regcache
->tdesc
, 0) == 4 ? pc
.reg32
: pc
.reg64
;
303 mips_target::low_set_pc (regcache
*regcache
, CORE_ADDR pc
)
305 union mips_register newpc
;
306 if (register_size (regcache
->tdesc
, 0) == 4)
311 supply_register_by_name (regcache
, "pc", newpc
.buf
);
314 /* Correct in either endianness. */
315 static const unsigned int mips_breakpoint
= 0x0005000d;
316 #define mips_breakpoint_len 4
318 /* Implementation of linux_target_ops method "sw_breakpoint_from_kind". */
320 static const gdb_byte
*
321 mips_sw_breakpoint_from_kind (int kind
, int *size
)
323 *size
= mips_breakpoint_len
;
324 return (const gdb_byte
*) &mips_breakpoint
;
328 mips_breakpoint_at (CORE_ADDR where
)
332 the_target
->read_memory (where
, (unsigned char *) &insn
, 4);
333 if (insn
== mips_breakpoint
)
336 /* If necessary, recognize more trap instructions here. GDB only uses the
341 /* Mark the watch registers of lwp, represented by ENTRY, as changed. */
344 update_watch_registers_callback (thread_info
*thread
)
346 struct lwp_info
*lwp
= get_thread_lwp (thread
);
348 /* The actual update is done later just before resuming the lwp,
349 we just mark that the registers need updating. */
350 lwp
->arch_private
->watch_registers_changed
= 1;
352 /* If the lwp isn't stopped, force it to momentarily pause, so
353 we can update its watch registers. */
355 linux_stop_lwp (lwp
);
358 /* This is the implementation of linux_target_ops method
361 static struct arch_process_info
*
362 mips_linux_new_process (void)
364 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
369 /* This is the implementation of linux_target_ops method
373 mips_linux_delete_process (struct arch_process_info
*info
)
378 /* This is the implementation of linux_target_ops method new_thread.
379 Mark the watch registers as changed, so the threads' copies will
383 mips_linux_new_thread (struct lwp_info
*lwp
)
385 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
387 info
->watch_registers_changed
= 1;
389 lwp
->arch_private
= info
;
392 /* Function to call when a thread is being deleted. */
395 mips_linux_delete_thread (struct arch_lwp_info
*arch_lwp
)
400 /* Create a new mips_watchpoint and add it to the list. */
403 mips_add_watchpoint (struct arch_process_info
*priv
, CORE_ADDR addr
, int len
,
404 enum target_hw_bp_type watch_type
)
406 struct mips_watchpoint
*new_watch
;
407 struct mips_watchpoint
**pw
;
409 new_watch
= XNEW (struct mips_watchpoint
);
410 new_watch
->addr
= addr
;
411 new_watch
->len
= len
;
412 new_watch
->type
= watch_type
;
413 new_watch
->next
= NULL
;
415 pw
= &priv
->current_watches
;
421 /* Hook to call when a new fork is attached. */
424 mips_linux_new_fork (struct process_info
*parent
,
425 struct process_info
*child
)
427 struct arch_process_info
*parent_private
;
428 struct arch_process_info
*child_private
;
429 struct mips_watchpoint
*wp
;
431 /* These are allocated by linux_add_process. */
432 gdb_assert (parent
->priv
!= NULL
433 && parent
->priv
->arch_private
!= NULL
);
434 gdb_assert (child
->priv
!= NULL
435 && child
->priv
->arch_private
!= NULL
);
437 /* Linux kernel before 2.6.33 commit
438 72f674d203cd230426437cdcf7dd6f681dad8b0d
439 will inherit hardware debug registers from parent
440 on fork/vfork/clone. Newer Linux kernels create such tasks with
441 zeroed debug registers.
443 GDB core assumes the child inherits the watchpoints/hw
444 breakpoints of the parent, and will remove them all from the
445 forked off process. Copy the debug registers mirrors into the
446 new process so that all breakpoints and watchpoints can be
447 removed together. The debug registers mirror will become zeroed
448 in the end before detaching the forked off process, thus making
449 this compatible with older Linux kernels too. */
451 parent_private
= parent
->priv
->arch_private
;
452 child_private
= child
->priv
->arch_private
;
454 child_private
->watch_readback_valid
= parent_private
->watch_readback_valid
;
455 child_private
->watch_readback
= parent_private
->watch_readback
;
457 for (wp
= parent_private
->current_watches
; wp
!= NULL
; wp
= wp
->next
)
458 mips_add_watchpoint (child_private
, wp
->addr
, wp
->len
, wp
->type
);
460 child_private
->watch_mirror
= parent_private
->watch_mirror
;
462 /* This is the implementation of linux_target_ops method
463 prepare_to_resume. If the watch regs have changed, update the
467 mips_linux_prepare_to_resume (struct lwp_info
*lwp
)
469 ptid_t ptid
= ptid_of (get_lwp_thread (lwp
));
470 struct process_info
*proc
= find_process_pid (ptid
.pid ());
471 struct arch_process_info
*priv
= proc
->priv
->arch_private
;
473 if (lwp
->arch_private
->watch_registers_changed
)
475 /* Only update the watch registers if we have set or unset a
476 watchpoint already. */
477 if (mips_linux_watch_get_num_valid (&priv
->watch_mirror
) > 0)
479 /* Write the mirrored watch register values. */
480 int tid
= ptid
.lwp ();
482 if (-1 == ptrace (PTRACE_SET_WATCH_REGS
, tid
,
483 &priv
->watch_mirror
, NULL
))
484 perror_with_name ("Couldn't write watch register");
487 lwp
->arch_private
->watch_registers_changed
= 0;
492 mips_supports_z_point_type (char z_type
)
496 case Z_PACKET_WRITE_WP
:
497 case Z_PACKET_READ_WP
:
498 case Z_PACKET_ACCESS_WP
:
505 /* This is the implementation of linux_target_ops method
509 mips_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
510 int len
, struct raw_breakpoint
*bp
)
512 struct process_info
*proc
= current_process ();
513 struct arch_process_info
*priv
= proc
->priv
->arch_private
;
514 struct pt_watch_regs regs
;
516 enum target_hw_bp_type watch_type
;
519 lwpid
= lwpid_of (current_thread
);
520 if (!mips_linux_read_watch_registers (lwpid
,
521 &priv
->watch_readback
,
522 &priv
->watch_readback_valid
,
529 regs
= priv
->watch_readback
;
530 /* Add the current watches. */
531 mips_linux_watch_populate_regs (priv
->current_watches
, ®s
);
533 /* Now try to add the new watch. */
534 watch_type
= raw_bkpt_type_to_target_hw_bp_type (type
);
535 irw
= mips_linux_watch_type_to_irw (watch_type
);
536 if (!mips_linux_watch_try_one_watch (®s
, addr
, len
, irw
))
539 /* It fit. Stick it on the end of the list. */
540 mips_add_watchpoint (priv
, addr
, len
, watch_type
);
542 priv
->watch_mirror
= regs
;
544 /* Only update the threads of this process. */
545 for_each_thread (proc
->pid
, update_watch_registers_callback
);
550 /* This is the implementation of linux_target_ops method
554 mips_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
555 int len
, struct raw_breakpoint
*bp
)
557 struct process_info
*proc
= current_process ();
558 struct arch_process_info
*priv
= proc
->priv
->arch_private
;
561 enum target_hw_bp_type watch_type
;
563 struct mips_watchpoint
**pw
;
564 struct mips_watchpoint
*w
;
566 /* Search for a known watch that matches. Then unlink and free it. */
567 watch_type
= raw_bkpt_type_to_target_hw_bp_type (type
);
569 pw
= &priv
->current_watches
;
572 if (w
->addr
== addr
&& w
->len
== len
&& w
->type
== watch_type
)
583 return -1; /* We don't know about it, fail doing nothing. */
585 /* At this point watch_readback is known to be valid because we
586 could not have added the watch without reading it. */
587 gdb_assert (priv
->watch_readback_valid
== 1);
589 priv
->watch_mirror
= priv
->watch_readback
;
590 mips_linux_watch_populate_regs (priv
->current_watches
,
591 &priv
->watch_mirror
);
593 /* Only update the threads of this process. */
594 for_each_thread (proc
->pid
, update_watch_registers_callback
);
599 /* This is the implementation of linux_target_ops method
600 stopped_by_watchpoint. The watchhi R and W bits indicate
601 the watch register triggered. */
604 mips_stopped_by_watchpoint (void)
606 struct process_info
*proc
= current_process ();
607 struct arch_process_info
*priv
= proc
->priv
->arch_private
;
610 long lwpid
= lwpid_of (current_thread
);
612 if (!mips_linux_read_watch_registers (lwpid
,
613 &priv
->watch_readback
,
614 &priv
->watch_readback_valid
,
618 num_valid
= mips_linux_watch_get_num_valid (&priv
->watch_readback
);
620 for (n
= 0; n
< MAX_DEBUG_REGISTER
&& n
< num_valid
; n
++)
621 if (mips_linux_watch_get_watchhi (&priv
->watch_readback
, n
)
628 /* This is the implementation of linux_target_ops method
629 stopped_data_address. */
632 mips_stopped_data_address (void)
634 struct process_info
*proc
= current_process ();
635 struct arch_process_info
*priv
= proc
->priv
->arch_private
;
638 long lwpid
= lwpid_of (current_thread
);
640 /* On MIPS we don't know the low order 3 bits of the data address.
641 GDB does not support remote targets that can't report the
642 watchpoint address. So, make our best guess; return the starting
643 address of a watchpoint request which overlaps the one that
646 if (!mips_linux_read_watch_registers (lwpid
,
647 &priv
->watch_readback
,
648 &priv
->watch_readback_valid
,
652 num_valid
= mips_linux_watch_get_num_valid (&priv
->watch_readback
);
654 for (n
= 0; n
< MAX_DEBUG_REGISTER
&& n
< num_valid
; n
++)
655 if (mips_linux_watch_get_watchhi (&priv
->watch_readback
, n
)
658 CORE_ADDR t_low
, t_hi
;
660 struct mips_watchpoint
*watch
;
662 t_low
= mips_linux_watch_get_watchlo (&priv
->watch_readback
, n
);
663 t_irw
= t_low
& IRW_MASK
;
664 t_hi
= (mips_linux_watch_get_watchhi (&priv
->watch_readback
, n
)
666 t_low
&= ~(CORE_ADDR
)t_hi
;
668 for (watch
= priv
->current_watches
;
672 CORE_ADDR addr
= watch
->addr
;
673 CORE_ADDR last_byte
= addr
+ watch
->len
- 1;
675 if ((t_irw
& mips_linux_watch_type_to_irw (watch
->type
)) == 0)
677 /* Different type. */
680 /* Check for overlap of even a single byte. */
681 if (last_byte
>= t_low
&& addr
<= t_low
+ t_hi
)
686 /* Shouldn't happen. */
690 /* Fetch the thread-local storage pointer for libthread_db. */
693 ps_get_thread_area (struct ps_prochandle
*ph
,
694 lwpid_t lwpid
, int idx
, void **base
)
696 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
699 /* IDX is the bias from the thread pointer to the beginning of the
700 thread descriptor. It has to be subtracted due to implementation
701 quirks in libthread_db. */
702 *base
= (void *) ((char *)*base
- idx
);
708 mips_collect_register (struct regcache
*regcache
,
709 int use_64bit
, int regno
, union mips_register
*reg
)
711 union mips_register tmp_reg
;
715 collect_register (regcache
, regno
, &tmp_reg
.reg64
);
720 collect_register (regcache
, regno
, &tmp_reg
.reg32
);
721 reg
->reg64
= tmp_reg
.reg32
;
726 mips_supply_register (struct regcache
*regcache
,
727 int use_64bit
, int regno
, const union mips_register
*reg
)
731 /* For big-endian 32-bit targets, ignore the high four bytes of each
733 if (__BYTE_ORDER
== __BIG_ENDIAN
&& !use_64bit
)
736 supply_register (regcache
, regno
, reg
->buf
+ offset
);
739 #ifdef HAVE_PTRACE_GETREGS
742 mips_collect_register_32bit (struct regcache
*regcache
,
743 int use_64bit
, int regno
, unsigned char *buf
)
745 union mips_register tmp_reg
;
748 mips_collect_register (regcache
, use_64bit
, regno
, &tmp_reg
);
749 reg32
= tmp_reg
.reg64
;
750 memcpy (buf
, ®32
, 4);
754 mips_supply_register_32bit (struct regcache
*regcache
,
755 int use_64bit
, int regno
, const unsigned char *buf
)
757 union mips_register tmp_reg
;
760 memcpy (®32
, buf
, 4);
761 tmp_reg
.reg64
= reg32
;
762 mips_supply_register (regcache
, use_64bit
, regno
, &tmp_reg
);
766 mips_fill_gregset (struct regcache
*regcache
, void *buf
)
768 union mips_register
*regset
= (union mips_register
*) buf
;
770 const struct target_desc
*tdesc
= regcache
->tdesc
;
772 use_64bit
= (register_size (tdesc
, 0) == 8);
774 for (i
= 1; i
< 32; i
++)
775 mips_collect_register (regcache
, use_64bit
, i
, regset
+ i
);
777 mips_collect_register (regcache
, use_64bit
,
778 find_regno (tdesc
, "lo"), regset
+ 32);
779 mips_collect_register (regcache
, use_64bit
,
780 find_regno (tdesc
, "hi"), regset
+ 33);
781 mips_collect_register (regcache
, use_64bit
,
782 find_regno (tdesc
, "pc"), regset
+ 34);
783 mips_collect_register (regcache
, use_64bit
,
784 find_regno (tdesc
, "badvaddr"), regset
+ 35);
785 mips_collect_register (regcache
, use_64bit
,
786 find_regno (tdesc
, "status"), regset
+ 36);
787 mips_collect_register (regcache
, use_64bit
,
788 find_regno (tdesc
, "cause"), regset
+ 37);
790 mips_collect_register (regcache
, use_64bit
,
791 find_regno (tdesc
, "restart"), regset
+ 0);
795 mips_store_gregset (struct regcache
*regcache
, const void *buf
)
797 const union mips_register
*regset
= (const union mips_register
*) buf
;
800 use_64bit
= (register_size (regcache
->tdesc
, 0) == 8);
802 supply_register_by_name_zeroed (regcache
, "r0");
804 for (i
= 1; i
< 32; i
++)
805 mips_supply_register (regcache
, use_64bit
, i
, regset
+ i
);
807 mips_supply_register (regcache
, use_64bit
,
808 find_regno (regcache
->tdesc
, "lo"), regset
+ 32);
809 mips_supply_register (regcache
, use_64bit
,
810 find_regno (regcache
->tdesc
, "hi"), regset
+ 33);
811 mips_supply_register (regcache
, use_64bit
,
812 find_regno (regcache
->tdesc
, "pc"), regset
+ 34);
813 mips_supply_register (regcache
, use_64bit
,
814 find_regno (regcache
->tdesc
, "badvaddr"), regset
+ 35);
815 mips_supply_register (regcache
, use_64bit
,
816 find_regno (regcache
->tdesc
, "status"), regset
+ 36);
817 mips_supply_register (regcache
, use_64bit
,
818 find_regno (regcache
->tdesc
, "cause"), regset
+ 37);
820 mips_supply_register (regcache
, use_64bit
,
821 find_regno (regcache
->tdesc
, "restart"), regset
+ 0);
825 mips_fill_fpregset (struct regcache
*regcache
, void *buf
)
827 union mips_register
*regset
= (union mips_register
*) buf
;
828 int i
, use_64bit
, first_fp
, big_endian
;
830 use_64bit
= (register_size (regcache
->tdesc
, 0) == 8);
831 first_fp
= find_regno (regcache
->tdesc
, "f0");
832 big_endian
= (__BYTE_ORDER
== __BIG_ENDIAN
);
834 /* See GDB for a discussion of this peculiar layout. */
835 for (i
= 0; i
< 32; i
++)
837 collect_register (regcache
, first_fp
+ i
, regset
[i
].buf
);
839 collect_register (regcache
, first_fp
+ i
,
840 regset
[i
& ~1].buf
+ 4 * (big_endian
!= (i
& 1)));
842 mips_collect_register_32bit (regcache
, use_64bit
,
843 find_regno (regcache
->tdesc
, "fcsr"), regset
[32].buf
);
844 mips_collect_register_32bit (regcache
, use_64bit
,
845 find_regno (regcache
->tdesc
, "fir"),
850 mips_store_fpregset (struct regcache
*regcache
, const void *buf
)
852 const union mips_register
*regset
= (const union mips_register
*) buf
;
853 int i
, use_64bit
, first_fp
, big_endian
;
855 use_64bit
= (register_size (regcache
->tdesc
, 0) == 8);
856 first_fp
= find_regno (regcache
->tdesc
, "f0");
857 big_endian
= (__BYTE_ORDER
== __BIG_ENDIAN
);
859 /* See GDB for a discussion of this peculiar layout. */
860 for (i
= 0; i
< 32; i
++)
862 supply_register (regcache
, first_fp
+ i
, regset
[i
].buf
);
864 supply_register (regcache
, first_fp
+ i
,
865 regset
[i
& ~1].buf
+ 4 * (big_endian
!= (i
& 1)));
867 mips_supply_register_32bit (regcache
, use_64bit
,
868 find_regno (regcache
->tdesc
, "fcsr"),
870 mips_supply_register_32bit (regcache
, use_64bit
,
871 find_regno (regcache
->tdesc
, "fir"),
874 #endif /* HAVE_PTRACE_GETREGS */
876 /* Take care of 32-bit registers with 64-bit ptrace, POKEUSER side. */
879 mips_collect_ptrace_register (struct regcache
*regcache
,
880 int regno
, char *buf
)
882 int use_64bit
= sizeof (PTRACE_XFER_TYPE
) == 8;
884 if (use_64bit
&& register_size (regcache
->tdesc
, regno
) == 4)
886 union mips_register reg
;
888 mips_collect_register (regcache
, 0, regno
, ®
);
889 memcpy (buf
, ®
, sizeof (reg
));
892 collect_register (regcache
, regno
, buf
);
895 /* Take care of 32-bit registers with 64-bit ptrace, PEEKUSER side. */
898 mips_supply_ptrace_register (struct regcache
*regcache
,
899 int regno
, const char *buf
)
901 int use_64bit
= sizeof (PTRACE_XFER_TYPE
) == 8;
903 if (use_64bit
&& register_size (regcache
->tdesc
, regno
) == 4)
905 union mips_register reg
;
907 memcpy (®
, buf
, sizeof (reg
));
908 mips_supply_register (regcache
, 0, regno
, ®
);
911 supply_register (regcache
, regno
, buf
);
914 static struct regset_info mips_regsets
[] = {
915 #ifdef HAVE_PTRACE_GETREGS
916 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0, 38 * 8, GENERAL_REGS
,
917 mips_fill_gregset
, mips_store_gregset
},
918 { PTRACE_GETFPREGS
, PTRACE_SETFPREGS
, 0, 33 * 8, FP_REGS
,
919 mips_fill_fpregset
, mips_store_fpregset
},
920 #endif /* HAVE_PTRACE_GETREGS */
924 static struct regsets_info mips_regsets_info
=
926 mips_regsets
, /* regsets */
928 NULL
, /* disabled_regsets */
931 static struct usrregs_info mips_dsp_usrregs_info
=
937 static struct usrregs_info mips_usrregs_info
=
943 static struct regs_info dsp_regs_info
=
945 mips_dsp_regset_bitmap
,
946 &mips_dsp_usrregs_info
,
950 static struct regs_info myregs_info
=
952 NULL
, /* regset_bitmap */
958 mips_target::get_regs_info ()
961 return &dsp_regs_info
;
966 struct linux_target_ops the_low_target
= {
967 NULL
, /* breakpoint_kind_from_pc */
968 mips_sw_breakpoint_from_kind
,
969 NULL
, /* get_next_pcs */
972 mips_supports_z_point_type
,
975 mips_stopped_by_watchpoint
,
976 mips_stopped_data_address
,
977 mips_collect_ptrace_register
,
978 mips_supply_ptrace_register
,
979 NULL
, /* siginfo_fixup */
980 mips_linux_new_process
,
981 mips_linux_delete_process
,
982 mips_linux_new_thread
,
983 mips_linux_delete_thread
,
985 mips_linux_prepare_to_resume
988 /* The linux target ops object. */
990 linux_process_target
*the_linux_target
= &the_mips_target
;
993 initialize_low_arch (void)
995 /* Initialize the Linux target descriptions. */
996 init_registers_mips_linux ();
997 init_registers_mips_dsp_linux ();
998 init_registers_mips64_linux ();
999 init_registers_mips64_dsp_linux ();
1001 initialize_regsets_info (&mips_regsets_info
);