From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 45870 invoked by alias); 25 May 2016 12:46:06 -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 45850 invoked by uid 89); 25 May 2016 12:46:05 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.9 required=5.0 tests=AWL,BAYES_00,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.2 spammy=transfer X-HELO: mail-it0-f49.google.com Received: from mail-it0-f49.google.com (HELO mail-it0-f49.google.com) (209.85.214.49) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Wed, 25 May 2016 12:45:55 +0000 Received: by mail-it0-f49.google.com with SMTP id l63so31090430ita.1 for ; Wed, 25 May 2016 05:45:54 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:in-reply-to:references:date :message-id:subject:from:to:cc; bh=i8085wmepn9sjwdPOflL9xBn3hThmkf1pP7AGgv20nY=; b=A8eSNok3fukrrS0oKCCfONtG1vGHrfFUIgvraKhWwEQK4dFxzKq8K6rEQ9bxdsUZYf KT/yjeR79QK2KqyD+wbXg5usurCIy3aENSFqNOiBZ7wGvLJz7YE4uT+A2t3tEB9v76BI pEuB5lRvMILrAuS9lYk3Ed8D6+yeci3zb6dzAf8YcjLTOU241IMmOFtpDsb8uKajrAoo lMibGkPB0o0QPlL3M6ZYnMzp05T8gOO5gOzV8tx2WnxfvcISDFIcrGdZ7hv1wjZaAnpH GW4OmqrX7/MdnZYeWqFYDBq9CoCtueOKdVVQZeJNiPi6YkYvNCxmcAJIor3yoeDOFmN7 KTQA== X-Gm-Message-State: ALyK8tIClK3UBayNgts7WvQ+s982Et5hqANYgenGsrIulgHqqPA2EwFNExrqu/CXkLFHacJf8yqW6ss8TMNfDzgZ MIME-Version: 1.0 X-Received: by 10.36.160.5 with SMTP id o5mr3817977ite.31.1464180352550; Wed, 25 May 2016 05:45:52 -0700 (PDT) Received: by 10.36.236.5 with HTTP; Wed, 25 May 2016 05:45:52 -0700 (PDT) In-Reply-To: References: Date: Wed, 25 May 2016 13:33:00 -0000 Message-ID: Subject: Re: RFC [1/2] divmod transform From: Prathamesh Kulkarni To: Richard Biener Cc: Richard Biener , gcc Patches , Ramana Radhakrishnan , Kugan Vivekanandarajah , Jim Wilson Content-Type: multipart/mixed; boundary=94eb2c03caaccd56ae0533aa0d5b X-IsSubscribed: yes X-SW-Source: 2016-05/txt/msg02017.txt.bz2 --94eb2c03caaccd56ae0533aa0d5b Content-Type: text/plain; charset=UTF-8 Content-length: 13728 On 25 May 2016 at 12:52, Richard Biener wrote: > On Tue, 24 May 2016, Prathamesh Kulkarni wrote: > >> On 24 May 2016 at 19:39, Richard Biener wrote: >> > On Tue, 24 May 2016, Prathamesh Kulkarni wrote: >> > >> >> On 24 May 2016 at 17:42, Richard Biener wrote: >> >> > On Tue, 24 May 2016, Prathamesh Kulkarni wrote: >> >> > >> >> >> On 23 May 2016 at 17:35, Richard Biener wrote: >> >> >> > On Mon, May 23, 2016 at 10:58 AM, Prathamesh Kulkarni >> >> >> > wrote: >> >> >> >> Hi, >> >> >> >> I have updated my patch for divmod (attached), which was originally >> >> >> >> based on Kugan's patch. >> >> >> >> The patch transforms stmts with code TRUNC_DIV_EXPR and TRUNC_MOD_EXPR >> >> >> >> having same operands to divmod representation, so we can cse computation of mod. >> >> >> >> >> >> >> >> t1 = a TRUNC_DIV_EXPR b; >> >> >> >> t2 = a TRUNC_MOD_EXPR b >> >> >> >> is transformed to: >> >> >> >> complex_tmp = DIVMOD (a, b); >> >> >> >> t1 = REALPART_EXPR (complex_tmp); >> >> >> >> t2 = IMAGPART_EXPR (complex_tmp); >> >> >> >> >> >> >> >> * New hook divmod_expand_libfunc >> >> >> >> The rationale for introducing the hook is that different targets have >> >> >> >> incompatible calling conventions for divmod libfunc. >> >> >> >> Currently three ports define divmod libfunc: c6x, spu and arm. >> >> >> >> c6x and spu follow the convention of libgcc2.c:__udivmoddi4: >> >> >> >> return quotient and store remainder in argument passed as pointer, >> >> >> >> while the arm version takes two arguments and returns both >> >> >> >> quotient and remainder having mode double the size of the operand mode. >> >> >> >> The port should hence override the hook expand_divmod_libfunc >> >> >> >> to generate call to target-specific divmod. >> >> >> >> Ports should define this hook if: >> >> >> >> a) The port does not have divmod or div insn for the given mode. >> >> >> >> b) The port defines divmod libfunc for the given mode. >> >> >> >> The default hook default_expand_divmod_libfunc() generates call >> >> >> >> to libgcc2.c:__udivmoddi4 provided the operands are unsigned and >> >> >> >> are of DImode. >> >> >> >> >> >> >> >> Patch passes bootstrap+test on x86_64-unknown-linux-gnu and >> >> >> >> cross-tested on arm*-*-*. >> >> >> >> Bootstrap+test in progress on arm-linux-gnueabihf. >> >> >> >> Does this patch look OK ? >> >> >> > >> >> >> > diff --git a/gcc/targhooks.c b/gcc/targhooks.c >> >> >> > index 6b4601b..e4a021a 100644 >> >> >> > --- a/gcc/targhooks.c >> >> >> > +++ b/gcc/targhooks.c >> >> >> > @@ -1965,4 +1965,31 @@ default_optab_supported_p (int, machine_mode, >> >> >> > machine_mode, optimization_type) >> >> >> > return true; >> >> >> > } >> >> >> > >> >> >> > +void >> >> >> > +default_expand_divmod_libfunc (bool unsignedp, machine_mode mode, >> >> >> > + rtx op0, rtx op1, >> >> >> > + rtx *quot_p, rtx *rem_p) >> >> >> > >> >> >> > functions need a comment. >> >> >> > >> >> >> > ISTR it was suggested that ARM change to libgcc2.c__udivmoddi4 style? In that >> >> >> > case we could avoid the target hook. >> >> >> Well I would prefer adding the hook because that's more easier -;) >> >> >> Would it be ok for now to go with the hook ? >> >> >> > >> >> >> > + /* If target overrides expand_divmod_libfunc hook >> >> >> > + then perform divmod by generating call to the target-specifc divmod >> >> >> > libfunc. */ >> >> >> > + if (targetm.expand_divmod_libfunc != default_expand_divmod_libfunc) >> >> >> > + return true; >> >> >> > + >> >> >> > + /* Fall back to using libgcc2.c:__udivmoddi4. */ >> >> >> > + return (mode == DImode && unsignedp); >> >> >> > >> >> >> > I don't understand this - we know optab_libfunc returns non-NULL for 'mode' >> >> >> > but still restrict this to DImode && unsigned? Also if >> >> >> > targetm.expand_divmod_libfunc >> >> >> > is not the default we expect the target to handle all modes? >> >> >> Ah indeed, the check for DImode is unnecessary. >> >> >> However I suppose the check for unsignedp should be there, >> >> >> since we want to generate call to __udivmoddi4 only if operand is unsigned ? >> >> > >> >> > The optab libfunc for sdivmod should be NULL in that case. >> >> Ah indeed, thanks. >> >> > >> >> >> > >> >> >> > That said - I expected the above piece to be simply a 'return true;' ;) >> >> >> > >> >> >> > Usually we use some can_expand_XXX helper in optabs.c to query if the target >> >> >> > supports a specific operation (for example SImode divmod would use DImode >> >> >> > divmod by means of widening operands - for the unsigned case of course). >> >> >> Thanks for pointing out. So if a target does not support divmod >> >> >> libfunc for a mode >> >> >> but for a wider mode, then we could zero-extend operands to the wider-mode, >> >> >> perform divmod on the wider-mode, and then cast result back to the >> >> >> original mode. >> >> >> I haven't done that in this patch, would it be OK to do that as a follow up ? >> >> > >> >> > I think that you should conservatively handle the div_optab query, thus if >> >> > the target has a HW division in a wider mode don't use the divmod IFN. >> >> > You'd simply iterate over GET_MODE_WIDER_MODE and repeat the >> >> > if (optab_handler (div_optab, mode) != CODE_FOR_nothing) check, bailing >> >> > out if that is available. >> >> Done. >> >> > >> >> >> > + /* Disable the transform if either is a constant, since >> >> >> > division-by-constant >> >> >> > + may have specialized expansion. */ >> >> >> > + if (TREE_CONSTANT (op1) || TREE_CONSTANT (op2)) >> >> >> > + return false; >> >> >> > >> >> >> > please use CONSTANT_CLASS_P (op1) || CONSTANT_CLASS_P (op2) >> >> >> > >> >> >> > + if (TYPE_OVERFLOW_TRAPS (type)) >> >> >> > + return false; >> >> >> > >> >> >> > why's that? Generally please first test cheap things (trapping, constant-ness) >> >> >> > before checking expensive stuff (target_supports_divmod_p). >> >> >> I added TYPE_OVERFLOW_TRAPS (type) based on your suggestion in: >> >> >> https://www.mail-archive.com/gcc@gcc.gnu.org/msg78534.html >> >> >> "When looking at TRUNC_DIV_EXPR you should also exclude >> >> >> the case where TYPE_OVERFLOW_TRAPS (type) as that should >> >> >> expand using the [su]divv optabs (no trapping overflow >> >> >> divmod optab exists)." >> >> > >> >> > Ok, didn't remember that. >> >> > >> >> >> > >> >> >> > +static bool >> >> >> > +convert_to_divmod (gassign *stmt) >> >> >> > +{ >> >> >> > + if (!divmod_candidate_p (stmt)) >> >> >> > + return false; >> >> >> > + >> >> >> > + tree op1 = gimple_assign_rhs1 (stmt); >> >> >> > + tree op2 = gimple_assign_rhs2 (stmt); >> >> >> > + >> >> >> > + vec stmts = vNULL; >> >> >> > >> >> >> > use an auto_vec - you currently leak it in at least one place. >> >> >> > >> >> >> > + if (maybe_clean_or_replace_eh_stmt (use_stmt, use_stmt)) >> >> >> > + cfg_changed = true; >> >> >> > >> >> >> > note that this suggests you should check whether any of the stmts may throw >> >> >> > internally as you don't update / transfer EH info correctly. So for 'stmt' and >> >> >> > all 'use_stmt' check stmt_can_throw_internal and if so do not add it to >> >> >> > the list of stmts to modify. >> >> >> > >> >> >> > Btw, I think you should not add 'stmt' immediately but when iterating over >> >> >> > all uses also gather uses in TRUNC_MOD_EXPR. >> >> >> > >> >> >> > Otherwise looks ok. >> >> >> Done changes in this version. I am gathering mod uses same time as div uses, >> >> >> so this imposes a constraint that mod dominates mod. I am not sure if >> >> >> that's desirable. >> >> > >> >> > I think you also need a mod_seen variable now that you don't necessarily >> >> > end up with 'stmt' in the vector of stmts. I don't see how there is a >> >> > constraint that mod dominates mod - it's just that the top_stmt needs >> >> > to dominate all other uses that can be replaced with replacing top_stmt >> >> > with a divmod. It's just that the actual stmt set we choose may now >> >> > depend on immediate uses order which on a second thought is bad >> >> > as immediate uses order could be affected by debug stmts ... hmm. >> >> > >> >> > To avoid this please re-add the code adding 'stmt' to stmts immediately >> >> > and add a use_stmt != stmt check to the immediate use processing loop >> >> > so that we don't end up adding it twice. >> >> Well I wonder what will happen for the following case: >> >> t1 = x / y; >> >> if (cond) >> >> t2 = x % y; >> >> else >> >> t3 = x % y; >> >> >> >> Assuming stmt == top_stmt is "t2 = x % y" and use_stmt is "t3 = x % y", >> >> use_stmt will not get added to stmts vector, since top_stmt and >> >> use_stmt are not in same bb, >> >> and bb's containing top_stmt and use_stmt don't dominate each other. >> >> Not sure if this is practical case (I assume fre will hoist mod >> >> outside if-else?) >> >> >> >> Now that we immediately add stmt to stmts vector, I suppose mod_seen >> >> shall not be required ? >> > >> > In that case mod_seen is not needed. But the situation you say will >> > still happen so I wonder if we'd need a better way of iterating over >> > immediate uses, like first pushing all candidates into a worklist >> > vector and then iterating over that until we find no more candidates. >> > >> > You can then also handle the case of more than one group of stmts >> > (the pass currently doesn't iterate in any particular useful order >> > over BBs). >> IIUC, we want to perform the transform if: >> i) there exists top_stmt with code trunc_div_expr/trunc_mod_expr and >> having same operands as stmt. >> ii) top_stmt dominates all other stmts with code >> trunc_div_expr/trunc_mod_expr and having same operands as top_stmt. >> >> Firstly, we try to get to top_stmt if it exists, by iterating over uses of stmt, >> and then iterate over all uses of top_stmt and add them to stmts vector >> only if top_stmt dominates all the stmts with same operands as top_stmt >> and have code trunc_div_expr/trunc_mod_expr. >> >> /* Get to top_stmt. */ >> top_stmt = stmt; >> top_bb = gimple_bb (stmt); >> >> FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, op1) >> { >> if (use_stmt code is TRUNC_DIV_EXPR or TRUNC_MOD_EXPR >> && use_stmt has same operands as stmt) >> { >> if (gimple_bb (use_stmt) dominates top_bb) >> { >> top_bb = gimple_bb (use_stmt); >> top_stmt = use_stmt; >> } >> else if (gimple_bb (use_stmt) == top_stmt >> && gimple_uid (use_stmt) < top_stmt) >> top_stmt = use_stmt; >> } >> } >> >> /* Speculatively consider top_stmt as dominating all other >> div_expr/mod_expr stmts with same operands as stmt. */ >> stmts.safe_push (top_stmt); >> >> /* Walk uses of top_stmt to ensure that all stmts are dominated by top_stmt. */ >> top_op1 = gimple_assign_rhs1 (top_stmt); >> FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, top_op1) >> { >> if (use_stmt code is TRUNC_DIV_EXPR or TRUNC_MOD_EXPR >> && use_stmt has same operands as top_stmt) >> { >> if (use_stmt == top_stmt) >> continue; >> >> /* No top_stmt exits, do not proceed with transform */ >> if (top_bb does not dominate gimple_bb (use_stmt)) >> return false; >> >> stmts.safe_push (use_stmt); >> } >> } >> >> For the case: >> t1 = x / y; >> if (cond) >> t2 = x % y; >> else >> t3 = x % y; >> >> Assuming stmt is "t2 = x % y", it will walk uses of stmt and set >> top_stmt to "t1 = x / y" >> Then it will walk all uses of top_stmt: >> "t2 = x % y" -> dominated by top_stmt >> "t3 = x % y" -> dominated by top_stmt >> Since all stmts are dominated by top_stmt, we add all three stmts to >> vector of stmts and proceed with transform. >> >> For the case where, top_stmt dominates original stmt but not all stmts: >> >> if (cond) >> t1 = x / y; >> else >> { >> t2 = x % y; >> return; >> } >> >> t3 = x % y; >> >> Assuming stmt is "t3 = x % y", >> Walking stmt uses will set top_stmt to "t1 = x / y"; >> >> Walking immediate uses of top_stmt, we find that "t2 = x % y" is not >> dominated by top_stmt, >> and hence don't do the transform. >> >> Does this sound reasonable ? > > Yes, that's reasonable. Thanks, I have attached patch that implements above approach. Does it look OK ? The patch does not still handle the following case: int f(int x, int y) { extern int cond; int q, r; if (cond) q = x % y; else q = x % y; r = x % y; return q + r; } In above case although the mod stmt is not dominated by either div stmt, I suppose the transform is still possible by inserting DIVMOD (x, y) before if-else ? For the following test-case, I am surprised why CSE didn't take place before widening_mul pass ? int f_1 (int x, int y) { int q = x / y; int r1 = 0, r2 = 0; if (cond) r1 = x % y; else r2 = x % y; return q + r1 + r2; } The input to widening_mul pass is: f_1 (int x, int y) { int r2; int r1; int q; int cond.0_1; int _2; int _11; : q_7 = x_5(D) / y_6(D); cond.0_1 = cond; if (cond.0_1 != 0) goto ; else goto ; : r1_9 = x_5(D) % y_6(D); goto ; : r2_10 = x_5(D) % y_6(D); : # r1_3 = PHI # r2_4 = PHI <0(3), r2_10(4)> _2 = r1_3 + q_7; _11 = _2 + r2_4; return _11; } Thanks, Prathamesh > > Richard. > >> Thanks, >> Prathamesh >> > >> > Richard. >> > >> >> > > -- > Richard Biener > SUSE LINUX GmbH, GF: Felix Imendoerffer, Jane Smithard, Graham Norton, HRB 21284 (AG Nuernberg) --94eb2c03caaccd56ae0533aa0d5b Content-Type: text/plain; charset=US-ASCII; name="divmod-part1_4.diff" Content-Disposition: attachment; filename="divmod-part1_4.diff" Content-Transfer-Encoding: base64 X-Attachment-Id: f_iomv62yl0 Content-length: 20008 ZGlmZiAtLWdpdCBhL2djYy9kb2MvdG0udGV4aSBiL2djYy9kb2MvdG0udGV4 aQppbmRleCA4YzdmMmExLi4xMTFmMTlmIDEwMDY0NAotLS0gYS9nY2MvZG9j L3RtLnRleGkKKysrIGIvZ2NjL2RvYy90bS50ZXhpCkBAIC02OTYzLDYgKzY5 NjMsMTIgQEAgVGhpcyBpcyBmaXJzdGx5IGludHJvZHVjZWQgb24gQVJNL0FB cmNoNjQgdGFyZ2V0cywgcGxlYXNlIHJlZmVyIHRvCiB0aGUgaG9vayBpbXBs ZW1lbnRhdGlvbiBmb3IgaG93IGRpZmZlcmVudCBmdXNpb24gdHlwZXMgYXJl IHN1cHBvcnRlZC4KIEBlbmQgZGVmdHlwZWZuCiAKK0BkZWZ0eXBlZm4ge1Rh cmdldCBIb29rfSB2b2lkIFRBUkdFVF9FWFBBTkRfRElWTU9EX0xJQkZVTkMg KGJvb2wgQHZhcnt1bnNpZ25lZHB9LCBtYWNoaW5lX21vZGUgQHZhcnttb2Rl fSwgQHZhcntydHh9LCBAdmFye3J0eH0sIHJ0eCAqQHZhcntxdW90fSwgcnR4 ICpAdmFye3JlbX0pCitEZWZpbmUgdGhpcyBob29rIGlmIHRoZSBwb3J0IGRv ZXMgbm90IGhhdmUgaGFyZHdhcmUgZGl2IGFuZCBkaXZtb2QgaW5zbiBmb3IK K3RoZSBnaXZlbiBtb2RlIGJ1dCBoYXMgZGl2bW9kIGxpYmZ1bmMsIHdoaWNo IGlzIGluY29tcGF0aWJsZQord2l0aCBsaWJnY2MyLmM6X191ZGl2bW9kZGk0 CitAZW5kIGRlZnR5cGVmbgorCiBAbm9kZSBTZWN0aW9ucwogQHNlY3Rpb24g RGl2aWRpbmcgdGhlIE91dHB1dCBpbnRvIFNlY3Rpb25zIChUZXh0cywgRGF0 YSwgQGRvdHN7fSkKIEBjIHRoZSBhYm92ZSBzZWN0aW9uIHRpdGxlIGlzIFdB WSB0b28gbG9uZy4gIG1heWJlIGN1dCB0aGUgcGFydCBiZXR3ZWVuCmRpZmYg LS1naXQgYS9nY2MvZG9jL3RtLnRleGkuaW4gYi9nY2MvZG9jL3RtLnRleGku aW4KaW5kZXggZjk2M2E1OC4uMmM5YTgwMCAxMDA2NDQKLS0tIGEvZ2NjL2Rv Yy90bS50ZXhpLmluCisrKyBiL2djYy9kb2MvdG0udGV4aS5pbgpAQCAtNDg0 OCw2ICs0ODQ4LDggQEAgdGhlbTogdHJ5IHRoZSBmaXJzdCBvbmVzIGluIHRo aXMgbGlzdCBmaXJzdC4KIAogQGhvb2sgVEFSR0VUX1NDSEVEX0ZVU0lPTl9Q UklPUklUWQogCitAaG9vayBUQVJHRVRfRVhQQU5EX0RJVk1PRF9MSUJGVU5D CisKIEBub2RlIFNlY3Rpb25zCiBAc2VjdGlvbiBEaXZpZGluZyB0aGUgT3V0 cHV0IGludG8gU2VjdGlvbnMgKFRleHRzLCBEYXRhLCBAZG90c3t9KQogQGMg dGhlIGFib3ZlIHNlY3Rpb24gdGl0bGUgaXMgV0FZIHRvbyBsb25nLiAgbWF5 YmUgY3V0IHRoZSBwYXJ0IGJldHdlZW4KZGlmZiAtLWdpdCBhL2djYy9pbnRl cm5hbC1mbi5jIGIvZ2NjL2ludGVybmFsLWZuLmMKaW5kZXggYzg2N2RkYy4u MGNiNTlmNyAxMDA2NDQKLS0tIGEvZ2NjL2ludGVybmFsLWZuLmMKKysrIGIv Z2NjL2ludGVybmFsLWZuLmMKQEAgLTIyNzYsNiArMjI3Niw0OCBAQCBtdWx0 aV92ZWN0b3Jfb3B0YWJfc3VwcG9ydGVkX3AgKGNvbnZlcnRfb3B0YWIgb3B0 YWIsIHRyZWVfcGFpciB0eXBlcywKICNkZWZpbmUgZGlyZWN0X21hc2tfc3Rv cmVfb3B0YWJfc3VwcG9ydGVkX3AgZGlyZWN0X29wdGFiX3N1cHBvcnRlZF9w CiAjZGVmaW5lIGRpcmVjdF9zdG9yZV9sYW5lc19vcHRhYl9zdXBwb3J0ZWRf cCBtdWx0aV92ZWN0b3Jfb3B0YWJfc3VwcG9ydGVkX3AKIAorLyogRXhwYW5k IERJVk1PRCgpIHVzaW5nOgorIGEpIG9wdGFiIGhhbmRsZXIgZm9yIHVkaXZt b2Qvc2Rpdm1vZCBpZiBpdCBpcyBhdmFpbGFibGUuCisgYikgSWYgb3B0YWJf aGFuZGxlciBkb2Vzbid0IGV4aXN0LCBHZW5lcmF0ZSBjYWxsIHRvCisgICAg b3B0YWJfbGliZnVuYyBmb3IgdWRpdm1vZC9zZGl2bW9kLiAgKi8KKworc3Rh dGljIHZvaWQgCitleHBhbmRfRElWTU9EIChpbnRlcm5hbF9mbiwgZ2NhbGwg KnN0bXQpCit7CisgIHRyZWUgbGhzID0gZ2ltcGxlX2NhbGxfbGhzIChzdG10 KTsKKyAgdHJlZSBhcmcwID0gZ2ltcGxlX2NhbGxfYXJnIChzdG10LCAwKTsK KyAgdHJlZSBhcmcxID0gZ2ltcGxlX2NhbGxfYXJnIChzdG10LCAxKTsKKwor ICBnY2NfYXNzZXJ0IChUUkVFX0NPREUgKFRSRUVfVFlQRSAobGhzKSkgPT0g Q09NUExFWF9UWVBFKTsKKyAgdHJlZSB0eXBlID0gVFJFRV9UWVBFIChUUkVF X1RZUEUgKGxocykpOworICBtYWNoaW5lX21vZGUgbW9kZSA9IFRZUEVfTU9E RSAodHlwZSk7CisgIGJvb2wgdW5zaWduZWRwID0gVFlQRV9VTlNJR05FRCAo dHlwZSk7CisgIG9wdGFiIHRhYiA9ICh1bnNpZ25lZHApID8gdWRpdm1vZF9v cHRhYiA6IHNkaXZtb2Rfb3B0YWI7CisKKyAgcnR4IG9wMCA9IGV4cGFuZF9u b3JtYWwgKGFyZzApOworICBydHggb3AxID0gZXhwYW5kX25vcm1hbCAoYXJn MSk7CisgIHJ0eCB0YXJnZXQgPSBleHBhbmRfZXhwciAobGhzLCBOVUxMX1JU WCwgVk9JRG1vZGUsIEVYUEFORF9XUklURSk7CisKKyAgcnR4IHF1b3RpZW50 LCByZW1haW5kZXI7CisKKyAgLyogQ2hlY2sgaWYgb3B0YWIgaGFuZGxlciBl eGlzdHMgZm9yIFt1XWRpdm1vZC4gICovCisgIGlmIChvcHRhYl9oYW5kbGVy ICh0YWIsIG1vZGUpICE9IENPREVfRk9SX25vdGhpbmcpCisgICAgeworICAg ICAgcXVvdGllbnQgPSBnZW5fcmVnX3J0eCAobW9kZSk7CisgICAgICByZW1h aW5kZXIgPSBnZW5fcmVnX3J0eCAobW9kZSk7CisgICAgICBleHBhbmRfdHdv dmFsX2Jpbm9wICh0YWIsIG9wMCwgb3AxLCBxdW90aWVudCwgcmVtYWluZGVy LCB1bnNpZ25lZHApOworICAgIH0KKyAgZWxzZQorICAgIHRhcmdldG0uZXhw YW5kX2Rpdm1vZF9saWJmdW5jICh1bnNpZ25lZHAsIG1vZGUsIG9wMCwgb3Ax LAorCQkJCSAgICZxdW90aWVudCwgJnJlbWFpbmRlcik7CisKKyAgLyogV3Jh cCB0aGUgcmV0dXJuIHZhbHVlIChxdW90aWVudCwgcmVtYWluZGVyKSB3aXRo aW4gQ09NUExFWF9FWFBSLiAgKi8KKyAgZXhwYW5kX2V4cHIgKGJ1aWxkMiAo Q09NUExFWF9FWFBSLCBUUkVFX1RZUEUgKGxocyksCisJCSAgICAgICBtYWtl X3RyZWUgKFRSRUVfVFlQRSAoYXJnMCksIHF1b3RpZW50KSwKKwkJICAgICAg IG1ha2VfdHJlZSAoVFJFRV9UWVBFIChhcmcxKSwgcmVtYWluZGVyKSksCisJ ICAgICAgIHRhcmdldCwgVk9JRG1vZGUsIEVYUEFORF9OT1JNQUwpOworfQor CiAvKiBSZXR1cm4gdHJ1ZSBpZiBGTiBpcyBzdXBwb3J0ZWQgZm9yIHRoZSB0 eXBlcyBpbiBUWVBFUyB3aGVuIHRoZQogICAgb3B0aW1pemF0aW9uIHR5cGUg aXMgT1BUX1RZUEUuICBUaGUgdHlwZXMgYXJlIHRob3NlIGFzc29jaWF0ZWQg d2l0aAogICAgdGhlICJ0eXBlMCIgYW5kICJ0eXBlMSIgZmllbGRzIG9mIEZO J3MgZGlyZWN0X2ludGVybmFsX2ZuX2luZm8KZGlmZiAtLWdpdCBhL2djYy9p bnRlcm5hbC1mbi5kZWYgYi9nY2MvaW50ZXJuYWwtZm4uZGVmCmluZGV4IGU3 MjlkODUuLjU2YTgwZjEgMTAwNjQ0Ci0tLSBhL2djYy9pbnRlcm5hbC1mbi5k ZWYKKysrIGIvZ2NjL2ludGVybmFsLWZuLmRlZgpAQCAtMTk0LDYgKzE5NCw5 IEBAIERFRl9JTlRFUk5BTF9GTiAoQVRPTUlDX0JJVF9URVNUX0FORF9TRVQs IEVDRl9MRUFGIHwgRUNGX05PVEhST1csIE5VTEwpCiBERUZfSU5URVJOQUxf Rk4gKEFUT01JQ19CSVRfVEVTVF9BTkRfQ09NUExFTUVOVCwgRUNGX0xFQUYg fCBFQ0ZfTk9USFJPVywgTlVMTCkKIERFRl9JTlRFUk5BTF9GTiAoQVRPTUlD X0JJVF9URVNUX0FORF9SRVNFVCwgRUNGX0xFQUYgfCBFQ0ZfTk9USFJPVywg TlVMTCkKIAorLyogRGl2bW9kIGZ1bmN0aW9uLiAgKi8KK0RFRl9JTlRFUk5B TF9GTiAoRElWTU9ELCBFQ0ZfQ09OU1QgfCBFQ0ZfTEVBRiwgTlVMTCkKKwog I3VuZGVmIERFRl9JTlRFUk5BTF9JTlRfRk4KICN1bmRlZiBERUZfSU5URVJO QUxfRkxUX0ZOCiAjdW5kZWYgREVGX0lOVEVSTkFMX09QVEFCX0ZOCmRpZmYg LS1naXQgYS9nY2MvdGFyZ2V0LmRlZiBiL2djYy90YXJnZXQuZGVmCmluZGV4 IDYzOTJlNzMuLjQ0OTZmOWEgMTAwNjQ0Ci0tLSBhL2djYy90YXJnZXQuZGVm CisrKyBiL2djYy90YXJnZXQuZGVmCkBAIC00OTQ4LDYgKzQ5NDgsMTYgQEAg Tm9ybWFsbHksIHRoaXMgaXMgbm90IG5lZWRlZC4iLAogIGJvb2wsIChjb25z dF90cmVlIGZpZWxkLCBtYWNoaW5lX21vZGUgbW9kZSksCiAgZGVmYXVsdF9t ZW1iZXJfdHlwZV9mb3JjZXNfYmxrKQogCisvKiBTZWUgdHJlZS1zc2EtbWF0 aC1vcHRzLmM6ZGl2bW9kX2NhbmRpZGF0ZV9wIGZvciBjb25kaXRpb25zIHRo YXQgZ2F0ZQorICAgdGhlIGRpdm1vZCB0cmFuc2Zvcm0uICAqLworREVGSE9P SworKGV4cGFuZF9kaXZtb2RfbGliZnVuYywKKyAiRGVmaW5lIHRoaXMgaG9v ayBpZiB0aGUgcG9ydCBkb2VzIG5vdCBoYXZlIGhhcmR3YXJlIGRpdiBhbmQg ZGl2bW9kIGluc24gZm9yXG5cCit0aGUgZ2l2ZW4gbW9kZSBidXQgaGFzIGRp dm1vZCBsaWJmdW5jLCB3aGljaCBpcyBpbmNvbXBhdGlibGVcblwKK3dpdGgg bGliZ2NjMi5jOl9fdWRpdm1vZGRpNCIsCisgdm9pZCwgKGJvb2wgdW5zaWdu ZWRwLCBtYWNoaW5lX21vZGUgbW9kZSwgcnR4LCBydHgsIHJ0eCAqcXVvdCwg cnR4ICpyZW0pLAorIGRlZmF1bHRfZXhwYW5kX2Rpdm1vZF9saWJmdW5jKQor CiAvKiBSZXR1cm4gdGhlIGNsYXNzIGZvciBhIHNlY29uZGFyeSByZWxvYWQs IGFuZCBmaWxsIGluIGV4dHJhIGluZm9ybWF0aW9uLiAgKi8KIERFRkhPT0sK IChzZWNvbmRhcnlfcmVsb2FkLApkaWZmIC0tZ2l0IGEvZ2NjL3Rhcmdob29r cy5jIGIvZ2NjL3Rhcmdob29rcy5jCmluZGV4IDZiNDYwMWIuLjIwMzI3YTYg MTAwNjQ0Ci0tLSBhL2djYy90YXJnaG9va3MuYworKysgYi9nY2MvdGFyZ2hv b2tzLmMKQEAgLTE5NjUsNCArMTk2NSwzMSBAQCBkZWZhdWx0X29wdGFiX3N1 cHBvcnRlZF9wIChpbnQsIG1hY2hpbmVfbW9kZSwgbWFjaGluZV9tb2RlLCBv cHRpbWl6YXRpb25fdHlwZSkKICAgcmV0dXJuIHRydWU7CiB9CiAKKy8qIEdl bmVyYXRlIGNhbGwgdG8KKyAgIERJbW9kZSBfX3VkaXZtb2RkaTQgKERJbW9k ZSBvcDAsIERJbW9kZSBvcDEsIERJbW9kZSAqcmVtKS4gICovCisKK3ZvaWQK K2RlZmF1bHRfZXhwYW5kX2Rpdm1vZF9saWJmdW5jIChib29sIHVuc2lnbmVk cCwgbWFjaGluZV9tb2RlIG1vZGUsCisJCQkgICAgICAgcnR4IG9wMCwgcnR4 IG9wMSwKKwkJCSAgICAgICBydHggKnF1b3RfcCwgcnR4ICpyZW1fcCkKK3sK KyAgZ2NjX2Fzc2VydCAobW9kZSA9PSBESW1vZGUpOworICBnY2NfYXNzZXJ0 ICh1bnNpZ25lZHApOworCisgIHJ0eCBsaWJmdW5jID0gb3B0YWJfbGliZnVu YyAodWRpdm1vZF9vcHRhYiwgREltb2RlKTsKKyAgZ2NjX2Fzc2VydCAobGli ZnVuYyk7CisKKyAgcnR4IHJlbWFpbmRlciA9IGFzc2lnbl9zdGFja190ZW1w IChESW1vZGUsIEdFVF9NT0RFX1NJWkUgKERJbW9kZSkpOworICBydHggYWRk cmVzcyA9IFhFWFAgKHJlbWFpbmRlciwgMCk7CisKKyAgcnR4IHF1b3RpZW50 ID0gZW1pdF9saWJyYXJ5X2NhbGxfdmFsdWUgKGxpYmZ1bmMsIE5VTExfUlRY LCBMQ1RfQ09OU1QsCisJCQkJCSAgREltb2RlLCAzLAorCQkJCQkgIG9wMCwg R0VUX01PREUgKG9wMCksCisJCQkJCSAgb3AxLCBHRVRfTU9ERSAob3AxKSwK KwkJCQkJICBhZGRyZXNzLCBHRVRfTU9ERSAoYWRkcmVzcykpOworCisgICpx dW90X3AgPSBxdW90aWVudDsKKyAgKnJlbV9wID0gcmVtYWluZGVyOworfQor CiAjaW5jbHVkZSAiZ3QtdGFyZ2hvb2tzLmgiCmRpZmYgLS1naXQgYS9nY2Mv dGFyZ2hvb2tzLmggYi9nY2MvdGFyZ2hvb2tzLmgKaW5kZXggNzY4N2MzOS4u ZGM1ZThlNyAxMDA2NDQKLS0tIGEvZ2NjL3Rhcmdob29rcy5oCisrKyBiL2dj Yy90YXJnaG9va3MuaApAQCAtMjU0LDQgKzI1NCw3IEBAIGV4dGVybiB2b2lk IGRlZmF1bHRfc2V0dXBfaW5jb21pbmdfdmFyYXJnX2JvdW5kcyAoY3VtdWxh dGl2ZV9hcmdzX3QgY2EgQVRUUklCVVRFCiBleHRlcm4gYm9vbCBkZWZhdWx0 X29wdGFiX3N1cHBvcnRlZF9wIChpbnQsIG1hY2hpbmVfbW9kZSwgbWFjaGlu ZV9tb2RlLAogCQkJCSAgICAgICBvcHRpbWl6YXRpb25fdHlwZSk7CiAKK2V4 dGVybiB2b2lkIGRlZmF1bHRfZXhwYW5kX2Rpdm1vZF9saWJmdW5jIChib29s LCBtYWNoaW5lX21vZGUsCisJCQkJCSAgIHJ0eCwgcnR4LCBydHggKiwgcnR4 ICopOworCiAjZW5kaWYgLyogR0NDX1RBUkdIT09LU19IICovCmRpZmYgLS1n aXQgYS9nY2MvdHJlZS1zc2EtbWF0aC1vcHRzLmMgYi9nY2MvdHJlZS1zc2Et bWF0aC1vcHRzLmMKaW5kZXggODE2ODhjZC4uN2I2ZDk4MyAxMDA2NDQKLS0t IGEvZ2NjL3RyZWUtc3NhLW1hdGgtb3B0cy5jCisrKyBiL2djYy90cmVlLXNz YS1tYXRoLW9wdHMuYwpAQCAtMTEyLDYgKzExMiw5IEBAIGFsb25nIHdpdGgg R0NDOyBzZWUgdGhlIGZpbGUgQ09QWUlORzMuICBJZiBub3Qgc2VlCiAjaW5j bHVkZSAicGFyYW1zLmgiCiAjaW5jbHVkZSAiaW50ZXJuYWwtZm4uaCIKICNp bmNsdWRlICJjYXNlLWNmbi1tYWNyb3MuaCIKKyNpbmNsdWRlICJvcHRhYnMt bGliZnVuY3MuaCIKKyNpbmNsdWRlICJ0cmVlLWVoLmgiCisjaW5jbHVkZSAi dGFyZ2hvb2tzLmgiCiAKIC8qIFRoaXMgc3RydWN0dXJlIHJlcHJlc2VudHMg b25lIGJhc2ljIGJsb2NrIHRoYXQgZWl0aGVyIGNvbXB1dGVzIGEKICAgIGRp dmlzaW9uLCBvciBpcyBhIGNvbW1vbiBkb21pbmF0b3IgZm9yIGJhc2ljIGJs b2NrIHRoYXQgY29tcHV0ZSBhCkBAIC0xODQsNiArMTg3LDkgQEAgc3RhdGlj IHN0cnVjdAogCiAgIC8qIE51bWJlciBvZiBmcCBmdXNlZCBtdWx0aXBseS1h ZGQgb3BzIGluc2VydGVkLiAgKi8KICAgaW50IGZtYXNfaW5zZXJ0ZWQ7CisK KyAgLyogTnVtYmVyIG9mIGRpdm1vZCBjYWxscyBpbnNlcnRlZC4gICovCisg IGludCBkaXZtb2RfY2FsbHNfaW5zZXJ0ZWQ7CiB9IHdpZGVuX211bF9zdGF0 czsKIAogLyogVGhlIGluc3RhbmNlIG9mICJzdHJ1Y3Qgb2NjdXJyZW5jZSIg cmVwcmVzZW50aW5nIHRoZSBoaWdoZXN0CkBAIC0zNzg0LDYgKzM3OTAsMjMz IEBAIG1hdGNoX3VhZGRzdWJfb3ZlcmZsb3cgKGdpbXBsZV9zdG10X2l0ZXJh dG9yICpnc2ksIGdpbXBsZSAqc3RtdCwKICAgcmV0dXJuIHRydWU7CiB9CiAK Ky8qIFJldHVybiB0cnVlIGlmIHRhcmdldCBoYXMgc3VwcG9ydCBmb3IgZGl2 bW9kLiAgKi8KKworc3RhdGljIGJvb2wKK3RhcmdldF9zdXBwb3J0c19kaXZt b2RfcCAob3B0YWIgZGl2bW9kX29wdGFiLCBvcHRhYiBkaXZfb3B0YWIsIG1h Y2hpbmVfbW9kZSBtb2RlKQoreworICAvKiBJZiB0YXJnZXQgc3VwcG9ydHMg aGFyZHdhcmUgZGl2bW9kIGluc24sIHVzZSBpdCBmb3IgZGl2bW9kLiAgKi8K KyAgaWYgKG9wdGFiX2hhbmRsZXIgKGRpdm1vZF9vcHRhYiwgbW9kZSkgIT0g Q09ERV9GT1Jfbm90aGluZykKKyAgICByZXR1cm4gdHJ1ZTsKKworICAvKiBD aGVjayBpZiBsaWJmdW5jIGZvciBkaXZtb2QgaXMgYXZhaWxhYmxlLiAgKi8K KyAgaWYgKG9wdGFiX2xpYmZ1bmMgKGRpdm1vZF9vcHRhYiwgbW9kZSkgIT0g TlVMTF9SVFgpCisgICAgeworICAgICAgLyogSWYgb3B0YWJfaGFuZGxlciBl eGlzdHMgZm9yIGRpdl9vcHRhYiwgcGVyaGFwcyBpbiBhIHdpZGVyIG1vZGUs CisJIHdlIGRvbid0IHdhbnQgdG8gdXNlIHRoZSBsaWJmdW5jIGV2ZW4gaWYg aXQgZXhpc3RzIGZvciBnaXZlbiBtb2RlLiAgKi8gCisgICAgICBmb3IgKG1h Y2hpbmVfbW9kZSBkaXZfbW9kZSA9IG1vZGU7CisJICAgZGl2X21vZGUgIT0g Vk9JRG1vZGU7CisJICAgZGl2X21vZGUgPSBHRVRfTU9ERV9XSURFUl9NT0RF IChkaXZfbW9kZSkpCisJaWYgKG9wdGFiX2hhbmRsZXIgKGRpdl9vcHRhYiwg ZGl2X21vZGUpICE9IENPREVfRk9SX25vdGhpbmcpCisJICByZXR1cm4gZmFs c2U7CisgCisgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAgcmV0dXJu IGZhbHNlOworfQorCisvKiBDaGVjayBpZiBzdG10IGlzIGNhbmRpZGF0ZSBm b3IgZGl2bW9kIHRyYW5zZm9ybS4gICovCisKK3N0YXRpYyBib29sCitkaXZt b2RfY2FuZGlkYXRlX3AgKGdhc3NpZ24gKnN0bXQpCit7CisgIHRyZWUgdHlw ZSA9IFRSRUVfVFlQRSAoZ2ltcGxlX2Fzc2lnbl9saHMgKHN0bXQpKTsKKyAg ZW51bSBtYWNoaW5lX21vZGUgbW9kZSA9IFRZUEVfTU9ERSAodHlwZSk7Cisg IG9wdGFiIGRpdm1vZF9vcHRhYiwgZGl2X29wdGFiOworCisgIGlmIChUWVBF X1VOU0lHTkVEICh0eXBlKSkKKyAgICB7CisgICAgICBkaXZtb2Rfb3B0YWIg PSB1ZGl2bW9kX29wdGFiOworICAgICAgZGl2X29wdGFiID0gdWRpdl9vcHRh YjsKKyAgICB9CisgIGVsc2UKKyAgICB7CisgICAgICBkaXZtb2Rfb3B0YWIg PSBzZGl2bW9kX29wdGFiOworICAgICAgZGl2X29wdGFiID0gc2Rpdl9vcHRh YjsKKyAgICB9CisKKyAgdHJlZSBvcDEgPSBnaW1wbGVfYXNzaWduX3JoczEg KHN0bXQpOworICB0cmVlIG9wMiA9IGdpbXBsZV9hc3NpZ25fcmhzMiAoc3Rt dCk7CisKKyAgLyogRGlzYWJsZSB0aGUgdHJhbnNmb3JtIGlmIGVpdGhlciBp cyBhIGNvbnN0YW50LCBzaW5jZSBkaXZpc2lvbi1ieS1jb25zdGFudAorICAg ICBtYXkgaGF2ZSBzcGVjaWFsaXplZCBleHBhbnNpb24uICAqLworICBpZiAo Q09OU1RBTlRfQ0xBU1NfUCAob3AxKSB8fCBDT05TVEFOVF9DTEFTU19QIChv cDIpKQorICAgIHJldHVybiBmYWxzZTsKKworICAvKiBFeGNsdWRlIHRoZSBj YXNlIHdoZXJlIFRZUEVfT1ZFUkZMT1dfVFJBUFMgKHR5cGUpIGFzIHRoYXQg c2hvdWxkCisgICAgIGV4cGFuZCB1c2luZyB0aGUgW3N1XWRpdnYgb3B0YWJz LiAgKi8KKyAgaWYgKFRZUEVfT1ZFUkZMT1dfVFJBUFMgKHR5cGUpKQorICAg IHJldHVybiBmYWxzZTsKKyAgCisgIGlmICghdGFyZ2V0X3N1cHBvcnRzX2Rp dm1vZF9wIChkaXZtb2Rfb3B0YWIsIGRpdl9vcHRhYiwgbW9kZSkpCisgICAg cmV0dXJuIGZhbHNlOworCisgIHJldHVybiB0cnVlOworfQorCisvKiBUaGlz IGZ1bmN0aW9uIGxvb2tzIGZvcjoKKyAgIHQxID0gYSBUUlVOQ19ESVZfRVhQ UiBiOworICAgdDIgPSBhIFRSVU5DX01PRF9FWFBSIGI7CisgICBhbmQgdHJh bnNmb3JtcyBpdCB0byB0aGUgZm9sbG93aW5nIHNlcXVlbmNlOgorICAgY29t cGxleF90bXAgPSBESVZNT0QgKGEsIGIpOworICAgdDEgPSBSRUFMUEFSVF9F WFBSKGEpOworICAgdDIgPSBJTUFHUEFSVF9FWFBSKGIpOworICAgRm9yIGNv bmRpdGlvbnMgZW5hYmxpbmcgdGhlIHRyYW5zZm9ybSBzZWUgZGl2bW9kX2Nh bmRpZGF0ZV9wKCkuCisKKyAgIFRoZSBwYXNzIHdvcmtzIGluIHR3byBwaGFz ZXM6CisgICAxKSBXYWxrIHRocm91Z2ggYWxsIGltbWVkaWF0ZSB1c2VzIG9m IHN0bXQncyBvcGVyYW5kIGFuZCBmaW5kIGEKKyAgICAgIFRSVU5DX0RJVl9F WFBSIHdpdGggbWF0Y2hpbmcgb3BlcmFuZHMgYW5kIGlmIHN1Y2ggYSBzdG10 IGlzIGZvdW5kIGFkZAorICAgICAgaXQgdG8gc3RtdHMgdmVjdG9yLgorICAg MikgSW5zZXJ0IERJVk1PRCBjYWxsIGJlZm9yZSBmaXJzdCBkaXYvbW9kIHN0 bXQgaW4gdG9wX2JiIChiYXNpYyBibG9jayB0aGF0CisgICAgICBkb21pbmF0 ZXMgb3RoZXIgZGl2L21vZCBzdG10cyB3aXRoIHNhbWUgb3BlcmFuZHMpIGFu ZCB1cGRhdGUgZW50cmllcyBpbgorICAgICAgc3RtdHMgdmVjdG9yIHRvIHVz ZSByZXR1cm4gdmFsdWUgb2YgRElNT1ZEIChSRUFMRVhQUl9QQVJUIGZvciBk aXYsCisgICAgICBJTUFHUEFSVF9FWFBSIGZvciBtb2QpLiAgKi8KKworc3Rh dGljIGJvb2wKK2NvbnZlcnRfdG9fZGl2bW9kIChnYXNzaWduICpzdG10KQor eworICBpZiAoIWRpdm1vZF9jYW5kaWRhdGVfcCAoc3RtdCkpCisgICAgcmV0 dXJuIGZhbHNlOworCisgIHRyZWUgb3AxID0gZ2ltcGxlX2Fzc2lnbl9yaHMx IChzdG10KTsKKyAgdHJlZSBvcDIgPSBnaW1wbGVfYXNzaWduX3JoczIgKHN0 bXQpOworICAKKyAgaW1tX3VzZV9pdGVyYXRvciB1c2VfaXRlcjsKKyAgZ2lt cGxlICp1c2Vfc3RtdDsKKyAgYXV0b192ZWM8Z2ltcGxlICo+IHN0bXRzOyAK KworICBnaW1wbGUgKnRvcF9zdG10ID0gTlVMTDsKKyAgYmFzaWNfYmxvY2sg dG9wX2JiID0gTlVMTDsKKworICAvKiBUcnkgdG8gc2V0IHRvcF9zdG10IHRv ICJ0b3Btb3N0IiBzdG10CisgICAgIHdpdGggY29kZSBUUlVOQ19ESVZfRVhQ Ui9UUlVOQ19NT0RfRVhQUiBoYXZpbmcgc2FtZSBvcGVyYW5kcyBhcyBzdG10 LiAgKi8KKworICBGT1JfRUFDSF9JTU1fVVNFX1NUTVQgKHVzZV9zdG10LCB1 c2VfaXRlciwgb3AxKQorICAgIHsKKyAgICAgIGlmIChpc19naW1wbGVfYXNz aWduICh1c2Vfc3RtdCkKKwkgICYmIChnaW1wbGVfYXNzaWduX3Joc19jb2Rl ICh1c2Vfc3RtdCkgPT0gVFJVTkNfRElWX0VYUFIKKwkgICAgICB8fCBnaW1w bGVfYXNzaWduX3Joc19jb2RlICh1c2Vfc3RtdCkgPT0gVFJVTkNfTU9EX0VY UFIpCisJICAmJiBvcGVyYW5kX2VxdWFsX3AgKG9wMSwgZ2ltcGxlX2Fzc2ln bl9yaHMxICh1c2Vfc3RtdCksIDApCisJICAmJiBvcGVyYW5kX2VxdWFsX3Ag KG9wMiwgZ2ltcGxlX2Fzc2lnbl9yaHMyICh1c2Vfc3RtdCksIDApKQorCXsK KwkgIGlmIChzdG10X2Nhbl90aHJvd19pbnRlcm5hbCAodXNlX3N0bXQpKQor CSAgICBjb250aW51ZTsKKworCSAgYmFzaWNfYmxvY2sgYmIgPSBnaW1wbGVf YmIgKHVzZV9zdG10KTsKKworCSAgaWYgKHRvcF9iYiA9PSBOVUxMKQorCSAg ICB7CisJICAgICAgdG9wX3N0bXQgPSBzdG10OworCSAgICAgIHRvcF9iYiA9 IGJiOworCSAgICB9CisJICBlbHNlIGlmIChiYiA9PSB0b3BfYmIgJiYgZ2lt cGxlX3VpZCAodXNlX3N0bXQpIDwgZ2ltcGxlX3VpZCAodG9wX3N0bXQpKQor CSAgICB0b3Bfc3RtdCA9IHVzZV9zdG10OworCSAgZWxzZSBpZiAoZG9taW5h dGVkX2J5X3AgKENESV9ET01JTkFUT1JTLCB0b3BfYmIsIGJiKSkKKwkgICAg eworCSAgICAgIHRvcF9iYiA9IGJiOworCSAgICAgIHRvcF9zdG10ID0gdXNl X3N0bXQ7CisJICAgIH0KKwl9CisgICAgfQorCisgIGlmICh0b3Bfc3RtdCA9 PSBOVUxMKQorICAgIHJldHVybiBmYWxzZTsgCisKKyAgYm9vbCBkaXZfc2Vl biA9IGZhbHNlOworICBib29sIG1vZF9zZWVuID0gZmFsc2U7CisKKyAgdHJl ZSB0b3Bfb3AxID0gZ2ltcGxlX2Fzc2lnbl9yaHMxICh0b3Bfc3RtdCk7Cisg IHRyZWUgdG9wX29wMiA9IGdpbXBsZV9hc3NpZ25fcmhzMiAodG9wX3N0bXQp OworCisgIHN0bXRzLnNhZmVfcHVzaCAodG9wX3N0bXQpOworICBpZiAoZ2lt cGxlX2Fzc2lnbl9yaHNfY29kZSAodG9wX3N0bXQpID09IFRSVU5DX0RJVl9F WFBSKQorICAgIGRpdl9zZWVuID0gdHJ1ZTsKKyAgZWxzZSBpZiAoZ2ltcGxl X2Fzc2lnbl9yaHNfY29kZSAodG9wX3N0bXQpID09IFRSVU5DX01PRF9FWFBS KQorICAgIG1vZF9zZWVuID0gdHJ1ZTsKKworICAvKiBFbnN1cmUgdGhhdCBn aW1wbGVfYmIgKHVzZV9zdG10KSBpcyBkb21pbmF0ZWQgYnkgdG9wX2JiLiAg Ki8gICAgCisKKyAgRk9SX0VBQ0hfSU1NX1VTRV9TVE1UICh1c2Vfc3RtdCwg dXNlX2l0ZXIsIHRvcF9vcDEpCisgICAgeworICAgICAgaWYgKGlzX2dpbXBs ZV9hc3NpZ24gKHVzZV9zdG10KQorCSAgJiYgKGdpbXBsZV9hc3NpZ25fcmhz X2NvZGUgKHVzZV9zdG10KSA9PSBUUlVOQ19ESVZfRVhQUgorCSAgICAgIHx8 IGdpbXBsZV9hc3NpZ25fcmhzX2NvZGUgKHVzZV9zdG10KSA9PSBUUlVOQ19N T0RfRVhQUikKKwkgICYmIG9wZXJhbmRfZXF1YWxfcCAodG9wX29wMSwgZ2lt cGxlX2Fzc2lnbl9yaHMxICh1c2Vfc3RtdCksIDApCisJICAmJiBvcGVyYW5k X2VxdWFsX3AgKHRvcF9vcDIsIGdpbXBsZV9hc3NpZ25fcmhzMiAodXNlX3N0 bXQpLCAwKSkKKwl7CisJICBpZiAodXNlX3N0bXQgPT0gdG9wX3N0bXQpCisJ ICAgIGNvbnRpbnVlOwkgIAorCisJICBpZiAoc3RtdF9jYW5fdGhyb3dfaW50 ZXJuYWwgKHVzZV9zdG10KSkKKwkgICAgY29udGludWU7CisKKwkgIGlmICgh ZG9taW5hdGVkX2J5X3AgKENESV9ET01JTkFUT1JTLCBnaW1wbGVfYmIgKHVz ZV9zdG10KSwgdG9wX2JiKSkKKwkgICAgeworCSAgICAgIGVuZF9pbW1fdXNl X3N0bXRfdHJhdmVyc2UgKCZ1c2VfaXRlcik7CisJICAgICAgcmV0dXJuIGZh bHNlOworCSAgICB9CisKKwkgIHN0bXRzLnNhZmVfcHVzaCAodXNlX3N0bXQp OworCSAgaWYgKGdpbXBsZV9hc3NpZ25fcmhzX2NvZGUgKHVzZV9zdG10KSA9 PSBUUlVOQ19ESVZfRVhQUikKKwkgICAgZGl2X3NlZW4gPSB0cnVlOworCSAg ZWxzZSBpZiAoZ2ltcGxlX2Fzc2lnbl9yaHNfY29kZSAodXNlX3N0bXQpID09 IFRSVU5DX01PRF9FWFBSKQorCSAgICBtb2Rfc2VlbiA9IHRydWU7CisJfQor ICAgIH0KKworICBpZiAoIShkaXZfc2VlbiAmJiBtb2Rfc2VlbikpIAorICAg IHJldHVybiBmYWxzZTsKKworICAvKiBDcmVhdGUgbGliY2FsbCB0byBpbnRl cm5hbCBmbiBESVZNT0Q6CisgICAgIGRpdm1vZF90bXAgPSBESVZNT0QgKG9w MSwgb3AyKS4gICovCisKKyAgZ2NhbGwgKmNhbGxfc3RtdCA9IGdpbXBsZV9i dWlsZF9jYWxsX2ludGVybmFsIChJRk5fRElWTU9ELCAyLCBvcDEsIG9wMik7 CisgIHRyZWUgcmVzID0gbWFrZV90ZW1wX3NzYV9uYW1lICgKKwkJYnVpbGRf Y29tcGxleF90eXBlIChUUkVFX1RZUEUgKG9wMSkpLAorCQljYWxsX3N0bXQs ICJkaXZtb2RfdG1wIik7CisgIGdpbXBsZV9jYWxsX3NldF9saHMgKGNhbGxf c3RtdCwgcmVzKTsKKworICAvKiBJbnNlcnQgdGhlIGNhbGwgYmVmb3JlIHRv cF9zdG10LiAgKi8KKyAgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgdG9wX3N0bXRf Z3NpID0gZ3NpX2Zvcl9zdG10ICh0b3Bfc3RtdCk7CisgIGdzaV9pbnNlcnRf YmVmb3JlICgmdG9wX3N0bXRfZ3NpLCBjYWxsX3N0bXQsIEdTSV9TQU1FX1NU TVQpOworCisgIHdpZGVuX211bF9zdGF0cy5kaXZtb2RfY2FsbHNfaW5zZXJ0 ZWQrKzsJCQorCisgIC8qIFVwZGF0ZSBhbGwgc3RhdGVtZW50cyBpbiBzdG10 cy4KKyAgICAgaWYgc3RtdCBpcyBsaHMgPSBvcDEgVFJVTkNfRElWX0VYUFIg b3AyLCBjaGFuZ2UgdG8gbGhzID0gUkVBTFBBUlRfRVhQUjxkaXZtb2RfdG1w PgorICAgICBpZiBzdG10IGlzIGxocyA9IG9wMSBUUlVOQ19NT0RfRVhQUiBv cDIsIGNoYW5nZSB0byBsaHMgPSBJTUFHUEFSVF9FWFBSPGRpdm1vZF90bXA+ LiAgKi8KKworICBib29sIGNmZ19jaGFuZ2VkID0gZmFsc2U7CisgIGZvciAo dW5zaWduZWQgaSA9IDA7IHN0bXRzLml0ZXJhdGUgKGksICZ1c2Vfc3RtdCk7 ICsraSkKKyAgICB7CisgICAgICB0cmVlIG5ld19yaHM7CisKKyAgICAgIHN3 aXRjaCAoZ2ltcGxlX2Fzc2lnbl9yaHNfY29kZSAodXNlX3N0bXQpKQorCXsK KwkgIGNhc2UgVFJVTkNfRElWX0VYUFI6CisJICAgIG5ld19yaHMgPSBmb2xk X2J1aWxkMSAoUkVBTFBBUlRfRVhQUiwgVFJFRV9UWVBFIChvcDEpLCByZXMp OworCSAgICBicmVhazsKKworCSAgY2FzZSBUUlVOQ19NT0RfRVhQUjoKKwkg ICAgbmV3X3JocyA9IGZvbGRfYnVpbGQxIChJTUFHUEFSVF9FWFBSLCBUUkVF X1RZUEUgKG9wMiksIHJlcyk7CisJICAgIGJyZWFrOworCisJICBkZWZhdWx0 OgorCSAgICBnY2NfdW5yZWFjaGFibGUgKCk7CisJfQorCisgICAgICBnaW1w bGVfc3RtdF9pdGVyYXRvciBnc2kgPSBnc2lfZm9yX3N0bXQgKHVzZV9zdG10 KTsKKyAgICAgIGdpbXBsZV9hc3NpZ25fc2V0X3Joc19mcm9tX3RyZWUgKCZn c2ksIG5ld19yaHMpOworICAgICAgdXBkYXRlX3N0bXQgKHVzZV9zdG10KTsK KworICAgICAgaWYgKG1heWJlX2NsZWFuX29yX3JlcGxhY2VfZWhfc3RtdCAo dXNlX3N0bXQsIHVzZV9zdG10KSkKKwljZmdfY2hhbmdlZCA9IHRydWU7Cisg ICAgfQorCisgIHN0bXRzLnJlbGVhc2UgKCk7CisgIHJldHVybiBjZmdfY2hh bmdlZDsKK30gICAgCiAKIC8qIEZpbmQgaW50ZWdlciBtdWx0aXBsaWNhdGlv bnMgd2hlcmUgdGhlIG9wZXJhbmRzIGFyZSBleHRlbmRlZCBmcm9tCiAgICBz bWFsbGVyIHR5cGVzLCBhbmQgcmVwbGFjZSB0aGUgTVVMVF9FWFBSIHdpdGgg YSBXSURFTl9NVUxUX0VYUFIKQEAgLTM4MjgsNiArNDA2MSw4IEBAIHBhc3Nf b3B0aW1pemVfd2lkZW5pbmdfbXVsOjpleGVjdXRlIChmdW5jdGlvbiAqZnVu KQogICBib29sIGNmZ19jaGFuZ2VkID0gZmFsc2U7CiAKICAgbWVtc2V0ICgm d2lkZW5fbXVsX3N0YXRzLCAwLCBzaXplb2YgKHdpZGVuX211bF9zdGF0cykp OworICBjYWxjdWxhdGVfZG9taW5hbmNlX2luZm8gKENESV9ET01JTkFUT1JT KTsKKyAgcmVudW1iZXJfZ2ltcGxlX3N0bXRfdWlkcyAoKTsKIAogICBGT1Jf RUFDSF9CQl9GTiAoYmIsIGZ1bikKICAgICB7CkBAIC0zODYxLDYgKzQwOTYs MTAgQEAgcGFzc19vcHRpbWl6ZV93aWRlbmluZ19tdWw6OmV4ZWN1dGUgKGZ1 bmN0aW9uICpmdW4pCiAJCSAgICBtYXRjaF91YWRkc3ViX292ZXJmbG93ICgm Z3NpLCBzdG10LCBjb2RlKTsKIAkJICBicmVhazsKIAorCQljYXNlIFRSVU5D X01PRF9FWFBSOgorCQkgIGNmZ19jaGFuZ2VkID0gY29udmVydF90b19kaXZt b2QgKGFzX2E8Z2Fzc2lnbiAqPiAoc3RtdCkpOworCQkgIGJyZWFrOworCiAJ CWRlZmF1bHQ6OwogCQl9CiAJICAgIH0KQEAgLTM5MDcsNiArNDE0Niw4IEBA IHBhc3Nfb3B0aW1pemVfd2lkZW5pbmdfbXVsOjpleGVjdXRlIChmdW5jdGlv biAqZnVuKQogCQkJICAgIHdpZGVuX211bF9zdGF0cy5tYWNjc19pbnNlcnRl ZCk7CiAgIHN0YXRpc3RpY3NfY291bnRlcl9ldmVudCAoZnVuLCAiZnVzZWQg bXVsdGlwbHktYWRkcyBpbnNlcnRlZCIsCiAJCQkgICAgd2lkZW5fbXVsX3N0 YXRzLmZtYXNfaW5zZXJ0ZWQpOworICBzdGF0aXN0aWNzX2NvdW50ZXJfZXZl bnQgKGZ1biwgImRpdm1vZCBjYWxscyBpbnNlcnRlZCIsCisJCQkgICAgd2lk ZW5fbXVsX3N0YXRzLmRpdm1vZF9jYWxsc19pbnNlcnRlZCk7CiAKICAgcmV0 dXJuIGNmZ19jaGFuZ2VkID8gVE9ET19jbGVhbnVwX2NmZyA6IDA7CiB9Cg== --94eb2c03caaccd56ae0533aa0d5b--