1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "xcoffsolib.h"
30 #include "libbfd.h" /* For bfd_cache_lookup (FIXME) */
32 #include "gdb-stabs.h"
34 #include "arch-utils.h"
36 #include <sys/ptrace.h>
39 #include <sys/param.h>
43 #include <sys/ioctl.h>
51 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
52 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
54 #include <sys/systemcfg.h>
56 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
57 debugging 32-bit and 64-bit processes. Define a typedef and macros for
58 accessing fields in the appropriate structures. */
60 /* In 32-bit compilation mode (which is the only mode from which ptrace()
61 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
67 /* Return whether the current architecture is 64-bit. */
72 # define ARCH64() (REGISTER_RAW_SIZE (0) == 8)
75 /* Union of 32-bit and 64-bit ".reg" core file sections. */
79 struct __context64 r64;
86 /* Union of 32-bit and 64-bit versions of ld_info. */
93 struct __ld_info32 l32;
94 struct __ld_info64 l64;
98 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
99 declare and initialize a variable named VAR suitable for use as the arch64
100 parameter to the various LDI_*() macros. */
103 # define ARCH64_DECL(var)
105 # define ARCH64_DECL(var) int var = ARCH64 ()
108 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
109 otherwise. This technique only works for FIELDs with the same data type in
110 32-bit and 64-bit versions of ld_info. */
113 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
115 # define LDI_FIELD(ldi, arch64, field) \
116 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
119 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
120 process otherwise. */
122 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
123 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
124 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
126 extern struct vmap *map_vmap (bfd * bf, bfd * arch);
128 extern struct target_ops exec_ops;
130 static void vmap_exec (void);
132 static void vmap_ldinfo (LdInfo *);
134 static struct vmap *add_vmap (LdInfo *);
136 static int objfile_symbol_add (void *);
138 static void vmap_symtab (struct vmap *);
140 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
142 static void exec_one_dummy_insn (void);
145 fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
147 /* Conversion from gdb-to-system special purpose register numbers. */
149 static int special_regs[] =
155 CTR, /* CTR_REGNUM */
156 XER, /* XER_REGNUM */
160 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
163 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
165 int ret = ptrace (req, id, (int *)addr, data, buf);
167 printf ("rs6000_ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
168 req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
173 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
176 rs6000_ptrace64 (int req, int id, long long addr, int data, int *buf)
179 int ret = ptracex (req, id, addr, data, buf);
184 printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
185 req, id, addr, data, (unsigned int)buf, ret);
190 /* Fetch register REGNO from the inferior. */
193 fetch_register (int regno)
195 int *addr = (int *) ®isters[REGISTER_BYTE (regno)];
198 /* Retrieved values may be -1, so infer errors from errno. */
201 /* Floating-point registers. */
202 if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
204 nr = regno - FP0_REGNUM + FPR0;
205 rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
208 /* Bogus register number. */
209 else if (regno > LAST_UISA_SP_REGNUM)
211 if (regno >= NUM_REGS)
212 fprintf_unfiltered (gdb_stderr,
213 "gdb error: register no %d not implemented.\n",
217 /* Fixed-point registers. */
220 if (regno >= FIRST_UISA_SP_REGNUM)
221 nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
226 *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (int *)nr, 0, 0);
229 /* PT_READ_GPR requires the buffer parameter to point to long long,
230 even if the register is really only 32 bits. */
232 rs6000_ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
233 if (REGISTER_RAW_SIZE (regno) == 8)
234 memcpy (addr, &buf, 8);
241 register_valid[regno] = 1;
245 /* FIXME: this happens 3 times at the start of each 64-bit program. */
246 perror ("ptrace read");
252 /* Store register REGNO back into the inferior. */
255 store_register (int regno)
257 int *addr = (int *) ®isters[REGISTER_BYTE (regno)];
260 /* -1 can be a successful return value, so infer errors from errno. */
263 /* Floating-point registers. */
264 if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
266 nr = regno - FP0_REGNUM + FPR0;
267 rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
270 /* Bogus register number. */
271 else if (regno > LAST_UISA_SP_REGNUM)
273 if (regno >= NUM_REGS)
274 fprintf_unfiltered (gdb_stderr,
275 "gdb error: register no %d not implemented.\n",
279 /* Fixed-point registers. */
282 if (regno == SP_REGNUM)
283 /* Execute one dummy instruction (which is a breakpoint) in inferior
284 process to give kernel a chance to do internal housekeeping.
285 Otherwise the following ptrace(2) calls will mess up user stack
286 since kernel will get confused about the bottom of the stack
288 exec_one_dummy_insn ();
290 if (regno >= FIRST_UISA_SP_REGNUM)
291 nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
296 rs6000_ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid), (int *)nr, *addr, 0);
299 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
300 area, even if the register is really only 32 bits. */
302 if (REGISTER_RAW_SIZE (regno) == 8)
303 memcpy (&buf, addr, 8);
306 rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
312 perror ("ptrace write");
317 /* Read from the inferior all registers if REGNO == -1 and just register
321 fetch_inferior_registers (int regno)
324 fetch_register (regno);
328 /* read 32 general purpose registers. */
329 for (regno = 0; regno < 32; regno++)
330 fetch_register (regno);
332 /* read general purpose floating point registers. */
333 for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
334 fetch_register (regno);
336 /* read special registers. */
337 for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++)
338 fetch_register (regno);
342 /* Store our register values back into the inferior.
343 If REGNO is -1, do this for all registers.
344 Otherwise, REGNO specifies which register (so we can save time). */
347 store_inferior_registers (int regno)
350 store_register (regno);
354 /* write general purpose registers first! */
355 for (regno = GPR0; regno <= GPR31; regno++)
356 store_register (regno);
358 /* write floating point registers now. */
359 for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
360 store_register (regno);
362 /* write special registers. */
364 for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++)
365 store_register (regno);
369 /* Store in *TO the 32-bit word at 32-bit-aligned ADDR in the child
370 process, which is 64-bit if ARCH64 and 32-bit otherwise. Return
374 read_word (CORE_ADDR from, int *to, int arch64)
376 /* Retrieved values may be -1, so infer errors from errno. */
380 *to = rs6000_ptrace64 (PT_READ_I, PIDGET (inferior_ptid), from, 0, NULL);
382 *to = rs6000_ptrace32 (PT_READ_I, PIDGET (inferior_ptid), (int *)(long) from,
388 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
389 to debugger memory starting at MYADDR. Copy to inferior if
392 Returns the length copied, which is either the LEN argument or zero.
393 This xfer function does not do partial moves, since child_ops
394 doesn't allow memory operations to cross below us in the target stack
398 child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
399 int write, struct mem_attrib *attrib,
400 struct target_ops *target)
402 /* Round starting address down to 32-bit word boundary. */
403 int mask = sizeof (int) - 1;
404 CORE_ADDR addr = memaddr & ~(CORE_ADDR)mask;
406 /* Round ending address up to 32-bit word boundary. */
407 int count = ((memaddr + len - addr + mask) & ~(CORE_ADDR)mask)
410 /* Allocate word transfer buffer. */
411 /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
412 because it uses alloca to allocate a buffer of arbitrary size.
413 For very large xfers, this could crash GDB's stack. */
414 int *buf = (int *) alloca (count * sizeof (int));
416 int arch64 = ARCH64 ();
421 /* Retrieve memory a word at a time. */
422 for (i = 0; i < count; i++, addr += sizeof (int))
424 if (!read_word (addr, buf + i, arch64))
429 /* Copy memory to supplied buffer. */
430 addr -= count * sizeof (int);
431 memcpy (myaddr, (char *)buf + (memaddr - addr), len);
435 /* Fetch leading memory needed for alignment. */
437 if (!read_word (addr, buf, arch64))
440 /* Fetch trailing memory needed for alignment. */
441 if (addr + count * sizeof (int) > memaddr + len)
442 if (!read_word (addr, buf + count - 1, arch64))
445 /* Copy supplied data into memory buffer. */
446 memcpy ((char *)buf + (memaddr - addr), myaddr, len);
448 /* Store memory one word at a time. */
449 for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
452 rs6000_ptrace64 (PT_WRITE_D, PIDGET (inferior_ptid), addr, buf[i], NULL);
454 rs6000_ptrace32 (PT_WRITE_D, PIDGET (inferior_ptid), (int *)(long) addr,
466 /* Execute one dummy breakpoint instruction. This way we give the kernel
467 a chance to do some housekeeping and update inferior's internal data,
471 exec_one_dummy_insn (void)
473 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
475 char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
476 int ret, status, pid;
479 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
480 assume that this address will never be executed again by the real
483 target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
485 /* You might think this could be done with a single ptrace call, and
486 you'd be correct for just about every platform I've ever worked
487 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
488 the inferior never hits the breakpoint (it's also worth noting
489 powerpc-ibm-aix4.1.3 works correctly). */
490 prev_pc = read_pc ();
491 write_pc (DUMMY_INSN_ADDR);
493 ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
495 ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
498 perror ("pt_continue");
502 pid = wait (&status);
504 while (pid != PIDGET (inferior_ptid));
507 target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
510 /* Fetch registers from the register section in core bfd. */
513 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
514 int which, CORE_ADDR reg_addr)
519 void *gprs, *sprs[7];
525 "Gdb error: unknown parameter to fetch_core_registers().\n");
530 regs = (CoreRegs *) core_reg_sect;
532 /* Retrieve register pointers. */
536 gprs = regs->r64.gpr;
537 fprs = regs->r64.fpr;
538 sprs[0] = ®s->r64.iar;
539 sprs[1] = ®s->r64.msr;
540 sprs[2] = ®s->r64.cr;
541 sprs[3] = ®s->r64.lr;
542 sprs[4] = ®s->r64.ctr;
543 sprs[5] = ®s->r64.xer;
547 gprs = regs->r32.gpr;
548 fprs = regs->r32.fpr;
549 sprs[0] = ®s->r32.iar;
550 sprs[1] = ®s->r32.msr;
551 sprs[2] = ®s->r32.cr;
552 sprs[3] = ®s->r32.lr;
553 sprs[4] = ®s->r32.ctr;
554 sprs[5] = ®s->r32.xer;
555 sprs[6] = ®s->r32.mq;
558 /* Copy from pointers to registers[]. */
560 memcpy (registers, gprs, 32 * (arch64 ? 8 : 4));
561 memcpy (registers + REGISTER_BYTE (FP0_REGNUM), fprs, 32 * 8);
562 for (i = FIRST_UISA_SP_REGNUM; i <= LAST_UISA_SP_REGNUM; i++)
564 size = REGISTER_RAW_SIZE (i);
566 memcpy (registers + REGISTER_BYTE (i),
567 sprs[i - FIRST_UISA_SP_REGNUM], size);
572 /* Copy information about text and data sections from LDI to VP for a 64-bit
573 process if ARCH64 and for a 32-bit process otherwise. */
576 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
580 vp->tstart = (CORE_ADDR) ldi->l64.ldinfo_textorg;
581 vp->tend = vp->tstart + ldi->l64.ldinfo_textsize;
582 vp->dstart = (CORE_ADDR) ldi->l64.ldinfo_dataorg;
583 vp->dend = vp->dstart + ldi->l64.ldinfo_datasize;
587 vp->tstart = (unsigned long) ldi->l32.ldinfo_textorg;
588 vp->tend = vp->tstart + ldi->l32.ldinfo_textsize;
589 vp->dstart = (unsigned long) ldi->l32.ldinfo_dataorg;
590 vp->dend = vp->dstart + ldi->l32.ldinfo_datasize;
593 /* The run time loader maps the file header in addition to the text
594 section and returns a pointer to the header in ldinfo_textorg.
595 Adjust the text start address to point to the real start address
596 of the text section. */
597 vp->tstart += vp->toffs;
600 /* handle symbol translation on vmapping */
603 vmap_symtab (struct vmap *vp)
605 register struct objfile *objfile;
606 struct section_offsets *new_offsets;
609 objfile = vp->objfile;
612 /* OK, it's not an objfile we opened ourselves.
613 Currently, that can only happen with the exec file, so
614 relocate the symbols for the symfile. */
615 if (symfile_objfile == NULL)
617 objfile = symfile_objfile;
619 else if (!vp->loaded)
620 /* If symbols are not yet loaded, offsets are not yet valid. */
623 new_offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
625 for (i = 0; i < objfile->num_sections; ++i)
626 new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
628 /* The symbols in the object file are linked to the VMA of the section,
629 relocate them VMA relative. */
630 new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
631 new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
632 new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;
634 objfile_relocate (objfile, new_offsets);
637 /* Add symbols for an objfile. */
640 objfile_symbol_add (void *arg)
642 struct objfile *obj = (struct objfile *) arg;
644 syms_from_objfile (obj, NULL, 0, 0);
645 new_symfile_objfile (obj, 0, 0);
649 /* Add symbols for a vmap. Return zero upon error. */
652 vmap_add_symbols (struct vmap *vp)
654 if (catch_errors (objfile_symbol_add, vp->objfile,
655 "Error while reading shared library symbols:\n",
658 /* Note this is only done if symbol reading was successful. */
666 /* Add a new vmap entry based on ldinfo() information.
668 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
669 core file), the caller should set it to -1, and we will open the file.
671 Return the vmap new entry. */
674 add_vmap (LdInfo *ldi)
677 register char *mem, *objname, *filename;
681 ARCH64_DECL (arch64);
683 /* This ldi structure was allocated using alloca() in
684 xcoff_relocate_symtab(). Now we need to have persistent object
685 and member names, so we should save them. */
687 filename = LDI_FILENAME (ldi, arch64);
688 mem = filename + strlen (filename) + 1;
689 mem = savestring (mem, strlen (mem));
690 objname = savestring (filename, strlen (filename));
692 fd = LDI_FD (ldi, arch64);
694 /* Note that this opens it once for every member; a possible
695 enhancement would be to only open it once for every object. */
696 abfd = bfd_openr (objname, gnutarget);
698 abfd = bfd_fdopenr (objname, gnutarget, fd);
701 warning ("Could not open `%s' as an executable file: %s",
702 objname, bfd_errmsg (bfd_get_error ()));
706 /* make sure we have an object file */
708 if (bfd_check_format (abfd, bfd_object))
709 vp = map_vmap (abfd, 0);
711 else if (bfd_check_format (abfd, bfd_archive))
714 /* FIXME??? am I tossing BFDs? bfd? */
715 while ((last = bfd_openr_next_archived_file (abfd, last)))
716 if (STREQ (mem, last->filename))
721 warning ("\"%s\": member \"%s\" missing.", objname, mem);
726 if (!bfd_check_format (last, bfd_object))
728 warning ("\"%s\": member \"%s\" not in executable format: %s.",
729 objname, mem, bfd_errmsg (bfd_get_error ()));
735 vp = map_vmap (last, abfd);
739 warning ("\"%s\": not in executable format: %s.",
740 objname, bfd_errmsg (bfd_get_error ()));
744 obj = allocate_objfile (vp->bfd, 0);
747 /* Always add symbols for the main objfile. */
748 if (vp == vmap || auto_solib_add)
749 vmap_add_symbols (vp);
753 /* update VMAP info with ldinfo() information
754 Input is ptr to ldinfo() results. */
757 vmap_ldinfo (LdInfo *ldi)
760 register struct vmap *vp;
761 int got_one, retried;
762 int got_exec_file = 0;
764 int arch64 = ARCH64 ();
766 /* For each *ldi, see if we have a corresponding *vp.
767 If so, update the mapping, and symbol table.
768 If not, add an entry and symbol table. */
772 char *name = LDI_FILENAME (ldi, arch64);
773 char *memb = name + strlen (name) + 1;
774 int fd = LDI_FD (ldi, arch64);
778 if (fstat (fd, &ii) < 0)
780 /* The kernel sets ld_info to -1, if the process is still using the
781 object, and the object is removed. Keep the symbol info for the
782 removed object and issue a warning. */
783 warning ("%s (fd=%d) has disappeared, keeping its symbols",
788 for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
790 struct objfile *objfile;
792 /* First try to find a `vp', which is the same as in ldinfo.
793 If not the same, just continue and grep the next `vp'. If same,
794 relocate its tstart, tend, dstart, dend values. If no such `vp'
795 found, get out of this for loop, add this ldi entry as a new vmap
796 (add_vmap) and come back, find its `vp' and so on... */
798 /* The filenames are not always sufficient to match on. */
800 if ((name[0] == '/' && !STREQ (name, vp->name))
801 || (memb[0] && !STREQ (memb, vp->member)))
804 /* See if we are referring to the same file.
805 We have to check objfile->obfd, symfile.c:reread_symbols might
806 have updated the obfd after a change. */
807 objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
809 || objfile->obfd == NULL
810 || bfd_stat (objfile->obfd, &vi) < 0)
812 warning ("Unable to stat %s, keeping its symbols", name);
816 if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
824 /* Found a corresponding VMAP. Remap! */
826 vmap_secs (vp, ldi, arch64);
828 /* The objfile is only NULL for the exec file. */
829 if (vp->objfile == NULL)
832 /* relocate symbol table(s). */
835 /* There may be more, so we don't break out of the loop. */
838 /* if there was no matching *vp, we must perforce create the sucker(s) */
839 if (!got_one && !retried)
846 while ((next = LDI_NEXT (ldi, arch64))
847 && (ldi = (void *) (next + (char *) ldi)));
849 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
850 is unlikely that the symbol file is relocated to the proper
851 address. And we might have attached to a process which is
852 running a different copy of the same executable. */
853 if (symfile_objfile != NULL && !got_exec_file)
855 warning ("Symbol file %s\nis not mapped; discarding it.\n\
856 If in fact that file has symbols which the mapped files listed by\n\
857 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
858 \"add-symbol-file\" commands (note that you must take care of relocating\n\
859 symbols to the proper address).",
860 symfile_objfile->name);
861 free_objfile (symfile_objfile);
862 symfile_objfile = NULL;
864 breakpoint_re_set ();
867 /* As well as symbol tables, exec_sections need relocation. After
868 the inferior process' termination, there will be a relocated symbol
869 table exist with no corresponding inferior process. At that time, we
870 need to use `exec' bfd, rather than the inferior process's memory space
873 `exec_sections' need to be relocated only once, as long as the exec
874 file remains unchanged.
883 if (execbfd == exec_bfd)
888 if (!vmap || !exec_ops.to_sections)
889 error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
891 for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
893 if (STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
895 exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
896 exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
898 else if (STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
900 exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
901 exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
903 else if (STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
905 exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
906 exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
911 /* Set the current architecture from the host running GDB. Called when
912 starting a child process. */
915 set_host_arch (int pid)
917 enum bfd_architecture arch;
920 struct gdbarch_info info;
924 arch = bfd_arch_rs6000;
925 mach = bfd_mach_rs6k;
929 arch = bfd_arch_powerpc;
933 /* FIXME: schauer/2002-02-25:
934 We don't know if we are executing a 32 or 64 bit executable,
935 and have no way to pass the proper word size to rs6000_gdbarch_init.
936 So we have to avoid switching to a new architecture, if the architecture
938 Blindly calling rs6000_gdbarch_init used to work in older versions of
939 GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
940 determine the wordsize. */
943 const struct bfd_arch_info *exec_bfd_arch_info;
945 exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
946 if (arch == exec_bfd_arch_info->arch)
950 bfd_default_set_arch_mach (&abfd, arch, mach);
952 gdbarch_info_init (&info);
953 info.bfd_arch_info = bfd_get_arch_info (&abfd);
955 if (!gdbarch_update_p (info))
957 internal_error (__FILE__, __LINE__,
958 "set_host_arch: failed to select architecture");
963 /* xcoff_relocate_symtab - hook for symbol table relocation.
964 also reads shared libraries.. */
967 xcoff_relocate_symtab (unsigned int pid)
969 int load_segs = 64; /* number of load segments */
972 int arch64 = ARCH64 ();
973 int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
978 size = load_segs * ldisize;
979 ldi = (void *) xrealloc (ldi, size);
982 /* According to my humble theory, AIX has some timing problems and
983 when the user stack grows, kernel doesn't update stack info in time
984 and ptrace calls step on user stack. That is why we sleep here a
985 little, and give kernel to update its internals. */
990 rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
992 rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
999 perror_with_name ("ptrace ldinfo");
1004 vmap_exec (); /* relocate the exec and core sections as well. */
1011 /* Core file stuff. */
1013 /* Relocate symtabs and read in shared library info, based on symbols
1014 from the core file. */
1017 xcoff_relocate_core (struct target_ops *target)
1023 int arch64 = ARCH64 ();
1025 /* Size of a struct ld_info except for the variable-length filename. */
1026 int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1028 /* Allocated size of buffer. */
1029 int buffer_size = nonfilesz;
1030 char *buffer = xmalloc (buffer_size);
1031 struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1033 ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1034 if (ldinfo_sec == NULL)
1037 fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1038 bfd_errmsg (bfd_get_error ()));
1045 int names_found = 0;
1047 /* Read in everything but the name. */
1048 if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1049 offset, nonfilesz) == 0)
1056 if (i == buffer_size)
1059 buffer = xrealloc (buffer, buffer_size);
1061 if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1062 offset + i, 1) == 0)
1064 if (buffer[i++] == '\0')
1067 while (names_found < 2);
1069 ldi = (LdInfo *) buffer;
1071 /* Can't use a file descriptor from the core file; need to open it. */
1073 ldi->l64.ldinfo_fd = -1;
1075 ldi->l32.ldinfo_fd = -1;
1077 /* The first ldinfo is for the exec file, allocated elsewhere. */
1078 if (offset == 0 && vmap != NULL)
1081 vp = add_vmap (ldi);
1083 /* Process next shared library upon error. */
1084 offset += LDI_NEXT (ldi, arch64);
1088 vmap_secs (vp, ldi, arch64);
1090 /* Unless this is the exec file,
1091 add our sections to the section table for the core target. */
1094 struct section_table *stp;
1096 target_resize_to_sections (target, 2);
1097 stp = target->to_sections_end - 2;
1100 stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1101 stp->addr = vp->tstart;
1102 stp->endaddr = vp->tend;
1106 stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1107 stp->addr = vp->dstart;
1108 stp->endaddr = vp->dend;
1113 while (LDI_NEXT (ldi, arch64) != 0);
1115 breakpoint_re_set ();
1120 kernel_u_size (void)
1122 return (sizeof (struct user));
1125 /* Under AIX, we have to pass the correct TOC pointer to a function
1126 when calling functions in the inferior.
1127 We try to find the relative toc offset of the objfile containing PC
1128 and add the current load address of the data segment from the vmap. */
1131 find_toc_address (CORE_ADDR pc)
1134 extern CORE_ADDR get_toc_offset (struct objfile *); /* xcoffread.c */
1136 for (vp = vmap; vp; vp = vp->nxt)
1138 if (pc >= vp->tstart && pc < vp->tend)
1140 /* vp->objfile is only NULL for the exec file. */
1141 return vp->dstart + get_toc_offset (vp->objfile == NULL
1146 error ("Unable to find TOC entry for pc 0x%x\n", pc);
1149 /* Register that we are able to handle rs6000 core file formats. */
1151 static struct core_fns rs6000_core_fns =
1153 bfd_target_xcoff_flavour, /* core_flavour */
1154 default_check_format, /* check_format */
1155 default_core_sniffer, /* core_sniffer */
1156 fetch_core_registers, /* core_read_registers */
1161 _initialize_core_rs6000 (void)
1163 /* Initialize hook in rs6000-tdep.c for determining the TOC address when
1164 calling functions in the inferior. */
1165 rs6000_find_toc_address_hook = find_toc_address;
1167 /* Initialize hook in rs6000-tdep.c to set the current architecture when
1168 starting a child process. */
1169 rs6000_set_host_arch_hook = set_host_arch;
1171 add_core_fns (&rs6000_core_fns);