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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 176ABC44500 for ; Wed, 21 Jan 2026 08:29:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Content-Transfer-Encoding: Content-Type:In-Reply-To:From:References:To:Subject:MIME-Version:Date: Message-ID:Reply-To:Cc:Content-ID:Content-Description:Resent-Date:Resent-From :Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=8PJ1arTqaBa/dWpdkdp/fiB3SwDbrcvTTkbsPmUh3yA=; b=wIv5CX8aiC5umvvycPvYtcFQ4U is+FcE/qHysh+CPlsgh+N/dW6SisKsafh5CfFOHpMel4Suc7HutJerpnQGOPmOfHgJrHka7HeZqui 8XMaE2D4fHhYxdDhUkoxA35IfG6oieKuL1mtrW1qsPrlVP6K1i6iMgxLHlQ/3MZRLzH9DfzNhF+MH JjBDBG9hNBdvsV8WDSrx2zgjqLx7O957iHdukmTxdHS73vmVyOFmK7oCETyIJj8WOJYt4Az1I6fK1 OJh3rr91dK353wdJSFXFuCkB1wtomZoneNe/0Wx2i3D6AsVc84iyNlLK9JxgrLHauFy8ZAp4WKXri G7v9OFlQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1viTaE-0000000563e-3pF7; Wed, 21 Jan 2026 08:28:58 +0000 Received: from mgamail.intel.com ([198.175.65.10]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1viTaB-0000000563G-3wHS; Wed, 21 Jan 2026 08:28:57 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1768984136; x=1800520136; h=message-id:date:mime-version:subject:to:references:from: in-reply-to:content-transfer-encoding; bh=dApeybvVB3pkwlaT7r4Q5fiIBsXrDsXP3PI8sNxgi2U=; b=ECXnSl+dhb1Ma9k+tS0c8Rdy7QTcgBGmMQ9ehSX4OyggAP2TymLcKESz yFASgQb4VVtj8N6ZhCFLrRGo39mW6HsSuWGgPlUFhq7n8ClzAngCReW4j vtztApwJMfNVFQHwIwGjvDt+to+zG6prybD5eGPQoOjdQKZm7RoprPR5i izHrh6Uwe7VPeUz5IQ8/G1xgQA21exHN+fjLitKuUVhvgJDCkpjEp7Lam o/ZWE0cSae8dL6ulRDP/Pw50qPdr+w/tkxwkNYEut4zqVTRfCpUXIfNrT 6WlEsXPzl3nk+7e7Pz7JomC953ZdlCnpykuZmTropyqjvjm1CG4sgYeVd A==; X-CSE-ConnectionGUID: QbsgN8YuQkqgmObl/BlKXQ== X-CSE-MsgGUID: UBpzIrO8R1Snp9TACTfkrQ== X-IronPort-AV: E=McAfee;i="6800,10657,11677"; a="87619247" X-IronPort-AV: E=Sophos;i="6.21,242,1763452800"; d="scan'208";a="87619247" Received: from orviesa001.jf.intel.com ([10.64.159.141]) by orvoesa102.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 Jan 2026 00:28:51 -0800 X-CSE-ConnectionGUID: UvcO273KTwmUMSsp4luI+w== X-CSE-MsgGUID: AUUo9LUiTuiJxGX8Cxz6AA== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.21,242,1763452800"; d="scan'208";a="243956015" Received: from unknown (HELO [10.238.3.254]) ([10.238.3.254]) by smtpauth.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 Jan 2026 00:28:41 -0800 Message-ID: <56bb6d4d-ad9e-485f-af15-e0f6fbc261c1@linux.intel.com> Date: Wed, 21 Jan 2026 16:28:37 +0800 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v2] perf regs: Refactor use of arch__sample_reg_masks to perf_reg_name To: Ian Rogers , Peter Zijlstra , Ingo Molnar , Arnaldo Carvalho de Melo , Namhyung Kim , Jiri Olsa , Adrian Hunter , James Clark , John Garry , Will Deacon , Leo Yan , Guo Ren , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , Shimin Guo , Athira Rajeev , Stephen Brennan , Howard Chu , Thomas Falcon , Andi Kleen , "Dr. David Alan Gilbert" , Dmitry Vyukov , =?UTF-8?Q?Krzysztof_=C5=81opatowski?= , Chun-Tse Shao , Aditya Bodkhe , Haibo Xu , Sergei Trofimovich , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-csky@vger.kernel.org, linux-riscv@lists.infradead.org References: <20260121021735.3625244-1-irogers@google.com> Content-Language: en-US From: "Mi, Dapeng" In-Reply-To: <20260121021735.3625244-1-irogers@google.com> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260121_002856_075031_5F36F8D0 X-CRM114-Status: GOOD ( 22.52 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org On 1/21/2026 10:17 AM, Ian Rogers wrote: > arch__sample_reg_masks isn't supported on ARM(32), csky, loongarch, > MIPS, RISC-V and s390. The table returned by the function just has the > name of a register paired with the corresponding sample_regs_user mask > value. For a given perf register we can compute the name with > perf_reg_name and the mask is just 1 left-shifted by the perf register > number. Change __parse_regs to use this method for finding registers > rather than arch__sample_reg_masks, thereby adding __parse_regs > support for ARM(32), csky, loongarch, MIPS, RISC-V and s390. As > arch__sample_reg_masks is then unused, remove the now unneeded > declarations. > > Signed-off-by: Ian Rogers > --- > v2: Correct the setting of reg mask for registers that need >1 bit set > like XMMs. > > The idea for this patch came up in conversation with Dapeng Mi to > avoid additional functions and tables for x86 APX support: > https://lore.kernel.org/lkml/CAP-5=fWOsvAXuu8qx0tk9q8j8BoXPMJB3Gxto+iu6wf06i4cVA@mail.gmail.com/ > > The patch is on top of the dwfl clean up patches that switch perf > register functions to using e_machine as an argument rather than the > arch string, this means that EM_HOST can be used with perf_reg_name: > https://lore.kernel.org/lkml/20260117052849.2205545-1-irogers@google.com/ > --- > tools/perf/arch/arm/util/perf_regs.c | 9 -- > tools/perf/arch/arm64/util/machine.c | 14 +-- > tools/perf/arch/arm64/util/perf_regs.c | 45 +------ > tools/perf/arch/csky/util/perf_regs.c | 9 -- > tools/perf/arch/loongarch/util/perf_regs.c | 9 -- > tools/perf/arch/mips/util/perf_regs.c | 9 -- > tools/perf/arch/powerpc/util/perf_regs.c | 68 ---------- > tools/perf/arch/riscv/util/perf_regs.c | 9 -- > tools/perf/arch/s390/util/perf_regs.c | 9 -- > tools/perf/arch/x86/util/perf_regs.c | 47 ------- > .../util/arm64-frame-pointer-unwind-support.c | 3 +- > tools/perf/util/parse-regs-options.c | 116 +++++++++++------- > tools/perf/util/perf_regs.c | 9 -- > tools/perf/util/perf_regs.h | 12 -- > 14 files changed, 81 insertions(+), 287 deletions(-) > > diff --git a/tools/perf/arch/arm/util/perf_regs.c b/tools/perf/arch/arm/util/perf_regs.c > index f94a0210c7b7..03a5bc0cf64c 100644 > --- a/tools/perf/arch/arm/util/perf_regs.c > +++ b/tools/perf/arch/arm/util/perf_regs.c > @@ -2,10 +2,6 @@ > #include "perf_regs.h" > #include "../../../util/perf_regs.h" > > -static const struct sample_reg sample_reg_masks[] = { > - SMPL_REG_END > -}; > - > uint64_t arch__intr_reg_mask(void) > { > return PERF_REGS_MASK; > @@ -15,8 +11,3 @@ uint64_t arch__user_reg_mask(void) > { > return PERF_REGS_MASK; > } > - > -const struct sample_reg *arch__sample_reg_masks(void) > -{ > - return sample_reg_masks; > -} > diff --git a/tools/perf/arch/arm64/util/machine.c b/tools/perf/arch/arm64/util/machine.c > index aab1cc2bc283..80fb13c958d9 100644 > --- a/tools/perf/arch/arm64/util/machine.c > +++ b/tools/perf/arch/arm64/util/machine.c > @@ -1,18 +1,12 @@ > // SPDX-License-Identifier: GPL-2.0 > > -#include > -#include > -#include > -#include "debug.h" > -#include "symbol.h" > -#include "callchain.h" > +#include "callchain.h" // prototype of arch__add_leaf_frame_record_opts > #include "perf_regs.h" > #include "record.h" > -#include "util/perf_regs.h" > + > +#define SMPL_REG_MASK(b) (1ULL << (b)) > > void arch__add_leaf_frame_record_opts(struct record_opts *opts) > { > - const struct sample_reg *sample_reg_masks = arch__sample_reg_masks(); > - > - opts->sample_user_regs |= sample_reg_masks[PERF_REG_ARM64_LR].mask; > + opts->sample_user_regs |= SMPL_REG_MASK(PERF_REG_ARM64_LR); > } > diff --git a/tools/perf/arch/arm64/util/perf_regs.c b/tools/perf/arch/arm64/util/perf_regs.c > index 09308665e28a..9bb768e1bea1 100644 > --- a/tools/perf/arch/arm64/util/perf_regs.c > +++ b/tools/perf/arch/arm64/util/perf_regs.c > @@ -12,48 +12,12 @@ > #include "../../../util/event.h" > #include "../../../util/perf_regs.h" > > +#define SMPL_REG_MASK(b) (1ULL << (b)) > + > #ifndef HWCAP_SVE > #define HWCAP_SVE (1 << 22) > #endif > > -static const struct sample_reg sample_reg_masks[] = { > - SMPL_REG(x0, PERF_REG_ARM64_X0), > - SMPL_REG(x1, PERF_REG_ARM64_X1), > - SMPL_REG(x2, PERF_REG_ARM64_X2), > - SMPL_REG(x3, PERF_REG_ARM64_X3), > - SMPL_REG(x4, PERF_REG_ARM64_X4), > - SMPL_REG(x5, PERF_REG_ARM64_X5), > - SMPL_REG(x6, PERF_REG_ARM64_X6), > - SMPL_REG(x7, PERF_REG_ARM64_X7), > - SMPL_REG(x8, PERF_REG_ARM64_X8), > - SMPL_REG(x9, PERF_REG_ARM64_X9), > - SMPL_REG(x10, PERF_REG_ARM64_X10), > - SMPL_REG(x11, PERF_REG_ARM64_X11), > - SMPL_REG(x12, PERF_REG_ARM64_X12), > - SMPL_REG(x13, PERF_REG_ARM64_X13), > - SMPL_REG(x14, PERF_REG_ARM64_X14), > - SMPL_REG(x15, PERF_REG_ARM64_X15), > - SMPL_REG(x16, PERF_REG_ARM64_X16), > - SMPL_REG(x17, PERF_REG_ARM64_X17), > - SMPL_REG(x18, PERF_REG_ARM64_X18), > - SMPL_REG(x19, PERF_REG_ARM64_X19), > - SMPL_REG(x20, PERF_REG_ARM64_X20), > - SMPL_REG(x21, PERF_REG_ARM64_X21), > - SMPL_REG(x22, PERF_REG_ARM64_X22), > - SMPL_REG(x23, PERF_REG_ARM64_X23), > - SMPL_REG(x24, PERF_REG_ARM64_X24), > - SMPL_REG(x25, PERF_REG_ARM64_X25), > - SMPL_REG(x26, PERF_REG_ARM64_X26), > - SMPL_REG(x27, PERF_REG_ARM64_X27), > - SMPL_REG(x28, PERF_REG_ARM64_X28), > - SMPL_REG(x29, PERF_REG_ARM64_X29), > - SMPL_REG(lr, PERF_REG_ARM64_LR), > - SMPL_REG(sp, PERF_REG_ARM64_SP), > - SMPL_REG(pc, PERF_REG_ARM64_PC), > - SMPL_REG(vg, PERF_REG_ARM64_VG), > - SMPL_REG_END > -}; > - > /* %xNUM */ > #define SDT_OP_REGEX1 "^(x[1-2]?[0-9]|3[0-1])$" > > @@ -175,8 +139,3 @@ uint64_t arch__user_reg_mask(void) > } > return PERF_REGS_MASK; > } > - > -const struct sample_reg *arch__sample_reg_masks(void) > -{ > - return sample_reg_masks; > -} > diff --git a/tools/perf/arch/csky/util/perf_regs.c b/tools/perf/arch/csky/util/perf_regs.c > index 6b1665f41180..2cf7a54106e0 100644 > --- a/tools/perf/arch/csky/util/perf_regs.c > +++ b/tools/perf/arch/csky/util/perf_regs.c > @@ -2,10 +2,6 @@ > #include "perf_regs.h" > #include "../../util/perf_regs.h" > > -static const struct sample_reg sample_reg_masks[] = { > - SMPL_REG_END > -}; > - > uint64_t arch__intr_reg_mask(void) > { > return PERF_REGS_MASK; > @@ -15,8 +11,3 @@ uint64_t arch__user_reg_mask(void) > { > return PERF_REGS_MASK; > } > - > -const struct sample_reg *arch__sample_reg_masks(void) > -{ > - return sample_reg_masks; > -} > diff --git a/tools/perf/arch/loongarch/util/perf_regs.c b/tools/perf/arch/loongarch/util/perf_regs.c > index f94a0210c7b7..03a5bc0cf64c 100644 > --- a/tools/perf/arch/loongarch/util/perf_regs.c > +++ b/tools/perf/arch/loongarch/util/perf_regs.c > @@ -2,10 +2,6 @@ > #include "perf_regs.h" > #include "../../../util/perf_regs.h" > > -static const struct sample_reg sample_reg_masks[] = { > - SMPL_REG_END > -}; > - > uint64_t arch__intr_reg_mask(void) > { > return PERF_REGS_MASK; > @@ -15,8 +11,3 @@ uint64_t arch__user_reg_mask(void) > { > return PERF_REGS_MASK; > } > - > -const struct sample_reg *arch__sample_reg_masks(void) > -{ > - return sample_reg_masks; > -} > diff --git a/tools/perf/arch/mips/util/perf_regs.c b/tools/perf/arch/mips/util/perf_regs.c > index 6b1665f41180..2cf7a54106e0 100644 > --- a/tools/perf/arch/mips/util/perf_regs.c > +++ b/tools/perf/arch/mips/util/perf_regs.c > @@ -2,10 +2,6 @@ > #include "perf_regs.h" > #include "../../util/perf_regs.h" > > -static const struct sample_reg sample_reg_masks[] = { > - SMPL_REG_END > -}; > - > uint64_t arch__intr_reg_mask(void) > { > return PERF_REGS_MASK; > @@ -15,8 +11,3 @@ uint64_t arch__user_reg_mask(void) > { > return PERF_REGS_MASK; > } > - > -const struct sample_reg *arch__sample_reg_masks(void) > -{ > - return sample_reg_masks; > -} > diff --git a/tools/perf/arch/powerpc/util/perf_regs.c b/tools/perf/arch/powerpc/util/perf_regs.c > index bd36cfd420a2..779073f7e992 100644 > --- a/tools/perf/arch/powerpc/util/perf_regs.c > +++ b/tools/perf/arch/powerpc/util/perf_regs.c > @@ -18,69 +18,6 @@ > #define PVR_POWER10 0x0080 > #define PVR_POWER11 0x0082 > > -static const struct sample_reg sample_reg_masks[] = { > - SMPL_REG(r0, PERF_REG_POWERPC_R0), > - SMPL_REG(r1, PERF_REG_POWERPC_R1), > - SMPL_REG(r2, PERF_REG_POWERPC_R2), > - SMPL_REG(r3, PERF_REG_POWERPC_R3), > - SMPL_REG(r4, PERF_REG_POWERPC_R4), > - SMPL_REG(r5, PERF_REG_POWERPC_R5), > - SMPL_REG(r6, PERF_REG_POWERPC_R6), > - SMPL_REG(r7, PERF_REG_POWERPC_R7), > - SMPL_REG(r8, PERF_REG_POWERPC_R8), > - SMPL_REG(r9, PERF_REG_POWERPC_R9), > - SMPL_REG(r10, PERF_REG_POWERPC_R10), > - SMPL_REG(r11, PERF_REG_POWERPC_R11), > - SMPL_REG(r12, PERF_REG_POWERPC_R12), > - SMPL_REG(r13, PERF_REG_POWERPC_R13), > - SMPL_REG(r14, PERF_REG_POWERPC_R14), > - SMPL_REG(r15, PERF_REG_POWERPC_R15), > - SMPL_REG(r16, PERF_REG_POWERPC_R16), > - SMPL_REG(r17, PERF_REG_POWERPC_R17), > - SMPL_REG(r18, PERF_REG_POWERPC_R18), > - SMPL_REG(r19, PERF_REG_POWERPC_R19), > - SMPL_REG(r20, PERF_REG_POWERPC_R20), > - SMPL_REG(r21, PERF_REG_POWERPC_R21), > - SMPL_REG(r22, PERF_REG_POWERPC_R22), > - SMPL_REG(r23, PERF_REG_POWERPC_R23), > - SMPL_REG(r24, PERF_REG_POWERPC_R24), > - SMPL_REG(r25, PERF_REG_POWERPC_R25), > - SMPL_REG(r26, PERF_REG_POWERPC_R26), > - SMPL_REG(r27, PERF_REG_POWERPC_R27), > - SMPL_REG(r28, PERF_REG_POWERPC_R28), > - SMPL_REG(r29, PERF_REG_POWERPC_R29), > - SMPL_REG(r30, PERF_REG_POWERPC_R30), > - SMPL_REG(r31, PERF_REG_POWERPC_R31), > - SMPL_REG(nip, PERF_REG_POWERPC_NIP), > - SMPL_REG(msr, PERF_REG_POWERPC_MSR), > - SMPL_REG(orig_r3, PERF_REG_POWERPC_ORIG_R3), > - SMPL_REG(ctr, PERF_REG_POWERPC_CTR), > - SMPL_REG(link, PERF_REG_POWERPC_LINK), > - SMPL_REG(xer, PERF_REG_POWERPC_XER), > - SMPL_REG(ccr, PERF_REG_POWERPC_CCR), > - SMPL_REG(softe, PERF_REG_POWERPC_SOFTE), > - SMPL_REG(trap, PERF_REG_POWERPC_TRAP), > - SMPL_REG(dar, PERF_REG_POWERPC_DAR), > - SMPL_REG(dsisr, PERF_REG_POWERPC_DSISR), > - SMPL_REG(sier, PERF_REG_POWERPC_SIER), > - SMPL_REG(mmcra, PERF_REG_POWERPC_MMCRA), > - SMPL_REG(mmcr0, PERF_REG_POWERPC_MMCR0), > - SMPL_REG(mmcr1, PERF_REG_POWERPC_MMCR1), > - SMPL_REG(mmcr2, PERF_REG_POWERPC_MMCR2), > - SMPL_REG(mmcr3, PERF_REG_POWERPC_MMCR3), > - SMPL_REG(sier2, PERF_REG_POWERPC_SIER2), > - SMPL_REG(sier3, PERF_REG_POWERPC_SIER3), > - SMPL_REG(pmc1, PERF_REG_POWERPC_PMC1), > - SMPL_REG(pmc2, PERF_REG_POWERPC_PMC2), > - SMPL_REG(pmc3, PERF_REG_POWERPC_PMC3), > - SMPL_REG(pmc4, PERF_REG_POWERPC_PMC4), > - SMPL_REG(pmc5, PERF_REG_POWERPC_PMC5), > - SMPL_REG(pmc6, PERF_REG_POWERPC_PMC6), > - SMPL_REG(sdar, PERF_REG_POWERPC_SDAR), > - SMPL_REG(siar, PERF_REG_POWERPC_SIAR), > - SMPL_REG_END > -}; > - > /* REG or %rREG */ > #define SDT_OP_REGEX1 "^(%r)?([1-2]?[0-9]|3[0-1])$" > > @@ -233,8 +170,3 @@ uint64_t arch__user_reg_mask(void) > { > return PERF_REGS_MASK; > } > - > -const struct sample_reg *arch__sample_reg_masks(void) > -{ > - return sample_reg_masks; > -} > diff --git a/tools/perf/arch/riscv/util/perf_regs.c b/tools/perf/arch/riscv/util/perf_regs.c > index 6b1665f41180..2cf7a54106e0 100644 > --- a/tools/perf/arch/riscv/util/perf_regs.c > +++ b/tools/perf/arch/riscv/util/perf_regs.c > @@ -2,10 +2,6 @@ > #include "perf_regs.h" > #include "../../util/perf_regs.h" > > -static const struct sample_reg sample_reg_masks[] = { > - SMPL_REG_END > -}; > - > uint64_t arch__intr_reg_mask(void) > { > return PERF_REGS_MASK; > @@ -15,8 +11,3 @@ uint64_t arch__user_reg_mask(void) > { > return PERF_REGS_MASK; > } > - > -const struct sample_reg *arch__sample_reg_masks(void) > -{ > - return sample_reg_masks; > -} > diff --git a/tools/perf/arch/s390/util/perf_regs.c b/tools/perf/arch/s390/util/perf_regs.c > index 6b1665f41180..2cf7a54106e0 100644 > --- a/tools/perf/arch/s390/util/perf_regs.c > +++ b/tools/perf/arch/s390/util/perf_regs.c > @@ -2,10 +2,6 @@ > #include "perf_regs.h" > #include "../../util/perf_regs.h" > > -static const struct sample_reg sample_reg_masks[] = { > - SMPL_REG_END > -}; > - > uint64_t arch__intr_reg_mask(void) > { > return PERF_REGS_MASK; > @@ -15,8 +11,3 @@ uint64_t arch__user_reg_mask(void) > { > return PERF_REGS_MASK; > } > - > -const struct sample_reg *arch__sample_reg_masks(void) > -{ > - return sample_reg_masks; > -} > diff --git a/tools/perf/arch/x86/util/perf_regs.c b/tools/perf/arch/x86/util/perf_regs.c > index 12fd93f04802..a7ca4154fdf9 100644 > --- a/tools/perf/arch/x86/util/perf_regs.c > +++ b/tools/perf/arch/x86/util/perf_regs.c > @@ -13,48 +13,6 @@ > #include "../../../util/pmu.h" > #include "../../../util/pmus.h" > > -static const struct sample_reg sample_reg_masks[] = { > - SMPL_REG(AX, PERF_REG_X86_AX), > - SMPL_REG(BX, PERF_REG_X86_BX), > - SMPL_REG(CX, PERF_REG_X86_CX), > - SMPL_REG(DX, PERF_REG_X86_DX), > - SMPL_REG(SI, PERF_REG_X86_SI), > - SMPL_REG(DI, PERF_REG_X86_DI), > - SMPL_REG(BP, PERF_REG_X86_BP), > - SMPL_REG(SP, PERF_REG_X86_SP), > - SMPL_REG(IP, PERF_REG_X86_IP), > - SMPL_REG(FLAGS, PERF_REG_X86_FLAGS), > - SMPL_REG(CS, PERF_REG_X86_CS), > - SMPL_REG(SS, PERF_REG_X86_SS), > -#ifdef HAVE_ARCH_X86_64_SUPPORT > - SMPL_REG(R8, PERF_REG_X86_R8), > - SMPL_REG(R9, PERF_REG_X86_R9), > - SMPL_REG(R10, PERF_REG_X86_R10), > - SMPL_REG(R11, PERF_REG_X86_R11), > - SMPL_REG(R12, PERF_REG_X86_R12), > - SMPL_REG(R13, PERF_REG_X86_R13), > - SMPL_REG(R14, PERF_REG_X86_R14), > - SMPL_REG(R15, PERF_REG_X86_R15), > -#endif > - SMPL_REG2(XMM0, PERF_REG_X86_XMM0), > - SMPL_REG2(XMM1, PERF_REG_X86_XMM1), > - SMPL_REG2(XMM2, PERF_REG_X86_XMM2), > - SMPL_REG2(XMM3, PERF_REG_X86_XMM3), > - SMPL_REG2(XMM4, PERF_REG_X86_XMM4), > - SMPL_REG2(XMM5, PERF_REG_X86_XMM5), > - SMPL_REG2(XMM6, PERF_REG_X86_XMM6), > - SMPL_REG2(XMM7, PERF_REG_X86_XMM7), > - SMPL_REG2(XMM8, PERF_REG_X86_XMM8), > - SMPL_REG2(XMM9, PERF_REG_X86_XMM9), > - SMPL_REG2(XMM10, PERF_REG_X86_XMM10), > - SMPL_REG2(XMM11, PERF_REG_X86_XMM11), > - SMPL_REG2(XMM12, PERF_REG_X86_XMM12), > - SMPL_REG2(XMM13, PERF_REG_X86_XMM13), > - SMPL_REG2(XMM14, PERF_REG_X86_XMM14), > - SMPL_REG2(XMM15, PERF_REG_X86_XMM15), > - SMPL_REG_END > -}; > - > struct sdt_name_reg { > const char *sdt_name; > const char *uprobe_name; > @@ -276,11 +234,6 @@ int arch_sdt_arg_parse_op(char *old_op, char **new_op) > return SDT_ARG_VALID; > } > > -const struct sample_reg *arch__sample_reg_masks(void) > -{ > - return sample_reg_masks; > -} > - > uint64_t arch__intr_reg_mask(void) > { > struct perf_event_attr attr = { > diff --git a/tools/perf/util/arm64-frame-pointer-unwind-support.c b/tools/perf/util/arm64-frame-pointer-unwind-support.c > index 958afe8b821e..858ce2b01812 100644 > --- a/tools/perf/util/arm64-frame-pointer-unwind-support.c > +++ b/tools/perf/util/arm64-frame-pointer-unwind-support.c > @@ -2,7 +2,6 @@ > #include "arm64-frame-pointer-unwind-support.h" > #include "callchain.h" > #include "event.h" > -#include "perf_regs.h" // SMPL_REG_MASK > #include "unwind.h" > #include > > @@ -15,6 +14,8 @@ struct entries { > size_t length; > }; > > +#define SMPL_REG_MASK(b) (1ULL << (b)) > + > static bool get_leaf_frame_caller_enabled(struct perf_sample *sample) > { > struct regs_dump *regs; > diff --git a/tools/perf/util/parse-regs-options.c b/tools/perf/util/parse-regs-options.c > index cda1c620968e..c0d0ef9fd495 100644 > --- a/tools/perf/util/parse-regs-options.c > +++ b/tools/perf/util/parse-regs-options.c > @@ -5,15 +5,54 @@ > #include > #include > #include "util/debug.h" > +#include > #include > #include "util/perf_regs.h" > #include "util/parse-regs-options.h" > > +static void list_perf_regs(FILE *fp, uint64_t mask) > +{ > + const char *last_name = NULL; > + > + fprintf(fp, "available registers: "); > + for (int reg = 0; reg < 64; reg++) { Could we not use the magic number 64? It's not safe, the supported GP register number could exceed 64 in the future, then the exceeded register won't be iterated. How about this? diff --git a/tools/perf/util/parse-regs-options.c b/tools/perf/util/parse-regs-options.c index c0d0ef9fd495..5177016a7ad4 100644 --- a/tools/perf/util/parse-regs-options.c +++ b/tools/perf/util/parse-regs-options.c @@ -15,7 +15,7 @@ static void list_perf_regs(FILE *fp, uint64_t mask)         const char *last_name = NULL;         fprintf(fp, "available registers: "); -       for (int reg = 0; reg < 64; reg++) { +       for (unsigned long reg = 0; reg < sizeof(mask) * BITS_PER_BYTE; reg++) {                 const char *name;                 if (((1ULL << reg) & mask) == 0) > + const char *name; > + > + if (((1ULL << reg) & mask) == 0) > + continue; > + > + name = perf_reg_name(reg, EM_HOST); > + if (name && (!last_name || strcmp(last_name, name))) > + fprintf(fp, "%s%s", reg > 0 ? " " : "", name); > + last_name = name; > + } > + fputc('\n', fp); > +} > + > +static uint64_t name_to_perf_reg_mask(const char *to_match, uint64_t mask) > +{ > + uint64_t reg_mask = 0; > + > + for (int reg = 0; reg < 64; reg++) { ditto. > + const char *name; > + > + if (((1ULL << reg) & mask) == 0) > + continue; > + > + name = perf_reg_name(reg, EM_HOST); > + if (!name) > + continue; > + > + if (!strcasecmp(to_match, name)) > + reg_mask |= 1ULL << reg; How much register names are expected to match here? It seems the function expects to match only one register name. If so, we can "break" here. Thanks. > + } > + return reg_mask; > +} > + > static int > __parse_regs(const struct option *opt, const char *str, int unset, bool intr) > { > uint64_t *mode = (uint64_t *)opt->value; > - const struct sample_reg *r = NULL; > char *s, *os = NULL, *p; > int ret = -1; > uint64_t mask; > @@ -27,50 +66,41 @@ __parse_regs(const struct option *opt, const char *str, int unset, bool intr) > if (*mode) > return -1; > > - if (intr) > - mask = arch__intr_reg_mask(); > - else > - mask = arch__user_reg_mask(); > - > /* str may be NULL in case no arg is passed to -I */ > - if (str) { > - /* because str is read-only */ > - s = os = strdup(str); > - if (!s) > - return -1; > - > - for (;;) { > - p = strchr(s, ','); > - if (p) > - *p = '\0'; > - > - if (!strcmp(s, "?")) { > - fprintf(stderr, "available registers: "); > - for (r = arch__sample_reg_masks(); r->name; r++) { > - if (r->mask & mask) > - fprintf(stderr, "%s ", r->name); > - } > - fputc('\n', stderr); > - /* just printing available regs */ > - goto error; > - } > - for (r = arch__sample_reg_masks(); r->name; r++) { > - if ((r->mask & mask) && !strcasecmp(s, r->name)) > - break; > - } > - if (!r || !r->name) { > - ui__warning("Unknown register \"%s\", check man page or run \"perf record %s?\"\n", > - s, intr ? "-I" : "--user-regs="); > - goto error; > - } > - > - *mode |= r->mask; > - > - if (!p) > - break; > - > - s = p + 1; > + if (!str) > + return -1; > + > + mask = intr ? arch__intr_reg_mask() : arch__user_reg_mask(); > + > + /* because str is read-only */ > + s = os = strdup(str); > + if (!s) > + return -1; > + > + for (;;) { > + uint64_t reg_mask; > + > + p = strchr(s, ','); > + if (p) > + *p = '\0'; > + > + if (!strcmp(s, "?")) { > + list_perf_regs(stderr, mask); > + goto error; > + } > + > + reg_mask = name_to_perf_reg_mask(s, mask); > + if (reg_mask == 0) { > + ui__warning("Unknown register \"%s\", check man page or run \"perf record %s?\"\n", > + s, intr ? "-I" : "--user-regs="); > + goto error; > } > + *mode |= reg_mask; > + > + if (!p) > + break; > + > + s = p + 1; > } > ret = 0; > > diff --git a/tools/perf/util/perf_regs.c b/tools/perf/util/perf_regs.c > index b58d59b84fb1..ec602da1aeb6 100644 > --- a/tools/perf/util/perf_regs.c > +++ b/tools/perf/util/perf_regs.c > @@ -22,15 +22,6 @@ uint64_t __weak arch__user_reg_mask(void) > return 0; > } > > -static const struct sample_reg sample_reg_masks[] = { > - SMPL_REG_END > -}; > - > -const struct sample_reg * __weak arch__sample_reg_masks(void) > -{ > - return sample_reg_masks; > -} > - > const char *perf_reg_name(int id, uint16_t e_machine) > { > const char *reg_name = NULL; > diff --git a/tools/perf/util/perf_regs.h b/tools/perf/util/perf_regs.h > index 7bfc6a34c02b..2c2a8de6912d 100644 > --- a/tools/perf/util/perf_regs.h > +++ b/tools/perf/util/perf_regs.h > @@ -7,17 +7,6 @@ > > struct regs_dump; > > -struct sample_reg { > - const char *name; > - uint64_t mask; > -}; > - > -#define SMPL_REG_MASK(b) (1ULL << (b)) > -#define SMPL_REG(n, b) { .name = #n, .mask = SMPL_REG_MASK(b) } > -#define SMPL_REG2_MASK(b) (3ULL << (b)) > -#define SMPL_REG2(n, b) { .name = #n, .mask = SMPL_REG2_MASK(b) } > -#define SMPL_REG_END { .name = NULL } > - > enum { > SDT_ARG_VALID = 0, > SDT_ARG_SKIP, > @@ -26,7 +15,6 @@ enum { > int arch_sdt_arg_parse_op(char *old_op, char **new_op); > uint64_t arch__intr_reg_mask(void); > uint64_t arch__user_reg_mask(void); > -const struct sample_reg *arch__sample_reg_masks(void); > > const char *perf_reg_name(int id, uint16_t e_machine); > int perf_reg_value(u64 *valp, struct regs_dump *regs, int id); 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id AC46EC44500 for ; Wed, 21 Jan 2026 08:29:13 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:From:References:To:Subject: MIME-Version:Date:Message-ID:Reply-To:Cc:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=1UX/vDoNgelOusZks80PPZE13RM58hhUwg5PK4RixLI=; b=BCDUmT2A84u91b lJaJSx0P84AA6Gz9lt3+YJLD+808SXPpAwq7kTbWCub9aDpYTIZS0ngUXdQkxvxSwZv5VANfDtb5+ 3GLjSHveO94ssxoDp4PGNsFdsKQ/ps6FSPvI828qMCadx9D3aipmhuWIYLdJZ1DU0ONmQ7oT/tr8p 9wcoNwxmIrNTlQd88DFrLoW6b2wnVkYnXdajs9eS/qFKEQn19acLYWYOPBu9tygbgseE3DQUixI3z mtYD1GkAz/amNgah26fh9/4ABANnDywTMhPUsD8jMVafCXP7wod/9JNKxteHyeGN5Cpqbsl+3qcSv F4XvxomIk94XnZujcGfg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1viTaF-0000000563w-0rtw; Wed, 21 Jan 2026 08:28:59 +0000 Received: from mgamail.intel.com ([198.175.65.10]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1viTaB-0000000563G-3wHS; Wed, 21 Jan 2026 08:28:57 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1768984136; x=1800520136; h=message-id:date:mime-version:subject:to:references:from: in-reply-to:content-transfer-encoding; bh=dApeybvVB3pkwlaT7r4Q5fiIBsXrDsXP3PI8sNxgi2U=; b=ECXnSl+dhb1Ma9k+tS0c8Rdy7QTcgBGmMQ9ehSX4OyggAP2TymLcKESz yFASgQb4VVtj8N6ZhCFLrRGo39mW6HsSuWGgPlUFhq7n8ClzAngCReW4j vtztApwJMfNVFQHwIwGjvDt+to+zG6prybD5eGPQoOjdQKZm7RoprPR5i izHrh6Uwe7VPeUz5IQ8/G1xgQA21exHN+fjLitKuUVhvgJDCkpjEp7Lam o/ZWE0cSae8dL6ulRDP/Pw50qPdr+w/tkxwkNYEut4zqVTRfCpUXIfNrT 6WlEsXPzl3nk+7e7Pz7JomC953ZdlCnpykuZmTropyqjvjm1CG4sgYeVd A==; X-CSE-ConnectionGUID: QbsgN8YuQkqgmObl/BlKXQ== X-CSE-MsgGUID: UBpzIrO8R1Snp9TACTfkrQ== X-IronPort-AV: E=McAfee;i="6800,10657,11677"; a="87619247" X-IronPort-AV: E=Sophos;i="6.21,242,1763452800"; d="scan'208";a="87619247" Received: from orviesa001.jf.intel.com ([10.64.159.141]) by orvoesa102.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 Jan 2026 00:28:51 -0800 X-CSE-ConnectionGUID: UvcO273KTwmUMSsp4luI+w== X-CSE-MsgGUID: AUUo9LUiTuiJxGX8Cxz6AA== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.21,242,1763452800"; d="scan'208";a="243956015" Received: from unknown (HELO [10.238.3.254]) ([10.238.3.254]) by smtpauth.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 Jan 2026 00:28:41 -0800 Message-ID: <56bb6d4d-ad9e-485f-af15-e0f6fbc261c1@linux.intel.com> Date: Wed, 21 Jan 2026 16:28:37 +0800 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v2] perf regs: Refactor use of arch__sample_reg_masks to perf_reg_name To: Ian Rogers , Peter Zijlstra , Ingo Molnar , Arnaldo Carvalho de Melo , Namhyung Kim , Jiri Olsa , Adrian Hunter , James Clark , John Garry , Will Deacon , Leo Yan , Guo Ren , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , Shimin Guo , Athira Rajeev , Stephen Brennan , Howard Chu , Thomas Falcon , Andi Kleen , "Dr. David Alan Gilbert" , Dmitry Vyukov , =?UTF-8?Q?Krzysztof_=C5=81opatowski?= , Chun-Tse Shao , Aditya Bodkhe , Haibo Xu , Sergei Trofimovich , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-csky@vger.kernel.org, linux-riscv@lists.infradead.org References: <20260121021735.3625244-1-irogers@google.com> Content-Language: en-US From: "Mi, Dapeng" In-Reply-To: <20260121021735.3625244-1-irogers@google.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260121_002856_075031_5F36F8D0 X-CRM114-Status: GOOD ( 22.52 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org Ck9uIDEvMjEvMjAyNiAxMDoxNyBBTSwgSWFuIFJvZ2VycyB3cm90ZToKPiBhcmNoX19zYW1wbGVf cmVnX21hc2tzIGlzbid0IHN1cHBvcnRlZCBvbiBBUk0oMzIpLCBjc2t5LCBsb29uZ2FyY2gsCj4g TUlQUywgUklTQy1WIGFuZCBzMzkwLiBUaGUgdGFibGUgcmV0dXJuZWQgYnkgdGhlIGZ1bmN0aW9u IGp1c3QgaGFzIHRoZQo+IG5hbWUgb2YgYSByZWdpc3RlciBwYWlyZWQgd2l0aCB0aGUgY29ycmVz cG9uZGluZyBzYW1wbGVfcmVnc191c2VyIG1hc2sKPiB2YWx1ZS4gRm9yIGEgZ2l2ZW4gcGVyZiBy ZWdpc3RlciB3ZSBjYW4gY29tcHV0ZSB0aGUgbmFtZSB3aXRoCj4gcGVyZl9yZWdfbmFtZSBhbmQg dGhlIG1hc2sgaXMganVzdCAxIGxlZnQtc2hpZnRlZCBieSB0aGUgcGVyZiByZWdpc3Rlcgo+IG51 bWJlci4gQ2hhbmdlIF9fcGFyc2VfcmVncyB0byB1c2UgdGhpcyBtZXRob2QgZm9yIGZpbmRpbmcg cmVnaXN0ZXJzCj4gcmF0aGVyIHRoYW4gYXJjaF9fc2FtcGxlX3JlZ19tYXNrcywgdGhlcmVieSBh ZGRpbmcgX19wYXJzZV9yZWdzCj4gc3VwcG9ydCBmb3IgQVJNKDMyKSwgY3NreSwgbG9vbmdhcmNo LCBNSVBTLCBSSVNDLVYgYW5kIHMzOTAuIEFzCj4gYXJjaF9fc2FtcGxlX3JlZ19tYXNrcyBpcyB0 aGVuIHVudXNlZCwgcmVtb3ZlIHRoZSBub3cgdW5uZWVkZWQKPiBkZWNsYXJhdGlvbnMuCj4KPiBT aWduZWQtb2ZmLWJ5OiBJYW4gUm9nZXJzIDxpcm9nZXJzQGdvb2dsZS5jb20+Cj4gLS0tCj4gdjI6 IENvcnJlY3QgdGhlIHNldHRpbmcgb2YgcmVnIG1hc2sgZm9yIHJlZ2lzdGVycyB0aGF0IG5lZWQg PjEgYml0IHNldAo+ICAgICBsaWtlIFhNTXMuCj4KPiBUaGUgaWRlYSBmb3IgdGhpcyBwYXRjaCBj YW1lIHVwIGluIGNvbnZlcnNhdGlvbiB3aXRoIERhcGVuZyBNaSB0bwo+IGF2b2lkIGFkZGl0aW9u YWwgZnVuY3Rpb25zIGFuZCB0YWJsZXMgZm9yIHg4NiBBUFggc3VwcG9ydDoKPiBodHRwczovL2xv cmUua2VybmVsLm9yZy9sa21sL0NBUC01PWZXT3N2QVh1dThxeDB0azlxOGo4Qm9YUE1KQjNHeHRv K2l1NndmMDZpNGNWQUBtYWlsLmdtYWlsLmNvbS8KPgo+IFRoZSBwYXRjaCBpcyBvbiB0b3Agb2Yg dGhlIGR3ZmwgY2xlYW4gdXAgcGF0Y2hlcyB0aGF0IHN3aXRjaCBwZXJmCj4gcmVnaXN0ZXIgZnVu Y3Rpb25zIHRvIHVzaW5nIGVfbWFjaGluZSBhcyBhbiBhcmd1bWVudCByYXRoZXIgdGhhbiB0aGUK PiBhcmNoIHN0cmluZywgdGhpcyBtZWFucyB0aGF0IEVNX0hPU1QgY2FuIGJlIHVzZWQgd2l0aCBw ZXJmX3JlZ19uYW1lOgo+IGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2xrbWwvMjAyNjAxMTcwNTI4 NDkuMjIwNTU0NS0xLWlyb2dlcnNAZ29vZ2xlLmNvbS8KPiAtLS0KPiAgdG9vbHMvcGVyZi9hcmNo L2FybS91dGlsL3BlcmZfcmVncy5jICAgICAgICAgIHwgICA5IC0tCj4gIHRvb2xzL3BlcmYvYXJj aC9hcm02NC91dGlsL21hY2hpbmUuYyAgICAgICAgICB8ICAxNCArLS0KPiAgdG9vbHMvcGVyZi9h cmNoL2FybTY0L3V0aWwvcGVyZl9yZWdzLmMgICAgICAgIHwgIDQ1ICstLS0tLS0KPiAgdG9vbHMv cGVyZi9hcmNoL2Nza3kvdXRpbC9wZXJmX3JlZ3MuYyAgICAgICAgIHwgICA5IC0tCj4gIHRvb2xz L3BlcmYvYXJjaC9sb29uZ2FyY2gvdXRpbC9wZXJmX3JlZ3MuYyAgICB8ICAgOSAtLQo+ICB0b29s cy9wZXJmL2FyY2gvbWlwcy91dGlsL3BlcmZfcmVncy5jICAgICAgICAgfCAgIDkgLS0KPiAgdG9v bHMvcGVyZi9hcmNoL3Bvd2VycGMvdXRpbC9wZXJmX3JlZ3MuYyAgICAgIHwgIDY4IC0tLS0tLS0t LS0KPiAgdG9vbHMvcGVyZi9hcmNoL3Jpc2N2L3V0aWwvcGVyZl9yZWdzLmMgICAgICAgIHwgICA5 IC0tCj4gIHRvb2xzL3BlcmYvYXJjaC9zMzkwL3V0aWwvcGVyZl9yZWdzLmMgICAgICAgICB8ICAg OSAtLQo+ICB0b29scy9wZXJmL2FyY2gveDg2L3V0aWwvcGVyZl9yZWdzLmMgICAgICAgICAgfCAg NDcgLS0tLS0tLQo+ICAuLi4vdXRpbC9hcm02NC1mcmFtZS1wb2ludGVyLXVud2luZC1zdXBwb3J0 LmMgfCAgIDMgKy0KPiAgdG9vbHMvcGVyZi91dGlsL3BhcnNlLXJlZ3Mtb3B0aW9ucy5jICAgICAg ICAgIHwgMTE2ICsrKysrKysrKysrLS0tLS0tLQo+ICB0b29scy9wZXJmL3V0aWwvcGVyZl9yZWdz LmMgICAgICAgICAgICAgICAgICAgfCAgIDkgLS0KPiAgdG9vbHMvcGVyZi91dGlsL3BlcmZfcmVn cy5oICAgICAgICAgICAgICAgICAgIHwgIDEyIC0tCj4gIDE0IGZpbGVzIGNoYW5nZWQsIDgxIGlu c2VydGlvbnMoKyksIDI4NyBkZWxldGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS90b29scy9wZXJm L2FyY2gvYXJtL3V0aWwvcGVyZl9yZWdzLmMgYi90b29scy9wZXJmL2FyY2gvYXJtL3V0aWwvcGVy Zl9yZWdzLmMKPiBpbmRleCBmOTRhMDIxMGM3YjcuLjAzYTViYzBjZjY0YyAxMDA2NDQKPiAtLS0g YS90b29scy9wZXJmL2FyY2gvYXJtL3V0aWwvcGVyZl9yZWdzLmMKPiArKysgYi90b29scy9wZXJm L2FyY2gvYXJtL3V0aWwvcGVyZl9yZWdzLmMKPiBAQCAtMiwxMCArMiw2IEBACj4gICNpbmNsdWRl ICJwZXJmX3JlZ3MuaCIKPiAgI2luY2x1ZGUgIi4uLy4uLy4uL3V0aWwvcGVyZl9yZWdzLmgiCj4g IAo+IC1zdGF0aWMgY29uc3Qgc3RydWN0IHNhbXBsZV9yZWcgc2FtcGxlX3JlZ19tYXNrc1tdID0g ewo+IC0JU01QTF9SRUdfRU5ECj4gLX07Cj4gLQo+ICB1aW50NjRfdCBhcmNoX19pbnRyX3JlZ19t YXNrKHZvaWQpCj4gIHsKPiAgCXJldHVybiBQRVJGX1JFR1NfTUFTSzsKPiBAQCAtMTUsOCArMTEs MyBAQCB1aW50NjRfdCBhcmNoX191c2VyX3JlZ19tYXNrKHZvaWQpCj4gIHsKPiAgCXJldHVybiBQ RVJGX1JFR1NfTUFTSzsKPiAgfQo+IC0KPiAtY29uc3Qgc3RydWN0IHNhbXBsZV9yZWcgKmFyY2hf X3NhbXBsZV9yZWdfbWFza3Modm9pZCkKPiAtewo+IC0JcmV0dXJuIHNhbXBsZV9yZWdfbWFza3M7 Cj4gLX0KPiBkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9hcmNoL2FybTY0L3V0aWwvbWFjaGluZS5j IGIvdG9vbHMvcGVyZi9hcmNoL2FybTY0L3V0aWwvbWFjaGluZS5jCj4gaW5kZXggYWFiMWNjMmJj MjgzLi44MGZiMTNjOTU4ZDkgMTAwNjQ0Cj4gLS0tIGEvdG9vbHMvcGVyZi9hcmNoL2FybTY0L3V0 aWwvbWFjaGluZS5jCj4gKysrIGIvdG9vbHMvcGVyZi9hcmNoL2FybTY0L3V0aWwvbWFjaGluZS5j Cj4gQEAgLTEsMTggKzEsMTIgQEAKPiAgLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0y LjAKPiAgCj4gLSNpbmNsdWRlIDxpbnR0eXBlcy5oPgo+IC0jaW5jbHVkZSA8c3RkaW8uaD4KPiAt I2luY2x1ZGUgPHN0cmluZy5oPgo+IC0jaW5jbHVkZSAiZGVidWcuaCIKPiAtI2luY2x1ZGUgInN5 bWJvbC5oIgo+IC0jaW5jbHVkZSAiY2FsbGNoYWluLmgiCj4gKyNpbmNsdWRlICJjYWxsY2hhaW4u aCIgLy8gcHJvdG90eXBlIG9mIGFyY2hfX2FkZF9sZWFmX2ZyYW1lX3JlY29yZF9vcHRzCj4gICNp bmNsdWRlICJwZXJmX3JlZ3MuaCIKPiAgI2luY2x1ZGUgInJlY29yZC5oIgo+IC0jaW5jbHVkZSAi dXRpbC9wZXJmX3JlZ3MuaCIKPiArCj4gKyNkZWZpbmUgU01QTF9SRUdfTUFTSyhiKSAoMVVMTCA8 PCAoYikpCj4gIAo+ICB2b2lkIGFyY2hfX2FkZF9sZWFmX2ZyYW1lX3JlY29yZF9vcHRzKHN0cnVj dCByZWNvcmRfb3B0cyAqb3B0cykKPiAgewo+IC0JY29uc3Qgc3RydWN0IHNhbXBsZV9yZWcgKnNh bXBsZV9yZWdfbWFza3MgPSBhcmNoX19zYW1wbGVfcmVnX21hc2tzKCk7Cj4gLQo+IC0Jb3B0cy0+ c2FtcGxlX3VzZXJfcmVncyB8PSBzYW1wbGVfcmVnX21hc2tzW1BFUkZfUkVHX0FSTTY0X0xSXS5t YXNrOwo+ICsJb3B0cy0+c2FtcGxlX3VzZXJfcmVncyB8PSBTTVBMX1JFR19NQVNLKFBFUkZfUkVH X0FSTTY0X0xSKTsKPiAgfQo+IGRpZmYgLS1naXQgYS90b29scy9wZXJmL2FyY2gvYXJtNjQvdXRp bC9wZXJmX3JlZ3MuYyBiL3Rvb2xzL3BlcmYvYXJjaC9hcm02NC91dGlsL3BlcmZfcmVncy5jCj4g aW5kZXggMDkzMDg2NjVlMjhhLi45YmI3NjhlMWJlYTEgMTAwNjQ0Cj4gLS0tIGEvdG9vbHMvcGVy Zi9hcmNoL2FybTY0L3V0aWwvcGVyZl9yZWdzLmMKPiArKysgYi90b29scy9wZXJmL2FyY2gvYXJt NjQvdXRpbC9wZXJmX3JlZ3MuYwo+IEBAIC0xMiw0OCArMTIsMTIgQEAKPiAgI2luY2x1ZGUgIi4u Ly4uLy4uL3V0aWwvZXZlbnQuaCIKPiAgI2luY2x1ZGUgIi4uLy4uLy4uL3V0aWwvcGVyZl9yZWdz LmgiCj4gIAo+ICsjZGVmaW5lIFNNUExfUkVHX01BU0soYikgKDFVTEwgPDwgKGIpKQo+ICsKPiAg I2lmbmRlZiBIV0NBUF9TVkUKPiAgI2RlZmluZSBIV0NBUF9TVkUJKDEgPDwgMjIpCj4gICNlbmRp Zgo+ICAKPiAtc3RhdGljIGNvbnN0IHN0cnVjdCBzYW1wbGVfcmVnIHNhbXBsZV9yZWdfbWFza3Nb XSA9IHsKPiAtCVNNUExfUkVHKHgwLCBQRVJGX1JFR19BUk02NF9YMCksCj4gLQlTTVBMX1JFRyh4 MSwgUEVSRl9SRUdfQVJNNjRfWDEpLAo+IC0JU01QTF9SRUcoeDIsIFBFUkZfUkVHX0FSTTY0X1gy KSwKPiAtCVNNUExfUkVHKHgzLCBQRVJGX1JFR19BUk02NF9YMyksCj4gLQlTTVBMX1JFRyh4NCwg UEVSRl9SRUdfQVJNNjRfWDQpLAo+IC0JU01QTF9SRUcoeDUsIFBFUkZfUkVHX0FSTTY0X1g1KSwK PiAtCVNNUExfUkVHKHg2LCBQRVJGX1JFR19BUk02NF9YNiksCj4gLQlTTVBMX1JFRyh4NywgUEVS Rl9SRUdfQVJNNjRfWDcpLAo+IC0JU01QTF9SRUcoeDgsIFBFUkZfUkVHX0FSTTY0X1g4KSwKPiAt CVNNUExfUkVHKHg5LCBQRVJGX1JFR19BUk02NF9YOSksCj4gLQlTTVBMX1JFRyh4MTAsIFBFUkZf UkVHX0FSTTY0X1gxMCksCj4gLQlTTVBMX1JFRyh4MTEsIFBFUkZfUkVHX0FSTTY0X1gxMSksCj4g LQlTTVBMX1JFRyh4MTIsIFBFUkZfUkVHX0FSTTY0X1gxMiksCj4gLQlTTVBMX1JFRyh4MTMsIFBF UkZfUkVHX0FSTTY0X1gxMyksCj4gLQlTTVBMX1JFRyh4MTQsIFBFUkZfUkVHX0FSTTY0X1gxNCks Cj4gLQlTTVBMX1JFRyh4MTUsIFBFUkZfUkVHX0FSTTY0X1gxNSksCj4gLQlTTVBMX1JFRyh4MTYs IFBFUkZfUkVHX0FSTTY0X1gxNiksCj4gLQlTTVBMX1JFRyh4MTcsIFBFUkZfUkVHX0FSTTY0X1gx NyksCj4gLQlTTVBMX1JFRyh4MTgsIFBFUkZfUkVHX0FSTTY0X1gxOCksCj4gLQlTTVBMX1JFRyh4 MTksIFBFUkZfUkVHX0FSTTY0X1gxOSksCj4gLQlTTVBMX1JFRyh4MjAsIFBFUkZfUkVHX0FSTTY0 X1gyMCksCj4gLQlTTVBMX1JFRyh4MjEsIFBFUkZfUkVHX0FSTTY0X1gyMSksCj4gLQlTTVBMX1JF Ryh4MjIsIFBFUkZfUkVHX0FSTTY0X1gyMiksCj4gLQlTTVBMX1JFRyh4MjMsIFBFUkZfUkVHX0FS TTY0X1gyMyksCj4gLQlTTVBMX1JFRyh4MjQsIFBFUkZfUkVHX0FSTTY0X1gyNCksCj4gLQlTTVBM X1JFRyh4MjUsIFBFUkZfUkVHX0FSTTY0X1gyNSksCj4gLQlTTVBMX1JFRyh4MjYsIFBFUkZfUkVH X0FSTTY0X1gyNiksCj4gLQlTTVBMX1JFRyh4MjcsIFBFUkZfUkVHX0FSTTY0X1gyNyksCj4gLQlT TVBMX1JFRyh4MjgsIFBFUkZfUkVHX0FSTTY0X1gyOCksCj4gLQlTTVBMX1JFRyh4MjksIFBFUkZf UkVHX0FSTTY0X1gyOSksCj4gLQlTTVBMX1JFRyhsciwgUEVSRl9SRUdfQVJNNjRfTFIpLAo+IC0J U01QTF9SRUcoc3AsIFBFUkZfUkVHX0FSTTY0X1NQKSwKPiAtCVNNUExfUkVHKHBjLCBQRVJGX1JF R19BUk02NF9QQyksCj4gLQlTTVBMX1JFRyh2ZywgUEVSRl9SRUdfQVJNNjRfVkcpLAo+IC0JU01Q TF9SRUdfRU5ECj4gLX07Cj4gLQo+ICAvKiAleE5VTSAqLwo+ICAjZGVmaW5lIFNEVF9PUF9SRUdF WDEgICJeKHhbMS0yXT9bMC05XXwzWzAtMV0pJCIKPiAgCj4gQEAgLTE3NSw4ICsxMzksMyBAQCB1 aW50NjRfdCBhcmNoX191c2VyX3JlZ19tYXNrKHZvaWQpCj4gIAl9Cj4gIAlyZXR1cm4gUEVSRl9S RUdTX01BU0s7Cj4gIH0KPiAtCj4gLWNvbnN0IHN0cnVjdCBzYW1wbGVfcmVnICphcmNoX19zYW1w bGVfcmVnX21hc2tzKHZvaWQpCj4gLXsKPiAtCXJldHVybiBzYW1wbGVfcmVnX21hc2tzOwo+IC19 Cj4gZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvYXJjaC9jc2t5L3V0aWwvcGVyZl9yZWdzLmMgYi90 b29scy9wZXJmL2FyY2gvY3NreS91dGlsL3BlcmZfcmVncy5jCj4gaW5kZXggNmIxNjY1ZjQxMTgw Li4yY2Y3YTU0MTA2ZTAgMTAwNjQ0Cj4gLS0tIGEvdG9vbHMvcGVyZi9hcmNoL2Nza3kvdXRpbC9w ZXJmX3JlZ3MuYwo+ICsrKyBiL3Rvb2xzL3BlcmYvYXJjaC9jc2t5L3V0aWwvcGVyZl9yZWdzLmMK PiBAQCAtMiwxMCArMiw2IEBACj4gICNpbmNsdWRlICJwZXJmX3JlZ3MuaCIKPiAgI2luY2x1ZGUg Ii4uLy4uL3V0aWwvcGVyZl9yZWdzLmgiCj4gIAo+IC1zdGF0aWMgY29uc3Qgc3RydWN0IHNhbXBs ZV9yZWcgc2FtcGxlX3JlZ19tYXNrc1tdID0gewo+IC0JU01QTF9SRUdfRU5ECj4gLX07Cj4gLQo+ ICB1aW50NjRfdCBhcmNoX19pbnRyX3JlZ19tYXNrKHZvaWQpCj4gIHsKPiAgCXJldHVybiBQRVJG X1JFR1NfTUFTSzsKPiBAQCAtMTUsOCArMTEsMyBAQCB1aW50NjRfdCBhcmNoX191c2VyX3JlZ19t YXNrKHZvaWQpCj4gIHsKPiAgCXJldHVybiBQRVJGX1JFR1NfTUFTSzsKPiAgfQo+IC0KPiAtY29u c3Qgc3RydWN0IHNhbXBsZV9yZWcgKmFyY2hfX3NhbXBsZV9yZWdfbWFza3Modm9pZCkKPiAtewo+ IC0JcmV0dXJuIHNhbXBsZV9yZWdfbWFza3M7Cj4gLX0KPiBkaWZmIC0tZ2l0IGEvdG9vbHMvcGVy Zi9hcmNoL2xvb25nYXJjaC91dGlsL3BlcmZfcmVncy5jIGIvdG9vbHMvcGVyZi9hcmNoL2xvb25n YXJjaC91dGlsL3BlcmZfcmVncy5jCj4gaW5kZXggZjk0YTAyMTBjN2I3Li4wM2E1YmMwY2Y2NGMg MTAwNjQ0Cj4gLS0tIGEvdG9vbHMvcGVyZi9hcmNoL2xvb25nYXJjaC91dGlsL3BlcmZfcmVncy5j Cj4gKysrIGIvdG9vbHMvcGVyZi9hcmNoL2xvb25nYXJjaC91dGlsL3BlcmZfcmVncy5jCj4gQEAg LTIsMTAgKzIsNiBAQAo+ICAjaW5jbHVkZSAicGVyZl9yZWdzLmgiCj4gICNpbmNsdWRlICIuLi8u Li8uLi91dGlsL3BlcmZfcmVncy5oIgo+ICAKPiAtc3RhdGljIGNvbnN0IHN0cnVjdCBzYW1wbGVf cmVnIHNhbXBsZV9yZWdfbWFza3NbXSA9IHsKPiAtCVNNUExfUkVHX0VORAo+IC19Owo+IC0KPiAg dWludDY0X3QgYXJjaF9faW50cl9yZWdfbWFzayh2b2lkKQo+ICB7Cj4gIAlyZXR1cm4gUEVSRl9S RUdTX01BU0s7Cj4gQEAgLTE1LDggKzExLDMgQEAgdWludDY0X3QgYXJjaF9fdXNlcl9yZWdfbWFz ayh2b2lkKQo+ICB7Cj4gIAlyZXR1cm4gUEVSRl9SRUdTX01BU0s7Cj4gIH0KPiAtCj4gLWNvbnN0 IHN0cnVjdCBzYW1wbGVfcmVnICphcmNoX19zYW1wbGVfcmVnX21hc2tzKHZvaWQpCj4gLXsKPiAt CXJldHVybiBzYW1wbGVfcmVnX21hc2tzOwo+IC19Cj4gZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYv YXJjaC9taXBzL3V0aWwvcGVyZl9yZWdzLmMgYi90b29scy9wZXJmL2FyY2gvbWlwcy91dGlsL3Bl cmZfcmVncy5jCj4gaW5kZXggNmIxNjY1ZjQxMTgwLi4yY2Y3YTU0MTA2ZTAgMTAwNjQ0Cj4gLS0t IGEvdG9vbHMvcGVyZi9hcmNoL21pcHMvdXRpbC9wZXJmX3JlZ3MuYwo+ICsrKyBiL3Rvb2xzL3Bl cmYvYXJjaC9taXBzL3V0aWwvcGVyZl9yZWdzLmMKPiBAQCAtMiwxMCArMiw2IEBACj4gICNpbmNs dWRlICJwZXJmX3JlZ3MuaCIKPiAgI2luY2x1ZGUgIi4uLy4uL3V0aWwvcGVyZl9yZWdzLmgiCj4g IAo+IC1zdGF0aWMgY29uc3Qgc3RydWN0IHNhbXBsZV9yZWcgc2FtcGxlX3JlZ19tYXNrc1tdID0g ewo+IC0JU01QTF9SRUdfRU5ECj4gLX07Cj4gLQo+ICB1aW50NjRfdCBhcmNoX19pbnRyX3JlZ19t YXNrKHZvaWQpCj4gIHsKPiAgCXJldHVybiBQRVJGX1JFR1NfTUFTSzsKPiBAQCAtMTUsOCArMTEs MyBAQCB1aW50NjRfdCBhcmNoX191c2VyX3JlZ19tYXNrKHZvaWQpCj4gIHsKPiAgCXJldHVybiBQ RVJGX1JFR1NfTUFTSzsKPiAgfQo+IC0KPiAtY29uc3Qgc3RydWN0IHNhbXBsZV9yZWcgKmFyY2hf X3NhbXBsZV9yZWdfbWFza3Modm9pZCkKPiAtewo+IC0JcmV0dXJuIHNhbXBsZV9yZWdfbWFza3M7 Cj4gLX0KPiBkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9hcmNoL3Bvd2VycGMvdXRpbC9wZXJmX3Jl Z3MuYyBiL3Rvb2xzL3BlcmYvYXJjaC9wb3dlcnBjL3V0aWwvcGVyZl9yZWdzLmMKPiBpbmRleCBi ZDM2Y2ZkNDIwYTIuLjc3OTA3M2Y3ZTk5MiAxMDA2NDQKPiAtLS0gYS90b29scy9wZXJmL2FyY2gv cG93ZXJwYy91dGlsL3BlcmZfcmVncy5jCj4gKysrIGIvdG9vbHMvcGVyZi9hcmNoL3Bvd2VycGMv dXRpbC9wZXJmX3JlZ3MuYwo+IEBAIC0xOCw2OSArMTgsNiBAQAo+ICAjZGVmaW5lIFBWUl9QT1dF UjEwCQkweDAwODAKPiAgI2RlZmluZSBQVlJfUE9XRVIxMQkJMHgwMDgyCj4gIAo+IC1zdGF0aWMg Y29uc3Qgc3RydWN0IHNhbXBsZV9yZWcgc2FtcGxlX3JlZ19tYXNrc1tdID0gewo+IC0JU01QTF9S RUcocjAsIFBFUkZfUkVHX1BPV0VSUENfUjApLAo+IC0JU01QTF9SRUcocjEsIFBFUkZfUkVHX1BP V0VSUENfUjEpLAo+IC0JU01QTF9SRUcocjIsIFBFUkZfUkVHX1BPV0VSUENfUjIpLAo+IC0JU01Q TF9SRUcocjMsIFBFUkZfUkVHX1BPV0VSUENfUjMpLAo+IC0JU01QTF9SRUcocjQsIFBFUkZfUkVH X1BPV0VSUENfUjQpLAo+IC0JU01QTF9SRUcocjUsIFBFUkZfUkVHX1BPV0VSUENfUjUpLAo+IC0J U01QTF9SRUcocjYsIFBFUkZfUkVHX1BPV0VSUENfUjYpLAo+IC0JU01QTF9SRUcocjcsIFBFUkZf UkVHX1BPV0VSUENfUjcpLAo+IC0JU01QTF9SRUcocjgsIFBFUkZfUkVHX1BPV0VSUENfUjgpLAo+ IC0JU01QTF9SRUcocjksIFBFUkZfUkVHX1BPV0VSUENfUjkpLAo+IC0JU01QTF9SRUcocjEwLCBQ RVJGX1JFR19QT1dFUlBDX1IxMCksCj4gLQlTTVBMX1JFRyhyMTEsIFBFUkZfUkVHX1BPV0VSUENf UjExKSwKPiAtCVNNUExfUkVHKHIxMiwgUEVSRl9SRUdfUE9XRVJQQ19SMTIpLAo+IC0JU01QTF9S RUcocjEzLCBQRVJGX1JFR19QT1dFUlBDX1IxMyksCj4gLQlTTVBMX1JFRyhyMTQsIFBFUkZfUkVH X1BPV0VSUENfUjE0KSwKPiAtCVNNUExfUkVHKHIxNSwgUEVSRl9SRUdfUE9XRVJQQ19SMTUpLAo+ IC0JU01QTF9SRUcocjE2LCBQRVJGX1JFR19QT1dFUlBDX1IxNiksCj4gLQlTTVBMX1JFRyhyMTcs IFBFUkZfUkVHX1BPV0VSUENfUjE3KSwKPiAtCVNNUExfUkVHKHIxOCwgUEVSRl9SRUdfUE9XRVJQ Q19SMTgpLAo+IC0JU01QTF9SRUcocjE5LCBQRVJGX1JFR19QT1dFUlBDX1IxOSksCj4gLQlTTVBM X1JFRyhyMjAsIFBFUkZfUkVHX1BPV0VSUENfUjIwKSwKPiAtCVNNUExfUkVHKHIyMSwgUEVSRl9S RUdfUE9XRVJQQ19SMjEpLAo+IC0JU01QTF9SRUcocjIyLCBQRVJGX1JFR19QT1dFUlBDX1IyMiks Cj4gLQlTTVBMX1JFRyhyMjMsIFBFUkZfUkVHX1BPV0VSUENfUjIzKSwKPiAtCVNNUExfUkVHKHIy NCwgUEVSRl9SRUdfUE9XRVJQQ19SMjQpLAo+IC0JU01QTF9SRUcocjI1LCBQRVJGX1JFR19QT1dF UlBDX1IyNSksCj4gLQlTTVBMX1JFRyhyMjYsIFBFUkZfUkVHX1BPV0VSUENfUjI2KSwKPiAtCVNN UExfUkVHKHIyNywgUEVSRl9SRUdfUE9XRVJQQ19SMjcpLAo+IC0JU01QTF9SRUcocjI4LCBQRVJG X1JFR19QT1dFUlBDX1IyOCksCj4gLQlTTVBMX1JFRyhyMjksIFBFUkZfUkVHX1BPV0VSUENfUjI5 KSwKPiAtCVNNUExfUkVHKHIzMCwgUEVSRl9SRUdfUE9XRVJQQ19SMzApLAo+IC0JU01QTF9SRUco cjMxLCBQRVJGX1JFR19QT1dFUlBDX1IzMSksCj4gLQlTTVBMX1JFRyhuaXAsIFBFUkZfUkVHX1BP V0VSUENfTklQKSwKPiAtCVNNUExfUkVHKG1zciwgUEVSRl9SRUdfUE9XRVJQQ19NU1IpLAo+IC0J U01QTF9SRUcob3JpZ19yMywgUEVSRl9SRUdfUE9XRVJQQ19PUklHX1IzKSwKPiAtCVNNUExfUkVH KGN0ciwgUEVSRl9SRUdfUE9XRVJQQ19DVFIpLAo+IC0JU01QTF9SRUcobGluaywgUEVSRl9SRUdf UE9XRVJQQ19MSU5LKSwKPiAtCVNNUExfUkVHKHhlciwgUEVSRl9SRUdfUE9XRVJQQ19YRVIpLAo+ IC0JU01QTF9SRUcoY2NyLCBQRVJGX1JFR19QT1dFUlBDX0NDUiksCj4gLQlTTVBMX1JFRyhzb2Z0 ZSwgUEVSRl9SRUdfUE9XRVJQQ19TT0ZURSksCj4gLQlTTVBMX1JFRyh0cmFwLCBQRVJGX1JFR19Q T1dFUlBDX1RSQVApLAo+IC0JU01QTF9SRUcoZGFyLCBQRVJGX1JFR19QT1dFUlBDX0RBUiksCj4g LQlTTVBMX1JFRyhkc2lzciwgUEVSRl9SRUdfUE9XRVJQQ19EU0lTUiksCj4gLQlTTVBMX1JFRyhz aWVyLCBQRVJGX1JFR19QT1dFUlBDX1NJRVIpLAo+IC0JU01QTF9SRUcobW1jcmEsIFBFUkZfUkVH X1BPV0VSUENfTU1DUkEpLAo+IC0JU01QTF9SRUcobW1jcjAsIFBFUkZfUkVHX1BPV0VSUENfTU1D UjApLAo+IC0JU01QTF9SRUcobW1jcjEsIFBFUkZfUkVHX1BPV0VSUENfTU1DUjEpLAo+IC0JU01Q TF9SRUcobW1jcjIsIFBFUkZfUkVHX1BPV0VSUENfTU1DUjIpLAo+IC0JU01QTF9SRUcobW1jcjMs IFBFUkZfUkVHX1BPV0VSUENfTU1DUjMpLAo+IC0JU01QTF9SRUcoc2llcjIsIFBFUkZfUkVHX1BP V0VSUENfU0lFUjIpLAo+IC0JU01QTF9SRUcoc2llcjMsIFBFUkZfUkVHX1BPV0VSUENfU0lFUjMp LAo+IC0JU01QTF9SRUcocG1jMSwgUEVSRl9SRUdfUE9XRVJQQ19QTUMxKSwKPiAtCVNNUExfUkVH KHBtYzIsIFBFUkZfUkVHX1BPV0VSUENfUE1DMiksCj4gLQlTTVBMX1JFRyhwbWMzLCBQRVJGX1JF R19QT1dFUlBDX1BNQzMpLAo+IC0JU01QTF9SRUcocG1jNCwgUEVSRl9SRUdfUE9XRVJQQ19QTUM0 KSwKPiAtCVNNUExfUkVHKHBtYzUsIFBFUkZfUkVHX1BPV0VSUENfUE1DNSksCj4gLQlTTVBMX1JF RyhwbWM2LCBQRVJGX1JFR19QT1dFUlBDX1BNQzYpLAo+IC0JU01QTF9SRUcoc2RhciwgUEVSRl9S RUdfUE9XRVJQQ19TREFSKSwKPiAtCVNNUExfUkVHKHNpYXIsIFBFUkZfUkVHX1BPV0VSUENfU0lB UiksCj4gLQlTTVBMX1JFR19FTkQKPiAtfTsKPiAtCj4gIC8qIFJFRyBvciAlclJFRyAqLwo+ICAj ZGVmaW5lIFNEVF9PUF9SRUdFWDEgICJeKCVyKT8oWzEtMl0/WzAtOV18M1swLTFdKSQiCj4gIAo+ IEBAIC0yMzMsOCArMTcwLDMgQEAgdWludDY0X3QgYXJjaF9fdXNlcl9yZWdfbWFzayh2b2lkKQo+ ICB7Cj4gIAlyZXR1cm4gUEVSRl9SRUdTX01BU0s7Cj4gIH0KPiAtCj4gLWNvbnN0IHN0cnVjdCBz YW1wbGVfcmVnICphcmNoX19zYW1wbGVfcmVnX21hc2tzKHZvaWQpCj4gLXsKPiAtCXJldHVybiBz YW1wbGVfcmVnX21hc2tzOwo+IC19Cj4gZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvYXJjaC9yaXNj di91dGlsL3BlcmZfcmVncy5jIGIvdG9vbHMvcGVyZi9hcmNoL3Jpc2N2L3V0aWwvcGVyZl9yZWdz LmMKPiBpbmRleCA2YjE2NjVmNDExODAuLjJjZjdhNTQxMDZlMCAxMDA2NDQKPiAtLS0gYS90b29s cy9wZXJmL2FyY2gvcmlzY3YvdXRpbC9wZXJmX3JlZ3MuYwo+ICsrKyBiL3Rvb2xzL3BlcmYvYXJj aC9yaXNjdi91dGlsL3BlcmZfcmVncy5jCj4gQEAgLTIsMTAgKzIsNiBAQAo+ICAjaW5jbHVkZSAi cGVyZl9yZWdzLmgiCj4gICNpbmNsdWRlICIuLi8uLi91dGlsL3BlcmZfcmVncy5oIgo+ICAKPiAt c3RhdGljIGNvbnN0IHN0cnVjdCBzYW1wbGVfcmVnIHNhbXBsZV9yZWdfbWFza3NbXSA9IHsKPiAt CVNNUExfUkVHX0VORAo+IC19Owo+IC0KPiAgdWludDY0X3QgYXJjaF9faW50cl9yZWdfbWFzayh2 b2lkKQo+ICB7Cj4gIAlyZXR1cm4gUEVSRl9SRUdTX01BU0s7Cj4gQEAgLTE1LDggKzExLDMgQEAg dWludDY0X3QgYXJjaF9fdXNlcl9yZWdfbWFzayh2b2lkKQo+ICB7Cj4gIAlyZXR1cm4gUEVSRl9S RUdTX01BU0s7Cj4gIH0KPiAtCj4gLWNvbnN0IHN0cnVjdCBzYW1wbGVfcmVnICphcmNoX19zYW1w bGVfcmVnX21hc2tzKHZvaWQpCj4gLXsKPiAtCXJldHVybiBzYW1wbGVfcmVnX21hc2tzOwo+IC19 Cj4gZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvYXJjaC9zMzkwL3V0aWwvcGVyZl9yZWdzLmMgYi90 b29scy9wZXJmL2FyY2gvczM5MC91dGlsL3BlcmZfcmVncy5jCj4gaW5kZXggNmIxNjY1ZjQxMTgw Li4yY2Y3YTU0MTA2ZTAgMTAwNjQ0Cj4gLS0tIGEvdG9vbHMvcGVyZi9hcmNoL3MzOTAvdXRpbC9w ZXJmX3JlZ3MuYwo+ICsrKyBiL3Rvb2xzL3BlcmYvYXJjaC9zMzkwL3V0aWwvcGVyZl9yZWdzLmMK PiBAQCAtMiwxMCArMiw2IEBACj4gICNpbmNsdWRlICJwZXJmX3JlZ3MuaCIKPiAgI2luY2x1ZGUg Ii4uLy4uL3V0aWwvcGVyZl9yZWdzLmgiCj4gIAo+IC1zdGF0aWMgY29uc3Qgc3RydWN0IHNhbXBs ZV9yZWcgc2FtcGxlX3JlZ19tYXNrc1tdID0gewo+IC0JU01QTF9SRUdfRU5ECj4gLX07Cj4gLQo+ ICB1aW50NjRfdCBhcmNoX19pbnRyX3JlZ19tYXNrKHZvaWQpCj4gIHsKPiAgCXJldHVybiBQRVJG X1JFR1NfTUFTSzsKPiBAQCAtMTUsOCArMTEsMyBAQCB1aW50NjRfdCBhcmNoX191c2VyX3JlZ19t YXNrKHZvaWQpCj4gIHsKPiAgCXJldHVybiBQRVJGX1JFR1NfTUFTSzsKPiAgfQo+IC0KPiAtY29u c3Qgc3RydWN0IHNhbXBsZV9yZWcgKmFyY2hfX3NhbXBsZV9yZWdfbWFza3Modm9pZCkKPiAtewo+ IC0JcmV0dXJuIHNhbXBsZV9yZWdfbWFza3M7Cj4gLX0KPiBkaWZmIC0tZ2l0IGEvdG9vbHMvcGVy Zi9hcmNoL3g4Ni91dGlsL3BlcmZfcmVncy5jIGIvdG9vbHMvcGVyZi9hcmNoL3g4Ni91dGlsL3Bl cmZfcmVncy5jCj4gaW5kZXggMTJmZDkzZjA0ODAyLi5hN2NhNDE1NGZkZjkgMTAwNjQ0Cj4gLS0t IGEvdG9vbHMvcGVyZi9hcmNoL3g4Ni91dGlsL3BlcmZfcmVncy5jCj4gKysrIGIvdG9vbHMvcGVy Zi9hcmNoL3g4Ni91dGlsL3BlcmZfcmVncy5jCj4gQEAgLTEzLDQ4ICsxMyw2IEBACj4gICNpbmNs dWRlICIuLi8uLi8uLi91dGlsL3BtdS5oIgo+ICAjaW5jbHVkZSAiLi4vLi4vLi4vdXRpbC9wbXVz LmgiCj4gIAo+IC1zdGF0aWMgY29uc3Qgc3RydWN0IHNhbXBsZV9yZWcgc2FtcGxlX3JlZ19tYXNr c1tdID0gewo+IC0JU01QTF9SRUcoQVgsIFBFUkZfUkVHX1g4Nl9BWCksCj4gLQlTTVBMX1JFRyhC WCwgUEVSRl9SRUdfWDg2X0JYKSwKPiAtCVNNUExfUkVHKENYLCBQRVJGX1JFR19YODZfQ1gpLAo+ IC0JU01QTF9SRUcoRFgsIFBFUkZfUkVHX1g4Nl9EWCksCj4gLQlTTVBMX1JFRyhTSSwgUEVSRl9S RUdfWDg2X1NJKSwKPiAtCVNNUExfUkVHKERJLCBQRVJGX1JFR19YODZfREkpLAo+IC0JU01QTF9S RUcoQlAsIFBFUkZfUkVHX1g4Nl9CUCksCj4gLQlTTVBMX1JFRyhTUCwgUEVSRl9SRUdfWDg2X1NQ KSwKPiAtCVNNUExfUkVHKElQLCBQRVJGX1JFR19YODZfSVApLAo+IC0JU01QTF9SRUcoRkxBR1Ms IFBFUkZfUkVHX1g4Nl9GTEFHUyksCj4gLQlTTVBMX1JFRyhDUywgUEVSRl9SRUdfWDg2X0NTKSwK PiAtCVNNUExfUkVHKFNTLCBQRVJGX1JFR19YODZfU1MpLAo+IC0jaWZkZWYgSEFWRV9BUkNIX1g4 Nl82NF9TVVBQT1JUCj4gLQlTTVBMX1JFRyhSOCwgUEVSRl9SRUdfWDg2X1I4KSwKPiAtCVNNUExf UkVHKFI5LCBQRVJGX1JFR19YODZfUjkpLAo+IC0JU01QTF9SRUcoUjEwLCBQRVJGX1JFR19YODZf UjEwKSwKPiAtCVNNUExfUkVHKFIxMSwgUEVSRl9SRUdfWDg2X1IxMSksCj4gLQlTTVBMX1JFRyhS MTIsIFBFUkZfUkVHX1g4Nl9SMTIpLAo+IC0JU01QTF9SRUcoUjEzLCBQRVJGX1JFR19YODZfUjEz KSwKPiAtCVNNUExfUkVHKFIxNCwgUEVSRl9SRUdfWDg2X1IxNCksCj4gLQlTTVBMX1JFRyhSMTUs IFBFUkZfUkVHX1g4Nl9SMTUpLAo+IC0jZW5kaWYKPiAtCVNNUExfUkVHMihYTU0wLCBQRVJGX1JF R19YODZfWE1NMCksCj4gLQlTTVBMX1JFRzIoWE1NMSwgUEVSRl9SRUdfWDg2X1hNTTEpLAo+IC0J U01QTF9SRUcyKFhNTTIsIFBFUkZfUkVHX1g4Nl9YTU0yKSwKPiAtCVNNUExfUkVHMihYTU0zLCBQ RVJGX1JFR19YODZfWE1NMyksCj4gLQlTTVBMX1JFRzIoWE1NNCwgUEVSRl9SRUdfWDg2X1hNTTQp LAo+IC0JU01QTF9SRUcyKFhNTTUsIFBFUkZfUkVHX1g4Nl9YTU01KSwKPiAtCVNNUExfUkVHMihY TU02LCBQRVJGX1JFR19YODZfWE1NNiksCj4gLQlTTVBMX1JFRzIoWE1NNywgUEVSRl9SRUdfWDg2 X1hNTTcpLAo+IC0JU01QTF9SRUcyKFhNTTgsIFBFUkZfUkVHX1g4Nl9YTU04KSwKPiAtCVNNUExf UkVHMihYTU05LCBQRVJGX1JFR19YODZfWE1NOSksCj4gLQlTTVBMX1JFRzIoWE1NMTAsIFBFUkZf UkVHX1g4Nl9YTU0xMCksCj4gLQlTTVBMX1JFRzIoWE1NMTEsIFBFUkZfUkVHX1g4Nl9YTU0xMSks Cj4gLQlTTVBMX1JFRzIoWE1NMTIsIFBFUkZfUkVHX1g4Nl9YTU0xMiksCj4gLQlTTVBMX1JFRzIo WE1NMTMsIFBFUkZfUkVHX1g4Nl9YTU0xMyksCj4gLQlTTVBMX1JFRzIoWE1NMTQsIFBFUkZfUkVH X1g4Nl9YTU0xNCksCj4gLQlTTVBMX1JFRzIoWE1NMTUsIFBFUkZfUkVHX1g4Nl9YTU0xNSksCj4g LQlTTVBMX1JFR19FTkQKPiAtfTsKPiAtCj4gIHN0cnVjdCBzZHRfbmFtZV9yZWcgewo+ICAJY29u c3QgY2hhciAqc2R0X25hbWU7Cj4gIAljb25zdCBjaGFyICp1cHJvYmVfbmFtZTsKPiBAQCAtMjc2 LDExICsyMzQsNiBAQCBpbnQgYXJjaF9zZHRfYXJnX3BhcnNlX29wKGNoYXIgKm9sZF9vcCwgY2hh ciAqKm5ld19vcCkKPiAgCXJldHVybiBTRFRfQVJHX1ZBTElEOwo+ICB9Cj4gIAo+IC1jb25zdCBz dHJ1Y3Qgc2FtcGxlX3JlZyAqYXJjaF9fc2FtcGxlX3JlZ19tYXNrcyh2b2lkKQo+IC17Cj4gLQly ZXR1cm4gc2FtcGxlX3JlZ19tYXNrczsKPiAtfQo+IC0KPiAgdWludDY0X3QgYXJjaF9faW50cl9y ZWdfbWFzayh2b2lkKQo+ICB7Cj4gIAlzdHJ1Y3QgcGVyZl9ldmVudF9hdHRyIGF0dHIgPSB7Cj4g ZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9hcm02NC1mcmFtZS1wb2ludGVyLXVud2luZC1z dXBwb3J0LmMgYi90b29scy9wZXJmL3V0aWwvYXJtNjQtZnJhbWUtcG9pbnRlci11bndpbmQtc3Vw cG9ydC5jCj4gaW5kZXggOTU4YWZlOGI4MjFlLi44NThjZTJiMDE4MTIgMTAwNjQ0Cj4gLS0tIGEv dG9vbHMvcGVyZi91dGlsL2FybTY0LWZyYW1lLXBvaW50ZXItdW53aW5kLXN1cHBvcnQuYwo+ICsr KyBiL3Rvb2xzL3BlcmYvdXRpbC9hcm02NC1mcmFtZS1wb2ludGVyLXVud2luZC1zdXBwb3J0LmMK PiBAQCAtMiw3ICsyLDYgQEAKPiAgI2luY2x1ZGUgImFybTY0LWZyYW1lLXBvaW50ZXItdW53aW5k LXN1cHBvcnQuaCIKPiAgI2luY2x1ZGUgImNhbGxjaGFpbi5oIgo+ICAjaW5jbHVkZSAiZXZlbnQu aCIKPiAtI2luY2x1ZGUgInBlcmZfcmVncy5oIiAvLyBTTVBMX1JFR19NQVNLCj4gICNpbmNsdWRl ICJ1bndpbmQuaCIKPiAgI2luY2x1ZGUgPHN0cmluZy5oPgo+ICAKPiBAQCAtMTUsNiArMTQsOCBA QCBzdHJ1Y3QgZW50cmllcyB7Cj4gIAlzaXplX3QgbGVuZ3RoOwo+ICB9Owo+ICAKPiArI2RlZmlu ZSBTTVBMX1JFR19NQVNLKGIpICgxVUxMIDw8IChiKSkKPiArCj4gIHN0YXRpYyBib29sIGdldF9s ZWFmX2ZyYW1lX2NhbGxlcl9lbmFibGVkKHN0cnVjdCBwZXJmX3NhbXBsZSAqc2FtcGxlKQo+ICB7 Cj4gIAlzdHJ1Y3QgcmVnc19kdW1wICpyZWdzOwo+IGRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0 aWwvcGFyc2UtcmVncy1vcHRpb25zLmMgYi90b29scy9wZXJmL3V0aWwvcGFyc2UtcmVncy1vcHRp b25zLmMKPiBpbmRleCBjZGExYzYyMDk2OGUuLmMwZDBlZjlmZDQ5NSAxMDA2NDQKPiAtLS0gYS90 b29scy9wZXJmL3V0aWwvcGFyc2UtcmVncy1vcHRpb25zLmMKPiArKysgYi90b29scy9wZXJmL3V0 aWwvcGFyc2UtcmVncy1vcHRpb25zLmMKPiBAQCAtNSwxNSArNSw1NCBAQAo+ICAjaW5jbHVkZSA8 c3RyaW5nLmg+Cj4gICNpbmNsdWRlIDxzdGRpby5oPgo+ICAjaW5jbHVkZSAidXRpbC9kZWJ1Zy5o Igo+ICsjaW5jbHVkZSA8ZHdhcmYtcmVncy5oPgo+ICAjaW5jbHVkZSA8c3ViY21kL3BhcnNlLW9w dGlvbnMuaD4KPiAgI2luY2x1ZGUgInV0aWwvcGVyZl9yZWdzLmgiCj4gICNpbmNsdWRlICJ1dGls L3BhcnNlLXJlZ3Mtb3B0aW9ucy5oIgo+ICAKPiArc3RhdGljIHZvaWQgbGlzdF9wZXJmX3JlZ3Mo RklMRSAqZnAsIHVpbnQ2NF90IG1hc2spCj4gK3sKPiArCWNvbnN0IGNoYXIgKmxhc3RfbmFtZSA9 IE5VTEw7Cj4gKwo+ICsJZnByaW50ZihmcCwgImF2YWlsYWJsZSByZWdpc3RlcnM6ICIpOwo+ICsJ Zm9yIChpbnQgcmVnID0gMDsgcmVnIDwgNjQ7IHJlZysrKSB7CgpDb3VsZCB3ZSBub3QgdXNlIHRo ZSBtYWdpYyBudW1iZXIgNjQ/IEl0J3Mgbm90IHNhZmUsIHRoZSBzdXBwb3J0ZWQgR1AKcmVnaXN0 ZXIgbnVtYmVyIGNvdWxkIGV4Y2VlZCA2NCBpbiB0aGUgZnV0dXJlLCB0aGVuIHRoZSBleGNlZWRl ZCByZWdpc3Rlcgp3b24ndCBiZSBpdGVyYXRlZC4KCkhvdyBhYm91dCB0aGlzPwoKZGlmZiAtLWdp dCBhL3Rvb2xzL3BlcmYvdXRpbC9wYXJzZS1yZWdzLW9wdGlvbnMuYwpiL3Rvb2xzL3BlcmYvdXRp bC9wYXJzZS1yZWdzLW9wdGlvbnMuYwppbmRleCBjMGQwZWY5ZmQ0OTUuLjUxNzcwMTZhN2FkNCAx MDA2NDQKLS0tIGEvdG9vbHMvcGVyZi91dGlsL3BhcnNlLXJlZ3Mtb3B0aW9ucy5jCisrKyBiL3Rv b2xzL3BlcmYvdXRpbC9wYXJzZS1yZWdzLW9wdGlvbnMuYwpAQCAtMTUsNyArMTUsNyBAQCBzdGF0 aWMgdm9pZCBsaXN0X3BlcmZfcmVncyhGSUxFICpmcCwgdWludDY0X3QgbWFzaykKwqAgwqAgwqAg wqAgY29uc3QgY2hhciAqbGFzdF9uYW1lID0gTlVMTDsKCsKgIMKgIMKgIMKgIGZwcmludGYoZnAs ICJhdmFpbGFibGUgcmVnaXN0ZXJzOiAiKTsKLcKgIMKgIMKgIMKgZm9yIChpbnQgcmVnID0gMDsg cmVnIDwgNjQ7IHJlZysrKSB7CivCoCDCoCDCoCDCoGZvciAodW5zaWduZWQgbG9uZyByZWcgPSAw OyByZWcgPCBzaXplb2YobWFzaykgKiBCSVRTX1BFUl9CWVRFOwpyZWcrKykgewrCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCBjb25zdCBjaGFyICpuYW1lOwoKwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg aWYgKCgoMVVMTCA8PCByZWcpICYgbWFzaykgPT0gMCkKCgo+ICsJCWNvbnN0IGNoYXIgKm5hbWU7 Cj4gKwo+ICsJCWlmICgoKDFVTEwgPDwgcmVnKSAmIG1hc2spID09IDApCj4gKwkJCWNvbnRpbnVl Owo+ICsKPiArCQluYW1lID0gcGVyZl9yZWdfbmFtZShyZWcsIEVNX0hPU1QpOwo+ICsJCWlmIChu YW1lICYmICghbGFzdF9uYW1lIHx8IHN0cmNtcChsYXN0X25hbWUsIG5hbWUpKSkKPiArCQkJZnBy aW50ZihmcCwgIiVzJXMiLCByZWcgPiAwID8gIiAiIDogIiIsIG5hbWUpOwo+ICsJCWxhc3RfbmFt ZSA9IG5hbWU7Cj4gKwl9Cj4gKwlmcHV0YygnXG4nLCBmcCk7Cj4gK30KPiArCj4gK3N0YXRpYyB1 aW50NjRfdCBuYW1lX3RvX3BlcmZfcmVnX21hc2soY29uc3QgY2hhciAqdG9fbWF0Y2gsIHVpbnQ2 NF90IG1hc2spCj4gK3sKPiArCXVpbnQ2NF90IHJlZ19tYXNrID0gMDsKPiArCj4gKwlmb3IgKGlu dCByZWcgPSAwOyByZWcgPCA2NDsgcmVnKyspIHsKCmRpdHRvLgoKCj4gKwkJY29uc3QgY2hhciAq bmFtZTsKPiArCj4gKwkJaWYgKCgoMVVMTCA8PCByZWcpICYgbWFzaykgPT0gMCkKPiArCQkJY29u dGludWU7Cj4gKwo+ICsJCW5hbWUgPSBwZXJmX3JlZ19uYW1lKHJlZywgRU1fSE9TVCk7Cj4gKwkJ aWYgKCFuYW1lKQo+ICsJCQljb250aW51ZTsKPiArCj4gKwkJaWYgKCFzdHJjYXNlY21wKHRvX21h dGNoLCBuYW1lKSkKPiArCQkJcmVnX21hc2sgfD0gMVVMTCA8PCByZWc7CgpIb3cgbXVjaCByZWdp c3RlciBuYW1lcyBhcmUgZXhwZWN0ZWQgdG8gbWF0Y2ggaGVyZT8gSXQgc2VlbXMgdGhlIGZ1bmN0 aW9uCmV4cGVjdHMgdG8gbWF0Y2ggb25seSBvbmUgcmVnaXN0ZXIgbmFtZS4gSWYgc28sIHdlIGNh biAiYnJlYWsiIGhlcmUuCgpUaGFua3MuCgoKPiArCX0KPiArCXJldHVybiByZWdfbWFzazsKPiAr fQo+ICsKPiAgc3RhdGljIGludAo+ICBfX3BhcnNlX3JlZ3MoY29uc3Qgc3RydWN0IG9wdGlvbiAq b3B0LCBjb25zdCBjaGFyICpzdHIsIGludCB1bnNldCwgYm9vbCBpbnRyKQo+ICB7Cj4gIAl1aW50 NjRfdCAqbW9kZSA9ICh1aW50NjRfdCAqKW9wdC0+dmFsdWU7Cj4gLQljb25zdCBzdHJ1Y3Qgc2Ft cGxlX3JlZyAqciA9IE5VTEw7Cj4gIAljaGFyICpzLCAqb3MgPSBOVUxMLCAqcDsKPiAgCWludCBy ZXQgPSAtMTsKPiAgCXVpbnQ2NF90IG1hc2s7Cj4gQEAgLTI3LDUwICs2Niw0MSBAQCBfX3BhcnNl X3JlZ3MoY29uc3Qgc3RydWN0IG9wdGlvbiAqb3B0LCBjb25zdCBjaGFyICpzdHIsIGludCB1bnNl dCwgYm9vbCBpbnRyKQo+ICAJaWYgKCptb2RlKQo+ICAJCXJldHVybiAtMTsKPiAgCj4gLQlpZiAo aW50cikKPiAtCQltYXNrID0gYXJjaF9faW50cl9yZWdfbWFzaygpOwo+IC0JZWxzZQo+IC0JCW1h c2sgPSBhcmNoX191c2VyX3JlZ19tYXNrKCk7Cj4gLQo+ICAJLyogc3RyIG1heSBiZSBOVUxMIGlu IGNhc2Ugbm8gYXJnIGlzIHBhc3NlZCB0byAtSSAqLwo+IC0JaWYgKHN0cikgewo+IC0JCS8qIGJl Y2F1c2Ugc3RyIGlzIHJlYWQtb25seSAqLwo+IC0JCXMgPSBvcyA9IHN0cmR1cChzdHIpOwo+IC0J CWlmICghcykKPiAtCQkJcmV0dXJuIC0xOwo+IC0KPiAtCQlmb3IgKDs7KSB7Cj4gLQkJCXAgPSBz dHJjaHIocywgJywnKTsKPiAtCQkJaWYgKHApCj4gLQkJCQkqcCA9ICdcMCc7Cj4gLQo+IC0JCQlp ZiAoIXN0cmNtcChzLCAiPyIpKSB7Cj4gLQkJCQlmcHJpbnRmKHN0ZGVyciwgImF2YWlsYWJsZSBy ZWdpc3RlcnM6ICIpOwo+IC0JCQkJZm9yIChyID0gYXJjaF9fc2FtcGxlX3JlZ19tYXNrcygpOyBy LT5uYW1lOyByKyspIHsKPiAtCQkJCQlpZiAoci0+bWFzayAmIG1hc2spCj4gLQkJCQkJCWZwcmlu dGYoc3RkZXJyLCAiJXMgIiwgci0+bmFtZSk7Cj4gLQkJCQl9Cj4gLQkJCQlmcHV0YygnXG4nLCBz dGRlcnIpOwo+IC0JCQkJLyoganVzdCBwcmludGluZyBhdmFpbGFibGUgcmVncyAqLwo+IC0JCQkJ Z290byBlcnJvcjsKPiAtCQkJfQo+IC0JCQlmb3IgKHIgPSBhcmNoX19zYW1wbGVfcmVnX21hc2tz KCk7IHItPm5hbWU7IHIrKykgewo+IC0JCQkJaWYgKChyLT5tYXNrICYgbWFzaykgJiYgIXN0cmNh c2VjbXAocywgci0+bmFtZSkpCj4gLQkJCQkJYnJlYWs7Cj4gLQkJCX0KPiAtCQkJaWYgKCFyIHx8 ICFyLT5uYW1lKSB7Cj4gLQkJCQl1aV9fd2FybmluZygiVW5rbm93biByZWdpc3RlciBcIiVzXCIs IGNoZWNrIG1hbiBwYWdlIG9yIHJ1biBcInBlcmYgcmVjb3JkICVzP1wiXG4iLAo+IC0JCQkJCSAg ICBzLCBpbnRyID8gIi1JIiA6ICItLXVzZXItcmVncz0iKTsKPiAtCQkJCWdvdG8gZXJyb3I7Cj4g LQkJCX0KPiAtCj4gLQkJCSptb2RlIHw9IHItPm1hc2s7Cj4gLQo+IC0JCQlpZiAoIXApCj4gLQkJ CQlicmVhazsKPiAtCj4gLQkJCXMgPSBwICsgMTsKPiArCWlmICghc3RyKQo+ICsJCXJldHVybiAt MTsKPiArCj4gKwltYXNrID0gaW50ciA/IGFyY2hfX2ludHJfcmVnX21hc2soKSA6IGFyY2hfX3Vz ZXJfcmVnX21hc2soKTsKPiArCj4gKwkvKiBiZWNhdXNlIHN0ciBpcyByZWFkLW9ubHkgKi8KPiAr CXMgPSBvcyA9IHN0cmR1cChzdHIpOwo+ICsJaWYgKCFzKQo+ICsJCXJldHVybiAtMTsKPiArCj4g Kwlmb3IgKDs7KSB7Cj4gKwkJdWludDY0X3QgcmVnX21hc2s7Cj4gKwo+ICsJCXAgPSBzdHJjaHIo cywgJywnKTsKPiArCQlpZiAocCkKPiArCQkJKnAgPSAnXDAnOwo+ICsKPiArCQlpZiAoIXN0cmNt cChzLCAiPyIpKSB7Cj4gKwkJCWxpc3RfcGVyZl9yZWdzKHN0ZGVyciwgbWFzayk7Cj4gKwkJCWdv dG8gZXJyb3I7Cj4gKwkJfQo+ICsKPiArCQlyZWdfbWFzayA9IG5hbWVfdG9fcGVyZl9yZWdfbWFz ayhzLCBtYXNrKTsKPiArCQlpZiAocmVnX21hc2sgPT0gMCkgewo+ICsJCQl1aV9fd2FybmluZygi VW5rbm93biByZWdpc3RlciBcIiVzXCIsIGNoZWNrIG1hbiBwYWdlIG9yIHJ1biBcInBlcmYgcmVj b3JkICVzP1wiXG4iLAo+ICsJCQkJcywgaW50ciA/ICItSSIgOiAiLS11c2VyLXJlZ3M9Iik7Cj4g KwkJCWdvdG8gZXJyb3I7Cj4gIAkJfQo+ICsJCSptb2RlIHw9IHJlZ19tYXNrOwo+ICsKPiArCQlp ZiAoIXApCj4gKwkJCWJyZWFrOwo+ICsKPiArCQlzID0gcCArIDE7Cj4gIAl9Cj4gIAlyZXQgPSAw Owo+ICAKPiBkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3BlcmZfcmVncy5jIGIvdG9vbHMv cGVyZi91dGlsL3BlcmZfcmVncy5jCj4gaW5kZXggYjU4ZDU5Yjg0ZmIxLi5lYzYwMmRhMWFlYjYg MTAwNjQ0Cj4gLS0tIGEvdG9vbHMvcGVyZi91dGlsL3BlcmZfcmVncy5jCj4gKysrIGIvdG9vbHMv cGVyZi91dGlsL3BlcmZfcmVncy5jCj4gQEAgLTIyLDE1ICsyMiw2IEBAIHVpbnQ2NF90IF9fd2Vh ayBhcmNoX191c2VyX3JlZ19tYXNrKHZvaWQpCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiAtc3Rh dGljIGNvbnN0IHN0cnVjdCBzYW1wbGVfcmVnIHNhbXBsZV9yZWdfbWFza3NbXSA9IHsKPiAtCVNN UExfUkVHX0VORAo+IC19Owo+IC0KPiAtY29uc3Qgc3RydWN0IHNhbXBsZV9yZWcgKiBfX3dlYWsg YXJjaF9fc2FtcGxlX3JlZ19tYXNrcyh2b2lkKQo+IC17Cj4gLQlyZXR1cm4gc2FtcGxlX3JlZ19t YXNrczsKPiAtfQo+IC0KPiAgY29uc3QgY2hhciAqcGVyZl9yZWdfbmFtZShpbnQgaWQsIHVpbnQx Nl90IGVfbWFjaGluZSkKPiAgewo+ICAJY29uc3QgY2hhciAqcmVnX25hbWUgPSBOVUxMOwo+IGRp ZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcGVyZl9yZWdzLmggYi90b29scy9wZXJmL3V0aWwv cGVyZl9yZWdzLmgKPiBpbmRleCA3YmZjNmEzNGMwMmIuLjJjMmE4ZGU2OTEyZCAxMDA2NDQKPiAt LS0gYS90b29scy9wZXJmL3V0aWwvcGVyZl9yZWdzLmgKPiArKysgYi90b29scy9wZXJmL3V0aWwv cGVyZl9yZWdzLmgKPiBAQCAtNywxNyArNyw2IEBACj4gIAo+ICBzdHJ1Y3QgcmVnc19kdW1wOwo+ ICAKPiAtc3RydWN0IHNhbXBsZV9yZWcgewo+IC0JY29uc3QgY2hhciAqbmFtZTsKPiAtCXVpbnQ2 NF90IG1hc2s7Cj4gLX07Cj4gLQo+IC0jZGVmaW5lIFNNUExfUkVHX01BU0soYikgKDFVTEwgPDwg KGIpKQo+IC0jZGVmaW5lIFNNUExfUkVHKG4sIGIpIHsgLm5hbWUgPSAjbiwgLm1hc2sgPSBTTVBM X1JFR19NQVNLKGIpIH0KPiAtI2RlZmluZSBTTVBMX1JFRzJfTUFTSyhiKSAoM1VMTCA8PCAoYikp Cj4gLSNkZWZpbmUgU01QTF9SRUcyKG4sIGIpIHsgLm5hbWUgPSAjbiwgLm1hc2sgPSBTTVBMX1JF RzJfTUFTSyhiKSB9Cj4gLSNkZWZpbmUgU01QTF9SRUdfRU5EIHsgLm5hbWUgPSBOVUxMIH0KPiAt Cj4gIGVudW0gewo+ICAJU0RUX0FSR19WQUxJRCA9IDAsCj4gIAlTRFRfQVJHX1NLSVAsCj4gQEAg LTI2LDcgKzE1LDYgQEAgZW51bSB7Cj4gIGludCBhcmNoX3NkdF9hcmdfcGFyc2Vfb3AoY2hhciAq b2xkX29wLCBjaGFyICoqbmV3X29wKTsKPiAgdWludDY0X3QgYXJjaF9faW50cl9yZWdfbWFzayh2 b2lkKTsKPiAgdWludDY0X3QgYXJjaF9fdXNlcl9yZWdfbWFzayh2b2lkKTsKPiAtY29uc3Qgc3Ry dWN0IHNhbXBsZV9yZWcgKmFyY2hfX3NhbXBsZV9yZWdfbWFza3Modm9pZCk7Cj4gIAo+ICBjb25z dCBjaGFyICpwZXJmX3JlZ19uYW1lKGludCBpZCwgdWludDE2X3QgZV9tYWNoaW5lKTsKPiAgaW50 IHBlcmZfcmVnX3ZhbHVlKHU2NCAqdmFscCwgc3RydWN0IHJlZ3NfZHVtcCAqcmVncywgaW50IGlk KTsKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4 LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6 Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcmlzY3YK