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, inferior_pid, 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, inferior_pid, (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, inferior_pid, 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, inferior_pid, 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, inferior_pid, (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, inferior_pid, 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, inferior_pid, from, 0, NULL);
 377   else
 378     *to = ptrace32 (PT_READ_I, inferior_pid, (int *)(long) from, 0, NULL);
 379
 380   return !errno;
 381 }
 382
 383 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 384    to debugger memory starting at MYADDR.  Copy to inferior if
 385    WRITE is nonzero.
 386
 387    Returns the length copied, which is either the LEN argument or zero.
 388    This xfer function does not do partial moves, since child_ops
 389    doesn't allow memory operations to cross below us in the target stack
 390    anyway.  */
 391
 392 int
 393 child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
 394                    int write, struct mem_attrib *attrib,
 395                    struct target_ops *target)
 396 {
 397   /* Round starting address down to 32-bit word boundary. */
 398   int mask = sizeof (int) - 1;
 399   CORE_ADDR addr = memaddr & ~(CORE_ADDR)mask;
 400
 401   /* Round ending address up to 32-bit word boundary. */
 402   int count = ((memaddr + len - addr + mask) & ~(CORE_ADDR)mask)
 403     / sizeof (int);
 404
 405   /* Allocate word transfer buffer. */
 406   int *buf = (int *) alloca (count * sizeof (int));
 407
 408   int arch64 = ARCH64 ();
 409   int i;
 410
 411   if (!write)
 412     {
 413       /* Retrieve memory a word at a time. */
 414       for (i = 0; i < count; i++, addr += sizeof (int))
 415         {
 416           if (!read_word (addr, buf + i, arch64))
 417             return 0;
 418           QUIT;
 419         }
 420
 421       /* Copy memory to supplied buffer. */
 422       addr -= count * sizeof (int);
 423       memcpy (myaddr, (char *)buf + (memaddr - addr), len);
 424     }
 425   else
 426     {
 427       /* Fetch leading memory needed for alignment. */
 428       if (addr < memaddr)
 429         if (!read_word (addr, buf, arch64))
 430           return 0;
 431
 432       /* Fetch trailing memory needed for alignment. */
 433       if (addr + count * sizeof (int) > memaddr + len)
 434         if (!read_word (addr, buf + count - 1, arch64))
 435           return 0;
 436
 437       /* Copy supplied data into memory buffer. */
 438       memcpy ((char *)buf + (memaddr - addr), myaddr, len);
 439
 440       /* Store memory one word at a time. */
 441       for (i = 0, errno = 0; i < count; i++, addr += sizeof (int))
 442         {
 443           if (arch64)
 444             ptrace64 (PT_WRITE_D, inferior_pid, addr, buf[i], NULL);
 445           else
 446             ptrace32 (PT_WRITE_D, inferior_pid, (int *)(long) addr,
 447                       buf[i], NULL);
 448
 449           if (errno)
 450             return 0;
 451           QUIT;
 452         }
 453     }
 454
 455   return len;
 456 }
 457
 458 /* Execute one dummy breakpoint instruction.  This way we give the kernel
 459    a chance to do some housekeeping and update inferior's internal data,
 460    including u_area. */
 461
 462 static void
 463 exec_one_dummy_insn (void)
 464 {
 465 #define DUMMY_INSN_ADDR (TEXT_SEGMENT_BASE)+0x200
 466
 467   char shadow_contents[BREAKPOINT_MAX];         /* Stash old bkpt addr contents */
 468   int ret, status, pid;
 469   CORE_ADDR prev_pc;
 470
 471   /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We
 472      assume that this address will never be executed again by the real
 473      code. */
 474
 475   target_insert_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
 476
 477   /* You might think this could be done with a single ptrace call, and
 478      you'd be correct for just about every platform I've ever worked
 479      on.  However, rs6000-ibm-aix4.1.3 seems to have screwed this up --
 480      the inferior never hits the breakpoint (it's also worth noting
 481      powerpc-ibm-aix4.1.3 works correctly).  */
 482   prev_pc = read_pc ();
 483   write_pc (DUMMY_INSN_ADDR);
 484   if (ARCH64 ())
 485     ret = ptrace64 (PT_CONTINUE, inferior_pid, 1, 0, NULL);
 486   else
 487     ret = ptrace32 (PT_CONTINUE, inferior_pid, (int *)1, 0, NULL);
 488
 489   if (ret != 0)
 490     perror ("pt_continue");
 491
 492   do
 493     {
 494       pid = wait (&status);
 495     }
 496   while (pid != inferior_pid);
 497
 498   write_pc (prev_pc);
 499   target_remove_breakpoint (DUMMY_INSN_ADDR, shadow_contents);
 500 }
 501
 502 /* Fetch registers from the register section in core bfd. */
 503
 504 static void
 505 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
 506                       int which, CORE_ADDR reg_addr)
 507 {
 508   CoreRegs *regs;
 509   double *fprs;
 510   int arch64, i, size;
 511   void *gprs, *sprs[7];
 512
 513   if (which != 0)
 514     {
 515       fprintf_unfiltered
 516         (gdb_stderr,
 517          "Gdb error: unknown parameter to fetch_core_registers().\n");
 518       return;
 519     }
 520
 521   arch64 = ARCH64 ();
 522   regs = (CoreRegs *) core_reg_sect;
 523
 524   /* Retrieve register pointers. */
 525
 526   if (arch64)
 527     {
 528       gprs = regs->r64.gpr;
 529       fprs = regs->r64.fpr;
 530       sprs[0] = &regs->r64.iar;
 531       sprs[1] = &regs->r64.msr;
 532       sprs[2] = &regs->r64.cr;
 533       sprs[3] = &regs->r64.lr;
 534       sprs[4] = &regs->r64.ctr;
 535       sprs[5] = &regs->r64.xer;
 536     }
 537   else
 538     {
 539       gprs = regs->r32.gpr;
 540       fprs = regs->r32.fpr;
 541       sprs[0] = &regs->r32.iar;
 542       sprs[1] = &regs->r32.msr;
 543       sprs[2] = &regs->r32.cr;
 544       sprs[3] = &regs->r32.lr;
 545       sprs[4] = &regs->r32.ctr;
 546       sprs[5] = &regs->r32.xer;
 547       sprs[6] = &regs->r32.mq;
 548     }
 549
 550   /* Copy from pointers to registers[]. */
 551
 552   memcpy (registers, gprs, 32 * (arch64 ? 8 : 4));
 553   memcpy (registers + REGISTER_BYTE (FP0_REGNUM), fprs, 32 * 8);
 554   for (i = FIRST_UISA_SP_REGNUM; i <= LAST_UISA_SP_REGNUM; i++)
 555     {
 556       size = REGISTER_RAW_SIZE (i);
 557       if (size)
 558         memcpy (registers + REGISTER_BYTE (i),
 559                 sprs[i - FIRST_UISA_SP_REGNUM], size);
 560     }
 561 }
 562 \f
 563
 564 /* Copy information about text and data sections from LDI to VP for a 64-bit
 565    process if ARCH64 and for a 32-bit process otherwise. */
 566
 567 static void
 568 vmap_secs (struct vmap *vp, LdInfo *ldi, int arch64)
 569 {
 570   if (arch64)
 571     {
 572       vp->tstart = (CORE_ADDR) ldi->l64.ldinfo_textorg;
 573       vp->tend = vp->tstart + ldi->l64.ldinfo_textsize;
 574       vp->dstart = (CORE_ADDR) ldi->l64.ldinfo_dataorg;
 575       vp->dend = vp->dstart + ldi->l64.ldinfo_datasize;
 576     }
 577   else
 578     {
 579       vp->tstart = (unsigned long) ldi->l32.ldinfo_textorg;
 580       vp->tend = vp->tstart + ldi->l32.ldinfo_textsize;
 581       vp->dstart = (unsigned long) ldi->l32.ldinfo_dataorg;
 582       vp->dend = vp->dstart + ldi->l32.ldinfo_datasize;
 583     }
 584
 585   /* The run time loader maps the file header in addition to the text
 586      section and returns a pointer to the header in ldinfo_textorg.
 587      Adjust the text start address to point to the real start address
 588      of the text section.  */
 589   vp->tstart += vp->toffs;
 590 }
 591
 592 /* handle symbol translation on vmapping */
 593
 594 static void
 595 vmap_symtab (struct vmap *vp)
 596 {
 597   register struct objfile *objfile;
 598   struct section_offsets *new_offsets;
 599   int i;
 600
 601   objfile = vp->objfile;
 602   if (objfile == NULL)
 603     {
 604       /* OK, it's not an objfile we opened ourselves.
 605          Currently, that can only happen with the exec file, so
 606          relocate the symbols for the symfile.  */
 607       if (symfile_objfile == NULL)
 608         return;
 609       objfile = symfile_objfile;
 610     }
 611   else if (!vp->loaded)
 612     /* If symbols are not yet loaded, offsets are not yet valid. */
 613     return;
 614
 615   new_offsets = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
 616
 617   for (i = 0; i < objfile->num_sections; ++i)
 618     new_offsets->offsets[i] = ANOFFSET (objfile->section_offsets, i);
 619
 620   /* The symbols in the object file are linked to the VMA of the section,
 621      relocate them VMA relative.  */
 622   new_offsets->offsets[SECT_OFF_TEXT (objfile)] = vp->tstart - vp->tvma;
 623   new_offsets->offsets[SECT_OFF_DATA (objfile)] = vp->dstart - vp->dvma;
 624   new_offsets->offsets[SECT_OFF_BSS (objfile)] = vp->dstart - vp->dvma;
 625
 626   objfile_relocate (objfile, new_offsets);
 627 }
 628 \f
 629 /* Add symbols for an objfile.  */
 630
 631 static int
 632 objfile_symbol_add (void *arg)
 633 {
 634   struct objfile *obj = (struct objfile *) arg;
 635
 636   syms_from_objfile (obj, NULL, 0, 0);
 637   new_symfile_objfile (obj, 0, 0);
 638   return 1;
 639 }
 640
 641 /* Add symbols for a vmap. Return zero upon error.  */
 642
 643 int
 644 vmap_add_symbols (struct vmap *vp)
 645 {
 646   if (catch_errors (objfile_symbol_add, vp->objfile,
 647                     "Error while reading shared library symbols:\n",
 648                     RETURN_MASK_ALL))
 649     {
 650       /* Note this is only done if symbol reading was successful.  */
 651       vp->loaded = 1;
 652       vmap_symtab (vp);
 653       return 1;
 654     }
 655   return 0;
 656 }
 657
 658 /* Add a new vmap entry based on ldinfo() information.
 659
 660    If ldi->ldinfo_fd is not valid (e.g. this struct ld_info is from a
 661    core file), the caller should set it to -1, and we will open the file.
 662
 663    Return the vmap new entry.  */
 664
 665 static struct vmap *
 666 add_vmap (LdInfo *ldi)
 667 {
 668   bfd *abfd, *last;
 669   register char *mem, *objname, *filename;
 670   struct objfile *obj;
 671   struct vmap *vp;
 672   int fd;
 673   ARCH64_DECL (arch64);
 674
 675   /* This ldi structure was allocated using alloca() in
 676      xcoff_relocate_symtab(). Now we need to have persistent object
 677      and member names, so we should save them. */
 678
 679   filename = LDI_FILENAME (ldi, arch64);
 680   mem = filename + strlen (filename) + 1;
 681   mem = savestring (mem, strlen (mem));
 682   objname = savestring (filename, strlen (filename));
 683
 684   fd = LDI_FD (ldi, arch64);
 685   if (fd < 0)
 686     /* Note that this opens it once for every member; a possible
 687        enhancement would be to only open it once for every object.  */
 688     abfd = bfd_openr (objname, gnutarget);
 689   else
 690     abfd = bfd_fdopenr (objname, gnutarget, fd);
 691   if (!abfd)
 692     {
 693       warning ("Could not open `%s' as an executable file: %s",
 694                objname, bfd_errmsg (bfd_get_error ()));
 695       return NULL;
 696     }
 697
 698   /* make sure we have an object file */
 699
 700   if (bfd_check_format (abfd, bfd_object))
 701     vp = map_vmap (abfd, 0);
 702
 703   else if (bfd_check_format (abfd, bfd_archive))
 704     {
 705       last = 0;
 706       /* FIXME??? am I tossing BFDs?  bfd? */
 707       while ((last = bfd_openr_next_archived_file (abfd, last)))
 708         if (STREQ (mem, last->filename))
 709           break;
 710
 711       if (!last)
 712         {
 713           warning ("\"%s\": member \"%s\" missing.", objname, mem);
 714           bfd_close (abfd);
 715           return NULL;
 716         }
 717
 718       if (!bfd_check_format (last, bfd_object))
 719         {
 720           warning ("\"%s\": member \"%s\" not in executable format: %s.",
 721                    objname, mem, bfd_errmsg (bfd_get_error ()));
 722           bfd_close (last);
 723           bfd_close (abfd);
 724           return NULL;
 725         }
 726
 727       vp = map_vmap (last, abfd);
 728     }
 729   else
 730     {
 731       warning ("\"%s\": not in executable format: %s.",
 732                objname, bfd_errmsg (bfd_get_error ()));
 733       bfd_close (abfd);
 734       return NULL;
 735     }
 736   obj = allocate_objfile (vp->bfd, 0);
 737   vp->objfile = obj;
 738
 739   /* Always add symbols for the main objfile.  */
 740   if (vp == vmap || auto_solib_add)
 741     vmap_add_symbols (vp);
 742   return vp;
 743 }
 744 \f
 745 /* update VMAP info with ldinfo() information
 746    Input is ptr to ldinfo() results.  */
 747
 748 static void
 749 vmap_ldinfo (LdInfo *ldi)
 750 {
 751   struct stat ii, vi;
 752   register struct vmap *vp;
 753   int got_one, retried;
 754   int got_exec_file = 0;
 755   uint next;
 756   int arch64 = ARCH64 ();
 757
 758   /* For each *ldi, see if we have a corresponding *vp.
 759      If so, update the mapping, and symbol table.
 760      If not, add an entry and symbol table.  */
 761
 762   do
 763     {
 764       char *name = LDI_FILENAME (ldi, arch64);
 765       char *memb = name + strlen (name) + 1;
 766       int fd = LDI_FD (ldi, arch64);
 767
 768       retried = 0;
 769
 770       if (fstat (fd, &ii) < 0)
 771         {
 772           /* The kernel sets ld_info to -1, if the process is still using the
 773              object, and the object is removed. Keep the symbol info for the
 774              removed object and issue a warning.  */
 775           warning ("%s (fd=%d) has disappeared, keeping its symbols",
 776                    name, fd);
 777           continue;
 778         }
 779     retry:
 780       for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
 781         {
 782           struct objfile *objfile;
 783
 784           /* First try to find a `vp', which is the same as in ldinfo.
 785              If not the same, just continue and grep the next `vp'. If same,
 786              relocate its tstart, tend, dstart, dend values. If no such `vp'
 787              found, get out of this for loop, add this ldi entry as a new vmap
 788              (add_vmap) and come back, find its `vp' and so on... */
 789
 790           /* The filenames are not always sufficient to match on. */
 791
 792           if ((name[0] == '/' && !STREQ (name, vp->name))
 793               || (memb[0] && !STREQ (memb, vp->member)))
 794             continue;
 795
 796           /* See if we are referring to the same file.
 797              We have to check objfile->obfd, symfile.c:reread_symbols might
 798              have updated the obfd after a change.  */
 799           objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
 800           if (objfile == NULL
 801               || objfile->obfd == NULL
 802               || bfd_stat (objfile->obfd, &vi) < 0)
 803             {
 804               warning ("Unable to stat %s, keeping its symbols", name);
 805               continue;
 806             }
 807
 808           if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
 809             continue;
 810
 811           if (!retried)
 812             close (fd);
 813
 814           ++got_one;
 815
 816           /* Found a corresponding VMAP.  Remap!  */
 817
 818           vmap_secs (vp, ldi, arch64);
 819
 820           /* The objfile is only NULL for the exec file.  */
 821           if (vp->objfile == NULL)
 822             got_exec_file = 1;
 823
 824           /* relocate symbol table(s). */
 825           vmap_symtab (vp);
 826
 827           /* There may be more, so we don't break out of the loop.  */
 828         }
 829
 830       /* if there was no matching *vp, we must perforce create the sucker(s) */
 831       if (!got_one && !retried)
 832         {
 833           add_vmap (ldi);
 834           ++retried;
 835           goto retry;
 836         }
 837     }
 838   while ((next = LDI_NEXT (ldi, arch64))
 839          && (ldi = (void *) (next + (char *) ldi)));
 840
 841   /* If we don't find the symfile_objfile anywhere in the ldinfo, it
 842      is unlikely that the symbol file is relocated to the proper
 843      address.  And we might have attached to a process which is
 844      running a different copy of the same executable.  */
 845   if (symfile_objfile != NULL && !got_exec_file)
 846     {
 847       warning_begin ();
 848       fputs_unfiltered ("Symbol file ", gdb_stderr);
 849       fputs_unfiltered (symfile_objfile->name, gdb_stderr);
 850       fputs_unfiltered ("\nis not mapped; discarding it.\n\
 851 If in fact that file has symbols which the mapped files listed by\n\
 852 \"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
 853 \"add-symbol-file\" commands (note that you must take care of relocating\n\
 854 symbols to the proper address).\n", gdb_stderr);
 855       free_objfile (symfile_objfile);
 856       symfile_objfile = NULL;
 857     }
 858   breakpoint_re_set ();
 859 }
 860 \f
 861 /* As well as symbol tables, exec_sections need relocation. After
 862    the inferior process' termination, there will be a relocated symbol
 863    table exist with no corresponding inferior process. At that time, we
 864    need to use `exec' bfd, rather than the inferior process's memory space
 865    to look up symbols.
 866
 867    `exec_sections' need to be relocated only once, as long as the exec
 868    file remains unchanged.
 869  */
 870
 871 static void
 872 vmap_exec (void)
 873 {
 874   static bfd *execbfd;
 875   int i;
 876
 877   if (execbfd == exec_bfd)
 878     return;
 879
 880   execbfd = exec_bfd;
 881
 882   if (!vmap || !exec_ops.to_sections)
 883     error ("vmap_exec: vmap or exec_ops.to_sections == 0\n");
 884
 885   for (i = 0; &exec_ops.to_sections[i] < exec_ops.to_sections_end; i++)
 886     {
 887       if (STREQ (".text", exec_ops.to_sections[i].the_bfd_section->name))
 888         {
 889           exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
 890           exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
 891         }
 892       else if (STREQ (".data", exec_ops.to_sections[i].the_bfd_section->name))
 893         {
 894           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 895           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 896         }
 897       else if (STREQ (".bss", exec_ops.to_sections[i].the_bfd_section->name))
 898         {
 899           exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
 900           exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
 901         }
 902     }
 903 }
 904
 905 /* Set the current architecture from the host running GDB.  Called when
 906    starting a child process. */
 907
 908 static void
 909 set_host_arch (int pid)
 910 {
 911   enum bfd_architecture arch;
 912   unsigned long mach;
 913   bfd abfd;
 914   struct gdbarch_info info;
 915
 916   if (__power_rs ())
 917     {
 918       arch = bfd_arch_rs6000;
 919       mach = bfd_mach_rs6k;
 920     }
 921   else
 922     {
 923       arch = bfd_arch_powerpc;
 924       mach = bfd_mach_ppc;
 925     }
 926   bfd_default_set_arch_mach (&abfd, arch, mach);
 927
 928   memset (&info, 0, sizeof info);
 929   info.bfd_arch_info = bfd_get_arch_info (&abfd);
 930
 931   if (!gdbarch_update_p (info))
 932     {
 933       internal_error (__FILE__, __LINE__,
 934                       "set_host_arch: failed to select architecture");
 935     }
 936 }
 937
 938 \f
 939 /* xcoff_relocate_symtab -      hook for symbol table relocation.
 940    also reads shared libraries.. */
 941
 942 void
 943 xcoff_relocate_symtab (unsigned int pid)
 944 {
 945   int load_segs = 64; /* number of load segments */
 946   int rc;
 947   LdInfo *ldi = NULL;
 948   int arch64 = ARCH64 ();
 949   int ldisize = arch64 ? sizeof (ldi->l64) : sizeof (ldi->l32);
 950   int size;
 951
 952   do
 953     {
 954       size = load_segs * ldisize;
 955       ldi = (void *) xrealloc (ldi, size);
 956
 957 #if 0
 958       /* According to my humble theory, AIX has some timing problems and
 959          when the user stack grows, kernel doesn't update stack info in time
 960          and ptrace calls step on user stack. That is why we sleep here a
 961          little, and give kernel to update its internals. */
 962       usleep (36000);
 963 #endif
 964
 965       if (arch64)
 966         rc = ptrace64 (PT_LDINFO, pid, (unsigned long) ldi, size, NULL);
 967       else
 968         rc = ptrace32 (PT_LDINFO, pid, (int *) ldi, size, NULL);
 969
 970       if (rc == -1)
 971         {
 972           if (errno == ENOMEM)
 973             load_segs *= 2;
 974           else
 975             perror_with_name ("ptrace ldinfo");
 976         }
 977       else
 978         {
 979           vmap_ldinfo (ldi);
 980           vmap_exec (); /* relocate the exec and core sections as well. */
 981         }
 982     } while (rc == -1);
 983   if (ldi)
 984     xfree (ldi);
 985 }
 986 \f
 987 /* Core file stuff.  */
 988
 989 /* Relocate symtabs and read in shared library info, based on symbols
 990    from the core file.  */
 991
 992 void
 993 xcoff_relocate_core (struct target_ops *target)
 994 {
 995   sec_ptr ldinfo_sec;
 996   int offset = 0;
 997   LdInfo *ldi;
 998   struct vmap *vp;
 999   int arch64 = ARCH64 ();
1000
1001   /* Size of a struct ld_info except for the variable-length filename. */
1002   int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
1003
1004   /* Allocated size of buffer.  */
1005   int buffer_size = nonfilesz;
1006   char *buffer = xmalloc (buffer_size);
1007   struct cleanup *old = make_cleanup (free_current_contents, &buffer);
1008
1009   ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
1010   if (ldinfo_sec == NULL)
1011     {
1012     bfd_err:
1013       fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
1014                         bfd_errmsg (bfd_get_error ()));
1015       do_cleanups (old);
1016       return;
1017     }
1018   do
1019     {
1020       int i;
1021       int names_found = 0;
1022
1023       /* Read in everything but the name.  */
1024       if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
1025                                     offset, nonfilesz) == 0)
1026         goto bfd_err;
1027
1028       /* Now the name.  */
1029       i = nonfilesz;
1030       do
1031         {
1032           if (i == buffer_size)
1033             {
1034               buffer_size *= 2;
1035               buffer = xrealloc (buffer, buffer_size);
1036             }
1037           if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
1038                                         offset + i, 1) == 0)
1039             goto bfd_err;
1040           if (buffer[i++] == '\0')
1041             ++names_found;
1042         }
1043       while (names_found < 2);
1044
1045       ldi = (LdInfo *) buffer;
1046
1047       /* Can't use a file descriptor from the core file; need to open it.  */
1048       if (arch64)
1049         ldi->l64.ldinfo_fd = -1;
1050       else
1051         ldi->l32.ldinfo_fd = -1;
1052
1053       /* The first ldinfo is for the exec file, allocated elsewhere.  */
1054       if (offset == 0 && vmap != NULL)
1055         vp = vmap;
1056       else
1057         vp = add_vmap (ldi);
1058
1059       /* Process next shared library upon error. */
1060       offset += LDI_NEXT (ldi, arch64);
1061       if (vp == NULL)
1062         continue;
1063
1064       vmap_secs (vp, ldi, arch64);
1065
1066       /* Unless this is the exec file,
1067          add our sections to the section table for the core target.  */
1068       if (vp != vmap)
1069         {
1070           struct section_table *stp;
1071
1072           target_resize_to_sections (target, 2);
1073           stp = target->to_sections_end - 2;
1074
1075           stp->bfd = vp->bfd;
1076           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
1077           stp->addr = vp->tstart;
1078           stp->endaddr = vp->tend;
1079           stp++;
1080
1081           stp->bfd = vp->bfd;
1082           stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
1083           stp->addr = vp->dstart;
1084           stp->endaddr = vp->dend;
1085         }
1086
1087       vmap_symtab (vp);
1088     }
1089   while (LDI_NEXT (ldi, arch64) != 0);
1090   vmap_exec ();
1091   breakpoint_re_set ();
1092   do_cleanups (old);
1093 }
1094
1095 int
1096 kernel_u_size (void)
1097 {
1098   return (sizeof (struct user));
1099 }
1100 \f
1101 /* Under AIX, we have to pass the correct TOC pointer to a function
1102    when calling functions in the inferior.
1103    We try to find the relative toc offset of the objfile containing PC
1104    and add the current load address of the data segment from the vmap.  */
1105
1106 static CORE_ADDR
1107 find_toc_address (CORE_ADDR pc)
1108 {
1109   struct vmap *vp;
1110   extern CORE_ADDR get_toc_offset (struct objfile *);   /* xcoffread.c */
1111
1112   for (vp = vmap; vp; vp = vp->nxt)
1113     {
1114       if (pc >= vp->tstart && pc < vp->tend)
1115         {
1116           /* vp->objfile is only NULL for the exec file.  */
1117           return vp->dstart + get_toc_offset (vp->objfile == NULL
1118                                               ? symfile_objfile
1119                                               : vp->objfile);
1120         }
1121     }
1122   error ("Unable to find TOC entry for pc 0x%x\n", pc);
1123 }
1124 \f
1125 /* Register that we are able to handle rs6000 core file formats. */
1126
1127 static struct core_fns rs6000_core_fns =
1128 {
1129   bfd_target_xcoff_flavour,             /* core_flavour */
1130   default_check_format,                 /* check_format */
1131   default_core_sniffer,                 /* core_sniffer */
1132   fetch_core_registers,                 /* core_read_registers */
1133   NULL                                  /* next */
1134 };
1135
1136 void
1137 _initialize_core_rs6000 (void)
1138 {
1139   /* Initialize hook in rs6000-tdep.c for determining the TOC address when
1140      calling functions in the inferior.  */
1141   rs6000_find_toc_address_hook = find_toc_address;
1142
1143   /* Initialize hook in rs6000-tdep.c to set the current architecture when
1144      starting a child process. */
1145   rs6000_set_host_arch_hook = set_host_arch;
1146
1147   add_core_fns (&rs6000_core_fns);
1148 }