From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 31453 invoked by alias); 30 Jun 2015 08:16:16 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 31435 invoked by uid 89); 30 Jun 2015 08:16:16 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.2 required=5.0 tests=AWL,BAYES_50,RCVD_IN_DNSWL_NONE,SPF_HELO_PASS,SPF_PASS autolearn=ham version=3.3.2 X-HELO: na01-bl2-obe.outbound.protection.outlook.com Received: from mail-bl2on0090.outbound.protection.outlook.com (HELO na01-bl2-obe.outbound.protection.outlook.com) (65.55.169.90) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-SHA256 encrypted) ESMTPS; Tue, 30 Jun 2015 08:16:12 +0000 Received: from BY2FFO11FD019.protection.gbl (10.1.14.33) by BY2FFO11HUB011.protection.gbl (10.1.15.222) with Microsoft SMTP Server (TLS) id 15.1.201.10; Tue, 30 Jun 2015 08:16:05 +0000 Authentication-Results: spf=pass (sender IP is 149.199.60.100) smtp.mailfrom=xilinx.com; gcc.gnu.org; dkim=none (message not signed) header.d=none; Received-SPF: Pass (protection.outlook.com: domain of xilinx.com designates 149.199.60.100 as permitted sender) receiver=protection.outlook.com; client-ip=149.199.60.100; helo=xsj-pvapsmtpgw02; Received: from xsj-pvapsmtpgw02 (149.199.60.100) by BY2FFO11FD019.mail.protection.outlook.com (10.1.14.107) with Microsoft SMTP Server (TLS) id 15.1.201.10 via Frontend Transport; Tue, 30 Jun 2015 08:16:05 +0000 Received: from unknown-38-66.xilinx.com ([149.199.38.66]:48017 helo=xsj-pvapsmtp01) by xsj-pvapsmtpgw02 with esmtp (Exim 4.63) (envelope-from ) id 1Z9qi5-0007ul-2o; Tue, 30 Jun 2015 01:16:05 -0700 Received: from [127.0.0.1] (helo=xsj-smtp-dlp1.xlnx.xilinx.com) by xsj-pvapsmtp01 with esmtp (Exim 4.63) (envelope-from ) id 1Z9qi4-00088u-Sr; Tue, 30 Jun 2015 01:16:04 -0700 Received: from xsj-pvapsmtp01 (smtp2.xilinx.com [149.199.38.66]) by xsj-smtp-dlp1.xlnx.xilinx.com (8.13.8/8.13.1) with ESMTP id t5U8FbIj018151; Tue, 30 Jun 2015 01:15:38 -0700 Received: from [172.22.159.26] (helo=XAP-PVEXCAS02.xlnx.xilinx.com) by xsj-pvapsmtp01 with esmtp (Exim 4.63) (envelope-from ) id 1Z9qi3-00087O-36; Tue, 30 Jun 2015 01:16:03 -0700 Received: from XAP-PVEXMBX02.xlnx.xilinx.com ([fe80::6c95:7dae:8014:5ca1]) by XAP-PVEXCAS02.xlnx.xilinx.com ([::1]) with mapi id 14.03.0195.001; Tue, 30 Jun 2015 16:16:02 +0800 From: Ajit Kumar Agarwal To: "law@redhat.com" , GCC Patches CC: Vinod Kathail , Shail Aditya Gupta , Vidhumouli Hunsigida , "Nagaraju Mekala" Subject: [Patch,tree-optimization]: Add new path Splitting pass on tree ssa representation Date: Tue, 30 Jun 2015 08:34:00 -0000 Message-ID: <37378DC5BCD0EE48BA4B082E0B55DFAA41F3F56C@XAP-PVEXMBX02.xlnx.xilinx.com> Content-Type: multipart/mixed; boundary="_002_37378DC5BCD0EE48BA4B082E0B55DFAA41F3F56CXAPPVEXMBX02xln_" MIME-Version: 1.0 X-RCIS-Action: ALLOW X-EOPAttributedMessage: 0 X-Microsoft-Exchange-Diagnostics: 1;BY2FFO11FD019;1:CdD4MUQ5uUyrWrZPjRG+qQA7BGIjyuMr5K7WCkRxM9Ndop1FR2QFaQW0bpQESRbUvcIJszCqsxlKi3r3B//gurcYMDJsAbDsc5CN4DcmTMENUtjA7/ktppQiajlJTwVs+9XM0b0fQUqluu00PygWesGwaiSBUDqPL+4E+cuLXnjqPcNQZmmULr/pbzOXD2ae3gQ5NE/E6REU69SQvxJPXwgxvbTBqbDU6jtCm0LsP93JVRPtobSoCM241t9XE7vNlPHeoMWKBtHiAFK9wziTKNOsLJcgu6dhALcwC7jqvvWOs7xSczV2N9gXe/TvZbqT X-Forefront-Antispam-Report: CIP:149.199.60.100;CTRY:US;IPV:NLI;EFV:NLI;SFV:NSPM;SFS:(10009020)(979002)(6009001)(2980300002)(438002)(189002)(199003)(377424004)(54534003)(6806004)(54356999)(99936001)(189998001)(46102003)(107886002)(5003600100002)(5001960100002)(92566002)(50986999)(568964001)(229853001)(84326002)(2930100002)(5260100001)(2920100001)(2900100001)(4610100001)(87936001)(55846006)(19580395003)(19580405001)(2656002)(106466001)(63266004)(102836002)(5890100001)(5250100002)(2501003)(5001770100001)(15975445007)(33656002)(77156002)(86362001)(62966003)(575784001)(512954002)(142933001)(2004002)(107986001)(4001430100001)(969003)(989001)(999001)(1009001)(1019001);DIR:OUT;SFP:1101;SCL:1;SRVR:BY2FFO11HUB011;H:xsj-pvapsmtpgw02;FPR:;SPF:Pass;MLV:ovrnspm;MX:1;A:1;PTR:unknown-60-100.xilinx.com,xapps1.xilinx.com;LANG:en; X-Microsoft-Exchange-Diagnostics: 1;BY2FFO11HUB011;2:GAmhGORpDfNtZfzTHxbMBy9tqHqLW2s31HgsH651v6aWGOn7PIjcFRlp74loU0xc;3:p+R9LAEmMEqMUyZ/lETYtPFZYWzGdQausdDuEaubc49q4pnHRWHv0jJj6u8cjFxH9PuM6BnQr6Ksxl9Ze8EGfckjRfis79cBbAeOe4co3pZIIlHr9d45a7mE0wnWe7lK8GhS9qJIVZj090sYeiTOb9GhYDv6lPqK6DefHnVHbvg9nLzEk+QZIoJa8Zksv4olJZpovdP2Tye4wRcOleV2TEE4/llBO0yUVy/SaZmLe6dlxT9/qXkpBxm4o7I762Lj;20:Ad0flcvU6/p33tJwosQapoVSuaIJBj4PqUZGIYrHxB45v8anPKxRe1sfmIpiYME28rfi7R8FEFrWuLC8jSvIWT5Lg9JPw1vp1S0EVt6BJLOHfu7cmvh+LMBE1HFiTQ2j5Iw0P7qE7D5rkaO+HilKTXYo51T5aNHv2KX2ILShWaJbRmpqeIZOuXbq4uuI96WSOJho8ktLf/mvYuLXFnjtGSPf7SdKzzLHR2zezHGewjTqP69MB8p43Ohh22kAPHMBdQQJhDRElpl8iTaDhAyd+qk+N0bH9L8opsGB6CxQ45silJYQ5lFR2T0wIMyrWT22gjjXUxsAObZdX/97t+Ec1V8G2FUlYFsiKXwWu5dCPiGr8uLwLtxhECV8iCX9tH9771XU7gURfi560hKYfjhwgYafMMjesZpGcF4mcLgeeNeGHE+zxleXqx5IAUaTzdFu09l8vAWTndXZAH7vUbx5L8LiNlW47GHqMc0Gp41Ab+Dkt6dF2mM6A+Ut0Y2nzXxn X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:BY2FFO11HUB011; X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(601004)(5005006)(3002001);SRVR:BY2FFO11HUB011;BCL:0;PCL:0;RULEID:;SRVR:BY2FFO11HUB011; X-Microsoft-Exchange-Diagnostics: 1;BY2FFO11HUB011;4:G9MOHXiu9qzDD7joss2/7TbktI0i2cQIF+MlnlKO+R1pqeZz0mRFNYxdZZee6RuTaH1H/wK43ArAQLDPbx+PVdkRxkz01y0l1MIk4HRxOUL51ZMNSG+vbWdujrrUpqlEoTZuE3wQF9HnsiOUpcK/0PTZuD30c3kpGx9XRtUsxsZAv4+/XvjxQP/WUu10kXor5tssiA7b8EKIEwu1N7joczguGAaqGlYmwLhxxRtO5uWDiQFGcNLLwxqy5P2n4hZYmOZKIcMBBUrzDtJBDVl+QCPitClaLUC2Y2SAlxoTsw4= X-Forefront-PRVS: 06237E4555 X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1;BY2FFO11HUB011;23:jiG1N5Th459IOGp81931Sg+xAMPoUgFdVRygLFqD?= =?us-ascii?Q?LdAURR9PAxSk7sk7kgPoCbkyWanVKIjFQlGpNoDYzmYajj8fwP7XdLur+MF9?= =?us-ascii?Q?ASe4lt6Vi4Cm1Pz8e481iJCij2fWDSHL24Ra5d8uIS9VFEdt1Bp4i62lL/Rl?= =?us-ascii?Q?hGLpKAp3skoQiwzZ9WcOS2wHs0BMgxcpCF+qV7srOTETAlKc5xORMif8g5zx?= =?us-ascii?Q?qqE2JUPEK8zdCbpVq88PWORwgwOq3BlLGWHrjflO7o+deSjwwtfG848Iqleh?= =?us-ascii?Q?YHm9Husb346pu3wyCNq02O5NSFVKipka3EPtWWEeA72Hii8SYh6efEnqA33k?= =?us-ascii?Q?JNsQkodyorXbN7F+6PeiiubmJ2hgbPYWPix6yssBD3Ynezo9e2RySMC6p2bk?= =?us-ascii?Q?R1uloWHxxYMUooB8jgvFJWWD67hvkagTPKSfht6Y2VqSMq5SUOeRqriIUhmx?= =?us-ascii?Q?ZlO4yZe3Ey2tq/wqU0Fasqjd7cU13YleXGiOf0c1rDHEz8MMCY52TvBA0pdr?= =?us-ascii?Q?SnFRNjouZpFtXE7bSljBOs4UEIgprceo+mSt+rY4/orkF3/6KO2jXOD2Fya2?= =?us-ascii?Q?na8Ts9pBI7T0XGWvsnZyOzfekZPYG85mqWx26ZYB9AlxpxCIlCpMXCzsCX3V?= =?us-ascii?Q?TSmzFf6MBIuMxfNNimfCiKrDBk/mlTu3XaLTXhs9yjWtoOhdZxvnZe6piwW3?= =?us-ascii?Q?EWv9FQrZxpJ39jng7ajYMyIetVu0TNZI4vpSv+uvlHUCb7XGWkFy2IwEycrq?= =?us-ascii?Q?j+swpoRtG9eIpPtxEj220sSvTP46sq91zgZJ8b8Rd1N0F451ycXbe/VeFcti?= =?us-ascii?Q?qD+HFZsybtrxVxzn2utwMjywDKwilAFgKVorDATiCvhiUr/bqbOu2ptkhSIl?= =?us-ascii?Q?Uxuh6B5MArHStZuA/N0qz1zgtAW8KAKuVeDhdZe4vqaBHqck8xZEz432mjlu?= =?us-ascii?Q?rS6DQkJGkZHjPuO7FuGMOeprjm0W5sZEs4ie4yMegg9paHlTyCTSXf0qWV7v?= =?us-ascii?Q?NnYdZrFoTcSWpnTIp45QHQTbbc7yuZM1bzuNchiYaYn6WY6C+kJSY2fdK/6L?= =?us-ascii?Q?0cVTQ6abYQcTdnHk9IJ93weJI055KDRvrYD5Trc8Yb4HBeorQtp4KneO52Dx?= =?us-ascii?Q?sdUu7trNNQrtGwOxRQbJ/Ug5Ue878rnevVxqHMoN7OgghYzNhjHpMjzXoFBh?= =?us-ascii?Q?dktHq421/eYBLQiXQEWoHVDiPHEeDnpWlU6aG7K6r9EvDiYct2dJWCBsaMFg?= =?us-ascii?Q?ot5ncMMULq1bqlp332by0wTrFYHUalUhSB5uJk/lY2MdywFhSUS4/c6oVJ4S?= =?us-ascii?Q?MXQMlGHlaWIplMm9ytQXCnfqOIvjrWWCTrLEtpaEzlQPE7hjgwmMgTTLdGkx?= =?us-ascii?Q?K/IEMw=3D=3D?= X-Microsoft-Exchange-Diagnostics: 1;BY2FFO11HUB011;5:EYQrrZjeHzxGF+XhsIT/3YjrUqZdD/VGgI89c2sDmHOx5pBVXi0SkKSyXkO29Tdoa03CtRs8xA/TUhgmTmNg7xuxm+3dd7nEShiKzHRHSqwZ1kJ/lCoPJ5wYA/RXqv+pdd97oEh1tzmPjq2LUX3SkA==;24:naX1z/M4LEC9H6nPlNTk1a/RYKqP2y6b0vvrFb6Imn6vyosm8CT2l1LYlFXZPl2TnRpGeV0CXCc3oKaamq8AafdfTC7bgDs10V+crMOP0ow= X-OriginatorOrg: xilinx.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 30 Jun 2015 08:16:05.7486 (UTC) X-MS-Exchange-CrossTenant-Id: 657af505-d5df-48d0-8300-c31994686c5c X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=657af505-d5df-48d0-8300-c31994686c5c;Ip=[149.199.60.100];Helo=[xsj-pvapsmtpgw02] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BY2FFO11HUB011 X-SW-Source: 2015-06/txt/msg02159.txt.bz2 --_002_37378DC5BCD0EE48BA4B082E0B55DFAA41F3F56CXAPPVEXMBX02xln_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Content-length: 24306 All: The below patch added a new path Splitting optimization pass on SSA represe= ntation. The Path Splitting optimization Pass moves the join block of if-then-else same as loop latch to its predece= ssors and get merged with the predecessors Preserving the SSA representation. The patch is tested for Microblaze and i386 target. The EEMBC/Mibench bench= marks is run with the Microblaze target And the performance gain of 9.15% and rgbcmy01_lite(EEMBC benchmarks). The = Deja GNU tests is run for Mircroblaze=20 Target and no regression is seen for Microblaze target and the new testcase= attached are passed. For i386 bootstrapping goes through fine and the Spec cpu2000 benchmarks is= run with this patch. Following observation were seen with spec cpu2000 benchmarks.=20 Ratio of path splitting change vs Ratio of not having path splitting change= is 3653.353 vs 3652.14 for INT benchmarks. Ratio of path splitting change vs Ratio of not having path splitting change= is 4353.812 vs 4345.351 for FP benchmarks. Based on comments from RFC patch following changes were done. 1. Added a new pass for path splitting changes. 2. Placed the new path Splitting Optimization pass before the copy propaga= tion pass. 3. The join block same as the Loop latch is wired into its predecessors so = that the CFG Cleanup pass will merge the blocks Wired together. 4. Copy propagation routines added for path splitting changes is not needed= as suggested by Jeff. They are removed in the patch as The copy propagation in the copied join blocks will be done by the existing= copy propagation pass and the update ssa pass. 5. Only the propagation of phi results of the join block with the phi argum= ent is done which will not be done by the existing update_ssa Or copy propagation pass on tree ssa representation. 6. Added 2 tests. a) compilation check tests. b) execution tests. 7. Refactoring of the code for the feasibility check and finding the join b= lock same as loop latch node. [Patch,tree-optimization]: Add new path Splitting pass on tree ssa repr= esentation. =20=20=20=20 Added a new pass on path splitting on tree SSA representation. The path splitting optimization does the CFG transformation of join block of the if-then-else same as the loop latch node is moved and merged with the predecessor blocks after preserving the SSA representation. =20=20=20=20 ChangeLog: 2015-06-30 Ajit Agarwal =20=20=20=20 * gcc/Makefile.in: Add the build of the new file tree-ssa-path-split.c * gcc/common.opt: Add the new flag ftree-path-split. * gcc/opts.c: Add an entry for Path splitting pass with optimization flag greater and equal to O2. * gcc/passes.def: Enable and add new pass path splitting. * gcc/timevar.def: Add the new entry for TV_TREE_PATH_SPLIT. * gcc/tree-pass.h: Extern Declaration of make_pass_path_split. * gcc/tree-ssa-path-split.c: New file for path splitting pass. * gcc/testsuite/gcc.dg/tree-ssa/path-split-2.c: New testcase. * gcc/testsuite/gcc.dg/path-split-1.c: New testcase. =20=20=20=20 Signed-off-by:Ajit Agarwal ajitkum@xilinx.com. gcc/Makefile.in | 1 + gcc/common.opt | 4 + gcc/opts.c | 1 + gcc/passes.def | 1 + gcc/testsuite/gcc.dg/path-split-1.c | 65 ++++ gcc/testsuite/gcc.dg/tree-ssa/path-split-2.c | 62 ++++ gcc/timevar.def | 1 + gcc/tree-pass.h | 1 + gcc/tree-ssa-path-split.c | 462 +++++++++++++++++++++++= ++++ 9 files changed, 598 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/path-split-1.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/path-split-2.c create mode 100644 gcc/tree-ssa-path-split.c diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 5f9261f..35ac363 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1476,6 +1476,7 @@ OBJS =3D \ tree-vect-slp.o \ tree-vectorizer.o \ tree-vrp.o \ + tree-ssa-path-split.o \ tree.o \ valtrack.o \ value-prof.o \ diff --git a/gcc/common.opt b/gcc/common.opt index e104269..c63b100 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -2328,6 +2328,10 @@ ftree-vrp Common Report Var(flag_tree_vrp) Init(0) Optimization Perform Value Range Propagation on trees =20 +ftree-path-split +Common Report Var(flag_tree_path_split) Init(0) Optimization +Perform Path Splitting + funit-at-a-time Common Report Var(flag_unit_at_a_time) Init(1) Optimization Compile whole compilation unit at a time diff --git a/gcc/opts.c b/gcc/opts.c index 8a16116..31947ff 100644 --- a/gcc/opts.c +++ b/gcc/opts.c @@ -508,6 +508,7 @@ static const struct default_options default_options_tab= le[] =3D { OPT_LEVELS_2_PLUS, OPT_fisolate_erroneous_paths_dereference, NULL, 1= }, { OPT_LEVELS_2_PLUS, OPT_fipa_ra, NULL, 1 }, { OPT_LEVELS_2_PLUS, OPT_flra_remat, NULL, 1 }, + { OPT_LEVELS_2_PLUS, OPT_ftree_path_split, NULL, 1 }, =20 /* -O3 optimizations. */ { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 }, diff --git a/gcc/passes.def b/gcc/passes.def index c0ddee4..43618eb 100644 --- a/gcc/passes.def +++ b/gcc/passes.def @@ -155,6 +155,7 @@ along with GCC; see the file COPYING3. If not see NEXT_PASS (pass_ccp); /* After CCP we rewrite no longer addressed locals into SSA form if possible. */ + NEXT_PASS (pass_path_split); NEXT_PASS (pass_copy_prop); NEXT_PASS (pass_complete_unrolli); NEXT_PASS (pass_phiprop); diff --git a/gcc/testsuite/gcc.dg/path-split-1.c b/gcc/testsuite/gcc.dg/pat= h-split-1.c new file mode 100644 index 0000000..075dc87 --- /dev/null +++ b/gcc/testsuite/gcc.dg/path-split-1.c @@ -0,0 +1,65 @@ +/* { dg-do run } */ +/* { dg-options "-O2 " } */ + +#include +#include + +#define RGBMAX 255 + +int +test() +{ + int i, Pels; + unsigned char sum =3D 0; + unsigned char xr, xg, xb; + unsigned char xc, xm, xy, xk; + unsigned char *ReadPtr, *EritePtr; + + ReadPtr =3D ( unsigned char *) malloc (sizeof (unsigned char) * 100); + EritePtr =3D ( unsigned char *) malloc (sizeof (unsigned char) * 100); + + for (i =3D 0; i < 100;i++) + { + ReadPtr[i] =3D 100 - i; + } + + for (i =3D 0; i < 100; i++) + { + xr =3D *ReadPtr++; + xg =3D *ReadPtr++; + xb =3D *ReadPtr++; + + xc =3D (unsigned char) (RGBMAX - xr); + xm =3D (unsigned char) (RGBMAX - xg); + xy =3D (unsigned char) (RGBMAX - xb); + + if (xc < xm) + { + xk =3D (unsigned char) (xc < xy ? xc : xy); + } + else + { + xk =3D (unsigned char) (xm < xy ? xm : xy); + } + + xc =3D (unsigned char) (xc - xk); + xm =3D (unsigned char) (xm - xk); + xy =3D (unsigned char) (xy - xk); + + *EritePtr++ =3D xc; + *EritePtr++ =3D xm; + *EritePtr++ =3D xy; + *EritePtr++ =3D xk; + sum +=3D *EritePtr; + } + return sum; +} + +int +main() +{ + if (test() !=3D 33) + abort(); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/tree-ssa/path-split-2.c b/gcc/testsuite/g= cc.dg/tree-ssa/path-split-2.c new file mode 100644 index 0000000..19f277c --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/path-split-2.c @@ -0,0 +1,62 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-path_split" } */ + +#include +#include + +#define RGBMAX 255 + +int +test() +{ + int i, Pels; + unsigned char sum =3D 0; + unsigned char xr, xg, xb; + unsigned char xc, xm, xy, xk; + unsigned char *ReadPtr, *EritePtr; + + ReadPtr =3D (unsigned char *) malloc (sizeof (unsigned char) * 100); + EritePtr =3D ( unsigned char *) malloc (sizeof (unsigned char) * 100); + + for (i =3D 0; i < 100;i++) + { + ReadPtr[i] =3D 100 - i; + } + + for (i =3D 0; i < 100; i++) + { + xr =3D *ReadPtr++; + xg =3D *ReadPtr++; + xb =3D *ReadPtr++; + + xc =3D ( unsigned char) (RGBMAX - xr); + xm =3D ( unsigned char) (RGBMAX - xg); + xy =3D ( unsigned char) (RGBMAX - xb); + + if (xc < xm) + { + xk =3D ( unsigned char) (xc < xy ? xc : xy); + } + else + { + xk =3D ( unsigned char) (xm < xy ? xm : xy); + } + + xc =3D (unsigned char) (xc - xk); + xm =3D (unsigned char) (xm - xk); + xy =3D (unsigned char) (xy - xk); + + *EritePtr++ =3D xc; + *EritePtr++ =3D xm; + *EritePtr++ =3D xy; + *EritePtr++ =3D xk; + sum +=3D *EritePtr; + } + return sum; +} + +/* { dg-final { scan-tree-dump "xc_[0-9][0-9]* -> { xc_[0-9][0-9]* }" "pat= h_split"} } */ +/* { dg-final { scan-tree-dump "xm_[0-9][0-9]* -> { xm_[0-9][0-9]* }" "pat= h_split"} } */ +/* { dg-final { scan-tree-dump "xy_[0-9][0-9]* -> { xy_[0-9][0-9]* }" "pat= h_split"} } */ +/* { dg-final { scan-tree-dump "Merging blocks" "path_split"} } */ +/* { dg-final { cleanup-tree-dump "path_split" } } */ diff --git a/gcc/timevar.def b/gcc/timevar.def index 711bbed..6217a8e 100644 --- a/gcc/timevar.def +++ b/gcc/timevar.def @@ -288,3 +288,4 @@ DEFTIMEVAR (TV_JIT_REPLAY , "replay of JIT client = activity") DEFTIMEVAR (TV_ASSEMBLE , "assemble JIT code") DEFTIMEVAR (TV_LINK , "link JIT code") DEFTIMEVAR (TV_LOAD , "load JIT result") +DEFTIMEVAR (TV_TREE_PATH_SPLIT , "tree path_split") diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h index 398ab83..e00639e 100644 --- a/gcc/tree-pass.h +++ b/gcc/tree-pass.h @@ -379,6 +379,7 @@ extern gimple_opt_pass *make_pass_iv_optimize (gcc::con= text *ctxt); extern gimple_opt_pass *make_pass_tree_loop_done (gcc::context *ctxt); extern gimple_opt_pass *make_pass_ch (gcc::context *ctxt); extern gimple_opt_pass *make_pass_ccp (gcc::context *ctxt); +extern gimple_opt_pass *make_pass_path_split (gcc::context *ctxt); extern gimple_opt_pass *make_pass_phi_only_cprop (gcc::context *ctxt); extern gimple_opt_pass *make_pass_build_ssa (gcc::context *ctxt); extern gimple_opt_pass *make_pass_build_alias (gcc::context *ctxt); diff --git a/gcc/tree-ssa-path-split.c b/gcc/tree-ssa-path-split.c new file mode 100644 index 0000000..3da7791 --- /dev/null +++ b/gcc/tree-ssa-path-split.c @@ -0,0 +1,462 @@ +/* Support routines for Path Splitting. + Copyright (C) 2015 Free Software Foundation, Inc. + Contributed by Ajit Kumar Agarwal . +=20 + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "flags.h" +#include "tree.h" +#include "stor-layout.h" +#include "calls.h" +#include "predict.h" +#include "vec.h" +#include "hashtab.h" +#include "hash-set.h" +#include "machmode.h" +#include "hard-reg-set.h" +#include "input.h" +#include "function.h" +#include "dominance.h" +#include "cfg.h" +#include "cfganal.h" +#include "basic-block.h" +#include "tree-ssa-alias.h" +#include "internal-fn.h" +#include "gimple-fold.h" +#include "tree-eh.h" +#include "gimple-expr.h" +#include "is-a.h" +#include "gimple.h" +#include "gimple-iterator.h" +#include "gimple-walk.h" +#include "gimple-ssa.h" +#include "tree-cfg.h" +#include "tree-phinodes.h" +#include "ssa-iterators.h" +#include "stringpool.h" +#include "tree-ssanames.h" +#include "tree-ssa-loop-manip.h" +#include "tree-ssa-loop-niter.h" +#include "tree-ssa-loop.h" +#include "tree-into-ssa.h" +#include "tree-ssa.h" +#include "tree-pass.h" +#include "tree-dump.h" +#include "gimple-pretty-print.h" +#include "diagnostic-core.h" +#include "intl.h" +#include "cfgloop.h" +#include "tree-scalar-evolution.h" +#include "tree-ssa-propagate.h" +#include "tree-chrec.h" +#include "tree-ssa-threadupdate.h" +#include "expr.h" +#include "insn-codes.h" +#include "optabs.h" +#include "tree-ssa-threadedge.h" +#include "wide-int.h" + +/* Replace_uses_phi function propagates the phi results with the + first phi argument into each of the copied join blocks wired into + its predecessors. This function is called from the replace_uses_phi=20 + to replace the uses of first phi arguments with the second + phi arguments in the next copy of join block. */ + +static void +replace_use_phi_operand1_with_operand2 (basic_block b, + tree use1, + tree use2) +{ + use_operand_p use; + ssa_op_iter iter; + gimple_stmt_iterator gsi; + + for (gsi =3D gsi_start_bb (b); !gsi_end_p (gsi);) + { + gimple stmt =3D gsi_stmt (gsi); + FOR_EACH_SSA_USE_OPERAND (use, stmt, iter, SSA_OP_USE) + { + tree tuse =3D USE_FROM_PTR (use); + if (use1 =3D=3D tuse || use1 =3D=3D NULL_TREE) + { + propagate_value (use, use2); + update_stmt(stmt); + } + } + gsi_next(&gsi); + } +} + +/* This function propagates the phi result into the use points with + the phi arguments. The join block is copied and wired into the + predecessors. Since the use points of the phi results will be same + in the each of the copy join blocks in the predecessors, it + propagates the phi arguments in the copy of the join blocks wired + into its predecessor. */ +=20 +static +void replace_uses_phi (basic_block b, basic_block temp_bb) +{ + gimple_seq phis =3D phi_nodes (b); + gimple phi =3D gimple_seq_first_stmt (phis); + tree def =3D gimple_phi_result (phi), use =3D gimple_phi_arg_def (phi,0); + tree use2 =3D gimple_phi_arg_def (phi,1); + + if (virtual_operand_p (def)) + { + imm_use_iterator iter; + use_operand_p use_p; + gimple stmt; + + FOR_EACH_IMM_USE_STMT (stmt, iter, def) + FOR_EACH_IMM_USE_ON_STMT (use_p, iter) + SET_USE (use_p, use); + if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def)) + SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use) =3D 1; + } + else + replace_uses_by (def, use); + replace_use_phi_operand1_with_operand2 (temp_bb, use, use2); +} + +/* Returns true if the block bb has label or call statements. + Otherwise return false. */ + +static bool +is_block_has_label_call (basic_block bb) +{ + gimple_stmt_iterator gsi; + + for (gsi =3D gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) + { + gimple stmt =3D gsi_stmt(gsi); + if (dyn_cast (stmt)) + { + return true; + } + if (is_gimple_call (stmt)) + return true; + } + return false; +} + +/* This function performs the feasibility tests for path splitting + to perform. Return false if the feasibility for path splitting + is not done and returns true if the feasbility for path splitting + is done. Following feasibility tests are performed. +=20 + 1. Return false if the join block has call gimple statements. + 2. Return false if the join block has rhs casting for assign + gimple statements. + 3. If the number of phis is greater than 1 or the phi node in + the join block has virtual operand return false. + 4. Return false if the number of sequential statements is + greater than 2. + 5. If the predecessors blocks has labels and call statements + return false. + 6. If the phi result in the phi node of the join block is not + used inside the same join block return false. + 7. Otherwise returns true. */ + +static bool +is_feasible_path_splitting (basic_block join_node, basic_block pred1, + basic_block pred2) +{ + int num_stmt =3D 0, num_phis =3D 0; + gimple_stmt_iterator psi, gsi; + + for (gsi =3D gsi_start_bb (join_node); !gsi_end_p (gsi); gsi_next (&gsi)) + { + gimple stmt =3D gsi_stmt(gsi); + + if (gimple_assign_cast_p (stmt)) + return false; + + if (is_gimple_call (stmt)) + return false; + + if (!is_gimple_debug(stmt)) + { + num_stmt++; + } + } + + if (pred1 && pred2 && (num_stmt > 2)) + { + bool found_virtual_result =3D false; + + for (psi =3D gsi_start_phis (join_node); !gsi_end_p (psi); ) + { + use_operand_p use_p; + imm_use_iterator iter; + gimple stmt =3D gsi_stmt(psi); + + if (!virtual_operand_p (gimple_phi_result (stmt))) + num_phis++; + else + found_virtual_result =3D true; + + FOR_EACH_IMM_USE_FAST (use_p, iter, gimple_phi_result (stmt)) + { + gimple use_stmt =3D USE_STMT (use_p); + + if (gimple_bb (use_stmt) !=3D join_node) + return false; + } + + gsi_next(&psi); + } + + if ((num_phis >1) || found_virtual_result) + return false; + + if(is_block_has_label_call(pred1) || is_block_has_label_call(pred2)) + return false; + + return true; + } + return false; +} + +/* Update the statements in the basic block with the basic + basic block. */ + +static void +update_stmt_bb(basic_block b) +{ + gimple_stmt_iterator gsi; + for(gsi =3D gsi_start_bb(b); !gsi_end_p(gsi); gsi_next(&gsi)) + { + gimple stmt =3D gsi_stmt(gsi); + gimple_set_bb(stmt,b); + } +} + +/* This function gets the join blocks same as the source + node of the loop latch nodes and the predecessors of + the join block is updated in the pred1 and pred2 passed + as the reference arguments into the function. Return + the join block. */ + +static basic_block +get_join_blk_same_as_loop_latch (basic_block bb, + basic_block &pred1, + basic_block &pred2) +{ + vec bbs; + basic_block bb1; + unsigned int i; + edge_iterator ei; + edge e1; + bool found =3D false ,found1; + bbs =3D get_all_dominated_blocks (CDI_DOMINATORS, + bb ); + FOR_EACH_VEC_ELT (bbs, i, bb1) + { + found1 =3D false; + FOR_EACH_EDGE (e1, ei, bb->succs) + { + if ( bb1 =3D=3D e1->dest) + { + found =3D true; + found1 =3D true; + } + } + if (!found1 && found) + { + found =3D false; + FOR_EACH_EDGE (e1, ei, bb1->succs) + { + if (e1->flags & (EDGE_DFS_BACK)) + found =3D true; + } + + if (found && EDGE_COUNT(bb1->preds) =3D=3D 2) + { + unsigned int k =3D 0; + FOR_EACH_EDGE (e1, ei, bb1->preds) + { + if ((e1->flags & (EDGE_DFS_BACK))) + continue; + + if ( k =3D=3D 1) + { + if (single_succ_p(e1->src) && + single_succ_edge (e1->src)->flags & EDGE_FALLTHRU) + { + pred2 =3D e1->src; + } + } + else + { + if (single_succ_p(e1->src) && + single_succ_edge (e1->src)->flags & EDGE_FALLTHRU) + { + pred1 =3D e1->src; + } + } + k++; + } + bbs.release(); + return bb1; + } + } + } + bbs.release(); + return NULL; +} + +/* This is the core function to perform path splitting. The join + same as the source of the loop latch node is identified along + with their predecessors. Based on the feasibility tests for + path splitting the path splitting is performed by wiring the + copy of join blocks into the predecessors and propagating the phi + result with the corresponding phi arguments into each of the copy + of join blocks wired with the original predecessors of the join + block. +=20 + The tree-cfg-cleanup will merge the blocks in the predecessors + path and the update-ssa will update the ssa representation after + the path splitting is performed. */ +=20 +static void +perform_path_splitting (basic_block bb) +{ + basic_block pred1 =3D NULL, pred2 =3D NULL, join_block =3D NULL; + + join_block =3D get_join_blk_same_as_loop_latch (bb, pred1, pred2); + + if (join_block &&=20 + is_feasible_path_splitting (join_block, pred1, pred2)) + { + basic_block new_bb1 =3D NULL, new_bb2 =3D NULL; + gimple_stmt_iterator last; + basic_block temp_bb =3D NULL; + edge_iterator ei; + edge e1; + + temp_bb =3D duplicate_block (join_block, NULL, NULL); + + FOR_EACH_EDGE (e1, ei, pred1->succs) + new_bb1 =3D split_edge (e1); + + FOR_EACH_EDGE (e1, ei, pred2->succs) + new_bb2 =3D split_edge (e1); + + last =3D gsi_start_bb (new_bb1); + gsi_insert_seq_after (&last, bb_seq (join_block), GSI_NEW_STMT); + last =3D gsi_start_bb (new_bb2); + gsi_insert_seq_after (&last, bb_seq (temp_bb), GSI_NEW_STMT); + update_stmt_bb (new_bb1); + update_stmt_bb (new_bb2); + + replace_uses_phi (join_block, new_bb2); + + set_bb_seq (join_block, NULL); + set_bb_seq(temp_bb,NULL); + delete_basic_block (temp_bb); + return; + } +} + +static unsigned int +execute_path_split (void) +{ + basic_block bb; + + loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS); + initialize_original_copy_tables(); + + calculate_dominance_info (CDI_DOMINATORS); + calculate_dominance_info (CDI_POST_DOMINATORS); + + mark_dfs_back_edges (); + + FOR_EACH_BB_FN (bb, cfun) + { + gimple last; + + /* We only care about blocks ending in a COND_EXPR. */ + + last =3D gsi_stmt (gsi_last_bb (bb)); + + /* We're basically looking for a switch or any kind of conditional with + integral or pointer type arguments. Note the type of the second + argument will be the same as the first argument, so no need to + check it explicitly. */ + if ((last && (gimple_code (last) =3D=3D GIMPLE_COND + && TREE_CODE (gimple_cond_lhs (last)) =3D=3D SSA_NAME + && (INTEGRAL_TYPE_P (TREE_TYPE (gimple_cond_lhs (last))) + || POINTER_TYPE_P (TREE_TYPE (gimple_cond_lhs (last)))) + && (TREE_CODE (gimple_cond_rhs (last)) =3D=3D SSA_NAME + || is_gimple_min_invariant (gimple_cond_rhs (last)))))) + { + + if (gimple_code(last) =3D=3D GIMPLE_COND) + { + perform_path_splitting (bb); + } + } + } + + loop_optimizer_finalize (); + free_original_copy_tables (); + free_dominance_info (CDI_DOMINATORS); + free_dominance_info (CDI_POST_DOMINATORS); + return 0; +} + +namespace { + +const pass_data pass_data_path_split =3D +{ + GIMPLE_PASS, /* type */ + "path_split", /* name */ + OPTGROUP_NONE, /* optinfo_flags */ + TV_TREE_PATH_SPLIT, /* tv_id */ + PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + ( TODO_cleanup_cfg | TODO_update_ssa ), /* todo_flags_finish */ +}; + +class pass_path_split : public gimple_opt_pass +{ + public: + pass_path_split (gcc::context *ctxt) + : gimple_opt_pass (pass_data_path_split, ctxt) + {} +=20 + /* opt_pass methods: */ + opt_pass * clone () { return new pass_path_split (m_ctxt); } + virtual bool gate (function *) { return flag_tree_path_split !=3D 0; } + virtual unsigned int execute (function *) { return execute_path_split (= ); } +=20 +}; // class pass_path_split + +} // anon namespace + +gimple_opt_pass * +make_pass_path_split (gcc::context *ctxt) +{ + return new pass_path_split (ctxt); +} --=20 1.8.2.1 Thanks & Regards Ajit --_002_37378DC5BCD0EE48BA4B082E0B55DFAA41F3F56CXAPPVEXMBX02xln_ Content-Type: application/octet-stream; name="0001-Patch-tree-optimization-Add-new-path-Splitting-pass-.patch" Content-Description: 0001-Patch-tree-optimization-Add-new-path-Splitting-pass-.patch Content-Disposition: attachment; filename="0001-Patch-tree-optimization-Add-new-path-Splitting-pass-.patch"; size=22044; creation-date="Tue, 30 Jun 2015 08:04:31 GMT"; modification-date="Tue, 30 Jun 2015 07:51:59 GMT" Content-Transfer-Encoding: base64 Content-length: 29882 RnJvbSA2NzZhM2ZiNjRiNWIxM2E2YWUwZTRhMjJkYWRjZTg1YThiZjgwYmFl IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBaml0IEt1bWFyIEFn YXJ3YWwgPGFqaXRrdW1AeGdvbGludXgyLnhpbGlueC5jb20+CkRhdGU6IFR1 ZSwgMzAgSnVuIDIwMTUgMDk6Mzk6MjkgKzAyMDAKU3ViamVjdDogW1BBVENI XSBbUGF0Y2gsdHJlZS1vcHRpbWl6YXRpb25dOiBBZGQgbmV3IHBhdGggU3Bs aXR0aW5nIHBhc3Mgb24KIHRyZWUgc3NhIHJlcHJlc2VudGF0aW9uLgoKQWRk ZWQgYSBuZXcgcGFzcyBvbiBwYXRoIHNwbGl0dGluZyBvbiB0cmVlIFNTQSBy ZXByZXNlbnRhdGlvbi4gVGhlIHBhdGgKc3BsaXR0aW5nIG9wdGltaXphdGlv biBkb2VzIHRoZSBDRkcgdHJhbnNmb3JtYXRpb24gb2Ygam9pbiBibG9jayBv ZiB0aGUKaWYtdGhlbi1lbHNlIHNhbWUgYXMgdGhlIGxvb3AgbGF0Y2ggbm9k ZSBpcyBtb3ZlZCBhbmQgbWVyZ2VkIHdpdGggdGhlCnByZWRlY2Vzc29yIGJs b2NrcyBhZnRlciBwcmVzZXJ2aW5nIHRoZSBTU0EgcmVwcmVzZW50YXRpb24u CgpDaGFuZ2VMb2c6CjIwMTUtMDYtMzAgIEFqaXQgQWdhcndhbCAgPGFqaXRr dW1AeGlsaW54LmNvbT4KCgkqIGdjYy9NYWtlZmlsZS5pbjogQWRkIHRoZSBi dWlsZCBvZiB0aGUgbmV3IGZpbGUKCXRyZWUtc3NhLXBhdGgtc3BsaXQuYwoJ KiBnY2MvY29tbW9uLm9wdDogQWRkIHRoZSBuZXcgZmxhZyBmdHJlZS1wYXRo LXNwbGl0LgoJKiBnY2Mvb3B0cy5jOiBBZGQgYW4gZW50cnkgZm9yIFBhdGgg c3BsaXR0aW5nIHBhc3MKCXdpdGggb3B0aW1pemF0aW9uIGZsYWcgZ3JlYXRl ciBhbmQgZXF1YWwgdG8gTzIuCgkqIGdjYy9wYXNzZXMuZGVmOiBFbmFibGUg YW5kIGFkZCBuZXcgcGFzcyBwYXRoIHNwbGl0dGluZy4KCSogZ2NjL3RpbWV2 YXIuZGVmOiBBZGQgdGhlIG5ldyBlbnRyeSBmb3IgVFZfVFJFRV9QQVRIX1NQ TElULgoJKiBnY2MvdHJlZS1wYXNzLmg6IEV4dGVybiBEZWNsYXJhdGlvbiBv ZiBtYWtlX3Bhc3NfcGF0aF9zcGxpdC4KCSogZ2NjL3RyZWUtc3NhLXBhdGgt c3BsaXQuYzogTmV3IGZpbGUgZm9yIHBhdGggc3BsaXR0aW5nIHBhc3MuCgkq IGdjYy90ZXN0c3VpdGUvZ2NjLmRnL3RyZWUtc3NhL3BhdGgtc3BsaXQtMi5j OiBOZXcgdGVzdGNhc2UuCgkqIGdjYy90ZXN0c3VpdGUvZ2NjLmRnL3BhdGgt c3BsaXQtMS5jOiBOZXcgdGVzdGNhc2UuCgpTaWduZWQtb2ZmLWJ5OkFqaXQg QWdhcndhbCBhaml0a3VtQHhpbGlueC5jb20uCi0tLQogZ2NjL01ha2VmaWxl LmluICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwogZ2Nj L2NvbW1vbi5vcHQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg IDQgKwogZ2NjL29wdHMuYyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgfCAgIDEgKwogZ2NjL3Bhc3Nlcy5kZWYgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgIDEgKwogZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcv cGF0aC1zcGxpdC0xLmMgICAgICAgICAgfCAgNjUgKysrKwogZ2NjL3Rlc3Rz dWl0ZS9nY2MuZGcvdHJlZS1zc2EvcGF0aC1zcGxpdC0yLmMgfCAgNjIgKysr KwogZ2NjL3RpbWV2YXIuZGVmICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgIDEgKwogZ2NjL3RyZWUtcGFzcy5oICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDEgKwogZ2NjL3RyZWUtc3NhLXBhdGgtc3BsaXQu YyAgICAgICAgICAgICAgICAgICAgfCA0NjIgKysrKysrKysrKysrKysrKysr KysrKysrKysrCiA5IGZpbGVzIGNoYW5nZWQsIDU5OCBpbnNlcnRpb25zKCsp CiBjcmVhdGUgbW9kZSAxMDA2NDQgZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvcGF0 aC1zcGxpdC0xLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBnY2MvdGVzdHN1aXRl L2djYy5kZy90cmVlLXNzYS9wYXRoLXNwbGl0LTIuYwogY3JlYXRlIG1vZGUg MTAwNjQ0IGdjYy90cmVlLXNzYS1wYXRoLXNwbGl0LmMKCmRpZmYgLS1naXQg YS9nY2MvTWFrZWZpbGUuaW4gYi9nY2MvTWFrZWZpbGUuaW4KaW5kZXggNWY5 MjYxZi4uMzVhYzM2MyAxMDA2NDQKLS0tIGEvZ2NjL01ha2VmaWxlLmluCisr KyBiL2djYy9NYWtlZmlsZS5pbgpAQCAtMTQ3Niw2ICsxNDc2LDcgQEAgT0JK UyA9IFwKIAl0cmVlLXZlY3Qtc2xwLm8gXAogCXRyZWUtdmVjdG9yaXplci5v IFwKIAl0cmVlLXZycC5vIFwKKyAgICAgICAgdHJlZS1zc2EtcGF0aC1zcGxp dC5vIFwKIAl0cmVlLm8gXAogCXZhbHRyYWNrLm8gXAogCXZhbHVlLXByb2Yu byBcCmRpZmYgLS1naXQgYS9nY2MvY29tbW9uLm9wdCBiL2djYy9jb21tb24u b3B0CmluZGV4IGUxMDQyNjkuLmM2M2IxMDAgMTAwNjQ0Ci0tLSBhL2djYy9j b21tb24ub3B0CisrKyBiL2djYy9jb21tb24ub3B0CkBAIC0yMzI4LDYgKzIz MjgsMTAgQEAgZnRyZWUtdnJwCiBDb21tb24gUmVwb3J0IFZhcihmbGFnX3Ry ZWVfdnJwKSBJbml0KDApIE9wdGltaXphdGlvbgogUGVyZm9ybSBWYWx1ZSBS YW5nZSBQcm9wYWdhdGlvbiBvbiB0cmVlcwogCitmdHJlZS1wYXRoLXNwbGl0 CitDb21tb24gUmVwb3J0IFZhcihmbGFnX3RyZWVfcGF0aF9zcGxpdCkgSW5p dCgwKSBPcHRpbWl6YXRpb24KK1BlcmZvcm0gUGF0aCBTcGxpdHRpbmcKKwog ZnVuaXQtYXQtYS10aW1lCiBDb21tb24gUmVwb3J0IFZhcihmbGFnX3VuaXRf YXRfYV90aW1lKSBJbml0KDEpIE9wdGltaXphdGlvbgogQ29tcGlsZSB3aG9s ZSBjb21waWxhdGlvbiB1bml0IGF0IGEgdGltZQpkaWZmIC0tZ2l0IGEvZ2Nj L29wdHMuYyBiL2djYy9vcHRzLmMKaW5kZXggOGExNjExNi4uMzE5NDdmZiAx MDA2NDQKLS0tIGEvZ2NjL29wdHMuYworKysgYi9nY2Mvb3B0cy5jCkBAIC01 MDgsNiArNTA4LDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBkZWZhdWx0X29w dGlvbnMgZGVmYXVsdF9vcHRpb25zX3RhYmxlW10gPQogICAgIHsgT1BUX0xF VkVMU18yX1BMVVMsIE9QVF9maXNvbGF0ZV9lcnJvbmVvdXNfcGF0aHNfZGVy ZWZlcmVuY2UsIE5VTEwsIDEgfSwKICAgICB7IE9QVF9MRVZFTFNfMl9QTFVT LCBPUFRfZmlwYV9yYSwgTlVMTCwgMSB9LAogICAgIHsgT1BUX0xFVkVMU18y X1BMVVMsIE9QVF9mbHJhX3JlbWF0LCBOVUxMLCAxIH0sCisgICAgeyBPUFRf TEVWRUxTXzJfUExVUywgT1BUX2Z0cmVlX3BhdGhfc3BsaXQsIE5VTEwsIDEg fSwKIAogICAgIC8qIC1PMyBvcHRpbWl6YXRpb25zLiAgKi8KICAgICB7IE9Q VF9MRVZFTFNfM19QTFVTLCBPUFRfZnRyZWVfbG9vcF9kaXN0cmlidXRlX3Bh dHRlcm5zLCBOVUxMLCAxIH0sCmRpZmYgLS1naXQgYS9nY2MvcGFzc2VzLmRl ZiBiL2djYy9wYXNzZXMuZGVmCmluZGV4IGMwZGRlZTQuLjQzNjE4ZWIgMTAw NjQ0Ci0tLSBhL2djYy9wYXNzZXMuZGVmCisrKyBiL2djYy9wYXNzZXMuZGVm CkBAIC0xNTUsNiArMTU1LDcgQEAgYWxvbmcgd2l0aCBHQ0M7IHNlZSB0aGUg ZmlsZSBDT1BZSU5HMy4gIElmIG5vdCBzZWUKICAgICAgIE5FWFRfUEFTUyAo cGFzc19jY3ApOwogICAgICAgLyogQWZ0ZXIgQ0NQIHdlIHJld3JpdGUgbm8g bG9uZ2VyIGFkZHJlc3NlZCBsb2NhbHMgaW50byBTU0EKIAkgZm9ybSBpZiBw b3NzaWJsZS4gICovCisgICAgICBORVhUX1BBU1MgKHBhc3NfcGF0aF9zcGxp dCk7CiAgICAgICBORVhUX1BBU1MgKHBhc3NfY29weV9wcm9wKTsKICAgICAg IE5FWFRfUEFTUyAocGFzc19jb21wbGV0ZV91bnJvbGxpKTsKICAgICAgIE5F WFRfUEFTUyAocGFzc19waGlwcm9wKTsKZGlmZiAtLWdpdCBhL2djYy90ZXN0 c3VpdGUvZ2NjLmRnL3BhdGgtc3BsaXQtMS5jIGIvZ2NjL3Rlc3RzdWl0ZS9n Y2MuZGcvcGF0aC1zcGxpdC0xLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMC4uMDc1ZGM4NwotLS0gL2Rldi9udWxsCisrKyBiL2djYy90 ZXN0c3VpdGUvZ2NjLmRnL3BhdGgtc3BsaXQtMS5jCkBAIC0wLDAgKzEsNjUg QEAKKy8qIHsgZGctZG8gcnVuIH0gKi8KKy8qIHsgZGctb3B0aW9ucyAiLU8y ICIgfSAqLworCisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDxzdGRs aWIuaD4KKworI2RlZmluZSBSR0JNQVggMjU1CisKK2ludAordGVzdCgpCit7 CisgIGludCBpLCBQZWxzOworICB1bnNpZ25lZCBjaGFyIHN1bSA9IDA7Cisg IHVuc2lnbmVkIGNoYXIgeHIsIHhnLCB4YjsKKyAgdW5zaWduZWQgY2hhciB4 YywgeG0sIHh5LCB4azsKKyAgdW5zaWduZWQgY2hhciAqUmVhZFB0ciwgKkVy aXRlUHRyOworCisgIFJlYWRQdHIgPSAoIHVuc2lnbmVkIGNoYXIgKikgbWFs bG9jIChzaXplb2YgKHVuc2lnbmVkIGNoYXIpICogMTAwKTsKKyAgRXJpdGVQ dHIgPSAoIHVuc2lnbmVkIGNoYXIgKikgbWFsbG9jIChzaXplb2YgKHVuc2ln bmVkIGNoYXIpICogMTAwKTsKKworICBmb3IgKGkgPSAwOyBpIDwgMTAwO2kr KykKKyAgICAgeworICAgICAgIFJlYWRQdHJbaV0gPSAxMDAgLSBpOworICAg ICB9CisKKyAgZm9yIChpID0gMDsgaSA8IDEwMDsgaSsrKQorICAgICB7Cisg ICAgICAgeHIgPSAqUmVhZFB0cisrOworICAgICAgIHhnID0gKlJlYWRQdHIr KzsKKyAgICAgICB4YiA9ICpSZWFkUHRyKys7CisKKyAgICAgICB4YyA9ICh1 bnNpZ25lZCBjaGFyKSAoUkdCTUFYIC0geHIpOworICAgICAgIHhtID0gKHVu c2lnbmVkIGNoYXIpIChSR0JNQVggLSB4Zyk7CisgICAgICAgeHkgPSAodW5z aWduZWQgY2hhcikgKFJHQk1BWCAtIHhiKTsKKworICAgICAgIGlmICh4YyA8 IHhtKQorICAgICAgICAgeworICAgICAgICAgICB4ayA9ICh1bnNpZ25lZCBj aGFyKSAoeGMgPCB4eSA/IHhjIDogeHkpOworICAgICAgICAgfQorICAgICAg IGVsc2UKKyAgICAgICAgeworICAgICAgICAgIHhrID0gKHVuc2lnbmVkIGNo YXIpICh4bSA8IHh5ID8geG0gOiB4eSk7CisgICAgICAgIH0KKworICAgICAg IHhjID0gKHVuc2lnbmVkIGNoYXIpICh4YyAtIHhrKTsKKyAgICAgICB4bSA9 ICh1bnNpZ25lZCBjaGFyKSAoeG0gLSB4ayk7CisgICAgICAgeHkgPSAodW5z aWduZWQgY2hhcikgKHh5IC0geGspOworCisgICAgICAgKkVyaXRlUHRyKysg PSB4YzsKKyAgICAgICAqRXJpdGVQdHIrKyA9IHhtOworICAgICAgICpFcml0 ZVB0cisrID0geHk7CisgICAgICAgKkVyaXRlUHRyKysgPSB4azsKKyAgICAg ICBzdW0gKz0gKkVyaXRlUHRyOworICAgIH0KKyAgcmV0dXJuIHN1bTsKK30K KworaW50CittYWluKCkKK3sKKyAgaWYgKHRlc3QoKSAhPSAzMykKKyAgICBh Ym9ydCgpOworCisgIHJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvZ2NjL3Rl c3RzdWl0ZS9nY2MuZGcvdHJlZS1zc2EvcGF0aC1zcGxpdC0yLmMgYi9nY2Mv dGVzdHN1aXRlL2djYy5kZy90cmVlLXNzYS9wYXRoLXNwbGl0LTIuYwpuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xOWYyNzdjCi0tLSAv ZGV2L251bGwKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdHJlZS1zc2Ev cGF0aC1zcGxpdC0yLmMKQEAgLTAsMCArMSw2MiBAQAorLyogeyBkZy1kbyBj b21waWxlIH0gKi8KKy8qIHsgZGctb3B0aW9ucyAiLU8yIC1mZHVtcC10cmVl LXBhdGhfc3BsaXQiIH0gKi8KKworI2luY2x1ZGUgPHN0ZGlvLmg+CisjaW5j bHVkZSA8c3RkbGliLmg+CisKKyNkZWZpbmUgUkdCTUFYIDI1NQorCitpbnQK K3Rlc3QoKQoreworICBpbnQgaSwgUGVsczsKKyAgdW5zaWduZWQgY2hhciBz dW0gPSAwOworICB1bnNpZ25lZCBjaGFyIHhyLCB4ZywgeGI7CisgIHVuc2ln bmVkIGNoYXIgeGMsIHhtLCB4eSwgeGs7CisgIHVuc2lnbmVkIGNoYXIgKlJl YWRQdHIsICpFcml0ZVB0cjsKKworICBSZWFkUHRyID0gKHVuc2lnbmVkIGNo YXIgKikgbWFsbG9jIChzaXplb2YgKHVuc2lnbmVkIGNoYXIpICogMTAwKTsK KyAgRXJpdGVQdHIgPSAoIHVuc2lnbmVkIGNoYXIgKikgbWFsbG9jIChzaXpl b2YgKHVuc2lnbmVkIGNoYXIpICogMTAwKTsKKworICBmb3IgKGkgPSAwOyBp IDwgMTAwO2krKykKKyAgICAgeworICAgICAgIFJlYWRQdHJbaV0gPSAxMDAg LSBpOworICAgICB9CisKKyAgZm9yIChpID0gMDsgaSA8IDEwMDsgaSsrKQor ICAgICB7CisgICAgICAgeHIgPSAqUmVhZFB0cisrOworICAgICAgIHhnID0g KlJlYWRQdHIrKzsKKyAgICAgICB4YiA9ICpSZWFkUHRyKys7CisKKyAgICAg ICB4YyA9ICggdW5zaWduZWQgY2hhcikgKFJHQk1BWCAtIHhyKTsKKyAgICAg ICB4bSA9ICggdW5zaWduZWQgY2hhcikgKFJHQk1BWCAtIHhnKTsKKyAgICAg ICB4eSA9ICggdW5zaWduZWQgY2hhcikgKFJHQk1BWCAtIHhiKTsKKworICAg ICAgIGlmICh4YyA8IHhtKQorICAgICAgICAgeworICAgICAgICAgICB4ayA9 ICggdW5zaWduZWQgY2hhcikgKHhjIDwgeHkgPyB4YyA6IHh5KTsKKyAgICAg ICAgIH0KKyAgICAgICBlbHNlCisgICAgICAgICB7CisgICAgICAgICAgIHhr ID0gKCB1bnNpZ25lZCBjaGFyKSAoeG0gPCB4eSA/IHhtIDogeHkpOworICAg ICAgICAgfQorCisgICAgICAgeGMgPSAodW5zaWduZWQgY2hhcikgKHhjIC0g eGspOworICAgICAgIHhtID0gKHVuc2lnbmVkIGNoYXIpICh4bSAtIHhrKTsK KyAgICAgICB4eSA9ICh1bnNpZ25lZCBjaGFyKSAoeHkgLSB4ayk7CisKKyAg ICAgICAqRXJpdGVQdHIrKyA9IHhjOworICAgICAgICpFcml0ZVB0cisrID0g eG07CisgICAgICAgKkVyaXRlUHRyKysgPSB4eTsKKyAgICAgICAqRXJpdGVQ dHIrKyA9IHhrOworICAgICAgIHN1bSArPSAqRXJpdGVQdHI7CisgICAgfQor ICByZXR1cm4gc3VtOworfQorCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVl LWR1bXAgInhjX1swLTldWzAtOV0qIC0+IHsgeGNfWzAtOV1bMC05XSogfSIg InBhdGhfc3BsaXQifSB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVl LWR1bXAgInhtX1swLTldWzAtOV0qIC0+IHsgeG1fWzAtOV1bMC05XSogfSIg InBhdGhfc3BsaXQifSB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVl LWR1bXAgInh5X1swLTldWzAtOV0qIC0+IHsgeHlfWzAtOV1bMC05XSogfSIg InBhdGhfc3BsaXQifSB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVl LWR1bXAgIk1lcmdpbmcgYmxvY2tzIiAicGF0aF9zcGxpdCJ9IH0gKi8KKy8q IHsgZGctZmluYWwgeyBjbGVhbnVwLXRyZWUtZHVtcCAicGF0aF9zcGxpdCIg fSB9ICovCmRpZmYgLS1naXQgYS9nY2MvdGltZXZhci5kZWYgYi9nY2MvdGlt ZXZhci5kZWYKaW5kZXggNzExYmJlZC4uNjIxN2E4ZSAxMDA2NDQKLS0tIGEv Z2NjL3RpbWV2YXIuZGVmCisrKyBiL2djYy90aW1ldmFyLmRlZgpAQCAtMjg4 LDMgKzI4OCw0IEBAIERFRlRJTUVWQVIgKFRWX0pJVF9SRVBMQVkJICAgICAs ICJyZXBsYXkgb2YgSklUIGNsaWVudCBhY3Rpdml0eSIpCiBERUZUSU1FVkFS IChUVl9BU1NFTUJMRQkgICAgICwgImFzc2VtYmxlIEpJVCBjb2RlIikKIERF RlRJTUVWQVIgKFRWX0xJTksJCSAgICAgLCAibGluayBKSVQgY29kZSIpCiBE RUZUSU1FVkFSIChUVl9MT0FECQkgICAgICwgImxvYWQgSklUIHJlc3VsdCIp CitERUZUSU1FVkFSIChUVl9UUkVFX1BBVEhfU1BMSVQgICwgInRyZWUgcGF0 aF9zcGxpdCIpCmRpZmYgLS1naXQgYS9nY2MvdHJlZS1wYXNzLmggYi9nY2Mv dHJlZS1wYXNzLmgKaW5kZXggMzk4YWI4My4uZTAwNjM5ZSAxMDA2NDQKLS0t IGEvZ2NjL3RyZWUtcGFzcy5oCisrKyBiL2djYy90cmVlLXBhc3MuaApAQCAt Mzc5LDYgKzM3OSw3IEBAIGV4dGVybiBnaW1wbGVfb3B0X3Bhc3MgKm1ha2Vf cGFzc19pdl9vcHRpbWl6ZSAoZ2NjOjpjb250ZXh0ICpjdHh0KTsKIGV4dGVy biBnaW1wbGVfb3B0X3Bhc3MgKm1ha2VfcGFzc190cmVlX2xvb3BfZG9uZSAo Z2NjOjpjb250ZXh0ICpjdHh0KTsKIGV4dGVybiBnaW1wbGVfb3B0X3Bhc3Mg Km1ha2VfcGFzc19jaCAoZ2NjOjpjb250ZXh0ICpjdHh0KTsKIGV4dGVybiBn aW1wbGVfb3B0X3Bhc3MgKm1ha2VfcGFzc19jY3AgKGdjYzo6Y29udGV4dCAq Y3R4dCk7CitleHRlcm4gZ2ltcGxlX29wdF9wYXNzICptYWtlX3Bhc3NfcGF0 aF9zcGxpdCAoZ2NjOjpjb250ZXh0ICpjdHh0KTsKIGV4dGVybiBnaW1wbGVf b3B0X3Bhc3MgKm1ha2VfcGFzc19waGlfb25seV9jcHJvcCAoZ2NjOjpjb250 ZXh0ICpjdHh0KTsKIGV4dGVybiBnaW1wbGVfb3B0X3Bhc3MgKm1ha2VfcGFz c19idWlsZF9zc2EgKGdjYzo6Y29udGV4dCAqY3R4dCk7CiBleHRlcm4gZ2lt cGxlX29wdF9wYXNzICptYWtlX3Bhc3NfYnVpbGRfYWxpYXMgKGdjYzo6Y29u dGV4dCAqY3R4dCk7CmRpZmYgLS1naXQgYS9nY2MvdHJlZS1zc2EtcGF0aC1z cGxpdC5jIGIvZ2NjL3RyZWUtc3NhLXBhdGgtc3BsaXQuYwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zZGE3NzkxCi0tLSAvZGV2L251 bGwKKysrIGIvZ2NjL3RyZWUtc3NhLXBhdGgtc3BsaXQuYwpAQCAtMCwwICsx LDQ2MiBAQAorLyogU3VwcG9ydCByb3V0aW5lcyBmb3IgUGF0aCBTcGxpdHRp bmcuCisgICBDb3B5cmlnaHQgKEMpIDIwMTUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uLCBJbmMuCisgICBDb250cmlidXRlZCBieSBBaml0IEt1bWFyIEFn YXJ3YWwgPGFqaXRrdW1AeGlsaW54LmNvbT4uCisgCisgVGhpcyBmaWxlIGlz IHBhcnQgb2YgR0NDLgorCisgR0NDIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyBpdCB1bmRlciB0 aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFz IHB1Ymxpc2hlZCBieQorIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247 IGVpdGhlciB2ZXJzaW9uIDMsIG9yIChhdCB5b3VyIG9wdGlvbikKKyBhbnkg bGF0ZXIgdmVyc2lvbi4KKworR0NDIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBo b3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCitidXQgV0lUSE9VVCBBTlkg V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBv ZgorTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZQorR05VIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKworWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UK K2Fsb25nIHdpdGggR0NDOyBzZWUgdGhlIGZpbGUgQ09QWUlORzMuICBJZiBu b3Qgc2VlCis8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uICAqLwor CisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAic3lzdGVtLmgiCisj aW5jbHVkZSAiY29yZXR5cGVzLmgiCisjaW5jbHVkZSAidG0uaCIKKyNpbmNs dWRlICJmbGFncy5oIgorI2luY2x1ZGUgInRyZWUuaCIKKyNpbmNsdWRlICJz dG9yLWxheW91dC5oIgorI2luY2x1ZGUgImNhbGxzLmgiCisjaW5jbHVkZSAi cHJlZGljdC5oIgorI2luY2x1ZGUgInZlYy5oIgorI2luY2x1ZGUgImhhc2h0 YWIuaCIKKyNpbmNsdWRlICJoYXNoLXNldC5oIgorI2luY2x1ZGUgIm1hY2ht b2RlLmgiCisjaW5jbHVkZSAiaGFyZC1yZWctc2V0LmgiCisjaW5jbHVkZSAi aW5wdXQuaCIKKyNpbmNsdWRlICJmdW5jdGlvbi5oIgorI2luY2x1ZGUgImRv bWluYW5jZS5oIgorI2luY2x1ZGUgImNmZy5oIgorI2luY2x1ZGUgImNmZ2Fu YWwuaCIKKyNpbmNsdWRlICJiYXNpYy1ibG9jay5oIgorI2luY2x1ZGUgInRy ZWUtc3NhLWFsaWFzLmgiCisjaW5jbHVkZSAiaW50ZXJuYWwtZm4uaCIKKyNp bmNsdWRlICJnaW1wbGUtZm9sZC5oIgorI2luY2x1ZGUgInRyZWUtZWguaCIK KyNpbmNsdWRlICJnaW1wbGUtZXhwci5oIgorI2luY2x1ZGUgImlzLWEuaCIK KyNpbmNsdWRlICJnaW1wbGUuaCIKKyNpbmNsdWRlICJnaW1wbGUtaXRlcmF0 b3IuaCIKKyNpbmNsdWRlICJnaW1wbGUtd2Fsay5oIgorI2luY2x1ZGUgImdp bXBsZS1zc2EuaCIKKyNpbmNsdWRlICJ0cmVlLWNmZy5oIgorI2luY2x1ZGUg InRyZWUtcGhpbm9kZXMuaCIKKyNpbmNsdWRlICJzc2EtaXRlcmF0b3JzLmgi CisjaW5jbHVkZSAic3RyaW5ncG9vbC5oIgorI2luY2x1ZGUgInRyZWUtc3Nh bmFtZXMuaCIKKyNpbmNsdWRlICJ0cmVlLXNzYS1sb29wLW1hbmlwLmgiCisj aW5jbHVkZSAidHJlZS1zc2EtbG9vcC1uaXRlci5oIgorI2luY2x1ZGUgInRy ZWUtc3NhLWxvb3AuaCIKKyNpbmNsdWRlICJ0cmVlLWludG8tc3NhLmgiCisj aW5jbHVkZSAidHJlZS1zc2EuaCIKKyNpbmNsdWRlICJ0cmVlLXBhc3MuaCIK KyNpbmNsdWRlICJ0cmVlLWR1bXAuaCIKKyNpbmNsdWRlICJnaW1wbGUtcHJl dHR5LXByaW50LmgiCisjaW5jbHVkZSAiZGlhZ25vc3RpYy1jb3JlLmgiCisj aW5jbHVkZSAiaW50bC5oIgorI2luY2x1ZGUgImNmZ2xvb3AuaCIKKyNpbmNs dWRlICJ0cmVlLXNjYWxhci1ldm9sdXRpb24uaCIKKyNpbmNsdWRlICJ0cmVl LXNzYS1wcm9wYWdhdGUuaCIKKyNpbmNsdWRlICJ0cmVlLWNocmVjLmgiCisj aW5jbHVkZSAidHJlZS1zc2EtdGhyZWFkdXBkYXRlLmgiCisjaW5jbHVkZSAi ZXhwci5oIgorI2luY2x1ZGUgImluc24tY29kZXMuaCIKKyNpbmNsdWRlICJv cHRhYnMuaCIKKyNpbmNsdWRlICJ0cmVlLXNzYS10aHJlYWRlZGdlLmgiCisj aW5jbHVkZSAid2lkZS1pbnQuaCIKKworLyogUmVwbGFjZV91c2VzX3BoaSBm dW5jdGlvbiBwcm9wYWdhdGVzIHRoZSBwaGkgcmVzdWx0cyB3aXRoIHRoZQor ICAgZmlyc3QgcGhpIGFyZ3VtZW50IGludG8gZWFjaCBvZiB0aGUgY29waWVk IGpvaW4gYmxvY2tzIHdpcmVkIGludG8KKyAgIGl0cyBwcmVkZWNlc3NvcnMu IFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIGZyb20gdGhlIHJlcGxhY2VfdXNl c19waGkgCisgICB0byByZXBsYWNlIHRoZSB1c2VzIG9mIGZpcnN0IHBoaSBh cmd1bWVudHMgd2l0aCB0aGUgc2Vjb25kCisgICBwaGkgYXJndW1lbnRzIGlu IHRoZSBuZXh0IGNvcHkgb2Ygam9pbiBibG9jay4gICovCisKK3N0YXRpYyB2 b2lkCityZXBsYWNlX3VzZV9waGlfb3BlcmFuZDFfd2l0aF9vcGVyYW5kMiAo YmFzaWNfYmxvY2sgYiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB0cmVlIHVzZTEsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgdHJlZSB1c2UyKQoreworICB1c2Vfb3BlcmFu ZF9wIHVzZTsKKyAgc3NhX29wX2l0ZXIgaXRlcjsKKyAgZ2ltcGxlX3N0bXRf aXRlcmF0b3IgZ3NpOworCisgIGZvciAoZ3NpID0gZ3NpX3N0YXJ0X2JiIChi KTsgIWdzaV9lbmRfcCAoZ3NpKTspCisgICAgIHsKKyAgICAgICBnaW1wbGUg c3RtdCA9IGdzaV9zdG10IChnc2kpOworICAgICAgIEZPUl9FQUNIX1NTQV9V U0VfT1BFUkFORCAodXNlLCBzdG10LCBpdGVyLCBTU0FfT1BfVVNFKQorICAg ICAgIHsKKyAgICAgICAgIHRyZWUgdHVzZSA9IFVTRV9GUk9NX1BUUiAodXNl KTsKKyAgICAgICAgICBpZiAodXNlMSA9PSB0dXNlIHx8IHVzZTEgPT0gTlVM TF9UUkVFKQorICAgICAgICAgICAgeworICAgICAgICAgICAgICBwcm9wYWdh dGVfdmFsdWUgKHVzZSwgdXNlMik7CisgICAgICAgICAgICAgIHVwZGF0ZV9z dG10KHN0bXQpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgICAg Z3NpX25leHQoJmdzaSk7CisgICAgIH0KK30KKworLyogVGhpcyBmdW5jdGlv biBwcm9wYWdhdGVzIHRoZSBwaGkgcmVzdWx0IGludG8gdGhlIHVzZSBwb2lu dHMgd2l0aAorICAgdGhlIHBoaSBhcmd1bWVudHMuIFRoZSBqb2luIGJsb2Nr IGlzIGNvcGllZCBhbmQgd2lyZWQgaW50byB0aGUKKyAgIHByZWRlY2Vzc29y cy4gU2luY2UgdGhlIHVzZSBwb2ludHMgb2YgdGhlIHBoaSByZXN1bHRzIHdp bGwgYmUgc2FtZQorICAgaW4gdGhlIGVhY2ggb2YgdGhlIGNvcHkgam9pbiBi bG9ja3MgaW4gdGhlICBwcmVkZWNlc3NvcnMsIGl0CisgICBwcm9wYWdhdGVz IHRoZSBwaGkgYXJndW1lbnRzIGluIHRoZSBjb3B5IG9mIHRoZSBqb2luIGJs b2NrcyB3aXJlZAorICAgaW50byBpdHMgcHJlZGVjZXNzb3IuICAqLworIAor c3RhdGljCit2b2lkIHJlcGxhY2VfdXNlc19waGkgKGJhc2ljX2Jsb2NrIGIs IGJhc2ljX2Jsb2NrIHRlbXBfYmIpCit7CisgIGdpbXBsZV9zZXEgcGhpcyA9 IHBoaV9ub2RlcyAoYik7CisgIGdpbXBsZSBwaGkgPSBnaW1wbGVfc2VxX2Zp cnN0X3N0bXQgKHBoaXMpOworICB0cmVlIGRlZiA9IGdpbXBsZV9waGlfcmVz dWx0IChwaGkpLCB1c2UgPSBnaW1wbGVfcGhpX2FyZ19kZWYgKHBoaSwwKTsK KyAgdHJlZSB1c2UyID0gZ2ltcGxlX3BoaV9hcmdfZGVmIChwaGksMSk7CisK KyAgaWYgKHZpcnR1YWxfb3BlcmFuZF9wIChkZWYpKQorICAgIHsKKyAgICAg IGltbV91c2VfaXRlcmF0b3IgaXRlcjsKKyAgICAgIHVzZV9vcGVyYW5kX3Ag dXNlX3A7CisgICAgICBnaW1wbGUgc3RtdDsKKworICAgICAgRk9SX0VBQ0hf SU1NX1VTRV9TVE1UIChzdG10LCBpdGVyLCBkZWYpCisgICAgICAgIEZPUl9F QUNIX0lNTV9VU0VfT05fU1RNVCAodXNlX3AsIGl0ZXIpCisgICAgICAgICAg U0VUX1VTRSAodXNlX3AsIHVzZSk7CisgICAgICBpZiAoU1NBX05BTUVfT0ND VVJTX0lOX0FCTk9STUFMX1BISSAoZGVmKSkKKyAgICAgICAgU1NBX05BTUVf T0NDVVJTX0lOX0FCTk9STUFMX1BISSAodXNlKSA9IDE7CisgICAgfQorICAg ZWxzZQorICAgICByZXBsYWNlX3VzZXNfYnkgKGRlZiwgdXNlKTsKKyAgIHJl cGxhY2VfdXNlX3BoaV9vcGVyYW5kMV93aXRoX29wZXJhbmQyICh0ZW1wX2Ji LCB1c2UsIHVzZTIpOworfQorCisvKiBSZXR1cm5zIHRydWUgaWYgdGhlIGJs b2NrIGJiIGhhcyBsYWJlbCBvciBjYWxsIHN0YXRlbWVudHMuCisgICBPdGhl cndpc2UgcmV0dXJuIGZhbHNlLiAgKi8KKworc3RhdGljIGJvb2wKK2lzX2Js b2NrX2hhc19sYWJlbF9jYWxsIChiYXNpY19ibG9jayBiYikKK3sKKyAgZ2lt cGxlX3N0bXRfaXRlcmF0b3IgZ3NpOworCisgIGZvciAoZ3NpID0gZ3NpX3N0 YXJ0X2JiIChiYik7ICFnc2lfZW5kX3AgKGdzaSk7IGdzaV9uZXh0ICgmZ3Np KSkKKyAgICAgeworICAgICAgIGdpbXBsZSBzdG10ID0gZ3NpX3N0bXQoZ3Np KTsKKyAgICAgICBpZiAoZHluX2Nhc3QgPGdsYWJlbCAqPiAoc3RtdCkpCisg ICAgICAgICB7CisgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICAg fQorICAgICAgIGlmIChpc19naW1wbGVfY2FsbCAoc3RtdCkpCisgICAgICAg ICByZXR1cm4gdHJ1ZTsKKyAgICAgfQorICByZXR1cm4gZmFsc2U7Cit9CisK Ky8qIFRoaXMgZnVuY3Rpb24gcGVyZm9ybXMgdGhlIGZlYXNpYmlsaXR5IHRl c3RzIGZvciBwYXRoIHNwbGl0dGluZworICAgdG8gcGVyZm9ybS4gUmV0dXJu IGZhbHNlIGlmIHRoZSBmZWFzaWJpbGl0eSBmb3IgcGF0aCBzcGxpdHRpbmcK KyAgIGlzIG5vdCBkb25lIGFuZCByZXR1cm5zIHRydWUgaWYgdGhlIGZlYXNi aWxpdHkgZm9yIHBhdGggc3BsaXR0aW5nCisgICBpcyBkb25lLiBGb2xsb3dp bmcgZmVhc2liaWxpdHkgdGVzdHMgYXJlIHBlcmZvcm1lZC4KKyAKKyAgIDEu IFJldHVybiBmYWxzZSBpZiB0aGUgam9pbiBibG9jayBoYXMgY2FsbCBnaW1w bGUgc3RhdGVtZW50cy4KKyAgIDIuIFJldHVybiBmYWxzZSBpZiB0aGUgam9p biBibG9jayBoYXMgcmhzIGNhc3RpbmcgZm9yIGFzc2lnbgorICAgICAgZ2lt cGxlIHN0YXRlbWVudHMuCisgICAzLiBJZiB0aGUgbnVtYmVyIG9mIHBoaXMg aXMgZ3JlYXRlciB0aGFuIDEgb3IgdGhlIHBoaSBub2RlIGluCisgICAgICB0 aGUgam9pbiBibG9jayBoYXMgdmlydHVhbCBvcGVyYW5kIHJldHVybiBmYWxz ZS4KKyAgIDQuIFJldHVybiBmYWxzZSBpZiB0aGUgbnVtYmVyIG9mIHNlcXVl bnRpYWwgc3RhdGVtZW50cyBpcworICAgICAgZ3JlYXRlciB0aGFuIDIuCisg ICA1LiBJZiB0aGUgcHJlZGVjZXNzb3JzIGJsb2NrcyBoYXMgbGFiZWxzIGFu ZCBjYWxsIHN0YXRlbWVudHMKKyAgICAgIHJldHVybiBmYWxzZS4KKyAgIDYu IElmIHRoZSBwaGkgcmVzdWx0IGluIHRoZSBwaGkgbm9kZSBvZiB0aGUgam9p biBibG9jayBpcyBub3QKKyAgICAgIHVzZWQgaW5zaWRlIHRoZSBzYW1lIGpv aW4gYmxvY2sgcmV0dXJuIGZhbHNlLgorICAgNy4gT3RoZXJ3aXNlIHJldHVy bnMgdHJ1ZS4gICovCisKK3N0YXRpYyBib29sCitpc19mZWFzaWJsZV9wYXRo X3NwbGl0dGluZyAoYmFzaWNfYmxvY2sgam9pbl9ub2RlLCBiYXNpY19ibG9j ayBwcmVkMSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIGJhc2ljX2Js b2NrIHByZWQyKQoreworICBpbnQgbnVtX3N0bXQgPSAwLCBudW1fcGhpcyA9 IDA7CisgIGdpbXBsZV9zdG10X2l0ZXJhdG9yIHBzaSwgZ3NpOworCisgIGZv ciAoZ3NpID0gZ3NpX3N0YXJ0X2JiIChqb2luX25vZGUpOyAhZ3NpX2VuZF9w IChnc2kpOyBnc2lfbmV4dCAoJmdzaSkpCisgICAgIHsKKyAgICAgICBnaW1w bGUgc3RtdCA9IGdzaV9zdG10KGdzaSk7CisKKyAgICAgICBpZiAoZ2ltcGxl X2Fzc2lnbl9jYXN0X3AgKHN0bXQpKQorICAgICAgICAgcmV0dXJuIGZhbHNl OworCisgICAgICAgaWYgKGlzX2dpbXBsZV9jYWxsIChzdG10KSkKKyAgICAg ICAgIHJldHVybiBmYWxzZTsKKworICAgICAgIGlmICghaXNfZ2ltcGxlX2Rl YnVnKHN0bXQpKQorICAgICAgICAgeworICAgICAgICAgICBudW1fc3RtdCsr OworICAgICAgICAgfQorICAgICB9CisKKyAgIGlmIChwcmVkMSAmJiBwcmVk MiAmJiAobnVtX3N0bXQgPiAyKSkKKyAgICAgeworICAgICAgIGJvb2wgZm91 bmRfdmlydHVhbF9yZXN1bHQgPSBmYWxzZTsKKworICAgICAgIGZvciAocHNp ID0gZ3NpX3N0YXJ0X3BoaXMgKGpvaW5fbm9kZSk7ICFnc2lfZW5kX3AgKHBz aSk7ICkKKyAgICAgICAgICB7CisgICAgICAgICAgICB1c2Vfb3BlcmFuZF9w IHVzZV9wOworICAgICAgICAgICAgaW1tX3VzZV9pdGVyYXRvciBpdGVyOwor ICAgICAgICAgICAgZ2ltcGxlIHN0bXQgPSBnc2lfc3RtdChwc2kpOworCisg ICAgICAgICAgICBpZiAoIXZpcnR1YWxfb3BlcmFuZF9wIChnaW1wbGVfcGhp X3Jlc3VsdCAoc3RtdCkpKQorICAgICAgICAgICAgICBudW1fcGhpcysrOwor ICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICBmb3VuZF92aXJ0dWFs X3Jlc3VsdCA9IHRydWU7CisKKyAgICAgICAgICAgIEZPUl9FQUNIX0lNTV9V U0VfRkFTVCAodXNlX3AsIGl0ZXIsIGdpbXBsZV9waGlfcmVzdWx0IChzdG10 KSkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgZ2ltcGxlIHVzZV9z dG10ID0gVVNFX1NUTVQgKHVzZV9wKTsKKworICAgICAgICAgICAgICBpZiAo Z2ltcGxlX2JiICh1c2Vfc3RtdCkgIT0gam9pbl9ub2RlKQorICAgICAgICAg ICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgIH0KKworICAgICAg ICAgICAgZ3NpX25leHQoJnBzaSk7CisgICAgICAgICB9CisKKyAgICAgICBp ZiAoKG51bV9waGlzID4xKSB8fCBmb3VuZF92aXJ0dWFsX3Jlc3VsdCkKKyAg ICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAgICBpZihpc19ibG9ja19o YXNfbGFiZWxfY2FsbChwcmVkMSkgfHwgaXNfYmxvY2tfaGFzX2xhYmVsX2Nh bGwocHJlZDIpKQorICAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgICAg cmV0dXJuIHRydWU7CisgICAgfQorICByZXR1cm4gZmFsc2U7Cit9CisKKy8q IFVwZGF0ZSB0aGUgc3RhdGVtZW50cyBpbiB0aGUgYmFzaWMgYmxvY2sgd2l0 aCB0aGUgYmFzaWMKKyAgIGJhc2ljIGJsb2NrLiAgKi8KKworc3RhdGljIHZv aWQKK3VwZGF0ZV9zdG10X2JiKGJhc2ljX2Jsb2NrIGIpCit7CisgIGdpbXBs ZV9zdG10X2l0ZXJhdG9yIGdzaTsKKyAgZm9yKGdzaSA9IGdzaV9zdGFydF9i YihiKTsgIWdzaV9lbmRfcChnc2kpOyBnc2lfbmV4dCgmZ3NpKSkKKyAgIHsK KyAgICAgZ2ltcGxlIHN0bXQgPSBnc2lfc3RtdChnc2kpOworICAgICBnaW1w bGVfc2V0X2JiKHN0bXQsYik7CisgICB9Cit9CisKKy8qIFRoaXMgZnVuY3Rp b24gZ2V0cyB0aGUgam9pbiBibG9ja3Mgc2FtZSBhcyB0aGUgc291cmNlCisg ICBub2RlIG9mIHRoZSBsb29wIGxhdGNoIG5vZGVzIGFuZCB0aGUgcHJlZGVj ZXNzb3JzIG9mCisgICB0aGUgam9pbiBibG9jayBpcyB1cGRhdGVkIGluIHRo ZSBwcmVkMSBhbmQgcHJlZDIgcGFzc2VkCisgICBhcyB0aGUgcmVmZXJlbmNl IGFyZ3VtZW50cyBpbnRvIHRoZSBmdW5jdGlvbi4gUmV0dXJuCisgICB0aGUg am9pbiBibG9jay4gICovCisKK3N0YXRpYyBiYXNpY19ibG9jaworZ2V0X2pv aW5fYmxrX3NhbWVfYXNfbG9vcF9sYXRjaCAoYmFzaWNfYmxvY2sgYmIsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBiYXNpY19ibG9jayAm cHJlZDEsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBiYXNp Y19ibG9jayAmcHJlZDIpCit7CisgIHZlYzxiYXNpY19ibG9jaz4gYmJzOwor ICBiYXNpY19ibG9jayBiYjE7CisgIHVuc2lnbmVkIGludCBpOworICBlZGdl X2l0ZXJhdG9yIGVpOworICBlZGdlIGUxOworICBib29sIGZvdW5kID0gZmFs c2UgLGZvdW5kMTsKKyAgYmJzID0gZ2V0X2FsbF9kb21pbmF0ZWRfYmxvY2tz IChDRElfRE9NSU5BVE9SUywKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBiYiApOworICBGT1JfRUFDSF9WRUNfRUxUIChiYnMsIGksIGJi MSkKKyAgeworICAgIGZvdW5kMSA9IGZhbHNlOworICAgIEZPUl9FQUNIX0VE R0UgKGUxLCBlaSwgYmItPnN1Y2NzKQorICAgIHsKKyAgICAgIGlmICggYmIx ID09IGUxLT5kZXN0KQorICAgICAgICB7CisgICAgICAgICAgZm91bmQgPSB0 cnVlOworICAgICAgICAgIGZvdW5kMSA9IHRydWU7CisgICAgICAgIH0KKyAg ICB9CisgICAgaWYgKCFmb3VuZDEgJiYgZm91bmQpCisgICAgICB7CisgICAg ICAgIGZvdW5kID0gZmFsc2U7CisgICAgICAgIEZPUl9FQUNIX0VER0UgKGUx LCBlaSwgYmIxLT5zdWNjcykKKyAgICAgICAgeworICAgICAgICAgIGlmIChl MS0+ZmxhZ3MgJiAoRURHRV9ERlNfQkFDSykpCisgICAgICAgICAgICBmb3Vu ZCA9IHRydWU7CisgICAgICAgIH0KKworICAgICAgICBpZiAoZm91bmQgJiYg RURHRV9DT1VOVChiYjEtPnByZWRzKSA9PSAyKQorICAgICAgICAgIHsKKyAg ICAgICAgICAgIHVuc2lnbmVkIGludCBrID0gMDsKKyAgICAgICAgICAgIEZP Ul9FQUNIX0VER0UgKGUxLCBlaSwgYmIxLT5wcmVkcykKKyAgICAgICAgICAg IHsKKyAgICAgICAgICAgICAgaWYgKChlMS0+ZmxhZ3MgJiAoRURHRV9ERlNf QkFDSykpKQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAg ICAgICAgIGlmICggayA9PSAxKQorICAgICAgICAgICAgICAgIHsKKyAgICAg ICAgICAgICAgICAgIGlmIChzaW5nbGVfc3VjY19wKGUxLT5zcmMpICYmCisg ICAgICAgICAgICAgICAgICAgICAgc2luZ2xlX3N1Y2NfZWRnZSAoZTEtPnNy YyktPmZsYWdzICYgRURHRV9GQUxMVEhSVSkKKyAgICAgICAgICAgICAgICAg ICAgeworICAgICAgICAgICAgICAgICAgICAgIHByZWQyID0gZTEtPnNyYzsK KyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIH0KKyAg ICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgICB7CisgICAg ICAgICAgICAgICAgICAgIGlmIChzaW5nbGVfc3VjY19wKGUxLT5zcmMpICYm CisgICAgICAgICAgICAgICAgICAgICAgICBzaW5nbGVfc3VjY19lZGdlIChl MS0+c3JjKS0+ZmxhZ3MgJiBFREdFX0ZBTExUSFJVKQorICAgICAgICAgICAg ICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIHByZWQxID0g ZTEtPnNyYzsKKyAgICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAg ICAgICAgICB9CisgICAgICAgICAgICAgICAgaysrOworICAgICAgICAgICAg fQorICAgICAgICAgICAgYmJzLnJlbGVhc2UoKTsKKyAgICAgICAgICAgIHJl dHVybiBiYjE7CisgICAgICAgICAgfQorICAgICAgIH0KKyAgIH0KKyAgIGJi cy5yZWxlYXNlKCk7CisgICByZXR1cm4gTlVMTDsKK30KKworLyogVGhpcyBp cyB0aGUgY29yZSBmdW5jdGlvbiB0byBwZXJmb3JtIHBhdGggc3BsaXR0aW5n LiBUaGUgam9pbgorICAgc2FtZSBhcyB0aGUgc291cmNlIG9mIHRoZSBsb29w IGxhdGNoIG5vZGUgaXMgaWRlbnRpZmllZCBhbG9uZworICAgd2l0aCB0aGVp ciBwcmVkZWNlc3NvcnMuIEJhc2VkIG9uIHRoZSBmZWFzaWJpbGl0eSB0ZXN0 cyBmb3IKKyAgIHBhdGggc3BsaXR0aW5nIHRoZSBwYXRoIHNwbGl0dGluZyBp cyBwZXJmb3JtZWQgYnkgd2lyaW5nIHRoZQorICAgY29weSBvZiBqb2luIGJs b2NrcyBpbnRvIHRoZSBwcmVkZWNlc3NvcnMgYW5kIHByb3BhZ2F0aW5nIHRo ZSBwaGkKKyAgIHJlc3VsdCB3aXRoIHRoZSBjb3JyZXNwb25kaW5nIHBoaSBh cmd1bWVudHMgaW50byBlYWNoIG9mIHRoZSBjb3B5CisgICBvZiBqb2luIGJs b2NrcyB3aXJlZCB3aXRoIHRoZSBvcmlnaW5hbCBwcmVkZWNlc3NvcnMgb2Yg dGhlIGpvaW4KKyAgIGJsb2NrLgorIAorICAgVGhlICB0cmVlLWNmZy1jbGVh bnVwIHdpbGwgbWVyZ2UgdGhlIGJsb2NrcyBpbiB0aGUgcHJlZGVjZXNzb3Jz CisgICBwYXRoIGFuZCB0aGUgdXBkYXRlLXNzYSB3aWxsIHVwZGF0ZSB0aGUg c3NhIHJlcHJlc2VudGF0aW9uIGFmdGVyCisgICB0aGUgcGF0aCBzcGxpdHRp bmcgaXMgcGVyZm9ybWVkLiAgKi8KKyAKK3N0YXRpYyB2b2lkCitwZXJmb3Jt X3BhdGhfc3BsaXR0aW5nIChiYXNpY19ibG9jayBiYikKK3sKKyAgYmFzaWNf YmxvY2sgcHJlZDEgPSBOVUxMLCBwcmVkMiA9IE5VTEwsIGpvaW5fYmxvY2sg PSBOVUxMOworCisgIGpvaW5fYmxvY2sgPSBnZXRfam9pbl9ibGtfc2FtZV9h c19sb29wX2xhdGNoIChiYiwgcHJlZDEsIHByZWQyKTsKKworICBpZiAoam9p bl9ibG9jayAgJiYgCisgICAgICBpc19mZWFzaWJsZV9wYXRoX3NwbGl0dGlu ZyAoam9pbl9ibG9jaywgcHJlZDEsIHByZWQyKSkKKyAgICB7CisgICAgICBi YXNpY19ibG9jayBuZXdfYmIxID0gTlVMTCwgbmV3X2JiMiA9IE5VTEw7Cisg ICAgICBnaW1wbGVfc3RtdF9pdGVyYXRvciBsYXN0OworICAgICAgYmFzaWNf YmxvY2sgdGVtcF9iYiA9IE5VTEw7CisgICAgICBlZGdlX2l0ZXJhdG9yIGVp OworICAgICAgZWRnZSBlMTsKKworICAgICAgdGVtcF9iYiA9IGR1cGxpY2F0 ZV9ibG9jayAoam9pbl9ibG9jaywgTlVMTCwgTlVMTCk7CisKKyAgICAgIEZP Ul9FQUNIX0VER0UgKGUxLCBlaSwgcHJlZDEtPnN1Y2NzKQorICAgICAgICBu ZXdfYmIxID0gc3BsaXRfZWRnZSAoZTEpOworCisgICAgICBGT1JfRUFDSF9F REdFIChlMSwgZWksIHByZWQyLT5zdWNjcykKKyAgICAgICAgbmV3X2JiMiA9 IHNwbGl0X2VkZ2UgKGUxKTsKKworICAgICAgbGFzdCA9IGdzaV9zdGFydF9i YiAobmV3X2JiMSk7CisgICAgICBnc2lfaW5zZXJ0X3NlcV9hZnRlciAoJmxh c3QsIGJiX3NlcSAoam9pbl9ibG9jayksIEdTSV9ORVdfU1RNVCk7CisgICAg ICBsYXN0ID0gZ3NpX3N0YXJ0X2JiIChuZXdfYmIyKTsKKyAgICAgIGdzaV9p bnNlcnRfc2VxX2FmdGVyICgmbGFzdCwgYmJfc2VxICh0ZW1wX2JiKSwgR1NJ X05FV19TVE1UKTsKKyAgICAgIHVwZGF0ZV9zdG10X2JiIChuZXdfYmIxKTsK KyAgICAgIHVwZGF0ZV9zdG10X2JiIChuZXdfYmIyKTsKKworICAgICAgcmVw bGFjZV91c2VzX3BoaSAoam9pbl9ibG9jaywgbmV3X2JiMik7CisKKyAgICAg IHNldF9iYl9zZXEgKGpvaW5fYmxvY2ssIE5VTEwpOworICAgICAgc2V0X2Ji X3NlcSh0ZW1wX2JiLE5VTEwpOworICAgICAgZGVsZXRlX2Jhc2ljX2Jsb2Nr ICh0ZW1wX2JiKTsKKyAgICAgIHJldHVybjsKKyAgICB9Cit9CisKK3N0YXRp YyB1bnNpZ25lZCBpbnQKK2V4ZWN1dGVfcGF0aF9zcGxpdCAodm9pZCkKK3sK KyAgYmFzaWNfYmxvY2sgYmI7CisKKyAgbG9vcF9vcHRpbWl6ZXJfaW5pdCAo TE9PUFNfTk9STUFMIHwgTE9PUFNfSEFWRV9SRUNPUkRFRF9FWElUUyk7Cisg IGluaXRpYWxpemVfb3JpZ2luYWxfY29weV90YWJsZXMoKTsKKworICBjYWxj dWxhdGVfZG9taW5hbmNlX2luZm8gKENESV9ET01JTkFUT1JTKTsKKyAgY2Fs Y3VsYXRlX2RvbWluYW5jZV9pbmZvIChDRElfUE9TVF9ET01JTkFUT1JTKTsK KworICBtYXJrX2Rmc19iYWNrX2VkZ2VzICgpOworCisgIEZPUl9FQUNIX0JC X0ZOIChiYiwgY2Z1bikKKyAgeworICAgIGdpbXBsZSBsYXN0OworCisgICAg LyogV2Ugb25seSBjYXJlIGFib3V0IGJsb2NrcyBlbmRpbmcgaW4gYSBDT05E X0VYUFIuICovCisKKyAgICBsYXN0ID0gZ3NpX3N0bXQgKGdzaV9sYXN0X2Ji IChiYikpOworCisgICAgLyogV2UncmUgYmFzaWNhbGx5IGxvb2tpbmcgZm9y IGEgc3dpdGNoIG9yIGFueSBraW5kIG9mIGNvbmRpdGlvbmFsIHdpdGgKKyAg ICAgICBpbnRlZ3JhbCBvciBwb2ludGVyIHR5cGUgYXJndW1lbnRzLiAgTm90 ZSB0aGUgdHlwZSBvZiB0aGUgc2Vjb25kCisgICAgICAgYXJndW1lbnQgd2ls bCBiZSB0aGUgc2FtZSBhcyB0aGUgZmlyc3QgYXJndW1lbnQsIHNvIG5vIG5l ZWQgdG8KKyAgICAgICBjaGVjayBpdCBleHBsaWNpdGx5LiAgKi8KKyAgICBp ZiAoKGxhc3QgJiYgKGdpbXBsZV9jb2RlIChsYXN0KSA9PSBHSU1QTEVfQ09O RAorICAgICAgICAgICAgJiYgVFJFRV9DT0RFIChnaW1wbGVfY29uZF9saHMg KGxhc3QpKSA9PSBTU0FfTkFNRQorICAgICAgICAgICAgJiYgKElOVEVHUkFM X1RZUEVfUCAoVFJFRV9UWVBFIChnaW1wbGVfY29uZF9saHMgKGxhc3QpKSkK KyAgICAgICAgICAgIHx8IFBPSU5URVJfVFlQRV9QIChUUkVFX1RZUEUgKGdp bXBsZV9jb25kX2xocyAobGFzdCkpKSkKKyAgICAgICAgICAgICYmIChUUkVF X0NPREUgKGdpbXBsZV9jb25kX3JocyAobGFzdCkpID09IFNTQV9OQU1FCisg ICAgICAgICAgICB8fCBpc19naW1wbGVfbWluX2ludmFyaWFudCAoZ2ltcGxl X2NvbmRfcmhzIChsYXN0KSkpKSkpCisgICAgICB7CisKKyAgICAgICAgIGlm IChnaW1wbGVfY29kZShsYXN0KSA9PSBHSU1QTEVfQ09ORCkKKyAgICAgICAg ICAgeworICAgICAgICAgICAgICBwZXJmb3JtX3BhdGhfc3BsaXR0aW5nIChi Yik7CisgICAgICAgICAgIH0KKyAgICAgIH0KKyAgIH0KKworICAgbG9vcF9v cHRpbWl6ZXJfZmluYWxpemUgKCk7CisgICBmcmVlX29yaWdpbmFsX2NvcHlf dGFibGVzICgpOworICAgZnJlZV9kb21pbmFuY2VfaW5mbyAoQ0RJX0RPTUlO QVRPUlMpOworICAgZnJlZV9kb21pbmFuY2VfaW5mbyAoQ0RJX1BPU1RfRE9N SU5BVE9SUyk7CisgICByZXR1cm4gMDsKK30KKworbmFtZXNwYWNlIHsKKwor Y29uc3QgcGFzc19kYXRhIHBhc3NfZGF0YV9wYXRoX3NwbGl0ID0KK3sKKyAg IEdJTVBMRV9QQVNTLCAvKiB0eXBlICovCisgICAicGF0aF9zcGxpdCIsIC8q IG5hbWUgKi8KKyAgICBPUFRHUk9VUF9OT05FLCAvKiBvcHRpbmZvX2ZsYWdz ICovCisgICAgVFZfVFJFRV9QQVRIX1NQTElULCAvKiB0dl9pZCAqLworICAg IFBST1Bfc3NhLCAvKiBwcm9wZXJ0aWVzX3JlcXVpcmVkICovCisgICAgMCwg LyogcHJvcGVydGllc19wcm92aWRlZCAqLworICAgIDAsIC8qIHByb3BlcnRp ZXNfZGVzdHJveWVkICovCisgICAgMCwgLyogdG9kb19mbGFnc19zdGFydCAq LworICAgICggVE9ET19jbGVhbnVwX2NmZyB8IFRPRE9fdXBkYXRlX3NzYSAp LCAvKiB0b2RvX2ZsYWdzX2ZpbmlzaCAqLworfTsKKworY2xhc3MgcGFzc19w YXRoX3NwbGl0IDogcHVibGljIGdpbXBsZV9vcHRfcGFzcworeworICAgcHVi bGljOgorICAgIHBhc3NfcGF0aF9zcGxpdCAoZ2NjOjpjb250ZXh0ICpjdHh0 KQorICAgICAgOiBnaW1wbGVfb3B0X3Bhc3MgKHBhc3NfZGF0YV9wYXRoX3Nw bGl0LCBjdHh0KQorICAgIHt9CisgCisgICAvKiBvcHRfcGFzcyBtZXRob2Rz OiAqLworICAgb3B0X3Bhc3MgKiBjbG9uZSAoKSB7IHJldHVybiBuZXcgcGFz c19wYXRoX3NwbGl0IChtX2N0eHQpOyB9CisgICB2aXJ0dWFsIGJvb2wgZ2F0 ZSAoZnVuY3Rpb24gKikgeyByZXR1cm4gZmxhZ190cmVlX3BhdGhfc3BsaXQg IT0gMDsgfQorICAgdmlydHVhbCB1bnNpZ25lZCBpbnQgZXhlY3V0ZSAoZnVu Y3Rpb24gKikgeyByZXR1cm4gZXhlY3V0ZV9wYXRoX3NwbGl0ICgpOyB9Cisg Cit9OyAvLyBjbGFzcyBwYXNzX3BhdGhfc3BsaXQKKworfSAvLyBhbm9uIG5h bWVzcGFjZQorCitnaW1wbGVfb3B0X3Bhc3MgKgorbWFrZV9wYXNzX3BhdGhf c3BsaXQgKGdjYzo6Y29udGV4dCAqY3R4dCkKK3sKKyAgcmV0dXJuIG5ldyBw YXNzX3BhdGhfc3BsaXQgKGN0eHQpOworfQotLSAKMS44LjIuMQoK --_002_37378DC5BCD0EE48BA4B082E0B55DFAA41F3F56CXAPPVEXMBX02xln_--