1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "xcoffsolib.h"
27 #include "libbfd.h" /* For bfd_default_set_arch_mach (FIXME) */
29 #include "exceptions.h"
30 #include "gdb-stabs.h"
32 #include "arch-utils.h"
33 #include "inf-child.h"
34 #include "inf-ptrace.h"
36 #include "rs6000-tdep.h"
39 #include "xcoffread.h"
41 #include <sys/ptrace.h>
44 #include <sys/param.h>
48 #include <sys/ioctl.h>
57 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
58 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
60 #include <sys/systemcfg.h>
62 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
63 debugging 32-bit and 64-bit processes. Define a typedef and macros for
64 accessing fields in the appropriate structures. */
66 /* In 32-bit compilation mode (which is the only mode from which ptrace()
67 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
73 /* Return whether the current architecture is 64-bit. */
78 # define ARCH64() (register_size (target_gdbarch (), 0) == 8)
81 /* Union of 32-bit and 64-bit versions of ld_info. */
88 struct __ld_info32 l32
;
89 struct __ld_info64 l64
;
93 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
94 declare and initialize a variable named VAR suitable for use as the arch64
95 parameter to the various LDI_*() macros. */
98 # define ARCH64_DECL(var)
100 # define ARCH64_DECL(var) int var = ARCH64 ()
103 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
104 otherwise. This technique only works for FIELDs with the same data type in
105 32-bit and 64-bit versions of ld_info. */
108 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
110 # define LDI_FIELD(ldi, arch64, field) \
111 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
114 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
115 process otherwise. */
117 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
118 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
119 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
121 extern struct vmap
*map_vmap (bfd
* bf
, bfd
* arch
);
123 static void vmap_exec (void);
125 static void vmap_ldinfo (LdInfo
*);
127 static struct vmap
*add_vmap (LdInfo
*);
129 static int objfile_symbol_add (void *);
131 static void vmap_symtab (struct vmap
*);
133 static void exec_one_dummy_insn (struct regcache
*);
135 /* Given REGNO, a gdb register number, return the corresponding
136 number suitable for use as a ptrace() parameter. Return -1 if
137 there's no suitable mapping. Also, set the int pointed to by
138 ISFLOAT to indicate whether REGNO is a floating point register. */
141 regmap (struct gdbarch
*gdbarch
, int regno
, int *isfloat
)
143 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
146 if (tdep
->ppc_gp0_regnum
<= regno
147 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
)
149 else if (tdep
->ppc_fp0_regnum
>= 0
150 && tdep
->ppc_fp0_regnum
<= regno
151 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)
154 return regno
- tdep
->ppc_fp0_regnum
+ FPR0
;
156 else if (regno
== gdbarch_pc_regnum (gdbarch
))
158 else if (regno
== tdep
->ppc_ps_regnum
)
160 else if (regno
== tdep
->ppc_cr_regnum
)
162 else if (regno
== tdep
->ppc_lr_regnum
)
164 else if (regno
== tdep
->ppc_ctr_regnum
)
166 else if (regno
== tdep
->ppc_xer_regnum
)
168 else if (tdep
->ppc_fpscr_regnum
>= 0
169 && regno
== tdep
->ppc_fpscr_regnum
)
171 else if (tdep
->ppc_mq_regnum
>= 0 && regno
== tdep
->ppc_mq_regnum
)
177 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
180 rs6000_ptrace32 (int req
, int id
, int *addr
, int data
, int *buf
)
182 int ret
= ptrace (req
, id
, (int *)addr
, data
, buf
);
184 printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
185 req
, id
, (unsigned int)addr
, data
, (unsigned int)buf
, ret
);
190 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
193 rs6000_ptrace64 (int req
, int id
, long long addr
, int data
, void *buf
)
196 int ret
= ptracex (req
, id
, addr
, data
, buf
);
201 printf ("rs6000_ptrace64 (%d, %d, %s, %08x, 0x%x) = 0x%x\n",
202 req
, id
, hex_string (addr
), data
, (unsigned int)buf
, ret
);
207 /* Fetch register REGNO from the inferior. */
210 fetch_register (struct regcache
*regcache
, int regno
)
212 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
213 int addr
[MAX_REGISTER_SIZE
];
216 /* Retrieved values may be -1, so infer errors from errno. */
219 nr
= regmap (gdbarch
, regno
, &isfloat
);
221 /* Floating-point registers. */
223 rs6000_ptrace32 (PT_READ_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
225 /* Bogus register number. */
228 if (regno
>= gdbarch_num_regs (gdbarch
))
229 fprintf_unfiltered (gdb_stderr
,
230 "gdb error: register no %d not implemented.\n",
235 /* Fixed-point registers. */
239 *addr
= rs6000_ptrace32 (PT_READ_GPR
, PIDGET (inferior_ptid
),
243 /* PT_READ_GPR requires the buffer parameter to point to long long,
244 even if the register is really only 32 bits. */
246 rs6000_ptrace64 (PT_READ_GPR
, PIDGET (inferior_ptid
), nr
, 0, &buf
);
247 if (register_size (gdbarch
, regno
) == 8)
248 memcpy (addr
, &buf
, 8);
255 regcache_raw_supply (regcache
, regno
, (char *) addr
);
259 /* FIXME: this happens 3 times at the start of each 64-bit program. */
260 perror (_("ptrace read"));
266 /* Store register REGNO back into the inferior. */
269 store_register (struct regcache
*regcache
, int regno
)
271 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
272 int addr
[MAX_REGISTER_SIZE
];
275 /* Fetch the register's value from the register cache. */
276 regcache_raw_collect (regcache
, regno
, addr
);
278 /* -1 can be a successful return value, so infer errors from errno. */
281 nr
= regmap (gdbarch
, regno
, &isfloat
);
283 /* Floating-point registers. */
285 rs6000_ptrace32 (PT_WRITE_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
287 /* Bogus register number. */
290 if (regno
>= gdbarch_num_regs (gdbarch
))
291 fprintf_unfiltered (gdb_stderr
,
292 "gdb error: register no %d not implemented.\n",
296 /* Fixed-point registers. */
299 if (regno
== gdbarch_sp_regnum (gdbarch
))
300 /* Execute one dummy instruction (which is a breakpoint) in inferior
301 process to give kernel a chance to do internal housekeeping.
302 Otherwise the following ptrace(2) calls will mess up user stack
303 since kernel will get confused about the bottom of the stack
305 exec_one_dummy_insn (regcache
);
307 /* The PT_WRITE_GPR operation is rather odd. For 32-bit inferiors,
308 the register's value is passed by value, but for 64-bit inferiors,
309 the address of a buffer containing the value is passed. */
311 rs6000_ptrace32 (PT_WRITE_GPR
, PIDGET (inferior_ptid
),
312 (int *) nr
, *addr
, 0);
315 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
316 area, even if the register is really only 32 bits. */
318 if (register_size (gdbarch
, regno
) == 8)
319 memcpy (&buf
, addr
, 8);
322 rs6000_ptrace64 (PT_WRITE_GPR
, PIDGET (inferior_ptid
), nr
, 0, &buf
);
328 perror (_("ptrace write"));
333 /* Read from the inferior all registers if REGNO == -1 and just register
337 rs6000_fetch_inferior_registers (struct target_ops
*ops
,
338 struct regcache
*regcache
, int regno
)
340 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
342 fetch_register (regcache
, regno
);
346 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
348 /* Read 32 general purpose registers. */
349 for (regno
= tdep
->ppc_gp0_regnum
;
350 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
353 fetch_register (regcache
, regno
);
356 /* Read general purpose floating point registers. */
357 if (tdep
->ppc_fp0_regnum
>= 0)
358 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
359 fetch_register (regcache
, tdep
->ppc_fp0_regnum
+ regno
);
361 /* Read special registers. */
362 fetch_register (regcache
, gdbarch_pc_regnum (gdbarch
));
363 fetch_register (regcache
, tdep
->ppc_ps_regnum
);
364 fetch_register (regcache
, tdep
->ppc_cr_regnum
);
365 fetch_register (regcache
, tdep
->ppc_lr_regnum
);
366 fetch_register (regcache
, tdep
->ppc_ctr_regnum
);
367 fetch_register (regcache
, tdep
->ppc_xer_regnum
);
368 if (tdep
->ppc_fpscr_regnum
>= 0)
369 fetch_register (regcache
, tdep
->ppc_fpscr_regnum
);
370 if (tdep
->ppc_mq_regnum
>= 0)
371 fetch_register (regcache
, tdep
->ppc_mq_regnum
);
375 /* Store our register values back into the inferior.
376 If REGNO is -1, do this for all registers.
377 Otherwise, REGNO specifies which register (so we can save time). */
380 rs6000_store_inferior_registers (struct target_ops
*ops
,
381 struct regcache
*regcache
, int regno
)
383 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
385 store_register (regcache
, regno
);
389 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
391 /* Write general purpose registers first. */
392 for (regno
= tdep
->ppc_gp0_regnum
;
393 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
396 store_register (regcache
, regno
);
399 /* Write floating point registers. */
400 if (tdep
->ppc_fp0_regnum
>= 0)
401 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
402 store_register (regcache
, tdep
->ppc_fp0_regnum
+ regno
);
404 /* Write special registers. */
405 store_register (regcache
, gdbarch_pc_regnum (gdbarch
));
406 store_register (regcache
, tdep
->ppc_ps_regnum
);
407 store_register (regcache
, tdep
->ppc_cr_regnum
);
408 store_register (regcache
, tdep
->ppc_lr_regnum
);
409 store_register (regcache
, tdep
->ppc_ctr_regnum
);
410 store_register (regcache
, tdep
->ppc_xer_regnum
);
411 if (tdep
->ppc_fpscr_regnum
>= 0)
412 store_register (regcache
, tdep
->ppc_fpscr_regnum
);
413 if (tdep
->ppc_mq_regnum
>= 0)
414 store_register (regcache
, tdep
->ppc_mq_regnum
);
419 /* Attempt a transfer all LEN bytes starting at OFFSET between the
420 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
421 Return the number of bytes actually transferred. */
424 rs6000_xfer_partial (struct target_ops
*ops
, enum target_object object
,
425 const char *annex
, gdb_byte
*readbuf
,
426 const gdb_byte
*writebuf
,
427 ULONGEST offset
, LONGEST len
)
429 pid_t pid
= ptid_get_pid (inferior_ptid
);
430 int arch64
= ARCH64 ();
434 case TARGET_OBJECT_MEMORY
:
438 PTRACE_TYPE_RET word
;
439 gdb_byte byte
[sizeof (PTRACE_TYPE_RET
)];
441 ULONGEST rounded_offset
;
444 /* Round the start offset down to the next long word
446 rounded_offset
= offset
& -(ULONGEST
) sizeof (PTRACE_TYPE_RET
);
448 /* Since ptrace will transfer a single word starting at that
449 rounded_offset the partial_len needs to be adjusted down to
450 that (remember this function only does a single transfer).
451 Should the required length be even less, adjust it down
453 partial_len
= (rounded_offset
+ sizeof (PTRACE_TYPE_RET
)) - offset
;
454 if (partial_len
> len
)
459 /* If OFFSET:PARTIAL_LEN is smaller than
460 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
461 be needed. Read in the entire word. */
462 if (rounded_offset
< offset
463 || (offset
+ partial_len
464 < rounded_offset
+ sizeof (PTRACE_TYPE_RET
)))
466 /* Need part of initial word -- fetch it. */
468 buffer
.word
= rs6000_ptrace64 (PT_READ_I
, pid
,
469 rounded_offset
, 0, NULL
);
471 buffer
.word
= rs6000_ptrace32 (PT_READ_I
, pid
,
477 /* Copy data to be written over corresponding part of
479 memcpy (buffer
.byte
+ (offset
- rounded_offset
),
480 writebuf
, partial_len
);
484 rs6000_ptrace64 (PT_WRITE_D
, pid
,
485 rounded_offset
, buffer
.word
, NULL
);
487 rs6000_ptrace32 (PT_WRITE_D
, pid
,
488 (int *) (uintptr_t) rounded_offset
,
498 buffer
.word
= rs6000_ptrace64 (PT_READ_I
, pid
,
499 rounded_offset
, 0, NULL
);
501 buffer
.word
= rs6000_ptrace32 (PT_READ_I
, pid
,
502 (int *)(uintptr_t)rounded_offset
,
507 /* Copy appropriate bytes out of the buffer. */
508 memcpy (readbuf
, buffer
.byte
+ (offset
- rounded_offset
),
520 /* Wait for the child specified by PTID to do something. Return the
521 process ID of the child, or MINUS_ONE_PTID in case of error; store
522 the status in *OURSTATUS. */
525 rs6000_wait (struct target_ops
*ops
,
526 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
529 int status
, save_errno
;
537 pid
= waitpid (ptid_get_pid (ptid
), &status
, 0);
540 while (pid
== -1 && errno
== EINTR
);
542 clear_sigint_trap ();
546 fprintf_unfiltered (gdb_stderr
,
547 _("Child process unexpectedly missing: %s.\n"),
548 safe_strerror (save_errno
));
550 /* Claim it exited with unknown signal. */
551 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
552 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
553 return inferior_ptid
;
556 /* Ignore terminated detached child processes. */
557 if (!WIFSTOPPED (status
) && pid
!= ptid_get_pid (inferior_ptid
))
562 /* AIX has a couple of strange returns from wait(). */
564 /* stop after load" status. */
566 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
567 /* signal 0. I have no idea why wait(2) returns with this status word. */
568 else if (status
== 0x7f)
569 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
570 /* A normal waitstatus. Let the usual macros deal with it. */
572 store_waitstatus (ourstatus
, status
);
574 return pid_to_ptid (pid
);
577 /* Execute one dummy breakpoint instruction. This way we give the kernel
578 a chance to do some housekeeping and update inferior's internal data,
582 exec_one_dummy_insn (struct regcache
*regcache
)
584 #define DUMMY_INSN_ADDR AIX_TEXT_SEGMENT_BASE+0x200
586 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
587 int ret
, status
, pid
;
591 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
592 assume that this address will never be executed again by the real
595 bp
= deprecated_insert_raw_breakpoint (gdbarch
, NULL
, DUMMY_INSN_ADDR
);
597 /* You might think this could be done with a single ptrace call, and
598 you'd be correct for just about every platform I've ever worked
599 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
600 the inferior never hits the breakpoint (it's also worth noting
601 powerpc-ibm-aix4.1.3 works correctly). */
602 prev_pc
= regcache_read_pc (regcache
);
603 regcache_write_pc (regcache
, DUMMY_INSN_ADDR
);
605 ret
= rs6000_ptrace64 (PT_CONTINUE
, PIDGET (inferior_ptid
), 1, 0, NULL
);
607 ret
= rs6000_ptrace32 (PT_CONTINUE
, PIDGET (inferior_ptid
),
611 perror (_("pt_continue"));
615 pid
= waitpid (PIDGET (inferior_ptid
), &status
, 0);
617 while (pid
!= PIDGET (inferior_ptid
));
619 regcache_write_pc (regcache
, prev_pc
);
620 deprecated_remove_raw_breakpoint (gdbarch
, bp
);
624 /* Copy information about text and data sections from LDI to VP for a 64-bit
625 process if ARCH64 and for a 32-bit process otherwise. */
628 vmap_secs (struct vmap
*vp
, LdInfo
*ldi
, int arch64
)
632 vp
->tstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_textorg
;
633 vp
->tend
= vp
->tstart
+ ldi
->l64
.ldinfo_textsize
;
634 vp
->dstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_dataorg
;
635 vp
->dend
= vp
->dstart
+ ldi
->l64
.ldinfo_datasize
;
639 vp
->tstart
= (unsigned long) ldi
->l32
.ldinfo_textorg
;
640 vp
->tend
= vp
->tstart
+ ldi
->l32
.ldinfo_textsize
;
641 vp
->dstart
= (unsigned long) ldi
->l32
.ldinfo_dataorg
;
642 vp
->dend
= vp
->dstart
+ ldi
->l32
.ldinfo_datasize
;
645 /* The run time loader maps the file header in addition to the text
646 section and returns a pointer to the header in ldinfo_textorg.
647 Adjust the text start address to point to the real start address
648 of the text section. */
649 vp
->tstart
+= vp
->toffs
;
652 /* If the .bss section's VMA is set to an address located before
653 the end of the .data section, causing the two sections to overlap,
654 return the overlap in bytes. Otherwise, return zero.
658 The GNU linker sometimes sets the start address of the .bss session
659 before the end of the .data section, making the 2 sections overlap.
660 The loader appears to handle this situation gracefully, by simply
661 loading the bss section right after the end of the .data section.
663 This means that the .data and the .bss sections are sometimes
664 no longer relocated by the same amount. The problem is that
665 the ldinfo data does not contain any information regarding
666 the relocation of the .bss section, assuming that it would be
667 identical to the information provided for the .data section
668 (this is what would normally happen if the program was linked
671 GDB therefore needs to detect those cases, and make the corresponding
672 adjustment to the .bss section offset computed from the ldinfo data
673 when necessary. This function returns the adjustment amount (or
674 zero when no adjustment is needed). */
677 bss_data_overlap (struct objfile
*objfile
)
679 struct obj_section
*osect
;
680 struct bfd_section
*data
= NULL
;
681 struct bfd_section
*bss
= NULL
;
683 /* First, find the .data and .bss sections. */
684 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
686 if (strcmp (bfd_section_name (objfile
->obfd
,
687 osect
->the_bfd_section
),
689 data
= osect
->the_bfd_section
;
690 else if (strcmp (bfd_section_name (objfile
->obfd
,
691 osect
->the_bfd_section
),
693 bss
= osect
->the_bfd_section
;
696 /* If either section is not defined, there can be no overlap. */
697 if (data
== NULL
|| bss
== NULL
)
700 /* Assume the problem only occurs with linkers that place the .bss
701 section after the .data section (the problem has only been
702 observed when using the GNU linker, and the default linker
703 script always places the .data and .bss sections in that order). */
704 if (bfd_section_vma (objfile
->obfd
, bss
)
705 < bfd_section_vma (objfile
->obfd
, data
))
708 if (bfd_section_vma (objfile
->obfd
, bss
)
709 < bfd_section_vma (objfile
->obfd
, data
) + bfd_get_section_size (data
))
710 return ((bfd_section_vma (objfile
->obfd
, data
)
711 + bfd_get_section_size (data
))
712 - bfd_section_vma (objfile
->obfd
, bss
));
717 /* Handle symbol translation on vmapping. */
720 vmap_symtab (struct vmap
*vp
)
722 struct objfile
*objfile
;
723 struct section_offsets
*new_offsets
;
726 objfile
= vp
->objfile
;
729 /* OK, it's not an objfile we opened ourselves.
730 Currently, that can only happen with the exec file, so
731 relocate the symbols for the symfile. */
732 if (symfile_objfile
== NULL
)
734 objfile
= symfile_objfile
;
736 else if (!vp
->loaded
)
737 /* If symbols are not yet loaded, offsets are not yet valid. */
741 (struct section_offsets
*)
742 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
744 for (i
= 0; i
< objfile
->num_sections
; ++i
)
745 new_offsets
->offsets
[i
] = ANOFFSET (objfile
->section_offsets
, i
);
747 /* The symbols in the object file are linked to the VMA of the section,
748 relocate them VMA relative. */
749 new_offsets
->offsets
[SECT_OFF_TEXT (objfile
)] = vp
->tstart
- vp
->tvma
;
750 new_offsets
->offsets
[SECT_OFF_DATA (objfile
)] = vp
->dstart
- vp
->dvma
;
751 new_offsets
->offsets
[SECT_OFF_BSS (objfile
)] = vp
->dstart
- vp
->dvma
;
753 /* Perform the same adjustment as the loader if the .data and
754 .bss sections overlap. */
755 new_offsets
->offsets
[SECT_OFF_BSS (objfile
)] += bss_data_overlap (objfile
);
757 objfile_relocate (objfile
, new_offsets
);
760 /* Add symbols for an objfile. */
763 objfile_symbol_add (void *arg
)
765 struct objfile
*obj
= (struct objfile
*) arg
;
767 syms_from_objfile (obj
, NULL
, 0, 0, 0);
768 new_symfile_objfile (obj
, 0);
772 /* Add symbols for a vmap. Return zero upon error. */
775 vmap_add_symbols (struct vmap
*vp
)
777 if (catch_errors (objfile_symbol_add
, vp
->objfile
,
778 "Error while reading shared library symbols:\n",
781 /* Note this is only done if symbol reading was successful. */
789 /* Add a new vmap entry based on ldinfo() information.
791 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
792 core file), the caller should set it to -1, and we will open the file.
794 Return the vmap new entry. */
797 add_vmap (LdInfo
*ldi
)
800 char *mem
, *filename
;
804 ARCH64_DECL (arch64
);
806 /* This ldi structure was allocated using alloca() in
807 xcoff_relocate_symtab(). Now we need to have persistent object
808 and member names, so we should save them. */
810 filename
= LDI_FILENAME (ldi
, arch64
);
811 mem
= filename
+ strlen (filename
) + 1;
814 fd
= LDI_FD (ldi
, arch64
);
815 abfd
= gdb_bfd_open (filename
, gnutarget
, fd
< 0 ? -1 : fd
);
818 warning (_("Could not open `%s' as an executable file: %s"),
819 filename
, bfd_errmsg (bfd_get_error ()));
823 /* Make sure we have an object file. */
825 if (bfd_check_format (abfd
, bfd_object
))
826 vp
= map_vmap (abfd
, 0);
828 else if (bfd_check_format (abfd
, bfd_archive
))
830 last
= gdb_bfd_openr_next_archived_file (abfd
, NULL
);
835 if (strcmp (mem
, last
->filename
) == 0)
838 next
= gdb_bfd_openr_next_archived_file (abfd
, last
);
839 gdb_bfd_unref (last
);
845 warning (_("\"%s\": member \"%s\" missing."), filename
, mem
);
846 gdb_bfd_unref (abfd
);
850 if (!bfd_check_format (last
, bfd_object
))
852 warning (_("\"%s\": member \"%s\" not in executable format: %s."),
853 filename
, mem
, bfd_errmsg (bfd_get_error ()));
854 gdb_bfd_unref (last
);
855 gdb_bfd_unref (abfd
);
859 vp
= map_vmap (last
, abfd
);
860 /* map_vmap acquired a reference to LAST, so we can release
862 gdb_bfd_unref (last
);
866 warning (_("\"%s\": not in executable format: %s."),
867 filename
, bfd_errmsg (bfd_get_error ()));
868 gdb_bfd_unref (abfd
);
871 obj
= allocate_objfile (vp
->bfd
, 0);
874 /* Always add symbols for the main objfile. */
875 if (vp
== vmap
|| auto_solib_add
)
876 vmap_add_symbols (vp
);
878 /* Anything needing a reference to ABFD has already acquired it, so
879 release our local reference. */
880 gdb_bfd_unref (abfd
);
885 /* update VMAP info with ldinfo() information
886 Input is ptr to ldinfo() results. */
889 vmap_ldinfo (LdInfo
*ldi
)
893 int got_one
, retried
;
894 int got_exec_file
= 0;
896 int arch64
= ARCH64 ();
898 /* For each *ldi, see if we have a corresponding *vp.
899 If so, update the mapping, and symbol table.
900 If not, add an entry and symbol table. */
904 char *name
= LDI_FILENAME (ldi
, arch64
);
905 char *memb
= name
+ strlen (name
) + 1;
906 int fd
= LDI_FD (ldi
, arch64
);
910 if (fstat (fd
, &ii
) < 0)
912 /* The kernel sets ld_info to -1, if the process is still using the
913 object, and the object is removed. Keep the symbol info for the
914 removed object and issue a warning. */
915 warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
920 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
)
922 struct objfile
*objfile
;
924 /* First try to find a `vp', which is the same as in ldinfo.
925 If not the same, just continue and grep the next `vp'. If same,
926 relocate its tstart, tend, dstart, dend values. If no such `vp'
927 found, get out of this for loop, add this ldi entry as a new vmap
928 (add_vmap) and come back, find its `vp' and so on... */
930 /* The filenames are not always sufficient to match on. */
932 if ((name
[0] == '/' && strcmp (name
, vp
->name
) != 0)
933 || (memb
[0] && strcmp (memb
, vp
->member
) != 0))
936 /* See if we are referring to the same file.
937 We have to check objfile->obfd, symfile.c:reread_symbols might
938 have updated the obfd after a change. */
939 objfile
= vp
->objfile
== NULL
? symfile_objfile
: vp
->objfile
;
941 || objfile
->obfd
== NULL
942 || bfd_stat (objfile
->obfd
, &vi
) < 0)
944 warning (_("Unable to stat %s, keeping its symbols"), name
);
948 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
956 /* Found a corresponding VMAP. Remap! */
958 vmap_secs (vp
, ldi
, arch64
);
960 /* The objfile is only NULL for the exec file. */
961 if (vp
->objfile
== NULL
)
964 /* relocate symbol table(s). */
967 /* Announce new object files. Doing this after symbol relocation
968 makes aix-thread.c's job easier. */
970 observer_notify_new_objfile (vp
->objfile
);
972 /* There may be more, so we don't break out of the loop. */
975 /* If there was no matching *vp, we must perforce create the
977 if (!got_one
&& !retried
)
984 while ((next
= LDI_NEXT (ldi
, arch64
))
985 && (ldi
= (void *) (next
+ (char *) ldi
)));
987 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
988 is unlikely that the symbol file is relocated to the proper
989 address. And we might have attached to a process which is
990 running a different copy of the same executable. */
991 if (symfile_objfile
!= NULL
&& !got_exec_file
)
993 warning (_("Symbol file %s\nis not mapped; discarding it.\n\
994 If in fact that file has symbols which the mapped files listed by\n\
995 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
996 \"add-symbol-file\" commands (note that you must take care of relocating\n\
997 symbols to the proper address)."),
998 symfile_objfile
->name
);
999 free_objfile (symfile_objfile
);
1000 gdb_assert (symfile_objfile
== NULL
);
1002 breakpoint_re_set ();
1005 /* As well as symbol tables, exec_sections need relocation. After
1006 the inferior process' termination, there will be a relocated symbol
1007 table exist with no corresponding inferior process. At that time, we
1008 need to use `exec' bfd, rather than the inferior process's memory space
1011 `exec_sections' need to be relocated only once, as long as the exec
1012 file remains unchanged. */
1017 static bfd
*execbfd
;
1019 struct target_section_table
*table
= target_get_section_table (&exec_ops
);
1021 if (execbfd
== exec_bfd
)
1026 if (!vmap
|| !table
->sections
)
1027 error (_("vmap_exec: vmap or table->sections == 0."));
1029 for (i
= 0; &table
->sections
[i
] < table
->sections_end
; i
++)
1031 if (strcmp (".text", table
->sections
[i
].the_bfd_section
->name
) == 0)
1033 table
->sections
[i
].addr
+= vmap
->tstart
- vmap
->tvma
;
1034 table
->sections
[i
].endaddr
+= vmap
->tstart
- vmap
->tvma
;
1036 else if (strcmp (".data", table
->sections
[i
].the_bfd_section
->name
) == 0)
1038 table
->sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
1039 table
->sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
1041 else if (strcmp (".bss", table
->sections
[i
].the_bfd_section
->name
) == 0)
1043 table
->sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
1044 table
->sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
1049 /* Set the current architecture from the host running GDB. Called when
1050 starting a child process. */
1052 static void (*super_create_inferior
) (struct target_ops
*,char *exec_file
,
1053 char *allargs
, char **env
, int from_tty
);
1055 rs6000_create_inferior (struct target_ops
* ops
, char *exec_file
,
1056 char *allargs
, char **env
, int from_tty
)
1058 enum bfd_architecture arch
;
1061 struct gdbarch_info info
;
1063 super_create_inferior (ops
, exec_file
, allargs
, env
, from_tty
);
1067 arch
= bfd_arch_rs6000
;
1068 mach
= bfd_mach_rs6k
;
1072 arch
= bfd_arch_powerpc
;
1073 mach
= bfd_mach_ppc
;
1076 /* FIXME: schauer/2002-02-25:
1077 We don't know if we are executing a 32 or 64 bit executable,
1078 and have no way to pass the proper word size to rs6000_gdbarch_init.
1079 So we have to avoid switching to a new architecture, if the architecture
1081 Blindly calling rs6000_gdbarch_init used to work in older versions of
1082 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
1083 determine the wordsize. */
1086 const struct bfd_arch_info
*exec_bfd_arch_info
;
1088 exec_bfd_arch_info
= bfd_get_arch_info (exec_bfd
);
1089 if (arch
== exec_bfd_arch_info
->arch
)
1093 bfd_default_set_arch_mach (&abfd
, arch
, mach
);
1095 gdbarch_info_init (&info
);
1096 info
.bfd_arch_info
= bfd_get_arch_info (&abfd
);
1097 info
.abfd
= exec_bfd
;
1099 if (!gdbarch_update_p (info
))
1100 internal_error (__FILE__
, __LINE__
,
1101 _("rs6000_create_inferior: failed "
1102 "to select architecture"));
1106 /* xcoff_relocate_symtab - hook for symbol table relocation.
1108 This is only applicable to live processes, and is a no-op when
1109 debugging a core file. */
1112 xcoff_relocate_symtab (unsigned int pid
)
1114 int load_segs
= 64; /* number of load segments */
1117 int arch64
= ARCH64 ();
1118 int ldisize
= arch64
? sizeof (ldi
->l64
) : sizeof (ldi
->l32
);
1121 /* Nothing to do if we are debugging a core file. */
1122 if (!target_has_execution
)
1127 size
= load_segs
* ldisize
;
1128 ldi
= (void *) xrealloc (ldi
, size
);
1131 /* According to my humble theory, AIX has some timing problems and
1132 when the user stack grows, kernel doesn't update stack info in time
1133 and ptrace calls step on user stack. That is why we sleep here a
1134 little, and give kernel to update its internals. */
1139 rc
= rs6000_ptrace64 (PT_LDINFO
, pid
, (unsigned long) ldi
, size
, NULL
);
1141 rc
= rs6000_ptrace32 (PT_LDINFO
, pid
, (int *) ldi
, size
, NULL
);
1145 if (errno
== ENOMEM
)
1148 perror_with_name (_("ptrace ldinfo"));
1153 vmap_exec (); /* relocate the exec and core sections as well. */
1160 /* Core file stuff. */
1162 /* Relocate symtabs and read in shared library info, based on symbols
1163 from the core file. */
1166 xcoff_relocate_core (struct target_ops
*target
)
1168 struct bfd_section
*ldinfo_sec
;
1172 int arch64
= ARCH64 ();
1174 /* Size of a struct ld_info except for the variable-length filename. */
1175 int nonfilesz
= (int)LDI_FILENAME ((LdInfo
*)0, arch64
);
1177 /* Allocated size of buffer. */
1178 int buffer_size
= nonfilesz
;
1179 char *buffer
= xmalloc (buffer_size
);
1180 struct cleanup
*old
= make_cleanup (free_current_contents
, &buffer
);
1182 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1183 if (ldinfo_sec
== NULL
)
1186 fprintf_filtered (gdb_stderr
, "Couldn't get ldinfo from core file: %s\n",
1187 bfd_errmsg (bfd_get_error ()));
1194 int names_found
= 0;
1196 /* Read in everything but the name. */
1197 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, buffer
,
1198 offset
, nonfilesz
) == 0)
1205 if (i
== buffer_size
)
1208 buffer
= xrealloc (buffer
, buffer_size
);
1210 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, &buffer
[i
],
1211 offset
+ i
, 1) == 0)
1213 if (buffer
[i
++] == '\0')
1216 while (names_found
< 2);
1218 ldi
= (LdInfo
*) buffer
;
1220 /* Can't use a file descriptor from the core file; need to open it. */
1222 ldi
->l64
.ldinfo_fd
= -1;
1224 ldi
->l32
.ldinfo_fd
= -1;
1226 /* The first ldinfo is for the exec file, allocated elsewhere. */
1227 if (offset
== 0 && vmap
!= NULL
)
1230 vp
= add_vmap (ldi
);
1232 /* Process next shared library upon error. */
1233 offset
+= LDI_NEXT (ldi
, arch64
);
1237 vmap_secs (vp
, ldi
, arch64
);
1239 /* Unless this is the exec file,
1240 add our sections to the section table for the core target. */
1243 struct target_section
*stp
;
1245 stp
= deprecated_core_resize_section_table (2);
1248 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".text");
1249 stp
->addr
= vp
->tstart
;
1250 stp
->endaddr
= vp
->tend
;
1254 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".data");
1255 stp
->addr
= vp
->dstart
;
1256 stp
->endaddr
= vp
->dend
;
1261 if (vp
!= vmap
&& vp
->objfile
)
1262 observer_notify_new_objfile (vp
->objfile
);
1264 while (LDI_NEXT (ldi
, arch64
) != 0);
1266 breakpoint_re_set ();
1270 /* Under AIX, we have to pass the correct TOC pointer to a function
1271 when calling functions in the inferior.
1272 We try to find the relative toc offset of the objfile containing PC
1273 and add the current load address of the data segment from the vmap. */
1276 find_toc_address (CORE_ADDR pc
)
1280 for (vp
= vmap
; vp
; vp
= vp
->nxt
)
1282 if (pc
>= vp
->tstart
&& pc
< vp
->tend
)
1284 /* vp->objfile is only NULL for the exec file. */
1285 return vp
->dstart
+ xcoff_get_toc_offset (vp
->objfile
== NULL
1290 error (_("Unable to find TOC entry for pc %s."), hex_string (pc
));
1294 void _initialize_rs6000_nat (void);
1297 _initialize_rs6000_nat (void)
1299 struct target_ops
*t
;
1301 t
= inf_ptrace_target ();
1302 t
->to_fetch_registers
= rs6000_fetch_inferior_registers
;
1303 t
->to_store_registers
= rs6000_store_inferior_registers
;
1304 t
->to_xfer_partial
= rs6000_xfer_partial
;
1306 super_create_inferior
= t
->to_create_inferior
;
1307 t
->to_create_inferior
= rs6000_create_inferior
;
1309 t
->to_wait
= rs6000_wait
;
1313 /* Initialize hook in rs6000-tdep.c for determining the TOC address
1314 when calling functions in the inferior. */
1315 rs6000_find_toc_address_hook
= find_toc_address
;