Merge GDB 7.5.1

gdb/arm-tdep.c

 /* Common target dependent code for GDB on ARM systems.
 
    Copyright (C) 1988-1989, 1991-1993, 1995-1996, 1998-2012 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
@@ skipping 22 matching lines @@
 #include "value.h"
 #include "arch-utils.h"
 #include "osabi.h"
 #include "frame-unwind.h"
 #include "frame-base.h"
 #include "trad-frame.h"
 #include "objfiles.h"
 #include "dwarf2-frame.h"
 #include "gdbtypes.h"
 #include "prologue-value.h"
+#include "remote.h"
 #include "target-descriptions.h"
 #include "user-regs.h"
 #include "observer.h"
 
 #include "arm-tdep.h"
 #include "gdb/sim-arm.h"
 
 #include "elf-bfd.h"
 #include "coff/internal.h"
 #include "elf/arm.h"
 
 #include "gdb_assert.h"
 #include "vec.h"
 
+#include "record.h"
+
 #include "features/arm-with-m.c"
+#include "features/arm-with-m-fpa-layout.c"
+#include "features/arm-with-m-vfp-d16.c"
 #include "features/arm-with-iwmmxt.c"
 #include "features/arm-with-vfpv2.c"
 #include "features/arm-with-vfpv3.c"
 #include "features/arm-with-neon.c"
 
 static int arm_debug;
 
 /* Macros for setting and testing a bit in a minimal symbol that marks
    it as Thumb function.  The MSB of the minimal symbol's "info" field
    is used for this purpose.
@@ skipping 22 matching lines @@
 {
   VEC(arm_mapping_symbol_s) **section_maps;
 };
 
 /* The list of available "set arm ..." and "show arm ..." commands.  */
 static struct cmd_list_element *setarmcmdlist = NULL;
 static struct cmd_list_element *showarmcmdlist = NULL;
 
 /* The type of floating-point to use.  Keep this in sync with enum
    arm_float_model, and the help string in _initialize_arm_tdep.  */
-static const char *fp_model_strings[] =
+static const char *const fp_model_strings[] =
 {
   "auto",
   "softfpa",
   "fpa",
   "softvfp",
   "vfp",
   NULL
 };
 
 /* A variable that can be configured by the user.  */
 static enum arm_float_model arm_fp_model = ARM_FLOAT_AUTO;
 static const char *current_fp_model = "auto";
 
 /* The ABI to use.  Keep this in sync with arm_abi_kind.  */
-static const char *arm_abi_strings[] =
+static const char *const arm_abi_strings[] =
 {
   "auto",
   "APCS",
   "AAPCS",
   NULL
 };
 
 /* A variable that can be configured by the user.  */
 static enum arm_abi_kind arm_abi_global = ARM_ABI_AUTO;
 static const char *arm_abi_string = "auto";
 
 /* The execution mode to assume.  */
-static const char *arm_mode_strings[] =
+static const char *const arm_mode_strings[] =
   {
     "auto",
     "arm",
     "thumb",
     NULL
   };
 
 static const char *arm_fallback_mode_string = "auto";
 static const char *arm_force_mode_string = "auto";
 
@@ skipping 229 matching lines @@
   return 0;
 }
 
 /* Determine if the program counter specified in MEMADDR is in a Thumb
    function.  This function should be called for addresses unrelated to
    any executing frame; otherwise, prefer arm_frame_is_thumb.  */
 
 int
 arm_pc_is_thumb (struct gdbarch *gdbarch, CORE_ADDR memaddr)
 {
-  struct obj_section *sec;
   struct minimal_symbol *sym;
   char type;
   struct displaced_step_closure* dsc
     = get_displaced_step_closure_by_addr(memaddr);
 
   /* If checking the mode of displaced instruction in copy area, the mode
      should be determined by instruction on the original address.  */
   if (dsc)
     {
       if (debug_displaced)
@@ skipping 884 matching lines @@
 
    Since ldr/str is a very popular instruction, we can't use them as
    'fingerprint' or 'signature' of stack protector sequence.  Here we choose
    sequence {movw/movt, ldr}/ldr/str plus symbol __stack_chk_guard, if not
    stripped, as the 'fingerprint' of a stack protector cdoe sequence.  */
 
 static CORE_ADDR
 arm_skip_stack_protector(CORE_ADDR pc, struct gdbarch *gdbarch)
 {
   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
-  unsigned int address, basereg;
+  unsigned int basereg;
   struct minimal_symbol *stack_chk_guard;
   int offset;
   int is_thumb = arm_pc_is_thumb (gdbarch, pc);
   CORE_ADDR addr;
 
   /* Try to parse the instructions in Step 1.  */
   addr = arm_analyze_load_stack_chk_guard (pc, gdbarch,
                                            &basereg, &offset);
   if (!addr)
     return pc;
@@ skipping 71 matching lines @@
    [stfe        f4, [sp, #-12]!]
    sub fp, ip, #nn @@ nn == 20 or 4 depending on second insn.  */
 
 static CORE_ADDR
 arm_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 {
   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
   unsigned long inst;
   CORE_ADDR skip_pc;
   CORE_ADDR func_addr, limit_pc;
-  struct symtab_and_line sal;
 
   /* See if we can determine the end of the prologue via the symbol table.
      If so, then return either PC, or the PC after the prologue, whichever
      is greater.  */
   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
     {
       CORE_ADDR post_prologue_pc
         = skip_prologue_using_sal (gdbarch, func_addr);
       struct symtab *s = find_pc_symtab (func_addr);
 
@@ skipping 138 matching lines @@
    The comments for thumb_skip_prolog() describe the algorithm we use
    to detect the end of the prolog.  */
 /* *INDENT-ON* */
 
 static void
 thumb_scan_prologue (struct gdbarch *gdbarch, CORE_ADDR prev_pc,
                      CORE_ADDR block_addr, struct arm_prologue_cache *cache)
 {
   CORE_ADDR prologue_start;
   CORE_ADDR prologue_end;
-  CORE_ADDR current_pc;
 
   if (find_pc_partial_function (block_addr, NULL, &prologue_start,
                                 &prologue_end))
     {
       /* See comment in arm_scan_prologue for an explanation of
          this heuristics.  */
       if (prologue_end > prologue_start + 64)
         {
           prologue_end = prologue_start + 64;
         }
@@ skipping 1663 matching lines @@
         found_stack_adjust = 1;
       else if ((insn & 0x0df0f000) == 0x0040d000)
         /* SUB SP (register or immediate).  */
         found_stack_adjust = 1;
       else if ((insn & 0x0ffffff0) == 0x01a0d000)
         /* MOV SP.  */
         found_stack_adjust = 1;
       else if ((insn & 0x0fff0000) == 0x08bd0000)
         /* POP (LDMIA).  */
         found_stack_adjust = 1;
+      else if ((insn & 0x0fff0000) == 0x049d0000)
+        /* POP of a single register.  */
+        found_stack_adjust = 1;
     }
 
   if (found_stack_adjust)
     return 1;
 
   return 0;
 }
 
 
 /* When arguments must be pushed onto the stack, they go on in reverse
@@ skipping 1892 matching lines @@
 }
 
 /* Given BUF, which is OLD_LEN bytes ending at ENDADDR, expand
    the buffer to be NEW_LEN bytes ending at ENDADDR.  Return
    NULL if an error occurs.  BUF is freed.  */
 
 static gdb_byte *
 extend_buffer_earlier (gdb_byte *buf, CORE_ADDR endaddr,
                        int old_len, int new_len)
 {
-  gdb_byte *new_buf, *middle;
+  gdb_byte *new_buf;
   int bytes_to_read = new_len - old_len;
 
   new_buf = xmalloc (new_len);
   memcpy (new_buf + bytes_to_read, buf, old_len);
   xfree (buf);
   if (target_read_memory (endaddr - new_len, new_buf, bytes_to_read) != 0)
     {
       xfree (new_buf);
       return NULL;
     }
@@ skipping 12 matching lines @@
 
 /* Adjust a breakpoint's address to move breakpoints out of IT blocks.
    A breakpoint in an IT block may not be hit, depending on the
    condition flags.  */
 static CORE_ADDR
 arm_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
 {
   gdb_byte *buf;
   char map_type;
   CORE_ADDR boundary, func_start;
-  int buf_len, buf2_len;
+  int buf_len;
   enum bfd_endian order = gdbarch_byte_order_for_code (gdbarch);
   int i, any, last_it, last_it_count;
 
   /* If we are using BKPT breakpoints, none of this is necessary.  */
   if (gdbarch_tdep (gdbarch)->thumb2_breakpoint == NULL)
     return bpaddr;
 
   /* ARM mode does not have this problem.  */
   if (!arm_pc_is_thumb (gdbarch, bpaddr))
     return bpaddr;
@@ skipping 1679 matching lines @@
    the registers in the transferred list into a contiguous range r0...rX (to
    avoid loading PC directly and losing control of the debugged program), so we
    must undo that here.  */
 
 static void
 cleanup_block_load_pc (struct gdbarch *gdbarch,
                        struct regcache *regs,
                        struct displaced_step_closure *dsc)
 {
   uint32_t status = displaced_read_reg (regs, dsc, ARM_PS_REGNUM);
-  int load_executed = condition_true (dsc->u.block.cond, status), i;
+  int load_executed = condition_true (dsc->u.block.cond, status);
   unsigned int mask = dsc->u.block.regmask, write_reg = ARM_PC_REGNUM;
   unsigned int regs_loaded = bitcount (mask);
   unsigned int num_to_shuffle = regs_loaded, clobbered;
 
   /* The method employed here will fail if the register list is fully populated
      (we need to avoid loading PC directly).  */
   gdb_assert (num_to_shuffle < 16);
 
   if (!load_executed)
     return;
@@ skipping 1821 matching lines @@
     {
       *lenptr = tdep->arm_breakpoint_size;
       return tdep->arm_breakpoint;
     }
 }
 
 static void
 arm_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
                                int *kindptr)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-
   arm_breakpoint_from_pc (gdbarch, pcptr, kindptr);
 
   if (arm_pc_is_thumb (gdbarch, *pcptr) && *kindptr == 4)
     /* The documented magic value for a 32-bit Thumb-2 breakpoint, so
        that this is not confused with a 32-bit ARM breakpoint.  */
     *kindptr = 3;
 }
 
 /* Extract from an array REGBUF containing the (raw) register state a
    function return value of type TYPE, and copy that, in virtual
@@ skipping 282 matching lines @@
           len -= INT_REGISTER_SIZE;
           valbuf += INT_REGISTER_SIZE;
         }
     }
 }
 
 
 /* Handle function return values.  */
 
 static enum return_value_convention
-arm_return_value (struct gdbarch *gdbarch, struct type *func_type,
+arm_return_value (struct gdbarch *gdbarch, struct value *function,
                   struct type *valtype, struct regcache *regcache,
                   gdb_byte *readbuf, const gdb_byte *writebuf)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  struct type *func_type = function ? value_type (function) : NULL;
   enum arm_vfp_cprc_base_type vfp_base_type;
   int vfp_base_count;
 
   if (arm_vfp_abi_for_function (gdbarch, func_type)
       && arm_vfp_call_candidate (valtype, &vfp_base_type, &vfp_base_count))
     {
       int reg_char = arm_vfp_cprc_reg_char (vfp_base_type);
       int unit_length = arm_vfp_cprc_unit_length (vfp_base_type);
       int i;
       for (i = 0; i < vfp_base_count; i++)
@@ skipping 70 matching lines @@
   *pc = extract_unsigned_integer (buf, INT_REGISTER_SIZE, byte_order);
   return 1;
 }
 
 /* Recognize GCC and GNU ld's trampolines.  If we are in a trampoline,
    return the target PC.  Otherwise return 0.  */
 
 CORE_ADDR
 arm_skip_stub (struct frame_info *frame, CORE_ADDR pc)
 {
-  char *name;
+  const char *name;
   int namelen;
   CORE_ADDR start_addr;
 
   /* Find the starting address and name of the function containing the PC.  */
   if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0)
     return 0;
 
   /* If PC is in a Thumb call or return stub, return the address of the
      target PC, which is in a register.  The thunk functions are called
      _call_via_xx, where x is the register name.  The possible names
@@ skipping 155 matching lines @@
                       arm_abi_strings[tdep->arm_abi]);
   else
     fprintf_filtered (file, _("The current ARM ABI is \"%s\".\n"),
                       arm_abi_string);
 }
 
 static void
 arm_show_fallback_mode (struct ui_file *file, int from_tty,
                         struct cmd_list_element *c, const char *value)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch);
-
   fprintf_filtered (file,
                     _("The current execution mode assumed "
                       "(when symbols are unavailable) is \"%s\".\n"),
                     arm_fallback_mode_string);
 }
 
 static void
 arm_show_force_mode (struct ui_file *file, int from_tty,
                      struct cmd_list_element *c, const char *value)
 {
@@ skipping 266 matching lines @@
 }
 
 /* Store the contents of BUF to a NEON quad register, by writing to
    two double registers.  This is used to implement the quad pseudo
    registers, and for argument passing in case the quad registers are
    missing; vectors are passed in quad registers when using the VFP
    ABI, even if a NEON unit is not present.  REGNUM is the index
    of the quad register, in [0, 15].  */
 
 static void