From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 116868 invoked by alias); 23 Oct 2017 09:03:41 -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 116851 invoked by uid 89); 23 Oct 2017 09:03:40 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-6.7 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_2,MIME_BASE64_BLANKS,RP_MATCHES_RCVD,SPF_PASS autolearn=ham version=3.3.2 spammy=problem!, Behalf X-HELO: mga02.intel.com Received: from mga02.intel.com (HELO mga02.intel.com) (134.134.136.20) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 23 Oct 2017 09:03:38 +0000 Received: from orsmga003.jf.intel.com ([10.7.209.27]) by orsmga101.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 23 Oct 2017 02:03:35 -0700 X-ExtLoop1: 1 Received: from irsmsx108.ger.corp.intel.com ([163.33.3.3]) by orsmga003.jf.intel.com with ESMTP; 23 Oct 2017 02:03:33 -0700 Received: from irsmsx104.ger.corp.intel.com ([169.254.5.248]) by IRSMSX108.ger.corp.intel.com ([169.254.11.167]) with mapi id 14.03.0319.002; Mon, 23 Oct 2017 10:03:33 +0100 From: "Tedeschi, Walfred" To: "Tedeschi, Walfred" , Pedro Alves , Simon Marchi , Simon Marchi CC: "gdb-patches@sourceware.org" Subject: RE: [PATCH V4] symlookup: improves symbol lookup when a file is specified. Date: Mon, 23 Oct 2017 09:03:00 -0000 Message-ID: References: <1508317280-31265-1-git-send-email-walfred.tedeschi@intel.com> <327caaf3429595c07a29d455ea3ed6a0@polymtl.ca> In-Reply-To: dlp-product: dlpe-windows dlp-version: 11.0.0.116 dlp-reaction: no-action x-ctpclassification: CTP_IC x-titus-metadata-40: eyJDYXRlZ29yeUxhYmVscyI6IiIsIk1ldGFkYXRhIjp7Im5zIjoiaHR0cDpcL1wvd3d3LnRpdHVzLmNvbVwvbnNcL0ludGVsMyIsImlkIjoiZGFjNTIzMzktYTgxMi00YzNmLTgzYmQtNjZhZDNhMzA5ZDU3IiwicHJvcHMiOlt7Im4iOiJDVFBDbGFzc2lmaWNhdGlvbiIsInZhbHMiOlt7InZhbHVlIjoiQ1RQX0lDIn1dfV19LCJTdWJqZWN0TGFiZWxzIjpbXSwiVE1DVmVyc2lvbiI6IjE3LjIuNS4xOCIsIlRydXN0ZWRMYWJlbEhhc2giOiIzNnpvSTd2dzhTMmtcL0JkMW9NejNvK2dINjBWXC9JRWJnTm0zZmtFQTFxSzltcVJDT1pGZzhqb0Zuc04rSFdhWDEifQ== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 X-IsSubscribed: yes X-SW-Source: 2017-10/txt/msg00707.txt.bz2 DQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogZ2Ri LXBhdGNoZXMtb3duZXJAc291cmNld2FyZS5vcmcgW21haWx0bzpnZGItcGF0 Y2hlcy0NCj4gb3duZXJAc291cmNld2FyZS5vcmddIE9uIEJlaGFsZiBPZiBU ZWRlc2NoaSwgV2FsZnJlZA0KPiBTZW50OiBTYXR1cmRheSwgT2N0b2JlciAy MSwgMjAxNyAxMjo0NyBQTQ0KPiBUbzogUGVkcm8gQWx2ZXMgPHBhbHZlc0By ZWRoYXQuY29tPjsgU2ltb24gTWFyY2hpDQo+IDxzaW1vbi5tYXJjaGlAZXJp Y3Nzb24uY29tPjsgU2ltb24gTWFyY2hpIDxzaW1vbi5tYXJjaGlAcG9seW10 bC5jYT4NCj4gQ2M6IGdkYi1wYXRjaGVzQHNvdXJjZXdhcmUub3JnDQo+IFN1 YmplY3Q6IFJFOiBbUEFUQ0ggVjRdIHN5bWxvb2t1cDogaW1wcm92ZXMgc3lt Ym9sIGxvb2t1cCB3aGVuIGEgZmlsZSBpcw0KPiBzcGVjaWZpZWQuDQo+IA0K PiA+IC0tLS0tT3JpZ2luYWwgTWVzc2FnZS0tLS0tDQo+ID4gRnJvbTogUGVk cm8gQWx2ZXMgW21haWx0bzpwYWx2ZXNAcmVkaGF0LmNvbV0NCj4gPiBTZW50 OiBGcmlkYXksIE9jdG9iZXIgMjAsIDIwMTcgNToyOSBQTQ0KPiA+IFRvOiBT aW1vbiBNYXJjaGkgPHNpbW9uLm1hcmNoaUBlcmljc3Nvbi5jb20+OyBUZWRl c2NoaSwgV2FsZnJlZA0KPiA+IDx3YWxmcmVkLnRlZGVzY2hpQGludGVsLmNv bT47IFNpbW9uIE1hcmNoaSA8c2ltb24ubWFyY2hpQHBvbHltdGwuY2E+DQo+ ID4gQ2M6IGdkYi1wYXRjaGVzQHNvdXJjZXdhcmUub3JnDQo+ID4gU3ViamVj dDogUmU6IFtQQVRDSCBWNF0gc3ltbG9va3VwOiBpbXByb3ZlcyBzeW1ib2wg bG9va3VwIHdoZW4gYSBmaWxlDQo+ID4gaXMgc3BlY2lmaWVkLg0KPiA+DQo+ ID4gT24gMTAvMjAvMjAxNyAwMzoyOCBQTSwgU2ltb24gTWFyY2hpIHdyb3Rl Og0KPiA+ID4gT24gMjAxNy0xMC0yMCAwMzo0NSBBTSwgVGVkZXNjaGksIFdh bGZyZWQgd3JvdGU6DQo+ID4gPj4gSGkgU2ltb24sDQo+ID4gPj4NCj4gPiA+ PiBUaGFua3MgZm9yIHlvdXIgcmV2aWV3IQ0KPiA+ID4+IEZvciBhbGwgdGhl IGNvbW1lbnQgYWJvdmUgSSBhZ3JlZSwgVGhhbmtzIGFnYWluIQ0KPiA+ID4+ DQo+ID4gPj4gRm9yIHRoZSBvbmUgYmVsb3cgdGhlcmUgYXJlIGRpZmZlcmVu dCBwb2ludCBvZiB2aWV3cy4NCj4gPiA+PiBIb3cgSSBzZWUgaXQ6IFZlcnkg ZmV3IHNhbmUgcGVvcGxlIHdpbGwgYWRkIGEgc3ltYm9scyBpbiBhIHNoYXJl ZA0KPiA+ID4+IGxpYnJhcnkgdGhhdCB3aWxsIGNvbGxpZGUgbGlrZSB0aGUg Y2FzZSB3ZSBwcmVzZW50ZWQgaGVyZS4gIElmIG9uZQ0KPiA+ID4+IGRvZXMg c28gaG93IGNhbiB0aGUgZGVidWdnZXIgaGVscD8NCj4gPiA+DQo+ID4gPiBJ IHRoaW5rIG9uZSB1c3VhbCB1c2UgY2FzZSBpcyBwbHVnaW5zIGltcGxlbWVu dGVkIHdpdGggc2hhcmVkIGxpYnJhcnkuDQo+ID4gPiBBbHRob3VnaCB0aGUg ZGF0YSBzeW1ib2xzIHdpbGwgY29tbW9ubHkgYmUgc3RhdGljLCBhbmQgdGhl IHBsdWdpbg0KPiA+ID4gd2lsbCBvbmx5IGV4cG9zZSBzb21lIGZ1bmN0aW9u IHN5bWJvbHMuDQo+ID4gPg0KPiA+ID4+IFByb3ZpZGluZyB0aGUgc2FtZSB2 YWx1ZSBhcyB0aGUgcnVudGltZSBvciBsaW5rZXIgZG9lcz8NCj4gPiA+PiBU aGlzIG9uZSB1c2VyIGFscmVhZHkga25vd3MuDQo+ID4gPj4gT3IgcHJvdmlk aW5nIHdoYXQgdGhlIGRlYnVnIGluZm9ybWF0aW9uIHByb3ZpZGVzIGFzIHZh bHVlIGNyZWF0ZWQNCj4gPiA+PiBieSB0aGUNCj4gPiBsaWJyYXJ5IGl0c2Vs Zi4NCj4gPiA+PiBJbiBmaW5hbCBlbmQgYm90aCBhcmUgcmlnaHQuIDp8DQo+ ID4gPj4NCj4gPiA+PiBCdXQgd2hlbiBzcGVjaWZ5aW5nIHRoZSBzY29wZSBp ZiB1c2VyIGlzIHByb3ZpZGVkIHRoZSB2YWx1ZSBvZiB0aGUNCj4gPiA+PiBk ZWJ1ZyBpbmZvIGl0IHNob3VsZCBiZSBlYXNpZXIgdG8gc3BvdCB0aGF0IHRo ZXJlIGlzIHNvbWV0aGluZw0KPiA+ID4+IHdlaXJkIGdvaW5nIG9uDQo+ID4g aW4gdGhlIGNvZGUuDQo+ID4gPg0KPiA+ID4gSSB0aGluayB3aGF0IHlvdSBq dXN0IHNhaWQgc3VtbWFyaXplcyB0aGUgcHJvYmxlbSB3ZWxsIGFuZCBJIHRo aW5rDQo+ID4gPiBpdCBtYWtlcw0KPiA+IHNlbnNlLg0KPiA+ID4gSSBqdXN0 IGRvbid0IHRoaW5rIEkgaGF2ZSBlbm91Z2ggZXhwZXJpZW5jZSBhYm91dCBz eW1ib2wgaGFuZGxpbmcgdG8NCj4gPiA+IHVuZGVyc3RhbmQgdGhlIHNpdHVh dGlvbiBmdWxseS4gIENvdWxkIGFub3RoZXIgbWFpbnRhaW5lciB3aXRoIG1v cmUNCj4gPiA+IGV4cGVyaWVuY2UgYWJvdXQgc3ltYm9scyBnaXZlIHRoZSBm aW5hbCBvaz8NCj4gPg0KPiA+IEkgZGlzYWdyZWUuICBIYXZpbmcNCj4gPiAg KGdkYikgZnJhbWUNCj4gPiAgIzAgMHgwMDAwMDAwMDAwNDAwNzNiIGluIGZ1 bmN0aW9uICgpIGF0IHNvdXJjZS5jOjIyDQo+ID4gIChnZGIpIHByaW50IGZv bw0KPiA+IGFuZDoNCj4gPiAgKGdkYikgcHJpbnQgJ3NvdXJjZS5jJzpmb28N Cj4gPg0KPiA+IHNob3cgZGlmZmVyZW50IHZhbHVlcyB3aGVuIHlvdSdyZSBz dG9wcGVkIGluIGEgZnVuY3Rpb24gaW4gdGhlDQo+ID4gc291cmNlLmMgZmls ZSB3b3VsZCBsb29rIGluY29uc2lzdGVudCB0byBtZS4NCj4gPg0KPiA+IEFj dHVhbGx5LCB0aGUgcGF0Y2ggaW50cm9kdWNlcyB3aGF0IGxvb2tzIGxpa2Ug YSByZWxhdGVkIGNsZWFyIHJlZ3Jlc3Npb24gdG8NCj4gbWUuDQo+ID4gV2l0 aCB0aGUgcHJpbnQtZmlsZS12YXIuZXhwIHRlc3QgcHJvZ3JhbSwgdHJ5IHN0 ZXBwaW5nIGludG8NCj4gPiBnZXRfdmVyc2lvbl8yLCBhbmQgcHJpbnRpbmcg dGhlIHRoaXNfdmVyc2lvbl9pZCBnbG9iYWwuICBBbmQgdGhlbiB0eXBlDQo+ IGZpbmlzaC4gIFZpczoNCj4gPg0KPiA+ICAoZ2RiKSBzDQo+ID4gIGdldF92 ZXJzaW9uXzIgKCkgYXQgZ2RiLmJhc2UvcHJpbnQtZmlsZS12YXItbGliMi5j OjIyDQo+ID4gIDIyICAgICAgICByZXR1cm4gdGhpc192ZXJzaW9uX2lkOw0K PiA+ICAoZ2RiKSBwIHRoaXNfdmVyc2lvbl9pZA0KPiA+ICAkMSA9IDIwMw0K PiA+ICAoZ2RiKSBmaW5pc2gNCj4gPiAgUnVuIHRpbGwgZXhpdCBmcm9tICMw ICBnZXRfdmVyc2lvbl8yICgpIGF0DQo+ID4gZ2RiLmJhc2UvcHJpbnQtZmls ZS12YXItbGliMi5jOjIyIDB4MDAwMDAwMDAwMDQwMDczYiBpbiBtYWluICgp IGF0DQo+IGdkYi5iYXNlL3ByaW50LWZpbGUtdmFyLW1haW4uYzoyNA0KPiA+ ICAyNCAgICAgICAgaW50IHYyID0gZ2V0X3ZlcnNpb25fMiAoKTsNCj4gPiAg VmFsdWUgcmV0dXJuZWQgaXMgJDIgPSAxMDQNCj4gPiAgKGdkYikNCj4gPg0K PiA+IEdEQiBzYXlzICIyMDMiLCB3aGlsZSB0aGUgcHJvZ3JhbSByZXR1cm5z ICIxMDQiLg0KPiA+IFRoYXQgbG9va3MgbGlrZSBhIGJ1ZyB0byBtZS4gIEkn ZCBleHBlY3QgdGhlIHByaW50IHRvIHNob3cgbWUgdGhlDQo+ID4gY3VycmVu dCB2YWx1ZSBvZiB0aGUgdmFyaWFibGUgaW4gc2NvcGUuDQo+ID4NCj4gPiBJ biBjdXJyZW50IG1hc3RlciAod2l0aG91dCB0aGUgcGF0Y2gpLCB3ZSBnZXQ6 DQo+ID4NCj4gPiAgKGdkYikgcw0KPiA+ICBnZXRfdmVyc2lvbl8yICgpIGF0 IGdkYi5iYXNlL3ByaW50LWZpbGUtdmFyLWxpYjIuYzoyMg0KPiA+ICAyMiAg ICAgICAgcmV0dXJuIHRoaXNfdmVyc2lvbl9pZDsNCj4gPiAgKGdkYikgcCB0 aGlzX3ZlcnNpb25faWQNCj4gPiAgJDEgPSAxMDQNCj4gPiAgKGdkYikgZmlu aXNoDQo+ID4gIFJ1biB0aWxsIGV4aXQgZnJvbSAjMCAgZ2V0X3ZlcnNpb25f MiAoKSBhdA0KPiA+IGdkYi5iYXNlL3ByaW50LWZpbGUtdmFyLWxpYjIuYzoy MiAweDAwMDAwMDAwMDA0MDA3M2IgaW4gbWFpbiAoKSBhdA0KPiBnZGIuYmFz ZS9wcmludC1maWxlLXZhci1tYWluLmM6MjQNCj4gPiAgMjQgICAgICAgIGlu dCB2MiA9IGdldF92ZXJzaW9uXzIgKCk7DQo+ID4gIFZhbHVlIHJldHVybmVk IGlzICQyID0gMTA0DQo+IA0KPiBIZWxsbyBQZWRybywNCj4gDQo+IFRoYW5r cyBhIGxvdCBmb3IgcmV2aWV3aW5nIHRoYXQhDQo+IEkgd2lsbCBicmluZyBt b3JlIGluZm9ybWF0aW9uIHJlbGF0ZWQgdG8gd2hhdCBkZWJ1ZyBpbmZvcm1h dGlvbiBwcm92aWRlIGFuZA0KPiBzbyBvbi4NCj4gVGhlIGxpbmtlciBpcyB0 aGUgY2F1c2Ugb2YgdGhpcyBkaXNjb25uZWN0aW9uLiAgSW4gYSBwcmV2aW91 cyB0ZXN0IHBhdGNoIEkgaGF2ZQ0KPiBhZGRlZCBhIHNldC9zaG93IHZhcmlh YmxlIHN3aXRjaCBiZXR3ZWVuLg0KPiBEbG9wZW4gYW5kIGxpbmtlciBiZWhh dmlvci4gIEkgYWxzbyBmb3VuZCB0aGF0IHdyb25nIGFuZCBsb29raW5nIGF0 IGl0IGFnYWluLg0KPiANCj4gSSB3aWxsIHRyeSB0byBicmluZyBtb3JlIGZh Y3RzIHdpdGggdGhlIGRlYnVnIGluZm8gYW5kIG1lbW9yeSBleGFtaW5hdGlv bi4NCj4gDQo+IEluIGFueSBjYXNlIGFjdHVhbCBiZWhhdmlvciBvZiBtYXN0 ZXIgaXMgYWxzbyB3cm9uZyBmb3IgZGxvcGVuIGNhc2UhDQo+IA0KDQpIZWxs byBhbGwsDQoNCkhlcmUgd2UgZ286DQoNCldpdGggbWFpbmxpbmUgZ2RiIHdl IGhhdmUgdGhlIGZvbGxvd2luZyBzY2VuYXJpbzoNCg0KU3RvcHBlZCBhdCBt YWluIGxpbmUgMzIgaW4gcHJpbnQtZmlsZS12YXItbWFpbih0ZXN0Y2FzZSkN Cg0KCShnZGIpIHByaW50IHRoaXNfdmVyc2lvbl9pZCANCgkkMSA9IDEwNA0K DQpUaGlzIHdhcyBleHBlY3RlZCwgd2UgYXJlIGxvb2tpbmcgYXQgdGhlIHN5 bWJvbCB0aGF0IHRoZSBsaW5rZXIgYW5kIG1haW4gY2FuIHNlZSBhcyBzcGVj aWZpZWQgaW4gdGhlIGdsb2JhbCBzY29wZS4NCg0KCShnZGIpIHByaW50ICZ0 aGlzX3ZlcnNpb25faWQgDQoJJDIgPSAoaW50ICopIDB4N2ZmZmY3ZGRiMDI4 IDx0aGlzX3ZlcnNpb25faWQ+DQoNCgkoZ2RiKSBpbmZvIHN5bWJvbCAweDdm ZmZmN2RkYjAyOA0KCXRoaXNfdmVyc2lvbl9pZCBpbiBzZWN0aW9uIC5kYXRh IG9mIC9uZnMvaXVsL2Rpc2tzL2l1bF90ZWFtMi93dGVkZXNjaC9fZ2RiXy9l eHRlcm5fZ2RiL2Jpbi9kbG9wZW4vZ2RiL3Rlc3RzdWl0ZS9vdXRwdXRzL2dk Yi5iYXNlL3ByaW50LWZpbGUtdmFyL3ByaW50LWZpbGUtdmFyLWxpYjEuc28N Cg0KVGhvc2UgdHdvIGxhc3QgZXZhbHVhdGlvbnMgcHJvdmUgdGhhdCB3ZSBh cmUgc2VlbSBhIHN5bWJvbCBjb21pbmcgZnJvbSB0aGUgZmlyc3QgbGlicmFy eSBhcyBleHBlY3RlZCBhbmQgZG9uZSBieSB0aGUgbGlua2VyLg0KDQpIb3dl dmVyIGludGVyZXN0aW5nbHkgaWYgSSBzcGVjaWZ5IHRoZSBzY29wZSwgSSBn ZXQ6DQoNCgkoZ2RiKSBwcmludCAgJigncHJpbnQtZmlsZS12YXItbGliMi5j Jzo6dGhpc192ZXJzaW9uX2lkKQ0KCSQzID0gKGludCAqKSAweDdmZmZmN2Rk YjAyOCAgPHRoaXNfdmVyc2lvbl9pZD4NCg0KCShnZGIpIGluZm8gc3ltYm9s IDB4N2ZmZmY3ZGRiMDI4ICANCgl0aGlzX3ZlcnNpb25faWQgaW4gc2VjdGlv biAuZGF0YSBvZiAvbmZzL2l1bC9kaXNrcy9pdWxfdGVhbTIvd3RlZGVzY2gv X2dkYl8vZXh0ZXJuX2dkYi9iaW4vZGxvcGVuL2dkYi90ZXN0c3VpdGUvb3V0 cHV0cy9nZGIuYmFzZS9wcmludC1maWxlLXZhci9wcmludC1maWxlLXZhci1s aWIxLnNvDQoJDQpCdXQgSSBoYXZlIHNwZWNpZmllZCB0aGUgc2NvcGUhIEkg YW0gYXNraW5nIHNwZWNpZmljYWxseSB0aGF0IEkgd2FudCB0aGUgc3ltYm9s IGRlZmluZWQgaW4gdGhlIHNlY29uZCBsaWJyYXJ5IG5vdCBpbiB0aGUgZmly c3QuDQoNCklmIEkgdXNlIHRoZSBwYXRjaCBwcm92aWRlZCB0aGFuIEkgZ2V0 Og0KDQoJKGdkYikgcHJpbnQgICYoJ3ByaW50LWZpbGUtdmFyLWxpYjIuYyc6 OnRoaXNfdmVyc2lvbl9pZCkNCgkkNCA9IChpbnQgKikgMHg3ZmZmZjdkZGIw MjggPHRoaXNfdmVyc2lvbl9pZD4NCg0KCShnZGIpIGluZm8gc3ltYm9sIDB4 N2ZmZmY3ZGRiMDI4DQoJdGhpc192ZXJzaW9uX2lkIGluIHNlY3Rpb24gLmRh dGEgb2YgL25mcy9pdWwvZGlza3MvaXVsX3RlYW0yL3d0ZWRlc2NoL19nZGJf L2V4dGVybl9nZGIvYmluL2Rsb3Blbi9nZGIvdGVzdHN1aXRlL291dHB1dHMv Z2RiLmJhc2UvcHJpbnQtZmlsZS12YXIvcHJpbnQtZmlsZS12YXItbGliMS5z bw0KDQpfVGhpcyB3YXMgd2hhdCBJJ3ZlIGV4cGVjdGVkLiBfDQoNCldpdGgg dGhhdCBJIF9jYW5ub3RfIHNheSB0aGF0IEdEQiBpcyBkb2luZyByaWdodCBp biB0aGUgbWFpbiBsaW5lLiBCYXNpY2FsbHkgdGhlIHRlc3QgaXMgd2VhayEN Cg0KVGhlIGlzc3VlIGlzIGluIHRoZSBzeW10YWIuYyB+MjYwMzoNCiAgICAg Z2RiYXJjaF9pdGVyYXRlX292ZXJfb2JqZmlsZXNfaW5fc2VhcmNoX29yZGVy DQogCShvYmpmaWxlICE9IE5VTEwgPyBnZXRfb2JqZmlsZV9hcmNoIChvYmpm aWxlKSA6IHRhcmdldF9nZGJhcmNoICgpLA0KIAkgbG9va3VwX3N5bWJvbF9n bG9iYWxfaXRlcmF0b3JfY2IsICZsb29rdXBfZGF0YSwgb2JqZmlsZSk7DQoN ClRoZSBsb29rdXAgaGVyZSBpcyBkb25lIGluIHRoZSBvcmRlciBvZiB0aGUg bGlicmFyeSBsb2FkLCB3aGF0IGlzIHJpZ2h0IGZvciBnbG9iYWwgc3ltYm9s cywgSWYgYW5kIG9ubHkgaWYgbm8gc2NvcGUgaXMgcHJvdmlkZWQuDQpBZ2Fp biB1c2VyIHdpbGwgc3BlY2lmeSB0aGUgc2NvcGUgaWYgaGUgaGFzIGEgZG91 YnQgb24gaG93IGluIGVhcnRoIGhpcyB2YWx1ZSBpcyBub3Qgd2hhdCBpcyBz ZWVuIGluIHRoZSBleGVjdXRpb24hDQoNCg0KSSBob3BlIHRoaXMgc2FtcGxl IHJ1biBoZWxwcyBpbiBlbHVjaWRhdGluZyB0aGUgcHJvYmxlbSENCg0KVGhh bmtzIGFuZCByZWdhcmRzLA0KL0ZyZWQNCg0KPiBUaGFua3MgYW5kIHJlZ2Fy ZHMsDQo+IC9GcmVkDQo+ID4NCj4gPiBUaGFua3MsDQo+ID4gUGVkcm8gQWx2 ZXMNCj4gSW50ZWwgRGV1dHNjaGxhbmQgR21iSA0KPiBSZWdpc3RlcmVkIEFk ZHJlc3M6IEFtIENhbXBlb24gMTAtMTIsIDg1NTc5IE5ldWJpYmVyZywgR2Vy bWFueQ0KPiBUZWw6ICs0OSA4OSA5OSA4ODUzLTAsIHd3dy5pbnRlbC5kZQ0K PiBNYW5hZ2luZyBEaXJlY3RvcnM6IENocmlzdGluIEVpc2Vuc2NobWlkLCBD aHJpc3RpYW4gTGFtcHJlY2h0ZXIgQ2hhaXJwZXJzb24NCj4gb2YgdGhlIFN1 cGVydmlzb3J5IEJvYXJkOiBOaWNvbGUgTGF1IFJlZ2lzdGVyZWQgT2ZmaWNl OiBNdW5pY2ggQ29tbWVyY2lhbA0KPiBSZWdpc3RlcjogQW10c2dlcmljaHQg TXVlbmNoZW4gSFJCIDE4NjkyOA0KSW50ZWwgRGV1dHNjaGxhbmQgR21iSApS ZWdpc3RlcmVkIEFkZHJlc3M6IEFtIENhbXBlb24gMTAtMTIsIDg1NTc5IE5l dWJpYmVyZywgR2VybWFueQpUZWw6ICs0OSA4OSA5OSA4ODUzLTAsIHd3dy5p bnRlbC5kZQpNYW5hZ2luZyBEaXJlY3RvcnM6IENocmlzdGluIEVpc2Vuc2No bWlkLCBDaHJpc3RpYW4gTGFtcHJlY2h0ZXIKQ2hhaXJwZXJzb24gb2YgdGhl IFN1cGVydmlzb3J5IEJvYXJkOiBOaWNvbGUgTGF1ClJlZ2lzdGVyZWQgT2Zm aWNlOiBNdW5pY2gKQ29tbWVyY2lhbCBSZWdpc3RlcjogQW10c2dlcmljaHQg TXVlbmNoZW4gSFJCIDE4NjkyOAo= >From gdb-patches-return-142901-listarch-gdb-patches=sources.redhat.com@sourceware.org Mon Oct 23 09:13:55 2017 Return-Path: Delivered-To: listarch-gdb-patches@sources.redhat.com Received: (qmail 69240 invoked by alias); 23 Oct 2017 09:13:55 -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 68126 invoked by uid 89); 23 Oct 2017 09:13:54 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-6.7 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_2,MIME_BASE64_BLANKS,RP_MATCHES_RCVD,SPF_PASS autolearn=ham version=3.3.2 spammy=Those X-HELO: mga01.intel.com Received: from mga01.intel.com (HELO mga01.intel.com) (192.55.52.88) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 23 Oct 2017 09:13:52 +0000 Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by fmsmga101.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 23 Oct 2017 02:13:50 -0700 X-ExtLoop1: 1 Received: from irsmsx151.ger.corp.intel.com ([163.33.192.59]) by fmsmga006.fm.intel.com with ESMTP; 23 Oct 2017 02:13:49 -0700 Received: from irsmsx104.ger.corp.intel.com ([169.254.5.248]) by IRSMSX151.ger.corp.intel.com ([169.254.4.108]) with mapi id 14.03.0319.002; Mon, 23 Oct 2017 10:13:48 +0100 From: "Tedeschi, Walfred" To: Pedro Alves , Simon Marchi , Simon Marchi CC: "gdb-patches@sourceware.org" Subject: RE: [PATCH V4] symlookup: improves symbol lookup when a file is specified. Date: Mon, 23 Oct 2017 09:13:00 -0000 Message-ID: References: <1508317280-31265-1-git-send-email-walfred.tedeschi@intel.com> <327caaf3429595c07a29d455ea3ed6a0@polymtl.ca> In-Reply-To: dlp-product: dlpe-windows dlp-version: 11.0.0.116 dlp-reaction: no-action x-ctpclassification: CTP_IC x-titus-metadata-40: eyJDYXRlZ29yeUxhYmVscyI6IiIsIk1ldGFkYXRhIjp7Im5zIjoiaHR0cDpcL1wvd3d3LnRpdHVzLmNvbVwvbnNcL0ludGVsMyIsImlkIjoiZGFjNTIzMzktYTgxMi00YzNmLTgzYmQtNjZhZDNhMzA5ZDU3IiwicHJvcHMiOlt7Im4iOiJDVFBDbGFzc2lmaWNhdGlvbiIsInZhbHMiOlt7InZhbHVlIjoiQ1RQX0lDIn1dfV19LCJTdWJqZWN0TGFiZWxzIjpbXSwiVE1DVmVyc2lvbiI6IjE3LjIuNS4xOCIsIlRydXN0ZWRMYWJlbEhhc2giOiIzNnpvSTd2dzhTMmtcL0JkMW9NejNvK2dINjBWXC9JRWJnTm0zZmtFQTFxSzltcVJDT1pGZzhqb0Zuc04rSFdhWDEifQ== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 X-IsSubscribed: yes X-SW-Source: 2017-10/txt/msg00708.txt.bz2 Content-length: 11973 DQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogVGVk ZXNjaGksIFdhbGZyZWQNCj4gU2VudDogTW9uZGF5LCBPY3RvYmVyIDIzLCAy MDE3IDExOjA0IEFNDQo+IFRvOiBUZWRlc2NoaSwgV2FsZnJlZCA8d2FsZnJl ZC50ZWRlc2NoaUBpbnRlbC5jb20+OyBQZWRybyBBbHZlcw0KPiA8cGFsdmVz QHJlZGhhdC5jb20+OyBTaW1vbiBNYXJjaGkgPHNpbW9uLm1hcmNoaUBlcmlj c3Nvbi5jb20+OyBTaW1vbg0KPiBNYXJjaGkgPHNpbW9uLm1hcmNoaUBwb2x5 bXRsLmNhPg0KPiBDYzogZ2RiLXBhdGNoZXNAc291cmNld2FyZS5vcmcNCj4g U3ViamVjdDogUkU6IFtQQVRDSCBWNF0gc3ltbG9va3VwOiBpbXByb3ZlcyBz eW1ib2wgbG9va3VwIHdoZW4gYSBmaWxlIGlzDQo+IHNwZWNpZmllZC4NCj4g DQo+IA0KPiANCj4gPiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiA+ IEZyb206IGdkYi1wYXRjaGVzLW93bmVyQHNvdXJjZXdhcmUub3JnIFttYWls dG86Z2RiLXBhdGNoZXMtDQo+ID4gb3duZXJAc291cmNld2FyZS5vcmddIE9u IEJlaGFsZiBPZiBUZWRlc2NoaSwgV2FsZnJlZA0KPiA+IFNlbnQ6IFNhdHVy ZGF5LCBPY3RvYmVyIDIxLCAyMDE3IDEyOjQ3IFBNDQo+ID4gVG86IFBlZHJv IEFsdmVzIDxwYWx2ZXNAcmVkaGF0LmNvbT47IFNpbW9uIE1hcmNoaQ0KPiA+ IDxzaW1vbi5tYXJjaGlAZXJpY3Nzb24uY29tPjsgU2ltb24gTWFyY2hpIDxz aW1vbi5tYXJjaGlAcG9seW10bC5jYT4NCj4gPiBDYzogZ2RiLXBhdGNoZXNA c291cmNld2FyZS5vcmcNCj4gPiBTdWJqZWN0OiBSRTogW1BBVENIIFY0XSBz eW1sb29rdXA6IGltcHJvdmVzIHN5bWJvbCBsb29rdXAgd2hlbiBhIGZpbGUN Cj4gPiBpcyBzcGVjaWZpZWQuDQo+ID4NCj4gPiA+IC0tLS0tT3JpZ2luYWwg TWVzc2FnZS0tLS0tDQo+ID4gPiBGcm9tOiBQZWRybyBBbHZlcyBbbWFpbHRv OnBhbHZlc0ByZWRoYXQuY29tXQ0KPiA+ID4gU2VudDogRnJpZGF5LCBPY3Rv YmVyIDIwLCAyMDE3IDU6MjkgUE0NCj4gPiA+IFRvOiBTaW1vbiBNYXJjaGkg PHNpbW9uLm1hcmNoaUBlcmljc3Nvbi5jb20+OyBUZWRlc2NoaSwgV2FsZnJl ZA0KPiA+ID4gPHdhbGZyZWQudGVkZXNjaGlAaW50ZWwuY29tPjsgU2ltb24g TWFyY2hpDQo+IDxzaW1vbi5tYXJjaGlAcG9seW10bC5jYT4NCj4gPiA+IENj OiBnZGItcGF0Y2hlc0Bzb3VyY2V3YXJlLm9yZw0KPiA+ID4gU3ViamVjdDog UmU6IFtQQVRDSCBWNF0gc3ltbG9va3VwOiBpbXByb3ZlcyBzeW1ib2wgbG9v a3VwIHdoZW4gYQ0KPiA+ID4gZmlsZSBpcyBzcGVjaWZpZWQuDQo+ID4gPg0K PiA+ID4gT24gMTAvMjAvMjAxNyAwMzoyOCBQTSwgU2ltb24gTWFyY2hpIHdy b3RlOg0KPiA+ID4gPiBPbiAyMDE3LTEwLTIwIDAzOjQ1IEFNLCBUZWRlc2No aSwgV2FsZnJlZCB3cm90ZToNCj4gPiA+ID4+IEhpIFNpbW9uLA0KPiA+ID4g Pj4NCj4gPiA+ID4+IFRoYW5rcyBmb3IgeW91ciByZXZpZXchDQo+ID4gPiA+ PiBGb3IgYWxsIHRoZSBjb21tZW50IGFib3ZlIEkgYWdyZWUsIFRoYW5rcyBh Z2FpbiENCj4gPiA+ID4+DQo+ID4gPiA+PiBGb3IgdGhlIG9uZSBiZWxvdyB0 aGVyZSBhcmUgZGlmZmVyZW50IHBvaW50IG9mIHZpZXdzLg0KPiA+ID4gPj4g SG93IEkgc2VlIGl0OiBWZXJ5IGZldyBzYW5lIHBlb3BsZSB3aWxsIGFkZCBh IHN5bWJvbHMgaW4gYSBzaGFyZWQNCj4gPiA+ID4+IGxpYnJhcnkgdGhhdCB3 aWxsIGNvbGxpZGUgbGlrZSB0aGUgY2FzZSB3ZSBwcmVzZW50ZWQgaGVyZS4g IElmDQo+ID4gPiA+PiBvbmUgZG9lcyBzbyBob3cgY2FuIHRoZSBkZWJ1Z2dl ciBoZWxwPw0KPiA+ID4gPg0KPiA+ID4gPiBJIHRoaW5rIG9uZSB1c3VhbCB1 c2UgY2FzZSBpcyBwbHVnaW5zIGltcGxlbWVudGVkIHdpdGggc2hhcmVkIGxp YnJhcnkuDQo+ID4gPiA+IEFsdGhvdWdoIHRoZSBkYXRhIHN5bWJvbHMgd2ls bCBjb21tb25seSBiZSBzdGF0aWMsIGFuZCB0aGUgcGx1Z2luDQo+ID4gPiA+ IHdpbGwgb25seSBleHBvc2Ugc29tZSBmdW5jdGlvbiBzeW1ib2xzLg0KPiA+ ID4gPg0KPiA+ID4gPj4gUHJvdmlkaW5nIHRoZSBzYW1lIHZhbHVlIGFzIHRo ZSBydW50aW1lIG9yIGxpbmtlciBkb2VzPw0KPiA+ID4gPj4gVGhpcyBvbmUg dXNlciBhbHJlYWR5IGtub3dzLg0KPiA+ID4gPj4gT3IgcHJvdmlkaW5nIHdo YXQgdGhlIGRlYnVnIGluZm9ybWF0aW9uIHByb3ZpZGVzIGFzIHZhbHVlIGNy ZWF0ZWQNCj4gPiA+ID4+IGJ5IHRoZQ0KPiA+ID4gbGlicmFyeSBpdHNlbGYu DQo+ID4gPiA+PiBJbiBmaW5hbCBlbmQgYm90aCBhcmUgcmlnaHQuIDp8DQo+ ID4gPiA+Pg0KPiA+ID4gPj4gQnV0IHdoZW4gc3BlY2lmeWluZyB0aGUgc2Nv cGUgaWYgdXNlciBpcyBwcm92aWRlZCB0aGUgdmFsdWUgb2YNCj4gPiA+ID4+ IHRoZSBkZWJ1ZyBpbmZvIGl0IHNob3VsZCBiZSBlYXNpZXIgdG8gc3BvdCB0 aGF0IHRoZXJlIGlzDQo+ID4gPiA+PiBzb21ldGhpbmcgd2VpcmQgZ29pbmcg b24NCj4gPiA+IGluIHRoZSBjb2RlLg0KPiA+ID4gPg0KPiA+ID4gPiBJIHRo aW5rIHdoYXQgeW91IGp1c3Qgc2FpZCBzdW1tYXJpemVzIHRoZSBwcm9ibGVt IHdlbGwgYW5kIEkgdGhpbmsNCj4gPiA+ID4gaXQgbWFrZXMNCj4gPiA+IHNl bnNlLg0KPiA+ID4gPiBJIGp1c3QgZG9uJ3QgdGhpbmsgSSBoYXZlIGVub3Vn aCBleHBlcmllbmNlIGFib3V0IHN5bWJvbCBoYW5kbGluZw0KPiA+ID4gPiB0 byB1bmRlcnN0YW5kIHRoZSBzaXR1YXRpb24gZnVsbHkuICBDb3VsZCBhbm90 aGVyIG1haW50YWluZXIgd2l0aA0KPiA+ID4gPiBtb3JlIGV4cGVyaWVuY2Ug YWJvdXQgc3ltYm9scyBnaXZlIHRoZSBmaW5hbCBvaz8NCj4gPiA+DQo+ID4g PiBJIGRpc2FncmVlLiAgSGF2aW5nDQo+ID4gPiAgKGdkYikgZnJhbWUNCj4g PiA+ICAjMCAweDAwMDAwMDAwMDA0MDA3M2IgaW4gZnVuY3Rpb24gKCkgYXQg c291cmNlLmM6MjINCj4gPiA+ICAoZ2RiKSBwcmludCBmb28NCj4gPiA+IGFu ZDoNCj4gPiA+ICAoZ2RiKSBwcmludCAnc291cmNlLmMnOmZvbw0KPiA+ID4N Cj4gPiA+IHNob3cgZGlmZmVyZW50IHZhbHVlcyB3aGVuIHlvdSdyZSBzdG9w cGVkIGluIGEgZnVuY3Rpb24gaW4gdGhlDQo+ID4gPiBzb3VyY2UuYyBmaWxl IHdvdWxkIGxvb2sgaW5jb25zaXN0ZW50IHRvIG1lLg0KPiA+ID4NCj4gPiA+ IEFjdHVhbGx5LCB0aGUgcGF0Y2ggaW50cm9kdWNlcyB3aGF0IGxvb2tzIGxp a2UgYSByZWxhdGVkIGNsZWFyDQo+ID4gPiByZWdyZXNzaW9uIHRvDQo+ID4g bWUuDQo+ID4gPiBXaXRoIHRoZSBwcmludC1maWxlLXZhci5leHAgdGVzdCBw cm9ncmFtLCB0cnkgc3RlcHBpbmcgaW50bw0KPiA+ID4gZ2V0X3ZlcnNpb25f MiwgYW5kIHByaW50aW5nIHRoZSB0aGlzX3ZlcnNpb25faWQgZ2xvYmFsLiAg QW5kIHRoZW4NCj4gPiA+IHR5cGUNCj4gPiBmaW5pc2guICBWaXM6DQo+ID4g Pg0KPiA+ID4gIChnZGIpIHMNCj4gPiA+ICBnZXRfdmVyc2lvbl8yICgpIGF0 IGdkYi5iYXNlL3ByaW50LWZpbGUtdmFyLWxpYjIuYzoyMg0KPiA+ID4gIDIy ICAgICAgICByZXR1cm4gdGhpc192ZXJzaW9uX2lkOw0KPiA+ID4gIChnZGIp IHAgdGhpc192ZXJzaW9uX2lkDQo+ID4gPiAgJDEgPSAyMDMNCj4gPiA+ICAo Z2RiKSBmaW5pc2gNCj4gPiA+ICBSdW4gdGlsbCBleGl0IGZyb20gIzAgIGdl dF92ZXJzaW9uXzIgKCkgYXQNCj4gPiA+IGdkYi5iYXNlL3ByaW50LWZpbGUt dmFyLWxpYjIuYzoyMiAweDAwMDAwMDAwMDA0MDA3M2IgaW4gbWFpbiAoKSBh dA0KPiA+IGdkYi5iYXNlL3ByaW50LWZpbGUtdmFyLW1haW4uYzoyNA0KPiA+ ID4gIDI0ICAgICAgICBpbnQgdjIgPSBnZXRfdmVyc2lvbl8yICgpOw0KPiA+ ID4gIFZhbHVlIHJldHVybmVkIGlzICQyID0gMTA0DQo+ID4gPiAgKGdkYikN Cj4gPiA+DQo+ID4gPiBHREIgc2F5cyAiMjAzIiwgd2hpbGUgdGhlIHByb2dy YW0gcmV0dXJucyAiMTA0Ii4NCj4gPiA+IFRoYXQgbG9va3MgbGlrZSBhIGJ1 ZyB0byBtZS4gIEknZCBleHBlY3QgdGhlIHByaW50IHRvIHNob3cgbWUgdGhl DQo+ID4gPiBjdXJyZW50IHZhbHVlIG9mIHRoZSB2YXJpYWJsZSBpbiBzY29w ZS4NCj4gPiA+DQo+ID4gPiBJbiBjdXJyZW50IG1hc3RlciAod2l0aG91dCB0 aGUgcGF0Y2gpLCB3ZSBnZXQ6DQo+ID4gPg0KPiA+ID4gIChnZGIpIHMNCj4g PiA+ICBnZXRfdmVyc2lvbl8yICgpIGF0IGdkYi5iYXNlL3ByaW50LWZpbGUt dmFyLWxpYjIuYzoyMg0KPiA+ID4gIDIyICAgICAgICByZXR1cm4gdGhpc192 ZXJzaW9uX2lkOw0KPiA+ID4gIChnZGIpIHAgdGhpc192ZXJzaW9uX2lkDQo+ ID4gPiAgJDEgPSAxMDQNCj4gPiA+ICAoZ2RiKSBmaW5pc2gNCj4gPiA+ICBS dW4gdGlsbCBleGl0IGZyb20gIzAgIGdldF92ZXJzaW9uXzIgKCkgYXQNCj4g PiA+IGdkYi5iYXNlL3ByaW50LWZpbGUtdmFyLWxpYjIuYzoyMiAweDAwMDAw MDAwMDA0MDA3M2IgaW4gbWFpbiAoKSBhdA0KPiA+IGdkYi5iYXNlL3ByaW50 LWZpbGUtdmFyLW1haW4uYzoyNA0KPiA+ID4gIDI0ICAgICAgICBpbnQgdjIg PSBnZXRfdmVyc2lvbl8yICgpOw0KPiA+ID4gIFZhbHVlIHJldHVybmVkIGlz ICQyID0gMTA0DQo+ID4NCj4gPiBIZWxsbyBQZWRybywNCj4gPg0KPiA+IFRo YW5rcyBhIGxvdCBmb3IgcmV2aWV3aW5nIHRoYXQhDQo+ID4gSSB3aWxsIGJy aW5nIG1vcmUgaW5mb3JtYXRpb24gcmVsYXRlZCB0byB3aGF0IGRlYnVnIGlu Zm9ybWF0aW9uDQo+ID4gcHJvdmlkZSBhbmQgc28gb24uDQo+ID4gVGhlIGxp bmtlciBpcyB0aGUgY2F1c2Ugb2YgdGhpcyBkaXNjb25uZWN0aW9uLiAgSW4g YSBwcmV2aW91cyB0ZXN0DQo+ID4gcGF0Y2ggSSBoYXZlIGFkZGVkIGEgc2V0 L3Nob3cgdmFyaWFibGUgc3dpdGNoIGJldHdlZW4uDQo+ID4gRGxvcGVuIGFu ZCBsaW5rZXIgYmVoYXZpb3IuICBJIGFsc28gZm91bmQgdGhhdCB3cm9uZyBh bmQgbG9va2luZyBhdCBpdCBhZ2Fpbi4NCj4gPg0KPiA+IEkgd2lsbCB0cnkg dG8gYnJpbmcgbW9yZSBmYWN0cyB3aXRoIHRoZSBkZWJ1ZyBpbmZvIGFuZCBt ZW1vcnkgZXhhbWluYXRpb24uDQo+ID4NCj4gPiBJbiBhbnkgY2FzZSBhY3R1 YWwgYmVoYXZpb3Igb2YgbWFzdGVyIGlzIGFsc28gd3JvbmcgZm9yIGRsb3Bl biBjYXNlIQ0KPiA+DQo+IA0KPiBIZWxsbyBhbGwsDQo+IA0KPiBIZXJlIHdl IGdvOg0KPiANCj4gV2l0aCBtYWlubGluZSBnZGIgd2UgaGF2ZSB0aGUgZm9s bG93aW5nIHNjZW5hcmlvOg0KPiANCj4gU3RvcHBlZCBhdCBtYWluIGxpbmUg MzIgaW4gcHJpbnQtZmlsZS12YXItbWFpbih0ZXN0Y2FzZSkNCj4gDQo+IAko Z2RiKSBwcmludCB0aGlzX3ZlcnNpb25faWQNCj4gCSQxID0gMTA0DQo+IA0K PiBUaGlzIHdhcyBleHBlY3RlZCwgd2UgYXJlIGxvb2tpbmcgYXQgdGhlIHN5 bWJvbCB0aGF0IHRoZSBsaW5rZXIgYW5kIG1haW4gY2FuDQo+IHNlZSBhcyBz cGVjaWZpZWQgaW4gdGhlIGdsb2JhbCBzY29wZS4NCj4gDQo+IAkoZ2RiKSBw cmludCAmdGhpc192ZXJzaW9uX2lkDQo+IAkkMiA9IChpbnQgKikgMHg3ZmZm ZjdkZGIwMjggPHRoaXNfdmVyc2lvbl9pZD4NCj4gDQo+IAkoZ2RiKSBpbmZv IHN5bWJvbCAweDdmZmZmN2RkYjAyOA0KPiAJdGhpc192ZXJzaW9uX2lkIGlu IHNlY3Rpb24gLmRhdGEgb2YNCj4gL25mcy9pdWwvZGlza3MvaXVsX3RlYW0y L3d0ZWRlc2NoL19nZGJfL2V4dGVybl9nZGIvYmluL2Rsb3Blbi9nZGIvdGVz dA0KPiBzdWl0ZS9vdXRwdXRzL2dkYi5iYXNlL3ByaW50LWZpbGUtdmFyL3By aW50LWZpbGUtdmFyLWxpYjEuc28NCj4gDQo+IFRob3NlIHR3byBsYXN0IGV2 YWx1YXRpb25zIHByb3ZlIHRoYXQgd2UgYXJlIHNlZW0gYSBzeW1ib2wgY29t aW5nIGZyb20NCj4gdGhlIGZpcnN0IGxpYnJhcnkgYXMgZXhwZWN0ZWQgYW5k IGRvbmUgYnkgdGhlIGxpbmtlci4NCj4gDQo+IEhvd2V2ZXIgaW50ZXJlc3Rp bmdseSBpZiBJIHNwZWNpZnkgdGhlIHNjb3BlLCBJIGdldDoNCj4gDQo+IAko Z2RiKSBwcmludCAgJigncHJpbnQtZmlsZS12YXItbGliMi5jJzo6dGhpc192 ZXJzaW9uX2lkKQ0KPiAJJDMgPSAoaW50ICopIDB4N2ZmZmY3ZGRiMDI4ICA8 dGhpc192ZXJzaW9uX2lkPg0KPiANCj4gCShnZGIpIGluZm8gc3ltYm9sIDB4 N2ZmZmY3ZGRiMDI4DQo+IAl0aGlzX3ZlcnNpb25faWQgaW4gc2VjdGlvbiAu ZGF0YSBvZg0KPiAvbmZzL2l1bC9kaXNrcy9pdWxfdGVhbTIvd3RlZGVzY2gv X2dkYl8vZXh0ZXJuX2dkYi9iaW4vZGxvcGVuL2dkYi90ZXN0DQo+IHN1aXRl L291dHB1dHMvZ2RiLmJhc2UvcHJpbnQtZmlsZS12YXIvcHJpbnQtZmlsZS12 YXItbGliMS5zbw0KPiANCj4gQnV0IEkgaGF2ZSBzcGVjaWZpZWQgdGhlIHNj b3BlISBJIGFtIGFza2luZyBzcGVjaWZpY2FsbHkgdGhhdCBJIHdhbnQgdGhl IHN5bWJvbA0KPiBkZWZpbmVkIGluIHRoZSBzZWNvbmQgbGlicmFyeSBub3Qg aW4gdGhlIGZpcnN0Lg0KPiANCj4gSWYgSSB1c2UgdGhlIHBhdGNoIHByb3Zp ZGVkIHRoYW4gSSBnZXQ6DQo+IA0KPiAJKGdkYikgcHJpbnQgICYoJ3ByaW50 LWZpbGUtdmFyLWxpYjIuYyc6OnRoaXNfdmVyc2lvbl9pZCkNCj4gCSQ0ID0g KGludCAqKSAweDdmZmZmN2RkYjAyOCA8dGhpc192ZXJzaW9uX2lkPg0KPiAN Cj4gCShnZGIpIGluZm8gc3ltYm9sIDB4N2ZmZmY3ZGRiMDI4DQo+IAl0aGlz X3ZlcnNpb25faWQgaW4gc2VjdGlvbiAuZGF0YSBvZg0KPiAvbmZzL2l1bC9k aXNrcy9pdWxfdGVhbTIvd3RlZGVzY2gvX2dkYl8vZXh0ZXJuX2dkYi9iaW4v ZGxvcGVuL2dkYi90ZXN0DQo+IHN1aXRlL291dHB1dHMvZ2RiLmJhc2UvcHJp bnQtZmlsZS12YXIvcHJpbnQtZmlsZS12YXItbGliMS5zbw0KPiANClNvcnJ5 IFdyb25nIGNvcHksIHdpdGggdGhlIHBhdGNoOg0KCShnZGIpIGluZm8gc3lt Ym9sIDB4N2ZmZmY3YmQ5MDI4DQoJdGhpc192ZXJzaW9uX2lkIGluIHNlY3Rp b24gLmRhdGEgb2YgL25mcy9pdWwvZGlza3MvaXVsX3RlYW0yL3d0ZWRlc2No L19nZGJfL2V4dGVybl9nZGIvYmluL2Rsb3Blbi9nZGIvdGVzdHN1aXRlL291 dHB1dHMvZ2RiLmJhc2UvcHJpbnQtZmlsZS12YXIvcHJpbnQtZmlsZS12YXIt bGliMi5zbw0KDQoJKGdkYikgcHJpbnQgICYoJ3ByaW50LWZpbGUtdmFyLWxp YjIuYyc6OnRoaXNfdmVyc2lvbl9pZCkNCgkkNCA9IChpbnQgKikgMHg3ZmZm ZjdiZDkwMjggPHRoaXNfdmVyc2lvbl9pZD4NCg0KCShnZGIpIGluZm8gc3lt Ym9sIDB4N2ZmZmY3YmQ5MDI4DQoJdGhpc192ZXJzaW9uX2lkIGluIHNlY3Rp b24gLmRhdGEgb2YgL25mcy9pdWwvZGlza3MvaXVsX3RlYW0yL3d0ZWRlc2No L19nZGJfL2V4dGVybl9nZGIvYmluL2Rsb3Blbi9nZGIvdGVzdHN1aXRlL291 dHB1dHMvZ2RiLmJhc2UvcHJpbnQtZmlsZS12YXIvcHJpbnQtZmlsZS12YXIt bGliMi5zbw0KDQoNCj4gX1RoaXMgd2FzIHdoYXQgSSd2ZSBleHBlY3RlZC4g Xw0KPiANCj4gV2l0aCB0aGF0IEkgX2Nhbm5vdF8gc2F5IHRoYXQgR0RCIGlz IGRvaW5nIHJpZ2h0IGluIHRoZSBtYWluIGxpbmUuIEJhc2ljYWxseSB0aGUN Cj4gdGVzdCBpcyB3ZWFrIQ0KPiANCj4gVGhlIGlzc3VlIGlzIGluIHRoZSBz eW10YWIuYyB+MjYwMzoNCj4gICAgICBnZGJhcmNoX2l0ZXJhdGVfb3Zlcl9v YmpmaWxlc19pbl9zZWFyY2hfb3JkZXINCj4gIAkob2JqZmlsZSAhPSBOVUxM ID8gZ2V0X29iamZpbGVfYXJjaCAob2JqZmlsZSkgOiB0YXJnZXRfZ2RiYXJj aCAoKSwNCj4gIAkgbG9va3VwX3N5bWJvbF9nbG9iYWxfaXRlcmF0b3JfY2Is ICZsb29rdXBfZGF0YSwgb2JqZmlsZSk7DQo+IA0KPiBUaGUgbG9va3VwIGhl cmUgaXMgZG9uZSBpbiB0aGUgb3JkZXIgb2YgdGhlIGxpYnJhcnkgbG9hZCwg d2hhdCBpcyByaWdodCBmb3INCj4gZ2xvYmFsIHN5bWJvbHMsIElmIGFuZCBv bmx5IGlmIG5vIHNjb3BlIGlzIHByb3ZpZGVkLg0KPiBBZ2FpbiB1c2VyIHdp bGwgc3BlY2lmeSB0aGUgc2NvcGUgaWYgaGUgaGFzIGEgZG91YnQgb24gaG93 IGluIGVhcnRoIGhpcyB2YWx1ZSBpcw0KPiBub3Qgd2hhdCBpcyBzZWVuIGlu IHRoZSBleGVjdXRpb24hDQo+IA0KPiANCj4gSSBob3BlIHRoaXMgc2FtcGxl IHJ1biBoZWxwcyBpbiBlbHVjaWRhdGluZyB0aGUgcHJvYmxlbSENCj4gDQo+ IFRoYW5rcyBhbmQgcmVnYXJkcywNCj4gL0ZyZWQNCj4gDQo+ID4gVGhhbmtz IGFuZCByZWdhcmRzLA0KPiA+IC9GcmVkDQo+ID4gPg0KPiA+ID4gVGhhbmtz LA0KPiA+ID4gUGVkcm8gQWx2ZXMNCj4gPiBJbnRlbCBEZXV0c2NobGFuZCBH bWJIDQo+ID4gUmVnaXN0ZXJlZCBBZGRyZXNzOiBBbSBDYW1wZW9uIDEwLTEy LCA4NTU3OSBOZXViaWJlcmcsIEdlcm1hbnkNCj4gPiBUZWw6ICs0OSA4OSA5 OSA4ODUzLTAsIHd3dy5pbnRlbC5kZQ0KPiA+IE1hbmFnaW5nIERpcmVjdG9y czogQ2hyaXN0aW4gRWlzZW5zY2htaWQsIENocmlzdGlhbiBMYW1wcmVjaHRl cg0KPiA+IENoYWlycGVyc29uIG9mIHRoZSBTdXBlcnZpc29yeSBCb2FyZDog Tmljb2xlIExhdSBSZWdpc3RlcmVkIE9mZmljZToNCj4gPiBNdW5pY2ggQ29t bWVyY2lhbA0KPiA+IFJlZ2lzdGVyOiBBbXRzZ2VyaWNodCBNdWVuY2hlbiBI UkIgMTg2OTI4DQpJbnRlbCBEZXV0c2NobGFuZCBHbWJIClJlZ2lzdGVyZWQg QWRkcmVzczogQW0gQ2FtcGVvbiAxMC0xMiwgODU1NzkgTmV1YmliZXJnLCBH ZXJtYW55ClRlbDogKzQ5IDg5IDk5IDg4NTMtMCwgd3d3LmludGVsLmRlCk1h bmFnaW5nIERpcmVjdG9yczogQ2hyaXN0aW4gRWlzZW5zY2htaWQsIENocmlz dGlhbiBMYW1wcmVjaHRlcgpDaGFpcnBlcnNvbiBvZiB0aGUgU3VwZXJ2aXNv cnkgQm9hcmQ6IE5pY29sZSBMYXUKUmVnaXN0ZXJlZCBPZmZpY2U6IE11bmlj aApDb21tZXJjaWFsIFJlZ2lzdGVyOiBBbXRzZ2VyaWNodCBNdWVuY2hlbiBI UkIgMTg2OTI4Cg== >From gdb-patches-return-142902-listarch-gdb-patches=sources.redhat.com@sourceware.org Mon Oct 23 10:07:17 2017 Return-Path: Delivered-To: listarch-gdb-patches@sources.redhat.com Received: (qmail 23248 invoked by alias); 23 Oct 2017 10:07:17 -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 23230 invoked by uid 89); 23 Oct 2017 10:07:16 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.5 required=5.0 tests=BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,RCVD_IN_BRBL_LASTEXT,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.2 spammy=b2, $b2, 2.3, inclusive X-HELO: smtp.eu.adacore.com Received: from mel.act-europe.fr (HELO smtp.eu.adacore.com) (194.98.77.210) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 23 Oct 2017 10:07:12 +0000 Received: from localhost (localhost [127.0.0.1]) by filtered-smtp.eu.adacore.com (Postfix) with ESMTP id C8FAA81850; Mon, 23 Oct 2017 12:07:09 +0200 (CEST) Received: from smtp.eu.adacore.com ([127.0.0.1]) by localhost (smtp.eu.adacore.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 3uZl1s3c771J; Mon, 23 Oct 2017 12:07:09 +0200 (CEST) Received: from Xaviers-MacBook-Pro.local (unknown [46.18.100.10]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.eu.adacore.com (Postfix) with ESMTPSA id 7A01681399; Mon, 23 Oct 2017 12:07:09 +0200 (CEST) Subject: [RFA v4] enable/disable sub breakpoint range To: Pedro Alves , gdb-patches@sourceware.org References: <83lgks1e1h.fsf@gnu.org> <57a9cdc7-a5fc-0852-8ebe-c7c32c78d475@adacore.com> <77911433-028a-ee7c-e617-eb1fd84f65c0@redhat.com> From: Xavier Roirand Message-ID: Date: Mon, 23 Oct 2017 10:07:00 -0000 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12; rv:52.0) Gecko/20100101 Thunderbird/52.4.0 MIME-Version: 1.0 In-Reply-To: <77911433-028a-ee7c-e617-eb1fd84f65c0@redhat.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit X-IsSubscribed: yes X-SW-Source: 2017-10/txt/msg00709.txt.bz2 Content-length: 25703 Hello, Seems that my v3 patch sent in my previous email was not merging fine so here's a rebased version. Hope it will work better. ----- Allow enabling/disabling breakpoint location range In some cases, adding one breakpoint corresponds to multiple places in a program thus leads GDB to define main breakpoint number and other breakpoints using location number with syntax: . For example: Num Type Disp Enb Address What 1 breakpoint keep y 1.1 y 0x080486a2 in void foo()... 1.2 y 0x080486ca in void foo()... In this example, main breakpoint is breakpoint 1 where location breakpoints are 1.1 and 1.2 ones. This patch allows enable/disable a range of breakpoint locations using syntax: .- with inclusive last_location_number. For instance, if adding a breakpoint to foo() generates 5 breakpoint locations from 1.1 to 1.5 then it's now possible to enable/disable only location breakpoint 1.3 to location breakpoint 1.5 (so 1.3, 1.4 and 1.5) using syntax: enable 1.3-5 or disable 1.3-5 gdb/ChangeLog: * breakpoint.c (map_breakpoint_number_range): Create from map_breakpoint_numbers refactoring. (map_breakpoint_numbers): Refactor by calling map_breakpoint_number_range. (find_location_by_number): Change parameters from string to breakpoint number and location. (extract_bp_number_and_location): New function. (enable_disable_bp_num_loc): Create from enable/disable_command refactoring. (enable_disable_command): Create from enable/disable_command refactoring. (enable_command): Refactor using enable_disable_command. (disable_command): Refactor using enable_disable_command. * NEWS: Document enable/disable location range feature. gdb/doc/ChangeLog: * gdb.texinfo (Set Breaks): Add documentation for location breakpoint range enable/disable action. gdb/testsuite/ChangeLog: * gdb.cp/locbprange.exp: New test scenario. * gdb.cp/locbprange.cc: New test. diff --git a/gdb/NEWS b/gdb/NEWS index fbf5591..76d7cec 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -75,6 +75,11 @@ QSetWorkingDir * The "maintenance selftest" command now takes an optional argument to filter the tests to be run. +* Breakpoint commands accept location ranges. + +The breakpoint commands ``enable'', and ``disable'' now accept a +location range of breakpoints, e.g. ``1.3-5''. + * New commands set|show cwd diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index 32ceea7..c5a84eb 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -93,9 +93,18 @@ enum exception_event_kind /* Prototypes for local functions. */ +static void disable_command (char *, int); + +static void enable_command (char *, int); + +static void map_breakpoint_number_range (std::pair &bp_num_range, + gdb::function_view); + static void map_breakpoint_numbers (const char *, gdb::function_view); +static void enable_disable_command (char *args, int from_tty, bool enable); + static void ignore_command (char *, int); static void breakpoint_re_set_default (struct breakpoint *); @@ -14160,17 +14169,51 @@ ignore_command (char *args, int from_tty) if (from_tty) printf_filtered ("\n"); } - + +/* Call FUNCTION on each of the breakpoints present in range defined by + BP_NUM_RANGE as pair of integer in which BP_NUM_RANGE.FIRST is the start + of the breakpoint number range and BP_NUM_RANGE.SECOND is the end of + the breakpoint number range. + If BP_NUM_RANGE.FIRST == BP_NUM_RANGE.SECOND then the + range is just a single breakpoint number. */ + +static void +map_breakpoint_number_range (std::pair &bp_num_range, + gdb::function_view function) +{ + if (bp_num_range.first == 0) + { + warning (_("bad breakpoint number at or near '%d'"), + bp_num_range.first); + } + else + { + struct breakpoint *b, *tmp; + + for (int i = bp_num_range.first; i <= bp_num_range.second; i++) + { + bool match = false; + + ALL_BREAKPOINTS_SAFE (b, tmp) + if (b->number == i) + { + match = true; + function (b); + break; + } + if (!match) + printf_unfiltered (_("No breakpoint number %d.\n"), i); + } + } +} + /* Call FUNCTION on each of the breakpoints whose numbers are given in ARGS. */ static void map_breakpoint_numbers (const char *args, - gdb::function_view function) + gdb::function_view function) { - int num; - struct breakpoint *b, *tmp; - if (args == 0 || *args == '\0') error_no_arg (_("one or more breakpoint numbers")); @@ -14178,43 +14221,22 @@ map_breakpoint_numbers (const char *args, while (!parser.finished ()) { - const char *p = parser.cur_tok (); - bool match = false; + int num = parser.get_number (); + std::pair range = std::make_pair (num, num); - num = parser.get_number (); - if (num == 0) - { - warning (_("bad breakpoint number at or near '%s'"), p); - } - else - { - ALL_BREAKPOINTS_SAFE (b, tmp) - if (b->number == num) - { - match = true; - function (b); - break; - } - if (!match) - printf_unfiltered (_("No breakpoint number %d.\n"), num); - } + map_breakpoint_number_range (range, function); } } +/* Return the breakpoint location structure corresponding to the + BP_NUM and LOC_NUM values. */ + static struct bp_location * -find_location_by_number (const char *number) +find_location_by_number (int bp_num, int loc_num) { - const char *p1; - int bp_num; - int loc_num; struct breakpoint *b; struct bp_location *loc; - p1 = number; - bp_num = get_number_trailer (&p1, '.'); - if (bp_num == 0 || p1[0] != '.') - error (_("Bad breakpoint number '%s'"), number); - ALL_BREAKPOINTS (b) if (b->number == bp_num) { @@ -14222,25 +14244,154 @@ find_location_by_number (const char *number) } if (!b || b->number != bp_num) - error (_("Bad breakpoint number '%s'"), number); + error (_("Bad breakpoint number '%d'"), bp_num); - /* Skip the dot. */ - ++p1; - const char *save = p1; - loc_num = get_number (&p1); if (loc_num == 0) - error (_("Bad breakpoint location number '%s'"), number); + error (_("Bad breakpoint location number '%d'"), loc_num); --loc_num; loc = b->loc; for (;loc_num && loc; --loc_num, loc = loc->next) ; if (!loc) - error (_("Bad breakpoint location number '%s'"), save); + error (_("Bad breakpoint location number '%d'"), loc_num); return loc; } +/* Extract the breakpoint range defined by ARG. Return the start of + the breakpoint range defined by BP_NUM_RANGE.FIRST and + BP_LOC_RANGE.FIRST and the end of the breakpoint range defined by + BP_NUM_RANGE.second and BP_LOC_RANGE.SECOND. + + The range may be any of the following form: + + x where x is breakpoint number. + x-y where x and y are breakpoint numbers range. + x.y where x is breakpoint number and z a location number. + x.y-z where x is breakpoint number and y and z a location number + range. */ + +static int +extract_bp_number_and_location (const std::string &arg, + std::pair &bp_num_range, + std::pair &bp_loc_range) +{ + std::size_t dot = arg.find ("."); + + if (dot != std::string::npos) + { + /* Handle x.y and x.y-z cases. */ + std::size_t dash; + std::string bp_loc; + + if (arg.length () == dot + 1 || dot == 0) + error (_("bad breakpoint number at or near: '%s'"), arg.c_str ()); + + dash = arg.find ("-", dot + 1); + + bp_loc = arg.substr (dot + 1); + const char *ptbf = arg.substr (0, dot).c_str (); + bp_num_range.first = get_number(&ptbf); + bp_num_range.second = bp_num_range.first; + + if (bp_num_range.first == 0) + error (_("Bad breakpoint number '%s'"), arg.c_str ()); + + if (dash != std::string::npos) + { + /* bp_loc is range (x-z). */ + if (arg.length () == dash + 1) + error (_("bad breakpoint number at or near: '%s'"), arg.c_str ()); + dash = bp_loc.find ("-"); + const char *ptlf = bp_loc.substr (0, dash).c_str (); + bp_loc_range.first = get_number(&ptlf); + const char *ptls= bp_loc.substr (dash + 1).c_str (); + bp_loc_range.second = get_number(&ptls); + } + else + { + /* bp_loc is single value. */ + const char *ptls= bp_loc.c_str (); + bp_loc_range.second = get_number(&ptls); + bp_loc_range.first = bp_loc_range.second; + if (bp_loc_range.first == 0) + { + warning (_("bad breakpoint number at or near '%s'"), arg.c_str ()); + return 1; + } + } + } + else + { + /* Handle x and x-y cases. */ + std::size_t dash; + + dash = arg.find ("-"); + bp_loc_range.first = 0; + bp_loc_range.second = 0; + if (dash != std::string::npos) + { + if (arg.length () == dash + 1 || dash == 0) + error (_("bad breakpoint number at or near: '%s'"), arg.c_str ()); + + const char *ptlf = arg.substr (0, dash).c_str (); + bp_num_range.first = get_number (&ptlf); + const char *ptls= arg.substr (dash + 1).c_str (); + bp_num_range.second = get_number (&ptls); + } + else + { + const char * ptlf = arg.c_str (); + bp_num_range.first = get_number (&ptlf); + bp_num_range.second = bp_num_range.first; + if (bp_num_range.first == 0) + { + warning (_("bad breakpoint number at or near '%s'"), arg.c_str ()); + return 1; + } + } + } + + if (bp_num_range.first == 0 || bp_num_range.second == 0) + error (_("bad breakpoint number at or near: '%s'"), arg.c_str ()); + + return 0; +} + +/* Enable or disable a breakpoint using BP_NUMB, LOC_NUM and enable. */ + +static void +enable_disable_bp_num_loc (int bp_num, int loc_num, bool enable) +{ + struct bp_location *loc = find_location_by_number (bp_num, loc_num); + if (loc != NULL) + { + if (loc->enabled != enable) + { + loc->enabled = enable; + mark_breakpoint_location_modified (loc); + } + if (target_supports_enable_disable_tracepoint () + && current_trace_status ()->running && loc->owner + && is_tracepoint (loc->owner)) + target_disable_tracepoint (loc); + } + update_global_location_list (UGLL_DONT_INSERT); +} + +/* Enable or disable a breakpoint location range. It uses BP_NUM, + BP_LOC_RANGE.FIRST for the start of the range, BP_LOC_RANGE.SECOND for + the end of the range and enable. */ + +static void +enable_disable_breakpoint_location_range (int bp_num, + std::pair &bp_loc_range, + bool enable) +{ + for (int i = bp_loc_range.first; i <= bp_loc_range.second; i++) + enable_disable_bp_num_loc (bp_num, i, enable); +} /* Set ignore-count of breakpoint number BPTNUM to COUNT. If from_tty is nonzero, it prints a message to that effect, @@ -14274,8 +14425,12 @@ disable_breakpoint (struct breakpoint *bpt) observer_notify_breakpoint_modified (bpt); } +/* Enable or disable breakpoint defined in ARGS. Breakpoint may be + any of the form defined in extract_bp_number_and_location. + ENABLE enable or disable breakpoint. */ + static void -disable_command (const char *args, int from_tty) +enable_disable_command (char *args, int from_tty, bool enable) { if (args == 0) { @@ -14283,43 +14438,58 @@ disable_command (const char *args, int from_tty) ALL_BREAKPOINTS (bpt) if (user_breakpoint_p (bpt)) - disable_breakpoint (bpt); + { + if (enable) + enable_breakpoint (bpt); + else + disable_breakpoint (bpt); + } } else { std::string num = extract_arg (&args); while (!num.empty ()) - { - if (num.find ('.') != std::string::npos) - { - struct bp_location *loc = find_location_by_number (num.c_str ()); - - if (loc) - { - if (loc->enabled) - { - loc->enabled = 0; - mark_breakpoint_location_modified (loc); - } - if (target_supports_enable_disable_tracepoint () - && current_trace_status ()->running && loc->owner - && is_tracepoint (loc->owner)) - target_disable_tracepoint (loc); - } - update_global_location_list (UGLL_DONT_INSERT); - } - else - map_breakpoint_numbers - (num.c_str (), [&] (breakpoint *b) - { - iterate_over_related_breakpoints (b, disable_breakpoint); - }); - num = extract_arg (&args); - } + { + std::pair bp_num_range; + std::pair bp_loc_range; + + int err_ret = extract_bp_number_and_location (num.c_str(), + bp_num_range, + bp_loc_range); + if (!err_ret) + { + if (bp_loc_range.first == bp_loc_range.second + && bp_loc_range.first == 0) + { + /* Handle breakpoint with format x or x-z only. */ + map_breakpoint_number_range (bp_num_range, + enable ? enable_breakpoint : + disable_breakpoint); + } + else + { + /* Handle breakpoint with format is x.y or x.y-z */ + enable_disable_breakpoint_location_range + (bp_num_range.first, bp_loc_range, enable); + } + } + num = extract_arg (&args); + } } } +/* The disable command disables the specified breakpoints (or all defined + breakpoints) so they once stop be effective in stopping + the inferior. ARGS may be any of the form defined in + extract_bp_number_and_location. */ + +static void +disable_command (char *args, int from_tty) +{ + enable_disable_command (args, from_tty, false); +} + static void enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition, int count) @@ -14392,52 +14562,13 @@ enable_breakpoint (struct breakpoint *bpt) /* The enable command enables the specified breakpoints (or all defined breakpoints) so they once again become (or continue to be) effective - in stopping the inferior. */ + in stopping the inferior. ARGS may be any of the form defined in + extract_bp_number_and_location. */ static void enable_command (const char *args, int from_tty) { - if (args == 0) - { - struct breakpoint *bpt; - - ALL_BREAKPOINTS (bpt) - if (user_breakpoint_p (bpt)) - enable_breakpoint (bpt); - } - else - { - std::string num = extract_arg (&args); - - while (!num.empty ()) - { - if (num.find ('.') != std::string::npos) - { - struct bp_location *loc = find_location_by_number (num.c_str ()); - - if (loc) - { - if (!loc->enabled) - { - loc->enabled = 1; - mark_breakpoint_location_modified (loc); - } - if (target_supports_enable_disable_tracepoint () - && current_trace_status ()->running && loc->owner - && is_tracepoint (loc->owner)) - target_enable_tracepoint (loc); - } - update_global_location_list (UGLL_MAY_INSERT); - } - else - map_breakpoint_numbers - (num.c_str (), [&] (breakpoint *b) - { - iterate_over_related_breakpoints (b, enable_breakpoint); - }); - num = extract_arg (&args); - } - } + enable_disable_command (args, from_tty, true); } static void diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index bfeb7a9..b1346d9 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -3929,13 +3929,20 @@ Num Type Disp Enb Address What Each location can be individually enabled or disabled by passing @var{breakpoint-number}.@var{location-number} as argument to the -@code{enable} and @code{disable} commands. Note that you cannot -delete the individual locations from the list, you can only delete the -entire list of locations that belong to their parent breakpoint (with -the @kbd{delete @var{num}} command, where @var{num} is the number of -the parent breakpoint, 1 in the above example). Disabling or enabling -the parent breakpoint (@pxref{Disabling}) affects all of the locations -that belong to that breakpoint. +@code{enable} and @code{disable} commands. It's also possible to +@code{enable} and @code{disable} range of @var{location-number} +breakpoints using a @var{breakpoint-number} and two @var{location-number}, +in increasing order, separated by a hyphen, like +‘@var{breakpoint-number}.5-7’. +In this case, when a @var{location-number} range is given to this +command, all breakpoints belonging to this @var{breakpoint-number} +and inside that range are operated on. +Note that you cannot delete the individual locations from the list, +you can only delete the entire list of locations that belong to their +parent breakpoint (with the @kbd{delete @var{num}} command, where +@var{num} is the number of the parent breakpoint, 1 in the above example). +Disabling or enabling the parent breakpoint (@pxref{Disabling}) affects +all of the locations that belong to that breakpoint. @cindex pending breakpoints It's quite common to have a breakpoint inside a shared library. diff --git a/gdb/testsuite/gdb.cp/locbprange.cc b/gdb/testsuite/gdb.cp/locbprange.cc new file mode 100644 index 0000000..ff44b50 --- /dev/null +++ b/gdb/testsuite/gdb.cp/locbprange.cc @@ -0,0 +1,57 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2017 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include + +class foo + { + public: + static int overload (void); + static int overload (char); + static int overload (int); + static int overload (double); + }; + +void marker1() + { + } + +int main () + { + foo::overload (); + foo::overload (111); + foo::overload ('h'); + foo::overload (3.14); + + marker1 (); // marker1-returns-here + + return 0; + } + +/* Some functions to test overloading by varying one argument type. */ + +int foo::overload (void) + { + return 1; + } +int foo::overload (char arg) + { + arg = 0; + return 2; + } +int foo::overload (int arg) { arg = 0; return 3;} +int foo::overload (double arg) { arg = 0; return 4;} diff --git a/gdb/testsuite/gdb.cp/locbprange.exp b/gdb/testsuite/gdb.cp/locbprange.exp new file mode 100644 index 0000000..2a13791 --- /dev/null +++ b/gdb/testsuite/gdb.cp/locbprange.exp @@ -0,0 +1,160 @@ +# Copyright 2017 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# This file is part of the gdb testsuite + +# Tests for breakpoint location range enable/disable commands. + +set ws "\[\r\n\t \]+" +set nl "\[\r\n\]+" + + +if { [skip_cplus_tests] } { continue } + +standard_testfile .cc + +if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} { + return -1 +} + +# Set it up at a breakpoint so we can play with the variable values. + +if ![runto 'marker1'] then { + perror "couldn't run to marker1" + continue +} + +# Prevent symbol on address 0x0 being printed. +gdb_test_no_output "set print symbol off" + +gdb_test "up" ".*main.*" "up from marker1" + +# Returns a buffer corresponding to what gdb replies when +# asking for 'info breakpoint'. The parameters are all the +# existing breakpoints enabled/disable value: 'n' or 'y'. + +proc set_info_breakpoint_reply {b1 b2 b21 b22 b23 b24} { + + set buf "Num Type\[ \]+Disp Enb Address\[ \]+What.* +1\[\t \]+breakpoint keep $b1.* in marker1\\(\\) at .* +\[\t \]+breakpoint already hit 1 time.* +2\[\t \]+breakpoint\[\t \]+keep $b2\[\t \]+.* +2.1\[\t \]+$b21.* +2.2\[\t \]+$b22.* +2.3\[\t \]+$b23.* +2.4\[\t \]+$b24.*" + + return $buf +} + +gdb_test "break foo::overload" \ + "Breakpoint \[0-9\]+ at $hex: foo::overload. .4 locations." \ + "set breakpoint at overload" + +gdb_test "info break" [set_info_breakpoint_reply y y y y y y] \ + "breakpoint info" + +# Check that we can disable a breakpoint. +gdb_test_no_output "disable 1" + +gdb_test "info break" [set_info_breakpoint_reply n y y y y y] \ + "breakpoint info disable bkpt 1" + +# Check that we can enable a breakpoint. +gdb_test_no_output "enable 1" + +gdb_test "info break" [set_info_breakpoint_reply y y y y y y] \ + "breakpoint info enable bkpt 1" + +# Check that we can disable a breakpoint containing location breakpoints. +gdb_test_no_output "disable 2" + +gdb_test "info break" [set_info_breakpoint_reply y n y y y y] \ + "breakpoint info disable bkpt 2" + +# Check that we can enable a breakpoint containing location breakpoints. +gdb_test_no_output "enable 2" + +gdb_test "info break" [set_info_breakpoint_reply y y y y y y] \ + "breakpoint info enable bkpt 2" + +# Check that we can disable a single location breakpoint. +gdb_test_no_output "disable 2.2" + +gdb_test "info break" [set_info_breakpoint_reply y y y n y y] \ + "breakpoint info disable bkpt 2.2" + +# Check that we can enable a single location breakpoint. +gdb_test_no_output "enable 2.2" + +gdb_test "info break" [set_info_breakpoint_reply y y y y y y] \ + "breakpoint info enable bkpt 2.2" + +# Check that we can disable a location breakpoint range. +gdb_test_no_output "disable 2.2-3" + +gdb_test "info break" [set_info_breakpoint_reply y y y n n y] \ + "breakpoint info disable bkpt 2.2 to 2.3" + +# Check that we can enable a location breakpoint range. +gdb_test_no_output "enable 2.2-3" + +gdb_test "info break" [set_info_breakpoint_reply y y y y y y] \ + "breakpoint info enaable bkpt 2.2 to 2.3" + +# Check that we can disable a location breakpoint range reduced +# to a single location. +gdb_test_no_output "disable 2.2-2" + +gdb_test "info break" [set_info_breakpoint_reply y y y n y y] \ + "breakpoint info disable 2.2 to 2.2" + +# Check that we can disable a location breakpoint range with max > +# existing breakpoint location. +gdb_test "disable 2.3-5" "Bad breakpoint location number '$decimal'" \ + "disable location breakpoint range with max > existing" + +gdb_test "info break" [set_info_breakpoint_reply y y y n n n] \ + "breakpoint info disable 2.3 to 2.5" + +# Check that we can enable a location breakpoint range with max > +# existing breakpoint location. +gdb_test "enable 2.3-5" "Bad breakpoint location number '$decimal'" \ + "enable location breakpoint range with max > existing" + +gdb_test "info break" [set_info_breakpoint_reply y y y n y y] \ + "breakpoint info enable 2.3 to 2.5" + +# Check that disabling an reverse location breakpoint range does +# not work. +gdb_test_no_output "disable 2.3-2" + +gdb_test "info break" [set_info_breakpoint_reply y y y n y y] \ + "breakpoint info disable 2.3 to 2.3" + +# Check that disabling an unvalid location breakpoint range does +# not cause unexpected behavior. +gdb_test "disable 2.6-7" "Bad breakpoint location number '$decimal'" \ + "disable an unvalid location breakpoint range" + +gdb_test "info break" [set_info_breakpoint_reply y y y n y y] \ + "breakpoint info disable 2.6 to 2.7" + +# Check that disabling an invalid location breakpoint range does not +# cause trouble. +gdb_test_no_output "disable 2.8-6" + +gdb_test "info break" [set_info_breakpoint_reply y y y n y y] \ + "breakpoint info disable 2.8 to 2.6"