From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 51811 invoked by alias); 5 Jun 2018 09:02:25 -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 118391 invoked by uid 89); 5 Jun 2018 09:00:00 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.5 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.2 spammy=9856, UD:gimple-fold.h, bit_and_expr, gimplefoldh X-HELO: mail-lf0-f49.google.com Received: from mail-lf0-f49.google.com (HELO mail-lf0-f49.google.com) (209.85.215.49) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 05 Jun 2018 08:59:50 +0000 Received: by mail-lf0-f49.google.com with SMTP id q11-v6so2316178lfc.7 for ; Tue, 05 Jun 2018 01:59:50 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:in-reply-to:references:from:date :message-id:subject:to:cc; bh=oesG13ah69YrW+qhiWMMIH50lWT+ikRxQnHgNWg6V1o=; b=YnTtCCr/mSOR7NTB30DLu0KzBO98FcTucpCIg7ScRJlQhFqh6oMcQo+w1yR+NSuLSs lfVwKO0Z9WEDJU1Ie3FgwFHMN1X/Vhe8Pu9H4l1hkKtq83ZTAqoUrvjnb5/Ip4Jp1rMU o1XdB74EKK80M/enaRZjXkhatPh/b1t6wXLaO1VXfznf2E4jvawKUVluqk82O2dCwRwl zsZLsn5afO6dMBBUWW8Jqiio+TMQ1rv1JvHrTt7XW93j3T5OfIaUiog0+2LhKUuxvnMA jFQZrEhaWophtf2PBJAh7MV/qFfcrIpRWmRYj4ZSVtQRaUMSKaGTajGOABgVh+jqCm8o Kp+g== X-Gm-Message-State: APt69E3owv2A6zYgHBxLjAAGMc7HwgN7lPwpgjUjO1Bcz5hoQOiag+Mv Fa4p7XcbpX9pH2t86HZpCjZpwax+04CvR3b7Kdnnq7Ki X-Google-Smtp-Source: ADUXVKLt5bB6n2MkIudDgFxZd123JAo60ecCrn9Huzy//xjGiugh8AnAONpL5ydUgFbb+OqYF1DvdMevtDi4MvPnYBc= X-Received: by 2002:a19:b54d:: with SMTP id e74-v6mr973919lff.118.1528189188138; Tue, 05 Jun 2018 01:59:48 -0700 (PDT) MIME-Version: 1.0 Received: by 2002:a2e:81d6:0:0:0:0:0 with HTTP; Tue, 5 Jun 2018 01:59:07 -0700 (PDT) In-Reply-To: References: From: Kugan Vivekanandarajah Date: Tue, 05 Jun 2018 09:02:00 -0000 Message-ID: Subject: Re: [RFC][PR82479] missing popcount builtin detection To: Richard Biener Cc: "Amker.Cheng" , GCC Patches Content-Type: multipart/mixed; boundary="000000000000b5dd3c056de145ac" X-IsSubscribed: yes X-SW-Source: 2018-06/txt/msg00203.txt.bz2 --000000000000b5dd3c056de145ac Content-Type: text/plain; charset="UTF-8" Content-length: 9213 Hi Richard, Thanks for the review. On 1 June 2018 at 23:12, Richard Biener wrote: > On Fri, Jun 1, 2018 at 12:06 PM Bin.Cheng wrote: >> >> On Fri, Jun 1, 2018 at 9:56 AM, Kugan Vivekanandarajah >> wrote: >> > Hi Bin, >> > >> > Thanks a lo for the review. >> > >> > On 1 June 2018 at 03:45, Bin.Cheng wrote: >> >> On Thu, May 31, 2018 at 3:51 AM, Kugan Vivekanandarajah >> >> wrote: >> >>> Hi Bin, >> >>> >> >>> Thanks for the review. Please find the revised patch based on the >> >>> review comments. >> >>> >> >>> Thanks, >> >>> Kugan >> >>> >> >>> On 17 May 2018 at 19:56, Bin.Cheng wrote: >> >>>> On Thu, May 17, 2018 at 2:39 AM, Kugan Vivekanandarajah >> >>>> wrote: >> >>>>> Hi Richard, >> >>>>> >> >>>>> On 6 March 2018 at 02:24, Richard Biener wrote: >> >>>>>> On Thu, Feb 8, 2018 at 1:41 AM, Kugan Vivekanandarajah >> >>>>>> wrote: >> >>>>>>> Hi Richard, >> >>>>>>> >> >> >> >> Hi, >> >> Thanks very much for working. >> >> >> >>> +/* Utility function to check if OP is defined by a stmt >> >>> + that is a val - 1. If that is the case, set it to STMT. */ >> >>> + >> >>> +static bool >> >>> +ssa_defined_by_and_minus_one_stmt_p (tree op, tree val, gimple **stmt) >> >> This is checking if op is defined as val - 1, so name it as >> >> ssa_defined_by_minus_one_stmt_p? >> >> >> >>> +{ >> >>> + if (TREE_CODE (op) == SSA_NAME >> >>> + && (*stmt = SSA_NAME_DEF_STMT (op)) >> >>> + && is_gimple_assign (*stmt) >> >>> + && (gimple_assign_rhs_code (*stmt) == PLUS_EXPR) >> >>> + && val == gimple_assign_rhs1 (*stmt) >> >>> + && integer_minus_onep (gimple_assign_rhs2 (*stmt))) >> >>> + return true; >> >>> + else >> >>> + return false; >> >> You can simply return the boolean condition. >> > Done. >> > >> >> >> >>> +} >> >>> + >> >>> +/* See if LOOP is a popcout implementation of the form >> >> ... >> >>> + rhs1 = gimple_assign_rhs1 (and_stmt); >> >>> + rhs2 = gimple_assign_rhs2 (and_stmt); >> >>> + >> >>> + if (ssa_defined_by_and_minus_one_stmt_p (rhs1, rhs2, &and_minus_one)) >> >>> + rhs1 = rhs2; >> >>> + else if (ssa_defined_by_and_minus_one_stmt_p (rhs2, rhs1, &and_minus_one)) >> >>> + ; >> >>> + else >> >>> + return false; >> >>> + >> >>> + /* Check the recurrence. */ >> >>> + phi = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (and_minus_one)); >> >> So gimple_assign_rhs1 (and_minus_one) == rhs1 is always true? Please >> >> use rhs1 directly. >> > >> > Done. >> >>> + gimple *src_phi = SSA_NAME_DEF_STMT (rhs2); >> >> I think this is checking wrong thing and is redundant. Either rhs2 >> >> equals to rhs1 or is defined as (rhs1 - 1). For (rhs2 == rhs1) case, >> >> the check duplicates checking on phi; for the latter, it's never a PHI >> >> stmt and shouldn't be checked. >> >> >> >>> + if (gimple_code (phi) != GIMPLE_PHI >> >>> + || gimple_code (src_phi) != GIMPLE_PHI) >> >>> + return false; >> >>> + >> >>> + dest = gimple_assign_lhs (count_stmt); >> >>> + tree fn = builtin_decl_implicit (BUILT_IN_POPCOUNT); >> >>> + tree src = gimple_phi_arg_def (src_phi, loop_preheader_edge (loop)->dest_idx); >> >>> + if (adjust) >> >>> + iter = fold_build2 (MINUS_EXPR, TREE_TYPE (dest), >> >>> + build_call_expr (fn, 1, src), >> >>> + build_int_cst (TREE_TYPE (dest), 1)); >> >>> + else >> >>> + iter = build_call_expr (fn, 1, src); >> >> Note tree-ssa-loop-niters.c always use unsigned_type_for (IV-type) as >> >> niters type. Though unsigned type is unnecessary in this case, but >> >> better to follow existing behavior? >> > >> > Done. >> >> >> >>> + max = int_cst_value (TYPE_MAX_VALUE (TREE_TYPE (dest))); >> >> As richi suggested, max should be the number of bits in type of IV. >> >> >> >>> + >> >>> + niter->assumptions = boolean_false_node; >> >> Redundant. >> > >> > Not sure I understand. If I remove this, I am getting ICE >> > (segmentation fault). What is the expectation here? >> Is it a simple typo? Because assumptions is set to boolean_true_node >> just 5 lines below? >> The niters part looks good for me with this change. You may need >> richi's approval for other parts? > > diff --git a/gcc/ipa-fnsummary.c b/gcc/ipa-fnsummary.c > index bdf9ba1..4dc156a 100644 > --- a/gcc/ipa-fnsummary.c > +++ b/gcc/ipa-fnsummary.c > @@ -1485,6 +1485,10 @@ will_be_nonconstant_expr_predicate (struct > ipa_node_params *info, > nonconstant_names); > return p2.or_with (summary->conds, p1); > } > + else if (TREE_CODE (expr) == CALL_EXPR) > + { > + return false; > + } > else > { > debug_tree (expr); > > I'd return true here instead - we don't want to track popcount() in > predicates. Also unnecessary braces. > > @@ -3492,6 +3494,11 @@ expression_expensive_p (tree expr) > if (!integer_pow2p (TREE_OPERAND (expr, 1))) > return true; > } > + if (code == CALL_EXPR > + && (fndecl = get_callee_fndecl (expr)) > + && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL > + && (BUILT_IN_POPCOUNT == DECL_FUNCTION_CODE (fndecl))) > + return false; > > please use > > if (code == CALL_EXPR) > { > if (!is_inexpensive_builtin (get_callee_fndecl (expr))) > return true; > FOR_EACH_CALL_EXPR_ARG (arg, iter, expr) > if (expression_expensive_p (arg)) > return true; > return false; > } > > instead. Done. > > + /* Check "b = b & (b - 1)" is calculated. */ > + if (!is_gimple_assign (and_stmt) > + || gimple_assign_rhs_code (and_stmt) != BIT_AND_EXPR) > + return false; > + > + rhs1 = gimple_assign_rhs1 (and_stmt); > + rhs2 = gimple_assign_rhs2 (and_stmt); > + > + if (ssa_defined_by_minus_one_stmt_p (rhs1, rhs2, &and_minus_one)) > + std::swap (rhs1, rhs2); > + else if (ssa_defined_by_minus_one_stmt_p (rhs2, rhs1, &and_minus_one)) > + ; > + else > + return false; > > so the powers of match-and-simplify let you add sth like the following to > match.pd: > > #if GIMPLE > (match (b_bit_and_b_minus_one @0) > (bit_and:c @0 (plus @0 integer_minus_onep))) > #endif > > and then use it like > > extern bool gimple_b_bit_and_b_minus_one (tree, tree *, tree (*)(tree)); > if (!gimple_b_bit_and_b_minus_one (gimple_assign_lhs (and_stmt), > &rhs1, NULL)) > return false; > > note you need to explicitely declare the matcher as there's no header > file generated > for them. It would be also the first user for this "feature" and at > some point I > considered using in-line source markup (and sth like GTY_FILES for > what files to scan) > to gather patterns. > > + /* Check the loop closed SSA definition for just the variable c defined in > + loop. */ > + basic_block bb = exit->dest; > + for (gphi_iterator gpi = gsi_start_phis (bb); > + !gsi_end_p (gpi); gsi_next (&gpi)) > + { > + phi = gpi.phi (); > + count++; > + } > > I don't understand why you are checking for this - isn't the number of > iterations I am trying to be overly conservative. I have removed it now and adjusted. > independent on the rest of the loop-closed PHIs? That is, even for just > > while (b) { b = b & (b-1); } > > the number of iterations is popcount (b). So it's enough to check > the exit condition? In fact you are coming from number_of_iterations_exit > and thus are asked for a specific exit and thus > > + if (!(exit = single_exit (loop))) > + return false; Ok, changed it. > is premature. That is, for > > while (b) { b = b & (b - 1); if (--c == 0) break; } > > still should have popcount (b) iterations for the exit involving the > while (b) test. > > So please simplify (and thus genericize) the code accordingly. Do so > without the match.pd trick for now, I think we can simplify the current > beast down enough to not need the factored out function. I am not using match.pd changes as you have asked. Please let me know if you want that to be included as well. > > You then also can handle replacing > > int c = 0; > while (b) { b = b & (b-1); c+=3; } > > with 3 * popcount (b); Made to handle this too. But, there are still cases we don't handle. I am not sure if it is worth the complexity handling all the possible cases. Is the attached patch looks better now? Thanks, Kugan > > Richard. > >> Thanks, >> bin >> > >> >>> + niter->control.base = NULL_TREE; >> >>> + niter->control.step = NULL_TREE; >> >>> + niter->control.no_overflow = false; >> >>> + niter->niter = iter; >> >>> + niter->assumptions = boolean_true_node; >> >>> + niter->may_be_zero = boolean_false_node; >> >>> + niter->max = max; >> >>> + niter->bound = NULL_TREE; >> >>> + niter->cmp = ERROR_MARK; >> >>> + return true; >> >>> +} >> >>> + >> >>> + >> >> Appology if these are nitpickings. >> > Thanks for the review. I am happy to make the changes needed to get it >> > to how it should be :) >> > >> > Thanks, >> > Kugan >> > >> >> >> >> Thanks, >> >> bin --000000000000b5dd3c056de145ac Content-Type: text/x-patch; charset="US-ASCII"; name="0001-popcount.patch" Content-Disposition: attachment; filename="0001-popcount.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_ji1gavlw0 Content-length: 14051 RnJvbSBhMjEwMjA4MzFmNDQ5MTVjNjllN2E0OTY5MmJhMWU5OGI3YmUzNzYw IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBLdWdhbiBWaXZla2Fu YW5kYXJhamFoIDxrdWdhbi52aXZla2FuYW5kYXJhamFoQGxpbmFyby5vcmc+ CkRhdGU6IFRodSwgMTAgTWF5IDIwMTggMjE6NDE6NTMgKzEwMDAKU3ViamVj dDogW1BBVENIXSBwb3Bjb3VudAoKQ2hhbmdlLUlkOiBJMzgzMTc4ZTAxMDUx YzI5Mjk2NDdhZjQ3NGM3ZTc3YTU3ODEzNzNmMAotLS0KIGdjYy9pcGEtZm5z dW1tYXJ5LmMgICAgICAgICAgICAgICAgICAgICAgIHwgICAyICsKIGdjYy90 ZXN0c3VpdGUvZ2NjLmRnL3RyZWUtc3NhL3BvcGNvdW50LmMgIHwgIDQxICsr KysrKysrKwogZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdHJlZS1zc2EvcG9wY291 bnQyLmMgfCAgMjkgKysrKysrCiBnY2MvdGVzdHN1aXRlL2djYy5kZy90cmVl LXNzYS9wb3Bjb3VudDMuYyB8ICAyOCArKysrKysKIGdjYy90cmVlLXNjYWxh ci1ldm9sdXRpb24uYyAgICAgICAgICAgICAgIHwgIDE1ICsrKysKIGdjYy90 cmVlLXNzYS1sb29wLWl2b3B0cy5jICAgICAgICAgICAgICAgIHwgIDEwICsr KwogZ2NjL3RyZWUtc3NhLWxvb3Atbml0ZXIuYyAgICAgICAgICAgICAgICAg fCAxNDMgKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCiA3IGZpbGVz IGNoYW5nZWQsIDI2NyBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCiBj cmVhdGUgbW9kZSAxMDA2NDQgZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdHJlZS1z c2EvcG9wY291bnQuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGdjYy90ZXN0c3Vp dGUvZ2NjLmRnL3RyZWUtc3NhL3BvcGNvdW50Mi5jCiBjcmVhdGUgbW9kZSAx MDA2NDQgZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdHJlZS1zc2EvcG9wY291bnQz LmMKCmRpZmYgLS1naXQgYS9nY2MvaXBhLWZuc3VtbWFyeS5jIGIvZ2NjL2lw YS1mbnN1bW1hcnkuYwppbmRleCBiZGY5YmExLi5mZWIxYzllIDEwMDY0NAot LS0gYS9nY2MvaXBhLWZuc3VtbWFyeS5jCisrKyBiL2djYy9pcGEtZm5zdW1t YXJ5LmMKQEAgLTE0ODUsNiArMTQ4NSw4IEBAIHdpbGxfYmVfbm9uY29uc3Rh bnRfZXhwcl9wcmVkaWNhdGUgKHN0cnVjdCBpcGFfbm9kZV9wYXJhbXMgKmlu Zm8sCiAJCQkJCSAgICAgICBub25jb25zdGFudF9uYW1lcyk7CiAgICAgICBy ZXR1cm4gcDIub3Jfd2l0aCAoc3VtbWFyeS0+Y29uZHMsIHAxKTsKICAgICB9 CisgIGVsc2UgaWYgKFRSRUVfQ09ERSAoZXhwcikgPT0gQ0FMTF9FWFBSKQor ICAgIHJldHVybiB0cnVlOwogICBlbHNlCiAgICAgewogICAgICAgZGVidWdf dHJlZSAoZXhwcik7CmRpZmYgLS1naXQgYS9nY2MvdGVzdHN1aXRlL2djYy5k Zy90cmVlLXNzYS9wb3Bjb3VudC5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcv dHJlZS1zc2EvcG9wY291bnQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi44NmE2NmNiCi0tLSAvZGV2L251bGwKKysrIGIvZ2NjL3Rl c3RzdWl0ZS9nY2MuZGcvdHJlZS1zc2EvcG9wY291bnQuYwpAQCAtMCwwICsx LDQxIEBACisvKiB7IGRnLWRvIGNvbXBpbGUgfSAqLworLyogeyBkZy1vcHRp b25zICItTzMgLWZkdW1wLXRyZWUtb3B0aW1pemVkIiB9ICovCisKK2V4dGVy biBpbnQgZm9vIChpbnQpOworCitpbnQgUG9wQ291bnQgKGxvbmcgYikgewor ICAgIGludCBjID0gMDsKKyAgICBiKys7CisKKyAgICB3aGlsZSAoYikgewor CWIgJj0gYiAtIDE7CisJYysrOworICAgIH0KKyAgICByZXR1cm4gYzsKK30K K2ludCBQb3BDb3VudDIgKGxvbmcgYikgeworICAgIGludCBjID0gMDsKKwor ICAgIHdoaWxlIChiKSB7CisJYiAmPSBiIC0gMTsKKwljKys7CisgICAgfQor ICAgIGZvbyAoYyk7CisgICAgcmV0dXJuIGZvbyAoYyk7Cit9CisKK3ZvaWQg UG9wQ291bnQzIChsb25nIGIxKSB7CisKKyAgICBmb3IgKGxvbmcgaSA9IDA7 IGkgPCBiMTsgKytpKQorICAgICAgeworCWxvbmcgYiA9IGk7CisJaW50IGMg PSAwOworCXdoaWxlIChiKSB7CisJICAgIGIgJj0gYiAtIDE7CisJICAgIGMr KzsKKwl9CisJZm9vIChjKTsKKyAgICAgIH0KK30KKworLyogeyBkZy1maW5h bCB7IHNjYW4tdHJlZS1kdW1wLXRpbWVzICJfX2J1aWx0aW5fcG9wY291bnQi IDMgIm9wdGltaXplZCIgfSB9ICovCmRpZmYgLS1naXQgYS9nY2MvdGVzdHN1 aXRlL2djYy5kZy90cmVlLXNzYS9wb3Bjb3VudDIuYyBiL2djYy90ZXN0c3Vp dGUvZ2NjLmRnL3RyZWUtc3NhL3BvcGNvdW50Mi5jCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLjUyYWZjMmQKLS0tIC9kZXYvbnVsbAor KysgYi9nY2MvdGVzdHN1aXRlL2djYy5kZy90cmVlLXNzYS9wb3Bjb3VudDIu YwpAQCAtMCwwICsxLDI5IEBACisvKiB7IGRnLWRvIGV4ZWN1dGUgfSAqLwor LyogeyBkZy1vcHRpb25zICItTzIgLWZkdW1wLXRyZWUtb3B0aW1pemVkIiB9 ICovCisKK2ludAorX19hdHRyaWJ1dGVfXyAoKG5vaW5saW5lLCBub2Nsb25l KSkKK2ZvbyAoaW50IGksIGxvbmcgYikKK3sKKyAgICBpbnQgYyA9IGk7CisK KyAgICB3aGlsZSAoYikgeworCWIgJj0gYiAtIDE7CisJYysrOworICAgIH0K KyAgICByZXR1cm4gYzsKK30KKworaW50IG1haW4oKQoreworCisgIGlmIChm b28gKDEsIDcpICE9IDQpCisgICBfX2J1aWx0aW5fYWJvcnQgKCk7CisgIGlm IChmb28gKDAsIDApICE9IDApCisgICBfX2J1aWx0aW5fYWJvcnQgKCk7Cisg IGlmIChmb28gKDgsIDB4ZmYpICE9IDE2KQorICAgX19idWlsdGluX2Fib3J0 ICgpOworICByZXR1cm4gMDsKK30KKworLyogeyBkZy1maW5hbCB7IHNjYW4t dHJlZS1kdW1wLXRpbWVzICJfX2J1aWx0aW5fcG9wY291bnQiIDEgIm9wdGlt aXplZCIgfSB9ICovCmRpZmYgLS1naXQgYS9nY2MvdGVzdHN1aXRlL2djYy5k Zy90cmVlLXNzYS9wb3Bjb3VudDMuYyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRn L3RyZWUtc3NhL3BvcGNvdW50My5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLjBjNjlkOTcKLS0tIC9kZXYvbnVsbAorKysgYi9nY2Mv dGVzdHN1aXRlL2djYy5kZy90cmVlLXNzYS9wb3Bjb3VudDMuYwpAQCAtMCww ICsxLDI4IEBACisvKiB7IGRnLWRvIGV4ZWN1dGUgfSAqLworLyogeyBkZy1v cHRpb25zICItTzIgLWZuby10cmVlLWNoIC1mZHVtcC10cmVlLW9wdGltaXpl ZCIgfSAqLworCitpbnQKK19fYXR0cmlidXRlX18gKChub2lubGluZSwgbm9j bG9uZSkpCitmb28gKGxvbmcgYikKK3sKKyAgICBpbnQgYyA9IGk7CisKKyAg ICB3aGlsZSAoYikgeworCWIgJj0gYiAtIDE7CisJYysrOworICAgIH0KKyAg ICByZXR1cm4gYzsKK30KKworaW50IG1haW4oKQoreworICBpZiAoZm9vICg3 KSAhPSAzKQorICAgX19idWlsdGluX2Fib3J0ICgpOworICBpZiAoZm9vICgw KSAhPSAwKQorICAgX19idWlsdGluX2Fib3J0ICgpOworICBpZiAoZm9vICgw eGZmKSAhPSA4KQorICAgX19idWlsdGluX2Fib3J0ICgpOworICByZXR1cm4g MDsKK30KKworLyogeyBkZy1maW5hbCB7IHNjYW4tdHJlZS1kdW1wLXRpbWVz ICJfX2J1aWx0aW5fcG9wY291bnQiIDEgIm9wdGltaXplZCIgfSB9ICovCmRp ZmYgLS1naXQgYS9nY2MvdHJlZS1zY2FsYXItZXZvbHV0aW9uLmMgYi9nY2Mv dHJlZS1zY2FsYXItZXZvbHV0aW9uLmMKaW5kZXggZmVmYzlkZS4uNGIwZWMw MiAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtc2NhbGFyLWV2b2x1dGlvbi5jCisr KyBiL2djYy90cmVlLXNjYWxhci1ldm9sdXRpb24uYwpAQCAtMjgxLDYgKzI4 MSw3IEBAIGFsb25nIHdpdGggR0NDOyBzZWUgdGhlIGZpbGUgQ09QWUlORzMu ICBJZiBub3Qgc2VlCiAjaW5jbHVkZSAidHJlZS1zc2EtcHJvcGFnYXRlLmgi CiAjaW5jbHVkZSAiZ2ltcGxlLWZvbGQuaCIKICNpbmNsdWRlICJ0cmVlLWlu dG8tc3NhLmgiCisjaW5jbHVkZSAiYnVpbHRpbnMuaCIKIAogc3RhdGljIHRy ZWUgYW5hbHl6ZV9zY2FsYXJfZXZvbHV0aW9uXzEgKHN0cnVjdCBsb29wICos IHRyZWUpOwogc3RhdGljIHRyZWUgYW5hbHl6ZV9zY2FsYXJfZXZvbHV0aW9u X2Zvcl9hZGRyZXNzX29mIChzdHJ1Y3QgbG9vcCAqbG9vcCwKQEAgLTE5ODQs NiArMTk4NSw3IEBAIGludGVycHJldF9leHByIChzdHJ1Y3QgbG9vcCAqbG9v cCwgZ2ltcGxlICphdF9zdG10LCB0cmVlIGV4cHIpCiAgICAgcmV0dXJuIGV4 cHI7CiAKICAgaWYgKFRSRUVfQ09ERSAoZXhwcikgPT0gUE9MWU5PTUlBTF9D SFJFQworICAgICAgfHwgVFJFRV9DT0RFIChleHByKSA9PSBDQUxMX0VYUFIK ICAgICAgIHx8IGdldF9naW1wbGVfcmhzX2NsYXNzIChUUkVFX0NPREUgKGV4 cHIpKSA9PSBHSU1QTEVfVEVSTkFSWV9SSFMpCiAgICAgcmV0dXJuIGNocmVj X2RvbnRfa25vdzsKIApAQCAtMzQ5Myw2ICszNDk1LDE5IEBAIGV4cHJlc3Np b25fZXhwZW5zaXZlX3AgKHRyZWUgZXhwcikKIAlyZXR1cm4gdHJ1ZTsKICAg ICB9CiAKKyAgaWYgKGNvZGUgPT0gQ0FMTF9FWFBSKQorICAgIHsKKyAgICAg IHRyZWUgYXJnOworICAgICAgY2FsbF9leHByX2FyZ19pdGVyYXRvciBpdGVy OworCisgICAgICBpZiAoIWlzX2luZXhwZW5zaXZlX2J1aWx0aW4gKGdldF9j YWxsZWVfZm5kZWNsIChleHByKSkpCisJcmV0dXJuIHRydWU7CisgICAgICBG T1JfRUFDSF9DQUxMX0VYUFJfQVJHIChhcmcsIGl0ZXIsIGV4cHIpCisJaWYg KGV4cHJlc3Npb25fZXhwZW5zaXZlX3AgKGFyZykpCisJICByZXR1cm4gdHJ1 ZTsKKyAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisKICAgc3dpdGNoIChU UkVFX0NPREVfQ0xBU1MgKGNvZGUpKQogICAgIHsKICAgICBjYXNlIHRjY19i aW5hcnk6CmRpZmYgLS1naXQgYS9nY2MvdHJlZS1zc2EtbG9vcC1pdm9wdHMu YyBiL2djYy90cmVlLXNzYS1sb29wLWl2b3B0cy5jCmluZGV4IGIzMTM1NzEu LjUxOTY0OWEgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXNzYS1sb29wLWl2b3B0 cy5jCisrKyBiL2djYy90cmVlLXNzYS1sb29wLWl2b3B0cy5jCkBAIC05ODUs NiArOTg1LDE2IEBAIGNvbnRhaW5zX2Fibm9ybWFsX3NzYV9uYW1lX3AgKHRy ZWUgZXhwcikKICAgY29kZSA9IFRSRUVfQ09ERSAoZXhwcik7CiAgIGNvZGVj bGFzcyA9IFRSRUVfQ09ERV9DTEFTUyAoY29kZSk7CiAKKyAgaWYgKGNvZGUg PT0gQ0FMTF9FWFBSKQorICAgIHsKKyAgICAgIHRyZWUgYXJnOworICAgICAg Y2FsbF9leHByX2FyZ19pdGVyYXRvciBpdGVyOworICAgICAgRk9SX0VBQ0hf Q0FMTF9FWFBSX0FSRyAoYXJnLCBpdGVyLCBleHByKQorCWlmIChjb250YWlu c19hYm5vcm1hbF9zc2FfbmFtZV9wIChhcmcpKQorCSAgcmV0dXJuIHRydWU7 CisgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCiAgIGlmIChjb2RlID09 IFNTQV9OQU1FKQogICAgIHJldHVybiBTU0FfTkFNRV9PQ0NVUlNfSU5fQUJO T1JNQUxfUEhJIChleHByKSAhPSAwOwogCmRpZmYgLS1naXQgYS9nY2MvdHJl ZS1zc2EtbG9vcC1uaXRlci5jIGIvZ2NjL3RyZWUtc3NhLWxvb3Atbml0ZXIu YwppbmRleCA3YTU0YzVmLi4zNGM3ZDE1IDEwMDY0NAotLS0gYS9nY2MvdHJl ZS1zc2EtbG9vcC1uaXRlci5jCisrKyBiL2djYy90cmVlLXNzYS1sb29wLW5p dGVyLmMKQEAgLTI0MzAsNiArMjQzMCwxNDMgQEAgbnVtYmVyX29mX2l0ZXJh dGlvbnNfZXhpdF9hc3N1bXB0aW9ucyAoc3RydWN0IGxvb3AgKmxvb3AsIGVk Z2UgZXhpdCwKICAgcmV0dXJuICghaW50ZWdlcl96ZXJvcCAobml0ZXItPmFz c3VtcHRpb25zKSk7CiB9CiAKKworLyogVXRpbGl0eSBmdW5jdGlvbiB0byBj aGVjayBpZiBPUCBpcyBkZWZpbmVkIGJ5IGEgc3RtdAorICAgdGhhdCBpcyBh IHZhbCAtIDEuICAqLworCitzdGF0aWMgYm9vbAorc3NhX2RlZmluZWRfYnlf bWludXNfb25lX3N0bXRfcCAodHJlZSBvcCwgdHJlZSB2YWwpCit7CisgIGdp bXBsZSAqc3RtdDsKKyAgcmV0dXJuIChUUkVFX0NPREUgKG9wKSA9PSBTU0Ff TkFNRQorCSAgJiYgKHN0bXQgPSBTU0FfTkFNRV9ERUZfU1RNVCAob3ApKQor CSAgJiYgaXNfZ2ltcGxlX2Fzc2lnbiAoc3RtdCkKKwkgICYmIChnaW1wbGVf YXNzaWduX3Joc19jb2RlIChzdG10KSA9PSBQTFVTX0VYUFIpCisJICAmJiB2 YWwgPT0gZ2ltcGxlX2Fzc2lnbl9yaHMxIChzdG10KQorCSAgJiYgaW50ZWdl cl9taW51c19vbmVwIChnaW1wbGVfYXNzaWduX3JoczIgKHN0bXQpKSk7Cit9 CisKKworLyogU2VlIGlmIExPT1AgaXMgYSBwb3Bjb3V0IGltcGxlbWVudGF0 aW9uIG9mIHRoZSBmb3JtCisKKyAgICBpbnQgYyA9IDA7CisgICAgd2hpbGUg KGIpIHsKKwliID0gYiAmIChiIC0gMSk7CisJYysrOworICAgIH0KKworICAg IElmIHBvcGNvdW50IHBhdHRlcm4sIHVwZGF0ZSBOSVRFUiBhY2NvcmRpbmds eS4KKyAgICBpLmUuLCBzZXQgTklURVIgdG8gIF9fYnVpbHRpbl9wb3Bjb3Vu dCAoYikKKyAgICByZXR1cm4gdHJ1ZSBpZiB3ZSBkaWQsIGZhbHNlIG90aGVy d2lzZS4KKworICovCisKK3N0YXRpYyBib29sCitudW1iZXJfb2ZfaXRlcmF0 aW9uc19wb3Bjb3VudCAobG9vcF9wIGxvb3AsIGVkZ2UgZXhpdCwKKwkJCSAg ICAgICBzdHJ1Y3QgdHJlZV9uaXRlcl9kZXNjICpuaXRlcikKK3sKKyAgdHJl ZSByaHMxLCByaHMyOworICB0cmVlIGRlc3Q7CisgIGJvb2wgYWRqdXN0ID0g dHJ1ZTsKKyAgdHJlZSBpdGVyOworICBIT1NUX1dJREVfSU5UIG1heDsKKyAg dHJlZSB0aW1lczsKKyAgYWRqdXN0ID0gdHJ1ZTsKKworICAvKiBDaGVjayBs b29wIHRlcm1pbmF0aW5nIGJyYW5jaCBpcyBsaWtlCisgICAgIGlmIChiICE9 IDApLiAgKi8KKyAgZ2ltcGxlICpzdG10ID0gbGFzdF9zdG10IChsb29wLT5o ZWFkZXIpOworICBpZiAoIXN0bXQKKyAgICAgIHx8IGdpbXBsZV9jb2RlIChz dG10KSAhPSBHSU1QTEVfQ09ORAorICAgICAgfHwgZ2ltcGxlX2NvbmRfY29k ZSAoc3RtdCkgIT0gTkVfRVhQUgorICAgICAgfHwgIXplcm9wIChnaW1wbGVf Y29uZF9yaHMgKHN0bXQpKQorICAgICAgfHwgVFJFRV9DT0RFIChnaW1wbGVf Y29uZF9saHMgKHN0bXQpKSAhPSBTU0FfTkFNRSkKKyAgICByZXR1cm4gZmFs c2U7CisKKyAgZ3BoaV9pdGVyYXRvciBncGkgPSBnc2lfc3RhcnRfcGhpcyAo ZXhpdC0+ZGVzdCk7CisgIGlmIChnc2lfZW5kX3AgKGdwaSkpCisgICAgcmV0 dXJuIGZhbHNlOworICByaHMxID0gZ2ltcGxlX3BoaV9hcmdfZGVmIChncGku cGhpICgpLCBleGl0LT5kZXN0X2lkeCk7CisgIGlmIChUUkVFX0NPREUgKHJo czEpICE9IFNTQV9OQU1FKQorICAgIHJldHVybiBmYWxzZTsKKworICBnaW1w bGUgKmNvdW50X3N0bXQgPSBTU0FfTkFNRV9ERUZfU1RNVCAocmhzMSk7Cisg IGdpbXBsZSAqYW5kX3N0bXQgPSBTU0FfTkFNRV9ERUZfU1RNVCAoZ2ltcGxl X2NvbmRfbGhzIChzdG10KSk7CisKKyAgLyogRGVwZW5kaW5nIG9uIGNvcHkt aGVhZGVyIGlzIHBlcmZvcm1lZCwgZmVlZGluZyBQSEkgc3RtdHMgbWlnaHQg YmUgaW4KKyAgICAgdGhlIGxvb3AgaGVhZGVyIG9yIGxvb3AgZXhpdCwgaGFu ZGxlIHRoaXMuICAqLworICBpZiAoZ2ltcGxlX2NvZGUgKGNvdW50X3N0bXQp ID09IEdJTVBMRV9QSEkKKyAgICAgICYmIGdpbXBsZV9jb2RlIChhbmRfc3Rt dCkgPT0gR0lNUExFX1BISQorICAgICAgJiYgZ2ltcGxlX2JiIChhbmRfc3Rt dCkgPT0gZXhpdC0+c3JjCisgICAgICAmJiBnaW1wbGVfYmIgKGNvdW50X3N0 bXQpID09IGV4aXQtPnNyYworICAgICAgJiYgKFRSRUVfQ09ERSAoZ2ltcGxl X3BoaV9hcmdfZGVmIChjb3VudF9zdG10LAorCQkJCQkgbG9vcF9sYXRjaF9l ZGdlIChsb29wKS0+ZGVzdF9pZHgpKQorCSAgPT0gU1NBX05BTUUpCisgICAg ICAmJiAoVFJFRV9DT0RFIChnaW1wbGVfcGhpX2FyZ19kZWYgKGFuZF9zdG10 LAorCQkJCQkgbG9vcF9sYXRjaF9lZGdlIChsb29wKS0+ZGVzdF9pZHgpKQor CSAgPT0gU1NBX05BTUUpKQorICAgIHsKKyAgICAgIHRyZWUgdDsKKyAgICAg IHQgPSBnaW1wbGVfcGhpX2FyZ19kZWYgKGNvdW50X3N0bXQsIGxvb3BfbGF0 Y2hfZWRnZSAobG9vcCktPmRlc3RfaWR4KTsKKyAgICAgIGNvdW50X3N0bXQg PSBTU0FfTkFNRV9ERUZfU1RNVCAodCk7CisgICAgICB0ID0gZ2ltcGxlX3Bo aV9hcmdfZGVmIChhbmRfc3RtdCwgbG9vcF9sYXRjaF9lZGdlIChsb29wKS0+ ZGVzdF9pZHgpOworICAgICAgYW5kX3N0bXQgPSBTU0FfTkFNRV9ERUZfU1RN VCAodCk7CisgICAgICBhZGp1c3QgPSBmYWxzZTsKKyAgICB9CisKKyAgLyog TWFrZSBzdXJlIHdlIGhhdmUgYSBjb3VudCBieSBvbmUuICAqLworICBpZiAo IWlzX2dpbXBsZV9hc3NpZ24gKGNvdW50X3N0bXQpCisgICAgICB8fCAoZ2lt cGxlX2Fzc2lnbl9yaHNfY29kZSAoY291bnRfc3RtdCkgIT0gUExVU19FWFBS KQorICAgICAgfHwgVFJFRV9DT0RFIChnaW1wbGVfYXNzaWduX3JoczIgKGNv dW50X3N0bXQpKSAhPSBJTlRFR0VSX0NTVCkKKyAgICByZXR1cm4gZmFsc2U7 CisgIHRpbWVzID0gZ2ltcGxlX2Fzc2lnbl9yaHMyIChjb3VudF9zdG10KTsK KworICAvKiBDaGVjayAiYiA9IGIgJiAoYiAtIDEpIiBpcyBjYWxjdWxhdGVk LiAgKi8KKyAgaWYgKCFpc19naW1wbGVfYXNzaWduIChhbmRfc3RtdCkKKyAg ICAgIHx8IGdpbXBsZV9hc3NpZ25fcmhzX2NvZGUgKGFuZF9zdG10KSAhPSBC SVRfQU5EX0VYUFIpCisgICAgcmV0dXJuIGZhbHNlOworCisgIHJoczEgPSBn aW1wbGVfYXNzaWduX3JoczEgKGFuZF9zdG10KTsKKyAgcmhzMiA9IGdpbXBs ZV9hc3NpZ25fcmhzMiAoYW5kX3N0bXQpOworCisgIGlmIChzc2FfZGVmaW5l ZF9ieV9taW51c19vbmVfc3RtdF9wIChyaHMxLCByaHMyKSkKKyAgICBzdGQ6 OnN3YXAgKHJoczEsIHJoczIpOworICBlbHNlIGlmIChzc2FfZGVmaW5lZF9i eV9taW51c19vbmVfc3RtdF9wIChyaHMyLCByaHMxKSkKKyAgICA7CisgIGVs c2UKKyAgICByZXR1cm4gZmFsc2U7CisKKyAgLyogQ2hlY2sgdGhlIHJlY3Vy cmVuY2UuICAqLworICBnaW1wbGUgKnBoaSA9IFNTQV9OQU1FX0RFRl9TVE1U IChyaHMxKTsKKyAgaWYgKGdpbXBsZV9jb2RlIChwaGkpICE9IEdJTVBMRV9Q SEkpCisgICAgcmV0dXJuIGZhbHNlOworCisgIGRlc3QgPSBnaW1wbGVfYXNz aWduX2xocyAoY291bnRfc3RtdCk7CisgIHRyZWUgdXR5cGUgPSB1bnNpZ25l ZF90eXBlX2ZvciAoVFJFRV9UWVBFIChkZXN0KSk7CisgIHRyZWUgZm4gPSBi dWlsdGluX2RlY2xfaW1wbGljaXQgKEJVSUxUX0lOX1BPUENPVU5UKTsKKyAg dHJlZSBzcmMgPSBnaW1wbGVfcGhpX2FyZ19kZWYgKHBoaSwgbG9vcF9wcmVo ZWFkZXJfZWRnZSAobG9vcCktPmRlc3RfaWR4KTsKKyAgaWYgKGFkanVzdCkK KyAgICBpdGVyID0gZm9sZF9idWlsZDIgKE1JTlVTX0VYUFIsIHV0eXBlLAor CQkJYnVpbGRfY2FsbF9leHByIChmbiwgMSwgc3JjKSwKKwkJCWJ1aWxkX2lu dF9jc3QgKHV0eXBlLCAxKSk7CisgIGVsc2UKKyAgICBpdGVyID0gZm9sZF9j b252ZXJ0ICh1dHlwZSwgYnVpbGRfY2FsbF9leHByIChmbiwgMSwgc3JjKSk7 CisgIG1heCA9IGludF9jc3RfdmFsdWUgKFRZUEVfTUFYX1ZBTFVFIChUUkVF X1RZUEUgKGRlc3QpKSk7CisKKyAgbml0ZXItPmFzc3VtcHRpb25zID0gYm9v bGVhbl9mYWxzZV9ub2RlOworICBuaXRlci0+Y29udHJvbC5iYXNlID0gTlVM TF9UUkVFOworICBuaXRlci0+Y29udHJvbC5zdGVwID0gdGltZXM7CisgIG5p dGVyLT5jb250cm9sLm5vX292ZXJmbG93ID0gZmFsc2U7CisgIG5pdGVyLT5u aXRlciA9IGl0ZXI7CisgIG5pdGVyLT5hc3N1bXB0aW9ucyA9IGJvb2xlYW5f dHJ1ZV9ub2RlOworICBuaXRlci0+bWF5X2JlX3plcm8gPSBib29sZWFuX2Zh bHNlX25vZGU7CisgIG5pdGVyLT5tYXggPSBtYXg7CisgIG5pdGVyLT5ib3Vu ZCA9IE5VTExfVFJFRTsKKyAgbml0ZXItPmNtcCA9IEVSUk9SX01BUks7Cisg IHJldHVybiB0cnVlOworfQorCisKIC8qIExpa2UgbnVtYmVyX29mX2l0ZXJh dGlvbnNfZXhpdF9hc3N1bXB0aW9ucywgYnV0IHJldHVybiBUUlVFIG9ubHkg aWYKICAgIHRoZSBuaXRlciBpbmZvcm1hdGlvbiBob2xkcyB1bmNvbmRpdGlv bmFsbHkuICAqLwogCkBAIC0yNDQxLDcgKzI1NzgsMTEgQEAgbnVtYmVyX29m X2l0ZXJhdGlvbnNfZXhpdCAoc3RydWN0IGxvb3AgKmxvb3AsIGVkZ2UgZXhp dCwKICAgZ2NvbmQgKnN0bXQ7CiAgIGlmICghbnVtYmVyX29mX2l0ZXJhdGlv bnNfZXhpdF9hc3N1bXB0aW9ucyAobG9vcCwgZXhpdCwgbml0ZXIsCiAJCQkJ CSAgICAgICZzdG10LCBldmVyeV9pdGVyYXRpb24pKQotICAgIHJldHVybiBm YWxzZTsKKyAgICB7CisgICAgICBpZiAobnVtYmVyX29mX2l0ZXJhdGlvbnNf cG9wY291bnQgKGxvb3AsIGV4aXQsIG5pdGVyKSkKKwlyZXR1cm4gdHJ1ZTsK KyAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CiAKICAgaWYgKGludGVnZXJf bm9uemVyb3AgKG5pdGVyLT5hc3N1bXB0aW9ucykpCiAgICAgcmV0dXJuIHRy dWU7Ci0tIAoyLjcuNAoK --000000000000b5dd3c056de145ac--