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
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 2 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, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
37 #include "solib-svr4.h"
39 #include "trad-frame.h"
40 #include "frame-unwind.h"
41 #include "tramp-frame.h"
43 /* From <asm/ptrace.h>, values for PT_NIP, PT_R1, and PT_LNK */
44 #define PPC_LINUX_PT_R0 0
45 #define PPC_LINUX_PT_R1 1
46 #define PPC_LINUX_PT_R2 2
47 #define PPC_LINUX_PT_R3 3
48 #define PPC_LINUX_PT_R4 4
49 #define PPC_LINUX_PT_R5 5
50 #define PPC_LINUX_PT_R6 6
51 #define PPC_LINUX_PT_R7 7
52 #define PPC_LINUX_PT_R8 8
53 #define PPC_LINUX_PT_R9 9
54 #define PPC_LINUX_PT_R10 10
55 #define PPC_LINUX_PT_R11 11
56 #define PPC_LINUX_PT_R12 12
57 #define PPC_LINUX_PT_R13 13
58 #define PPC_LINUX_PT_R14 14
59 #define PPC_LINUX_PT_R15 15
60 #define PPC_LINUX_PT_R16 16
61 #define PPC_LINUX_PT_R17 17
62 #define PPC_LINUX_PT_R18 18
63 #define PPC_LINUX_PT_R19 19
64 #define PPC_LINUX_PT_R20 20
65 #define PPC_LINUX_PT_R21 21
66 #define PPC_LINUX_PT_R22 22
67 #define PPC_LINUX_PT_R23 23
68 #define PPC_LINUX_PT_R24 24
69 #define PPC_LINUX_PT_R25 25
70 #define PPC_LINUX_PT_R26 26
71 #define PPC_LINUX_PT_R27 27
72 #define PPC_LINUX_PT_R28 28
73 #define PPC_LINUX_PT_R29 29
74 #define PPC_LINUX_PT_R30 30
75 #define PPC_LINUX_PT_R31 31
76 #define PPC_LINUX_PT_NIP 32
77 #define PPC_LINUX_PT_MSR 33
78 #define PPC_LINUX_PT_CTR 35
79 #define PPC_LINUX_PT_LNK 36
80 #define PPC_LINUX_PT_XER 37
81 #define PPC_LINUX_PT_CCR 38
82 #define PPC_LINUX_PT_MQ 39
83 #define PPC_LINUX_PT_FPR0 48 /* each FP reg occupies 2 slots in this space */
84 #define PPC_LINUX_PT_FPR31 (PPC_LINUX_PT_FPR0 + 2*31)
85 #define PPC_LINUX_PT_FPSCR (PPC_LINUX_PT_FPR0 + 2*32 + 1)
89 ppc_linux_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
92 struct obj_section
*sect
;
93 struct objfile
*objfile
;
95 CORE_ADDR plt_start
= 0;
105 struct minimal_symbol
*msymbol
;
107 /* Find the section pc is in; return if not in .plt */
108 sect
= find_pc_section (pc
);
109 if (!sect
|| strcmp (sect
->the_bfd_section
->name
, ".plt") != 0)
112 objfile
= sect
->objfile
;
114 /* Pick up the instruction at pc. It had better be of the
118 where IDX is an index into the plt_table. */
120 if (target_read_memory (pc
, buf
, 4) != 0)
122 insn
= extract_unsigned_integer (buf
, 4);
124 if ((insn
& 0xffff0000) != 0x39600000 /* li r11, VAL */ )
127 reloc_index
= (insn
<< 16) >> 16;
129 /* Find the objfile that pc is in and obtain the information
130 necessary for finding the symbol name. */
131 for (sect
= objfile
->sections
; sect
< objfile
->sections_end
; ++sect
)
133 const char *secname
= sect
->the_bfd_section
->name
;
134 if (strcmp (secname
, ".plt") == 0)
135 plt_start
= sect
->addr
;
136 else if (strcmp (secname
, ".rela.plt") == 0)
137 num_slots
= ((int) sect
->endaddr
- (int) sect
->addr
) / 12;
138 else if (strcmp (secname
, ".dynsym") == 0)
140 else if (strcmp (secname
, ".dynstr") == 0)
144 /* Make sure we have all the information we need. */
145 if (plt_start
== 0 || num_slots
== -1 || symtab
== 0 || strtab
== 0)
148 /* Compute the value of the plt table */
149 plt_table
= plt_start
+ 72 + 8 * num_slots
;
151 /* Get address of the relocation entry (Elf32_Rela) */
152 if (target_read_memory (plt_table
+ reloc_index
, buf
, 4) != 0)
154 reloc
= extract_unsigned_integer (buf
, 4);
156 sect
= find_pc_section (reloc
);
160 if (strcmp (sect
->the_bfd_section
->name
, ".text") == 0)
163 /* Now get the r_info field which is the relocation type and symbol
165 if (target_read_memory (reloc
+ 4, buf
, 4) != 0)
167 symidx
= extract_unsigned_integer (buf
, 4);
169 /* Shift out the relocation type leaving just the symbol index */
170 /* symidx = ELF32_R_SYM(symidx); */
171 symidx
= symidx
>> 8;
173 /* compute the address of the symbol */
174 sym
= symtab
+ symidx
* 4;
176 /* Fetch the string table index */
177 if (target_read_memory (sym
, buf
, 4) != 0)
179 symidx
= extract_unsigned_integer (buf
, 4);
181 /* Fetch the string; we don't know how long it is. Is it possible
182 that the following will fail because we're trying to fetch too
184 if (target_read_memory (strtab
+ symidx
, (gdb_byte
*) symname
,
185 sizeof (symname
)) != 0)
188 /* This might not work right if we have multiple symbols with the
189 same name; the only way to really get it right is to perform
190 the same sort of lookup as the dynamic linker. */
191 msymbol
= lookup_minimal_symbol_text (symname
, NULL
);
195 return SYMBOL_VALUE_ADDRESS (msymbol
);
198 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
199 in much the same fashion as memory_remove_breakpoint in mem-break.c,
200 but is careful not to write back the previous contents if the code
201 in question has changed in between inserting the breakpoint and
204 Here is the problem that we're trying to solve...
206 Once upon a time, before introducing this function to remove
207 breakpoints from the inferior, setting a breakpoint on a shared
208 library function prior to running the program would not work
209 properly. In order to understand the problem, it is first
210 necessary to understand a little bit about dynamic linking on
213 A call to a shared library function is accomplished via a bl
214 (branch-and-link) instruction whose branch target is an entry
215 in the procedure linkage table (PLT). The PLT in the object
216 file is uninitialized. To gdb, prior to running the program, the
217 entries in the PLT are all zeros.
219 Once the program starts running, the shared libraries are loaded
220 and the procedure linkage table is initialized, but the entries in
221 the table are not (necessarily) resolved. Once a function is
222 actually called, the code in the PLT is hit and the function is
223 resolved. In order to better illustrate this, an example is in
224 order; the following example is from the gdb testsuite.
226 We start the program shmain.
228 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
231 We place two breakpoints, one on shr1 and the other on main.
234 Breakpoint 1 at 0x100409d4
236 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
238 Examine the instruction (and the immediatly following instruction)
239 upon which the breakpoint was placed. Note that the PLT entry
240 for shr1 contains zeros.
242 (gdb) x/2i 0x100409d4
243 0x100409d4 <shr1>: .long 0x0
244 0x100409d8 <shr1+4>: .long 0x0
249 Starting program: gdb.base/shmain
250 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
252 Breakpoint 2, main ()
253 at gdb.base/shmain.c:44
256 Examine the PLT again. Note that the loading of the shared
257 library has initialized the PLT to code which loads a constant
258 (which I think is an index into the GOT) into r11 and then
259 branchs a short distance to the code which actually does the
262 (gdb) x/2i 0x100409d4
263 0x100409d4 <shr1>: li r11,4
264 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
268 Breakpoint 1, shr1 (x=1)
269 at gdb.base/shr1.c:19
272 Now we've hit the breakpoint at shr1. (The breakpoint was
273 reset from the PLT entry to the actual shr1 function after the
274 shared library was loaded.) Note that the PLT entry has been
275 resolved to contain a branch that takes us directly to shr1.
276 (The real one, not the PLT entry.)
278 (gdb) x/2i 0x100409d4
279 0x100409d4 <shr1>: b 0xffaf76c <shr1>
280 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
282 The thing to note here is that the PLT entry for shr1 has been
285 Now the problem should be obvious. GDB places a breakpoint (a
286 trap instruction) on the zero value of the PLT entry for shr1.
287 Later on, after the shared library had been loaded and the PLT
288 initialized, GDB gets a signal indicating this fact and attempts
289 (as it always does when it stops) to remove all the breakpoints.
291 The breakpoint removal was causing the former contents (a zero
292 word) to be written back to the now initialized PLT entry thus
293 destroying a portion of the initialization that had occurred only a
294 short time ago. When execution continued, the zero word would be
295 executed as an instruction an an illegal instruction trap was
296 generated instead. (0 is not a legal instruction.)
298 The fix for this problem was fairly straightforward. The function
299 memory_remove_breakpoint from mem-break.c was copied to this file,
300 modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
301 In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
304 The differences between ppc_linux_memory_remove_breakpoint () and
305 memory_remove_breakpoint () are minor. All that the former does
306 that the latter does not is check to make sure that the breakpoint
307 location actually contains a breakpoint (trap instruction) prior
308 to attempting to write back the old contents. If it does contain
309 a trap instruction, we allow the old contents to be written back.
310 Otherwise, we silently do nothing.
312 The big question is whether memory_remove_breakpoint () should be
313 changed to have the same functionality. The downside is that more
314 traffic is generated for remote targets since we'll have an extra
315 fetch of a memory word each time a breakpoint is removed.
317 For the time being, we'll leave this self-modifying-code-friendly
318 version in ppc-linux-tdep.c, but it ought to be migrated somewhere
319 else in the event that some other platform has similar needs with
320 regard to removing breakpoints in some potentially self modifying
323 ppc_linux_memory_remove_breakpoint (struct bp_target_info
*bp_tgt
)
325 CORE_ADDR addr
= bp_tgt
->placed_address
;
326 const unsigned char *bp
;
329 gdb_byte old_contents
[BREAKPOINT_MAX
];
331 /* Determine appropriate breakpoint contents and size for this address. */
332 bp
= gdbarch_breakpoint_from_pc (current_gdbarch
, &addr
, &bplen
);
334 error (_("Software breakpoints not implemented for this target."));
336 val
= target_read_memory (addr
, old_contents
, bplen
);
338 /* If our breakpoint is no longer at the address, this means that the
339 program modified the code on us, so it is wrong to put back the
341 if (val
== 0 && memcmp (bp
, old_contents
, bplen
) == 0)
342 val
= target_write_memory (addr
, bp_tgt
->shadow_contents
, bplen
);
347 /* For historic reasons, PPC 32 GNU/Linux follows PowerOpen rather
348 than the 32 bit SYSV R4 ABI structure return convention - all
349 structures, no matter their size, are put in memory. Vectors,
350 which were added later, do get returned in a register though. */
352 static enum return_value_convention
353 ppc_linux_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
,
354 struct regcache
*regcache
, gdb_byte
*readbuf
,
355 const gdb_byte
*writebuf
)
357 if ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
358 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
)
359 && !((TYPE_LENGTH (valtype
) == 16 || TYPE_LENGTH (valtype
) == 8)
360 && TYPE_VECTOR (valtype
)))
361 return RETURN_VALUE_STRUCT_CONVENTION
;
363 return ppc_sysv_abi_return_value (gdbarch
, valtype
, regcache
, readbuf
,
367 /* Macros for matching instructions. Note that, since all the
368 operands are masked off before they're or-ed into the instruction,
369 you can use -1 to make masks. */
371 #define insn_d(opcd, rts, ra, d) \
372 ((((opcd) & 0x3f) << 26) \
373 | (((rts) & 0x1f) << 21) \
374 | (((ra) & 0x1f) << 16) \
377 #define insn_ds(opcd, rts, ra, d, xo) \
378 ((((opcd) & 0x3f) << 26) \
379 | (((rts) & 0x1f) << 21) \
380 | (((ra) & 0x1f) << 16) \
384 #define insn_xfx(opcd, rts, spr, xo) \
385 ((((opcd) & 0x3f) << 26) \
386 | (((rts) & 0x1f) << 21) \
387 | (((spr) & 0x1f) << 16) \
388 | (((spr) & 0x3e0) << 6) \
389 | (((xo) & 0x3ff) << 1))
391 /* Read a PPC instruction from memory. PPC instructions are always
392 big-endian, no matter what endianness the program is running in, so
393 we can't use read_memory_integer or one of its friends here. */
395 read_insn (CORE_ADDR pc
)
397 unsigned char buf
[4];
399 read_memory (pc
, buf
, 4);
400 return (buf
[0] << 24) | (buf
[1] << 16) | (buf
[2] << 8) | buf
[3];
404 /* An instruction to match. */
407 unsigned int mask
; /* mask the insn with this... */
408 unsigned int data
; /* ...and see if it matches this. */
409 int optional
; /* If non-zero, this insn may be absent. */
412 /* Return non-zero if the instructions at PC match the series
413 described in PATTERN, or zero otherwise. PATTERN is an array of
414 'struct insn_pattern' objects, terminated by an entry whose mask is
417 When the match is successful, fill INSN[i] with what PATTERN[i]
418 matched. If PATTERN[i] is optional, and the instruction wasn't
419 present, set INSN[i] to 0 (which is not a valid PPC instruction).
420 INSN should have as many elements as PATTERN. Note that, if
421 PATTERN contains optional instructions which aren't present in
422 memory, then INSN will have holes, so INSN[i] isn't necessarily the
423 i'th instruction in memory. */
425 insns_match_pattern (CORE_ADDR pc
,
426 struct insn_pattern
*pattern
,
431 for (i
= 0; pattern
[i
].mask
; i
++)
433 insn
[i
] = read_insn (pc
);
434 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
436 else if (pattern
[i
].optional
)
446 /* Return the 'd' field of the d-form instruction INSN, properly
449 insn_d_field (unsigned int insn
)
451 return ((((CORE_ADDR
) insn
& 0xffff) ^ 0x8000) - 0x8000);
455 /* Return the 'ds' field of the ds-form instruction INSN, with the two
456 zero bits concatenated at the right, and properly
459 insn_ds_field (unsigned int insn
)
461 return ((((CORE_ADDR
) insn
& 0xfffc) ^ 0x8000) - 0x8000);
465 /* If DESC is the address of a 64-bit PowerPC GNU/Linux function
466 descriptor, return the descriptor's entry point. */
468 ppc64_desc_entry_point (CORE_ADDR desc
)
470 /* The first word of the descriptor is the entry point. */
471 return (CORE_ADDR
) read_memory_unsigned_integer (desc
, 8);
475 /* Pattern for the standard linkage function. These are built by
476 build_plt_stub in elf64-ppc.c, whose GLINK argument is always
478 static struct insn_pattern ppc64_standard_linkage
[] =
480 /* addis r12, r2, <any> */
481 { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
484 { -1, insn_ds (62, 2, 1, 40, 0), 0 },
486 /* ld r11, <any>(r12) */
487 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
489 /* addis r12, r12, 1 <optional> */
490 { insn_d (-1, -1, -1, -1), insn_d (15, 12, 2, 1), 1 },
492 /* ld r2, <any>(r12) */
493 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
495 /* addis r12, r12, 1 <optional> */
496 { insn_d (-1, -1, -1, -1), insn_d (15, 12, 2, 1), 1 },
499 { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467),
502 /* ld r11, <any>(r12) */
503 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
506 { -1, 0x4e800420, 0 },
510 #define PPC64_STANDARD_LINKAGE_LEN \
511 (sizeof (ppc64_standard_linkage) / sizeof (ppc64_standard_linkage[0]))
513 /* When the dynamic linker is doing lazy symbol resolution, the first
514 call to a function in another object will go like this:
516 - The user's function calls the linkage function:
518 100007c4: 4b ff fc d5 bl 10000498
519 100007c8: e8 41 00 28 ld r2,40(r1)
521 - The linkage function loads the entry point (and other stuff) from
522 the function descriptor in the PLT, and jumps to it:
524 10000498: 3d 82 00 00 addis r12,r2,0
525 1000049c: f8 41 00 28 std r2,40(r1)
526 100004a0: e9 6c 80 98 ld r11,-32616(r12)
527 100004a4: e8 4c 80 a0 ld r2,-32608(r12)
528 100004a8: 7d 69 03 a6 mtctr r11
529 100004ac: e9 6c 80 a8 ld r11,-32600(r12)
530 100004b0: 4e 80 04 20 bctr
532 - But since this is the first time that PLT entry has been used, it
533 sends control to its glink entry. That loads the number of the
534 PLT entry and jumps to the common glink0 code:
536 10000c98: 38 00 00 00 li r0,0
537 10000c9c: 4b ff ff dc b 10000c78
539 - The common glink0 code then transfers control to the dynamic
542 10000c78: e8 41 00 28 ld r2,40(r1)
543 10000c7c: 3d 82 00 00 addis r12,r2,0
544 10000c80: e9 6c 80 80 ld r11,-32640(r12)
545 10000c84: e8 4c 80 88 ld r2,-32632(r12)
546 10000c88: 7d 69 03 a6 mtctr r11
547 10000c8c: e9 6c 80 90 ld r11,-32624(r12)
548 10000c90: 4e 80 04 20 bctr
550 Eventually, this code will figure out how to skip all of this,
551 including the dynamic linker. At the moment, we just get through
552 the linkage function. */
554 /* If the current thread is about to execute a series of instructions
555 at PC matching the ppc64_standard_linkage pattern, and INSN is the result
556 from that pattern match, return the code address to which the
557 standard linkage function will send them. (This doesn't deal with
558 dynamic linker lazy symbol resolution stubs.) */
560 ppc64_standard_linkage_target (struct frame_info
*frame
,
561 CORE_ADDR pc
, unsigned int *insn
)
563 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
565 /* The address of the function descriptor this linkage function
568 = ((CORE_ADDR
) get_frame_register_unsigned (frame
,
569 tdep
->ppc_gp0_regnum
+ 2)
570 + (insn_d_field (insn
[0]) << 16)
571 + insn_ds_field (insn
[2]));
573 /* The first word of the descriptor is the entry point. Return that. */
574 return ppc64_desc_entry_point (desc
);
578 /* Given that we've begun executing a call trampoline at PC, return
579 the entry point of the function the trampoline will go to. */
581 ppc64_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
583 unsigned int ppc64_standard_linkage_insn
[PPC64_STANDARD_LINKAGE_LEN
];
585 if (insns_match_pattern (pc
, ppc64_standard_linkage
,
586 ppc64_standard_linkage_insn
))
587 return ppc64_standard_linkage_target (frame
, pc
,
588 ppc64_standard_linkage_insn
);
594 /* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC
597 Usually a function pointer's representation is simply the address
598 of the function. On GNU/Linux on the PowerPC however, a function
599 pointer may be a pointer to a function descriptor.
601 For PPC64, a function descriptor is a TOC entry, in a data section,
602 which contains three words: the first word is the address of the
603 function, the second word is the TOC pointer (r2), and the third word
604 is the static chain value.
606 For PPC32, there are two kinds of function pointers: non-secure and
607 secure. Non-secure function pointers point directly to the
608 function in a code section and thus need no translation. Secure
609 ones (from GCC's -msecure-plt option) are in a data section and
610 contain one word: the address of the function.
612 Throughout GDB it is currently assumed that a function pointer contains
613 the address of the function, which is not easy to fix. In addition, the
614 conversion of a function address to a function pointer would
615 require allocation of a TOC entry in the inferior's memory space,
616 with all its drawbacks. To be able to call C++ virtual methods in
617 the inferior (which are called via function pointers),
618 find_function_addr uses this function to get the function address
619 from a function pointer.
621 If ADDR points at what is clearly a function descriptor, transform
622 it into the address of the corresponding function, if needed. Be
623 conservative, otherwise GDB will do the transformation on any
624 random addresses such as occur when there is no symbol table. */
627 ppc_linux_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
629 struct target_ops
*targ
)
631 struct gdbarch_tdep
*tdep
;
632 struct section_table
*s
= target_section_by_addr (targ
, addr
);
633 char *sect_name
= NULL
;
638 tdep
= gdbarch_tdep (gdbarch
);
640 switch (tdep
->wordsize
)
649 internal_error (__FILE__
, __LINE__
,
650 _("failed internal consistency check"));
653 /* Check if ADDR points to a function descriptor. */
655 /* NOTE: this depends on the coincidence that the address of a functions
656 entry point is contained in the first word of its function descriptor
657 for both PPC-64 and for PPC-32 with secure PLTs. */
658 if ((strcmp (s
->the_bfd_section
->name
, sect_name
) == 0)
659 && s
->the_bfd_section
->flags
& SEC_DATA
)
660 return get_target_memory_unsigned (targ
, addr
, tdep
->wordsize
);
666 right_supply_register (struct regcache
*regcache
, int wordsize
, int regnum
,
669 regcache_raw_supply (regcache
, regnum
,
670 (buf
+ wordsize
- register_size (current_gdbarch
, regnum
)));
673 /* Extract the register values found in the WORDSIZED ABI GREGSET,
674 storing their values in REGCACHE. Note that some are left-aligned,
675 while others are right aligned. */
678 ppc_linux_supply_gregset (struct regcache
*regcache
,
679 int regnum
, const void *gregs
, size_t size
,
683 struct gdbarch
*regcache_arch
= get_regcache_arch (regcache
);
684 struct gdbarch_tdep
*regcache_tdep
= gdbarch_tdep (regcache_arch
);
685 const bfd_byte
*buf
= gregs
;
687 for (regi
= 0; regi
< ppc_num_gprs
; regi
++)
688 right_supply_register (regcache
, wordsize
,
689 regcache_tdep
->ppc_gp0_regnum
+ regi
,
690 buf
+ wordsize
* regi
);
692 right_supply_register (regcache
, wordsize
, gdbarch_pc_regnum (regcache_arch
),
693 buf
+ wordsize
* PPC_LINUX_PT_NIP
);
694 right_supply_register (regcache
, wordsize
, regcache_tdep
->ppc_lr_regnum
,
695 buf
+ wordsize
* PPC_LINUX_PT_LNK
);
696 regcache_raw_supply (regcache
, regcache_tdep
->ppc_cr_regnum
,
697 buf
+ wordsize
* PPC_LINUX_PT_CCR
);
698 regcache_raw_supply (regcache
, regcache_tdep
->ppc_xer_regnum
,
699 buf
+ wordsize
* PPC_LINUX_PT_XER
);
700 regcache_raw_supply (regcache
, regcache_tdep
->ppc_ctr_regnum
,
701 buf
+ wordsize
* PPC_LINUX_PT_CTR
);
702 if (regcache_tdep
->ppc_mq_regnum
!= -1)
703 right_supply_register (regcache
, wordsize
, regcache_tdep
->ppc_mq_regnum
,
704 buf
+ wordsize
* PPC_LINUX_PT_MQ
);
705 right_supply_register (regcache
, wordsize
, regcache_tdep
->ppc_ps_regnum
,
706 buf
+ wordsize
* PPC_LINUX_PT_MSR
);
710 ppc32_linux_supply_gregset (const struct regset
*regset
,
711 struct regcache
*regcache
,
712 int regnum
, const void *gregs
, size_t size
)
714 ppc_linux_supply_gregset (regcache
, regnum
, gregs
, size
, 4);
717 static struct regset ppc32_linux_gregset
= {
718 NULL
, ppc32_linux_supply_gregset
722 ppc64_linux_supply_gregset (const struct regset
*regset
,
723 struct regcache
* regcache
,
724 int regnum
, const void *gregs
, size_t size
)
726 ppc_linux_supply_gregset (regcache
, regnum
, gregs
, size
, 8);
729 static struct regset ppc64_linux_gregset
= {
730 NULL
, ppc64_linux_supply_gregset
734 ppc_linux_supply_fpregset (const struct regset
*regset
,
735 struct regcache
* regcache
,
736 int regnum
, const void *fpset
, size_t size
)
739 struct gdbarch
*regcache_arch
= get_regcache_arch (regcache
);
740 struct gdbarch_tdep
*regcache_tdep
= gdbarch_tdep (regcache_arch
);
741 const bfd_byte
*buf
= fpset
;
743 if (! ppc_floating_point_unit_p (regcache_arch
))
746 for (regi
= 0; regi
< ppc_num_fprs
; regi
++)
747 regcache_raw_supply (regcache
,
748 regcache_tdep
->ppc_fp0_regnum
+ regi
,
751 /* The FPSCR is stored in the low order word of the last
752 doubleword in the fpregset. */
753 regcache_raw_supply (regcache
, regcache_tdep
->ppc_fpscr_regnum
,
757 static struct regset ppc_linux_fpregset
= { NULL
, ppc_linux_supply_fpregset
};
759 static const struct regset
*
760 ppc_linux_regset_from_core_section (struct gdbarch
*core_arch
,
761 const char *sect_name
, size_t sect_size
)
763 struct gdbarch_tdep
*tdep
= gdbarch_tdep (core_arch
);
764 if (strcmp (sect_name
, ".reg") == 0)
766 if (tdep
->wordsize
== 4)
767 return &ppc32_linux_gregset
;
769 return &ppc64_linux_gregset
;
771 if (strcmp (sect_name
, ".reg2") == 0)
772 return &ppc_linux_fpregset
;
777 ppc_linux_sigtramp_cache (struct frame_info
*next_frame
,
778 struct trad_frame_cache
*this_cache
,
779 CORE_ADDR func
, LONGEST offset
,
787 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
788 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
790 base
= frame_unwind_register_unsigned (next_frame
,
791 gdbarch_sp_regnum (current_gdbarch
));
792 if (bias
> 0 && frame_pc_unwind (next_frame
) != func
)
793 /* See below, some signal trampolines increment the stack as their
794 first instruction, need to compensate for that. */
797 /* Find the address of the register buffer pointer. */
798 regs
= base
+ offset
;
799 /* Use that to find the address of the corresponding register
801 gpregs
= read_memory_unsigned_integer (regs
, tdep
->wordsize
);
802 fpregs
= gpregs
+ 48 * tdep
->wordsize
;
804 /* General purpose. */
805 for (i
= 0; i
< 32; i
++)
807 int regnum
= i
+ tdep
->ppc_gp0_regnum
;
808 trad_frame_set_reg_addr (this_cache
, regnum
, gpregs
+ i
* tdep
->wordsize
);
810 trad_frame_set_reg_addr (this_cache
,
811 gdbarch_pc_regnum (current_gdbarch
),
812 gpregs
+ 32 * tdep
->wordsize
);
813 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_ctr_regnum
,
814 gpregs
+ 35 * tdep
->wordsize
);
815 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_lr_regnum
,
816 gpregs
+ 36 * tdep
->wordsize
);
817 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_xer_regnum
,
818 gpregs
+ 37 * tdep
->wordsize
);
819 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_cr_regnum
,
820 gpregs
+ 38 * tdep
->wordsize
);
822 if (ppc_floating_point_unit_p (gdbarch
))
824 /* Floating point registers. */
825 for (i
= 0; i
< 32; i
++)
827 int regnum
= i
+ gdbarch_fp0_regnum (current_gdbarch
);
828 trad_frame_set_reg_addr (this_cache
, regnum
,
829 fpregs
+ i
* tdep
->wordsize
);
831 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_fpscr_regnum
,
832 fpregs
+ 32 * tdep
->wordsize
);
834 trad_frame_set_id (this_cache
, frame_id_build (base
, func
));
838 ppc32_linux_sigaction_cache_init (const struct tramp_frame
*self
,
839 struct frame_info
*next_frame
,
840 struct trad_frame_cache
*this_cache
,
843 ppc_linux_sigtramp_cache (next_frame
, this_cache
, func
,
844 0xd0 /* Offset to ucontext_t. */
845 + 0x30 /* Offset to .reg. */,
850 ppc64_linux_sigaction_cache_init (const struct tramp_frame
*self
,
851 struct frame_info
*next_frame
,
852 struct trad_frame_cache
*this_cache
,
855 ppc_linux_sigtramp_cache (next_frame
, this_cache
, func
,
856 0x80 /* Offset to ucontext_t. */
857 + 0xe0 /* Offset to .reg. */,
862 ppc32_linux_sighandler_cache_init (const struct tramp_frame
*self
,
863 struct frame_info
*next_frame
,
864 struct trad_frame_cache
*this_cache
,
867 ppc_linux_sigtramp_cache (next_frame
, this_cache
, func
,
868 0x40 /* Offset to ucontext_t. */
869 + 0x1c /* Offset to .reg. */,
874 ppc64_linux_sighandler_cache_init (const struct tramp_frame
*self
,
875 struct frame_info
*next_frame
,
876 struct trad_frame_cache
*this_cache
,
879 ppc_linux_sigtramp_cache (next_frame
, this_cache
, func
,
880 0x80 /* Offset to struct sigcontext. */
881 + 0x38 /* Offset to .reg. */,
885 static struct tramp_frame ppc32_linux_sigaction_tramp_frame
= {
889 { 0x380000ac, -1 }, /* li r0, 172 */
890 { 0x44000002, -1 }, /* sc */
891 { TRAMP_SENTINEL_INSN
},
893 ppc32_linux_sigaction_cache_init
895 static struct tramp_frame ppc64_linux_sigaction_tramp_frame
= {
899 { 0x38210080, -1 }, /* addi r1,r1,128 */
900 { 0x380000ac, -1 }, /* li r0, 172 */
901 { 0x44000002, -1 }, /* sc */
902 { TRAMP_SENTINEL_INSN
},
904 ppc64_linux_sigaction_cache_init
906 static struct tramp_frame ppc32_linux_sighandler_tramp_frame
= {
910 { 0x38000077, -1 }, /* li r0,119 */
911 { 0x44000002, -1 }, /* sc */
912 { TRAMP_SENTINEL_INSN
},
914 ppc32_linux_sighandler_cache_init
916 static struct tramp_frame ppc64_linux_sighandler_tramp_frame
= {
920 { 0x38210080, -1 }, /* addi r1,r1,128 */
921 { 0x38000077, -1 }, /* li r0,119 */
922 { 0x44000002, -1 }, /* sc */
923 { TRAMP_SENTINEL_INSN
},
925 ppc64_linux_sighandler_cache_init
929 ppc_linux_init_abi (struct gdbarch_info info
,
930 struct gdbarch
*gdbarch
)
932 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
934 /* NOTE: jimb/2004-03-26: The System V ABI PowerPC Processor
935 Supplement says that long doubles are sixteen bytes long.
936 However, as one of the known warts of its ABI, PPC GNU/Linux uses
937 eight-byte long doubles. GCC only recently got 128-bit long
938 double support on PPC, so it may be changing soon. The
939 Linux[sic] Standards Base says that programs that use 'long
940 double' on PPC GNU/Linux are non-conformant. */
941 /* NOTE: cagney/2005-01-25: True for both 32- and 64-bit. */
942 set_gdbarch_long_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
944 /* Handle PPC GNU/Linux 64-bit function pointers (which are really
945 function descriptors) and 32-bit secure PLT entries. */
946 set_gdbarch_convert_from_func_ptr_addr
947 (gdbarch
, ppc_linux_convert_from_func_ptr_addr
);
949 if (tdep
->wordsize
== 4)
951 /* Until November 2001, gcc did not comply with the 32 bit SysV
952 R4 ABI requirement that structures less than or equal to 8
953 bytes should be returned in registers. Instead GCC was using
954 the the AIX/PowerOpen ABI - everything returned in memory
955 (well ignoring vectors that is). When this was corrected, it
956 wasn't fixed for GNU/Linux native platform. Use the
957 PowerOpen struct convention. */
958 set_gdbarch_return_value (gdbarch
, ppc_linux_return_value
);
960 set_gdbarch_memory_remove_breakpoint (gdbarch
,
961 ppc_linux_memory_remove_breakpoint
);
963 /* Shared library handling. */
964 set_gdbarch_skip_trampoline_code (gdbarch
,
965 ppc_linux_skip_trampoline_code
);
966 set_solib_svr4_fetch_link_map_offsets
967 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
970 tramp_frame_prepend_unwinder (gdbarch
, &ppc32_linux_sigaction_tramp_frame
);
971 tramp_frame_prepend_unwinder (gdbarch
, &ppc32_linux_sighandler_tramp_frame
);
974 if (tdep
->wordsize
== 8)
976 /* Shared library handling. */
977 set_gdbarch_skip_trampoline_code (gdbarch
, ppc64_skip_trampoline_code
);
978 set_solib_svr4_fetch_link_map_offsets
979 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
982 tramp_frame_prepend_unwinder (gdbarch
, &ppc64_linux_sigaction_tramp_frame
);
983 tramp_frame_prepend_unwinder (gdbarch
, &ppc64_linux_sighandler_tramp_frame
);
985 set_gdbarch_regset_from_core_section (gdbarch
, ppc_linux_regset_from_core_section
);
987 /* Enable TLS support. */
988 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
989 svr4_fetch_objfile_link_map
);
993 _initialize_ppc_linux_tdep (void)
995 /* Register for all sub-familes of the POWER/PowerPC: 32-bit and
996 64-bit PowerPC, and the older rs6k. */
997 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc
, GDB_OSABI_LINUX
,
999 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc64
, GDB_OSABI_LINUX
,
1000 ppc_linux_init_abi
);
1001 gdbarch_register_osabi (bfd_arch_rs6000
, bfd_mach_rs6k
, GDB_OSABI_LINUX
,
1002 ppc_linux_init_abi
);