From: Tom Tromey Date: Mon, 25 Jul 2022 17:06:33 +0000 (-0300) Subject: Remove frame_id_eq X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=a0cbd6505e9590baddd27d2ce603103d6e77421a;p=binutils-gdb.git Remove frame_id_eq This replaces frame_id_eq with operator== and operator!=. I wrote this for a version of this series that I later abandoned; but since it simplifies the code, I left this patch in. Approved-by: Tom Tomey --- diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index a3a154c19a9..2eabdd63c2e 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -5325,7 +5325,7 @@ bpstat_check_breakpoint_conditions (bpstat *bs, thread_info *thread) breakpoint or a single step breakpoint. */ if (frame_id_p (b->frame_id) - && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ()))) + && b->frame_id != get_stack_frame_id (get_current_frame ())) { infrun_debug_printf ("incorrect frame %s not %s, not stopping", get_stack_frame_id (get_current_frame ()).to_string ().c_str (), diff --git a/gdb/dummy-frame.c b/gdb/dummy-frame.c index 40b455c7e4a..2fef6eae562 100644 --- a/gdb/dummy-frame.c +++ b/gdb/dummy-frame.c @@ -47,7 +47,7 @@ static int dummy_frame_id_eq (struct dummy_frame_id *id1, struct dummy_frame_id *id2) { - return frame_id_eq (id1->id, id2->id) && id1->thread == id2->thread; + return id1->id == id2->id && id1->thread == id2->thread; } /* List of dummy_frame destructors. */ @@ -130,7 +130,7 @@ static bool pop_dummy_frame_bpt (struct breakpoint *b, struct dummy_frame *dummy) { if (b->thread == dummy->id.thread->global_num - && b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id.id)) + && b->disposition == disp_del && b->frame_id == dummy->id.id) { while (b->related_breakpoint != b) delete_breakpoint (b->related_breakpoint); diff --git a/gdb/elfread.c b/gdb/elfread.c index 8aee634b44b..8b0e3c30468 100644 --- a/gdb/elfread.c +++ b/gdb/elfread.c @@ -946,7 +946,7 @@ elf_gnu_ifunc_resolver_stop (code_breakpoint *b) if (b_return->thread == thread_id && b_return->loc->requested_address == prev_pc - && frame_id_eq (b_return->frame_id, prev_frame_id)) + && b_return->frame_id == prev_frame_id) break; } diff --git a/gdb/frame-unwind.c b/gdb/frame-unwind.c index 78fc8dd4bcf..78e3f1d8bad 100644 --- a/gdb/frame-unwind.c +++ b/gdb/frame-unwind.c @@ -229,7 +229,7 @@ default_frame_unwind_stop_reason (struct frame_info *this_frame, { struct frame_id this_id = get_frame_id (this_frame); - if (frame_id_eq (this_id, outer_frame_id)) + if (this_id == outer_frame_id) return UNWIND_OUTERMOST; else return UNWIND_NO_REASON; diff --git a/gdb/frame.c b/gdb/frame.c index fc883b3239e..8df5feb4825 100644 --- a/gdb/frame.c +++ b/gdb/frame.c @@ -244,7 +244,7 @@ frame_addr_hash (const void *ap) } /* Internal equality function for the hash table. This function - defers equality operations to frame_id_eq. */ + defers equality operations to frame_id::operator==. */ static int frame_addr_hash_eq (const void *a, const void *b) @@ -252,8 +252,7 @@ frame_addr_hash_eq (const void *a, const void *b) const struct frame_info *f_entry = (const struct frame_info *) a; const struct frame_info *f_element = (const struct frame_info *) b; - return frame_id_eq (f_entry->this_id.value, - f_element->this_id.value); + return f_entry->this_id.value == f_element->this_id.value; } /* Internal function to create the frame_stash hash table. 100 seems @@ -752,28 +751,28 @@ frame_id_artificial_p (frame_id l) } bool -frame_id_eq (frame_id l, frame_id r) +frame_id::operator== (const frame_id &r) const { bool eq; - if (l.stack_status == FID_STACK_INVALID + if (stack_status == FID_STACK_INVALID || r.stack_status == FID_STACK_INVALID) /* Like a NaN, if either ID is invalid, the result is false. Note that a frame ID is invalid iff it is the null frame ID. */ eq = false; - else if (l.stack_status != r.stack_status || l.stack_addr != r.stack_addr) + else if (stack_status != r.stack_status || stack_addr != r.stack_addr) /* If .stack addresses are different, the frames are different. */ eq = false; - else if (l.code_addr_p && r.code_addr_p && l.code_addr != r.code_addr) + else if (code_addr_p && r.code_addr_p && code_addr != r.code_addr) /* An invalid code addr is a wild card. If .code addresses are different, the frames are different. */ eq = false; - else if (l.special_addr_p && r.special_addr_p - && l.special_addr != r.special_addr) + else if (special_addr_p && r.special_addr_p + && special_addr != r.special_addr) /* An invalid special addr is a wild card (or unused). Otherwise if special addresses are different, the frames are different. */ eq = false; - else if (l.artificial_depth != r.artificial_depth) + else if (artificial_depth != r.artificial_depth) /* If artificial depths are different, the frames must be different. */ eq = false; else @@ -781,7 +780,7 @@ frame_id_eq (frame_id l, frame_id r) eq = true; frame_debug_printf ("l=%s, r=%s -> %d", - l.to_string ().c_str (), r.to_string ().c_str (), eq); + to_string ().c_str (), r.to_string ().c_str (), eq); return eq; } @@ -875,7 +874,7 @@ frame_find_by_id (struct frame_id id) return NULL; /* Check for the sentinel frame. */ - if (frame_id_eq (id, sentinel_frame_id)) + if (id == sentinel_frame_id) return sentinel_frame; /* Try using the frame stash first. Finding it there removes the need @@ -894,7 +893,7 @@ frame_find_by_id (struct frame_id id) { struct frame_id self = get_frame_id (frame); - if (frame_id_eq (id, self)) + if (id == self) /* An exact match. */ return frame; @@ -1738,7 +1737,7 @@ lookup_selected_frame (struct frame_id a_frame_id, int frame_level) it's highly unlikely the search by level finds the wrong frame, it's 99.9(9)% of the time (for all practical purposes) safe. */ - && frame_id_eq (get_frame_id (frame), a_frame_id)) + && get_frame_id (frame) == a_frame_id) { /* Cool, all is fine. */ select_frame (frame); diff --git a/gdb/frame.h b/gdb/frame.h index b9a3793cc23..75bb3bd2aa0 100644 --- a/gdb/frame.h +++ b/gdb/frame.h @@ -173,6 +173,16 @@ struct frame_id /* Return a string representation of this frame id. */ std::string to_string () const; + + /* Returns true when this frame_id and R identify the same + frame. */ + bool operator== (const frame_id &r) const; + + /* Inverse of ==. */ + bool operator!= (const frame_id &r) const + { + return !(*this == r); + } }; /* Save and restore the currently selected frame. */ @@ -269,9 +279,6 @@ extern bool frame_id_p (frame_id l); TAILCALL_FRAME. */ extern bool frame_id_artificial_p (frame_id l); -/* Returns true when L and R identify the same frame. */ -extern bool frame_id_eq (frame_id l, frame_id r); - /* Frame types. Some are real, some are signal trampolines, and some are completely artificial (dummy). */ @@ -498,22 +505,7 @@ extern CORE_ADDR get_frame_base (struct frame_info *); /* Return the per-frame unique identifer. Can be used to relocate a frame after a frame cache flush (and other similar operations). If - FI is NULL, return the null_frame_id. - - NOTE: kettenis/20040508: These functions return a structure. On - platforms where structures are returned in static storage (vax, - m68k), this may trigger compiler bugs in code like: - - if (frame_id_eq (get_frame_id (l), get_frame_id (r))) - - where the return value from the first get_frame_id (l) gets - overwritten by the second get_frame_id (r). Please avoid writing - code like this. Use code like: - - struct frame_id id = get_frame_id (l); - if (frame_id_eq (id, get_frame_id (r))) - - instead, since that avoids the bug. */ + FI is NULL, return the null_frame_id. */ extern struct frame_id get_frame_id (struct frame_info *fi); extern struct frame_id get_stack_frame_id (struct frame_info *fi); extern struct frame_id frame_unwind_caller_id (struct frame_info *next_frame); diff --git a/gdb/guile/scm-frame.c b/gdb/guile/scm-frame.c index 159603b8008..77764944208 100644 --- a/gdb/guile/scm-frame.c +++ b/gdb/guile/scm-frame.c @@ -134,7 +134,7 @@ frscm_eq_frame_smob (const void *ap, const void *bp) const frame_smob *a = (const frame_smob *) ap; const frame_smob *b = (const frame_smob *) bp; - return (frame_id_eq (a->frame_id, b->frame_id) + return (a->frame_id == b->frame_id && a->inferior == b->inferior && a->inferior != NULL); } diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c index 0b448e9a231..2bac2a64e9d 100644 --- a/gdb/ia64-tdep.c +++ b/gdb/ia64-tdep.c @@ -2901,7 +2901,7 @@ ia64_libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache, CORE_ADDR bsp; libunwind_frame_this_id (this_frame, this_cache, &id); - if (frame_id_eq (id, outer_frame_id)) + if (id == outer_frame_id) { (*this_id) = outer_frame_id; return; @@ -3032,7 +3032,7 @@ ia64_libunwind_sigtramp_frame_this_id (struct frame_info *this_frame, struct frame_id id = outer_frame_id; libunwind_frame_this_id (this_frame, this_cache, &id); - if (frame_id_eq (id, outer_frame_id)) + if (id == outer_frame_id) { (*this_id) = outer_frame_id; return; diff --git a/gdb/infrun.c b/gdb/infrun.c index 1957e8020dd..db82e2a9bbb 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -4565,7 +4565,7 @@ stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id) frame != NULL; frame = get_prev_frame (frame)) { - if (frame_id_eq (get_frame_id (frame), step_frame_id)) + if (get_frame_id (frame) == step_frame_id) return true; if (get_frame_type (frame) != INLINE_FRAME) @@ -4595,7 +4595,7 @@ inline_frame_is_marked_for_skip (bool prev_frame, struct thread_info *tp) symtab_and_line sal; struct symbol *sym; - if (frame_id_eq (get_frame_id (frame), tp->control.step_frame_id)) + if (get_frame_id (frame) == tp->control.step_frame_id) break; if (get_frame_type (frame) != INLINE_FRAME) break; @@ -6576,8 +6576,8 @@ handle_signal_stop (struct execution_control_state *ecs) && (pc_in_thread_step_range (ecs->event_thread->stop_pc (), ecs->event_thread) || ecs->event_thread->control.step_range_end == 1) - && frame_id_eq (get_stack_frame_id (frame), - ecs->event_thread->control.step_stack_frame_id) + && (get_stack_frame_id (frame) + == ecs->event_thread->control.step_stack_frame_id) && ecs->event_thread->control.step_resume_breakpoint == NULL) { /* The inferior is about to take a signal that will take it @@ -6744,8 +6744,7 @@ process_event_stop_test (struct execution_control_state *ecs) { struct frame_id current_id = get_frame_id (get_current_frame ()); - if (frame_id_eq (current_id, - ecs->event_thread->initiating_frame)) + if (current_id == ecs->event_thread->initiating_frame) { /* Case 2. Fall through. */ } @@ -6918,8 +6917,7 @@ process_event_stop_test (struct execution_control_state *ecs) if (pc_in_thread_step_range (ecs->event_thread->stop_pc (), ecs->event_thread) && (execution_direction != EXEC_REVERSE - || frame_id_eq (get_frame_id (frame), - ecs->event_thread->control.step_frame_id))) + || get_frame_id (frame) == ecs->event_thread->control.step_frame_id)) { infrun_debug_printf ("stepping inside range [%s-%s]", @@ -7053,7 +7051,7 @@ process_event_stop_test (struct execution_control_state *ecs) previous frame's ID is sufficient - but it is a common case and cheaper than checking the previous frame's ID. - NOTE: frame_id_eq will never report two invalid frame IDs as + NOTE: frame_id::operator== will never report two invalid frame IDs as being equal, so to get into this block, both the current and previous frame must have valid frame IDs. */ /* The outer_frame_id check is a heuristic to detect stepping @@ -7063,14 +7061,14 @@ process_event_stop_test (struct execution_control_state *ecs) "outermost" function. This could be fixed by marking outermost frames as !stack_p,code_p,special_p. Then the initial outermost frame, before sp was valid, would - have code_addr == &_start. See the comment in frame_id_eq + have code_addr == &_start. See the comment in frame_id::operator== for more. */ - if (!frame_id_eq (get_stack_frame_id (frame), - ecs->event_thread->control.step_stack_frame_id) - && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()), - ecs->event_thread->control.step_stack_frame_id) - && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id, - outer_frame_id) + if ((get_stack_frame_id (frame) + != ecs->event_thread->control.step_stack_frame_id) + && ((frame_unwind_caller_id (get_current_frame ()) + == ecs->event_thread->control.step_stack_frame_id) + && ((ecs->event_thread->control.step_stack_frame_id + != outer_frame_id) || (ecs->event_thread->control.step_start_function != find_pc_function (ecs->event_thread->stop_pc ()))))) { @@ -7327,8 +7325,8 @@ process_event_stop_test (struct execution_control_state *ecs) frame machinery detected some skipped call sites, we have entered a new inline function. */ - if (frame_id_eq (get_frame_id (get_current_frame ()), - ecs->event_thread->control.step_frame_id) + if ((get_frame_id (get_current_frame ()) + == ecs->event_thread->control.step_frame_id) && inline_skipped_frames (ecs->event_thread)) { infrun_debug_printf ("stepped into inlined function"); @@ -7376,8 +7374,8 @@ process_event_stop_test (struct execution_control_state *ecs) through a more inlined call beyond its call site. */ if (get_frame_type (get_current_frame ()) == INLINE_FRAME - && !frame_id_eq (get_frame_id (get_current_frame ()), - ecs->event_thread->control.step_frame_id) + && (get_frame_id (get_current_frame ()) + != ecs->event_thread->control.step_frame_id) && stepped_in_from (get_current_frame (), ecs->event_thread->control.step_frame_id)) { @@ -7409,8 +7407,8 @@ process_event_stop_test (struct execution_control_state *ecs) end_stepping_range (ecs); return; } - else if (frame_id_eq (get_frame_id (get_current_frame ()), - ecs->event_thread->control.step_frame_id)) + else if (get_frame_id (get_current_frame ()) + == ecs->event_thread->control.step_frame_id) { /* We are not at the start of a statement, and we have not changed frame. @@ -8467,8 +8465,8 @@ print_stop_location (const target_waitstatus &ws) should) carry around the function and does (or should) use that when doing a frame comparison. */ if (tp->control.stop_step - && frame_id_eq (tp->control.step_frame_id, - get_frame_id (get_current_frame ())) + && (tp->control.step_frame_id + == get_frame_id (get_current_frame ())) && (tp->control.step_start_function == find_pc_function (tp->stop_pc ()))) { diff --git a/gdb/mi/mi-cmd-stack.c b/gdb/mi/mi-cmd-stack.c index 70c51e6186e..8acb9cd6fd9 100644 --- a/gdb/mi/mi-cmd-stack.c +++ b/gdb/mi/mi-cmd-stack.c @@ -729,7 +729,7 @@ parse_frame_specification (const char *frame_exp) fid != NULL; fid = get_prev_frame (fid)) { - if (frame_id_eq (id, get_frame_id (fid))) + if (id == get_frame_id (fid)) { struct frame_info *prev_frame; @@ -737,7 +737,7 @@ parse_frame_specification (const char *frame_exp) { prev_frame = get_prev_frame (fid); if (!prev_frame - || !frame_id_eq (id, get_frame_id (prev_frame))) + || id != get_frame_id (prev_frame)) break; fid = prev_frame; } diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c index 80b5cd9bf90..6d8e510619e 100644 --- a/gdb/mi/mi-main.c +++ b/gdb/mi/mi-main.c @@ -1997,7 +1997,7 @@ struct user_selected_context reports not-equal, we only do the equality test if we have something other than the innermost frame selected. */ if (current_frame_level != -1 - && !frame_id_eq (current_frame_id, m_previous_frame_id)) + && current_frame_id != m_previous_frame_id) return true; /* Nothing changed! */ diff --git a/gdb/python/py-finishbreakpoint.c b/gdb/python/py-finishbreakpoint.c index c4b043f5bfe..317e2d708d9 100644 --- a/gdb/python/py-finishbreakpoint.c +++ b/gdb/python/py-finishbreakpoint.c @@ -207,7 +207,7 @@ bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs) else { frame_id = get_frame_id (prev_frame); - if (frame_id_eq (frame_id, null_frame_id)) + if (frame_id == null_frame_id) PyErr_SetString (PyExc_ValueError, _("Invalid ID for the `frame' object.")); } diff --git a/gdb/python/py-frame.c b/gdb/python/py-frame.c index 8bd2e0bc6da..0240da966ff 100644 --- a/gdb/python/py-frame.c +++ b/gdb/python/py-frame.c @@ -701,7 +701,7 @@ frapy_richcompare (PyObject *self, PyObject *other, int op) frame_object *other_frame = (frame_object *) other; if (self_frame->frame_id_is_next == other_frame->frame_id_is_next - && frame_id_eq (self_frame->frame_id, other_frame->frame_id)) + && self_frame->frame_id == other_frame->frame_id) result = Py_EQ; else result = Py_NE; diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index 3a56925f63e..bc1411ecb3f 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -2033,10 +2033,8 @@ record_btrace_start_replaying (struct thread_info *tp) frame_id = get_thread_current_frame_id (tp); /* Check if we need to update any stepping-related frame id's. */ - upd_step_frame_id = frame_id_eq (frame_id, - tp->control.step_frame_id); - upd_step_stack_frame_id = frame_id_eq (frame_id, - tp->control.step_stack_frame_id); + upd_step_frame_id = (frame_id == tp->control.step_frame_id); + upd_step_stack_frame_id = (frame_id == tp->control.step_stack_frame_id); /* We start replaying at the end of the branch trace. This corresponds to the current instruction. */ diff --git a/gdb/stack.c b/gdb/stack.c index 379635e409e..012aa5d57d5 100644 --- a/gdb/stack.c +++ b/gdb/stack.c @@ -3252,7 +3252,7 @@ find_frame_for_address (CORE_ADDR address) fid != NULL; fid = get_prev_frame (fid)) { - if (frame_id_eq (id, get_frame_id (fid))) + if (id == get_frame_id (fid)) { struct frame_info *prev_frame; @@ -3260,7 +3260,7 @@ find_frame_for_address (CORE_ADDR address) { prev_frame = get_prev_frame (fid); if (!prev_frame - || !frame_id_eq (id, get_frame_id (prev_frame))) + || id != get_frame_id (prev_frame)) break; fid = prev_frame; } diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c index 6f01f52a874..2f867a0606d 100644 --- a/gdb/tracepoint.c +++ b/gdb/tracepoint.c @@ -2190,8 +2190,7 @@ tfind_1 (enum trace_find_type type, int num, function and it's arguments) -- otherwise we'll just show the new source line. */ - if (frame_id_eq (old_frame_id, - get_frame_id (get_current_frame ()))) + if (old_frame_id == get_frame_id (get_current_frame ())) print_what = SRC_LINE; else print_what = SRC_AND_LOC; diff --git a/gdb/value.c b/gdb/value.c index 8ed941f3749..43023bf7ee4 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -4004,7 +4004,7 @@ value_fetch_lazy_register (struct value *val) in this situation. */ if (VALUE_LVAL (new_val) == lval_register && value_lazy (new_val) - && frame_id_eq (VALUE_NEXT_FRAME_ID (new_val), next_frame_id)) + && VALUE_NEXT_FRAME_ID (new_val) == next_frame_id) internal_error (__FILE__, __LINE__, _("infinite loop while fetching a register")); }