2003-05-30 Andrew Cagney <cagney@redhat.com>

[deliverable/binutils-gdb.git] / gdb / cris-tdep.c

diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c
index 9a526114d9a51dd4b1e8243b7b64114d95ed2008..2fbfde53b0e3477d3e227475188c28bae3b6fc0d 100644 (file)
--- a/gdb/cris-tdep.c
+++ b/gdb/cris-tdep.c
@@ -1,5 +1,5 @@
 /* Target dependent code for CRIS, for GDB, the GNU debugger.
 /* Target dependent code for CRIS, for GDB, the GNU debugger.

-   Copyright 2001 Free Software Foundation, Inc.
+   Copyright 2001, 2002, 2003 Free Software Foundation, Inc.

    Contributed by Axis Communications AB.
    Written by Hendrik Ruijter, Stefan Andersson, and Orjan Friberg.
 
    Contributed by Axis Communications AB.
    Written by Hendrik Ruijter, Stefan Andersson, and Orjan Friberg.
 


@@ -37,6 +37,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "solib.h"              /* Support for shared libraries. */
 #include "solib-svr4.h"         /* For struct link_map_offsets.  */
 
 #include "solib.h"              /* Support for shared libraries. */
 #include "solib-svr4.h"         /* For struct link_map_offsets.  */

+#include "gdb_string.h"

 
 
 enum cris_num_regs
 
 
 enum cris_num_regs


@@ -52,7 +53,7 @@ enum cris_num_regs
 };
 
 /* Register numbers of various important registers.
 };
 
 /* Register numbers of various important registers.

-   FP_REGNUM   Contains address of executing stack frame.
+   DEPRECATED_FP_REGNUM   Contains address of executing stack frame.

    STR_REGNUM  Contains the address of structure return values.
    RET_REGNUM  Contains the return value when shorter than or equal to 32 bits
    ARG1_REGNUM Contains the first parameter to a function.
    STR_REGNUM  Contains the address of structure return values.
    RET_REGNUM  Contains the return value when shorter than or equal to 32 bits
    ARG1_REGNUM Contains the first parameter to a function.


@@ -64,8 +65,8 @@ enum cris_num_regs
    SRP_REGNUM  Subroutine return pointer register.
    BRP_REGNUM  Breakpoint return pointer register.  */
 
    SRP_REGNUM  Subroutine return pointer register.
    BRP_REGNUM  Breakpoint return pointer register.  */
 

-/* FP_REGNUM = 8, SP_REGNUM = 14, and PC_REGNUM = 15 have been incorporated
-   into the multi-arch framework.  */
+/* DEPRECATED_FP_REGNUM = 8, SP_REGNUM = 14, and PC_REGNUM = 15 have
+   been incorporated into the multi-arch framework.  */

 
 enum cris_regnums
 {
 
 enum cris_regnums
 {


@@ -391,7 +392,7 @@ static CORE_ADDR bfd_lookup_symbol (bfd *, const char *);
 
    CORE_ADDR frame
    CORE_ADDR pc
 
    CORE_ADDR frame
    CORE_ADDR pc

-   int signal_handler_caller
+   enum frame_type type;

    CORE_ADDR return_pc
    int leaf_function
 
    CORE_ADDR return_pc
    int leaf_function
 


@@ -404,8 +405,9 @@ static CORE_ADDR bfd_lookup_symbol (bfd *, const char *);
    of the register PC.  All other frames contain the content of the
    register PC in the next frame.
 
    of the register PC.  All other frames contain the content of the
    register PC in the next frame.
 

-   The variable signal_handler_caller is non-zero when the frame is
-   associated with the call of a signal handler.
+   The variable `type' indicates the frame's type: normal, SIGTRAMP
+   (associated with a signal handler), dummy (associated with a dummy
+   frame).

 
    The variable return_pc contains the address where execution should be
    resumed when the present frame has finished, the return address.
 
    The variable return_pc contains the address where execution should be
    resumed when the present frame has finished, the return address.


@@ -486,7 +488,7 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
   short source_register; 
 
   /* This frame is with respect to a leaf until a push srp is found.  */
   short source_register; 
 
   /* This frame is with respect to a leaf until a push srp is found.  */

-  fi->extra_info->leaf_function = 1;
+  get_frame_extra_info (fi)->leaf_function = 1;

 
   /* This frame is without the FP until a push fp is found.  */
   have_fp = 0;
 
   /* This frame is without the FP until a push fp is found.  */
   have_fp = 0;


@@ -499,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.  */
 
   /* 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 (fi->saved_regs)
+  if (get_frame_saved_regs (fi))

     {
       for (regno = 0; regno < NUM_REGS; regno++)
     {
       for (regno = 0; regno < NUM_REGS; regno++)

-        fi->saved_regs[regno] = 0;
+        get_frame_saved_regs (fi)[regno] = 0;

     }
  
   /* Find the prologue instructions.  */
     }
  
   /* Find the prologue instructions.  */


@@ -525,9 +527,9 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
                 {
                   return ip;
                 }
                 {
                   return ip;
                 }

-              fi->extra_info->leaf_function = 0;
+              get_frame_extra_info (fi)->leaf_function = 0;

             }
             }

-          else if (regno == FP_REGNUM)
+          else if (regno == DEPRECATED_FP_REGNUM)

             {
               have_fp = 1;
             }
             {
               have_fp = 1;
             }


@@ -614,7 +616,7 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
               break;
             }
         }
               break;
             }
         }

-      else if (cris_get_operand2 (insn) == FP_REGNUM 
+      else if (cris_get_operand2 (insn) == DEPRECATED_FP_REGNUM 

                /* The size is a fixed-size.  */
                && ((insn & 0x0F00) >> 8) == 0x0001 
                /* A negative offset.  */
                /* The size is a fixed-size.  */
                && ((insn & 0x0F00) >> 8) == 0x0001 
                /* A negative offset.  */


@@ -638,7 +640,7 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
               break;
             }
         }
               break;
             }
         }

-      else if (cris_get_operand2 (insn) == FP_REGNUM 
+      else if (cris_get_operand2 (insn) == DEPRECATED_FP_REGNUM 

                /* The size is a fixed-size.  */
                && ((insn & 0x0F00) >> 8) == 0x0001 
                /* A positive offset.  */
                /* The size is a fixed-size.  */
                && ((insn & 0x0F00) >> 8) == 0x0001 
                /* A positive offset.  */


@@ -674,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.  */ 
 
   /* We only want to know the end of the prologue when
      fi->saved_regs == 0.  */ 

-  if (!fi->saved_regs)
+  if (!get_frame_saved_regs (fi))

     return ip;
 
   if (have_fp)
     {
     return ip;
 
   if (have_fp)
     {

-      fi->saved_regs[FP_REGNUM] = FRAME_FP (fi);
+      get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] = get_frame_base (fi);

       
       /* Calculate the addresses.  */
       for (regno = regsave; regno >= 0; regno--)
         {
       
       /* Calculate the addresses.  */
       for (regno = regsave; regno >= 0; regno--)
         {

-          fi->saved_regs[regno] = FRAME_FP (fi) - val;
+          get_frame_saved_regs (fi)[regno] = get_frame_base (fi) - val;

           val -= 4;
         }
           val -= 4;
         }

-      if (fi->extra_info->leaf_function)
+      if (get_frame_extra_info (fi)->leaf_function)

         {
           /* Set the register SP to contain the stack pointer of 
              the caller.  */
         {
           /* Set the register SP to contain the stack pointer of 
              the caller.  */

-          fi->saved_regs[SP_REGNUM] = FRAME_FP (fi) + 4;
+          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.  */
         }
       else
         {
           /* Set the register SP to contain the stack pointer of 
              the caller.  */

-          fi->saved_regs[SP_REGNUM] = FRAME_FP (fi) + 8;
+          get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 8;

       
           /* Set the register SRP to contain the return address of 
              the caller.  */
       
           /* Set the register SRP to contain the return address of 
              the caller.  */

-          fi->saved_regs[SRP_REGNUM] = FRAME_FP (fi) + 4;
+          get_frame_saved_regs (fi)[SRP_REGNUM] = get_frame_base (fi) + 4;

         }
     }
   return ip;
         }
     }
   return ip;


@@ -732,17 +734,15 @@ cris_skip_prologue_frameless_p (CORE_ADDR pc)
 CORE_ADDR
 cris_skip_prologue_main (CORE_ADDR pc, int frameless_p)
 {
 CORE_ADDR
 cris_skip_prologue_main (CORE_ADDR pc, int frameless_p)
 {

-  struct frame_info fi;
-  static struct frame_extra_info fei;
+  struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
+  struct frame_info *fi;

   struct symtab_and_line sal = find_pc_line (pc, 0);
   int best_limit;
   CORE_ADDR pc_after_prologue;
   
   struct symtab_and_line sal = find_pc_line (pc, 0);
   int best_limit;
   CORE_ADDR pc_after_prologue;
   

-  /* frame_info now contains dynamic memory.  Since fi is a dummy here,
-     I use static memory for extra_info, and don't bother allocating
-     memory for saved_regs.  */
-  fi.saved_regs = 0;
-  fi.extra_info = &fei;
+  /* frame_info now contains dynamic memory.  Since fi is a dummy
+     here, I don't bother allocating memory for saved_regs.  */
+  fi = deprecated_frame_xmalloc_with_cleanup (0, sizeof (struct frame_extra_info));

 
   /* If there is no symbol information then sal.end == 0, and we end up
      examining only the first instruction in the function prologue. 
 
   /* If there is no symbol information then sal.end == 0, and we end up
      examining only the first instruction in the function prologue. 


@@ -752,7 +752,8 @@ cris_skip_prologue_main (CORE_ADDR pc, int frameless_p)
   else
     best_limit = pc + 100; 
 
   else
     best_limit = pc + 100; 
 

-  pc_after_prologue = cris_examine (pc, best_limit, &fi, frameless_p);
+  pc_after_prologue = cris_examine (pc, best_limit, fi, frameless_p);
+  do_cleanups (old_chain);

   return pc_after_prologue;
 }
 
   return pc_after_prologue;
 }
 


@@ -762,7 +763,7 @@ cris_skip_prologue_main (CORE_ADDR pc, int frameless_p)
    adjusts pcptr (if necessary) to point to the actual memory location where
    the breakpoint should be inserted.  */
 
    adjusts pcptr (if necessary) to point to the actual memory location where
    the breakpoint should be inserted.  */
 

-unsigned char *
+const unsigned char *

 cris_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 {
   static unsigned char break_insn[] = {0x38, 0xe9};
 cris_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 {
   static unsigned char break_insn[] = {0x38, 0xe9};


@@ -774,8 +775,8 @@ cris_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 /* Returns the register SRP (subroutine return pointer) which must contain 
    the content of the register PC after a function call.  */
 
 /* Returns the register SRP (subroutine return pointer) which must contain 
    the content of the register PC after a function call.  */
 

-CORE_ADDR
-cris_saved_pc_after_call ()
+static CORE_ADDR
+cris_saved_pc_after_call (struct frame_info *frame)

 {
   return read_register (SRP_REGNUM);
 }
 {
   return read_register (SRP_REGNUM);
 }


@@ -970,8 +971,8 @@ cris_abi_original_store_return_value (struct type *type, char *valbuf)
 {
   int len = TYPE_LENGTH (type);
   
 {
   int len = TYPE_LENGTH (type);
   

-  if (len <= REGISTER_SIZE) 
-    write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len);
+  if (len <= DEPRECATED_REGISTER_SIZE) 
+    deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len);

   else
     internal_error (__FILE__, __LINE__, "cris_abi_original_store_return_value: type length too large.");
 }
   else
     internal_error (__FILE__, __LINE__, "cris_abi_original_store_return_value: type length too large.");
 }


@@ -983,10 +984,11 @@ cris_abi_v2_store_return_value (struct type *type, char *valbuf)
 {
   int len = TYPE_LENGTH (type);
   
 {
   int len = TYPE_LENGTH (type);
   

-  if (len <= 2 * REGISTER_SIZE)
+  if (len <= 2 * DEPRECATED_REGISTER_SIZE)

     {
       /* Note that this works since R10 and R11 are consecutive registers.  */
     {
       /* Note that this works since R10 and R11 are consecutive registers.  */

-      write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len);
+      deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf,
+                                      len);

     }
   else
     internal_error (__FILE__, __LINE__, "cris_abi_v2_store_return_value: type length too large.");
     }
   else
     internal_error (__FILE__, __LINE__, "cris_abi_v2_store_return_value: type length too large.");


@@ -995,7 +997,7 @@ cris_abi_v2_store_return_value (struct type *type, char *valbuf)
 /* Return the name of register regno as a string. Return NULL for an invalid or
    unimplemented register.  */
 
 /* Return the name of register regno as a string. Return NULL for an invalid or
    unimplemented register.  */
 

-char *
+const char *

 cris_register_name (int regno)
 {
   static char *cris_genreg_names[] =
 cris_register_name (int regno)
 {
   static char *cris_genreg_names[] =


@@ -1040,7 +1042,7 @@ cris_register_name (int regno)
 int
 cris_register_bytes_ok (long bytes)
 {
 int
 cris_register_bytes_ok (long bytes)
 {

-  return (bytes == REGISTER_BYTES);
+  return (bytes == DEPRECATED_REGISTER_BYTES);

 }
 
 /* Extract from an array regbuf containing the raw register state a function
 }
 
 /* Extract from an array regbuf containing the raw register state a function


@@ -1055,7 +1057,7 @@ cris_abi_original_extract_return_value (struct type *type, char *regbuf,
 {
   int len = TYPE_LENGTH (type);
   
 {
   int len = TYPE_LENGTH (type);
   

-  if (len <= REGISTER_SIZE)
+  if (len <= DEPRECATED_REGISTER_SIZE)

     memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
   else
     internal_error (__FILE__, __LINE__, "cris_abi_original_extract_return_value: type length too large");
     memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
   else
     internal_error (__FILE__, __LINE__, "cris_abi_original_extract_return_value: type length too large");


@@ -1069,7 +1071,7 @@ cris_abi_v2_extract_return_value (struct type *type, char *regbuf,
 {
   int len = TYPE_LENGTH (type);
   
 {
   int len = TYPE_LENGTH (type);
   

-  if (len <= 2 * REGISTER_SIZE)
+  if (len <= 2 * DEPRECATED_REGISTER_SIZE)

     memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
   else
     internal_error (__FILE__, __LINE__, "cris_abi_v2_extract_return_value: type length too large");
     memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
   else
     internal_error (__FILE__, __LINE__, "cris_abi_v2_extract_return_value: type length too large");


@@ -1138,16 +1140,16 @@ cris_abi_v2_reg_struct_has_addr (int gcc_p, struct type *type)
 int
 cris_frameless_function_invocation (struct frame_info *fi)
 {
 int
 cris_frameless_function_invocation (struct frame_info *fi)
 {

-  if (fi->signal_handler_caller)
+  if ((get_frame_type (fi) == SIGTRAMP_FRAME))

     return 0;
   else
     return frameless_look_for_prologue (fi);
 }
 
     return 0;
   else
     return frameless_look_for_prologue (fi);
 }
 

-/* See frame.h.  Determines the address of all registers in the current stack
-   frame storing each in frame->saved_regs.  Space for frame->saved_regs shall
-   be allocated by FRAME_INIT_SAVED_REGS using either frame_saved_regs_zalloc
-   or frame_obstack_alloc.  */
+/* See frame.h.  Determines the address of all registers in the
+   current stack frame storing each in frame->saved_regs.  Space for
+   frame->saved_regs shall be allocated by
+   DEPRECATED_FRAME_INIT_SAVED_REGS using frame_saved_regs_zalloc.  */

 
 void
 cris_frame_init_saved_regs (struct frame_info *fi)
 
 void
 cris_frame_init_saved_regs (struct frame_info *fi)


@@ -1155,13 +1157,14 @@ cris_frame_init_saved_regs (struct frame_info *fi)
   CORE_ADDR ip;
   struct symtab_and_line sal;
   int best_limit;
   CORE_ADDR ip;
   struct symtab_and_line sal;
   int best_limit;

-  char *dummy_regs = generic_find_dummy_frame (fi->pc, fi->frame);
+  char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi),
+                                                         get_frame_base (fi));

   
   /* Examine the entire prologue.  */
   register int frameless_p = 0; 
 
   /* Has this frame's registers already been initialized?  */
   
   /* Examine the entire prologue.  */
   register int frameless_p = 0; 
 
   /* Has this frame's registers already been initialized?  */

-  if (fi->saved_regs)
+  if (get_frame_saved_regs (fi))

     return;
 
   frame_saved_regs_zalloc (fi);
     return;
 
   frame_saved_regs_zalloc (fi);


@@ -1171,11 +1174,11 @@ 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).  */
       /* 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 (&fi->saved_regs, dummy_regs, sizeof (fi->saved_regs));
+      memcpy (get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);

     }
   else
     {    
     }
   else
     {    

-      ip = get_pc_function_start (fi->pc);
+      ip = get_frame_func (fi);

       sal = find_pc_line (ip, 0);
 
       /* If there is no symbol information then sal.end == 0, and we end up
       sal = find_pc_line (ip, 0);
 
       /* If there is no symbol information then sal.end == 0, and we end up


@@ -1198,28 +1201,30 @@ cris_frame_init_saved_regs (struct frame_info *fi)
 void
 cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 {
 void
 cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 {

-  if (fi->next)
+  if (get_next_frame (fi))

     {
       /* Called from get_prev_frame.  */
     {
       /* Called from get_prev_frame.  */

-      fi->pc = FRAME_SAVED_PC (fi->next);
+      deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));

     }
  
     }
  

-  fi->extra_info = (struct frame_extra_info *)
-    frame_obstack_alloc (sizeof (struct frame_extra_info));
+  frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));

  
  

-  fi->extra_info->return_pc = 0;
-  fi->extra_info->leaf_function = 0;
+  get_frame_extra_info (fi)->return_pc = 0;
+  get_frame_extra_info (fi)->leaf_function = 0;

 
 

-  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+  if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi),
+                                  get_frame_base (fi),
+                                  get_frame_base (fi)))

     {    
     {    

-      /* We need to setup fi->frame here because run_stack_dummy gets it wrong
-         by assuming it's always FP.  */
-      fi->frame = generic_read_register_dummy (fi->pc, fi->frame, SP_REGNUM);
-      fi->extra_info->return_pc = 
-        generic_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
+      /* We need to setup fi->frame here because call_function_by_hand
+         gets it wrong by assuming it's always FP.  */
+      deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM));
+      get_frame_extra_info (fi)->return_pc = 
+        deprecated_read_register_dummy (get_frame_pc (fi),
+                                       get_frame_base (fi), PC_REGNUM);

 
       /* FIXME: Is this necessarily true?  */
 
       /* FIXME: Is this necessarily true?  */

-      fi->extra_info->leaf_function = 0;
+      get_frame_extra_info (fi)->leaf_function = 0;

     }
   else
     {
     }
   else
     {


@@ -1227,19 +1232,19 @@ cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 
       /* Check fromleaf/frameless_function_invocation.  (FIXME)  */
 
 
       /* Check fromleaf/frameless_function_invocation.  (FIXME)  */
 

-      if (fi->saved_regs[SRP_REGNUM] != 0)
+      if (get_frame_saved_regs (fi)[SRP_REGNUM] != 0)

         {
           /* SRP was saved on the stack; non-leaf function.  */
         {
           /* SRP was saved on the stack; non-leaf function.  */

-          fi->extra_info->return_pc =
-            read_memory_integer (fi->saved_regs[SRP_REGNUM], 
+          get_frame_extra_info (fi)->return_pc =
+            read_memory_integer (get_frame_saved_regs (fi)[SRP_REGNUM], 

                                  REGISTER_RAW_SIZE (SRP_REGNUM));
         }
       else
         {
           /* SRP is still in a register; leaf function.  */
                                  REGISTER_RAW_SIZE (SRP_REGNUM));
         }
       else
         {
           /* SRP is still in a register; leaf function.  */

-          fi->extra_info->return_pc = read_register (SRP_REGNUM);
+          get_frame_extra_info (fi)->return_pc = read_register (SRP_REGNUM);

           /* FIXME: Should leaf_function be set to 1 here?  */
           /* FIXME: Should leaf_function be set to 1 here?  */

-          fi->extra_info->leaf_function = 1;
+          get_frame_extra_info (fi)->leaf_function = 1;

         }
     }
 }
         }
     }
 }


@@ -1250,13 +1255,15 @@ cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 CORE_ADDR
 cris_frame_chain (struct frame_info *fi)
 {
 CORE_ADDR
 cris_frame_chain (struct frame_info *fi)
 {

-  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+  if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi),
+                                  get_frame_base (fi),
+                                  get_frame_base (fi)))

     {
     {

-      return fi->frame;
+      return get_frame_base (fi);

     }
     }

-  else if (!inside_entry_file (fi->pc))
+  else if (!inside_entry_file (get_frame_pc (fi)))

     {
     {

-      return read_memory_unsigned_integer (FRAME_FP (fi), 4);
+      return read_memory_unsigned_integer (get_frame_base (fi), 4);

     }
   else
     {
     }
   else
     {


@@ -1269,25 +1276,7 @@ cris_frame_chain (struct frame_info *fi)
 CORE_ADDR
 cris_frame_saved_pc (struct frame_info *fi)
 {
 CORE_ADDR
 cris_frame_saved_pc (struct frame_info *fi)
 {

-  return fi->extra_info->return_pc;
-}
-
-/* Return the address of the argument block for the frame described 
-   by struct frame_info.  */
-
-CORE_ADDR
-cris_frame_args_address (struct frame_info *fi)
-{
-  return FRAME_FP (fi);
-}
-
-/* Return the address of the locals block for the frame
-   described by struct frame_info.  */
-
-CORE_ADDR
-cris_frame_locals_address (struct frame_info *fi)
-{
-  return FRAME_FP (fi);
+  return get_frame_extra_info (fi)->return_pc;

 }
 
 /* Setup the function arguments for calling a function in the inferior.  */
 }
 
 /* Setup the function arguments for calling a function in the inferior.  */


@@ -1322,13 +1311,13 @@ cris_abi_original_push_arguments (int nargs, struct value **args,
   /* Make sure there's space on the stack.  Allocate space for data and a 
      parameter to refer to that data.  */
   for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
   /* Make sure there's space on the stack.  Allocate space for data and a 
      parameter to refer to that data.  */
   for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)

-    stack_alloc += (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + REGISTER_SIZE);
+    stack_alloc += (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + DEPRECATED_REGISTER_SIZE);

   sp -= stack_alloc;
   /* We may over-allocate a little here, but that won't hurt anything.  */
 
   /* Initialize stack frame pointers.  */
   fp_params = sp;
   sp -= stack_alloc;
   /* We may over-allocate a little here, but that won't hurt anything.  */
 
   /* Initialize stack frame pointers.  */
   fp_params = sp;

-  fp_data = sp + (nargs * REGISTER_SIZE);
+  fp_data = sp + (nargs * DEPRECATED_REGISTER_SIZE);

 
   /* Now load as many as possible of the first arguments into
      registers, and push the rest onto the stack.  */
 
   /* Now load as many as possible of the first arguments into
      registers, and push the rest onto the stack.  */


@@ -1341,14 +1330,14 @@ cris_abi_original_push_arguments (int nargs, struct value **args,
       len = TYPE_LENGTH (type);
       val = (char *) VALUE_CONTENTS (args[argnum]);
     
       len = TYPE_LENGTH (type);
       val = (char *) VALUE_CONTENTS (args[argnum]);
     

-      if (len <= REGISTER_SIZE && argreg <= ARG4_REGNUM)
+      if (len <= DEPRECATED_REGISTER_SIZE && argreg <= ARG4_REGNUM)

         {
           /* Data fits in a register; put it in the first available 
              register.  */
           write_register (argreg, *(unsigned long *) val);
           argreg++;
         }
         {
           /* Data fits in a register; put it in the first available 
              register.  */
           write_register (argreg, *(unsigned long *) val);
           argreg++;
         }

-      else if (len > REGISTER_SIZE && argreg <= ARG4_REGNUM)
+      else if (len > DEPRECATED_REGISTER_SIZE && argreg <= ARG4_REGNUM)

         {
           /* Data does not fit in register; pass it on the stack and
              put its address in the first available register.  */
         {
           /* Data does not fit in register; pass it on the stack and
              put its address in the first available register.  */


@@ -1357,21 +1346,21 @@ cris_abi_original_push_arguments (int nargs, struct value **args,
           fp_data += len;
           argreg++;      
         }
           fp_data += len;
           argreg++;      
         }

-      else if (len > REGISTER_SIZE)
+      else if (len > DEPRECATED_REGISTER_SIZE)

         {
           /* Data does not fit in register; put both data and 
              parameter on the stack.  */
           write_memory (fp_data, val, len);
         {
           /* Data does not fit in register; put both data and 
              parameter on the stack.  */
           write_memory (fp_data, val, len);

-          write_memory (fp_params, (char *) (&fp_data), REGISTER_SIZE);
+          write_memory (fp_params, (char *) (&fp_data), DEPRECATED_REGISTER_SIZE);

           fp_data += len;
           fp_data += len;

-          fp_params += REGISTER_SIZE;
+          fp_params += DEPRECATED_REGISTER_SIZE;

         }
       else
         {
           /* Data fits in a register, but we are out of registers;
              put the parameter on the stack.  */
         }
       else
         {
           /* Data fits in a register, but we are out of registers;
              put the parameter on the stack.  */

-          write_memory (fp_params, val, REGISTER_SIZE);
-          fp_params += REGISTER_SIZE;
+          write_memory (fp_params, val, DEPRECATED_REGISTER_SIZE);
+          fp_params += DEPRECATED_REGISTER_SIZE;

         }
     }
 
         }
     }
 


@@ -1412,20 +1401,21 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
       int reg_demand;
       
       len = TYPE_LENGTH (VALUE_TYPE (args[argnum]));
       int reg_demand;
       
       len = TYPE_LENGTH (VALUE_TYPE (args[argnum]));

-      reg_demand = (len / REGISTER_SIZE) + (len % REGISTER_SIZE != 0 ? 1 : 0);
+      reg_demand = (len / DEPRECATED_REGISTER_SIZE) + (len % DEPRECATED_REGISTER_SIZE != 0 ? 1 : 0);

 
 

-      /* reg_demand * REGISTER_SIZE is the amount of memory we might need to
-         allocate for this argument.  2 * REGISTER_SIZE is the amount of stack
-         space we might need to pass the argument itself (either by value or by
+      /* reg_demand * DEPRECATED_REGISTER_SIZE is the amount of memory
+         we might need to allocate for this argument.  2 *
+         DEPRECATED_REGISTER_SIZE is the amount of stack space we
+         might need to pass the argument itself (either by value or by

          reference).  */
          reference).  */

-      stack_alloc += (reg_demand * REGISTER_SIZE + 2 * REGISTER_SIZE);
+      stack_alloc += (reg_demand * DEPRECATED_REGISTER_SIZE + 2 * DEPRECATED_REGISTER_SIZE);

     }
   sp -= stack_alloc;
   /* We may over-allocate a little here, but that won't hurt anything.  */
 
   /* Initialize frame pointers.  */
   fp_arg = sp;
     }
   sp -= stack_alloc;
   /* We may over-allocate a little here, but that won't hurt anything.  */
 
   /* Initialize frame pointers.  */
   fp_arg = sp;

-  fp_mem = sp + (nargs * (2 * REGISTER_SIZE));
+  fp_mem = sp + (nargs * (2 * DEPRECATED_REGISTER_SIZE));

 
   /* Now load as many as possible of the first arguments into registers,
      and push the rest onto the stack.  */
 
   /* Now load as many as possible of the first arguments into registers,
      and push the rest onto the stack.  */


@@ -1443,9 +1433,9 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
       val = (char *) VALUE_CONTENTS (args[argnum]);
       
       /* How may registers worth of storage do we need for this argument?  */
       val = (char *) VALUE_CONTENTS (args[argnum]);
       
       /* How may registers worth of storage do we need for this argument?  */

-      reg_demand = (len / REGISTER_SIZE) + (len % REGISTER_SIZE != 0 ? 1 : 0);
+      reg_demand = (len / DEPRECATED_REGISTER_SIZE) + (len % DEPRECATED_REGISTER_SIZE != 0 ? 1 : 0);

         
         

-      if (len <= (2 * REGISTER_SIZE)
+      if (len <= (2 * DEPRECATED_REGISTER_SIZE)

           && (argreg + reg_demand - 1 <= ARG4_REGNUM)) 
         {
           /* Data passed by value.  Fits in available register(s).  */
           && (argreg + reg_demand - 1 <= ARG4_REGNUM)) 
         {
           /* Data passed by value.  Fits in available register(s).  */


@@ -1453,10 +1443,10 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
             {
               write_register (argreg, *(unsigned long *) val);
               argreg++;
             {
               write_register (argreg, *(unsigned long *) val);
               argreg++;

-              val += REGISTER_SIZE;
+              val += DEPRECATED_REGISTER_SIZE;

             }
         }
             }
         }

-      else if (len <= (2 * REGISTER_SIZE) && argreg <= ARG4_REGNUM)
+      else if (len <= (2 * DEPRECATED_REGISTER_SIZE) && argreg <= ARG4_REGNUM)

         {
           /* Data passed by value. Does not fit in available register(s).  
              Use the register(s) first, then the stack.  */
         {
           /* Data passed by value. Does not fit in available register(s).  
              Use the register(s) first, then the stack.  */


@@ -1466,28 +1456,29 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
                 {
                   write_register (argreg, *(unsigned long *) val);
                   argreg++;
                 {
                   write_register (argreg, *(unsigned long *) val);
                   argreg++;

-                  val += REGISTER_SIZE;
+                  val += DEPRECATED_REGISTER_SIZE;

                 }
               else
                 {
                 }
               else
                 {

-                  /* I guess this memory write could write the remaining data
-                     all at once instead of in REGISTER_SIZE chunks.  */
-                  write_memory (fp_arg, val, REGISTER_SIZE);
-                  fp_arg += REGISTER_SIZE;
-                  val += REGISTER_SIZE;              
+                  /* I guess this memory write could write the
+                     remaining data all at once instead of in
+                     DEPRECATED_REGISTER_SIZE chunks.  */
+                  write_memory (fp_arg, val, DEPRECATED_REGISTER_SIZE);
+                  fp_arg += DEPRECATED_REGISTER_SIZE;
+                  val += DEPRECATED_REGISTER_SIZE;              

                 }
             }    
         }
                 }
             }    
         }

-      else if (len > (2 * REGISTER_SIZE))
+      else if (len > (2 * DEPRECATED_REGISTER_SIZE))

         {
           /* Data passed by reference.  Put it on the stack.  */
           write_memory (fp_mem, val, len);
         {
           /* Data passed by reference.  Put it on the stack.  */
           write_memory (fp_mem, val, len);

-          write_memory (fp_arg, (char *) (&fp_mem), REGISTER_SIZE);
+          write_memory (fp_arg, (char *) (&fp_mem), DEPRECATED_REGISTER_SIZE);

 
           /* fp_mem need not be word-aligned since it's just a chunk of
              memory being pointed at.  That is, += len would do.  */
 
           /* fp_mem need not be word-aligned since it's just a chunk of
              memory being pointed at.  That is, += len would do.  */

-          fp_mem += reg_demand * REGISTER_SIZE;
-          fp_arg += REGISTER_SIZE;
+          fp_mem += reg_demand * DEPRECATED_REGISTER_SIZE;
+          fp_arg += DEPRECATED_REGISTER_SIZE;

         }
       else
         {
         }
       else
         {


@@ -1497,7 +1488,7 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 
           /* fp_arg must be word-aligned (i.e., don't += len) to match
              the function prologue.  */
 
           /* fp_arg must be word-aligned (i.e., don't += len) to match
              the function prologue.  */

-          fp_arg += reg_demand * REGISTER_SIZE;
+          fp_arg += reg_demand * DEPRECATED_REGISTER_SIZE;

         }
     }
 
         }
     }
 


@@ -1520,13 +1511,15 @@ cris_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
    all saved registers.  */
 
 void 
    all saved registers.  */
 
 void 

-cris_pop_frame ()
+cris_pop_frame (void)

 {
   register struct frame_info *fi = get_current_frame ();
   register int regno;
   register int stack_offset = 0;
   
 {
   register struct frame_info *fi = get_current_frame ();
   register int regno;
   register int stack_offset = 0;
   

-  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+  if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi),
+                                  get_frame_base (fi),
+                                  get_frame_base (fi)))

     {
       /* This happens when we hit a breakpoint set at the entry point,
          when returning from a dummy frame.  */
     {
       /* This happens when we hit a breakpoint set at the entry point,
          when returning from a dummy frame.  */


@@ -1545,32 +1538,32 @@ cris_pop_frame ()
                                                      
       /* Restore general registers R0 - R7.  They were pushed on the stack 
          after SP was saved.  */
                                                      
       /* Restore general registers R0 - R7.  They were pushed on the stack 
          after SP was saved.  */

-      for (regno = 0; regno < FP_REGNUM; regno++)
+      for (regno = 0; regno < DEPRECATED_FP_REGNUM; regno++)

         {
         {

-          if (fi->saved_regs[regno])
+          if (get_frame_saved_regs (fi)[regno])

             {
               write_register (regno, 
             {
               write_register (regno, 

-                              read_memory_integer (fi->saved_regs[regno], 4));
+                              read_memory_integer (get_frame_saved_regs (fi)[regno], 4));

             }
         }
      
             }
         }
      

-      if (fi->saved_regs[FP_REGNUM])
+      if (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM])

         {
           /* Pop the frame pointer (R8).  It was pushed before SP 
              was saved.  */
         {
           /* Pop the frame pointer (R8).  It was pushed before SP 
              was saved.  */

-          write_register (FP_REGNUM, 
-                          read_memory_integer (fi->saved_regs[FP_REGNUM], 4));
+          write_register (DEPRECATED_FP_REGNUM, 
+                          read_memory_integer (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4));

           stack_offset += 4;
 
           /* Not a leaf function.  */
           stack_offset += 4;
 
           /* Not a leaf function.  */

-          if (fi->saved_regs[SRP_REGNUM])
+          if (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.  */
             {     
               /* SRP was pushed before SP was saved.  */
               stack_offset += 4;
             }
       
           /* Restore the SP and adjust for R8 and (possibly) SRP.  */

-          write_register (SP_REGNUM, fi->saved_regs[FP_REGNUM] + stack_offset);
+          write_register (SP_REGNUM, get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] + stack_offset);

         } 
       else
         {
         } 
       else
         {


@@ -1579,7 +1572,7 @@ cris_pop_frame ()
         }
     
       /* Restore the PC.  */
         }
     
       /* Restore the PC.  */

-      write_register (PC_REGNUM, fi->extra_info->return_pc);
+      write_register (PC_REGNUM, get_frame_extra_info (fi)->return_pc);

     }
   flush_cached_frames ();
 }
     }
   flush_cached_frames ();
 }


@@ -1878,8 +1871,7 @@ process_autoincrement (int size, unsigned short inst, inst_env_type *inst_env)
 
 /* Just a forward declaration.  */
 
 
 /* Just a forward declaration.  */
 

-unsigned long
-get_data_from_address (unsigned short *inst, CORE_ADDR address);
+unsigned long get_data_from_address (unsigned short *inst, CORE_ADDR address);

 
 /* Calculates the prefix value for the general case of offset addressing 
    mode.  */
 
 /* Calculates the prefix value for the general case of offset addressing 
    mode.  */


@@ -3558,7 +3550,7 @@ static void cris_gdb_func (enum cris_op_type op_type, unsigned short inst,
 static int
 cris_delayed_get_disassembler (bfd_vma addr, disassemble_info *info)
 {
 static int
 cris_delayed_get_disassembler (bfd_vma addr, disassemble_info *info)
 {

-  tm_print_insn = cris_get_disassembler (exec_bfd);
+  deprecated_tm_print_insn = cris_get_disassembler (exec_bfd);

   return TARGET_PRINT_INSN (addr, info);
 }
 
   return TARGET_PRINT_INSN (addr, info);
 }
 


@@ -3704,8 +3696,8 @@ cris_fpless_backtrace (char *noargs, int from_tty)
      function (since there's no push srp in that case).  */
   int innermost_frame = 1;
   
      function (since there's no push srp in that case).  */
   int innermost_frame = 1;
   

-  read_register_gen (PC_REGNUM, (char *) &pc);
-  read_register_gen (SP_REGNUM, (char *) &sp);
+  deprecated_read_register_gen (PC_REGNUM, (char *) &pc);
+  deprecated_read_register_gen (SP_REGNUM, (char *) &sp);

   
   /* We make an explicit return when we can't find an outer frame.  */
   while (1)
   
   /* We make an explicit return when we can't find an outer frame.  */
   while (1)


@@ -3844,7 +3836,7 @@ cris_fpless_backtrace (char *noargs, int from_tty)
           /* We couldn't find a push srp in the prologue, so this must be
              a leaf function, and thus we use the srp register directly.
              This should happen at most once, for the innermost function.  */
           /* We couldn't find a push srp in the prologue, so this must be
              a leaf function, and thus we use the srp register directly.
              This should happen at most once, for the innermost function.  */

-          read_register_gen (SRP_REGNUM, (char *) &pc);
+          deprecated_read_register_gen (SRP_REGNUM, (char *) &pc);

         }
       else
         {
         }
       else
         {


@@ -3871,7 +3863,7 @@ _initialize_cris_tdep (void)
   gdbarch_register (bfd_arch_cris, cris_gdbarch_init, cris_dump_tdep);
   
   /* Used in disassembly.  */
   gdbarch_register (bfd_arch_cris, cris_gdbarch_init, cris_dump_tdep);
   
   /* Used in disassembly.  */

-  tm_print_insn = cris_delayed_get_disassembler;
+  deprecated_tm_print_insn = cris_delayed_get_disassembler;

 
   /* CRIS-specific user-commands.  */
   c = add_set_cmd ("cris-version", class_support, var_integer, 
 
   /* CRIS-specific user-commands.  */
   c = add_set_cmd ("cris-version", class_support, var_integer, 


@@ -4018,7 +4010,7 @@ bfd_lookup_symbol (bfd *abfd, const char *symname)
   if (storage_needed > 0)
     {
       symbol_table = (asymbol **) xmalloc (storage_needed);
   if (storage_needed > 0)
     {
       symbol_table = (asymbol **) xmalloc (storage_needed);

-      back_to = make_cleanup (free, (PTR) symbol_table);
+      back_to = make_cleanup (free, symbol_table);

       number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 
       for (i = 0; i < number_of_symbols; i++)
       number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 
       for (i = 0; i < number_of_symbols; i++)


@@ -4100,17 +4092,19 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
           cris_abi = CRIS_ABI_V2;
         }
     }
           cris_abi = CRIS_ABI_V2;
         }
     }

-  else if (gdbarch_tdep (current_gdbarch))
+  else if (arches != NULL)

     {
     {

-      /* No bfd available.  Stick with whatever ABI we're currently using.  
-         (This is to avoid changing the ABI when the user updates the 
-         architecture with the 'set cris-version' command.)  */
-      cris_abi = gdbarch_tdep (current_gdbarch)->cris_abi;
+      /* No bfd available.  Stick with the ABI from the most recently
+         selected architecture of this same family (the head of arches
+         always points to this).  (This is to avoid changing the ABI
+         when the user updates the architecture with the 'set
+         cris-version' command.)  */
+      cris_abi = gdbarch_tdep (arches->gdbarch)->cris_abi;

     }
   else
     {
     }
   else
     {

-      /* No bfd, and no current architecture available.  Assume it's the 
-         new ABI.  */
+      /* No bfd, and no previously selected architecture available.
+         Assume it's the new ABI.  */

       cris_abi = CRIS_ABI_V2;
     }
 
       cris_abi = CRIS_ABI_V2;
     }
 


@@ -4135,6 +4129,10 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
   gdbarch = gdbarch_alloc (&info, tdep);
 
   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
   gdbarch = gdbarch_alloc (&info, tdep);
 

+  /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
+     ready to unwind the PC first (see frame.c:get_prev_frame()).  */
+  set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
+

   tdep->cris_version = cris_version;
   tdep->cris_mode = cris_mode;
   tdep->cris_abi = cris_abi;
   tdep->cris_version = cris_version;
   tdep->cris_mode = cris_mode;
   tdep->cris_abi = cris_abi;


@@ -4158,10 +4156,10 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   if (tdep->cris_abi == CRIS_ABI_ORIGINAL)
     {
       set_gdbarch_double_bit (gdbarch, 32);
   if (tdep->cris_abi == CRIS_ABI_ORIGINAL)
     {
       set_gdbarch_double_bit (gdbarch, 32);

-      set_gdbarch_push_arguments (gdbarch, cris_abi_original_push_arguments);
-      set_gdbarch_store_return_value (gdbarch, 
+      set_gdbarch_deprecated_push_arguments (gdbarch, cris_abi_original_push_arguments);
+      set_gdbarch_deprecated_store_return_value (gdbarch, 

                                       cris_abi_original_store_return_value);
                                       cris_abi_original_store_return_value);

-      set_gdbarch_extract_return_value 
+      set_gdbarch_deprecated_extract_return_value 

         (gdbarch, cris_abi_original_extract_return_value);
       set_gdbarch_reg_struct_has_addr 
         (gdbarch, cris_abi_original_reg_struct_has_addr);
         (gdbarch, cris_abi_original_extract_return_value);
       set_gdbarch_reg_struct_has_addr 
         (gdbarch, cris_abi_original_reg_struct_has_addr);


@@ -4169,10 +4167,10 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   else if (tdep->cris_abi == CRIS_ABI_V2)
     {
       set_gdbarch_double_bit (gdbarch, 64);
   else if (tdep->cris_abi == CRIS_ABI_V2)
     {
       set_gdbarch_double_bit (gdbarch, 64);

-      set_gdbarch_push_arguments (gdbarch, cris_abi_v2_push_arguments);
-      set_gdbarch_store_return_value (gdbarch, cris_abi_v2_store_return_value);
-      set_gdbarch_extract_return_value (gdbarch, 
-                                        cris_abi_v2_extract_return_value);
+      set_gdbarch_deprecated_push_arguments (gdbarch, cris_abi_v2_push_arguments);
+      set_gdbarch_deprecated_store_return_value (gdbarch, cris_abi_v2_store_return_value);
+      set_gdbarch_deprecated_extract_return_value
+       (gdbarch, cris_abi_v2_extract_return_value);

       set_gdbarch_reg_struct_has_addr (gdbarch, 
                                        cris_abi_v2_reg_struct_has_addr);
     }
       set_gdbarch_reg_struct_has_addr (gdbarch, 
                                        cris_abi_v2_reg_struct_has_addr);
     }


@@ -4186,14 +4184,14 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   /* There are 32 registers (some of which may not be implemented).  */
   set_gdbarch_num_regs (gdbarch, 32);
   set_gdbarch_sp_regnum (gdbarch, 14);
   /* There are 32 registers (some of which may not be implemented).  */
   set_gdbarch_num_regs (gdbarch, 32);
   set_gdbarch_sp_regnum (gdbarch, 14);

-  set_gdbarch_fp_regnum (gdbarch, 8);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, 8);

   set_gdbarch_pc_regnum (gdbarch, 15);
 
   set_gdbarch_register_name (gdbarch, cris_register_name);
   
   /* Length of ordinary registers used in push_word and a few other places. 
      REGISTER_RAW_SIZE is the real way to know how big a register is.  */
   set_gdbarch_pc_regnum (gdbarch, 15);
 
   set_gdbarch_register_name (gdbarch, cris_register_name);
   
   /* Length of ordinary registers used in push_word and a few other places. 
      REGISTER_RAW_SIZE is the real way to know how big a register is.  */

-  set_gdbarch_register_size (gdbarch, 4);
+  set_gdbarch_deprecated_register_size (gdbarch, 4);

   
   /* NEW */
   set_gdbarch_register_bytes_ok (gdbarch, cris_register_bytes_ok);
   
   /* NEW */
   set_gdbarch_register_bytes_ok (gdbarch, cris_register_bytes_ok);


@@ -4237,7 +4235,7 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       internal_error (__FILE__, __LINE__, "cris_gdbarch_init: unknown CRIS version");
     }
 
       internal_error (__FILE__, __LINE__, "cris_gdbarch_init: unknown CRIS version");
     }
 

-  set_gdbarch_register_bytes (gdbarch, register_bytes);
+  set_gdbarch_deprecated_register_bytes (gdbarch, register_bytes);

 
   /* Returns the register offset for the first byte of register regno's space 
      in the saved register state.  */
 
   /* Returns the register offset for the first byte of register regno's space 
      in the saved register state.  */


@@ -4247,60 +4245,41 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_register_raw_size (gdbarch, cris_register_size);
   
   /* The largest value REGISTER_RAW_SIZE can have.  */
   set_gdbarch_register_raw_size (gdbarch, cris_register_size);
   
   /* The largest value REGISTER_RAW_SIZE can have.  */

-  set_gdbarch_max_register_raw_size (gdbarch, 32);
+  set_gdbarch_deprecated_max_register_raw_size (gdbarch, 32);

   
   /* The length of the registers in the program's representation.  */
   set_gdbarch_register_virtual_size (gdbarch, cris_register_size);
   
   /* The largest value REGISTER_VIRTUAL_SIZE can have.  */
   
   /* The length of the registers in the program's representation.  */
   set_gdbarch_register_virtual_size (gdbarch, cris_register_size);
   
   /* The largest value REGISTER_VIRTUAL_SIZE can have.  */

-  set_gdbarch_max_register_virtual_size (gdbarch, 32);
+  set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 32);

 
   set_gdbarch_register_virtual_type (gdbarch, cris_register_virtual_type);
   
   /* Use generic dummy frames.  */
 
   set_gdbarch_register_virtual_type (gdbarch, cris_register_virtual_type);
   
   /* Use generic dummy frames.  */

-  set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
-  
-  /* Where to execute the call in the memory segments.  */
-  set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
-  set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
-  
-  /* Start execution at the beginning of dummy.  */
-  set_gdbarch_call_dummy_start_offset (gdbarch, 0);
-  set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
-  
-  /* Set to 1 since call_dummy_breakpoint_offset was defined.  */
-  set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);

   
   /* Read all about dummy frames in blockframe.c.  */
   
   /* Read all about dummy frames in blockframe.c.  */

-  set_gdbarch_call_dummy_length (gdbarch, 0);
-  set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
+  set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);

   
   /* Defined to 1 to indicate that the target supports inferior function 
      calls.  */
   
   /* Defined to 1 to indicate that the target supports inferior function 
      calls.  */

-  set_gdbarch_call_dummy_p (gdbarch, 1);
-  set_gdbarch_call_dummy_words (gdbarch, 0);
-  set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+  set_gdbarch_deprecated_call_dummy_words (gdbarch, 0);
+  set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);

   
   

-  /* No stack adjustment needed when peforming an inferior function call.  */
-  set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
-  set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
-
-  set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
+  set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);

   
   /* No register requires conversion from raw format to virtual format.  */
   set_gdbarch_register_convertible (gdbarch, generic_register_convertible_not);
 
   
   /* No register requires conversion from raw format to virtual format.  */
   set_gdbarch_register_convertible (gdbarch, generic_register_convertible_not);
 

-  set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
-  set_gdbarch_push_return_address (gdbarch, cris_push_return_address);
-  set_gdbarch_pop_frame (gdbarch, cris_pop_frame);
+  set_gdbarch_deprecated_push_return_address (gdbarch, cris_push_return_address);
+  set_gdbarch_deprecated_pop_frame (gdbarch, cris_pop_frame);

 
 

-  set_gdbarch_store_struct_return (gdbarch, cris_store_struct_return);
-  set_gdbarch_extract_struct_value_address (gdbarch, 
-                                            cris_extract_struct_value_address);
+  set_gdbarch_deprecated_store_struct_return (gdbarch, cris_store_struct_return);
+  set_gdbarch_deprecated_extract_struct_value_address
+    (gdbarch, cris_extract_struct_value_address);

   set_gdbarch_use_struct_convention (gdbarch, cris_use_struct_convention);
 
   set_gdbarch_use_struct_convention (gdbarch, cris_use_struct_convention);
 

-  set_gdbarch_frame_init_saved_regs (gdbarch, cris_frame_init_saved_regs);
-  set_gdbarch_init_extra_frame_info (gdbarch, cris_init_extra_frame_info);
+  set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, cris_frame_init_saved_regs);
+  set_gdbarch_deprecated_init_extra_frame_info (gdbarch, cris_init_extra_frame_info);

   set_gdbarch_skip_prologue (gdbarch, cris_skip_prologue);
   set_gdbarch_prologue_frameless_p (gdbarch, generic_prologue_frameless_p);
   
   set_gdbarch_skip_prologue (gdbarch, cris_skip_prologue);
   set_gdbarch_prologue_frameless_p (gdbarch, generic_prologue_frameless_p);
   


@@ -4321,22 +4300,19 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_frame_args_skip (gdbarch, 0);
   set_gdbarch_frameless_function_invocation 
     (gdbarch, cris_frameless_function_invocation);
   set_gdbarch_frame_args_skip (gdbarch, 0);
   set_gdbarch_frameless_function_invocation 
     (gdbarch, cris_frameless_function_invocation);

-  set_gdbarch_frame_chain (gdbarch, cris_frame_chain);
-  set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
+  set_gdbarch_deprecated_frame_chain (gdbarch, cris_frame_chain);

 
 

-  set_gdbarch_frame_saved_pc (gdbarch, cris_frame_saved_pc);
-  set_gdbarch_frame_args_address (gdbarch, cris_frame_args_address);
-  set_gdbarch_frame_locals_address (gdbarch, cris_frame_locals_address);
-  set_gdbarch_saved_pc_after_call (gdbarch, cris_saved_pc_after_call);
+  set_gdbarch_deprecated_frame_saved_pc (gdbarch, cris_frame_saved_pc);
+  set_gdbarch_deprecated_saved_pc_after_call (gdbarch, cris_saved_pc_after_call);

 
   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
   
 
   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
   

-  /* No extra stack alignment needed.  Set to 1 by default.  */
-  set_gdbarch_extra_stack_alignment_needed (gdbarch, 0);
-  

   /* Helpful for backtracing and returning in a call dummy.  */
   set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
 
   /* Helpful for backtracing and returning in a call dummy.  */
   set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
 

+  /* Should be using push_dummy_call.  */
+  set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
+

   /* Use target_specific function to define link map offsets.  */
   set_solib_svr4_fetch_link_map_offsets 
     (gdbarch, cris_linux_svr4_fetch_link_map_offsets);
   /* Use target_specific function to define link map offsets.  */
   set_solib_svr4_fetch_link_map_offsets 
     (gdbarch, cris_linux_svr4_fetch_link_map_offsets);