From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wr1-x430.google.com (mail-wr1-x430.google.com [IPv6:2a00:1450:4864:20::430]) by sourceware.org (Postfix) with ESMTPS id 8636C3858D33; Thu, 23 May 2024 17:38:01 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 8636C3858D33 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 8636C3858D33 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::430 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1716485884; cv=none; b=itdunlElOAJqsPunKw2iUaGwsgzMBy14m4EKCZW7mnbCPyz2s92aazPMZ6QC5YvQaD8nDAcgGBojQWDqbF8HZtVpfI0weWFJObljYPmTDgdOLGFX+dy/KDsraOZqqZ8rfZ8U7TJtvP/fN/WitXqHeygCq0Im5HCsRk+an1Q34z8= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1716485884; c=relaxed/simple; bh=Reka/YfWAjgGbmTMqHtFkTh98Fae98icL7cPpFZ3J4k=; h=DKIM-Signature:Message-ID:Date:MIME-Version:Subject:To:From; b=XhfV/5Te25AlfHShLOZtvJsf8gC34U3nXddWf4/oyaBdm/F9VGmM1vRfMAsgDQyjtDnAurvb4YjhvhrcD5JM3FMWpsdG37pQENRDovR8KFV4D3zepFUTdNoe2EAKax1IY4mS18cvQbm/34Y5E/Zx0lIEagarg1bcPE+wKUcT+p0= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-wr1-x430.google.com with SMTP id ffacd0b85a97d-354b7d76c52so1730106f8f.3; Thu, 23 May 2024 10:38:01 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1716485879; x=1717090679; 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=hMkaBGNepHy+tAzEFI1vpTFuQeatLofJIYMzEOv0HCE=; b=H8gZxiJXiW2sXeu0M4MMK5r0QZUri94jYLJDxDWCkNVwfOYDV8FCXFZr3kKv8EqOCA XIelOJ4sz748LiIcldeS/RaNUbPO1r15TbGG1PXRCE0asXPjfmco+Czp/hYhxDZ5sV1N 3zLnlnM9SOyOSeJVwcGLaRUuMZJLBv3YVuXVpuZRSJUbUKtAR0ziLidsRC5Aae9a2CO1 5i7GtPyxpA/N6whlHrxjn+NYTE4Zzk+7AFuMncm2WI0EzIfCsPk3ATcISfojvZy9YXxv 9mDHyDevSegTSizJ7Pc2pgYrwzLX/XcHaOBmHm9//gToO7+cuW0OjdAPxvicG3C4h0UE FeJA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1716485879; x=1717090679; 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=hMkaBGNepHy+tAzEFI1vpTFuQeatLofJIYMzEOv0HCE=; b=ngKQrX1ukY5NHYc8vykRioq9Jn3SsmHUDyQOKyPnX/3hIcQRHGJYOKZt1XpVZA5u3f U2WDvwgEKetfefJQg/E6tlpJvOj9rxUtZBQ9A2CCWaJrJ9gnDIq2KhSTtjGR6af1VlQQ T7BCtIyqAcc8uVU+MXsN8juuuaV7yW8bwlyscN4rXJGaKDfUhP3bXjy0z+IIKkkYuY0q ew5AAe7t4mXEhBSKsi/1+khm8koPREV9SM6bB3G1ojp294DyvZTDIlfyDpMiCzo6tZEZ OZSMVOI8X9jUn9i9tru2DIbsTJ8u5yubY8z7EcTvd1+bI5OknA82fRrReAJFF5BOAXj1 BZmQ== X-Forwarded-Encrypted: i=1; AJvYcCXArmK5EcXO3drD3baKyIm7ss4LYrWMIqTqVbFoHNf8NO3yCmH63xJiXWroiM66Fdi8oFrbQ3EzvPr77RZWsJgYuqA3mdmO5g== X-Gm-Message-State: AOJu0YwF/hJ9mEYzTaFWoHsvkNKCnpL1h/0AiFCU4GxstPF+B6Q0j8xz plG0GOi/7zvyXLp/CZQcAvdHGtyafbA2Kw4IEOhEgxno/Aa32v9911ceig== X-Google-Smtp-Source: AGHT+IGKnt6KDgrYhCB+H1yMimuujl/0p3hSPQP9iOsGeR9WZnkmnQMZ9+AQaE1U8w1Qt8AyAJ7/hQ== X-Received: by 2002:a05:6000:1041:b0:34f:4cc7:88f5 with SMTP id ffacd0b85a97d-354d8cde0f1mr4260246f8f.27.1716485879056; Thu, 23 May 2024 10:37:59 -0700 (PDT) Received: from [10.28.1.89] ([89.207.171.118]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-35502f1785asm732467f8f.98.2024.05.23.10.37.57 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Thu, 23 May 2024 10:37:58 -0700 (PDT) Content-Type: multipart/mixed; boundary="------------ACIs6JaksGxxkYWg6DCaiHaq" Message-ID: Date: Thu, 23 May 2024 19:37:56 +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> 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 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. --------------ACIs6JaksGxxkYWg6DCaiHaq Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit 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 :-) Ok to commit ? François --------------ACIs6JaksGxxkYWg6DCaiHaq Content-Type: text/plain; charset=UTF-8; name="vector_patch.txt" Content-Disposition: attachment; filename="vector_patch.txt" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2xpYnN0ZGMrKy12My9pbmNsdWRlL2JpdHMvc3RsX3ZlY3Rvci5oIGIv bGlic3RkYysrLXYzL2luY2x1ZGUvYml0cy9zdGxfdmVjdG9yLmgKaW5kZXggMzExNjk3MTFh NDguLjMwZDcyMDFjNjEzIDEwMDY0NAotLS0gYS9saWJzdGRjKystdjMvaW5jbHVkZS9iaXRz 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 NDIsMTMgKzE2NjcsMTcgQEAgX0dMSUJDWFhfQkVHSU5fTkFNRVNQQUNFX0NPTlRBSU5FUgog ICAgICAgLy8gNDM4LiBBbWJpZ3VpdHkgaW4gdGhlICJkbyB0aGUgcmlnaHQgdGhpbmciIGNs YXVzZQogICAgICAgdGVtcGxhdGU8dHlwZW5hbWUgX0ludGVnZXI+CiAJdm9pZAotCV9NX2lu aXRpYWxpemVfZGlzcGF0Y2goX0ludGVnZXIgX19uLCBfSW50ZWdlciBfX3ZhbHVlLCBfX3Ry dWVfdHlwZSkKKwlfTV9pbml0aWFsaXplX2Rpc3BhdGNoKF9JbnRlZ2VyIF9faW50X24sIF9J bnRlZ2VyIF9fdmFsdWUsIF9fdHJ1ZV90eXBlKQogCXsKLQkgIHRoaXMtPl9NX2ltcGwuX01f c3RhcnQgPSBfTV9hbGxvY2F0ZShfU19jaGVja19pbml0X2xlbigKLQkJc3RhdGljX2Nhc3Q8 c2l6ZV90eXBlPihfX24pLCBfTV9nZXRfVHBfYWxsb2NhdG9yKCkpKTsKLQkgIHRoaXMtPl9N X2ltcGwuX01fZW5kX29mX3N0b3JhZ2UgPQotCSAgICB0aGlzLT5fTV9pbXBsLl9NX3N0YXJ0 ICsgc3RhdGljX2Nhc3Q8c2l6ZV90eXBlPihfX24pOwotCSAgX01fZmlsbF9pbml0aWFsaXpl KHN0YXRpY19jYXN0PHNpemVfdHlwZT4oX19uKSwgX192YWx1ZSk7CisJICBjb25zdCBzaXpl X3R5cGUgX19uID0gc3RhdGljX2Nhc3Q8c2l6ZV90eXBlPihfX2ludF9uKTsKKwkgIHBvaW50 ZXIgX19zdGFydCA9CisJICAgIF9NX2FsbG9jYXRlKF9TX2NoZWNrX2luaXRfbGVuKF9fbiwg X01fZ2V0X1RwX2FsbG9jYXRvcigpKSk7CisJICBfR3VhcmRfYWxsb2MgX19ndWFyZChfX3N0 YXJ0LCBfX24sICp0aGlzKTsKKwkgIHRoaXMtPl9NX2ltcGwuX01fZmluaXNoID0gc3RkOjpf X3VuaW5pdGlhbGl6ZWRfZmlsbF9uX2EKKwkgICAgKF9fc3RhcnQsIF9fbiwgX192YWx1ZSwg X01fZ2V0X1RwX2FsbG9jYXRvcigpKTsKKwkgIHRoaXMtPl9NX2ltcGwuX01fc3RhcnQgPSBf X3N0YXJ0OworCSAgKHZvaWQpX19ndWFyZC5fTV9yZWxlYXNlKCk7CisJICB0aGlzLT5fTV9p bXBsLl9NX2VuZF9vZl9zdG9yYWdlID0gX19zdGFydCArIF9fbjsKIAl9CiAKICAgICAgIC8v IENhbGxlZCBieSB0aGUgcmFuZ2UgY29uc3RydWN0b3IgdG8gaW1wbGVtZW50IFsyMy4xLjFd LzkKQEAgLTE2OTAsMTcgKzE3MTksMTcgQEAgX0dMSUJDWFhfQkVHSU5fTkFNRVNQQUNFX0NP TlRBSU5FUgogCQkJICAgIHN0ZDo6Zm9yd2FyZF9pdGVyYXRvcl90YWcpCiAJewogCSAgY29u c3Qgc2l6ZV90eXBlIF9fbiA9IHN0ZDo6ZGlzdGFuY2UoX19maXJzdCwgX19sYXN0KTsKLQkg IHRoaXMtPl9NX2ltcGwuX01fc3RhcnQKLQkgICAgPSB0aGlzLT5fTV9hbGxvY2F0ZShfU19j aGVja19pbml0X2xlbihfX24sIF9NX2dldF9UcF9hbGxvY2F0b3IoKSkpOwotCSAgdGhpcy0+ X01faW1wbC5fTV9lbmRfb2Zfc3RvcmFnZSA9IHRoaXMtPl9NX2ltcGwuX01fc3RhcnQgKyBf X247Ci0JICB0aGlzLT5fTV9pbXBsLl9NX2ZpbmlzaCA9Ci0JICAgIHN0ZDo6X191bmluaXRp YWxpemVkX2NvcHlfYShfX2ZpcnN0LCBfX2xhc3QsCi0JCQkJCXRoaXMtPl9NX2ltcGwuX01f c3RhcnQsCi0JCQkJCV9NX2dldF9UcF9hbGxvY2F0b3IoKSk7CisJICBwb2ludGVyIF9fc3Rh cnQgPQorCSAgICB0aGlzLT5fTV9hbGxvY2F0ZShfU19jaGVja19pbml0X2xlbihfX24sIF9N X2dldF9UcF9hbGxvY2F0b3IoKSkpOworCSAgX0d1YXJkX2FsbG9jIF9fZ3VhcmQoX19zdGFy dCwgX19uLCAqdGhpcyk7CisJICB0aGlzLT5fTV9pbXBsLl9NX2ZpbmlzaCA9IHN0ZDo6X191 bmluaXRpYWxpemVkX2NvcHlfYQorCSAgICAoX19maXJzdCwgX19sYXN0LCBfX3N0YXJ0LCBf TV9nZXRfVHBfYWxsb2NhdG9yKCkpOworCSAgdGhpcy0+X01faW1wbC5fTV9zdGFydCA9IF9f c3RhcnQ7CisJICAodm9pZCkgX19ndWFyZC5fTV9yZWxlYXNlKCk7CisJICB0aGlzLT5fTV9p bXBsLl9NX2VuZF9vZl9zdG9yYWdlID0gX19zdGFydCArIF9fbjsKIAl9CiAKLSAgICAgIC8v IENhbGxlZCBieSB0aGUgZmlyc3QgaW5pdGlhbGl6ZV9kaXNwYXRjaCBhYm92ZSBhbmQgYnkg dGhlCi0gICAgICAvLyB2ZWN0b3Iobix2YWx1ZSxhKSBjb25zdHJ1Y3Rvci4KKyAgICAgIC8v IENhbGxlZCBieSB0aGUgdmVjdG9yKG4sdmFsdWUsYSkgY29uc3RydWN0b3IuCiAgICAgICBf R0xJQkNYWDIwX0NPTlNURVhQUgogICAgICAgdm9pZAogICAgICAgX01fZmlsbF9pbml0aWFs aXplKHNpemVfdHlwZSBfX24sIGNvbnN0IHZhbHVlX3R5cGUmIF9fdmFsdWUpCmRpZmYgLS1n aXQgYS9saWJzdGRjKystdjMvaW5jbHVkZS9iaXRzL3ZlY3Rvci50Y2MgYi9saWJzdGRjKyst djMvaW5jbHVkZS9iaXRzL3ZlY3Rvci50Y2MKaW5kZXggMjVkZjA2MGJlZWUuLjM2YjI3ZGNl N2I5IDEwMDY0NAotLS0gYS9saWJzdGRjKystdjMvaW5jbHVkZS9iaXRzL3ZlY3Rvci50Y2MK KysrIGIvbGlic3RkYysrLXYzL2luY2x1ZGUvYml0cy92ZWN0b3IudGNjCkBAIC00NjcsMzIg KzQ2Nyw4IEBAIF9HTElCQ1hYX0JFR0lOX05BTUVTUEFDRV9DT05UQUlORVIKICAgICAgIHBv aW50ZXIgX19uZXdfc3RhcnQodGhpcy0+X01fYWxsb2NhdGUoX19sZW4pKTsKICAgICAgIHBv aW50ZXIgX19uZXdfZmluaXNoKF9fbmV3X3N0YXJ0KTsKIAotICAgICAgLy8gUkFJSSBndWFy ZCBmb3IgYWxsb2NhdGVkIHN0b3JhZ2UuCi0gICAgICBzdHJ1Y3QgX0d1YXJkCiAgICAgICB7 Ci0JcG9pbnRlciBfTV9zdG9yYWdlOwkgICAgLy8gU3RvcmFnZSB0byBkZWFsbG9jYXRlCi0J c2l6ZV90eXBlIF9NX2xlbjsKLQlfVHBfYWxsb2NfdHlwZSYgX01fYWxsb2M7Ci0KLQlfR0xJ QkNYWDIwX0NPTlNURVhQUgotCV9HdWFyZChwb2ludGVyIF9fcywgc2l6ZV90eXBlIF9fbCwg X1RwX2FsbG9jX3R5cGUmIF9fYSkKLQk6IF9NX3N0b3JhZ2UoX19zKSwgX01fbGVuKF9fbCks IF9NX2FsbG9jKF9fYSkKLQl7IH0KLQotCV9HTElCQ1hYMjBfQ09OU1RFWFBSCi0Jfl9HdWFy ZCgpCi0JewotCSAgaWYgKF9NX3N0b3JhZ2UpCi0JICAgIF9fZ251X2N4eDo6X19hbGxvY190 cmFpdHM8X1RwX2FsbG9jX3R5cGU+OjoKLQkgICAgICBkZWFsbG9jYXRlKF9NX2FsbG9jLCBf TV9zdG9yYWdlLCBfTV9sZW4pOwotCX0KLQotICAgICAgcHJpdmF0ZToKLQlfR3VhcmQoY29u c3QgX0d1YXJkJik7Ci0gICAgICB9OwotCi0gICAgICB7Ci0JX0d1YXJkIF9fZ3VhcmQoX19u ZXdfc3RhcnQsIF9fbGVuLCBfTV9pbXBsKTsKKwlfR3VhcmRfYWxsb2MgX19ndWFyZChfX25l d19zdGFydCwgX19sZW4sICp0aGlzKTsKIAogCS8vIFRoZSBvcmRlciBvZiB0aGUgdGhyZWUg b3BlcmF0aW9ucyBpcyBkaWN0YXRlZCBieSB0aGUgQysrMTEKIAkvLyBjYXNlLCB3aGVyZSB0 aGUgbW92ZXMgY291bGQgYWx0ZXIgYSBuZXcgZWxlbWVudCBiZWxvbmdpbmcKQEAgLTU5Niwz MiArNTcyLDggQEAgX0dMSUJDWFhfQkVHSU5fTkFNRVNQQUNFX0NPTlRBSU5FUgogICAgICAg cG9pbnRlciBfX25ld19zdGFydCh0aGlzLT5fTV9hbGxvY2F0ZShfX2xlbikpOwogICAgICAg cG9pbnRlciBfX25ld19maW5pc2goX19uZXdfc3RhcnQpOwogCi0gICAgICAvLyBSQUlJIGd1 YXJkIGZvciBhbGxvY2F0ZWQgc3RvcmFnZS4KLSAgICAgIHN0cnVjdCBfR3VhcmQKICAgICAg IHsKLQlwb2ludGVyIF9NX3N0b3JhZ2U7CSAgICAvLyBTdG9yYWdlIHRvIGRlYWxsb2NhdGUK LQlzaXplX3R5cGUgX01fbGVuOwotCV9UcF9hbGxvY190eXBlJiBfTV9hbGxvYzsKLQotCV9H TElCQ1hYMjBfQ09OU1RFWFBSCi0JX0d1YXJkKHBvaW50ZXIgX19zLCBzaXplX3R5cGUgX19s LCBfVHBfYWxsb2NfdHlwZSYgX19hKQotCTogX01fc3RvcmFnZShfX3MpLCBfTV9sZW4oX19s KSwgX01fYWxsb2MoX19hKQotCXsgfQotCi0JX0dMSUJDWFgyMF9DT05TVEVYUFIKLQl+X0d1 YXJkKCkKLQl7Ci0JICBpZiAoX01fc3RvcmFnZSkKLQkgICAgX19nbnVfY3h4OjpfX2FsbG9j X3RyYWl0czxfVHBfYWxsb2NfdHlwZT46OgotCSAgICAgIGRlYWxsb2NhdGUoX01fYWxsb2Ms IF9NX3N0b3JhZ2UsIF9NX2xlbik7Ci0JfQotCi0gICAgICBwcml2YXRlOgotCV9HdWFyZChj b25zdCBfR3VhcmQmKTsKLSAgICAgIH07Ci0KLSAgICAgIHsKLQlfR3VhcmQgX19ndWFyZChf X25ld19zdGFydCwgX19sZW4sIF9NX2ltcGwpOworCV9HdWFyZF9hbGxvYyBfX2d1YXJkKF9f bmV3X3N0YXJ0LCBfX2xlbiwgKnRoaXMpOwogCiAJLy8gVGhlIG9yZGVyIG9mIHRoZSB0aHJl ZSBvcGVyYXRpb25zIGlzIGRpY3RhdGVkIGJ5IHRoZSBDKysxMQogCS8vIGNhc2UsIHdoZXJl IHRoZSBtb3ZlcyBjb3VsZCBhbHRlciBhIG5ldyBlbGVtZW50IGJlbG9uZ2luZwpAQCAtODMz LDMyICs3ODUsOCBAQCBfR0xJQkNYWF9CRUdJTl9OQU1FU1BBQ0VfQ09OVEFJTkVSCiAJCV9N X2NoZWNrX2xlbihfX24sICJ2ZWN0b3I6Ol9NX2RlZmF1bHRfYXBwZW5kIik7CiAJICAgICAg cG9pbnRlciBfX25ld19zdGFydCh0aGlzLT5fTV9hbGxvY2F0ZShfX2xlbikpOwogCi0JICAg ICAgLy8gUkFJSSBndWFyZCBmb3IgYWxsb2NhdGVkIHN0b3JhZ2UuCi0JICAgICAgc3RydWN0 IF9HdWFyZAotCSAgICAgIHsKLQkJcG9pbnRlciBfTV9zdG9yYWdlOyAgICAgICAgIC8vIFN0 b3JhZ2UgdG8gZGVhbGxvY2F0ZQotCQlzaXplX3R5cGUgX01fbGVuOwotCQlfVHBfYWxsb2Nf dHlwZSYgX01fYWxsb2M7Ci0KLQkJX0dMSUJDWFgyMF9DT05TVEVYUFIKLQkJX0d1YXJkKHBv aW50ZXIgX19zLCBzaXplX3R5cGUgX19sLCBfVHBfYWxsb2NfdHlwZSYgX19hKQotCQk6IF9N X3N0b3JhZ2UoX19zKSwgX01fbGVuKF9fbCksIF9NX2FsbG9jKF9fYSkKLQkJeyB9Ci0KLQkJ X0dMSUJDWFgyMF9DT05TVEVYUFIKLQkJfl9HdWFyZCgpCi0JCXsKLQkJICBpZiAoX01fc3Rv cmFnZSkKLQkJICAgIF9fZ251X2N4eDo6X19hbGxvY190cmFpdHM8X1RwX2FsbG9jX3R5cGU+ OjoKLQkJICAgICAgZGVhbGxvY2F0ZShfTV9hbGxvYywgX01fc3RvcmFnZSwgX01fbGVuKTsK LQkJfQotCi0JICAgICAgcHJpdmF0ZToKLQkJX0d1YXJkKGNvbnN0IF9HdWFyZCYpOwotCSAg ICAgIH07Ci0KIAkgICAgICB7Ci0JCV9HdWFyZCBfX2d1YXJkKF9fbmV3X3N0YXJ0LCBfX2xl biwgX01faW1wbCk7CisJCV9HdWFyZF9hbGxvYyBfX2d1YXJkKF9fbmV3X3N0YXJ0LCBfX2xl biwgKnRoaXMpOwogCiAJCXN0ZDo6X191bmluaXRpYWxpemVkX2RlZmF1bHRfbl9hKF9fbmV3 X3N0YXJ0ICsgX19zaXplLCBfX24sCiAJCQkJCQkgX01fZ2V0X1RwX2FsbG9jYXRvcigpKTsK --------------ACIs6JaksGxxkYWg6DCaiHaq--