From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 90321 invoked by alias); 19 Jun 2018 15:46:47 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 90311 invoked by uid 89); 19 Jun 2018 15:46:46 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-3.5 required=5.0 tests=AWL,BAYES_00,MIME_BASE64_BLANKS,RCVD_IN_DNSWL_NONE,SPF_HELO_PASS,SPF_PASS autolearn=ham version=3.3.2 spammy= X-HELO: EUR01-DB5-obe.outbound.protection.outlook.com Received: from mail-db5eur01on0052.outbound.protection.outlook.com (HELO EUR01-DB5-obe.outbound.protection.outlook.com) (104.47.2.52) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 19 Jun 2018 15:46:45 +0000 Received: from DB6PR0802MB2133.eurprd08.prod.outlook.com (10.172.226.148) by DB6PR0802MB2486.eurprd08.prod.outlook.com (10.172.251.21) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.863.19; Tue, 19 Jun 2018 15:46:41 +0000 Received: from DB6PR0802MB2133.eurprd08.prod.outlook.com ([fe80::a152:f8f6:6608:7624]) by DB6PR0802MB2133.eurprd08.prod.outlook.com ([fe80::a152:f8f6:6608:7624%5]) with mapi id 15.20.0863.016; Tue, 19 Jun 2018 15:46:42 +0000 From: Alan Hayward To: Simon Marchi CC: GDB Patches , nd Subject: Re: [PATCH] Support large registers in regcache transfer_regset Date: Tue, 19 Jun 2018 15:46:00 -0000 Message-ID: References: <20180612080356.33157-1-alan.hayward@arm.com> <6bba6aa4-c350-e5fb-3913-823eccae60ef@simark.ca> <85CCB6E0-63F0-4298-B328-D43D3207A91E@arm.com> In-Reply-To: authentication-results: spf=none (sender IP is ) smtp.mailfrom=Alan.Hayward@arm.com; x-ms-publictraffictype: Email x-ms-exchange-antispam-srfa-diagnostics: SOS; x-ms-office365-filtering-ht: Tenant x-ms-office365-filtering-correlation-id: d35f280a-0475-4022-befe-08d5d5fbda7f x-ms-traffictypediagnostic: DB6PR0802MB2486: nodisclaimer: True x-exchange-antispam-report-test: UriScan:; x-ms-exchange-senderadcheck: 1 x-forefront-prvs: 07083FF734 received-spf: None (protection.outlook.com: arm.com does not designate permitted sender hosts) spamdiagnosticoutput: 1:99 spamdiagnosticmetadata: NSPM Content-Type: text/plain; charset="utf-8" Content-ID: <0ED96CD4853BBB47B1E129A19B5AE6B7@eurprd08.prod.outlook.com> Content-Transfer-Encoding: base64 MIME-Version: 1.0 X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-Network-Message-Id: d35f280a-0475-4022-befe-08d5d5fbda7f X-MS-Exchange-CrossTenant-originalarrivaltime: 19 Jun 2018 15:46:42.0699 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: f34e5979-57d9-4aaa-ad4d-b122a662184d X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB6PR0802MB2486 X-IsSubscribed: yes X-SW-Source: 2018-06/txt/msg00479.txt.bz2 DQoNCj4gT24gMTkgSnVuIDIwMTgsIGF0IDE1OjUyLCBTaW1vbiBNYXJjaGkg PHNpbWFya0BzaW1hcmsuY2E+IHdyb3RlOg0KPiANCj4gT24gMjAxOC0wNi0x OSAwNzoyNywgQWxhbiBIYXl3YXJkIHdyb3RlOg0KPj4+PiArLyogU2VlIHJl Z2NhY2hlLmguICAqLw0KPj4+PiArDQo+Pj4+ICt2b2lkDQo+Pj4+ICtyZWdf YnVmZmVyOjpyYXdfY29sbGVjdF9wYXJ0IChpbnQgcmVnbnVtLCBpbnQgb2Zm c2V0LCBpbnQgbGVuLCB2b2lkICppbikgY29uc3QNCj4+Pj4gK3sNCj4+Pj4g KyAgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2ggPSBhcmNoICgpOw0KPj4+PiAr ICBnZGJfYnl0ZSAqcmVnID0gKGdkYl9ieXRlICopIGFsbG9jYSAocmVnaXN0 ZXJfc2l6ZSAoZ2RiYXJjaCwgcmVnbnVtKSk7DQo+Pj4+ICsNCj4+Pj4gKyAg Z2RiX2Fzc2VydCAoaW4gIT0gTlVMTCk7DQo+Pj4+ICsgIGdkYl9hc3NlcnQg KG9mZnNldCA+PSAwICYmIG9mZnNldCA8PSBtX2Rlc2NyLT5zaXplb2ZfcmVn aXN0ZXJbcmVnbnVtXSk7DQo+Pj4+ICsgIGdkYl9hc3NlcnQgKGxlbiA+PSAw ICYmIG9mZnNldCArIGxlbiA8PSBtX2Rlc2NyLT5zaXplb2ZfcmVnaXN0ZXJb cmVnbnVtXSk7DQo+Pj4gVGhlICImJiBvZmZzZXQgPD0gbV9kZXNjci0+c2l6 ZW9mX3JlZ2lzdGVyW3JlZ251bV0iIGlzIHJlZHVuZGFudCwgZ2l2ZW4gdGhl DQo+Pj4gZm9sbG93aW5nIGxpbmUuICBPdGhlciB0aGFuIG1pbWlja2luZyBy YXdfcmVhZF9wYXJ0LCBpcyB0aGVyZSBhIHJlYXNvbiB3aHkNCj4+PiB0aGVz ZSBhcmUgc2lnbmVkIGludGVnZXJzPyAgSGF2aW5nIHRoZW0gdW5zaWduZWQg d291bGQgYXZvaWQgaGF2aW5nIHRvIGFzc2VydA0KPj4+IHRoZXkgYXJlID49 IDAuDQo+PiBMb29raW5nIGF0IHJlZ2NhY2hlLCBpbnQgaXMgdXNlZCBmb3Ig cmVnbnVtIHRocm91Z2hvdXQuIEnigJlkIHJhdGhlciBub3QgaGF2ZSBhDQo+ PiBtaXNtYXRjaCwgYW5kIHdvdWxkbuKAmXQgd2FudCB0byB1cGRhdGUgZXZl cnl0aGluZyBlbHNlIGVpdGhlciAoYXQgbGVhc3Qgbm90DQo+PiBpbiB0aGlz IHBhdGNoKS4gSW4gYWRkaXRpb24sIGlmIHRoaXMgY29kZSBpcyBnb2luZyB0 byBub3cgY2FsbCBkb3duIHRvDQo+PiByYXdfY29sbGVjdC9yYXdfc3VwcGx5 LCB0aGV5IHNob3VsZCBtYXRjaC4NCj4gDQo+IFNvcnJ5LCBJIHdhcyB0YWxr aW5nIGFib3V0IGxlbiBhbmQgb2Zmc2V0LCBub3QgcmVnbnVtLg0KPiANCj4g U2ltb24NCg0KQWgsIG9rLiBJZiBkb2luZyB0aGF0LCB0aGVuIGl04oCZZCBt YWtlIHNlbnNlIHRvIHVwZGF0ZSByZWdjYWNoZV9tYXBfZW50cnkgdG8gdXNl DQp1bnNpZ25lZCBpbnRzIGZvciBjb3VudCBhbmQgc2l6ZS4NCg0Kc3RydWN0 IHJlZ2NhY2hlX21hcF9lbnRyeQ0Kew0KICBpbnQgY291bnQ7DQogIGludCBy ZWdubzsNCiAgaW50IHNpemU7DQp9Ow0KDQpBdCB0aGF0IHBvaW50IGl0IHBy b2JhYmx5IG1ha2VzIHNlbnNlIHRvIHJlcG9zdCB0aGUgcGF0Y2ggYXMgdjIg aW4gc21hbGxlciBwaWVjZXM/DQoNCg0KQWxhbi4NCg0KDQo= >From gdb-patches-return-148337-listarch-gdb-patches=sources.redhat.com@sourceware.org Tue Jun 19 16:36:32 2018 Return-Path: Delivered-To: listarch-gdb-patches@sources.redhat.com Received: (qmail 16212 invoked by alias); 19 Jun 2018 16:36:32 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 16197 invoked by uid 89); 19 Jun 2018 16:36:31 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-23.1 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_LAZY_DOMAIN_SECURITY,KAM_STOCKGEN,SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=played, 2e8, readers, As X-HELO: mx1.redhat.com Received: from mx3-rdu2.redhat.com (HELO mx1.redhat.com) (66.187.233.73) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 19 Jun 2018 16:36:29 +0000 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 mx1.redhat.com (Postfix) with ESMTPS id EDB7080125CE; Tue, 19 Jun 2018 16:36:27 +0000 (UTC) Received: from [127.0.0.1] (ovpn04.gateway.prod.ext.ams2.redhat.com [10.39.146.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id 24E3E16870; Tue, 19 Jun 2018 16:36:26 +0000 (UTC) Subject: [pushed] Change inline frame breakpoint skipping logic (fix gdb.gdb/selftest.exp) To: Tom de Vries , gdb-patches@sourceware.org References: <20180612150620.wloegrt5dgpdugi2@localhost.localdomain> <58a758b7-e4b4-4fee-c7cb-be5a2ab344e6@suse.de> Cc: Keith Seitz From: Pedro Alves Message-ID: <8c7ace90-f0b8-56f0-0033-5b7827796037@redhat.com> Date: Tue, 19 Jun 2018 16:36:00 -0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.8.0 MIME-Version: 1.0 In-Reply-To: <58a758b7-e4b4-4fee-c7cb-be5a2ab344e6@suse.de> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 7bit X-SW-Source: 2018-06/txt/msg00480.txt.bz2 Content-length: 12569 On 06/14/2018 02:22 PM, Tom de Vries wrote: > On 06/12/2018 07:38 PM, Pedro Alves wrote: >> Yes, sounds like it. But the selftest.exp explicitly asks to stop >> at "captured_main", not "captured_main_1", so I'm thinking that >> it's gdb's behavior that might be wrong: >> > Agreed, that's a better solution. > >> Note that both captured_main and captured_main_1 resolved to the >> same address, 0x791339. > > Right. I played around a bit with this, and set breakpoints on > captured_main and captured_main_1. > > If I set a breakpoint on captured_main_1, we have captured_main unknown: > ... > Breakpoint 2, captured_main_1 (context=) > at /home/vries/gdb_versions/devel/src/gdb/main.c:492 > 492 lim_at_start = (char *) sbrk (0); > (gdb) p captured_main > No symbol "captured_main" in current context. > (gdb) p captured_main_1 > $1 = {void (captured_main_args *)} 0x61b959 > > ... > > But If I set a breakpoint on captured_main instead, we have > captured_main_1 unknown: > ... > Breakpoint 3, captured_main (data=) > at /home/vries/gdb_versions/devel/src/gdb/main.c:1147 > 1147 captured_main_1 (context); > (gdb) p captured_main > $2 = {void (void *)} 0x61b959 > (gdb) p captured_main_1 > No symbol "captured_main_1" in current context. > ... > > And if I set a breakpoint on both, captured_main_1 seems to take > precedence (independent of the order used to set the breakpoint): > ... > Breakpoint 1, captured_main_1 (context=) > at /home/vries/gdb_versions/devel/src/gdb/main.c:492 > 492 lim_at_start = (char *) sbrk (0); > (gdb) p captured_main_1 > $1 = {void (captured_main_args *)} 0x61b959 > > (gdb) p captured_main > No symbol "captured_main" in current context. > ... > > I don't understand the underlying mechanisms well enough to decide > whether this is a problem or not, but I thought I just mention it. Can't pinpoint offhand where the problem is, but sounds like something in the dwarf or elf symbol readers, maybe the breakpoint you set first changes the order in which symbols are read and are added to search hashes etc., or something like that. It's most certainly unrelated to this change though. > >> The gdb.base/inline-break.exp testcase >> currently does not exercise that, but the new test added by the >> patch below does. That new test fails without the patch and passes >> with the patch. No regressions on x86-64 GNU/Linux. WDYT? >> > > AFAICT, the patch looks ok (just one nit below). > >> +/* A static inlined function that is called by another static inlined >> + function. */ >> + >> +static inline ATTR int >> +func_callee (int x) >> +{ >> + return x * 23; >> +} >> + >> +/* A static inlined function that calls another static inlined >> + function. The body of the function is a simple as possible so that >> + both functions are inlined to the same PC address. */ >> + >> +static int > > inline ATTR ? Hmm, indeed. If I do that however gcc (7.3) seemingly optimizes out the functions more aggressively and we can't set a breakpoint anymore: (gdb) b func_inline_caller Function "func_inline_caller" not defined. Breakpoint 1 (func_inline_caller) pending. A quick look at the debug info reveals that the debug info does mention the functions, so this may be another gdb bug: <1><2c3>: Abbrev Number: 12 (DW_TAG_subprogram) <2c4> DW_AT_name : (indirect string, offset: 0x16f): func_inline_caller <2c8> DW_AT_decl_file : 1 <2c9> DW_AT_decl_line : 197 <2ca> DW_AT_prototyped : 1 <2ca> DW_AT_type : <0x2a4> <2ce> DW_AT_inline : 3 (declared as inline and inlined) <2cf> DW_AT_sibling : <0x2dd> ... <1><2dd>: Abbrev Number: 12 (DW_TAG_subprogram) <2de> DW_AT_name : (indirect string, offset: 0x112): func_inline_callee <2e2> DW_AT_decl_file : 1 <2e3> DW_AT_decl_line : 187 <2e4> DW_AT_prototyped : 1 <2e4> DW_AT_type : <0x2a4> <2e8> DW_AT_inline : 3 (declared as inline and inlined) <2e9> DW_AT_sibling : <0x2f7> I haven't investigated that one. In order to move forward with the frame skipping patch, I'm adding a non-inline caller level in the testcase instead. Below's what I've now merged. >From 4de1f9e76460db0f6b97762ff368e5b8f0da16b0 Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Tue, 19 Jun 2018 16:30:13 +0100 Subject: [PATCH] Change inline frame breakpoint skipping logic (fix gdb.gdb/selftest.exp) Currently, gdb.gdb/selftest.exp fails if you build GDB with optimization (-O2, etc.). The reason is that after setting a breakpoint in captured_main, we stop at: ... Breakpoint 1, captured_main_1 (context=) at src/gdb/main.c:492 ... while selftest_setup expects a stop at captured_main. Here, captured_main_1 has been inlined into captured_main, and captured_main has been inlined into gdb_main: ... $ nm ./build/gdb/gdb | egrep ' [tT] .*captured_main|gdb_main' | c++filt 000000000061b950 T gdb_main(captured_main_args*) ... Indeed, the two inlined functions show up in the backtrace: ... (gdb) bt #0 captured_main_1 (context=) at main.c:492 #1 captured_main (data=) at main.c:1147 #2 gdb_main (args=args@entry=0x7fffffffdb80) at main.c:1173 #3 0x000000000040fea5 in main (argc=, argv=) at gdb.c:32 ... We're now stopping at captured_main_1 because commit ddfe970e6bec ("Don't elide all inlined frames") makes GDB present a stop at the innermost inlined frame if the program stopped by a user breakpoint. Now, the selftest.exp testcase explicitly asks to stop at "captured_main", not "captured_main_1", so I'm thinking that it's GDB'S behavior that should be improved. That is what this commit does, by only showing a stop at an inline frame if the user breakpoint was set in that frame's block. Before this commit: (top-gdb) b captured_main Breakpoint 1 at 0x792f99: file src/gdb/main.c, line 492. (top-gdb) r Starting program: build/gdb/gdb Breakpoint 1, captured_main_1 (context=) at src/gdb/main.c:492 492 lim_at_start = (char *) sbrk (0); (top-gdb) After this commit, we now instead get: (top-gdb) b captured_main Breakpoint 1 at 0x791339: file src/gdb/main.c, line 492. (top-gdb) r Starting program: build/gdb/gdb Breakpoint 1, captured_main (data=) at src/gdb/main.c:1147 1147 captured_main_1 (context); (top-gdb) and: (top-gdb) b captured_main_1 Breakpoint 2 at 0x791339: file src/gdb/main.c, line 492. (top-gdb) r Starting program: build/gdb/gdb Breakpoint 2, captured_main_1 (context=) at src/gdb/main.c:492 492 lim_at_start = (char *) sbrk (0); (top-gdb) Note that both captured_main and captured_main_1 resolved to the same address, 0x791339. That is necessary to trigger the issue in question. The gdb.base/inline-break.exp testcase currently does not exercise that, but the new test added by this commit does. That new test fails without the GDB fix and passes with the fix. No regressions on x86-64 GNU/Linux. While at it, the THIS_PC comparison in stopped_by_user_bp_inline_frame is basically a nop, so just remove it -- if a software or hardware breakpoint explains the stop, then it must be that it was installed at the current PC. gdb/ChangeLog: 2018-06-19 Pedro Alves * inline-frame.c (stopped_by_user_bp_inline_frame): Replace PC parameter with a block parameter. Compare location's block symbol with the frame's block instead of addresses. (skip_inline_frames): Pass the current block instead of the frame's address. Break out as soon as we determine the frame should not be skipped. gdb/testsuite/ChangeLog: 2018-06-19 Pedro Alves * gdb.opt/inline-break.c (func_inline_callee, func_inline_caller) (func_extern_caller): New. (main): Call func_extern_caller. * gdb.opt/inline-break.exp: Add tests for inline frame skipping logic change. --- gdb/inline-frame.c | 23 +++++++++++------------ gdb/testsuite/gdb.opt/inline-break.c | 34 ++++++++++++++++++++++++++++++++++ gdb/testsuite/gdb.opt/inline-break.exp | 25 +++++++++++++++++++++++++ 3 files changed, 70 insertions(+), 12 deletions(-) diff --git a/gdb/inline-frame.c b/gdb/inline-frame.c index 1ac5835438d..3edd5b2b20b 100644 --- a/gdb/inline-frame.c +++ b/gdb/inline-frame.c @@ -286,11 +286,10 @@ block_starting_point_at (CORE_ADDR pc, const struct block *block) } /* Loop over the stop chain and determine if execution stopped in an - inlined frame because of a user breakpoint. THIS_PC is the current - frame's PC. */ + inlined frame because of a user breakpoint set at FRAME_BLOCK. */ static bool -stopped_by_user_bp_inline_frame (CORE_ADDR this_pc, bpstat stop_chain) +stopped_by_user_bp_inline_frame (const block *frame_block, bpstat stop_chain) { for (bpstat s = stop_chain; s != NULL; s = s->next) { @@ -301,9 +300,9 @@ stopped_by_user_bp_inline_frame (CORE_ADDR this_pc, bpstat stop_chain) bp_location *loc = s->bp_location_at; enum bp_loc_type t = loc->loc_type; - if (loc->address == this_pc - && (t == bp_loc_software_breakpoint - || t == bp_loc_hardware_breakpoint)) + if ((t == bp_loc_software_breakpoint + || t == bp_loc_hardware_breakpoint) + && frame_block == SYMBOL_BLOCK_VALUE (loc->symbol)) return true; } } @@ -340,12 +339,12 @@ skip_inline_frames (ptid_t ptid, bpstat stop_chain) { /* Do not skip the inlined frame if execution stopped in an inlined frame because of a user - breakpoint. */ - if (!stopped_by_user_bp_inline_frame (this_pc, stop_chain)) - { - skip_count++; - last_sym = BLOCK_FUNCTION (cur_block); - } + breakpoint for this inline function. */ + if (stopped_by_user_bp_inline_frame (cur_block, stop_chain)) + break; + + skip_count++; + last_sym = BLOCK_FUNCTION (cur_block); } else break; diff --git a/gdb/testsuite/gdb.opt/inline-break.c b/gdb/testsuite/gdb.opt/inline-break.c index 922102debb6..f64a81af939 100644 --- a/gdb/testsuite/gdb.opt/inline-break.c +++ b/gdb/testsuite/gdb.opt/inline-break.c @@ -176,6 +176,38 @@ not_inline_func3 (int x) return y + inline_func3 (x); } +/* The following three functions serve to exercise GDB's inline frame + skipping logic when setting a user breakpoint on an inline function + by name. */ + +/* A static inlined function that is called by another static inlined + function. */ + +static inline ATTR int +func_inline_callee (int x) +{ + return x * 23; +} + +/* A static inlined function that calls another static inlined + function. The body of the function is as simple as possible so + that both functions are inlined to the same PC address. */ + +static inline ATTR int +func_inline_caller (int x) +{ + return func_inline_callee (x); +} + +/* An extern not-inline function that calls a static inlined + function. */ + +int +func_extern_caller (int x) +{ + return func_inline_caller (x); +} + /* Entry point. */ int @@ -205,5 +237,7 @@ main (int argc, char *argv[]) x = not_inline_func3 (-21); + func_extern_caller (1); + return x; } diff --git a/gdb/testsuite/gdb.opt/inline-break.exp b/gdb/testsuite/gdb.opt/inline-break.exp index 008ff1ac33a..bae76254905 100644 --- a/gdb/testsuite/gdb.opt/inline-break.exp +++ b/gdb/testsuite/gdb.opt/inline-break.exp @@ -231,4 +231,29 @@ foreach_with_prefix cmd [list "break" "tbreak"] { } } +# func_extern_caller calls func_inline_caller which calls +# func_inline_callee. The latter two are both inline functions. Test +# that setting a breakpoint on each of the functions reports a stop at +# that function. This exercises the inline frame skipping logic. If +# we set a breakpoint at function A, we want to present the stop at A, +# even if A's entry code is an inlined call to another inline function +# B. + +foreach_with_prefix func { + "func_extern_caller" + "func_inline_caller" + "func_inline_callee" +} { + clean_restart $binfile + + if {![runto main]} { + untested "could not run to main" + continue + } + + gdb_breakpoint $func + gdb_test "continue" "Breakpoint .* $func .*at .*$srcfile.*" \ + "breakpoint hit presents stop at breakpointed function" +} + unset -nocomplain results -- 2.14.3