1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 1986-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
33 #include "solib-svr4.h"
34 #include "solib-spu.h"
38 #include "ppc64-tdep.h"
39 #include "ppc-linux-tdep.h"
40 #include "glibc-tdep.h"
41 #include "trad-frame.h"
42 #include "frame-unwind.h"
43 #include "tramp-frame.h"
46 #include "elf/common.h"
47 #include "elf/ppc64.h"
48 #include "arch-utils.h"
50 #include "xml-syscall.h"
51 #include "linux-tdep.h"
52 #include "linux-record.h"
53 #include "record-full.h"
56 #include "stap-probe.h"
59 #include "cli/cli-utils.h"
60 #include "parser-defs.h"
61 #include "user-regs.h"
63 #include "elf-bfd.h" /* for elfcore_write_* */
65 #include "features/rs6000/powerpc-32l.c"
66 #include "features/rs6000/powerpc-altivec32l.c"
67 #include "features/rs6000/powerpc-cell32l.c"
68 #include "features/rs6000/powerpc-vsx32l.c"
69 #include "features/rs6000/powerpc-isa205-32l.c"
70 #include "features/rs6000/powerpc-isa205-altivec32l.c"
71 #include "features/rs6000/powerpc-isa205-vsx32l.c"
72 #include "features/rs6000/powerpc-64l.c"
73 #include "features/rs6000/powerpc-altivec64l.c"
74 #include "features/rs6000/powerpc-cell64l.c"
75 #include "features/rs6000/powerpc-vsx64l.c"
76 #include "features/rs6000/powerpc-isa205-64l.c"
77 #include "features/rs6000/powerpc-isa205-altivec64l.c"
78 #include "features/rs6000/powerpc-isa205-vsx64l.c"
79 #include "features/rs6000/powerpc-e500l.c"
81 /* Shared library operations for PowerPC-Linux. */
82 static struct target_so_ops powerpc_so_ops
;
84 /* The syscall's XML filename for PPC and PPC64. */
85 #define XML_SYSCALL_FILENAME_PPC "syscalls/ppc-linux.xml"
86 #define XML_SYSCALL_FILENAME_PPC64 "syscalls/ppc64-linux.xml"
88 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
89 in much the same fashion as memory_remove_breakpoint in mem-break.c,
90 but is careful not to write back the previous contents if the code
91 in question has changed in between inserting the breakpoint and
94 Here is the problem that we're trying to solve...
96 Once upon a time, before introducing this function to remove
97 breakpoints from the inferior, setting a breakpoint on a shared
98 library function prior to running the program would not work
99 properly. In order to understand the problem, it is first
100 necessary to understand a little bit about dynamic linking on
103 A call to a shared library function is accomplished via a bl
104 (branch-and-link) instruction whose branch target is an entry
105 in the procedure linkage table (PLT). The PLT in the object
106 file is uninitialized. To gdb, prior to running the program, the
107 entries in the PLT are all zeros.
109 Once the program starts running, the shared libraries are loaded
110 and the procedure linkage table is initialized, but the entries in
111 the table are not (necessarily) resolved. Once a function is
112 actually called, the code in the PLT is hit and the function is
113 resolved. In order to better illustrate this, an example is in
114 order; the following example is from the gdb testsuite.
116 We start the program shmain.
118 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
121 We place two breakpoints, one on shr1 and the other on main.
124 Breakpoint 1 at 0x100409d4
126 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
128 Examine the instruction (and the immediatly following instruction)
129 upon which the breakpoint was placed. Note that the PLT entry
130 for shr1 contains zeros.
132 (gdb) x/2i 0x100409d4
133 0x100409d4 <shr1>: .long 0x0
134 0x100409d8 <shr1+4>: .long 0x0
139 Starting program: gdb.base/shmain
140 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
142 Breakpoint 2, main ()
143 at gdb.base/shmain.c:44
146 Examine the PLT again. Note that the loading of the shared
147 library has initialized the PLT to code which loads a constant
148 (which I think is an index into the GOT) into r11 and then
149 branchs a short distance to the code which actually does the
152 (gdb) x/2i 0x100409d4
153 0x100409d4 <shr1>: li r11,4
154 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
158 Breakpoint 1, shr1 (x=1)
159 at gdb.base/shr1.c:19
162 Now we've hit the breakpoint at shr1. (The breakpoint was
163 reset from the PLT entry to the actual shr1 function after the
164 shared library was loaded.) Note that the PLT entry has been
165 resolved to contain a branch that takes us directly to shr1.
166 (The real one, not the PLT entry.)
168 (gdb) x/2i 0x100409d4
169 0x100409d4 <shr1>: b 0xffaf76c <shr1>
170 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
172 The thing to note here is that the PLT entry for shr1 has been
175 Now the problem should be obvious. GDB places a breakpoint (a
176 trap instruction) on the zero value of the PLT entry for shr1.
177 Later on, after the shared library had been loaded and the PLT
178 initialized, GDB gets a signal indicating this fact and attempts
179 (as it always does when it stops) to remove all the breakpoints.
181 The breakpoint removal was causing the former contents (a zero
182 word) to be written back to the now initialized PLT entry thus
183 destroying a portion of the initialization that had occurred only a
184 short time ago. When execution continued, the zero word would be
185 executed as an instruction an illegal instruction trap was
186 generated instead. (0 is not a legal instruction.)
188 The fix for this problem was fairly straightforward. The function
189 memory_remove_breakpoint from mem-break.c was copied to this file,
190 modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
191 In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
194 The differences between ppc_linux_memory_remove_breakpoint () and
195 memory_remove_breakpoint () are minor. All that the former does
196 that the latter does not is check to make sure that the breakpoint
197 location actually contains a breakpoint (trap instruction) prior
198 to attempting to write back the old contents. If it does contain
199 a trap instruction, we allow the old contents to be written back.
200 Otherwise, we silently do nothing.
202 The big question is whether memory_remove_breakpoint () should be
203 changed to have the same functionality. The downside is that more
204 traffic is generated for remote targets since we'll have an extra
205 fetch of a memory word each time a breakpoint is removed.
207 For the time being, we'll leave this self-modifying-code-friendly
208 version in ppc-linux-tdep.c, but it ought to be migrated somewhere
209 else in the event that some other platform has similar needs with
210 regard to removing breakpoints in some potentially self modifying
213 ppc_linux_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
214 struct bp_target_info
*bp_tgt
)
216 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
217 const unsigned char *bp
;
220 gdb_byte old_contents
[BREAKPOINT_MAX
];
221 struct cleanup
*cleanup
;
223 /* Determine appropriate breakpoint contents and size for this address. */
224 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bplen
);
226 error (_("Software breakpoints not implemented for this target."));
228 /* Make sure we see the memory breakpoints. */
229 cleanup
= make_show_memory_breakpoints_cleanup (1);
230 val
= target_read_memory (addr
, old_contents
, bplen
);
232 /* If our breakpoint is no longer at the address, this means that the
233 program modified the code on us, so it is wrong to put back the
235 if (val
== 0 && memcmp (bp
, old_contents
, bplen
) == 0)
236 val
= target_write_raw_memory (addr
, bp_tgt
->shadow_contents
, bplen
);
238 do_cleanups (cleanup
);
242 /* For historic reasons, PPC 32 GNU/Linux follows PowerOpen rather
243 than the 32 bit SYSV R4 ABI structure return convention - all
244 structures, no matter their size, are put in memory. Vectors,
245 which were added later, do get returned in a register though. */
247 static enum return_value_convention
248 ppc_linux_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
249 struct type
*valtype
, struct regcache
*regcache
,
250 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
252 if ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
253 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
)
254 && !((TYPE_LENGTH (valtype
) == 16 || TYPE_LENGTH (valtype
) == 8)
255 && TYPE_VECTOR (valtype
)))
256 return RETURN_VALUE_STRUCT_CONVENTION
;
258 return ppc_sysv_abi_return_value (gdbarch
, function
, valtype
, regcache
,
262 /* PLT stub in executable. */
263 static struct ppc_insn_pattern powerpc32_plt_stub
[] =
265 { 0xffff0000, 0x3d600000, 0 }, /* lis r11, xxxx */
266 { 0xffff0000, 0x816b0000, 0 }, /* lwz r11, xxxx(r11) */
267 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
268 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
272 /* PLT stub in shared library. */
273 static struct ppc_insn_pattern powerpc32_plt_stub_so
[] =
275 { 0xffff0000, 0x817e0000, 0 }, /* lwz r11, xxxx(r30) */
276 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
277 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
278 { 0xffffffff, 0x60000000, 0 }, /* nop */
281 #define POWERPC32_PLT_STUB_LEN ARRAY_SIZE (powerpc32_plt_stub)
283 /* Check if PC is in PLT stub. For non-secure PLT, stub is in .plt
284 section. For secure PLT, stub is in .text and we need to check
285 instruction patterns. */
288 powerpc_linux_in_dynsym_resolve_code (CORE_ADDR pc
)
290 struct bound_minimal_symbol sym
;
292 /* Check whether PC is in the dynamic linker. This also checks
293 whether it is in the .plt section, used by non-PIC executables. */
294 if (svr4_in_dynsym_resolve_code (pc
))
297 /* Check if we are in the resolver. */
298 sym
= lookup_minimal_symbol_by_pc (pc
);
299 if (sym
.minsym
!= NULL
300 && (strcmp (MSYMBOL_LINKAGE_NAME (sym
.minsym
), "__glink") == 0
301 || strcmp (MSYMBOL_LINKAGE_NAME (sym
.minsym
),
302 "__glink_PLTresolve") == 0))
308 /* Follow PLT stub to actual routine.
310 When the execution direction is EXEC_REVERSE, scan backward to
311 check whether we are in the middle of a PLT stub. Currently,
312 we only look-behind at most 4 instructions (the max length of PLT
316 ppc_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
318 unsigned int insnbuf
[POWERPC32_PLT_STUB_LEN
];
319 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
320 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
321 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
322 CORE_ADDR target
= 0;
326 /* When reverse-debugging, scan backward to check whether we are
327 in the middle of trampoline code. */
328 if (execution_direction
== EXEC_REVERSE
)
329 scan_limit
= 4; /* At more 4 instructions. */
331 for (i
= 0; i
< scan_limit
; i
++)
333 if (ppc_insns_match_pattern (frame
, pc
, powerpc32_plt_stub
, insnbuf
))
338 Branch target is in r11. */
340 target
= (ppc_insn_d_field (insnbuf
[0]) << 16)
341 | ppc_insn_d_field (insnbuf
[1]);
342 target
= read_memory_unsigned_integer (target
, 4, byte_order
);
344 else if (ppc_insns_match_pattern (frame
, pc
, powerpc32_plt_stub_so
,
349 Branch target is in r11. */
351 target
= get_frame_register_unsigned (frame
,
352 tdep
->ppc_gp0_regnum
+ 30)
353 + ppc_insn_d_field (insnbuf
[0]);
354 target
= read_memory_unsigned_integer (target
, 4, byte_order
);
358 /* Scan backward one more instructions if doesn't match. */
369 /* Wrappers to handle Linux-only registers. */
372 ppc_linux_supply_gregset (const struct regset
*regset
,
373 struct regcache
*regcache
,
374 int regnum
, const void *gregs
, size_t len
)
376 const struct ppc_reg_offsets
*offsets
= regset
->regmap
;
378 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
380 if (ppc_linux_trap_reg_p (get_regcache_arch (regcache
)))
382 /* "orig_r3" is stored 2 slots after "pc". */
383 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
384 ppc_supply_reg (regcache
, PPC_ORIG_R3_REGNUM
, gregs
,
385 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
388 /* "trap" is stored 8 slots after "pc". */
389 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
390 ppc_supply_reg (regcache
, PPC_TRAP_REGNUM
, gregs
,
391 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
397 ppc_linux_collect_gregset (const struct regset
*regset
,
398 const struct regcache
*regcache
,
399 int regnum
, void *gregs
, size_t len
)
401 const struct ppc_reg_offsets
*offsets
= regset
->regmap
;
403 /* Clear areas in the linux gregset not written elsewhere. */
405 memset (gregs
, 0, len
);
407 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
409 if (ppc_linux_trap_reg_p (get_regcache_arch (regcache
)))
411 /* "orig_r3" is stored 2 slots after "pc". */
412 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
413 ppc_collect_reg (regcache
, PPC_ORIG_R3_REGNUM
, gregs
,
414 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
417 /* "trap" is stored 8 slots after "pc". */
418 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
419 ppc_collect_reg (regcache
, PPC_TRAP_REGNUM
, gregs
,
420 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
425 /* Regset descriptions. */
426 static const struct ppc_reg_offsets ppc32_linux_reg_offsets
=
428 /* General-purpose registers. */
429 /* .r0_offset = */ 0,
432 /* .pc_offset = */ 128,
433 /* .ps_offset = */ 132,
434 /* .cr_offset = */ 152,
435 /* .lr_offset = */ 144,
436 /* .ctr_offset = */ 140,
437 /* .xer_offset = */ 148,
438 /* .mq_offset = */ 156,
440 /* Floating-point registers. */
441 /* .f0_offset = */ 0,
442 /* .fpscr_offset = */ 256,
443 /* .fpscr_size = */ 8,
445 /* AltiVec registers. */
446 /* .vr0_offset = */ 0,
447 /* .vscr_offset = */ 512 + 12,
448 /* .vrsave_offset = */ 528
451 static const struct ppc_reg_offsets ppc64_linux_reg_offsets
=
453 /* General-purpose registers. */
454 /* .r0_offset = */ 0,
457 /* .pc_offset = */ 256,
458 /* .ps_offset = */ 264,
459 /* .cr_offset = */ 304,
460 /* .lr_offset = */ 288,
461 /* .ctr_offset = */ 280,
462 /* .xer_offset = */ 296,
463 /* .mq_offset = */ 312,
465 /* Floating-point registers. */
466 /* .f0_offset = */ 0,
467 /* .fpscr_offset = */ 256,
468 /* .fpscr_size = */ 8,
470 /* AltiVec registers. */
471 /* .vr0_offset = */ 0,
472 /* .vscr_offset = */ 512 + 12,
473 /* .vrsave_offset = */ 528
476 static const struct regset ppc32_linux_gregset
= {
477 &ppc32_linux_reg_offsets
,
478 ppc_linux_supply_gregset
,
479 ppc_linux_collect_gregset
482 static const struct regset ppc64_linux_gregset
= {
483 &ppc64_linux_reg_offsets
,
484 ppc_linux_supply_gregset
,
485 ppc_linux_collect_gregset
488 static const struct regset ppc32_linux_fpregset
= {
489 &ppc32_linux_reg_offsets
,
494 static const struct regset ppc32_linux_vrregset
= {
495 &ppc32_linux_reg_offsets
,
500 static const struct regset ppc32_linux_vsxregset
= {
501 &ppc32_linux_reg_offsets
,
502 ppc_supply_vsxregset
,
503 ppc_collect_vsxregset
506 const struct regset
*
507 ppc_linux_gregset (int wordsize
)
509 return wordsize
== 8 ? &ppc64_linux_gregset
: &ppc32_linux_gregset
;
512 const struct regset
*
513 ppc_linux_fpregset (void)
515 return &ppc32_linux_fpregset
;
518 /* Iterate over supported core file register note sections. */
521 ppc_linux_iterate_over_regset_sections (struct gdbarch
*gdbarch
,
522 iterate_over_regset_sections_cb
*cb
,
524 const struct regcache
*regcache
)
526 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
527 int have_altivec
= tdep
->ppc_vr0_regnum
!= -1;
528 int have_vsx
= tdep
->ppc_vsr0_upper_regnum
!= -1;
530 if (tdep
->wordsize
== 4)
531 cb (".reg", 48 * 4, &ppc32_linux_gregset
, NULL
, cb_data
);
533 cb (".reg", 48 * 8, &ppc64_linux_gregset
, NULL
, cb_data
);
535 cb (".reg2", 264, &ppc32_linux_fpregset
, NULL
, cb_data
);
538 cb (".reg-ppc-vmx", 544, &ppc32_linux_vrregset
, "ppc Altivec", cb_data
);
541 cb (".reg-ppc-vsx", 256, &ppc32_linux_vsxregset
, "POWER7 VSX", cb_data
);
545 ppc_linux_sigtramp_cache (struct frame_info
*this_frame
,
546 struct trad_frame_cache
*this_cache
,
547 CORE_ADDR func
, LONGEST offset
,
555 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
556 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
557 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
559 base
= get_frame_register_unsigned (this_frame
,
560 gdbarch_sp_regnum (gdbarch
));
561 if (bias
> 0 && get_frame_pc (this_frame
) != func
)
562 /* See below, some signal trampolines increment the stack as their
563 first instruction, need to compensate for that. */
566 /* Find the address of the register buffer pointer. */
567 regs
= base
+ offset
;
568 /* Use that to find the address of the corresponding register
570 gpregs
= read_memory_unsigned_integer (regs
, tdep
->wordsize
, byte_order
);
571 fpregs
= gpregs
+ 48 * tdep
->wordsize
;
573 /* General purpose. */
574 for (i
= 0; i
< 32; i
++)
576 int regnum
= i
+ tdep
->ppc_gp0_regnum
;
577 trad_frame_set_reg_addr (this_cache
,
578 regnum
, gpregs
+ i
* tdep
->wordsize
);
580 trad_frame_set_reg_addr (this_cache
,
581 gdbarch_pc_regnum (gdbarch
),
582 gpregs
+ 32 * tdep
->wordsize
);
583 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_ctr_regnum
,
584 gpregs
+ 35 * tdep
->wordsize
);
585 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_lr_regnum
,
586 gpregs
+ 36 * tdep
->wordsize
);
587 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_xer_regnum
,
588 gpregs
+ 37 * tdep
->wordsize
);
589 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_cr_regnum
,
590 gpregs
+ 38 * tdep
->wordsize
);
592 if (ppc_linux_trap_reg_p (gdbarch
))
594 trad_frame_set_reg_addr (this_cache
, PPC_ORIG_R3_REGNUM
,
595 gpregs
+ 34 * tdep
->wordsize
);
596 trad_frame_set_reg_addr (this_cache
, PPC_TRAP_REGNUM
,
597 gpregs
+ 40 * tdep
->wordsize
);
600 if (ppc_floating_point_unit_p (gdbarch
))
602 /* Floating point registers. */
603 for (i
= 0; i
< 32; i
++)
605 int regnum
= i
+ gdbarch_fp0_regnum (gdbarch
);
606 trad_frame_set_reg_addr (this_cache
, regnum
,
607 fpregs
+ i
* tdep
->wordsize
);
609 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_fpscr_regnum
,
610 fpregs
+ 32 * tdep
->wordsize
);
612 trad_frame_set_id (this_cache
, frame_id_build (base
, func
));
616 ppc32_linux_sigaction_cache_init (const struct tramp_frame
*self
,
617 struct frame_info
*this_frame
,
618 struct trad_frame_cache
*this_cache
,
621 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
622 0xd0 /* Offset to ucontext_t. */
623 + 0x30 /* Offset to .reg. */,
628 ppc64_linux_sigaction_cache_init (const struct tramp_frame
*self
,
629 struct frame_info
*this_frame
,
630 struct trad_frame_cache
*this_cache
,
633 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
634 0x80 /* Offset to ucontext_t. */
635 + 0xe0 /* Offset to .reg. */,
640 ppc32_linux_sighandler_cache_init (const struct tramp_frame
*self
,
641 struct frame_info
*this_frame
,
642 struct trad_frame_cache
*this_cache
,
645 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
646 0x40 /* Offset to ucontext_t. */
647 + 0x1c /* Offset to .reg. */,
652 ppc64_linux_sighandler_cache_init (const struct tramp_frame
*self
,
653 struct frame_info
*this_frame
,
654 struct trad_frame_cache
*this_cache
,
657 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
658 0x80 /* Offset to struct sigcontext. */
659 + 0x38 /* Offset to .reg. */,
663 static struct tramp_frame ppc32_linux_sigaction_tramp_frame
= {
667 { 0x380000ac, -1 }, /* li r0, 172 */
668 { 0x44000002, -1 }, /* sc */
669 { TRAMP_SENTINEL_INSN
},
671 ppc32_linux_sigaction_cache_init
673 static struct tramp_frame ppc64_linux_sigaction_tramp_frame
= {
677 { 0x38210080, -1 }, /* addi r1,r1,128 */
678 { 0x380000ac, -1 }, /* li r0, 172 */
679 { 0x44000002, -1 }, /* sc */
680 { TRAMP_SENTINEL_INSN
},
682 ppc64_linux_sigaction_cache_init
684 static struct tramp_frame ppc32_linux_sighandler_tramp_frame
= {
688 { 0x38000077, -1 }, /* li r0,119 */
689 { 0x44000002, -1 }, /* sc */
690 { TRAMP_SENTINEL_INSN
},
692 ppc32_linux_sighandler_cache_init
694 static struct tramp_frame ppc64_linux_sighandler_tramp_frame
= {
698 { 0x38210080, -1 }, /* addi r1,r1,128 */
699 { 0x38000077, -1 }, /* li r0,119 */
700 { 0x44000002, -1 }, /* sc */
701 { TRAMP_SENTINEL_INSN
},
703 ppc64_linux_sighandler_cache_init
707 /* Address to use for displaced stepping. When debugging a stand-alone
708 SPU executable, entry_point_address () will point to an SPU local-store
709 address and is thus not usable as displaced stepping location. We use
710 the auxiliary vector to determine the PowerPC-side entry point address
713 static CORE_ADDR ppc_linux_entry_point_addr
= 0;
716 ppc_linux_inferior_created (struct target_ops
*target
, int from_tty
)
718 ppc_linux_entry_point_addr
= 0;
722 ppc_linux_displaced_step_location (struct gdbarch
*gdbarch
)
724 if (ppc_linux_entry_point_addr
== 0)
728 /* Determine entry point from target auxiliary vector. */
729 if (target_auxv_search (¤t_target
, AT_ENTRY
, &addr
) <= 0)
730 error (_("Cannot find AT_ENTRY auxiliary vector entry."));
732 /* Make certain that the address points at real code, and not a
733 function descriptor. */
734 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
737 /* Inferior calls also use the entry point as a breakpoint location.
738 We don't want displaced stepping to interfere with those
739 breakpoints, so leave space. */
740 ppc_linux_entry_point_addr
= addr
+ 2 * PPC_INSN_SIZE
;
743 return ppc_linux_entry_point_addr
;
747 /* Return 1 if PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM are usable. */
749 ppc_linux_trap_reg_p (struct gdbarch
*gdbarch
)
751 /* If we do not have a target description with registers, then
752 the special registers will not be included in the register set. */
753 if (!tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
756 /* If we do, then it is safe to check the size. */
757 return register_size (gdbarch
, PPC_ORIG_R3_REGNUM
) > 0
758 && register_size (gdbarch
, PPC_TRAP_REGNUM
) > 0;
761 /* Return the current system call's number present in the
762 r0 register. When the function fails, it returns -1. */
764 ppc_linux_get_syscall_number (struct gdbarch
*gdbarch
,
767 struct regcache
*regcache
= get_thread_regcache (ptid
);
768 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
769 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
770 struct cleanup
*cleanbuf
;
771 /* The content of a register */
776 /* Make sure we're in a 32- or 64-bit machine */
777 gdb_assert (tdep
->wordsize
== 4 || tdep
->wordsize
== 8);
779 buf
= (gdb_byte
*) xmalloc (tdep
->wordsize
* sizeof (gdb_byte
));
781 cleanbuf
= make_cleanup (xfree
, buf
);
783 /* Getting the system call number from the register.
784 When dealing with PowerPC architecture, this information
785 is stored at 0th register. */
786 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
, buf
);
788 ret
= extract_signed_integer (buf
, tdep
->wordsize
, byte_order
);
789 do_cleanups (cleanbuf
);
794 /* PPC process record-replay */
796 static struct linux_record_tdep ppc_linux_record_tdep
;
797 static struct linux_record_tdep ppc64_linux_record_tdep
;
799 /* ppc_canonicalize_syscall maps from the native PowerPC Linux set of
800 syscall ids into a canonical set of syscall ids used by process
801 record. (See arch/powerpc/include/uapi/asm/unistd.h in kernel tree.)
802 Return -1 if this system call is not supported by process record.
803 Otherwise, return the syscall number for preocess reocrd of given
806 static enum gdb_syscall
807 ppc_canonicalize_syscall (int syscall
)
811 else if (syscall
>= 167 && syscall
<= 190) /* Skip query_module 166 */
813 else if (syscall
>= 192 && syscall
<= 197) /* mmap2 */
815 else if (syscall
== 208) /* tkill */
816 return gdb_sys_tkill
;
817 else if (syscall
>= 207 && syscall
<= 220) /* gettid */
818 return syscall
+ 224 - 207;
819 else if (syscall
>= 234 && syscall
<= 239) /* exit_group */
820 return syscall
+ 252 - 234;
821 else if (syscall
>= 240 && syscall
<=248) /* timer_create */
822 return syscall
+= 259 - 240;
823 else if (syscall
>= 250 && syscall
<=251) /* tgkill */
824 return syscall
+ 270 - 250;
825 else if (syscall
== 336)
827 else if (syscall
== 337)
828 return gdb_sys_recvfrom
;
829 else if (syscall
== 342)
830 return gdb_sys_recvmsg
;
834 /* Record registers which might be clobbered during system call.
835 Return 0 if successful. */
838 ppc_linux_syscall_record (struct regcache
*regcache
)
840 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
841 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
843 enum gdb_syscall syscall_gdb
;
847 regcache_raw_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
, &scnum
);
848 syscall_gdb
= ppc_canonicalize_syscall (scnum
);
852 printf_unfiltered (_("Process record and replay target doesn't "
853 "support syscall number %d\n"), (int) scnum
);
857 if (syscall_gdb
== gdb_sys_sigreturn
858 || syscall_gdb
== gdb_sys_rt_sigreturn
)
861 int regsets
[] = { tdep
->ppc_gp0_regnum
,
862 tdep
->ppc_fp0_regnum
,
863 tdep
->ppc_vr0_regnum
,
864 tdep
->ppc_vsr0_upper_regnum
};
866 for (j
= 0; j
< 4; j
++)
868 if (regsets
[j
] == -1)
870 for (i
= 0; i
< 32; i
++)
872 if (record_full_arch_list_add_reg (regcache
, regsets
[j
] + i
))
877 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_cr_regnum
))
879 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_ctr_regnum
))
881 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_lr_regnum
))
883 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_xer_regnum
))
889 if (tdep
->wordsize
== 8)
890 ret
= record_linux_system_call (syscall_gdb
, regcache
,
891 &ppc64_linux_record_tdep
);
893 ret
= record_linux_system_call (syscall_gdb
, regcache
,
894 &ppc_linux_record_tdep
);
899 /* Record registers clobbered during syscall. */
900 for (i
= 3; i
<= 12; i
++)
902 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ i
))
905 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ 0))
907 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_cr_regnum
))
909 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_ctr_regnum
))
911 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_lr_regnum
))
917 /* Record registers which might be clobbered during signal handling.
918 Return 0 if successful. */
921 ppc_linux_record_signal (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
922 enum gdb_signal signal
)
924 /* See handle_rt_signal64 in arch/powerpc/kernel/signal_64.c
925 handle_rt_signal32 in arch/powerpc/kernel/signal_32.c
926 arch/powerpc/include/asm/ptrace.h
928 const int SIGNAL_FRAMESIZE
= 128;
929 const int sizeof_rt_sigframe
= 1440 * 2 + 8 * 2 + 4 * 6 + 8 + 8 + 128 + 512;
931 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
934 for (i
= 3; i
<= 12; i
++)
936 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ i
))
940 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_lr_regnum
))
942 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_cr_regnum
))
944 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_ctr_regnum
))
946 if (record_full_arch_list_add_reg (regcache
, gdbarch_pc_regnum (gdbarch
)))
948 if (record_full_arch_list_add_reg (regcache
, gdbarch_sp_regnum (gdbarch
)))
951 /* Record the change in the stack.
952 frame-size = sizeof (struct rt_sigframe) + SIGNAL_FRAMESIZE */
953 regcache_raw_read_unsigned (regcache
, gdbarch_sp_regnum (gdbarch
), &sp
);
954 sp
-= SIGNAL_FRAMESIZE
;
955 sp
-= sizeof_rt_sigframe
;
957 if (record_full_arch_list_add_mem (sp
, SIGNAL_FRAMESIZE
+ sizeof_rt_sigframe
))
960 if (record_full_arch_list_add_end ())
967 ppc_linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
969 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
971 regcache_cooked_write_unsigned (regcache
, gdbarch_pc_regnum (gdbarch
), pc
);
973 /* Set special TRAP register to -1 to prevent the kernel from
974 messing with the PC we just installed, if we happen to be
975 within an interrupted system call that the kernel wants to
978 Note that after we return from the dummy call, the TRAP and
979 ORIG_R3 registers will be automatically restored, and the
980 kernel continues to restart the system call at this point. */
981 if (ppc_linux_trap_reg_p (gdbarch
))
982 regcache_cooked_write_unsigned (regcache
, PPC_TRAP_REGNUM
, -1);
986 ppc_linux_spu_section (bfd
*abfd
, asection
*asect
, void *user_data
)
988 return startswith (bfd_section_name (abfd
, asect
), "SPU/");
991 static const struct target_desc
*
992 ppc_linux_core_read_description (struct gdbarch
*gdbarch
,
993 struct target_ops
*target
,
996 asection
*cell
= bfd_sections_find_if (abfd
, ppc_linux_spu_section
, NULL
);
997 asection
*altivec
= bfd_get_section_by_name (abfd
, ".reg-ppc-vmx");
998 asection
*vsx
= bfd_get_section_by_name (abfd
, ".reg-ppc-vsx");
999 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
1003 switch (bfd_section_size (abfd
, section
))
1007 return tdesc_powerpc_cell32l
;
1009 return tdesc_powerpc_vsx32l
;
1011 return tdesc_powerpc_altivec32l
;
1013 return tdesc_powerpc_32l
;
1017 return tdesc_powerpc_cell64l
;
1019 return tdesc_powerpc_vsx64l
;
1021 return tdesc_powerpc_altivec64l
;
1023 return tdesc_powerpc_64l
;
1031 /* Implementation of `gdbarch_elf_make_msymbol_special', as defined in
1032 gdbarch.h. This implementation is used for the ELFv2 ABI only. */
1035 ppc_elfv2_elf_make_msymbol_special (asymbol
*sym
, struct minimal_symbol
*msym
)
1037 elf_symbol_type
*elf_sym
= (elf_symbol_type
*)sym
;
1039 /* If the symbol is marked as having a local entry point, set a target
1040 flag in the msymbol. We currently only support local entry point
1041 offsets of 8 bytes, which is the only entry point offset ever used
1042 by current compilers. If/when other offsets are ever used, we will
1043 have to use additional target flag bits to store them. */
1044 switch (PPC64_LOCAL_ENTRY_OFFSET (elf_sym
->internal_elf_sym
.st_other
))
1049 MSYMBOL_TARGET_FLAG_1 (msym
) = 1;
1054 /* Implementation of `gdbarch_skip_entrypoint', as defined in
1055 gdbarch.h. This implementation is used for the ELFv2 ABI only. */
1058 ppc_elfv2_skip_entrypoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1060 struct bound_minimal_symbol fun
;
1061 int local_entry_offset
= 0;
1063 fun
= lookup_minimal_symbol_by_pc (pc
);
1064 if (fun
.minsym
== NULL
)
1067 /* See ppc_elfv2_elf_make_msymbol_special for how local entry point
1068 offset values are encoded. */
1069 if (MSYMBOL_TARGET_FLAG_1 (fun
.minsym
))
1070 local_entry_offset
= 8;
1072 if (BMSYMBOL_VALUE_ADDRESS (fun
) <= pc
1073 && pc
< BMSYMBOL_VALUE_ADDRESS (fun
) + local_entry_offset
)
1074 return BMSYMBOL_VALUE_ADDRESS (fun
) + local_entry_offset
;
1079 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1083 ppc_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
1085 return (*s
== 'i' /* Literal number. */
1086 || (isdigit (*s
) && s
[1] == '('
1087 && isdigit (s
[2])) /* Displacement. */
1088 || (*s
== '(' && isdigit (s
[1])) /* Register indirection. */
1089 || isdigit (*s
)); /* Register value. */
1092 /* Implementation of `gdbarch_stap_parse_special_token', as defined in
1096 ppc_stap_parse_special_token (struct gdbarch
*gdbarch
,
1097 struct stap_parse_info
*p
)
1099 if (isdigit (*p
->arg
))
1101 /* This temporary pointer is needed because we have to do a lookahead.
1102 We could be dealing with a register displacement, and in such case
1103 we would not need to do anything. */
1104 const char *s
= p
->arg
;
1109 while (isdigit (*s
))
1114 /* It is a register displacement indeed. Returning 0 means we are
1115 deferring the treatment of this case to the generic parser. */
1120 regname
= alloca (len
+ 2);
1123 strncpy (regname
+ 1, p
->arg
, len
);
1125 regname
[len
] = '\0';
1127 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
1128 error (_("Invalid register name `%s' on expression `%s'."),
1129 regname
, p
->saved_arg
);
1131 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1134 write_exp_string (&p
->pstate
, str
);
1135 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1141 /* All the other tokens should be handled correctly by the generic
1149 /* Cell/B.E. active SPE context tracking support. */
1151 static struct objfile
*spe_context_objfile
= NULL
;
1152 static CORE_ADDR spe_context_lm_addr
= 0;
1153 static CORE_ADDR spe_context_offset
= 0;
1155 static ptid_t spe_context_cache_ptid
;
1156 static CORE_ADDR spe_context_cache_address
;
1158 /* Hook into inferior_created, solib_loaded, and solib_unloaded observers
1159 to track whether we've loaded a version of libspe2 (as static or dynamic
1160 library) that provides the __spe_current_active_context variable. */
1162 ppc_linux_spe_context_lookup (struct objfile
*objfile
)
1164 struct bound_minimal_symbol sym
;
1168 spe_context_objfile
= NULL
;
1169 spe_context_lm_addr
= 0;
1170 spe_context_offset
= 0;
1171 spe_context_cache_ptid
= minus_one_ptid
;
1172 spe_context_cache_address
= 0;
1176 sym
= lookup_minimal_symbol ("__spe_current_active_context", NULL
, objfile
);
1179 spe_context_objfile
= objfile
;
1180 spe_context_lm_addr
= svr4_fetch_objfile_link_map (objfile
);
1181 spe_context_offset
= BMSYMBOL_VALUE_ADDRESS (sym
);
1182 spe_context_cache_ptid
= minus_one_ptid
;
1183 spe_context_cache_address
= 0;
1189 ppc_linux_spe_context_inferior_created (struct target_ops
*t
, int from_tty
)
1191 struct objfile
*objfile
;
1193 ppc_linux_spe_context_lookup (NULL
);
1194 ALL_OBJFILES (objfile
)
1195 ppc_linux_spe_context_lookup (objfile
);
1199 ppc_linux_spe_context_solib_loaded (struct so_list
*so
)
1201 if (strstr (so
->so_original_name
, "/libspe") != NULL
)
1203 solib_read_symbols (so
, 0);
1204 ppc_linux_spe_context_lookup (so
->objfile
);
1209 ppc_linux_spe_context_solib_unloaded (struct so_list
*so
)
1211 if (so
->objfile
== spe_context_objfile
)
1212 ppc_linux_spe_context_lookup (NULL
);
1215 /* Retrieve contents of the N'th element in the current thread's
1216 linked SPE context list into ID and NPC. Return the address of
1217 said context element, or 0 if not found. */
1219 ppc_linux_spe_context (int wordsize
, enum bfd_endian byte_order
,
1220 int n
, int *id
, unsigned int *npc
)
1222 CORE_ADDR spe_context
= 0;
1226 /* Quick exit if we have not found __spe_current_active_context. */
1227 if (!spe_context_objfile
)
1230 /* Look up cached address of thread-local variable. */
1231 if (!ptid_equal (spe_context_cache_ptid
, inferior_ptid
))
1233 struct target_ops
*target
= ¤t_target
;
1237 /* We do not call target_translate_tls_address here, because
1238 svr4_fetch_objfile_link_map may invalidate the frame chain,
1239 which must not do while inside a frame sniffer.
1241 Instead, we have cached the lm_addr value, and use that to
1242 directly call the target's to_get_thread_local_address. */
1243 spe_context_cache_address
1244 = target
->to_get_thread_local_address (target
, inferior_ptid
,
1245 spe_context_lm_addr
,
1246 spe_context_offset
);
1247 spe_context_cache_ptid
= inferior_ptid
;
1250 CATCH (ex
, RETURN_MASK_ERROR
)
1257 /* Read variable value. */
1258 if (target_read_memory (spe_context_cache_address
, buf
, wordsize
) == 0)
1259 spe_context
= extract_unsigned_integer (buf
, wordsize
, byte_order
);
1261 /* Cyle through to N'th linked list element. */
1262 for (i
= 0; i
< n
&& spe_context
; i
++)
1263 if (target_read_memory (spe_context
+ align_up (12, wordsize
),
1264 buf
, wordsize
) == 0)
1265 spe_context
= extract_unsigned_integer (buf
, wordsize
, byte_order
);
1269 /* Read current context. */
1271 && target_read_memory (spe_context
, buf
, 12) != 0)
1274 /* Extract data elements. */
1278 *id
= extract_signed_integer (buf
, 4, byte_order
);
1280 *npc
= extract_unsigned_integer (buf
+ 4, 4, byte_order
);
1287 /* Cell/B.E. cross-architecture unwinder support. */
1289 struct ppu2spu_cache
1291 struct frame_id frame_id
;
1292 struct regcache
*regcache
;
1295 static struct gdbarch
*
1296 ppu2spu_prev_arch (struct frame_info
*this_frame
, void **this_cache
)
1298 struct ppu2spu_cache
*cache
= *this_cache
;
1299 return get_regcache_arch (cache
->regcache
);
1303 ppu2spu_this_id (struct frame_info
*this_frame
,
1304 void **this_cache
, struct frame_id
*this_id
)
1306 struct ppu2spu_cache
*cache
= *this_cache
;
1307 *this_id
= cache
->frame_id
;
1310 static struct value
*
1311 ppu2spu_prev_register (struct frame_info
*this_frame
,
1312 void **this_cache
, int regnum
)
1314 struct ppu2spu_cache
*cache
= *this_cache
;
1315 struct gdbarch
*gdbarch
= get_regcache_arch (cache
->regcache
);
1318 buf
= alloca (register_size (gdbarch
, regnum
));
1320 if (regnum
< gdbarch_num_regs (gdbarch
))
1321 regcache_raw_read (cache
->regcache
, regnum
, buf
);
1323 gdbarch_pseudo_register_read (gdbarch
, cache
->regcache
, regnum
, buf
);
1325 return frame_unwind_got_bytes (this_frame
, regnum
, buf
);
1330 struct gdbarch
*gdbarch
;
1333 gdb_byte gprs
[128*16];
1337 ppu2spu_unwind_register (void *src
, int regnum
, gdb_byte
*buf
)
1339 struct ppu2spu_data
*data
= src
;
1340 enum bfd_endian byte_order
= gdbarch_byte_order (data
->gdbarch
);
1342 if (regnum
>= 0 && regnum
< SPU_NUM_GPRS
)
1343 memcpy (buf
, data
->gprs
+ 16*regnum
, 16);
1344 else if (regnum
== SPU_ID_REGNUM
)
1345 store_unsigned_integer (buf
, 4, byte_order
, data
->id
);
1346 else if (regnum
== SPU_PC_REGNUM
)
1347 store_unsigned_integer (buf
, 4, byte_order
, data
->npc
);
1349 return REG_UNAVAILABLE
;
1355 ppu2spu_sniffer (const struct frame_unwind
*self
,
1356 struct frame_info
*this_frame
, void **this_prologue_cache
)
1358 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1359 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1360 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1361 struct ppu2spu_data data
;
1362 struct frame_info
*fi
;
1363 CORE_ADDR base
, func
, backchain
, spe_context
;
1367 /* Count the number of SPU contexts already in the frame chain. */
1368 for (fi
= get_next_frame (this_frame
); fi
; fi
= get_next_frame (fi
))
1369 if (get_frame_type (fi
) == ARCH_FRAME
1370 && gdbarch_bfd_arch_info (get_frame_arch (fi
))->arch
== bfd_arch_spu
)
1373 base
= get_frame_sp (this_frame
);
1374 func
= get_frame_pc (this_frame
);
1375 if (target_read_memory (base
, buf
, tdep
->wordsize
))
1377 backchain
= extract_unsigned_integer (buf
, tdep
->wordsize
, byte_order
);
1379 spe_context
= ppc_linux_spe_context (tdep
->wordsize
, byte_order
,
1380 n
, &data
.id
, &data
.npc
);
1381 if (spe_context
&& base
<= spe_context
&& spe_context
< backchain
)
1385 /* Find gdbarch for SPU. */
1386 struct gdbarch_info info
;
1387 gdbarch_info_init (&info
);
1388 info
.bfd_arch_info
= bfd_lookup_arch (bfd_arch_spu
, bfd_mach_spu
);
1389 info
.byte_order
= BFD_ENDIAN_BIG
;
1390 info
.osabi
= GDB_OSABI_LINUX
;
1391 info
.tdep_info
= (void *) &data
.id
;
1392 data
.gdbarch
= gdbarch_find_by_info (info
);
1396 xsnprintf (annex
, sizeof annex
, "%d/regs", data
.id
);
1397 if (target_read (¤t_target
, TARGET_OBJECT_SPU
, annex
,
1398 data
.gprs
, 0, sizeof data
.gprs
)
1399 == sizeof data
.gprs
)
1401 struct ppu2spu_cache
*cache
1402 = FRAME_OBSTACK_CALLOC (1, struct ppu2spu_cache
);
1404 struct address_space
*aspace
= get_frame_address_space (this_frame
);
1405 struct regcache
*regcache
= regcache_xmalloc (data
.gdbarch
, aspace
);
1406 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
1407 regcache_save (regcache
, ppu2spu_unwind_register
, &data
);
1408 discard_cleanups (cleanups
);
1410 cache
->frame_id
= frame_id_build (base
, func
);
1411 cache
->regcache
= regcache
;
1412 *this_prologue_cache
= cache
;
1421 ppu2spu_dealloc_cache (struct frame_info
*self
, void *this_cache
)
1423 struct ppu2spu_cache
*cache
= this_cache
;
1424 regcache_xfree (cache
->regcache
);
1427 static const struct frame_unwind ppu2spu_unwind
= {
1429 default_frame_unwind_stop_reason
,
1431 ppu2spu_prev_register
,
1434 ppu2spu_dealloc_cache
,
1438 /* Initialize linux_record_tdep if not initialized yet.
1439 WORDSIZE is 4 or 8 for 32- or 64-bit PowerPC Linux respectively.
1440 Sizes of data structures are initialized accordingly. */
1443 ppc_init_linux_record_tdep (struct linux_record_tdep
*record_tdep
,
1446 /* Simply return if it had been initialized. */
1447 if (record_tdep
->size_pointer
!= 0)
1450 /* These values are the size of the type that will be used in a system
1451 call. They are obtained from Linux Kernel source. */
1455 record_tdep
->size_pointer
= 8;
1456 record_tdep
->size__old_kernel_stat
= 32;
1457 record_tdep
->size_tms
= 32;
1458 record_tdep
->size_loff_t
= 8;
1459 record_tdep
->size_flock
= 32;
1460 record_tdep
->size_oldold_utsname
= 45;
1461 record_tdep
->size_ustat
= 32;
1462 record_tdep
->size_old_sigaction
= 152;
1463 record_tdep
->size_old_sigset_t
= 128;
1464 record_tdep
->size_rlimit
= 16;
1465 record_tdep
->size_rusage
= 144;
1466 record_tdep
->size_timeval
= 16;
1467 record_tdep
->size_timezone
= 8;
1468 record_tdep
->size_old_gid_t
= 4;
1469 record_tdep
->size_old_uid_t
= 4;
1470 record_tdep
->size_fd_set
= 128;
1471 record_tdep
->size_dirent
= 280;
1472 record_tdep
->size_dirent64
= 280;
1473 record_tdep
->size_statfs
= 120;
1474 record_tdep
->size_statfs64
= 120;
1475 record_tdep
->size_sockaddr
= 16;
1476 record_tdep
->size_int
= 4;
1477 record_tdep
->size_long
= 8;
1478 record_tdep
->size_ulong
= 8;
1479 record_tdep
->size_msghdr
= 56;
1480 record_tdep
->size_itimerval
= 32;
1481 record_tdep
->size_stat
= 144;
1482 record_tdep
->size_old_utsname
= 325;
1483 record_tdep
->size_sysinfo
= 112;
1484 record_tdep
->size_msqid_ds
= 120;
1485 record_tdep
->size_shmid_ds
= 112;
1486 record_tdep
->size_new_utsname
= 390;
1487 record_tdep
->size_timex
= 208;
1488 record_tdep
->size_mem_dqinfo
= 24;
1489 record_tdep
->size_if_dqblk
= 72;
1490 record_tdep
->size_fs_quota_stat
= 80;
1491 record_tdep
->size_timespec
= 16;
1492 record_tdep
->size_pollfd
= 8;
1493 record_tdep
->size_NFS_FHSIZE
= 32;
1494 record_tdep
->size_knfsd_fh
= 132;
1495 record_tdep
->size_TASK_COMM_LEN
= 32;
1496 record_tdep
->size_sigaction
= 152;
1497 record_tdep
->size_sigset_t
= 128;
1498 record_tdep
->size_siginfo_t
= 128;
1499 record_tdep
->size_cap_user_data_t
= 8;
1500 record_tdep
->size_stack_t
= 24;
1501 record_tdep
->size_off_t
= 8;
1502 record_tdep
->size_stat64
= 104;
1503 record_tdep
->size_gid_t
= 4;
1504 record_tdep
->size_uid_t
= 4;
1505 record_tdep
->size_PAGE_SIZE
= 0x10000; /* 64KB */
1506 record_tdep
->size_flock64
= 32;
1507 record_tdep
->size_io_event
= 32;
1508 record_tdep
->size_iocb
= 64;
1509 record_tdep
->size_epoll_event
= 16;
1510 record_tdep
->size_itimerspec
= 32;
1511 record_tdep
->size_mq_attr
= 64;
1512 record_tdep
->size_siginfo
= 128;
1513 record_tdep
->size_termios
= 44;
1514 record_tdep
->size_pid_t
= 4;
1515 record_tdep
->size_winsize
= 8;
1516 record_tdep
->size_serial_struct
= 72;
1517 record_tdep
->size_serial_icounter_struct
= 80;
1518 record_tdep
->size_size_t
= 8;
1519 record_tdep
->size_iovec
= 16;
1521 else if (wordsize
== 4)
1523 record_tdep
->size_pointer
= 4;
1524 record_tdep
->size__old_kernel_stat
= 32;
1525 record_tdep
->size_tms
= 16;
1526 record_tdep
->size_loff_t
= 8;
1527 record_tdep
->size_flock
= 16;
1528 record_tdep
->size_oldold_utsname
= 45;
1529 record_tdep
->size_ustat
= 20;
1530 record_tdep
->size_old_sigaction
= 152;
1531 record_tdep
->size_old_sigset_t
= 128;
1532 record_tdep
->size_rlimit
= 8;
1533 record_tdep
->size_rusage
= 72;
1534 record_tdep
->size_timeval
= 8;
1535 record_tdep
->size_timezone
= 8;
1536 record_tdep
->size_old_gid_t
= 4;
1537 record_tdep
->size_old_uid_t
= 4;
1538 record_tdep
->size_fd_set
= 128;
1539 record_tdep
->size_dirent
= 268;
1540 record_tdep
->size_dirent64
= 280;
1541 record_tdep
->size_statfs
= 64;
1542 record_tdep
->size_statfs64
= 88;
1543 record_tdep
->size_sockaddr
= 16;
1544 record_tdep
->size_int
= 4;
1545 record_tdep
->size_long
= 4;
1546 record_tdep
->size_ulong
= 4;
1547 record_tdep
->size_msghdr
= 28;
1548 record_tdep
->size_itimerval
= 16;
1549 record_tdep
->size_stat
= 88;
1550 record_tdep
->size_old_utsname
= 325;
1551 record_tdep
->size_sysinfo
= 64;
1552 record_tdep
->size_msqid_ds
= 68;
1553 record_tdep
->size_shmid_ds
= 60;
1554 record_tdep
->size_new_utsname
= 390;
1555 record_tdep
->size_timex
= 128;
1556 record_tdep
->size_mem_dqinfo
= 24;
1557 record_tdep
->size_if_dqblk
= 72;
1558 record_tdep
->size_fs_quota_stat
= 80;
1559 record_tdep
->size_timespec
= 8;
1560 record_tdep
->size_pollfd
= 8;
1561 record_tdep
->size_NFS_FHSIZE
= 32;
1562 record_tdep
->size_knfsd_fh
= 132;
1563 record_tdep
->size_TASK_COMM_LEN
= 32;
1564 record_tdep
->size_sigaction
= 140;
1565 record_tdep
->size_sigset_t
= 128;
1566 record_tdep
->size_siginfo_t
= 128;
1567 record_tdep
->size_cap_user_data_t
= 4;
1568 record_tdep
->size_stack_t
= 12;
1569 record_tdep
->size_off_t
= 4;
1570 record_tdep
->size_stat64
= 104;
1571 record_tdep
->size_gid_t
= 4;
1572 record_tdep
->size_uid_t
= 4;
1573 record_tdep
->size_PAGE_SIZE
= 0x10000; /* 64KB */
1574 record_tdep
->size_flock64
= 32;
1575 record_tdep
->size_io_event
= 32;
1576 record_tdep
->size_iocb
= 64;
1577 record_tdep
->size_epoll_event
= 16;
1578 record_tdep
->size_itimerspec
= 16;
1579 record_tdep
->size_mq_attr
= 32;
1580 record_tdep
->size_siginfo
= 128;
1581 record_tdep
->size_termios
= 44;
1582 record_tdep
->size_pid_t
= 4;
1583 record_tdep
->size_winsize
= 8;
1584 record_tdep
->size_serial_struct
= 60;
1585 record_tdep
->size_serial_icounter_struct
= 80;
1586 record_tdep
->size_size_t
= 4;
1587 record_tdep
->size_iovec
= 8;
1590 internal_error (__FILE__
, __LINE__
, _("unexpected wordsize"));
1592 /* These values are the second argument of system call "sys_fcntl"
1593 and "sys_fcntl64". They are obtained from Linux Kernel source. */
1594 record_tdep
->fcntl_F_GETLK
= 5;
1595 record_tdep
->fcntl_F_GETLK64
= 12;
1596 record_tdep
->fcntl_F_SETLK64
= 13;
1597 record_tdep
->fcntl_F_SETLKW64
= 14;
1599 record_tdep
->arg1
= PPC_R0_REGNUM
+ 3;
1600 record_tdep
->arg2
= PPC_R0_REGNUM
+ 4;
1601 record_tdep
->arg3
= PPC_R0_REGNUM
+ 5;
1602 record_tdep
->arg4
= PPC_R0_REGNUM
+ 6;
1603 record_tdep
->arg5
= PPC_R0_REGNUM
+ 7;
1604 record_tdep
->arg6
= PPC_R0_REGNUM
+ 8;
1606 /* These values are the second argument of system call "sys_ioctl".
1607 They are obtained from Linux Kernel source.
1608 See arch/powerpc/include/uapi/asm/ioctls.h. */
1609 record_tdep
->ioctl_TCGETS
= 0x403c7413;
1610 record_tdep
->ioctl_TCSETS
= 0x803c7414;
1611 record_tdep
->ioctl_TCSETSW
= 0x803c7415;
1612 record_tdep
->ioctl_TCSETSF
= 0x803c7416;
1613 record_tdep
->ioctl_TCGETA
= 0x40147417;
1614 record_tdep
->ioctl_TCSETA
= 0x80147418;
1615 record_tdep
->ioctl_TCSETAW
= 0x80147419;
1616 record_tdep
->ioctl_TCSETAF
= 0x8014741c;
1617 record_tdep
->ioctl_TCSBRK
= 0x2000741d;
1618 record_tdep
->ioctl_TCXONC
= 0x2000741e;
1619 record_tdep
->ioctl_TCFLSH
= 0x2000741f;
1620 record_tdep
->ioctl_TIOCEXCL
= 0x540c;
1621 record_tdep
->ioctl_TIOCNXCL
= 0x540d;
1622 record_tdep
->ioctl_TIOCSCTTY
= 0x540e;
1623 record_tdep
->ioctl_TIOCGPGRP
= 0x40047477;
1624 record_tdep
->ioctl_TIOCSPGRP
= 0x80047476;
1625 record_tdep
->ioctl_TIOCOUTQ
= 0x40047473;
1626 record_tdep
->ioctl_TIOCSTI
= 0x5412;
1627 record_tdep
->ioctl_TIOCGWINSZ
= 0x40087468;
1628 record_tdep
->ioctl_TIOCSWINSZ
= 0x80087467;
1629 record_tdep
->ioctl_TIOCMGET
= 0x5415;
1630 record_tdep
->ioctl_TIOCMBIS
= 0x5416;
1631 record_tdep
->ioctl_TIOCMBIC
= 0x5417;
1632 record_tdep
->ioctl_TIOCMSET
= 0x5418;
1633 record_tdep
->ioctl_TIOCGSOFTCAR
= 0x5419;
1634 record_tdep
->ioctl_TIOCSSOFTCAR
= 0x541a;
1635 record_tdep
->ioctl_FIONREAD
= 0x4004667f;
1636 record_tdep
->ioctl_TIOCINQ
= 0x4004667f;
1637 record_tdep
->ioctl_TIOCLINUX
= 0x541c;
1638 record_tdep
->ioctl_TIOCCONS
= 0x541d;
1639 record_tdep
->ioctl_TIOCGSERIAL
= 0x541e;
1640 record_tdep
->ioctl_TIOCSSERIAL
= 0x541f;
1641 record_tdep
->ioctl_TIOCPKT
= 0x5420;
1642 record_tdep
->ioctl_FIONBIO
= 0x8004667e;
1643 record_tdep
->ioctl_TIOCNOTTY
= 0x5422;
1644 record_tdep
->ioctl_TIOCSETD
= 0x5423;
1645 record_tdep
->ioctl_TIOCGETD
= 0x5424;
1646 record_tdep
->ioctl_TCSBRKP
= 0x5425;
1647 record_tdep
->ioctl_TIOCSBRK
= 0x5427;
1648 record_tdep
->ioctl_TIOCCBRK
= 0x5428;
1649 record_tdep
->ioctl_TIOCGSID
= 0x5429;
1650 record_tdep
->ioctl_TIOCGPTN
= 0x40045430;
1651 record_tdep
->ioctl_TIOCSPTLCK
= 0x80045431;
1652 record_tdep
->ioctl_FIONCLEX
= 0x20006602;
1653 record_tdep
->ioctl_FIOCLEX
= 0x20006601;
1654 record_tdep
->ioctl_FIOASYNC
= 0x8004667d;
1655 record_tdep
->ioctl_TIOCSERCONFIG
= 0x5453;
1656 record_tdep
->ioctl_TIOCSERGWILD
= 0x5454;
1657 record_tdep
->ioctl_TIOCSERSWILD
= 0x5455;
1658 record_tdep
->ioctl_TIOCGLCKTRMIOS
= 0x5456;
1659 record_tdep
->ioctl_TIOCSLCKTRMIOS
= 0x5457;
1660 record_tdep
->ioctl_TIOCSERGSTRUCT
= 0x5458;
1661 record_tdep
->ioctl_TIOCSERGETLSR
= 0x5459;
1662 record_tdep
->ioctl_TIOCSERGETMULTI
= 0x545a;
1663 record_tdep
->ioctl_TIOCSERSETMULTI
= 0x545b;
1664 record_tdep
->ioctl_TIOCMIWAIT
= 0x545c;
1665 record_tdep
->ioctl_TIOCGICOUNT
= 0x545d;
1666 record_tdep
->ioctl_FIOQSIZE
= 0x40086680;
1670 ppc_linux_init_abi (struct gdbarch_info info
,
1671 struct gdbarch
*gdbarch
)
1673 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1674 struct tdesc_arch_data
*tdesc_data
= (void *) info
.tdep_info
;
1675 static const char *const stap_integer_prefixes
[] = { "i", NULL
};
1676 static const char *const stap_register_indirection_prefixes
[] = { "(",
1678 static const char *const stap_register_indirection_suffixes
[] = { ")",
1681 linux_init_abi (info
, gdbarch
);
1683 /* PPC GNU/Linux uses either 64-bit or 128-bit long doubles; where
1684 128-bit, they are IBM long double, not IEEE quad long double as
1685 in the System V ABI PowerPC Processor Supplement. We can safely
1686 let them default to 128-bit, since the debug info will give the
1687 size of type actually used in each case. */
1688 set_gdbarch_long_double_bit (gdbarch
, 16 * TARGET_CHAR_BIT
);
1689 set_gdbarch_long_double_format (gdbarch
, floatformats_ibm_long_double
);
1691 /* Handle inferior calls during interrupted system calls. */
1692 set_gdbarch_write_pc (gdbarch
, ppc_linux_write_pc
);
1694 /* Get the syscall number from the arch's register. */
1695 set_gdbarch_get_syscall_number (gdbarch
, ppc_linux_get_syscall_number
);
1697 /* SystemTap functions. */
1698 set_gdbarch_stap_integer_prefixes (gdbarch
, stap_integer_prefixes
);
1699 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
1700 stap_register_indirection_prefixes
);
1701 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
1702 stap_register_indirection_suffixes
);
1703 set_gdbarch_stap_gdb_register_prefix (gdbarch
, "r");
1704 set_gdbarch_stap_is_single_operand (gdbarch
, ppc_stap_is_single_operand
);
1705 set_gdbarch_stap_parse_special_token (gdbarch
,
1706 ppc_stap_parse_special_token
);
1708 if (tdep
->wordsize
== 4)
1710 /* Until November 2001, gcc did not comply with the 32 bit SysV
1711 R4 ABI requirement that structures less than or equal to 8
1712 bytes should be returned in registers. Instead GCC was using
1713 the AIX/PowerOpen ABI - everything returned in memory
1714 (well ignoring vectors that is). When this was corrected, it
1715 wasn't fixed for GNU/Linux native platform. Use the
1716 PowerOpen struct convention. */
1717 set_gdbarch_return_value (gdbarch
, ppc_linux_return_value
);
1719 set_gdbarch_memory_remove_breakpoint (gdbarch
,
1720 ppc_linux_memory_remove_breakpoint
);
1722 /* Shared library handling. */
1723 set_gdbarch_skip_trampoline_code (gdbarch
, ppc_skip_trampoline_code
);
1724 set_solib_svr4_fetch_link_map_offsets
1725 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1727 /* Setting the correct XML syscall filename. */
1728 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_PPC
);
1731 tramp_frame_prepend_unwinder (gdbarch
,
1732 &ppc32_linux_sigaction_tramp_frame
);
1733 tramp_frame_prepend_unwinder (gdbarch
,
1734 &ppc32_linux_sighandler_tramp_frame
);
1736 /* BFD target for core files. */
1737 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
1738 set_gdbarch_gcore_bfd_target (gdbarch
, "elf32-powerpcle");
1740 set_gdbarch_gcore_bfd_target (gdbarch
, "elf32-powerpc");
1742 if (powerpc_so_ops
.in_dynsym_resolve_code
== NULL
)
1744 powerpc_so_ops
= svr4_so_ops
;
1745 /* Override dynamic resolve function. */
1746 powerpc_so_ops
.in_dynsym_resolve_code
=
1747 powerpc_linux_in_dynsym_resolve_code
;
1749 set_solib_ops (gdbarch
, &powerpc_so_ops
);
1751 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
1754 if (tdep
->wordsize
== 8)
1756 if (tdep
->elf_abi
== POWERPC_ELF_V1
)
1758 /* Handle PPC GNU/Linux 64-bit function pointers (which are really
1759 function descriptors). */
1760 set_gdbarch_convert_from_func_ptr_addr
1761 (gdbarch
, ppc64_convert_from_func_ptr_addr
);
1763 set_gdbarch_elf_make_msymbol_special
1764 (gdbarch
, ppc64_elf_make_msymbol_special
);
1768 set_gdbarch_elf_make_msymbol_special
1769 (gdbarch
, ppc_elfv2_elf_make_msymbol_special
);
1771 set_gdbarch_skip_entrypoint (gdbarch
, ppc_elfv2_skip_entrypoint
);
1774 /* Shared library handling. */
1775 set_gdbarch_skip_trampoline_code (gdbarch
, ppc64_skip_trampoline_code
);
1776 set_solib_svr4_fetch_link_map_offsets
1777 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
1779 /* Setting the correct XML syscall filename. */
1780 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_PPC64
);
1783 tramp_frame_prepend_unwinder (gdbarch
,
1784 &ppc64_linux_sigaction_tramp_frame
);
1785 tramp_frame_prepend_unwinder (gdbarch
,
1786 &ppc64_linux_sighandler_tramp_frame
);
1788 /* BFD target for core files. */
1789 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
1790 set_gdbarch_gcore_bfd_target (gdbarch
, "elf64-powerpcle");
1792 set_gdbarch_gcore_bfd_target (gdbarch
, "elf64-powerpc");
1795 /* PPC32 uses a different prpsinfo32 compared to most other Linux
1797 if (tdep
->wordsize
== 4)
1798 set_gdbarch_elfcore_write_linux_prpsinfo (gdbarch
,
1799 elfcore_write_ppc_linux_prpsinfo32
);
1801 set_gdbarch_core_read_description (gdbarch
, ppc_linux_core_read_description
);
1802 set_gdbarch_iterate_over_regset_sections (gdbarch
,
1803 ppc_linux_iterate_over_regset_sections
);
1805 /* Enable TLS support. */
1806 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
1807 svr4_fetch_objfile_link_map
);
1811 const struct tdesc_feature
*feature
;
1813 /* If we have target-described registers, then we can safely
1814 reserve a number for PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM
1815 (whether they are described or not). */
1816 gdb_assert (gdbarch_num_regs (gdbarch
) <= PPC_ORIG_R3_REGNUM
);
1817 set_gdbarch_num_regs (gdbarch
, PPC_TRAP_REGNUM
+ 1);
1819 /* If they are present, then assign them to the reserved number. */
1820 feature
= tdesc_find_feature (info
.target_desc
,
1821 "org.gnu.gdb.power.linux");
1822 if (feature
!= NULL
)
1824 tdesc_numbered_register (feature
, tdesc_data
,
1825 PPC_ORIG_R3_REGNUM
, "orig_r3");
1826 tdesc_numbered_register (feature
, tdesc_data
,
1827 PPC_TRAP_REGNUM
, "trap");
1831 /* Enable Cell/B.E. if supported by the target. */
1832 if (tdesc_compatible_p (info
.target_desc
,
1833 bfd_lookup_arch (bfd_arch_spu
, bfd_mach_spu
)))
1835 /* Cell/B.E. multi-architecture support. */
1836 set_spu_solib_ops (gdbarch
);
1838 /* Cell/B.E. cross-architecture unwinder support. */
1839 frame_unwind_prepend_unwinder (gdbarch
, &ppu2spu_unwind
);
1841 /* The default displaced_step_at_entry_point doesn't work for
1842 SPU stand-alone executables. */
1843 set_gdbarch_displaced_step_location (gdbarch
,
1844 ppc_linux_displaced_step_location
);
1847 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
1849 /* Support reverse debugging. */
1850 set_gdbarch_process_record (gdbarch
, ppc_process_record
);
1851 set_gdbarch_process_record_signal (gdbarch
, ppc_linux_record_signal
);
1852 tdep
->ppc_syscall_record
= ppc_linux_syscall_record
;
1854 ppc_init_linux_record_tdep (&ppc_linux_record_tdep
, 4);
1855 ppc_init_linux_record_tdep (&ppc64_linux_record_tdep
, 8);
1858 /* Provide a prototype to silence -Wmissing-prototypes. */
1859 extern initialize_file_ftype _initialize_ppc_linux_tdep
;
1862 _initialize_ppc_linux_tdep (void)
1864 /* Register for all sub-familes of the POWER/PowerPC: 32-bit and
1865 64-bit PowerPC, and the older rs6k. */
1866 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc
, GDB_OSABI_LINUX
,
1867 ppc_linux_init_abi
);
1868 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc64
, GDB_OSABI_LINUX
,
1869 ppc_linux_init_abi
);
1870 gdbarch_register_osabi (bfd_arch_rs6000
, bfd_mach_rs6k
, GDB_OSABI_LINUX
,
1871 ppc_linux_init_abi
);
1873 /* Attach to inferior_created observer. */
1874 observer_attach_inferior_created (ppc_linux_inferior_created
);
1876 /* Attach to observers to track __spe_current_active_context. */
1877 observer_attach_inferior_created (ppc_linux_spe_context_inferior_created
);
1878 observer_attach_solib_loaded (ppc_linux_spe_context_solib_loaded
);
1879 observer_attach_solib_unloaded (ppc_linux_spe_context_solib_unloaded
);
1881 /* Initialize the Linux target descriptions. */
1882 initialize_tdesc_powerpc_32l ();
1883 initialize_tdesc_powerpc_altivec32l ();
1884 initialize_tdesc_powerpc_cell32l ();
1885 initialize_tdesc_powerpc_vsx32l ();
1886 initialize_tdesc_powerpc_isa205_32l ();
1887 initialize_tdesc_powerpc_isa205_altivec32l ();
1888 initialize_tdesc_powerpc_isa205_vsx32l ();
1889 initialize_tdesc_powerpc_64l ();
1890 initialize_tdesc_powerpc_altivec64l ();
1891 initialize_tdesc_powerpc_cell64l ();
1892 initialize_tdesc_powerpc_vsx64l ();
1893 initialize_tdesc_powerpc_isa205_64l ();
1894 initialize_tdesc_powerpc_isa205_altivec64l ();
1895 initialize_tdesc_powerpc_isa205_vsx64l ();
1896 initialize_tdesc_powerpc_e500l ();