From patchwork Fri Apr 18 09:43:49 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 614 Return-Path: X-Original-To: siddhesh@wilcox.dreamhost.com Delivered-To: siddhesh@wilcox.dreamhost.com Received: from homiemail-mx22.g.dreamhost.com (mx2.sub5.homie.mail.dreamhost.com [208.113.200.128]) by wilcox.dreamhost.com (Postfix) with ESMTP id 98ECF36007A for ; Fri, 18 Apr 2014 02:43:58 -0700 (PDT) Received: by homiemail-mx22.g.dreamhost.com (Postfix, from userid 14314964) id 481A84C02DBB; Fri, 18 Apr 2014 02:43:58 -0700 (PDT) X-Original-To: gdb@patchwork.siddhesh.in Delivered-To: x14314964@homiemail-mx22.g.dreamhost.com Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by homiemail-mx22.g.dreamhost.com (Postfix) with ESMTPS id F37504C08325 for ; Fri, 18 Apr 2014 02:43:57 -0700 (PDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:message-id:date:from:mime-version:to:cc :subject:references:in-reply-to:content-type :content-transfer-encoding; q=dns; s=default; b=jLiOEShhgkgSNHDi n1RXgqA/kg2mk93HJtTKP1fntcqeERuRZ1bqDHbZOtpkSGm0wX9O3uSUTotQA7pL iWRawPTSVFyzlym9oJJEL2lzQakHNjShL3fIsG1jgLdX2140MCVtaCj8ZtHidKF6 AIVJxy5Vufh1xRnR2wYScdege8U= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:message-id:date:from:mime-version:to:cc :subject:references:in-reply-to:content-type :content-transfer-encoding; s=default; bh=JxJJxi7Lq9/S3LzmTclcoJ 0FQ0o=; b=CvfmoyyconvZxLbYrpbBsdbgCMa6IrvVUn9XdJ0QPZC+rRv+JqLe4c grGLEf6E1lLG068bcj/tv8IxR72rTNBG9g6+Lw0Eujh6MQX34e9QkWxmB1vRgq2z Wdh/ov6keco6ljjTeQQLZjAT1PKrspz8OVTk73sCJIAX2qvtzK3uw= Received: (qmail 28268 invoked by alias); 18 Apr 2014 09:43:55 -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 28256 invoked by uid 89); 18 Apr 2014 09:43:55 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.1 required=5.0 tests=AWL, BAYES_00, RP_MATCHES_RCVD, SPF_HELO_PASS, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 18 Apr 2014 09:43:53 +0000 Received: from int-mx14.intmail.prod.int.phx2.redhat.com (int-mx14.intmail.prod.int.phx2.redhat.com [10.5.11.27]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id s3I9hpIQ009146 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 18 Apr 2014 05:43:51 -0400 Received: from [127.0.0.1] (ovpn01.gateway.prod.ext.ams2.redhat.com [10.39.146.11]) by int-mx14.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id s3I9hnKT009304; Fri, 18 Apr 2014 05:43:50 -0400 Message-ID: <5350F3D5.5090200@redhat.com> Date: Fri, 18 Apr 2014 10:43:49 +0100 From: Pedro Alves User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130625 Thunderbird/17.0.7 MIME-Version: 1.0 To: Tom Tromey CC: Andrew Pinski , "gdb-patches@sourceware.org" Subject: Re: RFC: fix PR backtrace/15558 References: <87li6nghhz.fsf@fleche.redhat.com> <51B11E66.70102@redhat.com> <87mwqjw613.fsf@fleche.redhat.com> <87ha5vrdki.fsf@fleche.redhat.com> <534C2C19.1010503@redhat.com> <87tx9vpwvb.fsf@fleche.redhat.com> <534C6BDD.2090805@redhat.com> <87fvldnit4.fsf@fleche.redhat.com> In-Reply-To: <87fvldnit4.fsf@fleche.redhat.com> X-DH-Original-To: gdb@patchwork.siddhesh.in On 04/16/2014 09:03 PM, Tom Tromey wrote: >>>>>> "Pedro" == Pedro Alves writes: > Pedro> Not sure. I guess Python code might want to be implementing some > Pedro> new frame-related CLI command, where the limits make sense. Maybe > Pedro> Python should really have access to both variants, somehow? > > I was thinking perhaps new methods on the python frame object. Works for me. > Pedro> PR backtrace/15558 > Pedro> * gdb.opt/inline-bt.exp: Test backtracing from an inline function > Pedro> with a backtrace limit. > Pedro> * py-frame-inline.exp: Test running to an inline function with a > Pedro> bactrace limit, and printing the newest frame. > > Typo in "backtrace" on the last line. > > The patch looks good but the ChangeLog has a missing directory name and > doesn't mention : > >> gdb/testsuite/gdb.python/py-frame-inline.c | 4 +++- > Thank you. Fixed and pushed as below. I also removed the change to the comment about outer frames from the patch, as it's an unrelated change. ------ [PATCH] Fix PR backtrace/15558 This PR is about an assertion failure in GDB that can be triggered by setting "backtrace limit" to a value that causes GDB to stop unwinding after an inline frame. In this case, an assertion in inline_frame_this_id will trigger: /* We need a valid frame ID, so we need to be based on a valid frame. (...). */ gdb_assert (frame_id_p (*this_id)); Looking at the function: static void inline_frame_this_id (struct frame_info *this_frame, void **this_cache, struct frame_id *this_id) { struct symbol *func; /* In order to have a stable frame ID for a given inline function, we must get the stack / special addresses from the underlying real frame's this_id method. So we must call get_prev_frame. Because we are inlined into some function, there must be previous frames, so this is safe - as long as we're careful not to create any cycles. */ *this_id = get_frame_id (get_prev_frame (this_frame)); we see we're computing the frame id for the inline frame. If this is an inline frame, which is a virtual frame constructed based on debug info, on top of a real stack frame, we should _always_ be able to find where the frame was inlined into, as that ultimately just means peeling off the virtual frames on top of the real stack frame. If there ultimately was no prev (real) stack frame, then we wouldn't have been able to construct the inline frame either, by design. That's what the assertion catches. So we have an inline frame, we should _always_ be able to compute its ID, even if that means bypassing the user backtrace limits to get at the real stack frame's info. The problem is that inline_frame_id calls get_prev_frame, and that takes user backtrace limits into account. Code that wants to bypass the limits calls get_prev_frame_1 instead. Note how get_prev_frame_1 already skips all checks for inline frames: /* If we are unwinding from an inline frame, all of the below tests were already performed when we unwound from the next non-inline frame. We must skip them, since we can not get THIS_FRAME's ID until we have unwound all the way down to the previous non-inline frame. */ if (get_frame_type (this_frame) == INLINE_FRAME) return get_prev_frame_if_no_cycle (this_frame); And note how the related frame_unwind_caller_id function also uses get_prev_frame_1: struct frame_id frame_unwind_caller_id (struct frame_info *next_frame) { struct frame_info *this_frame; /* Use get_prev_frame_1, and not get_prev_frame. The latter will truncate the frame chain, leading to this function unintentionally returning a null_frame_id (e.g., when a caller requests the frame ID of "main()"s caller. */ next_frame = skip_artificial_frames (next_frame); this_frame = get_prev_frame_1 (next_frame); if (this_frame) return get_frame_id (skip_artificial_frames (this_frame)); else return null_frame_id; } get_prev_frame_1 is currently static in frame.c. As a _1 suffix is not a good name for an extern function, I've renamed it. Tested on x86-64 Fedora 17. gdb/ 2014-04-18 Pedro alves Tom Tromey PR backtrace/15558 * frame.c (get_prev_frame_1): Rename to ... (get_prev_frame_always): ... this, and make extern. Adjust. (skip_artificial_frames): Use get_prev_frame_always. (frame_unwind_caller_id, frame_pop, get_prev_frame) (get_frame_unwind_stop_reason): Adjust to rename. * frame.h (get_prev_frame_always): Declare. * inline-frame.c: Include frame.h. (inline_frame_this_id): Use get_prev_frame_always. gdb/testsuite/ 2014-04-18 Tom Tromey Pedro alves PR backtrace/15558 * gdb.opt/inline-bt.exp: Test backtracing from an inline function with a backtrace limit. * gdb.python/py-frame-inline.exp: Test running to an inline function with a backtrace limit, and printing the newest frame. * gdb.python/py-frame-inline.c (main): Call f. --- gdb/ChangeLog | 13 ++++++++++++ gdb/frame.c | 31 ++++++++++++++++------------ gdb/frame.h | 7 +++++++ gdb/inline-frame.c | 11 +++++----- gdb/testsuite/ChangeLog | 10 +++++++++ gdb/testsuite/gdb.opt/inline-bt.exp | 16 ++++++++++++++ gdb/testsuite/gdb.python/py-frame-inline.c | 4 +++- gdb/testsuite/gdb.python/py-frame-inline.exp | 14 +++++++++++++ 8 files changed, 87 insertions(+), 19 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index c9b914a..cad4602 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,16 @@ +2014-04-18 Pedro alves + Tom Tromey + + PR backtrace/15558 + * frame.c (get_prev_frame_1): Rename to ... + (get_prev_frame_always): ... this, and make extern. Adjust. + (skip_artificial_frames): Use get_prev_frame_always. + (frame_unwind_caller_id, frame_pop, get_prev_frame) + (get_frame_unwind_stop_reason): Adjust to rename. + * frame.h (get_prev_frame_always): Declare. + * inline-frame.c: Include frame.h. + (inline_frame_this_id): Use get_prev_frame_always. + 2014-04-18 Tristan Gingold * solib-darwin.c (darwin_solib_create_inferior_hook): Simplify diff --git a/gdb/frame.c b/gdb/frame.c index 97d54e9..013d602 100644 --- a/gdb/frame.c +++ b/gdb/frame.c @@ -46,7 +46,6 @@ #include "hashtab.h" #include "valprint.h" -static struct frame_info *get_prev_frame_1 (struct frame_info *this_frame); static struct frame_info *get_prev_frame_raw (struct frame_info *this_frame); static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason); @@ -425,9 +424,15 @@ fprint_frame (struct ui_file *file, struct frame_info *fi) static struct frame_info * skip_artificial_frames (struct frame_info *frame) { + /* Note we use get_prev_frame_always, and not get_prev_frame. The + latter will truncate the frame chain, leading to this function + unintentionally returning a null_frame_id (e.g., when the user + sets a backtrace limit). This is safe, because as these frames + are made up by GDB, there must be a real frame in the chain + below. */ while (get_frame_type (frame) == INLINE_FRAME || get_frame_type (frame) == TAILCALL_FRAME) - frame = get_prev_frame (frame); + frame = get_prev_frame_always (frame); return frame; } @@ -484,13 +489,13 @@ frame_unwind_caller_id (struct frame_info *next_frame) { struct frame_info *this_frame; - /* Use get_prev_frame_1, and not get_prev_frame. The latter will truncate - the frame chain, leading to this function unintentionally - returning a null_frame_id (e.g., when a caller requests the frame - ID of "main()"s caller. */ + /* Use get_prev_frame_always, and not get_prev_frame. The latter + will truncate the frame chain, leading to this function + unintentionally returning a null_frame_id (e.g., when a caller + requests the frame ID of "main()"s caller. */ next_frame = skip_artificial_frames (next_frame); - this_frame = get_prev_frame_1 (next_frame); + this_frame = get_prev_frame_always (next_frame); if (this_frame) return get_frame_id (skip_artificial_frames (this_frame)); else @@ -956,7 +961,7 @@ frame_pop (struct frame_info *this_frame) } /* Ensure that we have a frame to pop to. */ - prev_frame = get_prev_frame_1 (this_frame); + prev_frame = get_prev_frame_always (this_frame); if (!prev_frame) error (_("Cannot pop the initial frame.")); @@ -1775,8 +1780,8 @@ get_prev_frame_if_no_cycle (struct frame_info *this_frame) Unlike get_prev_frame, this function always tries to unwind the frame. */ -static struct frame_info * -get_prev_frame_1 (struct frame_info *this_frame) +struct frame_info * +get_prev_frame_always (struct frame_info *this_frame) { struct gdbarch *gdbarch; @@ -1785,7 +1790,7 @@ get_prev_frame_1 (struct frame_info *this_frame) if (frame_debug) { - fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_1 (this_frame="); + fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_always (this_frame="); if (this_frame != NULL) fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level); else @@ -2137,7 +2142,7 @@ get_prev_frame (struct frame_info *this_frame) return NULL; } - return get_prev_frame_1 (this_frame); + return get_prev_frame_always (this_frame); } CORE_ADDR @@ -2523,7 +2528,7 @@ enum unwind_stop_reason get_frame_unwind_stop_reason (struct frame_info *frame) { /* Fill-in STOP_REASON. */ - get_prev_frame_1 (frame); + get_prev_frame_always (frame); gdb_assert (frame->prev_p); return frame->stop_reason; diff --git a/gdb/frame.h b/gdb/frame.h index e451a93..b88bd28 100644 --- a/gdb/frame.h +++ b/gdb/frame.h @@ -307,6 +307,13 @@ extern void select_frame (struct frame_info *); extern struct frame_info *get_prev_frame (struct frame_info *); extern struct frame_info *get_next_frame (struct frame_info *); +/* Return a "struct frame_info" corresponding to the frame that called + THIS_FRAME. Returns NULL if there is no such frame. + + Unlike get_prev_frame, this function always tries to unwind the + frame. */ +extern struct frame_info *get_prev_frame_always (struct frame_info *); + /* Given a frame's ID, relocate the frame. Returns NULL if the frame is not found. */ extern struct frame_info *frame_find_by_id (struct frame_id id); diff --git a/gdb/inline-frame.c b/gdb/inline-frame.c index 05ba9ff..eb82143 100644 --- a/gdb/inline-frame.c +++ b/gdb/inline-frame.c @@ -26,6 +26,7 @@ #include "regcache.h" #include "symtab.h" #include "vec.h" +#include "frame.h" #include "gdb_assert.h" @@ -154,11 +155,11 @@ inline_frame_this_id (struct frame_info *this_frame, /* In order to have a stable frame ID for a given inline function, we must get the stack / special addresses from the underlying - real frame's this_id method. So we must call get_prev_frame. - Because we are inlined into some function, there must be previous - frames, so this is safe - as long as we're careful not to - create any cycles. */ - *this_id = get_frame_id (get_prev_frame (this_frame)); + real frame's this_id method. So we must call + get_prev_frame_always. Because we are inlined into some + function, there must be previous frames, so this is safe - as + long as we're careful not to create any cycles. */ + *this_id = get_frame_id (get_prev_frame_always (this_frame)); /* We need a valid frame ID, so we need to be based on a valid frame. FSF submission NOTE: this would be a good assertion to diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 6f5f9aa..08a3a61 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,13 @@ +2014-04-18 Tom Tromey + Pedro alves + + PR backtrace/15558 + * gdb.opt/inline-bt.exp: Test backtracing from an inline function + with a backtrace limit. + * gdb.python/py-frame-inline.exp: Test running to an inline + function with a backtrace limit, and printing the newest frame. + * gdb.python/py-frame-inline.c (main): Call f. + 2014-04-17 Marcus Shawcroft * gdb.java/jnpe.exp: Drop srcdir from untested path. diff --git a/gdb/testsuite/gdb.opt/inline-bt.exp b/gdb/testsuite/gdb.opt/inline-bt.exp index c437383..ce73623 100644 --- a/gdb/testsuite/gdb.opt/inline-bt.exp +++ b/gdb/testsuite/gdb.opt/inline-bt.exp @@ -50,3 +50,19 @@ gdb_test "up" "#1 .*func1.*" "up from bar (3)" gdb_test "info frame" ".*inlined into frame.*" "func1 inlined (3)" gdb_test "up" "#2 .*func2.*" "up from func1 (3)" gdb_test "info frame" ".*inlined into frame.*" "func2 inlined (3)" + +# A regression test for having a backtrace limit that forces unwinding +# to stop after an inline frame. GDB needs to compute the frame_id of +# the inline frame, which requires unwinding past all the inline +# frames to the real stack frame, even if that means bypassing the +# user visible backtrace limit. See PR backtrace/15558. +# +# Set a backtrace limit that forces an unwind stop after an inline +# function. +gdb_test_no_output "set backtrace limit 2" +# Force flushing the frame cache. +gdb_test "flushregs" "Register cache flushed." +gdb_test "up" "#1 .*func1.*" "up from bar (4)" +gdb_test "info frame" ".*in func1.*" "info frame still works" +# Verify the user visible limit works as expected. +gdb_test "up" "Initial frame selected; you cannot go up." "up hits limit" diff --git a/gdb/testsuite/gdb.python/py-frame-inline.c b/gdb/testsuite/gdb.python/py-frame-inline.c index a3669bc..f08e84b 100644 --- a/gdb/testsuite/gdb.python/py-frame-inline.c +++ b/gdb/testsuite/gdb.python/py-frame-inline.c @@ -39,5 +39,7 @@ g (void) int main (void) { - return g (); + int x = g (); + x += f (); + return x; } diff --git a/gdb/testsuite/gdb.python/py-frame-inline.exp b/gdb/testsuite/gdb.python/py-frame-inline.exp index f5cf33e..8851d87 100644 --- a/gdb/testsuite/gdb.python/py-frame-inline.exp +++ b/gdb/testsuite/gdb.python/py-frame-inline.exp @@ -37,3 +37,17 @@ gdb_test "info frame" "inlined into frame 1\r\n.*" gdb_test "up" "#1 g .*" gdb_test "python print (gdb.selected_frame().read_var('l'))" "\r\n42" + +# A regression test for having a backtrace limit that forces unwinding +# to stop after an inline frame. GDB needs to compute the frame_id of +# the inline frame, which requires unwinding past all the inline +# frames to the real stack frame, even if that means bypassing the +# user visible backtrace limit. See PR backtrace/15558. +# +# Set the limit, and run to an inline function. It's important that +# the frame cache is flushed somehow after setting the limit, to force +# frame id recomputation. +gdb_test_no_output "set backtrace limit 1" +gdb_continue_to_breakpoint "Block break here." + +gdb_test "python print (gdb.newest_frame())" ".*"