From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wr1-x42a.google.com (mail-wr1-x42a.google.com [IPv6:2a00:1450:4864:20::42a]) by sourceware.org (Postfix) with ESMTPS id 1E10A3856DDA; Wed, 25 May 2022 05:10:01 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 1E10A3856DDA Received: by mail-wr1-x42a.google.com with SMTP id e28so27841735wra.10; Tue, 24 May 2022 22:10:01 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:mime-version:user-agent:subject :content-language:to:cc:references:from:in-reply-to; bh=ooJg/vdsNYdkRjuQcXTGw3SyL48NVNRbZXd2DgZctcc=; b=tDniYIMsf3AGvYnKsDzpMkw6MSsUrEC6OGS2vA9cn5zpWcscwaeuiL/VR657yw2K8c ZVVGqe8KxZfRPgZGYoln0Mz7gIMTzNscCwMBF/xFIQj72JLBBVx9lR1xWEwKEeCzRIZz PVGlJgt0iL2QgYIlgd7QMWDaV/j3m1NVPRF6o63CTUELl4ejchMtMXVCtVkgA55KUpB5 MysyMyp5ugf3MM10LTTunVvuRMjMgCzmWmlKLJ4vtgfW2xK1KQ4R6VnBku29H4QEmtV2 EcSzbXPCosNS8v/JZp9EcRBq+k4B3RdiWUJ9WSZZJjpWnFv/rzgkVTsRfoIZh05TwEgQ Xprw== X-Gm-Message-State: AOAM5339SIz52MFb1s/hsmD8JkxjbrIv4pKQNpqeE6SrgCqu43ozVl7u 1ZFaG38vRQzMWPb2+UwpsH0= X-Google-Smtp-Source: ABdhPJwSmLE6lUiCwpef/h5NqudnCL8xae9kKX7+j6zhyWZEEURVP+0/Voyyivy0qhws9hhUuZ1kpg== X-Received: by 2002:a5d:4312:0:b0:20c:af5f:bdcf with SMTP id h18-20020a5d4312000000b0020caf5fbdcfmr25687933wrq.498.1653455399822; Tue, 24 May 2022 22:09:59 -0700 (PDT) Received: from [10.34.0.172] ([109.190.253.11]) by smtp.googlemail.com with ESMTPSA id 10-20020a05600c230a00b003974ca9fa6dsm3653455wmo.2.2022.05.24.22.09.58 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 24 May 2022 22:09:59 -0700 (PDT) Content-Type: multipart/mixed; boundary="------------SAOU2tgvU0izOYolY9k9uOvP" Message-ID: Date: Wed, 25 May 2022 07:09:57 +0200 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101 Thunderbird/91.8.1 Subject: Re: [PATCH][_Hashtable] Fix insertion of range of type convertible to value_type PR 105714 Content-Language: fr To: Jonathan Wakely Cc: "libstdc++@gcc.gnu.org" , gcc-patches References: <2fe3937d-1b9a-a547-bb41-225d3d5426a2@gmail.com> From: =?UTF-8?Q?Fran=c3=a7ois_Dumont?= In-Reply-To: X-Spam-Status: No, score=-8.2 required=5.0 tests=BAYES_00, BODY_8BITS, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, KAM_NUMSUBJECT, KAM_SHORT, NICE_REPLY_A, RCVD_IN_BARRACUDACENTRAL, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE, URI_HEX autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: libstdc++@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++ mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 25 May 2022 05:10:04 -0000 This is a multi-part message in MIME format. --------------SAOU2tgvU0izOYolY9k9uOvP Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Here is the patch to fix just what is described in PR 105714.     libstdc++: [_Hashtable] Insert range of types convertible to value_type PR 105714     Fix insertion of range of types convertible to value_type.     libstdc++-v3/ChangeLog:             PR libstdc++/105714             * include/bits/hashtable_policy.h (_ValueTypeEnforcer): New.             * include/bits/hashtable.h (_Hashtable<>::_M_insert_unique_aux): New.             (_Hashtable<>::_M_insert(_Arg&&, const _NodeGenerator&, true_type)): Use latters.             (_Hashtable<>::_M_insert(_Arg&&, const _NodeGenerator&, false_type)): Likewise.             (_Hashtable(_InputIterator, _InputIterator, size_type, const _Hash&, const _Equal&,             const allocator_type&, true_type)): Use this.insert range.             (_Hashtable(_InputIterator, _InputIterator, size_type, const _Hash&, const _Equal&,             const allocator_type&, false_type)): Use _M_insert.             * testsuite/23_containers/unordered_map/cons/56112.cc: Check how many times conversion             is done.             * testsuite/23_containers/unordered_map/insert/105714.cc: New test.             * testsuite/23_containers/unordered_set/insert/105714.cc: New test. Tested under Linux x64, ok to commit ? François On 24/05/22 12:31, Jonathan Wakely wrote: > On Tue, 24 May 2022 at 11:22, Jonathan Wakely wrote: >> On Tue, 24 May 2022 at 11:18, Jonathan Wakely wrote: >>> On Thu, 5 May 2022 at 18:38, François Dumont via Libstdc++ >>> wrote: >>>> Hi >>>> >>>> Renewing my patch to fix PR 56112 but for the insert methods, I totally >>>> change it, now works also with move-only key types. >>>> >>>> I let you Jonathan find a better name than _ValueTypeEnforcer as usual :-) >>>> >>>> libstdc++: [_Hashtable] Insert range of types convertible to value_type >>>> PR 56112 >>>> >>>> Fix insertion of range of types convertible to value_type. Fix also when >>>> this value_type >>>> has a move-only key_type which also allow converted values to be moved. >>>> >>>> libstdc++-v3/ChangeLog: >>>> >>>> PR libstdc++/56112 >>>> * include/bits/hashtable_policy.h (_ValueTypeEnforcer): New. >>>> * include/bits/hashtable.h >>>> (_Hashtable<>::_M_insert_unique_aux): New. >>>> (_Hashtable<>::_M_insert(_Arg&&, const _NodeGenerator&, >>>> true_type)): Use latters. >>>> (_Hashtable<>::_M_insert(_Arg&&, const _NodeGenerator&, >>>> false_type)): Likewise. >>>> (_Hashtable(_InputIterator, _InputIterator, size_type, const >>>> _Hash&, const _Equal&, >>>> const allocator_type&, true_type)): Use this.insert range. >>>> (_Hashtable(_InputIterator, _InputIterator, size_type, const >>>> _Hash&, const _Equal&, >>>> const allocator_type&, false_type)): Use _M_insert. >>>> * testsuite/23_containers/unordered_map/cons/56112.cc: Check >>>> how many times conversion >>>> is done. >>>> (test02): New test case. >>>> * testsuite/23_containers/unordered_set/cons/56112.cc: New test. >>>> >>>> Tested under Linux x86_64. >>>> >>>> Ok to commit ? >>> No, sorry. >>> >>> The new test02 function in 23_containers/unordered_map/cons/56112.cc >>> doesn't compile with libc++ or MSVC either, are you sure that test is >>> valid? I don't think it is, because S2 is not convertible to >>> pair. None of the pair constructors are >>> viable, because the move constructor would require two user-defined >>> conversions (from S2 to pair and then from >>> pair to pair). A conversion >>> sequence cannot have more than one user-defined conversion using a >>> constructor or converion operator. So if your patch makes that >>> compile, it's a bug in the new code. I haven't analyzed that code to >>> see where the problem is, I'm just looking at the test results and the >>> changes in behaviour. >> I meant to include this link showing that libc++ and MSVC reject >> test02() as well: >> >> https://godbolt.org/z/j7E9f6bd4 > I've created https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105717 for > the insertion bug, rather than reopening PR 56112. > --------------SAOU2tgvU0izOYolY9k9uOvP Content-Type: text/x-patch; charset=UTF-8; name="pr105714.patch" Content-Disposition: attachment; filename="pr105714.patch" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2xpYnN0ZGMrKy12My9pbmNsdWRlL2JpdHMvaGFzaHRhYmxlLmggYi9s aWJzdGRjKystdjMvaW5jbHVkZS9iaXRzL2hhc2h0YWJsZS5oCmluZGV4IDVlMWE0MTdmN2Nk Li5jZDQyZDNjOWJhMCAxMDA2NDQKLS0tIGEvbGlic3RkYysrLXYzL2luY2x1ZGUvYml0cy9o YXNodGFibGUuaAorKysgYi9saWJzdGRjKystdjMvaW5jbHVkZS9iaXRzL2hhc2h0YWJsZS5o CkBAIC04OTgsMjEgKzg5OCwzMyBAQCBfR0xJQkNYWF9CRUdJTl9OQU1FU1BBQ0VfVkVSU0lP TgogCiAgICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBfQXJnLCB0eXBlbmFtZSBfTm9kZUdlbmVy YXRvcj4KIAlzdGQ6OnBhaXI8aXRlcmF0b3IsIGJvb2w+Ci0JX01faW5zZXJ0KF9BcmcmJiBf X2FyZywgY29uc3QgX05vZGVHZW5lcmF0b3ImIF9fbm9kZV9nZW4sCi0JCSAgdHJ1ZV90eXBl IC8qIF9fdWtzICovKQorCV9NX2luc2VydF91bmlxdWVfYXV4KF9BcmcmJiBfX2FyZywgY29u c3QgX05vZGVHZW5lcmF0b3ImIF9fbm9kZV9nZW4pCiAJewogCSAgcmV0dXJuIF9NX2luc2Vy dF91bmlxdWUoCiAJICAgIF9TX2ZvcndhcmRfa2V5KF9FeHRyYWN0S2V5e30oc3RkOjpmb3J3 YXJkPF9Bcmc+KF9fYXJnKSkpLAogCSAgICBzdGQ6OmZvcndhcmQ8X0FyZz4oX19hcmcpLCBf X25vZGVfZ2VuKTsKIAl9CiAKKyAgICAgIHRlbXBsYXRlPHR5cGVuYW1lIF9BcmcsIHR5cGVu YW1lIF9Ob2RlR2VuZXJhdG9yPgorCXN0ZDo6cGFpcjxpdGVyYXRvciwgYm9vbD4KKwlfTV9p bnNlcnQoX0FyZyYmIF9fYXJnLCBjb25zdCBfTm9kZUdlbmVyYXRvciYgX19ub2RlX2dlbiwK KwkJICB0cnVlX3R5cGUgLyogX191a3MgKi8pCisJeworCSAgdXNpbmcgX190b192YWx1ZQor CSAgICA9IF9fZGV0YWlsOjpfVmFsdWVUeXBlRW5mb3JjZXI8X0V4dHJhY3RLZXksIHZhbHVl X3R5cGU+OworCSAgcmV0dXJuIF9NX2luc2VydF91bmlxdWVfYXV4KAorCSAgICBfX3RvX3Zh bHVle30oc3RkOjpmb3J3YXJkPF9Bcmc+KF9fYXJnKSksIF9fbm9kZV9nZW4pOworCX0KKwog ICAgICAgdGVtcGxhdGU8dHlwZW5hbWUgX0FyZywgdHlwZW5hbWUgX05vZGVHZW5lcmF0b3I+ CiAJaXRlcmF0b3IKIAlfTV9pbnNlcnQoX0FyZyYmIF9fYXJnLCBjb25zdCBfTm9kZUdlbmVy YXRvciYgX19ub2RlX2dlbiwKIAkJICBmYWxzZV90eXBlIF9fdWtzKQogCXsKLQkgIHJldHVy biBfTV9pbnNlcnQoY2VuZCgpLCBzdGQ6OmZvcndhcmQ8X0FyZz4oX19hcmcpLCBfX25vZGVf Z2VuLAotCQkJICAgX191a3MpOworCSAgdXNpbmcgX190b192YWx1ZQorCSAgICA9IF9fZGV0 YWlsOjpfVmFsdWVUeXBlRW5mb3JjZXI8X0V4dHJhY3RLZXksIHZhbHVlX3R5cGU+OworCSAg cmV0dXJuIF9NX2luc2VydChjZW5kKCksCisJICAgIF9fdG9fdmFsdWV7fShzdGQ6OmZvcndh cmQ8X0FyZz4oX19hcmcpKSwgX19ub2RlX2dlbiwgX191a3MpOwogCX0KIAogICAgICAgLy8g SW5zZXJ0IHdpdGggaGludCwgbm90IHVzZWQgd2hlbiBrZXlzIGFyZSB1bmlxdWUuCkBAIC0x MTg0LDEwICsxMTk2LDcgQEAgX0dMSUJDWFhfQkVHSU5fTkFNRVNQQUNFX1ZFUlNJT04KIAkJ IGNvbnN0IF9IYXNoJiBfX2gsIGNvbnN0IF9FcXVhbCYgX19lcSwKIAkJIGNvbnN0IGFsbG9j YXRvcl90eXBlJiBfX2EsIHRydWVfdHlwZSAvKiBfX3VrcyAqLykKICAgICAgIDogX0hhc2h0 YWJsZShfX2JrdF9jb3VudF9oaW50LCBfX2gsIF9fZXEsIF9fYSkKLSAgICAgIHsKLQlmb3Ig KDsgX19mICE9IF9fbDsgKytfX2YpCi0JICB0aGlzLT5pbnNlcnQoKl9fZik7Ci0gICAgICB9 CisgICAgICB7IHRoaXMtPmluc2VydChfX2YsIF9fbCk7IH0KIAogICB0ZW1wbGF0ZTx0eXBl bmFtZSBfS2V5LCB0eXBlbmFtZSBfVmFsdWUsIHR5cGVuYW1lIF9BbGxvYywKIAkgICB0eXBl bmFtZSBfRXh0cmFjdEtleSwgdHlwZW5hbWUgX0VxdWFsLApAQCAtMTE5OSw3ICsxMjA4LDcg QEAgX0dMSUJDWFhfQkVHSU5fTkFNRVNQQUNFX1ZFUlNJT04KICAgICAgIF9IYXNodGFibGUo X0lucHV0SXRlcmF0b3IgX19mLCBfSW5wdXRJdGVyYXRvciBfX2wsCiAJCSBzaXplX3R5cGUg X19ia3RfY291bnRfaGludCwKIAkJIGNvbnN0IF9IYXNoJiBfX2gsIGNvbnN0IF9FcXVhbCYg X19lcSwKLQkJIGNvbnN0IGFsbG9jYXRvcl90eXBlJiBfX2EsIGZhbHNlX3R5cGUgLyogX191 a3MgKi8pCisJCSBjb25zdCBhbGxvY2F0b3JfdHlwZSYgX19hLCBmYWxzZV90eXBlIF9fdWtz KQogICAgICAgOiBfSGFzaHRhYmxlKF9faCwgX19lcSwgX19hKQogICAgICAgewogCWF1dG8g X19uYl9lbGVtcyA9IF9fZGV0YWlsOjpfX2Rpc3RhbmNlX2Z3KF9fZiwgX19sKTsKQEAgLTEy MTQsOCArMTIyMyw5IEBAIF9HTElCQ1hYX0JFR0lOX05BTUVTUEFDRV9WRVJTSU9OCiAJICAg IF9NX2J1Y2tldF9jb3VudCA9IF9fYmt0X2NvdW50OwogCSAgfQogCisJX19hbGxvY19ub2Rl X2dlbl90IF9fbm9kZV9nZW4oKnRoaXMpOwogCWZvciAoOyBfX2YgIT0gX19sOyArK19fZikK LQkgIHRoaXMtPmluc2VydCgqX19mKTsKKwkgIF9NX2luc2VydCgqX19mLCBfX25vZGVfZ2Vu LCBfX3Vrcyk7CiAgICAgICB9CiAKICAgdGVtcGxhdGU8dHlwZW5hbWUgX0tleSwgdHlwZW5h bWUgX1ZhbHVlLCB0eXBlbmFtZSBfQWxsb2MsCmRpZmYgLS1naXQgYS9saWJzdGRjKystdjMv aW5jbHVkZS9iaXRzL2hhc2h0YWJsZV9wb2xpY3kuaCBiL2xpYnN0ZGMrKy12My9pbmNsdWRl L2JpdHMvaGFzaHRhYmxlX3BvbGljeS5oCmluZGV4IDBmMGIwZjllYTUxLi5hNmJhNmExZDFh YyAxMDA2NDQKLS0tIGEvbGlic3RkYysrLXYzL2luY2x1ZGUvYml0cy9oYXNodGFibGVfcG9s aWN5LmgKKysrIGIvbGlic3RkYysrLXYzL2luY2x1ZGUvYml0cy9oYXNodGFibGVfcG9saWN5 LmgKQEAgLTEwOSw2ICsxMDksNDAgQEAgbmFtZXNwYWNlIF9fZGV0YWlsCiAgICAgICB7IHJl dHVybiBzdGQ6OmZvcndhcmQ8X1RwPihfX3gpLmZpcnN0OyB9CiAgIH07CiAKKyAgdGVtcGxh dGU8dHlwZW5hbWUgX0V4S2V5LCB0eXBlbmFtZSBfVmFsdWU+CisgICAgc3RydWN0IF9WYWx1 ZVR5cGVFbmZvcmNlcjsKKworICB0ZW1wbGF0ZTx0eXBlbmFtZSBfVmFsdWU+CisgICAgc3Ry dWN0IF9WYWx1ZVR5cGVFbmZvcmNlcjxfSWRlbnRpdHksIF9WYWx1ZT4KKyAgICB7CisgICAg ICB0ZW1wbGF0ZTx0eXBlbmFtZSBfS3Q+CisJY29uc3RleHByIF9LdCYmCisJb3BlcmF0b3Io KShfS3QmJiBfX2spIG5vZXhjZXB0CisJeyByZXR1cm4gc3RkOjpmb3J3YXJkPF9LdD4oX19r KTsgfQorICAgIH07CisKKyAgdGVtcGxhdGU8dHlwZW5hbWUgX1ZhbHVlPgorICAgIHN0cnVj dCBfVmFsdWVUeXBlRW5mb3JjZXI8X1NlbGVjdDFzdCwgX1ZhbHVlPgorICAgIHsKKyAgICAg IGNvbnN0ZXhwciBfVmFsdWUmJgorICAgICAgb3BlcmF0b3IoKShfVmFsdWUmJiBfX3gpIG5v ZXhjZXB0CisgICAgICB7IHJldHVybiBzdGQ6Om1vdmUoX194KTsgfQorCisgICAgICBjb25z dGV4cHIgY29uc3QgX1ZhbHVlJgorICAgICAgb3BlcmF0b3IoKShjb25zdCBfVmFsdWUmIF9f eCkgbm9leGNlcHQKKyAgICAgIHsgcmV0dXJuIF9feDsgfQorCisgICAgICB0ZW1wbGF0ZTx0 eXBlbmFtZSBfS3QsIHR5cGVuYW1lIF9WYWw+CisJY29uc3RleHByIHN0ZDo6cGFpcjxfS3Qs IF9WYWw+JiYKKwlvcGVyYXRvcigpKHN0ZDo6cGFpcjxfS3QsIF9WYWw+JiYgX194KSBub2V4 Y2VwdAorCXsgcmV0dXJuIHN0ZDo6bW92ZShfX3gpOyB9CisKKyAgICAgIHRlbXBsYXRlPHR5 cGVuYW1lIF9LdCwgdHlwZW5hbWUgX1ZhbD4KKwljb25zdGV4cHIgY29uc3Qgc3RkOjpwYWly PF9LdCwgX1ZhbD4mCisJb3BlcmF0b3IoKShjb25zdCBzdGQ6OnBhaXI8X0t0LCBfVmFsPiYg X194KSBub2V4Y2VwdAorCXsgcmV0dXJuIF9feDsgfQorICAgIH07CisKICAgdGVtcGxhdGU8 dHlwZW5hbWUgX0V4S2V5PgogICAgIHN0cnVjdCBfTm9kZUJ1aWxkZXI7CiAKZGlmZiAtLWdp dCBhL2xpYnN0ZGMrKy12My90ZXN0c3VpdGUvMjNfY29udGFpbmVycy91bm9yZGVyZWRfbWFw L2NvbnMvNTYxMTIuY2MgYi9saWJzdGRjKystdjMvdGVzdHN1aXRlLzIzX2NvbnRhaW5lcnMv dW5vcmRlcmVkX21hcC9jb25zLzU2MTEyLmNjCmluZGV4IGM0Y2RlZWUyMzRjLi5iMGVkYTMw YjRjYiAxMDA2NDQKLS0tIGEvbGlic3RkYysrLXYzL3Rlc3RzdWl0ZS8yM19jb250YWluZXJz L3Vub3JkZXJlZF9tYXAvY29ucy81NjExMi5jYworKysgYi9saWJzdGRjKystdjMvdGVzdHN1 aXRlLzIzX2NvbnRhaW5lcnMvdW5vcmRlcmVkX21hcC9jb25zLzU2MTEyLmNjCkBAIC0yMCwz MCArMjAsNTEgQEAKICNpbmNsdWRlIDx1bm9yZGVyZWRfbWFwPgogI2luY2x1ZGUgPHV0aWxp dHk+CiAKKyNpbmNsdWRlIDx0ZXN0c3VpdGVfaG9va3MuaD4KKwogc3RydWN0IEtleQogewog ICBleHBsaWNpdCBLZXkoY29uc3QgaW50KiBwKSA6IHZhbHVlKHApIHsgfQogICB+S2V5KCkg eyB2YWx1ZSA9IG51bGxwdHI7IH0KIAotICBib29sIG9wZXJhdG9yPT0oY29uc3QgS2V5JiBr KSBjb25zdCB7IHJldHVybiAqdmFsdWUgPT0gKmsudmFsdWU7IH0KKyAgYm9vbCBvcGVyYXRv cj09KGNvbnN0IEtleSYgaykgY29uc3QKKyAgeyByZXR1cm4gKnZhbHVlID09ICprLnZhbHVl OyB9CiAKICAgY29uc3QgaW50KiB2YWx1ZTsKIH07CiAKIHN0cnVjdCBoYXNoCiB7Ci0gIHN0 ZDo6c2l6ZV90IG9wZXJhdG9yKCkoY29uc3QgS2V5JiBrKSBjb25zdCBub2V4Y2VwdCB7IHJl dHVybiAqay52YWx1ZTsgfQorICBzdGQ6OnNpemVfdCBvcGVyYXRvcigpKGNvbnN0IEtleSYg aykgY29uc3Qgbm9leGNlcHQKKyAgeyByZXR1cm4gKmsudmFsdWU7IH0KIH07CiAKIHN0cnVj dCBTCiB7CisgIHN0YXRpYyBpbnQgX2NvdW50OworCiAgIGludCB2YWx1ZTsKLSAgb3BlcmF0 b3Igc3RkOjpwYWlyPGNvbnN0IEtleSwgaW50PigpIGNvbnN0IHsgcmV0dXJuIHtLZXkoJnZh bHVlKSwgdmFsdWV9OyB9CisgIG9wZXJhdG9yIHN0ZDo6cGFpcjxjb25zdCBLZXksIGludD4o KSBjb25zdAorICB7CisgICAgKytfY291bnQ7CisgICAgcmV0dXJuIHsgS2V5KCZ2YWx1ZSks IHZhbHVlIH07CisgIH0KIH07CiAKLWludCBtYWluKCkKK2ludCBTOjpfY291bnQgPSAwOwor Cit2b2lkIHRlc3QwMSgpCiB7CiAgICAgUyBzWzFdID0geyB7Mn0gfTsKLSAgICBzdGQ6OnVu b3JkZXJlZF9tYXA8S2V5LCBpbnQsIGhhc2g+IG0ocywgcysxKTsKLSAgICBzdGQ6OnVub3Jk ZXJlZF9tdWx0aW1hcDxLZXksIGludCwgaGFzaD4gbW0ocywgcysxKTsKKyAgICBzdGQ6OnVu b3JkZXJlZF9tYXA8S2V5LCBpbnQsIGhhc2g+IG0ocywgcyArIDEpOworICAgIFZFUklGWSgg Uzo6X2NvdW50ID09IDEgKTsKKworICAgIHN0ZDo6dW5vcmRlcmVkX211bHRpbWFwPEtleSwg aW50LCBoYXNoPiBtbShzLCBzICsgMSk7CisgICAgVkVSSUZZKCBTOjpfY291bnQgPT0gMiAp OworfQorCitpbnQgbWFpbigpCit7CisgIHRlc3QwMSgpOworICByZXR1cm4gMDsKIH0KZGlm ZiAtLWdpdCBhL2xpYnN0ZGMrKy12My90ZXN0c3VpdGUvMjNfY29udGFpbmVycy91bm9yZGVy ZWRfbWFwL2luc2VydC8xMDU3MTcuY2MgYi9saWJzdGRjKystdjMvdGVzdHN1aXRlLzIzX2Nv bnRhaW5lcnMvdW5vcmRlcmVkX21hcC9pbnNlcnQvMTA1NzE3LmNjCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi4yMDJiYWE5ODE4YgotLS0gL2Rldi9udWxsCisr KyBiL2xpYnN0ZGMrKy12My90ZXN0c3VpdGUvMjNfY29udGFpbmVycy91bm9yZGVyZWRfbWFw L2luc2VydC8xMDU3MTcuY2MKQEAgLTAsMCArMSw3MyBAQAorLy8geyBkZy1kbyBydW4geyB0 YXJnZXQgYysrMTEgfSB9CisKKy8vIENvcHlyaWdodCAoQykgMjAyMiBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIEluYy4KKy8vCisvLyBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgR05V IElTTyBDKysgTGlicmFyeS4gIFRoaXMgbGlicmFyeSBpcyBmcmVlCisvLyBzb2Z0d2FyZTsg eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdCB1bmRlciB0aGUKKy8v IHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQg YnkgdGhlCisvLyBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMs IG9yIChhdCB5b3VyIG9wdGlvbikKKy8vIGFueSBsYXRlciB2ZXJzaW9uLgorCisvLyBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVz ZWZ1bCwKKy8vIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisvLyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisvLyBHTlUgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisvLyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2 ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZworLy8g d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HMy4gIElmIG5vdCBzZWUK Ky8vIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4KKworI2luY2x1ZGUgPHVub3Jk ZXJlZF9tYXA+CisjaW5jbHVkZSA8dXRpbGl0eT4KKworI2luY2x1ZGUgPHRlc3RzdWl0ZV9o b29rcy5oPgorCitzdHJ1Y3QgS2V5Cit7CisgIGV4cGxpY2l0IEtleShjb25zdCBpbnQqIHAp IDogdmFsdWUocCkgeyB9CisgIH5LZXkoKSB7IHZhbHVlID0gbnVsbHB0cjsgfQorCisgIGJv b2wgb3BlcmF0b3I9PShjb25zdCBLZXkmIGspIGNvbnN0CisgIHsgcmV0dXJuICp2YWx1ZSA9 PSAqay52YWx1ZTsgfQorCisgIGNvbnN0IGludCogdmFsdWU7Cit9OworCitzdHJ1Y3QgaGFz aAoreworICBzdGQ6OnNpemVfdCBvcGVyYXRvcigpKGNvbnN0IEtleSYgaykgY29uc3Qgbm9l eGNlcHQKKyAgeyByZXR1cm4gKmsudmFsdWU7IH0KK307CisKK3N0cnVjdCBTCit7CisgIHN0 YXRpYyBpbnQgX2NvdW50OworCisgIGludCB2YWx1ZTsKKyAgb3BlcmF0b3Igc3RkOjpwYWly PGNvbnN0IEtleSwgaW50PigpIGNvbnN0CisgIHsKKyAgICArK19jb3VudDsKKyAgICByZXR1 cm4geyBLZXkoJnZhbHVlKSwgdmFsdWUgfTsKKyAgfQorfTsKKworaW50IFM6Ol9jb3VudCA9 IDA7CisKK3ZvaWQgdGVzdDAxKCkKK3sKKyAgICBTIHNbMV0gPSB7IHsyfSB9OworICAgIHN0 ZDo6dW5vcmRlcmVkX21hcDxLZXksIGludCwgaGFzaD4gbTsKKyAgICBzdGQ6OnVub3JkZXJl ZF9tdWx0aW1hcDxLZXksIGludCwgaGFzaD4gbW07CisKKyAgICBtLmluc2VydChzLCBzICsg MSk7CisgICAgVkVSSUZZKCBTOjpfY291bnQgPT0gMSApOworCisgICAgbW0uaW5zZXJ0KHMs IHMgKyAxKTsKKyAgICBWRVJJRlkoIFM6Ol9jb3VudCA9PSAyICk7Cit9CisKK2ludCBtYWlu KCkKK3sKKyAgdGVzdDAxKCk7CisgIHJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvbGlic3Rk YysrLXYzL3Rlc3RzdWl0ZS8yM19jb250YWluZXJzL3Vub3JkZXJlZF9zZXQvaW5zZXJ0LzEw NTcxNy5jYyBiL2xpYnN0ZGMrKy12My90ZXN0c3VpdGUvMjNfY29udGFpbmVycy91bm9yZGVy ZWRfc2V0L2luc2VydC8xMDU3MTcuY2MKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAuLmFiMjI5YzViYWExCi0tLSAvZGV2L251bGwKKysrIGIvbGlic3RkYysrLXYz L3Rlc3RzdWl0ZS8yM19jb250YWluZXJzL3Vub3JkZXJlZF9zZXQvaW5zZXJ0LzEwNTcxNy5j YwpAQCAtMCwwICsxLDczIEBACisvLyB7IGRnLWRvIHJ1biB7IHRhcmdldCBjKysxMSB9IH0K KworLy8gQ29weXJpZ2h0IChDKSAyMDIyIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5j LgorLy8KKy8vIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBHTlUgSVNPIEMrKyBMaWJyYXJ5 LiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUKKy8vIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJp YnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0IHVuZGVyIHRoZQorLy8gdGVybXMgb2YgdGhlIEdO VSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKKy8vIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMywgb3IgKGF0IHlvdXIgb3B0 aW9uKQorLy8gYW55IGxhdGVyIHZlcnNpb24uCisKKy8vIFRoaXMgbGlicmFyeSBpcyBkaXN0 cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorLy8gYnV0IFdJ VEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKy8vIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRS4gIFNlZSB0aGUKKy8vIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCisKKy8vIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nCisvLyB3aXRoIHRoaXMgbGlicmFy eTsgc2VlIHRoZSBmaWxlIENPUFlJTkczLiAgSWYgbm90IHNlZQorLy8gPGh0dHA6Ly93d3cu Z251Lm9yZy9saWNlbnNlcy8+LgorCisjaW5jbHVkZSA8dW5vcmRlcmVkX3NldD4KKyNpbmNs dWRlIDx1dGlsaXR5PgorCisjaW5jbHVkZSA8dGVzdHN1aXRlX2hvb2tzLmg+CisKK3N0cnVj dCBLZXkKK3sKKyAgZXhwbGljaXQgS2V5KGNvbnN0IGludCogcCkgOiB2YWx1ZShwKSB7IH0K KyAgfktleSgpIHsgdmFsdWUgPSBudWxscHRyOyB9CisKKyAgYm9vbCBvcGVyYXRvcj09KGNv bnN0IEtleSYgaykgY29uc3QKKyAgeyByZXR1cm4gKnZhbHVlID09ICprLnZhbHVlOyB9CisK KyAgY29uc3QgaW50KiB2YWx1ZTsKK307CisKK3N0cnVjdCBoYXNoCit7CisgIHN0ZDo6c2l6 ZV90IG9wZXJhdG9yKCkoY29uc3QgS2V5JiBrKSBjb25zdCBub2V4Y2VwdAorICB7IHJldHVy biAqay52YWx1ZTsgfQorfTsKKworc3RydWN0IFMKK3sKKyAgc3RhdGljIGludCBfY291bnQ7 CisKKyAgaW50IHZhbHVlOworICBvcGVyYXRvciBLZXkoKSBjb25zdAorICB7CisgICAgKytf Y291bnQ7CisgICAgcmV0dXJuIEtleSgmdmFsdWUpOworICB9Cit9OworCitpbnQgUzo6X2Nv dW50ID0gMDsKKwordm9pZCB0ZXN0MDEoKQoreworICAgIFMgYVsxXSA9IHsgezJ9IH07Cisg ICAgc3RkOjp1bm9yZGVyZWRfc2V0PEtleSwgaGFzaD4gczsKKyAgICBzdGQ6OnVub3JkZXJl ZF9tdWx0aXNldDxLZXksIGhhc2g+IG1zOworCisgICAgcy5pbnNlcnQoYSwgYSArIDEpOwor ICAgIFZFUklGWSggUzo6X2NvdW50ID09IDEgKTsKKworICAgIG1zLmluc2VydChhLCBhICsg MSk7CisgICAgVkVSSUZZKCBTOjpfY291bnQgPT0gMiApOworfQorCitpbnQgbWFpbigpCit7 CisgIHRlc3QwMSgpOworICByZXR1cm4gMDsKK30K --------------SAOU2tgvU0izOYolY9k9uOvP--