From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 76357 invoked by alias); 6 Oct 2015 11:41:47 -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 75302 invoked by uid 89); 6 Oct 2015 11:41:46 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.6 required=5.0 tests=AWL,BAYES_00,FREEMAIL_FROM,RCVD_IN_DNSWL_LOW,SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-ob0-f173.google.com Received: from mail-ob0-f173.google.com (HELO mail-ob0-f173.google.com) (209.85.214.173) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Tue, 06 Oct 2015 11:41:39 +0000 Received: by obcgx8 with SMTP id gx8so151413242obc.3 for ; Tue, 06 Oct 2015 04:41:37 -0700 (PDT) MIME-Version: 1.0 X-Received: by 10.182.118.202 with SMTP id ko10mr19645035obb.25.1444131697563; Tue, 06 Oct 2015 04:41:37 -0700 (PDT) Received: by 10.202.191.6 with HTTP; Tue, 6 Oct 2015 04:41:37 -0700 (PDT) In-Reply-To: References: Date: Tue, 06 Oct 2015 11:41:00 -0000 Message-ID: Subject: Re: [PATCH] Unswitching outer loops. From: Yuri Rumyantsev To: Richard Biener Cc: gcc-patches , Igor Zamyatin Content-Type: multipart/mixed; boundary=089e0149c410d7e40405216e1c0e X-SW-Source: 2015-10/txt/msg00540.txt.bz2 --089e0149c410d7e40405216e1c0e Content-Type: text/plain; charset=UTF-8 Content-length: 17303 Richard, Here is updated patch which reflects almost all your remarks: 1. Use ordinary get_loop_body. 2. Delete useless asserts. 3. Use check on iterated loop instead of finite_loop_p. 4. Do not update CFG by adjusting the CONDs condition to always true/false. 5. Add couple tests. ChangeLog: 2015-10-06 Yuri Rumyantsev * tree-ssa-loop-unswitch.c: Include "gimple-iterator.h" and "cfghooks.h", add prototypes for introduced new functions. (tree_ssa_unswitch_loops): Use from innermost loop iterator, move all checks on ability of loop unswitching to tree_unswitch_single_loop; invoke tree_unswitch_single_loop or tree_unswitch_outer_loop depending on innermost loop check. (tree_unswitch_single_loop): Add all required checks on ability of loop unswitching under zero recursive level guard. (tree_unswitch_outer_loop): New function. (find_loop_guard): Likewise. (empty_bb_without_guard_p): Likewise. (used_outside_loop_p): Likewise. (hoist_guard): Likewise. (check_exit_phi): Likewise. gcc/testsuite/ChangeLog: * gcc.dg/loop-unswitch-2.c: New test. * gcc.dg/loop-unswitch-3.c: Likewise. * gcc.dg/loop-unswitch-4.c: Likewise. 2015-10-06 10:59 GMT+03:00 Richard Biener : > On Mon, Oct 5, 2015 at 3:13 PM, Yuri Rumyantsev wrote: >> Thanks Richard. >> I'd like to answer on your last comment related to using of exit edge >> argument for edge that skips loop. >> Let's consider the following test-case: >> >> #include >> #define N 32 >> float *foo(int ustride, int size, float *src) >> { >> float *buffer, *p; >> int i, k; >> >> if (!src) >> return NULL; >> >> buffer = (float *) malloc(N * size * sizeof(float)); >> >> if(buffer) >> for(i=0, p=buffer; i> for(k=0; k> *p++ = src[k]; >> >> return buffer; >> } >> >> Before adding new edge we have in post-header bb: >> : >> # _6 = PHI <0B(8), buffer_20(16)> >> return _6; >> >> It is clear that we must preserve function semantic and transform it to >> _6 = PHI <0B(12), buffer_19(9), buffer_19(4)> > > Ah, yeah. I was confusing the loop exit of the inner vs. the outer loop. > > Richard. > >> >> 2015-10-05 13:57 GMT+03:00 Richard Biener : >>> On Wed, Sep 30, 2015 at 12:46 PM, Yuri Rumyantsev wrote: >>>> Hi Richard, >>>> >>>> I re-designed outer loop unswitching using basic idea of 23855 patch - >>>> hoist invariant guard if loop is empty without guard. Note that this >>>> was added to loop unswitching pass with simple modifications - using >>>> another loop iterator etc. >>>> >>>> Bootstrap and regression testing did not show any new failures. >>>> What is your opinion? >>> >>> Overall it looks good. Some comments below - a few more testcases would >>> be nice as well. >>> >>> + /* Loop must not be infinite. */ >>> + if (!finite_loop_p (loop)) >>> + return false; >>> >>> why's that? >>> >>> + body = get_loop_body_in_dom_order (loop); >>> + for (i = 0; i < loop->num_nodes; i++) >>> + { >>> + if (body[i]->loop_father != loop) >>> + continue; >>> + if (!empty_bb_without_guard_p (loop, body[i])) >>> >>> I wonder if there is a better way to iterate over the interesting >>> blocks and PHIs >>> we need to check for side-effects (and thus we maybe can avoid gathering >>> the loop in DOM order). >>> >>> + FOR_EACH_SSA_TREE_OPERAND (name, stmt, op_iter, SSA_OP_DEF) >>> + { >>> + if (may_be_used_outside >>> >>> may_be_used_outside can be hoisted above the loop. I wonder if we can take >>> advantage of loop-closed SSA form here (and the fact we have a single exit >>> from the loop). Iterating over exit dest PHIs and determining whether the >>> exit edge DEF is inside the loop part it may not be should be enough. >>> >>> + gcc_assert (single_succ_p (pre_header)); >>> >>> that should be always true. >>> >>> + gsi_remove (&gsi, false); >>> + bb = guard->dest; >>> + remove_edge (guard); >>> + /* Update dominance for destination of GUARD. */ >>> + if (EDGE_COUNT (bb->preds) == 0) >>> + { >>> + basic_block s_bb; >>> + gcc_assert (single_succ_p (bb)); >>> + s_bb = single_succ (bb); >>> + delete_basic_block (bb); >>> + if (single_pred_p (s_bb)) >>> + set_immediate_dominator (CDI_DOMINATORS, s_bb, single_pred (s_bb)); >>> >>> all this massaging should be simplified by leaving it to CFG cleanup by >>> simply adjusting the CONDs condition to always true/false. There is >>> gimple_cond_make_{true,false} () for this (would be nice to have a variant >>> taking a bool). >>> >>> + new_edge = make_edge (pre_header, exit->dest, flags); >>> + if (fix_dom_of_exit) >>> + set_immediate_dominator (CDI_DOMINATORS, exit->dest, pre_header); >>> + update_stmt (gsi_stmt (gsi)); >>> >>> the update_stmt should be not necessary, it's done by gsi_insert_after already. >>> >>> + /* Add NEW_ADGE argument for all phi in post-header block. */ >>> + bb = exit->dest; >>> + for (gphi_iterator gsi = gsi_start_phis (bb); >>> + !gsi_end_p (gsi); gsi_next (&gsi)) >>> + { >>> + gphi *phi = gsi.phi (); >>> + /* edge_iterator ei; */ >>> + tree arg; >>> + if (virtual_operand_p (gimple_phi_result (phi))) >>> + { >>> + arg = PHI_ARG_DEF_FROM_EDGE (phi, loop_preheader_edge (loop)); >>> + add_phi_arg (phi, arg, new_edge, UNKNOWN_LOCATION); >>> + } >>> + else >>> + { >>> + /* Use exit edge argument. */ >>> + arg = PHI_ARG_DEF_FROM_EDGE (phi, exit); >>> + add_phi_arg (phi, arg, new_edge, UNKNOWN_LOCATION); >>> >>> Hum. How is it ok to use the exit edge argument for the edge that skips >>> the loop? Why can't you always use the pre-header edge value? >>> That is, if we have >>> >>> for(i=0;i>> { >>> if (n > 0) >>> { >>> for (;;) >>> { >>> } >>> } >>> } >>> ... = i; >>> >>> then i is used after the loop and the correct value to use if >>> n > 0 is false is '0'. Maybe this way we can also relax >>> what check_exit_phi does? IMHO the only restriction is >>> if sth defined inside the loop before the header check for >>> the inner loop is used after the loop. >>> >>> Thanks, >>> Richard. >>> >>>> Thanks. >>>> >>>> ChangeLog: >>>> 2015-09-30 Yuri Rumyantsev >>>> >>>> * tree-ssa-loop-unswitch.c: Include "gimple-iterator.h" and >>>> "cfghooks.h", add prototypes for introduced new functions. >>>> (tree_ssa_unswitch_loops): Use from innermost loop iterator, move all >>>> checks on ability of loop unswitching to tree_unswitch_single_loop; >>>> invoke tree_unswitch_single_loop or tree_unswitch_outer_loop depending >>>> on innermost loop check. >>>> (tree_unswitch_single_loop): Add all required checks on ability of >>>> loop unswitching under zero recursive level guard. >>>> (tree_unswitch_outer_loop): New function. >>>> (find_loop_guard): Likewise. >>>> (empty_bb_without_guard_p): Likewise. >>>> (used_outside_loop_p): Likewise. >>>> (hoist_guard): Likewise. >>>> (check_exit_phi): Likewise. >>>> >>>> gcc/testsuite/ChangeLog: >>>> * gcc.dg/loop-unswitch-2.c: New test. >>>> >>>> 2015-09-16 11:26 GMT+03:00 Richard Biener : >>>>> Yeah, as said, the patch wasn't fully ready and it also felt odd to do >>>>> this hoisting in loop header copying. Integrating it >>>>> with LIM would be a better fit eventually. >>>>> >>>>> Note that we did agree to go forward with your original patch just >>>>> making it more "generically" perform outer loop >>>>> unswitching. Did you explore that idea further? >>>>> >>>>> >>>>> >>>>> On Tue, Sep 15, 2015 at 6:00 PM, Yuri Rumyantsev wrote: >>>>>> Thanks Richard. >>>>>> >>>>>> I found one more issue that could not be fixed simply. In 23855 you >>>>>> consider the following test-case: >>>>>> void foo(int *ie, int *je, double *x) >>>>>> { >>>>>> int i, j; >>>>>> for (j=0; j<*je; ++j) >>>>>> for (i=0; i<*ie; ++i) >>>>>> x[i+j] = 0.0; >>>>>> } >>>>>> and proposed to hoist up a check on *ie out of loop. It requires >>>>>> memref alias analysis since in general x and ie can alias (if their >>>>>> types are compatible - int *ie & int * x). Such analysis is performed >>>>>> by pre or lim passes. Without such analysis we can not hoist a test on >>>>>> non-zero for *ie out of loop using 238565 patch. >>>>>> The second concern is that proposed copy header algorithm changes >>>>>> loop structure significantly and it is not accepted by vectorizer >>>>>> since latch is not empty (such transformation assumes loop peeling for >>>>>> one iteration. So I can propose to implement simple guard hoisting >>>>>> without copying header and tail blocks (if it is possible). >>>>>> >>>>>> I will appreciate you for any advice or help since without such >>>>>> hoisting we are not able to perform outer loop vectorization for >>>>>> important benchmark. >>>>>> and >>>>>> >>>>>> 2015-09-15 14:22 GMT+03:00 Richard Biener : >>>>>>> On Thu, Sep 3, 2015 at 6:32 PM, Yuri Rumyantsev wrote: >>>>>>>> Hi Richard, >>>>>>>> >>>>>>>> I started learning, tuning and debugging patch proposed in 23855 and >>>>>>>> discovered thta it does not work properly. >>>>>>>> So I wonder is it tested patch and it should work? >>>>>>> >>>>>>> I don't remember, but as it wasn't committed it certainly wasn't ready. >>>>>>> >>>>>>>> Should it accept for hoisting the following loop nest >>>>>>>> for (i=0; i>>>>>>> s = 0; >>>>>>>> for (j=0; j>>>>>>> s += a[i] * b[j]; >>>>>>>> c[i] = s; >>>>>>>> } >>>>>>>> Note that i-loop will nit be empty if m is equal to 0. >>>>>>> >>>>>>> if m is equal to 0 then we still have the c[i] = s store, no? Of course >>>>>>> we could unswitch the outer loop on m == 0 but simple hoisting wouldn't work. >>>>>>> >>>>>>> Richard. >>>>>>> >>>>>>>> 2015-08-03 10:27 GMT+03:00 Richard Biener : >>>>>>>>> On Fri, Jul 31, 2015 at 1:17 PM, Yuri Rumyantsev wrote: >>>>>>>>>> Hi Richard, >>>>>>>>>> >>>>>>>>>> I learned your updated patch for 23825 and it is more general in >>>>>>>>>> comparison with my. >>>>>>>>>> I'd like to propose you a compromise - let's consider my patch only >>>>>>>>>> for force-vectorize outer loop only to allow outer-loop >>>>>>>>>> vecctorization. >>>>>>>>> >>>>>>>>> I don't see why we should special-case that if the approach in 23825 >>>>>>>>> is sensible. >>>>>>>>> >>>>>>>>>> Note that your approach will not hoist invariant >>>>>>>>>> guards if loops contains something else except for inner-loop, i.e. it >>>>>>>>>> won't be empty for taken branch. >>>>>>>>> >>>>>>>>> Yes, it does not perform unswitching but guard hoisting. Note that this >>>>>>>>> is originally Zdenek Dvoraks patch. >>>>>>>>> >>>>>>>>>> I also would like to answer on your last question - CFG cleanup is >>>>>>>>>> invoked to perform deletion of single-argument phi nodes from tail >>>>>>>>>> block through substitution - such phi's prevent outer-loop >>>>>>>>>> vectorization. But it is clear that such transformation can be done >>>>>>>>>> other pass. >>>>>>>>> >>>>>>>>> Hmm, I wonder why the copy_prop pass after unswitching does not >>>>>>>>> get rid of them? >>>>>>>>> >>>>>>>>>> What is your opinion? >>>>>>>>> >>>>>>>>> My opinion is that if we want to enhance unswitching to catch this >>>>>>>>> (or similar) cases then we should make it a lot more general than >>>>>>>>> your pattern-matching approach. I see nothing that should prevent >>>>>>>>> us from considering unswitching non-innermost loops in general. >>>>>>>>> It should be only a cost consideration to not do non-innermost loop >>>>>>>>> unswitching (in addition to maybe a --param specifying the maximum >>>>>>>>> depth of a loop nest to unswitch). >>>>>>>>> >>>>>>>>> So my first thought when seeing your patch still holds - the patch >>>>>>>>> looks very much too specific. >>>>>>>>> >>>>>>>>> Richard. >>>>>>>>> >>>>>>>>>> Yuri. >>>>>>>>>> >>>>>>>>>> 2015-07-28 13:50 GMT+03:00 Richard Biener : >>>>>>>>>>> On Thu, Jul 23, 2015 at 4:45 PM, Yuri Rumyantsev wrote: >>>>>>>>>>>> Hi Richard, >>>>>>>>>>>> >>>>>>>>>>>> I checked that both test-cases from 23855 are sucessfully unswitched >>>>>>>>>>>> by proposed patch. I understand that it does not catch deeper loop >>>>>>>>>>>> nest as >>>>>>>>>>>> for (i=0; i<10; i++) >>>>>>>>>>>> for (j=0;j>>>>>>>>>>> for (k=0;k<20;k++) >>>>>>>>>>>> ... >>>>>>>>>>>> but duplication of middle-loop does not look reasonable. >>>>>>>>>>>> >>>>>>>>>>>> Here is dump for your second test-case: >>>>>>>>>>>> >>>>>>>>>>>> void foo(int *ie, int *je, double *x) >>>>>>>>>>>> { >>>>>>>>>>>> int i, j; >>>>>>>>>>>> for (j=0; j<*je; ++j) >>>>>>>>>>>> for (i=0; i<*ie; ++i) >>>>>>>>>>>> x[i+j] = 0.0; >>>>>>>>>>>> } >>>>>>>>>>>> grep -i unswitch t6.c.119t.unswitch >>>>>>>>>>>> ;; Unswitching outer loop >>>>>>>>>>> >>>>>>>>>>> I was saying that why go with a limited approach when a patch (in >>>>>>>>>>> unknown state...) >>>>>>>>>>> is available that does it more generally? Also unswitching is quite >>>>>>>>>>> expensive compared >>>>>>>>>>> to "moving" the invariant condition. >>>>>>>>>>> >>>>>>>>>>> In your patch: >>>>>>>>>>> >>>>>>>>>>> + if (!nloop->force_vectorize) >>>>>>>>>>> + nloop->force_vectorize = true; >>>>>>>>>>> + if (loop->safelen != 0) >>>>>>>>>>> + nloop->safelen = loop->safelen; >>>>>>>>>>> >>>>>>>>>>> I see no guard on force_vectorize so = true looks bogus here. Please just use >>>>>>>>>>> copy_loop_info. >>>>>>>>>>> >>>>>>>>>>> + if (integer_nonzerop (cond_new)) >>>>>>>>>>> + gimple_cond_set_condition_from_tree (cond_stmt, boolean_true_node); >>>>>>>>>>> + else if (integer_zerop (cond_new)) >>>>>>>>>>> + gimple_cond_set_condition_from_tree (cond_stmt, boolean_false_node); >>>>>>>>>>> >>>>>>>>>>> gimple_cond_make_true/false (cond_stmt); >>>>>>>>>>> >>>>>>>>>>> btw, seems odd that we have to recompute which loop is the true / false variant >>>>>>>>>>> when we just fed a guard condition to loop_version. Can't we statically >>>>>>>>>>> determine whether loop or nloop has the in-loop condition true or false? >>>>>>>>>>> >>>>>>>>>>> + /* Clean-up cfg to remove useless one-argument phi in exit block of >>>>>>>>>>> + outer-loop. */ >>>>>>>>>>> + cleanup_tree_cfg (); >>>>>>>>>>> >>>>>>>>>>> I know unswitching is already O(number-of-unswitched-loops * size-of-function) >>>>>>>>>>> because it updates SSA form after each individual unswitching (and it does that >>>>>>>>>>> because it invokes itself recursively on unswitched loops). But do you really >>>>>>>>>>> need to invoke CFG cleanup here? >>>>>>>>>>> >>>>>>>>>>> Richard. >>>>>>>>>>> >>>>>>>>>>>> Yuri. >>>>>>>>>>>> >>>>>>>>>>>> 2015-07-14 14:06 GMT+03:00 Richard Biener : >>>>>>>>>>>>> On Fri, Jul 10, 2015 at 12:02 PM, Yuri Rumyantsev wrote: >>>>>>>>>>>>>> Hi All, >>>>>>>>>>>>>> >>>>>>>>>>>>>> Here is presented simple transformation which tries to hoist out of >>>>>>>>>>>>>> outer-loop a check on zero trip count for inner-loop. This is very >>>>>>>>>>>>>> restricted transformation since it accepts outer-loops with very >>>>>>>>>>>>>> simple cfg, as for example: >>>>>>>>>>>>>> acc = 0; >>>>>>>>>>>>>> for (i = 1; i <= m; i++) { >>>>>>>>>>>>>> for (j = 0; j < n; j++) >>>>>>>>>>>>>> if (l[j] == i) { v[j] = acc; acc++; }; >>>>>>>>>>>>>> acc <<= 1; >>>>>>>>>>>>>> } >>>>>>>>>>>>>> >>>>>>>>>>>>>> Note that degenerative outer loop (without inner loop) will be >>>>>>>>>>>>>> completely deleted as dead code. >>>>>>>>>>>>>> The main goal of this transformation was to convert outer-loop to form >>>>>>>>>>>>>> accepted by outer-loop vectorization (such test-case is also included >>>>>>>>>>>>>> to patch). >>>>>>>>>>>>>> >>>>>>>>>>>>>> Bootstrap and regression testing did not show any new failures. >>>>>>>>>>>>>> >>>>>>>>>>>>>> Is it OK for trunk? >>>>>>>>>>>>> >>>>>>>>>>>>> I think this is >>>>>>>>>>>>> >>>>>>>>>>>>> https://gcc.gnu.org/bugzilla/show_bug.cgi?id=23855 >>>>>>>>>>>>> >>>>>>>>>>>>> as well. It has a patch adding a invariant loop guard hoisting >>>>>>>>>>>>> phase to loop-header copying. Yeah, it needs updating to >>>>>>>>>>>>> trunk again I suppose. It's always non-stage1 when I come >>>>>>>>>>>>> back to that patch. >>>>>>>>>>>>> >>>>>>>>>>>>> Your patch seems to be very specific and only handles outer >>>>>>>>>>>>> loops of innermost loops. >>>>>>>>>>>>> >>>>>>>>>>>>> Richard. >>>>>>>>>>>>> >>>>>>>>>>>>>> ChangeLog: >>>>>>>>>>>>>> 2015-07-10 Yuri Rumyantsev >>>>>>>>>>>>>> >>>>>>>>>>>>>> * tree-ssa-loop-unswitch.c: Include "tree-cfgcleanup.h" and >>>>>>>>>>>>>> "gimple-iterator.h", add prototype for tree_unswitch_outer_loop. >>>>>>>>>>>>>> (tree_ssa_unswitch_loops): Add invoke of tree_unswitch_outer_loop. >>>>>>>>>>>>>> (tree_unswitch_outer_loop): New function. >>>>>>>>>>>>>> >>>>>>>>>>>>>> gcc/testsuite/ChangeLog: >>>>>>>>>>>>>> * gcc.dg/tree-ssa/unswitch-outer-loop-1.c: New test. >>>>>>>>>>>>>> * gcc.dg/vect/vect-outer-simd-3.c: New test. --089e0149c410d7e40405216e1c0e Content-Type: application/octet-stream; name="patch.update" Content-Disposition: attachment; filename="patch.update" Content-Transfer-Encoding: base64 X-Attachment-Id: f_iffapxq20 Content-length: 22473 ZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLmRnL2xvb3AtdW5zd2l0 Y2gtMi5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvbG9vcC11bnN3aXRjaC0y LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGY5MWQy MAotLS0gL2Rldi9udWxsCisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRnL2xv b3AtdW5zd2l0Y2gtMi5jCkBAIC0wLDAgKzEsMTYgQEAKKy8qIHsgZGctZG8g Y29tcGlsZSB9ICovCisvKiB7IGRnLW9wdGlvbnMgIi1PMiAtZnVuc3dpdGNo LWxvb3BzIC1mZHVtcC10cmVlLXVuc3dpdGNoLWRldGFpbHMiIH0gKi8KKwor dm9pZCBmb28gKGZsb2F0ICoqYSwgZmxvYXQgKipiLCBmbG9hdCAqYywgaW50 IG4sIGludCBtLCBpbnQgbCkKK3sKKyAgaW50IGksaixrOworICBmbG9hdCBz OworICBmb3IgKGk9MDsgaTxsOyBpKyspCisgICAgeworICAgICAgZm9yIChq PTA7IGo8bjsgaisrKQorCWZvciAoaz0wOyBrPG07IGsrKykKKwkgIGNbaV0g Kz0gYVtpXVtrXSAqIGJba11bal07CisgICAgfQorfQorCisvKiB7IGRnLWZp bmFsIHsgc2Nhbi10cmVlLWR1bXAtdGltZXMgImd1YXJkIGhvaXN0ZWQiIDIg InVuc3dpdGNoIiB9IH0gKi8KZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUv Z2NjLmRnL2xvb3AtdW5zd2l0Y2gtMy5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2Mu ZGcvbG9vcC11bnN3aXRjaC0zLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMC4uMGRkZjU0YQotLS0gL2Rldi9udWxsCisrKyBiL2djYy90 ZXN0c3VpdGUvZ2NjLmRnL2xvb3AtdW5zd2l0Y2gtMy5jCkBAIC0wLDAgKzEs MjUgQEAKKy8qIHsgZGctZG8gY29tcGlsZSB9ICovCisvKiB7IGRnLW9wdGlv bnMgIi1PMiAtZnVuc3dpdGNoLWxvb3BzIC1mZHVtcC10cmVlLXVuc3dpdGNo LWRldGFpbHMiIH0gKi8KKworI2luY2x1ZGUgPHN0ZGxpYi5oPgorI2RlZmlu ZSBOIDMyCitmbG9hdCAqZm9vKGludCB1c3RyaWRlLCBpbnQgc2l6ZSwgZmxv YXQgKnNyYykKK3sKKyAgIGZsb2F0ICpidWZmZXIsICpwOworICAgaW50IGks IGs7CisKKyAgIGlmICghc3JjKQorICAgIHJldHVybiBOVUxMOworCisgICBi dWZmZXIgPSAoZmxvYXQgKikgbWFsbG9jKE4gKiBzaXplICogc2l6ZW9mKGZs b2F0KSk7CisKKyAgIGlmKGJ1ZmZlcikgCisgICAgICBmb3IoaT0wLCBwPWJ1 ZmZlcjsgaTxOOyBpKyssIHNyYys9dXN0cmlkZSkKKwlmb3Ioaz0wOyBrPHNp emU7IGsrKykKKwkgICpwKysgPSBzcmNba107CisKKyAgIHJldHVybiBidWZm ZXI7Cit9CisKKy8qIHsgZGctZmluYWwgeyBzY2FuLXRyZWUtZHVtcC10aW1l cyAiZ3VhcmQgaG9pc3RlZCIgMSAidW5zd2l0Y2giIH0gfSAqLyAKKwpkaWZm IC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvbG9vcC11bnN3aXRjaC00 LmMgYi9nY2MvdGVzdHN1aXRlL2djYy5kZy9sb29wLXVuc3dpdGNoLTQuYwpu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lNGE3ZjJlCi0t LSAvZGV2L251bGwKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvbG9vcC11 bnN3aXRjaC00LmMKQEAgLTAsMCArMSw1MSBAQAorLyogeyBkZy1kbyBydW4g fSAqLworLyogeyBkZy1vcHRpb25zICItTzIgLWZ1bnN3aXRjaC1sb29wcyIg fSAqLworCisjaW5jbHVkZSA8c3RkbGliLmg+CitfX2F0dHJpYnV0ZV9fICgo bm9pbmxpbmUpKQordm9pZCBmb28gKGZsb2F0ICoqYSwgZmxvYXQgKipiLCBm bG9hdCAqYywgaW50IG4sIGludCBtLCBpbnQgbCkKK3sKKyAgaW50IGksaixr OworICBmbG9hdCBzOworICBmb3IgKGk9MDsgaTxsOyBpKyspCisgICAgZm9y IChqPTA7IGo8bjsgaisrKQorICAgICAgZm9yIChrPTA7IGs8bTsgaysrKQor CWNbaV0gKz0gYVtpXVtrXSAqIGJba11bal07Cit9CisKK2ludCBtYWluKCkK K3sKKyAgY29uc3QgaW50IE4gPSAzMjsKKyAgZmxvYXQgKiphcjEsICoqYXIy OworICBmbG9hdCAqcmVzOworICBpbnQgaSwgajsKKyAgYXIxID0gKGZsb2F0 ICoqKW1hbGxvYyAoTiAqIHNpemVvZiAoZmxvYXQqKSk7CisgIGFyMiA9IChm bG9hdCAqKiltYWxsb2MgKE4gKiBzaXplb2YgKGZsb2F0KikpOworICByZXMg PSAoZmxvYXQgKiltYWxsb2MoIE4gKiBzaXplb2YgKGZsb2F0KSk7CisgIGZv ciAoaT0wOyBpPE47IGkrKykKKyAgICB7CisgICAgICBhcjFbaV0gPSAoZmxv YXQqKW1hbGxvYyAoTiAqIHNpemVvZiAoZmxvYXQpKTsKKyAgICAgIGFyMltp XSA9IChmbG9hdCopbWFsbG9jIChOICogc2l6ZW9mIChmbG9hdCkpOworICAg IH0KKyAgZm9yIChpPTA7IGk8TjsgaSsrKQorICAgIHsKKyAgICAgIGZvciAo aj0wOyBqPE47IGorKykKKwl7CisJICBhcjFbaV1bal0gPSAyLjBmOworCSAg YXIyW2ldW2pdID0gMS41ZjsKKwl9CisgICAgICByZXNbaV0gPSAwLjBmOwor ICAgIH0KKyAgZm9vIChhcjEsIGFyMiwgcmVzLCBOLCBOLCBOKTsKKyAgZm9y IChpPTA7IGk8TjsgaSsrKQorICAgIGlmIChyZXNbaV0gIT0gMzA3Mi4wZikK KyAgICAgIGFib3J0KCk7CisgIGZvciAoaT0wOyBpPE47IGkrKykKKyAgICBy ZXNbaV0gPSAwLjBmOworICBmb28gKGFyMSwgYXIyLCByZXMsIE4sIDAsIE4p OworICBmb3IgKGk9MDsgaTxOOyBpKyspCisgICAgaWYgKHJlc1tpXSAhPSAw LjBmKQorICAgICAgYWJvcnQoKTsKKyAgcmV0dXJuIDA7Cit9CisKZGlmZiAt LWdpdCBhL2djYy90cmVlLXNzYS1sb29wLXVuc3dpdGNoLmMgYi9nY2MvdHJl ZS1zc2EtbG9vcC11bnN3aXRjaC5jCmluZGV4IGEyNzM2MzguLjc5MWFlYTIg MTAwNjQ0Ci0tLSBhL2djYy90cmVlLXNzYS1sb29wLXVuc3dpdGNoLmMKKysr IGIvZ2NjL3RyZWUtc3NhLWxvb3AtdW5zd2l0Y2guYwpAQCAtMzksNiArMzks OCBAQCBhbG9uZyB3aXRoIEdDQzsgc2VlIHRoZSBmaWxlIENPUFlJTkczLiAg SWYgbm90IHNlZQogI2luY2x1ZGUgInBhcmFtcy5oIgogI2luY2x1ZGUgInRy ZWUtcGFzcy5oIgogI2luY2x1ZGUgInRyZWUtaW5saW5lLmgiCisjaW5jbHVk ZSAiZ2ltcGxlLWl0ZXJhdG9yLmgiCisjaW5jbHVkZSAiY2ZnaG9va3MuaCIK IAogLyogVGhpcyBmaWxlIGltcGxlbWVudHMgdGhlIGxvb3AgdW5zd2l0Y2hp bmcsIGkuZS4gdHJhbnNmb3JtYXRpb24gb2YgbG9vcHMgbGlrZQogCkBAIC03 OSw2ICs4MSwxMiBAQCBhbG9uZyB3aXRoIEdDQzsgc2VlIHRoZSBmaWxlIENP UFlJTkczLiAgSWYgbm90IHNlZQogc3RhdGljIHN0cnVjdCBsb29wICp0cmVl X3Vuc3dpdGNoX2xvb3AgKHN0cnVjdCBsb29wICosIGJhc2ljX2Jsb2NrLCB0 cmVlKTsKIHN0YXRpYyBib29sIHRyZWVfdW5zd2l0Y2hfc2luZ2xlX2xvb3Ag KHN0cnVjdCBsb29wICosIGludCk7CiBzdGF0aWMgdHJlZSB0cmVlX21heV91 bnN3aXRjaF9vbiAoYmFzaWNfYmxvY2ssIHN0cnVjdCBsb29wICopOworc3Rh dGljIGJvb2wgdHJlZV91bnN3aXRjaF9vdXRlcl9sb29wIChzdHJ1Y3QgbG9v cCAqKTsKK3N0YXRpYyBlZGdlIGZpbmRfbG9vcF9ndWFyZCAoc3RydWN0IGxv b3AgKik7CitzdGF0aWMgYm9vbCBlbXB0eV9iYl93aXRob3V0X2d1YXJkX3Ag KHN0cnVjdCBsb29wICosIGJhc2ljX2Jsb2NrKTsKK3N0YXRpYyBib29sIHVz ZWRfb3V0c2lkZV9sb29wX3AgKHN0cnVjdCBsb29wICosIHRyZWUpOworc3Rh dGljIHZvaWQgaG9pc3RfZ3VhcmQgKHN0cnVjdCBsb29wICosIGVkZ2UpOwor c3RhdGljIGJvb2wgY2hlY2tfZXhpdF9waGkgKHN0cnVjdCBsb29wICopOwog CiAvKiBNYWluIGVudHJ5IHBvaW50LiAgUGVyZm9ybSBsb29wIHVuc3dpdGNo aW5nIG9uIGFsbCBzdWl0YWJsZSBsb29wcy4gICovCiAKQEAgLTg3LDQyICs5 NSwxNSBAQCB0cmVlX3NzYV91bnN3aXRjaF9sb29wcyAodm9pZCkKIHsKICAg c3RydWN0IGxvb3AgKmxvb3A7CiAgIGJvb2wgY2hhbmdlZCA9IGZhbHNlOwot ICBIT1NUX1dJREVfSU5UIGl0ZXJhdGlvbnM7CiAKLSAgLyogR28gdGhyb3Vn aCBpbm5lciBsb29wcyAob25seSBvcmlnaW5hbCBvbmVzKS4gICovCi0gIEZP Ul9FQUNIX0xPT1AgKGxvb3AsIExJX09OTFlfSU5ORVJNT1NUKQorICAvKiBH byB0aHJvdWdoIGFsbCBsb29wcyBzdGFydGluZyBmcm9tIGlubmVybW9zdC4g ICovCisgIEZPUl9FQUNIX0xPT1AgKGxvb3AsIExJX0ZST01fSU5ORVJNT1NU KQogICAgIHsKLSAgICAgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBfZmxhZ3Mg JiBUREZfREVUQUlMUykpCi0gICAgICAgIGZwcmludGYgKGR1bXBfZmlsZSwg Ijs7IENvbnNpZGVyaW5nIGxvb3AgJWRcbiIsIGxvb3AtPm51bSk7Ci0KLSAg ICAgIC8qIERvIG5vdCB1bnN3aXRjaCBpbiBjb2xkIHJlZ2lvbnMuICovCi0g ICAgICBpZiAob3B0aW1pemVfbG9vcF9mb3Jfc2l6ZV9wIChsb29wKSkKLSAg ICAgICAgewotICAgICAgICAgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBfZmxh Z3MgJiBUREZfREVUQUlMUykpCi0gICAgICAgICAgICBmcHJpbnRmIChkdW1w X2ZpbGUsICI7OyBOb3QgdW5zd2l0Y2hpbmcgY29sZCBsb29wc1xuIik7Ci0g ICAgICAgICAgY29udGludWU7Ci0gICAgICAgIH0KLQotICAgICAgLyogVGhl IGxvb3Agc2hvdWxkIG5vdCBiZSB0b28gbGFyZ2UsIHRvIGxpbWl0IGNvZGUg Z3Jvd3RoLiAqLwotICAgICAgaWYgKHRyZWVfbnVtX2xvb3BfaW5zbnMgKGxv b3AsICZlbmlfc2l6ZV93ZWlnaHRzKQotICAgICAgICAgID4gKHVuc2lnbmVk KSBQQVJBTV9WQUxVRSAoUEFSQU1fTUFYX1VOU1dJVENIX0lOU05TKSkKLSAg ICAgICAgewotICAgICAgICAgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBfZmxh Z3MgJiBUREZfREVUQUlMUykpCi0gICAgICAgICAgICBmcHJpbnRmIChkdW1w X2ZpbGUsICI7OyBOb3QgdW5zd2l0Y2hpbmcsIGxvb3AgdG9vIGJpZ1xuIik7 Ci0gICAgICAgICAgY29udGludWU7Ci0gICAgICAgIH0KLQotICAgICAgLyog SWYgdGhlIGxvb3AgaXMgbm90IGV4cGVjdGVkIHRvIGl0ZXJhdGUsIHRoZXJl IGlzIG5vIG5lZWQKLQkgZm9yIHVuc3dpdGNoaW5nLiAgKi8KLSAgICAgIGl0 ZXJhdGlvbnMgPSBlc3RpbWF0ZWRfbG9vcF9pdGVyYXRpb25zX2ludCAobG9v cCk7Ci0gICAgICBpZiAoaXRlcmF0aW9ucyA+PSAwICYmIGl0ZXJhdGlvbnMg PD0gMSkKLQl7Ci0gICAgICAgICAgaWYgKGR1bXBfZmlsZSAmJiAoZHVtcF9m bGFncyAmIFRERl9ERVRBSUxTKSkKLSAgICAgICAgICAgIGZwcmludGYgKGR1 bXBfZmlsZSwgIjs7IE5vdCB1bnN3aXRjaGluZywgbG9vcCBpcyBub3QgZXhw ZWN0ZWQgdG8gaXRlcmF0ZVxuIik7Ci0gICAgICAgICAgY29udGludWU7Ci0J fQotCi0gICAgICBjaGFuZ2VkIHw9IHRyZWVfdW5zd2l0Y2hfc2luZ2xlX2xv b3AgKGxvb3AsIDApOworICAgICAgaWYgKCFsb29wLT5pbm5lcikKKwkvKiBV bnN3aXRjaCBpbm5lcm1vc3QgbG9vcC4gICovCisJY2hhbmdlZCB8PSB0cmVl X3Vuc3dpdGNoX3NpbmdsZV9sb29wIChsb29wLCAwKTsKKyAgICAgIGVsc2UK KwljaGFuZ2VkIHw9IHRyZWVfdW5zd2l0Y2hfb3V0ZXJfbG9vcCAobG9vcCk7 CiAgICAgfQogCiAgIGlmIChjaGFuZ2VkKQpAQCAtMjE2LDYgKzE5NywzOSBA QCB0cmVlX3Vuc3dpdGNoX3NpbmdsZV9sb29wIChzdHJ1Y3QgbG9vcCAqbG9v cCwgaW50IG51bSkKICAgdHJlZSBjb25kID0gTlVMTF9UUkVFOwogICBnaW1w bGUgc3RtdDsKICAgYm9vbCBjaGFuZ2VkID0gZmFsc2U7CisgIEhPU1RfV0lE RV9JTlQgaXRlcmF0aW9uczsKKworICAvKiBQZXJmb3JtIGluaXRpYWwgdGVz dHMgaWYgdW5zd2l0Y2ggaXMgZWxpZ2libGUuICAqLworICBpZiAobnVtID09 IDApCisgICAgeworICAgICAgLyogRG8gbm90IHVuc3dpdGNoIGluIGNvbGQg cmVnaW9ucy4gKi8KKyAgICAgIGlmIChvcHRpbWl6ZV9sb29wX2Zvcl9zaXpl X3AgKGxvb3ApKQorCXsKKwkgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBfZmxh Z3MgJiBUREZfREVUQUlMUykpCisJICAgIGZwcmludGYgKGR1bXBfZmlsZSwg Ijs7IE5vdCB1bnN3aXRjaGluZyBjb2xkIGxvb3BzXG4iKTsKKwkgIHJldHVy biBmYWxzZTsKKwl9CisKKyAgICAgIC8qIFRoZSBsb29wIHNob3VsZCBub3Qg YmUgdG9vIGxhcmdlLCB0byBsaW1pdCBjb2RlIGdyb3d0aC4gKi8KKyAgICAg IGlmICh0cmVlX251bV9sb29wX2luc25zIChsb29wLCAmZW5pX3NpemVfd2Vp Z2h0cykKKwkgID4gKHVuc2lnbmVkKSBQQVJBTV9WQUxVRSAoUEFSQU1fTUFY X1VOU1dJVENIX0lOU05TKSkKKwl7CisJICBpZiAoZHVtcF9maWxlICYmIChk dW1wX2ZsYWdzICYgVERGX0RFVEFJTFMpKQorCSAgICBmcHJpbnRmIChkdW1w X2ZpbGUsICI7OyBOb3QgdW5zd2l0Y2hpbmcsIGxvb3AgdG9vIGJpZ1xuIik7 CisJICByZXR1cm4gZmFsc2U7CisJfQorCisgICAgICAvKiBJZiB0aGUgbG9v cCBpcyBub3QgZXhwZWN0ZWQgdG8gaXRlcmF0ZSwgdGhlcmUgaXMgbm8gbmVl ZAorCSBmb3IgdW5zd2l0Y2hpbmcuICAqLworICAgICAgaXRlcmF0aW9ucyA9 IGVzdGltYXRlZF9sb29wX2l0ZXJhdGlvbnNfaW50IChsb29wKTsKKyAgICAg IGlmIChpdGVyYXRpb25zID49IDAgJiYgaXRlcmF0aW9ucyA8PSAxKQorCXsK KwkgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBfZmxhZ3MgJiBUREZfREVUQUlM UykpCisJICAgIGZwcmludGYgKGR1bXBfZmlsZSwgIjs7IE5vdCB1bnN3aXRj aGluZywgbG9vcCBpcyBub3QgZXhwZWN0ZWQiCisJCSAgICAgIiB0byBpdGVy YXRlXG4iKTsKKwkgIHJldHVybiBmYWxzZTsKKwl9CisgICAgfQogCiAgIGkg PSAwOwogICBiYnMgPSBnZXRfbG9vcF9ib2R5IChsb29wKTsKQEAgLTQwMyw2 ICs0MTcsMzQ3IEBAIHRyZWVfdW5zd2l0Y2hfbG9vcCAoc3RydWN0IGxvb3Ag Kmxvb3AsCiAJCSAgICAgICBSRUdfQlJfUFJPQl9CQVNFIC0gcHJvYl90cnVl LCBmYWxzZSk7CiB9CiAKKy8qIFVuc3dpdGNoIG91dGVyIGxvb3BzIGJ5IGhv aXN0aW5nIGludmFyaWFudCBndWFyZCBvbgorICAgaW5uZXIgbG9vcCB3aXRo b3V0IGNvZGUgZHVwbGljYXRpb24uICAqLworc3RhdGljIGJvb2wKK3RyZWVf dW5zd2l0Y2hfb3V0ZXJfbG9vcCAoc3RydWN0IGxvb3AgKmxvb3ApCit7Cisg IGVkZ2UgZXhpdCwgZ3VhcmQ7CisgIEhPU1RfV0lERV9JTlQgaXRlcmF0aW9u czsKKworICBnY2NfYXNzZXJ0IChsb29wLT5pbm5lcik7CisgIGlmIChsb29w LT5pbm5lci0+bmV4dCkKKyAgICByZXR1cm4gZmFsc2U7CisgIC8qIEFjY2Vw dCBsb29wcyB3aXRoIHNpbmdsZSBleGl0IG9ubHkuICAqLworICBleGl0ID0g c2luZ2xlX2V4aXQgKGxvb3ApOworICBpZiAoIWV4aXQpCisgICAgcmV0dXJu IGZhbHNlOworICAvKiBDaGVjayB0aGF0IHBoaSBhcmd1bWVudCBvZiBleGl0 IGVkZ2UgaXMgbm90IGRlZmluZWQgaW5zaWRlIGxvb3AuICAqLworICBpZiAo IWNoZWNrX2V4aXRfcGhpIChsb29wKSkKKyAgICByZXR1cm4gZmFsc2U7Cisg IC8qIElmIHRoZSBsb29wIGlzIG5vdCBleHBlY3RlZCB0byBpdGVyYXRlLCB0 aGVyZSBpcyBubyBuZWVkCisgICAgICBmb3IgdW5zd2l0Y2hpbmcuICAqLwor ICBpdGVyYXRpb25zID0gZXN0aW1hdGVkX2xvb3BfaXRlcmF0aW9uc19pbnQg KGxvb3ApOworICBpZiAoaXRlcmF0aW9ucyA+PSAwICYmIGl0ZXJhdGlvbnMg PD0gMSkKKyAgICB7CisgICAgICBpZiAoZHVtcF9maWxlICYmIChkdW1wX2Zs YWdzICYgVERGX0RFVEFJTFMpKQorCWZwcmludGYgKGR1bXBfZmlsZSwgIjs7 IE5vdCB1bnN3aXRjaGluZywgbG9vcCBpcyBub3QgZXhwZWN0ZWQiCisJCSAi IHRvIGl0ZXJhdGVcbiIpOworCXJldHVybiBmYWxzZTsKKyAgICB9CisKKyAg Z3VhcmQgPSBmaW5kX2xvb3BfZ3VhcmQgKGxvb3ApOworICBpZiAoZ3VhcmQp CisgICAgeworICAgICAgaG9pc3RfZ3VhcmQgKGxvb3AsIGd1YXJkKTsKKyAg ICAgIHVwZGF0ZV9zc2EgKFRPRE9fdXBkYXRlX3NzYSk7CisgICAgICByZXR1 cm4gdHJ1ZTsKKyAgICB9CisgIHJldHVybiBmYWxzZTsKK30KKworLyogQ2hl Y2tzIGlmIHRoZSBib2R5IG9mIHRoZSBMT09QIGlzIHdpdGhpbiBhbiBpbnZh cmlhbnQgZ3VhcmQuICBJZiB0aGlzCisgICBpcyB0aGUgY2FzZSwgcmV0dXJu cyB0aGUgZWRnZSB0aGF0IGp1bXBzIG92ZXIgdGhlIHJlYWwgYm9keSBvZiB0 aGUgbG9vcCwKKyAgIG90aGVyd2lzZSByZXR1cm5zIE5VTEwuICAqLworCitz dGF0aWMgZWRnZQorZmluZF9sb29wX2d1YXJkIChzdHJ1Y3QgbG9vcCAqbG9v cCkKK3sKKyAgYmFzaWNfYmxvY2sgaGVhZGVyID0gbG9vcC0+aGVhZGVyOwor ICBlZGdlIGd1YXJkX2VkZ2UsIHRlLCBmZTsKKyAgLyogYml0bWFwIHByb2Nl c3NlZCwga25vd25faW52YXJpYW50czsqLworICBiYXNpY19ibG9jayAqYm9k eSA9IE5VTEw7CisgIHVuc2lnbmVkIGk7CisgIHRyZWUgdXNlOworICBzc2Ff b3BfaXRlciBpdGVyOworCisgIC8qIFdlIGNoZWNrIGZvciB0aGUgZm9sbG93 aW5nIHNpdHVhdGlvbjoKKworICAgICB3aGlsZSAoMSkKKyAgICAgICB7CisJ IFtoZWFkZXJdXQorICAgICAgICAgbG9vcF9waGlfbm9kZXM7CisJIHNvbWV0 aGluZzE7CisJIGlmIChjb25kMSkKKwkgICBib2R5OworCSBudmFyID0gcGhp KG9yaWcsIGJ2YXIpIC4uLiBmb3IgYWxsIHZhcmlhYmxlcyBjaGFuZ2VkIGlu IGJvZHk7CisJIFtndWFyZF9lbmRdCisJIHNvbWV0aGluZzI7CisJIGlmIChj b25kMikKKwkgICBicmVhazsKKwkgc29tZXRoaW5nMzsKKyAgICAgICB9CisK KyAgICAgd2hlcmU6CisKKyAgICAgMSkgY29uZDEgaXMgbG9vcCBpbnZhcmlh bnQKKyAgICAgMikgSWYgY29uZDEgaXMgZmFsc2UsIHRoZW4gdGhlIGxvb3Ag aXMgZXNzZW50aWFsbHkgZW1wdHk7IGkuZS4sCisJYSkgbm90aGluZyBpbiBz b21ldGhpbmcxLCBzb21ldGhpbmcyIGFuZCBzb21ldGhpbmczIGhhcyBzaWRl CisJICAgZWZmZWN0cworCWIpIGFueXRoaW5nIGRlZmluZWQgaW4gc29tZXRo aW5nMSwgc29tZXRoaW5nMiBhbmQgc29tZXRoaW5nMworCSAgIGlzIG5vdCB1 c2VkIG91dHNpZGUgb2YgdGhlIGxvb3AuICAqLworCisgIHdoaWxlIChzaW5n bGVfc3VjY19wIChoZWFkZXIpKQorICAgIGhlYWRlciA9IHNpbmdsZV9zdWNj IChoZWFkZXIpOworICBpZiAoIWxhc3Rfc3RtdCAoaGVhZGVyKQorICAgICAg fHwgZ2ltcGxlX2NvZGUgKGxhc3Rfc3RtdCAoaGVhZGVyKSkgIT0gR0lNUExF X0NPTkQpCisgICAgcmV0dXJuIE5VTEw7CisKKyAgZXh0cmFjdF90cnVlX2Zh bHNlX2VkZ2VzX2Zyb21fYmxvY2sgKGhlYWRlciwgJnRlLCAmZmUpOworICBp ZiAoIWZsb3dfYmJfaW5zaWRlX2xvb3BfcCAobG9vcCwgdGUtPmRlc3QpCisg ICAgICB8fCAhZmxvd19iYl9pbnNpZGVfbG9vcF9wIChsb29wLCBmZS0+ZGVz dCkpCisgICAgcmV0dXJuIE5VTEw7CisKKyAgaWYgKGp1c3Rfb25jZV9lYWNo X2l0ZXJhdGlvbl9wIChsb29wLCB0ZS0+ZGVzdCkKKyAgICAgIHx8IChzaW5n bGVfc3VjY19wICh0ZS0+ZGVzdCkKKwkgICYmIGp1c3Rfb25jZV9lYWNoX2l0 ZXJhdGlvbl9wIChsb29wLCBzaW5nbGVfc3VjYyAodGUtPmRlc3QpKSkpCisg ICAgeworICAgICAgaWYgKGp1c3Rfb25jZV9lYWNoX2l0ZXJhdGlvbl9wIChs b29wLCBmZS0+ZGVzdCkpCisJcmV0dXJuIE5VTEw7CisgICAgICBndWFyZF9l ZGdlID0gdGU7CisgICAgfQorICBlbHNlIGlmIChqdXN0X29uY2VfZWFjaF9p dGVyYXRpb25fcCAobG9vcCwgZmUtPmRlc3QpCisJICAgfHwgKHNpbmdsZV9z dWNjX3AgKGZlLT5kZXN0KQorCSAgICAgICAmJiBqdXN0X29uY2VfZWFjaF9p dGVyYXRpb25fcCAobG9vcCwgc2luZ2xlX3N1Y2MgKGZlLT5kZXN0KSkpKQor ICAgIGd1YXJkX2VkZ2UgPSBmZTsKKyAgZWxzZQorICAgIHJldHVybiBOVUxM OworCisgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBfZmxhZ3MgJiBUREZfREVU QUlMUykpCisgICAgZnByaW50ZiAoZHVtcF9maWxlLAorCSAgICAgIkNvbnNp ZGVyaW5nIGd1YXJkICVkIC0+ICVkIGluIGxvb3AgJWRcbiIsCisJICAgICBn dWFyZF9lZGdlLT5zcmMtPmluZGV4LCBndWFyZF9lZGdlLT5kZXN0LT5pbmRl eCwgbG9vcC0+bnVtKTsKKyAgLyogQ2hlY2sgaWYgY29uZGl0aW9uIG9wZXJh bmRzIGRvIG5vdCBoYXZlIGRlZmluaXRpb25zIGluc2lkZSBsb29wIHNpbmNl CisgICAgIGFueSBiYiBjb3B5aW5nIGlzIG5vdCBwZXJmb3JtZWQuICAqLwor ICBGT1JfRUFDSF9TU0FfVFJFRV9PUEVSQU5EICh1c2UsIGxhc3Rfc3RtdCAo aGVhZGVyKSwgaXRlciwgU1NBX09QX1VTRSkKKyAgICB7CisgICAgICBnaW1w bGUgZGVmID0gU1NBX05BTUVfREVGX1NUTVQgKHVzZSk7CisgICAgICBiYXNp Y19ibG9jayBkZWZfYmIgPSBnaW1wbGVfYmIgKGRlZik7CisgICAgICBpZiAo ZGVmX2JiCisgICAgICAgICAgJiYgZmxvd19iYl9pbnNpZGVfbG9vcF9wIChs b29wLCBkZWZfYmIpKQorCXsKKwkgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBf ZmxhZ3MgJiBUREZfREVUQUlMUykpCisJICAgIGZwcmludGYgKGR1bXBfZmls ZSwgIiAgZ3VhcmQgb3BlcmFuZHMgaGF2ZSBkZWZpbml0aW9ucyIKKwkJCQki IGluc2lkZSBsb29wXG4iKTsKKwkgIHJldHVybiBOVUxMOworCX0KKyAgICB9 CisKKyAgYm9keSA9IGdldF9sb29wX2JvZHkgKGxvb3ApOworICBmb3IgKGkg PSAwOyBpIDwgbG9vcC0+bnVtX25vZGVzOyBpKyspCisgICAgeworICAgICAg aWYgKGJvZHlbaV0tPmxvb3BfZmF0aGVyICE9IGxvb3ApCisJY29udGludWU7 CisgICAgICBpZiAoIWVtcHR5X2JiX3dpdGhvdXRfZ3VhcmRfcCAobG9vcCwg Ym9keVtpXSkpCisJeworCSAgaWYgKGR1bXBfZmlsZSAmJiAoZHVtcF9mbGFn cyAmIFRERl9ERVRBSUxTKSkKKwkgICAgZnByaW50ZiAoZHVtcF9maWxlLCAi ICBibG9jayAlZCBoYXMgc2lkZSBlZmZlY3RzXG4iLCBib2R5W2ldLT5pbmRl eCk7CisJICBndWFyZF9lZGdlID0gTlVMTDsKKwkgIGdvdG8gZW5kOworCX0K KyAgICB9CisKKyAgaWYgKGR1bXBfZmlsZSAmJiAoZHVtcF9mbGFncyAmIFRE Rl9ERVRBSUxTKSkKKyAgICBmcHJpbnRmIChkdW1wX2ZpbGUsICIgIHN1aXRh YmxlIHRvIGhvaXN0XG4iKTsKK2VuZDoKKyAgaWYgKGJvZHkpCisgICAgZnJl ZSAoYm9keSk7CisgIHJldHVybiBndWFyZF9lZGdlOworfQorCisvKiBSZXR1 cm5zIHRydWUgaWYKKyAgIDEpIG5vIHN0YXRlbWVudCBpbiBCQiBoYXMgc2lk ZSBlZmZlY3RzCisgICAyKSBhc3N1bWluZyB0aGF0IGVkZ2UgR1VBUkQgaXMg YWx3YXlzIHRha2VuLCBhbGwgZGVmaW5pdGlvbnMgaW4gQkIKKyAgICAgIGFy ZSBub3kgdXNlZCBvdXRzaWRlIG9mIHRoZSBsb29wLgorICAgS05PV05fSU5W QVJJQU5UUyBpcyBhIHNldCBvZiBzc2EgbmFtZXMgd2Uga25vdyB0byBiZSBp bnZhcmlhbnQsIGFuZAorICAgUFJPQ0VTU0VEIGlzIGEgc2V0IG9mIHNzYSBu YW1lcyBmb3IgdGhhdCB3ZSBhbHJlYWR5IHRlc3RlZCB3aGV0aGVyIHRoZXkK KyAgIGFyZSBpbnZhcmlhbnQgb3Igbm90LiAgKi8KKworc3RhdGljIGJvb2wK K2VtcHR5X2JiX3dpdGhvdXRfZ3VhcmRfcCAoc3RydWN0IGxvb3AgKmxvb3As IGJhc2ljX2Jsb2NrIGJiKQoreworICBiYXNpY19ibG9jayBleGl0X2JiID0g c2luZ2xlX2V4aXQgKGxvb3ApLT5zcmM7CisgIGJvb2wgbWF5X2JlX3VzZWRf b3V0c2lkZSA9IChiYiA9PSBleGl0X2JiCisJCQkgICAgICB8fCAhZG9taW5h dGVkX2J5X3AgKENESV9ET01JTkFUT1JTLCBiYiwgZXhpdF9iYikpOworICB0 cmVlIG5hbWU7CisgIHNzYV9vcF9pdGVyIG9wX2l0ZXI7CisKKyAgLyogUGhp IG5vZGVzIGRvIG5vdCBoYXZlIHNpZGUgZWZmZWN0cywgYnV0IHRoZWlyIHJl c3VsdHMgbWlnaHQgYmUgdXNlZAorICAgICBvdXRzaWRlIG9mIHRoZSBsb29w LiAgKi8KKyAgaWYgKG1heV9iZV91c2VkX291dHNpZGUpCisgICAgeworICAg ICAgZm9yIChncGhpX2l0ZXJhdG9yIGdzaSA9IGdzaV9zdGFydF9waGlzIChi Yik7CisJICAgIWdzaV9lbmRfcCAoZ3NpKTsgZ3NpX25leHQgKCZnc2kpKQor CXsKKwkgIGdwaGkgKnBoaSA9IGdzaS5waGkgKCk7CisJICBuYW1lID0gUEhJ X1JFU1VMVCAocGhpKTsKKwkgIGlmICh2aXJ0dWFsX29wZXJhbmRfcCAobmFt ZSkpCisJICAgIGNvbnRpbnVlOworCisJICBpZiAodXNlZF9vdXRzaWRlX2xv b3BfcCAobG9vcCwgbmFtZSkpCisJICAgIHJldHVybiBmYWxzZTsKKwl9Cisg ICAgfQorCisgIGZvciAoZ2ltcGxlX3N0bXRfaXRlcmF0b3IgZ3NpID0gZ3Np X3N0YXJ0X2JiIChiYik7CisgICAgICAgIWdzaV9lbmRfcCAoZ3NpKTsgZ3Np X25leHQgKCZnc2kpKQorICAgIHsKKyAgICAgIGdpbXBsZSBzdG10ID0gZ3Np X3N0bXQgKGdzaSk7CisgICAgICBpZiAoZ2ltcGxlX2hhc19zaWRlX2VmZmVj dHMgKHN0bXQpKQorCXJldHVybiBmYWxzZTsKKworICAgICAgaWYgKGdpbXBs ZV92ZGVmKHN0bXQpKQorCXJldHVybiBmYWxzZTsKKworICAgICAgRk9SX0VB Q0hfU1NBX1RSRUVfT1BFUkFORCAobmFtZSwgc3RtdCwgb3BfaXRlciwgU1NB X09QX0RFRikKKwl7CisJICBpZiAobWF5X2JlX3VzZWRfb3V0c2lkZQorCSAg ICAgICYmIHVzZWRfb3V0c2lkZV9sb29wX3AgKGxvb3AsIG5hbWUpKQorCSAg ICByZXR1cm4gZmFsc2U7CisJfQorICAgIH0KKyAgcmV0dXJuIHRydWU7Cit9 CisKKy8qIFJldHVybiB0cnVlIGlmIE5BTUUgaXMgdXNlZCBvdXRzaWRlIG9m IExPT1AuICAqLworCitzdGF0aWMgYm9vbAordXNlZF9vdXRzaWRlX2xvb3Bf cCAoc3RydWN0IGxvb3AgKmxvb3AsIHRyZWUgbmFtZSkKK3sKKyAgaW1tX3Vz ZV9pdGVyYXRvciBpdDsKKyAgdXNlX29wZXJhbmRfcCB1c2U7CisKKyAgRk9S X0VBQ0hfSU1NX1VTRV9GQVNUICh1c2UsIGl0LCBuYW1lKQorICAgIHsKKyAg ICAgIGdpbXBsZSBzdG10ID0gVVNFX1NUTVQgKHVzZSk7CisgICAgICBpZiAo IWZsb3dfYmJfaW5zaWRlX2xvb3BfcCAobG9vcCwgZ2ltcGxlX2JiIChzdG10 KSkpCisJcmV0dXJuIHRydWU7CisgICAgfQorCisgIHJldHVybiBmYWxzZTsK K30KKworLyogTW92ZXMgdGhlIGNoZWNrIG9mIEdVQVJEIG91dHNpZGUgb2Yg TE9PUC4gICovCisKK3N0YXRpYyB2b2lkCitob2lzdF9ndWFyZCAoc3RydWN0 IGxvb3AgKmxvb3AsIGVkZ2UgZ3VhcmQpCit7CisgIGVkZ2UgZXhpdCA9IHNp bmdsZV9leGl0IChsb29wKTsKKyAgZWRnZSBwcmVoID0gbG9vcF9wcmVoZWFk ZXJfZWRnZSAobG9vcCk7CisgIGJhc2ljX2Jsb2NrIHByZV9oZWFkZXIgPSBw cmVoLT5zcmM7CisgIGJhc2ljX2Jsb2NrIGJiOworICBlZGdlIHRlLCBmZSwg ZSwgbmV3X2VkZ2U7CisgIGdpbXBsZSBzdG10OworICBiYXNpY19ibG9jayBn dWFyZF9iYiA9IGd1YXJkLT5zcmM7CisgIGdpbXBsZV9zdG10X2l0ZXJhdG9y IGdzaTsKKyAgaW50IGZsYWdzID0gMDsKKyAgYm9vbCBmaXhfZG9tX29mX2V4 aXQ7CisgIGdjb25kICpjb25kX3N0bXQsICpuZXdfY29uZF9zdG10OworCisg IGJiID0gZ2V0X2ltbWVkaWF0ZV9kb21pbmF0b3IgKENESV9ET01JTkFUT1JT LCBleGl0LT5kZXN0KTsKKyAgZml4X2RvbV9vZl9leGl0ID0gZmxvd19iYl9p bnNpZGVfbG9vcF9wIChsb29wLCBiYik7CisgIGdzaSA9IGdzaV9sYXN0X2Ji IChndWFyZF9iYik7CisgIHN0bXQgPSBnc2lfc3RtdCAoZ3NpKTsKKyAgZ2Nj X2Fzc2VydCAoZ2ltcGxlX2NvZGUgKHN0bXQpID09IEdJTVBMRV9DT05EKTsK KyAgY29uZF9zdG10ID0gYXNfYSA8Z2NvbmQgKj4gKHN0bXQpOworICBleHRy YWN0X3RydWVfZmFsc2VfZWRnZXNfZnJvbV9ibG9jayAoZ3VhcmRfYmIsICZ0 ZSwgJmZlKTsKKyAgLyogSW5zZXJ0IGd1YXJkIHRvIFBSRV9IRUFERVIuICAq LworICBpZiAoIWVtcHR5X2Jsb2NrX3AgKHByZV9oZWFkZXIpKQorICAgIGdz aSA9IGdzaV9sYXN0X2JiIChwcmVfaGVhZGVyKTsKKyAgZWxzZQorICAgIGdz aSA9IGdzaV9zdGFydF9iYiAocHJlX2hlYWRlcik7CisgIC8qIENyZWF0ZSBj b3B5IG9mIENPTkRfU1RNVC4gICovCisgIG5ld19jb25kX3N0bXQgPSBnaW1w bGVfYnVpbGRfY29uZCAoZ2ltcGxlX2NvbmRfY29kZSAoY29uZF9zdG10KSwK KwkJCQkgICAgIGdpbXBsZV9jb25kX2xocyAoY29uZF9zdG10KSwKKwkJCQkg ICAgIGdpbXBsZV9jb25kX3JocyAoY29uZF9zdG10KSwKKwkJCQkgICAgIE5V TExfVFJFRSwgTlVMTF9UUkVFKTsKKyAgZ3NpX2luc2VydF9hZnRlciAoJmdz aSwgbmV3X2NvbmRfc3RtdCwgR1NJX05FV19TVE1UKTsKKyAgLyogQ29udmVy dCBDT05EX1NUTVQgdG8gdHJ1ZS9mYWxzZSBjb25kaXRpb25hbC4gICovCisg IGlmIChndWFyZCA9PSB0ZSkKKyAgICBnaW1wbGVfY29uZF9tYWtlX2ZhbHNl IChjb25kX3N0bXQpOworICBlbHNlCisgICAgZ2ltcGxlX2NvbmRfbWFrZV90 cnVlIChjb25kX3N0bXQpOworICB1cGRhdGVfc3RtdCAoY29uZF9zdG10KTsK KyAgLyogQ3JlYXRlIG5ldyBsb29wIHByZS1oZWFkZXIuICAqLworICBlID0g c3BsaXRfYmxvY2sgKHByZV9oZWFkZXIsIGxhc3Rfc3RtdCAocHJlX2hlYWRl cikpOworICBnY2NfYXNzZXJ0IChsb29wX3ByZWhlYWRlcl9lZGdlIChsb29w KS0+c3JjID09IGUtPmRlc3QpOworICBpZiAoZ3VhcmQgPT0gZmUpCisgICAg eworICAgICAgZS0+ZmxhZ3MgPSBFREdFX1RSVUVfVkFMVUU7CisgICAgICBm bGFncyB8PSBFREdFX0ZBTFNFX1ZBTFVFOworICAgIH0KKyAgZWxzZQorICAg IHsKKyAgICAgIGUtPmZsYWdzID0gRURHRV9GQUxTRV9WQUxVRTsKKyAgICAg IGZsYWdzIHw9IEVER0VfVFJVRV9WQUxVRTsKKyAgICB9CisgIG5ld19lZGdl ID0gbWFrZV9lZGdlIChwcmVfaGVhZGVyLCBleGl0LT5kZXN0LCBmbGFncyk7 CisgIGlmIChmaXhfZG9tX29mX2V4aXQpCisgICAgc2V0X2ltbWVkaWF0ZV9k b21pbmF0b3IgKENESV9ET01JTkFUT1JTLCBleGl0LT5kZXN0LCBwcmVfaGVh ZGVyKTsKKyAgLyogQWRkIE5FV19BREdFIGFyZ3VtZW50IGZvciBhbGwgcGhp IGluIHBvc3QtaGVhZGVyIGJsb2NrLiAgKi8KKyAgYmIgPSBleGl0LT5kZXN0 OworICBmb3IgKGdwaGlfaXRlcmF0b3IgZ3NpID0gZ3NpX3N0YXJ0X3BoaXMg KGJiKTsKKyAgICAgICAhZ3NpX2VuZF9wIChnc2kpOyBnc2lfbmV4dCAoJmdz aSkpCisgICAgeworICAgICAgZ3BoaSAqcGhpID0gZ3NpLnBoaSAoKTsKKyAg ICAgIC8qIGVkZ2VfaXRlcmF0b3IgZWk7ICovCisgICAgICB0cmVlIGFyZzsK KyAgICAgIGlmICh2aXJ0dWFsX29wZXJhbmRfcCAoZ2ltcGxlX3BoaV9yZXN1 bHQgKHBoaSkpKQorCXsKKwkgIGFyZyA9IFBISV9BUkdfREVGX0ZST01fRURH RSAocGhpLCBsb29wX3ByZWhlYWRlcl9lZGdlIChsb29wKSk7CisJICBhZGRf cGhpX2FyZyAocGhpLCBhcmcsIG5ld19lZGdlLCBVTktOT1dOX0xPQ0FUSU9O KTsKKwl9CisgICAgICBlbHNlCisJeworCSAgLyogVXNlIGV4aXQgZWRnZSBh cmd1bWVudC4gICovCisJICBhcmcgPSBQSElfQVJHX0RFRl9GUk9NX0VER0Ug KHBoaSwgZXhpdCk7CisJICBhZGRfcGhpX2FyZyAocGhpLCBhcmcsIG5ld19l ZGdlLCBVTktOT1dOX0xPQ0FUSU9OKTsKKwl9CisgICAgfQorCisgIG1hcmtf dmlydHVhbF9vcGVyYW5kc19mb3JfcmVuYW1pbmcgKGNmdW4pOworICB1cGRh dGVfc3NhIChUT0RPX3VwZGF0ZV9zc2EpOworICBpZiAoZHVtcF9maWxlICYm IChkdW1wX2ZsYWdzICYgVERGX0RFVEFJTFMpKQorICAgIGZwcmludGYgKGR1 bXBfZmlsZSwgIiAgZ3VhcmQgaG9pc3RlZC5cbiIpOworfQorCisvKiBSZXR1 cm4gdHJ1ZSBpZiBwaGkgYXJndW1lbnQgZm9yIGV4aXQgZWRnZSBjYW4gYmUg dXNlZAorICAgZm9yIGVkZ2UgYXJvdW5kIGxvb3AuICAqLworCitzdGF0aWMg Ym9vbAorY2hlY2tfZXhpdF9waGkgKHN0cnVjdCBsb29wICpsb29wKQorewor ICBlZGdlIGV4aXQgPSBzaW5nbGVfZXhpdCAobG9vcCk7CisgIGJhc2ljX2Js b2NrIHByZV9oZWFkZXIgPSBsb29wX3ByZWhlYWRlcl9lZGdlIChsb29wKS0+ c3JjOworCisgIGZvciAoZ3BoaV9pdGVyYXRvciBnc2kgPSBnc2lfc3RhcnRf cGhpcyAoZXhpdC0+ZGVzdCk7CisgICAgICAgIWdzaV9lbmRfcCAoZ3NpKTsg Z3NpX25leHQgKCZnc2kpKQorICAgIHsKKyAgICAgIGdwaGkgKnBoaSA9IGdz aS5waGkgKCk7CisgICAgICB0cmVlIGFyZzsKKyAgICAgIGdpbXBsZSBkZWY7 CisgICAgICBiYXNpY19ibG9jayBkZWZfYmI7CisgICAgICBpZiAodmlydHVh bF9vcGVyYW5kX3AgKGdpbXBsZV9waGlfcmVzdWx0IChwaGkpKSkKKwljb250 aW51ZTsKKyAgICAgIGFyZyA9IFBISV9BUkdfREVGX0ZST01fRURHRSAocGhp LCBleGl0KTsKKyAgICAgIGlmIChUUkVFX0NPREUgKGFyZykgIT0gU1NBX05B TUUpCisJY29udGludWU7CisgICAgICBkZWYgPSBTU0FfTkFNRV9ERUZfU1RN VCAoYXJnKTsKKyAgICAgIGlmICghZGVmKQorCWNvbnRpbnVlOworICAgICAg ZGVmX2JiID0gZ2ltcGxlX2JiIChkZWYpOworICAgICAgaWYgKCFkZWZfYmIp CisJY29udGludWU7CisgICAgICBpZiAoIWRvbWluYXRlZF9ieV9wIChDRElf RE9NSU5BVE9SUywgcHJlX2hlYWRlciwgZGVmX2JiKSkKKwkvKiBEZWZpbml0 aW9uIGluc2lkZSBsb29wISAgKi8KKwlyZXR1cm4gZmFsc2U7CisgICAgICAv KiBDaGVjayBsb29wIGNsb3NlZCBwaGkgaW52YXJpYW50LiAgKi8KKyAgICAg IGlmICghZmxvd19iYl9pbnNpZGVfbG9vcF9wIChkZWZfYmItPmxvb3BfZmF0 aGVyLCBwcmVfaGVhZGVyKSkKKwlyZXR1cm4gZmFsc2U7CisgICAgfQorICBy ZXR1cm4gdHJ1ZTsKK30KKwogLyogTG9vcCB1bnN3aXRjaGluZyBwYXNzLiAg Ki8KIAogbmFtZXNwYWNlIHsK --089e0149c410d7e40405216e1c0e--