From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx0a-001b2d01.pphosted.com (mx0a-001b2d01.pphosted.com [148.163.156.1]) by sourceware.org (Postfix) with ESMTPS id 5C44E3858412; Fri, 15 Oct 2021 05:51:29 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 5C44E3858412 Received: from pps.filterd (m0098410.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.16.1.2/8.16.1.2) with SMTP id 19F3jlOE021078; Fri, 15 Oct 2021 01:51:28 -0400 Received: from ppma04ams.nl.ibm.com (63.31.33a9.ip4.static.sl-reverse.com [169.51.49.99]) by mx0a-001b2d01.pphosted.com with ESMTP id 3bpp01jkc6-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 15 Oct 2021 01:51:27 -0400 Received: from pps.filterd (ppma04ams.nl.ibm.com [127.0.0.1]) by ppma04ams.nl.ibm.com (8.16.1.2/8.16.1.2) with SMTP id 19F5lgHr006356; Fri, 15 Oct 2021 05:51:25 GMT Received: from b06cxnps4075.portsmouth.uk.ibm.com (d06relay12.portsmouth.uk.ibm.com [9.149.109.197]) by ppma04ams.nl.ibm.com with ESMTP id 3bk2qav1kq-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 15 Oct 2021 05:51:25 +0000 Received: from d06av26.portsmouth.uk.ibm.com (d06av26.portsmouth.uk.ibm.com [9.149.105.62]) by b06cxnps4075.portsmouth.uk.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 19F5pLwc60424612 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 15 Oct 2021 05:51:21 GMT Received: from d06av26.portsmouth.uk.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 49405AE058; Fri, 15 Oct 2021 05:51:21 +0000 (GMT) Received: from d06av26.portsmouth.uk.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 26C81AE051; Fri, 15 Oct 2021 05:51:18 +0000 (GMT) Received: from [9.200.46.43] (unknown [9.200.46.43]) by d06av26.portsmouth.uk.ibm.com (Postfix) with ESMTPS; Fri, 15 Oct 2021 05:51:17 +0000 (GMT) Content-Type: multipart/mixed; boundary="------------zcF0SKeNig21D05GD0oxoQsU" Message-ID: Date: Fri, 15 Oct 2021 13:51:15 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.2.0 Subject: Re: [PATCH] Fix loop split incorrect count and probability Content-Language: en-US To: Richard Biener Cc: gcc-patches@gcc.gnu.org, segher@kernel.crashing.org, fxue@os.amperecomputing.com, wschmidt@linux.ibm.com, guojiufu@linux.ibm.com, linkw@gcc.gnu.org, hubicka@ucw.cz References: <20210803085813.2217766-1-luoxhu@linux.ibm.com> <58f9e351-fc10-406e-5272-270ece73be71@linux.ibm.com> <4rpoq32-1r80-89p-436-npo6p91q72pr@fhfr.qr> From: Xionghu Luo In-Reply-To: <4rpoq32-1r80-89p-436-npo6p91q72pr@fhfr.qr> X-TM-AS-GCONF: 00 X-Proofpoint-ORIG-GUID: sPVeobnaWBMRENm6PE-wjYl6q6ytBKIH X-Proofpoint-GUID: sPVeobnaWBMRENm6PE-wjYl6q6ytBKIH X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.182.1,Aquarius:18.0.790,Hydra:6.0.425,FMLib:17.0.607.475 definitions=2021-10-14_12,2021-10-14_02,2020-04-07_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 bulkscore=0 adultscore=0 mlxscore=0 priorityscore=1501 phishscore=0 clxscore=1015 impostorscore=0 mlxlogscore=999 spamscore=0 malwarescore=0 lowpriorityscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2109230001 definitions=main-2110150035 X-Spam-Status: No, score=-12.2 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_EF, GIT_PATCH_0, NICE_REPLY_A, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 15 Oct 2021 05:51:32 -0000 This is a multi-part message in MIME format. --------------zcF0SKeNig21D05GD0oxoQsU Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit On 2021/9/23 20:17, Richard Biener wrote: > On Wed, 22 Sep 2021, Xionghu Luo wrote: > >> >> >> On 2021/8/11 17:16, Richard Biener wrote: >>> On Wed, 11 Aug 2021, Xionghu Luo wrote: >>> >>>> >>>> >>>> On 2021/8/10 22:47, Richard Biener wrote: >>>>> On Mon, 9 Aug 2021, Xionghu Luo wrote: >>>>> >>>>>> Thanks, >>>>>> >>>>>> On 2021/8/6 19:46, Richard Biener wrote: >>>>>>> On Tue, 3 Aug 2021, Xionghu Luo wrote: >>>>>>> >>>>>>>> loop split condition is moved between loop1 and loop2, the split bb's >>>>>>>> count and probability should also be duplicated instead of (100% vs >>>>>>>> INV), >>>>>>>> secondly, the original loop1 and loop2 count need be propotional from >>>>>>>> the >>>>>>>> original loop. >>>>>>>> >>>>>>>> >>>>>>>> diff base/loop-cond-split-1.c.151t.lsplit >>>>>>>> patched/loop-cond-split-1.c.151t.lsplit: >>>>>>>> ... >>>>>>>> int prephitmp_16; >>>>>>>> int prephitmp_25; >>>>>>>> >>>>>>>> [local count: 118111600]: >>>>>>>> if (n_7(D) > 0) >>>>>>>> goto ; [89.00%] >>>>>>>> else >>>>>>>> goto ; [11.00%] >>>>>>>> >>>>>>>> [local count: 118111600]: >>>>>>>> return; >>>>>>>> >>>>>>>> [local count: 105119324]: >>>>>>>> pretmp_3 = ga; >>>>>>>> >>>>>>>> - [local count: 955630225]: >>>>>>>> + [local count: 315357973]: >>>>>>>> # i_13 = PHI >>>>>>>> # prephitmp_12 = PHI >>>>>>>> if (prephitmp_12 != 0) >>>>>>>> goto ; [33.00%] >>>>>>>> else >>>>>>>> goto ; [67.00%] >>>>>>>> >>>>>>>> - [local count: 315357972]: >>>>>>>> + [local count: 104068130]: >>>>>>>> _2 = do_something (); >>>>>>>> ga = _2; >>>>>>>> >>>>>>>> - [local count: 955630225]: >>>>>>>> + [local count: 315357973]: >>>>>>>> # prephitmp_5 = PHI >>>>>>>> i_10 = inc (i_13); >>>>>>>> if (n_7(D) > i_10) >>>>>>>> goto ; [89.00%] >>>>>>>> else >>>>>>>> goto ; [11.00%] >>>>>>>> >>>>>>>> [local count: 105119324]: >>>>>>>> goto ; [100.00%] >>>>>>>> >>>>>>>> - [local count: 850510901]: >>>>>>>> + [local count: 280668596]: >>>>>>>> if (prephitmp_12 != 0) >>>>>>>> - goto ; [100.00%] >>>>>>>> + goto ; [33.00%] >>>>>>>> else >>>>>>>> - goto ; [INV] >>>>>>>> + goto ; [67.00%] >>>>>>>> >>>>>>>> - [local count: 850510901]: >>>>>>>> + [local count: 280668596]: >>>>>>>> goto ; [100.00%] >>>>>>>> >>>>>>>> - [count: 0]: >>>>>>>> + [local count: 70429947]: >>>>>>>> # i_23 = PHI >>>>>>>> # prephitmp_25 = PHI >>>>>>>> >>>>>>>> - [local count: 955630225]: >>>>>>>> + [local count: 640272252]: >>>>>>>> # i_15 = PHI >>>>>>>> # prephitmp_16 = PHI >>>>>>>> i_22 = inc (i_15); >>>>>>>> if (n_7(D) > i_22) >>>>>>>> goto ; [89.00%] >>>>>>>> else >>>>>>>> goto ; [11.00%] >>>>>>>> >>>>>>>> - [local count: 850510901]: >>>>>>>> + [local count: 569842305]: >>>>>>>> goto ; [100.00%] >>>>>>>> >>>>>>>> } >>>>>>>> >>>>>>>> gcc/ChangeLog: >>>>>>>> >>>>>>>> * tree-ssa-loop-split.c (split_loop): Fix incorrect probability. >>>>>>>> (do_split_loop_on_cond): Likewise. >>>>>>>> --- >>>>>>>> gcc/tree-ssa-loop-split.c | 16 ++++++++-------- >>>>>>>> 1 file changed, 8 insertions(+), 8 deletions(-) >>>>>>>> >>>>>>>> diff --git a/gcc/tree-ssa-loop-split.c b/gcc/tree-ssa-loop-split.c >>>>>>>> index 3a09bbc39e5..8e5a7ded0f7 100644 >>>>>>>> --- a/gcc/tree-ssa-loop-split.c >>>>>>>> +++ b/gcc/tree-ssa-loop-split.c >>>>>>>> @@ -583,10 +583,10 @@ split_loop (class loop *loop1) >>>>>>>> basic_block cond_bb; >>>>>> >>>>>> if (!initial_true) >>>>>> - cond = fold_build1 (TRUTH_NOT_EXPR, boolean_type_node, cond); >>>>>> + cond = fold_build1 (TRUTH_NOT_EXPR, boolean_type_node, cond); >>>>>> + >>>>>> + edge true_edge = EDGE_SUCC (bbs[i], 0)->flags & EDGE_TRUE_VALUE >>>>>> + ? EDGE_SUCC (bbs[i], 0) >>>>>> + : EDGE_SUCC (bbs[i], 1); >>>>>> >>>>>>>> >>>>>>>> class loop *loop2 = loop_version (loop1, cond, &cond_bb, >>>>>>>> - profile_probability::always >>>>>>>> (), >>>>>>>> - profile_probability::always >>>>>>>> (), >>>>>>>> - profile_probability::always >>>>>>>> (), >>>>>>>> - profile_probability::always >>>>>>>> (), >>>>>>>> + true_edge->probability, >>>>>>>> + >>>>>>>> true_edge->probability.invert (), >>>>>>>> + true_edge->probability, >>>>>>>> + >>>>>>>> true_edge->probability.invert (), >>>>>>>> true); >>>>>>> >>>>>>> there is no 'true_edge' variable at this point. >>>>>> >>>>>> Sorry, missed the above hunk when split the patch. >>>>>> >>>>>>> >>>>>>>> gcc_assert (loop2); >>>>>>>> @@ -1486,10 +1486,10 @@ do_split_loop_on_cond (struct loop *loop1, >>>>>>>> edge invar_branch) >>>>>>>> initialize_original_copy_tables (); >>>>>>>> >>>>>>>> struct loop *loop2 = loop_version (loop1, boolean_true_node, >>>>>>>> NULL, >>>>>>>> - profile_probability::always (), >>>>>>>> - profile_probability::never (), >>>>>>>> - profile_probability::always (), >>>>>>>> - profile_probability::always (), >>>>>>>> + invar_branch->probability.invert >>>>>>>> (), >>>>>>>> + invar_branch->probability, >>>>>>>> + invar_branch->probability.invert >>>>>>>> (), >>>>>>>> + invar_branch->probability, >>>>>>>> true); >>>>>>>> if (!loop2) >>>>>>>> { >>>>>>> >>>>>>> The patch introduction seems to talk about do_split_loop_on_cond only. >>>>>> >>>>>> split_loop faces similar issue though it sets the two branches to 100% vs >>>>>> 100% >>>>>> and no scaling which seems also incorrect. >>>>>> >>>>>>> Since loop versioning inserts a condition with the passed probabilities >>>>>>> but in this case a 'boolean_true_node' condition the then and else >>>>>>> probabilities passed look correct. It's just the scaling arguments >>>>>>> that look wrong? This loop_version call should get a comment as to >>>>>>> why we are passing probabilities the way we do. >>>>>> >>>>>> This optimization is transforming from: >>>>>> >>>>>> for (i = 0; i < n; i = inc (i)) >>>>>> { >>>>>> if (ga) >>>>>> ga = do_something (); >>>>>> } >>>>>> >>>>>> to: >>>>>> >>>>>> for (i = 0; i < x; i = inc (i)) >>>>>> { >>>>>> if (true) >>>>>> ga = do_something (); >>>>>> if (!ga) >>>>>> break; >>>>>> } >>>>>> for (; i < n; i = inc (i)) >>>>>> { >>>>>> if (false) >>>>>> ga = do_something (); >>>>>> } >>>>>> >>>>>> >>>>>> `boolean_true_node` is passed in to make the first loop's condition >>>>>> statement to be 'true', after returning from loop_version, there is a >>>>>> piece of code forcing the condition in second loop to be false, >>>>>> and the original condition is moved from *in loop* to *exit edge* >>>>>> between loop1 and loop2. >>>>> >>>>> Yes, one complication is that we use loop_version but do not retain >>>>> the CFG it creates. Something like the vectorizers >>>>> slpeel_tree_duplicate_loop_to_edge_cfg would be a better "fit" >>>>> but then that code doesn't do any scaling yet. But then >>>>> loop_version uses cfg_hook_duplicate_loop_to_header_edge and I suppose >>>>> we could write a variant that simply doesn't mangle the CFG >>>>> with a new condition switching between both loops but keeps them >>>>> executed after each other ... >>>>> >>>>> As said, this adds to the confusion and some awkwardness. >>>> >>>> Then loop_version in loop split requires two types of variant, one >>>> is to insert condition to loop preheader for 'split_loops' usage, >>>> another is to insert condition to loop exit for 'do_split_loop_on_cond' >>>> usage, it needs one extra function to encapsulate these cfg alterations >>>> from outside to inside. >>>> >>>> unswitching only execute one loop as it only moves the invariant condition >>>> to first loop's pre-header. While 'split_loops' and >>>> 'do_split_loop_on_cond' >>>> may execute both loops no matter the condition is moved to the first loop's >>>> preheader or exit. >>>> >>>> The condition stmt in loop unswitching is invariant, but it is variant >>>> in loop splitting, that's why loop unswitching execute only one loop >>>> but loop splitting executes both loops. >>>> >>>> Seems we need two condition arguments for loop_version, one for connecting >>>> loop1 preheader to loop2 preheader, another one for connecting loop1's exit >>>> to loop2's header? Then it will be more generic for both unswitching pass >>>> and splitting pass. Looks a bit complicated and conflicted with >>>> loop_version's >>>> comments: >>>> >>>> /* Main entry point for Loop Versioning transformation. >>>> >>>> This transformation given a condition and a loop, creates >>>> -if (condition) { loop_copy1 } else { loop_copy2 }, ... */ >>>> >>>> >>>> And this only works for loop split usage, those many other places >>>> doesn't use loop_version like this? >>> >>> Yes, as said if you don't want the above CFG then you probably >>> shouldn't use loop_version but instead use its building blocks >>> (and some refactoring of loop_version can make that easier). >>> >>> I think splitting wants >>> >>> loop_copy1 >>> if (condition) >>> loop_copy2 >>> >>> IMHO it would be good to split 'loopify' into the actual loopification >>> and the scaling. Basically make the part of loop_version that >>> copies the loop on the header edge and creates a loop structure for >>> it separate. >>> >>> loop distribution uses slpeel_tree_duplicate_loop_to_edge_cfg >>> (copy_loop_before). >>> >> >> Unfortunately slpeel_tree_duplicate_loop_to_edge_cfg only supports >> copying loops with single exit, it would cause many ICEs in it even >> building GCC stage1 (line 1065, line 1184 due to exit or new_exit >> is NULL returning from single_exit (loop).). Seems loop_version is >> more flexible for loop split. > > Hmm, sure - loop_version does not need to do anything special with > exits since control flow either enters the original or the loop copy. > > But slpeel_tree_duplicate_loop_to_edge_cfg intends to create > control flow that enters _both_ loops, so it needs to have > an edge from the first loop exit to the second loop entry. > > One could extend this to a region copy, copying eventual CFG merges > of exits and specifying which exit of a SEME region is supposed > to be connected to the original region entry. > > After all that's what loop splitting needs in the end - though not > sure what exactly it does with more than one exit. In tree-ssa-loop-split.c, split_loop only accepts single exit loop, the recently added split_loop_on_cond could process multiple exits loop. For example, do some changes to the loop-cond-split-1.c, int ga; extern int a; extern int b; extern int c; void test1 (int n) { int i; for (i = 0; i < n; i = inc (i)). { if (a+3 > 0) break; if (ga) ga = do_something (); for (int j = 0; j < n; j++) { b+=5; if (b > c) break; } } } the "if (ga)" will be a new exit edge from loop_copy1 to loop_copy2. I am not sure whether it is valuable to do semi-invariant loop split to such cases with multiple exits, but obviously the split_loop_on_cond is a special case from split_loop both duplicate loop to if (condition1) {loop_copy1} if (condition2) {loop_copy2} The only difference is condition1 is true for split_loop_on_cond. > > So there's another set of "loop" copying, gimple_duplicate_sese_region, > which doesn't actually require a single exit but a single "important" > exit. That might match how you treat multiple exits. gimple_duplicate_sese_region doesn't handle subloops and latches. Finally, I found that loop_version is still much better than slpeel_tree_duplicate_loop_to_edge_cfg and gimple_duplicate_sese_region since it could handle all cases like multiple exits/subloops, etc. I did some refactor to the code to introduce loop_version2 to create duplicated loops with two input conditions as attached patch, is this reasonable enough? I also tried to copy the code in loop_version out of it to don't call loop_version in loop_version2, but it seems useless with many duplicate code and NOT get rid of creating "if (condition1) {loop_copy1}" at first? -- Thanks, Xionghu --------------zcF0SKeNig21D05GD0oxoQsU Content-Type: text/plain; charset=UTF-8; name="0001-Add-loop_version2-to-support-loop-transformation-wit.patch" Content-Disposition: attachment; filename*0="0001-Add-loop_version2-to-support-loop-transformation-wit.pa"; filename*1="tch" Content-Transfer-Encoding: base64 RnJvbSBjZGUzYTNhMWFiNjAwMWYzNDBmM2RhNWMzN2I0MTZlYjQyZmViYzhlIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBYaW9uZyBIdSBMdW8gPGx1b3hodUBsaW51eC5pYm0u Y29tPgpEYXRlOiBUaHUsIDE0IE9jdCAyMDIxIDA0OjAxOjUwIC0wNTAwClN1YmplY3Q6IFtQ QVRDSF0gQWRkIGxvb3BfdmVyc2lvbjIgdG8gc3VwcG9ydCBsb29wIHRyYW5zZm9ybWF0aW9u IHdpdGggdHdvCiBjb25kaXRpb25zCgpsb29wX3ZlcnNpb24yIGlzIGFkZGVkIHRvIHN1cHBv cnQgdHJhbnNmb3JtIGxvb3AgdG8KICAtIGlmIChjb25kaXRpb24xKSB7bG9vcF9jb3B5MX0g aWYoY29uZGl0aW9uMikge2xvb3BfY29weTJ9LAp0byBzdXBwb3J0IGJvdGggbG9vcCBzcGxp dCBhbmQgbG9vcCBjb25kaXRpb25hbCBzcGxpdCB1c2FnZS4gIEFjdHVhbGx5CmRvX3NwbGl0 X2xvb3Bfb25fY29uZCBpcyBhIHNwZWNpZmljIHVzYWdlIGZyb20gbG9vcCBzcGxpdCB3aGVu CmNvbmRpdGlvbjEgaXMgdHJ1ZS4gVGhlIGxvb29wX3ZlcnNpb24yIGltcGxlbWVudGF0aW9u IGNhbGxzCmxvb3BfdmVyc2lvbiBmaXJzdCB0byBjcmVhdGUKIC1pZiAoY29uZGl0aW9uMSkg eyBsb29wX2NvcHkxICB9IGVsc2UgeyBsb29wX2NvcHkyICB9CmZpcnN0LCB0aGVuIGluc2Vy dCBjb25kaXRpb24yIHRvIGxvb3BfY29weTIgd2l0aCBjb25uZWN0X2xvb3BzLgoKZ2NjL0No YW5nZUxvZzoKCgkqIHRyZWUtc3NhLWxvb3Atc3BsaXQuYyAoY29ubmVjdF9sb29wX3BoaXMp OiBNb3ZlIGZyb20gLi4uCgkoY29ubmVjdF9sb29wcyk6IE1vdmUgZnJvbSAuLi4KCShzcGxp dF9sb29wKTogQ2FsbCBsb29wX3ZlcnNpb24yLgoJKGRvX3NwbGl0X2xvb3Bfb25fY29uZCk6 IENhbGwgbG9vcF92ZXJzaW9uMi4KCSogY2ZnbG9vcG1hbmlwLmMgKGNvbm5lY3RfbG9vcF9w aGlzKTogLi4uIHRvIHRoaXMuCgkoY29ubmVjdF9sb29wcyk6IC4uLiB0byB0aGlzLgoJKGxv b3BfdmVyc2lvbjIpOiBOZXcgZnVuY3Rpb24uCgkqIGNmZ2xvb3BtYW5pcC5oIChsb29wX3Zl cnNpb24yKTogTmV3IGRlY2xhcmUuCi0tLQogZ2NjL2NmZ2xvb3BtYW5pcC5jICAgICAgICB8 IDE3OCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogZ2NjL2NmZ2xv b3BtYW5pcC5oICAgICAgICB8ICAgNSArKwogZ2NjL3RyZWUtc3NhLWxvb3Atc3BsaXQuYyB8 ICA1OCArKysrLS0tLS0tLS0tCiAzIGZpbGVzIGNoYW5nZWQsIDIwMSBpbnNlcnRpb25zKCsp LCA0MCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9nY2MvY2ZnbG9vcG1hbmlwLmMgYi9n Y2MvY2ZnbG9vcG1hbmlwLmMKaW5kZXggODJjMjQyZGQ3MjAuLmI1ZDBkOTk3MzRkIDEwMDY0 NAotLS0gYS9nY2MvY2ZnbG9vcG1hbmlwLmMKKysrIGIvZ2NjL2NmZ2xvb3BtYW5pcC5jCkBA IC0yNCw2ICsyNCw4IEBAIGFsb25nIHdpdGggR0NDOyBzZWUgdGhlIGZpbGUgQ09QWUlORzMu ICBJZiBub3Qgc2VlCiAjaW5jbHVkZSAicnRsLmgiCiAjaW5jbHVkZSAidHJlZS5oIgogI2lu Y2x1ZGUgImdpbXBsZS5oIgorI2luY2x1ZGUgInNzYS5oIgorI2luY2x1ZGUgInRyZWUtY2Zn LmgiCiAjaW5jbHVkZSAiY2ZnaG9va3MuaCIKICNpbmNsdWRlICJjZmdhbmFsLmgiCiAjaW5j bHVkZSAiY2ZnbG9vcC5oIgpAQCAtMTc2OCwzICsxNzcwLDE3OSBAQCBsb29wX3ZlcnNpb24g KGNsYXNzIGxvb3AgKmxvb3AsCiAKICAgcmV0dXJuIG5sb29wOwogfQorCisvKiBUaGlzIGZ1 bmN0aW9uIHVwZGF0ZXMgdGhlIFNTQSBmb3JtIGFmdGVyIGNvbm5lY3RfbG9vcHMgbWFkZSBh IG5ldworICAgZWRnZSBORVdfRSBsZWFkaW5nIGZyb20gTE9PUDEgZXhpdCB0byBMT09QMiAo dmlhIGluIGludGVybWVkaWF0ZQorICAgY29uZGl0aW9uYWwpLiAgSS5lLiB0aGUgc2Vjb25k IGxvb3AgY2FuIG5vdyBiZSBlbnRlcmVkIGVpdGhlcgorICAgdmlhIHRoZSBvcmlnaW5hbCBl bnRyeSBvciB2aWEgTkVXX0UsIHNvIHRoZSBlbnRyeSB2YWx1ZXMgb2YgTE9PUDIKKyAgIHBo aSBub2RlcyBhcmUgZWl0aGVyIHRoZSBvcmlnaW5hbCBvbmVzIG9yIHRob3NlIGF0IHRoZSBl eGl0CisgICBvZiBMT09QMS4gIEluc2VydCBuZXcgcGhpIG5vZGVzIGluIExPT1AyIHByZS1o ZWFkZXIgcmVmbGVjdGluZworICAgdGhpcy4gIFRoZSBsb29wcyBuZWVkIHRvIGZ1bGZpbGwg ZWFzeV9leGl0X3ZhbHVlcygpLiAgKi8KKworc3RhdGljIHZvaWQKK2Nvbm5lY3RfbG9vcF9w aGlzIChjbGFzcyBsb29wICpsb29wMSwgY2xhc3MgbG9vcCAqbG9vcDIsIGVkZ2UgbmV3X2Up Cit7CisgIGJhc2ljX2Jsb2NrIHJlc3QgPSBsb29wX3ByZWhlYWRlcl9lZGdlIChsb29wMikt PnNyYzsKKyAgZ2NjX2Fzc2VydCAobmV3X2UtPmRlc3QgPT0gcmVzdCk7CisgIGVkZ2Ugc2tp cF9maXJzdCA9IEVER0VfUFJFRCAocmVzdCwgRURHRV9QUkVEIChyZXN0LCAwKSA9PSBuZXdf ZSk7CisKKyAgZWRnZSBmaXJzdGUgPSBsb29wX3ByZWhlYWRlcl9lZGdlIChsb29wMSk7Cisg IGVkZ2Ugc2Vjb25kZSA9IGxvb3BfcHJlaGVhZGVyX2VkZ2UgKGxvb3AyKTsKKyAgZWRnZSBm aXJzdG4gPSBsb29wX2xhdGNoX2VkZ2UgKGxvb3AxKTsKKyAgZ3BoaV9pdGVyYXRvciBwc2lf Zmlyc3QsIHBzaV9zZWNvbmQ7CisgIGZvciAocHNpX2ZpcnN0ID0gZ3NpX3N0YXJ0X3BoaXMg KGxvb3AxLT5oZWFkZXIpLAorICAgICAgIHBzaV9zZWNvbmQgPSBnc2lfc3RhcnRfcGhpcyAo bG9vcDItPmhlYWRlcik7CisgICAgICAgIWdzaV9lbmRfcCAocHNpX2ZpcnN0KTsKKyAgICAg ICBnc2lfbmV4dCAoJnBzaV9maXJzdCksIGdzaV9uZXh0ICgmcHNpX3NlY29uZCkpCisgICAg eworICAgICAgdHJlZSBpbml0LCBuZXh0LCBuZXdfaW5pdDsKKyAgICAgIHVzZV9vcGVyYW5k X3Agb3A7CisgICAgICBncGhpICpwaGlfZmlyc3QgPSBwc2lfZmlyc3QucGhpICgpOworICAg ICAgZ3BoaSAqcGhpX3NlY29uZCA9IHBzaV9zZWNvbmQucGhpICgpOworCisgICAgICBpbml0 ID0gUEhJX0FSR19ERUZfRlJPTV9FREdFIChwaGlfZmlyc3QsIGZpcnN0ZSk7CisgICAgICBu ZXh0ID0gUEhJX0FSR19ERUZfRlJPTV9FREdFIChwaGlfZmlyc3QsIGZpcnN0bik7CisgICAg ICBvcCA9IFBISV9BUkdfREVGX1BUUl9GUk9NX0VER0UgKHBoaV9zZWNvbmQsIHNlY29uZGUp OworICAgICAgZ2NjX2Fzc2VydCAob3BlcmFuZF9lcXVhbF9mb3JfcGhpX2FyZ19wIChpbml0 LCBVU0VfRlJPTV9QVFIgKG9wKSkpOworCisgICAgICAvKiBQcmVmZXIgdXNpbmcgb3JpZ2lu YWwgdmFyaWFibGUgYXMgYSBiYXNlIGZvciB0aGUgbmV3IHNzYSBuYW1lLgorCSBUaGlzIGlz IG5lY2Vzc2FyeSBmb3IgdmlydHVhbCBvcHMsIGFuZCB1c2VmdWwgaW4gb3JkZXIgdG8gYXZv aWQKKwkgbG9zaW5nIGRlYnVnIGluZm8gZm9yIHJlYWwgb3BzLiAgKi8KKyAgICAgIGlmIChU UkVFX0NPREUgKG5leHQpID09IFNTQV9OQU1FCisJICAmJiB1c2VsZXNzX3R5cGVfY29udmVy c2lvbl9wIChUUkVFX1RZUEUgKG5leHQpLAorCQkJCQlUUkVFX1RZUEUgKGluaXQpKSkKKwlu ZXdfaW5pdCA9IGNvcHlfc3NhX25hbWUgKG5leHQpOworICAgICAgZWxzZSBpZiAoVFJFRV9D T0RFIChpbml0KSA9PSBTU0FfTkFNRQorCSAgICAgICAmJiB1c2VsZXNzX3R5cGVfY29udmVy c2lvbl9wIChUUkVFX1RZUEUgKGluaXQpLAorCQkJCQkgICAgIFRSRUVfVFlQRSAobmV4dCkp KQorCW5ld19pbml0ID0gY29weV9zc2FfbmFtZSAoaW5pdCk7CisgICAgICBlbHNlIGlmICh1 c2VsZXNzX3R5cGVfY29udmVyc2lvbl9wIChUUkVFX1RZUEUgKG5leHQpLAorCQkJCQkgIFRS RUVfVFlQRSAoaW5pdCkpKQorCW5ld19pbml0ID0gbWFrZV90ZW1wX3NzYV9uYW1lIChUUkVF X1RZUEUgKG5leHQpLCBOVUxMLAorCQkJCSAgICAgICAidW5yaW5pdHRtcCIpOworICAgICAg ZWxzZQorCW5ld19pbml0ID0gbWFrZV90ZW1wX3NzYV9uYW1lIChUUkVFX1RZUEUgKGluaXQp LCBOVUxMLAorCQkJCSAgICAgICAidW5yaW5pdHRtcCIpOworCisgICAgICBncGhpICogbmV3 cGhpID0gY3JlYXRlX3BoaV9ub2RlIChuZXdfaW5pdCwgcmVzdCk7CisgICAgICBhZGRfcGhp X2FyZyAobmV3cGhpLCBpbml0LCBza2lwX2ZpcnN0LCBVTktOT1dOX0xPQ0FUSU9OKTsKKyAg ICAgIGFkZF9waGlfYXJnIChuZXdwaGksIG5leHQsIG5ld19lLCBVTktOT1dOX0xPQ0FUSU9O KTsKKyAgICAgIFNFVF9VU0UgKG9wLCBuZXdfaW5pdCk7CisgICAgfQorfQorCisvKiBUaGUg dHdvIGxvb3BzIExPT1AxIGFuZCBMT09QMiB3ZXJlIGp1c3QgY3JlYXRlZCBieSBsb29wIHZl cnNpb25pbmcsCisgICB0aGV5IGFyZSBzdGlsbCBlcXVpdmFsZW50IGFuZCBwbGFjZWQgaW4g dHdvIGFybXMgb2YgYSBkaWFtb25kLCBsaWtlIHNvOgorCisgICAgICAgICAgICAgICAuLS0t LS0taWYgKGNvbmQpLS0tLS0tLgorICAgICAgICAgICAgICAgdiAgICAgICAgICAgICAgICAg ICAgIHYKKyAgICAgICAgICAgICBwcmUxICAgICAgICAgICAgICAgICAgIHByZTIKKyAgICAg ICAgICAgICAgfCAgICAgICAgICAgICAgICAgICAgICB8CisgICAgICAgIC4tLS0+aDEgICAg ICAgICAgICAgICAgICAgICBoMjwtLS0tLgorICAgICAgICB8ICAgICB8ICAgICAgICAgICAg ICAgICAgICAgIHwgICAgIHwKKyAgICAgICAgfCAgICBleDEtLS0uICAgICAgICAgICAgLi0t LWV4MiAgICB8CisgICAgICAgIHwgICAgLyAgICAgfCAgICAgICAgICAgIHwgICAgIFwgICAg fAorICAgICAgICAnLS0tbDEgICAgIFggICAgICAgICAgICB8ICAgICBsMi0tLScKKyAgICAg ICAgICAgICAgICAgICB8ICAgICAgICAgICAgfAorICAgICAgICAgICAgICAgICAgIHwgICAg ICAgICAgICB8CisgICAgICAgICAgICAgICAgICAgJy0tLT5qb2luPC0tLScKKworICAgVGhp cyBmdW5jdGlvbiB0cmFuc2Zvcm1zIHRoZSBwcm9ncmFtIHN1Y2ggdGhhdCBMT09QMSBpcyBj b25kaXRpb25hbGx5CisgICBmYWxsaW5nIHRocm91Z2ggdG8gTE9PUDIsIG9yIHNraXBwaW5n IGl0LiAgVGhpcyBpcyBkb25lIGJ5IHNwbGl0dGluZworICAgdGhlIGV4MS0+am9pbiBlZGdl IGF0IFggaW4gdGhlIGRpYWdyYW0gYWJvdmUsIGFuZCBpbnNlcnRpbmcgYSBjb25kaXRpb24K KyAgIHdob3NlIG9uZSBhcm0gZ29lcyB0byBwcmUyLCByZXN1bHRpbmcgaW4gdGhpcyBzaXR1 YXRpb246CisKKyAgICAgICAgICAgICAgIC4tLS0tLS1pZiAoY29uZCktLS0tLS0uCisgICAg ICAgICAgICAgICB2ICAgICAgICAgICAgICAgICAgICAgdgorICAgICAgICAgICAgIHByZTEg ICAgICAgLi0tLS0tLS0tLS0+cHJlMgorICAgICAgICAgICAgICB8ICAgICAgICAgfCAgICAg ICAgICAgIHwKKyAgICAgICAgLi0tLT5oMSAgICAgICAgIHwgICAgICAgICAgIGgyPC0tLS0u CisgICAgICAgIHwgICAgIHwgICAgICAgICB8ICAgICAgICAgICAgfCAgICAgfAorICAgICAg ICB8ICAgIGV4MS0tLS4gICAgfCAgICAgICAuLS0tZXgyICAgIHwKKyAgICAgICAgfCAgICAv ICAgICB2ICAgIHwgICAgICAgfCAgICAgXCAgICB8CisgICAgICAgICctLS1sMSAgIHNraXAt LS0nICAgICAgIHwgICAgIGwyLS0tJworICAgICAgICAgICAgICAgICAgIHwgICAgICAgICAg ICB8CisgICAgICAgICAgICAgICAgICAgfCAgICAgICAgICAgIHwKKyAgICAgICAgICAgICAg ICAgICAnLS0tPmpvaW48LS0tJworCisKKyAgIFRoZSBjb25kaXRpb24gdXNlZCBpcyB0aGUg ZXhpdCBjb25kaXRpb24gb2YgTE9PUDEsIHdoaWNoIGVmZmVjdGl2ZWx5IG1lYW5zCisgICB0 aGF0IHdoZW4gdGhlIGZpcnN0IGxvb3AgZXhpdHMgKGZvciB3aGF0ZXZlciByZWFzb24pIGJ1 dCB0aGUgcmVhbCBvcmlnaW5hbAorICAgZXhpdCBleHByZXNzaW9uIGlzIHN0aWxsIGZhbHNl IHRoZSBzZWNvbmQgbG9vcCB3aWxsIGJlIGVudGVyZWQuCisgICBUaGUgZnVuY3Rpb24gcmV0 dXJucyB0aGUgbmV3IGVkZ2UgY29uZC0+cHJlMi4KKworICAgVGhpcyBkb2Vzbid0IHVwZGF0 ZSB0aGUgU1NBIGZvcm0sIHNlZSBjb25uZWN0X2xvb3BfcGhpcyBmb3IgdGhhdC4gICovCisK K3N0YXRpYyBlZGdlCitjb25uZWN0X2xvb3BzIChjbGFzcyBsb29wICpsb29wMSwgY2xhc3Mg bG9vcCAqbG9vcDIsIHZvaWQgKmNvbmRfZSkKK3sKKyAgdHJlZSBjb25kX2V4cHIgPSAodHJl ZSkgY29uZF9lOworICBlZGdlIGV4aXQgPSBzaW5nbGVfZXhpdCAobG9vcDEpOworICBiYXNp Y19ibG9jayBza2lwX2JiID0gc3BsaXRfZWRnZSAoZXhpdCk7CisgIGdpbXBsZSAqbmV3X2Nv bmRfZXhwcjsKKyAgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgZ3NpOworICBlZGdlIG5ld19lLCBz a2lwX2U7CisKKyAgbmV3X2NvbmRfZXhwciA9IGdpbXBsZV9idWlsZF9jb25kX2Zyb21fdHJl ZSAoY29uZF9leHByLCBOVUxMX1RSRUUsIE5VTExfVFJFRSk7CisKKyAgZ3NpID0gZ3NpX2xh c3RfYmIgKHNraXBfYmIpOworICBnc2lfaW5zZXJ0X2FmdGVyICgmZ3NpLCBuZXdfY29uZF9l eHByLCBHU0lfTkVXX1NUTVQpOworCisgIHNraXBfZSA9IEVER0VfU1VDQyAoc2tpcF9iYiwg MCk7CisgIHNraXBfZS0+ZmxhZ3MgJj0gfkVER0VfRkFMTFRIUlU7CisgIG5ld19lID0gbWFr ZV9lZGdlIChza2lwX2JiLCBsb29wX3ByZWhlYWRlcl9lZGdlIChsb29wMiktPnNyYywgMCk7 CisgIGlmIChleGl0LT5mbGFncyAmIEVER0VfVFJVRV9WQUxVRSkKKyAgICB7CisgICAgICBz a2lwX2UtPmZsYWdzIHw9IEVER0VfVFJVRV9WQUxVRTsKKyAgICAgIG5ld19lLT5mbGFncyB8 PSBFREdFX0ZBTFNFX1ZBTFVFOworICAgIH0KKyAgZWxzZQorICAgIHsKKyAgICAgIHNraXBf ZS0+ZmxhZ3MgfD0gRURHRV9GQUxTRV9WQUxVRTsKKyAgICAgIG5ld19lLT5mbGFncyB8PSBF REdFX1RSVUVfVkFMVUU7CisgICAgfQorCisgIG5ld19lLT5wcm9iYWJpbGl0eSA9IHByb2Zp bGVfcHJvYmFiaWxpdHk6Omxpa2VseSAoKTsKKyAgc2tpcF9lLT5wcm9iYWJpbGl0eSA9IG5l d19lLT5wcm9iYWJpbGl0eS5pbnZlcnQgKCk7CisKKyAgcmV0dXJuIG5ld19lOworfQorCisv KiBNYWluIGVudHJ5IHBvaW50IGZvciBMb29wIFZlcnNpb25pbmcgdHJhbnNmb3JtYXRpb24g d2l0aCB0d28gY29uZGl0aW9ucy4KKworICAgVGhpcyB0cmFuc2Zvcm1hdGlvbiBnaXZlbiBh IGNvbmRpdGlvbiBhbmQgYSBsb29wLCBjcmVhdGVzCisgICAtaWYgKGNvbmRpdGlvbjEpIHsg bG9vcF9jb3B5MSB9IGlmIChjb25kaXRpb24yKSB7IGxvb3BfY29weTIgfSwKKyAgIHdoZXJl IGxvb3BfY29weTEgaXMgdGhlIGxvb3AgdHJhbnNmb3JtZWQgaW4gb25lIHdheSwgYW5kIGxv b3BfY29weTIKKyAgIGlzIHRoZSBsb29wIHRyYW5zZm9ybWVkIGluIGFub3RoZXIgd2F5IChv ciB1bmNoYW5nZWQpLiBDT05EX0VYUFIxCisgICBhbmQgQ09ORF9FWFBSMiBtYXkgYmUgYSBy dW4gdGltZSB0ZXN0IGZvciB0aGluZ3MgdGhhdCB3ZXJlIG5vdCByZXNvbHZlZCBieQorICAg c3RhdGljIGFuYWx5c2lzIChvdmVybGFwcGluZyByYW5nZXMgKGFudGktYWxpYXNpbmcpLCBh bGlnbm1lbnQsIGV0Yy4pLgorCisgICBJZiBub24tTlVMTCwgQ09ORElUSU9OX0JCIGlzIHNl dCB0byB0aGUgYmFzaWMgYmxvY2sKKyAgIGNvbnRhaW5pbmcgdGhlIGNvbmRpdGlvbi4KKwor ICAgVEhFTl9QUk9CIGlzIHRoZSBwcm9iYWJpbGl0eSBvZiB0aGUgdGhlbiBlZGdlIG9mIHRo ZSBpZi4gIFRIRU5fU0NBTEUKKyAgIGlzIHRoZSByYXRpbyBieSB0aGF0IHRoZSBmcmVxdWVu Y2llcyBpbiB0aGUgb3JpZ2luYWwgbG9vcCBzaG91bGQKKyAgIGJlIHNjYWxlZC4gIEVMU0Vf U0NBTEUgaXMgdGhlIHJhdGlvIGJ5IHRoYXQgdGhlIGZyZXF1ZW5jaWVzIGluIHRoZQorICAg bmV3IGxvb3Agc2hvdWxkIGJlIHNjYWxlZC4KKworICAgSWYgUExBQ0VfQUZURVIgaXMgdHJ1 ZSwgd2UgcGxhY2UgdGhlIG5ldyBsb29wIGFmdGVyIExPT1AgaW4gdGhlCisgICBpbnN0cnVj dGlvbiBzdHJlYW0sIG90aGVyd2lzZSBpdCBpcyBwbGFjZWQgYmVmb3JlIExPT1AuICAqLwor CitjbGFzcyBsb29wICoKK2xvb3BfdmVyc2lvbjIgKGNsYXNzIGxvb3AgKmxvb3AsIHZvaWQg KmNvbmRfZXhwcjEsIGJhc2ljX2Jsb2NrICpjb25kaXRpb25fYmIsCisJICAgICAgIHZvaWQg KmNvbmRfZXhwcjIsIHByb2ZpbGVfcHJvYmFiaWxpdHkgdGhlbl9wcm9iLAorCSAgICAgICBw cm9maWxlX3Byb2JhYmlsaXR5IGVsc2VfcHJvYiwgcHJvZmlsZV9wcm9iYWJpbGl0eSB0aGVu X3NjYWxlLAorCSAgICAgICBwcm9maWxlX3Byb2JhYmlsaXR5IGVsc2Vfc2NhbGUsIGJvb2wg cGxhY2VfYWZ0ZXIpCit7CisgIC8qIEdlbmVyYXRlIGlmIChjb25kaXRpb24xKSB7bG9vcF9j b3B5MX0gZWxzZSB7bG9vcF9jb3B5Mn0gYW5kIHByb3BvdGlvbiB0aGUKKyAgICBwcm9maWxl X2NvdW50IGZpcnN0LiAgKi8KKyAgY2xhc3MgbG9vcCAqbmxvb3AgPSBsb29wX3ZlcnNpb24g KGxvb3AsIGNvbmRfZXhwcjEsIGNvbmRpdGlvbl9iYiwgdGhlbl9wcm9iLAorCQkJCSAgICBl bHNlX3Byb2IsIHRoZW5fc2NhbGUsIGVsc2Vfc2NhbGUsIHBsYWNlX2FmdGVyKTsKKworICAv KiBGaXggdXAgdGhlIGNmZyB0bworICAgICAgLSBpZiAoY29uZGl0aW9uMSkge2xvb3BfY29w eTF9OyBpZiAoY29uZGl0aW9uMikge2xvb3BfY29weTJ9LiAgKi8KKyAgZWRnZSBuZXdfZSA9 IGNvbm5lY3RfbG9vcHMgKGxvb3AsIG5sb29wLCBjb25kX2V4cHIyKTsKKyAgY29ubmVjdF9s b29wX3BoaXMgKGxvb3AsIG5sb29wLCBuZXdfZSk7CisKKyAgcmV0dXJuIG5sb29wOworfQpk aWZmIC0tZ2l0IGEvZ2NjL2NmZ2xvb3BtYW5pcC5oIGIvZ2NjL2NmZ2xvb3BtYW5pcC5oCmlu ZGV4IDA3ZDVmOTI1Yjc5Li4yM2IwNzdlOTRkNSAxMDA2NDQKLS0tIGEvZ2NjL2NmZ2xvb3Bt YW5pcC5oCisrKyBiL2djYy9jZmdsb29wbWFuaXAuaApAQCAtNjMsNCArNjMsOSBAQCBjbGFz cyBsb29wICogbG9vcF92ZXJzaW9uIChjbGFzcyBsb29wICosIHZvaWQgKiwKIAkJCSAgICBw cm9maWxlX3Byb2JhYmlsaXR5LCBwcm9maWxlX3Byb2JhYmlsaXR5LAogCQkJICAgIHByb2Zp bGVfcHJvYmFiaWxpdHksIHByb2ZpbGVfcHJvYmFiaWxpdHksIGJvb2wpOwogCitjbGFzcyBs b29wICogbG9vcF92ZXJzaW9uMiAoY2xhc3MgbG9vcCAqLCB2b2lkICosCisJCQkgICAgYmFz aWNfYmxvY2sgKiwgdm9pZCAqLAorCQkJICAgIHByb2ZpbGVfcHJvYmFiaWxpdHksIHByb2Zp bGVfcHJvYmFiaWxpdHksCisJCQkgICAgcHJvZmlsZV9wcm9iYWJpbGl0eSwgcHJvZmlsZV9w cm9iYWJpbGl0eSwgYm9vbCk7CisKICNlbmRpZiAvKiBHQ0NfQ0ZHTE9PUE1BTklQX0ggKi8K ZGlmZiAtLWdpdCBhL2djYy90cmVlLXNzYS1sb29wLXNwbGl0LmMgYi9nY2MvdHJlZS1zc2Et bG9vcC1zcGxpdC5jCmluZGV4IGQzMDc4Mjg4OGYzLi5mMzA5NjQ4ODQ3MyAxMDA2NDQKLS0t IGEvZ2NjL3RyZWUtc3NhLWxvb3Atc3BsaXQuYworKysgYi9nY2MvdHJlZS1zc2EtbG9vcC1z cGxpdC5jCkBAIC01NzMsOSArNTczLDkgQEAgc3BsaXRfbG9vcCAoY2xhc3MgbG9vcCAqbG9v cDEpCiAJaWYgKHN0bXRzMikKIAkgIGdzaV9pbnNlcnRfc2VxX29uX2VkZ2VfaW1tZWRpYXRl IChsb29wX3ByZWhlYWRlcl9lZGdlIChsb29wMSksCiAJCQkJCSAgICBzdG10czIpOwotCXRy ZWUgY29uZCA9IGJ1aWxkMiAoZ3VhcmRfY29kZSwgYm9vbGVhbl90eXBlX25vZGUsIGd1YXJk X2luaXQsIGJvcmRlcik7CisJdHJlZSBjb25kMSA9IGJ1aWxkMiAoZ3VhcmRfY29kZSwgYm9v bGVhbl90eXBlX25vZGUsIGd1YXJkX2luaXQsIGJvcmRlcik7CiAJaWYgKCFpbml0aWFsX3Ry dWUpCi0JICBjb25kID0gZm9sZF9idWlsZDEgKFRSVVRIX05PVF9FWFBSLCBib29sZWFuX3R5 cGVfbm9kZSwgY29uZCk7CisJICBjb25kMSA9IGZvbGRfYnVpbGQxIChUUlVUSF9OT1RfRVhQ UiwgYm9vbGVhbl90eXBlX25vZGUsIGNvbmQxKTsKIAogCWVkZ2UgdHJ1ZV9lZGdlID0gRURH RV9TVUNDIChiYnNbaV0sIDApLT5mbGFncyAmIEVER0VfVFJVRV9WQUxVRQogCQkJICAgPyBF REdFX1NVQ0MgKGJic1tpXSwgMCkKQEAgLTU4NiwxNiArNTg2LDE5IEBAIHNwbGl0X2xvb3Ag KGNsYXNzIGxvb3AgKmxvb3AxKQogCWluaXRpYWxpemVfb3JpZ2luYWxfY29weV90YWJsZXMg KCk7CiAJYmFzaWNfYmxvY2sgY29uZF9iYjsKIAotCWNsYXNzIGxvb3AgKmxvb3AyID0gbG9v cF92ZXJzaW9uIChsb29wMSwgY29uZCwgJmNvbmRfYmIsCisJZWRnZSBleGl0ID0gc2luZ2xl X2V4aXQgKGxvb3AxKTsKKwlnaW1wbGUgKnN0bXQgPSBsYXN0X3N0bXQgKGV4aXQtPnNyYyk7 CisJdHJlZSBjb25kMiA9IGJ1aWxkMiAoZ2ltcGxlX2NvbmRfY29kZSAoc3RtdCksIGJvb2xl YW5fdHlwZV9ub2RlLAorCQkJICAgICBnaW1wbGVfY29uZF9saHMgKHN0bXQpLCBnaW1wbGVf Y29uZF9yaHMgKHN0bXQpKTsKKworCWNsYXNzIGxvb3AgKmxvb3AyID0gbG9vcF92ZXJzaW9u MiAobG9vcDEsIGNvbmQxLCAmY29uZF9iYiwgY29uZDIsCiAJCQkJCSAgIHRydWVfZWRnZS0+ cHJvYmFiaWxpdHksCiAJCQkJCSAgIHRydWVfZWRnZS0+cHJvYmFiaWxpdHkuaW52ZXJ0ICgp LAogCQkJCQkgICB0cnVlX2VkZ2UtPnByb2JhYmlsaXR5LAogCQkJCQkgICB0cnVlX2VkZ2Ut PnByb2JhYmlsaXR5LmludmVydCAoKSwKIAkJCQkJICAgdHJ1ZSk7Ci0JZ2NjX2Fzc2VydCAo bG9vcDIpOwogCi0JZWRnZSBuZXdfZSA9IGNvbm5lY3RfbG9vcHMgKGxvb3AxLCBsb29wMik7 Ci0JY29ubmVjdF9sb29wX3BoaXMgKGxvb3AxLCBsb29wMiwgbmV3X2UpOworCWdjY19hc3Nl cnQgKGxvb3AyKTsKIAogCS8qIFRoZSBpdGVyYXRpb25zIG9mIHRoZSBzZWNvbmQgbG9vcCBp cyBub3cgYWxyZWFkeQogCSAgIGV4YWN0bHkgdGhvc2UgdGhhdCB0aGUgZmlyc3QgbG9vcCBk aWRuJ3QgZG8sIGJ1dCB0aGUKQEAgLTE0ODksMTIgKzE0OTIsMTYgQEAgZG9fc3BsaXRfbG9v cF9vbl9jb25kIChzdHJ1Y3QgbG9vcCAqbG9vcDEsIGVkZ2UgaW52YXJfYnJhbmNoKQogCiAg IGluaXRpYWxpemVfb3JpZ2luYWxfY29weV90YWJsZXMgKCk7CiAKLSAgc3RydWN0IGxvb3Ag Kmxvb3AyID0gbG9vcF92ZXJzaW9uIChsb29wMSwgYm9vbGVhbl90cnVlX25vZGUsIE5VTEws Ci0JCQkJICAgICBpbnZhcl9icmFuY2gtPnByb2JhYmlsaXR5LmludmVydCAoKSwKLQkJCQkg ICAgIGludmFyX2JyYW5jaC0+cHJvYmFiaWxpdHksCisgIGdpbXBsZSAqYnJlYWtfY29uZCA9 IGdpbXBsZV9idWlsZF9jb25kIChnaW1wbGVfY29uZF9jb2RlKGNvbmQpLAorCQkJCQkgIGdp bXBsZV9jb25kX2xocyAoY29uZCksCisJCQkJCSAgZ2ltcGxlX2NvbmRfcmhzIChjb25kKSwK KwkJCQkJICBOVUxMX1RSRUUsIE5VTExfVFJFRSk7CisKKyAgY2xhc3MgbG9vcCAqbG9vcDIg PSBsb29wX3ZlcnNpb24yIChsb29wMSwgYm9vbGVhbl90cnVlX25vZGUsICZjb25kX2JiLAor CQkJCSAgICAgYnJlYWtfY29uZCwgcHJvZmlsZV9wcm9iYWJpbGl0eTo6YWx3YXlzICgpLAor CQkJCSAgICAgcHJvZmlsZV9wcm9iYWJpbGl0eTo6bmV2ZXIgKCksCiAJCQkJICAgICBpbnZh cl9icmFuY2gtPnByb2JhYmlsaXR5LmludmVydCAoKSwKLQkJCQkgICAgIGludmFyX2JyYW5j aC0+cHJvYmFiaWxpdHksCi0JCQkJICAgICB0cnVlKTsKKwkJCQkgICAgIGludmFyX2JyYW5j aC0+cHJvYmFiaWxpdHksIHRydWUpOwogICBpZiAoIWxvb3AyKQogICAgIHsKICAgICAgIGZy ZWVfb3JpZ2luYWxfY29weV90YWJsZXMgKCk7CkBAIC0xNTEzLDM1ICsxNTIwLDYgQEAgZG9f c3BsaXRfbG9vcF9vbl9jb25kIChzdHJ1Y3QgbG9vcCAqbG9vcDEsIGVkZ2UgaW52YXJfYnJh bmNoKQogCiAgIHVwZGF0ZV9zdG10IChjb25kX2NvcHkpOwogCi0gIC8qIEluc2VydCBhIG5l dyBjb25kaXRpb25hbCBzdGF0ZW1lbnQgb24gbGF0Y2ggZWRnZSBvZiBsb29wMSwgaXRzIGNv bmRpdGlvbgotICAgICBpcyBkdXBsaWNhdGVkIGZyb20gdGhlIHNlbWktaW52YXJpYW50LiAg VGhpcyBzdGF0ZW1lbnQgYWN0cyBhcyBhIHN3aXRjaAotICAgICB0byB0cmFuc2ZlciBleGVj dXRpb24gZnJvbSBsb29wMSB0byBsb29wMiwgd2hlbiBsb29wMSBlbnRlcnMgaW50bwotICAg ICBpbnZhcmlhbnQgc3RhdGUuICAqLwotICBiYXNpY19ibG9jayBsYXRjaF9iYiA9IHNwbGl0 X2VkZ2UgKGxvb3BfbGF0Y2hfZWRnZSAobG9vcDEpKTsKLSAgYmFzaWNfYmxvY2sgYnJlYWtf YmIgPSBzcGxpdF9lZGdlIChzaW5nbGVfcHJlZF9lZGdlIChsYXRjaF9iYikpOwotICBnaW1w bGUgKmJyZWFrX2NvbmQgPSBnaW1wbGVfYnVpbGRfY29uZCAoZ2ltcGxlX2NvbmRfY29kZShj b25kKSwKLQkJCQkJICBnaW1wbGVfY29uZF9saHMgKGNvbmQpLAotCQkJCQkgIGdpbXBsZV9j b25kX3JocyAoY29uZCksCi0JCQkJCSAgTlVMTF9UUkVFLCBOVUxMX1RSRUUpOwotCi0gIGdp bXBsZV9zdG10X2l0ZXJhdG9yIGdzaSA9IGdzaV9sYXN0X2JiIChicmVha19iYik7Ci0gIGdz aV9pbnNlcnRfYWZ0ZXIgKCZnc2ksIGJyZWFrX2NvbmQsIEdTSV9ORVdfU1RNVCk7Ci0KLSAg ZWRnZSB0b19sb29wMSA9IHNpbmdsZV9zdWNjX2VkZ2UgKGJyZWFrX2JiKTsKLSAgZWRnZSB0 b19sb29wMiA9IG1ha2VfZWRnZSAoYnJlYWtfYmIsIGxvb3BfcHJlaGVhZGVyX2VkZ2UgKGxv b3AyKS0+c3JjLCAwKTsKLQotICB0b19sb29wMS0+ZmxhZ3MgJj0gfkVER0VfRkFMTFRIUlU7 Ci0gIHRvX2xvb3AxLT5mbGFncyB8PSB0cnVlX2ludmFyID8gRURHRV9GQUxTRV9WQUxVRSA6 IEVER0VfVFJVRV9WQUxVRTsKLSAgdG9fbG9vcDItPmZsYWdzIHw9IHRydWVfaW52YXIgPyBF REdFX1RSVUVfVkFMVUUgOiBFREdFX0ZBTFNFX1ZBTFVFOwotCi0gIHRvX2xvb3AxLT5wcm9i YWJpbGl0eSA9IGludmFyX2JyYW5jaC0+cHJvYmFiaWxpdHkuaW52ZXJ0ICgpOwotICB0b19s b29wMi0+cHJvYmFiaWxpdHkgPSBpbnZhcl9icmFuY2gtPnByb2JhYmlsaXR5OwotCi0gIC8q IER1ZSB0byBpbnRyb2R1Y3Rpb24gb2YgYSBjb250cm9sIGZsb3cgZWRnZSBmcm9tIGxvb3Ax IGxhdGNoIHRvIGxvb3AyCi0gICAgIHByZS1oZWFkZXIsIHdlIHNob3VsZCB1cGRhdGUgUEhJ cyBpbiBsb29wMiB0byByZWZsZWN0IHRoaXMgY29ubmVjdGlvbgotICAgICBiZXR3ZWVuIGxv b3AxIGFuZCBsb29wMi4gICovCi0gIGNvbm5lY3RfbG9vcF9waGlzIChsb29wMSwgbG9vcDIs IHRvX2xvb3AyKTsKLQogICBmcmVlX29yaWdpbmFsX2NvcHlfdGFibGVzICgpOwogCiAgIHJl dHVybiB0cnVlOwotLSAKMi4yNy4wLjkwLmdlZWJiNTFiYThjCgo= --------------zcF0SKeNig21D05GD0oxoQsU--