GDB (xrefs)
Loading...
Searching...
No Matches
rs6000-aix-tdep.c
Go to the documentation of this file.
1/* Native support code for PPC AIX, for GDB the GNU debugger.
2
3 Copyright (C) 2006-2023 Free Software Foundation, Inc.
4
5 Free Software Foundation, Inc.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22#include "defs.h"
23#include "osabi.h"
24#include "regcache.h"
25#include "regset.h"
26#include "gdbtypes.h"
27#include "gdbcore.h"
28#include "target.h"
29#include "value.h"
30#include "infcall.h"
31#include "objfiles.h"
32#include "breakpoint.h"
33#include "ppc-tdep.h"
34#include "rs6000-aix-tdep.h"
35#include "xcoffread.h"
36#include "solib.h"
37#include "solib-aix.h"
38#include "target-float.h"
39#include "gdbsupport/xml-utils.h"
40#include "trad-frame.h"
41#include "frame-unwind.h"
42
43/* If the kernel has to deliver a signal, it pushes a sigcontext
44 structure on the stack and then calls the signal handler, passing
45 the address of the sigcontext in an argument register. Usually
46 the signal handler doesn't save this register, so we have to
47 access the sigcontext structure via an offset from the signal handler
48 frame.
49 The following constants were determined by experimentation on AIX 3.2.
50
51 sigcontext structure have the mstsave saved under the
52 sc_jmpbuf.jmp_context. STKMIN(minimum stack size) is 56 for 32-bit
53 processes, and iar offset under sc_jmpbuf.jmp_context is 40.
54 ie offsetof(struct sigcontext, sc_jmpbuf.jmp_context.iar).
55 so PC offset in this case is STKMIN+iar offset, which is 96. */
56
57#define SIG_FRAME_PC_OFFSET 96
58#define SIG_FRAME_LR_OFFSET 108
59/* STKMIN+grp1 offset, which is 56+228=284 */
60#define SIG_FRAME_FP_OFFSET 284
61
62/* 64 bit process.
63 STKMIN64 is 112 and iar offset is 312. So 112+312=424 */
64#define SIG_FRAME_LR_OFFSET64 424
65/* STKMIN64+grp1 offset. 112+56=168 */
66#define SIG_FRAME_FP_OFFSET64 168
67
68/* Minimum possible text address in AIX. */
69#define AIX_TEXT_SEGMENT_BASE 0x10000000
70
77
79{
80 /* AltiVec registers. */
81 32, /* vr0_offset */
82 544, /* vscr_offset. */
83 560 /* vrsave_offset */
84};
85
86static int
88 const struct rs6000_aix_reg_vrreg_offset *offsets,
89 int regnum)
90{
91 if (regnum >= tdep->ppc_vr0_regnum &&
92 regnum < tdep->ppc_vr0_regnum + ppc_num_vrs)
93 return offsets->vr0_offset + (regnum - tdep->ppc_vr0_regnum) * 16;
94
95 if (regnum == tdep->ppc_vrsave_regnum - 1)
96 return offsets->vscr_offset;
97
98 if (regnum == tdep->ppc_vrsave_regnum)
99 return offsets->vrsave_offset;
100
101 return -1;
102}
103
104static void
106 int regnum, const void *vrregs, size_t len)
107{
108 struct gdbarch *gdbarch = regcache->arch ();
109 const struct rs6000_aix_reg_vrreg_offset *offsets;
110 size_t offset;
111 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
112 if (!(tdep->ppc_vr0_regnum >= 0 && tdep->ppc_vrsave_regnum >= 0))
113 return;
114
115 offsets = (const struct rs6000_aix_reg_vrreg_offset *) regset->regmap;
116 if (regnum == -1)
117 {
118 int i;
119
120 for (i = tdep->ppc_vr0_regnum, offset = offsets->vr0_offset;
121 i < tdep->ppc_vr0_regnum + ppc_num_vrs;
122 i++, offset += 16)
123 ppc_supply_reg (regcache, i, (const gdb_byte *) vrregs, offset, 16);
124
126 (const gdb_byte *) vrregs, offsets->vscr_offset, 4);
127
129 (const gdb_byte *) vrregs, offsets->vrsave_offset, 4);
130
131 return;
132 }
133 offset = rs6000_aix_get_vrreg_offset (tdep, offsets, regnum);
134 if (regnum != tdep->ppc_vrsave_regnum &&
135 regnum != tdep->ppc_vrsave_regnum - 1)
136 ppc_supply_reg (regcache, regnum, (const gdb_byte *) vrregs, offset, 16);
137 else
139 (const gdb_byte *) vrregs, offset, 4);
140
141}
142
143static void
145 int regnum, const void *vsxregs, size_t len)
146{
147 struct gdbarch *gdbarch = regcache->arch ();
148 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
149 if (!(tdep->ppc_vsr0_regnum >= 0))
150 return;
151
152 if (regnum == -1)
153 {
154 int i, offset = 0;
155
156 for (i = tdep->ppc_vsr0_upper_regnum; i < tdep->ppc_vsr0_upper_regnum
157 + 32; i++, offset += 8)
158 ppc_supply_reg (regcache, i, (const gdb_byte *) vsxregs, offset, 8);
159
160 return;
161 }
162 else
163 ppc_supply_reg (regcache, regnum, (const gdb_byte *) vsxregs, 0, 8);
164}
165
166static void
168 const struct regcache *regcache,
169 int regnum, void *vsxregs, size_t len)
170{
171 struct gdbarch *gdbarch = regcache->arch ();
172 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
173 if (!(tdep->ppc_vsr0_regnum >= 0))
174 return;
175
176 if (regnum == -1)
177 {
178 int i;
179 int offset = 0;
180 for (i = tdep->ppc_vsr0_upper_regnum; i < tdep->ppc_vsr0_upper_regnum
181 + 32; i++, offset += 8)
182 ppc_collect_reg (regcache, i, (gdb_byte *) vsxregs, offset, 8);
183
184 return;
185 }
186 else
187 ppc_collect_reg (regcache, regnum, (gdb_byte *) vsxregs, 0, 8);
188}
189
190static void
192 const struct regcache *regcache,
193 int regnum, void *vrregs, size_t len)
194{
195 struct gdbarch *gdbarch = regcache->arch ();
196 const struct rs6000_aix_reg_vrreg_offset *offsets;
197 size_t offset;
198
199 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
200 if (!(tdep->ppc_vr0_regnum >= 0 && tdep->ppc_vrsave_regnum >= 0))
201 return;
202
203 offsets = (const struct rs6000_aix_reg_vrreg_offset *) regset->regmap;
204 if (regnum == -1)
205 {
206 int i;
207
208 for (i = tdep->ppc_vr0_regnum, offset = offsets->vr0_offset; i <
209 tdep->ppc_vr0_regnum + ppc_num_vrs; i++, offset += 16)
210 ppc_collect_reg (regcache, i, (gdb_byte *) vrregs, offset, 16);
211
213 (gdb_byte *) vrregs, offsets->vscr_offset, 4);
214
216 (gdb_byte *) vrregs, offsets->vrsave_offset, 4);
217
218 return;
219 }
220
221 offset = rs6000_aix_get_vrreg_offset (tdep, offsets, regnum);
222 if (regnum != tdep->ppc_vrsave_regnum
223 && regnum != tdep->ppc_vrsave_regnum - 1)
224 ppc_collect_reg (regcache, regnum, (gdb_byte *) vrregs, offset, 16);
225 else
227 (gdb_byte *) vrregs, offset, 4);
228}
229
235
241
242static struct trad_frame_cache *
244 void **this_cache)
245{
246 LONGEST backchain;
247 CORE_ADDR base, base_orig, func;
248 struct gdbarch *gdbarch = get_frame_arch (this_frame);
249 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
250 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
251 struct trad_frame_cache *this_trad_cache;
252
253 if ((*this_cache) != NULL)
254 return (struct trad_frame_cache *) (*this_cache);
255
256 this_trad_cache = trad_frame_cache_zalloc (this_frame);
257 (*this_cache) = this_trad_cache;
258
261 base_orig = base;
262
263 if (tdep->wordsize == 4)
264 {
267 tdep->wordsize, byte_order);
269 tdep->wordsize, byte_order, &backchain);
270 base = (CORE_ADDR)backchain;
271 }
272 else
273 {
276 tdep->wordsize, byte_order);
278 tdep->wordsize, byte_order, &backchain);
279 base = (CORE_ADDR)backchain;
280 }
281
283 trad_frame_set_reg_value (this_trad_cache, gdbarch_sp_regnum (gdbarch), base);
284
285 if (tdep->wordsize == 4)
286 trad_frame_set_reg_addr (this_trad_cache, tdep->ppc_lr_regnum,
287 base_orig + 0x38 + 52 + 8);
288 else
289 trad_frame_set_reg_addr (this_trad_cache, tdep->ppc_lr_regnum,
290 base_orig + 0x70 + 320);
291
292 trad_frame_set_id (this_trad_cache, frame_id_build (base, func));
293 trad_frame_set_this_base (this_trad_cache, base);
294
295 return this_trad_cache;
296}
297
298static void
300 void **this_prologue_cache,
301 struct frame_id *this_id)
302{
303 struct trad_frame_cache *this_trad_cache
304 = aix_sighandle_frame_cache (this_frame, this_prologue_cache);
305 trad_frame_get_id (this_trad_cache, this_id);
306}
307
308static struct value *
310 void **this_prologue_cache, int regnum)
311{
312 struct trad_frame_cache *this_trad_cache
313 = aix_sighandle_frame_cache (this_frame, this_prologue_cache);
314 return trad_frame_get_register (this_trad_cache, this_frame, regnum);
315}
316
317static int
320 void **this_prologue_cache)
321{
322 CORE_ADDR pc = get_frame_pc (this_frame);
323 if (pc && pc < AIX_TEXT_SEGMENT_BASE)
324 return 1;
325
326 return 0;
327}
328
329/* AIX signal handler frame unwinder */
330
340
341/* Core file support. */
342
344{
345 /* General-purpose registers. */
346 208, /* r0_offset */
347 4, /* gpr_size */
348 4, /* xr_size */
349 24, /* pc_offset */
350 28, /* ps_offset */
351 32, /* cr_offset */
352 36, /* lr_offset */
353 40, /* ctr_offset */
354 44, /* xer_offset */
355 48, /* mq_offset */
356
357 /* Floating-point registers. */
358 336, /* f0_offset */
359 56, /* fpscr_offset */
360 4 /* fpscr_size */
361};
362
364{
365 /* General-purpose registers. */
366 0, /* r0_offset */
367 8, /* gpr_size */
368 4, /* xr_size */
369 264, /* pc_offset */
370 256, /* ps_offset */
371 288, /* cr_offset */
372 272, /* lr_offset */
373 280, /* ctr_offset */
374 292, /* xer_offset */
375 -1, /* mq_offset */
376
377 /* Floating-point registers. */
378 312, /* f0_offset */
379 296, /* fpscr_offset */
380 4 /* fpscr_size */
381};
382
383
384/* Supply register REGNUM in the general-purpose register set REGSET
385 from the buffer specified by GREGS and LEN to register cache
386 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
387
388static void
390 struct regcache *regcache, int regnum,
391 const void *gregs, size_t len)
392{
395}
396
397/* Collect register REGNUM in the general-purpose register set
398 REGSET, from register cache REGCACHE into the buffer specified by
399 GREGS and LEN. If REGNUM is -1, do this for all registers in
400 REGSET. */
401
402static void
404 const struct regcache *regcache, int regnum,
405 void *gregs, size_t len)
406{
409}
410
411/* AIX register set. */
412
419
426
427/* Iterate over core file register note sections. */
428
429static void
432 void *cb_data,
433 const struct regcache *regcache)
434{
435 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
436 int have_altivec = tdep->ppc_vr0_regnum != -1;
437 int have_vsx = tdep->ppc_vsr0_upper_regnum != -1;
438
439 if (tdep->wordsize == 4)
440 cb (".reg", 592, 592, &rs6000_aix32_regset, NULL, cb_data);
441 else
442 cb (".reg", 576, 576, &rs6000_aix64_regset, NULL, cb_data);
443
444 if (have_altivec)
445 cb (".aix-vmx", 560, 560, &rs6000_aix_vrregset, "AIX altivec", cb_data);
446
447 if (have_vsx)
448 cb (".aix-vsx", 256, 256, &rs6000_aix_vsxregset, "AIX vsx", cb_data);
449
450}
451
452/* Read core file description for AIX. */
453
454static const struct target_desc *
456 struct target_ops *target,
457 bfd *abfd)
458{
459 asection *altivec = bfd_get_section_by_name (abfd, ".aix-vmx");
460 asection *vsx = bfd_get_section_by_name (abfd, ".aix-vsx");
461 asection *section = bfd_get_section_by_name (abfd, ".reg");
462 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
463
464 if (!section)
465 return NULL;
466
467 int arch64 = 0;
468 if (tdep->wordsize == 8)
469 arch64 = 1;
470
471 if (vsx && arch64)
472 return tdesc_powerpc_vsx64;
473 else if (vsx && !arch64)
474 return tdesc_powerpc_vsx32;
475 else if (altivec && arch64)
477 else if (altivec && !arch64)
479
480 return NULL;
481}
482
483/* Pass the arguments in either registers, or in the stack. In RS/6000,
484 the first eight words of the argument list (that might be less than
485 eight parameters if some parameters occupy more than one word) are
486 passed in r3..r10 registers. Float and double parameters are
487 passed in fpr's, in addition to that. Rest of the parameters if any
488 are passed in user stack. There might be cases in which half of the
489 parameter is copied into registers, the other half is pushed into
490 stack.
491
492 Stack must be aligned on 64-bit boundaries when synthesizing
493 function calls.
494
495 If the function is returning a structure, then the return address is passed
496 in r3, then the first 7 words of the parameters can be passed in registers,
497 starting from r4. */
498
499static CORE_ADDR
500rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
501 struct regcache *regcache, CORE_ADDR bp_addr,
502 int nargs, struct value **args, CORE_ADDR sp,
503 function_call_return_method return_method,
504 CORE_ADDR struct_addr)
505{
506 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
507 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
508 int ii;
509 int len = 0;
510 int argno; /* current argument number */
511 int argbytes; /* current argument byte */
512 gdb_byte tmp_buffer[50];
513 int f_argno = 0; /* current floating point argno */
514 int wordsize = tdep->wordsize;
515 CORE_ADDR func_addr = find_function_addr (function, NULL);
516
517 struct value *arg = 0;
518 struct type *type;
519
520 ULONGEST saved_sp;
521
522 /* The calling convention this function implements assumes the
523 processor has floating-point registers. We shouldn't be using it
524 on PPC variants that lack them. */
525 gdb_assert (ppc_floating_point_unit_p (gdbarch));
526
527 /* The first eight words of ther arguments are passed in registers.
528 Copy them appropriately. */
529 ii = 0;
530
531 /* If the function is returning a `struct', then the first word
532 (which will be passed in r3) is used for struct return address.
533 In that case we should advance one word and start from r4
534 register to copy parameters. */
535 if (return_method == return_method_struct)
536 {
538 struct_addr);
539 ii++;
540 }
541
542/* effectively indirect call... gcc does...
543
544 return_val example( float, int);
545
546 eabi:
547 float in fp0, int in r3
548 offset of stack on overflow 8/16
549 for varargs, must go by type.
550 power open:
551 float in r3&r4, int in r5
552 offset of stack on overflow different
553 both:
554 return in r3 or f0. If no float, must study how gcc emulates floats;
555 pay attention to arg promotion.
556 User may have to cast\args to handle promotion correctly
557 since gdb won't know if prototype supplied or not. */
558
559 for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii)
560 {
561 int reg_size = register_size (gdbarch, ii + 3);
562
563 arg = args[argno];
564 type = check_typedef (arg->type ());
565 len = type->length ();
566
567 if (type->code () == TYPE_CODE_FLT)
568 {
569 /* Floating point arguments are passed in fpr's, as well as gpr's.
570 There are 13 fpr's reserved for passing parameters. At this point
571 there is no way we would run out of them.
572
573 Always store the floating point value using the register's
574 floating-point format. */
575 const int fp_regnum = tdep->ppc_fp0_regnum + 1 + f_argno;
576 gdb_byte reg_val[PPC_MAX_REGISTER_SIZE];
577 struct type *reg_type = register_type (gdbarch, fp_regnum);
578
579 gdb_assert (len <= 8);
580
581 target_float_convert (arg->contents ().data (), type, reg_val,
582 reg_type);
583 regcache->cooked_write (fp_regnum, reg_val);
584 ++f_argno;
585 }
586
587 if (len > reg_size)
588 {
589
590 /* Argument takes more than one register. */
591 while (argbytes < len)
592 {
593 gdb_byte word[PPC_MAX_REGISTER_SIZE];
594 memset (word, 0, reg_size);
595 memcpy (word,
596 ((char *) arg->contents ().data ()) + argbytes,
597 (len - argbytes) > reg_size
598 ? reg_size : len - argbytes);
599 regcache->cooked_write (tdep->ppc_gp0_regnum + 3 + ii, word);
600 ++ii, argbytes += reg_size;
601
602 if (ii >= 8)
603 goto ran_out_of_registers_for_arguments;
604 }
605 argbytes = 0;
606 --ii;
607 }
608 else
609 {
610 /* Argument can fit in one register. No problem. */
611 gdb_byte word[PPC_MAX_REGISTER_SIZE];
612
613 memset (word, 0, reg_size);
614 if (type->code () == TYPE_CODE_INT
615 || type->code () == TYPE_CODE_ENUM
616 || type->code () == TYPE_CODE_BOOL
617 || type->code () == TYPE_CODE_CHAR)
618 /* Sign or zero extend the "int" into a "word". */
619 store_unsigned_integer (word, reg_size, byte_order,
620 unpack_long (type, arg->contents ().data ()));
621 else
622 memcpy (word, arg->contents ().data (), len);
623 regcache->cooked_write (tdep->ppc_gp0_regnum + 3 +ii, word);
624 }
625 ++argno;
626 }
627
628ran_out_of_registers_for_arguments:
629
632 &saved_sp);
633
634 /* Location for 8 parameters are always reserved. */
635 sp -= wordsize * 8;
636
637 /* Another six words for back chain, TOC register, link register, etc. */
638 sp -= wordsize * 6;
639
640 /* Stack pointer must be quadword aligned. */
641 sp &= -16;
642
643 /* If there are more arguments, allocate space for them in
644 the stack, then push them starting from the ninth one. */
645
646 if ((argno < nargs) || argbytes)
647 {
648 int space = 0, jj;
649
650 if (argbytes)
651 {
652 space += ((len - argbytes + wordsize -1) & -wordsize);
653 jj = argno + 1;
654 }
655 else
656 jj = argno;
657
658 for (; jj < nargs; ++jj)
659 {
660 struct value *val = args[jj];
661 space += ((val->type ()->length () + wordsize -1) & -wordsize);
662 }
663
664 /* Add location required for the rest of the parameters. */
665 space = (space + 15) & -16;
666 sp -= space;
667
668 /* This is another instance we need to be concerned about
669 securing our stack space. If we write anything underneath %sp
670 (r1), we might conflict with the kernel who thinks he is free
671 to use this area. So, update %sp first before doing anything
672 else. */
673
676
677 /* If the last argument copied into the registers didn't fit there
678 completely, push the rest of it into stack. */
679
680 if (argbytes)
681 {
682 write_memory (sp + 6 * wordsize + (ii * wordsize),
683 arg->contents ().data () + argbytes,
684 len - argbytes);
685 ++argno;
686 ii += ((len - argbytes + wordsize - 1) & -wordsize) / wordsize;
687 }
688
689 /* Push the rest of the arguments into stack. */
690 for (; argno < nargs; ++argno)
691 {
692
693 arg = args[argno];
694 type = check_typedef (arg->type ());
695 len = type->length ();
696
697
698 /* Float types should be passed in fpr's, as well as in the
699 stack. */
700 if (type->code () == TYPE_CODE_FLT && f_argno < 13)
701 {
702
703 gdb_assert (len <= 8);
704
705 regcache->cooked_write (tdep->ppc_fp0_regnum + 1 + f_argno,
706 arg->contents ().data ());
707 ++f_argno;
708 }
709
710 if (type->code () == TYPE_CODE_INT
711 || type->code () == TYPE_CODE_ENUM
712 || type->code () == TYPE_CODE_BOOL
713 || type->code () == TYPE_CODE_CHAR )
714 {
715 gdb_byte word[PPC_MAX_REGISTER_SIZE];
716 memset (word, 0, PPC_MAX_REGISTER_SIZE);
717 store_unsigned_integer (word, tdep->wordsize, byte_order,
718 unpack_long (type, arg->contents ().data ()));
719 write_memory (sp + 6 * wordsize + (ii * wordsize), word, PPC_MAX_REGISTER_SIZE);
720 }
721 else
722 write_memory (sp + 6 * wordsize + (ii * wordsize), arg->contents ().data (), len);
723 ii += ((len + wordsize -1) & -wordsize) / wordsize;
724 }
725 }
726
727 /* Set the stack pointer. According to the ABI, the SP is meant to
728 be set _before_ the corresponding stack space is used. On AIX,
729 this even applies when the target has been completely stopped!
730 Not doing this can lead to conflicts with the kernel which thinks
731 that it still has control over this not-yet-allocated stack
732 region. */
734
735 /* Set back chain properly. */
736 store_unsigned_integer (tmp_buffer, wordsize, byte_order, saved_sp);
737 write_memory (sp, tmp_buffer, wordsize);
738
739 /* Point the inferior function call's return address at the dummy's
740 breakpoint. */
742
743 /* Set the TOC register value. */
745 solib_aix_get_toc_value (func_addr));
746
748 return sp;
749}
750
751static enum return_value_convention
752rs6000_return_value (struct gdbarch *gdbarch, struct value *function,
753 struct type *valtype, struct regcache *regcache,
754 gdb_byte *readbuf, const gdb_byte *writebuf)
755{
756 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
757 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
758
759 /* The calling convention this function implements assumes the
760 processor has floating-point registers. We shouldn't be using it
761 on PowerPC variants that lack them. */
762 gdb_assert (ppc_floating_point_unit_p (gdbarch));
763
764 /* AltiVec extension: Functions that declare a vector data type as a
765 return value place that return value in VR2. */
766 if (valtype->code () == TYPE_CODE_ARRAY && valtype->is_vector ()
767 && valtype->length () == 16)
768 {
769 if (readbuf)
770 regcache->cooked_read (tdep->ppc_vr0_regnum + 2, readbuf);
771 if (writebuf)
772 regcache->cooked_write (tdep->ppc_vr0_regnum + 2, writebuf);
773
775 }
776
777 /* If the called subprogram returns an aggregate, there exists an
778 implicit first argument, whose value is the address of a caller-
779 allocated buffer into which the callee is assumed to store its
780 return value. All explicit parameters are appropriately
781 relabeled. */
782 if (valtype->code () == TYPE_CODE_STRUCT
783 || valtype->code () == TYPE_CODE_UNION
784 || valtype->code () == TYPE_CODE_ARRAY)
786
787 /* Scalar floating-point values are returned in FPR1 for float or
788 double, and in FPR1:FPR2 for quadword precision. Fortran
789 complex*8 and complex*16 are returned in FPR1:FPR2, and
790 complex*32 is returned in FPR1:FPR4. */
791 if (valtype->code () == TYPE_CODE_FLT
792 && (valtype->length () == 4 || valtype->length () == 8))
793 {
794 struct type *regtype = register_type (gdbarch, tdep->ppc_fp0_regnum);
795 gdb_byte regval[8];
796
797 /* FIXME: kettenis/2007-01-01: Add support for quadword
798 precision and complex. */
799
800 if (readbuf)
801 {
802 regcache->cooked_read (tdep->ppc_fp0_regnum + 1, regval);
803 target_float_convert (regval, regtype, readbuf, valtype);
804 }
805 if (writebuf)
806 {
807 target_float_convert (writebuf, valtype, regval, regtype);
808 regcache->cooked_write (tdep->ppc_fp0_regnum + 1, regval);
809 }
810
812 }
813
814 /* Values of the types int, long, short, pointer, and char (length
815 is less than or equal to four bytes), as well as bit values of
816 lengths less than or equal to 32 bits, must be returned right
817 justified in GPR3 with signed values sign extended and unsigned
818 values zero extended, as necessary. */
819 if (valtype->length () <= tdep->wordsize)
820 {
821 if (readbuf)
822 {
823 ULONGEST regval;
824
825 /* For reading we don't have to worry about sign extension. */
827 &regval);
828 store_unsigned_integer (readbuf, valtype->length (), byte_order,
829 regval);
830 }
831 if (writebuf)
832 {
833 /* For writing, use unpack_long since that should handle any
834 required sign extension. */
836 unpack_long (valtype, writebuf));
837 }
838
840 }
841
842 /* Eight-byte non-floating-point scalar values must be returned in
843 GPR3:GPR4. */
844
845 if (valtype->length () == 8)
846 {
847 gdb_assert (valtype->code () != TYPE_CODE_FLT);
848 gdb_assert (tdep->wordsize == 4);
849
850 if (readbuf)
851 {
852 gdb_byte regval[8];
853
854 regcache->cooked_read (tdep->ppc_gp0_regnum + 3, regval);
855 regcache->cooked_read (tdep->ppc_gp0_regnum + 4, regval + 4);
856 memcpy (readbuf, regval, 8);
857 }
858 if (writebuf)
859 {
860 regcache->cooked_write (tdep->ppc_gp0_regnum + 3, writebuf);
861 regcache->cooked_write (tdep->ppc_gp0_regnum + 4, writebuf + 4);
862 }
863
865 }
866
868}
869
870/* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG).
871
872 Usually a function pointer's representation is simply the address
873 of the function. On the RS/6000 however, a function pointer is
874 represented by a pointer to an OPD entry. This OPD entry contains
875 three words, the first word is the address of the function, the
876 second word is the TOC pointer (r2), and the third word is the
877 static chain value. Throughout GDB it is currently assumed that a
878 function pointer contains the address of the function, which is not
879 easy to fix. In addition, the conversion of a function address to
880 a function pointer would require allocation of an OPD entry in the
881 inferior's memory space, with all its drawbacks. To be able to
882 call C++ virtual methods in the inferior (which are called via
883 function pointers), find_function_addr uses this function to get the
884 function address from a function pointer. */
885
886/* Return real function address if ADDR (a function pointer) is in the data
887 space and is therefore a special function pointer. */
888
889static CORE_ADDR
891 CORE_ADDR addr,
892 struct target_ops *targ)
893{
894 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
895 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
896 struct obj_section *s;
897
898 s = find_pc_section (addr);
899
900 /* Normally, functions live inside a section that is executable.
901 So, if ADDR points to a non-executable section, then treat it
902 as a function descriptor and return the target address iff
903 the target address itself points to a section that is executable. */
904 if (s && (s->the_bfd_section->flags & SEC_CODE) == 0)
905 {
906 CORE_ADDR pc = 0;
907 struct obj_section *pc_section;
908
909 try
910 {
911 pc = read_memory_unsigned_integer (addr, tdep->wordsize, byte_order);
912 }
913 catch (const gdb_exception_error &e)
914 {
915 /* An error occurred during reading. Probably a memory error
916 due to the section not being loaded yet. This address
917 cannot be a function descriptor. */
918 return addr;
919 }
920
921 pc_section = find_pc_section (pc);
922
923 if (pc_section && (pc_section->the_bfd_section->flags & SEC_CODE))
924 return pc;
925 }
926
927 return addr;
928}
929
930
931/* Calculate the destination of a branch/jump. Return -1 if not a branch. */
932
933static CORE_ADDR
934branch_dest (struct regcache *regcache, int opcode, int instr,
935 CORE_ADDR pc, CORE_ADDR safety)
936{
937 struct gdbarch *gdbarch = regcache->arch ();
938 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
939 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
940 CORE_ADDR dest;
941 int immediate;
942 int absolute;
943 int ext_op;
944
945 absolute = (int) ((instr >> 1) & 1);
946
947 switch (opcode)
948 {
949 case 18:
950 immediate = ((instr & ~3) << 6) >> 6; /* br unconditional */
951 if (absolute)
952 dest = immediate;
953 else
954 dest = pc + immediate;
955 break;
956
957 case 16:
958 immediate = ((instr & ~3) << 16) >> 16; /* br conditional */
959 if (absolute)
960 dest = immediate;
961 else
962 dest = pc + immediate;
963 break;
964
965 case 19:
966 ext_op = (instr >> 1) & 0x3ff;
967
968 if (ext_op == 16) /* br conditional register */
969 {
970 dest = regcache_raw_get_unsigned (regcache, tdep->ppc_lr_regnum) & ~3;
971
972 /* If we are about to return from a signal handler, dest is
973 something like 0x3c90. The current frame is a signal handler
974 caller frame, upon completion of the sigreturn system call
975 execution will return to the saved PC in the frame. */
976 if (dest < AIX_TEXT_SEGMENT_BASE)
977 {
979
982 tdep->wordsize, byte_order);
983 }
984 }
985
986 else if (ext_op == 528) /* br cond to count reg */
987 {
988 dest = regcache_raw_get_unsigned (regcache,
989 tdep->ppc_ctr_regnum) & ~3;
990
991 /* If we are about to execute a system call, dest is something
992 like 0x22fc or 0x3b00. Upon completion the system call
993 will return to the address in the link register. */
994 if (dest < AIX_TEXT_SEGMENT_BASE)
995 dest = regcache_raw_get_unsigned (regcache,
996 tdep->ppc_lr_regnum) & ~3;
997 }
998 else
999 return -1;
1000 break;
1001
1002 default:
1003 return -1;
1004 }
1005 return (dest < AIX_TEXT_SEGMENT_BASE) ? safety : dest;
1006}
1007
1008/* AIX does not support PT_STEP. Simulate it. */
1009
1010static std::vector<CORE_ADDR>
1012{
1013 struct gdbarch *gdbarch = regcache->arch ();
1014 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1015 int ii, insn;
1016 CORE_ADDR loc;
1017 CORE_ADDR breaks[2];
1018 int opcode;
1019
1021
1022 insn = read_memory_integer (loc, 4, byte_order);
1023
1024 std::vector<CORE_ADDR> next_pcs = ppc_deal_with_atomic_sequence (regcache);
1025 if (!next_pcs.empty ())
1026 return next_pcs;
1027
1028 /* Here 0xfc000000 is the opcode mask to detect a P10 prefix instruction. */
1029 if ((insn & 0xfc000000) == 1 << 26)
1030 breaks[0] = loc + 2 * PPC_INSN_SIZE;
1031 else
1032 breaks[0] = loc + PPC_INSN_SIZE;
1033 opcode = insn >> 26;
1034 breaks[1] = branch_dest (regcache, opcode, insn, loc, breaks[0]);
1035
1036 /* Don't put two breakpoints on the same address. */
1037 if (breaks[1] == breaks[0])
1038 breaks[1] = -1;
1039
1040 for (ii = 0; ii < 2; ++ii)
1041 {
1042 /* ignore invalid breakpoint. */
1043 if (breaks[ii] == -1)
1044 continue;
1045
1046 next_pcs.push_back (breaks[ii]);
1047 }
1048
1049 errno = 0; /* FIXME, don't ignore errors! */
1050 /* What errors? {read,write}_memory call error(). */
1051 return next_pcs;
1052}
1053
1054/* Implement the "auto_wide_charset" gdbarch method for this platform. */
1055
1056static const char *
1058{
1059 return "UTF-16";
1060}
1061
1062/* Implement an osabi sniffer for RS6000/AIX.
1063
1064 This function assumes that ABFD's flavour is XCOFF. In other words,
1065 it should be registered as a sniffer for bfd_target_xcoff_flavour
1066 objfiles only. A failed assertion will be raised if this condition
1067 is not met. */
1068
1069static enum gdb_osabi
1071{
1072 gdb_assert (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
1073
1074 /* The only noticeable difference between Lynx178 XCOFF files and
1075 AIX XCOFF files comes from the fact that there are no shared
1076 libraries on Lynx178. On AIX, we are betting that an executable
1077 linked with no shared library will never exist. */
1078 if (xcoff_get_n_import_files (abfd) <= 0)
1079 return GDB_OSABI_UNKNOWN;
1080
1081 return GDB_OSABI_AIX;
1082}
1083
1084/* A structure encoding the offset and size of a field within
1085 a struct. */
1086
1088{
1090 int size;
1091};
1092
1093/* A structure describing the layout of all the fields of interest
1094 in AIX's struct ld_info. Each field in this struct corresponds
1095 to the field of the same name in struct ld_info. */
1096
1107
1108/* The following data has been generated by compiling and running
1109 the following program on AIX 5.3. */
1110
1111#if 0
1112#include <stddef.h>
1113#include <stdio.h>
1114#define __LDINFO_PTRACE32__
1115#define __LDINFO_PTRACE64__
1116#include <sys/ldr.h>
1117
1118#define pinfo(type,member) \
1119 { \
1120 struct type ldi = {0}; \
1121 \
1122 printf (" {%d, %d},\t/* %s */\n", \
1123 offsetof (struct type, member), \
1124 sizeof (ldi.member), \
1125 #member); \
1126 } \
1127 while (0)
1128
1129int
1130main (void)
1131{
1132 printf ("static const struct ld_info_desc ld_info32_desc =\n{\n");
1133 pinfo (__ld_info32, ldinfo_next);
1134 pinfo (__ld_info32, ldinfo_fd);
1135 pinfo (__ld_info32, ldinfo_textorg);
1136 pinfo (__ld_info32, ldinfo_textsize);
1137 pinfo (__ld_info32, ldinfo_dataorg);
1138 pinfo (__ld_info32, ldinfo_datasize);
1139 pinfo (__ld_info32, ldinfo_filename);
1140 printf ("};\n");
1141
1142 printf ("\n");
1143
1144 printf ("static const struct ld_info_desc ld_info64_desc =\n{\n");
1145 pinfo (__ld_info64, ldinfo_next);
1146 pinfo (__ld_info64, ldinfo_fd);
1147 pinfo (__ld_info64, ldinfo_textorg);
1148 pinfo (__ld_info64, ldinfo_textsize);
1149 pinfo (__ld_info64, ldinfo_dataorg);
1150 pinfo (__ld_info64, ldinfo_datasize);
1151 pinfo (__ld_info64, ldinfo_filename);
1152 printf ("};\n");
1153
1154 return 0;
1155}
1156#endif /* 0 */
1157
1158/* Layout of the 32bit version of struct ld_info. */
1159
1160static const struct ld_info_desc ld_info32_desc =
1161{
1162 {0, 4}, /* ldinfo_next */
1163 {4, 4}, /* ldinfo_fd */
1164 {8, 4}, /* ldinfo_textorg */
1165 {12, 4}, /* ldinfo_textsize */
1166 {16, 4}, /* ldinfo_dataorg */
1167 {20, 4}, /* ldinfo_datasize */
1168 {24, 2}, /* ldinfo_filename */
1169};
1170
1171/* Layout of the 64bit version of struct ld_info. */
1172
1173static const struct ld_info_desc ld_info64_desc =
1174{
1175 {0, 4}, /* ldinfo_next */
1176 {8, 4}, /* ldinfo_fd */
1177 {16, 8}, /* ldinfo_textorg */
1178 {24, 8}, /* ldinfo_textsize */
1179 {32, 8}, /* ldinfo_dataorg */
1180 {40, 8}, /* ldinfo_datasize */
1181 {48, 2}, /* ldinfo_filename */
1182};
1183
1184/* A structured representation of one entry read from the ld_info
1185 binary data provided by the AIX loader. */
1186
1188{
1189 ULONGEST next;
1190 int fd;
1191 CORE_ADDR textorg;
1192 ULONGEST textsize;
1193 CORE_ADDR dataorg;
1194 ULONGEST datasize;
1197};
1198
1199/* Return a struct ld_info object corresponding to the entry at
1200 LDI_BUF.
1201
1202 Note that the filename and member_name strings still point
1203 to the data in LDI_BUF. So LDI_BUF must not be deallocated
1204 while the struct ld_info object returned is in use. */
1205
1206static struct ld_info
1208 const gdb_byte *ldi_buf)
1209{
1210 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
1211 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1212 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
1213 const struct ld_info_desc desc
1214 = tdep->wordsize == 8 ? ld_info64_desc : ld_info32_desc;
1215 struct ld_info info;
1216
1217 info.next = extract_unsigned_integer (ldi_buf + desc.ldinfo_next.offset,
1218 desc.ldinfo_next.size,
1219 byte_order);
1220 info.fd = extract_signed_integer (ldi_buf + desc.ldinfo_fd.offset,
1221 desc.ldinfo_fd.size,
1222 byte_order);
1223 info.textorg = extract_typed_address (ldi_buf + desc.ldinfo_textorg.offset,
1224 ptr_type);
1225 info.textsize
1227 desc.ldinfo_textsize.size,
1228 byte_order);
1229 info.dataorg = extract_typed_address (ldi_buf + desc.ldinfo_dataorg.offset,
1230 ptr_type);
1231 info.datasize
1233 desc.ldinfo_datasize.size,
1234 byte_order);
1235 info.filename = (char *) ldi_buf + desc.ldinfo_filename.offset;
1236 info.member_name = info.filename + strlen (info.filename) + 1;
1237
1238 return info;
1239}
1240
1241/* Append to OBJSTACK an XML string description of the shared library
1242 corresponding to LDI, following the TARGET_OBJECT_LIBRARIES_AIX
1243 format. */
1244
1245static void
1247 struct obstack *obstack)
1248{
1249 obstack_grow_str (obstack, "<library name=\"");
1250 std::string p = xml_escape_text (ldi->filename);
1251 obstack_grow_str (obstack, p.c_str ());
1252 obstack_grow_str (obstack, "\"");
1253
1254 if (ldi->member_name[0] != '\0')
1255 {
1256 obstack_grow_str (obstack, " member=\"");
1257 p = xml_escape_text (ldi->member_name);
1258 obstack_grow_str (obstack, p.c_str ());
1259 obstack_grow_str (obstack, "\"");
1260 }
1261
1262 obstack_grow_str (obstack, " text_addr=\"");
1263 obstack_grow_str (obstack, core_addr_to_string (ldi->textorg));
1264 obstack_grow_str (obstack, "\"");
1265
1266 obstack_grow_str (obstack, " text_size=\"");
1267 obstack_grow_str (obstack, pulongest (ldi->textsize));
1268 obstack_grow_str (obstack, "\"");
1269
1270 obstack_grow_str (obstack, " data_addr=\"");
1271 obstack_grow_str (obstack, core_addr_to_string (ldi->dataorg));
1272 obstack_grow_str (obstack, "\"");
1273
1274 obstack_grow_str (obstack, " data_size=\"");
1275 obstack_grow_str (obstack, pulongest (ldi->datasize));
1276 obstack_grow_str (obstack, "\"");
1277
1278 obstack_grow_str (obstack, "></library>");
1279}
1280
1281/* Convert the ld_info binary data provided by the AIX loader into
1282 an XML representation following the TARGET_OBJECT_LIBRARIES_AIX
1283 format.
1284
1285 LDI_BUF is a buffer containing the ld_info data.
1286 READBUF, OFFSET and LEN follow the same semantics as target_ops'
1287 to_xfer_partial target_ops method.
1288
1289 If CLOSE_LDINFO_FD is nonzero, then this routine also closes
1290 the ldinfo_fd file descriptor. This is useful when the ldinfo
1291 data is obtained via ptrace, as ptrace opens a file descriptor
1292 for each and every entry; but we cannot use this descriptor
1293 as the consumer of the XML library list might live in a different
1294 process. */
1295
1296ULONGEST
1297rs6000_aix_ld_info_to_xml (struct gdbarch *gdbarch, const gdb_byte *ldi_buf,
1298 gdb_byte *readbuf, ULONGEST offset, ULONGEST len,
1299 int close_ldinfo_fd)
1300{
1301 struct obstack obstack;
1302 const char *buf;
1303 ULONGEST len_avail;
1304
1305 obstack_init (&obstack);
1306 obstack_grow_str (&obstack, "<library-list-aix version=\"1.0\">\n");
1307
1308 while (1)
1309 {
1310 struct ld_info ldi = rs6000_aix_extract_ld_info (gdbarch, ldi_buf);
1311
1312 rs6000_aix_shared_library_to_xml (&ldi, &obstack);
1313 if (close_ldinfo_fd)
1314 close (ldi.fd);
1315
1316 if (!ldi.next)
1317 break;
1318 ldi_buf = ldi_buf + ldi.next;
1319 }
1320
1321 obstack_grow_str0 (&obstack, "</library-list-aix>\n");
1322
1323 buf = (const char *) obstack_finish (&obstack);
1324 len_avail = strlen (buf);
1325 if (offset >= len_avail)
1326 len= 0;
1327 else
1328 {
1329 if (len > len_avail - offset)
1330 len = len_avail - offset;
1331 memcpy (readbuf, buf + offset, len);
1332 }
1333
1334 obstack_free (&obstack, NULL);
1335 return len;
1336}
1337
1338/* Implement the core_xfer_shared_libraries_aix gdbarch method. */
1339
1340static ULONGEST
1342 gdb_byte *readbuf,
1343 ULONGEST offset,
1344 ULONGEST len)
1345{
1346 struct bfd_section *ldinfo_sec;
1347 int ldinfo_size;
1348
1349 ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1350 if (ldinfo_sec == NULL)
1351 error (_("cannot find .ldinfo section from core file: %s"),
1352 bfd_errmsg (bfd_get_error ()));
1353 ldinfo_size = bfd_section_size (ldinfo_sec);
1354
1355 gdb::byte_vector ldinfo_buf (ldinfo_size);
1356
1357 if (! bfd_get_section_contents (core_bfd, ldinfo_sec,
1358 ldinfo_buf.data (), 0, ldinfo_size))
1359 error (_("unable to read .ldinfo section from core file: %s"),
1360 bfd_errmsg (bfd_get_error ()));
1361
1362 return rs6000_aix_ld_info_to_xml (gdbarch, ldinfo_buf.data (), readbuf,
1363 offset, len, 0);
1364}
1365
1366static void
1368{
1369 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
1370
1371 /* RS6000/AIX does not support PT_STEP. Has to be simulated. */
1373
1374 /* Displaced stepping is currently not supported in combination with
1375 software single-stepping. These override the values set by
1376 rs6000_gdbarch_init. */
1381
1384 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1385
1386 /* Handle RS/6000 function pointers (which are really function
1387 descriptors). */
1390
1391 /* Core file support. */
1397
1398 if (tdep->wordsize == 8)
1399 tdep->lr_frame_offset = 16;
1400 else
1401 tdep->lr_frame_offset = 8;
1402
1403 if (tdep->wordsize == 4)
1404 /* PowerOpen / AIX 32 bit. The saved area or red zone consists of
1405 19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes.
1406 Problem is, 220 isn't frame (16 byte) aligned. Round it up to
1407 224. */
1409 else
1410 /* In 64 bit mode the red zone should have 18 8 byte GPRS + 18 8 byte
1411 FPRS making it 288 bytes. This is 16 byte aligned as well. */
1413
1414 if (tdep->wordsize == 8)
1416 else
1420
1423}
1424
1426void
1428{
1429 gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
1430 bfd_target_xcoff_flavour,
1432 gdbarch_register_osabi_sniffer (bfd_arch_powerpc,
1433 bfd_target_xcoff_flavour,
1435
1436 gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_AIX,
1438 gdbarch_register_osabi (bfd_arch_powerpc, 0, GDB_OSABI_AIX,
1440}
1441
int regnum
int main()
Definition 1.cc:63
enum register_status cooked_read(int regnum, gdb_byte *buf)
Definition regcache.c:698
gdbarch * arch() const
Definition regcache.c:231
void cooked_write(int regnum, const gdb_byte *buf)
Definition regcache.c:870
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition corefile.c:347
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition corefile.c:306
int safe_read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order, LONGEST *return_value)
Definition corefile.c:264
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition corefile.c:296
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:515
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition findvar.c:152
static LONGEST extract_signed_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:465
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
return_value_convention
Definition defs.h:257
@ RETURN_VALUE_REGISTER_CONVENTION
Definition defs.h:260
@ RETURN_VALUE_STRUCT_CONVENTION
Definition defs.h:267
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
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
frame_info_ptr get_current_frame(void)
Definition frame.c:1670
CORE_ADDR get_frame_base(frame_info_ptr fi)
Definition frame.c:2879
@ SIGTRAMP_FRAME
Definition frame.h:198
@ fp_regnum
Definition frv-tdep.h:36
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition gdbarch.c:2054
void set_gdbarch_auto_wide_charset(struct gdbarch *gdbarch, gdbarch_auto_wide_charset_ftype *auto_wide_charset)
void set_gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step)
void set_gdbarch_displaced_step_finish(struct gdbarch *gdbarch, gdbarch_displaced_step_finish_ftype *displaced_step_finish)
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_core_xfer_shared_libraries_aix(struct gdbarch *gdbarch, gdbarch_core_xfer_shared_libraries_aix_ftype *core_xfer_shared_libraries_aix)
void set_gdbarch_wchar_bit(struct gdbarch *gdbarch, int wchar_bit)
Definition gdbarch.c:1680
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_wchar_signed(struct gdbarch *gdbarch, int wchar_signed)
Definition gdbarch.c:1698
void set_gdbarch_displaced_step_copy_insn(struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn)
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition gdbarch.c:2037
void set_gdbarch_frame_red_zone_size(struct gdbarch *gdbarch, int frame_red_zone_size)
Definition gdbarch.c:3128
void set_gdbarch_displaced_step_fixup(struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype *displaced_step_fixup)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition gdbarch.c:1646
void set_gdbarch_so_ops(struct gdbarch *gdbarch, const struct target_so_ops *so_ops)
Definition gdbarch.c:3380
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
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
function_call_return_method
Definition gdbarch.h:114
@ return_method_struct
Definition gdbarch.h:126
#define core_bfd
Definition gdbcore.h:130
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:2966
CORE_ADDR find_function_addr(struct value *function, struct type **retval_type, struct type **function_type)
Definition infcall.c:278
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition objfiles.c:1128
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
void gdbarch_register_osabi_sniffer(enum bfd_architecture arch, enum bfd_flavour flavour, enum gdb_osabi(*sniffer_fn)(bfd *))
Definition osabi.c:220
gdb_osabi
Definition osabi.h:25
@ GDB_OSABI_AIX
Definition osabi.h:41
@ GDB_OSABI_UNKNOWN
Definition osabi.h:26
const struct target_desc * tdesc_powerpc_altivec32
const struct target_desc * tdesc_powerpc_altivec64
const struct target_desc * tdesc_powerpc_vsx32
const struct target_desc * tdesc_powerpc_vsx64
void ppc_collect_gregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t len)
void ppc_supply_fpregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len)
std::vector< CORE_ADDR > ppc_deal_with_atomic_sequence(struct regcache *regcache)
#define PPC_MAX_REGISTER_SIZE
Definition ppc-tdep.h:395
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)
void ppc_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
@ ppc_num_vrs
Definition ppc-tdep.h:321
void ppc_collect_fpregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *fpregs, size_t len)
#define PPC_INSN_SIZE
Definition ppc-tdep.h:440
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition regcache.c:1333
void regcache_raw_write_signed(struct regcache *regcache, int regnum, LONGEST val)
Definition regcache.c:657
int register_size(struct gdbarch *gdbarch, int regnum)
Definition regcache.c:170
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition regcache.c:796
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:677
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:825
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition regcache.c:158
void(* func)(remote_target *remote, char *)
static const struct regset rs6000_aix_vsxregset
static const struct regset rs6000_aix32_regset
static enum gdb_osabi rs6000_aix_osabi_sniffer(bfd *abfd)
static const struct ld_info_desc ld_info32_desc
static struct trad_frame_cache * aix_sighandle_frame_cache(frame_info_ptr this_frame, void **this_cache)
#define SIG_FRAME_FP_OFFSET64
static const char * rs6000_aix_auto_wide_charset(void)
ULONGEST rs6000_aix_ld_info_to_xml(struct gdbarch *gdbarch, const gdb_byte *ldi_buf, gdb_byte *readbuf, ULONGEST offset, ULONGEST len, int close_ldinfo_fd)
static void rs6000_aix_supply_vrregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *vrregs, size_t len)
static int aix_sighandle_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
static void rs6000_aix_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t len)
static const struct regset rs6000_aix_vrregset
void _initialize_rs6000_aix_tdep()
static const struct ld_info_desc ld_info64_desc
static CORE_ADDR rs6000_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr)
#define SIG_FRAME_PC_OFFSET
static void rs6000_aix_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
static int rs6000_aix_get_vrreg_offset(ppc_gdbarch_tdep *tdep, const struct rs6000_aix_reg_vrreg_offset *offsets, int regnum)
static const struct target_desc * ppc_aix_core_read_description(struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd)
static struct value * aix_sighandle_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
static struct rs6000_aix_reg_vrreg_offset rs6000_aix_vrreg_offset
static void rs6000_aix_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
static void rs6000_aix_collect_vsxregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *vsxregs, size_t len)
static void rs6000_aix_supply_vsxregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *vsxregs, size_t len)
static void aix_sighandle_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
static void rs6000_aix_shared_library_to_xml(struct ld_info *ldi, struct obstack *obstack)
#define SIG_FRAME_FP_OFFSET
static struct ppc_reg_offsets rs6000_aix32_reg_offsets
static CORE_ADDR branch_dest(struct regcache *regcache, int opcode, int instr, CORE_ADDR pc, CORE_ADDR safety)
#define AIX_TEXT_SEGMENT_BASE
static ULONGEST rs6000_aix_core_xfer_shared_libraries_aix(struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
static const struct regset rs6000_aix64_regset
static struct ppc_reg_offsets rs6000_aix64_reg_offsets
static void rs6000_aix_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
static std::vector< CORE_ADDR > rs6000_software_single_step(struct regcache *regcache)
static CORE_ADDR rs6000_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
#define SIG_FRAME_LR_OFFSET64
static struct ld_info rs6000_aix_extract_ld_info(struct gdbarch *gdbarch, const gdb_byte *ldi_buf)
static enum return_value_convention rs6000_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static const struct frame_unwind aix_sighandle_frame_unwind
static void rs6000_aix_collect_vrregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *vrregs, size_t len)
enum var_types type
Definition scm-param.c:142
const struct target_so_ops solib_aix_so_ops
Definition solib-aix.c:713
CORE_ADDR solib_aix_get_toc_value(CORE_ADDR pc)
Definition solib-aix.c:673
struct type * builtin_data_ptr
Definition gdbtypes.h:2135
struct ldinfo_field ldinfo_textsize
struct ldinfo_field ldinfo_textorg
struct ldinfo_field ldinfo_next
struct ldinfo_field ldinfo_datasize
struct ldinfo_field ldinfo_dataorg
struct ldinfo_field ldinfo_fd
struct ldinfo_field ldinfo_filename
ULONGEST next
ULONGEST textsize
char * member_name
CORE_ADDR textorg
CORE_ADDR dataorg
ULONGEST datasize
char * filename
CORE_ADDR addr() const
Definition objfiles.h:385
struct bfd_section * the_bfd_section
Definition objfiles.h:398
int ppc_vsr0_upper_regnum
Definition ppc-tdep.h:246
const void * regmap
Definition regset.h:39
struct frame_id this_id
Definition trad-frame.c:35
frame_info_ptr this_frame
Definition trad-frame.c:32
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
gdb::array_view< const gdb_byte > contents()
Definition value.c:1262
struct type * type() const
Definition value.h:180
void target_float_convert(const gdb_byte *from, const struct type *from_type, gdb_byte *to, const struct type *to_type)
void target_store_registers(struct regcache *regcache, int regno)
Definition target.c:3936
struct trad_frame_cache * trad_frame_cache_zalloc(frame_info_ptr this_frame)
Definition trad-frame.c:39
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_get_id(struct trad_frame_cache *this_trad_cache, struct frame_id *this_id)
Definition trad-frame.c:227
void trad_frame_set_id(struct trad_frame_cache *this_trad_cache, struct frame_id this_id)
Definition trad-frame.c:220
void trad_frame_set_this_base(struct trad_frame_cache *this_trad_cache, CORE_ADDR this_base)
Definition trad-frame.c:234
void trad_frame_set_reg_value(struct trad_frame_cache *this_trad_cache, int regnum, LONGEST val)
Definition trad-frame.c:94
struct value * trad_frame_get_register(struct trad_frame_cache *this_trad_cache, frame_info_ptr this_frame, int regnum)
Definition trad-frame.c:211
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition value.c:2753
int xcoff_get_n_import_files(bfd *abfd)
Definition xcoffread.c:2977