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