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