gdb/rs6000-nat.c

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