gdb/rs6000-nat.c

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