From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR05-VI1-obe.outbound.protection.outlook.com (mail-vi1eur05on2062.outbound.protection.outlook.com [40.107.21.62]) by sourceware.org (Postfix) with ESMTPS id 419C43858D37 for ; Mon, 20 Nov 2023 21:57:57 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 419C43858D37 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-Filter: OpenARC Filter v1.0.0 sourceware.org 419C43858D37 Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=40.107.21.62 ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1700517481; cv=pass; b=ZMsgi5Zs3XCf0i0U7H7Nzhh4//Tr3wQ0E3xrH4thDyUjOVY3NrwTPy0F4xxgtQd9JdDCtxr0UAyVVMID29+CXGNXNeg7EOWO1Or7VZW4z0zfgVIZQBqdUnFusvBcP4gtt//s4TYOwKp4q/VfkVKsnRAKHhlFFcMIoP7cOQBRJ0Q= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1700517481; c=relaxed/simple; bh=pPwGPqBDVqvSwPyGOxVsl/ywXawO1uM+0+20BqxSqMI=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=OOEIUlZlipCmQj+zR3x81RRRC287x+KJCqbBRNYSTwBiLH/gTbumoB5LT2Yk7Ep2QlH4BIDUPXTfEwAw1jBDlH2aaEpGuvRzCVIcM6/9uLlSuCVCr18LpGZEpfpPL2uiKDZeBVtX6Zc23nVQcNeTBzfsWUbFgutHr9hG6CAPs/k= ARC-Authentication-Results: i=3; server2.sourceware.org ARC-Seal: i=2; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=pass; b=DB+m3k8PCqA/huZRnEgT+ffG2MSb+baNd6any3EYmQGiG8SZKdENqNRwvDFvGdlQ/C94O5fe0XFwrahP1gstccMG5GD1FhOIFC1aazdK2ihqSOSN/xgq8oT1VVY+QRvk13qfhEHuxo5kUI5xdc458I+u6owoWtS9jgjUWVvFUgXXc73Z/TEDWW4CLivRQQQI5vRsHe4GSQxkBxzDmLWbP1s45Dd36AD5hcIqTf7rD3Y9tLUieSfxeo5sU/0NZu3vrGNvUjlpH5ixzHq3yj1emLyvLk3Ws+zZd5fK0qA9ah9nw2RLR5TfaxsXN3t3fa593NUoWLJjOCA3bZQaATj1jw== 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=HoQ9TXUJKcE0T05uK0vWvyMB6IhssiAtDHkhmJxKnYM=; b=k9VeibJtqxUGcquV/uVxTyFtUiqxXY3rgEF2rVpR0GR7lq+zSMGOlUHs9NrWUFG99TumLI7j6oDnvuOmUHNhy/CSTARb/sEAV4D9mMv5kb4jcPBD5rGT06sPlznxijfbCViLsxZ0TJe1I/ZSfTWnq+DdIpGPl1QQD4gNRR4/hl1wBtKIudiZpSD/y9BFatvqR4CbhPL8WLuecY3kmBuCdZ0oyGp1FFgPlOtIhHu5oZBkmEcuiZEGYJZbNkQybRyUQ/ey5mAS8mz4Fl5o5Or1Bj4erwkXAuhT/yxASAJ65P1FnX3KAmZJLU5VOet/dz1UXfcXu0VOp1ZSOc9gsZ83Ew== 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=HoQ9TXUJKcE0T05uK0vWvyMB6IhssiAtDHkhmJxKnYM=; b=guMzSFfH+mf//MzcB86Fk3X+KIlISvf2aPshmjk3UEjnFFIVNtIUR5r6olIFI3N75wmKpRZwAnANa/3PtfBu1p5ctViDgGYhPGIiT2s4hn6zZpRcpU0YII3C26+qfoe7j0HO9xDd1wdPybDPV+SVF9hCgadzqKFtL25RXs2XO04= Received: from AM0PR07CA0035.eurprd07.prod.outlook.com (2603:10a6:208:ac::48) by GV2PR08MB8727.eurprd08.prod.outlook.com (2603:10a6:150:b6::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7002.26; Mon, 20 Nov 2023 21:57:49 +0000 Received: from AM3PEPF00009BA2.eurprd04.prod.outlook.com (2603:10a6:208:ac:cafe::3d) by AM0PR07CA0035.outlook.office365.com (2603:10a6:208:ac::48) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7025.16 via Frontend Transport; Mon, 20 Nov 2023 21:57:49 +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 AM3PEPF00009BA2.mail.protection.outlook.com (10.167.16.27) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7025.13 via Frontend Transport; Mon, 20 Nov 2023 21:57:48 +0000 Received: ("Tessian outbound 7671e7ddc218:v228"); Mon, 20 Nov 2023 21:57:48 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: 98209b792e6cd783 X-CR-MTA-TID: 64aa7808 Received: from c4d3b9308879.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id F00DDEC3-4895-4F05-B45D-ED399DD22D4D.1; Mon, 20 Nov 2023 21:57:41 +0000 Received: from EUR02-AM0-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id c4d3b9308879.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Mon, 20 Nov 2023 21:57:41 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=h1O9QFJwYhckXObp5X6bqZHsdIJqyIGIcCiwi215H0cRZ09U8Z/06oEJiEsBbF2kCpewnxG1UcrQbuN7LTjlBCE1CWUoHhf7TVDTeC0gjUGPcH0sL5df+fXYjGXnTGFDvlrY+7IamXu+TwZELpbEVJJectgs7dNZhgoHV8eEXxyfu/SZhhfOL4ooq3hJ/iM6v1fiVBZzbwsZMZPDCpK5NgV6EfOwj6UbEDp4cYkAV+AV4jN6fvE7p6pdDeC/pj0XxKgfLjnq5+06Lfq/mHkhNiX97FbU901ekdI8xtq7sfc/ZEZoCCpXq9hPi3XLSrrlxnietBQM/Q+oBlTBkXsLcA== 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=HoQ9TXUJKcE0T05uK0vWvyMB6IhssiAtDHkhmJxKnYM=; b=RgODYubwNteUucQTkkf5GAnZdtd9UZwQZ+WRII3l6/QG4CsSOjswBke322frR2N1JJtXQ3/O7dHb70R41B+Oi7nO9UBHd0HiZGCsjwfMVLghTqXOlCjQtZeDM8ebq4c0qONOwkyfjNoYARi61tQ5kUBA3vhrhZVAYrsMNj3NAA12qORRJbIJqZDSGHk3efkVdA3pz9EZjxHIC5smOunezspyUbZcOJ3ZuKDSaPIDb6yjKtx8ew5fi2Q/TJouczdBdJYutAp+9keG1RE1UBSzoUW6/e/qmjCy42GHt9piPwYramOKgnfpbSMWywNIvBGFMTC/u9txeziSeQnRQbOtAA== 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=HoQ9TXUJKcE0T05uK0vWvyMB6IhssiAtDHkhmJxKnYM=; b=guMzSFfH+mf//MzcB86Fk3X+KIlISvf2aPshmjk3UEjnFFIVNtIUR5r6olIFI3N75wmKpRZwAnANa/3PtfBu1p5ctViDgGYhPGIiT2s4hn6zZpRcpU0YII3C26+qfoe7j0HO9xDd1wdPybDPV+SVF9hCgadzqKFtL25RXs2XO04= Received: from VI1PR08MB5325.eurprd08.prod.outlook.com (2603:10a6:803:13e::17) by VI0PR08MB10511.eurprd08.prod.outlook.com (2603:10a6:800:202::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7002.27; Mon, 20 Nov 2023 21:57:39 +0000 Received: from VI1PR08MB5325.eurprd08.prod.outlook.com ([fe80::9679:2ab0:99c6:54a3]) by VI1PR08MB5325.eurprd08.prod.outlook.com ([fe80::9679:2ab0:99c6:54a3%6]) with mapi id 15.20.7002.028; Mon, 20 Nov 2023 21:57:38 +0000 From: Tamar Christina To: Richard Biener CC: "gcc-patches@gcc.gnu.org" , nd , "jlaw@ventanamicro.com" Subject: RE: [PATCH 8/21]middle-end: update vectorizable_live_reduction with support for multiple exits and different exits Thread-Topic: [PATCH 8/21]middle-end: update vectorizable_live_reduction with support for multiple exits and different exits Thread-Index: AQHaEIRfThgW3PldRkqGsgaI/BlARbB6jVXQgADknwCAAAlP4IABYGMAgAb7u4A= Date: Mon, 20 Nov 2023 21:57:38 +0000 Message-ID: References: In-Reply-To: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: yes X-MS-TNEF-Correlator: Authentication-Results-Original: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=arm.com; x-ms-traffictypediagnostic: VI1PR08MB5325:EE_|VI0PR08MB10511:EE_|AM3PEPF00009BA2:EE_|GV2PR08MB8727:EE_ X-MS-Office365-Filtering-Correlation-Id: 4e17e056-a3a9-4939-091b-08dbea13bc5c 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: 9FW/EkPQm4wxsslErnzw8HBFGVLQFxjyG3WfeygGolsmDKq4ovocNuvq1nAapRPFJ5IxUvn7rlq9TtUkJHC5TBt1ZCjJ9QeC74TV435VVbW5oqgu4jXDVllt8+K/FqM3p238wuvn+7paDeE/+xLhIInP1Yj9Mdy9zTlM0F4dR3Utzxv7VtVD3Q9fbPqXCwpDK30COydA+algU98JLl9NpjqOAkI6MrCoyqQuilgPQEyhxezIkIOhGCx+u+/WaEd3vsR6xyW20iOTiBu9KPsDkuj1VsaB8gUdaSiSHSf2rH/0KEhzYmwIyLeB4lidL3bpm2vyBslInQi65g0o85wzXMaVeJA8t2misafIHZY9qKGQcSTVy2cN8alP10FPYfWGLPZG2N62GJBs13dKQf85saWBlva1nJKIdN8RU5f27AVMbqM6bYozM5g9cwKW2VRSjLZh4A5P5dZttnj6Ek79cX2gRubWBz4TDDRgJ1+GCmV8rhgmOWoOL5/lX1gHhG9gaa4GlNBASqbSfaFwo+63O1vpotwdKcc6aKtFsU4vc2dHvtRKuI9ZUfmyda36Ct07V4ZSeGrp8WAPm00QicaYevTOgDuEP5oSPvfPtqek8gsB2eaGYGu/iqnGXWra3aCX 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:(13230031)(39860400002)(366004)(396003)(376002)(346002)(136003)(230922051799003)(1800799012)(186009)(451199024)(64100799003)(2906002)(55016003)(8936002)(52536014)(41300700001)(4326008)(8676002)(15650500001)(5660300002)(30864003)(316002)(6916009)(64756008)(66556008)(66476007)(66446008)(76116006)(54906003)(66946007)(86362001)(478600001)(38070700009)(26005)(71200400001)(9686003)(7696005)(6506007)(99936003)(83380400001)(33656002)(122000001)(38100700002)(559001)(579004);DIR:OUT;SFP:1101; Content-Type: multipart/mixed; boundary="_002_VI1PR08MB5325326E1AF88F3235E641DBFFB4AVI1PR08MB5325eurp_" MIME-Version: 1.0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI0PR08MB10511 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: AM3PEPF00009BA2.eurprd04.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: 1bd1f718-6850-478c-96bb-08dbea13b674 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: yvKmJzCr+7wDRybGVZ6OMofPRgoxCN+9uYfn9jVN7S0/eYmb9D2z2iJt3t3L2jCpZPTQbixjyGNPXyBTu0UjcnjpFVvnFI3w2dfig38wotPrN3FyTLKpTs+swJPSWFZculPgFcG40Rg2xWYNskHafBbpCt4GJhJckF/lzooeJ4Nm/CI5zcPR1z/RNq3cBdTm6nWdX6I51eIX9e/XXu1J22Gz/jvurEBJ0wRctNKHLxNJjfvxPOkSFtvBLdq9ks1pwdsPOE0AVZsTRAjQCekyX2MX4ew+F/g4XWVAMboiBMeg00b5gyrje47BNwCloHyZKYs8+8X+O8ukTSbCYe8mUwLbqDOacJqrvkh8+I2TsD4ygHglahXBxZ8A7rHK7/GbengvKXVD3Y810y6ZhkauDgZERut8WaA0YQpUeAjq8mDGXtCpRln6Mvq8ZYQlCK57m9aOPLrWSu6fcA9SMMJYMxYz+zsX2IiwtvJWOPvL9Y77Jw0lHnrqAhT437qFFE82pCGt5rCDi+YFBj3Rm8rCh+4rpzWg4h3Wiz2SiWBTT2MHwdF7LVcDWnQWZxTd4qTqO9pOZ2JZXnTggxbbI2spBzNoSc/ulvhRGC8/By+tx6OYPpOhkKkaDCx0YapR25gmiHRLcnRmzHlbdN2P2Wlp1QKpovnTVVqVYxpFaPAD4Ntkirf4BH+gA4F3fHRLc2PaLMDSaNIq37By/CPMlPOb+fRdj/JKse2kITUWsnYBH47TAANR+oJbp0i5e84V7xw+ 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:(13230031)(4636009)(136003)(376002)(346002)(396003)(39860400002)(230922051799003)(451199024)(82310400011)(186009)(64100799003)(1800799012)(40470700004)(36840700001)(46966006)(30864003)(15650500001)(107886003)(5660300002)(235185007)(2906002)(26005)(40460700003)(52536014)(8676002)(4326008)(6862004)(8936002)(41300700001)(86362001)(336012)(33656002)(47076005)(83380400001)(99936003)(81166007)(356005)(36860700001)(82740400003)(70206006)(54906003)(55016003)(70586007)(6506007)(7696005)(316002)(40480700001)(478600001)(9686003);DIR:OUT;SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Nov 2023 21:57:48.7858 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 4e17e056-a3a9-4939-091b-08dbea13bc5c 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: AM3PEPF00009BA2.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: GV2PR08MB8727 X-Spam-Status: No, score=-12.0 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,T_SCC_BODY_TEXT_LINE,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_VI1PR08MB5325326E1AF88F3235E641DBFFB4AVI1PR08MB5325eurp_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Good morning, Here's the respun patch, as discussed we now use reductions and inductions= rather than scalar values: This adds support to vectorizable_live_reduction to handle multiple exits b= y doing a search for which exit the live value should be materialized in. Additinally which value in the index we're after depends on whether the exi= t it's materialized in is an early exit or whether the loop's main exit is different from the loop's natural one (i.e. the one with the same src block= as the latch). In those two cases we want the first rather than the last value as we're go= ing to restart the iteration in the scalar loop. For VLA this means we need to reverse both the mask and vector since there's only a way to get the last active element and not the first. For inductions and multiple exits: - we test if the target will support vectorizing the induction - mark all inductions in the loop as relevant - for codegen of non-live inductions during codegen - induction during an early exit gets the first element rather than last. For reductions and multiple exits: - Reductions for early exits reduces the reduction definition statement rather than the reduction step. This allows us to get the value at the start of the iteration. - The peeling layout means that we just have to update one block, the mer= ge block. We expect all the reductions to be the same but we leave it up = to the value numbering to clean up any duplicate code as we iterate over a= ll edges. These two changes fix the reduction codegen given before which has been add= ed to the testsuite for early vect. Bootstrapped Regtested on aarch64-none-linux-gnu and no issues. Ok for master? Thanks, Tamar gcc/ChangeLog: * tree-vect-loop.cc (vectorizable_live_operation): Support early exits. (vect_analyze_loop_operations): Check if target supports vectorizing IV. (vect_transform_loop): Call vectorizable_live_operation for non-live inductions or reductions. (find_connected_edge, vectorizable_live_operation_1): New. (vect_create_epilog_for_reduction): Support reductions in early break. * tree-vect-stmts.cc (perm_mask_for_reverse): Expose. (vect_stmt_relevant_p): Mark all inductions when early break as being relevant. * tree-vectorizer.h (perm_mask_for_reverse): Expose. (vect_iv_increment_position): New. * tree-vect-loop-manip.cc (vect_iv_increment_position): Expose. --- inline copy of patch --- diff --git a/gcc/tree-vect-loop-manip.cc b/gcc/tree-vect-loop-manip.cc index 139311142b376d4eaa7ef8765608220b1eb92b31..af216d3dcb8a502639898ff67cb= 86948a7f140a4 100644 --- a/gcc/tree-vect-loop-manip.cc +++ b/gcc/tree-vect-loop-manip.cc @@ -453,7 +453,7 @@ vect_adjust_loop_lens_control (tree iv_type, gimple_seq= *seq, INSERT_AFTER is set to true if the increment should be inserted after *BSI. */ =20 -static void +void vect_iv_increment_position (edge loop_exit, gimple_stmt_iterator *bsi, bool *insert_after) { diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc index 8a50380de49bc12105be47ea1d8ee3cf1f2bdab4..b1c34c4c3aaf8bdf9bf52d5a726= 836936de772b6 100644 --- a/gcc/tree-vect-loop.cc +++ b/gcc/tree-vect-loop.cc @@ -2163,6 +2163,15 @@ vect_analyze_loop_operations (loop_vec_info loop_vin= fo) ok =3D vectorizable_live_operation (loop_vinfo, stmt_info, NULL, NULL= , -1, false, &cost_vec); =20 + /* Check if we can perform the operation for early break if we force + the live operation. */ + if (ok + && LOOP_VINFO_EARLY_BREAKS (loop_vinfo) + && !STMT_VINFO_LIVE_P (stmt_info) + && STMT_VINFO_DEF_TYPE (stmt_info) =3D=3D vect_induction_def) + ok =3D vectorizable_live_operation (loop_vinfo, stmt_info, NULL, NULL= , + -1, false, &cost_vec); + if (!ok) return opt_result::failure_at (phi, "not vectorized: relevant phi not " @@ -5842,6 +5851,10 @@ vect_create_partial_epilog (tree vec_def, tree vecty= pe, code_helper code, SLP_NODE_INSTANCE is the SLP node instance containing SLP_NODE REDUC_INDEX says which rhs operand of the STMT_INFO is the reduction ph= i (counting from 0) + LOOP_EXIT is the edge to update in the merge block. In the case of a s= ingle + exit this edge is always the main loop exit. + MAIN_EXIT_P indicates whether we are updating the main exit or an alter= nate + exit. This determines whether we use the final or original value. =20 This function: 1. Completes the reduction def-use cycles. @@ -5882,7 +5895,9 @@ static void vect_create_epilog_for_reduction (loop_vec_info loop_vinfo, stmt_vec_info stmt_info, slp_tree slp_node, - slp_instance slp_node_instance) + slp_instance slp_node_instance, + edge loop_exit, + bool main_exit_p =3D true) { stmt_vec_info reduc_info =3D info_for_reduction (loop_vinfo, stmt_info); gcc_assert (reduc_info->is_reduc_info); @@ -6053,7 +6068,7 @@ vect_create_epilog_for_reduction (loop_vec_info loop_= vinfo, /* Create an induction variable. */ gimple_stmt_iterator incr_gsi; bool insert_after; - standard_iv_increment_position (loop, &incr_gsi, &insert_after); + vect_iv_increment_position (loop_exit, &incr_gsi, &insert_after); create_iv (series_vect, PLUS_EXPR, vec_step, NULL_TREE, loop, &incr_= gsi, insert_after, &indx_before_incr, &indx_after_incr); =20 @@ -6132,23 +6147,30 @@ vect_create_epilog_for_reduction (loop_vec_info loo= p_vinfo, Store them in NEW_PHIS. */ if (double_reduc) loop =3D outer_loop; - exit_bb =3D LOOP_VINFO_IV_EXIT (loop_vinfo)->dest; + /* We need to reduce values in all exits. */ + exit_bb =3D loop_exit->dest; exit_gsi =3D gsi_after_labels (exit_bb); reduc_inputs.create (slp_node ? vec_num : ncopies); + vec vec_stmts; + if (main_exit_p) + vec_stmts =3D STMT_VINFO_VEC_STMTS (rdef_info); + else + vec_stmts =3D STMT_VINFO_VEC_STMTS (STMT_VINFO_REDUC_DEF (rdef_info)); + for (unsigned i =3D 0; i < vec_num; i++) { gimple_seq stmts =3D NULL; if (slp_node) def =3D vect_get_slp_vect_def (slp_node, i); else - def =3D gimple_get_lhs (STMT_VINFO_VEC_STMTS (rdef_info)[0]); + def =3D gimple_get_lhs (vec_stmts[0]); for (j =3D 0; j < ncopies; j++) { tree new_def =3D copy_ssa_name (def); phi =3D create_phi_node (new_def, exit_bb); if (j) - def =3D gimple_get_lhs (STMT_VINFO_VEC_STMTS (rdef_info)[j]); - SET_PHI_ARG_DEF (phi, LOOP_VINFO_IV_EXIT (loop_vinfo)->dest_idx, def); + def =3D gimple_get_lhs (vec_stmts[j]); + SET_PHI_ARG_DEF (phi, loop_exit->dest_idx, def); new_def =3D gimple_convert (&stmts, vectype, new_def); reduc_inputs.quick_push (new_def); } @@ -6885,7 +6907,20 @@ vect_create_epilog_for_reduction (loop_vec_info loop= _vinfo, FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name) { FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter) - SET_USE (use_p, scalar_result); + { + gimple *stmt =3D USE_STMT (use_p); + if (main_exit_p) + SET_USE (use_p, scalar_result); + else if (is_a (stmt)) + { + /* If an early exit only update usages in the merge + block. */ + edge merge_e =3D single_succ_edge (loop_exit->dest); + if (gimple_bb (stmt) !=3D merge_e->dest) + continue; + SET_PHI_ARG_DEF (stmt, merge_e->dest_idx, scalar_result); + } + } update_stmt (use_stmt); } } @@ -10481,6 +10516,156 @@ vectorizable_induction (loop_vec_info loop_vinfo, return true; } =20 +/* Function vectorizable_live_operation_1. + + helper function for vectorizable_live_operation. */ + +tree +vectorizable_live_operation_1 (loop_vec_info loop_vinfo, + stmt_vec_info stmt_info, edge exit_e, + tree vectype, int ncopies, slp_tree slp_node, + tree bitsize, tree bitstart, tree vec_lhs, + tree lhs_type, bool restart_loop, + gimple_stmt_iterator *exit_gsi) +{ + basic_block exit_bb =3D exit_e->dest; + gcc_assert (single_pred_p (exit_bb) || LOOP_VINFO_EARLY_BREAKS (loop_vin= fo)); + + tree vec_lhs_phi =3D copy_ssa_name (vec_lhs); + gimple *phi =3D create_phi_node (vec_lhs_phi, exit_bb); + for (unsigned i =3D 0; i < gimple_phi_num_args (phi); i++) + SET_PHI_ARG_DEF (phi, i, vec_lhs); + + gimple_seq stmts =3D NULL; + tree new_tree; + if (LOOP_VINFO_FULLY_WITH_LENGTH_P (loop_vinfo)) + { + /* Emit: + + SCALAR_RES =3D VEC_EXTRACT + + where VEC_LHS is the vectorized live-out result and MASK is + the loop mask for the final iteration. */ + gcc_assert (ncopies =3D=3D 1 && !slp_node); + gimple_seq tem =3D NULL; + gimple_stmt_iterator gsi =3D gsi_last (tem); + tree len =3D vect_get_loop_len (loop_vinfo, &gsi, + &LOOP_VINFO_LENS (loop_vinfo), + 1, vectype, 0, 0); + + /* BIAS - 1. */ + signed char biasval =3D LOOP_VINFO_PARTIAL_LOAD_STORE_BIAS (loop_vin= fo); + tree bias_minus_one + =3D int_const_binop (MINUS_EXPR, + build_int_cst (TREE_TYPE (len), biasval), + build_one_cst (TREE_TYPE (len))); + + /* LAST_INDEX =3D LEN + (BIAS - 1). */ + tree last_index =3D gimple_build (&stmts, PLUS_EXPR, TREE_TYPE (len)= , + len, bias_minus_one); + + /* This needs to implement extraction of the first index, but not su= re + how the LEN stuff works. At the moment we shouldn't get here since + there's no LEN support for early breaks. But guard this so there's + no incorrect codegen. */ + gcc_assert (!LOOP_VINFO_EARLY_BREAKS (loop_vinfo)); + + /* SCALAR_RES =3D VEC_EXTRACT . */ + tree scalar_res + =3D gimple_build (&stmts, CFN_VEC_EXTRACT, TREE_TYPE (vectype), + vec_lhs_phi, last_index); + + /* Convert the extracted vector element to the scalar type. */ + new_tree =3D gimple_convert (&stmts, lhs_type, scalar_res); + } + else if (LOOP_VINFO_FULLY_MASKED_P (loop_vinfo)) + { + /* Emit: + + SCALAR_RES =3D EXTRACT_LAST + + where VEC_LHS is the vectorized live-out result and MASK is + the loop mask for the final iteration. */ + gcc_assert (!slp_node); + tree scalar_type =3D TREE_TYPE (STMT_VINFO_VECTYPE (stmt_info)); + gimple_seq tem =3D NULL; + gimple_stmt_iterator gsi =3D gsi_last (tem); + tree mask =3D vect_get_loop_mask (loop_vinfo, &gsi, + &LOOP_VINFO_MASKS (loop_vinfo), + 1, vectype, 0); + tree scalar_res; + + /* For an inverted control flow with early breaks we want EXTRACT_FI= RST + instead of EXTRACT_LAST. Emulate by reversing the vector and mask. */ + if (restart_loop && LOOP_VINFO_EARLY_BREAKS (loop_vinfo)) + { + /* First create the permuted mask. */ + tree perm_mask =3D perm_mask_for_reverse (TREE_TYPE (mask)); + tree perm_dest =3D copy_ssa_name (mask); + gimple *perm_stmt + =3D gimple_build_assign (perm_dest, VEC_PERM_EXPR, mask, + mask, perm_mask); + vect_finish_stmt_generation (loop_vinfo, stmt_info, perm_stmt, + &gsi); + mask =3D perm_dest; + + /* Then permute the vector contents. */ + tree perm_elem =3D perm_mask_for_reverse (vectype); + perm_dest =3D copy_ssa_name (vec_lhs_phi); + perm_stmt + =3D gimple_build_assign (perm_dest, VEC_PERM_EXPR, vec_lhs_phi, + vec_lhs_phi, perm_elem); + vect_finish_stmt_generation (loop_vinfo, stmt_info, perm_stmt, + &gsi); + vec_lhs_phi =3D perm_dest; + } + + gimple_seq_add_seq (&stmts, tem); + + scalar_res =3D gimple_build (&stmts, CFN_EXTRACT_LAST, scalar_type, + mask, vec_lhs_phi); + + /* Convert the extracted vector element to the scalar type. */ + new_tree =3D gimple_convert (&stmts, lhs_type, scalar_res); + } + else + { + tree bftype =3D TREE_TYPE (vectype); + if (VECTOR_BOOLEAN_TYPE_P (vectype)) + bftype =3D build_nonstandard_integer_type (tree_to_uhwi (bitsize), 1); + new_tree =3D build3 (BIT_FIELD_REF, bftype, vec_lhs_phi, bitsize, bi= tstart); + new_tree =3D force_gimple_operand (fold_convert (lhs_type, new_tree)= , + &stmts, true, NULL_TREE); + } + + *exit_gsi =3D gsi_after_labels (exit_bb); + if (stmts) + gsi_insert_seq_before (exit_gsi, stmts, GSI_SAME_STMT); + + return new_tree; +} + +/* Find the edge that's the final one in the path from SRC to DEST and + return it. This edge must exist in at most one forwarder edge between.= */ + +static edge +find_connected_edge (edge src, basic_block dest) +{ + if (src->dest =3D=3D dest) + return src; + + edge e; + edge_iterator ei; + + FOR_EACH_EDGE (e, ei, dest->preds) + { + if (src->dest =3D=3D e->src) + return e; + } + + return NULL; +} + /* Function vectorizable_live_operation. =20 STMT_INFO computes a value that is used outside the loop. Check if @@ -10505,7 +10690,8 @@ vectorizable_live_operation (vec_info *vinfo, stmt_= vec_info stmt_info, int vec_entry =3D 0; poly_uint64 vec_index =3D 0; =20 - gcc_assert (STMT_VINFO_LIVE_P (stmt_info)); + gcc_assert (STMT_VINFO_LIVE_P (stmt_info) + || LOOP_VINFO_EARLY_BREAKS (loop_vinfo)); =20 /* If a stmt of a reduction is live, vectorize it via vect_create_epilog_for_reduction. vectorizable_reduction assessed @@ -10530,8 +10716,22 @@ vectorizable_live_operation (vec_info *vinfo, stmt= _vec_info stmt_info, if (STMT_VINFO_REDUC_TYPE (reduc_info) =3D=3D FOLD_LEFT_REDUCTION || STMT_VINFO_REDUC_TYPE (reduc_info) =3D=3D EXTRACT_LAST_REDUCTION) return true; + + /* If early break we only have to materialize the reduction on the m= erge + block, but we have to find an alternate exit first. */ + if (LOOP_VINFO_EARLY_BREAKS (loop_vinfo)) + { + for (auto exit : get_loop_exit_edges (LOOP_VINFO_LOOP (loop_vinfo))) + if (exit !=3D LOOP_VINFO_IV_EXIT (loop_vinfo)) + vect_create_epilog_for_reduction (loop_vinfo, stmt_info, + slp_node, slp_node_instance, + exit, false); + } + vect_create_epilog_for_reduction (loop_vinfo, stmt_info, slp_node, - slp_node_instance); + slp_node_instance, + LOOP_VINFO_IV_EXIT (loop_vinfo)); + return true; } =20 @@ -10683,103 +10883,62 @@ vectorizable_live_operation (vec_info *vinfo, st= mt_vec_info stmt_info, lhs' =3D new_tree; */ =20 class loop *loop =3D LOOP_VINFO_LOOP (loop_vinfo); - basic_block exit_bb =3D LOOP_VINFO_IV_EXIT (loop_vinfo)->dest; - gcc_assert (single_pred_p (exit_bb)); - - tree vec_lhs_phi =3D copy_ssa_name (vec_lhs); - gimple *phi =3D create_phi_node (vec_lhs_phi, exit_bb); - SET_PHI_ARG_DEF (phi, LOOP_VINFO_IV_EXIT (loop_vinfo)->dest_idx, vec= _lhs); - - gimple_seq stmts =3D NULL; - tree new_tree; - if (LOOP_VINFO_FULLY_WITH_LENGTH_P (loop_vinfo)) - { - /* Emit: - - SCALAR_RES =3D VEC_EXTRACT - - where VEC_LHS is the vectorized live-out result and MASK is - the loop mask for the final iteration. */ - gcc_assert (ncopies =3D=3D 1 && !slp_node); - gimple_seq tem =3D NULL; - gimple_stmt_iterator gsi =3D gsi_last (tem); - tree len - =3D vect_get_loop_len (loop_vinfo, &gsi, - &LOOP_VINFO_LENS (loop_vinfo), - 1, vectype, 0, 0); - - /* BIAS - 1. */ - signed char biasval =3D LOOP_VINFO_PARTIAL_LOAD_STORE_BIAS (loop_vinfo)= ; - tree bias_minus_one - =3D int_const_binop (MINUS_EXPR, - build_int_cst (TREE_TYPE (len), biasval), - build_one_cst (TREE_TYPE (len))); - - /* LAST_INDEX =3D LEN + (BIAS - 1). */ - tree last_index =3D gimple_build (&stmts, PLUS_EXPR, TREE_TYPE (len), - len, bias_minus_one); - - /* SCALAR_RES =3D VEC_EXTRACT . */ - tree scalar_res - =3D gimple_build (&stmts, CFN_VEC_EXTRACT, TREE_TYPE (vectype), - vec_lhs_phi, last_index); - - /* Convert the extracted vector element to the scalar type. */ - new_tree =3D gimple_convert (&stmts, lhs_type, scalar_res); - } - else if (LOOP_VINFO_FULLY_MASKED_P (loop_vinfo)) - { - /* Emit: - - SCALAR_RES =3D EXTRACT_LAST - - where VEC_LHS is the vectorized live-out result and MASK is - the loop mask for the final iteration. */ - gcc_assert (ncopies =3D=3D 1 && !slp_node); - tree scalar_type =3D TREE_TYPE (STMT_VINFO_VECTYPE (stmt_info)); - gimple_seq tem =3D NULL; - gimple_stmt_iterator gsi =3D gsi_last (tem); - tree mask =3D vect_get_loop_mask (loop_vinfo, &gsi, - &LOOP_VINFO_MASKS (loop_vinfo), - 1, vectype, 0); - gimple_seq_add_seq (&stmts, tem); - tree scalar_res =3D gimple_build (&stmts, CFN_EXTRACT_LAST, scalar_type= , - mask, vec_lhs_phi); - - /* Convert the extracted vector element to the scalar type. */ - new_tree =3D gimple_convert (&stmts, lhs_type, scalar_res); - } - else - { - tree bftype =3D TREE_TYPE (vectype); - if (VECTOR_BOOLEAN_TYPE_P (vectype)) - bftype =3D build_nonstandard_integer_type (tree_to_uhwi (bitsize), 1)= ; - new_tree =3D build3 (BIT_FIELD_REF, bftype, - vec_lhs_phi, bitsize, bitstart); - new_tree =3D force_gimple_operand (fold_convert (lhs_type, new_tree), - &stmts, true, NULL_TREE); - } + /* Check if we have a loop where the chosen exit is not the main exi= t, + in these cases for an early break we restart the iteration the vector co= de + did. For the live values we want the value at the start of the iteratio= n + rather than at the end. */ + edge main_e =3D LOOP_VINFO_IV_EXIT (loop_vinfo); + bool restart_loop =3D !vect_is_loop_exit_latch_pred (main_e, loop); + FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, lhs) + if (!is_gimple_debug (use_stmt) + && !flow_bb_inside_loop_p (loop, gimple_bb (use_stmt))) + { + basic_block use_bb =3D gimple_bb (use_stmt); + if (!is_a (use_stmt)) + continue; + for (auto exit_e : get_loop_exit_edges (loop)) + { + /* See if this exit leads to the value. */ + edge dest_e =3D find_connected_edge (exit_e, use_bb); + if (!dest_e || PHI_ARG_DEF_FROM_EDGE (use_stmt, dest_e) !=3D lhs) + continue; =20 - gimple_stmt_iterator exit_gsi =3D gsi_after_labels (exit_bb); - if (stmts) - gsi_insert_seq_before (&exit_gsi, stmts, GSI_SAME_STMT); + gimple *tmp_vec_stmt =3D vec_stmt; + tree tmp_vec_lhs =3D vec_lhs; + tree tmp_bitstart =3D bitstart; + /* For early exit where the exit is not in the BB that leads + to the latch then we're restarting the iteration in the + scalar loop. So get the first live value. */ + if (restart_loop || exit_e !=3D main_e) + { + tmp_vec_stmt =3D STMT_VINFO_VEC_STMTS (stmt_info)[0]; + tmp_vec_lhs =3D gimple_get_lhs (tmp_vec_stmt); + tmp_bitstart =3D build_zero_cst (TREE_TYPE (bitstart)); + } =20 - /* Remove existing phis that copy from lhs and create copies - from new_tree. */ - gimple_stmt_iterator gsi; - for (gsi =3D gsi_start_phis (exit_bb); !gsi_end_p (gsi);) - { - gimple *phi =3D gsi_stmt (gsi); - if ((gimple_phi_arg_def (phi, 0) =3D=3D lhs)) - { - remove_phi_node (&gsi, false); - tree lhs_phi =3D gimple_phi_result (phi); - gimple *copy =3D gimple_build_assign (lhs_phi, new_tree); - gsi_insert_before (&exit_gsi, copy, GSI_SAME_STMT); - } - else - gsi_next (&gsi); - } + gimple_stmt_iterator exit_gsi; + tree new_tree + =3D vectorizable_live_operation_1 (loop_vinfo, stmt_info, + exit_e, vectype, ncopies, + slp_node, bitsize, + tmp_bitstart, tmp_vec_lhs, + lhs_type, restart_loop, + &exit_gsi); + + /* Use the empty block on the exit to materialize the new stmts + so we can use update the PHI here. */ + if (gimple_phi_num_args (use_stmt) =3D=3D 1) + { + auto gsi =3D gsi_for_stmt (use_stmt); + remove_phi_node (&gsi, false); + tree lhs_phi =3D gimple_phi_result (use_stmt); + gimple *copy =3D gimple_build_assign (lhs_phi, new_tree); + gsi_insert_before (&exit_gsi, copy, GSI_SAME_STMT); + } + else + SET_PHI_ARG_DEF (use_stmt, dest_e->dest_idx, new_tree); + } + } =20 /* There a no further out-of-loop uses of lhs by LC-SSA construction= . */ FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, lhs) @@ -11797,6 +11956,21 @@ vect_transform_loop (loop_vec_info loop_vinfo, gim= ple *loop_vectorized_call) if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, "transform phi.\n"); vect_transform_stmt (loop_vinfo, stmt_info, NULL, NULL, NULL); + /* If vectorizing early break we must also vectorize the use of + the PHIs as a live operation. */ + if (LOOP_VINFO_EARLY_BREAKS (loop_vinfo) + && !STMT_VINFO_LIVE_P (stmt_info) + && STMT_VINFO_DEF_TYPE (stmt_info) =3D=3D vect_induction_def) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "----> vectorizing early break reduc or induc phi: %G", + (gimple *) phi); + bool done + =3D vectorizable_live_operation (loop_vinfo, stmt_info, NULL, + NULL, -1, true, NULL); + gcc_assert (done); + } } } =20 diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index fe38beb4fa1d9f8593445354f56ba52e10a040cd..f1b6a13395f286f9997530bbe57= cda3a00502f8f 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -342,6 +342,7 @@ is_simple_and_all_uses_invariant (stmt_vec_info stmt_in= fo, - it has uses outside the loop. - it has vdefs (it alters memory). - control stmts in the loop (except for the exit condition). + - it is an induction and we have multiple exits. =20 CHECKME: what other side effects would the vectorizer allow? */ =20 @@ -399,6 +400,19 @@ vect_stmt_relevant_p (stmt_vec_info stmt_info, loop_ve= c_info loop_vinfo, } } =20 + /* Check if it's an induction and multiple exits. In this case there wi= ll be + a usage later on after peeling which is needed for the alternate exit= . */ + if (LOOP_VINFO_EARLY_BREAKS (loop_vinfo) + && STMT_VINFO_DEF_TYPE (stmt_info) =3D=3D vect_induction_def) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "vec_stmt_relevant_p: induction forced for " + "early break.\n"); + *relevant =3D vect_used_in_scope; + + } + if (*live_p && *relevant =3D=3D vect_unused_in_scope && !is_simple_and_all_uses_invariant (stmt_info, loop_vinfo)) { @@ -1774,7 +1788,7 @@ compare_step_with_zero (vec_info *vinfo, stmt_vec_inf= o stmt_info) /* If the target supports a permute mask that reverses the elements in a vector of type VECTYPE, return that mask, otherwise return null. */ =20 -static tree +tree perm_mask_for_reverse (tree vectype) { poly_uint64 nunits =3D TYPE_VECTOR_SUBPARTS (vectype); diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index 22a8c3d384d7ae1ca93079b64f2d40821b4a3c56..cfd6756492e4af460c2f5669ecc= cc82b1089cfe4 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -2225,6 +2225,7 @@ extern bool vect_can_advance_ivs_p (loop_vec_info); extern void vect_update_inits_of_drs (loop_vec_info, tree, tree_code); extern edge vec_init_loop_exit_info (class loop *); extern bool vect_is_loop_exit_latch_pred (edge, class loop *); +extern void vect_iv_increment_position (edge, gimple_stmt_iterator *, bool= *); =20 /* In tree-vect-stmts.cc. */ extern tree get_related_vectype_for_scalar_type (machine_mode, tree, @@ -2246,6 +2247,7 @@ extern bool vect_is_simple_use (vec_info *, stmt_vec_= info, slp_tree, enum vect_def_type *, tree *, stmt_vec_info * =3D NULL); extern bool vect_maybe_update_slp_op_vectype (slp_tree, tree); +extern tree perm_mask_for_reverse (tree); extern bool supportable_widening_operation (vec_info*, code_helper, stmt_vec_info, tree, tree, code_helper*, code_helper*, --_002_VI1PR08MB5325326E1AF88F3235E641DBFFB4AVI1PR08MB5325eurp_ Content-Type: application/octet-stream; name="rb17968 (1).patch" Content-Description: rb17968 (1).patch Content-Disposition: attachment; filename="rb17968 (1).patch"; size=21096; creation-date="Mon, 20 Nov 2023 21:56:25 GMT"; modification-date="Mon, 20 Nov 2023 21:57:38 GMT" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtbG9vcC1tYW5pcC5jYyBiL2djYy90cmVlLXZlY3Qt bG9vcC1tYW5pcC5jYwppbmRleCAxMzkzMTExNDJiMzc2ZDRlYWE3ZWY4NzY1NjA4MjIwYjFlYjky YjMxLi5hZjIxNmQzZGNiOGE1MDI2Mzk4OThmZjY3Y2I4Njk0OGE3ZjE0MGE0IDEwMDY0NAotLS0g YS9nY2MvdHJlZS12ZWN0LWxvb3AtbWFuaXAuY2MKKysrIGIvZ2NjL3RyZWUtdmVjdC1sb29wLW1h bmlwLmNjCkBAIC00NTMsNyArNDUzLDcgQEAgdmVjdF9hZGp1c3RfbG9vcF9sZW5zX2NvbnRyb2wg KHRyZWUgaXZfdHlwZSwgZ2ltcGxlX3NlcSAqc2VxLAogICAgSU5TRVJUX0FGVEVSIGlzIHNldCB0 byB0cnVlIGlmIHRoZSBpbmNyZW1lbnQgc2hvdWxkIGJlIGluc2VydGVkIGFmdGVyCiAgICAqQlNJ LiAgKi8KIAotc3RhdGljIHZvaWQKK3ZvaWQKIHZlY3RfaXZfaW5jcmVtZW50X3Bvc2l0aW9uIChl ZGdlIGxvb3BfZXhpdCwgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKmJzaSwKIAkJCSAgICBib29sICpp bnNlcnRfYWZ0ZXIpCiB7CmRpZmYgLS1naXQgYS9nY2MvdHJlZS12ZWN0LWxvb3AuY2MgYi9nY2Mv dHJlZS12ZWN0LWxvb3AuY2MKaW5kZXggOGE1MDM4MGRlNDliYzEyMTA1YmU0N2VhMWQ4ZWUzY2Yx ZjJiZGFiNC4uYjFjMzRjNGMzYWFmOGJkZjliZjUyZDVhNzI2ODM2OTM2ZGU3NzJiNiAxMDA2NDQK LS0tIGEvZ2NjL3RyZWUtdmVjdC1sb29wLmNjCisrKyBiL2djYy90cmVlLXZlY3QtbG9vcC5jYwpA QCAtMjE2Myw2ICsyMTYzLDE1IEBAIHZlY3RfYW5hbHl6ZV9sb29wX29wZXJhdGlvbnMgKGxvb3Bf dmVjX2luZm8gbG9vcF92aW5mbykKIAkgICAgb2sgPSB2ZWN0b3JpemFibGVfbGl2ZV9vcGVyYXRp b24gKGxvb3BfdmluZm8sIHN0bXRfaW5mbywgTlVMTCwgTlVMTCwKIAkJCQkJICAgICAgLTEsIGZh bHNlLCAmY29zdF92ZWMpOwogCisJICAvKiBDaGVjayBpZiB3ZSBjYW4gcGVyZm9ybSB0aGUgb3Bl cmF0aW9uIGZvciBlYXJseSBicmVhayBpZiB3ZSBmb3JjZQorCSAgICAgdGhlIGxpdmUgb3BlcmF0 aW9uLiAgKi8KKwkgIGlmIChvaworCSAgICAgICYmIExPT1BfVklORk9fRUFSTFlfQlJFQUtTIChs b29wX3ZpbmZvKQorCSAgICAgICYmICFTVE1UX1ZJTkZPX0xJVkVfUCAoc3RtdF9pbmZvKQorCSAg ICAgICYmIFNUTVRfVklORk9fREVGX1RZUEUgKHN0bXRfaW5mbykgPT0gdmVjdF9pbmR1Y3Rpb25f ZGVmKQorCSAgICBvayA9IHZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbiAobG9vcF92aW5mbywg c3RtdF9pbmZvLCBOVUxMLCBOVUxMLAorCQkJCQkgICAgICAtMSwgZmFsc2UsICZjb3N0X3ZlYyk7 CisKICAgICAgICAgICBpZiAoIW9rKQogCSAgICByZXR1cm4gb3B0X3Jlc3VsdDo6ZmFpbHVyZV9h dCAocGhpLAogCQkJCQkgICAibm90IHZlY3Rvcml6ZWQ6IHJlbGV2YW50IHBoaSBub3QgIgpAQCAt NTg0Miw2ICs1ODUxLDEwIEBAIHZlY3RfY3JlYXRlX3BhcnRpYWxfZXBpbG9nICh0cmVlIHZlY19k ZWYsIHRyZWUgdmVjdHlwZSwgY29kZV9oZWxwZXIgY29kZSwKICAgIFNMUF9OT0RFX0lOU1RBTkNF IGlzIHRoZSBTTFAgbm9kZSBpbnN0YW5jZSBjb250YWluaW5nIFNMUF9OT0RFCiAgICBSRURVQ19J TkRFWCBzYXlzIHdoaWNoIHJocyBvcGVyYW5kIG9mIHRoZSBTVE1UX0lORk8gaXMgdGhlIHJlZHVj dGlvbiBwaGkKICAgICAgKGNvdW50aW5nIGZyb20gMCkKKyAgIExPT1BfRVhJVCBpcyB0aGUgZWRn ZSB0byB1cGRhdGUgaW4gdGhlIG1lcmdlIGJsb2NrLiAgSW4gdGhlIGNhc2Ugb2YgYSBzaW5nbGUK KyAgICAgZXhpdCB0aGlzIGVkZ2UgaXMgYWx3YXlzIHRoZSBtYWluIGxvb3AgZXhpdC4KKyAgIE1B SU5fRVhJVF9QIGluZGljYXRlcyB3aGV0aGVyIHdlIGFyZSB1cGRhdGluZyB0aGUgbWFpbiBleGl0 IG9yIGFuIGFsdGVybmF0ZQorICAgICBleGl0LiAgVGhpcyBkZXRlcm1pbmVzIHdoZXRoZXIgd2Ug dXNlIHRoZSBmaW5hbCBvciBvcmlnaW5hbCB2YWx1ZS4KIAogICAgVGhpcyBmdW5jdGlvbjoKICAg IDEuIENvbXBsZXRlcyB0aGUgcmVkdWN0aW9uIGRlZi11c2UgY3ljbGVzLgpAQCAtNTg4Miw3ICs1 ODk1LDkgQEAgc3RhdGljIHZvaWQKIHZlY3RfY3JlYXRlX2VwaWxvZ19mb3JfcmVkdWN0aW9uIChs b29wX3ZlY19pbmZvIGxvb3BfdmluZm8sCiAJCQkJICBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywK IAkJCQkgIHNscF90cmVlIHNscF9ub2RlLAotCQkJCSAgc2xwX2luc3RhbmNlIHNscF9ub2RlX2lu c3RhbmNlKQorCQkJCSAgc2xwX2luc3RhbmNlIHNscF9ub2RlX2luc3RhbmNlLAorCQkJCSAgZWRn ZSBsb29wX2V4aXQsCisJCQkJICBib29sIG1haW5fZXhpdF9wID0gdHJ1ZSkKIHsKICAgc3RtdF92 ZWNfaW5mbyByZWR1Y19pbmZvID0gaW5mb19mb3JfcmVkdWN0aW9uIChsb29wX3ZpbmZvLCBzdG10 X2luZm8pOwogICBnY2NfYXNzZXJ0IChyZWR1Y19pbmZvLT5pc19yZWR1Y19pbmZvKTsKQEAgLTYw NTMsNyArNjA2OCw3IEBAIHZlY3RfY3JlYXRlX2VwaWxvZ19mb3JfcmVkdWN0aW9uIChsb29wX3Zl Y19pbmZvIGxvb3BfdmluZm8sCiAgICAgICAvKiBDcmVhdGUgYW4gaW5kdWN0aW9uIHZhcmlhYmxl LiAgKi8KICAgICAgIGdpbXBsZV9zdG10X2l0ZXJhdG9yIGluY3JfZ3NpOwogICAgICAgYm9vbCBp bnNlcnRfYWZ0ZXI7Ci0gICAgICBzdGFuZGFyZF9pdl9pbmNyZW1lbnRfcG9zaXRpb24gKGxvb3As ICZpbmNyX2dzaSwgJmluc2VydF9hZnRlcik7CisgICAgICB2ZWN0X2l2X2luY3JlbWVudF9wb3Np dGlvbiAobG9vcF9leGl0LCAmaW5jcl9nc2ksICZpbnNlcnRfYWZ0ZXIpOwogICAgICAgY3JlYXRl X2l2IChzZXJpZXNfdmVjdCwgUExVU19FWFBSLCB2ZWNfc3RlcCwgTlVMTF9UUkVFLCBsb29wLCAm aW5jcl9nc2ksCiAJCSBpbnNlcnRfYWZ0ZXIsICZpbmR4X2JlZm9yZV9pbmNyLCAmaW5keF9hZnRl cl9pbmNyKTsKIApAQCAtNjEzMiwyMyArNjE0NywzMCBAQCB2ZWN0X2NyZWF0ZV9lcGlsb2dfZm9y X3JlZHVjdGlvbiAobG9vcF92ZWNfaW5mbyBsb29wX3ZpbmZvLAogICAgICAgICAgU3RvcmUgdGhl bSBpbiBORVdfUEhJUy4gICovCiAgIGlmIChkb3VibGVfcmVkdWMpCiAgICAgbG9vcCA9IG91dGVy X2xvb3A7Ci0gIGV4aXRfYmIgPSBMT09QX1ZJTkZPX0lWX0VYSVQgKGxvb3BfdmluZm8pLT5kZXN0 OworICAvKiBXZSBuZWVkIHRvIHJlZHVjZSB2YWx1ZXMgaW4gYWxsIGV4aXRzLiAgKi8KKyAgZXhp dF9iYiA9IGxvb3BfZXhpdC0+ZGVzdDsKICAgZXhpdF9nc2kgPSBnc2lfYWZ0ZXJfbGFiZWxzIChl eGl0X2JiKTsKICAgcmVkdWNfaW5wdXRzLmNyZWF0ZSAoc2xwX25vZGUgPyB2ZWNfbnVtIDogbmNv cGllcyk7CisgIHZlYyA8Z2ltcGxlICo+IHZlY19zdG10czsKKyAgaWYgKG1haW5fZXhpdF9wKQor ICAgIHZlY19zdG10cyA9IFNUTVRfVklORk9fVkVDX1NUTVRTIChyZGVmX2luZm8pOworICBlbHNl CisgICAgdmVjX3N0bXRzID0gU1RNVF9WSU5GT19WRUNfU1RNVFMgKFNUTVRfVklORk9fUkVEVUNf REVGIChyZGVmX2luZm8pKTsKKwogICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgdmVjX251bTsg aSsrKQogICAgIHsKICAgICAgIGdpbXBsZV9zZXEgc3RtdHMgPSBOVUxMOwogICAgICAgaWYgKHNs cF9ub2RlKQogCWRlZiA9IHZlY3RfZ2V0X3NscF92ZWN0X2RlZiAoc2xwX25vZGUsIGkpOwogICAg ICAgZWxzZQotCWRlZiA9IGdpbXBsZV9nZXRfbGhzIChTVE1UX1ZJTkZPX1ZFQ19TVE1UUyAocmRl Zl9pbmZvKVswXSk7CisJZGVmID0gZ2ltcGxlX2dldF9saHMgKHZlY19zdG10c1swXSk7CiAgICAg ICBmb3IgKGogPSAwOyBqIDwgbmNvcGllczsgaisrKQogCXsKIAkgIHRyZWUgbmV3X2RlZiA9IGNv cHlfc3NhX25hbWUgKGRlZik7CiAJICBwaGkgPSBjcmVhdGVfcGhpX25vZGUgKG5ld19kZWYsIGV4 aXRfYmIpOwogCSAgaWYgKGopCi0JICAgIGRlZiA9IGdpbXBsZV9nZXRfbGhzIChTVE1UX1ZJTkZP X1ZFQ19TVE1UUyAocmRlZl9pbmZvKVtqXSk7Ci0JICBTRVRfUEhJX0FSR19ERUYgKHBoaSwgTE9P UF9WSU5GT19JVl9FWElUIChsb29wX3ZpbmZvKS0+ZGVzdF9pZHgsIGRlZik7CisJICAgIGRlZiA9 IGdpbXBsZV9nZXRfbGhzICh2ZWNfc3RtdHNbal0pOworCSAgU0VUX1BISV9BUkdfREVGIChwaGks IGxvb3BfZXhpdC0+ZGVzdF9pZHgsIGRlZik7CiAJICBuZXdfZGVmID0gZ2ltcGxlX2NvbnZlcnQg KCZzdG10cywgdmVjdHlwZSwgbmV3X2RlZik7CiAJICByZWR1Y19pbnB1dHMucXVpY2tfcHVzaCAo bmV3X2RlZik7CiAJfQpAQCAtNjg4NSw3ICs2OTA3LDIwIEBAIHZlY3RfY3JlYXRlX2VwaWxvZ19m b3JfcmVkdWN0aW9uIChsb29wX3ZlY19pbmZvIGxvb3BfdmluZm8sCiAgICAgICAgICAgRk9SX0VB Q0hfSU1NX1VTRV9TVE1UICh1c2Vfc3RtdCwgaW1tX2l0ZXIsIG9yaWdfbmFtZSkKIAkgICAgewog CSAgICAgIEZPUl9FQUNIX0lNTV9VU0VfT05fU1RNVCAodXNlX3AsIGltbV9pdGVyKQotCQlTRVRf VVNFICh1c2VfcCwgc2NhbGFyX3Jlc3VsdCk7CisJCXsKKwkJICBnaW1wbGUgKnN0bXQgPSBVU0Vf U1RNVCAodXNlX3ApOworCQkgIGlmIChtYWluX2V4aXRfcCkKKwkJICAgIFNFVF9VU0UgKHVzZV9w LCBzY2FsYXJfcmVzdWx0KTsKKwkJICBlbHNlIGlmIChpc19hIDxncGhpICo+IChzdG10KSkKKwkJ ICAgIHsKKwkJICAgICAgLyogSWYgYW4gZWFybHkgZXhpdCBvbmx5IHVwZGF0ZSB1c2FnZXMgaW4g dGhlIG1lcmdlCisJCQkgYmxvY2suICAqLworCQkgICAgICBlZGdlIG1lcmdlX2UgPSBzaW5nbGVf c3VjY19lZGdlIChsb29wX2V4aXQtPmRlc3QpOworCQkgICAgICBpZiAoZ2ltcGxlX2JiIChzdG10 KSAhPSBtZXJnZV9lLT5kZXN0KQorCQkJY29udGludWU7CisJCSAgICAgIFNFVF9QSElfQVJHX0RF RiAoc3RtdCwgbWVyZ2VfZS0+ZGVzdF9pZHgsIHNjYWxhcl9yZXN1bHQpOworCQkgICAgfQorCQl9 CiAJICAgICAgdXBkYXRlX3N0bXQgKHVzZV9zdG10KTsKIAkgICAgfQogICAgICAgICB9CkBAIC0x MDQ4MSw2ICsxMDUxNiwxNTYgQEAgdmVjdG9yaXphYmxlX2luZHVjdGlvbiAobG9vcF92ZWNfaW5m byBsb29wX3ZpbmZvLAogICByZXR1cm4gdHJ1ZTsKIH0KIAorLyogRnVuY3Rpb24gdmVjdG9yaXph YmxlX2xpdmVfb3BlcmF0aW9uXzEuCisKKyAgIGhlbHBlciBmdW5jdGlvbiBmb3IgdmVjdG9yaXph YmxlX2xpdmVfb3BlcmF0aW9uLiAgKi8KKwordHJlZQordmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0 aW9uXzEgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKKwkJCSAgICAgICBzdG10X3ZlY19pbmZv IHN0bXRfaW5mbywgZWRnZSBleGl0X2UsCisJCQkgICAgICAgdHJlZSB2ZWN0eXBlLCBpbnQgbmNv cGllcywgc2xwX3RyZWUgc2xwX25vZGUsCisJCQkgICAgICAgdHJlZSBiaXRzaXplLCB0cmVlIGJp dHN0YXJ0LCB0cmVlIHZlY19saHMsCisJCQkgICAgICAgdHJlZSBsaHNfdHlwZSwgYm9vbCByZXN0 YXJ0X2xvb3AsCisJCQkgICAgICAgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKmV4aXRfZ3NpKQorewor ICBiYXNpY19ibG9jayBleGl0X2JiID0gZXhpdF9lLT5kZXN0OworICBnY2NfYXNzZXJ0IChzaW5n bGVfcHJlZF9wIChleGl0X2JiKSB8fCBMT09QX1ZJTkZPX0VBUkxZX0JSRUFLUyAobG9vcF92aW5m bykpOworCisgIHRyZWUgdmVjX2xoc19waGkgPSBjb3B5X3NzYV9uYW1lICh2ZWNfbGhzKTsKKyAg Z2ltcGxlICpwaGkgPSBjcmVhdGVfcGhpX25vZGUgKHZlY19saHNfcGhpLCBleGl0X2JiKTsKKyAg Zm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGdpbXBsZV9waGlfbnVtX2FyZ3MgKHBoaSk7IGkrKykK KyAgICBTRVRfUEhJX0FSR19ERUYgKHBoaSwgaSwgdmVjX2xocyk7CisKKyAgZ2ltcGxlX3NlcSBz dG10cyA9IE5VTEw7CisgIHRyZWUgbmV3X3RyZWU7CisgIGlmIChMT09QX1ZJTkZPX0ZVTExZX1dJ VEhfTEVOR1RIX1AgKGxvb3BfdmluZm8pKQorICAgIHsKKyAgICAgIC8qIEVtaXQ6CisKKwkgU0NB TEFSX1JFUyA9IFZFQ19FWFRSQUNUIDxWRUNfTEhTLCBMRU4gKyBCSUFTIC0gMT4KKworCSB3aGVy ZSBWRUNfTEhTIGlzIHRoZSB2ZWN0b3JpemVkIGxpdmUtb3V0IHJlc3VsdCBhbmQgTUFTSyBpcwor CSB0aGUgbG9vcCBtYXNrIGZvciB0aGUgZmluYWwgaXRlcmF0aW9uLiAgKi8KKyAgICAgIGdjY19h c3NlcnQgKG5jb3BpZXMgPT0gMSAmJiAhc2xwX25vZGUpOworICAgICAgZ2ltcGxlX3NlcSB0ZW0g PSBOVUxMOworICAgICAgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgZ3NpID0gZ3NpX2xhc3QgKHRlbSk7 CisgICAgICB0cmVlIGxlbiA9IHZlY3RfZ2V0X2xvb3BfbGVuIChsb29wX3ZpbmZvLCAmZ3NpLAor CQkJCSAgICAmTE9PUF9WSU5GT19MRU5TIChsb29wX3ZpbmZvKSwKKwkJCQkgICAgMSwgdmVjdHlw ZSwgMCwgMCk7CisKKyAgICAgIC8qIEJJQVMgLSAxLiAgKi8KKyAgICAgIHNpZ25lZCBjaGFyIGJp YXN2YWwgPSBMT09QX1ZJTkZPX1BBUlRJQUxfTE9BRF9TVE9SRV9CSUFTIChsb29wX3ZpbmZvKTsK KyAgICAgIHRyZWUgYmlhc19taW51c19vbmUKKwk9IGludF9jb25zdF9iaW5vcCAoTUlOVVNfRVhQ UiwKKwkJCSAgIGJ1aWxkX2ludF9jc3QgKFRSRUVfVFlQRSAobGVuKSwgYmlhc3ZhbCksCisJCQkg ICBidWlsZF9vbmVfY3N0IChUUkVFX1RZUEUgKGxlbikpKTsKKworICAgICAgLyogTEFTVF9JTkRF WCA9IExFTiArIChCSUFTIC0gMSkuICAqLworICAgICAgdHJlZSBsYXN0X2luZGV4ID0gZ2ltcGxl X2J1aWxkICgmc3RtdHMsIFBMVVNfRVhQUiwgVFJFRV9UWVBFIChsZW4pLAorCQkJCSAgICAgbGVu LCBiaWFzX21pbnVzX29uZSk7CisKKyAgICAgIC8qIFRoaXMgbmVlZHMgdG8gaW1wbGVtZW50IGV4 dHJhY3Rpb24gb2YgdGhlIGZpcnN0IGluZGV4LCBidXQgbm90IHN1cmUKKwkgaG93IHRoZSBMRU4g c3R1ZmYgd29ya3MuICBBdCB0aGUgbW9tZW50IHdlIHNob3VsZG4ndCBnZXQgaGVyZSBzaW5jZQor CSB0aGVyZSdzIG5vIExFTiBzdXBwb3J0IGZvciBlYXJseSBicmVha3MuICBCdXQgZ3VhcmQgdGhp cyBzbyB0aGVyZSdzCisJIG5vIGluY29ycmVjdCBjb2RlZ2VuLiAgKi8KKyAgICAgIGdjY19hc3Nl cnQgKCFMT09QX1ZJTkZPX0VBUkxZX0JSRUFLUyAobG9vcF92aW5mbykpOworCisgICAgICAvKiBT Q0FMQVJfUkVTID0gVkVDX0VYVFJBQ1QgPFZFQ19MSFMsIExFTiArIEJJQVMgLSAxPi4gICovCisg ICAgICB0cmVlIHNjYWxhcl9yZXMKKwk9IGdpbXBsZV9idWlsZCAoJnN0bXRzLCBDRk5fVkVDX0VY VFJBQ1QsIFRSRUVfVFlQRSAodmVjdHlwZSksCisJCQl2ZWNfbGhzX3BoaSwgbGFzdF9pbmRleCk7 CisKKyAgICAgIC8qIENvbnZlcnQgdGhlIGV4dHJhY3RlZCB2ZWN0b3IgZWxlbWVudCB0byB0aGUg c2NhbGFyIHR5cGUuICAqLworICAgICAgbmV3X3RyZWUgPSBnaW1wbGVfY29udmVydCAoJnN0bXRz LCBsaHNfdHlwZSwgc2NhbGFyX3Jlcyk7CisgICAgfQorICBlbHNlIGlmIChMT09QX1ZJTkZPX0ZV TExZX01BU0tFRF9QIChsb29wX3ZpbmZvKSkKKyAgICB7CisgICAgICAvKiBFbWl0OgorCisJIFND QUxBUl9SRVMgPSBFWFRSQUNUX0xBU1QgPFZFQ19MSFMsIE1BU0s+CisKKwkgd2hlcmUgVkVDX0xI UyBpcyB0aGUgdmVjdG9yaXplZCBsaXZlLW91dCByZXN1bHQgYW5kIE1BU0sgaXMKKwkgdGhlIGxv b3AgbWFzayBmb3IgdGhlIGZpbmFsIGl0ZXJhdGlvbi4gICovCisgICAgICBnY2NfYXNzZXJ0ICgh c2xwX25vZGUpOworICAgICAgdHJlZSBzY2FsYXJfdHlwZSA9IFRSRUVfVFlQRSAoU1RNVF9WSU5G T19WRUNUWVBFIChzdG10X2luZm8pKTsKKyAgICAgIGdpbXBsZV9zZXEgdGVtID0gTlVMTDsKKyAg ICAgIGdpbXBsZV9zdG10X2l0ZXJhdG9yIGdzaSA9IGdzaV9sYXN0ICh0ZW0pOworICAgICAgdHJl ZSBtYXNrID0gdmVjdF9nZXRfbG9vcF9tYXNrIChsb29wX3ZpbmZvLCAmZ3NpLAorCQkJCSAgICAg ICZMT09QX1ZJTkZPX01BU0tTIChsb29wX3ZpbmZvKSwKKwkJCQkgICAgICAxLCB2ZWN0eXBlLCAw KTsKKyAgICAgIHRyZWUgc2NhbGFyX3JlczsKKworICAgICAgLyogRm9yIGFuIGludmVydGVkIGNv bnRyb2wgZmxvdyB3aXRoIGVhcmx5IGJyZWFrcyB3ZSB3YW50IEVYVFJBQ1RfRklSU1QKKwkgaW5z dGVhZCBvZiBFWFRSQUNUX0xBU1QuICBFbXVsYXRlIGJ5IHJldmVyc2luZyB0aGUgdmVjdG9yIGFu ZCBtYXNrLiAqLworICAgICAgaWYgKHJlc3RhcnRfbG9vcCAmJiBMT09QX1ZJTkZPX0VBUkxZX0JS RUFLUyAobG9vcF92aW5mbykpCisJeworCSAgLyogRmlyc3QgY3JlYXRlIHRoZSBwZXJtdXRlZCBt YXNrLiAgKi8KKwkgIHRyZWUgcGVybV9tYXNrID0gcGVybV9tYXNrX2Zvcl9yZXZlcnNlIChUUkVF X1RZUEUgKG1hc2spKTsKKwkgIHRyZWUgcGVybV9kZXN0ID0gY29weV9zc2FfbmFtZSAobWFzayk7 CisJICBnaW1wbGUgKnBlcm1fc3RtdAorCQk9IGdpbXBsZV9idWlsZF9hc3NpZ24gKHBlcm1fZGVz dCwgVkVDX1BFUk1fRVhQUiwgbWFzaywKKwkJCQkgICAgICAgbWFzaywgcGVybV9tYXNrKTsKKwkg IHZlY3RfZmluaXNoX3N0bXRfZ2VuZXJhdGlvbiAobG9vcF92aW5mbywgc3RtdF9pbmZvLCBwZXJt X3N0bXQsCisJCQkJICAgICAgICZnc2kpOworCSAgbWFzayA9IHBlcm1fZGVzdDsKKworCSAgLyog VGhlbiBwZXJtdXRlIHRoZSB2ZWN0b3IgY29udGVudHMuICAqLworCSAgdHJlZSBwZXJtX2VsZW0g PSBwZXJtX21hc2tfZm9yX3JldmVyc2UgKHZlY3R5cGUpOworCSAgcGVybV9kZXN0ID0gY29weV9z c2FfbmFtZSAodmVjX2xoc19waGkpOworCSAgcGVybV9zdG10CisJCT0gZ2ltcGxlX2J1aWxkX2Fz c2lnbiAocGVybV9kZXN0LCBWRUNfUEVSTV9FWFBSLCB2ZWNfbGhzX3BoaSwKKwkJCQkgICAgICAg dmVjX2xoc19waGksIHBlcm1fZWxlbSk7CisJICB2ZWN0X2ZpbmlzaF9zdG10X2dlbmVyYXRpb24g KGxvb3BfdmluZm8sIHN0bXRfaW5mbywgcGVybV9zdG10LAorCQkJCSAgICAgICAmZ3NpKTsKKwkg IHZlY19saHNfcGhpID0gcGVybV9kZXN0OworCX0KKworICAgICAgZ2ltcGxlX3NlcV9hZGRfc2Vx ICgmc3RtdHMsIHRlbSk7CisKKyAgICAgIHNjYWxhcl9yZXMgPSBnaW1wbGVfYnVpbGQgKCZzdG10 cywgQ0ZOX0VYVFJBQ1RfTEFTVCwgc2NhbGFyX3R5cGUsCisJCQkJIG1hc2ssIHZlY19saHNfcGhp KTsKKworICAgICAgLyogQ29udmVydCB0aGUgZXh0cmFjdGVkIHZlY3RvciBlbGVtZW50IHRvIHRo ZSBzY2FsYXIgdHlwZS4gICovCisgICAgICBuZXdfdHJlZSA9IGdpbXBsZV9jb252ZXJ0ICgmc3Rt dHMsIGxoc190eXBlLCBzY2FsYXJfcmVzKTsKKyAgICB9CisgIGVsc2UKKyAgICB7CisgICAgICB0 cmVlIGJmdHlwZSA9IFRSRUVfVFlQRSAodmVjdHlwZSk7CisgICAgICBpZiAoVkVDVE9SX0JPT0xF QU5fVFlQRV9QICh2ZWN0eXBlKSkKKwliZnR5cGUgPSBidWlsZF9ub25zdGFuZGFyZF9pbnRlZ2Vy X3R5cGUgKHRyZWVfdG9fdWh3aSAoYml0c2l6ZSksIDEpOworICAgICAgbmV3X3RyZWUgPSBidWls ZDMgKEJJVF9GSUVMRF9SRUYsIGJmdHlwZSwgdmVjX2xoc19waGksIGJpdHNpemUsIGJpdHN0YXJ0 KTsKKyAgICAgIG5ld190cmVlID0gZm9yY2VfZ2ltcGxlX29wZXJhbmQgKGZvbGRfY29udmVydCAo bGhzX3R5cGUsIG5ld190cmVlKSwKKwkJCQkgICAgICAgJnN0bXRzLCB0cnVlLCBOVUxMX1RSRUUp OworICAgIH0KKworICAqZXhpdF9nc2kgPSBnc2lfYWZ0ZXJfbGFiZWxzIChleGl0X2JiKTsKKyAg aWYgKHN0bXRzKQorICAgIGdzaV9pbnNlcnRfc2VxX2JlZm9yZSAoZXhpdF9nc2ksIHN0bXRzLCBH U0lfU0FNRV9TVE1UKTsKKworICByZXR1cm4gbmV3X3RyZWU7Cit9CisKKy8qIEZpbmQgdGhlIGVk Z2UgdGhhdCdzIHRoZSBmaW5hbCBvbmUgaW4gdGhlIHBhdGggZnJvbSBTUkMgdG8gREVTVCBhbmQK KyAgIHJldHVybiBpdC4gIFRoaXMgZWRnZSBtdXN0IGV4aXN0IGluIGF0IG1vc3Qgb25lIGZvcndh cmRlciBlZGdlIGJldHdlZW4uICAqLworCitzdGF0aWMgZWRnZQorZmluZF9jb25uZWN0ZWRfZWRn ZSAoZWRnZSBzcmMsIGJhc2ljX2Jsb2NrIGRlc3QpCit7CisgICBpZiAoc3JjLT5kZXN0ID09IGRl c3QpCisgICAgIHJldHVybiBzcmM7CisKKyAgZWRnZSBlOworICBlZGdlX2l0ZXJhdG9yIGVpOwor CisgIEZPUl9FQUNIX0VER0UgKGUsIGVpLCBkZXN0LT5wcmVkcykKKyAgICB7CisgICAgICBpZiAo c3JjLT5kZXN0ID09IGUtPnNyYykKKwlyZXR1cm4gZTsKKyAgICB9CisKKyAgcmV0dXJuIE5VTEw7 Cit9CisKIC8qIEZ1bmN0aW9uIHZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbi4KIAogICAgU1RN VF9JTkZPIGNvbXB1dGVzIGEgdmFsdWUgdGhhdCBpcyB1c2VkIG91dHNpZGUgdGhlIGxvb3AuICBD aGVjayBpZgpAQCAtMTA1MDUsNyArMTA2OTAsOCBAQCB2ZWN0b3JpemFibGVfbGl2ZV9vcGVyYXRp b24gKHZlY19pbmZvICp2aW5mbywgc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sCiAgIGludCB2ZWNf ZW50cnkgPSAwOwogICBwb2x5X3VpbnQ2NCB2ZWNfaW5kZXggPSAwOwogCi0gIGdjY19hc3NlcnQg KFNUTVRfVklORk9fTElWRV9QIChzdG10X2luZm8pKTsKKyAgZ2NjX2Fzc2VydCAoU1RNVF9WSU5G T19MSVZFX1AgKHN0bXRfaW5mbykKKwkgICAgICB8fCBMT09QX1ZJTkZPX0VBUkxZX0JSRUFLUyAo bG9vcF92aW5mbykpOwogCiAgIC8qIElmIGEgc3RtdCBvZiBhIHJlZHVjdGlvbiBpcyBsaXZlLCB2 ZWN0b3JpemUgaXQgdmlhCiAgICAgIHZlY3RfY3JlYXRlX2VwaWxvZ19mb3JfcmVkdWN0aW9uLiAg dmVjdG9yaXphYmxlX3JlZHVjdGlvbiBhc3Nlc3NlZApAQCAtMTA1MzAsOCArMTA3MTYsMjIgQEAg dmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uICh2ZWNfaW5mbyAqdmluZm8sIHN0bXRfdmVjX2lu Zm8gc3RtdF9pbmZvLAogICAgICAgaWYgKFNUTVRfVklORk9fUkVEVUNfVFlQRSAocmVkdWNfaW5m bykgPT0gRk9MRF9MRUZUX1JFRFVDVElPTgogCSAgfHwgU1RNVF9WSU5GT19SRURVQ19UWVBFIChy ZWR1Y19pbmZvKSA9PSBFWFRSQUNUX0xBU1RfUkVEVUNUSU9OKQogCXJldHVybiB0cnVlOworCisg ICAgICAvKiBJZiBlYXJseSBicmVhayB3ZSBvbmx5IGhhdmUgdG8gbWF0ZXJpYWxpemUgdGhlIHJl ZHVjdGlvbiBvbiB0aGUgbWVyZ2UKKwkgYmxvY2ssIGJ1dCB3ZSBoYXZlIHRvIGZpbmQgYW4gYWx0 ZXJuYXRlIGV4aXQgZmlyc3QuICAqLworICAgICAgaWYgKExPT1BfVklORk9fRUFSTFlfQlJFQUtT IChsb29wX3ZpbmZvKSkKKwl7CisJICBmb3IgKGF1dG8gZXhpdCA6IGdldF9sb29wX2V4aXRfZWRn ZXMgKExPT1BfVklORk9fTE9PUCAobG9vcF92aW5mbykpKQorCSAgICBpZiAoZXhpdCAhPSBMT09Q X1ZJTkZPX0lWX0VYSVQgKGxvb3BfdmluZm8pKQorCSAgICAgIHZlY3RfY3JlYXRlX2VwaWxvZ19m b3JfcmVkdWN0aW9uIChsb29wX3ZpbmZvLCBzdG10X2luZm8sCisJCQkJCQlzbHBfbm9kZSwgc2xw X25vZGVfaW5zdGFuY2UsCisJCQkJCQlleGl0LCBmYWxzZSk7CisJfQorCiAgICAgICB2ZWN0X2Ny ZWF0ZV9lcGlsb2dfZm9yX3JlZHVjdGlvbiAobG9vcF92aW5mbywgc3RtdF9pbmZvLCBzbHBfbm9k ZSwKLQkJCQkJc2xwX25vZGVfaW5zdGFuY2UpOworCQkJCQlzbHBfbm9kZV9pbnN0YW5jZSwKKwkJ CQkJTE9PUF9WSU5GT19JVl9FWElUIChsb29wX3ZpbmZvKSk7CisKICAgICAgIHJldHVybiB0cnVl OwogICAgIH0KIApAQCAtMTA2ODMsMTAzICsxMDg4Myw2MiBAQCB2ZWN0b3JpemFibGVfbGl2ZV9v cGVyYXRpb24gKHZlY19pbmZvICp2aW5mbywgc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sCiAJICAg bGhzJyA9IG5ld190cmVlOyAgKi8KIAogICAgICAgY2xhc3MgbG9vcCAqbG9vcCA9IExPT1BfVklO Rk9fTE9PUCAobG9vcF92aW5mbyk7Ci0gICAgICBiYXNpY19ibG9jayBleGl0X2JiID0gTE9PUF9W SU5GT19JVl9FWElUIChsb29wX3ZpbmZvKS0+ZGVzdDsKLSAgICAgIGdjY19hc3NlcnQgKHNpbmds ZV9wcmVkX3AgKGV4aXRfYmIpKTsKLQotICAgICAgdHJlZSB2ZWNfbGhzX3BoaSA9IGNvcHlfc3Nh X25hbWUgKHZlY19saHMpOwotICAgICAgZ2ltcGxlICpwaGkgPSBjcmVhdGVfcGhpX25vZGUgKHZl Y19saHNfcGhpLCBleGl0X2JiKTsKLSAgICAgIFNFVF9QSElfQVJHX0RFRiAocGhpLCBMT09QX1ZJ TkZPX0lWX0VYSVQgKGxvb3BfdmluZm8pLT5kZXN0X2lkeCwgdmVjX2xocyk7Ci0KLSAgICAgIGdp bXBsZV9zZXEgc3RtdHMgPSBOVUxMOwotICAgICAgdHJlZSBuZXdfdHJlZTsKLSAgICAgIGlmIChM T09QX1ZJTkZPX0ZVTExZX1dJVEhfTEVOR1RIX1AgKGxvb3BfdmluZm8pKQotCXsKLQkgIC8qIEVt aXQ6Ci0KLQkgICAgICAgU0NBTEFSX1JFUyA9IFZFQ19FWFRSQUNUIDxWRUNfTEhTLCBMRU4gKyBC SUFTIC0gMT4KLQotCSAgICAgd2hlcmUgVkVDX0xIUyBpcyB0aGUgdmVjdG9yaXplZCBsaXZlLW91 dCByZXN1bHQgYW5kIE1BU0sgaXMKLQkgICAgIHRoZSBsb29wIG1hc2sgZm9yIHRoZSBmaW5hbCBp dGVyYXRpb24uICAqLwotCSAgZ2NjX2Fzc2VydCAobmNvcGllcyA9PSAxICYmICFzbHBfbm9kZSk7 Ci0JICBnaW1wbGVfc2VxIHRlbSA9IE5VTEw7Ci0JICBnaW1wbGVfc3RtdF9pdGVyYXRvciBnc2kg PSBnc2lfbGFzdCAodGVtKTsKLQkgIHRyZWUgbGVuCi0JICAgID0gdmVjdF9nZXRfbG9vcF9sZW4g KGxvb3BfdmluZm8sICZnc2ksCi0JCQkJICZMT09QX1ZJTkZPX0xFTlMgKGxvb3BfdmluZm8pLAot CQkJCSAxLCB2ZWN0eXBlLCAwLCAwKTsKLQotCSAgLyogQklBUyAtIDEuICAqLwotCSAgc2lnbmVk IGNoYXIgYmlhc3ZhbCA9IExPT1BfVklORk9fUEFSVElBTF9MT0FEX1NUT1JFX0JJQVMgKGxvb3Bf dmluZm8pOwotCSAgdHJlZSBiaWFzX21pbnVzX29uZQotCSAgICA9IGludF9jb25zdF9iaW5vcCAo TUlOVVNfRVhQUiwKLQkJCSAgICAgICBidWlsZF9pbnRfY3N0IChUUkVFX1RZUEUgKGxlbiksIGJp YXN2YWwpLAotCQkJICAgICAgIGJ1aWxkX29uZV9jc3QgKFRSRUVfVFlQRSAobGVuKSkpOwotCi0J ICAvKiBMQVNUX0lOREVYID0gTEVOICsgKEJJQVMgLSAxKS4gICovCi0JICB0cmVlIGxhc3RfaW5k ZXggPSBnaW1wbGVfYnVpbGQgKCZzdG10cywgUExVU19FWFBSLCBUUkVFX1RZUEUgKGxlbiksCi0J CQkJCSAgbGVuLCBiaWFzX21pbnVzX29uZSk7Ci0KLQkgIC8qIFNDQUxBUl9SRVMgPSBWRUNfRVhU UkFDVCA8VkVDX0xIUywgTEVOICsgQklBUyAtIDE+LiAgKi8KLQkgIHRyZWUgc2NhbGFyX3Jlcwot CSAgICA9IGdpbXBsZV9idWlsZCAoJnN0bXRzLCBDRk5fVkVDX0VYVFJBQ1QsIFRSRUVfVFlQRSAo dmVjdHlwZSksCi0JCQkgICAgdmVjX2xoc19waGksIGxhc3RfaW5kZXgpOwotCi0JICAvKiBDb252 ZXJ0IHRoZSBleHRyYWN0ZWQgdmVjdG9yIGVsZW1lbnQgdG8gdGhlIHNjYWxhciB0eXBlLiAgKi8K LQkgIG5ld190cmVlID0gZ2ltcGxlX2NvbnZlcnQgKCZzdG10cywgbGhzX3R5cGUsIHNjYWxhcl9y ZXMpOwotCX0KLSAgICAgIGVsc2UgaWYgKExPT1BfVklORk9fRlVMTFlfTUFTS0VEX1AgKGxvb3Bf dmluZm8pKQotCXsKLQkgIC8qIEVtaXQ6Ci0KLQkgICAgICAgU0NBTEFSX1JFUyA9IEVYVFJBQ1Rf TEFTVCA8VkVDX0xIUywgTUFTSz4KLQotCSAgICAgd2hlcmUgVkVDX0xIUyBpcyB0aGUgdmVjdG9y aXplZCBsaXZlLW91dCByZXN1bHQgYW5kIE1BU0sgaXMKLQkgICAgIHRoZSBsb29wIG1hc2sgZm9y IHRoZSBmaW5hbCBpdGVyYXRpb24uICAqLwotCSAgZ2NjX2Fzc2VydCAobmNvcGllcyA9PSAxICYm ICFzbHBfbm9kZSk7Ci0JICB0cmVlIHNjYWxhcl90eXBlID0gVFJFRV9UWVBFIChTVE1UX1ZJTkZP X1ZFQ1RZUEUgKHN0bXRfaW5mbykpOwotCSAgZ2ltcGxlX3NlcSB0ZW0gPSBOVUxMOwotCSAgZ2lt cGxlX3N0bXRfaXRlcmF0b3IgZ3NpID0gZ3NpX2xhc3QgKHRlbSk7Ci0JICB0cmVlIG1hc2sgPSB2 ZWN0X2dldF9sb29wX21hc2sgKGxvb3BfdmluZm8sICZnc2ksCi0JCQkJCSAgJkxPT1BfVklORk9f TUFTS1MgKGxvb3BfdmluZm8pLAotCQkJCQkgIDEsIHZlY3R5cGUsIDApOwotCSAgZ2ltcGxlX3Nl cV9hZGRfc2VxICgmc3RtdHMsIHRlbSk7Ci0JICB0cmVlIHNjYWxhcl9yZXMgPSBnaW1wbGVfYnVp bGQgKCZzdG10cywgQ0ZOX0VYVFJBQ1RfTEFTVCwgc2NhbGFyX3R5cGUsCi0JCQkJCSAgbWFzaywg dmVjX2xoc19waGkpOwotCi0JICAvKiBDb252ZXJ0IHRoZSBleHRyYWN0ZWQgdmVjdG9yIGVsZW1l bnQgdG8gdGhlIHNjYWxhciB0eXBlLiAgKi8KLQkgIG5ld190cmVlID0gZ2ltcGxlX2NvbnZlcnQg KCZzdG10cywgbGhzX3R5cGUsIHNjYWxhcl9yZXMpOwotCX0KLSAgICAgIGVsc2UKLQl7Ci0JICB0 cmVlIGJmdHlwZSA9IFRSRUVfVFlQRSAodmVjdHlwZSk7Ci0JICBpZiAoVkVDVE9SX0JPT0xFQU5f VFlQRV9QICh2ZWN0eXBlKSkKLQkgICAgYmZ0eXBlID0gYnVpbGRfbm9uc3RhbmRhcmRfaW50ZWdl cl90eXBlICh0cmVlX3RvX3Vod2kgKGJpdHNpemUpLCAxKTsKLQkgIG5ld190cmVlID0gYnVpbGQz IChCSVRfRklFTERfUkVGLCBiZnR5cGUsCi0JCQkgICAgIHZlY19saHNfcGhpLCBiaXRzaXplLCBi aXRzdGFydCk7Ci0JICBuZXdfdHJlZSA9IGZvcmNlX2dpbXBsZV9vcGVyYW5kIChmb2xkX2NvbnZl cnQgKGxoc190eXBlLCBuZXdfdHJlZSksCi0JCQkJCSAgICZzdG10cywgdHJ1ZSwgTlVMTF9UUkVF KTsKLQl9CisgICAgICAvKiBDaGVjayBpZiB3ZSBoYXZlIGEgbG9vcCB3aGVyZSB0aGUgY2hvc2Vu IGV4aXQgaXMgbm90IHRoZSBtYWluIGV4aXQsCisJIGluIHRoZXNlIGNhc2VzIGZvciBhbiBlYXJs eSBicmVhayB3ZSByZXN0YXJ0IHRoZSBpdGVyYXRpb24gdGhlIHZlY3RvciBjb2RlCisJIGRpZC4g IEZvciB0aGUgbGl2ZSB2YWx1ZXMgd2Ugd2FudCB0aGUgdmFsdWUgYXQgdGhlIHN0YXJ0IG9mIHRo ZSBpdGVyYXRpb24KKwkgcmF0aGVyIHRoYW4gYXQgdGhlIGVuZC4gICovCisgICAgICBlZGdlIG1h aW5fZSA9IExPT1BfVklORk9fSVZfRVhJVCAobG9vcF92aW5mbyk7CisgICAgICBib29sIHJlc3Rh cnRfbG9vcCA9ICF2ZWN0X2lzX2xvb3BfZXhpdF9sYXRjaF9wcmVkIChtYWluX2UsIGxvb3ApOwor ICAgICAgRk9SX0VBQ0hfSU1NX1VTRV9TVE1UICh1c2Vfc3RtdCwgaW1tX2l0ZXIsIGxocykKKwlp ZiAoIWlzX2dpbXBsZV9kZWJ1ZyAodXNlX3N0bXQpCisJICAgICYmICFmbG93X2JiX2luc2lkZV9s b29wX3AgKGxvb3AsIGdpbXBsZV9iYiAodXNlX3N0bXQpKSkKKwkgIHsKKwkgICAgYmFzaWNfYmxv Y2sgdXNlX2JiID0gZ2ltcGxlX2JiICh1c2Vfc3RtdCk7CisJICAgIGlmICghaXNfYSA8Z3BoaSAq PiAodXNlX3N0bXQpKQorCSAgICAgIGNvbnRpbnVlOworCSAgICBmb3IgKGF1dG8gZXhpdF9lIDog Z2V0X2xvb3BfZXhpdF9lZGdlcyAobG9vcCkpCisJICAgICAgeworCQkvKiBTZWUgaWYgdGhpcyBl eGl0IGxlYWRzIHRvIHRoZSB2YWx1ZS4gICovCisJCWVkZ2UgZGVzdF9lID0gZmluZF9jb25uZWN0 ZWRfZWRnZSAoZXhpdF9lLCB1c2VfYmIpOworCQlpZiAoIWRlc3RfZSB8fCBQSElfQVJHX0RFRl9G Uk9NX0VER0UgKHVzZV9zdG10LCBkZXN0X2UpICE9IGxocykKKwkJICBjb250aW51ZTsKIAotICAg ICAgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgZXhpdF9nc2kgPSBnc2lfYWZ0ZXJfbGFiZWxzIChleGl0 X2JiKTsKLSAgICAgIGlmIChzdG10cykKLQlnc2lfaW5zZXJ0X3NlcV9iZWZvcmUgKCZleGl0X2dz aSwgc3RtdHMsIEdTSV9TQU1FX1NUTVQpOworCQlnaW1wbGUgKnRtcF92ZWNfc3RtdCA9IHZlY19z dG10OworCQl0cmVlIHRtcF92ZWNfbGhzID0gdmVjX2xoczsKKwkJdHJlZSB0bXBfYml0c3RhcnQg PSBiaXRzdGFydDsKKwkJLyogRm9yIGVhcmx5IGV4aXQgd2hlcmUgdGhlIGV4aXQgaXMgbm90IGlu IHRoZSBCQiB0aGF0IGxlYWRzCisJCSAgIHRvIHRoZSBsYXRjaCB0aGVuIHdlJ3JlIHJlc3RhcnRp bmcgdGhlIGl0ZXJhdGlvbiBpbiB0aGUKKwkJICAgc2NhbGFyIGxvb3AuICBTbyBnZXQgdGhlIGZp cnN0IGxpdmUgdmFsdWUuICAqLworCQlpZiAocmVzdGFydF9sb29wIHx8IGV4aXRfZSAhPSBtYWlu X2UpCisJCSAgeworCQkgICAgdG1wX3ZlY19zdG10ID0gU1RNVF9WSU5GT19WRUNfU1RNVFMgKHN0 bXRfaW5mbylbMF07CisJCSAgICB0bXBfdmVjX2xocyA9IGdpbXBsZV9nZXRfbGhzICh0bXBfdmVj X3N0bXQpOworCQkgICAgdG1wX2JpdHN0YXJ0ID0gYnVpbGRfemVyb19jc3QgKFRSRUVfVFlQRSAo Yml0c3RhcnQpKTsKKwkJICB9CiAKLSAgICAgIC8qIFJlbW92ZSBleGlzdGluZyBwaGlzIHRoYXQg Y29weSBmcm9tIGxocyBhbmQgY3JlYXRlIGNvcGllcwotCSBmcm9tIG5ld190cmVlLiAgKi8KLSAg ICAgIGdpbXBsZV9zdG10X2l0ZXJhdG9yIGdzaTsKLSAgICAgIGZvciAoZ3NpID0gZ3NpX3N0YXJ0 X3BoaXMgKGV4aXRfYmIpOyAhZ3NpX2VuZF9wIChnc2kpOykKLQl7Ci0JICBnaW1wbGUgKnBoaSA9 IGdzaV9zdG10IChnc2kpOwotCSAgaWYgKChnaW1wbGVfcGhpX2FyZ19kZWYgKHBoaSwgMCkgPT0g bGhzKSkKLQkgICAgewotCSAgICAgIHJlbW92ZV9waGlfbm9kZSAoJmdzaSwgZmFsc2UpOwotCSAg ICAgIHRyZWUgbGhzX3BoaSA9IGdpbXBsZV9waGlfcmVzdWx0IChwaGkpOwotCSAgICAgIGdpbXBs ZSAqY29weSA9IGdpbXBsZV9idWlsZF9hc3NpZ24gKGxoc19waGksIG5ld190cmVlKTsKLQkgICAg ICBnc2lfaW5zZXJ0X2JlZm9yZSAoJmV4aXRfZ3NpLCBjb3B5LCBHU0lfU0FNRV9TVE1UKTsKLQkg ICAgfQotCSAgZWxzZQotCSAgICBnc2lfbmV4dCAoJmdzaSk7Ci0JfQorCQlnaW1wbGVfc3RtdF9p dGVyYXRvciBleGl0X2dzaTsKKwkJdHJlZSBuZXdfdHJlZQorCQkgID0gdmVjdG9yaXphYmxlX2xp dmVfb3BlcmF0aW9uXzEgKGxvb3BfdmluZm8sIHN0bXRfaW5mbywKKwkJCQkJCSAgIGV4aXRfZSwg dmVjdHlwZSwgbmNvcGllcywKKwkJCQkJCSAgIHNscF9ub2RlLCBiaXRzaXplLAorCQkJCQkJICAg dG1wX2JpdHN0YXJ0LCB0bXBfdmVjX2xocywKKwkJCQkJCSAgIGxoc190eXBlLCByZXN0YXJ0X2xv b3AsCisJCQkJCQkgICAmZXhpdF9nc2kpOworCisJCS8qIFVzZSB0aGUgZW1wdHkgYmxvY2sgb24g dGhlIGV4aXQgdG8gbWF0ZXJpYWxpemUgdGhlIG5ldyBzdG10cworCQkgICBzbyB3ZSBjYW4gdXNl IHVwZGF0ZSB0aGUgUEhJIGhlcmUuICAqLworCQlpZiAoZ2ltcGxlX3BoaV9udW1fYXJncyAodXNl X3N0bXQpID09IDEpCisJCSAgeworCQkgICAgYXV0byBnc2kgPSBnc2lfZm9yX3N0bXQgKHVzZV9z dG10KTsKKwkJICAgIHJlbW92ZV9waGlfbm9kZSAoJmdzaSwgZmFsc2UpOworCQkgICAgdHJlZSBs aHNfcGhpID0gZ2ltcGxlX3BoaV9yZXN1bHQgKHVzZV9zdG10KTsKKwkJICAgIGdpbXBsZSAqY29w eSA9IGdpbXBsZV9idWlsZF9hc3NpZ24gKGxoc19waGksIG5ld190cmVlKTsKKwkJICAgIGdzaV9p bnNlcnRfYmVmb3JlICgmZXhpdF9nc2ksIGNvcHksIEdTSV9TQU1FX1NUTVQpOworCQkgIH0KKwkJ ZWxzZQorCQkgIFNFVF9QSElfQVJHX0RFRiAodXNlX3N0bXQsIGRlc3RfZS0+ZGVzdF9pZHgsIG5l d190cmVlKTsKKwkgICAgICB9CisJICB9CiAKICAgICAgIC8qIFRoZXJlIGEgbm8gZnVydGhlciBv dXQtb2YtbG9vcCB1c2VzIG9mIGxocyBieSBMQy1TU0EgY29uc3RydWN0aW9uLiAgKi8KICAgICAg IEZPUl9FQUNIX0lNTV9VU0VfU1RNVCAodXNlX3N0bXQsIGltbV9pdGVyLCBsaHMpCkBAIC0xMTc5 Nyw2ICsxMTk1NiwyMSBAQCB2ZWN0X3RyYW5zZm9ybV9sb29wIChsb29wX3ZlY19pbmZvIGxvb3Bf dmluZm8sIGdpbXBsZSAqbG9vcF92ZWN0b3JpemVkX2NhbGwpCiAJICAgICAgaWYgKGR1bXBfZW5h YmxlZF9wICgpKQogCQlkdW1wX3ByaW50Zl9sb2MgKE1TR19OT1RFLCB2ZWN0X2xvY2F0aW9uLCAi dHJhbnNmb3JtIHBoaS5cbiIpOwogCSAgICAgIHZlY3RfdHJhbnNmb3JtX3N0bXQgKGxvb3Bfdmlu Zm8sIHN0bXRfaW5mbywgTlVMTCwgTlVMTCwgTlVMTCk7CisJICAgICAgLyogSWYgdmVjdG9yaXpp bmcgZWFybHkgYnJlYWsgd2UgbXVzdCBhbHNvIHZlY3Rvcml6ZSB0aGUgdXNlIG9mCisJCSB0aGUg UEhJcyBhcyBhIGxpdmUgb3BlcmF0aW9uLiAgKi8KKwkgICAgICBpZiAoTE9PUF9WSU5GT19FQVJM WV9CUkVBS1MgKGxvb3BfdmluZm8pCisJCSAgJiYgIVNUTVRfVklORk9fTElWRV9QIChzdG10X2lu Zm8pCisJCSAgJiYgU1RNVF9WSU5GT19ERUZfVFlQRSAoc3RtdF9pbmZvKSA9PSB2ZWN0X2luZHVj dGlvbl9kZWYpCisJCXsKKwkJICBpZiAoZHVtcF9lbmFibGVkX3AgKCkpCisJCSAgICBkdW1wX3By aW50Zl9sb2MgKE1TR19OT1RFLCB2ZWN0X2xvY2F0aW9uLAorCQkJICItLS0tPiB2ZWN0b3Jpemlu ZyBlYXJseSBicmVhayByZWR1YyBvciBpbmR1YyBwaGk6ICVHIiwKKwkJCSAoZ2ltcGxlICopIHBo aSk7CisJCSAgYm9vbCBkb25lCisJCSAgICA9IHZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbiAo bG9vcF92aW5mbywgc3RtdF9pbmZvLCBOVUxMLAorCQkJCQkJICAgTlVMTCwgLTEsIHRydWUsIE5V TEwpOworCQkgIGdjY19hc3NlcnQgKGRvbmUpOworCQl9CiAJICAgIH0KIAl9CiAKZGlmZiAtLWdp dCBhL2djYy90cmVlLXZlY3Qtc3RtdHMuY2MgYi9nY2MvdHJlZS12ZWN0LXN0bXRzLmNjCmluZGV4 IGZlMzhiZWI0ZmExZDlmODU5MzQ0NTM1NGY1NmJhNTJlMTBhMDQwY2QuLmYxYjZhMTMzOTVmMjg2 Zjk5OTc1MzBiYmU1N2NkYTNhMDA1MDJmOGYgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXZlY3Qtc3Rt dHMuY2MKKysrIGIvZ2NjL3RyZWUtdmVjdC1zdG10cy5jYwpAQCAtMzQyLDYgKzM0Miw3IEBAIGlz X3NpbXBsZV9hbmRfYWxsX3VzZXNfaW52YXJpYW50IChzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywK ICAgIC0gaXQgaGFzIHVzZXMgb3V0c2lkZSB0aGUgbG9vcC4KICAgIC0gaXQgaGFzIHZkZWZzIChp dCBhbHRlcnMgbWVtb3J5KS4KICAgIC0gY29udHJvbCBzdG10cyBpbiB0aGUgbG9vcCAoZXhjZXB0 IGZvciB0aGUgZXhpdCBjb25kaXRpb24pLgorICAgLSBpdCBpcyBhbiBpbmR1Y3Rpb24gYW5kIHdl IGhhdmUgbXVsdGlwbGUgZXhpdHMuCiAKICAgIENIRUNLTUU6IHdoYXQgb3RoZXIgc2lkZSBlZmZl Y3RzIHdvdWxkIHRoZSB2ZWN0b3JpemVyIGFsbG93PyAgKi8KIApAQCAtMzk5LDYgKzQwMCwxOSBA QCB2ZWN0X3N0bXRfcmVsZXZhbnRfcCAoc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sIGxvb3BfdmVj X2luZm8gbG9vcF92aW5mbywKIAl9CiAgICAgfQogCisgIC8qIENoZWNrIGlmIGl0J3MgYW4gaW5k dWN0aW9uIGFuZCBtdWx0aXBsZSBleGl0cy4gIEluIHRoaXMgY2FzZSB0aGVyZSB3aWxsIGJlCisg ICAgIGEgdXNhZ2UgbGF0ZXIgb24gYWZ0ZXIgcGVlbGluZyB3aGljaCBpcyBuZWVkZWQgZm9yIHRo ZSBhbHRlcm5hdGUgZXhpdC4gICovCisgIGlmIChMT09QX1ZJTkZPX0VBUkxZX0JSRUFLUyAobG9v cF92aW5mbykKKyAgICAgICYmIFNUTVRfVklORk9fREVGX1RZUEUgKHN0bXRfaW5mbykgPT0gdmVj dF9pbmR1Y3Rpb25fZGVmKQorICAgIHsKKyAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkg IGR1bXBfcHJpbnRmX2xvYyAoTVNHX05PVEUsIHZlY3RfbG9jYXRpb24sCisJCQkgICAidmVjX3N0 bXRfcmVsZXZhbnRfcDogaW5kdWN0aW9uIGZvcmNlZCBmb3IgIgorCQkJICAgImVhcmx5IGJyZWFr LlxuIik7CisgICAgICAqcmVsZXZhbnQgPSB2ZWN0X3VzZWRfaW5fc2NvcGU7CisKKyAgICB9CisK ICAgaWYgKCpsaXZlX3AgJiYgKnJlbGV2YW50ID09IHZlY3RfdW51c2VkX2luX3Njb3BlCiAgICAg ICAmJiAhaXNfc2ltcGxlX2FuZF9hbGxfdXNlc19pbnZhcmlhbnQgKHN0bXRfaW5mbywgbG9vcF92 aW5mbykpCiAgICAgewpAQCAtMTc3NCw3ICsxNzg4LDcgQEAgY29tcGFyZV9zdGVwX3dpdGhfemVy byAodmVjX2luZm8gKnZpbmZvLCBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbykKIC8qIElmIHRoZSB0 YXJnZXQgc3VwcG9ydHMgYSBwZXJtdXRlIG1hc2sgdGhhdCByZXZlcnNlcyB0aGUgZWxlbWVudHMg aW4KICAgIGEgdmVjdG9yIG9mIHR5cGUgVkVDVFlQRSwgcmV0dXJuIHRoYXQgbWFzaywgb3RoZXJ3 aXNlIHJldHVybiBudWxsLiAgKi8KIAotc3RhdGljIHRyZWUKK3RyZWUKIHBlcm1fbWFza19mb3Jf cmV2ZXJzZSAodHJlZSB2ZWN0eXBlKQogewogICBwb2x5X3VpbnQ2NCBudW5pdHMgPSBUWVBFX1ZF Q1RPUl9TVUJQQVJUUyAodmVjdHlwZSk7CmRpZmYgLS1naXQgYS9nY2MvdHJlZS12ZWN0b3JpemVy LmggYi9nY2MvdHJlZS12ZWN0b3JpemVyLmgKaW5kZXggMjJhOGMzZDM4NGQ3YWUxY2E5MzA3OWI2 NGYyZDQwODIxYjRhM2M1Ni4uY2ZkNjc1NjQ5MmU0YWY0NjBjMmY1NjY5ZWNjY2M4MmIxMDg5Y2Zl NCAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtdmVjdG9yaXplci5oCisrKyBiL2djYy90cmVlLXZlY3Rv cml6ZXIuaApAQCAtMjIyNSw2ICsyMjI1LDcgQEAgZXh0ZXJuIGJvb2wgdmVjdF9jYW5fYWR2YW5j ZV9pdnNfcCAobG9vcF92ZWNfaW5mbyk7CiBleHRlcm4gdm9pZCB2ZWN0X3VwZGF0ZV9pbml0c19v Zl9kcnMgKGxvb3BfdmVjX2luZm8sIHRyZWUsIHRyZWVfY29kZSk7CiBleHRlcm4gZWRnZSB2ZWNf aW5pdF9sb29wX2V4aXRfaW5mbyAoY2xhc3MgbG9vcCAqKTsKIGV4dGVybiBib29sIHZlY3RfaXNf bG9vcF9leGl0X2xhdGNoX3ByZWQgKGVkZ2UsIGNsYXNzIGxvb3AgKik7CitleHRlcm4gdm9pZCB2 ZWN0X2l2X2luY3JlbWVudF9wb3NpdGlvbiAoZWRnZSwgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKiwg Ym9vbCAqKTsKIAogLyogSW4gdHJlZS12ZWN0LXN0bXRzLmNjLiAgKi8KIGV4dGVybiB0cmVlIGdl dF9yZWxhdGVkX3ZlY3R5cGVfZm9yX3NjYWxhcl90eXBlIChtYWNoaW5lX21vZGUsIHRyZWUsCkBA IC0yMjQ2LDYgKzIyNDcsNyBAQCBleHRlcm4gYm9vbCB2ZWN0X2lzX3NpbXBsZV91c2UgKHZlY19p bmZvICosIHN0bXRfdmVjX2luZm8sIHNscF90cmVlLAogCQkJCWVudW0gdmVjdF9kZWZfdHlwZSAq LAogCQkJCXRyZWUgKiwgc3RtdF92ZWNfaW5mbyAqID0gTlVMTCk7CiBleHRlcm4gYm9vbCB2ZWN0 X21heWJlX3VwZGF0ZV9zbHBfb3BfdmVjdHlwZSAoc2xwX3RyZWUsIHRyZWUpOworZXh0ZXJuIHRy ZWUgcGVybV9tYXNrX2Zvcl9yZXZlcnNlICh0cmVlKTsKIGV4dGVybiBib29sIHN1cHBvcnRhYmxl X3dpZGVuaW5nX29wZXJhdGlvbiAodmVjX2luZm8qLCBjb2RlX2hlbHBlciwKIAkJCQkJICAgIHN0 bXRfdmVjX2luZm8sIHRyZWUsIHRyZWUsCiAJCQkJCSAgICBjb2RlX2hlbHBlciosIGNvZGVfaGVs cGVyKiwK --_002_VI1PR08MB5325326E1AF88F3235E641DBFFB4AVI1PR08MB5325eurp_--