From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca (simark.ca [158.69.221.121]) by sourceware.org (Postfix) with ESMTPS id A70913858C2A for ; Thu, 21 Dec 2023 19:19:20 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org A70913858C2A Authentication-Results: sourceware.org; dmarc=fail (p=none dis=none) header.from=efficios.com Authentication-Results: sourceware.org; spf=fail smtp.mailfrom=efficios.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org A70913858C2A Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=158.69.221.121 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1703186362; cv=none; b=OoYd6DE/valVMGOHyzWIUm9jRGGvizMwqqT/Fpqd19wQamsL36xcldxWudxbRy/W7A+H+WO+y9xnoxsKO1u2YyZ26gEaeMmqlLtsm1ggTDHzBunClHaVHoSjXsx23gYEpP5lXWVtF18eXTkwuLfzmYRk9ID9qqoaXUG9ardxSzo= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1703186362; c=relaxed/simple; bh=P/Avty0IEMcVAywFWg6nLhXC2TDdE/f9BDr1U+ZiqHU=; h=From:To:Subject:Date:Message-ID:MIME-Version; b=lfBQsimwojhUCeHRfTZ7EmQev2XzVs0nlfu7znfiTedmkSLo9KzOqMj07NdMhQqunx6gYsDSXDL7xMeLY3ueEX+8ct8sYSFxhE+U8h825xdoOmeoOoxBjxqzgFJntMKUfF6WAhzHNy8Z5bzRfeATjcYHUsrHVGcsOrMXwjthaCM= ARC-Authentication-Results: i=1; server2.sourceware.org Received: from smarchi-efficios.internal.efficios.com (192-222-143-198.qc.cable.ebox.net [192.222.143.198]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPSA id 3A1681E0BB; Thu, 21 Dec 2023 14:19:20 -0500 (EST) From: Simon Marchi To: gdb-patches@sourceware.org Cc: Simon Marchi Subject: [PATCH 9/9] gdb: make value::allocate_register_lazy store id of next non-inline frame Date: Thu, 21 Dec 2023 14:16:30 -0500 Message-ID: <20231221191716.257256-10-simon.marchi@efficios.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20231221191716.257256-1-simon.marchi@efficios.com> References: <20231221191716.257256-1-simon.marchi@efficios.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spam-Status: No, score=-3496.5 required=5.0 tests=BAYES_00,GIT_PATCH_0,KAM_DMARC_NONE,KAM_DMARC_STATUS,SPF_HELO_PASS,SPF_SOFTFAIL,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 List-Id: Some spots loop on the frame chain to find the first next non-inline frame, and pass that as the "next frame" to value::allocate_register_lazy / value::allocate_register. This is necessary if the value is used in the process of computing the id of "this frame". If the frame next to "this frame" is inlined into "this frame", then you that next frame won't have a computed id yet. You have to go past that to find the next non-inline frame, which will have a computed id. In other cases, it's fine to store the id of an inline frame as the "next frame id" in a register struct value. When trying to unwind a register from it, it will just call inline_frame_prev_register, which will forward the request to the next next frame, until we hit the next physical frame. I think it would make things simpler to just never store the id of an inline frame as the next frame id of register struct values, and go with the first next non-inline frame directly. This way, we don't have to wonder which code paths have to skip inline frames when creating register values and which don't. So, change value::allocate_register_lazy to do that work, and remove the loops for the callers that did it. Change-Id: Ic88115dac49dc14e3053c95f92050062b24b7310 --- gdb/findvar.c | 19 +++---------------- gdb/rs6000-tdep.c | 7 ++----- gdb/value.c | 12 ++++++++++++ gdb/value.h | 8 ++++---- 4 files changed, 21 insertions(+), 25 deletions(-) diff --git a/gdb/findvar.c b/gdb/findvar.c index 7c360eb37ff9..90d3385b36d8 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -270,17 +270,6 @@ value_of_register_lazy (frame_info_ptr next_frame, int regnum) gdb_assert (regnum < gdbarch_num_cooked_regs (gdbarch)); gdb_assert (next_frame != nullptr); - /* In some cases NEXT_FRAME may not have a valid frame-id yet. This can - happen if we end up trying to unwind a register as part of the frame - sniffer. The only time that we get here without a valid frame-id is - if NEXT_FRAME is an inline frame. If this is the case then we can - avoid getting into trouble here by skipping past the inline frames. */ - while (get_frame_type (next_frame) == INLINE_FRAME) - next_frame = get_next_frame_sentinel_okay (next_frame); - - /* We should have a valid next frame. */ - gdb_assert (frame_id_p (get_frame_id (next_frame))); - return value::allocate_register_lazy (next_frame, regnum); } @@ -746,11 +735,9 @@ value * default_value_from_register (gdbarch *gdbarch, type *type, int regnum, frame_info_ptr this_frame) { - frame_info_ptr next_frame = get_next_frame_sentinel_okay (this_frame); - while (get_frame_type (next_frame) == INLINE_FRAME) - next_frame = get_next_frame_sentinel_okay (next_frame); - - value *value = value::allocate_register (next_frame, regnum, type); + value *value + = value::allocate_register (get_next_frame_sentinel_okay (this_frame), + regnum, type); /* Any structure stored in more than one register will always be an integral number of registers. Otherwise, you need to do diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c index edf776853e20..1c9bb3e5f04f 100644 --- a/gdb/rs6000-tdep.c +++ b/gdb/rs6000-tdep.c @@ -2755,12 +2755,9 @@ rs6000_value_from_register (gdbarch *gdbarch, type *type, int regnum, fpr to vsr. */ regnum = ieee_128_float_regnum_adjust (gdbarch, type, regnum); - frame_info_ptr next_frame = get_next_frame_sentinel_okay (this_frame); - while (get_frame_type (next_frame) == INLINE_FRAME) - next_frame = get_next_frame_sentinel_okay (next_frame); - value *value - = value::allocate_register (next_frame, regnum, type); + = value::allocate_register (get_next_frame_sentinel_okay (this_frame), + regnum, type); /* Any structure stored in more than one register will always be an integral number of registers. Otherwise, you need to do diff --git a/gdb/value.c b/gdb/value.c index a69bc348167a..92e62d655d0c 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -972,8 +972,20 @@ value::allocate_register_lazy (frame_info_ptr next_frame, int regnum, result->set_lval (lval_register); result->m_location.reg.regnum = regnum; + + /* If this register value is created during unwind (while computing a frame + id), and NEXT_FRAME is a frame inlined in the frame being unwound, then + NEXT_FRAME will not have a valid frame id yet. Find the next non-inline + frame (possibly the sentinel frame). This is where registers are unwound + from anyway. */ + while (get_frame_type (next_frame) == INLINE_FRAME) + next_frame = get_next_frame_sentinel_okay (next_frame); + result->m_location.reg.next_frame_id = get_frame_id (next_frame); + /* We should have a next frame with a valid id. */ + gdb_assert (frame_id_p (result->m_location.reg.next_frame_id)); + return result; } diff --git a/gdb/value.h b/gdb/value.h index f1202007bb4f..22b3a09e5a5b 100644 --- a/gdb/value.h +++ b/gdb/value.h @@ -680,10 +680,10 @@ struct value { /* Register number. */ int regnum; - /* Frame ID of "next" frame to which a register value is relative. - If the register value is found relative to frame F, then the - frame id of F->next will be stored in next_frame_id. */ - struct frame_id next_frame_id; + + /* Frame ID of the next physical (non-inline) frame to which a register + value is relative. */ + frame_id next_frame_id; } reg; /* Pointer to internal variable. */ -- 2.43.0