GDB (xrefs)
Loading...
Searching...
No Matches
ppc-linux-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "frame.h"
22#include "inferior.h"
23#include "symtab.h"
24#include "target.h"
25#include "gdbcore.h"
26#include "gdbcmd.h"
27#include "symfile.h"
28#include "objfiles.h"
29#include "regcache.h"
30#include "value.h"
31#include "osabi.h"
32#include "regset.h"
33#include "solib-svr4.h"
34#include "solib.h"
35#include "solist.h"
36#include "ppc-tdep.h"
37#include "ppc64-tdep.h"
38#include "ppc-linux-tdep.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"
46#include "auxv.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"
54#include "infrun.h"
55#include "expop.h"
56
57#include "stap-probe.h"
58#include "ax.h"
59#include "ax-gdb.h"
60#include "cli/cli-utils.h"
61#include "parser-defs.h"
62#include "user-regs.h"
63#include <ctype.h>
64#include "elf-bfd.h"
65#include "producer.h"
66
86
87/* Shared library operations for PowerPC-Linux. */
89
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"
93
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
98 removing it.
99
100 Here is the problem that we're trying to solve...
101
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
107 this platform.
108
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.
114
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.
121
122 We start the program shmain.
123
124 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
125 [...]
126
127 We place two breakpoints, one on shr1 and the other on main.
128
129 (gdb) b shr1
130 Breakpoint 1 at 0x100409d4
131 (gdb) b main
132 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
133
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.
137
138 (gdb) x/2i 0x100409d4
139 0x100409d4 <shr1>: .long 0x0
140 0x100409d8 <shr1+4>: .long 0x0
141
142 Now run 'til main.
143
144 (gdb) r
145 Starting program: gdb.base/shmain
146 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
147
148 Breakpoint 2, main ()
149 at gdb.base/shmain.c:44
150 44 g = 1;
151
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
156 resolving.
157
158 (gdb) x/2i 0x100409d4
159 0x100409d4 <shr1>: li r11,4
160 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
161 (gdb) c
162 Continuing.
163
164 Breakpoint 1, shr1 (x=1)
165 at gdb.base/shr1.c:19
166 19 l = 1;
167
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.)
173
174 (gdb) x/2i 0x100409d4
175 0x100409d4 <shr1>: b 0xffaf76c <shr1>
176 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
177
178 The thing to note here is that the PLT entry for shr1 has been
179 changed twice.
180
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.
186
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.)
193
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
198 function.
199
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.
207
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.
212
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
217 code. */
218static int
220 struct bp_target_info *bp_tgt)
221{
222 CORE_ADDR addr = bp_tgt->reqstd_address;
223 const unsigned char *bp;
224 int val;
225 int bplen;
226 gdb_byte old_contents[BREAKPOINT_MAX];
227
228 /* Determine appropriate breakpoint contents and size for this address. */
229 bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);
230
231 /* Make sure we see the memory breakpoints. */
232 scoped_restore restore_memory
234 val = target_read_memory (addr, old_contents, bplen);
235
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
238 old value. */
239 if (val == 0 && memcmp (bp, old_contents, bplen) == 0)
240 val = target_write_raw_memory (addr, bp_tgt->shadow_contents, bplen);
241
242 return val;
243}
244
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. */
249
250static enum return_value_convention
251ppc_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)
254{
255 gdb_byte *readbuf = nullptr;
256 if (read_value != nullptr)
257 {
258 *read_value = value::allocate (valtype);
259 readbuf = (*read_value)->contents_raw ().data ();
260 }
261
262 if ((valtype->code () == TYPE_CODE_STRUCT
263 || valtype->code () == TYPE_CODE_UNION)
264 && !((valtype->length () == 16 || valtype->length () == 8)
265 && valtype->is_vector ()))
267 else
268 return ppc_sysv_abi_return_value (gdbarch, function, valtype, regcache,
269 readbuf, writebuf);
270}
271
272/* PLT stub in an executable. */
274 {
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 */
279 { 0, 0, 0 }
280 };
281
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). */
286 {
287 { 0xffff0000, 0x817e0000, 0 }, /* lwz r11, xxxx(r30) */
288 { 0xffffffff, 0x7d6903a6, 0 }, /* mtctr r11 */
289 { 0xffffffff, 0x4e800420, 0 }, /* bctr */
290 { 0, 0, 0 }
291 };
292
293/* The second variant is used when the PLT entry is more than +/-32k
294 from the GOT pointer (r30). */
296 {
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 */
301 { 0, 0, 0 }
302 };
303
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)
306
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. */
310
311static int
313{
314 struct bound_minimal_symbol sym;
315
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. */
319 return 1;
320
321 /* Check if we are in the resolver. */
323 if (sym.minsym != NULL
324 && (strcmp (sym.minsym->linkage_name (), "__glink") == 0
325 || strcmp (sym.minsym->linkage_name (), "__glink_PLTresolve") == 0))
326 return 1;
327
328 return 0;
329}
330
331/* Follow PLT stub to actual routine.
332
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
336 stub sequence. */
337
338static CORE_ADDR
340{
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;
346 int scan_limit, i;
347
348 scan_limit = 1;
349 /* When reverse-debugging, scan backward to check whether we are
350 in the middle of trampoline code. */
352 scan_limit = 4; /* At most 4 instructions. */
353
354 for (i = 0; i < scan_limit; i++)
355 {
356 if (ppc_insns_match_pattern (frame, pc, powerpc32_plt_stub, insnbuf))
357 {
358 /* Calculate PLT entry address from
359 lis r11, xxxx
360 lwz r11, xxxx(r11). */
361 target = ((ppc_insn_d_field (insnbuf[0]) << 16)
362 + ppc_insn_d_field (insnbuf[1]));
363 }
364 else if (i < ARRAY_SIZE (powerpc32_plt_stub_so_1) - 1
366 insnbuf))
367 {
368 /* Calculate PLT entry address from
369 lwz r11, xxxx(r30). */
370 target = (ppc_insn_d_field (insnbuf[0])
372 tdep->ppc_gp0_regnum + 30));
373 }
375 insnbuf))
376 {
377 /* Calculate PLT entry address from
378 addis r11, r30, xxxx
379 lwz r11, xxxx(r11). */
380 target = ((ppc_insn_d_field (insnbuf[0]) << 16)
381 + ppc_insn_d_field (insnbuf[1])
383 tdep->ppc_gp0_regnum + 30));
384 }
385 else
386 {
387 /* Scan backward one more instruction if it doesn't match. */
388 pc -= 4;
389 continue;
390 }
391
392 target = read_memory_unsigned_integer (target, 4, byte_order);
393 return target;
394 }
395
396 return 0;
397}
398
399/* Wrappers to handle Linux-only registers. */
400
401static void
403 struct regcache *regcache,
404 int regnum, const void *gregs, size_t len)
405{
406 const struct ppc_reg_offsets *offsets
407 = (const struct ppc_reg_offsets *) regset->regmap;
408
410
412 {
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,
417 offsets->gpr_size);
418
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,
423 offsets->gpr_size);
424 }
425}
426
427static void
429 const struct regcache *regcache,
430 int regnum, void *gregs, size_t len)
431{
432 const struct ppc_reg_offsets *offsets
433 = (const struct ppc_reg_offsets *) regset->regmap;
434
435 /* Clear areas in the linux gregset not written elsewhere. */
436 if (regnum == -1)
437 memset (gregs, 0, len);
438
440
442 {
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,
447 offsets->gpr_size);
448
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,
453 offsets->gpr_size);
454 }
455}
456
457/* Regset descriptions. */
459 {
460 /* General-purpose registers. */
461 /* .r0_offset = */ 0,
462 /* .gpr_size = */ 4,
463 /* .xr_size = */ 4,
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,
471
472 /* Floating-point registers. */
473 /* .f0_offset = */ 0,
474 /* .fpscr_offset = */ 256,
475 /* .fpscr_size = */ 8
476 };
477
479 {
480 /* General-purpose registers. */
481 /* .r0_offset = */ 0,
482 /* .gpr_size = */ 8,
483 /* .xr_size = */ 8,
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,
491
492 /* Floating-point registers. */
493 /* .f0_offset = */ 0,
494 /* .fpscr_offset = */ 256,
495 /* .fpscr_size = */ 8
496 };
497
503
509
515
517 {
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 },
523 { 0 }
524 };
525
527 {
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 },
533 { 0 }
534 };
535
541
547
549 {
550 { 32, PPC_VSR0_UPPER_REGNUM, 8 },
551 { 0 }
552 };
553
559
560/* Program Priorty Register regmap. */
561
563 {
564 { 1, PPC_PPR_REGNUM, 8 },
565 { 0 }
566 };
567
568/* Program Priorty Register regset. */
569
575
576/* Data Stream Control Register regmap. */
577
579 {
580 { 1, PPC_DSCR_REGNUM, 8 },
581 { 0 }
582 };
583
584/* Data Stream Control Register regset. */
585
591
592/* Target Address Register regmap. */
593
595 {
596 { 1, PPC_TAR_REGNUM, 8 },
597 { 0 }
598 };
599
600/* Target Address Register regset. */
601
607
608/* Event-Based Branching regmap. */
609
611 {
612 { 1, PPC_EBBRR_REGNUM, 8 },
613 { 1, PPC_EBBHR_REGNUM, 8 },
614 { 1, PPC_BESCR_REGNUM, 8 },
615 { 0 }
616 };
617
618/* Event-Based Branching regset. */
619
625
626/* Performance Monitoring Unit regmap. */
627
629 {
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 },
635 { 0 }
636 };
637
638/* Performance Monitoring Unit regset. */
639
645
646/* Hardware Transactional Memory special-purpose register regmap. */
647
649 {
650 { 1, PPC_TFHAR_REGNUM, 8 },
651 { 1, PPC_TEXASR_REGNUM, 8 },
652 { 1, PPC_TFIAR_REGNUM, 8 },
653 { 0 }
654 };
655
656/* Hardware Transactional Memory special-purpose register regset. */
657
663
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.
671
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). */
684
686 {
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. */
694 { 0 }
695 };
696
698 {
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},
708 { 0 }
709 };
710
712 {
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},
722 { 0 }
723 };
724
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.
728
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. */
733
740
746
752
753/* Hardware Transactional Memory checkpointed floating-point regmap. */
754
756 {
757 { 32, PPC_CF0_REGNUM, 8 },
758 { 1, PPC_CFPSCR_REGNUM, 8 },
759 { 0 }
760 };
761
762/* Hardware Transactional Memory checkpointed floating-point regset. */
763
769
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. */
773
775 {
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 },
781 { 0 }
782 };
783
785 {
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},
791 { 0 }
792 };
793
794/* Hardware Transactional Memory checkpointed vector regsets, for little
795 and big endian targets. */
796
802
808
809/* Hardware Transactional Memory checkpointed vector-scalar regmap. */
810
812 {
813 { 32, PPC_CVSR0_UPPER_REGNUM, 8 },
814 { 0 }
815 };
816
817/* Hardware Transactional Memory checkpointed vector-scalar regset. */
818
824
825/* Hardware Transactional Memory checkpointed Program Priority Register
826 regmap. */
827
829 {
830 { 1, PPC_CPPR_REGNUM, 8 },
831 { 0 }
832 };
833
834/* Hardware Transactional Memory checkpointed Program Priority Register
835 regset. */
836
842
843/* Hardware Transactional Memory checkpointed Data Stream Control
844 Register regmap. */
845
847 {
848 { 1, PPC_CDSCR_REGNUM, 8 },
849 { 0 }
850 };
851
852/* Hardware Transactional Memory checkpointed Data Stream Control
853 Register regset. */
854
860
861/* Hardware Transactional Memory checkpointed Target Address Register
862 regmap. */
863
865 {
866 { 1, PPC_CTAR_REGNUM, 8 },
867 { 0 }
868 };
869
870/* Hardware Transactional Memory checkpointed Target Address Register
871 regset. */
872
878
879const struct regset *
880ppc_linux_gregset (int wordsize)
881{
882 return wordsize == 8 ? &ppc64_linux_gregset : &ppc32_linux_gregset;
883}
884
885const struct regset *
887{
888 return &ppc32_linux_fpregset;
889}
890
891const struct regset *
893{
894 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
896 else
898}
899
900const struct regset *
902{
903 return &ppc32_linux_vsxregset;
904}
905
906const struct regset *
908{
909 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
910
911 if (tdep->wordsize == 4)
912 {
914 }
915 else
916 {
917 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
919 else
921 }
922}
923
924const struct regset *
926{
927 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
929 else
931}
932
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
941 most cases. */
942
943static void
945 const struct regcache *regcache,
946 int regnum, void *buf, size_t len)
947{
948 struct gdbarch *gdbarch = regcache->arch ();
949 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
950
951 const struct regset *cgprregset = ppc_linux_cgprregset (gdbarch);
952
953 /* We collect the checkpointed GPRs already defined in the regular
954 regmap, then overlay TFHAR/MSR on the checkpointed NIP/MSR
955 slots. */
956 cgprregset->collect_regset (cgprregset, regcache, regnum, buf, len);
957
958 /* Check that we are collecting all the registers, which should be
959 the case when generating a core file. */
960 if (regnum != -1)
961 return;
962
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
966 values. */
967 int pt_offset = 32;
968
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);
972
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. */
978 (PPC_TFHAR_REGNUM, ((gdb_byte *) buf) + pt_offset * tdep->wordsize,
979 tdep->wordsize, false));
980
981 pt_offset = 33;
982
984 (PPC_MSR_REGNUM, ((gdb_byte *) buf) + pt_offset * tdep->wordsize,
985 tdep->wordsize, false));
986}
987
988/* Iterate over supported core file register note sections. */
989
990static void
993 void *cb_data,
994 const struct regcache *regcache)
995{
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;
1002
1003 if (tdep->wordsize == 4)
1004 cb (".reg", 48 * 4, 48 * 4, &ppc32_linux_gregset, NULL, cb_data);
1005 else
1006 cb (".reg", 48 * 8, 48 * 8, &ppc64_linux_gregset, NULL, cb_data);
1007
1008 cb (".reg2", 264, 264, &ppc32_linux_fpregset, NULL, cb_data);
1009
1010 if (have_altivec)
1011 {
1012 const struct regset *vrregset = ppc_linux_vrregset (gdbarch);
1014 vrregset, "ppc Altivec", cb_data);
1015 }
1016
1017 if (have_vsx)
1019 &ppc32_linux_vsxregset, "POWER7 VSX", cb_data);
1020
1021 if (have_ppr)
1022 cb (".reg-ppc-ppr", PPC_LINUX_SIZEOF_PPRREGSET,
1024 &ppc32_linux_pprregset, "Priority Program Register", cb_data);
1025
1026 if (have_dscr)
1027 cb (".reg-ppc-dscr", PPC_LINUX_SIZEOF_DSCRREGSET,
1029 &ppc32_linux_dscrregset, "Data Stream Control Register",
1030 cb_data);
1031
1032 if (have_tar)
1033 cb (".reg-ppc-tar", PPC_LINUX_SIZEOF_TARREGSET,
1035 &ppc32_linux_tarregset, "Target Address Register", cb_data);
1036
1037 /* EBB registers are unavailable when ptrace returns ENODATA. Check
1038 availability when generating a core file (regcache != NULL). */
1039 if (tdep->have_ebb)
1040 if (regcache == NULL
1042 cb (".reg-ppc-ebb", PPC_LINUX_SIZEOF_EBBREGSET,
1044 &ppc32_linux_ebbregset, "Event-based Branching Registers",
1045 cb_data);
1046
1047 if (tdep->ppc_mmcr0_regnum != -1)
1048 cb (".reg-ppc-pmu", PPC_LINUX_SIZEOF_PMUREGSET,
1050 &ppc32_linux_pmuregset, "Performance Monitor Registers",
1051 cb_data);
1052
1053 if (tdep->have_htm_spr)
1054 cb (".reg-ppc-tm-spr", PPC_LINUX_SIZEOF_TM_SPRREGSET,
1057 "Hardware Transactional Memory Special Purpose Registers",
1058 cb_data);
1059
1060 /* Checkpointed registers can be unavailable, don't call back if
1061 we are generating a core file. */
1062
1063 if (tdep->have_htm_core)
1064 {
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 ||
1071 && tdep->have_htm_spr))
1072 {
1073 int cgpr_size = (tdep->wordsize == 4?
1076
1077 const struct regset *cgprregset =
1079
1080 if (regcache != NULL)
1081 {
1082 struct regset core_cgprregset = *cgprregset;
1083
1084 core_cgprregset.collect_regset
1086
1087 cb (".reg-ppc-tm-cgpr",
1088 cgpr_size, cgpr_size,
1089 &core_cgprregset,
1090 "Checkpointed General Purpose Registers", cb_data);
1091 }
1092 else
1093 {
1094 cb (".reg-ppc-tm-cgpr",
1095 cgpr_size, cgpr_size,
1096 cgprregset,
1097 "Checkpointed General Purpose Registers", cb_data);
1098 }
1099 }
1100 }
1101
1102 if (tdep->have_htm_fpu)
1103 {
1104 if (regcache == NULL ||
1106 cb (".reg-ppc-tm-cfpr", PPC_LINUX_SIZEOF_CFPRREGSET,
1109 "Checkpointed Floating Point Registers", cb_data);
1110 }
1111
1112 if (tdep->have_htm_altivec)
1113 {
1114 if (regcache == NULL ||
1116 {
1117 const struct regset *cvmxregset =
1119
1120 cb (".reg-ppc-tm-cvmx", PPC_LINUX_SIZEOF_CVMXREGSET,
1122 cvmxregset,
1123 "Checkpointed Altivec (VMX) Registers", cb_data);
1124 }
1125 }
1126
1127 if (tdep->have_htm_vsx)
1128 {
1129 if (regcache == NULL ||
1130 (REG_VALID
1132 cb (".reg-ppc-tm-cvsx", PPC_LINUX_SIZEOF_CVSXREGSET,
1135 "Checkpointed VSX Registers", cb_data);
1136 }
1137
1138 if (tdep->ppc_cppr_regnum != -1)
1139 {
1140 if (regcache == NULL ||
1142 cb (".reg-ppc-tm-cppr", PPC_LINUX_SIZEOF_CPPRREGSET,
1145 "Checkpointed Priority Program Register", cb_data);
1146 }
1147
1148 if (tdep->ppc_cdscr_regnum != -1)
1149 {
1150 if (regcache == NULL ||
1152 cb (".reg-ppc-tm-cdscr", PPC_LINUX_SIZEOF_CDSCRREGSET,
1155 "Checkpointed Data Stream Control Register", cb_data);
1156 }
1157
1158 if (tdep->ppc_ctar_regnum)
1159 {
1160 if ( regcache == NULL ||
1162 cb (".reg-ppc-tm-ctar", PPC_LINUX_SIZEOF_CTARREGSET,
1165 "Checkpointed Target Address Register", cb_data);
1166 }
1167}
1168
1169static void
1171 struct trad_frame_cache *this_cache,
1172 CORE_ADDR func, LONGEST offset,
1173 int bias)
1174{
1175 CORE_ADDR base;
1176 CORE_ADDR regs;
1177 CORE_ADDR gpregs;
1178 CORE_ADDR fpregs;
1179 int i;
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);
1183
1184 base = get_frame_register_unsigned (this_frame,
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. */
1189 base -= bias;
1190
1191 /* Find the address of the register buffer pointer. */
1192 regs = base + offset;
1193 /* Use that to find the address of the corresponding register
1194 buffers. */
1195 gpregs = read_memory_unsigned_integer (regs, tdep->wordsize, byte_order);
1196 fpregs = gpregs + 48 * tdep->wordsize;
1197
1198 /* General purpose. */
1199 for (i = 0; i < 32; i++)
1200 {
1201 int regnum = i + tdep->ppc_gp0_regnum;
1202 trad_frame_set_reg_addr (this_cache,
1203 regnum, gpregs + i * tdep->wordsize);
1204 }
1205 trad_frame_set_reg_addr (this_cache,
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);
1216
1218 {
1220 gpregs + 34 * tdep->wordsize);
1222 gpregs + 40 * tdep->wordsize);
1223 }
1224
1226 {
1227 /* Floating point registers. */
1228 for (i = 0; i < 32; i++)
1229 {
1230 int regnum = i + gdbarch_fp0_regnum (gdbarch);
1231 trad_frame_set_reg_addr (this_cache, regnum,
1232 fpregs + i * tdep->wordsize);
1233 }
1234 trad_frame_set_reg_addr (this_cache, tdep->ppc_fpscr_regnum,
1235 fpregs + 32 * tdep->wordsize);
1236 }
1237 trad_frame_set_id (this_cache, frame_id_build (base, func));
1238}
1239
1240static void
1242 frame_info_ptr this_frame,
1243 struct trad_frame_cache *this_cache,
1244 CORE_ADDR func)
1245{
1246 ppc_linux_sigtramp_cache (this_frame, this_cache, func,
1247 0xd0 /* Offset to ucontext_t. */
1248 + 0x30 /* Offset to .reg. */,
1249 0);
1250}
1251
1252static void
1254 frame_info_ptr this_frame,
1255 struct trad_frame_cache *this_cache,
1256 CORE_ADDR func)
1257{
1258 ppc_linux_sigtramp_cache (this_frame, this_cache, func,
1259 0x80 /* Offset to ucontext_t. */
1260 + 0xe0 /* Offset to .reg. */,
1261 128);
1262}
1263
1264static void
1266 frame_info_ptr this_frame,
1267 struct trad_frame_cache *this_cache,
1268 CORE_ADDR func)
1269{
1270 ppc_linux_sigtramp_cache (this_frame, this_cache, func,
1271 0x40 /* Offset to ucontext_t. */
1272 + 0x1c /* Offset to .reg. */,
1273 0);
1274}
1275
1276static void
1278 frame_info_ptr this_frame,
1279 struct trad_frame_cache *this_cache,
1280 CORE_ADDR func)
1281{
1282 ppc_linux_sigtramp_cache (this_frame, this_cache, func,
1283 0x80 /* Offset to struct sigcontext. */
1284 + 0x38 /* Offset to .reg. */,
1285 128);
1286}
1287
1290 4,
1291 {
1292 { 0x380000ac, ULONGEST_MAX }, /* li r0, 172 */
1293 { 0x44000002, ULONGEST_MAX }, /* sc */
1295 },
1297};
1300 4,
1301 {
1302 { 0x38210080, ULONGEST_MAX }, /* addi r1,r1,128 */
1303 { 0x380000ac, ULONGEST_MAX }, /* li r0, 172 */
1304 { 0x44000002, ULONGEST_MAX }, /* sc */
1306 },
1308};
1311 4,
1312 {
1313 { 0x38000077, ULONGEST_MAX }, /* li r0,119 */
1314 { 0x44000002, ULONGEST_MAX }, /* sc */
1316 },
1318};
1321 4,
1322 {
1323 { 0x38210080, ULONGEST_MAX }, /* addi r1,r1,128 */
1324 { 0x38000077, ULONGEST_MAX }, /* li r0,119 */
1325 { 0x44000002, ULONGEST_MAX }, /* sc */
1327 },
1329};
1330
1331/* Return 1 if PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM are usable. */
1332int
1334{
1335 /* If we do not have a target description with registers, then
1336 the special registers will not be included in the register set. */
1338 return 0;
1339
1340 /* If we do, then it is safe to check the size. */
1343}
1344
1345/* Return the current system call's number present in the
1346 r0 register. When the function fails, it returns -1. */
1347static LONGEST
1349 thread_info *thread)
1350{
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);
1354
1355 /* Make sure we're in a 32- or 64-bit machine */
1356 gdb_assert (tdep->wordsize == 4 || tdep->wordsize == 8);
1357
1358 /* The content of a register */
1359 gdb::byte_vector buf (tdep->wordsize);
1360
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 ());
1365
1366 return extract_signed_integer (buf.data (), tdep->wordsize, byte_order);
1367}
1368
1369/* PPC process record-replay */
1370
1373
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
1379 SYSCALL. */
1380
1381static enum gdb_syscall
1383{
1384 int result = -1;
1385
1386 if (syscall <= 165)
1387 result = syscall;
1388 else if (syscall >= 167 && syscall <= 190) /* Skip query_module 166 */
1389 result = syscall + 1;
1390 else if (syscall >= 192 && syscall <= 197) /* mmap2 */
1391 result = syscall;
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)
1405 {
1406 if (wordsize == 64)
1407 result = gdb_sys_newfstatat;
1408 else
1409 result = gdb_sys_fstatat64;
1410 }
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;
1421
1422 return (enum gdb_syscall) result;
1423}
1424
1425/* Record registers which might be clobbered during system call.
1426 Return 0 if successful. */
1427
1428static int
1430{
1431 struct gdbarch *gdbarch = regcache->arch ();
1432 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
1433 ULONGEST scnum;
1434 enum gdb_syscall syscall_gdb;
1435 int ret;
1436
1438 syscall_gdb = ppc_canonicalize_syscall (scnum, tdep->wordsize);
1439
1440 if (syscall_gdb < 0)
1441 {
1443 _("Process record and replay target doesn't "
1444 "support syscall number %d\n"), (int) scnum);
1445 return 0;
1446 }
1447
1448 if (syscall_gdb == gdb_sys_sigreturn
1449 || syscall_gdb == gdb_sys_rt_sigreturn)
1450 {
1451 int i, j;
1452 int regsets[] = { tdep->ppc_gp0_regnum,
1453 tdep->ppc_fp0_regnum,
1454 tdep->ppc_vr0_regnum,
1455 tdep->ppc_vsr0_upper_regnum };
1456
1457 for (j = 0; j < 4; j++)
1458 {
1459 if (regsets[j] == -1)
1460 continue;
1461 for (i = 0; i < 32; i++)
1462 {
1463 if (record_full_arch_list_add_reg (regcache, regsets[j] + i))
1464 return -1;
1465 }
1466 }
1467
1469 return -1;
1471 return -1;
1473 return -1;
1475 return -1;
1476
1477 return 0;
1478 }
1479
1480 if (tdep->wordsize == 8)
1481 ret = record_linux_system_call (syscall_gdb, regcache,
1483 else
1484 ret = record_linux_system_call (syscall_gdb, regcache,
1486
1487 if (ret != 0)
1488 return ret;
1489
1490 /* Record registers clobbered during syscall. */
1491 for (int i = 3; i <= 12; i++)
1492 {
1494 return -1;
1495 }
1497 return -1;
1499 return -1;
1501 return -1;
1503 return -1;
1504
1505 return 0;
1506}
1507
1508/* Record registers which might be clobbered during signal handling.
1509 Return 0 if successful. */
1510
1511static int
1513 enum gdb_signal signal)
1514{
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
1518 for details. */
1519 const int SIGNAL_FRAMESIZE = 128;
1520 const int sizeof_rt_sigframe = 1440 * 2 + 8 * 2 + 4 * 6 + 8 + 8 + 128 + 512;
1521 ULONGEST sp;
1522 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
1523 int i;
1524
1525 for (i = 3; i <= 12; i++)
1526 {
1528 return -1;
1529 }
1530
1532 return -1;
1534 return -1;
1536 return -1;
1538 return -1;
1540 return -1;
1541
1542 /* Record the change in the stack.
1543 frame-size = sizeof (struct rt_sigframe) + SIGNAL_FRAMESIZE */
1545 sp -= SIGNAL_FRAMESIZE;
1546 sp -= sizeof_rt_sigframe;
1547
1548 if (record_full_arch_list_add_mem (sp, SIGNAL_FRAMESIZE + sizeof_rt_sigframe))
1549 return -1;
1550
1552 return -1;
1553
1554 return 0;
1555}
1556
1557static void
1558ppc_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
1559{
1560 struct gdbarch *gdbarch = regcache->arch ();
1561
1563
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
1567 restart.
1568
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. */
1574}
1575
1576static const struct target_desc *
1578 struct target_ops *target,
1579 bfd *abfd)
1580{
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");
1590
1591 if (! section)
1592 return NULL;
1593
1594 switch (bfd_section_size (section))
1595 {
1596 case 48 * 4:
1597 features.wordsize = 4;
1598 break;
1599 case 48 * 8:
1600 features.wordsize = 8;
1601 break;
1602 default:
1603 return NULL;
1604 }
1605
1606 if (altivec)
1607 features.altivec = true;
1608
1609 if (vsx)
1610 features.vsx = true;
1611
1612 gdb::optional<gdb::byte_vector> auxv = target_read_auxv_raw (target);
1613 CORE_ADDR hwcap = linux_get_hwcap (auxv, target, gdbarch);
1614
1615 features.isa205 = ppc_linux_has_isa205 (hwcap);
1616
1617 if (ppr && dscr)
1618 {
1619 features.ppr_dscr = true;
1620
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. */
1625 if (tar && pmu)
1626 {
1627 features.isa207 = true;
1628 if (htmspr)
1629 features.htm = true;
1630 }
1631 }
1632
1633 return ppc_linux_match_description (features);
1634}
1635
1636
1637/* Implementation of `gdbarch_elf_make_msymbol_special', as defined in
1638 gdbarch.h. This implementation is used for the ELFv2 ABI only. */
1639
1640static void
1642{
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. */
1646 return;
1647
1648 elf_symbol_type *elf_sym = (elf_symbol_type *)sym;
1649
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))
1656 {
1657 default:
1658 break;
1659 case 8:
1660 msym->set_target_flag_1 (true);
1661 break;
1662 }
1663}
1664
1665/* Implementation of `gdbarch_skip_entrypoint', as defined in
1666 gdbarch.h. This implementation is used for the ELFv2 ABI only. */
1667
1668static CORE_ADDR
1670{
1671 struct bound_minimal_symbol fun;
1672 int local_entry_offset = 0;
1673
1674 fun = lookup_minimal_symbol_by_pc (pc);
1675 if (fun.minsym == NULL)
1676 return pc;
1677
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;
1682
1683 if (fun.value_address () <= pc
1684 && pc < fun.value_address () + local_entry_offset)
1685 return fun.value_address () + local_entry_offset;
1686
1687 return pc;
1688}
1689
1690/* Implementation of `gdbarch_stap_is_single_operand', as defined in
1691 gdbarch.h. */
1692
1693static int
1695{
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. */
1701}
1702
1703/* Implementation of `gdbarch_stap_parse_special_token', as defined in
1704 gdbarch.h. */
1705
1706static expr::operation_up
1708 struct stap_parse_info *p)
1709{
1710 if (isdigit (*p->arg))
1711 {
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;
1716 char *regname;
1717 int len;
1718
1719 while (isdigit (*s))
1720 ++s;
1721
1722 if (*s == '(')
1723 {
1724 /* It is a register displacement indeed. Returning 0 means we are
1725 deferring the treatment of this case to the generic parser. */
1726 return {};
1727 }
1728
1729 len = s - p->arg;
1730 regname = (char *) alloca (len + 2);
1731 regname[0] = 'r';
1732
1733 strncpy (regname + 1, p->arg, len);
1734 ++len;
1735 regname[len] = '\0';
1736
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);
1740
1741 p->arg = s;
1742
1743 return expr::make_operation<expr::register_operation> (regname);
1744 }
1745
1746 /* All the other tokens should be handled correctly by the generic
1747 parser. */
1748 return {};
1749}
1750
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. */
1754
1755static void
1757 int wordsize)
1758{
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
1763
1764 /* Simply return if it had been initialized. */
1765 if (record_tdep->size_pointer != 0)
1766 return;
1767
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. */
1770
1771 if (wordsize == 8)
1772 {
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;
1837 }
1838 else if (wordsize == 4)
1839 {
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;
1904 }
1905 else
1906 internal_error (_("unexpected wordsize"));
1907
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;
1914
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;
1921
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);
1933
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;
1984}
1985
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. */
1989
1990static const struct floatformat **
1992 const char *name, int len)
1993{
1994 if (len == 128 && name)
1995 {
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)
2002
2003 if (strcmp (name, "__ibm128") == 0)
2005 }
2006
2008}
2009
2010static bool
2012 const char *producer, const char *name)
2013{
2014 int gcc_major, gcc_minor;
2015
2016 if (producer_is_gcc (producer, &gcc_major, &gcc_minor))
2017 {
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))
2022 {
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
2027
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.
2032
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. */
2036 return true;
2037 }
2038 }
2039 return false;
2040}
2041
2042/* Specify the powerpc64le target triplet.
2043 This can be variations of
2044 ppc64le-{distro}-linux-gcc
2045 and
2046 powerpc64le-{distro}-linux-gcc. */
2047
2048static const char *
2050{
2051 return "p(ower)?pc64le";
2052}
2053
2054/* Specify the powerpc64 target triplet.
2055 This can be variations of
2056 ppc64-{distro}-linux-gcc
2057 and
2058 powerpc64-{distro}-linux-gcc. */
2059
2060static const char *
2062{
2063 return "p(ower)?pc64";
2064}
2065
2066/* Implement the linux_gcc_target_options method. */
2067
2068static std::string
2070{
2071 return "";
2072}
2073
2076 CORE_ADDR &displaced_pc)
2077{
2078 ppc_inferior_data *per_inferior = get_ppc_per_inferior (thread->inf);
2079 if (!per_inferior->disp_step_buf.has_value ())
2080 {
2081 /* Figure out where the displaced step buffer is. */
2082 CORE_ADDR disp_step_buf_addr
2084
2085 per_inferior->disp_step_buf.emplace (disp_step_buf_addr);
2086 }
2087
2088 return per_inferior->disp_step_buf->prepare (thread, displaced_pc);
2089}
2090
2091static void
2093 struct gdbarch *gdbarch)
2094{
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[] = { "(",
2099 NULL };
2100 static const char *const stap_register_indirection_suffixes[] = { ")",
2101 NULL };
2102
2103 linux_init_abi (info, gdbarch, 0);
2104
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)
2113 else
2115
2116 /* Support for floating-point data type variants. */
2118
2119 /* Support for replacing typedef record. */
2121
2122 /* Handle inferior calls during interrupted system calls. */
2124
2125 /* Get the syscall number from the arch's register. */
2127
2128 /* SystemTap functions. */
2129 set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
2138
2139 if (tdep->wordsize == 4)
2140 {
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. */
2150
2153
2154 /* Shared library handling. */
2158
2159 /* Setting the correct XML syscall filename. */
2161
2162 /* Trampolines. */
2167
2168 /* BFD target for core files. */
2169 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
2170 set_gdbarch_gcore_bfd_target (gdbarch, "elf32-powerpcle");
2171 else
2172 set_gdbarch_gcore_bfd_target (gdbarch, "elf32-powerpc");
2173
2175 {
2177 /* Override dynamic resolve function. */
2180 }
2182
2184 }
2185
2186 if (tdep->wordsize == 8)
2187 {
2188 if (tdep->elf_abi == POWERPC_ELF_V1)
2189 {
2190 /* Handle PPC GNU/Linux 64-bit function pointers (which are really
2191 function descriptors). */
2194
2197 }
2198 else
2199 {
2202
2204 }
2205
2206 /* Shared library handling. */
2210
2211 /* Setting the correct XML syscall filename. */
2213
2214 /* Trampolines. */
2219
2220 /* BFD target for core files. */
2221 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
2222 set_gdbarch_gcore_bfd_target (gdbarch, "elf64-powerpcle");
2223 else
2224 set_gdbarch_gcore_bfd_target (gdbarch, "elf64-powerpc");
2225 /* Set compiler triplet. */
2226 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
2228 else
2230 /* Set GCC target options. */
2232 }
2233
2237
2238 /* Enable TLS support. */
2241
2242 if (tdesc_data)
2243 {
2244 const struct tdesc_feature *feature;
2245
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). */
2251
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)
2256 {
2258 PPC_ORIG_R3_REGNUM, "orig_r3");
2260 PPC_TRAP_REGNUM, "trap");
2261 }
2262 }
2263
2264 /* Support reverse debugging. */
2268
2271
2272 /* Setup displaced stepping. */
2275
2276}
2277
2279void
int regnum
const char *const name
const struct floatformat ** default_floatformat_for_type(struct gdbarch *gdbarch, const char *name, int len)
Definition arch-utils.c:289
gdb::optional< gdb::byte_vector > target_read_auxv_raw(target_ops *ops)
Definition auxv.c:377
#define BREAKPOINT_MAX
Definition breakpoint.h:78
struct gdbarch * gdbarch
Definition inferior.h:661
enum register_status cooked_read(int regnum, gdb_byte *buf)
Definition regcache.c:698
gdbarch * arch() const
Definition regcache.c:231
void raw_collect_integer(int regnum, gdb_byte *addr, int addr_len, bool is_signed) const
Definition regcache.c:1143
enum register_status get_register_status(int regnum) const override
Definition regcache.c:304
struct inferior * inf
Definition gdbthread.h:301
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition corefile.c:306
static LONGEST extract_signed_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:465
return_value_convention
Definition defs.h:257
@ RETURN_VALUE_STRUCT_CONVENTION
Definition defs.h:267
displaced_step_prepare_status
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition frame.c:1399
CORE_ADDR get_frame_pc(frame_info_ptr frame)
Definition frame.c:2712
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:736
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
@ SIGTRAMP_FRAME
Definition frame.h:198
void set_gdbarch_process_record(struct gdbarch *gdbarch, gdbarch_process_record_ftype *process_record)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition gdbarch.c:2054
void set_gdbarch_return_value_as_value(struct gdbarch *gdbarch, gdbarch_return_value_as_value_ftype *return_value_as_value)
void set_gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr)
const gdb_byte * gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition gdbarch.c:2777
void set_gdbarch_dwarf2_omit_typedef_p(struct gdbarch *gdbarch, gdbarch_dwarf2_omit_typedef_p_ftype *dwarf2_omit_typedef_p)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
void set_gdbarch_stap_parse_special_token(struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype *stap_parse_special_token)
void set_gdbarch_stap_integer_prefixes(struct gdbarch *gdbarch, const char *const *stap_integer_prefixes)
Definition gdbarch.c:4560
void set_gdbarch_displaced_step_prepare(struct gdbarch *gdbarch, gdbarch_displaced_step_prepare_ftype *displaced_step_prepare)
void set_gdbarch_core_read_description(struct gdbarch *gdbarch, gdbarch_core_read_description_ftype *core_read_description)
void set_gdbarch_stap_gdb_register_prefix(struct gdbarch *gdbarch, const char *stap_gdb_register_prefix)
Definition gdbarch.c:4662
void set_gdbarch_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc)
void set_gdbarch_elf_make_msymbol_special(struct gdbarch *gdbarch, gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special)
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code)
void set_gdbarch_stap_is_single_operand(struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_get_syscall_number(struct gdbarch *gdbarch, gdbarch_get_syscall_number_ftype *get_syscall_number)
void set_gdbarch_gnu_triplet_regexp(struct gdbarch *gdbarch, gdbarch_gnu_triplet_regexp_ftype *gnu_triplet_regexp)
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition gdbarch.c:1930
void set_gdbarch_gcore_bfd_target(struct gdbarch *gdbarch, const char *gcore_bfd_target)
Definition gdbarch.c:4017
void set_gdbarch_stap_register_indirection_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_prefixes)
Definition gdbarch.c:4628
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition gdbarch.c:2037
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
Definition gdbarch.c:1663
void set_gdbarch_gcc_target_options(struct gdbarch *gdbarch, gdbarch_gcc_target_options_ftype *gcc_target_options)
const struct target_desc * gdbarch_target_desc(struct gdbarch *gdbarch)
Definition gdbarch.c:1423
void set_gdbarch_process_record_signal(struct gdbarch *gdbarch, gdbarch_process_record_signal_ftype *process_record_signal)
void set_gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address)
int gdbarch_fp0_regnum(struct gdbarch *gdbarch)
Definition gdbarch.c:2088
void set_gdbarch_memory_remove_breakpoint(struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition gdbarch.c:1941
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition gdbarch.c:1646
void set_gdbarch_skip_entrypoint(struct gdbarch *gdbarch, gdbarch_skip_entrypoint_ftype *skip_entrypoint)
void set_gdbarch_stap_register_indirection_suffixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_suffixes)
Definition gdbarch.c:4645
void set_gdbarch_floatformat_for_type(struct gdbarch *gdbarch, gdbarch_floatformat_for_type_ftype *floatformat_for_type)
void set_gdbarch_so_ops(struct gdbarch *gdbarch, const struct target_so_ops *so_ops)
Definition gdbarch.c:3380
void set_gdbarch_skip_solib_resolver(struct gdbarch *gdbarch, gdbarch_skip_solib_resolver_ftype *skip_solib_resolver)
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype *iterate_over_regset_sections)
void iterate_over_regset_sections_cb(const char *sect_name, int supply_size, int collect_size, const struct regset *regset, const char *human_name, void *cb_data)
Definition gdbarch.h:104
const struct floatformat * floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:125
const struct floatformat * floatformats_ieee_quad[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:93
CORE_ADDR glibc_skip_solib_resolver(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition glibc-tdep.c:38
enum exec_direction_kind execution_direction
Definition infrun.c:9768
@ EXEC_REVERSE
Definition infrun.h:114
int record_linux_system_call(enum gdb_syscall syscall, struct regcache *regcache, struct linux_record_tdep *tdep)
gdb_syscall
@ gdb_sys_sigreturn
@ gdb_sys_rt_sigreturn
@ gdb_sys_recvfrom
@ gdb_sys_fstatat64
@ gdb_sys_newfstatat
@ gdb_sys_tkill
@ gdb_sys_getrandom
@ gdb_sys_openat
@ gdb_sys_pipe2
@ gdb_sys_recv
@ gdb_sys_recvmsg
link_map_offsets * linux_lp64_fetch_link_map_offsets()
CORE_ADDR linux_displaced_step_location(struct gdbarch *gdbarch)
link_map_offsets * linux_ilp32_fetch_link_map_offsets()
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch, int num_disp_step_buffers)
CORE_ADDR linux_get_hwcap()
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition minsyms.c:996
std::unique_ptr< operation > operation_up
Definition expression.h:82
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
Definition osabi.c:146
@ GDB_OSABI_LINUX
Definition osabi.h:32
static void initialize_tdesc_powerpc_32l(void)
Definition powerpc-32l.c:10
static void initialize_tdesc_powerpc_64l(void)
Definition powerpc-64l.c:10
static void initialize_tdesc_powerpc_altivec32l(void)
static void initialize_tdesc_powerpc_altivec64l(void)
static void initialize_tdesc_powerpc_e500l(void)
static void initialize_tdesc_powerpc_isa205_32l(void)
static void initialize_tdesc_powerpc_isa205_64l(void)
static void initialize_tdesc_powerpc_isa205_altivec32l(void)
static void initialize_tdesc_powerpc_isa205_altivec64l(void)
static void initialize_tdesc_powerpc_isa205_ppr_dscr_vsx32l(void)
static void initialize_tdesc_powerpc_isa205_ppr_dscr_vsx64l(void)
static void initialize_tdesc_powerpc_isa205_vsx32l(void)
static void initialize_tdesc_powerpc_isa205_vsx64l(void)
static void initialize_tdesc_powerpc_isa207_htm_vsx32l(void)
static void initialize_tdesc_powerpc_isa207_htm_vsx64l(void)
static void initialize_tdesc_powerpc_isa207_vsx32l(void)
static void initialize_tdesc_powerpc_isa207_vsx64l(void)
static void initialize_tdesc_powerpc_vsx32l(void)
static void initialize_tdesc_powerpc_vsx64l(void)
bool ppc_linux_has_isa205(CORE_ADDR hwcap)
const struct target_desc * ppc_linux_match_description(struct ppc_linux_features features)
#define PPC_LINUX_SIZEOF_DSCRREGSET
#define PPC_LINUX_SIZEOF_CTARREGSET
#define PPC_LINUX_SIZEOF_PPRREGSET
#define PPC64_LINUX_SIZEOF_CGPRREGSET
#define PPC_LINUX_SIZEOF_EBBREGSET
#define PPC_LINUX_SIZEOF_CPPRREGSET
#define PPC_LINUX_SIZEOF_VSXREGSET
#define PPC_LINUX_SIZEOF_CVSXREGSET
const struct ppc_linux_features ppc_linux_no_features
#define PPC32_LINUX_SIZEOF_CGPRREGSET
#define PPC_LINUX_SIZEOF_TM_SPRREGSET
#define PPC_LINUX_SIZEOF_PMUREGSET
#define PPC_LINUX_SIZEOF_CFPRREGSET
#define PPC_LINUX_SIZEOF_CDSCRREGSET
#define PPC_LINUX_SIZEOF_VRREGSET
#define PPC_LINUX_SIZEOF_CVMXREGSET
#define PPC_LINUX_SIZEOF_TARREGSET
static void ppc_linux_write_pc(struct regcache *regcache, CORE_ADDR pc)
static void ppc_linux_collect_gregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t len)
static const struct regcache_map_entry ppc32_regmap_ppr[]
static const char * ppc64le_gnu_triplet_regexp(struct gdbarch *gdbarch)
static const struct ppc_insn_pattern powerpc32_plt_stub[]
static const struct regset ppc32_linux_vsxregset
const struct regset ppc32_linux_dscrregset
#define SIZE_OF_STRUCT_TERMIOS
static struct linux_record_tdep ppc64_linux_record_tdep
static int ppc_linux_memory_remove_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
const struct regset ppc32_linux_tm_sprregset
static const struct regset ppc64_linux_gregset
static const struct regcache_map_entry ppc32_regmap_pmu[]
static const struct regcache_map_entry ppc32_be_linux_vrregmap[]
static const struct ppc_insn_pattern powerpc32_plt_stub_so_1[]
static const struct regset ppc32_le_linux_cvmxregset
const struct regset * ppc_linux_vsxregset(void)
static void ppc_linux_collect_core_cpgrregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t len)
static LONGEST ppc_linux_get_syscall_number(struct gdbarch *gdbarch, thread_info *thread)
static int powerpc_linux_in_dynsym_resolve_code(CORE_ADDR pc)
const struct regset * ppc_linux_fpregset(void)
static expr::operation_up ppc_stap_parse_special_token(struct gdbarch *gdbarch, struct stap_parse_info *p)
static const struct regset ppc64_le_linux_cgprregset
#define XML_SYSCALL_FILENAME_PPC64
static const struct regcache_map_entry ppc32_regmap_dscr[]
static const struct regset ppc32_le_linux_vrregset
#define XML_SYSCALL_FILENAME_PPC
static void ppc_linux_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
static CORE_ADDR ppc_elfv2_skip_entrypoint(struct gdbarch *gdbarch, CORE_ADDR pc)
static const struct regset ppc32_be_linux_vrregset
static const struct regset ppc32_linux_fpregset
static const struct regcache_map_entry ppc32_linux_vsxregmap[]
static void ppc64_linux_sighandler_cache_init(const struct tramp_frame *self, frame_info_ptr this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func)
static const struct ppc_reg_offsets ppc32_linux_reg_offsets
static const struct regcache_map_entry ppc32_regmap_cvsx[]
const struct regset ppc32_linux_tarregset
const struct regset ppc32_linux_cfprregset
int ppc_linux_trap_reg_p(struct gdbarch *gdbarch)
void _initialize_ppc_linux_tdep()
static int ppc_linux_record_signal(struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal)
const struct regset ppc32_linux_pmuregset
static struct tramp_frame ppc64_linux_sighandler_tramp_frame
static const struct regcache_map_entry ppc32_regmap_cppr[]
static struct linux_record_tdep ppc_linux_record_tdep
static void ppc32_linux_sigaction_cache_init(const struct tramp_frame *self, frame_info_ptr this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func)
static void ppc_linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
static struct tramp_frame ppc64_linux_sigaction_tramp_frame
static const struct regcache_map_entry ppc64_le_regmap_cgpr[]
static struct tramp_frame ppc32_linux_sighandler_tramp_frame
static const struct regcache_map_entry ppc32_regmap_tar[]
static std::string ppc64_linux_gcc_target_options(struct gdbarch *gdbarch)
static const char * ppc64_gnu_triplet_regexp(struct gdbarch *gdbarch)
static const struct ppc_reg_offsets ppc64_linux_reg_offsets
static const struct target_desc * ppc_linux_core_read_description(struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd)
static displaced_step_prepare_status ppc_linux_displaced_step_prepare(gdbarch *arch, thread_info *thread, CORE_ADDR &displaced_pc)
static const struct regset ppc64_be_linux_cgprregset
static const struct regcache_map_entry ppc32_regmap_cgpr[]
static void ppc_linux_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
static const struct regcache_map_entry ppc32_be_regmap_cvmx[]
static const struct regset ppc32_be_linux_cvmxregset
static const struct regcache_map_entry ppc32_regmap_ebb[]
static const struct regcache_map_entry ppc64_be_regmap_cgpr[]
static const struct regset ppc32_linux_gregset
static const struct regset ppc32_linux_cgprregset
static int ppc_linux_syscall_record(struct regcache *regcache)
const struct regset * ppc_linux_gregset(int wordsize)
static const struct floatformat ** ppc_floatformat_for_type(struct gdbarch *gdbarch, const char *name, int len)
static void ppc_linux_sigtramp_cache(frame_info_ptr this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func, LONGEST offset, int bias)
const struct regset ppc32_linux_cvsxregset
static int ppc_stap_is_single_operand(struct gdbarch *gdbarch, const char *s)
static void ppc32_linux_sighandler_cache_init(const struct tramp_frame *self, frame_info_ptr this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func)
static struct target_so_ops powerpc_so_ops
const struct regset ppc32_linux_pprregset
const struct regset ppc32_linux_ebbregset
static const struct regcache_map_entry ppc32_regmap_tm_spr[]
static CORE_ADDR ppc_skip_trampoline_code(frame_info_ptr frame, CORE_ADDR pc)
static const struct regcache_map_entry ppc32_le_regmap_cvmx[]
static enum gdb_syscall ppc_canonicalize_syscall(int syscall, int wordsize)
static bool linux_dwarf2_omit_typedef_p(struct type *target_type, const char *producer, const char *name)
const struct regset ppc32_linux_ctarregset
static struct tramp_frame ppc32_linux_sigaction_tramp_frame
static void ppc_init_linux_record_tdep(struct linux_record_tdep *record_tdep, int wordsize)
const struct regset ppc32_linux_cdscrregset
#define POWERPC32_PLT_CHECK_LEN
const struct regset * ppc_linux_cvmxregset(struct gdbarch *gdbarch)
const struct regset * ppc_linux_cgprregset(struct gdbarch *gdbarch)
static const struct regcache_map_entry ppc32_regmap_cdscr[]
static const struct regcache_map_entry ppc32_le_linux_vrregmap[]
const struct regset ppc32_linux_cpprregset
const struct regset * ppc_linux_vrregset(struct gdbarch *gdbarch)
static void ppc_elfv2_elf_make_msymbol_special(asymbol *sym, struct minimal_symbol *msym)
static void ppc64_linux_sigaction_cache_init(const struct tramp_frame *self, frame_info_ptr this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func)
static const struct regcache_map_entry ppc32_regmap_ctar[]
static const struct ppc_insn_pattern powerpc32_plt_stub_so_2[]
static enum return_value_convention ppc_linux_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, struct value **read_value, const gdb_byte *writebuf)
static const struct regcache_map_entry ppc32_regmap_cfpr[]
@ PPC_TRAP_REGNUM
@ PPC_ORIG_R3_REGNUM
enum return_value_convention ppc_sysv_abi_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
void ppc_collect_gregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t len)
@ POWERPC_ELF_V1
Definition ppc-tdep.h:188
CORE_ADDR ppc_insn_d_field(unsigned int insn)
void ppc_supply_fpregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len)
@ POWERPC_LONG_DOUBLE_IEEE128
Definition ppc-tdep.h:208
int ppc_insns_match_pattern(frame_info_ptr frame, CORE_ADDR pc, const struct ppc_insn_pattern *pattern, unsigned int *insns)
void ppc_collect_reg(const struct regcache *regcache, int regnum, gdb_byte *regs, size_t offset, int regsize)
int ppc_floating_point_unit_p(struct gdbarch *gdbarch)
void ppc_supply_reg(struct regcache *regcache, int regnum, const gdb_byte *regs, size_t offset, int regsize)
ppc_inferior_data * get_ppc_per_inferior(inferior *inf)
void ppc_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
int ppc_process_record(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
@ PPC_CXER_REGNUM
Definition ppc-tdep.h:375
@ PPC_MMCR0_REGNUM
Definition ppc-tdep.h:362
@ PPC_CLR_REGNUM
Definition ppc-tdep.h:376
@ PPC_CVSCR_REGNUM
Definition ppc-tdep.h:383
@ PPC_CVRSAVE_REGNUM
Definition ppc-tdep.h:384
@ PPC_SIER_REGNUM
Definition ppc-tdep.h:366
@ PPC_DSCR_REGNUM
Definition ppc-tdep.h:353
@ PPC_VSR0_UPPER_REGNUM
Definition ppc-tdep.h:350
@ PPC_TAR_REGNUM
Definition ppc-tdep.h:354
@ PPC_VRSAVE_REGNUM
Definition ppc-tdep.h:349
@ PPC_CTAR_REGNUM
Definition ppc-tdep.h:390
@ PPC_TFIAR_REGNUM
Definition ppc-tdep.h:371
@ PPC_CCTR_REGNUM
Definition ppc-tdep.h:377
@ PPC_TFHAR_REGNUM
Definition ppc-tdep.h:369
@ PPC_CVSR0_UPPER_REGNUM
Definition ppc-tdep.h:386
@ PPC_CDSCR_REGNUM
Definition ppc-tdep.h:389
@ PPC_BESCR_REGNUM
Definition ppc-tdep.h:357
@ PPC_CPPR_REGNUM
Definition ppc-tdep.h:388
@ PPC_SIAR_REGNUM
Definition ppc-tdep.h:364
@ PPC_TEXASR_REGNUM
Definition ppc-tdep.h:370
@ PPC_CVR0_REGNUM
Definition ppc-tdep.h:382
@ PPC_R0_REGNUM
Definition ppc-tdep.h:334
@ PPC_VR0_REGNUM
Definition ppc-tdep.h:347
@ PPC_EBBRR_REGNUM
Definition ppc-tdep.h:359
@ PPC_CCR_REGNUM
Definition ppc-tdep.h:374
@ PPC_CFPSCR_REGNUM
Definition ppc-tdep.h:380
@ PPC_EBBHR_REGNUM
Definition ppc-tdep.h:358
@ PPC_SDAR_REGNUM
Definition ppc-tdep.h:365
@ PPC_VSCR_REGNUM
Definition ppc-tdep.h:348
@ PPC_MSR_REGNUM
Definition ppc-tdep.h:337
@ PPC_CF0_REGNUM
Definition ppc-tdep.h:379
@ PPC_PPR_REGNUM
Definition ppc-tdep.h:352
@ PPC_CR0_REGNUM
Definition ppc-tdep.h:373
@ PPC_MMCR2_REGNUM
Definition ppc-tdep.h:363
void ppc_collect_fpregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *fpregs, size_t len)
CORE_ADDR ppc64_skip_trampoline_code(frame_info_ptr frame, CORE_ADDR pc)
Definition ppc64-tdep.c:710
void ppc64_elf_make_msymbol_special(asymbol *sym, struct minimal_symbol *msym)
Definition ppc64-tdep.c:796
CORE_ADDR ppc64_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition ppc64-tdep.c:747
int producer_is_gcc(const char *producer, int *major, int *minor)
Definition producer.c:44
int record_full_arch_list_add_reg(struct regcache *regcache, int regnum)
int record_full_arch_list_add_mem(CORE_ADDR addr, int len)
int record_full_arch_list_add_end(void)
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
Definition regcache.c:1273
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition regcache.c:649
int register_size(struct gdbarch *gdbarch, int regnum)
Definition regcache.c:170
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
Definition regcache.c:400
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:825
void regcache_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
Definition regcache.c:1251
@ REGCACHE_MAP_SKIP
Definition regcache.h:121
#define REGSET_VARIABLE_SIZE
Definition regset.h:52
void(* func)(remote_target *remote, char *)
static const char *const stap_register_indirection_prefixes[]
static const char *const stap_register_indirection_suffixes[]
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
const struct target_so_ops svr4_so_ops
int svr4_in_dynsym_resolve_code(CORE_ADDR pc)
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
gdb_byte shadow_contents[BREAKPOINT_MAX]
Definition breakpoint.h:279
CORE_ADDR reqstd_address
Definition breakpoint.h:269
const char * linkage_name() const
Definition symtab.h:460
ULONGEST ioctl_TIOCGLCKTRMIOS
ULONGEST ioctl_TIOCMIWAIT
ULONGEST ioctl_TCGETA
ULONGEST ioctl_TIOCGICOUNT
ULONGEST ioctl_TIOCMBIC
ULONGEST ioctl_TIOCMBIS
ULONGEST ioctl_TIOCSERGSTRUCT
ULONGEST ioctl_TIOCGPTN
ULONGEST ioctl_TIOCSERGETMULTI
ULONGEST ioctl_TIOCGSID
ULONGEST ioctl_FIOQSIZE
ULONGEST ioctl_TIOCSERCONFIG
ULONGEST ioctl_FIONCLEX
ULONGEST ioctl_TIOCSSOFTCAR
ULONGEST ioctl_TIOCSWINSZ
ULONGEST ioctl_TCSETSF
ULONGEST ioctl_TIOCLINUX
ULONGEST ioctl_TIOCSBRK
ULONGEST ioctl_TIOCGPGRP
ULONGEST ioctl_TIOCSERSETMULTI
ULONGEST ioctl_TCSETS
ULONGEST ioctl_TIOCSSERIAL
int size_serial_icounter_struct
ULONGEST ioctl_TIOCSPTLCK
ULONGEST ioctl_TIOCGETD
ULONGEST ioctl_FIONREAD
ULONGEST ioctl_TIOCCBRK
ULONGEST ioctl_TCGETS
ULONGEST ioctl_TIOCGSOFTCAR
ULONGEST ioctl_TIOCNOTTY
ULONGEST ioctl_TIOCSPGRP
ULONGEST ioctl_TIOCGSERIAL
ULONGEST ioctl_FIOASYNC
ULONGEST ioctl_TIOCSERGETLSR
ULONGEST ioctl_TIOCOUTQ
ULONGEST ioctl_TIOCMGET
ULONGEST ioctl_TIOCGWINSZ
ULONGEST ioctl_TIOCSERGWILD
ULONGEST ioctl_TIOCCONS
ULONGEST ioctl_TIOCSCTTY
ULONGEST ioctl_TIOCSETD
ULONGEST ioctl_TIOCSLCKTRMIOS
ULONGEST ioctl_TIOCEXCL
ULONGEST ioctl_TIOCNXCL
ULONGEST ioctl_TCSETSW
ULONGEST ioctl_TIOCMSET
ULONGEST ioctl_TIOCSERSWILD
bool target_flag_1() const
Definition symtab.h:806
void set_target_flag_1(bool target_flag_1)
Definition symtab.h:813
int(* ppc_syscall_record)(struct regcache *regcache)
Definition ppc-tdep.h:311
int ppc_vsr0_upper_regnum
Definition ppc-tdep.h:246
gdb::optional< displaced_step_buffers > disp_step_buf
Definition ppc-tdep.h:450
Definition regcache.h:111
const void * regmap
Definition regset.h:39
collect_regset_ftype * collect_regset
Definition regset.h:45
const char * arg
Definition stap-probe.h:45
const char * saved_arg
Definition stap-probe.h:53
int(* in_dynsym_resolve_code)(CORE_ADDR pc)
Definition solist.h:121
type_code code() const
Definition gdbtypes.h:956
ULONGEST length() const
Definition gdbtypes.h:983
bool is_vector() const
Definition gdbtypes.h:1186
Definition value.h:130
static struct value * allocate(struct type *type)
Definition value.c:957
const struct tdesc_feature * tdesc_find_feature(const struct target_desc *target_desc, const char *name)
int tdesc_numbered_register(const struct tdesc_feature *feature, struct tdesc_arch_data *data, int regno, const char *name)
static const registry< gdbarch >::key< tdesc_arch_data > tdesc_data
int tdesc_has_registers(const struct target_desc *target_desc)
scoped_restore_tmpl< int > make_scoped_restore_show_memory_breakpoints(int show)
Definition target.c:1667
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
int target_write_raw_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition target.c:1878
void trad_frame_set_reg_addr(struct trad_frame_cache *this_trad_cache, int regnum, CORE_ADDR addr)
Definition trad-frame.c:110
void trad_frame_set_id(struct trad_frame_cache *this_trad_cache, struct frame_id this_id)
Definition trad-frame.c:220
void tramp_frame_prepend_unwinder(struct gdbarch *gdbarch, const struct tramp_frame *tramp_frame)
#define TRAMP_SENTINEL_INSN
Definition tramp-frame.h:44
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
Definition user-regs.c:132
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
#define gdb_stderr
Definition utils.h:187
void set_xml_syscall_file_name(struct gdbarch *gdbarch, const char *name)
Definition xml-syscall.c:50