gdb.base/skip.exp: Clean up multiple references to same test name.

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

diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c
index 785f4519a5f7d362b501cb977551c51a5b0f333a..599b0768a9a64976b6e3346c02c05d3fa56ba5f1 100644 (file)
--- a/gdb/rs6000-tdep.c
+++ b/gdb/rs6000-tdep.c
@@ -1,6 +1,6 @@
 /* Target-dependent code for GDB, the GNU debugger.
 
-   Copyright (C) 1986-2015 Free Software Foundation, Inc.
+   Copyright (C) 1986-2016 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -328,7 +328,7 @@ init_sim_regno_table (struct gdbarch *arch)
     set_sim_regno (sim_regno, tdep->ppc_acc_regnum, sim_ppc_acc_regnum);
   /* spefscr is a special-purpose register, so the code below handles it.  */
 
-#ifdef WITH_SIM
+#ifdef WITH_PPC_SIM
   /* Now handle all special-purpose registers.  Verify that they
      haven't mistakenly been assigned numbers by any of the above
      code.  */
@@ -507,7 +507,8 @@ ppc_supply_gregset (const struct regset *regset, struct regcache *regcache,
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-  const struct ppc_reg_offsets *offsets = regset->regmap;
+  const struct ppc_reg_offsets *offsets
+    = (const struct ppc_reg_offsets *) regset->regmap;
   size_t offset;
   int regsize;
 
@@ -519,27 +520,31 @@ ppc_supply_gregset (const struct regset *regset, struct regcache *regcache,
       for (i = tdep->ppc_gp0_regnum, offset = offsets->r0_offset;
           i < tdep->ppc_gp0_regnum + ppc_num_gprs;
           i++, offset += gpr_size)
-       ppc_supply_reg (regcache, i, gregs, offset, gpr_size);
+       ppc_supply_reg (regcache, i, (const gdb_byte *) gregs, offset,
+                       gpr_size);
 
       ppc_supply_reg (regcache, gdbarch_pc_regnum (gdbarch),
-                     gregs, offsets->pc_offset, gpr_size);
+                     (const gdb_byte *) gregs, offsets->pc_offset, gpr_size);
       ppc_supply_reg (regcache, tdep->ppc_ps_regnum,
-                     gregs, offsets->ps_offset, gpr_size);
+                     (const gdb_byte *) gregs, offsets->ps_offset, gpr_size);
       ppc_supply_reg (regcache, tdep->ppc_lr_regnum,
-                     gregs, offsets->lr_offset, gpr_size);
+                     (const gdb_byte *) gregs, offsets->lr_offset, gpr_size);
       ppc_supply_reg (regcache, tdep->ppc_ctr_regnum,
-                     gregs, offsets->ctr_offset, gpr_size);
+                     (const gdb_byte *) gregs, offsets->ctr_offset, gpr_size);
       ppc_supply_reg (regcache, tdep->ppc_cr_regnum,
-                     gregs, offsets->cr_offset, offsets->xr_size);
+                     (const gdb_byte *) gregs, offsets->cr_offset,
+                     offsets->xr_size);
       ppc_supply_reg (regcache, tdep->ppc_xer_regnum,
-                     gregs, offsets->xer_offset, offsets->xr_size);
+                     (const gdb_byte *) gregs, offsets->xer_offset,
+                     offsets->xr_size);
       ppc_supply_reg (regcache, tdep->ppc_mq_regnum,
-                     gregs, offsets->mq_offset, offsets->xr_size);
+                     (const gdb_byte *) gregs, offsets->mq_offset,
+                     offsets->xr_size);
       return;
     }
 
   offset = ppc_greg_offset (gdbarch, tdep, offsets, regnum, &regsize);
-  ppc_supply_reg (regcache, regnum, gregs, offset, regsize);
+  ppc_supply_reg (regcache, regnum, (const gdb_byte *) gregs, offset, regsize);
 }
 
 /* Supply register REGNUM in the floating-point register set REGSET
@@ -559,7 +564,7 @@ ppc_supply_fpregset (const struct regset *regset, struct regcache *regcache,
     return;
 
   tdep = gdbarch_tdep (gdbarch);
-  offsets = regset->regmap;
+  offsets = (const struct ppc_reg_offsets *) regset->regmap;
   if (regnum == -1)
     {
       int i;
@@ -567,15 +572,16 @@ ppc_supply_fpregset (const struct regset *regset, struct regcache *regcache,
       for (i = tdep->ppc_fp0_regnum, offset = offsets->f0_offset;
           i < tdep->ppc_fp0_regnum + ppc_num_fprs;
           i++, offset += 8)
-       ppc_supply_reg (regcache, i, fpregs, offset, 8);
+       ppc_supply_reg (regcache, i, (const gdb_byte *) fpregs, offset, 8);
 
       ppc_supply_reg (regcache, tdep->ppc_fpscr_regnum,
-                     fpregs, offsets->fpscr_offset, offsets->fpscr_size);
+                     (const gdb_byte *) fpregs, offsets->fpscr_offset,
+                     offsets->fpscr_size);
       return;
     }
 
   offset = ppc_fpreg_offset (tdep, offsets, regnum);
-  ppc_supply_reg (regcache, regnum, fpregs, offset,
+  ppc_supply_reg (regcache, regnum, (const gdb_byte *) fpregs, offset,
                  regnum == tdep->ppc_fpscr_regnum ? offsets->fpscr_size : 8);
 }
 
@@ -602,12 +608,12 @@ ppc_supply_vsxregset (const struct regset *regset, struct regcache *regcache,
       for (i = tdep->ppc_vsr0_upper_regnum;
           i < tdep->ppc_vsr0_upper_regnum + 32;
           i++)
-       ppc_supply_reg (regcache, i, vsxregs, 0, 8);
+       ppc_supply_reg (regcache, i, (const gdb_byte *) vsxregs, 0, 8);
 
       return;
     }
   else
-    ppc_supply_reg (regcache, regnum, vsxregs, 0, 8);
+    ppc_supply_reg (regcache, regnum, (const gdb_byte *) vsxregs, 0, 8);
 }
 
 /* Supply register REGNUM in the Altivec register set REGSET
@@ -627,7 +633,7 @@ ppc_supply_vrregset (const struct regset *regset, struct regcache *regcache,
     return;
 
   tdep = gdbarch_tdep (gdbarch);
-  offsets = regset->regmap;
+  offsets = (const struct ppc_reg_offsets *) regset->regmap;
   if (regnum == -1)
     {
       int i;
@@ -635,23 +641,23 @@ ppc_supply_vrregset (const struct regset *regset, struct regcache *regcache,
       for (i = tdep->ppc_vr0_regnum, offset = offsets->vr0_offset;
           i < tdep->ppc_vr0_regnum + ppc_num_vrs;
           i++, offset += 16)
-        ppc_supply_reg (regcache, i, vrregs, offset, 16);
+        ppc_supply_reg (regcache, i, (const gdb_byte *) vrregs, offset, 16);
 
       ppc_supply_reg (regcache, (tdep->ppc_vrsave_regnum - 1),
-                     vrregs, offsets->vscr_offset, 4);
+                     (const gdb_byte *) vrregs, offsets->vscr_offset, 4);
 
       ppc_supply_reg (regcache, tdep->ppc_vrsave_regnum,
-                     vrregs, offsets->vrsave_offset, 4);
+                     (const gdb_byte *) vrregs, offsets->vrsave_offset, 4);
       return;
     }
 
   offset = ppc_vrreg_offset (tdep, offsets, regnum);
   if (regnum != tdep->ppc_vrsave_regnum
       && regnum != tdep->ppc_vrsave_regnum - 1)
-    ppc_supply_reg (regcache, regnum, vrregs, offset, 16);
+    ppc_supply_reg (regcache, regnum, (const gdb_byte *) vrregs, offset, 16);
   else
     ppc_supply_reg (regcache, regnum,
-                   vrregs, offset, 4);
+                   (const gdb_byte *) vrregs, offset, 4);
 }
 
 /* Collect register REGNUM in the general-purpose register set
@@ -666,7 +672,8 @@ ppc_collect_gregset (const struct regset *regset,
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-  const struct ppc_reg_offsets *offsets = regset->regmap;
+  const struct ppc_reg_offsets *offsets
+    = (const struct ppc_reg_offsets *) regset->regmap;
   size_t offset;
   int regsize;
 
@@ -678,27 +685,30 @@ ppc_collect_gregset (const struct regset *regset,
       for (i = tdep->ppc_gp0_regnum, offset = offsets->r0_offset;
           i < tdep->ppc_gp0_regnum + ppc_num_gprs;
           i++, offset += gpr_size)
-       ppc_collect_reg (regcache, i, gregs, offset, gpr_size);
+       ppc_collect_reg (regcache, i, (gdb_byte *) gregs, offset, gpr_size);
 
       ppc_collect_reg (regcache, gdbarch_pc_regnum (gdbarch),
-                      gregs, offsets->pc_offset, gpr_size);
+                      (gdb_byte *) gregs, offsets->pc_offset, gpr_size);
       ppc_collect_reg (regcache, tdep->ppc_ps_regnum,
-                      gregs, offsets->ps_offset, gpr_size);
+                      (gdb_byte *) gregs, offsets->ps_offset, gpr_size);
       ppc_collect_reg (regcache, tdep->ppc_lr_regnum,
-                      gregs, offsets->lr_offset, gpr_size);
+                      (gdb_byte *) gregs, offsets->lr_offset, gpr_size);
       ppc_collect_reg (regcache, tdep->ppc_ctr_regnum,
-                      gregs, offsets->ctr_offset, gpr_size);
+                      (gdb_byte *) gregs, offsets->ctr_offset, gpr_size);
       ppc_collect_reg (regcache, tdep->ppc_cr_regnum,
-                      gregs, offsets->cr_offset, offsets->xr_size);
+                      (gdb_byte *) gregs, offsets->cr_offset,
+                      offsets->xr_size);
       ppc_collect_reg (regcache, tdep->ppc_xer_regnum,
-                      gregs, offsets->xer_offset, offsets->xr_size);
+                      (gdb_byte *) gregs, offsets->xer_offset,
+                      offsets->xr_size);
       ppc_collect_reg (regcache, tdep->ppc_mq_regnum,
-                      gregs, offsets->mq_offset, offsets->xr_size);
+                      (gdb_byte *) gregs, offsets->mq_offset,
+                      offsets->xr_size);
       return;
     }
 
   offset = ppc_greg_offset (gdbarch, tdep, offsets, regnum, &regsize);
-  ppc_collect_reg (regcache, regnum, gregs, offset, regsize);
+  ppc_collect_reg (regcache, regnum, (gdb_byte *) gregs, offset, regsize);
 }
 
 /* Collect register REGNUM in the floating-point register set
@@ -720,7 +730,7 @@ ppc_collect_fpregset (const struct regset *regset,
     return;
 
   tdep = gdbarch_tdep (gdbarch);
-  offsets = regset->regmap;
+  offsets = (const struct ppc_reg_offsets *) regset->regmap;
   if (regnum == -1)
     {
       int i;
@@ -728,15 +738,16 @@ ppc_collect_fpregset (const struct regset *regset,
       for (i = tdep->ppc_fp0_regnum, offset = offsets->f0_offset;
           i < tdep->ppc_fp0_regnum + ppc_num_fprs;
           i++, offset += 8)
-       ppc_collect_reg (regcache, i, fpregs, offset, 8);
+       ppc_collect_reg (regcache, i, (gdb_byte *) fpregs, offset, 8);
 
       ppc_collect_reg (regcache, tdep->ppc_fpscr_regnum,
-                      fpregs, offsets->fpscr_offset, offsets->fpscr_size);
+                      (gdb_byte *) fpregs, offsets->fpscr_offset,
+                      offsets->fpscr_size);
       return;
     }
 
   offset = ppc_fpreg_offset (tdep, offsets, regnum);
-  ppc_collect_reg (regcache, regnum, fpregs, offset,
+  ppc_collect_reg (regcache, regnum, (gdb_byte *) fpregs, offset,
                   regnum == tdep->ppc_fpscr_regnum ? offsets->fpscr_size : 8);
 }
 
@@ -765,12 +776,12 @@ ppc_collect_vsxregset (const struct regset *regset,
       for (i = tdep->ppc_vsr0_upper_regnum;
           i < tdep->ppc_vsr0_upper_regnum + 32;
           i++)
-       ppc_collect_reg (regcache, i, vsxregs, 0, 8);
+       ppc_collect_reg (regcache, i, (gdb_byte *) vsxregs, 0, 8);
 
       return;
     }
   else
-    ppc_collect_reg (regcache, regnum, vsxregs, 0, 8);
+    ppc_collect_reg (regcache, regnum, (gdb_byte *) vsxregs, 0, 8);
 }
 
 
@@ -793,7 +804,7 @@ ppc_collect_vrregset (const struct regset *regset,
     return;
 
   tdep = gdbarch_tdep (gdbarch);
-  offsets = regset->regmap;
+  offsets = (const struct ppc_reg_offsets *) regset->regmap;
   if (regnum == -1)
     {
       int i;
@@ -801,23 +812,23 @@ ppc_collect_vrregset (const struct regset *regset,
       for (i = tdep->ppc_vr0_regnum, offset = offsets->vr0_offset;
           i < tdep->ppc_vr0_regnum + ppc_num_vrs;
           i++, offset += 16)
-       ppc_collect_reg (regcache, i, vrregs, offset, 16);
+       ppc_collect_reg (regcache, i, (gdb_byte *) vrregs, offset, 16);
 
       ppc_collect_reg (regcache, (tdep->ppc_vrsave_regnum - 1),
-                      vrregs, offsets->vscr_offset, 4);
+                      (gdb_byte *) vrregs, offsets->vscr_offset, 4);
 
       ppc_collect_reg (regcache, tdep->ppc_vrsave_regnum,
-                      vrregs, offsets->vrsave_offset, 4);
+                      (gdb_byte *) vrregs, offsets->vrsave_offset, 4);
       return;
     }
 
   offset = ppc_vrreg_offset (tdep, offsets, regnum);
   if (regnum != tdep->ppc_vrsave_regnum
       && regnum != tdep->ppc_vrsave_regnum - 1)
-    ppc_collect_reg (regcache, regnum, vrregs, offset, 16);
+    ppc_collect_reg (regcache, regnum, (gdb_byte *) vrregs, offset, 16);
   else
     ppc_collect_reg (regcache, regnum,
-                   vrregs, offset, 4);
+                   (gdb_byte *) vrregs, offset, 4);
 }
 \f
 
@@ -992,7 +1003,7 @@ ppc_displaced_step_copy_insn (struct gdbarch *gdbarch,
                              struct regcache *regs)
 {
   size_t len = gdbarch_max_insn_length (gdbarch);
-  gdb_byte *buf = xmalloc (len);
+  gdb_byte *buf = (gdb_byte *) xmalloc (len);
   struct cleanup *old_chain = make_cleanup (xfree, buf);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   int insn;
@@ -2652,7 +2663,7 @@ e500_move_ev_register (move_ev_register_func move,
   struct gdbarch *arch = get_regcache_arch (regcache);
   struct gdbarch_tdep *tdep = gdbarch_tdep (arch); 
   int reg_index;
-  gdb_byte *byte_buffer = buffer;
+  gdb_byte *byte_buffer = (gdb_byte *) buffer;
   enum register_status status;
 
   gdb_assert (IS_SPE_PSEUDOREG (tdep, ev_reg));
@@ -2681,13 +2692,13 @@ e500_move_ev_register (move_ev_register_func move,
 static enum register_status
 do_regcache_raw_read (struct regcache *regcache, int regnum, void *buffer)
 {
-  return regcache_raw_read (regcache, regnum, buffer);
+  return regcache_raw_read (regcache, regnum, (gdb_byte *) buffer);
 }
 
 static enum register_status
 do_regcache_raw_write (struct regcache *regcache, int regnum, void *buffer)
 {
-  regcache_raw_write (regcache, regnum, buffer);
+  regcache_raw_write (regcache, regnum, (const gdb_byte *) buffer);
 
   return REG_VALID;
 }
@@ -3133,7 +3144,7 @@ static struct variant variants[] =
   {"rs2", "IBM POWER RS2", bfd_arch_rs6000,
    bfd_mach_rs6k_rs2, &tdesc_rs6000},
 
-  {0, 0, 0, 0, 0}
+  {0, 0, (enum bfd_architecture) 0, 0, 0}
 };
 
 /* Return the variant corresponding to architecture ARCH and machine number
@@ -3194,7 +3205,7 @@ rs6000_frame_cache (struct frame_info *this_frame, void **this_cache)
   CORE_ADDR func, pc;
 
   if ((*this_cache) != NULL)
-    return (*this_cache);
+    return (struct rs6000_frame_cache *) (*this_cache);
   cache = FRAME_OBSTACK_ZALLOC (struct rs6000_frame_cache);
   (*this_cache) = cache;
   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
@@ -3406,7 +3417,7 @@ rs6000_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (*this_cache)
-    return *this_cache;
+    return (struct rs6000_frame_cache *) *this_cache;
 
   cache = FRAME_OBSTACK_ZALLOC (struct rs6000_frame_cache);
   (*this_cache) = cache;
@@ -3613,7 +3624,7 @@ bfd_uses_spe_extensions (bfd *abfd)
     return 0;
 
   size = bfd_get_section_size (sect);
-  contents = xmalloc (size);
+  contents = (gdb_byte *) xmalloc (size);
   if (!bfd_get_section_contents (abfd, sect, contents, 0, size))
     {
       xfree (contents);
@@ -5982,7 +5993,7 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   /* Hook in ABI-specific overrides, if they have been registered.  */
   info.target_desc = tdesc;
-  info.tdep_info = (void *) tdesc_data;
+  info.tdep_info = tdesc_data;
   gdbarch_init_osabi (info, gdbarch);
 
   switch (info.osabi)