From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 57909 invoked by alias); 19 Nov 2015 15:20:15 -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 57841 invoked by uid 89); 19 Nov 2015 15:20:15 -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-f52.google.com Received: from mail-oi0-f52.google.com (HELO mail-oi0-f52.google.com) (209.85.218.52) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Thu, 19 Nov 2015 15:20:11 +0000 Received: by oiww189 with SMTP id w189so46608661oiw.3 for ; Thu, 19 Nov 2015 07:20:09 -0800 (PST) MIME-Version: 1.0 X-Received: by 10.202.75.1 with SMTP id y1mr5075478oia.42.1447946408773; Thu, 19 Nov 2015 07:20:08 -0800 (PST) Received: by 10.202.61.193 with HTTP; Thu, 19 Nov 2015 07:20:08 -0800 (PST) In-Reply-To: References: <559F5D7B.6070208@redhat.com> <55B148AB.6010103@redhat.com> <55B28DCB.2080404@redhat.com> Date: Thu, 19 Nov 2015 15:20:00 -0000 Message-ID: Subject: Re: [PATCH] Simple optimization for MASK_STORE. From: Yuri Rumyantsev To: Richard Biener Cc: Ilya Enkovich , Jeff Law , gcc-patches , Igor Zamyatin Content-Type: multipart/mixed; boundary=001a11c15cfa59b8450524e64b47 X-SW-Source: 2015-11/txt/msg02351.txt.bz2 --001a11c15cfa59b8450524e64b47 Content-Type: text/plain; charset=UTF-8 Content-length: 8000 Hi Richard, I send you updated version of patch which contains fixes you mentioned and additional early exit in register_edge_assert_for() for gcond with vector comparison - it tries to produce assert for if (vect != {0,0,0,0}) but can't create such constant. This is not essential since this is applied to very specialized context. My answers are below. 2015-11-12 16:58 GMT+03:00 Richard Biener : > On Wed, Nov 11, 2015 at 2:13 PM, Yuri Rumyantsev wrote: >> Richard, >> >> What we should do to cope with this problem (structure size increasing)? >> Should we return to vector comparison version? > > Ok, given this constraint I think the cleanest approach is to allow > integer(!) vector equality(!) compares with scalar result. This should then > expand via cmp_optab and not via vec_cmp_optab. In fact it is expanded through cbranch_optab since the only use of such comparison is for masked store motion > > On gimple you can then have > > if (mask_vec_1 != {0, 0, .... }) > ... > > Note that a fallback expansion (for optabs.c to try) would be > the suggested view-conversion (aka, subreg) variant using > a same-sized integer mode. > > Target maintainers can then choose what is a better fit for > their target (and instruction set as register set constraints may apply). > > The patch you posted seems to do this but not restrict the compares > to integer ones (please do that). > > if (TREE_CODE (op0_type) == VECTOR_TYPE > || TREE_CODE (op1_type) == VECTOR_TYPE) > { > - error ("vector comparison returning a boolean"); > - debug_generic_expr (op0_type); > - debug_generic_expr (op1_type); > - return true; > + /* Allow vector comparison returning boolean if operand types > + are equal and CODE is EQ/NE. */ > + if ((code != EQ_EXPR && code != NE_EXPR) > + || TREE_CODE (op0_type) != TREE_CODE (op1_type) > + || TYPE_VECTOR_SUBPARTS (op0_type) > + != TYPE_VECTOR_SUBPARTS (op1_type) > + || GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0_type))) > + != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1_type)))) > > These are all checked with the useless_type_conversion_p checks done earlier. > > As said I'd like to see a > > || ! VECTOR_INTEGER_TYPE_P (op0_type) I added check on VECTOR_BOOLEAN_TYPE_P (op0_type) instead since type of mask was changed. > > check added so we and targets do not need to worry about using EQ/NE vs. CMP > and worry about signed zeros and friends. > > + { > + error ("type mismatch for vector comparison returning a boolean"); > + debug_generic_expr (op0_type); > + debug_generic_expr (op1_type); > + return true; > + } > > > > --- a/gcc/tree-ssa-forwprop.c > +++ b/gcc/tree-ssa-forwprop.c > @@ -422,6 +422,15 @@ forward_propagate_into_comparison_1 (gimple *stmt, > enum tree_code def_code = gimple_assign_rhs_code (def_stmt); > bool invariant_only_p = !single_use0_p; > > + /* Can't combine vector comparison with scalar boolean type of > + the result and VEC_COND_EXPR having vector type of comparison. */ > + if (TREE_CODE (TREE_TYPE (op0)) == VECTOR_TYPE > + && INTEGRAL_TYPE_P (type) > + && (TREE_CODE (type) == BOOLEAN_TYPE > + || TYPE_PRECISION (type) == 1) > + && def_code == VEC_COND_EXPR) > + return NULL_TREE; > > this hints at larger fallout you paper over here. So this effectively > means we're trying combining (vec1 != vec2) != 0 for example > and that fails miserably? If so then the solution is to fix whatever > does not expect this (valid) GENERIC tree. I changed it to the following check in combine_cond_expr_cond: /* Do not perform combining it types are not compatible. */ if (TREE_CODE (TREE_TYPE (op0)) == VECTOR_TYPE && !tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (op0)))) return NULL_TREE; > > + if (ENABLE_ZERO_TEST_FOR_MASK_STORE == 0) > + return; > > not sure if I like a param more than a target hook ... :/ I introduced the param instead of a target hook to make this transformation user visible, i.e. to switch it on/off for different targets. > > + /* Create vector comparison with boolean result. */ > + vectype = TREE_TYPE (mask); > + zero = build_zero_cst (TREE_TYPE (vectype)); > + zero = build_vector_from_val (vectype, zero); > > build_zero_cst (vectype); Done. > > + stmt = gimple_build_cond (EQ_EXPR, mask, zero, NULL_TREE, NULL_TREE); > > you can omit the NULL_TREE operands. I did not find such definition for it. > > + gcc_assert (vdef && TREE_CODE (vdef) == SSA_NAME); > > please omit the assert. Done. > > + gimple_set_vdef (last, new_vdef); > > do this before you create the PHI. > Done. > + /* Put definition statement of stored value in STORE_BB > + if possible. */ > + arg3 = gimple_call_arg (last, 3); > + if (TREE_CODE (arg3) == SSA_NAME && has_single_use (arg3)) > + { > ... > > is this really necessary? It looks incomplete to me anyway. I'd rather have > a late sink pass if this shows necessary. Btw,.. I tried to avoid creation of multiple ne basic blocks for the same mask and also I don't want to put all semi-hammock guarded by this mask to separate block to keep it small enough since x86 chips prefer short branches. Note also that icc does almost the same. > > + it is legal. */ > + if (gimple_bb (def_stmt) == bb > + && is_valid_sink (def_stmt, last_store)) > > with the implementation of is_valid_sink this is effectively > > && (!gimple_vuse (def_stmt) > || gimple_vuse (def_stmt) == gimple_vdef (last_store)) I did inlining of correspondent part of "is_valif_sink" to this place. > > I still think this "pass" is quite a hack, esp. as it appears as generic > code in a GIMPLE pass. And esp. as this hack seems to be needed > for Haswell only, not Boradwell or Skylake. This is not truth since for all them this transformation is performed for skylake and broadwell since both them belong to HASWELL family. > > Thanks, > Richard. > ChangeLog: 2015-11-19 Yuri Rumyantsev * config/i386/i386.c: Add conditional initialization of PARAM_ZERO_TEST_FOR_MASK_STORE. (ix86_expand_branch): Implement vector comparison with boolean result. * config/i386/i386.h: New macros TARGET_OPTIMIZE_MASK_STORE. * config/i386/sse.md (define_expand "cbranch4): Add define-expand for vector comparion with eq/ne only. * config/i386/x86-tune.def: New macros X86_TUNE_OPTIMIZE_MASK_STORE. * fold-const.c (fold_relational_const): Add handling of vector comparison with boolean result. * params.def (PARAM_ZERO_TEST_FOR_MASK_STORE): New DEFPARAM. * params.h (ENABLE_ZERO_TEST_FOR_MASK_STORE): New macros. * tree-cfg.c (verify_gimple_comparison): Add argument CODE, allow comparison of vector operands with boolean result for EQ/NE only. (verify_gimple_assign_binary): Adjust call for verify_gimple_comparison. (verify_gimple_cond): Likewise. * tree-ssa-forwprop.c (combine_cond_expr_cond): Do not perform combining for non-compatible vector types. * tree-vect-loop.c (is_valid_sink): New function. (optimize_mask_stores): Likewise. * tree-vect-stmts.c (vectorizable_mask_load_store): Initialize has_mask_store field of vect_info. * tree-vectorizer.c (vectorize_loops): Invoke optimaze_mask_stores for vectorized loops having masked stores. * tree-vectorizer.h (loop_vec_info): Add new has_mask_store field and correspondent macros. (optimize_mask_stores): Add prototype. * tree-vrp.c (register_edge_assert_for): Do not handle NAME with vector type. gcc/testsuite/ChangeLog: * gcc.target/i386/avx2-vect-mask-store-move1.c: New test. * gcc.target/i386/avx2-vect-mask-store-move2.c: Likewise. --001a11c15cfa59b8450524e64b47 Content-Type: application/octet-stream; name="patch.6" Content-Disposition: attachment; filename="patch.6" Content-Transfer-Encoding: base64 X-Attachment-Id: f_ih6dw4el0 Content-length: 26320 ZGlmZiAtLWdpdCBhL2djYy9jb25maWcvaTM4Ni9pMzg2LmMgYi9nY2MvY29u ZmlnL2kzODYvaTM4Ni5jCmluZGV4IDgzNzQ5ZDUuLjVhNTE1ZjggMTAwNjQ0 Ci0tLSBhL2djYy9jb25maWcvaTM4Ni9pMzg2LmMKKysrIGIvZ2NjL2NvbmZp Zy9pMzg2L2kzODYuYwpAQCAtNTMyNiw2ICs1MzI2LDEyIEBAIGl4ODZfb3B0 aW9uX292ZXJyaWRlX2ludGVybmFsIChib29sIG1haW5fYXJnc19wLAogCQkJ IG9wdHMtPnhfcGFyYW1fdmFsdWVzLAogCQkJIG9wdHNfc2V0LT54X3BhcmFt X3ZhbHVlcyk7CiAKKyAgaWYgKFRBUkdFVF9PUFRJTUlaRV9NQVNLX1NUT1JF KQorICAgIG1heWJlX3NldF9wYXJhbV92YWx1ZSAoUEFSQU1fWkVST19URVNU X0ZPUl9NQVNLX1NUT1JFLAorCQkJICAgMSwKKwkJCSAgIG9wdHMtPnhfcGFy YW1fdmFsdWVzLAorCQkJICAgb3B0c19zZXQtPnhfcGFyYW1fdmFsdWVzKTsK KwogICAvKiBFbmFibGUgc3cgcHJlZmV0Y2hpbmcgYXQgLU8zIGZvciBDUFVT IHRoYXQgcHJlZmV0Y2hpbmcgaXMgaGVscGZ1bC4gICovCiAgIGlmIChvcHRz LT54X2ZsYWdfcHJlZmV0Y2hfbG9vcF9hcnJheXMgPCAwCiAgICAgICAmJiBI QVZFX3ByZWZldGNoCkBAIC0yMTY0MSw2ICsyMTY0NywzOCBAQCBpeDg2X2V4 cGFuZF9icmFuY2ggKGVudW0gcnR4X2NvZGUgY29kZSwgcnR4IG9wMCwgcnR4 IG9wMSwgcnR4IGxhYmVsKQogICBtYWNoaW5lX21vZGUgbW9kZSA9IEdFVF9N T0RFIChvcDApOwogICBydHggdG1wOwogCisgIC8qIEhhbmRsZSBzcGVjaWFs IGNhc2UgLSB2ZWN0b3IgY29tcGFyc2lvbiB3aXRoIGJvb2xlYW4gcmVzdWx0 LCB0cmFuc2Zvcm0KKyAgICAgaXQgdXNpbmcgcHRlc3QgaW5zdHJ1Y3Rpb24u ICAqLworICBpZiAoR0VUX01PREVfQ0xBU1MgKG1vZGUpID09IE1PREVfVkVD VE9SX0lOVCkKKyAgICB7CisgICAgICBydHggbGhzOworICAgICAgcnR4IGZs YWc7CisgICAgICBtYWNoaW5lX21vZGUgcF9tb2RlID0gR0VUX01PREVfU0la RSAobW9kZSkgPT0gMzIgPyBWNERJbW9kZSA6IFYyREltb2RlOworICAgICAg Z2NjX2Fzc2VydCAoY29kZSA9PSBFUSB8fCBjb2RlID09IE5FKTsKKyAgICAg IGlmICghUkVHX1AgKG9wMCkpCisJb3AwID0gZm9yY2VfcmVnIChtb2RlLCBv cDApOworICAgICAgaWYgKCFSRUdfUCAob3AxKSkKKwlvcDEgPSBmb3JjZV9y ZWcgKG1vZGUsIG9wMSk7CisgICAgICAvKiBHZW5lcmF0ZSBzdWJ0cmFjdGlv biBzaW5jZSB3ZSBjYW4ndCBjaGVjayB0aGF0IG9uZSBvcGVyYW5kIGlzCisJ IHplcm8gdmVjdG9yLiAgKi8KKwkgIGxocyA9IGdlbl9yZWdfcnR4IChtb2Rl KTsKKwkgIGVtaXRfaW5zbiAoZ2VuX3J0eF9TRVQgKGxocywKKwkJCQkgIGdl bl9ydHhfTUlOVVMgKG1vZGUsIG9wMCwgb3AxKSkpOworICAgICAgbGhzID0g Z2VuX3J0eF9TVUJSRUcgKHBfbW9kZSwgbGhzLCAwKTsKKyAgICAgIHRtcCA9 IGdlbl9ydHhfU0VUIChnZW5fcnR4X1JFRyAoQ0Ntb2RlLCBGTEFHU19SRUcp LAorCQkJICBnZW5fcnR4X1VOU1BFQyAoQ0Ntb2RlLAorCQkJCQkgIGdlbl9y dHZlYyAoMiwgbGhzLCBsaHMpLAorCQkJCQkgIFVOU1BFQ19QVEVTVCkpOwor ICAgICAgZW1pdF9pbnNuICh0bXApOworICAgICAgZmxhZyA9IGdlbl9ydHhf UkVHIChDQ1ptb2RlLCBGTEFHU19SRUcpOworICAgICAgdG1wID0gZ2VuX3J0 eF9mbXRfZWUgKGNvZGUsIFZPSURtb2RlLCBmbGFnLCBjb25zdDBfcnR4KTsK KyAgICAgIHRtcCA9IGdlbl9ydHhfSUZfVEhFTl9FTFNFIChWT0lEbW9kZSwg dG1wLAorCQkJCSAgZ2VuX3J0eF9MQUJFTF9SRUYgKFZPSURtb2RlLCBsYWJl bCksCisJCQkJICBwY19ydHgpOworICAgICAgZW1pdF9qdW1wX2luc24gKGdl bl9ydHhfU0VUIChwY19ydHgsIHRtcCkpOworICAgICAgcmV0dXJuOworICAg IH0KKwogICBzd2l0Y2ggKG1vZGUpCiAgICAgewogICAgIGNhc2UgU0Ztb2Rl OgpkaWZmIC0tZ2l0IGEvZ2NjL2NvbmZpZy9pMzg2L2kzODYuaCBiL2djYy9j b25maWcvaTM4Ni9pMzg2LmgKaW5kZXggY2VkYTQ3Mi4uNTEzMzIxNiAxMDA2 NDQKLS0tIGEvZ2NjL2NvbmZpZy9pMzg2L2kzODYuaAorKysgYi9nY2MvY29u ZmlnL2kzODYvaTM4Ni5oCkBAIC00OTYsNiArNDk2LDggQEAgZXh0ZXJuIHVu c2lnbmVkIGNoYXIgaXg4Nl90dW5lX2ZlYXR1cmVzW1g4Nl9UVU5FX0xBU1Rd OwogICAgIGl4ODZfdHVuZV9mZWF0dXJlc1tYODZfVFVORV9BREpVU1RfVU5S T0xMXQogI2RlZmluZSBUQVJHRVRfQVZPSURfRkFMU0VfREVQX0ZPUl9CTUkg XAogCWl4ODZfdHVuZV9mZWF0dXJlc1tYODZfVFVORV9BVk9JRF9GQUxTRV9E RVBfRk9SX0JNSV0KKyNkZWZpbmUgVEFSR0VUX09QVElNSVpFX01BU0tfU1RP UkUgXAorCWl4ODZfdHVuZV9mZWF0dXJlc1tYODZfVFVORV9PUFRJTUlaRV9N QVNLX1NUT1JFXQogCiAvKiBGZWF0dXJlIHRlc3RzIGFnYWluc3QgdGhlIHZh cmlvdXMgYXJjaGl0ZWN0dXJlIHZhcmlhdGlvbnMuICAqLwogZW51bSBpeDg2 X2FyY2hfaW5kaWNlcyB7CmRpZmYgLS1naXQgYS9nY2MvY29uZmlnL2kzODYv c3NlLm1kIGIvZ2NjL2NvbmZpZy9pMzg2L3NzZS5tZAppbmRleCBlN2I1MTdh Li5lMTQ5Y2IzIDEwMDY0NAotLS0gYS9nY2MvY29uZmlnL2kzODYvc3NlLm1k CisrKyBiL2djYy9jb25maWcvaTM4Ni9zc2UubWQKQEAgLTE4MzQwLDYgKzE4 MzQwLDI1IEBACiAJICAobWF0Y2hfb3BlcmFuZDo8YXZ4NTEyZm1hc2ttb2Rl PiAyICJyZWdpc3Rlcl9vcGVyYW5kIikpKV0KICAgIlRBUkdFVF9BVlg1MTJC VyIpCiAKKyhkZWZpbmVfZXhwYW5kICJjYnJhbmNoPG1vZGU+NCIKKyAgWyhz ZXQgKHJlZzpDQyBGTEFHU19SRUcpCisJKGNvbXBhcmU6Q0MgKG1hdGNoX29w ZXJhbmQ6VjQ4X0FWWDIgMSAibm9uaW1tZWRpYXRlX29wZXJhbmQiKQorCQkg ICAgKG1hdGNoX29wZXJhbmQ6VjQ4X0FWWDIgMiAicmVnaXN0ZXJfb3BlcmFu ZCIpKSkKKyAgIChzZXQgKHBjKSAoaWZfdGhlbl9lbHNlCisJICAgICAgICht YXRjaF9vcGVyYXRvciAwICJidF9jb21wYXJpc29uX29wZXJhdG9yIgorCQlb KHJlZzpDQyBGTEFHU19SRUcpIChjb25zdF9pbnQgMCldKQorCSAgICAgICAo bGFiZWxfcmVmIChtYXRjaF9vcGVyYW5kIDMpKQorCSAgICAgICAocGMpKSld CisgICJUQVJHRVRfQVZYMiIKK3sKKyAgaWYgKE1FTV9QIChvcGVyYW5kc1sx XSkgJiYgTUVNX1AgKG9wZXJhbmRzWzJdKSkKKyAgICBvcGVyYW5kc1sxXSA9 IGZvcmNlX3JlZyAoPE1PREU+bW9kZSwgb3BlcmFuZHNbMV0pOworICBpeDg2 X2V4cGFuZF9icmFuY2ggKEdFVF9DT0RFIChvcGVyYW5kc1swXSksCisJCSAg ICAgIG9wZXJhbmRzWzFdLCBvcGVyYW5kc1syXSwgb3BlcmFuZHNbM10pOwor ICBET05FOworfSkKKworCiAoZGVmaW5lX2luc25fYW5kX3NwbGl0ICJhdnhf PGNhc3Rtb2RlPjxhdnhzaXplc3VmZml4Pl88Y2FzdG1vZGU+IgogICBbKHNl dCAobWF0Y2hfb3BlcmFuZDpBVlgyNTZNT0RFMlAgMCAibm9uaW1tZWRpYXRl X29wZXJhbmQiICI9eCxtIikKIAkodW5zcGVjOkFWWDI1Nk1PREUyUApkaWZm IC0tZ2l0IGEvZ2NjL2NvbmZpZy9pMzg2L3g4Ni10dW5lLmRlZiBiL2djYy9j b25maWcvaTM4Ni94ODYtdHVuZS5kZWYKaW5kZXggYjJkMzkyMS4uYzVlNWI2 MyAxMDA2NDQKLS0tIGEvZ2NjL2NvbmZpZy9pMzg2L3g4Ni10dW5lLmRlZgor KysgYi9nY2MvY29uZmlnL2kzODYveDg2LXR1bmUuZGVmCkBAIC01MjcsNiAr NTI3LDEwIEBAIERFRl9UVU5FIChYODZfVFVORV9BVk9JRF9WRUNUT1JfREVD T0RFLCAiYXZvaWRfdmVjdG9yX2RlY29kZSIsCiBERUZfVFVORSAoWDg2X1RV TkVfQVZPSURfRkFMU0VfREVQX0ZPUl9CTUksICJhdm9pZF9mYWxzZV9kZXBf Zm9yX2JtaSIsCiAJICBtX1NBTkRZQlJJREdFIHwgbV9IQVNXRUxMIHwgbV9H RU5FUklDKQogCisvKiBYODZfVFVORV9PUFRNSVpFX01BU0tfU1RPUkU6IFBl cmZvcm0gbWFza2VkIHN0b3JlIGlmIGlzIGl0cyBtYXNrIGlzIG5vdAorICAg ZXF1YWwgdG8gemVyby4gICovCitERUZfVFVORSAoWDg2X1RVTkVfT1BUSU1J WkVfTUFTS19TVE9SRSwgIm9wdGltaXplX21hc2tfc3RvcmUiLCBtX0hBU1dF TEwpCisKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8q IFRoaXMgbmV2ZXIgd29ya2VkIHdlbGwgYmVmb3JlLiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KIC8qKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKi8KZGlmZiAtLWdpdCBhL2djYy9mb2xk LWNvbnN0LmMgYi9nY2MvZm9sZC1jb25zdC5jCmluZGV4IDY5ODA2MmUuLjk5 ODhiZTEgMTAwNjQ0Ci0tLSBhL2djYy9mb2xkLWNvbnN0LmMKKysrIGIvZ2Nj L2ZvbGQtY29uc3QuYwpAQCAtMTM4ODgsNiArMTM4ODgsMjUgQEAgZm9sZF9y ZWxhdGlvbmFsX2NvbnN0IChlbnVtIHRyZWVfY29kZSBjb2RlLCB0cmVlIHR5 cGUsIHRyZWUgb3AwLCB0cmVlIG9wMSkKIAogICBpZiAoVFJFRV9DT0RFIChv cDApID09IFZFQ1RPUl9DU1QgJiYgVFJFRV9DT0RFIChvcDEpID09IFZFQ1RP Ul9DU1QpCiAgICAgeworICAgICAgaWYgKElOVEVHUkFMX1RZUEVfUCAodHlw ZSkKKwkgICYmIChUUkVFX0NPREUgKHR5cGUpID09IEJPT0xFQU5fVFlQRQor CSAgICAgIHx8IFRZUEVfUFJFQ0lTSU9OICh0eXBlKSA9PSAxKSkKKwl7CisJ ICAvKiBIYXZlIHZlY3RvciBjb21wYXJpc29uIHdpdGggc2NhbGFyIGJvb2xl YW4gcmVzdWx0LiAgKi8KKwkgIGJvb2wgcmVzdWx0ID0gdHJ1ZTsKKwkgIGdj Y19hc3NlcnQgKGNvZGUgPT0gRVFfRVhQUiB8fCBjb2RlID09IE5FX0VYUFIp OworCSAgZ2NjX2Fzc2VydCAoVkVDVE9SX0NTVF9ORUxUUyAob3AwKSA9PSBW RUNUT1JfQ1NUX05FTFRTIChvcDEpKTsKKwkgIGZvciAodW5zaWduZWQgaSA9 IDA7IGkgPCBWRUNUT1JfQ1NUX05FTFRTIChvcDApOyBpKyspCisJICAgIHsK KwkgICAgICB0cmVlIGVsZW0wID0gVkVDVE9SX0NTVF9FTFQgKG9wMCwgaSk7 CisJICAgICAgdHJlZSBlbGVtMSA9IFZFQ1RPUl9DU1RfRUxUIChvcDEsIGkp OworCSAgICAgIHRyZWUgdG1wID0gZm9sZF9yZWxhdGlvbmFsX2NvbnN0IChj b2RlLCB0eXBlLCBlbGVtMCwgZWxlbTEpOworCSAgICAgIHJlc3VsdCAmPSBp bnRlZ2VyX29uZXAgKHRtcCk7CisJICAgIH0KKwkgIGlmIChjb2RlID09IE5F X0VYUFIpCisJICAgIHJlc3VsdCA9ICFyZXN1bHQ7CisJICByZXR1cm4gY29u c3RhbnRfYm9vbGVhbl9ub2RlIChyZXN1bHQsIHR5cGUpOworCX0KICAgICAg IHVuc2lnbmVkIGNvdW50ID0gVkVDVE9SX0NTVF9ORUxUUyAob3AwKTsKICAg ICAgIHRyZWUgKmVsdHMgPSAgWEFMTE9DQVZFQyAodHJlZSwgY291bnQpOwog ICAgICAgZ2NjX2Fzc2VydCAoVkVDVE9SX0NTVF9ORUxUUyAob3AxKSA9PSBj b3VudApkaWZmIC0tZ2l0IGEvZ2NjL3BhcmFtcy5kZWYgYi9nY2MvcGFyYW1z LmRlZgppbmRleCA0MWZkOGE4Li5kMjI4NDc3IDEwMDY0NAotLS0gYS9nY2Mv cGFyYW1zLmRlZgorKysgYi9nY2MvcGFyYW1zLmRlZgpAQCAtMTA0Myw2ICsx MDQzLDEyIEBAIERFRlBBUkFNIChQQVJBTV9NQVhfU1RPUkVTX1RPX1NJTkss CiAgICAgICAgICAgIk1heGltdW0gbnVtYmVyIG9mIGNvbmRpdGlvbmFsIHN0 b3JlIHBhaXJzIHRoYXQgY2FuIGJlIHN1bmsuIiwKICAgICAgICAgICAyLCAw LCAwKQogCisvKiBFbmFibGUgaW5zZXJpb24gdGVzdCBvbiB6ZXJvIG1hc2sg Zm9yIG1hc2tlZCBzdG9yZXMgaWYgbm9uLXplcm8uICAqLworREVGUEFSQU0g KFBBUkFNX1pFUk9fVEVTVF9GT1JfTUFTS19TVE9SRSwKKwkgICJ6ZXJvLXRl c3QtZm9yLW1hc2stc3RvcmUiLAorCSAgIkVuYWJsZSBpbnNlcnRpb24gb2Yg dGVzdCBvbiB6ZXJvIG1hc2sgZm9yIG1hc2tlZCBzdG9yZXMiLAorCSAgMCwg MCwgMSkKKwogLyogT3ZlcnJpZGUgQ0FTRV9WQUxVRVNfVEhSRVNIT0xEIG9m IHdoZW4gdG8gc3dpdGNoIGZyb20gZG9pbmcgc3dpdGNoCiAgICBzdGF0ZW1l bnRzIHZpYSBpZiBzdGF0ZW1lbnRzIHRvIHVzaW5nIGEgdGFibGUganVtcCBv cGVyYXRpb24uICBJZiB0aGUgdmFsdWUKICAgIGlzIDAsIHRoZSBkZWZhdWx0 IENBU0VfVkFMVUVTX1RIUkVTSE9MRCB3aWxsIGJlIHVzZWQuICAqLwpkaWZm IC0tZ2l0IGEvZ2NjL3BhcmFtcy5oIGIvZ2NjL3BhcmFtcy5oCmluZGV4IDEw OTBkMDAuLjIwMzdjNzMgMTAwNjQ0Ci0tLSBhL2djYy9wYXJhbXMuaAorKysg Yi9nY2MvcGFyYW1zLmgKQEAgLTIyMSw2ICsyMjEsOCBAQCBleHRlcm4gdm9p ZCBpbml0X3BhcmFtX3ZhbHVlcyAoaW50ICpwYXJhbXMpOwogICBQQVJBTV9W QUxVRSAoUEFSQU1fTUlOX05PTkRFQlVHX0lOU05fVUlEKQogI2RlZmluZSBN QVhfU1RPUkVTX1RPX1NJTksgXAogICBQQVJBTV9WQUxVRSAoUEFSQU1fTUFY X1NUT1JFU19UT19TSU5LKQorI2RlZmluZSBFTkFCTEVfWkVST19URVNUX0ZP Ul9NQVNLX1NUT1JFIFwKKyAgUEFSQU1fVkFMVUUgKFBBUkFNX1pFUk9fVEVT VF9GT1JfTUFTS19TVE9SRSkKICNkZWZpbmUgQUxMT1dfTE9BRF9EQVRBX1JB Q0VTIFwKICAgUEFSQU1fVkFMVUUgKFBBUkFNX0FMTE9XX0xPQURfREFUQV9S QUNFUykKICNkZWZpbmUgQUxMT1dfU1RPUkVfREFUQV9SQUNFUyBcCmRpZmYg LS1naXQgYS9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQvaTM4Ni9hdngyLXZl Y3QtbWFzay1zdG9yZS1tb3ZlMS5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFy Z2V0L2kzODYvYXZ4Mi12ZWN0LW1hc2stc3RvcmUtbW92ZTEuYwpuZXcgZmls ZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwLi42MGJiODQxCi0tLSAvZGV2 L251bGwKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2kzODYvYXZ4 Mi12ZWN0LW1hc2stc3RvcmUtbW92ZTEuYwpAQCAtMCwwICsxLDE3IEBACisv KiB7IGRnLWRvIGNvbXBpbGUgfSAqLworLyogeyBkZy1vcHRpb25zICItbWFy Y2g9Y29yZS1hdngyIC1PMyAtZmR1bXAtdHJlZS12ZWN0LWRldGFpbHMiIH0g Ki8KKworZXh0ZXJuIGludCAqcDEsICpwMiwgKnAzOworaW50IGNbMjU2XTsK K3ZvaWQgZm9vIChpbnQgbikKK3sKKyAgaW50IGk7CisgIGZvciAoaSA9IDA7 IGkgPCBuOyBpKyspCisgICAgaWYgKGNbaV0pCisgICAgICB7CisJcDFbaV0g Kz0gMTsKKwlwMltpXSA9IHAzW2ldICsyOworICAgICAgfQorfQorCisvKiB7 IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAtdGltZXMgIk1vdmUgTUFTS19T VE9SRSB0byBuZXcgYmIiIDIgInZlY3QiIH0gfSAqLwpkaWZmIC0tZ2l0IGEv Z2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2kzODYvYXZ4Mi12ZWN0LW1hc2st c3RvcmUtbW92ZTIuYyBiL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9pMzg2 L2F2eDItdmVjdC1tYXNrLXN0b3JlLW1vdmUyLmMKbmV3IGZpbGUgbW9kZSAx MDA3NTUKaW5kZXggMDAwMDAwMC4uYTM4M2I5OQotLS0gL2Rldi9udWxsCisr KyBiL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9pMzg2L2F2eDItdmVjdC1t YXNrLXN0b3JlLW1vdmUyLmMKQEAgLTAsMCArMSwxOSBAQAorLyogeyBkZy1k byBjb21waWxlIH0gKi8KKy8qIHsgZGctb3B0aW9ucyAiLW1hcmNoPWNvcmUt YXZ4MiAtTzMgLWZkdW1wLXRyZWUtdmVjdC1kZXRhaWxzIiB9ICovCisKK2V4 dGVybiBpbnQgKnAxLCAqcDIsICpwMzsKK2ludCBjWzI1Nl07CisvKiBBbGwg bWFza2VkIGxvYWQvc3RvcmVzIG11c3QgYmUgcHV0IGludG8gb25lIG5ldyBi Yi4gICovCisKK3ZvaWQgZm9vIChpbnQgbikKK3sKKyAgaW50IGk7CisgIGZv ciAoaSA9IDA7IGkgPCBuOyBpKyspCisgICAgaWYgKGNbaV0pCisgICAgICB7 CisJcDFbaV0gLT0gMTsKKwlwMltpXSA9IHAzW2ldOworICAgICAgfQorfQor CisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAtdGltZXMgIk1vdmUg TUFTS19TVE9SRSB0byBuZXcgYmIiIDEgInZlY3QiIH0gfSAqLwpkaWZmIC0t Z2l0IGEvZ2NjL3RyZWUtY2ZnLmMgYi9nY2MvdHJlZS1jZmcuYwpvbGQgbW9k ZSAxMDA2NDQKbmV3IG1vZGUgMTAwNzU1CmluZGV4IDBjNjI0YWEuLmNmZGUz NzkKLS0tIGEvZ2NjL3RyZWUtY2ZnLmMKKysrIGIvZ2NjL3RyZWUtY2ZnLmMK QEAgLTM0MDgsMTAgKzM0MDgsMTAgQEAgdmVyaWZ5X2dpbXBsZV9jYWxsIChn Y2FsbCAqc3RtdCkKIH0KIAogLyogVmVyaWZpZXMgdGhlIGdpbXBsZSBjb21w YXJpc29uIHdpdGggdGhlIHJlc3VsdCB0eXBlIFRZUEUgYW5kCi0gICB0aGUg b3BlcmFuZHMgT1AwIGFuZCBPUDEuICAqLworICAgdGhlIG9wZXJhbmRzIE9Q MCBhbmQgT1AxLCBjb21wYXJpc29uIGNvZGUgaXMgQ09ERS4gICovCiAKIHN0 YXRpYyBib29sCi12ZXJpZnlfZ2ltcGxlX2NvbXBhcmlzb24gKHRyZWUgdHlw ZSwgdHJlZSBvcDAsIHRyZWUgb3AxKQordmVyaWZ5X2dpbXBsZV9jb21wYXJp c29uICh0cmVlIHR5cGUsIHRyZWUgb3AwLCB0cmVlIG9wMSwgZW51bSB0cmVl X2NvZGUgY29kZSkKIHsKICAgdHJlZSBvcDBfdHlwZSA9IFRSRUVfVFlQRSAo b3AwKTsKICAgdHJlZSBvcDFfdHlwZSA9IFRSRUVfVFlQRSAob3AxKTsKQEAg LTM0NDgsMTAgKzM0NDgsMTYgQEAgdmVyaWZ5X2dpbXBsZV9jb21wYXJpc29u ICh0cmVlIHR5cGUsIHRyZWUgb3AwLCB0cmVlIG9wMSkKICAgICAgIGlmIChU UkVFX0NPREUgKG9wMF90eXBlKSA9PSBWRUNUT1JfVFlQRQogCSAgfHwgVFJF RV9DT0RFIChvcDFfdHlwZSkgPT0gVkVDVE9SX1RZUEUpCiAgICAgICAgIHsK LSAgICAgICAgICBlcnJvciAoInZlY3RvciBjb21wYXJpc29uIHJldHVybmlu ZyBhIGJvb2xlYW4iKTsKLSAgICAgICAgICBkZWJ1Z19nZW5lcmljX2V4cHIg KG9wMF90eXBlKTsKLSAgICAgICAgICBkZWJ1Z19nZW5lcmljX2V4cHIgKG9w MV90eXBlKTsKLSAgICAgICAgICByZXR1cm4gdHJ1ZTsKKwkgIC8qIEFsbG93 IHZlY3RvciBjb21wYXJpc29uIHJldHVybmluZyBib29sZWFuIGlmIG9wZXJh bmQgdHlwZXMKKwkgICAgIGFyZSBlcXVhbCBhbmQgQ09ERSBpcyBFUS9ORS4g ICovCisJICBpZiAoKGNvZGUgIT0gRVFfRVhQUiAmJiBjb2RlICE9IE5FX0VY UFIpCisJICAgICAgfHwgIVZFQ1RPUl9CT09MRUFOX1RZUEVfUCAob3AwX3R5 cGUpKQorCSAgICB7CisJICAgICAgZXJyb3IgKCJ0eXBlIG1pc21hdGNoIGZv ciB2ZWN0b3IgY29tcGFyaXNvbiByZXR1cm5pbmcgYSBib29sZWFuIik7CisJ ICAgICAgZGVidWdfZ2VuZXJpY19leHByIChvcDBfdHlwZSk7CisJICAgICAg ZGVidWdfZ2VuZXJpY19leHByIChvcDFfdHlwZSk7CisJICAgICAgcmV0dXJu IHRydWU7CisJICAgIH0KICAgICAgICAgfQogICAgIH0KICAgLyogT3IgYSBi b29sZWFuIHZlY3RvciB0eXBlIHdpdGggdGhlIHNhbWUgZWxlbWVudCBjb3Vu dApAQCAtMzgzMiw3ICszODM4LDcgQEAgdmVyaWZ5X2dpbXBsZV9hc3NpZ25f YmluYXJ5IChnYXNzaWduICpzdG10KQogICAgIGNhc2UgTFRHVF9FWFBSOgog ICAgICAgLyogQ29tcGFyaXNvbnMgYXJlIGFsc28gYmluYXJ5LCBidXQgdGhl IHJlc3VsdCB0eXBlIGlzIG5vdAogCSBjb25uZWN0ZWQgdG8gdGhlIG9wZXJh bmQgdHlwZXMuICAqLwotICAgICAgcmV0dXJuIHZlcmlmeV9naW1wbGVfY29t cGFyaXNvbiAobGhzX3R5cGUsIHJoczEsIHJoczIpOworICAgICAgcmV0dXJu IHZlcmlmeV9naW1wbGVfY29tcGFyaXNvbiAobGhzX3R5cGUsIHJoczEsIHJo czIsIHJoc19jb2RlKTsKIAogICAgIGNhc2UgV0lERU5fTVVMVF9FWFBSOgog ICAgICAgaWYgKFRSRUVfQ09ERSAobGhzX3R5cGUpICE9IElOVEVHRVJfVFlQ RSkKQEAgLTQ1NDEsNyArNDU0Nyw4IEBAIHZlcmlmeV9naW1wbGVfY29uZCAo Z2NvbmQgKnN0bXQpCiAKICAgcmV0dXJuIHZlcmlmeV9naW1wbGVfY29tcGFy aXNvbiAoYm9vbGVhbl90eXBlX25vZGUsCiAJCQkJICAgZ2ltcGxlX2NvbmRf bGhzIChzdG10KSwKLQkJCQkgICBnaW1wbGVfY29uZF9yaHMgKHN0bXQpKTsK KwkJCQkgICBnaW1wbGVfY29uZF9yaHMgKHN0bXQpLAorCQkJCSAgIGdpbXBs ZV9jb25kX2NvZGUgKHN0bXQpKTsKIH0KIAogLyogVmVyaWZ5IHRoZSBHSU1Q TEUgc3RhdGVtZW50IFNUTVQuICBSZXR1cm5zIHRydWUgaWYgdGhlcmUgaXMg YW4KZGlmZiAtLWdpdCBhL2djYy90cmVlLXNzYS1mb3J3cHJvcC5jIGIvZ2Nj L3RyZWUtc3NhLWZvcndwcm9wLmMKaW5kZXggYjgyYWUzYy4uNzNlZTNiZSAx MDA2NDQKLS0tIGEvZ2NjL3RyZWUtc3NhLWZvcndwcm9wLmMKKysrIGIvZ2Nj L3RyZWUtc3NhLWZvcndwcm9wLmMKQEAgLTM3Myw2ICszNzMsMTEgQEAgY29t YmluZV9jb25kX2V4cHJfY29uZCAoZ2ltcGxlICpzdG10LCBlbnVtIHRyZWVf Y29kZSBjb2RlLCB0cmVlIHR5cGUsCiAKICAgZ2NjX2Fzc2VydCAoVFJFRV9D T0RFX0NMQVNTIChjb2RlKSA9PSB0Y2NfY29tcGFyaXNvbik7CiAKKyAgLyog RG8gbm90IHBlcmZvcm0gY29tYmluaW5nIGl0IHR5cGVzIGFyZSBub3QgY29t cGF0aWJsZS4gICovCisgIGlmIChUUkVFX0NPREUgKFRSRUVfVFlQRSAob3Aw KSkgPT0gVkVDVE9SX1RZUEUKKyAgICAgICYmICF0cmVlX2ludF9jc3RfZXF1 YWwgKFRZUEVfU0laRSAodHlwZSksIFRZUEVfU0laRSAoVFJFRV9UWVBFIChv cDApKSkpCisgICAgcmV0dXJuIE5VTExfVFJFRTsKKwogICBmb2xkX2RlZmVy X292ZXJmbG93X3dhcm5pbmdzICgpOwogICB0ID0gZm9sZF9iaW5hcnlfbG9j IChnaW1wbGVfbG9jYXRpb24gKHN0bXQpLCBjb2RlLCB0eXBlLCBvcDAsIG9w MSk7CiAgIGlmICghdCkKZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3QtbG9v cC5jIGIvZ2NjL3RyZWUtdmVjdC1sb29wLmMKaW5kZXggYzNkYmZkMy4uNGEy NDdjOCAxMDA2NDQKLS0tIGEvZ2NjL3RyZWUtdmVjdC1sb29wLmMKKysrIGIv Z2NjL3RyZWUtdmVjdC1sb29wLmMKQEAgLTY4MjYsMyArNjgyNiwxNjkgQEAg dmVjdF90cmFuc2Zvcm1fbG9vcCAobG9vcF92ZWNfaW5mbyBsb29wX3ZpbmZv KQogICAgICAgZHVtcF9wcmludGYgKE1TR19OT1RFLCAiXG4iKTsKICAgICB9 CiB9CisKKy8qIEhlbHBlciBmb3Igb3B0aW1pemVfbWFza19zdG9yZXM6IHJl dHVybnMgdHJ1ZSBpZiBTVE1UIHNpbmtpbmcgdG8gZW5kCisgICBvZiBCQiBp cyB2YWxpZCBhbmQgZmFsc2Ugb3RoZXJ3aXNlLiAgKi8KKworc3RhdGljIGJv b2wKK2lzX3ZhbGlkX3NpbmsgKGdpbXBsZSAqc3RtdCwgZ2ltcGxlICpsYXN0 X3N0b3JlKQoreworICB0cmVlIHZkZWY7CisgIGltbV91c2VfaXRlcmF0b3Ig aW1tX2l0OworICB1c2Vfb3BlcmFuZF9wIHVzZV9wOworICBiYXNpY19ibG9j ayBiYiA9IGdpbXBsZV9iYiAoc3RtdCk7CisKKyAgaWYgKGlzX2dpbXBsZV9j YWxsIChzdG10KQorICAgICAgJiYgIWdpbXBsZV9jYWxsX2ludGVybmFsX3Ag KHN0bXQpKQorICAgIC8qIERvIG5vdCBjb25zaWRlciBub24taW50ZXJuYWwg Y2FsbCBhcyB2YWxpZCB0byBzaW5rLiAgKi8KKyAgICByZXR1cm4gZmFsc2U7 CisKKyAgaWYgKCh2ZGVmID0gZ2ltcGxlX3ZkZWYgKHN0bXQpKSkKKyAgICB7 CisgICAgICAvKiBDaGVjayB0aGF0IHRoZXIgYXJlIG5vIHN0b3JlIHZ1c2Vz IGluIGN1cnJlbnQgYmIuICAqLworICAgICAgRk9SX0VBQ0hfSU1NX1VTRV9G QVNUICh1c2VfcCwgaW1tX2l0LCB2ZGVmKQorCWlmIChnaW1wbGVfYmIgKFVT RV9TVE1UICh1c2VfcCkpID09IGJiKQorCSAgcmV0dXJuIGZhbHNlOworICAg ICAgcmV0dXJuIHRydWU7CisgICAgfQorICBlbHNlIGlmIChnaW1wbGVfdnVz ZSAoc3RtdCkgPT0gTlVMTF9UUkVFKQorICAgIHJldHVybiB0cnVlOworICBl bHNlIGlmIChnaW1wbGVfdnVzZSAoc3RtdCkgPT0gZ2ltcGxlX3Z1c2UgKGxh c3Rfc3RvcmUpKQorICAgIHJldHVybiB0cnVlOworICByZXR1cm4gZmFsc2U7 Cit9CisKKy8qIFRoZSBjb2RlIGJlbG93IGlzIHRyeWluZyB0byBwZXJmb3Jt IHNpbXBsZSBvcHRpbWl6YXRpb24gLSBkbyBub3QgZXhlY3V0ZQorICAgbWFz a2VkIHN0b3JlIHN0YXRlbWVudCBpZiBpdHMgbWFzayBpcyB6ZXJvIHZlY3Rv ciBzaW5jZSBsb2FkcyB0aGF0IGZvbGxvdworICAgYSBtYXNrZWQgc3RvcmUg Y2FuIGJlIGJsb2NrZWQuICBJdCBwdXRzIGFsbCBtYXNrZWQgc3RvcmVzIHdp dGggdGhlIHNhbWUKKyAgIG1hc2stdmVjdG9yIGludG8gdGhlIG5ldyBiYiB3 aXRoIGEgY2hlY2sgb24gemVybyBtYXNrLiAgKi8KKwordm9pZAorb3B0aW1p emVfbWFza19zdG9yZXMgKHN0cnVjdCBsb29wICpsb29wKQoreworICBiYXNp Y19ibG9jayBiYiA9IGxvb3AtPmhlYWRlcjsKKyAgZ2ltcGxlX3N0bXRfaXRl cmF0b3IgZ3NpOworICBnaW1wbGUgKnN0bXQ7CisgIGF1dG9fdmVjPGdpbXBs ZSAqPiB3b3JrbGlzdDsKKworICBpZiAoRU5BQkxFX1pFUk9fVEVTVF9GT1Jf TUFTS19TVE9SRSA9PSAwKQorICAgIHJldHVybjsKKworICAvKiBQaWNrIHVw IGFsbCBtYXNrZWQgc3RvcmVzIGluIGxvb3AgaWYgYW55LiAgKi8KKyAgZm9y IChnc2kgPSBnc2lfc3RhcnRfYmIgKGJiKTsgIWdzaV9lbmRfcCAoZ3NpKTsg Z3NpX25leHQgKCZnc2kpKQorICAgIHsKKyAgICAgIHN0bXQgPSBnc2lfc3Rt dCAoZ3NpKTsKKyAgICAgIGlmIChpc19naW1wbGVfY2FsbCAoc3RtdCkKKwkg ICYmIGdpbXBsZV9jYWxsX2ludGVybmFsX3AgKHN0bXQpCisJICAmJiBnaW1w bGVfY2FsbF9pbnRlcm5hbF9mbiAoc3RtdCkgPT0gSUZOX01BU0tfU1RPUkUp CisJd29ya2xpc3Quc2FmZV9wdXNoIChzdG10KTsKKyAgICB9CisKKyAgaWYg KHdvcmtsaXN0LmlzX2VtcHR5ICgpKQorICAgIHJldHVybjsKKworICAvKiBM b29wIGhhcyBtYXNrZWQgc3RvcmVzLiAgKi8KKyAgd2hpbGUgKCF3b3JrbGlz dC5pc19lbXB0eSAoKSkKKyAgICB7CisgICAgICBnaW1wbGUgKmxhc3QsICpk ZWZfc3RtdCwgKmxhc3Rfc3RvcmU7CisgICAgICBlZGdlIGUsIGVmYWxzZTsK KyAgICAgIHRyZWUgbWFzazsKKyAgICAgIGJhc2ljX2Jsb2NrIHN0b3JlX2Ji LCBqb2luX2JiOworICAgICAgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgZ3NpX3Rv OworICAgICAgdHJlZSBhcmczOworICAgICAgdHJlZSB2ZGVmLCBuZXdfdmRl ZjsKKyAgICAgIGdwaGkgKnBoaTsKKyAgICAgIGJvb2wgZmlyc3RfZHVtcDsK KyAgICAgIHRyZWUgdmVjdHlwZTsKKyAgICAgIHRyZWUgemVybzsKKworICAg ICAgbGFzdCA9IHdvcmtsaXN0LnBvcCAoKTsKKyAgICAgIG1hc2sgPSBnaW1w bGVfY2FsbF9hcmcgKGxhc3QsIDIpOworICAgICAgLyogQ3JlYXRlIG5ldyBi Yi4gICovCisgICAgICBlID0gc3BsaXRfYmxvY2sgKGJiLCBsYXN0KTsKKyAg ICAgIGpvaW5fYmIgPSBlLT5kZXN0OworICAgICAgc3RvcmVfYmIgPSBjcmVh dGVfZW1wdHlfYmIgKGJiKTsKKyAgICAgIGFkZF9iYl90b19sb29wIChzdG9y ZV9iYiwgbG9vcCk7CisgICAgICBlLT5mbGFncyA9IEVER0VfVFJVRV9WQUxV RTsKKyAgICAgIGVmYWxzZSA9IG1ha2VfZWRnZSAoYmIsIHN0b3JlX2JiLCBF REdFX0ZBTFNFX1ZBTFVFKTsKKyAgICAgIC8qIFB1dCBTVE9SRV9CQiB0byBs aWtlbHkgcGFydC4gICovCisgICAgICBlZmFsc2UtPnByb2JhYmlsaXR5ID0g UFJPQl9VTkxJS0VMWTsKKyAgICAgIHN0b3JlX2JiLT5mcmVxdWVuY3kgPSBQ Uk9CX0FMV0FZUyAtIEVER0VfRlJFUVVFTkNZIChlZmFsc2UpOworICAgICAg bWFrZV9lZGdlIChzdG9yZV9iYiwgam9pbl9iYiwgRURHRV9GQUxMVEhSVSk7 CisgICAgICBpZiAoZG9tX2luZm9fYXZhaWxhYmxlX3AgKENESV9ET01JTkFU T1JTKSkKKwlzZXRfaW1tZWRpYXRlX2RvbWluYXRvciAoQ0RJX0RPTUlOQVRP UlMsIHN0b3JlX2JiLCBiYik7CisgICAgICAvKiBDcmVhdGUgdmVjdG9yIGNv bXBhcmlzb24gd2l0aCBib29sZWFuIHJlc3VsdC4gICovCisgICAgICB2ZWN0 eXBlID0gVFJFRV9UWVBFIChtYXNrKTsKKyAgICAgIHplcm8gPSBidWlsZF96 ZXJvX2NzdCAodmVjdHlwZSk7CisgICAgICBzdG10ID0gZ2ltcGxlX2J1aWxk X2NvbmQgKEVRX0VYUFIsIG1hc2ssIHplcm8sIE5VTExfVFJFRSwgTlVMTF9U UkVFKTsKKyAgICAgIGdzaSA9IGdzaV9sYXN0X2JiIChiYik7CisgICAgICBn c2lfaW5zZXJ0X2FmdGVyICgmZ3NpLCBzdG10LCBHU0lfU0FNRV9TVE1UKTsK KyAgICAgIC8qIENyZWF0ZSBuZXcgUEhJIG5vZGUgZm9yIHZkZWYgb2YgdGhl IGxhc3QgbWFza2VkIHN0b3JlOgorCSAuTUVNXzIgPSBWREVGIDwuTUVNXzE+ CisJIHdpbGwgYmUgY29udmVydGVkIHRvCisJIC5NRU0uMyA9IFZERUYgPC5N RU1fMT4KKwkgYW5kIG5ldyBQSEkgbm9kZSB3aWxsIGJlIGNyZWF0ZWQgaW4g am9pbiBiYgorCSAuTUVNXzIgPSBQSEkgPC5NRU1fMSwgLk1FTV8zPgorICAg ICAgKi8KKyAgICAgIHZkZWYgPSBnaW1wbGVfdmRlZiAobGFzdCk7CisgICAg ICBuZXdfdmRlZiA9IG1ha2Vfc3NhX25hbWUgKGdpbXBsZV92b3AgKGNmdW4p LCBsYXN0KTsKKyAgICAgIGdpbXBsZV9zZXRfdmRlZiAobGFzdCwgbmV3X3Zk ZWYpOworICAgICAgcGhpID0gY3JlYXRlX3BoaV9ub2RlICh2ZGVmLCBqb2lu X2JiKTsKKyAgICAgIGFkZF9waGlfYXJnIChwaGksIG5ld192ZGVmLCBFREdF X1NVQ0MgKHN0b3JlX2JiLCAwKSwgVU5LTk9XTl9MT0NBVElPTik7CisgICAg ICBmaXJzdF9kdW1wID0gdHJ1ZTsKKworICAgICAgLyogUHV0IGFsbCBtYXNr ZWQgc3RvcmVzIHdpdGggdGhlIHNhbWUgbWFzayB0byBTVE9SRV9CQiBpZiBw b3NzaWJsZS4gICovCisgICAgICB3aGlsZSAodHJ1ZSkKKwl7CisJICAvKiBN b3ZlIG1hc2tlZCBzdG9yZSB0byBTVE9SRV9CQi4gICovCisJICBsYXN0X3N0 b3JlID0gbGFzdDsKKwkgIGdzaSA9IGdzaV9mb3Jfc3RtdCAobGFzdCk7CisJ ICBnc2lfdG8gPSBnc2lfc3RhcnRfYmIgKHN0b3JlX2JiKTsKKwkgIGdzaV9t b3ZlX2JlZm9yZSAoJmdzaSwgJmdzaV90byk7CisJICB1cGRhdGVfc3RtdCAo bGFzdCk7CisJICBpZiAoZHVtcF9lbmFibGVkX3AgKCkpCisJICAgIHsKKwkg ICAgICAvKiBJc3N1ZSBkaWZmZXJlbnQgbWVzc2FnZXMgZGVwZW5kaW5nIG9u IEZJUlNUX0RVTVAuICAqLworCSAgICAgIGlmIChmaXJzdF9kdW1wKQorCQl7 CisJCSAgZHVtcF9wcmludGYgKE1TR19OT1RFLCAiTW92ZSBNQVNLX1NUT1JF IHRvIG5ldyBiYiMlZFxuIiwKKwkJCSAgICAgICBzdG9yZV9iYi0+aW5kZXgp OworCQkgIGZpcnN0X2R1bXAgPSBmYWxzZTsKKwkJfQorCSAgICAgIGVsc2UK KwkJZHVtcF9wcmludGYgKE1TR19OT1RFLCAiTW92ZSBNQVNLX1NUT1JFIHRv IGNyZWF0ZWQgYmJcbiIpOworCSAgICAgIGR1bXBfZ2ltcGxlX3N0bXQgKE1T R19OT1RFLCBUREZfU0xJTSwgbGFzdCwgMCk7CisJICAgIH0KKwkgIC8qIFB1 dCBkZWZpbml0aW9uIHN0YXRlbWVudCBvZiBzdG9yZWQgdmFsdWUgaW4gU1RP UkVfQkIKKwkgICAgIGlmIHBvc3NpYmxlLiAgKi8KKwkgIGFyZzMgPSBnaW1w bGVfY2FsbF9hcmcgKGxhc3QsIDMpOworCSAgaWYgKFRSRUVfQ09ERSAoYXJn MykgPT0gU1NBX05BTUUgJiYgaGFzX3NpbmdsZV91c2UgKGFyZzMpKQorCSAg ICB7CisJICAgICAgZGVmX3N0bXQgPSBTU0FfTkFNRV9ERUZfU1RNVCAoYXJn Myk7CisJICAgICAgLyogTW92ZSBkZWZfc3RtdCB0byBTVE9SRV9CQiBpZiBp dCBpcyBpbiB0aGUgc2FtZSBCQiBhbmQKKwkJIGl0IGlzIHZhbGlkIHNpbmsu ICAqLworCSAgICAgIGlmIChnaW1wbGVfYmIgKGRlZl9zdG10KSA9PSBiYgor CQkgICYmICghZ2ltcGxlX3Z1c2UgKGRlZl9zdG10KQorCQkgICAgICB8fCBn aW1wbGVfdnVzZSAoZGVmX3N0bXQpID09IGdpbXBsZV92dXNlIChsYXN0X3N0 b3JlKSkpCisJCXsKKwkJICBpZiAoZHVtcF9lbmFibGVkX3AgKCkpCisJCSAg ICB7CisJCSAgICAgIGR1bXBfcHJpbnRmIChNU0dfTk9URSwgIk1vdmUgc3Rt dCB0byBjcmVhdGVkIGJiXG4iKTsKKwkJICAgICAgZHVtcF9naW1wbGVfc3Rt dCAoTVNHX05PVEUsIFRERl9TTElNLCBkZWZfc3RtdCwgMCk7CisJCSAgICB9 CisJCSAgZ3NpID0gZ3NpX2Zvcl9zdG10IChkZWZfc3RtdCk7CisJCSAgZ3Np X3RvID0gZ3NpX3N0YXJ0X2JiIChzdG9yZV9iYik7CisJCSAgZ3NpX21vdmVf YmVmb3JlICgmZ3NpLCAmZ3NpX3RvKTsKKwkJICB1cGRhdGVfc3RtdCAoZGVm X3N0bXQpOworCQl9CisJICAgIH0KKwkgICAgLyogUHV0IG90aGVyIG1hc2tl ZCBzdG9yZXMgd2l0aCB0aGUgc2FtZSBtYXNrIHRvIFNUT1JFX0JCLiAgKi8K KwkgICAgaWYgKHdvcmtsaXN0LmlzX2VtcHR5ICgpCisJCXx8IGdpbXBsZV9j YWxsX2FyZyAod29ya2xpc3QubGFzdCAoKSwgMikgIT0gbWFzaworCQl8fCAh aXNfdmFsaWRfc2luayAod29ya2xpc3QubGFzdCAoKSwgbGFzdF9zdG9yZSkp CisJICAgICAgYnJlYWs7CisJICAgIGxhc3QgPSB3b3JrbGlzdC5wb3AgKCk7 CisJfQorICAgICAgYWRkX3BoaV9hcmcgKHBoaSwgZ2ltcGxlX3Z1c2UgKGxh c3Rfc3RvcmUpLCBlLCBVTktOT1dOX0xPQ0FUSU9OKTsKKyAgICB9Cit9CmRp ZmYgLS1naXQgYS9nY2MvdHJlZS12ZWN0LXN0bXRzLmMgYi9nY2MvdHJlZS12 ZWN0LXN0bXRzLmMKaW5kZXggNGJiNThiOS4uNTViMTk1NiAxMDA2NDQKLS0t IGEvZ2NjL3RyZWUtdmVjdC1zdG10cy5jCisrKyBiL2djYy90cmVlLXZlY3Qt c3RtdHMuYwpAQCAtMjAwMCw2ICsyMDAwLDcgQEAgdmVjdG9yaXphYmxlX21h c2tfbG9hZF9zdG9yZSAoZ2ltcGxlICpzdG10LCBnaW1wbGVfc3RtdF9pdGVy YXRvciAqZ3NpLAogICAgIHsKICAgICAgIHRyZWUgdmVjX3JocyA9IE5VTExf VFJFRSwgdmVjX21hc2sgPSBOVUxMX1RSRUU7CiAgICAgICBwcmV2X3N0bXRf aW5mbyA9IE5VTEw7CisgICAgICBMT09QX1ZJTkZPX0hBU19NQVNLX1NUT1JF IChsb29wX3ZpbmZvKSA9IHRydWU7CiAgICAgICBmb3IgKGkgPSAwOyBpIDwg bmNvcGllczsgaSsrKQogCXsKIAkgIHVuc2lnbmVkIGFsaWduLCBtaXNhbGln bjsKZGlmZiAtLWdpdCBhL2djYy90cmVlLXZlY3Rvcml6ZXIuYyBiL2djYy90 cmVlLXZlY3Rvcml6ZXIuYwppbmRleCBiNzIxYzU2Li42NzMyNjE2IDEwMDY0 NAotLS0gYS9nY2MvdHJlZS12ZWN0b3JpemVyLmMKKysrIGIvZ2NjL3RyZWUt dmVjdG9yaXplci5jCkBAIC01OTgsMTIgKzU5OCwxOCBAQCB2ZWN0b3JpemVf bG9vcHMgKHZvaWQpCiAgIGZvciAoaSA9IDE7IGkgPCB2ZWN0X2xvb3BzX251 bTsgaSsrKQogICAgIHsKICAgICAgIGxvb3BfdmVjX2luZm8gbG9vcF92aW5m bzsKKyAgICAgIGJvb2wgaGFzX21hc2tfc3RvcmU7CiAKICAgICAgIGxvb3Ag PSBnZXRfbG9vcCAoY2Z1biwgaSk7CiAgICAgICBpZiAoIWxvb3ApCiAJY29u dGludWU7CiAgICAgICBsb29wX3ZpbmZvID0gKGxvb3BfdmVjX2luZm8pIGxv b3AtPmF1eDsKKyAgICAgIGhhc19tYXNrX3N0b3JlID0gZmFsc2U7CisgICAg ICBpZiAobG9vcF92aW5mbykKKwloYXNfbWFza19zdG9yZSA9IExPT1BfVklO Rk9fSEFTX01BU0tfU1RPUkUgKGxvb3BfdmluZm8pOwogICAgICAgZGVzdHJv eV9sb29wX3ZlY19pbmZvIChsb29wX3ZpbmZvLCB0cnVlKTsKKyAgICAgIGlm IChoYXNfbWFza19zdG9yZSkKKwlvcHRpbWl6ZV9tYXNrX3N0b3JlcyAobG9v cCk7CiAgICAgICBsb29wLT5hdXggPSBOVUxMOwogICAgIH0KIApkaWZmIC0t Z2l0IGEvZ2NjL3RyZWUtdmVjdG9yaXplci5oIGIvZ2NjL3RyZWUtdmVjdG9y aXplci5oCmluZGV4IDc4NjdjMjYuLjA0MDA1MWMgMTAwNjQ0Ci0tLSBhL2dj Yy90cmVlLXZlY3Rvcml6ZXIuaAorKysgYi9nY2MvdHJlZS12ZWN0b3JpemVy LmgKQEAgLTMzMCw2ICszMzAsOSBAQCB0eXBlZGVmIHN0cnVjdCBfbG9vcF92 ZWNfaW5mbyA6IHB1YmxpYyB2ZWNfaW5mbyB7CiAgICAgIGxvb3AgdmVyc2lv biB3aXRob3V0IGlmLWNvbnZlcnNpb24uICAqLwogICBzdHJ1Y3QgbG9vcCAq c2NhbGFyX2xvb3A7CiAKKyAgLyogTWFyayBsb29wcyBoYXZpbmcgbWFza2Vk IHN0b3Jlcy4gICovCisgIGJvb2wgaGFzX21hc2tfc3RvcmU7CisKIH0gKmxv b3BfdmVjX2luZm87CiAKIC8qIEFjY2VzcyBGdW5jdGlvbnMuICAqLwpAQCAt MzY3LDYgKzM3MCw3IEBAIHR5cGVkZWYgc3RydWN0IF9sb29wX3ZlY19pbmZv IDogcHVibGljIHZlY19pbmZvIHsKICNkZWZpbmUgTE9PUF9WSU5GT19TQ0FM QVJfTE9PUChMKQkgICAoTCktPnNjYWxhcl9sb29wCiAjZGVmaW5lIExPT1Bf VklORk9fU0NBTEFSX0lURVJBVElPTl9DT1NUKEwpIChMKS0+c2NhbGFyX2Nv c3RfdmVjCiAjZGVmaW5lIExPT1BfVklORk9fU0lOR0xFX1NDQUxBUl9JVEVS QVRJT05fQ09TVChMKSAoTCktPnNpbmdsZV9zY2FsYXJfaXRlcmF0aW9uX2Nv c3QKKyNkZWZpbmUgTE9PUF9WSU5GT19IQVNfTUFTS19TVE9SRShMKSAgICAg IChMKS0+aGFzX21hc2tfc3RvcmUKIAogI2RlZmluZSBMT09QX1JFUVVJUkVT X1ZFUlNJT05JTkdfRk9SX0FMSUdOTUVOVChMKSBcCiAgICgoTCktPm1heV9t aXNhbGlnbl9zdG10cy5sZW5ndGggKCkgPiAwKQpAQCAtMTAwMSw2ICsxMDA1 LDcgQEAgZXh0ZXJuIHZvaWQgdmVjdF9nZXRfdmVjX2RlZnMgKHRyZWUsIHRy ZWUsIGdpbXBsZSAqLCB2ZWM8dHJlZT4gKiwKIAkJCSAgICAgICB2ZWM8dHJl ZT4gKiwgc2xwX3RyZWUsIGludCk7CiBleHRlcm4gdHJlZSB2ZWN0X2dlbl9w ZXJtX21hc2tfYW55ICh0cmVlLCBjb25zdCB1bnNpZ25lZCBjaGFyICopOwog ZXh0ZXJuIHRyZWUgdmVjdF9nZW5fcGVybV9tYXNrX2NoZWNrZWQgKHRyZWUs IGNvbnN0IHVuc2lnbmVkIGNoYXIgKik7CitleHRlcm4gdm9pZCBvcHRpbWl6 ZV9tYXNrX3N0b3JlcyAoc3RydWN0IGxvb3AgKik7CiAKIC8qIEluIHRyZWUt dmVjdC1kYXRhLXJlZnMuYy4gICovCiBleHRlcm4gYm9vbCB2ZWN0X2Nhbl9m b3JjZV9kcl9hbGlnbm1lbnRfcCAoY29uc3RfdHJlZSwgdW5zaWduZWQgaW50 KTsKZGlmZiAtLWdpdCBhL2djYy90cmVlLXZycC5jIGIvZ2NjL3RyZWUtdnJw LmMKaW5kZXggZTY3MDQ4ZS4uMTYwNTUyMGMgMTAwNjQ0Ci0tLSBhL2djYy90 cmVlLXZycC5jCisrKyBiL2djYy90cmVlLXZycC5jCkBAIC01NzYwLDYgKzU3 NjAsMTIgQEAgcmVnaXN0ZXJfZWRnZV9hc3NlcnRfZm9yICh0cmVlIG5hbWUs IGVkZ2UgZSwgZ2ltcGxlX3N0bXRfaXRlcmF0b3Igc2ksCiAJCQkJCQkmY29t cF9jb2RlLCAmdmFsKSkKICAgICByZXR1cm47CiAKKyAgLyogVXNlIG9mIHZl Y3RvciBjb21wYXJpc29uIGluIGdjb25kIGlzIHZlcnkgcmVzdHJpY3RlZCBh bmQgdXNlZCB0byBjaGVjaworICAgICB0aGF0IHRoZSBtYXNrIGluIG1hc2tl ZCBzdG9yZSBpcyB6ZXJvLCBzbyBhc3NlcnQgZm9yIHN1Y2ggY29tcGFyaXNv bgorICAgICBpcyBub3QgaW1wbGVtZW50ZWQgeWV0LiAgKi8KKyAgaWYgKFRS RUVfQ09ERSAoVFJFRV9UWVBFIChuYW1lKSkgPT0gVkVDVE9SX1RZUEUpCisg ICAgcmV0dXJuOworCiAgIC8qIFJlZ2lzdGVyIEFTU0VSVF9FWFBScyBmb3Ig bmFtZS4gICovCiAgIHJlZ2lzdGVyX2VkZ2VfYXNzZXJ0X2Zvcl8yIChuYW1l LCBlLCBzaSwgY29uZF9jb2RlLCBjb25kX29wMCwKIAkJCSAgICAgIGNvbmRf b3AxLCBpc19lbHNlX2VkZ2UpOwo= --001a11c15cfa59b8450524e64b47--