gdb/ppc-linux-tdep.c

   1 /* Target-dependent code for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   5    Free Software 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 3 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, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "inferior.h"
  25 #include "symtab.h"
  26 #include "target.h"
  27 #include "gdbcore.h"
  28 #include "gdbcmd.h"
  29 #include "symfile.h"
  30 #include "objfiles.h"
  31 #include "regcache.h"
  32 #include "value.h"
  33 #include "osabi.h"
  34 #include "regset.h"
  35 #include "solib-svr4.h"
  36 #include "ppc-tdep.h"
  37 #include "trad-frame.h"
  38 #include "frame-unwind.h"
  39 #include "tramp-frame.h"
  40
  41 static CORE_ADDR
  42 ppc_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
  43 {
  44   gdb_byte buf[4];
  45   struct obj_section *sect;
  46   struct objfile *objfile;
  47   unsigned long insn;
  48   CORE_ADDR plt_start = 0;
  49   CORE_ADDR symtab = 0;
  50   CORE_ADDR strtab = 0;
  51   int num_slots = -1;
  52   int reloc_index = -1;
  53   CORE_ADDR plt_table;
  54   CORE_ADDR reloc;
  55   CORE_ADDR sym;
  56   long symidx;
  57   char symname[1024];
  58   struct minimal_symbol *msymbol;
  59
  60   /* Find the section pc is in; if not in .plt, try the default method.  */
  61   sect = find_pc_section (pc);
  62   if (!sect || strcmp (sect->the_bfd_section->name, ".plt") != 0)
  63     return find_solib_trampoline_target (frame, pc);
  64
  65   objfile = sect->objfile;
  66
  67   /* Pick up the instruction at pc.  It had better be of the
  68      form
  69      li r11, IDX
  70
  71      where IDX is an index into the plt_table.  */
  72
  73   if (target_read_memory (pc, buf, 4) != 0)
  74     return 0;
  75   insn = extract_unsigned_integer (buf, 4);
  76
  77   if ((insn & 0xffff0000) != 0x39600000 /* li r11, VAL */ )
  78     return 0;
  79
  80   reloc_index = (insn << 16) >> 16;
  81
  82   /* Find the objfile that pc is in and obtain the information
  83      necessary for finding the symbol name. */
  84   for (sect = objfile->sections; sect < objfile->sections_end; ++sect)
  85     {
  86       const char *secname = sect->the_bfd_section->name;
  87       if (strcmp (secname, ".plt") == 0)
  88         plt_start = sect->addr;
  89       else if (strcmp (secname, ".rela.plt") == 0)
  90         num_slots = ((int) sect->endaddr - (int) sect->addr) / 12;
  91       else if (strcmp (secname, ".dynsym") == 0)
  92         symtab = sect->addr;
  93       else if (strcmp (secname, ".dynstr") == 0)
  94         strtab = sect->addr;
  95     }
  96
  97   /* Make sure we have all the information we need. */
  98   if (plt_start == 0 || num_slots == -1 || symtab == 0 || strtab == 0)
  99     return 0;
 100
 101   /* Compute the value of the plt table */
 102   plt_table = plt_start + 72 + 8 * num_slots;
 103
 104   /* Get address of the relocation entry (Elf32_Rela) */
 105   if (target_read_memory (plt_table + reloc_index, buf, 4) != 0)
 106     return 0;
 107   reloc = extract_unsigned_integer (buf, 4);
 108
 109   sect = find_pc_section (reloc);
 110   if (!sect)
 111     return 0;
 112
 113   if (strcmp (sect->the_bfd_section->name, ".text") == 0)
 114     return reloc;
 115
 116   /* Now get the r_info field which is the relocation type and symbol
 117      index. */
 118   if (target_read_memory (reloc + 4, buf, 4) != 0)
 119     return 0;
 120   symidx = extract_unsigned_integer (buf, 4);
 121
 122   /* Shift out the relocation type leaving just the symbol index */
 123   /* symidx = ELF32_R_SYM(symidx); */
 124   symidx = symidx >> 8;
 125
 126   /* compute the address of the symbol */
 127   sym = symtab + symidx * 4;
 128
 129   /* Fetch the string table index */
 130   if (target_read_memory (sym, buf, 4) != 0)
 131     return 0;
 132   symidx = extract_unsigned_integer (buf, 4);
 133
 134   /* Fetch the string; we don't know how long it is.  Is it possible
 135      that the following will fail because we're trying to fetch too
 136      much? */
 137   if (target_read_memory (strtab + symidx, (gdb_byte *) symname,
 138                           sizeof (symname)) != 0)
 139     return 0;
 140
 141   /* This might not work right if we have multiple symbols with the
 142      same name; the only way to really get it right is to perform
 143      the same sort of lookup as the dynamic linker. */
 144   msymbol = lookup_minimal_symbol_text (symname, NULL);
 145   if (!msymbol)
 146     return 0;
 147
 148   return SYMBOL_VALUE_ADDRESS (msymbol);
 149 }
 150
 151 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
 152    in much the same fashion as memory_remove_breakpoint in mem-break.c,
 153    but is careful not to write back the previous contents if the code
 154    in question has changed in between inserting the breakpoint and
 155    removing it.
 156
 157    Here is the problem that we're trying to solve...
 158
 159    Once upon a time, before introducing this function to remove
 160    breakpoints from the inferior, setting a breakpoint on a shared
 161    library function prior to running the program would not work
 162    properly.  In order to understand the problem, it is first
 163    necessary to understand a little bit about dynamic linking on
 164    this platform.
 165
 166    A call to a shared library function is accomplished via a bl
 167    (branch-and-link) instruction whose branch target is an entry
 168    in the procedure linkage table (PLT).  The PLT in the object
 169    file is uninitialized.  To gdb, prior to running the program, the
 170    entries in the PLT are all zeros.
 171
 172    Once the program starts running, the shared libraries are loaded
 173    and the procedure linkage table is initialized, but the entries in
 174    the table are not (necessarily) resolved.  Once a function is
 175    actually called, the code in the PLT is hit and the function is
 176    resolved.  In order to better illustrate this, an example is in
 177    order; the following example is from the gdb testsuite.
 178
 179         We start the program shmain.
 180
 181             [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
 182             [...]
 183
 184         We place two breakpoints, one on shr1 and the other on main.
 185
 186             (gdb) b shr1
 187             Breakpoint 1 at 0x100409d4
 188             (gdb) b main
 189             Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
 190
 191         Examine the instruction (and the immediatly following instruction)
 192         upon which the breakpoint was placed.  Note that the PLT entry
 193         for shr1 contains zeros.
 194
 195             (gdb) x/2i 0x100409d4
 196             0x100409d4 <shr1>:      .long 0x0
 197             0x100409d8 <shr1+4>:    .long 0x0
 198
 199         Now run 'til main.
 200
 201             (gdb) r
 202             Starting program: gdb.base/shmain
 203             Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
 204
 205             Breakpoint 2, main ()
 206                 at gdb.base/shmain.c:44
 207             44        g = 1;
 208
 209         Examine the PLT again.  Note that the loading of the shared
 210         library has initialized the PLT to code which loads a constant
 211         (which I think is an index into the GOT) into r11 and then
 212         branchs a short distance to the code which actually does the
 213         resolving.
 214
 215             (gdb) x/2i 0x100409d4
 216             0x100409d4 <shr1>:      li      r11,4
 217             0x100409d8 <shr1+4>:    b       0x10040984 <sg+4>
 218             (gdb) c
 219             Continuing.
 220
 221             Breakpoint 1, shr1 (x=1)
 222                 at gdb.base/shr1.c:19
 223             19        l = 1;
 224
 225         Now we've hit the breakpoint at shr1.  (The breakpoint was
 226         reset from the PLT entry to the actual shr1 function after the
 227         shared library was loaded.) Note that the PLT entry has been
 228         resolved to contain a branch that takes us directly to shr1.
 229         (The real one, not the PLT entry.)
 230
 231             (gdb) x/2i 0x100409d4
 232             0x100409d4 <shr1>:      b       0xffaf76c <shr1>
 233             0x100409d8 <shr1+4>:    b       0x10040984 <sg+4>
 234
 235    The thing to note here is that the PLT entry for shr1 has been
 236    changed twice.
 237
 238    Now the problem should be obvious.  GDB places a breakpoint (a
 239    trap instruction) on the zero value of the PLT entry for shr1.
 240    Later on, after the shared library had been loaded and the PLT
 241    initialized, GDB gets a signal indicating this fact and attempts
 242    (as it always does when it stops) to remove all the breakpoints.
 243
 244    The breakpoint removal was causing the former contents (a zero
 245    word) to be written back to the now initialized PLT entry thus
 246    destroying a portion of the initialization that had occurred only a
 247    short time ago.  When execution continued, the zero word would be
 248    executed as an instruction an an illegal instruction trap was
 249    generated instead.  (0 is not a legal instruction.)
 250
 251    The fix for this problem was fairly straightforward.  The function
 252    memory_remove_breakpoint from mem-break.c was copied to this file,
 253    modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
 254    In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
 255    function.
 256
 257    The differences between ppc_linux_memory_remove_breakpoint () and
 258    memory_remove_breakpoint () are minor.  All that the former does
 259    that the latter does not is check to make sure that the breakpoint
 260    location actually contains a breakpoint (trap instruction) prior
 261    to attempting to write back the old contents.  If it does contain
 262    a trap instruction, we allow the old contents to be written back.
 263    Otherwise, we silently do nothing.
 264
 265    The big question is whether memory_remove_breakpoint () should be
 266    changed to have the same functionality.  The downside is that more
 267    traffic is generated for remote targets since we'll have an extra
 268    fetch of a memory word each time a breakpoint is removed.
 269
 270    For the time being, we'll leave this self-modifying-code-friendly
 271    version in ppc-linux-tdep.c, but it ought to be migrated somewhere
 272    else in the event that some other platform has similar needs with
 273    regard to removing breakpoints in some potentially self modifying
 274    code.  */
 275 int
 276 ppc_linux_memory_remove_breakpoint (struct gdbarch *gdbarch,
 277                                     struct bp_target_info *bp_tgt)
 278 {
 279   CORE_ADDR addr = bp_tgt->placed_address;
 280   const unsigned char *bp;
 281   int val;
 282   int bplen;
 283   gdb_byte old_contents[BREAKPOINT_MAX];
 284   struct cleanup *cleanup;
 285
 286   /* Determine appropriate breakpoint contents and size for this address.  */
 287   bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);
 288   if (bp == NULL)
 289     error (_("Software breakpoints not implemented for this target."));
 290
 291   /* Make sure we see the memory breakpoints.  */
 292   cleanup = make_show_memory_breakpoints_cleanup (1);
 293   val = target_read_memory (addr, old_contents, bplen);
 294
 295   /* If our breakpoint is no longer at the address, this means that the
 296      program modified the code on us, so it is wrong to put back the
 297      old value */
 298   if (val == 0 && memcmp (bp, old_contents, bplen) == 0)
 299     val = target_write_memory (addr, bp_tgt->shadow_contents, bplen);
 300
 301   do_cleanups (cleanup);
 302   return val;
 303 }
 304
 305 /* For historic reasons, PPC 32 GNU/Linux follows PowerOpen rather
 306    than the 32 bit SYSV R4 ABI structure return convention - all
 307    structures, no matter their size, are put in memory.  Vectors,
 308    which were added later, do get returned in a register though.  */
 309
 310 static enum return_value_convention
 311 ppc_linux_return_value (struct gdbarch *gdbarch, struct type *func_type,
 312                         struct type *valtype, struct regcache *regcache,
 313                         gdb_byte *readbuf, const gdb_byte *writebuf)
 314 {
 315   if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
 316        || TYPE_CODE (valtype) == TYPE_CODE_UNION)
 317       && !((TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 8)
 318            && TYPE_VECTOR (valtype)))
 319     return RETURN_VALUE_STRUCT_CONVENTION;
 320   else
 321     return ppc_sysv_abi_return_value (gdbarch, func_type, valtype, regcache,
 322                                       readbuf, writebuf);
 323 }
 324
 325 /* Macros for matching instructions.  Note that, since all the
 326    operands are masked off before they're or-ed into the instruction,
 327    you can use -1 to make masks.  */
 328
 329 #define insn_d(opcd, rts, ra, d)                \
 330   ((((opcd) & 0x3f) << 26)                      \
 331    | (((rts) & 0x1f) << 21)                     \
 332    | (((ra) & 0x1f) << 16)                      \
 333    | ((d) & 0xffff))
 334
 335 #define insn_ds(opcd, rts, ra, d, xo)           \
 336   ((((opcd) & 0x3f) << 26)                      \
 337    | (((rts) & 0x1f) << 21)                     \
 338    | (((ra) & 0x1f) << 16)                      \
 339    | ((d) & 0xfffc)                             \
 340    | ((xo) & 0x3))
 341
 342 #define insn_xfx(opcd, rts, spr, xo)            \
 343   ((((opcd) & 0x3f) << 26)                      \
 344    | (((rts) & 0x1f) << 21)                     \
 345    | (((spr) & 0x1f) << 16)                     \
 346    | (((spr) & 0x3e0) << 6)                     \
 347    | (((xo) & 0x3ff) << 1))
 348
 349 /* Read a PPC instruction from memory.  PPC instructions are always
 350    big-endian, no matter what endianness the program is running in, so
 351    we can't use read_memory_integer or one of its friends here.  */
 352 static unsigned int
 353 read_insn (CORE_ADDR pc)
 354 {
 355   unsigned char buf[4];
 356
 357   read_memory (pc, buf, 4);
 358   return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 359 }
 360
 361
 362 /* An instruction to match.  */
 363 struct insn_pattern
 364 {
 365   unsigned int mask;            /* mask the insn with this... */
 366   unsigned int data;            /* ...and see if it matches this. */
 367   int optional;                 /* If non-zero, this insn may be absent.  */
 368 };
 369
 370 /* Return non-zero if the instructions at PC match the series
 371    described in PATTERN, or zero otherwise.  PATTERN is an array of
 372    'struct insn_pattern' objects, terminated by an entry whose mask is
 373    zero.
 374
 375    When the match is successful, fill INSN[i] with what PATTERN[i]
 376    matched.  If PATTERN[i] is optional, and the instruction wasn't
 377    present, set INSN[i] to 0 (which is not a valid PPC instruction).
 378    INSN should have as many elements as PATTERN.  Note that, if
 379    PATTERN contains optional instructions which aren't present in
 380    memory, then INSN will have holes, so INSN[i] isn't necessarily the
 381    i'th instruction in memory.  */
 382 static int
 383 insns_match_pattern (CORE_ADDR pc,
 384                      struct insn_pattern *pattern,
 385                      unsigned int *insn)
 386 {
 387   int i;
 388
 389   for (i = 0; pattern[i].mask; i++)
 390     {
 391       insn[i] = read_insn (pc);
 392       if ((insn[i] & pattern[i].mask) == pattern[i].data)
 393         pc += 4;
 394       else if (pattern[i].optional)
 395         insn[i] = 0;
 396       else
 397         return 0;
 398     }
 399
 400   return 1;
 401 }
 402
 403
 404 /* Return the 'd' field of the d-form instruction INSN, properly
 405    sign-extended.  */
 406 static CORE_ADDR
 407 insn_d_field (unsigned int insn)
 408 {
 409   return ((((CORE_ADDR) insn & 0xffff) ^ 0x8000) - 0x8000);
 410 }
 411
 412
 413 /* Return the 'ds' field of the ds-form instruction INSN, with the two
 414    zero bits concatenated at the right, and properly
 415    sign-extended.  */
 416 static CORE_ADDR
 417 insn_ds_field (unsigned int insn)
 418 {
 419   return ((((CORE_ADDR) insn & 0xfffc) ^ 0x8000) - 0x8000);
 420 }
 421
 422
 423 /* If DESC is the address of a 64-bit PowerPC GNU/Linux function
 424    descriptor, return the descriptor's entry point.  */
 425 static CORE_ADDR
 426 ppc64_desc_entry_point (CORE_ADDR desc)
 427 {
 428   /* The first word of the descriptor is the entry point.  */
 429   return (CORE_ADDR) read_memory_unsigned_integer (desc, 8);
 430 }
 431
 432
 433 /* Pattern for the standard linkage function.  These are built by
 434    build_plt_stub in elf64-ppc.c, whose GLINK argument is always
 435    zero.  */
 436 static struct insn_pattern ppc64_standard_linkage[] =
 437   {
 438     /* addis r12, r2, <any> */
 439     { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
 440
 441     /* std r2, 40(r1) */
 442     { -1, insn_ds (62, 2, 1, 40, 0), 0 },
 443
 444     /* ld r11, <any>(r12) */
 445     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
 446
 447     /* addis r12, r12, 1 <optional> */
 448     { insn_d (-1, -1, -1, -1), insn_d (15, 12, 2, 1), 1 },
 449
 450     /* ld r2, <any>(r12) */
 451     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
 452
 453     /* addis r12, r12, 1 <optional> */
 454     { insn_d (-1, -1, -1, -1), insn_d (15, 12, 2, 1), 1 },
 455
 456     /* mtctr r11 */
 457     { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467),
 458       0 },
 459
 460     /* ld r11, <any>(r12) */
 461     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
 462
 463     /* bctr */
 464     { -1, 0x4e800420, 0 },
 465
 466     { 0, 0, 0 }
 467   };
 468 #define PPC64_STANDARD_LINKAGE_LEN \
 469   (sizeof (ppc64_standard_linkage) / sizeof (ppc64_standard_linkage[0]))
 470
 471 /* When the dynamic linker is doing lazy symbol resolution, the first
 472    call to a function in another object will go like this:
 473
 474    - The user's function calls the linkage function:
 475
 476      100007c4:  4b ff fc d5     bl      10000498
 477      100007c8:  e8 41 00 28     ld      r2,40(r1)
 478
 479    - The linkage function loads the entry point (and other stuff) from
 480      the function descriptor in the PLT, and jumps to it:
 481
 482      10000498:  3d 82 00 00     addis   r12,r2,0
 483      1000049c:  f8 41 00 28     std     r2,40(r1)
 484      100004a0:  e9 6c 80 98     ld      r11,-32616(r12)
 485      100004a4:  e8 4c 80 a0     ld      r2,-32608(r12)
 486      100004a8:  7d 69 03 a6     mtctr   r11
 487      100004ac:  e9 6c 80 a8     ld      r11,-32600(r12)
 488      100004b0:  4e 80 04 20     bctr
 489
 490    - But since this is the first time that PLT entry has been used, it
 491      sends control to its glink entry.  That loads the number of the
 492      PLT entry and jumps to the common glink0 code:
 493
 494      10000c98:  38 00 00 00     li      r0,0
 495      10000c9c:  4b ff ff dc     b       10000c78
 496
 497    - The common glink0 code then transfers control to the dynamic
 498      linker's fixup code:
 499
 500      10000c78:  e8 41 00 28     ld      r2,40(r1)
 501      10000c7c:  3d 82 00 00     addis   r12,r2,0
 502      10000c80:  e9 6c 80 80     ld      r11,-32640(r12)
 503      10000c84:  e8 4c 80 88     ld      r2,-32632(r12)
 504      10000c88:  7d 69 03 a6     mtctr   r11
 505      10000c8c:  e9 6c 80 90     ld      r11,-32624(r12)
 506      10000c90:  4e 80 04 20     bctr
 507
 508    Eventually, this code will figure out how to skip all of this,
 509    including the dynamic linker.  At the moment, we just get through
 510    the linkage function.  */
 511
 512 /* If the current thread is about to execute a series of instructions
 513    at PC matching the ppc64_standard_linkage pattern, and INSN is the result
 514    from that pattern match, return the code address to which the
 515    standard linkage function will send them.  (This doesn't deal with
 516    dynamic linker lazy symbol resolution stubs.)  */
 517 static CORE_ADDR
 518 ppc64_standard_linkage_target (struct frame_info *frame,
 519                                CORE_ADDR pc, unsigned int *insn)
 520 {
 521   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
 522
 523   /* The address of the function descriptor this linkage function
 524      references.  */
 525   CORE_ADDR desc
 526     = ((CORE_ADDR) get_frame_register_unsigned (frame,
 527                                                 tdep->ppc_gp0_regnum + 2)
 528        + (insn_d_field (insn[0]) << 16)
 529        + insn_ds_field (insn[2]));
 530
 531   /* The first word of the descriptor is the entry point.  Return that.  */
 532   return ppc64_desc_entry_point (desc);
 533 }
 534
 535
 536 /* Given that we've begun executing a call trampoline at PC, return
 537    the entry point of the function the trampoline will go to.  */
 538 static CORE_ADDR
 539 ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 540 {
 541   unsigned int ppc64_standard_linkage_insn[PPC64_STANDARD_LINKAGE_LEN];
 542
 543   if (insns_match_pattern (pc, ppc64_standard_linkage,
 544                            ppc64_standard_linkage_insn))
 545     return ppc64_standard_linkage_target (frame, pc,
 546                                           ppc64_standard_linkage_insn);
 547   else
 548     return 0;
 549 }
 550
 551
 552 /* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC
 553    GNU/Linux.
 554
 555    Usually a function pointer's representation is simply the address
 556    of the function.  On GNU/Linux on the PowerPC however, a function
 557    pointer may be a pointer to a function descriptor.
 558
 559    For PPC64, a function descriptor is a TOC entry, in a data section,
 560    which contains three words: the first word is the address of the
 561    function, the second word is the TOC pointer (r2), and the third word
 562    is the static chain value.
 563
 564    For PPC32, there are two kinds of function pointers: non-secure and
 565    secure.  Non-secure function pointers point directly to the
 566    function in a code section and thus need no translation.  Secure
 567    ones (from GCC's -msecure-plt option) are in a data section and
 568    contain one word: the address of the function.
 569
 570    Throughout GDB it is currently assumed that a function pointer contains
 571    the address of the function, which is not easy to fix.  In addition, the
 572    conversion of a function address to a function pointer would
 573    require allocation of a TOC entry in the inferior's memory space,
 574    with all its drawbacks.  To be able to call C++ virtual methods in
 575    the inferior (which are called via function pointers),
 576    find_function_addr uses this function to get the function address
 577    from a function pointer.
 578
 579    If ADDR points at what is clearly a function descriptor, transform
 580    it into the address of the corresponding function, if needed.  Be
 581    conservative, otherwise GDB will do the transformation on any
 582    random addresses such as occur when there is no symbol table.  */
 583
 584 static CORE_ADDR
 585 ppc_linux_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
 586                                       CORE_ADDR addr,
 587                                       struct target_ops *targ)
 588 {
 589   struct gdbarch_tdep *tdep;
 590   struct section_table *s = target_section_by_addr (targ, addr);
 591   char *sect_name = NULL;
 592
 593   if (!s)
 594     return addr;
 595
 596   tdep = gdbarch_tdep (gdbarch);
 597
 598   switch (tdep->wordsize)
 599     {
 600       case 4:
 601         sect_name = ".plt";
 602         break;
 603       case 8:
 604         sect_name = ".opd";
 605         break;
 606       default:
 607         internal_error (__FILE__, __LINE__,
 608                         _("failed internal consistency check"));
 609     }
 610
 611   /* Check if ADDR points to a function descriptor.  */
 612
 613   /* NOTE: this depends on the coincidence that the address of a functions
 614      entry point is contained in the first word of its function descriptor
 615      for both PPC-64 and for PPC-32 with secure PLTs.  */
 616   if ((strcmp (s->the_bfd_section->name, sect_name) == 0)
 617       && s->the_bfd_section->flags & SEC_DATA)
 618     return get_target_memory_unsigned (targ, addr, tdep->wordsize);
 619
 620   return addr;
 621 }
 622
 623 /* This wrapper clears areas in the linux gregset not written by
 624    ppc_collect_gregset.  */
 625
 626 static void
 627 ppc_linux_collect_gregset (const struct regset *regset,
 628                            const struct regcache *regcache,
 629                            int regnum, void *gregs, size_t len)
 630 {
 631   if (regnum == -1)
 632     memset (gregs, 0, len);
 633   ppc_collect_gregset (regset, regcache, regnum, gregs, len);
 634 }
 635
 636 /* Regset descriptions.  */
 637 static const struct ppc_reg_offsets ppc32_linux_reg_offsets =
 638   {
 639     /* General-purpose registers.  */
 640     /* .r0_offset = */ 0,
 641     /* .gpr_size = */ 4,
 642     /* .xr_size = */ 4,
 643     /* .pc_offset = */ 128,
 644     /* .ps_offset = */ 132,
 645     /* .cr_offset = */ 152,
 646     /* .lr_offset = */ 144,
 647     /* .ctr_offset = */ 140,
 648     /* .xer_offset = */ 148,
 649     /* .mq_offset = */ 156,
 650
 651     /* Floating-point registers.  */
 652     /* .f0_offset = */ 0,
 653     /* .fpscr_offset = */ 256,
 654     /* .fpscr_size = */ 8,
 655
 656     /* AltiVec registers.  */
 657     /* .vr0_offset = */ 0,
 658     /* .vscr_offset = */ 512 + 12,
 659     /* .vrsave_offset = */ 528
 660   };
 661
 662 static const struct ppc_reg_offsets ppc64_linux_reg_offsets =
 663   {
 664     /* General-purpose registers.  */
 665     /* .r0_offset = */ 0,
 666     /* .gpr_size = */ 8,
 667     /* .xr_size = */ 8,
 668     /* .pc_offset = */ 256,
 669     /* .ps_offset = */ 264,
 670     /* .cr_offset = */ 304,
 671     /* .lr_offset = */ 288,
 672     /* .ctr_offset = */ 280,
 673     /* .xer_offset = */ 296,
 674     /* .mq_offset = */ 312,
 675
 676     /* Floating-point registers.  */
 677     /* .f0_offset = */ 0,
 678     /* .fpscr_offset = */ 256,
 679     /* .fpscr_size = */ 8,
 680
 681     /* AltiVec registers.  */
 682     /* .vr0_offset = */ 0,
 683     /* .vscr_offset = */ 512 + 12,
 684     /* .vrsave_offset = */ 528
 685   };
 686
 687 static const struct regset ppc32_linux_gregset = {
 688   &ppc32_linux_reg_offsets,
 689   ppc_supply_gregset,
 690   ppc_linux_collect_gregset,
 691   NULL
 692 };
 693
 694 static const struct regset ppc64_linux_gregset = {
 695   &ppc64_linux_reg_offsets,
 696   ppc_supply_gregset,
 697   ppc_linux_collect_gregset,
 698   NULL
 699 };
 700
 701 static const struct regset ppc32_linux_fpregset = {
 702   &ppc32_linux_reg_offsets,
 703   ppc_supply_fpregset,
 704   ppc_collect_fpregset,
 705   NULL
 706 };
 707
 708 static const struct regset ppc32_linux_vrregset = {
 709   &ppc32_linux_reg_offsets,
 710   ppc_supply_vrregset,
 711   ppc_collect_vrregset,
 712   NULL
 713 };
 714
 715 const struct regset *
 716 ppc_linux_gregset (int wordsize)
 717 {
 718   return wordsize == 8 ? &ppc64_linux_gregset : &ppc32_linux_gregset;
 719 }
 720
 721 const struct regset *
 722 ppc_linux_fpregset (void)
 723 {
 724   return &ppc32_linux_fpregset;
 725 }
 726
 727 static const struct regset *
 728 ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
 729                                     const char *sect_name, size_t sect_size)
 730 {
 731   struct gdbarch_tdep *tdep = gdbarch_tdep (core_arch);
 732   if (strcmp (sect_name, ".reg") == 0)
 733     {
 734       if (tdep->wordsize == 4)
 735         return &ppc32_linux_gregset;
 736       else
 737         return &ppc64_linux_gregset;
 738     }
 739   if (strcmp (sect_name, ".reg2") == 0)
 740     return &ppc32_linux_fpregset;
 741   if (strcmp (sect_name, ".reg-ppc-vmx") == 0)
 742     return &ppc32_linux_vrregset;
 743   return NULL;
 744 }
 745
 746 static void
 747 ppc_linux_sigtramp_cache (struct frame_info *this_frame,
 748                           struct trad_frame_cache *this_cache,
 749                           CORE_ADDR func, LONGEST offset,
 750                           int bias)
 751 {
 752   CORE_ADDR base;
 753   CORE_ADDR regs;
 754   CORE_ADDR gpregs;
 755   CORE_ADDR fpregs;
 756   int i;
 757   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 758   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 759
 760   base = get_frame_register_unsigned (this_frame,
 761                                       gdbarch_sp_regnum (gdbarch));
 762   if (bias > 0 && get_frame_pc (this_frame) != func)
 763     /* See below, some signal trampolines increment the stack as their
 764        first instruction, need to compensate for that.  */
 765     base -= bias;
 766
 767   /* Find the address of the register buffer pointer.  */
 768   regs = base + offset;
 769   /* Use that to find the address of the corresponding register
 770      buffers.  */
 771   gpregs = read_memory_unsigned_integer (regs, tdep->wordsize);
 772   fpregs = gpregs + 48 * tdep->wordsize;
 773
 774   /* General purpose.  */
 775   for (i = 0; i < 32; i++)
 776     {
 777       int regnum = i + tdep->ppc_gp0_regnum;
 778       trad_frame_set_reg_addr (this_cache, regnum, gpregs + i * tdep->wordsize);
 779     }
 780   trad_frame_set_reg_addr (this_cache,
 781                            gdbarch_pc_regnum (gdbarch),
 782                            gpregs + 32 * tdep->wordsize);
 783   trad_frame_set_reg_addr (this_cache, tdep->ppc_ctr_regnum,
 784                            gpregs + 35 * tdep->wordsize);
 785   trad_frame_set_reg_addr (this_cache, tdep->ppc_lr_regnum,
 786                            gpregs + 36 * tdep->wordsize);
 787   trad_frame_set_reg_addr (this_cache, tdep->ppc_xer_regnum,
 788                            gpregs + 37 * tdep->wordsize);
 789   trad_frame_set_reg_addr (this_cache, tdep->ppc_cr_regnum,
 790                            gpregs + 38 * tdep->wordsize);
 791
 792   if (ppc_floating_point_unit_p (gdbarch))
 793     {
 794       /* Floating point registers.  */
 795       for (i = 0; i < 32; i++)
 796         {
 797           int regnum = i + gdbarch_fp0_regnum (gdbarch);
 798           trad_frame_set_reg_addr (this_cache, regnum,
 799                                    fpregs + i * tdep->wordsize);
 800         }
 801       trad_frame_set_reg_addr (this_cache, tdep->ppc_fpscr_regnum,
 802                          fpregs + 32 * tdep->wordsize);
 803     }
 804   trad_frame_set_id (this_cache, frame_id_build (base, func));
 805 }
 806
 807 static void
 808 ppc32_linux_sigaction_cache_init (const struct tramp_frame *self,
 809                                   struct frame_info *this_frame,
 810                                   struct trad_frame_cache *this_cache,
 811                                   CORE_ADDR func)
 812 {
 813   ppc_linux_sigtramp_cache (this_frame, this_cache, func,
 814                             0xd0 /* Offset to ucontext_t.  */
 815                             + 0x30 /* Offset to .reg.  */,
 816                             0);
 817 }
 818
 819 static void
 820 ppc64_linux_sigaction_cache_init (const struct tramp_frame *self,
 821                                   struct frame_info *this_frame,
 822                                   struct trad_frame_cache *this_cache,
 823                                   CORE_ADDR func)
 824 {
 825   ppc_linux_sigtramp_cache (this_frame, this_cache, func,
 826                             0x80 /* Offset to ucontext_t.  */
 827                             + 0xe0 /* Offset to .reg.  */,
 828                             128);
 829 }
 830
 831 static void
 832 ppc32_linux_sighandler_cache_init (const struct tramp_frame *self,
 833                                    struct frame_info *this_frame,
 834                                    struct trad_frame_cache *this_cache,
 835                                    CORE_ADDR func)
 836 {
 837   ppc_linux_sigtramp_cache (this_frame, this_cache, func,
 838                             0x40 /* Offset to ucontext_t.  */
 839                             + 0x1c /* Offset to .reg.  */,
 840                             0);
 841 }
 842
 843 static void
 844 ppc64_linux_sighandler_cache_init (const struct tramp_frame *self,
 845                                    struct frame_info *this_frame,
 846                                    struct trad_frame_cache *this_cache,
 847                                    CORE_ADDR func)
 848 {
 849   ppc_linux_sigtramp_cache (this_frame, this_cache, func,
 850                             0x80 /* Offset to struct sigcontext.  */
 851                             + 0x38 /* Offset to .reg.  */,
 852                             128);
 853 }
 854
 855 static struct tramp_frame ppc32_linux_sigaction_tramp_frame = {
 856   SIGTRAMP_FRAME,
 857   4,
 858   {
 859     { 0x380000ac, -1 }, /* li r0, 172 */
 860     { 0x44000002, -1 }, /* sc */
 861     { TRAMP_SENTINEL_INSN },
 862   },
 863   ppc32_linux_sigaction_cache_init
 864 };
 865 static struct tramp_frame ppc64_linux_sigaction_tramp_frame = {
 866   SIGTRAMP_FRAME,
 867   4,
 868   {
 869     { 0x38210080, -1 }, /* addi r1,r1,128 */
 870     { 0x380000ac, -1 }, /* li r0, 172 */
 871     { 0x44000002, -1 }, /* sc */
 872     { TRAMP_SENTINEL_INSN },
 873   },
 874   ppc64_linux_sigaction_cache_init
 875 };
 876 static struct tramp_frame ppc32_linux_sighandler_tramp_frame = {
 877   SIGTRAMP_FRAME,
 878   4,
 879   {
 880     { 0x38000077, -1 }, /* li r0,119 */
 881     { 0x44000002, -1 }, /* sc */
 882     { TRAMP_SENTINEL_INSN },
 883   },
 884   ppc32_linux_sighandler_cache_init
 885 };
 886 static struct tramp_frame ppc64_linux_sighandler_tramp_frame = {
 887   SIGTRAMP_FRAME,
 888   4,
 889   {
 890     { 0x38210080, -1 }, /* addi r1,r1,128 */
 891     { 0x38000077, -1 }, /* li r0,119 */
 892     { 0x44000002, -1 }, /* sc */
 893     { TRAMP_SENTINEL_INSN },
 894   },
 895   ppc64_linux_sighandler_cache_init
 896 };
 897
 898 static void
 899 ppc_linux_init_abi (struct gdbarch_info info,
 900                     struct gdbarch *gdbarch)
 901 {
 902   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 903
 904   /* PPC GNU/Linux uses either 64-bit or 128-bit long doubles; where
 905      128-bit, they are IBM long double, not IEEE quad long double as
 906      in the System V ABI PowerPC Processor Supplement.  We can safely
 907      let them default to 128-bit, since the debug info will give the
 908      size of type actually used in each case.  */
 909   set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);
 910   set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double);
 911
 912   /* Handle PPC GNU/Linux 64-bit function pointers (which are really
 913      function descriptors) and 32-bit secure PLT entries.  */
 914   set_gdbarch_convert_from_func_ptr_addr
 915     (gdbarch, ppc_linux_convert_from_func_ptr_addr);
 916
 917   if (tdep->wordsize == 4)
 918     {
 919       /* Until November 2001, gcc did not comply with the 32 bit SysV
 920          R4 ABI requirement that structures less than or equal to 8
 921          bytes should be returned in registers.  Instead GCC was using
 922          the the AIX/PowerOpen ABI - everything returned in memory
 923          (well ignoring vectors that is).  When this was corrected, it
 924          wasn't fixed for GNU/Linux native platform.  Use the
 925          PowerOpen struct convention.  */
 926       set_gdbarch_return_value (gdbarch, ppc_linux_return_value);
 927
 928       set_gdbarch_memory_remove_breakpoint (gdbarch,
 929                                             ppc_linux_memory_remove_breakpoint);
 930
 931       /* Shared library handling.  */
 932       set_gdbarch_skip_trampoline_code (gdbarch,
 933                                         ppc_linux_skip_trampoline_code);
 934       set_solib_svr4_fetch_link_map_offsets
 935         (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 936
 937       /* Trampolines.  */
 938       tramp_frame_prepend_unwinder (gdbarch, &ppc32_linux_sigaction_tramp_frame);
 939       tramp_frame_prepend_unwinder (gdbarch, &ppc32_linux_sighandler_tramp_frame);
 940     }
 941
 942   if (tdep->wordsize == 8)
 943     {
 944       /* Shared library handling.  */
 945       set_gdbarch_skip_trampoline_code (gdbarch, ppc64_skip_trampoline_code);
 946       set_solib_svr4_fetch_link_map_offsets
 947         (gdbarch, svr4_lp64_fetch_link_map_offsets);
 948
 949       /* Trampolines.  */
 950       tramp_frame_prepend_unwinder (gdbarch, &ppc64_linux_sigaction_tramp_frame);
 951       tramp_frame_prepend_unwinder (gdbarch, &ppc64_linux_sighandler_tramp_frame);
 952     }
 953   set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);
 954
 955   /* Enable TLS support.  */
 956   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 957                                              svr4_fetch_objfile_link_map);
 958 }
 959
 960 void
 961 _initialize_ppc_linux_tdep (void)
 962 {
 963   /* Register for all sub-familes of the POWER/PowerPC: 32-bit and
 964      64-bit PowerPC, and the older rs6k.  */
 965   gdbarch_register_osabi (bfd_arch_powerpc, bfd_mach_ppc, GDB_OSABI_LINUX,
 966                          ppc_linux_init_abi);
 967   gdbarch_register_osabi (bfd_arch_powerpc, bfd_mach_ppc64, GDB_OSABI_LINUX,
 968                          ppc_linux_init_abi);
 969   gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
 970                          ppc_linux_init_abi);
 971 }