projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* gdbarch.sh (memory_insert_breakpoint, memory_remove_breakpoint): Add
[deliverable/binutils-gdb.git] / gdb / ia64-tdep.c
diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c
index a8af64b1aedbf2b5c6aae4008bee6d11db7ba069..b724dda721e3587e97540cdc377c98670d4bafcc 100644 (file)
--- a/gdb/ia64-tdep.c
+++ b/gdb/ia64-tdep.c
@@ -1,13 +1,13 @@
 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
 
 /* Target-dependent code for the IA-64 for GDB, the GNU debugger.
 
-   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
    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
    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 2 of the License, or
+   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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -16,9 +16,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "inferior.h"
 
 #include "defs.h"
 #include "inferior.h"
@@ -276,9 +274,6 @@ struct ia64_frame_cache
 
 };
 
 
 };
 
-#define SIGCONTEXT_REGISTER_ADDRESS \
-  (gdbarch_tdep (current_gdbarch)->sigcontext_register_address)
-
 int
 ia64_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
                          struct reggroup *group)
 int
 ia64_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
                          struct reggroup *group)
@@ -303,7 +298,7 @@ ia64_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
 }
 
 static const char *
 }
 
 static const char *
-ia64_register_name (int reg)
+ia64_register_name (struct gdbarch *gdbarch, int reg)
 {
   return ia64_register_names[reg];
 }
 {
   return ia64_register_names[reg];
 }
@@ -318,7 +313,7 @@ ia64_register_type (struct gdbarch *arch, int reg)
 }
 
 static int
 }
 
 static int
-ia64_dwarf_reg_to_regnum (int reg)
+ia64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 {
   if (reg >= IA64_GR32_REGNUM && reg <= IA64_GR127_REGNUM)
     return V32_REGNUM + (reg - IA64_GR32_REGNUM);
 {
   if (reg >= IA64_GR32_REGNUM && reg <= IA64_GR127_REGNUM)
     return V32_REGNUM + (reg - IA64_GR32_REGNUM);
@@ -334,7 +329,7 @@ floatformat_valid (const struct floatformat *fmt, const void *from)
 const struct floatformat floatformat_ia64_ext =
 {
   floatformat_little, 82, 0, 1, 17, 65535, 0x1ffff, 18, 64,
 const struct floatformat floatformat_ia64_ext =
 {
   floatformat_little, 82, 0, 1, 17, 65535, 0x1ffff, 18, 64,
-  floatformat_intbit_yes, "floatformat_ia64_ext", floatformat_valid
+  floatformat_intbit_yes, "floatformat_ia64_ext", floatformat_valid, NULL
 };
 
 const struct floatformat *floatformats_ia64_ext[2] =
 };
 
 const struct floatformat *floatformats_ia64_ext[2] =
@@ -558,7 +553,8 @@ fetch_instruction (CORE_ADDR addr, instruction_type *it, long long *instr)
 #define IA64_BREAKPOINT 0x00003333300LL
 
 static int
 #define IA64_BREAKPOINT 0x00003333300LL
 
 static int
-ia64_memory_insert_breakpoint (struct bp_target_info *bp_tgt)
+ia64_memory_insert_breakpoint (struct gdbarch *gdbarch,
+                              struct bp_target_info *bp_tgt)
 {
   CORE_ADDR addr = bp_tgt->placed_address;
   char bundle[BUNDLE_LEN];
 {
   CORE_ADDR addr = bp_tgt->placed_address;
   char bundle[BUNDLE_LEN];
@@ -593,7 +589,8 @@ ia64_memory_insert_breakpoint (struct bp_target_info *bp_tgt)
 }
 
 static int
 }
 
 static int
-ia64_memory_remove_breakpoint (struct bp_target_info *bp_tgt)
+ia64_memory_remove_breakpoint (struct gdbarch *gdbarch,
+                              struct bp_target_info *bp_tgt)
 {
   CORE_ADDR addr = bp_tgt->placed_address;
   char bundle[BUNDLE_LEN];
 {
   CORE_ADDR addr = bp_tgt->placed_address;
   char bundle[BUNDLE_LEN];
@@ -625,7 +622,7 @@ ia64_memory_remove_breakpoint (struct bp_target_info *bp_tgt)
 /* We don't really want to use this, but remote.c needs to call it in order
    to figure out if Z-packets are supported or not.  Oh, well. */
 const unsigned char *
 /* We don't really want to use this, but remote.c needs to call it in order
    to figure out if Z-packets are supported or not.  Oh, well. */
 const unsigned char *
-ia64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+ia64_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
 {
   static unsigned char breakpoint[] =
     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 {
   static unsigned char breakpoint[] =
     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
@@ -637,27 +634,32 @@ ia64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 }
 
 static CORE_ADDR
 }
 
 static CORE_ADDR
-ia64_read_pc (ptid_t ptid)
+ia64_read_pc (struct regcache *regcache)
 {
 {
-  CORE_ADDR psr_value = read_register_pid (IA64_PSR_REGNUM, ptid);
-  CORE_ADDR pc_value   = read_register_pid (IA64_IP_REGNUM, ptid);
-  int slot_num = (psr_value >> 41) & 3;
+  ULONGEST psr_value, pc_value;
+  int slot_num;
+
+  regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr_value);
+  regcache_cooked_read_unsigned (regcache, IA64_IP_REGNUM, &pc_value);
+  slot_num = (psr_value >> 41) & 3;
 
   return pc_value | (slot_num * SLOT_MULTIPLIER);
 }
 
 void
 
   return pc_value | (slot_num * SLOT_MULTIPLIER);
 }
 
 void
-ia64_write_pc (CORE_ADDR new_pc, ptid_t ptid)
+ia64_write_pc (struct regcache *regcache, CORE_ADDR new_pc)
 {
   int slot_num = (int) (new_pc & 0xf) / SLOT_MULTIPLIER;
 {
   int slot_num = (int) (new_pc & 0xf) / SLOT_MULTIPLIER;
-  CORE_ADDR psr_value = read_register_pid (IA64_PSR_REGNUM, ptid);
+  ULONGEST psr_value;
+
+  regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr_value);
   psr_value &= ~(3LL << 41);
   psr_value &= ~(3LL << 41);
-  psr_value |= (CORE_ADDR)(slot_num & 0x3) << 41;
+  psr_value |= (ULONGEST)(slot_num & 0x3) << 41;
 
   new_pc &= ~0xfLL;
 
 
   new_pc &= ~0xfLL;
 
-  write_register_pid (IA64_PSR_REGNUM, psr_value, ptid);
-  write_register_pid (IA64_IP_REGNUM, new_pc, ptid);
+  regcache_cooked_write_unsigned (regcache, IA64_PSR_REGNUM, psr_value);
+  regcache_cooked_write_unsigned (regcache, IA64_IP_REGNUM, new_pc);
 }
 
 #define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
 }
 
 #define IS_NaT_COLLECTION_ADDR(addr) ((((addr) >> 3) & 0x3f) == 0x3f)
@@ -692,7 +694,7 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
       /* First try and use the libunwind special reg accessor, otherwise fallback to
         standard logic.  */
       if (!libunwind_is_initialized ()
       /* First try and use the libunwind special reg accessor, otherwise fallback to
         standard logic.  */
       if (!libunwind_is_initialized ()
-         || libunwind_get_reg_special (gdbarch, regnum, buf) != 0)
+         || libunwind_get_reg_special (gdbarch, regcache, regnum, buf) != 0)
 #endif
        {
          /* The fallback position is to assume that r32-r127 are found sequentially
 #endif
        {
          /* The fallback position is to assume that r32-r127 are found sequentially
@@ -712,10 +714,10 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
            {
              ULONGEST reg_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
              reg = read_memory_integer ((CORE_ADDR)reg_addr, 8);
            {
              ULONGEST reg_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
              reg = read_memory_integer ((CORE_ADDR)reg_addr, 8);
-             store_unsigned_integer (buf, register_size (current_gdbarch, regnum), reg);
+             store_unsigned_integer (buf, register_size (gdbarch, regnum), reg);
            }
          else
            }
          else
-           store_unsigned_integer (buf, register_size (current_gdbarch, regnum), 0);
+           store_unsigned_integer (buf, register_size (gdbarch, regnum), 0);
        }
     }
   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
        }
     }
   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
@@ -724,7 +726,7 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
       ULONGEST unat;
       regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat);
       unatN_val = (unat & (1LL << (regnum - IA64_NAT0_REGNUM))) != 0;
       ULONGEST unat;
       regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat);
       unatN_val = (unat & (1LL << (regnum - IA64_NAT0_REGNUM))) != 0;
-      store_unsigned_integer (buf, register_size (current_gdbarch, regnum), unatN_val);
+      store_unsigned_integer (buf, register_size (gdbarch, regnum), unatN_val);
     }
   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
     {
     }
   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
     {
@@ -759,7 +761,7 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
          natN_val = (nat_collection >> nat_bit) & 1;
        }
       
          natN_val = (nat_collection >> nat_bit) & 1;
        }
       
-      store_unsigned_integer (buf, register_size (current_gdbarch, regnum), natN_val);
+      store_unsigned_integer (buf, register_size (gdbarch, regnum), natN_val);
     }
   else if (regnum == VBOF_REGNUM)
     {
     }
   else if (regnum == VBOF_REGNUM)
     {
@@ -774,7 +776,7 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
       /* 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));
       /* 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 (current_gdbarch, regnum), vbsp);
+      store_unsigned_integer (buf, register_size (gdbarch, regnum), vbsp);
     }
   else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
     {
     }
   else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
     {
@@ -796,10 +798,10 @@ ia64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
                 + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
        }
       prN_val = (pr & (1LL << (regnum - VP0_REGNUM))) != 0;
                 + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
        }
       prN_val = (pr & (1LL << (regnum - VP0_REGNUM))) != 0;
-      store_unsigned_integer (buf, register_size (current_gdbarch, regnum), prN_val);
+      store_unsigned_integer (buf, register_size (gdbarch, regnum), prN_val);
     }
   else
     }
   else
-    memset (buf, 0, register_size (current_gdbarch, regnum));
+    memset (buf, 0, register_size (gdbarch, regnum));
 }
 
 static void
 }
 
 static void
@@ -826,7 +828,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
     {
       ULONGEST unatN_val, unat, unatN_mask;
       regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat);
     {
       ULONGEST unatN_val, unat, unatN_mask;
       regcache_cooked_read_unsigned (regcache, IA64_UNAT_REGNUM, &unat);
-      unatN_val = extract_unsigned_integer (buf, register_size (current_gdbarch, regnum)); 
+      unatN_val = extract_unsigned_integer (buf, register_size (gdbarch, regnum)); 
       unatN_mask = (1LL << (regnum - IA64_NAT0_REGNUM));
       if (unatN_val == 0)
        unat &= ~unatN_mask;
       unatN_mask = (1LL << (regnum - IA64_NAT0_REGNUM));
       if (unatN_val == 0)
        unat &= ~unatN_mask;
@@ -850,7 +852,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
       if ((cfm & 0x7f) > regnum - V32_REGNUM) 
        gr_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
       
       if ((cfm & 0x7f) > regnum - V32_REGNUM) 
        gr_addr = rse_address_add (bsp, (regnum - V32_REGNUM));
       
-      natN_val = extract_unsigned_integer (buf, register_size (current_gdbarch, regnum)); 
+      natN_val = extract_unsigned_integer (buf, register_size (gdbarch, regnum)); 
 
       if (gr_addr != 0 && (natN_val == 0 || natN_val == 1))
        {
 
       if (gr_addr != 0 && (natN_val == 0 || natN_val == 1))
        {
@@ -879,7 +881,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
                nat_collection |= natN_mask;
              else
                nat_collection &= ~natN_mask;
                nat_collection |= natN_mask;
              else
                nat_collection &= ~natN_mask;
-             store_unsigned_integer (nat_buf, register_size (current_gdbarch, regnum), nat_collection);
+             store_unsigned_integer (nat_buf, register_size (gdbarch, regnum), nat_collection);
              write_memory (nat_addr, nat_buf, 8);
            }
        }
              write_memory (nat_addr, nat_buf, 8);
            }
        }
@@ -904,7 +906,7 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
          regnum = VP16_REGNUM 
                 + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
        }
          regnum = VP16_REGNUM 
                 + ((regnum - VP16_REGNUM) + rrb_pr) % 48;
        }
-      prN_val = extract_unsigned_integer (buf, register_size (current_gdbarch, regnum)); 
+      prN_val = extract_unsigned_integer (buf, register_size (gdbarch, regnum)); 
       prN_mask = (1LL << (regnum - VP0_REGNUM));
       if (prN_val == 0)
        pr &= ~prN_mask;
       prN_mask = (1LL << (regnum - VP0_REGNUM));
       if (prN_val == 0)
        pr &= ~prN_mask;
@@ -918,9 +920,10 @@ ia64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
    and the special ia64 floating point register format.  */
 
 static int
    and the special ia64 floating point register format.  */
 
 static int
-ia64_convert_register_p (int regno, struct type *type)
+ia64_convert_register_p (struct gdbarch *gdbarch, int regno, struct type *type)
 {
 {
-  return (regno >= IA64_FR0_REGNUM && regno <= IA64_FR127_REGNUM);
+  return (regno >= IA64_FR0_REGNUM && regno <= IA64_FR127_REGNUM
+         && type != builtin_type_ia64_ext);
 }
 
 static void
 }
 
 static void
@@ -964,6 +967,12 @@ refine_prologue_limit (CORE_ADDR pc, CORE_ADDR lim_pc, int *trust_limit)
 {
   struct symtab_and_line prologue_sal;
   CORE_ADDR start_pc = pc;
 {
   struct symtab_and_line prologue_sal;
   CORE_ADDR start_pc = pc;
+  CORE_ADDR end_pc;
+
+  /* The prologue can not possibly go past the function end itself,
+     so we can already adjust LIM_PC accordingly.  */
+  if (find_pc_partial_function (pc, NULL, NULL, &end_pc) && end_pc < lim_pc)
+    lim_pc = end_pc;
 
   /* Start off not trusting the limit.  */
   *trust_limit = 0;
 
   /* Start off not trusting the limit.  */
   *trust_limit = 0;
@@ -1505,7 +1514,7 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct frame_info *next_frame,
 }
 
 CORE_ADDR
 }
 
 CORE_ADDR
-ia64_skip_prologue (CORE_ADDR pc)
+ia64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 {
   struct ia64_frame_cache cache;
   cache.base = 0;
 {
   struct ia64_frame_cache cache;
   cache.base = 0;
@@ -1591,6 +1600,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
                          enum lval_type *lvalp, CORE_ADDR *addrp,
                          int *realnump, gdb_byte *valuep)
 {
                          enum lval_type *lvalp, CORE_ADDR *addrp,
                          int *realnump, gdb_byte *valuep)
 {
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
   struct ia64_frame_cache *cache =
     ia64_frame_cache (next_frame, this_cache);
   char dummy_valp[MAX_REGISTER_SIZE];
   struct ia64_frame_cache *cache =
     ia64_frame_cache (next_frame, this_cache);
   char dummy_valp[MAX_REGISTER_SIZE];
@@ -1611,12 +1621,12 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
   if (!valuep)
     valuep = dummy_valp;
   
   if (!valuep)
     valuep = dummy_valp;
   
-  memset (valuep, 0, register_size (current_gdbarch, regnum));
+  memset (valuep, 0, register_size (gdbarch, regnum));
  
  
-  if (regnum == SP_REGNUM)
+  if (regnum == gdbarch_sp_regnum (gdbarch))
     {
       /* Handle SP values for all frames but the topmost. */
     {
       /* Handle SP values for all frames but the topmost. */
-      store_unsigned_integer (valuep, register_size (current_gdbarch, regnum),
+      store_unsigned_integer (valuep, register_size (gdbarch, regnum),
                              cache->base);
     }
   else if (regnum == IA64_BSP_REGNUM)
                              cache->base);
     }
   else if (regnum == IA64_BSP_REGNUM)
@@ -1641,7 +1651,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
       bsp = rse_address_add (cache->bsp, -(cache->sof));
       prev_bsp = rse_address_add (bsp, (prev_cfm & 0x7f) - ((prev_cfm >> 7) & 0x7f));
 
       bsp = rse_address_add (cache->bsp, -(cache->sof));
       prev_bsp = rse_address_add (bsp, (prev_cfm & 0x7f) - ((prev_cfm >> 7) & 0x7f));
 
-      store_unsigned_integer (valuep, register_size (current_gdbarch, regnum), 
+      store_unsigned_integer (valuep, register_size (gdbarch, regnum), 
                              prev_bsp);
     }
   else if (regnum == IA64_CFM_REGNUM)
                              prev_bsp);
     }
   else if (regnum == IA64_CFM_REGNUM)
@@ -1652,10 +1662,10 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
        {
          *lvalp = lval_memory;
          *addrp = addr;
        {
          *lvalp = lval_memory;
          *addrp = addr;
-         read_memory (addr, valuep, register_size (current_gdbarch, regnum));
+         read_memory (addr, valuep, register_size (gdbarch, regnum));
        }
       else if (cache->prev_cfm)
        }
       else if (cache->prev_cfm)
-       store_unsigned_integer (valuep, register_size (current_gdbarch, regnum), cache->prev_cfm);
+       store_unsigned_integer (valuep, register_size (gdbarch, regnum), cache->prev_cfm);
       else if (cache->frameless)
        {
          CORE_ADDR cfm = 0;
       else if (cache->frameless)
        {
          CORE_ADDR cfm = 0;
@@ -1669,7 +1679,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
         above.  If the function lacks one of these frame pointers, we can
         still provide a value since we know the size of the frame.  */
       CORE_ADDR vfp = cache->base;
         above.  If the function lacks one of these frame pointers, we can
         still provide a value since we know the size of the frame.  */
       CORE_ADDR vfp = cache->base;
-      store_unsigned_integer (valuep, register_size (current_gdbarch, IA64_VFP_REGNUM), vfp);
+      store_unsigned_integer (valuep, register_size (gdbarch, IA64_VFP_REGNUM), vfp);
     }
   else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
     {
     }
   else if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
     {
@@ -1693,7 +1703,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
        }
       prN_val = extract_bit_field ((unsigned char *) pr_valuep,
                                    regnum - VP0_REGNUM, 1);
        }
       prN_val = extract_bit_field ((unsigned char *) pr_valuep,
                                    regnum - VP0_REGNUM, 1);
-      store_unsigned_integer (valuep, register_size (current_gdbarch, regnum), prN_val);
+      store_unsigned_integer (valuep, register_size (gdbarch, regnum), prN_val);
     }
   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
     {
     }
   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT31_REGNUM)
     {
@@ -1707,7 +1717,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
                                &unat_optim, &unat_lval, &unat_addr, &unat_realnum, unat_valuep);
       unatN_val = extract_bit_field ((unsigned char *) unat_valuep,
                                    regnum - IA64_NAT0_REGNUM, 1);
                                &unat_optim, &unat_lval, &unat_addr, &unat_realnum, unat_valuep);
       unatN_val = extract_bit_field ((unsigned char *) unat_valuep,
                                    regnum - IA64_NAT0_REGNUM, 1);
-      store_unsigned_integer (valuep, register_size (current_gdbarch, regnum), 
+      store_unsigned_integer (valuep, register_size (gdbarch, regnum), 
                               unatN_val);
     }
   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
                               unatN_val);
     }
   else if (IA64_NAT32_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
@@ -1742,7 +1752,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
          natval = (nat_collection >> nat_bit) & 1;
        }
 
          natval = (nat_collection >> nat_bit) & 1;
        }
 
-      store_unsigned_integer (valuep, register_size (current_gdbarch, regnum), natval);
+      store_unsigned_integer (valuep, register_size (gdbarch, regnum), natval);
     }
   else if (regnum == IA64_IP_REGNUM)
     {
     }
   else if (regnum == IA64_IP_REGNUM)
     {
@@ -1753,7 +1763,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
        {
          *lvalp = lval_memory;
          *addrp = addr;
        {
          *lvalp = lval_memory;
          *addrp = addr;
-         read_memory (addr, buf, register_size (current_gdbarch, IA64_IP_REGNUM));
+         read_memory (addr, buf, register_size (gdbarch, IA64_IP_REGNUM));
          pc = extract_unsigned_integer (buf, 8);
        }
       else if (cache->frameless)
          pc = extract_unsigned_integer (buf, 8);
        }
       else if (cache->frameless)
@@ -1782,7 +1792,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
        {
          *lvalp = lval_memory;
          *addrp = addr;
        {
          *lvalp = lval_memory;
          *addrp = addr;
-         read_memory (addr, buf, register_size (current_gdbarch, IA64_IP_REGNUM));
+         read_memory (addr, buf, register_size (gdbarch, IA64_IP_REGNUM));
          pc = extract_unsigned_integer (buf, 8);
        }
       else if (cache->frameless)
          pc = extract_unsigned_integer (buf, 8);
        }
       else if (cache->frameless)
@@ -1804,7 +1814,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
        {
          *lvalp = lval_memory;
          *addrp = addr;
        {
          *lvalp = lval_memory;
          *addrp = addr;
-         read_memory (addr, buf, register_size (current_gdbarch, IA64_BR0_REGNUM));
+         read_memory (addr, buf, register_size (gdbarch, IA64_BR0_REGNUM));
          br0 = extract_unsigned_integer (buf, 8);
        }
       store_unsigned_integer (valuep, 8, br0);
          br0 = extract_unsigned_integer (buf, 8);
        }
       store_unsigned_integer (valuep, 8, br0);
@@ -1820,7 +1830,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
        {
          *lvalp = lval_memory;
          *addrp = addr;
        {
          *lvalp = lval_memory;
          *addrp = addr;
-         read_memory (addr, valuep, register_size (current_gdbarch, regnum));
+         read_memory (addr, valuep, register_size (gdbarch, regnum));
        }
       else if (cache->frameless)
         {
        }
       else if (cache->frameless)
         {
@@ -1844,7 +1854,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
          addr = rse_address_add (prev_bof, (regnum - IA64_GR32_REGNUM));
          *lvalp = lval_memory;
          *addrp = addr;
          addr = rse_address_add (prev_bof, (regnum - IA64_GR32_REGNUM));
          *lvalp = lval_memory;
          *addrp = addr;
-         read_memory (addr, valuep, register_size (current_gdbarch, regnum));
+         read_memory (addr, valuep, register_size (gdbarch, regnum));
         }
     }
   else
         }
     }
   else
@@ -1868,7 +1878,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
        {
          *lvalp = lval_memory;
          *addrp = addr;
        {
          *lvalp = lval_memory;
          *addrp = addr;
-         read_memory (addr, valuep, register_size (current_gdbarch, regnum));
+         read_memory (addr, valuep, register_size (gdbarch, regnum));
        }
       /* Otherwise, punt and get the current value of the register.  */
       else 
        }
       /* Otherwise, punt and get the current value of the register.  */
       else 
@@ -1899,41 +1909,44 @@ ia64_frame_sniffer (struct frame_info *next_frame)
 /* Signal trampolines.  */
 
 static void
 /* Signal trampolines.  */
 
 static void
-ia64_sigtramp_frame_init_saved_regs (struct ia64_frame_cache *cache)
+ia64_sigtramp_frame_init_saved_regs (struct frame_info *next_frame,
+                                    struct ia64_frame_cache *cache)
 {
 {
-  if (SIGCONTEXT_REGISTER_ADDRESS)
+  struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (next_frame));
+
+  if (tdep->sigcontext_register_address)
     {
       int regno;
 
       cache->saved_regs[IA64_VRAP_REGNUM] = 
     {
       int regno;
 
       cache->saved_regs[IA64_VRAP_REGNUM] = 
-       SIGCONTEXT_REGISTER_ADDRESS (cache->base, IA64_IP_REGNUM);
+       tdep->sigcontext_register_address (cache->base, IA64_IP_REGNUM);
       cache->saved_regs[IA64_CFM_REGNUM] = 
       cache->saved_regs[IA64_CFM_REGNUM] = 
-       SIGCONTEXT_REGISTER_ADDRESS (cache->base, IA64_CFM_REGNUM);
+       tdep->sigcontext_register_address (cache->base, IA64_CFM_REGNUM);
       cache->saved_regs[IA64_PSR_REGNUM] = 
       cache->saved_regs[IA64_PSR_REGNUM] = 
-       SIGCONTEXT_REGISTER_ADDRESS (cache->base, IA64_PSR_REGNUM);
+       tdep->sigcontext_register_address (cache->base, IA64_PSR_REGNUM);
       cache->saved_regs[IA64_BSP_REGNUM] = 
       cache->saved_regs[IA64_BSP_REGNUM] = 
-       SIGCONTEXT_REGISTER_ADDRESS (cache->base, IA64_BSP_REGNUM);
+       tdep->sigcontext_register_address (cache->base, IA64_BSP_REGNUM);
       cache->saved_regs[IA64_RNAT_REGNUM] = 
       cache->saved_regs[IA64_RNAT_REGNUM] = 
-       SIGCONTEXT_REGISTER_ADDRESS (cache->base, IA64_RNAT_REGNUM);
+       tdep->sigcontext_register_address (cache->base, IA64_RNAT_REGNUM);
       cache->saved_regs[IA64_CCV_REGNUM] = 
       cache->saved_regs[IA64_CCV_REGNUM] = 
-       SIGCONTEXT_REGISTER_ADDRESS (cache->base, IA64_CCV_REGNUM);
+       tdep->sigcontext_register_address (cache->base, IA64_CCV_REGNUM);
       cache->saved_regs[IA64_UNAT_REGNUM] = 
       cache->saved_regs[IA64_UNAT_REGNUM] = 
-       SIGCONTEXT_REGISTER_ADDRESS (cache->base, IA64_UNAT_REGNUM);
+       tdep->sigcontext_register_address (cache->base, IA64_UNAT_REGNUM);
       cache->saved_regs[IA64_FPSR_REGNUM] = 
       cache->saved_regs[IA64_FPSR_REGNUM] = 
-       SIGCONTEXT_REGISTER_ADDRESS (cache->base, IA64_FPSR_REGNUM);
+       tdep->sigcontext_register_address (cache->base, IA64_FPSR_REGNUM);
       cache->saved_regs[IA64_PFS_REGNUM] = 
       cache->saved_regs[IA64_PFS_REGNUM] = 
-       SIGCONTEXT_REGISTER_ADDRESS (cache->base, IA64_PFS_REGNUM);
+       tdep->sigcontext_register_address (cache->base, IA64_PFS_REGNUM);
       cache->saved_regs[IA64_LC_REGNUM] = 
       cache->saved_regs[IA64_LC_REGNUM] = 
-       SIGCONTEXT_REGISTER_ADDRESS (cache->base, IA64_LC_REGNUM);
+       tdep->sigcontext_register_address (cache->base, IA64_LC_REGNUM);
       for (regno = IA64_GR1_REGNUM; regno <= IA64_GR31_REGNUM; regno++)
        cache->saved_regs[regno] =
       for (regno = IA64_GR1_REGNUM; regno <= IA64_GR31_REGNUM; regno++)
        cache->saved_regs[regno] =
-         SIGCONTEXT_REGISTER_ADDRESS (cache->base, regno);
+         tdep->sigcontext_register_address (cache->base, regno);
       for (regno = IA64_BR0_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
        cache->saved_regs[regno] =
       for (regno = IA64_BR0_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
        cache->saved_regs[regno] =
-         SIGCONTEXT_REGISTER_ADDRESS (cache->base, regno);
+         tdep->sigcontext_register_address (cache->base, regno);
       for (regno = IA64_FR2_REGNUM; regno <= IA64_FR31_REGNUM; regno++)
        cache->saved_regs[regno] =
       for (regno = IA64_FR2_REGNUM; regno <= IA64_FR31_REGNUM; regno++)
        cache->saved_regs[regno] =
-         SIGCONTEXT_REGISTER_ADDRESS (cache->base, regno);
+         tdep->sigcontext_register_address (cache->base, regno);
     }
 }
 
     }
 }
 
@@ -1962,7 +1975,7 @@ ia64_sigtramp_frame_cache (struct frame_info *next_frame, void **this_cache)
   cache->cfm = extract_unsigned_integer (buf, 8);
   cache->sof = cache->cfm & 0x7f;
 
   cache->cfm = extract_unsigned_integer (buf, 8);
   cache->sof = cache->cfm & 0x7f;
 
-  ia64_sigtramp_frame_init_saved_regs (cache);
+  ia64_sigtramp_frame_init_saved_regs (next_frame, cache);
 
   *this_cache = cache;
   return cache;
 
   *this_cache = cache;
   return cache;
@@ -1994,6 +2007,7 @@ ia64_sigtramp_frame_prev_register (struct frame_info *next_frame,
   char dummy_valp[MAX_REGISTER_SIZE];
   char buf[MAX_REGISTER_SIZE];
 
   char dummy_valp[MAX_REGISTER_SIZE];
   char buf[MAX_REGISTER_SIZE];
 
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
   struct ia64_frame_cache *cache =
     ia64_sigtramp_frame_cache (next_frame, this_cache);
 
   struct ia64_frame_cache *cache =
     ia64_sigtramp_frame_cache (next_frame, this_cache);
 
@@ -2012,7 +2026,7 @@ ia64_sigtramp_frame_prev_register (struct frame_info *next_frame,
   if (!valuep)
     valuep = dummy_valp;
   
   if (!valuep)
     valuep = dummy_valp;
   
-  memset (valuep, 0, register_size (current_gdbarch, regnum));
+  memset (valuep, 0, register_size (gdbarch, regnum));
  
   if (regnum == IA64_IP_REGNUM)
     {
  
   if (regnum == IA64_IP_REGNUM)
     {
@@ -2023,7 +2037,7 @@ ia64_sigtramp_frame_prev_register (struct frame_info *next_frame,
        {
          *lvalp = lval_memory;
          *addrp = addr;
        {
          *lvalp = lval_memory;
          *addrp = addr;
-         read_memory (addr, buf, register_size (current_gdbarch, IA64_IP_REGNUM));
+         read_memory (addr, buf, register_size (gdbarch, IA64_IP_REGNUM));
          pc = extract_unsigned_integer (buf, 8);
        }
       pc &= ~0xf;
          pc = extract_unsigned_integer (buf, 8);
        }
       pc &= ~0xf;
@@ -2040,7 +2054,7 @@ ia64_sigtramp_frame_prev_register (struct frame_info *next_frame,
        {
          *lvalp = lval_memory;
          *addrp = addr;
        {
          *lvalp = lval_memory;
          *addrp = addr;
-         read_memory (addr, valuep, register_size (current_gdbarch, regnum));
+         read_memory (addr, valuep, register_size (gdbarch, regnum));
        }
     }
   else
        }
     }
   else
@@ -2051,7 +2065,7 @@ ia64_sigtramp_frame_prev_register (struct frame_info *next_frame,
        {
          *lvalp = lval_memory;
          *addrp = addr;
        {
          *lvalp = lval_memory;
          *addrp = addr;
-         read_memory (addr, valuep, register_size (current_gdbarch, regnum));
+         read_memory (addr, valuep, register_size (gdbarch, regnum));
        }
     }
 
        }
     }
 
@@ -2218,106 +2232,53 @@ ia64_access_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t *val,
   long new_sof, old_sof;
   char buf[MAX_REGISTER_SIZE];
   
   long new_sof, old_sof;
   char buf[MAX_REGISTER_SIZE];
   
-  if (write)
-    {
-      if (regnum < 0)
-       /* ignore writes to pseudo-registers such as UNW_IA64_PROC_STARTI.  */
-       return 0;
-  
-      switch (uw_regnum)
-       {
-       case UNW_REG_IP:
-         ia64_write_pc (*val, inferior_ptid);
-         break;
+  /* We never call any libunwind routines that need to write registers.  */
+  gdb_assert (!write);
+
+  switch (uw_regnum)
+    {
+      case UNW_REG_IP:
+       /* Libunwind expects to see the pc value which means the slot number
+          from the psr must be merged with the ip word address.  */
+       frame_unwind_register (next_frame, IA64_IP_REGNUM, buf);
+       ip = extract_unsigned_integer (buf, 8); 
+       frame_unwind_register (next_frame, IA64_PSR_REGNUM, buf);
+       psr = extract_unsigned_integer (buf, 8); 
+       *val = ip | ((psr >> 41) & 0x3);
+       break;
+ 
+      case UNW_IA64_AR_BSP:
+       /* Libunwind expects to see the beginning of the current register
+          frame so we must account for the fact that ptrace() will return a value
+          for bsp that points *after* the current register frame.  */
+       frame_unwind_register (next_frame, IA64_BSP_REGNUM, buf);
+       bsp = extract_unsigned_integer (buf, 8);
+       frame_unwind_register (next_frame, IA64_CFM_REGNUM, buf);
+       cfm = extract_unsigned_integer (buf, 8); 
+       sof = (cfm & 0x7f);
+       *val = ia64_rse_skip_regs (bsp, -sof);
+       break;
 
 
-       case UNW_IA64_AR_BSPSTORE:
-         write_register (IA64_BSP_REGNUM, *val);
-         break;
-         
-       case UNW_IA64_AR_BSP:
-       case UNW_IA64_BSP:
-         /* Account for the fact that ptrace() expects bsp to point
-            after the current register frame.  */
-         cfm = read_register (IA64_CFM_REGNUM);
-         sof = (cfm & 0x7f);
-         bsp = ia64_rse_skip_regs (*val, sof);
-         write_register (IA64_BSP_REGNUM, bsp);
-         break;
-         
-       case UNW_IA64_CFM:
-         /* If we change CFM, we need to adjust ptrace's notion of
-            bsp accordingly, so that the real bsp remains
-            unchanged.  */
-         bsp = read_register (IA64_BSP_REGNUM);
-         cfm = read_register (IA64_CFM_REGNUM);
-         old_sof = (cfm & 0x7f);
-         new_sof = (*val & 0x7f);
-         if (old_sof != new_sof)
-           {
-             bsp = ia64_rse_skip_regs (bsp, -old_sof + new_sof);
-             write_register (IA64_BSP_REGNUM, bsp);
-           }
-         write_register (IA64_CFM_REGNUM, *val);
-         break;
-         
-       default:
-         write_register (regnum, *val);
-         break;
-       }
-      if (gdbarch_debug >= 1)
-       fprintf_unfiltered (gdb_stdlog, 
-                           "  access_reg: to cache: %4s=0x%s\n",
-                           (((unsigned) regnum <= IA64_NAT127_REGNUM)
-                            ? ia64_register_names[regnum] : "r??"), 
-                           paddr_nz (*val));
-    }
-  else
-    {
-      switch (uw_regnum)
-       {
-       case UNW_REG_IP:
-         /* Libunwind expects to see the pc value which means the slot number
-            from the psr must be merged with the ip word address.  */
-         frame_unwind_register (next_frame, IA64_IP_REGNUM, buf);
-         ip = extract_unsigned_integer (buf, 8); 
-         frame_unwind_register (next_frame, IA64_PSR_REGNUM, buf);
-         psr = extract_unsigned_integer (buf, 8); 
-         *val = ip | ((psr >> 41) & 0x3);
-         break;
-         
-       case UNW_IA64_AR_BSP:
-         /* Libunwind expects to see the beginning of the current register
-            frame so we must account for the fact that ptrace() will return a value
-            for bsp that points *after* the current register frame.  */
-         frame_unwind_register (next_frame, IA64_BSP_REGNUM, buf);
-         bsp = extract_unsigned_integer (buf, 8);
-         frame_unwind_register (next_frame, IA64_CFM_REGNUM, buf);
-         cfm = extract_unsigned_integer (buf, 8); 
-         sof = (cfm & 0x7f);
-         *val = ia64_rse_skip_regs (bsp, -sof);
-         break;
-         
-       case UNW_IA64_AR_BSPSTORE:
-         /* Libunwind wants bspstore to be after the current register frame.
-            This is what ptrace() and gdb treats as the regular bsp value.  */
-         frame_unwind_register (next_frame, IA64_BSP_REGNUM, buf);
-         *val = extract_unsigned_integer (buf, 8);
-         break;
+      case UNW_IA64_AR_BSPSTORE:
+       /* Libunwind wants bspstore to be after the current register frame.
+          This is what ptrace() and gdb treats as the regular bsp value.  */
+       frame_unwind_register (next_frame, IA64_BSP_REGNUM, buf);
+       *val = extract_unsigned_integer (buf, 8);
+       break;
 
 
-       default:
-         /* For all other registers, just unwind the value directly.  */
-         frame_unwind_register (next_frame, regnum, buf);
-         *val = extract_unsigned_integer (buf, 8); 
-         break;
-       }
-      
-      if (gdbarch_debug >= 1)
-       fprintf_unfiltered (gdb_stdlog, 
-                           "  access_reg: from cache: %4s=0x%s\n",
-                           (((unsigned) regnum <= IA64_NAT127_REGNUM)
-                            ? ia64_register_names[regnum] : "r??"), 
-                           paddr_nz (*val));
+      default:
+       /* For all other registers, just unwind the value directly.  */
+       frame_unwind_register (next_frame, regnum, buf);
+       *val = extract_unsigned_integer (buf, 8); 
+       break;
     }
     }
+      
+  if (gdbarch_debug >= 1)
+    fprintf_unfiltered (gdb_stdlog, 
+                       "  access_reg: from cache: %4s=0x%s\n",
+                       (((unsigned) regnum <= IA64_NAT127_REGNUM)
+                       ? ia64_register_names[regnum] : "r??"), 
+                       paddr_nz (*val));
   return 0;
 }
 
   return 0;
 }
 
@@ -2327,11 +2288,13 @@ ia64_access_fpreg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_fpreg_t *val
                   int write, void *arg)
 {
   int regnum = ia64_uw2gdb_regnum (uw_regnum);
                   int write, void *arg)
 {
   int regnum = ia64_uw2gdb_regnum (uw_regnum);
+  struct frame_info *next_frame = arg;
   
   
-  if (write)
-    regcache_cooked_write (current_regcache, regnum, (char *) val);
-  else
-    regcache_cooked_read (current_regcache, regnum, (char *) val);
+  /* We never call any libunwind routines that need to write registers.  */
+  gdb_assert (!write);
+
+  frame_unwind_register (next_frame, regnum, (char *) val);
+
   return 0;
 }
 
   return 0;
 }
 
@@ -2342,94 +2305,49 @@ ia64_access_rse_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t *va
 {
   int regnum = ia64_uw2gdb_regnum (uw_regnum);
   unw_word_t bsp, sof, sol, cfm, psr, ip;
 {
   int regnum = ia64_uw2gdb_regnum (uw_regnum);
   unw_word_t bsp, sof, sol, cfm, psr, ip;
+  struct regcache *regcache = arg;
   long new_sof, old_sof;
   long new_sof, old_sof;
+  char buf[MAX_REGISTER_SIZE];
   
   
-  if (write)
-    {
-      if (regnum < 0)
-       /* ignore writes to pseudo-registers such as UNW_IA64_PROC_STARTI.  */
-       return 0;
-  
-      switch (uw_regnum)
-       {
-       case UNW_REG_IP:
-         ia64_write_pc (*val, inferior_ptid);
-         break;
-
-       case UNW_IA64_AR_BSPSTORE:
-         write_register (IA64_BSP_REGNUM, *val);
-         break;
-         
-       case UNW_IA64_AR_BSP:
-       case UNW_IA64_BSP:
-         /* Account for the fact that ptrace() expects bsp to point
-            after the current register frame.  */
-         cfm = read_register (IA64_CFM_REGNUM);
-         sof = (cfm & 0x7f);
-         bsp = ia64_rse_skip_regs (*val, sof);
-         write_register (IA64_BSP_REGNUM, bsp);
-         break;
-         
-       case UNW_IA64_CFM:
-         /* If we change CFM, we need to adjust ptrace's notion of
-            bsp accordingly, so that the real bsp remains
-            unchanged.  */
-         bsp = read_register (IA64_BSP_REGNUM);
-         cfm = read_register (IA64_CFM_REGNUM);
-         old_sof = (cfm & 0x7f);
-         new_sof = (*val & 0x7f);
-         if (old_sof != new_sof)
-           {
-             bsp = ia64_rse_skip_regs (bsp, -old_sof + new_sof);
-             write_register (IA64_BSP_REGNUM, bsp);
-           }
-         write_register (IA64_CFM_REGNUM, *val);
-         break;
-         
-       default:
-         write_register (regnum, *val);
-         break;
-       }
-      if (gdbarch_debug >= 1)
-       fprintf_unfiltered (gdb_stdlog, 
-                           "  access_rse_reg: to cache: %4s=0x%s\n",
-                           (((unsigned) regnum <= IA64_NAT127_REGNUM)
-                            ? ia64_register_names[regnum] : "r??"), 
-                           paddr_nz (*val));
-    }
-  else
-    {
-      switch (uw_regnum)
-       {
-       case UNW_REG_IP:
-         /* Libunwind expects to see the pc value which means the slot number
-            from the psr must be merged with the ip word address.  */
-         ip = read_register (IA64_IP_REGNUM); 
-         psr = read_register (IA64_PSR_REGNUM);
-         *val = ip | ((psr >> 41) & 0x3);
-         break;
+  /* We never call any libunwind routines that need to write registers.  */
+  gdb_assert (!write);
+
+  switch (uw_regnum)
+    {
+      case UNW_REG_IP:
+       /* Libunwind expects to see the pc value which means the slot number
+          from the psr must be merged with the ip word address.  */
+       regcache_cooked_read (regcache, IA64_IP_REGNUM, buf);
+       ip = extract_unsigned_integer (buf, 8); 
+       regcache_cooked_read (regcache, IA64_PSR_REGNUM, buf);
+       psr = extract_unsigned_integer (buf, 8); 
+       *val = ip | ((psr >> 41) & 0x3);
+       break;
          
          
-       case UNW_IA64_AR_BSP:
-         /* Libunwind expects to see the beginning of the current register
-            frame so we must account for the fact that ptrace() will return a value
-            for bsp that points *after* the current register frame.  */
-         bsp = read_register (IA64_BSP_REGNUM);
-         cfm = read_register (IA64_CFM_REGNUM);
-         sof = (cfm & 0x7f);
-         *val = ia64_rse_skip_regs (bsp, -sof);
-         break;
+      case UNW_IA64_AR_BSP:
+       /* Libunwind expects to see the beginning of the current register
+          frame so we must account for the fact that ptrace() will return a value
+          for bsp that points *after* the current register frame.  */
+       regcache_cooked_read (regcache, IA64_BSP_REGNUM, buf);
+       bsp = extract_unsigned_integer (buf, 8);
+       regcache_cooked_read (regcache, IA64_CFM_REGNUM, buf);
+       cfm = extract_unsigned_integer (buf, 8); 
+       sof = (cfm & 0x7f);
+       *val = ia64_rse_skip_regs (bsp, -sof);
+       break;
          
          
-       case UNW_IA64_AR_BSPSTORE:
-         /* Libunwind wants bspstore to be after the current register frame.
-            This is what ptrace() and gdb treats as the regular bsp value.  */
-         *val = read_register (IA64_BSP_REGNUM);
-         break;
+      case UNW_IA64_AR_BSPSTORE:
+       /* Libunwind wants bspstore to be after the current register frame.
+          This is what ptrace() and gdb treats as the regular bsp value.  */
+       regcache_cooked_read (regcache, IA64_BSP_REGNUM, buf);
+       *val = extract_unsigned_integer (buf, 8);
+       break;
 
 
-       default:
-         /* For all other registers, just read the value directly.  */
-         *val = read_register (regnum);
-         break;
-       }
+      default:
+        /* For all other registers, just unwind the value directly.  */
+       regcache_cooked_read (regcache, regnum, buf);
+       *val = extract_unsigned_integer (buf, 8); 
+       break;
     }
       
   if (gdbarch_debug >= 1)
     }
       
   if (gdbarch_debug >= 1)
@@ -2442,6 +2360,22 @@ ia64_access_rse_reg (unw_addr_space_t as, unw_regnum_t uw_regnum, unw_word_t *va
   return 0;
 }
 
   return 0;
 }
 
+/* Libunwind callback accessor function for top-level fp registers.  */
+static int
+ia64_access_rse_fpreg (unw_addr_space_t as, unw_regnum_t uw_regnum,
+                      unw_fpreg_t *val, int write, void *arg)
+{
+  int regnum = ia64_uw2gdb_regnum (uw_regnum);
+  struct regcache *regcache = arg;
+  
+  /* We never call any libunwind routines that need to write registers.  */
+  gdb_assert (!write);
+
+  regcache_cooked_read (regcache, regnum, (char *) val);
+
+  return 0;
+}
+
 /* Libunwind callback accessor function for accessing memory.  */
 static int
 ia64_access_mem (unw_addr_space_t as,
 /* Libunwind callback accessor function for accessing memory.  */
 static int
 ia64_access_mem (unw_addr_space_t as,
@@ -2772,6 +2706,7 @@ ia64_libunwind_frame_prev_register (struct frame_info *next_frame,
 {
   int reg = regnum;
 
 {
   int reg = regnum;
 
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
   if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
     reg = IA64_PR_REGNUM;
   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
   if (VP0_REGNUM <= regnum && regnum <= VP63_REGNUM)
     reg = IA64_PR_REGNUM;
   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
@@ -2807,7 +2742,7 @@ ia64_libunwind_frame_prev_register (struct frame_info *next_frame,
        }
       prN_val = extract_bit_field ((unsigned char *) valuep,
                                   regnum - VP0_REGNUM, 1);
        }
       prN_val = extract_bit_field ((unsigned char *) valuep,
                                   regnum - VP0_REGNUM, 1);
-      store_unsigned_integer (valuep, register_size (current_gdbarch, regnum), prN_val);
+      store_unsigned_integer (valuep, register_size (gdbarch, regnum), prN_val);
     }
   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
     {
     }
   else if (IA64_NAT0_REGNUM <= regnum && regnum <= IA64_NAT127_REGNUM)
     {
@@ -2815,7 +2750,7 @@ ia64_libunwind_frame_prev_register (struct frame_info *next_frame,
 
       unatN_val = extract_bit_field ((unsigned char *) valuep,
                                    regnum - IA64_NAT0_REGNUM, 1);
 
       unatN_val = extract_bit_field ((unsigned char *) valuep,
                                    regnum - IA64_NAT0_REGNUM, 1);
-      store_unsigned_integer (valuep, register_size (current_gdbarch, regnum), 
+      store_unsigned_integer (valuep, register_size (gdbarch, regnum), 
                               unatN_val);
     }
   else if (regnum == IA64_BSP_REGNUM)
                               unatN_val);
     }
   else if (regnum == IA64_BSP_REGNUM)
@@ -2837,7 +2772,7 @@ ia64_libunwind_frame_prev_register (struct frame_info *next_frame,
       prev_cfm = extract_unsigned_integer (cfm_valuep, 8);
       prev_bsp = rse_address_add (prev_bsp, (prev_cfm & 0x7f));
 
       prev_cfm = extract_unsigned_integer (cfm_valuep, 8);
       prev_bsp = rse_address_add (prev_bsp, (prev_cfm & 0x7f));
 
-      store_unsigned_integer (valuep, register_size (current_gdbarch, regnum), 
+      store_unsigned_integer (valuep, register_size (gdbarch, regnum), 
                              prev_bsp);
     }
 
                              prev_bsp);
     }
 
@@ -2858,7 +2793,11 @@ static const struct frame_unwind ia64_libunwind_frame_unwind =
 {
   NORMAL_FRAME,
   ia64_libunwind_frame_this_id,
 {
   NORMAL_FRAME,
   ia64_libunwind_frame_this_id,
-  ia64_libunwind_frame_prev_register
+  ia64_libunwind_frame_prev_register,
+  NULL,
+  NULL,
+  NULL,
+  libunwind_frame_dealloc_cache
 };
 
 static const struct frame_unwind *
 };
 
 static const struct frame_unwind *
@@ -2976,7 +2915,7 @@ static unw_accessors_t ia64_unw_rse_accessors =
   ia64_get_dyn_info_list,
   ia64_access_mem,
   ia64_access_rse_reg,
   ia64_get_dyn_info_list,
   ia64_access_mem,
   ia64_access_rse_reg,
-  ia64_access_fpreg,
+  ia64_access_rse_fpreg,
   /* resume */
   /* get_proc_name */
 };
   /* resume */
   /* get_proc_name */
 };
@@ -2993,14 +2932,18 @@ static struct libunwind_descr ia64_libunwind_descr =
 
 #endif /* HAVE_LIBUNWIND_IA64_H  */
 
 
 #endif /* HAVE_LIBUNWIND_IA64_H  */
 
-/* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of
-   EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc and TYPE
-   is the type (which is known to be struct, union or array).  */
-int
-ia64_use_struct_convention (int gcc_p, struct type *type)
+static int
+ia64_use_struct_convention (struct type *type)
 {
   struct type *float_elt_type;
 
 {
   struct type *float_elt_type;
 
+  /* Don't use the struct convention for anything but structure,
+     union, or array types.  */
+  if (!(TYPE_CODE (type) == TYPE_CODE_STRUCT
+       || TYPE_CODE (type) == TYPE_CODE_UNION
+       || TYPE_CODE (type) == TYPE_CODE_ARRAY))
+    return 0;
+
   /* HFAs are structures (or arrays) consisting entirely of floating
      point values of the same length.  Up to 8 of these are returned
      in registers.  Don't use the struct convention when this is the
   /* HFAs are structures (or arrays) consisting entirely of floating
      point values of the same length.  Up to 8 of these are returned
      in registers.  Don't use the struct convention when this is the
@@ -3015,7 +2958,7 @@ ia64_use_struct_convention (int gcc_p, struct type *type)
   return TYPE_LENGTH (type) > 32;
 }
 
   return TYPE_LENGTH (type) > 32;
 }
 
-void
+static void
 ia64_extract_return_value (struct type *type, struct regcache *regcache,
                           gdb_byte *valbuf)
 {
 ia64_extract_return_value (struct type *type, struct regcache *regcache,
                           gdb_byte *valbuf)
 {
@@ -3065,13 +3008,80 @@ ia64_extract_return_value (struct type *type, struct regcache *regcache,
     }
 }
 
     }
 }
 
-CORE_ADDR
-ia64_extract_struct_value_address (struct regcache *regcache)
+static void
+ia64_store_return_value (struct type *type, struct regcache *regcache, 
+                        const gdb_byte *valbuf)
 {
 {
-  error (_("ia64_extract_struct_value_address called and cannot get struct value address"));
-  return 0;
+  struct type *float_elt_type;
+
+  float_elt_type = is_float_or_hfa_type (type);
+  if (float_elt_type != NULL)
+    {
+      char to[MAX_REGISTER_SIZE];
+      int offset = 0;
+      int regnum = IA64_FR8_REGNUM;
+      int n = TYPE_LENGTH (type) / TYPE_LENGTH (float_elt_type);
+
+      while (n-- > 0)
+       {
+         convert_typed_floating ((char *)valbuf + offset, float_elt_type,
+                                 to, builtin_type_ia64_ext);
+         regcache_cooked_write (regcache, regnum, to);
+         offset += TYPE_LENGTH (float_elt_type);
+         regnum++;
+       }
+    }
+  else
+    {
+      ULONGEST val;
+      int offset = 0;
+      int regnum = IA64_GR8_REGNUM;
+      int reglen = TYPE_LENGTH (register_type (get_regcache_arch (regcache),
+                                              IA64_GR8_REGNUM));
+      int n = TYPE_LENGTH (type) / reglen;
+      int m = TYPE_LENGTH (type) % reglen;
+
+      while (n-- > 0)
+       {
+         ULONGEST val;
+         memcpy (&val, (char *)valbuf + offset, reglen);
+         regcache_cooked_write_unsigned (regcache, regnum, val);
+         offset += reglen;
+         regnum++;
+       }
+
+      if (m)
+       {
+         memcpy (&val, (char *)valbuf + offset, m);
+          regcache_cooked_write_unsigned (regcache, regnum, val);
+       }
+    }
 }
 }
+  
+static enum return_value_convention
+ia64_return_value (struct gdbarch *gdbarch, struct type *valtype,
+                  struct regcache *regcache, gdb_byte *readbuf,
+                  const gdb_byte *writebuf)
+{
+  int struct_return = ia64_use_struct_convention (valtype);
+
+  if (writebuf != NULL)
+    {
+      gdb_assert (!struct_return);
+      ia64_store_return_value (valtype, regcache, writebuf);
+    }
 
 
+  if (readbuf != NULL)
+    {
+      gdb_assert (!struct_return);
+      ia64_extract_return_value (valtype, regcache, readbuf);
+    }
+
+  if (struct_return)
+    return RETURN_VALUE_STRUCT_CONVENTION;
+  else
+    return RETURN_VALUE_REGISTER_CONVENTION;
+}
 
 static int
 is_float_or_hfa_type_recurse (struct type *t, struct type **etp)
 
 static int
 is_float_or_hfa_type_recurse (struct type *t, struct type **etp)
@@ -3274,7 +3284,7 @@ find_extant_func_descr (CORE_ADDR faddr)
    stack using the address at fdaptr.  */
 
 static CORE_ADDR
    stack using the address at fdaptr.  */
 
 static CORE_ADDR
-find_func_descr (CORE_ADDR faddr, CORE_ADDR *fdaptr)
+find_func_descr (struct regcache *regcache, CORE_ADDR faddr, CORE_ADDR *fdaptr)
 {
   CORE_ADDR fdesc;
 
 {
   CORE_ADDR fdesc;
 
@@ -3282,7 +3292,7 @@ find_func_descr (CORE_ADDR faddr, CORE_ADDR *fdaptr)
 
   if (fdesc == 0)
     {
 
   if (fdesc == 0)
     {
-      CORE_ADDR global_pointer;
+      ULONGEST global_pointer;
       char buf[16];
 
       fdesc = *fdaptr;
       char buf[16];
 
       fdesc = *fdaptr;
@@ -3291,7 +3301,8 @@ find_func_descr (CORE_ADDR faddr, CORE_ADDR *fdaptr)
       global_pointer = ia64_find_global_pointer (faddr);
 
       if (global_pointer == 0)
       global_pointer = ia64_find_global_pointer (faddr);
 
       if (global_pointer == 0)
-       global_pointer = read_register (IA64_GR1_REGNUM);
+       regcache_cooked_read_unsigned (regcache,
+                                      IA64_GR1_REGNUM, &global_pointer);
 
       store_unsigned_integer (buf, 8, faddr);
       store_unsigned_integer (buf + 8, 8, global_pointer);
 
       store_unsigned_integer (buf, 8, faddr);
       store_unsigned_integer (buf + 8, 8, global_pointer);
@@ -3349,7 +3360,8 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   int len, argoffset;
   int nslots, rseslots, memslots, slotnum, nfuncargs;
   int floatreg;
   int len, argoffset;
   int nslots, rseslots, memslots, slotnum, nfuncargs;
   int floatreg;
-  CORE_ADDR bsp, cfm, pfs, new_bsp, funcdescaddr, pc, global_pointer;
+  ULONGEST bsp, cfm, pfs, new_bsp;
+  CORE_ADDR funcdescaddr, pc, global_pointer;
   CORE_ADDR func_addr = find_function_addr (function, NULL);
 
   nslots = 0;
   CORE_ADDR func_addr = find_function_addr (function, NULL);
 
   nslots = 0;
@@ -3375,20 +3387,20 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   memslots = nslots - rseslots;
 
   /* Allocate a new RSE frame.  */
   memslots = nslots - rseslots;
 
   /* Allocate a new RSE frame.  */
-  cfm = read_register (IA64_CFM_REGNUM);
+  regcache_cooked_read_unsigned (regcache, IA64_CFM_REGNUM, &cfm);
 
 
-  bsp = read_register (IA64_BSP_REGNUM);
+  regcache_cooked_read_unsigned (regcache, IA64_BSP_REGNUM, &bsp);
   new_bsp = rse_address_add (bsp, rseslots);
   new_bsp = rse_address_add (bsp, rseslots);
-  write_register (IA64_BSP_REGNUM, new_bsp);
+  regcache_cooked_write_unsigned (regcache, IA64_BSP_REGNUM, new_bsp);
 
 
-  pfs = read_register (IA64_PFS_REGNUM);
+  regcache_cooked_read_unsigned (regcache, IA64_PFS_REGNUM, &pfs);
   pfs &= 0xc000000000000000LL;
   pfs |= (cfm & 0xffffffffffffLL);
   pfs &= 0xc000000000000000LL;
   pfs |= (cfm & 0xffffffffffffLL);
-  write_register (IA64_PFS_REGNUM, pfs);
+  regcache_cooked_write_unsigned (regcache, IA64_PFS_REGNUM, pfs);
 
   cfm &= 0xc000000000000000LL;
   cfm |= rseslots;
 
   cfm &= 0xc000000000000000LL;
   cfm |= rseslots;
-  write_register (IA64_CFM_REGNUM, cfm);
+  regcache_cooked_write_unsigned (regcache, IA64_CFM_REGNUM, cfm);
   
   /* We will attempt to find function descriptors in the .opd segment,
      but if we can't we'll construct them ourselves.  That being the
   
   /* We will attempt to find function descriptors in the .opd segment,
      but if we can't we'll construct them ourselves.  That being the
@@ -3422,9 +3434,9 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
          && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
        {
          char val_buf[8];
          && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
        {
          char val_buf[8];
-
+         ULONGEST faddr = extract_unsigned_integer (value_contents (arg), 8);
          store_unsigned_integer (val_buf, 8,
          store_unsigned_integer (val_buf, 8,
-                                 find_func_descr (extract_unsigned_integer (value_contents (arg), 8),
+                                 find_func_descr (regcache, faddr,
                                                   &funcdescaddr));
          if (slotnum < rseslots)
            write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
                                                   &funcdescaddr));
          if (slotnum < rseslots)
            write_memory (rse_address_add (bsp, slotnum), val_buf, 8);
@@ -3486,11 +3498,11 @@ ia64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   global_pointer = ia64_find_global_pointer (func_addr);
 
   if (global_pointer != 0)
   global_pointer = ia64_find_global_pointer (func_addr);
 
   if (global_pointer != 0)
-    write_register (IA64_GR1_REGNUM, global_pointer);
+    regcache_cooked_write_unsigned (regcache, IA64_GR1_REGNUM, global_pointer);
 
 
-  write_register (IA64_BR0_REGNUM, bp_addr);
+  regcache_cooked_write_unsigned (regcache, IA64_BR0_REGNUM, bp_addr);
 
 
-  write_register (sp_regnum, sp);
+  regcache_cooked_write_unsigned (regcache, sp_regnum, sp);
 
   return sp;
 }
 
   return sp;
 }
@@ -3531,21 +3543,6 @@ ia64_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
   return pc;
 }
 
   return pc;
 }
 
-static void
-ia64_store_return_value (struct type *type, struct regcache *regcache, 
-                       const gdb_byte *valbuf)
-{
-  if (TYPE_CODE (type) == TYPE_CODE_FLT)
-    {
-      char to[MAX_REGISTER_SIZE];
-      convert_typed_floating (valbuf, type, to, builtin_type_ia64_ext);
-      regcache_cooked_write (regcache, IA64_FR8_REGNUM, (void *)to);
-      target_store_registers (regcache, IA64_FR8_REGNUM);
-    }
-  else
-    regcache_cooked_write (regcache, IA64_GR8_REGNUM, valbuf);
-}
-
 static int
 ia64_print_insn (bfd_vma memaddr, struct disassemble_info *info)
 {
 static int
 ia64_print_insn (bfd_vma memaddr, struct disassemble_info *info)
 {
@@ -3570,12 +3567,6 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   tdep->sigcontext_register_address = 0;
   tdep->pc_in_sigtramp = 0;
 
   tdep->sigcontext_register_address = 0;
   tdep->pc_in_sigtramp = 0;
 
-  /* Define the ia64 floating-point format to gdb.  */
-  builtin_type_ia64_ext =
-    init_type (TYPE_CODE_FLT, 128 / 8,
-               0, "builtin_type_ia64_ext", NULL);
-  TYPE_FLOATFORMAT (builtin_type_ia64_ext) = floatformats_ia64_ext;
-
   /* According to the ia64 specs, instructions that store long double
      floats in memory use a long-double format different than that
      used in the floating registers.  The memory format matches the
   /* According to the ia64 specs, instructions that store long double
      floats in memory use a long-double format different than that
      used in the floating registers.  The memory format matches the
@@ -3601,9 +3592,6 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_fp0_regnum (gdbarch, IA64_FR0_REGNUM);
 
   set_gdbarch_register_name (gdbarch, ia64_register_name);
   set_gdbarch_fp0_regnum (gdbarch, IA64_FR0_REGNUM);
 
   set_gdbarch_register_name (gdbarch, ia64_register_name);
-  /* FIXME:  Following interface should not be needed, however, without it recurse.exp
-     gets a number of extra failures.  */
-  set_gdbarch_deprecated_register_size (gdbarch, 8);
   set_gdbarch_register_type (gdbarch, ia64_register_type);
 
   set_gdbarch_pseudo_register_read (gdbarch, ia64_pseudo_register_read);
   set_gdbarch_register_type (gdbarch, ia64_register_type);
 
   set_gdbarch_pseudo_register_read (gdbarch, ia64_pseudo_register_read);
@@ -3616,11 +3604,7 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
   set_gdbarch_skip_prologue (gdbarch, ia64_skip_prologue);
 
 
   set_gdbarch_skip_prologue (gdbarch, ia64_skip_prologue);
 
-  set_gdbarch_deprecated_use_struct_convention (gdbarch, ia64_use_struct_convention);
-  set_gdbarch_extract_return_value (gdbarch, ia64_extract_return_value);
-
-  set_gdbarch_store_return_value (gdbarch, ia64_store_return_value);
-  set_gdbarch_deprecated_extract_struct_value_address (gdbarch, ia64_extract_struct_value_address);
+  set_gdbarch_return_value (gdbarch, ia64_return_value);
 
   set_gdbarch_memory_insert_breakpoint (gdbarch, ia64_memory_insert_breakpoint);
   set_gdbarch_memory_remove_breakpoint (gdbarch, ia64_memory_remove_breakpoint);
 
   set_gdbarch_memory_insert_breakpoint (gdbarch, ia64_memory_insert_breakpoint);
   set_gdbarch_memory_remove_breakpoint (gdbarch, ia64_memory_remove_breakpoint);
@@ -3665,5 +3649,11 @@ extern initialize_file_ftype _initialize_ia64_tdep; /* -Wmissing-prototypes */
 void
 _initialize_ia64_tdep (void)
 {
 void
 _initialize_ia64_tdep (void)
 {
+  /* Define the ia64 floating-point format to gdb.  */
+  builtin_type_ia64_ext =
+    init_type (TYPE_CODE_FLT, 128 / 8,
+               0, "builtin_type_ia64_ext", NULL);
+  TYPE_FLOATFORMAT (builtin_type_ia64_ext) = floatformats_ia64_ext;
+
   gdbarch_register (bfd_arch_ia64, ia64_gdbarch_init, NULL);
 }
   gdbarch_register (bfd_arch_ia64, ia64_gdbarch_init, NULL);
 }
GDB Binutils - Deliverables
This page took 0.039309 seconds and 4 git commands to generate.