From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jiri Slaby Subject: [PATCH v6 01/28] linkage: new macros for assembler symbols Date: Fri, 18 May 2018 11:16:54 +0200 Message-ID: <20180518091721.7604-2-jslaby@suse.cz> References: <20180518091721.7604-1-jslaby@suse.cz> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180518091721.7604-1-jslaby@suse.cz> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: mingo@redhat.com Cc: linux-arch@vger.kernel.org, Juergen Gross , x86@kernel.org, Peter Zijlstra , Len Brown , Linus Torvalds , linux-pm@vger.kernel.org, jpoimboe@redhat.com, "Rafael J. Wysocki" , linux-kernel@vger.kernel.org, Ingo Molnar , Thomas Gleixner , Pavel Machek , hpa@zytor.com, xen-devel@lists.xenproject.org, Andrew Morton , Jiri Slaby , Boris Ostrovsky List-Id: linux-arch.vger.kernel.org SW50cm9kdWNlIG5ldyBDIG1hY3JvcyBmb3IgYW5ub3RhdGlvbnMgb2YgZnVuY3Rpb25zIGFuZCBk YXRhIGluCmFzc2VtYmx5LiBUaGVyZSBpcyBhIGxvbmctc3RhbmRpbmcgbWVzcyBpbiBtYWNyb3Mg bGlrZSBFTlRSWSwgRU5ELApFTkRQUk9DIGFuZCBzaW1pbGFyLiBUaGV5IGFyZSB1c2VkIGluIGRp ZmZlcmVudCBtYW5uZXJzIGFuZCBzb21ldGltZXMKaW5jb3JyZWN0bHkuCgpTbyBpbnRyb2R1Y2Ug bWFjcm9zIHdpdGggY2xlYXIgdXNlIHRvIGFubm90YXRlIGFzc2VtYmx5IGFzIGZvbGxvd3M6Cgph KSBTdXBwb3J0IG1hY3JvcyBmb3IgdGhlIG9uZXMgYmVsb3cKICAgU1lNX1RfRlVOQyAtLSB0eXBl IHVzZWQgYnkgYXNzZW1ibGVyIHRvIG1hcmsgZnVuY3Rpb25zCiAgIFNZTV9UX09CSkVDVCAtLSB0 eXBlIHVzZWQgYnkgYXNzZW1ibGVyIHRvIG1hcmsgZGF0YQogICBTWU1fVF9OT05FIC0tIHR5cGUg dXNlZCBieSBhc3NlbWJsZXIgdG8gbWFyayBlbnRyaWVzIG9mIHVua25vd24gdHlwZQoKICAgVGhl eSBhcmUgZGVmaW5lZCBhcyBTVFRfRlVOQywgU1RUX09CSkVDVCwgYW5kIFNUVF9OT1RZUEUKICAg cmVzcGVjdGl2ZWx5LiBBY2NvcmRpbmcgdG8gdGhlIGdhcyBtYW51YWwsIHRoaXMgaXMgdGhlIG1v c3QgcG9ydGFibGUKICAgd2F5LiBJIGFtIG5vdCBzdXJlIGFib3V0IG90aGVyIGFzc2VtYmxlcnMs IHNvIHdlIGNhbiBzd2l0Y2ggdGhpcyBiYWNrCiAgIHRvICVmdW5jdGlvbiBhbmQgJW9iamVjdCBp ZiB0aGlzIHR1cm5zIGludG8gYSBwcm9ibGVtLiBBcmNoaXRlY3R1cmVzCiAgIGNhbiBhbHNvIG92 ZXJyaWRlIHRoZW0gYnkgc29tZXRoaW5nIGxpa2UgIiwgQGZ1bmN0aW9uIiBpZiB0aGV5IG5lZWQu CgogICBTWU1fQV9BTElHTiwgU1lNX0FfTk9ORSAtLSBhbGlnbiB0aGUgc3ltYm9sPwogICBTWU1f TF9HTE9CQUwsIFNZTV9MX1dFQUssIFNZTV9MX0xPQ0FMIC0tIGxpbmthZ2Ugb2Ygc3ltYm9scwoK YikgTW9zdGx5IGludGVybmFsIGFubm90YXRpb25zLCB1c2VkIGJ5IHRoZSBvbmVzIGJlbG93CiAg IFNZTV9FTlRSWSAtLSB1c2Ugb25seSBpZiB5b3UgaGF2ZSB0byAoZm9yIG5vbi1wYWlyZWQgc3lt Ym9scykKICAgU1lNX1NUQVJUIC0tIHVzZSBvbmx5IGlmIHlvdSBoYXZlIHRvIChmb3IgcGFpcmVk IHN5bWJvbHMpCiAgIFNZTV9FTkQgLS0gdXNlIG9ubHkgaWYgeW91IGhhdmUgdG8gKGZvciBwYWly ZWQgc3ltYm9scykKCmMpIEFubm90YXRpb25zIGZvciBjb2RlCiAgIFNZTV9JTk5FUl9MQUJFTF9B TElHTiAtLSBvbmx5IGZvciBsYWJlbHMgaW4gdGhlIG1pZGRsZSBvZiBjb2RlCiAgIFNZTV9JTk5F Ul9MQUJFTCAtLSBvbmx5IGZvciBsYWJlbHMgaW4gdGhlIG1pZGRsZSBvZiBjb2RlCgogICBTWU1f RlVOQ19TVEFSVF9MT0NBTF9BTElBUyAtLSB1c2Ugd2hlcmUgdGhlcmUgYXJlIHR3byBsb2NhbCBu YW1lcyBmb3IKCW9uZSBmdW5jdGlvbgogICBTWU1fRlVOQ19TVEFSVF9BTElBUyAtLSB1c2Ugd2hl cmUgdGhlcmUgYXJlIHR3byBnbG9iYWwgbmFtZXMgZm9yIG9uZQoJZnVuY3Rpb24KICAgU1lNX0ZV TkNfRU5EX0FMSUFTIC0tIHRoZSBlbmQgb2YgTE9DQUxfQUxJQVNlZCBvciBBTElBU2VkIGZ1bmN0 aW9uCgogICBTWU1fRlVOQ19TVEFSVCAtLSB1c2UgZm9yIGdsb2JhbCBmdW5jdGlvbnMKICAgU1lN X0ZVTkNfU1RBUlRfTk9BTElHTiAtLSB1c2UgZm9yIGdsb2JhbCBmdW5jdGlvbnMsIHcvbyBhbGln bm1lbnQKICAgU1lNX0ZVTkNfU1RBUlRfTE9DQUwgLS0gdXNlIGZvciBsb2NhbCBmdW5jdGlvbnMK ICAgU1lNX0ZVTkNfU1RBUlRfTE9DQUxfTk9BTElHTiAtLSB1c2UgZm9yIGxvY2FsIGZ1bmN0aW9u cywgdy9vCglhbGlnbm1lbnQKICAgU1lNX0ZVTkNfU1RBUlRfV0VBSyAtLSB1c2UgZm9yIHdlYWsg ZnVuY3Rpb25zCiAgIFNZTV9GVU5DX1NUQVJUX1dFQUtfTk9BTElHTiAtLSB1c2UgZm9yIHdlYWsg ZnVuY3Rpb25zLCB3L28gYWxpZ25tZW50CiAgIFNZTV9GVU5DX0VORCAtLSB0aGUgZW5kIG9mIFNZ TV9GVU5DX1NUQVJUX0xPQ0FMLCBTWU1fRlVOQ19TVEFSVCwKCVNZTV9GVU5DX1NUQVJUX1dFQUss IC4uLgoKICAgRm9yIGZ1bmN0aW9ucyB3aXRoIHNwZWNpYWwgKG5vbi1DKSBjYWxsaW5nIGNvbnZl bnRpb25zOgogICBTWU1fQ09ERV9TVEFSVCAtLSB1c2UgZm9yIG5vbi1DIChzcGVjaWFsKSBmdW5j dGlvbnMKICAgU1lNX0NPREVfU1RBUlRfTk9BTElHTiAtLSB1c2UgZm9yIG5vbi1DIChzcGVjaWFs KSBmdW5jdGlvbnMsIHcvbwoJYWxpZ25tZW50CiAgIFNZTV9DT0RFX1NUQVJUX0xPQ0FMIC0tIHVz ZSBmb3IgbG9jYWwgbm9uLUMgKHNwZWNpYWwpIGZ1bmN0aW9ucwogICBTWU1fQ09ERV9TVEFSVF9M T0NBTF9OT0FMSUdOIC0tIHVzZSBmb3IgbG9jYWwgbm9uLUMgKHNwZWNpYWwpCglmdW5jdGlvbnMs IHcvbyBhbGlnbm1lbnQKICAgU1lNX0NPREVfRU5EIC0tIHRoZSBlbmQgb2YgU1lNX0NPREVfU1RB UlRfTE9DQUwgb3IgU1lNX0NPREVfU1RBUlQKCmQpIEZvciBkYXRhCiAgIFNZTV9EQVRBX1NUQVJU IC0tIGdsb2JhbCBkYXRhIHN5bWJvbAogICBTWU1fREFUQV9TVEFSVF9MT0NBTCAtLSBsb2NhbCBk YXRhIHN5bWJvbAogICBTWU1fREFUQV9FTkQgLS0gdGhlIGVuZCBvZiB0aGUgU1lNX0RBVEFfU1RB UlQgc3ltYm9sCiAgIFNZTV9EQVRBX0VORF9MQUJFTCAtLSB0aGUgbGFiZWxlZCBlbmQgb2YgU1lN X0RBVEFfU1RBUlQgc3ltYm9sCiAgIFNZTV9EQVRBIC0tIHN0YXJ0K2VuZCB3cmFwcGVyIGFyb3Vu ZCBzaW1wbGUgZ2xvYmFsIGRhdGEKICAgU1lNX0RBVEFfTE9DQUwgLS0gc3RhcnQrZW5kIHdyYXBw ZXIgYXJvdW5kIHNpbXBsZSBsb2NhbCBkYXRhCgo9PT09PT09PT09CgpUaGUgbWFjcm9zIGFsbG93 IHRvIHBhaXIgc3RhcnRzIGFuZCBlbmRzIG9mIGZ1bmN0aW9ucyBhbmQgbWFyayBmdW5jdGlvbnMK Y29ycmVjdGx5IGluIHRoZSBvdXRwdXQgRUxGIG9iamVjdHMuCgpBbGwgdXNlcnMgb2YgdGhlIG9s ZCBtYWNyb3MgaW4geDg2IGFyZSBjb252ZXJ0ZWQgdG8gdXNlIHRoZXNlIGluIGZ1cnRoZXIKcGF0 Y2hlcy4KClt2Ml0KKiB1c2UgU1lNXyBwcmVmaXggYW5kIHNhbmUgbmFtZXMKKiBhZGQgU1lNX1NU QVJUIGFuZCBTWU1fRU5EIGFuZCBwYXJhbWV0cml6ZSBhbGwgdGhlIG1hY3JvcwoKW3YzXQoqIGFk ZCBTWU1fREFUQSwgU1lNX0RBVEFfTE9DQUwsIGFuZCBTWU1fREFUQV9FTkRfTEFCRUwKClt2NF0K KiBhZGQgX05PQUxJR04gdmVyc2lvbnMgb2Ygc29tZSBtYWNyb3MKKiBhZGQgX0NPREVfIGRlcml2 YXRlcyBvZiBfRlVOQ18gbWFjcm9zCgpbdjVdCiogZHJvcCAiU0lNUExFIiBmcm9tIGRhdGEgYW5u b3RhdGlvbnMKKiBzd2l0Y2ggTk9BTElHTiBhbmQgQUxJR04gdmFyaWFudHMgb2YgaW5uZXIgbGFi ZWxzCiogcy92aXNpYmlsaXR5L2xpbmthZ2UvOyBzQFNZTV9WX0BTWU1fTF9ACiogYWRkIERvY3Vt ZW50YXRpb24KClt2Nl0KKiBmaXhlZCB0eXBvcyBmb3VuZCBieSBSYW5keSBEdW5sYXAKKiByZW1v dmUgZG91YmxlZCBJTk5FUl9MQUJFTCBtYWNyb3MsIG9uZSBwYWlyIHdhcyB1bnVzZWQKClNpZ25l ZC1vZmYtYnk6IEppcmkgU2xhYnkgPGpzbGFieUBzdXNlLmN6PgpDYzogQW5kcmV3IE1vcnRvbiA8 YWtwbUBsaW51eC1mb3VuZGF0aW9uLm9yZz4KQ2M6IEJvcmlzIE9zdHJvdnNreSA8Ym9yaXMub3N0 cm92c2t5QG9yYWNsZS5jb20+CkNjOiBocGFAenl0b3IuY29tCkNjOiBJbmdvIE1vbG5hciA8bWlu Z29Aa2VybmVsLm9yZz4KQ2M6IGpwb2ltYm9lQHJlZGhhdC5jb20KQ2M6IEp1ZXJnZW4gR3Jvc3Mg PGpncm9zc0BzdXNlLmNvbT4KQ2M6IExlbiBCcm93biA8bGVuLmJyb3duQGludGVsLmNvbT4KQ2M6 IExpbnVzIFRvcnZhbGRzIDx0b3J2YWxkc0BsaW51eC1mb3VuZGF0aW9uLm9yZz4KQ2M6IGxpbnV4 LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKQ2M6IGxpbnV4LXBtQHZnZXIua2VybmVsLm9yZwpDYzog bWluZ29AcmVkaGF0LmNvbQpDYzogUGF2ZWwgTWFjaGVrIDxwYXZlbEB1Y3cuY3o+CkNjOiBQZXRl ciBaaWpsc3RyYSA8YS5wLnppamxzdHJhQGNoZWxsby5ubD4KQ2M6ICJSYWZhZWwgSi4gV3lzb2Nr aSIgPHJqd0Byand5c29ja2kubmV0PgpDYzogVGhvbWFzIEdsZWl4bmVyIDx0Z2x4QGxpbnV0cm9u aXguZGU+CkNjOiB4ZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKQ2M6IHg4NkBrZXJuZWwu b3JnCi0tLQogRG9jdW1lbnRhdGlvbi9hc20tYW5ub3RhdGlvbnMucnN0IHwgMjE3ICsrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysKIGFyY2gveDg2L2luY2x1ZGUvYXNtL2xpbmthZ2Uu aCAgICB8ICAxMCArLQogaW5jbHVkZS9saW51eC9saW5rYWdlLmggICAgICAgICAgIHwgMjQzICsr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tCiAzIGZpbGVzIGNoYW5nZWQsIDQ2 MCBpbnNlcnRpb25zKCspLCAxMCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1 bWVudGF0aW9uL2FzbS1hbm5vdGF0aW9ucy5yc3QKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9u L2FzbS1hbm5vdGF0aW9ucy5yc3QgYi9Eb2N1bWVudGF0aW9uL2FzbS1hbm5vdGF0aW9ucy5yc3QK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4yNjVkNjRhMWZjMGIKLS0t IC9kZXYvbnVsbAorKysgYi9Eb2N1bWVudGF0aW9uL2FzbS1hbm5vdGF0aW9ucy5yc3QKQEAgLTAs MCArMSwyMTcgQEAKK0Fzc2VtYmxlciBBbm5vdGF0aW9ucworPT09PT09PT09PT09PT09PT09PT09 CisKK0NvcHlyaWdodCAoYykgMjAxNyBKaXJpIFNsYWJ5CisKK1RoaXMgZG9jdW1lbnQgZGVzY3Jp YmVzIHRoZSBuZXcgbWFjcm9zIGZvciBhbm5vdGF0aW9uIG9mIGRhdGEgYW5kIGNvZGUgaW4KK2Fz c2VtYmxlci4gSW4gcGFydGljdWxhciwgaXQgY29udGFpbnMgaW5mb3JtYXRpb24gYWJvdXQgYGBT WU1fRlVOQ19TVEFSVGBgLAorYGBTWU1fRlVOQ19FTkRgYCwgYGBTWU1fQ09ERV9TVEFSVGBgLCBh bmQgc2ltaWxhci4KKworUmF0aW9uYWxlCistLS0tLS0tLS0KK1NvbWUgY29kZSBsaWtlIGVudHJp ZXMsIHRyYW1wb2xpbmVzLCBvciBib290IGNvZGUgbmVlZHMgdG8gYmUgd3JpdHRlbiBpbgorYXNz ZW1ibHkuIFRoZSBzYW1lIGFzIGluIEMsIHdlIGdyb3VwIHN1Y2ggY29kZSBpbnRvIGZ1bmN0aW9u cyBhbmQgYWNjb21wYW55Cit0aGVtIHdpdGggZGF0YS4gU3RhbmRhcmQgYXNzZW1ibGVycyBkbyBu b3QgZm9yY2UgdXNlcnMgaW50byBwcmVjaXNlbHkgbWFya2luZwordGhlc2UgcGllY2VzIGFzIGNv ZGUsIGRhdGEsIG9yIGV2ZW4gc3BlY2lmeWluZyB0aGVpciBsZW5ndGguIE5ldmVydGhlbGVzcywK K2Fzc2VtYmxlcnMgcHJvdmlkZSBkZXZlbG9wZXJzIHdpdGggc3VjaCBtYXJrcyB0byBhaWQgZGVi dWdnZXJzIHRocm91Z2hvdXQKK2Fzc2VtYmx5LiBPbiB0aGUgdG9wIG9mIHRoYXQsIGRldmVsb3Bl cnMgYWxzbyB3YW50IHRvIHN0YW1wIHNvbWUgZnVuY3Rpb25zIGFzCisqZ2xvYmFsKiB0byBiZSB2 aXNpYmxlIG91dHNpZGUgb2YgdGhlaXIgdHJhbnNsYXRpb24gdW5pdHMuCisKK092ZXIgdGhlIHRp bWUsIHRoZSBMaW51eCBrZXJuZWwgdG9vayBvdmVyIG1hY3JvcyBmcm9tIHZhcmlvdXMgcHJvamVj dHMgKGxpa2UKK2BgYmludXRpbHNgYCkgdG8gZWFzZSB0aGVzZSBtYXJraW5ncy4gU28gZm9yIGhp c3RvcmljIHJlYXNvbnMsIHdlIGhhdmUgYmVlbgordXNpbmcgYGBFTlRSWWBgLCBgYEVORGBgLCBg YEVORFBST0NgYCwgYW5kIG90aGVyIGFubm90YXRpb25zIGluIGFzc2VtYmx5LiBEdWUKK3RvIHRo ZSBsYWNrIG9mIHRoZWlyIGRvY3VtZW50YXRpb24sIHRoZSBtYWNyb3MgYXJlIHVzZWQgaW4gcmF0 aGVyIHdyb25nCitjb250ZXh0cyBhdCBzb21lIGxvY2F0aW9ucy4gQ2xlYXJseSwgYGBFTlRSWWBg IHdhcyBpbnRlbmRlZCBmb3Igc3RhcnRzIG9mCitnbG9iYWwgc3ltYm9scyAoYmUgaXQgZGF0YSBv ciBjb2RlKS4gYGBFTkRgYCB1c2VkIHRvIGJlIHRoZSBlbmQgb2YgZGF0YSBvciBlbmQKK29mIHNw ZWNpYWwgZnVuY3Rpb25zIHdpdGggKm5vbi1zdGFuZGFyZCogY2FsbGluZyBjb252ZW50aW9uLiBJ biBjb250cmFzdCwKK2BgRU5EUFJPQ2BgIHNob3VsZCBhbm5vdGF0ZSBvbmx5IGVuZHMgb2YgKnN0 YW5kYXJkKiBmdW5jdGlvbnMuCisKK1doZW4gdGhlc2UgbWFjcm9zIGFyZSB1c2VkIGNvcnJlY3Rs eSwgdGhleSBoZWxwIGFzc2VtYmxlcnMgdG8gZ2VuZXJhdGUgYSBuaWNlCitvYmplY3Qgd2l0aCBi b3RoIHNpemVzIGFuZCB0eXBlcyBzZXQgY29ycmVjdGx5LiBGb3IgZXhhbXBsZSB0aGUgcmVzdWx0 IG9mCitgYGFyY2gveDg2L2xpYi9wdXR1c2VyLlNgYDo6CisKKyAgIE51bTogICAgVmFsdWUgICAg ICAgICAgU2l6ZSBUeXBlICAgIEJpbmQgICBWaXMgICAgICBOZHggTmFtZQorICAgIDI1OiAwMDAw MDAwMDAwMDAwMDAwICAgIDMzIEZVTkMgICAgR0xPQkFMIERFRkFVTFQgICAgMSBfX3B1dF91c2Vy XzEKKyAgICAyOTogMDAwMDAwMDAwMDAwMDAzMCAgICAzNyBGVU5DICAgIEdMT0JBTCBERUZBVUxU ICAgIDEgX19wdXRfdXNlcl8yCisgICAgMzI6IDAwMDAwMDAwMDAwMDAwNjAgICAgMzYgRlVOQyAg ICBHTE9CQUwgREVGQVVMVCAgICAxIF9fcHV0X3VzZXJfNAorICAgIDM1OiAwMDAwMDAwMDAwMDAw MDkwICAgIDM3IEZVTkMgICAgR0xPQkFMIERFRkFVTFQgICAgMSBfX3B1dF91c2VyXzgKKworVGhp cyBpcyBub3Qgb25seSBpbXBvcnRhbnQgZm9yIGRlYnVnZ2luZyBwdXJwb3Nlcy4gV2hlbiB3ZSBo YXZlIHByb3Blcmx5CittYXJrZWQgb2JqZWN0cyBsaWtlIHRoaXMsIHdlIGNhbiBydW4gdG9vbHMg b24gdGhlbSBhbmQgbGV0IHRoZSB0b29scyBnZW5lcmF0ZQorbW9yZSB1c2VmdWwgaW5mb3JtYXRp b24uIEluIHBhcnRpY3VsYXIsIG9uIHByb3Blcmx5IG1hcmtlZCBvYmplY3RzLCB3ZSBjYW4gcnVu CitgYG9ianRvb2xgYCBhbmQgbGV0IGl0IGNoZWNrIGFuZCBmaXggdGhlIG9iamVjdCBpZiBuZWVk ZWQuIEN1cnJlbnRseSwgaXQgY2FuCityZXBvcnQgbWlzc2luZyBmcmFtZSBwb2ludGVyIHNldHVw L2Rlc3RydWN0aW9uIGluIGZ1bmN0aW9ucy4gSXQgY2FuIGFsc28KK2F1dG9tYXRpY2FsbHkgZ2Vu ZXJhdGUgYW5ub3RhdGlvbnMgZm9yICpPUkMgdW53aW5kZXIqIChjZi4KKzxEb2N1bWVudGF0aW9u L3g4Ni9vcmMtdW53aW5kZXIudHh0PikgZm9yIG1vc3QgY29kZS4gQm90aCBvZiB0aGVzZSBhcmUK K2VzcGVjaWFsbHkgaW1wb3J0YW50IHRvIHN1cHBvcnQgcmVsaWFibGUgc3RhY2sgdHJhY2VzIHdo aWNoIGFyZSBpbiB0dXJuCituZWNlc3NhcnkgZm9yICpLZXJuZWwgbGl2ZSBwYXRjaGluZyogKHNl ZQorPERvY3VtZW50YXRpb24vbGl2ZXBhdGNoL2xpdmVwYXRjaC50eHQ+KS4KKworQ2F2ZWF0IGFu ZCBEaXNjdXNzaW9uCistLS0tLS0tLS0tLS0tLS0tLS0tLS0KK0FzIG9uZSBtaWdodCByZWFsaXpl LCB0aGVyZSB3ZXJlIG9ubHkgdGhyZWUgbWFjcm9zIHByZXZpb3VzbHkuIFRoYXQgaXMgaW5kZWVk CitpbnN1ZmZpY2llbnQgdG8gY292ZXIgYWxsIHRoZSBjb21iaW5hdGlvbnMgb2YgY2FzZXM6CisK Kyogc3RhbmRhcmQvbm9uLXN0YW5kYXJkIGZ1bmN0aW9uCisqIGNvZGUvZGF0YQorKiBnbG9iYWwv bG9jYWwgc3ltYm9sCisKK1dlIGhhZCBhIGRpc2N1c3Npb25fIGFuZCBpbnN0ZWFkIG9mIGV4dGVu ZGluZyB0aGUgY3VycmVudCBgYEVOVFJZL0VORCpgYAorbWFjcm9zLCBpdCB3YXMgZGVjaWRlZCB0 aGF0IHdlIHNob3VsZCBpbnRyb2R1Y2UgYnJhbmQgbmV3IG1hY3JvcyBpbnN0ZWFkOjoKKworICAg IFNvIGhvdyBhYm91dCB1c2luZyBtYWNybyBuYW1lcyB0aGF0IGFjdHVhbGx5IHNob3cgdGhlIHB1 cnBvc2UsIGluc3RlYWQKKyAgICBvZiBpbXBvcnRpbmcgYWxsIHRoZSBjcmFwcHksIGhpc3Rvcmlj LCBlc3NlbnRpYWxseSByYW5kb21seSBjaG9zZW4KKyAgICBkZWJ1ZyBzeW1ib2wgbWFjcm8gbmFt ZXMgZnJvbSB0aGUgYmludXRpbHMgYW5kIG9sZGVyIGtlcm5lbHM/CisKKy4uIF9kaXNjdXNzaW9u OiBodHRwczovL21hcmMuaW5mby8/aT0yMDE3MDIxNzEwNDc1Ny4yODU4OC0xLWpzbGFieSU0MHN1 c2UuY3oKKworTWFjcm9zIERlc2NyaXB0aW9uCistLS0tLS0tLS0tLS0tLS0tLS0KKworVGhlIG5l dyBtYWNyb3MgYXJlIHByZWZpeGVkIHdpdGggdGhlIGBgU1lNX2BgIHByZWZpeCBhbmQgY2FuIGJl IGRpdmlkZWQgaW50bwordGhyZWUgbWFpbiBncm91cHM6CisKKzEuIGBgU1lNX0ZVTkNfKmBgIC0t IHRvIGFubm90YXRlIEMtbGlrZSBmdW5jdGlvbnMuIFRoaXMgbWVhbnMgZnVuY3Rpb25zIHdpdGgK KyAgIHN0YW5kYXJkIEMgY2FsbGluZyBjb252ZW50aW9ucywgaS5lLiB0aGUgc3RhY2sgY29udGFp bnMgYSByZXR1cm4gYWRkcmVzcyBhdAorICAgdGhlIHByZWRlZmluZWQgcGxhY2UgYW5kIGEgcmV0 dXJuIGZyb20gdGhlIGZ1bmN0aW9uIGNhbiBoYXBwZW4gaW4gYQorICAgc3RhbmRhcmQgd2F5LiBX aGVuIGZyYW1lIHBvaW50ZXJzIGFyZSBlbmFibGVkLCBzYXZlL3Jlc3RvcmUgb2YgZnJhbWUKKyAg IHBvaW50ZXIgc2hhbGwgaGFwcGVuIGF0IHRoZSBzdGFydC9lbmQgb2YgYSBmdW5jdGlvbiwgcmVz cGVjdGl2ZWx5LCB0b28uCisKKyAgIENoZWNraW5nIHRvb2xzIGxpa2UgYGBvYmp0b29sYGAgc2hv dWxkIGVuc3VyZSBzdWNoIG1hcmtlZCBmdW5jdGlvbnMgY29uZm9ybQorICAgdG8gdGhlc2UgcnVs ZXMuIFRoZSB0b29scyBjYW4gYWxzbyBlYXNpbHkgYW5ub3RhdGUgdGhlc2UgZnVuY3Rpb25zIHdp dGgKKyAgIGRlYnVnZ2luZyBpbmZvcm1hdGlvbiAobGlrZSAqT1JDIGRhdGEqKSBhdXRvbWF0aWNh bGx5LgorCisyLiBgYFNZTV9DT0RFXypgYCAtLSBzcGVjaWFsIGZ1bmN0aW9ucyBjYWxsZWQgd2l0 aCBzcGVjaWFsIHN0YWNrLiBCZSBpdAorICAgaW50ZXJydXB0IGhhbmRsZXJzIHdpdGggc3BlY2lh bCBzdGFjayBjb250ZW50LCB0cmFtcG9saW5lcywgb3Igc3RhcnR1cAorICAgZnVuY3Rpb25zLgor CisgICBDaGVja2luZyB0b29scyBtb3N0bHkgaWdub3JlIGNoZWNraW5nIG9mIHRoZXNlIGZ1bmN0 aW9ucy4gQnV0IHNvbWUgZGVidWcKKyAgIGluZm9ybWF0aW9uIHN0aWxsIGNhbiBiZSBnZW5lcmF0 ZWQgYXV0b21hdGljYWxseS4gRm9yIGNvcnJlY3QgZGVidWcgZGF0YSwKKyAgIHRoaXMgY29kZSBu ZWVkcyBoaW50cyBsaWtlIGBgVU5XSU5EX0hJTlRfUkVHU2BgIHByb3ZpZGVkIGJ5IGRldmVsb3Bl cnMuCisKKzMuIGBgU1lNX0RBVEEqYGAgLS0gb2J2aW91c2x5IGRhdGEgYmVsb25naW5nIHRvIGBg LmRhdGFgYCBzZWN0aW9ucyBhbmQgbm90IHRvCisgICBgYC50ZXh0YGAuIERhdGEgZG8gbm90IGNv bnRhaW4gaW5zdHJ1Y3Rpb25zLCBzbyB0aGV5IGhhdmUgdG8gYmUgdHJlYXRlZAorICAgc3BlY2lh bGx5IGJ5IHRoZSB0b29sczogdGhleSBzaG91bGQgbm90IHRyZWF0IHRoZSBieXRlcyBhcyBpbnN0 cnVjdGlvbnMsCisgICBub3IgYXNzaWduIGFueSBkZWJ1ZyBpbmZvcm1hdGlvbiB0byB0aGVtLgor CitJbnN0cnVjdGlvbiBNYWNyb3MKK35+fn5+fn5+fn5+fn5+fn5+fgorVGhpcyBzZWN0aW9uIGNv dmVycyBgYFNZTV9GVU5DXypgYCBhbmQgYGBTWU1fQ09ERV8qYGAgZW51bWVyYXRlZCBhYm92ZS4K KworKiBgYFNZTV9GVU5DX1NUQVJUYGAgYW5kIGBgU1lNX0ZVTkNfU1RBUlRfTE9DQUxgYCBhcmUg c3VwcG9zZWQgdG8gYmUgKip0aGUKKyAgbW9zdCBmcmVxdWVudCBtYXJraW5ncyoqLiBUaGV5IGFy ZSB1c2VkIGZvciBmdW5jdGlvbnMgd2l0aCBzdGFuZGFyZCBjYWxsaW5nCisgIGNvbnZlbnRpb25z IC0tIGdsb2JhbCBhbmQgbG9jYWwuIExpa2UgaW4gQywgdGhleSBib3RoIGFsaWduIHRoZSBmdW5j dGlvbnMgdG8KKyAgYXJjaGl0ZWN0dXJlIHNwZWNpZmljIGBgX19BTElHTmBgIGJ5dGVzLiBUaGVy ZSBhcmUgYWxzbyBgYF9OT0FMSUdOYGAgdmFyaWFudHMKKyAgZm9yIHNwZWNpYWwgY2FzZXMgd2hl cmUgZGV2ZWxvcGVycyBkbyBub3Qgd2FudCB0aGlzIGltcGxpY2l0IGFsaWdubWVudC4KKworICBX ZSBvZmZlciBhbHNvIGBgU1lNX0ZVTkNfU1RBUlRfV0VBS2BgIGFuZCBgYFNZTV9GVU5DX1NUQVJU X1dFQUtfTk9BTElHTmBgCisgIG1hcmtzIGFzIGFuIGFzc2VtYmxlciBjb3VudGVycGFydCBvZiB0 aGUgKndlYWsqIGF0dHJpYnV0ZSBrbm93biBmcm9tIEMuCisKKyAgQWxsIG9mIHRoZXNlICoqc2hh bGwqKiBiZSBjb3VwbGVkIHdpdGggYGBTWU1fRlVOQ19FTkRgYC4gRmlyc3QsIGl0IG1hcmtzCisg IHRoZSBzZXF1ZW5jZSBvZiBpbnN0cnVjdGlvbnMgYXMgYSBmdW5jdGlvbiBhbmQgY29tcHV0ZXMg aXRzIHNpemUgdG8gdGhlCisgIGdlbmVyYXRlZCBvYmplY3QgZmlsZS4gU2Vjb25kLCBpdCBhbHNv IGVhc2VzIGNoZWNraW5nIGFuZCBwcm9jZXNzaW5nIHN1Y2gKKyAgb2JqZWN0IGZpbGVzIGFzIHRo ZSB0b29scyBjYW4gdHJpdmlhbGx5IGZpbmQgZXhhY3Qgc3RhcnQgYW5kIGVuZCBvZiBhCisgIGZ1 bmN0aW9uLgorCisgIFNvIGluIG1vc3QgY2FzZXMsIGRldmVsb3BlcnMgc2hvdWxkIHdyaXRlIHNv bWV0aGluZyBsaWtlIGluIHRoZSBmb2xsb3dpbmcKKyAgZXhhbXBsZSwgaGF2aW5nIG1vcmUgaW5z dHJ1Y3Rpb25zIGluIGJldHdlZW4gdGhlIG1hY3Jvcywgb2YgY291cnNlOjoKKworICAgIFNZTV9G VU5DX1NUQVJUKGZ1bmN0aW9uX2hvb2spCisgICAgICAgIHJldHEKKyAgICBTWU1fRlVOQ19FTkQo ZnVuY3Rpb25faG9vaykKKworICBJbiBmYWN0LCB0aGlzIGtpbmQgb2YgYW5ub3RhdGlvbiBjb3Jy ZXNwb25kcyB0byBub3cgZGVwcmVjYXRlZCBgYEVOVFJZYGAgYW5kCisgIGBgRU5EUFJPQ2BgLgor CisqIGBgU1lNX0ZVTkNfU1RBUlRfQUxJQVNgYCBhbmQgYGBTWU1fRlVOQ19TVEFSVF9MT0NBTF9B TElBU2BgIHNlcnZlIGZvciB0aG9zZQorICB3aG8gZGVjaWRlZCB0byBoYXZlIHR3byBvciBtb3Jl IG5hbWVzIGZvciBvbmUgZnVuY3Rpb24uIFRoZSB0eXBpY2FsIHVzZSBpczo6CisKKyAgICBTWU1f RlVOQ19TVEFSVF9BTElBUyhfX21lbXNldCkKKyAgICBTWU1fRlVOQ19TVEFSVChtZW1zZXQpCisg ICAgICAgIC4uLgorICAgIFNZTV9GVU5DX0VORChtZW1zZXQpCisgICAgU1lNX0ZVTkNfRU5EX0FM SUFTKF9fbWVtc2V0KQorCisgIEluIHRoaXMgZXhhbXBsZSwgb25lIGNhbiBjYWxsIGBgX19tZW1z ZXRgYCBvciBgYG1lbXNldGBgIHdpdGggdGhlIHNhbWUKKyAgcmVzdWx0LiBFeGNlcHQgdGhlIGRl YnVnIGluZm9ybWF0aW9uIGZvciB0aGUgaW5zdHJ1Y3Rpb25zIGlzIGdlbmVyYXRlZCB0bworICB0 aGUgb2JqZWN0IGZpbGUgb25seSBvbmNlIC0tIGZvciB0aGUgbm9uLWBgQUxJQVNgYCBjYXNlLgor CisqIGBgU1lNX0NPREVfU1RBUlRgYCBhbmQgYGBTWU1fQ09ERV9TVEFSVF9MT0NBTGBgIHNob3Vs ZCBiZSB1c2VkIG9ubHkgaW4KKyAgc3BlY2lhbCBjYXNlcyAtLSBpZiB5b3Uga25vdyB3aGF0IHlv dSBhcmUgZG9pbmcuIFRoaXMgaXMgdXNlZCBleGNsdXNpdmVseQorICBmb3IgaW50ZXJydXB0IGhh bmRsZXJzIGFuZCBzaW1pbGFyIHdoZXJlIHRoZSBjYWxsaW5nIGNvbnZlbnRpb24gaXMgbm90IHRo ZSBDCisgIG9uZS4gYGBfTk9BTElHTmBgIHZhcmlhbnRzIGV4aXN0IHRvby4gVGhlIHVzZSBpcyB0 aGUgc2FtZSBhcyBmb3IgdGhlIGBgRlVOQ2BgCisgIGNhdGVnb3J5IGFib3ZlOjoKKworICAgIFNZ TV9DT0RFX1NUQVJUX0xPQ0FMKGJhZF9wdXRfdXNlcikKKyAgICAgICAgbW92bCAkLUVGQVVMVCwl ZWF4CisgICAgICAgIEVYSVQKKyAgICBTWU1fQ09ERV9FTkQoYmFkX3B1dF91c2VyKQorCisgIEFn YWluLCBldmVyeSBgYFNZTV9DT0RFX1NUQVJUKmBgICoqc2hhbGwqKiBiZSBjb3VwbGVkIGJ5IGBg U1lNX0NPREVfRU5EYGAuCisKKyAgVG8gc29tZSBleHRlbnQsIHRoaXMgY2F0ZWdvcnkgY29ycmVz cG9uZHMgdG8gZGVwcmVjYXRlZCBgYEVOVFJZYGAgYW5kCisgIGBgRU5EYGAuIEV4Y2VwdCBgYEVO RGBgIGhhZCBzZXZlcmFsIG90aGVyIG1lYW5pbmdzIHRvby4KKworKiBgYFNZTV9JTk5FUl9MQUJF TCpgYCBpcyB1c2VkIHRvIGRlbm90ZSBhIGxhYmVsIGluc2lkZSBzb21lCisgIGBgU1lNX3tDT0RF LEZVTkN9X1NUQVJUYGAgYW5kIGBgU1lNX3tDT0RFLEZVTkN9X0VORGBgLiAgVGhleSBhcmUgdmVy eSBzaW1pbGFyCisgIHRvIEMgbGFiZWxzLCBleGNlcHQgdGhleSBjYW4gYmUgbWFkZSBnbG9iYWwu IEFuIGV4YW1wbGUgb2YgdXNlOjoKKworICAgIFNZTV9DT0RFX1NUQVJUKGZ0cmFjZV9jYWxsZXIp CisgICAgICAgIC8qIHNhdmVfbWNvdW50X3JlZ3MgZmlsbHMgaW4gZmlyc3QgdHdvIHBhcmFtZXRl cnMgKi8KKyAgICAgICAgLi4uCisKKyAgICBTWU1fSU5ORVJfTEFCRUwoZnRyYWNlX2NhbGxlcl9v cF9wdHIsIFNZTV9MX0dMT0JBTCkKKyAgICAgICAgLyogTG9hZCB0aGUgZnRyYWNlX29wcyBpbnRv IHRoZSAzcmQgcGFyYW1ldGVyICovCisgICAgICAgIC4uLgorCisgICAgU1lNX0lOTkVSX0xBQkVM KGZ0cmFjZV9jYWxsLCBTWU1fTF9HTE9CQUwpCisgICAgICAgIGNhbGwgZnRyYWNlX3N0dWIKKyAg ICAgICAgLi4uCisgICAgICAgIHJldHEKKyAgICBTWU1fQ09ERV9FTkQoZnRyYWNlX2NhbGxlcikK KworRGF0YSBNYWNyb3MKK35+fn5+fn5+fn5+CitTaW1pbGFyIHRvIGluc3RydWN0aW9ucywgd2Ug aGF2ZSBhIGNvdXBsZSBvZiBtYWNyb3MgdG8gZGVzY3JpYmUgZGF0YSBpbiB0aGUKK2Fzc2VtYmx5 LiBBZ2FpbiwgdGhleSBoZWxwIGRlYnVnZ2VycyB0byB1bmRlcnN0YW5kIHRoZSBsYXlvdXQgb2Yg dGhlIHJlc3VsdGluZworb2JqZWN0IGZpbGVzLgorCisqIGBgU1lNX0RBVEFfU1RBUlRgYCBhbmQg YGBTWU1fREFUQV9TVEFSVF9MT0NBTGBgIG1hcmsgdGhlIHN0YXJ0IG9mIHNvbWUgZGF0YQorICBh bmQgc2hhbGwgYmUgdXNlZCBpbiBjb25qdW5jdGlvbiB3aXRoIGVpdGhlciBgYFNZTV9EQVRBX0VO RGBgLCBvcgorICBgYFNZTV9EQVRBX0VORF9MQUJFTGBgLiBUaGUgbGF0dGVyIGFkZHMgYWxzbyBh IGxhYmVsIHRvIHRoZSBlbmQsIHNvIHRoYXQKKyAgcGVvcGxlIGNhbiB1c2UgYGBsc3RhY2tgYCBh bmQgKGxvY2FsKSBgYGxzdGFja19lbmRgYCBpbiB0aGUgZm9sbG93aW5nCisgIGV4YW1wbGU6Ogor CisgICAgU1lNX0RBVEFfU1RBUlRfTE9DQUwobHN0YWNrKQorICAgICAgICAuc2tpcCA0MDk2Cisg ICAgU1lNX0RBVEFfRU5EX0xBQkVMKGxzdGFjaywgU1lNX0xfTE9DQUwsIGxzdGFja19lbmQpCisK KyogYGBTWU1fREFUQWBgIGFuZCBgYFNZTV9EQVRBX0xPQ0FMYGAgYXJlIHZhcmlhbnRzIGZvciBz aW1wbGUsIG1vc3RseSBvbmUtbGluZQorICBkYXRhOjoKKworICAgIFNZTV9EQVRBKEhFQVAsICAg ICAubG9uZyBybV9oZWFwKQorICAgIFNZTV9EQVRBKGhlYXBfZW5kLCAubG9uZyBybV9zdGFjaykK KworICBJbiB0aGUgZW5kLCB0aGV5IGV4cGFuZCB0byBgYFNZTV9EQVRBX1NUQVJUYGAgd2l0aCBg YFNZTV9EQVRBX0VORGBgCisgIGludGVybmFsbHkuCisKK1N1cHBvcnQgTWFjcm9zCit+fn5+fn5+ fn5+fn5+fgorQWxsIHRoZSBhYm92ZSByZWR1Y2UgdGhlbXNlbHZlcyB0byBzb21lIGludm9jYXRp b24gb2YgYGBTWU1fU1RBUlRgYCwKK2BgU1lNX0VORGBgLCBvciBgYFNZTV9FTlRSWWBgIGF0IGxh c3QuIE5vcm1hbGx5LCBkZXZlbG9wZXJzIHNob3VsZCBhdm9pZCB1c2luZwordGhlc2UuCisKK0Z1 cnRoZXIsIGluIHRoZSBhYm92ZSBleGFtcGxlcywgb25lIGNvdWxkIHNlZSBgYFNZTV9MX0xPQ0FM YGAuIFRoZXJlIGFyZSBhbHNvCitgYFNZTV9MX0dMT0JBTGBgIGFuZCBgYFNZTV9MX1dFQUtgYC4g QWxsIGFyZSBpbnRlbmRlZCB0byBkZW5vdGUgbGlua2FnZSBvZiBhCitzeW1ib2wgbWFya2VkIGJ5 IHRoZW0uIFRoZXkgYXJlIHVzZWQgZWl0aGVyIGluIGBgX0xBQkVMYGAgdmFyaWFudHMgb2YgdGhl CitlYXJsaWVyIG1hY3Jvcywgb3IgaW4gYGBTWU1fU1RBUlRgYC4KKworCitPdmVycmlkaW5nIE1h Y3Jvcworfn5+fn5+fn5+fn5+fn5+fn4KK0FyY2hpdGVjdHVyZSBjYW4gYWxzbyBvdmVycmlkZSBh bnkgb2YgdGhlIG1hY3JvcyBpbiB0aGVpciBvd24KK2BgYXNtL2xpbmthZ2UuaGBgLCBpbmNsdWRp bmcgbWFjcm9zIHNwZWNpZnlpbmcgdGhlIHR5cGUgb2YgYSBzeW1ib2wKKyhgYFNZTV9UX0ZVTkNg YCwgYGBTWU1fVF9PQkpFQ1RgYCwgYW5kIGBgU1lNX1RfTk9ORWBgKS4gIEFzIGV2ZXJ5IG1hY3Jv CitkZXNjcmliZWQgaW4gdGhpcyBmaWxlIGlzIHN1cnJvdW5kZWQgYnkgYGAjaWZkZWZgYCArIGBg I2VuZGlmYGAsIGl0IGlzIGVub3VnaAordG8gZGVmaW5lIHRoZSBtYWNyb3MgZGlmZmVyZW50bHkg aW4gdGhlIGFmb3JlbWVudGlvbmVkIGFyY2hpdGVjdHVyZS1kZXBlbmRlbnQKK2hlYWRlci4KZGlm ZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2xpbmthZ2UuaCBiL2FyY2gveDg2L2luY2x1 ZGUvYXNtL2xpbmthZ2UuaAppbmRleCAxNGNhYTlkOWZiN2YuLmUwNzE4OGU4ZDc2MyAxMDA2NDQK LS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vbGlua2FnZS5oCisrKyBiL2FyY2gveDg2L2luY2x1 ZGUvYXNtL2xpbmthZ2UuaApAQCAtMTMsOSArMTMsMTMgQEAKIAogI2lmZGVmIF9fQVNTRU1CTFlf XwogCi0jZGVmaW5lIEdMT0JBTChuYW1lKQlcCi0JLmdsb2JsIG5hbWU7CVwKLQluYW1lOgorLyoK KyAqIEdMT0JBTCBpcyBERVBSRUNBVEVECisgKgorICogdXNlIFNZTV9EQVRBX1NUQVJULCBTWU1f RlVOQ19TVEFSVCwgU1lNX0lOTkVSX0xBQkVMLCBTWU1fQ09ERV9TVEFSVCwgb3IKKyAqIHNpbWls YXIKKyAqLworI2RlZmluZSBHTE9CQUwobmFtZSkJU1lNX0VOVFJZKG5hbWUsIFNZTV9MX0dMT0JB TCwgU1lNX0FfTk9ORSkKIAogI2lmIGRlZmluZWQoQ09ORklHX1g4Nl82NCkgfHwgZGVmaW5lZChD T05GSUdfWDg2X0FMSUdOTUVOVF8xNikKICNkZWZpbmUgX19BTElHTgkJLnAyYWxpZ24gNCwgMHg5 MApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9saW5rYWdlLmggYi9pbmNsdWRlL2xpbnV4L2xp bmthZ2UuaAppbmRleCBmNjhkYjllNDUwZWIuLmU5MjBmZmEyYTk0MyAxMDA2NDQKLS0tIGEvaW5j bHVkZS9saW51eC9saW5rYWdlLmgKKysrIGIvaW5jbHVkZS9saW51eC9saW5rYWdlLmgKQEAgLTc1 LDI1ICs3NSw1MSBAQAogCiAjaWZkZWYgX19BU1NFTUJMWV9fCiAKKy8qIFNZTV9UX0ZVTkMgLS0g dHlwZSB1c2VkIGJ5IGFzc2VtYmxlciB0byBtYXJrIGZ1bmN0aW9ucyAqLworI2lmbmRlZiBTWU1f VF9GVU5DCisjZGVmaW5lIFNZTV9UX0ZVTkMJCQkJU1RUX0ZVTkMKKyNlbmRpZgorCisvKiBTWU1f VF9PQkpFQ1QgLS0gdHlwZSB1c2VkIGJ5IGFzc2VtYmxlciB0byBtYXJrIGRhdGEgKi8KKyNpZm5k ZWYgU1lNX1RfT0JKRUNUCisjZGVmaW5lIFNZTV9UX09CSkVDVAkJCQlTVFRfT0JKRUNUCisjZW5k aWYKKworLyogU1lNX1RfTk9ORSAtLSB0eXBlIHVzZWQgYnkgYXNzZW1ibGVyIHRvIG1hcmsgZW50 cmllcyBvZiB1bmtub3duIHR5cGUgKi8KKyNpZm5kZWYgU1lNX1RfTk9ORQorI2RlZmluZSBTWU1f VF9OT05FCQkJCVNUVF9OT1RZUEUKKyNlbmRpZgorCisvKiBTWU1fQV8qIC0tIGFsaWduIHRoZSBz eW1ib2w/ICovCisjZGVmaW5lIFNZTV9BX0FMSUdOCQkJCUFMSUdOCisjZGVmaW5lIFNZTV9BX05P TkUJCQkJLyogbm90aGluZyAqLworCisvKiBTWU1fTF8qIC0tIGxpbmthZ2Ugb2Ygc3ltYm9scyAq LworI2RlZmluZSBTWU1fTF9HTE9CQUwobmFtZSkJCQkuZ2xvYmwgbmFtZQorI2RlZmluZSBTWU1f TF9XRUFLKG5hbWUpCQkJLndlYWsgbmFtZQorI2RlZmluZSBTWU1fTF9MT0NBTChuYW1lKQkJCS8q IG5vdGhpbmcgKi8KKwogI2lmbmRlZiBMSU5LRVJfU0NSSVBUCiAjZGVmaW5lIEFMSUdOIF9fQUxJ R04KICNkZWZpbmUgQUxJR05fU1RSIF9fQUxJR05fU1RSCiAKKy8qID09PSBERVBSRUNBVEVEIGFu bm90YXRpb25zID09PSAqLworCiAjaWZuZGVmIEVOVFJZCisvKiBkZXByZWNhdGVkLCB1c2UgU1lN X0ZVTkNfU1RBUlQgKi8KICNkZWZpbmUgRU5UUlkobmFtZSkgXAotCS5nbG9ibCBuYW1lIEFTTV9O TCBcCi0JQUxJR04gQVNNX05MIFwKLQluYW1lOgorCVNZTV9GVU5DX1NUQVJUKG5hbWUpCiAjZW5k aWYKICNlbmRpZiAvKiBMSU5LRVJfU0NSSVBUICovCiAKICNpZm5kZWYgV0VBSworLyogZGVwcmVj YXRlZCwgdXNlIFNZTV9GVU5DX1NUQVJUX1dFQUsqICovCiAjZGVmaW5lIFdFQUsobmFtZSkJICAg XAotCS53ZWFrIG5hbWUgQVNNX05MICAgXAotCW5hbWU6CisJU1lNX0ZVTkNfU1RBUlRfV0VBS19O T0FMSUdOKG5hbWUpCiAjZW5kaWYKIAogI2lmbmRlZiBFTkQKKy8qIGRlcHJlY2F0ZWQsIHVzZSBT WU1fRlVOQ19FTkQsIFNZTV9EQVRBX0VORCwgb3IgU1lNX0VORCAqLwogI2RlZmluZSBFTkQobmFt ZSkgXAogCS5zaXplIG5hbWUsIC4tbmFtZQogI2VuZGlmCkBAIC0xMDMsMTEgKzEyOSwyMTQgQEAK ICAqIHN0YXRpYyBhbmFseXNpcyB0b29scyBzdWNoIGFzIHN0YWNrIGRlcHRoIGFuYWx5emVyLgog ICovCiAjaWZuZGVmIEVORFBST0MKKy8qIGRlcHJlY2F0ZWQsIHVzZSBTWU1fRlVOQ19FTkQgKi8K ICNkZWZpbmUgRU5EUFJPQyhuYW1lKSBcCi0JLnR5cGUgbmFtZSwgQGZ1bmN0aW9uIEFTTV9OTCBc Ci0JRU5EKG5hbWUpCisJU1lNX0ZVTkNfRU5EKG5hbWUpCiAjZW5kaWYKIAorLyogPT09IGdlbmVy aWMgYW5ub3RhdGlvbnMgPT09ICovCisKKy8qIFNZTV9FTlRSWSAtLSB1c2Ugb25seSBpZiB5b3Ug aGF2ZSB0byBmb3Igbm9uLXBhaXJlZCBzeW1ib2xzICovCisjaWZuZGVmIFNZTV9FTlRSWQorI2Rl ZmluZSBTWU1fRU5UUlkobmFtZSwgbGlua2FnZSwgYWxpZ24uLi4pCQlcCisJbGlua2FnZShuYW1l KSBBU01fTkwJCQkJXAorCWFsaWduIEFTTV9OTAkJCQkJXAorCW5hbWU6CiAjZW5kaWYKIAorLyog U1lNX1NUQVJUIC0tIHVzZSBvbmx5IGlmIHlvdSBoYXZlIHRvICovCisjaWZuZGVmIFNZTV9TVEFS VAorI2RlZmluZSBTWU1fU1RBUlQobmFtZSwgbGlua2FnZSwgYWxpZ24uLi4pCQlcCisJU1lNX0VO VFJZKG5hbWUsIGxpbmthZ2UsIGFsaWduKQorI2VuZGlmCisKKy8qIFNZTV9FTkQgLS0gdXNlIG9u bHkgaWYgeW91IGhhdmUgdG8gKi8KKyNpZm5kZWYgU1lNX0VORAorI2RlZmluZSBTWU1fRU5EKG5h bWUsIHN5bV90eXBlKQkJCQlcCisJLnR5cGUgbmFtZSBzeW1fdHlwZSBBU01fTkwJCQlcCisJLnNp emUgbmFtZSwgLi1uYW1lCiAjZW5kaWYKKworLyogPT09IGNvZGUgYW5ub3RhdGlvbnMgPT09ICov CisKKy8qCisgKiBGVU5DIC0tIEMtbGlrZSBmdW5jdGlvbnMgKHByb3BlciBzdGFjayBmcmFtZSBl dGMuKQorICogQ09ERSAtLSBub24tQyBjb2RlIChlLmcuIGlycSBoYW5kbGVycyB3aXRoIGRpZmZl cmVudCwgc3BlY2lhbCBzdGFjayBldGMuKQorICoKKyAqIE9ianRvb2wgdmFsaWRhdGVzIHN0YWNr IGZvciBGVU5DLCBidXQgbm90IGZvciBDT0RFLgorICogT2JqdG9vbCBnZW5lcmF0ZXMgZGVidWcg aW5mbyBmb3IgYm90aCBGVU5DICYgQ09ERSwgYnV0IG5lZWRzIHNwZWNpYWwKKyAqIGFubm90YXRp b25zIGZvciBlYWNoIENPREUncyBzdGFydCAodG8gZGVzY3JpYmUgdGhlIGFjdHVhbCBzdGFjayBm cmFtZSkuCisgKgorICogQUxJQVMgLS0gZG9lcyBub3QgZ2VuZXJhdGUgZGVidWcgaW5mbyAtLSB0 aGUgYWxpYXNlZCBmdW5jdGlvbiB3aWxsCisgKi8KKworLyogU1lNX0lOTkVSX0xBQkVMX0FMSUdO IC0tIG9ubHkgZm9yIGxhYmVscyBpbiB0aGUgbWlkZGxlIG9mIGNvZGUgKi8KKyNpZm5kZWYgU1lN X0lOTkVSX0xBQkVMX0FMSUdOCisjZGVmaW5lIFNZTV9JTk5FUl9MQUJFTF9BTElHTihuYW1lLCBs aW5rYWdlKQlcCisJLnR5cGUgbmFtZSBTWU1fVF9OT05FIEFTTV9OTAkJCVwKKwlTWU1fRU5UUlko bmFtZSwgbGlua2FnZSwgU1lNX0FfQUxJR04pCisjZW5kaWYKKworLyogU1lNX0lOTkVSX0xBQkVM IC0tIG9ubHkgZm9yIGxhYmVscyBpbiB0aGUgbWlkZGxlIG9mIGNvZGUgKi8KKyNpZm5kZWYgU1lN X0lOTkVSX0xBQkVMCisjZGVmaW5lIFNZTV9JTk5FUl9MQUJFTChuYW1lLCBsaW5rYWdlKQkJXAor CS50eXBlIG5hbWUgU1lNX1RfTk9ORSBBU01fTkwJCQlcCisJU1lNX0VOVFJZKG5hbWUsIGxpbmth Z2UsIFNZTV9BX05PTkUpCisjZW5kaWYKKworLyoKKyAqIFNZTV9GVU5DX1NUQVJUX0xPQ0FMX0FM SUFTIC0tIHVzZSB3aGVyZSB0aGVyZSBhcmUgdHdvIGxvY2FsIG5hbWVzIGZvciBvbmUKKyAqIGZ1 bmN0aW9uCisgKi8KKyNpZm5kZWYgU1lNX0ZVTkNfU1RBUlRfTE9DQUxfQUxJQVMKKyNkZWZpbmUg U1lNX0ZVTkNfU1RBUlRfTE9DQUxfQUxJQVMobmFtZSkJCVwKKwlTWU1fU1RBUlQobmFtZSwgU1lN X0xfTE9DQUwsIFNZTV9BX0FMSUdOKQorI2VuZGlmCisKKy8qCisgKiBTWU1fRlVOQ19TVEFSVF9B TElBUyAtLSB1c2Ugd2hlcmUgdGhlcmUgYXJlIHR3byBnbG9iYWwgbmFtZXMgZm9yIG9uZQorICog ZnVuY3Rpb24KKyAqLworI2lmbmRlZiBTWU1fRlVOQ19TVEFSVF9BTElBUworI2RlZmluZSBTWU1f RlVOQ19TVEFSVF9BTElBUyhuYW1lKQkJCVwKKwlTWU1fU1RBUlQobmFtZSwgU1lNX0xfR0xPQkFM LCBTWU1fQV9BTElHTikKKyNlbmRpZgorCisvKiBTWU1fRlVOQ19TVEFSVCAtLSB1c2UgZm9yIGds b2JhbCBmdW5jdGlvbnMgKi8KKyNpZm5kZWYgU1lNX0ZVTkNfU1RBUlQKKy8qCisgKiBUaGUgc2Ft ZSBhcyBTWU1fRlVOQ19TVEFSVF9BTElBUywgYnV0IHdlIHdpbGwgbmVlZCB0byBkaXN0aW5ndWlz aCB0aGVzZSB0d28KKyAqIGxhdGVyLgorICovCisjZGVmaW5lIFNZTV9GVU5DX1NUQVJUKG5hbWUp CQkJCVwKKwlTWU1fU1RBUlQobmFtZSwgU1lNX0xfR0xPQkFMLCBTWU1fQV9BTElHTikKKyNlbmRp ZgorCisvKiBTWU1fRlVOQ19TVEFSVF9OT0FMSUdOIC0tIHVzZSBmb3IgZ2xvYmFsIGZ1bmN0aW9u cywgdy9vIGFsaWdubWVudCAqLworI2lmbmRlZiBTWU1fRlVOQ19TVEFSVF9OT0FMSUdOCisjZGVm aW5lIFNZTV9GVU5DX1NUQVJUX05PQUxJR04obmFtZSkJCQlcCisJU1lNX1NUQVJUKG5hbWUsIFNZ TV9MX0dMT0JBTCwgU1lNX0FfTk9ORSkKKyNlbmRpZgorCisvKiBTWU1fRlVOQ19TVEFSVF9MT0NB TCAtLSB1c2UgZm9yIGxvY2FsIGZ1bmN0aW9ucyAqLworI2lmbmRlZiBTWU1fRlVOQ19TVEFSVF9M T0NBTAorLyogdGhlIHNhbWUgYXMgU1lNX0ZVTkNfU1RBUlRfTE9DQUxfQUxJQVMsIHNlZSBjb21t ZW50IG5lYXIgU1lNX0ZVTkNfU1RBUlQgKi8KKyNkZWZpbmUgU1lNX0ZVTkNfU1RBUlRfTE9DQUwo bmFtZSkJCQlcCisJU1lNX1NUQVJUKG5hbWUsIFNZTV9MX0xPQ0FMLCBTWU1fQV9BTElHTikKKyNl bmRpZgorCisvKiBTWU1fRlVOQ19TVEFSVF9MT0NBTF9OT0FMSUdOIC0tIHVzZSBmb3IgbG9jYWwg ZnVuY3Rpb25zLCB3L28gYWxpZ25tZW50ICovCisjaWZuZGVmIFNZTV9GVU5DX1NUQVJUX0xPQ0FM X05PQUxJR04KKyNkZWZpbmUgU1lNX0ZVTkNfU1RBUlRfTE9DQUxfTk9BTElHTihuYW1lKQkJXAor CVNZTV9TVEFSVChuYW1lLCBTWU1fTF9MT0NBTCwgU1lNX0FfTk9ORSkKKyNlbmRpZgorCisvKiBT WU1fRlVOQ19TVEFSVF9XRUFLIC0tIHVzZSBmb3Igd2VhayBmdW5jdGlvbnMgKi8KKyNpZm5kZWYg U1lNX0ZVTkNfU1RBUlRfV0VBSworI2RlZmluZSBTWU1fRlVOQ19TVEFSVF9XRUFLKG5hbWUpCQkJ XAorCVNZTV9TVEFSVChuYW1lLCBTWU1fTF9XRUFLLCBTWU1fQV9BTElHTikKKyNlbmRpZgorCisv KiBTWU1fRlVOQ19TVEFSVF9XRUFLX05PQUxJR04gLS0gdXNlIGZvciB3ZWFrIGZ1bmN0aW9ucywg dy9vIGFsaWdubWVudCAqLworI2lmbmRlZiBTWU1fRlVOQ19TVEFSVF9XRUFLX05PQUxJR04KKyNk ZWZpbmUgU1lNX0ZVTkNfU1RBUlRfV0VBS19OT0FMSUdOKG5hbWUpCQlcCisJU1lNX1NUQVJUKG5h bWUsIFNZTV9MX1dFQUssIFNZTV9BX05PTkUpCisjZW5kaWYKKworLyogU1lNX0ZVTkNfRU5EX0FM SUFTIC0tIHRoZSBlbmQgb2YgTE9DQUxfQUxJQVNlZCBvciBBTElBU2VkIGZ1bmN0aW9uICovCisj aWZuZGVmIFNZTV9GVU5DX0VORF9BTElBUworI2RlZmluZSBTWU1fRlVOQ19FTkRfQUxJQVMobmFt ZSkJCQlcCisJU1lNX0VORChuYW1lLCBTWU1fVF9GVU5DKQorI2VuZGlmCisKKy8qCisgKiBTWU1f RlVOQ19FTkQgLS0gdGhlIGVuZCBvZiBTWU1fRlVOQ19TVEFSVF9MT0NBTCwgU1lNX0ZVTkNfU1RB UlQsCisgKiBTWU1fRlVOQ19TVEFSVF9XRUFLLCAuLi4KKyAqLworI2lmbmRlZiBTWU1fRlVOQ19F TkQKKy8qIHRoZSBzYW1lIGFzIFNZTV9GVU5DX0VORF9BTElBUywgc2VlIGNvbW1lbnQgbmVhciBT WU1fRlVOQ19TVEFSVCAqLworI2RlZmluZSBTWU1fRlVOQ19FTkQobmFtZSkJCQkJXAorCVNZTV9F TkQobmFtZSwgU1lNX1RfRlVOQykKKyNlbmRpZgorCisvKiBTWU1fQ09ERV9TVEFSVCAtLSB1c2Ug Zm9yIG5vbi1DIChzcGVjaWFsKSBmdW5jdGlvbnMgKi8KKyNpZm5kZWYgU1lNX0NPREVfU1RBUlQK KyNkZWZpbmUgU1lNX0NPREVfU1RBUlQobmFtZSkJCQkJXAorCVNZTV9TVEFSVChuYW1lLCBTWU1f TF9HTE9CQUwsIFNZTV9BX0FMSUdOKQorI2VuZGlmCisKKy8qIFNZTV9DT0RFX1NUQVJUX05PQUxJ R04gLS0gdXNlIGZvciBub24tQyAoc3BlY2lhbCkgZnVuY3Rpb25zLCB3L28gYWxpZ25tZW50ICov CisjaWZuZGVmIFNZTV9DT0RFX1NUQVJUX05PQUxJR04KKyNkZWZpbmUgU1lNX0NPREVfU1RBUlRf Tk9BTElHTihuYW1lKQkJCVwKKwlTWU1fU1RBUlQobmFtZSwgU1lNX0xfR0xPQkFMLCBTWU1fQV9O T05FKQorI2VuZGlmCisKKy8qIFNZTV9DT0RFX1NUQVJUX0xPQ0FMIC0tIHVzZSBmb3IgbG9jYWwg bm9uLUMgKHNwZWNpYWwpIGZ1bmN0aW9ucyAqLworI2lmbmRlZiBTWU1fQ09ERV9TVEFSVF9MT0NB TAorI2RlZmluZSBTWU1fQ09ERV9TVEFSVF9MT0NBTChuYW1lKQkJCVwKKwlTWU1fU1RBUlQobmFt ZSwgU1lNX0xfTE9DQUwsIFNZTV9BX0FMSUdOKQorI2VuZGlmCisKKy8qCisgKiBTWU1fQ09ERV9T VEFSVF9MT0NBTF9OT0FMSUdOIC0tIHVzZSBmb3IgbG9jYWwgbm9uLUMgKHNwZWNpYWwpIGZ1bmN0 aW9ucywKKyAqIHcvbyBhbGlnbm1lbnQKKyAqLworI2lmbmRlZiBTWU1fQ09ERV9TVEFSVF9MT0NB TF9OT0FMSUdOCisjZGVmaW5lIFNZTV9DT0RFX1NUQVJUX0xPQ0FMX05PQUxJR04obmFtZSkJCVwK KwlTWU1fU1RBUlQobmFtZSwgU1lNX0xfTE9DQUwsIFNZTV9BX05PTkUpCisjZW5kaWYKKworLyog U1lNX0NPREVfRU5EIC0tIHRoZSBlbmQgb2YgU1lNX0NPREVfU1RBUlRfTE9DQUwsIFNZTV9DT0RF X1NUQVJULCAuLi4gKi8KKyNpZm5kZWYgU1lNX0NPREVfRU5ECisjZGVmaW5lIFNZTV9DT0RFX0VO RChuYW1lKQkJCQlcCisJU1lNX0VORChuYW1lLCBTWU1fVF9OT05FKQorI2VuZGlmCisKKy8qID09 PSBkYXRhIGFubm90YXRpb25zID09PSAqLworCisvKiBTWU1fREFUQV9TVEFSVCAtLSBnbG9iYWwg ZGF0YSBzeW1ib2wgKi8KKyNpZm5kZWYgU1lNX0RBVEFfU1RBUlQKKyNkZWZpbmUgU1lNX0RBVEFf U1RBUlQobmFtZSkJCQkJXAorCVNZTV9TVEFSVChuYW1lLCBTWU1fTF9HTE9CQUwsIFNZTV9BX05P TkUpCisjZW5kaWYKKworLyogU1lNX0RBVEFfU1RBUlQgLS0gbG9jYWwgZGF0YSBzeW1ib2wgKi8K KyNpZm5kZWYgU1lNX0RBVEFfU1RBUlRfTE9DQUwKKyNkZWZpbmUgU1lNX0RBVEFfU1RBUlRfTE9D QUwobmFtZSkJCQlcCisJU1lNX1NUQVJUKG5hbWUsIFNZTV9MX0xPQ0FMLCBTWU1fQV9OT05FKQor I2VuZGlmCisKKy8qIFNZTV9EQVRBX0VORCAtLSB0aGUgZW5kIG9mIFNZTV9EQVRBX1NUQVJUIHN5 bWJvbCAqLworI2lmbmRlZiBTWU1fREFUQV9FTkQKKyNkZWZpbmUgU1lNX0RBVEFfRU5EKG5hbWUp CQkJCVwKKwlTWU1fRU5EKG5hbWUsIFNZTV9UX09CSkVDVCkKKyNlbmRpZgorCisvKiBTWU1fREFU QV9FTkRfTEFCRUwgLS0gdGhlIGxhYmVsZWQgZW5kIG9mIFNZTV9EQVRBX1NUQVJUIHN5bWJvbCAq LworI2lmbmRlZiBTWU1fREFUQV9FTkRfTEFCRUwKKyNkZWZpbmUgU1lNX0RBVEFfRU5EX0xBQkVM KG5hbWUsIGxpbmthZ2UsIGxhYmVsKQlcCisJbGlua2FnZShsYWJlbCkgQVNNX05MCQkJCVwKKwku dHlwZSBsYWJlbCBTWU1fVF9PQkpFQ1QgQVNNX05MCQkJXAorCWxhYmVsOgkJCQkJCVwKKwlTWU1f RU5EKG5hbWUsIFNZTV9UX09CSkVDVCkKKyNlbmRpZgorCisvKiBTWU1fREFUQSAtLSBzdGFydCtl bmQgd3JhcHBlciBhcm91bmQgc2ltcGxlIGdsb2JhbCBkYXRhICovCisjaWZuZGVmIFNZTV9EQVRB CisjZGVmaW5lIFNZTV9EQVRBKG5hbWUsIGRhdGEuLi4pCQkJCVwKKwlTWU1fREFUQV9TVEFSVChu YW1lKSBBU01fTkwJCQkJXAorCWRhdGEgQVNNX05MCQkJCQkJXAorCVNZTV9EQVRBX0VORChuYW1l KQorI2VuZGlmCisKKy8qIFNZTV9EQVRBX0xPQ0FMIC0tIHN0YXJ0K2VuZCB3cmFwcGVyIGFyb3Vu ZCBzaW1wbGUgbG9jYWwgZGF0YSAqLworI2lmbmRlZiBTWU1fREFUQV9MT0NBTAorI2RlZmluZSBT WU1fREFUQV9MT0NBTChuYW1lLCBkYXRhLi4uKQkJCVwKKwlTWU1fREFUQV9TVEFSVF9MT0NBTChu YW1lKSBBU01fTkwJCQlcCisJZGF0YSBBU01fTkwJCQkJCQlcCisJU1lNX0RBVEFfRU5EKG5hbWUp CisjZW5kaWYKKworI2VuZGlmIC8qIF9fQVNTRU1CTFlfXyAqLworCisjZW5kaWYgLyogX0xJTlVY X0xJTktBR0VfSCAqLwotLSAKMi4xNi4zCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMu eGVucHJvamVjdC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3Rp bmZvL3hlbi1kZXZlbA== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx2.suse.de ([195.135.220.15]:45337 "EHLO mx2.suse.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753079AbeERJR2 (ORCPT ); Fri, 18 May 2018 05:17:28 -0400 From: Jiri Slaby Subject: [PATCH v6 01/28] linkage: new macros for assembler symbols Date: Fri, 18 May 2018 11:16:54 +0200 Message-ID: <20180518091721.7604-2-jslaby@suse.cz> In-Reply-To: <20180518091721.7604-1-jslaby@suse.cz> References: <20180518091721.7604-1-jslaby@suse.cz> Sender: linux-arch-owner@vger.kernel.org List-ID: To: mingo@redhat.com Cc: linux-arch@vger.kernel.org, linux-kernel@vger.kernel.org, Jiri Slaby , Andrew Morton , Boris Ostrovsky , hpa@zytor.com, Ingo Molnar , jpoimboe@redhat.com, Juergen Gross , Len Brown , Linus Torvalds , linux-pm@vger.kernel.org, Pavel Machek , Peter Zijlstra , "Rafael J. Wysocki" , Thomas Gleixner , xen-devel@lists.xenproject.org, x86@kernel.org Message-ID: <20180518091654.uhbBwBJPVavTUEhc8Hrx_nGgVJv7ac2isL6QnwYky90@z> Introduce new C macros for annotations of functions and data in assembly. There is a long-standing mess in macros like ENTRY, END, ENDPROC and similar. They are used in different manners and sometimes incorrectly. So introduce macros with clear use to annotate assembly as follows: a) Support macros for the ones below SYM_T_FUNC -- type used by assembler to mark functions SYM_T_OBJECT -- type used by assembler to mark data SYM_T_NONE -- type used by assembler to mark entries of unknown type They are defined as STT_FUNC, STT_OBJECT, and STT_NOTYPE respectively. According to the gas manual, this is the most portable way. I am not sure about other assemblers, so we can switch this back to %function and %object if this turns into a problem. Architectures can also override them by something like ", @function" if they need. SYM_A_ALIGN, SYM_A_NONE -- align the symbol? SYM_L_GLOBAL, SYM_L_WEAK, SYM_L_LOCAL -- linkage of symbols b) Mostly internal annotations, used by the ones below SYM_ENTRY -- use only if you have to (for non-paired symbols) SYM_START -- use only if you have to (for paired symbols) SYM_END -- use only if you have to (for paired symbols) c) Annotations for code SYM_INNER_LABEL_ALIGN -- only for labels in the middle of code SYM_INNER_LABEL -- only for labels in the middle of code SYM_FUNC_START_LOCAL_ALIAS -- use where there are two local names for one function SYM_FUNC_START_ALIAS -- use where there are two global names for one function SYM_FUNC_END_ALIAS -- the end of LOCAL_ALIASed or ALIASed function SYM_FUNC_START -- use for global functions SYM_FUNC_START_NOALIGN -- use for global functions, w/o alignment SYM_FUNC_START_LOCAL -- use for local functions SYM_FUNC_START_LOCAL_NOALIGN -- use for local functions, w/o alignment SYM_FUNC_START_WEAK -- use for weak functions SYM_FUNC_START_WEAK_NOALIGN -- use for weak functions, w/o alignment SYM_FUNC_END -- the end of SYM_FUNC_START_LOCAL, SYM_FUNC_START, SYM_FUNC_START_WEAK, ... For functions with special (non-C) calling conventions: SYM_CODE_START -- use for non-C (special) functions SYM_CODE_START_NOALIGN -- use for non-C (special) functions, w/o alignment SYM_CODE_START_LOCAL -- use for local non-C (special) functions SYM_CODE_START_LOCAL_NOALIGN -- use for local non-C (special) functions, w/o alignment SYM_CODE_END -- the end of SYM_CODE_START_LOCAL or SYM_CODE_START d) For data SYM_DATA_START -- global data symbol SYM_DATA_START_LOCAL -- local data symbol SYM_DATA_END -- the end of the SYM_DATA_START symbol SYM_DATA_END_LABEL -- the labeled end of SYM_DATA_START symbol SYM_DATA -- start+end wrapper around simple global data SYM_DATA_LOCAL -- start+end wrapper around simple local data ========== The macros allow to pair starts and ends of functions and mark functions correctly in the output ELF objects. All users of the old macros in x86 are converted to use these in further patches. [v2] * use SYM_ prefix and sane names * add SYM_START and SYM_END and parametrize all the macros [v3] * add SYM_DATA, SYM_DATA_LOCAL, and SYM_DATA_END_LABEL [v4] * add _NOALIGN versions of some macros * add _CODE_ derivates of _FUNC_ macros [v5] * drop "SIMPLE" from data annotations * switch NOALIGN and ALIGN variants of inner labels * s/visibility/linkage/; s@SYM_V_@SYM_L_@ * add Documentation [v6] * fixed typos found by Randy Dunlap * remove doubled INNER_LABEL macros, one pair was unused Signed-off-by: Jiri Slaby Cc: Andrew Morton Cc: Boris Ostrovsky Cc: hpa@zytor.com Cc: Ingo Molnar Cc: jpoimboe@redhat.com Cc: Juergen Gross Cc: Len Brown Cc: Linus Torvalds Cc: linux-kernel@vger.kernel.org Cc: linux-pm@vger.kernel.org Cc: mingo@redhat.com Cc: Pavel Machek Cc: Peter Zijlstra Cc: "Rafael J. Wysocki" Cc: Thomas Gleixner Cc: xen-devel@lists.xenproject.org Cc: x86@kernel.org --- Documentation/asm-annotations.rst | 217 ++++++++++++++++++++++++++++++++++ arch/x86/include/asm/linkage.h | 10 +- include/linux/linkage.h | 243 ++++++++++++++++++++++++++++++++++++-- 3 files changed, 460 insertions(+), 10 deletions(-) create mode 100644 Documentation/asm-annotations.rst diff --git a/Documentation/asm-annotations.rst b/Documentation/asm-annotations.rst new file mode 100644 index 000000000000..265d64a1fc0b --- /dev/null +++ b/Documentation/asm-annotations.rst @@ -0,0 +1,217 @@ +Assembler Annotations +===================== + +Copyright (c) 2017 Jiri Slaby + +This document describes the new macros for annotation of data and code in +assembler. In particular, it contains information about ``SYM_FUNC_START``, +``SYM_FUNC_END``, ``SYM_CODE_START``, and similar. + +Rationale +--------- +Some code like entries, trampolines, or boot code needs to be written in +assembly. The same as in C, we group such code into functions and accompany +them with data. Standard assemblers do not force users into precisely marking +these pieces as code, data, or even specifying their length. Nevertheless, +assemblers provide developers with such marks to aid debuggers throughout +assembly. On the top of that, developers also want to stamp some functions as +*global* to be visible outside of their translation units. + +Over the time, the Linux kernel took over macros from various projects (like +``binutils``) to ease these markings. So for historic reasons, we have been +using ``ENTRY``, ``END``, ``ENDPROC``, and other annotations in assembly. Due +to the lack of their documentation, the macros are used in rather wrong +contexts at some locations. Clearly, ``ENTRY`` was intended for starts of +global symbols (be it data or code). ``END`` used to be the end of data or end +of special functions with *non-standard* calling convention. In contrast, +``ENDPROC`` should annotate only ends of *standard* functions. + +When these macros are used correctly, they help assemblers to generate a nice +object with both sizes and types set correctly. For example the result of +``arch/x86/lib/putuser.S``:: + + Num: Value Size Type Bind Vis Ndx Name + 25: 0000000000000000 33 FUNC GLOBAL DEFAULT 1 __put_user_1 + 29: 0000000000000030 37 FUNC GLOBAL DEFAULT 1 __put_user_2 + 32: 0000000000000060 36 FUNC GLOBAL DEFAULT 1 __put_user_4 + 35: 0000000000000090 37 FUNC GLOBAL DEFAULT 1 __put_user_8 + +This is not only important for debugging purposes. When we have properly +marked objects like this, we can run tools on them and let the tools generate +more useful information. In particular, on properly marked objects, we can run +``objtool`` and let it check and fix the object if needed. Currently, it can +report missing frame pointer setup/destruction in functions. It can also +automatically generate annotations for *ORC unwinder* (cf. +) for most code. Both of these are +especially important to support reliable stack traces which are in turn +necessary for *Kernel live patching* (see +). + +Caveat and Discussion +--------------------- +As one might realize, there were only three macros previously. That is indeed +insufficient to cover all the combinations of cases: + +* standard/non-standard function +* code/data +* global/local symbol + +We had a discussion_ and instead of extending the current ``ENTRY/END*`` +macros, it was decided that we should introduce brand new macros instead:: + + So how about using macro names that actually show the purpose, instead + of importing all the crappy, historic, essentially randomly chosen + debug symbol macro names from the binutils and older kernels? + +.. _discussion: https://marc.info/?i=20170217104757.28588-1-jslaby%40suse.cz + +Macros Description +------------------ + +The new macros are prefixed with the ``SYM_`` prefix and can be divided into +three main groups: + +1. ``SYM_FUNC_*`` -- to annotate C-like functions. This means functions with + standard C calling conventions, i.e. the stack contains a return address at + the predefined place and a return from the function can happen in a + standard way. When frame pointers are enabled, save/restore of frame + pointer shall happen at the start/end of a function, respectively, too. + + Checking tools like ``objtool`` should ensure such marked functions conform + to these rules. The tools can also easily annotate these functions with + debugging information (like *ORC data*) automatically. + +2. ``SYM_CODE_*`` -- special functions called with special stack. Be it + interrupt handlers with special stack content, trampolines, or startup + functions. + + Checking tools mostly ignore checking of these functions. But some debug + information still can be generated automatically. For correct debug data, + this code needs hints like ``UNWIND_HINT_REGS`` provided by developers. + +3. ``SYM_DATA*`` -- obviously data belonging to ``.data`` sections and not to + ``.text``. Data do not contain instructions, so they have to be treated + specially by the tools: they should not treat the bytes as instructions, + nor assign any debug information to them. + +Instruction Macros +~~~~~~~~~~~~~~~~~~ +This section covers ``SYM_FUNC_*`` and ``SYM_CODE_*`` enumerated above. + +* ``SYM_FUNC_START`` and ``SYM_FUNC_START_LOCAL`` are supposed to be **the + most frequent markings**. They are used for functions with standard calling + conventions -- global and local. Like in C, they both align the functions to + architecture specific ``__ALIGN`` bytes. There are also ``_NOALIGN`` variants + for special cases where developers do not want this implicit alignment. + + We offer also ``SYM_FUNC_START_WEAK`` and ``SYM_FUNC_START_WEAK_NOALIGN`` + marks as an assembler counterpart of the *weak* attribute known from C. + + All of these **shall** be coupled with ``SYM_FUNC_END``. First, it marks + the sequence of instructions as a function and computes its size to the + generated object file. Second, it also eases checking and processing such + object files as the tools can trivially find exact start and end of a + function. + + So in most cases, developers should write something like in the following + example, having more instructions in between the macros, of course:: + + SYM_FUNC_START(function_hook) + retq + SYM_FUNC_END(function_hook) + + In fact, this kind of annotation corresponds to now deprecated ``ENTRY`` and + ``ENDPROC``. + +* ``SYM_FUNC_START_ALIAS`` and ``SYM_FUNC_START_LOCAL_ALIAS`` serve for those + who decided to have two or more names for one function. The typical use is:: + + SYM_FUNC_START_ALIAS(__memset) + SYM_FUNC_START(memset) + ... + SYM_FUNC_END(memset) + SYM_FUNC_END_ALIAS(__memset) + + In this example, one can call ``__memset`` or ``memset`` with the same + result. Except the debug information for the instructions is generated to + the object file only once -- for the non-``ALIAS`` case. + +* ``SYM_CODE_START`` and ``SYM_CODE_START_LOCAL`` should be used only in + special cases -- if you know what you are doing. This is used exclusively + for interrupt handlers and similar where the calling convention is not the C + one. ``_NOALIGN`` variants exist too. The use is the same as for the ``FUNC`` + category above:: + + SYM_CODE_START_LOCAL(bad_put_user) + movl $-EFAULT,%eax + EXIT + SYM_CODE_END(bad_put_user) + + Again, every ``SYM_CODE_START*`` **shall** be coupled by ``SYM_CODE_END``. + + To some extent, this category corresponds to deprecated ``ENTRY`` and + ``END``. Except ``END`` had several other meanings too. + +* ``SYM_INNER_LABEL*`` is used to denote a label inside some + ``SYM_{CODE,FUNC}_START`` and ``SYM_{CODE,FUNC}_END``. They are very similar + to C labels, except they can be made global. An example of use:: + + SYM_CODE_START(ftrace_caller) + /* save_mcount_regs fills in first two parameters */ + ... + + SYM_INNER_LABEL(ftrace_caller_op_ptr, SYM_L_GLOBAL) + /* Load the ftrace_ops into the 3rd parameter */ + ... + + SYM_INNER_LABEL(ftrace_call, SYM_L_GLOBAL) + call ftrace_stub + ... + retq + SYM_CODE_END(ftrace_caller) + +Data Macros +~~~~~~~~~~~ +Similar to instructions, we have a couple of macros to describe data in the +assembly. Again, they help debuggers to understand the layout of the resulting +object files. + +* ``SYM_DATA_START`` and ``SYM_DATA_START_LOCAL`` mark the start of some data + and shall be used in conjunction with either ``SYM_DATA_END``, or + ``SYM_DATA_END_LABEL``. The latter adds also a label to the end, so that + people can use ``lstack`` and (local) ``lstack_end`` in the following + example:: + + SYM_DATA_START_LOCAL(lstack) + .skip 4096 + SYM_DATA_END_LABEL(lstack, SYM_L_LOCAL, lstack_end) + +* ``SYM_DATA`` and ``SYM_DATA_LOCAL`` are variants for simple, mostly one-line + data:: + + SYM_DATA(HEAP, .long rm_heap) + SYM_DATA(heap_end, .long rm_stack) + + In the end, they expand to ``SYM_DATA_START`` with ``SYM_DATA_END`` + internally. + +Support Macros +~~~~~~~~~~~~~~ +All the above reduce themselves to some invocation of ``SYM_START``, +``SYM_END``, or ``SYM_ENTRY`` at last. Normally, developers should avoid using +these. + +Further, in the above examples, one could see ``SYM_L_LOCAL``. There are also +``SYM_L_GLOBAL`` and ``SYM_L_WEAK``. All are intended to denote linkage of a +symbol marked by them. They are used either in ``_LABEL`` variants of the +earlier macros, or in ``SYM_START``. + + +Overriding Macros +~~~~~~~~~~~~~~~~~ +Architecture can also override any of the macros in their own +``asm/linkage.h``, including macros specifying the type of a symbol +(``SYM_T_FUNC``, ``SYM_T_OBJECT``, and ``SYM_T_NONE``). As every macro +described in this file is surrounded by ``#ifdef`` + ``#endif``, it is enough +to define the macros differently in the aforementioned architecture-dependent +header. diff --git a/arch/x86/include/asm/linkage.h b/arch/x86/include/asm/linkage.h index 14caa9d9fb7f..e07188e8d763 100644 --- a/arch/x86/include/asm/linkage.h +++ b/arch/x86/include/asm/linkage.h @@ -13,9 +13,13 @@ #ifdef __ASSEMBLY__ -#define GLOBAL(name) \ - .globl name; \ - name: +/* + * GLOBAL is DEPRECATED + * + * use SYM_DATA_START, SYM_FUNC_START, SYM_INNER_LABEL, SYM_CODE_START, or + * similar + */ +#define GLOBAL(name) SYM_ENTRY(name, SYM_L_GLOBAL, SYM_A_NONE) #if defined(CONFIG_X86_64) || defined(CONFIG_X86_ALIGNMENT_16) #define __ALIGN .p2align 4, 0x90 diff --git a/include/linux/linkage.h b/include/linux/linkage.h index f68db9e450eb..e920ffa2a943 100644 --- a/include/linux/linkage.h +++ b/include/linux/linkage.h @@ -75,25 +75,51 @@ #ifdef __ASSEMBLY__ +/* SYM_T_FUNC -- type used by assembler to mark functions */ +#ifndef SYM_T_FUNC +#define SYM_T_FUNC STT_FUNC +#endif + +/* SYM_T_OBJECT -- type used by assembler to mark data */ +#ifndef SYM_T_OBJECT +#define SYM_T_OBJECT STT_OBJECT +#endif + +/* SYM_T_NONE -- type used by assembler to mark entries of unknown type */ +#ifndef SYM_T_NONE +#define SYM_T_NONE STT_NOTYPE +#endif + +/* SYM_A_* -- align the symbol? */ +#define SYM_A_ALIGN ALIGN +#define SYM_A_NONE /* nothing */ + +/* SYM_L_* -- linkage of symbols */ +#define SYM_L_GLOBAL(name) .globl name +#define SYM_L_WEAK(name) .weak name +#define SYM_L_LOCAL(name) /* nothing */ + #ifndef LINKER_SCRIPT #define ALIGN __ALIGN #define ALIGN_STR __ALIGN_STR +/* === DEPRECATED annotations === */ + #ifndef ENTRY +/* deprecated, use SYM_FUNC_START */ #define ENTRY(name) \ - .globl name ASM_NL \ - ALIGN ASM_NL \ - name: + SYM_FUNC_START(name) #endif #endif /* LINKER_SCRIPT */ #ifndef WEAK +/* deprecated, use SYM_FUNC_START_WEAK* */ #define WEAK(name) \ - .weak name ASM_NL \ - name: + SYM_FUNC_START_WEAK_NOALIGN(name) #endif #ifndef END +/* deprecated, use SYM_FUNC_END, SYM_DATA_END, or SYM_END */ #define END(name) \ .size name, .-name #endif @@ -103,11 +129,214 @@ * static analysis tools such as stack depth analyzer. */ #ifndef ENDPROC +/* deprecated, use SYM_FUNC_END */ #define ENDPROC(name) \ - .type name, @function ASM_NL \ - END(name) + SYM_FUNC_END(name) #endif +/* === generic annotations === */ + +/* SYM_ENTRY -- use only if you have to for non-paired symbols */ +#ifndef SYM_ENTRY +#define SYM_ENTRY(name, linkage, align...) \ + linkage(name) ASM_NL \ + align ASM_NL \ + name: #endif +/* SYM_START -- use only if you have to */ +#ifndef SYM_START +#define SYM_START(name, linkage, align...) \ + SYM_ENTRY(name, linkage, align) +#endif + +/* SYM_END -- use only if you have to */ +#ifndef SYM_END +#define SYM_END(name, sym_type) \ + .type name sym_type ASM_NL \ + .size name, .-name #endif + +/* === code annotations === */ + +/* + * FUNC -- C-like functions (proper stack frame etc.) + * CODE -- non-C code (e.g. irq handlers with different, special stack etc.) + * + * Objtool validates stack for FUNC, but not for CODE. + * Objtool generates debug info for both FUNC & CODE, but needs special + * annotations for each CODE's start (to describe the actual stack frame). + * + * ALIAS -- does not generate debug info -- the aliased function will + */ + +/* SYM_INNER_LABEL_ALIGN -- only for labels in the middle of code */ +#ifndef SYM_INNER_LABEL_ALIGN +#define SYM_INNER_LABEL_ALIGN(name, linkage) \ + .type name SYM_T_NONE ASM_NL \ + SYM_ENTRY(name, linkage, SYM_A_ALIGN) +#endif + +/* SYM_INNER_LABEL -- only for labels in the middle of code */ +#ifndef SYM_INNER_LABEL +#define SYM_INNER_LABEL(name, linkage) \ + .type name SYM_T_NONE ASM_NL \ + SYM_ENTRY(name, linkage, SYM_A_NONE) +#endif + +/* + * SYM_FUNC_START_LOCAL_ALIAS -- use where there are two local names for one + * function + */ +#ifndef SYM_FUNC_START_LOCAL_ALIAS +#define SYM_FUNC_START_LOCAL_ALIAS(name) \ + SYM_START(name, SYM_L_LOCAL, SYM_A_ALIGN) +#endif + +/* + * SYM_FUNC_START_ALIAS -- use where there are two global names for one + * function + */ +#ifndef SYM_FUNC_START_ALIAS +#define SYM_FUNC_START_ALIAS(name) \ + SYM_START(name, SYM_L_GLOBAL, SYM_A_ALIGN) +#endif + +/* SYM_FUNC_START -- use for global functions */ +#ifndef SYM_FUNC_START +/* + * The same as SYM_FUNC_START_ALIAS, but we will need to distinguish these two + * later. + */ +#define SYM_FUNC_START(name) \ + SYM_START(name, SYM_L_GLOBAL, SYM_A_ALIGN) +#endif + +/* SYM_FUNC_START_NOALIGN -- use for global functions, w/o alignment */ +#ifndef SYM_FUNC_START_NOALIGN +#define SYM_FUNC_START_NOALIGN(name) \ + SYM_START(name, SYM_L_GLOBAL, SYM_A_NONE) +#endif + +/* SYM_FUNC_START_LOCAL -- use for local functions */ +#ifndef SYM_FUNC_START_LOCAL +/* the same as SYM_FUNC_START_LOCAL_ALIAS, see comment near SYM_FUNC_START */ +#define SYM_FUNC_START_LOCAL(name) \ + SYM_START(name, SYM_L_LOCAL, SYM_A_ALIGN) +#endif + +/* SYM_FUNC_START_LOCAL_NOALIGN -- use for local functions, w/o alignment */ +#ifndef SYM_FUNC_START_LOCAL_NOALIGN +#define SYM_FUNC_START_LOCAL_NOALIGN(name) \ + SYM_START(name, SYM_L_LOCAL, SYM_A_NONE) +#endif + +/* SYM_FUNC_START_WEAK -- use for weak functions */ +#ifndef SYM_FUNC_START_WEAK +#define SYM_FUNC_START_WEAK(name) \ + SYM_START(name, SYM_L_WEAK, SYM_A_ALIGN) +#endif + +/* SYM_FUNC_START_WEAK_NOALIGN -- use for weak functions, w/o alignment */ +#ifndef SYM_FUNC_START_WEAK_NOALIGN +#define SYM_FUNC_START_WEAK_NOALIGN(name) \ + SYM_START(name, SYM_L_WEAK, SYM_A_NONE) +#endif + +/* SYM_FUNC_END_ALIAS -- the end of LOCAL_ALIASed or ALIASed function */ +#ifndef SYM_FUNC_END_ALIAS +#define SYM_FUNC_END_ALIAS(name) \ + SYM_END(name, SYM_T_FUNC) +#endif + +/* + * SYM_FUNC_END -- the end of SYM_FUNC_START_LOCAL, SYM_FUNC_START, + * SYM_FUNC_START_WEAK, ... + */ +#ifndef SYM_FUNC_END +/* the same as SYM_FUNC_END_ALIAS, see comment near SYM_FUNC_START */ +#define SYM_FUNC_END(name) \ + SYM_END(name, SYM_T_FUNC) +#endif + +/* SYM_CODE_START -- use for non-C (special) functions */ +#ifndef SYM_CODE_START +#define SYM_CODE_START(name) \ + SYM_START(name, SYM_L_GLOBAL, SYM_A_ALIGN) +#endif + +/* SYM_CODE_START_NOALIGN -- use for non-C (special) functions, w/o alignment */ +#ifndef SYM_CODE_START_NOALIGN +#define SYM_CODE_START_NOALIGN(name) \ + SYM_START(name, SYM_L_GLOBAL, SYM_A_NONE) +#endif + +/* SYM_CODE_START_LOCAL -- use for local non-C (special) functions */ +#ifndef SYM_CODE_START_LOCAL +#define SYM_CODE_START_LOCAL(name) \ + SYM_START(name, SYM_L_LOCAL, SYM_A_ALIGN) +#endif + +/* + * SYM_CODE_START_LOCAL_NOALIGN -- use for local non-C (special) functions, + * w/o alignment + */ +#ifndef SYM_CODE_START_LOCAL_NOALIGN +#define SYM_CODE_START_LOCAL_NOALIGN(name) \ + SYM_START(name, SYM_L_LOCAL, SYM_A_NONE) +#endif + +/* SYM_CODE_END -- the end of SYM_CODE_START_LOCAL, SYM_CODE_START, ... */ +#ifndef SYM_CODE_END +#define SYM_CODE_END(name) \ + SYM_END(name, SYM_T_NONE) +#endif + +/* === data annotations === */ + +/* SYM_DATA_START -- global data symbol */ +#ifndef SYM_DATA_START +#define SYM_DATA_START(name) \ + SYM_START(name, SYM_L_GLOBAL, SYM_A_NONE) +#endif + +/* SYM_DATA_START -- local data symbol */ +#ifndef SYM_DATA_START_LOCAL +#define SYM_DATA_START_LOCAL(name) \ + SYM_START(name, SYM_L_LOCAL, SYM_A_NONE) +#endif + +/* SYM_DATA_END -- the end of SYM_DATA_START symbol */ +#ifndef SYM_DATA_END +#define SYM_DATA_END(name) \ + SYM_END(name, SYM_T_OBJECT) +#endif + +/* SYM_DATA_END_LABEL -- the labeled end of SYM_DATA_START symbol */ +#ifndef SYM_DATA_END_LABEL +#define SYM_DATA_END_LABEL(name, linkage, label) \ + linkage(label) ASM_NL \ + .type label SYM_T_OBJECT ASM_NL \ + label: \ + SYM_END(name, SYM_T_OBJECT) +#endif + +/* SYM_DATA -- start+end wrapper around simple global data */ +#ifndef SYM_DATA +#define SYM_DATA(name, data...) \ + SYM_DATA_START(name) ASM_NL \ + data ASM_NL \ + SYM_DATA_END(name) +#endif + +/* SYM_DATA_LOCAL -- start+end wrapper around simple local data */ +#ifndef SYM_DATA_LOCAL +#define SYM_DATA_LOCAL(name, data...) \ + SYM_DATA_START_LOCAL(name) ASM_NL \ + data ASM_NL \ + SYM_DATA_END(name) +#endif + +#endif /* __ASSEMBLY__ */ + +#endif /* _LINUX_LINKAGE_H */ -- 2.16.3