GDB 7.6.50

gdb/bfin-tdep.c

 /* Target-dependent code for Analog Devices Blackfin processor, for GDB.
 
-   Copyright (C) 2005-2012 Free Software Foundation, Inc.
+   Copyright (C) 2005-2013 Free Software Foundation, Inc.
 
    Contributed by Analog Devices, 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 "gdb_string.h"
+#include <string.h>
 #include "inferior.h"
 #include "gdbcore.h"
 #include "arch-utils.h"
 #include "regcache.h"
 #include "frame.h"
 #include "frame-unwind.h"
 #include "frame-base.h"
 #include "trad-frame.h"
 #include "dis-asm.h"
 #include "gdb_assert.h"
@@ skipping 462 matching lines @@
                       struct regcache *regcache,
                       CORE_ADDR bp_addr,
                       int nargs,
                       struct value **args,
                       CORE_ADDR sp,
                       int struct_return,
                       CORE_ADDR struct_addr)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-  char buf[4];
+  gdb_byte buf[4];
   int i;
   long reg_r0, reg_r1, reg_r2;
   int total_len = 0;
   enum bfin_abi abi = bfin_abi (gdbarch);
   CORE_ADDR func_addr = find_function_addr (function, NULL);
 
   for (i = nargs - 1; i >= 0; i--)
     {
       struct type *value_type = value_enclosing_type (args[i]);
-      int len = TYPE_LENGTH (value_type);
 
-      total_len += (len + 3) & ~3;
+      total_len += (TYPE_LENGTH (value_type) + 3) & ~3;
     }
 
   /* At least twelve bytes of stack space must be allocated for the function's
      arguments, even for functions that have less than 12 bytes of argument
      data.  */
 
   if (total_len < 12)
     sp -= 12 - total_len;
 
   /* Push arguments in reverse order.  */
 
   for (i = nargs - 1; i >= 0; i--)
     {
       struct type *value_type = value_enclosing_type (args[i]);
       struct type *arg_type = check_typedef (value_type);
-      int len = TYPE_LENGTH (value_type);
-      int container_len = (len + 3) & ~3;
+      int container_len = (TYPE_LENGTH (value_type) + 3) & ~3;
 
       sp -= container_len;
       write_memory (sp, value_contents_writeable (args[i]), container_len);
     }
 
   /* Initialize R0, R1, and R2 to the first 3 words of parameters.  */
 
   reg_r0 = read_memory_integer (sp, 4, byte_order);
   regcache_cooked_write_unsigned (regcache, BFIN_R0_REGNUM, reg_r0);
   reg_r1 = read_memory_integer (sp + 4, 4, byte_order);
@@ skipping 23 matching lines @@
 
 static int
 bfin_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 {
   if (reg > ARRAY_SIZE (map_gcc_gdb))
     return 0;
 
   return map_gcc_gdb[reg];
 }
 
-/* This function implements the BREAKPOINT_FROM_PC macro.  It returns
-   a pointer to a string of bytes that encode a breakpoint instruction,
-   stores the length of the string to *lenptr, and adjusts the program
-   counter (if necessary) to point to the actual memory location where
-   the breakpoint should be inserted.  */
+/* This function implements the 'breakpoint_from_pc' gdbarch method.
+   It returns a pointer to a string of bytes that encode a breakpoint
+   instruction, stores the length of the string to *lenptr, and
+   adjusts the program counter (if necessary) to point to the actual
+   memory location where the breakpoint should be inserted.  */
 
 static const unsigned char *
 bfin_breakpoint_from_pc (struct gdbarch *gdbarch,
                          CORE_ADDR *pcptr, int *lenptr)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   unsigned short iw;
   static unsigned char bfin_breakpoint[] = {0xa1, 0x00, 0x00, 0x00};
   static unsigned char bfin_sim_breakpoint[] = {0x25, 0x00, 0x00, 0x00};
 
@@ skipping 267 matching lines @@
 }
 
 /* Provide a prototype to silence -Wmissing-prototypes.  */
 extern initialize_file_ftype _initialize_bfin_tdep;
 
 void
 _initialize_bfin_tdep (void)
 {
   register_gdbarch_init (bfd_arch_bfin, bfin_gdbarch_init);
 }