From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR02-AM0-obe.outbound.protection.outlook.com (mail-am0eur02on2062.outbound.protection.outlook.com [40.107.247.62]) by sourceware.org (Postfix) with ESMTPS id 3451C3858C2D for ; Mon, 27 Nov 2023 22:47:54 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 3451C3858C2D 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 3451C3858C2D Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=40.107.247.62 ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1701125284; cv=pass; b=i2YbVFFVA8HH1gRVOLFjpcKf+S8MepmocBSEVPenNLDkRxArG7FBVWaXSWFkhivMU4WaKlaOYA/D0FMq7EBSA7EtdZwMN143FyRp1Fe1W35VbWXlXAph560+s87otP1dhk/0mfDjO59VQy2p2Be7L0gOZr3cpo9aB0CrdoevUsA= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1701125284; c=relaxed/simple; bh=+jgY/nqR5hQd54i+UvpNxcLijvN1NfAOszeVCulCaPE=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=j/Cbd+OSQ5/uuqLmVXe5oezTBAWI0CAknzXyNWZpel7Xf+90lOeSWw3uUnRNWy0Yglws53WyDe5K9NqYXdX6djCCS/ANo0yD6V3nAjfL1JmpOVeUA5x0qMhw96nHgrG0W8XIGgUWa/1gTnUXCALaGJlZ5losVqK1D6mBBRyumW0= ARC-Authentication-Results: i=3; server2.sourceware.org ARC-Seal: i=2; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=pass; b=YlJ47LKYAZAjU5OzPY3YQo2nQqdX0dKol5WNzcQQIOaEW9uHoHcyYSq3yjYJlTyp7iuvj2VYyclqPOxhrhFRN8CiwymLmUt9YCtQ8YxDsRYCMnmLPucJwg/yiV/zrpoH+w98CCIvQ9Mq4fYSPjQPKkhwKnHIWAXEnOES6WGbNcJFdGzg8p7uZN7TamFjaPyU6cQ31BGiKK4GkEiEcyI5ovb4rSsNcG0jwNJLvyM2d5DVmeG5VdBi5eKan1/MM3cTPcqDZeOnohdZdiafvuKPTLnT2Ht3oeRfcMBBU+Qndmaup3HqLt92j8LgH6UE9pzkieFfFf3sZuKW3hNFnSc6PA== 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=tBG2fQ7dJcKxhVvTT+yQ/Mh/8jOUSVTtFvi0iJxsiZs=; b=aGVEa9j1ILuv41bG7b7txjHpv1HNRCqT4857L271+c7DHk/JsSwMWX/zak3n9DemOrZhtdNZ3v0f3W9SZA7jsuBOaPqbTN+wUOt66sExK7mcqn0sE9OkO3h4RGXWSa6Sv3safYyoiIqJsm+buT5fxpOF8oyAsgOCaXC7vNxDZG72hSpkZ1BbtFfJad2jWew56sD9tiOq35Z8kifuRVZzE7rlS8C3OZMSh6G8kL1e9xGOVWiDit1SGaq704ulZnchbKS5eMih76tfhewdla0TeUbjwRTNaLuaeAcaOZKMPmRwlu1+ya9sXqs06NfkkhYLHFidE3w5io38hbavlGLDWw== 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=tBG2fQ7dJcKxhVvTT+yQ/Mh/8jOUSVTtFvi0iJxsiZs=; b=l1B4uw7jc8nuEmRyjcsIkxt0U7ds3cuRUWTyRcaxMYAio/ZHTj5B21X2OdTiOfIyPo8pXsnyTkvFsPc6px2vvPwFPHbjjGqawbP6rfvfOWcoQkDMAwpDs7RTIbh14CFMb8pNNwv71nSzVf/2Yt9Nck1IxjOD/rV7jqCumhaikC8= Received: from AM6P195CA0011.EURP195.PROD.OUTLOOK.COM (2603:10a6:209:81::24) by AS8PR08MB8923.eurprd08.prod.outlook.com (2603:10a6:20b:5b3::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7025.27; Mon, 27 Nov 2023 22:47:50 +0000 Received: from AM2PEPF0001C70F.eurprd05.prod.outlook.com (2603:10a6:209:81:cafe::83) by AM6P195CA0011.outlook.office365.com (2603:10a6:209:81::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7025.29 via Frontend Transport; Mon, 27 Nov 2023 22:47:50 +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 AM2PEPF0001C70F.mail.protection.outlook.com (10.167.16.203) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7046.17 via Frontend Transport; Mon, 27 Nov 2023 22:47:50 +0000 Received: ("Tessian outbound 8289ea11ec17:v228"); Mon, 27 Nov 2023 22:47:50 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: 2de600bda30c608c X-CR-MTA-TID: 64aa7808 Received: from 25eeee0e7a7f.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id 96123718-A3F9-4DA6-BA05-00E45BD8248E.1; Mon, 27 Nov 2023 22:47:43 +0000 Received: from EUR01-DB5-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id 25eeee0e7a7f.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Mon, 27 Nov 2023 22:47:43 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=Yj0QSDcYLVHmNdZUemqTdzgTroaKWoV8ZIO8XR1kBr+QmqFgIn/VQzHdee8ajGBIYcWyVTDOq5S+qjcrBGkJb7uFgz4JM+02xJ9LcWktcFFO3IDXKWeNeD+uzAb4BN7sJQwubmoLGWLC7y4H5h6XpJYCdxzLZCNZD0ARMcMuzBlU7TtrTXBKt7WWOFJYy2OQx7+jLzSsop+yXzmsB3xzTX9kxWJgB1uKap7Xi6j+Oe91FDWUjwlq2GxNjZ2AUpFHtlwJe1SyRAs14yTkQAJrCFRQHYwh2EMIP018NC6R1j/JIrvz/xHBSrmbXw351WzoeFhRmOYypBZOACQadv+YaA== 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=tBG2fQ7dJcKxhVvTT+yQ/Mh/8jOUSVTtFvi0iJxsiZs=; b=iL2+YRGEPkgzzf7ftSKK7RQ46tL1/2aYN6DQodxgVZvYygov3vWjjNCNdNeldJAlqcXUMoiQrqJl/ivXiOS3gpdLOPU5Wl3S+YJDLvTcNsSec0XFJ7gVlutrAYRsmcirF6409GdI1RjPetF9rZQcjAymrWtO182cnSJ+56zFZWUGQkTgY2aCD0rs7zPqvbtC3l/f0CrOkGlyFBiVGmNoVaTEGcWWYAL/1dODU0sn9WamhFI06Pkdc8hwzXLtixMIrO1nSWx0TjooVOslKDS20T/dF4P6W/yIgFHcQUdULHm4waw/91uZrTsf6zAUlpeqglFon8Rus6A2S0ZC8y8pLQ== 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=tBG2fQ7dJcKxhVvTT+yQ/Mh/8jOUSVTtFvi0iJxsiZs=; b=l1B4uw7jc8nuEmRyjcsIkxt0U7ds3cuRUWTyRcaxMYAio/ZHTj5B21X2OdTiOfIyPo8pXsnyTkvFsPc6px2vvPwFPHbjjGqawbP6rfvfOWcoQkDMAwpDs7RTIbh14CFMb8pNNwv71nSzVf/2Yt9Nck1IxjOD/rV7jqCumhaikC8= Received: from VI1PR08MB5325.eurprd08.prod.outlook.com (2603:10a6:803:13e::17) by DU0PR08MB9726.eurprd08.prod.outlook.com (2603:10a6:10:446::17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7025.27; Mon, 27 Nov 2023 22:47:39 +0000 Received: from VI1PR08MB5325.eurprd08.prod.outlook.com ([fe80::9679:2ab0:99c6:54a3]) by VI1PR08MB5325.eurprd08.prod.outlook.com ([fe80::9679:2ab0:99c6:54a3%6]) with mapi id 15.20.7025.022; Mon, 27 Nov 2023 22:47:39 +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/BlARbB6jVXQgADknwCAAAlP4IABYGMAgAb7u4CABYbB4IAAM6IAgAVS2JA= Date: Mon, 27 Nov 2023 22:47:38 +0000 Message-ID: References: In-Reply-To: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: yes X-MS-TNEF-Correlator: Authentication-Results-Original: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=arm.com; x-ms-traffictypediagnostic: VI1PR08MB5325:EE_|DU0PR08MB9726:EE_|AM2PEPF0001C70F:EE_|AS8PR08MB8923:EE_ X-MS-Office365-Filtering-Correlation-Id: d89ae052-de05-4bfa-8501-08dbef9ae24c 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: YFpYHeSrrkW6GkLFdF/WeEGPtG7Jd4JF7HEzPiwi5PLULBCspwU/sIGi0MqVACRkKRQvaWUwZGX9+D0IWiwT7PdLANbXsU9RCYRjbwW9MyOe48I9+75YEBH9CCViEkLyBse+szkFwqhhyEv/g485FEUcRkdK12ExqWHxv7dA73qX78OUM78dA0irDbHtha+cfHjsPNL+hoPdQBPjcg+oXiDOm57To1mBWe1QD7rhspkkfemq+6n2DUPwvYmrY+DPwnkC9ZCrlxOJO26eJbmZOfuiKMXQBerzeJpG0yDaLYnjwFok4VKYGiM9XECjvEIJz72Gbz7x/4wUlOEdwBD8Qxrhari3rVmTAZXrnKn3mtpdioQXgsu8kEMFLmZcrtuyE1oPFV4ra2bbpaM9BXjxeLLhQ7T9ihFImq3bzsKeHeRVtnq8Y+AQpnE2cCK61672hpaL4+5dSv6G/y/6FPtcJ5H1L2l7HYb3fRU9lJMqudxgKPJPhmWXdpYwGu3np3JpDhdBnt9iG8ij1+SM/bVsO0ESnOeePLGTdVFCY2j6sfngFQf88+Bv1LInpEwxCLa598L2uG50XmpI4mg+ZLcouXChtSaa54rgU+i3gdvdYtZ56DY8+dSxwUazf71RdU3o X-Forefront-Antispam-Report-Untrusted: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:VI1PR08MB5325.eurprd08.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230031)(376002)(366004)(136003)(39860400002)(396003)(346002)(230922051799003)(1800799012)(186009)(451199024)(64100799003)(83380400001)(38100700002)(99936003)(122000001)(8936002)(8676002)(4326008)(52536014)(6506007)(9686003)(71200400001)(55016003)(66556008)(76116006)(316002)(6916009)(66946007)(7696005)(54906003)(64756008)(66446008)(66476007)(86362001)(5660300002)(15650500001)(478600001)(30864003)(41300700001)(33656002)(2906002)(38070700009)(26005)(579004)(559001);DIR:OUT;SFP:1101; Content-Type: multipart/mixed; boundary="_002_VI1PR08MB5325273CEE65AD07032C7A8BFFBDAVI1PR08MB5325eurp_" MIME-Version: 1.0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: DU0PR08MB9726 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: AM2PEPF0001C70F.eurprd05.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: e5b34bef-545e-4dde-d791-08dbef9adb81 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: oRqhqnjSrTOuO2z9LDTgYhkE6b0hFN2bsxoL/bReGCy6UZghifj5hRQxiVLlHF9rpdcYNyb4z0/joEEISRtrNRBOkMxfT8IRVmumNRwguSPmDK8Azvg9QCIWyLSLWgIVDXab/D5crg7HA6QiObJ7XKVNsKS9d/xrfUiajf+XLNntdZU6f7PU+uD/PhpEyla0HkKQ0ldTPG9sX2RkJ/sJ4vh02E6uVtTlAooKgMfTmfSTAYERe+PPZ4K/nJMArokOdpiSu0H2sRmo8HiAcniQsIGnONDrYjtZYIbEorrebzQf4e9f+g1PWCeUBg1By6XHTauQ4h8IPyrOPk67D0mK09u7j40sOcuIKRTp5AGPFEWFokiLcmVcYYqDbY7T5FX120qaBu9X2yxl5ZyEnZT7+cbw1bm6e/DkDRSO3USqQLOFMkdU+vsDGOjK3mL1D1f3H8R2ty5FvYMkBECaAPUUOjW2qvVjaVQG198eIJ+cMQqq6xJTXgng+7aT2ZQdJ+beUEXWmZD0jhXRaXAwbLEN1dO0/eEDoCnol8PGAIiikQhiTzI7jyyTwy/VqItFETVpDBn1K5+VHJYOJK2UHEMmNa8DhFWPp4Ji+meO3HgE9ueJluqHFByMKe/z1RKjkdS1ZxcG/tvkJqZpRw7ici7zFZoDcyjpHspPO3kmyKLIUQK0HGF1kIOK947Ls1/kaaRwVMJMjER6aGV1AuFklWegqP4GCmtvb46CfN77nLiJ/gPHGYO+XvllwOT1SU4OLPJd X-Forefront-Antispam-Report: CIP:63.35.35.123;CTRY:IE;LANG:en;SCL:1;SRV:;IPV:CAL;SFV:NSPM;H:64aa7808-outbound-1.mta.getcheckrecipient.com;PTR:ec2-63-35-35-123.eu-west-1.compute.amazonaws.com;CAT:NONE;SFS:(13230031)(4636009)(346002)(39860400002)(396003)(376002)(136003)(230922051799003)(451199024)(186009)(1800799012)(64100799003)(82310400011)(36840700001)(46966006)(40470700004)(41300700001)(107886003)(81166007)(99936003)(30864003)(33656002)(356005)(55016003)(47076005)(15650500001)(2906002)(83380400001)(82740400003)(5660300002)(336012)(235185007)(26005)(86362001)(36860700001)(40480700001)(6506007)(7696005)(8936002)(8676002)(6862004)(4326008)(9686003)(52536014)(40460700003)(478600001)(54906003)(70206006)(70586007)(316002);DIR:OUT;SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 27 Nov 2023 22:47:50.2943 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: d89ae052-de05-4bfa-8501-08dbef9ae24c 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: AM2PEPF0001C70F.eurprd05.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR08MB8923 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_VI1PR08MB5325273CEE65AD07032C7A8BFFBDAVI1PR08MB5325eurp_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable > > > This is a respun patch with a fix for VLA. > > > > This adds support to vectorizable_live_reduction to handle multiple > > exits by doing a search for which exit the live value should be materia= lized in. > > > > Additionally which value in the index we're after depends on whether > > the exit it's materialized in is an early exit or whether the loop's > > main exit is different from the loop's natural one (i.e. the one with > > the same src block as the latch). > > > > In those two cases we want the first rather than the last value as > > we're going to restart the iteration in the scalar loop. For VLA this > > means we need to reverse both the mask and vector since there's only a > > way to get the last active element and not the first. > > > > For inductions and multiple exits: > > - we test if the target will support vectorizing the induction > > - mark all inductions in the loop as relevant > > - for codegen of non-live inductions during codegen > > - induction during an early exit gets the first element rather than l= ast. > > > > For reductions and multiple exits: > > - Reductions for early exits reduces the reduction definition stateme= nt > > rather than the reduction step. This allows us to get the value at= the > > start of the iteration. > > - The peeling layout means that we just have to update one block, the > merge > > block. We expect all the reductions to be the same but we leave it= up to > > the value numbering to clean up any duplicate code as we iterate ov= er all > > edges. > > > > These two changes fix the reduction codegen given before which has > > been added to the testsuite for early vect. > > > > Bootstrapped Regtested on aarch64-none-linux-gnu and no issues. > > > > Ok for master? > > > > Thanks, > > Tamar > > > > gcc/ChangeLog: > > > > * tree-vect-loop.cc (vectorizable_live_operation): Support early exits= . > > (vect_analyze_loop_operations): Check if target supports vectorizing > IV. > > (vect_transform_loop): Call vectorizable_live_operation for non-live > > inductions or reductions. > > (find_connected_edge, vectorizable_live_operation_1): New. > > (vect_create_epilog_for_reduction): Support reductions in early break. > > * tree-vect-stmts.cc (perm_mask_for_reverse): Expose. > > (vect_stmt_relevant_p): Mark all inductions when early break as being > > relevant. > > * tree-vectorizer.h (perm_mask_for_reverse): Expose. > > (vect_iv_increment_position): New. > > * tree-vect-loop-manip.cc (vect_iv_increment_position): Expose. > > > > --- inline copy of patch --- > > > > diff --git a/gcc/tree-vect-loop-manip.cc b/gcc/tree-vect-loop-manip.cc > > index > > > 476be8a0bb6da2d06c4ca7052cb07bacecca60b1..1a4ba349fb6ae39c79401 > aecd4e7 > > eaaaa9e2b8a0 100644 > > --- a/gcc/tree-vect-loop-manip.cc > > +++ b/gcc/tree-vect-loop-manip.cc > > @@ -453,7 +453,7 @@ vect_adjust_loop_lens_control (tree iv_type, > gimple_seq *seq, > > INSERT_AFTER is set to true if the increment should be inserted aft= er > > *BSI. */ > > > > -static void > > +void > > vect_iv_increment_position (edge loop_exit, gimple_stmt_iterator *bsi, > > bool *insert_after) > > { > > diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc index > > > 8a50380de49bc12105be47ea1d8ee3cf1f2bdab4..b42318b2999e6a27e698 > 33821907 > > 92602cb25af1 100644 > > --- a/gcc/tree-vect-loop.cc > > +++ b/gcc/tree-vect-loop.cc > > @@ -2163,6 +2163,15 @@ vect_analyze_loop_operations (loop_vec_info > loop_vinfo) > > ok =3D vectorizable_live_operation (loop_vinfo, stmt_info, NULL, > NULL, > > -1, false, &cost_vec); > > > > + /* Check if we can perform the operation for early break if we forc= e > > + the live operation. */ > > + if (ok > > + && LOOP_VINFO_EARLY_BREAKS (loop_vinfo) > > + && !STMT_VINFO_LIVE_P (stmt_info) > > + && STMT_VINFO_DEF_TYPE (stmt_info) =3D=3D vect_induction_def) > > + ok =3D vectorizable_live_operation (loop_vinfo, stmt_info, NULL, > NULL, > > + -1, false, &cost_vec); >=20 > can you add && !PURE_SLP_STMT? >=20 I've cleaned up the patch a bit more, so these hunks are now all gone. > > @@ -6132,23 +6147,30 @@ vect_create_epilog_for_reduction > (loop_vec_info loop_vinfo, > > Store them in NEW_PHIS. */ > > if (double_reduc) > > loop =3D outer_loop; > > - exit_bb =3D LOOP_VINFO_IV_EXIT (loop_vinfo)->dest; > > + /* We need to reduce values in all exits. */ exit_bb =3D > > + loop_exit->dest; > > exit_gsi =3D gsi_after_labels (exit_bb); > > reduc_inputs.create (slp_node ? vec_num : ncopies); > > + vec vec_stmts; > > + if (main_exit_p) > > + vec_stmts =3D STMT_VINFO_VEC_STMTS (rdef_info); else > > + vec_stmts =3D STMT_VINFO_VEC_STMTS (STMT_VINFO_REDUC_DEF > > + (rdef_info)); >=20 > both would be wrong for SLP, also I think you need to look at > STMT_VINFO_REDUC_DEF (vect_orig_stmt (stmt_info))? For SLP the PHI SLP > node is reached via slp_node_instance->reduc_phis. >=20 > I think an overall better structure would be to add a >=20 > vect_get_vect_def (stmt_vec_info, slp_tree, unsigned); >=20 > abstracting SLP and non-SLP and doing >=20 > for (unsigned i =3D 0; i < vec_num * ncopies; ++i) > { > def =3D vect_get_vect_def (stmt_info, slp_node, i); ... > } >=20 > and then adjusting stmt_info/slp_node according to main_exit_p? Done. > (would be nice to transition stmt_info->vec_stmts to stmt_info->vec_defs) True. I guess since the plan is to remove non-SLP next year this'll just go= away anyway. 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..90041d1e138afb08c0116f48f51= 7fe0fcc615557 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); } @@ -6882,10 +6914,33 @@ vect_create_epilog_for_reduction (loop_vec_info loo= p_vinfo, } =20 scalar_result =3D scalar_results[k]; + edge merge_e =3D loop_exit; + if (!main_exit_p) + merge_e =3D single_succ_edge (loop_exit->dest); FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name) { FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter) - SET_USE (use_p, scalar_result); + { + if (main_exit_p) + SET_USE (use_p, scalar_result); + else + { + /* When multiple exits the same SSA name can appear in + both the main and the early exits. The meaning of the + reduction however is not the same. In the main exit + case the meaning is "get the last value" and in the + early exit case it means "get the first value". As + such we should only update the value for the exit + attached to loop_exit. To make this easier we always + call vect_create_epilog_for_reduction on the early + exit main block first. As such for the main exit we + no longer have to perform the BB check. */ + gphi *stmt =3D as_a (USE_STMT (use_p)); + int idx =3D phi_arg_index_from_use (use_p); + if (gimple_phi_arg_edge (stmt, idx) =3D=3D merge_e) + SET_USE (use_p, scalar_result); + } + } update_stmt (use_stmt); } } @@ -10481,15 +10536,17 @@ vectorizable_induction (loop_vec_info loop_vinfo, return true; } =20 - /* Function vectorizable_live_operation_1. + helper function for vectorizable_live_operation. */ + tree vectorizable_live_operation_1 (loop_vec_info loop_vinfo, stmt_vec_info stmt_info, edge exit_e, tree vectype, int ncopies, slp_tree slp_node, tree bitsize, tree bitstart, tree vec_lhs, - tree lhs_type, 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)); @@ -10504,7 +10561,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 +10572,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 +10594,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 +10613,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 +10657,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 @@ -10594,7 +10701,8 @@ vectorizable_live_operation (vec_info *vinfo, stmt_= vec_info stmt_info, int vec_entry =3D 0; poly_uint64 vec_index =3D 0; =20 - gcc_assert (STMT_VINFO_LIVE_P (stmt_info)); + gcc_assert (STMT_VINFO_LIVE_P (stmt_info) + || LOOP_VINFO_EARLY_BREAKS (loop_vinfo)); =20 /* If a stmt of a reduction is live, vectorize it via vect_create_epilog_for_reduction. vectorizable_reduction assessed @@ -10619,8 +10727,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; + + /* 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; + } + } + vect_create_epilog_for_reduction (loop_vinfo, stmt_info, slp_node, - slp_node_instance); + slp_node_instance, + LOOP_VINFO_IV_EXIT (loop_vinfo)); + return true; } =20 @@ -10772,37 +10897,63 @@ 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)) - { - 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); - } + /* 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))) + { + basic_block use_bb =3D gimple_bb (use_stmt); + if (!is_a (use_stmt)) + continue; + for (auto exit_e : get_loop_exit_edges (loop)) + { + /* See if this exit leads to the value. */ + edge dest_e =3D find_connected_edge (exit_e, use_bb); + if (!dest_e || PHI_ARG_DEF_FROM_EDGE (use_stmt, dest_e) !=3D lhs) + continue; + + 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)); + } + + gimple_stmt_iterator exit_gsi; + tree new_tree + =3D vectorizable_live_operation_1 (loop_vinfo, stmt_info, + exit_e, vectype, ncopies, + slp_node, bitsize, + tmp_bitstart, tmp_vec_lhs, + lhs_type, restart_loop, + &exit_gsi); + + /* Use the empty block on the exit to materialize the new stmts + so we can use update the PHI here. */ + if (gimple_phi_num_args (use_stmt) =3D=3D 1) + { + auto gsi =3D gsi_for_stmt (use_stmt); + remove_phi_node (&gsi, false); + tree lhs_phi =3D gimple_phi_result (use_stmt); + gimple *copy =3D gimple_build_assign (lhs_phi, new_tree); + gsi_insert_before (&exit_gsi, copy, GSI_SAME_STMT); + } + else + SET_PHI_ARG_DEF (use_stmt, dest_e->dest_idx, new_tree); + } + } =20 /* There a no further out-of-loop uses of lhs by LC-SSA construction= . */ FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, lhs) diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index fe38beb4fa1d9f8593445354f56ba52e10a040cd..27221c6e8e86034050b562ee5c1= 5992827a8d2cb 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 de60da31e2a3030a7fbc302d3f676af9683fd019..fd4b0a787e6128b43c5ca2b0612= f55845e6b3cef 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_VI1PR08MB5325273CEE65AD07032C7A8BFFBDAVI1PR08MB5325eurp_ Content-Type: application/octet-stream; name="rb17968 (1).patch" Content-Description: rb17968 (1).patch Content-Disposition: attachment; filename="rb17968 (1).patch"; size=19351; creation-date="Mon, 27 Nov 2023 22:47:15 GMT"; modification-date="Mon, 27 Nov 2023 22:47:38 GMT" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtbG9vcC1tYW5pcC5jYyBiL2djYy90cmVlLXZlY3Qt bG9vcC1tYW5pcC5jYwppbmRleCBmMzhjYzQ3NTUxNDg4NTI1YjE1YzJiZTc1OGNhYzgyOTFkYmVm YjNhLi40ZTQ4MjE3YTMxZTU5MzE4YzJlYThlNWFiNjNiMDZiYTE5ODQwY2JkIDEwMDY0NAotLS0g YS9nY2MvdHJlZS12ZWN0LWxvb3AtbWFuaXAuY2MKKysrIGIvZ2NjL3RyZWUtdmVjdC1sb29wLW1h bmlwLmNjCkBAIC0zMzQ2LDYgKzMzNDYsNyBAQCB2ZWN0X2RvX3BlZWxpbmcgKGxvb3BfdmVjX2lu Zm8gbG9vcF92aW5mbywgdHJlZSBuaXRlcnMsIHRyZWUgbml0ZXJzbTEsCiAJICAgIGJiX2JlZm9y ZV9lcGlsb2ctPmNvdW50ID0gc2luZ2xlX3ByZWRfZWRnZSAoYmJfYmVmb3JlX2VwaWxvZyktPmNv dW50ICgpOwogCSAgYmJfYmVmb3JlX2VwaWxvZyA9IGxvb3BfcHJlaGVhZGVyX2VkZ2UgKGVwaWxv ZyktPnNyYzsKIAl9CisKICAgICAgIC8qIElmIGxvb3AgaXMgcGVlbGVkIGZvciBub24temVybyBj b25zdGFudCB0aW1lcywgbm93IG5pdGVycyByZWZlcnMgdG8KIAkgb3JpZ19uaXRlcnMgLSBwcm9s b2dfcGVlbGluZywgaXQgd29uJ3Qgb3ZlcmZsb3cgZXZlbiB0aGUgb3JpZ19uaXRlcnMKIAkgb3Zl cmZsb3dzLiAgKi8KZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtbG9vcC5jYyBiL2djYy90cmVl LXZlY3QtbG9vcC5jYwppbmRleCBkZjVlMWQyOGZhYzJjZTM1ZTcxZGVjZGVjMGQ4ZTMxZmI3NTU1 N2Y1Li45MDA0MWQxZTEzOGFmYjA4YzAxMTZmNDhmNTE3ZmUwZmNjNjE1NTU3IDEwMDY0NAotLS0g 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 X2RlZik7CiAJfQpAQCAtNjg4MiwxMCArNjkxNCwzMyBAQCB2ZWN0X2NyZWF0ZV9lcGlsb2dfZm9y X3JlZHVjdGlvbiAobG9vcF92ZWNfaW5mbyBsb29wX3ZpbmZvLAogCSAgICB9CiAKICAgICAgICAg ICBzY2FsYXJfcmVzdWx0ID0gc2NhbGFyX3Jlc3VsdHNba107CisJICBlZGdlIG1lcmdlX2UgPSBs b29wX2V4aXQ7CisJICBpZiAoIW1haW5fZXhpdF9wKQorCSAgICBtZXJnZV9lID0gc2luZ2xlX3N1 Y2NfZWRnZSAobG9vcF9leGl0LT5kZXN0KTsKICAgICAgICAgICBGT1JfRUFDSF9JTU1fVVNFX1NU TVQgKHVzZV9zdG10LCBpbW1faXRlciwgb3JpZ19uYW1lKQogCSAgICB7CiAJICAgICAgRk9SX0VB Q0hfSU1NX1VTRV9PTl9TVE1UICh1c2VfcCwgaW1tX2l0ZXIpCi0JCVNFVF9VU0UgKHVzZV9wLCBz Y2FsYXJfcmVzdWx0KTsKKwkJeworCQkgIGlmIChtYWluX2V4aXRfcCkKKwkJICAgIFNFVF9VU0Ug KHVzZV9wLCBzY2FsYXJfcmVzdWx0KTsKKwkJICBlbHNlCisJCSAgICB7CisJCSAgICAgIC8qIFdo ZW4gbXVsdGlwbGUgZXhpdHMgdGhlIHNhbWUgU1NBIG5hbWUgY2FuIGFwcGVhciBpbgorCQkJIGJv dGggdGhlIG1haW4gYW5kIHRoZSBlYXJseSBleGl0cy4gIFRoZSBtZWFuaW5nIG9mIHRoZQorCQkJ IHJlZHVjdGlvbiBob3dldmVyIGlzIG5vdCB0aGUgc2FtZS4gIEluIHRoZSBtYWluIGV4aXQKKwkJ CSBjYXNlIHRoZSBtZWFuaW5nIGlzICJnZXQgdGhlIGxhc3QgdmFsdWUiIGFuZCBpbiB0aGUKKwkJ CSBlYXJseSBleGl0IGNhc2UgaXQgbWVhbnMgImdldCB0aGUgZmlyc3QgdmFsdWUiLiAgQXMKKwkJ CSBzdWNoIHdlIHNob3VsZCBvbmx5IHVwZGF0ZSB0aGUgdmFsdWUgZm9yIHRoZSBleGl0CisJCQkg YXR0YWNoZWQgdG8gbG9vcF9leGl0LiAgVG8gbWFrZSB0aGlzIGVhc2llciB3ZSBhbHdheXMKKwkJ CSBjYWxsIHZlY3RfY3JlYXRlX2VwaWxvZ19mb3JfcmVkdWN0aW9uIG9uIHRoZSBlYXJseQorCQkJ IGV4aXQgbWFpbiBibG9jayBmaXJzdC4gIEFzIHN1Y2ggZm9yIHRoZSBtYWluIGV4aXQgd2UKKwkJ CSBubyBsb25nZXIgaGF2ZSB0byBwZXJmb3JtIHRoZSBCQiBjaGVjay4gICovCisJCSAgICAgIGdw aGkgKnN0bXQgPSBhc19hIDxncGhpICo+IChVU0VfU1RNVCAodXNlX3ApKTsKKwkJICAgICAgaW50 IGlkeCA9IHBoaV9hcmdfaW5kZXhfZnJvbV91c2UgKHVzZV9wKTsKKwkJICAgICAgaWYgKGdpbXBs ZV9waGlfYXJnX2VkZ2UgKHN0bXQsIGlkeCkgPT0gbWVyZ2VfZSkKKwkJCVNFVF9VU0UgKHVzZV9w LCBzY2FsYXJfcmVzdWx0KTsKKwkJICAgIH0KKwkJfQogCSAgICAgIHVwZGF0ZV9zdG10ICh1c2Vf c3RtdCk7CiAJICAgIH0KICAgICAgICAgfQpAQCAtMTA0ODEsMTUgKzEwNTM2LDE3IEBAIHZlY3Rv cml6YWJsZV9pbmR1Y3Rpb24gKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKICAgcmV0dXJuIHRy dWU7CiB9CiAKLQogLyogRnVuY3Rpb24gdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uXzEuCisK ICAgIGhlbHBlciBmdW5jdGlvbiBmb3IgdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uLiAgKi8K KwogdHJlZQogdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uXzEgKGxvb3BfdmVjX2luZm8gbG9v cF92aW5mbywKIAkJCSAgICAgICBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywgZWRnZSBleGl0X2Us CiAJCQkgICAgICAgdHJlZSB2ZWN0eXBlLCBpbnQgbmNvcGllcywgc2xwX3RyZWUgc2xwX25vZGUs CiAJCQkgICAgICAgdHJlZSBiaXRzaXplLCB0cmVlIGJpdHN0YXJ0LCB0cmVlIHZlY19saHMsCi0J CQkgICAgICAgdHJlZSBsaHNfdHlwZSwgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKmV4aXRfZ3NpKQor CQkJICAgICAgIHRyZWUgbGhzX3R5cGUsIGJvb2wgcmVzdGFydF9sb29wLAorCQkJICAgICAgIGdp bXBsZV9zdG10X2l0ZXJhdG9yICpleGl0X2dzaSkKIHsKICAgYmFzaWNfYmxvY2sgZXhpdF9iYiA9 IGV4aXRfZS0+ZGVzdDsKICAgZ2NjX2Fzc2VydCAoc2luZ2xlX3ByZWRfcCAoZXhpdF9iYikgfHwg TE9PUF9WSU5GT19FQVJMWV9CUkVBS1MgKGxvb3BfdmluZm8pKTsKQEAgLTEwNTA0LDcgKzEwNTYx LDkgQEAgdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uXzEgKGxvb3BfdmVjX2luZm8gbG9vcF92 aW5mbywKICAgaWYgKExPT1BfVklORk9fRlVMTFlfV0lUSF9MRU5HVEhfUCAobG9vcF92aW5mbykp CiAgICAgewogICAgICAgLyogRW1pdDoKKwogCSBTQ0FMQVJfUkVTID0gVkVDX0VYVFJBQ1QgPFZF Q19MSFMsIExFTiArIEJJQVMgLSAxPgorCiAJIHdoZXJlIFZFQ19MSFMgaXMgdGhlIHZlY3Rvcml6 ZWQgbGl2ZS1vdXQgcmVzdWx0IGFuZCBNQVNLIGlzCiAJIHRoZSBsb29wIG1hc2sgZm9yIHRoZSBm aW5hbCBpdGVyYXRpb24uICAqLwogICAgICAgZ2NjX2Fzc2VydCAobmNvcGllcyA9PSAxICYmICFz bHBfbm9kZSk7CkBAIC0xMDUxMywxNSArMTA1NzIsMTggQEAgdmVjdG9yaXphYmxlX2xpdmVfb3Bl cmF0aW9uXzEgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKICAgICAgIHRyZWUgbGVuID0gdmVj dF9nZXRfbG9vcF9sZW4gKGxvb3BfdmluZm8sICZnc2ksCiAJCQkJICAgICZMT09QX1ZJTkZPX0xF TlMgKGxvb3BfdmluZm8pLAogCQkJCSAgICAxLCB2ZWN0eXBlLCAwLCAwKTsKKwogICAgICAgLyog QklBUyAtIDEuICAqLwogICAgICAgc2lnbmVkIGNoYXIgYmlhc3ZhbCA9IExPT1BfVklORk9fUEFS VElBTF9MT0FEX1NUT1JFX0JJQVMgKGxvb3BfdmluZm8pOwogICAgICAgdHJlZSBiaWFzX21pbnVz X29uZQogCT0gaW50X2NvbnN0X2Jpbm9wIChNSU5VU19FWFBSLAogCQkJICAgYnVpbGRfaW50X2Nz dCAoVFJFRV9UWVBFIChsZW4pLCBiaWFzdmFsKSwKIAkJCSAgIGJ1aWxkX29uZV9jc3QgKFRSRUVf VFlQRSAobGVuKSkpOworCiAgICAgICAvKiBMQVNUX0lOREVYID0gTEVOICsgKEJJQVMgLSAxKS4g ICovCiAgICAgICB0cmVlIGxhc3RfaW5kZXggPSBnaW1wbGVfYnVpbGQgKCZzdG10cywgUExVU19F WFBSLCBUUkVFX1RZUEUgKGxlbiksCiAJCQkJICAgICBsZW4sIGJpYXNfbWludXNfb25lKTsKKwog ICAgICAgLyogVGhpcyBuZWVkcyB0byBpbXBsZW1lbnQgZXh0cmFjdGlvbiBvZiB0aGUgZmlyc3Qg aW5kZXgsIGJ1dCBub3Qgc3VyZQogCSBob3cgdGhlIExFTiBzdHVmZiB3b3Jrcy4gIEF0IHRoZSBt b21lbnQgd2Ugc2hvdWxkbid0IGdldCBoZXJlIHNpbmNlCiAJIHRoZXJlJ3Mgbm8gTEVOIHN1cHBv cnQgZm9yIGVhcmx5IGJyZWFrcy4gIEJ1dCBndWFyZCB0aGlzIHNvIHRoZXJlJ3MKQEAgLTEwNTMy LDEzICsxMDU5NCwxNiBAQCB2ZWN0b3JpemFibGVfbGl2ZV9vcGVyYXRpb25fMSAobG9vcF92ZWNf aW5mbyBsb29wX3ZpbmZvLAogICAgICAgdHJlZSBzY2FsYXJfcmVzCiAJPSBnaW1wbGVfYnVpbGQg KCZzdG10cywgQ0ZOX1ZFQ19FWFRSQUNULCBUUkVFX1RZUEUgKHZlY3R5cGUpLAogCQkJdmVjX2xo c19waGksIGxhc3RfaW5kZXgpOworCiAgICAgICAvKiBDb252ZXJ0IHRoZSBleHRyYWN0ZWQgdmVj dG9yIGVsZW1lbnQgdG8gdGhlIHNjYWxhciB0eXBlLiAgKi8KICAgICAgIG5ld190cmVlID0gZ2lt cGxlX2NvbnZlcnQgKCZzdG10cywgbGhzX3R5cGUsIHNjYWxhcl9yZXMpOwogICAgIH0KICAgZWxz ZSBpZiAoTE9PUF9WSU5GT19GVUxMWV9NQVNLRURfUCAobG9vcF92aW5mbykpCiAgICAgewogICAg ICAgLyogRW1pdDoKKwogCSBTQ0FMQVJfUkVTID0gRVhUUkFDVF9MQVNUIDxWRUNfTEhTLCBNQVNL PgorCiAJIHdoZXJlIFZFQ19MSFMgaXMgdGhlIHZlY3Rvcml6ZWQgbGl2ZS1vdXQgcmVzdWx0IGFu ZCBNQVNLIGlzCiAJIHRoZSBsb29wIG1hc2sgZm9yIHRoZSBmaW5hbCBpdGVyYXRpb24uICAqLwog ICAgICAgZ2NjX2Fzc2VydCAoIXNscF9ub2RlKTsKQEAgLTEwNTQ4LDEwICsxMDYxMywzOCBAQCB2 ZWN0b3JpemFibGVfbGl2ZV9vcGVyYXRpb25fMSAobG9vcF92ZWNfaW5mbyBsb29wX3ZpbmZvLAog ICAgICAgdHJlZSBtYXNrID0gdmVjdF9nZXRfbG9vcF9tYXNrIChsb29wX3ZpbmZvLCAmZ3NpLAog CQkJCSAgICAgICZMT09QX1ZJTkZPX01BU0tTIChsb29wX3ZpbmZvKSwKIAkJCQkgICAgICAxLCB2 ZWN0eXBlLCAwKTsKKyAgICAgIHRyZWUgc2NhbGFyX3JlczsKKworICAgICAgLyogRm9yIGFuIGlu dmVydGVkIGNvbnRyb2wgZmxvdyB3aXRoIGVhcmx5IGJyZWFrcyB3ZSB3YW50IEVYVFJBQ1RfRklS U1QKKwkgaW5zdGVhZCBvZiBFWFRSQUNUX0xBU1QuICBFbXVsYXRlIGJ5IHJldmVyc2luZyB0aGUg dmVjdG9yIGFuZCBtYXNrLiAqLworICAgICAgaWYgKHJlc3RhcnRfbG9vcCAmJiBMT09QX1ZJTkZP X0VBUkxZX0JSRUFLUyAobG9vcF92aW5mbykpCisJeworCSAgLyogRmlyc3QgY3JlYXRlIHRoZSBw ZXJtdXRlZCBtYXNrLiAgKi8KKwkgIHRyZWUgcGVybV9tYXNrID0gcGVybV9tYXNrX2Zvcl9yZXZl cnNlIChUUkVFX1RZUEUgKG1hc2spKTsKKwkgIHRyZWUgcGVybV9kZXN0ID0gY29weV9zc2FfbmFt ZSAobWFzayk7CisJICBnaW1wbGUgKnBlcm1fc3RtdAorCQk9IGdpbXBsZV9idWlsZF9hc3NpZ24g KHBlcm1fZGVzdCwgVkVDX1BFUk1fRVhQUiwgbWFzaywKKwkJCQkgICAgICAgbWFzaywgcGVybV9t YXNrKTsKKwkgIHZlY3RfZmluaXNoX3N0bXRfZ2VuZXJhdGlvbiAobG9vcF92aW5mbywgc3RtdF9p bmZvLCBwZXJtX3N0bXQsCisJCQkJICAgICAgICZnc2kpOworCSAgbWFzayA9IHBlcm1fZGVzdDsK KworCSAgLyogVGhlbiBwZXJtdXRlIHRoZSB2ZWN0b3IgY29udGVudHMuICAqLworCSAgdHJlZSBw ZXJtX2VsZW0gPSBwZXJtX21hc2tfZm9yX3JldmVyc2UgKHZlY3R5cGUpOworCSAgcGVybV9kZXN0 ID0gY29weV9zc2FfbmFtZSAodmVjX2xoc19waGkpOworCSAgcGVybV9zdG10CisJCT0gZ2ltcGxl X2J1aWxkX2Fzc2lnbiAocGVybV9kZXN0LCBWRUNfUEVSTV9FWFBSLCB2ZWNfbGhzX3BoaSwKKwkJ CQkgICAgICAgdmVjX2xoc19waGksIHBlcm1fZWxlbSk7CisJICB2ZWN0X2ZpbmlzaF9zdG10X2dl bmVyYXRpb24gKGxvb3BfdmluZm8sIHN0bXRfaW5mbywgcGVybV9zdG10LAorCQkJCSAgICAgICAm Z3NpKTsKKwkgIHZlY19saHNfcGhpID0gcGVybV9kZXN0OworCX0KIAogICAgICAgZ2ltcGxlX3Nl cV9hZGRfc2VxICgmc3RtdHMsIHRlbSk7Ci0gICAgICAgdHJlZSBzY2FsYXJfcmVzID0gZ2ltcGxl X2J1aWxkICgmc3RtdHMsIENGTl9FWFRSQUNUX0xBU1QsIHNjYWxhcl90eXBlLAotCQkJCSAgICAg ICBtYXNrLCB2ZWNfbGhzX3BoaSk7CisKKyAgICAgIHNjYWxhcl9yZXMgPSBnaW1wbGVfYnVpbGQg KCZzdG10cywgQ0ZOX0VYVFJBQ1RfTEFTVCwgc2NhbGFyX3R5cGUsCisJCQkJIG1hc2ssIHZlY19s aHNfcGhpKTsKKwogICAgICAgLyogQ29udmVydCB0aGUgZXh0cmFjdGVkIHZlY3RvciBlbGVtZW50 IHRvIHRoZSBzY2FsYXIgdHlwZS4gICovCiAgICAgICBuZXdfdHJlZSA9IGdpbXBsZV9jb252ZXJ0 ICgmc3RtdHMsIGxoc190eXBlLCBzY2FsYXJfcmVzKTsKICAgICB9CkBAIC0xMDU2NCwxMiArMTA2 NTcsMjYgQEAgdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uXzEgKGxvb3BfdmVjX2luZm8gbG9v cF92aW5mbywKICAgICAgIG5ld190cmVlID0gZm9yY2VfZ2ltcGxlX29wZXJhbmQgKGZvbGRfY29u dmVydCAobGhzX3R5cGUsIG5ld190cmVlKSwKIAkJCQkgICAgICAgJnN0bXRzLCB0cnVlLCBOVUxM X1RSRUUpOwogICAgIH0KKwogICAqZXhpdF9nc2kgPSBnc2lfYWZ0ZXJfbGFiZWxzIChleGl0X2Ji KTsKICAgaWYgKHN0bXRzKQogICAgIGdzaV9pbnNlcnRfc2VxX2JlZm9yZSAoZXhpdF9nc2ksIHN0 bXRzLCBHU0lfU0FNRV9TVE1UKTsKKwogICByZXR1cm4gbmV3X3RyZWU7CiB9CiAKKy8qIEZpbmQg dGhlIGVkZ2UgdGhhdCdzIHRoZSBmaW5hbCBvbmUgaW4gdGhlIHBhdGggZnJvbSBTUkMgdG8gREVT VCBhbmQKKyAgIHJldHVybiBpdC4gIFRoaXMgZWRnZSBtdXN0IGV4aXN0IGluIGF0IG1vc3Qgb25l IGZvcndhcmRlciBlZGdlIGJldHdlZW4uICAqLworCitzdGF0aWMgZWRnZQorZmluZF9jb25uZWN0 ZWRfZWRnZSAoZWRnZSBzcmMsIGJhc2ljX2Jsb2NrIGRlc3QpCit7CisgICBpZiAoc3JjLT5kZXN0 ID09IGRlc3QpCisgICAgIHJldHVybiBzcmM7CisKKyAgcmV0dXJuIGZpbmRfZWRnZSAoc3JjLT5k ZXN0LCBkZXN0KTsKK30KKwogLyogRnVuY3Rpb24gdmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9u LgogCiAgICBTVE1UX0lORk8gY29tcHV0ZXMgYSB2YWx1ZSB0aGF0IGlzIHVzZWQgb3V0c2lkZSB0 aGUgbG9vcC4gIENoZWNrIGlmCkBAIC0xMDU5NCw3ICsxMDcwMSw4IEBAIHZlY3Rvcml6YWJsZV9s aXZlX29wZXJhdGlvbiAodmVjX2luZm8gKnZpbmZvLCBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywK ICAgaW50IHZlY19lbnRyeSA9IDA7CiAgIHBvbHlfdWludDY0IHZlY19pbmRleCA9IDA7CiAKLSAg Z2NjX2Fzc2VydCAoU1RNVF9WSU5GT19MSVZFX1AgKHN0bXRfaW5mbykpOworICBnY2NfYXNzZXJ0 IChTVE1UX1ZJTkZPX0xJVkVfUCAoc3RtdF9pbmZvKQorCSAgICAgIHx8IExPT1BfVklORk9fRUFS TFlfQlJFQUtTIChsb29wX3ZpbmZvKSk7CiAKICAgLyogSWYgYSBzdG10IG9mIGEgcmVkdWN0aW9u IGlzIGxpdmUsIHZlY3Rvcml6ZSBpdCB2aWEKICAgICAgdmVjdF9jcmVhdGVfZXBpbG9nX2Zvcl9y ZWR1Y3Rpb24uICB2ZWN0b3JpemFibGVfcmVkdWN0aW9uIGFzc2Vzc2VkCkBAIC0xMDYxOSw4ICsx MDcyNywyNSBAQCB2ZWN0b3JpemFibGVfbGl2ZV9vcGVyYXRpb24gKHZlY19pbmZvICp2aW5mbywg c3RtdF92ZWNfaW5mbyBzdG10X2luZm8sCiAgICAgICBpZiAoU1RNVF9WSU5GT19SRURVQ19UWVBF IChyZWR1Y19pbmZvKSA9PSBGT0xEX0xFRlRfUkVEVUNUSU9OCiAJICB8fCBTVE1UX1ZJTkZPX1JF RFVDX1RZUEUgKHJlZHVjX2luZm8pID09IEVYVFJBQ1RfTEFTVF9SRURVQ1RJT04pCiAJcmV0dXJu IHRydWU7CisKKyAgICAgIC8qIElmIGVhcmx5IGJyZWFrIHdlIG9ubHkgaGF2ZSB0byBtYXRlcmlh bGl6ZSB0aGUgcmVkdWN0aW9uIG9uIHRoZSBtZXJnZQorCSBibG9jaywgYnV0IHdlIGhhdmUgdG8g ZmluZCBhbiBhbHRlcm5hdGUgZXhpdCBmaXJzdC4gICovCisgICAgICBpZiAoTE9PUF9WSU5GT19F QVJMWV9CUkVBS1MgKGxvb3BfdmluZm8pKQorCXsKKwkgIGZvciAoYXV0byBleGl0IDogZ2V0X2xv b3BfZXhpdF9lZGdlcyAoTE9PUF9WSU5GT19MT09QIChsb29wX3ZpbmZvKSkpCisJICAgIGlmIChl eGl0ICE9IExPT1BfVklORk9fSVZfRVhJVCAobG9vcF92aW5mbykpCisJICAgICAgeworCQl2ZWN0 X2NyZWF0ZV9lcGlsb2dfZm9yX3JlZHVjdGlvbiAobG9vcF92aW5mbywgc3RtdF9pbmZvLAorCQkJ CQkJICBzbHBfbm9kZSwgc2xwX25vZGVfaW5zdGFuY2UsCisJCQkJCQkgIGV4aXQpOworCQlicmVh azsKKwkgICAgICB9CisJfQorCiAgICAgICB2ZWN0X2NyZWF0ZV9lcGlsb2dfZm9yX3JlZHVjdGlv biAobG9vcF92aW5mbywgc3RtdF9pbmZvLCBzbHBfbm9kZSwKLQkJCQkJc2xwX25vZGVfaW5zdGFu Y2UpOworCQkJCQlzbHBfbm9kZV9pbnN0YW5jZSwKKwkJCQkJTE9PUF9WSU5GT19JVl9FWElUIChs b29wX3ZpbmZvKSk7CisKICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KIApAQCAtMTA3NzIsMzcg KzEwODk3LDYzIEBAIHZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbiAodmVjX2luZm8gKnZpbmZv LCBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywKIAkgICBsaHMnID0gbmV3X3RyZWU7ICAqLwogCiAg ICAgICBjbGFzcyBsb29wICpsb29wID0gTE9PUF9WSU5GT19MT09QIChsb29wX3ZpbmZvKTsKLSAg ICAgIGJhc2ljX2Jsb2NrIGV4aXRfYmIgPSBMT09QX1ZJTkZPX0lWX0VYSVQgKGxvb3BfdmluZm8p LT5kZXN0OwotICAgICAgZ2NjX2Fzc2VydCAoc2luZ2xlX3ByZWRfcCAoZXhpdF9iYikpOwotCi0g ICAgICB0cmVlIHZlY19saHNfcGhpID0gY29weV9zc2FfbmFtZSAodmVjX2xocyk7Ci0gICAgICBn aW1wbGUgKnBoaSA9IGNyZWF0ZV9waGlfbm9kZSAodmVjX2xoc19waGksIGV4aXRfYmIpOwotICAg ICAgU0VUX1BISV9BUkdfREVGIChwaGksIExPT1BfVklORk9fSVZfRVhJVCAobG9vcF92aW5mbykt PmRlc3RfaWR4LCB2ZWNfbGhzKTsKLQotICAgICAgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgZXhpdF9n c2k7Ci0gICAgICB0cmVlIG5ld190cmVlCi0JPSB2ZWN0b3JpemFibGVfbGl2ZV9vcGVyYXRpb25f MSAobG9vcF92aW5mbywgc3RtdF9pbmZvLAotCQkJCQkgTE9PUF9WSU5GT19JVl9FWElUIChsb29w X3ZpbmZvKSwKLQkJCQkJIHZlY3R5cGUsIG5jb3BpZXMsIHNscF9ub2RlLCBiaXRzaXplLAotCQkJ CQkgYml0c3RhcnQsIHZlY19saHMsIGxoc190eXBlLAotCQkJCQkgJmV4aXRfZ3NpKTsKLQotICAg ICAgLyogUmVtb3ZlIGV4aXN0aW5nIHBoaXMgdGhhdCBjb3B5IGZyb20gbGhzIGFuZCBjcmVhdGUg Y29waWVzCi0JIGZyb20gbmV3X3RyZWUuICAqLwotICAgICAgZ2ltcGxlX3N0bXRfaXRlcmF0b3Ig Z3NpOwotICAgICAgZm9yIChnc2kgPSBnc2lfc3RhcnRfcGhpcyAoZXhpdF9iYik7ICFnc2lfZW5k X3AgKGdzaSk7KQotCXsKLQkgIGdpbXBsZSAqcGhpID0gZ3NpX3N0bXQgKGdzaSk7Ci0JICBpZiAo KGdpbXBsZV9waGlfYXJnX2RlZiAocGhpLCAwKSA9PSBsaHMpKQotCSAgICB7Ci0JICAgICAgcmVt b3ZlX3BoaV9ub2RlICgmZ3NpLCBmYWxzZSk7Ci0JICAgICAgdHJlZSBsaHNfcGhpID0gZ2ltcGxl X3BoaV9yZXN1bHQgKHBoaSk7Ci0JICAgICAgZ2ltcGxlICpjb3B5ID0gZ2ltcGxlX2J1aWxkX2Fz c2lnbiAobGhzX3BoaSwgbmV3X3RyZWUpOwotCSAgICAgIGdzaV9pbnNlcnRfYmVmb3JlICgmZXhp dF9nc2ksIGNvcHksIEdTSV9TQU1FX1NUTVQpOwotCSAgICB9Ci0JICBlbHNlCi0JICAgIGdzaV9u ZXh0ICgmZ3NpKTsKLQl9CisgICAgICAvKiBDaGVjayBpZiB3ZSBoYXZlIGEgbG9vcCB3aGVyZSB0 aGUgY2hvc2VuIGV4aXQgaXMgbm90IHRoZSBtYWluIGV4aXQsCisJIGluIHRoZXNlIGNhc2VzIGZv ciBhbiBlYXJseSBicmVhayB3ZSByZXN0YXJ0IHRoZSBpdGVyYXRpb24gdGhlIHZlY3RvciBjb2Rl CisJIGRpZC4gIEZvciB0aGUgbGl2ZSB2YWx1ZXMgd2Ugd2FudCB0aGUgdmFsdWUgYXQgdGhlIHN0 YXJ0IG9mIHRoZSBpdGVyYXRpb24KKwkgcmF0aGVyIHRoYW4gYXQgdGhlIGVuZC4gICovCisgICAg ICBlZGdlIG1haW5fZSA9IExPT1BfVklORk9fSVZfRVhJVCAobG9vcF92aW5mbyk7CisgICAgICBi b29sIHJlc3RhcnRfbG9vcCA9IExPT1BfVklORk9fRUFSTFlfQlJFQUtTX1ZFQ1RfUEVFTEVEIChs b29wX3ZpbmZvKTsKKyAgICAgIEZPUl9FQUNIX0lNTV9VU0VfU1RNVCAodXNlX3N0bXQsIGltbV9p dGVyLCBsaHMpCisJaWYgKCFpc19naW1wbGVfZGVidWcgKHVzZV9zdG10KQorCSAgICAmJiAhZmxv d19iYl9pbnNpZGVfbG9vcF9wIChsb29wLCBnaW1wbGVfYmIgKHVzZV9zdG10KSkpCisJICB7CisJ ICAgIGJhc2ljX2Jsb2NrIHVzZV9iYiA9IGdpbXBsZV9iYiAodXNlX3N0bXQpOworCSAgICBpZiAo IWlzX2EgPGdwaGkgKj4gKHVzZV9zdG10KSkKKwkgICAgICBjb250aW51ZTsKKwkgICAgZm9yIChh dXRvIGV4aXRfZSA6IGdldF9sb29wX2V4aXRfZWRnZXMgKGxvb3ApKQorCSAgICAgIHsKKwkJLyog U2VlIGlmIHRoaXMgZXhpdCBsZWFkcyB0byB0aGUgdmFsdWUuICAqLworCQllZGdlIGRlc3RfZSA9 IGZpbmRfY29ubmVjdGVkX2VkZ2UgKGV4aXRfZSwgdXNlX2JiKTsKKwkJaWYgKCFkZXN0X2UgfHwg UEhJX0FSR19ERUZfRlJPTV9FREdFICh1c2Vfc3RtdCwgZGVzdF9lKSAhPSBsaHMpCisJCSAgY29u dGludWU7CisKKwkJZ2ltcGxlICp0bXBfdmVjX3N0bXQgPSB2ZWNfc3RtdDsKKwkJdHJlZSB0bXBf dmVjX2xocyA9IHZlY19saHM7CisJCXRyZWUgdG1wX2JpdHN0YXJ0ID0gYml0c3RhcnQ7CisJCS8q IEZvciBlYXJseSBleGl0IHdoZXJlIHRoZSBleGl0IGlzIG5vdCBpbiB0aGUgQkIgdGhhdCBsZWFk cworCQkgICB0byB0aGUgbGF0Y2ggdGhlbiB3ZSdyZSByZXN0YXJ0aW5nIHRoZSBpdGVyYXRpb24g aW4gdGhlCisJCSAgIHNjYWxhciBsb29wLiAgU28gZ2V0IHRoZSBmaXJzdCBsaXZlIHZhbHVlLiAg Ki8KKwkJcmVzdGFydF9sb29wID0gcmVzdGFydF9sb29wIHx8IGV4aXRfZSAhPSBtYWluX2U7CisJ CWlmIChyZXN0YXJ0X2xvb3ApCisJCSAgeworCQkgICAgdG1wX3ZlY19zdG10ID0gU1RNVF9WSU5G T19WRUNfU1RNVFMgKHN0bXRfaW5mbylbMF07CisJCSAgICB0bXBfdmVjX2xocyA9IGdpbXBsZV9n ZXRfbGhzICh0bXBfdmVjX3N0bXQpOworCQkgICAgdG1wX2JpdHN0YXJ0ID0gYnVpbGRfemVyb19j c3QgKFRSRUVfVFlQRSAoYml0c3RhcnQpKTsKKwkJICB9CisKKwkJZ2ltcGxlX3N0bXRfaXRlcmF0 b3IgZXhpdF9nc2k7CisJCXRyZWUgbmV3X3RyZWUKKwkJICA9IHZlY3Rvcml6YWJsZV9saXZlX29w ZXJhdGlvbl8xIChsb29wX3ZpbmZvLCBzdG10X2luZm8sCisJCQkJCQkgICBleGl0X2UsIHZlY3R5 cGUsIG5jb3BpZXMsCisJCQkJCQkgICBzbHBfbm9kZSwgYml0c2l6ZSwKKwkJCQkJCSAgIHRtcF9i aXRzdGFydCwgdG1wX3ZlY19saHMsCisJCQkJCQkgICBsaHNfdHlwZSwgcmVzdGFydF9sb29wLAor CQkJCQkJICAgJmV4aXRfZ3NpKTsKKworCQkvKiBVc2UgdGhlIGVtcHR5IGJsb2NrIG9uIHRoZSBl eGl0IHRvIG1hdGVyaWFsaXplIHRoZSBuZXcgc3RtdHMKKwkJICAgc28gd2UgY2FuIHVzZSB1cGRh dGUgdGhlIFBISSBoZXJlLiAgKi8KKwkJaWYgKGdpbXBsZV9waGlfbnVtX2FyZ3MgKHVzZV9zdG10 KSA9PSAxKQorCQkgIHsKKwkJICAgIGF1dG8gZ3NpID0gZ3NpX2Zvcl9zdG10ICh1c2Vfc3RtdCk7 CisJCSAgICByZW1vdmVfcGhpX25vZGUgKCZnc2ksIGZhbHNlKTsKKwkJICAgIHRyZWUgbGhzX3Bo aSA9IGdpbXBsZV9waGlfcmVzdWx0ICh1c2Vfc3RtdCk7CisJCSAgICBnaW1wbGUgKmNvcHkgPSBn aW1wbGVfYnVpbGRfYXNzaWduIChsaHNfcGhpLCBuZXdfdHJlZSk7CisJCSAgICBnc2lfaW5zZXJ0 X2JlZm9yZSAoJmV4aXRfZ3NpLCBjb3B5LCBHU0lfU0FNRV9TVE1UKTsKKwkJICB9CisJCWVsc2UK KwkJICBTRVRfUEhJX0FSR19ERUYgKHVzZV9zdG10LCBkZXN0X2UtPmRlc3RfaWR4LCBuZXdfdHJl ZSk7CisJICAgICAgfQorCSAgfQogCiAgICAgICAvKiBUaGVyZSBhIG5vIGZ1cnRoZXIgb3V0LW9m LWxvb3AgdXNlcyBvZiBsaHMgYnkgTEMtU1NBIGNvbnN0cnVjdGlvbi4gICovCiAgICAgICBGT1Jf RUFDSF9JTU1fVVNFX1NUTVQgKHVzZV9zdG10LCBpbW1faXRlciwgbGhzKQpkaWZmIC0tZ2l0IGEv Z2NjL3RyZWUtdmVjdC1zdG10cy5jYyBiL2djYy90cmVlLXZlY3Qtc3RtdHMuY2MKaW5kZXggZmUz OGJlYjRmYTFkOWY4NTkzNDQ1MzU0ZjU2YmE1MmUxMGEwNDBjZC4uMjcyMjFjNmU4ZTg2MDM0MDUw YjU2MmVlNWMxNTk5MjgyN2E4ZDJjYiAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtdmVjdC1zdG10cy5j YworKysgYi9nY2MvdHJlZS12ZWN0LXN0bXRzLmNjCkBAIC0zNDIsNiArMzQyLDcgQEAgaXNfc2lt cGxlX2FuZF9hbGxfdXNlc19pbnZhcmlhbnQgKHN0bXRfdmVjX2luZm8gc3RtdF9pbmZvLAogICAg LSBpdCBoYXMgdXNlcyBvdXRzaWRlIHRoZSBsb29wLgogICAgLSBpdCBoYXMgdmRlZnMgKGl0IGFs dGVycyBtZW1vcnkpLgogICAgLSBjb250cm9sIHN0bXRzIGluIHRoZSBsb29wIChleGNlcHQgZm9y IHRoZSBleGl0IGNvbmRpdGlvbikuCisgICAtIGl0IGlzIGFuIGluZHVjdGlvbiBhbmQgd2UgaGF2 ZSBtdWx0aXBsZSBleGl0cy4KIAogICAgQ0hFQ0tNRTogd2hhdCBvdGhlciBzaWRlIGVmZmVjdHMg d291bGQgdGhlIHZlY3Rvcml6ZXIgYWxsb3c/ICAqLwogCkBAIC0zOTksNiArNDAwLDE5IEBAIHZl Y3Rfc3RtdF9yZWxldmFudF9wIChzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywgbG9vcF92ZWNfaW5m byBsb29wX3ZpbmZvLAogCX0KICAgICB9CiAKKyAgLyogQ2hlY2sgaWYgaXQncyBhbiBpbmR1Y3Rp b24gYW5kIG11bHRpcGxlIGV4aXRzLiAgSW4gdGhpcyBjYXNlIHRoZXJlIHdpbGwgYmUKKyAgICAg YSB1c2FnZSBsYXRlciBvbiBhZnRlciBwZWVsaW5nIHdoaWNoIGlzIG5lZWRlZCBmb3IgdGhlIGFs dGVybmF0ZSBleGl0LiAgKi8KKyAgaWYgKExPT1BfVklORk9fRUFSTFlfQlJFQUtTIChsb29wX3Zp bmZvKQorICAgICAgJiYgU1RNVF9WSU5GT19ERUZfVFlQRSAoc3RtdF9pbmZvKSA9PSB2ZWN0X2lu ZHVjdGlvbl9kZWYpCisgICAgeworICAgICAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorCSAgZHVt cF9wcmludGZfbG9jIChNU0dfTk9URSwgdmVjdF9sb2NhdGlvbiwKKwkJCSAgICJ2ZWNfc3RtdF9y ZWxldmFudF9wOiBpbmR1Y3Rpb24gZm9yY2VkIGZvciAiCisJCQkgICAiZWFybHkgYnJlYWsuXG4i KTsKKyAgICAgICpsaXZlX3AgPSB0cnVlOworCisgICAgfQorCiAgIGlmICgqbGl2ZV9wICYmICpy ZWxldmFudCA9PSB2ZWN0X3VudXNlZF9pbl9zY29wZQogICAgICAgJiYgIWlzX3NpbXBsZV9hbmRf YWxsX3VzZXNfaW52YXJpYW50IChzdG10X2luZm8sIGxvb3BfdmluZm8pKQogICAgIHsKQEAgLTE3 NzQsNyArMTc4OCw3IEBAIGNvbXBhcmVfc3RlcF93aXRoX3plcm8gKHZlY19pbmZvICp2aW5mbywg c3RtdF92ZWNfaW5mbyBzdG10X2luZm8pCiAvKiBJZiB0aGUgdGFyZ2V0IHN1cHBvcnRzIGEgcGVy bXV0ZSBtYXNrIHRoYXQgcmV2ZXJzZXMgdGhlIGVsZW1lbnRzIGluCiAgICBhIHZlY3RvciBvZiB0 eXBlIFZFQ1RZUEUsIHJldHVybiB0aGF0IG1hc2ssIG90aGVyd2lzZSByZXR1cm4gbnVsbC4gICov CiAKLXN0YXRpYyB0cmVlCit0cmVlCiBwZXJtX21hc2tfZm9yX3JldmVyc2UgKHRyZWUgdmVjdHlw ZSkKIHsKICAgcG9seV91aW50NjQgbnVuaXRzID0gVFlQRV9WRUNUT1JfU1VCUEFSVFMgKHZlY3R5 cGUpOwpAQCAtMTI3MjAsMjAgKzEyNzM0LDI3IEBAIGNhbl92ZWN0b3JpemVfbGl2ZV9zdG10cyAo dmVjX2luZm8gKnZpbmZvLCBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywKIAkJCSAgYm9vbCB2ZWNf c3RtdF9wLAogCQkJICBzdG10X3ZlY3Rvcl9mb3JfY29zdCAqY29zdF92ZWMpCiB7CisgIGxvb3Bf dmVjX2luZm8gbG9vcF92aW5mbyA9IGR5bl9jYXN0IDxsb29wX3ZlY19pbmZvPiAodmluZm8pOwog ICBpZiAoc2xwX25vZGUpCiAgICAgewogICAgICAgc3RtdF92ZWNfaW5mbyBzbHBfc3RtdF9pbmZv OwogICAgICAgdW5zaWduZWQgaW50IGk7CiAgICAgICBGT1JfRUFDSF9WRUNfRUxUIChTTFBfVFJF RV9TQ0FMQVJfU1RNVFMgKHNscF9ub2RlKSwgaSwgc2xwX3N0bXRfaW5mbykKIAl7Ci0JICBpZiAo U1RNVF9WSU5GT19MSVZFX1AgKHNscF9zdG10X2luZm8pCisJICBpZiAoKFNUTVRfVklORk9fTElW RV9QIChzbHBfc3RtdF9pbmZvKQorCSAgICAgICB8fCAobG9vcF92aW5mbworCQkgICAmJiBMT09Q X1ZJTkZPX0VBUkxZX0JSRUFLUyAobG9vcF92aW5mbykKKwkJICAgJiYgU1RNVF9WSU5GT19ERUZf VFlQRSAoc2xwX3N0bXRfaW5mbykKKwkJCT09IHZlY3RfaW5kdWN0aW9uX2RlZikpCiAJICAgICAg JiYgIXZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbiAodmluZm8sIHNscF9zdG10X2luZm8sIHNs cF9ub2RlLAogCQkJCQkgICAgICAgc2xwX25vZGVfaW5zdGFuY2UsIGksCiAJCQkJCSAgICAgICB2 ZWNfc3RtdF9wLCBjb3N0X3ZlYykpCiAJICAgIHJldHVybiBmYWxzZTsKIAl9CiAgICAgfQotICBl bHNlIGlmIChTVE1UX1ZJTkZPX0xJVkVfUCAoc3RtdF9pbmZvKQorICBlbHNlIGlmICgoU1RNVF9W SU5GT19MSVZFX1AgKHN0bXRfaW5mbykKKwkgICAgfHwgKExPT1BfVklORk9fRUFSTFlfQlJFQUtT IChsb29wX3ZpbmZvKQorCQkmJiBTVE1UX1ZJTkZPX0RFRl9UWVBFIChzdG10X2luZm8pID09IHZl Y3RfaW5kdWN0aW9uX2RlZikpCiAJICAgJiYgIXZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbiAo dmluZm8sIHN0bXRfaW5mbywKIAkJCQkJICAgIHNscF9ub2RlLCBzbHBfbm9kZV9pbnN0YW5jZSwg LTEsCiAJCQkJCSAgICB2ZWNfc3RtdF9wLCBjb3N0X3ZlYykpCmRpZmYgLS1naXQgYS9nY2MvdHJl ZS12ZWN0b3JpemVyLmggYi9nY2MvdHJlZS12ZWN0b3JpemVyLmgKaW5kZXggZGU2MGRhMzFlMmEz MDMwYTdmYmMzMDJkM2Y2NzZhZjk2ODNmZDAxOS4uZmQ0YjBhNzg3ZTYxMjhiNDNjNWNhMmIwNjEy ZjU1ODQ1ZTZiM2NlZiAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtdmVjdG9yaXplci5oCisrKyBiL2dj Yy90cmVlLXZlY3Rvcml6ZXIuaApAQCAtMjI0OCw2ICsyMjQ4LDcgQEAgZXh0ZXJuIGJvb2wgdmVj dF9pc19zaW1wbGVfdXNlICh2ZWNfaW5mbyAqLCBzdG10X3ZlY19pbmZvLCBzbHBfdHJlZSwKIAkJ CQllbnVtIHZlY3RfZGVmX3R5cGUgKiwKIAkJCQl0cmVlICosIHN0bXRfdmVjX2luZm8gKiA9IE5V TEwpOwogZXh0ZXJuIGJvb2wgdmVjdF9tYXliZV91cGRhdGVfc2xwX29wX3ZlY3R5cGUgKHNscF90 cmVlLCB0cmVlKTsKK2V4dGVybiB0cmVlIHBlcm1fbWFza19mb3JfcmV2ZXJzZSAodHJlZSk7CiBl eHRlcm4gYm9vbCBzdXBwb3J0YWJsZV93aWRlbmluZ19vcGVyYXRpb24gKHZlY19pbmZvKiwgY29k ZV9oZWxwZXIsCiAJCQkJCSAgICBzdG10X3ZlY19pbmZvLCB0cmVlLCB0cmVlLAogCQkJCQkgICAg Y29kZV9oZWxwZXIqLCBjb2RlX2hlbHBlciosCg== --_002_VI1PR08MB5325273CEE65AD07032C7A8BFFBDAVI1PR08MB5325eurp_--