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 BCFA73858401 for ; Fri, 30 Jul 2021 05:20:17 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org BCFA73858401 Received: from pps.filterd (m0098399.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.16.0.43/8.16.0.43) with SMTP id 16U53Nx0061930; Fri, 30 Jul 2021 01:20:16 -0400 Received: from pps.reinject (localhost [127.0.0.1]) by mx0a-001b2d01.pphosted.com with ESMTP id 3a49vu1s8r-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 30 Jul 2021 01:20:16 -0400 Received: from m0098399.ppops.net (m0098399.ppops.net [127.0.0.1]) by pps.reinject (8.16.0.43/8.16.0.43) with SMTP id 16U54mhO068837; Fri, 30 Jul 2021 01:20:15 -0400 Received: from ppma01fra.de.ibm.com (46.49.7a9f.ip4.static.sl-reverse.com [159.122.73.70]) by mx0a-001b2d01.pphosted.com with ESMTP id 3a49vu1s7m-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 30 Jul 2021 01:20:15 -0400 Received: from pps.filterd (ppma01fra.de.ibm.com [127.0.0.1]) by ppma01fra.de.ibm.com (8.16.1.2/8.16.1.2) with SMTP id 16U5CiuS020773; Fri, 30 Jul 2021 05:20:13 GMT Received: from b06cxnps4075.portsmouth.uk.ibm.com (d06relay12.portsmouth.uk.ibm.com [9.149.109.197]) by ppma01fra.de.ibm.com with ESMTP id 3a417pgvy0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 30 Jul 2021 05:20:13 +0000 Received: from d06av22.portsmouth.uk.ibm.com (d06av22.portsmouth.uk.ibm.com [9.149.105.58]) by b06cxnps4075.portsmouth.uk.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 16U5KA7i14418400 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 30 Jul 2021 05:20:10 GMT Received: from d06av22.portsmouth.uk.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id C92E64C04E; Fri, 30 Jul 2021 05:20:10 +0000 (GMT) Received: from d06av22.portsmouth.uk.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id E78144C04A; Fri, 30 Jul 2021 05:20:08 +0000 (GMT) Received: from kewenlins-mbp.cn.ibm.com (unknown [9.200.147.34]) by d06av22.portsmouth.uk.ibm.com (Postfix) with ESMTP; Fri, 30 Jul 2021 05:20:08 +0000 (GMT) Subject: [PATCH v2] Make loops_list support an optional loop_p root To: Richard Biener Cc: GCC Patches , Segher Boessenkool , Martin Sebor , Bill Schmidt References: <0a8b77ba-1d54-1eff-b54d-d2cb1e769e09@linux.ibm.com> <61ac669c-7293-f53a-20c7-158b5a813cee@linux.ibm.com> From: "Kewen.Lin" Message-ID: <221d8a67-264a-b6a9-e705-bfb4a45f14bb@linux.ibm.com> Date: Fri, 30 Jul 2021 13:20:07 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.10.0 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------71561124EAAF428707AB1D3F" Content-Language: en-US X-TM-AS-GCONF: 00 X-Proofpoint-ORIG-GUID: eD0mvz5JR1N_ZTQuVysSfVuCwZ8bCUvA X-Proofpoint-GUID: QeqkNk-uPbG4xvOMIHGmIVDMB8G4vpum X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.391, 18.0.790 definitions=2021-07-30_03:2021-07-29, 2021-07-30 signatures=0 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 mlxscore=0 clxscore=1015 impostorscore=0 mlxlogscore=999 bulkscore=0 suspectscore=0 malwarescore=0 phishscore=0 spamscore=0 adultscore=0 lowpriorityscore=0 priorityscore=1501 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2107140000 definitions=main-2107300030 X-Spam-Status: No, score=-11.1 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, 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, 30 Jul 2021 05:20:19 -0000 This is a multi-part message in MIME format. --------------71561124EAAF428707AB1D3F Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit on 2021/7/29 下午4:01, Richard Biener wrote: > On Fri, Jul 23, 2021 at 10:41 AM Kewen.Lin wrote: >> >> on 2021/7/22 下午8:56, Richard Biener wrote: >>> On Tue, Jul 20, 2021 at 4:37 >>> PM Kewen.Lin wrote: >>>> >>>> Hi, >>>> >>>> This v2 has addressed some review comments/suggestions: >>>> >>>> - Use "!=" instead of "<" in function operator!= (const Iter &rhs) >>>> - Add new CTOR loops_list (struct loops *loops, unsigned flags) >>>> to support loop hierarchy tree rather than just a function, >>>> and adjust to use loops* accordingly. >>> >>> I actually meant struct loop *, not struct loops * ;) At the point >>> we pondered to make loop invariant motion work on single >>> loop nests we gave up not only but also because it iterates >>> over the loop nest but all the iterators only ever can process >>> all loops, not say, all loops inside a specific 'loop' (and >>> including that 'loop' if LI_INCLUDE_ROOT). So the >>> CTOR would take the 'root' of the loop tree as argument. >>> >>> I see that doesn't trivially fit how loops_list works, at least >>> not for LI_ONLY_INNERMOST. But I guess FROM_INNERMOST >>> could be adjusted to do ONLY_INNERMOST as well? >>> >> >> >> Thanks for the clarification! I just realized that the previous >> version with struct loops* is problematic, all traversal is >> still bounded with outer_loop == NULL. I think what you expect >> is to respect the given loop_p root boundary. Since we just >> record the loops' nums, I think we still need the function* fn? > > Would it simplify things if we recorded the actual loop *? > I'm afraid it's unsafe to record the loop*. I had the same question why the loop iterator uses index rather than loop* when I read this at the first time. I guess the design of processing loops allows its user to update or even delete the folllowing loops to be visited. For example, when the user does some tricks on one loop, then it duplicates the loop and its children to somewhere and then removes the loop and its children, when iterating onto its children later, the "index" way will check its validity by get_loop at that point, but the "loop *" way will have some recorded pointers to become dangling, can't do the validity check on itself, seems to need a side linear search to ensure the validity. > There's still the to_visit reserve which needs a bound on > the number of loops for efficiency reasons. > Yes, I still keep the fn in the updated version. >> So I add one optional argument loop_p root and update the >> visiting codes accordingly. Before this change, the previous >> visiting uses the outer_loop == NULL as the termination condition, >> it perfectly includes the root itself, but with this given root, >> we have to use it as the termination condition to avoid to iterate >> onto its possible existing next. >> >> For LI_ONLY_INNERMOST, I was thinking whether we can use the >> code like: >> >> struct loops *fn_loops = loops_for_fn (fn)->larray; >> for (i = 0; vec_safe_iterate (fn_loops, i, &aloop); i++) >> if (aloop != NULL >> && aloop->inner == NULL >> && flow_loop_nested_p (tree_root, aloop)) >> this->to_visit.quick_push (aloop->num); >> >> it has the stable bound, but if the given root only has several >> child loops, it can be much worse if there are many loops in fn. >> It seems impossible to predict the given root loop hierarchy size, >> maybe we can still use the original linear searching for the case >> loops_for_fn (fn) == root? But since this visiting seems not so >> performance critical, I chose to share the code originally used >> for FROM_INNERMOST, hope it can have better readability and >> maintainability. > > I was indeed looking for something that has execution/storage > bound on the subtree we're interested in. If we pull the CTOR > out-of-line we can probably keep the linear search for > LI_ONLY_INNERMOST when looking at the whole loop tree. > OK, I've moved the suggested single loop tree walker out-of-line to cfgloop.c, and brought the linear search back for LI_ONLY_INNERMOST when looking at the whole loop tree. > It just seemed to me that we can eventually re-use a > single loop tree walker for all orders, just adjusting the > places we push. > Wow, good point! Indeed, I have further unified all orders handlings into a single function walk_loop_tree. >> >> Bootstrapped and regtested on powerpc64le-linux-gnu P9, >> x86_64-redhat-linux and aarch64-linux-gnu, also >> bootstrapped on ppc64le P9 with bootstrap-O3 config. >> >> Does the attached patch meet what you expect? > > So yeah, it's probably close to what is sensible. Not sure > whether optimizing the loops for the !only_push_innermost_p > case is important - if we manage to produce a single > walker with conditionals based on 'flags' then IPA-CP should > produce optimal clones as well I guess. > Thanks for the comments, the updated v2 is attached. Comparing with v1, it does: - Unify one single loop tree walker for all orders. - Move walk_loop_tree out-of-line to cfgloop.c. - Keep the linear search for LI_ONLY_INNERMOST with tree_root of fn loops. - Use class loop * instead of loop_p. Bootstrapped & regtested on powerpc64le-linux-gnu Power9 (with/without the hunk for LI_ONLY_INNERMOST linear search, it can have the coverage to exercise LI_ONLY_INNERMOST in walk_loop_tree when "without"). Is it ok for trunk? BR, Kewen ----- gcc/ChangeLog: * cfgloop.h (loops_list::loops_list): Add one optional argument root and adjust accordingly, update loop tree walking and factor out to ... * cfgloop.c (loops_list::walk_loop_tree): ...this. New function. --------------71561124EAAF428707AB1D3F Content-Type: text/plain; charset=UTF-8; x-mac-type="0"; x-mac-creator="0"; name="loop_root-v2.diff" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="loop_root-v2.diff" LS0tCiBnY2MvY2ZnbG9vcC5jIHwgNjQgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysKIGdjYy9jZmdsb29wLmggfCA5MiArKysrKysrKysrKysrKysrKystLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIDIgZmlsZXMgY2hhbmdlZCwgOTcgaW5zZXJ0aW9u cygrKSwgNTkgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZ2NjL2NmZ2xvb3AuYyBiL2dj Yy9jZmdsb29wLmMKaW5kZXggNjI4NGFlMjkyYjYuLmFjZGI0ZWQxNGM4IDEwMDY0NAotLS0g YS9nY2MvY2ZnbG9vcC5jCisrKyBiL2djYy9jZmdsb29wLmMKQEAgLTIxMDQsMyArMjEwNCw2 NyBAQCBtYXJrX2xvb3BfZm9yX3JlbW92YWwgKGxvb3BfcCBsb29wKQogICBsb29wLT5sYXRj aCA9IE5VTEw7CiAgIGxvb3BzX3N0YXRlX3NldCAoTE9PUFNfTkVFRF9GSVhVUCk7CiB9CisK Ky8qIFN0YXJ0aW5nIGZyb20gbG9vcCB0cmVlIFJPT1QsIHdhbGsgbG9vcCB0cmVlIGFzIHRo ZSB2aXNpdGluZworICAgb3JkZXIgc3BlY2lmaWVkIGJ5IEZMQUdTLCBza2lwcGluZyB0aGUg bG9vcCB3aXRoIG51bWJlciBNTi4KKyAgIFRoZSBzdXBwb3J0ZWQgdmlzaXRpbmcgb3JkZXJz IGFyZToKKyAgICAgLSBMSV9PTkxZX0lOTkVSTU9TVAorICAgICAtIExJX0ZST01fSU5ORVJN T1NUCisgICAgIC0gUHJlb3JkZXIgKGlmIG5laXRoZXIgb2YgYWJvdmUgaXMgc3BlY2lmaWVk KSAgKi8KKwordm9pZAorbG9vcHNfbGlzdDo6d2Fsa19sb29wX3RyZWUgKGNsYXNzIGxvb3Ag KnJvb3QsIHVuc2lnbmVkIGZsYWdzLCBpbnQgbW4pCit7CisgIGJvb2wgb25seV9pbm5lcm1v c3RfcCA9IGZsYWdzICYgTElfT05MWV9JTk5FUk1PU1Q7CisgIGJvb2wgZnJvbV9pbm5lcm1v c3RfcCA9IGZsYWdzICYgTElfRlJPTV9JTk5FUk1PU1Q7CisgIGJvb2wgcHJlb3JkZXJfcCA9 ICEob25seV9pbm5lcm1vc3RfcCB8fCBmcm9tX2lubmVybW9zdF9wKTsKKworICAvKiBFYXJs eSBoYW5kbGUgcm9vdCB3aXRob3V0IGFueSBpbm5lciBsb29wcywgbWFrZSBsYXRlcgorICAg ICBwcm9jZXNzaW5nIHNpbXBsZXIsIHRoYXQgaXMgYWxsIGxvb3BzIHByb2Nlc3NlZCBpbiB0 aGUKKyAgICAgZm9sbG93aW5nIHdoaWxlIGxvb3AgYXJlIGltcG9zc2libGUgdG8gYmUgcm9v dC4gICovCisgIGlmICghcm9vdC0+aW5uZXIpCisgICAgeworICAgICAgaWYgKHJvb3QtPm51 bSAhPSBtbikKKwl0aGlzLT50b192aXNpdC5xdWlja19wdXNoIChyb290LT5udW0pOworICAg ICAgcmV0dXJuOworICAgIH0KKworICBjbGFzcyBsb29wICphbG9vcDsKKyAgZm9yIChhbG9v cCA9IHJvb3Q7CisgICAgICAgYWxvb3AtPmlubmVyICE9IE5VTEw7CisgICAgICAgYWxvb3Ag PSBhbG9vcC0+aW5uZXIpCisgICAgeworICAgICAgaWYgKHByZW9yZGVyX3AgJiYgYWxvb3At Pm51bSAhPSBtbikKKwl0aGlzLT50b192aXNpdC5xdWlja19wdXNoIChhbG9vcC0+bnVtKTsK KyAgICAgIGNvbnRpbnVlOworICAgIH0KKworICB3aGlsZSAoMSkKKyAgICB7CisgICAgICBn Y2NfYXNzZXJ0IChhbG9vcCAhPSByb290KTsKKyAgICAgIGlmIChmcm9tX2lubmVybW9zdF9w IHx8IGFsb29wLT5pbm5lciA9PSBOVUxMKQorCXRoaXMtPnRvX3Zpc2l0LnF1aWNrX3B1c2gg KGFsb29wLT5udW0pOworCisgICAgICBpZiAoYWxvb3AtPm5leHQpCisJeworCSAgZm9yIChh bG9vcCA9IGFsb29wLT5uZXh0OworCSAgICAgICBhbG9vcC0+aW5uZXIgIT0gTlVMTDsKKwkg ICAgICAgYWxvb3AgPSBhbG9vcC0+aW5uZXIpCisJICAgIHsKKwkgICAgICBpZiAocHJlb3Jk ZXJfcCkKKwkJdGhpcy0+dG9fdmlzaXQucXVpY2tfcHVzaCAoYWxvb3AtPm51bSk7CisJICAg ICAgY29udGludWU7CisJICAgIH0KKwl9CisgICAgICBlbHNlIGlmIChsb29wX291dGVyIChh bG9vcCkgPT0gcm9vdCkKKwlicmVhazsKKyAgICAgIGVsc2UKKwlhbG9vcCA9IGxvb3Bfb3V0 ZXIgKGFsb29wKTsKKyAgICB9CisKKyAgLyogV2hlbiB2aXNpdGluZyBmcm9tIGlubmVybW9z dCwgd2UgbmVlZCB0byBjb25zaWRlciByb290IGhlcmUKKyAgICAgc2luY2UgdGhlIHByZXZp b3VzIGxvb3AgZG9lc24ndCBoYW5kbGUgaXQuICAqLworICBpZiAoZnJvbV9pbm5lcm1vc3Rf cCAmJiByb290LT5udW0gIT0gbW4pCisgICAgdGhpcy0+dG9fdmlzaXQucXVpY2tfcHVzaCAo cm9vdC0+bnVtKTsKK30KKwpkaWZmIC0tZ2l0IGEvZ2NjL2NmZ2xvb3AuaCBiL2djYy9jZmds b29wLmgKaW5kZXggZDVlZWU2YjQ4NDAuLjMwNDZiZjcxM2JiIDEwMDY0NAotLS0gYS9nY2Mv Y2ZnbG9vcC5oCisrKyBiL2djYy9jZmdsb29wLmgKQEAgLTY2OSwxMyArNjY5LDE1IEBAIGFz X2NvbnN0IChUICZ0KQogfQogCiAvKiBBIGxpc3QgZm9yIHZpc2l0aW5nIGxvb3BzLCB3aGlj aCBjb250YWlucyB0aGUgbG9vcCBudW1iZXJzIGluc3RlYWQgb2YKLSAgIHRoZSBsb29wIHBv aW50ZXJzLiAgVGhlIHNjb3BlIGlzIHJlc3RyaWN0ZWQgaW4gZnVuY3Rpb24gRk4gYW5kIHRo ZQotICAgdmlzaXRpbmcgb3JkZXIgaXMgc3BlY2lmaWVkIGJ5IEZMQUdTLiAgKi8KKyAgIHRo ZSBsb29wIHBvaW50ZXJzLiAgSWYgdGhlIGxvb3AgUk9PVCBpcyBvZmZlcmVkIChub24tbnVs bCksIHRoZSB2aXNpdGluZworICAgd2lsbCBzdGFydCBmcm9tIGl0LCBvdGhlcndpc2UgaXQg d291bGQgc3RhcnQgZnJvbSB0aGUgdHJlZV9yb290IG9mCisgICBsb29wc19mb3JfZm4gKEZO KSBpbnN0ZWFkLiAgVGhlIHNjb3BlIGlzIHJlc3RyaWN0ZWQgaW4gZnVuY3Rpb24gRk4gYW5k CisgICB0aGUgdmlzaXRpbmcgb3JkZXIgaXMgc3BlY2lmaWVkIGJ5IEZMQUdTLiAgKi8KIAog Y2xhc3MgbG9vcHNfbGlzdAogewogcHVibGljOgotICBsb29wc19saXN0IChmdW5jdGlvbiAq Zm4sIHVuc2lnbmVkIGZsYWdzKTsKKyAgbG9vcHNfbGlzdCAoZnVuY3Rpb24gKmZuLCB1bnNp Z25lZCBmbGFncywgY2xhc3MgbG9vcCAqcm9vdCA9IG51bGxwdHIpOwogCiAgIHRlbXBsYXRl IDx0eXBlbmFtZSBUPiBjbGFzcyBJdGVyCiAgIHsKQEAgLTc1MCw2ICs3NTIsMTAgQEAgcHVi bGljOgogICB9CiAKIHByaXZhdGU6CisgIC8qIFdhbGsgbG9vcCB0cmVlIHN0YXJ0aW5nIGZy b20gUk9PVCBhcyB0aGUgdmlzaXRpbmcgb3JkZXIgc3BlY2lmaWVkCisgICAgIGJ5IEZMQUdT LCBza2lwcGluZyB0aGUgbG9vcCB3aXRoIG51bWJlciBNTi4gICovCisgIHZvaWQgd2Fsa19s b29wX3RyZWUgKGNsYXNzIGxvb3AgKnJvb3QsIHVuc2lnbmVkIGZsYWdzLCBpbnQgbW4pOwor CiAgIC8qIFRoZSBmdW5jdGlvbiB3ZSBhcmUgdmlzaXRpbmcuICAqLwogICBmdW5jdGlvbiAq Zm47CiAKQEAgLTc4Miw3NiArNzg4LDQ0IEBAIGxvb3BzX2xpc3Q6Okl0ZXI8VD46OmZpbGxf Y3Vycl9sb29wICgpCiB9CiAKIC8qIFNldCB1cCB0aGUgbG9vcHMgbGlzdCB0byB2aXNpdCBh Y2NvcmRpbmcgdG8gdGhlIHNwZWNpZmllZAotICAgZnVuY3Rpb24gc2NvcGUgRk4gYW5kIGl0 ZXJhdGluZyBvcmRlciBGTEFHUy4gICovCisgICBmdW5jdGlvbiBzY29wZSBGTiBhbmQgaXRl cmF0aW5nIG9yZGVyIEZMQUdTLiAgSWYgUk9PVCBpcworICAgbm90IG51bGwsIHRoZSB2aXNp dGluZyB3b3VsZCBzdGFydCBmcm9tIGl0LCBvdGhlcndpc2UgaXQKKyAgIHdpbGwgc3RhcnQg ZnJvbSB0cmVlX3Jvb3Qgb2YgbG9vcHNfZm9yX2ZuIChGTikuICAqLwogCi1pbmxpbmUgbG9v cHNfbGlzdDo6bG9vcHNfbGlzdCAoZnVuY3Rpb24gKmZuLCB1bnNpZ25lZCBmbGFncykKK2lu bGluZSBsb29wc19saXN0Ojpsb29wc19saXN0IChmdW5jdGlvbiAqZm4sIHVuc2lnbmVkIGZs YWdzLCBjbGFzcyBsb29wICpyb290KQogewotICBjbGFzcyBsb29wICphbG9vcDsKLSAgdW5z aWduZWQgaTsKLSAgaW50IG1uOworICBzdHJ1Y3QgbG9vcHMgKmxvb3BzID0gbG9vcHNfZm9y X2ZuIChmbik7CisgIGdjY19hc3NlcnQgKCFyb290IHx8IGxvb3BzKTsKKworICAvKiBDaGVj ayBtdXR1YWxseSBleGNsdXNpdmUgZmxhZ3Mgc2hvdWxkIG5vdCBjby1leGlzdC4gICovCisg IHVuc2lnbmVkIGNoZWNrZWRfZmxhZ3MgPSBMSV9PTkxZX0lOTkVSTU9TVCB8IExJX0ZST01f SU5ORVJNT1NUOworICBnY2NfYXNzZXJ0ICgoZmxhZ3MgJiBjaGVja2VkX2ZsYWdzKSAhPSBj aGVja2VkX2ZsYWdzKTsKIAogICB0aGlzLT5mbiA9IGZuOwotICBpZiAoIWxvb3BzX2Zvcl9m biAoZm4pKQorICBpZiAoIWxvb3BzKQogICAgIHJldHVybjsKIAorICBjbGFzcyBsb29wICp0 cmVlX3Jvb3QgPSByb290ID8gcm9vdCA6IGxvb3BzLT50cmVlX3Jvb3Q7CisKICAgdGhpcy0+ dG9fdmlzaXQucmVzZXJ2ZV9leGFjdCAobnVtYmVyX29mX2xvb3BzIChmbikpOwotICBtbiA9 IChmbGFncyAmIExJX0lOQ0xVREVfUk9PVCkgPyAwIDogMTsKKyAgaW50IG1uID0gKGZsYWdz ICYgTElfSU5DTFVERV9ST09UKSA/IC0xIDogdHJlZV9yb290LT5udW07CiAKLSAgaWYgKGZs YWdzICYgTElfT05MWV9JTk5FUk1PU1QpCisgIC8qIFdoZW4gcm9vdCBpcyB0cmVlX3Jvb3Qg b2YgbG9vcHNfZm9yX2ZuIChmbikgYW5kIHRoZSB2aXNpdGluZworICAgICBvcmRlciBpcyBM SV9PTkxZX0lOTkVSTU9TVCwgd2Ugd291bGQgbGlrZSB0byB1c2UgbGluZWFyCisgICAgIHNl YXJjaCBoZXJlIHNpbmNlIGl0IGhhcyBhIG1vcmUgc3RhYmxlIGJvdW5kIHRoYW4gdGhlCisg ICAgIHdhbGtfbG9vcF90cmVlLiAgKi8KKyAgaWYgKGZsYWdzICYgTElfT05MWV9JTk5FUk1P U1QgJiYgdHJlZV9yb290ID09IGxvb3BzLT50cmVlX3Jvb3QpCiAgICAgewotICAgICAgZm9y IChpID0gMDsgdmVjX3NhZmVfaXRlcmF0ZSAobG9vcHNfZm9yX2ZuIChmbiktPmxhcnJheSwg aSwgJmFsb29wKTsgaSsrKQorICAgICAgY2xhc3MgbG9vcCAqYWxvb3A7CisgICAgICB1bnNp Z25lZCBpbnQgaTsKKyAgICAgIGZvciAoaSA9IDA7IHZlY19zYWZlX2l0ZXJhdGUgKGxvb3Bz LT5sYXJyYXksIGksICZhbG9vcCk7IGkrKykKIAlpZiAoYWxvb3AgIT0gTlVMTAogCSAgICAm JiBhbG9vcC0+aW5uZXIgPT0gTlVMTAotCSAgICAmJiBhbG9vcC0+bnVtID49IG1uKQorCSAg ICAmJiBhbG9vcC0+bnVtICE9IG1uKQogCSAgdGhpcy0+dG9fdmlzaXQucXVpY2tfcHVzaCAo YWxvb3AtPm51bSk7CiAgICAgfQotICBlbHNlIGlmIChmbGFncyAmIExJX0ZST01fSU5ORVJN T1NUKQotICAgIHsKLSAgICAgIC8qIFB1c2ggdGhlIGxvb3BzIHRvIExJLT5UT19WSVNJVCBp biBwb3N0b3JkZXIuICAqLwotICAgICAgZm9yIChhbG9vcCA9IGxvb3BzX2Zvcl9mbiAoZm4p LT50cmVlX3Jvb3Q7Ci0JICAgYWxvb3AtPmlubmVyICE9IE5VTEw7Ci0JICAgYWxvb3AgPSBh bG9vcC0+aW5uZXIpCi0JY29udGludWU7Ci0KLSAgICAgIHdoaWxlICgxKQotCXsKLQkgIGlm IChhbG9vcC0+bnVtID49IG1uKQotCSAgICB0aGlzLT50b192aXNpdC5xdWlja19wdXNoIChh bG9vcC0+bnVtKTsKLQotCSAgaWYgKGFsb29wLT5uZXh0KQotCSAgICB7Ci0JICAgICAgZm9y IChhbG9vcCA9IGFsb29wLT5uZXh0OwotCQkgICBhbG9vcC0+aW5uZXIgIT0gTlVMTDsKLQkJ ICAgYWxvb3AgPSBhbG9vcC0+aW5uZXIpCi0JCWNvbnRpbnVlOwotCSAgICB9Ci0JICBlbHNl IGlmICghbG9vcF9vdXRlciAoYWxvb3ApKQotCSAgICBicmVhazsKLQkgIGVsc2UKLQkgICAg YWxvb3AgPSBsb29wX291dGVyIChhbG9vcCk7Ci0JfQotICAgIH0KICAgZWxzZQotICAgIHsK LSAgICAgIC8qIFB1c2ggdGhlIGxvb3BzIHRvIExJLT5UT19WSVNJVCBpbiBwcmVvcmRlci4g ICovCi0gICAgICBhbG9vcCA9IGxvb3BzX2Zvcl9mbiAoZm4pLT50cmVlX3Jvb3Q7Ci0gICAg ICB3aGlsZSAoMSkKLQl7Ci0JICBpZiAoYWxvb3AtPm51bSA+PSBtbikKLQkgICAgdGhpcy0+ dG9fdmlzaXQucXVpY2tfcHVzaCAoYWxvb3AtPm51bSk7Ci0KLQkgIGlmIChhbG9vcC0+aW5u ZXIgIT0gTlVMTCkKLQkgICAgYWxvb3AgPSBhbG9vcC0+aW5uZXI7Ci0JICBlbHNlCi0JICAg IHsKLQkgICAgICB3aGlsZSAoYWxvb3AgIT0gTlVMTCAmJiBhbG9vcC0+bmV4dCA9PSBOVUxM KQotCQlhbG9vcCA9IGxvb3Bfb3V0ZXIgKGFsb29wKTsKLQkgICAgICBpZiAoYWxvb3AgPT0g TlVMTCkKLQkJYnJlYWs7Ci0JICAgICAgYWxvb3AgPSBhbG9vcC0+bmV4dDsKLQkgICAgfQot CX0KLSAgICB9CisgICAgd2Fsa19sb29wX3RyZWUgKHRyZWVfcm9vdCwgZmxhZ3MsIG1uKTsK IH0KIAogLyogVGhlIHByb3BlcnRpZXMgb2YgdGhlIHRhcmdldC4gICovCg== --------------71561124EAAF428707AB1D3F--