From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 21017 invoked by alias); 25 Apr 2013 07:55:21 -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 21006 invoked by uid 89); 25 Apr 2013 07:55:20 -0000 X-Spam-SWARE-Status: No, score=-9.0 required=5.0 tests=AWL,BAYES_00,KHOP_ENCRYPTED_CONTENT,KHOP_THREADED,MIME_BASE64_BLANKS,RCVD_IN_HOSTKARMA_W,RCVD_IN_HOSTKARMA_WL,RP_MATCHES_RCVD,SPF_PASS autolearn=ham version=3.3.1 Received: from mga14.intel.com (HELO mga14.intel.com) (143.182.124.37) by sourceware.org (qpsmtpd/0.84/v0.84-167-ge50287c) with ESMTP; Thu, 25 Apr 2013 07:55:14 +0000 Received: from azsmga002.ch.intel.com ([10.2.17.35]) by azsmga102.ch.intel.com with ESMTP; 25 Apr 2013 00:55:11 -0700 X-ExtLoop1: 1 Received: from irsmsx102.ger.corp.intel.com ([163.33.3.155]) by AZSMGA002.ch.intel.com with ESMTP; 25 Apr 2013 00:55:09 -0700 Received: from irsmsx105.ger.corp.intel.com (163.33.3.28) by IRSMSX102.ger.corp.intel.com (163.33.3.155) with Microsoft SMTP Server (TLS) id 14.1.355.2; Thu, 25 Apr 2013 08:55:08 +0100 Received: from irsmsx104.ger.corp.intel.com ([169.254.5.19]) by IRSMSX105.ger.corp.intel.com ([169.254.7.14]) with mapi id 14.01.0438.000; Thu, 25 Apr 2013 08:55:07 +0100 From: "Tedeschi, Walfred" To: Tom Tromey CC: "gdb-patches@sourceware.org" , "drow@false.org" Subject: RE: [PATCH] Fix display of structures/bitfields in register description. Date: Thu, 25 Apr 2013 16:18:00 -0000 Message-ID: References: <1366812163-27865-1-git-send-email-walfred.tedeschi@intel.com> <87wqrrn7ki.fsf@fleche.redhat.com> In-Reply-To: <87wqrrn7ki.fsf@fleche.redhat.com> Content-Type: application/pkcs7-mime; smime-type=signed-data; name="smime.p7m" Content-Disposition: attachment; filename="smime.p7m" Content-Transfer-Encoding: base64 MIME-Version: 1.0 X-SW-Source: 2013-04/txt/msg00774.txt.bz2 MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEH AaCAJIAEggnXQ29udGVudC1UeXBlOiB0ZXh0L3BsYWluOw0KCWNoYXJzZXQ9 InVzLWFzY2lpIg0KQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogN2JpdA0K DQpIaSBUb20sDQoNCkZpcnN0IG9mIGFsbCB0aGFua3MgYSBsb3QgZm9yIHRo ZSBxdWljayByZXZpZXchDQoNCllvdSBhcmUgcmlnaHQgYXQgDQoNCgkgIGlm ICh0eXBlLT5raW5kID09IFRERVNDX1RZUEVfVU5JT04NCgkgICAgICAmJiBW RUNfbGVuZ3RoICh0ZGVzY190eXBlX2ZpZWxkLCB0eXBlLT51LnUuZmllbGRz KSA+IDApDQoJICAgIHsNCgkgICAgICBwcmludGZfdW5maWx0ZXJlZCAoIiAg c3RydWN0IHRkZXNjX3R5cGUgKnR5cGU7XG4iKTsNCg0KVGhlIHN0cnVjdHVy ZSBjYXNlIGhhcyBhbHNvIHRvIGJlIGNvbnNpZGVyZWQuDQoNCg0KTGluZXMg YmVsb3cgd2VyZSByZW1vdmVkIG9uIG5ldyBwYXRjaC4NCg0KV2FsZnJlZD4g K2dsb2JhbCBzcmNkaXINCldhbGZyZWQ+ICtnbG9iYWwgc3ViZGlyDQoNCg0K Q29weXJpZ2h0czoNCkkgdG9vayBhIGxvb2sgb24gc2V2ZXJhbCB4bWwgZmls ZXMgYW5kIGFsbCBvZiB0aGVtIGhhZCB0aGUgc2FtZSBjb3B5cmlnaHQgSQ0K aGF2ZSB1c2VkLg0KVGhvdWdoLCB3b3VsZCB5b3UgcmVjb21tZW5kIHRvIHVz ZSB0aGUgY29tbW9uIEdQTCBoZWFkZXI/DQoNClRoYW5rcyBhbmQgcmVnYXJk cywNCi1GcmVkDQoNCi0tLS0tT3JpZ2luYWwgTWVzc2FnZS0tLS0tDQpGcm9t OiBnZGItcGF0Y2hlcy1vd25lckBzb3VyY2V3YXJlLm9yZw0KW21haWx0bzpn ZGItcGF0Y2hlcy1vd25lckBzb3VyY2V3YXJlLm9yZ10gT24gQmVoYWxmIE9m IFRvbSBUcm9tZXkNClNlbnQ6IFdlZG5lc2RheSwgQXByaWwgMjQsIDIwMTMg Nzo0OCBQTQ0KVG86IFRlZGVzY2hpLCBXYWxmcmVkDQpDYzogZ2RiLXBhdGNo ZXNAc291cmNld2FyZS5vcmc7IGRyb3dAZmFsc2Uub3JnDQpTdWJqZWN0OiBS ZTogW1BBVENIXSBGaXggZGlzcGxheSBvZiBzdHJ1Y3R1cmVzL2JpdGZpZWxk cyBpbiByZWdpc3Rlcg0KZGVzY3JpcHRpb24uDQoNCj4+Pj4+ICJXYWxmcmVk IiA9PSBXYWxmcmVkIFRlZGVzY2hpIDx3YWxmcmVkLnRlZGVzY2hpQGludGVs LmNvbT4gd3JpdGVzOg0KDQpXYWxmcmVkPiBBZGQgc3VwcG9ydCBmb3IgZGlz cGxheWluZyBzdHJ1Y3R1cmVzIGFuZCBiaXRmaWVsZHMgZm9yIA0KV2FsZnJl ZD4gcmVnaXN0ZXJzIHdoZW4gZXhlY3V0aW5nIHRoZSAibWFpbnQgcHJpbnQg Yy10ZGVzYyIuIENvbW1hbmQgaXMgDQpXYWxmcmVkPiBhbHNvIHVzZWQgd2hl biBjb252ZXJ0aW5nIHRoZSB4bWwgdGFyZ2V0IGRlc2NyaXB0aW9uIGZpbGUg aW50byANCldhbGZyZWQ+IGMgZmlsZS4NCg0KVGhhbmtzIGZvciB0aGUgcGF0 Y2guDQoNCkkgdGhpbmsgaXQgbG9va3MgcHJldHR5IGdvb2QuICBJIGhhdmUg YSBmZXcgbm90ZXMuDQoNCldhbGZyZWQ+ICsJICAgIGNhc2UgVERFU0NfVFlQ RV9TVFJVQ1Q6DQpXYWxmcmVkPiArCSAgICAgIHByaW50Zl91bmZpbHRlcmVk DQpXYWxmcmVkPiArCQkoIiAgdHlwZSA9IHRkZXNjX2NyZWF0ZV9zdHJ1Y3Qg KGZlYXR1cmUsDQpcIiVzXCIpO1xuIiwNCg0KVGhpcyBlbWl0cyBjb2RlIHRv IGFzc2lnbiB0byB0aGUgdmFyaWFibGUgInR5cGUiLg0KQnV0IGlzIHRoaXMg dmFyaWFibGUgZGVmaW5lZD8NCkVhcmxpZXIgSSBzZWU6DQoNCgkgIGlmICh0 eXBlLT5raW5kID09IFRERVNDX1RZUEVfVU5JT04NCgkgICAgICAmJiBWRUNf bGVuZ3RoICh0ZGVzY190eXBlX2ZpZWxkLCB0eXBlLT51LnUuZmllbGRzKSA+ IDApDQoJICAgIHsNCgkgICAgICBwcmludGZfdW5maWx0ZXJlZCAoIiAgc3Ry dWN0IHRkZXNjX3R5cGUgKnR5cGU7XG4iKTsNCg0KLi4uIHdoaWNoIEkgdGhp bmsgaXMgdGhlIG9ubHkgc3BvdCB3aGVyZSBpdCBpcyBkZWZpbmVkLg0KDQpJ ZiB0aGlzIGlzIGNvcnJlY3QgdGhlbiBJIHRoaW5rIGNoYW5naW5nIHRoaXMg dG8gYWxzbyBjaGVjaw0KVERFU0NfVFlQRV9TVFJVQ1Qgd291bGQgYmUgYXBw cm9wcmlhdGUuDQoNCklmIGl0IGlzbid0IGNvcnJlY3QsIHRoZW4gSSdtIGN1 cmlvdXMgdG8ga25vdyB3aGF0IGRlZmluZXMgJ3R5cGUnIGluIHRoZQ0Kb3V0 cHV0Lg0KDQpXYWxmcmVkPiArZ2xvYmFsIHNyY2Rpcg0KV2FsZnJlZD4gK2ds b2JhbCBzdWJkaXINCg0KSSBkb24ndCB0aGluayB0aGVzZSBhcmUgbmVlZGVk Lg0KDQpXYWxmcmVkPiArPCEtLSBDb3B5cmlnaHQgKEMpIDIwMTMgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuDQpXYWxmcmVkPiArDQpXYWxmcmVk PiArICAgICBDb3B5aW5nIGFuZCBkaXN0cmlidXRpb24gb2YgdGhpcyBmaWxl LCB3aXRoIG9yIHdpdGhvdXQNCm1vZGlmaWNhdGlvbiwNCldhbGZyZWQ+ICsg ICAgIGFyZSBwZXJtaXR0ZWQgaW4gYW55IG1lZGl1bSB3aXRob3V0IHJveWFs dHkgcHJvdmlkZWQgdGhlDQpjb3B5cmlnaHQNCldhbGZyZWQ+ICsgICAgIG5v dGljZSBhbmQgdGhpcyBub3RpY2UgYXJlIHByZXNlcnZlZC4gIC0tPg0KDQpJ IHRoaW5rIHRoaXMgc2hvdWxkIGJlIHRoZSB1c3VhbCBHUEwgY29tbWVudC4N Cg0KVG9tDQoAAAAAAACggh4GMIIDIDCCAomgAwIBAgIENd70zzANBgkqhkiG 9w0BAQUFADBOMQswCQYDVQQGEwJVUzEQMA4GA1UEChMHRXF1aWZheDEtMCsG A1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlmaWNhdGUgQXV0aG9yaXR5MB4X DTk4MDgyMjE2NDE1MVoXDTE4MDgyMjE2NDE1MVowTjELMAkGA1UEBhMCVVMx EDAOBgNVBAoTB0VxdWlmYXgxLTArBgNVBAsTJEVxdWlmYXggU2VjdXJlIENl cnRpZmljYXRlIEF1dGhvcml0eTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkC gYEAwV2xWGcIYu6gmi0fCG2RFGiYCh7+2gRvE4RiIcPRfM6fBeC4AfBONOzi ipUEZKzxa1NfBbPLZ4C/QgKO/t0BCezhABRP/PvwDN1Dulsr4R+AcJkVV5MW 8Q+XarfCaCMczE1ZMKxRHjuvK9buY0V7xdlfUNLjUA86iOe/FP3gx7kCAwEA AaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEQ MA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2Vy dGlmaWNhdGUgQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGB DzIwMTgwODIyMTY0MTUxWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUSOZo +SvSspXXR9gjIBBPM5iQn9QwHQYDVR0OBBYEFEjmaPkr0rKV10fYIyAQTzOY kJ/UMAwGA1UdEwQFMAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbA MA0GCSqGSIb3DQEBBQUAA4GBAFjOKer89961zgK5F7WF0bnj4JXMJTENAKaS bn+2kmOeUJXRmm/kEd5jhW6Y7qj/WsjTVbJmcVfewCHrPSqnI0kBBIZCe/zu f6IWUrVnZ9NA2zsmWLIodz2uFHdh1voqZiegDfqnc1zqcPGUIWVEX/r87ylo qaKHee9570+sB3c4MIIDPTCCAqagAwIBAgIDBbD/MA0GCSqGSIb3DQEBBQUA ME4xCzAJBgNVBAYTAlVTMRAwDgYDVQQKEwdFcXVpZmF4MS0wKwYDVQQLEyRF cXVpZmF4IFNlY3VyZSBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMDYwMjE2 MTgwMTMwWhcNMTYwMjE5MTgwMTMwWjBSMQswCQYDVQQGEwJVUzEaMBgGA1UE ChMRSW50ZWwgQ29ycG9yYXRpb24xJzAlBgNVBAMTHkludGVsIEV4dGVybmFs IEJhc2ljIFBvbGljeSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC ggEBAMGl39c5v1BWoRnyZDXTjZN04ircBMMixXbEPK3fTIvIxHlaO26zRufc H6F7z0GI078s/r6sXMTCUPnk+Vf4csYgp400b3t2rJzfQUSURSNnNNkWrY3h 7eRUn9cAQSAA3NXy/2qnupbDG6A+B9zfP0GRii34KJ+jN7Ectv+ERmP7IhIJ TrWRFm+5JDQTXXJgvh1GByCUl5oejehfnuu8hyRouxhXn/UCP5HwMzU+mT3r ldAAqwd+fJPsLhLnRPiVWfiXPfrA501mf/N6AbXOnjWWehMV9Pgq4pUkfnHt gPWnopuAkIoui+e6Ma6iGq4E191cqlmS/Pqka/6ILUdrAl0CAwEAAaOBoDCB nTAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBrGDErER2+o260r8PRWBqPt N1QMMDoGA1UdHwQzMDEwL6AtoCuGKWh0dHA6Ly9jcmwuZ2VvdHJ1c3QuY29t L2NybHMvc2VjdXJlY2EuY3JsMB8GA1UdIwQYMBaAFEjmaPkr0rKV10fYIyAQ TzOYkJ/UMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAExA4 raRUpUiVRbAtN3LAn57Y748L+5CW0rYXeVHKs98Gfr206Qg/hKAMk5+zHKhs is8t7vmQEvD4OibXc4EOn8QxklnUKCVB9VXxyj2ZPdpkyNIYZCIyCQktHeMx +v3TR9dkqPld6oIn4k/SYSEkYR1UJj4UWWSwmNXzp8OurVAwggWKMIIEcqAD AgECAgphHoC3AAAAAAAHMA0GCSqGSIb3DQEBBQUAMFIxCzAJBgNVBAYTAlVT MRowGAYDVQQKExFJbnRlbCBDb3Jwb3JhdGlvbjEnMCUGA1UEAxMeSW50ZWwg RXh0ZXJuYWwgQmFzaWMgUG9saWN5IENBMB4XDTA5MDUxNTE5MjUxM1oXDTE1 MDUxNTE5MzUxM1owVjELMAkGA1UEBhMCVVMxGjAYBgNVBAoTEUludGVsIENv cnBvcmF0aW9uMSswKQYDVQQDEyJJbnRlbCBFeHRlcm5hbCBCYXNpYyBJc3N1 aW5nIENBIDNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwY+A Yuc47kg7OUdF+vVd8JVv3tXgFHZBWk9nsKtwhD4UZrYocP/p0+PDE4iu0VN1 9bgFiKR0WbFRlUFZFZnlXJ7ZwJ0bMVaogQ4TV7Xuc3HWMzxnoZkSpsNRL68G 4+UEUcpChWbkFo0genKfZdnGrCNX2Pn9ysh8+sIay2T7bO1SFVLw4cSDM7vz g+AP2k6AGecBtkeYQzUVhiZDqJtL6BUIfOhsNgb5hF5GIekUpYHGlS4/5fRZ gXD8lrUlbs3ykQsAUPDRQUFYWCK/VAi6x0u9LLyZywsnnDLTnQ5VzFKGqhTG HD/C/K66hDG+YQ+OFFrULahIKYY3TTTcYyFBYwIDAQABo4ICXDCCAlgwDwYD VR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqhZmr7c9VlNgrg3C7fPuB8tRYH4w CwYDVR0PBAQDAgGGMBIGCSsGAQQBgjcVAQQFAgMBAAEwIwYJKwYBBAGCNxUC BBYEFMIrCFPH6F0ywoKA6ZbAuCNCwBX5MBkGCSsGAQQBgjcUAgQMHgoAUwB1 AGIAQwBBMB8GA1UdIwQYMBaAFBrGDErER2+o260r8PRWBqPtN1QMMIG9BgNV HR8EgbUwgbIwga+ggayggamGTmh0dHA6Ly93d3cuaW50ZWwuY29tL3JlcG9z aXRvcnkvQ1JML0ludGVsJTIwRXh0ZXJuYWwlMjBCYXNpYyUyMFBvbGljeSUy MENBLmNybIZXaHR0cDovL2NlcnRpZmljYXRlcy5pbnRlbC5jb20vcmVwb3Np dG9yeS9DUkwvSW50ZWwlMjBFeHRlcm5hbCUyMEJhc2ljJTIwUG9saWN5JTIw Q0EuY3JsMIHjBggrBgEFBQcBAQSB1jCB0zBjBggrBgEFBQcwAoZXaHR0cDov L3d3dy5pbnRlbC5jb20vcmVwb3NpdG9yeS9jZXJ0aWZpY2F0ZXMvSW50ZWwl MjBFeHRlcm5hbCUyMEJhc2ljJTIwUG9saWN5JTIwQ0EuY3J0MGwGCCsGAQUF BzAChmBodHRwOi8vY2VydGlmaWNhdGVzLmludGVsLmNvbS9yZXBvc2l0b3J5 L2NlcnRpZmljYXRlcy9JbnRlbCUyMEV4dGVybmFsJTIwQmFzaWMlMjBQb2xp Y3klMjBDQS5jcnQwDQYJKoZIhvcNAQEFBQADggEBAJRj/V3QxLpU9OUhw6Gj VdaHX3c8PmQkMlI92mEsdB0zWgoD7CEx0gGhjVXNMMMr4L4TLglzKdrt+kLy 5Waf9HP+L0xm3Jzup7M+1lOf1TI5G8mZ10f47H9HJwbB7dqCzyNR2ykQKitg 6QnJmSycMiVNVS9tHvDJj6AYlirFZeqtxUUSIyxa7z84iV/sXaABgwHDWRnn l2fiVYEgzRaq9F5ak++Fh43tj7cwoR1IyRDtNmI1t91nkP/wp9Y0xMnhUeW0 6AIvWUDm3H8XhHX3bSySkvl67dKPrnRFR7es5expXk3InMHAHfX7XOyaV5V0 UPST8XD0fFdsBATfm5w3/sIwggWKMIIEcqADAgECAgphIIpiAAAAAAAIMA0G CSqGSIb3DQEBBQUAMFIxCzAJBgNVBAYTAlVTMRowGAYDVQQKExFJbnRlbCBD b3Jwb3JhdGlvbjEnMCUGA1UEAxMeSW50ZWwgRXh0ZXJuYWwgQmFzaWMgUG9s aWN5IENBMB4XDTA5MDUxNTE5MjcyNloXDTE1MDUxNTE5MzcyNlowVjELMAkG A1UEBhMCVVMxGjAYBgNVBAoTEUludGVsIENvcnBvcmF0aW9uMSswKQYDVQQD EyJJbnRlbCBFeHRlcm5hbCBCYXNpYyBJc3N1aW5nIENBIDNCMIIBIjANBgkq hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApAQzVaf1NT29z0L79NzsoH56JgSW atwRYTfZZR0e9Yb4hxAdVCyKROYzIoqiM0vDYHmzoh6RzyK8Oj/AJ+NnNf0n J+0ydz4ACtzSVrzs6XJvObwr2NcR9MG9OdRIVKIj1lh58hN2JSCqUAW6WMVk Qdgpi0u6GtFpymZB8/iZXrc0p1zZtPzTgdF/pim1kVriTpg33jOWsY2sG5BD vhYXPP+MsG6xtSkSSujoy79lgU4VZCtX2UGEX1G6TzI37c3qf19Sj+oGKCIX aQSf3FWHXKSXtIIYvaMFSRfHiqBXbtrpKLyVFF2Csca038dadJaUtdMfmXnv kfgur77vs4W/fwIDAQABo4ICXDCCAlgwDwYDVR0TAQH/BAUwAwEB/zAdBgNV HQ4EFgQUDsYq91myCBCQJW/D3f2KZjEwK8UwCwYDVR0PBAQDAgGGMBIGCSsG AQQBgjcVAQQFAgMBAAEwIwYJKwYBBAGCNxUCBBYEFDmgVjZ6QpD/kq2Kb5V0 x5JZvhBZMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMB8GA1UdIwQYMBaA FBrGDErER2+o260r8PRWBqPtN1QMMIG9BgNVHR8EgbUwgbIwga+ggayggamG Tmh0dHA6Ly93d3cuaW50ZWwuY29tL3JlcG9zaXRvcnkvQ1JML0ludGVsJTIw RXh0ZXJuYWwlMjBCYXNpYyUyMFBvbGljeSUyMENBLmNybIZXaHR0cDovL2Nl cnRpZmljYXRlcy5pbnRlbC5jb20vcmVwb3NpdG9yeS9DUkwvSW50ZWwlMjBF eHRlcm5hbCUyMEJhc2ljJTIwUG9saWN5JTIwQ0EuY3JsMIHjBggrBgEFBQcB AQSB1jCB0zBjBggrBgEFBQcwAoZXaHR0cDovL3d3dy5pbnRlbC5jb20vcmVw b3NpdG9yeS9jZXJ0aWZpY2F0ZXMvSW50ZWwlMjBFeHRlcm5hbCUyMEJhc2lj JTIwUG9saWN5JTIwQ0EuY3J0MGwGCCsGAQUFBzAChmBodHRwOi8vY2VydGlm aWNhdGVzLmludGVsLmNvbS9yZXBvc2l0b3J5L2NlcnRpZmljYXRlcy9JbnRl bCUyMEV4dGVybmFsJTIwQmFzaWMlMjBQb2xpY3klMjBDQS5jcnQwDQYJKoZI hvcNAQEFBQADggEBALG1AQdyFVCFfKMSq0xVQx7qCSY+whzMfFJ6o1uj12wP 7rFtPrklP6hiCkgC18Sxhd5Qm7VwKGqlvbZTlswDPt5pBxblvN5+59a8DqWD bTjwHyhzMGP+r7k/k2litQ7yM6Y3iNON8mrcSVnvIVanLusHdWb9o3oBNipZ 8xtL/F+H4kLGYfd2uhSYwkjT9pkkewu2NuMWc2wcM2sllfW/GUzvwtvWGOyR MQ0+aFtVt9OPmL9kaeG/i2YjxBk8I21x6Bcmt+FGXYP1tal1M4+taIsNSrPL VnoovtNw5L88KXxEcIleQ9q7+2FNAKkigNrb5z7dcD76BFN8BDiy9M7brQ0w ggYbMIIFA6ADAgECAgpWy3fWAAEAAGm7MA0GCSqGSIb3DQEBBQUAMFYxCzAJ BgNVBAYTAlVTMRowGAYDVQQKExFJbnRlbCBDb3Jwb3JhdGlvbjErMCkGA1UE AxMiSW50ZWwgRXh0ZXJuYWwgQmFzaWMgSXNzdWluZyBDQSAzQTAeFw0xMTA4 MDIwODM2NTNaFw0xNDA3MTcwODM2NTNaMEcxGjAYBgNVBAMTEVRlZGVzY2hp LCBXYWxmcmVkMSkwJwYJKoZIhvcNAQkBFhp3YWxmcmVkLnRlZGVzY2hpQGlu dGVsLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKF41jTa zotDr74550KXEIE+qkMfZgU4IZrPNlhBlcgem6yWMNejRtqC61CaHu3gZF8t kZ5TrkoJqvvTep7eEH27SgcEB5fPUCuGhrDgvBZOzbrBnMNVdrKZyD1WvzfO o+ySQjLsXVGom3eD0iHcHgVqrdCMHQZO+eBw/XTC/f5uG8aJRZKfFn+0kZFw brhtLHwCzUv9C5Lu0zQQCOvDqgH52ak+cj+d5PSUxEcRNrhdS+UD1Oj6jJgg qjcCdTWMJjFk9iJQWXPSKRQ9AzINQ/Eh/rLIv7yQUYaYk4bnKICqHOx71tqu wB9b6clivHHWwqqPdkYYlO7joWk80f9ET6MCAwEAAaOCAvgwggL0MAsGA1Ud DwQEAwIHgDA8BgkrBgEEAYI3FQcELzAtBiUrBgEEAYI3FQiGw4x1hJnlUYP9 gSiFjp9TgpHACWeB3r05lfBDAgFkAgEIMB0GA1UdDgQWBBTKTpMtqOpYN9CQ O24SCnIv1kJWFDAfBgNVHSMEGDAWgBSqFmavtz1WU2CuDcLt8+4Hy1FgfjCB zwYDVR0fBIHHMIHEMIHBoIG+oIG7hldodHRwOi8vd3d3LmludGVsLmNvbS9y ZXBvc2l0b3J5L0NSTC9JbnRlbCUyMEV4dGVybmFsJTIwQmFzaWMlMjBJc3N1 aW5nJTIwQ0ElMjAzQSgxKS5jcmyGYGh0dHA6Ly9jZXJ0aWZpY2F0ZXMuaW50 ZWwuY29tL3JlcG9zaXRvcnkvQ1JML0ludGVsJTIwRXh0ZXJuYWwlMjBCYXNp YyUyMElzc3VpbmclMjBDQSUyMDNBKDEpLmNybDCB9QYIKwYBBQUHAQEEgegw geUwbAYIKwYBBQUHMAKGYGh0dHA6Ly93d3cuaW50ZWwuY29tL3JlcG9zaXRv cnkvY2VydGlmaWNhdGVzL0ludGVsJTIwRXh0ZXJuYWwlMjBCYXNpYyUyMElz c3VpbmclMjBDQSUyMDNBKDEpLmNydDB1BggrBgEFBQcwAoZpaHR0cDovL2Nl cnRpZmljYXRlcy5pbnRlbC5jb20vcmVwb3NpdG9yeS9jZXJ0aWZpY2F0ZXMv SW50ZWwlMjBFeHRlcm5hbCUyMEJhc2ljJTIwSXNzdWluZyUyMENBJTIwM0Eo MSkuY3J0MB8GA1UdJQQYMBYGCCsGAQUFBwMEBgorBgEEAYI3CgMMMCkGCSsG AQQBgjcVCgQcMBowCgYIKwYBBQUHAwQwDAYKKwYBBAGCNwoDDDBRBgNVHREE SjBIoCoGCisGAQQBgjcUAgOgHAwad2FsZnJlZC50ZWRlc2NoaUBpbnRlbC5j b22BGndhbGZyZWQudGVkZXNjaGlAaW50ZWwuY29tMA0GCSqGSIb3DQEBBQUA A4IBAQAeFAdwWPM6qHmjNJQFQkvA5gWz/yW8Dy0xHAhHlBHgSZ42vyCuP2dS qJZ6uQzFVInsAC3+8tiUtOGwSUq9hGYIgHx2vd3jrmYBjbn1IKxsAfOXdMAx JDPV9Qus1B/hdkWXX7wRBjm8RqbvC+1HPRz7xCbo8ohLoBRdIAbTXJcCZEJQ 5kBVOKmspwdf6bARIesNdFmwClzAFSndA4OfqrnrVTDGxfb0qZz7zLBCHEaB osmIu3zsOoFukIiPzNUVY7M4Q2CYTjhhNa0eO3X/b8jSBuUaHzPuMHazleOL oTCzEZdq2rvMkAzeC6gMrrT1wYUsw5PXJsW1Er7zX6A7gWkoMIIGYjCCBUqg AwIBAgIKRAANFwABAAB0sDANBgkqhkiG9w0BAQUFADBWMQswCQYDVQQGEwJV UzEaMBgGA1UEChMRSW50ZWwgQ29ycG9yYXRpb24xKzApBgNVBAMTIkludGVs IEV4dGVybmFsIEJhc2ljIElzc3VpbmcgQ0EgM0IwHhcNMTEwODAyMDgzNjE5 WhcNMTQwNzE3MDgzNjE5WjBHMRowGAYDVQQDExFUZWRlc2NoaSwgV2FsZnJl ZDEpMCcGCSqGSIb3DQEJARYad2FsZnJlZC50ZWRlc2NoaUBpbnRlbC5jb20w ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCY1PZGxRf8o9DxgrWW gPwMkw2VKGFsh0SdQcv5i62jzWc7IWzncejYa80VuzGqGTrkz8NpNQJL1tF5 /AUiorrQKPPiwq03vvFhQVWm7VRA6PPxCCenjyQOpVcmhR0g2zZSdyfj7NQJ 5++POBzklTkarguS9b92QtnvKMYVe5qBUwyiQ0II9JgUTaU34h7oYDhNcB9r WygyTkYAYwTTjrcEVALDUD+M8SLe1F1Cx0X01FYMvno1cpUiX7AmEtv5ZvwO I6+SbRWEKLd6FF8dmjeqULwE5/qlWHVrvpiS5Y7C1Q9xxd+HAM455ioAM5IY 8DxkzGaS36EKkRjt85aLBcEBAgMBAAGjggM/MIIDOzALBgNVHQ8EBAMCBDAw PQYJKwYBBAGCNxUHBDAwLgYmKwYBBAGCNxUIhsOMdYSZ5VGD/YEohY6fU4KR wAlnhLnZQYeE/04CAWQCAQwwRAYJKoZIhvcNAQkPBDcwNTAOBggqhkiG9w0D AgICAIAwDgYIKoZIhvcNAwQCAgCAMAcGBSsOAwIHMAoGCCqGSIb3DQMHMB0G A1UdDgQWBBQpIMhMs8Vyp+jmG+rRvgpmPofoBjAfBgNVHSMEGDAWgBQOxir3 WbIIEJAlb8Pd/YpmMTArxTCBzwYDVR0fBIHHMIHEMIHBoIG+oIG7hldodHRw Oi8vd3d3LmludGVsLmNvbS9yZXBvc2l0b3J5L0NSTC9JbnRlbCUyMEV4dGVy bmFsJTIwQmFzaWMlMjBJc3N1aW5nJTIwQ0ElMjAzQigxKS5jcmyGYGh0dHA6 Ly9jZXJ0aWZpY2F0ZXMuaW50ZWwuY29tL3JlcG9zaXRvcnkvQ1JML0ludGVs JTIwRXh0ZXJuYWwlMjBCYXNpYyUyMElzc3VpbmclMjBDQSUyMDNCKDEpLmNy bDCB9QYIKwYBBQUHAQEEgegwgeUwbAYIKwYBBQUHMAKGYGh0dHA6Ly93d3cu aW50ZWwuY29tL3JlcG9zaXRvcnkvY2VydGlmaWNhdGVzL0ludGVsJTIwRXh0 ZXJuYWwlMjBCYXNpYyUyMElzc3VpbmclMjBDQSUyMDNCKDEpLmNydDB1Bggr BgEFBQcwAoZpaHR0cDovL2NlcnRpZmljYXRlcy5pbnRlbC5jb20vcmVwb3Np dG9yeS9jZXJ0aWZpY2F0ZXMvSW50ZWwlMjBFeHRlcm5hbCUyMEJhc2ljJTIw SXNzdWluZyUyMENBJTIwM0IoMSkuY3J0MB8GA1UdJQQYMBYGCCsGAQUFBwME BgorBgEEAYI3CgMEMCkGCSsGAQQBgjcVCgQcMBowCgYIKwYBBQUHAwQwDAYK KwYBBAGCNwoDBDBRBgNVHREESjBIoCoGCisGAQQBgjcUAgOgHAwad2FsZnJl ZC50ZWRlc2NoaUBpbnRlbC5jb22BGndhbGZyZWQudGVkZXNjaGlAaW50ZWwu Y29tMA0GCSqGSIb3DQEBBQUAA4IBAQALJMemgWjuHc1Xpt+TTwhGm1X2qK3A BHwL4u8Ib/GzRK4R8ZpM5W0lMS7TUWFmnWrZI8C5RPG3EqjmKh1TEQsg9BL4 VUIjrI1igsmdiKuA+vkkL3IEwjGBTPAmwfVNsuBkwyx7Dc7fCapeDhcyJ8uF oD/EPViPACZ6vdDXHMaCsTG4C7RsWbLxXbQBkuUM81cT424+5kQzUSADNpgx PPRZAlvrOsBbVO23IXwujMl3oqq3GDYcqSUtxLa7cKKQlsrLPd0VK/BF5bAU AagMIGkkenbm189ob6yqO08ODlLfSL6nRS/CoGB9aOZZnK6Qo7HLLNPkr6GS xqEqxrnzrCQJMYIDhjCCA4ICAQEwZDBWMQswCQYDVQQGEwJVUzEaMBgGA1UE ChMRSW50ZWwgQ29ycG9yYXRpb24xKzApBgNVBAMTIkludGVsIEV4dGVybmFs IEJhc2ljIElzc3VpbmcgQ0EgM0ECClbLd9YAAQAAabswCQYFKw4DAhoFAKCC AfcwGAYJKoZIhvcNAQkDMQsGCSqGSIb3DQEHATAcBgkqhkiG9w0BCQUxDxcN MTMwNDI1MDc1NTA1WjAjBgkqhkiG9w0BCQQxFgQUw5cKoLAyC2sb7mvxkekN 5ldzWqYwcwYJKwYBBAGCNxAEMWYwZDBWMQswCQYDVQQGEwJVUzEaMBgGA1UE ChMRSW50ZWwgQ29ycG9yYXRpb24xKzApBgNVBAMTIkludGVsIEV4dGVybmFs IEJhc2ljIElzc3VpbmcgQ0EgM0ICCkQADRcAAQAAdLAwdQYLKoZIhvcNAQkQ AgsxZqBkMFYxCzAJBgNVBAYTAlVTMRowGAYDVQQKExFJbnRlbCBDb3Jwb3Jh dGlvbjErMCkGA1UEAxMiSW50ZWwgRXh0ZXJuYWwgQmFzaWMgSXNzdWluZyBD QSAzQgIKRAANFwABAAB0sDCBqwYJKoZIhvcNAQkPMYGdMIGaMAoGCCqGSIb3 DQMHMAsGCWCGSAFlAwQBKjALBglghkgBZQMEARYwCwYJYIZIAWUDBAECMA4G CCqGSIb3DQMCAgIAgDAHBgUrDgMCBzANBggqhkiG9w0DAgIBQDANBggqhkiG 9w0DAgIBKDAHBgUrDgMCGjALBglghkgBZQMEAgMwCwYJYIZIAWUDBAICMAsG CWCGSAFlAwQCATANBgkqhkiG9w0BAQEFAASCAQBDsmk3vkZDreyh4NlpSbfR WlP0PJreJy43glRd5gkiCUxSzTFSztX0TqMN0y0cbVSuEh95IKSrR9dJ+HL7 ZJ4h3NWlAh06CwDP5Tt96ng6TJXUDFk0oJZTdKbTHZuTEasaQwrBuphrKdrf tW83mVT41ukhPXIJ6H9dQES1Fa9S4iv6rPdKoc9c/gsFoxDimHQ9jLwreZkF 7/g/eIMFfgzww4L6rcXcAVg87gSqblD70hIn+L0AUukoxsIv3wU3WlL7jBt+ mPIOLiez42Ea2nHk17z3FhlOO9zpJR5ojbWbR+oJNn0phPeNkSrg5sq8nnvl oaC0exAT8dZBllN96Ih/AAAAAAAA >From gdb-patches-return-100849-listarch-gdb-patches=sources.redhat.com@sourceware.org Thu Apr 25 08:02:14 2013 Return-Path: Delivered-To: listarch-gdb-patches@sources.redhat.com Received: (qmail 24951 invoked by alias); 25 Apr 2013 08:02:14 -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 24942 invoked by uid 89); 25 Apr 2013 08:02:13 -0000 X-Spam-SWARE-Status: No, score=-0.8 required=5.0 tests=AWL,BAYES_00,KHOP_RCVD_UNTRUST,RCVD_IN_HOSTKARMA_W,RCVD_IN_HOSTKARMA_WL,RP_MATCHES_RCVD autolearn=ham version=3.3.1 Received: from mga09.intel.com (HELO mga09.intel.com) (134.134.136.24) by sourceware.org (qpsmtpd/0.84/v0.84-167-ge50287c) with ESMTP; Thu, 25 Apr 2013 08:02:12 +0000 Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga102.jf.intel.com with ESMTP; 25 Apr 2013 01:00:19 -0700 X-ExtLoop1: 1 Received: from irvmail001.ir.intel.com ([163.33.26.43]) by orsmga001.jf.intel.com with ESMTP; 25 Apr 2013 01:02:08 -0700 Received: from ulslx001.iul.intel.com (ulslx001.iul.intel.com [172.28.207.63]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id r3P828ed014098; Thu, 25 Apr 2013 09:02:08 +0100 Received: from ulslx001.iul.intel.com (localhost [127.0.0.1]) by ulslx001.iul.intel.com with ESMTP id r3P8272v029972; Thu, 25 Apr 2013 10:02:07 +0200 Received: (from wtedesch@localhost) by ulslx001.iul.intel.com with id r3P825P9029968; Thu, 25 Apr 2013 10:02:05 +0200 From: Walfred Tedeschi To: gdb-patches@sourceware.org, walfred.tedeschi@intel.com, drow@false.org, tromey@redhat.com Subject: [PATCH] Fix display of structures/bitfields in register description. Date: Thu, 25 Apr 2013 17:24:00 -0000 Message-Id: <1366876919-29939-1-git-send-email-walfred.tedeschi@intel.com> X-SW-Source: 2013-04/txt/msg00775.txt.bz2 Content-length: 6639 Add support for displaying structures and bitfields for registers when executing the "maint print c-tdesc". Command is also used when converting the xml target description file into c file. Example of the behaviour is given below reporting a snipet of the xml file and a snippet of the c code generated. XML file contains: ... ... Setting this xml file as target description file and issuing the maintenance print c-tdesc the following output is obtained: feature = tdesc_create_feature (result, "extra"); field_type = tdesc_named_type (feature, "int8"); tdesc_create_vector (feature, "v4int8", field_type, 4); field_type = tdesc_named_type (feature, "int16"); tdesc_create_vector (feature, "v2int16", field_type, 2); type = tdesc_create_union (feature, "vecint"); field_type = tdesc_named_type (feature, "v4int8"); tdesc_add_field (type, "v4", field_type); field_type = tdesc_named_type (feature, "v2int16"); tdesc_add_field (type, "v2", field_type); C output is not supported type "struct1". This is finally the issue. 2013-03-27 Walfred Tedeschi * target-descriptions.c (maint_print_c_tdesc_cmd): Add case to parse structures as register types and bitfields. testsuite/gdb.xml/ * maint_print_struct.exp: New file. * maint_print_struct.xml: New file. Signed-off-by: Walfred Tedeschi --- gdb/target-descriptions.c | 33 +++++++++++++++++++++++- gdb/testsuite/gdb.xml/maint_print_struct.exp | 35 ++++++++++++++++++++++++++ gdb/testsuite/gdb.xml/maint_print_struct.xml | 26 +++++++++++++++++++ 3 files changed, 93 insertions(+), 1 deletion(-) create mode 100644 gdb/testsuite/gdb.xml/maint_print_struct.exp create mode 100644 gdb/testsuite/gdb.xml/maint_print_struct.xml diff --git a/gdb/target-descriptions.c b/gdb/target-descriptions.c index 95980c5..6e8aad4 100644 --- a/gdb/target-descriptions.c +++ b/gdb/target-descriptions.c @@ -1675,7 +1675,8 @@ maint_print_c_tdesc_cmd (char *args, int from_tty) printed_field_type = 1; } - if (type->kind == TDESC_TYPE_UNION + if ((type->kind == TDESC_TYPE_UNION || + type->kind == TDESC_TYPE_STRUCT) && VEC_length (tdesc_type_field, type->u.u.fields) > 0) { printf_unfiltered (" struct tdesc_type *type;\n"); @@ -1746,6 +1747,36 @@ feature = tdesc_create_feature (result, \"%s\");\n", (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n", type->name, type->u.v.count); break; + case TDESC_TYPE_STRUCT: + printf_unfiltered + (" type = tdesc_create_struct (feature, \"%s\");\n", + type->name); + if (type->u.u.size != 0) + printf_unfiltered + (" tdesc_set_struct_size (type, %s);\n", + plongest (type->u.u.size)); + for (ix3 = 0; + VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f); + ix3++) + { + /* Going first for implicitly sized types, else part handles + bitfields. As reported on xml-tdesc.c implicitly sized types + cannot contain a bitfield. */ + if (f->start == 0 && f->end == 0) + { + printf_unfiltered + (" field_type = tdesc_named_type (feature, \"%s\");\n", + f->type->name); + printf_unfiltered + (" tdesc_add_field (type, \"%s\", field_type);\n", + f->name); + } + else + printf_unfiltered + (" tdesc_add_bitfield (type, \"%s\", %d, %d);\n", + f->name, f->start, f->end); + } + break; case TDESC_TYPE_UNION: printf_unfiltered (" type = tdesc_create_union (feature, \"%s\");\n", diff --git a/gdb/testsuite/gdb.xml/maint_print_struct.exp b/gdb/testsuite/gdb.xml/maint_print_struct.exp new file mode 100644 index 0000000..568d174 --- /dev/null +++ b/gdb/testsuite/gdb.xml/maint_print_struct.exp @@ -0,0 +1,35 @@ +# This testcase is part of GDB, the GNU debugger. +# +# Copyright 2013 Free Software Foundation, Inc. +# +# Contributed by Intel Corp. +# +# 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 . + +if {[gdb_skip_xml_test]} { + unsupported "maint_print_struct.exp" + return -1 +} + +gdb_start + +# Required registers are not present so it is expected a warning. +# +gdb_test "set tdesc filename $srcdir/$subdir/maint_print_struct.xml" " +warning:.*" "setting a new tdesc having only a structure" + +gdb_test "maint print c-tdesc" " +.*tdesc_create_reg \\(feature, \"bad_reg1\", \[0-9\]+, 1, NULL, 128, \"two_fielded\"\\);\r +.*tdesc_create_reg \\(feature, \"bad_reg2\", \[0-9\]+, 1, NULL, 64, \"bitfield\"\\);\r +.*" "printing tdesc with a structure and a bitfield" diff --git a/gdb/testsuite/gdb.xml/maint_print_struct.xml b/gdb/testsuite/gdb.xml/maint_print_struct.xml new file mode 100644 index 0000000..dab71fa --- /dev/null +++ b/gdb/testsuite/gdb.xml/maint_print_struct.xml @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + -- 1.7.10.4