From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR03-AM7-obe.outbound.protection.outlook.com (mail-am7eur03on2053.outbound.protection.outlook.com [40.107.105.53]) by sourceware.org (Postfix) with ESMTPS id 520B63858439 for ; Wed, 20 Dec 2023 10:51:51 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 520B63858439 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 520B63858439 Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=40.107.105.53 ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1703069515; cv=pass; b=MLEZ30OyXw5OJMLwy0R+C6hZ2GXn3NqVy6cd/JDNXeY5m2U7KDiPzYjy2r5VBqrPOadjYFu49afejxggr9f7Lu4J69/IDM4OBe6snpViAh8+of8VLp5XObxHLZfne/5h2ibYtoQjYCwaz/nD3ZY76wA6LcdFHwTNFaJPr/jbF1k= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1703069515; c=relaxed/simple; bh=BARgUQ2Gzo4CTjQwIai0avAxiL5jbmhlEPWvs7BynUk=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=hHrKZU+JBfuiSsQkB4E5UINyirVXabWgEqZvryqfjKD7HOtUExxPWuNFA1HMCqnYg9ZJeA4gaiynV8dafQYa2iJlH8/1HDw0ZVgekQQVbxjG+FtGpTWEqjS8BXcrVyS/m3r8bX00dOVDregJjd9gHE3iCPgQx3O/4yx6Q6YJ5nM= ARC-Authentication-Results: i=3; server2.sourceware.org ARC-Seal: i=2; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=pass; b=UHoQoAWbbsih5KSmL02zXVdsNgA0WEFlubCI4pGJi5u/+qZY4wxHtZcMnviEHdeyAWfxP64jC6wO/HDWVdX74vK4TTB9YRzwCpwbppQdW5IeEYLO88Ih0tUGdZPHuy97LffidnWEwtuPtv9wkNV/vetZnUCvzKhbX+kJbtfDLL+gmKzoTukbCkjnniz2lr7PvCxiWhdo7jcxDJWPpckX3q94GO/f/XsfYYkQuuTmisa+GAmB+iUMAwSBisPHT+a1VXlHoKv04XTkGwwIieqKtn38pSZ3V0Ho3ufC/0DFWBQ6FiLU+eEnDLR/PGN0Bn3DYXV024LuIKlHKz8eMXTAIA== 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=gDljtWHjg81JIqS4jCEPjOpGTKdgpmM17d78Y8UXa48=; b=ThY9WIGd04Clk+CuyG0HyIyFk/NTv/ggj4rp071/19p43n6sYhLFDMKIPDSwrUML+7A73TTBI+6yw2ukiNvZ9mMLLKKn25KiQUDDn29ZMU90Hupz2BkGJXi1JTiRbtKfu/yD7xjiL8vKlw6uPkZssIIzX71/nKmqJrU7QnrUa4V+7W+349Feks6tw73cC1GrkeW02vLms2lX//WPEvLow0zS7YBctn11cShtjKAh0HQ7XzGQpvkJY5a2CGqHNcNBk9tsUn8dzQqqiYlt5A3Kchmg408XAfE+hWdDQwZhJZAIB1XIFwdbyn6rb/kRCr4zqKZA59iKq9v0kmYc4ZUI8A== 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=gDljtWHjg81JIqS4jCEPjOpGTKdgpmM17d78Y8UXa48=; b=mlAGNEmeuB4Ke2lYiSztHgpCPJHPm8+TWrgc2dmAYKNmoC9DGQlCfaJg8DTpk/FDIpaUnIPbTlisNwxTvTAis22unniFdSoge6PhFn6f/GYA3INX4e/kkLzrJeEKK20C8PPWukjDtCrls4PDfU4uvz6duP1uEsShTLCV7OjIjp8= Received: from AM4PR07CA0013.eurprd07.prod.outlook.com (2603:10a6:205:1::26) by AM9PR08MB6162.eurprd08.prod.outlook.com (2603:10a6:20b:2df::20) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7113.18; Wed, 20 Dec 2023 10:51:46 +0000 Received: from AM4PEPF00025F9B.EURPRD83.prod.outlook.com (2603:10a6:205:1:cafe::e9) by AM4PR07CA0013.outlook.office365.com (2603:10a6:205:1::26) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7113.17 via Frontend Transport; Wed, 20 Dec 2023 10:51:46 +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 AM4PEPF00025F9B.mail.protection.outlook.com (10.167.16.10) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7113.18 via Frontend Transport; Wed, 20 Dec 2023 10:51:46 +0000 Received: ("Tessian outbound e243565b0037:v228"); Wed, 20 Dec 2023 10:51:46 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: 9cb23ef36365b2c3 X-CR-MTA-TID: 64aa7808 Received: from b3a41f2e9617.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id F33D7028-82FD-4F13-8574-C004F2360BFB.1; Wed, 20 Dec 2023 10:51:40 +0000 Received: from EUR04-VI1-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id b3a41f2e9617.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Wed, 20 Dec 2023 10:51:40 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=E4UY5/pBxooPTbp1jvC0w8KWYoMTxZ4M10dckFK5MGmFrTjydBXCoITYudmZl+FQ8B35O7FhptuUumOLKc4DC7dtTFXgRV8qS8vcubZnQt+TbA4UElT+enAKcpl0ca6GOTJF8GPtzEQYY8iaCavVseIlf1SKAbZTwZdM9Cbh6v7TrGDqHzt0/OnIdliRFLXkMOyDK+cEzX8/rgHSmz9oHAu1yK3fkta2p4n0k6Cvhvdn/hQ+vXgbAfFkNJEhGZt5d0v4/bkwvX4HuugDtICLzCyMP8iDccEy2HCmJjMRyDJLwcTizk/gf8TETfLTwshB3nYziP42bo7wK+TFsqZ2dw== 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=gDljtWHjg81JIqS4jCEPjOpGTKdgpmM17d78Y8UXa48=; b=VNPl8KX+vyzPLvttwMVJzwn9w3SPDKKGlm06KMPtPqbYSdL5v3JooOoxv876DHnnftfpJCxAa39CVgnOukC59LqC98mqBRk+kToBCSoSv5JYasxodX657VSLvrfQWjRG3G+fjynmVfZBA9/CoA3fFkTJgEFMFsvSCNXPeTLRdkcvB+FMCscAHuIqRdEecILE7/Zs69ww8m0t5VCYt+DY2/EW7o9IMxBBoLQaOGqXCTFMXO3MQ9mPsCtF3EV/dgCZqP7pZXh0wL35OKWzzieFZY7ueVFB5iHTVtA9TLEEnbiQtv1Iza1wzbYx7fbt7L/sL414Y8VGe+h8nnGOMiu7EQ== 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=gDljtWHjg81JIqS4jCEPjOpGTKdgpmM17d78Y8UXa48=; b=mlAGNEmeuB4Ke2lYiSztHgpCPJHPm8+TWrgc2dmAYKNmoC9DGQlCfaJg8DTpk/FDIpaUnIPbTlisNwxTvTAis22unniFdSoge6PhFn6f/GYA3INX4e/kkLzrJeEKK20C8PPWukjDtCrls4PDfU4uvz6duP1uEsShTLCV7OjIjp8= Received: from VI1PR08MB5325.eurprd08.prod.outlook.com (2603:10a6:803:13e::17) by DU2PR08MB7325.eurprd08.prod.outlook.com (2603:10a6:10:2e4::7) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7113.18; Wed, 20 Dec 2023 10:51:37 +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.7113.016; Wed, 20 Dec 2023 10:51:36 +0000 From: Tamar Christina To: Richard Biener CC: "gcc-patches@gcc.gnu.org" , nd , "jlaw@ventanamicro.com" Subject: RE: [PATCH 3/21]middle-end: Implement code motion and dependency analysis for early breaks Thread-Topic: [PATCH 3/21]middle-end: Implement code motion and dependency analysis for early breaks Thread-Index: AQHaEIQp4D2KVmnz+EejwZw34pdOQrBusCOAgAABsMCAADkUgIBBunOQgABClICAAC6CEA== Date: Wed, 20 Dec 2023 10:51:36 +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_|DU2PR08MB7325:EE_|AM4PEPF00025F9B:EE_|AM9PR08MB6162:EE_ X-MS-Office365-Filtering-Correlation-Id: 488937ba-3100-4696-b6c4-08dc0149a994 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: 4/xpNpNADITtoubk+ayqh12jX9t1uWYOiCHuBg2lob2b0zvPI3Jvw3FyZdUzr41vh3IW8anylwLRmNKkqnZhxerjt0pDcpA1j0szGKQZB8OvB/9BuR6JC6cnG1rZIg7xTTkxBqY5g0w51ZsbJsSAiQFPvw3rtrlLbw1u2AvEGXTIDYaQ51Z41QpWH2GKU2W4ikcTjLgSvUfKnaKUfjW0VQCjyrPAoRdnURGYyjY2TW/B+dEXb5XdbNGhCrb660Kt42n5xsp8JTfBuQ167SkSKfxQ5nNU3xoLeA3PNxjrJ1surSP3L+vq1+W76CiO6NbTkbMQf9MDPXB8ntIp2PEIuUehCPL8sfSFjmVkGlTSxx7tqDk5Fx/3LxNUFKQ6lZ9pByKe62imPrUzmmQvnxmrsqsNER8oTB2Zm2iKu3jFdG7VTzOYWjGw413+Wfl9EzqDOlhu7L7DL0/yC+Rwphm2Dp5JGg017J6UEiCATJ6r0HkCJgZ2pD5c5Scs5hn23orBX93ERJaLiXiTf/btkhF/Ef2PGS/WkfUXldbHycmAXQr6ebUNMB2dar4uwBSDou3GV35fzOWvVYgnJLppTPeAwOG8ATa/jmwkrA25qN6c21w= 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)(396003)(136003)(366004)(39850400004)(346002)(230922051799003)(451199024)(186009)(1800799012)(64100799003)(55016003)(66899024)(84970400001)(41300700001)(9686003)(86362001)(6506007)(7696005)(26005)(478600001)(38070700009)(8676002)(4326008)(2906002)(8936002)(30864003)(5660300002)(33656002)(122000001)(83380400001)(71200400001)(316002)(6916009)(76116006)(52536014)(66446008)(66476007)(66556008)(66946007)(54906003)(64756008)(38100700002)(99936003)(559001)(579004);DIR:OUT;SFP:1101; Content-Type: multipart/mixed; boundary="_002_VI1PR08MB5325C3CEBA05F52781C818BFFF96AVI1PR08MB5325eurp_" MIME-Version: 1.0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: DU2PR08MB7325 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: AM4PEPF00025F9B.EURPRD83.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: 41748d2a-fbf8-4ad4-2660-08dc0149a399 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: XGRLMu8dZ2lJa3UkBUaymhwOtbOdQl9rebSiftaUP+yvMELFNJwopmBx6j/lhWNkF0T0tGdHzV8N9fImpExKORTGgDnKkvN2qrbLJBsiiE3wkph5tccD6IUS48qzl68fXvq9AIGL2zbgvV2YsdLSltkq7S9+yf7syAxbZHJkJeNyfEVOFYw3hRfwz7+ma4dS0uGTy2kbkUNAtg1ocm5JsyNaSj70fVZ1qM5QQGOgFkFqC1uXk4L61PbWato1lrkJ4SMAVthJx+zEoTeC/RRnFxVp2InJa8ZZhsPKbs8f1nQ1X8lxw0YRXeSSmc6+QCmcbqdiyWUcIVWK/PyVSvtx5FWm6/ycFUbHfL0nhtc192NAQgP0Y2wZDgJRmr5kbCR3JY5sYXIpQ+yTShXGzvaWyXqh2vuXDvErQ7In/UMec6wOWEH9zmpAVFJANtIaEX/dCSTmEz0/pLbuWmqWeBHFn8ISIDlzZBf7Olq8Mua7t1JK9LoCIzWcx1ed9q59L6KJ3AMuHzHMIW0LzR2w5pDmC7+xia8idKo47CfMsg1G81j6oNjcUxoiz1w/M/fIxCHq+maay466NBmBkecFCfP5Og4yYjM9earuyNhLU/ETJ1qdz8IiGHnaR55Rrt2v9gQg61GZvsqWDVeQFeOnAt1Aoi3eDQLV0HkhD0cvh3xjiHFhM1IWgxZpLisCeMgiQEl6uvq7KxmYuQm16uMbxmshdW0gJjKCOldWKGXYZY0uTsJJWQcStIMQU9Dpr8opA/+wpvvmt6B4q8QdfMMh56rqBw== X-Forefront-Antispam-Report: CIP:63.35.35.123;CTRY:IE;LANG:en;SCL:1;SRV:;IPV:CAL;SFV:NSPM;H:64aa7808-outbound-1.mta.getcheckrecipient.com;PTR:ec2-63-35-35-123.eu-west-1.compute.amazonaws.com;CAT:NONE;SFS:(13230031)(4636009)(136003)(396003)(376002)(39860400002)(346002)(230922051799003)(451199024)(1800799012)(64100799003)(82310400011)(186009)(46966006)(36840700001)(40470700004)(52536014)(8676002)(6862004)(8936002)(47076005)(66899024)(4326008)(30864003)(82740400003)(99936003)(33656002)(86362001)(356005)(41300700001)(2906002)(81166007)(36860700001)(5660300002)(235185007)(26005)(107886003)(84970400001)(40480700001)(9686003)(55016003)(7696005)(70206006)(6506007)(40460700003)(70586007)(54906003)(478600001)(83380400001)(316002)(336012);DIR:OUT;SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Dec 2023 10:51:46.8478 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 488937ba-3100-4696-b6c4-08dc0149a994 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: AM4PEPF00025F9B.EURPRD83.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM9PR08MB6162 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_VI1PR08MB5325C3CEBA05F52781C818BFFF96AVI1PR08MB5325eurp_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable > > + /* If we've moved a VDEF, extract the defining MEM and update > > + usages of it. */ > > + tree vdef; > > + /* This statement is to be moved. */ > > + if ((vdef =3D gimple_vdef (stmt))) > > + LOOP_VINFO_EARLY_BRK_CONFLICT_STMTS > (loop_vinfo).safe_push ( > > + stmt); >=20 > I'm also unsure why you need 'chain' at all given you have the vector > of stores to be moved? >=20 Yeah, so originally I wanted to move statements other than stores. While s= tores are needed for correctness, the other statements would be so we didn't exte= nd the live range too much for intermediate values. This proved difficult but eventually I got it to work, but as you saw it wa= s meh code. Instead I guess the better approach is to teach sched1 in GCC 15 to schedul= e across branches in loops. With that in mind, I changed it to move only stores. Since stores never pr= oduce a and are sinks, I don't really need fixed nor chain. So here's a much cleaned up patch. Bootstrapped Regtested on aarch64-none-linux-gnu and x86_64-pc-linux-gnu no issues. Ok for master? Thanks, Tamar gcc/ChangeLog: * tree-if-conv.cc (ref_within_array_bound): Expose. * tree-vect-data-refs.cc (vect_analyze_early_break_dependences): New. (vect_analyze_data_ref_dependences): Use them. * tree-vect-loop.cc (_loop_vec_info::_loop_vec_info): Initialize early_breaks. (move_early_exit_stmts): New. (vect_transform_loop): use it/ * tree-vect-stmts.cc (vect_is_simple_use): Use vect_early_exit_def. * tree-vectorizer.h (enum vect_def_type): Add vect_early_exit_def. (ref_within_array_bound): New. (class _loop_vec_info): Add early_breaks, early_break_conflict, early_break_vuses. (LOOP_VINFO_EARLY_BREAKS): New. (LOOP_VINFO_EARLY_BRK_STORES): New. (LOOP_VINFO_EARLY_BRK_DEST_BB): New. (LOOP_VINFO_EARLY_BRK_VUSES): New. gcc/testsuite/ChangeLog: * gcc.dg/vect/vect-early-break_57.c: Update. * gcc.dg/vect/vect-early-break_79.c: New test. * gcc.dg/vect/vect-early-break_80.c: New test. * gcc.dg/vect/vect-early-break_81.c: New test. * gcc.dg/vect/vect-early-break_83.c: New test. --- inline copy of patch --- diff --git a/gcc/testsuite/gcc.dg/vect/vect-early-break_57.c b/gcc/testsuit= e/gcc.dg/vect/vect-early-break_57.c index be4a0c7426093059ce37a9f824defb7ae270094d..9a4e795f92b7a8577ac71827f5c= b0bd15d88ebe1 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-early-break_57.c +++ b/gcc/testsuite/gcc.dg/vect/vect-early-break_57.c @@ -5,6 +5,7 @@ /* { dg-additional-options "-Ofast" } */ =20 /* { dg-final { scan-tree-dump "LOOP VECTORIZED" "vect" } } */ +/* { dg-final { scan-tree-dump "epilog loop required" "vect" } } */ =20 void abort (); =20 diff --git a/gcc/testsuite/gcc.dg/vect/vect-early-break_79.c b/gcc/testsuit= e/gcc.dg/vect/vect-early-break_79.c new file mode 100644 index 0000000000000000000000000000000000000000..a26011ef1ba5aa000692babc90d= 46621efc2f8b5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-early-break_79.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target vect_early_break } */ +/* { dg-require-effective-target vect_int } */ + +/* { dg-additional-options "-Ofast" } */ + +/* { dg-final { scan-tree-dump-not "LOOP VECTORIZED" "vect" } } */ + +#undef N +#define N 32 + +unsigned vect_a[N]; +unsigned vect_b[N]; + =20 +unsigned test4(unsigned x) +{ + unsigned ret =3D 0; + for (int i =3D 0; i < 1024; i++) + { + vect_b[i] =3D x + i; + if (vect_a[i] > x) + break; + vect_a[i] =3D x; + =20 + } + return ret; +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-early-break_80.c b/gcc/testsuit= e/gcc.dg/vect/vect-early-break_80.c new file mode 100644 index 0000000000000000000000000000000000000000..ddf504e0c8787ae33a0e98045c1= c91f2b9f533a9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-early-break_80.c @@ -0,0 +1,43 @@ +/* { dg-require-effective-target vect_early_break } */ +/* { dg-require-effective-target vect_int } */ + +/* { dg-additional-options "-Ofast" } */ + +/* { dg-final { scan-tree-dump "LOOP VECTORIZED" "vect" } } */ + +extern void abort (); + +int x; +__attribute__ ((noinline, noipa)) +void foo (int *a, int *b) +{ + int local_x =3D x; + for (int i =3D 0; i < 1024; ++i) + { + if (i + local_x =3D=3D 13) + break; + a[i] =3D 2 * b[i]; + } +} + +int main () +{ + int a[1024] =3D {0}; + int b[1024] =3D {0}; + + for (int i =3D 0; i < 1024; i++) + b[i] =3D i; + + x =3D -512; + foo (a, b); + + if (a[524] !=3D 1048) + abort (); + + if (a[525] !=3D 0) + abort (); + + if (a[1023] !=3D 0) + abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-early-break_81.c b/gcc/testsuit= e/gcc.dg/vect/vect-early-break_81.c new file mode 100644 index 0000000000000000000000000000000000000000..c38e394ad87863f0702d422cb58= 018b979c9fba6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-early-break_81.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target vect_early_break } */ +/* { dg-require-effective-target vect_int } */ + +/* { dg-additional-options "-Ofast" } */ + +/* { dg-final { scan-tree-dump "LOOP VECTORIZED" "vect" } } */ +/* { dg-final { scan-tree-dump "epilog loop required" "vect" } } */ +void abort (); + +unsigned short sa[32]; +unsigned short sc[32] =3D {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, + 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31}; +unsigned short sb[32] =3D {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, + 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31}; +unsigned int ia[32]; +unsigned int ic[32] =3D {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45, + 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; +unsigned int ib[32] =3D {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45, + 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + +int main2 (int n) +{ + int i; + for (i =3D 0; i < n - 3; i++) + { + if (sa[i+3] !=3D sb[i] + sc[i] || ia[i+3] !=3D ib[i] + ic[i]) + abort (); + } +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-early-break_83.c b/gcc/testsuit= e/gcc.dg/vect/vect-early-break_83.c new file mode 100644 index 0000000000000000000000000000000000000000..227dcf1b7ab2ace149e692a6aab= 41cdd5d47d098 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-early-break_83.c @@ -0,0 +1,28 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target vect_early_break } */ +/* { dg-require-effective-target vect_int } */ + +/* { dg-additional-options "-Ofast" } */ + +/* { dg-final { scan-tree-dump-not "LOOP VECTORIZED" "vect" } } */ + +#include + +#define N 1024 +complex double vect_a[N]; +complex double vect_b[N]; + =20 +complex double test4(complex double x) +{ + complex double ret =3D 0; + for (int i =3D 0; i < N; i++) + { + volatile complex double z =3D vect_b[i]; + vect_b[i] =3D x + i + z; + if (vect_a[i] =3D=3D x) + return i; + vect_a[i] +=3D x * vect_b[i]; + =20 + } + return ret; +} diff --git a/gcc/tree-if-conv.cc b/gcc/tree-if-conv.cc index 0bde281c2468d8e7f43afc4fe0f757e221ad5edb..a31e3d5161684878a79817d30a6= 955c8370444d8 100644 --- a/gcc/tree-if-conv.cc +++ b/gcc/tree-if-conv.cc @@ -844,7 +844,7 @@ idx_within_array_bound (tree ref, tree *idx, void *dta) =20 /* Return TRUE if ref is a within bound array reference. */ =20 -static bool +bool ref_within_array_bound (gimple *stmt, tree ref) { class loop *loop =3D loop_containing_stmt (stmt); diff --git a/gcc/tree-vect-data-refs.cc b/gcc/tree-vect-data-refs.cc index d5c9c4a11c2e5d8fd287f412bfa86d081c2f8325..85ae75ff2eb12b4299e8b7b91d0= cf16e4549d08e 100644 --- a/gcc/tree-vect-data-refs.cc +++ b/gcc/tree-vect-data-refs.cc @@ -613,6 +613,241 @@ vect_analyze_data_ref_dependence (struct data_depende= nce_relation *ddr, return opt_result::success (); } =20 +/* Funcion vect_analyze_early_break_dependences. + + Examime all the data references in the loop and make sure that if we ha= ve + mulitple exits that we are able to safely move stores such that they be= come + safe for vectorization. The function also calculates the place where t= o move + the instructions to and computes what the new vUSE chain should be. + + This works in tandem with the CFG that will be produced by + slpeel_tree_duplicate_loop_to_edge_cfg later on. + + This function tries to validate whether an early break vectorization + is possible for the current instruction sequence. Returns True i + possible, otherwise False. + + Requirements: + - Any memory access must be to a fixed size buffer. + - There must not be any loads and stores to the same object. + - Multiple loads are allowed as long as they don't alias. + + NOTE: + This implemementation is very conservative. Any overlappig loads/stor= es + that take place before the early break statement gets rejected aside = from + WAR dependencies. + + i.e.: + + a[i] =3D 8 + c =3D a[i] + if (b[i]) + ... + + is not allowed, but + + c =3D a[i] + a[i] =3D 8 + if (b[i]) + ... + + is which is the common case. */ + +static opt_result +vect_analyze_early_break_dependences (loop_vec_info loop_vinfo) +{ + DUMP_VECT_SCOPE ("vect_analyze_early_break_dependences"); + + /* List of all load data references found during traversal. */ + auto_vec bases; + basic_block dest_bb =3D NULL; + + hash_set visited; + class loop *loop =3D LOOP_VINFO_LOOP (loop_vinfo); + class loop *loop_nest =3D loop_outer (loop); + + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "loop contains multiple exits, analyzing" + " statement dependencies.\n"); + + for (gimple *c : LOOP_VINFO_LOOP_CONDS (loop_vinfo)) + { + stmt_vec_info loop_cond_info =3D loop_vinfo->lookup_stmt (c); + if (STMT_VINFO_TYPE (loop_cond_info) !=3D loop_exit_ctrl_vec_info_ty= pe) + continue; + + gimple_stmt_iterator gsi =3D gsi_for_stmt (c); + + /* Now analyze all the remaining statements and try to determine whi= ch + instructions are allowed/needed to be moved. */ + while (!gsi_end_p (gsi)) + { + gimple *stmt =3D gsi_stmt (gsi); + gsi_prev (&gsi); + if (!gimple_has_ops (stmt) + || is_gimple_debug (stmt)) + continue; + + stmt_vec_info stmt_vinfo =3D loop_vinfo->lookup_stmt (stmt); + auto dr_ref =3D STMT_VINFO_DATA_REF (stmt_vinfo); + if (!dr_ref) + continue; + + /* We currently only support statically allocated objects due to + not having first-faulting loads support or peeling for + alignment support. Compute the size of the referenced object + (it could be dynamically allocated). */ + tree obj =3D DR_BASE_ADDRESS (dr_ref); + if (!obj || TREE_CODE (obj) !=3D ADDR_EXPR) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "early breaks only supported on statically" + " allocated objects.\n"); + return opt_result::failure_at (c, + "can't safely apply code motion to " + "dependencies of %G to vectorize " + "the early exit.\n", c); + } + + tree refop =3D TREE_OPERAND (obj, 0); + tree refbase =3D get_base_address (refop); + if (!refbase || !DECL_P (refbase) || !DECL_SIZE (refbase) + || TREE_CODE (DECL_SIZE (refbase)) !=3D INTEGER_CST) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "early breaks only supported on" + " statically allocated objects.\n"); + return opt_result::failure_at (c, + "can't safely apply code motion to " + "dependencies of %G to vectorize " + "the early exit.\n", c); + } + + /* Check if vector accesses to the object will be within bounds. + must be a constant or assume loop will be versioned or niters + bounded by VF so accesses are within range. */ + if (!ref_within_array_bound (stmt, DR_REF (dr_ref))) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "early breaks not supported: vectorization " + "would %s beyond size of obj.", + DR_IS_READ (dr_ref) ? "read" : "write"); + return opt_result::failure_at (c, + "can't safely apply code motion to " + "dependencies of %G to vectorize " + "the early exit.\n", c); + } + + if (DR_IS_READ (dr_ref)) + bases.safe_push (dr_ref); + else if (DR_IS_WRITE (dr_ref)) + { + /* We are moving writes down in the CFG. To be sure that this + is valid after vectorization we have to check all the loads + we are sinking the stores past to see if any of them may + alias or are the same object. + + Same objects will not be an issue because unless the store + is marked volatile the value can be forwarded. If the + store is marked volatile we don't vectorize the loop + anyway. + + That leaves the check for aliasing. We don't really need + to care about the stores aliasing with each other since the + stores are moved in order so the effects are still observed + correctly. This leaves the check for WAR dependencies + which we would be introducing here if the DR can alias. + The check is quadratic in loads/stores but I have not found + a better API to do this. I believe all loads and stores + must be checked. We also must check them when we + encountered the store, since we don't care about loads past + the store. */ + + for (auto dr_read : bases) + if (dr_may_alias_p (dr_ref, dr_read, loop_nest)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, + vect_location, + "early breaks not supported: " + "overlapping loads and stores " + "found before the break " + "statement.\n"); + + return opt_result::failure_at (stmt, + "can't safely apply code motion to dependencies" + " to vectorize the early exit. %G may alias with" + " %G\n", stmt, dr_read->stmt); + } + } + + if (gimple_vdef (stmt)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "=3D=3D> recording stmt %G", stmt); + + LOOP_VINFO_EARLY_BRK_STORES (loop_vinfo).safe_push (stmt); + } + else if (gimple_vuse (stmt)) + { + LOOP_VINFO_EARLY_BRK_VUSES (loop_vinfo).safe_insert (0, stmt); + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "marked statement for vUSE update: %G", stmt); + } + } + + /* Save destination as we go, BB are visited in order and the last o= ne + is where statements should be moved to. */ + if (!dest_bb) + dest_bb =3D gimple_bb (c); + else + { + basic_block curr_bb =3D gimple_bb (c); + if (dominated_by_p (CDI_DOMINATORS, curr_bb, dest_bb)) + dest_bb =3D curr_bb; + } + + /* Mark the statement as a condition. */ + STMT_VINFO_DEF_TYPE (loop_cond_info) =3D vect_condition_def; + } + + basic_block dest_bb0 =3D EDGE_SUCC (dest_bb, 0)->dest; + basic_block dest_bb1 =3D EDGE_SUCC (dest_bb, 1)->dest; + dest_bb =3D flow_bb_inside_loop_p (loop, dest_bb0) ? dest_bb0 : dest_bb1= ; + /* We don't allow outer -> inner loop transitions which should have been + trapped already during loop form analysis. */ + gcc_assert (dest_bb->loop_father =3D=3D loop); + + gcc_assert (dest_bb); + LOOP_VINFO_EARLY_BRK_DEST_BB (loop_vinfo) =3D dest_bb; + + if (!LOOP_VINFO_EARLY_BRK_VUSES (loop_vinfo).is_empty ()) + { + /* All uses shall be updated to that of the first load. Entries are + stored in reverse order. */ + tree vuse =3D gimple_vuse (LOOP_VINFO_EARLY_BRK_VUSES (loop_vinfo).l= ast ()); + for (auto g : LOOP_VINFO_EARLY_BRK_VUSES (loop_vinfo)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "will update use: %T, mem_ref: %G", vuse, g); + } + } + + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "recorded statements to be moved to BB %d\n", + LOOP_VINFO_EARLY_BRK_DEST_BB (loop_vinfo)->index); + + return opt_result::success (); +} + /* Function vect_analyze_data_ref_dependences. =20 Examine all the data references in the loop, and make sure there do not @@ -657,6 +892,11 @@ vect_analyze_data_ref_dependences (loop_vec_info loop_= vinfo, return res; } =20 + /* If we have early break statements in the loop, check to see if they + are of a form we can vectorizer. */ + if (LOOP_VINFO_EARLY_BREAKS (loop_vinfo)) + return vect_analyze_early_break_dependences (loop_vinfo); + return opt_result::success (); } =20 diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc index fb8d999ee6bfaff551ac06ac2f3aea5354914659..900826567fee36206c0711ea514= 95602a7a031a1 100644 --- a/gcc/tree-vect-loop.cc +++ b/gcc/tree-vect-loop.cc @@ -1040,6 +1040,7 @@ _loop_vec_info::_loop_vec_info (class loop *loop_in, = vec_info_shared *shared) partial_load_store_bias (0), peeling_for_gaps (false), peeling_for_niter (false), + early_breaks (false), no_data_dependencies (false), has_mask_store (false), scalar_loop_scaling (profile_probability::uninitialized ()), @@ -11548,6 +11549,56 @@ update_epilogue_loop_vinfo (class loop *epilogue, = tree advance) epilogue_vinfo->shared->save_datarefs (); } =20 +/* When vectorizing early break statements instructions that happen befor= e + the early break in the current BB need to be moved to after the early + break. This function deals with that and assumes that any validity + checks has already been performed. + + While moving the instructions if it encounters a VUSE or VDEF it then + corrects the VUSES as it moves the statements along. GDEST is the loc= ation + in which to insert the new statements. */ + +static void +move_early_exit_stmts (loop_vec_info loop_vinfo) +{ + DUMP_VECT_SCOPE ("move_early_exit_stmts"); + + if (LOOP_VINFO_EARLY_BRK_STORES (loop_vinfo).is_empty ()) + return; + + /* Move all stmts that need moving. */ + basic_block dest_bb =3D LOOP_VINFO_EARLY_BRK_DEST_BB (loop_vinfo); + gimple_stmt_iterator dest_gsi =3D gsi_start_bb (dest_bb); + + for (gimple *stmt : LOOP_VINFO_EARLY_BRK_STORES (loop_vinfo)) + { + /* Check to see if statement is still required for vect or has been + elided. */ + auto stmt_info =3D loop_vinfo->lookup_stmt (stmt); + if (!stmt_info) + continue; + + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, "moving stmt %G", stmt); + + gimple_stmt_iterator stmt_gsi =3D gsi_for_stmt (stmt); + gsi_move_before (&stmt_gsi, &dest_gsi); + gsi_prev (&dest_gsi); + } + + /* Update all the stmts with their new reaching VUSES. */ + tree vuse + =3D gimple_vuse (LOOP_VINFO_EARLY_BRK_STORES (loop_vinfo).last ()); + for (auto p : LOOP_VINFO_EARLY_BRK_VUSES (loop_vinfo)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "updating vuse to %T for load %G", vuse, p); + gimple_set_vuse (p, vuse); + update_stmt (p); + } +} + /* Function vect_transform_loop. =20 The analysis phase has determined that the loop is vectorizable. @@ -11697,6 +11748,11 @@ vect_transform_loop (loop_vec_info loop_vinfo, gim= ple *loop_vectorized_call) vect_schedule_slp (loop_vinfo, LOOP_VINFO_SLP_INSTANCES (loop_vinfo)= ); } =20 + /* Handle any code motion that we need to for early-break vectorization = after + we've done peeling but just before we start vectorizing. */ + if (LOOP_VINFO_EARLY_BREAKS (loop_vinfo)) + move_early_exit_stmts (loop_vinfo); + /* FORNOW: the vectorizer supports only loops which body consist of one basic block (header + empty latch). When the vectorizer will support more involved loop forms, the order by which the BBs are diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index 96e4a6cffadebb43946c5cb7e9849c915da589bc..b3a09c0a804a38e17ef32b6ce13= b98b077459fc7 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -359,8 +359,8 @@ vect_stmt_relevant_p (stmt_vec_info stmt_info, loop_vec= _info loop_vinfo, *live_p =3D false; =20 /* cond stmt other than loop exit cond. */ - if (is_ctrl_stmt (stmt_info->stmt) - && STMT_VINFO_TYPE (stmt_info) !=3D loop_exit_ctrl_vec_info_type) + gimple *stmt =3D STMT_VINFO_STMT (stmt_info); + if (dyn_cast (stmt)) *relevant =3D vect_used_in_scope; =20 /* changing memory. */ @@ -13530,6 +13530,9 @@ vect_is_simple_use (tree operand, vec_info *vinfo, = enum vect_def_type *dt, case vect_first_order_recurrence: dump_printf (MSG_NOTE, "first order recurrence\n"); break; + case vect_condition_def: + dump_printf (MSG_NOTE, "control flow\n"); + break; case vect_unknown_def_type: dump_printf (MSG_NOTE, "unknown\n"); break; diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index e4d7ab4567cef3c018b958f98eeff045d3477725..744cdc86c969a62574be488df4f= 9c222b68f7994 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -66,6 +66,7 @@ enum vect_def_type { vect_double_reduction_def, vect_nested_cycle, vect_first_order_recurrence, + vect_condition_def, vect_unknown_def_type }; =20 @@ -888,6 +889,10 @@ public: we need to peel off iterations at the end to form an epilogue loop. = */ bool peeling_for_niter; =20 + /* When the loop has early breaks that we can vectorize we need to peel + the loop for the break finding loop. */ + bool early_breaks; + /* List of loop additional IV conditionals found in the loop. */ auto_vec conds; =20 @@ -942,6 +947,20 @@ public: /* The controlling loop IV for the scalar loop being vectorized. This I= V controls the natural exits of the loop. */ edge scalar_loop_iv_exit; + + /* Used to store the list of stores needing to be moved if doing early + break vectorization as they would violate the scalar loop semantics i= f + vectorized in their current location. These are stored in order that= they + need to be moved. */ + auto_vec early_break_stores; + + /* The final basic block where to move statements to. In the case of + multiple exits this could be pretty far away. */ + basic_block early_break_dest_bb; + + /* Statements whose VUSES need updating if early break vectorization is = to + happen. */ + auto_vec early_break_vuses; } *loop_vec_info; =20 /* Access Functions. */ @@ -996,6 +1015,10 @@ public: #define LOOP_VINFO_REDUCTION_CHAINS(L) (L)->reduction_chains #define LOOP_VINFO_PEELING_FOR_GAPS(L) (L)->peeling_for_gaps #define LOOP_VINFO_PEELING_FOR_NITER(L) (L)->peeling_for_niter +#define LOOP_VINFO_EARLY_BREAKS(L) (L)->early_breaks +#define LOOP_VINFO_EARLY_BRK_STORES(L) (L)->early_break_stores +#define LOOP_VINFO_EARLY_BRK_DEST_BB(L) (L)->early_break_dest_bb +#define LOOP_VINFO_EARLY_BRK_VUSES(L) (L)->early_break_vuses #define LOOP_VINFO_LOOP_CONDS(L) (L)->conds #define LOOP_VINFO_LOOP_IV_COND(L) (L)->loop_iv_cond #define LOOP_VINFO_NO_DATA_DEPENDENCIES(L) (L)->no_data_dependencies @@ -2298,6 +2321,9 @@ extern opt_result vect_get_vector_types_for_stmt (vec= _info *, tree *, unsigned int =3D 0); extern opt_tree vect_get_mask_type_for_stmt (stmt_vec_info, unsigned int = =3D 0); =20 +/* In tree-if-conv.cc. */ +extern bool ref_within_array_bound (gimple *, tree); + /* In tree-vect-data-refs.cc. */ extern bool vect_can_force_dr_alignment_p (const_tree, poly_uint64); extern enum dr_alignment_support vect_supportable_dr_alignment --_002_VI1PR08MB5325C3CEBA05F52781C818BFFF96AVI1PR08MB5325eurp_ Content-Type: application/octet-stream; name="rb17963 (1).patch" Content-Description: rb17963 (1).patch Content-Disposition: attachment; filename="rb17963 (1).patch"; size=21054; creation-date="Wed, 20 Dec 2023 10:51:26 GMT"; modification-date="Wed, 20 Dec 2023 10:51:36 GMT" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVjdC1lYXJseS1icmVha181 Ny5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFrXzU3LmMKaW5k ZXggYmU0YTBjNzQyNjA5MzA1OWNlMzdhOWY4MjRkZWZiN2FlMjcwMDk0ZC4uOWE0ZTc5NWY5MmI3 YTg1NzdhYzcxODI3ZjVjYjBiZDE1ZDg4ZWJlMSAxMDA2NDQKLS0tIGEvZ2NjL3Rlc3RzdWl0ZS9n Y2MuZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFrXzU3LmMKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2Mu ZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFrXzU3LmMKQEAgLTUsNiArNSw3IEBACiAvKiB7IGRnLWFk ZGl0aW9uYWwtb3B0aW9ucyAiLU9mYXN0IiB9ICovCiAKIC8qIHsgZGctZmluYWwgeyBzY2FuLXRy ZWUtZHVtcCAiTE9PUCBWRUNUT1JJWkVEIiAidmVjdCIgfSB9ICovCisvKiB7IGRnLWZpbmFsIHsg c2Nhbi10cmVlLWR1bXAgImVwaWxvZyBsb29wIHJlcXVpcmVkIiAidmVjdCIgfSB9ICovCiAKIHZv aWQgYWJvcnQgKCk7CiAKZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVj dC1lYXJseS1icmVha183OS5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5 LWJyZWFrXzc5LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYTI2MDExZWYxYmE1YWEwMDA2OTJiYWJjOTBkNDY2MjFl ZmMyZjhiNQotLS0gL2Rldi9udWxsCisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVj dC1lYXJseS1icmVha183OS5jCkBAIC0wLDAgKzEsMjcgQEAKKy8qIHsgZGctZG8gY29tcGlsZSB9 ICovCisvKiB7IGRnLXJlcXVpcmUtZWZmZWN0aXZlLXRhcmdldCB2ZWN0X2Vhcmx5X2JyZWFrIH0g Ki8KKy8qIHsgZGctcmVxdWlyZS1lZmZlY3RpdmUtdGFyZ2V0IHZlY3RfaW50IH0gKi8KKworLyog eyBkZy1hZGRpdGlvbmFsLW9wdGlvbnMgIi1PZmFzdCIgfSAqLworCisvKiB7IGRnLWZpbmFsIHsg c2Nhbi10cmVlLWR1bXAtbm90ICJMT09QIFZFQ1RPUklaRUQiICJ2ZWN0IiB9IH0gKi8KKworI3Vu ZGVmIE4KKyNkZWZpbmUgTiAzMgorCit1bnNpZ25lZCB2ZWN0X2FbTl07Cit1bnNpZ25lZCB2ZWN0 X2JbTl07CisgIAordW5zaWduZWQgdGVzdDQodW5zaWduZWQgeCkKK3sKKyB1bnNpZ25lZCByZXQg PSAwOworIGZvciAoaW50IGkgPSAwOyBpIDwgMTAyNDsgaSsrKQorIHsKKyAgIHZlY3RfYltpXSA9 IHggKyBpOworICAgaWYgKHZlY3RfYVtpXSA+IHgpCisgICAgIGJyZWFrOworICAgdmVjdF9hW2ld ID0geDsKKyAgIAorIH0KKyByZXR1cm4gcmV0OworfQpkaWZmIC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0 ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFrXzgwLmMgYi9nY2MvdGVzdHN1aXRlL2djYy5k Zy92ZWN0L3ZlY3QtZWFybHktYnJlYWtfODAuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kZGY1MDRlMGM4Nzg3YWUz M2EwZTk4MDQ1YzFjOTFmMmI5ZjUzM2E5Ci0tLSAvZGV2L251bGwKKysrIGIvZ2NjL3Rlc3RzdWl0 ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFrXzgwLmMKQEAgLTAsMCArMSw0MyBAQAorLyog eyBkZy1yZXF1aXJlLWVmZmVjdGl2ZS10YXJnZXQgdmVjdF9lYXJseV9icmVhayB9ICovCisvKiB7 IGRnLXJlcXVpcmUtZWZmZWN0aXZlLXRhcmdldCB2ZWN0X2ludCB9ICovCisKKy8qIHsgZGctYWRk aXRpb25hbC1vcHRpb25zICItT2Zhc3QiIH0gKi8KKworLyogeyBkZy1maW5hbCB7IHNjYW4tdHJl ZS1kdW1wICJMT09QIFZFQ1RPUklaRUQiICJ2ZWN0IiB9IH0gKi8KKworZXh0ZXJuIHZvaWQgYWJv cnQgKCk7CisKK2ludCB4OworX19hdHRyaWJ1dGVfXyAoKG5vaW5saW5lLCBub2lwYSkpCit2b2lk IGZvbyAoaW50ICphLCBpbnQgKmIpCit7CisgIGludCBsb2NhbF94ID0geDsKKyAgZm9yIChpbnQg aSA9IDA7IGkgPCAxMDI0OyArK2kpCisgICAgeworICAgICAgaWYgKGkgKyBsb2NhbF94ID09IDEz KQorICAgICAgICBicmVhazsKKyAgICAgIGFbaV0gPSAyICogYltpXTsKKyAgICB9Cit9CisKK2lu dCBtYWluICgpCit7CisgIGludCBhWzEwMjRdID0gezB9OworICBpbnQgYlsxMDI0XSA9IHswfTsK KworICBmb3IgKGludCBpID0gMDsgaSA8IDEwMjQ7IGkrKykKKyAgICBiW2ldID0gaTsKKworICB4 ID0gLTUxMjsKKyAgZm9vIChhLCBiKTsKKworICBpZiAoYVs1MjRdICE9IDEwNDgpCisgICAgYWJv cnQgKCk7CisKKyAgaWYgKGFbNTI1XSAhPSAwKQorICAgIGFib3J0ICgpOworCisgIGlmIChhWzEw MjNdICE9IDApCisgICAgYWJvcnQgKCk7CisgIHJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvZ2Nj L3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFrXzgxLmMgYi9nY2MvdGVzdHN1 aXRlL2djYy5kZy92ZWN0L3ZlY3QtZWFybHktYnJlYWtfODEuYwpuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jMzhlMzk0 YWQ4Nzg2M2YwNzAyZDQyMmNiNTgwMThiOTc5YzlmYmE2Ci0tLSAvZGV2L251bGwKKysrIGIvZ2Nj L3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFrXzgxLmMKQEAgLTAsMCArMSwz MCBAQAorLyogeyBkZy1kbyBjb21waWxlIH0gKi8KKy8qIHsgZGctcmVxdWlyZS1lZmZlY3RpdmUt dGFyZ2V0IHZlY3RfZWFybHlfYnJlYWsgfSAqLworLyogeyBkZy1yZXF1aXJlLWVmZmVjdGl2ZS10 YXJnZXQgdmVjdF9pbnQgfSAqLworCisvKiB7IGRnLWFkZGl0aW9uYWwtb3B0aW9ucyAiLU9mYXN0 IiB9ICovCisKKy8qIHsgZGctZmluYWwgeyBzY2FuLXRyZWUtZHVtcCAiTE9PUCBWRUNUT1JJWkVE IiAidmVjdCIgfSB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAgImVwaWxvZyBs b29wIHJlcXVpcmVkIiAidmVjdCIgfSB9ICovCit2b2lkIGFib3J0ICgpOworCit1bnNpZ25lZCBz aG9ydCBzYVszMl07Cit1bnNpZ25lZCBzaG9ydCBzY1szMl0gPSB7MCwxLDIsMyw0LDUsNiw3LDgs OSwxMCwxMSwxMiwxMywxNCwxNSwKKyAgMTYsMTcsMTgsMTksMjAsMjEsMjIsMjMsMjQsMjUsMjYs MjcsMjgsMjksMzAsMzF9OwordW5zaWduZWQgc2hvcnQgc2JbMzJdID0gezAsMSwyLDMsNCw1LDYs Nyw4LDksMTAsMTEsMTIsMTMsMTQsMTUsCisgIDE2LDE3LDE4LDE5LDIwLDIxLDIyLDIzLDI0LDI1 LDI2LDI3LDI4LDI5LDMwLDMxfTsKK3Vuc2lnbmVkIGludCBpYVszMl07Cit1bnNpZ25lZCBpbnQg aWNbMzJdID0gezAsMyw2LDksMTIsMTUsMTgsMjEsMjQsMjcsMzAsMzMsMzYsMzksNDIsNDUsCisg ICAgICAgIDAsMSwyLDMsNCw1LDYsNyw4LDksMTAsMTEsMTIsMTMsMTQsMTV9OwordW5zaWduZWQg aW50IGliWzMyXSA9IHswLDMsNiw5LDEyLDE1LDE4LDIxLDI0LDI3LDMwLDMzLDM2LDM5LDQyLDQ1 LAorICAgICAgICAwLDEsMiwzLDQsNSw2LDcsOCw5LDEwLDExLDEyLDEzLDE0LDE1fTsKKworaW50 IG1haW4yIChpbnQgbikKK3sKKyAgaW50IGk7CisgIGZvciAoaSA9IDA7IGkgPCBuIC0gMzsgaSsr KQorICAgIHsKKyAgICAgIGlmIChzYVtpKzNdICE9IHNiW2ldICsgc2NbaV0gfHwgaWFbaSszXSAh PSBpYltpXSArIGljW2ldKQorICAgICAgICBhYm9ydCAoKTsKKyAgICB9Cit9CmRpZmYgLS1naXQg YS9nY2MvdGVzdHN1aXRlL2djYy5kZy92ZWN0L3ZlY3QtZWFybHktYnJlYWtfODMuYyBiL2djYy90 ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVjdC1lYXJseS1icmVha184My5jCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjIy N2RjZjFiN2FiMmFjZTE0OWU2OTJhNmFhYjQxY2RkNWQ0N2QwOTgKLS0tIC9kZXYvbnVsbAorKysg Yi9nY2MvdGVzdHN1aXRlL2djYy5kZy92ZWN0L3ZlY3QtZWFybHktYnJlYWtfODMuYwpAQCAtMCww ICsxLDI4IEBACisvKiB7IGRnLWRvIGNvbXBpbGUgfSAqLworLyogeyBkZy1yZXF1aXJlLWVmZmVj dGl2ZS10YXJnZXQgdmVjdF9lYXJseV9icmVhayB9ICovCisvKiB7IGRnLXJlcXVpcmUtZWZmZWN0 aXZlLXRhcmdldCB2ZWN0X2ludCB9ICovCisKKy8qIHsgZGctYWRkaXRpb25hbC1vcHRpb25zICIt T2Zhc3QiIH0gKi8KKworLyogeyBkZy1maW5hbCB7IHNjYW4tdHJlZS1kdW1wLW5vdCAiTE9PUCBW RUNUT1JJWkVEIiAidmVjdCIgfSB9ICovCisKKyNpbmNsdWRlIDxjb21wbGV4Lmg+CisKKyNkZWZp bmUgTiAxMDI0Citjb21wbGV4IGRvdWJsZSB2ZWN0X2FbTl07Citjb21wbGV4IGRvdWJsZSB2ZWN0 X2JbTl07CisgIAorY29tcGxleCBkb3VibGUgdGVzdDQoY29tcGxleCBkb3VibGUgeCkKK3sKKyBj b21wbGV4IGRvdWJsZSByZXQgPSAwOworIGZvciAoaW50IGkgPSAwOyBpIDwgTjsgaSsrKQorIHsK KyAgIHZvbGF0aWxlIGNvbXBsZXggZG91YmxlIHogPSB2ZWN0X2JbaV07CisgICB2ZWN0X2JbaV0g PSB4ICsgaSArIHo7CisgICBpZiAodmVjdF9hW2ldID09IHgpCisgICAgIHJldHVybiBpOworICAg dmVjdF9hW2ldICs9IHggKiB2ZWN0X2JbaV07CisgICAKKyB9CisgcmV0dXJuIHJldDsKK30KZGlm ZiAtLWdpdCBhL2djYy90cmVlLWlmLWNvbnYuY2MgYi9nY2MvdHJlZS1pZi1jb252LmNjCmluZGV4 IDBiZGUyODFjMjQ2OGQ4ZTdmNDNhZmM0ZmUwZjc1N2UyMjFhZDVlZGIuLmEzMWUzZDUxNjE2ODQ4 NzhhNzk4MTdkMzBhNjk1NWM4MzcwNDQ0ZDggMTAwNjQ0Ci0tLSBhL2djYy90cmVlLWlmLWNvbnYu Y2MKKysrIGIvZ2NjL3RyZWUtaWYtY29udi5jYwpAQCAtODQ0LDcgKzg0NCw3IEBAIGlkeF93aXRo aW5fYXJyYXlfYm91bmQgKHRyZWUgcmVmLCB0cmVlICppZHgsIHZvaWQgKmR0YSkKIAogLyogUmV0 dXJuIFRSVUUgaWYgcmVmIGlzIGEgd2l0aGluIGJvdW5kIGFycmF5IHJlZmVyZW5jZS4gICovCiAK LXN0YXRpYyBib29sCitib29sCiByZWZfd2l0aGluX2FycmF5X2JvdW5kIChnaW1wbGUgKnN0bXQs IHRyZWUgcmVmKQogewogICBjbGFzcyBsb29wICpsb29wID0gbG9vcF9jb250YWluaW5nX3N0bXQg KHN0bXQpOwpkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUtdmVjdC1kYXRhLXJlZnMuY2MgYi9nY2MvdHJl ZS12ZWN0LWRhdGEtcmVmcy5jYwppbmRleCBkNWM5YzRhMTFjMmU1ZDhmZDI4N2Y0MTJiZmE4NmQw ODFjMmY4MzI1Li44NWFlNzVmZjJlYjEyYjQyOTllOGI3YjkxZDBjZjE2ZTQ1NDlkMDhlIDEwMDY0 NAotLS0gYS9nY2MvdHJlZS12ZWN0LWRhdGEtcmVmcy5jYworKysgYi9nY2MvdHJlZS12ZWN0LWRh dGEtcmVmcy5jYwpAQCAtNjEzLDYgKzYxMywyNDEgQEAgdmVjdF9hbmFseXplX2RhdGFfcmVmX2Rl cGVuZGVuY2UgKHN0cnVjdCBkYXRhX2RlcGVuZGVuY2VfcmVsYXRpb24gKmRkciwKICAgcmV0dXJu IG9wdF9yZXN1bHQ6OnN1Y2Nlc3MgKCk7CiB9CiAKKy8qIEZ1bmNpb24gdmVjdF9hbmFseXplX2Vh cmx5X2JyZWFrX2RlcGVuZGVuY2VzLgorCisgICBFeGFtaW1lIGFsbCB0aGUgZGF0YSByZWZlcmVu Y2VzIGluIHRoZSBsb29wIGFuZCBtYWtlIHN1cmUgdGhhdCBpZiB3ZSBoYXZlCisgICBtdWxpdHBs ZSBleGl0cyB0aGF0IHdlIGFyZSBhYmxlIHRvIHNhZmVseSBtb3ZlIHN0b3JlcyBzdWNoIHRoYXQg dGhleSBiZWNvbWUKKyAgIHNhZmUgZm9yIHZlY3Rvcml6YXRpb24uICBUaGUgZnVuY3Rpb24gYWxz byBjYWxjdWxhdGVzIHRoZSBwbGFjZSB3aGVyZSB0byBtb3ZlCisgICB0aGUgaW5zdHJ1Y3Rpb25z IHRvIGFuZCBjb21wdXRlcyB3aGF0IHRoZSBuZXcgdlVTRSBjaGFpbiBzaG91bGQgYmUuCisKKyAg IFRoaXMgd29ya3MgaW4gdGFuZGVtIHdpdGggdGhlIENGRyB0aGF0IHdpbGwgYmUgcHJvZHVjZWQg YnkKKyAgIHNscGVlbF90cmVlX2R1cGxpY2F0ZV9sb29wX3RvX2VkZ2VfY2ZnIGxhdGVyIG9uLgor CisgICBUaGlzIGZ1bmN0aW9uIHRyaWVzIHRvIHZhbGlkYXRlIHdoZXRoZXIgYW4gZWFybHkgYnJl YWsgdmVjdG9yaXphdGlvbgorICAgaXMgcG9zc2libGUgZm9yIHRoZSBjdXJyZW50IGluc3RydWN0 aW9uIHNlcXVlbmNlLiBSZXR1cm5zIFRydWUgaQorICAgcG9zc2libGUsIG90aGVyd2lzZSBGYWxz ZS4KKworICAgUmVxdWlyZW1lbnRzOgorICAgICAtIEFueSBtZW1vcnkgYWNjZXNzIG11c3QgYmUg dG8gYSBmaXhlZCBzaXplIGJ1ZmZlci4KKyAgICAgLSBUaGVyZSBtdXN0IG5vdCBiZSBhbnkgbG9h ZHMgYW5kIHN0b3JlcyB0byB0aGUgc2FtZSBvYmplY3QuCisgICAgIC0gTXVsdGlwbGUgbG9hZHMg YXJlIGFsbG93ZWQgYXMgbG9uZyBhcyB0aGV5IGRvbid0IGFsaWFzLgorCisgICBOT1RFOgorICAg ICBUaGlzIGltcGxlbWVtZW50YXRpb24gaXMgdmVyeSBjb25zZXJ2YXRpdmUuIEFueSBvdmVybGFw cGlnIGxvYWRzL3N0b3JlcworICAgICB0aGF0IHRha2UgcGxhY2UgYmVmb3JlIHRoZSBlYXJseSBi cmVhayBzdGF0ZW1lbnQgZ2V0cyByZWplY3RlZCBhc2lkZSBmcm9tCisgICAgIFdBUiBkZXBlbmRl bmNpZXMuCisKKyAgICAgaS5lLjoKKworCWFbaV0gPSA4CisJYyA9IGFbaV0KKwlpZiAoYltpXSkK KwkgIC4uLgorCisJaXMgbm90IGFsbG93ZWQsIGJ1dAorCisJYyA9IGFbaV0KKwlhW2ldID0gOAor CWlmIChiW2ldKQorCSAgLi4uCisKKwlpcyB3aGljaCBpcyB0aGUgY29tbW9uIGNhc2UuICAqLwor CitzdGF0aWMgb3B0X3Jlc3VsdAordmVjdF9hbmFseXplX2Vhcmx5X2JyZWFrX2RlcGVuZGVuY2Vz IChsb29wX3ZlY19pbmZvIGxvb3BfdmluZm8pCit7CisgIERVTVBfVkVDVF9TQ09QRSAoInZlY3Rf YW5hbHl6ZV9lYXJseV9icmVha19kZXBlbmRlbmNlcyIpOworCisgIC8qIExpc3Qgb2YgYWxsIGxv YWQgZGF0YSByZWZlcmVuY2VzIGZvdW5kIGR1cmluZyB0cmF2ZXJzYWwuICAqLworICBhdXRvX3Zl YzxkYXRhX3JlZmVyZW5jZSAqPiBiYXNlczsKKyAgYmFzaWNfYmxvY2sgZGVzdF9iYiA9IE5VTEw7 CisKKyAgaGFzaF9zZXQgPGdpbXBsZSAqPiB2aXNpdGVkOworICBjbGFzcyBsb29wICpsb29wID0g TE9PUF9WSU5GT19MT09QIChsb29wX3ZpbmZvKTsKKyAgY2xhc3MgbG9vcCAqbG9vcF9uZXN0ID0g bG9vcF9vdXRlciAobG9vcCk7CisKKyAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorICAgIGR1bXBf cHJpbnRmX2xvYyAoTVNHX05PVEUsIHZlY3RfbG9jYXRpb24sCisJCSAgICAgImxvb3AgY29udGFp bnMgbXVsdGlwbGUgZXhpdHMsIGFuYWx5emluZyIKKwkJICAgICAiIHN0YXRlbWVudCBkZXBlbmRl bmNpZXMuXG4iKTsKKworICBmb3IgKGdpbXBsZSAqYyA6IExPT1BfVklORk9fTE9PUF9DT05EUyAo bG9vcF92aW5mbykpCisgICAgeworICAgICAgc3RtdF92ZWNfaW5mbyBsb29wX2NvbmRfaW5mbyA9 IGxvb3BfdmluZm8tPmxvb2t1cF9zdG10IChjKTsKKyAgICAgIGlmIChTVE1UX1ZJTkZPX1RZUEUg KGxvb3BfY29uZF9pbmZvKSAhPSBsb29wX2V4aXRfY3RybF92ZWNfaW5mb190eXBlKQorCWNvbnRp bnVlOworCisgICAgICBnaW1wbGVfc3RtdF9pdGVyYXRvciBnc2kgPSBnc2lfZm9yX3N0bXQgKGMp OworCisgICAgICAvKiBOb3cgYW5hbHl6ZSBhbGwgdGhlIHJlbWFpbmluZyBzdGF0ZW1lbnRzIGFu ZCB0cnkgdG8gZGV0ZXJtaW5lIHdoaWNoCisJIGluc3RydWN0aW9ucyBhcmUgYWxsb3dlZC9uZWVk ZWQgdG8gYmUgbW92ZWQuICAqLworICAgICAgd2hpbGUgKCFnc2lfZW5kX3AgKGdzaSkpCisJewor CSAgZ2ltcGxlICpzdG10ID0gZ3NpX3N0bXQgKGdzaSk7CisJICBnc2lfcHJldiAoJmdzaSk7CisJ ICBpZiAoIWdpbXBsZV9oYXNfb3BzIChzdG10KQorCSAgICAgIHx8IGlzX2dpbXBsZV9kZWJ1ZyAo c3RtdCkpCisJICAgIGNvbnRpbnVlOworCisJICBzdG10X3ZlY19pbmZvIHN0bXRfdmluZm8gPSBs b29wX3ZpbmZvLT5sb29rdXBfc3RtdCAoc3RtdCk7CisJICBhdXRvIGRyX3JlZiA9IFNUTVRfVklO Rk9fREFUQV9SRUYgKHN0bXRfdmluZm8pOworCSAgaWYgKCFkcl9yZWYpCisJICAgIGNvbnRpbnVl OworCisJICAvKiBXZSBjdXJyZW50bHkgb25seSBzdXBwb3J0IHN0YXRpY2FsbHkgYWxsb2NhdGVk IG9iamVjdHMgZHVlIHRvCisJICAgICBub3QgaGF2aW5nIGZpcnN0LWZhdWx0aW5nIGxvYWRzIHN1 cHBvcnQgb3IgcGVlbGluZyBmb3IKKwkgICAgIGFsaWdubWVudCBzdXBwb3J0LiAgQ29tcHV0ZSB0 aGUgc2l6ZSBvZiB0aGUgcmVmZXJlbmNlZCBvYmplY3QKKwkgICAgIChpdCBjb3VsZCBiZSBkeW5h bWljYWxseSBhbGxvY2F0ZWQpLiAgKi8KKwkgIHRyZWUgb2JqID0gRFJfQkFTRV9BRERSRVNTIChk cl9yZWYpOworCSAgaWYgKCFvYmogfHwgVFJFRV9DT0RFIChvYmopICE9IEFERFJfRVhQUikKKwkg ICAgeworCSAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkJZHVtcF9wcmludGZfbG9jIChN U0dfTUlTU0VEX09QVElNSVpBVElPTiwgdmVjdF9sb2NhdGlvbiwKKwkJCQkgImVhcmx5IGJyZWFr cyBvbmx5IHN1cHBvcnRlZCBvbiBzdGF0aWNhbGx5IgorCQkJCSAiIGFsbG9jYXRlZCBvYmplY3Rz LlxuIik7CisJICAgICAgcmV0dXJuIG9wdF9yZXN1bHQ6OmZhaWx1cmVfYXQgKGMsCisJCQkJICJj YW4ndCBzYWZlbHkgYXBwbHkgY29kZSBtb3Rpb24gdG8gIgorCQkJCSAiZGVwZW5kZW5jaWVzIG9m ICVHIHRvIHZlY3Rvcml6ZSAiCisJCQkJICJ0aGUgZWFybHkgZXhpdC5cbiIsIGMpOworCSAgICB9 CisKKwkgIHRyZWUgcmVmb3AgPSBUUkVFX09QRVJBTkQgKG9iaiwgMCk7CisJICB0cmVlIHJlZmJh c2UgPSBnZXRfYmFzZV9hZGRyZXNzIChyZWZvcCk7CisJICBpZiAoIXJlZmJhc2UgfHwgIURFQ0xf UCAocmVmYmFzZSkgfHwgIURFQ0xfU0laRSAocmVmYmFzZSkKKwkgICAgICB8fCBUUkVFX0NPREUg KERFQ0xfU0laRSAocmVmYmFzZSkpICE9IElOVEVHRVJfQ1NUKQorCSAgICB7CisJICAgICAgaWYg KGR1bXBfZW5hYmxlZF9wICgpKQorCQlkdW1wX3ByaW50Zl9sb2MgKE1TR19NSVNTRURfT1BUSU1J WkFUSU9OLCB2ZWN0X2xvY2F0aW9uLAorCQkJCSAiZWFybHkgYnJlYWtzIG9ubHkgc3VwcG9ydGVk IG9uIgorCQkJCSAiIHN0YXRpY2FsbHkgYWxsb2NhdGVkIG9iamVjdHMuXG4iKTsKKwkgICAgICBy ZXR1cm4gb3B0X3Jlc3VsdDo6ZmFpbHVyZV9hdCAoYywKKwkJCQkgImNhbid0IHNhZmVseSBhcHBs eSBjb2RlIG1vdGlvbiB0byAiCisJCQkJICJkZXBlbmRlbmNpZXMgb2YgJUcgdG8gdmVjdG9yaXpl ICIKKwkJCQkgInRoZSBlYXJseSBleGl0LlxuIiwgYyk7CisJICAgIH0KKworCSAgLyogQ2hlY2sg aWYgdmVjdG9yIGFjY2Vzc2VzIHRvIHRoZSBvYmplY3Qgd2lsbCBiZSB3aXRoaW4gYm91bmRzLgor CSAgICAgbXVzdCBiZSBhIGNvbnN0YW50IG9yIGFzc3VtZSBsb29wIHdpbGwgYmUgdmVyc2lvbmVk IG9yIG5pdGVycworCSAgICAgYm91bmRlZCBieSBWRiBzbyBhY2Nlc3NlcyBhcmUgd2l0aGluIHJh bmdlLiAgKi8KKwkgIGlmICghcmVmX3dpdGhpbl9hcnJheV9ib3VuZCAoc3RtdCwgRFJfUkVGIChk cl9yZWYpKSkKKwkgICAgeworCSAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkJZHVtcF9w cmludGZfbG9jIChNU0dfTUlTU0VEX09QVElNSVpBVElPTiwgdmVjdF9sb2NhdGlvbiwKKwkJCQkg ImVhcmx5IGJyZWFrcyBub3Qgc3VwcG9ydGVkOiB2ZWN0b3JpemF0aW9uICIKKwkJCQkgIndvdWxk ICVzIGJleW9uZCBzaXplIG9mIG9iai4iLAorCQkJCSBEUl9JU19SRUFEIChkcl9yZWYpID8gInJl YWQiIDogIndyaXRlIik7CisJICAgICAgcmV0dXJuIG9wdF9yZXN1bHQ6OmZhaWx1cmVfYXQgKGMs CisJCQkJICJjYW4ndCBzYWZlbHkgYXBwbHkgY29kZSBtb3Rpb24gdG8gIgorCQkJCSAiZGVwZW5k ZW5jaWVzIG9mICVHIHRvIHZlY3Rvcml6ZSAiCisJCQkJICJ0aGUgZWFybHkgZXhpdC5cbiIsIGMp OworCSAgICB9CisKKwkgIGlmIChEUl9JU19SRUFEIChkcl9yZWYpKQorCSAgICBiYXNlcy5zYWZl X3B1c2ggKGRyX3JlZik7CisJICBlbHNlIGlmIChEUl9JU19XUklURSAoZHJfcmVmKSkKKwkgICAg eworCSAgICAgIC8qIFdlIGFyZSBtb3Zpbmcgd3JpdGVzIGRvd24gaW4gdGhlIENGRy4gIFRvIGJl IHN1cmUgdGhhdCB0aGlzCisJCSBpcyB2YWxpZCBhZnRlciB2ZWN0b3JpemF0aW9uIHdlIGhhdmUg dG8gY2hlY2sgYWxsIHRoZSBsb2FkcworCQkgd2UgYXJlIHNpbmtpbmcgdGhlIHN0b3JlcyBwYXN0 IHRvIHNlZSBpZiBhbnkgb2YgdGhlbSBtYXkKKwkJIGFsaWFzIG9yIGFyZSB0aGUgc2FtZSBvYmpl Y3QuCisKKwkJIFNhbWUgb2JqZWN0cyB3aWxsIG5vdCBiZSBhbiBpc3N1ZSBiZWNhdXNlIHVubGVz cyB0aGUgc3RvcmUKKwkJIGlzIG1hcmtlZCB2b2xhdGlsZSB0aGUgdmFsdWUgY2FuIGJlIGZvcndh cmRlZC4gIElmIHRoZQorCQkgc3RvcmUgaXMgbWFya2VkIHZvbGF0aWxlIHdlIGRvbid0IHZlY3Rv cml6ZSB0aGUgbG9vcAorCQkgYW55d2F5LgorCisJCSBUaGF0IGxlYXZlcyB0aGUgY2hlY2sgZm9y IGFsaWFzaW5nLiAgV2UgZG9uJ3QgcmVhbGx5IG5lZWQKKwkJIHRvIGNhcmUgYWJvdXQgdGhlIHN0 b3JlcyBhbGlhc2luZyB3aXRoIGVhY2ggb3RoZXIgc2luY2UgdGhlCisJCSBzdG9yZXMgYXJlIG1v dmVkIGluIG9yZGVyIHNvIHRoZSBlZmZlY3RzIGFyZSBzdGlsbCBvYnNlcnZlZAorCQkgY29ycmVj dGx5LiAgVGhpcyBsZWF2ZXMgdGhlIGNoZWNrIGZvciBXQVIgZGVwZW5kZW5jaWVzCisJCSB3aGlj aCB3ZSB3b3VsZCBiZSBpbnRyb2R1Y2luZyBoZXJlIGlmIHRoZSBEUiBjYW4gYWxpYXMuCisJCSBU aGUgY2hlY2sgaXMgcXVhZHJhdGljIGluIGxvYWRzL3N0b3JlcyBidXQgSSBoYXZlIG5vdCBmb3Vu ZAorCQkgYSBiZXR0ZXIgQVBJIHRvIGRvIHRoaXMuICBJIGJlbGlldmUgYWxsIGxvYWRzIGFuZCBz dG9yZXMKKwkJIG11c3QgYmUgY2hlY2tlZC4gIFdlIGFsc28gbXVzdCBjaGVjayB0aGVtIHdoZW4g d2UKKwkJIGVuY291bnRlcmVkIHRoZSBzdG9yZSwgc2luY2Ugd2UgZG9uJ3QgY2FyZSBhYm91dCBs b2FkcyBwYXN0CisJCSB0aGUgc3RvcmUuICAqLworCisJICAgICAgZm9yIChhdXRvIGRyX3JlYWQg OiBiYXNlcykKKwkJaWYgKGRyX21heV9hbGlhc19wIChkcl9yZWYsIGRyX3JlYWQsIGxvb3BfbmVz dCkpCisJCSAgeworCQkgICAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorCQkgICAgICBkdW1wX3By aW50Zl9sb2MgKE1TR19NSVNTRURfT1BUSU1JWkFUSU9OLAorCQkJCSAgICAgICB2ZWN0X2xvY2F0 aW9uLAorCQkJCSAgICAgICAiZWFybHkgYnJlYWtzIG5vdCBzdXBwb3J0ZWQ6ICIKKwkJCQkgICAg ICAgIm92ZXJsYXBwaW5nIGxvYWRzIGFuZCBzdG9yZXMgIgorCQkJCSAgICAgICAiZm91bmQgYmVm b3JlIHRoZSBicmVhayAiCisJCQkJICAgICAgICJzdGF0ZW1lbnQuXG4iKTsKKworCQkgICAgcmV0 dXJuIG9wdF9yZXN1bHQ6OmZhaWx1cmVfYXQgKHN0bXQsCisJCQkgICAgICJjYW4ndCBzYWZlbHkg YXBwbHkgY29kZSBtb3Rpb24gdG8gZGVwZW5kZW5jaWVzIgorCQkJICAgICAiIHRvIHZlY3Rvcml6 ZSB0aGUgZWFybHkgZXhpdC4gJUcgbWF5IGFsaWFzIHdpdGgiCisJCQkgICAgICIgJUdcbiIsIHN0 bXQsIGRyX3JlYWQtPnN0bXQpOworCQkgIH0KKwkgICAgfQorCisJICBpZiAoZ2ltcGxlX3ZkZWYg KHN0bXQpKQorCSAgICB7CisJICAgICAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorCQlkdW1wX3By aW50Zl9sb2MgKE1TR19OT1RFLCB2ZWN0X2xvY2F0aW9uLAorCQkJCSAiPT0+IHJlY29yZGluZyBz dG10ICVHIiwgc3RtdCk7CisKKwkgICAgICBMT09QX1ZJTkZPX0VBUkxZX0JSS19TVE9SRVMgKGxv b3BfdmluZm8pLnNhZmVfcHVzaCAoc3RtdCk7CisJICAgIH0KKwkgIGVsc2UgaWYgKGdpbXBsZV92 dXNlIChzdG10KSkKKwkgICAgeworCSAgICAgIExPT1BfVklORk9fRUFSTFlfQlJLX1ZVU0VTIChs b29wX3ZpbmZvKS5zYWZlX2luc2VydCAoMCwgc3RtdCk7CisJICAgICAgaWYgKGR1bXBfZW5hYmxl ZF9wICgpKQorCQlkdW1wX3ByaW50Zl9sb2MgKE1TR19OT1RFLCB2ZWN0X2xvY2F0aW9uLAorCQkJ CSAibWFya2VkIHN0YXRlbWVudCBmb3IgdlVTRSB1cGRhdGU6ICVHIiwgc3RtdCk7CisJICAgIH0K Kwl9CisKKyAgICAgIC8qIFNhdmUgZGVzdGluYXRpb24gYXMgd2UgZ28sIEJCIGFyZSB2aXNpdGVk IGluIG9yZGVyIGFuZCB0aGUgbGFzdCBvbmUKKwlpcyB3aGVyZSBzdGF0ZW1lbnRzIHNob3VsZCBi ZSBtb3ZlZCB0by4gICovCisgICAgICBpZiAoIWRlc3RfYmIpCisJZGVzdF9iYiA9IGdpbXBsZV9i YiAoYyk7CisgICAgICBlbHNlCisJeworCSAgYmFzaWNfYmxvY2sgY3Vycl9iYiA9IGdpbXBsZV9i YiAoYyk7CisJICBpZiAoZG9taW5hdGVkX2J5X3AgKENESV9ET01JTkFUT1JTLCBjdXJyX2JiLCBk ZXN0X2JiKSkKKwkgICAgZGVzdF9iYiA9IGN1cnJfYmI7CisJfQorCisgICAgICAvKiBNYXJrIHRo ZSBzdGF0ZW1lbnQgYXMgYSBjb25kaXRpb24uICAqLworICAgICAgU1RNVF9WSU5GT19ERUZfVFlQ RSAobG9vcF9jb25kX2luZm8pID0gdmVjdF9jb25kaXRpb25fZGVmOworICAgIH0KKworICBiYXNp Y19ibG9jayBkZXN0X2JiMCA9IEVER0VfU1VDQyAoZGVzdF9iYiwgMCktPmRlc3Q7CisgIGJhc2lj X2Jsb2NrIGRlc3RfYmIxID0gRURHRV9TVUNDIChkZXN0X2JiLCAxKS0+ZGVzdDsKKyAgZGVzdF9i YiA9IGZsb3dfYmJfaW5zaWRlX2xvb3BfcCAobG9vcCwgZGVzdF9iYjApID8gZGVzdF9iYjAgOiBk ZXN0X2JiMTsKKyAgLyogV2UgZG9uJ3QgYWxsb3cgb3V0ZXIgLT4gaW5uZXIgbG9vcCB0cmFuc2l0 aW9ucyB3aGljaCBzaG91bGQgaGF2ZSBiZWVuCisgICAgIHRyYXBwZWQgYWxyZWFkeSBkdXJpbmcg bG9vcCBmb3JtIGFuYWx5c2lzLiAgKi8KKyAgZ2NjX2Fzc2VydCAoZGVzdF9iYi0+bG9vcF9mYXRo ZXIgPT0gbG9vcCk7CisKKyAgZ2NjX2Fzc2VydCAoZGVzdF9iYik7CisgIExPT1BfVklORk9fRUFS TFlfQlJLX0RFU1RfQkIgKGxvb3BfdmluZm8pID0gZGVzdF9iYjsKKworICBpZiAoIUxPT1BfVklO Rk9fRUFSTFlfQlJLX1ZVU0VTIChsb29wX3ZpbmZvKS5pc19lbXB0eSAoKSkKKyAgICB7CisgICAg ICAvKiBBbGwgdXNlcyBzaGFsbCBiZSB1cGRhdGVkIHRvIHRoYXQgb2YgdGhlIGZpcnN0IGxvYWQu ICBFbnRyaWVzIGFyZQorCSBzdG9yZWQgaW4gcmV2ZXJzZSBvcmRlci4gICovCisgICAgICB0cmVl IHZ1c2UgPSBnaW1wbGVfdnVzZSAoTE9PUF9WSU5GT19FQVJMWV9CUktfVlVTRVMgKGxvb3Bfdmlu Zm8pLmxhc3QgKCkpOworICAgICAgZm9yIChhdXRvIGcgOiBMT09QX1ZJTkZPX0VBUkxZX0JSS19W VVNFUyAobG9vcF92aW5mbykpCisJeworCSAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorCSAgZHVt cF9wcmludGZfbG9jIChNU0dfTk9URSwgdmVjdF9sb2NhdGlvbiwKKwkJCSAgICJ3aWxsIHVwZGF0 ZSB1c2U6ICVULCBtZW1fcmVmOiAlRyIsIHZ1c2UsIGcpOworCX0KKyAgICB9CisKKyAgaWYgKGR1 bXBfZW5hYmxlZF9wICgpKQorICAgIGR1bXBfcHJpbnRmX2xvYyAoTVNHX05PVEUsIHZlY3RfbG9j YXRpb24sCisJCSAgICAgInJlY29yZGVkIHN0YXRlbWVudHMgdG8gYmUgbW92ZWQgdG8gQkIgJWRc biIsCisJCSAgICAgTE9PUF9WSU5GT19FQVJMWV9CUktfREVTVF9CQiAobG9vcF92aW5mbyktPmlu ZGV4KTsKKworICByZXR1cm4gb3B0X3Jlc3VsdDo6c3VjY2VzcyAoKTsKK30KKwogLyogRnVuY3Rp b24gdmVjdF9hbmFseXplX2RhdGFfcmVmX2RlcGVuZGVuY2VzLgogCiAgICBFeGFtaW5lIGFsbCB0 aGUgZGF0YSByZWZlcmVuY2VzIGluIHRoZSBsb29wLCBhbmQgbWFrZSBzdXJlIHRoZXJlIGRvIG5v dApAQCAtNjU3LDYgKzg5MiwxMSBAQCB2ZWN0X2FuYWx5emVfZGF0YV9yZWZfZGVwZW5kZW5jZXMg KGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywKIAkgIHJldHVybiByZXM7CiAgICAgICB9CiAKKyAg LyogSWYgd2UgaGF2ZSBlYXJseSBicmVhayBzdGF0ZW1lbnRzIGluIHRoZSBsb29wLCBjaGVjayB0 byBzZWUgaWYgdGhleQorICAgICBhcmUgb2YgYSBmb3JtIHdlIGNhbiB2ZWN0b3JpemVyLiAgKi8K KyAgaWYgKExPT1BfVklORk9fRUFSTFlfQlJFQUtTIChsb29wX3ZpbmZvKSkKKyAgICByZXR1cm4g dmVjdF9hbmFseXplX2Vhcmx5X2JyZWFrX2RlcGVuZGVuY2VzIChsb29wX3ZpbmZvKTsKKwogICBy ZXR1cm4gb3B0X3Jlc3VsdDo6c3VjY2VzcyAoKTsKIH0KIApkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUt dmVjdC1sb29wLmNjIGIvZ2NjL3RyZWUtdmVjdC1sb29wLmNjCmluZGV4IGZiOGQ5OTllZTZiZmFm ZjU1MWFjMDZhYzJmM2FlYTUzNTQ5MTQ2NTkuLjkwMDgyNjU2N2ZlZTM2MjA2YzA3MTFlYTUxNDk1 NjAyYTdhMDMxYTEgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXZlY3QtbG9vcC5jYworKysgYi9nY2Mv dHJlZS12ZWN0LWxvb3AuY2MKQEAgLTEwNDAsNiArMTA0MCw3IEBAIF9sb29wX3ZlY19pbmZvOjpf bG9vcF92ZWNfaW5mbyAoY2xhc3MgbG9vcCAqbG9vcF9pbiwgdmVjX2luZm9fc2hhcmVkICpzaGFy ZWQpCiAgICAgcGFydGlhbF9sb2FkX3N0b3JlX2JpYXMgKDApLAogICAgIHBlZWxpbmdfZm9yX2dh cHMgKGZhbHNlKSwKICAgICBwZWVsaW5nX2Zvcl9uaXRlciAoZmFsc2UpLAorICAgIGVhcmx5X2Jy ZWFrcyAoZmFsc2UpLAogICAgIG5vX2RhdGFfZGVwZW5kZW5jaWVzIChmYWxzZSksCiAgICAgaGFz X21hc2tfc3RvcmUgKGZhbHNlKSwKICAgICBzY2FsYXJfbG9vcF9zY2FsaW5nIChwcm9maWxlX3By b2JhYmlsaXR5Ojp1bmluaXRpYWxpemVkICgpKSwKQEAgLTExNTQ4LDYgKzExNTQ5LDU2IEBAIHVw ZGF0ZV9lcGlsb2d1ZV9sb29wX3ZpbmZvIChjbGFzcyBsb29wICplcGlsb2d1ZSwgdHJlZSBhZHZh bmNlKQogICBlcGlsb2d1ZV92aW5mby0+c2hhcmVkLT5zYXZlX2RhdGFyZWZzICgpOwogfQogCisv KiAgV2hlbiB2ZWN0b3JpemluZyBlYXJseSBicmVhayBzdGF0ZW1lbnRzIGluc3RydWN0aW9ucyB0 aGF0IGhhcHBlbiBiZWZvcmUKKyAgICB0aGUgZWFybHkgYnJlYWsgaW4gdGhlIGN1cnJlbnQgQkIg bmVlZCB0byBiZSBtb3ZlZCB0byBhZnRlciB0aGUgZWFybHkKKyAgICBicmVhay4gIFRoaXMgZnVu Y3Rpb24gZGVhbHMgd2l0aCB0aGF0IGFuZCBhc3N1bWVzIHRoYXQgYW55IHZhbGlkaXR5CisgICAg Y2hlY2tzIGhhcyBhbHJlYWR5IGJlZW4gcGVyZm9ybWVkLgorCisgICAgV2hpbGUgbW92aW5nIHRo ZSBpbnN0cnVjdGlvbnMgaWYgaXQgZW5jb3VudGVycyBhIFZVU0Ugb3IgVkRFRiBpdCB0aGVuCisg ICAgY29ycmVjdHMgdGhlIFZVU0VTIGFzIGl0IG1vdmVzIHRoZSBzdGF0ZW1lbnRzIGFsb25nLiAg R0RFU1QgaXMgdGhlIGxvY2F0aW9uCisgICAgaW4gd2hpY2ggdG8gaW5zZXJ0IHRoZSBuZXcgc3Rh dGVtZW50cy4gICovCisKK3N0YXRpYyB2b2lkCittb3ZlX2Vhcmx5X2V4aXRfc3RtdHMgKGxvb3Bf dmVjX2luZm8gbG9vcF92aW5mbykKK3sKKyAgRFVNUF9WRUNUX1NDT1BFICgibW92ZV9lYXJseV9l eGl0X3N0bXRzIik7CisKKyAgaWYgKExPT1BfVklORk9fRUFSTFlfQlJLX1NUT1JFUyAobG9vcF92 aW5mbykuaXNfZW1wdHkgKCkpCisgICAgcmV0dXJuOworCisgIC8qIE1vdmUgYWxsIHN0bXRzIHRo YXQgbmVlZCBtb3ZpbmcuICAqLworICBiYXNpY19ibG9jayBkZXN0X2JiID0gTE9PUF9WSU5GT19F QVJMWV9CUktfREVTVF9CQiAobG9vcF92aW5mbyk7CisgIGdpbXBsZV9zdG10X2l0ZXJhdG9yIGRl c3RfZ3NpID0gZ3NpX3N0YXJ0X2JiIChkZXN0X2JiKTsKKworICBmb3IgKGdpbXBsZSAqc3RtdCA6 IExPT1BfVklORk9fRUFSTFlfQlJLX1NUT1JFUyAobG9vcF92aW5mbykpCisgICAgeworICAgICAg LyogQ2hlY2sgdG8gc2VlIGlmIHN0YXRlbWVudCBpcyBzdGlsbCByZXF1aXJlZCBmb3IgdmVjdCBv ciBoYXMgYmVlbgorCSBlbGlkZWQuICAqLworICAgICAgYXV0byBzdG10X2luZm8gPSBsb29wX3Zp bmZvLT5sb29rdXBfc3RtdCAoc3RtdCk7CisgICAgICBpZiAoIXN0bXRfaW5mbykKKwljb250aW51 ZTsKKworICAgICAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorCWR1bXBfcHJpbnRmX2xvYyAoTVNH X05PVEUsIHZlY3RfbG9jYXRpb24sICJtb3Zpbmcgc3RtdCAlRyIsIHN0bXQpOworCisgICAgICBn aW1wbGVfc3RtdF9pdGVyYXRvciBzdG10X2dzaSA9IGdzaV9mb3Jfc3RtdCAoc3RtdCk7CisgICAg ICBnc2lfbW92ZV9iZWZvcmUgKCZzdG10X2dzaSwgJmRlc3RfZ3NpKTsKKyAgICAgIGdzaV9wcmV2 ICgmZGVzdF9nc2kpOworICAgIH0KKworICAvKiBVcGRhdGUgYWxsIHRoZSBzdG10cyB3aXRoIHRo ZWlyIG5ldyByZWFjaGluZyBWVVNFUy4gICovCisgIHRyZWUgdnVzZQorICAgID0gZ2ltcGxlX3Z1 c2UgKExPT1BfVklORk9fRUFSTFlfQlJLX1NUT1JFUyAobG9vcF92aW5mbykubGFzdCAoKSk7Cisg IGZvciAoYXV0byBwIDogTE9PUF9WSU5GT19FQVJMWV9CUktfVlVTRVMgKGxvb3BfdmluZm8pKQor ICAgIHsKKyAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkgIGR1bXBfcHJpbnRmX2xvYyAo TVNHX05PVEUsIHZlY3RfbG9jYXRpb24sCisJCQkgICAidXBkYXRpbmcgdnVzZSB0byAlVCBmb3Ig bG9hZCAlRyIsIHZ1c2UsIHApOworICAgICAgZ2ltcGxlX3NldF92dXNlIChwLCB2dXNlKTsKKyAg ICAgIHVwZGF0ZV9zdG10IChwKTsKKyAgICB9Cit9CisKIC8qIEZ1bmN0aW9uIHZlY3RfdHJhbnNm b3JtX2xvb3AuCiAKICAgIFRoZSBhbmFseXNpcyBwaGFzZSBoYXMgZGV0ZXJtaW5lZCB0aGF0IHRo ZSBsb29wIGlzIHZlY3Rvcml6YWJsZS4KQEAgLTExNjk3LDYgKzExNzQ4LDExIEBAIHZlY3RfdHJh bnNmb3JtX2xvb3AgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywgZ2ltcGxlICpsb29wX3ZlY3Rv cml6ZWRfY2FsbCkKICAgICAgIHZlY3Rfc2NoZWR1bGVfc2xwIChsb29wX3ZpbmZvLCBMT09QX1ZJ TkZPX1NMUF9JTlNUQU5DRVMgKGxvb3BfdmluZm8pKTsKICAgICB9CiAKKyAgLyogSGFuZGxlIGFu eSBjb2RlIG1vdGlvbiB0aGF0IHdlIG5lZWQgdG8gZm9yIGVhcmx5LWJyZWFrIHZlY3Rvcml6YXRp b24gYWZ0ZXIKKyAgICAgd2UndmUgZG9uZSBwZWVsaW5nIGJ1dCBqdXN0IGJlZm9yZSB3ZSBzdGFy dCB2ZWN0b3JpemluZy4gICovCisgIGlmIChMT09QX1ZJTkZPX0VBUkxZX0JSRUFLUyAobG9vcF92 aW5mbykpCisgICAgbW92ZV9lYXJseV9leGl0X3N0bXRzIChsb29wX3ZpbmZvKTsKKwogICAvKiBG T1JOT1c6IHRoZSB2ZWN0b3JpemVyIHN1cHBvcnRzIG9ubHkgbG9vcHMgd2hpY2ggYm9keSBjb25z aXN0CiAgICAgIG9mIG9uZSBiYXNpYyBibG9jayAoaGVhZGVyICsgZW1wdHkgbGF0Y2gpLiBXaGVu IHRoZSB2ZWN0b3JpemVyIHdpbGwKICAgICAgc3VwcG9ydCBtb3JlIGludm9sdmVkIGxvb3AgZm9y bXMsIHRoZSBvcmRlciBieSB3aGljaCB0aGUgQkJzIGFyZQpkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUt dmVjdC1zdG10cy5jYyBiL2djYy90cmVlLXZlY3Qtc3RtdHMuY2MKaW5kZXggOTZlNGE2Y2ZmYWRl YmI0Mzk0NmM1Y2I3ZTk4NDljOTE1ZGE1ODliYy4uYjNhMDljMGE4MDRhMzhlMTdlZjMyYjZjZTEz Yjk4YjA3NzQ1OWZjNyAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtdmVjdC1zdG10cy5jYworKysgYi9n Y2MvdHJlZS12ZWN0LXN0bXRzLmNjCkBAIC0zNTksOCArMzU5LDggQEAgdmVjdF9zdG10X3JlbGV2 YW50X3AgKHN0bXRfdmVjX2luZm8gc3RtdF9pbmZvLCBsb29wX3ZlY19pbmZvIGxvb3BfdmluZm8s CiAgICpsaXZlX3AgPSBmYWxzZTsKIAogICAvKiBjb25kIHN0bXQgb3RoZXIgdGhhbiBsb29wIGV4 aXQgY29uZC4gICovCi0gIGlmIChpc19jdHJsX3N0bXQgKHN0bXRfaW5mby0+c3RtdCkKLSAgICAg ICYmIFNUTVRfVklORk9fVFlQRSAoc3RtdF9pbmZvKSAhPSBsb29wX2V4aXRfY3RybF92ZWNfaW5m b190eXBlKQorICBnaW1wbGUgKnN0bXQgPSBTVE1UX1ZJTkZPX1NUTVQgKHN0bXRfaW5mbyk7Cisg IGlmIChkeW5fY2FzdCA8Z2NvbmQgKj4gKHN0bXQpKQogICAgICpyZWxldmFudCA9IHZlY3RfdXNl ZF9pbl9zY29wZTsKIAogICAvKiBjaGFuZ2luZyBtZW1vcnkuICAqLwpAQCAtMTM1MzAsNiArMTM1 MzAsOSBAQCB2ZWN0X2lzX3NpbXBsZV91c2UgKHRyZWUgb3BlcmFuZCwgdmVjX2luZm8gKnZpbmZv LCBlbnVtIHZlY3RfZGVmX3R5cGUgKmR0LAogCWNhc2UgdmVjdF9maXJzdF9vcmRlcl9yZWN1cnJl bmNlOgogCSAgZHVtcF9wcmludGYgKE1TR19OT1RFLCAiZmlyc3Qgb3JkZXIgcmVjdXJyZW5jZVxu Iik7CiAJICBicmVhazsKKwljYXNlIHZlY3RfY29uZGl0aW9uX2RlZjoKKwkgIGR1bXBfcHJpbnRm IChNU0dfTk9URSwgImNvbnRyb2wgZmxvd1xuIik7CisJICBicmVhazsKIAljYXNlIHZlY3RfdW5r bm93bl9kZWZfdHlwZToKIAkgIGR1bXBfcHJpbnRmIChNU0dfTk9URSwgInVua25vd25cbiIpOwog CSAgYnJlYWs7CmRpZmYgLS1naXQgYS9nY2MvdHJlZS12ZWN0b3JpemVyLmggYi9nY2MvdHJlZS12 ZWN0b3JpemVyLmgKaW5kZXggZTRkN2FiNDU2N2NlZjNjMDE4Yjk1OGY5OGVlZmYwNDVkMzQ3Nzcy NS4uNzQ0Y2RjODZjOTY5YTYyNTc0YmU0ODhkZjRmOWMyMjJiNjhmNzk5NCAxMDA2NDQKLS0tIGEv Z2NjL3RyZWUtdmVjdG9yaXplci5oCisrKyBiL2djYy90cmVlLXZlY3Rvcml6ZXIuaApAQCAtNjYs NiArNjYsNyBAQCBlbnVtIHZlY3RfZGVmX3R5cGUgewogICB2ZWN0X2RvdWJsZV9yZWR1Y3Rpb25f ZGVmLAogICB2ZWN0X25lc3RlZF9jeWNsZSwKICAgdmVjdF9maXJzdF9vcmRlcl9yZWN1cnJlbmNl LAorICB2ZWN0X2NvbmRpdGlvbl9kZWYsCiAgIHZlY3RfdW5rbm93bl9kZWZfdHlwZQogfTsKIApA QCAtODg4LDYgKzg4OSwxMCBAQCBwdWJsaWM6CiAgICAgIHdlIG5lZWQgdG8gcGVlbCBvZmYgaXRl cmF0aW9ucyBhdCB0aGUgZW5kIHRvIGZvcm0gYW4gZXBpbG9ndWUgbG9vcC4gICovCiAgIGJvb2wg cGVlbGluZ19mb3Jfbml0ZXI7CiAKKyAgLyogV2hlbiB0aGUgbG9vcCBoYXMgZWFybHkgYnJlYWtz IHRoYXQgd2UgY2FuIHZlY3Rvcml6ZSB3ZSBuZWVkIHRvIHBlZWwKKyAgICAgdGhlIGxvb3AgZm9y IHRoZSBicmVhayBmaW5kaW5nIGxvb3AuICAqLworICBib29sIGVhcmx5X2JyZWFrczsKKwogICAv KiBMaXN0IG9mIGxvb3AgYWRkaXRpb25hbCBJViBjb25kaXRpb25hbHMgZm91bmQgaW4gdGhlIGxv b3AuICAqLwogICBhdXRvX3ZlYzxnY29uZCAqPiBjb25kczsKIApAQCAtOTQyLDYgKzk0NywyMCBA QCBwdWJsaWM6CiAgIC8qIFRoZSBjb250cm9sbGluZyBsb29wIElWIGZvciB0aGUgc2NhbGFyIGxv b3AgYmVpbmcgdmVjdG9yaXplZC4gIFRoaXMgSVYKICAgICAgY29udHJvbHMgdGhlIG5hdHVyYWwg ZXhpdHMgb2YgdGhlIGxvb3AuICAqLwogICBlZGdlIHNjYWxhcl9sb29wX2l2X2V4aXQ7CisKKyAg LyogVXNlZCB0byBzdG9yZSB0aGUgbGlzdCBvZiBzdG9yZXMgbmVlZGluZyB0byBiZSBtb3ZlZCBp ZiBkb2luZyBlYXJseQorICAgICBicmVhayB2ZWN0b3JpemF0aW9uIGFzIHRoZXkgd291bGQgdmlv bGF0ZSB0aGUgc2NhbGFyIGxvb3Agc2VtYW50aWNzIGlmCisgICAgIHZlY3Rvcml6ZWQgaW4gdGhl aXIgY3VycmVudCBsb2NhdGlvbi4gIFRoZXNlIGFyZSBzdG9yZWQgaW4gb3JkZXIgdGhhdCB0aGV5 CisgICAgIG5lZWQgdG8gYmUgbW92ZWQuICAqLworICBhdXRvX3ZlYzxnaW1wbGUgKj4gZWFybHlf YnJlYWtfc3RvcmVzOworCisgIC8qIFRoZSBmaW5hbCBiYXNpYyBibG9jayB3aGVyZSB0byBtb3Zl IHN0YXRlbWVudHMgdG8uICBJbiB0aGUgY2FzZSBvZgorICAgICBtdWx0aXBsZSBleGl0cyB0aGlz IGNvdWxkIGJlIHByZXR0eSBmYXIgYXdheS4gICovCisgIGJhc2ljX2Jsb2NrIGVhcmx5X2JyZWFr X2Rlc3RfYmI7CisKKyAgLyogU3RhdGVtZW50cyB3aG9zZSBWVVNFUyBuZWVkIHVwZGF0aW5nIGlm IGVhcmx5IGJyZWFrIHZlY3Rvcml6YXRpb24gaXMgdG8KKyAgICAgaGFwcGVuLiAgKi8KKyAgYXV0 b192ZWM8Z2ltcGxlKj4gZWFybHlfYnJlYWtfdnVzZXM7CiB9ICpsb29wX3ZlY19pbmZvOwogCiAv KiBBY2Nlc3MgRnVuY3Rpb25zLiAgKi8KQEAgLTk5Niw2ICsxMDE1LDEwIEBAIHB1YmxpYzoKICNk ZWZpbmUgTE9PUF9WSU5GT19SRURVQ1RJT05fQ0hBSU5TKEwpICAgICAoTCktPnJlZHVjdGlvbl9j aGFpbnMKICNkZWZpbmUgTE9PUF9WSU5GT19QRUVMSU5HX0ZPUl9HQVBTKEwpICAgICAoTCktPnBl ZWxpbmdfZm9yX2dhcHMKICNkZWZpbmUgTE9PUF9WSU5GT19QRUVMSU5HX0ZPUl9OSVRFUihMKSAg ICAoTCktPnBlZWxpbmdfZm9yX25pdGVyCisjZGVmaW5lIExPT1BfVklORk9fRUFSTFlfQlJFQUtT KEwpICAgICAgICAgKEwpLT5lYXJseV9icmVha3MKKyNkZWZpbmUgTE9PUF9WSU5GT19FQVJMWV9C UktfU1RPUkVTKEwpICAgICAoTCktPmVhcmx5X2JyZWFrX3N0b3JlcworI2RlZmluZSBMT09QX1ZJ TkZPX0VBUkxZX0JSS19ERVNUX0JCKEwpICAgIChMKS0+ZWFybHlfYnJlYWtfZGVzdF9iYgorI2Rl ZmluZSBMT09QX1ZJTkZPX0VBUkxZX0JSS19WVVNFUyhMKSAgICAgIChMKS0+ZWFybHlfYnJlYWtf dnVzZXMKICNkZWZpbmUgTE9PUF9WSU5GT19MT09QX0NPTkRTKEwpICAgICAgICAgICAoTCktPmNv bmRzCiAjZGVmaW5lIExPT1BfVklORk9fTE9PUF9JVl9DT05EKEwpICAgICAgICAgKEwpLT5sb29w X2l2X2NvbmQKICNkZWZpbmUgTE9PUF9WSU5GT19OT19EQVRBX0RFUEVOREVOQ0lFUyhMKSAoTCkt Pm5vX2RhdGFfZGVwZW5kZW5jaWVzCkBAIC0yMjk4LDYgKzIzMjEsOSBAQCBleHRlcm4gb3B0X3Jl c3VsdCB2ZWN0X2dldF92ZWN0b3JfdHlwZXNfZm9yX3N0bXQgKHZlY19pbmZvICosCiAJCQkJCQkg IHRyZWUgKiwgdW5zaWduZWQgaW50ID0gMCk7CiBleHRlcm4gb3B0X3RyZWUgdmVjdF9nZXRfbWFz a190eXBlX2Zvcl9zdG10IChzdG10X3ZlY19pbmZvLCB1bnNpZ25lZCBpbnQgPSAwKTsKIAorLyog SW4gdHJlZS1pZi1jb252LmNjLiAgKi8KK2V4dGVybiBib29sIHJlZl93aXRoaW5fYXJyYXlfYm91 bmQgKGdpbXBsZSAqLCB0cmVlKTsKKwogLyogSW4gdHJlZS12ZWN0LWRhdGEtcmVmcy5jYy4gICov CiBleHRlcm4gYm9vbCB2ZWN0X2Nhbl9mb3JjZV9kcl9hbGlnbm1lbnRfcCAoY29uc3RfdHJlZSwg cG9seV91aW50NjQpOwogZXh0ZXJuIGVudW0gZHJfYWxpZ25tZW50X3N1cHBvcnQgdmVjdF9zdXBw b3J0YWJsZV9kcl9hbGlnbm1lbnQK --_002_VI1PR08MB5325C3CEBA05F52781C818BFFF96AVI1PR08MB5325eurp_--