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