From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wr1-x42c.google.com (mail-wr1-x42c.google.com [IPv6:2a00:1450:4864:20::42c]) by sourceware.org (Postfix) with ESMTPS id B935D3858D35; Thu, 17 Aug 2023 15:26:39 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org B935D3858D35 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-wr1-x42c.google.com with SMTP id ffacd0b85a97d-307d20548adso7054f8f.0; Thu, 17 Aug 2023 08:26:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1692285998; x=1692890798; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=ytduvEbLXb+lYFY+Mc3+RicFE4Dod/dmQh7+6fI8d3c=; b=l7wAC6XRcFEiJlf93kxfbIL620QjP/CKA3vfy8K33k2v0PMZ4i+pOSUdA43tdGyLEC UnyqapEWaCGafQlzKRkaTAxwNchM56aBwRxmkHts1yQRe5c1/MU9VwT5uHC3UrFboSHX 9FrTvxz2mQRUTPP1MCorh88fnuur1MEYb9FMfdvabwkr75p2u5C40hXj3uYbFxcb2mT8 Smy++m198eYDYO9AsisZzOiK7fcYWgczlIONEPK7v0ibIQ9upoeI+72zKeegio6Ilksf OQQo309Gp2k8xUHrU94IjnOrKjn/z/D/6fsfTWf/4kv1ApHQgFZ98jsKdBwE+z5imTrS QMLg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1692285998; x=1692890798; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=ytduvEbLXb+lYFY+Mc3+RicFE4Dod/dmQh7+6fI8d3c=; b=QeLGx9z3EwbH3CLQf22IoMpngaNZhCiLEVwLClGe+gPQAmWkYf8ATXC7rhrdLjqZZ2 tqfOzblOi1EpK0Z1cYuKwji2KefZD5X2qtk5RCs5Iiyyx3WrgQfoNZDjTz1+oFWVZO6u y7w1Lp3O2Y0eNm6PCRSIINjsf7z5FUZZC0ivo6usDimJbSjHdstkNpOReh2AUREE/onB rdrirrHM+IEK14UlDRlEMnwgAFHkHsN5hPUvHrCMWoGeggUsJoV7FkTF1LZXJpt4rLK9 GPD/q73KaLpHSsKZ0hNRhHxaDSPpaP+BCKtYJmqSUFJNTC3vWP0prpF15i9SrlvZMzNE PokA== X-Gm-Message-State: AOJu0YyEfU4T8Imib8moIF6hWNtBF4oQy6ZKpBOSnlFRJPcaxBcJIkv+ KdemszQuQ33BkcNsvkozmxWBsIPWV77doiQhkaewyUo3RtY7jQ== X-Google-Smtp-Source: AGHT+IH/QieqBUo4zvDyZJeCRBdzNOsXpZr9fYWFzdHFEvgxoVKXuu1K6lbp3QJG/5b+GCKCiAEIb7X8fIc+TNNCLPg= X-Received: by 2002:a5d:40d1:0:b0:317:5b76:826 with SMTP id b17-20020a5d40d1000000b003175b760826mr4673327wrq.0.1692285998131; Thu, 17 Aug 2023 08:26:38 -0700 (PDT) MIME-Version: 1.0 References: <059ffebd230df2dbbac3f138ec85016bb7a7306a.camel@redhat.com> In-Reply-To: From: Guillaume Gomez Date: Thu, 17 Aug 2023 17:26:26 +0200 Message-ID: Subject: Re: [PATCH] libgccjit: Add support for `restrict` attribute on function parameters To: David Malcolm Cc: gcc-patches@gcc.gnu.org, jit@gcc.gnu.org Content-Type: multipart/mixed; boundary="000000000000c7075a06032009d0" X-Spam-Status: No, score=-8.7 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM,GIT_PATCH_0,RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: --000000000000c7075a06032009d0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Antoni spot a typo I made: I added `LIBGCCJIT_HAVE_gcc_jit_type_get_size` instead of `LIBGCCJIT_HAVE_gcc_jit_type_get_restrict`. Fixed in this patch, sorry for the noise. Le jeu. 17 ao=C3=BBt 2023 =C3=A0 11:30, Guillaume Gomez a =C3=A9crit : > > Hi Dave, > > > What kind of testing has the patch had? (e.g. did you run "make check- > > jit" ? Has this been in use on real Rust code?) > > I tested it as Rust backend directly on this code: > > ``` > pub fn foo(a: &mut i32, b: &mut i32, c: &i32) { > *a +=3D *c; > *b +=3D *c; > } > ``` > > I ran it with `rustc` (and the GCC backend) with the following flags: > `-C link-args=3D-lc --emit=3Dasm -O --crate-type=3Dlib` which gave the di= ff > you can see in the attached file. Explanations: the diff on the right > has the `__restrict__` attribute used whereas on the left it is the > current version where we don't handle it. > > As for C testing, I used this code: > > ``` > void t(int *__restrict__ a, int *__restrict__ b, char *__restrict__ c) { > *a +=3D *c; > *b +=3D *c; > } > ``` > > (without the `__restrict__` of course when I need to have a witness > ASM). I attached the diff as well, this time the file with the use of > `__restrict__` in on the left. I compiled with the following flags: > `-S -O3`. > > > Please add a feature macro: > > #define LIBGCCJIT_HAVE_gcc_jit_type_get_restrict > > (see the similar ones in the header). > > I added `LIBGCCJIT_HAVE_gcc_jit_type_get_size` and extended the > documentation as well to mention the ABI change. > > > Please add a new ABI tag (LIBGCCJIT_ABI_25 ?), rather than adding this > > to ABI_0. > > I added `LIBGCCJIT_ABI_34` as `LIBGCCJIT_ABI_33` was the last one. > > > This refers to a "cold attribute"; is this a vestige of a copy-and- > > paste from a different test case? > > It is a vestige indeed... Missed this one. > > > I see that the test scans the generated assembler. Does the test > > actually verify that restrict has an effect, or was that another > > vestige from a different test case? > > No, this time it's what I wanted. Please see the C diff I provided > above to see that the ASM has a small diff that allowed me to confirm > that the `__restrict__` attribute was correctly set. > > > If this test is meant to run at -O3 and thus can't be part of test- > > combination.c, please add a comment about it to > > gcc/testsuite/jit.dg/all-non-failing-tests.h (in the alphabetical > > place). > > Below `-O3`, this ASM difference doesn't appear unfortunately. > > > The patch also needs to add documentation for the new entrypoint (in > > topics/types.rst), and for the new ABI tag (in > > topics/compatibility.rst). > > Added! > > > Thanks again for the patch; hope the above is constructive > > It was incredibly useful! Thanks for taking time to writing down the > explanations. > > The new patch is attached to this email. > > Cordially. > > Le jeu. 17 ao=C3=BBt 2023 =C3=A0 01:06, David Malcolm a =C3=A9crit : > > > > On Wed, 2023-08-16 at 22:06 +0200, Guillaume Gomez via Jit wrote: > > > My apologies, forgot to run the commit checkers. Here's the commit > > > with the errors fixed. > > > > > > Le mer. 16 ao=C3=BBt 2023 =C3=A0 18:32, Guillaume Gomez > > > a =C3=A9crit : > > > > > > > > Hi, > > > > Hi Guillaume, thanks for the patch. > > > > > > > > > > This patch adds the possibility to specify the __restrict__ > > > > attribute > > > > for function parameters. It is used by the Rust GCC backend. > > > > What kind of testing has the patch had? (e.g. did you run "make check- > > jit" ? Has this been in use on real Rust code?) > > > > Overall, this patch looks close to being ready, but some nits below... > > > > [...] > > > > > diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h > > > index 60eaf39bff6..2e0d08a06d8 100644 > > > --- a/gcc/jit/libgccjit.h > > > +++ b/gcc/jit/libgccjit.h > > > @@ -635,6 +635,10 @@ gcc_jit_type_get_const (gcc_jit_type *type); > > > extern gcc_jit_type * > > > gcc_jit_type_get_volatile (gcc_jit_type *type); > > > > > > +/* Given type "T", get type "restrict T". */ > > > +extern gcc_jit_type * > > > +gcc_jit_type_get_restrict (gcc_jit_type *type); > > > + > > > #define LIBGCCJIT_HAVE_SIZED_INTEGERS > > > > > > /* Given types LTYPE and RTYPE, return non-zero if they are > > compatible. > > > > Please add a feature macro: > > #define LIBGCCJIT_HAVE_gcc_jit_type_get_restrict > > (see the similar ones in the header). > > > > > diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map > > > index e52de0057a5..b7289b13845 100644 > > > --- a/gcc/jit/libgccjit.map > > > +++ b/gcc/jit/libgccjit.map > > > @@ -104,6 +104,7 @@ LIBGCCJIT_ABI_0 > > > gcc_jit_type_as_object; > > > gcc_jit_type_get_const; > > > gcc_jit_type_get_pointer; > > > + gcc_jit_type_get_restrict; > > > gcc_jit_type_get_volatile; > > > > Please add a new ABI tag (LIBGCCJIT_ABI_25 ?), rather than adding this > > to ABI_0. > > > > > diff --git a/gcc/testsuite/jit.dg/test-restrict.c > > b/gcc/testsuite/jit.dg/test-restrict.c > > > new file mode 100644 > > > index 00000000000..4c8c4407f91 > > > --- /dev/null > > > +++ b/gcc/testsuite/jit.dg/test-restrict.c > > > @@ -0,0 +1,77 @@ > > > +/* { dg-do compile { target x86_64-*-* } } */ > > > + > > > +#include > > > +#include > > > + > > > +#include "libgccjit.h" > > > + > > > +/* We don't want set_options() in harness.h to set -O3 to see that > > the cold > > > + attribute affects the optimizations. */ > > > > This refers to a "cold attribute"; is this a vestige of a copy-and- > > paste from a different test case? > > > > I see that the test scans the generated assembler. Does the test > > actually verify that restrict has an effect, or was that another > > vestige from a different test case? > > > > > +#define TEST_ESCHEWS_SET_OPTIONS > > > +static void set_options (gcc_jit_context *ctxt, const char *argv0) > > > +{ > > > + // Set "-O3". > > > + gcc_jit_context_set_int_option(ctxt, > > GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL, 3); > > > +} > > > + > > > +#define TEST_COMPILING_TO_FILE > > > +#define OUTPUT_KIND GCC_JIT_OUTPUT_KIND_ASSEMBLER > > > +#define OUTPUT_FILENAME "output-of-test-restrict.c.s" > > > +#include "harness.h" > > > + > > > +void > > > +create_code (gcc_jit_context *ctxt, void *user_data) > > > +{ > > > + /* Let's try to inject the equivalent of: > > > +void t(int *__restrict__ a, int *__restrict__ b, char *__restrict__ > > c) { > > > + *a +=3D *c; > > > + *b +=3D *c; > > > +} > > > + */ > > > + gcc_jit_type *int_type =3D > > > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); > > > + gcc_jit_type *pint_type =3D gcc_jit_type_get_pointer(int_type); > > > + gcc_jit_type *pint_restrict_type =3D > > gcc_jit_type_get_restrict(pint_type); > > > + > > > + gcc_jit_type *void_type =3D > > > + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID); > > > + > > > + gcc_jit_param *a =3D > > > + gcc_jit_context_new_param (ctxt, NULL, > > pint_restrict_type, "a"); > > > + gcc_jit_param *b =3D > > > + gcc_jit_context_new_param (ctxt, NULL, > > pint_restrict_type, "b"); > > > + gcc_jit_param *c =3D > > > + gcc_jit_context_new_param (ctxt, NULL, > > pint_restrict_type, "c"); > > > + gcc_jit_param *params[3] =3D {a, b, c}; > > > + > > > + gcc_jit_function *func_t =3D > > > + gcc_jit_context_new_function (ctxt, NULL, > > > + GCC_JIT_FUNCTION_EXPORTED, > > > + void_type, > > > + "t", > > > + 3, params, > > > + 0); > > > + > > > + gcc_jit_block *block =3D gcc_jit_function_new_block (func_t, > > NULL); > > > + > > > + /* *a +=3D *c; */ > > > + gcc_jit_block_add_assignment_op ( > > > + block, NULL, > > > + gcc_jit_rvalue_dereference (gcc_jit_param_as_rvalue > > (a), NULL), > > > + GCC_JIT_BINARY_OP_PLUS, > > > + gcc_jit_lvalue_as_rvalue ( > > > + gcc_jit_rvalue_dereference > > (gcc_jit_param_as_rvalue (c), NULL))); > > > + /* *b +=3D *c; */ > > > + gcc_jit_block_add_assignment_op ( > > > + block, NULL, > > > + gcc_jit_rvalue_dereference (gcc_jit_param_as_rvalue > > (b), NULL), > > > + GCC_JIT_BINARY_OP_PLUS, > > > + gcc_jit_lvalue_as_rvalue ( > > > + gcc_jit_rvalue_dereference > > (gcc_jit_param_as_rvalue (c), NULL))); > > > + > > > + gcc_jit_block_end_with_void_return (block, NULL); > > > +} > > > + > > > +/* { dg-final { jit-verify-output-file-was-created "" } } */ > > > +/* { dg-final { jit-verify-assembler-output "addl %eax, (%rdi) > > > + addl %eax, (%rsi)" } } */ > > > -- > > > 2.34.1 > > > > > > > If this test is meant to run at -O3 and thus can't be part of test- > > combination.c, please add a comment about it to > > gcc/testsuite/jit.dg/all-non-failing-tests.h (in the alphabetical > > place). > > > > The patch also needs to add documentation for the new entrypoint (in > > topics/types.rst), and for the new ABI tag (in > > topics/compatibility.rst). > > > > > > Thanks again for the patch; hope the above is constructive > > Dave > > --000000000000c7075a06032009d0 Content-Type: text/x-patch; charset="US-ASCII"; name="0001-PATCH-Add-support-for-restrict-attribute-on-function.patch" Content-Disposition: attachment; filename="0001-PATCH-Add-support-for-restrict-attribute-on-function.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_llfbdom80 RnJvbSA4YTI3MjEwZjdiNjM3ZGFhNzY0ZjY0MjFjYzY2MDEzYTJjZjM3MjMzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdWlsbGF1bWUgR29tZXogPGd1aWxsYXVtZTEuZ29tZXpAZ21h aWwuY29tPgpEYXRlOiBGcmksIDExIEF1ZyAyMDIzIDIyOjQ4OjExICswMjAwClN1YmplY3Q6IFtQ QVRDSF0gW1BBVENIXSBBZGQgc3VwcG9ydCBmb3IgYHJlc3RyaWN0YCBhdHRyaWJ1dGUgb24gZnVu Y3Rpb24KIHBhcmFtZXRlcnMKCmdjYy9qaXQvQ2hhbmdlbG9nOgoJKiBqaXQtcGxheWJhY2suY2M6 IFJlbW92ZSB0cmFpbGluZyB3aGl0ZXNwYWNlIGNoYXJhY3RlcnMuCgkqIGppdC1wbGF5YmFjay5o OiBBZGQgZ2V0X3Jlc3RyaWN0IG1ldGhvZC4KCSogaml0LXJlY29yZGluZy5jYzogQWRkIGdldF9y ZXN0cmljdCBtZXRob2RzLgoJKiBqaXQtcmVjb3JkaW5nLmg6IEFkZCBnZXRfcmVzdHJpY3QgbWV0 aG9kcy4KCSogbGliZ2Njaml0KysuaDogQWRkIGdldF9yZXN0cmljdCBtZXRob2RzLgoJKiBsaWJn Y2NqaXQuY2M6IEFkZCBnY2Nfaml0X3R5cGVfZ2V0X3Jlc3RyaWN0LgoJKiBsaWJnY2NqaXQuaDog RGVjbGFyZSBnY2Nfaml0X3R5cGVfZ2V0X3Jlc3RyaWN0LgoJKiBsaWJnY2NqaXQubWFwOiBEZWNs YXJlIGdjY19qaXRfdHlwZV9nZXRfcmVzdHJpY3QuCgpnY2MvdGVzdHN1aXRlL0NoYW5nZUxvZzoK CSogaml0LmRnL3Rlc3QtcmVzdHJpY3QuYzogQWRkIHRlc3QgZm9yIF9fcmVzdHJpY3RfXyBhdHRy aWJ1dGUuCgkqIGppdC5kZy9hbGwtbm9uLWZhaWxpbmctdGVzdHMuaDogQWRkIHRlc3QtcmVzdHJp Y3QuYyB0byB0aGUgbGlzdC4KCmdjYy9qaXQvQ2hhbmdlTG9nOgoJKiBkb2NzL3RvcGljcy9jb21w YXRpYmlsaXR5LnJzdDogQWRkIGRvY3VtZW50YXRpb24gZm9yIExJQkdDQ0pJVF9BQklfMzQuCgkq IGRvY3MvdG9waWNzL3R5cGVzLnJzdDogQWRkIGRvY3VtZW50YXRpb24gZm9yIGdjY19qaXRfdHlw ZV9nZXRfcmVzdHJpY3QuCgpTaWduZWQtb2ZmLWJ5OiBHdWlsbGF1bWUgR29tZXogPGd1aWxsYXVt ZTEuZ29tZXpAZ21haWwuY29tPgotLS0KIGdjYy9qaXQvZG9jcy90b3BpY3MvY29tcGF0aWJpbGl0 eS5yc3QgICAgICAgIHwgIDcgKysKIGdjYy9qaXQvZG9jcy90b3BpY3MvdHlwZXMucnN0ICAgICAg ICAgICAgICAgIHwgMTIgKysrCiBnY2Mvaml0L2ppdC1wbGF5YmFjay5jYyAgICAgICAgICAgICAg ICAgICAgICB8ICAyICstCiBnY2Mvaml0L2ppdC1wbGF5YmFjay5oICAgICAgICAgICAgICAgICAg ICAgICB8ICA1ICsrCiBnY2Mvaml0L2ppdC1yZWNvcmRpbmcuY2MgICAgICAgICAgICAgICAgICAg ICB8IDQ3ICsrKysrKysrKysrKwogZ2NjL2ppdC9qaXQtcmVjb3JkaW5nLmggICAgICAgICAgICAg ICAgICAgICAgfCAzOSArKysrKysrKystCiBnY2Mvaml0L2xpYmdjY2ppdCsrLmggICAgICAgICAg ICAgICAgICAgICAgICB8ICA2ICsrCiBnY2Mvaml0L2xpYmdjY2ppdC5jYyAgICAgICAgICAgICAg ICAgICAgICAgICB8IDE0ICsrKysKIGdjYy9qaXQvbGliZ2Njaml0LmggICAgICAgICAgICAgICAg ICAgICAgICAgIHwgIDkgKysrCiBnY2Mvaml0L2xpYmdjY2ppdC5tYXAgICAgICAgICAgICAgICAg ICAgICAgICB8ICA1ICsrCiBnY2MvdGVzdHN1aXRlL2ppdC5kZy9hbGwtbm9uLWZhaWxpbmctdGVz dHMuaCB8ICAzICsKIGdjYy90ZXN0c3VpdGUvaml0LmRnL3Rlc3QtcmVzdHJpY3QuYyAgICAgICAg IHwgNzcgKysrKysrKysrKysrKysrKysrKysKIDEyIGZpbGVzIGNoYW5nZWQsIDIyMyBpbnNlcnRp b25zKCspLCAzIGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGdjYy90ZXN0c3VpdGUv aml0LmRnL3Rlc3QtcmVzdHJpY3QuYwoKZGlmZiAtLWdpdCBhL2djYy9qaXQvZG9jcy90b3BpY3Mv Y29tcGF0aWJpbGl0eS5yc3QgYi9nY2Mvaml0L2RvY3MvdG9waWNzL2NvbXBhdGliaWxpdHkucnN0 CmluZGV4IDI3ODQ1ZWE5YTg0Li44NjZjZjAwODEyOCAxMDA2NDQKLS0tIGEvZ2NjL2ppdC9kb2Nz L3RvcGljcy9jb21wYXRpYmlsaXR5LnJzdAorKysgYi9nY2Mvaml0L2RvY3MvdG9waWNzL2NvbXBh dGliaWxpdHkucnN0CkBAIC0zNzEsMyArMzcxLDEwIEBAIGFsaWdubWVudCBvZiBhIHZhcmlhYmxl OgogCiAgICogOmZ1bmM6YGdjY19qaXRfbHZhbHVlX3NldF9hbGlnbm1lbnRgCiAgICogOmZ1bmM6 YGdjY19qaXRfbHZhbHVlX2dldF9hbGlnbm1lbnRgCisKKy4uIF9MSUJHQ0NKSVRfQUJJXzM0Ogor CitgYExJQkdDQ0pJVF9BQklfMzRgYAorLS0tLS0tLS0tLS0tLS0tLS0tLS0KK2BgTElCR0NDSklU X0FCSV8zNGBgIGNvdmVycyB0aGUgYWRkaXRpb24gb2YKKzpmdW5jOmBnY2Nfaml0X3R5cGVfZ2V0 X3Jlc3RyaWN0YApkaWZmIC0tZ2l0IGEvZ2NjL2ppdC9kb2NzL3RvcGljcy90eXBlcy5yc3QgYi9n Y2Mvaml0L2RvY3MvdG9waWNzL3R5cGVzLnJzdAppbmRleCA0NTdiMzYyM2VjOS4uOGE2MmJjNTli YmIgMTAwNjQ0Ci0tLSBhL2djYy9qaXQvZG9jcy90b3BpY3MvdHlwZXMucnN0CisrKyBiL2djYy9q aXQvZG9jcy90b3BpY3MvdHlwZXMucnN0CkBAIC01NDEsMyArNTQxLDE1IEBAIFJlZmxlY3Rpb24g QVBJCiAgICAuLiBjb2RlLWJsb2NrOjogYwogCiAgICAgICAjaWZkZWYgTElCR0NDSklUX0hBVkVf U0laRURfSU5URUdFUlMKKworLi4gZnVuY3Rpb246OiAgZ2NjX2ppdF90eXBlICpcCisgICAgICAg ICAgICAgICBnY2Nfaml0X3R5cGVfZ2V0X3Jlc3RyaWN0IChnY2Nfaml0X3R5cGUgKnR5cGUpCisK KyAgICAgR2l2ZW4gdHlwZSAiVCIsIGdldCB0eXBlICJyZXN0cmljdCBUIi4KKworICAgVGhpcyBl bnRyeXBvaW50IHdhcyBhZGRlZCBpbiA6cmVmOmBMSUJHQ0NKSVRfQUJJXzM0YDsgeW91IGNhbiB0 ZXN0IGZvcgorICAgaXRzIHByZXNlbmNlIHVzaW5nCisKKyAgIC4uIGNvZGUtYmxvY2s6OiBjCisK KyAgICAgICNpZmRlZiBMSUJHQ0NKSVRfSEFWRV9nY2Nfaml0X3R5cGVfZ2V0X3Jlc3RyaWN0CmRp ZmYgLS1naXQgYS9nY2Mvaml0L2ppdC1wbGF5YmFjay5jYyBiL2djYy9qaXQvaml0LXBsYXliYWNr LmNjCmluZGV4IDg4ZTFiMjEyMDMwLi4wZWI0ZTk0ZmRjNCAxMDA2NDQKLS0tIGEvZ2NjL2ppdC9q aXQtcGxheWJhY2suY2MKKysrIGIvZ2NjL2ppdC9qaXQtcGxheWJhY2suY2MKQEAgLTM3OTMsNyAr Mzc5Myw3IEBAIGlmICh0KSBcCiAgIE5BTUVfVFlQRSAoY29tcGxleF9mbG9hdF90eXBlX25vZGUs ICJjb21wbGV4IGZsb2F0Iik7CiAgIE5BTUVfVFlQRSAoY29tcGxleF9kb3VibGVfdHlwZV9ub2Rl LCAiY29tcGxleCBkb3VibGUiKTsKICAgTkFNRV9UWVBFIChjb21wbGV4X2xvbmdfZG91YmxlX3R5 cGVfbm9kZSwgImNvbXBsZXggbG9uZyBkb3VibGUiKTsKLSAgCisKICAgbV9jb25zdF9jaGFyX3B0 ciA9IGJ1aWxkX3BvaW50ZXJfdHlwZSgKICAgICBidWlsZF9xdWFsaWZpZWRfdHlwZSAoY2hhcl90 eXBlX25vZGUsIFRZUEVfUVVBTF9DT05TVCkpOwogCmRpZmYgLS1naXQgYS9nY2Mvaml0L2ppdC1w bGF5YmFjay5oIGIvZ2NjL2ppdC9qaXQtcGxheWJhY2suaAppbmRleCBkMTUzZjQ5NDVkOC4uZmI0 ZjdiOGI2NWIgMTAwNjQ0Ci0tLSBhL2djYy9qaXQvaml0LXBsYXliYWNrLmgKKysrIGIvZ2NjL2pp dC9qaXQtcGxheWJhY2suaApAQCAtNDkwLDYgKzQ5MCwxMSBAQCBwdWJsaWM6CiAgICAgcmV0dXJu IG5ldyB0eXBlIChidWlsZF9xdWFsaWZpZWRfdHlwZSAobV9pbm5lciwgVFlQRV9RVUFMX1ZPTEFU SUxFKSk7CiAgIH0KIAorICB0eXBlICpnZXRfcmVzdHJpY3QgKCkgY29uc3QKKyAgeworICAgIHJl dHVybiBuZXcgdHlwZSAoYnVpbGRfcXVhbGlmaWVkX3R5cGUgKG1faW5uZXIsIFRZUEVfUVVBTF9S RVNUUklDVCkpOworICB9CisKICAgdHlwZSAqZ2V0X2FsaWduZWQgKHNpemVfdCBhbGlnbm1lbnRf aW5fYnl0ZXMpIGNvbnN0OwogICB0eXBlICpnZXRfdmVjdG9yIChzaXplX3QgbnVtX3VuaXRzKSBj b25zdDsKIApkaWZmIC0tZ2l0IGEvZ2NjL2ppdC9qaXQtcmVjb3JkaW5nLmNjIGIvZ2NjL2ppdC9q aXQtcmVjb3JkaW5nLmNjCmluZGV4IGY5NjJjOTc0OGM0Li5mMWFjODA4NDUyMiAxMDA2NDQKLS0t IGEvZ2NjL2ppdC9qaXQtcmVjb3JkaW5nLmNjCisrKyBiL2djYy9qaXQvaml0LXJlY29yZGluZy5j YwpAQCAtMjM4MCw2ICsyMzgwLDE5IEBAIHJlY29yZGluZzo6dHlwZTo6Z2V0X2NvbnN0ICgpCiAg IHJldHVybiByZXN1bHQ7CiB9CiAKKy8qIEdpdmVuIGEgdHlwZSBULCBnZXQgdGhlIHR5cGUgcmVz dHJpY3QgVC4KKworICAgSW1wbGVtZW50cyB0aGUgcG9zdC1lcnJvci1jaGVja2luZyBwYXJ0IG9m CisgICBnY2Nfaml0X3R5cGVfZ2V0X3Jlc3RyaWN0LiAgKi8KKworcmVjb3JkaW5nOjp0eXBlICoK K3JlY29yZGluZzo6dHlwZTo6Z2V0X3Jlc3RyaWN0ICgpCit7CisgIHJlY29yZGluZzo6dHlwZSAq cmVzdWx0ID0gbmV3IG1lbWVudG9fb2ZfZ2V0X3Jlc3RyaWN0ICh0aGlzKTsKKyAgbV9jdHh0LT5y ZWNvcmQgKHJlc3VsdCk7CisgIHJldHVybiByZXN1bHQ7Cit9CisKIC8qIEdpdmVuIGEgdHlwZSBU LCBnZXQgdGhlIHR5cGUgdm9sYXRpbGUgVC4KIAogICAgSW1wbGVtZW50cyB0aGUgcG9zdC1lcnJv ci1jaGVja2luZyBwYXJ0IG9mCkBAIC0zMDkwLDYgKzMxMDMsNDAgQEAgcmVjb3JkaW5nOjptZW1l bnRvX29mX2dldF92b2xhdGlsZTo6d3JpdGVfcmVwcm9kdWNlciAocmVwcm9kdWNlciAmcikKIAkg ICByLmdldF9pZGVudGlmaWVyX2FzX3R5cGUgKG1fb3RoZXJfdHlwZSkpOwogfQogCisvKiBUaGUg aW1wbGVtZW50YXRpb24gb2YgY2xhc3MgZ2NjOjpqaXQ6OnJlY29yZGluZzo6bWVtZW50b19vZl9n ZXRfcmVzdHJpY3QuICAqLworCisvKiBJbXBsZW1lbnRhdGlvbiBvZiBwdXJlIHZpcnR1YWwgaG9v ayByZWNvcmRpbmc6Om1lbWVudG86OnJlcGxheV9pbnRvCisgICBmb3IgcmVjb3JkaW5nOjptZW1l bnRvX29mX2dldF9yZXN0cmljdC4gICovCisKK3ZvaWQKK3JlY29yZGluZzo6bWVtZW50b19vZl9n ZXRfcmVzdHJpY3Q6OnJlcGxheV9pbnRvIChyZXBsYXllciAqKQoreworICBzZXRfcGxheWJhY2tf b2JqIChtX290aGVyX3R5cGUtPnBsYXliYWNrX3R5cGUgKCktPmdldF9yZXN0cmljdCAoKSk7Cit9 CisKKy8qIEltcGxlbWVudGF0aW9uIG9mIHJlY29yZGluZzo6bWVtZW50bzo6bWFrZV9kZWJ1Z19z dHJpbmcgZm9yCisgICByZXN1bHRzIG9mIGdldF9yZXN0cmljdCwgcHJlcGVuZGluZyAicmVzdHJp Y3QgIi4gICovCisKK3JlY29yZGluZzo6c3RyaW5nICoKK3JlY29yZGluZzo6bWVtZW50b19vZl9n ZXRfcmVzdHJpY3Q6Om1ha2VfZGVidWdfc3RyaW5nICgpCit7CisgIHJldHVybiBzdHJpbmc6OmZy b21fcHJpbnRmIChtX2N0eHQsCisJCQkgICAgICAicmVzdHJpY3QgJXMiLCBtX290aGVyX3R5cGUt PmdldF9kZWJ1Z19zdHJpbmcgKCkpOworfQorCisvKiBJbXBsZW1lbnRhdGlvbiBvZiByZWNvcmRp bmc6Om1lbWVudG86OndyaXRlX3JlcHJvZHVjZXIgZm9yIHJlc3RyaWN0CisgICB0eXBlcy4gICov CisKK3ZvaWQKK3JlY29yZGluZzo6bWVtZW50b19vZl9nZXRfcmVzdHJpY3Q6OndyaXRlX3JlcHJv ZHVjZXIgKHJlcHJvZHVjZXIgJnIpCit7CisgIGNvbnN0IGNoYXIgKmlkID0gci5tYWtlX2lkZW50 aWZpZXIgKHRoaXMsICJ0eXBlIik7CisgIHIud3JpdGUgKCIgIGdjY19qaXRfdHlwZSAqJXMgPVxu IgorCSAgICIgICAgZ2NjX2ppdF90eXBlX2dldF9yZXN0cmljdCAoJXMpO1xuIiwKKwkgICBpZCwK KwkgICByLmdldF9pZGVudGlmaWVyX2FzX3R5cGUgKG1fb3RoZXJfdHlwZSkpOworfQorCiAvKiBU aGUgaW1wbGVtZW50YXRpb24gb2YgY2xhc3MgZ2NjOjpqaXQ6OnJlY29yZGluZzo6bWVtZW50b19v Zl9nZXRfYWxpZ25lZC4gICovCiAKIC8qIEltcGxlbWVudGF0aW9uIG9mIHB1cmUgdmlydHVhbCBo b29rIHJlY29yZGluZzo6bWVtZW50bzo6cmVwbGF5X2ludG8KZGlmZiAtLWdpdCBhL2djYy9qaXQv aml0LXJlY29yZGluZy5oIGIvZ2NjL2ppdC9qaXQtcmVjb3JkaW5nLmgKaW5kZXggOTI5YmJlMzdj M2YuLjBmMjBiYmFjZmYyIDEwMDY0NAotLS0gYS9nY2Mvaml0L2ppdC1yZWNvcmRpbmcuaAorKysg Yi9nY2Mvaml0L2ppdC1yZWNvcmRpbmcuaApAQCAtNTU1LDYgKzU1NSw3IEBAIHB1YmxpYzoKICAg dHlwZSAqZ2V0X3BvaW50ZXIgKCk7CiAgIHR5cGUgKmdldF9jb25zdCAoKTsKICAgdHlwZSAqZ2V0 X3ZvbGF0aWxlICgpOworICB0eXBlICpnZXRfcmVzdHJpY3QgKCk7CiAgIHR5cGUgKmdldF9hbGln bmVkIChzaXplX3QgYWxpZ25tZW50X2luX2J5dGVzKTsKICAgdHlwZSAqZ2V0X3ZlY3RvciAoc2l6 ZV90IG51bV91bml0cyk7CiAKQEAgLTYwMyw2ICs2MDQsNyBAQCBwdWJsaWM6CiAgIHZpcnR1YWwg Ym9vbCBpc19ib29sICgpIGNvbnN0ID0gMDsKICAgdmlydHVhbCB0eXBlICppc19wb2ludGVyICgp ID0gMDsKICAgdmlydHVhbCB0eXBlICppc192b2xhdGlsZSAoKSB7IHJldHVybiBOVUxMOyB9Cisg IHZpcnR1YWwgdHlwZSAqaXNfcmVzdHJpY3QgKCkgeyByZXR1cm4gTlVMTDsgfQogICB2aXJ0dWFs IHR5cGUgKmlzX2NvbnN0ICgpIHsgcmV0dXJuIE5VTEw7IH0KICAgdmlydHVhbCB0eXBlICppc19h cnJheSAoKSA9IDA7CiAgIHZpcnR1YWwgc3RydWN0XyAqaXNfc3RydWN0ICgpIHsgcmV0dXJuIE5V TEw7IH0KQEAgLTczNyw3ICs3MzksNyBAQCBwcml2YXRlOgogfTsKIAogLyogQSBkZWNvcmF0ZWQg dmVyc2lvbiBvZiBhIHR5cGUsIGZvciBnZXRfY29uc3QsIGdldF92b2xhdGlsZSwKLSAgIGdldF9h bGlnbmVkLCBhbmQgZ2V0X3ZlY3Rvci4gICovCisgICBnZXRfYWxpZ25lZCwgZ2V0X3Jlc3RyaWN0 LCBhbmQgZ2V0X3ZlY3Rvci4gICovCiAKIGNsYXNzIGRlY29yYXRlZF90eXBlIDogcHVibGljIHR5 cGUKIHsKQEAgLTgxMCw3ICs4MTIsNyBAQCBwdWJsaWM6CiAgICAgcmV0dXJuIG1fb3RoZXJfdHlw ZS0+aXNfc2FtZV90eXBlX2FzIChvdGhlci0+aXNfdm9sYXRpbGUgKCkpOwogICB9CiAKLSAgdHlw ZSogY29weShjb250ZXh0KiBjdHh0KSBmaW5hbCBvdmVycmlkZQorICB0eXBlKiBjb3B5IChjb250 ZXh0KiBjdHh0KSBmaW5hbCBvdmVycmlkZQogICB7CiAgICAgdHlwZSogcmVzdWx0ID0gbmV3IG1l bWVudG9fb2ZfZ2V0X3ZvbGF0aWxlIChtX290aGVyX3R5cGUtPmNvcHkgKGN0eHQpKTsKICAgICBj dHh0LT5yZWNvcmQgKHJlc3VsdCk7CkBAIC04MjksNiArODMxLDM5IEBAIHByaXZhdGU6CiAgIHZv aWQgd3JpdGVfcmVwcm9kdWNlciAocmVwcm9kdWNlciAmcikgZmluYWwgb3ZlcnJpZGU7CiB9Owog CisvKiBSZXN1bHQgb2YgImdjY19qaXRfdHlwZV9nZXRfcmVzdHJpY3QiLiAgKi8KK2NsYXNzIG1l bWVudG9fb2ZfZ2V0X3Jlc3RyaWN0IDogcHVibGljIGRlY29yYXRlZF90eXBlCit7CitwdWJsaWM6 CisgIG1lbWVudG9fb2ZfZ2V0X3Jlc3RyaWN0ICh0eXBlICpvdGhlcl90eXBlKQorICA6IGRlY29y YXRlZF90eXBlIChvdGhlcl90eXBlKSB7fQorCisgIGJvb2wgaXNfc2FtZV90eXBlX2FzICh0eXBl ICpvdGhlcikgZmluYWwgb3ZlcnJpZGUKKyAgeworICAgIGlmICghb3RoZXItPmlzX3Jlc3RyaWN0 ICgpKQorICAgICAgcmV0dXJuIGZhbHNlOworICAgIHJldHVybiBtX290aGVyX3R5cGUtPmlzX3Nh bWVfdHlwZV9hcyAob3RoZXItPmlzX3Jlc3RyaWN0ICgpKTsKKyAgfQorCisgIHR5cGUqIGNvcHkg KGNvbnRleHQqIGN0eHQpIGZpbmFsIG92ZXJyaWRlCisgIHsKKyAgICB0eXBlKiByZXN1bHQgPSBu ZXcgbWVtZW50b19vZl9nZXRfcmVzdHJpY3QgKG1fb3RoZXJfdHlwZS0+Y29weSAoY3R4dCkpOwor ICAgIGN0eHQtPnJlY29yZCAocmVzdWx0KTsKKyAgICByZXR1cm4gcmVzdWx0OworICB9CisKKyAg LyogU3RyaXAgb2ZmIHRoZSAicmVzdHJpY3QiLCBnaXZpbmcgdGhlIHVuZGVybHlpbmcgdHlwZS4g ICovCisgIHR5cGUgKnVucXVhbGlmaWVkICgpIGZpbmFsIG92ZXJyaWRlIHsgcmV0dXJuIG1fb3Ro ZXJfdHlwZTsgfQorCisgIHR5cGUgKmlzX3Jlc3RyaWN0ICgpIGZpbmFsIG92ZXJyaWRlIHsgcmV0 dXJuIG1fb3RoZXJfdHlwZTsgfQorCisgIHZvaWQgcmVwbGF5X2ludG8gKHJlcGxheWVyICopIGZp bmFsIG92ZXJyaWRlOworCitwcml2YXRlOgorICBzdHJpbmcgKiBtYWtlX2RlYnVnX3N0cmluZyAo KSBmaW5hbCBvdmVycmlkZTsKKyAgdm9pZCB3cml0ZV9yZXByb2R1Y2VyIChyZXByb2R1Y2VyICZy KSBmaW5hbCBvdmVycmlkZTsKK307CisKIC8qIFJlc3VsdCBvZiAiZ2NjX2ppdF90eXBlX2dldF9h bGlnbmVkIi4gICovCiBjbGFzcyBtZW1lbnRvX29mX2dldF9hbGlnbmVkIDogcHVibGljIGRlY29y YXRlZF90eXBlCiB7CmRpZmYgLS1naXQgYS9nY2Mvaml0L2xpYmdjY2ppdCsrLmggYi9nY2Mvaml0 L2xpYmdjY2ppdCsrLmgKaW5kZXggNGI4OGU4NzdiYzkuLmI0MzBmN2ViMDQ5IDEwMDY0NAotLS0g YS9nY2Mvaml0L2xpYmdjY2ppdCsrLmgKKysrIGIvZ2NjL2ppdC9saWJnY2NqaXQrKy5oCkBAIC0x NDEwLDYgKzE0MTAsMTIgQEAgdHlwZTo6Z2V0X2NvbnN0ICgpCiAgIHJldHVybiB0eXBlIChnY2Nf aml0X3R5cGVfZ2V0X2NvbnN0IChnZXRfaW5uZXJfdHlwZSAoKSkpOwogfQogCitpbmxpbmUgdHlw ZQordHlwZTo6Z2V0X3Jlc3RyaWN0ICgpCit7CisgIHJldHVybiB0eXBlIChnY2Nfaml0X3R5cGVf Z2V0X3Jlc3RyaWN0IChnZXRfaW5uZXJfdHlwZSAoKSkpOworfQorCiBpbmxpbmUgdHlwZQogdHlw ZTo6Z2V0X3ZvbGF0aWxlICgpCiB7CmRpZmYgLS1naXQgYS9nY2Mvaml0L2xpYmdjY2ppdC5jYyBi L2djYy9qaXQvbGliZ2Njaml0LmNjCmluZGV4IDA1MGU2OGI3MzhjLi45Yjg3ZTA1NjlkNiAxMDA2 NDQKLS0tIGEvZ2NjL2ppdC9saWJnY2NqaXQuY2MKKysrIGIvZ2NjL2ppdC9saWJnY2NqaXQuY2MK QEAgLTUzOSw2ICs1MzksMjAgQEAgZ2NjX2ppdF90eXBlX2dldF92b2xhdGlsZSAoZ2NjX2ppdF90 eXBlICp0eXBlKQogICByZXR1cm4gKGdjY19qaXRfdHlwZSAqKXR5cGUtPmdldF92b2xhdGlsZSAo KTsKIH0KIAorLyogUHVibGljIGVudHJ5cG9pbnQuICBTZWUgZGVzY3JpcHRpb24gaW4gbGliZ2Nj aml0LmguCisKKyAgIEFmdGVyIGVycm9yLWNoZWNraW5nLCB0aGUgcmVhbCB3b3JrIGlzIGRvbmUg YnkgdGhlCisgICBnY2M6OmppdDo6cmVjb3JkaW5nOjp0eXBlOjpnZXRfcmVzdHJpY3QgbWV0aG9k LCBpbgorICAgaml0LXJlY29yZGluZy5jYy4gICovCisKK2djY19qaXRfdHlwZSAqCitnY2Nfaml0 X3R5cGVfZ2V0X3Jlc3RyaWN0IChnY2Nfaml0X3R5cGUgKnR5cGUpCit7CisgIFJFVFVSTl9OVUxM X0lGX0ZBSUwgKHR5cGUsIE5VTEwsIE5VTEwsICJOVUxMIHR5cGUiKTsKKworICByZXR1cm4gKGdj Y19qaXRfdHlwZSAqKXR5cGUtPmdldF9yZXN0cmljdCAoKTsKK30KKwogLyogUHVibGljIGVudHJ5 cG9pbnQuICBTZWUgZGVzY3JpcHRpb24gaW4gbGliZ2Njaml0LmguCiAKICAgIEFmdGVyIGVycm9y LWNoZWNraW5nLCB0aGUgcmVhbCB3b3JrIGlzIGRvbmUgYnkgdGhlCmRpZmYgLS1naXQgYS9nY2Mv aml0L2xpYmdjY2ppdC5oIGIvZ2NjL2ppdC9saWJnY2NqaXQuaAppbmRleCA2MGVhZjM5YmZmNi4u ZTI0MzI1ODlkNzEgMTAwNjQ0Ci0tLSBhL2djYy9qaXQvbGliZ2Njaml0LmgKKysrIGIvZ2NjL2pp dC9saWJnY2NqaXQuaApAQCAtNjM1LDYgKzYzNSwxNSBAQCBnY2Nfaml0X3R5cGVfZ2V0X2NvbnN0 IChnY2Nfaml0X3R5cGUgKnR5cGUpOwogZXh0ZXJuIGdjY19qaXRfdHlwZSAqCiBnY2Nfaml0X3R5 cGVfZ2V0X3ZvbGF0aWxlIChnY2Nfaml0X3R5cGUgKnR5cGUpOwogCisjZGVmaW5lIExJQkdDQ0pJ VF9IQVZFX2djY19qaXRfdHlwZV9nZXRfcmVzdHJpY3QKKworLyogR2l2ZW4gdHlwZSAiVCIsIGdl dCB0eXBlICJyZXN0cmljdCBUIi4KKyAgIFRoaXMgQVBJIGVudHJ5cG9pbnQgd2FzIGFkZGVkIGlu IExJQkdDQ0pJVF9BQklfMzQ7IHlvdSBjYW4gdGVzdCBmb3IgaXRzCisgICBwcmVzZW5jZSB1c2lu ZworICAgICAjaWZkZWYgTElCR0NDSklUX0hBVkVfZ2NjX2ppdF90eXBlX2dldF9yZXN0cmljdCAg Ki8KK2V4dGVybiBnY2Nfaml0X3R5cGUgKgorZ2NjX2ppdF90eXBlX2dldF9yZXN0cmljdCAoZ2Nj X2ppdF90eXBlICp0eXBlKTsKKwogI2RlZmluZSBMSUJHQ0NKSVRfSEFWRV9TSVpFRF9JTlRFR0VS UwogCiAvKiBHaXZlbiB0eXBlcyBMVFlQRSBhbmQgUlRZUEUsIHJldHVybiBub24temVybyBpZiB0 aGV5IGFyZSBjb21wYXRpYmxlLgpkaWZmIC0tZ2l0IGEvZ2NjL2ppdC9saWJnY2NqaXQubWFwIGIv Z2NjL2ppdC9saWJnY2NqaXQubWFwCmluZGV4IGU1MmRlMDA1N2E1Li5jYzYyMjE2NDEyYiAxMDA2 NDQKLS0tIGEvZ2NjL2ppdC9saWJnY2NqaXQubWFwCisrKyBiL2djYy9qaXQvbGliZ2Njaml0Lm1h cApAQCAtMzI2LDMgKzMyNiw4IEBAIExJQkdDQ0pJVF9BQklfMzMgewogICAgIGdjY19qaXRfdGFy Z2V0X2luZm9fYXJjaDsKICAgICBnY2Nfaml0X3RhcmdldF9pbmZvX3N1cHBvcnRzXzEyOGJpdF9p bnQ7CiB9IExJQkdDQ0pJVF9BQklfMzI7CisKK0xJQkdDQ0pJVF9BQklfMzQgeworICBnbG9iYWw6 CisgICAgZ2NjX2ppdF90eXBlX2dldF9yZXN0cmljdDsKK30gTElCR0NDSklUX0FCSV8zMzsKZGlm ZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvaml0LmRnL2FsbC1ub24tZmFpbGluZy10ZXN0cy5oIGIv Z2NjL3Rlc3RzdWl0ZS9qaXQuZGcvYWxsLW5vbi1mYWlsaW5nLXRlc3RzLmgKaW5kZXggOTg4ZTE0 YWU5YmMuLjk4NzVjYmU2MjNjIDEwMDY0NAotLS0gYS9nY2MvdGVzdHN1aXRlL2ppdC5kZy9hbGwt bm9uLWZhaWxpbmctdGVzdHMuaAorKysgYi9nY2MvdGVzdHN1aXRlL2ppdC5kZy9hbGwtbm9uLWZh aWxpbmctdGVzdHMuaApAQCAtMzEzLDYgKzMxMyw5IEBACiAjdW5kZWYgY3JlYXRlX2NvZGUKICN1 bmRlZiB2ZXJpZnlfY29kZQogCisvKiB0ZXN0LXJlc3RyaWN0LmM6IFRoaXMgY2FuJ3QgYmUgaW4g dGhlIHRlc3RjYXNlcyBhcnJheSBhcyBpdCBuZWVkcworICAgdGhlIGAtTzNgIGZsYWcuICAqLwor CiAvKiB0ZXN0LXJlZ2lzdGVyLXZhcmlhYmxlLmM6IFRoaXMgY2FuJ3QgYmUgaW4gdGhlIHRlc3Rj YXNlcyBhcnJheSBhcyBpdAogICAgaXMgdGFyZ2V0LXNwZWNpZmljLiAgKi8KIApkaWZmIC0tZ2l0 IGEvZ2NjL3Rlc3RzdWl0ZS9qaXQuZGcvdGVzdC1yZXN0cmljdC5jIGIvZ2NjL3Rlc3RzdWl0ZS9q aXQuZGcvdGVzdC1yZXN0cmljdC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwLi5hNmFjOTYzMjRkMgotLS0gL2Rldi9udWxsCisrKyBiL2djYy90ZXN0c3VpdGUvaml0LmRn L3Rlc3QtcmVzdHJpY3QuYwpAQCAtMCwwICsxLDc3IEBACisvKiB7IGRnLWRvIGNvbXBpbGUgeyB0 YXJnZXQgeDg2XzY0LSotKiB9IH0gKi8KKworI2luY2x1ZGUgPHN0ZGxpYi5oPgorI2luY2x1ZGUg PHN0ZGlvLmg+CisKKyNpbmNsdWRlICJsaWJnY2NqaXQuaCIKKworLyogV2UgZG9uJ3Qgd2FudCBz ZXRfb3B0aW9ucygpIGluIGhhcm5lc3MuaCB0byBzZXQgLU8zIHRvIHNlZSB0aGF0IHRoZSByZXN0 cmljdAorCSBhdHRyaWJ1dGUgYWZmZWN0cyB0aGUgb3B0aW1pemF0aW9ucy4gKi8KKyNkZWZpbmUg VEVTVF9FU0NIRVdTX1NFVF9PUFRJT05TCitzdGF0aWMgdm9pZCBzZXRfb3B0aW9ucyAoZ2NjX2pp dF9jb250ZXh0ICpjdHh0LCBjb25zdCBjaGFyICphcmd2MCkKK3sKKwkvLyBTZXQgIi1PMyIuCisJ Z2NjX2ppdF9jb250ZXh0X3NldF9pbnRfb3B0aW9uKGN0eHQsIEdDQ19KSVRfSU5UX09QVElPTl9P UFRJTUlaQVRJT05fTEVWRUwsIDMpOworfQorCisjZGVmaW5lIFRFU1RfQ09NUElMSU5HX1RPX0ZJ TEUKKyNkZWZpbmUgT1VUUFVUX0tJTkQgICAgICBHQ0NfSklUX09VVFBVVF9LSU5EX0FTU0VNQkxF UgorI2RlZmluZSBPVVRQVVRfRklMRU5BTUUgICJvdXRwdXQtb2YtdGVzdC1yZXN0cmljdC5jLnMi CisjaW5jbHVkZSAiaGFybmVzcy5oIgorCit2b2lkCitjcmVhdGVfY29kZSAoZ2NjX2ppdF9jb250 ZXh0ICpjdHh0LCB2b2lkICp1c2VyX2RhdGEpCit7CisJLyogTGV0J3MgdHJ5IHRvIGluamVjdCB0 aGUgZXF1aXZhbGVudCBvZjoKK3ZvaWQgdChpbnQgKl9fcmVzdHJpY3RfXyBhLCBpbnQgKl9fcmVz dHJpY3RfXyBiLCBjaGFyICpfX3Jlc3RyaWN0X18gYykgeworCSphICs9ICpjOworCSpiICs9ICpj OworfQorCSovCisJZ2NjX2ppdF90eXBlICppbnRfdHlwZSA9CisJCWdjY19qaXRfY29udGV4dF9n ZXRfdHlwZSAoY3R4dCwgR0NDX0pJVF9UWVBFX0lOVCk7CisJZ2NjX2ppdF90eXBlICpwaW50X3R5 cGUgPSBnY2Nfaml0X3R5cGVfZ2V0X3BvaW50ZXIoaW50X3R5cGUpOworCWdjY19qaXRfdHlwZSAq cGludF9yZXN0cmljdF90eXBlID0gZ2NjX2ppdF90eXBlX2dldF9yZXN0cmljdChwaW50X3R5cGUp OworCisJZ2NjX2ppdF90eXBlICp2b2lkX3R5cGUgPQorCQlnY2Nfaml0X2NvbnRleHRfZ2V0X3R5 cGUgKGN0eHQsIEdDQ19KSVRfVFlQRV9WT0lEKTsKKworCWdjY19qaXRfcGFyYW0gKmEgPQorCQln Y2Nfaml0X2NvbnRleHRfbmV3X3BhcmFtIChjdHh0LCBOVUxMLCBwaW50X3Jlc3RyaWN0X3R5cGUs ICJhIik7CisJZ2NjX2ppdF9wYXJhbSAqYiA9CisJCWdjY19qaXRfY29udGV4dF9uZXdfcGFyYW0g KGN0eHQsIE5VTEwsIHBpbnRfcmVzdHJpY3RfdHlwZSwgImIiKTsKKwlnY2Nfaml0X3BhcmFtICpj ID0KKwkJZ2NjX2ppdF9jb250ZXh0X25ld19wYXJhbSAoY3R4dCwgTlVMTCwgcGludF9yZXN0cmlj dF90eXBlLCAiYyIpOworCWdjY19qaXRfcGFyYW0gKnBhcmFtc1szXSA9IHthLCBiLCBjfTsKKwor CWdjY19qaXRfZnVuY3Rpb24gKmZ1bmNfdCA9CisJCWdjY19qaXRfY29udGV4dF9uZXdfZnVuY3Rp b24gKGN0eHQsIE5VTEwsCisJCQkJCUdDQ19KSVRfRlVOQ1RJT05fRVhQT1JURUQsCisJCQkJCXZv aWRfdHlwZSwKKwkJCQkJInQiLAorCQkJCQkzLCBwYXJhbXMsCisJCQkJCTApOworCisJZ2NjX2pp dF9ibG9jayAqYmxvY2sgPSBnY2Nfaml0X2Z1bmN0aW9uX25ld19ibG9jayAoZnVuY190LCBOVUxM KTsKKworCS8qICphICs9ICpjOyAqLworCWdjY19qaXRfYmxvY2tfYWRkX2Fzc2lnbm1lbnRfb3Ag KAorCQlibG9jaywgTlVMTCwKKwkJZ2NjX2ppdF9ydmFsdWVfZGVyZWZlcmVuY2UgKGdjY19qaXRf cGFyYW1fYXNfcnZhbHVlIChhKSwgTlVMTCksCisJCUdDQ19KSVRfQklOQVJZX09QX1BMVVMsCisJ CWdjY19qaXRfbHZhbHVlX2FzX3J2YWx1ZSAoCisJCQlnY2Nfaml0X3J2YWx1ZV9kZXJlZmVyZW5j ZSAoZ2NjX2ppdF9wYXJhbV9hc19ydmFsdWUgKGMpLCBOVUxMKSkpOworCS8qICpiICs9ICpjOyAq LworCWdjY19qaXRfYmxvY2tfYWRkX2Fzc2lnbm1lbnRfb3AgKAorCQlibG9jaywgTlVMTCwKKwkJ Z2NjX2ppdF9ydmFsdWVfZGVyZWZlcmVuY2UgKGdjY19qaXRfcGFyYW1fYXNfcnZhbHVlIChiKSwg TlVMTCksCisJCUdDQ19KSVRfQklOQVJZX09QX1BMVVMsCisJCWdjY19qaXRfbHZhbHVlX2FzX3J2 YWx1ZSAoCisJCQlnY2Nfaml0X3J2YWx1ZV9kZXJlZmVyZW5jZSAoZ2NjX2ppdF9wYXJhbV9hc19y dmFsdWUgKGMpLCBOVUxMKSkpOworCisJZ2NjX2ppdF9ibG9ja19lbmRfd2l0aF92b2lkX3JldHVy biAoYmxvY2ssIE5VTEwpOworfQorCisvKiB7IGRnLWZpbmFsIHsgaml0LXZlcmlmeS1vdXRwdXQt ZmlsZS13YXMtY3JlYXRlZCAiIiB9IH0gKi8KKy8qIHsgZGctZmluYWwgeyBqaXQtdmVyaWZ5LWFz c2VtYmxlci1vdXRwdXQgImFkZGwJJWVheCwgKCVyZGkpCisJYWRkbAklZWF4LCAoJXJzaSkiIH0g fSAqLwotLSAKMi4zNC4xCgo= --000000000000c7075a06032009d0--