GDB 7.6.50

gdb/spu-tdep.c

 /* SPU target-dependent code for GDB, the GNU debugger.
-   Copyright (C) 2006-2012 Free Software Foundation, Inc.
+   Copyright (C) 2006-2013 Free Software Foundation, Inc.
 
    Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
    Based on a port by Sid Manning <sid@us.ibm.com>.
 
    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 "arch-utils.h"
 #include "gdbtypes.h"
 #include "gdbcmd.h"
 #include "gdbcore.h"
-#include "gdb_string.h"
+#include <string.h>
 #include "gdb_assert.h"
 #include "frame.h"
 #include "frame-unwind.h"
 #include "frame-base.h"
 #include "trad-frame.h"
 #include "symtab.h"
 #include "symfile.h"
 #include "value.h"
 #include "inferior.h"
 #include "dis-asm.h"
@@ skipping 147 matching lines @@
 static enum register_status
 spu_pseudo_register_read_spu (struct regcache *regcache, const char *regname,
                               gdb_byte *buf)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   enum register_status status;
   gdb_byte reg[32];
   char annex[32];
   ULONGEST id;
+  ULONGEST ul;
 
   status = regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id);
   if (status != REG_VALID)
     return status;
   xsnprintf (annex, sizeof annex, "%d/%s", (int) id, regname);
   memset (reg, 0, sizeof reg);
   target_read (&current_target, TARGET_OBJECT_SPU, annex,
                reg, 0, sizeof reg);
 
-  store_unsigned_integer (buf, 4, byte_order, strtoulst (reg, NULL, 16));
+  ul = strtoulst ((char *) reg, NULL, 16);
+  store_unsigned_integer (buf, 4, byte_order, ul);
   return REG_VALID;
 }
 
 static enum register_status
 spu_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
                           int regnum, gdb_byte *buf)
 {
   gdb_byte reg[16];
   char annex[32];
   ULONGEST id;
@@ skipping 32 matching lines @@
       internal_error (__FILE__, __LINE__, _("invalid regnum"));
     }
 }
 
 static void
 spu_pseudo_register_write_spu (struct regcache *regcache, const char *regname,
                                const gdb_byte *buf)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-  gdb_byte reg[32];
+  char reg[32];
   char annex[32];
   ULONGEST id;
 
   regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id);
   xsnprintf (annex, sizeof annex, "%d/%s", (int) id, regname);
   xsnprintf (reg, sizeof reg, "0x%s",
              phex_nz (extract_unsigned_integer (buf, 4, byte_order), 4));
   target_write (&current_target, TARGET_OBJECT_SPU, annex,
-                reg, 0, strlen (reg));
+                (gdb_byte *) reg, 0, strlen (reg));
 }
 
 static void
 spu_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
                            int regnum, const gdb_byte *buf)
 {
   gdb_byte reg[16];
   char annex[32];
   ULONGEST id;
 
@@ skipping 851 matching lines @@
   regcache_cooked_read_unsigned (regcache, SPU_PC_REGNUM, &pc);
   /* Mask off interrupt enable bit.  */
   return SPUADDR (tdep->id, pc & -4);
 }
 
 static void
 spu_write_pc (struct regcache *regcache, CORE_ADDR pc)
 {
   /* Keep interrupt enabled state unchanged.  */
   ULONGEST old_pc;
+
   regcache_cooked_read_unsigned (regcache, SPU_PC_REGNUM, &old_pc);
   regcache_cooked_write_unsigned (regcache, SPU_PC_REGNUM,
                                   (SPUADDR_ADDR (pc) & -4) | (old_pc & 3));
 }
 
 
 /* Cell/B.E. cross-architecture unwinder support.  */
 
 struct spu2ppu_cache
 {
@@ skipping 31 matching lines @@
 
 static int
 spu2ppu_sniffer (const struct frame_unwind *self,
                  struct frame_info *this_frame, void **this_prologue_cache)
 {
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   CORE_ADDR base, func, backchain;
   gdb_byte buf[4];
 
-  if (gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_spu)
+  if (gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_spu)
     return 0;
 
   base = get_frame_sp (this_frame);
   func = get_frame_pc (this_frame);
   if (target_read_memory (base, buf, 4))
     return 0;
   backchain = extract_unsigned_integer (buf, 4, byte_order);
 
   if (!backchain)
     {
@@ skipping 10 matching lines @@
 
       if (fi)
         {
           cache->regcache = frame_save_as_regcache (fi);
           *this_prologue_cache = cache;
           return 1;
         }
       else
         {
           struct regcache *regcache;
-          regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+          regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
           cache->regcache = regcache_dup (regcache);
           *this_prologue_cache = cache;
           return 1;
         }
     }
 
   return 0;
 }
 
 static void
@@ skipping 135 matching lines @@
       store_unsigned_integer (buf, 4, byte_order, SPUADDR_ADDR (struct_addr));
       regcache_cooked_write (regcache, regnum++, buf);
     }
 
   /* Fill in argument registers.  */
   for (i = 0; i < nargs; i++)
     {
       struct value *arg = args[i];
       struct type *type = check_typedef (value_type (arg));
       const gdb_byte *contents = value_contents (arg);
-      int len = TYPE_LENGTH (type);
-      int n_regs = align_up (len, 16) / 16;
+      int n_regs = align_up (TYPE_LENGTH (type), 16) / 16;
 
       /* If the argument doesn't wholly fit into registers, it and
          all subsequent arguments go to the stack.  */
       if (regnum + n_regs - 1 > SPU_ARGN_REGNUM)
         {
           stack_arg = i;
           break;
         }
 
       spu_value_to_regcache (regcache, regnum, type, contents);
@@ skipping 217 matching lines @@
       else if (reg != -1)
         {
           int optim, unavail;
 
           if (get_frame_register_bytes (frame, reg, 0, 4, buf,
                                          &optim, &unavail))
             target += extract_unsigned_integer (buf, 4, byte_order) & -4;
           else
             {
               if (optim)
-                error (_("Could not determine address of "
-                         "single-step breakpoint."));
+                throw_error (OPTIMIZED_OUT_ERROR,
+                             _("Could not determine address of "
+                               "single-step breakpoint."));
               if (unavail)
                 throw_error (NOT_AVAILABLE_ERROR,
                              _("Could not determine address of "
                                "single-step breakpoint."));
             }
         }
 
       target = target & lslr;
       if (target != next_pc)
         insert_single_step_breakpoint (gdbarch, aspace,
@@ skipping 115 matching lines @@
 static struct spu_overlay_table *
 spu_get_overlay_table (struct objfile *objfile)
 {
   enum bfd_endian byte_order = bfd_big_endian (objfile->obfd)?
                    BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
   struct minimal_symbol *ovly_table_msym, *ovly_buf_table_msym;
   CORE_ADDR ovly_table_base, ovly_buf_table_base;
   unsigned ovly_table_size, ovly_buf_table_size;
   struct spu_overlay_table *tbl;
   struct obj_section *osect;
-  char *ovly_table;
+  gdb_byte *ovly_table;
   int i;
 
   tbl = objfile_data (objfile, spu_overlay_data);
   if (tbl)
     return tbl;
 
   ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL, objfile);
   if (!ovly_table_msym)
     return NULL;
 
@@ skipping 151 matching lines @@
 
   /* There can be multiple symbols named "main".  Search for the
      "main" in *this* objfile.  */
   minsym = lookup_minimal_symbol ("main", NULL, objfile);
   if (!minsym)
     return;
 
   /* If we have debugging information, try to use it -- this
      will allow us to properly skip the prologue.  */
   pc = SYMBOL_VALUE_ADDRESS (minsym);
-  symtab = find_pc_sect_symtab (pc, SYMBOL_OBJ_SECTION (minsym));
+  symtab = find_pc_sect_symtab (pc, SYMBOL_OBJ_SECTION (objfile, minsym));
   if (symtab != NULL)
     {
       struct blockvector *bv = BLOCKVECTOR (symtab);
       struct block *block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
       struct symbol *sym;
       struct symtab_and_line sal;
 
       sym = lookup_block_symbol (block, "main", VAR_DOMAIN);
       if (sym)
         {
@@ skipping 103 matching lines @@
     error (_("\"info spu\" is only supported on the SPU architecture."));
 
   id = get_frame_register_unsigned (frame, SPU_ID_REGNUM);
 
   xsnprintf (annex, sizeof annex, "%d/event_status", id);
   len = target_read (&current_target, TARGET_OBJECT_SPU, annex,
                      buf, 0, (sizeof (buf) - 1));
   if (len <= 0)
     error (_("Could not read event_status."));
   buf[len] = '\0';
-  event_status = strtoulst (buf, NULL, 16);
+  event_status = strtoulst ((char *) buf, NULL, 16);
  
   xsnprintf (annex, sizeof annex, "%d/event_mask", id);
   len = target_read (&current_target, TARGET_OBJECT_SPU, annex,
                      buf, 0, (sizeof (buf) - 1));
   if (len <= 0)
     error (_("Could not read event_mask."));
   buf[len] = '\0';
-  event_mask = strtoulst (buf, NULL, 16);
+  event_mask = strtoulst ((char *) buf, NULL, 16);
  
   chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoEvent");
 
   if (ui_out_is_mi_like_p (current_uiout))
     {
       ui_out_field_fmt (current_uiout, "event_status",
                         "0x%s", phex_nz (event_status, 4));
       ui_out_field_fmt (current_uiout, "event_mask",
                         "0x%s", phex_nz (event_mask, 4));
     }
@@ skipping 38 matching lines @@
       signal1 = extract_unsigned_integer (buf, 4, byte_order);
       signal1_pending = 1;
     }
     
   xsnprintf (annex, sizeof annex, "%d/signal1_type", id);
   len = target_read (&current_target, TARGET_OBJECT_SPU, annex,
                      buf, 0, (sizeof (buf) - 1));
   if (len <= 0)
     error (_("Could not read signal1_type."));
   buf[len] = '\0';
-  signal1_type = strtoulst (buf, NULL, 16);
+  signal1_type = strtoulst ((char *) buf, NULL, 16);
 
   xsnprintf (annex, sizeof annex, "%d/signal2", id);
   len = target_read (&current_target, TARGET_OBJECT_SPU, annex, buf, 0, 4);
   if (len < 0)
     error (_("Could not read signal2."));
   else if (len == 4)
     {
       signal2 = extract_unsigned_integer (buf, 4, byte_order);
       signal2_pending = 1;
     }
     
   xsnprintf (annex, sizeof annex, "%d/signal2_type", id);
   len = target_read (&current_target, TARGET_OBJECT_SPU, annex,
                      buf, 0, (sizeof (buf) - 1));
   if (len <= 0)
     error (_("Could not read signal2_type."));
   buf[len] = '\0';
-  signal2_type = strtoulst (buf, NULL, 16);
+  signal2_type = strtoulst ((char *) buf, NULL, 16);
 
   chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoSignal");
 
   if (ui_out_is_mi_like_p (current_uiout))
     {
       ui_out_field_int (current_uiout, "signal1_pending", signal1_pending);
       ui_out_field_fmt (current_uiout, "signal1", "0x%s", phex_nz (signal1, 4));
       ui_out_field_int (current_uiout, "signal1_type", signal1_type);
       ui_out_field_int (current_uiout, "signal2_pending", signal2_pending);
       ui_out_field_fmt (current_uiout, "signal2", "0x%s", phex_nz (signal2, 4));
@@ skipping 666 matching lines @@
   add_cmd ("mailbox", class_info, info_spu_mailbox_command,
            _("Display SPU mailbox facility status.\n"),
            &infospucmdlist);
   add_cmd ("dma", class_info, info_spu_dma_command,
            _("Display MFC DMA status.\n"),
            &infospucmdlist);
   add_cmd ("proxydma", class_info, info_spu_proxydma_command,
            _("Display MFC Proxy-DMA status.\n"),
            &infospucmdlist);
 }