From 6f4192a70b4a73fe197b6ceb5f362c30bc528055 Mon Sep 17 00:00:00 2001 From: jjohnstn Date: Fri, 17 Oct 2003 16:32:16 +0000 Subject: [PATCH] 2003-10-17 Jeff Johnston * frame.h (struct frame_id): Add new field: special_addr. (frame_id_build_special): New prototype. * frame.c (frame_id_build_special): New function. (frame_id_build): Change to call frame_id_build_special(). (frame_id_eq): Change to also test special_addr field. (frame_id_inner): Update comment. --- gdb/ChangeLog | 9 +++++++++ gdb/frame.c | 27 +++++++++++++++++++++------ gdb/frame.h | 41 ++++++++++++++++++++++++++++++++++------- 3 files changed, 64 insertions(+), 13 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index b160034ee2..e4ce649113 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,12 @@ +2003-10-17 Jeff Johnston + + * frame.h (struct frame_id): Add new field: special_addr. + (frame_id_build_special): New prototype. + * frame.c (frame_id_build_special): New function. + (frame_id_build): Change to call frame_id_build_special(). + (frame_id_eq): Change to also test special_addr field. + (frame_id_inner): Update comment. + 2003-10-17 Andrew Cagney * target.c (update_current_target): Perform the target cleanup. diff --git a/gdb/frame.c b/gdb/frame.c index e91c52abcd..3a4b7091f1 100644 --- a/gdb/frame.c +++ b/gdb/frame.c @@ -144,9 +144,10 @@ static unsigned int backtrace_limit = UINT_MAX; void fprint_frame_id (struct ui_file *file, struct frame_id id) { - fprintf_unfiltered (file, "{stack=0x%s,code=0x%s}", + fprintf_unfiltered (file, "{stack=0x%s,code=0x%s,special=0x%s}", paddr_nz (id.stack_addr), - paddr_nz (id.code_addr)); + paddr_nz (id.code_addr), + paddr_nz (id.special_addr)); } static void @@ -256,14 +257,22 @@ get_frame_id (struct frame_info *fi) const struct frame_id null_frame_id; /* All zeros. */ struct frame_id -frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr) +frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr, + CORE_ADDR special_addr) { struct frame_id id; id.stack_addr = stack_addr; id.code_addr = code_addr; + id.special_addr = special_addr; return id; } +struct frame_id +frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr) +{ + return frame_id_build_special (stack_addr, code_addr, 0); +} + int frame_id_p (struct frame_id l) { @@ -292,8 +301,14 @@ frame_id_eq (struct frame_id l, struct frame_id r) else if (l.code_addr == 0 || r.code_addr == 0) /* A zero code addr is a wild card, always succeed. */ eq = 1; - else if (l.code_addr == r.code_addr) - /* The .stack and .code are identical, the ID's are identical. */ + else if (l.code_addr != r.code_addr) + /* If .code addresses are different, the frames are different. */ + eq = 0; + else if (l.special_addr == 0 || r.special_addr == 0) + /* A zero special addr is a wild card (or unused), always succeed. */ + eq = 1; + else if (l.special_addr == r.special_addr) + /* Frames are equal. */ eq = 1; else /* No luck. */ @@ -320,7 +335,7 @@ frame_id_inner (struct frame_id l, struct frame_id r) /* Only return non-zero when strictly inner than. Note that, per comment in "frame.h", there is some fuzz here. Frameless functions are not strictly inner than (same .stack but - different .code). */ + different .code and/or .special address). */ inner = INNER_THAN (l.stack_addr, r.stack_addr); if (frame_debug) { diff --git a/gdb/frame.h b/gdb/frame.h index 4e05f16ede..81f07eb177 100644 --- a/gdb/frame.h +++ b/gdb/frame.h @@ -95,8 +95,6 @@ struct frame_id is used. Watch out for all the legacy targets that still use the function pointer register or stack pointer register. They are wrong. */ - /* NOTE: cagney/2002-11-16: The ia64 has two stacks and hence two - frame bases. This will need to be expanded to accomodate that. */ CORE_ADDR stack_addr; /* The frame's code address. This shall be constant through out the lifetime of the frame. While the PC (a.k.a. resume address) @@ -104,15 +102,33 @@ struct frame_id Typically, it is set to the address of the entry point of the frame's function (as returned by frame_func_unwind(). */ CORE_ADDR code_addr; + /* The frame's special address. This shall be constant through out the + lifetime of the frame. This is used for architectures that may have + frames that do not change the stack but are still distinct and have + some form of distinct identifier (e.g. the ia64 which uses a 2nd + stack for registers). This field is treated as unordered - i.e. will + not be used in frame ordering comparisons such as frame_id_inner(). + A zero in this field will be treated as a wild-card when comparing + frames for equality. */ + CORE_ADDR special_addr; }; /* Methods for constructing and comparing Frame IDs. - NOTE: Given frameless functions A and B, where A calls B (and hence + NOTE: Given stackless functions A and B, where A calls B (and hence B is inner-to A). The relationships: !eq(A,B); !eq(B,A); - !inner(A,B); !inner(B,A); all hold. This is because, while B is - inner to A, B is not strictly inner to A (being frameless, they - have the same .base value). */ + !inner(A,B); !inner(B,A); all hold. + + This is because, while B is inner-to A, B is not strictly inner-to A. + Being stackless, they have an identical .stack_addr value, and differ + only by their unordered .code_addr and/or .special_addr values. + + Because frame_id_inner is only used as a safety net (e.g., + detect a corrupt stack) the lack of strictness is not a problem. + Code needing to determine an exact relationship between two frames + must instead use frame_id_eq and frame_id_unwind. For instance, + in the above, to determine that A stepped-into B, the equation + "A.id != B.id && A.id == id_unwind (B)" can be used. */ /* For convenience. All fields are zero. */ extern const struct frame_id null_frame_id; @@ -120,10 +136,21 @@ extern const struct frame_id null_frame_id; /* Construct a frame ID. The first parameter is the frame's constant stack address (typically the outer-bound), and the second the frame's constant code address (typically the entry point) (or zero, - to indicate a wild card). */ + to indicate a wild card). The special identifier address is + defaulted to zero. */ extern struct frame_id frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr); +/* Construct a special frame ID. The first parameter is the frame's constant + stack address (typically the outer-bound), the second is the + frame's constant code address (typically the entry point) (or zero, + to indicate a wild card), and the third parameter is the frame's + special identifier address (or zero to indicate a wild card or + unused default). */ +extern struct frame_id frame_id_build_special (CORE_ADDR stack_addr, + CORE_ADDR code_addr, + CORE_ADDR special_addr); + /* Returns non-zero when L is a valid frame (a valid frame has a non-zero .base). */ extern int frame_id_p (struct frame_id l); -- 2.11.0