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