From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by sourceware.org (Postfix) with ESMTP id 706CD3851C22 for ; Mon, 14 Jun 2021 08:10:32 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 706CD3851C22 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 09B111FB; Mon, 14 Jun 2021 01:10:32 -0700 (PDT) Received: from [10.57.75.172] (unknown [10.57.75.172]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 570C03F694; Mon, 14 Jun 2021 01:10:31 -0700 (PDT) Subject: Re: [RFC] Using main loop's updated IV as base_address for epilogue vectorization To: Richard Biener Cc: Richard Sandiford , "gcc-patches@gcc.gnu.org" References: <3a5de6dc-d5ec-7dda-8eb9-85ea6f77984f@arm.com> <6e4541ef-e0a1-1d2d-53f5-4bfed9a65598@arm.com> From: "Andre Vieira (lists)" Message-ID: <4925fee5-dcea-0c14-388c-85c881ffd918@arm.com> Date: Mon, 14 Jun 2021 09:10:29 +0100 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.10.1 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------E7B38F8A841FEA6FE7783B71" Content-Language: en-US X-Spam-Status: No, score=-12.8 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_ASCII_DIVIDERS, KAM_DMARC_STATUS, KAM_LOTSOFHASH, NICE_REPLY_A, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) 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: Mon, 14 Jun 2021 08:10:36 -0000 This is a multi-part message in MIME format. --------------E7B38F8A841FEA6FE7783B71 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Hi, On 20/05/2021 11:22, Richard Biener wrote: > On Mon, 17 May 2021, Andre Vieira (lists) wrote: > >> Hi, >> >> So this is my second attempt at finding a way to improve how we generate the >> vector IV's and teach the vectorizer to share them between main loop and >> epilogues. On IRC we discussed my idea to use the loop's control_iv, but that >> was a terrible idea and I quickly threw it in the bin. The main problem, that >> for some reason I failed to see, was that the control_iv increases by 's' and >> the datarefs by 's' * NELEMENTS where 's' is usually 1 and NELEMENTs the >> amount of elements we handle per iteration. That means the epilogue loops >> would have to start from the last loop's IV * the last loop's NELEMENT's and >> that would just cause a mess. >> >> Instead I started to think about creating IV's for the datarefs and what I >> thought worked best was to create these in scalar before peeling. That way the >> peeling mechanisms takes care of the duplication of these for the vector and >> scalar epilogues and it also takes care of adding phi-nodes for the >> skip_vector paths. > How does this work for if-converted loops where we use the > non-if-converted scalar loop for (scalar) peeling but the > if-converted scalar loop for vectorized epilogues? I suppose > you're only adjusting the if-converted copy. True hadn't thought about this :( > >> These new IV's have two functions: >> 1) 'vect_create_data_ref_ptr' can use them to: >>  a) if it's the main loop: replace the values of the 'initial' value of the >> main loop's IV and the initial values in the skip_vector phi-nodes >>  b) Update the the skip_vector phi-nodes argument for the non-skip path with >> the updated vector ptr. > b) means the prologue IV will not be dead there so we actually need > to compute it? I suppose IVOPTs could be teached to replace an > IV with its final value (based on some other IV) when it's unused? > Or does it already magically do good? It does not and ... > >> 2) They are used for the scalar epilogue ensuring they share the same >> datareference ptr. >> >> There are still a variety of 'hacky' elements here and a lot of testing to be >> done, but I hope to be able to clean them away. One of the main issues I had >> was that I had to skip a couple of checks and things for the added phi-nodes >> and update statements as these do not have stmt_vec_info representation. >> Though I'm not sure adding this representation at their creation was much >> cleaner... It is something I could play around with but I thought this was a >> good moment to ask you for input. For instance, maybe we could do this >> transformation before analysis? >> >> Also be aware that because I create a IV for each dataref this leads to >> regressions with SVE codegen for instance. NEON is able to use the post-index >> addressing mode to increase each dr IV at access time, but SVE can't do this. >> For this I don't know if maybe we could try to be smart and create shared >> IV's. So rather than make them based on the actual vector ptr, use a shared >> sizetype IV that can be shared among dr IV's with the same step. Or maybe this >> is something for IVOPTs? > Certainly IVOPTs could decide to use the newly created IVs in the > scalar loops for the DRs therein as well. But since IVOPTs only > considers a single loop at a time it will probably not pay too > much attention and is only influenced by the out-of-loop uses of > the final values of the IVs. > > My gut feeling tells me that whatever we do we'll have to look > into improving IVOPTs to consider multiple loops. So I redid the IV-sharing and it's looking a lot simpler and neater, however it only shares IVs between vectorized loops and not scalar pro- or epilogues. I am not certain IVOPTs will be able to deal with these, as it has no knowledge of the number of iterations of each different loop. So take for instance a prologue peeling for alignment loop and a first main vectorization loop. To be able to reuse the IV's from the prologue in the main vectorization loop it would need to know that the initial start adress + PEELING_NITERS == base address for main vectorization loop. I'll starting testing this approach for correctness if there are no major concerns. Though I suspect we will only want to turn this into a patch once we have the IVOPTs work done to a point where it at least doesn't regress codegen because of shared IVs and eventually we can look at how to solve the sharing between vectorized and scalar loops. A small nitpick on my own RFC. I will probably move the 'skip_e' to outside of the map, as we only need one per loop_vinfo and not one per DR. Initially I didnt even have this skip_e in, but was using the creation of a dummy PHI node and then replacing it with the real thing later. Though this made the code simpler, especially when inserting the 'init's stmt_list. Kind regards, Andre --------------E7B38F8A841FEA6FE7783B71 Content-Type: text/plain; charset=UTF-8; name="iv_rfc_3.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="iv_rfc_3.patch" ZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtZGF0YS1yZWZzLmMgYi9nY2MvdHJlZS12ZWN0 LWRhdGEtcmVmcy5jCmluZGV4IGIzMTdkZjUzMmE5YTkyYTYxOWRlOTU3MjM3ODQzN2QwOWM2 MzJhYjAuLmU3ZDBmMWU2NTdiMWEwYzliZWM3NTc5OTgxNzI0MmUwYmMxZDgyODIgMTAwNjQ0 Ci0tLSBhL2djYy90cmVlLXZlY3QtZGF0YS1yZWZzLmMKKysrIGIvZ2NjL3RyZWUtdmVjdC1k YXRhLXJlZnMuYwpAQCAtNDkwOSwxMSArNDkwOSwyNyBAQCB2ZWN0X2NyZWF0ZV9kYXRhX3Jl Zl9wdHIgKHZlY19pbmZvICp2aW5mbywgc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sCiAJCQkJ CQkgICBvZmZzZXQsIGJ5dGVfb2Zmc2V0KTsKICAgaWYgKG5ld19zdG10X2xpc3QpCiAgICAg ewotICAgICAgaWYgKHBlKQotICAgICAgICB7Ci0gICAgICAgICAgbmV3X2JiID0gZ3NpX2lu c2VydF9zZXFfb25fZWRnZV9pbW1lZGlhdGUgKHBlLCBuZXdfc3RtdF9saXN0KTsKLSAgICAg ICAgICBnY2NfYXNzZXJ0ICghbmV3X2JiKTsKLSAgICAgICAgfQorICAgICAgaWYgKGxvb3Bf dmluZm8pCisJeworCSAgaXZfc3RydWN0ICppdiA9IGxvb3BfdmluZm8tPmRyX2l2cy0+Z2V0 IChkcik7CisJICBpZiAoaXYgJiYgaXYtPnNraXBfZSkKKwkgICAgeworCSAgICAgIC8qIFRo ZSBpbml0aWFsIHZhbHVlIG9mIHRoZSBJViB3ZSBhcmUgaW5zZXJ0aW5nIGhlcmUgd2lsbCBi ZSB1c2VkCisJCSBpbiBhIFBISS1ub2RlIHRoYXQgd2lsbCBiZSB1c2VkIGFzIHRoZSBpbml0 aWFsIElWIGZvciB0aGUgbmV4dAorCQkgdmVjdG9yaXplZCBlcGlsb2d1ZSwgc28gd2UgaGF2 ZSB0byBtYWtlIHN1cmUgd2UgaW5zZXJ0IHRoaXMKKwkJIE5FV19TVE1UX0xJU1QgYmVmb3Jl IHRoZSBTS0lQX0UuICAqLworCSAgICAgIGdpbXBsZV9zdG10X2l0ZXJhdG9yIGcgPSBnc2lf bGFzdF9iYiAoaXYtPnNraXBfZS0+c3JjKTsKKwkgICAgICBpZiAoZ2ltcGxlX2NvZGUgKGdz aV9zdG10IChnKSkgPT0gR0lNUExFX0NPTkQpCisJCWdzaV9pbnNlcnRfc2VxX2JlZm9yZSAo JmcsIG5ld19zdG10X2xpc3QsIEdTSV9ORVdfU1RNVCk7CisJICAgICAgZWxzZQorCQlnc2lf aW5zZXJ0X3NlcV9hZnRlciAoJmcsIG5ld19zdG10X2xpc3QsIEdTSV9ORVdfU1RNVCk7CisJ ICAgIH0KKwkgIGVsc2UKKwkgICAgeworCSAgICAgIG5ld19iYiA9IGdzaV9pbnNlcnRfc2Vx X29uX2VkZ2VfaW1tZWRpYXRlIChwZSwgbmV3X3N0bXRfbGlzdCk7CisJICAgICAgZ2NjX2Fz c2VydCAoIW5ld19iYik7CisJICAgIH0KKwl9CiAgICAgICBlbHNlCiAgICAgICAgIGdzaV9p bnNlcnRfc2VxX2JlZm9yZSAoZ3NpLCBuZXdfc3RtdF9saXN0LCBHU0lfU0FNRV9TVE1UKTsK ICAgICB9CkBAIC00OTQ2LDEyICs0OTYyLDU1IEBAIHZlY3RfY3JlYXRlX2RhdGFfcmVmX3B0 ciAodmVjX2luZm8gKnZpbmZvLCBzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywKIAogICAgICAg c3RhbmRhcmRfaXZfaW5jcmVtZW50X3Bvc2l0aW9uIChsb29wLCAmaW5jcl9nc2ksICZpbnNl cnRfYWZ0ZXIpOwogCisgICAgICAvKiBJZiB0aGlzIGlzIGFuIGVwaWxvZ3VlLCBtYWtlIHN1 cmUgdG8gdXNlIHRoZSBwcmV2aW91cyBsb29wJ3MgSVYgZm9yCisJICB0aGUgc2FtZSBEUiBh cyB0aGUgaW5pdCBvZiB0aGlzIERSJ3MgSVYuICAqLworICAgICAgaWYgKGxvb3BfdmluZm8K KwkgICYmIExPT1BfVklORk9fT1JJR19MT09QX0lORk8gKGxvb3BfdmluZm8pKQorCXsKKwkg IGl2X3N0cnVjdCAqaXYKKwkgICAgPSBMT09QX1ZJTkZPX09SSUdfTE9PUF9JTkZPIChsb29w X3ZpbmZvKS0+ZHJfaXZzLT5nZXQgKGRyKTsKKwkgIGdjY19hc3NlcnQgKGl2KTsKKwkgIGFn Z3JfcHRyX2luaXQgPSBpdi0+ZGVmOworCX0KKwogICAgICAgY3JlYXRlX2l2IChhZ2dyX3B0 cl9pbml0LAogCQkgZm9sZF9jb252ZXJ0IChhZ2dyX3B0cl90eXBlLCBpdl9zdGVwKSwKIAkJ IGFnZ3JfcHRyLCBsb29wLCAmaW5jcl9nc2ksIGluc2VydF9hZnRlciwKIAkJICZpbmR4X2Jl Zm9yZV9pbmNyLCAmaW5keF9hZnRlcl9pbmNyKTsKICAgICAgIGluY3IgPSBnc2lfc3RtdCAo aW5jcl9nc2kpOwogCisgICAgICBpZiAobG9vcF92aW5mbykKKwl7CisJICBpdl9zdHJ1Y3Qg Jml2ID0gbG9vcF92aW5mby0+ZHJfaXZzLT5nZXRfb3JfaW5zZXJ0IChkcik7CisJICB0cmVl IGluY3JfbGhzID0gZ2ltcGxlX2dldF9saHMgKGluY3IpOworCSAgaWYgKGl2LnNraXBfZSkK KwkgICAgeworCSAgICAgIGVkZ2UgZTsKKwkgICAgICBlZGdlX2l0ZXJhdG9yIGVpOworCSAg ICAgIHRyZWUgdmFsOworCSAgICAgIC8qIENyZWF0ZSBhIHNraXAgUEhJLCB1c2UgSU5DUl9M SFMgYXMgdGhlIHZhbHVlIGZvciB0aGUgbm90LXNraXAKKwkJIHBhdGgocykgYW5kIEFHR1Jf UFRSX0lOSVQgYXMgdGhlIHZhbHVlIGZvciB0aGUgc2tpcCBwYXRoLiAgKi8KKwkgICAgICBp di5kZWYgPSBjb3B5X3NzYV9uYW1lIChpbmNyX2xocyk7CisJICAgICAgZ3BoaSAqc2tpcF9w aGkgPSBjcmVhdGVfcGhpX25vZGUgKGl2LmRlZiwKKwkJCQkJCWl2LnNraXBfZS0+ZGVzdCk7 CisKKwkgICAgICBGT1JfRUFDSF9FREdFIChlLCBlaSwgc2tpcF9waGktPmJiLT5wcmVkcykK KwkJeworCQkgIGlmIChlID09IGl2LnNraXBfZSkKKwkJICAgIHZhbCA9IGFnZ3JfcHRyX2lu aXQ7CisJCSAgZWxzZQorCQkgICAgdmFsID0gaW5jcl9saHM7CisJCSAgYWRkX3BoaV9hcmcg KHNraXBfcGhpLCB2YWwsIGUsIFVOS05PV05fTE9DQVRJT04pOworCQl9CisJICAgIH0KKwkg IGVsc2UKKwkgICAgeworCSAgICAgIC8qIE5vIHNraXAgUEhJIGhhcyBiZWVuIGNyZWF0ZWQs IHNvIHdlIGNhbiB1c2UgSU5DUl9MSFMgYXMgdGhlCisJCSBJVi5ERUYuICAqLworCSAgICAg IGl2LmRlZiA9IGluY3JfbGhzOworCSAgICB9CisJfQorCiAgICAgICAvKiBDb3B5IHRoZSBw b2ludHMtdG8gaW5mb3JtYXRpb24gaWYgaXQgZXhpc3RzLiAqLwogICAgICAgaWYgKERSX1BU Ul9JTkZPIChkcikpCiAJewpkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUtdmVjdC1sb29wLW1hbmlw LmMgYi9nY2MvdHJlZS12ZWN0LWxvb3AtbWFuaXAuYwppbmRleCAwMTJmNDhiZDQ4NzAxMjVj ODIwMDQ5YjRmYzcwZGIwZWYwNzU5YmRmLi4yNDc1YWI4YjgyNjM0OTlmMzQ3MWI2NGFhMTBi OTU2NTIzZmU1NmRmIDEwMDY0NAotLS0gYS9nY2MvdHJlZS12ZWN0LWxvb3AtbWFuaXAuYwor KysgYi9nY2MvdHJlZS12ZWN0LWxvb3AtbWFuaXAuYwpAQCAtMjU1NCw4ICsyNTU0LDcgQEAg Y2xhc3MgbG9vcCAqCiB2ZWN0X2RvX3BlZWxpbmcgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5m bywgdHJlZSBuaXRlcnMsIHRyZWUgbml0ZXJzbTEsCiAJCSB0cmVlICpuaXRlcnNfdmVjdG9y LCB0cmVlICpzdGVwX3ZlY3RvciwKIAkJIHRyZWUgKm5pdGVyc192ZWN0b3JfbXVsdF92Zl92 YXIsIGludCB0aCwKLQkJIGJvb2wgY2hlY2tfcHJvZml0YWJpbGl0eSwgYm9vbCBuaXRlcnNf bm9fb3ZlcmZsb3csCi0JCSB0cmVlICphZHZhbmNlKQorCQkgYm9vbCBjaGVja19wcm9maXRh YmlsaXR5LCBib29sIG5pdGVyc19ub19vdmVyZmxvdykKIHsKICAgZWRnZSBlLCBndWFyZF9l OwogICB0cmVlIHR5cGUgPSBUUkVFX1RZUEUgKG5pdGVycyksIGd1YXJkX2NvbmQ7CkBAIC0z MDU5LDEwICszMDU4LDYgQEAgdmVjdF9kb19wZWVsaW5nIChsb29wX3ZlY19pbmZvIGxvb3Bf dmluZm8sIHRyZWUgbml0ZXJzLCB0cmVlIG5pdGVyc20xLAogCSAgbml0ZXJzID0gUEhJX1JF U1VMVCAobmV3X3BoaSk7CiAJfQogCi0gICAgICAvKiBTZXQgQURWQU5DRSB0byB0aGUgbnVt YmVyIG9mIGl0ZXJhdGlvbnMgcGVyZm9ybWVkIGJ5IHRoZSBwcmV2aW91cwotCSBsb29wIGFu ZCBpdHMgcHJvbG9ndWUuICAqLwotICAgICAgKmFkdmFuY2UgPSBuaXRlcnM7Ci0KICAgICAg IGlmICghdmVjdF9lcGlsb2d1ZXNfdXBkYXRlZF9uaXRlcnMpCiAJewogCSAgLyogU3VidHJh Y3QgdGhlIG51bWJlciBvZiBpdGVyYXRpb25zIHBlcmZvcm1lZCBieSB0aGUgdmVjdG9yaXpl ZCBsb29wCkBAIC0zMDkwLDYgKzMwODUsMjEgQEAgdmVjdF9kb19wZWVsaW5nIChsb29wX3Zl Y19pbmZvIGxvb3BfdmluZm8sIHRyZWUgbml0ZXJzLCB0cmVlIG5pdGVyc20xLAogICBhZGp1 c3RfdmVjLnJlbGVhc2UgKCk7CiAgIGZyZWVfb3JpZ2luYWxfY29weV90YWJsZXMgKCk7CiAK KyAgaWYgKHZlY3RfZXBpbG9ndWVzICYmIHNraXBfZSkKKyAgICB7CisJLyogS2VlcCB0cmFj ayBvZiB0aGUgU0tJUF9FIHRvIGxhdGVyIGNvbnN0cnVjdCBhIHBoaS1ub2RlIHBlcgorCSAq IGRhdGFyZWZlcmVuY2UuICAqLworCXVuc2lnbmVkIGludCBpOworCXZlYzxkYXRhX3JlZmVy ZW5jZV9wPiBkYXRhcmVmcyA9IExPT1BfVklORk9fREFUQVJFRlMgKGxvb3BfdmluZm8pOwor CXN0cnVjdCBkYXRhX3JlZmVyZW5jZSAqZHI7CisKKwlGT1JfRUFDSF9WRUNfRUxUIChkYXRh cmVmcywgaSwgZHIpCisJICB7CisJICAgIGl2X3N0cnVjdCAmaXYgPSBsb29wX3ZpbmZvLT5k cl9pdnMtPmdldF9vcl9pbnNlcnQgKGRyKTsKKwkgICAgaXYuc2tpcF9lID0gc2tpcF9lOwor CSAgfQorICAgIH0KKwogICByZXR1cm4gdmVjdF9lcGlsb2d1ZXMgPyBlcGlsb2cgOiBOVUxM OwogfQogCmRpZmYgLS1naXQgYS9nY2MvdHJlZS12ZWN0LWxvb3AuYyBiL2djYy90cmVlLXZl Y3QtbG9vcC5jCmluZGV4IGJhMzYzNDhiODM1YzI1YmM1NTZkYTcxYTEzM2Y4MWY4YTZmYzM3 NDUuLmZjMjQ2OGViYzAwMTkzNWQ4NmZlZTliMDY4NTVhMDI4MzJiNDQ0YWQgMTAwNjQ0Ci0t LSBhL2djYy90cmVlLXZlY3QtbG9vcC5jCisrKyBiL2djYy90cmVlLXZlY3QtbG9vcC5jCkBA IC05MDEsNiArOTAxLDcgQEAgX2xvb3BfdmVjX2luZm86Ol9sb29wX3ZlY19pbmZvIChjbGFz cyBsb29wICpsb29wX2luLCB2ZWNfaW5mb19zaGFyZWQgKnNoYXJlZCkKICAgICB9CiAKICAg ZXBpbG9ndWVfdmluZm9zLmNyZWF0ZSAoNik7CisgIGRyX2l2cyA9IG5ldyBoYXNoX21hcDxk YXRhX3JlZmVyZW5jZSAqLCBpdl9zdHJ1Y3Q+ICgpOwogfQogCiAvKiBGcmVlIGFsbCBsZXZl bHMgb2Ygcmdyb3VwIENPTlRST0xTLiAgKi8KQEAgLTkyNyw2ICs5MjgsNyBAQCBfbG9vcF92 ZWNfaW5mbzo6fl9sb29wX3ZlY19pbmZvICgpCiAgIGRlbGV0ZSBpdmV4cHJfbWFwOwogICBk ZWxldGUgc2Nhbl9tYXA7CiAgIGVwaWxvZ3VlX3ZpbmZvcy5yZWxlYXNlICgpOworICBkZWxl dGUgZHJfaXZzOwogCiAgIC8qIFdoZW4gd2UgcmVsZWFzZSBhbiBlcGlsb2dlIHZpbmZvIHRo YXQgd2UgZG8gbm90IGludGVuZCB0byB1c2UKICAgICAgYXZvaWQgY2xlYXJpbmcgQVVYIG9m IHRoZSBtYWluIGxvb3Agd2hpY2ggc2hvdWxkIGNvbnRpbnVlIHRvCkBAIC05MjUyLDcgKzky NTQsNyBAQCBmaW5kX2luX21hcHBpbmcgKHRyZWUgdCwgdm9pZCAqY29udGV4dCkKICAgIHBy b2xvZ3VlIG9mIHRoZSBtYWluIGxvb3AuICAqLwogCiBzdGF0aWMgdm9pZAotdXBkYXRlX2Vw aWxvZ3VlX2xvb3BfdmluZm8gKGNsYXNzIGxvb3AgKmVwaWxvZ3VlLCB0cmVlIGFkdmFuY2Up Cit1cGRhdGVfZXBpbG9ndWVfbG9vcF92aW5mbyAoY2xhc3MgbG9vcCAqZXBpbG9ndWUpCiB7 CiAgIGxvb3BfdmVjX2luZm8gZXBpbG9ndWVfdmluZm8gPSBsb29wX3ZlY19pbmZvX2Zvcl9s b29wIChlcGlsb2d1ZSk7CiAgIGF1dG9fdmVjPGdpbXBsZSAqPiBzdG10X3dvcmtsaXN0OwpA QCAtOTI2NywxMSArOTI2OSw2IEBAIHVwZGF0ZV9lcGlsb2d1ZV9sb29wX3ZpbmZvIChjbGFz cyBsb29wICplcGlsb2d1ZSwgdHJlZSBhZHZhbmNlKQogICBmcmVlIChMT09QX1ZJTkZPX0JC UyAoZXBpbG9ndWVfdmluZm8pKTsKICAgTE9PUF9WSU5GT19CQlMgKGVwaWxvZ3VlX3ZpbmZv KSA9IGVwaWxvZ3VlX2JiczsKIAotICAvKiBBZHZhbmNlIGRhdGFfcmVmZXJlbmNlJ3Mgd2l0 aCB0aGUgbnVtYmVyIG9mIGl0ZXJhdGlvbnMgb2YgdGhlIHByZXZpb3VzCi0gICAgIGxvb3Ag YW5kIGl0cyBwcm9sb2d1ZS4gICovCi0gIHZlY3RfdXBkYXRlX2luaXRzX29mX2RycyAoZXBp bG9ndWVfdmluZm8sIGFkdmFuY2UsIFBMVVNfRVhQUik7Ci0KLQogICAvKiBUaGUgRVBJTE9H VUUgbG9vcCBpcyBhIGNvcHkgb2YgdGhlIG9yaWdpbmFsIGxvb3Agc28gdGhleSBzaGFyZSB0 aGUgc2FtZQogICAgICBnaW1wbGUgVUlEcy4gIEluIHRoaXMgbG9vcCB3ZSB1cGRhdGUgdGhl IGxvb3BfdmVjX2luZm8gb2YgdGhlIEVQSUxPR1VFIHRvCiAgICAgIHBvaW50IHRvIHRoZSBj b3BpZWQgc3RhdGVtZW50cy4gIFdlIGFsc28gY3JlYXRlIGEgbWFwcGluZyBvZiBhbGwgTEhT JyBpbgpAQCAtOTQ4OSw4ICs5NDg2LDcgQEAgdmVjdF90cmFuc2Zvcm1fbG9vcCAobG9vcF92 ZWNfaW5mbyBsb29wX3ZpbmZvLCBnaW1wbGUgKmxvb3BfdmVjdG9yaXplZF9jYWxsKQogCiAg IGVwaWxvZ3VlID0gdmVjdF9kb19wZWVsaW5nIChsb29wX3ZpbmZvLCBuaXRlcnMsIG5pdGVy c20xLCAmbml0ZXJzX3ZlY3RvciwKIAkJCSAgICAgICZzdGVwX3ZlY3RvciwgJm5pdGVyc192 ZWN0b3JfbXVsdF92ZiwgdGgsCi0JCQkgICAgICBjaGVja19wcm9maXRhYmlsaXR5LCBuaXRl cnNfbm9fb3ZlcmZsb3csCi0JCQkgICAgICAmYWR2YW5jZSk7CisJCQkgICAgICBjaGVja19w cm9maXRhYmlsaXR5LCBuaXRlcnNfbm9fb3ZlcmZsb3cpOwogCiAgIGlmIChMT09QX1ZJTkZP X1NDQUxBUl9MT09QIChsb29wX3ZpbmZvKQogICAgICAgJiYgTE9PUF9WSU5GT19TQ0FMQVJf TE9PUF9TQ0FMSU5HIChsb29wX3ZpbmZvKS5pbml0aWFsaXplZF9wICgpKQpAQCAtOTgxOCw3 ICs5ODE0LDcgQEAgdmVjdF90cmFuc2Zvcm1fbG9vcCAobG9vcF92ZWNfaW5mbyBsb29wX3Zp bmZvLCBnaW1wbGUgKmxvb3BfdmVjdG9yaXplZF9jYWxsKQogCiAgIGlmIChlcGlsb2d1ZSkK ICAgICB7Ci0gICAgICB1cGRhdGVfZXBpbG9ndWVfbG9vcF92aW5mbyAoZXBpbG9ndWUsIGFk dmFuY2UpOworICAgICAgdXBkYXRlX2VwaWxvZ3VlX2xvb3BfdmluZm8gKGVwaWxvZ3VlKTsK IAogICAgICAgZXBpbG9ndWUtPnNpbWR1aWQgPSBsb29wLT5zaW1kdWlkOwogICAgICAgZXBp bG9ndWUtPmZvcmNlX3ZlY3Rvcml6ZSA9IGxvb3AtPmZvcmNlX3ZlY3Rvcml6ZTsKZGlmZiAt LWdpdCBhL2djYy90cmVlLXZlY3Rvcml6ZXIuaCBiL2djYy90cmVlLXZlY3Rvcml6ZXIuaApp bmRleCA3ZGNiNGNkMGI0NmIwM2VlZjkwNzA1ZWVkNzc2ZDljM2RkNzk3MTAxLi5kYTdlMmZl NzJhNTQ5NjM0ZDNjYjE5N2U3MTM2ZGU5OTVlMjBjMmIwIDEwMDY0NAotLS0gYS9nY2MvdHJl ZS12ZWN0b3JpemVyLmgKKysrIGIvZ2NjL3RyZWUtdmVjdG9yaXplci5oCkBAIC01NDUsNiAr NTQ1LDEyIEBAIHR5cGVkZWYgYXV0b192ZWM8cmdyb3VwX2NvbnRyb2xzPiB2ZWNfbG9vcF9s ZW5zOwogCiB0eXBlZGVmIGF1dG9fdmVjPHN0ZDo6cGFpcjxkYXRhX3JlZmVyZW5jZSosIHRy ZWU+ID4gZHJzX2luaXRfdmVjOwogCitzdHJ1Y3QgaXZfc3RydWN0Cit7CisgIHRyZWUgZGVm OworICBlZGdlIHNraXBfZTsKK307CisKIC8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwogLyogSW5mbyBvbiB2 ZWN0b3JpemVkIGxvb3BzLiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICovCiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tKi8KQEAgLTc1Niw2ICs3NjIsOCBAQCBwdWJsaWM6CiAgICAg IGFuYWx5c2lzLiAgKi8KICAgdmVjPF9sb29wX3ZlY19pbmZvICo+IGVwaWxvZ3VlX3ZpbmZv czsKIAorICBoYXNoX21hcDxkYXRhX3JlZmVyZW5jZSAqLCBpdl9zdHJ1Y3Q+ICpkcl9pdnM7 CisKIH0gKmxvb3BfdmVjX2luZm87CiAKIC8qIEFjY2VzcyBGdW5jdGlvbnMuICAqLwpAQCAt MTc5MSw4ICsxNzk5LDcgQEAgY2xhc3MgbG9vcCAqc2xwZWVsX3RyZWVfZHVwbGljYXRlX2xv b3BfdG9fZWRnZV9jZmcgKGNsYXNzIGxvb3AgKiwKIAkJCQkJCSAgICAgY2xhc3MgbG9vcCAq LCBlZGdlKTsKIGNsYXNzIGxvb3AgKnZlY3RfbG9vcF92ZXJzaW9uaW5nIChsb29wX3ZlY19p bmZvLCBnaW1wbGUgKik7CiBleHRlcm4gY2xhc3MgbG9vcCAqdmVjdF9kb19wZWVsaW5nIChs b29wX3ZlY19pbmZvLCB0cmVlLCB0cmVlLAotCQkJCSAgICB0cmVlICosIHRyZWUgKiwgdHJl ZSAqLCBpbnQsIGJvb2wsIGJvb2wsCi0JCQkJICAgIHRyZWUgKik7CisJCQkJICAgIHRyZWUg KiwgdHJlZSAqLCB0cmVlICosIGludCwgYm9vbCwgYm9vbCk7CiBleHRlcm4gdm9pZCB2ZWN0 X3ByZXBhcmVfZm9yX21hc2tlZF9wZWVscyAobG9vcF92ZWNfaW5mbyk7CiBleHRlcm4gZHVt cF91c2VyX2xvY2F0aW9uX3QgZmluZF9sb29wX2xvY2F0aW9uIChjbGFzcyBsb29wICopOwog ZXh0ZXJuIGJvb2wgdmVjdF9jYW5fYWR2YW5jZV9pdnNfcCAobG9vcF92ZWNfaW5mbyk7Cg== --------------E7B38F8A841FEA6FE7783B71--