From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 4031 invoked by alias); 5 Jun 2019 12:19:33 -0000 Mailing-List: contact gcc-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-owner@gcc.gnu.org Received: (qmail 4021 invoked by uid 89); 5 Jun 2019 12:19:32 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-19.4 required=5.0 tests=AWL,BAYES_50,FREEMAIL_ENVFROM_END_DIGIT,FREEMAIL_FROM,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,RCVD_IN_DNSWL_NONE,SPF_PASS autolearn=ham version=3.3.1 spammy=005, foldconstc, fold-const.c, UD:fold-const.c X-HELO: mail-ed1-f52.google.com Received: from mail-ed1-f52.google.com (HELO mail-ed1-f52.google.com) (209.85.208.52) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 05 Jun 2019 12:19:29 +0000 Received: by mail-ed1-f52.google.com with SMTP id h10so5452083edi.13 for ; Wed, 05 Jun 2019 05:19:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=tpN6b64Y3Yg5IOIuyxiIfdrrI1avSOMkz3tUIo2lT7Q=; b=IuoZxyedmL+ZWKVwlHNIcYV0QZtlGlRcuPV/Luv2qq8G/zARuqHflLg6gGtdYn+WgQ e5vFQchTAe7Xu5P1ovQXgGefx7qS1qx0lPdq26xEnS/O51nxRHc8UD71JXXkKh94jsxb iIvIb0Q0dBQT1Me7AtO81BFSzKp6qHlLy29lEGjWIq9pItpu+zmla/XCOGDDc4kqvGv6 9yoLYp8/LW34GVRKmlGa/9dT/V+iWVDV58WMWB/AH079WqWQzPpfa7rKgGbR/f5kbK2J mz0+u1T0OnkpSkeK65Kxar3U+yOfzRPFIg7SqyevIZUxFMajc+IFVDNTnzu9gchoAahB z6ww== MIME-Version: 1.0 References: <20190530213839.GF31586@gate.crashing.org> In-Reply-To: From: Tejas Joshi Date: Wed, 05 Jun 2019 12:19:00 -0000 Message-ID: Subject: Re: About GSOC. To: gcc@gcc.gnu.org Cc: Martin Jambor , hubicka@ucw.cz, joseph@codesourcery.com Content-Type: multipart/mixed; boundary="000000000000c29cd6058a929be4" X-IsSubscribed: yes X-SW-Source: 2019-06/txt/msg00023.txt.bz2 --000000000000c29cd6058a929be4 Content-Type: text/plain; charset="UTF-8" Content-length: 6814 Hello. Following patch is tested on following test cases in the testsuite and tests did not fail. I have considered most of the test cases this time hopefully. /* { dg-do link } */ extern int link_error (int); #define TEST(FN, VALUE, RESULT) \ if (__builtin_##FN (VALUE) != RESULT) link_error (__LINE__); int main (void) { TEST(roundeven, 0, 0); TEST(roundeven, 0.5, 0); TEST(roundeven, -0.5, 0); TEST(roundeven, 6, 6); TEST(roundeven, -8, -8); TEST(roundeven, 2.5, 2); TEST(roundeven, 3.5, 4); TEST(roundeven, -1.5, -2); TEST(roundeven, 3.499, 3); TEST(roundeven, 3.501, 4); return 0; } _Float128 test cases : /* { dg-do link } */ /* { dg-add-options float128 } */ /* { dg-require-effective-target float128 } */ extern int link_error (int); #define TEST(FN, VALUE, RESULT) \ if (__builtin_##FN##f128 (VALUE) != RESULT) link_error (__LINE__); int main (void) { TEST(roundeven, (0x1p64+0.5f128), (0x1p64f128)); TEST(roundeven, (0x1p63+0.5f128), (0x1p63f128)); TEST(roundeven, (0x1p63-0.5f128), (0x1p63f128)); TEST(roundeven, (0x1p64-0.5f128), (0x1p64f128)); TEST(roundeven, (0x1p64+0.501f128), (0x1p64+1.0f128)); TEST(roundeven, (0x1.C00000000000039A5653p1f128), (0x1p2f128)) // the hex number is 3.50000000...01 which would fail for roundeven but not for f128 return 0; } Thanks, -Tejas On Tue, 4 Jun 2019 at 12:38, Tejas Joshi wrote: > > Hello. > > > NaN, and you should make sure it behaves accordingly. (If it should never > > be called for them, a gcc_assert would be appropriate.) > > I can't find any documentation about how and when to use gcc_assert. > But I used it looking at the comment at its definition and locations > it is used, is this appropriate? Or is it supposed to be used before > calling the function? : > > +bool > +is_even (REAL_VALUE_TYPE *r) > +{ > + /* The function is not supposed to use for Inf and NaN. */ > + gcc_assert (r->cl != rvc_inf); > + gcc_assert (r->cl != rvc_nan); > > > So n is the bit position, and w is the word position, of the bit with > > value 1; n-1 is the position of the bit with value 0.5. > > If n is a multiple of HOST_BITS_PER_LONG (that is, the bits with values > > 0.5 and 1 are in different words), this will incorrectly return false when > > the 0.5 bit is set. > > I did not understand this. What is the bit with value 1? > But when n is a multiple of HOST_BITS_PER_LONG, the function was > computing value of w wrong (e.g. for number 2^63 + 0.5). At such time, > would the following improvisation be acceptable in is_halfway_below? > > +bool > +is_halfway_below (const REAL_VALUE_TYPE *r) > +{ > + /* The function is not supposed to use for Inf and NaN. */ > + gcc_assert (r->cl != rvc_inf); > + gcc_assert (r->cl != rvc_nan); > + int i; > + > + /* For numbers (-0.5,0) and (0,0.5). */ > + if (REAL_EXP (r) < 0) > + return false; > + > + else if (REAL_EXP (r) <= SIGNIFICAND_BITS) > + { > + unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r); > + int w = n / HOST_BITS_PER_LONG; > + > + if (n % HOST_BITS_PER_LONG == 0) > + { > + if (w > 0) > + w = w - 1; > + else > + w = 0; > + } > + > + for (i = 0; i < w; ++i) > + { > + if (r->sig[i] != 0) > + return false; > + } > > Thanks. > > > On Mon, 3 Jun 2019 at 22:08, Joseph Myers wrote: > > > > On Fri, 31 May 2019, Tejas Joshi wrote: > > > > > +/* Return true if integer part of R is even, else return false. */ > > > + > > > +bool > > > +is_even (REAL_VALUE_TYPE *r) > > > +{ > > > + if (REAL_EXP (r) <= 0) > > > + return false; > > > > But the integer part (truncation towards 0) of something in the interval > > (-1, 1) is of course even. > > > > > + else if (REAL_EXP (r) < SIGNIFICAND_BITS) > > > + { > > > + unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r); > > > + int w = n / HOST_BITS_PER_LONG; > > > + > > > + unsigned long num = ((unsigned long)1 << (n % HOST_BITS_PER_LONG)); > > > + > > > + if ((r->sig[w] & num) == 0) > > > + return true; > > > + } > > > + return false; > > > +} > > > > Suppose REAL_EXP (r) == SIGNIFICAND_BITS. Then you still need to check > > the low bit in that case. > > > > Suppose REAL_EXP (r) > SIGNIFICAND_BITS. Then the number is definitely > > even, so you should return true, not false. > > > > The comment on this function needs to define what it does for infinity / > > NaN, and you should make sure it behaves accordingly. (If it should never > > be called for them, a gcc_assert would be appropriate.) > > > > What does this function do for zero? It should, of course, return that it > > is even. > > > > > +/* Return true if R is halfway between two integers, else return false. */ > > > > Again, define what this does for infinity / NaN and make sure it behaves > > accordingly. > > > > > +bool > > > +is_halfway_below (const REAL_VALUE_TYPE *r) > > > +{ > > > + if (REAL_EXP (r) < 0) > > > + return false; > > > + > > > + if (REAL_EXP (r) == 0) > > > + { > > > + unsigned long temp = ((unsigned long)1 << 63); > > > > unsigned long might be 32-bit; you can't assume it's 64-bit. You may mean > > (HOST_BITS_PER_LONG - 1) instead of 63. > > > > > + if (((r->sig[SIGSZ-1] & temp) != 0) && ((r->sig[SIGSZ-1] & (temp-1)) == 0)) > > > + return true; > > > + else > > > + return false; > > > > This appears only to be checking the high word, not lower bits. > > > > > + else if (REAL_EXP (r) < SIGNIFICAND_BITS) > > > + { > > > + unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r); > > > + int i, w = n / HOST_BITS_PER_LONG; > > > > So n is the bit position, and w is the word position, of the bit with > > value 1; n-1 is the position of the bit with value 0.5. > > > > > + for (i = 0; i < w; ++i) > > > + { > > > + if (r->sig[i] != 0) > > > + return false; > > > + } > > > > If n is a multiple of HOST_BITS_PER_LONG (that is, the bits with values > > 0.5 and 1 are in different words), this will incorrectly return false when > > the 0.5 bit is set. > > > > > + unsigned long num = ((unsigned long)1 << ((n - 1) % HOST_BITS_PER_LONG)); > > > + > > > + if (((r->sig[w] & num) != 0) && ((r->sig[w] & (num-1)) == 0)) > > > + return true; > > > > And this also needs updating to handle the case where 0.5 and 1 are in > > different words correctly; currently it's checking bits that are all one > > word too high. It's possible that for both issues, you want w to be the > > word with the 0.5 bit, not the word with the 1 bit. > > > > For all the above, please add appropriate tests in the testsuite (for > > example, where 0.5 and 1 are in different words and the above would have > > produced incorrect results). > > > > -- > > Joseph S. Myers > > joseph@codesourcery.com --000000000000c29cd6058a929be4 Content-Type: text/x-patch; charset="US-ASCII"; name="roundeven.patch" Content-Disposition: attachment; filename="roundeven.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_jwj7eio00 Content-length: 12103 ZGlmZiAtLWdpdCBhL2djYy9idWlsdGlucy5jIGIvZ2NjL2J1aWx0aW5zLmMK aW5kZXggMjVlMDFlNDA5MmIuLjBiMmQ2YmY4MmY5IDEwMDY0NAotLS0gYS9n Y2MvYnVpbHRpbnMuYworKysgYi9nY2MvYnVpbHRpbnMuYwpAQCAtMjA2Nyw2 ICsyMDY3LDcgQEAgbWF0aGZuX2J1aWx0X2luXzIgKHRyZWUgdHlwZSwgY29t YmluZWRfZm4gZm4pCiAgICAgQ0FTRV9NQVRIRk4gKFJFTVFVTykKICAgICBD QVNFX01BVEhGTl9GTE9BVE4gKFJJTlQpCiAgICAgQ0FTRV9NQVRIRk5fRkxP QVROIChST1VORCkKKyAgICBDQVNFX01BVEhGTiAoUk9VTkRFVkVOKQogICAg IENBU0VfTUFUSEZOIChTQ0FMQikKICAgICBDQVNFX01BVEhGTiAoU0NBTEJM TikKICAgICBDQVNFX01BVEhGTiAoU0NBTEJOKQpkaWZmIC0tZ2l0IGEvZ2Nj L2J1aWx0aW5zLmRlZiBiL2djYy9idWlsdGlucy5kZWYKaW5kZXggZWY4OTcy OWZkMGMuLmYyODRhM2VhZTNiIDEwMDY0NAotLS0gYS9nY2MvYnVpbHRpbnMu ZGVmCisrKyBiL2djYy9idWlsdGlucy5kZWYKQEAgLTU0MiwxMiArNTQyLDE4 IEBAIERFRl9DOTlfQlVJTFRJTiAgICAgICAgKEJVSUxUX0lOX1JJTlRMLCAi cmludGwiLCBCVF9GTl9MT05HRE9VQkxFX0xPTkdET1VCTEUsIEFUCiAjZGVm aW5lIFJJTlRfVFlQRShGKSBCVF9GTl8jI0YjI18jI0YKIERFRl9FWFRfTElC X0ZMT0FUTl9OWF9CVUlMVElOUyAoQlVJTFRfSU5fUklOVCwgInJpbnQiLCBS SU5UX1RZUEUsIEFUVFJfQ09OU1RfTk9USFJPV19MRUFGX0xJU1QpCiAjdW5k ZWYgUklOVF9UWVBFCitERUZfRVhUX0xJQl9CVUlMVElOICAgIChCVUlMVF9J Tl9ST1VOREVWRU4sICJyb3VuZGV2ZW4iLCBCVF9GTl9ET1VCTEVfRE9VQkxF LCBBVFRSX0NPTlNUX05PVEhST1dfTEVBRl9MSVNUKQorREVGX0VYVF9MSUJf QlVJTFRJTiAgICAoQlVJTFRfSU5fUk9VTkRFVkVORiwgInJvdW5kZXZlbmYi LCBCVF9GTl9GTE9BVF9GTE9BVCwgQVRUUl9DT05TVF9OT1RIUk9XX0xFQUZf TElTVCkKK0RFRl9FWFRfTElCX0JVSUxUSU4gICAgKEJVSUxUX0lOX1JPVU5E RVZFTkwsICJyb3VuZGV2ZW5sIiwgQlRfRk5fTE9OR0RPVUJMRV9MT05HRE9V QkxFLCBBVFRSX0NPTlNUX05PVEhST1dfTEVBRl9MSVNUKQogREVGX0M5OV9C VUlMVElOICAgICAgICAoQlVJTFRfSU5fUk9VTkQsICJyb3VuZCIsIEJUX0ZO X0RPVUJMRV9ET1VCTEUsIEFUVFJfQ09OU1RfTk9USFJPV19MRUFGX0xJU1Qp CiBERUZfQzk5X0JVSUxUSU4gICAgICAgIChCVUlMVF9JTl9ST1VOREYsICJy b3VuZGYiLCBCVF9GTl9GTE9BVF9GTE9BVCwgQVRUUl9DT05TVF9OT1RIUk9X X0xFQUZfTElTVCkKIERFRl9DOTlfQlVJTFRJTiAgICAgICAgKEJVSUxUX0lO X1JPVU5ETCwgInJvdW5kbCIsIEJUX0ZOX0xPTkdET1VCTEVfTE9OR0RPVUJM RSwgQVRUUl9DT05TVF9OT1RIUk9XX0xFQUZfTElTVCkKICNkZWZpbmUgUk9V TkRfVFlQRShGKSBCVF9GTl8jI0YjI18jI0YKIERFRl9FWFRfTElCX0ZMT0FU Tl9OWF9CVUlMVElOUyAoQlVJTFRfSU5fUk9VTkQsICJyb3VuZCIsIFJPVU5E X1RZUEUsIEFUVFJfQ09OU1RfTk9USFJPV19MRUFGX0xJU1QpCiAjdW5kZWYg Uk9VTkRfVFlQRQorI2RlZmluZSBST1VOREVWRU5fVFlQRShGKSBCVF9GTl8j I0YjI18jI0YKK0RFRl9FWFRfTElCX0ZMT0FUTl9OWF9CVUlMVElOUyAoQlVJ TFRfSU5fUk9VTkRFVkVOLCAicm91bmRldmVuIiwgUk9VTkRFVkVOX1RZUEUs IEFUVFJfQ09OU1RfTk9USFJPV19MRUFGX0xJU1QpCisjdW5kZWYgUk9VTkRF VkVOX1RZUEUKIERFRl9FWFRfTElCX0JVSUxUSU4gICAgKEJVSUxUX0lOX1ND QUxCLCAic2NhbGIiLCBCVF9GTl9ET1VCTEVfRE9VQkxFX0RPVUJMRSwgQVRU Ul9NQVRIRk5fRlBST1VORElOR19FUlJOTykKIERFRl9FWFRfTElCX0JVSUxU SU4gICAgKEJVSUxUX0lOX1NDQUxCRiwgInNjYWxiZiIsIEJUX0ZOX0ZMT0FU X0ZMT0FUX0ZMT0FULCBBVFRSX01BVEhGTl9GUFJPVU5ESU5HX0VSUk5PKQog REVGX0VYVF9MSUJfQlVJTFRJTiAgICAoQlVJTFRfSU5fU0NBTEJMLCAic2Nh bGJsIiwgQlRfRk5fTE9OR0RPVUJMRV9MT05HRE9VQkxFX0xPTkdET1VCTEUs IEFUVFJfTUFUSEZOX0ZQUk9VTkRJTkdfRVJSTk8pCmRpZmYgLS1naXQgYS9n Y2MvZm9sZC1jb25zdC1jYWxsLmMgYi9nY2MvZm9sZC1jb25zdC1jYWxsLmMK aW5kZXggMDZhNDIwNjAxYzAuLjU0MzE1ZDA1N2EyIDEwMDY0NAotLS0gYS9n Y2MvZm9sZC1jb25zdC1jYWxsLmMKKysrIGIvZ2NjL2ZvbGQtY29uc3QtY2Fs bC5jCkBAIC03OTIsNiArNzkyLDE1IEBAIGZvbGRfY29uc3RfY2FsbF9zcyAo cmVhbF92YWx1ZSAqcmVzdWx0LCBjb21iaW5lZF9mbiBmbiwKIAl9CiAgICAg ICByZXR1cm4gZmFsc2U7CiAKKyAgICBDQVNFX0NGTl9ST1VOREVWRU46Cisg ICAgQ0FTRV9DRk5fUk9VTkRFVkVOX0ZOOgorICAgICAgaWYgKCFSRUFMX1ZB TFVFX0lTTkFOICgqYXJnKSB8fCAhZmxhZ19lcnJub19tYXRoKQorICB7Cisg ICAgcmVhbF9yb3VuZGV2ZW4gKHJlc3VsdCwgZm9ybWF0LCBhcmcpOworICAg IHJldHVybiB0cnVlOworICB9CisgICAgICByZXR1cm4gZmFsc2U7CisKICAg ICBDQVNFX0NGTl9MT0dCOgogICAgICAgcmV0dXJuIGZvbGRfY29uc3RfbG9n YiAocmVzdWx0LCBhcmcsIGZvcm1hdCk7CiAKQEAgLTg1NCw2ICs4NjMsMTAg QEAgZm9sZF9jb25zdF9jYWxsX3NzICh3aWRlX2ludCAqcmVzdWx0LCBjb21i aW5lZF9mbiBmbiwKICAgICAgIHJldHVybiBmb2xkX2NvbnN0X2NvbnZlcnNp b24gKHJlc3VsdCwgcmVhbF9yb3VuZCwgYXJnLAogCQkJCSAgICBwcmVjaXNp b24sIGZvcm1hdCk7CiAKKyAgICBDQVNFX0NGTl9ST1VOREVWRU46CisgICAg Q0FTRV9DRk5fUk9VTkRFVkVOX0ZOOgorICAgICAgcmV0dXJuIGZvbGRfY29u c3RfY29udmVyc2lvbiAocmVzdWx0LCByZWFsX3JvdW5kZXZlbiwgYXJnLCBw cmVjaXNpb24sIGZvcm1hdCk7CisKICAgICBDQVNFX0NGTl9JUklOVDoKICAg ICBDQVNFX0NGTl9MUklOVDoKICAgICBDQVNFX0NGTl9MTFJJTlQ6CmRpZmYg LS1naXQgYS9nY2MvZm9sZC1jb25zdC5jIGIvZ2NjL2ZvbGQtY29uc3QuYwpp bmRleCA1OWNlZGVhZmQ3MS4uYWI5NmYxOTdkNWYgMTAwNjQ0Ci0tLSBhL2dj Yy9mb2xkLWNvbnN0LmMKKysrIGIvZ2NjL2ZvbGQtY29uc3QuYwpAQCAtMzI5 LDYgKzMyOSw4IEBAIG5lZ2F0ZV9tYXRoZm5fcCAoY29tYmluZWRfZm4gZm4p CiAgICAgQ0FTRV9DRk5fTExST1VORDoKICAgICBDQVNFX0NGTl9MUk9VTkQ6 CiAgICAgQ0FTRV9DRk5fUk9VTkQ6CisgICAgQ0FTRV9DRk5fUk9VTkRFVkVO OgorICAgIENBU0VfQ0ZOX1JPVU5ERVZFTl9GTjoKICAgICBDQVNFX0NGTl9T SU46CiAgICAgQ0FTRV9DRk5fU0lOSDoKICAgICBDQVNFX0NGTl9UQU46CkBA IC0xMzA2MCw2ICsxMzA2Miw4IEBAIHRyZWVfY2FsbF9ub25uZWdhdGl2ZV93 YXJudl9wICh0cmVlIHR5cGUsIGNvbWJpbmVkX2ZuIGZuLCB0cmVlIGFyZzAs IHRyZWUgYXJnMSwKICAgICBDQVNFX0NGTl9SSU5UX0ZOOgogICAgIENBU0Vf Q0ZOX1JPVU5EOgogICAgIENBU0VfQ0ZOX1JPVU5EX0ZOOgorICAgIENBU0Vf Q0ZOX1JPVU5ERVZFTjoKKyAgICBDQVNFX0NGTl9ST1VOREVWRU5fRk46CiAg ICAgQ0FTRV9DRk5fU0NBTEI6CiAgICAgQ0FTRV9DRk5fU0NBTEJMTjoKICAg ICBDQVNFX0NGTl9TQ0FMQk46CkBAIC0xMzU4Myw2ICsxMzU4Nyw4IEBAIGlu dGVnZXJfdmFsdWVkX3JlYWxfY2FsbF9wIChjb21iaW5lZF9mbiBmbiwgdHJl ZSBhcmcwLCB0cmVlIGFyZzEsIGludCBkZXB0aCkKICAgICBDQVNFX0NGTl9S SU5UX0ZOOgogICAgIENBU0VfQ0ZOX1JPVU5EOgogICAgIENBU0VfQ0ZOX1JP VU5EX0ZOOgorICAgIENBU0VfQ0ZOX1JPVU5ERVZFTjoKKyAgICBDQVNFX0NG Tl9ST1VOREVWRU5fRk46CiAgICAgQ0FTRV9DRk5fVFJVTkM6CiAgICAgQ0FT RV9DRk5fVFJVTkNfRk46CiAgICAgICByZXR1cm4gdHJ1ZTsKZGlmZiAtLWdp dCBhL2djYy9pbnRlcm5hbC1mbi5kZWYgYi9nY2MvaW50ZXJuYWwtZm4uZGVm CmluZGV4IGNkYTMxNGUxMTIxLi5iODk5MTg4MTVmOSAxMDA2NDQKLS0tIGEv Z2NjL2ludGVybmFsLWZuLmRlZgorKysgYi9nY2MvaW50ZXJuYWwtZm4uZGVm CkBAIC0yMjQsNiArMjI0LDcgQEAgREVGX0lOVEVSTkFMX0ZMVF9GTE9BVE5f Rk4gKEZMT09SLCBFQ0ZfQ09OU1QsIGZsb29yLCB1bmFyeSkKIERFRl9JTlRF Uk5BTF9GTFRfRkxPQVROX0ZOIChORUFSQllJTlQsIEVDRl9DT05TVCwgbmVh cmJ5aW50LCB1bmFyeSkKIERFRl9JTlRFUk5BTF9GTFRfRkxPQVROX0ZOIChS SU5ULCBFQ0ZfQ09OU1QsIHJpbnQsIHVuYXJ5KQogREVGX0lOVEVSTkFMX0ZM VF9GTE9BVE5fRk4gKFJPVU5ELCBFQ0ZfQ09OU1QsIHJvdW5kLCB1bmFyeSkK K0RFRl9JTlRFUk5BTF9GTFRfRkxPQVROX0ZOIChST1VOREVWRU4sIEVDRl9D T05TVCwgcm91bmRldmVuLCB1bmFyeSkKIERFRl9JTlRFUk5BTF9GTFRfRkxP QVROX0ZOIChUUlVOQywgRUNGX0NPTlNULCBidHJ1bmMsIHVuYXJ5KQogCiAv KiBCaW5hcnkgbWF0aCBmdW5jdGlvbnMuICAqLwpkaWZmIC0tZ2l0IGEvZ2Nj L21hdGNoLnBkIGIvZ2NjL21hdGNoLnBkCmluZGV4IDdjYzIzNzRmZmViLi5m YTE4YjQ5OTE2MiAxMDA2NDQKLS0tIGEvZ2NjL21hdGNoLnBkCisrKyBiL2dj Yy9tYXRjaC5wZApAQCAtNDIyOSw3ICs0MjI5LDcgQEAgREVGSU5FX0lOVF9B TkRfRkxPQVRfUk9VTkRfRk4gKFJJTlQpCiAgKGFicyBAMCkpCiAKIC8qIHRy dW5jKHRydW5jKHgpKSAtPiB0cnVuYyh4KSwgZXRjLiAgKi8KLShmb3IgZm5z IChUUlVOQ19BTEwgRkxPT1JfQUxMIENFSUxfQUxMIFJPVU5EX0FMTCBORUFS QllJTlRfQUxMIFJJTlRfQUxMKQorKGZvciBmbnMgKFRSVU5DX0FMTCBGTE9P Ul9BTEwgQ0VJTF9BTEwgUk9VTkRfQUxMIEJVSUxUX0lOX1JPVU5ERVZFTiBO RUFSQllJTlRfQUxMIFJJTlRfQUxMKQogIChzaW1wbGlmeQogICAoZm5zIChm bnMgQDApKQogICAoZm5zIEAwKSkpCmRpZmYgLS1naXQgYS9nY2Mvb3B0YWJz LmRlZiBiL2djYy9vcHRhYnMuZGVmCmluZGV4IDVhNjdmNWVlZDVlLi5lYjll MjJhY2Q4ZiAxMDA2NDQKLS0tIGEvZ2NjL29wdGFicy5kZWYKKysrIGIvZ2Nj L29wdGFicy5kZWYKQEAgLTI2Nyw2ICsyNjcsNyBAQCBPUFRBQl9EIChmbm1z X29wdGFiLCAiZm5tcyRhNCIpCiAKIE9QVEFCX0QgKHJpbnRfb3B0YWIsICJy aW50JGEyIikKIE9QVEFCX0QgKHJvdW5kX29wdGFiLCAicm91bmQkYTIiKQor T1BUQUJfRCAocm91bmRldmVuX29wdGFiLCAicm91bmRldmVuJGEyIikKIE9Q VEFCX0QgKGZsb29yX29wdGFiLCAiZmxvb3IkYTIiKQogT1BUQUJfRCAoY2Vp bF9vcHRhYiwgImNlaWwkYTIiKQogT1BUQUJfRCAoYnRydW5jX29wdGFiLCAi YnRydW5jJGEyIikKZGlmZiAtLWdpdCBhL2djYy9yZWFsLmMgYi9nY2MvcmVh bC5jCmluZGV4IGY4MjJhZTgyZDYxLi5hZWUxMWU1MmRkNCAxMDA2NDQKLS0t IGEvZ2NjL3JlYWwuYworKysgYi9nY2MvcmVhbC5jCkBAIC01MDEwLDYgKzUw MTAsOTYgQEAgcmVhbF9yb3VuZCAoUkVBTF9WQUxVRV9UWVBFICpyLCBmb3Jt YXRfaGVscGVyIGZtdCwKICAgICByZWFsX2NvbnZlcnQgKHIsIGZtdCwgcik7 CiB9CiAKKy8qIFJldHVybiB0cnVlIGluY2x1ZGluZyAwIGlmIGludGVnZXIg cGFydCBvZiBSIGlzIGV2ZW4sIGVsc2UgcmV0dXJuIGZhbHNlLiAqLworCiti b29sCitpc19ldmVuIChSRUFMX1ZBTFVFX1RZUEUgKnIpCit7CisgIC8qIFRo ZSBmdW5jdGlvbiBpcyBub3Qgc3VwcG9zZWQgdG8gdXNlIGZvciBJbmYgYW5k IE5hTi4gKi8KKyAgZ2NjX2Fzc2VydCAoci0+Y2wgIT0gcnZjX2luZik7Cisg IGdjY19hc3NlcnQgKHItPmNsICE9IHJ2Y19uYW4pOworCisgIC8qIEZvciAo LTEsMSkgaW5jbHVkaW5nIDAsIG51bWJlciBpcyBldmVuLiAqLworICBpZiAo UkVBTF9FWFAgKHIpIDw9IDApCisgICAgcmV0dXJuIHRydWU7CisKKyAgLyog Q2hlY2sgbG93ZXN0IGJpdCwgaWYgbm90IHNldCwgcmV0dXJuIHRydWUuICov CisgIGVsc2UgaWYgKFJFQUxfRVhQIChyKSA8PSBTSUdOSUZJQ0FORF9CSVRT KQorICB7CisgICAgdW5zaWduZWQgaW50IG4gPSBTSUdOSUZJQ0FORF9CSVRT IC0gUkVBTF9FWFAgKHIpOworICAgIGludCB3ID0gbiAvIEhPU1RfQklUU19Q RVJfTE9ORzsKKworICAgIHVuc2lnbmVkIGxvbmcgbnVtID0gKCh1bnNpZ25l ZCBsb25nKTEgPDwgKG4gJSBIT1NUX0JJVFNfUEVSX0xPTkcpKTsKKworICAg IGlmICgoci0+c2lnW3ddICYgbnVtKSA9PSAwKQorICAgICAgcmV0dXJuIHRy dWU7CisgIH0KKworICBlbHNlIGlmIChSRUFMX0VYUCAocikgPiBTSUdOSUZJ Q0FORF9CSVRTKQorICAgIHJldHVybiB0cnVlOworCisgIHJldHVybiBmYWxz ZTsKK30KKworLyogUmV0dXJuIHRydWUgaWYgUiBpcyBoYWxmd2F5IGJldHdl ZW4gdHdvIGludGVnZXJzLCBlbHNlIHJldHVybiBmYWxzZS4gKi8KKworYm9v bAoraXNfaGFsZndheV9iZWxvdyAoY29uc3QgUkVBTF9WQUxVRV9UWVBFICpy KQoreworICAvKiBUaGUgZnVuY3Rpb24gaXMgbm90IHN1cHBvc2VkIHRvIHVz ZSBmb3IgSW5mIGFuZCBOYU4uICovCisgIGdjY19hc3NlcnQgKHItPmNsICE9 IHJ2Y19pbmYpOworICBnY2NfYXNzZXJ0IChyLT5jbCAhPSBydmNfbmFuKTsK KyAgaW50IGk7CisKKyAgLyogRm9yIG51bWJlcnMgKC0wLjUsMCkgYW5kICgw LDAuNSkuICovCisgIGlmIChSRUFMX0VYUCAocikgPCAwKQorICAgIHJldHVy biBmYWxzZTsKKworICBlbHNlIGlmIChSRUFMX0VYUCAocikgPD0gU0lHTklG SUNBTkRfQklUUykKKyAgeworICAgIHVuc2lnbmVkIGludCBuID0gU0lHTklG SUNBTkRfQklUUyAtIFJFQUxfRVhQIChyKTsKKyAgICBpbnQgdyA9IG4gLyBI T1NUX0JJVFNfUEVSX0xPTkc7CisKKyAgICBpZiAobiAlIEhPU1RfQklUU19Q RVJfTE9ORyA9PSAwKQorICAgIHsKKyAgICAgIGlmICh3ID4gMCkKKyAgICAg ICAgdyA9IHcgLSAxOworICAgICAgZWxzZQorICAgICAgICB3ID0gMDsKKyAg ICB9CisKKyAgICBmb3IgKGkgPSAwOyBpIDwgdzsgKytpKQorICAgIHsKKyAg ICAgIGlmIChyLT5zaWdbaV0gIT0gMCkKKyAgICAgICAgcmV0dXJuIGZhbHNl OworICAgIH0KKworICAgIHVuc2lnbmVkIGxvbmcgbnVtID0gKCh1bnNpZ25l ZCBsb25nKTEgPDwgKChuIC0gMSkgJSBIT1NUX0JJVFNfUEVSX0xPTkcpKTsK KworICAgIGlmICgoKHItPnNpZ1t3XSAmIG51bSkgIT0gMCkgJiYgKChyLT5z aWdbd10gJiAobnVtLTEpKSA9PSAwKSkKKyAgICAgIHJldHVybiB0cnVlOwor ICB9CisgIHJldHVybiBmYWxzZTsKK30KKworLyogUm91bmQgWCB0byBuZWFy ZXN0IGludGVnZXIsIHJvdW5kaW5nIGhhbGZ3YXkgY2FzZXMgdG93YXJkcyBl dmVuLiAqLworCit2b2lkCityZWFsX3JvdW5kZXZlbiAoUkVBTF9WQUxVRV9U WVBFICpyLCBmb3JtYXRfaGVscGVyIGZtdCwKKwkJY29uc3QgUkVBTF9WQUxV RV9UWVBFICp4KQoreworICBpZiAoaXNfaGFsZndheV9iZWxvdyAoeCkpCisg IHsKKyAgICBkb19hZGQgKHIsIHgsICZkY29uc3RoYWxmLCB4LT5zaWduKTsK KyAgICBpZiAoIWlzX2V2ZW4gKHIpKQorICAgICAgZG9fYWRkIChyLCByLCAm ZGNvbnN0bTEsIHgtPnNpZ24pOworICAgIGlmIChmbXQpCisgICAgICByZWFs X2NvbnZlcnQgKHIsIGZtdCwgcik7CisgIH0KKyAgZWxzZQorICAgIHJlYWxf cm91bmQgKHIsIGZtdCwgeCk7Cit9CisKIC8qIFNldCB0aGUgc2lnbiBvZiBS IHRvIHRoZSBzaWduIG9mIFguICAqLwogCiB2b2lkCmRpZmYgLS1naXQgYS9n Y2MvcmVhbC5oIGIvZ2NjL3JlYWwuaAppbmRleCAwY2U0MjU2NTcwOC4uZWJl NjZkMjM0YWYgMTAwNjQ0Ci0tLSBhL2djYy9yZWFsLmgKKysrIGIvZ2NjL3Jl YWwuaApAQCAtNDEsMTEgKzQxLDE4IEBAIHN0cnVjdCBHVFkoKCkpIHJlYWxf dmFsdWUgewogICAgICBzdXJlIHRoZXkncmUgcGFja2VkIHRvZ2V0aGVyLCBv dGhlcndpc2UgUkVBTF9WQUxVRV9UWVBFX1NJWkUgd2lsbAogICAgICBiZSBt aXNjb21wdXRlZC4gICovCiAgIHVuc2lnbmVkIGludCAvKiBFTlVNX0JJVEZJ RUxEIChyZWFsX3ZhbHVlX2NsYXNzKSAqLyBjbCA6IDI7CisgIC8qIDEgaWYg bnVtYmVyIGlzIGRlY2ltYWwgZmxvYXRpbmcgcG9pbnQgKi8KICAgdW5zaWdu ZWQgaW50IGRlY2ltYWwgOiAxOworICAvKiAxIGlmIG51bWJlciBpcyBuZWdh dGl2ZSAqLwogICB1bnNpZ25lZCBpbnQgc2lnbiA6IDE7CisgIC8qIDEgaWYg bnVtYmVyIGlzIHNpZ25hbGxpbmcgKi8KICAgdW5zaWduZWQgaW50IHNpZ25h bGxpbmcgOiAxOworICAvKiAxIGlmIG51bWJlciBpcyBjYW5vbmljYWwKKyAg QWxsIGFyZSBnZW5lcmFsbHkgdXNlZCBmb3IgaGFuZGxpbmcgY2FzZXMgaW4g cmVhbC5jICovCiAgIHVuc2lnbmVkIGludCBjYW5vbmljYWwgOiAxOworICAv KiB1bmJpYXNlZCBleHBvbmVudCBvZiB0aGUgbnVtYmVyICovCiAgIHVuc2ln bmVkIGludCB1ZXhwIDogRVhQX0JJVFM7CisgIC8qIHNpZ25pZmljYW5kIG9m IHRoZSBudW1iZXIgKi8KICAgdW5zaWduZWQgbG9uZyBzaWdbU0lHU1pdOwog fTsKIApAQCAtNDk5LDYgKzUwNiw4IEBAIGV4dGVybiB2b2lkIHJlYWxfY2Vp bCAoUkVBTF9WQUxVRV9UWVBFICosIGZvcm1hdF9oZWxwZXIsCiAJCSAgICAg ICBjb25zdCBSRUFMX1ZBTFVFX1RZUEUgKik7CiBleHRlcm4gdm9pZCByZWFs X3JvdW5kIChSRUFMX1ZBTFVFX1RZUEUgKiwgZm9ybWF0X2hlbHBlciwKIAkJ CWNvbnN0IFJFQUxfVkFMVUVfVFlQRSAqKTsKK2V4dGVybiB2b2lkIHJlYWxf cm91bmRldmVuIChSRUFMX1ZBTFVFX1RZUEUgKiwgZm9ybWF0X2hlbHBlciwK KyAgICAgIGNvbnN0IFJFQUxfVkFMVUVfVFlQRSAqKTsKIAogLyogU2V0IHRo ZSBzaWduIG9mIFIgdG8gdGhlIHNpZ24gb2YgWC4gICovCiBleHRlcm4gdm9p ZCByZWFsX2NvcHlzaWduIChSRUFMX1ZBTFVFX1RZUEUgKiwgY29uc3QgUkVB TF9WQUxVRV9UWVBFICopOwo= --000000000000c29cd6058a929be4--