From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR04-HE1-obe.outbound.protection.outlook.com (mail-eopbgr70054.outbound.protection.outlook.com [40.107.7.54]) by sourceware.org (Postfix) with ESMTPS id 5B90F3854141 for ; Mon, 31 Oct 2022 11:34:51 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 5B90F3854141 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=arm.com ARC-Seal: i=2; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=pass; b=gkeXp+7dk15hafXsnjd0Jg2/s0f5+tt2ZSDG+OXdG7BcyJmj9UWRowRCUY++wTvNMvA62jAbw8CKUvw4O9/yD6/hqrsPd24ds66HDgext1EGyt05yL6HPJ3qOiTje0DukldCBczyZncgehyw0Tdyq86ztdFvlnoMOUKT+ski52+djPXgLgy9kS6H2Tpo4KcBqeRStUa2COhJB+VX4CvLk7v9+DaOvFIeessXdRfmNNZBsfB6uq3+oEam+xf5xawnGL45SJpjM5a44hJIkyLMehpaIhIgMk9c282lc6T6m1fGx2nPtAoawBvp8Nxy5PuKUUMiXvPwJOYgZ6/8nGCLpQ== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=kGOf5QUSBiruRVVby4zvTM8rMh/+krSj3ykfxAcmfwc=; b=IzvahKCbEK3h108yi2C+dax7XvhKwZsjre2TDoTkeuSlMlBo//fYBzKUVx0ZGSSg1Hfq5o6D6vp8F9rQoRWbv0DxrV6VxeerEBtmOzwfp6UlSSp0+vrjuEHxSd/6Neb5dW8Fw6eMpAW8zp1B9TRjWfMvqfHP9lBo6ryYV/fIvHT4sG9lglHptXLAZJnc4Fquxd037rElV1iC2D1O28/RnirsOcsl34RfaLL1fp8rfgPRBzBgIedmJ1BlHFVO9dkNz8GdITvouZ+WcUs5QBXGxZ2iOBy/NxwpOCMSi29PF7NWN/WXK7mvjX8uVbKNDXFYHQJQ38tUj86jAW5Fqt0/BA== ARC-Authentication-Results: i=2; mx.microsoft.com 1; spf=pass (sender ip is 63.35.35.123) smtp.rcpttodomain=gcc.gnu.org smtp.mailfrom=arm.com; dmarc=pass (p=none sp=none pct=100) action=none header.from=arm.com; dkim=pass (signature was verified) header.d=armh.onmicrosoft.com; arc=pass (0 oda=1 ltdi=1 spf=[1,1,smtp.mailfrom=arm.com] dkim=[1,1,header.d=arm.com] dmarc=[1,1,header.from=arm.com]) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=kGOf5QUSBiruRVVby4zvTM8rMh/+krSj3ykfxAcmfwc=; b=tBXoYmPzx/dGmGu8SVdwTCcPV/cMUaQldJ/4gt5o0dp9j0B3Pz7/wwXMzmvIevwpYB45haxgqqOGUKRWrMD2gdGBZL49YH5eOvOcGSL6ybJJIrLOmG8EQQVBQLSOcCeDVngWw7jegYPKufT70segqdcodBXpRdU0w6V8EIK3oxI= Received: from DB9PR06CA0030.eurprd06.prod.outlook.com (2603:10a6:10:1db::35) by PAXPR08MB7396.eurprd08.prod.outlook.com (2603:10a6:102:2ba::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5769.15; Mon, 31 Oct 2022 11:34:48 +0000 Received: from DBAEUR03FT058.eop-EUR03.prod.protection.outlook.com (2603:10a6:10:1db:cafe::a8) by DB9PR06CA0030.outlook.office365.com (2603:10a6:10:1db::35) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5769.19 via Frontend Transport; Mon, 31 Oct 2022 11:34:48 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 63.35.35.123) smtp.mailfrom=arm.com; dkim=pass (signature was verified) header.d=armh.onmicrosoft.com;dmarc=pass action=none header.from=arm.com; Received-SPF: Pass (protection.outlook.com: domain of arm.com designates 63.35.35.123 as permitted sender) receiver=protection.outlook.com; client-ip=63.35.35.123; helo=64aa7808-outbound-1.mta.getcheckrecipient.com; pr=C Received: from 64aa7808-outbound-1.mta.getcheckrecipient.com (63.35.35.123) by DBAEUR03FT058.mail.protection.outlook.com (100.127.142.120) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5769.14 via Frontend Transport; Mon, 31 Oct 2022 11:34:47 +0000 Received: ("Tessian outbound b4aebcc5bc64:v130"); Mon, 31 Oct 2022 11:34:47 +0000 X-CR-MTA-TID: 64aa7808 Received: from 6e5601e33af9.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id 0790814A-E18B-4AE0-A5DC-D84C1D340D53.1; Mon, 31 Oct 2022 11:34:41 +0000 Received: from EUR04-DB3-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id 6e5601e33af9.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Mon, 31 Oct 2022 11:34:41 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=R4g3Kdchq3vsBfRCyb3SYiGq/JX/3QNKnEJIyUZeZcR86N2RiKFzg9UK3yOEY6Iy8VMOfVqJPLJX1RgzD+kVbfYm1CTQqx+zmeCAEk8vuu+K3PKilGs4PXeoPZCrZoqG+xtaWfNk5P4fhul+qcblVX4gKDmYnlN0pxGhwr2kEEdS/9XD5+JguYk0+Os69ccuYpcOTapJLpePOvzOMxcB2+sG5Fq+qPMLt1h16cP+md2BfRYYJHI/Ho4fIgnZVFqlH4fMObaj4n6GqpKHgg+C2WzHY0jVg+NbFCfDfWd2A3gTn/XmYqx1USDYSGbW2gKbw3KT/n4WQrzPjz6ezrevVg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=kGOf5QUSBiruRVVby4zvTM8rMh/+krSj3ykfxAcmfwc=; b=SOTXq1vk0nUPstmN67LcUFHXav9WdTqkyDJX7e29BG16/sP0SlloSvkhN0ePLhtk4PeMCVcmU6QQuVwdZ4ynXE/6WApGoW8LHZaRg2+O1ZVQTYnnSbSS7uFB1qLA8m56XgTo2F5TUHhQxHFkVNXyQxzIe8tuAQbEzwQUCTTOMkf7qruXQvzrrjTQb8u3fXWc6zzWFggOCRMSKaWyqoFBJsb9KBUmlnu/NRRDtRZRcdWmXuJaDwIHTt3KO2Z0l8P/nGfRwt/p44wrRgI5JyvcHJ0rloXaz8T0voz9QIag952uhgG3YtLvj6RQKsukeih2lbK3r7I57oPYEULzAaQH+g== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=arm.com; dmarc=pass action=none header.from=arm.com; dkim=pass header.d=arm.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=kGOf5QUSBiruRVVby4zvTM8rMh/+krSj3ykfxAcmfwc=; b=tBXoYmPzx/dGmGu8SVdwTCcPV/cMUaQldJ/4gt5o0dp9j0B3Pz7/wwXMzmvIevwpYB45haxgqqOGUKRWrMD2gdGBZL49YH5eOvOcGSL6ybJJIrLOmG8EQQVBQLSOcCeDVngWw7jegYPKufT70segqdcodBXpRdU0w6V8EIK3oxI= Received: from VI1PR08MB5325.eurprd08.prod.outlook.com (2603:10a6:803:13e::17) by AS8PR08MB6056.eurprd08.prod.outlook.com (2603:10a6:20b:299::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5769.19; Mon, 31 Oct 2022 11:34:39 +0000 Received: from VI1PR08MB5325.eurprd08.prod.outlook.com ([fe80::c57d:50c2:3502:a52]) by VI1PR08MB5325.eurprd08.prod.outlook.com ([fe80::c57d:50c2:3502:a52%4]) with mapi id 15.20.5769.019; Mon, 31 Oct 2022 11:34:39 +0000 From: Tamar Christina To: Richard Biener CC: "gcc-patches@gcc.gnu.org" , nd , "jeffreyalaw@gmail.com" Subject: RE: [PATCH 1/4]middle-end Support not decomposing specific divisions during vectorization. Thread-Topic: [PATCH 1/4]middle-end Support not decomposing specific divisions during vectorization. Thread-Index: AQHY0ZRWEd9J41klKUyTQhS2iUxjL64olabA Date: Mon, 31 Oct 2022 11:34:39 +0000 Message-ID: References: In-Reply-To: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: yes X-MS-TNEF-Correlator: x-ts-tracking-id: 57DC9B9207BD314689EDB4E88CD088FC.0 x-checkrecipientchecked: true Authentication-Results-Original: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=arm.com; x-ms-traffictypediagnostic: VI1PR08MB5325:EE_|AS8PR08MB6056:EE_|DBAEUR03FT058:EE_|PAXPR08MB7396:EE_ X-MS-Office365-Filtering-Correlation-Id: d18a5963-5c6a-489e-269e-08dabb33ea8a x-checkrecipientrouted: true nodisclaimer: true X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam-Untrusted: BCL:0; X-Microsoft-Antispam-Message-Info-Original: Pzb5gMFj0C9QuiFam4Fqn9DIKJSWp0pVhqE6ICr6OvtelR6rbcEoJ/Rz87u9WaudmCsTdHraRYD0wWglaCIqqTMLn/YMRHFCKXUkGnmYCle+qE/fClrQeQogUSzQgp1XxS7AwtpMR4++zHLlygDUiyYztGCL2W29znSJVMqIbxBSINtImP5kHP6REGg5sAkbn99v9y6zdkcyVzpK/4gpLnfEjmt2fyVqGCvZBkIeC9BZ3k7AZq2LD6SQQu+acQbLtP0BWXjHWEaMuXDOtspcVWaIdYsEGh1NeSTUmibP2AdwLQgkCUN3N3OVXoubcFHufMiJrrY3Q2Et9NERlqgySk8/tpUKxDUP5lVZJGyOXkeSvitk4jO6LtGCgdUwcSnL/0gdGe+KWCgb98W4ZvGJdoAy7AaCGHizSWBVA5K873nlLtJJpfHPJnN9zHouMq4XVHDevD8FrxMbBgZGvqZnSmJy552a8VOa3C8therg+GyMhn8m+mb5obmNVrOSXVoQCOPQrhA6L25QJbP1v+ZmfL1CClqsn2qOyVFv+uwFzW9iJ7jLQUp5JoS4Oy3Zn9+SpCLFfUOn6hdVRUFqH4sKRa7ZPClHIlhrmDpQAYUk+tsXTgKaqVhbAxwlstyIhhxCC13wobrAtiZPAhVEB47m4SN9WocoGSBX8CufE/42ajrkbYa9v4OBGZt+eqeoqmIwsWk0WV2tk2qBuIVFOw/xcoODOsTyQvSGOJaTD4Y8mzruwERlEdOR5eSC2b/DDpAG9uzQdS/XTWlhBG3TIJgfo/XGhxoLEXQmdXG+ovNaOB4J++Rf+7QIJ//JbfOfI3SD+0q2JLtZ5BAKZqMyjZS1wA== X-Forefront-Antispam-Report-Untrusted: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:VI1PR08MB5325.eurprd08.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230022)(4636009)(39860400002)(396003)(346002)(136003)(376002)(366004)(451199015)(83380400001)(86362001)(38070700005)(33656002)(30864003)(38100700002)(122000001)(99936003)(5660300002)(52536014)(2906002)(66476007)(66556008)(64756008)(66446008)(41300700001)(8936002)(4326008)(76116006)(6506007)(7696005)(26005)(66946007)(9686003)(186003)(54906003)(6916009)(316002)(478600001)(71200400001)(55016003)(8676002)(84970400001)(579004);DIR:OUT;SFP:1101; Content-Type: multipart/mixed; boundary="_002_VI1PR08MB5325C56878364315686EBD99FF379VI1PR08MB5325eurp_" MIME-Version: 1.0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR08MB6056 Original-Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=arm.com; X-EOPAttributedMessage: 0 X-MS-Exchange-Transport-CrossTenantHeadersStripped: DBAEUR03FT058.eop-EUR03.prod.protection.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: 7acf650c-3362-46fa-0453-08dabb33e567 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: nbKGeEbnLLZd6KVfLrL2PMWgLNorVuFucTa9Eu92Qptfii+Ce6MYGuHLDhL7n9F1DLn7CI8ENwhWp9o7zqouos5y0joBgRtNMgTTeB6/JUpUu20tBrycB+z5NHnX/jQT4wfBT8JrvlOUz5LICPGgAs8AbNhFShEKFtHxOIaXfaM51JTm1LFk3FTLXt9tN9wytKNx0lOeOZSCR8pf5lnZHwTBUDHGY8Im086Q6od0xmwAIlCcMDZEIftrSchr5dQ9oU0mdBqGRPda6ID5zjmxeYF46lBk9P15O0TE/mIqLjgtDESk8pwn32GIdbkgKeaYvPohivJXKMfM8BrFmfbL73YIeb60XZA0F4lK3ZZ4vSO7JrxITAs8dj+WIs4Khiq/LrGaMTAkBv5tJtRyz+VfekB+yBJeQxbhVKYG39miBQMBIEliIfgyClPjd5Yr1pyL1Maxpip2Sur0KpZC+KvWihWtwBDah7pbYf6H53VE3Q9oxT9PeQeqhJ/S5mtuTqzAoUDqDuLatnABCt6RwODwVOGE3WXgZMnGXKQB7miTbg08ltrjFGa5So/ea8rFNhS85+Ep/w6cH6uB/uy0UJ5otqMk9yXg2kM0ZlXqdITwYKVoZlZW7KUSJ+o2Ez9H7HdzTwwmkJq3Rscqv2oZxUq7RuEVPp9z+IOhXAPwD0MA6KBdA9+wLbMhSPseuEiYIEPsm8KO0aWThl/tqcFWBVhJT1Bbnjwhq+SwavaP4OTD0xR6GCMHoaQB0p270KAKWXgahMO7YlfezDJpSitGez7CZKCE3M5jxHJCj1M5vdXFzXFSbdKlJdvd+glN1kkaKO8EV9yjBB1TATsKLhq1qralVdPTi04xziZtPGz7sK39aR4= X-Forefront-Antispam-Report: CIP:63.35.35.123;CTRY:IE;LANG:en;SCL:1;SRV:;IPV:CAL;SFV:NSPM;H:64aa7808-outbound-1.mta.getcheckrecipient.com;PTR:ec2-63-35-35-123.eu-west-1.compute.amazonaws.com;CAT:NONE;SFS:(13230022)(4636009)(346002)(136003)(376002)(39860400002)(396003)(451199015)(46966006)(36840700001)(40470700004)(86362001)(33656002)(84970400001)(99936003)(81166007)(356005)(82740400003)(2906002)(47076005)(36860700001)(40460700003)(55016003)(40480700001)(107886003)(478600001)(26005)(9686003)(336012)(83380400001)(186003)(6506007)(7696005)(6862004)(8676002)(316002)(54906003)(70206006)(5660300002)(235185007)(70586007)(4326008)(41300700001)(8936002)(82310400005)(52536014)(30864003);DIR:OUT;SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 31 Oct 2022 11:34:47.8995 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: d18a5963-5c6a-489e-269e-08dabb33ea8a X-MS-Exchange-CrossTenant-Id: f34e5979-57d9-4aaa-ad4d-b122a662184d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=f34e5979-57d9-4aaa-ad4d-b122a662184d;Ip=[63.35.35.123];Helo=[64aa7808-outbound-1.mta.getcheckrecipient.com] X-MS-Exchange-CrossTenant-AuthSource: DBAEUR03FT058.eop-EUR03.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXPR08MB7396 X-Spam-Status: No, score=-12.4 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,FORGED_SPF_HELO,GIT_PATCH_0,KAM_DMARC_NONE,KAM_LOTSOFHASH,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_PASS,SPF_NONE,TXREP,UNPARSEABLE_RELAY autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: --_002_VI1PR08MB5325C56878364315686EBD99FF379VI1PR08MB5325eurp_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable >=20 > The type of the expression should be available via the mode and the > signedness, no? So maybe to avoid having both RTX and TREE on the target > hook pass it a wide_int instead for the divisor? >=20 Done. Bootstrapped Regtested on aarch64-none-linux-gnu, x86_64-pc-linux-gnu and no issues. Ok for master? Thanks, Tamar gcc/ChangeLog: * expmed.h (expand_divmod): Pass tree operands down in addition to RTX. * expmed.cc (expand_divmod): Likewise. * explow.cc (round_push, align_dynamic_address): Likewise. * expr.cc (force_operand, expand_expr_divmod): Likewise. * optabs.cc (expand_doubleword_mod, expand_doubleword_divmod): Likewise. * target.h: Include tree-core. * target.def (can_special_div_by_const): New. * targhooks.cc (default_can_special_div_by_const): New. * targhooks.h (default_can_special_div_by_const): New. * tree-vect-generic.cc (expand_vector_operation): Use it. * doc/tm.texi.in: Document it. * doc/tm.texi: Regenerate. * tree-vect-patterns.cc (vect_recog_divmod_pattern): Check for support. * tree-vect-stmts.cc (vectorizable_operation): Likewise. gcc/testsuite/ChangeLog: * gcc.dg/vect/vect-div-bitmask-1.c: New test. * gcc.dg/vect/vect-div-bitmask-2.c: New test. * gcc.dg/vect/vect-div-bitmask-3.c: New test. * gcc.dg/vect/vect-div-bitmask.h: New file. --- inline copy of patch --- diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index 92bda1a7e14a3c9ea63e151e4a49a818bf4d1bdb..a29f5c39be3f0927f8ef6e094c7= a712c0604fb77 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -6112,6 +6112,22 @@ instruction pattern. There is no need for the hook = to handle these two implementation approaches itself. @end deftypefn =20 +@deftypefn {Target Hook} bool TARGET_VECTORIZE_CAN_SPECIAL_DIV_BY_CONST (e= num @var{tree_code}, tree @var{vectype}, wide_int @var{constant}, rtx *@var= {output}, rtx @var{in0}, rtx @var{in1}) +This hook is used to test whether the target has a special method of +division of vectors of type @var{vectype} using the value @var{constant}, +and producing a vector of type @var{vectype}. The division +will then not be decomposed by the and kept as a div. + +When the hook is being used to test whether the target supports a special +divide, @var{in0}, @var{in1}, and @var{output} are all null. When the hoo= k +is being used to emit a division, @var{in0} and @var{in1} are the source +vectors of type @var{vecttype} and @var{output} is the destination vector = of +type @var{vectype}. + +Return true if the operation is possible, emitting instructions for it +if rtxes are provided and updating @var{output}. +@end deftypefn + @deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION= (unsigned @var{code}, tree @var{vec_type_out}, tree @var{vec_type_in}) This hook should return the decl of a function that implements the vectorized variant of the function with the @code{combined_fn} code diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index 112462310b134705d860153294287cfd7d4af81d..d5a745a02acdf051ea1da1b0407= 6d058c24ce093 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -4164,6 +4164,8 @@ address; but often a machine-dependent strategy can = generate better code. =20 @hook TARGET_VECTORIZE_VEC_PERM_CONST =20 +@hook TARGET_VECTORIZE_CAN_SPECIAL_DIV_BY_CONST + @hook TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION =20 @hook TARGET_VECTORIZE_BUILTIN_MD_VECTORIZED_FUNCTION diff --git a/gcc/explow.cc b/gcc/explow.cc index ddb4d6ae3600542f8d2bb5617cdd3933a9fae6c0..568e0eb1a158c696458ae678f5e= 346bf34ba0036 100644 --- a/gcc/explow.cc +++ b/gcc/explow.cc @@ -1037,7 +1037,7 @@ round_push (rtx size) TRUNC_DIV_EXPR. */ size =3D expand_binop (Pmode, add_optab, size, alignm1_rtx, NULL_RTX, 1, OPTAB_LIB_WIDEN); - size =3D expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, align_rtx, + size =3D expand_divmod (0, TRUNC_DIV_EXPR, Pmode, NULL, NULL, size, alig= n_rtx, NULL_RTX, 1); size =3D expand_mult (Pmode, size, align_rtx, NULL_RTX, 1); =20 @@ -1203,7 +1203,7 @@ align_dynamic_address (rtx target, unsigned required_= align) gen_int_mode (required_align / BITS_PER_UNIT - 1, Pmode), NULL_RTX, 1, OPTAB_LIB_WIDEN); - target =3D expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target, + target =3D expand_divmod (0, TRUNC_DIV_EXPR, Pmode, NULL, NULL, target, gen_int_mode (required_align / BITS_PER_UNIT, Pmode), NULL_RTX, 1); diff --git a/gcc/expmed.h b/gcc/expmed.h index 0b2538c4c6bd51dfdc772ef70bdf631c0bed8717..0db2986f11ff4a4b10b59501c6f= 33cb3595659b5 100644 --- a/gcc/expmed.h +++ b/gcc/expmed.h @@ -708,8 +708,9 @@ extern rtx expand_variable_shift (enum tree_code, machi= ne_mode, extern rtx expand_shift (enum tree_code, machine_mode, rtx, poly_int64, rt= x, int); #ifdef GCC_OPTABS_H -extern rtx expand_divmod (int, enum tree_code, machine_mode, rtx, rtx, - rtx, int, enum optab_methods =3D OPTAB_LIB_WIDEN); +extern rtx expand_divmod (int, enum tree_code, machine_mode, tree, tree, + rtx, rtx, rtx, int, + enum optab_methods =3D OPTAB_LIB_WIDEN); #endif #endif =20 diff --git a/gcc/expmed.cc b/gcc/expmed.cc index 8d7418be418406e72a895ecddf2dc7fdb950c76c..bab020c07222afa38305ef8d733= 3f271b1965b78 100644 --- a/gcc/expmed.cc +++ b/gcc/expmed.cc @@ -4222,8 +4222,8 @@ expand_sdiv_pow2 (scalar_int_mode mode, rtx op0, HOST= _WIDE_INT d) =20 rtx expand_divmod (int rem_flag, enum tree_code code, machine_mode mode, - rtx op0, rtx op1, rtx target, int unsignedp, - enum optab_methods methods) + tree treeop0, tree treeop1, rtx op0, rtx op1, rtx target, + int unsignedp, enum optab_methods methods) { machine_mode compute_mode; rtx tquotient; @@ -4375,6 +4375,17 @@ expand_divmod (int rem_flag, enum tree_code code, ma= chine_mode mode, =20 last_div_const =3D ! rem_flag && op1_is_constant ? INTVAL (op1) : 0; =20 + /* Check if the target has specific expansions for the division. */ + tree cst; + if (treeop0 + && treeop1 + && (cst =3D uniform_integer_cst_p (treeop1)) + && targetm.vectorize.can_special_div_by_const (code, TREE_TYPE (tree= op0), + wi::to_wide (cst), + &target, op0, op1)) + return target; + + /* Now convert to the best mode to use. */ if (compute_mode !=3D mode) { @@ -4618,8 +4629,8 @@ expand_divmod (int rem_flag, enum tree_code code, mac= hine_mode mode, || (optab_handler (sdivmod_optab, int_mode) !=3D CODE_FOR_nothing))) quotient =3D expand_divmod (0, TRUNC_DIV_EXPR, - int_mode, op0, - gen_int_mode (abs_d, + int_mode, treeop0, treeop1, + op0, gen_int_mode (abs_d, int_mode), NULL_RTX, 0); else @@ -4808,8 +4819,8 @@ expand_divmod (int rem_flag, enum tree_code code, mac= hine_mode mode, size - 1, NULL_RTX, 0); t3 =3D force_operand (gen_rtx_MINUS (int_mode, t1, nsign), NULL_RTX); - t4 =3D expand_divmod (0, TRUNC_DIV_EXPR, int_mode, t3, op1, - NULL_RTX, 0); + t4 =3D expand_divmod (0, TRUNC_DIV_EXPR, int_mode, treeop0, + treeop1, t3, op1, NULL_RTX, 0); if (t4) { rtx t5; diff --git a/gcc/expr.cc b/gcc/expr.cc index 80bb1b8a4c5b8350fb1b8f57a99fd52e5882fcb6..b786f1d75e25f3410c0640cd96a= 8abc055fa34d9 100644 --- a/gcc/expr.cc +++ b/gcc/expr.cc @@ -8028,16 +8028,17 @@ force_operand (rtx value, rtx target) return expand_divmod (0, FLOAT_MODE_P (GET_MODE (value)) ? RDIV_EXPR : TRUNC_DIV_EXPR, - GET_MODE (value), op1, op2, target, 0); + GET_MODE (value), NULL, NULL, op1, op2, + target, 0); case MOD: - return expand_divmod (1, TRUNC_MOD_EXPR, GET_MODE (value), op1, op2, - target, 0); + return expand_divmod (1, TRUNC_MOD_EXPR, GET_MODE (value), NULL, NULL, + op1, op2, target, 0); case UDIV: - return expand_divmod (0, TRUNC_DIV_EXPR, GET_MODE (value), op1, op2, - target, 1); + return expand_divmod (0, TRUNC_DIV_EXPR, GET_MODE (value), NULL, NULL, + op1, op2, target, 1); case UMOD: - return expand_divmod (1, TRUNC_MOD_EXPR, GET_MODE (value), op1, op2, - target, 1); + return expand_divmod (1, TRUNC_MOD_EXPR, GET_MODE (value), NULL, NULL, + op1, op2, target, 1); case ASHIFTRT: return expand_simple_binop (GET_MODE (value), code, op1, op2, target, 0, OPTAB_LIB_WIDEN); @@ -8990,11 +8991,13 @@ expand_expr_divmod (tree_code code, machine_mode mo= de, tree treeop0, bool speed_p =3D optimize_insn_for_speed_p (); do_pending_stack_adjust (); start_sequence (); - rtx uns_ret =3D expand_divmod (mod_p, code, mode, op0, op1, target, = 1); + rtx uns_ret =3D expand_divmod (mod_p, code, mode, treeop0, treeop1, + op0, op1, target, 1); rtx_insn *uns_insns =3D get_insns (); end_sequence (); start_sequence (); - rtx sgn_ret =3D expand_divmod (mod_p, code, mode, op0, op1, target, = 0); + rtx sgn_ret =3D expand_divmod (mod_p, code, mode, treeop0, treeop1, + op0, op1, target, 0); rtx_insn *sgn_insns =3D get_insns (); end_sequence (); unsigned uns_cost =3D seq_cost (uns_insns, speed_p); @@ -9016,7 +9019,8 @@ expand_expr_divmod (tree_code code, machine_mode mode= , tree treeop0, emit_insn (sgn_insns); return sgn_ret; } - return expand_divmod (mod_p, code, mode, op0, op1, target, unsignedp); + return expand_divmod (mod_p, code, mode, treeop0, treeop1, + op0, op1, target, unsignedp); } =20 rtx diff --git a/gcc/optabs.cc b/gcc/optabs.cc index 165f8d1fa22432b96967c69a58dbb7b4bf18120d..cff37ccb0dfc3dd79b97d0abfd8= 72f340855dc96 100644 --- a/gcc/optabs.cc +++ b/gcc/optabs.cc @@ -1104,8 +1104,9 @@ expand_doubleword_mod (machine_mode mode, rtx op0, rt= x op1, bool unsignedp) return NULL_RTX; } } - rtx remainder =3D expand_divmod (1, TRUNC_MOD_EXPR, word_mode, sum, - gen_int_mode (INTVAL (op1), word_mode), + rtx remainder =3D expand_divmod (1, TRUNC_MOD_EXPR, word_mode, NULL,= NULL, + sum, gen_int_mode (INTVAL (op1), + word_mode), NULL_RTX, 1, OPTAB_DIRECT); if (remainder =3D=3D NULL_RTX) return NULL_RTX; @@ -1208,8 +1209,8 @@ expand_doubleword_divmod (machine_mode mode, rtx op0,= rtx op1, rtx *rem, =20 if (op11 !=3D const1_rtx) { - rtx rem2 =3D expand_divmod (1, TRUNC_MOD_EXPR, mode, quot1, op11, - NULL_RTX, unsignedp, OPTAB_DIRECT); + rtx rem2 =3D expand_divmod (1, TRUNC_MOD_EXPR, mode, NULL, NULL, quo= t1, + op11, NULL_RTX, unsignedp, OPTAB_DIRECT); if (rem2 =3D=3D NULL_RTX) return NULL_RTX; =20 @@ -1223,8 +1224,8 @@ expand_doubleword_divmod (machine_mode mode, rtx op0,= rtx op1, rtx *rem, if (rem2 =3D=3D NULL_RTX) return NULL_RTX; =20 - rtx quot2 =3D expand_divmod (0, TRUNC_DIV_EXPR, mode, quot1, op11, - NULL_RTX, unsignedp, OPTAB_DIRECT); + rtx quot2 =3D expand_divmod (0, TRUNC_DIV_EXPR, mode, NULL, NULL, qu= ot1, + op11, NULL_RTX, unsignedp, OPTAB_DIRECT); if (quot2 =3D=3D NULL_RTX) return NULL_RTX; =20 diff --git a/gcc/target.def b/gcc/target.def index 2a7fa68f83dd15dcdd2c332e8431e6142ec7d305..f491e2233cf18760631f148dacf= 18d0e0b133e4c 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -1902,6 +1902,25 @@ implementation approaches itself.", const vec_perm_indices &sel), NULL) =20 +DEFHOOK +(can_special_div_by_const, + "This hook is used to test whether the target has a special method of\n\ +division of vectors of type @var{vectype} using the value @var{constant},\= n\ +and producing a vector of type @var{vectype}. The division\n\ +will then not be decomposed by the and kept as a div.\n\ +\n\ +When the hook is being used to test whether the target supports a special\= n\ +divide, @var{in0}, @var{in1}, and @var{output} are all null. When the hoo= k\n\ +is being used to emit a division, @var{in0} and @var{in1} are the source\n= \ +vectors of type @var{vecttype} and @var{output} is the destination vector = of\n\ +type @var{vectype}.\n\ +\n\ +Return true if the operation is possible, emitting instructions for it\n\ +if rtxes are provided and updating @var{output}.", + bool, (enum tree_code, tree vectype, wide_int constant, rtx *output, + rtx in0, rtx in1), + default_can_special_div_by_const) + /* Return true if the target supports misaligned store/load of a specific factor denoted in the third parameter. The last parameter is true if the access is defined in a packed struct. */ diff --git a/gcc/target.h b/gcc/target.h index d6fa6931499d15edff3e5af3e429540d001c7058..c836036ac7fa7910d62bd3da56f= 39c061f68b665 100644 --- a/gcc/target.h +++ b/gcc/target.h @@ -51,6 +51,7 @@ #include "insn-codes.h" #include "tm.h" #include "hard-reg-set.h" +#include "tree-core.h" =20 #if CHECKING_P =20 diff --git a/gcc/targhooks.h b/gcc/targhooks.h index ecce55ebe797cedc940620e8d89816973a045d49..c8df2af02b9d8c41d953b7887dd= 980b1a7c5cf1c 100644 --- a/gcc/targhooks.h +++ b/gcc/targhooks.h @@ -207,6 +207,8 @@ extern void default_addr_space_diagnose_usage (addr_spa= ce_t, location_t); extern rtx default_addr_space_convert (rtx, tree, tree); extern unsigned int default_case_values_threshold (void); extern bool default_have_conditional_execution (void); +extern bool default_can_special_div_by_const (enum tree_code, tree, wide_i= nt, + rtx *, rtx, rtx); =20 extern bool default_libc_has_function (enum function_class, tree); extern bool default_libc_has_fast_function (int fcode); diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc index b15ae19bcb60c59ae8112e67b5f06a241a9bdbf1..f941b1c218d3c4de8b7f780b69f= e04593ae3419e 100644 --- a/gcc/targhooks.cc +++ b/gcc/targhooks.cc @@ -1807,6 +1807,14 @@ default_have_conditional_execution (void) return HAVE_conditional_execution; } =20 +/* Default that no division by constant operations are special. */ +bool +default_can_special_div_by_const (enum tree_code, tree, wide_int, rtx *, r= tx, + rtx) +{ + return false; +} + /* By default we assume that c99 functions are present at the runtime, but sincos is not. */ bool diff --git a/gcc/testsuite/gcc.dg/vect/vect-div-bitmask-1.c b/gcc/testsuite= /gcc.dg/vect/vect-div-bitmask-1.c new file mode 100644 index 0000000000000000000000000000000000000000..472cd710534bc8aa9b1b4916f3d= 7b4d5b64a19b9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-div-bitmask-1.c @@ -0,0 +1,25 @@ +/* { dg-require-effective-target vect_int } */ + +#include +#include "tree-vect.h" + +#define N 50 +#define TYPE uint8_t=20 + +__attribute__((noipa, noinline, optimize("O1"))) +void fun1(TYPE* restrict pixel, TYPE level, int n) +{ + for (int i =3D 0; i < n; i+=3D1) + pixel[i] =3D (pixel[i] * level) / 0xff; +} + +__attribute__((noipa, noinline, optimize("O3"))) +void fun2(TYPE* restrict pixel, TYPE level, int n) +{ + for (int i =3D 0; i < n; i+=3D1) + pixel[i] =3D (pixel[i] * level) / 0xff; +} + +#include "vect-div-bitmask.h" + +/* { dg-final { scan-tree-dump-not "vect_recog_divmod_pattern: detected" "= vect" { target aarch64*-*-* } } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-div-bitmask-2.c b/gcc/testsuite= /gcc.dg/vect/vect-div-bitmask-2.c new file mode 100644 index 0000000000000000000000000000000000000000..e904a71885b2e8487593a2cd3db= 75b3e4112e2cc --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-div-bitmask-2.c @@ -0,0 +1,25 @@ +/* { dg-require-effective-target vect_int } */ + +#include +#include "tree-vect.h" + +#define N 50 +#define TYPE uint16_t=20 + +__attribute__((noipa, noinline, optimize("O1"))) +void fun1(TYPE* restrict pixel, TYPE level, int n) +{ + for (int i =3D 0; i < n; i+=3D1) + pixel[i] =3D (pixel[i] * level) / 0xffffU; +} + +__attribute__((noipa, noinline, optimize("O3"))) +void fun2(TYPE* restrict pixel, TYPE level, int n) +{ + for (int i =3D 0; i < n; i+=3D1) + pixel[i] =3D (pixel[i] * level) / 0xffffU; +} + +#include "vect-div-bitmask.h" + +/* { dg-final { scan-tree-dump-not "vect_recog_divmod_pattern: detected" "= vect" { target aarch64*-*-* } } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-div-bitmask-3.c b/gcc/testsuite= /gcc.dg/vect/vect-div-bitmask-3.c new file mode 100644 index 0000000000000000000000000000000000000000..a1418ebbf5ea8731ed4e3e72015= 7701d9d1cf852 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-div-bitmask-3.c @@ -0,0 +1,26 @@ +/* { dg-require-effective-target vect_int } */ +/* { dg-additional-options "-fno-vect-cost-model" { target aarch64*-*-* } = } */ + +#include +#include "tree-vect.h" + +#define N 50 +#define TYPE uint32_t=20 + +__attribute__((noipa, noinline, optimize("O1"))) +void fun1(TYPE* restrict pixel, TYPE level, int n) +{ + for (int i =3D 0; i < n; i+=3D1) + pixel[i] =3D (pixel[i] * (uint64_t)level) / 0xffffffffUL; +} + +__attribute__((noipa, noinline, optimize("O3"))) +void fun2(TYPE* restrict pixel, TYPE level, int n) +{ + for (int i =3D 0; i < n; i+=3D1) + pixel[i] =3D (pixel[i] * (uint64_t)level) / 0xffffffffUL; +} + +#include "vect-div-bitmask.h" + +/* { dg-final { scan-tree-dump-not "vect_recog_divmod_pattern: detected" "= vect" { target aarch64*-*-* } } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-div-bitmask.h b/gcc/testsuite/g= cc.dg/vect/vect-div-bitmask.h new file mode 100644 index 0000000000000000000000000000000000000000..29a16739aa4b706616367bfd183= 2f28ebd07993e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-div-bitmask.h @@ -0,0 +1,43 @@ +#include + +#ifndef N +#define N 65 +#endif + +#ifndef TYPE +#define TYPE uint32_t +#endif + +#ifndef DEBUG +#define DEBUG 0 +#endif + +#define BASE ((TYPE) -1 < 0 ? -126 : 4) + +int main () +{ + TYPE a[N]; + TYPE b[N]; + + for (int i =3D 0; i < N; ++i) + { + a[i] =3D BASE + i * 13; + b[i] =3D BASE + i * 13; + if (DEBUG) + printf ("%d: 0x%x\n", i, a[i]); + } + + fun1 (a, N / 2, N); + fun2 (b, N / 2, N); + + for (int i =3D 0; i < N; ++i) + { + if (DEBUG) + printf ("%d =3D 0x%x =3D=3D 0x%x\n", i, a[i], b[i]); + + if (a[i] !=3D b[i]) + __builtin_abort (); + } + return 0; +} + diff --git a/gcc/tree-vect-generic.cc b/gcc/tree-vect-generic.cc index 350129555a0c71c0896c4f1003163f3b3557c11b..6ad6372c55eef94a742a8fa35e7= 9d66aa24e2f3b 100644 --- a/gcc/tree-vect-generic.cc +++ b/gcc/tree-vect-generic.cc @@ -1237,6 +1237,17 @@ expand_vector_operation (gimple_stmt_iterator *gsi, = tree type, tree compute_type tree rhs2 =3D gimple_assign_rhs2 (assign); tree ret; =20 + /* Check if the target was going to handle it through the special + division callback hook. */ + tree cst =3D uniform_integer_cst_p (rhs2); + if (cst && + targetm.vectorize.can_special_div_by_const (code, type, + wi::to_wide (cst), + NULL, + NULL_RTX, NULL_RTX)) + return NULL_TREE; + + if (!optimize || !VECTOR_INTEGER_TYPE_P (type) || TREE_CODE (rhs2) !=3D VECTOR_CST diff --git a/gcc/tree-vect-patterns.cc b/gcc/tree-vect-patterns.cc index 09574bb1a2696b3438a4ce9f09f74b42e784aca0..e91bcef56fff931a7a7ba534a0a= ffd56e7314370 100644 --- a/gcc/tree-vect-patterns.cc +++ b/gcc/tree-vect-patterns.cc @@ -3432,7 +3432,7 @@ vect_recog_divmod_pattern (vec_info *vinfo, gimple *pattern_stmt, *def_stmt; enum tree_code rhs_code; optab optab; - tree q; + tree q, cst; int dummy_int, prec; =20 if (!is_gimple_assign (last_stmt)) @@ -3596,6 +3596,14 @@ vect_recog_divmod_pattern (vec_info *vinfo, =20 return pattern_stmt; } + else if ((cst =3D uniform_integer_cst_p (oprnd1)) + && targetm.vectorize.can_special_div_by_const (rhs_code, vectype, + wi::to_wide (cst), + NULL, NULL_RTX, + NULL_RTX)) + { + return NULL; + } =20 if (prec > HOST_BITS_PER_WIDE_INT || integer_zerop (oprnd1)) diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index c9dab217f059f17e91e9a7582523e627d7a45b66..1399c22ba0df75f582887d7e83b= 67e3ea53d25f4 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -6260,6 +6260,14 @@ vectorizable_operation (vec_info *vinfo, } target_support_p =3D (optab_handler (optab, vec_mode) !=3D CODE_FOR_nothing); + tree cst; + if (!target_support_p + && (cst =3D uniform_integer_cst_p (op1))) + target_support_p + =3D targetm.vectorize.can_special_div_by_const (code, vectype, + wi::to_wide (cst), + NULL, NULL_RTX, + NULL_RTX); } =20 bool using_emulated_vectors_p =3D vect_emulated_vector_p (vectype); --_002_VI1PR08MB5325C56878364315686EBD99FF379VI1PR08MB5325eurp_ Content-Type: application/octet-stream; name="rb15779.patch" Content-Description: rb15779.patch Content-Disposition: attachment; filename="rb15779.patch"; size=18833; creation-date="Mon, 31 Oct 2022 11:33:22 GMT"; modification-date="Mon, 31 Oct 2022 11:34:38 GMT" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2djYy9kb2MvdG0udGV4aSBiL2djYy9kb2MvdG0udGV4aQppbmRleCA5MmJk YTFhN2UxNGEzYzllYTYzZTE1MWU0YTQ5YTgxOGJmNGQxYmRiLi5hMjlmNWMzOWJlM2YwOTI3Zjhl ZjZlMDk0YzdhNzEyYzA2MDRmYjc3IDEwMDY0NAotLS0gYS9nY2MvZG9jL3RtLnRleGkKKysrIGIv Z2NjL2RvYy90bS50ZXhpCkBAIC02MTEyLDYgKzYxMTIsMjIgQEAgaW5zdHJ1Y3Rpb24gcGF0dGVy bi4gIFRoZXJlIGlzIG5vIG5lZWQgZm9yIHRoZSBob29rIHRvIGhhbmRsZSB0aGVzZSB0d28KIGlt cGxlbWVudGF0aW9uIGFwcHJvYWNoZXMgaXRzZWxmLgogQGVuZCBkZWZ0eXBlZm4KIAorQGRlZnR5 cGVmbiB7VGFyZ2V0IEhvb2t9IGJvb2wgVEFSR0VUX1ZFQ1RPUklaRV9DQU5fU1BFQ0lBTF9ESVZf QllfQ09OU1QgKGVudW0gQHZhcnt0cmVlX2NvZGV9LCB0cmVlIEB2YXJ7dmVjdHlwZX0sIHdpZGVf aW50IEB2YXJ7Y29uc3RhbnR9LCBydHggKkB2YXJ7b3V0cHV0fSwgcnR4IEB2YXJ7aW4wfSwgcnR4 IEB2YXJ7aW4xfSkKK1RoaXMgaG9vayBpcyB1c2VkIHRvIHRlc3Qgd2hldGhlciB0aGUgdGFyZ2V0 IGhhcyBhIHNwZWNpYWwgbWV0aG9kIG9mCitkaXZpc2lvbiBvZiB2ZWN0b3JzIG9mIHR5cGUgQHZh cnt2ZWN0eXBlfSB1c2luZyB0aGUgdmFsdWUgQHZhcntjb25zdGFudH0sCithbmQgcHJvZHVjaW5n IGEgdmVjdG9yIG9mIHR5cGUgQHZhcnt2ZWN0eXBlfS4gIFRoZSBkaXZpc2lvbgord2lsbCB0aGVu IG5vdCBiZSBkZWNvbXBvc2VkIGJ5IHRoZSBhbmQga2VwdCBhcyBhIGRpdi4KKworV2hlbiB0aGUg aG9vayBpcyBiZWluZyB1c2VkIHRvIHRlc3Qgd2hldGhlciB0aGUgdGFyZ2V0IHN1cHBvcnRzIGEg c3BlY2lhbAorZGl2aWRlLCBAdmFye2luMH0sIEB2YXJ7aW4xfSwgYW5kIEB2YXJ7b3V0cHV0fSBh cmUgYWxsIG51bGwuICBXaGVuIHRoZSBob29rCitpcyBiZWluZyB1c2VkIHRvIGVtaXQgYSBkaXZp c2lvbiwgQHZhcntpbjB9IGFuZCBAdmFye2luMX0gYXJlIHRoZSBzb3VyY2UKK3ZlY3RvcnMgb2Yg dHlwZSBAdmFye3ZlY3R0eXBlfSBhbmQgQHZhcntvdXRwdXR9IGlzIHRoZSBkZXN0aW5hdGlvbiB2 ZWN0b3Igb2YKK3R5cGUgQHZhcnt2ZWN0eXBlfS4KKworUmV0dXJuIHRydWUgaWYgdGhlIG9wZXJh dGlvbiBpcyBwb3NzaWJsZSwgZW1pdHRpbmcgaW5zdHJ1Y3Rpb25zIGZvciBpdAoraWYgcnR4ZXMg YXJlIHByb3ZpZGVkIGFuZCB1cGRhdGluZyBAdmFye291dHB1dH0uCitAZW5kIGRlZnR5cGVmbgor CiBAZGVmdHlwZWZuIHtUYXJnZXQgSG9va30gdHJlZSBUQVJHRVRfVkVDVE9SSVpFX0JVSUxUSU5f VkVDVE9SSVpFRF9GVU5DVElPTiAodW5zaWduZWQgQHZhcntjb2RlfSwgdHJlZSBAdmFye3ZlY190 eXBlX291dH0sIHRyZWUgQHZhcnt2ZWNfdHlwZV9pbn0pCiBUaGlzIGhvb2sgc2hvdWxkIHJldHVy biB0aGUgZGVjbCBvZiBhIGZ1bmN0aW9uIHRoYXQgaW1wbGVtZW50cyB0aGUKIHZlY3Rvcml6ZWQg dmFyaWFudCBvZiB0aGUgZnVuY3Rpb24gd2l0aCB0aGUgQGNvZGV7Y29tYmluZWRfZm59IGNvZGUK ZGlmZiAtLWdpdCBhL2djYy9kb2MvdG0udGV4aS5pbiBiL2djYy9kb2MvdG0udGV4aS5pbgppbmRl eCAxMTI0NjIzMTBiMTM0NzA1ZDg2MDE1MzI5NDI4N2NmZDdkNGFmODFkLi5kNWE3NDVhMDJhY2Rm MDUxZWExZGExYjA0MDc2ZDA1OGMyNGNlMDkzIDEwMDY0NAotLS0gYS9nY2MvZG9jL3RtLnRleGku aW4KKysrIGIvZ2NjL2RvYy90bS50ZXhpLmluCkBAIC00MTY0LDYgKzQxNjQsOCBAQCBhZGRyZXNz OyAgYnV0IG9mdGVuIGEgbWFjaGluZS1kZXBlbmRlbnQgc3RyYXRlZ3kgY2FuIGdlbmVyYXRlIGJl dHRlciBjb2RlLgogCiBAaG9vayBUQVJHRVRfVkVDVE9SSVpFX1ZFQ19QRVJNX0NPTlNUCiAKK0Bo b29rIFRBUkdFVF9WRUNUT1JJWkVfQ0FOX1NQRUNJQUxfRElWX0JZX0NPTlNUCisKIEBob29rIFRB UkdFVF9WRUNUT1JJWkVfQlVJTFRJTl9WRUNUT1JJWkVEX0ZVTkNUSU9OCiAKIEBob29rIFRBUkdF VF9WRUNUT1JJWkVfQlVJTFRJTl9NRF9WRUNUT1JJWkVEX0ZVTkNUSU9OCmRpZmYgLS1naXQgYS9n Y2MvZXhwbG93LmNjIGIvZ2NjL2V4cGxvdy5jYwppbmRleCBkZGI0ZDZhZTM2MDA1NDJmOGQyYmI1 NjE3Y2RkMzkzM2E5ZmFlNmMwLi41NjhlMGViMWExNThjNjk2NDU4YWU2NzhmNWUzNDZiZjM0YmEw MDM2IDEwMDY0NAotLS0gYS9nY2MvZXhwbG93LmNjCisrKyBiL2djYy9leHBsb3cuY2MKQEAgLTEw MzcsNyArMTAzNyw3IEBAIHJvdW5kX3B1c2ggKHJ0eCBzaXplKQogICAgICBUUlVOQ19ESVZfRVhQ Ui4gICovCiAgIHNpemUgPSBleHBhbmRfYmlub3AgKFBtb2RlLCBhZGRfb3B0YWIsIHNpemUsIGFs aWdubTFfcnR4LAogCQkgICAgICAgTlVMTF9SVFgsIDEsIE9QVEFCX0xJQl9XSURFTik7Ci0gIHNp emUgPSBleHBhbmRfZGl2bW9kICgwLCBUUlVOQ19ESVZfRVhQUiwgUG1vZGUsIHNpemUsIGFsaWdu X3J0eCwKKyAgc2l6ZSA9IGV4cGFuZF9kaXZtb2QgKDAsIFRSVU5DX0RJVl9FWFBSLCBQbW9kZSwg TlVMTCwgTlVMTCwgc2l6ZSwgYWxpZ25fcnR4LAogCQkJTlVMTF9SVFgsIDEpOwogICBzaXplID0g ZXhwYW5kX211bHQgKFBtb2RlLCBzaXplLCBhbGlnbl9ydHgsIE5VTExfUlRYLCAxKTsKIApAQCAt MTIwMyw3ICsxMjAzLDcgQEAgYWxpZ25fZHluYW1pY19hZGRyZXNzIChydHggdGFyZ2V0LCB1bnNp Z25lZCByZXF1aXJlZF9hbGlnbikKIAkJCSBnZW5faW50X21vZGUgKHJlcXVpcmVkX2FsaWduIC8g QklUU19QRVJfVU5JVCAtIDEsCiAJCQkJICAgICAgIFBtb2RlKSwKIAkJCSBOVUxMX1JUWCwgMSwg T1BUQUJfTElCX1dJREVOKTsKLSAgdGFyZ2V0ID0gZXhwYW5kX2Rpdm1vZCAoMCwgVFJVTkNfRElW X0VYUFIsIFBtb2RlLCB0YXJnZXQsCisgIHRhcmdldCA9IGV4cGFuZF9kaXZtb2QgKDAsIFRSVU5D X0RJVl9FWFBSLCBQbW9kZSwgTlVMTCwgTlVMTCwgdGFyZ2V0LAogCQkJICBnZW5faW50X21vZGUg KHJlcXVpcmVkX2FsaWduIC8gQklUU19QRVJfVU5JVCwKIAkJCQkJUG1vZGUpLAogCQkJICBOVUxM X1JUWCwgMSk7CmRpZmYgLS1naXQgYS9nY2MvZXhwbWVkLmggYi9nY2MvZXhwbWVkLmgKaW5kZXgg MGIyNTM4YzRjNmJkNTFkZmRjNzcyZWY3MGJkZjYzMWMwYmVkODcxNy4uMGRiMjk4NmYxMWZmNGE0 YjEwYjU5NTAxYzZmMzNjYjM1OTU2NTliNSAxMDA2NDQKLS0tIGEvZ2NjL2V4cG1lZC5oCisrKyBi L2djYy9leHBtZWQuaApAQCAtNzA4LDggKzcwOCw5IEBAIGV4dGVybiBydHggZXhwYW5kX3Zhcmlh YmxlX3NoaWZ0IChlbnVtIHRyZWVfY29kZSwgbWFjaGluZV9tb2RlLAogZXh0ZXJuIHJ0eCBleHBh bmRfc2hpZnQgKGVudW0gdHJlZV9jb2RlLCBtYWNoaW5lX21vZGUsIHJ0eCwgcG9seV9pbnQ2NCwg cnR4LAogCQkJIGludCk7CiAjaWZkZWYgR0NDX09QVEFCU19ICi1leHRlcm4gcnR4IGV4cGFuZF9k aXZtb2QgKGludCwgZW51bSB0cmVlX2NvZGUsIG1hY2hpbmVfbW9kZSwgcnR4LCBydHgsCi0JCQkg IHJ0eCwgaW50LCBlbnVtIG9wdGFiX21ldGhvZHMgPSBPUFRBQl9MSUJfV0lERU4pOworZXh0ZXJu IHJ0eCBleHBhbmRfZGl2bW9kIChpbnQsIGVudW0gdHJlZV9jb2RlLCBtYWNoaW5lX21vZGUsIHRy ZWUsIHRyZWUsCisJCQkgIHJ0eCwgcnR4LCBydHgsIGludCwKKwkJCSAgZW51bSBvcHRhYl9tZXRo b2RzID0gT1BUQUJfTElCX1dJREVOKTsKICNlbmRpZgogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL2dj Yy9leHBtZWQuY2MgYi9nY2MvZXhwbWVkLmNjCmluZGV4IDhkNzQxOGJlNDE4NDA2ZTcyYTg5NWVj ZGRmMmRjN2ZkYjk1MGM3NmMuLmJhYjAyMGMwNzIyMmFmYTM4MzA1ZWY4ZDczMzNmMjcxYjE5NjVi NzggMTAwNjQ0Ci0tLSBhL2djYy9leHBtZWQuY2MKKysrIGIvZ2NjL2V4cG1lZC5jYwpAQCAtNDIy Miw4ICs0MjIyLDggQEAgZXhwYW5kX3NkaXZfcG93MiAoc2NhbGFyX2ludF9tb2RlIG1vZGUsIHJ0 eCBvcDAsIEhPU1RfV0lERV9JTlQgZCkKIAogcnR4CiBleHBhbmRfZGl2bW9kIChpbnQgcmVtX2Zs YWcsIGVudW0gdHJlZV9jb2RlIGNvZGUsIG1hY2hpbmVfbW9kZSBtb2RlLAotCSAgICAgICBydHgg b3AwLCBydHggb3AxLCBydHggdGFyZ2V0LCBpbnQgdW5zaWduZWRwLAotCSAgICAgICBlbnVtIG9w dGFiX21ldGhvZHMgbWV0aG9kcykKKwkgICAgICAgdHJlZSB0cmVlb3AwLCB0cmVlIHRyZWVvcDEs IHJ0eCBvcDAsIHJ0eCBvcDEsIHJ0eCB0YXJnZXQsCisJICAgICAgIGludCB1bnNpZ25lZHAsIGVu dW0gb3B0YWJfbWV0aG9kcyBtZXRob2RzKQogewogICBtYWNoaW5lX21vZGUgY29tcHV0ZV9tb2Rl OwogICBydHggdHF1b3RpZW50OwpAQCAtNDM3NSw2ICs0Mzc1LDE3IEBAIGV4cGFuZF9kaXZtb2Qg KGludCByZW1fZmxhZywgZW51bSB0cmVlX2NvZGUgY29kZSwgbWFjaGluZV9tb2RlIG1vZGUsCiAK ICAgbGFzdF9kaXZfY29uc3QgPSAhIHJlbV9mbGFnICYmIG9wMV9pc19jb25zdGFudCA/IElOVFZB TCAob3AxKSA6IDA7CiAKKyAgLyogQ2hlY2sgaWYgdGhlIHRhcmdldCBoYXMgc3BlY2lmaWMgZXhw YW5zaW9ucyBmb3IgdGhlIGRpdmlzaW9uLiAgKi8KKyAgdHJlZSBjc3Q7CisgIGlmICh0cmVlb3Aw CisgICAgICAmJiB0cmVlb3AxCisgICAgICAmJiAoY3N0ID0gdW5pZm9ybV9pbnRlZ2VyX2NzdF9w ICh0cmVlb3AxKSkKKyAgICAgICYmIHRhcmdldG0udmVjdG9yaXplLmNhbl9zcGVjaWFsX2Rpdl9i eV9jb25zdCAoY29kZSwgVFJFRV9UWVBFICh0cmVlb3AwKSwKKwkJCQkJCSAgICAgd2k6OnRvX3dp ZGUgKGNzdCksCisJCQkJCQkgICAgICZ0YXJnZXQsIG9wMCwgb3AxKSkKKyAgICByZXR1cm4gdGFy Z2V0OworCisKICAgLyogTm93IGNvbnZlcnQgdG8gdGhlIGJlc3QgbW9kZSB0byB1c2UuICAqLwog ICBpZiAoY29tcHV0ZV9tb2RlICE9IG1vZGUpCiAgICAgewpAQCAtNDYxOCw4ICs0NjI5LDggQEAg ZXhwYW5kX2Rpdm1vZCAoaW50IHJlbV9mbGFnLCBlbnVtIHRyZWVfY29kZSBjb2RlLCBtYWNoaW5l X21vZGUgbW9kZSwKIAkJCSAgICB8fCAob3B0YWJfaGFuZGxlciAoc2Rpdm1vZF9vcHRhYiwgaW50 X21vZGUpCiAJCQkJIT0gQ09ERV9GT1Jfbm90aGluZykpKQogCQkgICAgICBxdW90aWVudCA9IGV4 cGFuZF9kaXZtb2QgKDAsIFRSVU5DX0RJVl9FWFBSLAotCQkJCQkJaW50X21vZGUsIG9wMCwKLQkJ CQkJCWdlbl9pbnRfbW9kZSAoYWJzX2QsCisJCQkJCQlpbnRfbW9kZSwgdHJlZW9wMCwgdHJlZW9w MSwKKwkJCQkJCW9wMCwgZ2VuX2ludF9tb2RlIChhYnNfZCwKIAkJCQkJCQkgICAgICBpbnRfbW9k ZSksCiAJCQkJCQlOVUxMX1JUWCwgMCk7CiAJCSAgICBlbHNlCkBAIC00ODA4LDggKzQ4MTksOCBA QCBleHBhbmRfZGl2bW9kIChpbnQgcmVtX2ZsYWcsIGVudW0gdHJlZV9jb2RlIGNvZGUsIG1hY2hp bmVfbW9kZSBtb2RlLAogCQkJCSAgICAgIHNpemUgLSAxLCBOVUxMX1JUWCwgMCk7CiAJCXQzID0g Zm9yY2Vfb3BlcmFuZCAoZ2VuX3J0eF9NSU5VUyAoaW50X21vZGUsIHQxLCBuc2lnbiksCiAJCQkJ ICAgIE5VTExfUlRYKTsKLQkJdDQgPSBleHBhbmRfZGl2bW9kICgwLCBUUlVOQ19ESVZfRVhQUiwg aW50X21vZGUsIHQzLCBvcDEsCi0JCQkJICAgIE5VTExfUlRYLCAwKTsKKwkJdDQgPSBleHBhbmRf ZGl2bW9kICgwLCBUUlVOQ19ESVZfRVhQUiwgaW50X21vZGUsIHRyZWVvcDAsCisJCQkJICAgIHRy ZWVvcDEsIHQzLCBvcDEsIE5VTExfUlRYLCAwKTsKIAkJaWYgKHQ0KQogCQkgIHsKIAkJICAgIHJ0 eCB0NTsKZGlmZiAtLWdpdCBhL2djYy9leHByLmNjIGIvZ2NjL2V4cHIuY2MKaW5kZXggODBiYjFi OGE0YzViODM1MGZiMWI4ZjU3YTk5ZmQ1MmU1ODgyZmNiNi4uYjc4NmYxZDc1ZTI1ZjM0MTBjMDY0 MGNkOTZhOGFiYzA1NWZhMzRkOSAxMDA2NDQKLS0tIGEvZ2NjL2V4cHIuY2MKKysrIGIvZ2NjL2V4 cHIuY2MKQEAgLTgwMjgsMTYgKzgwMjgsMTcgQEAgZm9yY2Vfb3BlcmFuZCAocnR4IHZhbHVlLCBy dHggdGFyZ2V0KQogCSAgICByZXR1cm4gZXhwYW5kX2Rpdm1vZCAoMCwKIAkJCQkgIEZMT0FUX01P REVfUCAoR0VUX01PREUgKHZhbHVlKSkKIAkJCQkgID8gUkRJVl9FWFBSIDogVFJVTkNfRElWX0VY UFIsCi0JCQkJICBHRVRfTU9ERSAodmFsdWUpLCBvcDEsIG9wMiwgdGFyZ2V0LCAwKTsKKwkJCQkg IEdFVF9NT0RFICh2YWx1ZSksIE5VTEwsIE5VTEwsIG9wMSwgb3AyLAorCQkJCSAgdGFyZ2V0LCAw KTsKIAljYXNlIE1PRDoKLQkgIHJldHVybiBleHBhbmRfZGl2bW9kICgxLCBUUlVOQ19NT0RfRVhQ UiwgR0VUX01PREUgKHZhbHVlKSwgb3AxLCBvcDIsCi0JCQkJdGFyZ2V0LCAwKTsKKwkgIHJldHVy biBleHBhbmRfZGl2bW9kICgxLCBUUlVOQ19NT0RfRVhQUiwgR0VUX01PREUgKHZhbHVlKSwgTlVM TCwgTlVMTCwKKwkJCQlvcDEsIG9wMiwgdGFyZ2V0LCAwKTsKIAljYXNlIFVESVY6Ci0JICByZXR1 cm4gZXhwYW5kX2Rpdm1vZCAoMCwgVFJVTkNfRElWX0VYUFIsIEdFVF9NT0RFICh2YWx1ZSksIG9w MSwgb3AyLAotCQkJCXRhcmdldCwgMSk7CisJICByZXR1cm4gZXhwYW5kX2Rpdm1vZCAoMCwgVFJV TkNfRElWX0VYUFIsIEdFVF9NT0RFICh2YWx1ZSksIE5VTEwsIE5VTEwsCisJCQkJb3AxLCBvcDIs IHRhcmdldCwgMSk7CiAJY2FzZSBVTU9EOgotCSAgcmV0dXJuIGV4cGFuZF9kaXZtb2QgKDEsIFRS VU5DX01PRF9FWFBSLCBHRVRfTU9ERSAodmFsdWUpLCBvcDEsIG9wMiwKLQkJCQl0YXJnZXQsIDEp OworCSAgcmV0dXJuIGV4cGFuZF9kaXZtb2QgKDEsIFRSVU5DX01PRF9FWFBSLCBHRVRfTU9ERSAo dmFsdWUpLCBOVUxMLCBOVUxMLAorCQkJCW9wMSwgb3AyLCB0YXJnZXQsIDEpOwogCWNhc2UgQVNI SUZUUlQ6CiAJICByZXR1cm4gZXhwYW5kX3NpbXBsZV9iaW5vcCAoR0VUX01PREUgKHZhbHVlKSwg Y29kZSwgb3AxLCBvcDIsCiAJCQkJICAgICAgdGFyZ2V0LCAwLCBPUFRBQl9MSUJfV0lERU4pOwpA QCAtODk5MCwxMSArODk5MSwxMyBAQCBleHBhbmRfZXhwcl9kaXZtb2QgKHRyZWVfY29kZSBjb2Rl LCBtYWNoaW5lX21vZGUgbW9kZSwgdHJlZSB0cmVlb3AwLAogICAgICAgYm9vbCBzcGVlZF9wID0g b3B0aW1pemVfaW5zbl9mb3Jfc3BlZWRfcCAoKTsKICAgICAgIGRvX3BlbmRpbmdfc3RhY2tfYWRq dXN0ICgpOwogICAgICAgc3RhcnRfc2VxdWVuY2UgKCk7Ci0gICAgICBydHggdW5zX3JldCA9IGV4 cGFuZF9kaXZtb2QgKG1vZF9wLCBjb2RlLCBtb2RlLCBvcDAsIG9wMSwgdGFyZ2V0LCAxKTsKKyAg ICAgIHJ0eCB1bnNfcmV0ID0gZXhwYW5kX2Rpdm1vZCAobW9kX3AsIGNvZGUsIG1vZGUsIHRyZWVv cDAsIHRyZWVvcDEsCisJCQkJICAgb3AwLCBvcDEsIHRhcmdldCwgMSk7CiAgICAgICBydHhfaW5z biAqdW5zX2luc25zID0gZ2V0X2luc25zICgpOwogICAgICAgZW5kX3NlcXVlbmNlICgpOwogICAg ICAgc3RhcnRfc2VxdWVuY2UgKCk7Ci0gICAgICBydHggc2duX3JldCA9IGV4cGFuZF9kaXZtb2Qg KG1vZF9wLCBjb2RlLCBtb2RlLCBvcDAsIG9wMSwgdGFyZ2V0LCAwKTsKKyAgICAgIHJ0eCBzZ25f cmV0ID0gZXhwYW5kX2Rpdm1vZCAobW9kX3AsIGNvZGUsIG1vZGUsIHRyZWVvcDAsIHRyZWVvcDEs CisJCQkJICAgb3AwLCBvcDEsIHRhcmdldCwgMCk7CiAgICAgICBydHhfaW5zbiAqc2duX2luc25z ID0gZ2V0X2luc25zICgpOwogICAgICAgZW5kX3NlcXVlbmNlICgpOwogICAgICAgdW5zaWduZWQg dW5zX2Nvc3QgPSBzZXFfY29zdCAodW5zX2luc25zLCBzcGVlZF9wKTsKQEAgLTkwMTYsNyArOTAx OSw4IEBAIGV4cGFuZF9leHByX2Rpdm1vZCAodHJlZV9jb2RlIGNvZGUsIG1hY2hpbmVfbW9kZSBt b2RlLCB0cmVlIHRyZWVvcDAsCiAgICAgICBlbWl0X2luc24gKHNnbl9pbnNucyk7CiAgICAgICBy ZXR1cm4gc2duX3JldDsKICAgICB9Ci0gIHJldHVybiBleHBhbmRfZGl2bW9kIChtb2RfcCwgY29k ZSwgbW9kZSwgb3AwLCBvcDEsIHRhcmdldCwgdW5zaWduZWRwKTsKKyAgcmV0dXJuIGV4cGFuZF9k aXZtb2QgKG1vZF9wLCBjb2RlLCBtb2RlLCB0cmVlb3AwLCB0cmVlb3AxLAorCQkJb3AwLCBvcDEs IHRhcmdldCwgdW5zaWduZWRwKTsKIH0KIAogcnR4CmRpZmYgLS1naXQgYS9nY2Mvb3B0YWJzLmNj IGIvZ2NjL29wdGFicy5jYwppbmRleCAxNjVmOGQxZmEyMjQzMmI5Njk2N2M2OWE1OGRiYjdiNGJm MTgxMjBkLi5jZmYzN2NjYjBkZmMzZGQ3OWI5N2QwYWJmZDg3MmYzNDA4NTVkYzk2IDEwMDY0NAot LS0gYS9nY2Mvb3B0YWJzLmNjCisrKyBiL2djYy9vcHRhYnMuY2MKQEAgLTExMDQsOCArMTEwNCw5 IEBAIGV4cGFuZF9kb3VibGV3b3JkX21vZCAobWFjaGluZV9tb2RlIG1vZGUsIHJ0eCBvcDAsIHJ0 eCBvcDEsIGJvb2wgdW5zaWduZWRwKQogCQlyZXR1cm4gTlVMTF9SVFg7CiAJICAgIH0KIAl9Ci0g ICAgICBydHggcmVtYWluZGVyID0gZXhwYW5kX2Rpdm1vZCAoMSwgVFJVTkNfTU9EX0VYUFIsIHdv cmRfbW9kZSwgc3VtLAotCQkJCSAgICAgZ2VuX2ludF9tb2RlIChJTlRWQUwgKG9wMSksIHdvcmRf bW9kZSksCisgICAgICBydHggcmVtYWluZGVyID0gZXhwYW5kX2Rpdm1vZCAoMSwgVFJVTkNfTU9E X0VYUFIsIHdvcmRfbW9kZSwgTlVMTCwgTlVMTCwKKwkJCQkgICAgIHN1bSwgZ2VuX2ludF9tb2Rl IChJTlRWQUwgKG9wMSksCisJCQkJCQkJd29yZF9tb2RlKSwKIAkJCQkgICAgIE5VTExfUlRYLCAx LCBPUFRBQl9ESVJFQ1QpOwogICAgICAgaWYgKHJlbWFpbmRlciA9PSBOVUxMX1JUWCkKIAlyZXR1 cm4gTlVMTF9SVFg7CkBAIC0xMjA4LDggKzEyMDksOCBAQCBleHBhbmRfZG91Ymxld29yZF9kaXZt b2QgKG1hY2hpbmVfbW9kZSBtb2RlLCBydHggb3AwLCBydHggb3AxLCBydHggKnJlbSwKIAogICBp ZiAob3AxMSAhPSBjb25zdDFfcnR4KQogICAgIHsKLSAgICAgIHJ0eCByZW0yID0gZXhwYW5kX2Rp dm1vZCAoMSwgVFJVTkNfTU9EX0VYUFIsIG1vZGUsIHF1b3QxLCBvcDExLAotCQkJCU5VTExfUlRY LCB1bnNpZ25lZHAsIE9QVEFCX0RJUkVDVCk7CisgICAgICBydHggcmVtMiA9IGV4cGFuZF9kaXZt b2QgKDEsIFRSVU5DX01PRF9FWFBSLCBtb2RlLCBOVUxMLCBOVUxMLCBxdW90MSwKKwkJCQlvcDEx LCBOVUxMX1JUWCwgdW5zaWduZWRwLCBPUFRBQl9ESVJFQ1QpOwogICAgICAgaWYgKHJlbTIgPT0g TlVMTF9SVFgpCiAJcmV0dXJuIE5VTExfUlRYOwogCkBAIC0xMjIzLDggKzEyMjQsOCBAQCBleHBh bmRfZG91Ymxld29yZF9kaXZtb2QgKG1hY2hpbmVfbW9kZSBtb2RlLCBydHggb3AwLCBydHggb3Ax LCBydHggKnJlbSwKICAgICAgIGlmIChyZW0yID09IE5VTExfUlRYKQogCXJldHVybiBOVUxMX1JU WDsKIAotICAgICAgcnR4IHF1b3QyID0gZXhwYW5kX2Rpdm1vZCAoMCwgVFJVTkNfRElWX0VYUFIs IG1vZGUsIHF1b3QxLCBvcDExLAotCQkJCSBOVUxMX1JUWCwgdW5zaWduZWRwLCBPUFRBQl9ESVJF Q1QpOworICAgICAgcnR4IHF1b3QyID0gZXhwYW5kX2Rpdm1vZCAoMCwgVFJVTkNfRElWX0VYUFIs IG1vZGUsIE5VTEwsIE5VTEwsIHF1b3QxLAorCQkJCSBvcDExLCBOVUxMX1JUWCwgdW5zaWduZWRw LCBPUFRBQl9ESVJFQ1QpOwogICAgICAgaWYgKHF1b3QyID09IE5VTExfUlRYKQogCXJldHVybiBO VUxMX1JUWDsKIApkaWZmIC0tZ2l0IGEvZ2NjL3RhcmdldC5kZWYgYi9nY2MvdGFyZ2V0LmRlZgpp bmRleCAyYTdmYTY4ZjgzZGQxNWRjZGQyYzMzMmU4NDMxZTYxNDJlYzdkMzA1Li5mNDkxZTIyMzNj ZjE4NzYwNjMxZjE0OGRhY2YxOGQwZTBiMTMzZTRjIDEwMDY0NAotLS0gYS9nY2MvdGFyZ2V0LmRl ZgorKysgYi9nY2MvdGFyZ2V0LmRlZgpAQCAtMTkwMiw2ICsxOTAyLDI1IEBAIGltcGxlbWVudGF0 aW9uIGFwcHJvYWNoZXMgaXRzZWxmLiIsCiAJY29uc3QgdmVjX3Blcm1faW5kaWNlcyAmc2VsKSwK ICBOVUxMKQogCitERUZIT09LCisoY2FuX3NwZWNpYWxfZGl2X2J5X2NvbnN0LAorICJUaGlzIGhv b2sgaXMgdXNlZCB0byB0ZXN0IHdoZXRoZXIgdGhlIHRhcmdldCBoYXMgYSBzcGVjaWFsIG1ldGhv ZCBvZlxuXAorZGl2aXNpb24gb2YgdmVjdG9ycyBvZiB0eXBlIEB2YXJ7dmVjdHlwZX0gdXNpbmcg dGhlIHZhbHVlIEB2YXJ7Y29uc3RhbnR9LFxuXAorYW5kIHByb2R1Y2luZyBhIHZlY3RvciBvZiB0 eXBlIEB2YXJ7dmVjdHlwZX0uICBUaGUgZGl2aXNpb25cblwKK3dpbGwgdGhlbiBub3QgYmUgZGVj b21wb3NlZCBieSB0aGUgYW5kIGtlcHQgYXMgYSBkaXYuXG5cCitcblwKK1doZW4gdGhlIGhvb2sg aXMgYmVpbmcgdXNlZCB0byB0ZXN0IHdoZXRoZXIgdGhlIHRhcmdldCBzdXBwb3J0cyBhIHNwZWNp YWxcblwKK2RpdmlkZSwgQHZhcntpbjB9LCBAdmFye2luMX0sIGFuZCBAdmFye291dHB1dH0gYXJl IGFsbCBudWxsLiAgV2hlbiB0aGUgaG9va1xuXAoraXMgYmVpbmcgdXNlZCB0byBlbWl0IGEgZGl2 aXNpb24sIEB2YXJ7aW4wfSBhbmQgQHZhcntpbjF9IGFyZSB0aGUgc291cmNlXG5cCit2ZWN0b3Jz IG9mIHR5cGUgQHZhcnt2ZWN0dHlwZX0gYW5kIEB2YXJ7b3V0cHV0fSBpcyB0aGUgZGVzdGluYXRp b24gdmVjdG9yIG9mXG5cCit0eXBlIEB2YXJ7dmVjdHlwZX0uXG5cCitcblwKK1JldHVybiB0cnVl IGlmIHRoZSBvcGVyYXRpb24gaXMgcG9zc2libGUsIGVtaXR0aW5nIGluc3RydWN0aW9ucyBmb3Ig aXRcblwKK2lmIHJ0eGVzIGFyZSBwcm92aWRlZCBhbmQgdXBkYXRpbmcgQHZhcntvdXRwdXR9LiIs CisgYm9vbCwgKGVudW0gdHJlZV9jb2RlLCB0cmVlIHZlY3R5cGUsIHdpZGVfaW50IGNvbnN0YW50 LCBydHggKm91dHB1dCwKKwlydHggaW4wLCBydHggaW4xKSwKKyBkZWZhdWx0X2Nhbl9zcGVjaWFs X2Rpdl9ieV9jb25zdCkKKwogLyogUmV0dXJuIHRydWUgaWYgdGhlIHRhcmdldCBzdXBwb3J0cyBt aXNhbGlnbmVkIHN0b3JlL2xvYWQgb2YgYQogICAgc3BlY2lmaWMgZmFjdG9yIGRlbm90ZWQgaW4g dGhlIHRoaXJkIHBhcmFtZXRlci4gIFRoZSBsYXN0IHBhcmFtZXRlcgogICAgaXMgdHJ1ZSBpZiB0 aGUgYWNjZXNzIGlzIGRlZmluZWQgaW4gYSBwYWNrZWQgc3RydWN0LiAgKi8KZGlmZiAtLWdpdCBh L2djYy90YXJnZXQuaCBiL2djYy90YXJnZXQuaAppbmRleCBkNmZhNjkzMTQ5OWQxNWVkZmYzZTVh ZjNlNDI5NTQwZDAwMWM3MDU4Li5jODM2MDM2YWM3ZmE3OTEwZDYyYmQzZGE1NmYzOWMwNjFmNjhi NjY1IDEwMDY0NAotLS0gYS9nY2MvdGFyZ2V0LmgKKysrIGIvZ2NjL3RhcmdldC5oCkBAIC01MSw2 ICs1MSw3IEBACiAjaW5jbHVkZSAiaW5zbi1jb2Rlcy5oIgogI2luY2x1ZGUgInRtLmgiCiAjaW5j bHVkZSAiaGFyZC1yZWctc2V0LmgiCisjaW5jbHVkZSAidHJlZS1jb3JlLmgiCiAKICNpZiBDSEVD S0lOR19QCiAKZGlmZiAtLWdpdCBhL2djYy90YXJnaG9va3MuaCBiL2djYy90YXJnaG9va3MuaApp bmRleCBlY2NlNTVlYmU3OTdjZWRjOTQwNjIwZThkODk4MTY5NzNhMDQ1ZDQ5Li5jOGRmMmFmMDJi OWQ4YzQxZDk1M2I3ODg3ZGQ5ODBiMWE3YzVjZjFjIDEwMDY0NAotLS0gYS9nY2MvdGFyZ2hvb2tz LmgKKysrIGIvZ2NjL3Rhcmdob29rcy5oCkBAIC0yMDcsNiArMjA3LDggQEAgZXh0ZXJuIHZvaWQg ZGVmYXVsdF9hZGRyX3NwYWNlX2RpYWdub3NlX3VzYWdlIChhZGRyX3NwYWNlX3QsIGxvY2F0aW9u X3QpOwogZXh0ZXJuIHJ0eCBkZWZhdWx0X2FkZHJfc3BhY2VfY29udmVydCAocnR4LCB0cmVlLCB0 cmVlKTsKIGV4dGVybiB1bnNpZ25lZCBpbnQgZGVmYXVsdF9jYXNlX3ZhbHVlc190aHJlc2hvbGQg KHZvaWQpOwogZXh0ZXJuIGJvb2wgZGVmYXVsdF9oYXZlX2NvbmRpdGlvbmFsX2V4ZWN1dGlvbiAo dm9pZCk7CitleHRlcm4gYm9vbCBkZWZhdWx0X2Nhbl9zcGVjaWFsX2Rpdl9ieV9jb25zdCAoZW51 bSB0cmVlX2NvZGUsIHRyZWUsIHdpZGVfaW50LAorCQkJCQkgICAgICBydHggKiwgcnR4LCBydHgp OwogCiBleHRlcm4gYm9vbCBkZWZhdWx0X2xpYmNfaGFzX2Z1bmN0aW9uIChlbnVtIGZ1bmN0aW9u X2NsYXNzLCB0cmVlKTsKIGV4dGVybiBib29sIGRlZmF1bHRfbGliY19oYXNfZmFzdF9mdW5jdGlv biAoaW50IGZjb2RlKTsKZGlmZiAtLWdpdCBhL2djYy90YXJnaG9va3MuY2MgYi9nY2MvdGFyZ2hv b2tzLmNjCmluZGV4IGIxNWFlMTliY2I2MGM1OWFlODExMmU2N2I1ZjA2YTI0MWE5YmRiZjEuLmY5 NDFiMWMyMThkM2M0ZGU4YjdmNzgwYjY5ZmUwNDU5M2FlMzQxOWUgMTAwNjQ0Ci0tLSBhL2djYy90 YXJnaG9va3MuY2MKKysrIGIvZ2NjL3Rhcmdob29rcy5jYwpAQCAtMTgwNyw2ICsxODA3LDE0IEBA IGRlZmF1bHRfaGF2ZV9jb25kaXRpb25hbF9leGVjdXRpb24gKHZvaWQpCiAgIHJldHVybiBIQVZF X2NvbmRpdGlvbmFsX2V4ZWN1dGlvbjsKIH0KIAorLyogRGVmYXVsdCB0aGF0IG5vIGRpdmlzaW9u IGJ5IGNvbnN0YW50IG9wZXJhdGlvbnMgYXJlIHNwZWNpYWwuICAqLworYm9vbAorZGVmYXVsdF9j YW5fc3BlY2lhbF9kaXZfYnlfY29uc3QgKGVudW0gdHJlZV9jb2RlLCB0cmVlLCB3aWRlX2ludCwg cnR4ICosIHJ0eCwKKwkJCQkgIHJ0eCkKK3sKKyAgcmV0dXJuIGZhbHNlOworfQorCiAvKiBCeSBk ZWZhdWx0IHdlIGFzc3VtZSB0aGF0IGM5OSBmdW5jdGlvbnMgYXJlIHByZXNlbnQgYXQgdGhlIHJ1 bnRpbWUsCiAgICBidXQgc2luY29zIGlzIG5vdC4gICovCiBib29sCmRpZmYgLS1naXQgYS9nY2Mv dGVzdHN1aXRlL2djYy5kZy92ZWN0L3ZlY3QtZGl2LWJpdG1hc2stMS5jIGIvZ2NjL3Rlc3RzdWl0 ZS9nY2MuZGcvdmVjdC92ZWN0LWRpdi1iaXRtYXNrLTEuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40NzJjZDcxMDUz NGJjOGFhOWIxYjQ5MTZmM2Q3YjRkNWI2NGExOWI5Ci0tLSAvZGV2L251bGwKKysrIGIvZ2NjL3Rl c3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWRpdi1iaXRtYXNrLTEuYwpAQCAtMCwwICsxLDI1IEBA CisvKiB7IGRnLXJlcXVpcmUtZWZmZWN0aXZlLXRhcmdldCB2ZWN0X2ludCB9ICovCisKKyNpbmNs dWRlIDxzdGRpbnQuaD4KKyNpbmNsdWRlICJ0cmVlLXZlY3QuaCIKKworI2RlZmluZSBOIDUwCisj ZGVmaW5lIFRZUEUgdWludDhfdCAKKworX19hdHRyaWJ1dGVfXygobm9pcGEsIG5vaW5saW5lLCBv cHRpbWl6ZSgiTzEiKSkpCit2b2lkIGZ1bjEoVFlQRSogcmVzdHJpY3QgcGl4ZWwsIFRZUEUgbGV2 ZWwsIGludCBuKQoreworICBmb3IgKGludCBpID0gMDsgaSA8IG47IGkrPTEpCisgICAgcGl4ZWxb aV0gPSAocGl4ZWxbaV0gKiBsZXZlbCkgLyAweGZmOworfQorCitfX2F0dHJpYnV0ZV9fKChub2lw YSwgbm9pbmxpbmUsIG9wdGltaXplKCJPMyIpKSkKK3ZvaWQgZnVuMihUWVBFKiByZXN0cmljdCBw aXhlbCwgVFlQRSBsZXZlbCwgaW50IG4pCit7CisgIGZvciAoaW50IGkgPSAwOyBpIDwgbjsgaSs9 MSkKKyAgICBwaXhlbFtpXSA9IChwaXhlbFtpXSAqIGxldmVsKSAvIDB4ZmY7Cit9CisKKyNpbmNs dWRlICJ2ZWN0LWRpdi1iaXRtYXNrLmgiCisKKy8qIHsgZGctZmluYWwgeyBzY2FuLXRyZWUtZHVt cC1ub3QgInZlY3RfcmVjb2dfZGl2bW9kX3BhdHRlcm46IGRldGVjdGVkIiAidmVjdCIgeyB0YXJn ZXQgYWFyY2g2NCotKi0qIH0gfSB9ICovCmRpZmYgLS1naXQgYS9nY2MvdGVzdHN1aXRlL2djYy5k Zy92ZWN0L3ZlY3QtZGl2LWJpdG1hc2stMi5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92 ZWN0LWRpdi1iaXRtYXNrLTIuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lOTA0YTcxODg1YjJlODQ4NzU5M2EyY2Qz ZGI3NWIzZTQxMTJlMmNjCi0tLSAvZGV2L251bGwKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcv dmVjdC92ZWN0LWRpdi1iaXRtYXNrLTIuYwpAQCAtMCwwICsxLDI1IEBACisvKiB7IGRnLXJlcXVp cmUtZWZmZWN0aXZlLXRhcmdldCB2ZWN0X2ludCB9ICovCisKKyNpbmNsdWRlIDxzdGRpbnQuaD4K KyNpbmNsdWRlICJ0cmVlLXZlY3QuaCIKKworI2RlZmluZSBOIDUwCisjZGVmaW5lIFRZUEUgdWlu dDE2X3QgCisKK19fYXR0cmlidXRlX18oKG5vaXBhLCBub2lubGluZSwgb3B0aW1pemUoIk8xIikp KQordm9pZCBmdW4xKFRZUEUqIHJlc3RyaWN0IHBpeGVsLCBUWVBFIGxldmVsLCBpbnQgbikKK3sK KyAgZm9yIChpbnQgaSA9IDA7IGkgPCBuOyBpKz0xKQorICAgIHBpeGVsW2ldID0gKHBpeGVsW2ld ICogbGV2ZWwpIC8gMHhmZmZmVTsKK30KKworX19hdHRyaWJ1dGVfXygobm9pcGEsIG5vaW5saW5l LCBvcHRpbWl6ZSgiTzMiKSkpCit2b2lkIGZ1bjIoVFlQRSogcmVzdHJpY3QgcGl4ZWwsIFRZUEUg bGV2ZWwsIGludCBuKQoreworICBmb3IgKGludCBpID0gMDsgaSA8IG47IGkrPTEpCisgICAgcGl4 ZWxbaV0gPSAocGl4ZWxbaV0gKiBsZXZlbCkgLyAweGZmZmZVOworfQorCisjaW5jbHVkZSAidmVj dC1kaXYtYml0bWFzay5oIgorCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAtbm90ICJ2 ZWN0X3JlY29nX2Rpdm1vZF9wYXR0ZXJuOiBkZXRlY3RlZCIgInZlY3QiIHsgdGFyZ2V0IGFhcmNo NjQqLSotKiB9IH0gfSAqLwpkaWZmIC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92 ZWN0LWRpdi1iaXRtYXNrLTMuYyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVjdC1kaXYt Yml0bWFzay0zLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYTE0MThlYmJmNWVhODczMWVkNGUzZTcyMDE1NzcwMWQ5 ZDFjZjg1MgotLS0gL2Rldi9udWxsCisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVj dC1kaXYtYml0bWFzay0zLmMKQEAgLTAsMCArMSwyNiBAQAorLyogeyBkZy1yZXF1aXJlLWVmZmVj dGl2ZS10YXJnZXQgdmVjdF9pbnQgfSAqLworLyogeyBkZy1hZGRpdGlvbmFsLW9wdGlvbnMgIi1m bm8tdmVjdC1jb3N0LW1vZGVsIiB7IHRhcmdldCBhYXJjaDY0Ki0qLSogfSB9ICovCisKKyNpbmNs dWRlIDxzdGRpbnQuaD4KKyNpbmNsdWRlICJ0cmVlLXZlY3QuaCIKKworI2RlZmluZSBOIDUwCisj ZGVmaW5lIFRZUEUgdWludDMyX3QgCisKK19fYXR0cmlidXRlX18oKG5vaXBhLCBub2lubGluZSwg b3B0aW1pemUoIk8xIikpKQordm9pZCBmdW4xKFRZUEUqIHJlc3RyaWN0IHBpeGVsLCBUWVBFIGxl dmVsLCBpbnQgbikKK3sKKyAgZm9yIChpbnQgaSA9IDA7IGkgPCBuOyBpKz0xKQorICAgIHBpeGVs W2ldID0gKHBpeGVsW2ldICogKHVpbnQ2NF90KWxldmVsKSAvIDB4ZmZmZmZmZmZVTDsKK30KKwor X19hdHRyaWJ1dGVfXygobm9pcGEsIG5vaW5saW5lLCBvcHRpbWl6ZSgiTzMiKSkpCit2b2lkIGZ1 bjIoVFlQRSogcmVzdHJpY3QgcGl4ZWwsIFRZUEUgbGV2ZWwsIGludCBuKQoreworICBmb3IgKGlu dCBpID0gMDsgaSA8IG47IGkrPTEpCisgICAgcGl4ZWxbaV0gPSAocGl4ZWxbaV0gKiAodWludDY0 X3QpbGV2ZWwpIC8gMHhmZmZmZmZmZlVMOworfQorCisjaW5jbHVkZSAidmVjdC1kaXYtYml0bWFz ay5oIgorCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAtbm90ICJ2ZWN0X3JlY29nX2Rp dm1vZF9wYXR0ZXJuOiBkZXRlY3RlZCIgInZlY3QiIHsgdGFyZ2V0IGFhcmNoNjQqLSotKiB9IH0g fSAqLwpkaWZmIC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWRpdi1iaXRt YXNrLmggYi9nY2MvdGVzdHN1aXRlL2djYy5kZy92ZWN0L3ZlY3QtZGl2LWJpdG1hc2suaApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi4yOWExNjczOWFhNGI3MDY2MTYzNjdiZmQxODMyZjI4ZWJkMDc5OTNlCi0tLSAvZGV2 L251bGwKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWRpdi1iaXRtYXNrLmgK QEAgLTAsMCArMSw0MyBAQAorI2luY2x1ZGUgPHN0ZGlvLmg+CisKKyNpZm5kZWYgTgorI2RlZmlu ZSBOIDY1CisjZW5kaWYKKworI2lmbmRlZiBUWVBFCisjZGVmaW5lIFRZUEUgdWludDMyX3QKKyNl bmRpZgorCisjaWZuZGVmIERFQlVHCisjZGVmaW5lIERFQlVHIDAKKyNlbmRpZgorCisjZGVmaW5l IEJBU0UgKChUWVBFKSAtMSA8IDAgPyAtMTI2IDogNCkKKworaW50IG1haW4gKCkKK3sKKyAgVFlQ RSBhW05dOworICBUWVBFIGJbTl07CisKKyAgZm9yIChpbnQgaSA9IDA7IGkgPCBOOyArK2kpCisg ICAgeworICAgICAgYVtpXSA9IEJBU0UgKyBpICogMTM7CisgICAgICBiW2ldID0gQkFTRSArIGkg KiAxMzsKKyAgICAgIGlmIChERUJVRykKKyAgICAgICAgcHJpbnRmICgiJWQ6IDB4JXhcbiIsIGks IGFbaV0pOworICAgIH0KKworICBmdW4xIChhLCBOIC8gMiwgTik7CisgIGZ1bjIgKGIsIE4gLyAy LCBOKTsKKworICBmb3IgKGludCBpID0gMDsgaSA8IE47ICsraSkKKyAgICB7CisgICAgICBpZiAo REVCVUcpCisgICAgICAgIHByaW50ZiAoIiVkID0gMHgleCA9PSAweCV4XG4iLCBpLCBhW2ldLCBi W2ldKTsKKworICAgICAgaWYgKGFbaV0gIT0gYltpXSkKKyAgICAgICAgX19idWlsdGluX2Fib3J0 ICgpOworICAgIH0KKyAgcmV0dXJuIDA7Cit9CisKZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3Qt Z2VuZXJpYy5jYyBiL2djYy90cmVlLXZlY3QtZ2VuZXJpYy5jYwppbmRleCAzNTAxMjk1NTVhMGM3 MWMwODk2YzRmMTAwMzE2M2YzYjM1NTdjMTFiLi42YWQ2MzcyYzU1ZWVmOTRhNzQyYThmYTM1ZTc5 ZDY2YWEyNGUyZjNiIDEwMDY0NAotLS0gYS9nY2MvdHJlZS12ZWN0LWdlbmVyaWMuY2MKKysrIGIv Z2NjL3RyZWUtdmVjdC1nZW5lcmljLmNjCkBAIC0xMjM3LDYgKzEyMzcsMTcgQEAgZXhwYW5kX3Zl Y3Rvcl9vcGVyYXRpb24gKGdpbXBsZV9zdG10X2l0ZXJhdG9yICpnc2ksIHRyZWUgdHlwZSwgdHJl ZSBjb21wdXRlX3R5cGUKIAkgIHRyZWUgcmhzMiA9IGdpbXBsZV9hc3NpZ25fcmhzMiAoYXNzaWdu KTsKIAkgIHRyZWUgcmV0OwogCisJICAvKiBDaGVjayBpZiB0aGUgdGFyZ2V0IHdhcyBnb2luZyB0 byBoYW5kbGUgaXQgdGhyb3VnaCB0aGUgc3BlY2lhbAorCSAgICAgZGl2aXNpb24gY2FsbGJhY2sg aG9vay4gICovCisJICB0cmVlIGNzdCA9IHVuaWZvcm1faW50ZWdlcl9jc3RfcCAocmhzMik7CisJ ICBpZiAoY3N0ICYmCisJICAgICAgdGFyZ2V0bS52ZWN0b3JpemUuY2FuX3NwZWNpYWxfZGl2X2J5 X2NvbnN0IChjb2RlLCB0eXBlLAorCQkJCQkJCSAgd2k6OnRvX3dpZGUgKGNzdCksCisJCQkJCQkJ ICBOVUxMLAorCQkJCQkJCSAgTlVMTF9SVFgsIE5VTExfUlRYKSkKKwkgICAgcmV0dXJuIE5VTExf VFJFRTsKKworCiAJICBpZiAoIW9wdGltaXplCiAJICAgICAgfHwgIVZFQ1RPUl9JTlRFR0VSX1RZ UEVfUCAodHlwZSkKIAkgICAgICB8fCBUUkVFX0NPREUgKHJoczIpICE9IFZFQ1RPUl9DU1QKZGlm ZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtcGF0dGVybnMuY2MgYi9nY2MvdHJlZS12ZWN0LXBhdHRl cm5zLmNjCmluZGV4IDA5NTc0YmIxYTI2OTZiMzQzOGE0Y2U5ZjA5Zjc0YjQyZTc4NGFjYTAuLmU5 MWJjZWY1NmZmZjkzMWE3YTdiYTUzNGEwYWZmZDU2ZTczMTQzNzAgMTAwNjQ0Ci0tLSBhL2djYy90 cmVlLXZlY3QtcGF0dGVybnMuY2MKKysrIGIvZ2NjL3RyZWUtdmVjdC1wYXR0ZXJucy5jYwpAQCAt MzQzMiw3ICszNDMyLDcgQEAgdmVjdF9yZWNvZ19kaXZtb2RfcGF0dGVybiAodmVjX2luZm8gKnZp bmZvLAogICBnaW1wbGUgKnBhdHRlcm5fc3RtdCwgKmRlZl9zdG10OwogICBlbnVtIHRyZWVfY29k ZSByaHNfY29kZTsKICAgb3B0YWIgb3B0YWI7Ci0gIHRyZWUgcTsKKyAgdHJlZSBxLCBjc3Q7CiAg IGludCBkdW1teV9pbnQsIHByZWM7CiAKICAgaWYgKCFpc19naW1wbGVfYXNzaWduIChsYXN0X3N0 bXQpKQpAQCAtMzU5Niw2ICszNTk2LDE0IEBAIHZlY3RfcmVjb2dfZGl2bW9kX3BhdHRlcm4gKHZl Y19pbmZvICp2aW5mbywKIAogICAgICAgcmV0dXJuIHBhdHRlcm5fc3RtdDsKICAgICB9CisgIGVs c2UgaWYgKChjc3QgPSB1bmlmb3JtX2ludGVnZXJfY3N0X3AgKG9wcm5kMSkpCisJICAgJiYgdGFy Z2V0bS52ZWN0b3JpemUuY2FuX3NwZWNpYWxfZGl2X2J5X2NvbnN0IChyaHNfY29kZSwgdmVjdHlw ZSwKKwkJCQkJCQkgIHdpOjp0b193aWRlIChjc3QpLAorCQkJCQkJCSAgTlVMTCwgTlVMTF9SVFgs CisJCQkJCQkJICBOVUxMX1JUWCkpCisgICAgeworICAgICAgcmV0dXJuIE5VTEw7CisgICAgfQog CiAgIGlmIChwcmVjID4gSE9TVF9CSVRTX1BFUl9XSURFX0lOVAogICAgICAgfHwgaW50ZWdlcl96 ZXJvcCAob3BybmQxKSkKZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3Qtc3RtdHMuY2MgYi9nY2Mv dHJlZS12ZWN0LXN0bXRzLmNjCmluZGV4IGM5ZGFiMjE3ZjA1OWYxN2U5MWU5YTc1ODI1MjNlNjI3 ZDdhNDViNjYuLjEzOTljMjJiYTBkZjc1ZjU4Mjg4N2Q3ZTgzYjY3ZTNlYTUzZDI1ZjQgMTAwNjQ0 Ci0tLSBhL2djYy90cmVlLXZlY3Qtc3RtdHMuY2MKKysrIGIvZ2NjL3RyZWUtdmVjdC1zdG10cy5j YwpAQCAtNjI2MCw2ICs2MjYwLDE0IEBAIHZlY3Rvcml6YWJsZV9vcGVyYXRpb24gKHZlY19pbmZv ICp2aW5mbywKIAl9CiAgICAgICB0YXJnZXRfc3VwcG9ydF9wID0gKG9wdGFiX2hhbmRsZXIgKG9w dGFiLCB2ZWNfbW9kZSkKIAkJCSAgIT0gQ09ERV9GT1Jfbm90aGluZyk7CisgICAgICB0cmVlIGNz dDsKKyAgICAgIGlmICghdGFyZ2V0X3N1cHBvcnRfcAorCSAgJiYgKGNzdCA9IHVuaWZvcm1faW50 ZWdlcl9jc3RfcCAob3AxKSkpCisJdGFyZ2V0X3N1cHBvcnRfcAorCSAgPSB0YXJnZXRtLnZlY3Rv cml6ZS5jYW5fc3BlY2lhbF9kaXZfYnlfY29uc3QgKGNvZGUsIHZlY3R5cGUsCisJCQkJCQkJd2k6 OnRvX3dpZGUgKGNzdCksCisJCQkJCQkJTlVMTCwgTlVMTF9SVFgsCisJCQkJCQkJTlVMTF9SVFgp OwogICAgIH0KIAogICBib29sIHVzaW5nX2VtdWxhdGVkX3ZlY3RvcnNfcCA9IHZlY3RfZW11bGF0 ZWRfdmVjdG9yX3AgKHZlY3R5cGUpOwo= --_002_VI1PR08MB5325C56878364315686EBD99FF379VI1PR08MB5325eurp_--