1 /* Target-dependent code for GNU/Linux on MIPS processors.
3 Copyright (C) 2001, 2002, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "solib-svr4.h"
26 #include "mips-tdep.h"
27 #include "gdb_string.h"
28 #include "gdb_assert.h"
31 #include "trad-frame.h"
32 #include "tramp-frame.h"
35 #include "solib-svr4.h"
38 #include "target-descriptions.h"
39 #include "mips-linux-tdep.h"
41 static struct target_so_ops mips_svr4_so_ops
;
43 /* Figure out where the longjmp will land.
44 We expect the first arg to be a pointer to the jmp_buf structure
45 from which we extract the pc (MIPS_LINUX_JB_PC) that we will land
46 at. The pc is copied into PC. This routine returns 1 on
49 #define MIPS_LINUX_JB_ELEMENT_SIZE 4
50 #define MIPS_LINUX_JB_PC 0
53 mips_linux_get_longjmp_target (struct frame_info
*frame
, CORE_ADDR
*pc
)
56 char buf
[gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
];
58 jb_addr
= get_frame_register_unsigned (frame
, MIPS_A0_REGNUM
);
60 if (target_read_memory (jb_addr
61 + MIPS_LINUX_JB_PC
* MIPS_LINUX_JB_ELEMENT_SIZE
,
63 gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
))
66 *pc
= extract_unsigned_integer (buf
,
67 gdbarch_ptr_bit (current_gdbarch
)
73 /* Transform the bits comprising a 32-bit register to the right size
74 for regcache_raw_supply(). This is needed when mips_isa_regsize()
78 supply_32bit_reg (struct regcache
*regcache
, int regnum
, const void *addr
)
80 gdb_byte buf
[MAX_REGISTER_SIZE
];
81 store_signed_integer (buf
, register_size (current_gdbarch
, regnum
),
82 extract_signed_integer (addr
, 4));
83 regcache_raw_supply (regcache
, regnum
, buf
);
86 /* Unpack an elf_gregset_t into GDB's register cache. */
89 mips_supply_gregset (struct regcache
*regcache
,
90 const mips_elf_gregset_t
*gregsetp
)
93 const mips_elf_greg_t
*regp
= *gregsetp
;
94 char zerobuf
[MAX_REGISTER_SIZE
];
96 memset (zerobuf
, 0, MAX_REGISTER_SIZE
);
98 for (regi
= EF_REG0
+ 1; regi
<= EF_REG31
; regi
++)
99 supply_32bit_reg (regcache
, regi
- EF_REG0
, regp
+ regi
);
101 if (mips_linux_restart_reg_p (current_gdbarch
))
102 supply_32bit_reg (regcache
, MIPS_RESTART_REGNUM
, regp
+ EF_REG0
);
104 supply_32bit_reg (regcache
, mips_regnum (current_gdbarch
)->lo
,
106 supply_32bit_reg (regcache
, mips_regnum (current_gdbarch
)->hi
,
109 supply_32bit_reg (regcache
, mips_regnum (current_gdbarch
)->pc
,
111 supply_32bit_reg (regcache
, mips_regnum (current_gdbarch
)->badvaddr
,
112 regp
+ EF_CP0_BADVADDR
);
113 supply_32bit_reg (regcache
, MIPS_PS_REGNUM
, regp
+ EF_CP0_STATUS
);
114 supply_32bit_reg (regcache
, mips_regnum (current_gdbarch
)->cause
,
115 regp
+ EF_CP0_CAUSE
);
117 /* Fill inaccessible registers with zero. */
118 regcache_raw_supply (regcache
, MIPS_ZERO_REGNUM
, zerobuf
);
119 regcache_raw_supply (regcache
, MIPS_UNUSED_REGNUM
, zerobuf
);
120 for (regi
= MIPS_FIRST_EMBED_REGNUM
;
121 regi
<= MIPS_LAST_EMBED_REGNUM
;
123 regcache_raw_supply (regcache
, regi
, zerobuf
);
126 /* Pack our registers (or one register) into an elf_gregset_t. */
129 mips_fill_gregset (const struct regcache
*regcache
,
130 mips_elf_gregset_t
*gregsetp
, int regno
)
133 mips_elf_greg_t
*regp
= *gregsetp
;
138 memset (regp
, 0, sizeof (mips_elf_gregset_t
));
139 for (regi
= 1; regi
< 32; regi
++)
140 mips_fill_gregset (regcache
, gregsetp
, regi
);
141 mips_fill_gregset (regcache
, gregsetp
,
142 mips_regnum (current_gdbarch
)->lo
);
143 mips_fill_gregset (regcache
, gregsetp
,
144 mips_regnum (current_gdbarch
)->hi
);
145 mips_fill_gregset (regcache
, gregsetp
,
146 mips_regnum (current_gdbarch
)->pc
);
147 mips_fill_gregset (regcache
, gregsetp
,
148 mips_regnum (current_gdbarch
)->badvaddr
);
149 mips_fill_gregset (regcache
, gregsetp
, MIPS_PS_REGNUM
);
150 mips_fill_gregset (regcache
, gregsetp
,
151 mips_regnum (current_gdbarch
)->cause
);
152 mips_fill_gregset (regcache
, gregsetp
, MIPS_RESTART_REGNUM
);
156 if (regno
> 0 && regno
< 32)
158 dst
= regp
+ regno
+ EF_REG0
;
159 regcache_raw_collect (regcache
, regno
, dst
);
163 if (regno
== mips_regnum (current_gdbarch
)->lo
)
165 else if (regno
== mips_regnum (current_gdbarch
)->hi
)
167 else if (regno
== mips_regnum (current_gdbarch
)->pc
)
168 regaddr
= EF_CP0_EPC
;
169 else if (regno
== mips_regnum (current_gdbarch
)->badvaddr
)
170 regaddr
= EF_CP0_BADVADDR
;
171 else if (regno
== MIPS_PS_REGNUM
)
172 regaddr
= EF_CP0_STATUS
;
173 else if (regno
== mips_regnum (current_gdbarch
)->cause
)
174 regaddr
= EF_CP0_CAUSE
;
175 else if (mips_linux_restart_reg_p (current_gdbarch
)
176 && regno
== MIPS_RESTART_REGNUM
)
183 dst
= regp
+ regaddr
;
184 regcache_raw_collect (regcache
, regno
, dst
);
188 /* Likewise, unpack an elf_fpregset_t. */
191 mips_supply_fpregset (struct regcache
*regcache
,
192 const mips_elf_fpregset_t
*fpregsetp
)
195 char zerobuf
[MAX_REGISTER_SIZE
];
197 memset (zerobuf
, 0, MAX_REGISTER_SIZE
);
199 for (regi
= 0; regi
< 32; regi
++)
200 regcache_raw_supply (regcache
,
201 gdbarch_fp0_regnum (current_gdbarch
) + regi
,
204 regcache_raw_supply (regcache
,
205 mips_regnum (current_gdbarch
)->fp_control_status
,
208 /* FIXME: how can we supply FCRIR? The ABI doesn't tell us. */
209 regcache_raw_supply (regcache
,
210 mips_regnum (current_gdbarch
)->fp_implementation_revision
,
214 /* Likewise, pack one or all floating point registers into an
218 mips_fill_fpregset (const struct regcache
*regcache
,
219 mips_elf_fpregset_t
*fpregsetp
, int regno
)
223 if ((regno
>= gdbarch_fp0_regnum (current_gdbarch
))
224 && (regno
< gdbarch_fp0_regnum (current_gdbarch
) + 32))
226 to
= (char *) (*fpregsetp
+ regno
- gdbarch_fp0_regnum (current_gdbarch
));
227 regcache_raw_collect (regcache
, regno
, to
);
229 else if (regno
== mips_regnum (current_gdbarch
)->fp_control_status
)
231 to
= (char *) (*fpregsetp
+ 32);
232 regcache_raw_collect (regcache
, regno
, to
);
234 else if (regno
== -1)
238 for (regi
= 0; regi
< 32; regi
++)
239 mips_fill_fpregset (regcache
, fpregsetp
,
240 gdbarch_fp0_regnum (current_gdbarch
) + regi
);
241 mips_fill_fpregset (regcache
, fpregsetp
,
242 mips_regnum (current_gdbarch
)->fp_control_status
);
246 /* Support for 64-bit ABIs. */
248 /* Figure out where the longjmp will land.
249 We expect the first arg to be a pointer to the jmp_buf structure
250 from which we extract the pc (MIPS_LINUX_JB_PC) that we will land
251 at. The pc is copied into PC. This routine returns 1 on
254 /* Details about jmp_buf. */
256 #define MIPS64_LINUX_JB_PC 0
259 mips64_linux_get_longjmp_target (struct frame_info
*frame
, CORE_ADDR
*pc
)
262 void *buf
= alloca (gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
);
263 int element_size
= gdbarch_ptr_bit (current_gdbarch
) == 32 ? 4 : 8;
265 jb_addr
= get_frame_register_unsigned (frame
, MIPS_A0_REGNUM
);
267 if (target_read_memory (jb_addr
+ MIPS64_LINUX_JB_PC
* element_size
,
269 gdbarch_ptr_bit (current_gdbarch
) / TARGET_CHAR_BIT
))
272 *pc
= extract_unsigned_integer (buf
,
273 gdbarch_ptr_bit (current_gdbarch
)
279 /* Register set support functions. These operate on standard 64-bit
280 regsets, but work whether the target is 32-bit or 64-bit. A 32-bit
281 target will still use the 64-bit format for PTRACE_GETREGS. */
283 /* Supply a 64-bit register. */
286 supply_64bit_reg (struct regcache
*regcache
, int regnum
,
289 if (gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_BIG
290 && register_size (current_gdbarch
, regnum
) == 4)
291 regcache_raw_supply (regcache
, regnum
, buf
+ 4);
293 regcache_raw_supply (regcache
, regnum
, buf
);
296 /* Unpack a 64-bit elf_gregset_t into GDB's register cache. */
299 mips64_supply_gregset (struct regcache
*regcache
,
300 const mips64_elf_gregset_t
*gregsetp
)
303 const mips64_elf_greg_t
*regp
= *gregsetp
;
304 gdb_byte zerobuf
[MAX_REGISTER_SIZE
];
306 memset (zerobuf
, 0, MAX_REGISTER_SIZE
);
308 for (regi
= MIPS64_EF_REG0
+ 1; regi
<= MIPS64_EF_REG31
; regi
++)
309 supply_64bit_reg (regcache
, regi
- MIPS64_EF_REG0
,
310 (const gdb_byte
*)(regp
+ regi
));
312 if (mips_linux_restart_reg_p (current_gdbarch
))
313 supply_64bit_reg (regcache
, MIPS_RESTART_REGNUM
,
314 (const gdb_byte
*)(regp
+ MIPS64_EF_REG0
));
316 supply_64bit_reg (regcache
, mips_regnum (current_gdbarch
)->lo
,
317 (const gdb_byte
*) (regp
+ MIPS64_EF_LO
));
318 supply_64bit_reg (regcache
, mips_regnum (current_gdbarch
)->hi
,
319 (const gdb_byte
*) (regp
+ MIPS64_EF_HI
));
321 supply_64bit_reg (regcache
, mips_regnum (current_gdbarch
)->pc
,
322 (const gdb_byte
*) (regp
+ MIPS64_EF_CP0_EPC
));
323 supply_64bit_reg (regcache
, mips_regnum (current_gdbarch
)->badvaddr
,
324 (const gdb_byte
*) (regp
+ MIPS64_EF_CP0_BADVADDR
));
325 supply_64bit_reg (regcache
, MIPS_PS_REGNUM
,
326 (const gdb_byte
*) (regp
+ MIPS64_EF_CP0_STATUS
));
327 supply_64bit_reg (regcache
, mips_regnum (current_gdbarch
)->cause
,
328 (const gdb_byte
*) (regp
+ MIPS64_EF_CP0_CAUSE
));
330 /* Fill inaccessible registers with zero. */
331 regcache_raw_supply (regcache
, MIPS_ZERO_REGNUM
, zerobuf
);
332 regcache_raw_supply (regcache
, MIPS_UNUSED_REGNUM
, zerobuf
);
333 for (regi
= MIPS_FIRST_EMBED_REGNUM
;
334 regi
<= MIPS_LAST_EMBED_REGNUM
;
336 regcache_raw_supply (regcache
, regi
, zerobuf
);
339 /* Pack our registers (or one register) into a 64-bit elf_gregset_t. */
342 mips64_fill_gregset (const struct regcache
*regcache
,
343 mips64_elf_gregset_t
*gregsetp
, int regno
)
346 mips64_elf_greg_t
*regp
= *gregsetp
;
351 memset (regp
, 0, sizeof (mips64_elf_gregset_t
));
352 for (regi
= 1; regi
< 32; regi
++)
353 mips64_fill_gregset (regcache
, gregsetp
, regi
);
354 mips64_fill_gregset (regcache
, gregsetp
,
355 mips_regnum (current_gdbarch
)->lo
);
356 mips64_fill_gregset (regcache
, gregsetp
,
357 mips_regnum (current_gdbarch
)->hi
);
358 mips64_fill_gregset (regcache
, gregsetp
,
359 mips_regnum (current_gdbarch
)->pc
);
360 mips64_fill_gregset (regcache
, gregsetp
,
361 mips_regnum (current_gdbarch
)->badvaddr
);
362 mips64_fill_gregset (regcache
, gregsetp
, MIPS_PS_REGNUM
);
363 mips64_fill_gregset (regcache
, gregsetp
,
364 mips_regnum (current_gdbarch
)->cause
);
365 mips64_fill_gregset (regcache
, gregsetp
, MIPS_RESTART_REGNUM
);
369 if (regno
> 0 && regno
< 32)
370 regaddr
= regno
+ MIPS64_EF_REG0
;
371 else if (regno
== mips_regnum (current_gdbarch
)->lo
)
372 regaddr
= MIPS64_EF_LO
;
373 else if (regno
== mips_regnum (current_gdbarch
)->hi
)
374 regaddr
= MIPS64_EF_HI
;
375 else if (regno
== mips_regnum (current_gdbarch
)->pc
)
376 regaddr
= MIPS64_EF_CP0_EPC
;
377 else if (regno
== mips_regnum (current_gdbarch
)->badvaddr
)
378 regaddr
= MIPS64_EF_CP0_BADVADDR
;
379 else if (regno
== MIPS_PS_REGNUM
)
380 regaddr
= MIPS64_EF_CP0_STATUS
;
381 else if (regno
== mips_regnum (current_gdbarch
)->cause
)
382 regaddr
= MIPS64_EF_CP0_CAUSE
;
383 else if (mips_linux_restart_reg_p (current_gdbarch
)
384 && regno
== MIPS_RESTART_REGNUM
)
385 regaddr
= MIPS64_EF_REG0
;
391 gdb_byte buf
[MAX_REGISTER_SIZE
];
394 regcache_raw_collect (regcache
, regno
, buf
);
395 val
= extract_signed_integer (buf
,
396 register_size (current_gdbarch
, regno
));
397 dst
= regp
+ regaddr
;
398 store_signed_integer (dst
, 8, val
);
402 /* Likewise, unpack an elf_fpregset_t. */
405 mips64_supply_fpregset (struct regcache
*regcache
,
406 const mips64_elf_fpregset_t
*fpregsetp
)
410 /* See mips_linux_o32_sigframe_init for a description of the
411 peculiar FP register layout. */
412 if (register_size (current_gdbarch
,
413 gdbarch_fp0_regnum (current_gdbarch
)) == 4)
414 for (regi
= 0; regi
< 32; regi
++)
416 const gdb_byte
*reg_ptr
= (const gdb_byte
*)(*fpregsetp
+ (regi
& ~1));
417 if ((gdbarch_byte_order (current_gdbarch
)
418 == BFD_ENDIAN_BIG
) != (regi
& 1))
420 regcache_raw_supply (regcache
,
421 gdbarch_fp0_regnum (current_gdbarch
) + regi
,
425 for (regi
= 0; regi
< 32; regi
++)
426 regcache_raw_supply (regcache
,
427 gdbarch_fp0_regnum (current_gdbarch
) + regi
,
428 (const char *)(*fpregsetp
+ regi
));
430 supply_32bit_reg (regcache
, mips_regnum (current_gdbarch
)->fp_control_status
,
431 (const gdb_byte
*)(*fpregsetp
+ 32));
433 /* The ABI doesn't tell us how to supply FCRIR, and core dumps don't
434 include it - but the result of PTRACE_GETFPREGS does. The best we
435 can do is to assume that its value is present. */
436 supply_32bit_reg (regcache
,
437 mips_regnum (current_gdbarch
)->fp_implementation_revision
,
438 (const gdb_byte
*)(*fpregsetp
+ 32) + 4);
441 /* Likewise, pack one or all floating point registers into an
445 mips64_fill_fpregset (const struct regcache
*regcache
,
446 mips64_elf_fpregset_t
*fpregsetp
, int regno
)
450 if ((regno
>= gdbarch_fp0_regnum (current_gdbarch
))
451 && (regno
< gdbarch_fp0_regnum (current_gdbarch
) + 32))
453 /* See mips_linux_o32_sigframe_init for a description of the
454 peculiar FP register layout. */
455 if (register_size (current_gdbarch
, regno
) == 4)
457 int regi
= regno
- gdbarch_fp0_regnum (current_gdbarch
);
459 to
= (gdb_byte
*) (*fpregsetp
+ (regi
& ~1));
460 if ((gdbarch_byte_order (current_gdbarch
)
461 == BFD_ENDIAN_BIG
) != (regi
& 1))
463 regcache_raw_collect (regcache
, regno
, to
);
467 to
= (gdb_byte
*) (*fpregsetp
+ regno
468 - gdbarch_fp0_regnum (current_gdbarch
));
469 regcache_raw_collect (regcache
, regno
, to
);
472 else if (regno
== mips_regnum (current_gdbarch
)->fp_control_status
)
474 gdb_byte buf
[MAX_REGISTER_SIZE
];
477 regcache_raw_collect (regcache
, regno
, buf
);
478 val
= extract_signed_integer (buf
,
479 register_size (current_gdbarch
, regno
));
480 to
= (gdb_byte
*) (*fpregsetp
+ 32);
481 store_signed_integer (to
, 4, val
);
483 else if (regno
== mips_regnum (current_gdbarch
)->fp_implementation_revision
)
485 gdb_byte buf
[MAX_REGISTER_SIZE
];
488 regcache_raw_collect (regcache
, regno
, buf
);
489 val
= extract_signed_integer (buf
,
490 register_size (current_gdbarch
, regno
));
491 to
= (gdb_byte
*) (*fpregsetp
+ 32) + 4;
492 store_signed_integer (to
, 4, val
);
494 else if (regno
== -1)
498 for (regi
= 0; regi
< 32; regi
++)
499 mips64_fill_fpregset (regcache
, fpregsetp
,
500 gdbarch_fp0_regnum (current_gdbarch
) + regi
);
501 mips64_fill_fpregset (regcache
, fpregsetp
,
502 mips_regnum (current_gdbarch
)->fp_control_status
);
503 mips64_fill_fpregset (regcache
, fpregsetp
,
504 (mips_regnum (current_gdbarch
)
505 ->fp_implementation_revision
));
510 /* Use a local version of this function to get the correct types for
511 regsets, until multi-arch core support is ready. */
514 fetch_core_registers (struct regcache
*regcache
,
515 char *core_reg_sect
, unsigned core_reg_size
,
516 int which
, CORE_ADDR reg_addr
)
518 mips_elf_gregset_t gregset
;
519 mips_elf_fpregset_t fpregset
;
520 mips64_elf_gregset_t gregset64
;
521 mips64_elf_fpregset_t fpregset64
;
525 if (core_reg_size
== sizeof (gregset
))
527 memcpy ((char *) &gregset
, core_reg_sect
, sizeof (gregset
));
528 mips_supply_gregset (regcache
,
529 (const mips_elf_gregset_t
*) &gregset
);
531 else if (core_reg_size
== sizeof (gregset64
))
533 memcpy ((char *) &gregset64
, core_reg_sect
, sizeof (gregset64
));
534 mips64_supply_gregset (regcache
,
535 (const mips64_elf_gregset_t
*) &gregset64
);
539 warning (_("wrong size gregset struct in core file"));
544 if (core_reg_size
== sizeof (fpregset
))
546 memcpy ((char *) &fpregset
, core_reg_sect
, sizeof (fpregset
));
547 mips_supply_fpregset (regcache
,
548 (const mips_elf_fpregset_t
*) &fpregset
);
550 else if (core_reg_size
== sizeof (fpregset64
))
552 memcpy ((char *) &fpregset64
, core_reg_sect
,
553 sizeof (fpregset64
));
554 mips64_supply_fpregset (regcache
,
555 (const mips64_elf_fpregset_t
*) &fpregset64
);
559 warning (_("wrong size fpregset struct in core file"));
564 /* Register that we are able to handle ELF file formats using standard
565 procfs "regset" structures. */
567 static struct core_fns regset_core_fns
=
569 bfd_target_elf_flavour
, /* core_flavour */
570 default_check_format
, /* check_format */
571 default_core_sniffer
, /* core_sniffer */
572 fetch_core_registers
, /* core_read_registers */
576 static const struct target_desc
*
577 mips_linux_core_read_description (struct gdbarch
*gdbarch
,
578 struct target_ops
*target
,
581 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
585 switch (bfd_section_size (abfd
, section
))
587 case sizeof (mips_elf_gregset_t
):
588 return mips_tdesc_gp32
;
590 case sizeof (mips64_elf_gregset_t
):
591 return mips_tdesc_gp64
;
599 /* Check the code at PC for a dynamic linker lazy resolution stub.
600 Because they aren't in the .plt section, we pattern-match on the
601 code generated by GNU ld. They look like this:
608 (with the appropriate doubleword instructions for N64). Also
609 return the dynamic symbol index used in the last instruction. */
612 mips_linux_in_dynsym_stub (CORE_ADDR pc
, char *name
)
614 unsigned char buf
[28], *p
;
615 ULONGEST insn
, insn1
;
616 int n64
= (mips_abi (current_gdbarch
) == MIPS_ABI_N64
);
618 read_memory (pc
- 12, buf
, 28);
622 /* ld t9,0x8010(gp) */
627 /* lw t9,0x8010(gp) */
634 insn
= extract_unsigned_integer (p
, 4);
642 insn
= extract_unsigned_integer (p
+ 4, 4);
646 if (insn
!= 0x03e0782d)
652 if (insn
!= 0x03e07821)
656 insn
= extract_unsigned_integer (p
+ 8, 4);
658 if (insn
!= 0x0320f809)
661 insn
= extract_unsigned_integer (p
+ 12, 4);
664 /* daddiu t8,zero,0 */
665 if ((insn
& 0xffff0000) != 0x64180000)
670 /* addiu t8,zero,0 */
671 if ((insn
& 0xffff0000) != 0x24180000)
675 return (insn
& 0xffff);
678 /* Return non-zero iff PC belongs to the dynamic linker resolution
679 code or to a stub. */
682 mips_linux_in_dynsym_resolve_code (CORE_ADDR pc
)
684 /* Check whether PC is in the dynamic linker. This also checks
685 whether it is in the .plt section, which MIPS does not use. */
686 if (svr4_in_dynsym_resolve_code (pc
))
689 /* Pattern match for the stub. It would be nice if there were a
690 more efficient way to avoid this check. */
691 if (mips_linux_in_dynsym_stub (pc
, NULL
))
697 /* See the comments for SKIP_SOLIB_RESOLVER at the top of infrun.c,
698 and glibc_skip_solib_resolver in glibc-tdep.c. The normal glibc
699 implementation of this triggers at "fixup" from the same objfile as
700 "_dl_runtime_resolve"; MIPS GNU/Linux can trigger at
701 "__dl_runtime_resolve" directly. An unresolved PLT entry will
702 point to _dl_runtime_resolve, which will first call
703 __dl_runtime_resolve, and then pass control to the resolved
707 mips_linux_skip_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
709 struct minimal_symbol
*resolver
;
711 resolver
= lookup_minimal_symbol ("__dl_runtime_resolve", NULL
, NULL
);
713 if (resolver
&& SYMBOL_VALUE_ADDRESS (resolver
) == pc
)
714 return frame_pc_unwind (get_current_frame ());
719 /* Signal trampoline support. There are four supported layouts for a
720 signal frame: o32 sigframe, o32 rt_sigframe, n32 rt_sigframe, and
721 n64 rt_sigframe. We handle them all independently; not the most
722 efficient way, but simplest. First, declare all the unwinders. */
724 static void mips_linux_o32_sigframe_init (const struct tramp_frame
*self
,
725 struct frame_info
*next_frame
,
726 struct trad_frame_cache
*this_cache
,
729 static void mips_linux_n32n64_sigframe_init (const struct tramp_frame
*self
,
730 struct frame_info
*next_frame
,
731 struct trad_frame_cache
*this_cache
,
734 #define MIPS_NR_LINUX 4000
735 #define MIPS_NR_N64_LINUX 5000
736 #define MIPS_NR_N32_LINUX 6000
738 #define MIPS_NR_sigreturn MIPS_NR_LINUX + 119
739 #define MIPS_NR_rt_sigreturn MIPS_NR_LINUX + 193
740 #define MIPS_NR_N64_rt_sigreturn MIPS_NR_N64_LINUX + 211
741 #define MIPS_NR_N32_rt_sigreturn MIPS_NR_N32_LINUX + 211
743 #define MIPS_INST_LI_V0_SIGRETURN 0x24020000 + MIPS_NR_sigreturn
744 #define MIPS_INST_LI_V0_RT_SIGRETURN 0x24020000 + MIPS_NR_rt_sigreturn
745 #define MIPS_INST_LI_V0_N64_RT_SIGRETURN 0x24020000 + MIPS_NR_N64_rt_sigreturn
746 #define MIPS_INST_LI_V0_N32_RT_SIGRETURN 0x24020000 + MIPS_NR_N32_rt_sigreturn
747 #define MIPS_INST_SYSCALL 0x0000000c
749 static const struct tramp_frame mips_linux_o32_sigframe
= {
753 { MIPS_INST_LI_V0_SIGRETURN
, -1 },
754 { MIPS_INST_SYSCALL
, -1 },
755 { TRAMP_SENTINEL_INSN
, -1 }
757 mips_linux_o32_sigframe_init
760 static const struct tramp_frame mips_linux_o32_rt_sigframe
= {
764 { MIPS_INST_LI_V0_RT_SIGRETURN
, -1 },
765 { MIPS_INST_SYSCALL
, -1 },
766 { TRAMP_SENTINEL_INSN
, -1 } },
767 mips_linux_o32_sigframe_init
770 static const struct tramp_frame mips_linux_n32_rt_sigframe
= {
774 { MIPS_INST_LI_V0_N32_RT_SIGRETURN
, -1 },
775 { MIPS_INST_SYSCALL
, -1 },
776 { TRAMP_SENTINEL_INSN
, -1 }
778 mips_linux_n32n64_sigframe_init
781 static const struct tramp_frame mips_linux_n64_rt_sigframe
= {
785 { MIPS_INST_LI_V0_N64_RT_SIGRETURN
, -1 },
786 { MIPS_INST_SYSCALL
, -1 },
787 { TRAMP_SENTINEL_INSN
, -1 }
789 mips_linux_n32n64_sigframe_init
793 /* The unwinder for o32 signal frames. The legacy structures look
797 u32 sf_ass[4]; [argument save space for o32]
798 u32 sf_code[2]; [signal trampoline]
799 struct sigcontext sf_sc;
804 unsigned int sc_regmask; [Unused]
805 unsigned int sc_status;
806 unsigned long long sc_pc;
807 unsigned long long sc_regs[32];
808 unsigned long long sc_fpregs[32];
809 unsigned int sc_ownedfp;
810 unsigned int sc_fpc_csr;
811 unsigned int sc_fpc_eir; [Unused]
812 unsigned int sc_used_math;
813 unsigned int sc_ssflags; [Unused]
814 [Alignment hole of four bytes]
815 unsigned long long sc_mdhi;
816 unsigned long long sc_mdlo;
818 unsigned int sc_cause; [Unused]
819 unsigned int sc_badvaddr; [Unused]
821 unsigned long sc_sigset[4]; [kernel's sigset_t]
824 The RT signal frames look like this:
827 u32 rs_ass[4]; [argument save space for o32]
828 u32 rs_code[2] [signal trampoline]
829 struct siginfo rs_info;
830 struct ucontext rs_uc;
834 unsigned long uc_flags;
835 struct ucontext *uc_link;
837 [Alignment hole of four bytes]
838 struct sigcontext uc_mcontext;
843 #define SIGFRAME_CODE_OFFSET (4 * 4)
844 #define SIGFRAME_SIGCONTEXT_OFFSET (6 * 4)
846 #define RTSIGFRAME_SIGINFO_SIZE 128
847 #define STACK_T_SIZE (3 * 4)
848 #define UCONTEXT_SIGCONTEXT_OFFSET (2 * 4 + STACK_T_SIZE + 4)
849 #define RTSIGFRAME_SIGCONTEXT_OFFSET (SIGFRAME_SIGCONTEXT_OFFSET \
850 + RTSIGFRAME_SIGINFO_SIZE \
851 + UCONTEXT_SIGCONTEXT_OFFSET)
853 #define SIGCONTEXT_PC (1 * 8)
854 #define SIGCONTEXT_REGS (2 * 8)
855 #define SIGCONTEXT_FPREGS (34 * 8)
856 #define SIGCONTEXT_FPCSR (66 * 8 + 4)
857 #define SIGCONTEXT_HI (69 * 8)
858 #define SIGCONTEXT_LO (70 * 8)
859 #define SIGCONTEXT_CAUSE (71 * 8 + 0)
860 #define SIGCONTEXT_BADVADDR (71 * 8 + 4)
862 #define SIGCONTEXT_REG_SIZE 8
865 mips_linux_o32_sigframe_init (const struct tramp_frame
*self
,
866 struct frame_info
*next_frame
,
867 struct trad_frame_cache
*this_cache
,
870 int ireg
, reg_position
;
871 CORE_ADDR sigcontext_base
= func
- SIGFRAME_CODE_OFFSET
;
872 const struct mips_regnum
*regs
= mips_regnum (current_gdbarch
);
875 if (self
== &mips_linux_o32_sigframe
)
876 sigcontext_base
+= SIGFRAME_SIGCONTEXT_OFFSET
;
878 sigcontext_base
+= RTSIGFRAME_SIGCONTEXT_OFFSET
;
880 /* I'm not proud of this hack. Eventually we will have the
881 infrastructure to indicate the size of saved registers on a
882 per-frame basis, but right now we don't; the kernel saves eight
883 bytes but we only want four. Use regs_base to access any
885 if (gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_BIG
)
886 regs_base
= sigcontext_base
+ 4;
888 regs_base
= sigcontext_base
;
890 if (mips_linux_restart_reg_p (current_gdbarch
))
891 trad_frame_set_reg_addr (this_cache
,
893 + gdbarch_num_regs (current_gdbarch
)),
894 regs_base
+ SIGCONTEXT_REGS
);
896 for (ireg
= 1; ireg
< 32; ireg
++)
897 trad_frame_set_reg_addr (this_cache
,
898 ireg
+ MIPS_ZERO_REGNUM
899 + gdbarch_num_regs (current_gdbarch
),
900 regs_base
+ SIGCONTEXT_REGS
901 + ireg
* SIGCONTEXT_REG_SIZE
);
903 /* The way that floating point registers are saved, unfortunately,
904 depends on the architecture the kernel is built for. For the r3000 and
905 tx39, four bytes of each register are at the beginning of each of the
906 32 eight byte slots. For everything else, the registers are saved
907 using double precision; only the even-numbered slots are initialized,
908 and the high bits are the odd-numbered register. Assume the latter
909 layout, since we can't tell, and it's much more common. Which bits are
910 the "high" bits depends on endianness. */
911 for (ireg
= 0; ireg
< 32; ireg
++)
912 if ((gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_BIG
) != (ireg
& 1))
913 trad_frame_set_reg_addr (this_cache
,
915 gdbarch_num_regs (current_gdbarch
),
916 sigcontext_base
+ SIGCONTEXT_FPREGS
+ 4
917 + (ireg
& ~1) * SIGCONTEXT_REG_SIZE
);
919 trad_frame_set_reg_addr (this_cache
,
921 + gdbarch_num_regs (current_gdbarch
),
922 sigcontext_base
+ SIGCONTEXT_FPREGS
923 + (ireg
& ~1) * SIGCONTEXT_REG_SIZE
);
925 trad_frame_set_reg_addr (this_cache
,
926 regs
->pc
+ gdbarch_num_regs (current_gdbarch
),
927 regs_base
+ SIGCONTEXT_PC
);
929 trad_frame_set_reg_addr (this_cache
,
930 regs
->fp_control_status
931 + gdbarch_num_regs (current_gdbarch
),
932 sigcontext_base
+ SIGCONTEXT_FPCSR
);
933 trad_frame_set_reg_addr (this_cache
,
934 regs
->hi
+ gdbarch_num_regs (current_gdbarch
),
935 regs_base
+ SIGCONTEXT_HI
);
936 trad_frame_set_reg_addr (this_cache
,
937 regs
->lo
+ gdbarch_num_regs (current_gdbarch
),
938 regs_base
+ SIGCONTEXT_LO
);
939 trad_frame_set_reg_addr (this_cache
,
940 regs
->cause
+ gdbarch_num_regs (current_gdbarch
),
941 sigcontext_base
+ SIGCONTEXT_CAUSE
);
942 trad_frame_set_reg_addr (this_cache
,
943 regs
->badvaddr
+ gdbarch_num_regs (current_gdbarch
),
944 sigcontext_base
+ SIGCONTEXT_BADVADDR
);
946 /* Choice of the bottom of the sigframe is somewhat arbitrary. */
947 trad_frame_set_id (this_cache
,
948 frame_id_build (func
- SIGFRAME_CODE_OFFSET
,
953 /* For N32/N64 things look different. There is no non-rt signal frame.
955 struct rt_sigframe_n32 {
956 u32 rs_ass[4]; [ argument save space for o32 ]
957 u32 rs_code[2]; [ signal trampoline ]
958 struct siginfo rs_info;
959 struct ucontextn32 rs_uc;
966 struct sigcontext uc_mcontext;
967 sigset_t uc_sigmask; [ mask last for extensibility ]
970 struct rt_sigframe_n32 {
971 u32 rs_ass[4]; [ argument save space for o32 ]
972 u32 rs_code[2]; [ signal trampoline ]
973 struct siginfo rs_info;
974 struct ucontext rs_uc;
978 unsigned long uc_flags;
979 struct ucontext *uc_link;
981 struct sigcontext uc_mcontext;
982 sigset_t uc_sigmask; [ mask last for extensibility ]
985 And the sigcontext is different (this is for both n32 and n64):
988 unsigned long long sc_regs[32];
989 unsigned long long sc_fpregs[32];
990 unsigned long long sc_mdhi;
991 unsigned long long sc_mdlo;
992 unsigned long long sc_pc;
993 unsigned int sc_status;
994 unsigned int sc_fpc_csr;
995 unsigned int sc_fpc_eir;
996 unsigned int sc_used_math;
997 unsigned int sc_cause;
998 unsigned int sc_badvaddr;
1002 #define N32_STACK_T_SIZE STACK_T_SIZE
1003 #define N64_STACK_T_SIZE (2 * 8 + 4)
1004 #define N32_UCONTEXT_SIGCONTEXT_OFFSET (2 * 4 + N32_STACK_T_SIZE + 4)
1005 #define N64_UCONTEXT_SIGCONTEXT_OFFSET (2 * 8 + N64_STACK_T_SIZE + 4)
1006 #define N32_SIGFRAME_SIGCONTEXT_OFFSET (SIGFRAME_SIGCONTEXT_OFFSET \
1007 + RTSIGFRAME_SIGINFO_SIZE \
1008 + N32_UCONTEXT_SIGCONTEXT_OFFSET)
1009 #define N64_SIGFRAME_SIGCONTEXT_OFFSET (SIGFRAME_SIGCONTEXT_OFFSET \
1010 + RTSIGFRAME_SIGINFO_SIZE \
1011 + N64_UCONTEXT_SIGCONTEXT_OFFSET)
1013 #define N64_SIGCONTEXT_REGS (0 * 8)
1014 #define N64_SIGCONTEXT_FPREGS (32 * 8)
1015 #define N64_SIGCONTEXT_HI (64 * 8)
1016 #define N64_SIGCONTEXT_LO (65 * 8)
1017 #define N64_SIGCONTEXT_PC (66 * 8)
1018 #define N64_SIGCONTEXT_FPCSR (67 * 8 + 1 * 4)
1019 #define N64_SIGCONTEXT_FIR (67 * 8 + 2 * 4)
1020 #define N64_SIGCONTEXT_CAUSE (67 * 8 + 4 * 4)
1021 #define N64_SIGCONTEXT_BADVADDR (67 * 8 + 5 * 4)
1023 #define N64_SIGCONTEXT_REG_SIZE 8
1026 mips_linux_n32n64_sigframe_init (const struct tramp_frame
*self
,
1027 struct frame_info
*next_frame
,
1028 struct trad_frame_cache
*this_cache
,
1031 int ireg
, reg_position
;
1032 CORE_ADDR sigcontext_base
= func
- SIGFRAME_CODE_OFFSET
;
1033 const struct mips_regnum
*regs
= mips_regnum (current_gdbarch
);
1035 if (self
== &mips_linux_n32_rt_sigframe
)
1036 sigcontext_base
+= N32_SIGFRAME_SIGCONTEXT_OFFSET
;
1038 sigcontext_base
+= N64_SIGFRAME_SIGCONTEXT_OFFSET
;
1040 if (mips_linux_restart_reg_p (current_gdbarch
))
1041 trad_frame_set_reg_addr (this_cache
,
1042 (MIPS_RESTART_REGNUM
1043 + gdbarch_num_regs (current_gdbarch
)),
1044 sigcontext_base
+ N64_SIGCONTEXT_REGS
);
1046 for (ireg
= 1; ireg
< 32; ireg
++)
1047 trad_frame_set_reg_addr (this_cache
,
1048 ireg
+ MIPS_ZERO_REGNUM
1049 + gdbarch_num_regs (current_gdbarch
),
1050 sigcontext_base
+ N64_SIGCONTEXT_REGS
1051 + ireg
* N64_SIGCONTEXT_REG_SIZE
);
1053 for (ireg
= 0; ireg
< 32; ireg
++)
1054 trad_frame_set_reg_addr (this_cache
,
1056 + gdbarch_num_regs (current_gdbarch
),
1057 sigcontext_base
+ N64_SIGCONTEXT_FPREGS
1058 + ireg
* N64_SIGCONTEXT_REG_SIZE
);
1060 trad_frame_set_reg_addr (this_cache
,
1061 regs
->pc
+ gdbarch_num_regs (current_gdbarch
),
1062 sigcontext_base
+ N64_SIGCONTEXT_PC
);
1064 trad_frame_set_reg_addr (this_cache
,
1065 regs
->fp_control_status
1066 + gdbarch_num_regs (current_gdbarch
),
1067 sigcontext_base
+ N64_SIGCONTEXT_FPCSR
);
1068 trad_frame_set_reg_addr (this_cache
,
1069 regs
->hi
+ gdbarch_num_regs (current_gdbarch
),
1070 sigcontext_base
+ N64_SIGCONTEXT_HI
);
1071 trad_frame_set_reg_addr (this_cache
,
1072 regs
->lo
+ gdbarch_num_regs (current_gdbarch
),
1073 sigcontext_base
+ N64_SIGCONTEXT_LO
);
1074 trad_frame_set_reg_addr (this_cache
,
1075 regs
->cause
+ gdbarch_num_regs (current_gdbarch
),
1076 sigcontext_base
+ N64_SIGCONTEXT_CAUSE
);
1077 trad_frame_set_reg_addr (this_cache
,
1078 regs
->badvaddr
+ gdbarch_num_regs (current_gdbarch
),
1079 sigcontext_base
+ N64_SIGCONTEXT_BADVADDR
);
1081 /* Choice of the bottom of the sigframe is somewhat arbitrary. */
1082 trad_frame_set_id (this_cache
,
1083 frame_id_build (func
- SIGFRAME_CODE_OFFSET
,
1088 mips_linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1090 regcache_cooked_write_unsigned (regcache
,
1091 gdbarch_pc_regnum (current_gdbarch
), pc
);
1093 /* Clear the syscall restart flag. */
1094 if (mips_linux_restart_reg_p (current_gdbarch
))
1095 regcache_cooked_write_unsigned (regcache
, MIPS_RESTART_REGNUM
, 0);
1098 /* Return 1 if MIPS_RESTART_REGNUM is usable. */
1101 mips_linux_restart_reg_p (struct gdbarch
*gdbarch
)
1103 /* If we do not have a target description with registers, then
1104 MIPS_RESTART_REGNUM will not be included in the register set. */
1105 if (!tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
1108 /* If we do, then MIPS_RESTART_REGNUM is safe to check; it will
1109 either be GPR-sized or missing. */
1110 return register_size (gdbarch
, MIPS_RESTART_REGNUM
) > 0;
1113 /* Initialize one of the GNU/Linux OS ABIs. */
1116 mips_linux_init_abi (struct gdbarch_info info
,
1117 struct gdbarch
*gdbarch
)
1119 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1120 enum mips_abi abi
= mips_abi (gdbarch
);
1121 struct tdesc_arch_data
*tdesc_data
= (void *) info
.tdep_info
;
1126 set_gdbarch_get_longjmp_target (gdbarch
,
1127 mips_linux_get_longjmp_target
);
1128 set_solib_svr4_fetch_link_map_offsets
1129 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1130 tramp_frame_prepend_unwinder (gdbarch
, &mips_linux_o32_sigframe
);
1131 tramp_frame_prepend_unwinder (gdbarch
, &mips_linux_o32_rt_sigframe
);
1134 set_gdbarch_get_longjmp_target (gdbarch
,
1135 mips_linux_get_longjmp_target
);
1136 set_solib_svr4_fetch_link_map_offsets
1137 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1138 set_gdbarch_long_double_bit (gdbarch
, 128);
1139 /* These floatformats should probably be renamed. MIPS uses
1140 the same 128-bit IEEE floating point format that IA-64 uses,
1141 except that the quiet/signalling NaN bit is reversed (GDB
1142 does not distinguish between quiet and signalling NaNs). */
1143 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
1144 tramp_frame_prepend_unwinder (gdbarch
, &mips_linux_n32_rt_sigframe
);
1147 set_gdbarch_get_longjmp_target (gdbarch
,
1148 mips64_linux_get_longjmp_target
);
1149 set_solib_svr4_fetch_link_map_offsets
1150 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
1151 set_gdbarch_long_double_bit (gdbarch
, 128);
1152 /* These floatformats should probably be renamed. MIPS uses
1153 the same 128-bit IEEE floating point format that IA-64 uses,
1154 except that the quiet/signalling NaN bit is reversed (GDB
1155 does not distinguish between quiet and signalling NaNs). */
1156 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
1157 tramp_frame_prepend_unwinder (gdbarch
, &mips_linux_n64_rt_sigframe
);
1160 internal_error (__FILE__
, __LINE__
, _("can't handle ABI"));
1164 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1165 set_gdbarch_skip_solib_resolver (gdbarch
, mips_linux_skip_resolver
);
1167 set_gdbarch_software_single_step (gdbarch
, mips_software_single_step
);
1169 /* Enable TLS support. */
1170 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
1171 svr4_fetch_objfile_link_map
);
1173 /* Initialize this lazily, to avoid an initialization order
1174 dependency on solib-svr4.c's _initialize routine. */
1175 if (mips_svr4_so_ops
.in_dynsym_resolve_code
== NULL
)
1177 mips_svr4_so_ops
= svr4_so_ops
;
1178 mips_svr4_so_ops
.in_dynsym_resolve_code
1179 = mips_linux_in_dynsym_resolve_code
;
1181 set_solib_ops (gdbarch
, &mips_svr4_so_ops
);
1183 set_gdbarch_write_pc (gdbarch
, mips_linux_write_pc
);
1185 set_gdbarch_core_read_description (gdbarch
,
1186 mips_linux_core_read_description
);
1190 const struct tdesc_feature
*feature
;
1192 /* If we have target-described registers, then we can safely
1193 reserve a number for MIPS_RESTART_REGNUM (whether it is
1194 described or not). */
1195 gdb_assert (gdbarch_num_regs (gdbarch
) <= MIPS_RESTART_REGNUM
);
1196 set_gdbarch_num_regs (gdbarch
, MIPS_RESTART_REGNUM
+ 1);
1198 /* If it's present, then assign it to the reserved number. */
1199 feature
= tdesc_find_feature (info
.target_desc
,
1200 "org.gnu.gdb.mips.linux");
1201 if (feature
!= NULL
)
1202 tdesc_numbered_register (feature
, tdesc_data
, MIPS_RESTART_REGNUM
,
1208 _initialize_mips_linux_tdep (void)
1210 const struct bfd_arch_info
*arch_info
;
1212 for (arch_info
= bfd_lookup_arch (bfd_arch_mips
, 0);
1214 arch_info
= arch_info
->next
)
1216 gdbarch_register_osabi (bfd_arch_mips
, arch_info
->mach
,
1218 mips_linux_init_abi
);
1221 deprecated_add_core_fns (®set_core_fns
);