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"
66 #include "features/rs6000/powerpc-32l.c"
67 #include "features/rs6000/powerpc-altivec32l.c"
68 #include "features/rs6000/powerpc-vsx32l.c"
69 #include "features/rs6000/powerpc-isa205-32l.c"
70 #include "features/rs6000/powerpc-isa205-altivec32l.c"
71 #include "features/rs6000/powerpc-isa205-vsx32l.c"
72 #include "features/rs6000/powerpc-isa205-ppr-dscr-vsx32l.c"
73 #include "features/rs6000/powerpc-isa207-vsx32l.c"
74 #include "features/rs6000/powerpc-isa207-htm-vsx32l.c"
75 #include "features/rs6000/powerpc-64l.c"
76 #include "features/rs6000/powerpc-altivec64l.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-isa205-ppr-dscr-vsx64l.c"
82 #include "features/rs6000/powerpc-isa207-vsx64l.c"
83 #include "features/rs6000/powerpc-isa207-htm-vsx64l.c"
84 #include "features/rs6000/powerpc-e500l.c"
86 /* Shared library operations for PowerPC-Linux. */
87 static struct target_so_ops powerpc_so_ops
;
89 /* The syscall's XML filename for PPC and PPC64. */
90 #define XML_SYSCALL_FILENAME_PPC "syscalls/ppc-linux.xml"
91 #define XML_SYSCALL_FILENAME_PPC64 "syscalls/ppc64-linux.xml"
93 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
94 in much the same fashion as memory_remove_breakpoint in mem-break.c,
95 but is careful not to write back the previous contents if the code
96 in question has changed in between inserting the breakpoint and
99 Here is the problem that we're trying to solve...
101 Once upon a time, before introducing this function to remove
102 breakpoints from the inferior, setting a breakpoint on a shared
103 library function prior to running the program would not work
104 properly. In order to understand the problem, it is first
105 necessary to understand a little bit about dynamic linking on
108 A call to a shared library function is accomplished via a bl
109 (branch-and-link) instruction whose branch target is an entry
110 in the procedure linkage table (PLT). The PLT in the object
111 file is uninitialized. To gdb, prior to running the program, the
112 entries in the PLT are all zeros.
114 Once the program starts running, the shared libraries are loaded
115 and the procedure linkage table is initialized, but the entries in
116 the table are not (necessarily) resolved. Once a function is
117 actually called, the code in the PLT is hit and the function is
118 resolved. In order to better illustrate this, an example is in
119 order; the following example is from the gdb testsuite.
121 We start the program shmain.
123 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
126 We place two breakpoints, one on shr1 and the other on main.
129 Breakpoint 1 at 0x100409d4
131 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
133 Examine the instruction (and the immediatly following instruction)
134 upon which the breakpoint was placed. Note that the PLT entry
135 for shr1 contains zeros.
137 (gdb) x/2i 0x100409d4
138 0x100409d4 <shr1>: .long 0x0
139 0x100409d8 <shr1+4>: .long 0x0
144 Starting program: gdb.base/shmain
145 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
147 Breakpoint 2, main ()
148 at gdb.base/shmain.c:44
151 Examine the PLT again. Note that the loading of the shared
152 library has initialized the PLT to code which loads a constant
153 (which I think is an index into the GOT) into r11 and then
154 branches a short distance to the code which actually does the
157 (gdb) x/2i 0x100409d4
158 0x100409d4 <shr1>: li r11,4
159 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
163 Breakpoint 1, shr1 (x=1)
164 at gdb.base/shr1.c:19
167 Now we've hit the breakpoint at shr1. (The breakpoint was
168 reset from the PLT entry to the actual shr1 function after the
169 shared library was loaded.) Note that the PLT entry has been
170 resolved to contain a branch that takes us directly to shr1.
171 (The real one, not the PLT entry.)
173 (gdb) x/2i 0x100409d4
174 0x100409d4 <shr1>: b 0xffaf76c <shr1>
175 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
177 The thing to note here is that the PLT entry for shr1 has been
180 Now the problem should be obvious. GDB places a breakpoint (a
181 trap instruction) on the zero value of the PLT entry for shr1.
182 Later on, after the shared library had been loaded and the PLT
183 initialized, GDB gets a signal indicating this fact and attempts
184 (as it always does when it stops) to remove all the breakpoints.
186 The breakpoint removal was causing the former contents (a zero
187 word) to be written back to the now initialized PLT entry thus
188 destroying a portion of the initialization that had occurred only a
189 short time ago. When execution continued, the zero word would be
190 executed as an instruction an illegal instruction trap was
191 generated instead. (0 is not a legal instruction.)
193 The fix for this problem was fairly straightforward. The function
194 memory_remove_breakpoint from mem-break.c was copied to this file,
195 modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
196 In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
199 The differences between ppc_linux_memory_remove_breakpoint () and
200 memory_remove_breakpoint () are minor. All that the former does
201 that the latter does not is check to make sure that the breakpoint
202 location actually contains a breakpoint (trap instruction) prior
203 to attempting to write back the old contents. If it does contain
204 a trap instruction, we allow the old contents to be written back.
205 Otherwise, we silently do nothing.
207 The big question is whether memory_remove_breakpoint () should be
208 changed to have the same functionality. The downside is that more
209 traffic is generated for remote targets since we'll have an extra
210 fetch of a memory word each time a breakpoint is removed.
212 For the time being, we'll leave this self-modifying-code-friendly
213 version in ppc-linux-tdep.c, but it ought to be migrated somewhere
214 else in the event that some other platform has similar needs with
215 regard to removing breakpoints in some potentially self modifying
218 ppc_linux_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
219 struct bp_target_info
*bp_tgt
)
221 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
222 const unsigned char *bp
;
225 gdb_byte old_contents
[BREAKPOINT_MAX
];
227 /* Determine appropriate breakpoint contents and size for this address. */
228 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bplen
);
230 /* Make sure we see the memory breakpoints. */
231 scoped_restore restore_memory
232 = make_scoped_restore_show_memory_breakpoints (1);
233 val
= target_read_memory (addr
, old_contents
, bplen
);
235 /* If our breakpoint is no longer at the address, this means that the
236 program modified the code on us, so it is wrong to put back the
238 if (val
== 0 && memcmp (bp
, old_contents
, bplen
) == 0)
239 val
= target_write_raw_memory (addr
, bp_tgt
->shadow_contents
, bplen
);
244 /* For historic reasons, PPC 32 GNU/Linux follows PowerOpen rather
245 than the 32 bit SYSV R4 ABI structure return convention - all
246 structures, no matter their size, are put in memory. Vectors,
247 which were added later, do get returned in a register though. */
249 static enum return_value_convention
250 ppc_linux_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
251 struct type
*valtype
, struct regcache
*regcache
,
252 struct value
**read_value
, const gdb_byte
*writebuf
)
254 gdb_byte
*readbuf
= nullptr;
255 if (read_value
!= nullptr)
257 *read_value
= allocate_value (valtype
);
258 readbuf
= value_contents_raw (*read_value
).data ();
261 if ((valtype
->code () == TYPE_CODE_STRUCT
262 || valtype
->code () == TYPE_CODE_UNION
)
263 && !((valtype
->length () == 16 || valtype
->length () == 8)
264 && valtype
->is_vector ()))
265 return RETURN_VALUE_STRUCT_CONVENTION
;
267 return ppc_sysv_abi_return_value (gdbarch
, function
, valtype
, regcache
,
271 /* PLT stub in an executable. */
272 static const struct ppc_insn_pattern powerpc32_plt_stub
[] =
274 { 0xffff0000, 0x3d600000, 0 }, /* lis r11, xxxx */
275 { 0xffff0000, 0x816b0000, 0 }, /* lwz r11, xxxx(r11) */
276 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
277 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
281 /* PLT stubs in a shared library or PIE.
282 The first variant is used when the PLT entry is within +/-32k of
283 the GOT pointer (r30). */
284 static const struct ppc_insn_pattern powerpc32_plt_stub_so_1
[] =
286 { 0xffff0000, 0x817e0000, 0 }, /* lwz r11, xxxx(r30) */
287 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
288 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
292 /* The second variant is used when the PLT entry is more than +/-32k
293 from the GOT pointer (r30). */
294 static const struct ppc_insn_pattern powerpc32_plt_stub_so_2
[] =
296 { 0xffff0000, 0x3d7e0000, 0 }, /* addis r11, r30, xxxx */
297 { 0xffff0000, 0x816b0000, 0 }, /* lwz r11, xxxx(r11) */
298 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
299 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
303 /* The max number of insns we check using ppc_insns_match_pattern. */
304 #define POWERPC32_PLT_CHECK_LEN (ARRAY_SIZE (powerpc32_plt_stub) - 1)
306 /* Check if PC is in PLT stub. For non-secure PLT, stub is in .plt
307 section. For secure PLT, stub is in .text and we need to check
308 instruction patterns. */
311 powerpc_linux_in_dynsym_resolve_code (CORE_ADDR pc
)
313 struct bound_minimal_symbol sym
;
315 /* Check whether PC is in the dynamic linker. This also checks
316 whether it is in the .plt section, used by non-PIC executables. */
317 if (svr4_in_dynsym_resolve_code (pc
))
320 /* Check if we are in the resolver. */
321 sym
= lookup_minimal_symbol_by_pc (pc
);
322 if (sym
.minsym
!= NULL
323 && (strcmp (sym
.minsym
->linkage_name (), "__glink") == 0
324 || strcmp (sym
.minsym
->linkage_name (), "__glink_PLTresolve") == 0))
330 /* Follow PLT stub to actual routine.
332 When the execution direction is EXEC_REVERSE, scan backward to
333 check whether we are in the middle of a PLT stub. Currently,
334 we only look-behind at most 4 instructions (the max length of a PLT
338 ppc_skip_trampoline_code (frame_info_ptr frame
, CORE_ADDR pc
)
340 unsigned int insnbuf
[POWERPC32_PLT_CHECK_LEN
];
341 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
342 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
343 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
344 CORE_ADDR target
= 0;
348 /* When reverse-debugging, scan backward to check whether we are
349 in the middle of trampoline code. */
350 if (execution_direction
== EXEC_REVERSE
)
351 scan_limit
= 4; /* At most 4 instructions. */
353 for (i
= 0; i
< scan_limit
; i
++)
355 if (ppc_insns_match_pattern (frame
, pc
, powerpc32_plt_stub
, insnbuf
))
357 /* Calculate PLT entry address from
359 lwz r11, xxxx(r11). */
360 target
= ((ppc_insn_d_field (insnbuf
[0]) << 16)
361 + ppc_insn_d_field (insnbuf
[1]));
363 else if (i
< ARRAY_SIZE (powerpc32_plt_stub_so_1
) - 1
364 && ppc_insns_match_pattern (frame
, pc
, powerpc32_plt_stub_so_1
,
367 /* Calculate PLT entry address from
368 lwz r11, xxxx(r30). */
369 target
= (ppc_insn_d_field (insnbuf
[0])
370 + get_frame_register_unsigned (frame
,
371 tdep
->ppc_gp0_regnum
+ 30));
373 else if (ppc_insns_match_pattern (frame
, pc
, powerpc32_plt_stub_so_2
,
376 /* Calculate PLT entry address from
378 lwz r11, xxxx(r11). */
379 target
= ((ppc_insn_d_field (insnbuf
[0]) << 16)
380 + ppc_insn_d_field (insnbuf
[1])
381 + get_frame_register_unsigned (frame
,
382 tdep
->ppc_gp0_regnum
+ 30));
386 /* Scan backward one more instruction if it doesn't match. */
391 target
= read_memory_unsigned_integer (target
, 4, byte_order
);
398 /* Wrappers to handle Linux-only registers. */
401 ppc_linux_supply_gregset (const struct regset
*regset
,
402 struct regcache
*regcache
,
403 int regnum
, const void *gregs
, size_t len
)
405 const struct ppc_reg_offsets
*offsets
406 = (const struct ppc_reg_offsets
*) regset
->regmap
;
408 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
410 if (ppc_linux_trap_reg_p (regcache
->arch ()))
412 /* "orig_r3" is stored 2 slots after "pc". */
413 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
414 ppc_supply_reg (regcache
, PPC_ORIG_R3_REGNUM
, (const gdb_byte
*) gregs
,
415 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
418 /* "trap" is stored 8 slots after "pc". */
419 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
420 ppc_supply_reg (regcache
, PPC_TRAP_REGNUM
, (const gdb_byte
*) gregs
,
421 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
427 ppc_linux_collect_gregset (const struct regset
*regset
,
428 const struct regcache
*regcache
,
429 int regnum
, void *gregs
, size_t len
)
431 const struct ppc_reg_offsets
*offsets
432 = (const struct ppc_reg_offsets
*) regset
->regmap
;
434 /* Clear areas in the linux gregset not written elsewhere. */
436 memset (gregs
, 0, len
);
438 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
440 if (ppc_linux_trap_reg_p (regcache
->arch ()))
442 /* "orig_r3" is stored 2 slots after "pc". */
443 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
444 ppc_collect_reg (regcache
, PPC_ORIG_R3_REGNUM
, (gdb_byte
*) gregs
,
445 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
448 /* "trap" is stored 8 slots after "pc". */
449 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
450 ppc_collect_reg (regcache
, PPC_TRAP_REGNUM
, (gdb_byte
*) gregs
,
451 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
456 /* Regset descriptions. */
457 static const struct ppc_reg_offsets ppc32_linux_reg_offsets
=
459 /* General-purpose registers. */
460 /* .r0_offset = */ 0,
463 /* .pc_offset = */ 128,
464 /* .ps_offset = */ 132,
465 /* .cr_offset = */ 152,
466 /* .lr_offset = */ 144,
467 /* .ctr_offset = */ 140,
468 /* .xer_offset = */ 148,
469 /* .mq_offset = */ 156,
471 /* Floating-point registers. */
472 /* .f0_offset = */ 0,
473 /* .fpscr_offset = */ 256,
474 /* .fpscr_size = */ 8
477 static const struct ppc_reg_offsets ppc64_linux_reg_offsets
=
479 /* General-purpose registers. */
480 /* .r0_offset = */ 0,
483 /* .pc_offset = */ 256,
484 /* .ps_offset = */ 264,
485 /* .cr_offset = */ 304,
486 /* .lr_offset = */ 288,
487 /* .ctr_offset = */ 280,
488 /* .xer_offset = */ 296,
489 /* .mq_offset = */ 312,
491 /* Floating-point registers. */
492 /* .f0_offset = */ 0,
493 /* .fpscr_offset = */ 256,
494 /* .fpscr_size = */ 8
497 static const struct regset ppc32_linux_gregset
= {
498 &ppc32_linux_reg_offsets
,
499 ppc_linux_supply_gregset
,
500 ppc_linux_collect_gregset
503 static const struct regset ppc64_linux_gregset
= {
504 &ppc64_linux_reg_offsets
,
505 ppc_linux_supply_gregset
,
506 ppc_linux_collect_gregset
509 static const struct regset ppc32_linux_fpregset
= {
510 &ppc32_linux_reg_offsets
,
515 static const struct regcache_map_entry ppc32_le_linux_vrregmap
[] =
517 { 32, PPC_VR0_REGNUM
, 16 },
518 { 1, PPC_VSCR_REGNUM
, 4 },
519 { 1, REGCACHE_MAP_SKIP
, 12 },
520 { 1, PPC_VRSAVE_REGNUM
, 4 },
521 { 1, REGCACHE_MAP_SKIP
, 12 },
525 static const struct regcache_map_entry ppc32_be_linux_vrregmap
[] =
527 { 32, PPC_VR0_REGNUM
, 16 },
528 { 1, REGCACHE_MAP_SKIP
, 12},
529 { 1, PPC_VSCR_REGNUM
, 4 },
530 { 1, PPC_VRSAVE_REGNUM
, 4 },
531 { 1, REGCACHE_MAP_SKIP
, 12 },
535 static const struct regset ppc32_le_linux_vrregset
= {
536 ppc32_le_linux_vrregmap
,
537 regcache_supply_regset
,
538 regcache_collect_regset
541 static const struct regset ppc32_be_linux_vrregset
= {
542 ppc32_be_linux_vrregmap
,
543 regcache_supply_regset
,
544 regcache_collect_regset
547 static const struct regcache_map_entry ppc32_linux_vsxregmap
[] =
549 { 32, PPC_VSR0_UPPER_REGNUM
, 8 },
553 static const struct regset ppc32_linux_vsxregset
= {
554 ppc32_linux_vsxregmap
,
555 regcache_supply_regset
,
556 regcache_collect_regset
559 /* Program Priorty Register regmap. */
561 static const struct regcache_map_entry ppc32_regmap_ppr
[] =
563 { 1, PPC_PPR_REGNUM
, 8 },
567 /* Program Priorty Register regset. */
569 const struct regset ppc32_linux_pprregset
= {
571 regcache_supply_regset
,
572 regcache_collect_regset
575 /* Data Stream Control Register regmap. */
577 static const struct regcache_map_entry ppc32_regmap_dscr
[] =
579 { 1, PPC_DSCR_REGNUM
, 8 },
583 /* Data Stream Control Register regset. */
585 const struct regset ppc32_linux_dscrregset
= {
587 regcache_supply_regset
,
588 regcache_collect_regset
591 /* Target Address Register regmap. */
593 static const struct regcache_map_entry ppc32_regmap_tar
[] =
595 { 1, PPC_TAR_REGNUM
, 8 },
599 /* Target Address Register regset. */
601 const struct regset ppc32_linux_tarregset
= {
603 regcache_supply_regset
,
604 regcache_collect_regset
607 /* Event-Based Branching regmap. */
609 static const struct regcache_map_entry ppc32_regmap_ebb
[] =
611 { 1, PPC_EBBRR_REGNUM
, 8 },
612 { 1, PPC_EBBHR_REGNUM
, 8 },
613 { 1, PPC_BESCR_REGNUM
, 8 },
617 /* Event-Based Branching regset. */
619 const struct regset ppc32_linux_ebbregset
= {
621 regcache_supply_regset
,
622 regcache_collect_regset
625 /* Performance Monitoring Unit regmap. */
627 static const struct regcache_map_entry ppc32_regmap_pmu
[] =
629 { 1, PPC_SIAR_REGNUM
, 8 },
630 { 1, PPC_SDAR_REGNUM
, 8 },
631 { 1, PPC_SIER_REGNUM
, 8 },
632 { 1, PPC_MMCR2_REGNUM
, 8 },
633 { 1, PPC_MMCR0_REGNUM
, 8 },
637 /* Performance Monitoring Unit regset. */
639 const struct regset ppc32_linux_pmuregset
= {
641 regcache_supply_regset
,
642 regcache_collect_regset
645 /* Hardware Transactional Memory special-purpose register regmap. */
647 static const struct regcache_map_entry ppc32_regmap_tm_spr
[] =
649 { 1, PPC_TFHAR_REGNUM
, 8 },
650 { 1, PPC_TEXASR_REGNUM
, 8 },
651 { 1, PPC_TFIAR_REGNUM
, 8 },
655 /* Hardware Transactional Memory special-purpose register regset. */
657 const struct regset ppc32_linux_tm_sprregset
= {
659 regcache_supply_regset
,
660 regcache_collect_regset
663 /* Regmaps for the Hardware Transactional Memory checkpointed
664 general-purpose regsets for 32-bit, 64-bit big-endian, and 64-bit
665 little endian targets. The ptrace and core file buffers for 64-bit
666 targets use 8-byte fields for the 4-byte registers, and the
667 position of the register in the fields depends on the endianness.
668 The 32-bit regmap is the same for both endian types because the
669 fields are all 4-byte long.
671 The layout of checkpointed GPR regset is the same as a regular
672 struct pt_regs, but we skip all registers that are not actually
673 checkpointed by the processor (e.g. msr, nip), except when
674 generating a core file. The 64-bit regset is 48 * 8 bytes long.
675 In some 64-bit kernels, the regset for a 32-bit inferior has the
676 same length, but all the registers are squeezed in the first half
677 (48 * 4 bytes). The pt_regs struct calls the regular cr ccr, but
678 we use ccr for "checkpointed condition register". Note that CR
679 (condition register) field 0 is not checkpointed, but the kernel
680 returns all 4 bytes. The skipped registers should not be touched
681 when writing the regset to the inferior (with
682 PTRACE_SETREGSET). */
684 static const struct regcache_map_entry ppc32_regmap_cgpr
[] =
686 { 32, PPC_CR0_REGNUM
, 4 },
687 { 3, REGCACHE_MAP_SKIP
, 4 }, /* nip, msr, orig_gpr3. */
688 { 1, PPC_CCTR_REGNUM
, 4 },
689 { 1, PPC_CLR_REGNUM
, 4 },
690 { 1, PPC_CXER_REGNUM
, 4 },
691 { 1, PPC_CCR_REGNUM
, 4 },
692 { 9, REGCACHE_MAP_SKIP
, 4 }, /* All the rest. */
696 static const struct regcache_map_entry ppc64_le_regmap_cgpr
[] =
698 { 32, PPC_CR0_REGNUM
, 8 },
699 { 3, REGCACHE_MAP_SKIP
, 8 },
700 { 1, PPC_CCTR_REGNUM
, 8 },
701 { 1, PPC_CLR_REGNUM
, 8 },
702 { 1, PPC_CXER_REGNUM
, 4 },
703 { 1, REGCACHE_MAP_SKIP
, 4 }, /* CXER padding. */
704 { 1, PPC_CCR_REGNUM
, 4 },
705 { 1, REGCACHE_MAP_SKIP
, 4}, /* CCR padding. */
706 { 9, REGCACHE_MAP_SKIP
, 8},
710 static const struct regcache_map_entry ppc64_be_regmap_cgpr
[] =
712 { 32, PPC_CR0_REGNUM
, 8 },
713 { 3, REGCACHE_MAP_SKIP
, 8 },
714 { 1, PPC_CCTR_REGNUM
, 8 },
715 { 1, PPC_CLR_REGNUM
, 8 },
716 { 1, REGCACHE_MAP_SKIP
, 4}, /* CXER padding. */
717 { 1, PPC_CXER_REGNUM
, 4 },
718 { 1, REGCACHE_MAP_SKIP
, 4}, /* CCR padding. */
719 { 1, PPC_CCR_REGNUM
, 4 },
720 { 9, REGCACHE_MAP_SKIP
, 8},
724 /* Regsets for the Hardware Transactional Memory checkpointed
725 general-purpose registers for 32-bit, 64-bit big-endian, and 64-bit
726 little endian targets.
728 Some 64-bit kernels generate a checkpointed gpr note section with
729 48*8 bytes for a 32-bit thread, of which only 48*4 are actually
730 used, so we set the variable size flag in the corresponding regset
731 to accept this case. */
733 static const struct regset ppc32_linux_cgprregset
= {
735 regcache_supply_regset
,
736 regcache_collect_regset
,
740 static const struct regset ppc64_be_linux_cgprregset
= {
741 ppc64_be_regmap_cgpr
,
742 regcache_supply_regset
,
743 regcache_collect_regset
746 static const struct regset ppc64_le_linux_cgprregset
= {
747 ppc64_le_regmap_cgpr
,
748 regcache_supply_regset
,
749 regcache_collect_regset
752 /* Hardware Transactional Memory checkpointed floating-point regmap. */
754 static const struct regcache_map_entry ppc32_regmap_cfpr
[] =
756 { 32, PPC_CF0_REGNUM
, 8 },
757 { 1, PPC_CFPSCR_REGNUM
, 8 },
761 /* Hardware Transactional Memory checkpointed floating-point regset. */
763 const struct regset ppc32_linux_cfprregset
= {
765 regcache_supply_regset
,
766 regcache_collect_regset
769 /* Regmaps for the Hardware Transactional Memory checkpointed vector
770 regsets, for big and little endian targets. The position of the
771 4-byte VSCR in its 16-byte field depends on the endianness. */
773 static const struct regcache_map_entry ppc32_le_regmap_cvmx
[] =
775 { 32, PPC_CVR0_REGNUM
, 16 },
776 { 1, PPC_CVSCR_REGNUM
, 4 },
777 { 1, REGCACHE_MAP_SKIP
, 12 },
778 { 1, PPC_CVRSAVE_REGNUM
, 4 },
779 { 1, REGCACHE_MAP_SKIP
, 12 },
783 static const struct regcache_map_entry ppc32_be_regmap_cvmx
[] =
785 { 32, PPC_CVR0_REGNUM
, 16 },
786 { 1, REGCACHE_MAP_SKIP
, 12 },
787 { 1, PPC_CVSCR_REGNUM
, 4 },
788 { 1, PPC_CVRSAVE_REGNUM
, 4 },
789 { 1, REGCACHE_MAP_SKIP
, 12},
793 /* Hardware Transactional Memory checkpointed vector regsets, for little
794 and big endian targets. */
796 static const struct regset ppc32_le_linux_cvmxregset
= {
797 ppc32_le_regmap_cvmx
,
798 regcache_supply_regset
,
799 regcache_collect_regset
802 static const struct regset ppc32_be_linux_cvmxregset
= {
803 ppc32_be_regmap_cvmx
,
804 regcache_supply_regset
,
805 regcache_collect_regset
808 /* Hardware Transactional Memory checkpointed vector-scalar regmap. */
810 static const struct regcache_map_entry ppc32_regmap_cvsx
[] =
812 { 32, PPC_CVSR0_UPPER_REGNUM
, 8 },
816 /* Hardware Transactional Memory checkpointed vector-scalar regset. */
818 const struct regset ppc32_linux_cvsxregset
= {
820 regcache_supply_regset
,
821 regcache_collect_regset
824 /* Hardware Transactional Memory checkpointed Program Priority Register
827 static const struct regcache_map_entry ppc32_regmap_cppr
[] =
829 { 1, PPC_CPPR_REGNUM
, 8 },
833 /* Hardware Transactional Memory checkpointed Program Priority Register
836 const struct regset ppc32_linux_cpprregset
= {
838 regcache_supply_regset
,
839 regcache_collect_regset
842 /* Hardware Transactional Memory checkpointed Data Stream Control
845 static const struct regcache_map_entry ppc32_regmap_cdscr
[] =
847 { 1, PPC_CDSCR_REGNUM
, 8 },
851 /* Hardware Transactional Memory checkpointed Data Stream Control
854 const struct regset ppc32_linux_cdscrregset
= {
856 regcache_supply_regset
,
857 regcache_collect_regset
860 /* Hardware Transactional Memory checkpointed Target Address Register
863 static const struct regcache_map_entry ppc32_regmap_ctar
[] =
865 { 1, PPC_CTAR_REGNUM
, 8 },
869 /* Hardware Transactional Memory checkpointed Target Address Register
872 const struct regset ppc32_linux_ctarregset
= {
874 regcache_supply_regset
,
875 regcache_collect_regset
878 const struct regset
*
879 ppc_linux_gregset (int wordsize
)
881 return wordsize
== 8 ? &ppc64_linux_gregset
: &ppc32_linux_gregset
;
884 const struct regset
*
885 ppc_linux_fpregset (void)
887 return &ppc32_linux_fpregset
;
890 const struct regset
*
891 ppc_linux_vrregset (struct gdbarch
*gdbarch
)
893 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
894 return &ppc32_be_linux_vrregset
;
896 return &ppc32_le_linux_vrregset
;
899 const struct regset
*
900 ppc_linux_vsxregset (void)
902 return &ppc32_linux_vsxregset
;
905 const struct regset
*
906 ppc_linux_cgprregset (struct gdbarch
*gdbarch
)
908 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
910 if (tdep
->wordsize
== 4)
912 return &ppc32_linux_cgprregset
;
916 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
917 return &ppc64_be_linux_cgprregset
;
919 return &ppc64_le_linux_cgprregset
;
923 const struct regset
*
924 ppc_linux_cvmxregset (struct gdbarch
*gdbarch
)
926 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
927 return &ppc32_be_linux_cvmxregset
;
929 return &ppc32_le_linux_cvmxregset
;
932 /* Collect function used to generate the core note for the
933 checkpointed GPR regset. Here, we don't want to skip the
934 "checkpointed" NIP and MSR, so that the note section we generate is
935 similar to the one generated by the kernel. To avoid having to
936 define additional registers in GDB which are not actually
937 checkpointed in the architecture, we copy TFHAR to the checkpointed
938 NIP slot, which is what the kernel does, and copy the regular MSR
939 to the checkpointed MSR slot, which will have a similar value in
943 ppc_linux_collect_core_cpgrregset (const struct regset
*regset
,
944 const struct regcache
*regcache
,
945 int regnum
, void *buf
, size_t len
)
947 struct gdbarch
*gdbarch
= regcache
->arch ();
948 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
950 const struct regset
*cgprregset
= ppc_linux_cgprregset (gdbarch
);
952 /* We collect the checkpointed GPRs already defined in the regular
953 regmap, then overlay TFHAR/MSR on the checkpointed NIP/MSR
955 cgprregset
->collect_regset (cgprregset
, regcache
, regnum
, buf
, len
);
957 /* Check that we are collecting all the registers, which should be
958 the case when generating a core file. */
962 /* PT_NIP and PT_MSR are 32 and 33 for powerpc. Don't redefine
963 these symbols since this file can run on clients in other
964 architectures where they can already be defined to other
968 /* Check that our buffer is long enough to hold two slots at
969 pt_offset * wordsize, one for NIP and one for MSR. */
970 gdb_assert ((pt_offset
+ 2) * tdep
->wordsize
<= len
);
972 /* TFHAR is 8 bytes wide, but the NIP slot for a 32-bit thread is
973 4-bytes long. We use raw_collect_integer which handles
974 differences in the sizes for the source and destination buffers
975 for both endian modes. */
976 (regcache
->raw_collect_integer
977 (PPC_TFHAR_REGNUM
, ((gdb_byte
*) buf
) + pt_offset
* tdep
->wordsize
,
978 tdep
->wordsize
, false));
982 (regcache
->raw_collect_integer
983 (PPC_MSR_REGNUM
, ((gdb_byte
*) buf
) + pt_offset
* tdep
->wordsize
,
984 tdep
->wordsize
, false));
987 /* Iterate over supported core file register note sections. */
990 ppc_linux_iterate_over_regset_sections (struct gdbarch
*gdbarch
,
991 iterate_over_regset_sections_cb
*cb
,
993 const struct regcache
*regcache
)
995 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
996 int have_altivec
= tdep
->ppc_vr0_regnum
!= -1;
997 int have_vsx
= tdep
->ppc_vsr0_upper_regnum
!= -1;
998 int have_ppr
= tdep
->ppc_ppr_regnum
!= -1;
999 int have_dscr
= tdep
->ppc_dscr_regnum
!= -1;
1000 int have_tar
= tdep
->ppc_tar_regnum
!= -1;
1002 if (tdep
->wordsize
== 4)
1003 cb (".reg", 48 * 4, 48 * 4, &ppc32_linux_gregset
, NULL
, cb_data
);
1005 cb (".reg", 48 * 8, 48 * 8, &ppc64_linux_gregset
, NULL
, cb_data
);
1007 cb (".reg2", 264, 264, &ppc32_linux_fpregset
, NULL
, cb_data
);
1011 const struct regset
*vrregset
= ppc_linux_vrregset (gdbarch
);
1012 cb (".reg-ppc-vmx", PPC_LINUX_SIZEOF_VRREGSET
, PPC_LINUX_SIZEOF_VRREGSET
,
1013 vrregset
, "ppc Altivec", cb_data
);
1017 cb (".reg-ppc-vsx", PPC_LINUX_SIZEOF_VSXREGSET
, PPC_LINUX_SIZEOF_VSXREGSET
,
1018 &ppc32_linux_vsxregset
, "POWER7 VSX", cb_data
);
1021 cb (".reg-ppc-ppr", PPC_LINUX_SIZEOF_PPRREGSET
,
1022 PPC_LINUX_SIZEOF_PPRREGSET
,
1023 &ppc32_linux_pprregset
, "Priority Program Register", cb_data
);
1026 cb (".reg-ppc-dscr", PPC_LINUX_SIZEOF_DSCRREGSET
,
1027 PPC_LINUX_SIZEOF_DSCRREGSET
,
1028 &ppc32_linux_dscrregset
, "Data Stream Control Register",
1032 cb (".reg-ppc-tar", PPC_LINUX_SIZEOF_TARREGSET
,
1033 PPC_LINUX_SIZEOF_TARREGSET
,
1034 &ppc32_linux_tarregset
, "Target Address Register", cb_data
);
1036 /* EBB registers are unavailable when ptrace returns ENODATA. Check
1037 availability when generating a core file (regcache != NULL). */
1039 if (regcache
== NULL
1040 || REG_VALID
== regcache
->get_register_status (PPC_BESCR_REGNUM
))
1041 cb (".reg-ppc-ebb", PPC_LINUX_SIZEOF_EBBREGSET
,
1042 PPC_LINUX_SIZEOF_EBBREGSET
,
1043 &ppc32_linux_ebbregset
, "Event-based Branching Registers",
1046 if (tdep
->ppc_mmcr0_regnum
!= -1)
1047 cb (".reg-ppc-pmu", PPC_LINUX_SIZEOF_PMUREGSET
,
1048 PPC_LINUX_SIZEOF_PMUREGSET
,
1049 &ppc32_linux_pmuregset
, "Performance Monitor Registers",
1052 if (tdep
->have_htm_spr
)
1053 cb (".reg-ppc-tm-spr", PPC_LINUX_SIZEOF_TM_SPRREGSET
,
1054 PPC_LINUX_SIZEOF_TM_SPRREGSET
,
1055 &ppc32_linux_tm_sprregset
,
1056 "Hardware Transactional Memory Special Purpose Registers",
1059 /* Checkpointed registers can be unavailable, don't call back if
1060 we are generating a core file. */
1062 if (tdep
->have_htm_core
)
1064 /* Only generate the checkpointed GPR core note if we also have
1065 access to the HTM SPRs, because we need TFHAR to fill the
1066 "checkpointed" NIP slot. We can read a core file without it
1067 since GDB is not aware of this NIP as a visible register. */
1068 if (regcache
== NULL
||
1069 (REG_VALID
== regcache
->get_register_status (PPC_CR0_REGNUM
)
1070 && tdep
->have_htm_spr
))
1072 int cgpr_size
= (tdep
->wordsize
== 4?
1073 PPC32_LINUX_SIZEOF_CGPRREGSET
1074 : PPC64_LINUX_SIZEOF_CGPRREGSET
);
1076 const struct regset
*cgprregset
=
1077 ppc_linux_cgprregset (gdbarch
);
1079 if (regcache
!= NULL
)
1081 struct regset core_cgprregset
= *cgprregset
;
1083 core_cgprregset
.collect_regset
1084 = ppc_linux_collect_core_cpgrregset
;
1086 cb (".reg-ppc-tm-cgpr",
1087 cgpr_size
, cgpr_size
,
1089 "Checkpointed General Purpose Registers", cb_data
);
1093 cb (".reg-ppc-tm-cgpr",
1094 cgpr_size
, cgpr_size
,
1096 "Checkpointed General Purpose Registers", cb_data
);
1101 if (tdep
->have_htm_fpu
)
1103 if (regcache
== NULL
||
1104 REG_VALID
== regcache
->get_register_status (PPC_CF0_REGNUM
))
1105 cb (".reg-ppc-tm-cfpr", PPC_LINUX_SIZEOF_CFPRREGSET
,
1106 PPC_LINUX_SIZEOF_CFPRREGSET
,
1107 &ppc32_linux_cfprregset
,
1108 "Checkpointed Floating Point Registers", cb_data
);
1111 if (tdep
->have_htm_altivec
)
1113 if (regcache
== NULL
||
1114 REG_VALID
== regcache
->get_register_status (PPC_CVR0_REGNUM
))
1116 const struct regset
*cvmxregset
=
1117 ppc_linux_cvmxregset (gdbarch
);
1119 cb (".reg-ppc-tm-cvmx", PPC_LINUX_SIZEOF_CVMXREGSET
,
1120 PPC_LINUX_SIZEOF_CVMXREGSET
,
1122 "Checkpointed Altivec (VMX) Registers", cb_data
);
1126 if (tdep
->have_htm_vsx
)
1128 if (regcache
== NULL
||
1130 == regcache
->get_register_status (PPC_CVSR0_UPPER_REGNUM
)))
1131 cb (".reg-ppc-tm-cvsx", PPC_LINUX_SIZEOF_CVSXREGSET
,
1132 PPC_LINUX_SIZEOF_CVSXREGSET
,
1133 &ppc32_linux_cvsxregset
,
1134 "Checkpointed VSX Registers", cb_data
);
1137 if (tdep
->ppc_cppr_regnum
!= -1)
1139 if (regcache
== NULL
||
1140 REG_VALID
== regcache
->get_register_status (PPC_CPPR_REGNUM
))
1141 cb (".reg-ppc-tm-cppr", PPC_LINUX_SIZEOF_CPPRREGSET
,
1142 PPC_LINUX_SIZEOF_CPPRREGSET
,
1143 &ppc32_linux_cpprregset
,
1144 "Checkpointed Priority Program Register", cb_data
);
1147 if (tdep
->ppc_cdscr_regnum
!= -1)
1149 if (regcache
== NULL
||
1150 REG_VALID
== regcache
->get_register_status (PPC_CDSCR_REGNUM
))
1151 cb (".reg-ppc-tm-cdscr", PPC_LINUX_SIZEOF_CDSCRREGSET
,
1152 PPC_LINUX_SIZEOF_CDSCRREGSET
,
1153 &ppc32_linux_cdscrregset
,
1154 "Checkpointed Data Stream Control Register", cb_data
);
1157 if (tdep
->ppc_ctar_regnum
)
1159 if ( regcache
== NULL
||
1160 REG_VALID
== regcache
->get_register_status (PPC_CTAR_REGNUM
))
1161 cb (".reg-ppc-tm-ctar", PPC_LINUX_SIZEOF_CTARREGSET
,
1162 PPC_LINUX_SIZEOF_CTARREGSET
,
1163 &ppc32_linux_ctarregset
,
1164 "Checkpointed Target Address Register", cb_data
);
1169 ppc_linux_sigtramp_cache (frame_info_ptr this_frame
,
1170 struct trad_frame_cache
*this_cache
,
1171 CORE_ADDR func
, LONGEST offset
,
1179 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1180 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
1181 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1183 base
= get_frame_register_unsigned (this_frame
,
1184 gdbarch_sp_regnum (gdbarch
));
1185 if (bias
> 0 && get_frame_pc (this_frame
) != func
)
1186 /* See below, some signal trampolines increment the stack as their
1187 first instruction, need to compensate for that. */
1190 /* Find the address of the register buffer pointer. */
1191 regs
= base
+ offset
;
1192 /* Use that to find the address of the corresponding register
1194 gpregs
= read_memory_unsigned_integer (regs
, tdep
->wordsize
, byte_order
);
1195 fpregs
= gpregs
+ 48 * tdep
->wordsize
;
1197 /* General purpose. */
1198 for (i
= 0; i
< 32; i
++)
1200 int regnum
= i
+ tdep
->ppc_gp0_regnum
;
1201 trad_frame_set_reg_addr (this_cache
,
1202 regnum
, gpregs
+ i
* tdep
->wordsize
);
1204 trad_frame_set_reg_addr (this_cache
,
1205 gdbarch_pc_regnum (gdbarch
),
1206 gpregs
+ 32 * tdep
->wordsize
);
1207 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_ctr_regnum
,
1208 gpregs
+ 35 * tdep
->wordsize
);
1209 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_lr_regnum
,
1210 gpregs
+ 36 * tdep
->wordsize
);
1211 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_xer_regnum
,
1212 gpregs
+ 37 * tdep
->wordsize
);
1213 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_cr_regnum
,
1214 gpregs
+ 38 * tdep
->wordsize
);
1216 if (ppc_linux_trap_reg_p (gdbarch
))
1218 trad_frame_set_reg_addr (this_cache
, PPC_ORIG_R3_REGNUM
,
1219 gpregs
+ 34 * tdep
->wordsize
);
1220 trad_frame_set_reg_addr (this_cache
, PPC_TRAP_REGNUM
,
1221 gpregs
+ 40 * tdep
->wordsize
);
1224 if (ppc_floating_point_unit_p (gdbarch
))
1226 /* Floating point registers. */
1227 for (i
= 0; i
< 32; i
++)
1229 int regnum
= i
+ gdbarch_fp0_regnum (gdbarch
);
1230 trad_frame_set_reg_addr (this_cache
, regnum
,
1231 fpregs
+ i
* tdep
->wordsize
);
1233 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_fpscr_regnum
,
1234 fpregs
+ 32 * tdep
->wordsize
);
1236 trad_frame_set_id (this_cache
, frame_id_build (base
, func
));
1240 ppc32_linux_sigaction_cache_init (const struct tramp_frame
*self
,
1241 frame_info_ptr this_frame
,
1242 struct trad_frame_cache
*this_cache
,
1245 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
1246 0xd0 /* Offset to ucontext_t. */
1247 + 0x30 /* Offset to .reg. */,
1252 ppc64_linux_sigaction_cache_init (const struct tramp_frame
*self
,
1253 frame_info_ptr this_frame
,
1254 struct trad_frame_cache
*this_cache
,
1257 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
1258 0x80 /* Offset to ucontext_t. */
1259 + 0xe0 /* Offset to .reg. */,
1264 ppc32_linux_sighandler_cache_init (const struct tramp_frame
*self
,
1265 frame_info_ptr this_frame
,
1266 struct trad_frame_cache
*this_cache
,
1269 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
1270 0x40 /* Offset to ucontext_t. */
1271 + 0x1c /* Offset to .reg. */,
1276 ppc64_linux_sighandler_cache_init (const struct tramp_frame
*self
,
1277 frame_info_ptr this_frame
,
1278 struct trad_frame_cache
*this_cache
,
1281 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
1282 0x80 /* Offset to struct sigcontext. */
1283 + 0x38 /* Offset to .reg. */,
1287 static struct tramp_frame ppc32_linux_sigaction_tramp_frame
= {
1291 { 0x380000ac, ULONGEST_MAX
}, /* li r0, 172 */
1292 { 0x44000002, ULONGEST_MAX
}, /* sc */
1293 { TRAMP_SENTINEL_INSN
},
1295 ppc32_linux_sigaction_cache_init
1297 static struct tramp_frame ppc64_linux_sigaction_tramp_frame
= {
1301 { 0x38210080, ULONGEST_MAX
}, /* addi r1,r1,128 */
1302 { 0x380000ac, ULONGEST_MAX
}, /* li r0, 172 */
1303 { 0x44000002, ULONGEST_MAX
}, /* sc */
1304 { TRAMP_SENTINEL_INSN
},
1306 ppc64_linux_sigaction_cache_init
1308 static struct tramp_frame ppc32_linux_sighandler_tramp_frame
= {
1312 { 0x38000077, ULONGEST_MAX
}, /* li r0,119 */
1313 { 0x44000002, ULONGEST_MAX
}, /* sc */
1314 { TRAMP_SENTINEL_INSN
},
1316 ppc32_linux_sighandler_cache_init
1318 static struct tramp_frame ppc64_linux_sighandler_tramp_frame
= {
1322 { 0x38210080, ULONGEST_MAX
}, /* addi r1,r1,128 */
1323 { 0x38000077, ULONGEST_MAX
}, /* li r0,119 */
1324 { 0x44000002, ULONGEST_MAX
}, /* sc */
1325 { TRAMP_SENTINEL_INSN
},
1327 ppc64_linux_sighandler_cache_init
1330 /* Return 1 if PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM are usable. */
1332 ppc_linux_trap_reg_p (struct gdbarch
*gdbarch
)
1334 /* If we do not have a target description with registers, then
1335 the special registers will not be included in the register set. */
1336 if (!tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
1339 /* If we do, then it is safe to check the size. */
1340 return register_size (gdbarch
, PPC_ORIG_R3_REGNUM
) > 0
1341 && register_size (gdbarch
, PPC_TRAP_REGNUM
) > 0;
1344 /* Return the current system call's number present in the
1345 r0 register. When the function fails, it returns -1. */
1347 ppc_linux_get_syscall_number (struct gdbarch
*gdbarch
,
1348 thread_info
*thread
)
1350 struct regcache
*regcache
= get_thread_regcache (thread
);
1351 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
1352 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1354 /* Make sure we're in a 32- or 64-bit machine */
1355 gdb_assert (tdep
->wordsize
== 4 || tdep
->wordsize
== 8);
1357 /* The content of a register */
1358 gdb::byte_vector
buf (tdep
->wordsize
);
1360 /* Getting the system call number from the register.
1361 When dealing with PowerPC architecture, this information
1362 is stored at 0th register. */
1363 regcache
->cooked_read (tdep
->ppc_gp0_regnum
, buf
.data ());
1365 return extract_signed_integer (buf
.data (), tdep
->wordsize
, byte_order
);
1368 /* PPC process record-replay */
1370 static struct linux_record_tdep ppc_linux_record_tdep
;
1371 static struct linux_record_tdep ppc64_linux_record_tdep
;
1373 /* ppc_canonicalize_syscall maps from the native PowerPC Linux set of
1374 syscall ids into a canonical set of syscall ids used by process
1375 record. (See arch/powerpc/include/uapi/asm/unistd.h in kernel tree.)
1376 Return -1 if this system call is not supported by process record.
1377 Otherwise, return the syscall number for process record of given
1380 static enum gdb_syscall
1381 ppc_canonicalize_syscall (int syscall
, int wordsize
)
1387 else if (syscall
>= 167 && syscall
<= 190) /* Skip query_module 166 */
1388 result
= syscall
+ 1;
1389 else if (syscall
>= 192 && syscall
<= 197) /* mmap2 */
1391 else if (syscall
== 208) /* tkill */
1392 result
= gdb_sys_tkill
;
1393 else if (syscall
>= 207 && syscall
<= 220) /* gettid */
1394 result
= syscall
+ 224 - 207;
1395 else if (syscall
>= 234 && syscall
<= 239) /* exit_group */
1396 result
= syscall
+ 252 - 234;
1397 else if (syscall
>= 240 && syscall
<= 248) /* timer_create */
1398 result
= syscall
+= 259 - 240;
1399 else if (syscall
>= 250 && syscall
<= 251) /* tgkill */
1400 result
= syscall
+ 270 - 250;
1401 else if (syscall
== 286)
1402 result
= gdb_sys_openat
;
1403 else if (syscall
== 291)
1406 result
= gdb_sys_newfstatat
;
1408 result
= gdb_sys_fstatat64
;
1410 else if (syscall
== 317)
1411 result
= gdb_sys_pipe2
;
1412 else if (syscall
== 336)
1413 result
= gdb_sys_recv
;
1414 else if (syscall
== 337)
1415 result
= gdb_sys_recvfrom
;
1416 else if (syscall
== 342)
1417 result
= gdb_sys_recvmsg
;
1418 else if (syscall
== 359)
1419 result
= gdb_sys_getrandom
;
1421 return (enum gdb_syscall
) result
;
1424 /* Record registers which might be clobbered during system call.
1425 Return 0 if successful. */
1428 ppc_linux_syscall_record (struct regcache
*regcache
)
1430 struct gdbarch
*gdbarch
= regcache
->arch ();
1431 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
1433 enum gdb_syscall syscall_gdb
;
1436 regcache_raw_read_unsigned (regcache
, tdep
->ppc_gp0_regnum
, &scnum
);
1437 syscall_gdb
= ppc_canonicalize_syscall (scnum
, tdep
->wordsize
);
1439 if (syscall_gdb
< 0)
1441 gdb_printf (gdb_stderr
,
1442 _("Process record and replay target doesn't "
1443 "support syscall number %d\n"), (int) scnum
);
1447 if (syscall_gdb
== gdb_sys_sigreturn
1448 || syscall_gdb
== gdb_sys_rt_sigreturn
)
1451 int regsets
[] = { tdep
->ppc_gp0_regnum
,
1452 tdep
->ppc_fp0_regnum
,
1453 tdep
->ppc_vr0_regnum
,
1454 tdep
->ppc_vsr0_upper_regnum
};
1456 for (j
= 0; j
< 4; j
++)
1458 if (regsets
[j
] == -1)
1460 for (i
= 0; i
< 32; i
++)
1462 if (record_full_arch_list_add_reg (regcache
, regsets
[j
] + i
))
1467 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_cr_regnum
))
1469 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_ctr_regnum
))
1471 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_lr_regnum
))
1473 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_xer_regnum
))
1479 if (tdep
->wordsize
== 8)
1480 ret
= record_linux_system_call (syscall_gdb
, regcache
,
1481 &ppc64_linux_record_tdep
);
1483 ret
= record_linux_system_call (syscall_gdb
, regcache
,
1484 &ppc_linux_record_tdep
);
1489 /* Record registers clobbered during syscall. */
1490 for (int i
= 3; i
<= 12; i
++)
1492 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ i
))
1495 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ 0))
1497 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_cr_regnum
))
1499 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_ctr_regnum
))
1501 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_lr_regnum
))
1507 /* Record registers which might be clobbered during signal handling.
1508 Return 0 if successful. */
1511 ppc_linux_record_signal (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1512 enum gdb_signal signal
)
1514 /* See handle_rt_signal64 in arch/powerpc/kernel/signal_64.c
1515 handle_rt_signal32 in arch/powerpc/kernel/signal_32.c
1516 arch/powerpc/include/asm/ptrace.h
1518 const int SIGNAL_FRAMESIZE
= 128;
1519 const int sizeof_rt_sigframe
= 1440 * 2 + 8 * 2 + 4 * 6 + 8 + 8 + 128 + 512;
1521 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
1524 for (i
= 3; i
<= 12; i
++)
1526 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_gp0_regnum
+ i
))
1530 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_lr_regnum
))
1532 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_cr_regnum
))
1534 if (record_full_arch_list_add_reg (regcache
, tdep
->ppc_ctr_regnum
))
1536 if (record_full_arch_list_add_reg (regcache
, gdbarch_pc_regnum (gdbarch
)))
1538 if (record_full_arch_list_add_reg (regcache
, gdbarch_sp_regnum (gdbarch
)))
1541 /* Record the change in the stack.
1542 frame-size = sizeof (struct rt_sigframe) + SIGNAL_FRAMESIZE */
1543 regcache_raw_read_unsigned (regcache
, gdbarch_sp_regnum (gdbarch
), &sp
);
1544 sp
-= SIGNAL_FRAMESIZE
;
1545 sp
-= sizeof_rt_sigframe
;
1547 if (record_full_arch_list_add_mem (sp
, SIGNAL_FRAMESIZE
+ sizeof_rt_sigframe
))
1550 if (record_full_arch_list_add_end ())
1557 ppc_linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1559 struct gdbarch
*gdbarch
= regcache
->arch ();
1561 regcache_cooked_write_unsigned (regcache
, gdbarch_pc_regnum (gdbarch
), pc
);
1563 /* Set special TRAP register to -1 to prevent the kernel from
1564 messing with the PC we just installed, if we happen to be
1565 within an interrupted system call that the kernel wants to
1568 Note that after we return from the dummy call, the TRAP and
1569 ORIG_R3 registers will be automatically restored, and the
1570 kernel continues to restart the system call at this point. */
1571 if (ppc_linux_trap_reg_p (gdbarch
))
1572 regcache_cooked_write_unsigned (regcache
, PPC_TRAP_REGNUM
, -1);
1575 static const struct target_desc
*
1576 ppc_linux_core_read_description (struct gdbarch
*gdbarch
,
1577 struct target_ops
*target
,
1580 struct ppc_linux_features features
= ppc_linux_no_features
;
1581 asection
*altivec
= bfd_get_section_by_name (abfd
, ".reg-ppc-vmx");
1582 asection
*vsx
= bfd_get_section_by_name (abfd
, ".reg-ppc-vsx");
1583 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
1584 asection
*ppr
= bfd_get_section_by_name (abfd
, ".reg-ppc-ppr");
1585 asection
*dscr
= bfd_get_section_by_name (abfd
, ".reg-ppc-dscr");
1586 asection
*tar
= bfd_get_section_by_name (abfd
, ".reg-ppc-tar");
1587 asection
*pmu
= bfd_get_section_by_name (abfd
, ".reg-ppc-pmu");
1588 asection
*htmspr
= bfd_get_section_by_name (abfd
, ".reg-ppc-tm-spr");
1593 switch (bfd_section_size (section
))
1596 features
.wordsize
= 4;
1599 features
.wordsize
= 8;
1606 features
.altivec
= true;
1609 features
.vsx
= true;
1611 gdb::optional
<gdb::byte_vector
> auxv
= target_read_auxv_raw (target
);
1612 CORE_ADDR hwcap
= linux_get_hwcap (auxv
, target
, gdbarch
);
1614 features
.isa205
= ppc_linux_has_isa205 (hwcap
);
1618 features
.ppr_dscr
= true;
1620 /* We don't require the EBB note section to be present in the
1621 core file to select isa207 because these registers could have
1622 been unavailable when the core file was created. They will
1623 be in the tdep but will show as unavailable. */
1626 features
.isa207
= true;
1628 features
.htm
= true;
1632 return ppc_linux_match_description (features
);
1636 /* Implementation of `gdbarch_elf_make_msymbol_special', as defined in
1637 gdbarch.h. This implementation is used for the ELFv2 ABI only. */
1640 ppc_elfv2_elf_make_msymbol_special (asymbol
*sym
, struct minimal_symbol
*msym
)
1642 if ((sym
->flags
& BSF_SYNTHETIC
) != 0)
1643 /* ELFv2 synthetic symbols (the PLT stubs and the __glink_PLTresolve
1644 trampoline) do not have a local entry point. */
1647 elf_symbol_type
*elf_sym
= (elf_symbol_type
*)sym
;
1649 /* If the symbol is marked as having a local entry point, set a target
1650 flag in the msymbol. We currently only support local entry point
1651 offsets of 8 bytes, which is the only entry point offset ever used
1652 by current compilers. If/when other offsets are ever used, we will
1653 have to use additional target flag bits to store them. */
1654 switch (PPC64_LOCAL_ENTRY_OFFSET (elf_sym
->internal_elf_sym
.st_other
))
1659 msym
->set_target_flag_1 (true);
1664 /* Implementation of `gdbarch_skip_entrypoint', as defined in
1665 gdbarch.h. This implementation is used for the ELFv2 ABI only. */
1668 ppc_elfv2_skip_entrypoint (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1670 struct bound_minimal_symbol fun
;
1671 int local_entry_offset
= 0;
1673 fun
= lookup_minimal_symbol_by_pc (pc
);
1674 if (fun
.minsym
== NULL
)
1677 /* See ppc_elfv2_elf_make_msymbol_special for how local entry point
1678 offset values are encoded. */
1679 if (fun
.minsym
->target_flag_1 ())
1680 local_entry_offset
= 8;
1682 if (fun
.value_address () <= pc
1683 && pc
< fun
.value_address () + local_entry_offset
)
1684 return fun
.value_address () + local_entry_offset
;
1689 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1693 ppc_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
1695 return (*s
== 'i' /* Literal number. */
1696 || (isdigit (*s
) && s
[1] == '('
1697 && isdigit (s
[2])) /* Displacement. */
1698 || (*s
== '(' && isdigit (s
[1])) /* Register indirection. */
1699 || isdigit (*s
)); /* Register value. */
1702 /* Implementation of `gdbarch_stap_parse_special_token', as defined in
1705 static expr::operation_up
1706 ppc_stap_parse_special_token (struct gdbarch
*gdbarch
,
1707 struct stap_parse_info
*p
)
1709 if (isdigit (*p
->arg
))
1711 /* This temporary pointer is needed because we have to do a lookahead.
1712 We could be dealing with a register displacement, and in such case
1713 we would not need to do anything. */
1714 const char *s
= p
->arg
;
1718 while (isdigit (*s
))
1723 /* It is a register displacement indeed. Returning 0 means we are
1724 deferring the treatment of this case to the generic parser. */
1729 regname
= (char *) alloca (len
+ 2);
1732 strncpy (regname
+ 1, p
->arg
, len
);
1734 regname
[len
] = '\0';
1736 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
1737 error (_("Invalid register name `%s' on expression `%s'."),
1738 regname
, p
->saved_arg
);
1742 return expr::make_operation
<expr::register_operation
> (regname
);
1745 /* All the other tokens should be handled correctly by the generic
1750 /* Initialize linux_record_tdep if not initialized yet.
1751 WORDSIZE is 4 or 8 for 32- or 64-bit PowerPC Linux respectively.
1752 Sizes of data structures are initialized accordingly. */
1755 ppc_init_linux_record_tdep (struct linux_record_tdep
*record_tdep
,
1758 /* The values for TCGETS, TCSETS, TCSETSW, TCSETSF are based on the
1759 size of struct termios in the kernel source.
1760 include/uapi/asm-generic/termbits.h */
1761 #define SIZE_OF_STRUCT_TERMIOS 0x2c
1763 /* Simply return if it had been initialized. */
1764 if (record_tdep
->size_pointer
!= 0)
1767 /* These values are the size of the type that will be used in a system
1768 call. They are obtained from Linux Kernel source. */
1772 record_tdep
->size_pointer
= 8;
1773 record_tdep
->size__old_kernel_stat
= 32;
1774 record_tdep
->size_tms
= 32;
1775 record_tdep
->size_loff_t
= 8;
1776 record_tdep
->size_flock
= 32;
1777 record_tdep
->size_oldold_utsname
= 45;
1778 record_tdep
->size_ustat
= 32;
1779 record_tdep
->size_old_sigaction
= 32;
1780 record_tdep
->size_old_sigset_t
= 8;
1781 record_tdep
->size_rlimit
= 16;
1782 record_tdep
->size_rusage
= 144;
1783 record_tdep
->size_timeval
= 16;
1784 record_tdep
->size_timezone
= 8;
1785 record_tdep
->size_old_gid_t
= 4;
1786 record_tdep
->size_old_uid_t
= 4;
1787 record_tdep
->size_fd_set
= 128;
1788 record_tdep
->size_old_dirent
= 280;
1789 record_tdep
->size_statfs
= 120;
1790 record_tdep
->size_statfs64
= 120;
1791 record_tdep
->size_sockaddr
= 16;
1792 record_tdep
->size_int
= 4;
1793 record_tdep
->size_long
= 8;
1794 record_tdep
->size_ulong
= 8;
1795 record_tdep
->size_msghdr
= 56;
1796 record_tdep
->size_itimerval
= 32;
1797 record_tdep
->size_stat
= 144;
1798 record_tdep
->size_old_utsname
= 325;
1799 record_tdep
->size_sysinfo
= 112;
1800 record_tdep
->size_msqid_ds
= 120;
1801 record_tdep
->size_shmid_ds
= 112;
1802 record_tdep
->size_new_utsname
= 390;
1803 record_tdep
->size_timex
= 208;
1804 record_tdep
->size_mem_dqinfo
= 24;
1805 record_tdep
->size_if_dqblk
= 72;
1806 record_tdep
->size_fs_quota_stat
= 80;
1807 record_tdep
->size_timespec
= 16;
1808 record_tdep
->size_pollfd
= 8;
1809 record_tdep
->size_NFS_FHSIZE
= 32;
1810 record_tdep
->size_knfsd_fh
= 132;
1811 record_tdep
->size_TASK_COMM_LEN
= 16;
1812 record_tdep
->size_sigaction
= 32;
1813 record_tdep
->size_sigset_t
= 8;
1814 record_tdep
->size_siginfo_t
= 128;
1815 record_tdep
->size_cap_user_data_t
= 8;
1816 record_tdep
->size_stack_t
= 24;
1817 record_tdep
->size_off_t
= 8;
1818 record_tdep
->size_stat64
= 104;
1819 record_tdep
->size_gid_t
= 4;
1820 record_tdep
->size_uid_t
= 4;
1821 record_tdep
->size_PAGE_SIZE
= 0x10000; /* 64KB */
1822 record_tdep
->size_flock64
= 32;
1823 record_tdep
->size_io_event
= 32;
1824 record_tdep
->size_iocb
= 64;
1825 record_tdep
->size_epoll_event
= 16;
1826 record_tdep
->size_itimerspec
= 32;
1827 record_tdep
->size_mq_attr
= 64;
1828 record_tdep
->size_termios
= 44;
1829 record_tdep
->size_pid_t
= 4;
1830 record_tdep
->size_winsize
= 8;
1831 record_tdep
->size_serial_struct
= 72;
1832 record_tdep
->size_serial_icounter_struct
= 80;
1833 record_tdep
->size_size_t
= 8;
1834 record_tdep
->size_iovec
= 16;
1835 record_tdep
->size_time_t
= 8;
1837 else if (wordsize
== 4)
1839 record_tdep
->size_pointer
= 4;
1840 record_tdep
->size__old_kernel_stat
= 32;
1841 record_tdep
->size_tms
= 16;
1842 record_tdep
->size_loff_t
= 8;
1843 record_tdep
->size_flock
= 16;
1844 record_tdep
->size_oldold_utsname
= 45;
1845 record_tdep
->size_ustat
= 20;
1846 record_tdep
->size_old_sigaction
= 16;
1847 record_tdep
->size_old_sigset_t
= 4;
1848 record_tdep
->size_rlimit
= 8;
1849 record_tdep
->size_rusage
= 72;
1850 record_tdep
->size_timeval
= 8;
1851 record_tdep
->size_timezone
= 8;
1852 record_tdep
->size_old_gid_t
= 4;
1853 record_tdep
->size_old_uid_t
= 4;
1854 record_tdep
->size_fd_set
= 128;
1855 record_tdep
->size_old_dirent
= 268;
1856 record_tdep
->size_statfs
= 64;
1857 record_tdep
->size_statfs64
= 88;
1858 record_tdep
->size_sockaddr
= 16;
1859 record_tdep
->size_int
= 4;
1860 record_tdep
->size_long
= 4;
1861 record_tdep
->size_ulong
= 4;
1862 record_tdep
->size_msghdr
= 28;
1863 record_tdep
->size_itimerval
= 16;
1864 record_tdep
->size_stat
= 88;
1865 record_tdep
->size_old_utsname
= 325;
1866 record_tdep
->size_sysinfo
= 64;
1867 record_tdep
->size_msqid_ds
= 68;
1868 record_tdep
->size_shmid_ds
= 60;
1869 record_tdep
->size_new_utsname
= 390;
1870 record_tdep
->size_timex
= 128;
1871 record_tdep
->size_mem_dqinfo
= 24;
1872 record_tdep
->size_if_dqblk
= 72;
1873 record_tdep
->size_fs_quota_stat
= 80;
1874 record_tdep
->size_timespec
= 8;
1875 record_tdep
->size_pollfd
= 8;
1876 record_tdep
->size_NFS_FHSIZE
= 32;
1877 record_tdep
->size_knfsd_fh
= 132;
1878 record_tdep
->size_TASK_COMM_LEN
= 16;
1879 record_tdep
->size_sigaction
= 20;
1880 record_tdep
->size_sigset_t
= 8;
1881 record_tdep
->size_siginfo_t
= 128;
1882 record_tdep
->size_cap_user_data_t
= 4;
1883 record_tdep
->size_stack_t
= 12;
1884 record_tdep
->size_off_t
= 4;
1885 record_tdep
->size_stat64
= 104;
1886 record_tdep
->size_gid_t
= 4;
1887 record_tdep
->size_uid_t
= 4;
1888 record_tdep
->size_PAGE_SIZE
= 0x10000; /* 64KB */
1889 record_tdep
->size_flock64
= 32;
1890 record_tdep
->size_io_event
= 32;
1891 record_tdep
->size_iocb
= 64;
1892 record_tdep
->size_epoll_event
= 16;
1893 record_tdep
->size_itimerspec
= 16;
1894 record_tdep
->size_mq_attr
= 32;
1895 record_tdep
->size_termios
= 44;
1896 record_tdep
->size_pid_t
= 4;
1897 record_tdep
->size_winsize
= 8;
1898 record_tdep
->size_serial_struct
= 60;
1899 record_tdep
->size_serial_icounter_struct
= 80;
1900 record_tdep
->size_size_t
= 4;
1901 record_tdep
->size_iovec
= 8;
1902 record_tdep
->size_time_t
= 4;
1905 internal_error (_("unexpected wordsize"));
1907 /* These values are the second argument of system call "sys_fcntl"
1908 and "sys_fcntl64". They are obtained from Linux Kernel source. */
1909 record_tdep
->fcntl_F_GETLK
= 5;
1910 record_tdep
->fcntl_F_GETLK64
= 12;
1911 record_tdep
->fcntl_F_SETLK64
= 13;
1912 record_tdep
->fcntl_F_SETLKW64
= 14;
1914 record_tdep
->arg1
= PPC_R0_REGNUM
+ 3;
1915 record_tdep
->arg2
= PPC_R0_REGNUM
+ 4;
1916 record_tdep
->arg3
= PPC_R0_REGNUM
+ 5;
1917 record_tdep
->arg4
= PPC_R0_REGNUM
+ 6;
1918 record_tdep
->arg5
= PPC_R0_REGNUM
+ 7;
1919 record_tdep
->arg6
= PPC_R0_REGNUM
+ 8;
1921 /* These values are the second argument of system call "sys_ioctl".
1922 They are obtained from Linux Kernel source.
1923 See arch/powerpc/include/uapi/asm/ioctls.h. */
1924 record_tdep
->ioctl_TCGETA
= 0x40147417;
1925 record_tdep
->ioctl_TCSETA
= 0x80147418;
1926 record_tdep
->ioctl_TCSETAW
= 0x80147419;
1927 record_tdep
->ioctl_TCSETAF
= 0x8014741c;
1928 record_tdep
->ioctl_TCGETS
= 0x40007413 | (SIZE_OF_STRUCT_TERMIOS
<< 16);
1929 record_tdep
->ioctl_TCSETS
= 0x80007414 | (SIZE_OF_STRUCT_TERMIOS
<< 16);
1930 record_tdep
->ioctl_TCSETSW
= 0x80007415 | (SIZE_OF_STRUCT_TERMIOS
<< 16);
1931 record_tdep
->ioctl_TCSETSF
= 0x80007416 | (SIZE_OF_STRUCT_TERMIOS
<< 16);
1933 record_tdep
->ioctl_TCSBRK
= 0x2000741d;
1934 record_tdep
->ioctl_TCXONC
= 0x2000741e;
1935 record_tdep
->ioctl_TCFLSH
= 0x2000741f;
1936 record_tdep
->ioctl_TIOCEXCL
= 0x540c;
1937 record_tdep
->ioctl_TIOCNXCL
= 0x540d;
1938 record_tdep
->ioctl_TIOCSCTTY
= 0x540e;
1939 record_tdep
->ioctl_TIOCGPGRP
= 0x40047477;
1940 record_tdep
->ioctl_TIOCSPGRP
= 0x80047476;
1941 record_tdep
->ioctl_TIOCOUTQ
= 0x40047473;
1942 record_tdep
->ioctl_TIOCSTI
= 0x5412;
1943 record_tdep
->ioctl_TIOCGWINSZ
= 0x40087468;
1944 record_tdep
->ioctl_TIOCSWINSZ
= 0x80087467;
1945 record_tdep
->ioctl_TIOCMGET
= 0x5415;
1946 record_tdep
->ioctl_TIOCMBIS
= 0x5416;
1947 record_tdep
->ioctl_TIOCMBIC
= 0x5417;
1948 record_tdep
->ioctl_TIOCMSET
= 0x5418;
1949 record_tdep
->ioctl_TIOCGSOFTCAR
= 0x5419;
1950 record_tdep
->ioctl_TIOCSSOFTCAR
= 0x541a;
1951 record_tdep
->ioctl_FIONREAD
= 0x4004667f;
1952 record_tdep
->ioctl_TIOCINQ
= 0x4004667f;
1953 record_tdep
->ioctl_TIOCLINUX
= 0x541c;
1954 record_tdep
->ioctl_TIOCCONS
= 0x541d;
1955 record_tdep
->ioctl_TIOCGSERIAL
= 0x541e;
1956 record_tdep
->ioctl_TIOCSSERIAL
= 0x541f;
1957 record_tdep
->ioctl_TIOCPKT
= 0x5420;
1958 record_tdep
->ioctl_FIONBIO
= 0x8004667e;
1959 record_tdep
->ioctl_TIOCNOTTY
= 0x5422;
1960 record_tdep
->ioctl_TIOCSETD
= 0x5423;
1961 record_tdep
->ioctl_TIOCGETD
= 0x5424;
1962 record_tdep
->ioctl_TCSBRKP
= 0x5425;
1963 record_tdep
->ioctl_TIOCSBRK
= 0x5427;
1964 record_tdep
->ioctl_TIOCCBRK
= 0x5428;
1965 record_tdep
->ioctl_TIOCGSID
= 0x5429;
1966 record_tdep
->ioctl_TIOCGPTN
= 0x40045430;
1967 record_tdep
->ioctl_TIOCSPTLCK
= 0x80045431;
1968 record_tdep
->ioctl_FIONCLEX
= 0x20006602;
1969 record_tdep
->ioctl_FIOCLEX
= 0x20006601;
1970 record_tdep
->ioctl_FIOASYNC
= 0x8004667d;
1971 record_tdep
->ioctl_TIOCSERCONFIG
= 0x5453;
1972 record_tdep
->ioctl_TIOCSERGWILD
= 0x5454;
1973 record_tdep
->ioctl_TIOCSERSWILD
= 0x5455;
1974 record_tdep
->ioctl_TIOCGLCKTRMIOS
= 0x5456;
1975 record_tdep
->ioctl_TIOCSLCKTRMIOS
= 0x5457;
1976 record_tdep
->ioctl_TIOCSERGSTRUCT
= 0x5458;
1977 record_tdep
->ioctl_TIOCSERGETLSR
= 0x5459;
1978 record_tdep
->ioctl_TIOCSERGETMULTI
= 0x545a;
1979 record_tdep
->ioctl_TIOCSERSETMULTI
= 0x545b;
1980 record_tdep
->ioctl_TIOCMIWAIT
= 0x545c;
1981 record_tdep
->ioctl_TIOCGICOUNT
= 0x545d;
1982 record_tdep
->ioctl_FIOQSIZE
= 0x40086680;
1985 /* Return a floating-point format for a floating-point variable of
1986 length LEN in bits. If non-NULL, NAME is the name of its type.
1987 If no suitable type is found, return NULL. */
1989 static const struct floatformat
**
1990 ppc_floatformat_for_type (struct gdbarch
*gdbarch
,
1991 const char *name
, int len
)
1993 if (len
== 128 && name
)
1995 if (strcmp (name
, "__float128") == 0
1996 || strcmp (name
, "_Float128") == 0
1997 || strcmp (name
, "_Float64x") == 0
1998 || strcmp (name
, "complex _Float128") == 0
1999 || strcmp (name
, "complex _Float64x") == 0)
2000 return floatformats_ieee_quad
;
2002 if (strcmp (name
, "__ibm128") == 0)
2003 return floatformats_ibm_long_double
;
2006 return default_floatformat_for_type (gdbarch
, name
, len
);
2009 /* Specify the powerpc64le target triplet.
2010 This can be variations of
2011 ppc64le-{distro}-linux-gcc
2013 powerpc64le-{distro}-linux-gcc. */
2016 ppc64le_gnu_triplet_regexp (struct gdbarch
*gdbarch
)
2018 return "p(ower)?pc64le";
2021 /* Specify the powerpc64 target triplet.
2022 This can be variations of
2023 ppc64-{distro}-linux-gcc
2025 powerpc64-{distro}-linux-gcc. */
2028 ppc64_gnu_triplet_regexp (struct gdbarch
*gdbarch
)
2030 return "p(ower)?pc64";
2033 /* Implement the linux_gcc_target_options method. */
2036 ppc64_linux_gcc_target_options (struct gdbarch
*gdbarch
)
2041 static displaced_step_prepare_status
2042 ppc_linux_displaced_step_prepare (gdbarch
*arch
, thread_info
*thread
,
2043 CORE_ADDR
&displaced_pc
)
2045 ppc_inferior_data
*per_inferior
= get_ppc_per_inferior (thread
->inf
);
2046 if (!per_inferior
->disp_step_buf
.has_value ())
2048 /* Figure out where the displaced step buffer is. */
2049 CORE_ADDR disp_step_buf_addr
2050 = linux_displaced_step_location (thread
->inf
->gdbarch
);
2052 per_inferior
->disp_step_buf
.emplace (disp_step_buf_addr
);
2055 return per_inferior
->disp_step_buf
->prepare (thread
, displaced_pc
);
2059 ppc_linux_init_abi (struct gdbarch_info info
,
2060 struct gdbarch
*gdbarch
)
2062 ppc_gdbarch_tdep
*tdep
= gdbarch_tdep
<ppc_gdbarch_tdep
> (gdbarch
);
2063 struct tdesc_arch_data
*tdesc_data
= info
.tdesc_data
;
2064 static const char *const stap_integer_prefixes
[] = { "i", NULL
};
2065 static const char *const stap_register_indirection_prefixes
[] = { "(",
2067 static const char *const stap_register_indirection_suffixes
[] = { ")",
2070 linux_init_abi (info
, gdbarch
, 0);
2072 /* PPC GNU/Linux uses either 64-bit or 128-bit long doubles; where
2073 128-bit, they can be either IBM long double or IEEE quad long double.
2074 The 64-bit long double case will be detected automatically using
2075 the size specified in debug info. We use a .gnu.attribute flag
2076 to distinguish between the IBM long double and IEEE quad cases. */
2077 set_gdbarch_long_double_bit (gdbarch
, 16 * TARGET_CHAR_BIT
);
2078 if (tdep
->long_double_abi
== POWERPC_LONG_DOUBLE_IEEE128
)
2079 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_quad
);
2081 set_gdbarch_long_double_format (gdbarch
, floatformats_ibm_long_double
);
2083 /* Support for floating-point data type variants. */
2084 set_gdbarch_floatformat_for_type (gdbarch
, ppc_floatformat_for_type
);
2086 /* Handle inferior calls during interrupted system calls. */
2087 set_gdbarch_write_pc (gdbarch
, ppc_linux_write_pc
);
2089 /* Get the syscall number from the arch's register. */
2090 set_gdbarch_get_syscall_number (gdbarch
, ppc_linux_get_syscall_number
);
2092 /* SystemTap functions. */
2093 set_gdbarch_stap_integer_prefixes (gdbarch
, stap_integer_prefixes
);
2094 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
2095 stap_register_indirection_prefixes
);
2096 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
2097 stap_register_indirection_suffixes
);
2098 set_gdbarch_stap_gdb_register_prefix (gdbarch
, "r");
2099 set_gdbarch_stap_is_single_operand (gdbarch
, ppc_stap_is_single_operand
);
2100 set_gdbarch_stap_parse_special_token (gdbarch
,
2101 ppc_stap_parse_special_token
);
2103 if (tdep
->wordsize
== 4)
2105 /* Until November 2001, gcc did not comply with the 32 bit SysV
2106 R4 ABI requirement that structures less than or equal to 8
2107 bytes should be returned in registers. Instead GCC was using
2108 the AIX/PowerOpen ABI - everything returned in memory
2109 (well ignoring vectors that is). When this was corrected, it
2110 wasn't fixed for GNU/Linux native platform. Use the
2111 PowerOpen struct convention. */
2112 set_gdbarch_return_value_as_value (gdbarch
, ppc_linux_return_value
);
2113 set_gdbarch_return_value (gdbarch
, nullptr);
2115 set_gdbarch_memory_remove_breakpoint (gdbarch
,
2116 ppc_linux_memory_remove_breakpoint
);
2118 /* Shared library handling. */
2119 set_gdbarch_skip_trampoline_code (gdbarch
, ppc_skip_trampoline_code
);
2120 set_solib_svr4_fetch_link_map_offsets
2121 (gdbarch
, linux_ilp32_fetch_link_map_offsets
);
2123 /* Setting the correct XML syscall filename. */
2124 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_PPC
);
2127 tramp_frame_prepend_unwinder (gdbarch
,
2128 &ppc32_linux_sigaction_tramp_frame
);
2129 tramp_frame_prepend_unwinder (gdbarch
,
2130 &ppc32_linux_sighandler_tramp_frame
);
2132 /* BFD target for core files. */
2133 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
2134 set_gdbarch_gcore_bfd_target (gdbarch
, "elf32-powerpcle");
2136 set_gdbarch_gcore_bfd_target (gdbarch
, "elf32-powerpc");
2138 if (powerpc_so_ops
.in_dynsym_resolve_code
== NULL
)
2140 powerpc_so_ops
= svr4_so_ops
;
2141 /* Override dynamic resolve function. */
2142 powerpc_so_ops
.in_dynsym_resolve_code
=
2143 powerpc_linux_in_dynsym_resolve_code
;
2145 set_gdbarch_so_ops (gdbarch
, &powerpc_so_ops
);
2147 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
2150 if (tdep
->wordsize
== 8)
2152 if (tdep
->elf_abi
== POWERPC_ELF_V1
)
2154 /* Handle PPC GNU/Linux 64-bit function pointers (which are really
2155 function descriptors). */
2156 set_gdbarch_convert_from_func_ptr_addr
2157 (gdbarch
, ppc64_convert_from_func_ptr_addr
);
2159 set_gdbarch_elf_make_msymbol_special
2160 (gdbarch
, ppc64_elf_make_msymbol_special
);
2164 set_gdbarch_elf_make_msymbol_special
2165 (gdbarch
, ppc_elfv2_elf_make_msymbol_special
);
2167 set_gdbarch_skip_entrypoint (gdbarch
, ppc_elfv2_skip_entrypoint
);
2170 /* Shared library handling. */
2171 set_gdbarch_skip_trampoline_code (gdbarch
, ppc64_skip_trampoline_code
);
2172 set_solib_svr4_fetch_link_map_offsets
2173 (gdbarch
, linux_lp64_fetch_link_map_offsets
);
2175 /* Setting the correct XML syscall filename. */
2176 set_xml_syscall_file_name (gdbarch
, XML_SYSCALL_FILENAME_PPC64
);
2179 tramp_frame_prepend_unwinder (gdbarch
,
2180 &ppc64_linux_sigaction_tramp_frame
);
2181 tramp_frame_prepend_unwinder (gdbarch
,
2182 &ppc64_linux_sighandler_tramp_frame
);
2184 /* BFD target for core files. */
2185 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
2186 set_gdbarch_gcore_bfd_target (gdbarch
, "elf64-powerpcle");
2188 set_gdbarch_gcore_bfd_target (gdbarch
, "elf64-powerpc");
2189 /* Set compiler triplet. */
2190 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
2191 set_gdbarch_gnu_triplet_regexp (gdbarch
, ppc64le_gnu_triplet_regexp
);
2193 set_gdbarch_gnu_triplet_regexp (gdbarch
, ppc64_gnu_triplet_regexp
);
2194 /* Set GCC target options. */
2195 set_gdbarch_gcc_target_options (gdbarch
, ppc64_linux_gcc_target_options
);
2198 set_gdbarch_core_read_description (gdbarch
, ppc_linux_core_read_description
);
2199 set_gdbarch_iterate_over_regset_sections (gdbarch
,
2200 ppc_linux_iterate_over_regset_sections
);
2202 /* Enable TLS support. */
2203 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
2204 svr4_fetch_objfile_link_map
);
2208 const struct tdesc_feature
*feature
;
2210 /* If we have target-described registers, then we can safely
2211 reserve a number for PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM
2212 (whether they are described or not). */
2213 gdb_assert (gdbarch_num_regs (gdbarch
) <= PPC_ORIG_R3_REGNUM
);
2214 set_gdbarch_num_regs (gdbarch
, PPC_TRAP_REGNUM
+ 1);
2216 /* If they are present, then assign them to the reserved number. */
2217 feature
= tdesc_find_feature (info
.target_desc
,
2218 "org.gnu.gdb.power.linux");
2219 if (feature
!= NULL
)
2221 tdesc_numbered_register (feature
, tdesc_data
,
2222 PPC_ORIG_R3_REGNUM
, "orig_r3");
2223 tdesc_numbered_register (feature
, tdesc_data
,
2224 PPC_TRAP_REGNUM
, "trap");
2228 /* Support reverse debugging. */
2229 set_gdbarch_process_record (gdbarch
, ppc_process_record
);
2230 set_gdbarch_process_record_signal (gdbarch
, ppc_linux_record_signal
);
2231 tdep
->ppc_syscall_record
= ppc_linux_syscall_record
;
2233 ppc_init_linux_record_tdep (&ppc_linux_record_tdep
, 4);
2234 ppc_init_linux_record_tdep (&ppc64_linux_record_tdep
, 8);
2236 /* Setup displaced stepping. */
2237 set_gdbarch_displaced_step_prepare (gdbarch
,
2238 ppc_linux_displaced_step_prepare
);
2242 void _initialize_ppc_linux_tdep ();
2244 _initialize_ppc_linux_tdep ()
2246 /* Register for all sub-families of the POWER/PowerPC: 32-bit and
2247 64-bit PowerPC, and the older rs6k. */
2248 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc
, GDB_OSABI_LINUX
,
2249 ppc_linux_init_abi
);
2250 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc64
, GDB_OSABI_LINUX
,
2251 ppc_linux_init_abi
);
2252 gdbarch_register_osabi (bfd_arch_rs6000
, bfd_mach_rs6k
, GDB_OSABI_LINUX
,
2253 ppc_linux_init_abi
);
2255 /* Initialize the Linux target descriptions. */
2256 initialize_tdesc_powerpc_32l ();
2257 initialize_tdesc_powerpc_altivec32l ();
2258 initialize_tdesc_powerpc_vsx32l ();
2259 initialize_tdesc_powerpc_isa205_32l ();
2260 initialize_tdesc_powerpc_isa205_altivec32l ();
2261 initialize_tdesc_powerpc_isa205_vsx32l ();
2262 initialize_tdesc_powerpc_isa205_ppr_dscr_vsx32l ();
2263 initialize_tdesc_powerpc_isa207_vsx32l ();
2264 initialize_tdesc_powerpc_isa207_htm_vsx32l ();
2265 initialize_tdesc_powerpc_64l ();
2266 initialize_tdesc_powerpc_altivec64l ();
2267 initialize_tdesc_powerpc_vsx64l ();
2268 initialize_tdesc_powerpc_isa205_64l ();
2269 initialize_tdesc_powerpc_isa205_altivec64l ();
2270 initialize_tdesc_powerpc_isa205_vsx64l ();
2271 initialize_tdesc_powerpc_isa205_ppr_dscr_vsx64l ();
2272 initialize_tdesc_powerpc_isa207_vsx64l ();
2273 initialize_tdesc_powerpc_isa207_htm_vsx64l ();
2274 initialize_tdesc_powerpc_e500l ();