From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 91232 invoked by alias); 21 Oct 2019 20:12:21 -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 91177 invoked by uid 89); 21 Oct 2019 20:12:21 -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=H*f:sk:zoyFqaO, H*f:sk:rv0Z-ny, H*f:CAAgBjM X-HELO: mail-lj1-f182.google.com Received: from mail-lj1-f182.google.com (HELO mail-lj1-f182.google.com) (209.85.208.182) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 21 Oct 2019 20:12:17 +0000 Received: by mail-lj1-f182.google.com with SMTP id d1so14670418ljl.13 for ; Mon, 21 Oct 2019 13:12:17 -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 :cc; bh=YpuyQsIYUYUi71ZHGPj01ZaCcF0sc3vULagFXJZ5/6k=; b=MFtJ1WMHa7kx6OAxKIzivNiF+PuhFo8EXnAFOc+Xs+OJidvzvGxGC31peNrMtczBQ9 VGOYirmqVQYrQBNFBj7/GUVwLhB41HEEP+1bzyLh6OREjZ3YEseAXG9gyTTihkCKEQRg zd+E+hyrAFm6FWVoaa5EoTFCoU/D96Uu5hEQrK+f63eerPtOY8F5CflIAPYp8b2RTYx0 F3cGtNmKPnuSTRWNnlZaIP82EO7u4fs5hiQiPFN8iuvYg/E70r3dkbBG8FnFVD8I/HYb h0eVGz0pRBTxRBG/QYsadPp4NueZkLzI541hrADcVevGwQBaPgeHuvob0PCtHq9qjSTD q7Qg== MIME-Version: 1.0 References: In-Reply-To: From: Prathamesh Kulkarni Date: Mon, 21 Oct 2019 20:16:00 -0000 Message-ID: Subject: Re: [SVE] PR91272 To: Richard Sandiford Cc: gcc Patches Content-Type: multipart/mixed; boundary="000000000000bea6da0595714c4f" X-IsSubscribed: yes X-SW-Source: 2019-10/txt/msg01529.txt.bz2 --000000000000bea6da0595714c4f Content-Type: text/plain; charset="UTF-8" Content-length: 7599 On Fri, 18 Oct 2019 at 14:36, Richard Sandiford wrote: > > Prathamesh Kulkarni writes: > > Hi, > > The attached patch tries to fix PR91272. > > Does it look OK ? > > > > With patch, I see following failures for aarch64-sve.exp: > > FAIL: gcc.target/aarch64/sve/clastb_1.c -march=armv8.2-a+sve > > scan-assembler \\tclastb\\tw[0-9]+, p[0-7], w[0-9]+, z[0-9]+\\.s > > FAIL: gcc.target/aarch64/sve/clastb_2.c -march=armv8.2-a+sve > > scan-assembler \\tclastb\\tw[0-9]+, p[0-7]+, w[0-9]+, z[0-9]+\\.s > > FAIL: gcc.target/aarch64/sve/clastb_3.c -march=armv8.2-a+sve > > scan-assembler \\tclastb\\tw[0-9]+, p[0-7]+, w[0-9]+, z[0-9]+\\.b > > FAIL: gcc.target/aarch64/sve/clastb_5.c -march=armv8.2-a+sve > > scan-assembler \\tclastb\\tx[0-9]+, p[0-7], x[0-9]+, z[0-9]+\\.d > > > > For instance, in clastb_1.c, it now emits: > > clastb s1, p1, s1, z0.s > > while using a fully predicated loop. > > Should I adjust the tests ? > > Yeah, that's an improvement really. > > > diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c > > index acdd90784dc..2cad2cb94c8 100644 > > --- a/gcc/tree-vect-stmts.c > > +++ b/gcc/tree-vect-stmts.c > > @@ -10016,7 +10016,8 @@ vectorizable_condition (stmt_vec_info stmt_info, gimple_stmt_iterator *gsi, > > /* See whether another part of the vectorized code applies a loop > > mask to the condition, or to its inverse. */ > > > > - if (loop_vinfo && LOOP_VINFO_FULLY_MASKED_P (loop_vinfo)) > > + if (loop_vinfo && LOOP_VINFO_FULLY_MASKED_P (loop_vinfo) > > + && reduction_type != EXTRACT_LAST_REDUCTION) > > { > > scalar_cond_masked_key cond (cond_expr, ncopies); > > if (loop_vinfo->scalar_cond_masked_set.contains (cond)) > > The context here is: > > 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); > } > else > { > bool honor_nans = HONOR_NANS (TREE_TYPE (cond.op0)); > cond.code = invert_tree_comparison (cond.code, honor_nans); > 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); > cond_code = cond.code; > swap_cond_operands = true; > } > } > > Rather than have another instance of vect_get_loop_mask, I think > it would cleaner to use a nonnull "masks" to decide whether to apply > the loop mask: > > vec_loop_masks *masks = NULL; > if (loop_vinfo && LOOP_VINFO_FULLY_MASKED_P (loop_vinfo) > { > if (reduction_type == EXTRACT_LAST_REDUCTION > || loop_vinfo->scalar_cond_masked_set.contains (cond)) > masks = &LOOP_VINFO_MASKS (loop_vinfo); > else > { > ... > } > > Then: > > > @@ -10116,6 +10117,15 @@ vectorizable_condition (stmt_vec_info stmt_info, gimple_stmt_iterator *gsi, > > vec_then_clause = vec_oprnds2[i]; > > vec_else_clause = vec_oprnds3[i]; > > > > + if (loop_vinfo && LOOP_VINFO_FULLY_MASKED_P (loop_vinfo) > > + && reduction_type == EXTRACT_LAST_REDUCTION) > > + { > > + vec_loop_masks *masks = &LOOP_VINFO_MASKS (loop_vinfo); > > + unsigned vec_num = vec_oprnds0.length (); > > + loop_mask = vect_get_loop_mask (gsi, masks, vec_num * ncopies, > > + vectype, vec_num * j + i); > > + } > > + > > ...do this vect_get_loop_mask under the condition of "if (masks)". > > > if (swap_cond_operands) > > std::swap (vec_then_clause, vec_else_clause); > > > > @@ -10180,7 +10190,7 @@ vectorizable_condition (stmt_vec_info stmt_info, gimple_stmt_iterator *gsi, > > vec != { 0, ... } (masked in the MASK_LOAD, > > unmasked in the VEC_COND_EXPR). */ > > > > - if (loop_mask) > > + if (loop_mask && reduction_type != EXTRACT_LAST_REDUCTION) > > { > > if (COMPARISON_CLASS_P (vec_compare)) > > { > > @@ -10220,6 +10230,16 @@ vectorizable_condition (stmt_vec_info stmt_info, gimple_stmt_iterator *gsi, > > vect_finish_stmt_generation (stmt_info, new_stmt, gsi); > > vec_compare = vec_compare_name; > > } > > The code above here: > > if (!is_gimple_val (vec_compare)) > { > tree vec_compare_name = make_ssa_name (vec_cmp_type); > gassign *new_stmt = gimple_build_assign (vec_compare_name, > vec_compare); > vect_finish_stmt_generation (stmt_info, new_stmt, gsi); > vec_compare = vec_compare_name; > } > > is doing something similar to the new COND_EXPR handling: > > if (COMPARISON_CLASS_P (vec_compare)) > { > tree tmp = make_ssa_name (vec_cmp_type); > tree op0 = TREE_OPERAND (vec_compare, 0); > tree op1 = TREE_OPERAND (vec_compare, 1); > gassign *g = gimple_build_assign (tmp, > TREE_CODE (vec_compare), > op0, op1); > vect_finish_stmt_generation (stmt_info, g, gsi); > vec_compare = tmp; > } > > There's then an added case: > > if (must_invert_cmp_result) > { > tree vec_compare_name = make_ssa_name (vec_cmp_type); > gassign *new_stmt = gimple_build_assign (vec_compare_name, > BIT_NOT_EXPR, > vec_compare); > vect_finish_stmt_generation (stmt_info, new_stmt, gsi); > vec_compare = vec_compare_name; > } > > that would be a safe no-op for the normal COND_EXPR path (because > must_invert_cmp_result is always false then). Then this: > > > + > > + if (loop_mask) > > + { > > + tree tmp = make_ssa_name (vec_cmp_type); > > + gassign *g = gimple_build_assign (tmp, BIT_AND_EXPR, > > + vec_compare, loop_mask); > > + vect_finish_stmt_generation (stmt_info, g, gsi); > > + vec_compare = tmp; > > + } > > + > > is the equivalent of the above: > > 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; > > So with this patch, I think the EXTRACT_LAST_REDUCTION and the normal > COND_EXPR paths should be able to share the mask generation code. Hi Richard, Thanks for the suggestions, does the attached patch look OK ? A quick comparison of aarch64-sve.exp shows no regressions, bootstrap+test in progress. Thanks, Prathamesh > > Thanks, > Richard --000000000000bea6da0595714c4f Content-Type: text/x-patch; charset="US-ASCII"; name="pr91272-2.diff" Content-Disposition: attachment; filename="pr91272-2.diff" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_k20utgfl0 Content-length: 14148 ZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0 L3N2ZS9jbGFzdGJfMS5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2Fh cmNoNjQvc3ZlL2NsYXN0Yl8xLmMKaW5kZXggZDRmOWIwYjZhOTQuLmQzZWE1 MmRlYTQ3IDEwMDY0NAotLS0gYS9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQv YWFyY2g2NC9zdmUvY2xhc3RiXzEuYworKysgYi9nY2MvdGVzdHN1aXRlL2dj Yy50YXJnZXQvYWFyY2g2NC9zdmUvY2xhc3RiXzEuYwpAQCAtMSw1ICsxLDUg QEAKIC8qIHsgZGctZG8gYXNzZW1ibGUgeyB0YXJnZXQgYWFyY2g2NF9hc21f c3ZlX29rIH0gfSAqLwotLyogeyBkZy1vcHRpb25zICItTzIgLWZ0cmVlLXZl Y3Rvcml6ZSAtLXNhdmUtdGVtcHMiIH0gKi8KKy8qIHsgZGctb3B0aW9ucyAi LU8yIC1mdHJlZS12ZWN0b3JpemUgLWZkdW1wLXRyZWUtdmVjdC1kZXRhaWxz IC0tc2F2ZS10ZW1wcyIgfSAqLwogCiAjZGVmaW5lIE4gMzIKIApAQCAtMTcs NCArMTcsNSBAQCBjb25kaXRpb25fcmVkdWN0aW9uIChpbnQgKmEsIGludCBt aW5fdikKICAgcmV0dXJuIGxhc3Q7CiB9CiAKLS8qIHsgZGctZmluYWwgeyBz Y2FuLWFzc2VtYmxlciB7XHRjbGFzdGJcdHdbMC05XSssIHBbMC03XSwgd1sw LTldKywgelswLTldK1wuc30gfSB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nh bi10cmVlLWR1bXAgInVzaW5nIGEgZnVsbHktbWFza2VkIGxvb3AuIiAidmVj dCIgfSB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi1hc3NlbWJsZXIge1x0 Y2xhc3RiXHRzWzAtOV0rLCBwWzAtN10sIHNbMC05XSssIHpbMC05XStcLnN9 IH0gfSAqLwpkaWZmIC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0 L2FhcmNoNjQvc3ZlL2NsYXN0Yl8yLmMgYi9nY2MvdGVzdHN1aXRlL2djYy50 YXJnZXQvYWFyY2g2NC9zdmUvY2xhc3RiXzIuYwppbmRleCAyYzQ5YmQzYjBm MC4uYzIyMmI3MDc5MTIgMTAwNjQ0Ci0tLSBhL2djYy90ZXN0c3VpdGUvZ2Nj LnRhcmdldC9hYXJjaDY0L3N2ZS9jbGFzdGJfMi5jCisrKyBiL2djYy90ZXN0 c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0L3N2ZS9jbGFzdGJfMi5jCkBAIC0x LDUgKzEsNSBAQAogLyogeyBkZy1kbyBhc3NlbWJsZSB7IHRhcmdldCBhYXJj aDY0X2FzbV9zdmVfb2sgfSB9ICovCi0vKiB7IGRnLW9wdGlvbnMgIi1PMiAt ZnRyZWUtdmVjdG9yaXplIC0tc2F2ZS10ZW1wcyIgfSAqLworLyogeyBkZy1v cHRpb25zICItTzIgLWZ0cmVlLXZlY3Rvcml6ZSAtZmR1bXAtdHJlZS12ZWN0 LWRldGFpbHMgLS1zYXZlLXRlbXBzIiB9ICovCiAKICNpbmNsdWRlIDxzdGRp bnQuaD4KIApAQCAtMjMsNCArMjMsNSBAQCBjb25kaXRpb25fcmVkdWN0aW9u IChUWVBFICphLCBUWVBFIG1pbl92KQogICByZXR1cm4gbGFzdDsKIH0KIAot LyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyIHtcdGNsYXN0Ylx0d1sw LTldKywgcFswLTddKywgd1swLTldKywgelswLTldK1wuc30gfSB9ICovCisv KiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAgInVzaW5nIGEgZnVsbHkt bWFza2VkIGxvb3AuIiAidmVjdCIgfSB9ICovCisvKiB7IGRnLWZpbmFsIHsg c2Nhbi1hc3NlbWJsZXIge1x0Y2xhc3RiXHRzWzAtOV0rLCBwWzAtN10sIHNb MC05XSssIHpbMC05XStcLnN9IH0gfSAqLwpkaWZmIC0tZ2l0IGEvZ2NjL3Rl c3RzdWl0ZS9nY2MudGFyZ2V0L2FhcmNoNjQvc3ZlL2NsYXN0Yl8zLmMgYi9n Y2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYWFyY2g2NC9zdmUvY2xhc3RiXzMu YwppbmRleCAzNTM0NGY0NDZjNi4uNWFhYTcxZjk0OGQgMTAwNjQ0Ci0tLSBh L2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0L3N2ZS9jbGFzdGJf My5jCisrKyBiL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0L3N2 ZS9jbGFzdGJfMy5jCkBAIC0xLDggKzEsOSBAQAogLyogeyBkZy1kbyBhc3Nl bWJsZSB7IHRhcmdldCBhYXJjaDY0X2FzbV9zdmVfb2sgfSB9ICovCi0vKiB7 IGRnLW9wdGlvbnMgIi1PMiAtZnRyZWUtdmVjdG9yaXplIC0tc2F2ZS10ZW1w cyIgfSAqLworLyogeyBkZy1vcHRpb25zICItTzIgLWZ0cmVlLXZlY3Rvcml6 ZSAtZmR1bXAtdHJlZS12ZWN0LWRldGFpbHMgLS1zYXZlLXRlbXBzIiB9ICov CiAKICNkZWZpbmUgVFlQRSB1aW50OF90CiAKICNpbmNsdWRlICJjbGFzdGJf Mi5jIgogCi0vKiB7IGRnLWZpbmFsIHsgc2Nhbi1hc3NlbWJsZXIge1x0Y2xh c3RiXHR3WzAtOV0rLCBwWzAtN10rLCB3WzAtOV0rLCB6WzAtOV0rXC5ifSB9 IH0gKi8KKy8qIHsgZGctZmluYWwgeyBzY2FuLXRyZWUtZHVtcCAidXNpbmcg YSBmdWxseS1tYXNrZWQgbG9vcC4iICJ2ZWN0IiB9IH0gKi8KKy8qIHsgZGct ZmluYWwgeyBzY2FuLWFzc2VtYmxlciB7XHRjbGFzdGJcdGJbMC05XSssIHBb MC03XSwgYlswLTldKywgelswLTldK1wuYn0gfSB9ICovCmRpZmYgLS1naXQg YS9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYWFyY2g2NC9zdmUvY2xhc3Ri XzQuYyBiL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0L3N2ZS9j bGFzdGJfNC5jCmluZGV4IGNlNThhYmQ2MTYxLi5iNGRiMTcwZWEwNiAxMDA2 NDQKLS0tIGEvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FhcmNoNjQvc3Zl L2NsYXN0Yl80LmMKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2Fh cmNoNjQvc3ZlL2NsYXN0Yl80LmMKQEAgLTEsOCArMSw5IEBACiAvKiB7IGRn LWRvIGFzc2VtYmxlIHsgdGFyZ2V0IGFhcmNoNjRfYXNtX3N2ZV9vayB9IH0g Ki8KLS8qIHsgZGctb3B0aW9ucyAiLU8yIC1mdHJlZS12ZWN0b3JpemUgLS1z YXZlLXRlbXBzIiB9ICovCisvKiB7IGRnLW9wdGlvbnMgIi1PMiAtZnRyZWUt dmVjdG9yaXplIC1mZHVtcC10cmVlLXZlY3QtZGV0YWlscyAtLXNhdmUtdGVt cHMiIH0gKi8KIAogI2RlZmluZSBUWVBFIGludDE2X3QKIAogI2luY2x1ZGUg ImNsYXN0Yl8yLmMiCiAKKy8qIHsgZGctZmluYWwgeyBzY2FuLXRyZWUtZHVt cCAidXNpbmcgYSBmdWxseS1tYXNrZWQgbG9vcC4iICJ2ZWN0IiB9IH0gKi8K IC8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlciB7XHRjbGFzdGJcdHdb MC05XSssIHBbMC03XSwgd1swLTldKywgelswLTldK1wuaH0gfSB9ICovCmRp ZmYgLS1naXQgYS9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYWFyY2g2NC9z dmUvY2xhc3RiXzUuYyBiL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hYXJj aDY0L3N2ZS9jbGFzdGJfNS5jCmluZGV4IDJiOTc4M2Q2NjI3Li4yOGQ0MGEw MWY5MyAxMDA2NDQKLS0tIGEvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2Fh cmNoNjQvc3ZlL2NsYXN0Yl81LmMKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2Mu dGFyZ2V0L2FhcmNoNjQvc3ZlL2NsYXN0Yl81LmMKQEAgLTEsOCArMSw5IEBA CiAvKiB7IGRnLWRvIGFzc2VtYmxlIHsgdGFyZ2V0IGFhcmNoNjRfYXNtX3N2 ZV9vayB9IH0gKi8KLS8qIHsgZGctb3B0aW9ucyAiLU8yIC1mdHJlZS12ZWN0 b3JpemUgLS1zYXZlLXRlbXBzIiB9ICovCisvKiB7IGRnLW9wdGlvbnMgIi1P MiAtZnRyZWUtdmVjdG9yaXplIC1mZHVtcC10cmVlLXZlY3QtZGV0YWlscyAt LXNhdmUtdGVtcHMiIH0gKi8KIAogI2RlZmluZSBUWVBFIHVpbnQ2NF90CiAK ICNpbmNsdWRlICJjbGFzdGJfMi5jIgogCi0vKiB7IGRnLWZpbmFsIHsgc2Nh bi1hc3NlbWJsZXIge1x0Y2xhc3RiXHR4WzAtOV0rLCBwWzAtN10sIHhbMC05 XSssIHpbMC05XStcLmR9IH0gfSAqLworLyogeyBkZy1maW5hbCB7IHNjYW4t dHJlZS1kdW1wICJ1c2luZyBhIGZ1bGx5LW1hc2tlZCBsb29wLiIgInZlY3Qi IH0gfSAqLworLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyIHtcdGNs YXN0Ylx0ZFswLTldKywgcFswLTddLCBkWzAtOV0rLCB6WzAtOV0rXC5kfSB9 IH0gKi8KZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9h YXJjaDY0L3N2ZS9jbGFzdGJfNi5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFy Z2V0L2FhcmNoNjQvc3ZlL2NsYXN0Yl82LmMKaW5kZXggYzQ3ZDMwM2Y3MzAu LjM4NjMyYTIxYmUxIDEwMDY0NAotLS0gYS9nY2MvdGVzdHN1aXRlL2djYy50 YXJnZXQvYWFyY2g2NC9zdmUvY2xhc3RiXzYuYworKysgYi9nY2MvdGVzdHN1 aXRlL2djYy50YXJnZXQvYWFyY2g2NC9zdmUvY2xhc3RiXzYuYwpAQCAtMSw1 ICsxLDUgQEAKIC8qIHsgZGctZG8gYXNzZW1ibGUgeyB0YXJnZXQgYWFyY2g2 NF9hc21fc3ZlX29rIH0gfSAqLwotLyogeyBkZy1vcHRpb25zICItTzIgLWZ0 cmVlLXZlY3Rvcml6ZSAtLXNhdmUtdGVtcHMiIH0gKi8KKy8qIHsgZGctb3B0 aW9ucyAiLU8yIC1mdHJlZS12ZWN0b3JpemUgLWZkdW1wLXRyZWUtdmVjdC1k ZXRhaWxzIC0tc2F2ZS10ZW1wcyIgfSAqLwogCiAjZGVmaW5lIE4gMzIKIApA QCAtMjEsNCArMjEsNSBAQCBjb25kaXRpb25fcmVkdWN0aW9uIChUWVBFICph LCBUWVBFIG1pbl92KQogICByZXR1cm4gbGFzdDsKIH0KIAorLyogeyBkZy1m aW5hbCB7IHNjYW4tdHJlZS1kdW1wICJ1c2luZyBhIGZ1bGx5LW1hc2tlZCBs b29wLiIgInZlY3QiIH0gfSAqLwogLyogeyBkZy1maW5hbCB7IHNjYW4tYXNz ZW1ibGVyIHtcdGNsYXN0Ylx0c1swLTldKywgcFswLTddLCBzWzAtOV0rLCB6 WzAtOV0rXC5zfSB9IH0gKi8KZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUv Z2NjLnRhcmdldC9hYXJjaDY0L3N2ZS9jbGFzdGJfNy5jIGIvZ2NjL3Rlc3Rz dWl0ZS9nY2MudGFyZ2V0L2FhcmNoNjQvc3ZlL2NsYXN0Yl83LmMKaW5kZXgg MzM0NWY4NzRhMzkuLmU1MzA3ZDJlZGM4IDEwMDY0NAotLS0gYS9nY2MvdGVz dHN1aXRlL2djYy50YXJnZXQvYWFyY2g2NC9zdmUvY2xhc3RiXzcuYworKysg Yi9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYWFyY2g2NC9zdmUvY2xhc3Ri XzcuYwpAQCAtMSw3ICsxLDggQEAKIC8qIHsgZGctZG8gYXNzZW1ibGUgeyB0 YXJnZXQgYWFyY2g2NF9hc21fc3ZlX29rIH0gfSAqLwotLyogeyBkZy1vcHRp b25zICItTzIgLWZ0cmVlLXZlY3Rvcml6ZSAtLXNhdmUtdGVtcHMiIH0gKi8K Ky8qIHsgZGctb3B0aW9ucyAiLU8yIC1mdHJlZS12ZWN0b3JpemUgLWZkdW1w LXRyZWUtdmVjdC1kZXRhaWxzIC0tc2F2ZS10ZW1wcyIgfSAqLwogCiAjZGVm aW5lIFRZUEUgZG91YmxlCiAjaW5jbHVkZSAiY2xhc3RiXzYuYyIKIAorLyog eyBkZy1maW5hbCB7IHNjYW4tdHJlZS1kdW1wICJ1c2luZyBhIGZ1bGx5LW1h c2tlZCBsb29wLiIgInZlY3QiIH0gfSAqLwogLyogeyBkZy1maW5hbCB7IHNj YW4tYXNzZW1ibGVyIHtcdGNsYXN0Ylx0ZFswLTldKywgcFswLTddLCBkWzAt OV0rLCB6WzAtOV0rXC5kfSB9IH0gKi8KZGlmZiAtLWdpdCBhL2djYy90ZXN0 c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0L3N2ZS9jbGFzdGJfOC5jIGIvZ2Nj L3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FhcmNoNjQvc3ZlL2NsYXN0Yl84LmMK aW5kZXggZDg2YTQyOGE3ZmEuLjU4M2ZjOGQ4ZDZkIDEwMDY0NAotLS0gYS9n Y2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYWFyY2g2NC9zdmUvY2xhc3RiXzgu YworKysgYi9nY2MvdGVzdHN1aXRlL2djYy50YXJnZXQvYWFyY2g2NC9zdmUv Y2xhc3RiXzguYwpAQCAtMSw1ICsxLDUgQEAKIC8qIHsgZGctZG8gYXNzZW1i bGUgeyB0YXJnZXQgYWFyY2g2NF9hc21fc3ZlX29rIH0gfSAqLwotLyogeyBk Zy1vcHRpb25zICItTzIgLWZ0cmVlLXZlY3Rvcml6ZSAtbXN2ZS12ZWN0b3It Yml0cz0yNTYgLS1zYXZlLXRlbXBzIiB9ICovCisvKiB7IGRnLW9wdGlvbnMg Ii1PMiAtZnRyZWUtdmVjdG9yaXplIC1mZHVtcC10cmVlLXZlY3QtZGV0YWls cyAtbXN2ZS12ZWN0b3ItYml0cz0yNTYgLS1zYXZlLXRlbXBzIiB9ICovCiAK ICNpbmNsdWRlIDxzdGRpbnQuaD4KIApAQCAtMTksNiArMTksNyBAQCBURVNU X1RZUEUgKHVpbnQxNl90KTsKIFRFU1RfVFlQRSAodWludDMyX3QpOwogVEVT VF9UWVBFICh1aW50NjRfdCk7CiAKKy8qIHsgZGctZmluYWwgeyBzY2FuLXRy ZWUtZHVtcC10aW1lcyAidXNpbmcgYSBmdWxseS1tYXNrZWQgbG9vcC4iIDQg InZlY3QiIH0gfSAqLwogLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVy IHtcdGNsYXN0Ylx0KGJbMC05XSspLCBwWzAtN10sIFwxLCB6WzAtOV0rXC5i XG59IH0gfSAqLwogLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyIHtc dGNsYXN0Ylx0KGhbMC05XSspLCBwWzAtN10sIFwxLCB6WzAtOV0rXC5oXG59 IH0gfSAqLwogLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyIHtcdGNs YXN0Ylx0KHNbMC05XSspLCBwWzAtN10sIFwxLCB6WzAtOV0rXC5zXG59IH0g fSAqLwpkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUtdmVjdC1sb29wLmMgYi9nY2Mv dHJlZS12ZWN0LWxvb3AuYwppbmRleCBhNzBkNTJlYjJjYS4uODI4MTRlMmMy YWYgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXZlY3QtbG9vcC5jCisrKyBiL2dj Yy90cmVlLXZlY3QtbG9vcC5jCkBAIC02NDI4LDYgKzY0MjgsNyBAQCB2ZWN0 b3JpemFibGVfcmVkdWN0aW9uIChzdG10X3ZlY19pbmZvIHN0bXRfaW5mbywg c2xwX3RyZWUgc2xwX25vZGUsCiAgIGlmIChsb29wX3ZpbmZvICYmIExPT1Bf VklORk9fQ0FOX0ZVTExZX01BU0tfUCAobG9vcF92aW5mbykpCiAgICAgewog ICAgICAgaWYgKHJlZHVjdGlvbl90eXBlICE9IEZPTERfTEVGVF9SRURVQ1RJ T04KKwkgICYmIHJlZHVjdGlvbl90eXBlICE9IEVYVFJBQ1RfTEFTVF9SRURV Q1RJT04KIAkgICYmICFtYXNrX2J5X2NvbmRfZXhwcgogCSAgJiYgKGNvbmRf Zm4gPT0gSUZOX0xBU1QKIAkgICAgICB8fCAhZGlyZWN0X2ludGVybmFsX2Zu X3N1cHBvcnRlZF9wIChjb25kX2ZuLCB2ZWN0eXBlX2luLApkaWZmIC0tZ2l0 IGEvZ2NjL3RyZWUtdmVjdC1zdG10cy5jIGIvZ2NjL3RyZWUtdmVjdC1zdG10 cy5jCmluZGV4IGFjZGQ5MDc4NGRjLi5kZmQzM2IxNDJlZCAxMDA2NDQKLS0t IGEvZ2NjL3RyZWUtdmVjdC1zdG10cy5jCisrKyBiL2djYy90cmVlLXZlY3Qt c3RtdHMuYwpAQCAtMTAwMTYsMjUgKzEwMDE2LDI2IEBAIHZlY3Rvcml6YWJs ZV9jb25kaXRpb24gKHN0bXRfdmVjX2luZm8gc3RtdF9pbmZvLCBnaW1wbGVf c3RtdF9pdGVyYXRvciAqZ3NpLAogICAgICAgLyogU2VlIHdoZXRoZXIgYW5v dGhlciBwYXJ0IG9mIHRoZSB2ZWN0b3JpemVkIGNvZGUgYXBwbGllcyBhIGxv b3AKIAkgbWFzayB0byB0aGUgY29uZGl0aW9uLCBvciB0byBpdHMgaW52ZXJz ZS4gICovCiAKKyAgICAgIHZlY19sb29wX21hc2tzICptYXNrcyA9IE5VTEw7 CiAgICAgICBpZiAobG9vcF92aW5mbyAmJiBMT09QX1ZJTkZPX0ZVTExZX01B U0tFRF9QIChsb29wX3ZpbmZvKSkKIAl7Ci0JICBzY2FsYXJfY29uZF9tYXNr ZWRfa2V5IGNvbmQgKGNvbmRfZXhwciwgbmNvcGllcyk7Ci0JICBpZiAobG9v cF92aW5mby0+c2NhbGFyX2NvbmRfbWFza2VkX3NldC5jb250YWlucyAoY29u ZCkpCi0JICAgIHsKLQkgICAgICB2ZWNfbG9vcF9tYXNrcyAqbWFza3MgPSAm TE9PUF9WSU5GT19NQVNLUyAobG9vcF92aW5mbyk7Ci0JICAgICAgbG9vcF9t YXNrID0gdmVjdF9nZXRfbG9vcF9tYXNrIChnc2ksIG1hc2tzLCBuY29waWVz LCB2ZWN0eXBlLCBqKTsKLQkgICAgfQorCSAgaWYgKHJlZHVjdGlvbl90eXBl ID09IEVYVFJBQ1RfTEFTVF9SRURVQ1RJT04pCisJICAgIG1hc2tzID0gJkxP T1BfVklORk9fTUFTS1MgKGxvb3BfdmluZm8pOwogCSAgZWxzZQogCSAgICB7 Ci0JICAgICAgYm9vbCBob25vcl9uYW5zID0gSE9OT1JfTkFOUyAoVFJFRV9U WVBFIChjb25kLm9wMCkpOwotCSAgICAgIGNvbmQuY29kZSA9IGludmVydF90 cmVlX2NvbXBhcmlzb24gKGNvbmQuY29kZSwgaG9ub3JfbmFucyk7CisJICAg ICAgc2NhbGFyX2NvbmRfbWFza2VkX2tleSBjb25kIChjb25kX2V4cHIsIG5j b3BpZXMpOwogCSAgICAgIGlmIChsb29wX3ZpbmZvLT5zY2FsYXJfY29uZF9t YXNrZWRfc2V0LmNvbnRhaW5zIChjb25kKSkKKwkJbWFza3MgPSAmTE9PUF9W SU5GT19NQVNLUyAobG9vcF92aW5mbyk7CisJICAgICAgZWxzZQogCQl7Ci0J CSAgdmVjX2xvb3BfbWFza3MgKm1hc2tzID0gJkxPT1BfVklORk9fTUFTS1Mg KGxvb3BfdmluZm8pOwotCQkgIGxvb3BfbWFzayA9IHZlY3RfZ2V0X2xvb3Bf bWFzayAoZ3NpLCBtYXNrcywgbmNvcGllcywKLQkJCQkJCSAgdmVjdHlwZSwg aik7Ci0JCSAgY29uZF9jb2RlID0gY29uZC5jb2RlOwotCQkgIHN3YXBfY29u ZF9vcGVyYW5kcyA9IHRydWU7CisJCSAgYm9vbCBob25vcl9uYW5zID0gSE9O T1JfTkFOUyAoVFJFRV9UWVBFIChjb25kLm9wMCkpOworCQkgIGNvbmQuY29k ZSA9IGludmVydF90cmVlX2NvbXBhcmlzb24gKGNvbmQuY29kZSwgaG9ub3Jf bmFucyk7CisJCSAgaWYgKGxvb3BfdmluZm8tPnNjYWxhcl9jb25kX21hc2tl ZF9zZXQuY29udGFpbnMgKGNvbmQpKQorCQkgICAgeworCQkgICAgICBtYXNr cyA9ICZMT09QX1ZJTkZPX01BU0tTIChsb29wX3ZpbmZvKTsKKwkJICAgICAg Y29uZF9jb2RlID0gY29uZC5jb2RlOworCQkgICAgICBzd2FwX2NvbmRfb3Bl cmFuZHMgPSB0cnVlOworCQkgICAgfQogCQl9CiAJICAgIH0KIAl9CkBAIC0x MDExNiw2ICsxMDExNywxMyBAQCB2ZWN0b3JpemFibGVfY29uZGl0aW9uIChz dG10X3ZlY19pbmZvIHN0bXRfaW5mbywgZ2ltcGxlX3N0bXRfaXRlcmF0b3Ig KmdzaSwKICAgICAgICAgICB2ZWNfdGhlbl9jbGF1c2UgPSB2ZWNfb3BybmRz MltpXTsKICAgICAgICAgICB2ZWNfZWxzZV9jbGF1c2UgPSB2ZWNfb3BybmRz M1tpXTsKIAorICAgICAgICAgIGlmIChtYXNrcykKKwkgICAgeworCSAgICAg IHVuc2lnbmVkIHZlY19udW0gPSB2ZWNfb3BybmRzMC5sZW5ndGggKCk7CisJ ICAgICAgbG9vcF9tYXNrID0gdmVjdF9nZXRfbG9vcF9tYXNrIChnc2ksIG1h c2tzLCB2ZWNfbnVtICogbmNvcGllcywKKwkJCQkJICAgICAgdmVjdHlwZSwg dmVjX251bSAqIGogKyBpKTsKKwkgICAgfQorCiAJICBpZiAoc3dhcF9jb25k X29wZXJhbmRzKQogCSAgICBzdGQ6OnN3YXAgKHZlY190aGVuX2NsYXVzZSwg dmVjX2Vsc2VfY2xhdXNlKTsKIApAQCAtMTAxOTQsMjMgKzEwMjAyLDYgQEAg dmVjdG9yaXphYmxlX2NvbmRpdGlvbiAoc3RtdF92ZWNfaW5mbyBzdG10X2lu Zm8sIGdpbXBsZV9zdG10X2l0ZXJhdG9yICpnc2ksCiAJCSAgdmVjX2NvbXBh cmUgPSB0bXA7CiAJCX0KIAotCSAgICAgIHRyZWUgdG1wMiA9IG1ha2Vfc3Nh X25hbWUgKHZlY19jbXBfdHlwZSk7Ci0JICAgICAgZ2Fzc2lnbiAqZyA9IGdp bXBsZV9idWlsZF9hc3NpZ24gKHRtcDIsIEJJVF9BTkRfRVhQUiwKLQkJCQkJ CXZlY19jb21wYXJlLCBsb29wX21hc2spOwotCSAgICAgIHZlY3RfZmluaXNo X3N0bXRfZ2VuZXJhdGlvbiAoc3RtdF9pbmZvLCBnLCBnc2kpOwotCSAgICAg IHZlY19jb21wYXJlID0gdG1wMjsKLQkgICAgfQotCi0JICBpZiAocmVkdWN0 aW9uX3R5cGUgPT0gRVhUUkFDVF9MQVNUX1JFRFVDVElPTikKLQkgICAgewot CSAgICAgIGlmICghaXNfZ2ltcGxlX3ZhbCAodmVjX2NvbXBhcmUpKQotCQl7 Ci0JCSAgdHJlZSB2ZWNfY29tcGFyZV9uYW1lID0gbWFrZV9zc2FfbmFtZSAo dmVjX2NtcF90eXBlKTsKLQkJICBnYXNzaWduICpuZXdfc3RtdCA9IGdpbXBs ZV9idWlsZF9hc3NpZ24gKHZlY19jb21wYXJlX25hbWUsCi0JCQkJCQkJICAg dmVjX2NvbXBhcmUpOwotCQkgIHZlY3RfZmluaXNoX3N0bXRfZ2VuZXJhdGlv biAoc3RtdF9pbmZvLCBuZXdfc3RtdCwgZ3NpKTsKLQkJICB2ZWNfY29tcGFy ZSA9IHZlY19jb21wYXJlX25hbWU7Ci0JCX0KIAkgICAgICBpZiAobXVzdF9p bnZlcnRfY21wX3Jlc3VsdCkKIAkJewogCQkgIHRyZWUgdmVjX2NvbXBhcmVf bmFtZSA9IG1ha2Vfc3NhX25hbWUgKHZlY19jbXBfdHlwZSk7CkBAIC0xMDIy MCw2ICsxMDIxMSwxNiBAQCB2ZWN0b3JpemFibGVfY29uZGl0aW9uIChzdG10 X3ZlY19pbmZvIHN0bXRfaW5mbywgZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKmdz aSwKIAkJICB2ZWN0X2ZpbmlzaF9zdG10X2dlbmVyYXRpb24gKHN0bXRfaW5m bywgbmV3X3N0bXQsIGdzaSk7CiAJCSAgdmVjX2NvbXBhcmUgPSB2ZWNfY29t cGFyZV9uYW1lOwogCQl9CisKKwkgICAgICB0cmVlIHRtcDIgPSBtYWtlX3Nz YV9uYW1lICh2ZWNfY21wX3R5cGUpOworCSAgICAgIGdhc3NpZ24gKmcgPSBn aW1wbGVfYnVpbGRfYXNzaWduICh0bXAyLCBCSVRfQU5EX0VYUFIsCisJCQkJ CQl2ZWNfY29tcGFyZSwgbG9vcF9tYXNrKTsKKwkgICAgICB2ZWN0X2Zpbmlz aF9zdG10X2dlbmVyYXRpb24gKHN0bXRfaW5mbywgZywgZ3NpKTsKKwkgICAg ICB2ZWNfY29tcGFyZSA9IHRtcDI7CisJICAgIH0KKworCSAgaWYgKHJlZHVj dGlvbl90eXBlID09IEVYVFJBQ1RfTEFTVF9SRURVQ1RJT04pCisJICAgIHsK IAkgICAgICBnY2FsbCAqbmV3X3N0bXQgPSBnaW1wbGVfYnVpbGRfY2FsbF9p bnRlcm5hbAogCQkoSUZOX0ZPTERfRVhUUkFDVF9MQVNULCAzLCBlbHNlX2Ns YXVzZSwgdmVjX2NvbXBhcmUsCiAJCSB2ZWNfdGhlbl9jbGF1c2UpOwo= --000000000000bea6da0595714c4f--