From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR03-AM7-obe.outbound.protection.outlook.com (mail-am7eur03on2058.outbound.protection.outlook.com [40.107.105.58]) by sourceware.org (Postfix) with ESMTPS id 6B1243858C2F for ; Wed, 13 Dec 2023 14:13:28 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 6B1243858C2F 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 6B1243858C2F Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=40.107.105.58 ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1702476812; cv=pass; b=axlgv+2wK4kbi+9fHl75wu7vN8IowkpfjYrby3EkyhU3IX5owHKP0h+p/azWhXWsnNCkl7JCMKq4CtaRLBPF2wohZlBRkpaW+ncvwtUx1Ms9/qOIhffoHBRN4X0M1zSbHy77kGKp5g6ga/rqGvC1FONn5B+VS1Adr98AWonlhFg= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1702476812; c=relaxed/simple; bh=LW+7HWi3PZq6B32VlslUZZ+ZExz+lfN1ZrOvZXg8pKE=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=GVO/ZvgukmuC68FbvjMl1gA9LiRFrnJ7kumUjil7klWoXMCvpgj6MDKtNkxQ4t01KO3PkzuIAje1DyPyt4nSi9bop3k6W7pVwnR0F9HkNUAVtacwN/CjKBnsfP6AzmC/A6KHKwliQDx76tV8LbEEfUfwvat8IOhJWsBY9EEvqfI= ARC-Authentication-Results: i=3; server2.sourceware.org ARC-Seal: i=2; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=pass; b=oWbrlHCig3tT/u+Vxr4BujhIfoX73f3xpJgfoYxqCUWXzxQq8IEf4bSISWjgVvj50F5Bd95EQWaUGU3mj7eM0mdWBj3McFAOCaZfhTnYZ8Gt6ajPRBLOGIGKstmeNzf5yrOp/DotFaXq+sTAQ+N2OSgBL29C2f2cJrPrCiFmrUUfxVYrxJls+OFVimPPXjdNJtGMHulQy7D450MJNKJ+454/FIuwNXuj3SSVWepyh0LTtEKDZfP/e1KiYTlYEV/xb8/B1SG28SWPJnAUVvmDLb/2P+5OfHgw+RFu/LlZdnVPt+jzjaDuC1KJwFZrr8PF3Qp0IJe+NSFwrhDQFkIdJQ== 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=nR6PEnc2SUa0sEpeeqUqSRHya/DMkEe+Ve+WTH6YVRg=; b=VFvA9crA2Q/I/T146F7qypVYiCKsIdgTDTaZmdKAO3kFhYt35UndIGt2SUtCbG6h1aP98X8DCBtL6kuFE5P2SA/u+WmJNTxMHxYTesbAyzG+68pfbeRlfO8DbbMuwEYM/U4x5Pcy0JI4KoCfXtW2DGPrJBn9cVD7tb3d3NuLGOtQCb8pY94uAlsx1UN/RXnrgX4w+IcnfzmWxaf2fuZvXxyLeLDUUfi3NrMGHK+PYcmBUWRQhK+a2GBLrvqOmuQVUohLXkEvFo07c7rNMqKCd/r+XnyTnyogOcq50rPbaZl/N22WmvtJNM6WldeeHRGlRYhOjNeNts0kZGmf/RTWrQ== 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=nR6PEnc2SUa0sEpeeqUqSRHya/DMkEe+Ve+WTH6YVRg=; b=onZM7c8cco3q397A8FJVSq/5w09Mvp0lZSPWt60Z+xvr1CsfJ6Ng1VLsGMsIrIikP/EULs6nauM3ejYV6E2kdrO7f1R0sdA6ZUxf3Vulwe5JQeiZnCyZyLyzalhq8ELV3J+ieosBqbt3Duwkba++znB+ZMfLZdZ5bCU6f26Z/1M= Received: from AM6PR08CA0047.eurprd08.prod.outlook.com (2603:10a6:20b:c0::35) by GV1PR08MB10730.eurprd08.prod.outlook.com (2603:10a6:150:162::17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7091.26; Wed, 13 Dec 2023 14:13:22 +0000 Received: from AMS1EPF0000004D.eurprd04.prod.outlook.com (2603:10a6:20b:c0:cafe::bc) by AM6PR08CA0047.outlook.office365.com (2603:10a6:20b:c0::35) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7068.36 via Frontend Transport; Wed, 13 Dec 2023 14:13:22 +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 AMS1EPF0000004D.mail.protection.outlook.com (10.167.16.138) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7091.26 via Frontend Transport; Wed, 13 Dec 2023 14:13:22 +0000 Received: ("Tessian outbound 5d213238733f:v228"); Wed, 13 Dec 2023 14:13:22 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: 594cb94a96e5284a X-CR-MTA-TID: 64aa7808 Received: from e72bb5c619cc.2 by 64aa7808-outbound-1.mta.getcheckrecipient.com id 12F44D32-F1BE-4834-A95E-4E418D8AF139.1; Wed, 13 Dec 2023 14:13:15 +0000 Received: from EUR02-VI1-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id e72bb5c619cc.2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Wed, 13 Dec 2023 14:13:15 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=Vrwxio30qGTeh5O3AQIWMpWzSKouNocwrBmnz03NfHSKrLyP7yTh9BxPnZdmW/v2I3veRy9wusKsWaox/zRMm+OgxDtu3vxdnON7Mq5+SAO010MBcfQRKGfmwebKViKlyEJEsiPinSL7E6qs9kdOv1pS7ZIhD+mRss1BetNL/0bxdhi4DBC/xLF+E6OovnmG0VnBG2x/1vGXXx5BX/paBntJ0zq98ykKG5lhtv4+YGPJqfGWtWcI3lWbBV0KRq/0ZhoJ1G8mDBskzgRDWlCem/4BK+RzgXpsb0VBEPDgqBM84llazK5AoCFLhmndysk758Ku40rn3t7FNIiBu5GJSg== 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=nR6PEnc2SUa0sEpeeqUqSRHya/DMkEe+Ve+WTH6YVRg=; b=NobAxJulw6cM8GXjzz7V0OdAGimYPnpBPEOJntHcO1npICa2tNz5S2LZbSq8QP4dSeMR+KsYsTuKhA6nTa9PVkT8vpgMvXh1jhy5DfrdYEDfqPcoXfEqsMbkyeGVBcHo0mZQtxD7vLlp6czOIWzu3seb5HshU/GgdLyoMD/L+pvjr0Ujr39Vypwp4SuWK02Iyy3yOU1RtCKDNJputbVyUaNpQgFydHWSKbQEr5LSc4pk59vpvIcu3o3CWrLXg8zRlP78IiPSTVzo0eneU2nXEQlcZWY21plWCnbU2mKbwMDdOvJ78V7AvDH0Gucxj59/L0oEN0GlsIdpBrMYyCWc6w== 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=nR6PEnc2SUa0sEpeeqUqSRHya/DMkEe+Ve+WTH6YVRg=; b=onZM7c8cco3q397A8FJVSq/5w09Mvp0lZSPWt60Z+xvr1CsfJ6Ng1VLsGMsIrIikP/EULs6nauM3ejYV6E2kdrO7f1R0sdA6ZUxf3Vulwe5JQeiZnCyZyLyzalhq8ELV3J+ieosBqbt3Duwkba++znB+ZMfLZdZ5bCU6f26Z/1M= Received: from VI1PR08MB5325.eurprd08.prod.outlook.com (2603:10a6:803:13e::17) by DB9PR08MB7628.eurprd08.prod.outlook.com (2603:10a6:10:30c::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7091.26; Wed, 13 Dec 2023 14:13:11 +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.7091.022; Wed, 13 Dec 2023 14:13:11 +0000 From: Tamar Christina To: Richard Biener , Richard Sandiford 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/lXCPbCO5tuwgAKOHoCACmF78IAAWBaAgAMYIGCAABrAgIAAAmcwgAA4uQCABEHGgIAAK7mAgADdJdCAAL6RgIAADe9igAAIcwCAAb5I4A== Date: Wed, 13 Dec 2023 14:13:11 +0000 Message-ID: References: <85570n66-1540-0r07-7q80-269p3o133585@fhfr.qr> <5r3p7378-q309-ooqo-7o76-q9r567ns1890@fhfr.qr> <3o102so4-34pp-3o01-o002-0q245oo10303@fhfr.qr> 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_|DB9PR08MB7628:EE_|AMS1EPF0000004D:EE_|GV1PR08MB10730:EE_ X-MS-Office365-Filtering-Correlation-Id: 6995be37-c5a9-41a4-5ab0-08dbfbe5aa3e 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: oUW2e8Kpa2+TiozCZkOC/6DNDC1p7E7FEuTzLPj4toZ4LjqgjoR0Eub71uNfWBu05NYYTUaVn9c16ru37wHDi97YPcb5MBV5kIEuAJoi49ysdE6gWtWO3ZBnj2FO+55Kf2Mgode06xyhtZBRkfXYbN7a0wFcdKPZDSId9b62/mCNm0AGGOzM40xBaHi8MKQowIziPNaJTY5OAy1q0MJ0x6qVUAKXhZMfS929Q3mfkQ0YRIQk4eD964AjPWo4H1khjdPjE8O+yI0NcwSIuc5UHvEEpMyQQgPphxZYALov7u8BVbAcihXbBoXVjl8kma8cdg1UqeCK5aZkTWSuwTFCxtZP9xc3s1LJYRkJuydbocTFjhHsNSuVzGeVcwokficWVF0/V8+NP3yH4vZlWezLk6ZhAbCJG4phLg+ymWc50wk+vlbXIJ0ZY1frERiUHNElShGzIwpkenPE2J57ZieZ3HxHv9UtPPUFm2WvXeW9ItP8v6q9Sx8/dw0O5w+zGZ0vELUv5x4vhJAyOz0yGcAlVfyQm+vVEseoBAFduD7vSo6jw8dvNAbYFt4H2C2/X2BZJDKkxBEdlKCZamW2+28cWH9F0+blnOm7Sl2VLgcG87YZfkBy2fRGcq03J/rFqvbwuGYF37Lwvzk4qLuWDPuYKA== 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)(136003)(39860400002)(376002)(366004)(346002)(396003)(230922051799003)(186009)(451199024)(64100799003)(1800799012)(26005)(9686003)(71200400001)(7696005)(6506007)(86362001)(122000001)(66476007)(66556008)(64756008)(66446008)(6636002)(76116006)(316002)(54906003)(52536014)(66946007)(110136005)(478600001)(55016003)(84970400001)(83380400001)(99936003)(8936002)(8676002)(4326008)(38100700002)(5660300002)(30864003)(2906002)(41300700001)(38070700009)(33656002)(559001)(579004);DIR:OUT;SFP:1101; Content-Type: multipart/mixed; boundary="_002_VI1PR08MB5325688E37E6A409E577E00EFF8DAVI1PR08MB5325eurp_" MIME-Version: 1.0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB9PR08MB7628 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: AMS1EPF0000004D.eurprd04.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: 17b9ec72-cffa-428b-535f-08dbfbe5a3be X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: WR58FzWM2Ymh2ZkIiYYP8kjtIEHoIWYwwQAkW4sP0ZKIDhkHdaqp2qsTmqAoi9QdCx46nidrnVPXYHN+TbxzJ2j03NHfzkcFF/rJq+wVRNAu5BYuMElRfj6dwDNTCY4MfZhCi60GtKQQPrBUajy4vH236kBHKNv6ch5coGCANAsQR6h/0H9YHDN3M1lMQ/uUKA38vPYgDX6g+tIUgswfYeP4v7xMI86WWzOn98V0w+6zV4mXi33ss4zXCGwedH/QOfmRsdyM1AC2LqgA8JmhHKsQYRVXJ/XmlIou4PnBF9TzXqXI0seZn++s42dzxUCbX7pLw3A3onKpEuGWTzuNQ4kXXVRRrT0S9GAWF62jGgKfqrQlAXj3ZTwoSUwt7/VDpO/Ct7vcNf0PeH8w2Dw1VdBs7Qmp7Hv04ByjrM4DaujPHzbdvJrhXffRge/tmaXpsJ8o0dWm8zUtv9mqoW0kkzNlS9qkIKiuLK5D/w0+PrP6JG/cfgdVvC2NBwztPInwXugUdo/OFdjWfPI0BRFE238Gb1QY3gpFyKnn6oWGJuX3QKewss3C7jlxBr3AUkzQAdyb6jBlCiLVB9gjRJ8GLireZvUSTNhBDnhEPiHq96cMEOgwNzD3moKH4eyXB/kM//qDvzeMEIJj3ldqQcMv5Z7slEf3XcTEgvkC8q1wThLbB0exhNz7nMVUoVBudGxMVXuQ/Icm+AM5WfDcDg6Y18aJh6wWUJkW1dpSp9Jzkqim5SgozVAhQsJu8WzxklCY1gMKV7JaLEwf8abi+bVeJA== 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)(376002)(39860400002)(136003)(396003)(346002)(230922051799003)(64100799003)(451199024)(82310400011)(1800799012)(186009)(46966006)(40470700004)(36840700001)(40460700003)(36860700001)(47076005)(336012)(81166007)(83380400001)(99936003)(356005)(82740400003)(86362001)(41300700001)(5660300002)(235185007)(4326008)(8676002)(8936002)(110136005)(70206006)(70586007)(6636002)(52536014)(316002)(9686003)(54906003)(26005)(107886003)(6506007)(478600001)(7696005)(2906002)(30864003)(33656002)(40480700001)(84970400001)(55016003);DIR:OUT;SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 13 Dec 2023 14:13:22.4727 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 6995be37-c5a9-41a4-5ab0-08dbfbe5aa3e 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: AMS1EPF0000004D.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: GV1PR08MB10730 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_VI1PR08MB5325688E37E6A409E577E00EFF8DAVI1PR08MB5325eurp_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable > > > else if (vect_use_mask_type_p (stmt_info)) > > > { > > > unsigned int precision =3D stmt_info->mask_precision; > > > scalar_type =3D build_nonstandard_integer_type (precision, 1); > > > vectype =3D get_mask_type_for_scalar_type (vinfo, scalar_type, > > > group_size); > > > if (!vectype) > > > return opt_result::failure_at (stmt, "not vectorized: unsuppo= rted" > > > " data-type %T\n", scalar_type= ); > > > > > > Richard, do you have any advice here? I suppose vect_determine_preci= sions > > > needs to handle the gcond case with bool !=3D 0 somehow and for the > > > extra mask producer we add here we have to emulate what it would have > > > done, right? > > > > How about handling gconds directly in vect_determine_mask_precision? > > In a sense it's not needed, since gconds are always roots, and so we > > could calculate their precision on the fly instead. But handling it in > > vect_determine_mask_precision feels like it should reduce the number > > of special cases. >=20 > Yeah, that sounds worth trying. >=20 > Richard. So here's a respin with this suggestion and the other issues fixed. Note that the testcases still need to be updated with the right stanzas. The patch is much smaller, I still have a small change to vect_get_vector_types_for_stmt in case we get there on a gcond where vect_recog_gcond_pattern couldn't apply due to the target missing an appropriate vectype. The change only gracefully rejects the gcond. Since patterns cannot apply to the same root twice I've had to also do the split of the condition out of the gcond in bitfield lowering. Bootstrapped Regtested on aarch64-none-linux-gnu, x86_64-pc-linux-gnu and n= o issues. Ok for master? Thanks, Tamar gcc/ChangeLog: * tree-vect-patterns.cc (vect_init_pattern_stmt): Support gcond (vect_recog_bitfield_ref_pattern): Update to split out bool. (vect_recog_gcond_pattern): New. (possible_vector_mask_operation_p): Support gcond. (vect_determine_mask_precision): Likewise. * tree-vect-stmts.cc (vectorizable_comparison_1): Support stmts without lhs. (vectorizable_early_exit): New. (vect_analyze_stmt, vect_transform_stmt): Use it. (vect_get_vector_types_for_stmt): Rejects gcond if not lowered by vect_recog_gcond_pattern. gcc/testsuite/ChangeLog: * gcc.dg/vect/vect-early-break_84.c: New test. * gcc.dg/vect/vect-early-break_85.c: New test. * gcc.dg/vect/vect-early-break_86.c: New test. * gcc.dg/vect/vect-early-break_87.c: New test. * gcc.dg/vect/vect-early-break_88.c: New test. --- inline copy of patch --- diff --git a/gcc/testsuite/gcc.dg/vect/vect-early-break_84.c b/gcc/testsuit= e/gcc.dg/vect/vect-early-break_84.c new file mode 100644 index 0000000000000000000000000000000000000000..0622339491d333b07c2ce895785= b5216713097a9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-early-break_84.c @@ -0,0 +1,39 @@ +/* { dg-require-effective-target vect_early_break } */ +/* { dg-require-effective-target vect_int } */ + +/* { dg-final { scan-tree-dump "LOOP VECTORIZED" "vect" } } */ + +#include + +#ifndef N +#define N 17 +#endif +bool vect_a[N] =3D { false, false, true, false, false, false, + false, false, false, false, false, false, + false, false, false, false, false }; +unsigned vect_b[N] =3D { 0 }; + +__attribute__ ((noinline, noipa)) +unsigned test4(bool x) +{ + unsigned ret =3D 0; + for (int i =3D 0; i < N; i++) + { + if (vect_a[i] =3D=3D x) + return 1; + vect_a[i] =3D x; + =20 + } + return ret; +} + +extern void abort (); + +int main () +{ + if (test4 (true) !=3D 1) + abort (); + + if (vect_b[2] !=3D 0 && vect_b[1] =3D=3D 0) + abort (); +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-early-break_85.c b/gcc/testsuit= e/gcc.dg/vect/vect-early-break_85.c new file mode 100644 index 0000000000000000000000000000000000000000..39b3d9bad8681a2d15d7fc7de86= bdd3ce0f0bd4e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-early-break_85.c @@ -0,0 +1,35 @@ +/* { dg-require-effective-target vect_early_break } */ +/* { dg-require-effective-target vect_int } */ + +/* { dg-final { scan-tree-dump "LOOP VECTORIZED" "vect" } } */ + +#ifndef N +#define N 5 +#endif +int vect_a[N] =3D { 5, 4, 8, 4, 6 }; +unsigned vect_b[N] =3D { 0 }; + +__attribute__ ((noinline, noipa)) +unsigned test4(int x) +{ + unsigned ret =3D 0; + for (int i =3D 0; i < N; i++) + { + if (vect_a[i] > x) + return 1; + vect_a[i] =3D x; + =20 + } + return ret; +} + +extern void abort (); + +int main () +{ + if (test4 (7) !=3D 1) + abort (); + + if (vect_b[2] !=3D 0 && vect_b[1] =3D=3D 0) + abort (); +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-early-break_86.c b/gcc/testsuit= e/gcc.dg/vect/vect-early-break_86.c new file mode 100644 index 0000000000000000000000000000000000000000..66eb570f4028bca4b631329d7af= 50c646d3c0cb3 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-early-break_86.c @@ -0,0 +1,21 @@ +/* { dg-additional-options "-std=3Dgnu89" } */ +/* { dg-require-effective-target vect_early_break } */ +/* { dg-require-effective-target vect_int } */ + +/* { dg-final { scan-tree-dump "LOOP VECTORIZED" "vect" } } */ + +extern void abort (); +extern void exit (int); + +__attribute__((noinline, noipa)) +int f(x) { + int i; + for (i =3D 0; i < 8 && (x & 1) =3D=3D 1; i++) + x >>=3D 1; + return i; +} +main() { + if (f(4) !=3D 0) + abort(); + exit(0); +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-early-break_87.c b/gcc/testsuit= e/gcc.dg/vect/vect-early-break_87.c new file mode 100644 index 0000000000000000000000000000000000000000..67be67da0583ba7feda3bed09c4= 2fa735da9b98e --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-early-break_87.c @@ -0,0 +1,21 @@ +/* { dg-additional-options "-std=3Dgnu89" } */ +/* { dg-require-effective-target vect_early_break } */ +/* { dg-require-effective-target vect_int } */ + +/* { dg-final { scan-tree-dump "LOOP VECTORIZED" "vect" } } */ + +extern void abort (); +extern void exit (int); + +__attribute__((noinline, noipa)) +int f(x) { + int i; + for (i =3D 0; i < 8 && (x & 1) =3D=3D 0; i++) + x >>=3D 1; + return i; +} +main() { + if (f(4) !=3D 2) + abort(); + exit(0); +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-early-break_88.c b/gcc/testsuit= e/gcc.dg/vect/vect-early-break_88.c new file mode 100644 index 0000000000000000000000000000000000000000..b64becd588973f58601196bfcb1= 5afbe4bab60f2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-early-break_88.c @@ -0,0 +1,36 @@ +/* { dg-require-effective-target vect_early_break } */ +/* { dg-require-effective-target vect_int } */ + +/* { dg-additional-options "-Ofast --param vect-partial-vector-usage=3D2" = } */ +/* { dg-final { scan-tree-dump "LOOP VECTORIZED" "vect" } } */ + +#ifndef N +#define N 5 +#endif +float vect_a[N] =3D { 5.1f, 4.2f, 8.0f, 4.25f, 6.5f }; +unsigned vect_b[N] =3D { 0 }; + +__attribute__ ((noinline, noipa)) +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; + =20 + } + return ret; +} + +extern void abort (); + +int main () +{ + if (test4 (7.0) !=3D 0) + abort (); + + if (vect_b[2] !=3D 0 && vect_b[1] =3D=3D 0) + abort (); +} diff --git a/gcc/tree-vect-patterns.cc b/gcc/tree-vect-patterns.cc index 7debe7f0731673cd1bf25cd39d55e23990a73d0e..f6ce27a7c45aa6ce72c40298795= 8ee395c045a14 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; @@ -2786,15 +2787,24 @@ vect_recog_bitfield_ref_pattern (vec_info *vinfo, s= tmt_vec_info stmt_info, =20 if (!lhs) { + if (!vectype) + return NULL; + append_pattern_def_seq (vinfo, stmt_info, pattern_stmt, vectype); + vectype =3D truth_type_for (vectype); + + tree new_lhs =3D vect_recog_temp_ssa_var (boolean_type_node, NULL); gcond *cond_stmt =3D dyn_cast (stmt_info->stmt); tree cond_cst =3D gimple_cond_rhs (cond_stmt); + gimple *new_stmt + =3D gimple_build_assign (new_lhs, gimple_cond_code (cond_stmt), + gimple_get_lhs (pattern_stmt), + fold_convert (container_type, cond_cst)); + append_pattern_def_seq (vinfo, stmt_info, new_stmt, vectype, contain= er_type); pattern_stmt - =3D gimple_build_cond (gimple_cond_code (cond_stmt), - gimple_get_lhs (pattern_stmt), - fold_convert (ret_type, cond_cst), - gimple_cond_true_label (cond_stmt), - gimple_cond_false_label (cond_stmt)); + =3D gimple_build_cond (NE_EXPR, new_lhs, + build_zero_cst (TREE_TYPE (new_lhs)), + NULL_TREE, NULL_TREE); } =20 *type_out =3D STMT_VINFO_VECTYPE (stmt_info); @@ -5553,6 +5563,72 @@ integer_type_for_mask (tree var, vec_info *vinfo) return build_nonstandard_integer_type (def_stmt_info->mask_precision, 1)= ; } =20 +/* Function vect_recog_gcond_pattern + + Try to find pattern like following: + + if (a op b) + + where operator 'op' is not !=3D and convert it to an adjusted boolean p= attern + + mask =3D a op b + if (mask !=3D 0) + + and set the mask type on MASK. + + Input: + + * STMT_VINFO: The stmt at the end from which the pattern + search begins, i.e. cast of a bool to + an integer type. + + Output: + + * TYPE_OUT: The type of the output of this pattern. + + * Return value: A new stmt that will be used to replace the pattern. *= / + +static gimple * +vect_recog_gcond_pattern (vec_info *vinfo, + stmt_vec_info stmt_vinfo, tree *type_out) +{ + gimple *last_stmt =3D STMT_VINFO_STMT (stmt_vinfo); + gcond* cond =3D NULL; + if (!(cond =3D dyn_cast (last_stmt))) + return NULL; + + auto lhs =3D gimple_cond_lhs (cond); + auto rhs =3D gimple_cond_rhs (cond); + auto code =3D gimple_cond_code (cond); + + tree scalar_type =3D TREE_TYPE (lhs); + if (VECTOR_TYPE_P (scalar_type)) + return NULL; + + if (code =3D=3D NE_EXPR + && zerop (rhs) + && VECT_SCALAR_BOOLEAN_TYPE_P (scalar_type)) + return NULL; + + tree vecitype =3D get_vectype_for_scalar_type (vinfo, scalar_type); + if (vecitype =3D=3D NULL_TREE) + return NULL; + + tree vectype =3D truth_type_for (vecitype); + + tree new_lhs =3D vect_recog_temp_ssa_var (boolean_type_node, NULL); + gimple *new_stmt =3D gimple_build_assign (new_lhs, code, lhs, rhs); + append_pattern_def_seq (vinfo, stmt_vinfo, new_stmt, vectype, scalar_typ= e); + + gimple *pattern_stmt + =3D gimple_build_cond (NE_EXPR, new_lhs, + build_int_cst (TREE_TYPE (new_lhs), 0), + NULL_TREE, NULL_TREE); + *type_out =3D vectype; + vect_pattern_detected ("vect_recog_gcond_pattern", last_stmt); + return pattern_stmt; +} + /* Function vect_recog_bool_pattern =20 Try to find pattern like following: @@ -6581,15 +6657,26 @@ static bool possible_vector_mask_operation_p (stmt_vec_info stmt_info) { tree lhs =3D gimple_get_lhs (stmt_info->stmt); + tree_code code =3D ERROR_MARK; + gassign *assign =3D NULL; + gcond *cond =3D NULL; + + if ((assign =3D dyn_cast (stmt_info->stmt))) + code =3D gimple_assign_rhs_code (assign); + else if ((cond =3D dyn_cast (stmt_info->stmt))) + { + lhs =3D gimple_cond_lhs (cond); + code =3D gimple_cond_code (cond); + } + if (!lhs || TREE_CODE (lhs) !=3D SSA_NAME || !VECT_SCALAR_BOOLEAN_TYPE_P (TREE_TYPE (lhs))) return false; =20 - if (gassign *assign =3D dyn_cast (stmt_info->stmt)) + if (code !=3D ERROR_MARK) { - tree_code rhs_code =3D gimple_assign_rhs_code (assign); - switch (rhs_code) + switch (code) { CASE_CONVERT: case SSA_NAME: @@ -6600,7 +6687,7 @@ possible_vector_mask_operation_p (stmt_vec_info stmt_= info) return true; =20 default: - return TREE_CODE_CLASS (rhs_code) =3D=3D tcc_comparison; + return TREE_CODE_CLASS (code) =3D=3D tcc_comparison; } } else if (is_a (stmt_info->stmt)) @@ -6647,12 +6734,35 @@ vect_determine_mask_precision (vec_info *vinfo, stm= t_vec_info stmt_info) The number of operations are equal, but M16 would have given a shorter dependency chain and allowed more ILP. */ unsigned int precision =3D ~0U; - if (gassign *assign =3D dyn_cast (stmt_info->stmt)) + gimple *stmt =3D STMT_VINFO_STMT (stmt_info); + + /* If the statement compares two values that shouldn't use vector masks, + try comparing the values as normal scalars instead. */ + tree_code code =3D ERROR_MARK; + tree op0_type; + unsigned int nops =3D -1; + unsigned int ops_start =3D 0; + + if (gassign *assign =3D dyn_cast (stmt)) + { + code =3D gimple_assign_rhs_code (assign); + op0_type =3D TREE_TYPE (gimple_assign_rhs1 (assign)); + nops =3D gimple_num_ops (assign); + ops_start =3D 1; + } + else if (gcond *cond =3D dyn_cast (stmt)) + { + code =3D gimple_cond_code (cond); + op0_type =3D TREE_TYPE (gimple_cond_lhs (cond)); + nops =3D 2; + ops_start =3D 0; + } + + if (code !=3D ERROR_MARK) { - unsigned int nops =3D gimple_num_ops (assign); - for (unsigned int i =3D 1; i < nops; ++i) + for (unsigned int i =3D ops_start; i < nops; ++i) { - tree rhs =3D gimple_op (assign, i); + tree rhs =3D gimple_op (stmt, i); if (!VECT_SCALAR_BOOLEAN_TYPE_P (TREE_TYPE (rhs))) continue; =20 @@ -6669,19 +6779,15 @@ vect_determine_mask_precision (vec_info *vinfo, stm= t_vec_info stmt_info) } } =20 - /* If the statement compares two values that shouldn't use vector ma= sks, - try comparing the values as normal scalars instead. */ - tree_code rhs_code =3D gimple_assign_rhs_code (assign); if (precision =3D=3D ~0U - && TREE_CODE_CLASS (rhs_code) =3D=3D tcc_comparison) + && TREE_CODE_CLASS (code) =3D=3D tcc_comparison) { - tree rhs1_type =3D TREE_TYPE (gimple_assign_rhs1 (assign)); scalar_mode mode; tree vectype, mask_type; - if (is_a (TYPE_MODE (rhs1_type), &mode) - && (vectype =3D get_vectype_for_scalar_type (vinfo, rhs1_type)) - && (mask_type =3D get_mask_type_for_scalar_type (vinfo, rhs1_type)) - && expand_vec_cmp_expr_p (vectype, mask_type, rhs_code)) + if (is_a (TYPE_MODE (op0_type), &mode) + && (vectype =3D get_vectype_for_scalar_type (vinfo, op0_type)) + && (mask_type =3D get_mask_type_for_scalar_type (vinfo, op0_type)) + && expand_vec_cmp_expr_p (vectype, mask_type, code)) precision =3D GET_MODE_BITSIZE (mode); } } @@ -6860,6 +6966,7 @@ static vect_recog_func vect_vect_recog_func_ptrs[] = =3D { { vect_recog_divmod_pattern, "divmod" }, { vect_recog_mult_pattern, "mult" }, { vect_recog_mixed_size_cond_pattern, "mixed_size_cond" }, + { vect_recog_gcond_pattern, "gcond" }, { vect_recog_bool_pattern, "bool" }, /* This must come before mask conversion, and includes the parts of mask conversion that are needed for gather and scatter diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index 582c5e678fad802d6e76300fe3c939b9f2978f17..766450cd85b55ce4dfd45878c5d= c44cd09c68681 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,207 @@ 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; + + DUMP_VECT_SCOPE ("vectorizable_early_exit"); + + auto code =3D gimple_cond_code (STMT_VINFO_STMT (stmt_info)); + + tree vectype =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)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "use not simple.\n"); + return false; + } + + if (!vectype) + 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; + + 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. Normally we loop over + vec_num, but since we inspect the exact results of vectorization + we don't need to and instead can just use the stmts themselves. */ + if (masked_loop_p) + for (unsigned i =3D 0; i < stmts.length (); i++) + { + tree stmt_mask + =3D vect_get_loop_mask (loop_vinfo, gsi, masks, ncopies, vectype, + i); + stmt_mask + =3D prepare_vec_mask (loop_vinfo, TREE_TYPE (stmt_mask), stmt_mask, + stmts[i], &cond_gsi); + workset.quick_push (stmt_mask); + } + 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]; + if (masked_loop_p) + { + tree mask + =3D vect_get_loop_mask (loop_vinfo, gsi, masks, ncopies, vectype, 0); + new_temp =3D prepare_vec_mask (loop_vinfo, TREE_TYPE (mask), mask, + new_temp, &cond_gsi); + } + } + + gcc_assert (new_temp); + + /* 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); + /* When vectorizing we assume that if the branch edge is taken that we'r= e + exiting the loop. This is not however always the case as the compile= r will + rewrite conditions to always be a comparison against 0. To do this i= t + sometimes flips the edges. This is fine for scalar, but for vector = we + then have to flip the test, as we're still assuming that if you take = the + branch edge that we found the exit condition. */ + auto new_code =3D NE_EXPR; + tree cst =3D build_zero_cst (vectype); + if (flow_bb_inside_loop_p (LOOP_VINFO_LOOP (loop_vinfo), + BRANCH_EDGE (gimple_bb (cond_stmt))->dest)) + { + new_code =3D EQ_EXPR; + cst =3D build_minus_one_cst (vectype); + } + + gimple_cond_set_condition (cond_stmt, new_code, new_temp, cst); + 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 +13154,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 +13179,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 +13341,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,6 +14537,14 @@ vect_get_vector_types_for_stmt (vec_info *vinfo, s= tmt_vec_info stmt_info, } else { + /* If we got here with a gcond it means that the target had no avail= able vector + mode for the scalar type. We can't vectorize so abort. */ + if (is_a (stmt)) + return opt_result::failure_at (stmt, + "not vectorized:" + " unsupported data-type for gcond %T\n", + scalar_type); + 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)) --_002_VI1PR08MB5325688E37E6A409E577E00EFF8DAVI1PR08MB5325eurp_ Content-Type: application/octet-stream; name="rb17969 (2).patch" Content-Description: rb17969 (2).patch Content-Disposition: attachment; filename="rb17969 (2).patch"; size=22031; creation-date="Wed, 13 Dec 2023 14:09:31 GMT"; modification-date="Wed, 13 Dec 2023 14:13:11 GMT" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVjdC1lYXJseS1icmVha184 NC5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFrXzg0LmMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uMDYyMjMzOTQ5MWQzMzNiMDdjMmNlODk1Nzg1YjUyMTY3MTMwOTdhOQotLS0gL2Rl di9udWxsCisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVjdC1lYXJseS1icmVha184 NC5jCkBAIC0wLDAgKzEsMzkgQEAKKy8qIHsgZGctcmVxdWlyZS1lZmZlY3RpdmUtdGFyZ2V0IHZl Y3RfZWFybHlfYnJlYWsgfSAqLworLyogeyBkZy1yZXF1aXJlLWVmZmVjdGl2ZS10YXJnZXQgdmVj dF9pbnQgfSAqLworCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAgIkxPT1AgVkVDVE9S SVpFRCIgInZlY3QiIH0gfSAqLworCisjaW5jbHVkZSA8c3RkYm9vbC5oPgorCisjaWZuZGVmIE4K KyNkZWZpbmUgTiAxNworI2VuZGlmCitib29sIHZlY3RfYVtOXSA9IHsgZmFsc2UsIGZhbHNlLCB0 cnVlLCBmYWxzZSwgZmFsc2UsIGZhbHNlLAorICAgICAgICAgICAgICAgICAgIGZhbHNlLCBmYWxz ZSwgZmFsc2UsIGZhbHNlLCBmYWxzZSwgZmFsc2UsCisgICAgICAgICAgICAgICAgICAgZmFsc2Us IGZhbHNlLCBmYWxzZSwgZmFsc2UsIGZhbHNlIH07Cit1bnNpZ25lZCB2ZWN0X2JbTl0gPSB7IDAg fTsKKworX19hdHRyaWJ1dGVfXyAoKG5vaW5saW5lLCBub2lwYSkpCit1bnNpZ25lZCB0ZXN0NChi b29sIHgpCit7CisgdW5zaWduZWQgcmV0ID0gMDsKKyBmb3IgKGludCBpID0gMDsgaSA8IE47IGkr KykKKyB7CisgICBpZiAodmVjdF9hW2ldID09IHgpCisgICAgIHJldHVybiAxOworICAgdmVjdF9h W2ldID0geDsKKyAgIAorIH0KKyByZXR1cm4gcmV0OworfQorCitleHRlcm4gdm9pZCBhYm9ydCAo KTsKKworaW50IG1haW4gKCkKK3sKKyAgaWYgKHRlc3Q0ICh0cnVlKSAhPSAxKQorICAgIGFib3J0 ICgpOworCisgIGlmICh2ZWN0X2JbMl0gIT0gMCAmJiB2ZWN0X2JbMV0gPT0gMCkKKyAgICBhYm9y dCAoKTsKK30KZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVjdC1lYXJs eS1icmVha184NS5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFr Xzg1LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uMzliM2Q5YmFkODY4MWEyZDE1ZDdmYzdkZTg2YmRkM2NlMGYwYmQ0 ZQotLS0gL2Rldi9udWxsCisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVjdC1lYXJs eS1icmVha184NS5jCkBAIC0wLDAgKzEsMzUgQEAKKy8qIHsgZGctcmVxdWlyZS1lZmZlY3RpdmUt dGFyZ2V0IHZlY3RfZWFybHlfYnJlYWsgfSAqLworLyogeyBkZy1yZXF1aXJlLWVmZmVjdGl2ZS10 YXJnZXQgdmVjdF9pbnQgfSAqLworCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAgIkxP T1AgVkVDVE9SSVpFRCIgInZlY3QiIH0gfSAqLworCisjaWZuZGVmIE4KKyNkZWZpbmUgTiA1Cisj ZW5kaWYKK2ludCB2ZWN0X2FbTl0gPSB7IDUsIDQsIDgsIDQsIDYgfTsKK3Vuc2lnbmVkIHZlY3Rf YltOXSA9IHsgMCB9OworCitfX2F0dHJpYnV0ZV9fICgobm9pbmxpbmUsIG5vaXBhKSkKK3Vuc2ln bmVkIHRlc3Q0KGludCB4KQoreworIHVuc2lnbmVkIHJldCA9IDA7CisgZm9yIChpbnQgaSA9IDA7 IGkgPCBOOyBpKyspCisgeworICAgaWYgKHZlY3RfYVtpXSA+IHgpCisgICAgIHJldHVybiAxOwor ICAgdmVjdF9hW2ldID0geDsKKyAgIAorIH0KKyByZXR1cm4gcmV0OworfQorCitleHRlcm4gdm9p ZCBhYm9ydCAoKTsKKworaW50IG1haW4gKCkKK3sKKyAgaWYgKHRlc3Q0ICg3KSAhPSAxKQorICAg IGFib3J0ICgpOworCisgIGlmICh2ZWN0X2JbMl0gIT0gMCAmJiB2ZWN0X2JbMV0gPT0gMCkKKyAg ICBhYm9ydCAoKTsKK30KZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVj dC1lYXJseS1icmVha184Ni5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5 LWJyZWFrXzg2LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjZlYjU3MGY0MDI4YmNhNGI2MzEzMjlkN2FmNTBjNjQ2 ZDNjMGNiMwotLS0gL2Rldi9udWxsCisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVj dC1lYXJseS1icmVha184Ni5jCkBAIC0wLDAgKzEsMjEgQEAKKy8qIHsgZGctYWRkaXRpb25hbC1v cHRpb25zICItc3RkPWdudTg5IiB9ICovCisvKiB7IGRnLXJlcXVpcmUtZWZmZWN0aXZlLXRhcmdl dCB2ZWN0X2Vhcmx5X2JyZWFrIH0gKi8KKy8qIHsgZGctcmVxdWlyZS1lZmZlY3RpdmUtdGFyZ2V0 IHZlY3RfaW50IH0gKi8KKworLyogeyBkZy1maW5hbCB7IHNjYW4tdHJlZS1kdW1wICJMT09QIFZF Q1RPUklaRUQiICJ2ZWN0IiB9IH0gKi8KKworZXh0ZXJuIHZvaWQgYWJvcnQgKCk7CitleHRlcm4g dm9pZCBleGl0IChpbnQpOworCitfX2F0dHJpYnV0ZV9fKChub2lubGluZSwgbm9pcGEpKQoraW50 IGYoeCkgeworICBpbnQgaTsKKyAgZm9yIChpID0gMDsgaSA8IDggJiYgKHggJiAxKSA9PSAxOyBp KyspCisgICAgeCA+Pj0gMTsKKyAgcmV0dXJuIGk7Cit9CittYWluKCkgeworICBpZiAoZig0KSAh PSAwKQorICAgIGFib3J0KCk7CisgIGV4aXQoMCk7Cit9CmRpZmYgLS1naXQgYS9nY2MvdGVzdHN1 aXRlL2djYy5kZy92ZWN0L3ZlY3QtZWFybHktYnJlYWtfODcuYyBiL2djYy90ZXN0c3VpdGUvZ2Nj LmRnL3ZlY3QvdmVjdC1lYXJseS1icmVha184Ny5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjY3YmU2N2RhMDU4M2Jh N2ZlZGEzYmVkMDljNDJmYTczNWRhOWI5OGUKLS0tIC9kZXYvbnVsbAorKysgYi9nY2MvdGVzdHN1 aXRlL2djYy5kZy92ZWN0L3ZlY3QtZWFybHktYnJlYWtfODcuYwpAQCAtMCwwICsxLDIxIEBACisv KiB7IGRnLWFkZGl0aW9uYWwtb3B0aW9ucyAiLXN0ZD1nbnU4OSIgfSAqLworLyogeyBkZy1yZXF1 aXJlLWVmZmVjdGl2ZS10YXJnZXQgdmVjdF9lYXJseV9icmVhayB9ICovCisvKiB7IGRnLXJlcXVp cmUtZWZmZWN0aXZlLXRhcmdldCB2ZWN0X2ludCB9ICovCisKKy8qIHsgZGctZmluYWwgeyBzY2Fu LXRyZWUtZHVtcCAiTE9PUCBWRUNUT1JJWkVEIiAidmVjdCIgfSB9ICovCisKK2V4dGVybiB2b2lk IGFib3J0ICgpOworZXh0ZXJuIHZvaWQgZXhpdCAoaW50KTsKKworX19hdHRyaWJ1dGVfXygobm9p bmxpbmUsIG5vaXBhKSkKK2ludCBmKHgpIHsKKyAgaW50IGk7CisgIGZvciAoaSA9IDA7IGkgPCA4 ICYmICh4ICYgMSkgPT0gMDsgaSsrKQorICAgIHggPj49IDE7CisgIHJldHVybiBpOworfQorbWFp bigpIHsKKyAgaWYgKGYoNCkgIT0gMikKKyAgICBhYm9ydCgpOworICBleGl0KDApOworfQpkaWZm IC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFrXzg4LmMg Yi9nY2MvdGVzdHN1aXRlL2djYy5kZy92ZWN0L3ZlY3QtZWFybHktYnJlYWtfODguYwpuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi5iNjRiZWNkNTg4OTczZjU4NjAxMTk2YmZjYjE1YWZiZTRiYWI2MGYyCi0tLSAvZGV2L251 bGwKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFrXzg4LmMK QEAgLTAsMCArMSwzNiBAQAorLyogeyBkZy1yZXF1aXJlLWVmZmVjdGl2ZS10YXJnZXQgdmVjdF9l YXJseV9icmVhayB9ICovCisvKiB7IGRnLXJlcXVpcmUtZWZmZWN0aXZlLXRhcmdldCB2ZWN0X2lu dCB9ICovCisKKy8qIHsgZGctYWRkaXRpb25hbC1vcHRpb25zICItT2Zhc3QgLS1wYXJhbSB2ZWN0 LXBhcnRpYWwtdmVjdG9yLXVzYWdlPTIiIH0gKi8KKy8qIHsgZGctZmluYWwgeyBzY2FuLXRyZWUt ZHVtcCAiTE9PUCBWRUNUT1JJWkVEIiAidmVjdCIgfSB9ICovCisKKyNpZm5kZWYgTgorI2RlZmlu ZSBOIDUKKyNlbmRpZgorZmxvYXQgdmVjdF9hW05dID0geyA1LjFmLCA0LjJmLCA4LjBmLCA0LjI1 ZiwgNi41ZiB9OwordW5zaWduZWQgdmVjdF9iW05dID0geyAwIH07CisKK19fYXR0cmlidXRlX18g KChub2lubGluZSwgbm9pcGEpKQordW5zaWduZWQgdGVzdDQoZG91YmxlIHgpCit7CisgdW5zaWdu ZWQgcmV0ID0gMDsKKyBmb3IgKGludCBpID0gMDsgaSA8IE47IGkrKykKKyB7CisgICBpZiAodmVj dF9hW2ldID4geCkKKyAgICAgYnJlYWs7CisgICB2ZWN0X2FbaV0gPSB4OworICAgCisgfQorIHJl dHVybiByZXQ7Cit9CisKK2V4dGVybiB2b2lkIGFib3J0ICgpOworCitpbnQgbWFpbiAoKQorewor ICBpZiAodGVzdDQgKDcuMCkgIT0gMCkKKyAgICBhYm9ydCAoKTsKKworICBpZiAodmVjdF9iWzJd ICE9IDAgJiYgdmVjdF9iWzFdID09IDApCisgICAgYWJvcnQgKCk7Cit9CmRpZmYgLS1naXQgYS9n Y2MvdHJlZS12ZWN0LXBhdHRlcm5zLmNjIGIvZ2NjL3RyZWUtdmVjdC1wYXR0ZXJucy5jYwppbmRl eCA3ZGViZTdmMDczMTY3M2NkMWJmMjVjZDM5ZDU1ZTIzOTkwYTczZDBlLi5mNmNlMjdhN2M0NWFh NmNlNzJjNDAyOTg3OTU4ZWUzOTVjMDQ1YTE0IDEwMDY0NAotLS0gYS9nY2MvdHJlZS12ZWN0LXBh dHRlcm5zLmNjCisrKyBiL2djYy90cmVlLXZlY3QtcGF0dGVybnMuY2MKQEAgLTEzMiw2ICsxMzIs NyBAQCB2ZWN0X2luaXRfcGF0dGVybl9zdG10ICh2ZWNfaW5mbyAqdmluZm8sIGdpbXBsZSAqcGF0 dGVybl9zdG10LAogICBpZiAoIVNUTVRfVklORk9fVkVDVFlQRSAocGF0dGVybl9zdG10X2luZm8p KQogICAgIHsKICAgICAgIGdjY19hc3NlcnQgKCF2ZWN0eXBlCisJCSAgfHwgaXNfYSA8Z2NvbmQg Kj4gKHBhdHRlcm5fc3RtdCkKIAkJICB8fCAoVkVDVE9SX0JPT0xFQU5fVFlQRV9QICh2ZWN0eXBl KQogCQkgICAgICA9PSB2ZWN0X3VzZV9tYXNrX3R5cGVfcCAob3JpZ19zdG10X2luZm8pKSk7CiAg ICAgICBTVE1UX1ZJTkZPX1ZFQ1RZUEUgKHBhdHRlcm5fc3RtdF9pbmZvKSA9IHZlY3R5cGU7CkBA IC0yNzg2LDE1ICsyNzg3LDI0IEBAIHZlY3RfcmVjb2dfYml0ZmllbGRfcmVmX3BhdHRlcm4gKHZl Y19pbmZvICp2aW5mbywgc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sCiAKICAgaWYgKCFsaHMpCiAg ICAgeworICAgICAgaWYgKCF2ZWN0eXBlKQorCXJldHVybiBOVUxMOworCiAgICAgICBhcHBlbmRf cGF0dGVybl9kZWZfc2VxICh2aW5mbywgc3RtdF9pbmZvLCBwYXR0ZXJuX3N0bXQsIHZlY3R5cGUp OworICAgICAgdmVjdHlwZSA9IHRydXRoX3R5cGVfZm9yICh2ZWN0eXBlKTsKKworICAgICAgdHJl ZSBuZXdfbGhzID0gdmVjdF9yZWNvZ190ZW1wX3NzYV92YXIgKGJvb2xlYW5fdHlwZV9ub2RlLCBO VUxMKTsKICAgICAgIGdjb25kICpjb25kX3N0bXQgPSBkeW5fY2FzdCA8Z2NvbmQgKj4gKHN0bXRf aW5mby0+c3RtdCk7CiAgICAgICB0cmVlIGNvbmRfY3N0ID0gZ2ltcGxlX2NvbmRfcmhzIChjb25k X3N0bXQpOworICAgICAgZ2ltcGxlICpuZXdfc3RtdAorCT0gZ2ltcGxlX2J1aWxkX2Fzc2lnbiAo bmV3X2xocywgZ2ltcGxlX2NvbmRfY29kZSAoY29uZF9zdG10KSwKKwkJCSAgICAgICBnaW1wbGVf Z2V0X2xocyAocGF0dGVybl9zdG10KSwKKwkJCSAgICAgICBmb2xkX2NvbnZlcnQgKGNvbnRhaW5l cl90eXBlLCBjb25kX2NzdCkpOworICAgICAgYXBwZW5kX3BhdHRlcm5fZGVmX3NlcSAodmluZm8s IHN0bXRfaW5mbywgbmV3X3N0bXQsIHZlY3R5cGUsIGNvbnRhaW5lcl90eXBlKTsKICAgICAgIHBh dHRlcm5fc3RtdAotCT0gZ2ltcGxlX2J1aWxkX2NvbmQgKGdpbXBsZV9jb25kX2NvZGUgKGNvbmRf c3RtdCksCi0JCQkgICAgIGdpbXBsZV9nZXRfbGhzIChwYXR0ZXJuX3N0bXQpLAotCQkJICAgICBm b2xkX2NvbnZlcnQgKHJldF90eXBlLCBjb25kX2NzdCksCi0JCQkgICAgIGdpbXBsZV9jb25kX3Ry dWVfbGFiZWwgKGNvbmRfc3RtdCksCi0JCQkgICAgIGdpbXBsZV9jb25kX2ZhbHNlX2xhYmVsIChj b25kX3N0bXQpKTsKKwk9IGdpbXBsZV9idWlsZF9jb25kIChORV9FWFBSLCBuZXdfbGhzLAorCQkJ ICAgICBidWlsZF96ZXJvX2NzdCAoVFJFRV9UWVBFIChuZXdfbGhzKSksCisJCQkgICAgIE5VTExf VFJFRSwgTlVMTF9UUkVFKTsKICAgICB9CiAKICAgKnR5cGVfb3V0ID0gU1RNVF9WSU5GT19WRUNU WVBFIChzdG10X2luZm8pOwpAQCAtNTU1Myw2ICs1NTYzLDcyIEBAIGludGVnZXJfdHlwZV9mb3Jf bWFzayAodHJlZSB2YXIsIHZlY19pbmZvICp2aW5mbykKICAgcmV0dXJuIGJ1aWxkX25vbnN0YW5k YXJkX2ludGVnZXJfdHlwZSAoZGVmX3N0bXRfaW5mby0+bWFza19wcmVjaXNpb24sIDEpOwogfQog CisvKiBGdW5jdGlvbiB2ZWN0X3JlY29nX2djb25kX3BhdHRlcm4KKworICAgVHJ5IHRvIGZpbmQg cGF0dGVybiBsaWtlIGZvbGxvd2luZzoKKworICAgICBpZiAoYSBvcCBiKQorCisgICB3aGVyZSBv cGVyYXRvciAnb3AnIGlzIG5vdCAhPSBhbmQgY29udmVydCBpdCB0byBhbiBhZGp1c3RlZCBib29s ZWFuIHBhdHRlcm4KKworICAgICBtYXNrID0gYSBvcCBiCisgICAgIGlmIChtYXNrICE9IDApCisK KyAgIGFuZCBzZXQgdGhlIG1hc2sgdHlwZSBvbiBNQVNLLgorCisgICBJbnB1dDoKKworICAgKiBT VE1UX1ZJTkZPOiBUaGUgc3RtdCBhdCB0aGUgZW5kIGZyb20gd2hpY2ggdGhlIHBhdHRlcm4KKwkJ IHNlYXJjaCBiZWdpbnMsIGkuZS4gY2FzdCBvZiBhIGJvb2wgdG8KKwkJIGFuIGludGVnZXIgdHlw ZS4KKworICAgT3V0cHV0OgorCisgICAqIFRZUEVfT1VUOiBUaGUgdHlwZSBvZiB0aGUgb3V0cHV0 IG9mIHRoaXMgcGF0dGVybi4KKworICAgKiBSZXR1cm4gdmFsdWU6IEEgbmV3IHN0bXQgdGhhdCB3 aWxsIGJlIHVzZWQgdG8gcmVwbGFjZSB0aGUgcGF0dGVybi4gICovCisKK3N0YXRpYyBnaW1wbGUg KgordmVjdF9yZWNvZ19nY29uZF9wYXR0ZXJuICh2ZWNfaW5mbyAqdmluZm8sCisJCQkgc3RtdF92 ZWNfaW5mbyBzdG10X3ZpbmZvLCB0cmVlICp0eXBlX291dCkKK3sKKyAgZ2ltcGxlICpsYXN0X3N0 bXQgPSBTVE1UX1ZJTkZPX1NUTVQgKHN0bXRfdmluZm8pOworICBnY29uZCogY29uZCA9IE5VTEw7 CisgIGlmICghKGNvbmQgPSBkeW5fY2FzdCA8Z2NvbmQgKj4gKGxhc3Rfc3RtdCkpKQorICAgIHJl dHVybiBOVUxMOworCisgIGF1dG8gbGhzID0gZ2ltcGxlX2NvbmRfbGhzIChjb25kKTsKKyAgYXV0 byByaHMgPSBnaW1wbGVfY29uZF9yaHMgKGNvbmQpOworICBhdXRvIGNvZGUgPSBnaW1wbGVfY29u ZF9jb2RlIChjb25kKTsKKworICB0cmVlIHNjYWxhcl90eXBlID0gVFJFRV9UWVBFIChsaHMpOwor ICBpZiAoVkVDVE9SX1RZUEVfUCAoc2NhbGFyX3R5cGUpKQorICAgIHJldHVybiBOVUxMOworCisg IGlmIChjb2RlID09IE5FX0VYUFIKKyAgICAgICYmIHplcm9wIChyaHMpCisgICAgICAmJiBWRUNU X1NDQUxBUl9CT09MRUFOX1RZUEVfUCAoc2NhbGFyX3R5cGUpKQorICAgIHJldHVybiBOVUxMOwor CisgIHRyZWUgdmVjaXR5cGUgPSBnZXRfdmVjdHlwZV9mb3Jfc2NhbGFyX3R5cGUgKHZpbmZvLCBz Y2FsYXJfdHlwZSk7CisgIGlmICh2ZWNpdHlwZSA9PSBOVUxMX1RSRUUpCisgICAgcmV0dXJuIE5V TEw7CisKKyAgdHJlZSB2ZWN0eXBlID0gdHJ1dGhfdHlwZV9mb3IgKHZlY2l0eXBlKTsKKworICB0 cmVlIG5ld19saHMgPSB2ZWN0X3JlY29nX3RlbXBfc3NhX3ZhciAoYm9vbGVhbl90eXBlX25vZGUs IE5VTEwpOworICBnaW1wbGUgKm5ld19zdG10ID0gZ2ltcGxlX2J1aWxkX2Fzc2lnbiAobmV3X2xo cywgY29kZSwgbGhzLCByaHMpOworICBhcHBlbmRfcGF0dGVybl9kZWZfc2VxICh2aW5mbywgc3Rt dF92aW5mbywgbmV3X3N0bXQsIHZlY3R5cGUsIHNjYWxhcl90eXBlKTsKKworICBnaW1wbGUgKnBh dHRlcm5fc3RtdAorICAgID0gZ2ltcGxlX2J1aWxkX2NvbmQgKE5FX0VYUFIsIG5ld19saHMsCisJ CQkgYnVpbGRfaW50X2NzdCAoVFJFRV9UWVBFIChuZXdfbGhzKSwgMCksCisJCQkgTlVMTF9UUkVF LCBOVUxMX1RSRUUpOworICAqdHlwZV9vdXQgPSB2ZWN0eXBlOworICB2ZWN0X3BhdHRlcm5fZGV0 ZWN0ZWQgKCJ2ZWN0X3JlY29nX2djb25kX3BhdHRlcm4iLCBsYXN0X3N0bXQpOworICByZXR1cm4g cGF0dGVybl9zdG10OworfQorCiAvKiBGdW5jdGlvbiB2ZWN0X3JlY29nX2Jvb2xfcGF0dGVybgog CiAgICBUcnkgdG8gZmluZCBwYXR0ZXJuIGxpa2UgZm9sbG93aW5nOgpAQCAtNjU4MSwxNSArNjY1 NywyNiBAQCBzdGF0aWMgYm9vbAogcG9zc2libGVfdmVjdG9yX21hc2tfb3BlcmF0aW9uX3AgKHN0 bXRfdmVjX2luZm8gc3RtdF9pbmZvKQogewogICB0cmVlIGxocyA9IGdpbXBsZV9nZXRfbGhzIChz dG10X2luZm8tPnN0bXQpOworICB0cmVlX2NvZGUgY29kZSA9IEVSUk9SX01BUks7CisgIGdhc3Np Z24gKmFzc2lnbiA9IE5VTEw7CisgIGdjb25kICpjb25kID0gTlVMTDsKKworICBpZiAoKGFzc2ln biA9IGR5bl9jYXN0IDxnYXNzaWduICo+IChzdG10X2luZm8tPnN0bXQpKSkKKyAgICBjb2RlID0g Z2ltcGxlX2Fzc2lnbl9yaHNfY29kZSAoYXNzaWduKTsKKyAgZWxzZSBpZiAoKGNvbmQgPSBkeW5f Y2FzdCA8Z2NvbmQgKj4gKHN0bXRfaW5mby0+c3RtdCkpKQorICAgIHsKKyAgICAgIGxocyA9IGdp bXBsZV9jb25kX2xocyAoY29uZCk7CisgICAgICBjb2RlID0gZ2ltcGxlX2NvbmRfY29kZSAoY29u ZCk7CisgICAgfQorCiAgIGlmICghbGhzCiAgICAgICB8fCBUUkVFX0NPREUgKGxocykgIT0gU1NB X05BTUUKICAgICAgIHx8ICFWRUNUX1NDQUxBUl9CT09MRUFOX1RZUEVfUCAoVFJFRV9UWVBFIChs aHMpKSkKICAgICByZXR1cm4gZmFsc2U7CiAKLSAgaWYgKGdhc3NpZ24gKmFzc2lnbiA9IGR5bl9j YXN0IDxnYXNzaWduICo+IChzdG10X2luZm8tPnN0bXQpKQorICBpZiAoY29kZSAhPSBFUlJPUl9N QVJLKQogICAgIHsKLSAgICAgIHRyZWVfY29kZSByaHNfY29kZSA9IGdpbXBsZV9hc3NpZ25fcmhz X2NvZGUgKGFzc2lnbik7Ci0gICAgICBzd2l0Y2ggKHJoc19jb2RlKQorICAgICAgc3dpdGNoIChj b2RlKQogCXsKIAlDQVNFX0NPTlZFUlQ6CiAJY2FzZSBTU0FfTkFNRToKQEAgLTY2MDAsNyArNjY4 Nyw3IEBAIHBvc3NpYmxlX3ZlY3Rvcl9tYXNrX29wZXJhdGlvbl9wIChzdG10X3ZlY19pbmZvIHN0 bXRfaW5mbykKIAkgIHJldHVybiB0cnVlOwogCiAJZGVmYXVsdDoKLQkgIHJldHVybiBUUkVFX0NP REVfQ0xBU1MgKHJoc19jb2RlKSA9PSB0Y2NfY29tcGFyaXNvbjsKKwkgIHJldHVybiBUUkVFX0NP REVfQ0xBU1MgKGNvZGUpID09IHRjY19jb21wYXJpc29uOwogCX0KICAgICB9CiAgIGVsc2UgaWYg KGlzX2EgPGdwaGkgKj4gKHN0bXRfaW5mby0+c3RtdCkpCkBAIC02NjQ3LDEyICs2NzM0LDM1IEBA IHZlY3RfZGV0ZXJtaW5lX21hc2tfcHJlY2lzaW9uICh2ZWNfaW5mbyAqdmluZm8sIHN0bXRfdmVj X2luZm8gc3RtdF9pbmZvKQogICAgICBUaGUgbnVtYmVyIG9mIG9wZXJhdGlvbnMgYXJlIGVxdWFs LCBidXQgTTE2IHdvdWxkIGhhdmUgZ2l2ZW4KICAgICAgYSBzaG9ydGVyIGRlcGVuZGVuY3kgY2hh aW4gYW5kIGFsbG93ZWQgbW9yZSBJTFAuICAqLwogICB1bnNpZ25lZCBpbnQgcHJlY2lzaW9uID0g fjBVOwotICBpZiAoZ2Fzc2lnbiAqYXNzaWduID0gZHluX2Nhc3QgPGdhc3NpZ24gKj4gKHN0bXRf aW5mby0+c3RtdCkpCisgIGdpbXBsZSAqc3RtdCA9IFNUTVRfVklORk9fU1RNVCAoc3RtdF9pbmZv KTsKKworICAvKiBJZiB0aGUgc3RhdGVtZW50IGNvbXBhcmVzIHR3byB2YWx1ZXMgdGhhdCBzaG91 bGRuJ3QgdXNlIHZlY3RvciBtYXNrcywKKyAgICAgdHJ5IGNvbXBhcmluZyB0aGUgdmFsdWVzIGFz IG5vcm1hbCBzY2FsYXJzIGluc3RlYWQuICAqLworICB0cmVlX2NvZGUgY29kZSA9IEVSUk9SX01B Uks7CisgIHRyZWUgb3AwX3R5cGU7CisgIHVuc2lnbmVkIGludCBub3BzID0gLTE7CisgIHVuc2ln bmVkIGludCBvcHNfc3RhcnQgPSAwOworCisgIGlmIChnYXNzaWduICphc3NpZ24gPSBkeW5fY2Fz dCA8Z2Fzc2lnbiAqPiAoc3RtdCkpCisgICAgeworICAgICAgY29kZSA9IGdpbXBsZV9hc3NpZ25f cmhzX2NvZGUgKGFzc2lnbik7CisgICAgICBvcDBfdHlwZSA9IFRSRUVfVFlQRSAoZ2ltcGxlX2Fz c2lnbl9yaHMxIChhc3NpZ24pKTsKKyAgICAgIG5vcHMgPSBnaW1wbGVfbnVtX29wcyAoYXNzaWdu KTsKKyAgICAgIG9wc19zdGFydCA9IDE7CisgICAgfQorICBlbHNlIGlmIChnY29uZCAqY29uZCA9 IGR5bl9jYXN0IDxnY29uZCAqPiAoc3RtdCkpCisgICAgeworICAgICAgY29kZSA9IGdpbXBsZV9j b25kX2NvZGUgKGNvbmQpOworICAgICAgb3AwX3R5cGUgPSBUUkVFX1RZUEUgKGdpbXBsZV9jb25k X2xocyAoY29uZCkpOworICAgICAgbm9wcyA9IDI7CisgICAgICBvcHNfc3RhcnQgPSAwOworICAg IH0KKworICBpZiAoY29kZSAhPSBFUlJPUl9NQVJLKQogICAgIHsKLSAgICAgIHVuc2lnbmVkIGlu dCBub3BzID0gZ2ltcGxlX251bV9vcHMgKGFzc2lnbik7Ci0gICAgICBmb3IgKHVuc2lnbmVkIGlu dCBpID0gMTsgaSA8IG5vcHM7ICsraSkKKyAgICAgIGZvciAodW5zaWduZWQgaW50IGkgPSBvcHNf c3RhcnQ7IGkgPCBub3BzOyArK2kpCiAJewotCSAgdHJlZSByaHMgPSBnaW1wbGVfb3AgKGFzc2ln biwgaSk7CisJICB0cmVlIHJocyA9IGdpbXBsZV9vcCAoc3RtdCwgaSk7CiAJICBpZiAoIVZFQ1Rf U0NBTEFSX0JPT0xFQU5fVFlQRV9QIChUUkVFX1RZUEUgKHJocykpKQogCSAgICBjb250aW51ZTsK IApAQCAtNjY2OSwxOSArNjc3OSwxNSBAQCB2ZWN0X2RldGVybWluZV9tYXNrX3ByZWNpc2lvbiAo dmVjX2luZm8gKnZpbmZvLCBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbykKIAkgICAgfQogCX0KIAot ICAgICAgLyogSWYgdGhlIHN0YXRlbWVudCBjb21wYXJlcyB0d28gdmFsdWVzIHRoYXQgc2hvdWxk bid0IHVzZSB2ZWN0b3IgbWFza3MsCi0JIHRyeSBjb21wYXJpbmcgdGhlIHZhbHVlcyBhcyBub3Jt YWwgc2NhbGFycyBpbnN0ZWFkLiAgKi8KLSAgICAgIHRyZWVfY29kZSByaHNfY29kZSA9IGdpbXBs ZV9hc3NpZ25fcmhzX2NvZGUgKGFzc2lnbik7CiAgICAgICBpZiAocHJlY2lzaW9uID09IH4wVQot CSAgJiYgVFJFRV9DT0RFX0NMQVNTIChyaHNfY29kZSkgPT0gdGNjX2NvbXBhcmlzb24pCisJICAm JiBUUkVFX0NPREVfQ0xBU1MgKGNvZGUpID09IHRjY19jb21wYXJpc29uKQogCXsKLQkgIHRyZWUg cmhzMV90eXBlID0gVFJFRV9UWVBFIChnaW1wbGVfYXNzaWduX3JoczEgKGFzc2lnbikpOwogCSAg c2NhbGFyX21vZGUgbW9kZTsKIAkgIHRyZWUgdmVjdHlwZSwgbWFza190eXBlOwotCSAgaWYgKGlz X2EgPHNjYWxhcl9tb2RlPiAoVFlQRV9NT0RFIChyaHMxX3R5cGUpLCAmbW9kZSkKLQkgICAgICAm JiAodmVjdHlwZSA9IGdldF92ZWN0eXBlX2Zvcl9zY2FsYXJfdHlwZSAodmluZm8sIHJoczFfdHlw ZSkpCi0JICAgICAgJiYgKG1hc2tfdHlwZSA9IGdldF9tYXNrX3R5cGVfZm9yX3NjYWxhcl90eXBl ICh2aW5mbywgcmhzMV90eXBlKSkKLQkgICAgICAmJiBleHBhbmRfdmVjX2NtcF9leHByX3AgKHZl Y3R5cGUsIG1hc2tfdHlwZSwgcmhzX2NvZGUpKQorCSAgaWYgKGlzX2EgPHNjYWxhcl9tb2RlPiAo VFlQRV9NT0RFIChvcDBfdHlwZSksICZtb2RlKQorCSAgICAgICYmICh2ZWN0eXBlID0gZ2V0X3Zl Y3R5cGVfZm9yX3NjYWxhcl90eXBlICh2aW5mbywgb3AwX3R5cGUpKQorCSAgICAgICYmIChtYXNr X3R5cGUgPSBnZXRfbWFza190eXBlX2Zvcl9zY2FsYXJfdHlwZSAodmluZm8sIG9wMF90eXBlKSkK KwkgICAgICAmJiBleHBhbmRfdmVjX2NtcF9leHByX3AgKHZlY3R5cGUsIG1hc2tfdHlwZSwgY29k ZSkpCiAJICAgIHByZWNpc2lvbiA9IEdFVF9NT0RFX0JJVFNJWkUgKG1vZGUpOwogCX0KICAgICB9 CkBAIC02ODYwLDYgKzY5NjYsNyBAQCBzdGF0aWMgdmVjdF9yZWNvZ19mdW5jIHZlY3RfdmVjdF9y ZWNvZ19mdW5jX3B0cnNbXSA9IHsKICAgeyB2ZWN0X3JlY29nX2Rpdm1vZF9wYXR0ZXJuLCAiZGl2 bW9kIiB9LAogICB7IHZlY3RfcmVjb2dfbXVsdF9wYXR0ZXJuLCAibXVsdCIgfSwKICAgeyB2ZWN0 X3JlY29nX21peGVkX3NpemVfY29uZF9wYXR0ZXJuLCAibWl4ZWRfc2l6ZV9jb25kIiB9LAorICB7 IHZlY3RfcmVjb2dfZ2NvbmRfcGF0dGVybiwgImdjb25kIiB9LAogICB7IHZlY3RfcmVjb2dfYm9v bF9wYXR0ZXJuLCAiYm9vbCIgfSwKICAgLyogVGhpcyBtdXN0IGNvbWUgYmVmb3JlIG1hc2sgY29u dmVyc2lvbiwgYW5kIGluY2x1ZGVzIHRoZSBwYXJ0cwogICAgICBvZiBtYXNrIGNvbnZlcnNpb24g dGhhdCBhcmUgbmVlZGVkIGZvciBnYXRoZXIgYW5kIHNjYXR0ZXIKZGlmZiAtLWdpdCBhL2djYy90 cmVlLXZlY3Qtc3RtdHMuY2MgYi9nY2MvdHJlZS12ZWN0LXN0bXRzLmNjCmluZGV4IDU4MmM1ZTY3 OGZhZDgwMmQ2ZTc2MzAwZmUzYzkzOWI5ZjI5NzhmMTcuLjc2NjQ1MGNkODViNTVjZTRkZmQ0NTg3 OGM1ZGM0NGNkMDljNjg2ODEgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXZlY3Qtc3RtdHMuY2MKKysr IGIvZ2NjL3RyZWUtdmVjdC1zdG10cy5jYwpAQCAtMTI0ODksNyArMTI0ODksNyBAQCB2ZWN0b3Jp emFibGVfY29tcGFyaXNvbl8xICh2ZWNfaW5mbyAqdmluZm8sIHRyZWUgdmVjdHlwZSwKICAgdmVj PHRyZWU+IHZlY19vcHJuZHMwID0gdk5VTEw7CiAgIHZlYzx0cmVlPiB2ZWNfb3BybmRzMSA9IHZO VUxMOwogICB0cmVlIG1hc2tfdHlwZTsKLSAgdHJlZSBtYXNrOworICB0cmVlIG1hc2sgPSBOVUxM X1RSRUU7CiAKICAgaWYgKCFTVE1UX1ZJTkZPX1JFTEVWQU5UX1AgKHN0bXRfaW5mbykgJiYgIWJi X3ZpbmZvKQogICAgIHJldHVybiBmYWxzZTsKQEAgLTEyNjI5LDggKzEyNjI5LDkgQEAgdmVjdG9y aXphYmxlX2NvbXBhcmlzb25fMSAodmVjX2luZm8gKnZpbmZvLCB0cmVlIHZlY3R5cGUsCiAgIC8q IFRyYW5zZm9ybS4gICovCiAKICAgLyogSGFuZGxlIGRlZi4gICovCi0gIGxocyA9IGdpbXBsZV9h c3NpZ25fbGhzIChTVE1UX1ZJTkZPX1NUTVQgKHN0bXRfaW5mbykpOwotICBtYXNrID0gdmVjdF9j cmVhdGVfZGVzdGluYXRpb25fdmFyIChsaHMsIG1hc2tfdHlwZSk7CisgIGxocyA9IGdpbXBsZV9n ZXRfbGhzIChTVE1UX1ZJTkZPX1NUTVQgKHN0bXRfaW5mbykpOworICBpZiAobGhzKQorICAgIG1h c2sgPSB2ZWN0X2NyZWF0ZV9kZXN0aW5hdGlvbl92YXIgKGxocywgbWFza190eXBlKTsKIAogICB2 ZWN0X2dldF92ZWNfZGVmcyAodmluZm8sIHN0bXRfaW5mbywgc2xwX25vZGUsIG5jb3BpZXMsCiAJ CSAgICAgcmhzMSwgJnZlY19vcHJuZHMwLCB2ZWN0eXBlLApAQCAtMTI2NDQsNyArMTI2NDUsMTAg QEAgdmVjdG9yaXphYmxlX2NvbXBhcmlzb25fMSAodmVjX2luZm8gKnZpbmZvLCB0cmVlIHZlY3R5 cGUsCiAgICAgICBnaW1wbGUgKm5ld19zdG10OwogICAgICAgdmVjX3JoczIgPSB2ZWNfb3BybmRz MVtpXTsKIAotICAgICAgbmV3X3RlbXAgPSBtYWtlX3NzYV9uYW1lIChtYXNrKTsKKyAgICAgIGlm IChsaHMpCisJbmV3X3RlbXAgPSBtYWtlX3NzYV9uYW1lIChtYXNrKTsKKyAgICAgIGVsc2UKKwlu ZXdfdGVtcCA9IG1ha2VfdGVtcF9zc2FfbmFtZSAobWFza190eXBlLCBOVUxMLCAiY21wIik7CiAg ICAgICBpZiAoYml0b3AxID09IE5PUF9FWFBSKQogCXsKIAkgIG5ld19zdG10ID0gZ2ltcGxlX2J1 aWxkX2Fzc2lnbiAobmV3X3RlbXAsIGNvZGUsCkBAIC0xMjcyMyw2ICsxMjcyNywyMDcgQEAgdmVj dG9yaXphYmxlX2NvbXBhcmlzb24gKHZlY19pbmZvICp2aW5mbywKICAgcmV0dXJuIHRydWU7CiB9 CiAKKy8qIENoZWNrIHRvIHNlZSBpZiB0aGUgY3VycmVudCBlYXJseSBicmVhayBnaXZlbiBpbiBT VE1UX0lORk8gaXMgdmFsaWQgZm9yCisgICB2ZWN0b3JpemF0aW9uLiAgKi8KKworc3RhdGljIGJv b2wKK3ZlY3Rvcml6YWJsZV9lYXJseV9leGl0ICh2ZWNfaW5mbyAqdmluZm8sIHN0bXRfdmVjX2lu Zm8gc3RtdF9pbmZvLAorCQkJIGdpbXBsZV9zdG10X2l0ZXJhdG9yICpnc2ksIGdpbXBsZSAqKnZl Y19zdG10LAorCQkJIHNscF90cmVlIHNscF9ub2RlLCBzdG10X3ZlY3Rvcl9mb3JfY29zdCAqY29z dF92ZWMpCit7CisgIGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbyA9IGR5bl9jYXN0IDxsb29wX3Zl Y19pbmZvPiAodmluZm8pOworICBpZiAoIWxvb3BfdmluZm8KKyAgICAgIHx8ICFpc19hIDxnY29u ZCAqPiAoU1RNVF9WSU5GT19TVE1UIChzdG10X2luZm8pKSkKKyAgICByZXR1cm4gZmFsc2U7CisK KyAgaWYgKFNUTVRfVklORk9fREVGX1RZUEUgKHN0bXRfaW5mbykgIT0gdmVjdF9jb25kaXRpb25f ZGVmKQorICAgIHJldHVybiBmYWxzZTsKKworICBpZiAoIVNUTVRfVklORk9fUkVMRVZBTlRfUCAo c3RtdF9pbmZvKSkKKyAgICByZXR1cm4gZmFsc2U7CisKKyAgRFVNUF9WRUNUX1NDT1BFICgidmVj dG9yaXphYmxlX2Vhcmx5X2V4aXQiKTsKKworICBhdXRvIGNvZGUgPSBnaW1wbGVfY29uZF9jb2Rl IChTVE1UX1ZJTkZPX1NUTVQgKHN0bXRfaW5mbykpOworCisgIHRyZWUgdmVjdHlwZSA9IE5VTExf VFJFRTsKKyAgc2xwX3RyZWUgc2xwX29wMDsKKyAgdHJlZSBvcDA7CisgIGVudW0gdmVjdF9kZWZf dHlwZSBkdDA7CisgIGlmICghdmVjdF9pc19zaW1wbGVfdXNlICh2aW5mbywgc3RtdF9pbmZvLCBz bHBfbm9kZSwgMCwgJm9wMCwgJnNscF9vcDAsICZkdDAsCisJCQkgICAmdmVjdHlwZSkpCisgICAg eworICAgICAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorCSAgZHVtcF9wcmludGZfbG9jIChNU0df TUlTU0VEX09QVElNSVpBVElPTiwgdmVjdF9sb2NhdGlvbiwKKwkJCSAgICJ1c2Ugbm90IHNpbXBs ZS5cbiIpOworCXJldHVybiBmYWxzZTsKKyAgICB9CisKKyAgaWYgKCF2ZWN0eXBlKQorICAgIHJl dHVybiBmYWxzZTsKKworICBtYWNoaW5lX21vZGUgbW9kZSA9IFRZUEVfTU9ERSAodmVjdHlwZSk7 CisgIGludCBuY29waWVzOworCisgIGlmIChzbHBfbm9kZSkKKyAgICBuY29waWVzID0gMTsKKyAg ZWxzZQorICAgIG5jb3BpZXMgPSB2ZWN0X2dldF9udW1fY29waWVzIChsb29wX3ZpbmZvLCB2ZWN0 eXBlKTsKKworICB2ZWNfbG9vcF9tYXNrcyAqbWFza3MgPSAmTE9PUF9WSU5GT19NQVNLUyAobG9v cF92aW5mbyk7CisgIGJvb2wgbWFza2VkX2xvb3BfcCA9IExPT1BfVklORk9fRlVMTFlfTUFTS0VE X1AgKGxvb3BfdmluZm8pOworCisgIC8qIEFuYWx5emUgb25seS4gICovCisgIGlmICghdmVjX3N0 bXQpCisgICAgeworICAgICAgaWYgKGRpcmVjdF9vcHRhYl9oYW5kbGVyIChjYnJhbmNoX29wdGFi LCBtb2RlKSA9PSBDT0RFX0ZPUl9ub3RoaW5nKQorCXsKKwkgIGlmIChkdW1wX2VuYWJsZWRfcCAo KSkKKwkgICAgICBkdW1wX3ByaW50Zl9sb2MgKE1TR19NSVNTRURfT1BUSU1JWkFUSU9OLCB2ZWN0 X2xvY2F0aW9uLAorCQkJICAgICAgICJjYW4ndCB2ZWN0b3JpemUgZWFybHkgZXhpdCBiZWNhdXNl IHRoZSAiCisJCQkgICAgICAgInRhcmdldCBkb2Vzbid0IHN1cHBvcnQgZmxhZyBzZXR0aW5nIHZl Y3RvciAiCisJCQkgICAgICAgImNvbXBhcmlzb25zLlxuIik7CisJICByZXR1cm4gZmFsc2U7CisJ fQorCisgICAgICBpZiAobmNvcGllcyA+IDEKKwkgICYmIGRpcmVjdF9vcHRhYl9oYW5kbGVyIChp b3Jfb3B0YWIsIG1vZGUpID09IENPREVfRk9SX25vdGhpbmcpCisJeworCSAgaWYgKGR1bXBfZW5h YmxlZF9wICgpKQorCSAgICAgIGR1bXBfcHJpbnRmX2xvYyAoTVNHX01JU1NFRF9PUFRJTUlaQVRJ T04sIHZlY3RfbG9jYXRpb24sCisJCQkgICAgICAgImNhbid0IHZlY3Rvcml6ZSBlYXJseSBleGl0 IGJlY2F1c2UgdGhlICIKKwkJCSAgICAgICAidGFyZ2V0IGRvZXMgbm90IHN1cHBvcnQgYm9vbGVh biB2ZWN0b3IgT1IgZm9yICIKKwkJCSAgICAgICAidHlwZSAlVC5cbiIsIHZlY3R5cGUpOworCSAg cmV0dXJuIGZhbHNlOworCX0KKworICAgICAgaWYgKCF2ZWN0b3JpemFibGVfY29tcGFyaXNvbl8x ICh2aW5mbywgdmVjdHlwZSwgc3RtdF9pbmZvLCBjb2RlLCBnc2ksCisJCQkJICAgICAgdmVjX3N0 bXQsIHNscF9ub2RlLCBjb3N0X3ZlYykpCisJcmV0dXJuIGZhbHNlOworCisgICAgICBpZiAoTE9P UF9WSU5GT19DQU5fVVNFX1BBUlRJQUxfVkVDVE9SU19QIChsb29wX3ZpbmZvKSkKKwl7CisJICBp ZiAoZGlyZWN0X2ludGVybmFsX2ZuX3N1cHBvcnRlZF9wIChJRk5fVkNPTkRfTUFTS19MRU4sIHZl Y3R5cGUsCisJCQkJCSAgICAgIE9QVElNSVpFX0ZPUl9TUEVFRCkpCisJICAgIHJldHVybiBmYWxz ZTsKKwkgIGVsc2UKKwkgICAgdmVjdF9yZWNvcmRfbG9vcF9tYXNrIChsb29wX3ZpbmZvLCBtYXNr cywgbmNvcGllcywgdmVjdHlwZSwgTlVMTCk7CisJfQorCisKKyAgICAgIHJldHVybiB0cnVlOwor ICAgIH0KKworICAvKiBUcmFuZm9ybS4gICovCisKKyAgdHJlZSBuZXdfdGVtcCA9IE5VTExfVFJF RTsKKyAgZ2ltcGxlICpuZXdfc3RtdCA9IE5VTEw7CisKKyAgaWYgKGR1bXBfZW5hYmxlZF9wICgp KQorICAgIGR1bXBfcHJpbnRmX2xvYyAoTVNHX05PVEUsIHZlY3RfbG9jYXRpb24sICJ0cmFuc2Zv cm0gZWFybHktZXhpdC5cbiIpOworCisgIGlmICghdmVjdG9yaXphYmxlX2NvbXBhcmlzb25fMSAo dmluZm8sIHZlY3R5cGUsIHN0bXRfaW5mbywgY29kZSwgZ3NpLAorCQkJCSAgdmVjX3N0bXQsIHNs cF9ub2RlLCBjb3N0X3ZlYykpCisgICAgZ2NjX3VucmVhY2hhYmxlICgpOworCisgIGdpbXBsZSAq c3RtdCA9IFNUTVRfVklORk9fU1RNVCAoc3RtdF9pbmZvKTsKKyAgYmFzaWNfYmxvY2sgY29uZF9i YiA9IGdpbXBsZV9iYiAoc3RtdCk7CisgIGdpbXBsZV9zdG10X2l0ZXJhdG9yICBjb25kX2dzaSA9 IGdzaV9sYXN0X2JiIChjb25kX2JiKTsKKworICBhdXRvX3ZlYzx0cmVlPiBzdG10czsKKworICBp ZiAoc2xwX25vZGUpCisgICAgc3RtdHMuc2FmZV9zcGxpY2UgKFNMUF9UUkVFX1ZFQ19ERUZTIChz bHBfbm9kZSkpOworICBlbHNlCisgICAgeworICAgICAgYXV0byB2ZWNfc3RtdHMgPSBTVE1UX1ZJ TkZPX1ZFQ19TVE1UUyAoc3RtdF9pbmZvKTsKKyAgICAgIHN0bXRzLnJlc2VydmVfZXhhY3QgKHZl Y19zdG10cy5sZW5ndGggKCkpOworICAgICAgZm9yIChhdXRvIHN0bXQgOiB2ZWNfc3RtdHMpCisJ c3RtdHMucXVpY2tfcHVzaCAoZ2ltcGxlX2Fzc2lnbl9saHMgKHN0bXQpKTsKKyAgICB9CisKKyAg LyogRGV0ZXJtaW5lIGlmIHdlIG5lZWQgdG8gcmVkdWNlIHRoZSBmaW5hbCB2YWx1ZS4gICovCisg IGlmIChzdG10cy5sZW5ndGggKCkgPiAxKQorICAgIHsKKyAgICAgIC8qIFdlIGJ1aWxkIHRoZSBy ZWR1Y3Rpb25zIGluIGEgd2F5IHRvIG1haW50YWluIGFzIG11Y2ggcGFyYWxsZWxpc20gYXMKKwkg cG9zc2libGUuICAqLworICAgICAgYXV0b192ZWM8dHJlZT4gd29ya3NldCAoc3RtdHMubGVuZ3Ro ICgpKTsKKworICAgICAgLyogTWFzayB0aGUgc3RhdGVtZW50cyBhcyB3ZSBxdWV1ZSB0aGVtIHVw LiAgTm9ybWFsbHkgd2UgbG9vcCBvdmVyCisJIHZlY19udW0sICBidXQgc2luY2Ugd2UgaW5zcGVj dCB0aGUgZXhhY3QgcmVzdWx0cyBvZiB2ZWN0b3JpemF0aW9uCisJIHdlIGRvbid0IG5lZWQgdG8g YW5kIGluc3RlYWQgY2FuIGp1c3QgdXNlIHRoZSBzdG10cyB0aGVtc2VsdmVzLiAgKi8KKyAgICAg IGlmIChtYXNrZWRfbG9vcF9wKQorCWZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBzdG10cy5sZW5n dGggKCk7IGkrKykKKwkgIHsKKwkgICAgdHJlZSBzdG10X21hc2sKKwkgICAgICA9IHZlY3RfZ2V0 X2xvb3BfbWFzayAobG9vcF92aW5mbywgZ3NpLCBtYXNrcywgbmNvcGllcywgdmVjdHlwZSwKKwkJ CQkgICAgaSk7CisJICAgIHN0bXRfbWFzaworCSAgICAgID0gcHJlcGFyZV92ZWNfbWFzayAobG9v cF92aW5mbywgVFJFRV9UWVBFIChzdG10X21hc2spLCBzdG10X21hc2ssCisJCQkJICBzdG10c1tp XSwgJmNvbmRfZ3NpKTsKKwkgICAgd29ya3NldC5xdWlja19wdXNoIChzdG10X21hc2spOworCSAg fQorICAgICAgZWxzZQorCXdvcmtzZXQuc3BsaWNlIChzdG10cyk7CisKKyAgICAgIHdoaWxlICh3 b3Jrc2V0Lmxlbmd0aCAoKSA+IDEpCisJeworCSAgbmV3X3RlbXAgPSBtYWtlX3RlbXBfc3NhX25h bWUgKHZlY3R5cGUsIE5VTEwsICJ2ZXhpdF9yZWR1YyIpOworCSAgdHJlZSBhcmcwID0gd29ya3Nl dC5wb3AgKCk7CisJICB0cmVlIGFyZzEgPSB3b3Jrc2V0LnBvcCAoKTsKKwkgIG5ld19zdG10ID0g Z2ltcGxlX2J1aWxkX2Fzc2lnbiAobmV3X3RlbXAsIEJJVF9JT1JfRVhQUiwgYXJnMCwgYXJnMSk7 CisJICB2ZWN0X2ZpbmlzaF9zdG10X2dlbmVyYXRpb24gKGxvb3BfdmluZm8sIHN0bXRfaW5mbywg bmV3X3N0bXQsCisJCQkJICAgICAgICZjb25kX2dzaSk7CisJICB3b3Jrc2V0LnF1aWNrX2luc2Vy dCAoMCwgbmV3X3RlbXApOworCX0KKyAgICB9CisgIGVsc2UKKyAgICB7CisgICAgICBuZXdfdGVt cCA9IHN0bXRzWzBdOworICAgICAgaWYgKG1hc2tlZF9sb29wX3ApCisJeworCSAgdHJlZSBtYXNr CisJICAgID0gdmVjdF9nZXRfbG9vcF9tYXNrIChsb29wX3ZpbmZvLCBnc2ksIG1hc2tzLCBuY29w aWVzLCB2ZWN0eXBlLCAwKTsKKwkgIG5ld190ZW1wID0gcHJlcGFyZV92ZWNfbWFzayAobG9vcF92 aW5mbywgVFJFRV9UWVBFIChtYXNrKSwgbWFzaywKKwkJCQkgICAgICAgbmV3X3RlbXAsICZjb25k X2dzaSk7CisJfQorICAgIH0KKworICBnY2NfYXNzZXJ0IChuZXdfdGVtcCk7CisKKyAgLyogTm93 IGJ1aWxkIHRoZSBuZXcgY29uZGl0aW9uYWwuICBQYXR0ZXJuIGdpbXBsZV9jb25kcyBnZXQgZHJv cHBlZCBkdXJpbmcKKyAgICAgY29kZWdlbiBzbyB3ZSBtdXN0IHJlcGxhY2UgdGhlIG9yaWdpbmFs IGluc24uICAqLworICBzdG10ID0gU1RNVF9WSU5GT19TVE1UICh2ZWN0X29yaWdfc3RtdCAoc3Rt dF9pbmZvKSk7CisgIGdjb25kICpjb25kX3N0bXQgPSBhc19hIDxnY29uZCAqPihzdG10KTsKKyAg LyogV2hlbiB2ZWN0b3JpemluZyB3ZSBhc3N1bWUgdGhhdCBpZiB0aGUgYnJhbmNoIGVkZ2UgaXMg dGFrZW4gdGhhdCB3ZSdyZQorICAgICBleGl0aW5nIHRoZSBsb29wLiAgVGhpcyBpcyBub3QgaG93 ZXZlciBhbHdheXMgdGhlIGNhc2UgYXMgdGhlIGNvbXBpbGVyIHdpbGwKKyAgICAgcmV3cml0ZSBj b25kaXRpb25zIHRvIGFsd2F5cyBiZSBhIGNvbXBhcmlzb24gYWdhaW5zdCAwLiAgVG8gZG8gdGhp cyBpdAorICAgICBzb21ldGltZXMgZmxpcHMgdGhlIGVkZ2VzLiAgVGhpcyBpcyBmaW5lIGZvciBz Y2FsYXIsICBidXQgZm9yIHZlY3RvciB3ZQorICAgICB0aGVuIGhhdmUgdG8gZmxpcCB0aGUgdGVz dCwgYXMgd2UncmUgc3RpbGwgYXNzdW1pbmcgdGhhdCBpZiB5b3UgdGFrZSB0aGUKKyAgICAgYnJh bmNoIGVkZ2UgdGhhdCB3ZSBmb3VuZCB0aGUgZXhpdCBjb25kaXRpb24uICAqLworICBhdXRvIG5l d19jb2RlID0gTkVfRVhQUjsKKyAgdHJlZSBjc3QgPSBidWlsZF96ZXJvX2NzdCAodmVjdHlwZSk7 CisgIGlmIChmbG93X2JiX2luc2lkZV9sb29wX3AgKExPT1BfVklORk9fTE9PUCAobG9vcF92aW5m byksCisJCQkgICAgIEJSQU5DSF9FREdFIChnaW1wbGVfYmIgKGNvbmRfc3RtdCkpLT5kZXN0KSkK KyAgICB7CisgICAgICBuZXdfY29kZSA9IEVRX0VYUFI7CisgICAgICBjc3QgPSBidWlsZF9taW51 c19vbmVfY3N0ICh2ZWN0eXBlKTsKKyAgICB9CisKKyAgZ2ltcGxlX2NvbmRfc2V0X2NvbmRpdGlv biAoY29uZF9zdG10LCBuZXdfY29kZSwgbmV3X3RlbXAsIGNzdCk7CisgIHVwZGF0ZV9zdG10IChz dG10KTsKKworICBpZiAoc2xwX25vZGUpCisgICAgU0xQX1RSRUVfVkVDX0RFRlMgKHNscF9ub2Rl KS50cnVuY2F0ZSAoMCk7CisgICBlbHNlCisgICAgU1RNVF9WSU5GT19WRUNfU1RNVFMgKHN0bXRf aW5mbykudHJ1bmNhdGUgKDApOworCisgIGlmICghc2xwX25vZGUpCisgICAgKnZlY19zdG10ID0g c3RtdDsKKworICByZXR1cm4gdHJ1ZTsKK30KKwogLyogSWYgU0xQX05PREUgaXMgbm9ubnVsbCwg cmV0dXJuIHRydWUgaWYgdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uCiAgICBjYW4gaGFuZGxl IGFsbCBsaXZlIHN0YXRlbWVudHMgaW4gdGhlIG5vZGUuICBPdGhlcndpc2UgcmV0dXJuIHRydWUK ICAgIGlmIFNUTVRfSU5GTyBpcyBub3QgbGl2ZSBvciBpZiB2ZWN0b3JpemFibGVfbGl2ZV9vcGVy YXRpb24gY2FuIGhhbmRsZSBpdC4KQEAgLTEyOTQ5LDcgKzEzMTU0LDkgQEAgdmVjdF9hbmFseXpl X3N0bXQgKHZlY19pbmZvICp2aW5mbywKIAkgIHx8IHZlY3Rvcml6YWJsZV9sY19waGkgKGFzX2Eg PGxvb3BfdmVjX2luZm8+ICh2aW5mbyksCiAJCQkJICBzdG10X2luZm8sIE5VTEwsIG5vZGUpCiAJ ICB8fCB2ZWN0b3JpemFibGVfcmVjdXJyIChhc19hIDxsb29wX3ZlY19pbmZvPiAodmluZm8pLAot CQkJCSAgIHN0bXRfaW5mbywgTlVMTCwgbm9kZSwgY29zdF92ZWMpKTsKKwkJCQkgICBzdG10X2lu Zm8sIE5VTEwsIG5vZGUsIGNvc3RfdmVjKQorCSAgfHwgdmVjdG9yaXphYmxlX2Vhcmx5X2V4aXQg KHZpbmZvLCBzdG10X2luZm8sIE5VTEwsIE5VTEwsIG5vZGUsCisJCQkJICAgICAgY29zdF92ZWMp KTsKICAgZWxzZQogICAgIHsKICAgICAgIGlmIChiYl92aW5mbykKQEAgLTEyOTcyLDcgKzEzMTc5 LDEwIEBAIHZlY3RfYW5hbHl6ZV9zdG10ICh2ZWNfaW5mbyAqdmluZm8sCiAJCQkJCSBOVUxMLCBO VUxMLCBub2RlLCBjb3N0X3ZlYykKIAkgICAgICB8fCB2ZWN0b3JpemFibGVfY29tcGFyaXNvbiAo dmluZm8sIHN0bXRfaW5mbywgTlVMTCwgTlVMTCwgbm9kZSwKIAkJCQkJICBjb3N0X3ZlYykKLQkg ICAgICB8fCB2ZWN0b3JpemFibGVfcGhpICh2aW5mbywgc3RtdF9pbmZvLCBOVUxMLCBub2RlLCBj b3N0X3ZlYykpOworCSAgICAgIHx8IHZlY3Rvcml6YWJsZV9waGkgKHZpbmZvLCBzdG10X2luZm8s IE5VTEwsIG5vZGUsIGNvc3RfdmVjKQorCSAgICAgIHx8IHZlY3Rvcml6YWJsZV9lYXJseV9leGl0 ICh2aW5mbywgc3RtdF9pbmZvLCBOVUxMLCBOVUxMLCBub2RlLAorCQkJCQkgIGNvc3RfdmVjKSk7 CisKICAgICB9CiAKICAgaWYgKG5vZGUpCkBAIC0xMzEzMSw2ICsxMzM0MSwxMiBAQCB2ZWN0X3Ry YW5zZm9ybV9zdG10ICh2ZWNfaW5mbyAqdmluZm8sCiAgICAgICBnY2NfYXNzZXJ0IChkb25lKTsK ICAgICAgIGJyZWFrOwogCisgICAgY2FzZSBsb29wX2V4aXRfY3RybF92ZWNfaW5mb190eXBlOgor ICAgICAgZG9uZSA9IHZlY3Rvcml6YWJsZV9lYXJseV9leGl0ICh2aW5mbywgc3RtdF9pbmZvLCBn c2ksICZ2ZWNfc3RtdCwKKwkJCQkgICAgICBzbHBfbm9kZSwgTlVMTCk7CisgICAgICBnY2NfYXNz ZXJ0IChkb25lKTsKKyAgICAgIGJyZWFrOworCiAgICAgZGVmYXVsdDoKICAgICAgIGlmICghU1RN VF9WSU5GT19MSVZFX1AgKHN0bXRfaW5mbykpCiAJewpAQCAtMTQzMjEsNiArMTQ1MzcsMTQgQEAg dmVjdF9nZXRfdmVjdG9yX3R5cGVzX2Zvcl9zdG10ICh2ZWNfaW5mbyAqdmluZm8sIHN0bXRfdmVj X2luZm8gc3RtdF9pbmZvLAogICAgIH0KICAgZWxzZQogICAgIHsKKyAgICAgIC8qIElmIHdlIGdv dCBoZXJlIHdpdGggYSBnY29uZCBpdCBtZWFucyB0aGF0IHRoZSB0YXJnZXQgaGFkIG5vIGF2YWls YWJsZSB2ZWN0b3IKKwkgbW9kZSBmb3IgdGhlIHNjYWxhciB0eXBlLiAgV2UgY2FuJ3QgdmVjdG9y aXplIHNvIGFib3J0LiAgKi8KKyAgICAgIGlmIChpc19hIDxnY29uZCAqPiAoc3RtdCkpCisJcmV0 dXJuIG9wdF9yZXN1bHQ6OmZhaWx1cmVfYXQgKHN0bXQsCisJCQkJICAgICAgICJub3QgdmVjdG9y aXplZDoiCisJCQkJICAgICAgICIgdW5zdXBwb3J0ZWQgZGF0YS10eXBlIGZvciBnY29uZCAlVFxu IiwKKwkJCQkgICAgICAgc2NhbGFyX3R5cGUpOworCiAgICAgICBpZiAoZGF0YV9yZWZlcmVuY2Ug KmRyID0gU1RNVF9WSU5GT19EQVRBX1JFRiAoc3RtdF9pbmZvKSkKIAlzY2FsYXJfdHlwZSA9IFRS RUVfVFlQRSAoRFJfUkVGIChkcikpOwogICAgICAgZWxzZSBpZiAoZ2ltcGxlX2NhbGxfaW50ZXJu YWxfcCAoc3RtdCwgSUZOX01BU0tfU1RPUkUpKQo= --_002_VI1PR08MB5325688E37E6A409E577E00EFF8DAVI1PR08MB5325eurp_--