From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wr1-x434.google.com (mail-wr1-x434.google.com [IPv6:2a00:1450:4864:20::434]) by sourceware.org (Postfix) with ESMTPS id 7923A3858D37; Mon, 27 May 2024 04:37:14 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 7923A3858D37 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 7923A3858D37 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::434 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1716784637; cv=none; b=rze+tTtYlaRXepDXY2wpVo5n6xl5+0twO77iZcJXeA6xrAz2zrGp+oYnqcMXPzUwLTYorZ+UFlJVC4x2xrqLIZbTjUFTwOgBIfHpHeqkrUAmtkJFMs5nCWgoIYSfvcOV4b8bddaCCa5S1Ip9MVvgXu2mzZ46rbuithDpMk8Eios= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1716784637; c=relaxed/simple; bh=tuJbUPI6jpsOCe7wtkX3Wk5pxe15uDUIlSBOmlqmBQU=; h=DKIM-Signature:Message-ID:Date:MIME-Version:Subject:To:From; b=pR81AJZppNU2D0bXQJvT6ZI0CDpWKVsfd7pyG6iNmIzdiY3Vwti0/D2gbpPps0pvm7/c7I8pr4gmwN1kXXgHrUBb53ahvvKN1iUedb9shBUgU46VBF/dnP8L1qW2QbyjKQwlE7AwCyq/+WaRxGwkoPyKhTR3N9DUYgzIvxnRB88= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-wr1-x434.google.com with SMTP id ffacd0b85a97d-354be94c874so3763922f8f.3; Sun, 26 May 2024 21:37:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1716784633; x=1717389433; 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=VGyjrInsowlMrsOiqbdXn0WrHVIBkFk9Q1bW14V30vQ=; b=HNBuhUy/4vufnRY+44UmuW73e1P34T48HtSnwLFhWlkKIP7XL/9JsNXzsNjsHarYOf NkxMHGiq/pAioOp3hHoj2kNuove3T4C+FpIIEYRenH0UPSLMcAAjJRJuMB6s83tNlrwX c3v7dFLqfoHcJD7d2V/HIMMfs9yTjBId+DUHVTUP+IILMpelNi2h43LJWn02MSFSM018 VPrgC43h5HFFmPRTJvtP/KewVWtO6k+URFrkQow2a7pTL+ueSwTSTtX9ciu+kKnUSRQn WuwhO996q/NnYJ3mfSnBAlFWTlXu5SGo/ni8AyW9eaaS0USBFd76bTT1B7ZjaXcTT1aJ 2FFw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1716784633; x=1717389433; 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=VGyjrInsowlMrsOiqbdXn0WrHVIBkFk9Q1bW14V30vQ=; b=BDxVZnvB+1YbR7LvGkLWsgJ8h2IaNS+wqLuEAE7lDd/vPDaoRD3WQkatwAsOqlZHia Ys26HAPWPiOHQFGGpNgWgHbKZGMWPpARouszM2QGruPGB77YYRCcWTVfGRlpmu6h4qzz Kk95REvSw4fMMSBVOwTcxzbFxb+5cA60nGaH88oVpUHGq7z92jxjrI/BkvbpsvUn20m4 wf6t1zi3CT3xsPR54uWkLqCA49Vlr4Tnigr32l5/21UbyDJhFixbt7zrAVmWP740Iu3f okScN8QbWWeOdpCAYfKplSsC7bfz62ZPEZUEaK1PuXF+QMH/xXeFHf8PRWnCL78kehHe Fgsw== X-Forwarded-Encrypted: i=1; AJvYcCVGchbSLCZsV2DqpK5isnyU4wm4IgeGTyKxEPz83t39U27/gfI4+x0a36WkZWqIryxziNl1gBHenFdqiWLLdlYYxyATxZ5oMg== X-Gm-Message-State: AOJu0Yzxeis3bmz4XVtgEA0agQPRWUZAsU6VMaAssXUkRrU4WY0knfxd +tIfYX+0Kfko/5/sapje+k1IWBh5c0EG8QuHjyWjkie2m+jqIpMt X-Google-Smtp-Source: AGHT+IHC3uSNfhFD+8YWIw7xAsBeEaGdOx/6SiWMINe29Rs5V9RV49QN8ik6mU7BCzbAm5XCH/dTaA== X-Received: by 2002:a05:6000:4026:b0:357:393d:5006 with SMTP id ffacd0b85a97d-357393d5048mr6158293f8f.7.1716784632776; Sun, 26 May 2024 21:37:12 -0700 (PDT) Received: from [10.57.0.48] ([89.207.171.133]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-35579d7ed6fsm7879667f8f.9.2024.05.26.21.37.11 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Sun, 26 May 2024 21:37:12 -0700 (PDT) Content-Type: multipart/mixed; boundary="------------URf0XVmNdlx4zz0DHJm8EACN" Message-ID: <610e3afa-8a8a-400d-882e-41ec186d67f6@gmail.com> Date: Mon, 27 May 2024 06:37:10 +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=-10.9 required=5.0 tests=BAYES_00,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. --------------URf0XVmNdlx4zz0DHJm8EACN Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Here is a new version working also in C++98. 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. 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! > --------------URf0XVmNdlx4zz0DHJm8EACN Content-Type: text/plain; charset=UTF-8; name="vector_patch.txt" Content-Disposition: attachment; filename="vector_patch.txt" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2xpYnN0ZGMrKy12My9pbmNsdWRlL2JpdHMvc3RsX3ZlY3Rvci5oIGIv bGlic3RkYysrLXYzL2luY2x1ZGUvYml0cy9zdGxfdmVjdG9yLmgKaW5kZXggMzExNjk3MTFh NDguLjgxZmUzODI1MDY0IDEwMDY0NAotLS0gYS9saWJzdGRjKystdjMvaW5jbHVkZS9iaXRz 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 NDIsMTMgKzE2NjcsMTggQEAgX0dMSUJDWFhfQkVHSU5fTkFNRVNQQUNFX0NPTlRBSU5FUgog ICAgICAgLy8gNDM4LiBBbWJpZ3VpdHkgaW4gdGhlICJkbyB0aGUgcmlnaHQgdGhpbmciIGNs YXVzZQogICAgICAgdGVtcGxhdGU8dHlwZW5hbWUgX0ludGVnZXI+CiAJdm9pZAotCV9NX2lu aXRpYWxpemVfZGlzcGF0Y2goX0ludGVnZXIgX19uLCBfSW50ZWdlciBfX3ZhbHVlLCBfX3Ry dWVfdHlwZSkKKwlfTV9pbml0aWFsaXplX2Rpc3BhdGNoKF9JbnRlZ2VyIF9faW50X24sIF9J bnRlZ2VyIF9fdmFsdWUsIF9fdHJ1ZV90eXBlKQogCXsKLQkgIHRoaXMtPl9NX2ltcGwuX01f c3RhcnQgPSBfTV9hbGxvY2F0ZShfU19jaGVja19pbml0X2xlbigKLQkJc3RhdGljX2Nhc3Q8 c2l6ZV90eXBlPihfX24pLCBfTV9nZXRfVHBfYWxsb2NhdG9yKCkpKTsKLQkgIHRoaXMtPl9N X2ltcGwuX01fZW5kX29mX3N0b3JhZ2UgPQotCSAgICB0aGlzLT5fTV9pbXBsLl9NX3N0YXJ0 ICsgc3RhdGljX2Nhc3Q8c2l6ZV90eXBlPihfX24pOwotCSAgX01fZmlsbF9pbml0aWFsaXpl KHN0YXRpY19jYXN0PHNpemVfdHlwZT4oX19uKSwgX192YWx1ZSk7CisJICBjb25zdCBzaXpl X3R5cGUgX19uID0gc3RhdGljX2Nhc3Q8c2l6ZV90eXBlPihfX2ludF9uKTsKKwkgIHBvaW50 ZXIgX19zdGFydCA9CisJICAgIF9NX2FsbG9jYXRlKF9TX2NoZWNrX2luaXRfbGVuKF9fbiwg X01fZ2V0X1RwX2FsbG9jYXRvcigpKSk7CisJICBfR3VhcmRfYWxsb2MgX19ndWFyZChfX3N0 YXJ0LCBfX24sICp0aGlzKTsKKwkgIHRoaXMtPl9NX2ltcGwuX01fZmluaXNoID0KKwkgICAg c3RkOjpfX3VuaW5pdGlhbGl6ZWRfZmlsbF9uX2E8cG9pbnRlciwgc2l6ZV90eXBlLCB2YWx1 ZV90eXBlPgorCSAgICAoX19zdGFydCwgX19uLCBfX3ZhbHVlLCBfTV9nZXRfVHBfYWxsb2Nh dG9yKCkpOworCSAgdGhpcy0+X01faW1wbC5fTV9zdGFydCA9IF9fc3RhcnQ7CisJICAodm9p ZCkgX19ndWFyZC5fTV9yZWxlYXNlKCk7CisJICB0aGlzLT5fTV9pbXBsLl9NX2VuZF9vZl9z dG9yYWdlID0gX19zdGFydCArIF9fbjsKIAl9CiAKICAgICAgIC8vIENhbGxlZCBieSB0aGUg cmFuZ2UgY29uc3RydWN0b3IgdG8gaW1wbGVtZW50IFsyMy4xLjFdLzkKQEAgLTE2OTAsMTcg KzE3MjAsMTcgQEAgX0dMSUJDWFhfQkVHSU5fTkFNRVNQQUNFX0NPTlRBSU5FUgogCQkJICAg IHN0ZDo6Zm9yd2FyZF9pdGVyYXRvcl90YWcpCiAJewogCSAgY29uc3Qgc2l6ZV90eXBlIF9f biA9IHN0ZDo6ZGlzdGFuY2UoX19maXJzdCwgX19sYXN0KTsKLQkgIHRoaXMtPl9NX2ltcGwu X01fc3RhcnQKLQkgICAgPSB0aGlzLT5fTV9hbGxvY2F0ZShfU19jaGVja19pbml0X2xlbihf X24sIF9NX2dldF9UcF9hbGxvY2F0b3IoKSkpOwotCSAgdGhpcy0+X01faW1wbC5fTV9lbmRf b2Zfc3RvcmFnZSA9IHRoaXMtPl9NX2ltcGwuX01fc3RhcnQgKyBfX247Ci0JICB0aGlzLT5f TV9pbXBsLl9NX2ZpbmlzaCA9Ci0JICAgIHN0ZDo6X191bmluaXRpYWxpemVkX2NvcHlfYShf X2ZpcnN0LCBfX2xhc3QsCi0JCQkJCXRoaXMtPl9NX2ltcGwuX01fc3RhcnQsCi0JCQkJCV9N X2dldF9UcF9hbGxvY2F0b3IoKSk7CisJICBwb2ludGVyIF9fc3RhcnQgPQorCSAgICB0aGlz LT5fTV9hbGxvY2F0ZShfU19jaGVja19pbml0X2xlbihfX24sIF9NX2dldF9UcF9hbGxvY2F0 b3IoKSkpOworCSAgX0d1YXJkX2FsbG9jIF9fZ3VhcmQoX19zdGFydCwgX19uLCAqdGhpcyk7 CisJICB0aGlzLT5fTV9pbXBsLl9NX2ZpbmlzaCA9IHN0ZDo6X191bmluaXRpYWxpemVkX2Nv cHlfYQorCSAgICAoX19maXJzdCwgX19sYXN0LCBfX3N0YXJ0LCBfTV9nZXRfVHBfYWxsb2Nh dG9yKCkpOworCSAgdGhpcy0+X01faW1wbC5fTV9zdGFydCA9IF9fc3RhcnQ7CisJICAodm9p ZCkgX19ndWFyZC5fTV9yZWxlYXNlKCk7CisJICB0aGlzLT5fTV9pbXBsLl9NX2VuZF9vZl9z dG9yYWdlID0gX19zdGFydCArIF9fbjsKIAl9CiAKLSAgICAgIC8vIENhbGxlZCBieSB0aGUg Zmlyc3QgaW5pdGlhbGl6ZV9kaXNwYXRjaCBhYm92ZSBhbmQgYnkgdGhlCi0gICAgICAvLyB2 ZWN0b3Iobix2YWx1ZSxhKSBjb25zdHJ1Y3Rvci4KKyAgICAgIC8vIENhbGxlZCBieSB0aGUg dmVjdG9yKG4sdmFsdWUsYSkgY29uc3RydWN0b3IuCiAgICAgICBfR0xJQkNYWDIwX0NPTlNU RVhQUgogICAgICAgdm9pZAogICAgICAgX01fZmlsbF9pbml0aWFsaXplKHNpemVfdHlwZSBf X24sIGNvbnN0IHZhbHVlX3R5cGUmIF9fdmFsdWUpCmRpZmYgLS1naXQgYS9saWJzdGRjKyst djMvaW5jbHVkZS9iaXRzL3ZlY3Rvci50Y2MgYi9saWJzdGRjKystdjMvaW5jbHVkZS9iaXRz L3ZlY3Rvci50Y2MKaW5kZXggMjVkZjA2MGJlZWUuLjM2YjI3ZGNlN2I5IDEwMDY0NAotLS0g YS9saWJzdGRjKystdjMvaW5jbHVkZS9iaXRzL3ZlY3Rvci50Y2MKKysrIGIvbGlic3RkYysr LXYzL2luY2x1ZGUvYml0cy92ZWN0b3IudGNjCkBAIC00NjcsMzIgKzQ2Nyw4IEBAIF9HTElC Q1hYX0JFR0lOX05BTUVTUEFDRV9DT05UQUlORVIKICAgICAgIHBvaW50ZXIgX19uZXdfc3Rh cnQodGhpcy0+X01fYWxsb2NhdGUoX19sZW4pKTsKICAgICAgIHBvaW50ZXIgX19uZXdfZmlu aXNoKF9fbmV3X3N0YXJ0KTsKIAotICAgICAgLy8gUkFJSSBndWFyZCBmb3IgYWxsb2NhdGVk IHN0b3JhZ2UuCi0gICAgICBzdHJ1Y3QgX0d1YXJkCiAgICAgICB7Ci0JcG9pbnRlciBfTV9z dG9yYWdlOwkgICAgLy8gU3RvcmFnZSB0byBkZWFsbG9jYXRlCi0Jc2l6ZV90eXBlIF9NX2xl bjsKLQlfVHBfYWxsb2NfdHlwZSYgX01fYWxsb2M7Ci0KLQlfR0xJQkNYWDIwX0NPTlNURVhQ UgotCV9HdWFyZChwb2ludGVyIF9fcywgc2l6ZV90eXBlIF9fbCwgX1RwX2FsbG9jX3R5cGUm IF9fYSkKLQk6IF9NX3N0b3JhZ2UoX19zKSwgX01fbGVuKF9fbCksIF9NX2FsbG9jKF9fYSkK LQl7IH0KLQotCV9HTElCQ1hYMjBfQ09OU1RFWFBSCi0Jfl9HdWFyZCgpCi0JewotCSAgaWYg KF9NX3N0b3JhZ2UpCi0JICAgIF9fZ251X2N4eDo6X19hbGxvY190cmFpdHM8X1RwX2FsbG9j X3R5cGU+OjoKLQkgICAgICBkZWFsbG9jYXRlKF9NX2FsbG9jLCBfTV9zdG9yYWdlLCBfTV9s ZW4pOwotCX0KLQotICAgICAgcHJpdmF0ZToKLQlfR3VhcmQoY29uc3QgX0d1YXJkJik7Ci0g ICAgICB9OwotCi0gICAgICB7Ci0JX0d1YXJkIF9fZ3VhcmQoX19uZXdfc3RhcnQsIF9fbGVu LCBfTV9pbXBsKTsKKwlfR3VhcmRfYWxsb2MgX19ndWFyZChfX25ld19zdGFydCwgX19sZW4s ICp0aGlzKTsKIAogCS8vIFRoZSBvcmRlciBvZiB0aGUgdGhyZWUgb3BlcmF0aW9ucyBpcyBk aWN0YXRlZCBieSB0aGUgQysrMTEKIAkvLyBjYXNlLCB3aGVyZSB0aGUgbW92ZXMgY291bGQg YWx0ZXIgYSBuZXcgZWxlbWVudCBiZWxvbmdpbmcKQEAgLTU5NiwzMiArNTcyLDggQEAgX0dM SUJDWFhfQkVHSU5fTkFNRVNQQUNFX0NPTlRBSU5FUgogICAgICAgcG9pbnRlciBfX25ld19z dGFydCh0aGlzLT5fTV9hbGxvY2F0ZShfX2xlbikpOwogICAgICAgcG9pbnRlciBfX25ld19m aW5pc2goX19uZXdfc3RhcnQpOwogCi0gICAgICAvLyBSQUlJIGd1YXJkIGZvciBhbGxvY2F0 ZWQgc3RvcmFnZS4KLSAgICAgIHN0cnVjdCBfR3VhcmQKICAgICAgIHsKLQlwb2ludGVyIF9N X3N0b3JhZ2U7CSAgICAvLyBTdG9yYWdlIHRvIGRlYWxsb2NhdGUKLQlzaXplX3R5cGUgX01f bGVuOwotCV9UcF9hbGxvY190eXBlJiBfTV9hbGxvYzsKLQotCV9HTElCQ1hYMjBfQ09OU1RF WFBSCi0JX0d1YXJkKHBvaW50ZXIgX19zLCBzaXplX3R5cGUgX19sLCBfVHBfYWxsb2NfdHlw ZSYgX19hKQotCTogX01fc3RvcmFnZShfX3MpLCBfTV9sZW4oX19sKSwgX01fYWxsb2MoX19h KQotCXsgfQotCi0JX0dMSUJDWFgyMF9DT05TVEVYUFIKLQl+X0d1YXJkKCkKLQl7Ci0JICBp ZiAoX01fc3RvcmFnZSkKLQkgICAgX19nbnVfY3h4OjpfX2FsbG9jX3RyYWl0czxfVHBfYWxs b2NfdHlwZT46OgotCSAgICAgIGRlYWxsb2NhdGUoX01fYWxsb2MsIF9NX3N0b3JhZ2UsIF9N X2xlbik7Ci0JfQotCi0gICAgICBwcml2YXRlOgotCV9HdWFyZChjb25zdCBfR3VhcmQmKTsK LSAgICAgIH07Ci0KLSAgICAgIHsKLQlfR3VhcmQgX19ndWFyZChfX25ld19zdGFydCwgX19s ZW4sIF9NX2ltcGwpOworCV9HdWFyZF9hbGxvYyBfX2d1YXJkKF9fbmV3X3N0YXJ0LCBfX2xl biwgKnRoaXMpOwogCiAJLy8gVGhlIG9yZGVyIG9mIHRoZSB0aHJlZSBvcGVyYXRpb25zIGlz IGRpY3RhdGVkIGJ5IHRoZSBDKysxMQogCS8vIGNhc2UsIHdoZXJlIHRoZSBtb3ZlcyBjb3Vs ZCBhbHRlciBhIG5ldyBlbGVtZW50IGJlbG9uZ2luZwpAQCAtODMzLDMyICs3ODUsOCBAQCBf R0xJQkNYWF9CRUdJTl9OQU1FU1BBQ0VfQ09OVEFJTkVSCiAJCV9NX2NoZWNrX2xlbihfX24s ICJ2ZWN0b3I6Ol9NX2RlZmF1bHRfYXBwZW5kIik7CiAJICAgICAgcG9pbnRlciBfX25ld19z dGFydCh0aGlzLT5fTV9hbGxvY2F0ZShfX2xlbikpOwogCi0JICAgICAgLy8gUkFJSSBndWFy ZCBmb3IgYWxsb2NhdGVkIHN0b3JhZ2UuCi0JICAgICAgc3RydWN0IF9HdWFyZAotCSAgICAg IHsKLQkJcG9pbnRlciBfTV9zdG9yYWdlOyAgICAgICAgIC8vIFN0b3JhZ2UgdG8gZGVhbGxv Y2F0ZQotCQlzaXplX3R5cGUgX01fbGVuOwotCQlfVHBfYWxsb2NfdHlwZSYgX01fYWxsb2M7 Ci0KLQkJX0dMSUJDWFgyMF9DT05TVEVYUFIKLQkJX0d1YXJkKHBvaW50ZXIgX19zLCBzaXpl X3R5cGUgX19sLCBfVHBfYWxsb2NfdHlwZSYgX19hKQotCQk6IF9NX3N0b3JhZ2UoX19zKSwg X01fbGVuKF9fbCksIF9NX2FsbG9jKF9fYSkKLQkJeyB9Ci0KLQkJX0dMSUJDWFgyMF9DT05T VEVYUFIKLQkJfl9HdWFyZCgpCi0JCXsKLQkJICBpZiAoX01fc3RvcmFnZSkKLQkJICAgIF9f Z251X2N4eDo6X19hbGxvY190cmFpdHM8X1RwX2FsbG9jX3R5cGU+OjoKLQkJICAgICAgZGVh bGxvY2F0ZShfTV9hbGxvYywgX01fc3RvcmFnZSwgX01fbGVuKTsKLQkJfQotCi0JICAgICAg cHJpdmF0ZToKLQkJX0d1YXJkKGNvbnN0IF9HdWFyZCYpOwotCSAgICAgIH07Ci0KIAkgICAg ICB7Ci0JCV9HdWFyZCBfX2d1YXJkKF9fbmV3X3N0YXJ0LCBfX2xlbiwgX01faW1wbCk7CisJ CV9HdWFyZF9hbGxvYyBfX2d1YXJkKF9fbmV3X3N0YXJ0LCBfX2xlbiwgKnRoaXMpOwogCiAJ CXN0ZDo6X191bmluaXRpYWxpemVkX2RlZmF1bHRfbl9hKF9fbmV3X3N0YXJ0ICsgX19zaXpl LCBfX24sCiAJCQkJCQkgX01fZ2V0X1RwX2FsbG9jYXRvcigpKTsKZGlmZiAtLWdpdCBhL2xp YnN0ZGMrKy12My90ZXN0c3VpdGUvMjNfY29udGFpbmVycy92ZWN0b3IvcmVxdWlyZW1lbnRz L2RyNDM4L2NvbnN0cnVjdG9yXzFfbmVnLmNjIGIvbGlic3RkYysrLXYzL3Rlc3RzdWl0ZS8y M19jb250YWluZXJzL3ZlY3Rvci9yZXF1aXJlbWVudHMvZHI0MzgvY29uc3RydWN0b3JfMV9u ZWcuY2MKaW5kZXggNmIzZDQ4ZjBjOTIuLmQ3MzJjYThiZWQ4IDEwMDY0NAotLS0gYS9saWJz dGRjKystdjMvdGVzdHN1aXRlLzIzX2NvbnRhaW5lcnMvdmVjdG9yL3JlcXVpcmVtZW50cy9k cjQzOC9jb25zdHJ1Y3Rvcl8xX25lZy5jYworKysgYi9saWJzdGRjKystdjMvdGVzdHN1aXRl LzIzX2NvbnRhaW5lcnMvdmVjdG9yL3JlcXVpcmVtZW50cy9kcjQzOC9jb25zdHJ1Y3Rvcl8x X25lZy5jYwpAQCAtMTksNyArMTksNyBAQAogCiAvLyB7IGRnLWRvIGNvbXBpbGUgfQogLy8g eyBkZy1wcnVuZS1vdXRwdXQgImNhbm5vdCBjb252ZXJ0IiB9Ci0vLyB7IGRnLXBydW5lLW91 dHB1dCAibm8gbWF0Y2hpbmcgZnVuY3Rpb24gLipfTV9maWxsX2luaXRpYWxpemUiIH0KKy8v IHsgZGctcHJ1bmUtb3V0cHV0ICJubyBtYXRjaGluZyBmdW5jdGlvbiAuKl9fdW5pbml0aWFs aXplZF9maWxsX25fYSIgfQogCiAjaW5jbHVkZSA8dmVjdG9yPgogCmRpZmYgLS1naXQgYS9s aWJzdGRjKystdjMvdGVzdHN1aXRlLzIzX2NvbnRhaW5lcnMvdmVjdG9yL3JlcXVpcmVtZW50 cy9kcjQzOC9jb25zdHJ1Y3Rvcl8yX25lZy5jYyBiL2xpYnN0ZGMrKy12My90ZXN0c3VpdGUv MjNfY29udGFpbmVycy92ZWN0b3IvcmVxdWlyZW1lbnRzL2RyNDM4L2NvbnN0cnVjdG9yXzJf bmVnLmNjCmluZGV4IDY1Y2UyZmQzMGU1Li41OGM0YzhmOWE3MyAxMDA2NDQKLS0tIGEvbGli c3RkYysrLXYzL3Rlc3RzdWl0ZS8yM19jb250YWluZXJzL3ZlY3Rvci9yZXF1aXJlbWVudHMv ZHI0MzgvY29uc3RydWN0b3JfMl9uZWcuY2MKKysrIGIvbGlic3RkYysrLXYzL3Rlc3RzdWl0 ZS8yM19jb250YWluZXJzL3ZlY3Rvci9yZXF1aXJlbWVudHMvZHI0MzgvY29uc3RydWN0b3Jf Ml9uZWcuY2MKQEAgLTE5LDcgKzE5LDcgQEAKIAogLy8geyBkZy1kbyBjb21waWxlIH0KIC8v IHsgZGctcHJ1bmUtb3V0cHV0ICJjYW5ub3QgY29udmVydCIgfQotLy8geyBkZy1wcnVuZS1v dXRwdXQgIm5vIG1hdGNoaW5nIGZ1bmN0aW9uIC4qX01fZmlsbF9pbml0aWFsaXplIiB9Cisv LyB7IGRnLXBydW5lLW91dHB1dCAibm8gbWF0Y2hpbmcgZnVuY3Rpb24gLipfX3VuaW5pdGlh bGl6ZWRfZmlsbF9uX2EiIH0KIAogI2luY2x1ZGUgPHZlY3Rvcj4KICNpbmNsdWRlIDx1dGls aXR5Pgo= --------------URf0XVmNdlx4zz0DHJm8EACN--