From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 126421 invoked by alias); 8 Feb 2016 03:46:10 -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 126403 invoked by uid 89); 8 Feb 2016 03:46:09 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=1.0 required=5.0 tests=AWL,BAYES_50,KAM_ASCII_DIVIDERS,LIKELY_SPAM_BODY,RCVD_IN_DNSWL_NONE,RP_MATCHES_RCVD,SPF_PASS autolearn=no version=3.3.2 spammy=advertising, Lose, guidance, underway X-HELO: bosmailout01.eigbox.net Received: from bosmailout01.eigbox.net (HELO bosmailout01.eigbox.net) (66.96.190.1) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-SHA encrypted) ESMTPS; Mon, 08 Feb 2016 03:46:06 +0000 Received: from bosmailscan08.eigbox.net ([10.20.15.8]) by bosmailout01.eigbox.net with esmtp (Exim) id 1aScm3-0006zJ-Cb for gcc-patches@gcc.gnu.org; Sun, 07 Feb 2016 22:46:03 -0500 Received: from [10.115.3.32] (helo=bosimpout12) by bosmailscan08.eigbox.net with esmtp (Exim) id 1aScm3-0007vt-7q for gcc-patches@gcc.gnu.org; Sun, 07 Feb 2016 22:46:03 -0500 Received: from bosauthsmtp18.yourhostingaccount.com ([10.20.18.18]) by bosimpout12 with id Fflx1s0050PPbB601fm0m1; Sun, 07 Feb 2016 22:46:03 -0500 X-Authority-Analysis: v=2.1 cv=BfVW09d2 c=1 sm=1 tr=0 a=hsonH7E3nOZjOFuRJksPKA==:117 a=sZx1nW7oDdbgogxTPqu5Xw==:17 a=L9H7d07YOLsA:10 a=9cW_t1CCXrUA:10 a=s5jvgZ67dGcA:10 a=88b2x-oFWvEA:10 a=jFJIQSaiL_oA:10 a=r77TgQKjGQsHNAKrUKIA:9 a=mDV3o1hIAAAA:8 a=C8F9KGFtAAAA:8 a=AgeaKr-9NJKguJVWvfAA:9 a=WcZY_QAFIgvVifEb:21 a=Z2XF4PoNCYsDosv6:21 a=QEXdDO2ut3YA:10 a=JKmFtq4-eAMA:10 a=IPECJyk6XdEdxy7DGkMA:9 a=6q7fhYwmMtUvtO3n:21 a=5hxhG3sqmlnpgKnJ:21 Received: from [207.118.20.56] (port=50513 helo=[192.168.1.159]) by bosauthsmtp18.eigbox.net with esmtpa (Exim) id 1aSclv-0005qN-Lr; Sun, 07 Feb 2016 22:45:56 -0500 Subject: Re: Wonly-top-basic-asm To: Bernd Schmidt , "gcc-patches@gcc.gnu.org" , Richard Henderson , jason@redhat.com References: <56A54EF9.8060006@LimeGreenSocks.com> <56A61442.3090803@redhat.com> <56A9C134.1030500@LimeGreenSocks.com> Cc: segher@kernel.crashing.org, sandra@codesourcery.com, Paul_Koning@Dell.com, Jeff Law , bernds_cb1@t-online.de, Bernd Edlinger , Andrew Haley , David Wohlferd From: David Wohlferd Message-ID: <56B80F57.9020606@LimeGreenSocks.com> Date: Mon, 08 Feb 2016 03:46:00 -0000 User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:38.0) Gecko/20100101 Thunderbird/38.5.1 MIME-Version: 1.0 In-Reply-To: <56A9C134.1030500@LimeGreenSocks.com> Content-Type: multipart/mixed; boundary="------------060301050000030304060401" X-EN-UserInfo: 97390230d6758ac7ebdf93f8c6197d31:931c98230c6409dcc37fa7e93b490c27 X-EN-AuthUser: dw@limegreensocks.com X-EN-OrigIP: 207.118.20.56 X-EN-OrigHost: unknown X-SW-Source: 2016-02/txt/msg00498.txt.bz2 This is a multi-part message in MIME format. --------------060301050000030304060401 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Content-length: 8952 Hey Bernd. I replied with a patch that includes most of the changes you asked for (see inline below). Were you waiting on me for something more? I have cleaned up the testcases so they aren't so i386-specific, but otherwise this patch (attached) is the same. Let me know if there is something more I need to do here. Thanks, dw On 1/27/2016 11:20 PM, David Wohlferd wrote: > Rumors that I earn a commission for every person I switch to the > "extended asm" plan are completely unfounded... :) > > That said, I truly believe there are very few cases where using basic > asm within a function makes sense. What's more, either they currently > work incorrectly and need to be found and fixed, or they are going to > take a performance hit when the new "clobber everything" semantics are > implemented. So yeah, I pushed pretty hard to have the docs say > "DON'T USE IT!" > > But reading it all again, you are right: It's too much. > > On 1/25/2016 4:25 AM, Bernd Schmidt wrote: >> On 01/24/2016 11:23 PM, David Wohlferd wrote: >>> +Wonly-top-basic-asm >>> +C ObjC ObjC++ C++ Var(warn_only_top_basic_asm) Warning >>> +Warn on unsafe uses of basic asm. >> >> Maybe just -Wbasic-asm? > > Hmm. Maybe. I've never been completely satisfied with that name. But > wouldn't this sound like it would warn on all uses of basic asm? The > intent is to only flag the ones in functions. They are the ones with > all the problems. > > What would you say to -Wbasic-asm-in-function? A little verbose... > >>> + /* Warn on basic asm used inside of functions, >>> + EXCEPT when in naked functions. Also allow asm(""). */ >> >> Two spaces after a sentence. > > Fixed. > >>> + if (warn_only_top_basic_asm && (TREE_STRING_LENGTH (str) != 1) ) >> >> Unnecessary parens, and extra space before closing paren. > > Fixed. > >>> + if (warn_only_top_basic_asm && >>> + (TREE_STRING_LENGTH (string) != 1)) >> >> Extra parens, and && goes first on the next line. > > Fixed. > >>> + warning_at(asm_loc, OPT_Wonly_top_basic_asm, >> >> Space before "(". > > Fixed. > >>> + "asm statement in function does not use extended >>> syntax"); >> >> Could break that into ".." "..." over two lines so as to keep >> indentation. > > Fixed. > >>> -asm (""); >>> +asm ("":::); >> >> Is that necessary? As far as I can tell we're treating these equally. > > While you are correct that today they are treated (nearly) equally, if > Jeff does what he plans for v7, asm("") is going to translate (on x64) > to: > > asm("":::"rax", "rbx", "rcx", "rdx", "r8", "r9", "r10", "r11", "r12", > "r13", "r14", "r15", "rdi", "rsi", "rbp", "cc", "memory"); > > Given that, it seemed appropriate for the docs to start steering > people away from basic. This particular instance was just something > that was mentioned during the discussion. > > However, that's for someday. Maybe "someday" will turn into some > other solution. And since I'm not prepared to go thru all the docs > and change all the other basic asms at this time, I removed this change. > >>> @@ -7487,6 +7490,8 @@ >>> consecutive in the output, put them in a single multi-instruction >>> @code{asm} >>> statement. Note that GCC's optimizers can move @code{asm} statements >>> relative to other code, including across jumps. >>> +Using inputs and outputs with extended @code{asm} can help >>> correctly position >>> +your asm. >> >> Not sure this is needed either. Sounds a bit like advertising :) In >> general the doc changes seem much too verbose to me. > > I didn't think about this until it was brought up during the > discussion. But once it was pointed out to me, it made sense. > > However, at your suggestion I have removed this. > >>> +Extended @code{asm}'s @samp{%=} may help resolve this. >> >> Same here. I think the block that recommends extended asm is good >> enough. I think the next part could be shrunk significantly too. > > Removed. > >>> -Here is an example of basic @code{asm} for i386: >>> +Basic @code{asm} statements within functions do not perform an >>> implicit >>> +"memory" clobber (@pxref{Clobbers}). Also, there is no implicit >>> clobbering >>> +of @emph{any} registers, so (other than "naked" functions which >>> follow the >> >> "other than in"? Also @code{naked} maybe. > > It works for me either way. Since it bothers you, I changed it. > >> I'd place a note about clobbering after the existing "To access C >> data, it is better to use extended asm". >> >>> +ABI rules) changed registers must be restored to their original >>> value before >>> +exiting the @code{asm}. While this behavior has not always been >>> documented, >>> +GCC has worked this way since at least v2.95.3. Also, lacking >>> inputs and >>> +outputs means that GCC's optimizers may have difficulties consistently >>> +positioning the basic @code{asm} in the generated code. >> >> The existing text already mentions ordering issues. Lose this block. > > I've removed the rest of the paragraph after "Also" > > Wait, didn't you tell me to remove the other mention of 'ordering'? I > think I've removed all of them now. Not a huge loss, but was that > what you intended? > >>> +The concept of ``clobbering'' does not apply to basic @code{asm} >>> statements >>> +outside of functions (aka top-level asm). >> >> Stating the obvious? > > I don't actually agree with this one. However I do agree with your > comment re being too verbose. Since the new sample shows how to do > this (using extended asm for clobbers), I have removed this. > >>> +@strong{Warning!} This "clobber nothing" behavior may be different >>> than how >> >> Ok there is precedent for this, but it's spelt "@strong{Warning:}" in >> all other cases. > > Fixed. > >> Still, I'd probably also shrink this paragraph and put a note about >> lack of C semantics and possibly different behaviour from other >> compilers near the top, where we say that extended asm is better in >> most cases. >> >>> +other compilers treat basic @code{asm}, since the C standards for the >>> +@code{asm} statement provide no guidance regarding these >>> semantics. As a >>> +result, @code{asm} statements that work correctly on other >>> compilers may not >>> +work correctly with GCC (and vice versa), even though they both >>> compile >>> +without error. Also, there is discussion underway about changing >>> GCC to >>> +have basic @code{asm} clobber at least memory and perhaps some (or >>> all) >>> +registers. If implemented, this change may fix subtle problems with >>> +existing @code{asm} statements. However it may break or slow down >>> ones that >>> +were working correctly. >> >> How would such a change break anything? I'd also not mention >> discussion underway, just say "Future versions of GCC may treat basic >> @code{asm} as clobbering memory". > > Removed 'discussion underway', but kept references to clobbering > registers. That's Jeff's expressed intent, and part of why I believe > people will want to find these statements. > >>> +If your existing code needs clobbers that GCC's basic @code{asm} is >>> not >>> +providing, or if you want to 'future-proof' your asm against possible >>> +changes to basic @code{asm}'s semantics, use extended @code{asm}. >> >> Recommending it too often. Lose this. >> >>> +Extended @code{asm} allows you to specify what (if anything) needs >>> to be >>> +clobbered for your code to work correctly. >> >> And again. > > I believe I have removed and replaced all the recurring redundant > repetitiveness. > >>> You can use @ref{Warning >>> +Options, @option{-Wonly-top-basic-asm}} to locate basic @code{asm} >> >> I think just plain @option is usual. > > You are recommending I remove the link to the warning options? While > I'm normally a big fan of links, I defer to your judgement. Removed. > >>> +statements that may need changes, and refer to >>> +@uref{https://gcc.gnu.org/wiki/ConvertBasicAsmToExtended, How to >>> convert >>> +from basic asm to extended asm} for information about how to >>> perform the >>> +conversion. >> >> A link is probably good if we have such a page. > > We do have such a page, but it was written by the same "too verbose" > guy that wrote this patch. Might be worth a review if you have a minute. > >>> +Here is an example of top-level basic @code{asm} for i386 that >>> defines an >>> +asm macro. That macro is then invoked from within a function using >>> +extended @code{asm}: >> >> The updated example also looks good. > > There are legitimate uses for basic asm. While this sample is still > trivial, it shows a much more important concept than the old one. > >> I think I'm fine with the concept > > Thanks for the detailed review. > >> but I'd like to see an updated patch with better docs. > > Updated patch attached. Now includes testsuites. The updated web > page is at http://www.limegreensocks.com/gcc/Basic-Asm.html > > dw --------------060301050000030304060401 Content-Type: text/x-patch; name="24414Q.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="24414Q.patch" Content-length: 11684 SW5kZXg6IGdjYy9jLWZhbWlseS9jLm9wdA0KPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQ0KLS0tIGdjYy9jLWZhbWlseS9jLm9wdAkocmV2aXNpb24gMjMzMjA2 KQ0KKysrIGdjYy9jLWZhbWlseS9jLm9wdAkod29ya2luZyBjb3B5KQ0KQEAg LTU4NSw2ICs1ODUsMTAgQEANCiBDKysgT2JqQysrIFZhcih3YXJuX25hbWVz cGFjZXMpIFdhcm5pbmcKIFdhcm4gb24gbmFtZXNwYWNlIGRlZmluaXRpb24u CiAKK1dvbmx5LXRvcC1iYXNpYy1hc20KK0MgT2JqQyBPYmpDKysgQysrIFZh cih3YXJuX29ubHlfdG9wX2Jhc2ljX2FzbSkgV2FybmluZworV2FybiBvbiB1 bnNhZmUgdXNlcyBvZiBiYXNpYyBhc20uCisKIFdzaXplZC1kZWFsbG9jYXRp b24KIEMrKyBPYmpDKysgVmFyKHdhcm5fc2l6ZWRfZGVhbGxvY2F0aW9uKSBX YXJuaW5nIEVuYWJsZWRCeShXZXh0cmEpCiBXYXJuIGFib3V0IG1pc3Npbmcg c2l6ZWQgZGVhbGxvY2F0aW9uIGZ1bmN0aW9ucy4KSW5kZXg6IGdjYy9jL2Mt cGFyc2VyLmMNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBnY2MvYy9j LXBhcnNlci5jCShyZXZpc2lvbiAyMzMyMDYpDQorKysgZ2NjL2MvYy1wYXJz ZXIuYwkod29ya2luZyBjb3B5KQ0KQEAgLTU5NzIsNyArNTk3MiwxOCBAQA0K ICAgbGFiZWxzID0gTlVMTF9UUkVFOwogCiAgIGlmIChjX3BhcnNlcl9uZXh0 X3Rva2VuX2lzIChwYXJzZXIsIENQUF9DTE9TRV9QQVJFTikgJiYgIWlzX2dv dG8pCisgIHsKKyAgICAvKiBXYXJuIG9uIGJhc2ljIGFzbSB1c2VkIGluc2lk ZSBvZiBmdW5jdGlvbnMsIAorICAgICAgIEVYQ0VQVCB3aGVuIGluIG5ha2Vk IGZ1bmN0aW9ucy4gIEFsc28gYWxsb3cgYXNtKCIiKS4gKi8KKyAgICBpZiAo d2Fybl9vbmx5X3RvcF9iYXNpY19hc20gJiYgVFJFRV9TVFJJTkdfTEVOR1RI IChzdHIpICE9IDEpCisgICAgICBpZiAobG9va3VwX2F0dHJpYnV0ZSAoIm5h a2VkIiwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgREVDTF9BVFRS SUJVVEVTIChjdXJyZW50X2Z1bmN0aW9uX2RlY2wpKSAKKyAgICAgICAgICA9 PSBOVUxMX1RSRUUpCisgICAgICAgIHdhcm5pbmdfYXQgKGFzbV9sb2MsIE9Q VF9Xb25seV90b3BfYmFzaWNfYXNtLCAKKyAgICAgICAgICAgICAgICAgICAg ImFzbSBzdGF0ZW1lbnQgaW4gZnVuY3Rpb24gZG9lcyBub3QgdXNlIGV4dGVu ZGVkIHN5bnRheCIpOworCiAgICAgZ290byBkb25lX2FzbTsKKyAgfQogCiAg IC8qIFBhcnNlIGVhY2ggY29sb24tZGVsaW1pdGVkIHNlY3Rpb24gb2Ygb3Bl cmFuZHMuICAqLwogICBuc2VjdGlvbnMgPSAzICsgaXNfZ290bzsKSW5kZXg6 IGdjYy9jcC9wYXJzZXIuYw0KPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0t IGdjYy9jcC9wYXJzZXIuYwkocmV2aXNpb24gMjMzMjA2KQ0KKysrIGdjYy9j cC9wYXJzZXIuYwkod29ya2luZyBjb3B5KQ0KQEAgLTE4MDIxLDYgKzE4MDIx LDggQEANCiAgIGJvb2wgZ290b19wID0gZmFsc2U7CiAgIHJlcXVpcmVkX3Rv a2VuIG1pc3NpbmcgPSBSVF9OT05FOwogCisgIGxvY2F0aW9uX3QgYXNtX2xv YyA9IGNwX2xleGVyX3BlZWtfdG9rZW4gKHBhcnNlci0+bGV4ZXIpLT5sb2Nh dGlvbjsKKwogICAvKiBMb29rIGZvciB0aGUgYGFzbScga2V5d29yZC4gICov CiAgIGNwX3BhcnNlcl9yZXF1aXJlX2tleXdvcmQgKHBhcnNlciwgUklEX0FT TSwgUlRfQVNNKTsKIApAQCAtMTgxNzksNiArMTgxODEsMTcgQEANCiAJICAv KiBJZiB0aGUgZXh0ZW5kZWQgc3ludGF4IHdhcyBub3QgdXNlZCwgbWFyayB0 aGUgQVNNX0VYUFIuICAqLwogCSAgaWYgKCFleHRlbmRlZF9wKQogCSAgICB7 CisJICAgICAgLyogV2FybiBvbiBiYXNpYyBhc20gdXNlZCBpbnNpZGUgb2Yg ZnVuY3Rpb25zLAorCSAgICAgICAgIEVYQ0VQVCB3aGVuIGluIG5ha2VkIGZ1 bmN0aW9ucy4gIEFsc28gYWxsb3cgYXNtKCIiKS4gKi8KKwkgICAgICBpZiAo d2Fybl9vbmx5X3RvcF9iYXNpY19hc20KKwkgICAgICAgICAgJiYgVFJFRV9T VFJJTkdfTEVOR1RIIChzdHJpbmcpICE9IDEpCisJICAgICAgICBpZiAobG9v a3VwX2F0dHJpYnV0ZSgibmFrZWQiLAorCSAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgREVDTF9BVFRSSUJVVEVTIChjdXJyZW50X2Z1bmN0aW9uX2Rl Y2wpKQorCSAgICAgICAgICAgID09IE5VTExfVFJFRSkKKwkgICAgICAgICAg d2FybmluZ19hdCAoYXNtX2xvYywgT1BUX1dvbmx5X3RvcF9iYXNpY19hc20s CisJICAgICAgICAgICAgICAgICAgICAgICJhc20gc3RhdGVtZW50IGluIGZ1 bmN0aW9uIGRvZXMgbm90IHVzZSBleHRlbmRlZCIKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICIgc3ludGF4Iik7CisKIAkgICAgICB0cmVlIHRl bXAgPSBhc21fc3RtdDsKIAkgICAgICBpZiAoVFJFRV9DT0RFICh0ZW1wKSA9 PSBDTEVBTlVQX1BPSU5UX0VYUFIpCiAJCXRlbXAgPSBUUkVFX09QRVJBTkQg KHRlbXAsIDApOwpJbmRleDogZ2NjL2RvYy9leHRlbmQudGV4aQ0KPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQ0KLS0tIGdjYy9kb2MvZXh0ZW5kLnRleGkJKHJl dmlzaW9uIDIzMzIwNikNCisrKyBnY2MvZG9jL2V4dGVuZC50ZXhpCSh3b3Jr aW5nIGNvcHkpDQpAQCAtNzQ1OCw3ICs3NDU4LDggQEANCiBAZW5kIHRhYmxl CiAKIEBzdWJzdWJoZWFkaW5nIFJlbWFya3MKLVVzaW5nIGV4dGVuZGVkIEBj b2Rle2FzbX0gdHlwaWNhbGx5IHByb2R1Y2VzIHNtYWxsZXIsIHNhZmVyLCBh bmQgbW9yZQorVXNpbmcgZXh0ZW5kZWQgQGNvZGV7YXNtfSAoQHB4cmVme0V4 dGVuZGVkIEFzbX0pIHR5cGljYWxseSBwcm9kdWNlcyBzbWFsbGVyLAorc2Fm ZXIsIGFuZCBtb3JlCiBlZmZpY2llbnQgY29kZSwgYW5kIGluIG1vc3QgY2Fz ZXMgaXQgaXMgYSBiZXR0ZXIgc29sdXRpb24gdGhhbiBiYXNpYwogQGNvZGV7 YXNtfS4gIEhvd2V2ZXIsIHRoZXJlIGFyZSB0d28gc2l0dWF0aW9ucyB3aGVy ZSBvbmx5IGJhc2ljIEBjb2Rle2FzbX0KIGNhbiBiZSB1c2VkOgpAQCAtNzUx NiwxMSArNzUxNyw1MSBAQA0KIEJhc2ljIEBjb2Rle2FzbX0gcHJvdmlkZXMg bm8KIG1lY2hhbmlzbSB0byBwcm92aWRlIGRpZmZlcmVudCBhc3NlbWJsZXIg c3RyaW5ncyBmb3IgZGlmZmVyZW50IGRpYWxlY3RzLgogCi1IZXJlIGlzIGFu IGV4YW1wbGUgb2YgYmFzaWMgQGNvZGV7YXNtfSBmb3IgaTM4NjoKK0Jhc2lj IEBjb2Rle2FzbX0gc3RhdGVtZW50cyBkbyBub3QgcGVyZm9ybSBhbiBpbXBs aWNpdCAibWVtb3J5IiBjbG9iYmVyCisoQHB4cmVme0Nsb2JiZXJzfSkuICBB bHNvLCB0aGVyZSBpcyBubyBpbXBsaWNpdCBjbG9iYmVyaW5nIG9mIEBlbXBo e2FueX0KK3JlZ2lzdGVycywgc28gKG90aGVyIHRoYW4gaW4gQGNvZGV7bmFr ZWR9IGZ1bmN0aW9ucyB3aGljaCBmb2xsb3cgdGhlIEFCSQorcnVsZXMpIGNo YW5nZWQgcmVnaXN0ZXJzIG11c3QgYmUgcmVzdG9yZWQgdG8gdGhlaXIgb3Jp Z2luYWwgdmFsdWUgYmVmb3JlCitleGl0aW5nIHRoZSBAY29kZXthc219LiAg V2hpbGUgdGhpcyBiZWhhdmlvciBoYXMgbm90IGFsd2F5cyBiZWVuCitkb2N1 bWVudGVkLCBHQ0MgaGFzIHdvcmtlZCB0aGlzIHdheSBzaW5jZSBhdCBsZWFz dCB2Mi45NS4zLgogCitAc3Ryb25ne1dhcm5pbmc6fSBUaGlzICJjbG9iYmVy IG5vdGhpbmciIGJlaGF2aW9yIG1heSBiZSBkaWZmZXJlbnQgdGhhbiBob3cK K290aGVyIGNvbXBpbGVycyB0cmVhdCBiYXNpYyBAY29kZXthc219LCBzaW5j ZSB0aGUgQyBzdGFuZGFyZHMgZm9yIHRoZQorQGNvZGV7YXNtfSBzdGF0ZW1l bnQgcHJvdmlkZSBubyBndWlkYW5jZSByZWdhcmRpbmcgdGhlc2Ugc2VtYW50 aWNzLiAgQXMgYQorcmVzdWx0LCBAY29kZXthc219IHN0YXRlbWVudHMgdGhh dCB3b3JrIGNvcnJlY3RseSBvbiBvdGhlciBjb21waWxlcnMgbWF5IG5vdAor d29yayBjb3JyZWN0bHkgd2l0aCBHQ0MgKGFuZCB2aWNlIHZlcnNhKSwgZXZl biB0aG91Z2ggdGhleSBib3RoIGNvbXBpbGUKK3dpdGhvdXQgZXJyb3IuCisK K0Z1dHVyZSB2ZXJzaW9ucyBvZiBHQ0MgbWF5IGNoYW5nZSBiYXNpYyBAY29k ZXthc219IHRvIGNsb2JiZXIgbWVtb3J5IGFuZAorcGVyaGFwcyBzb21lIChv ciBhbGwpIHJlZ2lzdGVycy4gIFRoaXMgY2hhbmdlIG1heSBmaXggc3VidGxl IHByb2JsZW1zIHdpdGgKK2V4aXN0aW5nIEBjb2Rle2FzbX0gc3RhdGVtZW50 cy4gIEhvd2V2ZXIgaXQgbWF5IGJyZWFrIG9yIHNsb3cgZG93biBvbmVzCit0 aGF0IHdlcmUgd29ya2luZyBjb3JyZWN0bHkuICBUbyBgYGZ1dHVyZS1wcm9v ZicnIHlvdXIgYXNtIGFnYWluc3QgcG9zc2libGUKK2NoYW5nZXMgdG8gYmFz aWMgQGNvZGV7YXNtfSdzIHNlbWFudGljcywgdXNlIGV4dGVuZGVkIEBjb2Rl e2FzbX0uCisKK1lvdSBjYW4gdXNlIEBvcHRpb257LVdvbmx5LXRvcC1iYXNp Yy1hc219IHRvIGxvY2F0ZSBiYXNpYyBAY29kZXthc219CitzdGF0ZW1lbnRz IHRoYXQgbWF5IG5lZWQgY2hhbmdlcywgYW5kIHJlZmVyIHRvCitAdXJlZnto dHRwczovL2djYy5nbnUub3JnL3dpa2kvQ29udmVydEJhc2ljQXNtVG9FeHRl bmRlZCwgSG93IHRvIGNvbnZlcnQKK2Zyb20gYmFzaWMgYXNtIHRvIGV4dGVu ZGVkIGFzbX0gZm9yIGluZm9ybWF0aW9uIGFib3V0IGhvdyB0byBwZXJmb3Jt IHRoZQorY29udmVyc2lvbi4KKworSGVyZSBpcyBhbiBleGFtcGxlIG9mIHRv cC1sZXZlbCBiYXNpYyBAY29kZXthc219IGZvciBpMzg2IHRoYXQgZGVmaW5l cyBhbgorYXNtIG1hY3JvLiAgVGhhdCBtYWNybyBpcyB0aGVuIGludm9rZWQg ZnJvbSB3aXRoaW4gYSBmdW5jdGlvbiB1c2luZworZXh0ZW5kZWQgQGNvZGV7 YXNtfToKKwogQGV4YW1wbGUKLS8qIE5vdGUgdGhhdCB0aGlzIGNvZGUgd2ls bCBub3QgY29tcGlsZSB3aXRoIC1tYXNtPWludGVsICovCi0jZGVmaW5lIERl YnVnQnJlYWsoKSBhc20oImludCAkMyIpCisvKiBEZWZpbmUgbWFjcm8gYXQg ZmlsZSBzY29wZSB3aXRoIGJhc2ljIGFzbS4gKi8KKy8qIEFkZCBtYWNybyBw YXJhbWV0ZXIgcCB0byBlYXguICovCithc20oIi5tYWNybyB0ZXN0IHBcblx0 IgorICAgICJhZGRsICRcXHAsICVlYXhcblx0IgorICAgICIuZW5kbSIpOwor CisvKiBVc2UgbWFjcm8gaW4gZnVuY3Rpb24gdXNpbmcgZXh0ZW5kZWQgYXNt LiAgSXQgbmVlZHMgKi8KKy8qIHRoZSAiY2MiIGNsb2JiZXIgc2luY2UgdGhl IGZsYWdzIGFyZSBjaGFuZ2VkIGFuZCB1c2VzICovCisvKiB0aGUgImEiIGNv bnN0cmFpbnQgc2luY2UgaXQgbW9kaWZpZXMgZWF4LiAqLworaW50IERvQWRk KGludCB2YWx1ZSkKK0B7CisgICBhc20oInRlc3QgNSIgOiAiK2EiICh2YWx1 ZSkgOiA6ICJjYyIpOworICAgcmV0dXJuIHZhbHVlOworQH0KIEBlbmQgZXhh bXBsZQogCiBAbm9kZSBFeHRlbmRlZCBBc20KQEAgLTgwNDcsNyArODA4OCw3 IEBADQogZm9yIEBjb2Rle2R9IGJ5IHNwZWNpZnlpbmcgYm90aCBjb25zdHJh aW50cy4KIAogQGFuY2hvcntGbGFnT3V0cHV0T3BlcmFuZHN9Ci1Ac3Vic2Vj dGlvbiBGbGFnIE91dHB1dCBPcGVyYW5kcworQHN1YnN1YnNlY3Rpb24gRmxh ZyBPdXRwdXQgT3BlcmFuZHMKIEBjaW5kZXggQGNvZGV7YXNtfSBmbGFnIG91 dHB1dCBvcGVyYW5kcwogCiBTb21lIHRhcmdldHMgaGF2ZSBhIHNwZWNpYWwg cmVnaXN0ZXIgdGhhdCBob2xkcyB0aGUgYGBmbGFncycnIGZvciB0aGUKSW5k ZXg6IGdjYy9kb2MvaW52b2tlLnRleGkNCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0NCi0tLSBnY2MvZG9jL2ludm9rZS50ZXhpCShyZXZpc2lvbiAyMzMyMDYp DQorKysgZ2NjL2RvYy9pbnZva2UudGV4aQkod29ya2luZyBjb3B5KQ0KQEAg LTU3MjgsNiArNTcyOCwyMSBAQA0KIGEgc3RydWN0dXJlIHRoYXQgaGFzIGJl ZW4gbWFya2VkIHdpdGggdGhlIEBjb2Rle2Rlc2lnbmF0ZWRfaW5pdH0KIGF0 dHJpYnV0ZS4KIAorQGl0ZW0gLVdvbmx5LXRvcC1iYXNpYy1hc20gQHJ7KEMg YW5kIEMrKyBvbmx5KX0KK1dhcm4gaWYgYmFzaWMgQGNvZGV7YXNtfSBzdGF0 ZW1lbnRzIGFyZSB1c2VkIGluc2lkZSBhIGZ1bmN0aW9uIChpLmUuIG5vdCBh dAordG9wLWxldmVsL2ZpbGUgc2NvcGUpLgorCitXaGVuIHVzZWQgaW5zaWRl IG9mIGZ1bmN0aW9ucywgYmFzaWMgQGNvZGV7YXNtfSBjYW4gcmVzdWx0IGlu IHVuZXhwZWN0ZWQgYW5kCit1bndhbnRlZCB2YXJpYXRpb25zIGluIGJlaGF2 aW9yIGJldHdlZW4gY29tcGlsZXJzIGR1ZSB0byBob3cgcmVnaXN0ZXJzIGFy ZQoraGFuZGxlZCB3aGVuIGNhbGxpbmcgdGhlIGFzbSAoQHB4cmVme0Jhc2lj IEFzbX0pLiAgVGhlIGxhY2sgb2YgaW5wdXQgYW5kCitvdXRwdXQgY29uc3Ry YWludHMgKEBweHJlZntFeHRlbmRlZCBBc219KSBjYW4gYWxzbyBtYWtlIGl0 IGRpZmZpY3VsdCBmb3IKK29wdGltaXplcnMgdG8gY29ycmVjdGx5IGFuZCBj b25zaXN0ZW50bHkgcG9zaXRpb24gdGhlIG91dHB1dCByZWxhdGl2ZSB0bwor b3RoZXIgY29kZS4KKworRnVuY3Rpb25zIHRoYXQgYXJlIG1hcmtlZCB3aXRo IHRoZSBAb3B0aW9ue25ha2VkfSBhdHRyaWJ1dGUgKEBweHJlZntGdW5jdGlv bgorQXR0cmlidXRlc30pIGFuZCBAY29kZXthc219IHN0YXRlbWVudHMgd2l0 aCBhbiBlbXB0eSBpbnN0cnVjdGlvbiBzdHJpbmcgYXJlCitleGNsdWRlZCBm cm9tIHRoaXMgY2hlY2suCisKIEBpdGVtIC1XaHNhCiBJc3N1ZSBhIHdhcm5p bmcgd2hlbiBIU0FJTCBjYW5ub3QgYmUgZW1pdHRlZCBmb3IgdGhlIGNvbXBp bGVkIGZ1bmN0aW9uIG9yCiBPcGVuTVAgY29uc3RydWN0LgpJbmRleDogZ2Nj L3Rlc3RzdWl0ZS9jLWMrKy1jb21tb24vV29ubHktdG9wLWJhc2ljLWFzbS0y LmMNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBnY2MvdGVzdHN1aXRl L2MtYysrLWNvbW1vbi9Xb25seS10b3AtYmFzaWMtYXNtLTIuYwkocmV2aXNp b24gMCkNCisrKyBnY2MvdGVzdHN1aXRlL2MtYysrLWNvbW1vbi9Xb25seS10 b3AtYmFzaWMtYXNtLTIuYwkod29ya2luZyBjb3B5KQ0KQEAgLTAsMCArMSwx NSBAQA0KKy8qIHsgZGctZG8gY29tcGlsZSB9ICovCisvKiB7IGRnLXJlcXVp cmUtZWZmZWN0aXZlLXRhcmdldCBuYWtlZF9mdW5jdGlvbnMgfSAqLworLyog eyBkZy1vcHRpb25zICItV29ubHktdG9wLWJhc2ljLWFzbSIgfSAqLworCitp bnQgX19hdHRyaWJ1dGVfXygobmFrZWQpKQorZnVuYyAoaW50IHgsIGludCB5 KQoreworICAvKiBiYXNpYyBhc20gc2hvdWxkIG5vdCB3YXJuIGluIG5ha2Vk IGZ1bmN0aW9ucy4gKi8KKyAgIGFzbSgiICIpOyAvKiBubyB3YXJuaW5nICov Cit9CisKK2ludCBtYWluKGludCBhcmdjLCBjaGFyICphcmd2W10pCit7Cisg ICByZXR1cm4gZnVuYyhhcmdjLCBhcmdjKTsKK30KSW5kZXg6IGdjYy90ZXN0 c3VpdGUvYy1jKystY29tbW9uL1dvbmx5LXRvcC1iYXNpYy1hc20uYw0KPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQ0KLS0tIGdjYy90ZXN0c3VpdGUvYy1jKyst Y29tbW9uL1dvbmx5LXRvcC1iYXNpYy1hc20uYwkocmV2aXNpb24gMCkNCisr KyBnY2MvdGVzdHN1aXRlL2MtYysrLWNvbW1vbi9Xb25seS10b3AtYmFzaWMt YXNtLmMJKHdvcmtpbmcgY29weSkNCkBAIC0wLDAgKzEsNDMgQEANCisvKiB7 IGRnLWRvIGNvbXBpbGUgfSAqLworLyogeyBkZy1vcHRpb25zICItV29ubHkt dG9wLWJhc2ljLWFzbSIgfSAqLworDQorI2lmIGRlZmluZWQoX19pMzg2X18p IHx8IGRlZmluZWQoX194ODZfNjRfXykKKy8qIGFjY2VwdGFibGUgKi8NCity ZWdpc3RlciBpbnQgYiBhc20oImVzaSIpOw0KKyNlbHNlDQoraW50IGIgPSAz Ow0KKyNlbmRpZg0KKw0KKy8qIGFjY2VwdGFibGUgKi8NCitpbnQgZm9vIGFz bSAoIm15Zm9vIikgPSAyOw0KKw0KKy8qIGFjY2VwdGFibGUgKi8NCithc20g KCIgIik7DQorDQorLyogYWNjZXB0YWJsZSAqLw0KK2ludCBmdW5jIChpbnQg eCwgaW50IHkpIGFzbSAoIk1ZRlVOQyIpOw0KKw0KK2ludCBtYWluKGludCBh cmdjLCBjaGFyICphcmd2W10pDQorew0KKyNpZiBkZWZpbmVkKF9faTM4Nl9f KSB8fCBkZWZpbmVkKF9feDg2XzY0X18pCisgICAvKiBhY2NlcHRhYmxlICov DQorICAgcmVnaXN0ZXIgaW50IGEgYXNtKCJlZGkiKTsNCisjZWxzZQ0KKyAg IGludCBhID0gMjsNCisjZW5kaWYNCisNCisgICAvKiBhY2NlcHRhYmxlICov DQorICAgYXNtKCIgIjo6InIiKGEpLCAiciIgKGIpKTsNCisNCisgICAvKiBh Y2NlcHRhYmxlICovDQorICAgYXNtIGdvdG8gKCIiOjo6OmRvbmUpOw0KKw0K KyAgIC8qIGFjY2VwdGFibGUgKi8NCisgICBhc20oIiIpOw0KKw0KKyAgIC8q IHdhcm5pbmcgKi8NCisgICBhc20oIiAiKTsgLyogeyBkZy13YXJuaW5nICJk b2VzIG5vdCB1c2UgZXh0ZW5kZWQgc3ludGF4IiB9ICovDQorDQorICBkb25l Og0KKyAgIHJldHVybiAwOw0KK30NCg== --------------060301050000030304060401--