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 ".reg" core file sections. */
86 struct __context64 r64;
93 /* Union of 32-bit and 64-bit versions of ld_info. */
100 struct __ld_info32 l32;
101 struct __ld_info64 l64;
105 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
106 declare and initialize a variable named VAR suitable for use as the arch64
107 parameter to the various LDI_*() macros. */
110 # define ARCH64_DECL(var)
112 # define ARCH64_DECL(var) int var = ARCH64 ()
115 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
116 otherwise. This technique only works for FIELDs with the same data type in
117 32-bit and 64-bit versions of ld_info. */
120 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
122 # define LDI_FIELD(ldi, arch64, field) \
123 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
126 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
127 process otherwise. */
129 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
130 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
131 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
133 extern struct vmap *map_vmap (bfd * bf, bfd * arch);
135 static void vmap_exec (void);
137 static void vmap_ldinfo (LdInfo *);
139 static struct vmap *add_vmap (LdInfo *);
141 static int objfile_symbol_add (void *);
143 static void vmap_symtab (struct vmap *);
145 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
147 static void exec_one_dummy_insn (void);
149 extern void fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
151 /* Given REGNO, a gdb register number, return the corresponding
152 number suitable for use as a ptrace() parameter. Return -1 if
153 there's no suitable mapping. Also, set the int pointed to by
154 ISFLOAT to indicate whether REGNO is a floating point register. */
157 regmap (int regno, int *isfloat)
159 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
162 if (tdep->ppc_gp0_regnum <= regno
163 && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
165 else if (tdep->ppc_fp0_regnum >= 0
166 && tdep->ppc_fp0_regnum <= regno
167 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
170 return regno - tdep->ppc_fp0_regnum + FPR0;
172 else if (regno == PC_REGNUM)
174 else if (regno == tdep->ppc_ps_regnum)
176 else if (regno == tdep->ppc_cr_regnum)
178 else if (regno == tdep->ppc_lr_regnum)
180 else if (regno == tdep->ppc_ctr_regnum)
182 else if (regno == tdep->ppc_xer_regnum)
184 else if (tdep->ppc_fpscr_regnum >= 0
185 && regno == tdep->ppc_fpscr_regnum)
187 else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
193 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
196 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
198 int ret = ptrace (req, id, (int *)addr, data, buf);
200 printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
201 req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
206 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
209 rs6000_ptrace64 (int req, int id, long long addr, int data, void *buf)
212 int ret = ptracex (req, id, addr, data, buf);
217 printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
218 req, id, addr, data, (unsigned int)buf, ret);
223 /* Fetch register REGNO from the inferior. */
226 fetch_register (int regno)
228 int addr[MAX_REGISTER_SIZE];
231 /* Retrieved values may be -1, so infer errors from errno. */
234 nr = regmap (regno, &isfloat);
236 /* Floating-point registers. */
238 rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
240 /* Bogus register number. */
243 if (regno >= NUM_REGS)
244 fprintf_unfiltered (gdb_stderr,
245 "gdb error: register no %d not implemented.\n",
250 /* Fixed-point registers. */
254 *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (int *)nr, 0, 0);
257 /* PT_READ_GPR requires the buffer parameter to point to long long,
258 even if the register is really only 32 bits. */
260 rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
261 if (register_size (current_gdbarch, regno) == 8)
262 memcpy (addr, &buf, 8);
269 regcache_raw_supply (current_regcache, regno, (char *) addr);
273 /* FIXME: this happens 3 times at the start of each 64-bit program. */
274 perror ("ptrace read");
280 /* Store register REGNO back into the inferior. */
283 store_register (int regno)
285 int addr[MAX_REGISTER_SIZE];
288 /* Fetch the register's value from the register cache. */
289 regcache_raw_collect (current_regcache, regno, addr);
291 /* -1 can be a successful return value, so infer errors from errno. */
294 nr = regmap (regno, &isfloat);
296 /* Floating-point registers. */
298 rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
300 /* Bogus register number. */
303 if (regno >= NUM_REGS)
304 fprintf_unfiltered (gdb_stderr,
305 "gdb error: register no %d not implemented.\n",
309 /* Fixed-point registers. */
312 if (regno == SP_REGNUM)
313 /* Execute one dummy instruction (which is a breakpoint) in inferior
314 process to give kernel a chance to do internal housekeeping.
315 Otherwise the following ptrace(2) calls will mess up user stack
316 since kernel will get confused about the bottom of the stack
318 exec_one_dummy_insn ();
320 /* The PT_WRITE_GPR operation is rather odd. For 32-bit inferiors,
321 the register's value is passed by value, but for 64-bit inferiors,
322 the address of a buffer containing the value is passed. */
324 rs6000_ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid), (int *)nr, *addr, 0);
327 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
328 area, even if the register is really only 32 bits. */
330 if (register_size (current_gdbarch, regno) == 8)
331 memcpy (&buf, addr, 8);
334 rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, &buf);
340 perror ("ptrace write");
345 /* Read from the inferior all registers if REGNO == -1 and just register
349 rs6000_fetch_inferior_registers (int regno)
352 fetch_register (regno);
356 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
358 /* Read 32 general purpose registers. */
359 for (regno = tdep->ppc_gp0_regnum;
360 regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
363 fetch_register (regno);
366 /* Read general purpose floating point registers. */
367 if (tdep->ppc_fp0_regnum >= 0)
368 for (regno = 0; regno < ppc_num_fprs; regno++)
369 fetch_register (tdep->ppc_fp0_regnum + regno);
371 /* Read special registers. */
372 fetch_register (PC_REGNUM);
373 fetch_register (tdep->ppc_ps_regnum);
374 fetch_register (tdep->ppc_cr_regnum);
375 fetch_register (tdep->ppc_lr_regnum);
376 fetch_register (tdep->ppc_ctr_regnum);
377 fetch_register (tdep->ppc_xer_regnum);
378 if (tdep->ppc_fpscr_regnum >= 0)
379 fetch_register (tdep->ppc_fpscr_regnum);
380 if (tdep->ppc_mq_regnum >= 0)
381 fetch_register (tdep->ppc_mq_regnum);
385 /* Store our register values back into the inferior.
386 If REGNO is -1, do this for all registers.
387 Otherwise, REGNO specifies which register (so we can save time). */
390 rs6000_store_inferior_registers (int regno)
393 store_register (regno);
397 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
399 /* Write general purpose registers first. */
400 for (regno = tdep->ppc_gp0_regnum;
401 regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
404 store_register (regno);
407 /* Write floating point registers. */
408 if (tdep->ppc_fp0_regnum >= 0)
409 for (regno = 0; regno < ppc_num_fprs; regno++)
410 store_register (tdep->ppc_fp0_regnum + regno);
412 /* Write special registers. */
413 store_register (PC_REGNUM);
414 store_register (tdep->ppc_ps_regnum);
415 store_register (tdep->ppc_cr_regnum);
416 store_register (tdep->ppc_lr_regnum);
417 store_register (tdep->ppc_ctr_regnum);
418 store_register (tdep->ppc_xer_regnum);
419 if (tdep->ppc_fpscr_regnum >= 0)
420 store_register (tdep->ppc_fpscr_regnum);
421 if (tdep->ppc_mq_regnum >= 0)
422 store_register (tdep->ppc_mq_regnum);
427 /* Attempt a transfer all LEN bytes starting at OFFSET between the
428 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer.
429 Return the number of bytes actually transferred. */
432 rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
433 const char *annex, gdb_byte *readbuf,
434 const gdb_byte *writebuf,
435 ULONGEST offset, LONGEST len)
437 pid_t pid = ptid_get_pid (inferior_ptid);
438 int arch64 = ARCH64 ();
442 case TARGET_OBJECT_MEMORY:
446 PTRACE_TYPE_RET word;
447 gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
449 ULONGEST rounded_offset;
452 /* Round the start offset down to the next long word
454 rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
456 /* Since ptrace will transfer a single word starting at that
457 rounded_offset the partial_len needs to be adjusted down to
458 that (remember this function only does a single transfer).
459 Should the required length be even less, adjust it down
461 partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset;
462 if (partial_len > len)
467 /* If OFFSET:PARTIAL_LEN is smaller than
468 ROUNDED_OFFSET:WORDSIZE then a read/modify write will
469 be needed. Read in the entire word. */
470 if (rounded_offset < offset
471 || (offset + partial_len
472 < rounded_offset + sizeof (PTRACE_TYPE_RET)))
474 /* Need part of initial word -- fetch it. */
476 buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
477 rounded_offset, 0, NULL);
479 buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
480 (int *)(uintptr_t)rounded_offset,
484 /* Copy data to be written over corresponding part of
486 memcpy (buffer.byte + (offset - rounded_offset),
487 writebuf, partial_len);
491 rs6000_ptrace64 (PT_WRITE_D, pid,
492 rounded_offset, buffer.word, NULL);
494 rs6000_ptrace32 (PT_WRITE_D, pid,
495 (int *)(uintptr_t)rounded_offset, buffer.word, NULL);
504 buffer.word = rs6000_ptrace64 (PT_READ_I, pid,
505 rounded_offset, 0, NULL);
507 buffer.word = rs6000_ptrace32 (PT_READ_I, pid,
508 (int *)(uintptr_t)rounded_offset,
513 /* Copy appropriate bytes out of the buffer. */
514 memcpy (readbuf, buffer.byte + (offset - rounded_offset),
526 /* Wait for the child specified by PTID to do something. Return the
527 process ID of the child, or MINUS_ONE_PTID in case of error; store
528 the status in *OURSTATUS. */
531 rs6000_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
534 int status, save_errno;
543 pid = waitpid (ptid_get_pid (ptid), &status, 0);
546 while (pid == -1 && errno == EINTR);
549 clear_sigint_trap ();
553 fprintf_unfiltered (gdb_stderr,
554 _("Child process unexpectedly missing: %s.\n"),
555 safe_strerror (save_errno));
557 /* Claim it exited with unknown signal. */
558 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
559 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
560 return minus_one_ptid;
563 /* Ignore terminated detached child processes. */
564 if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
569 /* AIX has a couple of strange returns from wait(). */
571 /* stop after load" status. */
573 ourstatus->kind = TARGET_WAITKIND_LOADED;
574 /* signal 0. I have no idea why wait(2) returns with this status word. */
575 else if (status == 0x7f)
576 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
577 /* A normal waitstatus. Let the usual macros deal with it. */
579 store_waitstatus (ourstatus, status);
581 return pid_to_ptid (pid);
584 /* Execute one dummy breakpoint instruction. This way we give the kernel
585 a chance to do some housekeeping and update inferior's internal data,
589 exec_one_dummy_insn (void)
591 #define DUMMY_INSN_ADDR gdbarch_tdep (current_gdbarch)->text_segment_base+0x200
593 int ret, status, pid;
597 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
598 assume that this address will never be executed again by the real
601 bp = deprecated_insert_raw_breakpoint (DUMMY_INSN_ADDR);
603 /* You might think this could be done with a single ptrace call, and
604 you'd be correct for just about every platform I've ever worked
605 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
606 the inferior never hits the breakpoint (it's also worth noting
607 powerpc-ibm-aix4.1.3 works correctly). */
608 prev_pc = read_pc ();
609 write_pc (DUMMY_INSN_ADDR);
611 ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
613 ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
616 perror ("pt_continue");
620 pid = wait (&status);
622 while (pid != PIDGET (inferior_ptid));
625 deprecated_remove_raw_breakpoint (bp);
628 /* Fetch registers from the register section in core bfd. */
631 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
632 int which, CORE_ADDR reg_addr)
636 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
642 "Gdb error: unknown parameter to fetch_core_registers().\n");
646 regs = (CoreRegs *) core_reg_sect;
648 /* Put the register values from the core file section in the regcache. */
652 for (regi = 0; regi < ppc_num_gprs; regi++)
653 regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
654 (char *) ®s->r64.gpr[regi]);
656 if (tdep->ppc_fp0_regnum >= 0)
657 for (regi = 0; regi < ppc_num_fprs; regi++)
658 regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
659 (char *) ®s->r64.fpr[regi]);
661 regcache_raw_supply (current_regcache, PC_REGNUM,
662 (char *) ®s->r64.iar);
663 regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
664 (char *) ®s->r64.msr);
665 regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
666 (char *) ®s->r64.cr);
667 regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
668 (char *) ®s->r64.lr);
669 regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
670 (char *) ®s->r64.ctr);
671 regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
672 (char *) ®s->r64.xer);
673 if (tdep->ppc_fpscr_regnum >= 0)
674 regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
675 (char *) ®s->r64.fpscr);
679 for (regi = 0; regi < ppc_num_gprs; regi++)
680 regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
681 (char *) ®s->r32.gpr[regi]);
683 if (tdep->ppc_fp0_regnum >= 0)
684 for (regi = 0; regi < ppc_num_fprs; regi++)
685 regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
686 (char *) ®s->r32.fpr[regi]);
688 regcache_raw_supply (current_regcache, PC_REGNUM,
689 (char *) ®s->r32.iar);
690 regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
691 (char *) ®s->r32.msr);
692 regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
693 (char *) ®s->r32.cr);
694 regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
695 (char *) ®s->r32.lr);
696 regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
697 (char *) ®s->r32.ctr);
698 regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
699 (char *) ®s->r32.xer);
700 if (tdep->ppc_fpscr_regnum >= 0)
701 regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
702 (char *) ®s->r32.fpscr);
703 if (tdep->ppc_mq_regnum >= 0)
704 regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum,
705 (char *) ®s->r32.mq);
710 /* Copy information about text and data sections from LDI to VP for a 64-bit
711 process if ARCH64 and for a 32-bit process otherwise. */
714 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
718 vp->tstart = (CORE_ADDR) ldi->l64.ldinfo_textorg;
719 vp->tend = vp->tstart + ldi->l64.ldinfo_textsize;
720 vp->dstart = (CORE_ADDR) ldi->l64.ldinfo_dataorg;
721 vp->dend = vp->dstart + ldi->l64.ldinfo_datasize;
725 vp->tstart = (unsigned long) ldi->l32.ldinfo_textorg;
726 vp->tend = vp->tstart + ldi->l32.ldinfo_textsize;
727 vp->dstart = (unsigned long) ldi->l32.ldinfo_dataorg;
728 vp->dend = vp->dstart + ldi->l32.ldinfo_datasize;
731 /* The run time loader maps the file header in addition to the text
732 section and returns a pointer to the header in ldinfo_textorg.
733 Adjust the text start address to point to the real start address
734 of the text section. */
735 vp->tstart += vp->toffs;
738 /* handle symbol translation on vmapping */
741 vmap_symtab (struct vmap *vp)
743 struct objfile *objfile;
744 struct section_offsets *new_offsets;
747 objfile = vp->objfile;
750 /* OK, it's not an objfile we opened ourselves.
751 Currently, that can only happen with the exec file, so
752 relocate the symbols for the symfile. */
753 if (symfile_objfile == NULL)
755 objfile = symfile_objfile;
757 else if (!vp->loaded)
758 /* If symbols are not yet loaded, offsets are not yet valid. */
762 (struct section_offsets *)
763 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
765 for (i = 0; i < objfile->num_sections; ++i)
766 new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
768 /* The symbols in the object file are linked to the VMA of the section,
769 relocate them VMA relative. */
770 new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
771 new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
772 new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;
774 objfile_relocate (objfile, new_offsets);
777 /* Add symbols for an objfile. */
780 objfile_symbol_add (void *arg)
782 struct objfile *obj = (struct objfile *) arg;
784 syms_from_objfile (obj, NULL, 0, 0, 0, 0);
785 new_symfile_objfile (obj, 0, 0);
789 /* Add symbols for a vmap. Return zero upon error. */
792 vmap_add_symbols (struct vmap *vp)
794 if (catch_errors (objfile_symbol_add, vp->objfile,
795 "Error while reading shared library symbols:\n",
798 /* Note this is only done if symbol reading was successful. */
806 /* Add a new vmap entry based on ldinfo() information.
808 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
809 core file), the caller should set it to -1, and we will open the file.
811 Return the vmap new entry. */
814 add_vmap (LdInfo *ldi)
817 char *mem, *objname, *filename;
821 ARCH64_DECL (arch64);
823 /* This ldi structure was allocated using alloca() in
824 xcoff_relocate_symtab(). Now we need to have persistent object
825 and member names, so we should save them. */
827 filename = LDI_FILENAME (ldi, arch64);
828 mem = filename + strlen (filename) + 1;
829 mem = savestring (mem, strlen (mem));
830 objname = savestring (filename, strlen (filename));
832 fd = LDI_FD (ldi, arch64);
834 /* Note that this opens it once for every member; a possible
835 enhancement would be to only open it once for every object. */
836 abfd = bfd_openr (objname, gnutarget);
838 abfd = bfd_fdopenr (objname, gnutarget, fd);
841 warning (_("Could not open `%s' as an executable file: %s"),
842 objname, bfd_errmsg (bfd_get_error ()));
846 /* make sure we have an object file */
848 if (bfd_check_format (abfd, bfd_object))
849 vp = map_vmap (abfd, 0);
851 else if (bfd_check_format (abfd, bfd_archive))
854 /* FIXME??? am I tossing BFDs? bfd? */
855 while ((last = bfd_openr_next_archived_file (abfd, last)))
856 if (DEPRECATED_STREQ (mem, last->filename))
861 warning (_("\"%s\": member \"%s\" missing."), objname, mem);
866 if (!bfd_check_format (last, bfd_object))
868 warning (_("\"%s\": member \"%s\" not in executable format: %s."),
869 objname, mem, bfd_errmsg (bfd_get_error ()));
875 vp = map_vmap (last, abfd);
879 warning (_("\"%s\": not in executable format: %s."),
880 objname, bfd_errmsg (bfd_get_error ()));
884 obj = allocate_objfile (vp->bfd, 0);
887 /* Always add symbols for the main objfile. */
888 if (vp == vmap || auto_solib_add)
889 vmap_add_symbols (vp);
893 /* update VMAP info with ldinfo() information
894 Input is ptr to ldinfo() results. */
897 vmap_ldinfo (LdInfo *ldi)
901 int got_one, retried;
902 int got_exec_file = 0;
904 int arch64 = ARCH64 ();
906 /* For each *ldi, see if we have a corresponding *vp.
907 If so, update the mapping, and symbol table.
908 If not, add an entry and symbol table. */
912 char *name = LDI_FILENAME (ldi, arch64);
913 char *memb = name + strlen (name) + 1;
914 int fd = LDI_FD (ldi, arch64);
918 if (fstat (fd, &ii) < 0)
920 /* The kernel sets ld_info to -1, if the process is still using the
921 object, and the object is removed. Keep the symbol info for the
922 removed object and issue a warning. */
923 warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
928 for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
930 struct objfile *objfile;
932 /* First try to find a `vp', which is the same as in ldinfo.
933 If not the same, just continue and grep the next `vp'. If same,
934 relocate its tstart, tend, dstart, dend values. If no such `vp'
935 found, get out of this for loop, add this ldi entry as a new vmap
936 (add_vmap) and come back, find its `vp' and so on... */
938 /* The filenames are not always sufficient to match on. */
940 if ((name[0] == '/' && !DEPRECATED_STREQ (name, vp->name))
941 || (memb[0] && !DEPRECATED_STREQ (memb, vp->member)))
944 /* See if we are referring to the same file.
945 We have to check objfile->obfd, symfile.c:reread_symbols might
946 have updated the obfd after a change. */
947 objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
949 || objfile->obfd == NULL
950 || bfd_stat (objfile->obfd, &vi) < 0)
952 warning (_("Unable to stat %s, keeping its symbols"), name);
956 if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
964 /* Found a corresponding VMAP. Remap! */
966 vmap_secs (vp, ldi, arch64);
968 /* The objfile is only NULL for the exec file. */
969 if (vp->objfile == NULL)
972 /* relocate symbol table(s). */
975 /* Announce new object files. Doing this after symbol relocation
976 makes aix-thread.c's job easier. */
977 if (deprecated_target_new_objfile_hook && vp->objfile)
978 deprecated_target_new_objfile_hook (vp->objfile);
980 /* There may be more, so we don't break out of the loop. */
983 /* if there was no matching *vp, we must perforce create the sucker(s) */
984 if (!got_one && !retried)
991 while ((next = LDI_NEXT (ldi, arch64))
992 && (ldi = (void *) (next + (char *) ldi)));
994 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
995 is unlikely that the symbol file is relocated to the proper
996 address. And we might have attached to a process which is
997 running a different copy of the same executable. */
998 if (symfile_objfile != NULL && !got_exec_file)
1000 warning (_("Symbol file %s\nis not mapped; discarding it.\n\
1001 If in fact that file has symbols which the mapped files listed by\n\
1002 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
1003 \"add-symbol-file\" commands (note that you must take care of relocating\n\
1004 symbols to the proper address)."),
1005 symfile_objfile->name);
1006 free_objfile (symfile_objfile);
1007 symfile_objfile = NULL;
1009 breakpoint_re_set ();
1012 /* As well as symbol tables, exec_sections need relocation. After
1013 the inferior process' termination, there will be a relocated symbol
1014 table exist with no corresponding inferior process. At that time, we
1015 need to use `exec' bfd, rather than the inferior process's memory space
1018 `exec_sections' need to be relocated only once, as long as the exec
1019 file remains unchanged.
1025 static bfd *execbfd;
1028 if (execbfd == exec_bfd)
1033 if (!vmap || !exec_ops.to_sections)
1034 error (_("vmap_exec: vmap or exec_ops.to_sections == 0."));
1036 for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
1038 if (DEPRECATED_STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
1040 exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
1041 exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
1043 else if (DEPRECATED_STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
1045 exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
1046 exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
1048 else if (DEPRECATED_STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
1050 exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
1051 exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
1056 /* Set the current architecture from the host running GDB. Called when
1057 starting a child process. */
1059 static void (*super_create_inferior) (char *exec_file, char *allargs,
1060 char **env, int from_tty);
1062 rs6000_create_inferior (char *exec_file, char *allargs, char **env, int from_tty)
1064 enum bfd_architecture arch;
1067 struct gdbarch_info info;
1069 super_create_inferior (exec_file, allargs, env, from_tty);
1073 arch = bfd_arch_rs6000;
1074 mach = bfd_mach_rs6k;
1078 arch = bfd_arch_powerpc;
1079 mach = bfd_mach_ppc;
1082 /* FIXME: schauer/2002-02-25:
1083 We don't know if we are executing a 32 or 64 bit executable,
1084 and have no way to pass the proper word size to rs6000_gdbarch_init.
1085 So we have to avoid switching to a new architecture, if the architecture
1087 Blindly calling rs6000_gdbarch_init used to work in older versions of
1088 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
1089 determine the wordsize. */
1092 const struct bfd_arch_info *exec_bfd_arch_info;
1094 exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
1095 if (arch == exec_bfd_arch_info->arch)
1099 bfd_default_set_arch_mach (&abfd, arch, mach);
1101 gdbarch_info_init (&info);
1102 info.bfd_arch_info = bfd_get_arch_info (&abfd);
1103 info.abfd = exec_bfd;
1105 if (!gdbarch_update_p (info))
1106 internal_error (__FILE__, __LINE__,
1107 _("rs6000_create_inferior: failed to select architecture"));
1111 /* xcoff_relocate_symtab - hook for symbol table relocation.
1112 also reads shared libraries. */
1115 xcoff_relocate_symtab (unsigned int pid)
1117 int load_segs = 64; /* number of load segments */
1120 int arch64 = ARCH64 ();
1121 int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
1126 size = load_segs * ldisize;
1127 ldi = (void *) xrealloc (ldi, size);
1130 /* According to my humble theory, AIX has some timing problems and
1131 when the user stack grows, kernel doesn't update stack info in time
1132 and ptrace calls step on user stack. That is why we sleep here a
1133 little, and give kernel to update its internals. */
1138 rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
1140 rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
1144 if (errno == ENOMEM)
1147 perror_with_name (_("ptrace ldinfo"));
1152 vmap_exec (); /* relocate the exec and core sections as well. */
1159 /* Core file stuff. */
1161 /* Relocate symtabs and read in shared library info, based on symbols
1162 from the core file. */
1165 xcoff_relocate_core (struct target_ops *target)
1167 struct bfd_section *ldinfo_sec;
1171 int arch64 = ARCH64 ();
1173 /* Size of a struct ld_info except for the variable-length filename. */
1174 int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1176 /* Allocated size of buffer. */
1177 int buffer_size = nonfilesz;
1178 char *buffer = xmalloc (buffer_size);
1179 struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1181 ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1182 if (ldinfo_sec == NULL)
1185 fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1186 bfd_errmsg (bfd_get_error ()));
1193 int names_found = 0;
1195 /* Read in everything but the name. */
1196 if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1197 offset, nonfilesz) == 0)
1204 if (i == buffer_size)
1207 buffer = xrealloc (buffer, buffer_size);
1209 if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1210 offset + i, 1) == 0)
1212 if (buffer[i++] == '\0')
1215 while (names_found < 2);
1217 ldi = (LdInfo *) buffer;
1219 /* Can't use a file descriptor from the core file; need to open it. */
1221 ldi->l64.ldinfo_fd = -1;
1223 ldi->l32.ldinfo_fd = -1;
1225 /* The first ldinfo is for the exec file, allocated elsewhere. */
1226 if (offset == 0 && vmap != NULL)
1229 vp = add_vmap (ldi);
1231 /* Process next shared library upon error. */
1232 offset += LDI_NEXT (ldi, arch64);
1236 vmap_secs (vp, ldi, arch64);
1238 /* Unless this is the exec file,
1239 add our sections to the section table for the core target. */
1242 struct section_table *stp;
1244 target_resize_to_sections (target, 2);
1245 stp = target->to_sections_end - 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 (deprecated_target_new_objfile_hook && vp != vmap && vp->objfile)
1262 deprecated_target_new_objfile_hook (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)
1279 extern CORE_ADDR get_toc_offset (struct objfile *); /* xcoffread.c */
1281 for (vp = vmap; vp; vp = vp->nxt)
1283 if (pc >= vp->tstart && pc < vp->tend)
1285 /* vp->objfile is only NULL for the exec file. */
1286 return vp->dstart + get_toc_offset (vp->objfile == NULL
1291 error (_("Unable to find TOC entry for pc %s."), hex_string (pc));
1294 /* Register that we are able to handle rs6000 core file formats. */
1296 static struct core_fns rs6000_core_fns =
1298 bfd_target_xcoff_flavour, /* core_flavour */
1299 default_check_format, /* check_format */
1300 default_core_sniffer, /* core_sniffer */
1301 fetch_core_registers, /* core_read_registers */
1306 _initialize_core_rs6000 (void)
1308 struct target_ops *t;
1310 t = inf_ptrace_target ();
1311 t->to_fetch_registers = rs6000_fetch_inferior_registers;
1312 t->to_store_registers = rs6000_store_inferior_registers;
1313 t->to_xfer_partial = rs6000_xfer_partial;
1315 super_create_inferior = t->to_create_inferior;
1316 t->to_create_inferior = rs6000_create_inferior;
1318 t->to_wait = rs6000_wait;
1322 /* Initialize hook in rs6000-tdep.c for determining the TOC address
1323 when calling functions in the inferior. */
1324 rs6000_find_toc_address_hook = find_toc_address;
1326 deprecated_add_core_fns (&rs6000_core_fns);