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