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 /* Pattern for the standard linkage function.  These are built by
  63    build_plt_stub in elf64-ppc.c, whose GLINK argument is always
  64    zero.  */
  65
  66 static struct ppc_insn_pattern ppc64_standard_linkage1[] =
  67   {
  68     /* addis r12, r2, <any> */
  69     { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
  70
  71     /* std r2, 40(r1) */
  72     { -1, insn_ds (62, 2, 1, 40, 0), 0 },
  73
  74     /* ld r11, <any>(r12) */
  75     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
  76
  77     /* addis r12, r12, 1 <optional> */
  78     { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },
  79
  80     /* ld r2, <any>(r12) */
  81     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
  82
  83     /* addis r12, r12, 1 <optional> */
  84     { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },
  85
  86     /* mtctr r11 */
  87     { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
  88
  89     /* ld r11, <any>(r12) <optional> */
  90     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 },
  91
  92     /* bctr */
  93     { -1, 0x4e800420, 0 },
  94
  95     { 0, 0, 0 }
  96   };
  97
  98 #define PPC64_STANDARD_LINKAGE1_LEN ARRAY_SIZE (ppc64_standard_linkage1)
  99
 100 static struct ppc_insn_pattern ppc64_standard_linkage2[] =
 101   {
 102     /* addis r12, r2, <any> */
 103     { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
 104
 105     /* std r2, 40(r1) */
 106     { -1, insn_ds (62, 2, 1, 40, 0), 0 },
 107
 108     /* ld r11, <any>(r12) */
 109     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
 110
 111     /* addi r12, r12, <any> <optional> */
 112     { insn_d (-1, -1, -1, 0), insn_d (14, 12, 12, 0), 1 },
 113
 114     /* mtctr r11 */
 115     { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
 116
 117     /* ld r2, <any>(r12) */
 118     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
 119
 120     /* ld r11, <any>(r12) <optional> */
 121     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 },
 122
 123     /* bctr */
 124     { -1, 0x4e800420, 0 },
 125
 126     { 0, 0, 0 }
 127   };
 128
 129 #define PPC64_STANDARD_LINKAGE2_LEN ARRAY_SIZE (ppc64_standard_linkage2)
 130
 131 static struct ppc_insn_pattern ppc64_standard_linkage3[] =
 132   {
 133     /* std r2, 40(r1) */
 134     { -1, insn_ds (62, 2, 1, 40, 0), 0 },
 135
 136     /* ld r11, <any>(r2) */
 137     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 },
 138
 139     /* addi r2, r2, <any> <optional> */
 140     { insn_d (-1, -1, -1, 0), insn_d (14, 2, 2, 0), 1 },
 141
 142     /* mtctr r11 */
 143     { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
 144
 145     /* ld r11, <any>(r2) <optional> */
 146     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 1 },
 147
 148     /* ld r2, <any>(r2) */
 149     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 2, 0, 0), 0 },
 150
 151     /* bctr */
 152     { -1, 0x4e800420, 0 },
 153
 154     { 0, 0, 0 }
 155   };
 156
 157 #define PPC64_STANDARD_LINKAGE3_LEN ARRAY_SIZE (ppc64_standard_linkage3)
 158
 159 /* When the dynamic linker is doing lazy symbol resolution, the first
 160    call to a function in another object will go like this:
 161
 162    - The user's function calls the linkage function:
 163
 164          100007c4:      4b ff fc d5             bl      10000498
 165          100007c8:      e8 41 00 28             ld      r2,40(r1)
 166
 167    - The linkage function loads the entry point (and other stuff) from
 168          the function descriptor in the PLT, and jumps to it:
 169
 170          10000498:      3d 82 00 00             addis   r12,r2,0
 171          1000049c:      f8 41 00 28             std     r2,40(r1)
 172          100004a0:      e9 6c 80 98             ld      r11,-32616(r12)
 173          100004a4:      e8 4c 80 a0             ld      r2,-32608(r12)
 174          100004a8:      7d 69 03 a6             mtctr   r11
 175          100004ac:      e9 6c 80 a8             ld      r11,-32600(r12)
 176          100004b0:      4e 80 04 20             bctr
 177
 178    - But since this is the first time that PLT entry has been used, it
 179          sends control to its glink entry.  That loads the number of the
 180          PLT entry and jumps to the common glink0 code:
 181
 182          10000c98:      38 00 00 00             li      r0,0
 183          10000c9c:      4b ff ff dc             b       10000c78
 184
 185    - The common glink0 code then transfers control to the dynamic
 186          linker's fixup code:
 187
 188          10000c78:      e8 41 00 28             ld      r2,40(r1)
 189          10000c7c:      3d 82 00 00             addis   r12,r2,0
 190          10000c80:      e9 6c 80 80             ld      r11,-32640(r12)
 191          10000c84:      e8 4c 80 88             ld      r2,-32632(r12)
 192          10000c88:      7d 69 03 a6             mtctr   r11
 193          10000c8c:      e9 6c 80 90             ld      r11,-32624(r12)
 194          10000c90:      4e 80 04 20             bctr
 195
 196    Eventually, this code will figure out how to skip all of this,
 197    including the dynamic linker.  At the moment, we just get through
 198    the linkage function.  */
 199
 200 /* If the current thread is about to execute a series of instructions
 201    at PC matching the ppc64_standard_linkage pattern, and INSN is the result
 202    from that pattern match, return the code address to which the
 203    standard linkage function will send them.  (This doesn't deal with
 204    dynamic linker lazy symbol resolution stubs.)  */
 205
 206 static CORE_ADDR
 207 ppc64_standard_linkage1_target (struct frame_info *frame,
 208                                 CORE_ADDR pc, unsigned int *insn)
 209 {
 210   struct gdbarch *gdbarch = get_frame_arch (frame);
 211   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 212
 213   /* The address of the function descriptor this linkage function
 214      references.  */
 215   CORE_ADDR desc
 216     = ((CORE_ADDR) get_frame_register_unsigned (frame,
 217                                                 tdep->ppc_gp0_regnum + 2)
 218        + (ppc_insn_d_field (insn[0]) << 16)
 219        + ppc_insn_ds_field (insn[2]));
 220
 221   /* The first word of the descriptor is the entry point.  Return that.  */
 222   return ppc64_desc_entry_point (gdbarch, desc);
 223 }
 224
 225 static CORE_ADDR
 226 ppc64_standard_linkage2_target (struct frame_info *frame,
 227                                 CORE_ADDR pc, unsigned int *insn)
 228 {
 229   struct gdbarch *gdbarch = get_frame_arch (frame);
 230   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 231
 232   /* The address of the function descriptor this linkage function
 233      references.  */
 234   CORE_ADDR desc
 235     = ((CORE_ADDR) get_frame_register_unsigned (frame,
 236                                                 tdep->ppc_gp0_regnum + 2)
 237        + (ppc_insn_d_field (insn[0]) << 16)
 238        + ppc_insn_ds_field (insn[2]));
 239
 240   /* The first word of the descriptor is the entry point.  Return that.  */
 241   return ppc64_desc_entry_point (gdbarch, desc);
 242 }
 243
 244 static CORE_ADDR
 245 ppc64_standard_linkage3_target (struct frame_info *frame,
 246                                 CORE_ADDR pc, unsigned int *insn)
 247 {
 248   struct gdbarch *gdbarch = get_frame_arch (frame);
 249   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 250
 251   /* The address of the function descriptor this linkage function
 252      references.  */
 253   CORE_ADDR desc
 254     = ((CORE_ADDR) get_frame_register_unsigned (frame,
 255                                                 tdep->ppc_gp0_regnum + 2)
 256        + ppc_insn_ds_field (insn[1]));
 257
 258   /* The first word of the descriptor is the entry point.  Return that.  */
 259   return ppc64_desc_entry_point (gdbarch, desc);
 260 }
 261
 262
 263 /* Given that we've begun executing a call trampoline at PC, return
 264    the entry point of the function the trampoline will go to.  */
 265
 266 CORE_ADDR
 267 ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 268 {
 269   unsigned int ppc64_standard_linkage1_insn[PPC64_STANDARD_LINKAGE1_LEN];
 270   unsigned int ppc64_standard_linkage2_insn[PPC64_STANDARD_LINKAGE2_LEN];
 271   unsigned int ppc64_standard_linkage3_insn[PPC64_STANDARD_LINKAGE3_LEN];
 272   CORE_ADDR target;
 273
 274   if (ppc_insns_match_pattern (pc, ppc64_standard_linkage1,
 275                                ppc64_standard_linkage1_insn))
 276     pc = ppc64_standard_linkage1_target (frame, pc,
 277                                          ppc64_standard_linkage1_insn);
 278   else if (ppc_insns_match_pattern (pc, ppc64_standard_linkage2,
 279                                     ppc64_standard_linkage2_insn))
 280     pc = ppc64_standard_linkage2_target (frame, pc,
 281                                          ppc64_standard_linkage2_insn);
 282   else if (ppc_insns_match_pattern (pc, ppc64_standard_linkage3,
 283                                     ppc64_standard_linkage3_insn))
 284     pc = ppc64_standard_linkage3_target (frame, pc,
 285                                          ppc64_standard_linkage3_insn);
 286   else
 287     return 0;
 288
 289   /* The PLT descriptor will either point to the already resolved target
 290      address, or else to a glink stub.  As the latter carry synthetic @plt
 291      symbols, find_solib_trampoline_target should be able to resolve them.  */
 292   target = find_solib_trampoline_target (frame, pc);
 293   return target ? target : pc;
 294 }
 295
 296 /* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64
 297    GNU/Linux.
 298
 299    Usually a function pointer's representation is simply the address
 300    of the function.  On GNU/Linux on the PowerPC however, a function
 301    pointer may be a pointer to a function descriptor.
 302
 303    For PPC64, a function descriptor is a TOC entry, in a data section,
 304    which contains three words: the first word is the address of the
 305    function, the second word is the TOC pointer (r2), and the third word
 306    is the static chain value.
 307
 308    Throughout GDB it is currently assumed that a function pointer contains
 309    the address of the function, which is not easy to fix.  In addition, the
 310    conversion of a function address to a function pointer would
 311    require allocation of a TOC entry in the inferior's memory space,
 312    with all its drawbacks.  To be able to call C++ virtual methods in
 313    the inferior (which are called via function pointers),
 314    find_function_addr uses this function to get the function address
 315    from a function pointer.
 316
 317    If ADDR points at what is clearly a function descriptor, transform
 318    it into the address of the corresponding function, if needed.  Be
 319    conservative, otherwise GDB will do the transformation on any
 320    random addresses such as occur when there is no symbol table.  */
 321
 322 CORE_ADDR
 323 ppc64_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
 324                                         CORE_ADDR addr,
 325                                         struct target_ops *targ)
 326 {
 327   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 328   struct target_section *s = target_section_by_addr (targ, addr);
 329
 330   /* Check if ADDR points to a function descriptor.  */
 331   if (s && strcmp (s->the_bfd_section->name, ".opd") == 0)
 332     {
 333       /* There may be relocations that need to be applied to the .opd
 334          section.  Unfortunately, this function may be called at a time
 335          where these relocations have not yet been performed -- this can
 336          happen for example shortly after a library has been loaded with
 337          dlopen, but ld.so has not yet applied the relocations.
 338
 339          To cope with both the case where the relocation has been applied,
 340          and the case where it has not yet been applied, we do *not* read
 341          the (maybe) relocated value from target memory, but we instead
 342          read the non-relocated value from the BFD, and apply the relocation
 343          offset manually.
 344
 345          This makes the assumption that all .opd entries are always relocated
 346          by the same offset the section itself was relocated.  This should
 347          always be the case for GNU/Linux executables and shared libraries.
 348          Note that other kind of object files (e.g. those added via
 349          add-symbol-files) will currently never end up here anyway, as this
 350          function accesses *target* sections only; only the main exec and
 351          shared libraries are ever added to the target.  */
 352
 353       gdb_byte buf[8];
 354       int res;
 355
 356       res = bfd_get_section_contents (s->bfd, s->the_bfd_section,
 357                                       &buf, addr - s->addr, 8);
 358       if (res != 0)
 359         return extract_unsigned_integer (buf, 8, byte_order)
 360                 - bfd_section_vma (s->bfd, s->the_bfd_section) + s->addr;
 361    }
 362
 363   return addr;
 364 }
 365
 366 /* A synthetic 'dot' symbols on ppc64 has the udata.p entry pointing
 367    back to the original ELF symbol it was derived from.  Get the size
 368    from that symbol.  */
 369
 370 void
 371 ppc64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 372 {
 373   if ((sym->flags & BSF_SYNTHETIC) != 0 && sym->udata.p != NULL)
 374     {
 375       elf_symbol_type *elf_sym = (elf_symbol_type *) sym->udata.p;
 376       SET_MSYMBOL_SIZE (msym, elf_sym->internal_elf_sym.st_size);
 377     }
 378 }