From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01on2043.outbound.protection.outlook.com [40.107.14.43]) by sourceware.org (Postfix) with ESMTPS id 8DCBC3858CD1 for ; Fri, 8 Dec 2023 08:58:33 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 8DCBC3858CD1 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 8DCBC3858CD1 Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=40.107.14.43 ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1702025916; cv=pass; b=pxo0775jiWrtwQDsXKnM60rEBrWfK8BeIHhJK8liUWsvHi/yBLNH/fsQXTRFSdf7qvFNdlXZPaJQa4ddwaYNQlrCzvtTovvKFym5xnyR1Lpz8qI5zUgQlSLViyfFQCSQ25xbwjB0gf+UrmG2OQ53w02pskK7RvyO6PM+Yn5ICkw= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1702025916; c=relaxed/simple; bh=I/z09hHbkZ9V+UW0GXYqGXtDIdISkGbAJSGxTubN/ow=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=lwmvVcwikSTf6ypS2rGfzl0kwEcyQeXpyN+MX9TsTWld5GmRA7NvtPWMNchGL5NAvrXCxNVL/4xqKaN11bBt+38yaoRzPtWQYGrVAhDKBEVmeVMoQZcSauFYdVIP64n09QeDIO1y2HxHCpzWf/k6knOSqA4UZB4jJ86ogE+hj0E= ARC-Authentication-Results: i=3; server2.sourceware.org ARC-Seal: i=2; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=pass; b=CZooamjLwiQDk6j3fxiUclkLvJ8R7zeTl7XSdqMQ33+Nidh6RtiPbfsLy4ZbiMjLg/Z2xZCI2/Dhr91F5+n9rbhLCzexjyOANO6jPIQaFxa9ywcywvGziL2zt4WTjBQ988Ytzv8y2zzFJZllvRPtCTABLXPjIKpGTLiCitH1jsmuXA8ev7A5W37P+Z9KvSLvuWpfG7P2ehhAn0xNJ7Nn8b2FQU9GRPluiNW+iR7O5Rvc82nfolWwPvLbKAEHmuF5+1SelU8GISN3RMHIS7lW++rrCfbKJHXP/8eOKlp6cIvsmuf2ZGyP/7WzMFS6hWZeQybuSyHPUrecPublXYlJqg== 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=FF38Hvbq88xtCqmTwli3yViwDY4s5q9wGHv4ObqUp7g=; b=EoYwaqkVoj12hQysTRdpieNalQXDjRR1ZbcKccC581xpMBxEPHOad5jZj8Uwv2xEhj3aoTVSo+441QFcqFQcv5C7pFE1yu87LLdqbKNrEi8vFxLEKmdw4zffnNFkfigPIL2/kbI85g8m/o57POIdTQ33+lgyqZ82FCpq0aBpnAZHY/IhIkM+YMuoio7PqbvFefQIDBUuNtDfX6n8B9mDZLZZ5dPQCwy1jWtfuI7w4ua3D8RGBWmJmqaiFKWp2FJJcuV69VF5mZuf/D8EtgJazcR73gtkud20QiBrMTZ5uJpLrjDhTj0zItyQP6N9Sc/3xX5GkADh3arwKxQOZCY3RA== 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=FF38Hvbq88xtCqmTwli3yViwDY4s5q9wGHv4ObqUp7g=; b=2e6D8nq3X0YfuYsyAtZcAURQ+qTLM5X96+HW4tg0upmvUGnRiGx9dzpJVLx88ykayEIkmqGumSNdlQL+ZmsKmdq26cJyG2aCX24S1Jlx+A/HeEipJY03/Jut9qb/oDHLnxurZqVrg3zAhLSiGrf6ezXFYTJj63bV5p9eU3/hlNs= Received: from DUZPR01CA0061.eurprd01.prod.exchangelabs.com (2603:10a6:10:3c2::19) by PAWPR08MB8959.eurprd08.prod.outlook.com (2603:10a6:102:33f::15) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7068.25; Fri, 8 Dec 2023 08:58:29 +0000 Received: from DB5PEPF00014B94.eurprd02.prod.outlook.com (2603:10a6:10:3c2:cafe::ca) by DUZPR01CA0061.outlook.office365.com (2603:10a6:10:3c2::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7046.34 via Frontend Transport; Fri, 8 Dec 2023 08:58:29 +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 DB5PEPF00014B94.mail.protection.outlook.com (10.167.8.232) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7068.20 via Frontend Transport; Fri, 8 Dec 2023 08:58:29 +0000 Received: ("Tessian outbound 7671e7ddc218:v228"); Fri, 08 Dec 2023 08:58:29 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: 47ae6f0c8d1bc892 X-CR-MTA-TID: 64aa7808 Received: from 230268d447d9.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id 1F96887A-3AB3-495F-B605-F46F85184972.1; Fri, 08 Dec 2023 08:58:23 +0000 Received: from EUR05-VI1-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id 230268d447d9.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Fri, 08 Dec 2023 08:58:23 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=bL+jPF/49krseQTB7/cpZyBaOzFgbielqjDLq9r1ZV8nuZ3Ay1MVoUWl3LwwlmqQMb5KfOPBfvxSDl5iE6DlaeWsiOWpGNza15tPYYcKveR7UpbSG82S6ge4ziTR36MfUdPbOeUthzO9RrH8dRCu5f+kVa/5pKfB38eyl1aAImiwiu5kunpk5yxVRXN6A13dJqb0RyxGoEridn2ERy6xPDkSRq4f7CJ2BzXvhGh11qlZOl75RCvfvRQKKYFQyfT0LzCLhKkYh/3EEuDBxZGB3rnppnrhgUbBaVg4HZttBJFwZXe9+XEroAN9VEQg80H2MgwfuDvU+rcgZAwbpKrlHQ== 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=FF38Hvbq88xtCqmTwli3yViwDY4s5q9wGHv4ObqUp7g=; b=fYYb+34KgCJtakI2/OPMUsES3NNvHtkCj66hUVBriXG1ROu0mTe+aEUjoDlCb4ViAbYXZRWciw/YKlJT0AMvXJ8CG0aLHem0X0+dQWMrN7i2O3T7yXJ3C0DKtHnRbWISzYSwQCoiwwW7nth9gCl6538F0d87YpGNXwmmOH5nbOvDw/IwxEi0TSpT/tWUOrjRGrZ+p3l5zRq0UPKBIuy7Ejo7FwNq1l+op8FQqhjWHX8b40hDRPToae8Ly/Xq8jiPeY+Su1eOsJuLB72T/2MtrTdswQ6wwQqNl9h4OInmxwmpIiSeerbjBouJ6yM9eAcBvaib1Keh4iLb8dveMu2cSg== 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=FF38Hvbq88xtCqmTwli3yViwDY4s5q9wGHv4ObqUp7g=; b=2e6D8nq3X0YfuYsyAtZcAURQ+qTLM5X96+HW4tg0upmvUGnRiGx9dzpJVLx88ykayEIkmqGumSNdlQL+ZmsKmdq26cJyG2aCX24S1Jlx+A/HeEipJY03/Jut9qb/oDHLnxurZqVrg3zAhLSiGrf6ezXFYTJj63bV5p9eU3/hlNs= Received: from VI1PR08MB5325.eurprd08.prod.outlook.com (2603:10a6:803:13e::17) by DBBPR08MB6060.eurprd08.prod.outlook.com (2603:10a6:10:20a::22) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7068.28; Fri, 8 Dec 2023 08:58:18 +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.7068.027; Fri, 8 Dec 2023 08:58:18 +0000 From: Tamar Christina To: Richard Biener CC: "gcc-patches@gcc.gnu.org" , nd , "jlaw@ventanamicro.com" Subject: RE: [PATCH 9/21]middle-end: implement vectorizable_early_exit for codegen of exit code Thread-Topic: [PATCH 9/21]middle-end: implement vectorizable_early_exit for codegen of exit code Thread-Index: AQHaEIRpInfkk2iMNkKe/ayk/lXCPbCO5tuwgAKOHoCACmF78IAAWBaAgAMYIGA= Date: Fri, 8 Dec 2023 08:58:18 +0000 Message-ID: References: <85570n66-1540-0r07-7q80-269p3o133585@fhfr.qr> <5r3p7378-q309-ooqo-7o76-q9r567ns1890@fhfr.qr> In-Reply-To: <5r3p7378-q309-ooqo-7o76-q9r567ns1890@fhfr.qr> 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_|DBBPR08MB6060:EE_|DB5PEPF00014B94:EE_|PAWPR08MB8959:EE_ X-MS-Office365-Filtering-Correlation-Id: 07d38b6c-dd56-4abf-cf0b-08dbf7cbd931 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: 6ICuOV+qF/LGTXwkeo7Uev+ZBF9RdK5tdZdaHqOtt7ZNZXVrInsHdaq2xtJA7QXbAPpMF2LkVY7y7WcXVUZsb4swjmru2Hop6O7xMMRpYOOh38ZTMqhljOlOjzkAz8P5V1VSq0wfRI1X7s4TkwC6jtAvu4PwcH0GznomKsZ0R9RBTzjqO9hYrT71CxK8BMon7IRlwPf9XdBprNwJrEaMPEXkaqLasiUwuEdK49lAjkqUXSQTfseXBZ3XzAqEOj5soJqj7vTEytjgognNgZg3corz2VG6rAB6mRV5h2gLCokmxZSRvBi2Os1bTvdDx2QfC+ZE9MLNorPMO/CwBdBVUi10VMEiekn6dUxZJ9Wr/LERJoNh+mZ57tnzIck+E5ved+lJRMRnIa0XX4B2mYckAXZVT9FzReoq/orRW/facFvUwqkKRyzM+mb3m7D3V6bAx3TxEHFOIN0RFDimVRFd9ko4zJiQfKrYx1AVxsiTegvFt55RudwwKcdCrqhynlVI0kwcPSTa4elxfqG/+Wq2jnLhN+9sd4owiMkBaj6bIh7C/UOBEmAVdyr3nu/UOSaYxqX3q39ygRBndVRrS9om0uNtMgtNyzo3hBdr9uBpp5TzlHwHC0Jd9XzLjJgTqtKI 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)(376002)(136003)(366004)(396003)(346002)(39860400002)(230922051799003)(64100799003)(1800799012)(186009)(451199024)(26005)(83380400001)(9686003)(7696005)(33656002)(6506007)(71200400001)(478600001)(122000001)(316002)(64756008)(66946007)(66476007)(76116006)(66446008)(6916009)(66556008)(54906003)(38100700002)(8936002)(8676002)(4326008)(86362001)(52536014)(99936003)(5660300002)(2906002)(30864003)(55016003)(38070700009)(41300700001)(559001)(579004);DIR:OUT;SFP:1101; Content-Type: multipart/mixed; boundary="_002_VI1PR08MB5325B28C5C00234F14DB2E1DFF8AAVI1PR08MB5325eurp_" MIME-Version: 1.0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: DBBPR08MB6060 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: DB5PEPF00014B94.eurprd02.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: 65863032-0994-4de6-d1dc-08dbf7cbd2ac X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: IyK1Oa0Jg7IubwV+NBcAfUCivYVjcsi/uXZ1C6+bprQITbWgFRWAJX5/q+7R1ljDu0VxQzLN27csjvYmsGbsLYX8tp1+LP/nuhnt6NNhEnnxShLNZYHyOzpqWHHhph/1xq6VzWgLKlr4xUF+QXgH2oHfdIXgh7qvHx0gB93EJkSjyThQ7UUiCrMRiUJ2OoNYaF6BGY3a3rD6JOl4MUfnnuocyOuOYQzz+Rwu6myShZ4mLycNbHHr0YQCobpxjuToUF1M6SuqngXjFcnRQJ/ZvJtncmZeGuE+6mWKR6yC7o4KflwqXwmFoTyX7mCzYJnwsPQxBVpNrlOnCfrjvz5dru0qumn4NW9fwJIJ2pVW43vkD7r5UrfUYMgRTyUVEfcXwghZH5YdN91q7kbzddrjsVuZzj5BpMCgnjCtufi1BThfaoJ6Z2RYC1+NgqDimbduuc2aoh0F4zF25wH8O5wMjWetpVHTEcqe1IF/urNeywk4DzjtmQCKGHnljUuVIciq4eA9HqYH2deP6Og8TkodIxIUy/TtJNnaLYp6nRo7AaFoIRrl/z+jmcxX4J1zb3RhE7tbWSid6ascarNMsO+4XPoXTdBFEVqEclSzvyaPI9ZgZz6x4N0EYXw+H/AEZDUpWPYPkAdcICUNZZW2I+QbFIpGLUT4/Qt80snuoecBLSyrEw9WcCdYncDsAmq0gWH96uP6ctAMbwHoIixkm7QbA9TSms4T/GkATSirql/dtPLSghWhF8ZsIY+O3Zm+YZjX 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)(346002)(376002)(39860400002)(136003)(396003)(230922051799003)(451199024)(82310400011)(1800799012)(186009)(64100799003)(40470700004)(36840700001)(46966006)(40460700003)(9686003)(7696005)(478600001)(235185007)(86362001)(41300700001)(5660300002)(36860700001)(33656002)(356005)(82740400003)(2906002)(81166007)(107886003)(4326008)(99936003)(47076005)(52536014)(6506007)(8936002)(83380400001)(8676002)(54906003)(70206006)(70586007)(30864003)(316002)(26005)(6862004)(336012)(40480700001)(55016003);DIR:OUT;SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Dec 2023 08:58:29.7399 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 07d38b6c-dd56-4abf-cf0b-08dbf7cbd931 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: DB5PEPF00014B94.eurprd02.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAWPR08MB8959 X-Spam-Status: No, score=-12.1 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,FORGED_SPF_HELO,GIT_PATCH_0,KAM_DMARC_NONE,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_VI1PR08MB5325B28C5C00234F14DB2E1DFF8AAVI1PR08MB5325eurp_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable > --param vect-partial-vector-usage=3D2 would, no? >=20 I.. didn't even know it went to 2! > > In principal I suppose I could mask the individual stmts, that should h= andle the > future case when > > This is relaxed to supposed non-fix length buffers? >=20 > Well, it looks wrong - either put in an assert that we start with a > single stmt or assert !masked_loop_p instead? Better ICE than > generate wrong code. >=20 > That said, I think you need to apply the masking on the original > stmts[], before reducing them, no? Yeah, I've done so now. For simplicity I've just kept the final masking al= ways as well and just leave it up to the optimizers to drop it when it's superfluous. Simple testcase: #ifndef N #define N 837 #endif float vect_a[N]; unsigned vect_b[N]; unsigned test4(double x) { unsigned ret =3D 0; for (int i =3D 0; i < N; i++) { if (vect_a[i] > x) break; vect_a[i] =3D x; } return ret; } Looks good now. After this one there's only one patch left, the dependency = analysis. I'm almost done with the cleanup/respin, but want to take the weekend to do= uble check and will post it first thing Monday morning. Did you want to see the testsuite changes as well again? I've basically jus= t added the right dg-requires-effective and add-options etc. Thanks for all the reviews! Bootstrapped Regtested on aarch64-none-linux-gnu and no issues. Ok for master? Thanks, Tamar gcc/ChangeLog: * tree-vect-patterns.cc (vect_init_pattern_stmt): Support gconds. (check_bool_pattern, adjust_bool_pattern, adjust_bool_stmts, vect_recog_bool_pattern, sort_after_uid): Support gconds type analysis. * tree-vect-stmts.cc (vectorizable_comparison_1): Support stmts without lhs. (vectorizable_early_exit): New. (vect_analyze_stmt, vect_transform_stmt): Use it. (vect_is_simple_use, vect_get_vector_types_for_stmt): Support gcond. --- inline copy of patch --- diff --git a/gcc/tree-vect-patterns.cc b/gcc/tree-vect-patterns.cc index 7debe7f0731673cd1bf25cd39d55e23990a73d0e..8865cde9f3481a474d31848ae12= 523576d29744d 100644 --- a/gcc/tree-vect-patterns.cc +++ b/gcc/tree-vect-patterns.cc @@ -132,6 +132,7 @@ vect_init_pattern_stmt (vec_info *vinfo, gimple *patter= n_stmt, if (!STMT_VINFO_VECTYPE (pattern_stmt_info)) { gcc_assert (!vectype + || is_a (pattern_stmt) || (VECTOR_BOOLEAN_TYPE_P (vectype) =3D=3D vect_use_mask_type_p (orig_stmt_info))); STMT_VINFO_VECTYPE (pattern_stmt_info) =3D vectype; @@ -5210,19 +5211,28 @@ vect_recog_mixed_size_cond_pattern (vec_info *vinfo= , true if bool VAR can and should be optimized that way. Assume it shoul= dn't in case it's a result of a comparison which can be directly vectorized = into a vector comparison. Fills in STMTS with all stmts visited during the - walk. */ + walk. if ANALYZE_ONLY then only analyze the booleans but do not perfor= m any + codegen associated with the boolean condition. */ =20 static bool -check_bool_pattern (tree var, vec_info *vinfo, hash_set &stmts) +check_bool_pattern (tree var, vec_info *vinfo, hash_set &stmts, + bool analyze_only) { tree rhs1; enum tree_code rhs_code; + gassign *def_stmt =3D NULL; =20 stmt_vec_info def_stmt_info =3D vect_get_internal_def (vinfo, var); - if (!def_stmt_info) + if (!def_stmt_info && !analyze_only) return false; + else if (!def_stmt_info) + /* If we're a only analyzing we won't be codegen-ing the statements an= d are + only after if the types match. In that case we can accept loop inv= ariant + values. */ + def_stmt =3D dyn_cast (SSA_NAME_DEF_STMT (var)); + else + def_stmt =3D dyn_cast (def_stmt_info->stmt); =20 - gassign *def_stmt =3D dyn_cast (def_stmt_info->stmt); if (!def_stmt) return false; =20 @@ -5234,27 +5244,28 @@ check_bool_pattern (tree var, vec_info *vinfo, hash= _set &stmts) switch (rhs_code) { case SSA_NAME: - if (! check_bool_pattern (rhs1, vinfo, stmts)) + if (! check_bool_pattern (rhs1, vinfo, stmts, analyze_only)) return false; break; =20 CASE_CONVERT: if (!VECT_SCALAR_BOOLEAN_TYPE_P (TREE_TYPE (rhs1))) return false; - if (! check_bool_pattern (rhs1, vinfo, stmts)) + if (! check_bool_pattern (rhs1, vinfo, stmts, analyze_only)) return false; break; =20 case BIT_NOT_EXPR: - if (! check_bool_pattern (rhs1, vinfo, stmts)) + if (! check_bool_pattern (rhs1, vinfo, stmts, analyze_only)) return false; break; =20 case BIT_AND_EXPR: case BIT_IOR_EXPR: case BIT_XOR_EXPR: - if (! check_bool_pattern (rhs1, vinfo, stmts) - || ! check_bool_pattern (gimple_assign_rhs2 (def_stmt), vinfo, stmts)) + if (! check_bool_pattern (rhs1, vinfo, stmts, analyze_only) + || ! check_bool_pattern (gimple_assign_rhs2 (def_stmt), vinfo, stmts, + analyze_only)) return false; break; =20 @@ -5275,6 +5286,7 @@ check_bool_pattern (tree var, vec_info *vinfo, hash_s= et &stmts) tree mask_type =3D get_mask_type_for_scalar_type (vinfo, TREE_TYPE (rhs1)); if (mask_type + && !analyze_only && expand_vec_cmp_expr_p (comp_vectype, mask_type, rhs_code)) return false; =20 @@ -5289,7 +5301,8 @@ check_bool_pattern (tree var, vec_info *vinfo, hash_s= et &stmts) } else vecitype =3D comp_vectype; - if (! expand_vec_cond_expr_p (vecitype, comp_vectype, rhs_code)) + if (!analyze_only + && !expand_vec_cond_expr_p (vecitype, comp_vectype, rhs_code)) return false; } else @@ -5324,11 +5337,13 @@ adjust_bool_pattern_cast (vec_info *vinfo, VAR is an SSA_NAME that should be transformed from bool to a wider inte= ger type, OUT_TYPE is the desired final integer type of the whole pattern. STMT_INFO is the info of the pattern root and is where pattern stmts sh= ould - be associated with. DEFS is a map of pattern defs. */ + be associated with. DEFS is a map of pattern defs. If TYPE_ONLY then = don't + create new pattern statements and instead only fill LAST_STMT and DEFS.= */ =20 static void adjust_bool_pattern (vec_info *vinfo, tree var, tree out_type, - stmt_vec_info stmt_info, hash_map &defs) + stmt_vec_info stmt_info, hash_map &defs, + gimple *&last_stmt, bool type_only) { gimple *stmt =3D SSA_NAME_DEF_STMT (var); enum tree_code rhs_code, def_rhs_code; @@ -5492,28 +5507,38 @@ adjust_bool_pattern (vec_info *vinfo, tree var, tre= e out_type, } =20 gimple_set_location (pattern_stmt, loc); - append_pattern_def_seq (vinfo, stmt_info, pattern_stmt, - get_vectype_for_scalar_type (vinfo, itype)); + if (!type_only) + append_pattern_def_seq (vinfo, stmt_info, pattern_stmt, + get_vectype_for_scalar_type (vinfo, itype)); + last_stmt =3D pattern_stmt; defs.put (var, gimple_assign_lhs (pattern_stmt)); } =20 -/* Comparison function to qsort a vector of gimple stmts after UID. */ +/* Comparison function to qsort a vector of gimple stmts after BB and UID. + the def of one statement can be in an earlier block than the use, so if + the BB are different, first compare by BB. */ =20 static int sort_after_uid (const void *p1, const void *p2) { const gimple *stmt1 =3D *(const gimple * const *)p1; const gimple *stmt2 =3D *(const gimple * const *)p2; + if (gimple_bb (stmt1)->index !=3D gimple_bb (stmt2)->index) + return gimple_bb (stmt1)->index - gimple_bb (stmt2)->index; + return gimple_uid (stmt1) - gimple_uid (stmt2); } =20 /* Create pattern stmts for all stmts participating in the bool pattern specified by BOOL_STMT_SET and its root STMT_INFO with the desired type - OUT_TYPE. Return the def of the pattern root. */ + OUT_TYPE. Return the def of the pattern root. If TYPE_ONLY the new + statements are not emitted as pattern statements and the tree returned = is + only useful for type queries. */ =20 static tree adjust_bool_stmts (vec_info *vinfo, hash_set &bool_stmt_set, - tree out_type, stmt_vec_info stmt_info) + tree out_type, stmt_vec_info stmt_info, + bool type_only =3D false) { /* Gather original stmts in the bool pattern in their order of appearanc= e in the IL. */ @@ -5523,16 +5548,16 @@ adjust_bool_stmts (vec_info *vinfo, hash_set &bool_stmt_set, bool_stmts.quick_push (*i); bool_stmts.qsort (sort_after_uid); =20 + gimple *last_stmt =3D NULL; + /* Now process them in that order, producing pattern stmts. */ hash_map defs; - for (unsigned i =3D 0; i < bool_stmts.length (); ++i) - adjust_bool_pattern (vinfo, gimple_assign_lhs (bool_stmts[i]), - out_type, stmt_info, defs); + for (auto bool_stmt : bool_stmts) + adjust_bool_pattern (vinfo, gimple_assign_lhs (bool_stmt), + out_type, stmt_info, defs, last_stmt, type_only); =20 /* Pop the last pattern seq stmt and install it as pattern root for STMT= . */ - gimple *pattern_stmt - =3D gimple_seq_last_stmt (STMT_VINFO_PATTERN_DEF_SEQ (stmt_info)); - return gimple_assign_lhs (pattern_stmt); + return gimple_assign_lhs (last_stmt); } =20 /* Return the proper type for converting bool VAR into @@ -5608,13 +5633,27 @@ vect_recog_bool_pattern (vec_info *vinfo, enum tree_code rhs_code; tree var, lhs, rhs, vectype; gimple *pattern_stmt; - - if (!is_gimple_assign (last_stmt)) + gcond* cond =3D NULL; + if (!is_gimple_assign (last_stmt) + && !(cond =3D dyn_cast (last_stmt))) return NULL; =20 - var =3D gimple_assign_rhs1 (last_stmt); - lhs =3D gimple_assign_lhs (last_stmt); - rhs_code =3D gimple_assign_rhs_code (last_stmt); + loop_vec_info loop_vinfo =3D dyn_cast (vinfo); + if (is_gimple_assign (last_stmt)) + { + var =3D gimple_assign_rhs1 (last_stmt); + lhs =3D gimple_assign_lhs (last_stmt); + rhs_code =3D gimple_assign_rhs_code (last_stmt); + } + else if (loop_vinfo && LOOP_VINFO_EARLY_BREAKS (loop_vinfo)) + { + /* If not multiple exits, and loop vectorization don't bother analyz= ing + the gcond as we don't support SLP today. */ + lhs =3D var =3D gimple_cond_lhs (last_stmt); + rhs_code =3D gimple_cond_code (last_stmt); + } + else + return NULL; =20 if (rhs_code =3D=3D VIEW_CONVERT_EXPR) var =3D TREE_OPERAND (var, 0); @@ -5632,7 +5671,7 @@ vect_recog_bool_pattern (vec_info *vinfo, return NULL; vectype =3D get_vectype_for_scalar_type (vinfo, TREE_TYPE (lhs)); =20 - if (check_bool_pattern (var, vinfo, bool_stmts)) + if (check_bool_pattern (var, vinfo, bool_stmts, false)) { rhs =3D adjust_bool_stmts (vinfo, bool_stmts, TREE_TYPE (lhs), stmt_vinfo); @@ -5680,7 +5719,7 @@ vect_recog_bool_pattern (vec_info *vinfo, =20 return pattern_stmt; } - else if (rhs_code =3D=3D COND_EXPR + else if ((rhs_code =3D=3D COND_EXPR || cond) && TREE_CODE (var) =3D=3D SSA_NAME) { vectype =3D get_vectype_for_scalar_type (vinfo, TREE_TYPE (lhs)); @@ -5700,18 +5739,31 @@ vect_recog_bool_pattern (vec_info *vinfo, if (get_vectype_for_scalar_type (vinfo, type) =3D=3D NULL_TREE) return NULL; =20 - if (check_bool_pattern (var, vinfo, bool_stmts)) - var =3D adjust_bool_stmts (vinfo, bool_stmts, type, stmt_vinfo); + if (check_bool_pattern (var, vinfo, bool_stmts, cond)) + var =3D adjust_bool_stmts (vinfo, bool_stmts, type, stmt_vinfo, cond); else if (integer_type_for_mask (var, vinfo)) return NULL; =20 - lhs =3D vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL); - pattern_stmt=20 - =3D gimple_build_assign (lhs, COND_EXPR, - build2 (NE_EXPR, boolean_type_node, - var, build_int_cst (TREE_TYPE (var), 0)), - gimple_assign_rhs2 (last_stmt), - gimple_assign_rhs3 (last_stmt)); + if (!cond) + { + lhs =3D vect_recog_temp_ssa_var (TREE_TYPE (lhs), NULL); + pattern_stmt + =3D gimple_build_assign (lhs, COND_EXPR, + build2 (NE_EXPR, boolean_type_node, var, + build_int_cst (TREE_TYPE (var), 0)), + gimple_assign_rhs2 (last_stmt), + gimple_assign_rhs3 (last_stmt)); + } + else + { + pattern_stmt + =3D gimple_build_cond (gimple_cond_code (cond), + gimple_cond_lhs (cond), gimple_cond_rhs (cond), + gimple_cond_true_label (cond), + gimple_cond_false_label (cond)); + vectype =3D get_vectype_for_scalar_type (vinfo, TREE_TYPE (var)); + vectype =3D truth_type_for (vectype); + } *type_out =3D vectype; vect_pattern_detected ("vect_recog_bool_pattern", last_stmt); =20 @@ -5725,7 +5777,7 @@ vect_recog_bool_pattern (vec_info *vinfo, if (!vectype || !VECTOR_MODE_P (TYPE_MODE (vectype))) return NULL; =20 - if (check_bool_pattern (var, vinfo, bool_stmts)) + if (check_bool_pattern (var, vinfo, bool_stmts, false)) rhs =3D adjust_bool_stmts (vinfo, bool_stmts, TREE_TYPE (vectype), stmt_vinfo); else diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index 582c5e678fad802d6e76300fe3c939b9f2978f17..e9116d184149826ba436b0f5627= 21c140d586c94 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -12489,7 +12489,7 @@ vectorizable_comparison_1 (vec_info *vinfo, tree ve= ctype, vec vec_oprnds0 =3D vNULL; vec vec_oprnds1 =3D vNULL; tree mask_type; - tree mask; + tree mask =3D NULL_TREE; =20 if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo) return false; @@ -12629,8 +12629,9 @@ vectorizable_comparison_1 (vec_info *vinfo, tree ve= ctype, /* Transform. */ =20 /* Handle def. */ - lhs =3D gimple_assign_lhs (STMT_VINFO_STMT (stmt_info)); - mask =3D vect_create_destination_var (lhs, mask_type); + lhs =3D gimple_get_lhs (STMT_VINFO_STMT (stmt_info)); + if (lhs) + mask =3D vect_create_destination_var (lhs, mask_type); =20 vect_get_vec_defs (vinfo, stmt_info, slp_node, ncopies, rhs1, &vec_oprnds0, vectype, @@ -12644,7 +12645,10 @@ vectorizable_comparison_1 (vec_info *vinfo, tree v= ectype, gimple *new_stmt; vec_rhs2 =3D vec_oprnds1[i]; =20 - new_temp =3D make_ssa_name (mask); + if (lhs) + new_temp =3D make_ssa_name (mask); + else + new_temp =3D make_temp_ssa_name (mask_type, NULL, "cmp"); if (bitop1 =3D=3D NOP_EXPR) { new_stmt =3D gimple_build_assign (new_temp, code, @@ -12723,6 +12727,184 @@ vectorizable_comparison (vec_info *vinfo, return true; } =20 +/* Check to see if the current early break given in STMT_INFO is valid for + vectorization. */ + +static bool +vectorizable_early_exit (vec_info *vinfo, stmt_vec_info stmt_info, + gimple_stmt_iterator *gsi, gimple **vec_stmt, + slp_tree slp_node, stmt_vector_for_cost *cost_vec) +{ + loop_vec_info loop_vinfo =3D dyn_cast (vinfo); + if (!loop_vinfo + || !is_a (STMT_VINFO_STMT (stmt_info))) + return false; + + if (STMT_VINFO_DEF_TYPE (stmt_info) !=3D vect_condition_def) + return false; + + if (!STMT_VINFO_RELEVANT_P (stmt_info)) + return false; + + auto code =3D gimple_cond_code (STMT_VINFO_STMT (stmt_info)); + tree vectype =3D STMT_VINFO_VECTYPE (stmt_info); + gcc_assert (vectype); + + tree vectype_op0 =3D NULL_TREE; + slp_tree slp_op0; + tree op0; + enum vect_def_type dt0; + if (!vect_is_simple_use (vinfo, stmt_info, slp_node, 0, &op0, &slp_op0, = &dt0, + &vectype_op0)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "use not simple.\n"); + return false; + } + + machine_mode mode =3D TYPE_MODE (vectype); + int ncopies; + + if (slp_node) + ncopies =3D 1; + else + ncopies =3D vect_get_num_copies (loop_vinfo, vectype); + + vec_loop_masks *masks =3D &LOOP_VINFO_MASKS (loop_vinfo); + bool masked_loop_p =3D LOOP_VINFO_FULLY_MASKED_P (loop_vinfo); + + /* Analyze only. */ + if (!vec_stmt) + { + if (direct_optab_handler (cbranch_optab, mode) =3D=3D CODE_FOR_nothi= ng) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "can't vectorize early exit because the " + "target doesn't support flag setting vector " + "comparisons.\n"); + return false; + } + + if (ncopies > 1 + && direct_optab_handler (ior_optab, mode) =3D=3D CODE_FOR_nothing) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "can't vectorize early exit because the " + "target does not support boolean vector OR for " + "type %T.\n", vectype); + return false; + } + + if (!vectorizable_comparison_1 (vinfo, vectype, stmt_info, code, gsi= , + vec_stmt, slp_node, cost_vec)) + return false; + + if (LOOP_VINFO_CAN_USE_PARTIAL_VECTORS_P (loop_vinfo)) + { + if (direct_internal_fn_supported_p (IFN_VCOND_MASK_LEN, vectype, + OPTIMIZE_FOR_SPEED)) + return false; + else + vect_record_loop_mask (loop_vinfo, masks, ncopies, vectype, NULL); + } + + + return true; + } + + /* Tranform. */ + + tree new_temp =3D NULL_TREE; + gimple *new_stmt =3D NULL; + + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, "transform early-exit.\n"); + + if (!vectorizable_comparison_1 (vinfo, vectype, stmt_info, code, gsi, + vec_stmt, slp_node, cost_vec)) + gcc_unreachable (); + + gimple *stmt =3D STMT_VINFO_STMT (stmt_info); + basic_block cond_bb =3D gimple_bb (stmt); + gimple_stmt_iterator cond_gsi =3D gsi_last_bb (cond_bb); + + auto_vec stmts; + + tree mask =3D NULL_TREE; + if (masked_loop_p) + mask =3D vect_get_loop_mask (loop_vinfo, gsi, masks, ncopies, vectype,= 0); + + if (slp_node) + stmts.safe_splice (SLP_TREE_VEC_DEFS (slp_node)); + else + { + auto vec_stmts =3D STMT_VINFO_VEC_STMTS (stmt_info); + stmts.reserve_exact (vec_stmts.length ()); + for (auto stmt : vec_stmts) + stmts.quick_push (gimple_assign_lhs (stmt)); + } + + /* Determine if we need to reduce the final value. */ + if (stmts.length () > 1) + { + /* We build the reductions in a way to maintain as much parallelism = as + possible. */ + auto_vec workset (stmts.length ()); + + /* Mask the statements as we queue them up. */ + if (masked_loop_p) + for (auto stmt : stmts) + workset.quick_push (prepare_vec_mask (loop_vinfo, TREE_TYPE (mask), + mask, stmt, &cond_gsi)); + else + workset.splice (stmts); + + while (workset.length () > 1) + { + new_temp =3D make_temp_ssa_name (vectype, NULL, "vexit_reduc"); + tree arg0 =3D workset.pop (); + tree arg1 =3D workset.pop (); + new_stmt =3D gimple_build_assign (new_temp, BIT_IOR_EXPR, arg0, arg1); + vect_finish_stmt_generation (loop_vinfo, stmt_info, new_stmt, + &cond_gsi); + workset.quick_insert (0, new_temp); + } + } + else + new_temp =3D stmts[0]; + + gcc_assert (new_temp); + + tree cond =3D new_temp; + /* If we have multiple statements after reduction we should check all th= e + lanes and treat it as a full vector. */ + if (masked_loop_p) + cond =3D prepare_vec_mask (loop_vinfo, TREE_TYPE (mask), mask, cond, + &cond_gsi); + + /* Now build the new conditional. Pattern gimple_conds get dropped duri= ng + codegen so we must replace the original insn. */ + stmt =3D STMT_VINFO_STMT (vect_orig_stmt (stmt_info)); + gcond *cond_stmt =3D as_a (stmt); + gimple_cond_set_condition (cond_stmt, NE_EXPR, cond, + build_zero_cst (vectype)); + update_stmt (stmt); + + if (slp_node) + SLP_TREE_VEC_DEFS (slp_node).truncate (0); + else + STMT_VINFO_VEC_STMTS (stmt_info).truncate (0); + + + if (!slp_node) + *vec_stmt =3D stmt; + + return true; +} + /* If SLP_NODE is nonnull, return true if vectorizable_live_operation can handle all live statements in the node. Otherwise return true if STMT_INFO is not live or if vectorizable_live_operation can handle i= t. @@ -12949,7 +13131,9 @@ vect_analyze_stmt (vec_info *vinfo, || vectorizable_lc_phi (as_a (vinfo), stmt_info, NULL, node) || vectorizable_recurr (as_a (vinfo), - stmt_info, NULL, node, cost_vec)); + stmt_info, NULL, node, cost_vec) + || vectorizable_early_exit (vinfo, stmt_info, NULL, NULL, node, + cost_vec)); else { if (bb_vinfo) @@ -12972,7 +13156,10 @@ vect_analyze_stmt (vec_info *vinfo, NULL, NULL, node, cost_vec) || vectorizable_comparison (vinfo, stmt_info, NULL, NULL, node, cost_vec) - || vectorizable_phi (vinfo, stmt_info, NULL, node, cost_vec)); + || vectorizable_phi (vinfo, stmt_info, NULL, node, cost_vec) + || vectorizable_early_exit (vinfo, stmt_info, NULL, NULL, node, + cost_vec)); + } =20 if (node) @@ -13131,6 +13318,12 @@ vect_transform_stmt (vec_info *vinfo, gcc_assert (done); break; =20 + case loop_exit_ctrl_vec_info_type: + done =3D vectorizable_early_exit (vinfo, stmt_info, gsi, &vec_stmt, + slp_node, NULL); + gcc_assert (done); + break; + default: if (!STMT_VINFO_LIVE_P (stmt_info)) { @@ -14321,10 +14514,19 @@ vect_get_vector_types_for_stmt (vec_info *vinfo, = stmt_vec_info stmt_info, } else { + gcond *cond =3D NULL; if (data_reference *dr =3D STMT_VINFO_DATA_REF (stmt_info)) scalar_type =3D TREE_TYPE (DR_REF (dr)); else if (gimple_call_internal_p (stmt, IFN_MASK_STORE)) scalar_type =3D TREE_TYPE (gimple_call_arg (stmt, 3)); + else if ((cond =3D dyn_cast (stmt))) + { + /* We can't convert the scalar type to boolean yet, since booleans have= a + single bit precision and we need the vector boolean to be a + representation of the integer mask. So set the correct integer type= and + convert to boolean vector once we have a vectype. */ + scalar_type =3D TREE_TYPE (gimple_cond_lhs (cond)); + } else scalar_type =3D TREE_TYPE (gimple_get_lhs (stmt)); =20 @@ -14339,12 +14541,18 @@ vect_get_vector_types_for_stmt (vec_info *vinfo, = stmt_vec_info stmt_info, "get vectype for scalar type: %T\n", scalar_type); } vectype =3D get_vectype_for_scalar_type (vinfo, scalar_type, group_s= ize); + if (!vectype) return opt_result::failure_at (stmt, "not vectorized:" " unsupported data-type %T\n", scalar_type); =20 + /* If we were a gcond, convert the resulting type to a vector boolea= n type now + that we have the correct integer mask type. */ + if (cond) + vectype =3D truth_type_for (vectype); + if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, "vectype: %T\n", vectype); } --_002_VI1PR08MB5325B28C5C00234F14DB2E1DFF8AAVI1PR08MB5325eurp_ Content-Type: application/octet-stream; name="rb17969 (1).patch" Content-Description: rb17969 (1).patch Content-Disposition: attachment; filename="rb17969 (1).patch"; size=20605; creation-date="Fri, 08 Dec 2023 08:54:54 GMT"; modification-date="Fri, 08 Dec 2023 08:58:18 GMT" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtcGF0dGVybnMuY2MgYi9nY2MvdHJlZS12ZWN0LXBh dHRlcm5zLmNjCmluZGV4IDdkZWJlN2YwNzMxNjczY2QxYmYyNWNkMzlkNTVlMjM5OTBhNzNkMGUu Ljg4NjVjZGU5ZjM0ODFhNDc0ZDMxODQ4YWUxMjUyMzU3NmQyOTc0NGQgMTAwNjQ0Ci0tLSBhL2dj Yy90cmVlLXZlY3QtcGF0dGVybnMuY2MKKysrIGIvZ2NjL3RyZWUtdmVjdC1wYXR0ZXJucy5jYwpA QCAtMTMyLDYgKzEzMiw3IEBAIHZlY3RfaW5pdF9wYXR0ZXJuX3N0bXQgKHZlY19pbmZvICp2aW5m bywgZ2ltcGxlICpwYXR0ZXJuX3N0bXQsCiAgIGlmICghU1RNVF9WSU5GT19WRUNUWVBFIChwYXR0 ZXJuX3N0bXRfaW5mbykpCiAgICAgewogICAgICAgZ2NjX2Fzc2VydCAoIXZlY3R5cGUKKwkJICB8 fCBpc19hIDxnY29uZCAqPiAocGF0dGVybl9zdG10KQogCQkgIHx8IChWRUNUT1JfQk9PTEVBTl9U WVBFX1AgKHZlY3R5cGUpCiAJCSAgICAgID09IHZlY3RfdXNlX21hc2tfdHlwZV9wIChvcmlnX3N0 bXRfaW5mbykpKTsKICAgICAgIFNUTVRfVklORk9fVkVDVFlQRSAocGF0dGVybl9zdG10X2luZm8p ID0gdmVjdHlwZTsKQEAgLTUyMTAsMTkgKzUyMTEsMjggQEAgdmVjdF9yZWNvZ19taXhlZF9zaXpl X2NvbmRfcGF0dGVybiAodmVjX2luZm8gKnZpbmZvLAogICAgdHJ1ZSBpZiBib29sIFZBUiBjYW4g YW5kIHNob3VsZCBiZSBvcHRpbWl6ZWQgdGhhdCB3YXkuICBBc3N1bWUgaXQgc2hvdWxkbid0CiAg ICBpbiBjYXNlIGl0J3MgYSByZXN1bHQgb2YgYSBjb21wYXJpc29uIHdoaWNoIGNhbiBiZSBkaXJl Y3RseSB2ZWN0b3JpemVkIGludG8KICAgIGEgdmVjdG9yIGNvbXBhcmlzb24uICBGaWxscyBpbiBT VE1UUyB3aXRoIGFsbCBzdG10cyB2aXNpdGVkIGR1cmluZyB0aGUKLSAgIHdhbGsuICAqLworICAg d2Fsay4gIGlmIEFOQUxZWkVfT05MWSB0aGVuIG9ubHkgYW5hbHl6ZSB0aGUgYm9vbGVhbnMgYnV0 IGRvIG5vdCBwZXJmb3JtIGFueQorICAgY29kZWdlbiBhc3NvY2lhdGVkIHdpdGggdGhlIGJvb2xl YW4gY29uZGl0aW9uLiAgKi8KIAogc3RhdGljIGJvb2wKLWNoZWNrX2Jvb2xfcGF0dGVybiAodHJl ZSB2YXIsIHZlY19pbmZvICp2aW5mbywgaGFzaF9zZXQ8Z2ltcGxlICo+ICZzdG10cykKK2NoZWNr X2Jvb2xfcGF0dGVybiAodHJlZSB2YXIsIHZlY19pbmZvICp2aW5mbywgaGFzaF9zZXQ8Z2ltcGxl ICo+ICZzdG10cywKKwkJICAgIGJvb2wgYW5hbHl6ZV9vbmx5KQogewogICB0cmVlIHJoczE7CiAg IGVudW0gdHJlZV9jb2RlIHJoc19jb2RlOworICBnYXNzaWduICpkZWZfc3RtdCA9IE5VTEw7CiAK ICAgc3RtdF92ZWNfaW5mbyBkZWZfc3RtdF9pbmZvID0gdmVjdF9nZXRfaW50ZXJuYWxfZGVmICh2 aW5mbywgdmFyKTsKLSAgaWYgKCFkZWZfc3RtdF9pbmZvKQorICBpZiAoIWRlZl9zdG10X2luZm8g JiYgIWFuYWx5emVfb25seSkKICAgICByZXR1cm4gZmFsc2U7CisgIGVsc2UgaWYgKCFkZWZfc3Rt dF9pbmZvKQorICAgIC8qIElmIHdlJ3JlIGEgb25seSBhbmFseXppbmcgd2Ugd29uJ3QgYmUgY29k ZWdlbi1pbmcgdGhlIHN0YXRlbWVudHMgYW5kIGFyZQorICAgICAgIG9ubHkgYWZ0ZXIgaWYgdGhl IHR5cGVzIG1hdGNoLiAgSW4gdGhhdCBjYXNlIHdlIGNhbiBhY2NlcHQgbG9vcCBpbnZhcmlhbnQK KyAgICAgICB2YWx1ZXMuICAqLworICAgIGRlZl9zdG10ID0gZHluX2Nhc3QgPGdhc3NpZ24gKj4g KFNTQV9OQU1FX0RFRl9TVE1UICh2YXIpKTsKKyAgZWxzZQorICAgIGRlZl9zdG10ID0gZHluX2Nh c3QgPGdhc3NpZ24gKj4gKGRlZl9zdG10X2luZm8tPnN0bXQpOwogCi0gIGdhc3NpZ24gKmRlZl9z dG10ID0gZHluX2Nhc3QgPGdhc3NpZ24gKj4gKGRlZl9zdG10X2luZm8tPnN0bXQpOwogICBpZiAo IWRlZl9zdG10KQogICAgIHJldHVybiBmYWxzZTsKIApAQCAtNTIzNCwyNyArNTI0NCwyOCBAQCBj aGVja19ib29sX3BhdHRlcm4gKHRyZWUgdmFyLCB2ZWNfaW5mbyAqdmluZm8sIGhhc2hfc2V0PGdp bXBsZSAqPiAmc3RtdHMpCiAgIHN3aXRjaCAocmhzX2NvZGUpCiAgICAgewogICAgIGNhc2UgU1NB X05BTUU6Ci0gICAgICBpZiAoISBjaGVja19ib29sX3BhdHRlcm4gKHJoczEsIHZpbmZvLCBzdG10 cykpCisgICAgICBpZiAoISBjaGVja19ib29sX3BhdHRlcm4gKHJoczEsIHZpbmZvLCBzdG10cywg YW5hbHl6ZV9vbmx5KSkKIAlyZXR1cm4gZmFsc2U7CiAgICAgICBicmVhazsKIAogICAgIENBU0Vf Q09OVkVSVDoKICAgICAgIGlmICghVkVDVF9TQ0FMQVJfQk9PTEVBTl9UWVBFX1AgKFRSRUVfVFlQ RSAocmhzMSkpKQogCXJldHVybiBmYWxzZTsKLSAgICAgIGlmICghIGNoZWNrX2Jvb2xfcGF0dGVy biAocmhzMSwgdmluZm8sIHN0bXRzKSkKKyAgICAgIGlmICghIGNoZWNrX2Jvb2xfcGF0dGVybiAo cmhzMSwgdmluZm8sIHN0bXRzLCBhbmFseXplX29ubHkpKQogCXJldHVybiBmYWxzZTsKICAgICAg IGJyZWFrOwogCiAgICAgY2FzZSBCSVRfTk9UX0VYUFI6Ci0gICAgICBpZiAoISBjaGVja19ib29s X3BhdHRlcm4gKHJoczEsIHZpbmZvLCBzdG10cykpCisgICAgICBpZiAoISBjaGVja19ib29sX3Bh dHRlcm4gKHJoczEsIHZpbmZvLCBzdG10cywgYW5hbHl6ZV9vbmx5KSkKIAlyZXR1cm4gZmFsc2U7 CiAgICAgICBicmVhazsKIAogICAgIGNhc2UgQklUX0FORF9FWFBSOgogICAgIGNhc2UgQklUX0lP Ul9FWFBSOgogICAgIGNhc2UgQklUX1hPUl9FWFBSOgotICAgICAgaWYgKCEgY2hlY2tfYm9vbF9w YXR0ZXJuIChyaHMxLCB2aW5mbywgc3RtdHMpCi0JICB8fCAhIGNoZWNrX2Jvb2xfcGF0dGVybiAo Z2ltcGxlX2Fzc2lnbl9yaHMyIChkZWZfc3RtdCksIHZpbmZvLCBzdG10cykpCisgICAgICBpZiAo ISBjaGVja19ib29sX3BhdHRlcm4gKHJoczEsIHZpbmZvLCBzdG10cywgYW5hbHl6ZV9vbmx5KQor CSAgfHwgISBjaGVja19ib29sX3BhdHRlcm4gKGdpbXBsZV9hc3NpZ25fcmhzMiAoZGVmX3N0bXQp LCB2aW5mbywgc3RtdHMsCisJCQkJICAgYW5hbHl6ZV9vbmx5KSkKIAlyZXR1cm4gZmFsc2U7CiAg ICAgICBicmVhazsKIApAQCAtNTI3NSw2ICs1Mjg2LDcgQEAgY2hlY2tfYm9vbF9wYXR0ZXJuICh0 cmVlIHZhciwgdmVjX2luZm8gKnZpbmZvLCBoYXNoX3NldDxnaW1wbGUgKj4gJnN0bXRzKQogCSAg dHJlZSBtYXNrX3R5cGUgPSBnZXRfbWFza190eXBlX2Zvcl9zY2FsYXJfdHlwZSAodmluZm8sCiAJ CQkJCQkJICBUUkVFX1RZUEUgKHJoczEpKTsKIAkgIGlmIChtYXNrX3R5cGUKKwkgICAgICAmJiAh YW5hbHl6ZV9vbmx5CiAJICAgICAgJiYgZXhwYW5kX3ZlY19jbXBfZXhwcl9wIChjb21wX3ZlY3R5 cGUsIG1hc2tfdHlwZSwgcmhzX2NvZGUpKQogCSAgICByZXR1cm4gZmFsc2U7CiAKQEAgLTUyODks NyArNTMwMSw4IEBAIGNoZWNrX2Jvb2xfcGF0dGVybiAodHJlZSB2YXIsIHZlY19pbmZvICp2aW5m bywgaGFzaF9zZXQ8Z2ltcGxlICo+ICZzdG10cykKIAkgICAgfQogCSAgZWxzZQogCSAgICB2ZWNp dHlwZSA9IGNvbXBfdmVjdHlwZTsKLQkgIGlmICghIGV4cGFuZF92ZWNfY29uZF9leHByX3AgKHZl Y2l0eXBlLCBjb21wX3ZlY3R5cGUsIHJoc19jb2RlKSkKKwkgIGlmICghYW5hbHl6ZV9vbmx5CisJ ICAgICAgJiYgIWV4cGFuZF92ZWNfY29uZF9leHByX3AgKHZlY2l0eXBlLCBjb21wX3ZlY3R5cGUs IHJoc19jb2RlKSkKIAkgICAgcmV0dXJuIGZhbHNlOwogCX0KICAgICAgIGVsc2UKQEAgLTUzMjQs MTEgKzUzMzcsMTMgQEAgYWRqdXN0X2Jvb2xfcGF0dGVybl9jYXN0ICh2ZWNfaW5mbyAqdmluZm8s CiAgICBWQVIgaXMgYW4gU1NBX05BTUUgdGhhdCBzaG91bGQgYmUgdHJhbnNmb3JtZWQgZnJvbSBi b29sIHRvIGEgd2lkZXIgaW50ZWdlcgogICAgdHlwZSwgT1VUX1RZUEUgaXMgdGhlIGRlc2lyZWQg ZmluYWwgaW50ZWdlciB0eXBlIG9mIHRoZSB3aG9sZSBwYXR0ZXJuLgogICAgU1RNVF9JTkZPIGlz IHRoZSBpbmZvIG9mIHRoZSBwYXR0ZXJuIHJvb3QgYW5kIGlzIHdoZXJlIHBhdHRlcm4gc3RtdHMg c2hvdWxkCi0gICBiZSBhc3NvY2lhdGVkIHdpdGguICBERUZTIGlzIGEgbWFwIG9mIHBhdHRlcm4g ZGVmcy4gICovCisgICBiZSBhc3NvY2lhdGVkIHdpdGguICBERUZTIGlzIGEgbWFwIG9mIHBhdHRl cm4gZGVmcy4gIElmIFRZUEVfT05MWSB0aGVuIGRvbid0CisgICBjcmVhdGUgbmV3IHBhdHRlcm4g c3RhdGVtZW50cyBhbmQgaW5zdGVhZCBvbmx5IGZpbGwgTEFTVF9TVE1UIGFuZCBERUZTLiAgKi8K IAogc3RhdGljIHZvaWQKIGFkanVzdF9ib29sX3BhdHRlcm4gKHZlY19pbmZvICp2aW5mbywgdHJl ZSB2YXIsIHRyZWUgb3V0X3R5cGUsCi0JCSAgICAgc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sIGhh c2hfbWFwIDx0cmVlLCB0cmVlPiAmZGVmcykKKwkJICAgICBzdG10X3ZlY19pbmZvIHN0bXRfaW5m bywgaGFzaF9tYXAgPHRyZWUsIHRyZWU+ICZkZWZzLAorCQkgICAgIGdpbXBsZSAqJmxhc3Rfc3Rt dCwgYm9vbCB0eXBlX29ubHkpCiB7CiAgIGdpbXBsZSAqc3RtdCA9IFNTQV9OQU1FX0RFRl9TVE1U ICh2YXIpOwogICBlbnVtIHRyZWVfY29kZSByaHNfY29kZSwgZGVmX3Joc19jb2RlOwpAQCAtNTQ5 MiwyOCArNTUwNywzOCBAQCBhZGp1c3RfYm9vbF9wYXR0ZXJuICh2ZWNfaW5mbyAqdmluZm8sIHRy ZWUgdmFyLCB0cmVlIG91dF90eXBlLAogICAgIH0KIAogICBnaW1wbGVfc2V0X2xvY2F0aW9uIChw YXR0ZXJuX3N0bXQsIGxvYyk7Ci0gIGFwcGVuZF9wYXR0ZXJuX2RlZl9zZXEgKHZpbmZvLCBzdG10 X2luZm8sIHBhdHRlcm5fc3RtdCwKLQkJCSAgZ2V0X3ZlY3R5cGVfZm9yX3NjYWxhcl90eXBlICh2 aW5mbywgaXR5cGUpKTsKKyAgaWYgKCF0eXBlX29ubHkpCisgICAgYXBwZW5kX3BhdHRlcm5fZGVm X3NlcSAodmluZm8sIHN0bXRfaW5mbywgcGF0dGVybl9zdG10LAorCQkJICAgIGdldF92ZWN0eXBl X2Zvcl9zY2FsYXJfdHlwZSAodmluZm8sIGl0eXBlKSk7CisgIGxhc3Rfc3RtdCA9IHBhdHRlcm5f c3RtdDsKICAgZGVmcy5wdXQgKHZhciwgZ2ltcGxlX2Fzc2lnbl9saHMgKHBhdHRlcm5fc3RtdCkp OwogfQogCi0vKiBDb21wYXJpc29uIGZ1bmN0aW9uIHRvIHFzb3J0IGEgdmVjdG9yIG9mIGdpbXBs ZSBzdG10cyBhZnRlciBVSUQuICAqLworLyogQ29tcGFyaXNvbiBmdW5jdGlvbiB0byBxc29ydCBh IHZlY3RvciBvZiBnaW1wbGUgc3RtdHMgYWZ0ZXIgQkIgYW5kIFVJRC4KKyAgIHRoZSBkZWYgb2Yg b25lIHN0YXRlbWVudCBjYW4gYmUgaW4gYW4gZWFybGllciBibG9jayB0aGFuIHRoZSB1c2UsIHNv IGlmCisgICB0aGUgQkIgYXJlIGRpZmZlcmVudCwgZmlyc3QgY29tcGFyZSBieSBCQi4gICovCiAK IHN0YXRpYyBpbnQKIHNvcnRfYWZ0ZXJfdWlkIChjb25zdCB2b2lkICpwMSwgY29uc3Qgdm9pZCAq cDIpCiB7CiAgIGNvbnN0IGdpbXBsZSAqc3RtdDEgPSAqKGNvbnN0IGdpbXBsZSAqIGNvbnN0ICop cDE7CiAgIGNvbnN0IGdpbXBsZSAqc3RtdDIgPSAqKGNvbnN0IGdpbXBsZSAqIGNvbnN0ICopcDI7 CisgIGlmIChnaW1wbGVfYmIgKHN0bXQxKS0+aW5kZXggIT0gZ2ltcGxlX2JiIChzdG10MiktPmlu ZGV4KQorICAgIHJldHVybiBnaW1wbGVfYmIgKHN0bXQxKS0+aW5kZXggLSBnaW1wbGVfYmIgKHN0 bXQyKS0+aW5kZXg7CisKICAgcmV0dXJuIGdpbXBsZV91aWQgKHN0bXQxKSAtIGdpbXBsZV91aWQg KHN0bXQyKTsKIH0KIAogLyogQ3JlYXRlIHBhdHRlcm4gc3RtdHMgZm9yIGFsbCBzdG10cyBwYXJ0 aWNpcGF0aW5nIGluIHRoZSBib29sIHBhdHRlcm4KICAgIHNwZWNpZmllZCBieSBCT09MX1NUTVRf U0VUIGFuZCBpdHMgcm9vdCBTVE1UX0lORk8gd2l0aCB0aGUgZGVzaXJlZCB0eXBlCi0gICBPVVRf VFlQRS4gIFJldHVybiB0aGUgZGVmIG9mIHRoZSBwYXR0ZXJuIHJvb3QuICAqLworICAgT1VUX1RZ UEUuICBSZXR1cm4gdGhlIGRlZiBvZiB0aGUgcGF0dGVybiByb290LiAgSWYgVFlQRV9PTkxZIHRo ZSBuZXcKKyAgIHN0YXRlbWVudHMgYXJlIG5vdCBlbWl0dGVkIGFzIHBhdHRlcm4gc3RhdGVtZW50 cyBhbmQgdGhlIHRyZWUgcmV0dXJuZWQgaXMKKyAgIG9ubHkgdXNlZnVsIGZvciB0eXBlIHF1ZXJp ZXMuICAqLwogCiBzdGF0aWMgdHJlZQogYWRqdXN0X2Jvb2xfc3RtdHMgKHZlY19pbmZvICp2aW5m bywgaGFzaF9zZXQgPGdpbXBsZSAqPiAmYm9vbF9zdG10X3NldCwKLQkJICAgdHJlZSBvdXRfdHlw ZSwgc3RtdF92ZWNfaW5mbyBzdG10X2luZm8pCisJCSAgIHRyZWUgb3V0X3R5cGUsIHN0bXRfdmVj X2luZm8gc3RtdF9pbmZvLAorCQkgICBib29sIHR5cGVfb25seSA9IGZhbHNlKQogewogICAvKiBH YXRoZXIgb3JpZ2luYWwgc3RtdHMgaW4gdGhlIGJvb2wgcGF0dGVybiBpbiB0aGVpciBvcmRlciBv ZiBhcHBlYXJhbmNlCiAgICAgIGluIHRoZSBJTC4gICovCkBAIC01NTIzLDE2ICs1NTQ4LDE2IEBA IGFkanVzdF9ib29sX3N0bXRzICh2ZWNfaW5mbyAqdmluZm8sIGhhc2hfc2V0IDxnaW1wbGUgKj4g JmJvb2xfc3RtdF9zZXQsCiAgICAgYm9vbF9zdG10cy5xdWlja19wdXNoICgqaSk7CiAgIGJvb2xf c3RtdHMucXNvcnQgKHNvcnRfYWZ0ZXJfdWlkKTsKIAorICBnaW1wbGUgKmxhc3Rfc3RtdCA9IE5V TEw7CisKICAgLyogTm93IHByb2Nlc3MgdGhlbSBpbiB0aGF0IG9yZGVyLCBwcm9kdWNpbmcgcGF0 dGVybiBzdG10cy4gICovCiAgIGhhc2hfbWFwIDx0cmVlLCB0cmVlPiBkZWZzOwotICBmb3IgKHVu c2lnbmVkIGkgPSAwOyBpIDwgYm9vbF9zdG10cy5sZW5ndGggKCk7ICsraSkKLSAgICBhZGp1c3Rf Ym9vbF9wYXR0ZXJuICh2aW5mbywgZ2ltcGxlX2Fzc2lnbl9saHMgKGJvb2xfc3RtdHNbaV0pLAot CQkJIG91dF90eXBlLCBzdG10X2luZm8sIGRlZnMpOworICBmb3IgKGF1dG8gYm9vbF9zdG10IDog Ym9vbF9zdG10cykKKyAgICBhZGp1c3RfYm9vbF9wYXR0ZXJuICh2aW5mbywgZ2ltcGxlX2Fzc2ln bl9saHMgKGJvb2xfc3RtdCksCisJCQkgb3V0X3R5cGUsIHN0bXRfaW5mbywgZGVmcywgbGFzdF9z dG10LCB0eXBlX29ubHkpOwogCiAgIC8qIFBvcCB0aGUgbGFzdCBwYXR0ZXJuIHNlcSBzdG10IGFu ZCBpbnN0YWxsIGl0IGFzIHBhdHRlcm4gcm9vdCBmb3IgU1RNVC4gICovCi0gIGdpbXBsZSAqcGF0 dGVybl9zdG10Ci0gICAgPSBnaW1wbGVfc2VxX2xhc3Rfc3RtdCAoU1RNVF9WSU5GT19QQVRURVJO X0RFRl9TRVEgKHN0bXRfaW5mbykpOwotICByZXR1cm4gZ2ltcGxlX2Fzc2lnbl9saHMgKHBhdHRl cm5fc3RtdCk7CisgIHJldHVybiBnaW1wbGVfYXNzaWduX2xocyAobGFzdF9zdG10KTsKIH0KIAog LyogUmV0dXJuIHRoZSBwcm9wZXIgdHlwZSBmb3IgY29udmVydGluZyBib29sIFZBUiBpbnRvCkBA IC01NjA4LDEzICs1NjMzLDI3IEBAIHZlY3RfcmVjb2dfYm9vbF9wYXR0ZXJuICh2ZWNfaW5mbyAq dmluZm8sCiAgIGVudW0gdHJlZV9jb2RlIHJoc19jb2RlOwogICB0cmVlIHZhciwgbGhzLCByaHMs IHZlY3R5cGU7CiAgIGdpbXBsZSAqcGF0dGVybl9zdG10OwotCi0gIGlmICghaXNfZ2ltcGxlX2Fz c2lnbiAobGFzdF9zdG10KSkKKyAgZ2NvbmQqIGNvbmQgPSBOVUxMOworICBpZiAoIWlzX2dpbXBs ZV9hc3NpZ24gKGxhc3Rfc3RtdCkKKyAgICAgICYmICEoY29uZCA9IGR5bl9jYXN0IDxnY29uZCAq PiAobGFzdF9zdG10KSkpCiAgICAgcmV0dXJuIE5VTEw7CiAKLSAgdmFyID0gZ2ltcGxlX2Fzc2ln bl9yaHMxIChsYXN0X3N0bXQpOwotICBsaHMgPSBnaW1wbGVfYXNzaWduX2xocyAobGFzdF9zdG10 KTsKLSAgcmhzX2NvZGUgPSBnaW1wbGVfYXNzaWduX3Joc19jb2RlIChsYXN0X3N0bXQpOworICBs b29wX3ZlY19pbmZvIGxvb3BfdmluZm8gPSBkeW5fY2FzdCA8bG9vcF92ZWNfaW5mbz4gKHZpbmZv KTsKKyAgaWYgKGlzX2dpbXBsZV9hc3NpZ24gKGxhc3Rfc3RtdCkpCisgICAgeworICAgICAgdmFy ID0gZ2ltcGxlX2Fzc2lnbl9yaHMxIChsYXN0X3N0bXQpOworICAgICAgbGhzID0gZ2ltcGxlX2Fz c2lnbl9saHMgKGxhc3Rfc3RtdCk7CisgICAgICByaHNfY29kZSA9IGdpbXBsZV9hc3NpZ25fcmhz X2NvZGUgKGxhc3Rfc3RtdCk7CisgICAgfQorICBlbHNlIGlmIChsb29wX3ZpbmZvICYmIExPT1Bf VklORk9fRUFSTFlfQlJFQUtTIChsb29wX3ZpbmZvKSkKKyAgICB7CisgICAgICAvKiBJZiBub3Qg bXVsdGlwbGUgZXhpdHMsIGFuZCBsb29wIHZlY3Rvcml6YXRpb24gZG9uJ3QgYm90aGVyIGFuYWx5 emluZworCSB0aGUgZ2NvbmQgYXMgd2UgZG9uJ3Qgc3VwcG9ydCBTTFAgdG9kYXkuICAqLworICAg ICAgbGhzID0gdmFyID0gZ2ltcGxlX2NvbmRfbGhzIChsYXN0X3N0bXQpOworICAgICAgcmhzX2Nv ZGUgPSBnaW1wbGVfY29uZF9jb2RlIChsYXN0X3N0bXQpOworICAgIH0KKyAgZWxzZQorICAgIHJl dHVybiBOVUxMOwogCiAgIGlmIChyaHNfY29kZSA9PSBWSUVXX0NPTlZFUlRfRVhQUikKICAgICB2 YXIgPSBUUkVFX09QRVJBTkQgKHZhciwgMCk7CkBAIC01NjMyLDcgKzU2NzEsNyBAQCB2ZWN0X3Jl Y29nX2Jvb2xfcGF0dGVybiAodmVjX2luZm8gKnZpbmZvLAogCXJldHVybiBOVUxMOwogICAgICAg dmVjdHlwZSA9IGdldF92ZWN0eXBlX2Zvcl9zY2FsYXJfdHlwZSAodmluZm8sIFRSRUVfVFlQRSAo bGhzKSk7CiAKLSAgICAgIGlmIChjaGVja19ib29sX3BhdHRlcm4gKHZhciwgdmluZm8sIGJvb2xf c3RtdHMpKQorICAgICAgaWYgKGNoZWNrX2Jvb2xfcGF0dGVybiAodmFyLCB2aW5mbywgYm9vbF9z dG10cywgZmFsc2UpKQogCXsKIAkgIHJocyA9IGFkanVzdF9ib29sX3N0bXRzICh2aW5mbywgYm9v bF9zdG10cywKIAkJCQkgICBUUkVFX1RZUEUgKGxocyksIHN0bXRfdmluZm8pOwpAQCAtNTY4MCw3 ICs1NzE5LDcgQEAgdmVjdF9yZWNvZ19ib29sX3BhdHRlcm4gKHZlY19pbmZvICp2aW5mbywKIAog ICAgICAgcmV0dXJuIHBhdHRlcm5fc3RtdDsKICAgICB9Ci0gIGVsc2UgaWYgKHJoc19jb2RlID09 IENPTkRfRVhQUgorICBlbHNlIGlmICgocmhzX2NvZGUgPT0gQ09ORF9FWFBSIHx8IGNvbmQpCiAJ ICAgJiYgVFJFRV9DT0RFICh2YXIpID09IFNTQV9OQU1FKQogICAgIHsKICAgICAgIHZlY3R5cGUg PSBnZXRfdmVjdHlwZV9mb3Jfc2NhbGFyX3R5cGUgKHZpbmZvLCBUUkVFX1RZUEUgKGxocykpOwpA QCAtNTcwMCwxOCArNTczOSwzMSBAQCB2ZWN0X3JlY29nX2Jvb2xfcGF0dGVybiAodmVjX2luZm8g KnZpbmZvLAogICAgICAgaWYgKGdldF92ZWN0eXBlX2Zvcl9zY2FsYXJfdHlwZSAodmluZm8sIHR5 cGUpID09IE5VTExfVFJFRSkKIAlyZXR1cm4gTlVMTDsKIAotICAgICAgaWYgKGNoZWNrX2Jvb2xf cGF0dGVybiAodmFyLCB2aW5mbywgYm9vbF9zdG10cykpCi0JdmFyID0gYWRqdXN0X2Jvb2xfc3Rt dHMgKHZpbmZvLCBib29sX3N0bXRzLCB0eXBlLCBzdG10X3ZpbmZvKTsKKyAgICAgIGlmIChjaGVj a19ib29sX3BhdHRlcm4gKHZhciwgdmluZm8sIGJvb2xfc3RtdHMsIGNvbmQpKQorCXZhciA9IGFk anVzdF9ib29sX3N0bXRzICh2aW5mbywgYm9vbF9zdG10cywgdHlwZSwgc3RtdF92aW5mbywgY29u ZCk7CiAgICAgICBlbHNlIGlmIChpbnRlZ2VyX3R5cGVfZm9yX21hc2sgKHZhciwgdmluZm8pKQog CXJldHVybiBOVUxMOwogCi0gICAgICBsaHMgPSB2ZWN0X3JlY29nX3RlbXBfc3NhX3ZhciAoVFJF RV9UWVBFIChsaHMpLCBOVUxMKTsKLSAgICAgIHBhdHRlcm5fc3RtdCAKLQk9IGdpbXBsZV9idWls ZF9hc3NpZ24gKGxocywgQ09ORF9FWFBSLAotCQkJICAgICAgIGJ1aWxkMiAoTkVfRVhQUiwgYm9v bGVhbl90eXBlX25vZGUsCi0JCQkJICAgICAgIHZhciwgYnVpbGRfaW50X2NzdCAoVFJFRV9UWVBF ICh2YXIpLCAwKSksCi0JCQkgICAgICAgZ2ltcGxlX2Fzc2lnbl9yaHMyIChsYXN0X3N0bXQpLAot CQkJICAgICAgIGdpbXBsZV9hc3NpZ25fcmhzMyAobGFzdF9zdG10KSk7CisgICAgICBpZiAoIWNv bmQpCisJeworCSAgbGhzID0gdmVjdF9yZWNvZ190ZW1wX3NzYV92YXIgKFRSRUVfVFlQRSAobGhz KSwgTlVMTCk7CisJICBwYXR0ZXJuX3N0bXQKKwkgICAgPSBnaW1wbGVfYnVpbGRfYXNzaWduIChs aHMsIENPTkRfRVhQUiwKKwkJCQkgICBidWlsZDIgKE5FX0VYUFIsIGJvb2xlYW5fdHlwZV9ub2Rl LCB2YXIsCisJCQkJCSAgIGJ1aWxkX2ludF9jc3QgKFRSRUVfVFlQRSAodmFyKSwgMCkpLAorCQkJ CSAgIGdpbXBsZV9hc3NpZ25fcmhzMiAobGFzdF9zdG10KSwKKwkJCQkgICBnaW1wbGVfYXNzaWdu X3JoczMgKGxhc3Rfc3RtdCkpOworCX0KKyAgICAgIGVsc2UKKwl7CisJICBwYXR0ZXJuX3N0bXQK KwkgICAgPSBnaW1wbGVfYnVpbGRfY29uZCAoZ2ltcGxlX2NvbmRfY29kZSAoY29uZCksCisJCQkJ IGdpbXBsZV9jb25kX2xocyAoY29uZCksIGdpbXBsZV9jb25kX3JocyAoY29uZCksCisJCQkJIGdp bXBsZV9jb25kX3RydWVfbGFiZWwgKGNvbmQpLAorCQkJCSBnaW1wbGVfY29uZF9mYWxzZV9sYWJl bCAoY29uZCkpOworCSAgdmVjdHlwZSA9IGdldF92ZWN0eXBlX2Zvcl9zY2FsYXJfdHlwZSAodmlu Zm8sIFRSRUVfVFlQRSAodmFyKSk7CisJICB2ZWN0eXBlID0gdHJ1dGhfdHlwZV9mb3IgKHZlY3R5 cGUpOworCX0KICAgICAgICp0eXBlX291dCA9IHZlY3R5cGU7CiAgICAgICB2ZWN0X3BhdHRlcm5f ZGV0ZWN0ZWQgKCJ2ZWN0X3JlY29nX2Jvb2xfcGF0dGVybiIsIGxhc3Rfc3RtdCk7CiAKQEAgLTU3 MjUsNyArNTc3Nyw3IEBAIHZlY3RfcmVjb2dfYm9vbF9wYXR0ZXJuICh2ZWNfaW5mbyAqdmluZm8s CiAgICAgICBpZiAoIXZlY3R5cGUgfHwgIVZFQ1RPUl9NT0RFX1AgKFRZUEVfTU9ERSAodmVjdHlw ZSkpKQogCXJldHVybiBOVUxMOwogCi0gICAgICBpZiAoY2hlY2tfYm9vbF9wYXR0ZXJuICh2YXIs IHZpbmZvLCBib29sX3N0bXRzKSkKKyAgICAgIGlmIChjaGVja19ib29sX3BhdHRlcm4gKHZhciwg dmluZm8sIGJvb2xfc3RtdHMsIGZhbHNlKSkKIAlyaHMgPSBhZGp1c3RfYm9vbF9zdG10cyAodmlu Zm8sIGJvb2xfc3RtdHMsCiAJCQkJIFRSRUVfVFlQRSAodmVjdHlwZSksIHN0bXRfdmluZm8pOwog ICAgICAgZWxzZQpkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUtdmVjdC1zdG10cy5jYyBiL2djYy90cmVl LXZlY3Qtc3RtdHMuY2MKaW5kZXggNTgyYzVlNjc4ZmFkODAyZDZlNzYzMDBmZTNjOTM5YjlmMjk3 OGYxNy4uZTkxMTZkMTg0MTQ5ODI2YmE0MzZiMGY1NjI3MjFjMTQwZDU4NmM5NCAxMDA2NDQKLS0t IGEvZ2NjL3RyZWUtdmVjdC1zdG10cy5jYworKysgYi9nY2MvdHJlZS12ZWN0LXN0bXRzLmNjCkBA IC0xMjQ4OSw3ICsxMjQ4OSw3IEBAIHZlY3Rvcml6YWJsZV9jb21wYXJpc29uXzEgKHZlY19pbmZv ICp2aW5mbywgdHJlZSB2ZWN0eXBlLAogICB2ZWM8dHJlZT4gdmVjX29wcm5kczAgPSB2TlVMTDsK ICAgdmVjPHRyZWU+IHZlY19vcHJuZHMxID0gdk5VTEw7CiAgIHRyZWUgbWFza190eXBlOwotICB0 cmVlIG1hc2s7CisgIHRyZWUgbWFzayA9IE5VTExfVFJFRTsKIAogICBpZiAoIVNUTVRfVklORk9f UkVMRVZBTlRfUCAoc3RtdF9pbmZvKSAmJiAhYmJfdmluZm8pCiAgICAgcmV0dXJuIGZhbHNlOwpA QCAtMTI2MjksOCArMTI2MjksOSBAQCB2ZWN0b3JpemFibGVfY29tcGFyaXNvbl8xICh2ZWNfaW5m byAqdmluZm8sIHRyZWUgdmVjdHlwZSwKICAgLyogVHJhbnNmb3JtLiAgKi8KIAogICAvKiBIYW5k bGUgZGVmLiAgKi8KLSAgbGhzID0gZ2ltcGxlX2Fzc2lnbl9saHMgKFNUTVRfVklORk9fU1RNVCAo c3RtdF9pbmZvKSk7Ci0gIG1hc2sgPSB2ZWN0X2NyZWF0ZV9kZXN0aW5hdGlvbl92YXIgKGxocywg bWFza190eXBlKTsKKyAgbGhzID0gZ2ltcGxlX2dldF9saHMgKFNUTVRfVklORk9fU1RNVCAoc3Rt dF9pbmZvKSk7CisgIGlmIChsaHMpCisgICAgbWFzayA9IHZlY3RfY3JlYXRlX2Rlc3RpbmF0aW9u X3ZhciAobGhzLCBtYXNrX3R5cGUpOwogCiAgIHZlY3RfZ2V0X3ZlY19kZWZzICh2aW5mbywgc3Rt dF9pbmZvLCBzbHBfbm9kZSwgbmNvcGllcywKIAkJICAgICByaHMxLCAmdmVjX29wcm5kczAsIHZl Y3R5cGUsCkBAIC0xMjY0NCw3ICsxMjY0NSwxMCBAQCB2ZWN0b3JpemFibGVfY29tcGFyaXNvbl8x ICh2ZWNfaW5mbyAqdmluZm8sIHRyZWUgdmVjdHlwZSwKICAgICAgIGdpbXBsZSAqbmV3X3N0bXQ7 CiAgICAgICB2ZWNfcmhzMiA9IHZlY19vcHJuZHMxW2ldOwogCi0gICAgICBuZXdfdGVtcCA9IG1h a2Vfc3NhX25hbWUgKG1hc2spOworICAgICAgaWYgKGxocykKKwluZXdfdGVtcCA9IG1ha2Vfc3Nh X25hbWUgKG1hc2spOworICAgICAgZWxzZQorCW5ld190ZW1wID0gbWFrZV90ZW1wX3NzYV9uYW1l IChtYXNrX3R5cGUsIE5VTEwsICJjbXAiKTsKICAgICAgIGlmIChiaXRvcDEgPT0gTk9QX0VYUFIp CiAJewogCSAgbmV3X3N0bXQgPSBnaW1wbGVfYnVpbGRfYXNzaWduIChuZXdfdGVtcCwgY29kZSwK QEAgLTEyNzIzLDYgKzEyNzI3LDE4NCBAQCB2ZWN0b3JpemFibGVfY29tcGFyaXNvbiAodmVjX2lu Zm8gKnZpbmZvLAogICByZXR1cm4gdHJ1ZTsKIH0KIAorLyogQ2hlY2sgdG8gc2VlIGlmIHRoZSBj dXJyZW50IGVhcmx5IGJyZWFrIGdpdmVuIGluIFNUTVRfSU5GTyBpcyB2YWxpZCBmb3IKKyAgIHZl Y3Rvcml6YXRpb24uICAqLworCitzdGF0aWMgYm9vbAordmVjdG9yaXphYmxlX2Vhcmx5X2V4aXQg KHZlY19pbmZvICp2aW5mbywgc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sCisJCQkgZ2ltcGxlX3N0 bXRfaXRlcmF0b3IgKmdzaSwgZ2ltcGxlICoqdmVjX3N0bXQsCisJCQkgc2xwX3RyZWUgc2xwX25v ZGUsIHN0bXRfdmVjdG9yX2Zvcl9jb3N0ICpjb3N0X3ZlYykKK3sKKyAgbG9vcF92ZWNfaW5mbyBs b29wX3ZpbmZvID0gZHluX2Nhc3QgPGxvb3BfdmVjX2luZm8+ICh2aW5mbyk7CisgIGlmICghbG9v cF92aW5mbworICAgICAgfHwgIWlzX2EgPGdjb25kICo+IChTVE1UX1ZJTkZPX1NUTVQgKHN0bXRf aW5mbykpKQorICAgIHJldHVybiBmYWxzZTsKKworICBpZiAoU1RNVF9WSU5GT19ERUZfVFlQRSAo c3RtdF9pbmZvKSAhPSB2ZWN0X2NvbmRpdGlvbl9kZWYpCisgICAgcmV0dXJuIGZhbHNlOworCisg IGlmICghU1RNVF9WSU5GT19SRUxFVkFOVF9QIChzdG10X2luZm8pKQorICAgIHJldHVybiBmYWxz ZTsKKworICBhdXRvIGNvZGUgPSBnaW1wbGVfY29uZF9jb2RlIChTVE1UX1ZJTkZPX1NUTVQgKHN0 bXRfaW5mbykpOworICB0cmVlIHZlY3R5cGUgPSBTVE1UX1ZJTkZPX1ZFQ1RZUEUgKHN0bXRfaW5m byk7CisgIGdjY19hc3NlcnQgKHZlY3R5cGUpOworCisgIHRyZWUgdmVjdHlwZV9vcDAgPSBOVUxM X1RSRUU7CisgIHNscF90cmVlIHNscF9vcDA7CisgIHRyZWUgb3AwOworICBlbnVtIHZlY3RfZGVm X3R5cGUgZHQwOworICBpZiAoIXZlY3RfaXNfc2ltcGxlX3VzZSAodmluZm8sIHN0bXRfaW5mbywg c2xwX25vZGUsIDAsICZvcDAsICZzbHBfb3AwLCAmZHQwLAorCQkJICAgJnZlY3R5cGVfb3AwKSkK KyAgICB7CisgICAgICBpZiAoZHVtcF9lbmFibGVkX3AgKCkpCisJICBkdW1wX3ByaW50Zl9sb2Mg KE1TR19NSVNTRURfT1BUSU1JWkFUSU9OLCB2ZWN0X2xvY2F0aW9uLAorCQkJICAgInVzZSBub3Qg c2ltcGxlLlxuIik7CisJcmV0dXJuIGZhbHNlOworICAgIH0KKworICBtYWNoaW5lX21vZGUgbW9k ZSA9IFRZUEVfTU9ERSAodmVjdHlwZSk7CisgIGludCBuY29waWVzOworCisgIGlmIChzbHBfbm9k ZSkKKyAgICBuY29waWVzID0gMTsKKyAgZWxzZQorICAgIG5jb3BpZXMgPSB2ZWN0X2dldF9udW1f Y29waWVzIChsb29wX3ZpbmZvLCB2ZWN0eXBlKTsKKworICB2ZWNfbG9vcF9tYXNrcyAqbWFza3Mg PSAmTE9PUF9WSU5GT19NQVNLUyAobG9vcF92aW5mbyk7CisgIGJvb2wgbWFza2VkX2xvb3BfcCA9 IExPT1BfVklORk9fRlVMTFlfTUFTS0VEX1AgKGxvb3BfdmluZm8pOworCisgIC8qIEFuYWx5emUg b25seS4gICovCisgIGlmICghdmVjX3N0bXQpCisgICAgeworICAgICAgaWYgKGRpcmVjdF9vcHRh Yl9oYW5kbGVyIChjYnJhbmNoX29wdGFiLCBtb2RlKSA9PSBDT0RFX0ZPUl9ub3RoaW5nKQorCXsK KwkgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkgICAgICBkdW1wX3ByaW50Zl9sb2MgKE1TR19N SVNTRURfT1BUSU1JWkFUSU9OLCB2ZWN0X2xvY2F0aW9uLAorCQkJICAgICAgICJjYW4ndCB2ZWN0 b3JpemUgZWFybHkgZXhpdCBiZWNhdXNlIHRoZSAiCisJCQkgICAgICAgInRhcmdldCBkb2Vzbid0 IHN1cHBvcnQgZmxhZyBzZXR0aW5nIHZlY3RvciAiCisJCQkgICAgICAgImNvbXBhcmlzb25zLlxu Iik7CisJICByZXR1cm4gZmFsc2U7CisJfQorCisgICAgICBpZiAobmNvcGllcyA+IDEKKwkgICYm IGRpcmVjdF9vcHRhYl9oYW5kbGVyIChpb3Jfb3B0YWIsIG1vZGUpID09IENPREVfRk9SX25vdGhp bmcpCisJeworCSAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorCSAgICAgIGR1bXBfcHJpbnRmX2xv YyAoTVNHX01JU1NFRF9PUFRJTUlaQVRJT04sIHZlY3RfbG9jYXRpb24sCisJCQkgICAgICAgImNh bid0IHZlY3Rvcml6ZSBlYXJseSBleGl0IGJlY2F1c2UgdGhlICIKKwkJCSAgICAgICAidGFyZ2V0 IGRvZXMgbm90IHN1cHBvcnQgYm9vbGVhbiB2ZWN0b3IgT1IgZm9yICIKKwkJCSAgICAgICAidHlw ZSAlVC5cbiIsIHZlY3R5cGUpOworCSAgcmV0dXJuIGZhbHNlOworCX0KKworICAgICAgaWYgKCF2 ZWN0b3JpemFibGVfY29tcGFyaXNvbl8xICh2aW5mbywgdmVjdHlwZSwgc3RtdF9pbmZvLCBjb2Rl LCBnc2ksCisJCQkJICAgICAgdmVjX3N0bXQsIHNscF9ub2RlLCBjb3N0X3ZlYykpCisJcmV0dXJu IGZhbHNlOworCisgICAgICBpZiAoTE9PUF9WSU5GT19DQU5fVVNFX1BBUlRJQUxfVkVDVE9SU19Q IChsb29wX3ZpbmZvKSkKKwl7CisJICBpZiAoZGlyZWN0X2ludGVybmFsX2ZuX3N1cHBvcnRlZF9w IChJRk5fVkNPTkRfTUFTS19MRU4sIHZlY3R5cGUsCisJCQkJCSAgICAgIE9QVElNSVpFX0ZPUl9T UEVFRCkpCisJICAgIHJldHVybiBmYWxzZTsKKwkgIGVsc2UKKwkgICAgdmVjdF9yZWNvcmRfbG9v cF9tYXNrIChsb29wX3ZpbmZvLCBtYXNrcywgbmNvcGllcywgdmVjdHlwZSwgTlVMTCk7CisJfQor CisKKyAgICAgIHJldHVybiB0cnVlOworICAgIH0KKworICAvKiBUcmFuZm9ybS4gICovCisKKyAg dHJlZSBuZXdfdGVtcCA9IE5VTExfVFJFRTsKKyAgZ2ltcGxlICpuZXdfc3RtdCA9IE5VTEw7CisK KyAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorICAgIGR1bXBfcHJpbnRmX2xvYyAoTVNHX05PVEUs IHZlY3RfbG9jYXRpb24sICJ0cmFuc2Zvcm0gZWFybHktZXhpdC5cbiIpOworCisgIGlmICghdmVj dG9yaXphYmxlX2NvbXBhcmlzb25fMSAodmluZm8sIHZlY3R5cGUsIHN0bXRfaW5mbywgY29kZSwg Z3NpLAorCQkJCSAgdmVjX3N0bXQsIHNscF9ub2RlLCBjb3N0X3ZlYykpCisgICAgZ2NjX3VucmVh Y2hhYmxlICgpOworCisgIGdpbXBsZSAqc3RtdCA9IFNUTVRfVklORk9fU1RNVCAoc3RtdF9pbmZv KTsKKyAgYmFzaWNfYmxvY2sgY29uZF9iYiA9IGdpbXBsZV9iYiAoc3RtdCk7CisgIGdpbXBsZV9z dG10X2l0ZXJhdG9yICBjb25kX2dzaSA9IGdzaV9sYXN0X2JiIChjb25kX2JiKTsKKworICBhdXRv X3ZlYzx0cmVlPiBzdG10czsKKworICB0cmVlIG1hc2sgPSBOVUxMX1RSRUU7CisgIGlmIChtYXNr ZWRfbG9vcF9wKQorICAgIG1hc2sgPSB2ZWN0X2dldF9sb29wX21hc2sgKGxvb3BfdmluZm8sIGdz aSwgbWFza3MsIG5jb3BpZXMsIHZlY3R5cGUsIDApOworCisgIGlmIChzbHBfbm9kZSkKKyAgICBz dG10cy5zYWZlX3NwbGljZSAoU0xQX1RSRUVfVkVDX0RFRlMgKHNscF9ub2RlKSk7CisgIGVsc2UK KyAgICB7CisgICAgICBhdXRvIHZlY19zdG10cyA9IFNUTVRfVklORk9fVkVDX1NUTVRTIChzdG10 X2luZm8pOworICAgICAgc3RtdHMucmVzZXJ2ZV9leGFjdCAodmVjX3N0bXRzLmxlbmd0aCAoKSk7 CisgICAgICBmb3IgKGF1dG8gc3RtdCA6IHZlY19zdG10cykKKwlzdG10cy5xdWlja19wdXNoIChn aW1wbGVfYXNzaWduX2xocyAoc3RtdCkpOworICAgIH0KKworICAvKiBEZXRlcm1pbmUgaWYgd2Ug bmVlZCB0byByZWR1Y2UgdGhlIGZpbmFsIHZhbHVlLiAgKi8KKyAgaWYgKHN0bXRzLmxlbmd0aCAo KSA+IDEpCisgICAgeworICAgICAgLyogV2UgYnVpbGQgdGhlIHJlZHVjdGlvbnMgaW4gYSB3YXkg dG8gbWFpbnRhaW4gYXMgbXVjaCBwYXJhbGxlbGlzbSBhcworCSBwb3NzaWJsZS4gICovCisgICAg ICBhdXRvX3ZlYzx0cmVlPiB3b3Jrc2V0IChzdG10cy5sZW5ndGggKCkpOworCisgICAgICAvKiBN YXNrIHRoZSBzdGF0ZW1lbnRzIGFzIHdlIHF1ZXVlIHRoZW0gdXAuICAqLworICAgICAgaWYgKG1h c2tlZF9sb29wX3ApCisJZm9yIChhdXRvIHN0bXQgOiBzdG10cykKKwkgIHdvcmtzZXQucXVpY2tf cHVzaCAocHJlcGFyZV92ZWNfbWFzayAobG9vcF92aW5mbywgVFJFRV9UWVBFIChtYXNrKSwKKwkJ CQkJCW1hc2ssIHN0bXQsICZjb25kX2dzaSkpOworICAgICAgZWxzZQorCXdvcmtzZXQuc3BsaWNl IChzdG10cyk7CisKKyAgICAgIHdoaWxlICh3b3Jrc2V0Lmxlbmd0aCAoKSA+IDEpCisJeworCSAg bmV3X3RlbXAgPSBtYWtlX3RlbXBfc3NhX25hbWUgKHZlY3R5cGUsIE5VTEwsICJ2ZXhpdF9yZWR1 YyIpOworCSAgdHJlZSBhcmcwID0gd29ya3NldC5wb3AgKCk7CisJICB0cmVlIGFyZzEgPSB3b3Jr c2V0LnBvcCAoKTsKKwkgIG5ld19zdG10ID0gZ2ltcGxlX2J1aWxkX2Fzc2lnbiAobmV3X3RlbXAs IEJJVF9JT1JfRVhQUiwgYXJnMCwgYXJnMSk7CisJICB2ZWN0X2ZpbmlzaF9zdG10X2dlbmVyYXRp b24gKGxvb3BfdmluZm8sIHN0bXRfaW5mbywgbmV3X3N0bXQsCisJCQkJICAgICAgICZjb25kX2dz aSk7CisJICB3b3Jrc2V0LnF1aWNrX2luc2VydCAoMCwgbmV3X3RlbXApOworCX0KKyAgICB9Cisg IGVsc2UKKyAgICBuZXdfdGVtcCA9IHN0bXRzWzBdOworCisgIGdjY19hc3NlcnQgKG5ld190ZW1w KTsKKworICB0cmVlIGNvbmQgPSBuZXdfdGVtcDsKKyAgLyogSWYgd2UgaGF2ZSBtdWx0aXBsZSBz dGF0ZW1lbnRzIGFmdGVyIHJlZHVjdGlvbiB3ZSBzaG91bGQgY2hlY2sgYWxsIHRoZQorICAgICBs YW5lcyBhbmQgdHJlYXQgaXQgYXMgYSBmdWxsIHZlY3Rvci4gICovCisgIGlmIChtYXNrZWRfbG9v cF9wKQorICAgIGNvbmQgPSBwcmVwYXJlX3ZlY19tYXNrIChsb29wX3ZpbmZvLCBUUkVFX1RZUEUg KG1hc2spLCBtYXNrLCBjb25kLAorCQkJICAgICAmY29uZF9nc2kpOworCisgIC8qIE5vdyBidWls ZCB0aGUgbmV3IGNvbmRpdGlvbmFsLiAgUGF0dGVybiBnaW1wbGVfY29uZHMgZ2V0IGRyb3BwZWQg ZHVyaW5nCisgICAgIGNvZGVnZW4gc28gd2UgbXVzdCByZXBsYWNlIHRoZSBvcmlnaW5hbCBpbnNu LiAgKi8KKyAgc3RtdCA9IFNUTVRfVklORk9fU1RNVCAodmVjdF9vcmlnX3N0bXQgKHN0bXRfaW5m bykpOworICBnY29uZCAqY29uZF9zdG10ID0gYXNfYSA8Z2NvbmQgKj4oc3RtdCk7CisgIGdpbXBs ZV9jb25kX3NldF9jb25kaXRpb24gKGNvbmRfc3RtdCwgTkVfRVhQUiwgY29uZCwKKwkJCSAgICAg YnVpbGRfemVyb19jc3QgKHZlY3R5cGUpKTsKKyAgdXBkYXRlX3N0bXQgKHN0bXQpOworCisgIGlm IChzbHBfbm9kZSkKKyAgICBTTFBfVFJFRV9WRUNfREVGUyAoc2xwX25vZGUpLnRydW5jYXRlICgw KTsKKyAgIGVsc2UKKyAgICBTVE1UX1ZJTkZPX1ZFQ19TVE1UUyAoc3RtdF9pbmZvKS50cnVuY2F0 ZSAoMCk7CisKKworICBpZiAoIXNscF9ub2RlKQorICAgICp2ZWNfc3RtdCA9IHN0bXQ7CisKKyAg cmV0dXJuIHRydWU7Cit9CisKIC8qIElmIFNMUF9OT0RFIGlzIG5vbm51bGwsIHJldHVybiB0cnVl IGlmIHZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbgogICAgY2FuIGhhbmRsZSBhbGwgbGl2ZSBz dGF0ZW1lbnRzIGluIHRoZSBub2RlLiAgT3RoZXJ3aXNlIHJldHVybiB0cnVlCiAgICBpZiBTVE1U X0lORk8gaXMgbm90IGxpdmUgb3IgaWYgdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uIGNhbiBo YW5kbGUgaXQuCkBAIC0xMjk0OSw3ICsxMzEzMSw5IEBAIHZlY3RfYW5hbHl6ZV9zdG10ICh2ZWNf aW5mbyAqdmluZm8sCiAJICB8fCB2ZWN0b3JpemFibGVfbGNfcGhpIChhc19hIDxsb29wX3ZlY19p bmZvPiAodmluZm8pLAogCQkJCSAgc3RtdF9pbmZvLCBOVUxMLCBub2RlKQogCSAgfHwgdmVjdG9y aXphYmxlX3JlY3VyciAoYXNfYSA8bG9vcF92ZWNfaW5mbz4gKHZpbmZvKSwKLQkJCQkgICBzdG10 X2luZm8sIE5VTEwsIG5vZGUsIGNvc3RfdmVjKSk7CisJCQkJICAgc3RtdF9pbmZvLCBOVUxMLCBu b2RlLCBjb3N0X3ZlYykKKwkgIHx8IHZlY3Rvcml6YWJsZV9lYXJseV9leGl0ICh2aW5mbywgc3Rt dF9pbmZvLCBOVUxMLCBOVUxMLCBub2RlLAorCQkJCSAgICAgIGNvc3RfdmVjKSk7CiAgIGVsc2UK ICAgICB7CiAgICAgICBpZiAoYmJfdmluZm8pCkBAIC0xMjk3Miw3ICsxMzE1NiwxMCBAQCB2ZWN0 X2FuYWx5emVfc3RtdCAodmVjX2luZm8gKnZpbmZvLAogCQkJCQkgTlVMTCwgTlVMTCwgbm9kZSwg Y29zdF92ZWMpCiAJICAgICAgfHwgdmVjdG9yaXphYmxlX2NvbXBhcmlzb24gKHZpbmZvLCBzdG10 X2luZm8sIE5VTEwsIE5VTEwsIG5vZGUsCiAJCQkJCSAgY29zdF92ZWMpCi0JICAgICAgfHwgdmVj dG9yaXphYmxlX3BoaSAodmluZm8sIHN0bXRfaW5mbywgTlVMTCwgbm9kZSwgY29zdF92ZWMpKTsK KwkgICAgICB8fCB2ZWN0b3JpemFibGVfcGhpICh2aW5mbywgc3RtdF9pbmZvLCBOVUxMLCBub2Rl LCBjb3N0X3ZlYykKKwkgICAgICB8fCB2ZWN0b3JpemFibGVfZWFybHlfZXhpdCAodmluZm8sIHN0 bXRfaW5mbywgTlVMTCwgTlVMTCwgbm9kZSwKKwkJCQkJICBjb3N0X3ZlYykpOworCiAgICAgfQog CiAgIGlmIChub2RlKQpAQCAtMTMxMzEsNiArMTMzMTgsMTIgQEAgdmVjdF90cmFuc2Zvcm1fc3Rt dCAodmVjX2luZm8gKnZpbmZvLAogICAgICAgZ2NjX2Fzc2VydCAoZG9uZSk7CiAgICAgICBicmVh azsKIAorICAgIGNhc2UgbG9vcF9leGl0X2N0cmxfdmVjX2luZm9fdHlwZToKKyAgICAgIGRvbmUg PSB2ZWN0b3JpemFibGVfZWFybHlfZXhpdCAodmluZm8sIHN0bXRfaW5mbywgZ3NpLCAmdmVjX3N0 bXQsCisJCQkJICAgICAgc2xwX25vZGUsIE5VTEwpOworICAgICAgZ2NjX2Fzc2VydCAoZG9uZSk7 CisgICAgICBicmVhazsKKwogICAgIGRlZmF1bHQ6CiAgICAgICBpZiAoIVNUTVRfVklORk9fTElW RV9QIChzdG10X2luZm8pKQogCXsKQEAgLTE0MzIxLDEwICsxNDUxNCwxOSBAQCB2ZWN0X2dldF92 ZWN0b3JfdHlwZXNfZm9yX3N0bXQgKHZlY19pbmZvICp2aW5mbywgc3RtdF92ZWNfaW5mbyBzdG10 X2luZm8sCiAgICAgfQogICBlbHNlCiAgICAgeworICAgICAgZ2NvbmQgKmNvbmQgPSBOVUxMOwog ICAgICAgaWYgKGRhdGFfcmVmZXJlbmNlICpkciA9IFNUTVRfVklORk9fREFUQV9SRUYgKHN0bXRf aW5mbykpCiAJc2NhbGFyX3R5cGUgPSBUUkVFX1RZUEUgKERSX1JFRiAoZHIpKTsKICAgICAgIGVs c2UgaWYgKGdpbXBsZV9jYWxsX2ludGVybmFsX3AgKHN0bXQsIElGTl9NQVNLX1NUT1JFKSkKIAlz Y2FsYXJfdHlwZSA9IFRSRUVfVFlQRSAoZ2ltcGxlX2NhbGxfYXJnIChzdG10LCAzKSk7CisgICAg ICBlbHNlIGlmICgoY29uZCA9IGR5bl9jYXN0IDxnY29uZCAqPiAoc3RtdCkpKQorCXsKKwkgIC8q IFdlIGNhbid0IGNvbnZlcnQgdGhlIHNjYWxhciB0eXBlIHRvIGJvb2xlYW4geWV0LCBzaW5jZSBi b29sZWFucyBoYXZlIGEKKwkgICAgIHNpbmdsZSBiaXQgcHJlY2lzaW9uIGFuZCB3ZSBuZWVkIHRo ZSB2ZWN0b3IgYm9vbGVhbiB0byBiZSBhCisJICAgICByZXByZXNlbnRhdGlvbiBvZiB0aGUgaW50 ZWdlciBtYXNrLiAgU28gc2V0IHRoZSBjb3JyZWN0IGludGVnZXIgdHlwZSBhbmQKKwkgICAgIGNv bnZlcnQgdG8gYm9vbGVhbiB2ZWN0b3Igb25jZSB3ZSBoYXZlIGEgdmVjdHlwZS4gICovCisJICBz Y2FsYXJfdHlwZSA9IFRSRUVfVFlQRSAoZ2ltcGxlX2NvbmRfbGhzIChjb25kKSk7CisJfQogICAg ICAgZWxzZQogCXNjYWxhcl90eXBlID0gVFJFRV9UWVBFIChnaW1wbGVfZ2V0X2xocyAoc3RtdCkp OwogCkBAIC0xNDMzOSwxMiArMTQ1NDEsMTggQEAgdmVjdF9nZXRfdmVjdG9yX3R5cGVzX2Zvcl9z dG10ICh2ZWNfaW5mbyAqdmluZm8sIHN0bXRfdmVjX2luZm8gc3RtdF9pbmZvLAogCQkJICAgICAi Z2V0IHZlY3R5cGUgZm9yIHNjYWxhciB0eXBlOiAlVFxuIiwgc2NhbGFyX3R5cGUpOwogCX0KICAg ICAgIHZlY3R5cGUgPSBnZXRfdmVjdHlwZV9mb3Jfc2NhbGFyX3R5cGUgKHZpbmZvLCBzY2FsYXJf dHlwZSwgZ3JvdXBfc2l6ZSk7CisKICAgICAgIGlmICghdmVjdHlwZSkKIAlyZXR1cm4gb3B0X3Jl c3VsdDo6ZmFpbHVyZV9hdCAoc3RtdCwKIAkJCQkgICAgICAgIm5vdCB2ZWN0b3JpemVkOiIKIAkJ CQkgICAgICAgIiB1bnN1cHBvcnRlZCBkYXRhLXR5cGUgJVRcbiIsCiAJCQkJICAgICAgIHNjYWxh cl90eXBlKTsKIAorICAgICAgLyogSWYgd2Ugd2VyZSBhIGdjb25kLCBjb252ZXJ0IHRoZSByZXN1 bHRpbmcgdHlwZSB0byBhIHZlY3RvciBib29sZWFuIHR5cGUgbm93CisJIHRoYXQgd2UgaGF2ZSB0 aGUgY29ycmVjdCBpbnRlZ2VyIG1hc2sgdHlwZS4gICovCisgICAgICBpZiAoY29uZCkKKwl2ZWN0 eXBlID0gdHJ1dGhfdHlwZV9mb3IgKHZlY3R5cGUpOworCiAgICAgICBpZiAoZHVtcF9lbmFibGVk X3AgKCkpCiAJZHVtcF9wcmludGZfbG9jIChNU0dfTk9URSwgdmVjdF9sb2NhdGlvbiwgInZlY3R5 cGU6ICVUXG4iLCB2ZWN0eXBlKTsKICAgICB9Cg== --_002_VI1PR08MB5325B28C5C00234F14DB2E1DFF8AAVI1PR08MB5325eurp_--