From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-ej1-x62d.google.com (mail-ej1-x62d.google.com [IPv6:2a00:1450:4864:20::62d]) by sourceware.org (Postfix) with ESMTPS id 661533856255 for ; Wed, 11 May 2022 06:24:51 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 661533856255 Received: by mail-ej1-x62d.google.com with SMTP id ch13so1903427ejb.12 for ; Tue, 10 May 2022 23:24:51 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to; bh=EDoCg17+uomZsGnT471F3aNifkNZX82rcXFUVw7e9lw=; b=XDDFxbxUkshZ4HoV0mkQVq5huoma58I7g+alX/BG/LaSf0rIaY5VAa/5kL4ugrUWz6 KP6iQIh5OT3Hlh5g5cEvzH/h8xZcGMUnRIO3Ln+C3osUPsBQsAcW0fh8Qf43Zew94tsE /sm2l8ZkDWMgS6TSS0M/AwsOeSH+dw4uTTjVoL740xnqGUIzwFX/SbZrTrykIn2U3Ph6 kCXNU+m5QGk+VeCo8sNmNvdoIgbRirN6n8BMRP/C3ju+EH+le3QqATl4GZoTXWf4C6m/ VnS9vUopSNdify0LlP30WI66sCTZwue8Vdh4xSrx23DIZim0rLnLx2+doBHxlwTi15gF GidA== X-Gm-Message-State: AOAM530qbUdjYI2G7B5WGtWfHgtgPSdwiSTpAM5Oo0pQGMGDCFQ1XaSh VgYdLOmG6asgLiSoFLXrI40MwH7KcJ/NhbmgEKpZHQ== X-Google-Smtp-Source: ABdhPJzYqd+wC7qSgF1TTQk8FMQ64+IH1noOVFJXfuqywPtDddYNPqSOLGOF8YRShj/B4uzhcMEbLVvJY5YY7SnPUbM= X-Received: by 2002:a17:907:c0d:b0:6f3:ed89:d9c with SMTP id ga13-20020a1709070c0d00b006f3ed890d9cmr22276421ejc.502.1652250288990; Tue, 10 May 2022 23:24:48 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Prathamesh Kulkarni Date: Wed, 11 May 2022 11:54:15 +0530 Message-ID: Subject: Re: [1/2] PR96463 - aarch64 specific changes To: Prathamesh Kulkarni , gcc Patches , richard.sandiford@arm.com Content-Type: multipart/mixed; boundary="0000000000008e64f405deb67f2d" X-Spam-Status: No, score=-9.3 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 11 May 2022 06:24:54 -0000 --0000000000008e64f405deb67f2d Content-Type: text/plain; charset="UTF-8" On Fri, 6 May 2022 at 16:00, Richard Sandiford wrote: > > Prathamesh Kulkarni writes: > > diff --git a/gcc/config/aarch64/aarch64-sve-builtins-base.cc b/gcc/config/aarch64/aarch64-sve-builtins-base.cc > > index c24c0548724..1ef4ea2087b 100644 > > --- a/gcc/config/aarch64/aarch64-sve-builtins-base.cc > > +++ b/gcc/config/aarch64/aarch64-sve-builtins-base.cc > > @@ -44,6 +44,14 @@ > > #include "aarch64-sve-builtins-shapes.h" > > #include "aarch64-sve-builtins-base.h" > > #include "aarch64-sve-builtins-functions.h" > > +#include "aarch64-builtins.h" > > +#include "gimple-ssa.h" > > +#include "tree-phinodes.h" > > +#include "tree-ssa-operands.h" > > +#include "ssa-iterators.h" > > +#include "stringpool.h" > > +#include "value-range.h" > > +#include "tree-ssanames.h" > > Minor, but: I think the preferred approach is to include "ssa.h" > rather than include some of these headers directly. > > > > > using namespace aarch64_sve; > > > > @@ -1207,6 +1215,56 @@ public: > > insn_code icode = code_for_aarch64_sve_ld1rq (e.vector_mode (0)); > > return e.use_contiguous_load_insn (icode); > > } > > + > > + gimple * > > + fold (gimple_folder &f) const OVERRIDE > > + { > > + tree arg0 = gimple_call_arg (f.call, 0); > > + tree arg1 = gimple_call_arg (f.call, 1); > > + > > + /* Transform: > > + lhs = svld1rq ({-1, -1, ... }, arg1) > > + into: > > + tmp = mem_ref [(int * {ref-all}) arg1] > > + lhs = vec_perm_expr. > > + on little endian target. */ > > + > > + if (!BYTES_BIG_ENDIAN > > + && integer_all_onesp (arg0)) > > + { > > + tree lhs = gimple_call_lhs (f.call); > > + auto simd_type = aarch64_get_simd_info_for_type (Int32x4_t); > > Does this work for other element sizes? I would have expected it > to be the (128-bit) Advanced SIMD vector associated with the same > element type as the SVE vector. > > The testcase should cover more than just int32x4_t -> svint32_t, > just to be sure. In the attached patch, it obtains corresponding advsimd type with: tree eltype = TREE_TYPE (lhs_type); unsigned nunits = 128 / TREE_INT_CST_LOW (TYPE_SIZE (eltype)); tree vectype = build_vector_type (eltype, nunits); While this seems to work with different element sizes, I am not sure if it's the correct approach ? > > > + > > + tree elt_ptr_type > > + = build_pointer_type_for_mode (simd_type.eltype, VOIDmode, true); > > + tree zero = build_zero_cst (elt_ptr_type); > > + > > + /* Use element type alignment. */ > > + tree access_type > > + = build_aligned_type (simd_type.itype, TYPE_ALIGN (simd_type.eltype)); > > + > > + tree tmp = make_ssa_name_fn (cfun, access_type, 0); > > + gimple *mem_ref_stmt > > + = gimple_build_assign (tmp, fold_build2 (MEM_REF, access_type, arg1, zero)); > > Long line. Might be easier to format by assigning the fold_build2 result > to a temporary variable. > > > + gsi_insert_before (f.gsi, mem_ref_stmt, GSI_SAME_STMT); > > + > > + tree mem_ref_lhs = gimple_get_lhs (mem_ref_stmt); > > + tree vectype = TREE_TYPE (mem_ref_lhs); > > + tree lhs_type = TREE_TYPE (lhs); > > Is this necessary? The code above supplied the types and I wouldn't > have expected them to change during the build process. > > > + > > + int source_nelts = TYPE_VECTOR_SUBPARTS (vectype).to_constant (); > > + vec_perm_builder sel (TYPE_VECTOR_SUBPARTS (lhs_type), source_nelts, 1); > > + for (int i = 0; i < source_nelts; i++) > > + sel.quick_push (i); > > + > > + vec_perm_indices indices (sel, 1, source_nelts); > > + gcc_checking_assert (can_vec_perm_const_p (TYPE_MODE (lhs_type), indices)); > > + tree mask = vec_perm_indices_to_tree (lhs_type, indices); > > + return gimple_build_assign (lhs, VEC_PERM_EXPR, mem_ref_lhs, mem_ref_lhs, mask); > > Nit: long line. > > > + } > > + > > + return NULL; > > + } > > }; > > > > class svld1ro_impl : public load_replicate > > diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc > > index f650abbc4ce..47810fec804 100644 > > --- a/gcc/config/aarch64/aarch64.cc > > +++ b/gcc/config/aarch64/aarch64.cc > > @@ -23969,6 +23969,35 @@ aarch64_evpc_sve_tbl (struct expand_vec_perm_d *d) > > return true; > > } > > > > +/* Try to implement D using SVE dup instruction. */ > > + > > +static bool > > +aarch64_evpc_sve_dup (struct expand_vec_perm_d *d) > > +{ > > + if (BYTES_BIG_ENDIAN > > + || d->perm.length ().is_constant () > > + || !d->one_vector_p > > + || d->target == NULL > > + || d->op0 == NULL > > These last two lines mean that we always return false for d->testing. > The idea instead is that the return value should be the same for both > d->testing and !d->testing. The difference is that for !d->testing we > also emit code to do the permute. > > > + || GET_MODE_NUNITS (GET_MODE (d->target)).is_constant () > > Sorry, I've forgotten the context now, but: these positive tests > for is_constant surprised me. Do we really only want to do this > for variable-length SVE code generation, rather than fixed-length? > > > + || !GET_MODE_NUNITS (GET_MODE (d->op0)).is_constant ()) > > + return false; > > + > > + if (d->testing_p) > > + return true; > > This should happen after the later tests, once we're sure that the > permute vector has the right form. If the issue is that op0 isn't > provided for testing then I think the hook needs to be passed the > input mode alongside the result mode. > > It might then be better to test: > > aarch64_classify_vector_mode (...input_mode...) == VEC_ADVSIMD > > (despite what I said earlier, about testing is_constant, sorry). Thanks for the suggestions, I tried to address them in the attached patch. Does it look OK after bootstrap+test ? The patch seems to generate the same code for different vector types. For eg: svint32_t foo (int32x4_t x) { return svld1rq (svptrue_b8 (), &x[0]); } svint16_t foo2(int16x8_t x) { return svld1rq_s16 (svptrue_b8 (), &x[0]); } .optimized dump: ;; Function foo (foo, funcdef_no=4350, decl_uid=29928, cgraph_uid=4351, symbol_order=4350) svint32_t foo (int32x4_t x) { svint32_t _2; [local count: 1073741824]: _2 = VEC_PERM_EXPR ; return _2; } ;; Function foo2 (foo2, funcdef_no=4351, decl_uid=29931, cgraph_uid=4352, symbol_order=4351) svint16_t foo2 (int16x8_t x) { svint16_t _2; [local count: 1073741824]: _2 = VEC_PERM_EXPR ; return _2; } resulting in code-gen: foo: dup z0.q, z0.q[0] ret foo2: dup z0.q, z0.q[0] ret I suppose this is correct, since in both cases it's replicating the entire 128-bit vector (irrespective of element sizes) ? Thanks, Prathamesh > > > + > > + int npatterns = d->perm.encoding ().npatterns (); > > + if (!known_eq (npatterns, GET_MODE_NUNITS (GET_MODE (d->op0)))) > > + return false; > > + > > + for (int i = 0; i < npatterns; i++) > > + if (!known_eq (d->perm[i], i)) > > + return false; > > + > > + aarch64_expand_sve_dupq (d->target, GET_MODE (d->target), d->op0); > > + return true; > > +} > > + > > /* Try to implement D using SVE SEL instruction. */ > > > > static bool > > @@ -24129,7 +24158,12 @@ aarch64_expand_vec_perm_const_1 (struct expand_vec_perm_d *d) > > else if (aarch64_evpc_reencode (d)) > > return true; > > if (d->vec_flags == VEC_SVE_DATA) > > - return aarch64_evpc_sve_tbl (d); > > + { > > + if (aarch64_evpc_sve_dup (d)) > > + return true; > > + else if (aarch64_evpc_sve_tbl (d)) > > + return true; > > + } > > else if (d->vec_flags == VEC_ADVSIMD) > > return aarch64_evpc_tbl (d); > > } > > diff --git a/gcc/testsuite/gcc.target/aarch64/sve/acle/general/pr96463.c b/gcc/testsuite/gcc.target/aarch64/sve/acle/general/pr96463.c > > new file mode 100644 > > index 00000000000..35100a9e01c > > --- /dev/null > > +++ b/gcc/testsuite/gcc.target/aarch64/sve/acle/general/pr96463.c > > @@ -0,0 +1,17 @@ > > +/* { dg-do compile } */ > > +/* { dg-options "-O3" } */ > > + > > +#include "arm_neon.h" > > +#include "arm_sve.h" > > + > > +svint32_t f1 (int32x4_t x) > > +{ > > + return svld1rq (svptrue_b8 (), &x[0]); > > +} > > + > > +svint32_t f2 (int *x) > > +{ > > + return svld1rq (svptrue_b8 (), x); > > +} > > + > > +/* { dg-final { scan-assembler-times {\tdup\tz[0-9]+\.q, z[0-9]+\.q\[0\]} 2 { target aarch64_little_endian } } } */ --0000000000008e64f405deb67f2d Content-Type: text/plain; charset="US-ASCII"; name="pr96463-8.txt" Content-Disposition: attachment; filename="pr96463-8.txt" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_l3170hef0 ZGlmZiAtLWdpdCBhL2djYy9jb25maWcvYWFyY2g2NC9hYXJjaDY0LXN2ZS1idWlsdGlucy1iYXNl LmNjIGIvZ2NjL2NvbmZpZy9hYXJjaDY0L2FhcmNoNjQtc3ZlLWJ1aWx0aW5zLWJhc2UuY2MKaW5k ZXggYzI0YzA1NDg3MjQuLjhhMmU1Yjg4NmU0IDEwMDY0NAotLS0gYS9nY2MvY29uZmlnL2FhcmNo NjQvYWFyY2g2NC1zdmUtYnVpbHRpbnMtYmFzZS5jYworKysgYi9nY2MvY29uZmlnL2FhcmNoNjQv YWFyY2g2NC1zdmUtYnVpbHRpbnMtYmFzZS5jYwpAQCAtNDQsNiArNDQsNyBAQAogI2luY2x1ZGUg ImFhcmNoNjQtc3ZlLWJ1aWx0aW5zLXNoYXBlcy5oIgogI2luY2x1ZGUgImFhcmNoNjQtc3ZlLWJ1 aWx0aW5zLWJhc2UuaCIKICNpbmNsdWRlICJhYXJjaDY0LXN2ZS1idWlsdGlucy1mdW5jdGlvbnMu aCIKKyNpbmNsdWRlICJzc2EuaCIKIAogdXNpbmcgbmFtZXNwYWNlIGFhcmNoNjRfc3ZlOwogCkBA IC0xMjA3LDYgKzEyMDgsNTkgQEAgcHVibGljOgogICAgIGluc25fY29kZSBpY29kZSA9IGNvZGVf Zm9yX2FhcmNoNjRfc3ZlX2xkMXJxIChlLnZlY3Rvcl9tb2RlICgwKSk7CiAgICAgcmV0dXJuIGUu dXNlX2NvbnRpZ3VvdXNfbG9hZF9pbnNuIChpY29kZSk7CiAgIH0KKworICBnaW1wbGUgKgorICBm b2xkIChnaW1wbGVfZm9sZGVyICZmKSBjb25zdCBPVkVSUklERQorICB7CisgICAgdHJlZSBhcmcw ID0gZ2ltcGxlX2NhbGxfYXJnIChmLmNhbGwsIDApOworICAgIHRyZWUgYXJnMSA9IGdpbXBsZV9j YWxsX2FyZyAoZi5jYWxsLCAxKTsKKworICAgIC8qIFRyYW5zZm9ybToKKyAgICAgICBsaHMgPSBz dmxkMXJxICh7LTEsIC0xLCAuLi4gfSwgYXJnMSkKKyAgICAgICBpbnRvOgorICAgICAgIHRtcCA9 IG1lbV9yZWY8dmVjdHlwZT4gWyhpbnQgKiB7cmVmLWFsbH0pIGFyZzFdCisgICAgICAgbGhzID0g dmVjX3Blcm1fZXhwcjx0bXAsIHRtcCwgezAsIDEsIDIsIDMsIC4uLn0+LgorICAgICAgIG9uIGxp dHRsZSBlbmRpYW4gdGFyZ2V0LgorICAgICAgIHZlY3R5cGUgaXMgdGhlIGNvcnJlc3BvbmRpbmcg QURWU0lNRCB0eXBlLiAgKi8KKworICAgIGlmICghQllURVNfQklHX0VORElBTgorCSYmIGludGVn ZXJfYWxsX29uZXNwIChhcmcwKSkKKyAgICAgIHsKKwl0cmVlIGxocyA9IGdpbXBsZV9jYWxsX2xo cyAoZi5jYWxsKTsKKwl0cmVlIGxoc190eXBlID0gVFJFRV9UWVBFIChsaHMpOworCXRyZWUgZWx0 eXBlID0gVFJFRV9UWVBFIChsaHNfdHlwZSk7CisJdW5zaWduZWQgbnVuaXRzID0gMTI4IC8gVFJF RV9JTlRfQ1NUX0xPVyAoVFlQRV9TSVpFIChlbHR5cGUpKTsKKwl0cmVlIHZlY3R5cGUgPSBidWls ZF92ZWN0b3JfdHlwZSAoZWx0eXBlLCBudW5pdHMpOworCisJdHJlZSBlbHRfcHRyX3R5cGUKKwkg ID0gYnVpbGRfcG9pbnRlcl90eXBlX2Zvcl9tb2RlIChlbHR5cGUsIFZPSURtb2RlLCB0cnVlKTsK Kwl0cmVlIHplcm8gPSBidWlsZF96ZXJvX2NzdCAoZWx0X3B0cl90eXBlKTsKKworCS8qIFVzZSBl bGVtZW50IHR5cGUgYWxpZ25tZW50LiAgKi8KKwl0cmVlIGFjY2Vzc190eXBlCisJICA9IGJ1aWxk X2FsaWduZWRfdHlwZSAodmVjdHlwZSwgVFlQRV9BTElHTiAoZWx0eXBlKSk7CisKKwl0cmVlIG1l bV9yZWZfbGhzID0gbWFrZV9zc2FfbmFtZV9mbiAoY2Z1biwgYWNjZXNzX3R5cGUsIDApOworCXRy ZWUgbWVtX3JlZl9vcCA9IGZvbGRfYnVpbGQyIChNRU1fUkVGLCBhY2Nlc3NfdHlwZSwgYXJnMSwg emVybyk7CisJZ2ltcGxlICptZW1fcmVmX3N0bXQKKwkgID0gZ2ltcGxlX2J1aWxkX2Fzc2lnbiAo bWVtX3JlZl9saHMsIG1lbV9yZWZfb3ApOworCWdzaV9pbnNlcnRfYmVmb3JlIChmLmdzaSwgbWVt X3JlZl9zdG10LCBHU0lfU0FNRV9TVE1UKTsKKworCWludCBzb3VyY2VfbmVsdHMgPSBUWVBFX1ZF Q1RPUl9TVUJQQVJUUyAoYWNjZXNzX3R5cGUpLnRvX2NvbnN0YW50ICgpOworCXZlY19wZXJtX2J1 aWxkZXIgc2VsIChUWVBFX1ZFQ1RPUl9TVUJQQVJUUyAobGhzX3R5cGUpLCBzb3VyY2VfbmVsdHMs IDEpOworCWZvciAoaW50IGkgPSAwOyBpIDwgc291cmNlX25lbHRzOyBpKyspCisJICBzZWwucXVp Y2tfcHVzaCAoaSk7CisKKwl2ZWNfcGVybV9pbmRpY2VzIGluZGljZXMgKHNlbCwgMSwgc291cmNl X25lbHRzKTsKKwlnY2NfY2hlY2tpbmdfYXNzZXJ0IChjYW5fdmVjX3Blcm1fY29uc3RfcCAoVFlQ RV9NT0RFIChsaHNfdHlwZSksCisJCQkJCQkgICBpbmRpY2VzKSk7CisJdHJlZSBtYXNrID0gdmVj X3Blcm1faW5kaWNlc190b190cmVlIChsaHNfdHlwZSwgaW5kaWNlcyk7CisJcmV0dXJuIGdpbXBs ZV9idWlsZF9hc3NpZ24gKGxocywgVkVDX1BFUk1fRVhQUiwKKwkJCQkgICAgbWVtX3JlZl9saHMs IG1lbV9yZWZfbGhzLCBtYXNrKTsKKyAgICAgIH0KKworICAgIHJldHVybiBOVUxMOworICB9CiB9 OwogCiBjbGFzcyBzdmxkMXJvX2ltcGwgOiBwdWJsaWMgbG9hZF9yZXBsaWNhdGUKZGlmZiAtLWdp dCBhL2djYy9jb25maWcvYWFyY2g2NC9hYXJjaDY0LmNjIGIvZ2NjL2NvbmZpZy9hYXJjaDY0L2Fh cmNoNjQuY2MKaW5kZXggZjY1MGFiYmM0Y2UuLjA3MmVjOWJkMTUzIDEwMDY0NAotLS0gYS9nY2Mv Y29uZmlnL2FhcmNoNjQvYWFyY2g2NC5jYworKysgYi9nY2MvY29uZmlnL2FhcmNoNjQvYWFyY2g2 NC5jYwpAQCAtMjM5NjksNiArMjM5NjksMzUgQEAgYWFyY2g2NF9ldnBjX3N2ZV90YmwgKHN0cnVj dCBleHBhbmRfdmVjX3Blcm1fZCAqZCkKICAgcmV0dXJuIHRydWU7CiB9CiAKKy8qIFRyeSB0byBp bXBsZW1lbnQgRCB1c2luZyBTVkUgZHVwIGluc3RydWN0aW9uLiAgKi8KKworc3RhdGljIGJvb2wK K2FhcmNoNjRfZXZwY19zdmVfZHVwIChzdHJ1Y3QgZXhwYW5kX3ZlY19wZXJtX2QgKmQpCit7Cisg IGlmIChCWVRFU19CSUdfRU5ESUFOCisgICAgICB8fCBkLT5wZXJtLmxlbmd0aCAoKS5pc19jb25z dGFudCAoKQorICAgICAgfHwgIWQtPm9uZV92ZWN0b3JfcAorICAgICAgfHwgZC0+dGFyZ2V0ID09 IE5VTEwKKyAgICAgIHx8IGQtPm9wMCA9PSBOVUxMCisgICAgICB8fCAoYWFyY2g2NF9jbGFzc2lm eV92ZWN0b3JfbW9kZSAoR0VUX01PREUgKGQtPnRhcmdldCkpICYgVkVDX0FOWV9TVkUpID09IDAK KyAgICAgIHx8IChhYXJjaDY0X2NsYXNzaWZ5X3ZlY3Rvcl9tb2RlIChHRVRfTU9ERSAoZC0+b3Aw KSkgJiBWRUNfQURWU0lNRCkgPT0gMCkKKyAgICByZXR1cm4gZmFsc2U7CisKKyAgaW50IG5wYXR0 ZXJucyA9IGQtPnBlcm0uZW5jb2RpbmcgKCkubnBhdHRlcm5zICgpOworICBpZiAoIWtub3duX2Vx IChucGF0dGVybnMsIEdFVF9NT0RFX05VTklUUyAoR0VUX01PREUgKGQtPm9wMCkpKSkKKyAgICBy ZXR1cm4gZmFsc2U7CisKKyAgZm9yIChpbnQgaSA9IDA7IGkgPCBucGF0dGVybnM7IGkrKykKKyAg ICBpZiAoIWtub3duX2VxIChkLT5wZXJtW2ldLCBpKSkKKyAgICAgIHJldHVybiBmYWxzZTsKKwor ICBpZiAoZC0+dGVzdGluZ19wKQorICAgIHJldHVybiB0cnVlOworCisgIGFhcmNoNjRfZXhwYW5k X3N2ZV9kdXBxIChkLT50YXJnZXQsIEdFVF9NT0RFIChkLT50YXJnZXQpLCBkLT5vcDApOworICBy ZXR1cm4gdHJ1ZTsKK30KKwogLyogVHJ5IHRvIGltcGxlbWVudCBEIHVzaW5nIFNWRSBTRUwgaW5z dHJ1Y3Rpb24uICAqLwogCiBzdGF0aWMgYm9vbApAQCAtMjQxMjksNyArMjQxNTgsMTIgQEAgYWFy Y2g2NF9leHBhbmRfdmVjX3Blcm1fY29uc3RfMSAoc3RydWN0IGV4cGFuZF92ZWNfcGVybV9kICpk KQogICAgICAgZWxzZSBpZiAoYWFyY2g2NF9ldnBjX3JlZW5jb2RlIChkKSkKIAlyZXR1cm4gdHJ1 ZTsKICAgICAgIGlmIChkLT52ZWNfZmxhZ3MgPT0gVkVDX1NWRV9EQVRBKQotCXJldHVybiBhYXJj aDY0X2V2cGNfc3ZlX3RibCAoZCk7CisJeworCSAgaWYgKGFhcmNoNjRfZXZwY19zdmVfZHVwIChk KSkKKwkgICAgcmV0dXJuIHRydWU7CisJICBlbHNlIGlmIChhYXJjaDY0X2V2cGNfc3ZlX3RibCAo ZCkpCisJICAgIHJldHVybiB0cnVlOworCX0KICAgICAgIGVsc2UgaWYgKGQtPnZlY19mbGFncyA9 PSBWRUNfQURWU0lNRCkKIAlyZXR1cm4gYWFyY2g2NF9ldnBjX3RibCAoZCk7CiAgICAgfQpkaWZm IC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FhcmNoNjQvc3ZlL2FjbGUvZ2VuZXJh bC9wcjk2NDYzLTEuYyBiL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdldC9hYXJjaDY0L3N2ZS9hY2xl L2dlbmVyYWwvcHI5NjQ2My0xLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAuLjVhZjNiNmVkMjRjCi0tLSAvZGV2L251bGwKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFy Z2V0L2FhcmNoNjQvc3ZlL2FjbGUvZ2VuZXJhbC9wcjk2NDYzLTEuYwpAQCAtMCwwICsxLDIzIEBA CisvKiB7IGRnLWRvIGNvbXBpbGUgfSAqLworLyogeyBkZy1vcHRpb25zICItTzMiIH0gKi8KKwor I2luY2x1ZGUgImFybV9uZW9uLmgiCisjaW5jbHVkZSAiYXJtX3N2ZS5oIgorCisjZGVmaW5lIFRF U1QocmV0X3R5cGUsIHBhcmFtX3R5cGUsIHN1ZmZpeCkgXAorcmV0X3R5cGUgdGVzdF8jI3N1ZmZp eChwYXJhbV90eXBlIHgpIFwKK3sgXAorICByZXR1cm4gc3ZsZDFycV8jI3N1ZmZpeCAoc3ZwdHJ1 ZV9iOCAoKSwgJnhbMF0pOyBcCit9CisKK1RFU1Qoc3ZpbnQ4X3QsIGludDh4MTZfdCwgczgpCitU RVNUKHN2aW50MTZfdCwgaW50MTZ4OF90LCBzMTYpCitURVNUKHN2aW50MzJfdCwgaW50MzJ4NF90 LCBzMzIpCitURVNUKHN2aW50NjRfdCwgaW50NjR4Ml90LCBzNjQpCisKK1RFU1Qoc3Z1aW50OF90 LCB1aW50OHgxNl90LCB1OCkKK1RFU1Qoc3Z1aW50MTZfdCwgdWludDE2eDhfdCwgdTE2KQorVEVT VChzdnVpbnQzMl90LCB1aW50MzJ4NF90LCB1MzIpCitURVNUKHN2dWludDY0X3QsIHVpbnQ2NHgy X3QsIHU2NCkKKworLyogeyBkZy1maW5hbCB7IHNjYW4tYXNzZW1ibGVyLXRpbWVzIHtcdGR1cFx0 elswLTldK1wucSwgelswLTldK1wucVxbMFxdfSA4IHsgdGFyZ2V0IGFhcmNoNjRfbGl0dGxlX2Vu ZGlhbiB9IH0gfSAqLwpkaWZmIC0tZ2l0IGEvZ2NjL3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FhcmNo NjQvc3ZlL2FjbGUvZ2VuZXJhbC9wcjk2NDYzLTIuYyBiL2djYy90ZXN0c3VpdGUvZ2NjLnRhcmdl dC9hYXJjaDY0L3N2ZS9hY2xlL2dlbmVyYWwvcHI5NjQ2My0yLmMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAuLjE3ZTc4YzU3YzFiCi0tLSAvZGV2L251bGwKKysrIGIvZ2Nj L3Rlc3RzdWl0ZS9nY2MudGFyZ2V0L2FhcmNoNjQvc3ZlL2FjbGUvZ2VuZXJhbC9wcjk2NDYzLTIu YwpAQCAtMCwwICsxLDIzIEBACisvKiB7IGRnLWRvIGNvbXBpbGUgfSAqLworLyogeyBkZy1vcHRp b25zICItTzMiIH0gKi8KKworI2luY2x1ZGUgImFybV9uZW9uLmgiCisjaW5jbHVkZSAiYXJtX3N2 ZS5oIgorCisjZGVmaW5lIFRFU1QocmV0X3R5cGUsIHBhcmFtX3R5cGUsIHN1ZmZpeCkgXAorcmV0 X3R5cGUgdGVzdF8jI3N1ZmZpeChwYXJhbV90eXBlICp4KSBcCit7IFwKKyAgcmV0dXJuIHN2bGQx cnFfIyNzdWZmaXggKHN2cHRydWVfYjggKCksICZ4WzBdKTsgXAorfQorCitURVNUKHN2aW50OF90 LCBpbnQ4X3QsIHM4KQorVEVTVChzdmludDE2X3QsIGludDE2X3QsIHMxNikKK1RFU1Qoc3ZpbnQz Ml90LCBpbnQzMl90LCBzMzIpCitURVNUKHN2aW50NjRfdCwgaW50NjRfdCwgczY0KQorCitURVNU KHN2dWludDhfdCwgdWludDhfdCwgdTgpCitURVNUKHN2dWludDE2X3QsIHVpbnQxNl90LCB1MTYp CitURVNUKHN2dWludDMyX3QsIHVpbnQzMl90LCB1MzIpCitURVNUKHN2dWludDY0X3QsIHVpbnQ2 NF90LCB1NjQpCisKKy8qIHsgZGctZmluYWwgeyBzY2FuLWFzc2VtYmxlci10aW1lcyB7XHRkdXBc dHpbMC05XStcLnEsIHpbMC05XStcLnFcWzBcXX0gOCB7IHRhcmdldCBhYXJjaDY0X2xpdHRsZV9l bmRpYW4gfSB9IH0gKi8K --0000000000008e64f405deb67f2d--