gdb/ppc64-tdep.c

   1 /* Common target-dependent code for ppc64 GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2013 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "gdbcore.h"
  23 #include "ppc-tdep.h"
  24 #include "ppc64-tdep.h"
  25 #include "elf-bfd.h"
  26
  27 /* Macros for matching instructions.  Note that, since all the
  28    operands are masked off before they're or-ed into the instruction,
  29    you can use -1 to make masks.  */
  30
  31 #define insn_d(opcd, rts, ra, d)                \
  32   ((((opcd) & 0x3f) << 26)                      \
  33    | (((rts) & 0x1f) << 21)                     \
  34    | (((ra) & 0x1f) << 16)                      \
  35    | ((d) & 0xffff))
  36
  37 #define insn_ds(opcd, rts, ra, d, xo)           \
  38   ((((opcd) & 0x3f) << 26)                      \
  39    | (((rts) & 0x1f) << 21)                     \
  40    | (((ra) & 0x1f) << 16)                      \
  41    | ((d) & 0xfffc)                             \
  42    | ((xo) & 0x3))
  43
  44 #define insn_xfx(opcd, rts, spr, xo)            \
  45   ((((opcd) & 0x3f) << 26)                      \
  46    | (((rts) & 0x1f) << 21)                     \
  47    | (((spr) & 0x1f) << 16)                     \
  48    | (((spr) & 0x3e0) << 6)                     \
  49    | (((xo) & 0x3ff) << 1))
  50
  51 /* If DESC is the address of a 64-bit PowerPC FreeBSD function
  52    descriptor, return the descriptor's entry point.  */
  53
  54 static CORE_ADDR
  55 ppc64_desc_entry_point (struct gdbarch *gdbarch, CORE_ADDR desc)
  56 {
  57   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  58   /* The first word of the descriptor is the entry point.  */
  59   return (CORE_ADDR) read_memory_unsigned_integer (desc, 8, byte_order);
  60 }
  61
  62 /* Patterns for the standard linkage functions.  These are built by
  63    build_plt_stub in bfd/elf64-ppc.c.  */
  64
  65 /* Old PLT call stub.  */
  66
  67 static struct ppc_insn_pattern ppc64_standard_linkage1[] =
  68   {
  69     /* addis r12, r2, <any> */
  70     { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
  71
  72     /* std r2, 40(r1) */
  73     { -1, insn_ds (62, 2, 1, 40, 0), 0 },
  74
  75     /* ld r11, <any>(r12) */
  76     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
  77
  78     /* addis r12, r12, 1 <optional> */
  79     { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },
  80
  81     /* ld r2, <any>(r12) */
  82     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
  83
  84     /* addis r12, r12, 1 <optional> */
  85     { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },
  86
  87     /* mtctr r11 */
  88     { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
  89
  90     /* ld r11, <any>(r12) <optional> */
  91     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 },
  92
  93     /* bctr */
  94     { -1, 0x4e800420, 0 },
  95
  96     { 0, 0, 0 }
  97   };
  98
  99 /* Current PLT call stub to access PLT entries more than +/- 32k from r2.
 100    Also supports older stub with different placement of std 2,40(1),
 101    a stub that omits the std 2,40(1), and both versions of power7
 102    thread safety read barriers.  Note that there are actually two more
 103    instructions following "cmpldi r2, 0", "bnectr+" and "b <glink_i>",
 104    but there isn't any need to match them.  */
 105
 106 static struct ppc_insn_pattern ppc64_standard_linkage2[] =
 107   {
 108     /* std r2, 40(r1) <optional> */
 109     { -1, insn_ds (62, 2, 1, 40, 0), 1 },
 110
 111     /* addis r12, r2, <any> */
 112     { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
 113
 114     /* std r2, 40(r1) <optional> */
 115     { -1, insn_ds (62, 2, 1, 40, 0), 1 },
 116
 117     /* ld r11, <any>(r12) */
 118     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
 119
 120     /* addi r12, r12, <any> <optional> */
 121     { insn_d (-1, -1, -1, 0), insn_d (14, 12, 12, 0), 1 },
 122
 123     /* mtctr r11 */
 124     { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
 125
 126     /* xor r11, r11, r11 <optional> */
 127     { -1, 0x7d6b5a78, 1 },
 128
 129     /* add r12, r12, r11 <optional> */
 130     { -1, 0x7d8c5a14, 1 },
 131
 132     /* ld r2, <any>(r12) */
 133     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
 134
 135     /* ld r11, <any>(r12) <optional> */
 136     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 },
 137
 138     /* bctr <optional> */
 139     { -1, 0x4e800420, 1 },
 140
 141     /* cmpldi r2, 0 <optional> */
 142     { -1, 0x28220000, 1 },
 143
 144     { 0, 0, 0 }
 145   };
 146
 147 /* Current PLT call stub to access PLT entries within +/- 32k of r2.  */
 148
 149 static struct ppc_insn_pattern ppc64_standard_linkage3[] =
 150   {
 151     /* std r2, 40(r1) <optional> */
 152     { -1, insn_ds (62, 2, 1, 40, 0), 1 },
 153
 154     /* ld r11, <any>(r2) */
 155     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 },
 156
 157     /* addi r2, r2, <any> <optional> */
 158     { insn_d (-1, -1, -1, 0), insn_d (14, 2, 2, 0), 1 },
 159
 160     /* mtctr r11 */
 161     { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
 162
 163     /* xor r11, r11, r11 <optional> */
 164     { -1, 0x7d6b5a78, 1 },
 165
 166     /* add r2, r2, r11 <optional> */
 167     { -1, 0x7c425a14, 1 },
 168
 169     /* ld r11, <any>(r2) <optional> */
 170     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 1 },
 171
 172     /* ld r2, <any>(r2) */
 173     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 2, 0, 0), 0 },
 174
 175     /* bctr <optional> */
 176     { -1, 0x4e800420, 1 },
 177
 178     /* cmpldi r2, 0 <optional> */
 179     { -1, 0x28220000, 1 },
 180
 181     { 0, 0, 0 }
 182   };
 183
 184 /* When the dynamic linker is doing lazy symbol resolution, the first
 185    call to a function in another object will go like this:
 186
 187    - The user's function calls the linkage function:
 188
 189         100003d4:   4b ff ff ad     bl      10000380 <nnnn.plt_call.printf>
 190         100003d8:   e8 41 00 28     ld      r2,40(r1)
 191
 192    - The linkage function loads the entry point and toc pointer from
 193      the function descriptor in the PLT, and jumps to it:
 194
 195      <nnnn.plt_call.printf>:
 196         10000380:   f8 41 00 28     std     r2,40(r1)
 197         10000384:   e9 62 80 78     ld      r11,-32648(r2)
 198         10000388:   7d 69 03 a6     mtctr   r11
 199         1000038c:   e8 42 80 80     ld      r2,-32640(r2)
 200         10000390:   28 22 00 00     cmpldi  r2,0
 201         10000394:   4c e2 04 20     bnectr+
 202         10000398:   48 00 03 a0     b       10000738 <printf@plt>
 203
 204    - But since this is the first time that PLT entry has been used, it
 205      sends control to its glink entry.  That loads the number of the
 206      PLT entry and jumps to the common glink0 code:
 207
 208      <printf@plt>:
 209         10000738:   38 00 00 01     li      r0,1
 210         1000073c:   4b ff ff bc     b       100006f8 <__glink_PLTresolve>
 211
 212    - The common glink0 code then transfers control to the dynamic
 213      linker's fixup code:
 214
 215         100006f0:   0000000000010440 .quad plt0 - (. + 16)
 216      <__glink_PLTresolve>:
 217         100006f8:   7d 88 02 a6     mflr    r12
 218         100006fc:   42 9f 00 05     bcl     20,4*cr7+so,10000700
 219         10000700:   7d 68 02 a6     mflr    r11
 220         10000704:   e8 4b ff f0     ld      r2,-16(r11)
 221         10000708:   7d 88 03 a6     mtlr    r12
 222         1000070c:   7d 82 5a 14     add     r12,r2,r11
 223         10000710:   e9 6c 00 00     ld      r11,0(r12)
 224         10000714:   e8 4c 00 08     ld      r2,8(r12)
 225         10000718:   7d 69 03 a6     mtctr   r11
 226         1000071c:   e9 6c 00 10     ld      r11,16(r12)
 227         10000720:   4e 80 04 20     bctr
 228
 229    Eventually, this code will figure out how to skip all of this,
 230    including the dynamic linker.  At the moment, we just get through
 231    the linkage function.  */
 232
 233 /* If the current thread is about to execute a series of instructions
 234    at PC matching the ppc64_standard_linkage pattern, and INSN is the result
 235    from that pattern match, return the code address to which the
 236    standard linkage function will send them.  (This doesn't deal with
 237    dynamic linker lazy symbol resolution stubs.)  */
 238
 239 static CORE_ADDR
 240 ppc64_standard_linkage1_target (struct frame_info *frame,
 241                                 CORE_ADDR pc, unsigned int *insn)
 242 {
 243   struct gdbarch *gdbarch = get_frame_arch (frame);
 244   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 245
 246   /* The address of the function descriptor this linkage function
 247      references.  */
 248   CORE_ADDR desc
 249     = ((CORE_ADDR) get_frame_register_unsigned (frame,
 250                                                 tdep->ppc_gp0_regnum + 2)
 251        + (ppc_insn_d_field (insn[0]) << 16)
 252        + ppc_insn_ds_field (insn[2]));
 253
 254   /* The first word of the descriptor is the entry point.  Return that.  */
 255   return ppc64_desc_entry_point (gdbarch, desc);
 256 }
 257
 258 static CORE_ADDR
 259 ppc64_standard_linkage2_target (struct frame_info *frame,
 260                                 CORE_ADDR pc, unsigned int *insn)
 261 {
 262   struct gdbarch *gdbarch = get_frame_arch (frame);
 263   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 264
 265   /* The address of the function descriptor this linkage function
 266      references.  */
 267   CORE_ADDR desc
 268     = ((CORE_ADDR) get_frame_register_unsigned (frame,
 269                                                 tdep->ppc_gp0_regnum + 2)
 270        + (ppc_insn_d_field (insn[1]) << 16)
 271        + ppc_insn_ds_field (insn[3]));
 272
 273   /* The first word of the descriptor is the entry point.  Return that.  */
 274   return ppc64_desc_entry_point (gdbarch, desc);
 275 }
 276
 277 static CORE_ADDR
 278 ppc64_standard_linkage3_target (struct frame_info *frame,
 279                                 CORE_ADDR pc, unsigned int *insn)
 280 {
 281   struct gdbarch *gdbarch = get_frame_arch (frame);
 282   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 283
 284   /* The address of the function descriptor this linkage function
 285      references.  */
 286   CORE_ADDR desc
 287     = ((CORE_ADDR) get_frame_register_unsigned (frame,
 288                                                 tdep->ppc_gp0_regnum + 2)
 289        + ppc_insn_ds_field (insn[1]));
 290
 291   /* The first word of the descriptor is the entry point.  Return that.  */
 292   return ppc64_desc_entry_point (gdbarch, desc);
 293 }
 294
 295
 296 /* Given that we've begun executing a call trampoline at PC, return
 297    the entry point of the function the trampoline will go to.  */
 298
 299 CORE_ADDR
 300 ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 301 {
 302 #define MAX(a,b) ((a) > (b) ? (a) : (b))
 303   unsigned int insns[MAX (MAX (ARRAY_SIZE (ppc64_standard_linkage1),
 304                                ARRAY_SIZE (ppc64_standard_linkage2)),
 305                           ARRAY_SIZE (ppc64_standard_linkage3)) - 1];
 306   CORE_ADDR target;
 307
 308   if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage3, insns)
 309       && (insns[8] != 0 || insns[9] != 0))
 310     pc = ppc64_standard_linkage3_target (frame, pc, insns);
 311   else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage2, insns)
 312            && (insns[10] != 0 || insns[11] != 0))
 313     pc = ppc64_standard_linkage2_target (frame, pc, insns);
 314   else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage1, insns))
 315     pc = ppc64_standard_linkage1_target (frame, pc, insns);
 316   else
 317     return 0;
 318
 319   /* The PLT descriptor will either point to the already resolved target
 320      address, or else to a glink stub.  As the latter carry synthetic @plt
 321      symbols, find_solib_trampoline_target should be able to resolve them.  */
 322   target = find_solib_trampoline_target (frame, pc);
 323   return target ? target : pc;
 324 }
 325
 326 /* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64
 327    GNU/Linux.
 328
 329    Usually a function pointer's representation is simply the address
 330    of the function.  On GNU/Linux on the PowerPC however, a function
 331    pointer may be a pointer to a function descriptor.
 332
 333    For PPC64, a function descriptor is a TOC entry, in a data section,
 334    which contains three words: the first word is the address of the
 335    function, the second word is the TOC pointer (r2), and the third word
 336    is the static chain value.
 337
 338    Throughout GDB it is currently assumed that a function pointer contains
 339    the address of the function, which is not easy to fix.  In addition, the
 340    conversion of a function address to a function pointer would
 341    require allocation of a TOC entry in the inferior's memory space,
 342    with all its drawbacks.  To be able to call C++ virtual methods in
 343    the inferior (which are called via function pointers),
 344    find_function_addr uses this function to get the function address
 345    from a function pointer.
 346
 347    If ADDR points at what is clearly a function descriptor, transform
 348    it into the address of the corresponding function, if needed.  Be
 349    conservative, otherwise GDB will do the transformation on any
 350    random addresses such as occur when there is no symbol table.  */
 351
 352 CORE_ADDR
 353 ppc64_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
 354                                         CORE_ADDR addr,
 355                                         struct target_ops *targ)
 356 {
 357   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 358   struct target_section *s = target_section_by_addr (targ, addr);
 359
 360   /* Check if ADDR points to a function descriptor.  */
 361   if (s && strcmp (s->the_bfd_section->name, ".opd") == 0)
 362     {
 363       /* There may be relocations that need to be applied to the .opd
 364          section.  Unfortunately, this function may be called at a time
 365          where these relocations have not yet been performed -- this can
 366          happen for example shortly after a library has been loaded with
 367          dlopen, but ld.so has not yet applied the relocations.
 368
 369          To cope with both the case where the relocation has been applied,
 370          and the case where it has not yet been applied, we do *not* read
 371          the (maybe) relocated value from target memory, but we instead
 372          read the non-relocated value from the BFD, and apply the relocation
 373          offset manually.
 374
 375          This makes the assumption that all .opd entries are always relocated
 376          by the same offset the section itself was relocated.  This should
 377          always be the case for GNU/Linux executables and shared libraries.
 378          Note that other kind of object files (e.g. those added via
 379          add-symbol-files) will currently never end up here anyway, as this
 380          function accesses *target* sections only; only the main exec and
 381          shared libraries are ever added to the target.  */
 382
 383       gdb_byte buf[8];
 384       int res;
 385
 386       res = bfd_get_section_contents (s->the_bfd_section->owner,
 387                                       s->the_bfd_section,
 388                                       &buf, addr - s->addr, 8);
 389       if (res != 0)
 390         return extract_unsigned_integer (buf, 8, byte_order)
 391                 - bfd_section_vma (s->bfd, s->the_bfd_section) + s->addr;
 392    }
 393
 394   return addr;
 395 }
 396
 397 /* A synthetic 'dot' symbols on ppc64 has the udata.p entry pointing
 398    back to the original ELF symbol it was derived from.  Get the size
 399    from that symbol.  */
 400
 401 void
 402 ppc64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 403 {
 404   if ((sym->flags & BSF_SYNTHETIC) != 0 && sym->udata.p != NULL)
 405     {
 406       elf_symbol_type *elf_sym = (elf_symbol_type *) sym->udata.p;
 407       SET_MSYMBOL_SIZE (msym, elf_sym->internal_elf_sym.st_size);
 408     }
 409 }