gdb/rs6000-nat.c

   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.
   5
   6    This file is part of GDB.
   7
   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.
  12
  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.
  17
  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.  */
  22
  23 #include "defs.h"
  24 #include "inferior.h"
  25 #include "target.h"
  26 #include "gdbcore.h"
  27 #include "xcoffsolib.h"
  28 #include "symfile.h"
  29 #include "objfiles.h"
  30 #include "libbfd.h"             /* For bfd_cache_lookup (FIXME) */
  31 #include "bfd.h"
  32 #include "gdb-stabs.h"
  33 #include "regcache.h"
  34 #include "arch-utils.h"
  35
  36 #include <sys/ptrace.h>
  37 #include <sys/reg.h>
  38
  39 #include <sys/param.h>
  40 #include <sys/dir.h>
  41 #include <sys/user.h>
  42 #include <signal.h>
  43 #include <sys/ioctl.h>
  44 #include <fcntl.h>
  45 #include <errno.h>
  46
  47 #include <a.out.h>
  48 #include <sys/file.h>
  49 #include "gdb_stat.h"
  50 #include <sys/core.h>
  51 #define __LDINFO_PTRACE32__     /* for __ld_info32 */
  52 #define __LDINFO_PTRACE64__     /* for __ld_info64 */
  53 #include <sys/ldr.h>
  54 #include <sys/systemcfg.h>
  55
  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. */
  59
  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. */
  62
  63 #ifdef __ld_info32
  64 # define ARCH3264
  65 #endif
  66
  67 /* Return whether the current architecture is 64-bit. */
  68
  69 #ifndef ARCH3264
  70 # define ARCH64() 0
  71 #else
  72 # define ARCH64() (REGISTER_RAW_SIZE (0) == 8)
  73 #endif
  74
  75 /* Union of 32-bit and 64-bit ".reg" core file sections. */
  76
  77 typedef union {
  78 #ifdef ARCH3264
  79   struct __context64 r64;
  80 #else
  81   struct mstsave r64;
  82 #endif
  83   struct mstsave r32;
  84 } CoreRegs;
  85
  86 /* Union of 32-bit and 64-bit versions of ld_info. */
  87
  88 typedef union {
  89 #ifndef ARCH3264
  90   struct ld_info l32;
  91   struct ld_info l64;
  92 #else
  93   struct __ld_info32 l32;
  94   struct __ld_info64 l64;
  95 #endif
  96 } LdInfo;
  97
  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. */
 101
 102 #ifndef ARCH3264
 103 # define ARCH64_DECL(var)
 104 #else
 105 # define ARCH64_DECL(var) int var = ARCH64 ()
 106 #endif
 107
 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. */
 111
 112 #ifndef ARCH3264
 113 # define LDI_FIELD(ldi, arch64, field) (ldi)->l32.ldinfo_##field
 114 #else
 115 # define LDI_FIELD(ldi, arch64, field) \
 116   (arch64 ? (ldi)->l64.ldinfo_##field : (ldi)->l32.ldinfo_##field)
 117 #endif
 118
 119 /* Return various LDI fields for a 64-bit process if ARCH64 and for a 32-bit
 120    process otherwise. */
 121
 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)
 125
 126 extern struct vmap *map_vmap (bfd * bf, bfd * arch);
 127
 128 extern struct target_ops exec_ops;
 129
 130 static void vmap_exec (void);
 131
 132 static void vmap_ldinfo (LdInfo *);
 133
 134 static struct vmap *add_vmap (LdInfo *);
 135
 136 static int objfile_symbol_add (void *);
 137
 138 static void vmap_symtab (struct vmap *);
 139
 140 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
 141
 142 static void exec_one_dummy_insn (void);
 143
 144 extern void
 145 fixup_breakpoints (CORE_ADDR low, CORE_ADDR high, CORE_ADDR delta);
 146
 147 /* Conversion from gdb-to-system special purpose register numbers. */
 148
 149 static int special_regs[] =
 150 {
 151   IAR,                          /* PC_REGNUM    */
 152   MSR,                          /* PS_REGNUM    */
 153   CR,                           /* CR_REGNUM    */
 154   LR,                           /* LR_REGNUM    */
 155   CTR,                          /* CTR_REGNUM   */
 156   XER,                          /* XER_REGNUM   */
 157   MQ                            /* MQ_REGNUM    */
 158 };
 159
 160 /* Call ptrace(REQ, ID, ADDR, DATA, BUF). */
 161
 162 static int
 163 rs6000_ptrace32 (int req, int id, int *addr, int data, int *buf)
 164 {
 165   int ret = ptrace (req, id, (int *)addr, data, buf);
 166 #if 0
 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);
 169 #endif
 170   return ret;
 171 }
 172
 173 /* Call ptracex(REQ, ID, ADDR, DATA, BUF). */
 174
 175 static int
 176 rs6000_ptrace64 (int req, int id, long long addr, int data, int *buf)
 177 {
 178 #ifdef ARCH3264
 179   int ret = ptracex (req, id, addr, data, buf);
 180 #else
 181   int ret = 0;
 182 #endif
 183 #if 0
 184   printf ("rs6000_ptrace64 (%d, %d, 0x%llx, %08x, 0x%x) = 0x%x\n",
 185           req, id, addr, data, (unsigned int)buf, ret);
 186 #endif
 187   return ret;
 188 }
 189
 190 /* Fetch register REGNO from the inferior. */
 191
 192 static void
 193 fetch_register (int regno)
 194 {
 195   int *addr = (int *) &registers[REGISTER_BYTE (regno)];
 196   int nr;
 197
 198   /* Retrieved values may be -1, so infer errors from errno. */
 199   errno = 0;
 200
 201   /* Floating-point registers. */
 202   if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
 203     {
 204       nr = regno - FP0_REGNUM + FPR0;
 205       rs6000_ptrace32 (PT_READ_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 206     }
 207
 208   /* Bogus register number. */
 209   else if (regno > LAST_UISA_SP_REGNUM)
 210     {
 211       if (regno >= NUM_REGS)
 212         fprintf_unfiltered (gdb_stderr,
 213                             "gdb error: register no %d not implemented.\n",
 214                             regno);
 215     }
 216
 217   /* Fixed-point registers. */
 218   else
 219     {
 220       if (regno >= FIRST_UISA_SP_REGNUM)
 221         nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
 222       else
 223         nr = regno;
 224
 225       if (!ARCH64 ())
 226         *addr = rs6000_ptrace32 (PT_READ_GPR, PIDGET (inferior_ptid), (int *)nr, 0, 0);
 227       else
 228         {
 229           /* PT_READ_GPR requires the buffer parameter to point to long long,
 230              even if the register is really only 32 bits. */
 231           long long buf;
 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);
 235           else
 236             *addr = buf;
 237         }
 238     }
 239
 240   if (!errno)
 241     register_valid[regno] = 1;
 242   else
 243     {
 244 #if 0
 245       /* FIXME: this happens 3 times at the start of each 64-bit program. */
 246       perror ("ptrace read");
 247 #endif
 248       errno = 0;
 249     }
 250 }
 251
 252 /* Store register REGNO back into the inferior. */
 253
 254 static void
 255 store_register (int regno)
 256 {
 257   int *addr = (int *) &registers[REGISTER_BYTE (regno)];
 258   int nr;
 259
 260   /* -1 can be a successful return value, so infer errors from errno. */
 261   errno = 0;
 262
 263   /* Floating-point registers. */
 264   if (regno >= FP0_REGNUM && regno <= FPLAST_REGNUM)
 265     {
 266       nr = regno - FP0_REGNUM + FPR0;
 267       rs6000_ptrace32 (PT_WRITE_FPR, PIDGET (inferior_ptid), addr, nr, 0);
 268     }
 269
 270   /* Bogus register number. */
 271   else if (regno > LAST_UISA_SP_REGNUM)
 272     {
 273       if (regno >= NUM_REGS)
 274         fprintf_unfiltered (gdb_stderr,
 275                             "gdb error: register no %d not implemented.\n",
 276                             regno);
 277     }
 278
 279   /* Fixed-point registers. */
 280   else
 281     {
 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
 287            (%sp). */
 288         exec_one_dummy_insn ();
 289
 290       if (regno >= FIRST_UISA_SP_REGNUM)
 291         nr = special_regs[regno - FIRST_UISA_SP_REGNUM];
 292       else
 293         nr = regno;
 294
 295       if (!ARCH64 ())
 296         rs6000_ptrace32 (PT_WRITE_GPR, PIDGET (inferior_ptid), (int *)nr, *addr, 0);
 297       else
 298         {
 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. */
 301           long long buf;
 302           if (REGISTER_RAW_SIZE (regno) == 8)
 303             memcpy (&buf, addr, 8);
 304           else
 305             buf = *addr;
 306           rs6000_ptrace64 (PT_WRITE_GPR, PIDGET (inferior_ptid), nr, 0, (int *)&buf);
 307         }
 308     }
 309
 310   if (errno)
 311     {
 312       perror ("ptrace write");
 313       errno = 0;
 314     }
 315 }
 316
 317 /* Read from the inferior all registers if REGNO == -1 and just register
 318    REGNO otherwise. */
 319
 320 void
 321 fetch_inferior_registers (int regno)
 322 {
 323   if (regno != -1)
 324     fetch_register (regno);
 325
 326   else
 327     {
 328       /* read 32 general purpose registers. */
 329       for (regno = 0; regno < 32; regno++)
 330         fetch_register (regno);
 331
 332       /* read general purpose floating point registers. */
 333       for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
 334         fetch_register (regno);
 335
 336       /* read special registers. */
 337       for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++)
 338         fetch_register (regno);
 339     }
 340 }
 341
 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).  */
 345
 346 void
 347 store_inferior_registers (int regno)
 348 {
 349   if (regno != -1)
 350     store_register (regno);
 351
 352   else
 353     {
 354       /* write general purpose registers first! */
 355       for (regno = GPR0; regno <= GPR31; regno++)
 356         store_register (regno);
 357
 358       /* write floating point registers now. */
 359       for (regno = FP0_REGNUM; regno <= FPLAST_REGNUM; regno++)
 360         store_register (regno);
 361
 362       /* write special registers. */
 363
 364       for (regno = FIRST_UISA_SP_REGNUM; regno <= LAST_UISA_SP_REGNUM; regno++)
 365         store_register (regno);
 366     }
 367 }
 368
 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
 371    success. */
 372
 373 static int
 374 read_word (CORE_ADDR from, int *to, int arch64)
 375 {
 376   /* Retrieved values may be -1, so infer errors from errno. */
 377   errno = 0;
 378
 379   if (arch64)
 380     *to = rs6000_ptrace64 (PT_READ_I, PIDGET (inferior_ptid), from, 0, NULL);
 381   else
 382     *to = rs6000_ptrace32 (PT_READ_I, PIDGET (inferior_ptid), (int *)(long) from,
 383                     0, NULL);
 384
 385   return !errno;
 386 }
 387
 388 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 389    to debugger memory starting at MYADDR.  Copy to inferior if
 390    WRITE is nonzero.
 391
 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
 395    anyway.  */
 396
 397 int
 398 child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
 399                    int write, struct mem_attrib *attrib,
 400                    struct target_ops *target)
 401 {
 402   /* Round starting address down to 32-bit word boundary. */
 403   int mask = sizeof (int) - 1;
 404   CORE_ADDR addr = memaddr & ~(CORE_ADDR)mask;
 405
 406   /* Round ending address up to 32-bit word boundary. */
 407   int count = ((memaddr + len - addr + mask) & ~(CORE_ADDR)mask)
 408     / sizeof (int);
 409
 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));
 415
 416   int arch64 = ARCH64 ();
 417   int i;
 418
 419   if (!write)
 420     {
 421       /* Retrieve memory a word at a time. */
 422       for (i = 0; i < count; i++, addr += sizeof (int))
 423         {
 424           if (!read_word (addr, buf + i, arch64))
 425             return 0;
 426           QUIT;
 427         }
 428
 429       /* Copy memory to supplied buffer. */
 430       addr -= count * sizeof (int);
 431       memcpy (myaddr, (char *)buf + (memaddr - addr), len);
 432     }
 433   else
 434     {
 435       /* Fetch leading memory needed for alignment. */
 436       if (addr < memaddr)
 437         if (!read_word (addr, buf, arch64))
 438           return 0;
 439
 440       /* Fetch trailing memory needed for alignment. */
 441       if (addr + count * sizeof (int) > memaddr + len)
 442         if (!read_word (addr, buf + count - 1, arch64))
 443           return 0;
 444
 445       /* Copy supplied data into memory buffer. */
 446       memcpy ((char *)buf + (memaddr - addr), myaddr, len);
 447
 448       /* Store memory one word at a time. */
 449       for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
 450         {
 451           if (arch64)
 452             rs6000_ptrace64 (PT_WRITE_D, PIDGET (inferior_ptid), addr, buf[i], NULL);
 453           else
 454             rs6000_ptrace32 (PT_WRITE_D, PIDGET (inferior_ptid), (int *)(long) addr,
 455                       buf[i], NULL);
 456
 457           if (errno)
 458             return 0;
 459           QUIT;
 460         }
 461     }
 462
 463   return len;
 464 }
 465
 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,
 468    including u_area. */
 469
 470 static void
 471 exec_one_dummy_insn (void)
 472 {
 473 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
 474
 475   char shadow_contents[BREAKPOINT_MAX];         /* Stash old bkpt addr contents */
 476   int ret, status, pid;
 477   CORE_ADDR prev_pc;
 478
 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
 481      code. */
 482
 483   target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
 484
 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);
 492   if (ARCH64 ())
 493     ret = rs6000_ptrace64 (PT_CONTINUE, PIDGET (inferior_ptid), 1, 0, NULL);
 494   else
 495     ret = rs6000_ptrace32 (PT_CONTINUE, PIDGET (inferior_ptid), (int *)1, 0, NULL);
 496
 497   if (ret != 0)
 498     perror ("pt_continue");
 499
 500   do
 501     {
 502       pid = wait (&status);
 503     }
 504   while (pid != PIDGET (inferior_ptid));
 505
 506   write_pc (prev_pc);
 507   target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
 508 }
 509
 510 /* Fetch registers from the register section in core bfd. */
 511
 512 static void
 513 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
 514                       int which, CORE_ADDR reg_addr)
 515 {
 516   CoreRegs *regs;
 517   double *fprs;
 518   int arch64, i, size;
 519   void *gprs, *sprs[7];
 520
 521   if (which != 0)
 522     {
 523       fprintf_unfiltered
 524         (gdb_stderr,
 525          "Gdb error: unknown parameter to fetch_core_registers().\n");
 526       return;
 527     }
 528
 529   arch64 = ARCH64 ();
 530   regs = (CoreRegs *) core_reg_sect;
 531
 532   /* Retrieve register pointers. */
 533
 534   if (arch64)
 535     {
 536       gprs = regs->r64.gpr;
 537       fprs = regs->r64.fpr;
 538       sprs[0] = &regs->r64.iar;
 539       sprs[1] = &regs->r64.msr;
 540       sprs[2] = &regs->r64.cr;
 541       sprs[3] = &regs->r64.lr;
 542       sprs[4] = &regs->r64.ctr;
 543       sprs[5] = &regs->r64.xer;
 544     }
 545   else
 546     {
 547       gprs = regs->r32.gpr;
 548       fprs = regs->r32.fpr;
 549       sprs[0] = &regs->r32.iar;
 550       sprs[1] = &regs->r32.msr;
 551       sprs[2] = &regs->r32.cr;
 552       sprs[3] = &regs->r32.lr;
 553       sprs[4] = &regs->r32.ctr;
 554       sprs[5] = &regs->r32.xer;
 555       sprs[6] = &regs->r32.mq;
 556     }
 557
 558   /* Copy from pointers to registers[]. */
 559
 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++)
 563     {
 564       size = REGISTER_RAW_SIZE (i);
 565       if (size)
 566         memcpy (registers + REGISTER_BYTE (i),
 567                 sprs[i - FIRST_UISA_SP_REGNUM], size);
 568     }
 569 }
 570 \f
 571
 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. */
 574
 575 static void
 576 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
 577 {
 578   if (arch64)
 579     {
 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;
 584     }
 585   else
 586     {
 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;
 591     }
 592
 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;
 598 }
 599
 600 /* handle symbol translation on vmapping */
 601
 602 static void
 603 vmap_symtab (struct vmap *vp)
 604 {
 605   register struct objfile *objfile;
 606   struct section_offsets *new_offsets;
 607   int i;
 608
 609   objfile = vp->objfile;
 610   if (objfile == NULL)
 611     {
 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)
 616         return;
 617       objfile = symfile_objfile;
 618     }
 619   else if (!vp->loaded)
 620     /* If symbols are not yet loaded, offsets are not yet valid. */
 621     return;
 622
 623   new_offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
 624
 625   for (i = 0; i < objfile->num_sections; ++i)
 626     new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
 627
 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;
 633
 634   objfile_relocate (objfile, new_offsets);
 635 }
 636 \f
 637 /* Add symbols for an objfile.  */
 638
 639 static int
 640 objfile_symbol_add (void *arg)
 641 {
 642   struct objfile *obj = (struct objfile *) arg;
 643
 644   syms_from_objfile (obj, NULL, 0, 0);
 645   new_symfile_objfile (obj, 0, 0);
 646   return 1;
 647 }
 648
 649 /* Add symbols for a vmap. Return zero upon error.  */
 650
 651 int
 652 vmap_add_symbols (struct vmap *vp)
 653 {
 654   if (catch_errors (objfile_symbol_add, vp->objfile,
 655                     "Error while reading shared library symbols:\n",
 656                     RETURN_MASK_ALL))
 657     {
 658       /* Note this is only done if symbol reading was successful.  */
 659       vp->loaded = 1;
 660       vmap_symtab (vp);
 661       return 1;
 662     }
 663   return 0;
 664 }
 665
 666 /* Add a new vmap entry based on ldinfo() information.
 667
 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.
 670
 671    Return the vmap new entry.  */
 672
 673 static struct vmap *
 674 add_vmap (LdInfo *ldi)
 675 {
 676   bfd *abfd, *last;
 677   register char *mem, *objname, *filename;
 678   struct objfile *obj;
 679   struct vmap *vp;
 680   int fd;
 681   ARCH64_DECL (arch64);
 682
 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. */
 686
 687   filename = LDI_FILENAME (ldi, arch64);
 688   mem = filename + strlen (filename) + 1;
 689   mem = savestring (mem, strlen (mem));
 690   objname = savestring (filename, strlen (filename));
 691
 692   fd = LDI_FD (ldi, arch64);
 693   if (fd < 0)
 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);
 697   else
 698     abfd = bfd_fdopenr (objname, gnutarget, fd);
 699   if (!abfd)
 700     {
 701       warning ("Could not open `%s' as an executable file: %s",
 702                objname, bfd_errmsg (bfd_get_error ()));
 703       return NULL;
 704     }
 705
 706   /* make sure we have an object file */
 707
 708   if (bfd_check_format (abfd, bfd_object))
 709     vp = map_vmap (abfd, 0);
 710
 711   else if (bfd_check_format (abfd, bfd_archive))
 712     {
 713       last = 0;
 714       /* FIXME??? am I tossing BFDs?  bfd? */
 715       while ((last = bfd_openr_next_archived_file (abfd, last)))
 716         if (STREQ (mem, last->filename))
 717           break;
 718
 719       if (!last)
 720         {
 721           warning ("\"%s\": member \"%s\" missing.", objname, mem);
 722           bfd_close (abfd);
 723           return NULL;
 724         }
 725
 726       if (!bfd_check_format (last, bfd_object))
 727         {
 728           warning ("\"%s\": member \"%s\" not in executable format: %s.",
 729                    objname, mem, bfd_errmsg (bfd_get_error ()));
 730           bfd_close (last);
 731           bfd_close (abfd);
 732           return NULL;
 733         }
 734
 735       vp = map_vmap (last, abfd);
 736     }
 737   else
 738     {
 739       warning ("\"%s\": not in executable format: %s.",
 740                objname, bfd_errmsg (bfd_get_error ()));
 741       bfd_close (abfd);
 742       return NULL;
 743     }
 744   obj = allocate_objfile (vp->bfd, 0);
 745   vp->objfile = obj;
 746
 747   /* Always add symbols for the main objfile.  */
 748   if (vp == vmap || auto_solib_add)
 749     vmap_add_symbols (vp);
 750   return vp;
 751 }
 752 \f
 753 /* update VMAP info with ldinfo() information
 754    Input is ptr to ldinfo() results.  */
 755
 756 static void
 757 vmap_ldinfo (LdInfo *ldi)
 758 {
 759   struct stat ii, vi;
 760   register struct vmap *vp;
 761   int got_one, retried;
 762   int got_exec_file = 0;
 763   uint next;
 764   int arch64 = ARCH64 ();
 765
 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.  */
 769
 770   do
 771     {
 772       char *name = LDI_FILENAME (ldi, arch64);
 773       char *memb = name + strlen (name) + 1;
 774       int fd = LDI_FD (ldi, arch64);
 775
 776       retried = 0;
 777
 778       if (fstat (fd, &ii) < 0)
 779         {
 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",
 784                    name, fd);
 785           continue;
 786         }
 787     retry:
 788       for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
 789         {
 790           struct objfile *objfile;
 791
 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... */
 797
 798           /* The filenames are not always sufficient to match on. */
 799
 800           if ((name[0] == '/' && !STREQ (name, vp->name))
 801               || (memb[0] && !STREQ (memb, vp->member)))
 802             continue;
 803
 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;
 808           if (objfile == NULL
 809               || objfile->obfd == NULL
 810               || bfd_stat (objfile->obfd, &vi) < 0)
 811             {
 812               warning ("Unable to stat %s, keeping its symbols", name);
 813               continue;
 814             }
 815
 816           if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
 817             continue;
 818
 819           if (!retried)
 820             close (fd);
 821
 822           ++got_one;
 823
 824           /* Found a corresponding VMAP.  Remap!  */
 825
 826           vmap_secs (vp, ldi, arch64);
 827
 828           /* The objfile is only NULL for the exec file.  */
 829           if (vp->objfile == NULL)
 830             got_exec_file = 1;
 831
 832           /* relocate symbol table(s). */
 833           vmap_symtab (vp);
 834
 835           /* Announce new object files.  Doing this after symbol relocation
 836              makes aix-thread.c's job easier. */
 837           if (target_new_objfile_hook && vp->objfile)
 838             target_new_objfile_hook (vp->objfile);
 839
 840           /* There may be more, so we don't break out of the loop.  */
 841         }
 842
 843       /* if there was no matching *vp, we must perforce create the sucker(s) */
 844       if (!got_one && !retried)
 845         {
 846           add_vmap (ldi);
 847           ++retried;
 848           goto retry;
 849         }
 850     }
 851   while ((next = LDI_NEXT (ldi, arch64))
 852          && (ldi = (void *) (next + (char *) ldi)));
 853
 854   /* If we don't find the symfile_objfile anywhere in the ldinfo, it
 855      is unlikely that the symbol file is relocated to the proper
 856      address.  And we might have attached to a process which is
 857      running a different copy of the same executable.  */
 858   if (symfile_objfile != NULL && !got_exec_file)
 859     {
 860       warning ("Symbol file %s\nis not mapped; discarding it.\n\
 861 If in fact that file has symbols which the mapped files listed by\n\
 862 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
 863 \"add-symbol-file\" commands (note that you must take care of relocating\n\
 864 symbols to the proper address).",
 865                symfile_objfile->name);
 866       free_objfile (symfile_objfile);
 867       symfile_objfile = NULL;
 868     }
 869   breakpoint_re_set ();
 870 }
 871 \f
 872 /* As well as symbol tables, exec_sections need relocation. After
 873    the inferior process' termination, there will be a relocated symbol
 874    table exist with no corresponding inferior process. At that time, we
 875    need to use `exec' bfd, rather than the inferior process's memory space
 876    to look up symbols.
 877
 878    `exec_sections' need to be relocated only once, as long as the exec
 879    file remains unchanged.
 880  */
 881
 882 static void
 883 vmap_exec (void)
 884 {
 885   static bfd *execbfd;
 886   int i;
 887
 888   if (execbfd == exec_bfd)
 889     return;
 890
 891   execbfd = exec_bfd;
 892
 893   if (!vmap || !exec_ops.to_sections)
 894     error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
 895
 896   for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
 897     {
 898       if (STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
 899         {
 900           exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
 901           exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
 902         }
 903       else if (STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
 904         {
 905           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 906           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 907         }
 908       else if (STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
 909         {
 910           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 911           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 912         }
 913     }
 914 }
 915
 916 /* Set the current architecture from the host running GDB.  Called when
 917    starting a child process. */
 918
 919 static void
 920 set_host_arch (int pid)
 921 {
 922   enum bfd_architecture arch;
 923   unsigned long mach;
 924   bfd abfd;
 925   struct gdbarch_info info;
 926
 927   if (__power_rs ())
 928     {
 929       arch = bfd_arch_rs6000;
 930       mach = bfd_mach_rs6k;
 931     }
 932   else
 933     {
 934       arch = bfd_arch_powerpc;
 935       mach = bfd_mach_ppc;
 936     }
 937
 938   /* FIXME: schauer/2002-02-25:
 939      We don't know if we are executing a 32 or 64 bit executable,
 940      and have no way to pass the proper word size to rs6000_gdbarch_init.
 941      So we have to avoid switching to a new architecture, if the architecture
 942      matches already.
 943      Blindly calling rs6000_gdbarch_init used to work in older versions of
 944      GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
 945      determine the wordsize.  */
 946   if (exec_bfd)
 947     {
 948       const struct bfd_arch_info *exec_bfd_arch_info;
 949
 950       exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
 951       if (arch == exec_bfd_arch_info->arch)
 952         return;
 953     }
 954
 955   bfd_default_set_arch_mach (&abfd, arch, mach);
 956
 957   gdbarch_info_init (&info);
 958   info.bfd_arch_info = bfd_get_arch_info (&abfd);
 959
 960   if (!gdbarch_update_p (info))
 961     {
 962       internal_error (__FILE__, __LINE__,
 963                       "set_host_arch: failed to select architecture");
 964     }
 965 }
 966
 967 \f
 968 /* xcoff_relocate_symtab -      hook for symbol table relocation.
 969    also reads shared libraries.. */
 970
 971 void
 972 xcoff_relocate_symtab (unsigned int pid)
 973 {
 974   int load_segs = 64; /* number of load segments */
 975   int rc;
 976   LdInfo *ldi = NULL;
 977   int arch64 = ARCH64 ();
 978   int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
 979   int size;
 980
 981   do
 982     {
 983       size = load_segs * ldisize;
 984       ldi = (void *) xrealloc (ldi, size);
 985
 986 #if 0
 987       /* According to my humble theory, AIX has some timing problems and
 988          when the user stack grows, kernel doesn't update stack info in time
 989          and ptrace calls step on user stack. That is why we sleep here a
 990          little, and give kernel to update its internals. */
 991       usleep (36000);
 992 #endif
 993
 994       if (arch64)
 995         rc = rs6000_ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
 996       else
 997         rc = rs6000_ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
 998
 999       if (rc == -1)
1000         {
1001           if (errno == ENOMEM)
1002             load_segs *= 2;
1003           else
1004             perror_with_name ("ptrace ldinfo");
1005         }
1006       else
1007         {
1008           vmap_ldinfo (ldi);
1009           vmap_exec (); /* relocate the exec and core sections as well. */
1010         }
1011     } while (rc == -1);
1012   if (ldi)
1013     xfree (ldi);
1014 }
1015 \f
1016 /* Core file stuff.  */
1017
1018 /* Relocate symtabs and read in shared library info, based on symbols
1019    from the core file.  */
1020
1021 void
1022 xcoff_relocate_core (struct target_ops *target)
1023 {
1024   sec_ptr ldinfo_sec;
1025   int offset = 0;
1026   LdInfo *ldi;
1027   struct vmap *vp;
1028   int arch64 = ARCH64 ();
1029
1030   /* Size of a struct ld_info except for the variable-length filename. */
1031   int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1032
1033   /* Allocated size of buffer.  */
1034   int buffer_size = nonfilesz;
1035   char *buffer = xmalloc (buffer_size);
1036   struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1037
1038   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1039   if (ldinfo_sec == NULL)
1040     {
1041     bfd_err:
1042       fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1043                         bfd_errmsg (bfd_get_error ()));
1044       do_cleanups (old);
1045       return;
1046     }
1047   do
1048     {
1049       int i;
1050       int names_found = 0;
1051
1052       /* Read in everything but the name.  */
1053       if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1054                                     offset, nonfilesz) == 0)
1055         goto bfd_err;
1056
1057       /* Now the name.  */
1058       i = nonfilesz;
1059       do
1060         {
1061           if (i == buffer_size)
1062             {
1063               buffer_size *= 2;
1064               buffer = xrealloc (buffer, buffer_size);
1065             }
1066           if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1067                                         offset + i, 1) == 0)
1068             goto bfd_err;
1069           if (buffer[i++] == '\0')
1070             ++names_found;
1071         }
1072       while (names_found < 2);
1073
1074       ldi = (LdInfo *) buffer;
1075
1076       /* Can't use a file descriptor from the core file; need to open it.  */
1077       if (arch64)
1078         ldi->l64.ldinfo_fd = -1;
1079       else
1080         ldi->l32.ldinfo_fd = -1;
1081
1082       /* The first ldinfo is for the exec file, allocated elsewhere.  */
1083       if (offset == 0 && vmap != NULL)
1084         vp = vmap;
1085       else
1086         vp = add_vmap (ldi);
1087
1088       /* Process next shared library upon error. */
1089       offset += LDI_NEXT (ldi, arch64);
1090       if (vp == NULL)
1091         continue;
1092
1093       vmap_secs (vp, ldi, arch64);
1094
1095       /* Unless this is the exec file,
1096          add our sections to the section table for the core target.  */
1097       if (vp != vmap)
1098         {
1099           struct section_table *stp;
1100
1101           target_resize_to_sections (target, 2);
1102           stp = target->to_sections_end - 2;
1103
1104           stp->bfd = vp->bfd;
1105           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1106           stp->addr = vp->tstart;
1107           stp->endaddr = vp->tend;
1108           stp++;
1109
1110           stp->bfd = vp->bfd;
1111           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1112           stp->addr = vp->dstart;
1113           stp->endaddr = vp->dend;
1114         }
1115
1116       vmap_symtab (vp);
1117
1118       if (target_new_objfile_hook && vp != vmap && vp->objfile)
1119         target_new_objfile_hook (vp->objfile);
1120     }
1121   while (LDI_NEXT (ldi, arch64) != 0);
1122   vmap_exec ();
1123   breakpoint_re_set ();
1124   do_cleanups (old);
1125 }
1126
1127 int
1128 kernel_u_size (void)
1129 {
1130   return (sizeof (struct user));
1131 }
1132 \f
1133 /* Under AIX, we have to pass the correct TOC pointer to a function
1134    when calling functions in the inferior.
1135    We try to find the relative toc offset of the objfile containing PC
1136    and add the current load address of the data segment from the vmap.  */
1137
1138 static CORE_ADDR
1139 find_toc_address (CORE_ADDR pc)
1140 {
1141   struct vmap *vp;
1142   extern CORE_ADDR get_toc_offset (struct objfile *);   /* xcoffread.c */
1143
1144   for (vp = vmap; vp; vp = vp->nxt)
1145     {
1146       if (pc >= vp->tstart && pc < vp->tend)
1147         {
1148           /* vp->objfile is only NULL for the exec file.  */
1149           return vp->dstart + get_toc_offset (vp->objfile == NULL
1150                                               ? symfile_objfile
1151                                               : vp->objfile);
1152         }
1153     }
1154   error ("Unable to find TOC entry for pc 0x%x\n", pc);
1155 }
1156 \f
1157 /* Register that we are able to handle rs6000 core file formats. */
1158
1159 static struct core_fns rs6000_core_fns =
1160 {
1161   bfd_target_xcoff_flavour,             /* core_flavour */
1162   default_check_format,                 /* check_format */
1163   default_core_sniffer,                 /* core_sniffer */
1164   fetch_core_registers,                 /* core_read_registers */
1165   NULL                                  /* next */
1166 };
1167
1168 void
1169 _initialize_core_rs6000 (void)
1170 {
1171   /* Initialize hook in rs6000-tdep.c for determining the TOC address when
1172      calling functions in the inferior.  */
1173   rs6000_find_toc_address_hook = find_toc_address;
1174
1175   /* Initialize hook in rs6000-tdep.c to set the current architecture when
1176      starting a child process. */
1177   rs6000_set_host_arch_hook = set_host_arch;
1178
1179   add_core_fns (&rs6000_core_fns);
1180 }