aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorAndrew Cagney <cagney@redhat.com>2004-08-25 14:47:07 +0000
committerAndrew Cagney <cagney@redhat.com>2004-08-25 14:47:07 +0000
commit8fb3e588da490f3506c978264bdb2da01f3b6b51 (patch)
tree9d8f5a65ee07717d57e06006d26adf034b0bb966
parentf855931bbd914039754674f6f582a7236583f62b (diff)
downloadgdb-8fb3e588da490f3506c978264bdb2da01f3b6b51.zip
gdb-8fb3e588da490f3506c978264bdb2da01f3b6b51.tar.gz
gdb-8fb3e588da490f3506c978264bdb2da01f3b6b51.tar.bz2
2004-08-25 Andrew Cagney <cagney@gnu.org>
* infrun.c: Re-indent. Move expression operators to the beginning of the line. Remove long disabled #if 0 code.
-rw-r--r--gdb/ChangeLog5
-rw-r--r--gdb/infrun.c419
2 files changed, 194 insertions, 230 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 147f8cb..3014c58 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+2004-08-25 Andrew Cagney <cagney@gnu.org>
+
+ * infrun.c: Re-indent. Move expression operators to the beginning
+ of the line. Remove long disabled #if 0 code.
+
2004-08-24 Andrew Cagney <cagney@gnu.org>
* doublest.h (floatformat_ieee_quad): Rename
diff --git a/gdb/infrun.c b/gdb/infrun.c
index d44dd0d..b0c5eab 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -580,9 +580,9 @@ resume (int step, enum target_signal sig)
resume_ptid = RESUME_ALL; /* Default */
- if ((step || singlestep_breakpoints_inserted_p) &&
- (stepping_past_singlestep_breakpoint
- || (!breakpoints_inserted && breakpoint_here_p (read_pc ()))))
+ if ((step || singlestep_breakpoints_inserted_p)
+ && (stepping_past_singlestep_breakpoint
+ || (!breakpoints_inserted && breakpoint_here_p (read_pc ()))))
{
/* Stepping past a breakpoint without inserting breakpoints.
Make sure only the current thread gets to step, so that
@@ -592,9 +592,9 @@ resume (int step, enum target_signal sig)
resume_ptid = inferior_ptid;
}
- if ((scheduler_mode == schedlock_on) ||
- (scheduler_mode == schedlock_step &&
- (step || singlestep_breakpoints_inserted_p)))
+ if ((scheduler_mode == schedlock_on)
+ || (scheduler_mode == schedlock_step
+ && (step || singlestep_breakpoints_inserted_p)))
{
/* User-settable 'scheduler' mode requires solo thread resume. */
resume_ptid = inferior_ptid;
@@ -649,8 +649,8 @@ prepare_to_proceed (void)
/* Make sure we were stopped either at a breakpoint, or because
of a Ctrl-C. */
if (wait_status.kind != TARGET_WAITKIND_STOPPED
- || (wait_status.value.sig != TARGET_SIGNAL_TRAP &&
- wait_status.value.sig != TARGET_SIGNAL_INT))
+ || (wait_status.value.sig != TARGET_SIGNAL_TRAP
+ && wait_status.value.sig != TARGET_SIGNAL_INT))
{
return 0;
}
@@ -674,15 +674,15 @@ prepare_to_proceed (void)
select_frame (get_current_frame ());
}
- /* We return 1 to indicate that there is a breakpoint here,
- so we need to step over it before continuing to avoid
- hitting it straight away. */
- if (breakpoint_here_p (wait_pc))
- return 1;
+ /* We return 1 to indicate that there is a breakpoint here,
+ so we need to step over it before continuing to avoid
+ hitting it straight away. */
+ if (breakpoint_here_p (wait_pc))
+ return 1;
}
return 0;
-
+
}
/* Record the pc of the program the last time it stopped. This is
@@ -761,7 +761,7 @@ proceed (CORE_ADDR addr, enum target_signal siggnal, int step)
{
insert_breakpoints ();
/* If we get here there was no call to error() in
- insert breakpoints -- so they were inserted. */
+ insert breakpoints -- so they were inserted. */
breakpoints_inserted = 1;
}
@@ -799,7 +799,7 @@ proceed (CORE_ADDR addr, enum target_signal siggnal, int step)
cannot be read unless the inferior is stopped. At that point, we
are not guaranteed the inferior is stopped and so the read_pc ()
call can fail. Setting the prev_pc value here ensures the value is
- updated correctly when the inferior is stopped. */
+ updated correctly when the inferior is stopped. */
prev_pc = read_pc ();
/* Resume inferior. */
@@ -937,7 +937,8 @@ void handle_inferior_event (struct execution_control_state *ecs);
static void step_into_function (struct execution_control_state *ecs);
static void insert_step_resume_breakpoint (struct frame_info *step_frame,
- struct execution_control_state *ecs);
+ struct execution_control_state
+ *ecs);
static void stop_stepping (struct execution_control_state *ecs);
static void prepare_to_wait (struct execution_control_state *ecs);
static void keep_going (struct execution_control_state *ecs);
@@ -1161,14 +1162,14 @@ adjust_pc_after_break (struct execution_control_state *ecs)
affected by DECR_PC_AFTER_BREAK. Other waitkinds which are implemented
by software breakpoints should be handled through the normal breakpoint
layer.
-
+
NOTE drow/2004-01-31: On some targets, breakpoints may generate
different signals (SIGILL or SIGEMT for instance), but it is less
clear where the PC is pointing afterwards. It may not match
DECR_PC_AFTER_BREAK. I don't know any specific target that generates
these signals at breakpoints (the code has been in GDB since at least
1992) so I can not guess how to handle them here.
-
+
In earlier versions of GDB, a target with HAVE_NONSTEPPABLE_WATCHPOINTS
would have the PC after hitting a watchpoint affected by
DECR_PC_AFTER_BREAK. I haven't found any target with both of these set
@@ -1188,8 +1189,8 @@ adjust_pc_after_break (struct execution_control_state *ecs)
if (SOFTWARE_SINGLE_STEP_P ())
{
/* When using software single-step, a SIGTRAP can only indicate
- an inserted breakpoint. This actually makes things
- easier. */
+ an inserted breakpoint. This actually makes things
+ easier. */
if (singlestep_breakpoints_inserted_p)
/* When software single stepping, the instruction at [prev_pc]
is never a breakpoint, but the instruction following
@@ -1205,9 +1206,9 @@ adjust_pc_after_break (struct execution_control_state *ecs)
else
{
/* When using hardware single-step, a SIGTRAP is reported for
- both a completed single-step and a software breakpoint. Need
- to differentiate between the two as the latter needs
- adjusting but the former does not. */
+ both a completed single-step and a software breakpoint. Need
+ to differentiate between the two as the latter needs
+ adjusting but the former does not. */
if (currently_stepping (ecs))
{
if (prev_pc == breakpoint_pc
@@ -1245,7 +1246,7 @@ handle_inferior_event (struct execution_control_state *ecs)
defined in the file "config/pa/nm-hppah.h", accesses the variable
indirectly. Mutter something rude about the HP merge. */
int sw_single_step_trap_p = 0;
- int stopped_by_watchpoint = -1; /* Mark as unknown. */
+ int stopped_by_watchpoint = -1; /* Mark as unknown. */
/* Cache the last pid/waitstatus. */
target_last_wait_ptid = ecs->ptid;
@@ -1313,31 +1314,6 @@ handle_inferior_event (struct execution_control_state *ecs)
ui_out_text (uiout, "[New ");
ui_out_text (uiout, target_pid_or_tid_to_str (ecs->ptid));
ui_out_text (uiout, "]\n");
-
-#if 0
- /* NOTE: This block is ONLY meant to be invoked in case of a
- "thread creation event"! If it is invoked for any other
- sort of event (such as a new thread landing on a breakpoint),
- the event will be discarded, which is almost certainly
- a bad thing!
-
- To avoid this, the low-level module (eg. target_wait)
- should call in_thread_list and add_thread, so that the
- new thread is known by the time we get here. */
-
- /* We may want to consider not doing a resume here in order
- to give the user a chance to play with the new thread.
- It might be good to make that a user-settable option. */
-
- /* At this point, all threads are stopped (happens
- automatically in either the OS or the native code).
- Therefore we need to continue all threads in order to
- make progress. */
-
- target_resume (RESUME_ALL, 0, TARGET_SIGNAL_0);
- prepare_to_wait (ecs);
- return;
-#endif
}
switch (ecs->ws.kind)
@@ -1360,20 +1336,20 @@ handle_inferior_event (struct execution_control_state *ecs)
breakpoint_re_set. */
target_terminal_ours_for_output ();
/* NOTE: cagney/2003-11-25: Make certain that the target
- stack's section table is kept up-to-date. Architectures,
- (e.g., PPC64), use the section table to perform
- operations such as address => section name and hence
- require the table to contain all sections (including
- those found in shared libraries). */
+ stack's section table is kept up-to-date. Architectures,
+ (e.g., PPC64), use the section table to perform
+ operations such as address => section name and hence
+ require the table to contain all sections (including
+ those found in shared libraries). */
/* NOTE: cagney/2003-11-25: Pass current_target and not
- exec_ops to SOLIB_ADD. This is because current GDB is
- only tooled to propagate section_table changes out from
- the "current_target" (see target_resize_to_sections), and
- not up from the exec stratum. This, of course, isn't
- right. "infrun.c" should only interact with the
- exec/process stratum, instead relying on the target stack
- to propagate relevant changes (stop, section table
- changed, ...) up to other layers. */
+ exec_ops to SOLIB_ADD. This is because current GDB is
+ only tooled to propagate section_table changes out from
+ the "current_target" (see target_resize_to_sections), and
+ not up from the exec stratum. This, of course, isn't
+ right. "infrun.c" should only interact with the
+ exec/process stratum, instead relying on the target stack
+ to propagate relevant changes (stop, section table
+ changed, ...) up to other layers. */
SOLIB_ADD (NULL, 0, &current_target, auto_solib_add);
target_terminal_inferior ();
@@ -1453,8 +1429,8 @@ handle_inferior_event (struct execution_control_state *ecs)
stop_signal = TARGET_SIGNAL_TRAP;
/* NOTE drow/2002-12-05: This code should be pushed down into the
- target_wait function. Until then following vfork on HP/UX 10.20
- is probably broken by this. Of course, it's broken anyway. */
+ target_wait function. Until then following vfork on HP/UX 10.20
+ is probably broken by this. Of course, it's broken anyway. */
/* Is this a target which reports multiple exec events per actual
call to exec()? (HP-UX using ptrace does, for example.) If so,
ignore all but the last one. Just resume the exec'r, and wait
@@ -1559,12 +1535,12 @@ handle_inferior_event (struct execution_control_state *ecs)
/* We had an event in the inferior, but we are not interested
in handling it at this level. The lower layers have already
done what needs to be done, if anything.
-
- One of the possible circumstances for this is when the
- inferior produces output for the console. The inferior has
- not stopped, and we are ignoring the event. Another possible
- circumstance is any event which the lower level knows will be
- reported multiple times without an intervening resume. */
+
+ One of the possible circumstances for this is when the
+ inferior produces output for the console. The inferior has
+ not stopped, and we are ignoring the event. Another possible
+ circumstance is any event which the lower level knows will be
+ reported multiple times without an intervening resume. */
case TARGET_WAITKIND_IGNORE:
prepare_to_wait (ecs);
return;
@@ -1588,17 +1564,18 @@ handle_inferior_event (struct execution_control_state *ecs)
if (stepping_past_singlestep_breakpoint)
{
- gdb_assert (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p);
+ gdb_assert (SOFTWARE_SINGLE_STEP_P ()
+ && singlestep_breakpoints_inserted_p);
gdb_assert (ptid_equal (singlestep_ptid, ecs->ptid));
gdb_assert (!ptid_equal (singlestep_ptid, saved_singlestep_ptid));
stepping_past_singlestep_breakpoint = 0;
/* We've either finished single-stepping past the single-step
- breakpoint, or stopped for some other reason. It would be nice if
- we could tell, but we can't reliably. */
+ breakpoint, or stopped for some other reason. It would be nice if
+ we could tell, but we can't reliably. */
if (stop_signal == TARGET_SIGNAL_TRAP)
- {
+ {
/* Pull the single step breakpoints out of the target. */
SOFTWARE_SINGLE_STEP (0, 0);
singlestep_breakpoints_inserted_p = 0;
@@ -1652,66 +1629,66 @@ handle_inferior_event (struct execution_control_state *ecs)
}
if (thread_hop_needed)
- {
- int remove_status;
+ {
+ int remove_status;
- /* Saw a breakpoint, but it was hit by the wrong thread.
- Just continue. */
+ /* Saw a breakpoint, but it was hit by the wrong thread.
+ Just continue. */
- if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p)
- {
- /* Pull the single step breakpoints out of the target. */
- SOFTWARE_SINGLE_STEP (0, 0);
- singlestep_breakpoints_inserted_p = 0;
- }
+ if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p)
+ {
+ /* Pull the single step breakpoints out of the target. */
+ SOFTWARE_SINGLE_STEP (0, 0);
+ singlestep_breakpoints_inserted_p = 0;
+ }
- remove_status = remove_breakpoints ();
- /* Did we fail to remove breakpoints? If so, try
- to set the PC past the bp. (There's at least
- one situation in which we can fail to remove
- the bp's: On HP-UX's that use ttrace, we can't
- change the address space of a vforking child
- process until the child exits (well, okay, not
- then either :-) or execs. */
- if (remove_status != 0)
- {
- /* FIXME! This is obviously non-portable! */
- write_pc_pid (stop_pc + 4, ecs->ptid);
- /* We need to restart all the threads now,
- * unles we're running in scheduler-locked mode.
- * Use currently_stepping to determine whether to
- * step or continue.
- */
- /* FIXME MVS: is there any reason not to call resume()? */
- if (scheduler_mode == schedlock_on)
- target_resume (ecs->ptid,
- currently_stepping (ecs), TARGET_SIGNAL_0);
- else
- target_resume (RESUME_ALL,
- currently_stepping (ecs), TARGET_SIGNAL_0);
- prepare_to_wait (ecs);
- return;
- }
+ remove_status = remove_breakpoints ();
+ /* Did we fail to remove breakpoints? If so, try
+ to set the PC past the bp. (There's at least
+ one situation in which we can fail to remove
+ the bp's: On HP-UX's that use ttrace, we can't
+ change the address space of a vforking child
+ process until the child exits (well, okay, not
+ then either :-) or execs. */
+ if (remove_status != 0)
+ {
+ /* FIXME! This is obviously non-portable! */
+ write_pc_pid (stop_pc + 4, ecs->ptid);
+ /* We need to restart all the threads now,
+ * unles we're running in scheduler-locked mode.
+ * Use currently_stepping to determine whether to
+ * step or continue.
+ */
+ /* FIXME MVS: is there any reason not to call resume()? */
+ if (scheduler_mode == schedlock_on)
+ target_resume (ecs->ptid,
+ currently_stepping (ecs), TARGET_SIGNAL_0);
else
- { /* Single step */
- breakpoints_inserted = 0;
- if (!ptid_equal (inferior_ptid, ecs->ptid))
- context_switch (ecs);
- ecs->waiton_ptid = ecs->ptid;
- ecs->wp = &(ecs->ws);
- ecs->another_trap = 1;
-
- ecs->infwait_state = infwait_thread_hop_state;
- keep_going (ecs);
- registers_changed ();
- return;
- }
+ target_resume (RESUME_ALL,
+ currently_stepping (ecs), TARGET_SIGNAL_0);
+ prepare_to_wait (ecs);
+ return;
+ }
+ else
+ { /* Single step */
+ breakpoints_inserted = 0;
+ if (!ptid_equal (inferior_ptid, ecs->ptid))
+ context_switch (ecs);
+ ecs->waiton_ptid = ecs->ptid;
+ ecs->wp = &(ecs->ws);
+ ecs->another_trap = 1;
+
+ ecs->infwait_state = infwait_thread_hop_state;
+ keep_going (ecs);
+ registers_changed ();
+ return;
+ }
}
else if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p)
- {
- sw_single_step_trap_p = 1;
- ecs->random_signal = 0;
- }
+ {
+ sw_single_step_trap_p = 1;
+ ecs->random_signal = 0;
+ }
}
else
ecs->random_signal = 1;
@@ -1840,12 +1817,11 @@ handle_inferior_event (struct execution_control_state *ecs)
stack. */
if (stop_signal == TARGET_SIGNAL_TRAP
- || (breakpoints_inserted &&
- (stop_signal == TARGET_SIGNAL_ILL
- || stop_signal == TARGET_SIGNAL_SEGV
- || stop_signal == TARGET_SIGNAL_EMT))
- || stop_soon == STOP_QUIETLY
- || stop_soon == STOP_QUIETLY_NO_SIGSTOP)
+ || (breakpoints_inserted
+ && (stop_signal == TARGET_SIGNAL_ILL
+ || stop_signal == TARGET_SIGNAL_SEGV
+ || stop_signal == TARGET_SIGNAL_EMT))
+ || stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_NO_SIGSTOP)
{
if (stop_signal == TARGET_SIGNAL_TRAP && stop_after_trap)
{
@@ -1881,7 +1857,7 @@ handle_inferior_event (struct execution_control_state *ecs)
else
{
/* See if there is a breakpoint at the current PC. */
- stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid,
+ stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid,
stopped_by_watchpoint);
/* Following in case break condition called a
@@ -1890,13 +1866,13 @@ handle_inferior_event (struct execution_control_state *ecs)
}
/* NOTE: cagney/2003-03-29: These two checks for a random signal
- at one stage in the past included checks for an inferior
- function call's call dummy's return breakpoint. The original
- comment, that went with the test, read:
+ at one stage in the past included checks for an inferior
+ function call's call dummy's return breakpoint. The original
+ comment, that went with the test, read:
- ``End of a stack dummy. Some systems (e.g. Sony news) give
- another signal besides SIGTRAP, so check here as well as
- above.''
+ ``End of a stack dummy. Some systems (e.g. Sony news) give
+ another signal besides SIGTRAP, so check here as well as
+ above.''
If someone ever tries to get get call dummys on a
non-executable stack to work (where the target would stop
@@ -1905,9 +1881,9 @@ handle_inferior_event (struct execution_control_state *ecs)
enabled when momentary breakpoints were not being used, I
suspect that it won't be the case.
- NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
- be necessary for call dummies on a non-executable stack on
- SPARC. */
+ NOTE: kettenis/2004-02-05: Indeed such checks don't seem to
+ be necessary for call dummies on a non-executable stack on
+ SPARC. */
if (stop_signal == TARGET_SIGNAL_TRAP)
ecs->random_signal
@@ -2014,13 +1990,7 @@ process_event_stop_test:
delete_step_resume_breakpoint (&step_resume_breakpoint);
}
-#if 0
- /* FIXME - Need to implement nested temporary breakpoints */
- if (step_over_calls > 0)
- set_longjmp_resume_breakpoint (jmp_buf_pc, get_current_frame ());
- else
-#endif /* 0 */
- set_longjmp_resume_breakpoint (jmp_buf_pc, null_frame_id);
+ set_longjmp_resume_breakpoint (jmp_buf_pc, null_frame_id);
ecs->handling_longjmp = 1; /* FIXME */
keep_going (ecs);
return;
@@ -2029,17 +1999,6 @@ process_event_stop_test:
case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE:
remove_breakpoints ();
breakpoints_inserted = 0;
-#if 0
- /* FIXME - Need to implement nested temporary breakpoints */
- if (step_over_calls
- && (frame_id_inner (get_frame_id (get_current_frame ()),
- step_frame_id)))
- {
- ecs->another_trap = 1;
- keep_going (ecs);
- return;
- }
-#endif /* 0 */
disable_longjmp_breakpoint ();
ecs->handling_longjmp = 0; /* FIXME */
if (what.main_action == BPSTAT_WHAT_CLEAR_LONGJMP_RESUME)
@@ -2125,20 +2084,20 @@ process_event_stop_test:
breakpoint_re_set. */
target_terminal_ours_for_output ();
/* NOTE: cagney/2003-11-25: Make certain that the target
- stack's section table is kept up-to-date. Architectures,
- (e.g., PPC64), use the section table to perform
- operations such as address => section name and hence
- require the table to contain all sections (including
- those found in shared libraries). */
+ stack's section table is kept up-to-date. Architectures,
+ (e.g., PPC64), use the section table to perform
+ operations such as address => section name and hence
+ require the table to contain all sections (including
+ those found in shared libraries). */
/* NOTE: cagney/2003-11-25: Pass current_target and not
- exec_ops to SOLIB_ADD. This is because current GDB is
- only tooled to propagate section_table changes out from
- the "current_target" (see target_resize_to_sections), and
- not up from the exec stratum. This, of course, isn't
- right. "infrun.c" should only interact with the
- exec/process stratum, instead relying on the target stack
- to propagate relevant changes (stop, section table
- changed, ...) up to other layers. */
+ exec_ops to SOLIB_ADD. This is because current GDB is
+ only tooled to propagate section_table changes out from
+ the "current_target" (see target_resize_to_sections), and
+ not up from the exec stratum. This, of course, isn't
+ right. "infrun.c" should only interact with the
+ exec/process stratum, instead relying on the target stack
+ to propagate relevant changes (stop, section table
+ changed, ...) up to other layers. */
SOLIB_ADD (NULL, 0, &current_target, auto_solib_add);
target_terminal_inferior ();
@@ -2166,8 +2125,8 @@ process_event_stop_test:
the call that caused this catchpoint to trigger. That
gives the user a more useful vantage from which to
examine their program's state. */
- else if (what.main_action ==
- BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK)
+ else if (what.main_action
+ == BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK)
{
/* ??rehrauer: If I could figure out how to get the
right return PC from here, we could just set a temp
@@ -2304,20 +2263,19 @@ process_event_stop_test:
&& get_frame_type (get_current_frame ()) == SIGTRAMP_FRAME)
{
/* The inferior, while doing a "step" or "next", has ended up in
- a signal trampoline (either by a signal being delivered or by
- the signal handler returning). Just single-step until the
- inferior leaves the trampoline (either by calling the handler
- or returning). */
+ a signal trampoline (either by a signal being delivered or by
+ the signal handler returning). Just single-step until the
+ inferior leaves the trampoline (either by calling the handler
+ or returning). */
keep_going (ecs);
return;
}
- if (frame_id_eq (frame_unwind_id (get_current_frame ()),
- step_frame_id))
+ if (frame_id_eq (frame_unwind_id (get_current_frame ()), step_frame_id))
{
/* It's a subroutine call. */
CORE_ADDR real_stop_pc;
-
+
if ((step_over_calls == STEP_OVER_NONE)
|| ((step_range_end == 1)
&& in_prologue (prev_pc, ecs->stop_func_start)))
@@ -2333,25 +2291,25 @@ process_event_stop_test:
stop_stepping (ecs);
return;
}
-
+
#ifdef DEPRECATED_IGNORE_HELPER_CALL
/* On MIPS16, a function that returns a floating point value may
- call a library helper function to copy the return value to a
- floating point register. The DEPRECATED_IGNORE_HELPER_CALL
- macro returns non-zero if we should ignore (i.e. step over)
- this function call. */
+ call a library helper function to copy the return value to a
+ floating point register. The DEPRECATED_IGNORE_HELPER_CALL
+ macro returns non-zero if we should ignore (i.e. step over)
+ this function call. */
/* FIXME: cagney/2004-07-21: These custom ``ignore frame when
- stepping'' function attributes (SIGTRAMP_FRAME,
- DEPRECATED_IGNORE_HELPER_CALL, SKIP_TRAMPOLINE_CODE,
- skip_language_trampoline frame, et.al.) need to be replaced
- with generic attributes bound to the frame's function. */
+ stepping'' function attributes (SIGTRAMP_FRAME,
+ DEPRECATED_IGNORE_HELPER_CALL, SKIP_TRAMPOLINE_CODE,
+ skip_language_trampoline frame, et.al.) need to be replaced
+ with generic attributes bound to the frame's function. */
if (DEPRECATED_IGNORE_HELPER_CALL (stop_pc))
{
/* We're doing a "next", set a breakpoint at callee's return
address (the address at which the caller will
resume). */
- insert_step_resume_breakpoint (get_prev_frame (get_current_frame ()),
- ecs);
+ insert_step_resume_breakpoint (get_prev_frame
+ (get_current_frame ()), ecs);
keep_going (ecs);
return;
}
@@ -2361,23 +2319,23 @@ process_event_stop_test:
/* We're doing a "next", set a breakpoint at callee's return
address (the address at which the caller will
resume). */
- insert_step_resume_breakpoint (get_prev_frame (get_current_frame ()),
- ecs);
+ insert_step_resume_breakpoint (get_prev_frame
+ (get_current_frame ()), ecs);
keep_going (ecs);
return;
}
/* If we are in a function call trampoline (a stub between the
- calling routine and the real function), locate the real
- 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. */
+ calling routine and the real function), locate the real
+ 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);
if (real_stop_pc == 0)
real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc);
if (real_stop_pc != 0)
ecs->stop_func_start = real_stop_pc;
-
+
if (IN_SOLIB_DYNSYM_RESOLVE_CODE (ecs->stop_func_start))
{
struct symtab_and_line sr_sal;
@@ -2390,19 +2348,19 @@ process_event_stop_test:
if (breakpoints_inserted)
insert_breakpoints ();
- keep_going (ecs);
- return;
+ keep_going (ecs);
+ return;
}
/* If we have line number information for the function we are
- thinking of stepping into, step into it.
+ thinking of stepping into, step into it.
- If there are several symtabs at that PC (e.g. with include
- files), just want to know whether *any* of them have line
- numbers. find_pc_line handles this. */
+ If there are several symtabs at that PC (e.g. with include
+ files), just want to know whether *any* of them have line
+ numbers. find_pc_line handles this. */
{
struct symtab_and_line tmp_sal;
-
+
tmp_sal = find_pc_line (ecs->stop_func_start, 0);
if (tmp_sal.line != 0)
{
@@ -2412,8 +2370,8 @@ process_event_stop_test:
}
/* If we have no line number and the step-stop-if-no-debug is
- set, we stop the step so that the user has a chance to switch
- in assembly mode. */
+ set, we stop the step so that the user has a chance to switch
+ in assembly mode. */
if (step_over_calls == STEP_OVER_UNDEBUGGABLE && step_stop_if_no_debug)
{
stop_step = 1;
@@ -2423,8 +2381,9 @@ process_event_stop_test:
}
/* Set a breakpoint at callee's return address (the address at
- which the caller will resume). */
- insert_step_resume_breakpoint (get_prev_frame (get_current_frame ()), ecs);
+ which the caller will resume). */
+ insert_step_resume_breakpoint (get_prev_frame (get_current_frame ()),
+ ecs);
keep_going (ecs);
return;
}
@@ -2487,8 +2446,8 @@ process_event_stop_test:
{
/* Set a breakpoint at callee's return address (the address
at which the caller will resume). */
- insert_step_resume_breakpoint (get_prev_frame (get_current_frame ()),
- ecs);
+ insert_step_resume_breakpoint (get_prev_frame
+ (get_current_frame ()), ecs);
keep_going (ecs);
return;
}
@@ -2566,15 +2525,15 @@ process_event_stop_test:
stackless leaf function. I think the logic should instead look
at the unwound frame ID has that should give a more robust
indication of what happened. */
- if (step-ID == current-ID)
- still stepping in same function;
- else if (step-ID == unwind (current-ID))
- stepped into a function;
- else
- stepped out of a function;
- /* Of course this assumes that the frame ID unwind code is robust
- and we're willing to introduce frame unwind logic into this
- function. Fortunately, those days are nearly upon us. */
+ if (step - ID == current - ID)
+ still stepping in same function;
+ else if (step - ID == unwind (current - ID))
+ stepped into a function;
+ else
+ stepped out of a function;
+ /* Of course this assumes that the frame ID unwind code is robust
+ and we're willing to introduce frame unwind logic into this
+ function. Fortunately, those days are nearly upon us. */
#endif
{
struct frame_id current_frame = get_frame_id (get_current_frame ());
@@ -2627,7 +2586,7 @@ step_into_function (struct execution_control_state *ecs)
``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
ecs->stop_func_start to an address at which a breakpoint may be
legitimately placed.
-
+
Note: kevinb/2004-01-19: On FR-V, if this adjustment is not
made, GDB will enter an infinite loop when stepping through
optimized code consisting of VLIW instructions which contain
@@ -2637,12 +2596,12 @@ step_into_function (struct execution_control_state *ecs)
set, GDB will adjust the breakpoint address to the beginning of
the VLIW instruction. Thus, we need to make the corresponding
adjustment here when computing the stop address. */
-
+
if (gdbarch_adjust_breakpoint_address_p (current_gdbarch))
{
ecs->stop_func_start
= gdbarch_adjust_breakpoint_address (current_gdbarch,
- ecs->stop_func_start);
+ ecs->stop_func_start);
}
if (ecs->stop_func_start == stop_pc)
@@ -3024,8 +2983,8 @@ normal_stop (void)
{
case PRINT_UNKNOWN:
/* FIXME: cagney/2002-12-01: Given that a frame ID does
- (or should) carry around the function and does (or
- should) use that when doing a frame comparison. */
+ (or should) carry around the function and does (or
+ should) use that when doing a frame comparison. */
if (stop_step
&& frame_id_eq (step_frame_id,
get_frame_id (get_current_frame ()))