1 /* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
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"
35 #include <sys/ptrace.h>
38 #include <sys/param.h>
42 #include <sys/ioctl.h>
50 #define __LDINFO_PTRACE32__ /* for __ld_info32 */
51 #define __LDINFO_PTRACE64__ /* for __ld_info64 */
53 #include <sys/systemcfg.h>
55 /* On AIX4.3+, sys/ldr.h provides different versions of struct ld_info for
56 debugging 32-bit and 64-bit processes. Define a typedef and macros for
57 accessing fields in the appropriate structures. */
59 /* In 32-bit compilation mode (which is the only mode from which ptrace()
60 works on 4.3), __ld_info32 is #defined as equivalent to ld_info. */
66 /* Return whether the current architecture is 64-bit. */
71 # define ARCH64() (REGISTER_RAW_SIZE (0) == 8)
74 /* Union of 32-bit and 64-bit ".reg" core file sections. */
78 struct __context64 r64;
85 /* Union of 32-bit and 64-bit versions of ld_info. */
92 struct __ld_info32 l32;
93 struct __ld_info64 l64;
97 /* If compiling with 32-bit and 64-bit debugging capability (e.g. AIX 4.x),
98 declare and initialize a variable named VAR suitable for use as the arch64
99 parameter to the various LDI_*() macros. */
102 # define ARCH64_DECL(var)
104 # define ARCH64_DECL(var) int var = ARCH64 ()
107 /* Return LDI's FIELD for a 64-bit process if ARCH64 and for a 32-bit process
108 otherwise. This technique only works for FIELDs with the same data type in
109 32-bit and 64-bit versions of ld_info. */
112 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
114 # define LDI_FIELD(ldi, arch64, field) \
115 (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
118 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
119 process otherwise. */
121 #define LDI_NEXT(ldi, arch64) LDI_FIELD(ldi, arch64, next)
122 #define LDI_FD(ldi, arch64) LDI_FIELD(ldi, arch64, fd)
123 #define LDI_FILENAME(ldi, arch64) LDI_FIELD(ldi, arch64, filename)
125 extern struct vmap *map_vmap (bfd * bf, bfd * arch);
127 extern struct target_ops exec_ops;
129 static void vmap_exec (void);
131 static void vmap_ldinfo (LdInfo *);
133 static struct vmap *add_vmap (LdInfo *);
135 static int objfile_symbol_add (void *);
137 static void vmap_symtab (struct vmap *);
139 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
141 static void exec_one_dummy_insn (void);
144 fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
146 /* Conversion from gdb-to-system special purpose register numbers. */
148 static int special_regs[] =
154 CTR, /* CTR_REGNUM */
155 XER, /* XER_REGNUM */
159 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
162 ptrace32 (int req, int id, int *addr, int data, int *buf)
164 int ret = ptrace (req, id, (int *)addr, data, buf);
166 printf ("ptrace32 (%d, %d, 0x%x, %08x, 0x%x) = 0x%x\n",
167 req, id, (unsigned int)addr, data, (unsigned int)buf, ret);
172 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
175 ptrace64 (int req, int id, long long addr, int data, int *buf)
178 int ret = ptracex (req, id, addr, data, buf);
183 printf ("ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
184 req, id, addr, data, (unsigned int)buf, ret);
189 /* Fetch register REGNO from the inferior. */
192 fetch_register (int regno)
194 int *addr = (int *) ®isters[REGISTER_BYTE (regno)];
197 /* Retrieved values may be -1, so infer errors from errno. */
200 /* Floating-point registers. */
201 if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
203 nr = regno - FP0_REGNUM + FPR0;
204 ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
207 /* Bogus register number. */
208 else if (regno > LAST_UISA_SP_REGNUM)
210 if (regno >= NUM_REGS)
211 fprintf_unfiltered (gdb_stderr,
212 "gdb error: register no %d not implemented.\n",
216 /* Fixed-point registers. */
219 if (regno >= FIRST_UISA_SP_REGNUM)
220 nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
225 *addr = ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (int *)nr, 0, 0);
228 /* PT_READ_GPR requires the buffer parameter to point to long long,
229 even if the register is really only 32 bits. */
231 ptrace64 (PT_READ_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
232 if (REGISTER_RAW_SIZE (regno) == 8)
233 memcpy (addr, &buf, 8);
240 register_valid[regno] = 1;
244 /* FIXME: this happens 3 times at the start of each 64-bit program. */
245 perror ("ptrace read");
251 /* Store register REGNO back into the inferior. */
254 store_register (int regno)
256 int *addr = (int *) ®isters[REGISTER_BYTE (regno)];
259 /* -1 can be a successful return value, so infer errors from errno. */
262 /* Floating-point registers. */
263 if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
265 nr = regno - FP0_REGNUM + FPR0;
266 ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
269 /* Bogus register number. */
270 else if (regno > LAST_UISA_SP_REGNUM)
272 if (regno >= NUM_REGS)
273 fprintf_unfiltered (gdb_stderr,
274 "gdb error: register no %d not implemented.\n",
278 /* Fixed-point registers. */
281 if (regno == SP_REGNUM)
282 /* Execute one dummy instruction (which is a breakpoint) in inferior
283 process to give kernel a chance to do internal housekeeping.
284 Otherwise the following ptrace(2) calls will mess up user stack
285 since kernel will get confused about the bottom of the stack
287 exec_one_dummy_insn ();
289 if (regno >= FIRST_UISA_SP_REGNUM)
290 nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
295 ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid), (int *)nr, *addr, 0);
298 /* PT_WRITE_GPR requires the buffer parameter to point to an 8-byte
299 area, even if the register is really only 32 bits. */
301 if (REGISTER_RAW_SIZE (regno) == 8)
302 memcpy (&buf, addr, 8);
305 ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
311 perror ("ptrace write");
316 /* Read from the inferior all registers if REGNO == -1 and just register
320 fetch_inferior_registers (int regno)
323 fetch_register (regno);
327 /* read 32 general purpose registers. */
328 for (regno = 0; regno < 32; regno++)
329 fetch_register (regno);
331 /* read general purpose floating point registers. */
332 for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
333 fetch_register (regno);
335 /* read special registers. */
336 for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++)
337 fetch_register (regno);
341 /* Store our register values back into the inferior.
342 If REGNO is -1, do this for all registers.
343 Otherwise, REGNO specifies which register (so we can save time). */
346 store_inferior_registers (int regno)
349 store_register (regno);
353 /* write general purpose registers first! */
354 for (regno = GPR0; regno <= GPR31; regno++)
355 store_register (regno);
357 /* write floating point registers now. */
358 for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
359 store_register (regno);
361 /* write special registers. */
363 for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++)
364 store_register (regno);
368 /* Store in *TO the 32-bit word at 32-bit-aligned ADDR in the child
369 process, which is 64-bit if ARCH64 and 32-bit otherwise. Return
373 read_word (CORE_ADDR from, int *to, int arch64)
375 /* Retrieved values may be -1, so infer errors from errno. */
379 *to = ptrace64 (PT_READ_I, PIDGET (inferior_ptid), from, 0, NULL);
381 *to = ptrace32 (PT_READ_I, PIDGET (inferior_ptid), (int *)(long) from,
387 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
388 to debugger memory starting at MYADDR. Copy to inferior if
391 Returns the length copied, which is either the LEN argument or zero.
392 This xfer function does not do partial moves, since child_ops
393 doesn't allow memory operations to cross below us in the target stack
397 child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
398 int write, struct mem_attrib *attrib,
399 struct target_ops *target)
401 /* Round starting address down to 32-bit word boundary. */
402 int mask = sizeof (int) - 1;
403 CORE_ADDR addr = memaddr & ~(CORE_ADDR)mask;
405 /* Round ending address up to 32-bit word boundary. */
406 int count = ((memaddr + len - addr + mask) & ~(CORE_ADDR)mask)
409 /* Allocate word transfer buffer. */
410 int *buf = (int *) alloca (count * sizeof (int));
412 int arch64 = ARCH64 ();
417 /* Retrieve memory a word at a time. */
418 for (i = 0; i < count; i++, addr += sizeof (int))
420 if (!read_word (addr, buf + i, arch64))
425 /* Copy memory to supplied buffer. */
426 addr -= count * sizeof (int);
427 memcpy (myaddr, (char *)buf + (memaddr - addr), len);
431 /* Fetch leading memory needed for alignment. */
433 if (!read_word (addr, buf, arch64))
436 /* Fetch trailing memory needed for alignment. */
437 if (addr + count * sizeof (int) > memaddr + len)
438 if (!read_word (addr, buf + count - 1, arch64))
441 /* Copy supplied data into memory buffer. */
442 memcpy ((char *)buf + (memaddr - addr), myaddr, len);
444 /* Store memory one word at a time. */
445 for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
448 ptrace64 (PT_WRITE_D, PIDGET (inferior_ptid), addr, buf[i], NULL);
450 ptrace32 (PT_WRITE_D, PIDGET (inferior_ptid), (int *)(long) addr,
462 /* Execute one dummy breakpoint instruction. This way we give the kernel
463 a chance to do some housekeeping and update inferior's internal data,
467 exec_one_dummy_insn (void)
469 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
471 char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
472 int ret, status, pid;
475 /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
476 assume that this address will never be executed again by the real
479 target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
481 /* You might think this could be done with a single ptrace call, and
482 you'd be correct for just about every platform I've ever worked
483 on. However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
484 the inferior never hits the breakpoint (it's also worth noting
485 powerpc-ibm-aix4.1.3 works correctly). */
486 prev_pc = read_pc ();
487 write_pc (DUMMY_INSN_ADDR);
489 ret = ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
491 ret = ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
494 perror ("pt_continue");
498 pid = wait (&status);
500 while (pid != PIDGET (inferior_ptid));
503 target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
506 /* Fetch registers from the register section in core bfd. */
509 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
510 int which, CORE_ADDR reg_addr)
515 void *gprs, *sprs[7];
521 "Gdb error: unknown parameter to fetch_core_registers().\n");
526 regs = (CoreRegs *) core_reg_sect;
528 /* Retrieve register pointers. */
532 gprs = regs->r64.gpr;
533 fprs = regs->r64.fpr;
534 sprs[0] = ®s->r64.iar;
535 sprs[1] = ®s->r64.msr;
536 sprs[2] = ®s->r64.cr;
537 sprs[3] = ®s->r64.lr;
538 sprs[4] = ®s->r64.ctr;
539 sprs[5] = ®s->r64.xer;
543 gprs = regs->r32.gpr;
544 fprs = regs->r32.fpr;
545 sprs[0] = ®s->r32.iar;
546 sprs[1] = ®s->r32.msr;
547 sprs[2] = ®s->r32.cr;
548 sprs[3] = ®s->r32.lr;
549 sprs[4] = ®s->r32.ctr;
550 sprs[5] = ®s->r32.xer;
551 sprs[6] = ®s->r32.mq;
554 /* Copy from pointers to registers[]. */
556 memcpy (registers, gprs, 32 * (arch64 ? 8 : 4));
557 memcpy (registers + REGISTER_BYTE (FP0_REGNUM), fprs, 32 * 8);
558 for (i = FIRST_UISA_SP_REGNUM; i <= LAST_UISA_SP_REGNUM; i++)
560 size = REGISTER_RAW_SIZE (i);
562 memcpy (registers + REGISTER_BYTE (i),
563 sprs[i - FIRST_UISA_SP_REGNUM], size);
568 /* Copy information about text and data sections from LDI to VP for a 64-bit
569 process if ARCH64 and for a 32-bit process otherwise. */
572 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
576 vp->tstart = (CORE_ADDR) ldi->l64.ldinfo_textorg;
577 vp->tend = vp->tstart + ldi->l64.ldinfo_textsize;
578 vp->dstart = (CORE_ADDR) ldi->l64.ldinfo_dataorg;
579 vp->dend = vp->dstart + ldi->l64.ldinfo_datasize;
583 vp->tstart = (unsigned long) ldi->l32.ldinfo_textorg;
584 vp->tend = vp->tstart + ldi->l32.ldinfo_textsize;
585 vp->dstart = (unsigned long) ldi->l32.ldinfo_dataorg;
586 vp->dend = vp->dstart + ldi->l32.ldinfo_datasize;
589 /* The run time loader maps the file header in addition to the text
590 section and returns a pointer to the header in ldinfo_textorg.
591 Adjust the text start address to point to the real start address
592 of the text section. */
593 vp->tstart += vp->toffs;
596 /* handle symbol translation on vmapping */
599 vmap_symtab (struct vmap *vp)
601 register struct objfile *objfile;
602 struct section_offsets *new_offsets;
605 objfile = vp->objfile;
608 /* OK, it's not an objfile we opened ourselves.
609 Currently, that can only happen with the exec file, so
610 relocate the symbols for the symfile. */
611 if (symfile_objfile == NULL)
613 objfile = symfile_objfile;
615 else if (!vp->loaded)
616 /* If symbols are not yet loaded, offsets are not yet valid. */
619 new_offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
621 for (i = 0; i < objfile->num_sections; ++i)
622 new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
624 /* The symbols in the object file are linked to the VMA of the section,
625 relocate them VMA relative. */
626 new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
627 new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
628 new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;
630 objfile_relocate (objfile, new_offsets);
633 /* Add symbols for an objfile. */
636 objfile_symbol_add (void *arg)
638 struct objfile *obj = (struct objfile *) arg;
640 syms_from_objfile (obj, NULL, 0, 0);
641 new_symfile_objfile (obj, 0, 0);
645 /* Add symbols for a vmap. Return zero upon error. */
648 vmap_add_symbols (struct vmap *vp)
650 if (catch_errors (objfile_symbol_add, vp->objfile,
651 "Error while reading shared library symbols:\n",
654 /* Note this is only done if symbol reading was successful. */
662 /* Add a new vmap entry based on ldinfo() information.
664 If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
665 core file), the caller should set it to -1, and we will open the file.
667 Return the vmap new entry. */
670 add_vmap (LdInfo *ldi)
673 register char *mem, *objname, *filename;
677 ARCH64_DECL (arch64);
679 /* This ldi structure was allocated using alloca() in
680 xcoff_relocate_symtab(). Now we need to have persistent object
681 and member names, so we should save them. */
683 filename = LDI_FILENAME (ldi, arch64);
684 mem = filename + strlen (filename) + 1;
685 mem = savestring (mem, strlen (mem));
686 objname = savestring (filename, strlen (filename));
688 fd = LDI_FD (ldi, arch64);
690 /* Note that this opens it once for every member; a possible
691 enhancement would be to only open it once for every object. */
692 abfd = bfd_openr (objname, gnutarget);
694 abfd = bfd_fdopenr (objname, gnutarget, fd);
697 warning ("Could not open `%s' as an executable file: %s",
698 objname, bfd_errmsg (bfd_get_error ()));
702 /* make sure we have an object file */
704 if (bfd_check_format (abfd, bfd_object))
705 vp = map_vmap (abfd, 0);
707 else if (bfd_check_format (abfd, bfd_archive))
710 /* FIXME??? am I tossing BFDs? bfd? */
711 while ((last = bfd_openr_next_archived_file (abfd, last)))
712 if (STREQ (mem, last->filename))
717 warning ("\"%s\": member \"%s\" missing.", objname, mem);
722 if (!bfd_check_format (last, bfd_object))
724 warning ("\"%s\": member \"%s\" not in executable format: %s.",
725 objname, mem, bfd_errmsg (bfd_get_error ()));
731 vp = map_vmap (last, abfd);
735 warning ("\"%s\": not in executable format: %s.",
736 objname, bfd_errmsg (bfd_get_error ()));
740 obj = allocate_objfile (vp->bfd, 0);
743 /* Always add symbols for the main objfile. */
744 if (vp == vmap || auto_solib_add)
745 vmap_add_symbols (vp);
749 /* update VMAP info with ldinfo() information
750 Input is ptr to ldinfo() results. */
753 vmap_ldinfo (LdInfo *ldi)
756 register struct vmap *vp;
757 int got_one, retried;
758 int got_exec_file = 0;
760 int arch64 = ARCH64 ();
762 /* For each *ldi, see if we have a corresponding *vp.
763 If so, update the mapping, and symbol table.
764 If not, add an entry and symbol table. */
768 char *name = LDI_FILENAME (ldi, arch64);
769 char *memb = name + strlen (name) + 1;
770 int fd = LDI_FD (ldi, arch64);
774 if (fstat (fd, &ii) < 0)
776 /* The kernel sets ld_info to -1, if the process is still using the
777 object, and the object is removed. Keep the symbol info for the
778 removed object and issue a warning. */
779 warning ("%s (fd=%d) has disappeared, keeping its symbols",
784 for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
786 struct objfile *objfile;
788 /* First try to find a `vp', which is the same as in ldinfo.
789 If not the same, just continue and grep the next `vp'. If same,
790 relocate its tstart, tend, dstart, dend values. If no such `vp'
791 found, get out of this for loop, add this ldi entry as a new vmap
792 (add_vmap) and come back, find its `vp' and so on... */
794 /* The filenames are not always sufficient to match on. */
796 if ((name[0] == '/' && !STREQ (name, vp->name))
797 || (memb[0] && !STREQ (memb, vp->member)))
800 /* See if we are referring to the same file.
801 We have to check objfile->obfd, symfile.c:reread_symbols might
802 have updated the obfd after a change. */
803 objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
805 || objfile->obfd == NULL
806 || bfd_stat (objfile->obfd, &vi) < 0)
808 warning ("Unable to stat %s, keeping its symbols", name);
812 if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
820 /* Found a corresponding VMAP. Remap! */
822 vmap_secs (vp, ldi, arch64);
824 /* The objfile is only NULL for the exec file. */
825 if (vp->objfile == NULL)
828 /* relocate symbol table(s). */
831 /* There may be more, so we don't break out of the loop. */
834 /* if there was no matching *vp, we must perforce create the sucker(s) */
835 if (!got_one && !retried)
842 while ((next = LDI_NEXT (ldi, arch64))
843 && (ldi = (void *) (next + (char *) ldi)));
845 /* If we don't find the symfile_objfile anywhere in the ldinfo, it
846 is unlikely that the symbol file is relocated to the proper
847 address. And we might have attached to a process which is
848 running a different copy of the same executable. */
849 if (symfile_objfile != NULL && !got_exec_file)
852 fputs_unfiltered ("Symbol file ", gdb_stderr);
853 fputs_unfiltered (symfile_objfile->name, gdb_stderr);
854 fputs_unfiltered ("\nis not mapped; discarding it.\n\
855 If in fact that file has symbols which the mapped files listed by\n\
856 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
857 \"add-symbol-file\" commands (note that you must take care of relocating\n\
858 symbols to the proper address).\n", gdb_stderr);
859 free_objfile (symfile_objfile);
860 symfile_objfile = NULL;
862 breakpoint_re_set ();
865 /* As well as symbol tables, exec_sections need relocation. After
866 the inferior process' termination, there will be a relocated symbol
867 table exist with no corresponding inferior process. At that time, we
868 need to use `exec' bfd, rather than the inferior process's memory space
871 `exec_sections' need to be relocated only once, as long as the exec
872 file remains unchanged.
881 if (execbfd == exec_bfd)
886 if (!vmap || !exec_ops.to_sections)
887 error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
889 for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
891 if (STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
893 exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
894 exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
896 else if (STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
898 exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
899 exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
901 else if (STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
903 exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
904 exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
909 /* Set the current architecture from the host running GDB. Called when
910 starting a child process. */
913 set_host_arch (int pid)
915 enum bfd_architecture arch;
918 struct gdbarch_info info;
922 arch = bfd_arch_rs6000;
923 mach = bfd_mach_rs6k;
927 arch = bfd_arch_powerpc;
930 bfd_default_set_arch_mach (&abfd, arch, mach);
932 gdbarch_info_init (&info);
933 info.bfd_arch_info = bfd_get_arch_info (&abfd);
935 if (!gdbarch_update_p (info))
937 internal_error (__FILE__, __LINE__,
938 "set_host_arch: failed to select architecture");
943 /* xcoff_relocate_symtab - hook for symbol table relocation.
944 also reads shared libraries.. */
947 xcoff_relocate_symtab (unsigned int pid)
949 int load_segs = 64; /* number of load segments */
952 int arch64 = ARCH64 ();
953 int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
958 size = load_segs * ldisize;
959 ldi = (void *) xrealloc (ldi, size);
962 /* According to my humble theory, AIX has some timing problems and
963 when the user stack grows, kernel doesn't update stack info in time
964 and ptrace calls step on user stack. That is why we sleep here a
965 little, and give kernel to update its internals. */
970 rc = ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
972 rc = ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
979 perror_with_name ("ptrace ldinfo");
984 vmap_exec (); /* relocate the exec and core sections as well. */
991 /* Core file stuff. */
993 /* Relocate symtabs and read in shared library info, based on symbols
994 from the core file. */
997 xcoff_relocate_core (struct target_ops *target)
1003 int arch64 = ARCH64 ();
1005 /* Size of a struct ld_info except for the variable-length filename. */
1006 int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1008 /* Allocated size of buffer. */
1009 int buffer_size = nonfilesz;
1010 char *buffer = xmalloc (buffer_size);
1011 struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1013 ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1014 if (ldinfo_sec == NULL)
1017 fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1018 bfd_errmsg (bfd_get_error ()));
1025 int names_found = 0;
1027 /* Read in everything but the name. */
1028 if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1029 offset, nonfilesz) == 0)
1036 if (i == buffer_size)
1039 buffer = xrealloc (buffer, buffer_size);
1041 if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1042 offset + i, 1) == 0)
1044 if (buffer[i++] == '\0')
1047 while (names_found < 2);
1049 ldi = (LdInfo *) buffer;
1051 /* Can't use a file descriptor from the core file; need to open it. */
1053 ldi->l64.ldinfo_fd = -1;
1055 ldi->l32.ldinfo_fd = -1;
1057 /* The first ldinfo is for the exec file, allocated elsewhere. */
1058 if (offset == 0 && vmap != NULL)
1061 vp = add_vmap (ldi);
1063 /* Process next shared library upon error. */
1064 offset += LDI_NEXT (ldi, arch64);
1068 vmap_secs (vp, ldi, arch64);
1070 /* Unless this is the exec file,
1071 add our sections to the section table for the core target. */
1074 struct section_table *stp;
1076 target_resize_to_sections (target, 2);
1077 stp = target->to_sections_end - 2;
1080 stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1081 stp->addr = vp->tstart;
1082 stp->endaddr = vp->tend;
1086 stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1087 stp->addr = vp->dstart;
1088 stp->endaddr = vp->dend;
1093 while (LDI_NEXT (ldi, arch64) != 0);
1095 breakpoint_re_set ();
1100 kernel_u_size (void)
1102 return (sizeof (struct user));
1105 /* Under AIX, we have to pass the correct TOC pointer to a function
1106 when calling functions in the inferior.
1107 We try to find the relative toc offset of the objfile containing PC
1108 and add the current load address of the data segment from the vmap. */
1111 find_toc_address (CORE_ADDR pc)
1114 extern CORE_ADDR get_toc_offset (struct objfile *); /* xcoffread.c */
1116 for (vp = vmap; vp; vp = vp->nxt)
1118 if (pc >= vp->tstart && pc < vp->tend)
1120 /* vp->objfile is only NULL for the exec file. */
1121 return vp->dstart + get_toc_offset (vp->objfile == NULL
1126 error ("Unable to find TOC entry for pc 0x%x\n", pc);
1129 /* Register that we are able to handle rs6000 core file formats. */
1131 static struct core_fns rs6000_core_fns =
1133 bfd_target_xcoff_flavour, /* core_flavour */
1134 default_check_format, /* check_format */
1135 default_core_sniffer, /* core_sniffer */
1136 fetch_core_registers, /* core_read_registers */
1141 _initialize_core_rs6000 (void)
1143 /* Initialize hook in rs6000-tdep.c for determining the TOC address when
1144 calling functions in the inferior. */
1145 rs6000_find_toc_address_hook = find_toc_address;
1147 /* Initialize hook in rs6000-tdep.c to set the current architecture when
1148 starting a child process. */
1149 rs6000_set_host_arch_hook = set_host_arch;
1151 add_core_fns (&rs6000_core_fns);