From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 105242 invoked by alias); 17 Jan 2017 14:23:07 -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 105144 invoked by uid 89); 17 Jan 2017 14:23:06 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.5 required=5.0 tests=AWL,BAYES_00,KAM_LOTSOFHASH,MIME_BASE64_BLANKS,RCVD_IN_DNSWL_NONE,SPF_HELO_PASS,SPF_PASS,URIBL_RED autolearn=no version=3.3.2 spammy=Hayward, hayward, alanhaywardarmcom, sk:alanha X-HELO: EUR01-HE1-obe.outbound.protection.outlook.com Received: from mail-he1eur01on0080.outbound.protection.outlook.com (HELO EUR01-HE1-obe.outbound.protection.outlook.com) (104.47.0.80) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 17 Jan 2017 14:22:56 +0000 Received: from VI1PR0801MB1822.eurprd08.prod.outlook.com (10.168.68.7) by VI1PR0801MB1823.eurprd08.prod.outlook.com (10.168.68.8) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P384) id 15.1.829.7; Tue, 17 Jan 2017 14:22:52 +0000 Received: from VI1PR0801MB1822.eurprd08.prod.outlook.com ([10.168.68.7]) by VI1PR0801MB1822.eurprd08.prod.outlook.com ([10.168.68.7]) with mapi id 15.01.0845.013; Tue, 17 Jan 2017 14:22:52 +0000 From: Alan Hayward To: Luis Machado CC: "gdb-patches@sourceware.org" , nd Subject: Re: [PATCH 3/3] Calculate max register size Date: Tue, 17 Jan 2017 14:23:00 -0000 Message-ID: References: <000B14E8-6B46-4C03-B70F-CC5E50BCFBCF@arm.com> In-Reply-To: authentication-results: spf=none (sender IP is ) smtp.mailfrom=Alan.Hayward@arm.com; x-ms-exchange-messagesentrepresentingtype: 1 x-ms-office365-filtering-correlation-id: 9ce918f2-96c6-4a19-f449-08d43ee452c1 x-microsoft-antispam: UriScan:;BCL:0;PCL:0;RULEID:(22001);SRVR:VI1PR0801MB1823; x-microsoft-exchange-diagnostics: 1;VI1PR0801MB1823;7:dL2ddeJi9kxabTF7i8VTJ6jOHzh+csY/yiuPKMwPykcZ2XT+t0aLQ+Q9aiAG2n28iN/XL4FAOL+YPUgXINf9atbQIR4TUb3cGePFfs5OlTs0vF7w9hJRPaQ34SN424UwnpVeYtrkKrjRx5rmgUqo/areR6b2hZ7PlIi3K8WdD994NU1l6gjgrxCh/5Gd6nc733qUnJw8Pg+ZEl/tUupYWtZcX6vrbLnAC+Z+R8n7hVDWtNfnkrEBzvOFFSXroOFgP4GRcFPC7IQNTD3GB/YHim1cGPz04CsMDBHDlAWu+EnprURGIcjjIGlMJH8/RsxscUA6vpLvgGErJcxzUA8Pmm5Pr4vHBNfTJ7P5h/9LR0ZzMnPRTcupLQhcnHw9EI5fCcOJueVhZEzByNVUDefoUr+4OsxP34PVHweGqmbzahlcxKgKRqUfEXPko0Ihhk7NcsWb6ro09OeWuYt80dCHCQ== nodisclaimer: True x-microsoft-antispam-prvs: x-exchange-antispam-report-test: UriScan:(180628864354917); x-exchange-antispam-report-cfa-test: BCL:0;PCL:0;RULEID:(6040375)(601004)(2401047)(5005006)(8121501046)(3002001)(10201501046)(6055026)(6041248)(20161123562025)(20161123555025)(20161123564025)(20161123560025)(6072148);SRVR:VI1PR0801MB1823;BCL:0;PCL:0;RULEID:;SRVR:VI1PR0801MB1823; x-forefront-prvs: 01901B3451 x-forefront-antispam-report: SFV:NSPM;SFS:(10009020)(6009001)(7916002)(39840400002)(39410400002)(39860400002)(39450400003)(39850400002)(24454002)(199003)(189002)(377424004)(377454003)(33656002)(6506006)(101416001)(189998001)(77096006)(76176999)(25786008)(54356999)(50986999)(6436002)(68736007)(305945005)(105586002)(106116001)(106356001)(99286003)(7736002)(97736004)(575784001)(86362001)(54906002)(229853002)(92566002)(38730400001)(36756003)(81156014)(8676002)(81166006)(122556002)(66066001)(4326007)(110136003)(6512007)(6486002)(82746002)(2906002)(3280700002)(3846002)(6116002)(2900100001)(6916009)(5660300001)(102836003)(2950100002)(83716003)(30001)(3660700001)(8936002)(104396002);DIR:OUT;SFP:1101;SCL:1;SRVR:VI1PR0801MB1823;H:VI1PR0801MB1822.eurprd08.prod.outlook.com;FPR:;SPF:None;PTR:InfoNoRecords;A:1;MX:1;LANG:en; received-spf: None (protection.outlook.com: arm.com does not designate permitted sender hosts) spamdiagnosticoutput: 1:99 spamdiagnosticmetadata: NSPM Content-Type: text/plain; charset="utf-8" Content-ID: <3BB3A342DB16CC459F4787B45A6E3474@eurprd08.prod.outlook.com> Content-Transfer-Encoding: base64 MIME-Version: 1.0 X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-originalarrivaltime: 17 Jan 2017 14:22:52.6119 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: f34e5979-57d9-4aaa-ad4d-b122a662184d X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI1PR0801MB1823 X-SW-Source: 2017-01/txt/msg00323.txt.bz2 SSBhdHRlbXB0ZWQgdG8gY2hhbmdlIG1heF9yZWdpc3Rlcl9zaXplIHRvIHVu c2lnbmVkIGxvbmcuDQpIb3dldmVyLCB0aGlzIGNhdXNlZCBmYWlsdXJlcyBk dWUgdG8gYSB0eXBlIG1pc21hdGNoIHdoZW4gY2FsbGluZyBzdGQ6Om1heC4N ClRoaXMgcmVxdWlyZWQgdXBkYXRpbmcgc2l6ZW9mX3JlZ2lzdGVyIGluIHJl Z2NhY2hlX2Rlc2NyIHRvIHVuc2lnbmVkLCBhbmQNCmZvciBjb25zaXN0ZW5j eSwgdXBkYXRlZCB0aGUgcmVzdCBvZiB0aGUgcmVnY2FjaGVfZGVzY3IgdG8g dXNlIHVuc2lnbmVkLg0KVGhpcyB0aGVuIGNhdXNlZCBhIGNoYWluIG9mIHNt YWxsIGNoYW5nZXMsIHdoaWNoIGxlYWtlZCBpbnRvIHF1aXRlIGEgZmV3DQpv dGhlciBmaWxlcyAoaW5jbHVkaW5nIGdkYnNlcnZlcikuDQpJIHRoaW5rIHJl Z2NhY2hlX2Rlc2NyIHNob3VsZCBiZSB1cGRhdGVkIHRvIHVzZSB1bnNpZ25l ZCB0eXBlcyBhcyBwYXJ0IG9mDQphIHNlcGFyYXRlIHBhdGNoLCBhbmQgbm90 IGluIHRoaXMgcGF0Y2guDQoNCkkgZGlkIG5vdCBhZGQgYSBjaGVjayBmb3Ig bnVsbCBkZXNjciBpbiBtYXhfcmVnaXN0ZXJfc2l6ZSgpIC0NCmdkYmFyY2gu YyBlbnN1cmVzIGV2ZXJ5dGhpbmcgaXMgaW5pdGlhbGlzZWQuIEFsc28sIE5v bmUgb2YgdGhlIG90aGVyDQpmdW5jdGlvbnMgaW4gdGhpcyBmaWxlIGV2ZXIg Y2hlY2sgZGVzY3IgZm9yIG51bGwuDQoNCkluIHRoZSBlbmQsIHRoZSBvbmx5 IGNoYW5nZSBhZ2FpbnN0IHRoZSBwcmV2aW91cyB2ZXJzaW9uIGlzIHRvIHJl bW92ZSBhDQpzcHVyaW91cyBuZXdsaW5lDQoNCk9rIHRvIGNvbW1pdD8NCkFs c28sIGFyZSBwZW9wbGUgaGFwcHkgd2l0aCB0aGUgY29tbWVudHMgaW4gcGF0 Y2ggMi8zID8NCg0KDQoyMDE3LTAxLTE3ICBBbGFuIEhheXdhcmQgPGFsYW4u aGF5d2FyZEBhcm0uY29tPg0KDQogICAgICAgKiByZWdjYWNoZS5jIChzdHJ1 Y3QgcmVnY2FjaGVfZGVzY3IpOiBBZGQgbWF4X3JlZ2lzdGVyX3NpemUuDQog ICAgICAgKG1heF9yZWdpc3Rlcl9zaXplKTogTmV3Lg0KICAgICAgIChpbml0 X3JlZ2NhY2hlX2Rlc2NyKTogRmluZCBtYXggcmVnaXN0ZXIgc2l6ZS4NCiAg ICAgICAocmVnY2FjaGVfc2F2ZSk6IFVzZSBtYXhfcmVnaXN0ZXJfc2l6ZS4N CiAgICAgICAocmVnY2FjaGVfcmVzdG9yZSk6IExpa2V3aXNlLg0KICAgICAg IChyZWdjYWNoZV9kdW1wKTogTGlrZXdpc2UuDQogICAgICAgKiByZWdjYWNo ZS5oIChtYXhfcmVnaXN0ZXJfc2l6ZSk6IE5ldy4NCiAgICAgICAqIHJlbW90 ZS5jIChyZW1vdGVfcHJlcGFyZV90b19zdG9yZSk6IEFsbG9jYXRlIGJ1ZmZl ci4NCg0KDQpkaWZmIC0tZ2l0IGEvZ2RiL3JlZ2NhY2hlLmggYi9nZGIvcmVn Y2FjaGUuaA0KaW5kZXggZTVhN2NmNTUzMjc5YjhjYzBkNTQ2ZWMxYjgyNzRj YmY5N2UyNDZkNS4uNWJjOTlmNWMxZWY4NzMxOGVkZjRlOTM0ZWM2MGM3ZjEy MjVlNzU2MSAxMDA2NDQNCi0tLSBhL2dkYi9yZWdjYWNoZS5oDQorKysgYi9n ZGIvcmVnY2FjaGUuaA0KQEAgLTIwMiw2ICsyMDIsOCBAQCBleHRlcm4gc3Ry dWN0IHR5cGUgKnJlZ2lzdGVyX3R5cGUgKHN0cnVjdCBnZGJhcmNoICpnZGJh cmNoLCBpbnQgcmVnbnVtKTsNCg0KZXh0ZXJuIGludCByZWdpc3Rlcl9zaXpl IChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgaW50IHJlZ251bSk7DQoNCisv KiBSZXR1cm4gdGhlIHNpemUgb2YgdGhlIGxhcmdlc3QgcmVnaXN0ZXIuICAq Lw0KK2V4dGVybiBsb25nIG1heF9yZWdpc3Rlcl9zaXplIChzdHJ1Y3QgZ2Ri YXJjaCAqZ2RiYXJjaCk7DQoNCi8qIFNhdmUvcmVzdG9yZSBhIHJlZ2lzdGVy IGNhY2hlLiAgVGhlIHNldCBvZiByZWdpc3RlcnMgc2F2ZWQgLw0KICAgcmVz dG9yZWQgaW50byB0aGUgRFNUIHJlZ2NhY2hlIGRldGVybWluZWQgYnkgdGhl IHNhdmVfcmVnZ3JvdXAgLw0KZGlmZiAtLWdpdCBhL2dkYi9yZWdjYWNoZS5j IGIvZ2RiL3JlZ2NhY2hlLmMNCmluZGV4IDlkMjhhYTJjMjExNGUwZjFjNTI3 NThiYjJmYmU5NjY5YTMyOWMxM2UuLjFjZGMwNjA0ZmYyNjExMGRmNGRlMWFi NDY5ZDJmZTYyM2Y5MThiM2QgMTAwNjQ0DQotLS0gYS9nZGIvcmVnY2FjaGUu Yw0KKysrIGIvZ2RiL3JlZ2NhY2hlLmMNCkBAIC03Myw2ICs3Myw5IEBAIHN0 cnVjdCByZWdjYWNoZV9kZXNjcg0KDQogIC8qIENhY2hlZCB0YWJsZSBjb250 YWluaW5nIHRoZSB0eXBlIG9mIGVhY2ggcmVnaXN0ZXIuICAqLw0KICBzdHJ1 Y3QgdHlwZSAqKnJlZ2lzdGVyX3R5cGU7DQorDQorICAvKiBTaXplIG9mIHRo ZSBsYXJnZXN0IHJlZ2lzdGVyLiAgKi8NCisgIGxvbmcgbWF4X3JlZ2lzdGVy X3NpemU7DQp9Ow0KDQpzdGF0aWMgdm9pZCAqDQpAQCAtMTI2LDYgKzEyOSw4 IEBAIGluaXRfcmVnY2FjaGVfZGVzY3IgKHN0cnVjdCBnZGJhcmNoICpnZGJh cmNoKQ0KICAgICAgICBkZXNjci0+cmVnaXN0ZXJfb2Zmc2V0W2ldID0gb2Zm c2V0Ow0KICAgICAgICBvZmZzZXQgKz0gZGVzY3ItPnNpemVvZl9yZWdpc3Rl cltpXTsNCiAgICAgICAgZ2RiX2Fzc2VydCAoTUFYX1JFR0lTVEVSX1NJWkUg Pj0gZGVzY3ItPnNpemVvZl9yZWdpc3RlcltpXSk7DQorICAgICAgIGRlc2Ny LT5tYXhfcmVnaXN0ZXJfc2l6ZSA9IHN0ZDo6bWF4IChkZXNjci0+bWF4X3Jl Z2lzdGVyX3NpemUsDQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBkZXNjci0+c2l6ZW9mX3JlZ2lzdGVyW2ldKTsNCiAg ICAgIH0NCiAgICAvKiBTZXQgdGhlIHJlYWwgc2l6ZSBvZiB0aGUgcmF3IHJl Z2lzdGVyIGNhY2hlIGJ1ZmZlci4gICovDQogICAgZGVzY3ItPnNpemVvZl9y YXdfcmVnaXN0ZXJzID0gb2Zmc2V0Ow0KQEAgLTEzNiw2ICsxNDEsOCBAQCBp bml0X3JlZ2NhY2hlX2Rlc2NyIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCkN CiAgICAgICAgZGVzY3ItPnJlZ2lzdGVyX29mZnNldFtpXSA9IG9mZnNldDsN CiAgICAgICAgb2Zmc2V0ICs9IGRlc2NyLT5zaXplb2ZfcmVnaXN0ZXJbaV07 DQogICAgICAgIGdkYl9hc3NlcnQgKE1BWF9SRUdJU1RFUl9TSVpFID49IGRl c2NyLT5zaXplb2ZfcmVnaXN0ZXJbaV0pOw0KKyAgICAgICBkZXNjci0+bWF4 X3JlZ2lzdGVyX3NpemUgPSBzdGQ6Om1heCAoZGVzY3ItPm1heF9yZWdpc3Rl cl9zaXplLA0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgZGVzY3ItPnNpemVvZl9yZWdpc3RlcltpXSk7DQogICAgICB9 DQogICAgLyogU2V0IHRoZSByZWFsIHNpemUgb2YgdGhlIHJlYWRvbmx5IHJl Z2lzdGVyIGNhY2hlIGJ1ZmZlci4gICovDQogICAgZGVzY3ItPnNpemVvZl9j b29rZWRfcmVnaXN0ZXJzID0gb2Zmc2V0Ow0KQEAgLTE4Nyw2ICsxOTQsMTMg QEAgcmVnY2FjaGVfcmVnaXN0ZXJfc2l6ZSAoY29uc3Qgc3RydWN0IHJlZ2Nh Y2hlICpyZWdjYWNoZSwgaW50IG4pDQogIHJldHVybiByZWdpc3Rlcl9zaXpl IChnZXRfcmVnY2FjaGVfYXJjaCAocmVnY2FjaGUpLCBuKTsNCn0NCg0KK2xv bmcNCittYXhfcmVnaXN0ZXJfc2l6ZSAoc3RydWN0IGdkYmFyY2ggKmdkYmFy Y2gpDQorew0KKyAgc3RydWN0IHJlZ2NhY2hlX2Rlc2NyICpkZXNjciA9IHJl Z2NhY2hlX2Rlc2NyIChnZGJhcmNoKTsNCisgIHJldHVybiBkZXNjci0+bWF4 X3JlZ2lzdGVyX3NpemU7DQorfQ0KKw0KLyogVGhlIHJlZ2lzdGVyIGNhY2hl IGZvciBzdG9yaW5nIHJhdyByZWdpc3RlciB2YWx1ZXMuICAqLw0KDQpzdHJ1 Y3QgcmVnY2FjaGUNCkBAIC0zMjcsNyArMzQxLDcgQEAgcmVnY2FjaGVfc2F2 ZSAoc3RydWN0IHJlZ2NhY2hlICpkc3QsIHJlZ2NhY2hlX2Nvb2tlZF9yZWFk X2Z0eXBlICpjb29rZWRfcmVhZCwNCiAgICAgICAgICAgICAgIHZvaWQgKnNy YykNCnsNCiAgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2ggPSBkc3QtPmRlc2Ny LT5nZGJhcmNoOw0KLSAgZ2RiX2J5dGUgYnVmW01BWF9SRUdJU1RFUl9TSVpF XTsNCisgIGdkYl9ieXRlICpidWYgPSAoZ2RiX2J5dGUgKikgYWxsb2NhICht YXhfcmVnaXN0ZXJfc2l6ZSAoZ2RiYXJjaCkpOw0KICBpbnQgcmVnbnVtOw0K DQogIC8qIFRoZSBEU1Qgc2hvdWxkIGJlIGByZWFkLW9ubHknLCBpZiBpdCB3 YXNuJ3QgdGhlbiB0aGUgc2F2ZSB3b3VsZA0KQEAgLTM2OSw3ICszODMsNyBA QCByZWdjYWNoZV9yZXN0b3JlIChzdHJ1Y3QgcmVnY2FjaGUgKmRzdCwNCiAg ICAgICAgICAgICAgICAgIHZvaWQgKmNvb2tlZF9yZWFkX2NvbnRleHQpDQp7 DQogIHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoID0gZHN0LT5kZXNjci0+Z2Ri YXJjaDsNCi0gIGdkYl9ieXRlIGJ1ZltNQVhfUkVHSVNURVJfU0laRV07DQor ICBnZGJfYnl0ZSAqYnVmID0gKGdkYl9ieXRlICopIGFsbG9jYSAobWF4X3Jl Z2lzdGVyX3NpemUgKGdkYmFyY2gpKTsNCiAgaW50IHJlZ251bTsNCg0KICAv KiBUaGUgZHN0IGhhZCBiZXR0ZXIgbm90IGJlIHJlYWQtb25seS4gIElmIGl0 IGlzLCB0aGUgYHJlc3RvcmUnDQpAQCAtMTI3OSw3ICsxMjkzLDcgQEAgcmVn Y2FjaGVfZHVtcCAoc3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZSwgc3RydWN0 IHVpX2ZpbGUgKmZpbGUsDQogIGludCBmb290bm90ZV9yZWdpc3Rlcl9vZmZz ZXQgPSAwOw0KICBpbnQgZm9vdG5vdGVfcmVnaXN0ZXJfdHlwZV9uYW1lX251 bGwgPSAwOw0KICBsb25nIHJlZ2lzdGVyX29mZnNldCA9IDA7DQotICBnZGJf Ynl0ZSBidWZbTUFYX1JFR0lTVEVSX1NJWkVdOw0KKyAgZ2RiX2J5dGUgKmJ1 ZiA9IChnZGJfYnl0ZSAqKSBhbGxvY2EgKG1heF9yZWdpc3Rlcl9zaXplIChn ZGJhcmNoKSk7DQoNCiNpZiAwDQogIGZwcmludGZfdW5maWx0ZXJlZCAoZmls ZSwgIm5yX3Jhd19yZWdpc3RlcnMgJWRcbiIsDQpkaWZmIC0tZ2l0IGEvZ2Ri L3JlbW90ZS5jIGIvZ2RiL3JlbW90ZS5jDQppbmRleCA5MjQ3ZDQzYjA5NDky NWZmMzk3ZWIzNmI0NTBlYWJhNTIxYWRmYzk5Li44Njg1NmU2YTZhYmExOTY3 ZmFhYThlZjU0N2Y4YTQ4ZmNjNjNjMzgzIDEwMDY0NA0KLS0tIGEvZ2RiL3Jl bW90ZS5jDQorKysgYi9nZGIvcmVtb3RlLmMNCkBAIC03NzUyLDkgKzc3NTIs MTAgQEAgcmVtb3RlX2ZldGNoX3JlZ2lzdGVycyAoc3RydWN0IHRhcmdldF9v cHMgKm9wcywNCnN0YXRpYyB2b2lkDQpyZW1vdGVfcHJlcGFyZV90b19zdG9y ZSAoc3RydWN0IHRhcmdldF9vcHMgKnNlbGYsIHN0cnVjdCByZWdjYWNoZSAq cmVnY2FjaGUpDQp7DQorICBzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCA9IGdl dF9yZWdjYWNoZV9hcmNoIChyZWdjYWNoZSk7DQogIHN0cnVjdCByZW1vdGVf YXJjaF9zdGF0ZSAqcnNhID0gZ2V0X3JlbW90ZV9hcmNoX3N0YXRlICgpOw0K ICBpbnQgaTsNCi0gIGdkYl9ieXRlIGJ1ZltNQVhfUkVHSVNURVJfU0laRV07 DQorICBnZGJfYnl0ZSAqYnVmID0gKGdkYl9ieXRlICopIGFsbG9jYSAobWF4 X3JlZ2lzdGVyX3NpemUgKGdkYmFyY2gpKTsNCg0KICAvKiBNYWtlIHN1cmUg dGhlIGVudGlyZSByZWdpc3RlcnMgYXJyYXkgaXMgdmFsaWQuICAqLw0KICBz d2l0Y2ggKHBhY2tldF9zdXBwb3J0IChQQUNLRVRfUCkpDQoNCkFsYW4uDQoN Cg0KPiBPbiAxMCBKYW4gMjAxNywgYXQgMTM6NTAsIEFsYW4gSGF5d2FyZCA8 QWxhbi5IYXl3YXJkQGFybS5jb20+IHdyb3RlOg0KPiANCj4gDQo+PiBPbiA5 IEphbiAyMDE3LCBhdCAyMDoxNCwgTHVpcyBNYWNoYWRvIDxsZ3VzdGF2b0Bj b2Rlc291cmNlcnkuY29tPiB3cm90ZToNCj4+IA0KPj4gT24gMDEvMDkvMjAx NyAwNDo1OCBBTSwgQWxhbiBIYXl3YXJkIHdyb3RlOg0KPj4+IEFhcmNoNjQg U1ZFIHJlcXVpcmVzIGEgbWF4IHJlZ2lzdGVyIHNpemUgb2YgMjU2LiBUaGUg Y3VycmVudCBtYXggc2l6ZSBpbiBnZGINCj4+PiBpcyA2NC4gVGhpcyBpcyBw YXJ0IG9mIGEgc2VyaWVzIGRlbW9uc3RyYXRpbmcgdGhlIHJlcGxhY2VtZW50 IG9mDQo+Pj4gTUFYX1JFR0lTVEVSX1NJWkUuDQo+Pj4gDQo+Pj4gSW4gY2Fz ZXMgd2hlcmUgYSBidWZmZXIgaXMgY3JlYXRlZCB0byBiZSB1c2VkIG11bHRp cGxlIHRpbWVzIHRvIGhvbGQgZGlmZmVyZW50DQo+Pj4gcmVnaXN0ZXJzLCB0 aGVuIHRoZSBtYXhpbXVtIHJlZ2lzdGVyIHNpemUgaXMgcmVxdWlyZWQuIEFk ZCBhIG1heCByZWdpc3RlciB2YWx1ZQ0KPj4+IHRvIHRoZSByZWdjYWNoZSB3 aGljaCBpcyBjYWxjdWxhdGVkIG9uIGluaXRpYWxpemF0aW9uLg0KPj4+IA0K Pj4+IFRoaXMgcGF0Y2ggaXMgcmVzdHJpY3RlZCB0byByZW1vdGUuYyBhbmQg cmVnY2FjaGUuYy4NCj4+PiBGb2xsb3cgb24gcGF0Y2hlcyB3aWxsIGV4cGFu ZCB0byBvdGhlciBmaWxlcy4NCj4+PiANCj4+PiBUZXN0ZWQgb24geDg2Lg0K Pj4+IE9rIHRvIGNvbW1pdD8NCj4+PiANCj4+PiBUaGFua3MsDQo+Pj4gQWxh bi4NCj4+PiANCj4+PiAyMDE3LTAxLTA5ICBBbGFuIEhheXdhcmQgPGFsYW4u aGF5d2FyZEBhcm0uY29tPg0KPj4+IA0KPj4+IAkqIHJlZ2NhY2hlLmMgKHN0 cnVjdCByZWdjYWNoZV9kZXNjcik6IEFkZCBtYXhfcmVnaXN0ZXJfc2l6ZQ0K Pj4+IAkobWF4X3JlZ2lzdGVyX3NpemUpOiBOZXcuDQo+Pj4gCShpbml0X3Jl Z2NhY2hlX2Rlc2NyKTogRmluZCBtYXggcmVnaXN0ZXIgc2l6ZS4NCj4+PiAJ KHJlZ2NhY2hlX3NhdmUpOiBVc2UgbWF4X3JlZ2lzdGVyX3NpemUuDQo+Pj4g CShyZWdjYWNoZV9yZXN0b3JlKTogTGlrZXdpc2UuDQo+Pj4gCShyZWdjYWNo ZV9kdW1wKTogTGlrZXdpc2UuDQo+Pj4gCSogcmVnY2FjaGUuaCAobWF4X3Jl Z2lzdGVyX3NpemUpOiBOZXcuDQo+Pj4gCSogcmVtb3RlLmMgKHJlbW90ZV9w cmVwYXJlX3RvX3N0b3JlKTogQWxsb2NhdGUgYnVmZmVyLg0KPj4+IA0KPj4+ IA0KPj4+IGRpZmYgLS1naXQgYS9nZGIvcmVnY2FjaGUuaCBiL2dkYi9yZWdj YWNoZS5oDQo+Pj4gaW5kZXggZTVhN2NmNTUzMjc5YjhjYzBkNTQ2ZWMxYjgy NzRjYmY5N2UyNDZkNS4uNGRiOTUxN2E5ZGQ0NjRkOWM0M2JlMmFmMDU3M2I3 NjdiODZiZmI1NiAxMDA2NDQNCj4+PiAtLS0gYS9nZGIvcmVnY2FjaGUuaA0K Pj4+ICsrKyBiL2dkYi9yZWdjYWNoZS5oDQo+Pj4gQEAgLTIwMiw2ICsyMDIs OSBAQCBleHRlcm4gc3RydWN0IHR5cGUgKnJlZ2lzdGVyX3R5cGUgKHN0cnVj dCBnZGJhcmNoICpnZGJhcmNoLCBpbnQgcmVnbnVtKTsNCj4+PiANCj4+PiBl eHRlcm4gaW50IHJlZ2lzdGVyX3NpemUgKHN0cnVjdCBnZGJhcmNoICpnZGJh cmNoLCBpbnQgcmVnbnVtKTsNCj4+PiANCj4+PiArLyogUmV0dXJuIHRoZSBz aXplIG9mIHRoZSBsYXJnZXN0IHJlZ2lzdGVyLiAgKi8NCj4+PiArDQo+PiAN Cj4+IFNwdXJpb3VzIG5ld2xpbmUuDQo+IA0KPiBPay4NCj4gDQo+PiANCj4+ PiArZXh0ZXJuIGxvbmcgbWF4X3JlZ2lzdGVyX3NpemUgKHN0cnVjdCBnZGJh cmNoICpnZGJhcmNoKTsNCj4+PiANCj4+PiAvKiBTYXZlL3Jlc3RvcmUgYSBy ZWdpc3RlciBjYWNoZS4gIFRoZSBzZXQgb2YgcmVnaXN0ZXJzIHNhdmVkIC8N Cj4+PiAgIHJlc3RvcmVkIGludG8gdGhlIERTVCByZWdjYWNoZSBkZXRlcm1p bmVkIGJ5IHRoZSBzYXZlX3JlZ2dyb3VwIC8NCj4+PiBkaWZmIC0tZ2l0IGEv Z2RiL3JlZ2NhY2hlLmMgYi9nZGIvcmVnY2FjaGUuYw0KPj4+IGluZGV4IDlk MjhhYTJjMjExNGUwZjFjNTI3NThiYjJmYmU5NjY5YTMyOWMxM2UuLjQ2ZDAx N2M3YjJhYmNiMThjOWNkZGEwMDU3NDkwNzEzMjg3MzVkYmQgMTAwNjQ0DQo+ Pj4gLS0tIGEvZ2RiL3JlZ2NhY2hlLmMNCj4+PiArKysgYi9nZGIvcmVnY2Fj aGUuYw0KPj4+IEBAIC03Myw2ICs3Myw5IEBAIHN0cnVjdCByZWdjYWNoZV9k ZXNjcg0KPj4+IA0KPj4+ICAvKiBDYWNoZWQgdGFibGUgY29udGFpbmluZyB0 aGUgdHlwZSBvZiBlYWNoIHJlZ2lzdGVyLiAgKi8NCj4+PiAgc3RydWN0IHR5 cGUgKipyZWdpc3Rlcl90eXBlOw0KPj4+ICsNCj4+PiArICAvKiBTaXplIG9m IHRoZSBsYXJnZXN0IHJlZ2lzdGVyLiAgKi8NCj4+PiArICBsb25nIG1heF9y ZWdpc3Rlcl9zaXplOw0KPj4gDQo+PiBJcyB0aGlzIGV2ZXIgbmVnYXRpdmU/ IFdoeSBub3QgbWFrZSBpdCB1bnNpZ25lZD8NCj4gDQo+IFNob3VsZCBuZXZl ciBiZSBuZWdhdGl2ZS4gV2lsbCBjaGFuZ2UuDQo+IA0KPj4gDQo+Pj4gfTsN Cj4+PiANCj4+PiBzdGF0aWMgdm9pZCAqDQo+Pj4gQEAgLTEyNSw3ICsxMjgs OSBAQCBpbml0X3JlZ2NhY2hlX2Rlc2NyIChzdHJ1Y3QgZ2RiYXJjaCAqZ2Ri YXJjaCkNCj4+PiAJZGVzY3ItPnNpemVvZl9yZWdpc3RlcltpXSA9IFRZUEVf TEVOR1RIIChkZXNjci0+cmVnaXN0ZXJfdHlwZVtpXSk7DQo+Pj4gCWRlc2Ny LT5yZWdpc3Rlcl9vZmZzZXRbaV0gPSBvZmZzZXQ7DQo+Pj4gCW9mZnNldCAr PSBkZXNjci0+c2l6ZW9mX3JlZ2lzdGVyW2ldOw0KPj4+IC0JZ2RiX2Fzc2Vy dCAoTUFYX1JFR0lTVEVSX1NJWkUgPj0gZGVzY3ItPnNpemVvZl9yZWdpc3Rl cltpXSk7DQo+Pj4gKyAgICAgICAgZ2RiX2Fzc2VydCAoTUFYX1JFR0lTVEVS X1NJWkUgPj0gZGVzY3ItPnNpemVvZl9yZWdpc3RlcltpXSk7DQo+Pj4gKwlk ZXNjci0+bWF4X3JlZ2lzdGVyX3NpemUgPSBzdGQ6Om1heCAoZGVzY3ItPm1h eF9yZWdpc3Rlcl9zaXplLA0KPj4+ICsgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGRlc2NyLT5zaXplb2ZfcmVnaXN0ZXJbaV0p Ow0KPj4+ICAgICAgfQ0KPj4+ICAgIC8qIFNldCB0aGUgcmVhbCBzaXplIG9m IHRoZSByYXcgcmVnaXN0ZXIgY2FjaGUgYnVmZmVyLiAgKi8NCj4+PiAgICBk ZXNjci0+c2l6ZW9mX3Jhd19yZWdpc3RlcnMgPSBvZmZzZXQ7DQo+Pj4gQEAg LTEzNSw3ICsxNDAsOSBAQCBpbml0X3JlZ2NhY2hlX2Rlc2NyIChzdHJ1Y3Qg Z2RiYXJjaCAqZ2RiYXJjaCkNCj4+PiAJZGVzY3ItPnNpemVvZl9yZWdpc3Rl cltpXSA9IFRZUEVfTEVOR1RIIChkZXNjci0+cmVnaXN0ZXJfdHlwZVtpXSk7 DQo+Pj4gCWRlc2NyLT5yZWdpc3Rlcl9vZmZzZXRbaV0gPSBvZmZzZXQ7DQo+ Pj4gCW9mZnNldCArPSBkZXNjci0+c2l6ZW9mX3JlZ2lzdGVyW2ldOw0KPj4+ IC0JZ2RiX2Fzc2VydCAoTUFYX1JFR0lTVEVSX1NJWkUgPj0gZGVzY3ItPnNp emVvZl9yZWdpc3RlcltpXSk7DQo+Pj4gKyAgICAgICAgZ2RiX2Fzc2VydCAo TUFYX1JFR0lTVEVSX1NJWkUgPj0gZGVzY3ItPnNpemVvZl9yZWdpc3Rlcltp XSk7DQo+Pj4gKyAgICAgICAgZGVzY3ItPm1heF9yZWdpc3Rlcl9zaXplID0g c3RkOjptYXggKGRlc2NyLT5tYXhfcmVnaXN0ZXJfc2l6ZSwNCj4+PiArICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkZXNjci0+ c2l6ZW9mX3JlZ2lzdGVyW2ldKTsNCj4+PiAgICAgIH0NCj4+PiAgICAvKiBT ZXQgdGhlIHJlYWwgc2l6ZSBvZiB0aGUgcmVhZG9ubHkgcmVnaXN0ZXIgY2Fj aGUgYnVmZmVyLiAgKi8NCj4+PiAgICBkZXNjci0+c2l6ZW9mX2Nvb2tlZF9y ZWdpc3RlcnMgPSBvZmZzZXQ7DQo+Pj4gQEAgLTE4Nyw2ICsxOTQsMTMgQEAg cmVnY2FjaGVfcmVnaXN0ZXJfc2l6ZSAoY29uc3Qgc3RydWN0IHJlZ2NhY2hl ICpyZWdjYWNoZSwgaW50IG4pDQo+Pj4gIHJldHVybiByZWdpc3Rlcl9zaXpl IChnZXRfcmVnY2FjaGVfYXJjaCAocmVnY2FjaGUpLCBuKTsNCj4+PiB9DQo+ Pj4gDQo+Pj4gK2xvbmcNCj4+IA0KPj4gU2FtZSBhcyBhYm92ZSwgaXMgdGhp cyBldmVyIG5lZ2F0aXZlPw0KPiANCj4gT2suDQo+IA0KPj4gDQo+Pj4gK21h eF9yZWdpc3Rlcl9zaXplIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCkNCj4+ PiArew0KPj4+ICsgIHN0cnVjdCByZWdjYWNoZV9kZXNjciAqZGVzY3IgPSBy ZWdjYWNoZV9kZXNjciAoZ2RiYXJjaCk7DQo+PiANCj4+IElzIGRlc2NyIGV2 ZXIgTlVMTD8NCj4gDQo+IEkgZG9u4oCZdCB0aGluayBzby4gR2RiYXJjaC5j IGVuc3VyZXMgZXZlcnl0aGluZyBpcyBpbml0aWFsaXNlZC4NCj4gTm9uZSBv ZiB0aGUgb3RoZXIgZnVuY3Rpb25zIGluIHRoaXMgZmlsZSBldmVyIGNoZWNr IGZvciBudWxsLg0KPiANCj4+IA0KPj4+ICsgIHJldHVybiBkZXNjci0+bWF4 X3JlZ2lzdGVyX3NpemU7DQo+Pj4gK30NCj4+PiArDQo+Pj4gLyogVGhlIHJl Z2lzdGVyIGNhY2hlIGZvciBzdG9yaW5nIHJhdyByZWdpc3RlciB2YWx1ZXMu ICAqLw0KPj4+IA0KPj4+IHN0cnVjdCByZWdjYWNoZQ0KPj4+IEBAIC0zMjcs NyArMzQxLDcgQEAgcmVnY2FjaGVfc2F2ZSAoc3RydWN0IHJlZ2NhY2hlICpk c3QsIHJlZ2NhY2hlX2Nvb2tlZF9yZWFkX2Z0eXBlICpjb29rZWRfcmVhZCwN Cj4+PiAJICAgICAgIHZvaWQgKnNyYykNCj4+PiB7DQo+Pj4gIHN0cnVjdCBn ZGJhcmNoICpnZGJhcmNoID0gZHN0LT5kZXNjci0+Z2RiYXJjaDsNCj4+PiAt ICBnZGJfYnl0ZSBidWZbTUFYX1JFR0lTVEVSX1NJWkVdOw0KPj4+ICsgIGdk Yl9ieXRlICpidWYgPSAoZ2RiX2J5dGUgKikgYWxsb2NhIChtYXhfcmVnaXN0 ZXJfc2l6ZSAoZ2RiYXJjaCkpOw0KPj4+ICBpbnQgcmVnbnVtOw0KPj4+IA0K Pj4+ICAvKiBUaGUgRFNUIHNob3VsZCBiZSBgcmVhZC1vbmx5JywgaWYgaXQg d2Fzbid0IHRoZW4gdGhlIHNhdmUgd291bGQNCj4+PiBAQCAtMzY5LDcgKzM4 Myw3IEBAIHJlZ2NhY2hlX3Jlc3RvcmUgKHN0cnVjdCByZWdjYWNoZSAqZHN0 LA0KPj4+IAkJICB2b2lkICpjb29rZWRfcmVhZF9jb250ZXh0KQ0KPj4+IHsN Cj4+PiAgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2ggPSBkc3QtPmRlc2NyLT5n ZGJhcmNoOw0KPj4+IC0gIGdkYl9ieXRlIGJ1ZltNQVhfUkVHSVNURVJfU0la RV07DQo+Pj4gKyAgZ2RiX2J5dGUgKmJ1ZiA9IChnZGJfYnl0ZSAqKSBhbGxv Y2EgKG1heF9yZWdpc3Rlcl9zaXplIChnZGJhcmNoKSk7DQo+Pj4gIGludCBy ZWdudW07DQo+Pj4gDQo+Pj4gIC8qIFRoZSBkc3QgaGFkIGJldHRlciBub3Qg YmUgcmVhZC1vbmx5LiBJZiBpdCBpcywgdGhlIGByZXN0b3JlJw0KPj4+IEBA IC0xMjc5LDcgKzEyOTMsNyBAQCByZWdjYWNoZV9kdW1wIChzdHJ1Y3QgcmVn Y2FjaGUgKnJlZ2NhY2hlLCBzdHJ1Y3QgdWlfZmlsZSAqZmlsZSwNCj4+PiAg aW50IGZvb3Rub3RlX3JlZ2lzdGVyX29mZnNldCA9IDA7DQo+Pj4gIGludCBm b290bm90ZV9yZWdpc3Rlcl90eXBlX25hbWVfbnVsbCA9IDA7DQo+Pj4gIGxv bmcgcmVnaXN0ZXJfb2Zmc2V0ID0gMDsNCj4+PiAtICBnZGJfYnl0ZSBidWZb TUFYX1JFR0lTVEVSX1NJWkVdOw0KPj4+ICsgIGdkYl9ieXRlICpidWYgPSAo Z2RiX2J5dGUgKikgYWxsb2NhIChtYXhfcmVnaXN0ZXJfc2l6ZSAoZ2RiYXJj aCkpOw0KPj4+IA0KPj4+ICNpZiAwDQo+Pj4gIGZwcmludGZfdW5maWx0ZXJl ZCAoZmlsZSwgIm5yX3Jhd19yZWdpc3RlcnMgJWRcbiIsDQo+Pj4gZGlmZiAt LWdpdCBhL2dkYi9yZW1vdGUuYyBiL2dkYi9yZW1vdGUuYw0KPj4+IGluZGV4 IDkyNDdkNDNiMDk0OTI1ZmYzOTdlYjM2YjQ1MGVhYmE1MjFhZGZjOTkuLjg2 ODU2ZTZhNmFiYTE5NjdmYWFhOGVmNTQ3ZjhhNDhmY2M2M2MzODMgMTAwNjQ0 DQo+Pj4gLS0tIGEvZ2RiL3JlbW90ZS5jDQo+Pj4gKysrIGIvZ2RiL3JlbW90 ZS5jDQo+Pj4gQEAgLTc3NTIsOSArNzc1MiwxMCBAQCByZW1vdGVfZmV0Y2hf cmVnaXN0ZXJzIChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3BzLA0KPj4+IHN0YXRp YyB2b2lkDQo+Pj4gcmVtb3RlX3ByZXBhcmVfdG9fc3RvcmUgKHN0cnVjdCB0 YXJnZXRfb3BzICpzZWxmLCBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlKQ0K Pj4+IHsNCj4+PiArICBzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCA9IGdldF9y ZWdjYWNoZV9hcmNoIChyZWdjYWNoZSk7DQo+Pj4gIHN0cnVjdCByZW1vdGVf YXJjaF9zdGF0ZSAqcnNhID0gZ2V0X3JlbW90ZV9hcmNoX3N0YXRlICgpOw0K Pj4+ICBpbnQgaTsNCj4+PiAtICBnZGJfYnl0ZSBidWZbTUFYX1JFR0lTVEVS X1NJWkVdOw0KPj4+ICsgIGdkYl9ieXRlICpidWYgPSAoZ2RiX2J5dGUgKikg YWxsb2NhIChtYXhfcmVnaXN0ZXJfc2l6ZSAoZ2RiYXJjaCkpOw0KPj4+IA0K Pj4+ICAvKiBNYWtlIHN1cmUgdGhlIGVudGlyZSByZWdpc3RlcnMgYXJyYXkg aXMgdmFsaWQuICAqLw0KPj4+ICBzd2l0Y2ggKHBhY2tldF9zdXBwb3J0IChQ QUNLRVRfUCkpDQo+Pj4gDQo+Pj4gDQo+Pj4gDQo+PiANCj4+IE15IGNvbW1l bnQgaXMgdGhlIHNhbWUgYXMgMi8zLiBTaG91bGQgd2UgdXNlIGEgZGlmZmVy ZW50IGRhdGEgc3RydWN0dXJlIHRoYXQgY2FuIGdyb3cvc2hyaW5rIGFzIG9u ZSB3aXNoZXM/DQo+IA0KDQo= >From gdb-patches-return-136268-listarch-gdb-patches=sources.redhat.com@sourceware.org Tue Jan 17 14:33:44 2017 Return-Path: Delivered-To: listarch-gdb-patches@sources.redhat.com Received: (qmail 87937 invoked by alias); 17 Jan 2017 14:33:44 -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 87921 invoked by uid 89); 17 Jan 2017 14:33:43 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.9 required=5.0 tests=AWL,BAYES_00,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.2 spammy=H*M:881b X-HELO: relay1.mentorg.com Received: from relay1.mentorg.com (HELO relay1.mentorg.com) (192.94.38.131) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 17 Jan 2017 14:33:33 +0000 Received: from svr-orw-mbx-03.mgc.mentorg.com ([147.34.90.203]) by relay1.mentorg.com with esmtp id 1cTUpH-0005YY-MS from Luis_Gustavo@mentor.com ; Tue, 17 Jan 2017 06:33:31 -0800 Received: from [172.30.8.199] (147.34.91.1) by svr-orw-mbx-03.mgc.mentorg.com (147.34.90.203) with Microsoft SMTP Server (TLS) id 15.0.1210.3; Tue, 17 Jan 2017 06:33:28 -0800 Subject: Re: [PATCH 4/6] Disassembly unit test: disassemble one instruction References: <1484051178-16013-1-git-send-email-yao.qi@linaro.org> <1484560977-8693-1-git-send-email-yao.qi@linaro.org> <1484560977-8693-5-git-send-email-yao.qi@linaro.org> To: Yao Qi , From: Luis Machado Reply-To: Luis Machado Message-ID: <8555eaae-881b-31e6-843e-32c087f47232@codesourcery.com> Date: Tue, 17 Jan 2017 14:33:00 -0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.5.1 MIME-Version: 1.0 In-Reply-To: <1484560977-8693-5-git-send-email-yao.qi@linaro.org> Content-Type: text/plain; charset="windows-1252"; format=flowed Content-Transfer-Encoding: 7bit X-ClientProxiedBy: svr-orw-mbx-01.mgc.mentorg.com (147.34.90.201) To svr-orw-mbx-03.mgc.mentorg.com (147.34.90.203) X-IsSubscribed: yes X-SW-Source: 2017-01/txt/msg00324.txt.bz2 Content-length: 13021 On 01/16/2017 04:02 AM, Yao Qi wrote: > This patch adds one unit test, which disassemble one instruction for > every gdbarch if available. The test needs one valid instruction of > each gdbarch, and most of them are got from breakpoint instruction. > For the rest gdbarch whose breakpoint instruction isn't a valid > instruction, I copy one instruction from the gas/testsuite/gas/ > directory. > > I get the valid instruction of most gdbarch except ia64, mep, mips, > tic6x, and xtensa. People familiar with these arch should be easy > to extend the test. > > In order to achieve "do the unit test for every gdbarch", I add > selftest-arch.[c,h], so that we can register a function pointer, > which has one argument gdbarch. selftest.c will iterate over all > gdbarches to call the registered function pointer. > > v2: > - Add comments for getting breakpoint instructions for score and > nios2, > - Provide more contents in gdb_disassembler_test::read_memory if > caller requests more than one instruction, > - Stop using compound literal, > - Use null_stream, > - Split "selftest for each gdbarch" out of selftest.{c,h}, > > gdb: > > 2017-01-13 Yao Qi > > * Makefile.in (SFILES): Add disasm-selftests.c and > selftest-arch.c. > (COMMON_OBS): Add disasm-selftests.o and selftest-arch.o. > * disasm-selftests.c: New file. > * selftest-arch.c: New file. > * selftest-arch.h: New file. > --- > gdb/Makefile.in | 5 ++ > gdb/disasm-selftests.c | 178 +++++++++++++++++++++++++++++++++++++++++++++++++ > gdb/selftest-arch.c | 103 ++++++++++++++++++++++++++++ > gdb/selftest-arch.h | 26 ++++++++ > 4 files changed, 312 insertions(+) > create mode 100644 gdb/disasm-selftests.c > create mode 100644 gdb/selftest-arch.c > create mode 100644 gdb/selftest-arch.h > > diff --git a/gdb/Makefile.in b/gdb/Makefile.in > index 3ce7d69..e0fe442 100644 > --- a/gdb/Makefile.in > +++ b/gdb/Makefile.in > @@ -1039,6 +1039,7 @@ SFILES = \ > dfp.c \ > dictionary.c \ > disasm.c \ > + disasm-selftests.c \ > doublest.c \ > dtrace-probe.c \ > dummy-frame.c \ > @@ -1140,6 +1141,7 @@ SFILES = \ > rust-exp.y \ > rust-lang.c \ > selftest.c \ > + selftest-arch.c \ > sentinel-frame.c \ > ser-base.c \ > ser-event.c \ > @@ -1396,6 +1398,7 @@ HFILES_NO_SRCDIR = \ > rs6000-tdep.h \ > s390-linux-tdep.h \ > score-tdep.h \ > + selftest-arch.h \ > sentinel-frame.h \ > ser-base.h \ > ser-event.h \ > @@ -1643,6 +1646,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $(YYOBJ) \ > dfp.o \ > dictionary.o \ > disasm.o \ > + disasm-selftests.o \ > doublest.o \ > dummy-frame.o \ > dwarf2-frame.o \ > @@ -1744,6 +1748,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $(YYOBJ) \ > run-time-clock.o \ > rust-lang.o \ > selftest.o \ > + selftest-arch.o \ > sentinel-frame.o \ > ser-event.o \ > serial.o \ > diff --git a/gdb/disasm-selftests.c b/gdb/disasm-selftests.c > new file mode 100644 > index 0000000..46a0a21 > --- /dev/null > +++ b/gdb/disasm-selftests.c > @@ -0,0 +1,178 @@ > +/* Self tests for disassembler for GDB, the GNU debugger. > + > + Copyright (C) 2017 Free Software Foundation, Inc. > + > + This file is part of GDB. > + > + 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 "defs.h" > +#include "disasm.h" > + > +#if GDB_SELF_TEST > +#include "selftest.h" > +#include "selftest-arch.h" > + > +namespace selftests { > + > +/* Test disassembly of one instruction. */ > + > +static void > +gdb_disassembler_print_one_insn_test (struct gdbarch *gdbarch) One suggestion. Do you think it is worth repeating the context of the test in the function names? We already know this is a gdb disassembler selftest from the name of the source file. If we don't think it is worth it, we could significantly reduce the length of the name of these functions. > +{ > + size_t len = 0; > + const gdb_byte *insn = NULL; > + > + switch (gdbarch_bfd_arch_info (gdbarch)->arch) > + { > + case bfd_arch_bfin: > + /* M3.L = 0xe117 */ > + static const gdb_byte bfin_insn[] = {0x17, 0xe1, 0xff, 0xff}; > + > + insn = bfin_insn; > + len = sizeof (bfin_insn); > + break; > + case bfd_arch_arm: > + /* mov r0, #0 */ > + static const gdb_byte arm_insn[] = {0x0, 0x0, 0xa0, 0xe3}; > + > + insn = arm_insn; > + len = sizeof (arm_insn); > + break; > + case bfd_arch_ia64: > + case bfd_arch_mep: > + case bfd_arch_mips: > + case bfd_arch_tic6x: > + case bfd_arch_xtensa: > + return; > + case bfd_arch_s390: > + /* nopr %r7 */ > + static const gdb_byte s390_insn[] = {0x07, 0x07}; > + > + insn = s390_insn; > + len = sizeof (s390_insn); > + break; > + case bfd_arch_xstormy16: > + /* nop */ > + static const gdb_byte xstormy16_insn[] = {0x0, 0x0}; > + > + insn = xstormy16_insn; > + len = sizeof (xstormy16_insn); > + break; > + case bfd_arch_arc: > + { > + /* PR 21003 */ > + if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_arc_arc601) > + return; > + } > + case bfd_arch_nios2: > + case bfd_arch_score: > + /* nios2 and score need to know the current instruction to select > + breakpoint instruction. Give the breakpoint instruction kind > + explicitly. */ > + insn = gdbarch_sw_breakpoint_from_kind (gdbarch, 4, (int *) &len); > + break; > + default: > + { > + /* Test disassemble breakpoint instruction. */ > + CORE_ADDR pc = 0; > + int kind = gdbarch_breakpoint_kind_from_pc (gdbarch, &pc); > + > + insn = gdbarch_sw_breakpoint_from_kind (gdbarch, kind, > + (int *) &len); > + > + break; > + } > + } > + SELF_CHECK (len > 0); > + > + /* Test gdb_disassembler for a given gdbarch by reading data from a > + pre-allocated buffer. If you want to see the disassembled > + instruction printed to gdb_stdout, set DISASSEMBLER_TEST_VERBOSE > + to true. */ > + > + class gdb_disassembler_test : public gdb_disassembler > + { > + public: > + > + const bool DISASSEMBLER_TEST_VERBOSE = false; > + > + explicit gdb_disassembler_test (struct gdbarch *gdbarch, > + const gdb_byte *insn, > + size_t len) > + : gdb_disassembler (gdbarch, > + (DISASSEMBLER_TEST_VERBOSE > + ? gdb_stdout : null_stream ()), > + gdb_disassembler_test::read_memory), > + m_insn (insn), m_len (len) > + { > + } > + > + int Can this ever return negative? If not, then unsigned? This ties down with the comment on the other patch. > + print_insn (CORE_ADDR memaddr) > + { > + if (DISASSEMBLER_TEST_VERBOSE) > + { > + fprintf_unfiltered (stream (), "%s ", > + gdbarch_bfd_arch_info (arch ())->arch_name); > + } > + > + int len = gdb_disassembler::print_insn (memaddr); > + > + if (DISASSEMBLER_TEST_VERBOSE) > + fprintf_unfiltered (stream (), "\n"); > + > + return len; > + } > + > + private: > + /* A buffer contain one instruction. */ "A buffer containing..." or "A buffer contains ..." > + const gdb_byte *m_insn; > + > + /* Length of the buffer. */ > + size_t m_len; > + > + static int read_memory (bfd_vma memaddr, gdb_byte *myaddr, > + unsigned int len, struct disassemble_info *info) > + { > + gdb_disassembler_test *self > + = static_cast(info->application_data); > + > + /* The disassembler in opcodes may read more data than one > + instruction. */ > + for (unsigned int i = 0; i < len; i++) > + myaddr[i] = self->m_insn[(memaddr + i) % self->m_len]; > + > + return 0; > + } > + }; > + > + gdb_disassembler_test di (gdbarch, insn, len); > + > + SELF_CHECK (di.print_insn (0) == len); > +} > + > +} // namespace selftests > +#endif /* GDB_SELF_TEST */ > + > +/* Suppress warning from -Wmissing-prototypes. */ > +extern initialize_file_ftype _initialize_disasm_test; > + > +void > +_initialize_disasm_test (void) > +{ > +#if GDB_SELF_TEST > + register_self_test (selftests::gdb_disassembler_print_one_insn_test); > +#endif > +} > diff --git a/gdb/selftest-arch.c b/gdb/selftest-arch.c > new file mode 100644 > index 0000000..aa716be > --- /dev/null > +++ b/gdb/selftest-arch.c > @@ -0,0 +1,103 @@ > +/* GDB self-test for each gdbarch. > + Copyright (C) 2017 Free Software Foundation, Inc. > + > + This file is part of GDB. > + > + 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 "defs.h" > + > +#if GDB_SELF_TEST > +#include "selftest.h" > +#include "selftest-arch.h" > +#include "arch-utils.h" > + > +static std::vector gdbarch_tests; > + > +void > +register_self_test (self_test_function_with_gdbarch *function) > +{ > + gdbarch_tests.push_back (function); > +} > + > +namespace selftests { > + > +static void > +tests_with_arch (void) > +{ > + int failed = 0; > + > + for (const auto &f : gdbarch_tests) > + { > + const char **arches = gdbarch_printable_names (); > + int i; > + > + for (i = 0; arches[i] != NULL; i++) > + { > + if (strcmp ("fr300", arches[i]) == 0) > + { > + /* PR 20946 */ > + continue; > + } > + else if (strcmp ("powerpc:EC603e", arches[i]) == 0 > + || strcmp ("powerpc:e500mc", arches[i]) == 0 > + || strcmp ("powerpc:e500mc64", arches[i]) == 0 > + || strcmp ("powerpc:titan", arches[i]) == 0 > + || strcmp ("powerpc:vle", arches[i]) == 0 > + || strcmp ("powerpc:e5500", arches[i]) == 0 > + || strcmp ("powerpc:e6500", arches[i]) == 0) > + { > + /* PR 19797 */ > + continue; > + } > + > + QUIT; > + > + TRY > + { > + struct gdbarch_info info; > + > + gdbarch_info_init (&info); > + info.bfd_arch_info = bfd_scan_arch (arches[i]); > + > + struct gdbarch *gdbarch = gdbarch_find_by_info (info); > + SELF_CHECK (gdbarch != NULL); > + f (gdbarch); > + } > + CATCH (ex, RETURN_MASK_ERROR) > + { > + ++failed; > + exception_fprintf (gdb_stderr, ex, > + _("Self test failed: arch %s: "), arches[i]); > + } > + END_CATCH > + } > + } > + > + SELF_CHECK (failed == 0); > +} > + > +} // namespace selftests > +#endif /* GDB_SELF_TEST */ > + > +/* Suppress warning from -Wmissing-prototypes. */ > +extern initialize_file_ftype _initialize_selftests_with_arch; > + > +void > +_initialize_selftests_with_arch (void) > +{ > +#if GDB_SELF_TEST > + register_self_test (selftests::tests_with_arch); > +#endif > +} > diff --git a/gdb/selftest-arch.h b/gdb/selftest-arch.h > new file mode 100644 > index 0000000..d63c2d2 > --- /dev/null > +++ b/gdb/selftest-arch.h > @@ -0,0 +1,26 @@ > +/* GDB self-test for each gdbarch. > + Copyright (C) 2017 Free Software Foundation, Inc. > + > + This file is part of GDB. > + > + 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 . */ > + > +#ifndef SELFTEST_ARCH_H > +#define SELFTEST_ARCH_H > + > +typedef void self_test_function_with_gdbarch (struct gdbarch *); > + > +extern void register_self_test (self_test_function_with_gdbarch *function); > + > +#endif /* SELFTEST_ARCH_H */ > Otherwise looks OK