From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR03-AM7-obe.outbound.protection.outlook.com (mail-am7eur03on2067.outbound.protection.outlook.com [40.107.105.67]) by sourceware.org (Postfix) with ESMTPS id F1F56385840B for ; Wed, 6 Dec 2023 04:22:00 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org F1F56385840B 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 F1F56385840B Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=40.107.105.67 ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1701836524; cv=pass; b=UbkrBVr3wKafnIy4QNtyWWR/qziGQviQxCLWWCtPgiLOaLR4QfRM0BhSmQYLQ8p8AiFF0dcMv2dOLzmHr20Nh3k6dXlL9hvGOc1z6che8Q7zsqs5YUettp9TbQRgQwUq3lfkujlK+A3xhvxbkuJwjQUbJJPxDf5vetY7wAz4WtQ= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1701836524; c=relaxed/simple; bh=V8emSvs/qPBFZ4uIPSpeMZtAZrUKaiG+ZAwyp1ly+y8=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=W0OdwYT1fNBy2o1nt3gmX3lOImdy2JLDndZ/QooZiiTVkIy1N9I/g64ARvj3BUoZdKUFPlQelkKM7GwDu3ELk9C1S8WyM30CUYtyr5mNinw+KfBgJF4F7hgzoyc/SuLNXB7lcs9HIMc+/1XW0id+scfRglEWGJj9Ks+NdiGg+qc= ARC-Authentication-Results: i=3; server2.sourceware.org ARC-Seal: i=2; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=pass; b=VJrBEyxSmt8nnk0JmIRcUzh8cnpvAKAdfFRiMRj7OVdx7XmNGHOdoweiXdwaO6RdYgxLV4+sHQIdPcrDjwa4NgrpePA/A/eojBPnvRI0lufwAIk1h4RL5aAfWL4VH4bOUR47IZdIc/pPTQOIWq09RRt1amuNkFu017dmC+0OAw2px+qJ+AYsewFIKvrlVM7522sLOm7F8xSd7Y1d6kPoqb5EGB/DzStP1Y+P3uF7nIifzjaakl8CmoW372oko6XFf2Vw4c3fn5DPigDxPFjrX2BT2Faoemo3GWytpQ3/MXgzU6sYvrjumH0c8jYvil3R8nIWxxDSlVvuG0Ph9h1KxA== 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=RmGqVVfEzS6TCbjUNas4+z81uKIplvVz06eKJ5qIfY8=; b=H6UOHYPIY5ygk1n5IJCHCkEWevNAkOJXDzRAtQYqibvg+04yOpiuNznDwC26wXhhWSVTvhhavZBuf27VM3CQac7Q6ltAIUw1ISRQPXf6y1tJI6VsKQ+hV8XBMLYjug/5wC28hQNRzKORkwQ4jCkQK0JL2OhiBdJd6G9P9W1w+sP0eo1PC6pTYdU1DJ/dYPqeEXK/HXOttI7GXBa+MOE3bh9gaFWlNGWd5fSLbEOXxU6x+vfpIcQNB8gAK1ftvU5EC5MIYPOSiaAlC/Qgim+/lPi1rzOdLq6XpF+YWZg3Dr9qvr4s++xNRtitH4OnVwt7xjc6sOS4WSVKtw8+mafYZg== 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=RmGqVVfEzS6TCbjUNas4+z81uKIplvVz06eKJ5qIfY8=; b=y2wxSHvTG1vGwFxACHH2oEu8T674CK+X7+iUMIcOlmC9oQZ7Vc2fjWbL5AWj1qVgi8eN0vrh72Tj5SMwNawBM1+FVT5vwwgyCsbMLKMEDFXcrTErgEdXumCsB/HLwak00gfrN5H6NE1EaA/5eCM+UlVGcq4gVjDuYEiyNHir4dQ= Received: from AM7PR02CA0002.eurprd02.prod.outlook.com (2603:10a6:20b:100::12) by PR3PR08MB5561.eurprd08.prod.outlook.com (2603:10a6:102:8c::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7046.34; Wed, 6 Dec 2023 04:21:46 +0000 Received: from AMS0EPF0000019D.eurprd05.prod.outlook.com (2603:10a6:20b:100:cafe::a1) by AM7PR02CA0002.outlook.office365.com (2603:10a6:20b:100::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7046.33 via Frontend Transport; Wed, 6 Dec 2023 04:21:45 +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 AMS0EPF0000019D.mail.protection.outlook.com (10.167.16.249) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7068.20 via Frontend Transport; Wed, 6 Dec 2023 04:21:45 +0000 Received: ("Tessian outbound 385ad2f98d71:v228"); Wed, 06 Dec 2023 04:21:45 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: 00661edb4b7b9709 X-CR-MTA-TID: 64aa7808 Received: from 5d702432df86.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id 77175AFE-40F8-4544-B4F9-57C4E94A3ACC.1; Wed, 06 Dec 2023 04:21:38 +0000 Received: from EUR04-VI1-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id 5d702432df86.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Wed, 06 Dec 2023 04:21:38 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=Qxe+GxAF7R+RiHapRvwvBChupQHlAr6T+QD8PJUIocrZccZdgE1Idh2yvUhzLKswdLt08n4I55sGMupM1nwHpryD//e0X56b//oS2c+9JqQ/9QpqKpHPzIqdgvmWFI9Pxf7QoSRObl4yiTAF6w1sfTTcJvEnlqIm3Mq7TGkcV579iqRhIhLmeJ8QIkTL7IkYzZF1bZAvgH8OTPPoHt3g7sKzMzn0+qTUePKzVaKsIdTxhcLBWIQHtoy/i3We4/HVwEGqtY29UlYYQ29xadpuZX3d1rKwlbDyikvgEEVv46lErWULj5vJu/U6h2CqxYKtXWg0GsIDvY6bJUdzCdNYZQ== 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=RmGqVVfEzS6TCbjUNas4+z81uKIplvVz06eKJ5qIfY8=; b=Usq5VUTMFMOoGNYzdvRVhHOyDAx3SaPB/AWpz7+O/8Bbr2nlX3bDSvWxT7JAUeilyKK7Vl5BJs//FQdXE/HnkKH3lWZc8woc4uCdGvD9qlvnoBgmgLBX7OufGGprOR8VDM9oAoSQYk6tU8mEwufT0FS9rRQPiHvAqVHxsm4nX54Ies7g6YjTwK4QQpbfC8LXv1DwqFfKMyP09rCxzsb1p1Yt3wVQELPrLCUV/foySOvk6MAYXn+1f9XSS5gSqkEE2AOsasPERgfwJJn6ZaXfs3JtaFZAgBxhv2LQ9IYBxqlx4dEiPvol7nKnZmK518GjfLpNGX86F64e9dKsQiowmg== 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=RmGqVVfEzS6TCbjUNas4+z81uKIplvVz06eKJ5qIfY8=; b=y2wxSHvTG1vGwFxACHH2oEu8T674CK+X7+iUMIcOlmC9oQZ7Vc2fjWbL5AWj1qVgi8eN0vrh72Tj5SMwNawBM1+FVT5vwwgyCsbMLKMEDFXcrTErgEdXumCsB/HLwak00gfrN5H6NE1EaA/5eCM+UlVGcq4gVjDuYEiyNHir4dQ= Received: from VI1PR08MB5325.eurprd08.prod.outlook.com (2603:10a6:803:13e::17) by PAXPR08MB6621.eurprd08.prod.outlook.com (2603:10a6:102:dc::17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7046.34; Wed, 6 Dec 2023 04:21:34 +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.7046.034; Wed, 6 Dec 2023 04:21:34 +0000 From: Tamar Christina To: Richard Biener CC: "gcc-patches@gcc.gnu.org" , nd , "jlaw@ventanamicro.com" Subject: RE: [PATCH 8/21]middle-end: update vectorizable_live_reduction with support for multiple exits and different exits Thread-Topic: [PATCH 8/21]middle-end: update vectorizable_live_reduction with support for multiple exits and different exits Thread-Index: AQHaEIRfThgW3PldRkqGsgaI/BlARbB6jVXQgADknwCAAAlP4IABYGMAgAb7u4CABYbB4IAAM6IAgAVS2JCAAopggIAAA/AggAGM2gCACNOBUA== Date: Wed, 6 Dec 2023 04:21:34 +0000 Message-ID: References: <3p13osn9-n4qp-1s6r-545q-r1or36n8s23q@fhfr.qr> <024530p2-q575-onnr-5696-sq90p6520o29@fhfr.qr> In-Reply-To: <024530p2-q575-onnr-5696-sq90p6520o29@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_|PAXPR08MB6621:EE_|AMS0EPF0000019D:EE_|PR3PR08MB5561:EE_ X-MS-Office365-Filtering-Correlation-Id: 22c5523f-f243-45ee-f51b-08dbf612dbbd 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: ybccaA8zNhqkD+ylJXU0yT6LMz4f7nOIRw7UlF6ZdYeIGIDzX+PxQySOerRoFtporWxE7eTH38a2YqwNAt82k6cX9xAX1GhrK7KXK51oHCJmelFsWPv1PvQILLLWnVbgK3NJ/a4NQY+VYyAfvIrL1NG3WfVRN3qUavJZR3lX69cQhmJNSu22U7T3ljaeVnpOK/o1fK1hk9o0AhaLTaKMpg8fH0I6CSOxAjg91hK0SygenM87QRQDFxJjdOrisMA1Np2tprATRlzpNDaWZuQgGTTh+DUnkjuFZV9QJFCuQ14vrx/brs0He3ihN/E6LF+hxCHRZPd/+TNK6sHYmh9yi3nDEcuAfe9YaxOVOXsNoUO/QDYypq8Yvmg4QoZAr4F4stt84f89HJIdAywrgV9TIhPYIsLQ7KPQaKxWy52xCozn00kWKvtuxBgRJF3S+e82TWl90O48GTlb/h/srGWxMtrmbtNNAxOHJ8ba5vS0f9F1PSzuUNq2IJ2kaivrFs7olFobLu1IkhLwkV+he1iURVfIRf3JHCj7AT/SeUVfTc9TUzTj1pOUkEhO4bf+mFvcDHCs91xSEg/1/VtEnf/9w9ZX/BCnIrK4vYD3OUczxBv2FDZq6jH1efGcZcVceWNk 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)(366004)(136003)(39860400002)(396003)(346002)(376002)(230922051799003)(64100799003)(451199024)(1800799012)(186009)(30864003)(52536014)(2906002)(5660300002)(15650500001)(38070700009)(33656002)(41300700001)(86362001)(478600001)(6506007)(7696005)(9686003)(71200400001)(55016003)(38100700002)(122000001)(83380400001)(26005)(8676002)(4326008)(8936002)(6916009)(76116006)(66556008)(66946007)(99936003)(66476007)(66446008)(54906003)(64756008)(316002)(559001)(579004);DIR:OUT;SFP:1101; Content-Type: multipart/mixed; boundary="_002_VI1PR08MB53250A8BF46DFA507C3E9338FF84AVI1PR08MB5325eurp_" MIME-Version: 1.0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXPR08MB6621 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: AMS0EPF0000019D.eurprd05.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: 418997c1-26db-4ab0-9e40-08dbf612d4ea X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: ZlhK8EwZ0GZTMhDjk92/D0FQVDQxOMkU7QP2myX2U105OP/seaCku2MFb1fQ2u69ZshlFWCsIHuiOzZQNQMA5zhkZRNWgJTHcP592XFPU5NVjbCU+pImPryBXVHDF03Kwdz4Gl+u2KWfYEEp9BEFvrR52SpYK14mwHwVefKxz7giYpiLtYCpGmoSgMTDgP7qdax8UPoWfdZ8y8Sl7sVHMavuKr8P4ZBVL+vpzuRZlVV2JDpQgDfP9QZ8ncPPMVFurjzi0rqs0JQ2i7uCU3yvd0mKbc/XUyKFRqNE8iGYPqLWacuSVVPBsE6u7+VB+pBECq4J9VcRgPNeG7Y/naoxfVw7E/bbNSbiN/FITwJI81HfhTQm3T0qd9PO3fiIhBa11oVYcPYjSdSxm8uxOEPCriieSrVmc+71TY54XqyMnLADlTd0lMr5y58V7MnWZ5fSPqVeMHuivvSVy08j+cKtP3/GnBhqYa26k02OE1z8nVuOQZnIcGSLpmet5G7qHifIy6Ze0pcpvJdDt2MM0XPTCuSRFw/WGW7NdPPqrVMogRAtiahE1CFwMjUlpAicLSjARdY/um5iWeDvkfuWwYYfQEvJe+cnTW4Tqn50FdxKlXReT7R5BdUPAnigVeJGOhXXRipqbAMFEm9X8x7Mpr5ov/Bz4/XSMz0VgPS1YDF99rS/xddVcOg5ZJMgDGxWgRYp2WcG/B6f3LlwPawgorPNWyh4/dS6KfacOMMAjEBHa9XBzwIfy5sR3DjdX367vGMo 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)(396003)(136003)(39860400002)(346002)(376002)(230922051799003)(64100799003)(451199024)(1800799012)(82310400011)(186009)(40470700004)(46966006)(36840700001)(40460700003)(15650500001)(82740400003)(2906002)(52536014)(5660300002)(235185007)(30864003)(33656002)(86362001)(41300700001)(7696005)(6506007)(478600001)(40480700001)(9686003)(36860700001)(55016003)(83380400001)(26005)(107886003)(47076005)(336012)(8676002)(4326008)(6862004)(8936002)(99936003)(81166007)(70586007)(70206006)(356005)(54906003)(316002);DIR:OUT;SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 06 Dec 2023 04:21:45.8935 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 22c5523f-f243-45ee-f51b-08dbf612dbbd 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: AMS0EPF0000019D.eurprd05.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: PR3PR08MB5561 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_VI1PR08MB53250A8BF46DFA507C3E9338FF84AVI1PR08MB5325eurp_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable > > > is the exit edge you are looking for without iterating over all loop = exits. > > > > > > > + gimple *tmp_vec_stmt =3D vec_stmt; > > > > + tree tmp_vec_lhs =3D vec_lhs; > > > > + tree tmp_bitstart =3D bitstart; > > > > + /* For early exit where the exit is not in the BB that leads > > > > + to the latch then we're restarting the iteration in the > > > > + scalar loop. So get the first live value. */ > > > > + restart_loop =3D restart_loop || exit_e !=3D main_e; > > > > + if (restart_loop) > > > > + { > > > > + tmp_vec_stmt =3D STMT_VINFO_VEC_STMTS (stmt_info)[0]; > > > > + tmp_vec_lhs =3D gimple_get_lhs (tmp_vec_stmt); > > > > + tmp_bitstart =3D build_zero_cst (TREE_TYPE (bitstart)); > > > > > > Hmm, that gets you the value after the first iteration, not the one b= efore which > > > would be the last value of the preceeding vector iteration? > > > (but we don't keep those, we'd need a PHI) > > > > I don't fully follow. The comment on top of this hunk under if (loop_v= info) states > > that lhs should be pointing to a PHI. > > > > When I inspect the statement I see > > > > i_14 =3D PHI > > > > so i_14 is the value at the start of the current iteration. If we're c= oming from the > > header 0, otherwise i_11 which is the value of the previous iteration? > > > > The peeling code explicitly leaves i_14 in the merge block and not i_11= for this > exact reason. > > So I'm confused, my understanding is that we're already *at* the right = PHI. > > > > Is it perhaps that you thought we put i_11 here for the early exits? In= which case > > Yes I'd agree that that would be wrong, and there we would have had to = look at > > The defs, but i_11 is the def. > > > > I already kept this in mind and leveraged peeling to make this part eas= ier. > > i_11 is used in the main exit and i_14 in the early one. >=20 > I think the important detail is that this code is only executed for > vect_induction_defs which are indeed PHIs and so we're sure the > value live is before any modification so fine to feed as initial > value for the PHI in the epilog. >=20 > Maybe we can assert the def type here? We can't assert because until cfg cleanup the dead value is still seen and = still vectorized. That said I've added a guard here. We vectorize the non-induc= tion value as normal now and if it's ever used it'll fail. >=20 > > > > > > Why again do we need (non-induction) live values from the vector loop= to the > > > epilogue loop again? > > > > They can appear as the result value of the main exit. > > > > e.g. in testcase (vect-early-break_17.c) > > > > #define N 1024 > > unsigned vect_a[N]; > > unsigned vect_b[N]; > > > > unsigned test4(unsigned x) > > { > > unsigned ret =3D 0; > > for (int i =3D 0; i < N; i++) > > { > > vect_b[i] =3D x + i; > > if (vect_a[i] > x) > > return vect_a[i]; > > vect_a[i] =3D x; > > ret =3D vect_a[i] + vect_b[i]; > > } > > return ret; > > } > > > > The only situation they can appear in the as an early-break is when > > we have a case where main exit !=3D latch connected exit. > > > > However in these cases they are unused, and only there because > > normally you would have exited (i.e. there was a return) but the > > vector loop needs to start over so we ignore it. > > > > These happen in testcase vect-early-break_74.c and > > vect-early-break_78.c >=20 > Hmm, so in that case their value is incorrect (but doesn't matter, > we ignore it)? >=20 Correct, they're placed there due to exit redirection, but in these inverte= d testcases where we've peeled the vector iteration you can't ever skip the epilogue. So they are guaranteed not to be used. > > > > + gimple_stmt_iterator exit_gsi; > > > > + tree new_tree > > > > + =3D vectorizable_live_operation_1 (loop_vinfo, stmt_info, > > > > + exit_e, vectype, ncopies, > > > > + slp_node, bitsize, > > > > + tmp_bitstart, tmp_vec_lhs, > > > > + lhs_type, restart_loop, > > > > + &exit_gsi); > > > > + > > > > + /* Use the empty block on the exit to materialize the new > > > stmts > > > > + so we can use update the PHI here. */ > > > > + if (gimple_phi_num_args (use_stmt) =3D=3D 1) > > > > + { > > > > + auto gsi =3D gsi_for_stmt (use_stmt); > > > > + remove_phi_node (&gsi, false); > > > > + tree lhs_phi =3D gimple_phi_result (use_stmt); > > > > + gimple *copy =3D gimple_build_assign (lhs_phi, new_tree); > > > > + gsi_insert_before (&exit_gsi, copy, GSI_SAME_STMT); > > > > + } > > > > + else > > > > + SET_PHI_ARG_DEF (use_stmt, dest_e->dest_idx, new_tree); > > > > > > if the else case works, why not use it always? > > > > Because it doesn't work for main exit. The early exit have a intermedi= ate block > > that is used to generate the statements on, so for them we are fine upd= ating the > > use in place. > > > > The main exits don't. and so the existing trick the vectorizer uses is = to materialize > > the statements in the same block and then dissolves the phi node. How= ever you > > can't do that for the early exit because the phi node isn't singular. >=20 > But if the PHI has a single arg you can replace that? By making a > copy stmt from it don't you break LC SSA? >=20 Yeah, what the existing code is sneakily doing is this: It has to vectorize x =3D PHI y gets vectorized a z but x =3D PHI z =3D ... would be invalid, so what it does, since it doesn't have a predecessor not= e to place stuff in, it'll do z =3D ... x =3D z and removed the PHI. The PHI was only placed there for vectorization so it= 's not needed after this point. It's also for this reason why the code passes around a g= impe_seq since it needs to make sure it gets the order right when inserting statements. Bootstrapped Regtested on aarch64-none-linux-gnu and no issues. Ok for master? Thanks, Tamar gcc/ChangeLog: * tree-vect-loop.cc (vectorizable_live_operation, vectorizable_live_operation_1): Support early exits. (can_vectorize_live_stmts): Call vectorizable_live_operation for non-live inductions or reductions. (find_connected_edge, vect_get_vect_def): New. (vect_create_epilog_for_reduction): Support reductions in early break. * tree-vect-stmts.cc (perm_mask_for_reverse): Expose. (vect_stmt_relevant_p): Mark all inductions when early break as being live. * tree-vectorizer.h (perm_mask_for_reverse): Expose. --- inline copy of patch --- diff --git a/gcc/tree-vect-loop-manip.cc b/gcc/tree-vect-loop-manip.cc index f38cc47551488525b15c2be758cac8291dbefb3a..4e48217a31e59318c2ea8e5ab63= b06ba19840cbd 100644 --- a/gcc/tree-vect-loop-manip.cc +++ b/gcc/tree-vect-loop-manip.cc @@ -3346,6 +3346,7 @@ vect_do_peeling (loop_vec_info loop_vinfo, tree niter= s, tree nitersm1, bb_before_epilog->count =3D single_pred_edge (bb_before_epilog)->coun= t (); bb_before_epilog =3D loop_preheader_edge (epilog)->src; } + /* If loop is peeled for non-zero constant times, now niters refers = to orig_niters - prolog_peeling, it won't overflow even the orig_niters overflows. */ diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc index df5e1d28fac2ce35e71decdec0d8e31fb75557f5..2f922b42f6d567dfd5da9b276b1= c9d37bc681876 100644 --- a/gcc/tree-vect-loop.cc +++ b/gcc/tree-vect-loop.cc @@ -5831,6 +5831,34 @@ vect_create_partial_epilog (tree vec_def, tree vecty= pe, code_helper code, return new_temp; } =20 +/* Retrieves the definining statement to be used for a reduction. + For MAIN_EXIT_P we use the current VEC_STMTs and otherwise we look at + the reduction definitions. */ + +tree +vect_get_vect_def (stmt_vec_info reduc_info, slp_tree slp_node, + slp_instance slp_node_instance, bool main_exit_p, unsigned i, + vec &vec_stmts) +{ + tree def; + + if (slp_node) + { + if (!main_exit_p) + slp_node =3D slp_node_instance->reduc_phis; + def =3D vect_get_slp_vect_def (slp_node, i); + } + else + { + if (!main_exit_p) + reduc_info =3D STMT_VINFO_REDUC_DEF (vect_orig_stmt (reduc_info)); + vec_stmts =3D STMT_VINFO_VEC_STMTS (reduc_info); + def =3D gimple_get_lhs (vec_stmts[0]); + } + + return def; +} + /* Function vect_create_epilog_for_reduction =20 Create code at the loop-epilog to finalize the result of a reduction @@ -5842,6 +5870,8 @@ vect_create_partial_epilog (tree vec_def, tree vectyp= e, code_helper code, SLP_NODE_INSTANCE is the SLP node instance containing SLP_NODE REDUC_INDEX says which rhs operand of the STMT_INFO is the reduction ph= i (counting from 0) + LOOP_EXIT is the edge to update in the merge block. In the case of a s= ingle + exit this edge is always the main loop exit. =20 This function: 1. Completes the reduction def-use cycles. @@ -5882,7 +5912,8 @@ static void vect_create_epilog_for_reduction (loop_vec_info loop_vinfo, stmt_vec_info stmt_info, slp_tree slp_node, - slp_instance slp_node_instance) + slp_instance slp_node_instance, + edge loop_exit) { stmt_vec_info reduc_info =3D info_for_reduction (loop_vinfo, stmt_info); gcc_assert (reduc_info->is_reduc_info); @@ -5891,6 +5922,7 @@ vect_create_epilog_for_reduction (loop_vec_info loop_= vinfo, loop-closed PHI of the inner loop which we remember as def for the reduction PHI generation. */ bool double_reduc =3D false; + bool main_exit_p =3D LOOP_VINFO_IV_EXIT (loop_vinfo) =3D=3D loop_exit; stmt_vec_info rdef_info =3D stmt_info; if (STMT_VINFO_DEF_TYPE (stmt_info) =3D=3D vect_double_reduction_def) { @@ -6053,7 +6085,7 @@ vect_create_epilog_for_reduction (loop_vec_info loop_= vinfo, /* Create an induction variable. */ gimple_stmt_iterator incr_gsi; bool insert_after; - standard_iv_increment_position (loop, &incr_gsi, &insert_after); + vect_iv_increment_position (loop_exit, &incr_gsi, &insert_after); create_iv (series_vect, PLUS_EXPR, vec_step, NULL_TREE, loop, &incr_= gsi, insert_after, &indx_before_incr, &indx_after_incr); =20 @@ -6132,23 +6164,23 @@ vect_create_epilog_for_reduction (loop_vec_info loo= p_vinfo, Store them in NEW_PHIS. */ if (double_reduc) loop =3D outer_loop; - exit_bb =3D LOOP_VINFO_IV_EXIT (loop_vinfo)->dest; + /* We need to reduce values in all exits. */ + exit_bb =3D loop_exit->dest; exit_gsi =3D gsi_after_labels (exit_bb); reduc_inputs.create (slp_node ? vec_num : ncopies); + vec vec_stmts; for (unsigned i =3D 0; i < vec_num; i++) { gimple_seq stmts =3D NULL; - if (slp_node) - def =3D vect_get_slp_vect_def (slp_node, i); - else - def =3D gimple_get_lhs (STMT_VINFO_VEC_STMTS (rdef_info)[0]); + def =3D vect_get_vect_def (rdef_info, slp_node, slp_node_instance, + main_exit_p, i, vec_stmts); for (j =3D 0; j < ncopies; j++) { tree new_def =3D copy_ssa_name (def); phi =3D create_phi_node (new_def, exit_bb); if (j) - def =3D gimple_get_lhs (STMT_VINFO_VEC_STMTS (rdef_info)[j]); - SET_PHI_ARG_DEF (phi, LOOP_VINFO_IV_EXIT (loop_vinfo)->dest_idx, def); + def =3D gimple_get_lhs (vec_stmts[j]); + SET_PHI_ARG_DEF (phi, loop_exit->dest_idx, def); new_def =3D gimple_convert (&stmts, vectype, new_def); reduc_inputs.quick_push (new_def); } @@ -10481,17 +10513,18 @@ vectorizable_induction (loop_vec_info loop_vinfo, return true; } =20 - /* Function vectorizable_live_operation_1. + helper function for vectorizable_live_operation. */ + tree vectorizable_live_operation_1 (loop_vec_info loop_vinfo, - stmt_vec_info stmt_info, edge exit_e, + stmt_vec_info stmt_info, basic_block exit_bb, tree vectype, int ncopies, slp_tree slp_node, tree bitsize, tree bitstart, tree vec_lhs, - tree lhs_type, gimple_stmt_iterator *exit_gsi) + tree lhs_type, bool restart_loop, + gimple_stmt_iterator *exit_gsi) { - basic_block exit_bb =3D exit_e->dest; gcc_assert (single_pred_p (exit_bb) || LOOP_VINFO_EARLY_BREAKS (loop_vin= fo)); =20 tree vec_lhs_phi =3D copy_ssa_name (vec_lhs); @@ -10504,7 +10537,9 @@ vectorizable_live_operation_1 (loop_vec_info loop_v= info, if (LOOP_VINFO_FULLY_WITH_LENGTH_P (loop_vinfo)) { /* Emit: + SCALAR_RES =3D VEC_EXTRACT + where VEC_LHS is the vectorized live-out result and MASK is the loop mask for the final iteration. */ gcc_assert (ncopies =3D=3D 1 && !slp_node); @@ -10513,15 +10548,18 @@ vectorizable_live_operation_1 (loop_vec_info loop= _vinfo, tree len =3D vect_get_loop_len (loop_vinfo, &gsi, &LOOP_VINFO_LENS (loop_vinfo), 1, vectype, 0, 0); + /* BIAS - 1. */ signed char biasval =3D LOOP_VINFO_PARTIAL_LOAD_STORE_BIAS (loop_vin= fo); tree bias_minus_one =3D int_const_binop (MINUS_EXPR, build_int_cst (TREE_TYPE (len), biasval), build_one_cst (TREE_TYPE (len))); + /* LAST_INDEX =3D LEN + (BIAS - 1). */ tree last_index =3D gimple_build (&stmts, PLUS_EXPR, TREE_TYPE (len)= , len, bias_minus_one); + /* This needs to implement extraction of the first index, but not su= re how the LEN stuff works. At the moment we shouldn't get here since there's no LEN support for early breaks. But guard this so there's @@ -10532,13 +10570,16 @@ vectorizable_live_operation_1 (loop_vec_info loop= _vinfo, tree scalar_res =3D gimple_build (&stmts, CFN_VEC_EXTRACT, TREE_TYPE (vectype), vec_lhs_phi, last_index); + /* Convert the extracted vector element to the scalar type. */ new_tree =3D gimple_convert (&stmts, lhs_type, scalar_res); } else if (LOOP_VINFO_FULLY_MASKED_P (loop_vinfo)) { /* Emit: + SCALAR_RES =3D EXTRACT_LAST + where VEC_LHS is the vectorized live-out result and MASK is the loop mask for the final iteration. */ gcc_assert (!slp_node); @@ -10548,10 +10589,38 @@ vectorizable_live_operation_1 (loop_vec_info loop= _vinfo, tree mask =3D vect_get_loop_mask (loop_vinfo, &gsi, &LOOP_VINFO_MASKS (loop_vinfo), 1, vectype, 0); + tree scalar_res; + + /* For an inverted control flow with early breaks we want EXTRACT_FI= RST + instead of EXTRACT_LAST. Emulate by reversing the vector and mask. */ + if (restart_loop && LOOP_VINFO_EARLY_BREAKS (loop_vinfo)) + { + /* First create the permuted mask. */ + tree perm_mask =3D perm_mask_for_reverse (TREE_TYPE (mask)); + tree perm_dest =3D copy_ssa_name (mask); + gimple *perm_stmt + =3D gimple_build_assign (perm_dest, VEC_PERM_EXPR, mask, + mask, perm_mask); + vect_finish_stmt_generation (loop_vinfo, stmt_info, perm_stmt, + &gsi); + mask =3D perm_dest; + + /* Then permute the vector contents. */ + tree perm_elem =3D perm_mask_for_reverse (vectype); + perm_dest =3D copy_ssa_name (vec_lhs_phi); + perm_stmt + =3D gimple_build_assign (perm_dest, VEC_PERM_EXPR, vec_lhs_phi, + vec_lhs_phi, perm_elem); + vect_finish_stmt_generation (loop_vinfo, stmt_info, perm_stmt, + &gsi); + vec_lhs_phi =3D perm_dest; + } =20 gimple_seq_add_seq (&stmts, tem); - tree scalar_res =3D gimple_build (&stmts, CFN_EXTRACT_LAST, scalar_= type, - mask, vec_lhs_phi); + + scalar_res =3D gimple_build (&stmts, CFN_EXTRACT_LAST, scalar_type, + mask, vec_lhs_phi); + /* Convert the extracted vector element to the scalar type. */ new_tree =3D gimple_convert (&stmts, lhs_type, scalar_res); } @@ -10564,12 +10633,26 @@ vectorizable_live_operation_1 (loop_vec_info loop= _vinfo, new_tree =3D force_gimple_operand (fold_convert (lhs_type, new_tree)= , &stmts, true, NULL_TREE); } + *exit_gsi =3D gsi_after_labels (exit_bb); if (stmts) gsi_insert_seq_before (exit_gsi, stmts, GSI_SAME_STMT); + return new_tree; } =20 +/* Find the edge that's the final one in the path from SRC to DEST and + return it. This edge must exist in at most one forwarder edge between.= */ + +static edge +find_connected_edge (edge src, basic_block dest) +{ + if (src->dest =3D=3D dest) + return src; + + return find_edge (src->dest, dest); +} + /* Function vectorizable_live_operation. =20 STMT_INFO computes a value that is used outside the loop. Check if @@ -10590,11 +10673,13 @@ vectorizable_live_operation (vec_info *vinfo, stm= t_vec_info stmt_info, poly_uint64 nunits =3D TYPE_VECTOR_SUBPARTS (vectype); int ncopies; gimple *use_stmt; + use_operand_p use_p; auto_vec vec_oprnds; int vec_entry =3D 0; poly_uint64 vec_index =3D 0; =20 - gcc_assert (STMT_VINFO_LIVE_P (stmt_info)); + gcc_assert (STMT_VINFO_LIVE_P (stmt_info) + || LOOP_VINFO_EARLY_BREAKS (loop_vinfo)); =20 /* If a stmt of a reduction is live, vectorize it via vect_create_epilog_for_reduction. vectorizable_reduction assessed @@ -10619,8 +10704,25 @@ vectorizable_live_operation (vec_info *vinfo, stmt= _vec_info stmt_info, if (STMT_VINFO_REDUC_TYPE (reduc_info) =3D=3D FOLD_LEFT_REDUCTION || STMT_VINFO_REDUC_TYPE (reduc_info) =3D=3D EXTRACT_LAST_REDUCTION) return true; + vect_create_epilog_for_reduction (loop_vinfo, stmt_info, slp_node, - slp_node_instance); + slp_node_instance, + LOOP_VINFO_IV_EXIT (loop_vinfo)); + + /* If early break we only have to materialize the reduction on the m= erge + block, but we have to find an alternate exit first. */ + if (LOOP_VINFO_EARLY_BREAKS (loop_vinfo)) + { + for (auto exit : get_loop_exit_edges (LOOP_VINFO_LOOP (loop_vinfo))) + if (exit !=3D LOOP_VINFO_IV_EXIT (loop_vinfo)) + { + vect_create_epilog_for_reduction (loop_vinfo, stmt_info, + slp_node, slp_node_instance, + exit); + break; + } + } + return true; } =20 @@ -10772,37 +10874,62 @@ vectorizable_live_operation (vec_info *vinfo, stm= t_vec_info stmt_info, lhs' =3D new_tree; */ =20 class loop *loop =3D LOOP_VINFO_LOOP (loop_vinfo); - basic_block exit_bb =3D LOOP_VINFO_IV_EXIT (loop_vinfo)->dest; - gcc_assert (single_pred_p (exit_bb)); - - tree vec_lhs_phi =3D copy_ssa_name (vec_lhs); - gimple *phi =3D create_phi_node (vec_lhs_phi, exit_bb); - SET_PHI_ARG_DEF (phi, LOOP_VINFO_IV_EXIT (loop_vinfo)->dest_idx, vec= _lhs); - - gimple_stmt_iterator exit_gsi; - tree new_tree - =3D vectorizable_live_operation_1 (loop_vinfo, stmt_info, - LOOP_VINFO_IV_EXIT (loop_vinfo), - vectype, ncopies, slp_node, bitsize, - bitstart, vec_lhs, lhs_type, - &exit_gsi); - - /* Remove existing phis that copy from lhs and create copies - from new_tree. */ - gimple_stmt_iterator gsi; - for (gsi =3D gsi_start_phis (exit_bb); !gsi_end_p (gsi);) - { - gimple *phi =3D gsi_stmt (gsi); - if ((gimple_phi_arg_def (phi, 0) =3D=3D lhs)) + /* Check if we have a loop where the chosen exit is not the main exi= t, + in these cases for an early break we restart the iteration the vector co= de + did. For the live values we want the value at the start of the iteratio= n + rather than at the end. */ + edge main_e =3D LOOP_VINFO_IV_EXIT (loop_vinfo); + bool restart_loop =3D LOOP_VINFO_EARLY_BREAKS_VECT_PEELED (loop_vinf= o); + FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, lhs) + if (!is_gimple_debug (use_stmt) + && !flow_bb_inside_loop_p (loop, gimple_bb (use_stmt))) + FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter) { - remove_phi_node (&gsi, false); - tree lhs_phi =3D gimple_phi_result (phi); - gimple *copy =3D gimple_build_assign (lhs_phi, new_tree); - gsi_insert_before (&exit_gsi, copy, GSI_SAME_STMT); - } - else - gsi_next (&gsi); - } + edge e =3D gimple_phi_arg_edge (as_a (use_stmt), + phi_arg_index_from_use (use_p)); + bool main_exit_edge =3D e =3D=3D main_e + || find_connected_edge (main_e, e->src); + + /* Early exits have an merge block, we want the merge block itself + so use ->src. For main exit the merge block is the + destination. */ + basic_block dest =3D main_exit_edge ? main_e->dest : e->src; + gimple *tmp_vec_stmt =3D vec_stmt; + tree tmp_vec_lhs =3D vec_lhs; + tree tmp_bitstart =3D bitstart; + + /* For early exit where the exit is not in the BB that leads + to the latch then we're restarting the iteration in the + scalar loop. So get the first live value. */ + restart_loop =3D restart_loop || !main_exit_edge; + if (restart_loop + && STMT_VINFO_DEF_TYPE (stmt_info) =3D=3D vect_induction_def) + { + tmp_vec_stmt =3D STMT_VINFO_VEC_STMTS (stmt_info)[0]; + tmp_vec_lhs =3D gimple_get_lhs (tmp_vec_stmt); + tmp_bitstart =3D build_zero_cst (TREE_TYPE (bitstart)); + } + + gimple_stmt_iterator exit_gsi; + tree new_tree + =3D vectorizable_live_operation_1 (loop_vinfo, stmt_info, + dest, vectype, ncopies, + slp_node, bitsize, + tmp_bitstart, tmp_vec_lhs, + lhs_type, restart_loop, + &exit_gsi); + + if (gimple_phi_num_args (use_stmt) =3D=3D 1) + { + auto gsi =3D gsi_for_stmt (use_stmt); + remove_phi_node (&gsi, false); + tree lhs_phi =3D gimple_phi_result (use_stmt); + gimple *copy =3D gimple_build_assign (lhs_phi, new_tree); + gsi_insert_before (&exit_gsi, copy, GSI_SAME_STMT); + } + else + SET_PHI_ARG_DEF (use_stmt, e->dest_idx, new_tree); + } =20 /* There a no further out-of-loop uses of lhs by LC-SSA construction= . */ FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, lhs) diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index b3a09c0a804a38e17ef32b6ce13b98b077459fc7..582c5e678fad802d6e76300fe3c= 939b9f2978f17 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -342,6 +342,7 @@ is_simple_and_all_uses_invariant (stmt_vec_info stmt_in= fo, - it has uses outside the loop. - it has vdefs (it alters memory). - control stmts in the loop (except for the exit condition). + - it is an induction and we have multiple exits. =20 CHECKME: what other side effects would the vectorizer allow? */ =20 @@ -399,6 +400,19 @@ vect_stmt_relevant_p (stmt_vec_info stmt_info, loop_ve= c_info loop_vinfo, } } =20 + /* Check if it's an induction and multiple exits. In this case there wi= ll be + a usage later on after peeling which is needed for the alternate exit= . */ + if (LOOP_VINFO_EARLY_BREAKS (loop_vinfo) + && STMT_VINFO_DEF_TYPE (stmt_info) =3D=3D vect_induction_def) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "vec_stmt_relevant_p: induction forced for " + "early break.\n"); + *live_p =3D true; + + } + if (*live_p && *relevant =3D=3D vect_unused_in_scope && !is_simple_and_all_uses_invariant (stmt_info, loop_vinfo)) { @@ -1774,7 +1788,7 @@ compare_step_with_zero (vec_info *vinfo, stmt_vec_inf= o stmt_info) /* If the target supports a permute mask that reverses the elements in a vector of type VECTYPE, return that mask, otherwise return null. */ =20 -static tree +tree perm_mask_for_reverse (tree vectype) { poly_uint64 nunits =3D TYPE_VECTOR_SUBPARTS (vectype); @@ -12720,20 +12734,27 @@ can_vectorize_live_stmts (vec_info *vinfo, stmt_v= ec_info stmt_info, bool vec_stmt_p, stmt_vector_for_cost *cost_vec) { + loop_vec_info loop_vinfo =3D dyn_cast (vinfo); if (slp_node) { stmt_vec_info slp_stmt_info; unsigned int i; FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (slp_node), i, slp_stmt_info= ) { - if (STMT_VINFO_LIVE_P (slp_stmt_info) + if ((STMT_VINFO_LIVE_P (slp_stmt_info) + || (loop_vinfo + && LOOP_VINFO_EARLY_BREAKS (loop_vinfo) + && STMT_VINFO_DEF_TYPE (slp_stmt_info) + =3D=3D vect_induction_def)) && !vectorizable_live_operation (vinfo, slp_stmt_info, slp_node, slp_node_instance, i, vec_stmt_p, cost_vec)) return false; } } - else if (STMT_VINFO_LIVE_P (stmt_info) + else if ((STMT_VINFO_LIVE_P (stmt_info) + || (LOOP_VINFO_EARLY_BREAKS (loop_vinfo) + && STMT_VINFO_DEF_TYPE (stmt_info) =3D=3D vect_induction_def)) && !vectorizable_live_operation (vinfo, stmt_info, slp_node, slp_node_instance, -1, vec_stmt_p, cost_vec)) diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index 15c7f75b1f3c61ab469f1b1970dae9c6ac1a9f55..974f617d54a14c903894dd20d60= 098ca259c96f2 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -2248,6 +2248,7 @@ extern bool vect_is_simple_use (vec_info *, stmt_vec_= info, slp_tree, enum vect_def_type *, tree *, stmt_vec_info * =3D NULL); extern bool vect_maybe_update_slp_op_vectype (slp_tree, tree); +extern tree perm_mask_for_reverse (tree); extern bool supportable_widening_operation (vec_info*, code_helper, stmt_vec_info, tree, tree, code_helper*, code_helper*, --_002_VI1PR08MB53250A8BF46DFA507C3E9338FF84AVI1PR08MB5325eurp_ Content-Type: application/octet-stream; name="rb17968.patch" Content-Description: rb17968.patch Content-Disposition: attachment; filename="rb17968.patch"; size=18329; creation-date="Wed, 06 Dec 2023 04:11:02 GMT"; modification-date="Wed, 06 Dec 2023 04:21:34 GMT" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtbG9vcC1tYW5pcC5jYyBiL2djYy90cmVlLXZlY3Qt bG9vcC1tYW5pcC5jYwppbmRleCBmMzhjYzQ3NTUxNDg4NTI1YjE1YzJiZTc1OGNhYzgyOTFkYmVm YjNhLi40ZTQ4MjE3YTMxZTU5MzE4YzJlYThlNWFiNjNiMDZiYTE5ODQwY2JkIDEwMDY0NAotLS0g YS9nY2MvdHJlZS12ZWN0LWxvb3AtbWFuaXAuY2MKKysrIGIvZ2NjL3RyZWUtdmVjdC1sb29wLW1h bmlwLmNjCkBAIC0zMzQ2LDYgKzMzNDYsNyBAQCB2ZWN0X2RvX3BlZWxpbmcgKGxvb3BfdmVjX2lu Zm8gbG9vcF92aW5mbywgdHJlZSBuaXRlcnMsIHRyZWUgbml0ZXJzbTEsCiAJICAgIGJiX2JlZm9y ZV9lcGlsb2ctPmNvdW50ID0gc2luZ2xlX3ByZWRfZWRnZSAoYmJfYmVmb3JlX2VwaWxvZyktPmNv dW50ICgpOwogCSAgYmJfYmVmb3JlX2VwaWxvZyA9IGxvb3BfcHJlaGVhZGVyX2VkZ2UgKGVwaWxv ZyktPnNyYzsKIAl9CisKICAgICAgIC8qIElmIGxvb3AgaXMgcGVlbGVkIGZvciBub24temVybyBj b25zdGFudCB0aW1lcywgbm93IG5pdGVycyByZWZlcnMgdG8KIAkgb3JpZ19uaXRlcnMgLSBwcm9s b2dfcGVlbGluZywgaXQgd29uJ3Qgb3ZlcmZsb3cgZXZlbiB0aGUgb3JpZ19uaXRlcnMKIAkgb3Zl cmZsb3dzLiAgKi8KZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtbG9vcC5jYyBiL2djYy90cmVl LXZlY3QtbG9vcC5jYwppbmRleCBkZjVlMWQyOGZhYzJjZTM1ZTcxZGVjZGVjMGQ4ZTMxZmI3NTU1 N2Y1Li4yZjkyMmI0MmY2ZDU2N2RmZDVkYTliMjc2YjFjOWQzN2JjNjgxODc2IDEwMDY0NAotLS0g YS9nY2MvdHJlZS12ZWN0LWxvb3AuY2MKKysrIGIvZ2NjL3RyZWUtdmVjdC1sb29wLmNjCkBAIC01 ODMxLDYgKzU4MzEsMzQgQEAgdmVjdF9jcmVhdGVfcGFydGlhbF9lcGlsb2cgKHRyZWUgdmVjX2Rl ZiwgdHJlZSB2ZWN0eXBlLCBjb2RlX2hlbHBlciBjb2RlLAogICByZXR1cm4gbmV3X3RlbXA7CiB9 CiAKKy8qIFJldHJpZXZlcyB0aGUgZGVmaW5pbmluZyBzdGF0ZW1lbnQgdG8gYmUgdXNlZCBmb3Ig YSByZWR1Y3Rpb24uCisgICBGb3IgTUFJTl9FWElUX1Agd2UgdXNlIHRoZSBjdXJyZW50IFZFQ19T VE1UcyBhbmQgb3RoZXJ3aXNlIHdlIGxvb2sgYXQKKyAgIHRoZSByZWR1Y3Rpb24gZGVmaW5pdGlv bnMuICAqLworCit0cmVlCit2ZWN0X2dldF92ZWN0X2RlZiAoc3RtdF92ZWNfaW5mbyByZWR1Y19p bmZvLCBzbHBfdHJlZSBzbHBfbm9kZSwKKwkJICAgc2xwX2luc3RhbmNlIHNscF9ub2RlX2luc3Rh bmNlLCBib29sIG1haW5fZXhpdF9wLCB1bnNpZ25lZCBpLAorCQkgICB2ZWMgPGdpbXBsZSAqPiAm dmVjX3N0bXRzKQoreworICB0cmVlIGRlZjsKKworICBpZiAoc2xwX25vZGUpCisgICAgeworICAg ICAgaWYgKCFtYWluX2V4aXRfcCkKKyAgICAgICAgc2xwX25vZGUgPSBzbHBfbm9kZV9pbnN0YW5j ZS0+cmVkdWNfcGhpczsKKyAgICAgIGRlZiA9IHZlY3RfZ2V0X3NscF92ZWN0X2RlZiAoc2xwX25v ZGUsIGkpOworICAgIH0KKyAgZWxzZQorICAgIHsKKyAgICAgIGlmICghbWFpbl9leGl0X3ApCisJ cmVkdWNfaW5mbyA9IFNUTVRfVklORk9fUkVEVUNfREVGICh2ZWN0X29yaWdfc3RtdCAocmVkdWNf aW5mbykpOworICAgICAgdmVjX3N0bXRzID0gU1RNVF9WSU5GT19WRUNfU1RNVFMgKHJlZHVjX2lu Zm8pOworICAgICAgZGVmID0gZ2ltcGxlX2dldF9saHMgKHZlY19zdG10c1swXSk7CisgICAgfQor CisgIHJldHVybiBkZWY7Cit9CisKIC8qIEZ1bmN0aW9uIHZlY3RfY3JlYXRlX2VwaWxvZ19mb3Jf cmVkdWN0aW9uCiAKICAgIENyZWF0ZSBjb2RlIGF0IHRoZSBsb29wLWVwaWxvZyB0byBmaW5hbGl6 ZSB0aGUgcmVzdWx0IG9mIGEgcmVkdWN0aW9uCkBAIC01ODQyLDYgKzU4NzAsOCBAQCB2ZWN0X2Ny ZWF0ZV9wYXJ0aWFsX2VwaWxvZyAodHJlZSB2ZWNfZGVmLCB0cmVlIHZlY3R5cGUsIGNvZGVfaGVs cGVyIGNvZGUsCiAgICBTTFBfTk9ERV9JTlNUQU5DRSBpcyB0aGUgU0xQIG5vZGUgaW5zdGFuY2Ug Y29udGFpbmluZyBTTFBfTk9ERQogICAgUkVEVUNfSU5ERVggc2F5cyB3aGljaCByaHMgb3BlcmFu ZCBvZiB0aGUgU1RNVF9JTkZPIGlzIHRoZSByZWR1Y3Rpb24gcGhpCiAgICAgIChjb3VudGluZyBm cm9tIDApCisgICBMT09QX0VYSVQgaXMgdGhlIGVkZ2UgdG8gdXBkYXRlIGluIHRoZSBtZXJnZSBi bG9jay4gIEluIHRoZSBjYXNlIG9mIGEgc2luZ2xlCisgICAgIGV4aXQgdGhpcyBlZGdlIGlzIGFs d2F5cyB0aGUgbWFpbiBsb29wIGV4aXQuCiAKICAgIFRoaXMgZnVuY3Rpb246CiAgICAxLiBDb21w bGV0ZXMgdGhlIHJlZHVjdGlvbiBkZWYtdXNlIGN5Y2xlcy4KQEAgLTU4ODIsNyArNTkxMiw4IEBA IHN0YXRpYyB2b2lkCiB2ZWN0X2NyZWF0ZV9lcGlsb2dfZm9yX3JlZHVjdGlvbiAobG9vcF92ZWNf aW5mbyBsb29wX3ZpbmZvLAogCQkJCSAgc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sCiAJCQkJICBz bHBfdHJlZSBzbHBfbm9kZSwKLQkJCQkgIHNscF9pbnN0YW5jZSBzbHBfbm9kZV9pbnN0YW5jZSkK KwkJCQkgIHNscF9pbnN0YW5jZSBzbHBfbm9kZV9pbnN0YW5jZSwKKwkJCQkgIGVkZ2UgbG9vcF9l eGl0KQogewogICBzdG10X3ZlY19pbmZvIHJlZHVjX2luZm8gPSBpbmZvX2Zvcl9yZWR1Y3Rpb24g KGxvb3BfdmluZm8sIHN0bXRfaW5mbyk7CiAgIGdjY19hc3NlcnQgKHJlZHVjX2luZm8tPmlzX3Jl ZHVjX2luZm8pOwpAQCAtNTg5MSw2ICs1OTIyLDcgQEAgdmVjdF9jcmVhdGVfZXBpbG9nX2Zvcl9y ZWR1Y3Rpb24gKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKICAgICAgbG9vcC1jbG9zZWQgUEhJ IG9mIHRoZSBpbm5lciBsb29wIHdoaWNoIHdlIHJlbWVtYmVyIGFzCiAgICAgIGRlZiBmb3IgdGhl IHJlZHVjdGlvbiBQSEkgZ2VuZXJhdGlvbi4gICovCiAgIGJvb2wgZG91YmxlX3JlZHVjID0gZmFs c2U7CisgIGJvb2wgbWFpbl9leGl0X3AgPSBMT09QX1ZJTkZPX0lWX0VYSVQgKGxvb3BfdmluZm8p ID09IGxvb3BfZXhpdDsKICAgc3RtdF92ZWNfaW5mbyByZGVmX2luZm8gPSBzdG10X2luZm87CiAg IGlmIChTVE1UX1ZJTkZPX0RFRl9UWVBFIChzdG10X2luZm8pID09IHZlY3RfZG91YmxlX3JlZHVj dGlvbl9kZWYpCiAgICAgewpAQCAtNjA1Myw3ICs2MDg1LDcgQEAgdmVjdF9jcmVhdGVfZXBpbG9n X2Zvcl9yZWR1Y3Rpb24gKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKICAgICAgIC8qIENyZWF0 ZSBhbiBpbmR1Y3Rpb24gdmFyaWFibGUuICAqLwogICAgICAgZ2ltcGxlX3N0bXRfaXRlcmF0b3Ig aW5jcl9nc2k7CiAgICAgICBib29sIGluc2VydF9hZnRlcjsKLSAgICAgIHN0YW5kYXJkX2l2X2lu Y3JlbWVudF9wb3NpdGlvbiAobG9vcCwgJmluY3JfZ3NpLCAmaW5zZXJ0X2FmdGVyKTsKKyAgICAg IHZlY3RfaXZfaW5jcmVtZW50X3Bvc2l0aW9uIChsb29wX2V4aXQsICZpbmNyX2dzaSwgJmluc2Vy dF9hZnRlcik7CiAgICAgICBjcmVhdGVfaXYgKHNlcmllc192ZWN0LCBQTFVTX0VYUFIsIHZlY19z dGVwLCBOVUxMX1RSRUUsIGxvb3AsICZpbmNyX2dzaSwKIAkJIGluc2VydF9hZnRlciwgJmluZHhf YmVmb3JlX2luY3IsICZpbmR4X2FmdGVyX2luY3IpOwogCkBAIC02MTMyLDIzICs2MTY0LDIzIEBA IHZlY3RfY3JlYXRlX2VwaWxvZ19mb3JfcmVkdWN0aW9uIChsb29wX3ZlY19pbmZvIGxvb3Bfdmlu Zm8sCiAgICAgICAgICBTdG9yZSB0aGVtIGluIE5FV19QSElTLiAgKi8KICAgaWYgKGRvdWJsZV9y ZWR1YykKICAgICBsb29wID0gb3V0ZXJfbG9vcDsKLSAgZXhpdF9iYiA9IExPT1BfVklORk9fSVZf RVhJVCAobG9vcF92aW5mbyktPmRlc3Q7CisgIC8qIFdlIG5lZWQgdG8gcmVkdWNlIHZhbHVlcyBp biBhbGwgZXhpdHMuICAqLworICBleGl0X2JiID0gbG9vcF9leGl0LT5kZXN0OwogICBleGl0X2dz aSA9IGdzaV9hZnRlcl9sYWJlbHMgKGV4aXRfYmIpOwogICByZWR1Y19pbnB1dHMuY3JlYXRlIChz bHBfbm9kZSA/IHZlY19udW0gOiBuY29waWVzKTsKKyAgdmVjIDxnaW1wbGUgKj4gdmVjX3N0bXRz OwogICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgdmVjX251bTsgaSsrKQogICAgIHsKICAgICAg IGdpbXBsZV9zZXEgc3RtdHMgPSBOVUxMOwotICAgICAgaWYgKHNscF9ub2RlKQotCWRlZiA9IHZl Y3RfZ2V0X3NscF92ZWN0X2RlZiAoc2xwX25vZGUsIGkpOwotICAgICAgZWxzZQotCWRlZiA9IGdp bXBsZV9nZXRfbGhzIChTVE1UX1ZJTkZPX1ZFQ19TVE1UUyAocmRlZl9pbmZvKVswXSk7CisgICAg ICBkZWYgPSB2ZWN0X2dldF92ZWN0X2RlZiAocmRlZl9pbmZvLCBzbHBfbm9kZSwgc2xwX25vZGVf aW5zdGFuY2UsCisJCQkgICAgICAgbWFpbl9leGl0X3AsIGksIHZlY19zdG10cyk7CiAgICAgICBm b3IgKGogPSAwOyBqIDwgbmNvcGllczsgaisrKQogCXsKIAkgIHRyZWUgbmV3X2RlZiA9IGNvcHlf c3NhX25hbWUgKGRlZik7CiAJICBwaGkgPSBjcmVhdGVfcGhpX25vZGUgKG5ld19kZWYsIGV4aXRf YmIpOwogCSAgaWYgKGopCi0JICAgIGRlZiA9IGdpbXBsZV9nZXRfbGhzIChTVE1UX1ZJTkZPX1ZF Q19TVE1UUyAocmRlZl9pbmZvKVtqXSk7Ci0JICBTRVRfUEhJX0FSR19ERUYgKHBoaSwgTE9PUF9W SU5GT19JVl9FWElUIChsb29wX3ZpbmZvKS0+ZGVzdF9pZHgsIGRlZik7CisJICAgIGRlZiA9IGdp bXBsZV9nZXRfbGhzICh2ZWNfc3RtdHNbal0pOworCSAgU0VUX1BISV9BUkdfREVGIChwaGksIGxv b3BfZXhpdC0+ZGVzdF9pZHgsIGRlZik7CiAJICBuZXdfZGVmID0gZ2ltcGxlX2NvbnZlcnQgKCZz dG10cywgdmVjdHlwZSwgbmV3X2RlZik7CiAJICByZWR1Y19pbnB1dHMucXVpY2tfcHVzaCAobmV3 X2RlZik7CiAJfQpAQCAtMTA0ODEsMTcgKzEwNTEzLDE4IEBAIHZlY3Rvcml6YWJsZV9pbmR1Y3Rp b24gKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKICAgcmV0dXJuIHRydWU7CiB9CiAKLQogLyog RnVuY3Rpb24gdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uXzEuCisKICAgIGhlbHBlciBmdW5j dGlvbiBmb3IgdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uLiAgKi8KKwogdHJlZQogdmVjdG9y aXphYmxlX2xpdmVfb3BlcmF0aW9uXzEgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKLQkJCSAg ICAgICBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywgZWRnZSBleGl0X2UsCisJCQkgICAgICAgc3Rt dF92ZWNfaW5mbyBzdG10X2luZm8sIGJhc2ljX2Jsb2NrIGV4aXRfYmIsCiAJCQkgICAgICAgdHJl ZSB2ZWN0eXBlLCBpbnQgbmNvcGllcywgc2xwX3RyZWUgc2xwX25vZGUsCiAJCQkgICAgICAgdHJl ZSBiaXRzaXplLCB0cmVlIGJpdHN0YXJ0LCB0cmVlIHZlY19saHMsCi0JCQkgICAgICAgdHJlZSBs aHNfdHlwZSwgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKmV4aXRfZ3NpKQorCQkJICAgICAgIHRyZWUg bGhzX3R5cGUsIGJvb2wgcmVzdGFydF9sb29wLAorCQkJICAgICAgIGdpbXBsZV9zdG10X2l0ZXJh dG9yICpleGl0X2dzaSkKIHsKLSAgYmFzaWNfYmxvY2sgZXhpdF9iYiA9IGV4aXRfZS0+ZGVzdDsK ICAgZ2NjX2Fzc2VydCAoc2luZ2xlX3ByZWRfcCAoZXhpdF9iYikgfHwgTE9PUF9WSU5GT19FQVJM WV9CUkVBS1MgKGxvb3BfdmluZm8pKTsKIAogICB0cmVlIHZlY19saHNfcGhpID0gY29weV9zc2Ff bmFtZSAodmVjX2xocyk7CkBAIC0xMDUwNCw3ICsxMDUzNyw5IEBAIHZlY3Rvcml6YWJsZV9saXZl X29wZXJhdGlvbl8xIChsb29wX3ZlY19pbmZvIGxvb3BfdmluZm8sCiAgIGlmIChMT09QX1ZJTkZP X0ZVTExZX1dJVEhfTEVOR1RIX1AgKGxvb3BfdmluZm8pKQogICAgIHsKICAgICAgIC8qIEVtaXQ6 CisKIAkgU0NBTEFSX1JFUyA9IFZFQ19FWFRSQUNUIDxWRUNfTEhTLCBMRU4gKyBCSUFTIC0gMT4K KwogCSB3aGVyZSBWRUNfTEhTIGlzIHRoZSB2ZWN0b3JpemVkIGxpdmUtb3V0IHJlc3VsdCBhbmQg TUFTSyBpcwogCSB0aGUgbG9vcCBtYXNrIGZvciB0aGUgZmluYWwgaXRlcmF0aW9uLiAgKi8KICAg ICAgIGdjY19hc3NlcnQgKG5jb3BpZXMgPT0gMSAmJiAhc2xwX25vZGUpOwpAQCAtMTA1MTMsMTUg KzEwNTQ4LDE4IEBAIHZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbl8xIChsb29wX3ZlY19pbmZv IGxvb3BfdmluZm8sCiAgICAgICB0cmVlIGxlbiA9IHZlY3RfZ2V0X2xvb3BfbGVuIChsb29wX3Zp bmZvLCAmZ3NpLAogCQkJCSAgICAmTE9PUF9WSU5GT19MRU5TIChsb29wX3ZpbmZvKSwKIAkJCQkg ICAgMSwgdmVjdHlwZSwgMCwgMCk7CisKICAgICAgIC8qIEJJQVMgLSAxLiAgKi8KICAgICAgIHNp Z25lZCBjaGFyIGJpYXN2YWwgPSBMT09QX1ZJTkZPX1BBUlRJQUxfTE9BRF9TVE9SRV9CSUFTIChs b29wX3ZpbmZvKTsKICAgICAgIHRyZWUgYmlhc19taW51c19vbmUKIAk9IGludF9jb25zdF9iaW5v cCAoTUlOVVNfRVhQUiwKIAkJCSAgIGJ1aWxkX2ludF9jc3QgKFRSRUVfVFlQRSAobGVuKSwgYmlh c3ZhbCksCiAJCQkgICBidWlsZF9vbmVfY3N0IChUUkVFX1RZUEUgKGxlbikpKTsKKwogICAgICAg LyogTEFTVF9JTkRFWCA9IExFTiArIChCSUFTIC0gMSkuICAqLwogICAgICAgdHJlZSBsYXN0X2lu ZGV4ID0gZ2ltcGxlX2J1aWxkICgmc3RtdHMsIFBMVVNfRVhQUiwgVFJFRV9UWVBFIChsZW4pLAog CQkJCSAgICAgbGVuLCBiaWFzX21pbnVzX29uZSk7CisKICAgICAgIC8qIFRoaXMgbmVlZHMgdG8g aW1wbGVtZW50IGV4dHJhY3Rpb24gb2YgdGhlIGZpcnN0IGluZGV4LCBidXQgbm90IHN1cmUKIAkg aG93IHRoZSBMRU4gc3R1ZmYgd29ya3MuICBBdCB0aGUgbW9tZW50IHdlIHNob3VsZG4ndCBnZXQg aGVyZSBzaW5jZQogCSB0aGVyZSdzIG5vIExFTiBzdXBwb3J0IGZvciBlYXJseSBicmVha3MuICBC dXQgZ3VhcmQgdGhpcyBzbyB0aGVyZSdzCkBAIC0xMDUzMiwxMyArMTA1NzAsMTYgQEAgdmVjdG9y aXphYmxlX2xpdmVfb3BlcmF0aW9uXzEgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKICAgICAg IHRyZWUgc2NhbGFyX3JlcwogCT0gZ2ltcGxlX2J1aWxkICgmc3RtdHMsIENGTl9WRUNfRVhUUkFD VCwgVFJFRV9UWVBFICh2ZWN0eXBlKSwKIAkJCXZlY19saHNfcGhpLCBsYXN0X2luZGV4KTsKKwog ICAgICAgLyogQ29udmVydCB0aGUgZXh0cmFjdGVkIHZlY3RvciBlbGVtZW50IHRvIHRoZSBzY2Fs YXIgdHlwZS4gICovCiAgICAgICBuZXdfdHJlZSA9IGdpbXBsZV9jb252ZXJ0ICgmc3RtdHMsIGxo c190eXBlLCBzY2FsYXJfcmVzKTsKICAgICB9CiAgIGVsc2UgaWYgKExPT1BfVklORk9fRlVMTFlf TUFTS0VEX1AgKGxvb3BfdmluZm8pKQogICAgIHsKICAgICAgIC8qIEVtaXQ6CisKIAkgU0NBTEFS X1JFUyA9IEVYVFJBQ1RfTEFTVCA8VkVDX0xIUywgTUFTSz4KKwogCSB3aGVyZSBWRUNfTEhTIGlz IHRoZSB2ZWN0b3JpemVkIGxpdmUtb3V0IHJlc3VsdCBhbmQgTUFTSyBpcwogCSB0aGUgbG9vcCBt YXNrIGZvciB0aGUgZmluYWwgaXRlcmF0aW9uLiAgKi8KICAgICAgIGdjY19hc3NlcnQgKCFzbHBf bm9kZSk7CkBAIC0xMDU0OCwxMCArMTA1ODksMzggQEAgdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0 aW9uXzEgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKICAgICAgIHRyZWUgbWFzayA9IHZlY3Rf Z2V0X2xvb3BfbWFzayAobG9vcF92aW5mbywgJmdzaSwKIAkJCQkgICAgICAmTE9PUF9WSU5GT19N QVNLUyAobG9vcF92aW5mbyksCiAJCQkJICAgICAgMSwgdmVjdHlwZSwgMCk7CisgICAgICB0cmVl IHNjYWxhcl9yZXM7CisKKyAgICAgIC8qIEZvciBhbiBpbnZlcnRlZCBjb250cm9sIGZsb3cgd2l0 aCBlYXJseSBicmVha3Mgd2Ugd2FudCBFWFRSQUNUX0ZJUlNUCisJIGluc3RlYWQgb2YgRVhUUkFD VF9MQVNULiAgRW11bGF0ZSBieSByZXZlcnNpbmcgdGhlIHZlY3RvciBhbmQgbWFzay4gKi8KKyAg ICAgIGlmIChyZXN0YXJ0X2xvb3AgJiYgTE9PUF9WSU5GT19FQVJMWV9CUkVBS1MgKGxvb3Bfdmlu Zm8pKQorCXsKKwkgIC8qIEZpcnN0IGNyZWF0ZSB0aGUgcGVybXV0ZWQgbWFzay4gICovCisJICB0 cmVlIHBlcm1fbWFzayA9IHBlcm1fbWFza19mb3JfcmV2ZXJzZSAoVFJFRV9UWVBFIChtYXNrKSk7 CisJICB0cmVlIHBlcm1fZGVzdCA9IGNvcHlfc3NhX25hbWUgKG1hc2spOworCSAgZ2ltcGxlICpw ZXJtX3N0bXQKKwkJPSBnaW1wbGVfYnVpbGRfYXNzaWduIChwZXJtX2Rlc3QsIFZFQ19QRVJNX0VY UFIsIG1hc2ssCisJCQkJICAgICAgIG1hc2ssIHBlcm1fbWFzayk7CisJICB2ZWN0X2ZpbmlzaF9z dG10X2dlbmVyYXRpb24gKGxvb3BfdmluZm8sIHN0bXRfaW5mbywgcGVybV9zdG10LAorCQkJCSAg ICAgICAmZ3NpKTsKKwkgIG1hc2sgPSBwZXJtX2Rlc3Q7CisKKwkgIC8qIFRoZW4gcGVybXV0ZSB0 aGUgdmVjdG9yIGNvbnRlbnRzLiAgKi8KKwkgIHRyZWUgcGVybV9lbGVtID0gcGVybV9tYXNrX2Zv cl9yZXZlcnNlICh2ZWN0eXBlKTsKKwkgIHBlcm1fZGVzdCA9IGNvcHlfc3NhX25hbWUgKHZlY19s aHNfcGhpKTsKKwkgIHBlcm1fc3RtdAorCQk9IGdpbXBsZV9idWlsZF9hc3NpZ24gKHBlcm1fZGVz dCwgVkVDX1BFUk1fRVhQUiwgdmVjX2xoc19waGksCisJCQkJICAgICAgIHZlY19saHNfcGhpLCBw ZXJtX2VsZW0pOworCSAgdmVjdF9maW5pc2hfc3RtdF9nZW5lcmF0aW9uIChsb29wX3ZpbmZvLCBz dG10X2luZm8sIHBlcm1fc3RtdCwKKwkJCQkgICAgICAgJmdzaSk7CisJICB2ZWNfbGhzX3BoaSA9 IHBlcm1fZGVzdDsKKwl9CiAKICAgICAgIGdpbXBsZV9zZXFfYWRkX3NlcSAoJnN0bXRzLCB0ZW0p OwotICAgICAgIHRyZWUgc2NhbGFyX3JlcyA9IGdpbXBsZV9idWlsZCAoJnN0bXRzLCBDRk5fRVhU UkFDVF9MQVNULCBzY2FsYXJfdHlwZSwKLQkJCQkgICAgICAgbWFzaywgdmVjX2xoc19waGkpOwor CisgICAgICBzY2FsYXJfcmVzID0gZ2ltcGxlX2J1aWxkICgmc3RtdHMsIENGTl9FWFRSQUNUX0xB U1QsIHNjYWxhcl90eXBlLAorCQkJCSBtYXNrLCB2ZWNfbGhzX3BoaSk7CisKICAgICAgIC8qIENv bnZlcnQgdGhlIGV4dHJhY3RlZCB2ZWN0b3IgZWxlbWVudCB0byB0aGUgc2NhbGFyIHR5cGUuICAq LwogICAgICAgbmV3X3RyZWUgPSBnaW1wbGVfY29udmVydCAoJnN0bXRzLCBsaHNfdHlwZSwgc2Nh bGFyX3Jlcyk7CiAgICAgfQpAQCAtMTA1NjQsMTIgKzEwNjMzLDI2IEBAIHZlY3Rvcml6YWJsZV9s aXZlX29wZXJhdGlvbl8xIChsb29wX3ZlY19pbmZvIGxvb3BfdmluZm8sCiAgICAgICBuZXdfdHJl ZSA9IGZvcmNlX2dpbXBsZV9vcGVyYW5kIChmb2xkX2NvbnZlcnQgKGxoc190eXBlLCBuZXdfdHJl ZSksCiAJCQkJICAgICAgICZzdG10cywgdHJ1ZSwgTlVMTF9UUkVFKTsKICAgICB9CisKICAgKmV4 aXRfZ3NpID0gZ3NpX2FmdGVyX2xhYmVscyAoZXhpdF9iYik7CiAgIGlmIChzdG10cykKICAgICBn c2lfaW5zZXJ0X3NlcV9iZWZvcmUgKGV4aXRfZ3NpLCBzdG10cywgR1NJX1NBTUVfU1RNVCk7CisK ICAgcmV0dXJuIG5ld190cmVlOwogfQogCisvKiBGaW5kIHRoZSBlZGdlIHRoYXQncyB0aGUgZmlu YWwgb25lIGluIHRoZSBwYXRoIGZyb20gU1JDIHRvIERFU1QgYW5kCisgICByZXR1cm4gaXQuICBU aGlzIGVkZ2UgbXVzdCBleGlzdCBpbiBhdCBtb3N0IG9uZSBmb3J3YXJkZXIgZWRnZSBiZXR3ZWVu LiAgKi8KKworc3RhdGljIGVkZ2UKK2ZpbmRfY29ubmVjdGVkX2VkZ2UgKGVkZ2Ugc3JjLCBiYXNp Y19ibG9jayBkZXN0KQoreworICAgaWYgKHNyYy0+ZGVzdCA9PSBkZXN0KQorICAgICByZXR1cm4g c3JjOworCisgIHJldHVybiBmaW5kX2VkZ2UgKHNyYy0+ZGVzdCwgZGVzdCk7Cit9CisKIC8qIEZ1 bmN0aW9uIHZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbi4KIAogICAgU1RNVF9JTkZPIGNvbXB1 dGVzIGEgdmFsdWUgdGhhdCBpcyB1c2VkIG91dHNpZGUgdGhlIGxvb3AuICBDaGVjayBpZgpAQCAt MTA1OTAsMTEgKzEwNjczLDEzIEBAIHZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbiAodmVjX2lu Zm8gKnZpbmZvLCBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywKICAgcG9seV91aW50NjQgbnVuaXRz ID0gVFlQRV9WRUNUT1JfU1VCUEFSVFMgKHZlY3R5cGUpOwogICBpbnQgbmNvcGllczsKICAgZ2lt cGxlICp1c2Vfc3RtdDsKKyAgdXNlX29wZXJhbmRfcCB1c2VfcDsKICAgYXV0b192ZWM8dHJlZT4g dmVjX29wcm5kczsKICAgaW50IHZlY19lbnRyeSA9IDA7CiAgIHBvbHlfdWludDY0IHZlY19pbmRl eCA9IDA7CiAKLSAgZ2NjX2Fzc2VydCAoU1RNVF9WSU5GT19MSVZFX1AgKHN0bXRfaW5mbykpOwor ICBnY2NfYXNzZXJ0IChTVE1UX1ZJTkZPX0xJVkVfUCAoc3RtdF9pbmZvKQorCSAgICAgIHx8IExP T1BfVklORk9fRUFSTFlfQlJFQUtTIChsb29wX3ZpbmZvKSk7CiAKICAgLyogSWYgYSBzdG10IG9m IGEgcmVkdWN0aW9uIGlzIGxpdmUsIHZlY3Rvcml6ZSBpdCB2aWEKICAgICAgdmVjdF9jcmVhdGVf ZXBpbG9nX2Zvcl9yZWR1Y3Rpb24uICB2ZWN0b3JpemFibGVfcmVkdWN0aW9uIGFzc2Vzc2VkCkBA IC0xMDYxOSw4ICsxMDcwNCwyNSBAQCB2ZWN0b3JpemFibGVfbGl2ZV9vcGVyYXRpb24gKHZlY19p bmZvICp2aW5mbywgc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sCiAgICAgICBpZiAoU1RNVF9WSU5G T19SRURVQ19UWVBFIChyZWR1Y19pbmZvKSA9PSBGT0xEX0xFRlRfUkVEVUNUSU9OCiAJICB8fCBT VE1UX1ZJTkZPX1JFRFVDX1RZUEUgKHJlZHVjX2luZm8pID09IEVYVFJBQ1RfTEFTVF9SRURVQ1RJ T04pCiAJcmV0dXJuIHRydWU7CisKICAgICAgIHZlY3RfY3JlYXRlX2VwaWxvZ19mb3JfcmVkdWN0 aW9uIChsb29wX3ZpbmZvLCBzdG10X2luZm8sIHNscF9ub2RlLAotCQkJCQlzbHBfbm9kZV9pbnN0 YW5jZSk7CisJCQkJCXNscF9ub2RlX2luc3RhbmNlLAorCQkJCQlMT09QX1ZJTkZPX0lWX0VYSVQg KGxvb3BfdmluZm8pKTsKKworICAgICAgLyogSWYgZWFybHkgYnJlYWsgd2Ugb25seSBoYXZlIHRv IG1hdGVyaWFsaXplIHRoZSByZWR1Y3Rpb24gb24gdGhlIG1lcmdlCisJIGJsb2NrLCBidXQgd2Ug aGF2ZSB0byBmaW5kIGFuIGFsdGVybmF0ZSBleGl0IGZpcnN0LiAgKi8KKyAgICAgIGlmIChMT09Q X1ZJTkZPX0VBUkxZX0JSRUFLUyAobG9vcF92aW5mbykpCisJeworCSAgZm9yIChhdXRvIGV4aXQg OiBnZXRfbG9vcF9leGl0X2VkZ2VzIChMT09QX1ZJTkZPX0xPT1AgKGxvb3BfdmluZm8pKSkKKwkg ICAgaWYgKGV4aXQgIT0gTE9PUF9WSU5GT19JVl9FWElUIChsb29wX3ZpbmZvKSkKKwkgICAgICB7 CisJCXZlY3RfY3JlYXRlX2VwaWxvZ19mb3JfcmVkdWN0aW9uIChsb29wX3ZpbmZvLCBzdG10X2lu Zm8sCisJCQkJCQkgIHNscF9ub2RlLCBzbHBfbm9kZV9pbnN0YW5jZSwKKwkJCQkJCSAgZXhpdCk7 CisJCWJyZWFrOworCSAgICAgIH0KKwl9CisKICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KIApA QCAtMTA3NzIsMzcgKzEwODc0LDYyIEBAIHZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbiAodmVj X2luZm8gKnZpbmZvLCBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywKIAkgICBsaHMnID0gbmV3X3Ry ZWU7ICAqLwogCiAgICAgICBjbGFzcyBsb29wICpsb29wID0gTE9PUF9WSU5GT19MT09QIChsb29w X3ZpbmZvKTsKLSAgICAgIGJhc2ljX2Jsb2NrIGV4aXRfYmIgPSBMT09QX1ZJTkZPX0lWX0VYSVQg KGxvb3BfdmluZm8pLT5kZXN0OwotICAgICAgZ2NjX2Fzc2VydCAoc2luZ2xlX3ByZWRfcCAoZXhp dF9iYikpOwotCi0gICAgICB0cmVlIHZlY19saHNfcGhpID0gY29weV9zc2FfbmFtZSAodmVjX2xo cyk7Ci0gICAgICBnaW1wbGUgKnBoaSA9IGNyZWF0ZV9waGlfbm9kZSAodmVjX2xoc19waGksIGV4 aXRfYmIpOwotICAgICAgU0VUX1BISV9BUkdfREVGIChwaGksIExPT1BfVklORk9fSVZfRVhJVCAo bG9vcF92aW5mbyktPmRlc3RfaWR4LCB2ZWNfbGhzKTsKLQotICAgICAgZ2ltcGxlX3N0bXRfaXRl cmF0b3IgZXhpdF9nc2k7Ci0gICAgICB0cmVlIG5ld190cmVlCi0JPSB2ZWN0b3JpemFibGVfbGl2 ZV9vcGVyYXRpb25fMSAobG9vcF92aW5mbywgc3RtdF9pbmZvLAotCQkJCQkgTE9PUF9WSU5GT19J Vl9FWElUIChsb29wX3ZpbmZvKSwKLQkJCQkJIHZlY3R5cGUsIG5jb3BpZXMsIHNscF9ub2RlLCBi aXRzaXplLAotCQkJCQkgYml0c3RhcnQsIHZlY19saHMsIGxoc190eXBlLAotCQkJCQkgJmV4aXRf Z3NpKTsKLQotICAgICAgLyogUmVtb3ZlIGV4aXN0aW5nIHBoaXMgdGhhdCBjb3B5IGZyb20gbGhz IGFuZCBjcmVhdGUgY29waWVzCi0JIGZyb20gbmV3X3RyZWUuICAqLwotICAgICAgZ2ltcGxlX3N0 bXRfaXRlcmF0b3IgZ3NpOwotICAgICAgZm9yIChnc2kgPSBnc2lfc3RhcnRfcGhpcyAoZXhpdF9i Yik7ICFnc2lfZW5kX3AgKGdzaSk7KQotCXsKLQkgIGdpbXBsZSAqcGhpID0gZ3NpX3N0bXQgKGdz aSk7Ci0JICBpZiAoKGdpbXBsZV9waGlfYXJnX2RlZiAocGhpLCAwKSA9PSBsaHMpKQorICAgICAg LyogQ2hlY2sgaWYgd2UgaGF2ZSBhIGxvb3Agd2hlcmUgdGhlIGNob3NlbiBleGl0IGlzIG5vdCB0 aGUgbWFpbiBleGl0LAorCSBpbiB0aGVzZSBjYXNlcyBmb3IgYW4gZWFybHkgYnJlYWsgd2UgcmVz dGFydCB0aGUgaXRlcmF0aW9uIHRoZSB2ZWN0b3IgY29kZQorCSBkaWQuICBGb3IgdGhlIGxpdmUg dmFsdWVzIHdlIHdhbnQgdGhlIHZhbHVlIGF0IHRoZSBzdGFydCBvZiB0aGUgaXRlcmF0aW9uCisJ IHJhdGhlciB0aGFuIGF0IHRoZSBlbmQuICAqLworICAgICAgZWRnZSBtYWluX2UgPSBMT09QX1ZJ TkZPX0lWX0VYSVQgKGxvb3BfdmluZm8pOworICAgICAgYm9vbCByZXN0YXJ0X2xvb3AgPSBMT09Q X1ZJTkZPX0VBUkxZX0JSRUFLU19WRUNUX1BFRUxFRCAobG9vcF92aW5mbyk7CisgICAgICBGT1Jf RUFDSF9JTU1fVVNFX1NUTVQgKHVzZV9zdG10LCBpbW1faXRlciwgbGhzKQorCWlmICghaXNfZ2lt cGxlX2RlYnVnICh1c2Vfc3RtdCkKKwkgICAgJiYgIWZsb3dfYmJfaW5zaWRlX2xvb3BfcCAobG9v cCwgZ2ltcGxlX2JiICh1c2Vfc3RtdCkpKQorCSAgRk9SX0VBQ0hfSU1NX1VTRV9PTl9TVE1UICh1 c2VfcCwgaW1tX2l0ZXIpCiAJICAgIHsKLQkgICAgICByZW1vdmVfcGhpX25vZGUgKCZnc2ksIGZh bHNlKTsKLQkgICAgICB0cmVlIGxoc19waGkgPSBnaW1wbGVfcGhpX3Jlc3VsdCAocGhpKTsKLQkg ICAgICBnaW1wbGUgKmNvcHkgPSBnaW1wbGVfYnVpbGRfYXNzaWduIChsaHNfcGhpLCBuZXdfdHJl ZSk7Ci0JICAgICAgZ3NpX2luc2VydF9iZWZvcmUgKCZleGl0X2dzaSwgY29weSwgR1NJX1NBTUVf U1RNVCk7Ci0JICAgIH0KLQkgIGVsc2UKLQkgICAgZ3NpX25leHQgKCZnc2kpOwotCX0KKwkgICAg ICBlZGdlIGUgPSBnaW1wbGVfcGhpX2FyZ19lZGdlIChhc19hIDxncGhpICo+ICh1c2Vfc3RtdCks CisJCQkJCSAgIHBoaV9hcmdfaW5kZXhfZnJvbV91c2UgKHVzZV9wKSk7CisJICAgICAgYm9vbCBt YWluX2V4aXRfZWRnZSA9IGUgPT0gbWFpbl9lCisJCQkJICAgIHx8IGZpbmRfY29ubmVjdGVkX2Vk Z2UgKG1haW5fZSwgZS0+c3JjKTsKKworCSAgICAgIC8qIEVhcmx5IGV4aXRzIGhhdmUgYW4gbWVy Z2UgYmxvY2ssIHdlIHdhbnQgdGhlIG1lcmdlIGJsb2NrIGl0c2VsZgorCQkgc28gdXNlIC0+c3Jj LiAgRm9yIG1haW4gZXhpdCB0aGUgbWVyZ2UgYmxvY2sgaXMgdGhlCisJCSBkZXN0aW5hdGlvbi4g ICovCisJICAgICAgYmFzaWNfYmxvY2sgZGVzdCA9IG1haW5fZXhpdF9lZGdlID8gbWFpbl9lLT5k ZXN0IDogZS0+c3JjOworCSAgICAgIGdpbXBsZSAqdG1wX3ZlY19zdG10ID0gdmVjX3N0bXQ7CisJ ICAgICAgdHJlZSB0bXBfdmVjX2xocyA9IHZlY19saHM7CisJICAgICAgdHJlZSB0bXBfYml0c3Rh cnQgPSBiaXRzdGFydDsKKworCSAgICAgIC8qIEZvciBlYXJseSBleGl0IHdoZXJlIHRoZSBleGl0 IGlzIG5vdCBpbiB0aGUgQkIgdGhhdCBsZWFkcworCQkgdG8gdGhlIGxhdGNoIHRoZW4gd2UncmUg cmVzdGFydGluZyB0aGUgaXRlcmF0aW9uIGluIHRoZQorCQkgc2NhbGFyIGxvb3AuICBTbyBnZXQg dGhlIGZpcnN0IGxpdmUgdmFsdWUuICAqLworCSAgICAgIHJlc3RhcnRfbG9vcCA9IHJlc3RhcnRf bG9vcCB8fCAhbWFpbl9leGl0X2VkZ2U7CisJICAgICAgaWYgKHJlc3RhcnRfbG9vcAorCQkgICYm IFNUTVRfVklORk9fREVGX1RZUEUgKHN0bXRfaW5mbykgPT0gdmVjdF9pbmR1Y3Rpb25fZGVmKQor CQl7CisJCSAgdG1wX3ZlY19zdG10ID0gU1RNVF9WSU5GT19WRUNfU1RNVFMgKHN0bXRfaW5mbylb MF07CisJCSAgdG1wX3ZlY19saHMgPSBnaW1wbGVfZ2V0X2xocyAodG1wX3ZlY19zdG10KTsKKwkJ ICB0bXBfYml0c3RhcnQgPSBidWlsZF96ZXJvX2NzdCAoVFJFRV9UWVBFIChiaXRzdGFydCkpOwor CQl9CisKKwkgICAgICBnaW1wbGVfc3RtdF9pdGVyYXRvciBleGl0X2dzaTsKKwkgICAgICB0cmVl IG5ld190cmVlCisJCT0gdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uXzEgKGxvb3BfdmluZm8s IHN0bXRfaW5mbywKKwkJCQkJCSBkZXN0LCB2ZWN0eXBlLCBuY29waWVzLAorCQkJCQkJIHNscF9u b2RlLCBiaXRzaXplLAorCQkJCQkJIHRtcF9iaXRzdGFydCwgdG1wX3ZlY19saHMsCisJCQkJCQkg bGhzX3R5cGUsIHJlc3RhcnRfbG9vcCwKKwkJCQkJCSAmZXhpdF9nc2kpOworCisJICAgICAgaWYg KGdpbXBsZV9waGlfbnVtX2FyZ3MgKHVzZV9zdG10KSA9PSAxKQorCQl7CisJCSAgYXV0byBnc2kg PSBnc2lfZm9yX3N0bXQgKHVzZV9zdG10KTsKKwkJICByZW1vdmVfcGhpX25vZGUgKCZnc2ksIGZh bHNlKTsKKwkJICB0cmVlIGxoc19waGkgPSBnaW1wbGVfcGhpX3Jlc3VsdCAodXNlX3N0bXQpOwor CQkgIGdpbXBsZSAqY29weSA9IGdpbXBsZV9idWlsZF9hc3NpZ24gKGxoc19waGksIG5ld190cmVl KTsKKwkJICBnc2lfaW5zZXJ0X2JlZm9yZSAoJmV4aXRfZ3NpLCBjb3B5LCBHU0lfU0FNRV9TVE1U KTsKKwkJfQorCSAgICAgIGVsc2UKKwkJU0VUX1BISV9BUkdfREVGICh1c2Vfc3RtdCwgZS0+ZGVz dF9pZHgsIG5ld190cmVlKTsKKwkgIH0KIAogICAgICAgLyogVGhlcmUgYSBubyBmdXJ0aGVyIG91 dC1vZi1sb29wIHVzZXMgb2YgbGhzIGJ5IExDLVNTQSBjb25zdHJ1Y3Rpb24uICAqLwogICAgICAg Rk9SX0VBQ0hfSU1NX1VTRV9TVE1UICh1c2Vfc3RtdCwgaW1tX2l0ZXIsIGxocykKZGlmZiAtLWdp dCBhL2djYy90cmVlLXZlY3Qtc3RtdHMuY2MgYi9nY2MvdHJlZS12ZWN0LXN0bXRzLmNjCmluZGV4 IGIzYTA5YzBhODA0YTM4ZTE3ZWYzMmI2Y2UxM2I5OGIwNzc0NTlmYzcuLjU4MmM1ZTY3OGZhZDgw MmQ2ZTc2MzAwZmUzYzkzOWI5ZjI5NzhmMTcgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXZlY3Qtc3Rt dHMuY2MKKysrIGIvZ2NjL3RyZWUtdmVjdC1zdG10cy5jYwpAQCAtMzQyLDYgKzM0Miw3IEBAIGlz X3NpbXBsZV9hbmRfYWxsX3VzZXNfaW52YXJpYW50IChzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywK ICAgIC0gaXQgaGFzIHVzZXMgb3V0c2lkZSB0aGUgbG9vcC4KICAgIC0gaXQgaGFzIHZkZWZzIChp dCBhbHRlcnMgbWVtb3J5KS4KICAgIC0gY29udHJvbCBzdG10cyBpbiB0aGUgbG9vcCAoZXhjZXB0 IGZvciB0aGUgZXhpdCBjb25kaXRpb24pLgorICAgLSBpdCBpcyBhbiBpbmR1Y3Rpb24gYW5kIHdl IGhhdmUgbXVsdGlwbGUgZXhpdHMuCiAKICAgIENIRUNLTUU6IHdoYXQgb3RoZXIgc2lkZSBlZmZl Y3RzIHdvdWxkIHRoZSB2ZWN0b3JpemVyIGFsbG93PyAgKi8KIApAQCAtMzk5LDYgKzQwMCwxOSBA QCB2ZWN0X3N0bXRfcmVsZXZhbnRfcCAoc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sIGxvb3BfdmVj X2luZm8gbG9vcF92aW5mbywKIAl9CiAgICAgfQogCisgIC8qIENoZWNrIGlmIGl0J3MgYW4gaW5k dWN0aW9uIGFuZCBtdWx0aXBsZSBleGl0cy4gIEluIHRoaXMgY2FzZSB0aGVyZSB3aWxsIGJlCisg ICAgIGEgdXNhZ2UgbGF0ZXIgb24gYWZ0ZXIgcGVlbGluZyB3aGljaCBpcyBuZWVkZWQgZm9yIHRo ZSBhbHRlcm5hdGUgZXhpdC4gICovCisgIGlmIChMT09QX1ZJTkZPX0VBUkxZX0JSRUFLUyAobG9v cF92aW5mbykKKyAgICAgICYmIFNUTVRfVklORk9fREVGX1RZUEUgKHN0bXRfaW5mbykgPT0gdmVj dF9pbmR1Y3Rpb25fZGVmKQorICAgIHsKKyAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkg IGR1bXBfcHJpbnRmX2xvYyAoTVNHX05PVEUsIHZlY3RfbG9jYXRpb24sCisJCQkgICAidmVjX3N0 bXRfcmVsZXZhbnRfcDogaW5kdWN0aW9uIGZvcmNlZCBmb3IgIgorCQkJICAgImVhcmx5IGJyZWFr LlxuIik7CisgICAgICAqbGl2ZV9wID0gdHJ1ZTsKKworICAgIH0KKwogICBpZiAoKmxpdmVfcCAm JiAqcmVsZXZhbnQgPT0gdmVjdF91bnVzZWRfaW5fc2NvcGUKICAgICAgICYmICFpc19zaW1wbGVf YW5kX2FsbF91c2VzX2ludmFyaWFudCAoc3RtdF9pbmZvLCBsb29wX3ZpbmZvKSkKICAgICB7CkBA IC0xNzc0LDcgKzE3ODgsNyBAQCBjb21wYXJlX3N0ZXBfd2l0aF96ZXJvICh2ZWNfaW5mbyAqdmlu Zm8sIHN0bXRfdmVjX2luZm8gc3RtdF9pbmZvKQogLyogSWYgdGhlIHRhcmdldCBzdXBwb3J0cyBh IHBlcm11dGUgbWFzayB0aGF0IHJldmVyc2VzIHRoZSBlbGVtZW50cyBpbgogICAgYSB2ZWN0b3Ig b2YgdHlwZSBWRUNUWVBFLCByZXR1cm4gdGhhdCBtYXNrLCBvdGhlcndpc2UgcmV0dXJuIG51bGwu ICAqLwogCi1zdGF0aWMgdHJlZQordHJlZQogcGVybV9tYXNrX2Zvcl9yZXZlcnNlICh0cmVlIHZl Y3R5cGUpCiB7CiAgIHBvbHlfdWludDY0IG51bml0cyA9IFRZUEVfVkVDVE9SX1NVQlBBUlRTICh2 ZWN0eXBlKTsKQEAgLTEyNzIwLDIwICsxMjczNCwyNyBAQCBjYW5fdmVjdG9yaXplX2xpdmVfc3Rt dHMgKHZlY19pbmZvICp2aW5mbywgc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sCiAJCQkgIGJvb2wg dmVjX3N0bXRfcCwKIAkJCSAgc3RtdF92ZWN0b3JfZm9yX2Nvc3QgKmNvc3RfdmVjKQogeworICBs b29wX3ZlY19pbmZvIGxvb3BfdmluZm8gPSBkeW5fY2FzdCA8bG9vcF92ZWNfaW5mbz4gKHZpbmZv KTsKICAgaWYgKHNscF9ub2RlKQogICAgIHsKICAgICAgIHN0bXRfdmVjX2luZm8gc2xwX3N0bXRf aW5mbzsKICAgICAgIHVuc2lnbmVkIGludCBpOwogICAgICAgRk9SX0VBQ0hfVkVDX0VMVCAoU0xQ X1RSRUVfU0NBTEFSX1NUTVRTIChzbHBfbm9kZSksIGksIHNscF9zdG10X2luZm8pCiAJewotCSAg aWYgKFNUTVRfVklORk9fTElWRV9QIChzbHBfc3RtdF9pbmZvKQorCSAgaWYgKChTVE1UX1ZJTkZP X0xJVkVfUCAoc2xwX3N0bXRfaW5mbykKKwkgICAgICAgfHwgKGxvb3BfdmluZm8KKwkJICAgJiYg TE9PUF9WSU5GT19FQVJMWV9CUkVBS1MgKGxvb3BfdmluZm8pCisJCSAgICYmIFNUTVRfVklORk9f REVGX1RZUEUgKHNscF9zdG10X2luZm8pCisJCQk9PSB2ZWN0X2luZHVjdGlvbl9kZWYpKQogCSAg ICAgICYmICF2ZWN0b3JpemFibGVfbGl2ZV9vcGVyYXRpb24gKHZpbmZvLCBzbHBfc3RtdF9pbmZv LCBzbHBfbm9kZSwKIAkJCQkJICAgICAgIHNscF9ub2RlX2luc3RhbmNlLCBpLAogCQkJCQkgICAg ICAgdmVjX3N0bXRfcCwgY29zdF92ZWMpKQogCSAgICByZXR1cm4gZmFsc2U7CiAJfQogICAgIH0K LSAgZWxzZSBpZiAoU1RNVF9WSU5GT19MSVZFX1AgKHN0bXRfaW5mbykKKyAgZWxzZSBpZiAoKFNU TVRfVklORk9fTElWRV9QIChzdG10X2luZm8pCisJICAgIHx8IChMT09QX1ZJTkZPX0VBUkxZX0JS RUFLUyAobG9vcF92aW5mbykKKwkJJiYgU1RNVF9WSU5GT19ERUZfVFlQRSAoc3RtdF9pbmZvKSA9 PSB2ZWN0X2luZHVjdGlvbl9kZWYpKQogCSAgICYmICF2ZWN0b3JpemFibGVfbGl2ZV9vcGVyYXRp b24gKHZpbmZvLCBzdG10X2luZm8sCiAJCQkJCSAgICBzbHBfbm9kZSwgc2xwX25vZGVfaW5zdGFu Y2UsIC0xLAogCQkJCQkgICAgdmVjX3N0bXRfcCwgY29zdF92ZWMpKQpkaWZmIC0tZ2l0IGEvZ2Nj L3RyZWUtdmVjdG9yaXplci5oIGIvZ2NjL3RyZWUtdmVjdG9yaXplci5oCmluZGV4IDE1YzdmNzVi MWYzYzYxYWI0NjlmMWIxOTcwZGFlOWM2YWMxYTlmNTUuLjk3NGY2MTdkNTRhMTRjOTAzODk0ZGQy MGQ2MDA5OGNhMjU5Yzk2ZjIgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXZlY3Rvcml6ZXIuaAorKysg Yi9nY2MvdHJlZS12ZWN0b3JpemVyLmgKQEAgLTIyNDgsNiArMjI0OCw3IEBAIGV4dGVybiBib29s IHZlY3RfaXNfc2ltcGxlX3VzZSAodmVjX2luZm8gKiwgc3RtdF92ZWNfaW5mbywgc2xwX3RyZWUs CiAJCQkJZW51bSB2ZWN0X2RlZl90eXBlICosCiAJCQkJdHJlZSAqLCBzdG10X3ZlY19pbmZvICog PSBOVUxMKTsKIGV4dGVybiBib29sIHZlY3RfbWF5YmVfdXBkYXRlX3NscF9vcF92ZWN0eXBlIChz bHBfdHJlZSwgdHJlZSk7CitleHRlcm4gdHJlZSBwZXJtX21hc2tfZm9yX3JldmVyc2UgKHRyZWUp OwogZXh0ZXJuIGJvb2wgc3VwcG9ydGFibGVfd2lkZW5pbmdfb3BlcmF0aW9uICh2ZWNfaW5mbyos IGNvZGVfaGVscGVyLAogCQkJCQkgICAgc3RtdF92ZWNfaW5mbywgdHJlZSwgdHJlZSwKIAkJCQkJ ICAgIGNvZGVfaGVscGVyKiwgY29kZV9oZWxwZXIqLAo= --_002_VI1PR08MB53250A8BF46DFA507C3E9338FF84AVI1PR08MB5325eurp_--