From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR05-AM6-obe.outbound.protection.outlook.com (mail-am6eur05on2070.outbound.protection.outlook.com [40.107.22.70]) by sourceware.org (Postfix) with ESMTPS id D62F23858417 for ; Tue, 19 Dec 2023 10:12:01 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org D62F23858417 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 D62F23858417 Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=40.107.22.70 ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1702980725; cv=pass; b=pA9dg53H9MGytKbdC4Gs3NZ9R7kHzWRFGRiqoIU7N2QWXoiJOLQ72oUyLb8UWjKMhN62ZEiohfD9J/a5yu7wnYiYg4yHwiIfrI+dDKEFKOYgmDB11LJ2I6pHiYrdbjexXoIR5i+7XsEkmDMwK2/OtXIhQV+M8UL2v7FfbQkCMtM= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1702980725; c=relaxed/simple; bh=33pdU3iszizpd94AcURRbpqL/ADiURpkdqTI67aTQnQ=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=GXMQhaVqbQgcILgPXev1P5gqk3xAj7nTPAwL5Rh4PDCpmNWPLuJqZZgycpwnfbGaw53reohY/c7IcbQpqcqcj0Np3yO5lPQfKbwzr8ODezR4i6zmAvBbGYlwkQ17F8XXsjjxN5POsUHWt3UL57Asx+odVa3kQYzcAsJ2EAKIdRo= ARC-Authentication-Results: i=3; server2.sourceware.org ARC-Seal: i=2; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=pass; b=J9GTZmQND6XWV78uol0vli6Ih4HtTYxsvFzZLo+GxDf05D8V1XZey/6rBs07LJVph0SiuTfwzAN+IHhMvW6ZFSGNVI8dQfggCxcM89uuj3FZHilF0Sxivlvd5/ZcyXaPkObe7QlwHti/uwgR32T0uunjmM3Yp+hFqKi7soG03M5rNGTa9KwUpLe1V3UL0E4Wqj4s0zoSSoqCYdVhBrpkCE0hpr7JrWM7cu6UrcT1v20ZMxrZLQcRgG/gLygLqlMLNDkL5fUaEb7XnkaNVwayOsKm3oev+JHn3BaBYXBC63B2XAKuRvphNIRFsKhtbs8asboj4Fqpgb8cHmoealgMPw== 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=t3pHLXGgeEGrrh+mVtFGT3Eps8Wf7vuPJnmoFsywf7s=; b=a+EQWzbtSAvmWgM4QHY/MVMeQaCRHHGgt0K5Qrj3R2FJAF0CK24WfVzVwEhlKKBnW3Y3wQp5TOoDfcnfeN0F40+hcWrdS+lwtDXUlXTZgRC4YcEuCYpMg+WlQCG/GNfyC+kRNsQM1UXCxGe0bJQRfkNCfdXzUxhhWAIWlMdEwvVqtSreuOkuOCAl92oLfhmg317W0vI8AIKT/4DUbIxB155URPzLb30sw7ix/2n4EQC/ySR1p4wIJObVErfbTGz1uqEEXOVY8KU6iTnubst2RnvNWqAvgkSNGfGX7H+KjEc/kAjpivYgPgRMaUns3OAV5WUUBgKUJzrX4sBdWpXTuQ== 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=t3pHLXGgeEGrrh+mVtFGT3Eps8Wf7vuPJnmoFsywf7s=; b=ynW94f6grfqGoWoQvLxk0dXvouqdaGLMNawJ5pmmH5vA8frsQ+CGMU1QyNRZVqwpeh1pfkt9eT+ytGt6UTj/Hjh2P7Igu95HpZO0eOr2esKUUmpZOVEnObjf9RZDop54ucqzIvSv4jbKBMtk2W97jJ4cIbHGlWrmiskr6hXyOB0= Received: from AM6PR08CA0013.eurprd08.prod.outlook.com (2603:10a6:20b:b2::25) by PAXPR08MB6367.eurprd08.prod.outlook.com (2603:10a6:102:15b::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7091.38; Tue, 19 Dec 2023 10:11:56 +0000 Received: from AM3PEPF00009B9B.eurprd04.prod.outlook.com (2603:10a6:20b:b2:cafe::90) by AM6PR08CA0013.outlook.office365.com (2603:10a6:20b:b2::25) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7091.38 via Frontend Transport; Tue, 19 Dec 2023 10:11:56 +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 AM3PEPF00009B9B.mail.protection.outlook.com (10.167.16.20) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7113.14 via Frontend Transport; Tue, 19 Dec 2023 10:11:56 +0000 Received: ("Tessian outbound 7671e7ddc218:v228"); Tue, 19 Dec 2023 10:11:56 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: 961b20e54a0d7b48 X-CR-MTA-TID: 64aa7808 Received: from f465829b2ad3.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id 60C14A41-A39C-41B6-8BF9-B2AA8C9DDD10.1; Tue, 19 Dec 2023 10:11:48 +0000 Received: from EUR05-VI1-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id f465829b2ad3.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Tue, 19 Dec 2023 10:11:48 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=JN0mz78HgYXWgQr2wLSL3jQKSc6JGx7854mXaPuTEFWZzWmtuZXP0Vj3N6TPIC2dFG37CX8FV07A7COWyOj9wVqed6+2AzAsyHVN9I+yVSh9zt+jzpQ7hCtBrrMPB5GhLMYkuYaJ0FjYaJglH9rYd0/yWQrpjHOPmewipjudVeX9VTgsG/u27UQCE2ANM4yBqve+s1OtUUvpLe2zPqB88FIt/xer1jzZB5CW0KE4+v3HUmdWnZXpGtOPf/vavP3xptHm4CDObhkhXxodDhthYXoPbWupD03ofFzHXdK6oEimWy0Wj1lRYj4PqV4vfLUNu9dbGT9KI23BGOpnl/5Uxw== 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=t3pHLXGgeEGrrh+mVtFGT3Eps8Wf7vuPJnmoFsywf7s=; b=aUHwCak0JbW8ICpmMr5P3Tof+9o4a44nnulv3SJiI5tzAq1cBcPwKg/lZM1LwT5OHCCSZIfW7Wqg8iEkbdWKlC5F4Dwwg9U1+7u3EV+Di+VIxY8S+lcp80p2aOuDvRj76AsM1T2ay1FknMI6fs0w+S5FWn1oaZjzJruu7PL8K3LkoGbxDHblYyVXRsD8cs4dIzOuX0qraKtoiSDDTfJ7tVRHY8uksegWgXCV00XmE0UdvsNDPijd6S3ka00hXYID+HtUXpIfXsssat4Czh4hwMSbyj525h9tnKVeOqsJCjNV5RvMZNZSCpFzD/A+eOIKk+2HTVU+aJZC85oF0IFL0A== 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=t3pHLXGgeEGrrh+mVtFGT3Eps8Wf7vuPJnmoFsywf7s=; b=ynW94f6grfqGoWoQvLxk0dXvouqdaGLMNawJ5pmmH5vA8frsQ+CGMU1QyNRZVqwpeh1pfkt9eT+ytGt6UTj/Hjh2P7Igu95HpZO0eOr2esKUUmpZOVEnObjf9RZDop54ucqzIvSv4jbKBMtk2W97jJ4cIbHGlWrmiskr6hXyOB0= Received: from VI1PR08MB5325.eurprd08.prod.outlook.com (2603:10a6:803:13e::17) by DB9PR08MB9492.eurprd08.prod.outlook.com (2603:10a6:10:459::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7091.38; Tue, 19 Dec 2023 10:11:44 +0000 Received: from VI1PR08MB5325.eurprd08.prod.outlook.com ([fe80::9679:2ab0:99c6:54a3]) by VI1PR08MB5325.eurprd08.prod.outlook.com ([fe80::9679:2ab0:99c6:54a3%6]) with mapi id 15.20.7091.034; Tue, 19 Dec 2023 10:11:44 +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+EejwZw34pdOQrBusCOAgAABsMCAADkUgIBBunOQ Date: Tue, 19 Dec 2023 10:11:44 +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_|DB9PR08MB9492:EE_|AM3PEPF00009B9B:EE_|PAXPR08MB6367:EE_ X-MS-Office365-Filtering-Correlation-Id: 3a01983f-c8f0-4ba6-cf32-08dc007aee51 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: mOhmBJnTON1WwATjszDygvZwqLYWicZvVsYd44PQu6bPogTiRWOIAKTBc9/IZMo5eMzzbuoDKL+IL/wftLJKpbVK5hRyOVnuu9dyVNIZg8ZV54AGI+BjowQcFhCvbuDIm4nurPPs+yR3FE/+qSyc2BFBdl2+zQraarJdZdAd6OpL+u8abcmXqgYrT9vwUzr2W1OKLc6NDKTVQZWa/aBzWg9DQQZiA9icLQNgLpBGLIHqKcBxMISRRSTIU7f5k0CQ2WXyIemmBd5P1FLX+6PCGQfJCVLygKJmTFqpuWd23aqds5/w1A3WZOEWcaZdwpdfzhXlnbKCY+WyI7X4JuZjTOPM42R4NltManIJQnya79obT+yKDERGKJPiU5KYpK0p4mFgvIS34XfJe9nfVkE2kCoG6ZMBUii36P5AV0wjIjZXYkKC+vgCzcgSVO8DUPaKemyuH1evbw3Kni17V/GNZ7D/bvpWcqNLmUmmg6sZVwivotLrK8EEE//A8AbHo7z8nHTcirL8yyLUpAVzbJWjG8roZsX0Ss4UXsPOIAYj/mNzbqFEFdvOh2qqlEmj6+mOjitVrEd7PyVQyZO12D92fllhkeQDc+DrcyB32a+RrBkTyDpq703Yg02eQTXhYUN2LOKSSBoVDIxclMEdCok+Ng== 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)(39860400002)(366004)(136003)(346002)(396003)(376002)(230922051799003)(1800799012)(64100799003)(451199024)(186009)(2906002)(8936002)(8676002)(4326008)(9686003)(71200400001)(52536014)(6506007)(7696005)(55016003)(316002)(83380400001)(64756008)(66476007)(5660300002)(30864003)(66446008)(6916009)(66946007)(66556008)(76116006)(54906003)(41300700001)(99936003)(122000001)(38100700002)(84970400001)(478600001)(26005)(86362001)(33656002)(38070700009)(66899024)(559001)(579004);DIR:OUT;SFP:1101; Content-Type: multipart/mixed; boundary="_002_VI1PR08MB5325CBD43268E3BC25649BDDFF97AVI1PR08MB5325eurp_" MIME-Version: 1.0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB9PR08MB9492 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: AM3PEPF00009B9B.eurprd04.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: 3fa34409-000e-4a75-5526-08dc007ae734 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: +pkU5ZznntQixkLoHvtGc0gV5HnkrFNzjujwoQhCce7/45sYmQAhggwso6FT2trTQA9H8z8Kkb/MfY3b63zmVlhMY/Lrd0hK4N5BswSa+neIUlNxsSCGxn6duClPDwVIokGPoPbmFP09sMQM5p5JXJLU8/iUmisoL8zxhUjW804lLh0hM+vKCCz8ZQ88X5aDMEjUEiBoiY9+lYlUA8BLaYjDzP+aq7Gq6umHTOA656h25crf+QxiP/pHc6BAofsH00Ilf1hgYNYYiyvH9fGFYr1RYhzTU+PumIBGXhUl9bkT+Nf8AZyqwc4jby/Ddt3cikRriao7JjEsr8/z5r0MewflGNt6rCiPnF6XGeceGzJV5U3UAHSuSb7aawyflJI+v7bRqhZAyPLNQSq1f/15hLrtiWSqsDBGsrkfs3XMAdZg+DT5LTokt9uX2GB3VxXixetMsuvWJ/qKfK8dFrIGaGPXFTLkSQ7SdbichMKNzT+LRC3gUNgISkQU/FMBqpDLVQSI3wUwyLfjstxs971oo228SjmtPitcOmizVurpEcQsLl4PDuq+JyQ1HJ2BS2mLniBM1sbFmWl3ElssWSbZohe7XoGhOsxeP+UrpgB9nk31UD+8rfJIcnq7Yw0E6fGj5PFJE0QW1LO7Q5KtUqnXM8x5V0l9sRH8gx6M0DMTucDv0wyjdzjSHwu79FFRzGFOn5zQ6XjWfde4dJYVXPwzsC9g43lUaChCHS72sMculT9vN2ylHaU1e2AbZQ44UuQZL704pRuM7iiYj4Uzmi0y0w== X-Forefront-Antispam-Report: CIP:63.35.35.123;CTRY:IE;LANG:en;SCL:1;SRV:;IPV:CAL;SFV:NSPM;H:64aa7808-outbound-1.mta.getcheckrecipient.com;PTR:ec2-63-35-35-123.eu-west-1.compute.amazonaws.com;CAT:NONE;SFS:(13230031)(4636009)(396003)(39860400002)(346002)(376002)(136003)(230922051799003)(82310400011)(451199024)(64100799003)(186009)(1800799012)(46966006)(36840700001)(40470700004)(55016003)(40480700001)(84970400001)(40460700003)(36860700001)(81166007)(47076005)(356005)(82740400003)(30864003)(33656002)(2906002)(5660300002)(83380400001)(6506007)(99936003)(7696005)(107886003)(26005)(336012)(9686003)(235185007)(66899024)(478600001)(70206006)(70586007)(54906003)(41300700001)(86362001)(4326008)(8936002)(8676002)(6862004)(52536014)(316002);DIR:OUT;SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 19 Dec 2023 10:11:56.3335 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 3a01983f-c8f0-4ba6-cf32-08dc007aee51 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: AM3PEPF00009B9B.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXPR08MB6367 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_VI1PR08MB5325CBD43268E3BC25649BDDFF97AVI1PR08MB5325eurp_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable > > > > + /* Save destination as we go, BB are visited in order and th= e last one > > > > + 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; > > > > + } > > > > + } > > > > + > > > > + dest_bb =3D FALLTHRU_EDGE (dest_bb)->dest; > > > > > > no edge is the fallthru edge out of a condition, so this always selec= ts > > > EDGE_SUCC (dest_bb, 1) which cannot be correct (well, guess you're lu= cky). I > > > think you instead want > > > > > > dest_bb =3D EDGE_SUCC (dest_bb, 0)->dest->loop_father =3D=3D dest_b= b- > > > >loop_father ? EDGE_SUCC (dest_bb, 0)->dest : EDGE_SUCC (dest_bb, 1)- > > > >dest; > > > > > > more nicely written, of course. > > > > > > > + gcc_assert (dest_bb); > > > > + LOOP_VINFO_EARLY_BRK_DEST_BB (loop_vinfo) =3D dest_bb; > > > > > > Sorting the vector of early breaks as we gather them might be nicer t= han this - > > > you'd then simply use the first or last. > > > I opted not to do the sorting since I don't really need a full order betwee= n the exits here And only need to find the last one. A sort would be more expensive than t= he linear Check here. But I also couldn't think of a good sort key since all you hav= e is dominate yes/no. Bootstrapped Regtested on aarch64-none-linux-gnu, x86_64-pc-linux-gnu and no issues. Ok for master? Thanks, Tamar gcc/ChangeLog: * 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. (class _loop_vec_info): Add early_breaks, early_break_conflict, early_break_vuses. (LOOP_VINFO_EARLY_BREAKS): New. (LOOP_VINFO_EARLY_BRK_CONFLICT_STMTS): 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: New test. * 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-vect-data-refs.cc b/gcc/tree-vect-data-refs.cc index d5c9c4a11c2e5d8fd287f412bfa86d081c2f8325..8e9e780e01fd349b30da1f0a762= c0306ec257ff7 100644 --- a/gcc/tree-vect-data-refs.cc +++ b/gcc/tree-vect-data-refs.cc @@ -613,6 +613,377 @@ 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"); + + /* - CHAIN: Currently detected sequence of instructions that need to be = moved + if we are to vectorize this early break. + - FIXED: Sequences of SSA_NAMEs that must not be moved, they are reac= hable + from one or more cond conditions. If this set overlaps with CHAIN + then FIXED takes precedence. This deals with non-single use + cases. + - BASES: List of all load data references found during traversal. */ + hash_set chain, fixed; + auto_vec bases; + basic_block dest_bb =3D NULL; + + hash_set visited; + use_operand_p use_p; + ssa_op_iter iter; + 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); + + /* First determine the list of statements that we can't move because= they + are required for the early break vectorization itself. */ + auto_vec workset; + workset.safe_push (c); + do { + gimple *op =3D workset.pop (); + if (visited.add (op) + || is_a (op) + || is_gimple_debug (op)) + continue; + + if (gimple_has_lhs (op)) + fixed.add (gimple_get_lhs (op)); + + stmt_vec_info def_info =3D loop_vinfo->lookup_stmt (op); + if (!def_info) + continue; + + gimple *def_stmt =3D STMT_VINFO_STMT (def_info); + FOR_EACH_SSA_USE_OPERAND (use_p, def_stmt, iter, SSA_OP_USE) + { + tree use =3D USE_FROM_PTR (use_p); + if (TREE_CODE (use) !=3D SSA_NAME || SSA_NAME_IS_DEFAULT_DEF (use)) + continue; + + if (gimple *g =3D SSA_NAME_DEF_STMT (use)) + workset.safe_push (g); + } + } while (!workset.is_empty ()); + + /* 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; + + tree dest =3D NULL_TREE; + /* Try to find the SSA_NAME being defined. For Statements with an LHS + use the LHS, if not, assume that the first argument of a call is + the value being defined. e.g. MASKED_LOAD etc. */ + if (gimple_has_lhs (stmt)) + dest =3D gimple_get_lhs (stmt); + else if (const gcall *call =3D dyn_cast (stmt)) + dest =3D gimple_arg (call, 0); + + bool move =3D chain.contains (dest); + + stmt_vec_info stmt_vinfo =3D loop_vinfo->lookup_stmt (stmt); + if (!stmt_vinfo) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "early breaks not supported. Unknown" + " statement: %G", stmt); + return opt_result::failure_at (c, + "can't safely apply code motion to " + "dependencies of %G to vectorize " + "the early exit.\n", c); + } + + auto dr_ref =3D STMT_VINFO_DATA_REF (stmt_vinfo); + if (dr_ref) + { + /* 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. */ + tree stype =3D TREE_TYPE (DECL_SIZE (refbase)); + tree access =3D fold_build2 (PLUS_EXPR, stype, DR_OFFSET (dr_ref), + DR_INIT (dr_ref)); + tree final_adj + =3D fold_build2 (MULT_EXPR, stype, LOOP_VINFO_NITERS (loop_vinfo), + DR_STEP (dr_ref)); + + /* must be a constant or assume loop will be versioned or niters + bounded by VF so accesses are within range. */ + if (TREE_CODE (access) =3D=3D INTEGER_CST + && TREE_CODE (final_adj) =3D=3D INTEGER_CST) + { + access =3D fold_build2 (PLUS_EXPR, stype, access, final_adj); + wide_int size =3D wi::to_wide (DECL_SIZE (refbase)); + wide_int off =3D wi::to_wide (access); + if (wi::ge_p (off, size, UNSIGNED)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "early breaks not supported:" + " vectorization would read beyond size" + " of object %T.\n", obj); + 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 hoisting 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_read, dr_ref, 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); + } + + /* Any writes starts a new chain. */ + move =3D true; + } + } + + /* If a statement is live and escapes the loop through usage in the + loop epilogue then we can't move it since we need to maintain its + reachability through all exits. */ + bool skip =3D false; + if (STMT_VINFO_LIVE_P (stmt_vinfo) + && !(dr_ref && DR_IS_WRITE (dr_ref))) + { + imm_use_iterator imm_iter; + use_operand_p use_p; + FOR_EACH_IMM_USE_FAST (use_p, imm_iter, dest) + { + basic_block bb =3D gimple_bb (USE_STMT (use_p)); + skip =3D bb =3D=3D LOOP_VINFO_IV_EXIT (loop_vinfo)->dest; + if (skip) + break; + } + } + + /* If we found the defining statement of a something that's part of + the chain then expand the chain with the new SSA_VARs being + used. */ + if (!skip && move) + { + use_operand_p use_p; + ssa_op_iter iter; + FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE) + { + tree op =3D USE_FROM_PTR (use_p); + gcc_assert (TREE_CODE (op) =3D=3D SSA_NAME); + if (fixed.contains (dest)) + { + move =3D false; + fixed.add (op); + } + else + chain.add (op); + } + + if (dump_enabled_p ()) + { + if (move) + dump_printf_loc (MSG_NOTE, vect_location, + "found chain %G", stmt); + else + dump_printf_loc (MSG_NOTE, vect_location, + "ignored chain %G, not single use", stmt); + } + } + + if (move) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "=3D=3D> recording stmt %G", stmt); + + /* 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); + } + + if (gimple_vuse (stmt) && !gimple_vdef (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 +1028,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..0a90d2860b8d037b72fd41d4240= 804aa390467ea 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_CONFLICT_STMTS (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_CONFLICT_STMTS (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_CONFLICT_STMTS (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..3c9478a3dc8750c71e0bf2a36a5= b0815afc3fd94 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 statements needing to be moved if doing ear= ly + 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_conflict; + + /* 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_CONFLICT_STMTS(L) (L)->early_break_conflict +#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 --_002_VI1PR08MB5325CBD43268E3BC25649BDDFF97AVI1PR08MB5325eurp_ Content-Type: application/octet-stream; name="rb17963.patch" Content-Description: rb17963.patch Content-Disposition: attachment; filename="rb17963.patch"; size=24616; creation-date="Tue, 19 Dec 2023 10:11:15 GMT"; modification-date="Tue, 19 Dec 2023 10:11:44 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 ZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtZGF0YS1yZWZzLmNjIGIvZ2NjL3RyZWUtdmVjdC1kYXRh LXJlZnMuY2MKaW5kZXggZDVjOWM0YTExYzJlNWQ4ZmQyODdmNDEyYmZhODZkMDgxYzJmODMyNS4u OGU5ZTc4MGUwMWZkMzQ5YjMwZGExZjBhNzYyYzAzMDZlYzI1N2ZmNyAxMDA2NDQKLS0tIGEvZ2Nj L3RyZWUtdmVjdC1kYXRhLXJlZnMuY2MKKysrIGIvZ2NjL3RyZWUtdmVjdC1kYXRhLXJlZnMuY2MK QEAgLTYxMyw2ICs2MTMsMzc3IEBAIHZlY3RfYW5hbHl6ZV9kYXRhX3JlZl9kZXBlbmRlbmNlIChz dHJ1Y3QgZGF0YV9kZXBlbmRlbmNlX3JlbGF0aW9uICpkZHIsCiAgIHJldHVybiBvcHRfcmVzdWx0 OjpzdWNjZXNzICgpOwogfQogCisvKiBGdW5jaW9uIHZlY3RfYW5hbHl6ZV9lYXJseV9icmVha19k ZXBlbmRlbmNlcy4KKworICAgRXhhbWltZSBhbGwgdGhlIGRhdGEgcmVmZXJlbmNlcyBpbiB0aGUg bG9vcCBhbmQgbWFrZSBzdXJlIHRoYXQgaWYgd2UgaGF2ZQorICAgbXVsaXRwbGUgZXhpdHMgdGhh dCB3ZSBhcmUgYWJsZSB0byBzYWZlbHkgbW92ZSBzdG9yZXMgc3VjaCB0aGF0IHRoZXkgYmVjb21l CisgICBzYWZlIGZvciB2ZWN0b3JpemF0aW9uLiAgVGhlIGZ1bmN0aW9uIGFsc28gY2FsY3VsYXRl cyB0aGUgcGxhY2Ugd2hlcmUgdG8gbW92ZQorICAgdGhlIGluc3RydWN0aW9ucyB0byBhbmQgY29t cHV0ZXMgd2hhdCB0aGUgbmV3IHZVU0UgY2hhaW4gc2hvdWxkIGJlLgorCisgICBUaGlzIHdvcmtz IGluIHRhbmRlbSB3aXRoIHRoZSBDRkcgdGhhdCB3aWxsIGJlIHByb2R1Y2VkIGJ5CisgICBzbHBl ZWxfdHJlZV9kdXBsaWNhdGVfbG9vcF90b19lZGdlX2NmZyBsYXRlciBvbi4KKworICAgVGhpcyBm dW5jdGlvbiB0cmllcyB0byB2YWxpZGF0ZSB3aGV0aGVyIGFuIGVhcmx5IGJyZWFrIHZlY3Rvcml6 YXRpb24KKyAgIGlzIHBvc3NpYmxlIGZvciB0aGUgY3VycmVudCBpbnN0cnVjdGlvbiBzZXF1ZW5j ZS4gUmV0dXJucyBUcnVlIGkKKyAgIHBvc3NpYmxlLCBvdGhlcndpc2UgRmFsc2UuCisKKyAgIFJl cXVpcmVtZW50czoKKyAgICAgLSBBbnkgbWVtb3J5IGFjY2VzcyBtdXN0IGJlIHRvIGEgZml4ZWQg c2l6ZSBidWZmZXIuCisgICAgIC0gVGhlcmUgbXVzdCBub3QgYmUgYW55IGxvYWRzIGFuZCBzdG9y ZXMgdG8gdGhlIHNhbWUgb2JqZWN0LgorICAgICAtIE11bHRpcGxlIGxvYWRzIGFyZSBhbGxvd2Vk IGFzIGxvbmcgYXMgdGhleSBkb24ndCBhbGlhcy4KKworICAgTk9URToKKyAgICAgVGhpcyBpbXBs ZW1lbWVudGF0aW9uIGlzIHZlcnkgY29uc2VydmF0aXZlLiBBbnkgb3ZlcmxhcHBpZyBsb2Fkcy9z dG9yZXMKKyAgICAgdGhhdCB0YWtlIHBsYWNlIGJlZm9yZSB0aGUgZWFybHkgYnJlYWsgc3RhdGVt ZW50IGdldHMgcmVqZWN0ZWQgYXNpZGUgZnJvbQorICAgICBXQVIgZGVwZW5kZW5jaWVzLgorCisg ICAgIGkuZS46CisKKwlhW2ldID0gOAorCWMgPSBhW2ldCisJaWYgKGJbaV0pCisJICAuLi4KKwor CWlzIG5vdCBhbGxvd2VkLCBidXQKKworCWMgPSBhW2ldCisJYVtpXSA9IDgKKwlpZiAoYltpXSkK KwkgIC4uLgorCisJaXMgd2hpY2ggaXMgdGhlIGNvbW1vbiBjYXNlLiAgKi8KKworc3RhdGljIG9w dF9yZXN1bHQKK3ZlY3RfYW5hbHl6ZV9lYXJseV9icmVha19kZXBlbmRlbmNlcyAobG9vcF92ZWNf aW5mbyBsb29wX3ZpbmZvKQoreworICBEVU1QX1ZFQ1RfU0NPUEUgKCJ2ZWN0X2FuYWx5emVfZWFy bHlfYnJlYWtfZGVwZW5kZW5jZXMiKTsKKworICAvKiAtIENIQUlOOiBDdXJyZW50bHkgZGV0ZWN0 ZWQgc2VxdWVuY2Ugb2YgaW5zdHJ1Y3Rpb25zIHRoYXQgbmVlZCB0byBiZSBtb3ZlZAorCSAgICAg IGlmIHdlIGFyZSB0byB2ZWN0b3JpemUgdGhpcyBlYXJseSBicmVhay4KKyAgICAgLSBGSVhFRDog U2VxdWVuY2VzIG9mIFNTQV9OQU1FcyB0aGF0IG11c3Qgbm90IGJlIG1vdmVkLCB0aGV5IGFyZSBy ZWFjaGFibGUKKwkgICAgICBmcm9tIG9uZSBvciBtb3JlIGNvbmQgY29uZGl0aW9ucy4gIElmIHRo aXMgc2V0IG92ZXJsYXBzIHdpdGggQ0hBSU4KKwkgICAgICB0aGVuIEZJWEVEIHRha2VzIHByZWNl ZGVuY2UuICBUaGlzIGRlYWxzIHdpdGggbm9uLXNpbmdsZSB1c2UKKwkgICAgICBjYXNlcy4KKyAg ICAgLSBCQVNFUzogTGlzdCBvZiBhbGwgbG9hZCBkYXRhIHJlZmVyZW5jZXMgZm91bmQgZHVyaW5n IHRyYXZlcnNhbC4gICovCisgIGhhc2hfc2V0PHRyZWU+IGNoYWluLCBmaXhlZDsKKyAgYXV0b192 ZWM8ZGF0YV9yZWZlcmVuY2UgKj4gYmFzZXM7CisgIGJhc2ljX2Jsb2NrIGRlc3RfYmIgPSBOVUxM OworCisgIGhhc2hfc2V0IDxnaW1wbGUgKj4gdmlzaXRlZDsKKyAgdXNlX29wZXJhbmRfcCB1c2Vf cDsKKyAgc3NhX29wX2l0ZXIgaXRlcjsKKyAgY2xhc3MgbG9vcCAqbG9vcCA9IExPT1BfVklORk9f TE9PUCAobG9vcF92aW5mbyk7CisgIGNsYXNzIGxvb3AgKmxvb3BfbmVzdCA9IGxvb3Bfb3V0ZXIg KGxvb3ApOworCisgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKyAgICBkdW1wX3ByaW50Zl9sb2Mg KE1TR19OT1RFLCB2ZWN0X2xvY2F0aW9uLAorCQkgICAgICJsb29wIGNvbnRhaW5zIG11bHRpcGxl IGV4aXRzLCBhbmFseXppbmciCisJCSAgICAgIiBzdGF0ZW1lbnQgZGVwZW5kZW5jaWVzLlxuIik7 CisKKyAgZm9yIChnaW1wbGUgKmMgOiBMT09QX1ZJTkZPX0xPT1BfQ09ORFMgKGxvb3BfdmluZm8p KQorICAgIHsKKyAgICAgIHN0bXRfdmVjX2luZm8gbG9vcF9jb25kX2luZm8gPSBsb29wX3ZpbmZv LT5sb29rdXBfc3RtdCAoYyk7CisgICAgICBpZiAoU1RNVF9WSU5GT19UWVBFIChsb29wX2NvbmRf aW5mbykgIT0gbG9vcF9leGl0X2N0cmxfdmVjX2luZm9fdHlwZSkKKwljb250aW51ZTsKKworICAg ICAgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgZ3NpID0gZ3NpX2Zvcl9zdG10IChjKTsKKworICAgICAg LyogRmlyc3QgZGV0ZXJtaW5lIHRoZSBsaXN0IG9mIHN0YXRlbWVudHMgdGhhdCB3ZSBjYW4ndCBt b3ZlIGJlY2F1c2UgdGhleQorCSBhcmUgcmVxdWlyZWQgZm9yIHRoZSBlYXJseSBicmVhayB2ZWN0 b3JpemF0aW9uIGl0c2VsZi4gICovCisgICAgICBhdXRvX3ZlYyA8Z2ltcGxlICo+IHdvcmtzZXQ7 CisgICAgICB3b3Jrc2V0LnNhZmVfcHVzaCAoYyk7CisgICAgICBkbyB7CisJZ2ltcGxlICpvcCA9 IHdvcmtzZXQucG9wICgpOworCWlmICh2aXNpdGVkLmFkZCAob3ApCisJICAgIHx8IGlzX2EgPGdw aGkgKj4gKG9wKQorCSAgICB8fCBpc19naW1wbGVfZGVidWcgKG9wKSkKKwkgIGNvbnRpbnVlOwor CisJaWYgKGdpbXBsZV9oYXNfbGhzIChvcCkpCisJICBmaXhlZC5hZGQgKGdpbXBsZV9nZXRfbGhz IChvcCkpOworCisJc3RtdF92ZWNfaW5mbyBkZWZfaW5mbyA9IGxvb3BfdmluZm8tPmxvb2t1cF9z dG10IChvcCk7CisJaWYgKCFkZWZfaW5mbykKKwkgIGNvbnRpbnVlOworCisJZ2ltcGxlICpkZWZf c3RtdCA9IFNUTVRfVklORk9fU1RNVCAoZGVmX2luZm8pOworCUZPUl9FQUNIX1NTQV9VU0VfT1BF UkFORCAodXNlX3AsIGRlZl9zdG10LCBpdGVyLCBTU0FfT1BfVVNFKQorCSAgeworCSAgICB0cmVl IHVzZSA9IFVTRV9GUk9NX1BUUiAodXNlX3ApOworCSAgICBpZiAoVFJFRV9DT0RFICh1c2UpICE9 IFNTQV9OQU1FIHx8IFNTQV9OQU1FX0lTX0RFRkFVTFRfREVGICh1c2UpKQorCSAgICAgIGNvbnRp bnVlOworCisJICAgIGlmIChnaW1wbGUgKmcgPSBTU0FfTkFNRV9ERUZfU1RNVCAodXNlKSkKKwkg ICAgICB3b3Jrc2V0LnNhZmVfcHVzaCAoZyk7CisJICB9CisgICAgICB9IHdoaWxlICghd29ya3Nl dC5pc19lbXB0eSAoKSk7CisKKyAgICAgIC8qIE5vdyBhbmFseXplIGFsbCB0aGUgcmVtYWluaW5n IHN0YXRlbWVudHMgYW5kIHRyeSB0byBkZXRlcm1pbmUgd2hpY2gKKwkgaW5zdHJ1Y3Rpb25zIGFy ZSBhbGxvd2VkL25lZWRlZCB0byBiZSBtb3ZlZC4gICovCisgICAgICB3aGlsZSAoIWdzaV9lbmRf cCAoZ3NpKSkKKwl7CisJICBnaW1wbGUgKnN0bXQgPSBnc2lfc3RtdCAoZ3NpKTsKKwkgIGdzaV9w cmV2ICgmZ3NpKTsKKwkgIGlmICghZ2ltcGxlX2hhc19vcHMgKHN0bXQpCisJICAgICAgfHwgaXNf Z2ltcGxlX2RlYnVnIChzdG10KSkKKwkgICAgY29udGludWU7CisKKwkgIHRyZWUgZGVzdCA9IE5V TExfVFJFRTsKKwkgIC8qIFRyeSB0byBmaW5kIHRoZSBTU0FfTkFNRSBiZWluZyBkZWZpbmVkLiAg Rm9yIFN0YXRlbWVudHMgd2l0aCBhbiBMSFMKKwkgICAgIHVzZSB0aGUgTEhTLCBpZiBub3QsIGFz c3VtZSB0aGF0IHRoZSBmaXJzdCBhcmd1bWVudCBvZiBhIGNhbGwgaXMKKwkgICAgIHRoZSB2YWx1 ZSBiZWluZyBkZWZpbmVkLiAgZS5nLiBNQVNLRURfTE9BRCBldGMuICAqLworCSAgaWYgKGdpbXBs ZV9oYXNfbGhzIChzdG10KSkKKwkgICAgZGVzdCA9IGdpbXBsZV9nZXRfbGhzIChzdG10KTsKKwkg IGVsc2UgaWYgKGNvbnN0IGdjYWxsICpjYWxsID0gZHluX2Nhc3QgPGNvbnN0IGdjYWxsICo+IChz dG10KSkKKwkgICAgZGVzdCA9IGdpbXBsZV9hcmcgKGNhbGwsIDApOworCisJICBib29sIG1vdmUg PSBjaGFpbi5jb250YWlucyAoZGVzdCk7CisKKwkgIHN0bXRfdmVjX2luZm8gc3RtdF92aW5mbyA9 IGxvb3BfdmluZm8tPmxvb2t1cF9zdG10IChzdG10KTsKKwkgIGlmICghc3RtdF92aW5mbykKKwkg ICAgeworCSAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkJZHVtcF9wcmludGZfbG9jIChN U0dfTUlTU0VEX09QVElNSVpBVElPTiwgdmVjdF9sb2NhdGlvbiwKKwkJCQkgImVhcmx5IGJyZWFr cyBub3Qgc3VwcG9ydGVkLiBVbmtub3duIgorCQkJCSAiIHN0YXRlbWVudDogJUciLCBzdG10KTsK KwkgICAgICByZXR1cm4gb3B0X3Jlc3VsdDo6ZmFpbHVyZV9hdCAoYywKKwkJCQkgICAgICAgImNh bid0IHNhZmVseSBhcHBseSBjb2RlIG1vdGlvbiB0byAiCisJCQkJICAgICAgICJkZXBlbmRlbmNp ZXMgb2YgJUcgdG8gdmVjdG9yaXplICIKKwkJCQkgICAgICAgInRoZSBlYXJseSBleGl0LlxuIiwg Yyk7CisJICAgIH0KKworCSAgYXV0byBkcl9yZWYgPSBTVE1UX1ZJTkZPX0RBVEFfUkVGIChzdG10 X3ZpbmZvKTsKKwkgIGlmIChkcl9yZWYpCisJICAgIHsKKwkgICAgICAvKiBXZSBjdXJyZW50bHkg b25seSBzdXBwb3J0IHN0YXRpY2FsbHkgYWxsb2NhdGVkIG9iamVjdHMgZHVlIHRvCisJCSBub3Qg aGF2aW5nIGZpcnN0LWZhdWx0aW5nIGxvYWRzIHN1cHBvcnQgb3IgcGVlbGluZyBmb3IKKwkJIGFs aWdubWVudCBzdXBwb3J0LiAgQ29tcHV0ZSB0aGUgc2l6ZSBvZiB0aGUgcmVmZXJlbmNlZCBvYmpl Y3QKKwkJIChpdCBjb3VsZCBiZSBkeW5hbWljYWxseSBhbGxvY2F0ZWQpLiAgKi8KKwkgICAgICB0 cmVlIG9iaiA9IERSX0JBU0VfQUREUkVTUyAoZHJfcmVmKTsKKwkgICAgICBpZiAoIW9iaiB8fCBU UkVFX0NPREUgKG9iaikgIT0gQUREUl9FWFBSKQorCQl7CisJCSAgaWYgKGR1bXBfZW5hYmxlZF9w ICgpKQorCQkgICAgZHVtcF9wcmludGZfbG9jIChNU0dfTUlTU0VEX09QVElNSVpBVElPTiwgdmVj dF9sb2NhdGlvbiwKKwkJCQkgICAgICJlYXJseSBicmVha3Mgb25seSBzdXBwb3J0ZWQgb24gc3Rh dGljYWxseSIKKwkJCQkgICAgICIgYWxsb2NhdGVkIG9iamVjdHMuXG4iKTsKKwkJICByZXR1cm4g b3B0X3Jlc3VsdDo6ZmFpbHVyZV9hdCAoYywKKwkJCQkgICAgICJjYW4ndCBzYWZlbHkgYXBwbHkg Y29kZSBtb3Rpb24gdG8gIgorCQkJCSAgICAgImRlcGVuZGVuY2llcyBvZiAlRyB0byB2ZWN0b3Jp emUgIgorCQkJCSAgICAgInRoZSBlYXJseSBleGl0LlxuIiwgYyk7CisJCX0KKworCSAgICAgIHRy ZWUgcmVmb3AgPSBUUkVFX09QRVJBTkQgKG9iaiwgMCk7CisJICAgICAgdHJlZSByZWZiYXNlID0g Z2V0X2Jhc2VfYWRkcmVzcyAocmVmb3ApOworCSAgICAgIGlmICghcmVmYmFzZSB8fCAhREVDTF9Q IChyZWZiYXNlKSB8fCAhREVDTF9TSVpFIChyZWZiYXNlKQorCQkgIHx8IFRSRUVfQ09ERSAoREVD TF9TSVpFIChyZWZiYXNlKSkgIT0gSU5URUdFUl9DU1QpCisJCXsKKwkJICBpZiAoZHVtcF9lbmFi bGVkX3AgKCkpCisJCSAgICAgIGR1bXBfcHJpbnRmX2xvYyAoTVNHX01JU1NFRF9PUFRJTUlaQVRJ T04sIHZlY3RfbG9jYXRpb24sCisJCQkJICAgICAgICJlYXJseSBicmVha3Mgb25seSBzdXBwb3J0 ZWQgb24iCisJCQkJICAgICAgICIgc3RhdGljYWxseSBhbGxvY2F0ZWQgb2JqZWN0cy5cbiIpOwor CQkgIHJldHVybiBvcHRfcmVzdWx0OjpmYWlsdXJlX2F0IChjLAorCQkJCSAgICAgICAiY2FuJ3Qg c2FmZWx5IGFwcGx5IGNvZGUgbW90aW9uIHRvICIKKwkJCQkgICAgICAgImRlcGVuZGVuY2llcyBv ZiAlRyB0byB2ZWN0b3JpemUgIgorCQkJCSAgICAgICAidGhlIGVhcmx5IGV4aXQuXG4iLCBjKTsK KwkJfQorCisJICAgICAgLyogQ2hlY2sgaWYgdmVjdG9yIGFjY2Vzc2VzIHRvIHRoZSBvYmplY3Qg d2lsbCBiZSB3aXRoaW4KKwkJIGJvdW5kcy4gICovCisJICAgICAgdHJlZSBzdHlwZSA9IFRSRUVf VFlQRSAoREVDTF9TSVpFIChyZWZiYXNlKSk7CisJICAgICAgdHJlZSBhY2Nlc3MgPSBmb2xkX2J1 aWxkMiAoUExVU19FWFBSLCBzdHlwZSwgRFJfT0ZGU0VUIChkcl9yZWYpLAorCQkJCQkgRFJfSU5J VCAoZHJfcmVmKSk7CisJICAgICAgdHJlZSBmaW5hbF9hZGoKKwkJPSBmb2xkX2J1aWxkMiAoTVVM VF9FWFBSLCBzdHlwZSwgTE9PUF9WSU5GT19OSVRFUlMgKGxvb3BfdmluZm8pLAorCQkJICAgICAg IERSX1NURVAgKGRyX3JlZikpOworCisJICAgICAgLyogbXVzdCBiZSBhIGNvbnN0YW50IG9yIGFz c3VtZSBsb29wIHdpbGwgYmUgdmVyc2lvbmVkIG9yIG5pdGVycworCQkgYm91bmRlZCBieSBWRiBz byBhY2Nlc3NlcyBhcmUgd2l0aGluIHJhbmdlLiAgKi8KKwkgICAgICBpZiAoVFJFRV9DT0RFIChh Y2Nlc3MpID09IElOVEVHRVJfQ1NUCisJCSAgJiYgVFJFRV9DT0RFIChmaW5hbF9hZGopID09IElO VEVHRVJfQ1NUKQorCQl7CisJCSAgYWNjZXNzID0gZm9sZF9idWlsZDIgKFBMVVNfRVhQUiwgc3R5 cGUsIGFjY2VzcywgZmluYWxfYWRqKTsKKwkJICB3aWRlX2ludCBzaXplID0gd2k6OnRvX3dpZGUg KERFQ0xfU0laRSAocmVmYmFzZSkpOworCQkgIHdpZGVfaW50IG9mZiA9IHdpOjp0b193aWRlIChh Y2Nlc3MpOworCQkgIGlmICh3aTo6Z2VfcCAob2ZmLCBzaXplLCBVTlNJR05FRCkpCisJCSAgICB7 CisJCSAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkJCWR1bXBfcHJpbnRmX2xvYyAoTVNH X01JU1NFRF9PUFRJTUlaQVRJT04sIHZlY3RfbG9jYXRpb24sCisJCQkJCSAiZWFybHkgYnJlYWtz IG5vdCBzdXBwb3J0ZWQ6IgorCQkJCQkgIiB2ZWN0b3JpemF0aW9uIHdvdWxkIHJlYWQgYmV5b25k IHNpemUiCisJCQkJCSAiIG9mIG9iamVjdCAlVC5cbiIsIG9iaik7CisJCSAgICAgIHJldHVybiBv cHRfcmVzdWx0OjpmYWlsdXJlX2F0IChjLAorCQkJCQkgImNhbid0IHNhZmVseSBhcHBseSBjb2Rl IG1vdGlvbiB0byAiCisJCQkJCSAiZGVwZW5kZW5jaWVzIG9mICVHIHRvIHZlY3Rvcml6ZSAiCisJ CQkJCSAidGhlIGVhcmx5IGV4aXQuXG4iLCBjKTsKKwkJICAgIH0KKwkJfQorCisJICAgICAgaWYg KERSX0lTX1JFQUQgKGRyX3JlZikpCisJCWJhc2VzLnNhZmVfcHVzaCAoZHJfcmVmKTsKKwkgICAg ICBlbHNlIGlmIChEUl9JU19XUklURSAoZHJfcmVmKSkKKwkJeworCQkgIC8qIFdlIGFyZSBtb3Zp bmcgd3JpdGVzIGRvd24gaW4gdGhlIENGRy4gIFRvIGJlIHN1cmUgdGhhdCB0aGlzCisJCSAgICAg aXMgdmFsaWQgYWZ0ZXIgdmVjdG9yaXphdGlvbiB3ZSBoYXZlIHRvIGNoZWNrIGFsbCB0aGUgbG9h ZHMKKwkJICAgICB3ZSBhcmUgaG9pc3RpbmcgdGhlIHN0b3JlcyBwYXN0IHRvIHNlZSBpZiBhbnkg b2YgdGhlbSBtYXkKKwkJICAgICBhbGlhcyBvciBhcmUgdGhlIHNhbWUgb2JqZWN0LgorCisJCSAg ICAgU2FtZSBvYmplY3RzIHdpbGwgbm90IGJlIGFuIGlzc3VlIGJlY2F1c2UgdW5sZXNzIHRoZSBz dG9yZQorCQkgICAgIGlzIG1hcmtlZCB2b2xhdGlsZSB0aGUgdmFsdWUgY2FuIGJlIGZvcndhcmRl ZC4gIElmIHRoZQorCQkgICAgIHN0b3JlIGlzIG1hcmtlZCB2b2xhdGlsZSB3ZSBkb24ndCB2ZWN0 b3JpemUgdGhlIGxvb3AKKwkJICAgICBhbnl3YXkuCisKKwkJICAgICBUaGF0IGxlYXZlcyB0aGUg Y2hlY2sgZm9yIGFsaWFzaW5nLiAgV2UgZG9uJ3QgcmVhbGx5IG5lZWQKKwkJICAgICB0byBjYXJl IGFib3V0IHRoZSBzdG9yZXMgYWxpYXNpbmcgd2l0aCBlYWNoIG90aGVyIHNpbmNlIHRoZQorCQkg ICAgIHN0b3JlcyBhcmUgbW92ZWQgaW4gb3JkZXIgc28gdGhlIGVmZmVjdHMgYXJlIHN0aWxsIG9i c2VydmVkCisJCSAgICAgY29ycmVjdGx5LiAgVGhpcyBsZWF2ZXMgdGhlIGNoZWNrIGZvciBXQVIg ZGVwZW5kZW5jaWVzCisJCSAgICAgd2hpY2ggd2Ugd291bGQgYmUgaW50cm9kdWNpbmcgaGVyZSBp ZiB0aGUgRFIgY2FuIGFsaWFzLgorCQkgICAgIFRoZSBjaGVjayBpcyBxdWFkcmF0aWMgaW4gbG9h ZHMvc3RvcmVzIGJ1dCBJIGhhdmUgbm90IGZvdW5kCisJCSAgICAgYSBiZXR0ZXIgQVBJIHRvIGRv IHRoaXMuICBJIGJlbGlldmUgYWxsIGxvYWRzIGFuZCBzdG9yZXMKKwkJICAgICBtdXN0IGJlIGNo ZWNrZWQuICBXZSBhbHNvIG11c3QgY2hlY2sgdGhlbSB3aGVuIHdlCisJCSAgICAgZW5jb3VudGVy ZWQgdGhlIHN0b3JlLCBzaW5jZSB3ZSBkb24ndCBjYXJlIGFib3V0IGxvYWRzIHBhc3QKKwkJICAg ICB0aGUgc3RvcmUuICAqLworCisJCSAgZm9yIChhdXRvIGRyX3JlYWQgOiBiYXNlcykKKwkJICAg IGlmIChkcl9tYXlfYWxpYXNfcCAoZHJfcmVhZCwgZHJfcmVmLCBsb29wX25lc3QpKQorCQkgICAg ICB7CisJCQlpZiAoZHVtcF9lbmFibGVkX3AgKCkpCisJCQkgICAgZHVtcF9wcmludGZfbG9jIChN U0dfTUlTU0VEX09QVElNSVpBVElPTiwKKwkJCQkJICAgICB2ZWN0X2xvY2F0aW9uLAorCQkJCQkg ICAgICJlYXJseSBicmVha3Mgbm90IHN1cHBvcnRlZDogIgorCQkJCQkgICAgICJvdmVybGFwcGlu ZyBsb2FkcyBhbmQgc3RvcmVzICIKKwkJCQkJICAgICAiZm91bmQgYmVmb3JlIHRoZSBicmVhayAi CisJCQkJCSAgICAgInN0YXRlbWVudC5cbiIpOworCisJCQlyZXR1cm4gb3B0X3Jlc3VsdDo6ZmFp bHVyZV9hdCAoc3RtdCwKKwkJCSAgICAgImNhbid0IHNhZmVseSBhcHBseSBjb2RlIG1vdGlvbiB0 byBkZXBlbmRlbmNpZXMiCisJCQkgICAgICIgdG8gdmVjdG9yaXplIHRoZSBlYXJseSBleGl0LiAl RyBtYXkgYWxpYXMgd2l0aCIKKwkJCSAgICAgIiAlR1xuIiwgc3RtdCwgZHJfcmVhZC0+c3RtdCk7 CisJCSAgICAgIH0KKworCQkgIC8qIEFueSB3cml0ZXMgc3RhcnRzIGEgbmV3IGNoYWluLiAqLwor CQkgIG1vdmUgPSB0cnVlOworCQl9CisJICAgIH0KKworCSAgLyogSWYgYSBzdGF0ZW1lbnQgaXMg bGl2ZSBhbmQgZXNjYXBlcyB0aGUgbG9vcCB0aHJvdWdoIHVzYWdlIGluIHRoZQorCSAgICAgbG9v cCBlcGlsb2d1ZSB0aGVuIHdlIGNhbid0IG1vdmUgaXQgc2luY2Ugd2UgbmVlZCB0byBtYWludGFp biBpdHMKKwkgICAgIHJlYWNoYWJpbGl0eSB0aHJvdWdoIGFsbCBleGl0cy4gICovCisJICBib29s IHNraXAgPSBmYWxzZTsKKwkgIGlmIChTVE1UX1ZJTkZPX0xJVkVfUCAoc3RtdF92aW5mbykKKwkg ICAgICAmJiAhKGRyX3JlZiAmJiBEUl9JU19XUklURSAoZHJfcmVmKSkpCisJICAgIHsKKwkgICAg ICBpbW1fdXNlX2l0ZXJhdG9yIGltbV9pdGVyOworCSAgICAgIHVzZV9vcGVyYW5kX3AgdXNlX3A7 CisJICAgICAgRk9SX0VBQ0hfSU1NX1VTRV9GQVNUICh1c2VfcCwgaW1tX2l0ZXIsIGRlc3QpCisJ CXsKKwkJICBiYXNpY19ibG9jayBiYiA9IGdpbXBsZV9iYiAoVVNFX1NUTVQgKHVzZV9wKSk7CisJ CSAgc2tpcCA9IGJiID09IExPT1BfVklORk9fSVZfRVhJVCAobG9vcF92aW5mbyktPmRlc3Q7CisJ CSAgaWYgKHNraXApCisJCSAgICBicmVhazsKKwkJfQorCSAgICB9CisKKwkgIC8qIElmIHdlIGZv dW5kIHRoZSBkZWZpbmluZyBzdGF0ZW1lbnQgb2YgYSBzb21ldGhpbmcgdGhhdCdzIHBhcnQgb2YK KwkgICAgIHRoZSBjaGFpbiB0aGVuIGV4cGFuZCB0aGUgY2hhaW4gd2l0aCB0aGUgbmV3IFNTQV9W QVJzIGJlaW5nCisJICAgICB1c2VkLiAgKi8KKwkgIGlmICghc2tpcCAmJiBtb3ZlKQorCSAgICB7 CisJICAgICAgdXNlX29wZXJhbmRfcCB1c2VfcDsKKwkgICAgICBzc2Ffb3BfaXRlciBpdGVyOwor CSAgICAgIEZPUl9FQUNIX1NTQV9VU0VfT1BFUkFORCAodXNlX3AsIHN0bXQsIGl0ZXIsIFNTQV9P UF9VU0UpCisJCXsKKwkJICB0cmVlIG9wID0gVVNFX0ZST01fUFRSICh1c2VfcCk7CisJCSAgZ2Nj X2Fzc2VydCAoVFJFRV9DT0RFIChvcCkgPT0gU1NBX05BTUUpOworCQkgIGlmIChmaXhlZC5jb250 YWlucyAoZGVzdCkpCisJCSAgICB7CisJCSAgICAgIG1vdmUgPSBmYWxzZTsKKwkJICAgICAgZml4 ZWQuYWRkIChvcCk7CisJCSAgICB9CisJCSAgZWxzZQorCQkgICAgY2hhaW4uYWRkIChvcCk7CisJ CX0KKworCSAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkJeworCQkgIGlmIChtb3ZlKQor CQkgICAgZHVtcF9wcmludGZfbG9jIChNU0dfTk9URSwgdmVjdF9sb2NhdGlvbiwKKwkJCQkgICAg ICJmb3VuZCBjaGFpbiAlRyIsIHN0bXQpOworCQkgIGVsc2UKKwkJICAgIGR1bXBfcHJpbnRmX2xv YyAoTVNHX05PVEUsIHZlY3RfbG9jYXRpb24sCisJCQkJICAgICAiaWdub3JlZCBjaGFpbiAlRywg bm90IHNpbmdsZSB1c2UiLCBzdG10KTsKKwkJfQorCSAgICB9CisKKwkgIGlmIChtb3ZlKQorCSAg ICB7CisJICAgICAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQorCQlkdW1wX3ByaW50Zl9sb2MgKE1T R19OT1RFLCB2ZWN0X2xvY2F0aW9uLAorCQkJCSAiPT0+IHJlY29yZGluZyBzdG10ICVHIiwgc3Rt dCk7CisKKwkgICAgICAvKiBJZiB3ZSd2ZSBtb3ZlZCBhIFZERUYsIGV4dHJhY3QgdGhlIGRlZmlu aW5nIE1FTSBhbmQgdXBkYXRlCisJCSB1c2FnZXMgb2YgaXQuICAgKi8KKwkgICAgICB0cmVlIHZk ZWY7CisJICAgICAgLyogVGhpcyBzdGF0ZW1lbnQgaXMgdG8gYmUgbW92ZWQuICAqLworCSAgICAg IGlmICgodmRlZiA9IGdpbXBsZV92ZGVmIChzdG10KSkpCisJCUxPT1BfVklORk9fRUFSTFlfQlJL X0NPTkZMSUNUX1NUTVRTIChsb29wX3ZpbmZvKS5zYWZlX3B1c2ggKAorCQkgICAgc3RtdCk7CisJ ICAgIH0KKworCSAgaWYgKGdpbXBsZV92dXNlIChzdG10KSAmJiAhZ2ltcGxlX3ZkZWYgKHN0bXQp KQorCSAgICB7CisJICAgICAgTE9PUF9WSU5GT19FQVJMWV9CUktfVlVTRVMgKGxvb3BfdmluZm8p LnNhZmVfaW5zZXJ0ICgwLCBzdG10KTsKKwkgICAgICBpZiAoZHVtcF9lbmFibGVkX3AgKCkpCisJ CWR1bXBfcHJpbnRmX2xvYyAoTVNHX05PVEUsIHZlY3RfbG9jYXRpb24sCisJCQkJICJtYXJrZWQg c3RhdGVtZW50IGZvciB2VVNFIHVwZGF0ZTogJUciLCBzdG10KTsKKwkgICAgfQorCX0KKworICAg ICAgLyogU2F2ZSBkZXN0aW5hdGlvbiBhcyB3ZSBnbywgQkIgYXJlIHZpc2l0ZWQgaW4gb3JkZXIg YW5kIHRoZSBsYXN0IG9uZQorCWlzIHdoZXJlIHN0YXRlbWVudHMgc2hvdWxkIGJlIG1vdmVkIHRv LiAgKi8KKyAgICAgIGlmICghZGVzdF9iYikKKwlkZXN0X2JiID0gZ2ltcGxlX2JiIChjKTsKKyAg ICAgIGVsc2UKKwl7CisJICBiYXNpY19ibG9jayBjdXJyX2JiID0gZ2ltcGxlX2JiIChjKTsKKwkg IGlmIChkb21pbmF0ZWRfYnlfcCAoQ0RJX0RPTUlOQVRPUlMsIGN1cnJfYmIsIGRlc3RfYmIpKQor CSAgICBkZXN0X2JiID0gY3Vycl9iYjsKKwl9CisKKyAgICAgIC8qIE1hcmsgdGhlIHN0YXRlbWVu dCBhcyBhIGNvbmRpdGlvbi4gICovCisgICAgICBTVE1UX1ZJTkZPX0RFRl9UWVBFIChsb29wX2Nv bmRfaW5mbykgPSB2ZWN0X2NvbmRpdGlvbl9kZWY7CisgICAgfQorCisgIGJhc2ljX2Jsb2NrIGRl c3RfYmIwID0gRURHRV9TVUNDIChkZXN0X2JiLCAwKS0+ZGVzdDsKKyAgYmFzaWNfYmxvY2sgZGVz dF9iYjEgPSBFREdFX1NVQ0MgKGRlc3RfYmIsIDEpLT5kZXN0OworICBkZXN0X2JiID0gZmxvd19i Yl9pbnNpZGVfbG9vcF9wIChsb29wLCBkZXN0X2JiMCkgPyBkZXN0X2JiMCA6IGRlc3RfYmIxOwor ICAvKiBXZSBkb24ndCBhbGxvdyBvdXRlciAtPiBpbm5lciBsb29wIHRyYW5zaXRpb25zIHdoaWNo IHNob3VsZCBoYXZlIGJlZW4KKyAgICAgdHJhcHBlZCBhbHJlYWR5IGR1cmluZyBsb29wIGZvcm0g YW5hbHlzaXMuICAqLworICBnY2NfYXNzZXJ0IChkZXN0X2JiLT5sb29wX2ZhdGhlciA9PSBsb29w KTsKKworICBnY2NfYXNzZXJ0IChkZXN0X2JiKTsKKyAgTE9PUF9WSU5GT19FQVJMWV9CUktfREVT VF9CQiAobG9vcF92aW5mbykgPSBkZXN0X2JiOworCisgIGlmICghTE9PUF9WSU5GT19FQVJMWV9C UktfVlVTRVMgKGxvb3BfdmluZm8pLmlzX2VtcHR5ICgpKQorICAgIHsKKyAgICAgIC8qIEFsbCB1 c2VzIHNoYWxsIGJlIHVwZGF0ZWQgdG8gdGhhdCBvZiB0aGUgZmlyc3QgbG9hZC4gIEVudHJpZXMg YXJlCisJIHN0b3JlZCBpbiByZXZlcnNlIG9yZGVyLiAgKi8KKyAgICAgIHRyZWUgdnVzZSA9IGdp bXBsZV92dXNlIChMT09QX1ZJTkZPX0VBUkxZX0JSS19WVVNFUyAobG9vcF92aW5mbykubGFzdCAo KSk7CisgICAgICBmb3IgKGF1dG8gZyA6IExPT1BfVklORk9fRUFSTFlfQlJLX1ZVU0VTIChsb29w X3ZpbmZvKSkKKwl7CisJICBpZiAoZHVtcF9lbmFibGVkX3AgKCkpCisJICBkdW1wX3ByaW50Zl9s b2MgKE1TR19OT1RFLCB2ZWN0X2xvY2F0aW9uLAorCQkJICAgIndpbGwgdXBkYXRlIHVzZTogJVQs IG1lbV9yZWY6ICVHIiwgdnVzZSwgZyk7CisJfQorICAgIH0KKworICBpZiAoZHVtcF9lbmFibGVk X3AgKCkpCisgICAgZHVtcF9wcmludGZfbG9jIChNU0dfTk9URSwgdmVjdF9sb2NhdGlvbiwKKwkJ ICAgICAicmVjb3JkZWQgc3RhdGVtZW50cyB0byBiZSBtb3ZlZCB0byBCQiAlZFxuIiwKKwkJICAg ICBMT09QX1ZJTkZPX0VBUkxZX0JSS19ERVNUX0JCIChsb29wX3ZpbmZvKS0+aW5kZXgpOworCisg IHJldHVybiBvcHRfcmVzdWx0OjpzdWNjZXNzICgpOworfQorCiAvKiBGdW5jdGlvbiB2ZWN0X2Fu YWx5emVfZGF0YV9yZWZfZGVwZW5kZW5jZXMuCiAKICAgIEV4YW1pbmUgYWxsIHRoZSBkYXRhIHJl ZmVyZW5jZXMgaW4gdGhlIGxvb3AsIGFuZCBtYWtlIHN1cmUgdGhlcmUgZG8gbm90CkBAIC02NTcs NiArMTAyOCwxMSBAQCB2ZWN0X2FuYWx5emVfZGF0YV9yZWZfZGVwZW5kZW5jZXMgKGxvb3BfdmVj X2luZm8gbG9vcF92aW5mbywKIAkgIHJldHVybiByZXM7CiAgICAgICB9CiAKKyAgLyogSWYgd2Ug aGF2ZSBlYXJseSBicmVhayBzdGF0ZW1lbnRzIGluIHRoZSBsb29wLCBjaGVjayB0byBzZWUgaWYg dGhleQorICAgICBhcmUgb2YgYSBmb3JtIHdlIGNhbiB2ZWN0b3JpemVyLiAgKi8KKyAgaWYgKExP T1BfVklORk9fRUFSTFlfQlJFQUtTIChsb29wX3ZpbmZvKSkKKyAgICByZXR1cm4gdmVjdF9hbmFs eXplX2Vhcmx5X2JyZWFrX2RlcGVuZGVuY2VzIChsb29wX3ZpbmZvKTsKKwogICByZXR1cm4gb3B0 X3Jlc3VsdDo6c3VjY2VzcyAoKTsKIH0KIApkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUtdmVjdC1sb29w LmNjIGIvZ2NjL3RyZWUtdmVjdC1sb29wLmNjCmluZGV4IGZiOGQ5OTllZTZiZmFmZjU1MWFjMDZh YzJmM2FlYTUzNTQ5MTQ2NTkuLjBhOTBkMjg2MGI4ZDAzN2I3MmZkNDFkNDI0MDgwNGFhMzkwNDY3 ZWEgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXZlY3QtbG9vcC5jYworKysgYi9nY2MvdHJlZS12ZWN0 LWxvb3AuY2MKQEAgLTEwNDAsNiArMTA0MCw3IEBAIF9sb29wX3ZlY19pbmZvOjpfbG9vcF92ZWNf aW5mbyAoY2xhc3MgbG9vcCAqbG9vcF9pbiwgdmVjX2luZm9fc2hhcmVkICpzaGFyZWQpCiAgICAg cGFydGlhbF9sb2FkX3N0b3JlX2JpYXMgKDApLAogICAgIHBlZWxpbmdfZm9yX2dhcHMgKGZhbHNl KSwKICAgICBwZWVsaW5nX2Zvcl9uaXRlciAoZmFsc2UpLAorICAgIGVhcmx5X2JyZWFrcyAoZmFs c2UpLAogICAgIG5vX2RhdGFfZGVwZW5kZW5jaWVzIChmYWxzZSksCiAgICAgaGFzX21hc2tfc3Rv cmUgKGZhbHNlKSwKICAgICBzY2FsYXJfbG9vcF9zY2FsaW5nIChwcm9maWxlX3Byb2JhYmlsaXR5 Ojp1bmluaXRpYWxpemVkICgpKSwKQEAgLTExNTQ4LDYgKzExNTQ5LDU2IEBAIHVwZGF0ZV9lcGls b2d1ZV9sb29wX3ZpbmZvIChjbGFzcyBsb29wICplcGlsb2d1ZSwgdHJlZSBhZHZhbmNlKQogICBl cGlsb2d1ZV92aW5mby0+c2hhcmVkLT5zYXZlX2RhdGFyZWZzICgpOwogfQogCisvKiAgV2hlbiB2 ZWN0b3JpemluZyBlYXJseSBicmVhayBzdGF0ZW1lbnRzIGluc3RydWN0aW9ucyB0aGF0IGhhcHBl biBiZWZvcmUKKyAgICB0aGUgZWFybHkgYnJlYWsgaW4gdGhlIGN1cnJlbnQgQkIgbmVlZCB0byBi ZSBtb3ZlZCB0byBhZnRlciB0aGUgZWFybHkKKyAgICBicmVhay4gIFRoaXMgZnVuY3Rpb24gZGVh bHMgd2l0aCB0aGF0IGFuZCBhc3N1bWVzIHRoYXQgYW55IHZhbGlkaXR5CisgICAgY2hlY2tzIGhh cyBhbHJlYWR5IGJlZW4gcGVyZm9ybWVkLgorCisgICAgV2hpbGUgbW92aW5nIHRoZSBpbnN0cnVj dGlvbnMgaWYgaXQgZW5jb3VudGVycyBhIFZVU0Ugb3IgVkRFRiBpdCB0aGVuCisgICAgY29ycmVj dHMgdGhlIFZVU0VTIGFzIGl0IG1vdmVzIHRoZSBzdGF0ZW1lbnRzIGFsb25nLiAgR0RFU1QgaXMg dGhlIGxvY2F0aW9uCisgICAgaW4gd2hpY2ggdG8gaW5zZXJ0IHRoZSBuZXcgc3RhdGVtZW50cy4g ICovCisKK3N0YXRpYyB2b2lkCittb3ZlX2Vhcmx5X2V4aXRfc3RtdHMgKGxvb3BfdmVjX2luZm8g bG9vcF92aW5mbykKK3sKKyAgRFVNUF9WRUNUX1NDT1BFICgibW92ZV9lYXJseV9leGl0X3N0bXRz Iik7CisKKyAgaWYgKExPT1BfVklORk9fRUFSTFlfQlJLX0NPTkZMSUNUX1NUTVRTIChsb29wX3Zp bmZvKS5pc19lbXB0eSAoKSkKKyAgICByZXR1cm47CisKKyAgLyogTW92ZSBhbGwgc3RtdHMgdGhh dCBuZWVkIG1vdmluZy4gICovCisgIGJhc2ljX2Jsb2NrIGRlc3RfYmIgPSBMT09QX1ZJTkZPX0VB UkxZX0JSS19ERVNUX0JCIChsb29wX3ZpbmZvKTsKKyAgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgZGVz dF9nc2kgPSBnc2lfc3RhcnRfYmIgKGRlc3RfYmIpOworCisgIGZvciAoZ2ltcGxlICpzdG10IDog TE9PUF9WSU5GT19FQVJMWV9CUktfQ09ORkxJQ1RfU1RNVFMgKGxvb3BfdmluZm8pKQorICAgIHsK KyAgICAgIC8qIENoZWNrIHRvIHNlZSBpZiBzdGF0ZW1lbnQgaXMgc3RpbGwgcmVxdWlyZWQgZm9y IHZlY3Qgb3IgaGFzIGJlZW4KKwkgZWxpZGVkLiAgKi8KKyAgICAgIGF1dG8gc3RtdF9pbmZvID0g bG9vcF92aW5mby0+bG9va3VwX3N0bXQgKHN0bXQpOworICAgICAgaWYgKCFzdG10X2luZm8pCisJ Y29udGludWU7CisKKyAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwlkdW1wX3ByaW50Zl9s b2MgKE1TR19OT1RFLCB2ZWN0X2xvY2F0aW9uLCAibW92aW5nIHN0bXQgJUciLCBzdG10KTsKKwor ICAgICAgZ2ltcGxlX3N0bXRfaXRlcmF0b3Igc3RtdF9nc2kgPSBnc2lfZm9yX3N0bXQgKHN0bXQp OworICAgICAgZ3NpX21vdmVfYmVmb3JlICgmc3RtdF9nc2ksICZkZXN0X2dzaSk7CisgICAgICBn c2lfcHJldiAoJmRlc3RfZ3NpKTsKKyAgICB9CisKKyAgLyogVXBkYXRlIGFsbCB0aGUgc3RtdHMg d2l0aCB0aGVpciBuZXcgcmVhY2hpbmcgVlVTRVMuICAqLworICB0cmVlIHZ1c2UKKyAgICA9IGdp bXBsZV92dXNlIChMT09QX1ZJTkZPX0VBUkxZX0JSS19DT05GTElDVF9TVE1UUyAobG9vcF92aW5m bykubGFzdCAoKSk7CisgIGZvciAoYXV0byBwIDogTE9PUF9WSU5GT19FQVJMWV9CUktfVlVTRVMg KGxvb3BfdmluZm8pKQorICAgIHsKKyAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkgIGR1 bXBfcHJpbnRmX2xvYyAoTVNHX05PVEUsIHZlY3RfbG9jYXRpb24sCisJCQkgICAidXBkYXRpbmcg dnVzZSB0byAlVCBmb3IgbG9hZCAlRyIsIHZ1c2UsIHApOworICAgICAgZ2ltcGxlX3NldF92dXNl IChwLCB2dXNlKTsKKyAgICAgIHVwZGF0ZV9zdG10IChwKTsKKyAgICB9Cit9CisKIC8qIEZ1bmN0 aW9uIHZlY3RfdHJhbnNmb3JtX2xvb3AuCiAKICAgIFRoZSBhbmFseXNpcyBwaGFzZSBoYXMgZGV0 ZXJtaW5lZCB0aGF0IHRoZSBsb29wIGlzIHZlY3Rvcml6YWJsZS4KQEAgLTExNjk3LDYgKzExNzQ4 LDExIEBAIHZlY3RfdHJhbnNmb3JtX2xvb3AgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywgZ2lt cGxlICpsb29wX3ZlY3Rvcml6ZWRfY2FsbCkKICAgICAgIHZlY3Rfc2NoZWR1bGVfc2xwIChsb29w X3ZpbmZvLCBMT09QX1ZJTkZPX1NMUF9JTlNUQU5DRVMgKGxvb3BfdmluZm8pKTsKICAgICB9CiAK KyAgLyogSGFuZGxlIGFueSBjb2RlIG1vdGlvbiB0aGF0IHdlIG5lZWQgdG8gZm9yIGVhcmx5LWJy ZWFrIHZlY3Rvcml6YXRpb24gYWZ0ZXIKKyAgICAgd2UndmUgZG9uZSBwZWVsaW5nIGJ1dCBqdXN0 IGJlZm9yZSB3ZSBzdGFydCB2ZWN0b3JpemluZy4gICovCisgIGlmIChMT09QX1ZJTkZPX0VBUkxZ X0JSRUFLUyAobG9vcF92aW5mbykpCisgICAgbW92ZV9lYXJseV9leGl0X3N0bXRzIChsb29wX3Zp bmZvKTsKKwogICAvKiBGT1JOT1c6IHRoZSB2ZWN0b3JpemVyIHN1cHBvcnRzIG9ubHkgbG9vcHMg d2hpY2ggYm9keSBjb25zaXN0CiAgICAgIG9mIG9uZSBiYXNpYyBibG9jayAoaGVhZGVyICsgZW1w dHkgbGF0Y2gpLiBXaGVuIHRoZSB2ZWN0b3JpemVyIHdpbGwKICAgICAgc3VwcG9ydCBtb3JlIGlu dm9sdmVkIGxvb3AgZm9ybXMsIHRoZSBvcmRlciBieSB3aGljaCB0aGUgQkJzIGFyZQpkaWZmIC0t Z2l0IGEvZ2NjL3RyZWUtdmVjdC1zdG10cy5jYyBiL2djYy90cmVlLXZlY3Qtc3RtdHMuY2MKaW5k ZXggOTZlNGE2Y2ZmYWRlYmI0Mzk0NmM1Y2I3ZTk4NDljOTE1ZGE1ODliYy4uYjNhMDljMGE4MDRh MzhlMTdlZjMyYjZjZTEzYjk4YjA3NzQ1OWZjNyAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtdmVjdC1z dG10cy5jYworKysgYi9nY2MvdHJlZS12ZWN0LXN0bXRzLmNjCkBAIC0zNTksOCArMzU5LDggQEAg dmVjdF9zdG10X3JlbGV2YW50X3AgKHN0bXRfdmVjX2luZm8gc3RtdF9pbmZvLCBsb29wX3ZlY19p bmZvIGxvb3BfdmluZm8sCiAgICpsaXZlX3AgPSBmYWxzZTsKIAogICAvKiBjb25kIHN0bXQgb3Ro ZXIgdGhhbiBsb29wIGV4aXQgY29uZC4gICovCi0gIGlmIChpc19jdHJsX3N0bXQgKHN0bXRfaW5m by0+c3RtdCkKLSAgICAgICYmIFNUTVRfVklORk9fVFlQRSAoc3RtdF9pbmZvKSAhPSBsb29wX2V4 aXRfY3RybF92ZWNfaW5mb190eXBlKQorICBnaW1wbGUgKnN0bXQgPSBTVE1UX1ZJTkZPX1NUTVQg KHN0bXRfaW5mbyk7CisgIGlmIChkeW5fY2FzdCA8Z2NvbmQgKj4gKHN0bXQpKQogICAgICpyZWxl dmFudCA9IHZlY3RfdXNlZF9pbl9zY29wZTsKIAogICAvKiBjaGFuZ2luZyBtZW1vcnkuICAqLwpA QCAtMTM1MzAsNiArMTM1MzAsOSBAQCB2ZWN0X2lzX3NpbXBsZV91c2UgKHRyZWUgb3BlcmFuZCwg dmVjX2luZm8gKnZpbmZvLCBlbnVtIHZlY3RfZGVmX3R5cGUgKmR0LAogCWNhc2UgdmVjdF9maXJz dF9vcmRlcl9yZWN1cnJlbmNlOgogCSAgZHVtcF9wcmludGYgKE1TR19OT1RFLCAiZmlyc3Qgb3Jk ZXIgcmVjdXJyZW5jZVxuIik7CiAJICBicmVhazsKKwljYXNlIHZlY3RfY29uZGl0aW9uX2RlZjoK KwkgIGR1bXBfcHJpbnRmIChNU0dfTk9URSwgImNvbnRyb2wgZmxvd1xuIik7CisJICBicmVhazsK IAljYXNlIHZlY3RfdW5rbm93bl9kZWZfdHlwZToKIAkgIGR1bXBfcHJpbnRmIChNU0dfTk9URSwg InVua25vd25cbiIpOwogCSAgYnJlYWs7CmRpZmYgLS1naXQgYS9nY2MvdHJlZS12ZWN0b3JpemVy LmggYi9nY2MvdHJlZS12ZWN0b3JpemVyLmgKaW5kZXggZTRkN2FiNDU2N2NlZjNjMDE4Yjk1OGY5 OGVlZmYwNDVkMzQ3NzcyNS4uM2M5NDc4YTNkYzg3NTBjNzFlMGJmMmEzNmE1YjA4MTVhZmMzZmQ5 NCAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtdmVjdG9yaXplci5oCisrKyBiL2djYy90cmVlLXZlY3Rv cml6ZXIuaApAQCAtNjYsNiArNjYsNyBAQCBlbnVtIHZlY3RfZGVmX3R5cGUgewogICB2ZWN0X2Rv dWJsZV9yZWR1Y3Rpb25fZGVmLAogICB2ZWN0X25lc3RlZF9jeWNsZSwKICAgdmVjdF9maXJzdF9v cmRlcl9yZWN1cnJlbmNlLAorICB2ZWN0X2NvbmRpdGlvbl9kZWYsCiAgIHZlY3RfdW5rbm93bl9k ZWZfdHlwZQogfTsKIApAQCAtODg4LDYgKzg4OSwxMCBAQCBwdWJsaWM6CiAgICAgIHdlIG5lZWQg dG8gcGVlbCBvZmYgaXRlcmF0aW9ucyBhdCB0aGUgZW5kIHRvIGZvcm0gYW4gZXBpbG9ndWUgbG9v cC4gICovCiAgIGJvb2wgcGVlbGluZ19mb3Jfbml0ZXI7CiAKKyAgLyogV2hlbiB0aGUgbG9vcCBo YXMgZWFybHkgYnJlYWtzIHRoYXQgd2UgY2FuIHZlY3Rvcml6ZSB3ZSBuZWVkIHRvIHBlZWwKKyAg ICAgdGhlIGxvb3AgZm9yIHRoZSBicmVhayBmaW5kaW5nIGxvb3AuICAqLworICBib29sIGVhcmx5 X2JyZWFrczsKKwogICAvKiBMaXN0IG9mIGxvb3AgYWRkaXRpb25hbCBJViBjb25kaXRpb25hbHMg Zm91bmQgaW4gdGhlIGxvb3AuICAqLwogICBhdXRvX3ZlYzxnY29uZCAqPiBjb25kczsKIApAQCAt OTQyLDYgKzk0NywyMCBAQCBwdWJsaWM6CiAgIC8qIFRoZSBjb250cm9sbGluZyBsb29wIElWIGZv ciB0aGUgc2NhbGFyIGxvb3AgYmVpbmcgdmVjdG9yaXplZC4gIFRoaXMgSVYKICAgICAgY29udHJv bHMgdGhlIG5hdHVyYWwgZXhpdHMgb2YgdGhlIGxvb3AuICAqLwogICBlZGdlIHNjYWxhcl9sb29w X2l2X2V4aXQ7CisKKyAgLyogVXNlZCB0byBzdG9yZSB0aGUgbGlzdCBvZiBzdGF0ZW1lbnRzIG5l ZWRpbmcgdG8gYmUgbW92ZWQgaWYgZG9pbmcgZWFybHkKKyAgICAgYnJlYWsgdmVjdG9yaXphdGlv biBhcyB0aGV5IHdvdWxkIHZpb2xhdGUgdGhlIHNjYWxhciBsb29wIHNlbWFudGljcyBpZgorICAg ICB2ZWN0b3JpemVkIGluIHRoZWlyIGN1cnJlbnQgbG9jYXRpb24uICBUaGVzZSBhcmUgc3RvcmVk IGluIG9yZGVyIHRoYXQgdGhleSBuZWVkCisgICAgIHRvIGJlIG1vdmVkLiAgKi8KKyAgYXV0b192 ZWM8Z2ltcGxlICo+IGVhcmx5X2JyZWFrX2NvbmZsaWN0OworCisgIC8qIFRoZSBmaW5hbCBiYXNp YyBibG9jayB3aGVyZSB0byBtb3ZlIHN0YXRlbWVudHMgdG8uICBJbiB0aGUgY2FzZSBvZgorICAg ICBtdWx0aXBsZSBleGl0cyB0aGlzIGNvdWxkIGJlIHByZXR0eSBmYXIgYXdheS4gICovCisgIGJh c2ljX2Jsb2NrIGVhcmx5X2JyZWFrX2Rlc3RfYmI7CisKKyAgLyogU3RhdGVtZW50cyB3aG9zZSBW VVNFUyBuZWVkIHVwZGF0aW5nIGlmIGVhcmx5IGJyZWFrIHZlY3Rvcml6YXRpb24gaXMgdG8KKyAg ICAgaGFwcGVuLiAgKi8KKyAgYXV0b192ZWM8Z2ltcGxlKj4gZWFybHlfYnJlYWtfdnVzZXM7CiB9 ICpsb29wX3ZlY19pbmZvOwogCiAvKiBBY2Nlc3MgRnVuY3Rpb25zLiAgKi8KQEAgLTk5Niw2ICsx MDE1LDEwIEBAIHB1YmxpYzoKICNkZWZpbmUgTE9PUF9WSU5GT19SRURVQ1RJT05fQ0hBSU5TKEwp ICAgICAoTCktPnJlZHVjdGlvbl9jaGFpbnMKICNkZWZpbmUgTE9PUF9WSU5GT19QRUVMSU5HX0ZP Ul9HQVBTKEwpICAgICAoTCktPnBlZWxpbmdfZm9yX2dhcHMKICNkZWZpbmUgTE9PUF9WSU5GT19Q RUVMSU5HX0ZPUl9OSVRFUihMKSAgICAoTCktPnBlZWxpbmdfZm9yX25pdGVyCisjZGVmaW5lIExP T1BfVklORk9fRUFSTFlfQlJFQUtTKEwpICAgICAgICAgKEwpLT5lYXJseV9icmVha3MKKyNkZWZp bmUgTE9PUF9WSU5GT19FQVJMWV9CUktfQ09ORkxJQ1RfU1RNVFMoTCkgKEwpLT5lYXJseV9icmVh a19jb25mbGljdAorI2RlZmluZSBMT09QX1ZJTkZPX0VBUkxZX0JSS19ERVNUX0JCKEwpICAgIChM KS0+ZWFybHlfYnJlYWtfZGVzdF9iYgorI2RlZmluZSBMT09QX1ZJTkZPX0VBUkxZX0JSS19WVVNF UyhMKSAgICAgIChMKS0+ZWFybHlfYnJlYWtfdnVzZXMKICNkZWZpbmUgTE9PUF9WSU5GT19MT09Q X0NPTkRTKEwpICAgICAgICAgICAoTCktPmNvbmRzCiAjZGVmaW5lIExPT1BfVklORk9fTE9PUF9J Vl9DT05EKEwpICAgICAgICAgKEwpLT5sb29wX2l2X2NvbmQKICNkZWZpbmUgTE9PUF9WSU5GT19O T19EQVRBX0RFUEVOREVOQ0lFUyhMKSAoTCktPm5vX2RhdGFfZGVwZW5kZW5jaWVzCg== --_002_VI1PR08MB5325CBD43268E3BC25649BDDFF97AVI1PR08MB5325eurp_--