From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 2780 invoked by alias); 13 Jan 2020 19:36:08 -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 2763 invoked by uid 89); 13 Jan 2020 19:36:08 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-21.9 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_SHORT,SPF_PASS autolearn=ham version=3.3.1 spammy=Board, commercial, Managing X-HELO: mga07.intel.com Received: from mga07.intel.com (HELO mga07.intel.com) (134.134.136.100) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 13 Jan 2020 19:36:03 +0000 Received: from orsmga008.jf.intel.com ([10.7.209.65]) by orsmga105.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 13 Jan 2020 11:36:00 -0800 Received: from orsmsx110.amr.corp.intel.com ([10.22.240.8]) by orsmga008.jf.intel.com with ESMTP; 13 Jan 2020 11:36:00 -0800 Received: from orsmsx604.amr.corp.intel.com (10.22.229.17) by ORSMSX110.amr.corp.intel.com (10.22.240.8) with Microsoft SMTP Server (TLS) id 14.3.439.0; Mon, 13 Jan 2020 11:35:59 -0800 Received: from orsmsx604.amr.corp.intel.com (10.22.229.17) by ORSMSX604.amr.corp.intel.com (10.22.229.17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.1713.5; Mon, 13 Jan 2020 11:35:59 -0800 Received: from ORSEDG001.ED.cps.intel.com (10.7.248.4) by orsmsx604.amr.corp.intel.com (10.22.229.17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256) id 15.1.1713.5 via Frontend Transport; Mon, 13 Jan 2020 11:35:59 -0800 Received: from NAM11-CO1-obe.outbound.protection.outlook.com (104.47.56.177) by edgegateway.intel.com (134.134.137.100) with Microsoft SMTP Server (TLS) id 14.3.439.0; Mon, 13 Jan 2020 11:35:59 -0800 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=R4a4SXsrjP/yMzelZ9ZMwN2kI54h6RJfJa5DK05o9fqJCWJqilIqExOJeQ5TZ1pyqs0pt+zvSojwMNZosh6DLxUrR3RJj7Fks8jmKDbXeMdGLpI/RcHWwNUnRyhshjWKMEIm5JZyV32wR2v1zVZxPMfUvyNUsJSKDPcgzjaiU9LeswLIqB+4aRRAERd1bku2pKsWJwy0yANUDZrwi9IRpX98ebXPik6q0Tlw+XB2Zqp5OebK1S/FvYK36Ner7XMGpJxKAiImjOUXE/ljTdtPgsfqoDC2Q1tuj4jyXSELW3VDwl1RQ0b28pMPgkMahZlk8nkRAMpDkxmu8o5iZ/WxBw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=U6ZJeJKeO9QMWlbj13zysSTAL6vOXrlJWjPhRvODXYQ=; b=lSELyYWCiTTbKxYq4c22wY3dhGPWCErtb3MOAC7beNd8s2O6cGDAJPueSIec2dLxZorcIOs0vQkmffpYFrpM1BFTWCtCUVWmbkd49IoBz/VUQdOTEhXQd5ef12Gpx7xBwAp7A3+2nRXVZm3eAGE3y9kkcCzb35JeKbRWek2NiE2Bzmo5LFR3KSZ65aVgRJ9b23Z7BxA71a/Vu6BNkcvHmerm1BSZBPuOzAEn/xyy7yREdx/k5Vd11UfCqMviCLA31IevY8Y2abfzdqGPF4Sk0wSBjTToIxxWx7z+ThN3fbvtPpZnjf6UucIHWMN03WL1MLbtVCAgGE2hQqXW/ZnKLA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=intel.com; dmarc=pass action=none header.from=intel.com; dkim=pass header.d=intel.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=intel.onmicrosoft.com; s=selector2-intel-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=U6ZJeJKeO9QMWlbj13zysSTAL6vOXrlJWjPhRvODXYQ=; b=cuWaOXOL7F3+ur+6LBvlyMuaPte+huHkUNTUe/0ywcJIWaEK8d3VWQHSsMTF/nnnZlpDJx1bS/t/nq3bdud3CEd8byn9KvMaAEkVkH2miD6Mw8xoXvh3wPtBJNdc/s3qgbywuKEV+piJTSwKaj/pPVdyHLKCqTrYdJYqAbSrX6I= Received: from BYAPR11MB3030.namprd11.prod.outlook.com (20.177.225.91) by BYAPR11MB3029.namprd11.prod.outlook.com (20.177.227.26) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2623.15; Mon, 13 Jan 2020 19:35:58 +0000 Received: from BYAPR11MB3030.namprd11.prod.outlook.com ([fe80::2c94:a4bd:2d9c:30b]) by BYAPR11MB3030.namprd11.prod.outlook.com ([fe80::2c94:a4bd:2d9c:30b%6]) with mapi id 15.20.2623.015; Mon, 13 Jan 2020 19:35:58 +0000 From: "Aktemur, Tankut Baris" To: Luis Machado , "tromey@sourceware.org" , "gdb-patches@sourceware.org" , "Tankut Baris Aktemur (Code Review)" Subject: RE: [review v3] testsuite, cp: increase the coverage of testing pass-by-ref arguments Date: Mon, 13 Jan 2020 19:38:00 -0000 Message-ID: References: <20191214095325.3864520AF6@gnutoolchain-gerrit.osci.io> <80c8502f-a350-6a2b-0b72-bbc903f53bc3@linaro.org> In-Reply-To: <80c8502f-a350-6a2b-0b72-bbc903f53bc3@linaro.org> authentication-results: spf=none (sender IP is ) smtp.mailfrom=tankut.baris.aktemur@intel.com; x-ms-oob-tlc-oobclassifiers: OLM:9508; x-ms-exchange-senderadcheck: 1 x-ms-exchange-transport-forked: True Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: CGcbmSAIGVk6a7P1qHRMi/ixN9flhwiKAz3RThbncusVYXYdDaAG0bQSLcco13wHTPGBKhfvfTWhg74/RJWhnO1LNUUAvFunvBWqK0nPdA0= Return-Path: tankut.baris.aktemur@intel.com Content-Transfer-Encoding: base64 X-IsSubscribed: yes X-SW-Source: 2020-01/txt/msg00348.txt.bz2 T24gTW9uZGF5LCBKYW51YXJ5IDEzLCAyMDIwIDc6MjEgUE0sIEx1aXMgTWFj aGFkbyB3cm90ZToNCj4gDQo+IEhpLA0KPiANCj4gSSBub3RpY2VkIHRoZXNl IG5ldyB0ZXN0cyBmYWlsIChpbiBsYXJnZSBudW1iZXJzKSBmb3IgR0NDIDUu NC54LiBJcyBpdA0KPiBleHBlY3RlZD8gSWYgc28sIGl0IG1heSBiZSB3b3J0 aCBtYWtpbmcgdGhpcyB0ZXN0IGNvbmRpdGlvbmFsIG9uIG5ld2VyDQo+IEdD QyB2ZXJzaW9ucy4NCj4gDQoNClllcywgdGhpcyBpcyBleHBlY3RlZC4gT2xk ZXIgR0NDIHZlcnNpb25zIGRpZCBub3QgZW1pdCBjZXJ0YWluIERXQVJGIGF0 dHJpYnV0ZXMNCihEV19BVF9kZWxldGVkLCBEV19BVF9kZWZhdWx0ZWQpLiAg VGhpcyBwcmV2ZW50cyBHREIgZnJvbSBtYWtpbmcgdGhlIHJpZ2h0DQpwYXNz LWJ5LXJlZmVyZW5jZSBkZWNpc2lvbi4gIEknbGwgc3VibWl0IGEgcGF0Y2gg Zm9yIHRoaXMuDQoNClRoYW5rcyBmb3IgdGhlIHN1Z2dlc3Rpb24uDQoNCi1C YXJpcw0KDQo+IE9uIDEyLzE0LzE5IDY6NTMgQU0sIFRhbmt1dCBCYXJpcyBB a3RlbXVyIChDb2RlIFJldmlldykgd3JvdGU6DQo+ID4gQ2hhbmdlIFVSTDog aHR0cHM6Ly9nbnV0b29sY2hhaW4tZ2Vycml0Lm9zY2kuaW8vci9jL2JpbnV0 aWxzLWdkYi8rLzE0Mg0KPiA+IC4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4u Li4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4N Cj4gPg0KPiA+IHRlc3RzdWl0ZSwgY3A6IGluY3JlYXNlIHRoZSBjb3ZlcmFn ZSBvZiB0ZXN0aW5nIHBhc3MtYnktcmVmIGFyZ3VtZW50cw0KPiA+DQo+ID4g RXh0ZW5kIHRlc3RjYXNlcyBmb3IgR0RCJ3MgaW5mY2FsbCBvZiBjYWxsLWJ5 LXZhbHVlIGZ1bmN0aW9ucyB0aGF0DQo+ID4gdGFrZSBhZ2dyZWdhdGUgdmFs dWVzIGFzIHBhcmFtZXRlcnMuICBJbiBwYXJ0aWN1bGFyLCBleGlzdGluZyB0 ZXN0IGhhcw0KPiA+IGJlZW4gc3Vic3RhbnRpYWxseSBleHRlbmRlZCB3aXRo IGNsYXNzIGRlZmluaXRpb25zIHdob3NlIGRlZmluaXRpb25zDQo+ID4gb2Yg Y29weSBjb25zdHJ1Y3RvciwgZGVzdHJ1Y3RvciwgYW5kIG1vdmUgY29uc3Ry dWN0b3IgZnVuY3Rpb25zIGFyZSBhDQo+ID4gY29tYmluYXRpb24gb2YNCj4g Pg0KPiA+ICgxKSBleHBsaWNpdGx5IGRlZmluZWQgYnkgdGhlIHVzZXIsDQo+ ID4gKDIpIGRlZmF1bHRlZCBpbnNpZGUgdGhlIGNsYXNzIGRlY2xhcmF0aW9u LA0KPiA+ICgzKSBkZWZhdWx0ZWQgb3V0c2lkZSB0aGUgY2xhc3MgZGVjbGFy YXRpb24sDQo+ID4gKDQpIGRlbGV0ZWQNCj4gPiAoNSkgbm90IGRlZmluZWQg aW4gdGhlIHNvdXJjZS4NCj4gPg0KPiA+IEZvciBlYWNoIGNvbWJpbmF0aW9u LCBhIHNtYWxsIGFuZCBhIGxhcmdlIGNsYXNzIGlzIGdlbmVyYXRlZCBhcyB3 ZWxsDQo+ID4gYXMgYSBkZXJpdmVkIGNsYXNzIGFuZCBhIGNvbnRhaW5lciBj bGFzcy4gIEFkZGl0aW9uYWxseSwgdGhlIGZvbGxvd2luZw0KPiA+IG1hbnVh bGx5LXdyaXR0ZW4gY2FzZXMgYXJlIHByb3ZpZGVkOg0KPiA+DQo+ID4gLSBh IGR5bmFtaWMgY2xhc3MgKGkuZS4gY2xhc3Mgd2l0aCBhIHZpcnR1YWwgbWV0 aG9kKQ0KPiA+IC0gY2xhc3NlcyB0aGF0IGNvbnRhaW4gYW4gYXJyYXkgZmll bGQNCj4gPiAtIGEgY2xhc3Mgd2hvc2UgY29weSBjdG9yIGlzIGlubGluZWQN Cj4gPiAtIGEgY2xhc3Mgd2hvc2UgZGVzdHJ1Y3RvciBpcyBkZWxldGVkDQo+ ID4gLSBjbGFzc2VzIHdpdGggbXVsdGlwbGUgY29weSBhbmQvb3IgbW92ZSBj dG9ycw0KPiA+DQo+ID4gVGVzdCBjYXNlcyBjaGVjayB3aGV0aGVyIEdEQiBt YWtlcyB0aGUgcmlnaHQgZGVjaXNpb24gdG8gcGFzcyBhbg0KPiA+IG9iamVj dCBieSB2YWx1ZSBvciBpbXBsaWNpdGx5IGJ5IHJlZmVyZW5jZSwgd2hldGhl ciByZWFsbHkgYSBjb3B5IG9mDQo+ID4gdGhlIGFyZ3VtZW50IGlzIHBhc3Nl ZCwgYW5kIHdoZXRoZXIgdGhlIGNvcHkgY29uc3RydWN0b3IgYW5kDQo+ID4g ZGVzdHJ1Y3RvciBvZiB0aGUgY2xvbmUgb2YgdGhlIGFyZ3VtZW50IGFyZSBp bnZva2VkIHByb3Blcmx5Lg0KPiA+DQo+ID4gVGhlIGlucHV0IHByb2dyYW0g cGFzcy1ieS1yZWYuY2MgaXMgZ2VuZXJhdGVkIGluIHRoZSB0ZXN0J3Mgb3V0 cHV0DQo+ID4gZGlyZWN0b3J5LiAgVGhlIGlucHV0IHByb2dyYW0gcGFzcy1i eS1yZWYtMi5jYyBpcyBtYW51YWxseS13cml0dGVuLg0KPiA+DQo+ID4gVGVz dHMgaGF2ZSBiZWVuIHZlcmlmaWVkIG9uIHRoZSBYODZfNjQgYXJjaGl0ZWN0 dXJlIHdpdGgNCj4gPiBHQ0MgNy40LjAsIDguMi4wLCBhbmQgOS4yLjEuDQo+ ID4NCj4gPiBnZGIvdGVzdHN1aXRlL0NoYW5nZUxvZzoNCj4gPiAyMDE5LTEx LTA3ICBUYW5rdXQgQmFyaXMgQWt0ZW11ciAgPHRhbmt1dC5iYXJpcy5ha3Rl bXVyQGludGVsLmNvbT4NCj4gPg0KPiA+IAkqIGdkYi5jcC9wYXNzLWJ5LXJl Zi5jYzogRGVsZXRlLiAgR2VuZXJhdGVkIGluIHRoZSBvdXRwdXQNCj4gPiAJ ZGlyZWN0b3J5IGluc3RlYWQuDQo+ID4gCSogZ2RiLmNwL3Bhc3MtYnktcmVm LmV4cDogRXh0ZW5kIHdpdGggbW9yZSBjYXNlcy4NCj4gPiAJKiBnZGIuY3Av cGFzcy1ieS1yZWYtMi5jYzogTmV3IGZpbGUuDQo+ID4gCSogZ2RiLmNwL3Bh c3MtYnktcmVmLTIuZXhwOiBOZXcgZmlsZS4NCj4gPg0KPiA+IENoYW5nZS1J ZDogSWU4YWIxZjI2MGM2YWQ1ZWU0ZWIzNGIyYzE1OTdjZTI0YWYwNGFiYjYN Cj4gPiAtLS0NCj4gPiBBIGdkYi90ZXN0c3VpdGUvZ2RiLmNwL3Bhc3MtYnkt cmVmLTIuY2MNCj4gPiBBIGdkYi90ZXN0c3VpdGUvZ2RiLmNwL3Bhc3MtYnkt cmVmLTIuZXhwDQo+ID4gRCBnZGIvdGVzdHN1aXRlL2dkYi5jcC9wYXNzLWJ5 LXJlZi5jYw0KPiA+IE0gZ2RiL3Rlc3RzdWl0ZS9nZGIuY3AvcGFzcy1ieS1y ZWYuZXhwDQo+ID4gNCBmaWxlcyBjaGFuZ2VkLCA3OTEgaW5zZXJ0aW9ucygr KSwgODYgZGVsZXRpb25zKC0pDQo+ID4NCj4gPg0KPiA+DQo+ID4gZGlmZiAt LWdpdCBhL2dkYi90ZXN0c3VpdGUvZ2RiLmNwL3Bhc3MtYnktcmVmLTIuY2Mg Yi9nZGIvdGVzdHN1aXRlL2dkYi5jcC9wYXNzLWJ5LXJlZi0yLmNjDQo+ID4g bmV3IGZpbGUgbW9kZSAxMDA2NDQNCj4gPiBpbmRleCAwMDAwMDAwLi4xY2Q1 YTE2DQo+ID4gLS0tIC9kZXYvbnVsbA0KPiA+ICsrKyBiL2dkYi90ZXN0c3Vp dGUvZ2RiLmNwL3Bhc3MtYnktcmVmLTIuY2MNCj4gPiBAQCAtMCwwICsxLDI5 NSBAQA0KPiA+ICsvKiBUaGlzIHRlc3RjYXNlIGlzIHBhcnQgb2YgR0RCLCB0 aGUgR05VIGRlYnVnZ2VyLg0KPiA+ICsNCj4gPiArICAgQ29weXJpZ2h0IDIw MTkgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuDQo+ID4gKw0KPiA+ ICsgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQ0KPiA+ICsgICBpdCB1bmRl ciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl IGFzIHB1Ymxpc2hlZCBieQ0KPiA+ICsgICB0aGUgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBv cg0KPiA+ICsgICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9u Lg0KPiA+ICsNCj4gPiArICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVk IGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsDQo+ID4gKyAg IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mDQo+ID4gKyAgIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUN Cj4gPiArICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4NCj4gPiArDQo+ID4gKyAgIFlvdSBzaG91bGQgaGF2ZSByZWNl aXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl DQo+ID4gKyAgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBz ZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LiAgKi8NCj4gPiAr DQo+ID4gK2NsYXNzIEJ5VmFsIHsNCj4gPiArcHVibGljOg0KPiA+ICsgIEJ5 VmFsICh2b2lkKTsNCj4gPiArDQo+ID4gKyAgaW50IHg7DQo+ID4gK307DQo+ ID4gKw0KPiA+ICtCeVZhbDo6QnlWYWwgKHZvaWQpDQo+ID4gK3sNCj4gPiAr ICB4ID0gMjsNCj4gPiArfQ0KPiA+ICsNCj4gPiArY2xhc3MgQnlSZWYgew0K PiA+ICtwdWJsaWM6DQo+ID4gKyAgQnlSZWYgKHZvaWQpOw0KPiA+ICsNCj4g PiArICBCeVJlZiAoY29uc3QgQnlSZWYgJnJocyk7DQo+ID4gKw0KPiA+ICsg IGludCB4Ow0KPiA+ICt9Ow0KPiA+ICsNCj4gPiArQnlSZWY6OkJ5UmVmICh2 b2lkKQ0KPiA+ICt7DQo+ID4gKyAgeCA9IDI7DQo+ID4gK30NCj4gPiArDQo+ ID4gK0J5UmVmOjpCeVJlZiAoY29uc3QgQnlSZWYgJnJocykNCj4gPiArew0K PiA+ICsgIHggPSAzOyAvKiBCeVJlZi1jY3RvciAqLw0KPiA+ICt9DQo+ID4g Kw0KPiA+ICtjbGFzcyBBcnJheUNvbnRhaW5lckJ5VmFsIHsNCj4gPiArcHVi bGljOg0KPiA+ICsgIEJ5VmFsIGl0ZW1zWzJdOw0KPiA+ICt9Ow0KPiA+ICsN Cj4gPiAraW50DQo+ID4gK2NidkFycmF5Q29udGFpbmVyQnlWYWwgKEFycmF5 Q29udGFpbmVyQnlWYWwgYXJnKQ0KPiA+ICt7DQo+ID4gKyAgYXJnLml0ZW1z WzBdLnggKz0gNDsgIC8vIGludGVudGlvbmFsbHkgbW9kaWZ5DQo+ID4gKyAg cmV0dXJuIGFyZy5pdGVtc1swXS54Ow0KPiA+ICt9DQo+ID4gKw0KPiA+ICtj bGFzcyBBcnJheUNvbnRhaW5lckJ5UmVmIHsNCj4gPiArcHVibGljOg0KPiA+ ICsgIEJ5UmVmIGl0ZW1zWzJdOw0KPiA+ICt9Ow0KPiA+ICsNCj4gPiAraW50 DQo+ID4gK2NidkFycmF5Q29udGFpbmVyQnlSZWYgKEFycmF5Q29udGFpbmVy QnlSZWYgYXJnKQ0KPiA+ICt7DQo+ID4gKyAgYXJnLml0ZW1zWzBdLnggKz0g NDsgIC8vIGludGVudGlvbmFsbHkgbW9kaWZ5DQo+ID4gKyAgcmV0dXJuIGFy Zy5pdGVtc1swXS54Ow0KPiA+ICt9DQo+ID4gKw0KPiA+ICtjbGFzcyBEeW5h bWljQmFzZSB7DQo+ID4gK3B1YmxpYzoNCj4gPiArICBEeW5hbWljQmFzZSAo dm9pZCk7DQo+ID4gKw0KPiA+ICsgIHZpcnR1YWwgaW50IGdldCAodm9pZCk7 DQo+ID4gKw0KPiA+ICsgIGludCB4Ow0KPiA+ICt9Ow0KPiA+ICsNCj4gPiAr RHluYW1pY0Jhc2U6OkR5bmFtaWNCYXNlICh2b2lkKQ0KPiA+ICt7DQo+ID4g KyAgeCA9IDI7DQo+ID4gK30NCj4gPiArDQo+ID4gK2ludA0KPiA+ICtEeW5h bWljQmFzZTo6Z2V0ICh2b2lkKQ0KPiA+ICt7DQo+ID4gKyAgcmV0dXJuIDQy Ow0KPiA+ICt9DQo+ID4gKw0KPiA+ICtjbGFzcyBEeW5hbWljIDogcHVibGlj IER5bmFtaWNCYXNlIHsNCj4gPiArcHVibGljOg0KPiA+ICsgIHZpcnR1YWwg aW50IGdldCAodm9pZCk7DQo+ID4gK307DQo+ID4gKw0KPiA+ICtpbnQNCj4g PiArRHluYW1pYzo6Z2V0ICh2b2lkKQ0KPiA+ICt7DQo+ID4gKyAgcmV0dXJu IDk5OTk7DQo+ID4gK30NCj4gPiArDQo+ID4gK2ludA0KPiA+ICtjYnZEeW5h bWljIChEeW5hbWljQmFzZSBhcmcpDQo+ID4gK3sNCj4gPiArICBhcmcueCAr PSA0OyAgLy8gaW50ZW50aW9uYWxseSBtb2RpZnkNCj4gPiArICByZXR1cm4g YXJnLnggKyBhcmcuZ2V0ICgpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtjbGFz cyBJbmxpbmVkIHsNCj4gPiArcHVibGljOg0KPiA+ICsgIElubGluZWQgKHZv aWQpOw0KPiA+ICsNCj4gPiArICBfX2F0dHJpYnV0ZV9fKChhbHdheXNfaW5s aW5lKSkNCj4gPiArICBJbmxpbmVkIChjb25zdCBJbmxpbmVkICZyaHMpDQo+ ID4gKyAgew0KPiA+ICsgICAgeCA9IDM7DQo+ID4gKyAgfQ0KPiA+ICsNCj4g PiArICBpbnQgeDsNCj4gPiArfTsNCj4gPiArDQo+ID4gK0lubGluZWQ6Oklu bGluZWQgKHZvaWQpDQo+ID4gK3sNCj4gPiArICB4ID0gMjsNCj4gPiArfQ0K PiA+ICsNCj4gPiAraW50DQo+ID4gK2NidklubGluZWQgKElubGluZWQgYXJn KQ0KPiA+ICt7DQo+ID4gKyAgYXJnLnggKz0gNDsgIC8vIGludGVudGlvbmFs bHkgbW9kaWZ5DQo+ID4gKyAgcmV0dXJuIGFyZy54Ow0KPiA+ICt9DQo+ID4g Kw0KPiA+ICtjbGFzcyBEdG9yRGVsIHsNCj4gPiArcHVibGljOg0KPiA+ICsg IER0b3JEZWwgKHZvaWQpOw0KPiA+ICsNCj4gPiArICB+RHRvckRlbCAodm9p ZCkgPSBkZWxldGU7DQo+ID4gKw0KPiA+ICsgIGludCB4Ow0KPiA+ICt9Ow0K PiA+ICsNCj4gPiArRHRvckRlbDo6RHRvckRlbCAodm9pZCkNCj4gPiArew0K PiA+ICsgIHggPSAyOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtpbnQNCj4gPiAr Y2J2RHRvckRlbCAoRHRvckRlbCBhcmcpDQo+ID4gK3sNCj4gPiArICAvLyBD YWxsaW5nIHRoaXMgbWV0aG9kIHNob3VsZCBiZSByZWplY3RlZA0KPiA+ICsg IHJldHVybiBhcmcueDsNCj4gPiArfQ0KPiA+ICsNCj4gPiArY2xhc3MgRm91 ckNDdG9yIHsNCj4gPiArcHVibGljOg0KPiA+ICsgIEZvdXJDQ3RvciAodm9p ZCk7DQo+ID4gKw0KPiA+ICsgIEZvdXJDQ3RvciAoRm91ckNDdG9yICZyaHMp Ow0KPiA+ICsgIEZvdXJDQ3RvciAoY29uc3QgRm91ckNDdG9yICZyaHMpOw0K PiA+ICsgIEZvdXJDQ3RvciAodm9sYXRpbGUgRm91ckNDdG9yICZyaHMpOw0K PiA+ICsgIEZvdXJDQ3RvciAoY29uc3Qgdm9sYXRpbGUgRm91ckNDdG9yICZy aHMpOw0KPiA+ICsNCj4gPiArICBpbnQgeDsNCj4gPiArfTsNCj4gPiArDQo+ ID4gK0ZvdXJDQ3Rvcjo6Rm91ckNDdG9yICh2b2lkKQ0KPiA+ICt7DQo+ID4g KyAgeCA9IDI7DQo+ID4gK30NCj4gPiArDQo+ID4gK0ZvdXJDQ3Rvcjo6Rm91 ckNDdG9yIChGb3VyQ0N0b3IgJnJocykNCj4gPiArew0KPiA+ICsgIHggPSAz Ow0KPiA+ICt9DQo+ID4gKw0KPiA+ICtGb3VyQ0N0b3I6OkZvdXJDQ3RvciAo Y29uc3QgRm91ckNDdG9yICZyaHMpDQo+ID4gK3sNCj4gPiArICB4ID0gNDsN Cj4gPiArfQ0KPiA+ICsNCj4gPiArRm91ckNDdG9yOjpGb3VyQ0N0b3IgKHZv bGF0aWxlIEZvdXJDQ3RvciAmcmhzKQ0KPiA+ICt7DQo+ID4gKyAgeCA9IDU7 DQo+ID4gK30NCj4gPiArDQo+ID4gK0ZvdXJDQ3Rvcjo6Rm91ckNDdG9yIChj b25zdCB2b2xhdGlsZSBGb3VyQ0N0b3IgJnJocykNCj4gPiArew0KPiA+ICsg IHggPSA2Ow0KPiA+ICt9DQo+ID4gKw0KPiA+ICtpbnQNCj4gPiArY2J2Rm91 ckNDdG9yIChGb3VyQ0N0b3IgYXJnKQ0KPiA+ICt7DQo+ID4gKyAgYXJnLngg Kz0gMTA7ICAvLyBpbnRlbnRpb25hbGx5IG1vZGlmeQ0KPiA+ICsgIHJldHVy biBhcmcueDsNCj4gPiArfQ0KPiA+ICsNCj4gPiArY2xhc3MgVHdvTUN0b3Ig ew0KPiA+ICtwdWJsaWM6DQo+ID4gKyAgVHdvTUN0b3IgKHZvaWQpOw0KPiA+ ICsNCj4gPiArICAvKiBFdmVuIHRob3VnaCBvbmUgbW92ZSBjdG9yIGlzIGRl ZmF1bHRlZCwgdGhlIG90aGVyDQo+ID4gKyAgICAgaXMgZXhwbGljaXQuICAq Lw0KPiA+ICsgIFR3b01DdG9yIChjb25zdCBUd29NQ3RvciAmJnJocyk7DQo+ ID4gKyAgVHdvTUN0b3IgKFR3b01DdG9yICYmcmhzKSA9IGRlZmF1bHQ7DQo+ ID4gKw0KPiA+ICsgIGludCB4Ow0KPiA+ICt9Ow0KPiA+ICsNCj4gPiArVHdv TUN0b3I6OlR3b01DdG9yICh2b2lkKQ0KPiA+ICt7DQo+ID4gKyAgeCA9IDI7 DQo+ID4gK30NCj4gPiArDQo+ID4gK1R3b01DdG9yOjpUd29NQ3RvciAoY29u c3QgVHdvTUN0b3IgJiZyaHMpDQo+ID4gK3sNCj4gPiArICB4ID0gMzsNCj4g PiArfQ0KPiA+ICsNCj4gPiAraW50DQo+ID4gK2NidlR3b01DdG9yIChUd29N Q3RvciBhcmcpDQo+ID4gK3sNCj4gPiArICBhcmcueCArPSAxMDsgIC8vIGlu dGVudGlvbmFsbHkgbW9kaWZ5DQo+ID4gKyAgcmV0dXJuIGFyZy54Ow0KPiA+ ICt9DQo+ID4gKw0KPiA+ICtjbGFzcyBUd29NQ3RvckFuZENDdG9yIHsNCj4g PiArcHVibGljOg0KPiA+ICsgIFR3b01DdG9yQW5kQ0N0b3IgKHZvaWQpOw0K PiA+ICsNCj4gPiArICBUd29NQ3RvckFuZENDdG9yIChjb25zdCBUd29NQ3Rv ckFuZENDdG9yICZyaHMpID0gZGVmYXVsdDsNCj4gPiArDQo+ID4gKyAgLyog RXZlbiB0aG91Z2ggb25lIG1vdmUgY3RvciBpcyBkZWZhdWx0ZWQsIHRoZSBv dGhlcg0KPiA+ICsgICAgIGlzIGV4cGxpY2l0LiAgVGhpcyBtYWtlcyB0aGUg dHlwZSBwYXNzLWJ5LXJlZi4gICovDQo+ID4gKyAgVHdvTUN0b3JBbmRDQ3Rv ciAoY29uc3QgVHdvTUN0b3JBbmRDQ3RvciAmJnJocyk7DQo+ID4gKyAgVHdv TUN0b3JBbmRDQ3RvciAoVHdvTUN0b3JBbmRDQ3RvciAmJnJocykgPSBkZWZh dWx0Ow0KPiA+ICsNCj4gPiArICBpbnQgeDsNCj4gPiArfTsNCj4gPiArDQo+ ID4gK1R3b01DdG9yQW5kQ0N0b3I6OlR3b01DdG9yQW5kQ0N0b3IgKHZvaWQp DQo+ID4gK3sNCj4gPiArICB4ID0gMjsNCj4gPiArfQ0KPiA+ICsNCj4gPiAr VHdvTUN0b3JBbmRDQ3Rvcjo6VHdvTUN0b3JBbmRDQ3RvciAoY29uc3QgVHdv TUN0b3JBbmRDQ3RvciAmJnJocykNCj4gPiArew0KPiA+ICsgIHggPSA0Ow0K PiA+ICt9DQo+ID4gKw0KPiA+ICtpbnQNCj4gPiArY2J2VHdvTUN0b3JBbmRD Q3RvciAoVHdvTUN0b3JBbmRDQ3RvciBhcmcpDQo+ID4gK3sNCj4gPiArICBh cmcueCArPSAxMDsgIC8vIGludGVudGlvbmFsbHkgbW9kaWZ5DQo+ID4gKyAg cmV0dXJuIGFyZy54Ow0KPiA+ICt9DQo+ID4gKw0KPiA+ICtBcnJheUNvbnRh aW5lckJ5VmFsIGFycmF5Q29udGFpbmVyQnlWYWw7DQo+ID4gK0FycmF5Q29u dGFpbmVyQnlSZWYgYXJyYXlDb250YWluZXJCeVJlZjsNCj4gPiArRHluYW1p YyBkeW5hbWljOw0KPiA+ICtJbmxpbmVkIGlubGluZWQ7DQo+ID4gKy8vIENh bm5vdCBzdGFjay1hbGxvY2F0ZSBEdG9yRGVsDQo+ID4gK0R0b3JEZWwgKmR0 b3JEZWw7DQo+ID4gK0ZvdXJDQ3RvciBmb3VyQ2N0b3JfYzB2MDsNCj4gPiAr Y29uc3QgRm91ckNDdG9yIGZvdXJDY3Rvcl9jMXYwOw0KPiA+ICt2b2xhdGls ZSBGb3VyQ0N0b3IgZm91ckNjdG9yX2MwdjE7DQo+ID4gK2NvbnN0IHZvbGF0 aWxlIEZvdXJDQ3RvciBmb3VyQ2N0b3JfYzF2MTsNCj4gPiArVHdvTUN0b3Ig dHdvTWN0b3I7DQo+ID4gK1R3b01DdG9yQW5kQ0N0b3IgdHdvTWN0b3JBbmRD Y3RvcjsNCj4gPiArDQo+ID4gK2ludA0KPiA+ICttYWluICh2b2lkKQ0KPiA+ ICt7DQo+ID4gKyAgaW50IHY7DQo+ID4gKyAgZHRvckRlbCA9IG5ldyBEdG9y RGVsOw0KPiA+ICsgIC8qIEV4cGxpY2l0bHkgY2FsbCB0aGUgY2J2IGZ1bmN0 aW9uIHRvIG1ha2Ugc3VyZSB0aGUgY29tcGlsZXINCj4gPiArICAgICB3aWxs IG5vdCBvbWl0IGFueSBjb2RlIGluIHRoZSBiaW5hcnkuICAqLw0KPiA+ICsg IHYgPSBjYnZBcnJheUNvbnRhaW5lckJ5VmFsIChhcnJheUNvbnRhaW5lckJ5 VmFsKTsNCj4gPiArICB2ID0gY2J2QXJyYXlDb250YWluZXJCeVJlZiAoYXJy YXlDb250YWluZXJCeVJlZik7DQo+ID4gKyAgdiA9IGNidkR5bmFtaWMgKGR5 bmFtaWMpOw0KPiA+ICsgIHYgPSBjYnZJbmxpbmVkIChpbmxpbmVkKTsNCj4g PiArICB2ID0gY2J2Rm91ckNDdG9yIChmb3VyQ2N0b3JfYzB2MCk7DQo+ID4g KyAgdiA9IGNidkZvdXJDQ3RvciAoZm91ckNjdG9yX2MxdjApOw0KPiA+ICsg IHYgPSBjYnZGb3VyQ0N0b3IgKGZvdXJDY3Rvcl9jMHYxKTsNCj4gPiArICB2 ID0gY2J2Rm91ckNDdG9yIChmb3VyQ2N0b3JfYzF2MSk7DQo+ID4gKyAgLyog diA9IGNidlR3b01DdG9yICh0d29NY3Rvcik7ICovIC8vIFRoaXMgaXMgaWxs ZWdhbCwgY2N0b3IgaXMgZGVsZXRlZA0KPiA+ICsgIHYgPSBjYnZUd29NQ3Rv ckFuZENDdG9yICh0d29NY3RvckFuZENjdG9yKTsNCj4gPiArDQo+ID4gKyAg Lyogc3RvcCBoZXJlICovDQo+ID4gKw0KPiA+ICsgIHJldHVybiAwOw0KPiA+ ICt9DQo+ID4gZGlmZiAtLWdpdCBhL2dkYi90ZXN0c3VpdGUvZ2RiLmNwL3Bh c3MtYnktcmVmLTIuZXhwIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuY3AvcGFzcy1i eS1yZWYtMi5leHANCj4gPiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiA+IGlu ZGV4IDAwMDAwMDAuLjdjY2U4ODYNCj4gPiAtLS0gL2Rldi9udWxsDQo+ID4g KysrIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuY3AvcGFzcy1ieS1yZWYtMi5leHAN Cj4gPiBAQCAtMCwwICsxLDExNCBAQA0KPiA+ICsjIENvcHlyaWdodCAyMDE5 IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLg0KPiA+ICsNCj4gPiAr IyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRp c3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQ0KPiA+ICsjIGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5DQo+ID4gKyMgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3INCj4g PiArIyAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLg0KPiA+ ICsjDQo+ID4gKyMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRo ZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsDQo+ID4gKyMgYnV0IFdJ VEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YNCj4gPiArIyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlDQo+ID4gKyMg R05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4N Cj4gPiArIw0KPiA+ICsjIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlDQo+ID4gKyMg YWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNlZSA8aHR0cDov L3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uDQo+ID4gKw0KPiA+ICsjIENoZWNr IHRoYXQgR0RCIGNhbiBjYWxsIEMrKyBmdW5jdGlvbnMgd2hvc2UgcGFyYW1l dGVycyBoYXZlDQo+ID4gKyMgb2JqZWN0IHR5cGUsIGFuZCBhcmUgZWl0aGVy IHBhc3NlZCBieSB2YWx1ZSBvciBpbXBsaWNpdGx5IGJ5IHJlZmVyZW5jZS4N Cj4gPiArIw0KPiA+ICsjIFRoaXMgaXMgYSBjb21wYW5pb24gdGVzdCB0byBw YXNzLWJ5LXJlZi5leHAuICBJbiB0aGlzIHRlc3QsIHRoZSBpbnB1dA0KPiA+ ICsjIGlzIG1hbnVhbGx5LXdyaXR0ZW4uICBJbiBwYXNzLWJ5LXJlZi5leHAs IHRoZSB0ZXN0IGlucHV0IGlzIGdlbmVyYXRlZC4NCj4gPiArIw0KPiA+ICsj IFdlIGluY2x1ZGUgdGVzdHMgZm9yIGNsYXNzZXMgdGhhdA0KPiA+ICsjIC0g Y29udGFpbiBhcnJheXMgYXMgZmllbGRzLA0KPiA+ICsjIC0gYXJlIGR5bmFt aWMgKGkuZS4gaGF2ZSB2aXJ0dWFsIG1ldGhvZHMpDQo+ID4gKyMgLSBoYXZl IGlubGluZWQgY29weSBjdG9yDQo+ID4gKyMgLSBoYXZlIGRlbGV0ZWQgZGVz dHJ1Y3Rvcg0KPiA+ICsNCj4gPiAraWYge1tza2lwX2NwbHVzX3Rlc3RzXX0g ew0KPiA+ICsgICAgdW50ZXN0ZWQgImMrKyB0ZXN0IHNraXBwZWQiDQo+ID4g KyAgICBjb250aW51ZQ0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGFuZGFyZF90 ZXN0ZmlsZSAuY2MNCj4gPiArDQo+ID4gK3NldCBvcHRpb25zIHtkZWJ1ZyBj KysgYWRkaXRpb25hbF9mbGFncz0tc3RkPWMrKzExfQ0KPiA+ICtpZiB7W3By ZXBhcmVfZm9yX3Rlc3RpbmcgImZhaWxlZCB0byBwcmVwYXJlIiAkdGVzdGZp bGUgJHNyY2ZpbGUgJG9wdGlvbnNdfSB7DQo+ID4gKyAgICByZXR1cm4gLTEN Cj4gPiArfQ0KPiA+ICsNCj4gPiAraWYgeyFbcnVudG9fbWFpbl19IHsNCj4g PiArICAgIHVudGVzdGVkICJmYWlsZWQgdG8gcnVuIHRvIG1haW4iDQo+ID4g KyAgICByZXR1cm4gLTENCj4gPiArfQ0KPiA+ICsNCj4gPiArc2V0IGJwX2xv Y2F0aW9uIFtnZGJfZ2V0X2xpbmVfbnVtYmVyICJzdG9wIGhlcmUiXQ0KPiA+ ICtnZGJfYnJlYWtwb2ludCAkYnBfbG9jYXRpb24NCj4gPiArZ2RiX2NvbnRp bnVlX3RvX2JyZWFrcG9pbnQgImVuZCBvZiBtYWluIiAiLipyZXR1cm4gLio7 Ig0KPiA+ICsNCj4gPiArZ2RiX3Rlc3QgInByaW50IGNidkFycmF5Q29udGFp bmVyQnlWYWwgKGFycmF5Q29udGFpbmVyQnlWYWwpIiAiNiIgXA0KPiA+ICsg ICAgImNhbGwgY2J2QXJyYXlDb250YWluZXJCeVZhbCINCj4gPiArZ2RiX3Rl c3QgInByaW50IGFycmF5Q29udGFpbmVyQnlWYWwuaXRlbXNcWzBcXS54IiAi MiIgXA0KPiA+ICsgICAgImNidiBhcmd1bWVudCAnYXJyYXlDb250YWluZXJC eVZhbCcgc2hvdWxkIG5vdCBjaGFuZ2UiDQo+ID4gKw0KPiA+ICtnZGJfdGVz dCAicHJpbnQgY2J2QXJyYXlDb250YWluZXJCeVJlZiAoYXJyYXlDb250YWlu ZXJCeVJlZikiICI3IiBcDQo+ID4gKyAgICAiY2FsbCBjYnZBcnJheUNvbnRh aW5lckJ5UmVmIg0KPiA+ICtnZGJfdGVzdCAicHJpbnQgYXJyYXlDb250YWlu ZXJCeVJlZi5pdGVtc1xbMFxdLngiICIyIiBcDQo+ID4gKyAgICAiY2J2IGFy Z3VtZW50ICdhcnJheUNvbnRhaW5lckJ5UmVmJyBzaG91bGQgbm90IGNoYW5n ZSINCj4gPiArDQo+ID4gK2dkYl90ZXN0ICJwcmludCBjYnZEeW5hbWljIChk eW5hbWljKSIgIjQ4IiBcDQo+ID4gKyAgICAiY2FsbCBjYnZEeW5hbWljIg0K PiA+ICtnZGJfdGVzdCAicHJpbnQgZHluYW1pYy54IiAiMiIgXA0KPiA+ICsg ICAgImNidiBhcmd1bWVudCAnZHluYW1pYycgc2hvdWxkIG5vdCBjaGFuZ2Ui DQo+ID4gKw0KPiA+ICtzZXQgc2lnICJcIklubGluZWRcOlw6SW5saW5lZFxc KC4qSW5saW5lZCBjb25zdFwmXFwpXCIiDQo+ID4gK2dkYl90ZXN0ICJwcmlu dCBjYnZJbmxpbmVkIChpbmxpbmVkKSIgXA0KPiA+ICsgICAgImV4cHJlc3Np b24gY2Fubm90IGJlIGV2YWx1YXRlZCAuKiBcXChtYXliZSBpbmxpbmVkXFw/ XFwpIg0KPiA+ICsNCj4gPiArZ2RiX3Rlc3QgInByaW50IGNidkR0b3JEZWwg KCpkdG9yRGVsKSIgXA0KPiA+ICsgICAgIi4qIGNhbm5vdCBiZSBldmFsdWF0 ZWQgLiogJ0R0b3JEZWwnIGlzIG5vdCBkZXN0cnVjdGlibGUiIFwNCj4gPiAr ICAgICJ0eXBlIG5vdCBkZXN0cnVjdGlibGUiDQo+ID4gKw0KPiA+ICsjIFRl c3QgdGhhdCBHREIgY2FsbHMgdGhlIGNvcnJlY3QgY29weSBjdG9yDQo+ID4g K2dkYl90ZXN0ICJwcmludCBjYnZGb3VyQ0N0b3IgKGZvdXJDY3Rvcl9jMHYw KSIgIjEzIiBcDQo+ID4gKyAgICAiY2FsbCBjYnZGb3VyQ0N0b3IgKGMwdjAp Ig0KPiA+ICtnZGJfdGVzdCAicHJpbnQgZm91ckNjdG9yX2MwdjAueCIgIjIi IFwNCj4gPiArICAgICJjYnYgYXJndW1lbnQgJ3R3b0NjdG9yX2MwdjAnIHNo b3VsZCBub3QgY2hhbmdlIg0KPiA+ICsNCj4gPiArZ2RiX3Rlc3QgInByaW50 IGNidkZvdXJDQ3RvciAoZm91ckNjdG9yX2MxdjApIiAiMTQiIFwNCj4gPiAr ICAgICJjYWxsIGNidkZvdXJDQ3RvciAoYzF2MCkiDQo+ID4gK2dkYl90ZXN0 ICJwcmludCBmb3VyQ2N0b3JfYzF2MC54IiAiMiIgXA0KPiA+ICsgICAgImNi diBhcmd1bWVudCAndHdvQ2N0b3JfYzF2MCcgc2hvdWxkIG5vdCBjaGFuZ2Ui DQo+ID4gKw0KPiA+ICtnZGJfdGVzdCAicHJpbnQgY2J2Rm91ckNDdG9yIChm b3VyQ2N0b3JfYzB2MSkiICIxNSIgXA0KPiA+ICsgICAgImNhbGwgY2J2Rm91 ckNDdG9yIChjMHYxKSINCj4gPiArZ2RiX3Rlc3QgInByaW50IGZvdXJDY3Rv cl9jMHYxLngiICIyIiBcDQo+ID4gKyAgICAiY2J2IGFyZ3VtZW50ICd0d29D Y3Rvcl9jMHYxJyBzaG91bGQgbm90IGNoYW5nZSINCj4gPiArDQo+ID4gK2dk Yl90ZXN0ICJwcmludCBjYnZGb3VyQ0N0b3IgKGZvdXJDY3Rvcl9jMXYxKSIg IjE2IiBcDQo+ID4gKyAgICAiY2FsbCBjYnZGb3VyQ0N0b3IgKGMxdjEpIg0K PiA+ICtnZGJfdGVzdCAicHJpbnQgZm91ckNjdG9yX2MxdjEueCIgIjIiIFwN Cj4gPiArICAgICJjYnYgYXJndW1lbnQgJ3R3b0NjdG9yX2MxdjEnIHNob3Vs ZCBub3QgY2hhbmdlIg0KPiA+ICsNCj4gPiArZ2RiX3Rlc3QgInByaW50IGNi dlR3b01DdG9yICh0d29NY3RvcikiIFwNCj4gPiArICAgICIuKiBjYW5ub3Qg YmUgZXZhbHVhdGVkIC4qICdUd29NQ3RvcicgaXMgbm90IGNvcHkgY29uc3Ry dWN0aWJsZSIgXA0KPiA+ICsgICAgImNvcHkgY3RvciBpcyBpbXBsaWNpdGx5 IGRlbGV0ZWQiDQo+ID4gKw0KPiA+ICtnZGJfdGVzdCAicHJpbnQgY2J2VHdv TUN0b3JBbmRDQ3RvciAodHdvTWN0b3JBbmRDY3RvcikiICIxMiIgXA0KPiA+ ICsgICAgImNhbGwgY2J2VHdvTUN0b3JBbmRDQ3RvciINCj4gPiArZ2RiX3Rl c3QgInByaW50IHR3b01jdG9yQW5kQ2N0b3IueCIgIjIiIFwNCj4gPiArICAg ICJjYnYgYXJndW1lbnQgJ3R3b01jdG9yQW5kQ3Rvcicgc2hvdWxkIG5vdCBj aGFuZ2UiDQo+ID4gKw0KPiA+ICsjIFRlc3QgdGhhdCB3ZSBnZXQgYSBicmVh a3BvaW50IGZyb20gdGhlIGNjdG9yIGR1cmluZyBpbmZjYWxsIGFuZA0KPiA+ ICsjIHdlIGNhbiBleGFtaW5lIGFyZ3VtZW50cy4gIFRoaXMgaXMgYSB0ZXN0 IHRoYXQgdGhlIGR1bW15IGZyYW1lDQo+ID4gKyMgb2YgdGhlIGNvcHkgY29u c3RydWN0b3IgaXMgc2V0IHVwIGNvcnJlY3RseSBieSB0aGUgaW5mY2FsbCBt ZWNoYW5pc20uDQo+ID4gK3NldCBicF9sb2NhdGlvbiBbZ2RiX2dldF9saW5l X251bWJlciAiQnlSZWYtY2N0b3IiXQ0KPiA+ICtnZGJfYnJlYWtwb2ludCAk YnBfbG9jYXRpb24NCj4gPiArZ2RiX3Rlc3QgInByaW50IGNidkFycmF5Q29u dGFpbmVyQnlSZWYgKGFycmF5Q29udGFpbmVyQnlSZWYpIiBcDQo+ID4gKyAg ICAiLipUaGUgcHJvZ3JhbSBiZWluZyBkZWJ1Z2dlZCBzdG9wcGVkLioiIFwN Cj4gPiArICAgICJjYWxsIGNidkFycmF5Q29udGFpbmVyQnlSZWYgd2l0aCBC UCINCj4gPiArZ2RiX3Rlc3QgImJhY2t0cmFjZSIgW211bHRpX2xpbmUgXA0K PiA+ICsgICAgIiMwICBCeVJlZlw6XDpCeVJlZiAuKiBhdCAuKiRzcmNmaWxl OiRicF9sb2NhdGlvbiIgXA0KPiA+ICsgICAgIiMxICAuKiBBcnJheUNvbnRh aW5lckJ5UmVmOjpBcnJheUNvbnRhaW5lckJ5UmVmIC4qIiBcDQo+ID4gKyAg ICAiIzIgIDxmdW5jdGlvbiBjYWxsZWQgZnJvbSBnZGI+IiBcDQo+ID4gKyAg ICAiIzMgIG1haW4uKiJdDQo+ID4gZGlmZiAtLWdpdCBhL2dkYi90ZXN0c3Vp dGUvZ2RiLmNwL3Bhc3MtYnktcmVmLmNjIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIu Y3AvcGFzcy1ieS1yZWYuY2MNCj4gPiBkZWxldGVkIGZpbGUgbW9kZSAxMDA2 NDQNCj4gPiBpbmRleCBiYmU0NTBhLi4wMDAwMDAwDQo+ID4gLS0tIGEvZ2Ri L3Rlc3RzdWl0ZS9nZGIuY3AvcGFzcy1ieS1yZWYuY2MNCj4gPiArKysgL2Rl di9udWxsDQo+ID4gQEAgLTEsNzkgKzAsMCBAQA0KPiA+IC0vKiBUaGlzIHRl c3RjYXNlIGlzIHBhcnQgb2YgR0RCLCB0aGUgR05VIGRlYnVnZ2VyLg0KPiA+ IC0NCj4gPiAtICAgQ29weXJpZ2h0IDIwMDctMjAxOSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIEluYy4NCj4gPiAtDQo+ID4gLSAgIFRoaXMgcHJvZ3Jh bSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBh bmQvb3IgbW9kaWZ5DQo+ID4gLSAgIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 DQo+ID4gLSAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhl ciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yDQo+ID4gLSAgIChhdCB5 b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uDQo+ID4gLQ0KPiA+IC0g ICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhh dCBpdCB3aWxsIGJlIHVzZWZ1bCwNCj4gPiAtICAgYnV0IFdJVEhPVVQgQU5Z IFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YNCj4gPiAtICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQ0KPiA+IC0gICBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLg0KPiA+IC0N Cj4gPiAtICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UNCj4gPiAtICAgYWxvbmcg d2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5n bnUub3JnL2xpY2Vuc2VzLz4uICAqLw0KPiA+IC0NCj4gPiAtY2xhc3MgT2Jq IHsNCj4gPiAtcHVibGljOg0KPiA+IC0gIE9iaiAoKTsNCj4gPiAtICBPYmog KGNvbnN0IE9iaiAmKTsNCj4gPiAtICB+T2JqICgpOw0KPiA+IC0gIGludCB2 YXJbMl07DQo+ID4gLX07DQo+ID4gLQ0KPiA+IC1pbnQgZm9vIChPYmogYXJn KQ0KPiA+IC17DQo+ID4gLSAgcmV0dXJuIGFyZy52YXJbMF0gKyBhcmcudmFy WzFdOw0KPiA+IC19DQo+ID4gLQ0KPiA+IC1PYmo6Ok9iaiAoKQ0KPiA+IC17 DQo+ID4gLSAgdmFyWzBdID0gMTsNCj4gPiAtICB2YXJbMV0gPSAyOw0KPiA+ IC19DQo+ID4gLQ0KPiA+IC1PYmo6Ok9iaiAoY29uc3QgT2JqICZvYmopDQo+ ID4gLXsNCj4gPiAtICB2YXJbMF0gPSBvYmoudmFyWzBdOw0KPiA+IC0gIHZh clsxXSA9IG9iai52YXJbMV07DQo+ID4gLX0NCj4gPiAtDQo+ID4gLU9iajo6 fk9iaiAoKQ0KPiA+IC17DQo+ID4gLQ0KPiA+IC19DQo+ID4gLQ0KPiA+IC1z dHJ1Y3QgRGVyaXZlZCA6IHB1YmxpYyBPYmoNCj4gPiAtew0KPiA+IC0gIGlu dCBvdGhlcjsNCj4gPiAtfTsNCj4gPiAtDQo+ID4gLWludCBibGFwIChEZXJp dmVkIGFyZykNCj4gPiAtew0KPiA+IC0gIHJldHVybiBmb28gKGFyZyk7DQo+ ID4gLX0NCj4gPiAtDQo+ID4gLXN0cnVjdCBDb250YWluZXINCj4gPiAtew0K PiA+IC0gIE9iaiBvYmo7DQo+ID4gLX07DQo+ID4gLQ0KPiA+IC1pbnQgYmxp cCAoQ29udGFpbmVyIGFyZykNCj4gPiAtew0KPiA+IC0gIHJldHVybiBmb28g KGFyZy5vYmopOw0KPiA+IC19DQo+ID4gLQ0KPiA+IC1PYmogZ2xvYmFsX29i ajsNCj4gPiAtRGVyaXZlZCBnbG9iYWxfZGVyaXZlZDsNCj4gPiAtQ29udGFp bmVyIGdsb2JhbF9jb250YWluZXI7DQo+ID4gLQ0KPiA+IC1pbnQNCj4gPiAt bWFpbiAoKQ0KPiA+IC17DQo+ID4gLSAgaW50IGJhciA9IGZvbyAoZ2xvYmFs X29iaik7DQo+ID4gLSAgYmxhcCAoZ2xvYmFsX2Rlcml2ZWQpOw0KPiA+IC0g IGJsaXAgKGdsb2JhbF9jb250YWluZXIpOw0KPiA+IC0gIHJldHVybiBiYXI7 DQo+ID4gLX0NCj4gPiBkaWZmIC0tZ2l0IGEvZ2RiL3Rlc3RzdWl0ZS9nZGIu Y3AvcGFzcy1ieS1yZWYuZXhwIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuY3AvcGFz cy1ieS1yZWYuZXhwDQo+ID4gaW5kZXggOTRkZDM0NS4uZjQ0YmU3NyAxMDA2 NDQNCj4gPiAtLS0gYS9nZGIvdGVzdHN1aXRlL2dkYi5jcC9wYXNzLWJ5LXJl Zi5leHANCj4gPiArKysgYi9nZGIvdGVzdHN1aXRlL2dkYi5jcC9wYXNzLWJ5 LXJlZi5leHANCj4gPiBAQCAtMTQsMjAgKzE0LDM5NSBAQA0KPiA+ICAgIyBh bG9uZyB3aXRoIHRoaXMgcHJvZ3JhbS4gIElmIG5vdCwgc2VlIDxodHRwOi8v d3d3LmdudS5vcmcvbGljZW5zZXMvPi4NCj4gPg0KPiA+ICAgIyBDaGVjayB0 aGF0IEdEQiBjYW4gY2FsbCBDKysgZnVuY3Rpb25zIHdob3NlIHBhcmFtZXRl cnMgaGF2ZQ0KPiA+IC0jIG9iamVjdCB0eXBlLCBidXQgYXJlIHBhc3NlZCBi eSByZWZlcmVuY2UuDQo+ID4gKyMgb2JqZWN0IHR5cGUsIGFuZCBhcmUgZWl0 aGVyIHBhc3NlZCBieSB2YWx1ZSBvciBpbXBsaWNpdGx5IGJ5IHJlZmVyZW5j ZS4NCj4gPiArIw0KPiA+ICsjIFN1cHBvc2UgRiBpcyBhIGZ1bmN0aW9uIHRo YXQgaGFzIGEgY2FsbC1ieS12YWx1ZSBwYXJhbWV0ZXIgd2hvc2UNCj4gPiAr IyB0eXBlIGlzIGNsYXNzIEMuICBXaGVuIGNhbGxpbmcgRiB3aXRoIGFuIGFy Z3VtZW50IEEsIGEgY29weSBvZiBBIHNob3VsZA0KPiA+ICsjIGJlIGNyZWF0 ZWQgYW5kIHBhc3NlZCB0byBGLiAgSWYgQyBpcyBhIHRyaXZpYWxseS1jb3B5 YWJsZSB0eXBlLCBBIGNhbg0KPiA+ICsjIGJlIGNvcGllZCBieSBhIHN0cmFp Z2h0Zm9yd2FyZCBtZW1vcnkgY29weS4gIEhvd2V2ZXIsIHJvdWdobHkgc3Bl YWtpbmcsDQo+ID4gKyMgaWYgQyBoYXMgYSB1c2VyLWRlZmluZWQgY29weSBj b25zdHJ1Y3RvciBhbmQvb3IgYSB1c2VyLWRlZmluZWQNCj4gPiArIyBkZXN0 cnVjdG9yLCB0aGUgY29weSBjdG9yIHNob3VsZCBiZSB1c2VkIHRvIGluaXRp YWxpemUgdGhlIGNvcHkgb2YgQQ0KPiA+ICsjIGJlZm9yZSBjYWxsaW5nIEYs IGFuZCBhIHJlZmVyZW5jZSB0byB0aGF0IGNvcHkgaXMgcGFzc2VkIHRvIEYu ICBBZnRlcg0KPiA+ICsjIHRoZSBmdW5jdGlvbiByZXR1cm5zLCB0aGUgZGVz dHJ1Y3RvciBzaG91bGQgYmUgY2FsbGVkIHRvIGRlc3RydWN0IHRoZQ0KPiA+ ICsjIGNvcHkuICBJbiB0aGlzIGNhc2UsIEMgaXMgc2FpZCB0byBiZSBhICdw YXNzLWJ5LXJlZmVyZW5jZScgdHlwZS4NCj4gPiArIyBEZXRlcm1pbmluZyB3 aGV0aGVyIEMgaXMgcGFzcy1ieS1yZWYgZGVwZW5kcyBvbg0KPiA+ICsjIGhv dyB0aGUgY29weSBjdG9yLCBkZXN0cnVjdG9yLCBhbmQgdGhlIG1vdmUgY3Rv ciBvZiBDIGFyZSBkZWZpbmVkLg0KPiA+ICsjIEZpcnN0IG9mIGFsbCwgQyBp cyBub3QgY29weSBjb25zdHJ1Y3RpYmxlIGlmIGl0cyBjb3B5IGNvbnN0cnVj dG9yIGlzDQo+ID4gKyMgZXhwbGljaXRseSBvciBpbXBsaWNpdGx5IGRlbGV0 ZWQuICBJbiB0aGlzIGNhc2UsIGl0IHdvdWxkIGJlIGlsbGVnYWwNCj4gPiAr IyB0byBwYXNzIHZhbHVlcyBvZiB0eXBlIEMgdG8gYSBmdW5jdGlvbi4gIEMg aXMgcGFzcy1ieS12YWx1ZSwgaWYgYWxsIG9mDQo+ID4gKyMgaXRzIGNvcHkg Y3RvciwgZHRvciwgYW5kIG1vdmUgY3RvciBhcmUgdHJpdmlhbGx5IGRlZmlu ZWQuDQo+ID4gKyMgT3RoZXJ3aXNlLCBpdCBpcyBwYXNzLWJ5LXJlZi4NCj4g PiArIw0KPiA+ICsjIFRvIGNvdmVyIHRoZSBtYW55IHBvc3NpYmxlIGNvbWJp bmF0aW9ucywgdGhpcyB0ZXN0IGdlbmVyYXRlcyBjbGFzc2VzDQo+ID4gKyMg dGhhdCBjb250YWluIHRocmVlIHNwZWNpYWwgZnVuY3Rpb25zOg0KPiA+ICsj ICAgKDEpIGEgY29weSBjb25zdHJ1Y3RvciwNCj4gPiArIyAgICgyKSBhIGRl c3RydWN0b3IsIGFuZA0KPiA+ICsjICAgKDMpIGEgbW92ZSBjb25zdHJ1Y3Rv ci4NCj4gPiArIyBBIHNwZWNpYWwgZnVuY3Rpb24gaXMgaW4gb25lIG9mIHRo ZSBmb2xsb3dpbmcgc3RhdGVzOg0KPiA+ICsjICAqIGV4cGxpY2l0OiBUaGUg ZnVuY3Rpb24gaXMgZXhwbGljaXRseSBkZWZpbmVkIGJ5IHRoZSB1c2VyLg0K PiA+ICsjICAqIGRlZmF1bHRlZEluOiBUaGUgZnVuY3Rpb24gaXMgZGVmYXVs dGVkIGluc2lkZSB0aGUgY2xhc3MgZGVjbCwNCj4gPiArIyAgICAgIHVzaW5n IHRoZSAnZGVmYXVsdCcga2V5d29yZC4NCj4gPiArIyAgKiBkZWZhdWx0ZWRP dXQ6IFRoZSBmdW5jdGlvbiBpcyBkZWNsYXJlZCBpbnNpZGUgdGhlIGNsYXNz IGRlY2wsDQo+ID4gKyMgICAgICBhbmQgZGVmYXVsdGVkIG91dHNpZGUgdXNp bmcgdGhlICdkZWZhdWx0JyBrZXl3b3JkLg0KPiA+ICsjICAqIGRlbGV0ZWQ6 IFRoZSBmdW5jdGlvbiBpcyBleHBsaWNpdGx5IGRlbGV0ZWQgYnkgdGhlIHVz ZXIsDQo+ID4gKyMgICAgICB1c2luZyB0aGUgJ2RlbGV0ZScga2V5d29yZC4N Cj4gPiArIyAgKiBhYnNlbnQ6IFRoZSBmdW5jdGlvbiBpcyBub3QgZGVjbGFy ZWQgYnkgdGhlIHVzZXIgKGkuZS4gaXQgZG9lcyBub3QNCj4gPiArIyAgICAg IGV4aXN0IGluIHRoZSBzb3VyY2UuICBUaGUgY29tcGlsZXIgZ2VuZXJhdGVz IChvciBkZWxldGVzKSB0aGUNCj4gPiArIyAgICAgIGRlZmluaXRpb24gaW4g dGhpcyBjYXNlLg0KPiA+ICsjDQo+ID4gKyMgVGhlIEMrKyBBQkkgZGVjaWRl cyBpZiBhIGNsYXNzIGlzIHBhc3MtYnktdmFsdWUgb3IgcGFzcy1ieS1yZWYN Cj4gPiArIyAoaS5lLiAgdHJpdmlhbGx5IGNvcHlhYmxlIG9yIG5vdCkgZmly c3QgYXQgdGhlIGxhbmd1YWdlIGxldmVsLCBiYXNlZA0KPiA+ICsjIG9uIHRo ZSBzdGF0ZSBvZiB0aGUgc3BlY2lhbCBmdW5jdGlvbnMuICBUaGVuLCBhdCB0 aGUgdGFyZ2V0IGxldmVsLCBhDQo+ID4gKyMgY2xhc3MgbWF5IGJlIGRldGVy bWluZWQgdG8gYmUgcGFzcy1ieS1yZWYgYmVjYXVzZSBvZiBpdHMgc2l6ZQ0K PiA+ICsjIChlLmcuICBpZiBpdCBpcyB0b28gbGFyZ2UgdG8gZml0IG9uIHJl Z2lzdGVycykuICBGb3IgdGhpcyByZWFzb24sIHRoaXMNCj4gPiArIyB0ZXN0 IGdlbmVyYXRlcyBib3RoIGEgc21hbGwgYW5kIGEgbGFyZ2UgdmVyc2lvbiBm b3IgdGhlIHNhbWUNCj4gPiArIyBjb21iaW5hdGlvbiBvZiBzcGVjaWFsIGZ1 bmN0aW9uIHN0YXRlcy4NCj4gPiArIw0KPiA+ICsjIEEgY2xhc3MgaXMgbm90 IHRyaXZpYWxseS1jb3B5YWJsZSBpZiBhIGJhc2UgY2xhc3Mgb3IgYSBmaWVs ZCBpcyBub3QNCj4gPiArIyB0cml2aWFsbHktY29weWFibGUsIGV2ZW4gdGhv dWdoIHRoZSBjbGFzcyBkZWZpbml0aW9uIGl0c2VsZiBzZWVtcw0KPiA+ICsj IHRyaXZpYWwuICBUbyB0ZXN0IHRoZXNlIGNhc2VzLCB3ZSBhbHNvIGdlbmVy YXRlIGRlcml2ZWQgY2xhc3NlcyBhbmQNCj4gPiArIyBjb250YWluZXIgY2xh c3Nlcy4NCj4gPiArIw0KPiA+ICsjIFRoZSBnZW5lcmF0ZWQgY29kZSBpcyBw bGFjZWQgaW4gdGhlIHRlc3Qgb3V0cHV0IGRpcmVjdG9yeS4NCj4gPiArIw0K PiA+ICsjIFRoZSBjb21wYW5pb24gdGVzdCBmaWxlIHBhc3MtYnktcmVmLTIu ZXhwIGFsc28gY29udGFpbnMNCj4gPiArIyBtYW51YWxseS13cml0dGVuIGNh c2VzLg0KPiA+DQo+ID4gLWlmIHsgW3NraXBfY3BsdXNfdGVzdHNdIH0geyBj b250aW51ZSB9DQo+ID4gK2lmIHtbc2tpcF9jcGx1c190ZXN0c119IHsNCj4g PiArICAgIHVudGVzdGVkICJjKysgdGVzdCBza2lwcGVkIg0KPiA+ICsgICAg Y29udGludWUNCj4gPiArfQ0KPiA+DQo+ID4gKyMgVGhlIHByb2dyYW0gc291 cmNlIGlzIGdlbmVyYXRlZCBpbiB0aGUgb3V0cHV0IGRpcmVjdG9yeS4NCj4g PiArIyBXZSB1c2Ugc3RhbmRhcmRfdGVzdGZpbGUgaGVyZSB0byBzZXQgY29u dmVuaWVuY2UgdmFyaWFibGVzLg0KPiA+ICAgc3RhbmRhcmRfdGVzdGZpbGUg LmNjDQo+ID4NCj4gPiAtaWYge1twcmVwYXJlX2Zvcl90ZXN0aW5nICJmYWls ZWQgdG8gcHJlcGFyZSIgJHRlc3RmaWxlICRzcmNmaWxlIHtkZWJ1ZyBjKyt9 XX0gew0KPiA+ICsjIFNvbWUgY29uc3RhbnQgdmFsdWVzIHVzZWQgd2hlbiBn ZW5lcmF0aW5nIHRoZSBzb3VyY2UNCj4gPiArDQo+ID4gK3NldCBTTUFMTCAg ICAyDQo+ID4gK3NldCBMQVJHRSAgICAxNTANCj4gPiArc2V0IE9SSUdJTkFM IDINCj4gPiArc2V0IENVU1RPTSAgIDMNCj4gPiArc2V0IEFEREVEICAgIDQN Cj4gPiArc2V0IFRSQUNFICAgIDUNCj4gPiArDQo+ID4gKw0KPiA+ICsjIFJl dHVybiAxIGlmIHRoZSBjbGFzcyB3aG9zZSBzcGVjaWFsIGZ1bmN0aW9uIHN0 YXRlcyBhcmUgU1RBVEVTDQo+ID4gKyMgaXMgY29weWFibGUuICBPdGhlcndp c2UgcmV0dXJuIDAuDQo+ID4gKw0KPiA+ICtwcm9jIGlzX2NvcHlfY29uc3Ry dWN0aWJsZSB7IHN0YXRlcyB9IHsNCj4gPiArICAgIHNldCBjY3RvciBbbGlu ZGV4ICRzdGF0ZXMgMF0NCj4gPiArICAgIHNldCBkdG9yICBbbGluZGV4ICRz dGF0ZXMgMV0NCj4gPiArICAgIHNldCBtY3RvciBbbGluZGV4ICRzdGF0ZXMg Ml0NCj4gPiArDQo+ID4gKyAgICBpZiB7JGNjdG9yID09ICJkZWxldGVkIiB8 fCAoJGNjdG9yID09ICJhYnNlbnQiICYmICRtY3RvciAhPSAiYWJzZW50Iil9 IHsNCj4gPiArCXJldHVybiAwDQo+ID4gKyAgICB9DQo+ID4gKyAgICByZXR1 cm4gMQ0KPiA+ICt9DQo+ID4gKw0KPiA+ICsjIEdlbmVyYXRlIGEgZGVjbGFy YXRpb24gYW5kIGFuIG91dC1vZi1jbGFzcyBkZWZpbml0aW9uIGZvciBhIGZ1 bmN0aW9uDQo+ID4gKyMgd2l0aCB0aGUgcHJvdmlkZWQgc2lnbmF0dXJlLiAg VGhlIFNUQVRFIHNob3VsZCBiZSBvbmUgb2YgdGhlIGZvbGxvd2luZzoNCj4g PiArIyAtIGV4cGxpY2l0LCBkZWZhdWx0ZWRJbiwgZGVmYXVsdGVkT3V0LCBk ZWxldGVkLCBhYnNlbnQNCj4gPiArDQo+ID4gK3Byb2MgZ2VuZXJhdGVfbWVt YmVyX2Z1bmN0aW9uIHsgY2xhc3NuYW1lIHNpZ25hdHVyZSBsZW5ndGggc3Rh dGUgfSB7DQo+ID4gKyAgICBzZXQgZGVjbGFyYXRpb24gIiINCj4gPiArICAg IHNldCBkZWZpbml0aW9uICIiDQo+ID4gKw0KPiA+ICsgICAgZ2xvYmFsIENV U1RPTQ0KPiA+ICsgICAgZ2xvYmFsIFRSQUNFDQo+ID4gKw0KPiA+ICsgICAg c3dpdGNoICRzdGF0ZSB7DQo+ID4gKwlleHBsaWNpdCB7DQo+ID4gKwkgICAg c2V0IGRlY2xhcmF0aW9uICIkc2lnbmF0dXJlO1xuIg0KPiA+ICsJICAgIHNl dCBkZWZpbml0aW9uICIkY2xhc3NuYW1lXDpcOiRzaWduYXR1cmUNCj4gPiAr ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHsNCj4gPiArICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZGF0YVxbMFxdID0gJENVU1RPTTsNCj4g PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGF0YVxbW2V4cHIg JGxlbmd0aCAtIDFdXF0gPSAkQ1VTVE9NOw0KPiA+ICsgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB0cmFjZXIgPSAkVFJBQ0U7DQo+ID4gKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICB9XG4iDQo+ID4gKwl9DQo+ID4gKwlk ZWZhdWx0ZWRJbiB7DQo+ID4gKwkgICAgc2V0IGRlY2xhcmF0aW9uICIkc2ln bmF0dXJlID0gZGVmYXVsdDtcbiINCj4gPiArCX0NCj4gPiArCWRlZmF1bHRl ZE91dCB7DQo+ID4gKwkgICAgc2V0IGRlY2xhcmF0aW9uICIkc2lnbmF0dXJl O1xuIg0KPiA+ICsJICAgIHNldCBkZWZpbml0aW9uICIkY2xhc3NuYW1lXDpc OiRzaWduYXR1cmUgPSBkZWZhdWx0O1xuIg0KPiA+ICsJfQ0KPiA+ICsJZGVs ZXRlZCB7DQo+ID4gKwkgICAgc2V0IGRlY2xhcmF0aW9uICIkc2lnbmF0dXJl ID0gZGVsZXRlO1xuIg0KPiA+ICsJfQ0KPiA+ICsJZGVmYXVsdCB7DQo+ID4g KwkgICAgIyBmdW5jdGlvbiBpcyBub3QgdXNlci1kZWZpbmVkIGluIHRoaXMg Y2FzZQ0KPiA+ICsJfQ0KPiA+ICsgICAgfQ0KPiA+ICsNCj4gPiArICAgIHJl dHVybiBbbGlzdCAkZGVjbGFyYXRpb24gJGRlZmluaXRpb25dDQo+ID4gK30N Cj4gPiArDQo+ID4gKyMgR2VuZXJhdGUgYSBDKysgY2xhc3Mgd2l0aCB0aGUg Z2l2ZW4gQ0xBU1NOQU1FIGFuZCBMRU5HVEgtbWFueQ0KPiA+ICsjIGludGVn ZXIgZWxlbWVudHMuICBUaGUgU1RBVEVTIGlzIGFuIGFycmF5IG9mIDMgaXRl bXMNCj4gPiArIyBjb250YWluaW5nIHRoZSBkZXNpcmVkIHN0YXRlIG9mIHRo ZSBzcGVjaWFsIGZ1bmN0aW9ucw0KPiA+ICsjIGluIHRoaXMgb3JkZXI6DQo+ ID4gKyMgY29weSBjb25zdHJ1Y3RvciwgZGVzdHJ1Y3RvciwgbW92ZSBjb25z dHJ1Y3Rvcg0KPiA+ICsNCj4gPiArcHJvYyBnZW5lcmF0ZV9jbGFzcyB7IGNs YXNzbmFtZSBsZW5ndGggc3RhdGVzIH0gew0KPiA+ICsgICAgc2V0IGRlY2xh cmF0aW9ucyAiIg0KPiA+ICsgICAgc2V0IGRlZmluaXRpb25zICIiDQo+ID4g KyAgICBzZXQgY2xhc3NuYW1lICIke2NsYXNzbmFtZX1fW2pvaW4gJHN0YXRl cyBfXSINCj4gPiArDQo+ID4gKyAgICBmb3Ige3NldCBpIDB9IHskaSA8IFts bGVuZ3RoICRzdGF0ZXNdfSB7aW5jciBpfSB7DQo+ID4gKwlzZXQgc2lnICIi DQo+ID4gKwlzd2l0Y2ggJGkgew0KPiA+ICsJICAgIDAge3NldCBzaWcgIiRj bGFzc25hbWUgKGNvbnN0ICRjbGFzc25hbWUgXCZyaHMpIn0NCj4gPiArCSAg ICAxIHtzZXQgc2lnICJcfiRjbGFzc25hbWUgKHZvaWQpIn0NCj4gPiArCSAg ICAyIHtzZXQgc2lnICIkY2xhc3NuYW1lICgkY2xhc3NuYW1lIFwmXCZyaHMp In0NCj4gPiArCX0NCj4gPiArDQo+ID4gKwlzZXQgc3RhdGUgW2xpbmRleCAk c3RhdGVzICRpXQ0KPiA+ICsJc2V0IGNvZGUgW2dlbmVyYXRlX21lbWJlcl9m dW5jdGlvbiAkY2xhc3NuYW1lICRzaWcgJGxlbmd0aCAkc3RhdGVdDQo+ID4g KwlhcHBlbmQgZGVjbGFyYXRpb25zIFtsaW5kZXggJGNvZGUgMF0NCj4gPiAr CWFwcGVuZCBkZWZpbml0aW9ucyBbbGluZGV4ICRjb2RlIDFdDQo+ID4gKyAg ICB9DQo+ID4gKw0KPiA+ICsgICAgZ2xvYmFsIE9SSUdJTkFMDQo+ID4gKw0K PiA+ICsgICAgcmV0dXJuICINCj4gPiArICAgIC8qKiogQysrIGNsYXNzICRj bGFzc25hbWUgKioqLw0KPiA+ICsgICAgY2xhc3MgJHtjbGFzc25hbWV9IHsN Cj4gPiArICAgIHB1YmxpYzoNCj4gPiArICAgICAgICAkY2xhc3NuYW1lICh2 b2lkKTsNCj4gPiArICAgICAgICAkZGVjbGFyYXRpb25zDQo+ID4gKw0KPiA+ ICsgICAgICAgIGludCBkYXRhXFskbGVuZ3RoXF07DQo+ID4gKyAgICB9Ow0K PiA+ICsNCj4gPiArICAgICRjbGFzc25hbWVcOlw6JGNsYXNzbmFtZSAodm9p ZCkNCj4gPiArICAgIHsNCj4gPiArICAgICAgICBkYXRhXFswXF0gPSAkT1JJ R0lOQUw7DQo+ID4gKyAgICAgICAgZGF0YVxbW2V4cHIgJGxlbmd0aCAtIDFd XF0gPSAkT1JJR0lOQUw7DQo+ID4gKyAgICB9DQo+ID4gKw0KPiA+ICsgICAg JGRlZmluaXRpb25zDQo+ID4gKw0KPiA+ICsgICAgJGNsYXNzbmFtZSAke2Ns YXNzbmFtZX1fdmFyOyAvKiBnbG9iYWwgdmFyICovDQo+ID4gKw0KPiA+ICsg ICAgdGVtcGxhdGUgaW50IGNidjwkY2xhc3NuYW1lPiAoJGNsYXNzbmFtZSBh cmcpOyINCj4gPiArfQ0KPiA+ICsNCj4gPiArIyBHZW5lcmF0ZSBhIHNtYWxs IEMrKyBjbGFzcw0KPiA+ICsNCj4gPiArcHJvYyBnZW5lcmF0ZV9zbWFsbF9j bGFzcyB7IHN0YXRlcyB9IHsNCj4gPiArICAgIGdsb2JhbCBTTUFMTA0KPiA+ ICsgICAgcmV0dXJuIFtnZW5lcmF0ZV9jbGFzcyBTbWFsbCAkU01BTEwgJHN0 YXRlc107DQo+ID4gK30NCj4gPiArDQo+ID4gKyMgR2VuZXJhdGUgYSBsYXJn ZSBDKysgY2xhc3MNCj4gPiArDQo+ID4gK3Byb2MgZ2VuZXJhdGVfbGFyZ2Vf Y2xhc3MgeyBzdGF0ZXMgfSB7DQo+ID4gKyAgICBnbG9iYWwgTEFSR0UNCj4g PiArICAgIHJldHVybiBbZ2VuZXJhdGVfY2xhc3MgTGFyZ2UgJExBUkdFICRz dGF0ZXNdOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICsjIEdlbmVyYXRlIGEgY2xh c3MgdGhhdCBkZXJpdmVzIGZyb20gYSBzbWFsbCBjbGFzcw0KPiA+ICsNCj4g PiArcHJvYyBnZW5lcmF0ZV9kZXJpdmVkX2NsYXNzIHsgc3RhdGVzIH0gew0K PiA+ICsgICAgc2V0IGJhc2UgIlNtYWxsX1tqb2luICRzdGF0ZXMgX10iDQo+ ID4gKyAgICBzZXQgY2xhc3NuYW1lICJEZXJpdmVkX1tqb2luICRzdGF0ZXMg X10iDQo+ID4gKw0KPiA+ICsgICAgcmV0dXJuICINCj4gPiArICAgIC8qKiog Q2xhc3MgZGVyaXZlZCBmcm9tICRiYXNlICoqKi8NCj4gPiArICAgIGNsYXNz ICRjbGFzc25hbWUgOiBwdWJsaWMgJGJhc2Ugew0KPiA+ICsgICAgcHVibGlj Og0KPiA+ICsgICAgfTsNCj4gPiArDQo+ID4gKyAgICAkY2xhc3NuYW1lICR7 Y2xhc3NuYW1lfV92YXI7IC8qIGdsb2JhbCB2YXIgKi8NCj4gPiArDQo+ID4g KyAgICB0ZW1wbGF0ZSBpbnQgY2J2PCRjbGFzc25hbWU+ICgkY2xhc3NuYW1l IGFyZyk7Ig0KPiA+ICt9DQo+ID4gKw0KPiA+ICsjIEdlbmVyYXRlIGEgY2xh c3MgdGhhdCBjb250YWlucyBhIHNtYWxsIGNsYXNzIGl0ZW0NCj4gPiArDQo+ ID4gK3Byb2MgZ2VuZXJhdGVfY29udGFpbmVyX2NsYXNzIHsgc3RhdGVzIH0g ew0KPiA+ICsgICAgc2V0IGNvbnRhaW5lZCAiU21hbGxfW2pvaW4gJHN0YXRl cyBfXSINCj4gPiArICAgIHNldCBjbGFzc25hbWUgIkNvbnRhaW5lcl9bam9p biAkc3RhdGVzIF9dIg0KPiA+ICsNCj4gPiArICAgIHJldHVybiAiDQo+ID4g KyAgICAvKioqIENsYXNzIHRoYXQgY29udGFpbnMgJGNvbnRhaW5lZCAqKiov DQo+ID4gKyAgICBjbGFzcyAkY2xhc3NuYW1lIHsNCj4gPiArICAgIHB1Ymxp YzoNCj4gPiArICAgICAgICAkY29udGFpbmVkIGl0ZW07DQo+ID4gKyAgICB9 Ow0KPiA+ICsNCj4gPiArICAgICRjbGFzc25hbWUgJHtjbGFzc25hbWV9X3Zh cjsgLyogZ2xvYmFsIHZhciAqLw0KPiA+ICsNCj4gPiArICAgIHRlbXBsYXRl IGludCBjYnZfY29udGFpbmVyPCRjbGFzc25hbWU+ICgkY2xhc3NuYW1lIGFy Zyk7Ig0KPiA+ICt9DQo+ID4gKw0KPiA+ICsjIEdlbmVyYXRlIHVzZWZ1bCBz dGF0ZW1lbnRzIHRoYXQgdXNlIGEgY2xhc3MgaW4gdGhlIGRlYnVnZWUgcHJv Z3JhbQ0KPiA+ICsNCj4gPiArcHJvYyBnZW5lcmF0ZV9zdG10cyB7IGNsYXNz cHJlZml4IHN0YXRlcyB7Y2J2ZnVuICJjYnYifX0gew0KPiA+ICsgICAgc2V0 IGNsYXNzbmFtZSAiJHtjbGFzc3ByZWZpeH1fW2pvaW4gJHN0YXRlcyBfXSIN Cj4gPiArDQo+ID4gKyAgICAjIEhhdmluZyBhbiBleHBsaWNpdCBjYWxsIHRv IHRoZSBjYnYgZnVuY3Rpb24gaW4gdGhlIGRlYnVnZWUgcHJvZ3JhbQ0KPiA+ ICsgICAgIyBlbnN1cmVzIHRoYXQgdGhlIGNvbXBpbGVyIHdpbGwgZW1pdCBu ZWNlc3NhcnkgZnVuY3Rpb24gaW4gdGhlIGJpbmFyeS4NCj4gPiArICAgIGlm IHtbaXNfY29weV9jb25zdHJ1Y3RpYmxlICRzdGF0ZXNdfSB7DQo+ID4gKwlz ZXQgY2J2Y2FsbCAiJGNidmZ1bjwkY2xhc3NuYW1lPiAoJHtjbGFzc25hbWV9 X3Zhcik7XG4iDQo+ID4gKyAgICB9IGVsc2Ugew0KPiA+ICsJc2V0IGNidmNh bGwgIiINCj4gPiArICAgIH0NCj4gPiArDQo+ID4gKyAgICByZXR1cm4gIiRj YnZjYWxsIg0KPiA+ICt9DQo+ID4gKw0KPiA+ICsjIEdlbmVyYXRlIHRoZSBj b21wbGV0ZSBkZWJ1Z2VlIHByb2dyYW0NCj4gPiArDQo+ID4gK3Byb2MgZ2Vu ZXJhdGVfcHJvZ3JhbSB7IGNsYXNzZXMgc3RtdHMgfSB7DQo+ID4gKyAgICBn bG9iYWwgQURERUQNCj4gPiArDQo+ID4gKyAgICByZXR1cm4gIg0KPiA+ICsg ICAgLyoqKiBUSElTIEZJTEUgSVMgR0VORVJBVEVEIEJZIFRIRSBURVNULiAg KioqLw0KPiA+ICsNCj4gPiArICAgIHN0YXRpYyBpbnQgdHJhY2VyID0gMDsN Cj4gPiArDQo+ID4gKyAgICAvKiBUaGUgY2FsbC1ieS12YWx1ZSBmdW5jdGlv bi4gICovDQo+ID4gKyAgICB0ZW1wbGF0ZSA8Y2xhc3MgVD4NCj4gPiArICAg IGludA0KPiA+ICsgICAgY2J2IChUIGFyZykNCj4gPiArICAgIHsNCj4gPiAr ICAgICAgYXJnLmRhdGFcWzBcXSArPSAkQURERUQ7IC8vIGludGVudGlvbmFs bHkgbW9kaWZ5IHRoZSBhcmcNCj4gPiArICAgICAgcmV0dXJuIGFyZy5kYXRh XFswXF07DQo+ID4gKyAgICB9DQo+ID4gKw0KPiA+ICsgICAgdGVtcGxhdGUg PGNsYXNzIFQ+DQo+ID4gKyAgICBpbnQNCj4gPiArICAgIGNidl9jb250YWlu ZXIgKFQgYXJnKQ0KPiA+ICsgICAgew0KPiA+ICsgICAgICBhcmcuaXRlbS5k YXRhXFswXF0gKz0gJEFEREVEOyAgLy8gaW50ZW50aW9uYWxseSBtb2RpZnkN Cj4gPiArICAgICAgcmV0dXJuIGFyZy5pdGVtLmRhdGFcWzBcXTsNCj4gPiAr ICAgIH0NCj4gPiArDQo+ID4gKyAgICAkY2xhc3Nlcw0KPiA+ICsNCj4gPiAr ICAgIGludA0KPiA+ICsgICAgbWFpbiAodm9pZCkNCj4gPiArICAgIHsNCj4g PiArICAgICAgJHN0bXRzDQo+ID4gKw0KPiA+ICsgICAgICAvKiBzdG9wIGhl cmUgKi8NCj4gPiArDQo+ID4gKyAgICAgIHJldHVybiAwOw0KPiA+ICsgICAg fSINCj4gPiArfQ0KPiA+ICsNCj4gPiArIyBDb21wdXRlIGFsbCB0aGUgY29t YmluYXRpb25zIG9mIHNwZWNpYWwgZnVuY3Rpb24gc3RhdGVzLg0KPiA+ICsj IFdlIGRvIG5vdCBjb250YWluIHRoZSAnZGVsZXRlZCcgc3RhdGUgZm9yIHRo ZSBkZXN0cnVjdG9yLA0KPiA+ICsjIGJlY2F1c2UgaXQgaXMgaWxsZWdhbCB0 byBoYXZlIHN0YWNrLWFsbG9jYXRlZCBvYmplY3RzDQo+ID4gKyMgd2hvc2Ug ZGVzdHJ1Y3RvciBoYXZlIGJlZW4gZGVsZXRlZC4gIFRoaXMgY2FzZSBpcyBj b3ZlcmVkDQo+ID4gKyMgaW4gcGFzcy1ieS1yZWYtMiB2aWEgaGVhcC1hbGxv Y2F0ZWQgb2JqZWN0cy4NCj4gPiArDQo+ID4gK3NldCBvcHRpb25zX25vZGVs ZXRlIFtsaXN0IGFic2VudCBleHBsaWNpdCBkZWZhdWx0ZWRJbiBkZWZhdWx0 ZWRPdXRdDQo+ID4gK3NldCBvcHRpb25zIFtjb25jYXQgJG9wdGlvbnNfbm9k ZWxldGUge2RlbGV0ZWR9XQ0KPiA+ICtzZXQgYWxsX2NvbWJpbmF0aW9ucyB7 fQ0KPiA+ICsNCj4gPiArZm9yZWFjaCBjY3RvciAkb3B0aW9ucyB7DQo+ID4g KyAgICBmb3JlYWNoIGR0b3IgJG9wdGlvbnNfbm9kZWxldGUgew0KPiA+ICsJ Zm9yZWFjaCBtY3RvciAkb3B0aW9ucyB7DQo+ID4gKwkgICAgbGFwcGVuZCBh bGxfY29tYmluYXRpb25zIFtsaXN0ICRjY3RvciAkZHRvciAkbWN0b3JdDQo+ ID4gKwl9DQo+ID4gKyAgICB9DQo+ID4gK30NCj4gPiArDQo+ID4gKyMgR2Vu ZXJhdGUgdGhlIGNsYXNzZXMuDQo+ID4gKw0KPiA+ICtzZXQgY2xhc3NlcyAi Ig0KPiA+ICtzZXQgc3RtdHMgIiINCj4gPiArDQo+ID4gK2ZvcmVhY2ggc3Rh dGUgJGFsbF9jb21iaW5hdGlvbnMgew0KPiA+ICsgICAgYXBwZW5kIGNsYXNz ZXMgW2dlbmVyYXRlX3NtYWxsX2NsYXNzICRzdGF0ZV0NCj4gPiArICAgIGFw cGVuZCBzdG10cyBbZ2VuZXJhdGVfc3RtdHMgIlNtYWxsIiAkc3RhdGVdDQo+ ID4gKw0KPiA+ICsgICAgYXBwZW5kIGNsYXNzZXMgW2dlbmVyYXRlX2xhcmdl X2NsYXNzICRzdGF0ZV0NCj4gPiArICAgIGFwcGVuZCBzdG10cyBbZ2VuZXJh dGVfc3RtdHMgIkxhcmdlIiAkc3RhdGVdDQo+ID4gKw0KPiA+ICsgICAgYXBw ZW5kIGNsYXNzZXMgW2dlbmVyYXRlX2Rlcml2ZWRfY2xhc3MgJHN0YXRlXQ0K PiA+ICsgICAgYXBwZW5kIHN0bXRzIFtnZW5lcmF0ZV9zdG10cyAiRGVyaXZl ZCIgJHN0YXRlXQ0KPiA+ICsNCj4gPiArICAgIGFwcGVuZCBjbGFzc2VzIFtn ZW5lcmF0ZV9jb250YWluZXJfY2xhc3MgJHN0YXRlXQ0KPiA+ICsgICAgYXBw ZW5kIHN0bXRzIFtnZW5lcmF0ZV9zdG10cyAiQ29udGFpbmVyIiAkc3RhdGUg ImNidl9jb250YWluZXIiXQ0KPiA+ICt9DQo+ID4gKw0KPiA+ICsjIEdlbmVy YXRlIHRoZSBwcm9ncmFtIGNvZGUgYW5kIGNvbXBpbGUNCj4gPiArc2V0IHBy b2dyYW0gW2dlbmVyYXRlX3Byb2dyYW0gJGNsYXNzZXMgJHN0bXRzXQ0KPiA+ ICtzZXQgc3JjZmlsZSBbc3RhbmRhcmRfb3V0cHV0X2ZpbGUgJHtzcmNmaWxl fV0NCj4gPiArZ2RiX3Byb2R1Y2Vfc291cmNlICRzcmNmaWxlICRwcm9ncmFt DQo+ID4gKw0KPiA+ICtzZXQgb3B0aW9ucyB7ZGVidWcgYysrIGFkZGl0aW9u YWxfZmxhZ3M9LXN0ZD1jKysxMX0NCj4gPiAraWYge1twcmVwYXJlX2Zvcl90 ZXN0aW5nICJmYWlsZWQgdG8gcHJlcGFyZSIgJHRlc3RmaWxlICRzcmNmaWxl ICRvcHRpb25zXX0gew0KPiA+ICAgICAgIHJldHVybiAtMQ0KPiA+ICAgfQ0K PiA+DQo+ID4gLWlmICFbcnVudG9fbWFpbl0gdGhlbiB7DQo+ID4gK2lmIHsh W3J1bnRvX21haW5dfSB7DQo+ID4gKyAgICB1bnRlc3RlZCAiZmFpbGVkIHRv IHJ1biB0byBtYWluIg0KPiA+ICAgICAgIHJldHVybiAtMQ0KPiA+ICAgfQ0K PiA+DQo+ID4gLWdkYl90ZXN0ICJwcmludCBmb28gKGdsb2JhbF9vYmopIiAi ID0gMyIgImNhbGwgZnVuY3Rpb24gaW4gb2JqIg0KPiA+IC1nZGJfdGVzdCAi cHJpbnQgYmxhcCAoZ2xvYmFsX2Rlcml2ZWQpIiAiID0gMyIgImNhbGwgZnVu Y3Rpb24gaW4gZGVyaXZlZCINCj4gPiAtZ2RiX3Rlc3QgInByaW50IGJsaXAg KGdsb2JhbF9jb250YWluZXIpIiAiID0gMyIgImNhbGwgZnVuY3Rpb24gaW4g Y29udGFpbmVyIg0KPiA+ICtzZXQgYnBfbG9jYXRpb24gW2dkYl9nZXRfbGlu ZV9udW1iZXIgInN0b3AgaGVyZSJdDQo+ID4gK2dkYl9icmVha3BvaW50ICRi cF9sb2NhdGlvbg0KPiA+ICtnZGJfY29udGludWVfdG9fYnJlYWtwb2ludCAi ZW5kIG9mIG1haW4iICIuKnJldHVybiAuKjsiDQo+ID4gKw0KPiA+ICsjIERv IHRoZSBjaGVja3MgZm9yIGEgZ2l2ZW4gY2xhc3Mgd2hvc2UgbmFtZSBpcyBw cmVmaXhlZCB3aXRoIFBSRUZJWCwNCj4gPiArIyBhbmQgd2hvc2Ugc3BlY2lh bCBmdW5jdGlvbnMgaGF2ZSB0aGUgc3RhdGVzIGdpdmVuIGluIFNUQVRFUy4N Cj4gPiArIyBUaGUgbmFtZSBvZiB0aGUgY2FsbC1ieS12YWx1ZSBmdW5jdGlv biBhbmQgdGhlIGV4cHJlc3Npb24gdG8gYWNjZXNzDQo+ID4gKyMgdGhlIGRh dGEgZmllbGQgY2FuIGJlIHNwZWNpZmllZCBleHBsaWNpdGx5IGlmIHRoZSBk ZWZhdWx0IHZhbHVlcw0KPiA+ICsjIGRvIG5vdCB3b3JrLg0KPiA+ICsNCj4g PiArcHJvYyB0ZXN0X2Zvcl9jbGFzcyB7IHByZWZpeCBzdGF0ZXMgY2J2ZnVu IGRhdGFfZmllbGQgbGVuZ3RofSB7DQo+ID4gKyAgICBzZXQgbmFtZSAiJHtw cmVmaXh9X1tqb2luICRzdGF0ZXMgX10iDQo+ID4gKw0KPiA+ICsgICAgc2V0 IGNjdG9yIFtsaW5kZXggJHN0YXRlcyAwXQ0KPiA+ICsgICAgc2V0IGR0b3Ig IFtsaW5kZXggJHN0YXRlcyAxXQ0KPiA+ICsgICAgc2V0IG1jdG9yIFtsaW5k ZXggJHN0YXRlcyAyXQ0KPiA+ICsNCj4gPiArICAgIGdsb2JhbCBPUklHSU5B TA0KPiA+ICsgICAgZ2xvYmFsIENVU1RPTQ0KPiA+ICsgICAgZ2xvYmFsIEFE REVEDQo+ID4gKyAgICBnbG9iYWwgVFJBQ0UNCj4gPiArDQo+ID4gKyAgICB3 aXRoX3Rlc3RfcHJlZml4ICRuYW1lIHsNCj4gPiArCWlmIHtbaXNfY29weV9j b25zdHJ1Y3RpYmxlICRzdGF0ZXNdfSB7DQo+ID4gKwkgICAgc2V0IGV4cGVj dGVkIFtleHByIHskT1JJR0lOQUwgKyAkQURERUR9XQ0KPiA+ICsJICAgIGlm IHskY2N0b3IgPT0gImV4cGxpY2l0In0gew0KPiA+ICsJCXNldCBleHBlY3Rl ZCBbZXhwciB7JENVU1RPTSArICRBRERFRH1dDQo+ID4gKwkgICAgfQ0KPiA+ ICsJICAgIGlmIHskZHRvciA9PSAiZXhwbGljaXQifSB7DQo+ID4gKwkJZ2Ri X3Rlc3QgInByaW50IHRyYWNlciA9IDAiICIgPSAwIiAicmVzZXQgdGhlIHRy YWNlciINCj4gPiArCSAgICB9DQo+ID4gKwkgICAgZ2RiX3Rlc3QgInByaW50 ICR7Y2J2ZnVufTwkbmFtZT4gKCR7bmFtZX1fdmFyKSIgIiA9ICRleHBlY3Rl ZCIgXA0KPiA+ICsJCSJjYWxsICckY2J2ZnVuJyINCj4gPiArCSAgICBnZGJf dGVzdCAicHJpbnQgJHtuYW1lfV92YXIuJHtkYXRhX2ZpZWxkfVxbMFxdIiAi ID0gJE9SSUdJTkFMIiBcDQo+ID4gKwkJImNidiBhcmd1bWVudCBzaG91bGQg bm90IGNoYW5nZSAoaXRlbSAwKSINCj4gPiArCSAgICBpZiB7JGxlbmd0aCA+ IDF9IHsNCj4gPiArCQlzZXQgbGFzdF9pbmRleCBbZXhwciAkbGVuZ3RoIC0g MV0NCj4gPiArCQlnZGJfdGVzdCAicHJpbnQgJHtuYW1lfV92YXIuJHtkYXRh X2ZpZWxkfVxbJGxhc3RfaW5kZXhcXSIgXA0KPiA+ICsJCSAgICAiID0gJE9S SUdJTkFMIiBcDQo+ID4gKwkJICAgICJjYnYgYXJndW1lbnQgc2hvdWxkIG5v dCBjaGFuZ2UgKGl0ZW0gJGxhc3RfaW5kZXgpIg0KPiA+ICsJICAgIH0NCj4g PiArCSAgICBpZiB7JGR0b3IgPT0gImV4cGxpY2l0In0gew0KPiA+ICsJCWdk Yl90ZXN0ICJwcmludCB0cmFjZXIiICIgPSAkVFJBQ0UiIFwNCj4gPiArCQkg ICAgImRlc3RydWN0b3Igc2hvdWxkIGJlIGNhbGxlZCINCj4gPiArCSAgICB9 DQo+ID4gKwl9IGVsc2Ugew0KPiA+ICsJICAgIGdkYl90ZXN0ICJwcmludCAk e2NidmZ1bn08JG5hbWU+ICgke25hbWV9X3ZhcikiIFwNCj4gPiArCQkiLiog Y2Fubm90IGJlIGV2YWx1YXRlZCAuKiAnJHtuYW1lfScgaXMgbm90IGNvcHkg Y29uc3RydWN0aWJsZSIgXA0KPiA+ICsJCSJjYWxsaW5nICckY2J2ZnVuJyBz aG91bGQgYmUgcmVmdXNlZCINCj4gPiArCX0NCj4gPiArICAgIH0NCj4gPiAr fQ0KPiA+ICsNCj4gPiArZm9yZWFjaCBzdGF0ZSAkYWxsX2NvbWJpbmF0aW9u cyB7DQo+ID4gKyAgICB0ZXN0X2Zvcl9jbGFzcyAiU21hbGwiICAgICAkc3Rh dGUgImNidiIgICAgICAgICAgICJkYXRhIiAgICAgICRTTUFMTA0KPiA+ICsg ICAgdGVzdF9mb3JfY2xhc3MgIkxhcmdlIiAgICAgJHN0YXRlICJjYnYiICAg ICAgICAgICAiZGF0YSIgICAgICAkTEFSR0UNCj4gPiArICAgIHRlc3RfZm9y X2NsYXNzICJEZXJpdmVkIiAgICRzdGF0ZSAiY2J2IiAgICAgICAgICAgImRh dGEiICAgICAgMQ0KPiA+ICsgICAgdGVzdF9mb3JfY2xhc3MgIkNvbnRhaW5l ciIgJHN0YXRlICJjYnZfY29udGFpbmVyIiAiaXRlbS5kYXRhIiAxDQo+ID4g K30NCj4gPg0KSW50ZWwgRGV1dHNjaGxhbmQgR21iSApSZWdpc3RlcmVkIEFk ZHJlc3M6IEFtIENhbXBlb24gMTAtMTIsIDg1NTc5IE5ldWJpYmVyZywgR2Vy bWFueQpUZWw6ICs0OSA4OSA5OSA4ODUzLTAsIHd3dy5pbnRlbC5kZQpNYW5h Z2luZyBEaXJlY3RvcnM6IENocmlzdGluIEVpc2Vuc2NobWlkLCBHYXJ5IEtl cnNoYXcKQ2hhaXJwZXJzb24gb2YgdGhlIFN1cGVydmlzb3J5IEJvYXJkOiBO aWNvbGUgTGF1ClJlZ2lzdGVyZWQgT2ZmaWNlOiBNdW5pY2gKQ29tbWVyY2lh bCBSZWdpc3RlcjogQW10c2dlcmljaHQgTXVlbmNoZW4gSFJCIDE4NjkyOAo= >From gdb-patches-return-163035-listarch-gdb-patches=sources.redhat.com@sourceware.org Mon Jan 13 19:38:34 2020 Return-Path: Delivered-To: listarch-gdb-patches@sources.redhat.com Received: (qmail 4468 invoked by alias); 13 Jan 2020 19:38:33 -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 4450 invoked by uid 89); 13 Jan 2020 19:38:33 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-22.8 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_SHORT,RCVD_IN_DNSWL_NONE,SPAM_BODY,SPF_PASS autolearn=ham version=3.3.1 spammy= X-HELO: mail-qt1-f171.google.com Received: from mail-qt1-f171.google.com (HELO mail-qt1-f171.google.com) (209.85.160.171) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 13 Jan 2020 19:38:28 +0000 Received: by mail-qt1-f171.google.com with SMTP id w30so10131038qtd.12 for ; Mon, 13 Jan 2020 11:38:28 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=subject:to:references:from:message-id:date:user-agent:mime-version :in-reply-to:content-language:content-transfer-encoding; bh=UDaU72BQRGkMFscdDP7bMhh67+WaS0Bc3pI7JqMwyoU=; b=TuIxQl8ZYGNKyNdNl+cpKj+7pnAguKPeFFezJiA61BPMYkkKyDNq7iDaPWZ6puwKmh Dj174qcpAS8Z2FbH6jxU63YpryuspsqGm7ba/DG17JexPTkpHWfFM3d7d3LVsFkFU817 ciqY9n4ZIKUawcqxM0IH/Vk83EqO+APK2MEkOSfUWrQkuArz0iMBD7LAJO0j+Z4ql4a8 F7RmaSKPLxw86IM4EBfBD/okAkyi5BD1JDw2CT8k3zjKY+db2AQdnnTj5J4DmLJBbHAs TtF5tQjeDg7qrf8KIpH51FAIvrmiNZv7TAA1S+TXWJYFAgrkFSwfG3KZmpRPVP6jak6H zJqw== Return-Path: Received: from [192.168.0.185] ([179.183.9.215]) by smtp.gmail.com with ESMTPSA id x34sm6260122qtd.20.2020.01.13.11.38.23 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 13 Jan 2020 11:38:25 -0800 (PST) Subject: Re: [review v3] testsuite, cp: increase the coverage of testing pass-by-ref arguments To: "Aktemur, Tankut Baris" , "tromey@sourceware.org" , "gdb-patches@sourceware.org" , "Tankut Baris Aktemur (Code Review)" References: <20191214095325.3864520AF6@gnutoolchain-gerrit.osci.io> <80c8502f-a350-6a2b-0b72-bbc903f53bc3@linaro.org> From: Luis Machado Message-ID: Date: Mon, 13 Jan 2020 19:40:00 -0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.2.2 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit X-IsSubscribed: yes X-SW-Source: 2020-01/txt/msg00349.txt.bz2 Content-length: 31390 On 1/13/20 4:35 PM, Aktemur, Tankut Baris wrote: > On Monday, January 13, 2020 7:21 PM, Luis Machado wrote: >> >> Hi, >> >> I noticed these new tests fail (in large numbers) for GCC 5.4.x. Is it >> expected? If so, it may be worth making this test conditional on newer >> GCC versions. >> > > Yes, this is expected. Older GCC versions did not emit certain DWARF attributes > (DW_AT_deleted, DW_AT_defaulted). This prevents GDB from making the right > pass-by-reference decision. I'll submit a patch for this. Thanks for clarifying this. I can submit that patch if you like. I have a box running an older GCC, so i noticed that and thought i'd check. Luis > > Thanks for the suggestion. > > -Baris > >> On 12/14/19 6:53 AM, Tankut Baris Aktemur (Code Review) wrote: >>> Change URL: https://gnutoolchain-gerrit.osci.io/r/c/binutils-gdb/+/142 >>> ...................................................................... >>> >>> testsuite, cp: increase the coverage of testing pass-by-ref arguments >>> >>> Extend testcases for GDB's infcall of call-by-value functions that >>> take aggregate values as parameters. In particular, existing test has >>> been substantially extended with class definitions whose definitions >>> of copy constructor, destructor, and move constructor functions are a >>> combination of >>> >>> (1) explicitly defined by the user, >>> (2) defaulted inside the class declaration, >>> (3) defaulted outside the class declaration, >>> (4) deleted >>> (5) not defined in the source. >>> >>> For each combination, a small and a large class is generated as well >>> as a derived class and a container class. Additionally, the following >>> manually-written cases are provided: >>> >>> - a dynamic class (i.e. class with a virtual method) >>> - classes that contain an array field >>> - a class whose copy ctor is inlined >>> - a class whose destructor is deleted >>> - classes with multiple copy and/or move ctors >>> >>> Test cases check whether GDB makes the right decision to pass an >>> object by value or implicitly by reference, whether really a copy of >>> the argument is passed, and whether the copy constructor and >>> destructor of the clone of the argument are invoked properly. >>> >>> The input program pass-by-ref.cc is generated in the test's output >>> directory. The input program pass-by-ref-2.cc is manually-written. >>> >>> Tests have been verified on the X86_64 architecture with >>> GCC 7.4.0, 8.2.0, and 9.2.1. >>> >>> gdb/testsuite/ChangeLog: >>> 2019-11-07 Tankut Baris Aktemur >>> >>> * gdb.cp/pass-by-ref.cc: Delete. Generated in the output >>> directory instead. >>> * gdb.cp/pass-by-ref.exp: Extend with more cases. >>> * gdb.cp/pass-by-ref-2.cc: New file. >>> * gdb.cp/pass-by-ref-2.exp: New file. >>> >>> Change-Id: Ie8ab1f260c6ad5ee4eb34b2c1597ce24af04abb6 >>> --- >>> A gdb/testsuite/gdb.cp/pass-by-ref-2.cc >>> A gdb/testsuite/gdb.cp/pass-by-ref-2.exp >>> D gdb/testsuite/gdb.cp/pass-by-ref.cc >>> M gdb/testsuite/gdb.cp/pass-by-ref.exp >>> 4 files changed, 791 insertions(+), 86 deletions(-) >>> >>> >>> >>> diff --git a/gdb/testsuite/gdb.cp/pass-by-ref-2.cc b/gdb/testsuite/gdb.cp/pass-by-ref-2.cc >>> new file mode 100644 >>> index 0000000..1cd5a16 >>> --- /dev/null >>> +++ b/gdb/testsuite/gdb.cp/pass-by-ref-2.cc >>> @@ -0,0 +1,295 @@ >>> +/* This testcase is part of GDB, the GNU debugger. >>> + >>> + Copyright 2019 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 . */ >>> + >>> +class ByVal { >>> +public: >>> + ByVal (void); >>> + >>> + int x; >>> +}; >>> + >>> +ByVal::ByVal (void) >>> +{ >>> + x = 2; >>> +} >>> + >>> +class ByRef { >>> +public: >>> + ByRef (void); >>> + >>> + ByRef (const ByRef &rhs); >>> + >>> + int x; >>> +}; >>> + >>> +ByRef::ByRef (void) >>> +{ >>> + x = 2; >>> +} >>> + >>> +ByRef::ByRef (const ByRef &rhs) >>> +{ >>> + x = 3; /* ByRef-cctor */ >>> +} >>> + >>> +class ArrayContainerByVal { >>> +public: >>> + ByVal items[2]; >>> +}; >>> + >>> +int >>> +cbvArrayContainerByVal (ArrayContainerByVal arg) >>> +{ >>> + arg.items[0].x += 4; // intentionally modify >>> + return arg.items[0].x; >>> +} >>> + >>> +class ArrayContainerByRef { >>> +public: >>> + ByRef items[2]; >>> +}; >>> + >>> +int >>> +cbvArrayContainerByRef (ArrayContainerByRef arg) >>> +{ >>> + arg.items[0].x += 4; // intentionally modify >>> + return arg.items[0].x; >>> +} >>> + >>> +class DynamicBase { >>> +public: >>> + DynamicBase (void); >>> + >>> + virtual int get (void); >>> + >>> + int x; >>> +}; >>> + >>> +DynamicBase::DynamicBase (void) >>> +{ >>> + x = 2; >>> +} >>> + >>> +int >>> +DynamicBase::get (void) >>> +{ >>> + return 42; >>> +} >>> + >>> +class Dynamic : public DynamicBase { >>> +public: >>> + virtual int get (void); >>> +}; >>> + >>> +int >>> +Dynamic::get (void) >>> +{ >>> + return 9999; >>> +} >>> + >>> +int >>> +cbvDynamic (DynamicBase arg) >>> +{ >>> + arg.x += 4; // intentionally modify >>> + return arg.x + arg.get (); >>> +} >>> + >>> +class Inlined { >>> +public: >>> + Inlined (void); >>> + >>> + __attribute__((always_inline)) >>> + Inlined (const Inlined &rhs) >>> + { >>> + x = 3; >>> + } >>> + >>> + int x; >>> +}; >>> + >>> +Inlined::Inlined (void) >>> +{ >>> + x = 2; >>> +} >>> + >>> +int >>> +cbvInlined (Inlined arg) >>> +{ >>> + arg.x += 4; // intentionally modify >>> + return arg.x; >>> +} >>> + >>> +class DtorDel { >>> +public: >>> + DtorDel (void); >>> + >>> + ~DtorDel (void) = delete; >>> + >>> + int x; >>> +}; >>> + >>> +DtorDel::DtorDel (void) >>> +{ >>> + x = 2; >>> +} >>> + >>> +int >>> +cbvDtorDel (DtorDel arg) >>> +{ >>> + // Calling this method should be rejected >>> + return arg.x; >>> +} >>> + >>> +class FourCCtor { >>> +public: >>> + FourCCtor (void); >>> + >>> + FourCCtor (FourCCtor &rhs); >>> + FourCCtor (const FourCCtor &rhs); >>> + FourCCtor (volatile FourCCtor &rhs); >>> + FourCCtor (const volatile FourCCtor &rhs); >>> + >>> + int x; >>> +}; >>> + >>> +FourCCtor::FourCCtor (void) >>> +{ >>> + x = 2; >>> +} >>> + >>> +FourCCtor::FourCCtor (FourCCtor &rhs) >>> +{ >>> + x = 3; >>> +} >>> + >>> +FourCCtor::FourCCtor (const FourCCtor &rhs) >>> +{ >>> + x = 4; >>> +} >>> + >>> +FourCCtor::FourCCtor (volatile FourCCtor &rhs) >>> +{ >>> + x = 5; >>> +} >>> + >>> +FourCCtor::FourCCtor (const volatile FourCCtor &rhs) >>> +{ >>> + x = 6; >>> +} >>> + >>> +int >>> +cbvFourCCtor (FourCCtor arg) >>> +{ >>> + arg.x += 10; // intentionally modify >>> + return arg.x; >>> +} >>> + >>> +class TwoMCtor { >>> +public: >>> + TwoMCtor (void); >>> + >>> + /* Even though one move ctor is defaulted, the other >>> + is explicit. */ >>> + TwoMCtor (const TwoMCtor &&rhs); >>> + TwoMCtor (TwoMCtor &&rhs) = default; >>> + >>> + int x; >>> +}; >>> + >>> +TwoMCtor::TwoMCtor (void) >>> +{ >>> + x = 2; >>> +} >>> + >>> +TwoMCtor::TwoMCtor (const TwoMCtor &&rhs) >>> +{ >>> + x = 3; >>> +} >>> + >>> +int >>> +cbvTwoMCtor (TwoMCtor arg) >>> +{ >>> + arg.x += 10; // intentionally modify >>> + return arg.x; >>> +} >>> + >>> +class TwoMCtorAndCCtor { >>> +public: >>> + TwoMCtorAndCCtor (void); >>> + >>> + TwoMCtorAndCCtor (const TwoMCtorAndCCtor &rhs) = default; >>> + >>> + /* Even though one move ctor is defaulted, the other >>> + is explicit. This makes the type pass-by-ref. */ >>> + TwoMCtorAndCCtor (const TwoMCtorAndCCtor &&rhs); >>> + TwoMCtorAndCCtor (TwoMCtorAndCCtor &&rhs) = default; >>> + >>> + int x; >>> +}; >>> + >>> +TwoMCtorAndCCtor::TwoMCtorAndCCtor (void) >>> +{ >>> + x = 2; >>> +} >>> + >>> +TwoMCtorAndCCtor::TwoMCtorAndCCtor (const TwoMCtorAndCCtor &&rhs) >>> +{ >>> + x = 4; >>> +} >>> + >>> +int >>> +cbvTwoMCtorAndCCtor (TwoMCtorAndCCtor arg) >>> +{ >>> + arg.x += 10; // intentionally modify >>> + return arg.x; >>> +} >>> + >>> +ArrayContainerByVal arrayContainerByVal; >>> +ArrayContainerByRef arrayContainerByRef; >>> +Dynamic dynamic; >>> +Inlined inlined; >>> +// Cannot stack-allocate DtorDel >>> +DtorDel *dtorDel; >>> +FourCCtor fourCctor_c0v0; >>> +const FourCCtor fourCctor_c1v0; >>> +volatile FourCCtor fourCctor_c0v1; >>> +const volatile FourCCtor fourCctor_c1v1; >>> +TwoMCtor twoMctor; >>> +TwoMCtorAndCCtor twoMctorAndCctor; >>> + >>> +int >>> +main (void) >>> +{ >>> + int v; >>> + dtorDel = new DtorDel; >>> + /* Explicitly call the cbv function to make sure the compiler >>> + will not omit any code in the binary. */ >>> + v = cbvArrayContainerByVal (arrayContainerByVal); >>> + v = cbvArrayContainerByRef (arrayContainerByRef); >>> + v = cbvDynamic (dynamic); >>> + v = cbvInlined (inlined); >>> + v = cbvFourCCtor (fourCctor_c0v0); >>> + v = cbvFourCCtor (fourCctor_c1v0); >>> + v = cbvFourCCtor (fourCctor_c0v1); >>> + v = cbvFourCCtor (fourCctor_c1v1); >>> + /* v = cbvTwoMCtor (twoMctor); */ // This is illegal, cctor is deleted >>> + v = cbvTwoMCtorAndCCtor (twoMctorAndCctor); >>> + >>> + /* stop here */ >>> + >>> + return 0; >>> +} >>> diff --git a/gdb/testsuite/gdb.cp/pass-by-ref-2.exp b/gdb/testsuite/gdb.cp/pass-by-ref-2.exp >>> new file mode 100644 >>> index 0000000..7cce886 >>> --- /dev/null >>> +++ b/gdb/testsuite/gdb.cp/pass-by-ref-2.exp >>> @@ -0,0 +1,114 @@ >>> +# Copyright 2019 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 . >>> + >>> +# Check that GDB can call C++ functions whose parameters have >>> +# object type, and are either passed by value or implicitly by reference. >>> +# >>> +# This is a companion test to pass-by-ref.exp. In this test, the input >>> +# is manually-written. In pass-by-ref.exp, the test input is generated. >>> +# >>> +# We include tests for classes that >>> +# - contain arrays as fields, >>> +# - are dynamic (i.e. have virtual methods) >>> +# - have inlined copy ctor >>> +# - have deleted destructor >>> + >>> +if {[skip_cplus_tests]} { >>> + untested "c++ test skipped" >>> + continue >>> +} >>> + >>> +standard_testfile .cc >>> + >>> +set options {debug c++ additional_flags=-std=c++11} >>> +if {[prepare_for_testing "failed to prepare" $testfile $srcfile $options]} { >>> + return -1 >>> +} >>> + >>> +if {![runto_main]} { >>> + untested "failed to run to main" >>> + return -1 >>> +} >>> + >>> +set bp_location [gdb_get_line_number "stop here"] >>> +gdb_breakpoint $bp_location >>> +gdb_continue_to_breakpoint "end of main" ".*return .*;" >>> + >>> +gdb_test "print cbvArrayContainerByVal (arrayContainerByVal)" "6" \ >>> + "call cbvArrayContainerByVal" >>> +gdb_test "print arrayContainerByVal.items\[0\].x" "2" \ >>> + "cbv argument 'arrayContainerByVal' should not change" >>> + >>> +gdb_test "print cbvArrayContainerByRef (arrayContainerByRef)" "7" \ >>> + "call cbvArrayContainerByRef" >>> +gdb_test "print arrayContainerByRef.items\[0\].x" "2" \ >>> + "cbv argument 'arrayContainerByRef' should not change" >>> + >>> +gdb_test "print cbvDynamic (dynamic)" "48" \ >>> + "call cbvDynamic" >>> +gdb_test "print dynamic.x" "2" \ >>> + "cbv argument 'dynamic' should not change" >>> + >>> +set sig "\"Inlined\:\:Inlined\\(.*Inlined const\&\\)\"" >>> +gdb_test "print cbvInlined (inlined)" \ >>> + "expression cannot be evaluated .* \\(maybe inlined\\?\\)" >>> + >>> +gdb_test "print cbvDtorDel (*dtorDel)" \ >>> + ".* cannot be evaluated .* 'DtorDel' is not destructible" \ >>> + "type not destructible" >>> + >>> +# Test that GDB calls the correct copy ctor >>> +gdb_test "print cbvFourCCtor (fourCctor_c0v0)" "13" \ >>> + "call cbvFourCCtor (c0v0)" >>> +gdb_test "print fourCctor_c0v0.x" "2" \ >>> + "cbv argument 'twoCctor_c0v0' should not change" >>> + >>> +gdb_test "print cbvFourCCtor (fourCctor_c1v0)" "14" \ >>> + "call cbvFourCCtor (c1v0)" >>> +gdb_test "print fourCctor_c1v0.x" "2" \ >>> + "cbv argument 'twoCctor_c1v0' should not change" >>> + >>> +gdb_test "print cbvFourCCtor (fourCctor_c0v1)" "15" \ >>> + "call cbvFourCCtor (c0v1)" >>> +gdb_test "print fourCctor_c0v1.x" "2" \ >>> + "cbv argument 'twoCctor_c0v1' should not change" >>> + >>> +gdb_test "print cbvFourCCtor (fourCctor_c1v1)" "16" \ >>> + "call cbvFourCCtor (c1v1)" >>> +gdb_test "print fourCctor_c1v1.x" "2" \ >>> + "cbv argument 'twoCctor_c1v1' should not change" >>> + >>> +gdb_test "print cbvTwoMCtor (twoMctor)" \ >>> + ".* cannot be evaluated .* 'TwoMCtor' is not copy constructible" \ >>> + "copy ctor is implicitly deleted" >>> + >>> +gdb_test "print cbvTwoMCtorAndCCtor (twoMctorAndCctor)" "12" \ >>> + "call cbvTwoMCtorAndCCtor" >>> +gdb_test "print twoMctorAndCctor.x" "2" \ >>> + "cbv argument 'twoMctorAndCtor' should not change" >>> + >>> +# Test that we get a breakpoint from the cctor during infcall and >>> +# we can examine arguments. This is a test that the dummy frame >>> +# of the copy constructor is set up correctly by the infcall mechanism. >>> +set bp_location [gdb_get_line_number "ByRef-cctor"] >>> +gdb_breakpoint $bp_location >>> +gdb_test "print cbvArrayContainerByRef (arrayContainerByRef)" \ >>> + ".*The program being debugged stopped.*" \ >>> + "call cbvArrayContainerByRef with BP" >>> +gdb_test "backtrace" [multi_line \ >>> + "#0 ByRef\:\:ByRef .* at .*$srcfile:$bp_location" \ >>> + "#1 .* ArrayContainerByRef::ArrayContainerByRef .*" \ >>> + "#2 " \ >>> + "#3 main.*"] >>> diff --git a/gdb/testsuite/gdb.cp/pass-by-ref.cc b/gdb/testsuite/gdb.cp/pass-by-ref.cc >>> deleted file mode 100644 >>> index bbe450a..0000000 >>> --- a/gdb/testsuite/gdb.cp/pass-by-ref.cc >>> +++ /dev/null >>> @@ -1,79 +0,0 @@ >>> -/* This testcase is part of GDB, the GNU debugger. >>> - >>> - Copyright 2007-2019 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 . */ >>> - >>> -class Obj { >>> -public: >>> - Obj (); >>> - Obj (const Obj &); >>> - ~Obj (); >>> - int var[2]; >>> -}; >>> - >>> -int foo (Obj arg) >>> -{ >>> - return arg.var[0] + arg.var[1]; >>> -} >>> - >>> -Obj::Obj () >>> -{ >>> - var[0] = 1; >>> - var[1] = 2; >>> -} >>> - >>> -Obj::Obj (const Obj &obj) >>> -{ >>> - var[0] = obj.var[0]; >>> - var[1] = obj.var[1]; >>> -} >>> - >>> -Obj::~Obj () >>> -{ >>> - >>> -} >>> - >>> -struct Derived : public Obj >>> -{ >>> - int other; >>> -}; >>> - >>> -int blap (Derived arg) >>> -{ >>> - return foo (arg); >>> -} >>> - >>> -struct Container >>> -{ >>> - Obj obj; >>> -}; >>> - >>> -int blip (Container arg) >>> -{ >>> - return foo (arg.obj); >>> -} >>> - >>> -Obj global_obj; >>> -Derived global_derived; >>> -Container global_container; >>> - >>> -int >>> -main () >>> -{ >>> - int bar = foo (global_obj); >>> - blap (global_derived); >>> - blip (global_container); >>> - return bar; >>> -} >>> diff --git a/gdb/testsuite/gdb.cp/pass-by-ref.exp b/gdb/testsuite/gdb.cp/pass-by-ref.exp >>> index 94dd345..f44be77 100644 >>> --- a/gdb/testsuite/gdb.cp/pass-by-ref.exp >>> +++ b/gdb/testsuite/gdb.cp/pass-by-ref.exp >>> @@ -14,20 +14,395 @@ >>> # along with this program. If not, see . >>> >>> # Check that GDB can call C++ functions whose parameters have >>> -# object type, but are passed by reference. >>> +# object type, and are either passed by value or implicitly by reference. >>> +# >>> +# Suppose F is a function that has a call-by-value parameter whose >>> +# type is class C. When calling F with an argument A, a copy of A should >>> +# be created and passed to F. If C is a trivially-copyable type, A can >>> +# be copied by a straightforward memory copy. However, roughly speaking, >>> +# if C has a user-defined copy constructor and/or a user-defined >>> +# destructor, the copy ctor should be used to initialize the copy of A >>> +# before calling F, and a reference to that copy is passed to F. After >>> +# the function returns, the destructor should be called to destruct the >>> +# copy. In this case, C is said to be a 'pass-by-reference' type. >>> +# Determining whether C is pass-by-ref depends on >>> +# how the copy ctor, destructor, and the move ctor of C are defined. >>> +# First of all, C is not copy constructible if its copy constructor is >>> +# explicitly or implicitly deleted. In this case, it would be illegal >>> +# to pass values of type C to a function. C is pass-by-value, if all of >>> +# its copy ctor, dtor, and move ctor are trivially defined. >>> +# Otherwise, it is pass-by-ref. >>> +# >>> +# To cover the many possible combinations, this test generates classes >>> +# that contain three special functions: >>> +# (1) a copy constructor, >>> +# (2) a destructor, and >>> +# (3) a move constructor. >>> +# A special function is in one of the following states: >>> +# * explicit: The function is explicitly defined by the user. >>> +# * defaultedIn: The function is defaulted inside the class decl, >>> +# using the 'default' keyword. >>> +# * defaultedOut: The function is declared inside the class decl, >>> +# and defaulted outside using the 'default' keyword. >>> +# * deleted: The function is explicitly deleted by the user, >>> +# using the 'delete' keyword. >>> +# * absent: The function is not declared by the user (i.e. it does not >>> +# exist in the source. The compiler generates (or deletes) the >>> +# definition in this case. >>> +# >>> +# The C++ ABI decides if a class is pass-by-value or pass-by-ref >>> +# (i.e. trivially copyable or not) first at the language level, based >>> +# on the state of the special functions. Then, at the target level, a >>> +# class may be determined to be pass-by-ref because of its size >>> +# (e.g. if it is too large to fit on registers). For this reason, this >>> +# test generates both a small and a large version for the same >>> +# combination of special function states. >>> +# >>> +# A class is not trivially-copyable if a base class or a field is not >>> +# trivially-copyable, even though the class definition itself seems >>> +# trivial. To test these cases, we also generate derived classes and >>> +# container classes. >>> +# >>> +# The generated code is placed in the test output directory. >>> +# >>> +# The companion test file pass-by-ref-2.exp also contains >>> +# manually-written cases. >>> >>> -if { [skip_cplus_tests] } { continue } >>> +if {[skip_cplus_tests]} { >>> + untested "c++ test skipped" >>> + continue >>> +} >>> >>> +# The program source is generated in the output directory. >>> +# We use standard_testfile here to set convenience variables. >>> standard_testfile .cc >>> >>> -if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} { >>> +# Some constant values used when generating the source >>> + >>> +set SMALL 2 >>> +set LARGE 150 >>> +set ORIGINAL 2 >>> +set CUSTOM 3 >>> +set ADDED 4 >>> +set TRACE 5 >>> + >>> + >>> +# Return 1 if the class whose special function states are STATES >>> +# is copyable. Otherwise return 0. >>> + >>> +proc is_copy_constructible { states } { >>> + set cctor [lindex $states 0] >>> + set dtor [lindex $states 1] >>> + set mctor [lindex $states 2] >>> + >>> + if {$cctor == "deleted" || ($cctor == "absent" && $mctor != "absent")} { >>> + return 0 >>> + } >>> + return 1 >>> +} >>> + >>> +# Generate a declaration and an out-of-class definition for a function >>> +# with the provided signature. The STATE should be one of the following: >>> +# - explicit, defaultedIn, defaultedOut, deleted, absent >>> + >>> +proc generate_member_function { classname signature length state } { >>> + set declaration "" >>> + set definition "" >>> + >>> + global CUSTOM >>> + global TRACE >>> + >>> + switch $state { >>> + explicit { >>> + set declaration "$signature;\n" >>> + set definition "$classname\:\:$signature >>> + { >>> + data\[0\] = $CUSTOM; >>> + data\[[expr $length - 1]\] = $CUSTOM; >>> + tracer = $TRACE; >>> + }\n" >>> + } >>> + defaultedIn { >>> + set declaration "$signature = default;\n" >>> + } >>> + defaultedOut { >>> + set declaration "$signature;\n" >>> + set definition "$classname\:\:$signature = default;\n" >>> + } >>> + deleted { >>> + set declaration "$signature = delete;\n" >>> + } >>> + default { >>> + # function is not user-defined in this case >>> + } >>> + } >>> + >>> + return [list $declaration $definition] >>> +} >>> + >>> +# Generate a C++ class with the given CLASSNAME and LENGTH-many >>> +# integer elements. The STATES is an array of 3 items >>> +# containing the desired state of the special functions >>> +# in this order: >>> +# copy constructor, destructor, move constructor >>> + >>> +proc generate_class { classname length states } { >>> + set declarations "" >>> + set definitions "" >>> + set classname "${classname}_[join $states _]" >>> + >>> + for {set i 0} {$i < [llength $states]} {incr i} { >>> + set sig "" >>> + switch $i { >>> + 0 {set sig "$classname (const $classname \&rhs)"} >>> + 1 {set sig "\~$classname (void)"} >>> + 2 {set sig "$classname ($classname \&\&rhs)"} >>> + } >>> + >>> + set state [lindex $states $i] >>> + set code [generate_member_function $classname $sig $length $state] >>> + append declarations [lindex $code 0] >>> + append definitions [lindex $code 1] >>> + } >>> + >>> + global ORIGINAL >>> + >>> + return " >>> + /*** C++ class $classname ***/ >>> + class ${classname} { >>> + public: >>> + $classname (void); >>> + $declarations >>> + >>> + int data\[$length\]; >>> + }; >>> + >>> + $classname\:\:$classname (void) >>> + { >>> + data\[0\] = $ORIGINAL; >>> + data\[[expr $length - 1]\] = $ORIGINAL; >>> + } >>> + >>> + $definitions >>> + >>> + $classname ${classname}_var; /* global var */ >>> + >>> + template int cbv<$classname> ($classname arg);" >>> +} >>> + >>> +# Generate a small C++ class >>> + >>> +proc generate_small_class { states } { >>> + global SMALL >>> + return [generate_class Small $SMALL $states]; >>> +} >>> + >>> +# Generate a large C++ class >>> + >>> +proc generate_large_class { states } { >>> + global LARGE >>> + return [generate_class Large $LARGE $states]; >>> +} >>> + >>> +# Generate a class that derives from a small class >>> + >>> +proc generate_derived_class { states } { >>> + set base "Small_[join $states _]" >>> + set classname "Derived_[join $states _]" >>> + >>> + return " >>> + /*** Class derived from $base ***/ >>> + class $classname : public $base { >>> + public: >>> + }; >>> + >>> + $classname ${classname}_var; /* global var */ >>> + >>> + template int cbv<$classname> ($classname arg);" >>> +} >>> + >>> +# Generate a class that contains a small class item >>> + >>> +proc generate_container_class { states } { >>> + set contained "Small_[join $states _]" >>> + set classname "Container_[join $states _]" >>> + >>> + return " >>> + /*** Class that contains $contained ***/ >>> + class $classname { >>> + public: >>> + $contained item; >>> + }; >>> + >>> + $classname ${classname}_var; /* global var */ >>> + >>> + template int cbv_container<$classname> ($classname arg);" >>> +} >>> + >>> +# Generate useful statements that use a class in the debugee program >>> + >>> +proc generate_stmts { classprefix states {cbvfun "cbv"}} { >>> + set classname "${classprefix}_[join $states _]" >>> + >>> + # Having an explicit call to the cbv function in the debugee program >>> + # ensures that the compiler will emit necessary function in the binary. >>> + if {[is_copy_constructible $states]} { >>> + set cbvcall "$cbvfun<$classname> (${classname}_var);\n" >>> + } else { >>> + set cbvcall "" >>> + } >>> + >>> + return "$cbvcall" >>> +} >>> + >>> +# Generate the complete debugee program >>> + >>> +proc generate_program { classes stmts } { >>> + global ADDED >>> + >>> + return " >>> + /*** THIS FILE IS GENERATED BY THE TEST. ***/ >>> + >>> + static int tracer = 0; >>> + >>> + /* The call-by-value function. */ >>> + template >>> + int >>> + cbv (T arg) >>> + { >>> + arg.data\[0\] += $ADDED; // intentionally modify the arg >>> + return arg.data\[0\]; >>> + } >>> + >>> + template >>> + int >>> + cbv_container (T arg) >>> + { >>> + arg.item.data\[0\] += $ADDED; // intentionally modify >>> + return arg.item.data\[0\]; >>> + } >>> + >>> + $classes >>> + >>> + int >>> + main (void) >>> + { >>> + $stmts >>> + >>> + /* stop here */ >>> + >>> + return 0; >>> + }" >>> +} >>> + >>> +# Compute all the combinations of special function states. >>> +# We do not contain the 'deleted' state for the destructor, >>> +# because it is illegal to have stack-allocated objects >>> +# whose destructor have been deleted. This case is covered >>> +# in pass-by-ref-2 via heap-allocated objects. >>> + >>> +set options_nodelete [list absent explicit defaultedIn defaultedOut] >>> +set options [concat $options_nodelete {deleted}] >>> +set all_combinations {} >>> + >>> +foreach cctor $options { >>> + foreach dtor $options_nodelete { >>> + foreach mctor $options { >>> + lappend all_combinations [list $cctor $dtor $mctor] >>> + } >>> + } >>> +} >>> + >>> +# Generate the classes. >>> + >>> +set classes "" >>> +set stmts "" >>> + >>> +foreach state $all_combinations { >>> + append classes [generate_small_class $state] >>> + append stmts [generate_stmts "Small" $state] >>> + >>> + append classes [generate_large_class $state] >>> + append stmts [generate_stmts "Large" $state] >>> + >>> + append classes [generate_derived_class $state] >>> + append stmts [generate_stmts "Derived" $state] >>> + >>> + append classes [generate_container_class $state] >>> + append stmts [generate_stmts "Container" $state "cbv_container"] >>> +} >>> + >>> +# Generate the program code and compile >>> +set program [generate_program $classes $stmts] >>> +set srcfile [standard_output_file ${srcfile}] >>> +gdb_produce_source $srcfile $program >>> + >>> +set options {debug c++ additional_flags=-std=c++11} >>> +if {[prepare_for_testing "failed to prepare" $testfile $srcfile $options]} { >>> return -1 >>> } >>> >>> -if ![runto_main] then { >>> +if {![runto_main]} { >>> + untested "failed to run to main" >>> return -1 >>> } >>> >>> -gdb_test "print foo (global_obj)" " = 3" "call function in obj" >>> -gdb_test "print blap (global_derived)" " = 3" "call function in derived" >>> -gdb_test "print blip (global_container)" " = 3" "call function in container" >>> +set bp_location [gdb_get_line_number "stop here"] >>> +gdb_breakpoint $bp_location >>> +gdb_continue_to_breakpoint "end of main" ".*return .*;" >>> + >>> +# Do the checks for a given class whose name is prefixed with PREFIX, >>> +# and whose special functions have the states given in STATES. >>> +# The name of the call-by-value function and the expression to access >>> +# the data field can be specified explicitly if the default values >>> +# do not work. >>> + >>> +proc test_for_class { prefix states cbvfun data_field length} { >>> + set name "${prefix}_[join $states _]" >>> + >>> + set cctor [lindex $states 0] >>> + set dtor [lindex $states 1] >>> + set mctor [lindex $states 2] >>> + >>> + global ORIGINAL >>> + global CUSTOM >>> + global ADDED >>> + global TRACE >>> + >>> + with_test_prefix $name { >>> + if {[is_copy_constructible $states]} { >>> + set expected [expr {$ORIGINAL + $ADDED}] >>> + if {$cctor == "explicit"} { >>> + set expected [expr {$CUSTOM + $ADDED}] >>> + } >>> + if {$dtor == "explicit"} { >>> + gdb_test "print tracer = 0" " = 0" "reset the tracer" >>> + } >>> + gdb_test "print ${cbvfun}<$name> (${name}_var)" " = $expected" \ >>> + "call '$cbvfun'" >>> + gdb_test "print ${name}_var.${data_field}\[0\]" " = $ORIGINAL" \ >>> + "cbv argument should not change (item 0)" >>> + if {$length > 1} { >>> + set last_index [expr $length - 1] >>> + gdb_test "print ${name}_var.${data_field}\[$last_index\]" \ >>> + " = $ORIGINAL" \ >>> + "cbv argument should not change (item $last_index)" >>> + } >>> + if {$dtor == "explicit"} { >>> + gdb_test "print tracer" " = $TRACE" \ >>> + "destructor should be called" >>> + } >>> + } else { >>> + gdb_test "print ${cbvfun}<$name> (${name}_var)" \ >>> + ".* cannot be evaluated .* '${name}' is not copy constructible" \ >>> + "calling '$cbvfun' should be refused" >>> + } >>> + } >>> +} >>> + >>> +foreach state $all_combinations { >>> + test_for_class "Small" $state "cbv" "data" $SMALL >>> + test_for_class "Large" $state "cbv" "data" $LARGE >>> + test_for_class "Derived" $state "cbv" "data" 1 >>> + test_for_class "Container" $state "cbv_container" "item.data" 1 >>> +} >>> > Intel Deutschland GmbH > Registered Address: Am Campeon 10-12, 85579 Neubiberg, Germany > Tel: +49 89 99 8853-0, www.intel.de > Managing Directors: Christin Eisenschmid, Gary Kershaw > Chairperson of the Supervisory Board: Nicole Lau > Registered Office: Munich > Commercial Register: Amtsgericht Muenchen HRB 186928 >