1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
35 #include "solib-svr4.h"
37 #include "ppc-linux-tdep.h"
38 #include "trad-frame.h"
39 #include "frame-unwind.h"
40 #include "tramp-frame.h"
42 #include "features/rs6000/powerpc-32l.c"
43 #include "features/rs6000/powerpc-altivec32l.c"
44 #include "features/rs6000/powerpc-64l.c"
45 #include "features/rs6000/powerpc-altivec64l.c"
46 #include "features/rs6000/powerpc-e500l.c"
49 ppc_linux_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
52 struct obj_section
*sect
;
53 struct objfile
*objfile
;
55 CORE_ADDR plt_start
= 0;
65 struct minimal_symbol
*msymbol
;
67 /* Find the section pc is in; if not in .plt, try the default method. */
68 sect
= find_pc_section (pc
);
69 if (!sect
|| strcmp (sect
->the_bfd_section
->name
, ".plt") != 0)
70 return find_solib_trampoline_target (frame
, pc
);
72 objfile
= sect
->objfile
;
74 /* Pick up the instruction at pc. It had better be of the
78 where IDX is an index into the plt_table. */
80 if (target_read_memory (pc
, buf
, 4) != 0)
82 insn
= extract_unsigned_integer (buf
, 4);
84 if ((insn
& 0xffff0000) != 0x39600000 /* li r11, VAL */ )
87 reloc_index
= (insn
<< 16) >> 16;
89 /* Find the objfile that pc is in and obtain the information
90 necessary for finding the symbol name. */
91 for (sect
= objfile
->sections
; sect
< objfile
->sections_end
; ++sect
)
93 const char *secname
= sect
->the_bfd_section
->name
;
94 if (strcmp (secname
, ".plt") == 0)
95 plt_start
= sect
->addr
;
96 else if (strcmp (secname
, ".rela.plt") == 0)
97 num_slots
= ((int) sect
->endaddr
- (int) sect
->addr
) / 12;
98 else if (strcmp (secname
, ".dynsym") == 0)
100 else if (strcmp (secname
, ".dynstr") == 0)
104 /* Make sure we have all the information we need. */
105 if (plt_start
== 0 || num_slots
== -1 || symtab
== 0 || strtab
== 0)
108 /* Compute the value of the plt table */
109 plt_table
= plt_start
+ 72 + 8 * num_slots
;
111 /* Get address of the relocation entry (Elf32_Rela) */
112 if (target_read_memory (plt_table
+ reloc_index
, buf
, 4) != 0)
114 reloc
= extract_unsigned_integer (buf
, 4);
116 sect
= find_pc_section (reloc
);
120 if (strcmp (sect
->the_bfd_section
->name
, ".text") == 0)
123 /* Now get the r_info field which is the relocation type and symbol
125 if (target_read_memory (reloc
+ 4, buf
, 4) != 0)
127 symidx
= extract_unsigned_integer (buf
, 4);
129 /* Shift out the relocation type leaving just the symbol index */
130 /* symidx = ELF32_R_SYM(symidx); */
131 symidx
= symidx
>> 8;
133 /* compute the address of the symbol */
134 sym
= symtab
+ symidx
* 4;
136 /* Fetch the string table index */
137 if (target_read_memory (sym
, buf
, 4) != 0)
139 symidx
= extract_unsigned_integer (buf
, 4);
141 /* Fetch the string; we don't know how long it is. Is it possible
142 that the following will fail because we're trying to fetch too
144 if (target_read_memory (strtab
+ symidx
, (gdb_byte
*) symname
,
145 sizeof (symname
)) != 0)
148 /* This might not work right if we have multiple symbols with the
149 same name; the only way to really get it right is to perform
150 the same sort of lookup as the dynamic linker. */
151 msymbol
= lookup_minimal_symbol_text (symname
, NULL
);
155 return SYMBOL_VALUE_ADDRESS (msymbol
);
158 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
159 in much the same fashion as memory_remove_breakpoint in mem-break.c,
160 but is careful not to write back the previous contents if the code
161 in question has changed in between inserting the breakpoint and
164 Here is the problem that we're trying to solve...
166 Once upon a time, before introducing this function to remove
167 breakpoints from the inferior, setting a breakpoint on a shared
168 library function prior to running the program would not work
169 properly. In order to understand the problem, it is first
170 necessary to understand a little bit about dynamic linking on
173 A call to a shared library function is accomplished via a bl
174 (branch-and-link) instruction whose branch target is an entry
175 in the procedure linkage table (PLT). The PLT in the object
176 file is uninitialized. To gdb, prior to running the program, the
177 entries in the PLT are all zeros.
179 Once the program starts running, the shared libraries are loaded
180 and the procedure linkage table is initialized, but the entries in
181 the table are not (necessarily) resolved. Once a function is
182 actually called, the code in the PLT is hit and the function is
183 resolved. In order to better illustrate this, an example is in
184 order; the following example is from the gdb testsuite.
186 We start the program shmain.
188 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
191 We place two breakpoints, one on shr1 and the other on main.
194 Breakpoint 1 at 0x100409d4
196 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
198 Examine the instruction (and the immediatly following instruction)
199 upon which the breakpoint was placed. Note that the PLT entry
200 for shr1 contains zeros.
202 (gdb) x/2i 0x100409d4
203 0x100409d4 <shr1>: .long 0x0
204 0x100409d8 <shr1+4>: .long 0x0
209 Starting program: gdb.base/shmain
210 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
212 Breakpoint 2, main ()
213 at gdb.base/shmain.c:44
216 Examine the PLT again. Note that the loading of the shared
217 library has initialized the PLT to code which loads a constant
218 (which I think is an index into the GOT) into r11 and then
219 branchs a short distance to the code which actually does the
222 (gdb) x/2i 0x100409d4
223 0x100409d4 <shr1>: li r11,4
224 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
228 Breakpoint 1, shr1 (x=1)
229 at gdb.base/shr1.c:19
232 Now we've hit the breakpoint at shr1. (The breakpoint was
233 reset from the PLT entry to the actual shr1 function after the
234 shared library was loaded.) Note that the PLT entry has been
235 resolved to contain a branch that takes us directly to shr1.
236 (The real one, not the PLT entry.)
238 (gdb) x/2i 0x100409d4
239 0x100409d4 <shr1>: b 0xffaf76c <shr1>
240 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
242 The thing to note here is that the PLT entry for shr1 has been
245 Now the problem should be obvious. GDB places a breakpoint (a
246 trap instruction) on the zero value of the PLT entry for shr1.
247 Later on, after the shared library had been loaded and the PLT
248 initialized, GDB gets a signal indicating this fact and attempts
249 (as it always does when it stops) to remove all the breakpoints.
251 The breakpoint removal was causing the former contents (a zero
252 word) to be written back to the now initialized PLT entry thus
253 destroying a portion of the initialization that had occurred only a
254 short time ago. When execution continued, the zero word would be
255 executed as an instruction an an illegal instruction trap was
256 generated instead. (0 is not a legal instruction.)
258 The fix for this problem was fairly straightforward. The function
259 memory_remove_breakpoint from mem-break.c was copied to this file,
260 modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
261 In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
264 The differences between ppc_linux_memory_remove_breakpoint () and
265 memory_remove_breakpoint () are minor. All that the former does
266 that the latter does not is check to make sure that the breakpoint
267 location actually contains a breakpoint (trap instruction) prior
268 to attempting to write back the old contents. If it does contain
269 a trap instruction, we allow the old contents to be written back.
270 Otherwise, we silently do nothing.
272 The big question is whether memory_remove_breakpoint () should be
273 changed to have the same functionality. The downside is that more
274 traffic is generated for remote targets since we'll have an extra
275 fetch of a memory word each time a breakpoint is removed.
277 For the time being, we'll leave this self-modifying-code-friendly
278 version in ppc-linux-tdep.c, but it ought to be migrated somewhere
279 else in the event that some other platform has similar needs with
280 regard to removing breakpoints in some potentially self modifying
283 ppc_linux_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
284 struct bp_target_info
*bp_tgt
)
286 CORE_ADDR addr
= bp_tgt
->placed_address
;
287 const unsigned char *bp
;
290 gdb_byte old_contents
[BREAKPOINT_MAX
];
291 struct cleanup
*cleanup
;
293 /* Determine appropriate breakpoint contents and size for this address. */
294 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bplen
);
296 error (_("Software breakpoints not implemented for this target."));
298 /* Make sure we see the memory breakpoints. */
299 cleanup
= make_show_memory_breakpoints_cleanup (1);
300 val
= target_read_memory (addr
, old_contents
, bplen
);
302 /* If our breakpoint is no longer at the address, this means that the
303 program modified the code on us, so it is wrong to put back the
305 if (val
== 0 && memcmp (bp
, old_contents
, bplen
) == 0)
306 val
= target_write_memory (addr
, bp_tgt
->shadow_contents
, bplen
);
308 do_cleanups (cleanup
);
312 /* For historic reasons, PPC 32 GNU/Linux follows PowerOpen rather
313 than the 32 bit SYSV R4 ABI structure return convention - all
314 structures, no matter their size, are put in memory. Vectors,
315 which were added later, do get returned in a register though. */
317 static enum return_value_convention
318 ppc_linux_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
319 struct type
*valtype
, struct regcache
*regcache
,
320 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
322 if ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
323 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
)
324 && !((TYPE_LENGTH (valtype
) == 16 || TYPE_LENGTH (valtype
) == 8)
325 && TYPE_VECTOR (valtype
)))
326 return RETURN_VALUE_STRUCT_CONVENTION
;
328 return ppc_sysv_abi_return_value (gdbarch
, func_type
, valtype
, regcache
,
332 /* Macros for matching instructions. Note that, since all the
333 operands are masked off before they're or-ed into the instruction,
334 you can use -1 to make masks. */
336 #define insn_d(opcd, rts, ra, d) \
337 ((((opcd) & 0x3f) << 26) \
338 | (((rts) & 0x1f) << 21) \
339 | (((ra) & 0x1f) << 16) \
342 #define insn_ds(opcd, rts, ra, d, xo) \
343 ((((opcd) & 0x3f) << 26) \
344 | (((rts) & 0x1f) << 21) \
345 | (((ra) & 0x1f) << 16) \
349 #define insn_xfx(opcd, rts, spr, xo) \
350 ((((opcd) & 0x3f) << 26) \
351 | (((rts) & 0x1f) << 21) \
352 | (((spr) & 0x1f) << 16) \
353 | (((spr) & 0x3e0) << 6) \
354 | (((xo) & 0x3ff) << 1))
356 /* Read a PPC instruction from memory. PPC instructions are always
357 big-endian, no matter what endianness the program is running in, so
358 we can't use read_memory_integer or one of its friends here. */
360 read_insn (CORE_ADDR pc
)
362 unsigned char buf
[4];
364 read_memory (pc
, buf
, 4);
365 return (buf
[0] << 24) | (buf
[1] << 16) | (buf
[2] << 8) | buf
[3];
369 /* An instruction to match. */
372 unsigned int mask
; /* mask the insn with this... */
373 unsigned int data
; /* ...and see if it matches this. */
374 int optional
; /* If non-zero, this insn may be absent. */
377 /* Return non-zero if the instructions at PC match the series
378 described in PATTERN, or zero otherwise. PATTERN is an array of
379 'struct insn_pattern' objects, terminated by an entry whose mask is
382 When the match is successful, fill INSN[i] with what PATTERN[i]
383 matched. If PATTERN[i] is optional, and the instruction wasn't
384 present, set INSN[i] to 0 (which is not a valid PPC instruction).
385 INSN should have as many elements as PATTERN. Note that, if
386 PATTERN contains optional instructions which aren't present in
387 memory, then INSN will have holes, so INSN[i] isn't necessarily the
388 i'th instruction in memory. */
390 insns_match_pattern (CORE_ADDR pc
,
391 struct insn_pattern
*pattern
,
396 for (i
= 0; pattern
[i
].mask
; i
++)
398 insn
[i
] = read_insn (pc
);
399 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
401 else if (pattern
[i
].optional
)
411 /* Return the 'd' field of the d-form instruction INSN, properly
414 insn_d_field (unsigned int insn
)
416 return ((((CORE_ADDR
) insn
& 0xffff) ^ 0x8000) - 0x8000);
420 /* Return the 'ds' field of the ds-form instruction INSN, with the two
421 zero bits concatenated at the right, and properly
424 insn_ds_field (unsigned int insn
)
426 return ((((CORE_ADDR
) insn
& 0xfffc) ^ 0x8000) - 0x8000);
430 /* If DESC is the address of a 64-bit PowerPC GNU/Linux function
431 descriptor, return the descriptor's entry point. */
433 ppc64_desc_entry_point (CORE_ADDR desc
)
435 /* The first word of the descriptor is the entry point. */
436 return (CORE_ADDR
) read_memory_unsigned_integer (desc
, 8);
440 /* Pattern for the standard linkage function. These are built by
441 build_plt_stub in elf64-ppc.c, whose GLINK argument is always
443 static struct insn_pattern ppc64_standard_linkage
[] =
445 /* addis r12, r2, <any> */
446 { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
449 { -1, insn_ds (62, 2, 1, 40, 0), 0 },
451 /* ld r11, <any>(r12) */
452 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
454 /* addis r12, r12, 1 <optional> */
455 { insn_d (-1, -1, -1, -1), insn_d (15, 12, 2, 1), 1 },
457 /* ld r2, <any>(r12) */
458 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
460 /* addis r12, r12, 1 <optional> */
461 { insn_d (-1, -1, -1, -1), insn_d (15, 12, 2, 1), 1 },
464 { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467),
467 /* ld r11, <any>(r12) */
468 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
471 { -1, 0x4e800420, 0 },
475 #define PPC64_STANDARD_LINKAGE_LEN \
476 (sizeof (ppc64_standard_linkage) / sizeof (ppc64_standard_linkage[0]))
478 /* When the dynamic linker is doing lazy symbol resolution, the first
479 call to a function in another object will go like this:
481 - The user's function calls the linkage function:
483 100007c4: 4b ff fc d5 bl 10000498
484 100007c8: e8 41 00 28 ld r2,40(r1)
486 - The linkage function loads the entry point (and other stuff) from
487 the function descriptor in the PLT, and jumps to it:
489 10000498: 3d 82 00 00 addis r12,r2,0
490 1000049c: f8 41 00 28 std r2,40(r1)
491 100004a0: e9 6c 80 98 ld r11,-32616(r12)
492 100004a4: e8 4c 80 a0 ld r2,-32608(r12)
493 100004a8: 7d 69 03 a6 mtctr r11
494 100004ac: e9 6c 80 a8 ld r11,-32600(r12)
495 100004b0: 4e 80 04 20 bctr
497 - But since this is the first time that PLT entry has been used, it
498 sends control to its glink entry. That loads the number of the
499 PLT entry and jumps to the common glink0 code:
501 10000c98: 38 00 00 00 li r0,0
502 10000c9c: 4b ff ff dc b 10000c78
504 - The common glink0 code then transfers control to the dynamic
507 10000c78: e8 41 00 28 ld r2,40(r1)
508 10000c7c: 3d 82 00 00 addis r12,r2,0
509 10000c80: e9 6c 80 80 ld r11,-32640(r12)
510 10000c84: e8 4c 80 88 ld r2,-32632(r12)
511 10000c88: 7d 69 03 a6 mtctr r11
512 10000c8c: e9 6c 80 90 ld r11,-32624(r12)
513 10000c90: 4e 80 04 20 bctr
515 Eventually, this code will figure out how to skip all of this,
516 including the dynamic linker. At the moment, we just get through
517 the linkage function. */
519 /* If the current thread is about to execute a series of instructions
520 at PC matching the ppc64_standard_linkage pattern, and INSN is the result
521 from that pattern match, return the code address to which the
522 standard linkage function will send them. (This doesn't deal with
523 dynamic linker lazy symbol resolution stubs.) */
525 ppc64_standard_linkage_target (struct frame_info
*frame
,
526 CORE_ADDR pc
, unsigned int *insn
)
528 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
530 /* The address of the function descriptor this linkage function
533 = ((CORE_ADDR
) get_frame_register_unsigned (frame
,
534 tdep
->ppc_gp0_regnum
+ 2)
535 + (insn_d_field (insn
[0]) << 16)
536 + insn_ds_field (insn
[2]));
538 /* The first word of the descriptor is the entry point. Return that. */
539 return ppc64_desc_entry_point (desc
);
543 /* Given that we've begun executing a call trampoline at PC, return
544 the entry point of the function the trampoline will go to. */
546 ppc64_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
548 unsigned int ppc64_standard_linkage_insn
[PPC64_STANDARD_LINKAGE_LEN
];
550 if (insns_match_pattern (pc
, ppc64_standard_linkage
,
551 ppc64_standard_linkage_insn
))
552 return ppc64_standard_linkage_target (frame
, pc
,
553 ppc64_standard_linkage_insn
);
559 /* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64
562 Usually a function pointer's representation is simply the address
563 of the function. On GNU/Linux on the PowerPC however, a function
564 pointer may be a pointer to a function descriptor.
566 For PPC64, a function descriptor is a TOC entry, in a data section,
567 which contains three words: the first word is the address of the
568 function, the second word is the TOC pointer (r2), and the third word
569 is the static chain value.
571 Throughout GDB it is currently assumed that a function pointer contains
572 the address of the function, which is not easy to fix. In addition, the
573 conversion of a function address to a function pointer would
574 require allocation of a TOC entry in the inferior's memory space,
575 with all its drawbacks. To be able to call C++ virtual methods in
576 the inferior (which are called via function pointers),
577 find_function_addr uses this function to get the function address
578 from a function pointer.
580 If ADDR points at what is clearly a function descriptor, transform
581 it into the address of the corresponding function, if needed. Be
582 conservative, otherwise GDB will do the transformation on any
583 random addresses such as occur when there is no symbol table. */
586 ppc64_linux_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
588 struct target_ops
*targ
)
590 struct section_table
*s
= target_section_by_addr (targ
, addr
);
592 /* Check if ADDR points to a function descriptor. */
593 if (s
&& strcmp (s
->the_bfd_section
->name
, ".opd") == 0)
594 return get_target_memory_unsigned (targ
, addr
, 8);
599 /* Wrappers to handle Linux-only registers. */
602 ppc_linux_supply_gregset (const struct regset
*regset
,
603 struct regcache
*regcache
,
604 int regnum
, const void *gregs
, size_t len
)
606 const struct ppc_reg_offsets
*offsets
= regset
->descr
;
608 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
610 if (ppc_linux_trap_reg_p (get_regcache_arch (regcache
)))
612 /* "orig_r3" is stored 2 slots after "pc". */
613 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
614 ppc_supply_reg (regcache
, PPC_ORIG_R3_REGNUM
, gregs
,
615 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
618 /* "trap" is stored 8 slots after "pc". */
619 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
620 ppc_supply_reg (regcache
, PPC_TRAP_REGNUM
, gregs
,
621 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
627 ppc_linux_collect_gregset (const struct regset
*regset
,
628 const struct regcache
*regcache
,
629 int regnum
, void *gregs
, size_t len
)
631 const struct ppc_reg_offsets
*offsets
= regset
->descr
;
633 /* Clear areas in the linux gregset not written elsewhere. */
635 memset (gregs
, 0, len
);
637 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
639 if (ppc_linux_trap_reg_p (get_regcache_arch (regcache
)))
641 /* "orig_r3" is stored 2 slots after "pc". */
642 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
643 ppc_collect_reg (regcache
, PPC_ORIG_R3_REGNUM
, gregs
,
644 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
647 /* "trap" is stored 8 slots after "pc". */
648 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
649 ppc_collect_reg (regcache
, PPC_TRAP_REGNUM
, gregs
,
650 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
655 /* Regset descriptions. */
656 static const struct ppc_reg_offsets ppc32_linux_reg_offsets
=
658 /* General-purpose registers. */
659 /* .r0_offset = */ 0,
662 /* .pc_offset = */ 128,
663 /* .ps_offset = */ 132,
664 /* .cr_offset = */ 152,
665 /* .lr_offset = */ 144,
666 /* .ctr_offset = */ 140,
667 /* .xer_offset = */ 148,
668 /* .mq_offset = */ 156,
670 /* Floating-point registers. */
671 /* .f0_offset = */ 0,
672 /* .fpscr_offset = */ 256,
673 /* .fpscr_size = */ 8,
675 /* AltiVec registers. */
676 /* .vr0_offset = */ 0,
677 /* .vscr_offset = */ 512 + 12,
678 /* .vrsave_offset = */ 528
681 static const struct ppc_reg_offsets ppc64_linux_reg_offsets
=
683 /* General-purpose registers. */
684 /* .r0_offset = */ 0,
687 /* .pc_offset = */ 256,
688 /* .ps_offset = */ 264,
689 /* .cr_offset = */ 304,
690 /* .lr_offset = */ 288,
691 /* .ctr_offset = */ 280,
692 /* .xer_offset = */ 296,
693 /* .mq_offset = */ 312,
695 /* Floating-point registers. */
696 /* .f0_offset = */ 0,
697 /* .fpscr_offset = */ 256,
698 /* .fpscr_size = */ 8,
700 /* AltiVec registers. */
701 /* .vr0_offset = */ 0,
702 /* .vscr_offset = */ 512 + 12,
703 /* .vrsave_offset = */ 528
706 static const struct regset ppc32_linux_gregset
= {
707 &ppc32_linux_reg_offsets
,
708 ppc_linux_supply_gregset
,
709 ppc_linux_collect_gregset
,
713 static const struct regset ppc64_linux_gregset
= {
714 &ppc64_linux_reg_offsets
,
715 ppc_linux_supply_gregset
,
716 ppc_linux_collect_gregset
,
720 static const struct regset ppc32_linux_fpregset
= {
721 &ppc32_linux_reg_offsets
,
723 ppc_collect_fpregset
,
727 static const struct regset ppc32_linux_vrregset
= {
728 &ppc32_linux_reg_offsets
,
730 ppc_collect_vrregset
,
734 const struct regset
*
735 ppc_linux_gregset (int wordsize
)
737 return wordsize
== 8 ? &ppc64_linux_gregset
: &ppc32_linux_gregset
;
740 const struct regset
*
741 ppc_linux_fpregset (void)
743 return &ppc32_linux_fpregset
;
746 static const struct regset
*
747 ppc_linux_regset_from_core_section (struct gdbarch
*core_arch
,
748 const char *sect_name
, size_t sect_size
)
750 struct gdbarch_tdep
*tdep
= gdbarch_tdep (core_arch
);
751 if (strcmp (sect_name
, ".reg") == 0)
753 if (tdep
->wordsize
== 4)
754 return &ppc32_linux_gregset
;
756 return &ppc64_linux_gregset
;
758 if (strcmp (sect_name
, ".reg2") == 0)
759 return &ppc32_linux_fpregset
;
760 if (strcmp (sect_name
, ".reg-ppc-vmx") == 0)
761 return &ppc32_linux_vrregset
;
766 ppc_linux_sigtramp_cache (struct frame_info
*this_frame
,
767 struct trad_frame_cache
*this_cache
,
768 CORE_ADDR func
, LONGEST offset
,
776 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
777 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
779 base
= get_frame_register_unsigned (this_frame
,
780 gdbarch_sp_regnum (gdbarch
));
781 if (bias
> 0 && get_frame_pc (this_frame
) != func
)
782 /* See below, some signal trampolines increment the stack as their
783 first instruction, need to compensate for that. */
786 /* Find the address of the register buffer pointer. */
787 regs
= base
+ offset
;
788 /* Use that to find the address of the corresponding register
790 gpregs
= read_memory_unsigned_integer (regs
, tdep
->wordsize
);
791 fpregs
= gpregs
+ 48 * tdep
->wordsize
;
793 /* General purpose. */
794 for (i
= 0; i
< 32; i
++)
796 int regnum
= i
+ tdep
->ppc_gp0_regnum
;
797 trad_frame_set_reg_addr (this_cache
, regnum
, gpregs
+ i
* tdep
->wordsize
);
799 trad_frame_set_reg_addr (this_cache
,
800 gdbarch_pc_regnum (gdbarch
),
801 gpregs
+ 32 * tdep
->wordsize
);
802 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_ctr_regnum
,
803 gpregs
+ 35 * tdep
->wordsize
);
804 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_lr_regnum
,
805 gpregs
+ 36 * tdep
->wordsize
);
806 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_xer_regnum
,
807 gpregs
+ 37 * tdep
->wordsize
);
808 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_cr_regnum
,
809 gpregs
+ 38 * tdep
->wordsize
);
811 if (ppc_linux_trap_reg_p (gdbarch
))
813 trad_frame_set_reg_addr (this_cache
, PPC_ORIG_R3_REGNUM
,
814 gpregs
+ 34 * tdep
->wordsize
);
815 trad_frame_set_reg_addr (this_cache
, PPC_TRAP_REGNUM
,
816 gpregs
+ 40 * tdep
->wordsize
);
819 if (ppc_floating_point_unit_p (gdbarch
))
821 /* Floating point registers. */
822 for (i
= 0; i
< 32; i
++)
824 int regnum
= i
+ gdbarch_fp0_regnum (gdbarch
);
825 trad_frame_set_reg_addr (this_cache
, regnum
,
826 fpregs
+ i
* tdep
->wordsize
);
828 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_fpscr_regnum
,
829 fpregs
+ 32 * tdep
->wordsize
);
831 trad_frame_set_id (this_cache
, frame_id_build (base
, func
));
835 ppc32_linux_sigaction_cache_init (const struct tramp_frame
*self
,
836 struct frame_info
*this_frame
,
837 struct trad_frame_cache
*this_cache
,
840 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
841 0xd0 /* Offset to ucontext_t. */
842 + 0x30 /* Offset to .reg. */,
847 ppc64_linux_sigaction_cache_init (const struct tramp_frame
*self
,
848 struct frame_info
*this_frame
,
849 struct trad_frame_cache
*this_cache
,
852 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
853 0x80 /* Offset to ucontext_t. */
854 + 0xe0 /* Offset to .reg. */,
859 ppc32_linux_sighandler_cache_init (const struct tramp_frame
*self
,
860 struct frame_info
*this_frame
,
861 struct trad_frame_cache
*this_cache
,
864 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
865 0x40 /* Offset to ucontext_t. */
866 + 0x1c /* Offset to .reg. */,
871 ppc64_linux_sighandler_cache_init (const struct tramp_frame
*self
,
872 struct frame_info
*this_frame
,
873 struct trad_frame_cache
*this_cache
,
876 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
877 0x80 /* Offset to struct sigcontext. */
878 + 0x38 /* Offset to .reg. */,
882 static struct tramp_frame ppc32_linux_sigaction_tramp_frame
= {
886 { 0x380000ac, -1 }, /* li r0, 172 */
887 { 0x44000002, -1 }, /* sc */
888 { TRAMP_SENTINEL_INSN
},
890 ppc32_linux_sigaction_cache_init
892 static struct tramp_frame ppc64_linux_sigaction_tramp_frame
= {
896 { 0x38210080, -1 }, /* addi r1,r1,128 */
897 { 0x380000ac, -1 }, /* li r0, 172 */
898 { 0x44000002, -1 }, /* sc */
899 { TRAMP_SENTINEL_INSN
},
901 ppc64_linux_sigaction_cache_init
903 static struct tramp_frame ppc32_linux_sighandler_tramp_frame
= {
907 { 0x38000077, -1 }, /* li r0,119 */
908 { 0x44000002, -1 }, /* sc */
909 { TRAMP_SENTINEL_INSN
},
911 ppc32_linux_sighandler_cache_init
913 static struct tramp_frame ppc64_linux_sighandler_tramp_frame
= {
917 { 0x38210080, -1 }, /* addi r1,r1,128 */
918 { 0x38000077, -1 }, /* li r0,119 */
919 { 0x44000002, -1 }, /* sc */
920 { TRAMP_SENTINEL_INSN
},
922 ppc64_linux_sighandler_cache_init
926 /* Return 1 if PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM are usable. */
928 ppc_linux_trap_reg_p (struct gdbarch
*gdbarch
)
930 /* If we do not have a target description with registers, then
931 the special registers will not be included in the register set. */
932 if (!tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
935 /* If we do, then it is safe to check the size. */
936 return register_size (gdbarch
, PPC_ORIG_R3_REGNUM
) > 0
937 && register_size (gdbarch
, PPC_TRAP_REGNUM
) > 0;
941 ppc_linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
943 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
945 regcache_cooked_write_unsigned (regcache
, gdbarch_pc_regnum (gdbarch
), pc
);
947 /* Set special TRAP register to -1 to prevent the kernel from
948 messing with the PC we just installed, if we happen to be
949 within an interrupted system call that the kernel wants to
952 Note that after we return from the dummy call, the TRAP and
953 ORIG_R3 registers will be automatically restored, and the
954 kernel continues to restart the system call at this point. */
955 if (ppc_linux_trap_reg_p (gdbarch
))
956 regcache_cooked_write_unsigned (regcache
, PPC_TRAP_REGNUM
, -1);
959 static const struct target_desc
*
960 ppc_linux_core_read_description (struct gdbarch
*gdbarch
,
961 struct target_ops
*target
,
964 asection
*altivec
= bfd_get_section_by_name (abfd
, ".reg-ppc-vmx");
965 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
969 switch (bfd_section_size (abfd
, section
))
972 return altivec
? tdesc_powerpc_altivec32l
: tdesc_powerpc_32l
;
975 return altivec
? tdesc_powerpc_altivec64l
: tdesc_powerpc_64l
;
983 ppc_linux_init_abi (struct gdbarch_info info
,
984 struct gdbarch
*gdbarch
)
986 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
987 struct tdesc_arch_data
*tdesc_data
= (void *) info
.tdep_info
;
989 /* PPC GNU/Linux uses either 64-bit or 128-bit long doubles; where
990 128-bit, they are IBM long double, not IEEE quad long double as
991 in the System V ABI PowerPC Processor Supplement. We can safely
992 let them default to 128-bit, since the debug info will give the
993 size of type actually used in each case. */
994 set_gdbarch_long_double_bit (gdbarch
, 16 * TARGET_CHAR_BIT
);
995 set_gdbarch_long_double_format (gdbarch
, floatformats_ibm_long_double
);
997 /* Handle inferior calls during interrupted system calls. */
998 set_gdbarch_write_pc (gdbarch
, ppc_linux_write_pc
);
1000 if (tdep
->wordsize
== 4)
1002 /* Until November 2001, gcc did not comply with the 32 bit SysV
1003 R4 ABI requirement that structures less than or equal to 8
1004 bytes should be returned in registers. Instead GCC was using
1005 the the AIX/PowerOpen ABI - everything returned in memory
1006 (well ignoring vectors that is). When this was corrected, it
1007 wasn't fixed for GNU/Linux native platform. Use the
1008 PowerOpen struct convention. */
1009 set_gdbarch_return_value (gdbarch
, ppc_linux_return_value
);
1011 set_gdbarch_memory_remove_breakpoint (gdbarch
,
1012 ppc_linux_memory_remove_breakpoint
);
1014 /* Shared library handling. */
1015 set_gdbarch_skip_trampoline_code (gdbarch
,
1016 ppc_linux_skip_trampoline_code
);
1017 set_solib_svr4_fetch_link_map_offsets
1018 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1021 tramp_frame_prepend_unwinder (gdbarch
, &ppc32_linux_sigaction_tramp_frame
);
1022 tramp_frame_prepend_unwinder (gdbarch
, &ppc32_linux_sighandler_tramp_frame
);
1025 if (tdep
->wordsize
== 8)
1027 /* Handle the 64-bit SVR4 minimal-symbol convention of using "FN"
1028 for the descriptor and ".FN" for the entry-point -- a user
1029 specifying "break FN" will unexpectedly end up with a breakpoint
1030 on the descriptor and not the function. This architecture method
1031 transforms any breakpoints on descriptors into breakpoints on the
1032 corresponding entry point. */
1033 set_gdbarch_adjust_breakpoint_address
1034 (gdbarch
, ppc64_sysv_abi_adjust_breakpoint_address
);
1036 /* Handle PPC GNU/Linux 64-bit function pointers (which are really
1037 function descriptors). */
1038 set_gdbarch_convert_from_func_ptr_addr
1039 (gdbarch
, ppc64_linux_convert_from_func_ptr_addr
);
1041 /* Shared library handling. */
1042 set_gdbarch_skip_trampoline_code (gdbarch
, ppc64_skip_trampoline_code
);
1043 set_solib_svr4_fetch_link_map_offsets
1044 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
1047 tramp_frame_prepend_unwinder (gdbarch
, &ppc64_linux_sigaction_tramp_frame
);
1048 tramp_frame_prepend_unwinder (gdbarch
, &ppc64_linux_sighandler_tramp_frame
);
1050 set_gdbarch_regset_from_core_section (gdbarch
, ppc_linux_regset_from_core_section
);
1051 set_gdbarch_core_read_description (gdbarch
, ppc_linux_core_read_description
);
1053 /* Enable TLS support. */
1054 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
1055 svr4_fetch_objfile_link_map
);
1059 const struct tdesc_feature
*feature
;
1061 /* If we have target-described registers, then we can safely
1062 reserve a number for PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM
1063 (whether they are described or not). */
1064 gdb_assert (gdbarch_num_regs (gdbarch
) <= PPC_ORIG_R3_REGNUM
);
1065 set_gdbarch_num_regs (gdbarch
, PPC_TRAP_REGNUM
+ 1);
1067 /* If they are present, then assign them to the reserved number. */
1068 feature
= tdesc_find_feature (info
.target_desc
,
1069 "org.gnu.gdb.power.linux");
1070 if (feature
!= NULL
)
1072 tdesc_numbered_register (feature
, tdesc_data
,
1073 PPC_ORIG_R3_REGNUM
, "orig_r3");
1074 tdesc_numbered_register (feature
, tdesc_data
,
1075 PPC_TRAP_REGNUM
, "trap");
1081 _initialize_ppc_linux_tdep (void)
1083 /* Register for all sub-familes of the POWER/PowerPC: 32-bit and
1084 64-bit PowerPC, and the older rs6k. */
1085 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc
, GDB_OSABI_LINUX
,
1086 ppc_linux_init_abi
);
1087 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc64
, GDB_OSABI_LINUX
,
1088 ppc_linux_init_abi
);
1089 gdbarch_register_osabi (bfd_arch_rs6000
, bfd_mach_rs6k
, GDB_OSABI_LINUX
,
1090 ppc_linux_init_abi
);
1092 /* Initialize the Linux target descriptions. */
1093 initialize_tdesc_powerpc_32l ();
1094 initialize_tdesc_powerpc_altivec32l ();
1095 initialize_tdesc_powerpc_64l ();
1096 initialize_tdesc_powerpc_altivec64l ();
1097 initialize_tdesc_powerpc_e500l ();