From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 23694 invoked by alias); 5 Sep 2019 12:51:13 -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 23686 invoked by uid 89); 5 Sep 2019 12:51:13 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-20.9 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_NUMSUBJECT,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.1 spammy= X-HELO: mail-lj1-f193.google.com Received: from mail-lj1-f193.google.com (HELO mail-lj1-f193.google.com) (209.85.208.193) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 05 Sep 2019 12:51:10 +0000 Received: by mail-lj1-f193.google.com with SMTP id l1so2313487lji.12 for ; Thu, 05 Sep 2019 05:51:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=mime-version:references:in-reply-to:from:date:message-id:subject:to; bh=XqY/+yhLRuelKoyASAwuBug0jk1WsM97OmXscRgp8Ww=; b=vS0WobbNC2PlaTvNwjIfc+c9z5fGG7lITFs3eGAbF5jxHPzTGGqnU10w3XhfXEp4YZ dT5c5N+NVP2aWnIFLvMAvYYdPraSiE/LcMRkAgq07/C5tlXsWAvqLsUd+62SWdtEbiR4 R3xcN8oS512CxEFWdjhQ43M64ZyFdd2/pAjeCGCRD47ymhH5UBea3FBj1i2e6wfy6BS+ xLKiIp7TcilC9sPbfYG9PrEuE/NPcClIqdfNiFAAeiCx35wRn6Xta1n61JQd2kcIM5Wn hvgujxMCzT7oAJdTmcn0y9KuOAoEWQiT9AMxZmpb3mQZid6iJYlOAmWM9b1T4iU4lBPY LkPg== MIME-Version: 1.0 References: In-Reply-To: From: Prathamesh Kulkarni Date: Thu, 05 Sep 2019 12:51:00 -0000 Message-ID: Subject: Re: [SVE] PR86753 To: Prathamesh Kulkarni , Richard Biener , gcc Patches , Richard Sandiford Content-Type: multipart/mixed; boundary="0000000000005d94ec0591cdc6c2" X-IsSubscribed: yes X-SW-Source: 2019-09/txt/msg00287.txt.bz2 --0000000000005d94ec0591cdc6c2 Content-Type: text/plain; charset="UTF-8" Content-length: 12049 On Thu, 5 Sep 2019 at 14:29, Richard Sandiford wrote: > > Sorry for the slow reply. > > Prathamesh Kulkarni writes: > > On Fri, 30 Aug 2019 at 16:15, Richard Biener wrote: > >> > >> On Wed, Aug 28, 2019 at 11:02 AM Richard Sandiford > >> wrote: > >> > > >> > Prathamesh Kulkarni writes: > >> > > On Tue, 27 Aug 2019 at 21:14, Richard Sandiford > >> > > wrote: > >> > >> > >> > >> Richard should have the final say, but some comments... > >> > >> > >> > >> Prathamesh Kulkarni writes: > >> > >> > diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c > >> > >> > index 1e2dfe5d22d..862206b3256 100644 > >> > >> > --- a/gcc/tree-vect-stmts.c > >> > >> > +++ b/gcc/tree-vect-stmts.c > >> > >> > @@ -1989,17 +1989,31 @@ check_load_store_masking (loop_vec_info loop_vinfo, tree vectype, > >> > >> > > >> > >> > static tree > >> > >> > prepare_load_store_mask (tree mask_type, tree loop_mask, tree vec_mask, > >> > >> > - gimple_stmt_iterator *gsi) > >> > >> > + gimple_stmt_iterator *gsi, tree mask, > >> > >> > + cond_vmask_map_type *cond_to_vec_mask) > >> > >> > >> > >> "scalar_mask" might be a better name. But maybe we should key off the > >> > >> vector mask after all, now that we're relying on the code having no > >> > >> redundancies. > >> > >> > >> > >> Passing the vinfo would be better than passing the cond_vmask_map_type > >> > >> directly. > >> > >> > >> > >> > { > >> > >> > gcc_assert (useless_type_conversion_p (mask_type, TREE_TYPE (vec_mask))); > >> > >> > if (!loop_mask) > >> > >> > return vec_mask; > >> > >> > > >> > >> > gcc_assert (TREE_TYPE (loop_mask) == mask_type); > >> > >> > + > >> > >> > + tree *slot = 0; > >> > >> > + if (cond_to_vec_mask) > >> > >> > >> > >> The pointer should never be null in this context. > >> > > Disabling check for NULL results in segfault with cond_arith_4.c because we > >> > > reach prepare_load_store_mask via vect_schedule_slp, called from > >> > > here in vect_transform_loop: > >> > > /* Schedule the SLP instances first, then handle loop vectorization > >> > > below. */ > >> > > if (!loop_vinfo->slp_instances.is_empty ()) > >> > > { > >> > > DUMP_VECT_SCOPE ("scheduling SLP instances"); > >> > > vect_schedule_slp (loop_vinfo); > >> > > } > >> > > > >> > > which is before bb processing loop. > >> > > >> > We want this optimisation to be applied to SLP too though. Especially > >> > since non-SLP will be going away at some point. > >> > > >> > But as Richard says, the problem with SLP is that the statements aren't > >> > traversed in block order, so I guess we can't do the on-the-fly > >> > redundancy elimination there... > >> > >> And the current patch AFAICS can generate wrong SSA for this reason. > >> > >> > Maybe an alternative would be to record during the analysis phase which > >> > scalar conditions need which loop masks. Statements that need a loop > >> > mask currently do: > >> > > >> > vect_record_loop_mask (loop_vinfo, masks, ncopies, vectype); > >> > > >> > If we also pass the scalar condition, we can maintain a hash_set of > >> > pairs, representing the conditions that have > >> > loop masks applied at some point in the vectorised code. The COND_EXPR > >> > code can use that set to decide whether to apply the loop mask or not. > >> > >> Yeah, that sounds better. > >> > >> Note that I don't like the extra "helpers" in fold-const.c/h, they do not look > >> useful in general so put them into vectorizer private code. The decomposing > >> also doesn't look too nice, instead prepare_load_store_mask could get > >> such decomposed representation - possibly quite natural with the suggestion > >> from Richard above. > > Hi, > > Thanks for the suggestions, I have an attached updated patch, that > > tries to address above suggestions. > > With patch, we manage to use same predicate for both tests in PR, and > > the redundant AND ops are eliminated > > by fre4. > > > > I have a few doubts: > > 1] I moved tree_cond_ops into tree-vectorizer.[ch], I will get rid of > > it in follow up patch. > > I am not sure what to pass as def of scalar condition (scalar_mask) to > > vect_record_loop_mask > > from vectorizable_store, vectorizable_reduction and > > vectorizable_live_operation ? In the patch, > > I just passed NULL. > > For vectorizable_store this is just "mask", like for vectorizable_load. > Passing NULL looks right for the other two. (Nit, GCC style is to use > NULL rather than 0.) > > > 2] Do changes to vectorizable_condition and > > vectorizable_condition_apply_loop_mask look OK ? > > Some comments below. > > > 3] The patch additionally regresses following tests (apart from fmla_2.c): > > FAIL: gcc.target/aarch64/sve/cond_convert_1.c -march=armv8.2-a+sve > > scan-assembler-not \\tsel\\t > > FAIL: gcc.target/aarch64/sve/cond_convert_4.c -march=armv8.2-a+sve > > scan-assembler-not \\tsel\\t > > FAIL: gcc.target/aarch64/sve/cond_unary_2.c -march=armv8.2-a+sve > > scan-assembler-not \\tsel\\t > > FAIL: gcc.target/aarch64/sve/cond_unary_2.c -march=armv8.2-a+sve > > scan-assembler-times \\tmovprfx\\t > > [...] > > For cond_convert_1.c, I think it would be OK to change the test to: > > for (int i = 0; i < n; ++i) \ > { \ > FLOAT_TYPE bi = b[i]; \ > r[i] = pred[i] ? (FLOAT_TYPE) a[i] : bi; \ > } \ > > so that only the a[i] load is conditional. Same for the other two. > > I think originally I had to write it this way precisely because > we didn't have the optimisation you're adding, so this is actually > a good sign :-) > > > @@ -8313,7 +8313,7 @@ vect_double_mask_nunits (tree type) > > > > void > > vect_record_loop_mask (loop_vec_info loop_vinfo, vec_loop_masks *masks, > > - unsigned int nvectors, tree vectype) > > + unsigned int nvectors, tree vectype, tree scalar_mask) > > { > > gcc_assert (nvectors != 0); > > if (masks->length () < nvectors) > > New parameter needs documentation. > > > diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c > > index dd9d45a9547..49ea86a0680 100644 > > --- a/gcc/tree-vect-stmts.c > > +++ b/gcc/tree-vect-stmts.c > > @@ -1888,7 +1888,7 @@ static void > > check_load_store_masking (loop_vec_info loop_vinfo, tree vectype, > > vec_load_store_type vls_type, int group_size, > > vect_memory_access_type memory_access_type, > > - gather_scatter_info *gs_info) > > + gather_scatter_info *gs_info, tree scalar_mask) > > { > > /* Invariant loads need no special support. */ > > if (memory_access_type == VMAT_INVARIANT) > > Same here. > > > @@ -9763,6 +9765,29 @@ vect_is_simple_cond (tree cond, vec_info *vinfo, > > return true; > > } > > > > +static void > > +vectorizable_condition_apply_loop_mask (tree &vec_compare, > > + gimple_stmt_iterator *&gsi, > > + stmt_vec_info &stmt_info, > > + tree loop_mask, > > + tree vec_cmp_type) > > Function needs a comment. > > I think it'd be better to return the new mask and not make vec_compare > a reference. stmt_info shouldn't need to be a reference either (it's > just a pointer type). > > > +{ > > + if (COMPARISON_CLASS_P (vec_compare)) > > + { > > + tree tmp = make_ssa_name (vec_cmp_type); > > + gassign *g = gimple_build_assign (tmp, TREE_CODE (vec_compare), > > + TREE_OPERAND (vec_compare, 0), > > + TREE_OPERAND (vec_compare, 1)); > > + vect_finish_stmt_generation (stmt_info, g, gsi); > > + vec_compare = tmp; > > + } > > + > > + tree tmp2 = make_ssa_name (vec_cmp_type); > > + gassign *g = gimple_build_assign (tmp2, BIT_AND_EXPR, vec_compare, loop_mask); > > + vect_finish_stmt_generation (stmt_info, g, gsi); > > + vec_compare = tmp2; > > +} > > + > > /* vectorizable_condition. > > > > Check if STMT_INFO is conditional modify expression that can be vectorized. > > @@ -9975,6 +10000,36 @@ vectorizable_condition (stmt_vec_info stmt_info, gimple_stmt_iterator *gsi, > > /* Handle cond expr. */ > > for (j = 0; j < ncopies; j++) > > { > > + tree loop_mask = NULL_TREE; > > + > > + if (loop_vinfo && LOOP_VINFO_FULLY_MASKED_P (loop_vinfo)) > > + { > > + scalar_cond_masked_key cond (cond_expr, ncopies); > > + if (loop_vinfo->scalar_cond_masked_set->contains (cond)) > > Nit: untabified line. > > > + { > > + scalar_cond_masked_key cond (cond_expr, ncopies); > > + if (loop_vinfo->scalar_cond_masked_set->contains (cond)) > > This "if" looks redundant -- isn't the condition the same as above? Oops sorry, probably a copy-paste typo -;) > > > + { > > + vec_loop_masks *masks = &LOOP_VINFO_MASKS (loop_vinfo); > > + loop_mask = vect_get_loop_mask (gsi, masks, ncopies, vectype, j); > > + } > > + } > > + else > > + { > > + cond.cond_ops.code > > + = invert_tree_comparison (cond.cond_ops.code, true); > > Would be better to pass an HONOR_NANS value instead of "true". > > > + if (loop_vinfo->scalar_cond_masked_set->contains (cond)) > > + { > > + vec_loop_masks *masks = &LOOP_VINFO_MASKS (loop_vinfo); > > + loop_mask = vect_get_loop_mask (gsi, masks, ncopies, vectype, j); > > + std::swap (then_clause, else_clause); > > + cond_code = cond.cond_ops.code; > > + cond_expr = build2 (cond_code, TREE_TYPE (cond_expr), > > + then_clause, else_clause); > > Rather than do the swap here and build a new tree, I think it would be > better to set a boolean that indicates that the then and else are swapped. > Then we can conditionally swap them after: > > vec_then_clause = vec_oprnds2[i]; > vec_else_clause = vec_oprnds3[i]; > > > [...] > > diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c > > index dc181524744..794e65f0007 100644 > > --- a/gcc/tree-vectorizer.c > > +++ b/gcc/tree-vectorizer.c > > @@ -464,6 +464,7 @@ vec_info::vec_info (vec_info::vec_kind kind_in, void *target_cost_data_in, > > target_cost_data (target_cost_data_in) > > { > > stmt_vec_infos.create (50); > > + scalar_cond_masked_set = new scalar_cond_masked_set_type (); > > } > > > > vec_info::~vec_info () > > @@ -476,6 +477,8 @@ vec_info::~vec_info () > > > > destroy_cost_data (target_cost_data); > > free_stmt_vec_infos (); > > + delete scalar_cond_masked_set; > > + scalar_cond_masked_set = 0; > > } > > > > vec_info_shared::vec_info_shared () > > No need to assign null here, since we're at the end of the destructor. > But maybe scalar_cond_masked_set should be "scalar_cond_masked_set_type" > rather than "scalar_cond_masked_set_type *", if the object is going to > have the same lifetime as the vec_info anyway. > > Looks good otherwise. I skipped over the tree_cond_ops bit given > your comment above that this was temporary. Thanks for the suggestions, I tried addressing them in attached patch. Does it look OK ? With patch, the only following FAIL remains for aarch64-sve.exp: FAIL: gcc.target/aarch64/sve/cond_unary_2.c -march=armv8.2-a+sve scan-assembler-times \\tmovprfx\\t 6 which now contains 14. Should I adjust the test, assuming the change isn't a regression ? Thanks, Prathamesh > > Thanks, > Richard --0000000000005d94ec0591cdc6c2 Content-Type: application/x-patch; name="pr86753-v2-2.diff" Content-Disposition: attachment; filename="pr86753-v2-2.diff" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_k06o5gbm0 Content-length: 19272 ZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0 L3N2ZS9jb25kX2NvbnZlcnRfMS5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFy Z2V0L2FhcmNoNjQvc3ZlL2NvbmRfY29udmVydF8xLmMKaW5kZXggNjk0Njhl YjY5YmUuLmQyZmZjYzc1OGYzIDEwMDY0NAotLS0gYS9nY2MvdGVzdHN1aXRl L2djYy50YXJnZXQvYWFyY2g2NC9zdmUvY29uZF9jb252ZXJ0XzEuYworKysg Yi9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYWFyY2g2NC9zdmUvY29uZF9j b252ZXJ0XzEuYwpAQCAtMTEsNyArMTEsMTAgQEAKIAkJICAgSU5UX1RZUEUg Kl9fcmVzdHJpY3QgcHJlZCwgaW50IG4pCQlcCiAgIHsJCQkJCQkJCVwKICAg ICBmb3IgKGludCBpID0gMDsgaSA8IG47ICsraSkJCQkJCVwKLSAgICAgIHJb aV0gPSBwcmVkW2ldID8gKEZMT0FUX1RZUEUpIGFbaV0gOiBiW2ldOwkJXAor ICAgICAgewkJCQkJCQkJXAorCUZMT0FUX1RZUEUgYmkgPSBiW2ldOwkJCQkJ XAorCXJbaV0gPSBwcmVkW2ldID8gKEZMT0FUX1RZUEUpIGFbaV0gOiBiaTsJ CVwKKyAgICAgIH0JCQkJCQkJCVwKICAgfQogCiAjZGVmaW5lIFRFU1RfQUxM KFQpIFwKZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9h YXJjaDY0L3N2ZS9jb25kX2NvbnZlcnRfNC5jIGIvZ2NjL3Rlc3RzdWl0ZS9n Y2MudGFyZ2V0L2FhcmNoNjQvc3ZlL2NvbmRfY29udmVydF80LmMKaW5kZXgg NTViNTM1ZmEwY2YuLmQ1NWFlZjBiYjlhIDEwMDY0NAotLS0gYS9nY2MvdGVz dHN1aXRlL2djYy50YXJnZXQvYWFyY2g2NC9zdmUvY29uZF9jb252ZXJ0XzQu YworKysgYi9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYWFyY2g2NC9zdmUv Y29uZF9jb252ZXJ0XzQuYwpAQCAtMTEsNyArMTEsMTAgQEAKIAkJICAgSU5U X1RZUEUgKl9fcmVzdHJpY3QgcHJlZCwgaW50IG4pCQlcCiAgIHsJCQkJCQkJ CVwKICAgICBmb3IgKGludCBpID0gMDsgaSA8IG47ICsraSkJCQkJCVwKLSAg ICAgIHJbaV0gPSBwcmVkW2ldID8gKElOVF9UWVBFKSBhW2ldIDogYltpXTsJ CQlcCisgICAgICB7CQkJCQkJCQlcCisJSU5UX1RZUEUgYmkgPSBiW2ldOwkJ CQkJXAorCXJbaV0gPSBwcmVkW2ldID8gKElOVF9UWVBFKSBhW2ldIDogYmk7 CQkJXAorICAgICAgfQkJCQkJCQkJXAogICB9CiAKICNkZWZpbmUgVEVTVF9B TEwoVCkgXApkaWZmIC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0 L2FhcmNoNjQvc3ZlL2NvbmRfdW5hcnlfMi5jIGIvZ2NjL3Rlc3RzdWl0ZS9n Y2MudGFyZ2V0L2FhcmNoNjQvc3ZlL2NvbmRfdW5hcnlfMi5jCmluZGV4IGFk ZjgyODM5OGJiLi5mMTc0ODBmYjJmMiAxMDA2NDQKLS0tIGEvZ2NjL3Rlc3Rz dWl0ZS9nY2MudGFyZ2V0L2FhcmNoNjQvc3ZlL2NvbmRfdW5hcnlfMi5jCisr KyBiL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0L3N2ZS9jb25k X3VuYXJ5XzIuYwpAQCAtMTMsNyArMTMsMTAgQEAKIAkJICAgICAgVFlQRSAq X19yZXN0cmljdCBwcmVkLCBpbnQgbikJCVwKICAgewkJCQkJCQkJXAogICAg IGZvciAoaW50IGkgPSAwOyBpIDwgbjsgKytpKQkJCQkJXAotICAgICAgcltp XSA9IHByZWRbaV0gPyBPUCAoYVtpXSkgOiBiW2ldOwkJCVwKKyAgICAgIHsJ CQkJCQkJCVwKKwlUWVBFIGJpID0gYltpXTsJCQkJCQlcCisJcltpXSA9IHBy ZWRbaV0gPyBPUCAoYVtpXSkgOiBiaTsJCQlcCisgICAgICB9CQkJCQkJCQlc CiAgIH0KIAogI2RlZmluZSBURVNUX0lOVF9UWVBFKFQsIFRZUEUpIFwKZGlm ZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0L3N2 ZS9mbWxhXzIuYyBiL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0 L3N2ZS9mbWxhXzIuYwppbmRleCA1YzA0YmNkYjNmNS4uYTFiMDY2N2RhYjUg MTAwNjQ0Ci0tLSBhL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0 L3N2ZS9mbWxhXzIuYworKysgYi9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQv YWFyY2g2NC9zdmUvZm1sYV8yLmMKQEAgLTE1LDUgKzE1LDkgQEAgZiAoZG91 YmxlICpyZXN0cmljdCBhLCBkb3VibGUgKnJlc3RyaWN0IGIsIGRvdWJsZSAq cmVzdHJpY3QgYywKICAgICB9CiB9CiAKLS8qIHsgZGctZmluYWwgeyBzY2Fu LWFzc2VtYmxlci10aW1lcyB7XHRmbWxhXHR6WzAtOV0rXC5kLCBwWzAtN10v bSwgelswLTldK1wuZCwgelswLTldK1wuZFxufSAyIH0gfSAqLworLyogU2Vl IGh0dHBzOi8vZ2NjLmdudS5vcmcvbWwvZ2NjLXBhdGNoZXMvMjAxOS0wOC9t c2cwMTY0NC5odG1sCisgICBmb3IgWEZBSUxpbmcgdGhlIGJlbG93IHRlc3Qu ICAqLworCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi1hc3NlbWJsZXItdGltZXMg e1x0Zm1sYVx0elswLTldK1wuZCwgcFswLTddL20sIHpbMC05XStcLmQsIHpb MC05XStcLmRcbn0gMiB7IHhmYWlsICotKi0qIH0gfSB9ICovCisvKiB7IGRn LWZpbmFsIHsgc2Nhbi1hc3NlbWJsZXItdGltZXMge1x0Zm1sYVx0elswLTld K1wuZCwgcFswLTddL20sIHpbMC05XStcLmQsIHpbMC05XStcLmRcbn0gMyB9 IH0gKi8KIC8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlci1ub3Qge1x0 Zm1hZFx0fSB9IH0gKi8KZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtbG9v cC5jIGIvZ2NjL3RyZWUtdmVjdC1sb29wLmMKaW5kZXggYjBjYmJhYzBjYjUu LmQ4NjlkZmFiZWIwIDEwMDY0NAotLS0gYS9nY2MvdHJlZS12ZWN0LWxvb3Au YworKysgYi9nY2MvdHJlZS12ZWN0LWxvb3AuYwpAQCAtNzE5Nyw3ICs3MTk3 LDcgQEAgdmVjdG9yaXphYmxlX3JlZHVjdGlvbiAoc3RtdF92ZWNfaW5mbyBz dG10X2luZm8sIGdpbXBsZV9zdG10X2l0ZXJhdG9yICpnc2ksCiAJICAgIH0K IAkgIGVsc2UKIAkgICAgdmVjdF9yZWNvcmRfbG9vcF9tYXNrIChsb29wX3Zp bmZvLCBtYXNrcywgbmNvcGllcyAqIHZlY19udW0sCi0JCQkJICAgdmVjdHlw ZV9pbik7CisJCQkJICAgdmVjdHlwZV9pbiwgTlVMTCk7CiAJfQogICAgICAg aWYgKGR1bXBfZW5hYmxlZF9wICgpCiAJICAmJiByZWR1Y3Rpb25fdHlwZSA9 PSBGT0xEX0xFRlRfUkVEVUNUSU9OKQpAQCAtODExMCw3ICs4MTEwLDcgQEAg dmVjdG9yaXphYmxlX2xpdmVfb3BlcmF0aW9uIChzdG10X3ZlY19pbmZvIHN0 bXRfaW5mbywKIAkgICAgICBnY2NfYXNzZXJ0IChuY29waWVzID09IDEgJiYg IXNscF9ub2RlKTsKIAkgICAgICB2ZWN0X3JlY29yZF9sb29wX21hc2sgKGxv b3BfdmluZm8sCiAJCQkJICAgICAmTE9PUF9WSU5GT19NQVNLUyAobG9vcF92 aW5mbyksCi0JCQkJICAgICAxLCB2ZWN0eXBlKTsKKwkJCQkgICAgIDEsIHZl Y3R5cGUsIE5VTEwpOwogCSAgICB9CiAJfQogICAgICAgcmV0dXJuIHRydWU7 CkBAIC04MzA5LDExICs4MzA5LDEyIEBAIHZlY3RfZG91YmxlX21hc2tfbnVu aXRzICh0cmVlIHR5cGUpCiAKIC8qIFJlY29yZCB0aGF0IGEgZnVsbHktbWFz a2VkIHZlcnNpb24gb2YgTE9PUF9WSU5GTyB3b3VsZCBuZWVkIE1BU0tTIHRv CiAgICBjb250YWluIGEgc2VxdWVuY2Ugb2YgTlZFQ1RPUlMgbWFza3MgdGhh dCBlYWNoIGNvbnRyb2wgYSB2ZWN0b3Igb2YgdHlwZQotICAgVkVDVFlQRS4g ICovCisgICBWRUNUWVBFLiBTQ0FMQVJfTUFTSyBpZiBub24tbnVsbCwgcmVw cmVzZW50cyB0aGUgbWFzayB1c2VkIGZvciBjb3JyZXNwb25kaW5nCisgICBs b2FkL3N0b3JlIHN0bXQuICAqLwogCiB2b2lkCiB2ZWN0X3JlY29yZF9sb29w X21hc2sgKGxvb3BfdmVjX2luZm8gbG9vcF92aW5mbywgdmVjX2xvb3BfbWFz a3MgKm1hc2tzLAotCQkgICAgICAgdW5zaWduZWQgaW50IG52ZWN0b3JzLCB0 cmVlIHZlY3R5cGUpCisJCSAgICAgICB1bnNpZ25lZCBpbnQgbnZlY3RvcnMs IHRyZWUgdmVjdHlwZSwgdHJlZSBzY2FsYXJfbWFzaykKIHsKICAgZ2NjX2Fz c2VydCAobnZlY3RvcnMgIT0gMCk7CiAgIGlmIChtYXNrcy0+bGVuZ3RoICgp IDwgbnZlY3RvcnMpCkBAIC04MzI5LDYgKzgzMzAsMTIgQEAgdmVjdF9yZWNv cmRfbG9vcF9tYXNrIChsb29wX3ZlY19pbmZvIGxvb3BfdmluZm8sIHZlY19s b29wX21hc2tzICptYXNrcywKICAgICAgIHJnbS0+bWF4X25zY2FsYXJzX3Bl cl9pdGVyID0gbnNjYWxhcnNfcGVyX2l0ZXI7CiAgICAgICByZ20tPm1hc2tf dHlwZSA9IGJ1aWxkX3NhbWVfc2l6ZWRfdHJ1dGhfdmVjdG9yX3R5cGUgKHZl Y3R5cGUpOwogICAgIH0KKworICBpZiAoc2NhbGFyX21hc2spCisgICAgewor ICAgICAgc2NhbGFyX2NvbmRfbWFza2VkX2tleSBjb25kIChzY2FsYXJfbWFz aywgbnZlY3RvcnMpOworICAgICAgbG9vcF92aW5mby0+c2NhbGFyX2NvbmRf bWFza2VkX3NldC5hZGQgKGNvbmQpOworICAgIH0KIH0KIAogLyogR2l2ZW4g YSBjb21wbGV0ZSBzZXQgb2YgbWFza3MgTUFTS1MsIGV4dHJhY3QgbWFzayBu dW1iZXIgSU5ERVgKZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3Qtc3RtdHMu YyBiL2djYy90cmVlLXZlY3Qtc3RtdHMuYwppbmRleCBkZDlkNDVhOTU0Ny4u MTRjMmZjYjUzYTcgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXZlY3Qtc3RtdHMu YworKysgYi9nY2MvdHJlZS12ZWN0LXN0bXRzLmMKQEAgLTE4NzksNyArMTg3 OSw4IEBAIHN0YXRpYyB0cmVlIHBlcm11dGVfdmVjX2VsZW1lbnRzICh0cmVl LCB0cmVlLCB0cmVlLCBzdG10X3ZlY19pbmZvLAogICAgc2F5cyBob3cgdGhl IGxvYWQgb3Igc3RvcmUgaXMgZ29pbmcgdG8gYmUgaW1wbGVtZW50ZWQgYW5k IEdST1VQX1NJWkUKICAgIGlzIHRoZSBudW1iZXIgb2YgbG9hZCBvciBzdG9y ZSBzdGF0ZW1lbnRzIGluIHRoZSBjb250YWluaW5nIGdyb3VwLgogICAgSWYg dGhlIGFjY2VzcyBpcyBhIGdhdGhlciBsb2FkIG9yIHNjYXR0ZXIgc3RvcmUs IEdTX0lORk8gZGVzY3JpYmVzCi0gICBpdHMgYXJndW1lbnRzLgorICAgaXRz IGFyZ3VtZW50cy4gU0NBTEFSX01BU0sgaXMgdGhlIHNjYWxhciBtYXNrIHVz ZWQgZm9yIGNvcnJlc3BvbmRpbmcKKyAgIGxvYWQgb3Igc3RvcmUgc3RtdC4K IAogICAgQ2xlYXIgTE9PUF9WSU5GT19DQU5fRlVMTFlfTUFTS19QIGlmIGEg ZnVsbHktbWFza2VkIGxvb3AgaXMgbm90CiAgICBzdXBwb3J0ZWQsIG90aGVy d2lzZSByZWNvcmQgdGhlIHJlcXVpcmVkIG1hc2sgdHlwZXMuICAqLwpAQCAt MTg4OCw3ICsxODg5LDcgQEAgc3RhdGljIHZvaWQKIGNoZWNrX2xvYWRfc3Rv cmVfbWFza2luZyAobG9vcF92ZWNfaW5mbyBsb29wX3ZpbmZvLCB0cmVlIHZl Y3R5cGUsCiAJCQkgIHZlY19sb2FkX3N0b3JlX3R5cGUgdmxzX3R5cGUsIGlu dCBncm91cF9zaXplLAogCQkJICB2ZWN0X21lbW9yeV9hY2Nlc3NfdHlwZSBt ZW1vcnlfYWNjZXNzX3R5cGUsCi0JCQkgIGdhdGhlcl9zY2F0dGVyX2luZm8g KmdzX2luZm8pCisJCQkgIGdhdGhlcl9zY2F0dGVyX2luZm8gKmdzX2luZm8s IHRyZWUgc2NhbGFyX21hc2spCiB7CiAgIC8qIEludmFyaWFudCBsb2FkcyBu ZWVkIG5vIHNwZWNpYWwgc3VwcG9ydC4gICovCiAgIGlmIChtZW1vcnlfYWNj ZXNzX3R5cGUgPT0gVk1BVF9JTlZBUklBTlQpCkBAIC0xOTEyLDcgKzE5MTMs NyBAQCBjaGVja19sb2FkX3N0b3JlX21hc2tpbmcgKGxvb3BfdmVjX2luZm8g bG9vcF92aW5mbywgdHJlZSB2ZWN0eXBlLAogCSAgcmV0dXJuOwogCX0KICAg ICAgIHVuc2lnbmVkIGludCBuY29waWVzID0gdmVjdF9nZXRfbnVtX2NvcGll cyAobG9vcF92aW5mbywgdmVjdHlwZSk7Ci0gICAgICB2ZWN0X3JlY29yZF9s b29wX21hc2sgKGxvb3BfdmluZm8sIG1hc2tzLCBuY29waWVzLCB2ZWN0eXBl KTsKKyAgICAgIHZlY3RfcmVjb3JkX2xvb3BfbWFzayAobG9vcF92aW5mbywg bWFza3MsIG5jb3BpZXMsIHZlY3R5cGUsIHNjYWxhcl9tYXNrKTsKICAgICAg IHJldHVybjsKICAgICB9CiAKQEAgLTE5MzYsNyArMTkzNyw3IEBAIGNoZWNr X2xvYWRfc3RvcmVfbWFza2luZyAobG9vcF92ZWNfaW5mbyBsb29wX3ZpbmZv LCB0cmVlIHZlY3R5cGUsCiAJICByZXR1cm47CiAJfQogICAgICAgdW5zaWdu ZWQgaW50IG5jb3BpZXMgPSB2ZWN0X2dldF9udW1fY29waWVzIChsb29wX3Zp bmZvLCB2ZWN0eXBlKTsKLSAgICAgIHZlY3RfcmVjb3JkX2xvb3BfbWFzayAo bG9vcF92aW5mbywgbWFza3MsIG5jb3BpZXMsIHZlY3R5cGUpOworICAgICAg dmVjdF9yZWNvcmRfbG9vcF9tYXNrIChsb29wX3ZpbmZvLCBtYXNrcywgbmNv cGllcywgdmVjdHlwZSwgc2NhbGFyX21hc2spOwogICAgICAgcmV0dXJuOwog ICAgIH0KIApAQCAtMTk3NCw3ICsxOTc1LDcgQEAgY2hlY2tfbG9hZF9zdG9y ZV9tYXNraW5nIChsb29wX3ZlY19pbmZvIGxvb3BfdmluZm8sIHRyZWUgdmVj dHlwZSwKICAgcG9seV91aW50NjQgdmYgPSBMT09QX1ZJTkZPX1ZFQ1RfRkFD VE9SIChsb29wX3ZpbmZvKTsKICAgdW5zaWduZWQgaW50IG52ZWN0b3JzOwog ICBpZiAoY2FuX2Rpdl9hd2F5X2Zyb21femVyb19wIChncm91cF9zaXplICog dmYsIG51bml0cywgJm52ZWN0b3JzKSkKLSAgICB2ZWN0X3JlY29yZF9sb29w X21hc2sgKGxvb3BfdmluZm8sIG1hc2tzLCBudmVjdG9ycywgdmVjdHlwZSk7 CisgICAgdmVjdF9yZWNvcmRfbG9vcF9tYXNrIChsb29wX3ZpbmZvLCBtYXNr cywgbnZlY3RvcnMsIHZlY3R5cGUsIHNjYWxhcl9tYXNrKTsKICAgZWxzZQog ICAgIGdjY191bnJlYWNoYWJsZSAoKTsKIH0KQEAgLTM0MzYsNyArMzQzNyw5 IEBAIHZlY3Rvcml6YWJsZV9jYWxsIChzdG10X3ZlY19pbmZvIHN0bXRfaW5m bywgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKmdzaSwKIAkgIHVuc2lnbmVkIGlu dCBudmVjdG9ycyA9IChzbHBfbm9kZQogCQkJCSAgID8gU0xQX1RSRUVfTlVN QkVSX09GX1ZFQ19TVE1UUyAoc2xwX25vZGUpCiAJCQkJICAgOiBuY29waWVz KTsKLQkgIHZlY3RfcmVjb3JkX2xvb3BfbWFzayAobG9vcF92aW5mbywgbWFz a3MsIG52ZWN0b3JzLCB2ZWN0eXBlX291dCk7CisJICB0cmVlIHNjYWxhcl9t YXNrID0gZ2ltcGxlX2NhbGxfYXJnIChzdG10X2luZm8tPnN0bXQsIG1hc2tf b3Bubyk7CisJICB2ZWN0X3JlY29yZF9sb29wX21hc2sgKGxvb3BfdmluZm8s IG1hc2tzLCBudmVjdG9ycywKKwkJCQkgdmVjdHlwZV9vdXQsIHNjYWxhcl9t YXNrKTsKIAl9CiAgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9CkBAIC03Mzkw LDcgKzczOTMsNyBAQCB2ZWN0b3JpemFibGVfc3RvcmUgKHN0bXRfdmVjX2lu Zm8gc3RtdF9pbmZvLCBnaW1wbGVfc3RtdF9pdGVyYXRvciAqZ3NpLAogICAg ICAgaWYgKGxvb3BfdmluZm8KIAkgICYmIExPT1BfVklORk9fQ0FOX0ZVTExZ X01BU0tfUCAobG9vcF92aW5mbykpCiAJY2hlY2tfbG9hZF9zdG9yZV9tYXNr aW5nIChsb29wX3ZpbmZvLCB2ZWN0eXBlLCB2bHNfdHlwZSwgZ3JvdXBfc2l6 ZSwKLQkJCQkgIG1lbW9yeV9hY2Nlc3NfdHlwZSwgJmdzX2luZm8pOworCQkJ CSAgbWVtb3J5X2FjY2Vzc190eXBlLCAmZ3NfaW5mbywgbWFzayk7CiAKICAg ICAgIFNUTVRfVklORk9fVFlQRSAoc3RtdF9pbmZvKSA9IHN0b3JlX3ZlY19p bmZvX3R5cGU7CiAgICAgICB2ZWN0X21vZGVsX3N0b3JlX2Nvc3QgKHN0bXRf aW5mbywgbmNvcGllcywgcmhzX2R0LCBtZW1vcnlfYWNjZXNzX3R5cGUsCkBA IC04NjM3LDcgKzg2NDAsNyBAQCB2ZWN0b3JpemFibGVfbG9hZCAoc3RtdF92 ZWNfaW5mbyBzdG10X2luZm8sIGdpbXBsZV9zdG10X2l0ZXJhdG9yICpnc2ks CiAgICAgICBpZiAobG9vcF92aW5mbwogCSAgJiYgTE9PUF9WSU5GT19DQU5f RlVMTFlfTUFTS19QIChsb29wX3ZpbmZvKSkKIAljaGVja19sb2FkX3N0b3Jl X21hc2tpbmcgKGxvb3BfdmluZm8sIHZlY3R5cGUsIFZMU19MT0FELCBncm91 cF9zaXplLAotCQkJCSAgbWVtb3J5X2FjY2Vzc190eXBlLCAmZ3NfaW5mbyk7 CisJCQkJICBtZW1vcnlfYWNjZXNzX3R5cGUsICZnc19pbmZvLCBtYXNrKTsK IAogICAgICAgU1RNVF9WSU5GT19UWVBFIChzdG10X2luZm8pID0gbG9hZF92 ZWNfaW5mb190eXBlOwogICAgICAgdmVjdF9tb2RlbF9sb2FkX2Nvc3QgKHN0 bXRfaW5mbywgbmNvcGllcywgbWVtb3J5X2FjY2Vzc190eXBlLApAQCAtOTk3 NSw2ICs5OTc4LDMxIEBAIHZlY3Rvcml6YWJsZV9jb25kaXRpb24gKHN0bXRf dmVjX2luZm8gc3RtdF9pbmZvLCBnaW1wbGVfc3RtdF9pdGVyYXRvciAqZ3Np LAogICAvKiBIYW5kbGUgY29uZCBleHByLiAgKi8KICAgZm9yIChqID0gMDsg aiA8IG5jb3BpZXM7IGorKykKICAgICB7CisgICAgICB0cmVlIGxvb3BfbWFz ayA9IE5VTExfVFJFRTsKKyAgICAgIGJvb2wgc3dhcF9jb25kX29wZXJhbmRz ID0gZmFsc2U7CisKKyAgICAgIGlmIChsb29wX3ZpbmZvICYmIExPT1BfVklO Rk9fRlVMTFlfTUFTS0VEX1AgKGxvb3BfdmluZm8pKQorCXsKKwkgIHNjYWxh cl9jb25kX21hc2tlZF9rZXkgY29uZCAoY29uZF9leHByLCBuY29waWVzKTsK KwkgIGlmIChsb29wX3ZpbmZvLT5zY2FsYXJfY29uZF9tYXNrZWRfc2V0LmNv bnRhaW5zIChjb25kKSkKKwkgICAgeworCSAgICAgIHZlY19sb29wX21hc2tz ICptYXNrcyA9ICZMT09QX1ZJTkZPX01BU0tTIChsb29wX3ZpbmZvKTsKKwkg ICAgICBsb29wX21hc2sgPSB2ZWN0X2dldF9sb29wX21hc2sgKGdzaSwgbWFz a3MsIG5jb3BpZXMsIHZlY3R5cGUsIGopOworCSAgICB9CisJICBlbHNlCisJ ICAgIHsKKwkgICAgICBjb25kLmNvZGUgPSBpbnZlcnRfdHJlZV9jb21wYXJp c29uIChjb25kLmNvZGUsCisJCQkJCQkgIEhPTk9SX05BTlMgKFRSRUVfVFlQ RSAoY29uZC5vcDApKSk7CisJICAgICAgaWYgKGxvb3BfdmluZm8tPnNjYWxh cl9jb25kX21hc2tlZF9zZXQuY29udGFpbnMgKGNvbmQpKQorCQl7CisJCSAg dmVjX2xvb3BfbWFza3MgKm1hc2tzID0gJkxPT1BfVklORk9fTUFTS1MgKGxv b3BfdmluZm8pOworCQkgIGxvb3BfbWFzayA9IHZlY3RfZ2V0X2xvb3BfbWFz ayAoZ3NpLCBtYXNrcywgbmNvcGllcywgdmVjdHlwZSwgaik7CisJCSAgY29u ZF9jb2RlID0gY29uZC5jb2RlOyAKKwkJICBzd2FwX2NvbmRfb3BlcmFuZHMg PSB0cnVlOworCQl9CisJICAgIH0KKwl9CisKICAgICAgIHN0bXRfdmVjX2lu Zm8gbmV3X3N0bXRfaW5mbyA9IE5VTEw7CiAgICAgICBpZiAoaiA9PSAwKQog CXsKQEAgLTEwMDUyLDYgKzEwMDgwLDkgQEAgdmVjdG9yaXphYmxlX2NvbmRp dGlvbiAoc3RtdF92ZWNfaW5mbyBzdG10X2luZm8sIGdpbXBsZV9zdG10X2l0 ZXJhdG9yICpnc2ksCiAgICAgICAgICAgdmVjX3RoZW5fY2xhdXNlID0gdmVj X29wcm5kczJbaV07CiAgICAgICAgICAgdmVjX2Vsc2VfY2xhdXNlID0gdmVj X29wcm5kczNbaV07CiAKKwkgIGlmIChzd2FwX2NvbmRfb3BlcmFuZHMpCisJ ICAgIHN0ZDo6c3dhcCAodmVjX3RoZW5fY2xhdXNlLCB2ZWNfZWxzZV9jbGF1 c2UpOworCiAJICBpZiAobWFza2VkKQogCSAgICB2ZWNfY29tcGFyZSA9IHZl Y19jb25kX2xoczsKIAkgIGVsc2UKQEAgLTEwMDkwLDYgKzEwMTIxLDI2IEBA IHZlY3Rvcml6YWJsZV9jb25kaXRpb24gKHN0bXRfdmVjX2luZm8gc3RtdF9p bmZvLCBnaW1wbGVfc3RtdF9pdGVyYXRvciAqZ3NpLAogCQkgICAgfQogCQl9 CiAJICAgIH0KKworCSAgaWYgKGxvb3BfbWFzaykKKwkgICAgeworCSAgICAg IGlmIChDT01QQVJJU09OX0NMQVNTX1AgKHZlY19jb21wYXJlKSkKKwkJewor CQkgIHRyZWUgdG1wID0gbWFrZV9zc2FfbmFtZSAodmVjX2NtcF90eXBlKTsK KwkJICBnYXNzaWduICpnID0gZ2ltcGxlX2J1aWxkX2Fzc2lnbiAodG1wLAor CQkJCQkJICAgIFRSRUVfQ09ERSAodmVjX2NvbXBhcmUpLAorCQkJCQkJICAg IFRSRUVfT1BFUkFORCAodmVjX2NvbXBhcmUsIDApLAorCQkJCQkJICAgIFRS RUVfT1BFUkFORCAodmVjX2NvbXBhcmUsIDEpKTsKKwkJICB2ZWN0X2Zpbmlz aF9zdG10X2dlbmVyYXRpb24gKHN0bXRfaW5mbywgZywgZ3NpKTsKKwkJICB2 ZWNfY29tcGFyZSA9IHRtcDsKKwkJfQorCisJICAgICAgdHJlZSB0bXAyID0g bWFrZV9zc2FfbmFtZSAodmVjX2NtcF90eXBlKTsKKwkgICAgICBnYXNzaWdu ICpnID0gZ2ltcGxlX2J1aWxkX2Fzc2lnbiAodG1wMiwgQklUX0FORF9FWFBS LCB2ZWNfY29tcGFyZSwgbG9vcF9tYXNrKTsKKwkgICAgICB2ZWN0X2Zpbmlz aF9zdG10X2dlbmVyYXRpb24gKHN0bXRfaW5mbywgZywgZ3NpKTsKKwkgICAg ICB2ZWNfY29tcGFyZSA9IHRtcDI7CisJICAgIH0KKwogCSAgaWYgKHJlZHVj dGlvbl90eXBlID09IEVYVFJBQ1RfTEFTVF9SRURVQ1RJT04pCiAJICAgIHsK IAkgICAgICBpZiAoIWlzX2dpbXBsZV92YWwgKHZlY19jb21wYXJlKSkKZGlm ZiAtLWdpdCBhL2djYy90cmVlLXZlY3Rvcml6ZXIuYyBiL2djYy90cmVlLXZl Y3Rvcml6ZXIuYwppbmRleCBkYzE4MTUyNDc0NC4uYzRiMmQ4ZTg2NDcgMTAw NjQ0Ci0tLSBhL2djYy90cmVlLXZlY3Rvcml6ZXIuYworKysgYi9nY2MvdHJl ZS12ZWN0b3JpemVyLmMKQEAgLTE1MTMsMyArMTUxMywzOSBAQCBtYWtlX3Bh c3NfaXBhX2luY3JlYXNlX2FsaWdubWVudCAoZ2NjOjpjb250ZXh0ICpjdHh0 KQogewogICByZXR1cm4gbmV3IHBhc3NfaXBhX2luY3JlYXNlX2FsaWdubWVu dCAoY3R4dCk7CiB9CisKKy8qIElmIGNvZGUoVCkgaXMgY29tcGFyaXNvbiBv cCBvciBkZWYgb2YgY29tcGFyaXNvbiBzdG10LAorICAgZXh0cmFjdCBpdCdz IG9wZXJhbmRzLgorICAgRWxzZSByZXR1cm4gPE5FX0VYUFIsIFQsIDA+LiAg Ki8KKwordm9pZAorc2NhbGFyX2NvbmRfbWFza2VkX2tleTo6Z2V0X2NvbmRf b3BzX2Zyb21fdHJlZSAodHJlZSB0KSAKK3sKKyAgaWYgKFRSRUVfQ09ERV9D TEFTUyAoVFJFRV9DT0RFICh0KSkgPT0gdGNjX2NvbXBhcmlzb24pCisgICAg eworICAgICAgdGhpcy0+Y29kZSA9IFRSRUVfQ09ERSAodCk7CisgICAgICB0 aGlzLT5vcDAgPSBUUkVFX09QRVJBTkQgKHQsIDApOworICAgICAgdGhpcy0+ b3AxID0gVFJFRV9PUEVSQU5EICh0LCAxKTsKKyAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgaWYgKFRSRUVfQ09ERSAodCkgPT0gU1NBX05BTUUpCisgICAg eworICAgICAgZ2Fzc2lnbiAqc3RtdCA9IGR5bl9jYXN0PGdhc3NpZ24gKj4g KFNTQV9OQU1FX0RFRl9TVE1UICh0KSk7CisgICAgICBpZiAoc3RtdCkKKyAg ICAgICAgeworICAgICAgICAgIHRyZWVfY29kZSBjb2RlID0gZ2ltcGxlX2Fz c2lnbl9yaHNfY29kZSAoc3RtdCk7CisgICAgICAgICAgaWYgKFRSRUVfQ09E RV9DTEFTUyAoY29kZSkgPT0gdGNjX2NvbXBhcmlzb24pCisgICAgICAgICAg ICB7CisgICAgICAgICAgICAgIHRoaXMtPmNvZGUgPSBjb2RlOworICAgICAg ICAgICAgICB0aGlzLT5vcDAgPSBnaW1wbGVfYXNzaWduX3JoczEgKHN0bXQp OworICAgICAgICAgICAgICB0aGlzLT5vcDEgPSBnaW1wbGVfYXNzaWduX3Jo czIgKHN0bXQpOworICAgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAg ICB9CisgICAgICAgIH0KKyAgICB9CisKKyAgdGhpcy0+Y29kZSA9IE5FX0VY UFI7CisgIHRoaXMtPm9wMCA9IHQ7CisgIHRoaXMtPm9wMSA9IGJ1aWxkX3pl cm9fY3N0IChUUkVFX1RZUEUgKHQpKTsKK30KZGlmZiAtLWdpdCBhL2djYy90 cmVlLXZlY3Rvcml6ZXIuaCBiL2djYy90cmVlLXZlY3Rvcml6ZXIuaAppbmRl eCAxNDU2Y2RlNGMyYy4uZTIwYTYxZWUzM2YgMTAwNjQ0Ci0tLSBhL2djYy90 cmVlLXZlY3Rvcml6ZXIuaAorKysgYi9nY2MvdHJlZS12ZWN0b3JpemVyLmgK QEAgLTI2LDYgKzI2LDcgQEAgdHlwZWRlZiBjbGFzcyBfc3RtdF92ZWNfaW5m byAqc3RtdF92ZWNfaW5mbzsKICNpbmNsdWRlICJ0cmVlLWRhdGEtcmVmLmgi CiAjaW5jbHVkZSAidHJlZS1oYXNoLXRyYWl0cy5oIgogI2luY2x1ZGUgInRh cmdldC5oIgorI2luY2x1ZGUgImhhc2gtc2V0LmgiCiAKIC8qIFVzZWQgZm9y IG5hbWluZyBvZiBuZXcgdGVtcG9yYXJpZXMuICAqLwogZW51bSB2ZWN0X3Zh cl9raW5kIHsKQEAgLTE3NCw3ICsxNzUsNzEgQEAgcHVibGljOgogI2RlZmlu ZSBTTFBfVFJFRV9UV09fT1BFUkFUT1JTKFMpCQkgKFMpLT50d29fb3BlcmF0 b3JzCiAjZGVmaW5lIFNMUF9UUkVFX0RFRl9UWVBFKFMpCQkJIChTKS0+ZGVm X3R5cGUKIAorc3RydWN0IHNjYWxhcl9jb25kX21hc2tlZF9rZXkKK3sKKyAg c2NhbGFyX2NvbmRfbWFza2VkX2tleSAodHJlZSB0LCB1bnNpZ25lZCBuY29w aWVzXykKKyAgICA6IG5jb3BpZXMgKG5jb3BpZXNfKQorICB7CisgICAgZ2V0 X2NvbmRfb3BzX2Zyb21fdHJlZSAodCk7CisgIH0KKworICB2b2lkIGdldF9j b25kX29wc19mcm9tX3RyZWUgKHRyZWUpOworCisgIHVuc2lnbmVkIG5jb3Bp ZXM7CisgIHRyZWVfY29kZSBjb2RlOworICB0cmVlIG9wMDsKKyAgdHJlZSBv cDE7Cit9OwogCit0ZW1wbGF0ZTw+CitzdHJ1Y3QgZGVmYXVsdF9oYXNoX3Ry YWl0czxzY2FsYXJfY29uZF9tYXNrZWRfa2V5PgoreworICB0eXBlZGVmIHNj YWxhcl9jb25kX21hc2tlZF9rZXkgY29tcGFyZV90eXBlOworICB0eXBlZGVm IHNjYWxhcl9jb25kX21hc2tlZF9rZXkgdmFsdWVfdHlwZTsKKworICBzdGF0 aWMgaW5saW5lIGhhc2h2YWxfdAorICBoYXNoICh2YWx1ZV90eXBlIHYpCisg IHsKKyAgICBpbmNoYXNoOjpoYXNoIGg7CisgICAgaC5hZGRfaW50ICh2LmNv ZGUpOworICAgIGluY2hhc2g6OmFkZF9leHByICh2Lm9wMCwgaCwgMCk7Cisg ICAgaW5jaGFzaDo6YWRkX2V4cHIgKHYub3AxLCBoLCAwKTsKKyAgICBoLmFk ZF9pbnQgKHYubmNvcGllcyk7CisgICAgcmV0dXJuIGguZW5kICgpOworICB9 CisKKyAgc3RhdGljIGlubGluZSBib29sCisgIGVxdWFsICh2YWx1ZV90eXBl IGV4aXN0aW5nLCB2YWx1ZV90eXBlIGNhbmRpZGF0ZSkKKyAgeworICAgIHJl dHVybiAoZXhpc3RpbmcubmNvcGllcyA9PSBjYW5kaWRhdGUubmNvcGllcwor CSAgICAmJiBleGlzdGluZy5jb2RlID09IGNhbmRpZGF0ZS5jb2RlCisJICAg ICYmIG9wZXJhbmRfZXF1YWxfcCAoZXhpc3Rpbmcub3AwLCBjYW5kaWRhdGUu b3AwLCAwKQorCSAgICAmJiBvcGVyYW5kX2VxdWFsX3AgKGV4aXN0aW5nLm9w MSwgY2FuZGlkYXRlLm9wMSwgMCkpOworICB9CisKKyAgc3RhdGljIGlubGlu ZSB2b2lkCisgIG1hcmtfZW1wdHkgKHZhbHVlX3R5cGUgJnYpCisgIHsKKyAg ICB2Lm5jb3BpZXMgPSAwOworICB9CisKKyAgc3RhdGljIGlubGluZSBib29s CisgIGlzX2VtcHR5ICh2YWx1ZV90eXBlIHYpCisgIHsKKyAgICByZXR1cm4g di5uY29waWVzID09IDA7CisgIH0KKworICBzdGF0aWMgaW5saW5lIHZvaWQg bWFya19kZWxldGVkICh2YWx1ZV90eXBlICYpIHt9CisKKyAgc3RhdGljIGlu bGluZSBib29sIGlzX2RlbGV0ZWQgKGNvbnN0IHZhbHVlX3R5cGUgJikKKyAg eworICAgIHJldHVybiBmYWxzZTsKKyAgfQorCisgIHN0YXRpYyBpbmxpbmUg dm9pZCByZW1vdmUgKHZhbHVlX3R5cGUgJikge30KK307CisKK3R5cGVkZWYg aGFzaF9zZXQ8c2NhbGFyX2NvbmRfbWFza2VkX2tleT4gc2NhbGFyX2NvbmRf bWFza2VkX3NldF90eXBlOwogCiAvKiBEZXNjcmliZXMgdHdvIG9iamVjdHMg d2hvc2UgYWRkcmVzc2VzIG11c3QgYmUgdW5lcXVhbCBmb3IgdGhlIHZlY3Rv cml6ZWQKICAgIGxvb3AgdG8gYmUgdmFsaWQuICAqLwpAQCAtMjU1LDYgKzMy MCw5IEBAIHB1YmxpYzoKICAgLyogQ29zdCBkYXRhIHVzZWQgYnkgdGhlIHRh cmdldCBjb3N0IG1vZGVsLiAgKi8KICAgdm9pZCAqdGFyZ2V0X2Nvc3RfZGF0 YTsKIAorICAvKiBTZXQgb2Ygc2NhbGFyIGNvbmRpdGlvbnMgdGhhdCBoYXZl IGxvb3AgbWFzayBhcHBsaWVkLiAgKi8KKyAgc2NhbGFyX2NvbmRfbWFza2Vk X3NldF90eXBlIHNjYWxhcl9jb25kX21hc2tlZF9zZXQ7CisKIHByaXZhdGU6 CiAgIHN0bXRfdmVjX2luZm8gbmV3X3N0bXRfdmVjX2luZm8gKGdpbXBsZSAq c3RtdCk7CiAgIHZvaWQgc2V0X3ZpbmZvX2Zvcl9zdG10IChnaW1wbGUgKiwg c3RtdF92ZWNfaW5mbyk7CkBAIC0xNjE3LDcgKzE2ODUsNyBAQCBleHRlcm4g dm9pZCB2ZWN0X2dlbl92ZWN0b3JfbG9vcF9uaXRlcnMgKGxvb3BfdmVjX2lu Zm8sIHRyZWUsIHRyZWUgKiwKIGV4dGVybiB0cmVlIHZlY3RfaGFsdmVfbWFz a19udW5pdHMgKHRyZWUpOwogZXh0ZXJuIHRyZWUgdmVjdF9kb3VibGVfbWFz a19udW5pdHMgKHRyZWUpOwogZXh0ZXJuIHZvaWQgdmVjdF9yZWNvcmRfbG9v cF9tYXNrIChsb29wX3ZlY19pbmZvLCB2ZWNfbG9vcF9tYXNrcyAqLAotCQkJ CSAgIHVuc2lnbmVkIGludCwgdHJlZSk7CisJCQkJICAgdW5zaWduZWQgaW50 LCB0cmVlLCB0cmVlKTsKIGV4dGVybiB0cmVlIHZlY3RfZ2V0X2xvb3BfbWFz ayAoZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKiwgdmVjX2xvb3BfbWFza3MgKiwK IAkJCQl1bnNpZ25lZCBpbnQsIHRyZWUsIHVuc2lnbmVkIGludCk7CiAK --0000000000005d94ec0591cdc6c2--