2003-02-18 Elena Zannoni <ezannoni@redhat.com>

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

diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c
index 860286eb48e96d8b49a0c7eccf70452777d7ab1e..5911318266875aebd91d8755048a66548f43cd58 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.
 


@@ -392,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
 


@@ -405,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.


@@ -487,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;


@@ -500,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.  */


@@ -526,7 +527,7 @@ 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 == FP_REGNUM)
             {


@@ -675,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)[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;


@@ -733,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. 


@@ -753,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;
 }
 


@@ -972,7 +972,7 @@ cris_abi_original_store_return_value (struct type *type, char *valbuf)
   int len = TYPE_LENGTH (type);
   
   if (len <= REGISTER_SIZE) 
   int len = TYPE_LENGTH (type);
   
   if (len <= REGISTER_SIZE) 

-    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_original_store_return_value: type length too large.");
 }
   else
     internal_error (__FILE__, __LINE__, "cris_abi_original_store_return_value: type length too large.");
 }


@@ -987,7 +987,8 @@ cris_abi_v2_store_return_value (struct type *type, char *valbuf)
   if (len <= 2 * REGISTER_SIZE)
     {
       /* Note that this works since R10 and R11 are consecutive registers.  */
   if (len <= 2 * REGISTER_SIZE)
     {
       /* 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.");


@@ -1139,7 +1140,7 @@ 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);


@@ -1147,8 +1148,7 @@ cris_frameless_function_invocation (struct frame_info *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
 
 /* 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.  */
+   be allocated by 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)


@@ -1156,13 +1156,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 = deprecated_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);


@@ -1172,11 +1173,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_pc_function_start (get_frame_pc (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


@@ -1199,29 +1200,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, 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.  */
     {    
       /* We need to setup fi->frame here because run_stack_dummy gets it wrong
          by assuming it's always FP.  */

-      fi->frame = deprecated_read_register_dummy (fi->pc, fi->frame,
-                                                 SP_REGNUM);
-      fi->extra_info->return_pc = 
-        deprecated_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
+      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
     {


@@ -1229,19 +1231,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;

         }
     }
 }
         }
     }
 }


@@ -1252,13 +1254,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
     {


@@ -1271,25 +1275,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.  */


@@ -1528,7 +1514,9 @@ cris_pop_frame (void)
   register int regno;
   register int stack_offset = 0;
   
   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.  */


@@ -1549,30 +1537,30 @@ cris_pop_frame (void)
          after SP was saved.  */
       for (regno = 0; regno < FP_REGNUM; regno++)
         {
          after SP was saved.  */
       for (regno = 0; regno < 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)[FP_REGNUM])

         {
           /* Pop the frame pointer (R8).  It was pushed before SP 
              was saved.  */
           write_register (FP_REGNUM, 
         {
           /* 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));
+                          read_memory_integer (get_frame_saved_regs (fi)[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)[FP_REGNUM] + stack_offset);

         } 
       else
         {
         } 
       else
         {


@@ -1581,7 +1569,7 @@ cris_pop_frame (void)
         }
     
       /* 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 ();
 }


@@ -1880,8 +1868,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.  */


@@ -4020,7 +4007,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++)


@@ -4139,6 +4126,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;


@@ -4262,10 +4253,8 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   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.  */
   
   /* 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_address (gdbarch, entry_point_address);
   
   /* Start execution at the beginning of dummy.  */


@@ -4277,7 +4266,7 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   
   /* Read all about dummy frames in blockframe.c.  */
   set_gdbarch_call_dummy_length (gdbarch, 0);
   
   /* 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.  */


@@ -4326,11 +4315,8 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_frameless_function_invocation 
     (gdbarch, cris_frameless_function_invocation);
   set_gdbarch_frame_chain (gdbarch, cris_frame_chain);
   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_frame_saved_pc (gdbarch, cris_frame_saved_pc);
 
   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_frame_num_args (gdbarch, frame_num_args_unknown);
   set_gdbarch_saved_pc_after_call (gdbarch, cris_saved_pc_after_call);
 
   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);