2003-09-25 Andrew Cagney <cagney@redhat.com>

	* frame.h (deprecated_frame_saved_regs): Rename
	get_frame_saved_regs.
	* cris-tdep.c, frame.c, h8300-tdep.c, hppa-tdep.c: Update.
	* mcore-tdep.c, mips-tdep.c, mn10300-tdep.c: Update.
	* ns32k-tdep.c, ppc-linux-tdep.c, rs6000-tdep.c: Update.
	* s390-tdep.c, sh64-tdep.c, stack.c: Update.
	* v850-tdep.c, vax-tdep.c, xstormy16-tdep.c: Update.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 1ff07dc29832859d028bd33d648de2eeee0c0efc..ba2dceae8f3641435b6d117012eb2eee5cc44a5c 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,13 @@
+2003-09-25  Andrew Cagney  <cagney@redhat.com>
+
+       * frame.h (deprecated_frame_saved_regs): Rename
+       get_frame_saved_regs.
+       * cris-tdep.c, frame.c, h8300-tdep.c, hppa-tdep.c: Update.
+       * mcore-tdep.c, mips-tdep.c, mn10300-tdep.c: Update.
+       * ns32k-tdep.c, ppc-linux-tdep.c, rs6000-tdep.c: Update.
+       * s390-tdep.c, sh64-tdep.c, stack.c: Update.
+       * v850-tdep.c, vax-tdep.c, xstormy16-tdep.c: Update.
+
 2003-09-25  Andrew Cagney  <cagney@redhat.com>
 
        * NEWS: Mention the new backtrace mechanism, DWARF 2 CFI, hosted

diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c
index 89f54cf2ea308cda19d5f54b6e7b8e8fdf51f058..a3cfe6019820e7faefb212f2f668531377d56528 100644 (file)
--- a/gdb/cris-tdep.c
+++ b/gdb/cris-tdep.c
@@ -501,10 +501,10 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
 
   /* We only want to know the end of the prologue when fi->saved_regs == 0.
      When the saved registers are allocated full information is required.  */
-  if (get_frame_saved_regs (fi))
+  if (deprecated_get_frame_saved_regs (fi))
     {
       for (regno = 0; regno < NUM_REGS; regno++)
-        get_frame_saved_regs (fi)[regno] = 0;
+        deprecated_get_frame_saved_regs (fi)[regno] = 0;
     }
  
   /* Find the prologue instructions.  */
@@ -676,34 +676,34 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
 
   /* We only want to know the end of the prologue when
      fi->saved_regs == 0.  */ 
-  if (!get_frame_saved_regs (fi))
+  if (!deprecated_get_frame_saved_regs (fi))
     return ip;
 
   if (have_fp)
     {
-      get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] = get_frame_base (fi);
+      deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] = get_frame_base (fi);
       
       /* Calculate the addresses.  */
       for (regno = regsave; regno >= 0; regno--)
         {
-          get_frame_saved_regs (fi)[regno] = get_frame_base (fi) - val;
+          deprecated_get_frame_saved_regs (fi)[regno] = get_frame_base (fi) - val;
           val -= 4;
         }
       if (get_frame_extra_info (fi)->leaf_function)
         {
           /* Set the register SP to contain the stack pointer of 
              the caller.  */
-          get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 4;
+          deprecated_get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 4;
         }
       else
         {
           /* Set the register SP to contain the stack pointer of 
              the caller.  */
-          get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 8;
+          deprecated_get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 8;
       
           /* Set the register SRP to contain the return address of 
              the caller.  */
-          get_frame_saved_regs (fi)[SRP_REGNUM] = get_frame_base (fi) + 4;
+          deprecated_get_frame_saved_regs (fi)[SRP_REGNUM] = get_frame_base (fi) + 4;
         }
     }
   return ip;
@@ -1151,7 +1151,7 @@ cris_frame_init_saved_regs (struct frame_info *fi)
   int frameless_p = 0; 
 
   /* Has this frame's registers already been initialized?  */
-  if (get_frame_saved_regs (fi))
+  if (deprecated_get_frame_saved_regs (fi))
     return;
 
   frame_saved_regs_zalloc (fi);
@@ -1161,7 +1161,7 @@ cris_frame_init_saved_regs (struct frame_info *fi)
       /* I don't see this ever happening, considering the context in which
          cris_frame_init_saved_regs is called (always when we're not in
          a dummy frame).  */
-      memcpy (get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);
+      memcpy (deprecated_get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);
     }
   else
     {    
@@ -1219,11 +1219,11 @@ cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 
       /* Check fromleaf/frameless_function_invocation.  (FIXME)  */
 
-      if (get_frame_saved_regs (fi)[SRP_REGNUM] != 0)
+      if (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM] != 0)
         {
           /* SRP was saved on the stack; non-leaf function.  */
           get_frame_extra_info (fi)->return_pc =
-            read_memory_integer (get_frame_saved_regs (fi)[SRP_REGNUM], 
+            read_memory_integer (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM], 
                                  REGISTER_RAW_SIZE (SRP_REGNUM));
         }
       else
@@ -1527,30 +1527,30 @@ cris_pop_frame (void)
          after SP was saved.  */
       for (regno = 0; regno < DEPRECATED_FP_REGNUM; regno++)
         {
-          if (get_frame_saved_regs (fi)[regno])
+          if (deprecated_get_frame_saved_regs (fi)[regno])
             {
               write_register (regno, 
-                              read_memory_integer (get_frame_saved_regs (fi)[regno], 4));
+                              read_memory_integer (deprecated_get_frame_saved_regs (fi)[regno], 4));
             }
         }
      
-      if (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM])
+      if (deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM])
         {
           /* Pop the frame pointer (R8).  It was pushed before SP 
              was saved.  */
           write_register (DEPRECATED_FP_REGNUM, 
-                          read_memory_integer (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4));
+                          read_memory_integer (deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4));
           stack_offset += 4;
 
           /* Not a leaf function.  */
-          if (get_frame_saved_regs (fi)[SRP_REGNUM])
+          if (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM])
             {     
               /* SRP was pushed before SP was saved.  */
               stack_offset += 4;
             }
       
           /* Restore the SP and adjust for R8 and (possibly) SRP.  */
-          write_register (SP_REGNUM, get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] + stack_offset);
+          write_register (SP_REGNUM, deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] + stack_offset);
         } 
       else
         {

diff --git a/gdb/frame.c b/gdb/frame.c
index 4e88018247ff1c814adbcfaa9ebad92a0099f635..46949c0af3a7d2206113c8122019a59166075417 100644 (file)
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -844,7 +844,7 @@ frame_saved_regs_zalloc (struct frame_info *fi)
 }
 
 CORE_ADDR *
-get_frame_saved_regs (struct frame_info *fi)
+deprecated_get_frame_saved_regs (struct frame_info *fi)
 {
   return fi->saved_regs;
 }
@@ -986,16 +986,16 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame,
   struct frame_info *frame = next_frame->prev;
   gdb_assert (frame != NULL);
 
-  if (get_frame_saved_regs (frame) == NULL)
+  if (deprecated_get_frame_saved_regs (frame) == NULL)
     {
       /* If nothing's initialized the saved regs, do it now.  */
       gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
       DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
-      gdb_assert (get_frame_saved_regs (frame) != NULL);
+      gdb_assert (deprecated_get_frame_saved_regs (frame) != NULL);
     }
 
-  if (get_frame_saved_regs (frame) != NULL
-      && get_frame_saved_regs (frame)[regnum] != 0)
+  if (deprecated_get_frame_saved_regs (frame) != NULL
+      && deprecated_get_frame_saved_regs (frame)[regnum] != 0)
     {
       if (regnum == SP_REGNUM)
        {
@@ -1008,7 +1008,7 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame,
            /* NOTE: cagney/2003-05-09: In-lined store_address with
                it's body - store_unsigned_integer.  */
            store_unsigned_integer (bufferp, REGISTER_RAW_SIZE (regnum),
-                                   get_frame_saved_regs (frame)[regnum]);
+                                   deprecated_get_frame_saved_regs (frame)[regnum]);
        }
       else
        {
@@ -1016,7 +1016,7 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame,
              a local copy of its value.  */
          *optimizedp = 0;
          *lvalp = lval_memory;
-         *addrp = get_frame_saved_regs (frame)[regnum];
+         *addrp = deprecated_get_frame_saved_regs (frame)[regnum];
          *realnump = -1;
          if (bufferp != NULL)
            {
@@ -1035,13 +1035,13 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame,
                {
                  regs[regnum]
                    = frame_obstack_zalloc (REGISTER_RAW_SIZE (regnum));
-                 read_memory (get_frame_saved_regs (frame)[regnum], regs[regnum],
+                 read_memory (deprecated_get_frame_saved_regs (frame)[regnum], regs[regnum],
                               REGISTER_RAW_SIZE (regnum));
                }
              memcpy (bufferp, regs[regnum], REGISTER_RAW_SIZE (regnum));
 #else
              /* Read the value in from memory.  */
-             read_memory (get_frame_saved_regs (frame)[regnum], bufferp,
+             read_memory (deprecated_get_frame_saved_regs (frame)[regnum], bufferp,
                           REGISTER_RAW_SIZE (regnum));
 #endif
            }
@@ -1139,8 +1139,8 @@ deprecated_generic_get_saved_register (char *raw_buffer, int *optimized,
            }
 
          DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
-         if (get_frame_saved_regs (frame) != NULL
-             && get_frame_saved_regs (frame)[regnum] != 0)
+         if (deprecated_get_frame_saved_regs (frame) != NULL
+             && deprecated_get_frame_saved_regs (frame)[regnum] != 0)
            {
              if (lval)         /* found it saved on the stack */
                *lval = lval_memory;
@@ -1151,14 +1151,14 @@ deprecated_generic_get_saved_register (char *raw_buffer, int *optimized,
                        with it's body - store_unsigned_integer.  */
                    store_unsigned_integer (raw_buffer,
                                            REGISTER_RAW_SIZE (regnum),
-                                           get_frame_saved_regs (frame)[regnum]);
+                                           deprecated_get_frame_saved_regs (frame)[regnum]);
                }
              else
                {
                  if (addrp)    /* any other register */
-                   *addrp = get_frame_saved_regs (frame)[regnum];
+                   *addrp = deprecated_get_frame_saved_regs (frame)[regnum];
                  if (raw_buffer)
-                   read_memory (get_frame_saved_regs (frame)[regnum], raw_buffer,
+                   read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer,
                                 REGISTER_RAW_SIZE (regnum));
                }
              return;

diff --git a/gdb/frame.h b/gdb/frame.h
index afbde74c8a76168f898be52212f17a73efd15488..579dbdbd91ea7d93ae84eb6cf28c165120054330 100644 (file)
--- a/gdb/frame.h
+++ b/gdb/frame.h
@@ -671,7 +671,7 @@ extern struct frame_extra_info *get_frame_extra_info (struct frame_info *fi);
    SP_REGNUM where the value of the register in the previous frame is
    stored).  */
 extern CORE_ADDR *frame_saved_regs_zalloc (struct frame_info *);
-extern CORE_ADDR *get_frame_saved_regs (struct frame_info *);
+extern CORE_ADDR *deprecated_get_frame_saved_regs (struct frame_info *);
 
 /* FIXME: cagney/2002-12-06: Has the PC in the current frame changed?
    "infrun.c", Thanks to DECR_PC_AFTER_BREAK, can change the PC after

diff --git a/gdb/h8300-tdep.c b/gdb/h8300-tdep.c
index 77faad304824a5710c33ab802bfb7c4316325086..09fb6a169c1453951865c88081e01a324fb75dfa 100644 (file)
--- a/gdb/h8300-tdep.c
+++ b/gdb/h8300-tdep.c
@@ -478,7 +478,7 @@ h8300_frame_init_saved_regs (struct frame_info *fi)
 {
   CORE_ADDR func_addr, func_end;
 
-  if (!get_frame_saved_regs (fi))
+  if (!deprecated_get_frame_saved_regs (fi))
     {
       frame_saved_regs_zalloc (fi);
 
@@ -492,7 +492,7 @@ h8300_frame_init_saved_regs (struct frame_info *fi)
            ? sal.end : get_frame_pc (fi);
          /* This will fill in fields in fi. */
          h8300_examine_prologue (func_addr, limit, get_frame_base (fi),
-                                 get_frame_saved_regs (fi), fi);
+                                 deprecated_get_frame_saved_regs (fi), fi);
        }
       /* Else we're out of luck (can't debug completely stripped code). 
         FIXME. */
@@ -521,7 +521,7 @@ h8300_frame_chain (struct frame_info *thisframe)
                                        E_PC_REGNUM);
       return get_frame_base (thisframe);
     }
-  return get_frame_saved_regs (thisframe)[E_SP_REGNUM];
+  return deprecated_get_frame_saved_regs (thisframe)[E_SP_REGNUM];
 }
 
 /* Return the saved PC from this frame.
@@ -743,11 +743,11 @@ h8300_pop_frame (void)
        {
          /* Don't forget E_SP_REGNUM is a frame_saved_regs struct is the
             actual value we want, not the address of the value we want.  */
-         if (get_frame_saved_regs (frame)[regno] && regno != E_SP_REGNUM)
+         if (deprecated_get_frame_saved_regs (frame)[regno] && regno != E_SP_REGNUM)
            write_register (regno,
                            read_memory_integer 
-                           (get_frame_saved_regs (frame)[regno], BINWORD));
-         else if (get_frame_saved_regs (frame)[regno] && regno == E_SP_REGNUM)
+                           (deprecated_get_frame_saved_regs (frame)[regno], BINWORD));
+         else if (deprecated_get_frame_saved_regs (frame)[regno] && regno == E_SP_REGNUM)
            write_register (regno, get_frame_base (frame) + 2 * BINWORD);
        }
 

diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index 0670807493a3ccb4f8230a2ab177676f287c4bf2..9017971c07d0b0502fddb710fa45284aa2daf88a 100644 (file)
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -1090,7 +1090,7 @@ hppa_frame_saved_pc (struct frame_info *frame)
        {
          CORE_ADDR *saved_regs;
          hppa_frame_init_saved_regs (get_next_frame (frame));
-         saved_regs = get_frame_saved_regs (get_next_frame (frame));
+         saved_regs = deprecated_get_frame_saved_regs (get_next_frame (frame));
          if (read_memory_integer (saved_regs[FLAGS_REGNUM],
                                   TARGET_PTR_BIT / 8) & 0x2)
            {
@@ -1130,7 +1130,7 @@ hppa_frame_saved_pc (struct frame_info *frame)
        {
          CORE_ADDR *saved_regs;
          hppa_frame_init_saved_regs (get_next_frame (frame));
-         saved_regs = get_frame_saved_regs (get_next_frame (frame));
+         saved_regs = deprecated_get_frame_saved_regs (get_next_frame (frame));
          if (read_memory_integer (saved_regs[FLAGS_REGNUM],
                                   TARGET_PTR_BIT / 8) & 0x2)
            {
@@ -1404,7 +1404,7 @@ hppa_frame_chain (struct frame_info *frame)
             in optimized code, GCC often doesn't actually save r3.
             We'll discover this if we look at the prologue.  */
          hppa_frame_init_saved_regs (tmp_frame);
-         saved_regs = get_frame_saved_regs (tmp_frame);
+         saved_regs = deprecated_get_frame_saved_regs (tmp_frame);
          saved_regs_frame = tmp_frame;
 
          /* If we have an address for r3, that's good.  */
@@ -1455,7 +1455,7 @@ hppa_frame_chain (struct frame_info *frame)
          if (tmp_frame != saved_regs_frame)
            {
              hppa_frame_init_saved_regs (tmp_frame);
-             saved_regs = get_frame_saved_regs (tmp_frame);
+             saved_regs = deprecated_get_frame_saved_regs (tmp_frame);
            }
 
          /* Abominable hack.  */
@@ -1493,7 +1493,7 @@ hppa_frame_chain (struct frame_info *frame)
       if (tmp_frame != saved_regs_frame)
        {
          hppa_frame_init_saved_regs (tmp_frame);
-         saved_regs = get_frame_saved_regs (tmp_frame);
+         saved_regs = deprecated_get_frame_saved_regs (tmp_frame);
        }
 
       /* Abominable hack.  See above.  */
@@ -1698,7 +1698,7 @@ hppa_pop_frame (void)
 
   fp = get_frame_base (frame);
   hppa_frame_init_saved_regs (frame);
-  fsr = get_frame_saved_regs (frame);
+  fsr = deprecated_get_frame_saved_regs (frame);
 
 #ifndef NO_PC_SPACE_QUEUE_RESTORE
   if (fsr[IPSW_REGNUM])        /* Restoring a call dummy frame */
@@ -4248,9 +4248,9 @@ hppa_frame_find_saved_regs (struct frame_info *frame_info,
 void
 hppa_frame_init_saved_regs (struct frame_info *frame)
 {
-  if (get_frame_saved_regs (frame) == NULL)
+  if (deprecated_get_frame_saved_regs (frame) == NULL)
     frame_saved_regs_zalloc (frame);
-  hppa_frame_find_saved_regs (frame, get_frame_saved_regs (frame));
+  hppa_frame_find_saved_regs (frame, deprecated_get_frame_saved_regs (frame));
 }
 
 /* Exception handling support for the HP-UX ANSI C++ compiler.

diff --git a/gdb/mcore-tdep.c b/gdb/mcore-tdep.c
index 342d5a3dd4af5b3463eaad77d70baae53001d55b..330901395cfc05e5e44acbdda0607b182f0cdcd4 100644 (file)
--- a/gdb/mcore-tdep.c
+++ b/gdb/mcore-tdep.c
@@ -265,7 +265,7 @@ analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
   deprecated_update_frame_base_hack (dummy, frame);
   get_frame_extra_info (dummy)->status = 0;
   get_frame_extra_info (dummy)->framesize = 0;
-  memset (get_frame_saved_regs (dummy), '\000', SIZEOF_FRAME_SAVED_REGS);
+  memset (deprecated_get_frame_saved_regs (dummy), '\000', SIZEOF_FRAME_SAVED_REGS);
   mcore_analyze_prologue (dummy, 0, 0);
   return dummy;
 }
@@ -590,7 +590,7 @@ mcore_analyze_prologue (struct frame_info *fi, CORE_ADDR pc, int skip_prologue)
        {
          if (register_offsets[rn] >= 0)
            {
-             get_frame_saved_regs (fi)[rn] = get_frame_base (fi) - register_offsets[rn];
+             deprecated_get_frame_saved_regs (fi)[rn] = get_frame_base (fi) - register_offsets[rn];
              mcore_insn_debug (("Saved register %s stored at 0x%08x, value=0x%08x\n",
                               mcore_register_names[rn], fi->saved_regs[rn],
                              read_memory_integer (fi->saved_regs[rn], 4)));
@@ -639,11 +639,11 @@ mcore_frame_chain (struct frame_info * fi)
       int fp = get_frame_extra_info (dummy)->fp_regnum;
 
       /* Our caller has a frame pointer. */
-      if (get_frame_saved_regs (fi)[fp] != 0)
+      if (deprecated_get_frame_saved_regs (fi)[fp] != 0)
        {
          /* The "FP" was saved on the stack.  Don't forget to adjust
             the "FP" with the framesize to get a real FP. */
-         callers_addr = read_memory_integer (get_frame_saved_regs (fi)[fp],
+         callers_addr = read_memory_integer (deprecated_get_frame_saved_regs (fi)[fp],
                                              DEPRECATED_REGISTER_SIZE)
            + get_frame_extra_info (dummy)->framesize;
        }
@@ -726,8 +726,8 @@ mcore_find_callers_reg (struct frame_info *fi, int regnum)
                                       get_frame_base (fi)))
        return deprecated_read_register_dummy (get_frame_pc (fi),
                                               get_frame_base (fi), regnum);
-      else if (get_frame_saved_regs (fi)[regnum] != 0)
-       return read_memory_integer (get_frame_saved_regs (fi)[regnum],
+      else if (deprecated_get_frame_saved_regs (fi)[regnum] != 0)
+       return read_memory_integer (deprecated_get_frame_saved_regs (fi)[regnum],
                                    DEPRECATED_REGISTER_SIZE);
     }
 
@@ -770,11 +770,11 @@ mcore_pop_frame (void)
       /* Restore any saved registers. */
       for (rn = 0; rn < NUM_REGS; rn++)
        {
-         if (get_frame_saved_regs (fi)[rn] != 0)
+         if (deprecated_get_frame_saved_regs (fi)[rn] != 0)
            {
              ULONGEST value;
 
-             value = read_memory_unsigned_integer (get_frame_saved_regs (fi)[rn],
+             value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[rn],
                                                    DEPRECATED_REGISTER_SIZE);
              write_register (rn, value);
            }

diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
index 027cf44562cc8e93bbff598b31958c9d19eed559..fc38b58a241b23d58345ccd6ea375a8b58353da0 100644 (file)
--- a/gdb/mips-tdep.c
+++ b/gdb/mips-tdep.c
@@ -1570,7 +1570,7 @@ mips_find_saved_regs (struct frame_info *fci)
   t_inst inst;
   CORE_ADDR *saved_regs;
 
-  if (get_frame_saved_regs (fci) != NULL)
+  if (deprecated_get_frame_saved_regs (fci) != NULL)
     return;
   saved_regs = frame_saved_regs_zalloc (fci);
 
@@ -2733,7 +2733,7 @@ mips_init_extra_frame_info (int fromleaf, struct frame_info *fci)
                              get_frame_base (fci));
              set_reg_offset (temp_saved_regs, PC_REGNUM,
                              temp_saved_regs[RA_REGNUM]);
-             memcpy (get_frame_saved_regs (fci), temp_saved_regs,
+             memcpy (deprecated_get_frame_saved_regs (fci), temp_saved_regs,
                      SIZEOF_FRAME_SAVED_REGS);
            }
        }
@@ -3957,18 +3957,18 @@ mips_pop_frame (void)
   mips_find_saved_regs (frame);
   for (regnum = 0; regnum < NUM_REGS; regnum++)
     if (regnum != SP_REGNUM && regnum != PC_REGNUM
-       && get_frame_saved_regs (frame)[regnum])
+       && deprecated_get_frame_saved_regs (frame)[regnum])
       {
        /* Floating point registers must not be sign extended, 
           in case MIPS_SAVED_REGSIZE = 4 but sizeof (FP0_REGNUM) == 8.  */
 
        if (FP0_REGNUM <= regnum && regnum < FP0_REGNUM + 32)
          write_register (regnum,
-                         read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
+                         read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
                                                        MIPS_SAVED_REGSIZE));
        else
          write_register (regnum,
-                         read_memory_integer (get_frame_saved_regs (frame)[regnum],
+                         read_memory_integer (deprecated_get_frame_saved_regs (frame)[regnum],
                                               MIPS_SAVED_REGSIZE));
       }
 

diff --git a/gdb/mn10300-tdep.c b/gdb/mn10300-tdep.c
index d6011c22ffa7a3a09c03e4160aa9a93eec8d1bac..1820b1dd2e779803997666189eaeeef474577c87 100644 (file)
--- a/gdb/mn10300-tdep.c
+++ b/gdb/mn10300-tdep.c
@@ -169,7 +169,7 @@ analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
   deprecated_update_frame_base_hack (dummy, frame);
   get_frame_extra_info (dummy)->status = 0;
   get_frame_extra_info (dummy)->stack_size = 0;
-  memset (get_frame_saved_regs (dummy), '\000', SIZEOF_FRAME_SAVED_REGS);
+  memset (deprecated_get_frame_saved_regs (dummy), '\000', SIZEOF_FRAME_SAVED_REGS);
   mn10300_analyze_prologue (dummy, pc);
   return dummy;
 }
@@ -237,59 +237,59 @@ set_movm_offsets (struct frame_info *fi, int movm_args)
       /* The `other' bit leaves a blank area of four bytes at the
          beginning of its block of saved registers, making it 32 bytes
          long in total.  */
-      get_frame_saved_regs (fi)[LAR_REGNUM]    = get_frame_base (fi) + offset + 4;
-      get_frame_saved_regs (fi)[LIR_REGNUM]    = get_frame_base (fi) + offset + 8;
-      get_frame_saved_regs (fi)[MDR_REGNUM]    = get_frame_base (fi) + offset + 12;
-      get_frame_saved_regs (fi)[A0_REGNUM + 1] = get_frame_base (fi) + offset + 16;
-      get_frame_saved_regs (fi)[A0_REGNUM]     = get_frame_base (fi) + offset + 20;
-      get_frame_saved_regs (fi)[D0_REGNUM + 1] = get_frame_base (fi) + offset + 24;
-      get_frame_saved_regs (fi)[D0_REGNUM]     = get_frame_base (fi) + offset + 28;
+      deprecated_get_frame_saved_regs (fi)[LAR_REGNUM]    = get_frame_base (fi) + offset + 4;
+      deprecated_get_frame_saved_regs (fi)[LIR_REGNUM]    = get_frame_base (fi) + offset + 8;
+      deprecated_get_frame_saved_regs (fi)[MDR_REGNUM]    = get_frame_base (fi) + offset + 12;
+      deprecated_get_frame_saved_regs (fi)[A0_REGNUM + 1] = get_frame_base (fi) + offset + 16;
+      deprecated_get_frame_saved_regs (fi)[A0_REGNUM]     = get_frame_base (fi) + offset + 20;
+      deprecated_get_frame_saved_regs (fi)[D0_REGNUM + 1] = get_frame_base (fi) + offset + 24;
+      deprecated_get_frame_saved_regs (fi)[D0_REGNUM]     = get_frame_base (fi) + offset + 28;
       offset += 32;
     }
   if (movm_args & movm_a3_bit)
     {
-      get_frame_saved_regs (fi)[A3_REGNUM] = get_frame_base (fi) + offset;
+      deprecated_get_frame_saved_regs (fi)[A3_REGNUM] = get_frame_base (fi) + offset;
       offset += 4;
     }
   if (movm_args & movm_a2_bit)
     {
-      get_frame_saved_regs (fi)[A2_REGNUM] = get_frame_base (fi) + offset;
+      deprecated_get_frame_saved_regs (fi)[A2_REGNUM] = get_frame_base (fi) + offset;
       offset += 4;
     }
   if (movm_args & movm_d3_bit)
     {
-      get_frame_saved_regs (fi)[D3_REGNUM] = get_frame_base (fi) + offset;
+      deprecated_get_frame_saved_regs (fi)[D3_REGNUM] = get_frame_base (fi) + offset;
       offset += 4;
     }
   if (movm_args & movm_d2_bit)
     {
-      get_frame_saved_regs (fi)[D2_REGNUM] = get_frame_base (fi) + offset;
+      deprecated_get_frame_saved_regs (fi)[D2_REGNUM] = get_frame_base (fi) + offset;
       offset += 4;
     }
   if (AM33_MODE)
     {
       if (movm_args & movm_exother_bit)
         {
-          get_frame_saved_regs (fi)[MCVF_REGNUM]   = get_frame_base (fi) + offset;
-          get_frame_saved_regs (fi)[MCRL_REGNUM]   = get_frame_base (fi) + offset + 4;
-          get_frame_saved_regs (fi)[MCRH_REGNUM]   = get_frame_base (fi) + offset + 8;
-          get_frame_saved_regs (fi)[MDRQ_REGNUM]   = get_frame_base (fi) + offset + 12;
-          get_frame_saved_regs (fi)[E0_REGNUM + 1] = get_frame_base (fi) + offset + 16;
-          get_frame_saved_regs (fi)[E0_REGNUM + 0] = get_frame_base (fi) + offset + 20;
+          deprecated_get_frame_saved_regs (fi)[MCVF_REGNUM]   = get_frame_base (fi) + offset;
+          deprecated_get_frame_saved_regs (fi)[MCRL_REGNUM]   = get_frame_base (fi) + offset + 4;
+          deprecated_get_frame_saved_regs (fi)[MCRH_REGNUM]   = get_frame_base (fi) + offset + 8;
+          deprecated_get_frame_saved_regs (fi)[MDRQ_REGNUM]   = get_frame_base (fi) + offset + 12;
+          deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 1] = get_frame_base (fi) + offset + 16;
+          deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 0] = get_frame_base (fi) + offset + 20;
           offset += 24;
         }
       if (movm_args & movm_exreg1_bit)
         {
-          get_frame_saved_regs (fi)[E0_REGNUM + 7] = get_frame_base (fi) + offset;
-          get_frame_saved_regs (fi)[E0_REGNUM + 6] = get_frame_base (fi) + offset + 4;
-          get_frame_saved_regs (fi)[E0_REGNUM + 5] = get_frame_base (fi) + offset + 8;
-          get_frame_saved_regs (fi)[E0_REGNUM + 4] = get_frame_base (fi) + offset + 12;
+          deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 7] = get_frame_base (fi) + offset;
+          deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 6] = get_frame_base (fi) + offset + 4;
+          deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 5] = get_frame_base (fi) + offset + 8;
+          deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 4] = get_frame_base (fi) + offset + 12;
           offset += 16;
         }
       if (movm_args & movm_exreg0_bit)
         {
-          get_frame_saved_regs (fi)[E0_REGNUM + 3] = get_frame_base (fi) + offset;
-          get_frame_saved_regs (fi)[E0_REGNUM + 2] = get_frame_base (fi) + offset + 4;
+          deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 3] = get_frame_base (fi) + offset;
+          deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 2] = get_frame_base (fi) + offset + 4;
           offset += 8;
         }
     }
@@ -648,14 +648,14 @@ saved_regs_size (struct frame_info *fi)
 
   /* Reserve four bytes for every register saved.  */
   for (i = 0; i < NUM_REGS; i++)
-    if (get_frame_saved_regs (fi)[i])
+    if (deprecated_get_frame_saved_regs (fi)[i])
       adjust += 4;
 
   /* If we saved LIR, then it's most likely we used a `movm'
      instruction with the `other' bit set, in which case the SP is
      decremented by an extra four bytes, "to simplify calculation
      of the transfer area", according to the processor manual.  */
-  if (get_frame_saved_regs (fi)[LIR_REGNUM])
+  if (deprecated_get_frame_saved_regs (fi)[LIR_REGNUM])
     adjust += 4;
 
   return adjust;
@@ -705,8 +705,8 @@ mn10300_frame_chain (struct frame_info *fi)
     {
       /* Our caller has a frame pointer.  So find the frame in $a3 or
          in the stack.  */
-      if (get_frame_saved_regs (fi)[A3_REGNUM])
-       return (read_memory_integer (get_frame_saved_regs (fi)[A3_REGNUM],
+      if (deprecated_get_frame_saved_regs (fi)[A3_REGNUM])
+       return (read_memory_integer (deprecated_get_frame_saved_regs (fi)[A3_REGNUM],
                                     DEPRECATED_REGISTER_SIZE));
       else
        return read_register (A3_REGNUM);
@@ -744,11 +744,11 @@ mn10300_pop_frame_regular (struct frame_info *frame)
 
   /* Restore any saved registers.  */
   for (regnum = 0; regnum < NUM_REGS; regnum++)
-    if (get_frame_saved_regs (frame)[regnum] != 0)
+    if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
       {
         ULONGEST value;
 
-        value = read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
+        value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
                                               REGISTER_RAW_SIZE (regnum));
         write_register (regnum, value);
       }

diff --git a/gdb/ns32k-tdep.c b/gdb/ns32k-tdep.c
index 2485276c5781da78e96c8e7666f2496518f80213..7b4a01c8423e9073803846b8c67ce28a49e9d30e 100644 (file)
--- a/gdb/ns32k-tdep.c
+++ b/gdb/ns32k-tdep.c
@@ -370,7 +370,7 @@ ns32k_frame_init_saved_regs (struct frame_info *frame)
   int localcount;
   CORE_ADDR enter_addr, next_addr;
 
-  if (get_frame_saved_regs (frame))
+  if (deprecated_get_frame_saved_regs (frame))
     return;
 
   frame_saved_regs_zalloc (frame);
@@ -385,18 +385,18 @@ ns32k_frame_init_saved_regs (struct frame_info *frame)
       for (regnum = 0; regnum < 8; regnum++)
        {
           if (regmask & (1 << regnum))
-           get_frame_saved_regs (frame)[regnum] = next_addr -= 4;
+           deprecated_get_frame_saved_regs (frame)[regnum] = next_addr -= 4;
        }
 
-      get_frame_saved_regs (frame)[SP_REGNUM] = get_frame_base (frame) + 4;
-      get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 4;
-      get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = read_memory_integer (get_frame_base (frame), 4);
+      deprecated_get_frame_saved_regs (frame)[SP_REGNUM] = get_frame_base (frame) + 4;
+      deprecated_get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 4;
+      deprecated_get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = read_memory_integer (get_frame_base (frame), 4);
     }
   else if (enter_addr == 1)
     {
       CORE_ADDR sp = read_register (SP_REGNUM);
-      get_frame_saved_regs (frame)[PC_REGNUM] = sp;
-      get_frame_saved_regs (frame)[SP_REGNUM] = sp + 4;
+      deprecated_get_frame_saved_regs (frame)[PC_REGNUM] = sp;
+      deprecated_get_frame_saved_regs (frame)[SP_REGNUM] = sp + 4;
     }
 }
 
@@ -427,9 +427,9 @@ ns32k_pop_frame (void)
   DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
 
   for (regnum = 0; regnum < 8; regnum++)
-    if (get_frame_saved_regs (frame)[regnum])
+    if (deprecated_get_frame_saved_regs (frame)[regnum])
       write_register (regnum,
-                     read_memory_integer (get_frame_saved_regs (frame)[regnum], 4));
+                     read_memory_integer (deprecated_get_frame_saved_regs (frame)[regnum], 4));
 
   write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, 4));
   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));

diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c
index 22ebfd2bb2f1f403561c13130f8f3bb96c088c88..27744f3e12f1156412e0e60aa7d21415b3aa5603 100644 (file)
--- a/gdb/ppc-linux-tdep.c
+++ b/gdb/ppc-linux-tdep.c
@@ -402,7 +402,7 @@ ppc_linux_frame_init_saved_regs (struct frame_info *fi)
     {
       CORE_ADDR regs_addr;
       int i;
-      if (get_frame_saved_regs (fi))
+      if (deprecated_get_frame_saved_regs (fi))
        return;
 
       frame_saved_regs_zalloc (fi);
@@ -410,24 +410,24 @@ ppc_linux_frame_init_saved_regs (struct frame_info *fi)
       regs_addr =
        read_memory_integer (get_frame_base (fi)
                             + PPC_LINUX_REGS_PTR_OFFSET, 4);
-      get_frame_saved_regs (fi)[PC_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_NIP;
-      get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ps_regnum] =
+      deprecated_get_frame_saved_regs (fi)[PC_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_NIP;
+      deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ps_regnum] =
         regs_addr + 4 * PPC_LINUX_PT_MSR;
-      get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_cr_regnum] =
+      deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_cr_regnum] =
         regs_addr + 4 * PPC_LINUX_PT_CCR;
-      get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_lr_regnum] =
+      deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_lr_regnum] =
         regs_addr + 4 * PPC_LINUX_PT_LNK;
-      get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum] =
+      deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum] =
         regs_addr + 4 * PPC_LINUX_PT_CTR;
-      get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_xer_regnum] =
+      deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_xer_regnum] =
         regs_addr + 4 * PPC_LINUX_PT_XER;
-      get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_mq_regnum] =
+      deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_mq_regnum] =
        regs_addr + 4 * PPC_LINUX_PT_MQ;
       for (i = 0; i < 32; i++)
-       get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + i] =
+       deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + i] =
          regs_addr + 4 * PPC_LINUX_PT_R0 + 4 * i;
       for (i = 0; i < 32; i++)
-       get_frame_saved_regs (fi)[FP0_REGNUM + i] = regs_addr + 4 * PPC_LINUX_PT_FPR0 + 8 * i;
+       deprecated_get_frame_saved_regs (fi)[FP0_REGNUM + i] = regs_addr + 4 * PPC_LINUX_PT_FPR0 + 8 * i;
     }
   else
     rs6000_frame_init_saved_regs (fi);

diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c
index 0d663b753c64f0a4bf3bd1ab330e3ad54b45e640..e82aced4cc6a815bb6197021bf949cd30730c34d 100644 (file)
--- a/gdb/rs6000-tdep.c
+++ b/gdb/rs6000-tdep.c
@@ -1628,7 +1628,7 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
   struct gdbarch_tdep * tdep = gdbarch_tdep (current_gdbarch);
   int wordsize = tdep->wordsize;
 
-  if (get_frame_saved_regs (fi))
+  if (deprecated_get_frame_saved_regs (fi))
     return;
 
   if (fdatap == NULL)
@@ -1670,7 +1670,7 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
       CORE_ADDR fpr_addr = frame_addr + fdatap->fpr_offset;
       for (i = fdatap->saved_fpr; i < 32; i++)
        {
-         get_frame_saved_regs (fi)[FP0_REGNUM + i] = fpr_addr;
+         deprecated_get_frame_saved_regs (fi)[FP0_REGNUM + i] = fpr_addr;
          fpr_addr += 8;
        }
     }
@@ -1684,7 +1684,7 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
       CORE_ADDR gpr_addr = frame_addr + fdatap->gpr_offset;
       for (i = fdatap->saved_gpr; i < 32; i++)
        {
-         get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = gpr_addr;
+         deprecated_get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = gpr_addr;
          gpr_addr += wordsize;
        }
     }
@@ -1699,7 +1699,7 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
          CORE_ADDR vr_addr = frame_addr + fdatap->vr_offset;
          for (i = fdatap->saved_vr; i < 32; i++)
            {
-             get_frame_saved_regs (fi)[tdep->ppc_vr0_regnum + i] = vr_addr;
+             deprecated_get_frame_saved_regs (fi)[tdep->ppc_vr0_regnum + i] = vr_addr;
              vr_addr += REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
            }
        }
@@ -1715,8 +1715,8 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
          CORE_ADDR ev_addr = frame_addr + fdatap->ev_offset;
          for (i = fdatap->saved_ev; i < 32; i++)
            {
-             get_frame_saved_regs (fi)[tdep->ppc_ev0_regnum + i] = ev_addr;
-              get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = ev_addr + 4;
+             deprecated_get_frame_saved_regs (fi)[tdep->ppc_ev0_regnum + i] = ev_addr;
+              deprecated_get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = ev_addr + 4;
              ev_addr += REGISTER_RAW_SIZE (tdep->ppc_ev0_regnum);
             }
        }
@@ -1725,17 +1725,17 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
   /* If != 0, fdatap->cr_offset is the offset from the frame that holds
      the CR.  */
   if (fdatap->cr_offset != 0)
-    get_frame_saved_regs (fi)[tdep->ppc_cr_regnum] = frame_addr + fdatap->cr_offset;
+    deprecated_get_frame_saved_regs (fi)[tdep->ppc_cr_regnum] = frame_addr + fdatap->cr_offset;
 
   /* If != 0, fdatap->lr_offset is the offset from the frame that holds
      the LR.  */
   if (fdatap->lr_offset != 0)
-    get_frame_saved_regs (fi)[tdep->ppc_lr_regnum] = frame_addr + fdatap->lr_offset;
+    deprecated_get_frame_saved_regs (fi)[tdep->ppc_lr_regnum] = frame_addr + fdatap->lr_offset;
 
   /* If != 0, fdatap->vrsave_offset is the offset from the frame that holds
      the VRSAVE.  */
   if (fdatap->vrsave_offset != 0)
-    get_frame_saved_regs (fi)[tdep->ppc_vrsave_regnum] = frame_addr + fdatap->vrsave_offset;
+    deprecated_get_frame_saved_regs (fi)[tdep->ppc_vrsave_regnum] = frame_addr + fdatap->vrsave_offset;
 }
 
 /* Return the address of a frame. This is the inital %sp value when the frame
@@ -1762,7 +1762,7 @@ frame_initial_stack_address (struct frame_info *fi)
   /* If saved registers of this frame are not known yet, read and
      cache them.  */
 
-  if (!get_frame_saved_regs (fi))
+  if (!deprecated_get_frame_saved_regs (fi))
     frame_get_saved_regs (fi, &fdata);
 
   /* If no alloca register used, then fi->frame is the value of the %sp for

diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
index e4921eba41dccbd0c20f129047cf8f3d055da05a..eb267c6774af4ee094651dc770092adedafbf687 100644 (file)
--- a/gdb/s390-tdep.c
+++ b/gdb/s390-tdep.c
@@ -901,7 +901,7 @@ s390_get_signal_frame_info (struct frame_info *fi)
       && get_frame_extra_info (next_frame)->sigcontext)
     {
       /* We're definitely backtracing from a signal handler.  */
-      CORE_ADDR *saved_regs = get_frame_saved_regs (fi);
+      CORE_ADDR *saved_regs = deprecated_get_frame_saved_regs (fi);
       CORE_ADDR save_reg_addr = (get_frame_extra_info (next_frame)->sigcontext
                                  + DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM));
       int reg;
@@ -1428,12 +1428,12 @@ s390_get_frame_info (CORE_ADDR start_pc,
        - the analysis gave us enough information to actually figure it
          out.  */
     if (fi
-        && get_frame_saved_regs (fi)
+        && deprecated_get_frame_saved_regs (fi)
         && original_sp != -1)
       {
         int slot_num;
         CORE_ADDR slot_addr;
-        CORE_ADDR *saved_regs = get_frame_saved_regs (fi);
+        CORE_ADDR *saved_regs = deprecated_get_frame_saved_regs (fi);
 
         /* Scan the spill array; if a spill slot says it holds the
            original value of some register, then record that slot's
@@ -1719,7 +1719,7 @@ s390_frame_init_saved_regs (struct frame_info *fi)
 
   int quick;
 
-  if (get_frame_saved_regs (fi) == NULL)
+  if (deprecated_get_frame_saved_regs (fi) == NULL)
     {
       /* zalloc memsets the saved regs */
       frame_saved_regs_zalloc (fi);
@@ -1754,10 +1754,10 @@ s390_frame_saved_pc_nofix (struct frame_info *fi)
     {
       get_frame_extra_info (fi)->saved_pc_valid = 1;
       if (get_frame_extra_info (fi)->good_prologue
-          && get_frame_saved_regs (fi)[S390_RETADDR_REGNUM])
+          && deprecated_get_frame_saved_regs (fi)[S390_RETADDR_REGNUM])
         get_frame_extra_info (fi)->saved_pc
           = ADDR_BITS_REMOVE (read_memory_integer
-                              (get_frame_saved_regs (fi)[S390_RETADDR_REGNUM],
+                              (deprecated_get_frame_saved_regs (fi)[S390_RETADDR_REGNUM],
                                S390_GPR_SIZE));
       else
         get_frame_extra_info (fi)->saved_pc
@@ -1841,24 +1841,24 @@ s390_frame_chain (struct frame_info *thisframe)
        }
       else
        {
-         if (get_frame_saved_regs (thisframe))
+         if (deprecated_get_frame_saved_regs (thisframe))
            {
              int regno;
 
               if (prev_fextra_info.frame_pointer_saved_pc
-                  && get_frame_saved_regs (thisframe)[S390_FRAME_REGNUM])
+                  && deprecated_get_frame_saved_regs (thisframe)[S390_FRAME_REGNUM])
                 regno = S390_FRAME_REGNUM;
               else
                 regno = S390_SP_REGNUM;
 
-             if (get_frame_saved_regs (thisframe)[regno])
+             if (deprecated_get_frame_saved_regs (thisframe)[regno])
                 {
                   /* The SP's entry of `saved_regs' is special.  */
                   if (regno == S390_SP_REGNUM)
-                    prev_fp = get_frame_saved_regs (thisframe)[regno];
+                    prev_fp = deprecated_get_frame_saved_regs (thisframe)[regno];
                   else
                     prev_fp =
-                      read_memory_integer (get_frame_saved_regs (thisframe)[regno],
+                      read_memory_integer (deprecated_get_frame_saved_regs (thisframe)[regno],
                                            S390_GPR_SIZE);
                 }
            }
@@ -1992,14 +1992,14 @@ s390_pop_frame_regular (struct frame_info *frame)
   write_register (S390_PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
 
   /* Restore any saved registers.  */
-  if (get_frame_saved_regs (frame))
+  if (deprecated_get_frame_saved_regs (frame))
     {
       for (regnum = 0; regnum < NUM_REGS; regnum++)
-        if (get_frame_saved_regs (frame)[regnum] != 0)
+        if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
           {
             ULONGEST value;
             
-            value = read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
+            value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
                                                   REGISTER_RAW_SIZE (regnum));
             write_register (regnum, value);
           }
@@ -2007,7 +2007,7 @@ s390_pop_frame_regular (struct frame_info *frame)
       /* Actually cut back the stack.  Remember that the SP's element of
          saved_regs is the old SP itself, not the address at which it is
          saved.  */
-      write_register (S390_SP_REGNUM, get_frame_saved_regs (frame)[S390_SP_REGNUM]);
+      write_register (S390_SP_REGNUM, deprecated_get_frame_saved_regs (frame)[S390_SP_REGNUM]);
     }
 
   /* Throw away any cached frame information.  */

diff --git a/gdb/sh64-tdep.c b/gdb/sh64-tdep.c
index 99372b8b0326b1523ca5c3559c536b5be45411aa..3ea518cd2450e1624e84f04115a42b17cfe520ce 100644 (file)
--- a/gdb/sh64-tdep.c
+++ b/gdb/sh64-tdep.c
@@ -782,13 +782,13 @@ sh64_get_saved_pr (struct frame_info *fi, int pr_regnum)
 
        media_mode = pc_is_isa32 (get_frame_pc (fi));
 
-       if (get_frame_saved_regs (fi)[pr_regnum] != 0)
+       if (deprecated_get_frame_saved_regs (fi)[pr_regnum] != 0)
          {
            int gdb_reg_num = translate_insn_rn (pr_regnum, media_mode);
            int size = ((gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
                        ? 4
                        : REGISTER_RAW_SIZE (gdb_reg_num));
-           return read_memory_integer (get_frame_saved_regs (fi)[pr_regnum], size);
+           return read_memory_integer (deprecated_get_frame_saved_regs (fi)[pr_regnum], size);
          }
       }
   return read_register (pr_regnum);
@@ -1027,17 +1027,17 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
   char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi), get_frame_base (fi));
   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 
   
-  if (get_frame_saved_regs (fi) == NULL)
+  if (deprecated_get_frame_saved_regs (fi) == NULL)
     frame_saved_regs_zalloc (fi);
   else
-    memset (get_frame_saved_regs (fi), 0, SIZEOF_FRAME_SAVED_REGS);
+    memset (deprecated_get_frame_saved_regs (fi), 0, SIZEOF_FRAME_SAVED_REGS);
   
   if (dummy_regs)
     {
       /* DANGER!  This is ONLY going to work if the char buffer format of
          the saved registers is byte-for-byte identical to the 
          CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */
-      memcpy (get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);
+      memcpy (deprecated_get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);
       return;
     }
 
@@ -1185,11 +1185,11 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
 
          /* Watch out! saved_regs is only for the real registers, and
             doesn't include space for the pseudo registers. */
-         get_frame_saved_regs (fi)[register_number]= get_frame_base (fi) - where[rn] + depth; 
+         deprecated_get_frame_saved_regs (fi)[register_number]= get_frame_base (fi) - where[rn] + depth; 
            
        } 
       else 
-       get_frame_saved_regs (fi)[register_number] = 0; 
+       deprecated_get_frame_saved_regs (fi)[register_number] = 0; 
     }
 
   if (have_fp)
@@ -1206,10 +1206,10 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
        size = 4;
       else
        size = REGISTER_RAW_SIZE (fp_regnum);
-      get_frame_saved_regs (fi)[sp_regnum] = read_memory_integer (get_frame_saved_regs (fi)[fp_regnum], size);
+      deprecated_get_frame_saved_regs (fi)[sp_regnum] = read_memory_integer (deprecated_get_frame_saved_regs (fi)[fp_regnum], size);
     }
   else
-    get_frame_saved_regs (fi)[sp_regnum] = get_frame_base (fi);
+    deprecated_get_frame_saved_regs (fi)[sp_regnum] = get_frame_base (fi);
 
   get_frame_extra_info (fi)->f_offset = depth - where[fp_regnum]; 
 }
@@ -1298,8 +1298,8 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
        }
 
       DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
-      if (get_frame_saved_regs (frame) != NULL
-         && get_frame_saved_regs (frame)[regnum] != 0)
+      if (deprecated_get_frame_saved_regs (frame) != NULL
+         && deprecated_get_frame_saved_regs (frame)[regnum] != 0)
        {
          if (lval)             /* found it saved on the stack */
            *lval = lval_memory;
@@ -1307,13 +1307,13 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
            {
              if (raw_buffer)   /* SP register treated specially */
                store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum),
-                                       get_frame_saved_regs (frame)[regnum]);
+                                       deprecated_get_frame_saved_regs (frame)[regnum]);
            }
          else
            { /* any other register */
              
              if (addrp)
-               *addrp = get_frame_saved_regs (frame)[regnum];
+               *addrp = deprecated_get_frame_saved_regs (frame)[regnum];
              if (raw_buffer)
                {
                  int size;
@@ -1324,9 +1324,9 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
                  else
                    size = REGISTER_RAW_SIZE (live_regnum);
                  if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
-                   read_memory (get_frame_saved_regs (frame)[regnum], raw_buffer, size);
+                   read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer, size);
                  else
-                   read_memory (get_frame_saved_regs (frame)[regnum],
+                   read_memory (deprecated_get_frame_saved_regs (frame)[regnum],
                                 raw_buffer
                                 + REGISTER_RAW_SIZE (live_regnum)
                                 - size,
@@ -1384,7 +1384,7 @@ sh64_pop_frame (void)
 
       /* Copy regs from where they were saved in the frame */
       for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
-       if (get_frame_saved_regs (frame)[regnum])
+       if (deprecated_get_frame_saved_regs (frame)[regnum])
          {
            int size;
            if (tdep->sh_abi == SH_ABI_32
@@ -1395,7 +1395,7 @@ sh64_pop_frame (void)
              size = REGISTER_RAW_SIZE (translate_insn_rn (regnum,
                                                           media_mode));
            write_register (regnum,
-                           read_memory_integer (get_frame_saved_regs (frame)[regnum],
+                           read_memory_integer (deprecated_get_frame_saved_regs (frame)[regnum],
                                                 size));
          }
 

diff --git a/gdb/stack.c b/gdb/stack.c
index a82f9f3fd12cc54263fc54bb87571ea60ad3434f..ebf439e50e6bcd5e109e1e0ec373c95ee3d6159c 100644 (file)
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -1022,7 +1022,7 @@ frame_info (char *addr_exp, int from_tty)
   }
 
   if (DEPRECATED_FRAME_INIT_SAVED_REGS_P ()
-      && get_frame_saved_regs (fi) == NULL)
+      && deprecated_get_frame_saved_regs (fi) == NULL)
     DEPRECATED_FRAME_INIT_SAVED_REGS (fi);
   /* Print as much information as possible on the location of all the
      registers.  */

diff --git a/gdb/v850-tdep.c b/gdb/v850-tdep.c
index 2b239b627415ad701c12b5ed8cf0436686a541b1..030e2010fe7e7a6c874af6cd91343215fe9cc0b0 100644 (file)
--- a/gdb/v850-tdep.c
+++ b/gdb/v850-tdep.c
@@ -810,8 +810,8 @@ v850_find_callers_reg (struct frame_info *fi, int regnum)
                                     get_frame_base (fi)))
       return deprecated_read_register_dummy (get_frame_pc (fi),
                                             get_frame_base (fi), regnum);
-    else if (get_frame_saved_regs (fi)[regnum] != 0)
-      return read_memory_unsigned_integer (get_frame_saved_regs (fi)[regnum],
+    else if (deprecated_get_frame_saved_regs (fi)[regnum] != 0)
+      return read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[regnum],
                                           v850_register_raw_size (regnum));
 
   return read_register (regnum);
@@ -900,9 +900,9 @@ v850_pop_frame (void)
       write_register (E_PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
 
       for (regnum = 0; regnum < E_NUM_REGS; regnum++)
-       if (get_frame_saved_regs (frame)[regnum] != 0)
+       if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
          write_register (regnum,
-                     read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
+                     read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
                                             v850_register_raw_size (regnum)));
 
       write_register (E_SP_REGNUM, get_frame_base (frame));
@@ -1117,7 +1117,7 @@ v850_frame_init_saved_regs (struct frame_info *fi)
   struct pifsr pifsrs[E_NUM_REGS + 1], *pifsr;
   CORE_ADDR func_addr, func_end;
 
-  if (!get_frame_saved_regs (fi))
+  if (!deprecated_get_frame_saved_regs (fi))
     {
       frame_saved_regs_zalloc (fi);
 
@@ -1140,10 +1140,10 @@ v850_frame_init_saved_regs (struct frame_info *fi)
 
          for (pifsr = pifsrs; pifsr->framereg; pifsr++)
            {
-             get_frame_saved_regs (fi)[pifsr->reg] = pifsr->offset + get_frame_base (fi);
+             deprecated_get_frame_saved_regs (fi)[pifsr->reg] = pifsr->offset + get_frame_base (fi);
 
              if (pifsr->framereg == E_SP_REGNUM)
-               get_frame_saved_regs (fi)[pifsr->reg] += pi.frameoffset;
+               deprecated_get_frame_saved_regs (fi)[pifsr->reg] += pi.frameoffset;
            }
        }
       /* Else we're out of luck (can't debug completely stripped code). 

diff --git a/gdb/vax-tdep.c b/gdb/vax-tdep.c
index 2bbe42199e0a5c67b3ea1910823f3f03b22d3fe9..03a50a0798814e02089fd52b0dfb53cb7cb8ff60 100644 (file)
--- a/gdb/vax-tdep.c
+++ b/gdb/vax-tdep.c
@@ -93,7 +93,7 @@ vax_frame_init_saved_regs (struct frame_info *frame)
   int regnum, regmask;
   CORE_ADDR next_addr;
 
-  if (get_frame_saved_regs (frame))
+  if (deprecated_get_frame_saved_regs (frame))
     return;
 
   frame_saved_regs_zalloc (frame);
@@ -107,18 +107,18 @@ vax_frame_init_saved_regs (struct frame_info *frame)
   for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
     {
       if (regmask & (1 << regnum))
-        get_frame_saved_regs (frame)[regnum] = next_addr += 4;
+        deprecated_get_frame_saved_regs (frame)[regnum] = next_addr += 4;
     }
 
-  get_frame_saved_regs (frame)[SP_REGNUM] = next_addr + 4;
+  deprecated_get_frame_saved_regs (frame)[SP_REGNUM] = next_addr + 4;
   if (regmask & (1 << DEPRECATED_FP_REGNUM))
-    get_frame_saved_regs (frame)[SP_REGNUM] +=
+    deprecated_get_frame_saved_regs (frame)[SP_REGNUM] +=
       4 + (4 * read_memory_integer (next_addr + 4, 4));
 
-  get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 16;
-  get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = get_frame_base (frame) + 12;
-  get_frame_saved_regs (frame)[VAX_AP_REGNUM] = get_frame_base (frame) + 8;
-  get_frame_saved_regs (frame)[PS_REGNUM] = get_frame_base (frame) + 4;
+  deprecated_get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 16;
+  deprecated_get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = get_frame_base (frame) + 12;
+  deprecated_get_frame_saved_regs (frame)[VAX_AP_REGNUM] = get_frame_base (frame) + 8;
+  deprecated_get_frame_saved_regs (frame)[PS_REGNUM] = get_frame_base (frame) + 4;
 }
 
 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp.  */

diff --git a/gdb/xstormy16-tdep.c b/gdb/xstormy16-tdep.c
index 1e8629492b48e08e777f2c62d729a4f658185b8b..4740354637450fc236a27c7de84cf311f20286f2 100644 (file)
--- a/gdb/xstormy16-tdep.c
+++ b/gdb/xstormy16-tdep.c
@@ -343,15 +343,15 @@ xstormy16_pop_frame (void)
     {
       /* Restore the saved regs. */
       for (i = 0; i < NUM_REGS; i++)
-       if (get_frame_saved_regs (fi)[i])
+       if (deprecated_get_frame_saved_regs (fi)[i])
          {
            if (i == SP_REGNUM)
-             write_register (i, get_frame_saved_regs (fi)[i]);
+             write_register (i, deprecated_get_frame_saved_regs (fi)[i]);
            else if (i == E_PC_REGNUM)
-             write_register (i, read_memory_integer (get_frame_saved_regs (fi)[i],
+             write_register (i, read_memory_integer (deprecated_get_frame_saved_regs (fi)[i],
                                                      xstormy16_pc_size));
            else
-             write_register (i, read_memory_integer (get_frame_saved_regs (fi)[i],
+             write_register (i, read_memory_integer (deprecated_get_frame_saved_regs (fi)[i],
                                                      xstormy16_reg_size));
          }
       /* Restore the PC */
@@ -492,7 +492,7 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
          if (fi)
            {
              regnum = inst & 0x000f;
-             get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize;
+             deprecated_get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize;
              get_frame_extra_info (fi)->framesize += xstormy16_reg_size;
            }
        }
@@ -548,7 +548,7 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
              if (offset & 0x0800)
                offset -= 0x1000;
 
-             get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize + offset;
+             deprecated_get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize + offset;
            }
          next_addr += xstormy16_inst_size;
        }
@@ -595,12 +595,12 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
          previous value would have been pushed).  */
       if (get_frame_extra_info (fi)->frameless_p)
        {
-         get_frame_saved_regs (fi)[E_SP_REGNUM] = sp - get_frame_extra_info (fi)->framesize;
+         deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM] = sp - get_frame_extra_info (fi)->framesize;
          deprecated_update_frame_base_hack (fi, sp);
        }
       else
        {
-         get_frame_saved_regs (fi)[E_SP_REGNUM] = fp - get_frame_extra_info (fi)->framesize;
+         deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM] = fp - get_frame_extra_info (fi)->framesize;
          deprecated_update_frame_base_hack (fi, fp);
        }
 
@@ -609,11 +609,11 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
          sp, fp and framesize. We know the beginning of the frame
          so we can translate the register offsets to real addresses. */
       for (regnum = 0; regnum < E_SP_REGNUM; ++regnum)
-       if (get_frame_saved_regs (fi)[regnum])
-         get_frame_saved_regs (fi)[regnum] += get_frame_saved_regs (fi)[E_SP_REGNUM];
+       if (deprecated_get_frame_saved_regs (fi)[regnum])
+         deprecated_get_frame_saved_regs (fi)[regnum] += deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM];
 
       /* Save address of PC on stack. */
-      get_frame_saved_regs (fi)[E_PC_REGNUM] = get_frame_saved_regs (fi)[E_SP_REGNUM];
+      deprecated_get_frame_saved_regs (fi)[E_PC_REGNUM] = deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM];
     }
 
   return next_addr;
@@ -733,7 +733,7 @@ xstormy16_frame_init_saved_regs (struct frame_info *fi)
 {
   CORE_ADDR func_addr, func_end;
 
-  if (!get_frame_saved_regs (fi))
+  if (!deprecated_get_frame_saved_regs (fi))
     {
       frame_saved_regs_zalloc (fi);
 
@@ -765,7 +765,7 @@ xstormy16_frame_saved_pc (struct frame_info *fi)
     }
   else
     {
-      saved_pc = read_memory_unsigned_integer (get_frame_saved_regs (fi)[E_PC_REGNUM],
+      saved_pc = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[E_PC_REGNUM],
                                               xstormy16_pc_size);
     }