1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
3 Copyright (C) 1986-1987, 1989, 1991-2004, 2007-2012 Free Software
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "xcoffsolib.h"
28 #include "libbfd.h" /* For bfd_default_set_arch_mach (FIXME) */
30 #include "exceptions.h"
31 #include "gdb-stabs.h"
33 #include "arch-utils.h"
34 #include "inf-child.h"
35 #include "inf-ptrace.h"
37 #include "rs6000-tdep.h"
40 #include "xcoffread.h"
42 #include <sys/ptrace.h>
45 #include <sys/param.h>
49 #include <sys/ioctl.h>
58 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
59 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
61 #include <sys/systemcfg.h>
63 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
64 debugging 32-bit and 64-bit processes. Define a typedef and macros for
65 accessing fields in the appropriate structures. */
67 /* In 32-bit compilation mode (which is the only mode from which ptrace()
68 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
74 /* Return whether the current architecture is 64-bit. */
79 # define ARCH64() (register_size (target_gdbarch (), 0) == 8)
82 /* Union of 32-bit and 64-bit versions of ld_info. */
89 struct __ld_info32 l32
;
90 struct __ld_info64 l64
;
94 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
95 declare and initialize a variable named VAR suitable for use as the arch64
96 parameter to the various LDI_*() macros. */
99 # define ARCH64_DECL(var)
101 # define ARCH64_DECL(var) int var = ARCH64 ()
104 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
105 otherwise. This technique only works for FIELDs with the same data type in
106 32-bit and 64-bit versions of ld_info. */
109 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
111 # define LDI_FIELD(ldi, arch64, field) \
112 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
115 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
116 process otherwise. */
118 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
119 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
120 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
122 extern struct vmap
*map_vmap (bfd
* bf
, bfd
* arch
);
124 static void vmap_exec (void);
126 static void vmap_ldinfo (LdInfo
*);
128 static struct vmap
*add_vmap (LdInfo
*);
130 static int objfile_symbol_add (void *);
132 static void vmap_symtab (struct vmap
*);
134 static void exec_one_dummy_insn (struct regcache
*);
136 extern void fixup_breakpoints (CORE_ADDR low
, CORE_ADDR high
, CORE_ADDR delta
);
138 /* Given REGNO, a gdb register number, return the corresponding
139 number suitable for use as a ptrace() parameter. Return -1 if
140 there's no suitable mapping. Also, set the int pointed to by
141 ISFLOAT to indicate whether REGNO is a floating point register. */
144 regmap (struct gdbarch
*gdbarch
, int regno
, int *isfloat
)
146 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
149 if (tdep
->ppc_gp0_regnum
<= regno
150 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
)
152 else if (tdep
->ppc_fp0_regnum
>= 0
153 && tdep
->ppc_fp0_regnum
<= regno
154 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)
157 return regno
- tdep
->ppc_fp0_regnum
+ FPR0
;
159 else if (regno
== gdbarch_pc_regnum (gdbarch
))
161 else if (regno
== tdep
->ppc_ps_regnum
)
163 else if (regno
== tdep
->ppc_cr_regnum
)
165 else if (regno
== tdep
->ppc_lr_regnum
)
167 else if (regno
== tdep
->ppc_ctr_regnum
)
169 else if (regno
== tdep
->ppc_xer_regnum
)
171 else if (tdep
->ppc_fpscr_regnum
>= 0
172 && regno
== tdep
->ppc_fpscr_regnum
)
174 else if (tdep
->ppc_mq_regnum
>= 0 && regno
== tdep
->ppc_mq_regnum
)
180 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
183 rs6000_ptrace32 (int req
, int id
, int *addr
, int data
, int *buf
)
185 int ret
= ptrace (req
, id
, (int *)addr
, data
, buf
);
187 printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
188 req
, id
, (unsigned int)addr
, data
, (unsigned int)buf
, ret
);
193 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
196 rs6000_ptrace64 (int req
, int id
, long long addr
, int data
, void *buf
)
199 int ret
= ptracex (req
, id
, addr
, data
, buf
);
204 printf ("rs6000_ptrace64 (%d, %d, %s, %08x, 0x%x) = 0x%x\n",
205 req
, id
, hex_string (addr
), data
, (unsigned int)buf
, ret
);
210 /* Fetch register REGNO from the inferior. */
213 fetch_register (struct regcache
*regcache
, int regno
)
215 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
216 int addr
[MAX_REGISTER_SIZE
];
219 /* Retrieved values may be -1, so infer errors from errno. */
222 nr
= regmap (gdbarch
, regno
, &isfloat
);
224 /* Floating-point registers. */
226 rs6000_ptrace32 (PT_READ_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
228 /* Bogus register number. */
231 if (regno
>= gdbarch_num_regs (gdbarch
))
232 fprintf_unfiltered (gdb_stderr
,
233 "gdb error: register no %d not implemented.\n",
238 /* Fixed-point registers. */
242 *addr
= rs6000_ptrace32 (PT_READ_GPR
, PIDGET (inferior_ptid
),
246 /* PT_READ_GPR requires the buffer parameter to point to long long,
247 even if the register is really only 32 bits. */
249 rs6000_ptrace64 (PT_READ_GPR
, PIDGET (inferior_ptid
), nr
, 0, &buf
);
250 if (register_size (gdbarch
, regno
) == 8)
251 memcpy (addr
, &buf
, 8);
258 regcache_raw_supply (regcache
, regno
, (char *) addr
);
262 /* FIXME: this happens 3 times at the start of each 64-bit program. */
263 perror (_("ptrace read"));
269 /* Store register REGNO back into the inferior. */
272 store_register (struct regcache
*regcache
, int regno
)
274 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
275 int addr
[MAX_REGISTER_SIZE
];
278 /* Fetch the register's value from the register cache. */
279 regcache_raw_collect (regcache
, regno
, addr
);
281 /* -1 can be a successful return value, so infer errors from errno. */
284 nr
= regmap (gdbarch
, regno
, &isfloat
);
286 /* Floating-point registers. */
288 rs6000_ptrace32 (PT_WRITE_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
290 /* Bogus register number. */
293 if (regno
>= gdbarch_num_regs (gdbarch
))
294 fprintf_unfiltered (gdb_stderr
,
295 "gdb error: register no %d not implemented.\n",
299 /* Fixed-point registers. */
302 if (regno
== gdbarch_sp_regnum (gdbarch
))
303 /* Execute one dummy instruction (which is a breakpoint) in inferior
304 process to give kernel a chance to do internal housekeeping.
305 Otherwise the following ptrace(2) calls will mess up user stack
306 since kernel will get confused about the bottom of the stack
308 exec_one_dummy_insn (regcache
);
310 /* The PT_WRITE_GPR operation is rather odd. For 32-bit inferiors,
311 the register's value is passed by value, but for 64-bit inferiors,
312 the address of a buffer containing the value is passed. */
314 rs6000_ptrace32 (PT_WRITE_GPR
, PIDGET (inferior_ptid
),
315 (int *) nr
, *addr
, 0);
318 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
319 area, even if the register is really only 32 bits. */
321 if (register_size (gdbarch
, regno
) == 8)
322 memcpy (&buf
, addr
, 8);
325 rs6000_ptrace64 (PT_WRITE_GPR
, PIDGET (inferior_ptid
), nr
, 0, &buf
);
331 perror (_("ptrace write"));
336 /* Read from the inferior all registers if REGNO == -1 and just register
340 rs6000_fetch_inferior_registers (struct target_ops
*ops
,
341 struct regcache
*regcache
, int regno
)
343 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
345 fetch_register (regcache
, regno
);
349 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
351 /* Read 32 general purpose registers. */
352 for (regno
= tdep
->ppc_gp0_regnum
;
353 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
356 fetch_register (regcache
, regno
);
359 /* Read general purpose floating point registers. */
360 if (tdep
->ppc_fp0_regnum
>= 0)
361 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
362 fetch_register (regcache
, tdep
->ppc_fp0_regnum
+ regno
);
364 /* Read special registers. */
365 fetch_register (regcache
, gdbarch_pc_regnum (gdbarch
));
366 fetch_register (regcache
, tdep
->ppc_ps_regnum
);
367 fetch_register (regcache
, tdep
->ppc_cr_regnum
);
368 fetch_register (regcache
, tdep
->ppc_lr_regnum
);
369 fetch_register (regcache
, tdep
->ppc_ctr_regnum
);
370 fetch_register (regcache
, tdep
->ppc_xer_regnum
);
371 if (tdep
->ppc_fpscr_regnum
>= 0)
372 fetch_register (regcache
, tdep
->ppc_fpscr_regnum
);
373 if (tdep
->ppc_mq_regnum
>= 0)
374 fetch_register (regcache
, tdep
->ppc_mq_regnum
);
378 /* Store our register values back into the inferior.
379 If REGNO is -1, do this for all registers.
380 Otherwise, REGNO specifies which register (so we can save time). */
383 rs6000_store_inferior_registers (struct target_ops
*ops
,
384 struct regcache
*regcache
, int regno
)
386 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
388 store_register (regcache
, regno
);
392 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
394 /* Write general purpose registers first. */
395 for (regno
= tdep
->ppc_gp0_regnum
;
396 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
399 store_register (regcache
, regno
);
402 /* Write floating point registers. */
403 if (tdep
->ppc_fp0_regnum
>= 0)
404 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
405 store_register (regcache
, tdep
->ppc_fp0_regnum
+ regno
);
407 /* Write special registers. */
408 store_register (regcache
, gdbarch_pc_regnum (gdbarch
));
409 store_register (regcache
, tdep
->ppc_ps_regnum
);
410 store_register (regcache
, tdep
->ppc_cr_regnum
);
411 store_register (regcache
, tdep
->ppc_lr_regnum
);
412 store_register (regcache
, tdep
->ppc_ctr_regnum
);
413 store_register (regcache
, tdep
->ppc_xer_regnum
);
414 if (tdep
->ppc_fpscr_regnum
>= 0)
415 store_register (regcache
, tdep
->ppc_fpscr_regnum
);
416 if (tdep
->ppc_mq_regnum
>= 0)
417 store_register (regcache
, tdep
->ppc_mq_regnum
);
422 /* Attempt a transfer all LEN bytes starting at OFFSET between the
423 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
424 Return the number of bytes actually transferred. */
427 rs6000_xfer_partial (struct target_ops
*ops
, enum target_object object
,
428 const char *annex
, gdb_byte
*readbuf
,
429 const gdb_byte
*writebuf
,
430 ULONGEST offset
, LONGEST len
)
432 pid_t pid
= ptid_get_pid (inferior_ptid
);
433 int arch64
= ARCH64 ();
437 case TARGET_OBJECT_MEMORY
:
441 PTRACE_TYPE_RET word
;
442 gdb_byte byte
[sizeof (PTRACE_TYPE_RET
)];
444 ULONGEST rounded_offset
;
447 /* Round the start offset down to the next long word
449 rounded_offset
= offset
& -(ULONGEST
) sizeof (PTRACE_TYPE_RET
);
451 /* Since ptrace will transfer a single word starting at that
452 rounded_offset the partial_len needs to be adjusted down to
453 that (remember this function only does a single transfer).
454 Should the required length be even less, adjust it down
456 partial_len
= (rounded_offset
+ sizeof (PTRACE_TYPE_RET
)) - offset
;
457 if (partial_len
> len
)
462 /* If OFFSET:PARTIAL_LEN is smaller than
463 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
464 be needed. Read in the entire word. */
465 if (rounded_offset
< offset
466 || (offset
+ partial_len
467 < rounded_offset
+ sizeof (PTRACE_TYPE_RET
)))
469 /* Need part of initial word -- fetch it. */
471 buffer
.word
= rs6000_ptrace64 (PT_READ_I
, pid
,
472 rounded_offset
, 0, NULL
);
474 buffer
.word
= rs6000_ptrace32 (PT_READ_I
, pid
,
480 /* Copy data to be written over corresponding part of
482 memcpy (buffer
.byte
+ (offset
- rounded_offset
),
483 writebuf
, partial_len
);
487 rs6000_ptrace64 (PT_WRITE_D
, pid
,
488 rounded_offset
, buffer
.word
, NULL
);
490 rs6000_ptrace32 (PT_WRITE_D
, pid
,
491 (int *) (uintptr_t) rounded_offset
,
501 buffer
.word
= rs6000_ptrace64 (PT_READ_I
, pid
,
502 rounded_offset
, 0, NULL
);
504 buffer
.word
= rs6000_ptrace32 (PT_READ_I
, pid
,
505 (int *)(uintptr_t)rounded_offset
,
510 /* Copy appropriate bytes out of the buffer. */
511 memcpy (readbuf
, buffer
.byte
+ (offset
- rounded_offset
),
523 /* Wait for the child specified by PTID to do something. Return the
524 process ID of the child, or MINUS_ONE_PTID in case of error; store
525 the status in *OURSTATUS. */
528 rs6000_wait (struct target_ops
*ops
,
529 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
532 int status
, save_errno
;
540 pid
= waitpid (ptid_get_pid (ptid
), &status
, 0);
543 while (pid
== -1 && errno
== EINTR
);
545 clear_sigint_trap ();
549 fprintf_unfiltered (gdb_stderr
,
550 _("Child process unexpectedly missing: %s.\n"),
551 safe_strerror (save_errno
));
553 /* Claim it exited with unknown signal. */
554 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
555 ourstatus
->value
.sig
= GDB_SIGNAL_UNKNOWN
;
556 return inferior_ptid
;
559 /* Ignore terminated detached child processes. */
560 if (!WIFSTOPPED (status
) && pid
!= ptid_get_pid (inferior_ptid
))
565 /* AIX has a couple of strange returns from wait(). */
567 /* stop after load" status. */
569 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
570 /* signal 0. I have no idea why wait(2) returns with this status word. */
571 else if (status
== 0x7f)
572 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
573 /* A normal waitstatus. Let the usual macros deal with it. */
575 store_waitstatus (ourstatus
, status
);
577 return pid_to_ptid (pid
);
580 /* Execute one dummy breakpoint instruction. This way we give the kernel
581 a chance to do some housekeeping and update inferior's internal data,
585 exec_one_dummy_insn (struct regcache
*regcache
)
587 #define DUMMY_INSN_ADDR AIX_TEXT_SEGMENT_BASE+0x200
589 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
590 int ret
, status
, pid
;
594 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
595 assume that this address will never be executed again by the real
598 bp
= deprecated_insert_raw_breakpoint (gdbarch
, NULL
, DUMMY_INSN_ADDR
);
600 /* You might think this could be done with a single ptrace call, and
601 you'd be correct for just about every platform I've ever worked
602 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
603 the inferior never hits the breakpoint (it's also worth noting
604 powerpc-ibm-aix4.1.3 works correctly). */
605 prev_pc
= regcache_read_pc (regcache
);
606 regcache_write_pc (regcache
, DUMMY_INSN_ADDR
);
608 ret
= rs6000_ptrace64 (PT_CONTINUE
, PIDGET (inferior_ptid
), 1, 0, NULL
);
610 ret
= rs6000_ptrace32 (PT_CONTINUE
, PIDGET (inferior_ptid
),
614 perror (_("pt_continue"));
618 pid
= waitpid (PIDGET (inferior_ptid
), &status
, 0);
620 while (pid
!= PIDGET (inferior_ptid
));
622 regcache_write_pc (regcache
, prev_pc
);
623 deprecated_remove_raw_breakpoint (gdbarch
, bp
);
627 /* Copy information about text and data sections from LDI to VP for a 64-bit
628 process if ARCH64 and for a 32-bit process otherwise. */
631 vmap_secs (struct vmap
*vp
, LdInfo
*ldi
, int arch64
)
635 vp
->tstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_textorg
;
636 vp
->tend
= vp
->tstart
+ ldi
->l64
.ldinfo_textsize
;
637 vp
->dstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_dataorg
;
638 vp
->dend
= vp
->dstart
+ ldi
->l64
.ldinfo_datasize
;
642 vp
->tstart
= (unsigned long) ldi
->l32
.ldinfo_textorg
;
643 vp
->tend
= vp
->tstart
+ ldi
->l32
.ldinfo_textsize
;
644 vp
->dstart
= (unsigned long) ldi
->l32
.ldinfo_dataorg
;
645 vp
->dend
= vp
->dstart
+ ldi
->l32
.ldinfo_datasize
;
648 /* The run time loader maps the file header in addition to the text
649 section and returns a pointer to the header in ldinfo_textorg.
650 Adjust the text start address to point to the real start address
651 of the text section. */
652 vp
->tstart
+= vp
->toffs
;
655 /* Handle symbol translation on vmapping. */
658 vmap_symtab (struct vmap
*vp
)
660 struct objfile
*objfile
;
661 struct section_offsets
*new_offsets
;
664 objfile
= vp
->objfile
;
667 /* OK, it's not an objfile we opened ourselves.
668 Currently, that can only happen with the exec file, so
669 relocate the symbols for the symfile. */
670 if (symfile_objfile
== NULL
)
672 objfile
= symfile_objfile
;
674 else if (!vp
->loaded
)
675 /* If symbols are not yet loaded, offsets are not yet valid. */
679 (struct section_offsets
*)
680 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
682 for (i
= 0; i
< objfile
->num_sections
; ++i
)
683 new_offsets
->offsets
[i
] = ANOFFSET (objfile
->section_offsets
, i
);
685 /* The symbols in the object file are linked to the VMA of the section,
686 relocate them VMA relative. */
687 new_offsets
->offsets
[SECT_OFF_TEXT (objfile
)] = vp
->tstart
- vp
->tvma
;
688 new_offsets
->offsets
[SECT_OFF_DATA (objfile
)] = vp
->dstart
- vp
->dvma
;
689 new_offsets
->offsets
[SECT_OFF_BSS (objfile
)] = vp
->dstart
- vp
->dvma
;
691 objfile_relocate (objfile
, new_offsets
);
694 /* Add symbols for an objfile. */
697 objfile_symbol_add (void *arg
)
699 struct objfile
*obj
= (struct objfile
*) arg
;
701 syms_from_objfile (obj
, NULL
, 0, 0, 0);
702 new_symfile_objfile (obj
, 0);
706 /* Add symbols for a vmap. Return zero upon error. */
709 vmap_add_symbols (struct vmap
*vp
)
711 if (catch_errors (objfile_symbol_add
, vp
->objfile
,
712 "Error while reading shared library symbols:\n",
715 /* Note this is only done if symbol reading was successful. */
723 /* Add a new vmap entry based on ldinfo() information.
725 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
726 core file), the caller should set it to -1, and we will open the file.
728 Return the vmap new entry. */
731 add_vmap (LdInfo
*ldi
)
734 char *mem
, *filename
;
738 ARCH64_DECL (arch64
);
740 /* This ldi structure was allocated using alloca() in
741 xcoff_relocate_symtab(). Now we need to have persistent object
742 and member names, so we should save them. */
744 filename
= LDI_FILENAME (ldi
, arch64
);
745 mem
= filename
+ strlen (filename
) + 1;
748 fd
= LDI_FD (ldi
, arch64
);
749 abfd
= gdb_bfd_open (filename
, gnutarget
, fd
< 0 ? -1 : fd
);
752 warning (_("Could not open `%s' as an executable file: %s"),
753 filename
, bfd_errmsg (bfd_get_error ()));
757 /* Make sure we have an object file. */
759 if (bfd_check_format (abfd
, bfd_object
))
760 vp
= map_vmap (abfd
, 0);
762 else if (bfd_check_format (abfd
, bfd_archive
))
764 last
= gdb_bfd_openr_next_archived_file (abfd
, NULL
);
769 if (strcmp (mem
, last
->filename
) == 0)
772 next
= gdb_bfd_openr_next_archived_file (abfd
, last
);
773 gdb_bfd_unref (last
);
779 warning (_("\"%s\": member \"%s\" missing."), filename
, mem
);
780 gdb_bfd_unref (abfd
);
784 if (!bfd_check_format (last
, bfd_object
))
786 warning (_("\"%s\": member \"%s\" not in executable format: %s."),
787 filename
, mem
, bfd_errmsg (bfd_get_error ()));
788 gdb_bfd_unref (last
);
789 gdb_bfd_unref (abfd
);
793 vp
= map_vmap (last
, abfd
);
794 /* map_vmap acquired a reference to LAST, so we can release
796 gdb_bfd_unref (last
);
800 warning (_("\"%s\": not in executable format: %s."),
801 filename
, bfd_errmsg (bfd_get_error ()));
802 gdb_bfd_unref (abfd
);
805 obj
= allocate_objfile (vp
->bfd
, 0);
808 /* Always add symbols for the main objfile. */
809 if (vp
== vmap
|| auto_solib_add
)
810 vmap_add_symbols (vp
);
812 /* Anything needing a reference to ABFD has already acquired it, so
813 release our local reference. */
814 gdb_bfd_unref (abfd
);
819 /* update VMAP info with ldinfo() information
820 Input is ptr to ldinfo() results. */
823 vmap_ldinfo (LdInfo
*ldi
)
827 int got_one
, retried
;
828 int got_exec_file
= 0;
830 int arch64
= ARCH64 ();
832 /* For each *ldi, see if we have a corresponding *vp.
833 If so, update the mapping, and symbol table.
834 If not, add an entry and symbol table. */
838 char *name
= LDI_FILENAME (ldi
, arch64
);
839 char *memb
= name
+ strlen (name
) + 1;
840 int fd
= LDI_FD (ldi
, arch64
);
844 if (fstat (fd
, &ii
) < 0)
846 /* The kernel sets ld_info to -1, if the process is still using the
847 object, and the object is removed. Keep the symbol info for the
848 removed object and issue a warning. */
849 warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
854 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
)
856 struct objfile
*objfile
;
858 /* First try to find a `vp', which is the same as in ldinfo.
859 If not the same, just continue and grep the next `vp'. If same,
860 relocate its tstart, tend, dstart, dend values. If no such `vp'
861 found, get out of this for loop, add this ldi entry as a new vmap
862 (add_vmap) and come back, find its `vp' and so on... */
864 /* The filenames are not always sufficient to match on. */
866 if ((name
[0] == '/' && strcmp (name
, vp
->name
) != 0)
867 || (memb
[0] && strcmp (memb
, vp
->member
) != 0))
870 /* See if we are referring to the same file.
871 We have to check objfile->obfd, symfile.c:reread_symbols might
872 have updated the obfd after a change. */
873 objfile
= vp
->objfile
== NULL
? symfile_objfile
: vp
->objfile
;
875 || objfile
->obfd
== NULL
876 || bfd_stat (objfile
->obfd
, &vi
) < 0)
878 warning (_("Unable to stat %s, keeping its symbols"), name
);
882 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
890 /* Found a corresponding VMAP. Remap! */
892 vmap_secs (vp
, ldi
, arch64
);
894 /* The objfile is only NULL for the exec file. */
895 if (vp
->objfile
== NULL
)
898 /* relocate symbol table(s). */
901 /* Announce new object files. Doing this after symbol relocation
902 makes aix-thread.c's job easier. */
904 observer_notify_new_objfile (vp
->objfile
);
906 /* There may be more, so we don't break out of the loop. */
909 /* If there was no matching *vp, we must perforce create the
911 if (!got_one
&& !retried
)
918 while ((next
= LDI_NEXT (ldi
, arch64
))
919 && (ldi
= (void *) (next
+ (char *) ldi
)));
921 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
922 is unlikely that the symbol file is relocated to the proper
923 address. And we might have attached to a process which is
924 running a different copy of the same executable. */
925 if (symfile_objfile
!= NULL
&& !got_exec_file
)
927 warning (_("Symbol file %s\nis not mapped; discarding it.\n\
928 If in fact that file has symbols which the mapped files listed by\n\
929 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
930 \"add-symbol-file\" commands (note that you must take care of relocating\n\
931 symbols to the proper address)."),
932 symfile_objfile
->name
);
933 free_objfile (symfile_objfile
);
934 gdb_assert (symfile_objfile
== NULL
);
936 breakpoint_re_set ();
939 /* As well as symbol tables, exec_sections need relocation. After
940 the inferior process' termination, there will be a relocated symbol
941 table exist with no corresponding inferior process. At that time, we
942 need to use `exec' bfd, rather than the inferior process's memory space
945 `exec_sections' need to be relocated only once, as long as the exec
946 file remains unchanged. */
953 struct target_section_table
*table
= target_get_section_table (&exec_ops
);
955 if (execbfd
== exec_bfd
)
960 if (!vmap
|| !table
->sections
)
961 error (_("vmap_exec: vmap or table->sections == 0."));
963 for (i
= 0; &table
->sections
[i
] < table
->sections_end
; i
++)
965 if (strcmp (".text", table
->sections
[i
].the_bfd_section
->name
) == 0)
967 table
->sections
[i
].addr
+= vmap
->tstart
- vmap
->tvma
;
968 table
->sections
[i
].endaddr
+= vmap
->tstart
- vmap
->tvma
;
970 else if (strcmp (".data", table
->sections
[i
].the_bfd_section
->name
) == 0)
972 table
->sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
973 table
->sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
975 else if (strcmp (".bss", table
->sections
[i
].the_bfd_section
->name
) == 0)
977 table
->sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
978 table
->sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
983 /* Set the current architecture from the host running GDB. Called when
984 starting a child process. */
986 static void (*super_create_inferior
) (struct target_ops
*,char *exec_file
,
987 char *allargs
, char **env
, int from_tty
);
989 rs6000_create_inferior (struct target_ops
* ops
, char *exec_file
,
990 char *allargs
, char **env
, int from_tty
)
992 enum bfd_architecture arch
;
995 struct gdbarch_info info
;
997 super_create_inferior (ops
, exec_file
, allargs
, env
, from_tty
);
1001 arch
= bfd_arch_rs6000
;
1002 mach
= bfd_mach_rs6k
;
1006 arch
= bfd_arch_powerpc
;
1007 mach
= bfd_mach_ppc
;
1010 /* FIXME: schauer/2002-02-25:
1011 We don't know if we are executing a 32 or 64 bit executable,
1012 and have no way to pass the proper word size to rs6000_gdbarch_init.
1013 So we have to avoid switching to a new architecture, if the architecture
1015 Blindly calling rs6000_gdbarch_init used to work in older versions of
1016 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
1017 determine the wordsize. */
1020 const struct bfd_arch_info
*exec_bfd_arch_info
;
1022 exec_bfd_arch_info
= bfd_get_arch_info (exec_bfd
);
1023 if (arch
== exec_bfd_arch_info
->arch
)
1027 bfd_default_set_arch_mach (&abfd
, arch
, mach
);
1029 gdbarch_info_init (&info
);
1030 info
.bfd_arch_info
= bfd_get_arch_info (&abfd
);
1031 info
.abfd
= exec_bfd
;
1033 if (!gdbarch_update_p (info
))
1034 internal_error (__FILE__
, __LINE__
,
1035 _("rs6000_create_inferior: failed "
1036 "to select architecture"));
1040 /* xcoff_relocate_symtab - hook for symbol table relocation.
1042 This is only applicable to live processes, and is a no-op when
1043 debugging a core file. */
1046 xcoff_relocate_symtab (unsigned int pid
)
1048 int load_segs
= 64; /* number of load segments */
1051 int arch64
= ARCH64 ();
1052 int ldisize
= arch64
? sizeof (ldi
->l64
) : sizeof (ldi
->l32
);
1055 /* Nothing to do if we are debugging a core file. */
1056 if (!target_has_execution
)
1061 size
= load_segs
* ldisize
;
1062 ldi
= (void *) xrealloc (ldi
, size
);
1065 /* According to my humble theory, AIX has some timing problems and
1066 when the user stack grows, kernel doesn't update stack info in time
1067 and ptrace calls step on user stack. That is why we sleep here a
1068 little, and give kernel to update its internals. */
1073 rc
= rs6000_ptrace64 (PT_LDINFO
, pid
, (unsigned long) ldi
, size
, NULL
);
1075 rc
= rs6000_ptrace32 (PT_LDINFO
, pid
, (int *) ldi
, size
, NULL
);
1079 if (errno
== ENOMEM
)
1082 perror_with_name (_("ptrace ldinfo"));
1087 vmap_exec (); /* relocate the exec and core sections as well. */
1094 /* Core file stuff. */
1096 /* Relocate symtabs and read in shared library info, based on symbols
1097 from the core file. */
1100 xcoff_relocate_core (struct target_ops
*target
)
1102 struct bfd_section
*ldinfo_sec
;
1106 int arch64
= ARCH64 ();
1108 /* Size of a struct ld_info except for the variable-length filename. */
1109 int nonfilesz
= (int)LDI_FILENAME ((LdInfo
*)0, arch64
);
1111 /* Allocated size of buffer. */
1112 int buffer_size
= nonfilesz
;
1113 char *buffer
= xmalloc (buffer_size
);
1114 struct cleanup
*old
= make_cleanup (free_current_contents
, &buffer
);
1116 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1117 if (ldinfo_sec
== NULL
)
1120 fprintf_filtered (gdb_stderr
, "Couldn't get ldinfo from core file: %s\n",
1121 bfd_errmsg (bfd_get_error ()));
1128 int names_found
= 0;
1130 /* Read in everything but the name. */
1131 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, buffer
,
1132 offset
, nonfilesz
) == 0)
1139 if (i
== buffer_size
)
1142 buffer
= xrealloc (buffer
, buffer_size
);
1144 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, &buffer
[i
],
1145 offset
+ i
, 1) == 0)
1147 if (buffer
[i
++] == '\0')
1150 while (names_found
< 2);
1152 ldi
= (LdInfo
*) buffer
;
1154 /* Can't use a file descriptor from the core file; need to open it. */
1156 ldi
->l64
.ldinfo_fd
= -1;
1158 ldi
->l32
.ldinfo_fd
= -1;
1160 /* The first ldinfo is for the exec file, allocated elsewhere. */
1161 if (offset
== 0 && vmap
!= NULL
)
1164 vp
= add_vmap (ldi
);
1166 /* Process next shared library upon error. */
1167 offset
+= LDI_NEXT (ldi
, arch64
);
1171 vmap_secs (vp
, ldi
, arch64
);
1173 /* Unless this is the exec file,
1174 add our sections to the section table for the core target. */
1177 struct target_section
*stp
;
1179 stp
= deprecated_core_resize_section_table (2);
1182 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".text");
1183 stp
->addr
= vp
->tstart
;
1184 stp
->endaddr
= vp
->tend
;
1188 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".data");
1189 stp
->addr
= vp
->dstart
;
1190 stp
->endaddr
= vp
->dend
;
1195 if (vp
!= vmap
&& vp
->objfile
)
1196 observer_notify_new_objfile (vp
->objfile
);
1198 while (LDI_NEXT (ldi
, arch64
) != 0);
1200 breakpoint_re_set ();
1204 /* Under AIX, we have to pass the correct TOC pointer to a function
1205 when calling functions in the inferior.
1206 We try to find the relative toc offset of the objfile containing PC
1207 and add the current load address of the data segment from the vmap. */
1210 find_toc_address (CORE_ADDR pc
)
1214 for (vp
= vmap
; vp
; vp
= vp
->nxt
)
1216 if (pc
>= vp
->tstart
&& pc
< vp
->tend
)
1218 /* vp->objfile is only NULL for the exec file. */
1219 return vp
->dstart
+ xcoff_get_toc_offset (vp
->objfile
== NULL
1224 error (_("Unable to find TOC entry for pc %s."), hex_string (pc
));
1228 void _initialize_rs6000_nat (void);
1231 _initialize_rs6000_nat (void)
1233 struct target_ops
*t
;
1235 t
= inf_ptrace_target ();
1236 t
->to_fetch_registers
= rs6000_fetch_inferior_registers
;
1237 t
->to_store_registers
= rs6000_store_inferior_registers
;
1238 t
->to_xfer_partial
= rs6000_xfer_partial
;
1240 super_create_inferior
= t
->to_create_inferior
;
1241 t
->to_create_inferior
= rs6000_create_inferior
;
1243 t
->to_wait
= rs6000_wait
;
1247 /* Initialize hook in rs6000-tdep.c for determining the TOC address
1248 when calling functions in the inferior. */
1249 rs6000_find_toc_address_hook
= find_toc_address
;