From patchwork Thu Feb 20 15:58:20 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 38258 Received: (qmail 81408 invoked by alias); 20 Feb 2020 15:58:28 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 81331 invoked by uid 89); 20 Feb 2020 15:58:28 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-22.5 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.1 spammy=frame_info, 12356 X-HELO: rock.gnat.com Received: from rock.gnat.com (HELO rock.gnat.com) (205.232.38.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 20 Feb 2020 15:58:25 +0000 Received: from localhost (localhost.localdomain [127.0.0.1]) by filtered-rock.gnat.com (Postfix) with ESMTP id 646EF5608D; Thu, 20 Feb 2020 10:58:23 -0500 (EST) Received: from rock.gnat.com ([127.0.0.1]) by localhost (rock.gnat.com [127.0.0.1]) (amavisd-new, port 10024) with LMTP id HHMLdmPXaS-Z; Thu, 20 Feb 2020 10:58:23 -0500 (EST) Received: from murgatroyd.Home (75-166-123-50.hlrn.qwest.net [75.166.123.50]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by rock.gnat.com (Postfix) with ESMTPSA id 1B1A056092; Thu, 20 Feb 2020 10:58:23 -0500 (EST) From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [PATCH] Find tailcall frames before inline frames Date: Thu, 20 Feb 2020 08:58:20 -0700 Message-Id: <20200220155820.22809-1-tromey@adacore.com> MIME-Version: 1.0 A customer reported a failure to unwind in a certain core dump. A lengthy investigation showed that the problem came from the interaction between the tailcall and inline frame sniffers. Normally, the regular DWARF unwinder may discover a chain of tail calls ending in the current frame. In this case, it sets a member on the dwarf2_frame_cache object, so that a subsequent call into the tailcall sniffer will create the tailcall frames. However, in this scenario, what happened is that the DWARF unwinder did find tailcall frames -- but then the PC of the first such frame was recognized and claimed by the inline frame sniffer. This then caused unwinding to go astray further up the stack. This patch fixes the problem by arranging for the tailcall sniffer to be called before the inline sniffer. This way, if a DWARF frame has tailcall information, the tailcalls will always be processed first. This is safe to do, because the tailcall sniffer can only claim a frame if the previous frame did in fact find this information. (So, for example, if no DWARF frame is ever found, then this sniffer will never trigger.) This patch also partially reverts: commit 1ec56e88aa9b052ab10b806d82fbdbc8d153d977 Author: Pedro Alves Date: Fri Nov 22 13:17:46 2013 +0000 Eliminate dwarf2_frame_cache recursion, don't unwind from the dwarf2 sniffer (move dwarf2_tailcall_sniffer_first elsewhere). That patch moved the call to dwarf2_tailcall_sniffer_first out of dwarf2_frame_cache, and into dwarf2_frame_prev_register. However, in this situation, this is too late -- by the time dwarf2_frame_prev_register is called, the frame in question is already recognized by the inline frame sniffer. Rather than fully revert that patch, though, this just arranges to call dwarf2_tailcall_sniffer_first from dwarf2_frame_cache -- which is called shortly after the DWARF frame sniffer succeeds, via compute_frame_id. I don't know how to write a test case for this. gdb/ChangeLog 2020-02-20 Tom Tromey * dwarf2/frame.c (struct dwarf2_frame_cache) : Remove members. (dwarf2_frame_cache): Call dwarf2_tailcall_sniffer_first. (dwarf2_frame_prev_register): Don't call dwarf2_tailcall_sniffer_first. (dwarf2_append_unwinders): Don't append tailcall unwinder. * frame-unwind.c (add_unwinder): New fuction. (frame_unwind_init): Use it. Add tailcall unwinder. --- gdb/ChangeLog | 12 ++++++++++++ gdb/dwarf2/frame.c | 34 ++++++++-------------------------- gdb/frame-unwind.c | 33 +++++++++++++++++++++++++++------ 3 files changed, 47 insertions(+), 32 deletions(-) diff --git a/gdb/dwarf2/frame.c b/gdb/dwarf2/frame.c index b240a25e2d8..74488f9a8aa 100644 --- a/gdb/dwarf2/frame.c +++ b/gdb/dwarf2/frame.c @@ -959,22 +959,12 @@ struct dwarf2_frame_cache /* The .text offset. */ CORE_ADDR text_offset; - /* True if we already checked whether this frame is the bottom frame - of a virtual tail call frame chain. */ - int checked_tailcall_bottom; - /* If not NULL then this frame is the bottom frame of a TAILCALL_FRAME sequence. If NULL then it is a normal case with no TAILCALL_FRAME involved. Non-bottom frames of a virtual tail call frames chain use dwarf2_tailcall_frame_unwind unwinder so this field does not apply for them. */ void *tailcall_cache; - - /* The number of bytes to subtract from TAILCALL_FRAME frames frame - base to get the SP, to simulate the return address pushed on the - stack. */ - LONGEST entry_cfa_sp_offset; - int entry_cfa_sp_offset_p; }; static struct dwarf2_frame_cache * @@ -1037,6 +1027,8 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) in an address that's within the range of FDE locations. This is due to the possibility of the function occupying non-contiguous ranges. */ + LONGEST entry_cfa_sp_offset; + int entry_cfa_sp_offset_p = 0; if (get_frame_func_if_available (this_frame, &entry_pc) && fde->initial_location <= entry_pc && entry_pc < fde->initial_location + fde->address_range) @@ -1049,8 +1041,8 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache) && (dwarf_reg_to_regnum (gdbarch, fs.regs.cfa_reg) == gdbarch_sp_regnum (gdbarch))) { - cache->entry_cfa_sp_offset = fs.regs.cfa_offset; - cache->entry_cfa_sp_offset_p = 1; + entry_cfa_sp_offset = fs.regs.cfa_offset; + entry_cfa_sp_offset_p = 1; } } else @@ -1195,6 +1187,10 @@ incomplete CFI data; unspecified registers (e.g., %s) at %s"), && fs.regs.reg[fs.retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED) cache->undefined_retaddr = 1; + dwarf2_tailcall_sniffer_first (this_frame, &cache->tailcall_cache, + (entry_cfa_sp_offset_p + ? &entry_cfa_sp_offset : NULL)); + return cache; } @@ -1239,16 +1235,6 @@ dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache, CORE_ADDR addr; int realnum; - /* Check whether THIS_FRAME is the bottom frame of a virtual tail - call frame chain. */ - if (!cache->checked_tailcall_bottom) - { - cache->checked_tailcall_bottom = 1; - dwarf2_tailcall_sniffer_first (this_frame, &cache->tailcall_cache, - (cache->entry_cfa_sp_offset_p - ? &cache->entry_cfa_sp_offset : NULL)); - } - /* Non-bottom frames of a virtual tail call frames chain use dwarf2_tailcall_frame_unwind unwinder so this code does not apply for them. If dwarf2_tailcall_prev_register_first does not have specific value @@ -1410,10 +1396,6 @@ static const struct frame_unwind dwarf2_signal_frame_unwind = void dwarf2_append_unwinders (struct gdbarch *gdbarch) { - /* TAILCALL_FRAME must be first to find the record by - dwarf2_tailcall_sniffer_first. */ - frame_unwind_append_unwinder (gdbarch, &dwarf2_tailcall_frame_unwind); - frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind); frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind); } diff --git a/gdb/frame-unwind.c b/gdb/frame-unwind.c index 35f2e82c57d..3334c472d02 100644 --- a/gdb/frame-unwind.c +++ b/gdb/frame-unwind.c @@ -27,6 +27,7 @@ #include "gdb_obstack.h" #include "target.h" #include "gdbarch.h" +#include "dwarf2/frame-tailcall.h" static struct gdbarch_data *frame_unwind_data; @@ -43,6 +44,18 @@ struct frame_unwind_table struct frame_unwind_table_entry **osabi_head; }; +/* A helper function to add an unwinder to a list. LINK says where to + install the new unwinder. The new link is returned. */ + +static struct frame_unwind_table_entry ** +add_unwinder (struct obstack *obstack, const struct frame_unwind *unwinder, + struct frame_unwind_table_entry **link) +{ + *link = OBSTACK_ZALLOC (obstack, struct frame_unwind_table_entry); + (*link)->unwinder = unwinder; + return &(*link)->next; +} + static void * frame_unwind_init (struct obstack *obstack) { @@ -51,13 +64,21 @@ frame_unwind_init (struct obstack *obstack) /* Start the table out with a few default sniffers. OSABI code can't override this. */ - table->list = OBSTACK_ZALLOC (obstack, struct frame_unwind_table_entry); - table->list->unwinder = &dummy_frame_unwind; - table->list->next = OBSTACK_ZALLOC (obstack, - struct frame_unwind_table_entry); - table->list->next->unwinder = &inline_frame_unwind; + struct frame_unwind_table_entry **link = &table->list; + + link = add_unwinder (obstack, &dummy_frame_unwind, link); + /* The DWARF tailcall sniffer must come before the inline sniffer. + Otherwise, we can end up in a situation where a DWARF frame finds + tailcall information, but then the inline sniffer claims a frame + before the tailcall sniffer, resulting in confusion. This is + safe to do always because the tailcall sniffer can only ever be + activated if the newer frame was created using the DWARF + unwinder, and it also found tailcall information. */ + link = add_unwinder (obstack, &dwarf2_tailcall_frame_unwind, link); + link = add_unwinder (obstack, &inline_frame_unwind, link); + /* The insertion point for OSABI sniffers. */ - table->osabi_head = &table->list->next->next; + table->osabi_head = link; return table; }