From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 76E20382F0B7 for ; Tue, 30 Aug 2022 10:08:50 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 76E20382F0B7 Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-81-5AjAxOZZNcSG_0vxSTgihQ-1; Tue, 30 Aug 2022 06:08:44 -0400 X-MC-Unique: 5AjAxOZZNcSG_0vxSTgihQ-1 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.rdu2.redhat.com [10.11.54.5]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 2ACA085A58C; Tue, 30 Aug 2022 10:08:44 +0000 (UTC) Received: from fedora.redhat.com (unknown [10.43.2.105]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 65DC9909FF; Tue, 30 Aug 2022 10:08:43 +0000 (UTC) From: Bruno Larsen To: gdb-patches@sourceware.org Cc: blarsen@redhat.com, Tom Tromey Subject: [PATCH v4 1/5] Remove frame_id_eq Date: Tue, 30 Aug 2022 12:08:33 +0200 Message-Id: <20220830100837.926692-2-blarsen@redhat.com> In-Reply-To: <20220830100837.926692-1-blarsen@redhat.com> References: <20220830100837.926692-1-blarsen@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.11.54.5 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="US-ASCII"; x-default=true X-Spam-Status: No, score=-12.4 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 30 Aug 2022 10:09:05 -0000 From: Tom Tromey 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. --- gdb/breakpoint.c | 2 +- gdb/dummy-frame.c | 4 +-- gdb/elfread.c | 2 +- gdb/frame-unwind.c | 2 +- gdb/frame.c | 27 +++++++++---------- gdb/frame.h | 30 ++++++++------------- gdb/guile/scm-frame.c | 2 +- gdb/ia64-tdep.c | 4 +-- gdb/infrun.c | 46 +++++++++++++++----------------- gdb/mi/mi-cmd-stack.c | 4 +-- gdb/mi/mi-main.c | 2 +- gdb/python/py-finishbreakpoint.c | 2 +- gdb/python/py-frame.c | 2 +- gdb/record-btrace.c | 6 ++--- gdb/stack.c | 4 +-- gdb/tracepoint.c | 3 +-- gdb/value.c | 2 +- 17 files changed, 65 insertions(+), 79 deletions(-) diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index dae96d205be..5397dee6733 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -5323,7 +5323,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 ())) { bs->stop = 0; return; 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 08db208ebbb..e8b4a8e9177 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 ae45e22d613..c0cf3d585bf 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 b7c1c0decae..1e24debf17f 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 033699bc3f7..f846eb050a5 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 0fe204dbc66..40c1345404d 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 68868e49e99..ee2e9acf634 100644 --- a/gdb/mi/mi-main.c +++ b/gdb/mi/mi-main.c @@ -2003,7 +2003,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 c80096f6810..2d476114b35 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 9a28c36c1cc..9b3a0ac142b 100644 --- a/gdb/python/py-frame.c +++ b/gdb/python/py-frame.c @@ -704,7 +704,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 80801ccdb01..6e0f58565fe 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 75ac0cef3b0..98f1563a89a 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 557e22154eb..3a0cac741e4 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")); } -- 2.37.2