1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 1986-2023 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"
37 #include "ppc64-tdep.h"
38 #include "ppc-linux-tdep.h"
39 #include "arch/ppc-linux-common.h"
40 #include "arch/ppc-linux-tdesc.h"
41 #include "glibc-tdep.h"
42 #include "trad-frame.h"
43 #include "frame-unwind.h"
44 #include "tramp-frame.h"
45 #include "observable.h"
47 #include "elf/common.h"
48 #include "elf/ppc64.h"
49 #include "arch-utils.h"
50 #include "xml-syscall.h"
51 #include "linux-tdep.h"
52 #include "linux-record.h"
53 #include "record-full.h"
57 #include "stap-probe.h"
60 #include "cli/cli-utils.h"
61 #include "parser-defs.h"
62 #include "user-regs.h"
67 #include "features/rs6000/powerpc-32l.c"
68 #include "features/rs6000/powerpc-altivec32l.c"
69 #include "features/rs6000/powerpc-vsx32l.c"
70 #include "features/rs6000/powerpc-isa205-32l.c"
71 #include "features/rs6000/powerpc-isa205-altivec32l.c"
72 #include "features/rs6000/powerpc-isa205-vsx32l.c"
73 #include "features/rs6000/powerpc-isa205-ppr-dscr-vsx32l.c"
74 #include "features/rs6000/powerpc-isa207-vsx32l.c"
75 #include "features/rs6000/powerpc-isa207-htm-vsx32l.c"
76 #include "features/rs6000/powerpc-64l.c"
77 #include "features/rs6000/powerpc-altivec64l.c"
78 #include "features/rs6000/powerpc-vsx64l.c"
79 #include "features/rs6000/powerpc-isa205-64l.c"
80 #include "features/rs6000/powerpc-isa205-altivec64l.c"
81 #include "features/rs6000/powerpc-isa205-vsx64l.c"
82 #include "features/rs6000/powerpc-isa205-ppr-dscr-vsx64l.c"
83 #include "features/rs6000/powerpc-isa207-vsx64l.c"
84 #include "features/rs6000/powerpc-isa207-htm-vsx64l.c"
85 #include "features/rs6000/powerpc-e500l.c"
87 /* Shared library operations for PowerPC-Linux. */
88 static struct target_so_ops powerpc_so_ops
;
90 /* The syscall's XML filename for PPC and PPC64. */
91 #define XML_SYSCALL_FILENAME_PPC "syscalls/ppc-linux.xml"
92 #define XML_SYSCALL_FILENAME_PPC64 "syscalls/ppc64-linux.xml"
94 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
95 in much the same fashion as memory_remove_breakpoint in mem-break.c,
96 but is careful not to write back the previous contents if the code
97 in question has changed in between inserting the breakpoint and
100 Here is the problem that we're trying to solve...
102 Once upon a time, before introducing this function to remove
103 breakpoints from the inferior, setting a breakpoint on a shared
104 library function prior to running the program would not work
105 properly. In order to understand the problem, it is first
106 necessary to understand a little bit about dynamic linking on
109 A call to a shared library function is accomplished via a bl
110 (branch-and-link) instruction whose branch target is an entry
111 in the procedure linkage table (PLT). The PLT in the object
112 file is uninitialized. To gdb, prior to running the program, the
113 entries in the PLT are all zeros.
115 Once the program starts running, the shared libraries are loaded
116 and the procedure linkage table is initialized, but the entries in
117 the table are not (necessarily) resolved. Once a function is
118 actually called, the code in the PLT is hit and the function is
119 resolved. In order to better illustrate this, an example is in
120 order; the following example is from the gdb testsuite.
122 We start the program shmain.
124 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
127 We place two breakpoints, one on shr1 and the other on main.
130 Breakpoint 1 at 0x100409d4
132 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
134 Examine the instruction (and the immediatly following instruction)
135 upon which the breakpoint was placed. Note that the PLT entry
136 for shr1 contains zeros.
138 (gdb) x/2i 0x100409d4
139 0x100409d4 <shr1>: .long 0x0
140 0x100409d8 <shr1+4>: .long 0x0
145 Starting program: gdb.base/shmain
146 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
148 Breakpoint 2, main ()
149 at gdb.base/shmain.c:44
152 Examine the PLT again. Note that the loading of the shared
153 library has initialized the PLT to code which loads a constant
154 (which I think is an index into the GOT) into r11 and then
155 branches a short distance to the code which actually does the
158 (gdb) x/2i 0x100409d4
159 0x100409d4 <shr1>: li r11,4
160 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
164 Breakpoint 1, shr1 (x=1)
165 at gdb.base/shr1.c:19
168 Now we've hit the breakpoint at shr1. (The breakpoint was
169 reset from the PLT entry to the actual shr1 function after the
170 shared library was loaded.) Note that the PLT entry has been
171 resolved to contain a branch that takes us directly to shr1.
172 (The real one, not the PLT entry.)
174 (gdb) x/2i 0x100409d4
175 0x100409d4 <shr1>: b 0xffaf76c <shr1>
176 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
178 The thing to note here is that the PLT entry for shr1 has been
181 Now the problem should be obvious. GDB places a breakpoint (a
182 trap instruction) on the zero value of the PLT entry for shr1.
183 Later on, after the shared library had been loaded and the PLT
184 initialized, GDB gets a signal indicating this fact and attempts
185 (as it always does when it stops) to remove all the breakpoints.
187 The breakpoint removal was causing the former contents (a zero
188 word) to be written back to the now initialized PLT entry thus
189 destroying a portion of the initialization that had occurred only a
190 short time ago. When execution continued, the zero word would be
191 executed as an instruction an illegal instruction trap was
192 generated instead. (0 is not a legal instruction.)
194 The fix for this problem was fairly straightforward. The function
195 memory_remove_breakpoint from mem-break.c was copied to this file,
196 modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
197 In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
200 The differences between ppc_linux_memory_remove_breakpoint () and
201 memory_remove_breakpoint () are minor. All that the former does
202 that the latter does not is check to make sure that the breakpoint
203 location actually contains a breakpoint (trap instruction) prior
204 to attempting to write back the old contents. If it does contain
205 a trap instruction, we allow the old contents to be written back.
206 Otherwise, we silently do nothing.
208 The big question is whether memory_remove_breakpoint () should be
209 changed to have the same functionality. The downside is that more
210 traffic is generated for remote targets since we'll have an extra
211 fetch of a memory word each time a breakpoint is removed.
213 For the time being, we'll leave this self-modifying-code-friendly
214 version in ppc-linux-tdep.c, but it ought to be migrated somewhere
215 else in the event that some other platform has similar needs with
216 regard to removing breakpoints in some potentially self modifying
219 ppc_linux_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
220 struct bp_target_info
*bp_tgt
)
222 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
223 const unsigned char *bp
;
226 gdb_byte old_contents
[BREAKPOINT_MAX
];
228 /* Determine appropriate breakpoint contents and size for this address. */
229 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bplen
);
231 /* Make sure we see the memory breakpoints. */
232 scoped_restore restore_memory
233 = make_scoped_restore_show_memory_breakpoints (1);
234 val
= target_read_memory (addr
, old_contents
, bplen
);
236 /* If our breakpoint is no longer at the address, this means that the
237 program modified the code on us, so it is wrong to put back the
239 if (val
== 0 && memcmp (bp
, old_contents
, bplen
) == 0)
240 val
= target_write_raw_memory (addr
, bp_tgt
->shadow_contents
, bplen
);
245 /* For historic reasons, PPC 32 GNU/Linux follows PowerOpen rather
246 than the 32 bit SYSV R4 ABI structure return convention - all
247 structures, no matter their size, are put in memory. Vectors,
248 which were added later, do get returned in a register though. */
250 static enum return_value_convention
251 ppc_linux_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
252 struct type
*valtype
, struct regcache
*regcache
,
253 struct value
**read_value
, const gdb_byte
*writebuf
)
255 gdb_byte
*readbuf
= nullptr;
256 if (read_value
!= nullptr)
258 *read_value
= value::allocate (valtype
);
259 readbuf
= (*read_value
)->contents_raw ().data ();
262 if ((valtype
->code () == TYPE_CODE_STRUCT
263 || valtype
->code () == TYPE_CODE_UNION
)
264 && !((valtype
->length () == 16 || valtype
->length () == 8)
265 && valtype
->is_vector ()))
266 return RETURN_VALUE_STRUCT_CONVENTION
;
268 return ppc_sysv_abi_return_value (gdbarch
, function
, valtype
, regcache
,
272 /* PLT stub in an executable. */
273 static const struct ppc_insn_pattern powerpc32_plt_stub
[] =
275 { 0xffff0000, 0x3d600000, 0 }, /* lis r11, xxxx */
276 { 0xffff0000, 0x816b0000, 0 }, /* lwz r11, xxxx(r11) */
277 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
278 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
282 /* PLT stubs in a shared library or PIE.
283 The first variant is used when the PLT entry is within +/-32k of
284 the GOT pointer (r30). */
285 static const struct ppc_insn_pattern powerpc32_plt_stub_so_1
[] =
287 { 0xffff0000, 0x817e0000, 0 }, /* lwz r11, xxxx(r30) */
288 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
289 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
293 /* The second variant is used when the PLT entry is more than +/-32k
294 from the GOT pointer (r30). */
295 static const struct ppc_insn_pattern powerpc32_plt_stub_so_2
[] =
297 { 0xffff0000, 0x3d7e0000, 0 }, /* addis r11, r30, xxxx */
298 { 0xffff0000, 0x816b0000, 0 }, /* lwz r11, xxxx(r11) */
299 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
300 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
304 /* The max number of insns we check using ppc_insns_match_pattern. */
305 #define POWERPC32_PLT_CHECK_LEN (ARRAY_SIZE (powerpc32_plt_stub) - 1)
307 /* Check if PC is in PLT stub. For non-secure PLT, stub is in .plt
308 section. For secure PLT, stub is in .text and we need to check
309 instruction patterns. */
312 powerpc_linux_in_dynsym_resolve_code (CORE_ADDR pc
)
314 struct bound_minimal_symbol sym
;
316 /* Check whether PC is in the dynamic linker. This also checks
317 whether it is in the .plt section, used by non-PIC executables. */
318 if (svr4_in_dynsym_resolve_code (pc
))
321 /* Check if we are in the resolver. */
322 sym
= lookup_minimal_symbol_by_pc (pc
);
323 if (sym
.minsym
!= NULL
324 && (strcmp (sym
.minsym
->linkage_name (), "__glink") == 0
325 || strcmp (sym
.minsym
->linkage_name (), "__glink_PLTresolve") == 0))
331 /* Follow PLT stub to actual routine.
333 When the execution direction is EXEC_REVERSE, scan backward to
334 check whether we are in the middle of a PLT stub. Currently,
335 we only look-behind at most 4 instructions (the max length of a PLT
339 ppc_skip_trampoline_code (frame_info_ptr frame
, CORE_ADDR pc
)
341 unsigned int insnbuf
[POWERPC32_PLT_CHECK_LEN
];
342 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
343 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
344 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
345 CORE_ADDR target
= 0;
349 /* When reverse-debugging, scan backward to check whether we are
350 in the middle of trampoline code. */
351 if (execution_direction
== EXEC_REVERSE
)
352 scan_limit
= 4; /* At most 4 instructions. */
354 for (i
= 0; i
< scan_limit
; i
++)
356 if (ppc_insns_match_pattern (frame
, pc
, powerpc32_plt_stub
, insnbuf
))
358 /* Calculate PLT entry address from
360 lwz r11, xxxx(r11). */
361 target
= ((ppc_insn_d_field (insnbuf
[0]) << 16)
362 + ppc_insn_d_field (insnbuf
[1]));
364 else if (i
< ARRAY_SIZE (powerpc32_plt_stub_so_1
) - 1
365 && ppc_insns_match_pattern (frame
, pc
, powerpc32_plt_stub_so_1
,
368 /* Calculate PLT entry address from
369 lwz r11, xxxx(r30). */
370 target
= (ppc_insn_d_field (insnbuf
[0])
371 + get_frame_register_unsigned (frame
,
372 tdep
->ppc_gp0_regnum
+ 30));
374 else if (ppc_insns_match_pattern (frame
, pc
, powerpc32_plt_stub_so_2
,
377 /* Calculate PLT entry address from
379 lwz r11, xxxx(r11). */
380 target
= ((ppc_insn_d_field (insnbuf
[0]) << 16)
381 + ppc_insn_d_field (insnbuf
[1])
382 + get_frame_register_unsigned (frame
,
383 tdep
->ppc_gp0_regnum
+ 30));
387 /* Scan backward one more instruction if it doesn't match. */
392 target
= read_memory_unsigned_integer (target
, 4, byte_order
);
399 /* Wrappers to handle Linux-only registers. */
402 ppc_linux_supply_gregset (const struct regset
*regset
,
403 struct regcache
*regcache
,
404 int regnum
, const void *gregs
, size_t len
)
406 const struct ppc_reg_offsets
*offsets
407 = (const struct ppc_reg_offsets
*) regset
->regmap
;
409 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
411 if (ppc_linux_trap_reg_p (regcache
->arch ()))
413 /* "orig_r3" is stored 2 slots after "pc". */
414 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
415 ppc_supply_reg (regcache
, PPC_ORIG_R3_REGNUM
, (const gdb_byte
*) gregs
,
416 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
419 /* "trap" is stored 8 slots after "pc". */
420 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
421 ppc_supply_reg (regcache
, PPC_TRAP_REGNUM
, (const gdb_byte
*) gregs
,
422 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
428 ppc_linux_collect_gregset (const struct regset
*regset
,
429 const struct regcache
*regcache
,
430 int regnum
, void *gregs
, size_t len
)
432 const struct ppc_reg_offsets
*offsets
433 = (const struct ppc_reg_offsets
*) regset
->regmap
;
435 /* Clear areas in the linux gregset not written elsewhere. */
437 memset (gregs
, 0, len
);
439 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
441 if (ppc_linux_trap_reg_p (regcache
->arch ()))
443 /* "orig_r3" is stored 2 slots after "pc". */
444 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
445 ppc_collect_reg (regcache
, PPC_ORIG_R3_REGNUM
, (gdb_byte
*) gregs
,
446 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
449 /* "trap" is stored 8 slots after "pc". */
450 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
451 ppc_collect_reg (regcache
, PPC_TRAP_REGNUM
, (gdb_byte
*) gregs
,
452 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
457 /* Regset descriptions. */
458 static const struct ppc_reg_offsets ppc32_linux_reg_offsets
=
460 /* General-purpose registers. */
461 /* .r0_offset = */ 0,
464 /* .pc_offset = */ 128,
465 /* .ps_offset = */ 132,
466 /* .cr_offset = */ 152,
467 /* .lr_offset = */ 144,
468 /* .ctr_offset = */ 140,
469 /* .xer_offset = */ 148,
470 /* .mq_offset = */ 156,
472 /* Floating-point registers. */
473 /* .f0_offset = */ 0,
474 /* .fpscr_offset = */ 256,
475 /* .fpscr_size = */ 8
478 static const struct ppc_reg_offsets ppc64_linux_reg_offsets
=
480 /* General-purpose registers. */
481 /* .r0_offset = */ 0,
484 /* .pc_offset = */ 256,
485 /* .ps_offset = */ 264,
486 /* .cr_offset = */ 304,
487 /* .lr_offset = */ 288,
488 /* .ctr_offset = */ 280,
489 /* .xer_offset = */ 296,
490 /* .mq_offset = */ 312,
492 /* Floating-point registers. */
493 /* .f0_offset = */ 0,
494 /* .fpscr_offset = */ 256,
495 /* .fpscr_size = */ 8
498 static const struct regset ppc32_linux_gregset
= {
499 &ppc32_linux_reg_offsets
,
500 ppc_linux_supply_gregset
,
501 ppc_linux_collect_gregset
504 static const struct regset ppc64_linux_gregset
= {
505 &ppc64_linux_reg_offsets
,
506 ppc_linux_supply_gregset
,
507 ppc_linux_collect_gregset
510 static const struct regset ppc32_linux_fpregset
= {
511 &ppc32_linux_reg_offsets
,
516 static const struct regcache_map_entry ppc32_le_linux_vrregmap
[] =
518 { 32, PPC_VR0_REGNUM
, 16 },
519 { 1, PPC_VSCR_REGNUM
, 4 },
520 { 1, REGCACHE_MAP_SKIP
, 12 },
521 { 1, PPC_VRSAVE_REGNUM
, 4 },
522 { 1, REGCACHE_MAP_SKIP
, 12 },
526 static const struct regcache_map_entry ppc32_be_linux_vrregmap
[] =
528 { 32, PPC_VR0_REGNUM
, 16 },
529 { 1, REGCACHE_MAP_SKIP
, 12},
530 { 1, PPC_VSCR_REGNUM
, 4 },
531 { 1, PPC_VRSAVE_REGNUM
, 4 },
532 { 1, REGCACHE_MAP_SKIP
, 12 },
536 static const struct regset ppc32_le_linux_vrregset
= {
537 ppc32_le_linux_vrregmap
,
538 regcache_supply_regset
,
539 regcache_collect_regset
542 static const struct regset ppc32_be_linux_vrregset
= {
543 ppc32_be_linux_vrregmap
,
544 regcache_supply_regset
,
545 regcache_collect_regset
548 static const struct regcache_map_entry ppc32_linux_vsxregmap
[] =
550 { 32, PPC_VSR0_UPPER_REGNUM
, 8 },
554 static const struct regset ppc32_linux_vsxregset
= {
555 ppc32_linux_vsxregmap
,
556 regcache_supply_regset
,
557 regcache_collect_regset
560 /* Program Priorty Register regmap. */
562 static const struct regcache_map_entry ppc32_regmap_ppr
[] =
564 { 1, PPC_PPR_REGNUM
, 8 },
568 /* Program Priorty Register regset. */
570 const struct regset ppc32_linux_pprregset
= {
572 regcache_supply_regset
,
573 regcache_collect_regset
576 /* Data Stream Control Register regmap. */
578 static const struct regcache_map_entry ppc32_regmap_dscr
[] =
580 { 1, PPC_DSCR_REGNUM
, 8 },
584 /* Data Stream Control Register regset. */
586 const struct regset ppc32_linux_dscrregset
= {
588 regcache_supply_regset
,
589 regcache_collect_regset
592 /* Target Address Register regmap. */
594 static const struct regcache_map_entry ppc32_regmap_tar
[] =
596 { 1, PPC_TAR_REGNUM
, 8 },
600 /* Target Address Register regset. */
602 const struct regset ppc32_linux_tarregset
= {
604 regcache_supply_regset
,
605 regcache_collect_regset
608 /* Event-Based Branching regmap. */
610 static const struct regcache_map_entry ppc32_regmap_ebb
[] =
612 { 1, PPC_EBBRR_REGNUM
, 8 },
613 { 1, PPC_EBBHR_REGNUM
, 8 },
614 { 1, PPC_BESCR_REGNUM
, 8 },
618 /* Event-Based Branching regset. */
620 const struct regset ppc32_linux_ebbregset
= {
622 regcache_supply_regset
,
623 regcache_collect_regset
626 /* Performance Monitoring Unit regmap. */
628 static const struct regcache_map_entry ppc32_regmap_pmu
[] =
630 { 1, PPC_SIAR_REGNUM
, 8 },
631 { 1, PPC_SDAR_REGNUM
, 8 },
632 { 1, PPC_SIER_REGNUM
, 8 },
633 { 1, PPC_MMCR2_REGNUM
, 8 },
634 { 1, PPC_MMCR0_REGNUM
, 8 },
638 /* Performance Monitoring Unit regset. */
640 const struct regset ppc32_linux_pmuregset
= {
642 regcache_supply_regset
,
643 regcache_collect_regset
646 /* Hardware Transactional Memory special-purpose register regmap. */
648 static const struct regcache_map_entry ppc32_regmap_tm_spr
[] =
650 { 1, PPC_TFHAR_REGNUM
, 8 },
651 { 1, PPC_TEXASR_REGNUM
, 8 },
652 { 1, PPC_TFIAR_REGNUM
, 8 },
656 /* Hardware Transactional Memory special-purpose register regset. */
658 const struct regset ppc32_linux_tm_sprregset
= {
660 regcache_supply_regset
,
661 regcache_collect_regset
664 /* Regmaps for the Hardware Transactional Memory checkpointed
665 general-purpose regsets for 32-bit, 64-bit big-endian, and 64-bit
666 little endian targets. The ptrace and core file buffers for 64-bit
667 targets use 8-byte fields for the 4-byte registers, and the
668 position of the register in the fields depends on the endianness.
669 The 32-bit regmap is the same for both endian types because the
670 fields are all 4-byte long.
672 The layout of checkpointed GPR regset is the same as a regular
673 struct pt_regs, but we skip all registers that are not actually
674 checkpointed by the processor (e.g. msr, nip), except when
675 generating a core file. The 64-bit regset is 48 * 8 bytes long.
676 In some 64-bit kernels, the regset for a 32-bit inferior has the
677 same length, but all the registers are squeezed in the first half
678 (48 * 4 bytes). The pt_regs struct calls the regular cr ccr, but
679 we use ccr for "checkpointed condition register". Note that CR
680 (condition register) field 0 is not checkpointed, but the kernel
681 returns all 4 bytes. The skipped registers should not be touched
682 when writing the regset to the inferior (with
683 PTRACE_SETREGSET). */
685 static const struct regcache_map_entry ppc32_regmap_cgpr
[] =
687 { 32, PPC_CR0_REGNUM
, 4 },
688 { 3, REGCACHE_MAP_SKIP
, 4 }, /* nip, msr, orig_gpr3. */
689 { 1, PPC_CCTR_REGNUM
, 4 },
690 { 1, PPC_CLR_REGNUM
, 4 },
691 { 1, PPC_CXER_REGNUM
, 4 },
692 { 1, PPC_CCR_REGNUM
, 4 },
693 { 9, REGCACHE_MAP_SKIP
, 4 }, /* All the rest. */
697 static const struct regcache_map_entry ppc64_le_regmap_cgpr
[] =
699 { 32, PPC_CR0_REGNUM
, 8 },
700 { 3, REGCACHE_MAP_SKIP
, 8 },
701 { 1, PPC_CCTR_REGNUM
, 8 },
702 { 1, PPC_CLR_REGNUM
, 8 },
703 { 1, PPC_CXER_REGNUM
, 4 },
704 { 1, REGCACHE_MAP_SKIP
, 4 }, /* CXER padding. */
705 { 1, PPC_CCR_REGNUM
, 4 },
706 { 1, REGCACHE_MAP_SKIP
, 4}, /* CCR padding. */
707 { 9, REGCACHE_MAP_SKIP
, 8},
711 static const struct regcache_map_entry ppc64_be_regmap_cgpr
[] =
713 { 32, PPC_CR0_REGNUM
, 8 },
714 { 3, REGCACHE_MAP_SKIP
, 8 },
715 { 1, PPC_CCTR_REGNUM
, 8 },
716 { 1, PPC_CLR_REGNUM
, 8 },
717 { 1, REGCACHE_MAP_SKIP
, 4}, /* CXER padding. */
718 { 1, PPC_CXER_REGNUM
, 4 },
719 { 1, REGCACHE_MAP_SKIP
, 4}, /* CCR padding. */
720 { 1, PPC_CCR_REGNUM
, 4 },
721 { 9, REGCACHE_MAP_SKIP
, 8},
725 /* Regsets for the Hardware Transactional Memory checkpointed
726 general-purpose registers for 32-bit, 64-bit big-endian, and 64-bit
727 little endian targets.
729 Some 64-bit kernels generate a checkpointed gpr note section with
730 48*8 bytes for a 32-bit thread, of which only 48*4 are actually
731 used, so we set the variable size flag in the corresponding regset
732 to accept this case. */
734 static const struct regset ppc32_linux_cgprregset
= {
736 regcache_supply_regset
,
737 regcache_collect_regset
,
741 static const struct regset ppc64_be_linux_cgprregset
= {
742 ppc64_be_regmap_cgpr
,
743 regcache_supply_regset
,
744 regcache_collect_regset
747 static const struct regset ppc64_le_linux_cgprregset
= {
748 ppc64_le_regmap_cgpr
,
749 regcache_supply_regset
,
750 regcache_collect_regset
753 /* Hardware Transactional Memory checkpointed floating-point regmap. */
755 static const struct regcache_map_entry ppc32_regmap_cfpr
[] =
757 { 32, PPC_CF0_REGNUM
, 8 },
758 { 1, PPC_CFPSCR_REGNUM
, 8 },
762 /* Hardware Transactional Memory checkpointed floating-point regset. */
764 const struct regset ppc32_linux_cfprregset
= {
766 regcache_supply_regset
,
767 regcache_collect_regset
770 /* Regmaps for the Hardware Transactional Memory checkpointed vector
771 regsets, for big and little endian targets. The position of the
772 4-byte VSCR in its 16-byte field depends on the endianness. */
774 static const struct regcache_map_entry ppc32_le_regmap_cvmx
[] =
776 { 32, PPC_CVR0_REGNUM
, 16 },
777 { 1, PPC_CVSCR_REGNUM
, 4 },
778 { 1, REGCACHE_MAP_SKIP
, 12 },
779 { 1, PPC_CVRSAVE_REGNUM
, 4 },
780 { 1, REGCACHE_MAP_SKIP
, 12 },
784 static const struct regcache_map_entry ppc32_be_regmap_cvmx
[] =
786 { 32, PPC_CVR0_REGNUM
, 16 },
787 { 1, REGCACHE_MAP_SKIP
, 12 },
788 { 1, PPC_CVSCR_REGNUM
, 4 },
789 { 1, PPC_CVRSAVE_REGNUM
, 4 },
790 { 1, REGCACHE_MAP_SKIP
, 12},
794 /* Hardware Transactional Memory checkpointed vector regsets, for little
795 and big endian targets. */
797 static const struct regset ppc32_le_linux_cvmxregset
= {
798 ppc32_le_regmap_cvmx
,
799 regcache_supply_regset
,
800 regcache_collect_regset
803 static const struct regset ppc32_be_linux_cvmxregset
= {
804 ppc32_be_regmap_cvmx
,
805 regcache_supply_regset
,
806 regcache_collect_regset
809 /* Hardware Transactional Memory checkpointed vector-scalar regmap. */
811 static const struct regcache_map_entry ppc32_regmap_cvsx
[] =
813 { 32, PPC_CVSR0_UPPER_REGNUM
, 8 },
817 /* Hardware Transactional Memory checkpointed vector-scalar regset. */
819 const struct regset ppc32_linux_cvsxregset
= {
821 regcache_supply_regset
,
822 regcache_collect_regset
825 /* Hardware Transactional Memory checkpointed Program Priority Register
828 static const struct regcache_map_entry ppc32_regmap_cppr
[] =
830 { 1, PPC_CPPR_REGNUM
, 8 },
834 /* Hardware Transactional Memory checkpointed Program Priority Register
837 const struct regset ppc32_linux_cpprregset
= {
839 regcache_supply_regset
,
840 regcache_collect_regset
843 /* Hardware Transactional Memory checkpointed Data Stream Control
846 static const struct regcache_map_entry ppc32_regmap_cdscr
[] =
848 { 1, PPC_CDSCR_REGNUM
, 8 },
852 /* Hardware Transactional Memory checkpointed Data Stream Control
855 const struct regset ppc32_linux_cdscrregset
= {
857 regcache_supply_regset
,
858 regcache_collect_regset
861 /* Hardware Transactional Memory checkpointed Target Address Register
864 static const struct regcache_map_entry ppc32_regmap_ctar
[] =
866 { 1, PPC_CTAR_REGNUM
, 8 },
870 /* Hardware Transactional Memory checkpointed Target Address Register
873 const struct regset ppc32_linux_ctarregset
= {
875 regcache_supply_regset
,
876 regcache_collect_regset
879 const struct regset
*
880 ppc_linux_gregset (int wordsize
)
882 return wordsize
== 8 ? &ppc64_linux_gregset
: &ppc32_linux_gregset
;
885 const struct regset
*
886 ppc_linux_fpregset (void)
888 return &ppc32_linux_fpregset
;
891 const struct regset
*
892 ppc_linux_vrregset (struct gdbarch
*gdbarch
)
894 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
895 return &ppc32_be_linux_vrregset
;
897 return &ppc32_le_linux_vrregset
;
900 const struct regset
*
901 ppc_linux_vsxregset (void)
903 return &ppc32_linux_vsxregset
;
906 const struct regset
*
907 ppc_linux_cgprregset (struct gdbarch
*gdbarch
)
909 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
911 if (tdep
->wordsize
== 4)
913 return &ppc32_linux_cgprregset
;
917 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
918 return &ppc64_be_linux_cgprregset
;
920 return &ppc64_le_linux_cgprregset
;
924 const struct regset
*
925 ppc_linux_cvmxregset (struct gdbarch
*gdbarch
)
927 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
928 return &ppc32_be_linux_cvmxregset
;
930 return &ppc32_le_linux_cvmxregset
;
933 /* Collect function used to generate the core note for the
934 checkpointed GPR regset. Here, we don't want to skip the
935 "checkpointed" NIP and MSR, so that the note section we generate is
936 similar to the one generated by the kernel. To avoid having to
937 define additional registers in GDB which are not actually
938 checkpointed in the architecture, we copy TFHAR to the checkpointed
939 NIP slot, which is what the kernel does, and copy the regular MSR
940 to the checkpointed MSR slot, which will have a similar value in
944 ppc_linux_collect_core_cpgrregset (const struct regset
*regset
,
945 const struct regcache
*regcache
,
946 int regnum
, void *buf
, size_t len
)
948 struct gdbarch
*gdbarch
= regcache
->arch ();
949 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
951 const struct regset
*cgprregset
= ppc_linux_cgprregset (gdbarch
);
953 /* We collect the checkpointed GPRs already defined in the regular
954 regmap, then overlay TFHAR/MSR on the checkpointed NIP/MSR
956 cgprregset
->collect_regset (cgprregset
, regcache
, regnum
, buf
, len
);
958 /* Check that we are collecting all the registers, which should be
959 the case when generating a core file. */
963 /* PT_NIP and PT_MSR are 32 and 33 for powerpc. Don't redefine
964 these symbols since this file can run on clients in other
965 architectures where they can already be defined to other
969 /* Check that our buffer is long enough to hold two slots at
970 pt_offset * wordsize, one for NIP and one for MSR. */
971 gdb_assert ((pt_offset
+ 2) * tdep
->wordsize
<= len
);
973 /* TFHAR is 8 bytes wide, but the NIP slot for a 32-bit thread is
974 4-bytes long. We use raw_collect_integer which handles
975 differences in the sizes for the source and destination buffers
976 for both endian modes. */
977 (regcache
->raw_collect_integer
978 (PPC_TFHAR_REGNUM
, ((gdb_byte
*) buf
) + pt_offset
* tdep
->wordsize
,
979 tdep
->wordsize
, false));
983 (regcache
->raw_collect_integer
984 (PPC_MSR_REGNUM
, ((gdb_byte
*) buf
) + pt_offset
* tdep
->wordsize
,
985 tdep
->wordsize
, false));
988 /* Iterate over supported core file register note sections. */
991 ppc_linux_iterate_over_regset_sections (struct gdbarch
*gdbarch
,
992 iterate_over_regset_sections_cb
*cb
,
994 const struct regcache
*regcache
)
996 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
997 int have_altivec
= tdep
->ppc_vr0_regnum
!= -1;
998 int have_vsx
= tdep
->ppc_vsr0_upper_regnum
!= -1;
999 int have_ppr
= tdep
->ppc_ppr_regnum
!= -1;
1000 int have_dscr
= tdep
->ppc_dscr_regnum
!= -1;
1001 int have_tar
= tdep
->ppc_tar_regnum
!= -1;
1003 if (tdep
->wordsize
== 4)
1004 cb (".reg", 48 * 4, 48 * 4, &ppc32_linux_gregset
, NULL
, cb_data
);
1006 cb (".reg", 48 * 8, 48 * 8, &ppc64_linux_gregset
, NULL
, cb_data
);
1008 cb (".reg2", 264, 264, &ppc32_linux_fpregset
, NULL
, cb_data
);
1012 const struct regset
*vrregset
= ppc_linux_vrregset (gdbarch
);
1013 cb (".reg-ppc-vmx", PPC_LINUX_SIZEOF_VRREGSET
, PPC_LINUX_SIZEOF_VRREGSET
,
1014 vrregset
, "ppc Altivec", cb_data
);
1018 cb (".reg-ppc-vsx", PPC_LINUX_SIZEOF_VSXREGSET
, PPC_LINUX_SIZEOF_VSXREGSET
,
1019 &ppc32_linux_vsxregset
, "POWER7 VSX", cb_data
);
1022 cb (".reg-ppc-ppr", PPC_LINUX_SIZEOF_PPRREGSET
,
1023 PPC_LINUX_SIZEOF_PPRREGSET
,
1024 &ppc32_linux_pprregset
, "Priority Program Register", cb_data
);
1027 cb (".reg-ppc-dscr", PPC_LINUX_SIZEOF_DSCRREGSET
,
1028 PPC_LINUX_SIZEOF_DSCRREGSET
,
1029 &ppc32_linux_dscrregset
, "Data Stream Control Register",
1033 cb (".reg-ppc-tar", PPC_LINUX_SIZEOF_TARREGSET
,
1034 PPC_LINUX_SIZEOF_TARREGSET
,
1035 &ppc32_linux_tarregset
, "Target Address Register", cb_data
);
1037 /* EBB registers are unavailable when ptrace returns ENODATA. Check
1038 availability when generating a core file (regcache != NULL). */
1040 if (regcache
== NULL
1041 || REG_VALID
== regcache
->get_register_status (PPC_BESCR_REGNUM
))
1042 cb (".reg-ppc-ebb", PPC_LINUX_SIZEOF_EBBREGSET
,
1043 PPC_LINUX_SIZEOF_EBBREGSET
,
1044 &ppc32_linux_ebbregset
, "Event-based Branching Registers",
1047 if (tdep
->ppc_mmcr0_regnum
!= -1)
1048 cb (".reg-ppc-pmu", PPC_LINUX_SIZEOF_PMUREGSET
,
1049 PPC_LINUX_SIZEOF_PMUREGSET
,
1050 &ppc32_linux_pmuregset
, "Performance Monitor Registers",
1053 if (tdep
->have_htm_spr
)
1054 cb (".reg-ppc-tm-spr", PPC_LINUX_SIZEOF_TM_SPRREGSET
,
1055 PPC_LINUX_SIZEOF_TM_SPRREGSET
,
1056 &ppc32_linux_tm_sprregset
,
1057 "Hardware Transactional Memory Special Purpose Registers",
1060 /* Checkpointed registers can be unavailable, don't call back if
1061 we are generating a core file. */
1063 if (tdep
->have_htm_core
)
1065 /* Only generate the checkpointed GPR core note if we also have
1066 access to the HTM SPRs, because we need TFHAR to fill the
1067 "checkpointed" NIP slot. We can read a core file without it
1068 since GDB is not aware of this NIP as a visible register. */
1069 if (regcache
== NULL
||
1070 (REG_VALID
== regcache
->get_register_status (PPC_CR0_REGNUM
)
1071 && tdep
->have_htm_spr
))
1073 int cgpr_size
= (tdep
->wordsize
== 4?
1074 PPC32_LINUX_SIZEOF_CGPRREGSET
1075 : PPC64_LINUX_SIZEOF_CGPRREGSET
);
1077 const struct regset
*cgprregset
=
1078 ppc_linux_cgprregset (gdbarch
);
1080 if (regcache
!= NULL
)
1082 struct regset core_cgprregset
= *cgprregset
;
1084 core_cgprregset
.collect_regset
1085 = ppc_linux_collect_core_cpgrregset
;
1087 cb (".reg-ppc-tm-cgpr",
1088 cgpr_size
, cgpr_size
,
1090 "Checkpointed General Purpose Registers", cb_data
);
1094 cb (".reg-ppc-tm-cgpr",
1095 cgpr_size
, cgpr_size
,
1097 "Checkpointed General Purpose Registers", cb_data
);
1102 if (tdep
->have_htm_fpu
)
1104 if (regcache
== NULL
||
1105 REG_VALID
== regcache
->get_register_status (PPC_CF0_REGNUM
))
1106 cb (".reg-ppc-tm-cfpr", PPC_LINUX_SIZEOF_CFPRREGSET
,
1107 PPC_LINUX_SIZEOF_CFPRREGSET
,
1108 &ppc32_linux_cfprregset
,
1109 "Checkpointed Floating Point Registers", cb_data
);
1112 if (tdep
->have_htm_altivec
)
1114 if (regcache
== NULL
||
1115 REG_VALID
== regcache
->get_register_status (PPC_CVR0_REGNUM
))
1117 const struct regset
*cvmxregset
=
1118 ppc_linux_cvmxregset (gdbarch
);
1120 cb (".reg-ppc-tm-cvmx", PPC_LINUX_SIZEOF_CVMXREGSET
,
1121 PPC_LINUX_SIZEOF_CVMXREGSET
,
1123 "Checkpointed Altivec (VMX) Registers", cb_data
);
1127 if (tdep
->have_htm_vsx
)
1129 if (regcache
== NULL
||
1131 == regcache
->get_register_status (PPC_CVSR0_UPPER_REGNUM
)))
1132 cb (".reg-ppc-tm-cvsx", PPC_LINUX_SIZEOF_CVSXREGSET
,
1133 PPC_LINUX_SIZEOF_CVSXREGSET
,
1134 &ppc32_linux_cvsxregset
,
1135 "Checkpointed VSX Registers", cb_data
);
1138 if (tdep
->ppc_cppr_regnum
!= -1)
1140 if (regcache
== NULL
||
1141 REG_VALID
== regcache
->get_register_status (PPC_CPPR_REGNUM
))
1142 cb (".reg-ppc-tm-cppr", PPC_LINUX_SIZEOF_CPPRREGSET
,
1143 PPC_LINUX_SIZEOF_CPPRREGSET
,
1144 &ppc32_linux_cpprregset
,
1145 "Checkpointed Priority Program Register", cb_data
);
1148 if (tdep
->ppc_cdscr_regnum
!= -1)
1150 if (regcache
== NULL
||
1151 REG_VALID
== regcache
->get_register_status (PPC_CDSCR_REGNUM
))
1152 cb (".reg-ppc-tm-cdscr", PPC_LINUX_SIZEOF_CDSCRREGSET
,
1153 PPC_LINUX_SIZEOF_CDSCRREGSET
,
1154 &ppc32_linux_cdscrregset
,
1155 "Checkpointed Data Stream Control Register", cb_data
);
1158 if (tdep
->ppc_ctar_regnum
)
1160 if ( regcache
== NULL
||
1161 REG_VALID
== regcache
->get_register_status (PPC_CTAR_REGNUM
))
1162 cb (".reg-ppc-tm-ctar", PPC_LINUX_SIZEOF_CTARREGSET
,
1163 PPC_LINUX_SIZEOF_CTARREGSET
,
1164 &ppc32_linux_ctarregset
,
1165 "Checkpointed Target Address Register", cb_data
);
1170 ppc_linux_sigtramp_cache (frame_info_ptr this_frame
,
1171 struct trad_frame_cache
*this_cache
,
1172 CORE_ADDR func
, LONGEST offset
,
1180 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1181 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
1182 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1184 base
= get_frame_register_unsigned (this_frame
,
1185 gdbarch_sp_regnum (gdbarch
));
1186 if (bias
> 0 && get_frame_pc (this_frame
) != func
)
1187 /* See below, some signal trampolines increment the stack as their
1188 first instruction, need to compensate for that. */
1191 /* Find the address of the register buffer pointer. */
1192 regs
= base
+ offset
;
1193 /* Use that to find the address of the corresponding register
1195 gpregs
= read_memory_unsigned_integer (regs
, tdep
->wordsize
, byte_order
);
1196 fpregs
= gpregs
+ 48 * tdep
->wordsize
;
1198 /* General purpose. */
1199 for (i
= 0; i
< 32; i
++)
1201 int regnum
= i
+ tdep
->ppc_gp0_regnum
;
1202 trad_frame_set_reg_addr (this_cache
,
1203 regnum
, gpregs
+ i
* tdep
->wordsize
);
1205 trad_frame_set_reg_addr (this_cache
,
1206 gdbarch_pc_regnum (gdbarch
),
1207 gpregs
+ 32 * tdep
->wordsize
);
1208 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_ctr_regnum
,
1209 gpregs
+ 35 * tdep
->wordsize
);
1210 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_lr_regnum
,
1211 gpregs
+ 36 * tdep
->wordsize
);
1212 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_xer_regnum
,
1213 gpregs
+ 37 * tdep
->wordsize
);
1214 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_cr_regnum
,
1215 gpregs
+ 38 * tdep
->wordsize
);
1217 if (ppc_linux_trap_reg_p (gdbarch
))
1219 trad_frame_set_reg_addr (this_cache
, PPC_ORIG_R3_REGNUM
,
1220 gpregs
+ 34 * tdep
->wordsize
);
1221 trad_frame_set_reg_addr (this_cache
, PPC_TRAP_REGNUM
,
1222 gpregs
+ 40 * tdep
->wordsize
);
1225 if (ppc_floating_point_unit_p (gdbarch
))
1227 /* Floating point registers. */
1228 for (i
= 0; i
< 32; i
++)
1230 int regnum
= i
+ gdbarch_fp0_regnum (gdbarch
);
1231 trad_frame_set_reg_addr (this_cache
, regnum
,
1232 fpregs
+ i
* tdep
->wordsize
);
1234 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_fpscr_regnum
,
1235 fpregs
+ 32 * tdep
->wordsize
);
1237 trad_frame_set_id (this_cache
, frame_id_build (base
, func
));
1241 ppc32_linux_sigaction_cache_init (const struct tramp_frame
*self
,
1242 frame_info_ptr this_frame
,
1243 struct trad_frame_cache
*this_cache
,
1246 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
1247 0xd0 /* Offset to ucontext_t. */
1248 + 0x30 /* Offset to .reg. */,
1253 ppc64_linux_sigaction_cache_init (const struct tramp_frame
*self
,
1254 frame_info_ptr this_frame
,
1255 struct trad_frame_cache
*this_cache
,
1258 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
1259 0x80 /* Offset to ucontext_t. */
1260 + 0xe0 /* Offset to .reg. */,
1265 ppc32_linux_sighandler_cache_init (const struct tramp_frame
*self
,
1266 frame_info_ptr this_frame
,
1267 struct trad_frame_cache
*this_cache
,
1270 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
1271 0x40 /* Offset to ucontext_t. */
1272 + 0x1c /* Offset to .reg. */,
1277 ppc64_linux_sighandler_cache_init (const struct tramp_frame
*self
,
1278 frame_info_ptr this_frame
,
1279 struct trad_frame_cache
*this_cache
,
1282 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
1283 0x80 /* Offset to struct sigcontext. */
1284 + 0x38 /* Offset to .reg. */,
1288 static struct tramp_frame ppc32_linux_sigaction_tramp_frame
= {
1292 { 0x380000ac, ULONGEST_MAX
}, /* li r0, 172 */
1293 { 0x44000002, ULONGEST_MAX
}, /* sc */
1294 { TRAMP_SENTINEL_INSN
},
1296 ppc32_linux_sigaction_cache_init
1298 static struct tramp_frame ppc64_linux_sigaction_tramp_frame
= {
1302 { 0x38210080, ULONGEST_MAX
}, /* addi r1,r1,128 */
1303 { 0x380000ac, ULONGEST_MAX
}, /* li r0, 172 */
1304 { 0x44000002, ULONGEST_MAX
}, /* sc */
1305 { TRAMP_SENTINEL_INSN
},
1307 ppc64_linux_sigaction_cache_init
1309 static struct tramp_frame ppc32_linux_sighandler_tramp_frame
= {
1313 { 0x38000077, ULONGEST_MAX
}, /* li r0,119 */
1314 { 0x44000002, ULONGEST_MAX
}, /* sc */
1315 { TRAMP_SENTINEL_INSN
},
1317 ppc32_linux_sighandler_cache_init
1319 static struct tramp_frame ppc64_linux_sighandler_tramp_frame
= {
1323 { 0x38210080, ULONGEST_MAX
}, /* addi r1,r1,128 */
1324 { 0x38000077, ULONGEST_MAX
}, /* li r0,119 */
1325 { 0x44000002, ULONGEST_MAX
}, /* sc */
1326 { TRAMP_SENTINEL_INSN
},
1328 ppc64_linux_sighandler_cache_init
1331 /* Return 1 if PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM are usable. */
1333 ppc_linux_trap_reg_p (struct gdbarch
*gdbarch
)
1335 /* If we do not have a target description with registers, then
1336 the special registers will not be included in the register set. */
1337 if (!tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
1340 /* If we do, then it is safe to check the size. */
1341 return register_size (gdbarch
, PPC_ORIG_R3_REGNUM
) > 0
1342 && register_size (gdbarch
, PPC_TRAP_REGNUM
) > 0;
1345 /* Return the current system call's number present in the
1346 r0 register. When the function fails, it returns -1. */
1348 ppc_linux_get_syscall_number (struct gdbarch
*gdbarch
,
1349 thread_info
*thread
)
1351 struct regcache
*regcache
= get_thread_regcache (thread
);
1352 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
1353 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1355 /* Make sure we're in a 32- or 64-bit machine */
1356 gdb_assert (tdep
->wordsize
== 4 || tdep
->wordsize
== 8);
1358 /* The content of a register */
1359 gdb::byte_vector
buf (tdep
->wordsize
);
1361 /* Getting the system call number from the register.
1362 When dealing with PowerPC architecture, this information
1363 is stored at 0th register. */
1364 regcache
->cooked_read (tdep
->ppc_gp0_regnum
, buf
.data ());
1366 return extract_signed_integer (buf
.data (), tdep
->wordsize
, byte_order
);
1369 /* PPC process record-replay */
1371 static struct linux_record_tdep ppc_linux_record_tdep
;
1372 static struct linux_record_tdep ppc64_linux_record_tdep
;
1374 /* ppc_canonicalize_syscall maps from the native PowerPC Linux set of
1375 syscall ids into a canonical set of syscall ids used by process
1376 record. (See arch/powerpc/include/uapi/asm/unistd.h in kernel tree.)
1377 Return -1 if this system call is not supported by process record.
1378 Otherwise, return the syscall number for process record of given
1381 static enum gdb_syscall
1382 ppc_canonicalize_syscall (int syscall
, int wordsize
)
1388 else if (syscall
>= 167 && syscall
<= 190) /* Skip query_module 166 */
1389 result
= syscall
+ 1;
1390 else if (syscall
>= 192 && syscall
<= 197) /* mmap2 */
1392 else if (syscall
== 208) /* tkill */
1393 result
= gdb_sys_tkill
;
1394 else if (syscall
>= 207 && syscall
<= 220) /* gettid */
1395 result
= syscall
+ 224 - 207;
1396 else if (syscall
>= 234 && syscall
<= 239) /* exit_group */
1397 result
= syscall
+ 252 - 234;
1398 else if (syscall
>= 240 && syscall
<= 248) /* timer_create */
1399 result
= syscall
+= 259 - 240;
1400 else if (syscall
>= 250 && syscall
<= 251) /* tgkill */
1401 result
= syscall
+ 270 - 250;
1402 else if (syscall
== 286)
1403 result
= gdb_sys_openat
;
1404 else if (syscall
== 291)
1407 result
= gdb_sys_newfstatat
;
1409 result
= gdb_sys_fstatat64
;
1411 else if (syscall
== 317)
1412 result
= gdb_sys_pipe2
;
1413 else if (syscall
== 336)
1414 result
= gdb_sys_recv
;
1415 else if (syscall
== 337)
1416 result
= gdb_sys_recvfrom
;
1417 else if (syscall
== 342)
1418 result
= gdb_sys_recvmsg
;
1419 else if (syscall
== 359)
1420 result
= gdb_sys_getrandom
;
1422 return (enum gdb_syscall
) result
;
1425 /* Record registers which might be clobbered during system call.
1426 Return 0 if successful. */
1429 ppc_linux_syscall_record (struct regcache
*regcache
)
1431 struct gdbarch
*gdbarch
= regcache
->arch ();
1432 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
1434 enum gdb_syscall syscall_gdb
;
1437 regcache_raw_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
, &scnum
);
1438 syscall_gdb
= ppc_canonicalize_syscall (scnum
, tdep
->wordsize
);
1440 if (syscall_gdb
< 0)
1442 gdb_printf (gdb_stderr
,
1443 _("Process record and replay target doesn't "
1444 "support syscall number %d\n"), (int) scnum
);
1448 if (syscall_gdb
== gdb_sys_sigreturn
1449 || syscall_gdb
== gdb_sys_rt_sigreturn
)
1452 int regsets
[] = { tdep
->ppc_gp0_regnum
,
1453 tdep
->ppc_fp0_regnum
,
1454 tdep
->ppc_vr0_regnum
,
1455 tdep
->ppc_vsr0_upper_regnum
};
1457 for (j
= 0; j
< 4; j
++)
1459 if (regsets
[j
] == -1)
1461 for (i
= 0; i
< 32; i
++)
1463 if (record_full_arch_list_add_reg (regcache
, regsets
[j
] + i
))
1468 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_cr_regnum
))
1470 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_ctr_regnum
))
1472 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_lr_regnum
))
1474 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_xer_regnum
))
1480 if (tdep
->wordsize
== 8)
1481 ret
= record_linux_system_call (syscall_gdb
, regcache
,
1482 &ppc64_linux_record_tdep
);
1484 ret
= record_linux_system_call (syscall_gdb
, regcache
,
1485 &ppc_linux_record_tdep
);
1490 /* Record registers clobbered during syscall. */
1491 for (int i
= 3; i
<= 12; i
++)
1493 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ i
))
1496 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ 0))
1498 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_cr_regnum
))
1500 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_ctr_regnum
))
1502 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_lr_regnum
))
1508 /* Record registers which might be clobbered during signal handling.
1509 Return 0 if successful. */
1512 ppc_linux_record_signal (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1513 enum gdb_signal signal
)
1515 /* See handle_rt_signal64 in arch/powerpc/kernel/signal_64.c
1516 handle_rt_signal32 in arch/powerpc/kernel/signal_32.c
1517 arch/powerpc/include/asm/ptrace.h
1519 const int SIGNAL_FRAMESIZE
= 128;
1520 const int sizeof_rt_sigframe
= 1440 * 2 + 8 * 2 + 4 * 6 + 8 + 8 + 128 + 512;
1522 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
1525 for (i
= 3; i
<= 12; i
++)
1527 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ i
))
1531 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_lr_regnum
))
1533 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_cr_regnum
))
1535 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_ctr_regnum
))
1537 if (record_full_arch_list_add_reg (regcache
, gdbarch_pc_regnum (gdbarch
)))
1539 if (record_full_arch_list_add_reg (regcache
, gdbarch_sp_regnum (gdbarch
)))
1542 /* Record the change in the stack.
1543 frame-size = sizeof (struct rt_sigframe) + SIGNAL_FRAMESIZE */
1544 regcache_raw_read_unsigned (regcache
, gdbarch_sp_regnum (gdbarch
), &sp
);
1545 sp
-= SIGNAL_FRAMESIZE
;
1546 sp
-= sizeof_rt_sigframe
;
1548 if (record_full_arch_list_add_mem (sp
, SIGNAL_FRAMESIZE
+ sizeof_rt_sigframe
))
1551 if (record_full_arch_list_add_end ())
1558 ppc_linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1560 struct gdbarch
*gdbarch
= regcache
->arch ();
1562 regcache_cooked_write_unsigned (regcache
, gdbarch_pc_regnum (gdbarch
), pc
);
1564 /* Set special TRAP register to -1 to prevent the kernel from
1565 messing with the PC we just installed, if we happen to be
1566 within an interrupted system call that the kernel wants to
1569 Note that after we return from the dummy call, the TRAP and
1570 ORIG_R3 registers will be automatically restored, and the
1571 kernel continues to restart the system call at this point. */
1572 if (ppc_linux_trap_reg_p (gdbarch
))
1573 regcache_cooked_write_unsigned (regcache
, PPC_TRAP_REGNUM
, -1);
1576 static const struct target_desc
*
1577 ppc_linux_core_read_description (struct gdbarch
*gdbarch
,
1578 struct target_ops
*target
,
1581 struct ppc_linux_features features
= ppc_linux_no_features
;
1582 asection
*altivec
= bfd_get_section_by_name (abfd
, ".reg-ppc-vmx");
1583 asection
*vsx
= bfd_get_section_by_name (abfd
, ".reg-ppc-vsx");
1584 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
1585 asection
*ppr
= bfd_get_section_by_name (abfd
, ".reg-ppc-ppr");
1586 asection
*dscr
= bfd_get_section_by_name (abfd
, ".reg-ppc-dscr");
1587 asection
*tar
= bfd_get_section_by_name (abfd
, ".reg-ppc-tar");
1588 asection
*pmu
= bfd_get_section_by_name (abfd
, ".reg-ppc-pmu");
1589 asection
*htmspr
= bfd_get_section_by_name (abfd
, ".reg-ppc-tm-spr");
1594 switch (bfd_section_size (section
))
1597 features
.wordsize
= 4;
1600 features
.wordsize
= 8;
1607 features
.altivec
= true;
1610 features
.vsx
= true;
1612 gdb::optional
<gdb::byte_vector
> auxv
= target_read_auxv_raw (target
);
1613 CORE_ADDR hwcap
= linux_get_hwcap (auxv
, target
, gdbarch
);
1615 features
.isa205
= ppc_linux_has_isa205 (hwcap
);
1619 features
.ppr_dscr
= true;
1621 /* We don't require the EBB note section to be present in the
1622 core file to select isa207 because these registers could have
1623 been unavailable when the core file was created. They will
1624 be in the tdep but will show as unavailable. */
1627 features
.isa207
= true;
1629 features
.htm
= true;
1633 return ppc_linux_match_description (features
);
1637 /* Implementation of `gdbarch_elf_make_msymbol_special', as defined in
1638 gdbarch.h. This implementation is used for the ELFv2 ABI only. */
1641 ppc_elfv2_elf_make_msymbol_special (asymbol
*sym
, struct minimal_symbol
*msym
)
1643 if ((sym
->flags
& BSF_SYNTHETIC
) != 0)
1644 /* ELFv2 synthetic symbols (the PLT stubs and the __glink_PLTresolve
1645 trampoline) do not have a local entry point. */
1648 elf_symbol_type
*elf_sym
= (elf_symbol_type
*)sym
;
1650 /* If the symbol is marked as having a local entry point, set a target
1651 flag in the msymbol. We currently only support local entry point
1652 offsets of 8 bytes, which is the only entry point offset ever used
1653 by current compilers. If/when other offsets are ever used, we will
1654 have to use additional target flag bits to store them. */
1655 switch (PPC64_LOCAL_ENTRY_OFFSET (elf_sym
->internal_elf_sym
.st_other
))
1660 msym
->set_target_flag_1 (true);
1665 /* Implementation of `gdbarch_skip_entrypoint', as defined in
1666 gdbarch.h. This implementation is used for the ELFv2 ABI only. */
1669 ppc_elfv2_skip_entrypoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1671 struct bound_minimal_symbol fun
;
1672 int local_entry_offset
= 0;
1674 fun
= lookup_minimal_symbol_by_pc (pc
);
1675 if (fun
.minsym
== NULL
)
1678 /* See ppc_elfv2_elf_make_msymbol_special for how local entry point
1679 offset values are encoded. */
1680 if (fun
.minsym
->target_flag_1 ())
1681 local_entry_offset
= 8;
1683 if (fun
.value_address () <= pc
1684 && pc
< fun
.value_address () + local_entry_offset
)
1685 return fun
.value_address () + local_entry_offset
;
1690 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1694 ppc_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
1696 return (*s
== 'i' /* Literal number. */
1697 || (isdigit (*s
) && s
[1] == '('
1698 && isdigit (s
[2])) /* Displacement. */
1699 || (*s
== '(' && isdigit (s
[1])) /* Register indirection. */
1700 || isdigit (*s
)); /* Register value. */
1703 /* Implementation of `gdbarch_stap_parse_special_token', as defined in
1706 static expr::operation_up
1707 ppc_stap_parse_special_token (struct gdbarch
*gdbarch
,
1708 struct stap_parse_info
*p
)
1710 if (isdigit (*p
->arg
))
1712 /* This temporary pointer is needed because we have to do a lookahead.
1713 We could be dealing with a register displacement, and in such case
1714 we would not need to do anything. */
1715 const char *s
= p
->arg
;
1719 while (isdigit (*s
))
1724 /* It is a register displacement indeed. Returning 0 means we are
1725 deferring the treatment of this case to the generic parser. */
1730 regname
= (char *) alloca (len
+ 2);
1733 strncpy (regname
+ 1, p
->arg
, len
);
1735 regname
[len
] = '\0';
1737 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
1738 error (_("Invalid register name `%s' on expression `%s'."),
1739 regname
, p
->saved_arg
);
1743 return expr::make_operation
<expr::register_operation
> (regname
);
1746 /* All the other tokens should be handled correctly by the generic
1751 /* Initialize linux_record_tdep if not initialized yet.
1752 WORDSIZE is 4 or 8 for 32- or 64-bit PowerPC Linux respectively.
1753 Sizes of data structures are initialized accordingly. */
1756 ppc_init_linux_record_tdep (struct linux_record_tdep
*record_tdep
,
1759 /* The values for TCGETS, TCSETS, TCSETSW, TCSETSF are based on the
1760 size of struct termios in the kernel source.
1761 include/uapi/asm-generic/termbits.h */
1762 #define SIZE_OF_STRUCT_TERMIOS 0x2c
1764 /* Simply return if it had been initialized. */
1765 if (record_tdep
->size_pointer
!= 0)
1768 /* These values are the size of the type that will be used in a system
1769 call. They are obtained from Linux Kernel source. */
1773 record_tdep
->size_pointer
= 8;
1774 record_tdep
->size__old_kernel_stat
= 32;
1775 record_tdep
->size_tms
= 32;
1776 record_tdep
->size_loff_t
= 8;
1777 record_tdep
->size_flock
= 32;
1778 record_tdep
->size_oldold_utsname
= 45;
1779 record_tdep
->size_ustat
= 32;
1780 record_tdep
->size_old_sigaction
= 32;
1781 record_tdep
->size_old_sigset_t
= 8;
1782 record_tdep
->size_rlimit
= 16;
1783 record_tdep
->size_rusage
= 144;
1784 record_tdep
->size_timeval
= 16;
1785 record_tdep
->size_timezone
= 8;
1786 record_tdep
->size_old_gid_t
= 4;
1787 record_tdep
->size_old_uid_t
= 4;
1788 record_tdep
->size_fd_set
= 128;
1789 record_tdep
->size_old_dirent
= 280;
1790 record_tdep
->size_statfs
= 120;
1791 record_tdep
->size_statfs64
= 120;
1792 record_tdep
->size_sockaddr
= 16;
1793 record_tdep
->size_int
= 4;
1794 record_tdep
->size_long
= 8;
1795 record_tdep
->size_ulong
= 8;
1796 record_tdep
->size_msghdr
= 56;
1797 record_tdep
->size_itimerval
= 32;
1798 record_tdep
->size_stat
= 144;
1799 record_tdep
->size_old_utsname
= 325;
1800 record_tdep
->size_sysinfo
= 112;
1801 record_tdep
->size_msqid_ds
= 120;
1802 record_tdep
->size_shmid_ds
= 112;
1803 record_tdep
->size_new_utsname
= 390;
1804 record_tdep
->size_timex
= 208;
1805 record_tdep
->size_mem_dqinfo
= 24;
1806 record_tdep
->size_if_dqblk
= 72;
1807 record_tdep
->size_fs_quota_stat
= 80;
1808 record_tdep
->size_timespec
= 16;
1809 record_tdep
->size_pollfd
= 8;
1810 record_tdep
->size_NFS_FHSIZE
= 32;
1811 record_tdep
->size_knfsd_fh
= 132;
1812 record_tdep
->size_TASK_COMM_LEN
= 16;
1813 record_tdep
->size_sigaction
= 32;
1814 record_tdep
->size_sigset_t
= 8;
1815 record_tdep
->size_siginfo_t
= 128;
1816 record_tdep
->size_cap_user_data_t
= 8;
1817 record_tdep
->size_stack_t
= 24;
1818 record_tdep
->size_off_t
= 8;
1819 record_tdep
->size_stat64
= 104;
1820 record_tdep
->size_gid_t
= 4;
1821 record_tdep
->size_uid_t
= 4;
1822 record_tdep
->size_PAGE_SIZE
= 0x10000; /* 64KB */
1823 record_tdep
->size_flock64
= 32;
1824 record_tdep
->size_io_event
= 32;
1825 record_tdep
->size_iocb
= 64;
1826 record_tdep
->size_epoll_event
= 16;
1827 record_tdep
->size_itimerspec
= 32;
1828 record_tdep
->size_mq_attr
= 64;
1829 record_tdep
->size_termios
= 44;
1830 record_tdep
->size_pid_t
= 4;
1831 record_tdep
->size_winsize
= 8;
1832 record_tdep
->size_serial_struct
= 72;
1833 record_tdep
->size_serial_icounter_struct
= 80;
1834 record_tdep
->size_size_t
= 8;
1835 record_tdep
->size_iovec
= 16;
1836 record_tdep
->size_time_t
= 8;
1838 else if (wordsize
== 4)
1840 record_tdep
->size_pointer
= 4;
1841 record_tdep
->size__old_kernel_stat
= 32;
1842 record_tdep
->size_tms
= 16;
1843 record_tdep
->size_loff_t
= 8;
1844 record_tdep
->size_flock
= 16;
1845 record_tdep
->size_oldold_utsname
= 45;
1846 record_tdep
->size_ustat
= 20;
1847 record_tdep
->size_old_sigaction
= 16;
1848 record_tdep
->size_old_sigset_t
= 4;
1849 record_tdep
->size_rlimit
= 8;
1850 record_tdep
->size_rusage
= 72;
1851 record_tdep
->size_timeval
= 8;
1852 record_tdep
->size_timezone
= 8;
1853 record_tdep
->size_old_gid_t
= 4;
1854 record_tdep
->size_old_uid_t
= 4;
1855 record_tdep
->size_fd_set
= 128;
1856 record_tdep
->size_old_dirent
= 268;
1857 record_tdep
->size_statfs
= 64;
1858 record_tdep
->size_statfs64
= 88;
1859 record_tdep
->size_sockaddr
= 16;
1860 record_tdep
->size_int
= 4;
1861 record_tdep
->size_long
= 4;
1862 record_tdep
->size_ulong
= 4;
1863 record_tdep
->size_msghdr
= 28;
1864 record_tdep
->size_itimerval
= 16;
1865 record_tdep
->size_stat
= 88;
1866 record_tdep
->size_old_utsname
= 325;
1867 record_tdep
->size_sysinfo
= 64;
1868 record_tdep
->size_msqid_ds
= 68;
1869 record_tdep
->size_shmid_ds
= 60;
1870 record_tdep
->size_new_utsname
= 390;
1871 record_tdep
->size_timex
= 128;
1872 record_tdep
->size_mem_dqinfo
= 24;
1873 record_tdep
->size_if_dqblk
= 72;
1874 record_tdep
->size_fs_quota_stat
= 80;
1875 record_tdep
->size_timespec
= 8;
1876 record_tdep
->size_pollfd
= 8;
1877 record_tdep
->size_NFS_FHSIZE
= 32;
1878 record_tdep
->size_knfsd_fh
= 132;
1879 record_tdep
->size_TASK_COMM_LEN
= 16;
1880 record_tdep
->size_sigaction
= 20;
1881 record_tdep
->size_sigset_t
= 8;
1882 record_tdep
->size_siginfo_t
= 128;
1883 record_tdep
->size_cap_user_data_t
= 4;
1884 record_tdep
->size_stack_t
= 12;
1885 record_tdep
->size_off_t
= 4;
1886 record_tdep
->size_stat64
= 104;
1887 record_tdep
->size_gid_t
= 4;
1888 record_tdep
->size_uid_t
= 4;
1889 record_tdep
->size_PAGE_SIZE
= 0x10000; /* 64KB */
1890 record_tdep
->size_flock64
= 32;
1891 record_tdep
->size_io_event
= 32;
1892 record_tdep
->size_iocb
= 64;
1893 record_tdep
->size_epoll_event
= 16;
1894 record_tdep
->size_itimerspec
= 16;
1895 record_tdep
->size_mq_attr
= 32;
1896 record_tdep
->size_termios
= 44;
1897 record_tdep
->size_pid_t
= 4;
1898 record_tdep
->size_winsize
= 8;
1899 record_tdep
->size_serial_struct
= 60;
1900 record_tdep
->size_serial_icounter_struct
= 80;
1901 record_tdep
->size_size_t
= 4;
1902 record_tdep
->size_iovec
= 8;
1903 record_tdep
->size_time_t
= 4;
1906 internal_error (_("unexpected wordsize"));
1908 /* These values are the second argument of system call "sys_fcntl"
1909 and "sys_fcntl64". They are obtained from Linux Kernel source. */
1910 record_tdep
->fcntl_F_GETLK
= 5;
1911 record_tdep
->fcntl_F_GETLK64
= 12;
1912 record_tdep
->fcntl_F_SETLK64
= 13;
1913 record_tdep
->fcntl_F_SETLKW64
= 14;
1915 record_tdep
->arg1
= PPC_R0_REGNUM
+ 3;
1916 record_tdep
->arg2
= PPC_R0_REGNUM
+ 4;
1917 record_tdep
->arg3
= PPC_R0_REGNUM
+ 5;
1918 record_tdep
->arg4
= PPC_R0_REGNUM
+ 6;
1919 record_tdep
->arg5
= PPC_R0_REGNUM
+ 7;
1920 record_tdep
->arg6
= PPC_R0_REGNUM
+ 8;
1922 /* These values are the second argument of system call "sys_ioctl".
1923 They are obtained from Linux Kernel source.
1924 See arch/powerpc/include/uapi/asm/ioctls.h. */
1925 record_tdep
->ioctl_TCGETA
= 0x40147417;
1926 record_tdep
->ioctl_TCSETA
= 0x80147418;
1927 record_tdep
->ioctl_TCSETAW
= 0x80147419;
1928 record_tdep
->ioctl_TCSETAF
= 0x8014741c;
1929 record_tdep
->ioctl_TCGETS
= 0x40007413 | (SIZE_OF_STRUCT_TERMIOS
<< 16);
1930 record_tdep
->ioctl_TCSETS
= 0x80007414 | (SIZE_OF_STRUCT_TERMIOS
<< 16);
1931 record_tdep
->ioctl_TCSETSW
= 0x80007415 | (SIZE_OF_STRUCT_TERMIOS
<< 16);
1932 record_tdep
->ioctl_TCSETSF
= 0x80007416 | (SIZE_OF_STRUCT_TERMIOS
<< 16);
1934 record_tdep
->ioctl_TCSBRK
= 0x2000741d;
1935 record_tdep
->ioctl_TCXONC
= 0x2000741e;
1936 record_tdep
->ioctl_TCFLSH
= 0x2000741f;
1937 record_tdep
->ioctl_TIOCEXCL
= 0x540c;
1938 record_tdep
->ioctl_TIOCNXCL
= 0x540d;
1939 record_tdep
->ioctl_TIOCSCTTY
= 0x540e;
1940 record_tdep
->ioctl_TIOCGPGRP
= 0x40047477;
1941 record_tdep
->ioctl_TIOCSPGRP
= 0x80047476;
1942 record_tdep
->ioctl_TIOCOUTQ
= 0x40047473;
1943 record_tdep
->ioctl_TIOCSTI
= 0x5412;
1944 record_tdep
->ioctl_TIOCGWINSZ
= 0x40087468;
1945 record_tdep
->ioctl_TIOCSWINSZ
= 0x80087467;
1946 record_tdep
->ioctl_TIOCMGET
= 0x5415;
1947 record_tdep
->ioctl_TIOCMBIS
= 0x5416;
1948 record_tdep
->ioctl_TIOCMBIC
= 0x5417;
1949 record_tdep
->ioctl_TIOCMSET
= 0x5418;
1950 record_tdep
->ioctl_TIOCGSOFTCAR
= 0x5419;
1951 record_tdep
->ioctl_TIOCSSOFTCAR
= 0x541a;
1952 record_tdep
->ioctl_FIONREAD
= 0x4004667f;
1953 record_tdep
->ioctl_TIOCINQ
= 0x4004667f;
1954 record_tdep
->ioctl_TIOCLINUX
= 0x541c;
1955 record_tdep
->ioctl_TIOCCONS
= 0x541d;
1956 record_tdep
->ioctl_TIOCGSERIAL
= 0x541e;
1957 record_tdep
->ioctl_TIOCSSERIAL
= 0x541f;
1958 record_tdep
->ioctl_TIOCPKT
= 0x5420;
1959 record_tdep
->ioctl_FIONBIO
= 0x8004667e;
1960 record_tdep
->ioctl_TIOCNOTTY
= 0x5422;
1961 record_tdep
->ioctl_TIOCSETD
= 0x5423;
1962 record_tdep
->ioctl_TIOCGETD
= 0x5424;
1963 record_tdep
->ioctl_TCSBRKP
= 0x5425;
1964 record_tdep
->ioctl_TIOCSBRK
= 0x5427;
1965 record_tdep
->ioctl_TIOCCBRK
= 0x5428;
1966 record_tdep
->ioctl_TIOCGSID
= 0x5429;
1967 record_tdep
->ioctl_TIOCGPTN
= 0x40045430;
1968 record_tdep
->ioctl_TIOCSPTLCK
= 0x80045431;
1969 record_tdep
->ioctl_FIONCLEX
= 0x20006602;
1970 record_tdep
->ioctl_FIOCLEX
= 0x20006601;
1971 record_tdep
->ioctl_FIOASYNC
= 0x8004667d;
1972 record_tdep
->ioctl_TIOCSERCONFIG
= 0x5453;
1973 record_tdep
->ioctl_TIOCSERGWILD
= 0x5454;
1974 record_tdep
->ioctl_TIOCSERSWILD
= 0x5455;
1975 record_tdep
->ioctl_TIOCGLCKTRMIOS
= 0x5456;
1976 record_tdep
->ioctl_TIOCSLCKTRMIOS
= 0x5457;
1977 record_tdep
->ioctl_TIOCSERGSTRUCT
= 0x5458;
1978 record_tdep
->ioctl_TIOCSERGETLSR
= 0x5459;
1979 record_tdep
->ioctl_TIOCSERGETMULTI
= 0x545a;
1980 record_tdep
->ioctl_TIOCSERSETMULTI
= 0x545b;
1981 record_tdep
->ioctl_TIOCMIWAIT
= 0x545c;
1982 record_tdep
->ioctl_TIOCGICOUNT
= 0x545d;
1983 record_tdep
->ioctl_FIOQSIZE
= 0x40086680;
1986 /* Return a floating-point format for a floating-point variable of
1987 length LEN in bits. If non-NULL, NAME is the name of its type.
1988 If no suitable type is found, return NULL. */
1990 static const struct floatformat
**
1991 ppc_floatformat_for_type (struct gdbarch
*gdbarch
,
1992 const char *name
, int len
)
1994 if (len
== 128 && name
)
1996 if (strcmp (name
, "__float128") == 0
1997 || strcmp (name
, "_Float128") == 0
1998 || strcmp (name
, "_Float64x") == 0
1999 || strcmp (name
, "complex _Float128") == 0
2000 || strcmp (name
, "complex _Float64x") == 0)
2001 return floatformats_ieee_quad
;
2003 if (strcmp (name
, "__ibm128") == 0)
2004 return floatformats_ibm_long_double
;
2007 return default_floatformat_for_type (gdbarch
, name
, len
);
2011 linux_dwarf2_omit_typedef_p (struct type
*target_type
,
2012 const char *producer
, const char *name
)
2014 int gcc_major
, gcc_minor
;
2016 if (producer_is_gcc (producer
, &gcc_major
, &gcc_minor
))
2018 if ((target_type
->code () == TYPE_CODE_FLT
2019 || target_type
->code () == TYPE_CODE_COMPLEX
)
2020 && (strcmp (name
, "long double") == 0
2021 || strcmp (name
, "complex long double") == 0))
2023 /* IEEE 128-bit floating point and IBM long double are two
2024 encodings for 128-bit values. The DWARF debug data can't
2025 distinguish between them. See bugzilla:
2026 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104194
2028 A GCC hack was introduced to still allow the debugger to identify
2029 the case where "long double" uses the IEEE 128-bit floating point
2030 format: GCC will emit a bogus DWARF type record pretending that
2031 "long double" is a typedef alias for the _Float128 type.
2033 This hack should not be visible to the GDB user, so we replace
2034 this bogus typedef by a normal floating-point type, copying the
2035 format information from the target type of the bogus typedef. */
2042 /* Specify the powerpc64le target triplet.
2043 This can be variations of
2044 ppc64le-{distro}-linux-gcc
2046 powerpc64le-{distro}-linux-gcc. */
2049 ppc64le_gnu_triplet_regexp (struct gdbarch
*gdbarch
)
2051 return "p(ower)?pc64le";
2054 /* Specify the powerpc64 target triplet.
2055 This can be variations of
2056 ppc64-{distro}-linux-gcc
2058 powerpc64-{distro}-linux-gcc. */
2061 ppc64_gnu_triplet_regexp (struct gdbarch
*gdbarch
)
2063 return "p(ower)?pc64";
2066 /* Implement the linux_gcc_target_options method. */
2069 ppc64_linux_gcc_target_options (struct gdbarch
*gdbarch
)
2074 static displaced_step_prepare_status
2075 ppc_linux_displaced_step_prepare (gdbarch
*arch
, thread_info
*thread
,
2076 CORE_ADDR
&displaced_pc
)
2078 ppc_inferior_data
*per_inferior
= get_ppc_per_inferior (thread
->inf
);
2079 if (!per_inferior
->disp_step_buf
.has_value ())
2081 /* Figure out where the displaced step buffer is. */
2082 CORE_ADDR disp_step_buf_addr
2083 = linux_displaced_step_location (thread
->inf
->arch ());
2085 per_inferior
->disp_step_buf
.emplace (disp_step_buf_addr
);
2088 return per_inferior
->disp_step_buf
->prepare (thread
, displaced_pc
);
2092 ppc_linux_init_abi (struct gdbarch_info info
,
2093 struct gdbarch
*gdbarch
)
2095 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
2096 struct tdesc_arch_data
*tdesc_data
= info
.tdesc_data
;
2097 static const char *const stap_integer_prefixes
[] = { "i", NULL
};
2098 static const char *const stap_register_indirection_prefixes
[] = { "(",
2100 static const char *const stap_register_indirection_suffixes
[] = { ")",
2103 linux_init_abi (info
, gdbarch
, 0);
2105 /* PPC GNU/Linux uses either 64-bit or 128-bit long doubles; where
2106 128-bit, they can be either IBM long double or IEEE quad long double.
2107 The 64-bit long double case will be detected automatically using
2108 the size specified in debug info. We use a .gnu.attribute flag
2109 to distinguish between the IBM long double and IEEE quad cases. */
2110 set_gdbarch_long_double_bit (gdbarch
, 16 * TARGET_CHAR_BIT
);
2111 if (tdep
->long_double_abi
== POWERPC_LONG_DOUBLE_IEEE128
)
2112 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_quad
);
2114 set_gdbarch_long_double_format (gdbarch
, floatformats_ibm_long_double
);
2116 /* Support for floating-point data type variants. */
2117 set_gdbarch_floatformat_for_type (gdbarch
, ppc_floatformat_for_type
);
2119 /* Support for replacing typedef record. */
2120 set_gdbarch_dwarf2_omit_typedef_p (gdbarch
, linux_dwarf2_omit_typedef_p
);
2122 /* Handle inferior calls during interrupted system calls. */
2123 set_gdbarch_write_pc (gdbarch
, ppc_linux_write_pc
);
2125 /* Get the syscall number from the arch's register. */
2126 set_gdbarch_get_syscall_number (gdbarch
, ppc_linux_get_syscall_number
);
2128 /* SystemTap functions. */
2129 set_gdbarch_stap_integer_prefixes (gdbarch
, stap_integer_prefixes
);
2130 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
2131 stap_register_indirection_prefixes
);
2132 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
2133 stap_register_indirection_suffixes
);
2134 set_gdbarch_stap_gdb_register_prefix (gdbarch
, "r");
2135 set_gdbarch_stap_is_single_operand (gdbarch
, ppc_stap_is_single_operand
);
2136 set_gdbarch_stap_parse_special_token (gdbarch
,
2137 ppc_stap_parse_special_token
);
2139 if (tdep
->wordsize
== 4)
2141 /* Until November 2001, gcc did not comply with the 32 bit SysV
2142 R4 ABI requirement that structures less than or equal to 8
2143 bytes should be returned in registers. Instead GCC was using
2144 the AIX/PowerOpen ABI - everything returned in memory
2145 (well ignoring vectors that is). When this was corrected, it
2146 wasn't fixed for GNU/Linux native platform. Use the
2147 PowerOpen struct convention. */
2148 set_gdbarch_return_value_as_value (gdbarch
, ppc_linux_return_value
);
2149 set_gdbarch_return_value (gdbarch
, nullptr);
2151 set_gdbarch_memory_remove_breakpoint (gdbarch
,
2152 ppc_linux_memory_remove_breakpoint
);
2154 /* Shared library handling. */
2155 set_gdbarch_skip_trampoline_code (gdbarch
, ppc_skip_trampoline_code
);
2156 set_solib_svr4_fetch_link_map_offsets
2157 (gdbarch
, linux_ilp32_fetch_link_map_offsets
);
2159 /* Setting the correct XML syscall filename. */
2160 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_PPC
);
2163 tramp_frame_prepend_unwinder (gdbarch
,
2164 &ppc32_linux_sigaction_tramp_frame
);
2165 tramp_frame_prepend_unwinder (gdbarch
,
2166 &ppc32_linux_sighandler_tramp_frame
);
2168 /* BFD target for core files. */
2169 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
2170 set_gdbarch_gcore_bfd_target (gdbarch
, "elf32-powerpcle");
2172 set_gdbarch_gcore_bfd_target (gdbarch
, "elf32-powerpc");
2174 if (powerpc_so_ops
.in_dynsym_resolve_code
== NULL
)
2176 powerpc_so_ops
= svr4_so_ops
;
2177 /* Override dynamic resolve function. */
2178 powerpc_so_ops
.in_dynsym_resolve_code
=
2179 powerpc_linux_in_dynsym_resolve_code
;
2181 set_gdbarch_so_ops (gdbarch
, &powerpc_so_ops
);
2183 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
2186 if (tdep
->wordsize
== 8)
2188 if (tdep
->elf_abi
== POWERPC_ELF_V1
)
2190 /* Handle PPC GNU/Linux 64-bit function pointers (which are really
2191 function descriptors). */
2192 set_gdbarch_convert_from_func_ptr_addr
2193 (gdbarch
, ppc64_convert_from_func_ptr_addr
);
2195 set_gdbarch_elf_make_msymbol_special
2196 (gdbarch
, ppc64_elf_make_msymbol_special
);
2200 set_gdbarch_elf_make_msymbol_special
2201 (gdbarch
, ppc_elfv2_elf_make_msymbol_special
);
2203 set_gdbarch_skip_entrypoint (gdbarch
, ppc_elfv2_skip_entrypoint
);
2206 /* Shared library handling. */
2207 set_gdbarch_skip_trampoline_code (gdbarch
, ppc64_skip_trampoline_code
);
2208 set_solib_svr4_fetch_link_map_offsets
2209 (gdbarch
, linux_lp64_fetch_link_map_offsets
);
2211 /* Setting the correct XML syscall filename. */
2212 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_PPC64
);
2215 tramp_frame_prepend_unwinder (gdbarch
,
2216 &ppc64_linux_sigaction_tramp_frame
);
2217 tramp_frame_prepend_unwinder (gdbarch
,
2218 &ppc64_linux_sighandler_tramp_frame
);
2220 /* BFD target for core files. */
2221 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
2222 set_gdbarch_gcore_bfd_target (gdbarch
, "elf64-powerpcle");
2224 set_gdbarch_gcore_bfd_target (gdbarch
, "elf64-powerpc");
2225 /* Set compiler triplet. */
2226 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
2227 set_gdbarch_gnu_triplet_regexp (gdbarch
, ppc64le_gnu_triplet_regexp
);
2229 set_gdbarch_gnu_triplet_regexp (gdbarch
, ppc64_gnu_triplet_regexp
);
2230 /* Set GCC target options. */
2231 set_gdbarch_gcc_target_options (gdbarch
, ppc64_linux_gcc_target_options
);
2234 set_gdbarch_core_read_description (gdbarch
, ppc_linux_core_read_description
);
2235 set_gdbarch_iterate_over_regset_sections (gdbarch
,
2236 ppc_linux_iterate_over_regset_sections
);
2238 /* Enable TLS support. */
2239 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
2240 svr4_fetch_objfile_link_map
);
2244 const struct tdesc_feature
*feature
;
2246 /* If we have target-described registers, then we can safely
2247 reserve a number for PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM
2248 (whether they are described or not). */
2249 gdb_assert (gdbarch_num_regs (gdbarch
) <= PPC_ORIG_R3_REGNUM
);
2250 set_gdbarch_num_regs (gdbarch
, PPC_TRAP_REGNUM
+ 1);
2252 /* If they are present, then assign them to the reserved number. */
2253 feature
= tdesc_find_feature (info
.target_desc
,
2254 "org.gnu.gdb.power.linux");
2255 if (feature
!= NULL
)
2257 tdesc_numbered_register (feature
, tdesc_data
,
2258 PPC_ORIG_R3_REGNUM
, "orig_r3");
2259 tdesc_numbered_register (feature
, tdesc_data
,
2260 PPC_TRAP_REGNUM
, "trap");
2264 /* Support reverse debugging. */
2265 set_gdbarch_process_record (gdbarch
, ppc_process_record
);
2266 set_gdbarch_process_record_signal (gdbarch
, ppc_linux_record_signal
);
2267 tdep
->ppc_syscall_record
= ppc_linux_syscall_record
;
2269 ppc_init_linux_record_tdep (&ppc_linux_record_tdep
, 4);
2270 ppc_init_linux_record_tdep (&ppc64_linux_record_tdep
, 8);
2272 /* Setup displaced stepping. */
2273 set_gdbarch_displaced_step_prepare (gdbarch
,
2274 ppc_linux_displaced_step_prepare
);
2278 void _initialize_ppc_linux_tdep ();
2280 _initialize_ppc_linux_tdep ()
2282 /* Register for all sub-families of the POWER/PowerPC: 32-bit and
2283 64-bit PowerPC, and the older rs6k. */
2284 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc
, GDB_OSABI_LINUX
,
2285 ppc_linux_init_abi
);
2286 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc64
, GDB_OSABI_LINUX
,
2287 ppc_linux_init_abi
);
2288 gdbarch_register_osabi (bfd_arch_rs6000
, bfd_mach_rs6k
, GDB_OSABI_LINUX
,
2289 ppc_linux_init_abi
);
2291 /* Initialize the Linux target descriptions. */
2292 initialize_tdesc_powerpc_32l ();
2293 initialize_tdesc_powerpc_altivec32l ();
2294 initialize_tdesc_powerpc_vsx32l ();
2295 initialize_tdesc_powerpc_isa205_32l ();
2296 initialize_tdesc_powerpc_isa205_altivec32l ();
2297 initialize_tdesc_powerpc_isa205_vsx32l ();
2298 initialize_tdesc_powerpc_isa205_ppr_dscr_vsx32l ();
2299 initialize_tdesc_powerpc_isa207_vsx32l ();
2300 initialize_tdesc_powerpc_isa207_htm_vsx32l ();
2301 initialize_tdesc_powerpc_64l ();
2302 initialize_tdesc_powerpc_altivec64l ();
2303 initialize_tdesc_powerpc_vsx64l ();
2304 initialize_tdesc_powerpc_isa205_64l ();
2305 initialize_tdesc_powerpc_isa205_altivec64l ();
2306 initialize_tdesc_powerpc_isa205_vsx64l ();
2307 initialize_tdesc_powerpc_isa205_ppr_dscr_vsx64l ();
2308 initialize_tdesc_powerpc_isa207_vsx64l ();
2309 initialize_tdesc_powerpc_isa207_htm_vsx64l ();
2310 initialize_tdesc_powerpc_e500l ();