* target.h (struct section_table): Rename to ...

[deliverable/binutils-gdb.git] / gdb / ppc-linux-tdep.c

diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c
index a82c95ea4d6bc44983685078d70a70862242ebda..da332f3f0e2c209e5202f610cf54f6447f1379cd 100644 (file)
--- a/gdb/ppc-linux-tdep.c
+++ b/gdb/ppc-linux-tdep.c
@@ -1,7 +1,7 @@
 /* Target-dependent code for GDB, the GNU debugger.
 
    Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
 /* Target-dependent code for GDB, the GNU debugger.
 
    Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,

-   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009

    Free Software Foundation, Inc.
 
    This file is part of GDB.
    Free Software Foundation, Inc.
 
    This file is part of GDB.


@@ -34,119 +34,25 @@
 #include "regset.h"
 #include "solib-svr4.h"
 #include "ppc-tdep.h"
 #include "regset.h"
 #include "solib-svr4.h"
 #include "ppc-tdep.h"

+#include "ppc-linux-tdep.h"

 #include "trad-frame.h"
 #include "frame-unwind.h"
 #include "tramp-frame.h"
 
 #include "trad-frame.h"
 #include "frame-unwind.h"
 #include "tramp-frame.h"
 

-static CORE_ADDR
-ppc_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
-{
-  gdb_byte buf[4];
-  struct obj_section *sect;
-  struct objfile *objfile;
-  unsigned long insn;
-  CORE_ADDR plt_start = 0;
-  CORE_ADDR symtab = 0;
-  CORE_ADDR strtab = 0;
-  int num_slots = -1;
-  int reloc_index = -1;
-  CORE_ADDR plt_table;
-  CORE_ADDR reloc;
-  CORE_ADDR sym;
-  long symidx;
-  char symname[1024];
-  struct minimal_symbol *msymbol;
-
-  /* Find the section pc is in; if not in .plt, try the default method.  */
-  sect = find_pc_section (pc);
-  if (!sect || strcmp (sect->the_bfd_section->name, ".plt") != 0)
-    return find_solib_trampoline_target (frame, pc);
-
-  objfile = sect->objfile;
-
-  /* Pick up the instruction at pc.  It had better be of the
-     form
-     li r11, IDX
-
-     where IDX is an index into the plt_table.  */
-
-  if (target_read_memory (pc, buf, 4) != 0)
-    return 0;
-  insn = extract_unsigned_integer (buf, 4);
-
-  if ((insn & 0xffff0000) != 0x39600000 /* li r11, VAL */ )
-    return 0;
-
-  reloc_index = (insn << 16) >> 16;
-
-  /* Find the objfile that pc is in and obtain the information
-     necessary for finding the symbol name. */
-  for (sect = objfile->sections; sect < objfile->sections_end; ++sect)
-    {
-      const char *secname = sect->the_bfd_section->name;
-      if (strcmp (secname, ".plt") == 0)
-       plt_start = sect->addr;
-      else if (strcmp (secname, ".rela.plt") == 0)
-       num_slots = ((int) sect->endaddr - (int) sect->addr) / 12;
-      else if (strcmp (secname, ".dynsym") == 0)
-       symtab = sect->addr;
-      else if (strcmp (secname, ".dynstr") == 0)
-       strtab = sect->addr;
-    }
-
-  /* Make sure we have all the information we need. */
-  if (plt_start == 0 || num_slots == -1 || symtab == 0 || strtab == 0)
-    return 0;
-
-  /* Compute the value of the plt table */
-  plt_table = plt_start + 72 + 8 * num_slots;
-
-  /* Get address of the relocation entry (Elf32_Rela) */
-  if (target_read_memory (plt_table + reloc_index, buf, 4) != 0)
-    return 0;
-  reloc = extract_unsigned_integer (buf, 4);
-
-  sect = find_pc_section (reloc);
-  if (!sect)
-    return 0;
-
-  if (strcmp (sect->the_bfd_section->name, ".text") == 0)
-    return reloc;
-
-  /* Now get the r_info field which is the relocation type and symbol
-     index. */
-  if (target_read_memory (reloc + 4, buf, 4) != 0)
-    return 0;
-  symidx = extract_unsigned_integer (buf, 4);
-
-  /* Shift out the relocation type leaving just the symbol index */
-  /* symidx = ELF32_R_SYM(symidx); */
-  symidx = symidx >> 8;
-
-  /* compute the address of the symbol */
-  sym = symtab + symidx * 4;
-
-  /* Fetch the string table index */
-  if (target_read_memory (sym, buf, 4) != 0)
-    return 0;
-  symidx = extract_unsigned_integer (buf, 4);
-
-  /* Fetch the string; we don't know how long it is.  Is it possible
-     that the following will fail because we're trying to fetch too
-     much? */
-  if (target_read_memory (strtab + symidx, (gdb_byte *) symname,
-                         sizeof (symname)) != 0)
-    return 0;
+#include "features/rs6000/powerpc-32l.c"
+#include "features/rs6000/powerpc-altivec32l.c"
+#include "features/rs6000/powerpc-vsx32l.c"
+#include "features/rs6000/powerpc-isa205-32l.c"
+#include "features/rs6000/powerpc-isa205-altivec32l.c"
+#include "features/rs6000/powerpc-isa205-vsx32l.c"
+#include "features/rs6000/powerpc-64l.c"
+#include "features/rs6000/powerpc-altivec64l.c"
+#include "features/rs6000/powerpc-vsx64l.c"
+#include "features/rs6000/powerpc-isa205-64l.c"
+#include "features/rs6000/powerpc-isa205-altivec64l.c"
+#include "features/rs6000/powerpc-isa205-vsx64l.c"
+#include "features/rs6000/powerpc-e500l.c"

 
 

-  /* This might not work right if we have multiple symbols with the
-     same name; the only way to really get it right is to perform
-     the same sort of lookup as the dynamic linker. */
-  msymbol = lookup_minimal_symbol_text (symname, NULL);
-  if (!msymbol)
-    return 0;
-
-  return SYMBOL_VALUE_ADDRESS (msymbol);
-}

 
 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
    in much the same fashion as memory_remove_breakpoint in mem-break.c,
 
 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
    in much the same fashion as memory_remove_breakpoint in mem-break.c,


@@ -272,20 +178,24 @@ ppc_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
    else in the event that some other platform has similar needs with
    regard to removing breakpoints in some potentially self modifying
    code.  */
    else in the event that some other platform has similar needs with
    regard to removing breakpoints in some potentially self modifying
    code.  */

-int
-ppc_linux_memory_remove_breakpoint (struct bp_target_info *bp_tgt)
+static int
+ppc_linux_memory_remove_breakpoint (struct gdbarch *gdbarch,
+                                   struct bp_target_info *bp_tgt)

 {
   CORE_ADDR addr = bp_tgt->placed_address;
   const unsigned char *bp;
   int val;
   int bplen;
   gdb_byte old_contents[BREAKPOINT_MAX];
 {
   CORE_ADDR addr = bp_tgt->placed_address;
   const unsigned char *bp;
   int val;
   int bplen;
   gdb_byte old_contents[BREAKPOINT_MAX];

+  struct cleanup *cleanup;

 
   /* Determine appropriate breakpoint contents and size for this address.  */
 
   /* Determine appropriate breakpoint contents and size for this address.  */

-  bp = gdbarch_breakpoint_from_pc (current_gdbarch, &addr, &bplen);
+  bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);

   if (bp == NULL)
     error (_("Software breakpoints not implemented for this target."));
 
   if (bp == NULL)
     error (_("Software breakpoints not implemented for this target."));
 

+  /* Make sure we see the memory breakpoints.  */
+  cleanup = make_show_memory_breakpoints_cleanup (1);

   val = target_read_memory (addr, old_contents, bplen);
 
   /* If our breakpoint is no longer at the address, this means that the
   val = target_read_memory (addr, old_contents, bplen);
 
   /* If our breakpoint is no longer at the address, this means that the


@@ -294,6 +204,7 @@ ppc_linux_memory_remove_breakpoint (struct bp_target_info *bp_tgt)
   if (val == 0 && memcmp (bp, old_contents, bplen) == 0)
     val = target_write_memory (addr, bp_tgt->shadow_contents, bplen);
 
   if (val == 0 && memcmp (bp, old_contents, bplen) == 0)
     val = target_write_memory (addr, bp_tgt->shadow_contents, bplen);
 

+  do_cleanups (cleanup);

   return val;
 }
 
   return val;
 }
 


@@ -303,9 +214,9 @@ ppc_linux_memory_remove_breakpoint (struct bp_target_info *bp_tgt)
    which were added later, do get returned in a register though.  */
 
 static enum return_value_convention
    which were added later, do get returned in a register though.  */
 
 static enum return_value_convention

-ppc_linux_return_value (struct gdbarch *gdbarch, struct type *valtype,
-                       struct regcache *regcache, gdb_byte *readbuf,
-                       const gdb_byte *writebuf)
+ppc_linux_return_value (struct gdbarch *gdbarch, struct type *func_type,
+                       struct type *valtype, struct regcache *regcache,
+                       gdb_byte *readbuf, const gdb_byte *writebuf)

 {  
   if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
        || TYPE_CODE (valtype) == TYPE_CODE_UNION)
 {  
   if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
        || TYPE_CODE (valtype) == TYPE_CODE_UNION)


@@ -313,8 +224,8 @@ ppc_linux_return_value (struct gdbarch *gdbarch, struct type *valtype,
           && TYPE_VECTOR (valtype)))
     return RETURN_VALUE_STRUCT_CONVENTION;
   else
           && TYPE_VECTOR (valtype)))
     return RETURN_VALUE_STRUCT_CONVENTION;
   else

-    return ppc_sysv_abi_return_value (gdbarch, valtype, regcache, readbuf,
-                                     writebuf);
+    return ppc_sysv_abi_return_value (gdbarch, func_type, valtype, regcache,
+                                     readbuf, writebuf);

 }
 
 /* Macros for matching instructions.  Note that, since all the
 }
 
 /* Macros for matching instructions.  Note that, since all the


@@ -428,7 +339,7 @@ ppc64_desc_entry_point (CORE_ADDR desc)
 /* Pattern for the standard linkage function.  These are built by
    build_plt_stub in elf64-ppc.c, whose GLINK argument is always
    zero.  */
 /* 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 insn_pattern ppc64_standard_linkage[] =
+static struct insn_pattern ppc64_standard_linkage1[] =

   {
     /* addis r12, r2, <any> */
     { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
   {
     /* addis r12, r2, <any> */
     { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },


@@ -440,17 +351,16 @@ static struct insn_pattern ppc64_standard_linkage[] =
     { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
 
     /* addis r12, r12, 1 <optional> */
     { 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, 2, 1), 1 },
+    { 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> */
 
     /* 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, 2, 1), 1 },
+    { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },

 
     /* mtctr r11 */
 
     /* mtctr r11 */

-    { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467),
-      0 },
+    { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },

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


@@ -460,8 +370,68 @@ static struct insn_pattern ppc64_standard_linkage[] =
 
     { 0, 0, 0 }
   };
 
     { 0, 0, 0 }
   };

-#define PPC64_STANDARD_LINKAGE_LEN \
-  (sizeof (ppc64_standard_linkage) / sizeof (ppc64_standard_linkage[0]))
+#define PPC64_STANDARD_LINKAGE1_LEN \
+  (sizeof (ppc64_standard_linkage1) / sizeof (ppc64_standard_linkage1[0]))
+
+static struct 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) */
+    { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
+      
+    /* bctr */
+    { -1, 0x4e800420, 0 },
+
+    { 0, 0, 0 }
+  };
+#define PPC64_STANDARD_LINKAGE2_LEN \
+  (sizeof (ppc64_standard_linkage2) / sizeof (ppc64_standard_linkage2[0]))
+
+static struct 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) */
+    { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 },
+      
+    /* 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 \
+  (sizeof (ppc64_standard_linkage3) / sizeof (ppc64_standard_linkage3[0]))
+

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


@@ -510,8 +480,8 @@ static struct insn_pattern ppc64_standard_linkage[] =
    standard linkage function will send them.  (This doesn't deal with
    dynamic linker lazy symbol resolution stubs.)  */
 static CORE_ADDR
    standard linkage function will send them.  (This doesn't deal with
    dynamic linker lazy symbol resolution stubs.)  */
 static CORE_ADDR

-ppc64_standard_linkage_target (struct frame_info *frame,
-                              CORE_ADDR pc, unsigned int *insn)
+ppc64_standard_linkage1_target (struct frame_info *frame,
+                               CORE_ADDR pc, unsigned int *insn)

 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
 
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
 


@@ -527,24 +497,100 @@ ppc64_standard_linkage_target (struct frame_info *frame,
   return ppc64_desc_entry_point (desc);
 }
 
   return ppc64_desc_entry_point (desc);
 }
 

+static struct core_regset_section ppc_linux_vsx_regset_sections[] =
+{
+  { ".reg", 268 },
+  { ".reg2", 264 },
+  { ".reg-ppc-vmx", 544 },
+  { ".reg-ppc-vsx", 256 },
+  { NULL, 0}
+};
+
+static struct core_regset_section ppc_linux_vmx_regset_sections[] =
+{
+  { ".reg", 268 },
+  { ".reg2", 264 },
+  { ".reg-ppc-vmx", 544 },
+  { NULL, 0}
+};
+
+static struct core_regset_section ppc_linux_fp_regset_sections[] =
+{
+  { ".reg", 268 },
+  { ".reg2", 264 },
+  { NULL, 0}
+};
+
+static CORE_ADDR
+ppc64_standard_linkage2_target (struct frame_info *frame,
+                               CORE_ADDR pc, unsigned int *insn)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
+
+  /* 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)
+       + (insn_d_field (insn[0]) << 16)
+       + insn_ds_field (insn[2]));
+
+  /* The first word of the descriptor is the entry point.  Return that.  */
+  return ppc64_desc_entry_point (desc);
+}
+
+static CORE_ADDR
+ppc64_standard_linkage3_target (struct frame_info *frame,
+                               CORE_ADDR pc, unsigned int *insn)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
+
+  /* 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)
+       + insn_ds_field (insn[1]));
+
+  /* The first word of the descriptor is the entry point.  Return that.  */
+  return ppc64_desc_entry_point (desc);
+}
+

 
 /* Given that we've begun executing a call trampoline at PC, return
    the entry point of the function the trampoline will go to.  */
 static CORE_ADDR
 ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 {
 
 /* Given that we've begun executing a call trampoline at PC, return
    the entry point of the function the trampoline will go to.  */
 static CORE_ADDR
 ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 {

-  unsigned int ppc64_standard_linkage_insn[PPC64_STANDARD_LINKAGE_LEN];
-
-  if (insns_match_pattern (pc, ppc64_standard_linkage,
-                           ppc64_standard_linkage_insn))
-    return ppc64_standard_linkage_target (frame, pc,
-                                         ppc64_standard_linkage_insn);
+  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 (insns_match_pattern (pc, ppc64_standard_linkage1,
+                           ppc64_standard_linkage1_insn))
+    pc = ppc64_standard_linkage1_target (frame, pc,
+                                        ppc64_standard_linkage1_insn);
+  else if (insns_match_pattern (pc, ppc64_standard_linkage2,
+                               ppc64_standard_linkage2_insn))
+    pc = ppc64_standard_linkage2_target (frame, pc,
+                                        ppc64_standard_linkage2_insn);
+  else if (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;
   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 PPC
+/* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64

    GNU/Linux.
 
    Usually a function pointer's representation is simply the address
    GNU/Linux.
 
    Usually a function pointer's representation is simply the address


@@ -556,12 +602,6 @@ ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
    function, the second word is the TOC pointer (r2), and the third word
    is the static chain value.
 
    function, the second word is the TOC pointer (r2), and the third word
    is the static chain value.
 

-   For PPC32, there are two kinds of function pointers: non-secure and
-   secure.  Non-secure function pointers point directly to the
-   function in a code section and thus need no translation.  Secure
-   ones (from GCC's -msecure-plt option) are in a data section and
-   contain one word: the address of the function.
-

    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
    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


@@ -577,55 +617,102 @@ ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
    random addresses such as occur when there is no symbol table.  */
 
 static CORE_ADDR
    random addresses such as occur when there is no symbol table.  */
 
 static CORE_ADDR

-ppc_linux_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
-                                     CORE_ADDR addr,
-                                     struct target_ops *targ)
+ppc64_linux_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
+                                       CORE_ADDR addr,
+                                       struct target_ops *targ)

 {
 {

-  struct gdbarch_tdep *tdep;
-  struct section_table *s = target_section_by_addr (targ, addr);
-  char *sect_name = NULL;
+  struct target_section *s = target_section_by_addr (targ, addr);

 
 

-  if (!s)
-    return 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)
+               - bfd_section_vma (s->bfd, s->the_bfd_section) + s->addr;
+   }

 
 

-  tdep = gdbarch_tdep (gdbarch);
+  return addr;
+}

 
 

-  switch (tdep->wordsize)
-    {
-      case 4:
-       sect_name = ".plt";
-       break;
-      case 8:
-       sect_name = ".opd";
-       break;
-      default:
-       internal_error (__FILE__, __LINE__,
-                       _("failed internal consistency check"));
-    }
+/* Wrappers to handle Linux-only registers.  */

 
 

-  /* Check if ADDR points to a function descriptor.  */
+static void
+ppc_linux_supply_gregset (const struct regset *regset,
+                         struct regcache *regcache,
+                         int regnum, const void *gregs, size_t len)
+{
+  const struct ppc_reg_offsets *offsets = regset->descr;

 
 

-  /* NOTE: this depends on the coincidence that the address of a functions
-     entry point is contained in the first word of its function descriptor
-     for both PPC-64 and for PPC-32 with secure PLTs.  */
-  if ((strcmp (s->the_bfd_section->name, sect_name) == 0)
-      && s->the_bfd_section->flags & SEC_DATA)
-    return get_target_memory_unsigned (targ, addr, tdep->wordsize);
+  ppc_supply_gregset (regset, regcache, regnum, gregs, len);

 
 

-  return addr;
+  if (ppc_linux_trap_reg_p (get_regcache_arch (regcache)))
+    {
+      /* "orig_r3" is stored 2 slots after "pc".  */
+      if (regnum == -1 || regnum == PPC_ORIG_R3_REGNUM)
+       ppc_supply_reg (regcache, PPC_ORIG_R3_REGNUM, gregs,
+                       offsets->pc_offset + 2 * offsets->gpr_size,
+                       offsets->gpr_size);
+
+      /* "trap" is stored 8 slots after "pc".  */
+      if (regnum == -1 || regnum == PPC_TRAP_REGNUM)
+       ppc_supply_reg (regcache, PPC_TRAP_REGNUM, gregs,
+                       offsets->pc_offset + 8 * offsets->gpr_size,
+                       offsets->gpr_size);
+    }

 }
 
 }
 

-/* This wrapper clears areas in the linux gregset not written by
-   ppc_collect_gregset.  */
-

 static void
 ppc_linux_collect_gregset (const struct regset *regset,
                           const struct regcache *regcache,
                           int regnum, void *gregs, size_t len)
 {
 static void
 ppc_linux_collect_gregset (const struct regset *regset,
                           const struct regcache *regcache,
                           int regnum, void *gregs, size_t len)
 {

+  const struct ppc_reg_offsets *offsets = regset->descr;
+
+  /* Clear areas in the linux gregset not written elsewhere.  */

   if (regnum == -1)
     memset (gregs, 0, len);
   if (regnum == -1)
     memset (gregs, 0, len);

+

   ppc_collect_gregset (regset, regcache, regnum, gregs, len);
   ppc_collect_gregset (regset, regcache, regnum, gregs, len);

+
+  if (ppc_linux_trap_reg_p (get_regcache_arch (regcache)))
+    {
+      /* "orig_r3" is stored 2 slots after "pc".  */
+      if (regnum == -1 || regnum == PPC_ORIG_R3_REGNUM)
+       ppc_collect_reg (regcache, PPC_ORIG_R3_REGNUM, gregs,
+                        offsets->pc_offset + 2 * offsets->gpr_size,
+                        offsets->gpr_size);
+
+      /* "trap" is stored 8 slots after "pc".  */
+      if (regnum == -1 || regnum == PPC_TRAP_REGNUM)
+       ppc_collect_reg (regcache, PPC_TRAP_REGNUM, gregs,
+                        offsets->pc_offset + 8 * offsets->gpr_size,
+                        offsets->gpr_size);
+    }

 }
 
 /* Regset descriptions.  */
 }
 
 /* Regset descriptions.  */


@@ -681,14 +768,14 @@ static const struct ppc_reg_offsets ppc64_linux_reg_offsets =
 
 static const struct regset ppc32_linux_gregset = {
   &ppc32_linux_reg_offsets,
 
 static const struct regset ppc32_linux_gregset = {
   &ppc32_linux_reg_offsets,

-  ppc_supply_gregset,
+  ppc_linux_supply_gregset,

   ppc_linux_collect_gregset,
   NULL
 };
 
 static const struct regset ppc64_linux_gregset = {
   &ppc64_linux_reg_offsets,
   ppc_linux_collect_gregset,
   NULL
 };
 
 static const struct regset ppc64_linux_gregset = {
   &ppc64_linux_reg_offsets,

-  ppc_supply_gregset,
+  ppc_linux_supply_gregset,

   ppc_linux_collect_gregset,
   NULL
 };
   ppc_linux_collect_gregset,
   NULL
 };


@@ -707,6 +794,13 @@ static const struct regset ppc32_linux_vrregset = {
   NULL
 };
 
   NULL
 };
 

+static const struct regset ppc32_linux_vsxregset = {
+  &ppc32_linux_reg_offsets,
+  ppc_supply_vsxregset,
+  ppc_collect_vsxregset,
+  NULL
+};
+

 const struct regset *
 ppc_linux_gregset (int wordsize)
 {
 const struct regset *
 ppc_linux_gregset (int wordsize)
 {


@@ -735,11 +829,13 @@ ppc_linux_regset_from_core_section (struct gdbarch *core_arch,
     return &ppc32_linux_fpregset;
   if (strcmp (sect_name, ".reg-ppc-vmx") == 0)
     return &ppc32_linux_vrregset;
     return &ppc32_linux_fpregset;
   if (strcmp (sect_name, ".reg-ppc-vmx") == 0)
     return &ppc32_linux_vrregset;

+  if (strcmp (sect_name, ".reg-ppc-vsx") == 0)
+    return &ppc32_linux_vsxregset;

   return NULL;
 }
 
 static void
   return NULL;
 }
 
 static void

-ppc_linux_sigtramp_cache (struct frame_info *next_frame,
+ppc_linux_sigtramp_cache (struct frame_info *this_frame,

                          struct trad_frame_cache *this_cache,
                          CORE_ADDR func, LONGEST offset,
                          int bias)
                          struct trad_frame_cache *this_cache,
                          CORE_ADDR func, LONGEST offset,
                          int bias)


@@ -749,12 +845,12 @@ ppc_linux_sigtramp_cache (struct frame_info *next_frame,
   CORE_ADDR gpregs;
   CORE_ADDR fpregs;
   int i;
   CORE_ADDR gpregs;
   CORE_ADDR fpregs;
   int i;

-  struct gdbarch *gdbarch = get_frame_arch (next_frame);
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);

   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 

-  base = frame_unwind_register_unsigned (next_frame,
-                                        gdbarch_sp_regnum (current_gdbarch));
-  if (bias > 0 && frame_pc_unwind (next_frame) != func)
+  base = get_frame_register_unsigned (this_frame,
+                                     gdbarch_sp_regnum (gdbarch));
+  if (bias > 0 && get_frame_pc (this_frame) != func)

     /* See below, some signal trampolines increment the stack as their
        first instruction, need to compensate for that.  */
     base -= bias;
     /* See below, some signal trampolines increment the stack as their
        first instruction, need to compensate for that.  */
     base -= bias;


@@ -773,7 +869,7 @@ ppc_linux_sigtramp_cache (struct frame_info *next_frame,
       trad_frame_set_reg_addr (this_cache, regnum, gpregs + i * tdep->wordsize);
     }
   trad_frame_set_reg_addr (this_cache,
       trad_frame_set_reg_addr (this_cache, regnum, gpregs + i * tdep->wordsize);
     }
   trad_frame_set_reg_addr (this_cache,

-                          gdbarch_pc_regnum (current_gdbarch),
+                          gdbarch_pc_regnum (gdbarch),

                           gpregs + 32 * tdep->wordsize);
   trad_frame_set_reg_addr (this_cache, tdep->ppc_ctr_regnum,
                           gpregs + 35 * tdep->wordsize);
                           gpregs + 32 * tdep->wordsize);
   trad_frame_set_reg_addr (this_cache, tdep->ppc_ctr_regnum,
                           gpregs + 35 * tdep->wordsize);


@@ -784,12 +880,20 @@ ppc_linux_sigtramp_cache (struct frame_info *next_frame,
   trad_frame_set_reg_addr (this_cache, tdep->ppc_cr_regnum,
                           gpregs + 38 * tdep->wordsize);
 
   trad_frame_set_reg_addr (this_cache, tdep->ppc_cr_regnum,
                           gpregs + 38 * tdep->wordsize);
 

+  if (ppc_linux_trap_reg_p (gdbarch))
+    {
+      trad_frame_set_reg_addr (this_cache, PPC_ORIG_R3_REGNUM,
+                              gpregs + 34 * tdep->wordsize);
+      trad_frame_set_reg_addr (this_cache, PPC_TRAP_REGNUM,
+                              gpregs + 40 * tdep->wordsize);
+    }
+

   if (ppc_floating_point_unit_p (gdbarch))
     {
       /* Floating point registers.  */
       for (i = 0; i < 32; i++)
        {
   if (ppc_floating_point_unit_p (gdbarch))
     {
       /* Floating point registers.  */
       for (i = 0; i < 32; i++)
        {

-         int regnum = i + gdbarch_fp0_regnum (current_gdbarch);
+         int regnum = i + gdbarch_fp0_regnum (gdbarch);

          trad_frame_set_reg_addr (this_cache, regnum,
                                   fpregs + i * tdep->wordsize);
        }
          trad_frame_set_reg_addr (this_cache, regnum,
                                   fpregs + i * tdep->wordsize);
        }


@@ -801,11 +905,11 @@ ppc_linux_sigtramp_cache (struct frame_info *next_frame,
 
 static void
 ppc32_linux_sigaction_cache_init (const struct tramp_frame *self,
 
 static void
 ppc32_linux_sigaction_cache_init (const struct tramp_frame *self,

-                                 struct frame_info *next_frame,
+                                 struct frame_info *this_frame,

                                  struct trad_frame_cache *this_cache,
                                  CORE_ADDR func)
 {
                                  struct trad_frame_cache *this_cache,
                                  CORE_ADDR func)
 {

-  ppc_linux_sigtramp_cache (next_frame, this_cache, func,
+  ppc_linux_sigtramp_cache (this_frame, this_cache, func,

                            0xd0 /* Offset to ucontext_t.  */
                            + 0x30 /* Offset to .reg.  */,
                            0);
                            0xd0 /* Offset to ucontext_t.  */
                            + 0x30 /* Offset to .reg.  */,
                            0);


@@ -813,11 +917,11 @@ ppc32_linux_sigaction_cache_init (const struct tramp_frame *self,
 
 static void
 ppc64_linux_sigaction_cache_init (const struct tramp_frame *self,
 
 static void
 ppc64_linux_sigaction_cache_init (const struct tramp_frame *self,

-                                 struct frame_info *next_frame,
+                                 struct frame_info *this_frame,

                                  struct trad_frame_cache *this_cache,
                                  CORE_ADDR func)
 {
                                  struct trad_frame_cache *this_cache,
                                  CORE_ADDR func)
 {

-  ppc_linux_sigtramp_cache (next_frame, this_cache, func,
+  ppc_linux_sigtramp_cache (this_frame, this_cache, func,

                            0x80 /* Offset to ucontext_t.  */
                            + 0xe0 /* Offset to .reg.  */,
                            128);
                            0x80 /* Offset to ucontext_t.  */
                            + 0xe0 /* Offset to .reg.  */,
                            128);


@@ -825,11 +929,11 @@ ppc64_linux_sigaction_cache_init (const struct tramp_frame *self,
 
 static void
 ppc32_linux_sighandler_cache_init (const struct tramp_frame *self,
 
 static void
 ppc32_linux_sighandler_cache_init (const struct tramp_frame *self,

-                                  struct frame_info *next_frame,
+                                  struct frame_info *this_frame,

                                   struct trad_frame_cache *this_cache,
                                   CORE_ADDR func)
 {
                                   struct trad_frame_cache *this_cache,
                                   CORE_ADDR func)
 {

-  ppc_linux_sigtramp_cache (next_frame, this_cache, func,
+  ppc_linux_sigtramp_cache (this_frame, this_cache, func,

                            0x40 /* Offset to ucontext_t.  */
                            + 0x1c /* Offset to .reg.  */,
                            0);
                            0x40 /* Offset to ucontext_t.  */
                            + 0x1c /* Offset to .reg.  */,
                            0);


@@ -837,11 +941,11 @@ ppc32_linux_sighandler_cache_init (const struct tramp_frame *self,
 
 static void
 ppc64_linux_sighandler_cache_init (const struct tramp_frame *self,
 
 static void
 ppc64_linux_sighandler_cache_init (const struct tramp_frame *self,

-                                  struct frame_info *next_frame,
+                                  struct frame_info *this_frame,

                                   struct trad_frame_cache *this_cache,
                                   CORE_ADDR func)
 {
                                   struct trad_frame_cache *this_cache,
                                   CORE_ADDR func)
 {

-  ppc_linux_sigtramp_cache (next_frame, this_cache, func,
+  ppc_linux_sigtramp_cache (this_frame, this_cache, func,

                            0x80 /* Offset to struct sigcontext.  */
                            + 0x38 /* Offset to .reg.  */,
                            128);
                            0x80 /* Offset to struct sigcontext.  */
                            + 0x38 /* Offset to .reg.  */,
                            128);


@@ -890,26 +994,91 @@ static struct tramp_frame ppc64_linux_sighandler_tramp_frame = {
   ppc64_linux_sighandler_cache_init
 };
 
   ppc64_linux_sighandler_cache_init
 };
 

+
+/* Return 1 if PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM are usable.  */
+int
+ppc_linux_trap_reg_p (struct gdbarch *gdbarch)
+{
+  /* If we do not have a target description with registers, then
+     the special registers will not be included in the register set.  */
+  if (!tdesc_has_registers (gdbarch_target_desc (gdbarch)))
+    return 0;
+
+  /* If we do, then it is safe to check the size.  */
+  return register_size (gdbarch, PPC_ORIG_R3_REGNUM) > 0
+         && register_size (gdbarch, PPC_TRAP_REGNUM) > 0;
+}
+
+static void
+ppc_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
+{
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+
+  regcache_cooked_write_unsigned (regcache, gdbarch_pc_regnum (gdbarch), pc);
+
+  /* Set special TRAP register to -1 to prevent the kernel from
+     messing with the PC we just installed, if we happen to be
+     within an interrupted system call that the kernel wants to
+     restart.
+
+     Note that after we return from the dummy call, the TRAP and
+     ORIG_R3 registers will be automatically restored, and the
+     kernel continues to restart the system call at this point.  */
+  if (ppc_linux_trap_reg_p (gdbarch))
+    regcache_cooked_write_unsigned (regcache, PPC_TRAP_REGNUM, -1);
+}
+
+static const struct target_desc *
+ppc_linux_core_read_description (struct gdbarch *gdbarch,
+                                struct target_ops *target,
+                                bfd *abfd)
+{
+  asection *altivec = bfd_get_section_by_name (abfd, ".reg-ppc-vmx");
+  asection *vsx = bfd_get_section_by_name (abfd, ".reg-ppc-vsx");
+  asection *section = bfd_get_section_by_name (abfd, ".reg");
+  if (! section)
+    return NULL;
+
+  switch (bfd_section_size (abfd, section))
+    {
+    case 48 * 4:
+      if (vsx)
+       return tdesc_powerpc_vsx32l;
+      else if (altivec)
+       return tdesc_powerpc_altivec32l;
+      else
+       return tdesc_powerpc_32l;
+
+    case 48 * 8:
+      if (vsx)
+       return tdesc_powerpc_vsx64l;
+      else if (altivec)
+       return tdesc_powerpc_altivec64l;
+      else
+       return tdesc_powerpc_64l;
+
+    default:
+      return NULL;
+    }
+}
+

 static void
 ppc_linux_init_abi (struct gdbarch_info info,
                     struct gdbarch *gdbarch)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 static void
 ppc_linux_init_abi (struct gdbarch_info info,
                     struct gdbarch *gdbarch)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

+  struct tdesc_arch_data *tdesc_data = (void *) info.tdep_info;

 
 

-  /* NOTE: jimb/2004-03-26: The System V ABI PowerPC Processor
-     Supplement says that long doubles are sixteen bytes long.
-     However, as one of the known warts of its ABI, PPC GNU/Linux uses
-     eight-byte long doubles.  GCC only recently got 128-bit long
-     double support on PPC, so it may be changing soon.  The
-     Linux[sic] Standards Base says that programs that use 'long
-     double' on PPC GNU/Linux are non-conformant.  */
-  /* NOTE: cagney/2005-01-25: True for both 32- and 64-bit.  */
-  set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
-
-  /* Handle PPC GNU/Linux 64-bit function pointers (which are really
-     function descriptors) and 32-bit secure PLT entries.  */
-  set_gdbarch_convert_from_func_ptr_addr
-    (gdbarch, ppc_linux_convert_from_func_ptr_addr);
+  /* PPC GNU/Linux uses either 64-bit or 128-bit long doubles; where
+     128-bit, they are IBM long double, not IEEE quad long double as
+     in the System V ABI PowerPC Processor Supplement.  We can safely
+     let them default to 128-bit, since the debug info will give the
+     size of type actually used in each case.  */
+  set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);
+  set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double);
+
+  /* Handle inferior calls during interrupted system calls.  */
+  set_gdbarch_write_pc (gdbarch, ppc_linux_write_pc);

 
   if (tdep->wordsize == 4)
     {
 
   if (tdep->wordsize == 4)
     {


@@ -926,8 +1095,7 @@ ppc_linux_init_abi (struct gdbarch_info info,
                                             ppc_linux_memory_remove_breakpoint);
 
       /* Shared library handling.  */
                                             ppc_linux_memory_remove_breakpoint);
 
       /* Shared library handling.  */

-      set_gdbarch_skip_trampoline_code (gdbarch,
-                                        ppc_linux_skip_trampoline_code);
+      set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);

       set_solib_svr4_fetch_link_map_offsets
         (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 
       set_solib_svr4_fetch_link_map_offsets
         (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 


@@ -938,6 +1106,11 @@ ppc_linux_init_abi (struct gdbarch_info info,
   
   if (tdep->wordsize == 8)
     {
   
   if (tdep->wordsize == 8)
     {

+      /* Handle PPC GNU/Linux 64-bit function pointers (which are really
+        function descriptors).  */
+      set_gdbarch_convert_from_func_ptr_addr
+       (gdbarch, ppc64_linux_convert_from_func_ptr_addr);
+

       /* Shared library handling.  */
       set_gdbarch_skip_trampoline_code (gdbarch, ppc64_skip_trampoline_code);
       set_solib_svr4_fetch_link_map_offsets
       /* Shared library handling.  */
       set_gdbarch_skip_trampoline_code (gdbarch, ppc64_skip_trampoline_code);
       set_solib_svr4_fetch_link_map_offsets


@@ -948,12 +1121,48 @@ ppc_linux_init_abi (struct gdbarch_info info,
       tramp_frame_prepend_unwinder (gdbarch, &ppc64_linux_sighandler_tramp_frame);
     }
   set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);
       tramp_frame_prepend_unwinder (gdbarch, &ppc64_linux_sighandler_tramp_frame);
     }
   set_gdbarch_regset_from_core_section (gdbarch, ppc_linux_regset_from_core_section);

+  set_gdbarch_core_read_description (gdbarch, ppc_linux_core_read_description);
+
+  /* Supported register sections.  */
+  if (tdesc_find_feature (info.target_desc,
+                         "org.gnu.gdb.power.vsx"))
+    set_gdbarch_core_regset_sections (gdbarch, ppc_linux_vsx_regset_sections);
+  else if (tdesc_find_feature (info.target_desc,
+                              "org.gnu.gdb.power.altivec"))
+    set_gdbarch_core_regset_sections (gdbarch, ppc_linux_vmx_regset_sections);
+  else
+    set_gdbarch_core_regset_sections (gdbarch, ppc_linux_fp_regset_sections);

 
   /* Enable TLS support.  */
   set_gdbarch_fetch_tls_load_module_address (gdbarch,
                                              svr4_fetch_objfile_link_map);
 
   /* Enable TLS support.  */
   set_gdbarch_fetch_tls_load_module_address (gdbarch,
                                              svr4_fetch_objfile_link_map);

+
+  if (tdesc_data)
+    {
+      const struct tdesc_feature *feature;
+
+      /* If we have target-described registers, then we can safely
+         reserve a number for PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM
+        (whether they are described or not).  */
+      gdb_assert (gdbarch_num_regs (gdbarch) <= PPC_ORIG_R3_REGNUM);
+      set_gdbarch_num_regs (gdbarch, PPC_TRAP_REGNUM + 1);
+
+      /* If they are present, then assign them to the reserved number.  */
+      feature = tdesc_find_feature (info.target_desc,
+                                    "org.gnu.gdb.power.linux");
+      if (feature != NULL)
+       {
+         tdesc_numbered_register (feature, tdesc_data,
+                                  PPC_ORIG_R3_REGNUM, "orig_r3");
+         tdesc_numbered_register (feature, tdesc_data,
+                                  PPC_TRAP_REGNUM, "trap");
+       }
+    }

 }
 
 }
 

+/* Provide a prototype to silence -Wmissing-prototypes.  */
+extern initialize_file_ftype _initialize_ppc_linux_tdep;
+

 void
 _initialize_ppc_linux_tdep (void)
 {
 void
 _initialize_ppc_linux_tdep (void)
 {


@@ -965,4 +1174,19 @@ _initialize_ppc_linux_tdep (void)
                          ppc_linux_init_abi);
   gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
                          ppc_linux_init_abi);
                          ppc_linux_init_abi);
   gdbarch_register_osabi (bfd_arch_rs6000, bfd_mach_rs6k, GDB_OSABI_LINUX,
                          ppc_linux_init_abi);

+
+  /* Initialize the Linux target descriptions.  */
+  initialize_tdesc_powerpc_32l ();
+  initialize_tdesc_powerpc_altivec32l ();
+  initialize_tdesc_powerpc_vsx32l ();
+  initialize_tdesc_powerpc_isa205_32l ();
+  initialize_tdesc_powerpc_isa205_altivec32l ();
+  initialize_tdesc_powerpc_isa205_vsx32l ();
+  initialize_tdesc_powerpc_64l ();
+  initialize_tdesc_powerpc_altivec64l ();
+  initialize_tdesc_powerpc_vsx64l ();
+  initialize_tdesc_powerpc_isa205_64l ();
+  initialize_tdesc_powerpc_isa205_altivec64l ();
+  initialize_tdesc_powerpc_isa205_vsx64l ();
+  initialize_tdesc_powerpc_e500l ();

 }
 }