From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1161505AbdDUOVH (ORCPT ); Fri, 21 Apr 2017 10:21:07 -0400 Received: from mx2.suse.de ([195.135.220.15]:56086 "EHLO mx1.suse.de" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1040300AbdDUONM (ORCPT ); Fri, 21 Apr 2017 10:13:12 -0400 From: Jiri Slaby To: mingo@redhat.com Cc: tglx@linutronix.de, hpa@zytor.com, x86@kernel.org, jpoimboe@redhat.com, linux-kernel@vger.kernel.org, Jiri Slaby , Andrew Morton , Boris Ostrovsky , Ingo Molnar , Juergen Gross , Len Brown , Linus Torvalds , linux-pm@vger.kernel.org, Pavel Machek , Peter Zijlstra , "Rafael J. Wysocki" , xen-devel@lists.xenproject.org Subject: [PATCH v3 08/29] linkage: new macros for assembler symbols Date: Fri, 21 Apr 2017 16:12:44 +0200 Message-Id: <20170421141305.25180-8-jslaby@suse.cz> X-Mailer: git-send-email 2.12.2 In-Reply-To: <20170421141305.25180-1-jslaby@suse.cz> References: <20170421141305.25180-1-jslaby@suse.cz> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Introduce new C macros for annotations of functions and data in assembly. There is a long-term 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 SYM_T_FUNC -- type used by assembler to mark functions SYM_T_OBJECT -- type used by assembler to mark data They are defined as STT_FUNC and STT_OBJECT 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 need be. SYM_A_ALIGN, SYM_A_NONE -- align the symbol? SYM_V_GLOBAL, SYM_V_WEAK, SYM_V_LOCAL -- visibility 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 SYM_END -- use only if you have to c) Generic annotations d) Annotations for code SYM_FUNC_START_LOCAL_ALIAS -- use where there are two local names for one code SYM_FUNC_START_ALIAS -- use where there are two global names for one code SYM_FUNC_END_ALIAS -- the end of LOCAL_ALIASed or ALIASed code SYM_FUNC_START -- use for global functions SYM_FUNC_START_LOCAL -- use for local functions SYM_FUNC_START_WEAK -- use for weak functions SYM_FUNC_END -- the end of SYM_FUNC_START_LOCAL, SYM_FUNC_START, SYM_FUNC_START_WEAK, ... SYM_FUNC_INNER_LABEL -- only for labels in the middle of functions d) For data SYM_DATA_START -- global data symbol SYM_DATA_END -- the end of SYM_DATA_START symbol SYM_DATA_END_LABEL -- the labeled end of SYM_DATA_START symbol SYM_DATA_SIMPLE -- start+end wrapper around simple global data SYM_DATA_SIMPLE_LOCAL -- start+end wrapper around simple local data ========== Note that SYM_FUNC_START_WEAK aligns symbols now too. The macros allow to pair starts and ends of functions and mark function correctly in the output ELF objects. This will also help a lot to generate DWARF information automatically during build of asm. Finally, all users of the old macros will be converted to use these later. [v2] * use SYM_ prefix and sane names * add SYM_START and SYM_END and parametrize all the macros [v3] * add SYM_DATA_SIMPLE, SYM_DATA_SIMPLE_LOCAL, and SYM_DATA_END_LABEL 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 --- arch/x86/include/asm/linkage.h | 5 +- include/linux/linkage.h | 163 +++++++++++++++++++++++++++++++++++++++-- 2 files changed, 158 insertions(+), 10 deletions(-) diff --git a/arch/x86/include/asm/linkage.h b/arch/x86/include/asm/linkage.h index 0ccb26dda126..de41e51a9ab4 100644 --- a/arch/x86/include/asm/linkage.h +++ b/arch/x86/include/asm/linkage.h @@ -12,9 +12,8 @@ #ifdef __ASSEMBLY__ -#define GLOBAL(name) \ - .globl name; \ - name: +/* deprecated, use SYM_DATA_START, SYM_FUNC_START, or SYM_FUNC_INNER_LABEL */ +#define GLOBAL(name) SYM_ENTRY(name, SYM_V_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 a6a42dd02466..31237e9db93f 100644 --- a/include/linux/linkage.h +++ b/include/linux/linkage.h @@ -74,25 +74,46 @@ #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_A_* -- align the symbol? */ +#define SYM_A_ALIGN ALIGN +#define SYM_A_NONE /* nothing */ + +/* SYM_V_* -- visibility of symbols */ +#define SYM_V_GLOBAL(name) .globl name +#define SYM_V_WEAK(name) .weak name +#define SYM_V_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(name) #endif #ifndef END +/* deprecated, use SYM_FUNC_END, SYM_DATA_END, or SYM_END */ #define END(name) \ .size name, .-name #endif @@ -102,11 +123,139 @@ * 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, visibility, align...) \ + visibility(name) ASM_NL \ + align ASM_NL \ + name: +#endif + +/* SYM_START -- use only if you have to */ +#ifndef SYM_START +#define SYM_START(name, visibility, align...) \ + SYM_ENTRY(name, visibility, 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 === */ + +/* SYM_FUNC_START_LOCAL_ALIAS -- use where there are two local names for one code */ +#ifndef SYM_FUNC_START_LOCAL_ALIAS +#define SYM_FUNC_START_LOCAL_ALIAS(name) \ + SYM_START(name, SYM_V_LOCAL, SYM_A_ALIGN) +#endif + +/* SYM_FUNC_START_ALIAS -- use where there are two global names for one code */ +#ifndef SYM_FUNC_START_ALIAS +#define SYM_FUNC_START_ALIAS(name) \ + SYM_START(name, SYM_V_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_V_GLOBAL, SYM_A_ALIGN) +#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_V_LOCAL, SYM_A_ALIGN) #endif +/* SYM_FUNC_START_WEAK -- use for weak functions */ +#ifndef SYM_FUNC_START_WEAK +#define SYM_FUNC_START_WEAK(name) \ + SYM_START(name, SYM_V_WEAK, SYM_A_ALIGN) #endif +/* SYM_FUNC_END_ALIAS -- the end of LOCAL_ALIASed or ALIASed code */ +#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_FUNC_INNER_LABEL -- only for labels to the middle of functions */ +#ifndef SYM_FUNC_INNER_LABEL +#define SYM_FUNC_INNER_LABEL(name, visibility) \ + .type name SYM_T_FUNC ASM_NL \ + SYM_ENTRY(name, visibility, SYM_A_NONE) +#endif + +/* === data annotations === */ + +/* SYM_DATA_START -- global data symbol */ +#ifndef SYM_DATA_START +#define SYM_DATA_START(name) \ + SYM_START(name, SYM_V_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_V_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, visibility, label) \ + visibility(label) ASM_NL \ + .type label SYM_T_OBJECT ASM_NL \ + label: \ + SYM_END(name, SYM_T_OBJECT) +#endif + +/* SYM_DATA_SIMPLE -- start+end wrapper around simple global data */ +#ifndef SYM_DATA_SIMPLE +#define SYM_DATA_SIMPLE(name, data) \ + SYM_DATA_START(name) ASM_NL \ + data ASM_NL \ + SYM_DATA_END(name) +#endif + +/* SYM_DATA_SIMPLE_LOCAL -- start+end wrapper around simple local data */ +#ifndef SYM_DATA_SIMPLE_LOCAL +#define SYM_DATA_SIMPLE_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.12.2 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jiri Slaby Subject: [PATCH v3 08/29] linkage: new macros for assembler symbols Date: Fri, 21 Apr 2017 16:12:44 +0200 Message-ID: <20170421141305.25180-8-jslaby@suse.cz> References: <20170421141305.25180-1-jslaby@suse.cz> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170421141305.25180-1-jslaby@suse.cz> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: mingo@redhat.com Cc: Juergen Gross , Len Brown , hpa@zytor.com, Peter Zijlstra , linux-pm@vger.kernel.org, Boris Ostrovsky , Linus Torvalds , x86@kernel.org, "Rafael J. Wysocki" , linux-kernel@vger.kernel.org, Ingo Molnar , Pavel Machek , jpoimboe@redhat.com, xen-devel@lists.xenproject.org, tglx@linutronix.de, Jiri Slaby , Andrew Morton List-Id: linux-pm@vger.kernel.org SW50cm9kdWNlIG5ldyBDIG1hY3JvcyBmb3IgYW5ub3RhdGlvbnMgb2YgZnVuY3Rpb25zIGFuZCBk YXRhIGluCmFzc2VtYmx5LiBUaGVyZSBpcyBhIGxvbmctdGVybSBtZXNzIGluIG1hY3JvcyBsaWtl IEVOVFJZLCBFTkQsIEVORFBST0MKYW5kIHNpbWlsYXIuIFRoZXkgYXJlIHVzZWQgaW4gZGlmZmVy ZW50IG1hbm5lcnMgYW5kIHNvbWV0aW1lcwppbmNvcnJlY3RseS4KClNvIGludHJvZHVjZSBtYWNy b3Mgd2l0aCBjbGVhciB1c2UgdG8gYW5ub3RhdGUgYXNzZW1ibHkgYXMgZm9sbG93czoKCmEpIFN1 cHBvcnQgbWFjcm9zCiAgIFNZTV9UX0ZVTkMgLS0gdHlwZSB1c2VkIGJ5IGFzc2VtYmxlciB0byBt YXJrIGZ1bmN0aW9ucwogICBTWU1fVF9PQkpFQ1QgLS0gdHlwZSB1c2VkIGJ5IGFzc2VtYmxlciB0 byBtYXJrIGRhdGEKCiAgIFRoZXkgYXJlIGRlZmluZWQgYXMgU1RUX0ZVTkMgYW5kIFNUVF9PQkpF Q1QgcmVzcGVjdGl2ZWx5LiBBY2NvcmRpbmcKICAgdG8gdGhlIGdhcyBtYW51YWwsIHRoaXMgaXMg dGhlIG1vc3QgcG9ydGFibGUgd2F5LiBJIGFtIG5vdCBzdXJlIGFib3V0CiAgIG90aGVyIGFzc2Vt YmxlcnMsIHNvIHdlIGNhbiBzd2l0Y2ggdGhpcyBiYWNrIHRvICVmdW5jdGlvbiBhbmQgJW9iamVj dAogICBpZiB0aGlzIHR1cm5zIGludG8gYSBwcm9ibGVtLiBBcmNoaXRlY3R1cmVzIGNhbiBhbHNv IG92ZXJyaWRlIHRoZW0gYnkKICAgc29tZXRoaW5nIGxpa2UgIiwgQGZ1bmN0aW9uIiBpZiBuZWVk IGJlLgoKICAgU1lNX0FfQUxJR04sIFNZTV9BX05PTkUgLS0gYWxpZ24gdGhlIHN5bWJvbD8KICAg U1lNX1ZfR0xPQkFMLCBTWU1fVl9XRUFLLCBTWU1fVl9MT0NBTCAtLSB2aXNpYmlsaXR5IG9mIHN5 bWJvbHMKYikgTW9zdGx5IGludGVybmFsIGFubm90YXRpb25zLCB1c2VkIGJ5IHRoZSBvbmVzIGJl bG93CiAgIFNZTV9FTlRSWSAtLSB1c2Ugb25seSBpZiB5b3UgaGF2ZSB0byBmb3Igbm9uLXBhaXJl ZCBzeW1ib2xzCiAgIFNZTV9TVEFSVCAtLSB1c2Ugb25seSBpZiB5b3UgaGF2ZSB0bwogICBTWU1f RU5EIC0tIHVzZSBvbmx5IGlmIHlvdSBoYXZlIHRvCmMpIEdlbmVyaWMgYW5ub3RhdGlvbnMKZCkg QW5ub3RhdGlvbnMgZm9yIGNvZGUKICAgU1lNX0ZVTkNfU1RBUlRfTE9DQUxfQUxJQVMgLS0gdXNl IHdoZXJlIHRoZXJlIGFyZSB0d28gbG9jYWwgbmFtZXMgZm9yCglvbmUgY29kZQogICBTWU1fRlVO Q19TVEFSVF9BTElBUyAtLSB1c2Ugd2hlcmUgdGhlcmUgYXJlIHR3byBnbG9iYWwgbmFtZXMgZm9y IG9uZQoJY29kZQogICBTWU1fRlVOQ19FTkRfQUxJQVMgLS0gdGhlIGVuZCBvZiBMT0NBTF9BTElB U2VkIG9yIEFMSUFTZWQgY29kZQoKICAgU1lNX0ZVTkNfU1RBUlQgLS0gdXNlIGZvciBnbG9iYWwg ZnVuY3Rpb25zCiAgIFNZTV9GVU5DX1NUQVJUX0xPQ0FMIC0tIHVzZSBmb3IgbG9jYWwgZnVuY3Rp b25zCiAgIFNZTV9GVU5DX1NUQVJUX1dFQUsgLS0gdXNlIGZvciB3ZWFrIGZ1bmN0aW9ucwogICBT WU1fRlVOQ19FTkQgLS0gdGhlIGVuZCBvZiBTWU1fRlVOQ19TVEFSVF9MT0NBTCwgU1lNX0ZVTkNf U1RBUlQsCglTWU1fRlVOQ19TVEFSVF9XRUFLLCAuLi4KCiAgIFNZTV9GVU5DX0lOTkVSX0xBQkVM IC0tIG9ubHkgZm9yIGxhYmVscyBpbiB0aGUgbWlkZGxlIG9mIGZ1bmN0aW9ucwpkKSBGb3IgZGF0 YQogICBTWU1fREFUQV9TVEFSVCAtLSBnbG9iYWwgZGF0YSBzeW1ib2wKICAgU1lNX0RBVEFfRU5E IC0tIHRoZSBlbmQgb2YgU1lNX0RBVEFfU1RBUlQgc3ltYm9sCiAgIFNZTV9EQVRBX0VORF9MQUJF TCAtLSB0aGUgbGFiZWxlZCBlbmQgb2YgU1lNX0RBVEFfU1RBUlQgc3ltYm9sCiAgIFNZTV9EQVRB X1NJTVBMRSAtLSBzdGFydCtlbmQgd3JhcHBlciBhcm91bmQgc2ltcGxlIGdsb2JhbCBkYXRhCiAg IFNZTV9EQVRBX1NJTVBMRV9MT0NBTCAtLSBzdGFydCtlbmQgd3JhcHBlciBhcm91bmQgc2ltcGxl IGxvY2FsIGRhdGEKCj09PT09PT09PT0KCk5vdGUgdGhhdCBTWU1fRlVOQ19TVEFSVF9XRUFLIGFs aWducyBzeW1ib2xzIG5vdyB0b28uCgpUaGUgbWFjcm9zIGFsbG93IHRvIHBhaXIgc3RhcnRzIGFu ZCBlbmRzIG9mIGZ1bmN0aW9ucyBhbmQgbWFyayBmdW5jdGlvbgpjb3JyZWN0bHkgaW4gdGhlIG91 dHB1dCBFTEYgb2JqZWN0cy4gVGhpcyB3aWxsIGFsc28gaGVscCBhIGxvdCB0bwpnZW5lcmF0ZSBE V0FSRiBpbmZvcm1hdGlvbiBhdXRvbWF0aWNhbGx5IGR1cmluZyBidWlsZCBvZiBhc20uCgpGaW5h bGx5LCBhbGwgdXNlcnMgb2YgdGhlIG9sZCBtYWNyb3Mgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gdXNl IHRoZXNlCmxhdGVyLgoKW3YyXQoqIHVzZSBTWU1fIHByZWZpeCBhbmQgc2FuZSBuYW1lcwoqIGFk ZCBTWU1fU1RBUlQgYW5kIFNZTV9FTkQgYW5kIHBhcmFtZXRyaXplIGFsbCB0aGUgbWFjcm9zCgpb djNdCiogYWRkIFNZTV9EQVRBX1NJTVBMRSwgU1lNX0RBVEFfU0lNUExFX0xPQ0FMLCBhbmQgU1lN X0RBVEFfRU5EX0xBQkVMCgpTaWduZWQtb2ZmLWJ5OiBKaXJpIFNsYWJ5IDxqc2xhYnlAc3VzZS5j ej4KQ2M6IEFuZHJldyBNb3J0b24gPGFrcG1AbGludXgtZm91bmRhdGlvbi5vcmc+CkNjOiBCb3Jp cyBPc3Ryb3Zza3kgPGJvcmlzLm9zdHJvdnNreUBvcmFjbGUuY29tPgpDYzogaHBhQHp5dG9yLmNv bQpDYzogSW5nbyBNb2xuYXIgPG1pbmdvQGtlcm5lbC5vcmc+CkNjOiBqcG9pbWJvZUByZWRoYXQu Y29tCkNjOiBKdWVyZ2VuIEdyb3NzIDxqZ3Jvc3NAc3VzZS5jb20+CkNjOiBMZW4gQnJvd24gPGxl bi5icm93bkBpbnRlbC5jb20+CkNjOiBMaW51cyBUb3J2YWxkcyA8dG9ydmFsZHNAbGludXgtZm91 bmRhdGlvbi5vcmc+CkNjOiBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnCkNjOiBsaW51eC1w bUB2Z2VyLmtlcm5lbC5vcmcKQ2M6IG1pbmdvQHJlZGhhdC5jb20KQ2M6IFBhdmVsIE1hY2hlayA8 cGF2ZWxAdWN3LmN6PgpDYzogUGV0ZXIgWmlqbHN0cmEgPGEucC56aWpsc3RyYUBjaGVsbG8ubmw+ CkNjOiAiUmFmYWVsIEouIFd5c29ja2kiIDxyandAcmp3eXNvY2tpLm5ldD4KQ2M6IFRob21hcyBH bGVpeG5lciA8dGdseEBsaW51dHJvbml4LmRlPgpDYzogeGVuLWRldmVsQGxpc3RzLnhlbnByb2pl Y3Qub3JnCkNjOiB4ODZAa2VybmVsLm9yZwotLS0KIGFyY2gveDg2L2luY2x1ZGUvYXNtL2xpbmth Z2UuaCB8ICAgNSArLQogaW5jbHVkZS9saW51eC9saW5rYWdlLmggICAgICAgIHwgMTYzICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tCiAyIGZpbGVzIGNoYW5nZWQsIDE1 OCBpbnNlcnRpb25zKCspLCAxMCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9p bmNsdWRlL2FzbS9saW5rYWdlLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9saW5rYWdlLmgKaW5k ZXggMGNjYjI2ZGRhMTI2Li5kZTQxZTUxYTlhYjQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1 ZGUvYXNtL2xpbmthZ2UuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9saW5rYWdlLmgKQEAg LTEyLDkgKzEyLDggQEAKIAogI2lmZGVmIF9fQVNTRU1CTFlfXwogCi0jZGVmaW5lIEdMT0JBTChu YW1lKQlcCi0JLmdsb2JsIG5hbWU7CVwKLQluYW1lOgorLyogZGVwcmVjYXRlZCwgdXNlIFNZTV9E QVRBX1NUQVJULCBTWU1fRlVOQ19TVEFSVCwgb3IgU1lNX0ZVTkNfSU5ORVJfTEFCRUwgKi8KKyNk ZWZpbmUgR0xPQkFMKG5hbWUpCVNZTV9FTlRSWShuYW1lLCBTWU1fVl9HTE9CQUwsIFNZTV9BX05P TkUpCiAKICNpZiBkZWZpbmVkKENPTkZJR19YODZfNjQpIHx8IGRlZmluZWQoQ09ORklHX1g4Nl9B TElHTk1FTlRfMTYpCiAjZGVmaW5lIF9fQUxJR04JCS5wMmFsaWduIDQsIDB4OTAKZGlmZiAtLWdp dCBhL2luY2x1ZGUvbGludXgvbGlua2FnZS5oIGIvaW5jbHVkZS9saW51eC9saW5rYWdlLmgKaW5k ZXggYTZhNDJkZDAyNDY2Li4zMTIzN2U5ZGI5M2YgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgv bGlua2FnZS5oCisrKyBiL2luY2x1ZGUvbGludXgvbGlua2FnZS5oCkBAIC03NCwyNSArNzQsNDYg QEAKIAogI2lmZGVmIF9fQVNTRU1CTFlfXwogCisvKiBTWU1fVF9GVU5DIC0tIHR5cGUgdXNlZCBi eSBhc3NlbWJsZXIgdG8gbWFyayBmdW5jdGlvbnMgKi8KKyNpZm5kZWYgU1lNX1RfRlVOQworI2Rl ZmluZSBTWU1fVF9GVU5DCQkJCVNUVF9GVU5DCisjZW5kaWYKKworLyogU1lNX1RfT0JKRUNUIC0t IHR5cGUgdXNlZCBieSBhc3NlbWJsZXIgdG8gbWFyayBkYXRhICovCisjaWZuZGVmIFNZTV9UX09C SkVDVAorI2RlZmluZSBTWU1fVF9PQkpFQ1QJCQkJU1RUX09CSkVDVAorI2VuZGlmCisKKy8qIFNZ TV9BXyogLS0gYWxpZ24gdGhlIHN5bWJvbD8gKi8KKyNkZWZpbmUgU1lNX0FfQUxJR04JCQkJQUxJ R04KKyNkZWZpbmUgU1lNX0FfTk9ORQkJCQkvKiBub3RoaW5nICovCisKKy8qIFNZTV9WXyogLS0g dmlzaWJpbGl0eSBvZiBzeW1ib2xzICovCisjZGVmaW5lIFNZTV9WX0dMT0JBTChuYW1lKQkJCS5n bG9ibCBuYW1lCisjZGVmaW5lIFNZTV9WX1dFQUsobmFtZSkJCQkud2VhayBuYW1lCisjZGVmaW5l IFNZTV9WX0xPQ0FMKG5hbWUpCQkJLyogbm90aGluZyAqLworCiAjaWZuZGVmIExJTktFUl9TQ1JJ UFQKICNkZWZpbmUgQUxJR04gX19BTElHTgogI2RlZmluZSBBTElHTl9TVFIgX19BTElHTl9TVFIK IAorLyogPT09IERFUFJFQ0FURUQgYW5ub3RhdGlvbnMgPT09ICovCisKICNpZm5kZWYgRU5UUlkK Ky8qIGRlcHJlY2F0ZWQsIHVzZSBTWU1fRlVOQ19TVEFSVCAqLwogI2RlZmluZSBFTlRSWShuYW1l KSBcCi0JLmdsb2JsIG5hbWUgQVNNX05MIFwKLQlBTElHTiBBU01fTkwgXAotCW5hbWU6CisJU1lN X0ZVTkNfU1RBUlQobmFtZSkKICNlbmRpZgogI2VuZGlmIC8qIExJTktFUl9TQ1JJUFQgKi8KIAog I2lmbmRlZiBXRUFLCisvKiBkZXByZWNhdGVkLCB1c2UgU1lNX0ZVTkNfU1RBUlRfV0VBSyAqLwog I2RlZmluZSBXRUFLKG5hbWUpCSAgIFwKLQkud2VhayBuYW1lIEFTTV9OTCAgIFwKLQluYW1lOgor CVNZTV9GVU5DX1NUQVJUX1dFQUsobmFtZSkKICNlbmRpZgogCiAjaWZuZGVmIEVORAorLyogZGVw cmVjYXRlZCwgdXNlIFNZTV9GVU5DX0VORCwgU1lNX0RBVEFfRU5ELCBvciBTWU1fRU5EICovCiAj ZGVmaW5lIEVORChuYW1lKSBcCiAJLnNpemUgbmFtZSwgLi1uYW1lCiAjZW5kaWYKQEAgLTEwMiwx MSArMTIzLDEzOSBAQAogICogc3RhdGljIGFuYWx5c2lzIHRvb2xzIHN1Y2ggYXMgc3RhY2sgZGVw dGggYW5hbHl6ZXIuCiAgKi8KICNpZm5kZWYgRU5EUFJPQworLyogZGVwcmVjYXRlZCwgdXNlIFNZ TV9GVU5DX0VORCAqLwogI2RlZmluZSBFTkRQUk9DKG5hbWUpIFwKLQkudHlwZSBuYW1lLCBAZnVu Y3Rpb24gQVNNX05MIFwKLQlFTkQobmFtZSkKKwlTWU1fRlVOQ19FTkQobmFtZSkKKyNlbmRpZgor CisvKiA9PT0gZ2VuZXJpYyBhbm5vdGF0aW9ucyA9PT0gKi8KKworLyogU1lNX0VOVFJZIC0tIHVz ZSBvbmx5IGlmIHlvdSBoYXZlIHRvIGZvciBub24tcGFpcmVkIHN5bWJvbHMgKi8KKyNpZm5kZWYg U1lNX0VOVFJZCisjZGVmaW5lIFNZTV9FTlRSWShuYW1lLCB2aXNpYmlsaXR5LCBhbGlnbi4uLikJ CVwKKwl2aXNpYmlsaXR5KG5hbWUpIEFTTV9OTAkJCQlcCisJYWxpZ24gQVNNX05MCQkJCQlcCisJ bmFtZToKKyNlbmRpZgorCisvKiBTWU1fU1RBUlQgLS0gdXNlIG9ubHkgaWYgeW91IGhhdmUgdG8g Ki8KKyNpZm5kZWYgU1lNX1NUQVJUCisjZGVmaW5lIFNZTV9TVEFSVChuYW1lLCB2aXNpYmlsaXR5 LCBhbGlnbi4uLikJCVwKKwlTWU1fRU5UUlkobmFtZSwgdmlzaWJpbGl0eSwgYWxpZ24pCisjZW5k aWYKKworLyogU1lNX0VORCAtLSB1c2Ugb25seSBpZiB5b3UgaGF2ZSB0byAqLworI2lmbmRlZiBT WU1fRU5ECisjZGVmaW5lIFNZTV9FTkQobmFtZSwgc3ltX3R5cGUpCQkJCVwKKwkudHlwZSBuYW1l IHN5bV90eXBlIEFTTV9OTAkJCVwKKwkuc2l6ZSBuYW1lLCAuLW5hbWUKKyNlbmRpZgorCisvKiA9 PT0gY29kZSBhbm5vdGF0aW9ucyA9PT0gKi8KKworLyogU1lNX0ZVTkNfU1RBUlRfTE9DQUxfQUxJ QVMgLS0gdXNlIHdoZXJlIHRoZXJlIGFyZSB0d28gbG9jYWwgbmFtZXMgZm9yIG9uZSBjb2RlICov CisjaWZuZGVmIFNZTV9GVU5DX1NUQVJUX0xPQ0FMX0FMSUFTCisjZGVmaW5lIFNZTV9GVU5DX1NU QVJUX0xPQ0FMX0FMSUFTKG5hbWUpCQlcCisJU1lNX1NUQVJUKG5hbWUsIFNZTV9WX0xPQ0FMLCBT WU1fQV9BTElHTikKKyNlbmRpZgorCisvKiBTWU1fRlVOQ19TVEFSVF9BTElBUyAtLSB1c2Ugd2hl cmUgdGhlcmUgYXJlIHR3byBnbG9iYWwgbmFtZXMgZm9yIG9uZSBjb2RlICovCisjaWZuZGVmIFNZ TV9GVU5DX1NUQVJUX0FMSUFTCisjZGVmaW5lIFNZTV9GVU5DX1NUQVJUX0FMSUFTKG5hbWUpCQkJ XAorCVNZTV9TVEFSVChuYW1lLCBTWU1fVl9HTE9CQUwsIFNZTV9BX0FMSUdOKQorI2VuZGlmCisK Ky8qIFNZTV9GVU5DX1NUQVJUIC0tIHVzZSBmb3IgZ2xvYmFsIGZ1bmN0aW9ucyAqLworI2lmbmRl ZiBTWU1fRlVOQ19TVEFSVAorLyoKKyAqIFRoZSBzYW1lIGFzIFNZTV9GVU5DX1NUQVJUX0FMSUFT LCBidXQgd2Ugd2lsbCBuZWVkIHRvIGRpc3Rpbmd1aXNoIHRoZXNlIHR3bworICogbGF0ZXIuCisg Ki8KKyNkZWZpbmUgU1lNX0ZVTkNfU1RBUlQobmFtZSkJCQkJXAorCVNZTV9TVEFSVChuYW1lLCBT WU1fVl9HTE9CQUwsIFNZTV9BX0FMSUdOKQorI2VuZGlmCisKKy8qIFNZTV9GVU5DX1NUQVJUX0xP Q0FMIC0tIHVzZSBmb3IgbG9jYWwgZnVuY3Rpb25zICovCisjaWZuZGVmIFNZTV9GVU5DX1NUQVJU X0xPQ0FMCisvKiB0aGUgc2FtZSBhcyBTWU1fRlVOQ19TVEFSVF9MT0NBTF9BTElBUywgc2VlIGNv bW1lbnQgbmVhciBTWU1fRlVOQ19TVEFSVCAqLworI2RlZmluZSBTWU1fRlVOQ19TVEFSVF9MT0NB TChuYW1lKQkJCVwKKwlTWU1fU1RBUlQobmFtZSwgU1lNX1ZfTE9DQUwsIFNZTV9BX0FMSUdOKQog I2VuZGlmCiAKKy8qIFNZTV9GVU5DX1NUQVJUX1dFQUsgLS0gdXNlIGZvciB3ZWFrIGZ1bmN0aW9u cyAqLworI2lmbmRlZiBTWU1fRlVOQ19TVEFSVF9XRUFLCisjZGVmaW5lIFNZTV9GVU5DX1NUQVJU X1dFQUsobmFtZSkJCQlcCisJU1lNX1NUQVJUKG5hbWUsIFNZTV9WX1dFQUssIFNZTV9BX0FMSUdO KQogI2VuZGlmCiAKKy8qIFNZTV9GVU5DX0VORF9BTElBUyAtLSB0aGUgZW5kIG9mIExPQ0FMX0FM SUFTZWQgb3IgQUxJQVNlZCBjb2RlICovCisjaWZuZGVmIFNZTV9GVU5DX0VORF9BTElBUworI2Rl ZmluZSBTWU1fRlVOQ19FTkRfQUxJQVMobmFtZSkJCQlcCisJU1lNX0VORChuYW1lLCBTWU1fVF9G VU5DKQorI2VuZGlmCisKKy8qCisgKiBTWU1fRlVOQ19FTkQgLS0gdGhlIGVuZCBvZiBTWU1fRlVO Q19TVEFSVF9MT0NBTCwgU1lNX0ZVTkNfU1RBUlQsCisgKiBTWU1fRlVOQ19TVEFSVF9XRUFLLCAu Li4KKyAqLworI2lmbmRlZiBTWU1fRlVOQ19FTkQKKy8qIHRoZSBzYW1lIGFzIFNZTV9GVU5DX0VO RF9BTElBUywgc2VlIGNvbW1lbnQgbmVhciBTWU1fRlVOQ19TVEFSVCAqLworI2RlZmluZSBTWU1f RlVOQ19FTkQobmFtZSkJCQkJXAorCVNZTV9FTkQobmFtZSwgU1lNX1RfRlVOQykKKyNlbmRpZgor CisvKiBTWU1fRlVOQ19JTk5FUl9MQUJFTCAtLSBvbmx5IGZvciBsYWJlbHMgdG8gdGhlIG1pZGRs ZSBvZiBmdW5jdGlvbnMgKi8KKyNpZm5kZWYgU1lNX0ZVTkNfSU5ORVJfTEFCRUwKKyNkZWZpbmUg U1lNX0ZVTkNfSU5ORVJfTEFCRUwobmFtZSwgdmlzaWJpbGl0eSkJCVwKKwkudHlwZSBuYW1lIFNZ TV9UX0ZVTkMgQVNNX05MCQkJXAorCVNZTV9FTlRSWShuYW1lLCB2aXNpYmlsaXR5LCBTWU1fQV9O T05FKQorI2VuZGlmCisKKy8qID09PSBkYXRhIGFubm90YXRpb25zID09PSAqLworCisvKiBTWU1f REFUQV9TVEFSVCAtLSBnbG9iYWwgZGF0YSBzeW1ib2wgKi8KKyNpZm5kZWYgU1lNX0RBVEFfU1RB UlQKKyNkZWZpbmUgU1lNX0RBVEFfU1RBUlQobmFtZSkJCQkJXAorCVNZTV9TVEFSVChuYW1lLCBT WU1fVl9HTE9CQUwsIFNZTV9BX05PTkUpCiAjZW5kaWYKKworLyogU1lNX0RBVEFfU1RBUlQgLS0g bG9jYWwgZGF0YSBzeW1ib2wgKi8KKyNpZm5kZWYgU1lNX0RBVEFfU1RBUlRfTE9DQUwKKyNkZWZp bmUgU1lNX0RBVEFfU1RBUlRfTE9DQUwobmFtZSkJCQlcCisJU1lNX1NUQVJUKG5hbWUsIFNZTV9W X0xPQ0FMLCBTWU1fQV9OT05FKQorI2VuZGlmCisKKy8qIFNZTV9EQVRBX0VORCAtLSB0aGUgZW5k IG9mIFNZTV9EQVRBX1NUQVJUIHN5bWJvbCAqLworI2lmbmRlZiBTWU1fREFUQV9FTkQKKyNkZWZp bmUgU1lNX0RBVEFfRU5EKG5hbWUpCQkJCVwKKwlTWU1fRU5EKG5hbWUsIFNZTV9UX09CSkVDVCkK KyNlbmRpZgorCisvKiBTWU1fREFUQV9FTkRfTEFCRUwgLS0gdGhlIGxhYmVsZWQgZW5kIG9mIFNZ TV9EQVRBX1NUQVJUIHN5bWJvbCAqLworI2lmbmRlZiBTWU1fREFUQV9FTkRfTEFCRUwKKyNkZWZp bmUgU1lNX0RBVEFfRU5EX0xBQkVMKG5hbWUsIHZpc2liaWxpdHksIGxhYmVsKQlcCisJdmlzaWJp bGl0eShsYWJlbCkgQVNNX05MCQkJXAorCS50eXBlIGxhYmVsIFNZTV9UX09CSkVDVCBBU01fTkwJ CQlcCisJbGFiZWw6CQkJCQkJXAorCVNZTV9FTkQobmFtZSwgU1lNX1RfT0JKRUNUKQorI2VuZGlm CisKKy8qIFNZTV9EQVRBX1NJTVBMRSAtLSBzdGFydCtlbmQgd3JhcHBlciBhcm91bmQgc2ltcGxl IGdsb2JhbCBkYXRhICovCisjaWZuZGVmIFNZTV9EQVRBX1NJTVBMRQorI2RlZmluZSBTWU1fREFU QV9TSU1QTEUobmFtZSwgZGF0YSkJCQkJXAorCVNZTV9EQVRBX1NUQVJUKG5hbWUpIEFTTV9OTAkJ CQlcCisJZGF0YSBBU01fTkwJCQkJCQlcCisJU1lNX0RBVEFfRU5EKG5hbWUpCisjZW5kaWYKKwor LyogU1lNX0RBVEFfU0lNUExFX0xPQ0FMIC0tIHN0YXJ0K2VuZCB3cmFwcGVyIGFyb3VuZCBzaW1w bGUgbG9jYWwgZGF0YSAqLworI2lmbmRlZiBTWU1fREFUQV9TSU1QTEVfTE9DQUwKKyNkZWZpbmUg U1lNX0RBVEFfU0lNUExFX0xPQ0FMKG5hbWUsIGRhdGEuLi4pCQkJXAorCVNZTV9EQVRBX1NUQVJU X0xPQ0FMKG5hbWUpIEFTTV9OTAkJCVwKKwlkYXRhIEFTTV9OTAkJCQkJCVwKKwlTWU1fREFUQV9F TkQobmFtZSkKKyNlbmRpZgorCisjZW5kaWYgLyogX19BU1NFTUJMWV9fICovCisKKyNlbmRpZiAv KiBfTElOVVhfTElOS0FHRV9IICovCi0tIAoyLjEyLjIKCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZl bEBsaXN0cy54ZW4ub3JnCmh0dHBzOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK