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-vsx32l.c"
45 #include "features/rs6000/powerpc-64l.c"
46 #include "features/rs6000/powerpc-altivec64l.c"
47 #include "features/rs6000/powerpc-vsx64l.c"
48 #include "features/rs6000/powerpc-e500l.c"
51 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
52 in much the same fashion as memory_remove_breakpoint in mem-break.c,
53 but is careful not to write back the previous contents if the code
54 in question has changed in between inserting the breakpoint and
57 Here is the problem that we're trying to solve...
59 Once upon a time, before introducing this function to remove
60 breakpoints from the inferior, setting a breakpoint on a shared
61 library function prior to running the program would not work
62 properly. In order to understand the problem, it is first
63 necessary to understand a little bit about dynamic linking on
66 A call to a shared library function is accomplished via a bl
67 (branch-and-link) instruction whose branch target is an entry
68 in the procedure linkage table (PLT). The PLT in the object
69 file is uninitialized. To gdb, prior to running the program, the
70 entries in the PLT are all zeros.
72 Once the program starts running, the shared libraries are loaded
73 and the procedure linkage table is initialized, but the entries in
74 the table are not (necessarily) resolved. Once a function is
75 actually called, the code in the PLT is hit and the function is
76 resolved. In order to better illustrate this, an example is in
77 order; the following example is from the gdb testsuite.
79 We start the program shmain.
81 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
84 We place two breakpoints, one on shr1 and the other on main.
87 Breakpoint 1 at 0x100409d4
89 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
91 Examine the instruction (and the immediatly following instruction)
92 upon which the breakpoint was placed. Note that the PLT entry
93 for shr1 contains zeros.
96 0x100409d4 <shr1>: .long 0x0
97 0x100409d8 <shr1+4>: .long 0x0
102 Starting program: gdb.base/shmain
103 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
105 Breakpoint 2, main ()
106 at gdb.base/shmain.c:44
109 Examine the PLT again. Note that the loading of the shared
110 library has initialized the PLT to code which loads a constant
111 (which I think is an index into the GOT) into r11 and then
112 branchs a short distance to the code which actually does the
115 (gdb) x/2i 0x100409d4
116 0x100409d4 <shr1>: li r11,4
117 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
121 Breakpoint 1, shr1 (x=1)
122 at gdb.base/shr1.c:19
125 Now we've hit the breakpoint at shr1. (The breakpoint was
126 reset from the PLT entry to the actual shr1 function after the
127 shared library was loaded.) Note that the PLT entry has been
128 resolved to contain a branch that takes us directly to shr1.
129 (The real one, not the PLT entry.)
131 (gdb) x/2i 0x100409d4
132 0x100409d4 <shr1>: b 0xffaf76c <shr1>
133 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
135 The thing to note here is that the PLT entry for shr1 has been
138 Now the problem should be obvious. GDB places a breakpoint (a
139 trap instruction) on the zero value of the PLT entry for shr1.
140 Later on, after the shared library had been loaded and the PLT
141 initialized, GDB gets a signal indicating this fact and attempts
142 (as it always does when it stops) to remove all the breakpoints.
144 The breakpoint removal was causing the former contents (a zero
145 word) to be written back to the now initialized PLT entry thus
146 destroying a portion of the initialization that had occurred only a
147 short time ago. When execution continued, the zero word would be
148 executed as an instruction an an illegal instruction trap was
149 generated instead. (0 is not a legal instruction.)
151 The fix for this problem was fairly straightforward. The function
152 memory_remove_breakpoint from mem-break.c was copied to this file,
153 modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
154 In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
157 The differences between ppc_linux_memory_remove_breakpoint () and
158 memory_remove_breakpoint () are minor. All that the former does
159 that the latter does not is check to make sure that the breakpoint
160 location actually contains a breakpoint (trap instruction) prior
161 to attempting to write back the old contents. If it does contain
162 a trap instruction, we allow the old contents to be written back.
163 Otherwise, we silently do nothing.
165 The big question is whether memory_remove_breakpoint () should be
166 changed to have the same functionality. The downside is that more
167 traffic is generated for remote targets since we'll have an extra
168 fetch of a memory word each time a breakpoint is removed.
170 For the time being, we'll leave this self-modifying-code-friendly
171 version in ppc-linux-tdep.c, but it ought to be migrated somewhere
172 else in the event that some other platform has similar needs with
173 regard to removing breakpoints in some potentially self modifying
176 ppc_linux_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
177 struct bp_target_info
*bp_tgt
)
179 CORE_ADDR addr
= bp_tgt
->placed_address
;
180 const unsigned char *bp
;
183 gdb_byte old_contents
[BREAKPOINT_MAX
];
184 struct cleanup
*cleanup
;
186 /* Determine appropriate breakpoint contents and size for this address. */
187 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bplen
);
189 error (_("Software breakpoints not implemented for this target."));
191 /* Make sure we see the memory breakpoints. */
192 cleanup
= make_show_memory_breakpoints_cleanup (1);
193 val
= target_read_memory (addr
, old_contents
, bplen
);
195 /* If our breakpoint is no longer at the address, this means that the
196 program modified the code on us, so it is wrong to put back the
198 if (val
== 0 && memcmp (bp
, old_contents
, bplen
) == 0)
199 val
= target_write_memory (addr
, bp_tgt
->shadow_contents
, bplen
);
201 do_cleanups (cleanup
);
205 /* For historic reasons, PPC 32 GNU/Linux follows PowerOpen rather
206 than the 32 bit SYSV R4 ABI structure return convention - all
207 structures, no matter their size, are put in memory. Vectors,
208 which were added later, do get returned in a register though. */
210 static enum return_value_convention
211 ppc_linux_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
212 struct type
*valtype
, struct regcache
*regcache
,
213 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
215 if ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
216 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
)
217 && !((TYPE_LENGTH (valtype
) == 16 || TYPE_LENGTH (valtype
) == 8)
218 && TYPE_VECTOR (valtype
)))
219 return RETURN_VALUE_STRUCT_CONVENTION
;
221 return ppc_sysv_abi_return_value (gdbarch
, func_type
, valtype
, regcache
,
225 /* Macros for matching instructions. Note that, since all the
226 operands are masked off before they're or-ed into the instruction,
227 you can use -1 to make masks. */
229 #define insn_d(opcd, rts, ra, d) \
230 ((((opcd) & 0x3f) << 26) \
231 | (((rts) & 0x1f) << 21) \
232 | (((ra) & 0x1f) << 16) \
235 #define insn_ds(opcd, rts, ra, d, xo) \
236 ((((opcd) & 0x3f) << 26) \
237 | (((rts) & 0x1f) << 21) \
238 | (((ra) & 0x1f) << 16) \
242 #define insn_xfx(opcd, rts, spr, xo) \
243 ((((opcd) & 0x3f) << 26) \
244 | (((rts) & 0x1f) << 21) \
245 | (((spr) & 0x1f) << 16) \
246 | (((spr) & 0x3e0) << 6) \
247 | (((xo) & 0x3ff) << 1))
249 /* Read a PPC instruction from memory. PPC instructions are always
250 big-endian, no matter what endianness the program is running in, so
251 we can't use read_memory_integer or one of its friends here. */
253 read_insn (CORE_ADDR pc
)
255 unsigned char buf
[4];
257 read_memory (pc
, buf
, 4);
258 return (buf
[0] << 24) | (buf
[1] << 16) | (buf
[2] << 8) | buf
[3];
262 /* An instruction to match. */
265 unsigned int mask
; /* mask the insn with this... */
266 unsigned int data
; /* ...and see if it matches this. */
267 int optional
; /* If non-zero, this insn may be absent. */
270 /* Return non-zero if the instructions at PC match the series
271 described in PATTERN, or zero otherwise. PATTERN is an array of
272 'struct insn_pattern' objects, terminated by an entry whose mask is
275 When the match is successful, fill INSN[i] with what PATTERN[i]
276 matched. If PATTERN[i] is optional, and the instruction wasn't
277 present, set INSN[i] to 0 (which is not a valid PPC instruction).
278 INSN should have as many elements as PATTERN. Note that, if
279 PATTERN contains optional instructions which aren't present in
280 memory, then INSN will have holes, so INSN[i] isn't necessarily the
281 i'th instruction in memory. */
283 insns_match_pattern (CORE_ADDR pc
,
284 struct insn_pattern
*pattern
,
289 for (i
= 0; pattern
[i
].mask
; i
++)
291 insn
[i
] = read_insn (pc
);
292 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
294 else if (pattern
[i
].optional
)
304 /* Return the 'd' field of the d-form instruction INSN, properly
307 insn_d_field (unsigned int insn
)
309 return ((((CORE_ADDR
) insn
& 0xffff) ^ 0x8000) - 0x8000);
313 /* Return the 'ds' field of the ds-form instruction INSN, with the two
314 zero bits concatenated at the right, and properly
317 insn_ds_field (unsigned int insn
)
319 return ((((CORE_ADDR
) insn
& 0xfffc) ^ 0x8000) - 0x8000);
323 /* If DESC is the address of a 64-bit PowerPC GNU/Linux function
324 descriptor, return the descriptor's entry point. */
326 ppc64_desc_entry_point (CORE_ADDR desc
)
328 /* The first word of the descriptor is the entry point. */
329 return (CORE_ADDR
) read_memory_unsigned_integer (desc
, 8);
333 /* Pattern for the standard linkage function. These are built by
334 build_plt_stub in elf64-ppc.c, whose GLINK argument is always
336 static struct insn_pattern ppc64_standard_linkage1
[] =
338 /* addis r12, r2, <any> */
339 { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
342 { -1, insn_ds (62, 2, 1, 40, 0), 0 },
344 /* ld r11, <any>(r12) */
345 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
347 /* addis r12, r12, 1 <optional> */
348 { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },
350 /* ld r2, <any>(r12) */
351 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
353 /* addis r12, r12, 1 <optional> */
354 { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },
357 { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
359 /* ld r11, <any>(r12) */
360 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
363 { -1, 0x4e800420, 0 },
367 #define PPC64_STANDARD_LINKAGE1_LEN \
368 (sizeof (ppc64_standard_linkage1) / sizeof (ppc64_standard_linkage1[0]))
370 static struct insn_pattern ppc64_standard_linkage2
[] =
372 /* addis r12, r2, <any> */
373 { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
376 { -1, insn_ds (62, 2, 1, 40, 0), 0 },
378 /* ld r11, <any>(r12) */
379 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
381 /* addi r12, r12, <any> <optional> */
382 { insn_d (-1, -1, -1, 0), insn_d (14, 12, 12, 0), 1 },
385 { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
387 /* ld r2, <any>(r12) */
388 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
390 /* ld r11, <any>(r12) */
391 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
394 { -1, 0x4e800420, 0 },
398 #define PPC64_STANDARD_LINKAGE2_LEN \
399 (sizeof (ppc64_standard_linkage2) / sizeof (ppc64_standard_linkage2[0]))
401 static struct insn_pattern ppc64_standard_linkage3
[] =
404 { -1, insn_ds (62, 2, 1, 40, 0), 0 },
406 /* ld r11, <any>(r2) */
407 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 },
409 /* addi r2, r2, <any> <optional> */
410 { insn_d (-1, -1, -1, 0), insn_d (14, 2, 2, 0), 1 },
413 { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
415 /* ld r11, <any>(r2) */
416 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 },
418 /* ld r2, <any>(r2) */
419 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 2, 0, 0), 0 },
422 { -1, 0x4e800420, 0 },
426 #define PPC64_STANDARD_LINKAGE3_LEN \
427 (sizeof (ppc64_standard_linkage3) / sizeof (ppc64_standard_linkage3[0]))
430 /* When the dynamic linker is doing lazy symbol resolution, the first
431 call to a function in another object will go like this:
433 - The user's function calls the linkage function:
435 100007c4: 4b ff fc d5 bl 10000498
436 100007c8: e8 41 00 28 ld r2,40(r1)
438 - The linkage function loads the entry point (and other stuff) from
439 the function descriptor in the PLT, and jumps to it:
441 10000498: 3d 82 00 00 addis r12,r2,0
442 1000049c: f8 41 00 28 std r2,40(r1)
443 100004a0: e9 6c 80 98 ld r11,-32616(r12)
444 100004a4: e8 4c 80 a0 ld r2,-32608(r12)
445 100004a8: 7d 69 03 a6 mtctr r11
446 100004ac: e9 6c 80 a8 ld r11,-32600(r12)
447 100004b0: 4e 80 04 20 bctr
449 - But since this is the first time that PLT entry has been used, it
450 sends control to its glink entry. That loads the number of the
451 PLT entry and jumps to the common glink0 code:
453 10000c98: 38 00 00 00 li r0,0
454 10000c9c: 4b ff ff dc b 10000c78
456 - The common glink0 code then transfers control to the dynamic
459 10000c78: e8 41 00 28 ld r2,40(r1)
460 10000c7c: 3d 82 00 00 addis r12,r2,0
461 10000c80: e9 6c 80 80 ld r11,-32640(r12)
462 10000c84: e8 4c 80 88 ld r2,-32632(r12)
463 10000c88: 7d 69 03 a6 mtctr r11
464 10000c8c: e9 6c 80 90 ld r11,-32624(r12)
465 10000c90: 4e 80 04 20 bctr
467 Eventually, this code will figure out how to skip all of this,
468 including the dynamic linker. At the moment, we just get through
469 the linkage function. */
471 /* If the current thread is about to execute a series of instructions
472 at PC matching the ppc64_standard_linkage pattern, and INSN is the result
473 from that pattern match, return the code address to which the
474 standard linkage function will send them. (This doesn't deal with
475 dynamic linker lazy symbol resolution stubs.) */
477 ppc64_standard_linkage1_target (struct frame_info
*frame
,
478 CORE_ADDR pc
, unsigned int *insn
)
480 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
482 /* The address of the function descriptor this linkage function
485 = ((CORE_ADDR
) get_frame_register_unsigned (frame
,
486 tdep
->ppc_gp0_regnum
+ 2)
487 + (insn_d_field (insn
[0]) << 16)
488 + insn_ds_field (insn
[2]));
490 /* The first word of the descriptor is the entry point. Return that. */
491 return ppc64_desc_entry_point (desc
);
494 static struct core_regset_section ppc_linux_regset_sections
[] =
498 { ".reg-ppc-vmx", 544 },
499 { ".reg-ppc-vsx", 256 },
504 ppc64_standard_linkage2_target (struct frame_info
*frame
,
505 CORE_ADDR pc
, unsigned int *insn
)
507 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
509 /* The address of the function descriptor this linkage function
512 = ((CORE_ADDR
) get_frame_register_unsigned (frame
,
513 tdep
->ppc_gp0_regnum
+ 2)
514 + (insn_d_field (insn
[0]) << 16)
515 + insn_ds_field (insn
[2]));
517 /* The first word of the descriptor is the entry point. Return that. */
518 return ppc64_desc_entry_point (desc
);
522 ppc64_standard_linkage3_target (struct frame_info
*frame
,
523 CORE_ADDR pc
, unsigned int *insn
)
525 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
527 /* The address of the function descriptor this linkage function
530 = ((CORE_ADDR
) get_frame_register_unsigned (frame
,
531 tdep
->ppc_gp0_regnum
+ 2)
532 + insn_ds_field (insn
[1]));
534 /* The first word of the descriptor is the entry point. Return that. */
535 return ppc64_desc_entry_point (desc
);
539 /* Given that we've begun executing a call trampoline at PC, return
540 the entry point of the function the trampoline will go to. */
542 ppc64_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
544 unsigned int ppc64_standard_linkage1_insn
[PPC64_STANDARD_LINKAGE1_LEN
];
545 unsigned int ppc64_standard_linkage2_insn
[PPC64_STANDARD_LINKAGE2_LEN
];
546 unsigned int ppc64_standard_linkage3_insn
[PPC64_STANDARD_LINKAGE3_LEN
];
549 if (insns_match_pattern (pc
, ppc64_standard_linkage1
,
550 ppc64_standard_linkage1_insn
))
551 pc
= ppc64_standard_linkage1_target (frame
, pc
,
552 ppc64_standard_linkage1_insn
);
553 else if (insns_match_pattern (pc
, ppc64_standard_linkage2
,
554 ppc64_standard_linkage2_insn
))
555 pc
= ppc64_standard_linkage2_target (frame
, pc
,
556 ppc64_standard_linkage2_insn
);
557 else if (insns_match_pattern (pc
, ppc64_standard_linkage3
,
558 ppc64_standard_linkage3_insn
))
559 pc
= ppc64_standard_linkage3_target (frame
, pc
,
560 ppc64_standard_linkage3_insn
);
564 /* The PLT descriptor will either point to the already resolved target
565 address, or else to a glink stub. As the latter carry synthetic @plt
566 symbols, find_solib_trampoline_target should be able to resolve them. */
567 target
= find_solib_trampoline_target (frame
, pc
);
568 return target
? target
: pc
;
572 /* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64
575 Usually a function pointer's representation is simply the address
576 of the function. On GNU/Linux on the PowerPC however, a function
577 pointer may be a pointer to a function descriptor.
579 For PPC64, a function descriptor is a TOC entry, in a data section,
580 which contains three words: the first word is the address of the
581 function, the second word is the TOC pointer (r2), and the third word
582 is the static chain value.
584 Throughout GDB it is currently assumed that a function pointer contains
585 the address of the function, which is not easy to fix. In addition, the
586 conversion of a function address to a function pointer would
587 require allocation of a TOC entry in the inferior's memory space,
588 with all its drawbacks. To be able to call C++ virtual methods in
589 the inferior (which are called via function pointers),
590 find_function_addr uses this function to get the function address
591 from a function pointer.
593 If ADDR points at what is clearly a function descriptor, transform
594 it into the address of the corresponding function, if needed. Be
595 conservative, otherwise GDB will do the transformation on any
596 random addresses such as occur when there is no symbol table. */
599 ppc64_linux_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
601 struct target_ops
*targ
)
603 struct section_table
*s
= target_section_by_addr (targ
, addr
);
605 /* Check if ADDR points to a function descriptor. */
606 if (s
&& strcmp (s
->the_bfd_section
->name
, ".opd") == 0)
608 /* There may be relocations that need to be applied to the .opd
609 section. Unfortunately, this function may be called at a time
610 where these relocations have not yet been performed -- this can
611 happen for example shortly after a library has been loaded with
612 dlopen, but ld.so has not yet applied the relocations.
614 To cope with both the case where the relocation has been applied,
615 and the case where it has not yet been applied, we do *not* read
616 the (maybe) relocated value from target memory, but we instead
617 read the non-relocated value from the BFD, and apply the relocation
620 This makes the assumption that all .opd entries are always relocated
621 by the same offset the section itself was relocated. This should
622 always be the case for GNU/Linux executables and shared libraries.
623 Note that other kind of object files (e.g. those added via
624 add-symbol-files) will currently never end up here anyway, as this
625 function accesses *target* sections only; only the main exec and
626 shared libraries are ever added to the target. */
631 res
= bfd_get_section_contents (s
->bfd
, s
->the_bfd_section
,
632 &buf
, addr
- s
->addr
, 8);
634 return extract_unsigned_integer (buf
, 8)
635 - bfd_section_vma (s
->bfd
, s
->the_bfd_section
) + s
->addr
;
641 /* Wrappers to handle Linux-only registers. */
644 ppc_linux_supply_gregset (const struct regset
*regset
,
645 struct regcache
*regcache
,
646 int regnum
, const void *gregs
, size_t len
)
648 const struct ppc_reg_offsets
*offsets
= regset
->descr
;
650 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
652 if (ppc_linux_trap_reg_p (get_regcache_arch (regcache
)))
654 /* "orig_r3" is stored 2 slots after "pc". */
655 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
656 ppc_supply_reg (regcache
, PPC_ORIG_R3_REGNUM
, gregs
,
657 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
660 /* "trap" is stored 8 slots after "pc". */
661 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
662 ppc_supply_reg (regcache
, PPC_TRAP_REGNUM
, gregs
,
663 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
669 ppc_linux_collect_gregset (const struct regset
*regset
,
670 const struct regcache
*regcache
,
671 int regnum
, void *gregs
, size_t len
)
673 const struct ppc_reg_offsets
*offsets
= regset
->descr
;
675 /* Clear areas in the linux gregset not written elsewhere. */
677 memset (gregs
, 0, len
);
679 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
681 if (ppc_linux_trap_reg_p (get_regcache_arch (regcache
)))
683 /* "orig_r3" is stored 2 slots after "pc". */
684 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
685 ppc_collect_reg (regcache
, PPC_ORIG_R3_REGNUM
, gregs
,
686 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
689 /* "trap" is stored 8 slots after "pc". */
690 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
691 ppc_collect_reg (regcache
, PPC_TRAP_REGNUM
, gregs
,
692 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
697 /* Regset descriptions. */
698 static const struct ppc_reg_offsets ppc32_linux_reg_offsets
=
700 /* General-purpose registers. */
701 /* .r0_offset = */ 0,
704 /* .pc_offset = */ 128,
705 /* .ps_offset = */ 132,
706 /* .cr_offset = */ 152,
707 /* .lr_offset = */ 144,
708 /* .ctr_offset = */ 140,
709 /* .xer_offset = */ 148,
710 /* .mq_offset = */ 156,
712 /* Floating-point registers. */
713 /* .f0_offset = */ 0,
714 /* .fpscr_offset = */ 256,
715 /* .fpscr_size = */ 8,
717 /* AltiVec registers. */
718 /* .vr0_offset = */ 0,
719 /* .vscr_offset = */ 512 + 12,
720 /* .vrsave_offset = */ 528
723 static const struct ppc_reg_offsets ppc64_linux_reg_offsets
=
725 /* General-purpose registers. */
726 /* .r0_offset = */ 0,
729 /* .pc_offset = */ 256,
730 /* .ps_offset = */ 264,
731 /* .cr_offset = */ 304,
732 /* .lr_offset = */ 288,
733 /* .ctr_offset = */ 280,
734 /* .xer_offset = */ 296,
735 /* .mq_offset = */ 312,
737 /* Floating-point registers. */
738 /* .f0_offset = */ 0,
739 /* .fpscr_offset = */ 256,
740 /* .fpscr_size = */ 8,
742 /* AltiVec registers. */
743 /* .vr0_offset = */ 0,
744 /* .vscr_offset = */ 512 + 12,
745 /* .vrsave_offset = */ 528
748 static const struct regset ppc32_linux_gregset
= {
749 &ppc32_linux_reg_offsets
,
750 ppc_linux_supply_gregset
,
751 ppc_linux_collect_gregset
,
755 static const struct regset ppc64_linux_gregset
= {
756 &ppc64_linux_reg_offsets
,
757 ppc_linux_supply_gregset
,
758 ppc_linux_collect_gregset
,
762 static const struct regset ppc32_linux_fpregset
= {
763 &ppc32_linux_reg_offsets
,
765 ppc_collect_fpregset
,
769 static const struct regset ppc32_linux_vrregset
= {
770 &ppc32_linux_reg_offsets
,
772 ppc_collect_vrregset
,
776 static const struct regset ppc32_linux_vsxregset
= {
777 &ppc32_linux_reg_offsets
,
778 ppc_supply_vsxregset
,
779 ppc_collect_vsxregset
,
783 const struct regset
*
784 ppc_linux_gregset (int wordsize
)
786 return wordsize
== 8 ? &ppc64_linux_gregset
: &ppc32_linux_gregset
;
789 const struct regset
*
790 ppc_linux_fpregset (void)
792 return &ppc32_linux_fpregset
;
795 static const struct regset
*
796 ppc_linux_regset_from_core_section (struct gdbarch
*core_arch
,
797 const char *sect_name
, size_t sect_size
)
799 struct gdbarch_tdep
*tdep
= gdbarch_tdep (core_arch
);
800 if (strcmp (sect_name
, ".reg") == 0)
802 if (tdep
->wordsize
== 4)
803 return &ppc32_linux_gregset
;
805 return &ppc64_linux_gregset
;
807 if (strcmp (sect_name
, ".reg2") == 0)
808 return &ppc32_linux_fpregset
;
809 if (strcmp (sect_name
, ".reg-ppc-vmx") == 0)
810 return &ppc32_linux_vrregset
;
811 if (strcmp (sect_name
, ".reg-ppc-vsx") == 0)
812 return &ppc32_linux_vsxregset
;
817 ppc_linux_sigtramp_cache (struct frame_info
*this_frame
,
818 struct trad_frame_cache
*this_cache
,
819 CORE_ADDR func
, LONGEST offset
,
827 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
828 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
830 base
= get_frame_register_unsigned (this_frame
,
831 gdbarch_sp_regnum (gdbarch
));
832 if (bias
> 0 && get_frame_pc (this_frame
) != func
)
833 /* See below, some signal trampolines increment the stack as their
834 first instruction, need to compensate for that. */
837 /* Find the address of the register buffer pointer. */
838 regs
= base
+ offset
;
839 /* Use that to find the address of the corresponding register
841 gpregs
= read_memory_unsigned_integer (regs
, tdep
->wordsize
);
842 fpregs
= gpregs
+ 48 * tdep
->wordsize
;
844 /* General purpose. */
845 for (i
= 0; i
< 32; i
++)
847 int regnum
= i
+ tdep
->ppc_gp0_regnum
;
848 trad_frame_set_reg_addr (this_cache
, regnum
, gpregs
+ i
* tdep
->wordsize
);
850 trad_frame_set_reg_addr (this_cache
,
851 gdbarch_pc_regnum (gdbarch
),
852 gpregs
+ 32 * tdep
->wordsize
);
853 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_ctr_regnum
,
854 gpregs
+ 35 * tdep
->wordsize
);
855 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_lr_regnum
,
856 gpregs
+ 36 * tdep
->wordsize
);
857 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_xer_regnum
,
858 gpregs
+ 37 * tdep
->wordsize
);
859 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_cr_regnum
,
860 gpregs
+ 38 * tdep
->wordsize
);
862 if (ppc_linux_trap_reg_p (gdbarch
))
864 trad_frame_set_reg_addr (this_cache
, PPC_ORIG_R3_REGNUM
,
865 gpregs
+ 34 * tdep
->wordsize
);
866 trad_frame_set_reg_addr (this_cache
, PPC_TRAP_REGNUM
,
867 gpregs
+ 40 * tdep
->wordsize
);
870 if (ppc_floating_point_unit_p (gdbarch
))
872 /* Floating point registers. */
873 for (i
= 0; i
< 32; i
++)
875 int regnum
= i
+ gdbarch_fp0_regnum (gdbarch
);
876 trad_frame_set_reg_addr (this_cache
, regnum
,
877 fpregs
+ i
* tdep
->wordsize
);
879 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_fpscr_regnum
,
880 fpregs
+ 32 * tdep
->wordsize
);
882 trad_frame_set_id (this_cache
, frame_id_build (base
, func
));
886 ppc32_linux_sigaction_cache_init (const struct tramp_frame
*self
,
887 struct frame_info
*this_frame
,
888 struct trad_frame_cache
*this_cache
,
891 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
892 0xd0 /* Offset to ucontext_t. */
893 + 0x30 /* Offset to .reg. */,
898 ppc64_linux_sigaction_cache_init (const struct tramp_frame
*self
,
899 struct frame_info
*this_frame
,
900 struct trad_frame_cache
*this_cache
,
903 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
904 0x80 /* Offset to ucontext_t. */
905 + 0xe0 /* Offset to .reg. */,
910 ppc32_linux_sighandler_cache_init (const struct tramp_frame
*self
,
911 struct frame_info
*this_frame
,
912 struct trad_frame_cache
*this_cache
,
915 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
916 0x40 /* Offset to ucontext_t. */
917 + 0x1c /* Offset to .reg. */,
922 ppc64_linux_sighandler_cache_init (const struct tramp_frame
*self
,
923 struct frame_info
*this_frame
,
924 struct trad_frame_cache
*this_cache
,
927 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
928 0x80 /* Offset to struct sigcontext. */
929 + 0x38 /* Offset to .reg. */,
933 static struct tramp_frame ppc32_linux_sigaction_tramp_frame
= {
937 { 0x380000ac, -1 }, /* li r0, 172 */
938 { 0x44000002, -1 }, /* sc */
939 { TRAMP_SENTINEL_INSN
},
941 ppc32_linux_sigaction_cache_init
943 static struct tramp_frame ppc64_linux_sigaction_tramp_frame
= {
947 { 0x38210080, -1 }, /* addi r1,r1,128 */
948 { 0x380000ac, -1 }, /* li r0, 172 */
949 { 0x44000002, -1 }, /* sc */
950 { TRAMP_SENTINEL_INSN
},
952 ppc64_linux_sigaction_cache_init
954 static struct tramp_frame ppc32_linux_sighandler_tramp_frame
= {
958 { 0x38000077, -1 }, /* li r0,119 */
959 { 0x44000002, -1 }, /* sc */
960 { TRAMP_SENTINEL_INSN
},
962 ppc32_linux_sighandler_cache_init
964 static struct tramp_frame ppc64_linux_sighandler_tramp_frame
= {
968 { 0x38210080, -1 }, /* addi r1,r1,128 */
969 { 0x38000077, -1 }, /* li r0,119 */
970 { 0x44000002, -1 }, /* sc */
971 { TRAMP_SENTINEL_INSN
},
973 ppc64_linux_sighandler_cache_init
977 /* Return 1 if PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM are usable. */
979 ppc_linux_trap_reg_p (struct gdbarch
*gdbarch
)
981 /* If we do not have a target description with registers, then
982 the special registers will not be included in the register set. */
983 if (!tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
986 /* If we do, then it is safe to check the size. */
987 return register_size (gdbarch
, PPC_ORIG_R3_REGNUM
) > 0
988 && register_size (gdbarch
, PPC_TRAP_REGNUM
) > 0;
992 ppc_linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
994 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
996 regcache_cooked_write_unsigned (regcache
, gdbarch_pc_regnum (gdbarch
), pc
);
998 /* Set special TRAP register to -1 to prevent the kernel from
999 messing with the PC we just installed, if we happen to be
1000 within an interrupted system call that the kernel wants to
1003 Note that after we return from the dummy call, the TRAP and
1004 ORIG_R3 registers will be automatically restored, and the
1005 kernel continues to restart the system call at this point. */
1006 if (ppc_linux_trap_reg_p (gdbarch
))
1007 regcache_cooked_write_unsigned (regcache
, PPC_TRAP_REGNUM
, -1);
1010 static const struct target_desc
*
1011 ppc_linux_core_read_description (struct gdbarch
*gdbarch
,
1012 struct target_ops
*target
,
1015 asection
*altivec
= bfd_get_section_by_name (abfd
, ".reg-ppc-vmx");
1016 asection
*vsx
= bfd_get_section_by_name (abfd
, ".reg-ppc-vsx");
1017 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
1021 switch (bfd_section_size (abfd
, section
))
1025 return tdesc_powerpc_vsx32l
;
1027 return tdesc_powerpc_altivec32l
;
1029 return tdesc_powerpc_32l
;
1033 return tdesc_powerpc_vsx64l
;
1035 return tdesc_powerpc_altivec64l
;
1037 return tdesc_powerpc_64l
;
1045 ppc_linux_init_abi (struct gdbarch_info info
,
1046 struct gdbarch
*gdbarch
)
1048 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1049 struct tdesc_arch_data
*tdesc_data
= (void *) info
.tdep_info
;
1051 /* PPC GNU/Linux uses either 64-bit or 128-bit long doubles; where
1052 128-bit, they are IBM long double, not IEEE quad long double as
1053 in the System V ABI PowerPC Processor Supplement. We can safely
1054 let them default to 128-bit, since the debug info will give the
1055 size of type actually used in each case. */
1056 set_gdbarch_long_double_bit (gdbarch
, 16 * TARGET_CHAR_BIT
);
1057 set_gdbarch_long_double_format (gdbarch
, floatformats_ibm_long_double
);
1059 /* Handle inferior calls during interrupted system calls. */
1060 set_gdbarch_write_pc (gdbarch
, ppc_linux_write_pc
);
1062 if (tdep
->wordsize
== 4)
1064 /* Until November 2001, gcc did not comply with the 32 bit SysV
1065 R4 ABI requirement that structures less than or equal to 8
1066 bytes should be returned in registers. Instead GCC was using
1067 the the AIX/PowerOpen ABI - everything returned in memory
1068 (well ignoring vectors that is). When this was corrected, it
1069 wasn't fixed for GNU/Linux native platform. Use the
1070 PowerOpen struct convention. */
1071 set_gdbarch_return_value (gdbarch
, ppc_linux_return_value
);
1073 set_gdbarch_memory_remove_breakpoint (gdbarch
,
1074 ppc_linux_memory_remove_breakpoint
);
1076 /* Shared library handling. */
1077 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1078 set_solib_svr4_fetch_link_map_offsets
1079 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1082 tramp_frame_prepend_unwinder (gdbarch
, &ppc32_linux_sigaction_tramp_frame
);
1083 tramp_frame_prepend_unwinder (gdbarch
, &ppc32_linux_sighandler_tramp_frame
);
1086 if (tdep
->wordsize
== 8)
1088 /* Handle PPC GNU/Linux 64-bit function pointers (which are really
1089 function descriptors). */
1090 set_gdbarch_convert_from_func_ptr_addr
1091 (gdbarch
, ppc64_linux_convert_from_func_ptr_addr
);
1093 /* Shared library handling. */
1094 set_gdbarch_skip_trampoline_code (gdbarch
, ppc64_skip_trampoline_code
);
1095 set_solib_svr4_fetch_link_map_offsets
1096 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
1099 tramp_frame_prepend_unwinder (gdbarch
, &ppc64_linux_sigaction_tramp_frame
);
1100 tramp_frame_prepend_unwinder (gdbarch
, &ppc64_linux_sighandler_tramp_frame
);
1102 set_gdbarch_regset_from_core_section (gdbarch
, ppc_linux_regset_from_core_section
);
1103 set_gdbarch_core_read_description (gdbarch
, ppc_linux_core_read_description
);
1105 /* Supported register sections. */
1106 set_gdbarch_core_regset_sections (gdbarch
, ppc_linux_regset_sections
);
1108 /* Enable TLS support. */
1109 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
1110 svr4_fetch_objfile_link_map
);
1114 const struct tdesc_feature
*feature
;
1116 /* If we have target-described registers, then we can safely
1117 reserve a number for PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM
1118 (whether they are described or not). */
1119 gdb_assert (gdbarch_num_regs (gdbarch
) <= PPC_ORIG_R3_REGNUM
);
1120 set_gdbarch_num_regs (gdbarch
, PPC_TRAP_REGNUM
+ 1);
1122 /* If they are present, then assign them to the reserved number. */
1123 feature
= tdesc_find_feature (info
.target_desc
,
1124 "org.gnu.gdb.power.linux");
1125 if (feature
!= NULL
)
1127 tdesc_numbered_register (feature
, tdesc_data
,
1128 PPC_ORIG_R3_REGNUM
, "orig_r3");
1129 tdesc_numbered_register (feature
, tdesc_data
,
1130 PPC_TRAP_REGNUM
, "trap");
1136 _initialize_ppc_linux_tdep (void)
1138 /* Register for all sub-familes of the POWER/PowerPC: 32-bit and
1139 64-bit PowerPC, and the older rs6k. */
1140 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc
, GDB_OSABI_LINUX
,
1141 ppc_linux_init_abi
);
1142 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc64
, GDB_OSABI_LINUX
,
1143 ppc_linux_init_abi
);
1144 gdbarch_register_osabi (bfd_arch_rs6000
, bfd_mach_rs6k
, GDB_OSABI_LINUX
,
1145 ppc_linux_init_abi
);
1147 /* Initialize the Linux target descriptions. */
1148 initialize_tdesc_powerpc_32l ();
1149 initialize_tdesc_powerpc_altivec32l ();
1150 initialize_tdesc_powerpc_vsx32l ();
1151 initialize_tdesc_powerpc_64l ();
1152 initialize_tdesc_powerpc_altivec64l ();
1153 initialize_tdesc_powerpc_vsx64l ();
1154 initialize_tdesc_powerpc_e500l ();