* gdbarch.sh (deprecated_register_size): Remove.

[deliverable/binutils-gdb.git] / gdb / infrun.c

diff --git a/gdb/infrun.c b/gdb/infrun.c
index db2c4a9f622b9b3f4522b587ed54dda7c3a318ab..bad50a1eca07ad0e3b37d8871bf60c1b3b0f560d 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -528,7 +528,8 @@ resume (int step, enum target_signal sig)
   if (breakpoint_here_p (read_pc ()) == permanent_breakpoint_here)
     {
       if (gdbarch_skip_permanent_breakpoint_p (current_gdbarch))
-       gdbarch_skip_permanent_breakpoint (current_gdbarch, current_regcache);
+       gdbarch_skip_permanent_breakpoint (current_gdbarch,
+                                          get_current_regcache ());
       else
        error (_("\
 The program is stopped at a permanent breakpoint, but GDB does not know\n\
@@ -539,7 +540,7 @@ a command like `return' or `jump' to continue execution."));
   if (SOFTWARE_SINGLE_STEP_P () && step)
     {
       /* Do it the hard way, w/temp breakpoints */
-      if (SOFTWARE_SINGLE_STEP (current_regcache))
+      if (SOFTWARE_SINGLE_STEP (get_current_frame ()))
         {
           /* ...and don't ask hardware to do it.  */
           step = 0;
@@ -1806,7 +1807,8 @@ handle_inferior_event (struct execution_control_state *ecs)
      will both be 0 if it doesn't work.  */
   find_pc_partial_function (stop_pc, &ecs->stop_func_name,
                            &ecs->stop_func_start, &ecs->stop_func_end);
-  ecs->stop_func_start += DEPRECATED_FUNCTION_START_OFFSET;
+  ecs->stop_func_start
+    += gdbarch_deprecated_function_start_offset (current_gdbarch);
   ecs->another_trap = 0;
   bpstat_clear (&stop_bpstat);
   stop_step = 0;
@@ -2077,7 +2079,8 @@ process_event_stop_test:
        remove_breakpoints ();
        breakpoints_inserted = 0;
        if (!gdbarch_get_longjmp_target_p (current_gdbarch)
-           || !gdbarch_get_longjmp_target (current_gdbarch, &jmp_buf_pc))
+           || !gdbarch_get_longjmp_target (current_gdbarch,
+                                           get_current_frame (), &jmp_buf_pc))
          {
            keep_going (ecs);
            return;
@@ -2456,9 +2459,10 @@ process_event_stop_test:
          function.  That's what tells us (a) whether we want to step
          into it at all, and (b) what prologue we want to run to the
          end of, if we do step into it.  */
-      real_stop_pc = skip_language_trampoline (stop_pc);
+      real_stop_pc = skip_language_trampoline (get_current_frame (), stop_pc);
       if (real_stop_pc == 0)
-       real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc);
+       real_stop_pc = gdbarch_skip_trampoline_code
+                        (current_gdbarch, get_current_frame (), stop_pc);
       if (real_stop_pc != 0)
        ecs->stop_func_start = real_stop_pc;
 
@@ -2516,10 +2520,13 @@ process_event_stop_test:
 
   /* If we're in the return path from a shared library trampoline,
      we want to proceed through the trampoline when stepping.  */
-  if (IN_SOLIB_RETURN_TRAMPOLINE (stop_pc, ecs->stop_func_name))
+  if (gdbarch_in_solib_return_trampoline (current_gdbarch,
+                                         stop_pc, ecs->stop_func_name))
     {
       /* Determine where this trampoline returns.  */
-      CORE_ADDR real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc);
+      CORE_ADDR real_stop_pc;
+      real_stop_pc = gdbarch_skip_trampoline_code
+                      (current_gdbarch, get_current_frame (), stop_pc);
 
       if (debug_infrun)
         fprintf_unfiltered (gdb_stdlog, "infrun: stepped into solib return tramp\n");
@@ -2709,7 +2716,8 @@ step_into_function (struct execution_control_state *ecs)
 
   s = find_pc_symtab (stop_pc);
   if (s && s->language != language_asm)
-    ecs->stop_func_start = SKIP_PROLOGUE (ecs->stop_func_start);
+    ecs->stop_func_start = gdbarch_skip_prologue
+                            (current_gdbarch, ecs->stop_func_start);
 
   ecs->sal = find_pc_line (ecs->stop_func_start, 0);
   /* Use the step_resume_break to step until the end of the prologue,
@@ -3212,7 +3220,7 @@ Further execution is probably impossible.\n"));
   if (proceed_to_finish)
     /* NB: The copy goes through to the target picking up the value of
        all the registers.  */
-    regcache_cpy (stop_registers, current_regcache);
+    regcache_cpy (stop_registers, get_current_regcache ());
 
   if (stop_stack_dummy)
     {
@@ -3669,7 +3677,7 @@ save_inferior_status (int restore_stack_info)
 
   inf_status->stop_registers = regcache_dup_no_passthrough (stop_registers);
 
-  inf_status->registers = regcache_dup (current_regcache);
+  inf_status->registers = regcache_dup (get_current_regcache ());
 
   inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
   return inf_status;
@@ -3724,7 +3732,7 @@ restore_inferior_status (struct inferior_status *inf_status)
      (and perhaps other times).  */
   if (target_has_execution)
     /* NB: The register write goes through to the target.  */
-    regcache_cpy (current_regcache, inf_status->registers);
+    regcache_cpy (get_current_regcache (), inf_status->registers);
   regcache_xfree (inf_status->registers);
 
   /* FIXME: If we are being called after stopping in a function which