1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 1986-2018 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 "arch/ppc-linux-common.h"
41 #include "arch/ppc-linux-tdesc.h"
42 #include "glibc-tdep.h"
43 #include "trad-frame.h"
44 #include "frame-unwind.h"
45 #include "tramp-frame.h"
46 #include "observable.h"
48 #include "elf/common.h"
49 #include "elf/ppc64.h"
50 #include "arch-utils.h"
52 #include "xml-syscall.h"
53 #include "linux-tdep.h"
54 #include "linux-record.h"
55 #include "record-full.h"
58 #include "stap-probe.h"
61 #include "cli/cli-utils.h"
62 #include "parser-defs.h"
63 #include "user-regs.h"
67 #include "features/rs6000/powerpc-32l.c"
68 #include "features/rs6000/powerpc-altivec32l.c"
69 #include "features/rs6000/powerpc-cell32l.c"
70 #include "features/rs6000/powerpc-vsx32l.c"
71 #include "features/rs6000/powerpc-isa205-32l.c"
72 #include "features/rs6000/powerpc-isa205-altivec32l.c"
73 #include "features/rs6000/powerpc-isa205-vsx32l.c"
74 #include "features/rs6000/powerpc-64l.c"
75 #include "features/rs6000/powerpc-altivec64l.c"
76 #include "features/rs6000/powerpc-cell64l.c"
77 #include "features/rs6000/powerpc-vsx64l.c"
78 #include "features/rs6000/powerpc-isa205-64l.c"
79 #include "features/rs6000/powerpc-isa205-altivec64l.c"
80 #include "features/rs6000/powerpc-isa205-vsx64l.c"
81 #include "features/rs6000/powerpc-e500l.c"
83 /* Shared library operations for PowerPC-Linux. */
84 static struct target_so_ops powerpc_so_ops
;
86 /* The syscall's XML filename for PPC and PPC64. */
87 #define XML_SYSCALL_FILENAME_PPC "syscalls/ppc-linux.xml"
88 #define XML_SYSCALL_FILENAME_PPC64 "syscalls/ppc64-linux.xml"
90 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
91 in much the same fashion as memory_remove_breakpoint in mem-break.c,
92 but is careful not to write back the previous contents if the code
93 in question has changed in between inserting the breakpoint and
96 Here is the problem that we're trying to solve...
98 Once upon a time, before introducing this function to remove
99 breakpoints from the inferior, setting a breakpoint on a shared
100 library function prior to running the program would not work
101 properly. In order to understand the problem, it is first
102 necessary to understand a little bit about dynamic linking on
105 A call to a shared library function is accomplished via a bl
106 (branch-and-link) instruction whose branch target is an entry
107 in the procedure linkage table (PLT). The PLT in the object
108 file is uninitialized. To gdb, prior to running the program, the
109 entries in the PLT are all zeros.
111 Once the program starts running, the shared libraries are loaded
112 and the procedure linkage table is initialized, but the entries in
113 the table are not (necessarily) resolved. Once a function is
114 actually called, the code in the PLT is hit and the function is
115 resolved. In order to better illustrate this, an example is in
116 order; the following example is from the gdb testsuite.
118 We start the program shmain.
120 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
123 We place two breakpoints, one on shr1 and the other on main.
126 Breakpoint 1 at 0x100409d4
128 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
130 Examine the instruction (and the immediatly following instruction)
131 upon which the breakpoint was placed. Note that the PLT entry
132 for shr1 contains zeros.
134 (gdb) x/2i 0x100409d4
135 0x100409d4 <shr1>: .long 0x0
136 0x100409d8 <shr1+4>: .long 0x0
141 Starting program: gdb.base/shmain
142 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
144 Breakpoint 2, main ()
145 at gdb.base/shmain.c:44
148 Examine the PLT again. Note that the loading of the shared
149 library has initialized the PLT to code which loads a constant
150 (which I think is an index into the GOT) into r11 and then
151 branchs a short distance to the code which actually does the
154 (gdb) x/2i 0x100409d4
155 0x100409d4 <shr1>: li r11,4
156 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
160 Breakpoint 1, shr1 (x=1)
161 at gdb.base/shr1.c:19
164 Now we've hit the breakpoint at shr1. (The breakpoint was
165 reset from the PLT entry to the actual shr1 function after the
166 shared library was loaded.) Note that the PLT entry has been
167 resolved to contain a branch that takes us directly to shr1.
168 (The real one, not the PLT entry.)
170 (gdb) x/2i 0x100409d4
171 0x100409d4 <shr1>: b 0xffaf76c <shr1>
172 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
174 The thing to note here is that the PLT entry for shr1 has been
177 Now the problem should be obvious. GDB places a breakpoint (a
178 trap instruction) on the zero value of the PLT entry for shr1.
179 Later on, after the shared library had been loaded and the PLT
180 initialized, GDB gets a signal indicating this fact and attempts
181 (as it always does when it stops) to remove all the breakpoints.
183 The breakpoint removal was causing the former contents (a zero
184 word) to be written back to the now initialized PLT entry thus
185 destroying a portion of the initialization that had occurred only a
186 short time ago. When execution continued, the zero word would be
187 executed as an instruction an illegal instruction trap was
188 generated instead. (0 is not a legal instruction.)
190 The fix for this problem was fairly straightforward. The function
191 memory_remove_breakpoint from mem-break.c was copied to this file,
192 modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
193 In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
196 The differences between ppc_linux_memory_remove_breakpoint () and
197 memory_remove_breakpoint () are minor. All that the former does
198 that the latter does not is check to make sure that the breakpoint
199 location actually contains a breakpoint (trap instruction) prior
200 to attempting to write back the old contents. If it does contain
201 a trap instruction, we allow the old contents to be written back.
202 Otherwise, we silently do nothing.
204 The big question is whether memory_remove_breakpoint () should be
205 changed to have the same functionality. The downside is that more
206 traffic is generated for remote targets since we'll have an extra
207 fetch of a memory word each time a breakpoint is removed.
209 For the time being, we'll leave this self-modifying-code-friendly
210 version in ppc-linux-tdep.c, but it ought to be migrated somewhere
211 else in the event that some other platform has similar needs with
212 regard to removing breakpoints in some potentially self modifying
215 ppc_linux_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
216 struct bp_target_info
*bp_tgt
)
218 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
219 const unsigned char *bp
;
222 gdb_byte old_contents
[BREAKPOINT_MAX
];
224 /* Determine appropriate breakpoint contents and size for this address. */
225 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bplen
);
227 /* Make sure we see the memory breakpoints. */
228 scoped_restore restore_memory
229 = make_scoped_restore_show_memory_breakpoints (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
);
241 /* For historic reasons, PPC 32 GNU/Linux follows PowerOpen rather
242 than the 32 bit SYSV R4 ABI structure return convention - all
243 structures, no matter their size, are put in memory. Vectors,
244 which were added later, do get returned in a register though. */
246 static enum return_value_convention
247 ppc_linux_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
248 struct type
*valtype
, struct regcache
*regcache
,
249 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
251 if ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
252 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
)
253 && !((TYPE_LENGTH (valtype
) == 16 || TYPE_LENGTH (valtype
) == 8)
254 && TYPE_VECTOR (valtype
)))
255 return RETURN_VALUE_STRUCT_CONVENTION
;
257 return ppc_sysv_abi_return_value (gdbarch
, function
, valtype
, regcache
,
261 /* PLT stub in an executable. */
262 static const struct ppc_insn_pattern powerpc32_plt_stub
[] =
264 { 0xffff0000, 0x3d600000, 0 }, /* lis r11, xxxx */
265 { 0xffff0000, 0x816b0000, 0 }, /* lwz r11, xxxx(r11) */
266 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
267 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
271 /* PLT stubs in a shared library or PIE.
272 The first variant is used when the PLT entry is within +/-32k of
273 the GOT pointer (r30). */
274 static const struct ppc_insn_pattern powerpc32_plt_stub_so_1
[] =
276 { 0xffff0000, 0x817e0000, 0 }, /* lwz r11, xxxx(r30) */
277 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
278 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
282 /* The second variant is used when the PLT entry is more than +/-32k
283 from the GOT pointer (r30). */
284 static const struct ppc_insn_pattern powerpc32_plt_stub_so_2
[] =
286 { 0xffff0000, 0x3d7e0000, 0 }, /* addis r11, r30, xxxx */
287 { 0xffff0000, 0x816b0000, 0 }, /* lwz r11, xxxx(r11) */
288 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
289 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
293 /* The max number of insns we check using ppc_insns_match_pattern. */
294 #define POWERPC32_PLT_CHECK_LEN (ARRAY_SIZE (powerpc32_plt_stub) - 1)
296 /* Check if PC is in PLT stub. For non-secure PLT, stub is in .plt
297 section. For secure PLT, stub is in .text and we need to check
298 instruction patterns. */
301 powerpc_linux_in_dynsym_resolve_code (CORE_ADDR pc
)
303 struct bound_minimal_symbol sym
;
305 /* Check whether PC is in the dynamic linker. This also checks
306 whether it is in the .plt section, used by non-PIC executables. */
307 if (svr4_in_dynsym_resolve_code (pc
))
310 /* Check if we are in the resolver. */
311 sym
= lookup_minimal_symbol_by_pc (pc
);
312 if (sym
.minsym
!= NULL
313 && (strcmp (MSYMBOL_LINKAGE_NAME (sym
.minsym
), "__glink") == 0
314 || strcmp (MSYMBOL_LINKAGE_NAME (sym
.minsym
),
315 "__glink_PLTresolve") == 0))
321 /* Follow PLT stub to actual routine.
323 When the execution direction is EXEC_REVERSE, scan backward to
324 check whether we are in the middle of a PLT stub. Currently,
325 we only look-behind at most 4 instructions (the max length of a PLT
329 ppc_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
331 unsigned int insnbuf
[POWERPC32_PLT_CHECK_LEN
];
332 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
333 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
334 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
335 CORE_ADDR target
= 0;
339 /* When reverse-debugging, scan backward to check whether we are
340 in the middle of trampoline code. */
341 if (execution_direction
== EXEC_REVERSE
)
342 scan_limit
= 4; /* At most 4 instructions. */
344 for (i
= 0; i
< scan_limit
; i
++)
346 if (ppc_insns_match_pattern (frame
, pc
, powerpc32_plt_stub
, insnbuf
))
348 /* Calculate PLT entry address from
350 lwz r11, xxxx(r11). */
351 target
= ((ppc_insn_d_field (insnbuf
[0]) << 16)
352 + ppc_insn_d_field (insnbuf
[1]));
354 else if (i
< ARRAY_SIZE (powerpc32_plt_stub_so_1
) - 1
355 && ppc_insns_match_pattern (frame
, pc
, powerpc32_plt_stub_so_1
,
358 /* Calculate PLT entry address from
359 lwz r11, xxxx(r30). */
360 target
= (ppc_insn_d_field (insnbuf
[0])
361 + get_frame_register_unsigned (frame
,
362 tdep
->ppc_gp0_regnum
+ 30));
364 else if (ppc_insns_match_pattern (frame
, pc
, powerpc32_plt_stub_so_2
,
367 /* Calculate PLT entry address from
369 lwz r11, xxxx(r11). */
370 target
= ((ppc_insn_d_field (insnbuf
[0]) << 16)
371 + ppc_insn_d_field (insnbuf
[1])
372 + get_frame_register_unsigned (frame
,
373 tdep
->ppc_gp0_regnum
+ 30));
377 /* Scan backward one more instruction if it doesn't match. */
382 target
= read_memory_unsigned_integer (target
, 4, byte_order
);
389 /* Wrappers to handle Linux-only registers. */
392 ppc_linux_supply_gregset (const struct regset
*regset
,
393 struct regcache
*regcache
,
394 int regnum
, const void *gregs
, size_t len
)
396 const struct ppc_reg_offsets
*offsets
397 = (const struct ppc_reg_offsets
*) regset
->regmap
;
399 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
401 if (ppc_linux_trap_reg_p (regcache
->arch ()))
403 /* "orig_r3" is stored 2 slots after "pc". */
404 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
405 ppc_supply_reg (regcache
, PPC_ORIG_R3_REGNUM
, (const gdb_byte
*) gregs
,
406 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
409 /* "trap" is stored 8 slots after "pc". */
410 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
411 ppc_supply_reg (regcache
, PPC_TRAP_REGNUM
, (const gdb_byte
*) gregs
,
412 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
418 ppc_linux_collect_gregset (const struct regset
*regset
,
419 const struct regcache
*regcache
,
420 int regnum
, void *gregs
, size_t len
)
422 const struct ppc_reg_offsets
*offsets
423 = (const struct ppc_reg_offsets
*) regset
->regmap
;
425 /* Clear areas in the linux gregset not written elsewhere. */
427 memset (gregs
, 0, len
);
429 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
431 if (ppc_linux_trap_reg_p (regcache
->arch ()))
433 /* "orig_r3" is stored 2 slots after "pc". */
434 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
435 ppc_collect_reg (regcache
, PPC_ORIG_R3_REGNUM
, (gdb_byte
*) gregs
,
436 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
439 /* "trap" is stored 8 slots after "pc". */
440 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
441 ppc_collect_reg (regcache
, PPC_TRAP_REGNUM
, (gdb_byte
*) gregs
,
442 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
448 ppc_linux_collect_vrregset (const struct regset
*regset
,
449 const struct regcache
*regcache
,
450 int regnum
, void *buf
, size_t len
)
452 gdb_byte
*vrregs
= (gdb_byte
*) buf
;
454 /* Zero-pad the unused bytes in the fields for vscr and vrsave
455 in case they get displayed somewhere (e.g. in core files). */
456 if (regnum
== PPC_VSCR_REGNUM
|| regnum
== -1)
457 memset (&vrregs
[32 * 16], 0, 16);
459 if (regnum
== PPC_VRSAVE_REGNUM
|| regnum
== -1)
460 memset (&vrregs
[33 * 16], 0, 16);
462 regcache_collect_regset (regset
, regcache
, regnum
, buf
, len
);
465 /* Regset descriptions. */
466 static const struct ppc_reg_offsets ppc32_linux_reg_offsets
=
468 /* General-purpose registers. */
469 /* .r0_offset = */ 0,
472 /* .pc_offset = */ 128,
473 /* .ps_offset = */ 132,
474 /* .cr_offset = */ 152,
475 /* .lr_offset = */ 144,
476 /* .ctr_offset = */ 140,
477 /* .xer_offset = */ 148,
478 /* .mq_offset = */ 156,
480 /* Floating-point registers. */
481 /* .f0_offset = */ 0,
482 /* .fpscr_offset = */ 256,
483 /* .fpscr_size = */ 8
486 static const struct ppc_reg_offsets ppc64_linux_reg_offsets
=
488 /* General-purpose registers. */
489 /* .r0_offset = */ 0,
492 /* .pc_offset = */ 256,
493 /* .ps_offset = */ 264,
494 /* .cr_offset = */ 304,
495 /* .lr_offset = */ 288,
496 /* .ctr_offset = */ 280,
497 /* .xer_offset = */ 296,
498 /* .mq_offset = */ 312,
500 /* Floating-point registers. */
501 /* .f0_offset = */ 0,
502 /* .fpscr_offset = */ 256,
503 /* .fpscr_size = */ 8
506 static const struct regset ppc32_linux_gregset
= {
507 &ppc32_linux_reg_offsets
,
508 ppc_linux_supply_gregset
,
509 ppc_linux_collect_gregset
512 static const struct regset ppc64_linux_gregset
= {
513 &ppc64_linux_reg_offsets
,
514 ppc_linux_supply_gregset
,
515 ppc_linux_collect_gregset
518 static const struct regset ppc32_linux_fpregset
= {
519 &ppc32_linux_reg_offsets
,
524 static const struct regcache_map_entry ppc32_le_linux_vrregmap
[] =
526 { 32, PPC_VR0_REGNUM
, 16 },
527 { 1, PPC_VSCR_REGNUM
, 4 },
528 { 1, REGCACHE_MAP_SKIP
, 12 },
529 { 1, PPC_VRSAVE_REGNUM
, 4 },
530 { 1, REGCACHE_MAP_SKIP
, 12 },
534 static const struct regcache_map_entry ppc32_be_linux_vrregmap
[] =
536 { 32, PPC_VR0_REGNUM
, 16 },
537 { 1, REGCACHE_MAP_SKIP
, 12},
538 { 1, PPC_VSCR_REGNUM
, 4 },
539 { 1, PPC_VRSAVE_REGNUM
, 4 },
540 { 1, REGCACHE_MAP_SKIP
, 12 },
544 static const struct regset ppc32_le_linux_vrregset
= {
545 ppc32_le_linux_vrregmap
,
546 regcache_supply_regset
,
547 ppc_linux_collect_vrregset
550 static const struct regset ppc32_be_linux_vrregset
= {
551 ppc32_be_linux_vrregmap
,
552 regcache_supply_regset
,
553 ppc_linux_collect_vrregset
556 static const struct regcache_map_entry ppc32_linux_vsxregmap
[] =
558 { 32, PPC_VSR0_UPPER_REGNUM
, 8 },
562 static const struct regset ppc32_linux_vsxregset
= {
563 ppc32_linux_vsxregmap
,
564 regcache_supply_regset
,
565 regcache_collect_regset
568 const struct regset
*
569 ppc_linux_gregset (int wordsize
)
571 return wordsize
== 8 ? &ppc64_linux_gregset
: &ppc32_linux_gregset
;
574 const struct regset
*
575 ppc_linux_fpregset (void)
577 return &ppc32_linux_fpregset
;
580 const struct regset
*
581 ppc_linux_vrregset (struct gdbarch
*gdbarch
)
583 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
584 return &ppc32_be_linux_vrregset
;
586 return &ppc32_le_linux_vrregset
;
589 const struct regset
*
590 ppc_linux_vsxregset (void)
592 return &ppc32_linux_vsxregset
;
595 /* Iterate over supported core file register note sections. */
598 ppc_linux_iterate_over_regset_sections (struct gdbarch
*gdbarch
,
599 iterate_over_regset_sections_cb
*cb
,
601 const struct regcache
*regcache
)
603 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
604 int have_altivec
= tdep
->ppc_vr0_regnum
!= -1;
605 int have_vsx
= tdep
->ppc_vsr0_upper_regnum
!= -1;
607 if (tdep
->wordsize
== 4)
608 cb (".reg", 48 * 4, &ppc32_linux_gregset
, NULL
, cb_data
);
610 cb (".reg", 48 * 8, &ppc64_linux_gregset
, NULL
, cb_data
);
612 cb (".reg2", 264, &ppc32_linux_fpregset
, NULL
, cb_data
);
616 const struct regset
*vrregset
= ppc_linux_vrregset (gdbarch
);
617 cb (".reg-ppc-vmx", PPC_LINUX_SIZEOF_VRREGSET
, vrregset
,
618 "ppc Altivec", cb_data
);
622 cb (".reg-ppc-vsx", PPC_LINUX_SIZEOF_VSXREGSET
,
623 &ppc32_linux_vsxregset
, "POWER7 VSX", cb_data
);
627 ppc_linux_sigtramp_cache (struct frame_info
*this_frame
,
628 struct trad_frame_cache
*this_cache
,
629 CORE_ADDR func
, LONGEST offset
,
637 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
638 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
639 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
641 base
= get_frame_register_unsigned (this_frame
,
642 gdbarch_sp_regnum (gdbarch
));
643 if (bias
> 0 && get_frame_pc (this_frame
) != func
)
644 /* See below, some signal trampolines increment the stack as their
645 first instruction, need to compensate for that. */
648 /* Find the address of the register buffer pointer. */
649 regs
= base
+ offset
;
650 /* Use that to find the address of the corresponding register
652 gpregs
= read_memory_unsigned_integer (regs
, tdep
->wordsize
, byte_order
);
653 fpregs
= gpregs
+ 48 * tdep
->wordsize
;
655 /* General purpose. */
656 for (i
= 0; i
< 32; i
++)
658 int regnum
= i
+ tdep
->ppc_gp0_regnum
;
659 trad_frame_set_reg_addr (this_cache
,
660 regnum
, gpregs
+ i
* tdep
->wordsize
);
662 trad_frame_set_reg_addr (this_cache
,
663 gdbarch_pc_regnum (gdbarch
),
664 gpregs
+ 32 * tdep
->wordsize
);
665 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_ctr_regnum
,
666 gpregs
+ 35 * tdep
->wordsize
);
667 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_lr_regnum
,
668 gpregs
+ 36 * tdep
->wordsize
);
669 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_xer_regnum
,
670 gpregs
+ 37 * tdep
->wordsize
);
671 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_cr_regnum
,
672 gpregs
+ 38 * tdep
->wordsize
);
674 if (ppc_linux_trap_reg_p (gdbarch
))
676 trad_frame_set_reg_addr (this_cache
, PPC_ORIG_R3_REGNUM
,
677 gpregs
+ 34 * tdep
->wordsize
);
678 trad_frame_set_reg_addr (this_cache
, PPC_TRAP_REGNUM
,
679 gpregs
+ 40 * tdep
->wordsize
);
682 if (ppc_floating_point_unit_p (gdbarch
))
684 /* Floating point registers. */
685 for (i
= 0; i
< 32; i
++)
687 int regnum
= i
+ gdbarch_fp0_regnum (gdbarch
);
688 trad_frame_set_reg_addr (this_cache
, regnum
,
689 fpregs
+ i
* tdep
->wordsize
);
691 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_fpscr_regnum
,
692 fpregs
+ 32 * tdep
->wordsize
);
694 trad_frame_set_id (this_cache
, frame_id_build (base
, func
));
698 ppc32_linux_sigaction_cache_init (const struct tramp_frame
*self
,
699 struct frame_info
*this_frame
,
700 struct trad_frame_cache
*this_cache
,
703 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
704 0xd0 /* Offset to ucontext_t. */
705 + 0x30 /* Offset to .reg. */,
710 ppc64_linux_sigaction_cache_init (const struct tramp_frame
*self
,
711 struct frame_info
*this_frame
,
712 struct trad_frame_cache
*this_cache
,
715 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
716 0x80 /* Offset to ucontext_t. */
717 + 0xe0 /* Offset to .reg. */,
722 ppc32_linux_sighandler_cache_init (const struct tramp_frame
*self
,
723 struct frame_info
*this_frame
,
724 struct trad_frame_cache
*this_cache
,
727 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
728 0x40 /* Offset to ucontext_t. */
729 + 0x1c /* Offset to .reg. */,
734 ppc64_linux_sighandler_cache_init (const struct tramp_frame
*self
,
735 struct frame_info
*this_frame
,
736 struct trad_frame_cache
*this_cache
,
739 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
740 0x80 /* Offset to struct sigcontext. */
741 + 0x38 /* Offset to .reg. */,
745 static struct tramp_frame ppc32_linux_sigaction_tramp_frame
= {
749 { 0x380000ac, -1 }, /* li r0, 172 */
750 { 0x44000002, -1 }, /* sc */
751 { TRAMP_SENTINEL_INSN
},
753 ppc32_linux_sigaction_cache_init
755 static struct tramp_frame ppc64_linux_sigaction_tramp_frame
= {
759 { 0x38210080, -1 }, /* addi r1,r1,128 */
760 { 0x380000ac, -1 }, /* li r0, 172 */
761 { 0x44000002, -1 }, /* sc */
762 { TRAMP_SENTINEL_INSN
},
764 ppc64_linux_sigaction_cache_init
766 static struct tramp_frame ppc32_linux_sighandler_tramp_frame
= {
770 { 0x38000077, -1 }, /* li r0,119 */
771 { 0x44000002, -1 }, /* sc */
772 { TRAMP_SENTINEL_INSN
},
774 ppc32_linux_sighandler_cache_init
776 static struct tramp_frame ppc64_linux_sighandler_tramp_frame
= {
780 { 0x38210080, -1 }, /* addi r1,r1,128 */
781 { 0x38000077, -1 }, /* li r0,119 */
782 { 0x44000002, -1 }, /* sc */
783 { TRAMP_SENTINEL_INSN
},
785 ppc64_linux_sighandler_cache_init
788 /* Return 1 if PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM are usable. */
790 ppc_linux_trap_reg_p (struct gdbarch
*gdbarch
)
792 /* If we do not have a target description with registers, then
793 the special registers will not be included in the register set. */
794 if (!tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
797 /* If we do, then it is safe to check the size. */
798 return register_size (gdbarch
, PPC_ORIG_R3_REGNUM
) > 0
799 && register_size (gdbarch
, PPC_TRAP_REGNUM
) > 0;
802 /* Return the current system call's number present in the
803 r0 register. When the function fails, it returns -1. */
805 ppc_linux_get_syscall_number (struct gdbarch
*gdbarch
,
808 struct regcache
*regcache
= get_thread_regcache (thread
);
809 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
810 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
812 /* Make sure we're in a 32- or 64-bit machine */
813 gdb_assert (tdep
->wordsize
== 4 || tdep
->wordsize
== 8);
815 /* The content of a register */
816 gdb::byte_vector
buf (tdep
->wordsize
);
818 /* Getting the system call number from the register.
819 When dealing with PowerPC architecture, this information
820 is stored at 0th register. */
821 regcache
->cooked_read (tdep
->ppc_gp0_regnum
, buf
.data ());
823 return extract_signed_integer (buf
.data (), tdep
->wordsize
, byte_order
);
826 /* PPC process record-replay */
828 static struct linux_record_tdep ppc_linux_record_tdep
;
829 static struct linux_record_tdep ppc64_linux_record_tdep
;
831 /* ppc_canonicalize_syscall maps from the native PowerPC Linux set of
832 syscall ids into a canonical set of syscall ids used by process
833 record. (See arch/powerpc/include/uapi/asm/unistd.h in kernel tree.)
834 Return -1 if this system call is not supported by process record.
835 Otherwise, return the syscall number for preocess reocrd of given
838 static enum gdb_syscall
839 ppc_canonicalize_syscall (int syscall
)
845 else if (syscall
>= 167 && syscall
<= 190) /* Skip query_module 166 */
846 result
= syscall
+ 1;
847 else if (syscall
>= 192 && syscall
<= 197) /* mmap2 */
849 else if (syscall
== 208) /* tkill */
850 result
= gdb_sys_tkill
;
851 else if (syscall
>= 207 && syscall
<= 220) /* gettid */
852 result
= syscall
+ 224 - 207;
853 else if (syscall
>= 234 && syscall
<= 239) /* exit_group */
854 result
= syscall
+ 252 - 234;
855 else if (syscall
>= 240 && syscall
<= 248) /* timer_create */
856 result
= syscall
+= 259 - 240;
857 else if (syscall
>= 250 && syscall
<= 251) /* tgkill */
858 result
= syscall
+ 270 - 250;
859 else if (syscall
== 336)
860 result
= gdb_sys_recv
;
861 else if (syscall
== 337)
862 result
= gdb_sys_recvfrom
;
863 else if (syscall
== 342)
864 result
= gdb_sys_recvmsg
;
866 return (enum gdb_syscall
) result
;
869 /* Record registers which might be clobbered during system call.
870 Return 0 if successful. */
873 ppc_linux_syscall_record (struct regcache
*regcache
)
875 struct gdbarch
*gdbarch
= regcache
->arch ();
876 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
878 enum gdb_syscall syscall_gdb
;
882 regcache_raw_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
, &scnum
);
883 syscall_gdb
= ppc_canonicalize_syscall (scnum
);
887 printf_unfiltered (_("Process record and replay target doesn't "
888 "support syscall number %d\n"), (int) scnum
);
892 if (syscall_gdb
== gdb_sys_sigreturn
893 || syscall_gdb
== gdb_sys_rt_sigreturn
)
896 int regsets
[] = { tdep
->ppc_gp0_regnum
,
897 tdep
->ppc_fp0_regnum
,
898 tdep
->ppc_vr0_regnum
,
899 tdep
->ppc_vsr0_upper_regnum
};
901 for (j
= 0; j
< 4; j
++)
903 if (regsets
[j
] == -1)
905 for (i
= 0; i
< 32; i
++)
907 if (record_full_arch_list_add_reg (regcache
, regsets
[j
] + i
))
912 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_cr_regnum
))
914 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_ctr_regnum
))
916 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_lr_regnum
))
918 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_xer_regnum
))
924 if (tdep
->wordsize
== 8)
925 ret
= record_linux_system_call (syscall_gdb
, regcache
,
926 &ppc64_linux_record_tdep
);
928 ret
= record_linux_system_call (syscall_gdb
, regcache
,
929 &ppc_linux_record_tdep
);
934 /* Record registers clobbered during syscall. */
935 for (i
= 3; i
<= 12; i
++)
937 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ i
))
940 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ 0))
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
, tdep
->ppc_lr_regnum
))
952 /* Record registers which might be clobbered during signal handling.
953 Return 0 if successful. */
956 ppc_linux_record_signal (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
957 enum gdb_signal signal
)
959 /* See handle_rt_signal64 in arch/powerpc/kernel/signal_64.c
960 handle_rt_signal32 in arch/powerpc/kernel/signal_32.c
961 arch/powerpc/include/asm/ptrace.h
963 const int SIGNAL_FRAMESIZE
= 128;
964 const int sizeof_rt_sigframe
= 1440 * 2 + 8 * 2 + 4 * 6 + 8 + 8 + 128 + 512;
966 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
969 for (i
= 3; i
<= 12; i
++)
971 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ i
))
975 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_lr_regnum
))
977 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_cr_regnum
))
979 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_ctr_regnum
))
981 if (record_full_arch_list_add_reg (regcache
, gdbarch_pc_regnum (gdbarch
)))
983 if (record_full_arch_list_add_reg (regcache
, gdbarch_sp_regnum (gdbarch
)))
986 /* Record the change in the stack.
987 frame-size = sizeof (struct rt_sigframe) + SIGNAL_FRAMESIZE */
988 regcache_raw_read_unsigned (regcache
, gdbarch_sp_regnum (gdbarch
), &sp
);
989 sp
-= SIGNAL_FRAMESIZE
;
990 sp
-= sizeof_rt_sigframe
;
992 if (record_full_arch_list_add_mem (sp
, SIGNAL_FRAMESIZE
+ sizeof_rt_sigframe
))
995 if (record_full_arch_list_add_end ())
1002 ppc_linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1004 struct gdbarch
*gdbarch
= regcache
->arch ();
1006 regcache_cooked_write_unsigned (regcache
, gdbarch_pc_regnum (gdbarch
), pc
);
1008 /* Set special TRAP register to -1 to prevent the kernel from
1009 messing with the PC we just installed, if we happen to be
1010 within an interrupted system call that the kernel wants to
1013 Note that after we return from the dummy call, the TRAP and
1014 ORIG_R3 registers will be automatically restored, and the
1015 kernel continues to restart the system call at this point. */
1016 if (ppc_linux_trap_reg_p (gdbarch
))
1017 regcache_cooked_write_unsigned (regcache
, PPC_TRAP_REGNUM
, -1);
1021 ppc_linux_spu_section (bfd
*abfd
, asection
*asect
, void *user_data
)
1023 return startswith (bfd_section_name (abfd
, asect
), "SPU/");
1026 static const struct target_desc
*
1027 ppc_linux_core_read_description (struct gdbarch
*gdbarch
,
1028 struct target_ops
*target
,
1031 struct ppc_linux_features features
= ppc_linux_no_features
;
1032 asection
*cell
= bfd_sections_find_if (abfd
, ppc_linux_spu_section
, NULL
);
1033 asection
*altivec
= bfd_get_section_by_name (abfd
, ".reg-ppc-vmx");
1034 asection
*vsx
= bfd_get_section_by_name (abfd
, ".reg-ppc-vsx");
1035 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
1040 switch (bfd_section_size (abfd
, section
))
1043 features
.wordsize
= 4;
1046 features
.wordsize
= 8;
1053 features
.cell
= true;
1056 features
.altivec
= true;
1059 features
.vsx
= true;
1063 if (target_auxv_search (target
, AT_HWCAP
, &hwcap
) != 1)
1066 features
.isa205
= ppc_linux_has_isa205 (hwcap
);
1068 return ppc_linux_match_description (features
);
1072 /* Implementation of `gdbarch_elf_make_msymbol_special', as defined in
1073 gdbarch.h. This implementation is used for the ELFv2 ABI only. */
1076 ppc_elfv2_elf_make_msymbol_special (asymbol
*sym
, struct minimal_symbol
*msym
)
1078 elf_symbol_type
*elf_sym
= (elf_symbol_type
*)sym
;
1080 /* If the symbol is marked as having a local entry point, set a target
1081 flag in the msymbol. We currently only support local entry point
1082 offsets of 8 bytes, which is the only entry point offset ever used
1083 by current compilers. If/when other offsets are ever used, we will
1084 have to use additional target flag bits to store them. */
1085 switch (PPC64_LOCAL_ENTRY_OFFSET (elf_sym
->internal_elf_sym
.st_other
))
1090 MSYMBOL_TARGET_FLAG_1 (msym
) = 1;
1095 /* Implementation of `gdbarch_skip_entrypoint', as defined in
1096 gdbarch.h. This implementation is used for the ELFv2 ABI only. */
1099 ppc_elfv2_skip_entrypoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1101 struct bound_minimal_symbol fun
;
1102 int local_entry_offset
= 0;
1104 fun
= lookup_minimal_symbol_by_pc (pc
);
1105 if (fun
.minsym
== NULL
)
1108 /* See ppc_elfv2_elf_make_msymbol_special for how local entry point
1109 offset values are encoded. */
1110 if (MSYMBOL_TARGET_FLAG_1 (fun
.minsym
))
1111 local_entry_offset
= 8;
1113 if (BMSYMBOL_VALUE_ADDRESS (fun
) <= pc
1114 && pc
< BMSYMBOL_VALUE_ADDRESS (fun
) + local_entry_offset
)
1115 return BMSYMBOL_VALUE_ADDRESS (fun
) + local_entry_offset
;
1120 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1124 ppc_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
1126 return (*s
== 'i' /* Literal number. */
1127 || (isdigit (*s
) && s
[1] == '('
1128 && isdigit (s
[2])) /* Displacement. */
1129 || (*s
== '(' && isdigit (s
[1])) /* Register indirection. */
1130 || isdigit (*s
)); /* Register value. */
1133 /* Implementation of `gdbarch_stap_parse_special_token', as defined in
1137 ppc_stap_parse_special_token (struct gdbarch
*gdbarch
,
1138 struct stap_parse_info
*p
)
1140 if (isdigit (*p
->arg
))
1142 /* This temporary pointer is needed because we have to do a lookahead.
1143 We could be dealing with a register displacement, and in such case
1144 we would not need to do anything. */
1145 const char *s
= p
->arg
;
1150 while (isdigit (*s
))
1155 /* It is a register displacement indeed. Returning 0 means we are
1156 deferring the treatment of this case to the generic parser. */
1161 regname
= (char *) alloca (len
+ 2);
1164 strncpy (regname
+ 1, p
->arg
, len
);
1166 regname
[len
] = '\0';
1168 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
1169 error (_("Invalid register name `%s' on expression `%s'."),
1170 regname
, p
->saved_arg
);
1172 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1175 write_exp_string (&p
->pstate
, str
);
1176 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1182 /* All the other tokens should be handled correctly by the generic
1190 /* Cell/B.E. active SPE context tracking support. */
1192 static struct objfile
*spe_context_objfile
= NULL
;
1193 static CORE_ADDR spe_context_lm_addr
= 0;
1194 static CORE_ADDR spe_context_offset
= 0;
1196 static ptid_t spe_context_cache_ptid
;
1197 static CORE_ADDR spe_context_cache_address
;
1199 /* Hook into inferior_created, solib_loaded, and solib_unloaded observers
1200 to track whether we've loaded a version of libspe2 (as static or dynamic
1201 library) that provides the __spe_current_active_context variable. */
1203 ppc_linux_spe_context_lookup (struct objfile
*objfile
)
1205 struct bound_minimal_symbol sym
;
1209 spe_context_objfile
= NULL
;
1210 spe_context_lm_addr
= 0;
1211 spe_context_offset
= 0;
1212 spe_context_cache_ptid
= minus_one_ptid
;
1213 spe_context_cache_address
= 0;
1217 sym
= lookup_minimal_symbol ("__spe_current_active_context", NULL
, objfile
);
1220 spe_context_objfile
= objfile
;
1221 spe_context_lm_addr
= svr4_fetch_objfile_link_map (objfile
);
1222 spe_context_offset
= MSYMBOL_VALUE_RAW_ADDRESS (sym
.minsym
);
1223 spe_context_cache_ptid
= minus_one_ptid
;
1224 spe_context_cache_address
= 0;
1230 ppc_linux_spe_context_inferior_created (struct target_ops
*t
, int from_tty
)
1232 struct objfile
*objfile
;
1234 ppc_linux_spe_context_lookup (NULL
);
1235 ALL_OBJFILES (objfile
)
1236 ppc_linux_spe_context_lookup (objfile
);
1240 ppc_linux_spe_context_solib_loaded (struct so_list
*so
)
1242 if (strstr (so
->so_original_name
, "/libspe") != NULL
)
1244 solib_read_symbols (so
, 0);
1245 ppc_linux_spe_context_lookup (so
->objfile
);
1250 ppc_linux_spe_context_solib_unloaded (struct so_list
*so
)
1252 if (so
->objfile
== spe_context_objfile
)
1253 ppc_linux_spe_context_lookup (NULL
);
1256 /* Retrieve contents of the N'th element in the current thread's
1257 linked SPE context list into ID and NPC. Return the address of
1258 said context element, or 0 if not found. */
1260 ppc_linux_spe_context (int wordsize
, enum bfd_endian byte_order
,
1261 int n
, int *id
, unsigned int *npc
)
1263 CORE_ADDR spe_context
= 0;
1267 /* Quick exit if we have not found __spe_current_active_context. */
1268 if (!spe_context_objfile
)
1271 /* Look up cached address of thread-local variable. */
1272 if (spe_context_cache_ptid
!= inferior_ptid
)
1274 struct target_ops
*target
= current_top_target ();
1278 /* We do not call target_translate_tls_address here, because
1279 svr4_fetch_objfile_link_map may invalidate the frame chain,
1280 which must not do while inside a frame sniffer.
1282 Instead, we have cached the lm_addr value, and use that to
1283 directly call the target's to_get_thread_local_address. */
1284 spe_context_cache_address
1285 = target
->get_thread_local_address (inferior_ptid
,
1286 spe_context_lm_addr
,
1287 spe_context_offset
);
1288 spe_context_cache_ptid
= inferior_ptid
;
1291 CATCH (ex
, RETURN_MASK_ERROR
)
1298 /* Read variable value. */
1299 if (target_read_memory (spe_context_cache_address
, buf
, wordsize
) == 0)
1300 spe_context
= extract_unsigned_integer (buf
, wordsize
, byte_order
);
1302 /* Cyle through to N'th linked list element. */
1303 for (i
= 0; i
< n
&& spe_context
; i
++)
1304 if (target_read_memory (spe_context
+ align_up (12, wordsize
),
1305 buf
, wordsize
) == 0)
1306 spe_context
= extract_unsigned_integer (buf
, wordsize
, byte_order
);
1310 /* Read current context. */
1312 && target_read_memory (spe_context
, buf
, 12) != 0)
1315 /* Extract data elements. */
1319 *id
= extract_signed_integer (buf
, 4, byte_order
);
1321 *npc
= extract_unsigned_integer (buf
+ 4, 4, byte_order
);
1328 /* Cell/B.E. cross-architecture unwinder support. */
1330 struct ppu2spu_cache
1332 struct frame_id frame_id
;
1333 readonly_detached_regcache
*regcache
;
1336 static struct gdbarch
*
1337 ppu2spu_prev_arch (struct frame_info
*this_frame
, void **this_cache
)
1339 struct ppu2spu_cache
*cache
= (struct ppu2spu_cache
*) *this_cache
;
1340 return cache
->regcache
->arch ();
1344 ppu2spu_this_id (struct frame_info
*this_frame
,
1345 void **this_cache
, struct frame_id
*this_id
)
1347 struct ppu2spu_cache
*cache
= (struct ppu2spu_cache
*) *this_cache
;
1348 *this_id
= cache
->frame_id
;
1351 static struct value
*
1352 ppu2spu_prev_register (struct frame_info
*this_frame
,
1353 void **this_cache
, int regnum
)
1355 struct ppu2spu_cache
*cache
= (struct ppu2spu_cache
*) *this_cache
;
1356 struct gdbarch
*gdbarch
= cache
->regcache
->arch ();
1359 buf
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
1361 cache
->regcache
->cooked_read (regnum
, buf
);
1362 return frame_unwind_got_bytes (this_frame
, regnum
, buf
);
1367 struct gdbarch
*gdbarch
;
1370 gdb_byte gprs
[128*16];
1373 static enum register_status
1374 ppu2spu_unwind_register (ppu2spu_data
*data
, int regnum
, gdb_byte
*buf
)
1376 enum bfd_endian byte_order
= gdbarch_byte_order (data
->gdbarch
);
1378 if (regnum
>= 0 && regnum
< SPU_NUM_GPRS
)
1379 memcpy (buf
, data
->gprs
+ 16*regnum
, 16);
1380 else if (regnum
== SPU_ID_REGNUM
)
1381 store_unsigned_integer (buf
, 4, byte_order
, data
->id
);
1382 else if (regnum
== SPU_PC_REGNUM
)
1383 store_unsigned_integer (buf
, 4, byte_order
, data
->npc
);
1385 return REG_UNAVAILABLE
;
1391 ppu2spu_sniffer (const struct frame_unwind
*self
,
1392 struct frame_info
*this_frame
, void **this_prologue_cache
)
1394 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1395 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1396 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1397 struct ppu2spu_data data
;
1398 struct frame_info
*fi
;
1399 CORE_ADDR base
, func
, backchain
, spe_context
;
1403 /* Count the number of SPU contexts already in the frame chain. */
1404 for (fi
= get_next_frame (this_frame
); fi
; fi
= get_next_frame (fi
))
1405 if (get_frame_type (fi
) == ARCH_FRAME
1406 && gdbarch_bfd_arch_info (get_frame_arch (fi
))->arch
== bfd_arch_spu
)
1409 base
= get_frame_sp (this_frame
);
1410 func
= get_frame_pc (this_frame
);
1411 if (target_read_memory (base
, buf
, tdep
->wordsize
))
1413 backchain
= extract_unsigned_integer (buf
, tdep
->wordsize
, byte_order
);
1415 spe_context
= ppc_linux_spe_context (tdep
->wordsize
, byte_order
,
1416 n
, &data
.id
, &data
.npc
);
1417 if (spe_context
&& base
<= spe_context
&& spe_context
< backchain
)
1421 /* Find gdbarch for SPU. */
1422 struct gdbarch_info info
;
1423 gdbarch_info_init (&info
);
1424 info
.bfd_arch_info
= bfd_lookup_arch (bfd_arch_spu
, bfd_mach_spu
);
1425 info
.byte_order
= BFD_ENDIAN_BIG
;
1426 info
.osabi
= GDB_OSABI_LINUX
;
1428 data
.gdbarch
= gdbarch_find_by_info (info
);
1432 xsnprintf (annex
, sizeof annex
, "%d/regs", data
.id
);
1433 if (target_read (current_top_target (), TARGET_OBJECT_SPU
, annex
,
1434 data
.gprs
, 0, sizeof data
.gprs
)
1435 == sizeof data
.gprs
)
1437 auto cooked_read
= [&data
] (int regnum
, gdb_byte
*buf
)
1439 return ppu2spu_unwind_register (&data
, regnum
, buf
);
1441 struct ppu2spu_cache
*cache
1442 = FRAME_OBSTACK_CALLOC (1, struct ppu2spu_cache
);
1443 std::unique_ptr
<readonly_detached_regcache
> regcache
1444 (new readonly_detached_regcache (data
.gdbarch
, cooked_read
));
1446 cache
->frame_id
= frame_id_build (base
, func
);
1447 cache
->regcache
= regcache
.release ();
1448 *this_prologue_cache
= cache
;
1457 ppu2spu_dealloc_cache (struct frame_info
*self
, void *this_cache
)
1459 struct ppu2spu_cache
*cache
= (struct ppu2spu_cache
*) this_cache
;
1460 delete cache
->regcache
;
1463 static const struct frame_unwind ppu2spu_unwind
= {
1465 default_frame_unwind_stop_reason
,
1467 ppu2spu_prev_register
,
1470 ppu2spu_dealloc_cache
,
1474 /* Initialize linux_record_tdep if not initialized yet.
1475 WORDSIZE is 4 or 8 for 32- or 64-bit PowerPC Linux respectively.
1476 Sizes of data structures are initialized accordingly. */
1479 ppc_init_linux_record_tdep (struct linux_record_tdep
*record_tdep
,
1482 /* Simply return if it had been initialized. */
1483 if (record_tdep
->size_pointer
!= 0)
1486 /* These values are the size of the type that will be used in a system
1487 call. They are obtained from Linux Kernel source. */
1491 record_tdep
->size_pointer
= 8;
1492 record_tdep
->size__old_kernel_stat
= 32;
1493 record_tdep
->size_tms
= 32;
1494 record_tdep
->size_loff_t
= 8;
1495 record_tdep
->size_flock
= 32;
1496 record_tdep
->size_oldold_utsname
= 45;
1497 record_tdep
->size_ustat
= 32;
1498 record_tdep
->size_old_sigaction
= 32;
1499 record_tdep
->size_old_sigset_t
= 8;
1500 record_tdep
->size_rlimit
= 16;
1501 record_tdep
->size_rusage
= 144;
1502 record_tdep
->size_timeval
= 16;
1503 record_tdep
->size_timezone
= 8;
1504 record_tdep
->size_old_gid_t
= 4;
1505 record_tdep
->size_old_uid_t
= 4;
1506 record_tdep
->size_fd_set
= 128;
1507 record_tdep
->size_old_dirent
= 280;
1508 record_tdep
->size_statfs
= 120;
1509 record_tdep
->size_statfs64
= 120;
1510 record_tdep
->size_sockaddr
= 16;
1511 record_tdep
->size_int
= 4;
1512 record_tdep
->size_long
= 8;
1513 record_tdep
->size_ulong
= 8;
1514 record_tdep
->size_msghdr
= 56;
1515 record_tdep
->size_itimerval
= 32;
1516 record_tdep
->size_stat
= 144;
1517 record_tdep
->size_old_utsname
= 325;
1518 record_tdep
->size_sysinfo
= 112;
1519 record_tdep
->size_msqid_ds
= 120;
1520 record_tdep
->size_shmid_ds
= 112;
1521 record_tdep
->size_new_utsname
= 390;
1522 record_tdep
->size_timex
= 208;
1523 record_tdep
->size_mem_dqinfo
= 24;
1524 record_tdep
->size_if_dqblk
= 72;
1525 record_tdep
->size_fs_quota_stat
= 80;
1526 record_tdep
->size_timespec
= 16;
1527 record_tdep
->size_pollfd
= 8;
1528 record_tdep
->size_NFS_FHSIZE
= 32;
1529 record_tdep
->size_knfsd_fh
= 132;
1530 record_tdep
->size_TASK_COMM_LEN
= 16;
1531 record_tdep
->size_sigaction
= 32;
1532 record_tdep
->size_sigset_t
= 8;
1533 record_tdep
->size_siginfo_t
= 128;
1534 record_tdep
->size_cap_user_data_t
= 8;
1535 record_tdep
->size_stack_t
= 24;
1536 record_tdep
->size_off_t
= 8;
1537 record_tdep
->size_stat64
= 104;
1538 record_tdep
->size_gid_t
= 4;
1539 record_tdep
->size_uid_t
= 4;
1540 record_tdep
->size_PAGE_SIZE
= 0x10000; /* 64KB */
1541 record_tdep
->size_flock64
= 32;
1542 record_tdep
->size_io_event
= 32;
1543 record_tdep
->size_iocb
= 64;
1544 record_tdep
->size_epoll_event
= 16;
1545 record_tdep
->size_itimerspec
= 32;
1546 record_tdep
->size_mq_attr
= 64;
1547 record_tdep
->size_termios
= 44;
1548 record_tdep
->size_pid_t
= 4;
1549 record_tdep
->size_winsize
= 8;
1550 record_tdep
->size_serial_struct
= 72;
1551 record_tdep
->size_serial_icounter_struct
= 80;
1552 record_tdep
->size_size_t
= 8;
1553 record_tdep
->size_iovec
= 16;
1554 record_tdep
->size_time_t
= 8;
1556 else if (wordsize
== 4)
1558 record_tdep
->size_pointer
= 4;
1559 record_tdep
->size__old_kernel_stat
= 32;
1560 record_tdep
->size_tms
= 16;
1561 record_tdep
->size_loff_t
= 8;
1562 record_tdep
->size_flock
= 16;
1563 record_tdep
->size_oldold_utsname
= 45;
1564 record_tdep
->size_ustat
= 20;
1565 record_tdep
->size_old_sigaction
= 16;
1566 record_tdep
->size_old_sigset_t
= 4;
1567 record_tdep
->size_rlimit
= 8;
1568 record_tdep
->size_rusage
= 72;
1569 record_tdep
->size_timeval
= 8;
1570 record_tdep
->size_timezone
= 8;
1571 record_tdep
->size_old_gid_t
= 4;
1572 record_tdep
->size_old_uid_t
= 4;
1573 record_tdep
->size_fd_set
= 128;
1574 record_tdep
->size_old_dirent
= 268;
1575 record_tdep
->size_statfs
= 64;
1576 record_tdep
->size_statfs64
= 88;
1577 record_tdep
->size_sockaddr
= 16;
1578 record_tdep
->size_int
= 4;
1579 record_tdep
->size_long
= 4;
1580 record_tdep
->size_ulong
= 4;
1581 record_tdep
->size_msghdr
= 28;
1582 record_tdep
->size_itimerval
= 16;
1583 record_tdep
->size_stat
= 88;
1584 record_tdep
->size_old_utsname
= 325;
1585 record_tdep
->size_sysinfo
= 64;
1586 record_tdep
->size_msqid_ds
= 68;
1587 record_tdep
->size_shmid_ds
= 60;
1588 record_tdep
->size_new_utsname
= 390;
1589 record_tdep
->size_timex
= 128;
1590 record_tdep
->size_mem_dqinfo
= 24;
1591 record_tdep
->size_if_dqblk
= 72;
1592 record_tdep
->size_fs_quota_stat
= 80;
1593 record_tdep
->size_timespec
= 8;
1594 record_tdep
->size_pollfd
= 8;
1595 record_tdep
->size_NFS_FHSIZE
= 32;
1596 record_tdep
->size_knfsd_fh
= 132;
1597 record_tdep
->size_TASK_COMM_LEN
= 16;
1598 record_tdep
->size_sigaction
= 20;
1599 record_tdep
->size_sigset_t
= 8;
1600 record_tdep
->size_siginfo_t
= 128;
1601 record_tdep
->size_cap_user_data_t
= 4;
1602 record_tdep
->size_stack_t
= 12;
1603 record_tdep
->size_off_t
= 4;
1604 record_tdep
->size_stat64
= 104;
1605 record_tdep
->size_gid_t
= 4;
1606 record_tdep
->size_uid_t
= 4;
1607 record_tdep
->size_PAGE_SIZE
= 0x10000; /* 64KB */
1608 record_tdep
->size_flock64
= 32;
1609 record_tdep
->size_io_event
= 32;
1610 record_tdep
->size_iocb
= 64;
1611 record_tdep
->size_epoll_event
= 16;
1612 record_tdep
->size_itimerspec
= 16;
1613 record_tdep
->size_mq_attr
= 32;
1614 record_tdep
->size_termios
= 44;
1615 record_tdep
->size_pid_t
= 4;
1616 record_tdep
->size_winsize
= 8;
1617 record_tdep
->size_serial_struct
= 60;
1618 record_tdep
->size_serial_icounter_struct
= 80;
1619 record_tdep
->size_size_t
= 4;
1620 record_tdep
->size_iovec
= 8;
1621 record_tdep
->size_time_t
= 4;
1624 internal_error (__FILE__
, __LINE__
, _("unexpected wordsize"));
1626 /* These values are the second argument of system call "sys_fcntl"
1627 and "sys_fcntl64". They are obtained from Linux Kernel source. */
1628 record_tdep
->fcntl_F_GETLK
= 5;
1629 record_tdep
->fcntl_F_GETLK64
= 12;
1630 record_tdep
->fcntl_F_SETLK64
= 13;
1631 record_tdep
->fcntl_F_SETLKW64
= 14;
1633 record_tdep
->arg1
= PPC_R0_REGNUM
+ 3;
1634 record_tdep
->arg2
= PPC_R0_REGNUM
+ 4;
1635 record_tdep
->arg3
= PPC_R0_REGNUM
+ 5;
1636 record_tdep
->arg4
= PPC_R0_REGNUM
+ 6;
1637 record_tdep
->arg5
= PPC_R0_REGNUM
+ 7;
1638 record_tdep
->arg6
= PPC_R0_REGNUM
+ 8;
1640 /* These values are the second argument of system call "sys_ioctl".
1641 They are obtained from Linux Kernel source.
1642 See arch/powerpc/include/uapi/asm/ioctls.h. */
1643 record_tdep
->ioctl_TCGETS
= 0x403c7413;
1644 record_tdep
->ioctl_TCSETS
= 0x803c7414;
1645 record_tdep
->ioctl_TCSETSW
= 0x803c7415;
1646 record_tdep
->ioctl_TCSETSF
= 0x803c7416;
1647 record_tdep
->ioctl_TCGETA
= 0x40147417;
1648 record_tdep
->ioctl_TCSETA
= 0x80147418;
1649 record_tdep
->ioctl_TCSETAW
= 0x80147419;
1650 record_tdep
->ioctl_TCSETAF
= 0x8014741c;
1651 record_tdep
->ioctl_TCSBRK
= 0x2000741d;
1652 record_tdep
->ioctl_TCXONC
= 0x2000741e;
1653 record_tdep
->ioctl_TCFLSH
= 0x2000741f;
1654 record_tdep
->ioctl_TIOCEXCL
= 0x540c;
1655 record_tdep
->ioctl_TIOCNXCL
= 0x540d;
1656 record_tdep
->ioctl_TIOCSCTTY
= 0x540e;
1657 record_tdep
->ioctl_TIOCGPGRP
= 0x40047477;
1658 record_tdep
->ioctl_TIOCSPGRP
= 0x80047476;
1659 record_tdep
->ioctl_TIOCOUTQ
= 0x40047473;
1660 record_tdep
->ioctl_TIOCSTI
= 0x5412;
1661 record_tdep
->ioctl_TIOCGWINSZ
= 0x40087468;
1662 record_tdep
->ioctl_TIOCSWINSZ
= 0x80087467;
1663 record_tdep
->ioctl_TIOCMGET
= 0x5415;
1664 record_tdep
->ioctl_TIOCMBIS
= 0x5416;
1665 record_tdep
->ioctl_TIOCMBIC
= 0x5417;
1666 record_tdep
->ioctl_TIOCMSET
= 0x5418;
1667 record_tdep
->ioctl_TIOCGSOFTCAR
= 0x5419;
1668 record_tdep
->ioctl_TIOCSSOFTCAR
= 0x541a;
1669 record_tdep
->ioctl_FIONREAD
= 0x4004667f;
1670 record_tdep
->ioctl_TIOCINQ
= 0x4004667f;
1671 record_tdep
->ioctl_TIOCLINUX
= 0x541c;
1672 record_tdep
->ioctl_TIOCCONS
= 0x541d;
1673 record_tdep
->ioctl_TIOCGSERIAL
= 0x541e;
1674 record_tdep
->ioctl_TIOCSSERIAL
= 0x541f;
1675 record_tdep
->ioctl_TIOCPKT
= 0x5420;
1676 record_tdep
->ioctl_FIONBIO
= 0x8004667e;
1677 record_tdep
->ioctl_TIOCNOTTY
= 0x5422;
1678 record_tdep
->ioctl_TIOCSETD
= 0x5423;
1679 record_tdep
->ioctl_TIOCGETD
= 0x5424;
1680 record_tdep
->ioctl_TCSBRKP
= 0x5425;
1681 record_tdep
->ioctl_TIOCSBRK
= 0x5427;
1682 record_tdep
->ioctl_TIOCCBRK
= 0x5428;
1683 record_tdep
->ioctl_TIOCGSID
= 0x5429;
1684 record_tdep
->ioctl_TIOCGPTN
= 0x40045430;
1685 record_tdep
->ioctl_TIOCSPTLCK
= 0x80045431;
1686 record_tdep
->ioctl_FIONCLEX
= 0x20006602;
1687 record_tdep
->ioctl_FIOCLEX
= 0x20006601;
1688 record_tdep
->ioctl_FIOASYNC
= 0x8004667d;
1689 record_tdep
->ioctl_TIOCSERCONFIG
= 0x5453;
1690 record_tdep
->ioctl_TIOCSERGWILD
= 0x5454;
1691 record_tdep
->ioctl_TIOCSERSWILD
= 0x5455;
1692 record_tdep
->ioctl_TIOCGLCKTRMIOS
= 0x5456;
1693 record_tdep
->ioctl_TIOCSLCKTRMIOS
= 0x5457;
1694 record_tdep
->ioctl_TIOCSERGSTRUCT
= 0x5458;
1695 record_tdep
->ioctl_TIOCSERGETLSR
= 0x5459;
1696 record_tdep
->ioctl_TIOCSERGETMULTI
= 0x545a;
1697 record_tdep
->ioctl_TIOCSERSETMULTI
= 0x545b;
1698 record_tdep
->ioctl_TIOCMIWAIT
= 0x545c;
1699 record_tdep
->ioctl_TIOCGICOUNT
= 0x545d;
1700 record_tdep
->ioctl_FIOQSIZE
= 0x40086680;
1703 /* Return a floating-point format for a floating-point variable of
1704 length LEN in bits. If non-NULL, NAME is the name of its type.
1705 If no suitable type is found, return NULL. */
1707 const struct floatformat
**
1708 ppc_floatformat_for_type (struct gdbarch
*gdbarch
,
1709 const char *name
, int len
)
1711 if (len
== 128 && name
)
1713 if (strcmp (name
, "__float128") == 0
1714 || strcmp (name
, "_Float128") == 0
1715 || strcmp (name
, "_Float64x") == 0
1716 || strcmp (name
, "complex _Float128") == 0
1717 || strcmp (name
, "complex _Float64x") == 0)
1718 return floatformats_ia64_quad
;
1720 if (strcmp (name
, "__ibm128") == 0)
1721 return floatformats_ibm_long_double
;
1724 return default_floatformat_for_type (gdbarch
, name
, len
);
1728 ppc_linux_init_abi (struct gdbarch_info info
,
1729 struct gdbarch
*gdbarch
)
1731 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1732 struct tdesc_arch_data
*tdesc_data
= info
.tdesc_data
;
1733 static const char *const stap_integer_prefixes
[] = { "i", NULL
};
1734 static const char *const stap_register_indirection_prefixes
[] = { "(",
1736 static const char *const stap_register_indirection_suffixes
[] = { ")",
1739 linux_init_abi (info
, gdbarch
);
1741 /* PPC GNU/Linux uses either 64-bit or 128-bit long doubles; where
1742 128-bit, they can be either IBM long double or IEEE quad long double.
1743 The 64-bit long double case will be detected automatically using
1744 the size specified in debug info. We use a .gnu.attribute flag
1745 to distinguish between the IBM long double and IEEE quad cases. */
1746 set_gdbarch_long_double_bit (gdbarch
, 16 * TARGET_CHAR_BIT
);
1747 if (tdep
->long_double_abi
== POWERPC_LONG_DOUBLE_IEEE128
)
1748 set_gdbarch_long_double_format (gdbarch
, floatformats_ia64_quad
);
1750 set_gdbarch_long_double_format (gdbarch
, floatformats_ibm_long_double
);
1752 /* Support for floating-point data type variants. */
1753 set_gdbarch_floatformat_for_type (gdbarch
, ppc_floatformat_for_type
);
1755 /* Handle inferior calls during interrupted system calls. */
1756 set_gdbarch_write_pc (gdbarch
, ppc_linux_write_pc
);
1758 /* Get the syscall number from the arch's register. */
1759 set_gdbarch_get_syscall_number (gdbarch
, ppc_linux_get_syscall_number
);
1761 /* SystemTap functions. */
1762 set_gdbarch_stap_integer_prefixes (gdbarch
, stap_integer_prefixes
);
1763 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
1764 stap_register_indirection_prefixes
);
1765 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
1766 stap_register_indirection_suffixes
);
1767 set_gdbarch_stap_gdb_register_prefix (gdbarch
, "r");
1768 set_gdbarch_stap_is_single_operand (gdbarch
, ppc_stap_is_single_operand
);
1769 set_gdbarch_stap_parse_special_token (gdbarch
,
1770 ppc_stap_parse_special_token
);
1772 if (tdep
->wordsize
== 4)
1774 /* Until November 2001, gcc did not comply with the 32 bit SysV
1775 R4 ABI requirement that structures less than or equal to 8
1776 bytes should be returned in registers. Instead GCC was using
1777 the AIX/PowerOpen ABI - everything returned in memory
1778 (well ignoring vectors that is). When this was corrected, it
1779 wasn't fixed for GNU/Linux native platform. Use the
1780 PowerOpen struct convention. */
1781 set_gdbarch_return_value (gdbarch
, ppc_linux_return_value
);
1783 set_gdbarch_memory_remove_breakpoint (gdbarch
,
1784 ppc_linux_memory_remove_breakpoint
);
1786 /* Shared library handling. */
1787 set_gdbarch_skip_trampoline_code (gdbarch
, ppc_skip_trampoline_code
);
1788 set_solib_svr4_fetch_link_map_offsets
1789 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1791 /* Setting the correct XML syscall filename. */
1792 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_PPC
);
1795 tramp_frame_prepend_unwinder (gdbarch
,
1796 &ppc32_linux_sigaction_tramp_frame
);
1797 tramp_frame_prepend_unwinder (gdbarch
,
1798 &ppc32_linux_sighandler_tramp_frame
);
1800 /* BFD target for core files. */
1801 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
1802 set_gdbarch_gcore_bfd_target (gdbarch
, "elf32-powerpcle");
1804 set_gdbarch_gcore_bfd_target (gdbarch
, "elf32-powerpc");
1806 if (powerpc_so_ops
.in_dynsym_resolve_code
== NULL
)
1808 powerpc_so_ops
= svr4_so_ops
;
1809 /* Override dynamic resolve function. */
1810 powerpc_so_ops
.in_dynsym_resolve_code
=
1811 powerpc_linux_in_dynsym_resolve_code
;
1813 set_solib_ops (gdbarch
, &powerpc_so_ops
);
1815 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
1818 if (tdep
->wordsize
== 8)
1820 if (tdep
->elf_abi
== POWERPC_ELF_V1
)
1822 /* Handle PPC GNU/Linux 64-bit function pointers (which are really
1823 function descriptors). */
1824 set_gdbarch_convert_from_func_ptr_addr
1825 (gdbarch
, ppc64_convert_from_func_ptr_addr
);
1827 set_gdbarch_elf_make_msymbol_special
1828 (gdbarch
, ppc64_elf_make_msymbol_special
);
1832 set_gdbarch_elf_make_msymbol_special
1833 (gdbarch
, ppc_elfv2_elf_make_msymbol_special
);
1835 set_gdbarch_skip_entrypoint (gdbarch
, ppc_elfv2_skip_entrypoint
);
1838 /* Shared library handling. */
1839 set_gdbarch_skip_trampoline_code (gdbarch
, ppc64_skip_trampoline_code
);
1840 set_solib_svr4_fetch_link_map_offsets
1841 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
1843 /* Setting the correct XML syscall filename. */
1844 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_PPC64
);
1847 tramp_frame_prepend_unwinder (gdbarch
,
1848 &ppc64_linux_sigaction_tramp_frame
);
1849 tramp_frame_prepend_unwinder (gdbarch
,
1850 &ppc64_linux_sighandler_tramp_frame
);
1852 /* BFD target for core files. */
1853 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
1854 set_gdbarch_gcore_bfd_target (gdbarch
, "elf64-powerpcle");
1856 set_gdbarch_gcore_bfd_target (gdbarch
, "elf64-powerpc");
1859 set_gdbarch_core_read_description (gdbarch
, ppc_linux_core_read_description
);
1860 set_gdbarch_iterate_over_regset_sections (gdbarch
,
1861 ppc_linux_iterate_over_regset_sections
);
1863 /* Enable TLS support. */
1864 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
1865 svr4_fetch_objfile_link_map
);
1869 const struct tdesc_feature
*feature
;
1871 /* If we have target-described registers, then we can safely
1872 reserve a number for PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM
1873 (whether they are described or not). */
1874 gdb_assert (gdbarch_num_regs (gdbarch
) <= PPC_ORIG_R3_REGNUM
);
1875 set_gdbarch_num_regs (gdbarch
, PPC_TRAP_REGNUM
+ 1);
1877 /* If they are present, then assign them to the reserved number. */
1878 feature
= tdesc_find_feature (info
.target_desc
,
1879 "org.gnu.gdb.power.linux");
1880 if (feature
!= NULL
)
1882 tdesc_numbered_register (feature
, tdesc_data
,
1883 PPC_ORIG_R3_REGNUM
, "orig_r3");
1884 tdesc_numbered_register (feature
, tdesc_data
,
1885 PPC_TRAP_REGNUM
, "trap");
1889 /* Enable Cell/B.E. if supported by the target. */
1890 if (tdesc_compatible_p (info
.target_desc
,
1891 bfd_lookup_arch (bfd_arch_spu
, bfd_mach_spu
)))
1893 /* Cell/B.E. multi-architecture support. */
1894 set_spu_solib_ops (gdbarch
);
1896 /* Cell/B.E. cross-architecture unwinder support. */
1897 frame_unwind_prepend_unwinder (gdbarch
, &ppu2spu_unwind
);
1899 /* We need to support more than "addr_bit" significant address bits
1900 in order to support SPUADDR_ADDR encoded values. */
1901 set_gdbarch_significant_addr_bit (gdbarch
, 64);
1904 set_gdbarch_displaced_step_location (gdbarch
,
1905 linux_displaced_step_location
);
1907 /* Support reverse debugging. */
1908 set_gdbarch_process_record (gdbarch
, ppc_process_record
);
1909 set_gdbarch_process_record_signal (gdbarch
, ppc_linux_record_signal
);
1910 tdep
->ppc_syscall_record
= ppc_linux_syscall_record
;
1912 ppc_init_linux_record_tdep (&ppc_linux_record_tdep
, 4);
1913 ppc_init_linux_record_tdep (&ppc64_linux_record_tdep
, 8);
1917 _initialize_ppc_linux_tdep (void)
1919 /* Register for all sub-familes of the POWER/PowerPC: 32-bit and
1920 64-bit PowerPC, and the older rs6k. */
1921 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc
, GDB_OSABI_LINUX
,
1922 ppc_linux_init_abi
);
1923 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc64
, GDB_OSABI_LINUX
,
1924 ppc_linux_init_abi
);
1925 gdbarch_register_osabi (bfd_arch_rs6000
, bfd_mach_rs6k
, GDB_OSABI_LINUX
,
1926 ppc_linux_init_abi
);
1928 /* Attach to observers to track __spe_current_active_context. */
1929 gdb::observers::inferior_created
.attach (ppc_linux_spe_context_inferior_created
);
1930 gdb::observers::solib_loaded
.attach (ppc_linux_spe_context_solib_loaded
);
1931 gdb::observers::solib_unloaded
.attach (ppc_linux_spe_context_solib_unloaded
);
1933 /* Initialize the Linux target descriptions. */
1934 initialize_tdesc_powerpc_32l ();
1935 initialize_tdesc_powerpc_altivec32l ();
1936 initialize_tdesc_powerpc_cell32l ();
1937 initialize_tdesc_powerpc_vsx32l ();
1938 initialize_tdesc_powerpc_isa205_32l ();
1939 initialize_tdesc_powerpc_isa205_altivec32l ();
1940 initialize_tdesc_powerpc_isa205_vsx32l ();
1941 initialize_tdesc_powerpc_64l ();
1942 initialize_tdesc_powerpc_altivec64l ();
1943 initialize_tdesc_powerpc_cell64l ();
1944 initialize_tdesc_powerpc_vsx64l ();
1945 initialize_tdesc_powerpc_isa205_64l ();
1946 initialize_tdesc_powerpc_isa205_altivec64l ();
1947 initialize_tdesc_powerpc_isa205_vsx64l ();
1948 initialize_tdesc_powerpc_e500l ();