[deliverable/binutils-gdb.git] / gdb / ppc64-tdep.c

/* Common target-dependent code for ppc64 GDB, the GNU debugger.

   Copyright (C) 1986-2013 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "frame.h"
#include "gdbcore.h"
#include "ppc-tdep.h"
#include "ppc64-tdep.h"

/* Macros for matching instructions.  Note that, since all the
   operands are masked off before they're or-ed into the instruction,
   you can use -1 to make masks.  */

#define insn_d(opcd, rts, ra, d)                \
  ((((opcd) & 0x3f) << 26)                      \
   | (((rts) & 0x1f) << 21)                     \
   | (((ra) & 0x1f) << 16)                      \
   | ((d) & 0xffff))

#define insn_ds(opcd, rts, ra, d, xo)           \
  ((((opcd) & 0x3f) << 26)                      \
   | (((rts) & 0x1f) << 21)                     \
   | (((ra) & 0x1f) << 16)                      \
   | ((d) & 0xfffc)                             \
   | ((xo) & 0x3))

#define insn_xfx(opcd, rts, spr, xo)            \
  ((((opcd) & 0x3f) << 26)                      \
   | (((rts) & 0x1f) << 21)                     \
   | (((spr) & 0x1f) << 16)                     \
   | (((spr) & 0x3e0) << 6)                     \
   | (((xo) & 0x3ff) << 1))

/* If DESC is the address of a 64-bit PowerPC FreeBSD function
   descriptor, return the descriptor's entry point.  */

static CORE_ADDR
ppc64_desc_entry_point (struct gdbarch *gdbarch, CORE_ADDR desc)
{
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  /* The first word of the descriptor is the entry point.  */
  return (CORE_ADDR) read_memory_unsigned_integer (desc, 8, byte_order);
}

/* Pattern for the standard linkage function.  These are built by
   build_plt_stub in elf64-ppc.c, whose GLINK argument is always
   zero.  */

static struct ppc_insn_pattern ppc64_standard_linkage1[] =
  {
    /* addis r12, r2, <any> */
    { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },

    /* std r2, 40(r1) */
    { -1, insn_ds (62, 2, 1, 40, 0), 0 },

    /* ld r11, <any>(r12) */
    { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },

    /* addis r12, r12, 1 <optional> */
    { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },

    /* ld r2, <any>(r12) */
    { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },

    /* addis r12, r12, 1 <optional> */
    { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },

    /* mtctr r11 */
    { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },

    /* ld r11, <any>(r12) <optional> */
    { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 },

    /* bctr */
    { -1, 0x4e800420, 0 },

    { 0, 0, 0 }
  };

#define PPC64_STANDARD_LINKAGE1_LEN ARRAY_SIZE (ppc64_standard_linkage1)

static struct ppc_insn_pattern ppc64_standard_linkage2[] =
  {
    /* addis r12, r2, <any> */
    { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },

    /* std r2, 40(r1) */
    { -1, insn_ds (62, 2, 1, 40, 0), 0 },

    /* ld r11, <any>(r12) */
    { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },

    /* addi r12, r12, <any> <optional> */
    { insn_d (-1, -1, -1, 0), insn_d (14, 12, 12, 0), 1 },

    /* mtctr r11 */
    { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },

    /* ld r2, <any>(r12) */
    { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },

    /* ld r11, <any>(r12) <optional> */
    { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 },

    /* bctr */
    { -1, 0x4e800420, 0 },

    { 0, 0, 0 }
  };

#define PPC64_STANDARD_LINKAGE2_LEN ARRAY_SIZE (ppc64_standard_linkage2)

static struct ppc_insn_pattern ppc64_standard_linkage3[] =
  {
    /* std r2, 40(r1) */
    { -1, insn_ds (62, 2, 1, 40, 0), 0 },

    /* ld r11, <any>(r2) */
    { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 },

    /* addi r2, r2, <any> <optional> */
    { insn_d (-1, -1, -1, 0), insn_d (14, 2, 2, 0), 1 },

    /* mtctr r11 */
    { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },

    /* ld r11, <any>(r2) <optional> */
    { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 1 },

    /* ld r2, <any>(r2) */
    { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 2, 0, 0), 0 },

    /* bctr */
    { -1, 0x4e800420, 0 },

    { 0, 0, 0 }
  };

#define PPC64_STANDARD_LINKAGE3_LEN ARRAY_SIZE (ppc64_standard_linkage3)

/* When the dynamic linker is doing lazy symbol resolution, the first
   call to a function in another object will go like this:

   - The user's function calls the linkage function:

	 100007c4:	4b ff fc d5		bl	10000498
	 100007c8:	e8 41 00 28		ld	r2,40(r1)

   - The linkage function loads the entry point (and other stuff) from
	 the function descriptor in the PLT, and jumps to it:

	 10000498:	3d 82 00 00		addis	r12,r2,0
	 1000049c:	f8 41 00 28		std	r2,40(r1)
	 100004a0:	e9 6c 80 98		ld	r11,-32616(r12)
	 100004a4:	e8 4c 80 a0		ld	r2,-32608(r12)
	 100004a8:	7d 69 03 a6		mtctr	r11
	 100004ac:	e9 6c 80 a8		ld	r11,-32600(r12)
	 100004b0:	4e 80 04 20		bctr

   - But since this is the first time that PLT entry has been used, it
	 sends control to its glink entry.  That loads the number of the
	 PLT entry and jumps to the common glink0 code:

	 10000c98:	38 00 00 00		li	r0,0
	 10000c9c:	4b ff ff dc		b	10000c78

   - The common glink0 code then transfers control to the dynamic
	 linker's fixup code:

	 10000c78:	e8 41 00 28		ld	r2,40(r1)
	 10000c7c:	3d 82 00 00		addis	r12,r2,0
	 10000c80:	e9 6c 80 80		ld	r11,-32640(r12)
	 10000c84:	e8 4c 80 88		ld	r2,-32632(r12)
	 10000c88:	7d 69 03 a6		mtctr	r11
	 10000c8c:	e9 6c 80 90		ld	r11,-32624(r12)
	 10000c90:	4e 80 04 20		bctr

   Eventually, this code will figure out how to skip all of this,
   including the dynamic linker.  At the moment, we just get through
   the linkage function.  */

/* If the current thread is about to execute a series of instructions
   at PC matching the ppc64_standard_linkage pattern, and INSN is the result
   from that pattern match, return the code address to which the
   standard linkage function will send them.  (This doesn't deal with
   dynamic linker lazy symbol resolution stubs.)  */

static CORE_ADDR
ppc64_standard_linkage1_target (struct frame_info *frame,
				CORE_ADDR pc, unsigned int *insn)
{
  struct gdbarch *gdbarch = get_frame_arch (frame);
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  /* The address of the function descriptor this linkage function
     references.  */
  CORE_ADDR desc
    = ((CORE_ADDR) get_frame_register_unsigned (frame,
						tdep->ppc_gp0_regnum + 2)
       + (ppc_insn_d_field (insn[0]) << 16)
       + ppc_insn_ds_field (insn[2]));

  /* The first word of the descriptor is the entry point.  Return that.  */
  return ppc64_desc_entry_point (gdbarch, desc);
}

static CORE_ADDR
ppc64_standard_linkage2_target (struct frame_info *frame,
				CORE_ADDR pc, unsigned int *insn)
{
  struct gdbarch *gdbarch = get_frame_arch (frame);
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  /* The address of the function descriptor this linkage function
     references.  */
  CORE_ADDR desc
    = ((CORE_ADDR) get_frame_register_unsigned (frame,
						tdep->ppc_gp0_regnum + 2)
       + (ppc_insn_d_field (insn[0]) << 16)
       + ppc_insn_ds_field (insn[2]));

  /* The first word of the descriptor is the entry point.  Return that.  */
  return ppc64_desc_entry_point (gdbarch, desc);
}

static CORE_ADDR
ppc64_standard_linkage3_target (struct frame_info *frame,
				CORE_ADDR pc, unsigned int *insn)
{
  struct gdbarch *gdbarch = get_frame_arch (frame);
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  /* The address of the function descriptor this linkage function
     references.  */
  CORE_ADDR desc
    = ((CORE_ADDR) get_frame_register_unsigned (frame,
						tdep->ppc_gp0_regnum + 2)
       + ppc_insn_ds_field (insn[1]));

  /* The first word of the descriptor is the entry point.  Return that.  */
  return ppc64_desc_entry_point (gdbarch, desc);
}


/* Given that we've begun executing a call trampoline at PC, return
   the entry point of the function the trampoline will go to.  */

CORE_ADDR
ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
  unsigned int ppc64_standard_linkage1_insn[PPC64_STANDARD_LINKAGE1_LEN];
  unsigned int ppc64_standard_linkage2_insn[PPC64_STANDARD_LINKAGE2_LEN];
  unsigned int ppc64_standard_linkage3_insn[PPC64_STANDARD_LINKAGE3_LEN];
  CORE_ADDR target;

  if (ppc_insns_match_pattern (pc, ppc64_standard_linkage1,
			       ppc64_standard_linkage1_insn))
    pc = ppc64_standard_linkage1_target (frame, pc,
					 ppc64_standard_linkage1_insn);
  else if (ppc_insns_match_pattern (pc, ppc64_standard_linkage2,
				    ppc64_standard_linkage2_insn))
    pc = ppc64_standard_linkage2_target (frame, pc,
					 ppc64_standard_linkage2_insn);
  else if (ppc_insns_match_pattern (pc, ppc64_standard_linkage3,
				    ppc64_standard_linkage3_insn))
    pc = ppc64_standard_linkage3_target (frame, pc,
					 ppc64_standard_linkage3_insn);
  else
    return 0;

  /* The PLT descriptor will either point to the already resolved target
     address, or else to a glink stub.  As the latter carry synthetic @plt
     symbols, find_solib_trampoline_target should be able to resolve them.  */
  target = find_solib_trampoline_target (frame, pc);
  return target ? target : pc;
}

/* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64
   GNU/Linux.

   Usually a function pointer's representation is simply the address
   of the function.  On GNU/Linux on the PowerPC however, a function
   pointer may be a pointer to a function descriptor.

   For PPC64, a function descriptor is a TOC entry, in a data section,
   which contains three words: the first word is the address of the
   function, the second word is the TOC pointer (r2), and the third word
   is the static chain value.

   Throughout GDB it is currently assumed that a function pointer contains
   the address of the function, which is not easy to fix.  In addition, the
   conversion of a function address to a function pointer would
   require allocation of a TOC entry in the inferior's memory space,
   with all its drawbacks.  To be able to call C++ virtual methods in
   the inferior (which are called via function pointers),
   find_function_addr uses this function to get the function address
   from a function pointer.

   If ADDR points at what is clearly a function descriptor, transform
   it into the address of the corresponding function, if needed.  Be
   conservative, otherwise GDB will do the transformation on any
   random addresses such as occur when there is no symbol table.  */

CORE_ADDR
ppc64_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
					CORE_ADDR addr,
					struct target_ops *targ)
{
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  struct target_section *s = target_section_by_addr (targ, addr);

  /* Check if ADDR points to a function descriptor.  */
  if (s && strcmp (s->the_bfd_section->name, ".opd") == 0)
    {
      /* There may be relocations that need to be applied to the .opd 
	 section.  Unfortunately, this function may be called at a time
	 where these relocations have not yet been performed -- this can
	 happen for example shortly after a library has been loaded with
	 dlopen, but ld.so has not yet applied the relocations.

	 To cope with both the case where the relocation has been applied,
	 and the case where it has not yet been applied, we do *not* read
	 the (maybe) relocated value from target memory, but we instead
	 read the non-relocated value from the BFD, and apply the relocation
	 offset manually.

	 This makes the assumption that all .opd entries are always relocated
	 by the same offset the section itself was relocated.  This should
	 always be the case for GNU/Linux executables and shared libraries.
	 Note that other kind of object files (e.g. those added via
	 add-symbol-files) will currently never end up here anyway, as this
	 function accesses *target* sections only; only the main exec and
	 shared libraries are ever added to the target.  */

      gdb_byte buf[8];
      int res;

      res = bfd_get_section_contents (s->bfd, s->the_bfd_section,
				      &buf, addr - s->addr, 8);
      if (res != 0)
	return extract_unsigned_integer (buf, 8, byte_order)
		- bfd_section_vma (s->bfd, s->the_bfd_section) + s->addr;
   }

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