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