From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR05-AM6-obe.outbound.protection.outlook.com (mail-am6eur05on2040.outbound.protection.outlook.com [40.107.22.40]) by sourceware.org (Postfix) with ESMTPS id 769F43858CDA for ; Mon, 11 Dec 2023 23:12:27 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 769F43858CDA 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 769F43858CDA Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=40.107.22.40 ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1702336350; cv=pass; b=fSg3wT52kEXteOr0Id7dUMzfzhTOUZNWcpFpNqljFIgQn2jhGbsQ/Pwnaz2C+a4WSR7OApNLLPDVJiT+2TV6StwuV9OGNv+J8TSeo3oNbhWJKmohWSrPYxsrW19TcYzKG4C/aFTLtkTE15N6Mzz+BLm6O7xwzht9dID9/TJHsmk= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1702336350; c=relaxed/simple; bh=S+gFoss6GpJ7VgvXTdL1xl/OmQLdR92hX8W1ctA5jV4=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=kJPavXro0ODLdeqZJ5wFQh3EaIGYyupP4lWk+49wPvqTM57U/CDXxeOjnm4tuwwN+9urG/+8FOGpXgDzY3UEJ13XztuV/K/b7B6un2zaQiaL1tCIiCaMLImHGIyeycChANja0rriYsuIABzzxymI+nKX9CspHwte3ua8/QG1nwU= ARC-Authentication-Results: i=3; server2.sourceware.org ARC-Seal: i=2; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=pass; b=OBBZxITbu9abDMw4R+9o7Jh2HA+vSIxRL5pLh643uUjJa95PC1vESOQPZDSZ+Uzu2YKXmUd5sh1jtdIvSNTtIppgA9hmZ61nQ2LUqvAnRExgNHGBfQ/aQRwq2efY1gT5oLqv6SJKFK3Jx/9BIILp0KMnmzLGF3Ipb62MopGEaO5oi85xcNS4SIrHopJLHgWKEdEqoyeriv+MOHVpe9cDUIVXUbNeK85BgEtvLXQAJ+UsjA8L6l720YC0+VCOhqW/MxAsfs8C4TLz5hiG2iYMYL+XJYyhoF3r1yktPtjIxobM+tbdFUewS5cdwRF0bXjzAE6Jfwf4I+Xa5orEcswFGA== 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=2tDcQdeCMETcSoVnjmHh8tv+dMbayiIkJ4i/6bLP6cQ=; b=iNyzT1fyr399g0boxEWHl74fdds5/J4HWAKEz1rP53FTv2fuvra6UQrlLvAccpeEFg3gQWINQCSDKbvo59N3AcJ3GXMUFkzMYZ2bNV406gerN3cTbOGUczFvsk6f/oMr6y0EayVyZ8QLP5SQYTbNbv4MhYWzf8OwBIFigBuCTQqHC8VvDmYzUfBu9L6+z4id+88d5zIzgEv/dkZsrOWhR6L7r8zPkqWN4JUMFtKsaCqy/Z9qL9x84YM6Iq709j2ZSzA8/ibBgjt6Iyqa06SxPc3ZFq5fczV6N382A2EC1wD2u0sOKuq3jegt/fNnr6SyuBrwhypJ6t9gMlktf7ehNw== 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=2tDcQdeCMETcSoVnjmHh8tv+dMbayiIkJ4i/6bLP6cQ=; b=U8JVgNDRWHdAM1S73DcpaR90+UQ0GEmtrxL5RyGCFyABGVwVEl3JZ8lP2Y8gpnv46EYDyPt4fuGylizOx/9xJ3z+eZFFOao5Tsro+Db/3VRSNwsugCkihd0ivkCgGoddOP+qxCShEKgA9zzXOcawxf6ZKLMv+UoakVlz02VE134= Received: from DUZPR01CA0294.eurprd01.prod.exchangelabs.com (2603:10a6:10:4b7::13) by DB9PR08MB6700.eurprd08.prod.outlook.com (2603:10a6:10:2a3::9) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7068.33; Mon, 11 Dec 2023 23:12:24 +0000 Received: from DU6PEPF0000A7DD.eurprd02.prod.outlook.com (2603:10a6:10:4b7:cafe::e3) by DUZPR01CA0294.outlook.office365.com (2603:10a6:10:4b7::13) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7068.32 via Frontend Transport; Mon, 11 Dec 2023 23:12:24 +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 DU6PEPF0000A7DD.mail.protection.outlook.com (10.167.8.37) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7091.18 via Frontend Transport; Mon, 11 Dec 2023 23:12:23 +0000 Received: ("Tessian outbound 26ee1d40577c:v228"); Mon, 11 Dec 2023 23:12:23 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: 3281fde08ad221c1 X-CR-MTA-TID: 64aa7808 Received: from da92676ee831.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id 8867B55F-2452-4875-A57D-E87DBDA28402.1; Mon, 11 Dec 2023 23:12:16 +0000 Received: from EUR04-VI1-obe.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id da92676ee831.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Mon, 11 Dec 2023 23:12:16 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=AqoNLiympZJKyfBriVdHzZ7WFL1YEGBBRtLLV1zj/iIM0QADps2s7+gBi5/l3yfcd0PjJDAvb4kDlZCpwYKfxgcE/Qz4pbArCnRr8EHhiT7u0jGJB/KFhPnb1InkagmA9EvUzr44kmCsJvyJSIsnytKZGAePpCElCpgWzQXl00mdiXi6LLIG/kVLth2/NIaTh4zMFjHwQHehhEJ9vq5H2Ji2mvfVPsmJypJCZJNqd2c565dD87i7fXSdS1ErO+z/1r4LkzDBWR9bTk8mSMv1aqOUtaLvDoR++2CSQTf91zbLXzCrJHaXzNHv8p6F4fN8SgctM9pqlGEGo7c1f9lWgQ== 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=2tDcQdeCMETcSoVnjmHh8tv+dMbayiIkJ4i/6bLP6cQ=; b=gp4l+bTjMfPbE/0Ot60xTZ+1pcO6BwS6WNOAV31GgbbfBJ0eHtHgnKayXJAxEdx/VVRybWJL1WvKp2EmubLy70zIfIqlVlkNEMxrpYIRUQNEzmaPkn+yQb+7hSisr7ksxaliGek+gPbatu4Hy+SAgyYL5MVk7ePCRo4fQxkorM0QbWN9MqHflxjArsGhCRlHHx724YB1jxCiZe/yGHRHXYC33X689AxuT3OBzPylL1wXpYuYF8Li0XysDZ14EHtDyJRyBp080QQangdIHRIEQR33CBkrDFvYfSeVB9dB3wtxIB4Cldf5Kt53AXdlj9scpth9mJuMKF9yIbNPA1V0MQ== 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=2tDcQdeCMETcSoVnjmHh8tv+dMbayiIkJ4i/6bLP6cQ=; b=U8JVgNDRWHdAM1S73DcpaR90+UQ0GEmtrxL5RyGCFyABGVwVEl3JZ8lP2Y8gpnv46EYDyPt4fuGylizOx/9xJ3z+eZFFOao5Tsro+Db/3VRSNwsugCkihd0ivkCgGoddOP+qxCShEKgA9zzXOcawxf6ZKLMv+UoakVlz02VE134= Received: from VI1PR08MB5325.eurprd08.prod.outlook.com (2603:10a6:803:13e::17) by AS2PR08MB10252.eurprd08.prod.outlook.com (2603:10a6:20b:648::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7068.32; Mon, 11 Dec 2023 23:12:13 +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.7068.031; Mon, 11 Dec 2023 23:12:13 +0000 From: Tamar Christina To: Richard Biener CC: "gcc-patches@gcc.gnu.org" , nd , "jlaw@ventanamicro.com" Subject: RE: [PATCH 9/21]middle-end: implement vectorizable_early_exit for codegen of exit code Thread-Topic: [PATCH 9/21]middle-end: implement vectorizable_early_exit for codegen of exit code Thread-Index: AQHaEIRpInfkk2iMNkKe/ayk/lXCPbCO5tuwgAKOHoCACmF78IAAWBaAgAMYIGCAABrAgIAAAmcwgAA4uQCABEHGgIAAK7mAgADdJdA= Date: Mon, 11 Dec 2023 23:12:13 +0000 Message-ID: References: <85570n66-1540-0r07-7q80-269p3o133585@fhfr.qr> <5r3p7378-q309-ooqo-7o76-q9r567ns1890@fhfr.qr> In-Reply-To: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: yes X-MS-TNEF-Correlator: Authentication-Results-Original: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=arm.com; x-ms-traffictypediagnostic: VI1PR08MB5325:EE_|AS2PR08MB10252:EE_|DU6PEPF0000A7DD:EE_|DB9PR08MB6700:EE_ X-MS-Office365-Filtering-Correlation-Id: db3099a7-10d5-4b4d-3739-08dbfa9ea25d 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: 2iSTIvQXzhb79qS2L4zWxJV39QaKwN3F1B3BnLFmVmcyUkheF2yavWt2Hbma9IhlrOHT5T+TIj4opXf7yLjaZqtelx1zc7DRMsrC9fi11O917eDCRwOwKgXQZJEONy5gr6o6sdC55QrJZf6Pcc7G6IPsXYbgWuy0Cf8vnjItk3ZMFWyFyYskbhO5QdipLbyxkIw0ILeGyKD6KeDpYkIWZGkS2tifN6PvN3W0J5XJNwfYkil+TP/p39lvnFMGfroPaHz+pvprcN8Rkv7xk15nOeBY2amd+JqKPLr9vUHvnKPseZeVryEH1+cNEK0g+gFZ1Ynxgqtl4gVxIzDQ8ynhRrzg+LYrh0s1xoapzZm6cydBxBqQf/qQnNBLXi8bcMtt+ZAUR2WP47C8m9bl570ourPtYmddT/N+FMcULAgKkAvCNpRiugRQWgwd/kDpDu/Us36ZGPYt1sa+0IJ4LxuWkmdNvHXiOnq1Z2w3eb68XiFBPDOWzDBxiD218QkA4dzrsmPpdGW7sl0GAiREBnSBcwBLzIhfLM4xg9v3VT1FlmYhZSDXmW7gtF0F8/ncFFhxPNG3AfNge6eR+cFD4+YCdr0S7nPCFlmu7O4foF5H8Ow= 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)(396003)(136003)(376002)(346002)(39860400002)(366004)(230922051799003)(451199024)(1800799012)(186009)(64100799003)(83380400001)(2906002)(86362001)(478600001)(41300700001)(99936003)(38070700009)(76116006)(54906003)(6916009)(66556008)(66476007)(66946007)(64756008)(30864003)(66446008)(84970400001)(71200400001)(122000001)(316002)(38100700002)(8676002)(7696005)(8936002)(4326008)(6506007)(9686003)(52536014)(55016003)(33656002)(5660300002)(26005)(579004);DIR:OUT;SFP:1101; Content-Type: multipart/mixed; boundary="_002_VI1PR08MB5325931CD930AEBBA5D27C7DFF8FAVI1PR08MB5325eurp_" MIME-Version: 1.0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS2PR08MB10252 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: DU6PEPF0000A7DD.eurprd02.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: f1dbf51d-affd-4441-14fe-08dbfa9e9c23 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Kji9Q2tcFgX4IrNNmDBozaK5gYX6+joYeqp57VNPwnPI3BWjbmdLLtlybaLPVPy0f6tH5OOSi/ukbuACsrZBhRwh4QOFSSYxIeZsaYrHlvfizfYXzGWvI2RQDEOtemGoLI7QqWSOYeIZ1a7v4OXnG9kTa4910MBZ9g7/rprvcMyXF0NGn4Q97Bnp9eNOhhfdTOkJ1WqgdFhke5wF3EW0RkZ8BtZ3Dwuf3w6L8skKRTqqLntGm+SY7JgpAzI5IuQ6//MvHx7XM9bXlS/zJGKv1YpS7GKv1KsDOTQTxW9uXfqiFJsDtWSQ0wmNmvl6Bb6u9sbyrEer35cDsbAxAEtmGqHmM3/jw/0lPAgZfeAf16NWUquGUb3JbktRXOhR0IvS5GJolX8rMCL+cEBeZOIfJvUtu8HisGJkdHEEeV7+nPiG7i3z+ZaCSj84OU+lmKBRdp5p7lfirTeC/IUr5qj7gXENapLV1V6u19+k5UN1UaFMQo0iIhuiMR0TPHaLB9j48+34C59f07BP4EGrX+PBzSqJxpeY/vozZvkmNcn1y92i6tRmtL9AkUaIAbpVs3rVtg6g9VqyZB1FgmOjvUmNcl3sT1zG/1sa+M74jkwiHu+scgNo+CLhKzCLY/+RhvnWoGbHBOQ7Ngcq1OXSrT0lPp4nr58Fmu0jJXlPwpbGWai38NjJnMPa6v/SeIyJhHSsXOmMTDwn0WmgZDRVomOqiLbFYoYS6le4SWlHeTmL/tQ= X-Forefront-Antispam-Report: CIP:63.35.35.123;CTRY:IE;LANG:en;SCL:1;SRV:;IPV:CAL;SFV:NSPM;H:64aa7808-outbound-1.mta.getcheckrecipient.com;PTR:ec2-63-35-35-123.eu-west-1.compute.amazonaws.com;CAT:NONE;SFS:(13230031)(4636009)(346002)(136003)(396003)(376002)(39860400002)(230922051799003)(451199024)(1800799012)(186009)(64100799003)(82310400011)(46966006)(36840700001)(40470700004)(40460700003)(26005)(107886003)(336012)(7696005)(6506007)(9686003)(36860700001)(83380400001)(47076005)(5660300002)(235185007)(52536014)(4326008)(41300700001)(6862004)(30864003)(2906002)(8676002)(478600001)(8936002)(70586007)(70206006)(316002)(54906003)(33656002)(356005)(81166007)(86362001)(99936003)(82740400003)(55016003)(40480700001)(84970400001);DIR:OUT;SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 11 Dec 2023 23:12:23.8695 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: db3099a7-10d5-4b4d-3739-08dbfa9ea25d 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: DU6PEPF0000A7DD.eurprd02.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB9PR08MB6700 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_VI1PR08MB5325931CD930AEBBA5D27C7DFF8FAVI1PR08MB5325eurp_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable > > + vectype =3D truth_type_for (comp_type); >=20 > so this leaves the producer of the mask in the GIMPLE_COND and we > vectorize the GIMPLE_COND as >=20 > mask_1 =3D ...; > if (mask_1 !=3D {-1,-1...}) > .. >=20 > ? In principle only the mask producer needs a vector type and that > adjusted by bool handling, the branch itself doesn't need any > STMT_VINFO_VECTYPE. >=20 > As said I believe if you recognize a GIMPLE_COND pattern for conds > that aren't bool !=3D 0 producing the mask stmt this should be picked > up by bool handling correctly already. >=20 > Also as said piggy-backing on the COND_EXPR handling in this function > which has the condition split out into a separate stmt(!) might not > completely handle things correctly and you are likely missing > the tcc_comparison handling of the embedded compare. >=20 Ok, I've stopped piggy-backing on the COND_EXPR handling and created vect_recog_gcond_pattern. As you said in the previous email I've also stopped setting the vectype for the gcond and instead use the type of the operand. Note that because the pattern doesn't apply if you were already an NE_EXPR I do need the extra truth_type_for for that case. Because in the case of e= .g. a =3D b > 4; If (a !=3D 0) The producer of the mask is already outside of the cond but will not trigge= r Boolean recognition. That means that while the integral type is correct it Won't be a Boolean one and vectorable_comparison expects a Boolean vector. Alternatively, we can remove that assert? But that seems worse. Additionally in the previous email you mention "adjusted Boolean statement"= . I'm guessing you were referring to generating a COND_EXPR from the gcond. So vect_recog_bool_pattern detects it? The problem with that this gets fol= ded to x & 1 and doesn't trigger. It also then blocks vectorization. So inste= ad I've not forced it. > > + /* Determine if we need to reduce the final value. */ > > + if (stmts.length () > 1) > > + { > > + /* We build the reductions in a way to maintain as much parallel= ism as > > + possible. */ > > + auto_vec workset (stmts.length ()); > > + > > + /* Mask the statements as we queue them up. */ > > + if (masked_loop_p) > > + for (auto stmt : stmts) > > + workset.quick_push (prepare_vec_mask (loop_vinfo, TREE_TYPE (mask), > > + mask, stmt, &cond_gsi)); > > + else > > + workset.splice (stmts); > > + > > + while (workset.length () > 1) > > + { > > + new_temp =3D make_temp_ssa_name (vectype, NULL, "vexit_reduc"); > > + tree arg0 =3D workset.pop (); > > + tree arg1 =3D workset.pop (); > > + new_stmt =3D gimple_build_assign (new_temp, BIT_IOR_EXPR, arg0, arg= 1); > > + vect_finish_stmt_generation (loop_vinfo, stmt_info, new_stmt, > > + &cond_gsi); > > + workset.quick_insert (0, new_temp); > > + } > > + } > > + else > > + new_temp =3D stmts[0]; > > + > > + gcc_assert (new_temp); > > + > > + tree cond =3D new_temp; > > + /* If we have multiple statements after reduction we should check al= l the > > + lanes and treat it as a full vector. */ > > + if (masked_loop_p) > > + cond =3D prepare_vec_mask (loop_vinfo, TREE_TYPE (mask), mask, con= d, > > + &cond_gsi); >=20 > You didn't fix any of the code above it seems, it's still wrong. >=20 Apologies, I hadn't realized that the last argument to get_loop_mask was th= e index. Should be fixed now. Is this closer to what you wanted? The individual ops are now masked with separate masks. (See testcase when N= =3D865). Ok for master? Thanks, Tamar gcc/ChangeLog: * tree-vect-patterns.cc (vect_init_pattern_stmt): Support gconds. (vect_recog_gcond_pattern): New. (vect_vect_recog_func_ptrs): Use it. * tree-vect-stmts.cc (vectorizable_comparison_1): Support stmts without lhs. (vectorizable_early_exit): New. (vect_analyze_stmt, vect_transform_stmt): Use it. (vect_is_simple_use, vect_get_vector_types_for_stmt): Support gcond. gcc/testsuite/ChangeLog: * gcc.dg/vect/vect-early-break_88.c: New test. --- inline copy of patch --- diff --git a/gcc/testsuite/gcc.dg/vect/vect-early-break_88.c b/gcc/testsuit= e/gcc.dg/vect/vect-early-break_88.c new file mode 100644 index 0000000000000000000000000000000000000000..b64becd588973f58601196bfcb1= 5afbe4bab60f2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-early-break_88.c @@ -0,0 +1,36 @@ +/* { dg-require-effective-target vect_early_break } */ +/* { dg-require-effective-target vect_int } */ + +/* { dg-additional-options "-Ofast --param vect-partial-vector-usage=3D2" = } */ +/* { dg-final { scan-tree-dump "LOOP VECTORIZED" "vect" } } */ + +#ifndef N +#define N 5 +#endif +float vect_a[N] =3D { 5.1f, 4.2f, 8.0f, 4.25f, 6.5f }; +unsigned vect_b[N] =3D { 0 }; + +__attribute__ ((noinline, noipa)) +unsigned test4(double x) +{ + unsigned ret =3D 0; + for (int i =3D 0; i < N; i++) + { + if (vect_a[i] > x) + break; + vect_a[i] =3D x; + =20 + } + return ret; +} + +extern void abort (); + +int main () +{ + if (test4 (7.0) !=3D 0) + abort (); + + if (vect_b[2] !=3D 0 && vect_b[1] =3D=3D 0) + abort (); +} diff --git a/gcc/tree-vect-patterns.cc b/gcc/tree-vect-patterns.cc index 7debe7f0731673cd1bf25cd39d55e23990a73d0e..359d30b5991a50717c269df577c= 08adffa44e71b 100644 --- a/gcc/tree-vect-patterns.cc +++ b/gcc/tree-vect-patterns.cc @@ -132,6 +132,7 @@ vect_init_pattern_stmt (vec_info *vinfo, gimple *patter= n_stmt, if (!STMT_VINFO_VECTYPE (pattern_stmt_info)) { gcc_assert (!vectype + || is_a (pattern_stmt) || (VECTOR_BOOLEAN_TYPE_P (vectype) =3D=3D vect_use_mask_type_p (orig_stmt_info))); STMT_VINFO_VECTYPE (pattern_stmt_info) =3D vectype; @@ -5553,6 +5554,83 @@ integer_type_for_mask (tree var, vec_info *vinfo) return build_nonstandard_integer_type (def_stmt_info->mask_precision, 1)= ; } =20 +/* Function vect_recog_gcond_pattern + + Try to find pattern like following: + + if (a op b) + + where operator 'op' is not !=3D and convert it to an adjusted boolean p= attern + + mask =3D a op b + if (mask !=3D 0) + + and set the mask type on MASK. + + Input: + + * STMT_VINFO: The stmt at the end from which the pattern + search begins, i.e. cast of a bool to + an integer type. + + Output: + + * TYPE_OUT: The type of the output of this pattern. + + * Return value: A new stmt that will be used to replace the pattern. *= / + +static gimple * +vect_recog_gcond_pattern (vec_info *vinfo, + stmt_vec_info stmt_vinfo, tree *type_out) +{ + gimple *last_stmt =3D STMT_VINFO_STMT (stmt_vinfo); + gcond* cond =3D NULL; + if (!(cond =3D dyn_cast (last_stmt))) + return NULL; + + auto lhs =3D gimple_cond_lhs (cond); + auto rhs =3D gimple_cond_rhs (cond); + auto code =3D gimple_cond_code (cond); + + tree scalar_type =3D TREE_TYPE (lhs); + if (VECTOR_TYPE_P (scalar_type)) + return NULL; + + if (code =3D=3D NE_EXPR && zerop (rhs)) + return NULL; + + tree vecitype =3D get_vectype_for_scalar_type (vinfo, scalar_type); + if (vecitype =3D=3D NULL_TREE) + return NULL; + + /* Build a scalar type for the boolean result that when vectorized match= es the + vector type of the result in size and number of elements. */ + unsigned prec + =3D vector_element_size (tree_to_poly_uint64 (TYPE_SIZE (vecitype)), + TYPE_VECTOR_SUBPARTS (vecitype)); + + scalar_type + =3D build_nonstandard_integer_type (prec, TYPE_UNSIGNED (scalar_type))= ; + + vecitype =3D get_vectype_for_scalar_type (vinfo, scalar_type); + if (vecitype =3D=3D NULL_TREE) + return NULL; + + tree vectype =3D truth_type_for (vecitype); + + tree new_lhs =3D vect_recog_temp_ssa_var (boolean_type_node, NULL); + gimple *new_stmt =3D gimple_build_assign (new_lhs, code, lhs, rhs); + append_pattern_def_seq (vinfo, stmt_vinfo, new_stmt, vectype, scalar_typ= e); + + gimple *pattern_stmt + =3D gimple_build_cond (NE_EXPR, new_lhs, + build_int_cst (TREE_TYPE (new_lhs), 0), + NULL_TREE, NULL_TREE); + *type_out =3D vectype; + vect_pattern_detected ("vect_recog_gcond_pattern", last_stmt); + return pattern_stmt; +} + /* Function vect_recog_bool_pattern =20 Try to find pattern like following: @@ -6860,6 +6938,7 @@ static vect_recog_func vect_vect_recog_func_ptrs[] = =3D { { vect_recog_divmod_pattern, "divmod" }, { vect_recog_mult_pattern, "mult" }, { vect_recog_mixed_size_cond_pattern, "mixed_size_cond" }, + { vect_recog_gcond_pattern, "gcond" }, { vect_recog_bool_pattern, "bool" }, /* This must come before mask conversion, and includes the parts of mask conversion that are needed for gather and scatter diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index 582c5e678fad802d6e76300fe3c939b9f2978f17..7c50ee37f2ade24eccf7a7d1ea2= e00b4450023f9 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -12489,7 +12489,7 @@ vectorizable_comparison_1 (vec_info *vinfo, tree ve= ctype, vec vec_oprnds0 =3D vNULL; vec vec_oprnds1 =3D vNULL; tree mask_type; - tree mask; + tree mask =3D NULL_TREE; =20 if (!STMT_VINFO_RELEVANT_P (stmt_info) && !bb_vinfo) return false; @@ -12629,8 +12629,9 @@ vectorizable_comparison_1 (vec_info *vinfo, tree ve= ctype, /* Transform. */ =20 /* Handle def. */ - lhs =3D gimple_assign_lhs (STMT_VINFO_STMT (stmt_info)); - mask =3D vect_create_destination_var (lhs, mask_type); + lhs =3D gimple_get_lhs (STMT_VINFO_STMT (stmt_info)); + if (lhs) + mask =3D vect_create_destination_var (lhs, mask_type); =20 vect_get_vec_defs (vinfo, stmt_info, slp_node, ncopies, rhs1, &vec_oprnds0, vectype, @@ -12644,7 +12645,10 @@ vectorizable_comparison_1 (vec_info *vinfo, tree v= ectype, gimple *new_stmt; vec_rhs2 =3D vec_oprnds1[i]; =20 - new_temp =3D make_ssa_name (mask); + if (lhs) + new_temp =3D make_ssa_name (mask); + else + new_temp =3D make_temp_ssa_name (mask_type, NULL, "cmp"); if (bitop1 =3D=3D NOP_EXPR) { new_stmt =3D gimple_build_assign (new_temp, code, @@ -12723,6 +12727,211 @@ vectorizable_comparison (vec_info *vinfo, return true; } =20 +/* Check to see if the current early break given in STMT_INFO is valid for + vectorization. */ + +static bool +vectorizable_early_exit (vec_info *vinfo, stmt_vec_info stmt_info, + gimple_stmt_iterator *gsi, gimple **vec_stmt, + slp_tree slp_node, stmt_vector_for_cost *cost_vec) +{ + loop_vec_info loop_vinfo =3D dyn_cast (vinfo); + if (!loop_vinfo + || !is_a (STMT_VINFO_STMT (stmt_info))) + return false; + + if (STMT_VINFO_DEF_TYPE (stmt_info) !=3D vect_condition_def) + return false; + + if (!STMT_VINFO_RELEVANT_P (stmt_info)) + return false; + + DUMP_VECT_SCOPE ("vectorizable_early_exit"); + + auto code =3D gimple_cond_code (STMT_VINFO_STMT (stmt_info)); + + tree vectype_op0 =3D NULL_TREE; + slp_tree slp_op0; + tree op0; + enum vect_def_type dt0; + if (!vect_is_simple_use (vinfo, stmt_info, slp_node, 0, &op0, &slp_op0, = &dt0, + &vectype_op0)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "use not simple.\n"); + return false; + } + + stmt_vec_info op0_info =3D vinfo->lookup_def (op0); + tree vectype =3D truth_type_for (STMT_VINFO_VECTYPE (op0_info)); + gcc_assert (vectype); + + machine_mode mode =3D TYPE_MODE (vectype); + int ncopies; + + if (slp_node) + ncopies =3D 1; + else + ncopies =3D vect_get_num_copies (loop_vinfo, vectype); + + vec_loop_masks *masks =3D &LOOP_VINFO_MASKS (loop_vinfo); + bool masked_loop_p =3D LOOP_VINFO_FULLY_MASKED_P (loop_vinfo); + + /* Analyze only. */ + if (!vec_stmt) + { + if (direct_optab_handler (cbranch_optab, mode) =3D=3D CODE_FOR_nothi= ng) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "can't vectorize early exit because the " + "target doesn't support flag setting vector " + "comparisons.\n"); + return false; + } + + if (ncopies > 1 + && direct_optab_handler (ior_optab, mode) =3D=3D CODE_FOR_nothing) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "can't vectorize early exit because the " + "target does not support boolean vector OR for " + "type %T.\n", vectype); + return false; + } + + if (!vectorizable_comparison_1 (vinfo, vectype, stmt_info, code, gsi= , + vec_stmt, slp_node, cost_vec)) + return false; + + if (LOOP_VINFO_CAN_USE_PARTIAL_VECTORS_P (loop_vinfo)) + { + if (direct_internal_fn_supported_p (IFN_VCOND_MASK_LEN, vectype, + OPTIMIZE_FOR_SPEED)) + return false; + else + vect_record_loop_mask (loop_vinfo, masks, ncopies, vectype, NULL); + } + + + return true; + } + + /* Tranform. */ + + tree new_temp =3D NULL_TREE; + gimple *new_stmt =3D NULL; + + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, "transform early-exit.\n"); + + if (!vectorizable_comparison_1 (vinfo, vectype, stmt_info, code, gsi, + vec_stmt, slp_node, cost_vec)) + gcc_unreachable (); + + gimple *stmt =3D STMT_VINFO_STMT (stmt_info); + basic_block cond_bb =3D gimple_bb (stmt); + gimple_stmt_iterator cond_gsi =3D gsi_last_bb (cond_bb); + + auto_vec stmts; + + tree mask =3D NULL_TREE; + if (masked_loop_p) + mask =3D vect_get_loop_mask (loop_vinfo, gsi, masks, ncopies, vectype,= 0); + + if (slp_node) + stmts.safe_splice (SLP_TREE_VEC_DEFS (slp_node)); + else + { + auto vec_stmts =3D STMT_VINFO_VEC_STMTS (stmt_info); + stmts.reserve_exact (vec_stmts.length ()); + for (auto stmt : vec_stmts) + stmts.quick_push (gimple_assign_lhs (stmt)); + } + + /* Determine if we need to reduce the final value. */ + if (stmts.length () > 1) + { + /* We build the reductions in a way to maintain as much parallelism = as + possible. */ + auto_vec workset (stmts.length ()); + + /* Mask the statements as we queue them up. Normally we loop over + vec_num, but since we inspect the exact results of vectorization + we don't need to and instead can just use the stmts themselves. */ + if (masked_loop_p) + for (unsigned i =3D 0; i < stmts.length (); i++) + { + tree stmt_mask + =3D vect_get_loop_mask (loop_vinfo, gsi, masks, ncopies, vectype, + i); + stmt_mask + =3D prepare_vec_mask (loop_vinfo, TREE_TYPE (stmt_mask), stmt_mask, + stmts[i], &cond_gsi); + workset.quick_push (stmt_mask); + } + else + workset.splice (stmts); + + while (workset.length () > 1) + { + new_temp =3D make_temp_ssa_name (vectype, NULL, "vexit_reduc"); + tree arg0 =3D workset.pop (); + tree arg1 =3D workset.pop (); + new_stmt =3D gimple_build_assign (new_temp, BIT_IOR_EXPR, arg0, arg1); + vect_finish_stmt_generation (loop_vinfo, stmt_info, new_stmt, + &cond_gsi); + workset.quick_insert (0, new_temp); + } + } + else + new_temp =3D stmts[0]; + + gcc_assert (new_temp); + + tree cond =3D new_temp; + /* If we have multiple statements after reduction we should check all th= e + lanes and treat it as a full vector. */ + if (masked_loop_p) + cond =3D prepare_vec_mask (loop_vinfo, TREE_TYPE (mask), mask, cond, + &cond_gsi); + + /* Now build the new conditional. Pattern gimple_conds get dropped duri= ng + codegen so we must replace the original insn. */ + stmt =3D STMT_VINFO_STMT (vect_orig_stmt (stmt_info)); + gcond *cond_stmt =3D as_a (stmt); + /* When vectorizing we assume that if the branch edge is taken that we'r= e + exiting the loop. This is not however always the case as the compile= r will + rewrite conditions to always be a comparison against 0. To do this i= t + sometimes flips the edges. This is fine for scalar, but for vector = we + then have to flip the test, as we're still assuming that if you take = the + branch edge that we found the exit condition. */ + auto new_code =3D NE_EXPR; + tree cst =3D build_zero_cst (vectype); + if (flow_bb_inside_loop_p (LOOP_VINFO_LOOP (loop_vinfo), + BRANCH_EDGE (gimple_bb (cond_stmt))->dest)) + { + new_code =3D EQ_EXPR; + cst =3D build_minus_one_cst (vectype); + } + + gimple_cond_set_condition (cond_stmt, new_code, cond, cst); + update_stmt (stmt); + + if (slp_node) + SLP_TREE_VEC_DEFS (slp_node).truncate (0); + else + STMT_VINFO_VEC_STMTS (stmt_info).truncate (0); + + + if (!slp_node) + *vec_stmt =3D stmt; + + return true; +} + /* If SLP_NODE is nonnull, return true if vectorizable_live_operation can handle all live statements in the node. Otherwise return true if STMT_INFO is not live or if vectorizable_live_operation can handle i= t. @@ -12949,7 +13158,9 @@ vect_analyze_stmt (vec_info *vinfo, || vectorizable_lc_phi (as_a (vinfo), stmt_info, NULL, node) || vectorizable_recurr (as_a (vinfo), - stmt_info, NULL, node, cost_vec)); + stmt_info, NULL, node, cost_vec) + || vectorizable_early_exit (vinfo, stmt_info, NULL, NULL, node, + cost_vec)); else { if (bb_vinfo) @@ -12972,7 +13183,10 @@ vect_analyze_stmt (vec_info *vinfo, NULL, NULL, node, cost_vec) || vectorizable_comparison (vinfo, stmt_info, NULL, NULL, node, cost_vec) - || vectorizable_phi (vinfo, stmt_info, NULL, node, cost_vec)); + || vectorizable_phi (vinfo, stmt_info, NULL, node, cost_vec) + || vectorizable_early_exit (vinfo, stmt_info, NULL, NULL, node, + cost_vec)); + } =20 if (node) @@ -13131,6 +13345,12 @@ vect_transform_stmt (vec_info *vinfo, gcc_assert (done); break; =20 + case loop_exit_ctrl_vec_info_type: + done =3D vectorizable_early_exit (vinfo, stmt_info, gsi, &vec_stmt, + slp_node, NULL); + gcc_assert (done); + break; + default: if (!STMT_VINFO_LIVE_P (stmt_info)) { @@ -14321,10 +14541,19 @@ vect_get_vector_types_for_stmt (vec_info *vinfo, = stmt_vec_info stmt_info, } else { + gcond *cond =3D NULL; if (data_reference *dr =3D STMT_VINFO_DATA_REF (stmt_info)) scalar_type =3D TREE_TYPE (DR_REF (dr)); else if (gimple_call_internal_p (stmt, IFN_MASK_STORE)) scalar_type =3D TREE_TYPE (gimple_call_arg (stmt, 3)); + else if ((cond =3D dyn_cast (stmt))) + { + /* We can't convert the scalar type to boolean yet, since booleans have= a + single bit precision and we need the vector boolean to be a + representation of the integer mask. So set the correct integer type= and + convert to boolean vector once we have a vectype. */ + scalar_type =3D TREE_TYPE (gimple_cond_lhs (cond)); + } else scalar_type =3D TREE_TYPE (gimple_get_lhs (stmt)); =20 @@ -14339,12 +14568,18 @@ vect_get_vector_types_for_stmt (vec_info *vinfo, = stmt_vec_info stmt_info, "get vectype for scalar type: %T\n", scalar_type); } vectype =3D get_vectype_for_scalar_type (vinfo, scalar_type, group_s= ize); + if (!vectype) return opt_result::failure_at (stmt, "not vectorized:" " unsupported data-type %T\n", scalar_type); =20 + /* If we were a gcond, convert the resulting type to a vector boolea= n type now + that we have the correct integer mask type. */ + if (cond) + vectype =3D truth_type_for (vectype); + if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, "vectype: %T\n", vectype); } --_002_VI1PR08MB5325931CD930AEBBA5D27C7DFF8FAVI1PR08MB5325eurp_ Content-Type: application/octet-stream; name="rb17969.patch" Content-Description: rb17969.patch Content-Disposition: attachment; filename="rb17969.patch"; size=15296; creation-date="Mon, 11 Dec 2023 22:48:12 GMT"; modification-date="Mon, 11 Dec 2023 23:12:13 GMT" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVjdC1lYXJseS1icmVha184 OC5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC92ZWN0LWVhcmx5LWJyZWFrXzg4LmMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uYjY0YmVjZDU4ODk3M2Y1ODYwMTE5NmJmY2IxNWFmYmU0YmFiNjBmMgotLS0gL2Rl di9udWxsCisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvdmVjdC1lYXJseS1icmVha184 OC5jCkBAIC0wLDAgKzEsMzYgQEAKKy8qIHsgZGctcmVxdWlyZS1lZmZlY3RpdmUtdGFyZ2V0IHZl Y3RfZWFybHlfYnJlYWsgfSAqLworLyogeyBkZy1yZXF1aXJlLWVmZmVjdGl2ZS10YXJnZXQgdmVj dF9pbnQgfSAqLworCisvKiB7IGRnLWFkZGl0aW9uYWwtb3B0aW9ucyAiLU9mYXN0IC0tcGFyYW0g dmVjdC1wYXJ0aWFsLXZlY3Rvci11c2FnZT0yIiB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10 cmVlLWR1bXAgIkxPT1AgVkVDVE9SSVpFRCIgInZlY3QiIH0gfSAqLworCisjaWZuZGVmIE4KKyNk ZWZpbmUgTiA1CisjZW5kaWYKK2Zsb2F0IHZlY3RfYVtOXSA9IHsgNS4xZiwgNC4yZiwgOC4wZiwg NC4yNWYsIDYuNWYgfTsKK3Vuc2lnbmVkIHZlY3RfYltOXSA9IHsgMCB9OworCitfX2F0dHJpYnV0 ZV9fICgobm9pbmxpbmUsIG5vaXBhKSkKK3Vuc2lnbmVkIHRlc3Q0KGRvdWJsZSB4KQoreworIHVu c2lnbmVkIHJldCA9IDA7CisgZm9yIChpbnQgaSA9IDA7IGkgPCBOOyBpKyspCisgeworICAgaWYg KHZlY3RfYVtpXSA+IHgpCisgICAgIGJyZWFrOworICAgdmVjdF9hW2ldID0geDsKKyAgIAorIH0K KyByZXR1cm4gcmV0OworfQorCitleHRlcm4gdm9pZCBhYm9ydCAoKTsKKworaW50IG1haW4gKCkK K3sKKyAgaWYgKHRlc3Q0ICg3LjApICE9IDApCisgICAgYWJvcnQgKCk7CisKKyAgaWYgKHZlY3Rf YlsyXSAhPSAwICYmIHZlY3RfYlsxXSA9PSAwKQorICAgIGFib3J0ICgpOworfQpkaWZmIC0tZ2l0 IGEvZ2NjL3RyZWUtdmVjdC1wYXR0ZXJucy5jYyBiL2djYy90cmVlLXZlY3QtcGF0dGVybnMuY2MK aW5kZXggN2RlYmU3ZjA3MzE2NzNjZDFiZjI1Y2QzOWQ1NWUyMzk5MGE3M2QwZS4uMzU5ZDMwYjU5 OTFhNTA3MTdjMjY5ZGY1NzdjMDhhZGZmYTQ0ZTcxYiAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtdmVj dC1wYXR0ZXJucy5jYworKysgYi9nY2MvdHJlZS12ZWN0LXBhdHRlcm5zLmNjCkBAIC0xMzIsNiAr MTMyLDcgQEAgdmVjdF9pbml0X3BhdHRlcm5fc3RtdCAodmVjX2luZm8gKnZpbmZvLCBnaW1wbGUg KnBhdHRlcm5fc3RtdCwKICAgaWYgKCFTVE1UX1ZJTkZPX1ZFQ1RZUEUgKHBhdHRlcm5fc3RtdF9p bmZvKSkKICAgICB7CiAgICAgICBnY2NfYXNzZXJ0ICghdmVjdHlwZQorCQkgIHx8IGlzX2EgPGdj b25kICo+IChwYXR0ZXJuX3N0bXQpCiAJCSAgfHwgKFZFQ1RPUl9CT09MRUFOX1RZUEVfUCAodmVj dHlwZSkKIAkJICAgICAgPT0gdmVjdF91c2VfbWFza190eXBlX3AgKG9yaWdfc3RtdF9pbmZvKSkp OwogICAgICAgU1RNVF9WSU5GT19WRUNUWVBFIChwYXR0ZXJuX3N0bXRfaW5mbykgPSB2ZWN0eXBl OwpAQCAtNTU1Myw2ICs1NTU0LDgzIEBAIGludGVnZXJfdHlwZV9mb3JfbWFzayAodHJlZSB2YXIs IHZlY19pbmZvICp2aW5mbykKICAgcmV0dXJuIGJ1aWxkX25vbnN0YW5kYXJkX2ludGVnZXJfdHlw ZSAoZGVmX3N0bXRfaW5mby0+bWFza19wcmVjaXNpb24sIDEpOwogfQogCisvKiBGdW5jdGlvbiB2 ZWN0X3JlY29nX2djb25kX3BhdHRlcm4KKworICAgVHJ5IHRvIGZpbmQgcGF0dGVybiBsaWtlIGZv bGxvd2luZzoKKworICAgICBpZiAoYSBvcCBiKQorCisgICB3aGVyZSBvcGVyYXRvciAnb3AnIGlz IG5vdCAhPSBhbmQgY29udmVydCBpdCB0byBhbiBhZGp1c3RlZCBib29sZWFuIHBhdHRlcm4KKwor ICAgICBtYXNrID0gYSBvcCBiCisgICAgIGlmIChtYXNrICE9IDApCisKKyAgIGFuZCBzZXQgdGhl IG1hc2sgdHlwZSBvbiBNQVNLLgorCisgICBJbnB1dDoKKworICAgKiBTVE1UX1ZJTkZPOiBUaGUg c3RtdCBhdCB0aGUgZW5kIGZyb20gd2hpY2ggdGhlIHBhdHRlcm4KKwkJIHNlYXJjaCBiZWdpbnMs IGkuZS4gY2FzdCBvZiBhIGJvb2wgdG8KKwkJIGFuIGludGVnZXIgdHlwZS4KKworICAgT3V0cHV0 OgorCisgICAqIFRZUEVfT1VUOiBUaGUgdHlwZSBvZiB0aGUgb3V0cHV0IG9mIHRoaXMgcGF0dGVy bi4KKworICAgKiBSZXR1cm4gdmFsdWU6IEEgbmV3IHN0bXQgdGhhdCB3aWxsIGJlIHVzZWQgdG8g cmVwbGFjZSB0aGUgcGF0dGVybi4gICovCisKK3N0YXRpYyBnaW1wbGUgKgordmVjdF9yZWNvZ19n Y29uZF9wYXR0ZXJuICh2ZWNfaW5mbyAqdmluZm8sCisJCQkgc3RtdF92ZWNfaW5mbyBzdG10X3Zp bmZvLCB0cmVlICp0eXBlX291dCkKK3sKKyAgZ2ltcGxlICpsYXN0X3N0bXQgPSBTVE1UX1ZJTkZP X1NUTVQgKHN0bXRfdmluZm8pOworICBnY29uZCogY29uZCA9IE5VTEw7CisgIGlmICghKGNvbmQg PSBkeW5fY2FzdCA8Z2NvbmQgKj4gKGxhc3Rfc3RtdCkpKQorICAgIHJldHVybiBOVUxMOworCisg IGF1dG8gbGhzID0gZ2ltcGxlX2NvbmRfbGhzIChjb25kKTsKKyAgYXV0byByaHMgPSBnaW1wbGVf Y29uZF9yaHMgKGNvbmQpOworICBhdXRvIGNvZGUgPSBnaW1wbGVfY29uZF9jb2RlIChjb25kKTsK KworICB0cmVlIHNjYWxhcl90eXBlID0gVFJFRV9UWVBFIChsaHMpOworICBpZiAoVkVDVE9SX1RZ UEVfUCAoc2NhbGFyX3R5cGUpKQorICAgIHJldHVybiBOVUxMOworCisgIGlmIChjb2RlID09IE5F X0VYUFIgJiYgemVyb3AgKHJocykpCisgICAgcmV0dXJuIE5VTEw7CisKKyAgdHJlZSB2ZWNpdHlw ZSA9IGdldF92ZWN0eXBlX2Zvcl9zY2FsYXJfdHlwZSAodmluZm8sIHNjYWxhcl90eXBlKTsKKyAg aWYgKHZlY2l0eXBlID09IE5VTExfVFJFRSkKKyAgICByZXR1cm4gTlVMTDsKKworICAvKiBCdWls ZCBhIHNjYWxhciB0eXBlIGZvciB0aGUgYm9vbGVhbiByZXN1bHQgdGhhdCB3aGVuIHZlY3Rvcml6 ZWQgbWF0Y2hlcyB0aGUKKyAgICAgdmVjdG9yIHR5cGUgb2YgdGhlIHJlc3VsdCBpbiBzaXplIGFu ZCBudW1iZXIgb2YgZWxlbWVudHMuICAqLworICB1bnNpZ25lZCBwcmVjCisgICAgPSB2ZWN0b3Jf ZWxlbWVudF9zaXplICh0cmVlX3RvX3BvbHlfdWludDY0IChUWVBFX1NJWkUgKHZlY2l0eXBlKSks CisJCQkgICBUWVBFX1ZFQ1RPUl9TVUJQQVJUUyAodmVjaXR5cGUpKTsKKworICBzY2FsYXJfdHlw ZQorICAgID0gYnVpbGRfbm9uc3RhbmRhcmRfaW50ZWdlcl90eXBlIChwcmVjLCBUWVBFX1VOU0lH TkVEIChzY2FsYXJfdHlwZSkpOworCisgIHZlY2l0eXBlID0gZ2V0X3ZlY3R5cGVfZm9yX3NjYWxh cl90eXBlICh2aW5mbywgc2NhbGFyX3R5cGUpOworICBpZiAodmVjaXR5cGUgPT0gTlVMTF9UUkVF KQorICAgIHJldHVybiBOVUxMOworCisgIHRyZWUgdmVjdHlwZSA9IHRydXRoX3R5cGVfZm9yICh2 ZWNpdHlwZSk7CisKKyAgdHJlZSBuZXdfbGhzID0gdmVjdF9yZWNvZ190ZW1wX3NzYV92YXIgKGJv b2xlYW5fdHlwZV9ub2RlLCBOVUxMKTsKKyAgZ2ltcGxlICpuZXdfc3RtdCA9IGdpbXBsZV9idWls ZF9hc3NpZ24gKG5ld19saHMsIGNvZGUsIGxocywgcmhzKTsKKyAgYXBwZW5kX3BhdHRlcm5fZGVm X3NlcSAodmluZm8sIHN0bXRfdmluZm8sIG5ld19zdG10LCB2ZWN0eXBlLCBzY2FsYXJfdHlwZSk7 CisKKyAgZ2ltcGxlICpwYXR0ZXJuX3N0bXQKKyAgICA9IGdpbXBsZV9idWlsZF9jb25kIChORV9F WFBSLCBuZXdfbGhzLAorCQkJIGJ1aWxkX2ludF9jc3QgKFRSRUVfVFlQRSAobmV3X2xocyksIDAp LAorCQkJIE5VTExfVFJFRSwgTlVMTF9UUkVFKTsKKyAgKnR5cGVfb3V0ID0gdmVjdHlwZTsKKyAg dmVjdF9wYXR0ZXJuX2RldGVjdGVkICgidmVjdF9yZWNvZ19nY29uZF9wYXR0ZXJuIiwgbGFzdF9z dG10KTsKKyAgcmV0dXJuIHBhdHRlcm5fc3RtdDsKK30KKwogLyogRnVuY3Rpb24gdmVjdF9yZWNv Z19ib29sX3BhdHRlcm4KIAogICAgVHJ5IHRvIGZpbmQgcGF0dGVybiBsaWtlIGZvbGxvd2luZzoK QEAgLTY4NjAsNiArNjkzOCw3IEBAIHN0YXRpYyB2ZWN0X3JlY29nX2Z1bmMgdmVjdF92ZWN0X3Jl Y29nX2Z1bmNfcHRyc1tdID0gewogICB7IHZlY3RfcmVjb2dfZGl2bW9kX3BhdHRlcm4sICJkaXZt b2QiIH0sCiAgIHsgdmVjdF9yZWNvZ19tdWx0X3BhdHRlcm4sICJtdWx0IiB9LAogICB7IHZlY3Rf cmVjb2dfbWl4ZWRfc2l6ZV9jb25kX3BhdHRlcm4sICJtaXhlZF9zaXplX2NvbmQiIH0sCisgIHsg dmVjdF9yZWNvZ19nY29uZF9wYXR0ZXJuLCAiZ2NvbmQiIH0sCiAgIHsgdmVjdF9yZWNvZ19ib29s X3BhdHRlcm4sICJib29sIiB9LAogICAvKiBUaGlzIG11c3QgY29tZSBiZWZvcmUgbWFzayBjb252 ZXJzaW9uLCBhbmQgaW5jbHVkZXMgdGhlIHBhcnRzCiAgICAgIG9mIG1hc2sgY29udmVyc2lvbiB0 aGF0IGFyZSBuZWVkZWQgZm9yIGdhdGhlciBhbmQgc2NhdHRlcgpkaWZmIC0tZ2l0IGEvZ2NjL3Ry ZWUtdmVjdC1zdG10cy5jYyBiL2djYy90cmVlLXZlY3Qtc3RtdHMuY2MKaW5kZXggNTgyYzVlNjc4 ZmFkODAyZDZlNzYzMDBmZTNjOTM5YjlmMjk3OGYxNy4uN2M1MGVlMzdmMmFkZTI0ZWNjZjdhN2Qx ZWEyZTAwYjQ0NTAwMjNmOSAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtdmVjdC1zdG10cy5jYworKysg Yi9nY2MvdHJlZS12ZWN0LXN0bXRzLmNjCkBAIC0xMjQ4OSw3ICsxMjQ4OSw3IEBAIHZlY3Rvcml6 YWJsZV9jb21wYXJpc29uXzEgKHZlY19pbmZvICp2aW5mbywgdHJlZSB2ZWN0eXBlLAogICB2ZWM8 dHJlZT4gdmVjX29wcm5kczAgPSB2TlVMTDsKICAgdmVjPHRyZWU+IHZlY19vcHJuZHMxID0gdk5V TEw7CiAgIHRyZWUgbWFza190eXBlOwotICB0cmVlIG1hc2s7CisgIHRyZWUgbWFzayA9IE5VTExf VFJFRTsKIAogICBpZiAoIVNUTVRfVklORk9fUkVMRVZBTlRfUCAoc3RtdF9pbmZvKSAmJiAhYmJf dmluZm8pCiAgICAgcmV0dXJuIGZhbHNlOwpAQCAtMTI2MjksOCArMTI2MjksOSBAQCB2ZWN0b3Jp emFibGVfY29tcGFyaXNvbl8xICh2ZWNfaW5mbyAqdmluZm8sIHRyZWUgdmVjdHlwZSwKICAgLyog VHJhbnNmb3JtLiAgKi8KIAogICAvKiBIYW5kbGUgZGVmLiAgKi8KLSAgbGhzID0gZ2ltcGxlX2Fz c2lnbl9saHMgKFNUTVRfVklORk9fU1RNVCAoc3RtdF9pbmZvKSk7Ci0gIG1hc2sgPSB2ZWN0X2Ny ZWF0ZV9kZXN0aW5hdGlvbl92YXIgKGxocywgbWFza190eXBlKTsKKyAgbGhzID0gZ2ltcGxlX2dl dF9saHMgKFNUTVRfVklORk9fU1RNVCAoc3RtdF9pbmZvKSk7CisgIGlmIChsaHMpCisgICAgbWFz ayA9IHZlY3RfY3JlYXRlX2Rlc3RpbmF0aW9uX3ZhciAobGhzLCBtYXNrX3R5cGUpOwogCiAgIHZl Y3RfZ2V0X3ZlY19kZWZzICh2aW5mbywgc3RtdF9pbmZvLCBzbHBfbm9kZSwgbmNvcGllcywKIAkJ ICAgICByaHMxLCAmdmVjX29wcm5kczAsIHZlY3R5cGUsCkBAIC0xMjY0NCw3ICsxMjY0NSwxMCBA QCB2ZWN0b3JpemFibGVfY29tcGFyaXNvbl8xICh2ZWNfaW5mbyAqdmluZm8sIHRyZWUgdmVjdHlw ZSwKICAgICAgIGdpbXBsZSAqbmV3X3N0bXQ7CiAgICAgICB2ZWNfcmhzMiA9IHZlY19vcHJuZHMx W2ldOwogCi0gICAgICBuZXdfdGVtcCA9IG1ha2Vfc3NhX25hbWUgKG1hc2spOworICAgICAgaWYg KGxocykKKwluZXdfdGVtcCA9IG1ha2Vfc3NhX25hbWUgKG1hc2spOworICAgICAgZWxzZQorCW5l d190ZW1wID0gbWFrZV90ZW1wX3NzYV9uYW1lIChtYXNrX3R5cGUsIE5VTEwsICJjbXAiKTsKICAg ICAgIGlmIChiaXRvcDEgPT0gTk9QX0VYUFIpCiAJewogCSAgbmV3X3N0bXQgPSBnaW1wbGVfYnVp bGRfYXNzaWduIChuZXdfdGVtcCwgY29kZSwKQEAgLTEyNzIzLDYgKzEyNzI3LDIxMSBAQCB2ZWN0 b3JpemFibGVfY29tcGFyaXNvbiAodmVjX2luZm8gKnZpbmZvLAogICByZXR1cm4gdHJ1ZTsKIH0K IAorLyogQ2hlY2sgdG8gc2VlIGlmIHRoZSBjdXJyZW50IGVhcmx5IGJyZWFrIGdpdmVuIGluIFNU TVRfSU5GTyBpcyB2YWxpZCBmb3IKKyAgIHZlY3Rvcml6YXRpb24uICAqLworCitzdGF0aWMgYm9v bAordmVjdG9yaXphYmxlX2Vhcmx5X2V4aXQgKHZlY19pbmZvICp2aW5mbywgc3RtdF92ZWNfaW5m byBzdG10X2luZm8sCisJCQkgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKmdzaSwgZ2ltcGxlICoqdmVj X3N0bXQsCisJCQkgc2xwX3RyZWUgc2xwX25vZGUsIHN0bXRfdmVjdG9yX2Zvcl9jb3N0ICpjb3N0 X3ZlYykKK3sKKyAgbG9vcF92ZWNfaW5mbyBsb29wX3ZpbmZvID0gZHluX2Nhc3QgPGxvb3BfdmVj X2luZm8+ICh2aW5mbyk7CisgIGlmICghbG9vcF92aW5mbworICAgICAgfHwgIWlzX2EgPGdjb25k ICo+IChTVE1UX1ZJTkZPX1NUTVQgKHN0bXRfaW5mbykpKQorICAgIHJldHVybiBmYWxzZTsKKwor ICBpZiAoU1RNVF9WSU5GT19ERUZfVFlQRSAoc3RtdF9pbmZvKSAhPSB2ZWN0X2NvbmRpdGlvbl9k ZWYpCisgICAgcmV0dXJuIGZhbHNlOworCisgIGlmICghU1RNVF9WSU5GT19SRUxFVkFOVF9QIChz dG10X2luZm8pKQorICAgIHJldHVybiBmYWxzZTsKKworICBEVU1QX1ZFQ1RfU0NPUEUgKCJ2ZWN0 b3JpemFibGVfZWFybHlfZXhpdCIpOworCisgIGF1dG8gY29kZSA9IGdpbXBsZV9jb25kX2NvZGUg KFNUTVRfVklORk9fU1RNVCAoc3RtdF9pbmZvKSk7CisKKyAgdHJlZSB2ZWN0eXBlX29wMCA9IE5V TExfVFJFRTsKKyAgc2xwX3RyZWUgc2xwX29wMDsKKyAgdHJlZSBvcDA7CisgIGVudW0gdmVjdF9k ZWZfdHlwZSBkdDA7CisgIGlmICghdmVjdF9pc19zaW1wbGVfdXNlICh2aW5mbywgc3RtdF9pbmZv LCBzbHBfbm9kZSwgMCwgJm9wMCwgJnNscF9vcDAsICZkdDAsCisJCQkgICAmdmVjdHlwZV9vcDAp KQorICAgIHsKKyAgICAgIGlmIChkdW1wX2VuYWJsZWRfcCAoKSkKKwkgIGR1bXBfcHJpbnRmX2xv YyAoTVNHX01JU1NFRF9PUFRJTUlaQVRJT04sIHZlY3RfbG9jYXRpb24sCisJCQkgICAidXNlIG5v dCBzaW1wbGUuXG4iKTsKKwlyZXR1cm4gZmFsc2U7CisgICAgfQorCisgIHN0bXRfdmVjX2luZm8g b3AwX2luZm8gPSB2aW5mby0+bG9va3VwX2RlZiAob3AwKTsKKyAgdHJlZSB2ZWN0eXBlID0gdHJ1 dGhfdHlwZV9mb3IgKFNUTVRfVklORk9fVkVDVFlQRSAob3AwX2luZm8pKTsKKyAgZ2NjX2Fzc2Vy dCAodmVjdHlwZSk7CisKKyAgbWFjaGluZV9tb2RlIG1vZGUgPSBUWVBFX01PREUgKHZlY3R5cGUp OworICBpbnQgbmNvcGllczsKKworICBpZiAoc2xwX25vZGUpCisgICAgbmNvcGllcyA9IDE7Cisg IGVsc2UKKyAgICBuY29waWVzID0gdmVjdF9nZXRfbnVtX2NvcGllcyAobG9vcF92aW5mbywgdmVj dHlwZSk7CisKKyAgdmVjX2xvb3BfbWFza3MgKm1hc2tzID0gJkxPT1BfVklORk9fTUFTS1MgKGxv b3BfdmluZm8pOworICBib29sIG1hc2tlZF9sb29wX3AgPSBMT09QX1ZJTkZPX0ZVTExZX01BU0tF RF9QIChsb29wX3ZpbmZvKTsKKworICAvKiBBbmFseXplIG9ubHkuICAqLworICBpZiAoIXZlY19z dG10KQorICAgIHsKKyAgICAgIGlmIChkaXJlY3Rfb3B0YWJfaGFuZGxlciAoY2JyYW5jaF9vcHRh YiwgbW9kZSkgPT0gQ09ERV9GT1Jfbm90aGluZykKKwl7CisJICBpZiAoZHVtcF9lbmFibGVkX3Ag KCkpCisJICAgICAgZHVtcF9wcmludGZfbG9jIChNU0dfTUlTU0VEX09QVElNSVpBVElPTiwgdmVj dF9sb2NhdGlvbiwKKwkJCSAgICAgICAiY2FuJ3QgdmVjdG9yaXplIGVhcmx5IGV4aXQgYmVjYXVz ZSB0aGUgIgorCQkJICAgICAgICJ0YXJnZXQgZG9lc24ndCBzdXBwb3J0IGZsYWcgc2V0dGluZyB2 ZWN0b3IgIgorCQkJICAgICAgICJjb21wYXJpc29ucy5cbiIpOworCSAgcmV0dXJuIGZhbHNlOwor CX0KKworICAgICAgaWYgKG5jb3BpZXMgPiAxCisJICAmJiBkaXJlY3Rfb3B0YWJfaGFuZGxlciAo aW9yX29wdGFiLCBtb2RlKSA9PSBDT0RFX0ZPUl9ub3RoaW5nKQorCXsKKwkgIGlmIChkdW1wX2Vu YWJsZWRfcCAoKSkKKwkgICAgICBkdW1wX3ByaW50Zl9sb2MgKE1TR19NSVNTRURfT1BUSU1JWkFU SU9OLCB2ZWN0X2xvY2F0aW9uLAorCQkJICAgICAgICJjYW4ndCB2ZWN0b3JpemUgZWFybHkgZXhp dCBiZWNhdXNlIHRoZSAiCisJCQkgICAgICAgInRhcmdldCBkb2VzIG5vdCBzdXBwb3J0IGJvb2xl YW4gdmVjdG9yIE9SIGZvciAiCisJCQkgICAgICAgInR5cGUgJVQuXG4iLCB2ZWN0eXBlKTsKKwkg IHJldHVybiBmYWxzZTsKKwl9CisKKyAgICAgIGlmICghdmVjdG9yaXphYmxlX2NvbXBhcmlzb25f MSAodmluZm8sIHZlY3R5cGUsIHN0bXRfaW5mbywgY29kZSwgZ3NpLAorCQkJCSAgICAgIHZlY19z dG10LCBzbHBfbm9kZSwgY29zdF92ZWMpKQorCXJldHVybiBmYWxzZTsKKworICAgICAgaWYgKExP T1BfVklORk9fQ0FOX1VTRV9QQVJUSUFMX1ZFQ1RPUlNfUCAobG9vcF92aW5mbykpCisJeworCSAg aWYgKGRpcmVjdF9pbnRlcm5hbF9mbl9zdXBwb3J0ZWRfcCAoSUZOX1ZDT05EX01BU0tfTEVOLCB2 ZWN0eXBlLAorCQkJCQkgICAgICBPUFRJTUlaRV9GT1JfU1BFRUQpKQorCSAgICByZXR1cm4gZmFs c2U7CisJICBlbHNlCisJICAgIHZlY3RfcmVjb3JkX2xvb3BfbWFzayAobG9vcF92aW5mbywgbWFz a3MsIG5jb3BpZXMsIHZlY3R5cGUsIE5VTEwpOworCX0KKworCisgICAgICByZXR1cm4gdHJ1ZTsK KyAgICB9CisKKyAgLyogVHJhbmZvcm0uICAqLworCisgIHRyZWUgbmV3X3RlbXAgPSBOVUxMX1RS RUU7CisgIGdpbXBsZSAqbmV3X3N0bXQgPSBOVUxMOworCisgIGlmIChkdW1wX2VuYWJsZWRfcCAo KSkKKyAgICBkdW1wX3ByaW50Zl9sb2MgKE1TR19OT1RFLCB2ZWN0X2xvY2F0aW9uLCAidHJhbnNm b3JtIGVhcmx5LWV4aXQuXG4iKTsKKworICBpZiAoIXZlY3Rvcml6YWJsZV9jb21wYXJpc29uXzEg KHZpbmZvLCB2ZWN0eXBlLCBzdG10X2luZm8sIGNvZGUsIGdzaSwKKwkJCQkgIHZlY19zdG10LCBz bHBfbm9kZSwgY29zdF92ZWMpKQorICAgIGdjY191bnJlYWNoYWJsZSAoKTsKKworICBnaW1wbGUg KnN0bXQgPSBTVE1UX1ZJTkZPX1NUTVQgKHN0bXRfaW5mbyk7CisgIGJhc2ljX2Jsb2NrIGNvbmRf YmIgPSBnaW1wbGVfYmIgKHN0bXQpOworICBnaW1wbGVfc3RtdF9pdGVyYXRvciAgY29uZF9nc2kg PSBnc2lfbGFzdF9iYiAoY29uZF9iYik7CisKKyAgYXV0b192ZWM8dHJlZT4gc3RtdHM7CisKKyAg dHJlZSBtYXNrID0gTlVMTF9UUkVFOworICBpZiAobWFza2VkX2xvb3BfcCkKKyAgICBtYXNrID0g dmVjdF9nZXRfbG9vcF9tYXNrIChsb29wX3ZpbmZvLCBnc2ksIG1hc2tzLCBuY29waWVzLCB2ZWN0 eXBlLCAwKTsKKworICBpZiAoc2xwX25vZGUpCisgICAgc3RtdHMuc2FmZV9zcGxpY2UgKFNMUF9U UkVFX1ZFQ19ERUZTIChzbHBfbm9kZSkpOworICBlbHNlCisgICAgeworICAgICAgYXV0byB2ZWNf c3RtdHMgPSBTVE1UX1ZJTkZPX1ZFQ19TVE1UUyAoc3RtdF9pbmZvKTsKKyAgICAgIHN0bXRzLnJl c2VydmVfZXhhY3QgKHZlY19zdG10cy5sZW5ndGggKCkpOworICAgICAgZm9yIChhdXRvIHN0bXQg OiB2ZWNfc3RtdHMpCisJc3RtdHMucXVpY2tfcHVzaCAoZ2ltcGxlX2Fzc2lnbl9saHMgKHN0bXQp KTsKKyAgICB9CisKKyAgLyogRGV0ZXJtaW5lIGlmIHdlIG5lZWQgdG8gcmVkdWNlIHRoZSBmaW5h bCB2YWx1ZS4gICovCisgIGlmIChzdG10cy5sZW5ndGggKCkgPiAxKQorICAgIHsKKyAgICAgIC8q IFdlIGJ1aWxkIHRoZSByZWR1Y3Rpb25zIGluIGEgd2F5IHRvIG1haW50YWluIGFzIG11Y2ggcGFy YWxsZWxpc20gYXMKKwkgcG9zc2libGUuICAqLworICAgICAgYXV0b192ZWM8dHJlZT4gd29ya3Nl dCAoc3RtdHMubGVuZ3RoICgpKTsKKworICAgICAgLyogTWFzayB0aGUgc3RhdGVtZW50cyBhcyB3 ZSBxdWV1ZSB0aGVtIHVwLiAgTm9ybWFsbHkgd2UgbG9vcCBvdmVyCisJIHZlY19udW0sICBidXQg c2luY2Ugd2UgaW5zcGVjdCB0aGUgZXhhY3QgcmVzdWx0cyBvZiB2ZWN0b3JpemF0aW9uCisJIHdl IGRvbid0IG5lZWQgdG8gYW5kIGluc3RlYWQgY2FuIGp1c3QgdXNlIHRoZSBzdG10cyB0aGVtc2Vs dmVzLiAgKi8KKyAgICAgIGlmIChtYXNrZWRfbG9vcF9wKQorCWZvciAodW5zaWduZWQgaSA9IDA7 IGkgPCBzdG10cy5sZW5ndGggKCk7IGkrKykKKwkgIHsKKwkgICAgdHJlZSBzdG10X21hc2sKKwkg ICAgICA9IHZlY3RfZ2V0X2xvb3BfbWFzayAobG9vcF92aW5mbywgZ3NpLCBtYXNrcywgbmNvcGll cywgdmVjdHlwZSwKKwkJCQkgICAgaSk7CisJICAgIHN0bXRfbWFzaworCSAgICAgID0gcHJlcGFy ZV92ZWNfbWFzayAobG9vcF92aW5mbywgVFJFRV9UWVBFIChzdG10X21hc2spLCBzdG10X21hc2ss CisJCQkJICBzdG10c1tpXSwgJmNvbmRfZ3NpKTsKKwkgICAgd29ya3NldC5xdWlja19wdXNoIChz dG10X21hc2spOworCSAgfQorICAgICAgZWxzZQorCXdvcmtzZXQuc3BsaWNlIChzdG10cyk7CisK KyAgICAgIHdoaWxlICh3b3Jrc2V0Lmxlbmd0aCAoKSA+IDEpCisJeworCSAgbmV3X3RlbXAgPSBt YWtlX3RlbXBfc3NhX25hbWUgKHZlY3R5cGUsIE5VTEwsICJ2ZXhpdF9yZWR1YyIpOworCSAgdHJl ZSBhcmcwID0gd29ya3NldC5wb3AgKCk7CisJICB0cmVlIGFyZzEgPSB3b3Jrc2V0LnBvcCAoKTsK KwkgIG5ld19zdG10ID0gZ2ltcGxlX2J1aWxkX2Fzc2lnbiAobmV3X3RlbXAsIEJJVF9JT1JfRVhQ UiwgYXJnMCwgYXJnMSk7CisJICB2ZWN0X2ZpbmlzaF9zdG10X2dlbmVyYXRpb24gKGxvb3Bfdmlu Zm8sIHN0bXRfaW5mbywgbmV3X3N0bXQsCisJCQkJICAgICAgICZjb25kX2dzaSk7CisJICB3b3Jr c2V0LnF1aWNrX2luc2VydCAoMCwgbmV3X3RlbXApOworCX0KKyAgICB9CisgIGVsc2UKKyAgICBu ZXdfdGVtcCA9IHN0bXRzWzBdOworCisgIGdjY19hc3NlcnQgKG5ld190ZW1wKTsKKworICB0cmVl IGNvbmQgPSBuZXdfdGVtcDsKKyAgLyogSWYgd2UgaGF2ZSBtdWx0aXBsZSBzdGF0ZW1lbnRzIGFm dGVyIHJlZHVjdGlvbiB3ZSBzaG91bGQgY2hlY2sgYWxsIHRoZQorICAgICBsYW5lcyBhbmQgdHJl YXQgaXQgYXMgYSBmdWxsIHZlY3Rvci4gICovCisgIGlmIChtYXNrZWRfbG9vcF9wKQorICAgIGNv bmQgPSBwcmVwYXJlX3ZlY19tYXNrIChsb29wX3ZpbmZvLCBUUkVFX1RZUEUgKG1hc2spLCBtYXNr LCBjb25kLAorCQkJICAgICAmY29uZF9nc2kpOworCisgIC8qIE5vdyBidWlsZCB0aGUgbmV3IGNv bmRpdGlvbmFsLiAgUGF0dGVybiBnaW1wbGVfY29uZHMgZ2V0IGRyb3BwZWQgZHVyaW5nCisgICAg IGNvZGVnZW4gc28gd2UgbXVzdCByZXBsYWNlIHRoZSBvcmlnaW5hbCBpbnNuLiAgKi8KKyAgc3Rt dCA9IFNUTVRfVklORk9fU1RNVCAodmVjdF9vcmlnX3N0bXQgKHN0bXRfaW5mbykpOworICBnY29u ZCAqY29uZF9zdG10ID0gYXNfYSA8Z2NvbmQgKj4oc3RtdCk7CisgIC8qIFdoZW4gdmVjdG9yaXpp bmcgd2UgYXNzdW1lIHRoYXQgaWYgdGhlIGJyYW5jaCBlZGdlIGlzIHRha2VuIHRoYXQgd2UncmUK KyAgICAgZXhpdGluZyB0aGUgbG9vcC4gIFRoaXMgaXMgbm90IGhvd2V2ZXIgYWx3YXlzIHRoZSBj YXNlIGFzIHRoZSBjb21waWxlciB3aWxsCisgICAgIHJld3JpdGUgY29uZGl0aW9ucyB0byBhbHdh eXMgYmUgYSBjb21wYXJpc29uIGFnYWluc3QgMC4gIFRvIGRvIHRoaXMgaXQKKyAgICAgc29tZXRp bWVzIGZsaXBzIHRoZSBlZGdlcy4gIFRoaXMgaXMgZmluZSBmb3Igc2NhbGFyLCAgYnV0IGZvciB2 ZWN0b3Igd2UKKyAgICAgdGhlbiBoYXZlIHRvIGZsaXAgdGhlIHRlc3QsIGFzIHdlJ3JlIHN0aWxs IGFzc3VtaW5nIHRoYXQgaWYgeW91IHRha2UgdGhlCisgICAgIGJyYW5jaCBlZGdlIHRoYXQgd2Ug Zm91bmQgdGhlIGV4aXQgY29uZGl0aW9uLiAgKi8KKyAgYXV0byBuZXdfY29kZSA9IE5FX0VYUFI7 CisgIHRyZWUgY3N0ID0gYnVpbGRfemVyb19jc3QgKHZlY3R5cGUpOworICBpZiAoZmxvd19iYl9p bnNpZGVfbG9vcF9wIChMT09QX1ZJTkZPX0xPT1AgKGxvb3BfdmluZm8pLAorCQkJICAgICBCUkFO Q0hfRURHRSAoZ2ltcGxlX2JiIChjb25kX3N0bXQpKS0+ZGVzdCkpCisgICAgeworICAgICAgbmV3 X2NvZGUgPSBFUV9FWFBSOworICAgICAgY3N0ID0gYnVpbGRfbWludXNfb25lX2NzdCAodmVjdHlw ZSk7CisgICAgfQorCisgIGdpbXBsZV9jb25kX3NldF9jb25kaXRpb24gKGNvbmRfc3RtdCwgbmV3 X2NvZGUsIGNvbmQsIGNzdCk7CisgIHVwZGF0ZV9zdG10IChzdG10KTsKKworICBpZiAoc2xwX25v ZGUpCisgICAgU0xQX1RSRUVfVkVDX0RFRlMgKHNscF9ub2RlKS50cnVuY2F0ZSAoMCk7CisgICBl bHNlCisgICAgU1RNVF9WSU5GT19WRUNfU1RNVFMgKHN0bXRfaW5mbykudHJ1bmNhdGUgKDApOwor CisKKyAgaWYgKCFzbHBfbm9kZSkKKyAgICAqdmVjX3N0bXQgPSBzdG10OworCisgIHJldHVybiB0 cnVlOworfQorCiAvKiBJZiBTTFBfTk9ERSBpcyBub25udWxsLCByZXR1cm4gdHJ1ZSBpZiB2ZWN0 b3JpemFibGVfbGl2ZV9vcGVyYXRpb24KICAgIGNhbiBoYW5kbGUgYWxsIGxpdmUgc3RhdGVtZW50 cyBpbiB0aGUgbm9kZS4gIE90aGVyd2lzZSByZXR1cm4gdHJ1ZQogICAgaWYgU1RNVF9JTkZPIGlz IG5vdCBsaXZlIG9yIGlmIHZlY3Rvcml6YWJsZV9saXZlX29wZXJhdGlvbiBjYW4gaGFuZGxlIGl0 LgpAQCAtMTI5NDksNyArMTMxNTgsOSBAQCB2ZWN0X2FuYWx5emVfc3RtdCAodmVjX2luZm8gKnZp bmZvLAogCSAgfHwgdmVjdG9yaXphYmxlX2xjX3BoaSAoYXNfYSA8bG9vcF92ZWNfaW5mbz4gKHZp bmZvKSwKIAkJCQkgIHN0bXRfaW5mbywgTlVMTCwgbm9kZSkKIAkgIHx8IHZlY3Rvcml6YWJsZV9y ZWN1cnIgKGFzX2EgPGxvb3BfdmVjX2luZm8+ICh2aW5mbyksCi0JCQkJICAgc3RtdF9pbmZvLCBO VUxMLCBub2RlLCBjb3N0X3ZlYykpOworCQkJCSAgIHN0bXRfaW5mbywgTlVMTCwgbm9kZSwgY29z dF92ZWMpCisJICB8fCB2ZWN0b3JpemFibGVfZWFybHlfZXhpdCAodmluZm8sIHN0bXRfaW5mbywg TlVMTCwgTlVMTCwgbm9kZSwKKwkJCQkgICAgICBjb3N0X3ZlYykpOwogICBlbHNlCiAgICAgewog ICAgICAgaWYgKGJiX3ZpbmZvKQpAQCAtMTI5NzIsNyArMTMxODMsMTAgQEAgdmVjdF9hbmFseXpl X3N0bXQgKHZlY19pbmZvICp2aW5mbywKIAkJCQkJIE5VTEwsIE5VTEwsIG5vZGUsIGNvc3RfdmVj KQogCSAgICAgIHx8IHZlY3Rvcml6YWJsZV9jb21wYXJpc29uICh2aW5mbywgc3RtdF9pbmZvLCBO VUxMLCBOVUxMLCBub2RlLAogCQkJCQkgIGNvc3RfdmVjKQotCSAgICAgIHx8IHZlY3Rvcml6YWJs ZV9waGkgKHZpbmZvLCBzdG10X2luZm8sIE5VTEwsIG5vZGUsIGNvc3RfdmVjKSk7CisJICAgICAg fHwgdmVjdG9yaXphYmxlX3BoaSAodmluZm8sIHN0bXRfaW5mbywgTlVMTCwgbm9kZSwgY29zdF92 ZWMpCisJICAgICAgfHwgdmVjdG9yaXphYmxlX2Vhcmx5X2V4aXQgKHZpbmZvLCBzdG10X2luZm8s IE5VTEwsIE5VTEwsIG5vZGUsCisJCQkJCSAgY29zdF92ZWMpKTsKKwogICAgIH0KIAogICBpZiAo bm9kZSkKQEAgLTEzMTMxLDYgKzEzMzQ1LDEyIEBAIHZlY3RfdHJhbnNmb3JtX3N0bXQgKHZlY19p bmZvICp2aW5mbywKICAgICAgIGdjY19hc3NlcnQgKGRvbmUpOwogICAgICAgYnJlYWs7CiAKKyAg ICBjYXNlIGxvb3BfZXhpdF9jdHJsX3ZlY19pbmZvX3R5cGU6CisgICAgICBkb25lID0gdmVjdG9y aXphYmxlX2Vhcmx5X2V4aXQgKHZpbmZvLCBzdG10X2luZm8sIGdzaSwgJnZlY19zdG10LAorCQkJ CSAgICAgIHNscF9ub2RlLCBOVUxMKTsKKyAgICAgIGdjY19hc3NlcnQgKGRvbmUpOworICAgICAg YnJlYWs7CisKICAgICBkZWZhdWx0OgogICAgICAgaWYgKCFTVE1UX1ZJTkZPX0xJVkVfUCAoc3Rt dF9pbmZvKSkKIAl7CkBAIC0xNDMyMSwxMCArMTQ1NDEsMTkgQEAgdmVjdF9nZXRfdmVjdG9yX3R5 cGVzX2Zvcl9zdG10ICh2ZWNfaW5mbyAqdmluZm8sIHN0bXRfdmVjX2luZm8gc3RtdF9pbmZvLAog ICAgIH0KICAgZWxzZQogICAgIHsKKyAgICAgIGdjb25kICpjb25kID0gTlVMTDsKICAgICAgIGlm IChkYXRhX3JlZmVyZW5jZSAqZHIgPSBTVE1UX1ZJTkZPX0RBVEFfUkVGIChzdG10X2luZm8pKQog CXNjYWxhcl90eXBlID0gVFJFRV9UWVBFIChEUl9SRUYgKGRyKSk7CiAgICAgICBlbHNlIGlmIChn aW1wbGVfY2FsbF9pbnRlcm5hbF9wIChzdG10LCBJRk5fTUFTS19TVE9SRSkpCiAJc2NhbGFyX3R5 cGUgPSBUUkVFX1RZUEUgKGdpbXBsZV9jYWxsX2FyZyAoc3RtdCwgMykpOworICAgICAgZWxzZSBp ZiAoKGNvbmQgPSBkeW5fY2FzdCA8Z2NvbmQgKj4gKHN0bXQpKSkKKwl7CisJICAvKiBXZSBjYW4n dCBjb252ZXJ0IHRoZSBzY2FsYXIgdHlwZSB0byBib29sZWFuIHlldCwgc2luY2UgYm9vbGVhbnMg aGF2ZSBhCisJICAgICBzaW5nbGUgYml0IHByZWNpc2lvbiBhbmQgd2UgbmVlZCB0aGUgdmVjdG9y IGJvb2xlYW4gdG8gYmUgYQorCSAgICAgcmVwcmVzZW50YXRpb24gb2YgdGhlIGludGVnZXIgbWFz ay4gIFNvIHNldCB0aGUgY29ycmVjdCBpbnRlZ2VyIHR5cGUgYW5kCisJICAgICBjb252ZXJ0IHRv IGJvb2xlYW4gdmVjdG9yIG9uY2Ugd2UgaGF2ZSBhIHZlY3R5cGUuICAqLworCSAgc2NhbGFyX3R5 cGUgPSBUUkVFX1RZUEUgKGdpbXBsZV9jb25kX2xocyAoY29uZCkpOworCX0KICAgICAgIGVsc2UK IAlzY2FsYXJfdHlwZSA9IFRSRUVfVFlQRSAoZ2ltcGxlX2dldF9saHMgKHN0bXQpKTsKIApAQCAt MTQzMzksMTIgKzE0NTY4LDE4IEBAIHZlY3RfZ2V0X3ZlY3Rvcl90eXBlc19mb3Jfc3RtdCAodmVj X2luZm8gKnZpbmZvLCBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywKIAkJCSAgICAgImdldCB2ZWN0 eXBlIGZvciBzY2FsYXIgdHlwZTogJVRcbiIsIHNjYWxhcl90eXBlKTsKIAl9CiAgICAgICB2ZWN0 eXBlID0gZ2V0X3ZlY3R5cGVfZm9yX3NjYWxhcl90eXBlICh2aW5mbywgc2NhbGFyX3R5cGUsIGdy b3VwX3NpemUpOworCiAgICAgICBpZiAoIXZlY3R5cGUpCiAJcmV0dXJuIG9wdF9yZXN1bHQ6OmZh aWx1cmVfYXQgKHN0bXQsCiAJCQkJICAgICAgICJub3QgdmVjdG9yaXplZDoiCiAJCQkJICAgICAg ICIgdW5zdXBwb3J0ZWQgZGF0YS10eXBlICVUXG4iLAogCQkJCSAgICAgICBzY2FsYXJfdHlwZSk7 CiAKKyAgICAgIC8qIElmIHdlIHdlcmUgYSBnY29uZCwgY29udmVydCB0aGUgcmVzdWx0aW5nIHR5 cGUgdG8gYSB2ZWN0b3IgYm9vbGVhbiB0eXBlIG5vdworCSB0aGF0IHdlIGhhdmUgdGhlIGNvcnJl Y3QgaW50ZWdlciBtYXNrIHR5cGUuICAqLworICAgICAgaWYgKGNvbmQpCisJdmVjdHlwZSA9IHRy dXRoX3R5cGVfZm9yICh2ZWN0eXBlKTsKKwogICAgICAgaWYgKGR1bXBfZW5hYmxlZF9wICgpKQog CWR1bXBfcHJpbnRmX2xvYyAoTVNHX05PVEUsIHZlY3RfbG9jYXRpb24sICJ2ZWN0eXBlOiAlVFxu IiwgdmVjdHlwZSk7CiAgICAgfQo= --_002_VI1PR08MB5325931CD930AEBBA5D27C7DFF8FAVI1PR08MB5325eurp_--