From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-11.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 63ED4CA9EAB for ; Fri, 18 Oct 2019 16:31:55 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 1AE4320659 for ; Fri, 18 Oct 2019 16:31:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2443098AbfJRQbx (ORCPT ); Fri, 18 Oct 2019 12:31:53 -0400 Received: from Galois.linutronix.de ([193.142.43.55]:57840 "EHLO Galois.linutronix.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2443015AbfJRQbQ (ORCPT ); Fri, 18 Oct 2019 12:31:16 -0400 Received: from [5.158.153.53] (helo=tip-bot2.lab.linutronix.de) by Galois.linutronix.de with esmtpsa (TLS1.2:DHE_RSA_AES_256_CBC_SHA256:256) (Exim 4.80) (envelope-from ) id 1iLV9G-00033g-4R; Fri, 18 Oct 2019 18:30:42 +0200 Received: from [127.0.1.1] (localhost [IPv6:::1]) by tip-bot2.lab.linutronix.de (Postfix) with ESMTP id CA5CC1C03AB; Fri, 18 Oct 2019 18:30:34 +0200 (CEST) Date: Fri, 18 Oct 2019 16:30:34 -0000 From: "tip-bot2 for Jiri Slaby" Reply-to: linux-kernel@vger.kernel.org To: linux-tip-commits@vger.kernel.org Subject: [tip: x86/asm] linkage: Introduce new macros for assembler symbols Cc: Jiri Slaby , Borislav Petkov , "Rafael J. Wysocki" , Andrew Morton , Andrey Ryabinin , Boris Ostrovsky , "H. Peter Anvin" , Ingo Molnar , Jonathan Corbet , Josh Poimboeuf , Juergen Gross , Len Brown , Linus Torvalds , linux-arch@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-pm@vger.kernel.org, Mark Rutland , Pavel Machek , Peter Zijlstra , Thomas Gleixner , Will Deacon , "x86-ml" , xen-devel@lists.xenproject.org, Borislav Petkov In-Reply-To: <20191011115108.12392-2-jslaby@suse.cz> References: <20191011115108.12392-2-jslaby@suse.cz> MIME-Version: 1.0 Message-ID: <157141623459.29376.12545407561193574329.tip-bot2@tip-bot2> X-Mailer: tip-git-log-daemon Robot-ID: Robot-Unsubscribe: Contact to get blacklisted from these emails Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit X-Linutronix-Spam-Score: -1.0 X-Linutronix-Spam-Level: - X-Linutronix-Spam-Status: No , -1.0 points, 5.0 required, ALL_TRUSTED=-1,SHORTCIRCUIT=-0.0001 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The following commit has been merged into the x86/asm branch of tip: Commit-ID: ffedeeb780dc554eff3d3b16e6a462a26a41d7ec Gitweb: https://git.kernel.org/tip/ffedeeb780dc554eff3d3b16e6a462a26a41d7ec Author: Jiri Slaby AuthorDate: Fri, 11 Oct 2019 13:50:41 +02:00 Committer: Borislav Petkov CommitterDate: Fri, 18 Oct 2019 09:48:11 +02:00 linkage: Introduce new macros for assembler symbols 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 this can be switched 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. Signed-off-by: Jiri Slaby Signed-off-by: Borislav Petkov Acked-by: Rafael J. Wysocki Cc: Andrew Morton Cc: Andrey Ryabinin Cc: Boris Ostrovsky Cc: "H. Peter Anvin" Cc: Ingo Molnar Cc: Jonathan Corbet Cc: Josh Poimboeuf Cc: Juergen Gross Cc: Len Brown Cc: Linus Torvalds Cc: linux-arch@vger.kernel.org Cc: linux-doc@vger.kernel.org Cc: linux-kernel@vger.kernel.org Cc: linux-pm@vger.kernel.org Cc: Mark Rutland Cc: Pavel Machek Cc: Peter Zijlstra Cc: Thomas Gleixner Cc: Will Deacon Cc: x86-ml Cc: xen-devel@lists.xenproject.org Link: https://lkml.kernel.org/r/20191011115108.12392-2-jslaby@suse.cz --- Documentation/asm-annotations.rst | 216 ++++++++++++++++++++++++++- Documentation/index.rst | 8 +- arch/x86/include/asm/linkage.h | 10 +- include/linux/linkage.h | 245 ++++++++++++++++++++++++++++- 4 files changed, 468 insertions(+), 11 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 0000000..29ccd6e --- /dev/null +++ b/Documentation/asm-annotations.rst @@ -0,0 +1,216 @@ +Assembler Annotations +===================== + +Copyright (c) 2017-2019 Jiri Slaby + +This document describes the new macros for annotation of data and code in +assembly. 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, such code is grouped into functions and +accompanied 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 annotations to aid +debuggers throughout assembly. On top of that, developers also want to mark +some functions as *global* in order to be visible outside of their translation +units. + +Over time, the Linux kernel has adopted macros from various projects (like +``binutils``) to facilitate such annotations. So for historic reasons, +developers 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 to denote the beginning of global symbols (be it data or code). +``END`` used to mark 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 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 there are properly +annotated objects like this, tools can be run on them to generate more useful +information. In particular, on properly annotated objects, ``objtool`` can be +run to check and fix the object if needed. Currently, ``objtool`` can report +missing frame pointer setup/destruction in functions. It can also +automatically generate annotations for :doc:`ORC unwinder ` +for most code. Both of these are especially important to support reliable +stack traces which are in turn necessary for :doc:`Kernel live patching +`. + +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 + +There was a discussion_ and instead of extending the current ``ENTRY/END*`` +macros, it was decided that brand new macros should be introduced 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://lkml.kernel.org/r/20170217104757.28588-1-jslaby@suse.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. + + ``SYM_FUNC_START_WEAK`` and ``SYM_FUNC_START_WEAK_NOALIGN`` markings are + also offered as an assembler counterpart to 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 function boundaries. + + So in most cases, developers should write something like in the following + example, having some asm instructions in between the macros, of course:: + + SYM_FUNC_START(function_hook) + ... asm insns ... + SYM_FUNC_END(function_hook) + + In fact, this kind of annotation corresponds to the now deprecated ``ENTRY`` + and ``ENDPROC`` macros. + +* ``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) + ... asm insns ... + 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) + ... asm insns ... + 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, there is a couple of macros to describe data in the +assembly. + +* ``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/Documentation/index.rst b/Documentation/index.rst index b843e31..2ceab19 100644 --- a/Documentation/index.rst +++ b/Documentation/index.rst @@ -135,6 +135,14 @@ needed). mic/index scheduler/index +Architecture-agnostic documentation +----------------------------------- + +.. toctree:: + :maxdepth: 2 + + asm-annotations + Architecture-specific documentation ----------------------------------- diff --git a/arch/x86/include/asm/linkage.h b/arch/x86/include/asm/linkage.h index 14caa9d..e07188e 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 7e02078..f3ae8f3 100644 --- a/include/linux/linkage.h +++ b/include/linux/linkage.h @@ -75,32 +75,58 @@ #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 GLOBAL +/* deprecated, use SYM_DATA*, SYM_ENTRY, or similar */ #define GLOBAL(name) \ .globl name ASM_NL \ name: #endif #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 \ - ALIGN 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 @@ -110,11 +136,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 */ From mboxrd@z Thu Jan 1 00:00:00 1970 From: "tip-bot2 for Jiri Slaby" Subject: [tip: x86/asm] linkage: Introduce new macros for assembler symbols Date: Fri, 18 Oct 2019 16:30:34 -0000 Message-ID: <157141623459.29376.12545407561193574329.tip-bot2@tip-bot2> References: <20191011115108.12392-2-jslaby@suse.cz> Reply-To: linux-kernel@vger.kernel.org Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Return-path: In-Reply-To: <20191011115108.12392-2-jslaby@suse.cz> Sender: linux-kernel-owner@vger.kernel.org To: linux-tip-commits@vger.kernel.org Cc: Jiri Slaby , Borislav Petkov , "Rafael J. Wysocki" , Andrew Morton , Andrey Ryabinin , Boris Ostrovsky , "H. Peter Anvin" , Ingo Molnar , Jonathan Corbet , Josh Poimboeuf , Juergen Gross , Len Brown , Linus Torvalds , linux-arch@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-pm@vger.kernel.org, Mark Rutland , Pavel Machek , Peter Zijlstra , Thomas Gleixner , Will List-Id: linux-arch.vger.kernel.org The following commit has been merged into the x86/asm branch of tip: Commit-ID: ffedeeb780dc554eff3d3b16e6a462a26a41d7ec Gitweb: https://git.kernel.org/tip/ffedeeb780dc554eff3d3b16e6a462a26a41d7ec Author: Jiri Slaby AuthorDate: Fri, 11 Oct 2019 13:50:41 +02:00 Committer: Borislav Petkov CommitterDate: Fri, 18 Oct 2019 09:48:11 +02:00 linkage: Introduce new macros for assembler symbols 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 this can be switched 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. Signed-off-by: Jiri Slaby Signed-off-by: Borislav Petkov Acked-by: Rafael J. Wysocki Cc: Andrew Morton Cc: Andrey Ryabinin Cc: Boris Ostrovsky Cc: "H. Peter Anvin" Cc: Ingo Molnar Cc: Jonathan Corbet Cc: Josh Poimboeuf Cc: Juergen Gross Cc: Len Brown Cc: Linus Torvalds Cc: linux-arch@vger.kernel.org Cc: linux-doc@vger.kernel.org Cc: linux-kernel@vger.kernel.org Cc: linux-pm@vger.kernel.org Cc: Mark Rutland Cc: Pavel Machek Cc: Peter Zijlstra Cc: Thomas Gleixner Cc: Will Deacon Cc: x86-ml Cc: xen-devel@lists.xenproject.org Link: https://lkml.kernel.org/r/20191011115108.12392-2-jslaby@suse.cz --- Documentation/asm-annotations.rst | 216 ++++++++++++++++++++++++++- Documentation/index.rst | 8 +- arch/x86/include/asm/linkage.h | 10 +- include/linux/linkage.h | 245 ++++++++++++++++++++++++++++- 4 files changed, 468 insertions(+), 11 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 0000000..29ccd6e --- /dev/null +++ b/Documentation/asm-annotations.rst @@ -0,0 +1,216 @@ +Assembler Annotations +===================== + +Copyright (c) 2017-2019 Jiri Slaby + +This document describes the new macros for annotation of data and code in +assembly. 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, such code is grouped into functions and +accompanied 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 annotations to aid +debuggers throughout assembly. On top of that, developers also want to mark +some functions as *global* in order to be visible outside of their translation +units. + +Over time, the Linux kernel has adopted macros from various projects (like +``binutils``) to facilitate such annotations. So for historic reasons, +developers 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 to denote the beginning of global symbols (be it data or code). +``END`` used to mark 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 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 there are properly +annotated objects like this, tools can be run on them to generate more useful +information. In particular, on properly annotated objects, ``objtool`` can be +run to check and fix the object if needed. Currently, ``objtool`` can report +missing frame pointer setup/destruction in functions. It can also +automatically generate annotations for :doc:`ORC unwinder ` +for most code. Both of these are especially important to support reliable +stack traces which are in turn necessary for :doc:`Kernel live patching +`. + +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 + +There was a discussion_ and instead of extending the current ``ENTRY/END*`` +macros, it was decided that brand new macros should be introduced 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://lkml.kernel.org/r/20170217104757.28588-1-jslaby@suse.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. + + ``SYM_FUNC_START_WEAK`` and ``SYM_FUNC_START_WEAK_NOALIGN`` markings are + also offered as an assembler counterpart to 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 function boundaries. + + So in most cases, developers should write something like in the following + example, having some asm instructions in between the macros, of course:: + + SYM_FUNC_START(function_hook) + ... asm insns ... + SYM_FUNC_END(function_hook) + + In fact, this kind of annotation corresponds to the now deprecated ``ENTRY`` + and ``ENDPROC`` macros. + +* ``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) + ... asm insns ... + 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) + ... asm insns ... + 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, there is a couple of macros to describe data in the +assembly. + +* ``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/Documentation/index.rst b/Documentation/index.rst index b843e31..2ceab19 100644 --- a/Documentation/index.rst +++ b/Documentation/index.rst @@ -135,6 +135,14 @@ needed). mic/index scheduler/index +Architecture-agnostic documentation +----------------------------------- + +.. toctree:: + :maxdepth: 2 + + asm-annotations + Architecture-specific documentation ----------------------------------- diff --git a/arch/x86/include/asm/linkage.h b/arch/x86/include/asm/linkage.h index 14caa9d..e07188e 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 7e02078..f3ae8f3 100644 --- a/include/linux/linkage.h +++ b/include/linux/linkage.h @@ -75,32 +75,58 @@ #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 GLOBAL +/* deprecated, use SYM_DATA*, SYM_ENTRY, or similar */ #define GLOBAL(name) \ .globl name ASM_NL \ name: #endif #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 \ - ALIGN 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 @@ -110,11 +136,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 */ From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-11.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B234CCA9EAB for ; Fri, 18 Oct 2019 16:31:33 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 801C520659 for ; Fri, 18 Oct 2019 16:31:33 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 801C520659 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=linutronix.de Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iLV9i-0006aC-Iz; Fri, 18 Oct 2019 16:31:10 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iLV9h-0006Zc-62 for xen-devel@lists.xenproject.org; Fri, 18 Oct 2019 16:31:09 +0000 X-Inumbo-ID: a5ffc9b2-f1c4-11e9-beca-bc764e2007e4 Received: from Galois.linutronix.de (unknown [2a0a:51c0:0:12e:550::1]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id a5ffc9b2-f1c4-11e9-beca-bc764e2007e4; Fri, 18 Oct 2019 16:30:51 +0000 (UTC) Received: from [5.158.153.53] (helo=tip-bot2.lab.linutronix.de) by Galois.linutronix.de with esmtpsa (TLS1.2:DHE_RSA_AES_256_CBC_SHA256:256) (Exim 4.80) (envelope-from ) id 1iLV9G-00033g-4R; Fri, 18 Oct 2019 18:30:42 +0200 Received: from [127.0.1.1] (localhost [IPv6:::1]) by tip-bot2.lab.linutronix.de (Postfix) with ESMTP id CA5CC1C03AB; Fri, 18 Oct 2019 18:30:34 +0200 (CEST) Date: Fri, 18 Oct 2019 16:30:34 -0000 From: "tip-bot2 for Jiri Slaby" To: linux-tip-commits@vger.kernel.org In-Reply-To: <20191011115108.12392-2-jslaby@suse.cz> References: <20191011115108.12392-2-jslaby@suse.cz> MIME-Version: 1.0 Message-ID: <157141623459.29376.12545407561193574329.tip-bot2@tip-bot2> X-Mailer: tip-git-log-daemon Robot-ID: Robot-Unsubscribe: Contact to get blacklisted from these emails Precedence: bulk X-Linutronix-Spam-Score: -1.0 X-Linutronix-Spam-Level: - X-Linutronix-Spam-Status: No , -1.0 points, 5.0 required, ALL_TRUSTED=-1, SHORTCIRCUIT=-0.0001 Subject: [Xen-devel] [tip: x86/asm] linkage: Introduce new macros for assembler symbols X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Reply-To: linux-kernel@vger.kernel.org Cc: Mark Rutland , x86-ml , linux-doc@vger.kernel.org, Boris Ostrovsky , Pavel Machek , "H. Peter Anvin" , Will Deacon , Ingo Molnar , linux-arch@vger.kernel.org, xen-devel@lists.xenproject.org, Jonathan Corbet , Jiri Slaby , "Rafael J. Wysocki" , Andrey Ryabinin , Borislav Petkov , Len Brown , Peter Zijlstra , linux-pm@vger.kernel.org, Borislav Petkov , Josh Poimboeuf , Thomas Gleixner , Juergen Gross , linux-kernel@vger.kernel.org, Andrew Morton , Linus Torvalds Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" VGhlIGZvbGxvd2luZyBjb21taXQgaGFzIGJlZW4gbWVyZ2VkIGludG8gdGhlIHg4Ni9hc20gYnJh bmNoIG9mIHRpcDoKCkNvbW1pdC1JRDogICAgIGZmZWRlZWI3ODBkYzU1NGVmZjNkM2IxNmU2YTQ2 MmEyNmE0MWQ3ZWMKR2l0d2ViOiAgICAgICAgaHR0cHM6Ly9naXQua2VybmVsLm9yZy90aXAvZmZl ZGVlYjc4MGRjNTU0ZWZmM2QzYjE2ZTZhNDYyYTI2YTQxZDdlYwpBdXRob3I6ICAgICAgICBKaXJp IFNsYWJ5IDxqc2xhYnlAc3VzZS5jej4KQXV0aG9yRGF0ZTogICAgRnJpLCAxMSBPY3QgMjAxOSAx Mzo1MDo0MSArMDI6MDAKQ29tbWl0dGVyOiAgICAgQm9yaXNsYXYgUGV0a292IDxicEBzdXNlLmRl PgpDb21taXR0ZXJEYXRlOiBGcmksIDE4IE9jdCAyMDE5IDA5OjQ4OjExICswMjowMAoKbGlua2Fn ZTogSW50cm9kdWNlIG5ldyBtYWNyb3MgZm9yIGFzc2VtYmxlciBzeW1ib2xzCgpJbnRyb2R1Y2Ug bmV3IEMgbWFjcm9zIGZvciBhbm5vdGF0aW9ucyBvZiBmdW5jdGlvbnMgYW5kIGRhdGEgaW4KYXNz ZW1ibHkuIFRoZXJlIGlzIGEgbG9uZy1zdGFuZGluZyBtZXNzIGluIG1hY3JvcyBsaWtlIEVOVFJZ LCBFTkQsCkVORFBST0MgYW5kIHNpbWlsYXIuIFRoZXkgYXJlIHVzZWQgaW4gZGlmZmVyZW50IG1h bm5lcnMgYW5kIHNvbWV0aW1lcwppbmNvcnJlY3RseS4KClNvIGludHJvZHVjZSBtYWNyb3Mgd2l0 aCBjbGVhciB1c2UgdG8gYW5ub3RhdGUgYXNzZW1ibHkgYXMgZm9sbG93czoKCmEpIFN1cHBvcnQg bWFjcm9zIGZvciB0aGUgb25lcyBiZWxvdwogICBTWU1fVF9GVU5DIC0tIHR5cGUgdXNlZCBieSBh c3NlbWJsZXIgdG8gbWFyayBmdW5jdGlvbnMKICAgU1lNX1RfT0JKRUNUIC0tIHR5cGUgdXNlZCBi eSBhc3NlbWJsZXIgdG8gbWFyayBkYXRhCiAgIFNZTV9UX05PTkUgLS0gdHlwZSB1c2VkIGJ5IGFz c2VtYmxlciB0byBtYXJrIGVudHJpZXMgb2YgdW5rbm93biB0eXBlCgogICBUaGV5IGFyZSBkZWZp bmVkIGFzIFNUVF9GVU5DLCBTVFRfT0JKRUNULCBhbmQgU1RUX05PVFlQRQogICByZXNwZWN0aXZl bHkuIEFjY29yZGluZyB0byB0aGUgZ2FzIG1hbnVhbCwgdGhpcyBpcyB0aGUgbW9zdCBwb3J0YWJs ZQogICB3YXkuIEkgYW0gbm90IHN1cmUgYWJvdXQgb3RoZXIgYXNzZW1ibGVycywgc28gdGhpcyBj YW4gYmUgc3dpdGNoZWQKICAgYmFjayB0byAlZnVuY3Rpb24gYW5kICVvYmplY3QgaWYgdGhpcyB0 dXJucyBpbnRvIGEgcHJvYmxlbS4KICAgQXJjaGl0ZWN0dXJlcyBjYW4gYWxzbyBvdmVycmlkZSB0 aGVtIGJ5IHNvbWV0aGluZyBsaWtlICIsIEBmdW5jdGlvbiIKICAgaWYgdGhleSBuZWVkLgoKICAg U1lNX0FfQUxJR04sIFNZTV9BX05PTkUgLS0gYWxpZ24gdGhlIHN5bWJvbD8KICAgU1lNX0xfR0xP QkFMLCBTWU1fTF9XRUFLLCBTWU1fTF9MT0NBTCAtLSBsaW5rYWdlIG9mIHN5bWJvbHMKCmIpIE1v c3RseSBpbnRlcm5hbCBhbm5vdGF0aW9ucywgdXNlZCBieSB0aGUgb25lcyBiZWxvdwogICBTWU1f RU5UUlkgLS0gdXNlIG9ubHkgaWYgeW91IGhhdmUgdG8gKGZvciBub24tcGFpcmVkIHN5bWJvbHMp CiAgIFNZTV9TVEFSVCAtLSB1c2Ugb25seSBpZiB5b3UgaGF2ZSB0byAoZm9yIHBhaXJlZCBzeW1i b2xzKQogICBTWU1fRU5EIC0tIHVzZSBvbmx5IGlmIHlvdSBoYXZlIHRvIChmb3IgcGFpcmVkIHN5 bWJvbHMpCgpjKSBBbm5vdGF0aW9ucyBmb3IgY29kZQogICBTWU1fSU5ORVJfTEFCRUxfQUxJR04g LS0gb25seSBmb3IgbGFiZWxzIGluIHRoZSBtaWRkbGUgb2YgY29kZQogICBTWU1fSU5ORVJfTEFC RUwgLS0gb25seSBmb3IgbGFiZWxzIGluIHRoZSBtaWRkbGUgb2YgY29kZQoKICAgU1lNX0ZVTkNf U1RBUlRfTE9DQUxfQUxJQVMgLS0gdXNlIHdoZXJlIHRoZXJlIGFyZSB0d28gbG9jYWwgbmFtZXMg Zm9yCglvbmUgZnVuY3Rpb24KICAgU1lNX0ZVTkNfU1RBUlRfQUxJQVMgLS0gdXNlIHdoZXJlIHRo ZXJlIGFyZSB0d28gZ2xvYmFsIG5hbWVzIGZvciBvbmUKCWZ1bmN0aW9uCiAgIFNZTV9GVU5DX0VO RF9BTElBUyAtLSB0aGUgZW5kIG9mIExPQ0FMX0FMSUFTZWQgb3IgQUxJQVNlZCBmdW5jdGlvbgoK ICAgU1lNX0ZVTkNfU1RBUlQgLS0gdXNlIGZvciBnbG9iYWwgZnVuY3Rpb25zCiAgIFNZTV9GVU5D X1NUQVJUX05PQUxJR04gLS0gdXNlIGZvciBnbG9iYWwgZnVuY3Rpb25zLCB3L28gYWxpZ25tZW50 CiAgIFNZTV9GVU5DX1NUQVJUX0xPQ0FMIC0tIHVzZSBmb3IgbG9jYWwgZnVuY3Rpb25zCiAgIFNZ TV9GVU5DX1NUQVJUX0xPQ0FMX05PQUxJR04gLS0gdXNlIGZvciBsb2NhbCBmdW5jdGlvbnMsIHcv bwoJYWxpZ25tZW50CiAgIFNZTV9GVU5DX1NUQVJUX1dFQUsgLS0gdXNlIGZvciB3ZWFrIGZ1bmN0 aW9ucwogICBTWU1fRlVOQ19TVEFSVF9XRUFLX05PQUxJR04gLS0gdXNlIGZvciB3ZWFrIGZ1bmN0 aW9ucywgdy9vIGFsaWdubWVudAogICBTWU1fRlVOQ19FTkQgLS0gdGhlIGVuZCBvZiBTWU1fRlVO Q19TVEFSVF9MT0NBTCwgU1lNX0ZVTkNfU1RBUlQsCglTWU1fRlVOQ19TVEFSVF9XRUFLLCAuLi4K CiAgIEZvciBmdW5jdGlvbnMgd2l0aCBzcGVjaWFsIChub24tQykgY2FsbGluZyBjb252ZW50aW9u czoKICAgU1lNX0NPREVfU1RBUlQgLS0gdXNlIGZvciBub24tQyAoc3BlY2lhbCkgZnVuY3Rpb25z CiAgIFNZTV9DT0RFX1NUQVJUX05PQUxJR04gLS0gdXNlIGZvciBub24tQyAoc3BlY2lhbCkgZnVu Y3Rpb25zLCB3L28KCWFsaWdubWVudAogICBTWU1fQ09ERV9TVEFSVF9MT0NBTCAtLSB1c2UgZm9y IGxvY2FsIG5vbi1DIChzcGVjaWFsKSBmdW5jdGlvbnMKICAgU1lNX0NPREVfU1RBUlRfTE9DQUxf Tk9BTElHTiAtLSB1c2UgZm9yIGxvY2FsIG5vbi1DIChzcGVjaWFsKQoJZnVuY3Rpb25zLCB3L28g YWxpZ25tZW50CiAgIFNZTV9DT0RFX0VORCAtLSB0aGUgZW5kIG9mIFNZTV9DT0RFX1NUQVJUX0xP Q0FMIG9yIFNZTV9DT0RFX1NUQVJUCgpkKSBGb3IgZGF0YQogICBTWU1fREFUQV9TVEFSVCAtLSBn bG9iYWwgZGF0YSBzeW1ib2wKICAgU1lNX0RBVEFfU1RBUlRfTE9DQUwgLS0gbG9jYWwgZGF0YSBz eW1ib2wKICAgU1lNX0RBVEFfRU5EIC0tIHRoZSBlbmQgb2YgdGhlIFNZTV9EQVRBX1NUQVJUIHN5 bWJvbAogICBTWU1fREFUQV9FTkRfTEFCRUwgLS0gdGhlIGxhYmVsZWQgZW5kIG9mIFNZTV9EQVRB X1NUQVJUIHN5bWJvbAogICBTWU1fREFUQSAtLSBzdGFydCtlbmQgd3JhcHBlciBhcm91bmQgc2lt cGxlIGdsb2JhbCBkYXRhCiAgIFNZTV9EQVRBX0xPQ0FMIC0tIHN0YXJ0K2VuZCB3cmFwcGVyIGFy b3VuZCBzaW1wbGUgbG9jYWwgZGF0YQoKPT09PT09PT09PQoKVGhlIG1hY3JvcyBhbGxvdyB0byBw YWlyIHN0YXJ0cyBhbmQgZW5kcyBvZiBmdW5jdGlvbnMgYW5kIG1hcmsgZnVuY3Rpb25zCmNvcnJl Y3RseSBpbiB0aGUgb3V0cHV0IEVMRiBvYmplY3RzLgoKQWxsIHVzZXJzIG9mIHRoZSBvbGQgbWFj cm9zIGluIHg4NiBhcmUgY29udmVydGVkIHRvIHVzZSB0aGVzZSBpbiBmdXJ0aGVyCnBhdGNoZXMu CgpTaWduZWQtb2ZmLWJ5OiBKaXJpIFNsYWJ5IDxqc2xhYnlAc3VzZS5jej4KU2lnbmVkLW9mZi1i eTogQm9yaXNsYXYgUGV0a292IDxicEBzdXNlLmRlPgpBY2tlZC1ieTogUmFmYWVsIEouIFd5c29j a2kgPHJhZmFlbC5qLnd5c29ja2lAaW50ZWwuY29tPgpDYzogQW5kcmV3IE1vcnRvbiA8YWtwbUBs aW51eC1mb3VuZGF0aW9uLm9yZz4KQ2M6IEFuZHJleSBSeWFiaW5pbiA8YXJ5YWJpbmluQHZpcnR1 b3p6by5jb20+CkNjOiBCb3JpcyBPc3Ryb3Zza3kgPGJvcmlzLm9zdHJvdnNreUBvcmFjbGUuY29t PgpDYzogIkguIFBldGVyIEFudmluIiA8aHBhQHp5dG9yLmNvbT4KQ2M6IEluZ28gTW9sbmFyIDxt aW5nb0BrZXJuZWwub3JnPgpDYzogSm9uYXRoYW4gQ29yYmV0IDxjb3JiZXRAbHduLm5ldD4KQ2M6 IEpvc2ggUG9pbWJvZXVmIDxqcG9pbWJvZUByZWRoYXQuY29tPgpDYzogSnVlcmdlbiBHcm9zcyA8 amdyb3NzQHN1c2UuY29tPgpDYzogTGVuIEJyb3duIDxsZW4uYnJvd25AaW50ZWwuY29tPgpDYzog TGludXMgVG9ydmFsZHMgPHRvcnZhbGRzQGxpbnV4LWZvdW5kYXRpb24ub3JnPgpDYzogbGludXgt YXJjaEB2Z2VyLmtlcm5lbC5vcmcKQ2M6IGxpbnV4LWRvY0B2Z2VyLmtlcm5lbC5vcmcKQ2M6IGxp bnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKQ2M6IGxpbnV4LXBtQHZnZXIua2VybmVsLm9yZwpD YzogTWFyayBSdXRsYW5kIDxtYXJrLnJ1dGxhbmRAYXJtLmNvbT4KQ2M6IFBhdmVsIE1hY2hlayA8 cGF2ZWxAdWN3LmN6PgpDYzogUGV0ZXIgWmlqbHN0cmEgPGEucC56aWpsc3RyYUBjaGVsbG8ubmw+ CkNjOiBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGludXRyb25peC5kZT4KQ2M6IFdpbGwgRGVhY29u IDx3aWxsQGtlcm5lbC5vcmc+CkNjOiB4ODYtbWwgPHg4NkBrZXJuZWwub3JnPgpDYzogeGVuLWRl dmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCkxpbms6IGh0dHBzOi8vbGttbC5rZXJuZWwub3JnL3Iv MjAxOTEwMTExMTUxMDguMTIzOTItMi1qc2xhYnlAc3VzZS5jegotLS0KIERvY3VtZW50YXRpb24v YXNtLWFubm90YXRpb25zLnJzdCB8IDIxNiArKysrKysrKysrKysrKysrKysrKysrKysrKy0KIERv Y3VtZW50YXRpb24vaW5kZXgucnN0ICAgICAgICAgICB8ICAgOCArLQogYXJjaC94ODYvaW5jbHVk ZS9hc20vbGlua2FnZS5oICAgIHwgIDEwICstCiBpbmNsdWRlL2xpbnV4L2xpbmthZ2UuaCAgICAg ICAgICAgfCAyNDUgKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KIDQgZmlsZXMgY2hhbmdl ZCwgNDY4IGluc2VydGlvbnMoKyksIDExIGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0 IERvY3VtZW50YXRpb24vYXNtLWFubm90YXRpb25zLnJzdAoKZGlmZiAtLWdpdCBhL0RvY3VtZW50 YXRpb24vYXNtLWFubm90YXRpb25zLnJzdCBiL0RvY3VtZW50YXRpb24vYXNtLWFubm90YXRpb25z LnJzdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yOWNjZDZlCi0tLSAvZGV2 L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi9hc20tYW5ub3RhdGlvbnMucnN0CkBAIC0wLDAgKzEs MjE2IEBACitBc3NlbWJsZXIgQW5ub3RhdGlvbnMKKz09PT09PT09PT09PT09PT09PT09PQorCitD b3B5cmlnaHQgKGMpIDIwMTctMjAxOSBKaXJpIFNsYWJ5CisKK1RoaXMgZG9jdW1lbnQgZGVzY3Jp YmVzIHRoZSBuZXcgbWFjcm9zIGZvciBhbm5vdGF0aW9uIG9mIGRhdGEgYW5kIGNvZGUgaW4KK2Fz c2VtYmx5LiBJbiBwYXJ0aWN1bGFyLCBpdCBjb250YWlucyBpbmZvcm1hdGlvbiBhYm91dCBgYFNZ TV9GVU5DX1NUQVJUYGAsCitgYFNZTV9GVU5DX0VORGBgLCBgYFNZTV9DT0RFX1NUQVJUYGAsIGFu ZCBzaW1pbGFyLgorCitSYXRpb25hbGUKKy0tLS0tLS0tLQorU29tZSBjb2RlIGxpa2UgZW50cmll cywgdHJhbXBvbGluZXMsIG9yIGJvb3QgY29kZSBuZWVkcyB0byBiZSB3cml0dGVuIGluCithc3Nl bWJseS4gVGhlIHNhbWUgYXMgaW4gQywgc3VjaCBjb2RlIGlzIGdyb3VwZWQgaW50byBmdW5jdGlv bnMgYW5kCithY2NvbXBhbmllZCB3aXRoIGRhdGEuIFN0YW5kYXJkIGFzc2VtYmxlcnMgZG8gbm90 IGZvcmNlIHVzZXJzIGludG8gcHJlY2lzZWx5CittYXJraW5nIHRoZXNlIHBpZWNlcyBhcyBjb2Rl LCBkYXRhLCBvciBldmVuIHNwZWNpZnlpbmcgdGhlaXIgbGVuZ3RoLgorTmV2ZXJ0aGVsZXNzLCBh c3NlbWJsZXJzIHByb3ZpZGUgZGV2ZWxvcGVycyB3aXRoIHN1Y2ggYW5ub3RhdGlvbnMgdG8gYWlk CitkZWJ1Z2dlcnMgdGhyb3VnaG91dCBhc3NlbWJseS4gT24gdG9wIG9mIHRoYXQsIGRldmVsb3Bl cnMgYWxzbyB3YW50IHRvIG1hcmsKK3NvbWUgZnVuY3Rpb25zIGFzICpnbG9iYWwqIGluIG9yZGVy IHRvIGJlIHZpc2libGUgb3V0c2lkZSBvZiB0aGVpciB0cmFuc2xhdGlvbgordW5pdHMuCisKK092 ZXIgdGltZSwgdGhlIExpbnV4IGtlcm5lbCBoYXMgYWRvcHRlZCBtYWNyb3MgZnJvbSB2YXJpb3Vz IHByb2plY3RzIChsaWtlCitgYGJpbnV0aWxzYGApIHRvIGZhY2lsaXRhdGUgc3VjaCBhbm5vdGF0 aW9ucy4gU28gZm9yIGhpc3RvcmljIHJlYXNvbnMsCitkZXZlbG9wZXJzIGhhdmUgYmVlbiB1c2lu ZyBgYEVOVFJZYGAsIGBgRU5EYGAsIGBgRU5EUFJPQ2BgLCBhbmQgb3RoZXIKK2Fubm90YXRpb25z IGluIGFzc2VtYmx5LiAgRHVlIHRvIHRoZSBsYWNrIG9mIHRoZWlyIGRvY3VtZW50YXRpb24sIHRo ZSBtYWNyb3MKK2FyZSB1c2VkIGluIHJhdGhlciB3cm9uZyBjb250ZXh0cyBhdCBzb21lIGxvY2F0 aW9ucy4gQ2xlYXJseSwgYGBFTlRSWWBgIHdhcworaW50ZW5kZWQgdG8gZGVub3RlIHRoZSBiZWdp bm5pbmcgb2YgZ2xvYmFsIHN5bWJvbHMgKGJlIGl0IGRhdGEgb3IgY29kZSkuCitgYEVORGBgIHVz ZWQgdG8gbWFyayB0aGUgZW5kIG9mIGRhdGEgb3IgZW5kIG9mIHNwZWNpYWwgZnVuY3Rpb25zIHdp dGgKKypub24tc3RhbmRhcmQqIGNhbGxpbmcgY29udmVudGlvbi4gSW4gY29udHJhc3QsIGBgRU5E UFJPQ2BgIHNob3VsZCBhbm5vdGF0ZQorb25seSBlbmRzIG9mICpzdGFuZGFyZCogZnVuY3Rpb25z LgorCitXaGVuIHRoZXNlIG1hY3JvcyBhcmUgdXNlZCBjb3JyZWN0bHksIHRoZXkgaGVscCBhc3Nl bWJsZXJzIGdlbmVyYXRlIGEgbmljZQorb2JqZWN0IHdpdGggYm90aCBzaXplcyBhbmQgdHlwZXMg c2V0IGNvcnJlY3RseS4gRm9yIGV4YW1wbGUsIHRoZSByZXN1bHQgb2YKK2BgYXJjaC94ODYvbGli L3B1dHVzZXIuU2BgOjoKKworICAgTnVtOiAgICBWYWx1ZSAgICAgICAgICBTaXplIFR5cGUgICAg QmluZCAgIFZpcyAgICAgIE5keCBOYW1lCisgICAgMjU6IDAwMDAwMDAwMDAwMDAwMDAgICAgMzMg RlVOQyAgICBHTE9CQUwgREVGQVVMVCAgICAxIF9fcHV0X3VzZXJfMQorICAgIDI5OiAwMDAwMDAw MDAwMDAwMDMwICAgIDM3IEZVTkMgICAgR0xPQkFMIERFRkFVTFQgICAgMSBfX3B1dF91c2VyXzIK KyAgICAzMjogMDAwMDAwMDAwMDAwMDA2MCAgICAzNiBGVU5DICAgIEdMT0JBTCBERUZBVUxUICAg IDEgX19wdXRfdXNlcl80CisgICAgMzU6IDAwMDAwMDAwMDAwMDAwOTAgICAgMzcgRlVOQyAgICBH TE9CQUwgREVGQVVMVCAgICAxIF9fcHV0X3VzZXJfOAorCitUaGlzIGlzIG5vdCBvbmx5IGltcG9y dGFudCBmb3IgZGVidWdnaW5nIHB1cnBvc2VzLiBXaGVuIHRoZXJlIGFyZSBwcm9wZXJseQorYW5u b3RhdGVkIG9iamVjdHMgbGlrZSB0aGlzLCB0b29scyBjYW4gYmUgcnVuIG9uIHRoZW0gdG8gZ2Vu ZXJhdGUgbW9yZSB1c2VmdWwKK2luZm9ybWF0aW9uLiBJbiBwYXJ0aWN1bGFyLCBvbiBwcm9wZXJs eSBhbm5vdGF0ZWQgb2JqZWN0cywgYGBvYmp0b29sYGAgY2FuIGJlCitydW4gdG8gY2hlY2sgYW5k IGZpeCB0aGUgb2JqZWN0IGlmIG5lZWRlZC4gQ3VycmVudGx5LCBgYG9ianRvb2xgYCBjYW4gcmVw b3J0CittaXNzaW5nIGZyYW1lIHBvaW50ZXIgc2V0dXAvZGVzdHJ1Y3Rpb24gaW4gZnVuY3Rpb25z LiBJdCBjYW4gYWxzbworYXV0b21hdGljYWxseSBnZW5lcmF0ZSBhbm5vdGF0aW9ucyBmb3IgOmRv YzpgT1JDIHVud2luZGVyIDx4ODYvb3JjLXVud2luZGVyPmAKK2ZvciBtb3N0IGNvZGUuIEJvdGgg b2YgdGhlc2UgYXJlIGVzcGVjaWFsbHkgaW1wb3J0YW50IHRvIHN1cHBvcnQgcmVsaWFibGUKK3N0 YWNrIHRyYWNlcyB3aGljaCBhcmUgaW4gdHVybiBuZWNlc3NhcnkgZm9yIDpkb2M6YEtlcm5lbCBs aXZlIHBhdGNoaW5nCis8bGl2ZXBhdGNoL2xpdmVwYXRjaD5gLgorCitDYXZlYXQgYW5kIERpc2N1 c3Npb24KKy0tLS0tLS0tLS0tLS0tLS0tLS0tLQorQXMgb25lIG1pZ2h0IHJlYWxpemUsIHRoZXJl IHdlcmUgb25seSB0aHJlZSBtYWNyb3MgcHJldmlvdXNseS4gVGhhdCBpcyBpbmRlZWQKK2luc3Vm ZmljaWVudCB0byBjb3ZlciBhbGwgdGhlIGNvbWJpbmF0aW9ucyBvZiBjYXNlczoKKworKiBzdGFu ZGFyZC9ub24tc3RhbmRhcmQgZnVuY3Rpb24KKyogY29kZS9kYXRhCisqIGdsb2JhbC9sb2NhbCBz eW1ib2wKKworVGhlcmUgd2FzIGEgZGlzY3Vzc2lvbl8gYW5kIGluc3RlYWQgb2YgZXh0ZW5kaW5n IHRoZSBjdXJyZW50IGBgRU5UUlkvRU5EKmBgCittYWNyb3MsIGl0IHdhcyBkZWNpZGVkIHRoYXQg YnJhbmQgbmV3IG1hY3JvcyBzaG91bGQgYmUgaW50cm9kdWNlZCBpbnN0ZWFkOjoKKworICAgIFNv IGhvdyBhYm91dCB1c2luZyBtYWNybyBuYW1lcyB0aGF0IGFjdHVhbGx5IHNob3cgdGhlIHB1cnBv c2UsIGluc3RlYWQKKyAgICBvZiBpbXBvcnRpbmcgYWxsIHRoZSBjcmFwcHksIGhpc3RvcmljLCBl c3NlbnRpYWxseSByYW5kb21seSBjaG9zZW4KKyAgICBkZWJ1ZyBzeW1ib2wgbWFjcm8gbmFtZXMg ZnJvbSB0aGUgYmludXRpbHMgYW5kIG9sZGVyIGtlcm5lbHM/CisKKy4uIF9kaXNjdXNzaW9uOiBo dHRwczovL2xrbWwua2VybmVsLm9yZy9yLzIwMTcwMjE3MTA0NzU3LjI4NTg4LTEtanNsYWJ5QHN1 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 cmUgZGV2ZWxvcGVycyBkbyBub3Qgd2FudCB0aGlzIGltcGxpY2l0IGFsaWdubWVudC4KKworICBg YFNZTV9GVU5DX1NUQVJUX1dFQUtgYCBhbmQgYGBTWU1fRlVOQ19TVEFSVF9XRUFLX05PQUxJR05g YCBtYXJraW5ncyBhcmUKKyAgYWxzbyBvZmZlcmVkIGFzIGFuIGFzc2VtYmxlciBjb3VudGVycGFy dCB0byB0aGUgKndlYWsqIGF0dHJpYnV0ZSBrbm93biBmcm9tCisgIEMuCisKKyAgQWxsIG9mIHRo ZXNlICoqc2hhbGwqKiBiZSBjb3VwbGVkIHdpdGggYGBTWU1fRlVOQ19FTkRgYC4gRmlyc3QsIGl0 IG1hcmtzCisgIHRoZSBzZXF1ZW5jZSBvZiBpbnN0cnVjdGlvbnMgYXMgYSBmdW5jdGlvbiBhbmQg Y29tcHV0ZXMgaXRzIHNpemUgdG8gdGhlCisgIGdlbmVyYXRlZCBvYmplY3QgZmlsZS4gU2Vjb25k LCBpdCBhbHNvIGVhc2VzIGNoZWNraW5nIGFuZCBwcm9jZXNzaW5nIHN1Y2gKKyAgb2JqZWN0IGZp bGVzIGFzIHRoZSB0b29scyBjYW4gdHJpdmlhbGx5IGZpbmQgZXhhY3QgZnVuY3Rpb24gYm91bmRh cmllcy4KKworICBTbyBpbiBtb3N0IGNhc2VzLCBkZXZlbG9wZXJzIHNob3VsZCB3cml0ZSBzb21l dGhpbmcgbGlrZSBpbiB0aGUgZm9sbG93aW5nCisgIGV4YW1wbGUsIGhhdmluZyBzb21lIGFzbSBp bnN0cnVjdGlvbnMgaW4gYmV0d2VlbiB0aGUgbWFjcm9zLCBvZiBjb3Vyc2U6OgorCisgICAgU1lN X0ZVTkNfU1RBUlQoZnVuY3Rpb25faG9vaykKKyAgICAgICAgLi4uIGFzbSBpbnNucyAuLi4KKyAg ICBTWU1fRlVOQ19FTkQoZnVuY3Rpb25faG9vaykKKworICBJbiBmYWN0LCB0aGlzIGtpbmQgb2Yg YW5ub3RhdGlvbiBjb3JyZXNwb25kcyB0byB0aGUgbm93IGRlcHJlY2F0ZWQgYGBFTlRSWWBgCisg IGFuZCBgYEVORFBST0NgYCBtYWNyb3MuCisKKyogYGBTWU1fRlVOQ19TVEFSVF9BTElBU2BgIGFu ZCBgYFNZTV9GVU5DX1NUQVJUX0xPQ0FMX0FMSUFTYGAgc2VydmUgZm9yIHRob3NlCisgIHdobyBk ZWNpZGVkIHRvIGhhdmUgdHdvIG9yIG1vcmUgbmFtZXMgZm9yIG9uZSBmdW5jdGlvbi4gVGhlIHR5 cGljYWwgdXNlIGlzOjoKKworICAgIFNZTV9GVU5DX1NUQVJUX0FMSUFTKF9fbWVtc2V0KQorICAg IFNZTV9GVU5DX1NUQVJUKG1lbXNldCkKKyAgICAgICAgLi4uIGFzbSBpbnNucyAuLi4KKyAgICBT WU1fRlVOQ19FTkQobWVtc2V0KQorICAgIFNZTV9GVU5DX0VORF9BTElBUyhfX21lbXNldCkKKwor ICBJbiB0aGlzIGV4YW1wbGUsIG9uZSBjYW4gY2FsbCBgYF9fbWVtc2V0YGAgb3IgYGBtZW1zZXRg YCB3aXRoIHRoZSBzYW1lCisgIHJlc3VsdCwgZXhjZXB0IHRoZSBkZWJ1ZyBpbmZvcm1hdGlvbiBm b3IgdGhlIGluc3RydWN0aW9ucyBpcyBnZW5lcmF0ZWQgdG8KKyAgdGhlIG9iamVjdCBmaWxlIG9u bHkgb25jZSAtLSBmb3IgdGhlIG5vbi1gYEFMSUFTYGAgY2FzZS4KKworKiBgYFNZTV9DT0RFX1NU QVJUYGAgYW5kIGBgU1lNX0NPREVfU1RBUlRfTE9DQUxgYCBzaG91bGQgYmUgdXNlZCBvbmx5IGlu CisgIHNwZWNpYWwgY2FzZXMgLS0gaWYgeW91IGtub3cgd2hhdCB5b3UgYXJlIGRvaW5nLiBUaGlz IGlzIHVzZWQgZXhjbHVzaXZlbHkKKyAgZm9yIGludGVycnVwdCBoYW5kbGVycyBhbmQgc2ltaWxh ciB3aGVyZSB0aGUgY2FsbGluZyBjb252ZW50aW9uIGlzIG5vdCB0aGUgQworICBvbmUuIGBgX05P QUxJR05gYCB2YXJpYW50cyBleGlzdCB0b28uIFRoZSB1c2UgaXMgdGhlIHNhbWUgYXMgZm9yIHRo ZSBgYEZVTkNgYAorICBjYXRlZ29yeSBhYm92ZTo6CisKKyAgICBTWU1fQ09ERV9TVEFSVF9MT0NB TChiYWRfcHV0X3VzZXIpCisgICAgICAgIC4uLiBhc20gaW5zbnMgLi4uCisgICAgU1lNX0NPREVf RU5EKGJhZF9wdXRfdXNlcikKKworICBBZ2FpbiwgZXZlcnkgYGBTWU1fQ09ERV9TVEFSVCpgYCAq KnNoYWxsKiogYmUgY291cGxlZCBieSBgYFNZTV9DT0RFX0VORGBgLgorCisgIFRvIHNvbWUgZXh0 ZW50LCB0aGlzIGNhdGVnb3J5IGNvcnJlc3BvbmRzIHRvIGRlcHJlY2F0ZWQgYGBFTlRSWWBgIGFu ZAorICBgYEVORGBgLiBFeGNlcHQgYGBFTkRgYCBoYWQgc2V2ZXJhbCBvdGhlciBtZWFuaW5ncyB0 b28uCisKKyogYGBTWU1fSU5ORVJfTEFCRUwqYGAgaXMgdXNlZCB0byBkZW5vdGUgYSBsYWJlbCBp bnNpZGUgc29tZQorICBgYFNZTV97Q09ERSxGVU5DfV9TVEFSVGBgIGFuZCBgYFNZTV97Q09ERSxG VU5DfV9FTkRgYC4gIFRoZXkgYXJlIHZlcnkgc2ltaWxhcgorICB0byBDIGxhYmVscywgZXhjZXB0 IHRoZXkgY2FuIGJlIG1hZGUgZ2xvYmFsLiBBbiBleGFtcGxlIG9mIHVzZTo6CisKKyAgICBTWU1f Q09ERV9TVEFSVChmdHJhY2VfY2FsbGVyKQorICAgICAgICAvKiBzYXZlX21jb3VudF9yZWdzIGZp bGxzIGluIGZpcnN0IHR3byBwYXJhbWV0ZXJzICovCisgICAgICAgIC4uLgorCisgICAgU1lNX0lO TkVSX0xBQkVMKGZ0cmFjZV9jYWxsZXJfb3BfcHRyLCBTWU1fTF9HTE9CQUwpCisgICAgICAgIC8q IExvYWQgdGhlIGZ0cmFjZV9vcHMgaW50byB0aGUgM3JkIHBhcmFtZXRlciAqLworICAgICAgICAu Li4KKworICAgIFNZTV9JTk5FUl9MQUJFTChmdHJhY2VfY2FsbCwgU1lNX0xfR0xPQkFMKQorICAg ICAgICBjYWxsIGZ0cmFjZV9zdHViCisgICAgICAgIC4uLgorICAgICAgICByZXRxCisgICAgU1lN X0NPREVfRU5EKGZ0cmFjZV9jYWxsZXIpCisKK0RhdGEgTWFjcm9zCit+fn5+fn5+fn5+fgorU2lt aWxhciB0byBpbnN0cnVjdGlvbnMsIHRoZXJlIGlzIGEgY291cGxlIG9mIG1hY3JvcyB0byBkZXNj cmliZSBkYXRhIGluIHRoZQorYXNzZW1ibHkuCisKKyogYGBTWU1fREFUQV9TVEFSVGBgIGFuZCBg YFNZTV9EQVRBX1NUQVJUX0xPQ0FMYGAgbWFyayB0aGUgc3RhcnQgb2Ygc29tZSBkYXRhCisgIGFu ZCBzaGFsbCBiZSB1c2VkIGluIGNvbmp1bmN0aW9uIHdpdGggZWl0aGVyIGBgU1lNX0RBVEFfRU5E YGAsIG9yCisgIGBgU1lNX0RBVEFfRU5EX0xBQkVMYGAuIFRoZSBsYXR0ZXIgYWRkcyBhbHNvIGEg bGFiZWwgdG8gdGhlIGVuZCwgc28gdGhhdAorICBwZW9wbGUgY2FuIHVzZSBgYGxzdGFja2BgIGFu ZCAobG9jYWwpIGBgbHN0YWNrX2VuZGBgIGluIHRoZSBmb2xsb3dpbmcKKyAgZXhhbXBsZTo6CisK KyAgICBTWU1fREFUQV9TVEFSVF9MT0NBTChsc3RhY2spCisgICAgICAgIC5za2lwIDQwOTYKKyAg ICBTWU1fREFUQV9FTkRfTEFCRUwobHN0YWNrLCBTWU1fTF9MT0NBTCwgbHN0YWNrX2VuZCkKKwor KiBgYFNZTV9EQVRBYGAgYW5kIGBgU1lNX0RBVEFfTE9DQUxgYCBhcmUgdmFyaWFudHMgZm9yIHNp bXBsZSwgbW9zdGx5IG9uZS1saW5lCisgIGRhdGE6OgorCisgICAgU1lNX0RBVEEoSEVBUCwgICAg IC5sb25nIHJtX2hlYXApCisgICAgU1lNX0RBVEEoaGVhcF9lbmQsIC5sb25nIHJtX3N0YWNrKQor CisgIEluIHRoZSBlbmQsIHRoZXkgZXhwYW5kIHRvIGBgU1lNX0RBVEFfU1RBUlRgYCB3aXRoIGBg U1lNX0RBVEFfRU5EYGAKKyAgaW50ZXJuYWxseS4KKworU3VwcG9ydCBNYWNyb3MKK35+fn5+fn5+ fn5+fn5+CitBbGwgdGhlIGFib3ZlIHJlZHVjZSB0aGVtc2VsdmVzIHRvIHNvbWUgaW52b2NhdGlv biBvZiBgYFNZTV9TVEFSVGBgLAorYGBTWU1fRU5EYGAsIG9yIGBgU1lNX0VOVFJZYGAgYXQgbGFz dC4gTm9ybWFsbHksIGRldmVsb3BlcnMgc2hvdWxkIGF2b2lkIHVzaW5nCit0aGVzZS4KKworRnVy dGhlciwgaW4gdGhlIGFib3ZlIGV4YW1wbGVzLCBvbmUgY291bGQgc2VlIGBgU1lNX0xfTE9DQUxg YC4gVGhlcmUgYXJlIGFsc28KK2BgU1lNX0xfR0xPQkFMYGAgYW5kIGBgU1lNX0xfV0VBS2BgLiBB bGwgYXJlIGludGVuZGVkIHRvIGRlbm90ZSBsaW5rYWdlIG9mIGEKK3N5bWJvbCBtYXJrZWQgYnkg dGhlbS4gVGhleSBhcmUgdXNlZCBlaXRoZXIgaW4gYGBfTEFCRUxgYCB2YXJpYW50cyBvZiB0aGUK K2VhcmxpZXIgbWFjcm9zLCBvciBpbiBgYFNZTV9TVEFSVGBgLgorCisKK092ZXJyaWRpbmcgTWFj cm9zCit+fn5+fn5+fn5+fn5+fn5+fgorQXJjaGl0ZWN0dXJlIGNhbiBhbHNvIG92ZXJyaWRlIGFu eSBvZiB0aGUgbWFjcm9zIGluIHRoZWlyIG93bgorYGBhc20vbGlua2FnZS5oYGAsIGluY2x1ZGlu ZyBtYWNyb3Mgc3BlY2lmeWluZyB0aGUgdHlwZSBvZiBhIHN5bWJvbAorKGBgU1lNX1RfRlVOQ2Bg LCBgYFNZTV9UX09CSkVDVGBgLCBhbmQgYGBTWU1fVF9OT05FYGApLiAgQXMgZXZlcnkgbWFjcm8K K2Rlc2NyaWJlZCBpbiB0aGlzIGZpbGUgaXMgc3Vycm91bmRlZCBieSBgYCNpZmRlZmBgICsgYGAj ZW5kaWZgYCwgaXQgaXMgZW5vdWdoCit0byBkZWZpbmUgdGhlIG1hY3JvcyBkaWZmZXJlbnRseSBp biB0aGUgYWZvcmVtZW50aW9uZWQgYXJjaGl0ZWN0dXJlLWRlcGVuZGVudAoraGVhZGVyLgpkaWZm IC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9pbmRleC5yc3QgYi9Eb2N1bWVudGF0aW9uL2luZGV4LnJz dAppbmRleCBiODQzZTMxLi4yY2VhYjE5IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2luZGV4 LnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL2luZGV4LnJzdApAQCAtMTM1LDYgKzEzNSwxNCBAQCBu ZWVkZWQpLgogICAgbWljL2luZGV4CiAgICBzY2hlZHVsZXIvaW5kZXgKIAorQXJjaGl0ZWN0dXJl LWFnbm9zdGljIGRvY3VtZW50YXRpb24KKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tCisKKy4uIHRvY3RyZWU6OgorICAgOm1heGRlcHRoOiAyCisKKyAgIGFzbS1hbm5vdGF0aW9u cworCiBBcmNoaXRlY3R1cmUtc3BlY2lmaWMgZG9jdW1lbnRhdGlvbgogLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9hc20v bGlua2FnZS5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vbGlua2FnZS5oCmluZGV4IDE0Y2FhOWQu LmUwNzE4OGUgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2xpbmthZ2UuaAorKysg Yi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9saW5rYWdlLmgKQEAgLTEzLDkgKzEzLDEzIEBACiAKICNp ZmRlZiBfX0FTU0VNQkxZX18KIAotI2RlZmluZSBHTE9CQUwobmFtZSkJXAotCS5nbG9ibCBuYW1l OwlcCi0JbmFtZToKKy8qCisgKiBHTE9CQUwgaXMgREVQUkVDQVRFRAorICoKKyAqIHVzZSBTWU1f REFUQV9TVEFSVCwgU1lNX0ZVTkNfU1RBUlQsIFNZTV9JTk5FUl9MQUJFTCwgU1lNX0NPREVfU1RB UlQsIG9yCisgKiBzaW1pbGFyCisgKi8KKyNkZWZpbmUgR0xPQkFMKG5hbWUpCVNZTV9FTlRSWShu YW1lLCBTWU1fTF9HTE9CQUwsIFNZTV9BX05PTkUpCiAKICNpZiBkZWZpbmVkKENPTkZJR19YODZf NjQpIHx8IGRlZmluZWQoQ09ORklHX1g4Nl9BTElHTk1FTlRfMTYpCiAjZGVmaW5lIF9fQUxJR04J CS5wMmFsaWduIDQsIDB4OTAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbGlua2FnZS5oIGIv aW5jbHVkZS9saW51eC9saW5rYWdlLmgKaW5kZXggN2UwMjA3OC4uZjNhZThmMyAxMDA2NDQKLS0t IGEvaW5jbHVkZS9saW51eC9saW5rYWdlLmgKKysrIGIvaW5jbHVkZS9saW51eC9saW5rYWdlLmgK QEAgLTc1LDMyICs3NSw1OCBAQAogCiAjaWZkZWYgX19BU1NFTUJMWV9fCiAKKy8qIFNZTV9UX0ZV TkMgLS0gdHlwZSB1c2VkIGJ5IGFzc2VtYmxlciB0byBtYXJrIGZ1bmN0aW9ucyAqLworI2lmbmRl ZiBTWU1fVF9GVU5DCisjZGVmaW5lIFNZTV9UX0ZVTkMJCQkJU1RUX0ZVTkMKKyNlbmRpZgorCisv KiBTWU1fVF9PQkpFQ1QgLS0gdHlwZSB1c2VkIGJ5IGFzc2VtYmxlciB0byBtYXJrIGRhdGEgKi8K KyNpZm5kZWYgU1lNX1RfT0JKRUNUCisjZGVmaW5lIFNZTV9UX09CSkVDVAkJCQlTVFRfT0JKRUNU CisjZW5kaWYKKworLyogU1lNX1RfTk9ORSAtLSB0eXBlIHVzZWQgYnkgYXNzZW1ibGVyIHRvIG1h cmsgZW50cmllcyBvZiB1bmtub3duIHR5cGUgKi8KKyNpZm5kZWYgU1lNX1RfTk9ORQorI2RlZmlu ZSBTWU1fVF9OT05FCQkJCVNUVF9OT1RZUEUKKyNlbmRpZgorCisvKiBTWU1fQV8qIC0tIGFsaWdu IHRoZSBzeW1ib2w/ICovCisjZGVmaW5lIFNZTV9BX0FMSUdOCQkJCUFMSUdOCisjZGVmaW5lIFNZ TV9BX05PTkUJCQkJLyogbm90aGluZyAqLworCisvKiBTWU1fTF8qIC0tIGxpbmthZ2Ugb2Ygc3lt Ym9scyAqLworI2RlZmluZSBTWU1fTF9HTE9CQUwobmFtZSkJCQkuZ2xvYmwgbmFtZQorI2RlZmlu ZSBTWU1fTF9XRUFLKG5hbWUpCQkJLndlYWsgbmFtZQorI2RlZmluZSBTWU1fTF9MT0NBTChuYW1l KQkJCS8qIG5vdGhpbmcgKi8KKwogI2lmbmRlZiBMSU5LRVJfU0NSSVBUCiAjZGVmaW5lIEFMSUdO IF9fQUxJR04KICNkZWZpbmUgQUxJR05fU1RSIF9fQUxJR05fU1RSCiAKKy8qID09PSBERVBSRUNB VEVEIGFubm90YXRpb25zID09PSAqLworCiAjaWZuZGVmIEdMT0JBTAorLyogZGVwcmVjYXRlZCwg dXNlIFNZTV9EQVRBKiwgU1lNX0VOVFJZLCBvciBzaW1pbGFyICovCiAjZGVmaW5lIEdMT0JBTChu YW1lKSBcCiAJLmdsb2JsIG5hbWUgQVNNX05MIFwKIAluYW1lOgogI2VuZGlmCiAKICNpZm5kZWYg RU5UUlkKKy8qIGRlcHJlY2F0ZWQsIHVzZSBTWU1fRlVOQ19TVEFSVCAqLwogI2RlZmluZSBFTlRS WShuYW1lKSBcCi0JLmdsb2JsIG5hbWUgQVNNX05MIFwKLQlBTElHTiBBU01fTkwgXAotCW5hbWU6 CisJU1lNX0ZVTkNfU1RBUlQobmFtZSkKICNlbmRpZgogI2VuZGlmIC8qIExJTktFUl9TQ1JJUFQg Ki8KIAogI2lmbmRlZiBXRUFLCisvKiBkZXByZWNhdGVkLCB1c2UgU1lNX0ZVTkNfU1RBUlRfV0VB SyogKi8KICNkZWZpbmUgV0VBSyhuYW1lKQkgICBcCi0JLndlYWsgbmFtZSBBU01fTkwgICBcCi0J QUxJR04gQVNNX05MIFwKLQluYW1lOgorCVNZTV9GVU5DX1NUQVJUX1dFQUsobmFtZSkKICNlbmRp ZgogCiAjaWZuZGVmIEVORAorLyogZGVwcmVjYXRlZCwgdXNlIFNZTV9GVU5DX0VORCwgU1lNX0RB VEFfRU5ELCBvciBTWU1fRU5EICovCiAjZGVmaW5lIEVORChuYW1lKSBcCiAJLnNpemUgbmFtZSwg Li1uYW1lCiAjZW5kaWYKQEAgLTExMCwxMSArMTM2LDIxNCBAQAogICogc3RhdGljIGFuYWx5c2lz IHRvb2xzIHN1Y2ggYXMgc3RhY2sgZGVwdGggYW5hbHl6ZXIuCiAgKi8KICNpZm5kZWYgRU5EUFJP QworLyogZGVwcmVjYXRlZCwgdXNlIFNZTV9GVU5DX0VORCAqLwogI2RlZmluZSBFTkRQUk9DKG5h bWUpIFwKLQkudHlwZSBuYW1lLCBAZnVuY3Rpb24gQVNNX05MIFwKLQlFTkQobmFtZSkKKwlTWU1f RlVOQ19FTkQobmFtZSkKKyNlbmRpZgorCisvKiA9PT0gZ2VuZXJpYyBhbm5vdGF0aW9ucyA9PT0g Ki8KKworLyogU1lNX0VOVFJZIC0tIHVzZSBvbmx5IGlmIHlvdSBoYXZlIHRvIGZvciBub24tcGFp cmVkIHN5bWJvbHMgKi8KKyNpZm5kZWYgU1lNX0VOVFJZCisjZGVmaW5lIFNZTV9FTlRSWShuYW1l LCBsaW5rYWdlLCBhbGlnbi4uLikJCVwKKwlsaW5rYWdlKG5hbWUpIEFTTV9OTAkJCQlcCisJYWxp Z24gQVNNX05MCQkJCQlcCisJbmFtZToKKyNlbmRpZgorCisvKiBTWU1fU1RBUlQgLS0gdXNlIG9u bHkgaWYgeW91IGhhdmUgdG8gKi8KKyNpZm5kZWYgU1lNX1NUQVJUCisjZGVmaW5lIFNZTV9TVEFS VChuYW1lLCBsaW5rYWdlLCBhbGlnbi4uLikJCVwKKwlTWU1fRU5UUlkobmFtZSwgbGlua2FnZSwg YWxpZ24pCisjZW5kaWYKKworLyogU1lNX0VORCAtLSB1c2Ugb25seSBpZiB5b3UgaGF2ZSB0byAq LworI2lmbmRlZiBTWU1fRU5ECisjZGVmaW5lIFNZTV9FTkQobmFtZSwgc3ltX3R5cGUpCQkJCVwK KwkudHlwZSBuYW1lIHN5bV90eXBlIEFTTV9OTAkJCVwKKwkuc2l6ZSBuYW1lLCAuLW5hbWUKKyNl bmRpZgorCisvKiA9PT0gY29kZSBhbm5vdGF0aW9ucyA9PT0gKi8KKworLyoKKyAqIEZVTkMgLS0g Qy1saWtlIGZ1bmN0aW9ucyAocHJvcGVyIHN0YWNrIGZyYW1lIGV0Yy4pCisgKiBDT0RFIC0tIG5v bi1DIGNvZGUgKGUuZy4gaXJxIGhhbmRsZXJzIHdpdGggZGlmZmVyZW50LCBzcGVjaWFsIHN0YWNr IGV0Yy4pCisgKgorICogT2JqdG9vbCB2YWxpZGF0ZXMgc3RhY2sgZm9yIEZVTkMsIGJ1dCBub3Qg Zm9yIENPREUuCisgKiBPYmp0b29sIGdlbmVyYXRlcyBkZWJ1ZyBpbmZvIGZvciBib3RoIEZVTkMg JiBDT0RFLCBidXQgbmVlZHMgc3BlY2lhbAorICogYW5ub3RhdGlvbnMgZm9yIGVhY2ggQ09ERSdz IHN0YXJ0ICh0byBkZXNjcmliZSB0aGUgYWN0dWFsIHN0YWNrIGZyYW1lKS4KKyAqCisgKiBBTElB UyAtLSBkb2VzIG5vdCBnZW5lcmF0ZSBkZWJ1ZyBpbmZvIC0tIHRoZSBhbGlhc2VkIGZ1bmN0aW9u IHdpbGwKKyAqLworCisvKiBTWU1fSU5ORVJfTEFCRUxfQUxJR04gLS0gb25seSBmb3IgbGFiZWxz IGluIHRoZSBtaWRkbGUgb2YgY29kZSAqLworI2lmbmRlZiBTWU1fSU5ORVJfTEFCRUxfQUxJR04K KyNkZWZpbmUgU1lNX0lOTkVSX0xBQkVMX0FMSUdOKG5hbWUsIGxpbmthZ2UpCVwKKwkudHlwZSBu YW1lIFNZTV9UX05PTkUgQVNNX05MCQkJXAorCVNZTV9FTlRSWShuYW1lLCBsaW5rYWdlLCBTWU1f QV9BTElHTikKKyNlbmRpZgorCisvKiBTWU1fSU5ORVJfTEFCRUwgLS0gb25seSBmb3IgbGFiZWxz IGluIHRoZSBtaWRkbGUgb2YgY29kZSAqLworI2lmbmRlZiBTWU1fSU5ORVJfTEFCRUwKKyNkZWZp bmUgU1lNX0lOTkVSX0xBQkVMKG5hbWUsIGxpbmthZ2UpCQlcCisJLnR5cGUgbmFtZSBTWU1fVF9O T05FIEFTTV9OTAkJCVwKKwlTWU1fRU5UUlkobmFtZSwgbGlua2FnZSwgU1lNX0FfTk9ORSkKKyNl bmRpZgorCisvKgorICogU1lNX0ZVTkNfU1RBUlRfTE9DQUxfQUxJQVMgLS0gdXNlIHdoZXJlIHRo ZXJlIGFyZSB0d28gbG9jYWwgbmFtZXMgZm9yIG9uZQorICogZnVuY3Rpb24KKyAqLworI2lmbmRl ZiBTWU1fRlVOQ19TVEFSVF9MT0NBTF9BTElBUworI2RlZmluZSBTWU1fRlVOQ19TVEFSVF9MT0NB TF9BTElBUyhuYW1lKQkJXAorCVNZTV9TVEFSVChuYW1lLCBTWU1fTF9MT0NBTCwgU1lNX0FfQUxJ R04pCisjZW5kaWYKKworLyoKKyAqIFNZTV9GVU5DX1NUQVJUX0FMSUFTIC0tIHVzZSB3aGVyZSB0 aGVyZSBhcmUgdHdvIGdsb2JhbCBuYW1lcyBmb3Igb25lCisgKiBmdW5jdGlvbgorICovCisjaWZu ZGVmIFNZTV9GVU5DX1NUQVJUX0FMSUFTCisjZGVmaW5lIFNZTV9GVU5DX1NUQVJUX0FMSUFTKG5h bWUpCQkJXAorCVNZTV9TVEFSVChuYW1lLCBTWU1fTF9HTE9CQUwsIFNZTV9BX0FMSUdOKQorI2Vu ZGlmCisKKy8qIFNZTV9GVU5DX1NUQVJUIC0tIHVzZSBmb3IgZ2xvYmFsIGZ1bmN0aW9ucyAqLwor I2lmbmRlZiBTWU1fRlVOQ19TVEFSVAorLyoKKyAqIFRoZSBzYW1lIGFzIFNZTV9GVU5DX1NUQVJU X0FMSUFTLCBidXQgd2Ugd2lsbCBuZWVkIHRvIGRpc3Rpbmd1aXNoIHRoZXNlIHR3bworICogbGF0 ZXIuCisgKi8KKyNkZWZpbmUgU1lNX0ZVTkNfU1RBUlQobmFtZSkJCQkJXAorCVNZTV9TVEFSVChu YW1lLCBTWU1fTF9HTE9CQUwsIFNZTV9BX0FMSUdOKQorI2VuZGlmCisKKy8qIFNZTV9GVU5DX1NU QVJUX05PQUxJR04gLS0gdXNlIGZvciBnbG9iYWwgZnVuY3Rpb25zLCB3L28gYWxpZ25tZW50ICov CisjaWZuZGVmIFNZTV9GVU5DX1NUQVJUX05PQUxJR04KKyNkZWZpbmUgU1lNX0ZVTkNfU1RBUlRf Tk9BTElHTihuYW1lKQkJCVwKKwlTWU1fU1RBUlQobmFtZSwgU1lNX0xfR0xPQkFMLCBTWU1fQV9O T05FKQorI2VuZGlmCisKKy8qIFNZTV9GVU5DX1NUQVJUX0xPQ0FMIC0tIHVzZSBmb3IgbG9jYWwg ZnVuY3Rpb25zICovCisjaWZuZGVmIFNZTV9GVU5DX1NUQVJUX0xPQ0FMCisvKiB0aGUgc2FtZSBh cyBTWU1fRlVOQ19TVEFSVF9MT0NBTF9BTElBUywgc2VlIGNvbW1lbnQgbmVhciBTWU1fRlVOQ19T VEFSVCAqLworI2RlZmluZSBTWU1fRlVOQ19TVEFSVF9MT0NBTChuYW1lKQkJCVwKKwlTWU1fU1RB UlQobmFtZSwgU1lNX0xfTE9DQUwsIFNZTV9BX0FMSUdOKQogI2VuZGlmCiAKKy8qIFNZTV9GVU5D X1NUQVJUX0xPQ0FMX05PQUxJR04gLS0gdXNlIGZvciBsb2NhbCBmdW5jdGlvbnMsIHcvbyBhbGln bm1lbnQgKi8KKyNpZm5kZWYgU1lNX0ZVTkNfU1RBUlRfTE9DQUxfTk9BTElHTgorI2RlZmluZSBT WU1fRlVOQ19TVEFSVF9MT0NBTF9OT0FMSUdOKG5hbWUpCQlcCisJU1lNX1NUQVJUKG5hbWUsIFNZ TV9MX0xPQ0FMLCBTWU1fQV9OT05FKQogI2VuZGlmCiAKKy8qIFNZTV9GVU5DX1NUQVJUX1dFQUsg LS0gdXNlIGZvciB3ZWFrIGZ1bmN0aW9ucyAqLworI2lmbmRlZiBTWU1fRlVOQ19TVEFSVF9XRUFL CisjZGVmaW5lIFNZTV9GVU5DX1NUQVJUX1dFQUsobmFtZSkJCQlcCisJU1lNX1NUQVJUKG5hbWUs IFNZTV9MX1dFQUssIFNZTV9BX0FMSUdOKQogI2VuZGlmCisKKy8qIFNZTV9GVU5DX1NUQVJUX1dF QUtfTk9BTElHTiAtLSB1c2UgZm9yIHdlYWsgZnVuY3Rpb25zLCB3L28gYWxpZ25tZW50ICovCisj aWZuZGVmIFNZTV9GVU5DX1NUQVJUX1dFQUtfTk9BTElHTgorI2RlZmluZSBTWU1fRlVOQ19TVEFS VF9XRUFLX05PQUxJR04obmFtZSkJCVwKKwlTWU1fU1RBUlQobmFtZSwgU1lNX0xfV0VBSywgU1lN X0FfTk9ORSkKKyNlbmRpZgorCisvKiBTWU1fRlVOQ19FTkRfQUxJQVMgLS0gdGhlIGVuZCBvZiBM T0NBTF9BTElBU2VkIG9yIEFMSUFTZWQgZnVuY3Rpb24gKi8KKyNpZm5kZWYgU1lNX0ZVTkNfRU5E X0FMSUFTCisjZGVmaW5lIFNZTV9GVU5DX0VORF9BTElBUyhuYW1lKQkJCVwKKwlTWU1fRU5EKG5h bWUsIFNZTV9UX0ZVTkMpCisjZW5kaWYKKworLyoKKyAqIFNZTV9GVU5DX0VORCAtLSB0aGUgZW5k IG9mIFNZTV9GVU5DX1NUQVJUX0xPQ0FMLCBTWU1fRlVOQ19TVEFSVCwKKyAqIFNZTV9GVU5DX1NU QVJUX1dFQUssIC4uLgorICovCisjaWZuZGVmIFNZTV9GVU5DX0VORAorLyogdGhlIHNhbWUgYXMg U1lNX0ZVTkNfRU5EX0FMSUFTLCBzZWUgY29tbWVudCBuZWFyIFNZTV9GVU5DX1NUQVJUICovCisj ZGVmaW5lIFNZTV9GVU5DX0VORChuYW1lKQkJCQlcCisJU1lNX0VORChuYW1lLCBTWU1fVF9GVU5D KQorI2VuZGlmCisKKy8qIFNZTV9DT0RFX1NUQVJUIC0tIHVzZSBmb3Igbm9uLUMgKHNwZWNpYWwp IGZ1bmN0aW9ucyAqLworI2lmbmRlZiBTWU1fQ09ERV9TVEFSVAorI2RlZmluZSBTWU1fQ09ERV9T VEFSVChuYW1lKQkJCQlcCisJU1lNX1NUQVJUKG5hbWUsIFNZTV9MX0dMT0JBTCwgU1lNX0FfQUxJ R04pCisjZW5kaWYKKworLyogU1lNX0NPREVfU1RBUlRfTk9BTElHTiAtLSB1c2UgZm9yIG5vbi1D IChzcGVjaWFsKSBmdW5jdGlvbnMsIHcvbyBhbGlnbm1lbnQgKi8KKyNpZm5kZWYgU1lNX0NPREVf U1RBUlRfTk9BTElHTgorI2RlZmluZSBTWU1fQ09ERV9TVEFSVF9OT0FMSUdOKG5hbWUpCQkJXAor CVNZTV9TVEFSVChuYW1lLCBTWU1fTF9HTE9CQUwsIFNZTV9BX05PTkUpCisjZW5kaWYKKworLyog U1lNX0NPREVfU1RBUlRfTE9DQUwgLS0gdXNlIGZvciBsb2NhbCBub24tQyAoc3BlY2lhbCkgZnVu Y3Rpb25zICovCisjaWZuZGVmIFNZTV9DT0RFX1NUQVJUX0xPQ0FMCisjZGVmaW5lIFNZTV9DT0RF X1NUQVJUX0xPQ0FMKG5hbWUpCQkJXAorCVNZTV9TVEFSVChuYW1lLCBTWU1fTF9MT0NBTCwgU1lN X0FfQUxJR04pCisjZW5kaWYKKworLyoKKyAqIFNZTV9DT0RFX1NUQVJUX0xPQ0FMX05PQUxJR04g LS0gdXNlIGZvciBsb2NhbCBub24tQyAoc3BlY2lhbCkgZnVuY3Rpb25zLAorICogdy9vIGFsaWdu bWVudAorICovCisjaWZuZGVmIFNZTV9DT0RFX1NUQVJUX0xPQ0FMX05PQUxJR04KKyNkZWZpbmUg U1lNX0NPREVfU1RBUlRfTE9DQUxfTk9BTElHTihuYW1lKQkJXAorCVNZTV9TVEFSVChuYW1lLCBT WU1fTF9MT0NBTCwgU1lNX0FfTk9ORSkKKyNlbmRpZgorCisvKiBTWU1fQ09ERV9FTkQgLS0gdGhl IGVuZCBvZiBTWU1fQ09ERV9TVEFSVF9MT0NBTCwgU1lNX0NPREVfU1RBUlQsIC4uLiAqLworI2lm bmRlZiBTWU1fQ09ERV9FTkQKKyNkZWZpbmUgU1lNX0NPREVfRU5EKG5hbWUpCQkJCVwKKwlTWU1f RU5EKG5hbWUsIFNZTV9UX05PTkUpCisjZW5kaWYKKworLyogPT09IGRhdGEgYW5ub3RhdGlvbnMg PT09ICovCisKKy8qIFNZTV9EQVRBX1NUQVJUIC0tIGdsb2JhbCBkYXRhIHN5bWJvbCAqLworI2lm bmRlZiBTWU1fREFUQV9TVEFSVAorI2RlZmluZSBTWU1fREFUQV9TVEFSVChuYW1lKQkJCQlcCisJ U1lNX1NUQVJUKG5hbWUsIFNZTV9MX0dMT0JBTCwgU1lNX0FfTk9ORSkKKyNlbmRpZgorCisvKiBT WU1fREFUQV9TVEFSVCAtLSBsb2NhbCBkYXRhIHN5bWJvbCAqLworI2lmbmRlZiBTWU1fREFUQV9T VEFSVF9MT0NBTAorI2RlZmluZSBTWU1fREFUQV9TVEFSVF9MT0NBTChuYW1lKQkJCVwKKwlTWU1f U1RBUlQobmFtZSwgU1lNX0xfTE9DQUwsIFNZTV9BX05PTkUpCisjZW5kaWYKKworLyogU1lNX0RB VEFfRU5EIC0tIHRoZSBlbmQgb2YgU1lNX0RBVEFfU1RBUlQgc3ltYm9sICovCisjaWZuZGVmIFNZ TV9EQVRBX0VORAorI2RlZmluZSBTWU1fREFUQV9FTkQobmFtZSkJCQkJXAorCVNZTV9FTkQobmFt ZSwgU1lNX1RfT0JKRUNUKQorI2VuZGlmCisKKy8qIFNZTV9EQVRBX0VORF9MQUJFTCAtLSB0aGUg bGFiZWxlZCBlbmQgb2YgU1lNX0RBVEFfU1RBUlQgc3ltYm9sICovCisjaWZuZGVmIFNZTV9EQVRB X0VORF9MQUJFTAorI2RlZmluZSBTWU1fREFUQV9FTkRfTEFCRUwobmFtZSwgbGlua2FnZSwgbGFi ZWwpCVwKKwlsaW5rYWdlKGxhYmVsKSBBU01fTkwJCQkJXAorCS50eXBlIGxhYmVsIFNZTV9UX09C SkVDVCBBU01fTkwJCQlcCisJbGFiZWw6CQkJCQkJXAorCVNZTV9FTkQobmFtZSwgU1lNX1RfT0JK RUNUKQorI2VuZGlmCisKKy8qIFNZTV9EQVRBIC0tIHN0YXJ0K2VuZCB3cmFwcGVyIGFyb3VuZCBz aW1wbGUgZ2xvYmFsIGRhdGEgKi8KKyNpZm5kZWYgU1lNX0RBVEEKKyNkZWZpbmUgU1lNX0RBVEEo bmFtZSwgZGF0YS4uLikJCQkJXAorCVNZTV9EQVRBX1NUQVJUKG5hbWUpIEFTTV9OTAkJCQlcCisJ ZGF0YSBBU01fTkwJCQkJCQlcCisJU1lNX0RBVEFfRU5EKG5hbWUpCisjZW5kaWYKKworLyogU1lN X0RBVEFfTE9DQUwgLS0gc3RhcnQrZW5kIHdyYXBwZXIgYXJvdW5kIHNpbXBsZSBsb2NhbCBkYXRh ICovCisjaWZuZGVmIFNZTV9EQVRBX0xPQ0FMCisjZGVmaW5lIFNZTV9EQVRBX0xPQ0FMKG5hbWUs IGRhdGEuLi4pCQkJXAorCVNZTV9EQVRBX1NUQVJUX0xPQ0FMKG5hbWUpIEFTTV9OTAkJCVwKKwlk YXRhIEFTTV9OTAkJCQkJCVwKKwlTWU1fREFUQV9FTkQobmFtZSkKKyNlbmRpZgorCisjZW5kaWYg LyogX19BU1NFTUJMWV9fICovCisKKyNlbmRpZiAvKiBfTElOVVhfTElOS0FHRV9IICovCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFp bGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xpc3RzLnhl bnByb2plY3Qub3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs