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