1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
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"
40 #include <sys/ptrace.h>
43 #include <sys/param.h>
47 #include <sys/ioctl.h>
55 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
56 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
58 #include <sys/systemcfg.h>
60 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
61 debugging 32-bit and 64-bit processes. Define a typedef and macros for
62 accessing fields in the appropriate structures. */
64 /* In 32-bit compilation mode (which is the only mode from which ptrace()
65 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
71 /* Return whether the current architecture is 64-bit. */
76 # define ARCH64() (register_size (current_gdbarch, 0) == 8)
79 /* Union of 32-bit and 64-bit ".reg" core file sections. */
83 struct __context64 r64;
90 /* Union of 32-bit and 64-bit versions of ld_info. */
97 struct __ld_info32 l32;
98 struct __ld_info64 l64;
102 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
103 declare and initialize a variable named VAR suitable for use as the arch64
104 parameter to the various LDI_*() macros. */
107 # define ARCH64_DECL(var)
109 # define ARCH64_DECL(var) int var = ARCH64 ()
112 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
113 otherwise. This technique only works for FIELDs with the same data type in
114 32-bit and 64-bit versions of ld_info. */
117 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
119 # define LDI_FIELD(ldi, arch64, field) \
120 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
123 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
124 process otherwise. */
126 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
127 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
128 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
130 extern struct vmap *map_vmap (bfd * bf, bfd * arch);
132 static void vmap_exec (void);
134 static void vmap_ldinfo (LdInfo *);
136 static struct vmap *add_vmap (LdInfo *);
138 static int objfile_symbol_add (void *);
140 static void vmap_symtab (struct vmap *);
142 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
144 static void exec_one_dummy_insn (void);
146 extern void fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
148 /* Given REGNO, a gdb register number, return the corresponding
149 number suitable for use as a ptrace() parameter. Return -1 if
150 there's no suitable mapping. Also, set the int pointed to by
151 ISFLOAT to indicate whether REGNO is a floating point register. */
154 regmap (int regno, int *isfloat)
156 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
159 if (tdep->ppc_gp0_regnum <= regno
160 && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)
162 else if (tdep->ppc_fp0_regnum >= 0
163 && tdep->ppc_fp0_regnum <= regno
164 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)
167 return regno - tdep->ppc_fp0_regnum + FPR0;
169 else if (regno == PC_REGNUM)
171 else if (regno == tdep->ppc_ps_regnum)
173 else if (regno == tdep->ppc_cr_regnum)
175 else if (regno == tdep->ppc_lr_regnum)
177 else if (regno == tdep->ppc_ctr_regnum)
179 else if (regno == tdep->ppc_xer_regnum)
181 else if (tdep->ppc_fpscr_regnum >= 0
182 && regno == tdep->ppc_fpscr_regnum)
184 else if (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum)
190 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
193 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
195 int ret = ptrace (req, id, (int *)addr, data, buf);
197 printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
198 req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
203 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
206 rs6000_ptrace64 (int req, int id, long long addr, int data, int *buf)
209 int ret = ptracex (req, id, addr, data, buf);
214 printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
215 req, id, addr, data, (unsigned int)buf, ret);
220 /* Fetch register REGNO from the inferior. */
223 fetch_register (int regno)
225 int addr[MAX_REGISTER_SIZE];
228 /* Retrieved values may be -1, so infer errors from errno. */
231 nr = regmap (regno, &isfloat);
233 /* Floating-point registers. */
235 rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
237 /* Bogus register number. */
240 if (regno >= NUM_REGS)
241 fprintf_unfiltered (gdb_stderr,
242 "gdb error: register no %d not implemented.\n",
247 /* Fixed-point registers. */
251 *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (int *)nr, 0, 0);
254 /* PT_READ_GPR requires the buffer parameter to point to long long,
255 even if the register is really only 32 bits. */
257 rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
258 if (register_size (current_gdbarch, regno) == 8)
259 memcpy (addr, &buf, 8);
266 regcache_raw_supply (current_regcache, regno, (char *) addr);
270 /* FIXME: this happens 3 times at the start of each 64-bit program. */
271 perror ("ptrace read");
277 /* Store register REGNO back into the inferior. */
280 store_register (int regno)
282 int addr[MAX_REGISTER_SIZE];
285 /* Fetch the register's value from the register cache. */
286 regcache_raw_collect (current_regcache, regno, addr);
288 /* -1 can be a successful return value, so infer errors from errno. */
291 nr = regmap (regno, &isfloat);
293 /* Floating-point registers. */
295 rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
297 /* Bogus register number. */
300 if (regno >= NUM_REGS)
301 fprintf_unfiltered (gdb_stderr,
302 "gdb error: register no %d not implemented.\n",
306 /* Fixed-point registers. */
309 if (regno == SP_REGNUM)
310 /* Execute one dummy instruction (which is a breakpoint) in inferior
311 process to give kernel a chance to do internal housekeeping.
312 Otherwise the following ptrace(2) calls will mess up user stack
313 since kernel will get confused about the bottom of the stack
315 exec_one_dummy_insn ();
317 /* The PT_WRITE_GPR operation is rather odd. For 32-bit inferiors,
318 the register's value is passed by value, but for 64-bit inferiors,
319 the address of a buffer containing the value is passed. */
321 rs6000_ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid), (int *)nr, *addr, 0);
324 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
325 area, even if the register is really only 32 bits. */
327 if (register_size (current_gdbarch, regno) == 8)
328 memcpy (&buf, addr, 8);
331 rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
337 perror ("ptrace write");
342 /* Read from the inferior all registers if REGNO == -1 and just register
346 fetch_inferior_registers (int regno)
349 fetch_register (regno);
353 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
355 /* Read 32 general purpose registers. */
356 for (regno = tdep->ppc_gp0_regnum;
357 regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
360 fetch_register (regno);
363 /* Read general purpose floating point registers. */
364 if (tdep->ppc_fp0_regnum >= 0)
365 for (regno = 0; regno < ppc_num_fprs; regno++)
366 fetch_register (tdep->ppc_fp0_regnum + regno);
368 /* Read special registers. */
369 fetch_register (PC_REGNUM);
370 fetch_register (tdep->ppc_ps_regnum);
371 fetch_register (tdep->ppc_cr_regnum);
372 fetch_register (tdep->ppc_lr_regnum);
373 fetch_register (tdep->ppc_ctr_regnum);
374 fetch_register (tdep->ppc_xer_regnum);
375 if (tdep->ppc_fpscr_regnum >= 0)
376 fetch_register (tdep->ppc_fpscr_regnum);
377 if (tdep->ppc_mq_regnum >= 0)
378 fetch_register (tdep->ppc_mq_regnum);
382 /* Store our register values back into the inferior.
383 If REGNO is -1, do this for all registers.
384 Otherwise, REGNO specifies which register (so we can save time). */
387 store_inferior_registers (int regno)
390 store_register (regno);
394 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
396 /* Write general purpose registers first. */
397 for (regno = tdep->ppc_gp0_regnum;
398 regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
401 store_register (regno);
404 /* Write floating point registers. */
405 if (tdep->ppc_fp0_regnum >= 0)
406 for (regno = 0; regno < ppc_num_fprs; regno++)
407 store_register (tdep->ppc_fp0_regnum + regno);
409 /* Write special registers. */
410 store_register (PC_REGNUM);
411 store_register (tdep->ppc_ps_regnum);
412 store_register (tdep->ppc_cr_regnum);
413 store_register (tdep->ppc_lr_regnum);
414 store_register (tdep->ppc_ctr_regnum);
415 store_register (tdep->ppc_xer_regnum);
416 if (tdep->ppc_fpscr_regnum >= 0)
417 store_register (tdep->ppc_fpscr_regnum);
418 if (tdep->ppc_mq_regnum >= 0)
419 store_register (tdep->ppc_mq_regnum);
423 /* Store in *TO the 32-bit word at 32-bit-aligned ADDR in the child
424 process, which is 64-bit if ARCH64 and 32-bit otherwise. Return
428 read_word (CORE_ADDR from, int *to, int arch64)
430 /* Retrieved values may be -1, so infer errors from errno. */
434 *to = rs6000_ptrace64 (PT_READ_I, PIDGET (inferior_ptid), from, 0, NULL);
436 *to = rs6000_ptrace32 (PT_READ_I, PIDGET (inferior_ptid), (int *)(long) from,
442 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
443 to debugger memory starting at MYADDR. Copy to inferior if
446 Returns the length copied, which is either the LEN argument or
447 zero. This xfer function does not do partial moves, since
448 deprecated_child_ops doesn't allow memory operations to cross below
449 us in the target stack anyway. */
452 child_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
453 int write, struct mem_attrib *attrib,
454 struct target_ops *target)
456 /* Round starting address down to 32-bit word boundary. */
457 int mask = sizeof (int) - 1;
458 CORE_ADDR addr = memaddr & ~(CORE_ADDR)mask;
460 /* Round ending address up to 32-bit word boundary. */
461 int count = ((memaddr + len - addr + mask) & ~(CORE_ADDR)mask)
464 /* Allocate word transfer buffer. */
465 /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
466 because it uses alloca to allocate a buffer of arbitrary size.
467 For very large xfers, this could crash GDB's stack. */
468 int *buf = (int *) alloca (count * sizeof (int));
470 int arch64 = ARCH64 ();
475 /* Retrieve memory a word at a time. */
476 for (i = 0; i < count; i++, addr += sizeof (int))
478 if (!read_word (addr, buf + i, arch64))
483 /* Copy memory to supplied buffer. */
484 addr -= count * sizeof (int);
485 memcpy (myaddr, (char *)buf + (memaddr - addr), len);
489 /* Fetch leading memory needed for alignment. */
491 if (!read_word (addr, buf, arch64))
494 /* Fetch trailing memory needed for alignment. */
495 if (addr + count * sizeof (int) > memaddr + len)
496 if (!read_word (addr + (count - 1) * sizeof (int),
497 buf + count - 1, arch64))
500 /* Copy supplied data into memory buffer. */
501 memcpy ((char *)buf + (memaddr - addr), myaddr, len);
503 /* Store memory one word at a time. */
504 for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
507 rs6000_ptrace64 (PT_WRITE_D, PIDGET (inferior_ptid), addr, buf[i], NULL);
509 rs6000_ptrace32 (PT_WRITE_D, PIDGET (inferior_ptid), (int *)(long) addr,
521 /* Execute one dummy breakpoint instruction. This way we give the kernel
522 a chance to do some housekeeping and update inferior's internal data,
526 exec_one_dummy_insn (void)
528 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
530 char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
531 int ret, status, pid;
534 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
535 assume that this address will never be executed again by the real
538 target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
540 /* You might think this could be done with a single ptrace call, and
541 you'd be correct for just about every platform I've ever worked
542 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
543 the inferior never hits the breakpoint (it's also worth noting
544 powerpc-ibm-aix4.1.3 works correctly). */
545 prev_pc = read_pc ();
546 write_pc (DUMMY_INSN_ADDR);
548 ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
550 ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
553 perror ("pt_continue");
557 pid = wait (&status);
559 while (pid != PIDGET (inferior_ptid));
562 target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
565 /* Fetch registers from the register section in core bfd. */
568 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
569 int which, CORE_ADDR reg_addr)
573 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
579 "Gdb error: unknown parameter to fetch_core_registers().\n");
583 regs = (CoreRegs *) core_reg_sect;
585 /* Put the register values from the core file section in the regcache. */
589 for (regi = 0; regi < ppc_num_gprs; regi++)
590 regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
591 (char *) ®s->r64.gpr[regi]);
593 if (tdep->ppc_fp0_regnum >= 0)
594 for (regi = 0; regi < ppc_num_fprs; regi++)
595 regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
596 (char *) ®s->r64.fpr[regi]);
598 regcache_raw_supply (current_regcache, PC_REGNUM,
599 (char *) ®s->r64.iar);
600 regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
601 (char *) ®s->r64.msr);
602 regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
603 (char *) ®s->r64.cr);
604 regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
605 (char *) ®s->r64.lr);
606 regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
607 (char *) ®s->r64.ctr);
608 regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
609 (char *) ®s->r64.xer);
610 if (tdep->ppc_fpscr_regnum >= 0)
611 regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
612 (char *) ®s->r64.fpscr);
616 for (regi = 0; regi < ppc_num_gprs; regi++)
617 regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
618 (char *) ®s->r32.gpr[regi]);
620 if (tdep->ppc_fp0_regnum >= 0)
621 for (regi = 0; regi < ppc_num_fprs; regi++)
622 regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
623 (char *) ®s->r32.fpr[regi]);
625 regcache_raw_supply (current_regcache, PC_REGNUM,
626 (char *) ®s->r32.iar);
627 regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
628 (char *) ®s->r32.msr);
629 regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
630 (char *) ®s->r32.cr);
631 regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
632 (char *) ®s->r32.lr);
633 regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
634 (char *) ®s->r32.ctr);
635 regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
636 (char *) ®s->r32.xer);
637 if (tdep->ppc_fpscr_regnum >= 0)
638 regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
639 (char *) ®s->r32.fpscr);
640 if (tdep->ppc_mq_regnum >= 0)
641 regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum,
642 (char *) ®s->r32.mq);
647 /* Copy information about text and data sections from LDI to VP for a 64-bit
648 process if ARCH64 and for a 32-bit process otherwise. */
651 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
655 vp->tstart = (CORE_ADDR) ldi->l64.ldinfo_textorg;
656 vp->tend = vp->tstart + ldi->l64.ldinfo_textsize;
657 vp->dstart = (CORE_ADDR) ldi->l64.ldinfo_dataorg;
658 vp->dend = vp->dstart + ldi->l64.ldinfo_datasize;
662 vp->tstart = (unsigned long) ldi->l32.ldinfo_textorg;
663 vp->tend = vp->tstart + ldi->l32.ldinfo_textsize;
664 vp->dstart = (unsigned long) ldi->l32.ldinfo_dataorg;
665 vp->dend = vp->dstart + ldi->l32.ldinfo_datasize;
668 /* The run time loader maps the file header in addition to the text
669 section and returns a pointer to the header in ldinfo_textorg.
670 Adjust the text start address to point to the real start address
671 of the text section. */
672 vp->tstart += vp->toffs;
675 /* handle symbol translation on vmapping */
678 vmap_symtab (struct vmap *vp)
680 struct objfile *objfile;
681 struct section_offsets *new_offsets;
684 objfile = vp->objfile;
687 /* OK, it's not an objfile we opened ourselves.
688 Currently, that can only happen with the exec file, so
689 relocate the symbols for the symfile. */
690 if (symfile_objfile == NULL)
692 objfile = symfile_objfile;
694 else if (!vp->loaded)
695 /* If symbols are not yet loaded, offsets are not yet valid. */
699 (struct section_offsets *)
700 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
702 for (i = 0; i < objfile->num_sections; ++i)
703 new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
705 /* The symbols in the object file are linked to the VMA of the section,
706 relocate them VMA relative. */
707 new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
708 new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
709 new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;
711 objfile_relocate (objfile, new_offsets);
714 /* Add symbols for an objfile. */
717 objfile_symbol_add (void *arg)
719 struct objfile *obj = (struct objfile *) arg;
721 syms_from_objfile (obj, NULL, 0, 0, 0, 0);
722 new_symfile_objfile (obj, 0, 0);
726 /* Add symbols for a vmap. Return zero upon error. */
729 vmap_add_symbols (struct vmap *vp)
731 if (catch_errors (objfile_symbol_add, vp->objfile,
732 "Error while reading shared library symbols:\n",
735 /* Note this is only done if symbol reading was successful. */
743 /* Add a new vmap entry based on ldinfo() information.
745 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
746 core file), the caller should set it to -1, and we will open the file.
748 Return the vmap new entry. */
751 add_vmap (LdInfo *ldi)
754 char *mem, *objname, *filename;
758 ARCH64_DECL (arch64);
760 /* This ldi structure was allocated using alloca() in
761 xcoff_relocate_symtab(). Now we need to have persistent object
762 and member names, so we should save them. */
764 filename = LDI_FILENAME (ldi, arch64);
765 mem = filename + strlen (filename) + 1;
766 mem = savestring (mem, strlen (mem));
767 objname = savestring (filename, strlen (filename));
769 fd = LDI_FD (ldi, arch64);
771 /* Note that this opens it once for every member; a possible
772 enhancement would be to only open it once for every object. */
773 abfd = bfd_openr (objname, gnutarget);
775 abfd = bfd_fdopenr (objname, gnutarget, fd);
778 warning (_("Could not open `%s' as an executable file: %s"),
779 objname, bfd_errmsg (bfd_get_error ()));
783 /* make sure we have an object file */
785 if (bfd_check_format (abfd, bfd_object))
786 vp = map_vmap (abfd, 0);
788 else if (bfd_check_format (abfd, bfd_archive))
791 /* FIXME??? am I tossing BFDs? bfd? */
792 while ((last = bfd_openr_next_archived_file (abfd, last)))
793 if (DEPRECATED_STREQ (mem, last->filename))
798 warning (_("\"%s\": member \"%s\" missing."), objname, mem);
803 if (!bfd_check_format (last, bfd_object))
805 warning (_("\"%s\": member \"%s\" not in executable format: %s."),
806 objname, mem, bfd_errmsg (bfd_get_error ()));
812 vp = map_vmap (last, abfd);
816 warning (_("\"%s\": not in executable format: %s."),
817 objname, bfd_errmsg (bfd_get_error ()));
821 obj = allocate_objfile (vp->bfd, 0);
824 /* Always add symbols for the main objfile. */
825 if (vp == vmap || auto_solib_add)
826 vmap_add_symbols (vp);
830 /* update VMAP info with ldinfo() information
831 Input is ptr to ldinfo() results. */
834 vmap_ldinfo (LdInfo *ldi)
838 int got_one, retried;
839 int got_exec_file = 0;
841 int arch64 = ARCH64 ();
843 /* For each *ldi, see if we have a corresponding *vp.
844 If so, update the mapping, and symbol table.
845 If not, add an entry and symbol table. */
849 char *name = LDI_FILENAME (ldi, arch64);
850 char *memb = name + strlen (name) + 1;
851 int fd = LDI_FD (ldi, arch64);
855 if (fstat (fd, &ii) < 0)
857 /* The kernel sets ld_info to -1, if the process is still using the
858 object, and the object is removed. Keep the symbol info for the
859 removed object and issue a warning. */
860 warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
865 for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
867 struct objfile *objfile;
869 /* First try to find a `vp', which is the same as in ldinfo.
870 If not the same, just continue and grep the next `vp'. If same,
871 relocate its tstart, tend, dstart, dend values. If no such `vp'
872 found, get out of this for loop, add this ldi entry as a new vmap
873 (add_vmap) and come back, find its `vp' and so on... */
875 /* The filenames are not always sufficient to match on. */
877 if ((name[0] == '/' && !DEPRECATED_STREQ (name, vp->name))
878 || (memb[0] && !DEPRECATED_STREQ (memb, vp->member)))
881 /* See if we are referring to the same file.
882 We have to check objfile->obfd, symfile.c:reread_symbols might
883 have updated the obfd after a change. */
884 objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
886 || objfile->obfd == NULL
887 || bfd_stat (objfile->obfd, &vi) < 0)
889 warning (_("Unable to stat %s, keeping its symbols"), name);
893 if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
901 /* Found a corresponding VMAP. Remap! */
903 vmap_secs (vp, ldi, arch64);
905 /* The objfile is only NULL for the exec file. */
906 if (vp->objfile == NULL)
909 /* relocate symbol table(s). */
912 /* Announce new object files. Doing this after symbol relocation
913 makes aix-thread.c's job easier. */
914 if (deprecated_target_new_objfile_hook && vp->objfile)
915 deprecated_target_new_objfile_hook (vp->objfile);
917 /* There may be more, so we don't break out of the loop. */
920 /* if there was no matching *vp, we must perforce create the sucker(s) */
921 if (!got_one && !retried)
928 while ((next = LDI_NEXT (ldi, arch64))
929 && (ldi = (void *) (next + (char *) ldi)));
931 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
932 is unlikely that the symbol file is relocated to the proper
933 address. And we might have attached to a process which is
934 running a different copy of the same executable. */
935 if (symfile_objfile != NULL && !got_exec_file)
937 warning (_("Symbol file %s\nis not mapped; discarding it.\n\
938 If in fact that file has symbols which the mapped files listed by\n\
939 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
940 \"add-symbol-file\" commands (note that you must take care of relocating\n\
941 symbols to the proper address)."),
942 symfile_objfile->name);
943 free_objfile (symfile_objfile);
944 symfile_objfile = NULL;
946 breakpoint_re_set ();
949 /* As well as symbol tables, exec_sections need relocation. After
950 the inferior process' termination, there will be a relocated symbol
951 table exist with no corresponding inferior process. At that time, we
952 need to use `exec' bfd, rather than the inferior process's memory space
955 `exec_sections' need to be relocated only once, as long as the exec
956 file remains unchanged.
965 if (execbfd == exec_bfd)
970 if (!vmap || !exec_ops.to_sections)
971 error (_("vmap_exec: vmap or exec_ops.to_sections == 0."));
973 for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
975 if (DEPRECATED_STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
977 exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
978 exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
980 else if (DEPRECATED_STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
982 exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
983 exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
985 else if (DEPRECATED_STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
987 exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
988 exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
993 /* Set the current architecture from the host running GDB. Called when
994 starting a child process. */
997 set_host_arch (int pid)
999 enum bfd_architecture arch;
1002 struct gdbarch_info info;
1006 arch = bfd_arch_rs6000;
1007 mach = bfd_mach_rs6k;
1011 arch = bfd_arch_powerpc;
1012 mach = bfd_mach_ppc;
1015 /* FIXME: schauer/2002-02-25:
1016 We don't know if we are executing a 32 or 64 bit executable,
1017 and have no way to pass the proper word size to rs6000_gdbarch_init.
1018 So we have to avoid switching to a new architecture, if the architecture
1020 Blindly calling rs6000_gdbarch_init used to work in older versions of
1021 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
1022 determine the wordsize. */
1025 const struct bfd_arch_info *exec_bfd_arch_info;
1027 exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
1028 if (arch == exec_bfd_arch_info->arch)
1032 bfd_default_set_arch_mach (&abfd, arch, mach);
1034 gdbarch_info_init (&info);
1035 info.bfd_arch_info = bfd_get_arch_info (&abfd);
1036 info.abfd = exec_bfd;
1038 if (!gdbarch_update_p (info))
1039 internal_error (__FILE__, __LINE__,
1040 _("set_host_arch: failed to select architecture"));
1044 /* xcoff_relocate_symtab - hook for symbol table relocation.
1045 also reads shared libraries. */
1048 xcoff_relocate_symtab (unsigned int pid)
1050 int load_segs = 64; /* number of load segments */
1053 int arch64 = ARCH64 ();
1054 int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
1059 size = load_segs * ldisize;
1060 ldi = (void *) xrealloc (ldi, size);
1063 /* According to my humble theory, AIX has some timing problems and
1064 when the user stack grows, kernel doesn't update stack info in time
1065 and ptrace calls step on user stack. That is why we sleep here a
1066 little, and give kernel to update its internals. */
1071 rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
1073 rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
1077 if (errno == ENOMEM)
1080 perror_with_name (_("ptrace ldinfo"));
1085 vmap_exec (); /* relocate the exec and core sections as well. */
1092 /* Core file stuff. */
1094 /* Relocate symtabs and read in shared library info, based on symbols
1095 from the core file. */
1098 xcoff_relocate_core (struct target_ops *target)
1100 struct bfd_section *ldinfo_sec;
1104 int arch64 = ARCH64 ();
1106 /* Size of a struct ld_info except for the variable-length filename. */
1107 int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1109 /* Allocated size of buffer. */
1110 int buffer_size = nonfilesz;
1111 char *buffer = xmalloc (buffer_size);
1112 struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1114 ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1115 if (ldinfo_sec == NULL)
1118 fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1119 bfd_errmsg (bfd_get_error ()));
1126 int names_found = 0;
1128 /* Read in everything but the name. */
1129 if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1130 offset, nonfilesz) == 0)
1137 if (i == buffer_size)
1140 buffer = xrealloc (buffer, buffer_size);
1142 if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1143 offset + i, 1) == 0)
1145 if (buffer[i++] == '\0')
1148 while (names_found < 2);
1150 ldi = (LdInfo *) buffer;
1152 /* Can't use a file descriptor from the core file; need to open it. */
1154 ldi->l64.ldinfo_fd = -1;
1156 ldi->l32.ldinfo_fd = -1;
1158 /* The first ldinfo is for the exec file, allocated elsewhere. */
1159 if (offset == 0 && vmap != NULL)
1162 vp = add_vmap (ldi);
1164 /* Process next shared library upon error. */
1165 offset += LDI_NEXT (ldi, arch64);
1169 vmap_secs (vp, ldi, arch64);
1171 /* Unless this is the exec file,
1172 add our sections to the section table for the core target. */
1175 struct section_table *stp;
1177 target_resize_to_sections (target, 2);
1178 stp = target->to_sections_end - 2;
1181 stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1182 stp->addr = vp->tstart;
1183 stp->endaddr = vp->tend;
1187 stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1188 stp->addr = vp->dstart;
1189 stp->endaddr = vp->dend;
1194 if (deprecated_target_new_objfile_hook && vp != vmap && vp->objfile)
1195 deprecated_target_new_objfile_hook (vp->objfile);
1197 while (LDI_NEXT (ldi, arch64) != 0);
1199 breakpoint_re_set ();
1204 kernel_u_size (void)
1206 return (sizeof (struct user));
1209 /* Under AIX, we have to pass the correct TOC pointer to a function
1210 when calling functions in the inferior.
1211 We try to find the relative toc offset of the objfile containing PC
1212 and add the current load address of the data segment from the vmap. */
1215 find_toc_address (CORE_ADDR pc)
1218 extern CORE_ADDR get_toc_offset (struct objfile *); /* xcoffread.c */
1220 for (vp = vmap; vp; vp = vp->nxt)
1222 if (pc >= vp->tstart && pc < vp->tend)
1224 /* vp->objfile is only NULL for the exec file. */
1225 return vp->dstart + get_toc_offset (vp->objfile == NULL
1230 error (_("Unable to find TOC entry for pc %s."), hex_string (pc));
1233 /* Register that we are able to handle rs6000 core file formats. */
1235 static struct core_fns rs6000_core_fns =
1237 bfd_target_xcoff_flavour, /* core_flavour */
1238 default_check_format, /* check_format */
1239 default_core_sniffer, /* core_sniffer */
1240 fetch_core_registers, /* core_read_registers */
1245 _initialize_core_rs6000 (void)
1247 /* Initialize hook in rs6000-tdep.c for determining the TOC address
1248 when calling functions in the inferior. */
1249 rs6000_find_toc_address_hook = find_toc_address;
1251 /* Initialize hook in rs6000-tdep.c to set the current architecture
1252 when starting a child process. */
1253 rs6000_set_host_arch_hook = set_host_arch;
1255 deprecated_add_core_fns (&rs6000_core_fns);