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, 2008, 2009
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 3 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, see <http://www.gnu.org/licenses/>. */
26 #include "xcoffsolib.h"
29 #include "libbfd.h" /* For bfd_default_set_arch_mach (FIXME) */
31 #include "exceptions.h"
32 #include "gdb-stabs.h"
34 #include "arch-utils.h"
35 #include "inf-ptrace.h"
37 #include "rs6000-tdep.h"
41 #include <sys/ptrace.h>
44 #include <sys/param.h>
48 #include <sys/ioctl.h>
56 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
57 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
59 #include <sys/systemcfg.h>
61 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
62 debugging 32-bit and 64-bit processes. Define a typedef and macros for
63 accessing fields in the appropriate structures. */
65 /* In 32-bit compilation mode (which is the only mode from which ptrace()
66 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
72 /* Return whether the current architecture is 64-bit. */
77 # define ARCH64() (register_size (current_gdbarch, 0) == 8)
80 /* Union of 32-bit and 64-bit versions of ld_info. */
87 struct __ld_info32 l32
;
88 struct __ld_info64 l64
;
92 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
93 declare and initialize a variable named VAR suitable for use as the arch64
94 parameter to the various LDI_*() macros. */
97 # define ARCH64_DECL(var)
99 # define ARCH64_DECL(var) int var = ARCH64 ()
102 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
103 otherwise. This technique only works for FIELDs with the same data type in
104 32-bit and 64-bit versions of ld_info. */
107 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
109 # define LDI_FIELD(ldi, arch64, field) \
110 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
113 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
114 process otherwise. */
116 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
117 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
118 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
120 extern struct vmap
*map_vmap (bfd
* bf
, bfd
* arch
);
122 static void vmap_exec (void);
124 static void vmap_ldinfo (LdInfo
*);
126 static struct vmap
*add_vmap (LdInfo
*);
128 static int objfile_symbol_add (void *);
130 static void vmap_symtab (struct vmap
*);
132 static void exec_one_dummy_insn (struct gdbarch
*);
134 extern void fixup_breakpoints (CORE_ADDR low
, CORE_ADDR high
, CORE_ADDR delta
);
136 /* Given REGNO, a gdb register number, return the corresponding
137 number suitable for use as a ptrace() parameter. Return -1 if
138 there's no suitable mapping. Also, set the int pointed to by
139 ISFLOAT to indicate whether REGNO is a floating point register. */
142 regmap (struct gdbarch
*gdbarch
, int regno
, int *isfloat
)
144 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
147 if (tdep
->ppc_gp0_regnum
<= regno
148 && regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
)
150 else if (tdep
->ppc_fp0_regnum
>= 0
151 && tdep
->ppc_fp0_regnum
<= regno
152 && regno
< tdep
->ppc_fp0_regnum
+ ppc_num_fprs
)
155 return regno
- tdep
->ppc_fp0_regnum
+ FPR0
;
157 else if (regno
== gdbarch_pc_regnum (gdbarch
))
159 else if (regno
== tdep
->ppc_ps_regnum
)
161 else if (regno
== tdep
->ppc_cr_regnum
)
163 else if (regno
== tdep
->ppc_lr_regnum
)
165 else if (regno
== tdep
->ppc_ctr_regnum
)
167 else if (regno
== tdep
->ppc_xer_regnum
)
169 else if (tdep
->ppc_fpscr_regnum
>= 0
170 && regno
== tdep
->ppc_fpscr_regnum
)
172 else if (tdep
->ppc_mq_regnum
>= 0 && regno
== tdep
->ppc_mq_regnum
)
178 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
181 rs6000_ptrace32 (int req
, int id
, int *addr
, int data
, int *buf
)
183 int ret
= ptrace (req
, id
, (int *)addr
, data
, buf
);
185 printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
186 req
, id
, (unsigned int)addr
, data
, (unsigned int)buf
, ret
);
191 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
194 rs6000_ptrace64 (int req
, int id
, long long addr
, int data
, void *buf
)
197 int ret
= ptracex (req
, id
, addr
, data
, buf
);
202 printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
203 req
, id
, addr
, data
, (unsigned int)buf
, ret
);
208 /* Fetch register REGNO from the inferior. */
211 fetch_register (struct regcache
*regcache
, int regno
)
213 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
214 int addr
[MAX_REGISTER_SIZE
];
217 /* Retrieved values may be -1, so infer errors from errno. */
220 nr
= regmap (gdbarch
, regno
, &isfloat
);
222 /* Floating-point registers. */
224 rs6000_ptrace32 (PT_READ_FPR
, PIDGET (inferior_ptid
), addr
, nr
, 0);
226 /* Bogus register number. */
229 if (regno
>= gdbarch_num_regs (gdbarch
))
230 fprintf_unfiltered (gdb_stderr
,
231 "gdb error: register no %d not implemented.\n",
236 /* Fixed-point registers. */
240 *addr
= rs6000_ptrace32 (PT_READ_GPR
, PIDGET (inferior_ptid
), (int *)nr
, 0, 0);
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 (const 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 (gdbarch
);
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 (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
)
338 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
340 fetch_register (regcache
, regno
);
344 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
346 /* Read 32 general purpose registers. */
347 for (regno
= tdep
->ppc_gp0_regnum
;
348 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
351 fetch_register (regcache
, regno
);
354 /* Read general purpose floating point registers. */
355 if (tdep
->ppc_fp0_regnum
>= 0)
356 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
357 fetch_register (regcache
, tdep
->ppc_fp0_regnum
+ regno
);
359 /* Read special registers. */
360 fetch_register (regcache
, gdbarch_pc_regnum (gdbarch
));
361 fetch_register (regcache
, tdep
->ppc_ps_regnum
);
362 fetch_register (regcache
, tdep
->ppc_cr_regnum
);
363 fetch_register (regcache
, tdep
->ppc_lr_regnum
);
364 fetch_register (regcache
, tdep
->ppc_ctr_regnum
);
365 fetch_register (regcache
, tdep
->ppc_xer_regnum
);
366 if (tdep
->ppc_fpscr_regnum
>= 0)
367 fetch_register (regcache
, tdep
->ppc_fpscr_regnum
);
368 if (tdep
->ppc_mq_regnum
>= 0)
369 fetch_register (regcache
, tdep
->ppc_mq_regnum
);
373 /* Store our register values back into the inferior.
374 If REGNO is -1, do this for all registers.
375 Otherwise, REGNO specifies which register (so we can save time). */
378 rs6000_store_inferior_registers (struct regcache
*regcache
, int regno
)
380 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
382 store_register (regcache
, regno
);
386 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
388 /* Write general purpose registers first. */
389 for (regno
= tdep
->ppc_gp0_regnum
;
390 regno
< tdep
->ppc_gp0_regnum
+ ppc_num_gprs
;
393 store_register (regcache
, regno
);
396 /* Write floating point registers. */
397 if (tdep
->ppc_fp0_regnum
>= 0)
398 for (regno
= 0; regno
< ppc_num_fprs
; regno
++)
399 store_register (regcache
, tdep
->ppc_fp0_regnum
+ regno
);
401 /* Write special registers. */
402 store_register (regcache
, gdbarch_pc_regnum (gdbarch
));
403 store_register (regcache
, tdep
->ppc_ps_regnum
);
404 store_register (regcache
, tdep
->ppc_cr_regnum
);
405 store_register (regcache
, tdep
->ppc_lr_regnum
);
406 store_register (regcache
, tdep
->ppc_ctr_regnum
);
407 store_register (regcache
, tdep
->ppc_xer_regnum
);
408 if (tdep
->ppc_fpscr_regnum
>= 0)
409 store_register (regcache
, tdep
->ppc_fpscr_regnum
);
410 if (tdep
->ppc_mq_regnum
>= 0)
411 store_register (regcache
, tdep
->ppc_mq_regnum
);
416 /* Attempt a transfer all LEN bytes starting at OFFSET between the
417 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
418 Return the number of bytes actually transferred. */
421 rs6000_xfer_partial (struct target_ops
*ops
, enum target_object object
,
422 const char *annex
, gdb_byte
*readbuf
,
423 const gdb_byte
*writebuf
,
424 ULONGEST offset
, LONGEST len
)
426 pid_t pid
= ptid_get_pid (inferior_ptid
);
427 int arch64
= ARCH64 ();
431 case TARGET_OBJECT_MEMORY
:
435 PTRACE_TYPE_RET word
;
436 gdb_byte byte
[sizeof (PTRACE_TYPE_RET
)];
438 ULONGEST rounded_offset
;
441 /* Round the start offset down to the next long word
443 rounded_offset
= offset
& -(ULONGEST
) sizeof (PTRACE_TYPE_RET
);
445 /* Since ptrace will transfer a single word starting at that
446 rounded_offset the partial_len needs to be adjusted down to
447 that (remember this function only does a single transfer).
448 Should the required length be even less, adjust it down
450 partial_len
= (rounded_offset
+ sizeof (PTRACE_TYPE_RET
)) - offset
;
451 if (partial_len
> len
)
456 /* If OFFSET:PARTIAL_LEN is smaller than
457 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
458 be needed. Read in the entire word. */
459 if (rounded_offset
< offset
460 || (offset
+ partial_len
461 < rounded_offset
+ sizeof (PTRACE_TYPE_RET
)))
463 /* Need part of initial word -- fetch it. */
465 buffer
.word
= rs6000_ptrace64 (PT_READ_I
, pid
,
466 rounded_offset
, 0, NULL
);
468 buffer
.word
= rs6000_ptrace32 (PT_READ_I
, pid
,
469 (int *)(uintptr_t)rounded_offset
,
473 /* Copy data to be written over corresponding part of
475 memcpy (buffer
.byte
+ (offset
- rounded_offset
),
476 writebuf
, partial_len
);
480 rs6000_ptrace64 (PT_WRITE_D
, pid
,
481 rounded_offset
, buffer
.word
, NULL
);
483 rs6000_ptrace32 (PT_WRITE_D
, pid
,
484 (int *)(uintptr_t)rounded_offset
, buffer
.word
, NULL
);
493 buffer
.word
= rs6000_ptrace64 (PT_READ_I
, pid
,
494 rounded_offset
, 0, NULL
);
496 buffer
.word
= rs6000_ptrace32 (PT_READ_I
, pid
,
497 (int *)(uintptr_t)rounded_offset
,
502 /* Copy appropriate bytes out of the buffer. */
503 memcpy (readbuf
, buffer
.byte
+ (offset
- rounded_offset
),
515 /* Wait for the child specified by PTID to do something. Return the
516 process ID of the child, or MINUS_ONE_PTID in case of error; store
517 the status in *OURSTATUS. */
520 rs6000_wait (struct target_ops
*ops
,
521 ptid_t ptid
, struct target_waitstatus
*ourstatus
)
524 int status
, save_errno
;
532 pid
= waitpid (ptid_get_pid (ptid
), &status
, 0);
535 while (pid
== -1 && errno
== EINTR
);
537 clear_sigint_trap ();
541 fprintf_unfiltered (gdb_stderr
,
542 _("Child process unexpectedly missing: %s.\n"),
543 safe_strerror (save_errno
));
545 /* Claim it exited with unknown signal. */
546 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
547 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
548 return inferior_ptid
;
551 /* Ignore terminated detached child processes. */
552 if (!WIFSTOPPED (status
) && pid
!= ptid_get_pid (inferior_ptid
))
557 /* AIX has a couple of strange returns from wait(). */
559 /* stop after load" status. */
561 ourstatus
->kind
= TARGET_WAITKIND_LOADED
;
562 /* signal 0. I have no idea why wait(2) returns with this status word. */
563 else if (status
== 0x7f)
564 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
565 /* A normal waitstatus. Let the usual macros deal with it. */
567 store_waitstatus (ourstatus
, status
);
569 return pid_to_ptid (pid
);
572 /* Execute one dummy breakpoint instruction. This way we give the kernel
573 a chance to do some housekeeping and update inferior's internal data,
577 exec_one_dummy_insn (struct gdbarch
*gdbarch
)
579 #define DUMMY_INSN_ADDR AIX_TEXT_SEGMENT_BASE+0x200
581 int ret
, status
, pid
;
585 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
586 assume that this address will never be executed again by the real
589 bp
= deprecated_insert_raw_breakpoint (DUMMY_INSN_ADDR
);
591 /* You might think this could be done with a single ptrace call, and
592 you'd be correct for just about every platform I've ever worked
593 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
594 the inferior never hits the breakpoint (it's also worth noting
595 powerpc-ibm-aix4.1.3 works correctly). */
596 prev_pc
= read_pc ();
597 write_pc (DUMMY_INSN_ADDR
);
599 ret
= rs6000_ptrace64 (PT_CONTINUE
, PIDGET (inferior_ptid
), 1, 0, NULL
);
601 ret
= rs6000_ptrace32 (PT_CONTINUE
, PIDGET (inferior_ptid
), (int *)1, 0, NULL
);
604 perror ("pt_continue");
608 pid
= wait (&status
);
610 while (pid
!= PIDGET (inferior_ptid
));
613 deprecated_remove_raw_breakpoint (bp
);
617 /* Copy information about text and data sections from LDI to VP for a 64-bit
618 process if ARCH64 and for a 32-bit process otherwise. */
621 vmap_secs (struct vmap
*vp
, LdInfo
*ldi
, int arch64
)
625 vp
->tstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_textorg
;
626 vp
->tend
= vp
->tstart
+ ldi
->l64
.ldinfo_textsize
;
627 vp
->dstart
= (CORE_ADDR
) ldi
->l64
.ldinfo_dataorg
;
628 vp
->dend
= vp
->dstart
+ ldi
->l64
.ldinfo_datasize
;
632 vp
->tstart
= (unsigned long) ldi
->l32
.ldinfo_textorg
;
633 vp
->tend
= vp
->tstart
+ ldi
->l32
.ldinfo_textsize
;
634 vp
->dstart
= (unsigned long) ldi
->l32
.ldinfo_dataorg
;
635 vp
->dend
= vp
->dstart
+ ldi
->l32
.ldinfo_datasize
;
638 /* The run time loader maps the file header in addition to the text
639 section and returns a pointer to the header in ldinfo_textorg.
640 Adjust the text start address to point to the real start address
641 of the text section. */
642 vp
->tstart
+= vp
->toffs
;
645 /* handle symbol translation on vmapping */
648 vmap_symtab (struct vmap
*vp
)
650 struct objfile
*objfile
;
651 struct section_offsets
*new_offsets
;
654 objfile
= vp
->objfile
;
657 /* OK, it's not an objfile we opened ourselves.
658 Currently, that can only happen with the exec file, so
659 relocate the symbols for the symfile. */
660 if (symfile_objfile
== NULL
)
662 objfile
= symfile_objfile
;
664 else if (!vp
->loaded
)
665 /* If symbols are not yet loaded, offsets are not yet valid. */
669 (struct section_offsets
*)
670 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
672 for (i
= 0; i
< objfile
->num_sections
; ++i
)
673 new_offsets
->offsets
[i
] = ANOFFSET (objfile
->section_offsets
, i
);
675 /* The symbols in the object file are linked to the VMA of the section,
676 relocate them VMA relative. */
677 new_offsets
->offsets
[SECT_OFF_TEXT (objfile
)] = vp
->tstart
- vp
->tvma
;
678 new_offsets
->offsets
[SECT_OFF_DATA (objfile
)] = vp
->dstart
- vp
->dvma
;
679 new_offsets
->offsets
[SECT_OFF_BSS (objfile
)] = vp
->dstart
- vp
->dvma
;
681 objfile_relocate (objfile
, new_offsets
);
684 /* Add symbols for an objfile. */
687 objfile_symbol_add (void *arg
)
689 struct objfile
*obj
= (struct objfile
*) arg
;
691 syms_from_objfile (obj
, NULL
, 0, 0, 0, 0);
692 new_symfile_objfile (obj
, 0, 0);
696 /* Add symbols for a vmap. Return zero upon error. */
699 vmap_add_symbols (struct vmap
*vp
)
701 if (catch_errors (objfile_symbol_add
, vp
->objfile
,
702 "Error while reading shared library symbols:\n",
705 /* Note this is only done if symbol reading was successful. */
713 /* Add a new vmap entry based on ldinfo() information.
715 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
716 core file), the caller should set it to -1, and we will open the file.
718 Return the vmap new entry. */
721 add_vmap (LdInfo
*ldi
)
724 char *mem
, *objname
, *filename
;
728 ARCH64_DECL (arch64
);
730 /* This ldi structure was allocated using alloca() in
731 xcoff_relocate_symtab(). Now we need to have persistent object
732 and member names, so we should save them. */
734 filename
= LDI_FILENAME (ldi
, arch64
);
735 mem
= filename
+ strlen (filename
) + 1;
736 mem
= savestring (mem
, strlen (mem
));
737 objname
= savestring (filename
, strlen (filename
));
739 fd
= LDI_FD (ldi
, arch64
);
741 /* Note that this opens it once for every member; a possible
742 enhancement would be to only open it once for every object. */
743 abfd
= bfd_openr (objname
, gnutarget
);
745 abfd
= bfd_fdopenr (objname
, gnutarget
, fd
);
748 warning (_("Could not open `%s' as an executable file: %s"),
749 objname
, bfd_errmsg (bfd_get_error ()));
753 /* make sure we have an object file */
755 if (bfd_check_format (abfd
, bfd_object
))
756 vp
= map_vmap (abfd
, 0);
758 else if (bfd_check_format (abfd
, bfd_archive
))
761 /* FIXME??? am I tossing BFDs? bfd? */
762 while ((last
= bfd_openr_next_archived_file (abfd
, last
)))
763 if (strcmp (mem
, last
->filename
) == 0)
768 warning (_("\"%s\": member \"%s\" missing."), objname
, mem
);
773 if (!bfd_check_format (last
, bfd_object
))
775 warning (_("\"%s\": member \"%s\" not in executable format: %s."),
776 objname
, mem
, bfd_errmsg (bfd_get_error ()));
782 vp
= map_vmap (last
, abfd
);
786 warning (_("\"%s\": not in executable format: %s."),
787 objname
, bfd_errmsg (bfd_get_error ()));
791 obj
= allocate_objfile (vp
->bfd
, 0);
794 /* Always add symbols for the main objfile. */
795 if (vp
== vmap
|| auto_solib_add
)
796 vmap_add_symbols (vp
);
800 /* update VMAP info with ldinfo() information
801 Input is ptr to ldinfo() results. */
804 vmap_ldinfo (LdInfo
*ldi
)
808 int got_one
, retried
;
809 int got_exec_file
= 0;
811 int arch64
= ARCH64 ();
813 /* For each *ldi, see if we have a corresponding *vp.
814 If so, update the mapping, and symbol table.
815 If not, add an entry and symbol table. */
819 char *name
= LDI_FILENAME (ldi
, arch64
);
820 char *memb
= name
+ strlen (name
) + 1;
821 int fd
= LDI_FD (ldi
, arch64
);
825 if (fstat (fd
, &ii
) < 0)
827 /* The kernel sets ld_info to -1, if the process is still using the
828 object, and the object is removed. Keep the symbol info for the
829 removed object and issue a warning. */
830 warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
835 for (got_one
= 0, vp
= vmap
; vp
; vp
= vp
->nxt
)
837 struct objfile
*objfile
;
839 /* First try to find a `vp', which is the same as in ldinfo.
840 If not the same, just continue and grep the next `vp'. If same,
841 relocate its tstart, tend, dstart, dend values. If no such `vp'
842 found, get out of this for loop, add this ldi entry as a new vmap
843 (add_vmap) and come back, find its `vp' and so on... */
845 /* The filenames are not always sufficient to match on. */
847 if ((name
[0] == '/' && strcmp (name
, vp
->name
) != 0)
848 || (memb
[0] && strcmp (memb
, vp
->member
) != 0))
851 /* See if we are referring to the same file.
852 We have to check objfile->obfd, symfile.c:reread_symbols might
853 have updated the obfd after a change. */
854 objfile
= vp
->objfile
== NULL
? symfile_objfile
: vp
->objfile
;
856 || objfile
->obfd
== NULL
857 || bfd_stat (objfile
->obfd
, &vi
) < 0)
859 warning (_("Unable to stat %s, keeping its symbols"), name
);
863 if (ii
.st_dev
!= vi
.st_dev
|| ii
.st_ino
!= vi
.st_ino
)
871 /* Found a corresponding VMAP. Remap! */
873 vmap_secs (vp
, ldi
, arch64
);
875 /* The objfile is only NULL for the exec file. */
876 if (vp
->objfile
== NULL
)
879 /* relocate symbol table(s). */
882 /* Announce new object files. Doing this after symbol relocation
883 makes aix-thread.c's job easier. */
885 observer_notify_new_objfile (vp
->objfile
);
887 /* There may be more, so we don't break out of the loop. */
890 /* if there was no matching *vp, we must perforce create the sucker(s) */
891 if (!got_one
&& !retried
)
898 while ((next
= LDI_NEXT (ldi
, arch64
))
899 && (ldi
= (void *) (next
+ (char *) ldi
)));
901 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
902 is unlikely that the symbol file is relocated to the proper
903 address. And we might have attached to a process which is
904 running a different copy of the same executable. */
905 if (symfile_objfile
!= NULL
&& !got_exec_file
)
907 warning (_("Symbol file %s\nis not mapped; discarding it.\n\
908 If in fact that file has symbols which the mapped files listed by\n\
909 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
910 \"add-symbol-file\" commands (note that you must take care of relocating\n\
911 symbols to the proper address)."),
912 symfile_objfile
->name
);
913 free_objfile (symfile_objfile
);
914 symfile_objfile
= NULL
;
916 breakpoint_re_set ();
919 /* As well as symbol tables, exec_sections need relocation. After
920 the inferior process' termination, there will be a relocated symbol
921 table exist with no corresponding inferior process. At that time, we
922 need to use `exec' bfd, rather than the inferior process's memory space
925 `exec_sections' need to be relocated only once, as long as the exec
926 file remains unchanged.
935 if (execbfd
== exec_bfd
)
940 if (!vmap
|| !exec_ops
.to_sections
)
941 error (_("vmap_exec: vmap or exec_ops.to_sections == 0."));
943 for (i
= 0; &exec_ops
.to_sections
[i
] < exec_ops
.to_sections_end
; i
++)
945 if (strcmp (".text", exec_ops
.to_sections
[i
].the_bfd_section
->name
) == 0)
947 exec_ops
.to_sections
[i
].addr
+= vmap
->tstart
- vmap
->tvma
;
948 exec_ops
.to_sections
[i
].endaddr
+= vmap
->tstart
- vmap
->tvma
;
950 else if (strcmp (".data",
951 exec_ops
.to_sections
[i
].the_bfd_section
->name
) == 0)
953 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
954 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
956 else if (strcmp (".bss",
957 exec_ops
.to_sections
[i
].the_bfd_section
->name
) == 0)
959 exec_ops
.to_sections
[i
].addr
+= vmap
->dstart
- vmap
->dvma
;
960 exec_ops
.to_sections
[i
].endaddr
+= vmap
->dstart
- vmap
->dvma
;
965 /* Set the current architecture from the host running GDB. Called when
966 starting a child process. */
968 static void (*super_create_inferior
) (struct target_ops
*,char *exec_file
,
969 char *allargs
, char **env
, int from_tty
);
971 rs6000_create_inferior (struct target_ops
* ops
, char *exec_file
,
972 char *allargs
, char **env
, int from_tty
)
974 enum bfd_architecture arch
;
977 struct gdbarch_info info
;
979 super_create_inferior (ops
, exec_file
, allargs
, env
, from_tty
);
983 arch
= bfd_arch_rs6000
;
984 mach
= bfd_mach_rs6k
;
988 arch
= bfd_arch_powerpc
;
992 /* FIXME: schauer/2002-02-25:
993 We don't know if we are executing a 32 or 64 bit executable,
994 and have no way to pass the proper word size to rs6000_gdbarch_init.
995 So we have to avoid switching to a new architecture, if the architecture
997 Blindly calling rs6000_gdbarch_init used to work in older versions of
998 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
999 determine the wordsize. */
1002 const struct bfd_arch_info
*exec_bfd_arch_info
;
1004 exec_bfd_arch_info
= bfd_get_arch_info (exec_bfd
);
1005 if (arch
== exec_bfd_arch_info
->arch
)
1009 bfd_default_set_arch_mach (&abfd
, arch
, mach
);
1011 gdbarch_info_init (&info
);
1012 info
.bfd_arch_info
= bfd_get_arch_info (&abfd
);
1013 info
.abfd
= exec_bfd
;
1015 if (!gdbarch_update_p (info
))
1016 internal_error (__FILE__
, __LINE__
,
1017 _("rs6000_create_inferior: failed to select architecture"));
1021 /* xcoff_relocate_symtab - hook for symbol table relocation.
1023 This is only applicable to live processes, and is a no-op when
1024 debugging a core file. */
1027 xcoff_relocate_symtab (unsigned int pid
)
1029 int load_segs
= 64; /* number of load segments */
1032 int arch64
= ARCH64 ();
1033 int ldisize
= arch64
? sizeof (ldi
->l64
) : sizeof (ldi
->l32
);
1036 if (ptid_equal (inferior_ptid
, null_ptid
))
1041 size
= load_segs
* ldisize
;
1042 ldi
= (void *) xrealloc (ldi
, size
);
1045 /* According to my humble theory, AIX has some timing problems and
1046 when the user stack grows, kernel doesn't update stack info in time
1047 and ptrace calls step on user stack. That is why we sleep here a
1048 little, and give kernel to update its internals. */
1053 rc
= rs6000_ptrace64 (PT_LDINFO
, pid
, (unsigned long) ldi
, size
, NULL
);
1055 rc
= rs6000_ptrace32 (PT_LDINFO
, pid
, (int *) ldi
, size
, NULL
);
1059 if (errno
== ENOMEM
)
1062 perror_with_name (_("ptrace ldinfo"));
1067 vmap_exec (); /* relocate the exec and core sections as well. */
1074 /* Core file stuff. */
1076 /* Relocate symtabs and read in shared library info, based on symbols
1077 from the core file. */
1080 xcoff_relocate_core (struct target_ops
*target
)
1082 struct bfd_section
*ldinfo_sec
;
1086 int arch64
= ARCH64 ();
1088 /* Size of a struct ld_info except for the variable-length filename. */
1089 int nonfilesz
= (int)LDI_FILENAME ((LdInfo
*)0, arch64
);
1091 /* Allocated size of buffer. */
1092 int buffer_size
= nonfilesz
;
1093 char *buffer
= xmalloc (buffer_size
);
1094 struct cleanup
*old
= make_cleanup (free_current_contents
, &buffer
);
1096 ldinfo_sec
= bfd_get_section_by_name (core_bfd
, ".ldinfo");
1097 if (ldinfo_sec
== NULL
)
1100 fprintf_filtered (gdb_stderr
, "Couldn't get ldinfo from core file: %s\n",
1101 bfd_errmsg (bfd_get_error ()));
1108 int names_found
= 0;
1110 /* Read in everything but the name. */
1111 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, buffer
,
1112 offset
, nonfilesz
) == 0)
1119 if (i
== buffer_size
)
1122 buffer
= xrealloc (buffer
, buffer_size
);
1124 if (bfd_get_section_contents (core_bfd
, ldinfo_sec
, &buffer
[i
],
1125 offset
+ i
, 1) == 0)
1127 if (buffer
[i
++] == '\0')
1130 while (names_found
< 2);
1132 ldi
= (LdInfo
*) buffer
;
1134 /* Can't use a file descriptor from the core file; need to open it. */
1136 ldi
->l64
.ldinfo_fd
= -1;
1138 ldi
->l32
.ldinfo_fd
= -1;
1140 /* The first ldinfo is for the exec file, allocated elsewhere. */
1141 if (offset
== 0 && vmap
!= NULL
)
1144 vp
= add_vmap (ldi
);
1146 /* Process next shared library upon error. */
1147 offset
+= LDI_NEXT (ldi
, arch64
);
1151 vmap_secs (vp
, ldi
, arch64
);
1153 /* Unless this is the exec file,
1154 add our sections to the section table for the core target. */
1157 struct section_table
*stp
;
1159 target_resize_to_sections (target
, 2);
1160 stp
= target
->to_sections_end
- 2;
1163 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".text");
1164 stp
->addr
= vp
->tstart
;
1165 stp
->endaddr
= vp
->tend
;
1169 stp
->the_bfd_section
= bfd_get_section_by_name (stp
->bfd
, ".data");
1170 stp
->addr
= vp
->dstart
;
1171 stp
->endaddr
= vp
->dend
;
1176 if (vp
!= vmap
&& vp
->objfile
)
1177 observer_notify_new_objfile (vp
->objfile
);
1179 while (LDI_NEXT (ldi
, arch64
) != 0);
1181 breakpoint_re_set ();
1185 /* Under AIX, we have to pass the correct TOC pointer to a function
1186 when calling functions in the inferior.
1187 We try to find the relative toc offset of the objfile containing PC
1188 and add the current load address of the data segment from the vmap. */
1191 find_toc_address (CORE_ADDR pc
)
1194 extern CORE_ADDR
get_toc_offset (struct objfile
*); /* xcoffread.c */
1196 for (vp
= vmap
; vp
; vp
= vp
->nxt
)
1198 if (pc
>= vp
->tstart
&& pc
< vp
->tend
)
1200 /* vp->objfile is only NULL for the exec file. */
1201 return vp
->dstart
+ get_toc_offset (vp
->objfile
== NULL
1206 error (_("Unable to find TOC entry for pc %s."), hex_string (pc
));
1211 _initialize_rs6000_nat (void)
1213 struct target_ops
*t
;
1215 t
= inf_ptrace_target ();
1216 t
->to_fetch_registers
= rs6000_fetch_inferior_registers
;
1217 t
->to_store_registers
= rs6000_store_inferior_registers
;
1218 t
->to_xfer_partial
= rs6000_xfer_partial
;
1220 super_create_inferior
= t
->to_create_inferior
;
1221 t
->to_create_inferior
= rs6000_create_inferior
;
1223 t
->to_wait
= rs6000_wait
;
1227 /* Initialize hook in rs6000-tdep.c for determining the TOC address
1228 when calling functions in the inferior. */
1229 rs6000_find_toc_address_hook
= find_toc_address
;