1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
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 2 of the License, or
12 (at your option) any later version.
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.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
28 #include "xcoffsolib.h"
31 #include "libbfd.h" /* For bfd_default_set_arch_mach (FIXME) */
33 #include "exceptions.h"
34 #include "gdb-stabs.h"
36 #include "arch-utils.h"
37 #include "inf-ptrace.h"
39 #include "rs6000-tdep.h"
41 #include "gdb_stdint.h"
43 #include <sys/ptrace.h>
46 #include <sys/param.h>
50 #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 (current_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 (void);
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 (int regno
, int *isfloat
)
146 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_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
== PC_REGNUM
)
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, 0x%llx, %08x, 0x%x) = 0x%x\n",
205 req
, id
, addr
, data
, (unsigned int)buf
, ret
);
210 /* Fetch register REGNO from the inferior. */
213 fetch_register (struct regcache
*regcache
, int regno
)
215 int addr
[MAX_REGISTER_SIZE
];
218 /* Retrieved values may be -1, so infer errors from errno. */
221 nr
= regmap (regno
, &isfloat
);
223 /* Floating-point registers. */
225 rs6000_ptrace32 (PT_READ_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
227 /* Bogus register number. */
230 if (regno
>= NUM_REGS
)
231 fprintf_unfiltered (gdb_stderr
,
232 "gdb error: register no %d not implemented.\n",
237 /* Fixed-point registers. */
241 *addr
= rs6000_ptrace32 (PT_READ_GPR
, PIDGET (inferior_ptid
), (int *)nr
, 0, 0);
244 /* PT_READ_GPR requires the buffer parameter to point to long long,
245 even if the register is really only 32 bits. */
247 rs6000_ptrace64 (PT_READ_GPR
, PIDGET (inferior_ptid
), nr
, 0, &buf
);
248 if (register_size (current_gdbarch
, regno
) == 8)
249 memcpy (addr
, &buf
, 8);
256 regcache_raw_supply (regcache
, regno
, (char *) addr
);
260 /* FIXME: this happens 3 times at the start of each 64-bit program. */
261 perror ("ptrace read");
267 /* Store register REGNO back into the inferior. */
270 store_register (const struct regcache
*regcache
, int regno
)
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 (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
>= NUM_REGS
)
291 fprintf_unfiltered (gdb_stderr
,
292 "gdb error: register no %d not implemented.\n",
296 /* Fixed-point registers. */
299 if (regno
== SP_REGNUM
)
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 ();
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
), (int *)nr
, *addr
, 0);
314 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
315 area, even if the register is really only 32 bits. */
317 if (register_size (current_gdbarch
, regno
) == 8)
318 memcpy (&buf
, addr
, 8);
321 rs6000_ptrace64 (PT_WRITE_GPR
, PIDGET (inferior_ptid
), nr
, 0, &buf
);
327 perror ("ptrace write");
332 /* Read from the inferior all registers if REGNO == -1 and just register
336 rs6000_fetch_inferior_registers (struct regcache
*regcache
, int regno
)
339 fetch_register (regcache
, regno
);
343 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
345 /* Read 32 general purpose registers. */
346 for (regno
= tdep
->ppc_gp0_regnum
;
347 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
350 fetch_register (regcache
, regno
);
353 /* Read general purpose floating point registers. */
354 if (tdep
->ppc_fp0_regnum
>= 0)
355 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
356 fetch_register (regcache
, tdep
->ppc_fp0_regnum
+ regno
);
358 /* Read special registers. */
359 fetch_register (regcache
, PC_REGNUM
);
360 fetch_register (regcache
, tdep
->ppc_ps_regnum
);
361 fetch_register (regcache
, tdep
->ppc_cr_regnum
);
362 fetch_register (regcache
, tdep
->ppc_lr_regnum
);
363 fetch_register (regcache
, tdep
->ppc_ctr_regnum
);
364 fetch_register (regcache
, tdep
->ppc_xer_regnum
);
365 if (tdep
->ppc_fpscr_regnum
>= 0)
366 fetch_register (regcache
, tdep
->ppc_fpscr_regnum
);
367 if (tdep
->ppc_mq_regnum
>= 0)
368 fetch_register (regcache
, tdep
->ppc_mq_regnum
);
372 /* Store our register values back into the inferior.
373 If REGNO is -1, do this for all registers.
374 Otherwise, REGNO specifies which register (so we can save time). */
377 rs6000_store_inferior_registers (struct regcache
*regcache
, int regno
)
380 store_register (regcache
, regno
);
384 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
386 /* Write general purpose registers first. */
387 for (regno
= tdep
->ppc_gp0_regnum
;
388 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
391 store_register (regcache
, regno
);
394 /* Write floating point registers. */
395 if (tdep
->ppc_fp0_regnum
>= 0)
396 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
397 store_register (regcache
, tdep
->ppc_fp0_regnum
+ regno
);
399 /* Write special registers. */
400 store_register (regcache
, PC_REGNUM
);
401 store_register (regcache
, tdep
->ppc_ps_regnum
);
402 store_register (regcache
, tdep
->ppc_cr_regnum
);
403 store_register (regcache
, tdep
->ppc_lr_regnum
);
404 store_register (regcache
, tdep
->ppc_ctr_regnum
);
405 store_register (regcache
, tdep
->ppc_xer_regnum
);
406 if (tdep
->ppc_fpscr_regnum
>= 0)
407 store_register (regcache
, tdep
->ppc_fpscr_regnum
);
408 if (tdep
->ppc_mq_regnum
>= 0)
409 store_register (regcache
, tdep
->ppc_mq_regnum
);
414 /* Attempt a transfer all LEN bytes starting at OFFSET between the
415 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
416 Return the number of bytes actually transferred. */
419 rs6000_xfer_partial (struct target_ops
*ops
, enum target_object object
,
420 const char *annex
, gdb_byte
*readbuf
,
421 const gdb_byte
*writebuf
,
422 ULONGEST offset
, LONGEST len
)
424 pid_t pid
= ptid_get_pid (inferior_ptid
);
425 int arch64
= ARCH64 ();
429 case TARGET_OBJECT_MEMORY
:
433 PTRACE_TYPE_RET word
;
434 gdb_byte byte
[sizeof (PTRACE_TYPE_RET
)];
436 ULONGEST rounded_offset
;
439 /* Round the start offset down to the next long word
441 rounded_offset
= offset
& -(ULONGEST
) sizeof (PTRACE_TYPE_RET
);
443 /* Since ptrace will transfer a single word starting at that
444 rounded_offset the partial_len needs to be adjusted down to
445 that (remember this function only does a single transfer).
446 Should the required length be even less, adjust it down
448 partial_len
= (rounded_offset
+ sizeof (PTRACE_TYPE_RET
)) - offset
;
449 if (partial_len
> len
)
454 /* If OFFSET:PARTIAL_LEN is smaller than
455 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
456 be needed. Read in the entire word. */
457 if (rounded_offset
< offset
458 || (offset
+ partial_len
459 < rounded_offset
+ sizeof (PTRACE_TYPE_RET
)))
461 /* Need part of initial word -- fetch it. */
463 buffer
.word
= rs6000_ptrace64 (PT_READ_I
, pid
,
464 rounded_offset
, 0, NULL
);
466 buffer
.word
= rs6000_ptrace32 (PT_READ_I
, pid
,
467 (int *)(uintptr_t)rounded_offset
,
471 /* Copy data to be written over corresponding part of
473 memcpy (buffer
.byte
+ (offset
- rounded_offset
),
474 writebuf
, partial_len
);
478 rs6000_ptrace64 (PT_WRITE_D
, pid
,
479 rounded_offset
, buffer
.word
, NULL
);
481 rs6000_ptrace32 (PT_WRITE_D
, pid
,
482 (int *)(uintptr_t)rounded_offset
, buffer
.word
, NULL
);
491 buffer
.word
= rs6000_ptrace64 (PT_READ_I
, pid
,
492 rounded_offset
, 0, NULL
);
494 buffer
.word
= rs6000_ptrace32 (PT_READ_I
, pid
,
495 (int *)(uintptr_t)rounded_offset
,
500 /* Copy appropriate bytes out of the buffer. */
501 memcpy (readbuf
, buffer
.byte
+ (offset
- rounded_offset
),
513 /* Wait for the child specified by PTID to do something. Return the
514 process ID of the child, or MINUS_ONE_PTID in case of error; store
515 the status in *OURSTATUS. */
518 rs6000_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
521 int status
, save_errno
;
530 pid
= waitpid (ptid_get_pid (ptid
), &status
, 0);
533 while (pid
== -1 && errno
== EINTR
);
536 clear_sigint_trap ();
540 fprintf_unfiltered (gdb_stderr
,
541 _("Child process unexpectedly missing: %s.\n"),
542 safe_strerror (save_errno
));
544 /* Claim it exited with unknown signal. */
545 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
546 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
547 return minus_one_ptid
;
550 /* Ignore terminated detached child processes. */
551 if (!WIFSTOPPED (status
) && pid
!= ptid_get_pid (inferior_ptid
))
556 /* AIX has a couple of strange returns from wait(). */
558 /* stop after load" status. */
560 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
561 /* signal 0. I have no idea why wait(2) returns with this status word. */
562 else if (status
== 0x7f)
563 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
564 /* A normal waitstatus. Let the usual macros deal with it. */
566 store_waitstatus (ourstatus
, status
);
568 return pid_to_ptid (pid
);
571 /* Execute one dummy breakpoint instruction. This way we give the kernel
572 a chance to do some housekeeping and update inferior's internal data,
576 exec_one_dummy_insn (void)
578 #define DUMMY_INSN_ADDR gdbarch_tdep (current_gdbarch)->text_segment_base+0x200
580 int ret
, status
, pid
;
584 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
585 assume that this address will never be executed again by the real
588 bp
= deprecated_insert_raw_breakpoint (DUMMY_INSN_ADDR
);
590 /* You might think this could be done with a single ptrace call, and
591 you'd be correct for just about every platform I've ever worked
592 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
593 the inferior never hits the breakpoint (it's also worth noting
594 powerpc-ibm-aix4.1.3 works correctly). */
595 prev_pc
= read_pc ();
596 write_pc (DUMMY_INSN_ADDR
);
598 ret
= rs6000_ptrace64 (PT_CONTINUE
, PIDGET (inferior_ptid
), 1, 0, NULL
);
600 ret
= rs6000_ptrace32 (PT_CONTINUE
, PIDGET (inferior_ptid
), (int *)1, 0, NULL
);
603 perror ("pt_continue");
607 pid
= wait (&status
);
609 while (pid
!= PIDGET (inferior_ptid
));
612 deprecated_remove_raw_breakpoint (bp
);
616 /* Copy information about text and data sections from LDI to VP for a 64-bit
617 process if ARCH64 and for a 32-bit process otherwise. */
620 vmap_secs (struct vmap
*vp
, LdInfo
*ldi
, int arch64
)
624 vp
->tstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_textorg
;
625 vp
->tend
= vp
->tstart
+ ldi
->l64
.ldinfo_textsize
;
626 vp
->dstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_dataorg
;
627 vp
->dend
= vp
->dstart
+ ldi
->l64
.ldinfo_datasize
;
631 vp
->tstart
= (unsigned long) ldi
->l32
.ldinfo_textorg
;
632 vp
->tend
= vp
->tstart
+ ldi
->l32
.ldinfo_textsize
;
633 vp
->dstart
= (unsigned long) ldi
->l32
.ldinfo_dataorg
;
634 vp
->dend
= vp
->dstart
+ ldi
->l32
.ldinfo_datasize
;
637 /* The run time loader maps the file header in addition to the text
638 section and returns a pointer to the header in ldinfo_textorg.
639 Adjust the text start address to point to the real start address
640 of the text section. */
641 vp
->tstart
+= vp
->toffs
;
644 /* handle symbol translation on vmapping */
647 vmap_symtab (struct vmap
*vp
)
649 struct objfile
*objfile
;
650 struct section_offsets
*new_offsets
;
653 objfile
= vp
->objfile
;
656 /* OK, it's not an objfile we opened ourselves.
657 Currently, that can only happen with the exec file, so
658 relocate the symbols for the symfile. */
659 if (symfile_objfile
== NULL
)
661 objfile
= symfile_objfile
;
663 else if (!vp
->loaded
)
664 /* If symbols are not yet loaded, offsets are not yet valid. */
668 (struct section_offsets
*)
669 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
671 for (i
= 0; i
< objfile
->num_sections
; ++i
)
672 new_offsets
->offsets
[i
] = ANOFFSET (objfile
->section_offsets
, i
);
674 /* The symbols in the object file are linked to the VMA of the section,
675 relocate them VMA relative. */
676 new_offsets
->offsets
[SECT_OFF_TEXT (objfile
)] = vp
->tstart
- vp
->tvma
;
677 new_offsets
->offsets
[SECT_OFF_DATA (objfile
)] = vp
->dstart
- vp
->dvma
;
678 new_offsets
->offsets
[SECT_OFF_BSS (objfile
)] = vp
->dstart
- vp
->dvma
;
680 objfile_relocate (objfile
, new_offsets
);
683 /* Add symbols for an objfile. */
686 objfile_symbol_add (void *arg
)
688 struct objfile
*obj
= (struct objfile
*) arg
;
690 syms_from_objfile (obj
, NULL
, 0, 0, 0, 0);
691 new_symfile_objfile (obj
, 0, 0);
695 /* Add symbols for a vmap. Return zero upon error. */
698 vmap_add_symbols (struct vmap
*vp
)
700 if (catch_errors (objfile_symbol_add
, vp
->objfile
,
701 "Error while reading shared library symbols:\n",
704 /* Note this is only done if symbol reading was successful. */
712 /* Add a new vmap entry based on ldinfo() information.
714 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
715 core file), the caller should set it to -1, and we will open the file.
717 Return the vmap new entry. */
720 add_vmap (LdInfo
*ldi
)
723 char *mem
, *objname
, *filename
;
727 ARCH64_DECL (arch64
);
729 /* This ldi structure was allocated using alloca() in
730 xcoff_relocate_symtab(). Now we need to have persistent object
731 and member names, so we should save them. */
733 filename
= LDI_FILENAME (ldi
, arch64
);
734 mem
= filename
+ strlen (filename
) + 1;
735 mem
= savestring (mem
, strlen (mem
));
736 objname
= savestring (filename
, strlen (filename
));
738 fd
= LDI_FD (ldi
, arch64
);
740 /* Note that this opens it once for every member; a possible
741 enhancement would be to only open it once for every object. */
742 abfd
= bfd_openr (objname
, gnutarget
);
744 abfd
= bfd_fdopenr (objname
, gnutarget
, fd
);
747 warning (_("Could not open `%s' as an executable file: %s"),
748 objname
, bfd_errmsg (bfd_get_error ()));
752 /* make sure we have an object file */
754 if (bfd_check_format (abfd
, bfd_object
))
755 vp
= map_vmap (abfd
, 0);
757 else if (bfd_check_format (abfd
, bfd_archive
))
760 /* FIXME??? am I tossing BFDs? bfd? */
761 while ((last
= bfd_openr_next_archived_file (abfd
, last
)))
762 if (DEPRECATED_STREQ (mem
, last
->filename
))
767 warning (_("\"%s\": member \"%s\" missing."), objname
, mem
);
772 if (!bfd_check_format (last
, bfd_object
))
774 warning (_("\"%s\": member \"%s\" not in executable format: %s."),
775 objname
, mem
, bfd_errmsg (bfd_get_error ()));
781 vp
= map_vmap (last
, abfd
);
785 warning (_("\"%s\": not in executable format: %s."),
786 objname
, bfd_errmsg (bfd_get_error ()));
790 obj
= allocate_objfile (vp
->bfd
, 0);
793 /* Always add symbols for the main objfile. */
794 if (vp
== vmap
|| auto_solib_add
)
795 vmap_add_symbols (vp
);
799 /* update VMAP info with ldinfo() information
800 Input is ptr to ldinfo() results. */
803 vmap_ldinfo (LdInfo
*ldi
)
807 int got_one
, retried
;
808 int got_exec_file
= 0;
810 int arch64
= ARCH64 ();
812 /* For each *ldi, see if we have a corresponding *vp.
813 If so, update the mapping, and symbol table.
814 If not, add an entry and symbol table. */
818 char *name
= LDI_FILENAME (ldi
, arch64
);
819 char *memb
= name
+ strlen (name
) + 1;
820 int fd
= LDI_FD (ldi
, arch64
);
824 if (fstat (fd
, &ii
) < 0)
826 /* The kernel sets ld_info to -1, if the process is still using the
827 object, and the object is removed. Keep the symbol info for the
828 removed object and issue a warning. */
829 warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
834 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
)
836 struct objfile
*objfile
;
838 /* First try to find a `vp', which is the same as in ldinfo.
839 If not the same, just continue and grep the next `vp'. If same,
840 relocate its tstart, tend, dstart, dend values. If no such `vp'
841 found, get out of this for loop, add this ldi entry as a new vmap
842 (add_vmap) and come back, find its `vp' and so on... */
844 /* The filenames are not always sufficient to match on. */
846 if ((name
[0] == '/' && !DEPRECATED_STREQ (name
, vp
->name
))
847 || (memb
[0] && !DEPRECATED_STREQ (memb
, vp
->member
)))
850 /* See if we are referring to the same file.
851 We have to check objfile->obfd, symfile.c:reread_symbols might
852 have updated the obfd after a change. */
853 objfile
= vp
->objfile
== NULL
? symfile_objfile
: vp
->objfile
;
855 || objfile
->obfd
== NULL
856 || bfd_stat (objfile
->obfd
, &vi
) < 0)
858 warning (_("Unable to stat %s, keeping its symbols"), name
);
862 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
870 /* Found a corresponding VMAP. Remap! */
872 vmap_secs (vp
, ldi
, arch64
);
874 /* The objfile is only NULL for the exec file. */
875 if (vp
->objfile
== NULL
)
878 /* relocate symbol table(s). */
881 /* Announce new object files. Doing this after symbol relocation
882 makes aix-thread.c's job easier. */
883 if (deprecated_target_new_objfile_hook
&& vp
->objfile
)
884 deprecated_target_new_objfile_hook (vp
->objfile
);
886 /* There may be more, so we don't break out of the loop. */
889 /* if there was no matching *vp, we must perforce create the sucker(s) */
890 if (!got_one
&& !retried
)
897 while ((next
= LDI_NEXT (ldi
, arch64
))
898 && (ldi
= (void *) (next
+ (char *) ldi
)));
900 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
901 is unlikely that the symbol file is relocated to the proper
902 address. And we might have attached to a process which is
903 running a different copy of the same executable. */
904 if (symfile_objfile
!= NULL
&& !got_exec_file
)
906 warning (_("Symbol file %s\nis not mapped; discarding it.\n\
907 If in fact that file has symbols which the mapped files listed by\n\
908 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
909 \"add-symbol-file\" commands (note that you must take care of relocating\n\
910 symbols to the proper address)."),
911 symfile_objfile
->name
);
912 free_objfile (symfile_objfile
);
913 symfile_objfile
= NULL
;
915 breakpoint_re_set ();
918 /* As well as symbol tables, exec_sections need relocation. After
919 the inferior process' termination, there will be a relocated symbol
920 table exist with no corresponding inferior process. At that time, we
921 need to use `exec' bfd, rather than the inferior process's memory space
924 `exec_sections' need to be relocated only once, as long as the exec
925 file remains unchanged.
934 if (execbfd
== exec_bfd
)
939 if (!vmap
|| !exec_ops
.to_sections
)
940 error (_("vmap_exec: vmap or exec_ops.to_sections == 0."));
942 for (i
= 0; &exec_ops
.to_sections
[i
] < exec_ops
.to_sections_end
; i
++)
944 if (DEPRECATED_STREQ (".text", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
946 exec_ops
.to_sections
[i
].addr
+= vmap
->tstart
- vmap
->tvma
;
947 exec_ops
.to_sections
[i
].endaddr
+= vmap
->tstart
- vmap
->tvma
;
949 else if (DEPRECATED_STREQ (".data", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
951 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
952 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
954 else if (DEPRECATED_STREQ (".bss", exec_ops
.to_sections
[i
].the_bfd_section
->name
))
956 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
957 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
962 /* Set the current architecture from the host running GDB. Called when
963 starting a child process. */
965 static void (*super_create_inferior
) (char *exec_file
, char *allargs
,
966 char **env
, int from_tty
);
968 rs6000_create_inferior (char *exec_file
, char *allargs
, char **env
, int from_tty
)
970 enum bfd_architecture arch
;
973 struct gdbarch_info info
;
975 super_create_inferior (exec_file
, allargs
, env
, from_tty
);
979 arch
= bfd_arch_rs6000
;
980 mach
= bfd_mach_rs6k
;
984 arch
= bfd_arch_powerpc
;
988 /* FIXME: schauer/2002-02-25:
989 We don't know if we are executing a 32 or 64 bit executable,
990 and have no way to pass the proper word size to rs6000_gdbarch_init.
991 So we have to avoid switching to a new architecture, if the architecture
993 Blindly calling rs6000_gdbarch_init used to work in older versions of
994 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
995 determine the wordsize. */
998 const struct bfd_arch_info
*exec_bfd_arch_info
;
1000 exec_bfd_arch_info
= bfd_get_arch_info (exec_bfd
);
1001 if (arch
== exec_bfd_arch_info
->arch
)
1005 bfd_default_set_arch_mach (&abfd
, arch
, mach
);
1007 gdbarch_info_init (&info
);
1008 info
.bfd_arch_info
= bfd_get_arch_info (&abfd
);
1009 info
.abfd
= exec_bfd
;
1011 if (!gdbarch_update_p (info
))
1012 internal_error (__FILE__
, __LINE__
,
1013 _("rs6000_create_inferior: failed to select architecture"));
1017 /* xcoff_relocate_symtab - hook for symbol table relocation.
1018 also reads shared libraries. */
1021 xcoff_relocate_symtab (unsigned int pid
)
1023 int load_segs
= 64; /* number of load segments */
1026 int arch64
= ARCH64 ();
1027 int ldisize
= arch64
? sizeof (ldi
->l64
) : sizeof (ldi
->l32
);
1032 size
= load_segs
* ldisize
;
1033 ldi
= (void *) xrealloc (ldi
, size
);
1036 /* According to my humble theory, AIX has some timing problems and
1037 when the user stack grows, kernel doesn't update stack info in time
1038 and ptrace calls step on user stack. That is why we sleep here a
1039 little, and give kernel to update its internals. */
1044 rc
= rs6000_ptrace64 (PT_LDINFO
, pid
, (unsigned long) ldi
, size
, NULL
);
1046 rc
= rs6000_ptrace32 (PT_LDINFO
, pid
, (int *) ldi
, size
, NULL
);
1050 if (errno
== ENOMEM
)
1053 perror_with_name (_("ptrace ldinfo"));
1058 vmap_exec (); /* relocate the exec and core sections as well. */
1065 /* Core file stuff. */
1067 /* Relocate symtabs and read in shared library info, based on symbols
1068 from the core file. */
1071 xcoff_relocate_core (struct target_ops
*target
)
1073 struct bfd_section
*ldinfo_sec
;
1077 int arch64
= ARCH64 ();
1079 /* Size of a struct ld_info except for the variable-length filename. */
1080 int nonfilesz
= (int)LDI_FILENAME ((LdInfo
*)0, arch64
);
1082 /* Allocated size of buffer. */
1083 int buffer_size
= nonfilesz
;
1084 char *buffer
= xmalloc (buffer_size
);
1085 struct cleanup
*old
= make_cleanup (free_current_contents
, &buffer
);
1087 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1088 if (ldinfo_sec
== NULL
)
1091 fprintf_filtered (gdb_stderr
, "Couldn't get ldinfo from core file: %s\n",
1092 bfd_errmsg (bfd_get_error ()));
1099 int names_found
= 0;
1101 /* Read in everything but the name. */
1102 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, buffer
,
1103 offset
, nonfilesz
) == 0)
1110 if (i
== buffer_size
)
1113 buffer
= xrealloc (buffer
, buffer_size
);
1115 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, &buffer
[i
],
1116 offset
+ i
, 1) == 0)
1118 if (buffer
[i
++] == '\0')
1121 while (names_found
< 2);
1123 ldi
= (LdInfo
*) buffer
;
1125 /* Can't use a file descriptor from the core file; need to open it. */
1127 ldi
->l64
.ldinfo_fd
= -1;
1129 ldi
->l32
.ldinfo_fd
= -1;
1131 /* The first ldinfo is for the exec file, allocated elsewhere. */
1132 if (offset
== 0 && vmap
!= NULL
)
1135 vp
= add_vmap (ldi
);
1137 /* Process next shared library upon error. */
1138 offset
+= LDI_NEXT (ldi
, arch64
);
1142 vmap_secs (vp
, ldi
, arch64
);
1144 /* Unless this is the exec file,
1145 add our sections to the section table for the core target. */
1148 struct section_table
*stp
;
1150 target_resize_to_sections (target
, 2);
1151 stp
= target
->to_sections_end
- 2;
1154 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".text");
1155 stp
->addr
= vp
->tstart
;
1156 stp
->endaddr
= vp
->tend
;
1160 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".data");
1161 stp
->addr
= vp
->dstart
;
1162 stp
->endaddr
= vp
->dend
;
1167 if (deprecated_target_new_objfile_hook
&& vp
!= vmap
&& vp
->objfile
)
1168 deprecated_target_new_objfile_hook (vp
->objfile
);
1170 while (LDI_NEXT (ldi
, arch64
) != 0);
1172 breakpoint_re_set ();
1176 /* Under AIX, we have to pass the correct TOC pointer to a function
1177 when calling functions in the inferior.
1178 We try to find the relative toc offset of the objfile containing PC
1179 and add the current load address of the data segment from the vmap. */
1182 find_toc_address (CORE_ADDR pc
)
1185 extern CORE_ADDR
get_toc_offset (struct objfile
*); /* xcoffread.c */
1187 for (vp
= vmap
; vp
; vp
= vp
->nxt
)
1189 if (pc
>= vp
->tstart
&& pc
< vp
->tend
)
1191 /* vp->objfile is only NULL for the exec file. */
1192 return vp
->dstart
+ get_toc_offset (vp
->objfile
== NULL
1197 error (_("Unable to find TOC entry for pc %s."), hex_string (pc
));
1202 _initialize_rs6000_nat (void)
1204 struct target_ops
*t
;
1206 t
= inf_ptrace_target ();
1207 t
->to_fetch_registers
= rs6000_fetch_inferior_registers
;
1208 t
->to_store_registers
= rs6000_store_inferior_registers
;
1209 t
->to_xfer_partial
= rs6000_xfer_partial
;
1211 super_create_inferior
= t
->to_create_inferior
;
1212 t
->to_create_inferior
= rs6000_create_inferior
;
1214 t
->to_wait
= rs6000_wait
;
1218 /* Initialize hook in rs6000-tdep.c for determining the TOC address
1219 when calling functions in the inferior. */
1220 rs6000_find_toc_address_hook
= find_toc_address
;