From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wm1-x334.google.com (mail-wm1-x334.google.com [IPv6:2a00:1450:4864:20::334]) by sourceware.org (Postfix) with ESMTPS id 80297384C2C4; Tue, 28 May 2024 20:53:41 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 80297384C2C4 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 80297384C2C4 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::334 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1716929624; cv=none; b=Snv8zTv5AiwN4ljTvhue/cxY4pTY4ccFMyHW39nIeWS1XMUaCChqIqxCqByU1V+TvOb/d42v3QWpTzI1GN7Un6Bqq8pebcyv5xP7dgMUmSepkWIWRA7Pln1dMzThkFzIUz6/Phk7fEWVI7ntGiS1jFTBycY0PbuP0P+MUzr5Cq0= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1716929624; c=relaxed/simple; bh=N0h2tjG2kNuHL8cQLtZ/T/QlrVB2M+1eU5X3hx2cbkQ=; h=DKIM-Signature:Message-ID:Date:MIME-Version:Subject:To:From; b=v/WM9MSakw8O0eJcEHODlwCsCuqoFv16+cttsAFJNxP6C59hTIHfrsdGmFBOwJ+qjkw/2E94gsZVH8skvxe5ZdfFVv1hCU3ZfBc7BFAK8mYxKNrZJfndCgpFB5xKW9pk6qW18PUH08UU8Yx2hZr6XJcXnV4cvfoIuw3TOyBpycU= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-wm1-x334.google.com with SMTP id 5b1f17b1804b1-42120fc8cbfso7668035e9.2; Tue, 28 May 2024 13:53:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1716929620; x=1717534420; darn=gcc.gnu.org; h=in-reply-to:from:content-language:references:cc:to:subject :user-agent:mime-version:date:message-id:from:to:cc:subject:date :message-id:reply-to; bh=aY6wBEblonYuIf6CjiZE/cfEB+oAj5jcIUs+/ekY1nI=; b=JyeHl5ciDlOq8c25i9Fo4zlX9ddU2ctRb9pME1ztjUNG+Z7fo4Ehulhcv6gMLHw+Dk qvKsgqjkDwpjQhfVVx37VHmwxtX3o/8tCFDqHc2szWEqGknFIdTPowo2W7Vgy4OhBhKO GXr13du7DDABBes4Lwlya/xnlL+celqbS8miq20Rc8I6oHmrfwTPyx12u2btrdHdK6Eq kEk/ZptxJGHrUjZTe4f72orEjNBexZJ+/XyttjSDYahBhB0+tMH7GwLohzdaD8TNidIg dpTPwzgVKVIE2rcWrSVqojGzoJaOGfHi+IDf2Ht0FxqctqC5mKKX1XEv57+A6sbwoCki zxqg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1716929620; x=1717534420; h=in-reply-to:from:content-language:references:cc:to:subject :user-agent:mime-version:date:message-id:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=aY6wBEblonYuIf6CjiZE/cfEB+oAj5jcIUs+/ekY1nI=; b=GQAm7r6Ja6ZJuLWeBrA7JXeccS2jRlLNYvJKZh+RA3fcasAqqRRm0bbu0067QoOIq3 RR/Y4/w1dsd9n7YJ7jwAuMfmksF0i/A3Yts0OloB1/jU4wPNQnTBBcnQfpt74Vw8WwFg AzYPIA8nFe9nBsCU1J3OrXtNVWhV9p/SmKNp5hOP4TrCGVtmYhb8vto6aTPHEm6bCukR 0EqykiMXAobL/cZKMs10BuHrN5utm1hyjSW/CdztPfQdgsHO9FUuZmOmkonHqpg+vh70 rpKJRzW4uPjat5sGi7Ah5KqZBKjpuob1/kb/VfzZQPAECzhSOWj4gww07wgmKOEAk08l +n3A== X-Forwarded-Encrypted: i=1; AJvYcCVbS9M2wJjrzXxqUWW5KGi6PEphfqGLjTO7gQnO6JJEXQrBW1EvSNPTTa2zby9/+GYavLfxprKcquGxlQrbbX3e1twuC7gRjQ== X-Gm-Message-State: AOJu0Yy5LTA0FFeRp4O79O7v6OGZZK4V6l0lr+k5LPpC1u98XTQ/m4Fe OmJL+EFyzAID55nCl9cP87DqmmEjZ7LYz20W1aUu9E3GVH8x/VxAgfDY9w== X-Google-Smtp-Source: AGHT+IFxcMBrXRsnMM1/5XazQFa/kIHUv9JW3vO9mTzCGFS3c6Wl0tRPiSv5sUNz8QjyV9CzENnbSQ== X-Received: by 2002:a05:600c:68c3:b0:41a:7bbe:c3bf with SMTP id 5b1f17b1804b1-421089dcb8cmr105174605e9.22.1716929619773; Tue, 28 May 2024 13:53:39 -0700 (PDT) Received: from ?IPV6:2a01:e0a:1dc:b1c0:f1c2:cc29:bb8:4251? ([2a01:e0a:1dc:b1c0:f1c2:cc29:bb8:4251]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-421089ccb10sm154215855e9.44.2024.05.28.13.53.37 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 28 May 2024 13:53:38 -0700 (PDT) Content-Type: multipart/mixed; boundary="------------Jnhx5IkhelGo1awvb3VvhNlY" Message-ID: <0634b907-5c27-4b8d-a47c-a899e637acac@gmail.com> Date: Tue, 28 May 2024 22:53:37 +0200 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH] Avoid vector -Wfree-nonheap-object warnings To: Jonathan Wakely Cc: libstdc++ , gcc-patches References: <305e3002-4ebb-4f07-91f3-10a29ec7fc70@gmail.com> <610e3afa-8a8a-400d-882e-41ec186d67f6@gmail.com> Content-Language: en-US From: =?UTF-8?Q?Fran=C3=A7ois_Dumont?= In-Reply-To: X-Spam-Status: No, score=-9.7 required=5.0 tests=BAYES_00,BODY_8BITS,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM,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.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: This is a multi-part message in MIME format. --------------Jnhx5IkhelGo1awvb3VvhNlY Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit I can indeed restore _M_initialize_dispatch as it was before. It was not fixing my initial problem. I simply kept the code simplification.     libstdc++: Use RAII to replace try/catch blocks     Move _Guard into std::vector declaration and use it to guard all calls to     vector _M_allocate.     Doing so the compiler has more visibility on what is done with the pointers     and do not raise anymore the -Wfree-nonheap-object warning.     libstdc++-v3/ChangeLog:             * include/bits/vector.tcc (_Guard): Move all the nested duplicated class...             * include/bits/stl_vector.h (_Guard_alloc): ...here and rename.             (_M_allocate_and_copy): Use latter.             (_M_initialize_dispatch): Small code simplification.             (_M_range_initialize): Likewise and set _M_finish first from the result             of __uninitialize_fill_n_a that can throw. Tested under Linux x86_64. Ok to commit ? François On 28/05/2024 12:30, Jonathan Wakely wrote: > On Mon, 27 May 2024 at 05:37, François Dumont wrote: >> Here is a new version working also in C++98. > Can we use a different solution that doesn't involve an explicit > template argument list for that __uninitialized_fill_n_a call? > > -+ this->_M_impl._M_finish = std::__uninitialized_fill_n_a > ++ this->_M_impl._M_finish = > ++ std::__uninitialized_fill_n_a > + (__start, __n, __value, _M_get_Tp_allocator()); > > Using _M_fill_initialize solves the problem :-) > > > >> Note that I have this failure: >> >> FAIL: 23_containers/vector/types/1.cc -std=gnu++98 (test for excess errors) >> >> but it's already failing on master, my patch do not change anything. > Yes, that's been failing for ages. > >> Tested under Linux x64, >> >> still ok to commit ? >> >> François >> >> On 24/05/2024 16:17, Jonathan Wakely wrote: >>> On Thu, 23 May 2024 at 18:38, François Dumont wrote: >>>> On 23/05/2024 15:31, Jonathan Wakely wrote: >>>>> On 23/05/24 06:55 +0200, François Dumont wrote: >>>>>> As explained in this email: >>>>>> >>>>>> https://gcc.gnu.org/pipermail/libstdc++/2024-April/058552.html >>>>>> >>>>>> I experimented -Wfree-nonheap-object because of my enhancements on >>>>>> algos. >>>>>> >>>>>> So here is a patch to extend the usage of the _Guard type to other >>>>>> parts of vector. >>>>> Nice, that fixes the warning you were seeing? >>>> Yes ! I indeed forgot to say so :-) >>>> >>>> >>>>> We recently got a bug report about -Wfree-nonheap-object in >>>>> std::vector, but that is coming from _M_realloc_append which already >>>>> uses the RAII guard :-( >>>>> https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115016 >>>> Note that I also had to move call to __uninitialized_copy_a before >>>> assigning this->_M_impl._M_start so get rid of the -Wfree-nonheap-object >>>> warn. But _M_realloc_append is already doing potentially throwing >>>> operations before assigning this->_M_impl so it must be something else. >>>> >>>> Though it made me notice another occurence of _Guard in this method. Now >>>> replaced too in this new patch. >>>> >>>> libstdc++: Use RAII to replace try/catch blocks >>>> >>>> Move _Guard into std::vector declaration and use it to guard all >>>> calls to >>>> vector _M_allocate. >>>> >>>> Doing so the compiler has more visibility on what is done with the >>>> pointers >>>> and do not raise anymore the -Wfree-nonheap-object warning. >>>> >>>> libstdc++-v3/ChangeLog: >>>> >>>> * include/bits/vector.tcc (_Guard): Move all the nested >>>> duplicated class... >>>> * include/bits/stl_vector.h (_Guard_alloc): ...here. >>>> (_M_allocate_and_copy): Use latter. >>>> (_M_initialize_dispatch): Likewise and set _M_finish first >>>> from the result >>>> of __uninitialize_fill_n_a that can throw. >>>> (_M_range_initialize): Likewise. >>>> >>>>>> diff --git a/libstdc++-v3/include/bits/stl_vector.h >>>>>> b/libstdc++-v3/include/bits/stl_vector.h >>>>>> index 31169711a48..4ea74e3339a 100644 >>>>>> --- a/libstdc++-v3/include/bits/stl_vector.h >>>>>> +++ b/libstdc++-v3/include/bits/stl_vector.h >>>>>> @@ -1607,6 +1607,39 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER >>>>>> clear() _GLIBCXX_NOEXCEPT >>>>>> { _M_erase_at_end(this->_M_impl._M_start); } >>>>>> >>>>>> + private: >>>>>> + // RAII guard for allocated storage. >>>>>> + struct _Guard >>>>> If it's being defined at class scope instead of locally in a member >>>>> function, I think a better name would be good. Maybe _Ptr_guard or >>>>> _Dealloc_guard or something. >>>> _Guard_alloc chosen. >>>>>> + { >>>>>> + pointer _M_storage; // Storage to deallocate >>>>>> + size_type _M_len; >>>>>> + _Base& _M_vect; >>>>>> + >>>>>> + _GLIBCXX20_CONSTEXPR >>>>>> + _Guard(pointer __s, size_type __l, _Base& __vect) >>>>>> + : _M_storage(__s), _M_len(__l), _M_vect(__vect) >>>>>> + { } >>>>>> + >>>>>> + _GLIBCXX20_CONSTEXPR >>>>>> + ~_Guard() >>>>>> + { >>>>>> + if (_M_storage) >>>>>> + _M_vect._M_deallocate(_M_storage, _M_len); >>>>>> + } >>>>>> + >>>>>> + _GLIBCXX20_CONSTEXPR >>>>>> + pointer >>>>>> + _M_release() >>>>>> + { >>>>>> + pointer __res = _M_storage; >>>>>> + _M_storage = 0; >>>>> I don't think the NullablePointer requirements include assigning 0, >>>>> only from nullptr, which isn't valid in C++98. >>>>> >>>>> https://en.cppreference.com/w/cpp/named_req/NullablePointer >>>>> >>>>> Please use _M_storage = pointer() instead. >>>> I forgot about user fancy pointer, fixed. >>>> >>>> >>>>>> + return __res; >>>>>> + } >>>>>> + >>>>>> + private: >>>>>> + _Guard(const _Guard&); >>>>>> + }; >>>>>> + >>>>>> protected: >>>>>> /** >>>>>> * Memory expansion handler. Uses the member allocation >>>>>> function to >>>>>> @@ -1618,18 +1651,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER >>>>>> _M_allocate_and_copy(size_type __n, >>>>>> _ForwardIterator __first, _ForwardIterator __last) >>>>>> { >>>>>> - pointer __result = this->_M_allocate(__n); >>>>>> - __try >>>>>> - { >>>>>> - std::__uninitialized_copy_a(__first, __last, __result, >>>>>> - _M_get_Tp_allocator()); >>>>>> - return __result; >>>>>> - } >>>>>> - __catch(...) >>>>>> - { >>>>>> - _M_deallocate(__result, __n); >>>>>> - __throw_exception_again; >>>>>> - } >>>>>> + _Guard __guard(this->_M_allocate(__n), __n, *this); >>>>>> + std::__uninitialized_copy_a >>>>>> + (__first, __last, __guard._M_storage, _M_get_Tp_allocator()); >>>>>> + return __guard._M_release(); >>>>>> } >>>>>> >>>>>> >>>>>> @@ -1642,13 +1667,15 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER >>>>>> // 438. Ambiguity in the "do the right thing" clause >>>>>> template >>>>>> void >>>>>> - _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type) >>>>>> + _M_initialize_dispatch(_Integer __int_n, _Integer __value, >>>>>> __true_type) >>>>>> { >>>>>> - this->_M_impl._M_start = _M_allocate(_S_check_init_len( >>>>>> - static_cast(__n), _M_get_Tp_allocator())); >>>>>> - this->_M_impl._M_end_of_storage = >>>>>> - this->_M_impl._M_start + static_cast(__n); >>>>>> - _M_fill_initialize(static_cast(__n), __value); >>>>> Please fix the comment on _M_fill_initialize if you're removing the >>>>> use of it here. >>>> Already done in this initial patch proposal, see below. >>>> >>>>>> + const size_type __n = static_cast(__int_n); >>>>>> + _Guard __guard(_M_allocate(_S_check_init_len( >>>>>> + __n, _M_get_Tp_allocator())), __n, *this); >>>>> I think this would be easier to read if the _S_check_init_len call was >>>>> done first, and maybe the allocation too, since we are going to need a >>>>> local __start later anyway. So maybe like this: >>>>> >>>>> template >>>>> void >>>>> _M_initialize_dispatch(_Integer __ni, _Integer __value, __true_type) >>>>> { >>>>> const size_type __n = static_cast(__ni); >>>>> pointer __start = _M_allocate(_S_check_init_len(__n), >>>>> _M_get_Tp_allocator()); >>>>> _Guard __guard(__start, __n, *this); >>>>> this->_M_impl._M_start = __start; >>>>> _M_fill_initialize(__n, __value); >>>>> this->_M_impl._M_end_of_storage = __start + __n; >>>>> (void) __guard._M_release(); >>>>> } >>>>> >>>>> Or inline the __uninitialized_fill_n_a call if you want to (but then >>>>> fix the comment on _M_fill_initialize). Inlining it does make this >>>>> function more consistent with the next one, which calls >>>>> __uninitialized_copy_a directly. >>>> Yes, this is why I called __uninitialized_fill_n_a instead and also to >>>> do so *before* assigning _M_impl._M_start. >>>> >>>> >>>>>> - // Called by the first initialize_dispatch above and by the >>>>>> - // vector(n,value,a) constructor. >>>>>> + // Called by the vector(n,value,a) constructor. >>>> See, it's here :-) >>> Doh! Sorry, I'm not sure how I missed that. >>> >>>> Ok to commit ? >>> OK for trunk, thanks! >>> --------------Jnhx5IkhelGo1awvb3VvhNlY Content-Type: text/plain; charset=UTF-8; name="vector_patch.txt" Content-Disposition: attachment; filename="vector_patch.txt" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2xpYnN0ZGMrKy12My9pbmNsdWRlL2JpdHMvc3RsX3ZlY3Rvci5oIGIv bGlic3RkYysrLXYzL2luY2x1ZGUvYml0cy9zdGxfdmVjdG9yLmgKaW5kZXggMzExNjk3MTFh NDguLjE4MmFkNDFlZDk0IDEwMDY0NAotLS0gYS9saWJzdGRjKystdjMvaW5jbHVkZS9iaXRz L3N0bF92ZWN0b3IuaAorKysgYi9saWJzdGRjKystdjMvaW5jbHVkZS9iaXRzL3N0bF92ZWN0 b3IuaApAQCAtMTYwNyw2ICsxNjA3LDM5IEBAIF9HTElCQ1hYX0JFR0lOX05BTUVTUEFDRV9D T05UQUlORVIKICAgICAgIGNsZWFyKCkgX0dMSUJDWFhfTk9FWENFUFQKICAgICAgIHsgX01f ZXJhc2VfYXRfZW5kKHRoaXMtPl9NX2ltcGwuX01fc3RhcnQpOyB9CiAKKyAgICBwcml2YXRl OgorICAgICAgLy8gUkFJSSBndWFyZCBmb3IgYWxsb2NhdGVkIHN0b3JhZ2UuCisgICAgICBz dHJ1Y3QgX0d1YXJkX2FsbG9jCisgICAgICB7CisJcG9pbnRlciBfTV9zdG9yYWdlOwkgICAg Ly8gU3RvcmFnZSB0byBkZWFsbG9jYXRlCisJc2l6ZV90eXBlIF9NX2xlbjsKKwlfQmFzZSYg X01fdmVjdDsKKworCV9HTElCQ1hYMjBfQ09OU1RFWFBSCisJX0d1YXJkX2FsbG9jKHBvaW50 ZXIgX19zLCBzaXplX3R5cGUgX19sLCBfQmFzZSYgX192ZWN0KQorCTogX01fc3RvcmFnZShf X3MpLCBfTV9sZW4oX19sKSwgX01fdmVjdChfX3ZlY3QpCisJeyB9CisKKwlfR0xJQkNYWDIw X0NPTlNURVhQUgorCX5fR3VhcmRfYWxsb2MoKQorCXsKKwkgIGlmIChfTV9zdG9yYWdlKQor CSAgICBfTV92ZWN0Ll9NX2RlYWxsb2NhdGUoX01fc3RvcmFnZSwgX01fbGVuKTsKKwl9CisK KwlfR0xJQkNYWDIwX0NPTlNURVhQUgorCXBvaW50ZXIKKwlfTV9yZWxlYXNlKCkKKwl7CisJ ICBwb2ludGVyIF9fcmVzID0gX01fc3RvcmFnZTsKKwkgIF9NX3N0b3JhZ2UgPSBwb2ludGVy KCk7CisJICByZXR1cm4gX19yZXM7CisJfQorCisgICAgICBwcml2YXRlOgorCV9HdWFyZF9h bGxvYyhjb25zdCBfR3VhcmRfYWxsb2MmKTsKKyAgICAgIH07CisKICAgICBwcm90ZWN0ZWQ6 CiAgICAgICAvKioKICAgICAgICAqICBNZW1vcnkgZXhwYW5zaW9uIGhhbmRsZXIuICBVc2Vz IHRoZSBtZW1iZXIgYWxsb2NhdGlvbiBmdW5jdGlvbiB0bwpAQCAtMTYxOCwxOCArMTY1MSwx MCBAQCBfR0xJQkNYWF9CRUdJTl9OQU1FU1BBQ0VfQ09OVEFJTkVSCiAJX01fYWxsb2NhdGVf YW5kX2NvcHkoc2l6ZV90eXBlIF9fbiwKIAkJCSAgICAgX0ZvcndhcmRJdGVyYXRvciBfX2Zp cnN0LCBfRm9yd2FyZEl0ZXJhdG9yIF9fbGFzdCkKIAl7Ci0JICBwb2ludGVyIF9fcmVzdWx0 ID0gdGhpcy0+X01fYWxsb2NhdGUoX19uKTsKLQkgIF9fdHJ5Ci0JICAgIHsKLQkgICAgICBz dGQ6Ol9fdW5pbml0aWFsaXplZF9jb3B5X2EoX19maXJzdCwgX19sYXN0LCBfX3Jlc3VsdCwK LQkJCQkJICBfTV9nZXRfVHBfYWxsb2NhdG9yKCkpOwotCSAgICAgIHJldHVybiBfX3Jlc3Vs dDsKLQkgICAgfQotCSAgX19jYXRjaCguLi4pCi0JICAgIHsKLQkgICAgICBfTV9kZWFsbG9j YXRlKF9fcmVzdWx0LCBfX24pOwotCSAgICAgIF9fdGhyb3dfZXhjZXB0aW9uX2FnYWluOwot CSAgICB9CisJICBfR3VhcmRfYWxsb2MgX19ndWFyZCh0aGlzLT5fTV9hbGxvY2F0ZShfX24p LCBfX24sICp0aGlzKTsKKwkgIHN0ZDo6X191bmluaXRpYWxpemVkX2NvcHlfYQorCSAgICAo X19maXJzdCwgX19sYXN0LCBfX2d1YXJkLl9NX3N0b3JhZ2UsIF9NX2dldF9UcF9hbGxvY2F0 b3IoKSk7CisJICByZXR1cm4gX19ndWFyZC5fTV9yZWxlYXNlKCk7CiAJfQogCiAKQEAgLTE2 NDIsMTMgKzE2NjcsMTQgQEAgX0dMSUJDWFhfQkVHSU5fTkFNRVNQQUNFX0NPTlRBSU5FUgog ICAgICAgLy8gNDM4LiBBbWJpZ3VpdHkgaW4gdGhlICJkbyB0aGUgcmlnaHQgdGhpbmciIGNs YXVzZQogICAgICAgdGVtcGxhdGU8dHlwZW5hbWUgX0ludGVnZXI+CiAJdm9pZAotCV9NX2lu aXRpYWxpemVfZGlzcGF0Y2goX0ludGVnZXIgX19uLCBfSW50ZWdlciBfX3ZhbHVlLCBfX3Ry dWVfdHlwZSkKKwlfTV9pbml0aWFsaXplX2Rpc3BhdGNoKF9JbnRlZ2VyIF9faW50X24sIF9J bnRlZ2VyIF9fdmFsdWUsIF9fdHJ1ZV90eXBlKQogCXsKLQkgIHRoaXMtPl9NX2ltcGwuX01f c3RhcnQgPSBfTV9hbGxvY2F0ZShfU19jaGVja19pbml0X2xlbigKLQkJc3RhdGljX2Nhc3Q8 c2l6ZV90eXBlPihfX24pLCBfTV9nZXRfVHBfYWxsb2NhdG9yKCkpKTsKLQkgIHRoaXMtPl9N X2ltcGwuX01fZW5kX29mX3N0b3JhZ2UgPQotCSAgICB0aGlzLT5fTV9pbXBsLl9NX3N0YXJ0 ICsgc3RhdGljX2Nhc3Q8c2l6ZV90eXBlPihfX24pOwotCSAgX01fZmlsbF9pbml0aWFsaXpl KHN0YXRpY19jYXN0PHNpemVfdHlwZT4oX19uKSwgX192YWx1ZSk7CisJICBjb25zdCBzaXpl X3R5cGUgX19uID0gc3RhdGljX2Nhc3Q8c2l6ZV90eXBlPihfX2ludF9uKTsKKwkgIHBvaW50 ZXIgX19zdGFydCA9CisJICAgIF9NX2FsbG9jYXRlKF9TX2NoZWNrX2luaXRfbGVuKF9fbiwg X01fZ2V0X1RwX2FsbG9jYXRvcigpKSk7CisJICB0aGlzLT5fTV9pbXBsLl9NX3N0YXJ0ID0g X19zdGFydDsKKwkgIHRoaXMtPl9NX2ltcGwuX01fZW5kX29mX3N0b3JhZ2UgPSBfX3N0YXJ0 ICsgX19uOworCSAgX01fZmlsbF9pbml0aWFsaXplKF9fbiwgX192YWx1ZSk7CiAJfQogCiAg ICAgICAvLyBDYWxsZWQgYnkgdGhlIHJhbmdlIGNvbnN0cnVjdG9yIHRvIGltcGxlbWVudCBb MjMuMS4xXS85CkBAIC0xNjkwLDEzICsxNzE2LDE0IEBAIF9HTElCQ1hYX0JFR0lOX05BTUVT UEFDRV9DT05UQUlORVIKIAkJCSAgICBzdGQ6OmZvcndhcmRfaXRlcmF0b3JfdGFnKQogCXsK IAkgIGNvbnN0IHNpemVfdHlwZSBfX24gPSBzdGQ6OmRpc3RhbmNlKF9fZmlyc3QsIF9fbGFz dCk7Ci0JICB0aGlzLT5fTV9pbXBsLl9NX3N0YXJ0Ci0JICAgID0gdGhpcy0+X01fYWxsb2Nh dGUoX1NfY2hlY2tfaW5pdF9sZW4oX19uLCBfTV9nZXRfVHBfYWxsb2NhdG9yKCkpKTsKLQkg IHRoaXMtPl9NX2ltcGwuX01fZW5kX29mX3N0b3JhZ2UgPSB0aGlzLT5fTV9pbXBsLl9NX3N0 YXJ0ICsgX19uOwotCSAgdGhpcy0+X01faW1wbC5fTV9maW5pc2ggPQotCSAgICBzdGQ6Ol9f dW5pbml0aWFsaXplZF9jb3B5X2EoX19maXJzdCwgX19sYXN0LAotCQkJCQl0aGlzLT5fTV9p bXBsLl9NX3N0YXJ0LAotCQkJCQlfTV9nZXRfVHBfYWxsb2NhdG9yKCkpOworCSAgcG9pbnRl ciBfX3N0YXJ0ID0KKwkgICAgdGhpcy0+X01fYWxsb2NhdGUoX1NfY2hlY2tfaW5pdF9sZW4o X19uLCBfTV9nZXRfVHBfYWxsb2NhdG9yKCkpKTsKKwkgIF9HdWFyZF9hbGxvYyBfX2d1YXJk KF9fc3RhcnQsIF9fbiwgKnRoaXMpOworCSAgdGhpcy0+X01faW1wbC5fTV9maW5pc2ggPSBz dGQ6Ol9fdW5pbml0aWFsaXplZF9jb3B5X2EKKwkgICAgKF9fZmlyc3QsIF9fbGFzdCwgX19z dGFydCwgX01fZ2V0X1RwX2FsbG9jYXRvcigpKTsKKwkgIHRoaXMtPl9NX2ltcGwuX01fc3Rh cnQgPSBfX3N0YXJ0OworCSAgKHZvaWQpIF9fZ3VhcmQuX01fcmVsZWFzZSgpOworCSAgdGhp cy0+X01faW1wbC5fTV9lbmRfb2Zfc3RvcmFnZSA9IF9fc3RhcnQgKyBfX247CiAJfQogCiAg ICAgICAvLyBDYWxsZWQgYnkgdGhlIGZpcnN0IGluaXRpYWxpemVfZGlzcGF0Y2ggYWJvdmUg YW5kIGJ5IHRoZQpkaWZmIC0tZ2l0IGEvbGlic3RkYysrLXYzL2luY2x1ZGUvYml0cy92ZWN0 b3IudGNjIGIvbGlic3RkYysrLXYzL2luY2x1ZGUvYml0cy92ZWN0b3IudGNjCmluZGV4IDI1 ZGYwNjBiZWVlLi4zNmIyN2RjZTdiOSAxMDA2NDQKLS0tIGEvbGlic3RkYysrLXYzL2luY2x1 ZGUvYml0cy92ZWN0b3IudGNjCisrKyBiL2xpYnN0ZGMrKy12My9pbmNsdWRlL2JpdHMvdmVj dG9yLnRjYwpAQCAtNDY3LDMyICs0NjcsOCBAQCBfR0xJQkNYWF9CRUdJTl9OQU1FU1BBQ0Vf Q09OVEFJTkVSCiAgICAgICBwb2ludGVyIF9fbmV3X3N0YXJ0KHRoaXMtPl9NX2FsbG9jYXRl KF9fbGVuKSk7CiAgICAgICBwb2ludGVyIF9fbmV3X2ZpbmlzaChfX25ld19zdGFydCk7CiAK LSAgICAgIC8vIFJBSUkgZ3VhcmQgZm9yIGFsbG9jYXRlZCBzdG9yYWdlLgotICAgICAgc3Ry dWN0IF9HdWFyZAogICAgICAgewotCXBvaW50ZXIgX01fc3RvcmFnZTsJICAgIC8vIFN0b3Jh Z2UgdG8gZGVhbGxvY2F0ZQotCXNpemVfdHlwZSBfTV9sZW47Ci0JX1RwX2FsbG9jX3R5cGUm IF9NX2FsbG9jOwotCi0JX0dMSUJDWFgyMF9DT05TVEVYUFIKLQlfR3VhcmQocG9pbnRlciBf X3MsIHNpemVfdHlwZSBfX2wsIF9UcF9hbGxvY190eXBlJiBfX2EpCi0JOiBfTV9zdG9yYWdl KF9fcyksIF9NX2xlbihfX2wpLCBfTV9hbGxvYyhfX2EpCi0JeyB9Ci0KLQlfR0xJQkNYWDIw X0NPTlNURVhQUgotCX5fR3VhcmQoKQotCXsKLQkgIGlmIChfTV9zdG9yYWdlKQotCSAgICBf X2dudV9jeHg6Ol9fYWxsb2NfdHJhaXRzPF9UcF9hbGxvY190eXBlPjo6Ci0JICAgICAgZGVh bGxvY2F0ZShfTV9hbGxvYywgX01fc3RvcmFnZSwgX01fbGVuKTsKLQl9Ci0KLSAgICAgIHBy aXZhdGU6Ci0JX0d1YXJkKGNvbnN0IF9HdWFyZCYpOwotICAgICAgfTsKLQotICAgICAgewot CV9HdWFyZCBfX2d1YXJkKF9fbmV3X3N0YXJ0LCBfX2xlbiwgX01faW1wbCk7CisJX0d1YXJk X2FsbG9jIF9fZ3VhcmQoX19uZXdfc3RhcnQsIF9fbGVuLCAqdGhpcyk7CiAKIAkvLyBUaGUg b3JkZXIgb2YgdGhlIHRocmVlIG9wZXJhdGlvbnMgaXMgZGljdGF0ZWQgYnkgdGhlIEMrKzEx CiAJLy8gY2FzZSwgd2hlcmUgdGhlIG1vdmVzIGNvdWxkIGFsdGVyIGEgbmV3IGVsZW1lbnQg YmVsb25naW5nCkBAIC01OTYsMzIgKzU3Miw4IEBAIF9HTElCQ1hYX0JFR0lOX05BTUVTUEFD RV9DT05UQUlORVIKICAgICAgIHBvaW50ZXIgX19uZXdfc3RhcnQodGhpcy0+X01fYWxsb2Nh dGUoX19sZW4pKTsKICAgICAgIHBvaW50ZXIgX19uZXdfZmluaXNoKF9fbmV3X3N0YXJ0KTsK IAotICAgICAgLy8gUkFJSSBndWFyZCBmb3IgYWxsb2NhdGVkIHN0b3JhZ2UuCi0gICAgICBz dHJ1Y3QgX0d1YXJkCiAgICAgICB7Ci0JcG9pbnRlciBfTV9zdG9yYWdlOwkgICAgLy8gU3Rv cmFnZSB0byBkZWFsbG9jYXRlCi0Jc2l6ZV90eXBlIF9NX2xlbjsKLQlfVHBfYWxsb2NfdHlw ZSYgX01fYWxsb2M7Ci0KLQlfR0xJQkNYWDIwX0NPTlNURVhQUgotCV9HdWFyZChwb2ludGVy IF9fcywgc2l6ZV90eXBlIF9fbCwgX1RwX2FsbG9jX3R5cGUmIF9fYSkKLQk6IF9NX3N0b3Jh Z2UoX19zKSwgX01fbGVuKF9fbCksIF9NX2FsbG9jKF9fYSkKLQl7IH0KLQotCV9HTElCQ1hY MjBfQ09OU1RFWFBSCi0Jfl9HdWFyZCgpCi0JewotCSAgaWYgKF9NX3N0b3JhZ2UpCi0JICAg IF9fZ251X2N4eDo6X19hbGxvY190cmFpdHM8X1RwX2FsbG9jX3R5cGU+OjoKLQkgICAgICBk ZWFsbG9jYXRlKF9NX2FsbG9jLCBfTV9zdG9yYWdlLCBfTV9sZW4pOwotCX0KLQotICAgICAg cHJpdmF0ZToKLQlfR3VhcmQoY29uc3QgX0d1YXJkJik7Ci0gICAgICB9OwotCi0gICAgICB7 Ci0JX0d1YXJkIF9fZ3VhcmQoX19uZXdfc3RhcnQsIF9fbGVuLCBfTV9pbXBsKTsKKwlfR3Vh cmRfYWxsb2MgX19ndWFyZChfX25ld19zdGFydCwgX19sZW4sICp0aGlzKTsKIAogCS8vIFRo ZSBvcmRlciBvZiB0aGUgdGhyZWUgb3BlcmF0aW9ucyBpcyBkaWN0YXRlZCBieSB0aGUgQysr MTEKIAkvLyBjYXNlLCB3aGVyZSB0aGUgbW92ZXMgY291bGQgYWx0ZXIgYSBuZXcgZWxlbWVu dCBiZWxvbmdpbmcKQEAgLTgzMywzMiArNzg1LDggQEAgX0dMSUJDWFhfQkVHSU5fTkFNRVNQ QUNFX0NPTlRBSU5FUgogCQlfTV9jaGVja19sZW4oX19uLCAidmVjdG9yOjpfTV9kZWZhdWx0 X2FwcGVuZCIpOwogCSAgICAgIHBvaW50ZXIgX19uZXdfc3RhcnQodGhpcy0+X01fYWxsb2Nh dGUoX19sZW4pKTsKIAotCSAgICAgIC8vIFJBSUkgZ3VhcmQgZm9yIGFsbG9jYXRlZCBzdG9y YWdlLgotCSAgICAgIHN0cnVjdCBfR3VhcmQKLQkgICAgICB7Ci0JCXBvaW50ZXIgX01fc3Rv cmFnZTsgICAgICAgICAvLyBTdG9yYWdlIHRvIGRlYWxsb2NhdGUKLQkJc2l6ZV90eXBlIF9N X2xlbjsKLQkJX1RwX2FsbG9jX3R5cGUmIF9NX2FsbG9jOwotCi0JCV9HTElCQ1hYMjBfQ09O U1RFWFBSCi0JCV9HdWFyZChwb2ludGVyIF9fcywgc2l6ZV90eXBlIF9fbCwgX1RwX2FsbG9j X3R5cGUmIF9fYSkKLQkJOiBfTV9zdG9yYWdlKF9fcyksIF9NX2xlbihfX2wpLCBfTV9hbGxv YyhfX2EpCi0JCXsgfQotCi0JCV9HTElCQ1hYMjBfQ09OU1RFWFBSCi0JCX5fR3VhcmQoKQot CQl7Ci0JCSAgaWYgKF9NX3N0b3JhZ2UpCi0JCSAgICBfX2dudV9jeHg6Ol9fYWxsb2NfdHJh aXRzPF9UcF9hbGxvY190eXBlPjo6Ci0JCSAgICAgIGRlYWxsb2NhdGUoX01fYWxsb2MsIF9N X3N0b3JhZ2UsIF9NX2xlbik7Ci0JCX0KLQotCSAgICAgIHByaXZhdGU6Ci0JCV9HdWFyZChj b25zdCBfR3VhcmQmKTsKLQkgICAgICB9OwotCiAJICAgICAgewotCQlfR3VhcmQgX19ndWFy ZChfX25ld19zdGFydCwgX19sZW4sIF9NX2ltcGwpOworCQlfR3VhcmRfYWxsb2MgX19ndWFy ZChfX25ld19zdGFydCwgX19sZW4sICp0aGlzKTsKIAogCQlzdGQ6Ol9fdW5pbml0aWFsaXpl ZF9kZWZhdWx0X25fYShfX25ld19zdGFydCArIF9fc2l6ZSwgX19uLAogCQkJCQkJIF9NX2dl dF9UcF9hbGxvY2F0b3IoKSk7Cg== --------------Jnhx5IkhelGo1awvb3VvhNlY--