Merge GDB 7.5.1

gdb/ia64-tdep.c

 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
 
    Copyright (C) 1999-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
    (at your option) any later version.
@@ skipping 24 matching lines @@
 #include "elf/common.h"         /* for DT_PLTGOT value */
 #include "elf-bfd.h"
 #include "dis-asm.h"
 #include "infcall.h"
 #include "osabi.h"
 #include "ia64-tdep.h"
 #include "cp-abi.h"
 
 #ifdef HAVE_LIBUNWIND_IA64_H
 #include "elf/ia64.h"           /* for PT_IA_64_UNWIND value */
-#include "libunwind-frame.h"
-#include "libunwind-ia64.h"
+#include "ia64-libunwind-tdep.h"
 
 /* Note: KERNEL_START is supposed to be an address which is not going
          to ever contain any valid unwind info.  For ia64 linux, the choice
          of 0xc000000000000000 is fairly safe since that's uncached space.
  
          We use KERNEL_START as follows: after obtaining the kernel's
          unwind table via getunwind(), we project its unwind data into
          address-range KERNEL_START-(KERNEL_START+ktab_size) and then
          when ia64_access_mem() sees a memory access to this
          address-range, we redirect it to ktab instead.
@@ skipping 978 matching lines @@
       
       store_unsigned_integer (buf, register_size (gdbarch, regnum),
                               byte_order, natN_val);
     }
   else if (regnum == VBOF_REGNUM)
     {
       /* A virtual register frame start is provided for user convenience.
          It can be calculated as the bsp - sof (sizeof frame).  */
       ULONGEST bsp, vbsp;
       ULONGEST cfm;
-      CORE_ADDR reg;
       status = regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
       if (status != REG_VALID)
         return status;
       status = regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
       if (status != REG_VALID)
         return status;
 
       /* The bsp points at the end of the register frame so we
          subtract the size of frame from it to get beginning of frame.  */
       vbsp = rse_address_add (bsp, -(cfm & 0x7f));
       store_unsigned_integer (buf, register_size (gdbarch, regnum),
                               byte_order, vbsp);
     }
   else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
     {
       ULONGEST pr;
       ULONGEST cfm;
       ULONGEST prN_val;
-      CORE_ADDR reg;
       status = regcache_cooked_read_unsigned (regcache, IA64_PR_REGNUM, &pr);
       if (status != REG_VALID)
         return status;
       status = regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
       if (status != REG_VALID)
         return status;
 
       if (VP16_REGNUM <= regnum && regnum <= VP63_REGNUM)
         {
           /* Fetch predicate register rename base from current frame
@@ skipping 17 matching lines @@
 static void
 ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
                             int regnum, const gdb_byte *buf)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 
   if (regnum >= V32_REGNUM && regnum <= V127_REGNUM)
     {
       ULONGEST bsp;
       ULONGEST cfm;
-      CORE_ADDR reg;
       regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
       regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
 
       bsp = rse_address_add (bsp, -(cfm & 0x7f));
  
       if ((cfm & 0x7f) > regnum - V32_REGNUM) 
         {
           ULONGEST reg_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
           write_memory (reg_addr, (void *) buf, 8);
         }
@@ skipping 735 matching lines @@
 
 /* Normal frames.  */
 
 static struct ia64_frame_cache *
 ia64_frame_cache (struct frame_info *this_frame, void **this_cache)
 {
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   struct ia64_frame_cache *cache;
   char buf[8];
-  CORE_ADDR cfm, sof, sol, bsp, psr;
-  int i;
+  CORE_ADDR cfm, psr;
 
   if (*this_cache)
     return *this_cache;
 
   cache = ia64_alloc_frame_cache ();
   *this_cache = cache;
 
   get_frame_register (this_frame, sp_regnum, buf);
   cache->saved_sp = extract_unsigned_integer (buf, 8, byte_order);
 
@@ skipping 366 matching lines @@
           tdep->sigcontext_register_address (gdbarch, cache->base, regno);
     }
 }
 
 static struct ia64_frame_cache *
 ia64_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
 {
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   struct ia64_frame_cache *cache;
-  CORE_ADDR addr;
   char buf[8];
-  int i;
 
   if (*this_cache)
     return *this_cache;
 
   cache = ia64_alloc_frame_cache ();
 
   get_frame_register (this_frame, sp_regnum, buf);
   /* Note that frame size is hard-coded below.  We cannot calculate it
      via prologue examination.  */
   cache->base = extract_unsigned_integer (buf, 8, byte_order) + 16;
@@ skipping 149 matching lines @@
 }
 
 /* Skip over a designated number of registers in the backing
    store, remembering every 64th position is for NAT.  */
 static __inline__ uint64_t
 ia64_rse_skip_regs (uint64_t addr, long num_regs)
 {
   long delta = ia64_rse_slot_num(addr) + num_regs;
 
   if (num_regs < 0)