Merge GDB 7.5.1

gdb/cris-tdep.c

 /* Target dependent code for CRIS, for GDB, the GNU debugger.
 
    Copyright (C) 2001-2012 Free Software Foundation, Inc.
 
    Contributed by Axis Communications AB.
    Written by Hendrik Ruijter, Stefan Andersson, and Orjan Friberg.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
@@ skipping 133 matching lines @@
 
 /* CRIS version, set via the user command 'set cris-version'.  Affects
    register names and sizes.  */
 static int usr_cmd_cris_version;
 
 /* Indicates whether to trust the above variable.  */
 static int usr_cmd_cris_version_valid = 0;
 
 static const char cris_mode_normal[] = "normal";
 static const char cris_mode_guru[] = "guru";
-static const char *cris_modes[] = {
+static const char *const cris_modes[] = {
   cris_mode_normal,
   cris_mode_guru,
   0
 };
 
 /* CRIS mode, set via the user command 'set cris-mode'.  Affects
    type of break instruction among other things.  */
 static const char *usr_cmd_cris_mode = cris_mode_normal;
 
 /* Whether to make use of Dwarf-2 CFI (default on).  */
@@ skipping 150 matching lines @@
 };
 
 static struct cris_unwind_cache *
 cris_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
                                   void **this_cache)
 {
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   struct cris_unwind_cache *info;
-  CORE_ADDR pc;
-  CORE_ADDR sp;
   CORE_ADDR addr;
   char buf[4];
   int i;
 
   if ((*this_cache))
     return (*this_cache);
 
   info = FRAME_OBSTACK_ZALLOC (struct cris_unwind_cache);
   (*this_cache) = info;
   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
@@ skipping 133 matching lines @@
   if (erp & 0x1)
     {
       /* In delay slot - check if there's a breakpoint at the preceding
          instruction.  */
       if (breakpoint_here_p (get_frame_address_space (this_frame), erp & ~0x1))
         ret = 1;
     }
   return ret;
 }
 
-/* Hardware watchpoint support.  */
-
-/* We support 6 hardware data watchpoints, but cannot trigger on execute
-   (any combination of read/write is fine).  */
-
-int
-cris_can_use_hardware_watchpoint (int type, int count, int other)
-{
-  struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch);
-
-  /* No bookkeeping is done here; it is handled by the remote debug agent.  */
-
-  if (tdep->cris_version != 32)
-    return 0;
-  else
-    /* CRISv32: Six data watchpoints, one for instructions.  */
-    return (((type == bp_read_watchpoint || type == bp_access_watchpoint
-             || type == bp_hardware_watchpoint) && count <= 6) 
-            || (type == bp_hardware_breakpoint && count <= 1));
-}
-
-/* The CRISv32 hardware data watchpoints work by specifying ranges,
-   which have no alignment or length restrictions.  */
-
-int
-cris_region_ok_for_watchpoint (CORE_ADDR addr, int len)
-{
-  return 1;
-}
-
-/* If the inferior has some watchpoint that triggered, return the
-   address associated with that watchpoint.  Otherwise, return
-   zero.  */
-
-CORE_ADDR
-cris_stopped_data_address (void)
-{
-  CORE_ADDR eda;
-  eda = get_frame_register_unsigned (get_current_frame (), EDA_REGNUM);
-  return eda;
-}
-
 /* The instruction environment needed to find single-step breakpoints.  */
 
 typedef 
 struct instruction_environment
 {
   unsigned long reg[NUM_GENREGS];
   unsigned long preg[NUM_SPECREGS];
   unsigned long branch_break_address;
   unsigned long delay_slot_pc;
   unsigned long prefix_value;
@@ skipping 214 matching lines @@
    includes special registers such as pc and fp saved in special ways
    in the stack frame.  sp is even more special: the address we return
    for it IS the sp for the next frame.  */
 
 static struct cris_unwind_cache *
 cris_frame_unwind_cache (struct frame_info *this_frame,
                          void **this_prologue_cache)
 {
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-  CORE_ADDR pc;
   struct cris_unwind_cache *info;
-  int i;
 
   if ((*this_prologue_cache))
     return (*this_prologue_cache);
 
   info = FRAME_OBSTACK_ZALLOC (struct cris_unwind_cache);
   (*this_prologue_cache) = info;
   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 
   /* Zero all fields.  */
   info->prev_sp = 0;
@@ skipping 89 matching lines @@
   return sp;
 }
 
 static CORE_ADDR
 cris_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                       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);
-  int stack_alloc;
   int stack_offset;
   int argreg;
   int argnum;
 
-  CORE_ADDR regval;
-
   /* The function's arguments and memory allocated by gdb for the arguments to
      point at reside in separate areas on the stack.
      Both frame pointers grow toward higher addresses.  */
   CORE_ADDR fp_arg;
   CORE_ADDR fp_mem;
 
   struct stack_item *si = NULL;
 
   /* Push the return address.  */
   regcache_cooked_write_unsigned (regcache, SRP_REGNUM, bp_addr);
@@ skipping 1013 matching lines @@
       regcache_cooked_read_unsigned (regcache, ARG2_REGNUM, &val);
       store_unsigned_integer ((char *)valbuf + 4, len - 4, byte_order, val);
     }
   else
     error (_("cris_extract_return_value: type length too large"));
 }
 
 /* Handle the CRIS return value convention.  */
 
 static enum return_value_convention
-cris_return_value (struct gdbarch *gdbarch, struct type *func_type,
+cris_return_value (struct gdbarch *gdbarch, struct value *function,
                    struct type *type, struct regcache *regcache,
                    gdb_byte *readbuf, const gdb_byte *writebuf)
 {
   if (TYPE_CODE (type) == TYPE_CODE_STRUCT 
       || TYPE_CODE (type) == TYPE_CODE_UNION
       || TYPE_LENGTH (type) > 8)
     /* Structs, unions, and anything larger than 8 bytes (2 registers)
        goes on the stack.  */
     return RETURN_VALUE_STRUCT_CONVENTION;
 
@@ skipping 305 matching lines @@
 static unsigned long get_data_from_address (unsigned short *inst,
                                             CORE_ADDR address,
                                             enum bfd_endian byte_order);
 
 /* Calculates the prefix value for the general case of offset addressing 
    mode.  */
 
 static void
 bdap_prefix (unsigned short inst, inst_env_type *inst_env)
 {
-
-  long offset;
-
   /* It's invalid to be in a delay slot.  */
   if (inst_env->slot_needed || inst_env->prefix_found)
     {
       inst_env->invalid = 1;
       return; 
     }
 
   /* The calculation of prefix_value used to be after process_autoincrement,
      but that fails for an instruction such as jsr [$r0+12] which is encoded
      as 5f0d 0c00 30b9 when compiled with -fpic.  Since PC is operand1 it
@@ skipping 1984 matching lines @@
   set_solib_svr4_fetch_link_map_offsets
     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
   
   /* FIXME: cagney/2003-08-27: It should be possible to select a CRIS
      disassembler, even when there is no BFD.  Does something like
      "gdb; target remote; disassmeble *0x123" work?  */
   set_gdbarch_print_insn (gdbarch, cris_delayed_get_disassembler);
 
   return gdbarch;
 }