From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 116536 invoked by alias); 7 Oct 2015 09:53:29 -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 116523 invoked by uid 89); 7 Oct 2015 09:53:28 -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-oi0-f41.google.com Received: from mail-oi0-f41.google.com (HELO mail-oi0-f41.google.com) (209.85.218.41) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Wed, 07 Oct 2015 09:53:24 +0000 Received: by oixx17 with SMTP id x17so6313930oix.0 for ; Wed, 07 Oct 2015 02:53:22 -0700 (PDT) MIME-Version: 1.0 X-Received: by 10.202.104.222 with SMTP id o91mr28324oik.49.1444211602617; Wed, 07 Oct 2015 02:53:22 -0700 (PDT) Received: by 10.202.191.6 with HTTP; Wed, 7 Oct 2015 02:53:22 -0700 (PDT) In-Reply-To: References: Date: Wed, 07 Oct 2015 09:53: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=001a1140fa448e2923052180b770 X-SW-Source: 2015-10/txt/msg00690.txt.bz2 --001a1140fa448e2923052180b770 Content-Type: text/plain; charset=UTF-8 Content-length: 21738 Richard, I've fixed adding virtual phi argument and add check on irreducible basic block. New patch is attached. I checked it for bootstrap and regression testing, no new failures. ChangeLog: 2015-10-07 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. (get_vop_from_header): 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 15:21 GMT+03:00 Richard Biener : > On Tue, Oct 6, 2015 at 1:41 PM, Yuri Rumyantsev wrote: >> 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. > > + /* 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); > > now I know what confused me - here you are looking at a loop exit PHI > but querying with the preheader edge index. I think you need to walk > the loop header PHIs to find the PHI for the virtual operand and use that > to get the PHI arg from? > > The side-effect / used-outside code is still the same. What matters > is side-effects outside of the loop-header protected code region, not > blocks excluding the inner loop. Say, > > for (;;) > { > if (invariant-guard) > { > printf ("Blah"); > for (;;) > ; > } > } > > would still ok to be unswitched. So instead of > > + if (body[i]->loop_father != loop) > + continue; > > it would be > > if (dominated_by_p (CDI_DOMINATORS, body[i], header) > && !dominated_by_p (CDI_DOMINATORS, body[i], fe->dest)) > > with the obvious improvement to the patch to not only consider header checks > in the outer loop header but in the pre-header block of the inner loop. > > And I still think you should walk the exit PHIs args to see whether they > are defined in the non-guarded region of the outer loop instead of walking > all uses of all defs. > > Note that I think you miss endless loops as side-effects if that endless > loop occurs through a irreducible region (thus not reflected in the > loop tree). Thus you should reject BB_IRREDUCIBLE_LOOP blocks > in the non-guarded region as well. > > It seems to me that protecting adjacent loops with a single guard is > also eligible for hoisting thus the restriction on loop->inner->next > should become a restriction on no loops (or irreducible regions) > in the non-guarded region. > > Most things can be improved as followup, but at least the > virtual PHI arg thing needs to be sorted out. > > Thanks, > Richard. > > >> 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. --001a1140fa448e2923052180b770 Content-Type: application/octet-stream; name="patch.update2" Content-Disposition: attachment; filename="patch.update2" Content-Transfer-Encoding: base64 X-Attachment-Id: f_ifgmakuu0 Content-length: 23555 ZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLmRnL2xvb3AtdW5zd2l0 Y2gtMi5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvbG9vcC11bnN3aXRjaC0y LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTU2MjJh NgotLS0gL2Rldi9udWxsCisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRnL2xv b3AtdW5zd2l0Y2gtMi5jCkBAIC0wLDAgKzEsMTYgQEAKKy8qIHsgZGctZG8g Y29tcGlsZSB9ICovCisvKiB7IGRnLW9wdGlvbnMgIi1PMiAtZnVuc3dpdGNo LWxvb3BzIC1mZHVtcC10cmVlLXVuc3dpdGNoLWRldGFpbHMiIH0gKi8KKwor dm9pZCBmb28gKGZsb2F0ICoqYSwgZmxvYXQgKipiLCBmbG9hdCAqYywgaW50 IG4sIGludCBtLCBpbnQgbCkKK3sKKyAgaW50IGksaixrOworICBmbG9hdCBz OworICBmb3IgKGk9MDsgaTxsOyBpKyspCisgICAgeworICAgICAgZm9yIChq PTA7IGo8bjsgaisrKQorCWZvciAoaz0wOyBrPG07IGsrKykKKwkgIGNbaV0g Kz0gYVtpXVtrXSAqIGJba11bal07CisgICAgfQorfQorCisvKiB7IGRnLWZp bmFsIHsgc2Nhbi10cmVlLWR1bXAtdGltZXMgImd1YXJkIGhvaXN0ZWQiIDIg InVuc3dpdGNoIiB9IH0gKi8KZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUv Z2NjLmRnL2xvb3AtdW5zd2l0Y2gtMy5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2Mu ZGcvbG9vcC11bnN3aXRjaC0zLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMC4uZDA0M2ViNgotLS0gL2Rldi9udWxsCisrKyBiL2djYy90 ZXN0c3VpdGUvZ2NjLmRnL2xvb3AtdW5zd2l0Y2gtMy5jCkBAIC0wLDAgKzEs MjUgQEAKKy8qIHsgZGctZG8gY29tcGlsZSB9ICovCisvKiB7IGRnLW9wdGlv bnMgIi1PMiAtZnVuc3dpdGNoLWxvb3BzIC1mZHVtcC10cmVlLXVuc3dpdGNo LWRldGFpbHMiIH0gKi8KKworI2luY2x1ZGUgPHN0ZGxpYi5oPgorI2RlZmlu ZSBOIDMyCitmbG9hdCAqZm9vKGludCB1c3RyaWRlLCBpbnQgc2l6ZSwgZmxv YXQgKnNyYykKK3sKKyAgIGZsb2F0ICpidWZmZXIsICpwOworICAgaW50IGks IGs7CisKKyAgIGlmICghc3JjKQorICAgIHJldHVybiBOVUxMOworCisgICBi dWZmZXIgPSAoZmxvYXQgKikgbWFsbG9jKE4gKiBzaXplICogc2l6ZW9mKGZs b2F0KSk7CisKKyAgIGlmKGJ1ZmZlcikKKyAgICAgIGZvcihpPTAsIHA9YnVm ZmVyOyBpPE47IGkrKywgc3JjKz11c3RyaWRlKQorCWZvcihrPTA7IGs8c2l6 ZTsgaysrKQorCSAgKnArKyA9IHNyY1trXTsKKworICAgcmV0dXJuIGJ1ZmZl cjsKK30KKworLyogeyBkZy1maW5hbCB7IHNjYW4tdHJlZS1kdW1wLXRpbWVz ICJndWFyZCBob2lzdGVkIiAxICJ1bnN3aXRjaCIgfSB9ICovCisKZGlmZiAt LWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLmRnL2xvb3AtdW5zd2l0Y2gtNC5j IGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvbG9vcC11bnN3aXRjaC00LmMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTRhN2YyZQotLS0g L2Rldi9udWxsCisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLmRnL2xvb3AtdW5z d2l0Y2gtNC5jCkBAIC0wLDAgKzEsNTEgQEAKKy8qIHsgZGctZG8gcnVuIH0g Ki8KKy8qIHsgZGctb3B0aW9ucyAiLU8yIC1mdW5zd2l0Y2gtbG9vcHMiIH0g Ki8KKworI2luY2x1ZGUgPHN0ZGxpYi5oPgorX19hdHRyaWJ1dGVfXyAoKG5v aW5saW5lKSkKK3ZvaWQgZm9vIChmbG9hdCAqKmEsIGZsb2F0ICoqYiwgZmxv YXQgKmMsIGludCBuLCBpbnQgbSwgaW50IGwpCit7CisgIGludCBpLGosazsK KyAgZmxvYXQgczsKKyAgZm9yIChpPTA7IGk8bDsgaSsrKQorICAgIGZvciAo aj0wOyBqPG47IGorKykKKyAgICAgIGZvciAoaz0wOyBrPG07IGsrKykKKwlj W2ldICs9IGFbaV1ba10gKiBiW2tdW2pdOworfQorCitpbnQgbWFpbigpCit7 CisgIGNvbnN0IGludCBOID0gMzI7CisgIGZsb2F0ICoqYXIxLCAqKmFyMjsK KyAgZmxvYXQgKnJlczsKKyAgaW50IGksIGo7CisgIGFyMSA9IChmbG9hdCAq KiltYWxsb2MgKE4gKiBzaXplb2YgKGZsb2F0KikpOworICBhcjIgPSAoZmxv YXQgKiopbWFsbG9jIChOICogc2l6ZW9mIChmbG9hdCopKTsKKyAgcmVzID0g KGZsb2F0ICopbWFsbG9jKCBOICogc2l6ZW9mIChmbG9hdCkpOworICBmb3Ig KGk9MDsgaTxOOyBpKyspCisgICAgeworICAgICAgYXIxW2ldID0gKGZsb2F0 KiltYWxsb2MgKE4gKiBzaXplb2YgKGZsb2F0KSk7CisgICAgICBhcjJbaV0g PSAoZmxvYXQqKW1hbGxvYyAoTiAqIHNpemVvZiAoZmxvYXQpKTsKKyAgICB9 CisgIGZvciAoaT0wOyBpPE47IGkrKykKKyAgICB7CisgICAgICBmb3IgKGo9 MDsgajxOOyBqKyspCisJeworCSAgYXIxW2ldW2pdID0gMi4wZjsKKwkgIGFy MltpXVtqXSA9IDEuNWY7CisJfQorICAgICAgcmVzW2ldID0gMC4wZjsKKyAg ICB9CisgIGZvbyAoYXIxLCBhcjIsIHJlcywgTiwgTiwgTik7CisgIGZvciAo aT0wOyBpPE47IGkrKykKKyAgICBpZiAocmVzW2ldICE9IDMwNzIuMGYpCisg ICAgICBhYm9ydCgpOworICBmb3IgKGk9MDsgaTxOOyBpKyspCisgICAgcmVz W2ldID0gMC4wZjsKKyAgZm9vIChhcjEsIGFyMiwgcmVzLCBOLCAwLCBOKTsK KyAgZm9yIChpPTA7IGk8TjsgaSsrKQorICAgIGlmIChyZXNbaV0gIT0gMC4w ZikKKyAgICAgIGFib3J0KCk7CisgIHJldHVybiAwOworfQorCmRpZmYgLS1n aXQgYS9nY2MvdHJlZS1zc2EtbG9vcC11bnN3aXRjaC5jIGIvZ2NjL3RyZWUt c3NhLWxvb3AtdW5zd2l0Y2guYwppbmRleCBhMjczNjM4Li5lZDVhNjRhIDEw MDY0NAotLS0gYS9nY2MvdHJlZS1zc2EtbG9vcC11bnN3aXRjaC5jCisrKyBi L2djYy90cmVlLXNzYS1sb29wLXVuc3dpdGNoLmMKQEAgLTM5LDYgKzM5LDgg QEAgYWxvbmcgd2l0aCBHQ0M7IHNlZSB0aGUgZmlsZSBDT1BZSU5HMy4gIElm IG5vdCBzZWUKICNpbmNsdWRlICJwYXJhbXMuaCIKICNpbmNsdWRlICJ0cmVl LXBhc3MuaCIKICNpbmNsdWRlICJ0cmVlLWlubGluZS5oIgorI2luY2x1ZGUg ImdpbXBsZS1pdGVyYXRvci5oIgorI2luY2x1ZGUgImNmZ2hvb2tzLmgiCiAK IC8qIFRoaXMgZmlsZSBpbXBsZW1lbnRzIHRoZSBsb29wIHVuc3dpdGNoaW5n LCBpLmUuIHRyYW5zZm9ybWF0aW9uIG9mIGxvb3BzIGxpa2UKIApAQCAtNzks NiArODEsMTMgQEAgYWxvbmcgd2l0aCBHQ0M7IHNlZSB0aGUgZmlsZSBDT1BZ SU5HMy4gIElmIG5vdCBzZWUKIHN0YXRpYyBzdHJ1Y3QgbG9vcCAqdHJlZV91 bnN3aXRjaF9sb29wIChzdHJ1Y3QgbG9vcCAqLCBiYXNpY19ibG9jaywgdHJl ZSk7CiBzdGF0aWMgYm9vbCB0cmVlX3Vuc3dpdGNoX3NpbmdsZV9sb29wIChz dHJ1Y3QgbG9vcCAqLCBpbnQpOwogc3RhdGljIHRyZWUgdHJlZV9tYXlfdW5z d2l0Y2hfb24gKGJhc2ljX2Jsb2NrLCBzdHJ1Y3QgbG9vcCAqKTsKK3N0YXRp YyBib29sIHRyZWVfdW5zd2l0Y2hfb3V0ZXJfbG9vcCAoc3RydWN0IGxvb3Ag Kik7CitzdGF0aWMgZWRnZSBmaW5kX2xvb3BfZ3VhcmQgKHN0cnVjdCBsb29w ICopOworc3RhdGljIGJvb2wgZW1wdHlfYmJfd2l0aG91dF9ndWFyZF9wIChz dHJ1Y3QgbG9vcCAqLCBiYXNpY19ibG9jayk7CitzdGF0aWMgYm9vbCB1c2Vk X291dHNpZGVfbG9vcF9wIChzdHJ1Y3QgbG9vcCAqLCB0cmVlKTsKK3N0YXRp YyB2b2lkIGhvaXN0X2d1YXJkIChzdHJ1Y3QgbG9vcCAqLCBlZGdlKTsKK3N0 YXRpYyBib29sIGNoZWNrX2V4aXRfcGhpIChzdHJ1Y3QgbG9vcCAqKTsKK3N0 YXRpYyB0cmVlIGdldF92b3BfZnJvbV9oZWFkZXIgKHN0cnVjdCBsb29wICop OwogCiAvKiBNYWluIGVudHJ5IHBvaW50LiAgUGVyZm9ybSBsb29wIHVuc3dp dGNoaW5nIG9uIGFsbCBzdWl0YWJsZSBsb29wcy4gICovCiAKQEAgLTg3LDQy ICs5NiwxNSBAQCB0cmVlX3NzYV91bnN3aXRjaF9sb29wcyAodm9pZCkKIHsK ICAgc3RydWN0IGxvb3AgKmxvb3A7CiAgIGJvb2wgY2hhbmdlZCA9IGZhbHNl OwotICBIT1NUX1dJREVfSU5UIGl0ZXJhdGlvbnM7CiAKLSAgLyogR28gdGhy b3VnaCBpbm5lciBsb29wcyAob25seSBvcmlnaW5hbCBvbmVzKS4gICovCi0g IEZPUl9FQUNIX0xPT1AgKGxvb3AsIExJX09OTFlfSU5ORVJNT1NUKQorICAv KiBHbyB0aHJvdWdoIGFsbCBsb29wcyBzdGFydGluZyBmcm9tIGlubmVybW9z dC4gICovCisgIEZPUl9FQUNIX0xPT1AgKGxvb3AsIExJX0ZST01fSU5ORVJN T1NUKQogICAgIHsKLSAgICAgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBfZmxh Z3MgJiBUREZfREVUQUlMUykpCi0gICAgICAgIGZwcmludGYgKGR1bXBfZmls ZSwgIjs7IENvbnNpZGVyaW5nIGxvb3AgJWRcbiIsIGxvb3AtPm51bSk7Ci0K LSAgICAgIC8qIERvIG5vdCB1bnN3aXRjaCBpbiBjb2xkIHJlZ2lvbnMuICov Ci0gICAgICBpZiAob3B0aW1pemVfbG9vcF9mb3Jfc2l6ZV9wIChsb29wKSkK LSAgICAgICAgewotICAgICAgICAgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBf ZmxhZ3MgJiBUREZfREVUQUlMUykpCi0gICAgICAgICAgICBmcHJpbnRmIChk dW1wX2ZpbGUsICI7OyBOb3QgdW5zd2l0Y2hpbmcgY29sZCBsb29wc1xuIik7 Ci0gICAgICAgICAgY29udGludWU7Ci0gICAgICAgIH0KLQotICAgICAgLyog VGhlIGxvb3Agc2hvdWxkIG5vdCBiZSB0b28gbGFyZ2UsIHRvIGxpbWl0IGNv ZGUgZ3Jvd3RoLiAqLwotICAgICAgaWYgKHRyZWVfbnVtX2xvb3BfaW5zbnMg KGxvb3AsICZlbmlfc2l6ZV93ZWlnaHRzKQotICAgICAgICAgID4gKHVuc2ln bmVkKSBQQVJBTV9WQUxVRSAoUEFSQU1fTUFYX1VOU1dJVENIX0lOU05TKSkK LSAgICAgICAgewotICAgICAgICAgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBf ZmxhZ3MgJiBUREZfREVUQUlMUykpCi0gICAgICAgICAgICBmcHJpbnRmIChk dW1wX2ZpbGUsICI7OyBOb3QgdW5zd2l0Y2hpbmcsIGxvb3AgdG9vIGJpZ1xu Iik7Ci0gICAgICAgICAgY29udGludWU7Ci0gICAgICAgIH0KLQotICAgICAg LyogSWYgdGhlIGxvb3AgaXMgbm90IGV4cGVjdGVkIHRvIGl0ZXJhdGUsIHRo ZXJlIGlzIG5vIG5lZWQKLQkgZm9yIHVuc3dpdGNoaW5nLiAgKi8KLSAgICAg IGl0ZXJhdGlvbnMgPSBlc3RpbWF0ZWRfbG9vcF9pdGVyYXRpb25zX2ludCAo bG9vcCk7Ci0gICAgICBpZiAoaXRlcmF0aW9ucyA+PSAwICYmIGl0ZXJhdGlv bnMgPD0gMSkKLQl7Ci0gICAgICAgICAgaWYgKGR1bXBfZmlsZSAmJiAoZHVt cF9mbGFncyAmIFRERl9ERVRBSUxTKSkKLSAgICAgICAgICAgIGZwcmludGYg KGR1bXBfZmlsZSwgIjs7IE5vdCB1bnN3aXRjaGluZywgbG9vcCBpcyBub3Qg ZXhwZWN0ZWQgdG8gaXRlcmF0ZVxuIik7Ci0gICAgICAgICAgY29udGludWU7 Ci0JfQotCi0gICAgICBjaGFuZ2VkIHw9IHRyZWVfdW5zd2l0Y2hfc2luZ2xl X2xvb3AgKGxvb3AsIDApOworICAgICAgaWYgKCFsb29wLT5pbm5lcikKKwkv KiBVbnN3aXRjaCBpbm5lcm1vc3QgbG9vcC4gICovCisJY2hhbmdlZCB8PSB0 cmVlX3Vuc3dpdGNoX3NpbmdsZV9sb29wIChsb29wLCAwKTsKKyAgICAgIGVs c2UKKwljaGFuZ2VkIHw9IHRyZWVfdW5zd2l0Y2hfb3V0ZXJfbG9vcCAobG9v cCk7CiAgICAgfQogCiAgIGlmIChjaGFuZ2VkKQpAQCAtMjE2LDYgKzE5OCwz OSBAQCB0cmVlX3Vuc3dpdGNoX3NpbmdsZV9sb29wIChzdHJ1Y3QgbG9vcCAq bG9vcCwgaW50IG51bSkKICAgdHJlZSBjb25kID0gTlVMTF9UUkVFOwogICBn aW1wbGUgc3RtdDsKICAgYm9vbCBjaGFuZ2VkID0gZmFsc2U7CisgIEhPU1Rf V0lERV9JTlQgaXRlcmF0aW9uczsKKworICAvKiBQZXJmb3JtIGluaXRpYWwg dGVzdHMgaWYgdW5zd2l0Y2ggaXMgZWxpZ2libGUuICAqLworICBpZiAobnVt ID09IDApCisgICAgeworICAgICAgLyogRG8gbm90IHVuc3dpdGNoIGluIGNv bGQgcmVnaW9ucy4gKi8KKyAgICAgIGlmIChvcHRpbWl6ZV9sb29wX2Zvcl9z aXplX3AgKGxvb3ApKQorCXsKKwkgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBf ZmxhZ3MgJiBUREZfREVUQUlMUykpCisJICAgIGZwcmludGYgKGR1bXBfZmls ZSwgIjs7IE5vdCB1bnN3aXRjaGluZyBjb2xkIGxvb3BzXG4iKTsKKwkgIHJl dHVybiBmYWxzZTsKKwl9CisKKyAgICAgIC8qIFRoZSBsb29wIHNob3VsZCBu b3QgYmUgdG9vIGxhcmdlLCB0byBsaW1pdCBjb2RlIGdyb3d0aC4gKi8KKyAg ICAgIGlmICh0cmVlX251bV9sb29wX2luc25zIChsb29wLCAmZW5pX3NpemVf d2VpZ2h0cykKKwkgID4gKHVuc2lnbmVkKSBQQVJBTV9WQUxVRSAoUEFSQU1f TUFYX1VOU1dJVENIX0lOU05TKSkKKwl7CisJICBpZiAoZHVtcF9maWxlICYm IChkdW1wX2ZsYWdzICYgVERGX0RFVEFJTFMpKQorCSAgICBmcHJpbnRmIChk dW1wX2ZpbGUsICI7OyBOb3QgdW5zd2l0Y2hpbmcsIGxvb3AgdG9vIGJpZ1xu Iik7CisJICByZXR1cm4gZmFsc2U7CisJfQorCisgICAgICAvKiBJZiB0aGUg bG9vcCBpcyBub3QgZXhwZWN0ZWQgdG8gaXRlcmF0ZSwgdGhlcmUgaXMgbm8g bmVlZAorCSBmb3IgdW5zd2l0Y2hpbmcuICAqLworICAgICAgaXRlcmF0aW9u cyA9IGVzdGltYXRlZF9sb29wX2l0ZXJhdGlvbnNfaW50IChsb29wKTsKKyAg ICAgIGlmIChpdGVyYXRpb25zID49IDAgJiYgaXRlcmF0aW9ucyA8PSAxKQor CXsKKwkgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBfZmxhZ3MgJiBUREZfREVU QUlMUykpCisJICAgIGZwcmludGYgKGR1bXBfZmlsZSwgIjs7IE5vdCB1bnN3 aXRjaGluZywgbG9vcCBpcyBub3QgZXhwZWN0ZWQiCisJCSAgICAgIiB0byBp dGVyYXRlXG4iKTsKKwkgIHJldHVybiBmYWxzZTsKKwl9CisgICAgfQogCiAg IGkgPSAwOwogICBiYnMgPSBnZXRfbG9vcF9ib2R5IChsb29wKTsKQEAgLTQw Myw2ICs0MTgsMzc0IEBAIHRyZWVfdW5zd2l0Y2hfbG9vcCAoc3RydWN0IGxv b3AgKmxvb3AsCiAJCSAgICAgICBSRUdfQlJfUFJPQl9CQVNFIC0gcHJvYl90 cnVlLCBmYWxzZSk7CiB9CiAKKy8qIFVuc3dpdGNoIG91dGVyIGxvb3BzIGJ5 IGhvaXN0aW5nIGludmFyaWFudCBndWFyZCBvbgorICAgaW5uZXIgbG9vcCB3 aXRob3V0IGNvZGUgZHVwbGljYXRpb24uICAqLworc3RhdGljIGJvb2wKK3Ry ZWVfdW5zd2l0Y2hfb3V0ZXJfbG9vcCAoc3RydWN0IGxvb3AgKmxvb3ApCit7 CisgIGVkZ2UgZXhpdCwgZ3VhcmQ7CisgIEhPU1RfV0lERV9JTlQgaXRlcmF0 aW9uczsKKworICBnY2NfYXNzZXJ0IChsb29wLT5pbm5lcik7CisgIGlmIChs b29wLT5pbm5lci0+bmV4dCkKKyAgICByZXR1cm4gZmFsc2U7CisgIC8qIEFj Y2VwdCBsb29wcyB3aXRoIHNpbmdsZSBleGl0IG9ubHkuICAqLworICBleGl0 ID0gc2luZ2xlX2V4aXQgKGxvb3ApOworICBpZiAoIWV4aXQpCisgICAgcmV0 dXJuIGZhbHNlOworICAvKiBDaGVjayB0aGF0IHBoaSBhcmd1bWVudCBvZiBl eGl0IGVkZ2UgaXMgbm90IGRlZmluZWQgaW5zaWRlIGxvb3AuICAqLworICBp ZiAoIWNoZWNrX2V4aXRfcGhpIChsb29wKSkKKyAgICByZXR1cm4gZmFsc2U7 CisgIC8qIElmIHRoZSBsb29wIGlzIG5vdCBleHBlY3RlZCB0byBpdGVyYXRl LCB0aGVyZSBpcyBubyBuZWVkCisgICAgICBmb3IgdW5zd2l0Y2hpbmcuICAq LworICBpdGVyYXRpb25zID0gZXN0aW1hdGVkX2xvb3BfaXRlcmF0aW9uc19p bnQgKGxvb3ApOworICBpZiAoaXRlcmF0aW9ucyA+PSAwICYmIGl0ZXJhdGlv bnMgPD0gMSkKKyAgICB7CisgICAgICBpZiAoZHVtcF9maWxlICYmIChkdW1w X2ZsYWdzICYgVERGX0RFVEFJTFMpKQorCWZwcmludGYgKGR1bXBfZmlsZSwg Ijs7IE5vdCB1bnN3aXRjaGluZywgbG9vcCBpcyBub3QgZXhwZWN0ZWQiCisJ CSAiIHRvIGl0ZXJhdGVcbiIpOworCXJldHVybiBmYWxzZTsKKyAgICB9CisK KyAgZ3VhcmQgPSBmaW5kX2xvb3BfZ3VhcmQgKGxvb3ApOworICBpZiAoZ3Vh cmQpCisgICAgeworICAgICAgaG9pc3RfZ3VhcmQgKGxvb3AsIGd1YXJkKTsK KyAgICAgIHVwZGF0ZV9zc2EgKFRPRE9fdXBkYXRlX3NzYSk7CisgICAgICBy ZXR1cm4gdHJ1ZTsKKyAgICB9CisgIHJldHVybiBmYWxzZTsKK30KKworLyog Q2hlY2tzIGlmIHRoZSBib2R5IG9mIHRoZSBMT09QIGlzIHdpdGhpbiBhbiBp bnZhcmlhbnQgZ3VhcmQuICBJZiB0aGlzCisgICBpcyB0aGUgY2FzZSwgcmV0 dXJucyB0aGUgZWRnZSB0aGF0IGp1bXBzIG92ZXIgdGhlIHJlYWwgYm9keSBv ZiB0aGUgbG9vcCwKKyAgIG90aGVyd2lzZSByZXR1cm5zIE5VTEwuICAqLwor CitzdGF0aWMgZWRnZQorZmluZF9sb29wX2d1YXJkIChzdHJ1Y3QgbG9vcCAq bG9vcCkKK3sKKyAgYmFzaWNfYmxvY2sgaGVhZGVyID0gbG9vcC0+aGVhZGVy OworICBlZGdlIGd1YXJkX2VkZ2UsIHRlLCBmZTsKKyAgLyogYml0bWFwIHBy b2Nlc3NlZCwga25vd25faW52YXJpYW50czsqLworICBiYXNpY19ibG9jayAq Ym9keSA9IE5VTEw7CisgIHVuc2lnbmVkIGk7CisgIHRyZWUgdXNlOworICBz c2Ffb3BfaXRlciBpdGVyOworCisgIC8qIFdlIGNoZWNrIGZvciB0aGUgZm9s bG93aW5nIHNpdHVhdGlvbjoKKworICAgICB3aGlsZSAoMSkKKyAgICAgICB7 CisJIFtoZWFkZXJdXQorICAgICAgICAgbG9vcF9waGlfbm9kZXM7CisJIHNv bWV0aGluZzE7CisJIGlmIChjb25kMSkKKwkgICBib2R5OworCSBudmFyID0g cGhpKG9yaWcsIGJ2YXIpIC4uLiBmb3IgYWxsIHZhcmlhYmxlcyBjaGFuZ2Vk IGluIGJvZHk7CisJIFtndWFyZF9lbmRdCisJIHNvbWV0aGluZzI7CisJIGlm IChjb25kMikKKwkgICBicmVhazsKKwkgc29tZXRoaW5nMzsKKyAgICAgICB9 CisKKyAgICAgd2hlcmU6CisKKyAgICAgMSkgY29uZDEgaXMgbG9vcCBpbnZh cmlhbnQKKyAgICAgMikgSWYgY29uZDEgaXMgZmFsc2UsIHRoZW4gdGhlIGxv b3AgaXMgZXNzZW50aWFsbHkgZW1wdHk7IGkuZS4sCisJYSkgbm90aGluZyBp biBzb21ldGhpbmcxLCBzb21ldGhpbmcyIGFuZCBzb21ldGhpbmczIGhhcyBz aWRlCisJICAgZWZmZWN0cworCWIpIGFueXRoaW5nIGRlZmluZWQgaW4gc29t ZXRoaW5nMSwgc29tZXRoaW5nMiBhbmQgc29tZXRoaW5nMworCSAgIGlzIG5v dCB1c2VkIG91dHNpZGUgb2YgdGhlIGxvb3AuICAqLworCisgIHdoaWxlIChz aW5nbGVfc3VjY19wIChoZWFkZXIpKQorICAgIGhlYWRlciA9IHNpbmdsZV9z dWNjIChoZWFkZXIpOworICBpZiAoIWxhc3Rfc3RtdCAoaGVhZGVyKQorICAg ICAgfHwgZ2ltcGxlX2NvZGUgKGxhc3Rfc3RtdCAoaGVhZGVyKSkgIT0gR0lN UExFX0NPTkQpCisgICAgcmV0dXJuIE5VTEw7CisKKyAgZXh0cmFjdF90cnVl X2ZhbHNlX2VkZ2VzX2Zyb21fYmxvY2sgKGhlYWRlciwgJnRlLCAmZmUpOwor ICBpZiAoIWZsb3dfYmJfaW5zaWRlX2xvb3BfcCAobG9vcCwgdGUtPmRlc3Qp CisgICAgICB8fCAhZmxvd19iYl9pbnNpZGVfbG9vcF9wIChsb29wLCBmZS0+ ZGVzdCkpCisgICAgcmV0dXJuIE5VTEw7CisKKyAgaWYgKGp1c3Rfb25jZV9l YWNoX2l0ZXJhdGlvbl9wIChsb29wLCB0ZS0+ZGVzdCkKKyAgICAgIHx8IChz aW5nbGVfc3VjY19wICh0ZS0+ZGVzdCkKKwkgICYmIGp1c3Rfb25jZV9lYWNo X2l0ZXJhdGlvbl9wIChsb29wLCBzaW5nbGVfc3VjYyAodGUtPmRlc3QpKSkp CisgICAgeworICAgICAgaWYgKGp1c3Rfb25jZV9lYWNoX2l0ZXJhdGlvbl9w IChsb29wLCBmZS0+ZGVzdCkpCisJcmV0dXJuIE5VTEw7CisgICAgICBndWFy ZF9lZGdlID0gdGU7CisgICAgfQorICBlbHNlIGlmIChqdXN0X29uY2VfZWFj aF9pdGVyYXRpb25fcCAobG9vcCwgZmUtPmRlc3QpCisJICAgfHwgKHNpbmds ZV9zdWNjX3AgKGZlLT5kZXN0KQorCSAgICAgICAmJiBqdXN0X29uY2VfZWFj aF9pdGVyYXRpb25fcCAobG9vcCwgc2luZ2xlX3N1Y2MgKGZlLT5kZXN0KSkp KQorICAgIGd1YXJkX2VkZ2UgPSBmZTsKKyAgZWxzZQorICAgIHJldHVybiBO VUxMOworCisgIGlmIChkdW1wX2ZpbGUgJiYgKGR1bXBfZmxhZ3MgJiBUREZf REVUQUlMUykpCisgICAgZnByaW50ZiAoZHVtcF9maWxlLAorCSAgICAgIkNv bnNpZGVyaW5nIGd1YXJkICVkIC0+ICVkIGluIGxvb3AgJWRcbiIsCisJICAg ICBndWFyZF9lZGdlLT5zcmMtPmluZGV4LCBndWFyZF9lZGdlLT5kZXN0LT5p bmRleCwgbG9vcC0+bnVtKTsKKyAgLyogQ2hlY2sgaWYgY29uZGl0aW9uIG9w ZXJhbmRzIGRvIG5vdCBoYXZlIGRlZmluaXRpb25zIGluc2lkZSBsb29wIHNp bmNlCisgICAgIGFueSBiYiBjb3B5aW5nIGlzIG5vdCBwZXJmb3JtZWQuICAq LworICBGT1JfRUFDSF9TU0FfVFJFRV9PUEVSQU5EICh1c2UsIGxhc3Rfc3Rt dCAoaGVhZGVyKSwgaXRlciwgU1NBX09QX1VTRSkKKyAgICB7CisgICAgICBn aW1wbGUgZGVmID0gU1NBX05BTUVfREVGX1NUTVQgKHVzZSk7CisgICAgICBi YXNpY19ibG9jayBkZWZfYmIgPSBnaW1wbGVfYmIgKGRlZik7CisgICAgICBp ZiAoZGVmX2JiCisgICAgICAgICAgJiYgZmxvd19iYl9pbnNpZGVfbG9vcF9w IChsb29wLCBkZWZfYmIpKQorCXsKKwkgIGlmIChkdW1wX2ZpbGUgJiYgKGR1 bXBfZmxhZ3MgJiBUREZfREVUQUlMUykpCisJICAgIGZwcmludGYgKGR1bXBf ZmlsZSwgIiAgZ3VhcmQgb3BlcmFuZHMgaGF2ZSBkZWZpbml0aW9ucyIKKwkJ CQkiIGluc2lkZSBsb29wXG4iKTsKKwkgIHJldHVybiBOVUxMOworCX0KKyAg ICB9CisKKyAgYm9keSA9IGdldF9sb29wX2JvZHkgKGxvb3ApOworICBmb3Ig KGkgPSAwOyBpIDwgbG9vcC0+bnVtX25vZGVzOyBpKyspCisgICAgeworICAg ICAgYmFzaWNfYmxvY2sgYmIgPSBib2R5W2ldOworICAgICAgaWYgKGJiLT5s b29wX2ZhdGhlciAhPSBsb29wKQorCWNvbnRpbnVlOworICAgICAgaWYgKGJi LT5mbGFncyAmIEJCX0lSUkVEVUNJQkxFX0xPT1ApCisJeworCSAgaWYgKGR1 bXBfZmlsZSAmJiAoZHVtcF9mbGFncyAmIFRERl9ERVRBSUxTKSkKKwkgICAg ZnByaW50ZiAoZHVtcF9maWxlLCAiQmxvY2sgJWQgaXMgbWFya2VkIGFzIGly cmVkdWNpYmxlIGluIGxvb3BcbiIsCisJCSAgICAgIGJiLT5pbmRleCk7CisJ ICBndWFyZF9lZGdlID0gTlVMTDsKKwkgIGdvdG8gZW5kOworCX0KKyAgICAg IGlmICghZW1wdHlfYmJfd2l0aG91dF9ndWFyZF9wIChsb29wLCBiYikpCisJ eworCSAgaWYgKGR1bXBfZmlsZSAmJiAoZHVtcF9mbGFncyAmIFRERl9ERVRB SUxTKSkKKwkgICAgZnByaW50ZiAoZHVtcF9maWxlLCAiICBibG9jayAlZCBo YXMgc2lkZSBlZmZlY3RzXG4iLCBiYi0+aW5kZXgpOworCSAgZ3VhcmRfZWRn ZSA9IE5VTEw7CisJICBnb3RvIGVuZDsKKwl9CisgICAgfQorCisgIGlmIChk dW1wX2ZpbGUgJiYgKGR1bXBfZmxhZ3MgJiBUREZfREVUQUlMUykpCisgICAg ZnByaW50ZiAoZHVtcF9maWxlLCAiICBzdWl0YWJsZSB0byBob2lzdFxuIik7 CitlbmQ6CisgIGlmIChib2R5KQorICAgIGZyZWUgKGJvZHkpOworICByZXR1 cm4gZ3VhcmRfZWRnZTsKK30KKworLyogUmV0dXJucyB0cnVlIGlmCisgICAx KSBubyBzdGF0ZW1lbnQgaW4gQkIgaGFzIHNpZGUgZWZmZWN0cworICAgMikg YXNzdW1pbmcgdGhhdCBlZGdlIEdVQVJEIGlzIGFsd2F5cyB0YWtlbiwgYWxs IGRlZmluaXRpb25zIGluIEJCCisgICAgICBhcmUgbm95IHVzZWQgb3V0c2lk ZSBvZiB0aGUgbG9vcC4KKyAgIEtOT1dOX0lOVkFSSUFOVFMgaXMgYSBzZXQg b2Ygc3NhIG5hbWVzIHdlIGtub3cgdG8gYmUgaW52YXJpYW50LCBhbmQKKyAg IFBST0NFU1NFRCBpcyBhIHNldCBvZiBzc2EgbmFtZXMgZm9yIHRoYXQgd2Ug YWxyZWFkeSB0ZXN0ZWQgd2hldGhlciB0aGV5CisgICBhcmUgaW52YXJpYW50 IG9yIG5vdC4gICovCisKK3N0YXRpYyBib29sCitlbXB0eV9iYl93aXRob3V0 X2d1YXJkX3AgKHN0cnVjdCBsb29wICpsb29wLCBiYXNpY19ibG9jayBiYikK K3sKKyAgYmFzaWNfYmxvY2sgZXhpdF9iYiA9IHNpbmdsZV9leGl0IChsb29w KS0+c3JjOworICBib29sIG1heV9iZV91c2VkX291dHNpZGUgPSAoYmIgPT0g ZXhpdF9iYgorCQkJICAgICAgfHwgIWRvbWluYXRlZF9ieV9wIChDRElfRE9N SU5BVE9SUywgYmIsIGV4aXRfYmIpKTsKKyAgdHJlZSBuYW1lOworICBzc2Ff b3BfaXRlciBvcF9pdGVyOworCisgIC8qIFBoaSBub2RlcyBkbyBub3QgaGF2 ZSBzaWRlIGVmZmVjdHMsIGJ1dCB0aGVpciByZXN1bHRzIG1pZ2h0IGJlIHVz ZWQKKyAgICAgb3V0c2lkZSBvZiB0aGUgbG9vcC4gICovCisgIGlmIChtYXlf YmVfdXNlZF9vdXRzaWRlKQorICAgIHsKKyAgICAgIGZvciAoZ3BoaV9pdGVy YXRvciBnc2kgPSBnc2lfc3RhcnRfcGhpcyAoYmIpOworCSAgICFnc2lfZW5k X3AgKGdzaSk7IGdzaV9uZXh0ICgmZ3NpKSkKKwl7CisJICBncGhpICpwaGkg PSBnc2kucGhpICgpOworCSAgbmFtZSA9IFBISV9SRVNVTFQgKHBoaSk7CisJ ICBpZiAodmlydHVhbF9vcGVyYW5kX3AgKG5hbWUpKQorCSAgICBjb250aW51 ZTsKKworCSAgaWYgKHVzZWRfb3V0c2lkZV9sb29wX3AgKGxvb3AsIG5hbWUp KQorCSAgICByZXR1cm4gZmFsc2U7CisJfQorICAgIH0KKworICBmb3IgKGdp bXBsZV9zdG10X2l0ZXJhdG9yIGdzaSA9IGdzaV9zdGFydF9iYiAoYmIpOwor ICAgICAgICFnc2lfZW5kX3AgKGdzaSk7IGdzaV9uZXh0ICgmZ3NpKSkKKyAg ICB7CisgICAgICBnaW1wbGUgc3RtdCA9IGdzaV9zdG10IChnc2kpOworICAg ICAgaWYgKGdpbXBsZV9oYXNfc2lkZV9lZmZlY3RzIChzdG10KSkKKwlyZXR1 cm4gZmFsc2U7CisKKyAgICAgIGlmIChnaW1wbGVfdmRlZihzdG10KSkKKwly ZXR1cm4gZmFsc2U7CisKKyAgICAgIEZPUl9FQUNIX1NTQV9UUkVFX09QRVJB TkQgKG5hbWUsIHN0bXQsIG9wX2l0ZXIsIFNTQV9PUF9ERUYpCisJeworCSAg aWYgKG1heV9iZV91c2VkX291dHNpZGUKKwkgICAgICAmJiB1c2VkX291dHNp ZGVfbG9vcF9wIChsb29wLCBuYW1lKSkKKwkgICAgcmV0dXJuIGZhbHNlOwor CX0KKyAgICB9CisgIHJldHVybiB0cnVlOworfQorCisvKiBSZXR1cm4gdHJ1 ZSBpZiBOQU1FIGlzIHVzZWQgb3V0c2lkZSBvZiBMT09QLiAgKi8KKworc3Rh dGljIGJvb2wKK3VzZWRfb3V0c2lkZV9sb29wX3AgKHN0cnVjdCBsb29wICps b29wLCB0cmVlIG5hbWUpCit7CisgIGltbV91c2VfaXRlcmF0b3IgaXQ7Cisg IHVzZV9vcGVyYW5kX3AgdXNlOworCisgIEZPUl9FQUNIX0lNTV9VU0VfRkFT VCAodXNlLCBpdCwgbmFtZSkKKyAgICB7CisgICAgICBnaW1wbGUgc3RtdCA9 IFVTRV9TVE1UICh1c2UpOworICAgICAgaWYgKCFmbG93X2JiX2luc2lkZV9s b29wX3AgKGxvb3AsIGdpbXBsZV9iYiAoc3RtdCkpKQorCXJldHVybiB0cnVl OworICAgIH0KKworICByZXR1cm4gZmFsc2U7Cit9CisKKy8qIFJldHVybiBh cmd1bWVudCBmb3IgbG9vcCBwcmVoZWFkZXIgZWRnZSBpbiBoZWFkZXIgdmly dHVhbCBwaGkgaWYgYW55LiAgKi8KKworc3RhdGljIHRyZWUKK2dldF92b3Bf ZnJvbV9oZWFkZXIgKHN0cnVjdCBsb29wICpsb29wKQoreworICBmb3IgKGdw aGlfaXRlcmF0b3IgZ3NpID0gZ3NpX3N0YXJ0X3BoaXMgKGxvb3AtPmhlYWRl cik7CisgICAgICAgIWdzaV9lbmRfcCAoZ3NpKTsgZ3NpX25leHQgKCZnc2kp KQorICAgIHsKKyAgICAgIGdwaGkgKnBoaSA9IGdzaS5waGkgKCk7CisgICAg ICBpZiAoIXZpcnR1YWxfb3BlcmFuZF9wIChnaW1wbGVfcGhpX3Jlc3VsdCAo cGhpKSkpCisJY29udGludWU7CisgICAgICByZXR1cm4gUEhJX0FSR19ERUZf RlJPTV9FREdFIChwaGksIGxvb3BfcHJlaGVhZGVyX2VkZ2UgKGxvb3ApKTsK KyAgICB9CisgIHJldHVybiBOVUxMX1RSRUU7Cit9CisKKy8qIE1vdmUgdGhl IGNoZWNrIG9mIEdVQVJEIG91dHNpZGUgb2YgTE9PUC4gICovCisKK3N0YXRp YyB2b2lkCitob2lzdF9ndWFyZCAoc3RydWN0IGxvb3AgKmxvb3AsIGVkZ2Ug Z3VhcmQpCit7CisgIGVkZ2UgZXhpdCA9IHNpbmdsZV9leGl0IChsb29wKTsK KyAgZWRnZSBwcmVoID0gbG9vcF9wcmVoZWFkZXJfZWRnZSAobG9vcCk7Cisg IGJhc2ljX2Jsb2NrIHByZV9oZWFkZXIgPSBwcmVoLT5zcmM7CisgIGJhc2lj X2Jsb2NrIGJiOworICBlZGdlIHRlLCBmZSwgZSwgbmV3X2VkZ2U7CisgIGdp bXBsZSBzdG10OworICBiYXNpY19ibG9jayBndWFyZF9iYiA9IGd1YXJkLT5z cmM7CisgIGdpbXBsZV9zdG10X2l0ZXJhdG9yIGdzaTsKKyAgaW50IGZsYWdz ID0gMDsKKyAgYm9vbCBmaXhfZG9tX29mX2V4aXQ7CisgIGdjb25kICpjb25k X3N0bXQsICpuZXdfY29uZF9zdG10OworCisgIGJiID0gZ2V0X2ltbWVkaWF0 ZV9kb21pbmF0b3IgKENESV9ET01JTkFUT1JTLCBleGl0LT5kZXN0KTsKKyAg Zml4X2RvbV9vZl9leGl0ID0gZmxvd19iYl9pbnNpZGVfbG9vcF9wIChsb29w LCBiYik7CisgIGdzaSA9IGdzaV9sYXN0X2JiIChndWFyZF9iYik7CisgIHN0 bXQgPSBnc2lfc3RtdCAoZ3NpKTsKKyAgZ2NjX2Fzc2VydCAoZ2ltcGxlX2Nv ZGUgKHN0bXQpID09IEdJTVBMRV9DT05EKTsKKyAgY29uZF9zdG10ID0gYXNf YSA8Z2NvbmQgKj4gKHN0bXQpOworICBleHRyYWN0X3RydWVfZmFsc2VfZWRn ZXNfZnJvbV9ibG9jayAoZ3VhcmRfYmIsICZ0ZSwgJmZlKTsKKyAgLyogSW5z ZXJ0IGd1YXJkIHRvIFBSRV9IRUFERVIuICAqLworICBpZiAoIWVtcHR5X2Js b2NrX3AgKHByZV9oZWFkZXIpKQorICAgIGdzaSA9IGdzaV9sYXN0X2JiIChw cmVfaGVhZGVyKTsKKyAgZWxzZQorICAgIGdzaSA9IGdzaV9zdGFydF9iYiAo cHJlX2hlYWRlcik7CisgIC8qIENyZWF0ZSBjb3B5IG9mIENPTkRfU1RNVC4g ICovCisgIG5ld19jb25kX3N0bXQgPSBnaW1wbGVfYnVpbGRfY29uZCAoZ2lt cGxlX2NvbmRfY29kZSAoY29uZF9zdG10KSwKKwkJCQkgICAgIGdpbXBsZV9j b25kX2xocyAoY29uZF9zdG10KSwKKwkJCQkgICAgIGdpbXBsZV9jb25kX3Jo cyAoY29uZF9zdG10KSwKKwkJCQkgICAgIE5VTExfVFJFRSwgTlVMTF9UUkVF KTsKKyAgZ3NpX2luc2VydF9hZnRlciAoJmdzaSwgbmV3X2NvbmRfc3RtdCwg R1NJX05FV19TVE1UKTsKKyAgLyogQ29udmVydCBDT05EX1NUTVQgdG8gdHJ1 ZS9mYWxzZSBjb25kaXRpb25hbC4gICovCisgIGlmIChndWFyZCA9PSB0ZSkK KyAgICBnaW1wbGVfY29uZF9tYWtlX2ZhbHNlIChjb25kX3N0bXQpOworICBl bHNlCisgICAgZ2ltcGxlX2NvbmRfbWFrZV90cnVlIChjb25kX3N0bXQpOwor ICB1cGRhdGVfc3RtdCAoY29uZF9zdG10KTsKKyAgLyogQ3JlYXRlIG5ldyBs b29wIHByZS1oZWFkZXIuICAqLworICBlID0gc3BsaXRfYmxvY2sgKHByZV9o ZWFkZXIsIGxhc3Rfc3RtdCAocHJlX2hlYWRlcikpOworICBnY2NfYXNzZXJ0 IChsb29wX3ByZWhlYWRlcl9lZGdlIChsb29wKS0+c3JjID09IGUtPmRlc3Qp OworICBpZiAoZ3VhcmQgPT0gZmUpCisgICAgeworICAgICAgZS0+ZmxhZ3Mg PSBFREdFX1RSVUVfVkFMVUU7CisgICAgICBmbGFncyB8PSBFREdFX0ZBTFNF X1ZBTFVFOworICAgIH0KKyAgZWxzZQorICAgIHsKKyAgICAgIGUtPmZsYWdz ID0gRURHRV9GQUxTRV9WQUxVRTsKKyAgICAgIGZsYWdzIHw9IEVER0VfVFJV RV9WQUxVRTsKKyAgICB9CisgIG5ld19lZGdlID0gbWFrZV9lZGdlIChwcmVf aGVhZGVyLCBleGl0LT5kZXN0LCBmbGFncyk7CisgIGlmIChmaXhfZG9tX29m X2V4aXQpCisgICAgc2V0X2ltbWVkaWF0ZV9kb21pbmF0b3IgKENESV9ET01J TkFUT1JTLCBleGl0LT5kZXN0LCBwcmVfaGVhZGVyKTsKKyAgLyogQWRkIE5F V19BREdFIGFyZ3VtZW50IGZvciBhbGwgcGhpIGluIHBvc3QtaGVhZGVyIGJs b2NrLiAgKi8KKyAgYmIgPSBleGl0LT5kZXN0OworICBmb3IgKGdwaGlfaXRl cmF0b3IgZ3NpID0gZ3NpX3N0YXJ0X3BoaXMgKGJiKTsKKyAgICAgICAhZ3Np X2VuZF9wIChnc2kpOyBnc2lfbmV4dCAoJmdzaSkpCisgICAgeworICAgICAg Z3BoaSAqcGhpID0gZ3NpLnBoaSAoKTsKKyAgICAgIHRyZWUgYXJnOworICAg ICAgaWYgKHZpcnR1YWxfb3BlcmFuZF9wIChnaW1wbGVfcGhpX3Jlc3VsdCAo cGhpKSkpCisJeworCSAgYXJnID0gZ2V0X3ZvcF9mcm9tX2hlYWRlciAobG9v cCk7CisJICBpZiAoYXJnID09IE5VTExfVFJFRSkKKwkgICAgLyogVXNlIGV4 aXQgZWRnZSBhcmd1bWVudC4gICovCisJICAgIGFyZyA9ICBQSElfQVJHX0RF Rl9GUk9NX0VER0UgKHBoaSwgZXhpdCk7CisJICBhZGRfcGhpX2FyZyAocGhp LCBhcmcsIG5ld19lZGdlLCBVTktOT1dOX0xPQ0FUSU9OKTsKKwl9CisgICAg ICBlbHNlCisJeworCSAgLyogVXNlIGV4aXQgZWRnZSBhcmd1bWVudC4gICov CisJICBhcmcgPSBQSElfQVJHX0RFRl9GUk9NX0VER0UgKHBoaSwgZXhpdCk7 CisJICBhZGRfcGhpX2FyZyAocGhpLCBhcmcsIG5ld19lZGdlLCBVTktOT1dO X0xPQ0FUSU9OKTsKKwl9CisgICAgfQorCisgIG1hcmtfdmlydHVhbF9vcGVy YW5kc19mb3JfcmVuYW1pbmcgKGNmdW4pOworICB1cGRhdGVfc3NhIChUT0RP X3VwZGF0ZV9zc2EpOworICBpZiAoZHVtcF9maWxlICYmIChkdW1wX2ZsYWdz ICYgVERGX0RFVEFJTFMpKQorICAgIGZwcmludGYgKGR1bXBfZmlsZSwgIiAg Z3VhcmQgaG9pc3RlZC5cbiIpOworfQorCisvKiBSZXR1cm4gdHJ1ZSBpZiBw aGkgYXJndW1lbnQgZm9yIGV4aXQgZWRnZSBjYW4gYmUgdXNlZAorICAgZm9y IGVkZ2UgYXJvdW5kIGxvb3AuICAqLworCitzdGF0aWMgYm9vbAorY2hlY2tf ZXhpdF9waGkgKHN0cnVjdCBsb29wICpsb29wKQoreworICBlZGdlIGV4aXQg PSBzaW5nbGVfZXhpdCAobG9vcCk7CisgIGJhc2ljX2Jsb2NrIHByZV9oZWFk ZXIgPSBsb29wX3ByZWhlYWRlcl9lZGdlIChsb29wKS0+c3JjOworCisgIGZv ciAoZ3BoaV9pdGVyYXRvciBnc2kgPSBnc2lfc3RhcnRfcGhpcyAoZXhpdC0+ ZGVzdCk7CisgICAgICAgIWdzaV9lbmRfcCAoZ3NpKTsgZ3NpX25leHQgKCZn c2kpKQorICAgIHsKKyAgICAgIGdwaGkgKnBoaSA9IGdzaS5waGkgKCk7Cisg ICAgICB0cmVlIGFyZzsKKyAgICAgIGdpbXBsZSBkZWY7CisgICAgICBiYXNp Y19ibG9jayBkZWZfYmI7CisgICAgICBpZiAodmlydHVhbF9vcGVyYW5kX3Ag KGdpbXBsZV9waGlfcmVzdWx0IChwaGkpKSkKKwljb250aW51ZTsKKyAgICAg IGFyZyA9IFBISV9BUkdfREVGX0ZST01fRURHRSAocGhpLCBleGl0KTsKKyAg ICAgIGlmIChUUkVFX0NPREUgKGFyZykgIT0gU1NBX05BTUUpCisJY29udGlu dWU7CisgICAgICBkZWYgPSBTU0FfTkFNRV9ERUZfU1RNVCAoYXJnKTsKKyAg ICAgIGlmICghZGVmKQorCWNvbnRpbnVlOworICAgICAgZGVmX2JiID0gZ2lt cGxlX2JiIChkZWYpOworICAgICAgaWYgKCFkZWZfYmIpCisJY29udGludWU7 CisgICAgICBpZiAoIWRvbWluYXRlZF9ieV9wIChDRElfRE9NSU5BVE9SUywg cHJlX2hlYWRlciwgZGVmX2JiKSkKKwkvKiBEZWZpbml0aW9uIGluc2lkZSBs b29wISAgKi8KKwlyZXR1cm4gZmFsc2U7CisgICAgICAvKiBDaGVjayBsb29w IGNsb3NlZCBwaGkgaW52YXJpYW50LiAgKi8KKyAgICAgIGlmICghZmxvd19i Yl9pbnNpZGVfbG9vcF9wIChkZWZfYmItPmxvb3BfZmF0aGVyLCBwcmVfaGVh ZGVyKSkKKwlyZXR1cm4gZmFsc2U7CisgICAgfQorICByZXR1cm4gdHJ1ZTsK K30KKwogLyogTG9vcCB1bnN3aXRjaGluZyBwYXNzLiAgKi8KIAogbmFtZXNw YWNlIHsK --001a1140fa448e2923052180b770--