darlinghq/darling-gdb
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-gdb.git synced 2025-02-03 23:56:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

2004-04-16 Jason Molenda (jmolenda@apple.com)

Browse Source 
* frame.c: Minor typeo corrections in comments.
This commit is contained in:
Jason Molenda 2004-04-17 00:48:25 +00:00
parent 588a9e4842
commit bbde78fa2d
2 changed files with 74 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gdb/ChangeLog
View File

@ -1,3 +1,7 @@
2004-04-16 Jason Molenda (jmolenda@apple.com)
* frame.c: Minor typeo corrections in comments.
2004-04-16 Joel Brobecker <brobecker@gnat.com> 2004-04-16 Joel Brobecker <brobecker@gnat.com>
* observer.c (observer_test_first_notification_function): Update * observer.c (observer_test_first_notification_function): Update

140
gdb/frame.c
View File

@ -59,7 +59,7 @@ struct frame_info
increases. This is a cached value. It could just as easily be increases. This is a cached value. It could just as easily be
computed by counting back from the selected frame to the inner computed by counting back from the selected frame to the inner
most frame. */ most frame. */
/* NOTE: cagney/2002-04-05: Perhaphs a level of ``-1'' should be /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
reserved to indicate a bogus frame - one that has been created reserved to indicate a bogus frame - one that has been created
just to keep GDB happy (GDB always needs a frame). For the just to keep GDB happy (GDB always needs a frame). For the
moment leave this as speculation. */ moment leave this as speculation. */
@ -91,7 +91,7 @@ struct frame_info
/* The frame's low-level unwinder and corresponding cache. The /* The frame's low-level unwinder and corresponding cache. The
low-level unwinder is responsible for unwinding register values low-level unwinder is responsible for unwinding register values
for the previous frame. The low-level unwind methods are for the previous frame. The low-level unwind methods are
selected based on the presence, or otherwize, of register unwind selected based on the presence, or otherwise, of register unwind
information such as CFI. */ information such as CFI. */
void *prologue_cache; void *prologue_cache;
const struct frame_unwind *unwind; const struct frame_unwind *unwind;
@ -234,8 +234,8 @@ get_frame_id (struct frame_info *fi)
&fi->prologue_cache); &fi->prologue_cache);
/* FIXME: cagney/2003-04-02: Rather than storing the frame's /* FIXME: cagney/2003-04-02: Rather than storing the frame's
type in the frame, the unwinder's type should be returned type in the frame, the unwinder's type should be returned
directly. Unfortunately, legacy code, called by directly. Unfortunately legacy code, called by
legacy_get_prev_frame, explicitly set the frames type legacy_get_prev_frame(), explicitly sets the frame's type
using the method deprecated_set_frame_type(). */ using the method deprecated_set_frame_type(). */
fi->type = fi->unwind->type; fi->type = fi->unwind->type;
} }
@ -377,8 +377,8 @@ frame_find_by_id (struct frame_id id)
if (frame_id_inner (id, this)) if (frame_id_inner (id, this))
/* Gone to far. */ /* Gone to far. */
return NULL; return NULL;
/* Either, we're not yet gone far enough out along the frame /* Either we're not yet gone far enough out along the frame
chain (inner(this,id), or we're comparing frameless functions chain (inner(this,id)), or we're comparing frameless functions
(same .base, different .func, no test available). Struggle (same .base, different .func, no test available). Struggle
on until we've definitly gone to far. */ on until we've definitly gone to far. */
} }
@ -413,9 +413,9 @@ frame_pc_unwind (struct frame_info *this_frame)
} }
else if (this_frame->level < 0) else if (this_frame->level < 0)
{ {
/* FIXME: cagney/2003-03-06: Old code and and a sentinel /* FIXME: cagney/2003-03-06: Old code and a sentinel
frame. Do like was always done. Fetch the PC's value frame. Do like was always done. Fetch the PC's value
direct from the global registers array (via read_pc). directly from the global registers array (via read_pc).
This assumes that this frame belongs to the current This assumes that this frame belongs to the current
global register cache. The assumption is dangerous. */ global register cache. The assumption is dangerous. */
pc = read_pc (); pc = read_pc ();
@ -489,8 +489,8 @@ frame_pop (struct frame_info *this_frame)
{ {
/* Make a copy of all the register values unwound from this /* Make a copy of all the register values unwound from this
frame. Save them in a scratch buffer so that there isn't a frame. Save them in a scratch buffer so that there isn't a
race betweening trying to extract the old values from the race between trying to extract the old values from the
current_regcache while, at the same time writing new values current_regcache while at the same time writing new values
into that same cache. */ into that same cache. */
struct regcache *scratch = regcache_xmalloc (current_gdbarch); struct regcache *scratch = regcache_xmalloc (current_gdbarch);
struct cleanup *cleanups = make_cleanup_regcache_xfree (scratch); struct cleanup *cleanups = make_cleanup_regcache_xfree (scratch);
@ -538,7 +538,7 @@ frame_register_unwind (struct frame_info *frame, int regnum,
/* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
is broken. There is always a frame. If there, for some reason, is broken. There is always a frame. If there, for some reason,
isn't, there is some pretty busted code as it should have isn't a frame, there is some pretty busted code as it should have
detected the problem before calling here. */ detected the problem before calling here. */
gdb_assert (frame != NULL); gdb_assert (frame != NULL);
@ -550,13 +550,13 @@ frame_register_unwind (struct frame_info *frame, int regnum,
/* FIXME: cagney/2003-04-02: Rather than storing the frame's /* FIXME: cagney/2003-04-02: Rather than storing the frame's
type in the frame, the unwinder's type should be returned type in the frame, the unwinder's type should be returned
directly. Unfortunately, legacy code, called by directly. Unfortunately, legacy code, called by
legacy_get_prev_frame, explicitly set the frames type using legacy_get_prev_frame(), explicitly set the frames type using
the method deprecated_set_frame_type(). */ the method deprecated_set_frame_type(). */
frame->type = frame->unwind->type; frame->type = frame->unwind->type;
} }
/* Ask this frame to unwind its register. See comment in /* Ask this frame to unwind its register. See comment in
"frame-unwind.h" for why NEXT frame and this unwind cace are "frame-unwind.h" for why NEXT frame and this unwind cache are
passed in. */ passed in. */
frame->unwind->prev_register (frame->next, &frame->prologue_cache, regnum, frame->unwind->prev_register (frame->next, &frame->prologue_cache, regnum,
optimizedp, lvalp, addrp, realnump, bufferp); optimizedp, lvalp, addrp, realnump, bufferp);
@ -732,7 +732,7 @@ frame_register_read (struct frame_info *frame, int regnum, void *myaddr)
int realnum; int realnum;
frame_register (frame, regnum, &optimized, &lval, &addr, &realnum, myaddr); frame_register (frame, regnum, &optimized, &lval, &addr, &realnum, myaddr);
/* FIXME: cagney/2002-05-15: This test, is just bogus. /* FIXME: cagney/2002-05-15: This test is just bogus.
It indicates that the target failed to supply a value for a It indicates that the target failed to supply a value for a
register because it was "not available" at this time. Problem register because it was "not available" at this time. Problem
@ -833,7 +833,7 @@ static int
unwind_to_current_frame (struct ui_out *ui_out, void *args) unwind_to_current_frame (struct ui_out *ui_out, void *args)
{ {
struct frame_info *frame = get_prev_frame (args); struct frame_info *frame = get_prev_frame (args);
/* A sentinel frame can fail to unwind, eg, because it's PC value /* A sentinel frame can fail to unwind, e.g., because its PC value
lands in somewhere like start. */ lands in somewhere like start. */
if (frame == NULL) if (frame == NULL)
return 1; return 1;
@ -875,7 +875,7 @@ get_current_frame (void)
struct frame_info *deprecated_selected_frame; struct frame_info *deprecated_selected_frame;
/* Return the selected frame. Always non-null (unless there isn't an /* Return the selected frame. Always non-NULL (unless there isn't an
inferior sufficient for creating a frame) in which case an error is inferior sufficient for creating a frame) in which case an error is
thrown. */ thrown. */
@ -892,9 +892,9 @@ get_selected_frame (void)
return deprecated_selected_frame; return deprecated_selected_frame;
} }
/* This is a variant of get_selected_frame which can be called when /* This is a variant of get_selected_frame() which can be called when
the inferior does not have a frame; in that case it will return the inferior does not have a frame; in that case it will return
NULL instead of calling error (). */ NULL instead of calling error(). */
struct frame_info * struct frame_info *
deprecated_safe_get_selected_frame (void) deprecated_safe_get_selected_frame (void)
@ -912,26 +912,26 @@ select_frame (struct frame_info *fi)
struct symtab *s; struct symtab *s;
deprecated_selected_frame = fi; deprecated_selected_frame = fi;
/* NOTE: cagney/2002-05-04: FI can be NULL. This occures when the /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
frame is being invalidated. */ frame is being invalidated. */
if (selected_frame_level_changed_hook) if (selected_frame_level_changed_hook)
selected_frame_level_changed_hook (frame_relative_level (fi)); selected_frame_level_changed_hook (frame_relative_level (fi));
/* FIXME: kseitz/2002-08-28: It would be nice to call /* FIXME: kseitz/2002-08-28: It would be nice to call
selected_frame_level_changed_event right here, but due to limitations selected_frame_level_changed_event() right here, but due to limitations
in the current interfaces, we would end up flooding UIs with events in the current interfaces, we would end up flooding UIs with events
because select_frame is used extensively internally. because select_frame() is used extensively internally.
Once we have frame-parameterized frame (and frame-related) commands, Once we have frame-parameterized frame (and frame-related) commands,
the event notification can be moved here, since this function will only the event notification can be moved here, since this function will only
be called when the users selected frame is being changed. */ be called when the user's selected frame is being changed. */
/* Ensure that symbols for this frame are read in. Also, determine the /* Ensure that symbols for this frame are read in. Also, determine the
source language of this frame, and switch to it if desired. */ source language of this frame, and switch to it if desired. */
if (fi) if (fi)
{ {
/* We retrieve the frame's symtab by using the frame PC. However /* We retrieve the frame's symtab by using the frame PC. However
we cannot use the frame pc as is, because it usually points to we cannot use the frame PC as-is, because it usually points to
the instruction following the "call", which is sometimes the the instruction following the "call", which is sometimes the
first instruction of another function. So we rely on first instruction of another function. So we rely on
get_frame_address_in_block() which provides us with a PC which get_frame_address_in_block() which provides us with a PC which
@ -969,7 +969,7 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame,
if (deprecated_get_frame_saved_regs (frame) == NULL) if (deprecated_get_frame_saved_regs (frame) == NULL)
{ {
/* If nothing's initialized the saved regs, do it now. */ /* If nothing has initialized the saved regs, do it now. */
gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ()); gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
DEPRECATED_FRAME_INIT_SAVED_REGS (frame); DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
gdb_assert (deprecated_get_frame_saved_regs (frame) != NULL); gdb_assert (deprecated_get_frame_saved_regs (frame) != NULL);
@ -986,8 +986,8 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame,
*addrp = 0; *addrp = 0;
*realnump = -1; *realnump = -1;
if (bufferp != NULL) if (bufferp != NULL)
/* NOTE: cagney/2003-05-09: In-lined store_address with /* NOTE: cagney/2003-05-09: In-lined store_address() with
it's body - store_unsigned_integer. */ it's body - store_unsigned_integer(). */
store_unsigned_integer (bufferp, DEPRECATED_REGISTER_RAW_SIZE (regnum), store_unsigned_integer (bufferp, DEPRECATED_REGISTER_RAW_SIZE (regnum),
deprecated_get_frame_saved_regs (frame)[regnum]); deprecated_get_frame_saved_regs (frame)[regnum]);
} }
@ -1051,7 +1051,7 @@ legacy_saved_regs_this_id (struct frame_info *next_frame,
} }
const struct frame_unwind legacy_saved_regs_unwinder = { const struct frame_unwind legacy_saved_regs_unwinder = {
/* Not really. It gets overridden by legacy_get_prev_frame. */ /* Not really. It gets overridden by legacy_get_prev_frame(). */
UNKNOWN_FRAME, UNKNOWN_FRAME,
legacy_saved_regs_this_id, legacy_saved_regs_this_id,
legacy_saved_regs_prev_register legacy_saved_regs_prev_register
@ -1131,8 +1131,8 @@ deprecated_generic_get_saved_register (char *raw_buffer, int *optimized,
if (regnum == SP_REGNUM) if (regnum == SP_REGNUM)
{ {
if (raw_buffer) /* SP register treated specially */ if (raw_buffer) /* SP register treated specially */
/* NOTE: cagney/2003-05-09: In-line store_address /* NOTE: cagney/2003-05-09: In-line store_address()
with it's body - store_unsigned_integer. */ with it's body - store_unsigned_integer(). */
store_unsigned_integer (raw_buffer, store_unsigned_integer (raw_buffer,
DEPRECATED_REGISTER_RAW_SIZE (regnum), DEPRECATED_REGISTER_RAW_SIZE (regnum),
deprecated_get_frame_saved_regs (frame)[regnum]); deprecated_get_frame_saved_regs (frame)[regnum]);
@ -1285,7 +1285,7 @@ legacy_get_prev_frame (struct frame_info *this_frame)
There is no reason to worry about memory leaks, should the There is no reason to worry about memory leaks, should the
remainder of the function fail. The allocated memory will be remainder of the function fail. The allocated memory will be
quickly reclaimed when the frame cache is flushed, and the `we've quickly reclaimed when the frame cache is flushed, and the `we've
been here before' check, in get_prev_frame will stop repeated been here before' check, in get_prev_frame() will stop repeated
memory allocation calls. */ memory allocation calls. */
prev = FRAME_OBSTACK_ZALLOC (struct frame_info); prev = FRAME_OBSTACK_ZALLOC (struct frame_info);
prev->level = this_frame->level + 1; prev->level = this_frame->level + 1;
@ -1325,7 +1325,7 @@ legacy_get_prev_frame (struct frame_info *this_frame)
Note that the pc-unwind is intentionally performed before the Note that the pc-unwind is intentionally performed before the
frame chain. This is ok since, for old targets, both frame chain. This is ok since, for old targets, both
frame_pc_unwind (nee, DEPRECATED_FRAME_SAVED_PC) and frame_pc_unwind() (nee, DEPRECATED_FRAME_SAVED_PC) and
DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
have already been initialized (using have already been initialized (using
DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
@ -1455,7 +1455,7 @@ legacy_get_prev_frame (struct frame_info *this_frame)
frame. This macro will set FROMLEAF if THIS_FRAME is a frameless frame. This macro will set FROMLEAF if THIS_FRAME is a frameless
function invocation. */ function invocation. */
if (this_frame->level == 0) if (this_frame->level == 0)
/* FIXME: 2002-11-09: Frameless functions can occure anywhere in /* FIXME: 2002-11-09: Frameless functions can occur anywhere in
the frame chain, not just the inner most frame! The generic, the frame chain, not just the inner most frame! The generic,
per-architecture, frame code should handle this and the below per-architecture, frame code should handle this and the below
should simply be removed. */ should simply be removed. */
@ -1469,7 +1469,7 @@ legacy_get_prev_frame (struct frame_info *this_frame)
architecture frame-pointer register!) of the caller is the same architecture frame-pointer register!) of the caller is the same
as the callee. */ as the callee. */
/* FIXME: 2002-11-09: There isn't any reason to special case this /* FIXME: 2002-11-09: There isn't any reason to special case this
edge condition. Instead the per-architecture code should hande edge condition. Instead the per-architecture code should handle
it locally. */ it locally. */
/* FIXME: cagney/2003-06-16: This returns the inner most stack /* FIXME: cagney/2003-06-16: This returns the inner most stack
address for the previous frame, that, however, is wrong. It address for the previous frame, that, however, is wrong. It
@ -1508,7 +1508,7 @@ legacy_get_prev_frame (struct frame_info *this_frame)
/* FIXME: cagney/2003-04-02: Rather than storing the frame's /* FIXME: cagney/2003-04-02: Rather than storing the frame's
type in the frame, the unwinder's type should be returned type in the frame, the unwinder's type should be returned
directly. Unfortunately, legacy code, called by directly. Unfortunately, legacy code, called by
legacy_get_prev_frame, explicitly set the frames type legacy_get_prev_frame(), explicitly set the frames type
using the method deprecated_set_frame_type(). */ using the method deprecated_set_frame_type(). */
prev->type = prev->unwind->type; prev->type = prev->unwind->type;
/* Find PREV frame's ID. */ /* Find PREV frame's ID. */
@ -1595,10 +1595,10 @@ legacy_get_prev_frame (struct frame_info *this_frame)
reason for things to be this complicated. reason for things to be this complicated.
The trick is to assume that there is always a frame. Instead of The trick is to assume that there is always a frame. Instead of
special casing the inner-most frame, create fake frame special casing the inner-most frame, create a fake frame
(containing the hardware registers) that is inner to the (containing the hardware registers) that is inner to the
user-visible inner-most frame (...) and then unwind from that. user-visible inner-most frame (...) and then unwind from that.
That way architecture code can use use the standard That way architecture code can use the standard
frame_XX_unwind() functions and not differentiate between the frame_XX_unwind() functions and not differentiate between the
inner most and any other case. inner most and any other case.
@ -1613,7 +1613,7 @@ legacy_get_prev_frame (struct frame_info *this_frame)
FRAME_SAVED_PC(), and FRAME_SAVED_PC() computes the PC but FRAME_SAVED_PC(), and FRAME_SAVED_PC() computes the PC but
without first needing the frame! Instead of the convolution without first needing the frame! Instead of the convolution
below, we could have simply called FRAME_SAVED_PC() and been done below, we could have simply called FRAME_SAVED_PC() and been done
with it! Note that FRAME_SAVED_PC() is being superseed by with it! Note that FRAME_SAVED_PC() is being superseded by
frame_pc_unwind() and that function does have somewhere to cache frame_pc_unwind() and that function does have somewhere to cache
that PC value. */ that PC value. */
@ -1622,7 +1622,7 @@ legacy_get_prev_frame (struct frame_info *this_frame)
/* This entry is in the frame queue now, which is good since /* This entry is in the frame queue now, which is good since
FRAME_SAVED_PC may use that queue to figure out its value (see FRAME_SAVED_PC may use that queue to figure out its value (see
tm-sparc.h). We want the pc saved in the inferior frame. */ tm-sparc.h). We want the PC saved in the inferior frame. */
if (DEPRECATED_INIT_FRAME_PC_P ()) if (DEPRECATED_INIT_FRAME_PC_P ())
deprecated_update_frame_pc_hack (prev, deprecated_update_frame_pc_hack (prev,
DEPRECATED_INIT_FRAME_PC (fromleaf, DEPRECATED_INIT_FRAME_PC (fromleaf,
@ -1659,7 +1659,7 @@ legacy_get_prev_frame (struct frame_info *this_frame)
prev->unwind = frame_unwind_find_by_frame (prev->next, prev->unwind = frame_unwind_find_by_frame (prev->next,
&prev->prologue_cache); &prev->prologue_cache);
/* If the unwinder provides a frame type, use it. Otherwize /* If the unwinder provides a frame type, use it. Otherwise
continue on to that heuristic mess. */ continue on to that heuristic mess. */
if (prev->unwind->type != UNKNOWN_FRAME) if (prev->unwind->type != UNKNOWN_FRAME)
{ {
@ -1678,8 +1678,8 @@ legacy_get_prev_frame (struct frame_info *this_frame)
} }
/* NOTE: cagney/2002-11-18: The code segments, found in /* NOTE: cagney/2002-11-18: The code segments, found in
create_new_frame and get_prev_frame(), that initializes the create_new_frame() and get_prev_frame(), that initialize the
frames type is subtly different. The latter only updates ->type frame's type is subtly different. The latter only updates ->type
when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME. This stops when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME. This stops
get_prev_frame() overriding the frame's type when the INIT code get_prev_frame() overriding the frame's type when the INIT code
has previously set it. This is really somewhat bogus. The has previously set it. This is really somewhat bogus. The
@ -1693,8 +1693,8 @@ legacy_get_prev_frame (struct frame_info *this_frame)
/* FIXME: cagney/2002-11-10: This should be moved to before the /* FIXME: cagney/2002-11-10: This should be moved to before the
INIT code above so that the INIT code knows what the frame's INIT code above so that the INIT code knows what the frame's
type is (in fact, for a [generic] dummy-frame, the type can type is (in fact, for a [generic] dummy-frame, the type can
be set and then the entire initialization can be skipped. be set and then the entire initialization can be skipped).
Unforunatly, its the INIT code that sets the PC (Hmm, catch Unfortunately, it's the INIT code that sets the PC (Hmm, catch
22). */ 22). */
char *name; char *name;
find_pc_partial_function (get_frame_pc (prev), &name, NULL, NULL); find_pc_partial_function (get_frame_pc (prev), &name, NULL, NULL);
@ -1759,7 +1759,7 @@ get_prev_frame_1 (struct frame_info *this_frame)
this_frame->prev_p = 1; this_frame->prev_p = 1;
/* If any of the old frame initialization methods are around, use /* If any of the old frame initialization methods are around, use
the legacy get_prev_frame method. */ the legacy get_prev_frame() method. */
if (legacy_frame_p (current_gdbarch)) if (legacy_frame_p (current_gdbarch))
{ {
prev_frame = legacy_get_prev_frame (this_frame); prev_frame = legacy_get_prev_frame (this_frame);
@ -1887,9 +1887,9 @@ get_prev_frame (struct frame_info *this_frame)
while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
it couldn't be written better, I don't know. it couldn't be written better, I don't know.
NOTE: cagney/2003-01-11: I suspect what is happening is NOTE: cagney/2003-01-11: I suspect what is happening in
block_innermost_frame() is, when the target has no state block_innermost_frame() is, when the target has no state
(registers, memory, ...), still calling this function. The (registers, memory, ...), it is still calling this function. The
assumption being that this function will return NULL indicating assumption being that this function will return NULL indicating
that a frame isn't possible, rather than checking that the target that a frame isn't possible, rather than checking that the target
has state and then calling get_current_frame() and has state and then calling get_current_frame() and
@ -1918,13 +1918,13 @@ get_prev_frame (struct frame_info *this_frame)
gdb_assert (this_frame != NULL); gdb_assert (this_frame != NULL);
/* Make sure we pass an address within THIS_FRAME's code block to /* Make sure we pass an address within THIS_FRAME's code block to
inside_main_func. Otherwise, we might stop unwinding at a inside_main_func(). Otherwise, we might stop unwinding at a
function which has a call instruction as its last instruction if function which has a call instruction as its last instruction if
that function immediately precedes main(). */ that function immediately precedes main(). */
if (this_frame->level >= 0 if (this_frame->level >= 0
&& !backtrace_past_main && !backtrace_past_main
&& inside_main_func (get_frame_address_in_block (this_frame))) && inside_main_func (get_frame_address_in_block (this_frame)))
/* Don't unwind past main(), bug always unwind the sentinel frame. /* Don't unwind past main(), but always unwind the sentinel frame.
Note, this is done _before_ the frame has been marked as Note, this is done _before_ the frame has been marked as
previously unwound. That way if the user later decides to previously unwound. That way if the user later decides to
allow unwinds past main(), that just happens. */ allow unwinds past main(), that just happens. */
@ -1940,22 +1940,22 @@ get_prev_frame (struct frame_info *this_frame)
/* If we're already inside the entry function for the main objfile, /* If we're already inside the entry function for the main objfile,
then it isn't valid. Don't apply this test to a dummy frame - then it isn't valid. Don't apply this test to a dummy frame -
dummy frame PC's typically land in the entry func. Don't apply dummy frame PCs typically land in the entry func. Don't apply
this test to the sentinel frame. Sentinel frames should always this test to the sentinel frame. Sentinel frames should always
be allowed to unwind. */ be allowed to unwind. */
/* NOTE: cagney/2003-02-25: Don't enable until someone has found /* NOTE: cagney/2003-02-25: Don't enable until someone has found
hard evidence that this is needed. */ hard evidence that this is needed. */
/* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func - wasn't /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() - wasn't
checking for "main" in the minimal symbols. With that fixed checking for "main" in the minimal symbols. With that fixed
asm-source tests now stop in "main" instead of halting the asm-source tests now stop in "main" instead of halting the
backtrace in wierd and wonderful ways somewhere inside the entry backtrace in weird and wonderful ways somewhere inside the entry
file. Suspect that deprecated_inside_entry_file and file. Suspect that deprecated_inside_entry_file() and
inside_entry_func tests were added to work around that (now inside_entry_func() tests were added to work around that (now
fixed) case. */ fixed) case. */
/* NOTE: cagney/2003-07-15: danielj (if I'm reading it right) /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
suggested having the inside_entry_func test use the suggested having the inside_entry_func test use the
inside_main_func msymbol trick (along with entry_point_address I inside_main_func() msymbol trick (along with entry_point_address()
guess) to determine the address range of the start function. I guess) to determine the address range of the start function.
That should provide a far better stopper than the current That should provide a far better stopper than the current
heuristics. */ heuristics. */
/* NOTE: cagney/2003-07-15: Need to add a "set backtrace /* NOTE: cagney/2003-07-15: Need to add a "set backtrace
@ -1973,25 +1973,25 @@ get_prev_frame (struct frame_info *this_frame)
} }
/* If we're inside the entry file, it isn't valid. Don't apply this /* If we're inside the entry file, it isn't valid. Don't apply this
test to a dummy frame - dummy frame PC's typically land in the test to a dummy frame - dummy frame PCs typically land in the
entry file. Don't apply this test to the sentinel frame. entry file. Don't apply this test to the sentinel frame.
Sentinel frames should always be allowed to unwind. */ Sentinel frames should always be allowed to unwind. */
/* NOTE: drow/2002-12-25: should there be a way to disable this /* NOTE: drow/2002-12-25: should there be a way to disable this
check? It assumes a single small entry file, and the way some check? It assumes a single small entry file, and the way some
debug readers (e.g. dbxread) figure out which object is the debug readers (e.g. dbxread) figure out which object is the
entry file is somewhat hokey. */ entry file is somewhat hokey. */
/* NOTE: cagney/2003-01-10: If there is a way of disabling this test /* NOTE: cagney/2003-01-10: If there is a way of disabling this test
then it should probably be moved to before the ->prev_p test, then it should probably be moved to before the ->prev_p test,
above. */ above. */
/* NOTE: vinschen/2003-04-01: Disabled. It turns out that the call /* NOTE: vinschen/2003-04-01: Disabled. It turns out that the call
to deprecated_inside_entry_file destroys a meaningful backtrace to deprecated_inside_entry_file() destroys a meaningful backtrace
under some conditions. E. g. the backtrace tests in the under some conditions, e.g. the backtrace tests in the
asm-source testcase are broken for some targets. In this test asm-source testcase are broken for some targets. In this test
the functions are all implemented as part of one file and the the functions are all implemented as part of one file and the
testcase is not necessarily linked with a start file (depending testcase is not necessarily linked with a start file (depending
on the target). What happens is, that the first frame is printed on the target). What happens is that the first frame is printed
normaly and following frames are treated as being inside the normally and following frames are treated as being inside the
enttry file then. This way, only the #0 frame is printed in the entry file then. This way, only the #0 frame is printed in the
backtrace output. */ backtrace output. */
if (0 if (0
&& this_frame->type != DUMMY_FRAME && this_frame->level >= 0 && this_frame->type != DUMMY_FRAME && this_frame->level >= 0
@ -2025,7 +2025,7 @@ frame_unwind_address_in_block (struct frame_info *next_frame)
"call". Adjust that PC value so that it falls on the call "call". Adjust that PC value so that it falls on the call
instruction (which, hopefully, falls within THIS frame's code instruction (which, hopefully, falls within THIS frame's code
block. So far it's proved to be a very good approximation. See block. So far it's proved to be a very good approximation. See
get_frame_type for why ->type can't be used. */ get_frame_type() for why ->type can't be used. */
if (next_frame->level >= 0 if (next_frame->level >= 0
&& get_frame_type (next_frame) == NORMAL_FRAME) && get_frame_type (next_frame) == NORMAL_FRAME)
--pc; --pc;
@ -2148,14 +2148,14 @@ get_frame_type (struct frame_info *frame)
legacy code. It will be initialized in legacy_get_prev_frame(). */ legacy code. It will be initialized in legacy_get_prev_frame(). */
if (frame->unwind == NULL && !legacy_frame_p (current_gdbarch)) if (frame->unwind == NULL && !legacy_frame_p (current_gdbarch))
{ {
/* Initialize the frame's unwinder because it is that which /* Initialize the frame's unwinder because that's what
provides the frame's type. */ provides the frame's type. */
frame->unwind = frame_unwind_find_by_frame (frame->next, frame->unwind = frame_unwind_find_by_frame (frame->next,
&frame->prologue_cache); &frame->prologue_cache);
/* FIXME: cagney/2003-04-02: Rather than storing the frame's /* FIXME: cagney/2003-04-02: Rather than storing the frame's
type in the frame, the unwinder's type should be returned type in the frame, the unwinder's type should be returned
directly. Unfortunately, legacy code, called by directly. Unfortunately, legacy code, called by
legacy_get_prev_frame, explicitly set the frames type using legacy_get_prev_frame(), explicitly set the frames type using
the method deprecated_set_frame_type(). */ the method deprecated_set_frame_type(). */
frame->type = frame->unwind->type; frame->type = frame->unwind->type;
} }
@ -2193,7 +2193,7 @@ deprecated_update_frame_pc_hack (struct frame_info *frame, CORE_ADDR pc)
"{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n", "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
frame->level, paddr_nz (pc)); frame->level, paddr_nz (pc));
/* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
maintaining a locally allocated frame object. Since such frame's maintaining a locally allocated frame object. Since such frames
are not in the frame chain, it isn't possible to assume that the are not in the frame chain, it isn't possible to assume that the
frame has a next. Sigh. */ frame has a next. Sigh. */
if (frame->next != NULL) if (frame->next != NULL)
@ -2288,12 +2288,12 @@ get_frame_sp (struct frame_info *this_frame)
CORE_ADDR CORE_ADDR
frame_sp_unwind (struct frame_info *next_frame) frame_sp_unwind (struct frame_info *next_frame)
{ {
/* Normality, an architecture that provides a way of obtaining any /* Normality - an architecture that provides a way of obtaining any
frame inner-most address. */ frame inner-most address. */
if (gdbarch_unwind_sp_p (current_gdbarch)) if (gdbarch_unwind_sp_p (current_gdbarch))
return gdbarch_unwind_sp (current_gdbarch, next_frame); return gdbarch_unwind_sp (current_gdbarch, next_frame);
/* Things are looking grim. If it's the inner-most frame and there /* Things are looking grim. If it's the inner-most frame and there
is a TARGET_READ_SP then that can be used. */ is a TARGET_READ_SP, then that can be used. */
if (next_frame->level < 0 && TARGET_READ_SP_P ()) if (next_frame->level < 0 && TARGET_READ_SP_P ())
return TARGET_READ_SP (); return TARGET_READ_SP ();
/* Now things are really are grim. Hope that the value returned by /* Now things are really are grim. Hope that the value returned by
@ -2324,12 +2324,12 @@ legacy_frame_p (struct gdbarch *current_gdbarch)
|| DEPRECATED_FP_REGNUM >= 0) || DEPRECATED_FP_REGNUM >= 0)
/* Assume it's legacy. If you're trying to convert a legacy frame /* Assume it's legacy. If you're trying to convert a legacy frame
target to the new mechanism, get rid of these. legacy target to the new mechanism, get rid of these. legacy
get_prev_frame requires these when unwind_frame_id isn't get_prev_frame() requires these when unwind_frame_id() isn't
available. */ available. */
return 1; return 1;
/* Default to assuming that it's brand new code, and hence not /* Default to assuming that it's brand new code, and hence not
legacy. Force it down the non-legacy path so that the new code legacy. Force it down the non-legacy path so that the new code
uses the new frame mechanism from day one. Dummy frame's won't uses the new frame mechanism from day one. Dummy frames won't
work very well but we can live with that. */ work very well but we can live with that. */
return 0; return 0;
} }