From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 27777 invoked by alias); 23 Jan 2015 16:33:45 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 27709 invoked by uid 89); 23 Jan 2015 16:33:40 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-2.7 required=5.0 tests=AWL,BAYES_00,KAM_STOCKGEN,SPF_HELO_PASS,SPF_PASS,T_RP_MATCHES_RCVD autolearn=no version=3.3.2 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Fri, 23 Jan 2015 16:33:32 +0000 Received: from int-mx13.intmail.prod.int.phx2.redhat.com (int-mx13.intmail.prod.int.phx2.redhat.com [10.5.11.26]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id t0NGXSc5026425 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Fri, 23 Jan 2015 11:33:28 -0500 Received: from bordewijk.wildebeest.org (ovpn-116-65.ams2.redhat.com [10.36.116.65]) by int-mx13.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id t0NGXQmA022481 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=NO); Fri, 23 Jan 2015 11:33:27 -0500 Received: by bordewijk.wildebeest.org (Postfix, from userid 1000) id 210F4813383E; Fri, 23 Jan 2015 17:33:25 +0100 (CET) Message-ID: <1422030805.4858.16.camel@bordewijk.wildebeest.org> Subject: Re: [PATCH] Use GCC5/DWARF5 DW_AT_noreturn to mark functions that don't return normally. From: Mark Wielaard To: Pedro Alves Cc: Stan Shebs , gdb-patches@sourceware.org Date: Fri, 23 Jan 2015 16:42:00 -0000 In-Reply-To: <54BFDCD8.9090709@redhat.com> References: <1417099980-31834-1-git-send-email-mjw@redhat.com> <5480696F.1060308@redhat.com> <1418122161.18974.42.camel@bordewijk.wildebeest.org> <548745FD.40000@earthlink.net> <1418210696.5011.10.camel@bordewijk.wildebeest.org> <548AC7C3.9020000@redhat.com> <1421366172.26117.29.camel@bordewijk.wildebeest.org> <54BFDCD8.9090709@redhat.com> Content-Type: multipart/mixed; boundary="=-crnh20nHxsHFfFNVVzJ5" Mime-Version: 1.0 X-SW-Source: 2015-01/txt/msg00654.txt.bz2 --=-crnh20nHxsHFfFNVVzJ5 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Content-length: 5577 On Wed, 2015-01-21 at 17:07 +0000, Pedro Alves wrote: >=20 > On 01/15/2015 11:56 PM, Mark Wielaard wrote: >=20 > > create mode 100644 gdb/testsuite/gdb.base/noreturn.c > > create mode 100644 gdb/testsuite/gdb.base/noreturn.exp >=20 > How about "noreturn-return.{c|exp}", to go with noreturn_finish ? > > > create mode 100644 gdb/testsuite/gdb.base/noreturn_finish.c > > create mode 100644 gdb/testsuite/gdb.base/noreturn_finish.exp >=20 > But please use '-' instead of '_': > > gdb/testsuite/gdb.base/noreturn-finish.c > gdb/testsuite/gdb.base/noreturn-finish.exp OK, changed all file and test names. > > diff --git a/gdb/testsuite/gdb.base/noreturn.c b/gdb/testsuite/gdb.base= /noreturn.c > > new file mode 100644 > > index 0000000..e39cf15 > > --- /dev/null > > +++ b/gdb/testsuite/gdb.base/noreturn.c > > @@ -0,0 +1,13 @@ >=20 > Please add a copyright header. Even though some of our old > files don't have it, all new files should, even if the file > is small (so that we don't have to recall adding it back > if the file grows in future). Added. Note that most .c files in gdb.base don't have such a header. > > +void __attribute__((noreturn)) > > +noreturn_func () >=20 > noreturn_func (void) Added the void. Note most existing .c tests in gdb.base don't declare functions with void arguments. > > +{ > > + while (1) > > + ; >=20 > Please don't make the test loop forever if GDB crashes. > Does e.g., "abort()" like the other test work here too? Changed. It isn't semantically the same, but it does work. > > +} > > + > > +int > > +main () >=20 > likewise (void) Added. > > +{ > > + noreturn_func (); > > + return 0; > > +} > > diff --git a/gdb/testsuite/gdb.base/noreturn.exp b/gdb/testsuite/gdb.ba= se/noreturn.exp > > new file mode 100644 > > index 0000000..885642f > > --- /dev/null > > +++ b/gdb/testsuite/gdb.base/noreturn.exp > > @@ -0,0 +1,54 @@ > > +# Copyright 2015 Free Software Foundation, Inc. > > + > > +# This program is free software; you can redistribute it and/or modify > > +# it under the terms of the GNU General Public License as published by > > +# the Free Software Foundation; either version 3 of the License, or > > +# (at your option) any later version. > > +# > > +# This program is distributed in the hope that it will be useful, > > +# but WITHOUT ANY WARRANTY; without even the implied warranty of > > +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > > +# GNU General Public License for more details. > > +# > > +# You should have received a copy of the GNU General Public License > > +# along with this program. If not, see . > > + > > +standard_testfile .c >=20 > You can drop the ".c", as it's the default. Dropped. It is used in other .exp files though. > > + > > +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" execu= table {debug}] !=3D "" } { > > + untested noreturn.exp > > + return -1 > > +} >=20 > Use prepare_for_testing, like: >=20 > if [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug= }] { > return -1 > } Changed. This idiom comes from existing .exp files though. > > + > > +proc noreturn_test { } { > > + global gdb_prompt > > + > > + if { ! [ runto_main ] } then { > > + untested noreturn.exp >=20 > Use $testfile, like "untested ${testfile}.exp". Changed. > > + return -1 > > + } > > + > > + gdb_test "break noreturn_func" "Breakpoint \[0123456789\].*" \ > > + "set break on noreturn_func" > > + gdb_test "continue" "Breakpoint.* noreturn_func.*" \ > > + "continue to noreturn_func" >=20 > gdb_breakpoint "noreturn_func" > gdb_continue_to_breakpoint "noreturn_func" Changed. Note that the above comes from existing .exp testcases. > > + > > + gdb_test_multiple "return" "return from noreturn_func" { > > + -re "warning: Function does not return normally to caller" { > > + verbose -log "saw warning" > > + exp_continue > > + } > > + -re "Make noreturn_func return now.*y or n. $" { > > + send_gdb "n\n" > > + exp_continue > > + } > > + -re "Not confirmed.*$gdb_prompt $" { > > + pass "noreturn_func return cancelled" > > + } >=20 > Make the test message be the same in all paths, like: >=20 > set test "return from noreturn_func" > gdb_test_multiple "return" $test { > -re "warning: Function does not return normally to caller" { > verbose -log "saw warning" > exp_continue > } > -re "Make noreturn_func return now.*y or n. $" { > send_gdb "n\n" > exp_continue > } > -re "Not confirmed.*$gdb_prompt $" { > pass $test > } Changed > > + } > > +} > > + > > +clean_restart ${binfile} >=20 > prepare_for_testing does this for you. Dropped. > > + > > +set timeout 30 >=20 > I don't see why this is necessary. Dropped. > I think this is just a copy/paste? Yes, I just took the testcases you recommended and changed them to test the new warning messages added. > > +noreturn_test > > diff --git a/gdb/testsuite/gdb.base/noreturn_finish.c b/gdb/testsuite/g= db.base/noreturn_finish.c > > new file mode 100644 > > index 0000000..cd52769 > > --- /dev/null > > +++ b/gdb/testsuite/gdb.base/noreturn_finish.c > > @@ -0,0 +1,14 @@ > > +#include > > + > > +void __attribute__((noreturn)) > > +noreturn_func () > > +{ > > + abort (); > > +} > > + > > +int > > +main () > > +{ > > + noreturn_func (); > > + return 0; > > +} >=20 > Same comments apply to noreturn_finish.c|exp. Same changes made. > Otherwise OK. Pushed as attached after retesting under GCC 5 and 4.8.2. Thanks, Mark --=-crnh20nHxsHFfFNVVzJ5 Content-Disposition: inline; filename*0=0001-Use-GCC5-DWARF5-DW_AT_noreturn-to-mark-functions-tha.pat; filename*1=ch Content-Transfer-Encoding: base64 Content-Type: text/x-patch; name="0001-Use-GCC5-DWARF5-DW_AT_noreturn-to-mark-functions-tha.patch"; charset="UTF-8" Content-length: 19240 RnJvbSA3NDM2NDlmZDgwNzc2ZGU5MjI0NzUzNjJiZjNhYzhiNDQ1MTFiYjI0 IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQ0KRnJvbTogTWFyayBXaWVsYWFy ZCA8bWp3QHJlZGhhdC5jb20+DQpEYXRlOiBUdWUsIDkgRGVjIDIwMTQgMTE6 NDU6NDEgKzAxMDANClN1YmplY3Q6IFtQQVRDSF0gVXNlIEdDQzUvRFdBUkY1 IERXX0FUX25vcmV0dXJuIHRvIG1hcmsgZnVuY3Rpb25zIHRoYXQgZG9uJ3QN CiByZXR1cm4gbm9ybWFsbHkuDQoNCkFkZCBhIGZsYWcgZmllbGQgaXNfbm9y ZXR1cm4gdG8gc3RydWN0IGZ1bmNfdHlwZS4gTWFrZSBjYWxsaW5nX2NvbnZl bnRpb24NCmEgc21hbGwgYml0IGZpZWxkIHRvIG5vdCBpbmNyZWFzZSB0aGUg c2l6ZSBvZiB0aGUgc3RydWN0LiBTZXQgaXNfbm9yZXR1cm4NCmlmIHRoZSBu ZXcgR0NDNS9EV0FSRjUgRFdfQVRfbm9yZXR1cm4gaXMgc2V0IG9uIGEgRFdf VEFHX3N1YnByb2dyYW0uDQpVc2UgdGhpcyBpbmZvcm1hdGlvbiB0byB3YXJu IHRoZSB1c2VyIGJlZm9yZSBkb2luZyBhIGZpbmlzaCBvciByZXR1cm4gZnJv bQ0KYSBmdW5jdGlvbiB0aGF0IGRvZXMgbm90IHJldHVybiBub3JtYWxseSB0 byBpdHMgY2FsbGVyLg0KDQooZ2RiKSBmaW5pc2gNCndhcm5pbmc6IEZ1bmN0 aW9uIGVuZGxlc3MgZG9lcyBub3QgcmV0dXJuIG5vcm1hbGx5Lg0KVHJ5IHRv IGZpbmlzaCBhbnl3YXk/ICh5IG9yIG4pDQoNCihnZGIpIHJldHVybg0Kd2Fy bmluZzogRnVuY3Rpb24gZG9lcyBub3QgcmV0dXJuIG5vcm1hbGx5IHRvIGNh bGxlci4NCk1ha2UgZW5kbGVzcyByZXR1cm4gbm93PyAoeSBvciBuKQ0KDQpn ZGIvQ2hhbmdlTG9nDQoNCgkqIGR3YXJmMnJlYWQuYyAocmVhZF9zdWJyb3V0 aW5lX3R5cGUpOiBTZXQgVFlQRV9OT19SRVRVUk4gZnJvbQ0KCURXX0FUX25v cmV0dXJuLg0KCSogZ2RidHlwZXMuaCAoc3RydWN0IGZ1bmNfdHlwZSk6IEFk ZCBpc19ub3JldHVybiBmaWVsZCBmbGFnLiBNYWtlDQoJY2FsbGluZ19jb252 ZW50aW9uIGFuIDggYml0IGJpdCBmaWVsZC4NCgkoVFlQRV9OT19SRVRVUk4p OiBOZXcgbWFjcm8uDQoJKiBpbmZjbWQuYyAoZmluaXNoX2NvbW1hbmQpOiBR dWVyeSBpZiBmdW5jdGlvbiBkb2VzIG5vdCByZXR1cm4NCglub3JtYWxseS4N CgkqIHN0YWNrLmMgKHJldHVybl9jb21tYW5kKTogTGlrZXdpc2UuDQoNCmdk Yi90ZXN0c3VpdGUvQ2hhbmdlTG9nDQoNCgkqIGdkYi5iYXNlL25vcmV0dXJu LXJldHVybi5jOiBOZXcgZmlsZS4NCgkqIGdkYi5iYXNlL25vcmV0dXJuLXJl dHVybi5leHA6IE5ldyBmaWxlLg0KCSogZ2RiLmJhc2Uvbm9yZXR1cm4tZmlu aXNoLmM6IE5ldyBmaWxlLg0KCSogZ2RiLmJhc2Uvbm9yZXR1cm4tZmluaXNo LmV4cDogTmV3IGZpbGUuDQoNCmluY2x1ZGUvQ2hhbmdlTG9nDQoNCgkqIGR3 YXJmMi5kZWYgKERXX0FUX25vcmV0dXJuKTogTmV3IERXQVJGNSBhdHRyaWJ1 dGUuDQoNClRoZSBkd2FyZjIuaCBhZGRpdGlvbiBhbmQgdGhlIGNvZGUgdG8g ZW1pdCB0aGUgbmV3IGF0dHJpYnV0ZSBpcyBhbHJlYWR5IGluDQp0aGUgZ2Nj IHRyZWUuDQotLS0NCiBnZGIvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAxMSArKysrKysrDQogZ2RiL2R3YXJmMnJlYWQuYyAg ICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDYgKysrKw0KIGdkYi9nZGJ0 eXBlcy5oICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IDEyICsrKysr LS0NCiBnZGIvaW5mY21kLmMgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgOSArKysrKy0NCiBnZGIvc3RhY2suYyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgOCArKystLQ0KIGdkYi90ZXN0c3VpdGUvQ2hh bmdlTG9nICAgICAgICAgICAgICAgICAgICB8ICA3ICsrKysNCiBnZGIvdGVz dHN1aXRlL2dkYi5iYXNlL25vcmV0dXJuLWZpbmlzaC5jICAgfCAzMSArKysr KysrKysrKysrKysrKysNCiBnZGIvdGVzdHN1aXRlL2dkYi5iYXNlL25vcmV0 dXJuLWZpbmlzaC5leHAgfCA1MSArKysrKysrKysrKysrKysrKysrKysrKysr KysrKysNCiBnZGIvdGVzdHN1aXRlL2dkYi5iYXNlL25vcmV0dXJuLXJldHVy bi5jICAgfCAzMSArKysrKysrKysrKysrKysrKysNCiBnZGIvdGVzdHN1aXRl L2dkYi5iYXNlL25vcmV0dXJuLXJldHVybi5leHAgfCA1MSArKysrKysrKysr KysrKysrKysrKysrKysrKysrKysNCiBpbmNsdWRlL0NoYW5nZUxvZyAgICAg ICAgICAgICAgICAgICAgICAgICAgfCAgNCArKysNCiBpbmNsdWRlL2R3YXJm Mi5kZWYgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMiArKw0KIDEyIGZp bGVzIGNoYW5nZWQsIDIxOCBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9ucygt KQ0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBnZGIvdGVzdHN1aXRlL2dkYi5iYXNl L25vcmV0dXJuLWZpbmlzaC5jDQogY3JlYXRlIG1vZGUgMTAwNjQ0IGdkYi90 ZXN0c3VpdGUvZ2RiLmJhc2Uvbm9yZXR1cm4tZmluaXNoLmV4cA0KIGNyZWF0 ZSBtb2RlIDEwMDY0NCBnZGIvdGVzdHN1aXRlL2dkYi5iYXNlL25vcmV0dXJu LXJldHVybi5jDQogY3JlYXRlIG1vZGUgMTAwNjQ0IGdkYi90ZXN0c3VpdGUv Z2RiLmJhc2Uvbm9yZXR1cm4tcmV0dXJuLmV4cA0KDQpkaWZmIC0tZ2l0IGEv Z2RiL0NoYW5nZUxvZyBiL2dkYi9DaGFuZ2VMb2cNCmluZGV4IDgxOGViN2Mu LmMxOTVmNWQgMTAwNjQ0DQotLS0gYS9nZGIvQ2hhbmdlTG9nDQorKysgYi9n ZGIvQ2hhbmdlTG9nDQpAQCAtMSwzICsxLDE0IEBADQorMjAxNS0wMS0xNSAg TWFyayBXaWVsYWFyZCAgPG1qd0ByZWRoYXQuY29tPg0KKw0KKwkqIGR3YXJm MnJlYWQuYyAocmVhZF9zdWJyb3V0aW5lX3R5cGUpOiBTZXQgVFlQRV9OT19S RVRVUk4gZnJvbQ0KKwlEV19BVF9ub3JldHVybi4NCisJKiBnZGJ0eXBlcy5o IChzdHJ1Y3QgZnVuY190eXBlKTogQWRkIGlzX25vcmV0dXJuIGZpZWxkIGZs YWcuIE1ha2UNCisJY2FsbGluZ19jb252ZW50aW9uIGFuIDggYml0IGJpdCBm aWVsZC4NCisJKFRZUEVfTk9fUkVUVVJOKTogTmV3IG1hY3JvLg0KKwkqIGlu ZmNtZC5jIChmaW5pc2hfY29tbWFuZCk6IFF1ZXJ5IGlmIGZ1bmN0aW9uIGRv ZXMgbm90IHJldHVybg0KKwlub3JtYWxseS4NCisJKiBzdGFjay5jIChyZXR1 cm5fY29tbWFuZCk6IExpa2V3aXNlLg0KKw0KIDIwMTUtMDEtMjMgIFBlZHJv IEFsdmVzICA8cGFsdmVzQHJlZGhhdC5jb20+DQogDQogCSogbGludXgtbmF0 LmMgKGxpbnV4X2lzX2FzeW5jX3ApOiBOZXcgbWFjcm8uDQpkaWZmIC0tZ2l0 IGEvZ2RiL2R3YXJmMnJlYWQuYyBiL2dkYi9kd2FyZjJyZWFkLmMNCmluZGV4 IDk2YjI1MzcuLjlkNzY1YzUgMTAwNjQ0DQotLS0gYS9nZGIvZHdhcmYycmVh ZC5jDQorKysgYi9nZGIvZHdhcmYycmVhZC5jDQpAQCAtMTQzNDMsNiArMTQz NDMsMTIgQEAgcmVhZF9zdWJyb3V0aW5lX3R5cGUgKHN0cnVjdCBkaWVfaW5m byAqZGllLCBzdHJ1Y3QgZHdhcmYyX2N1ICpjdSkNCiAgIGVsc2UNCiAgICAg VFlQRV9DQUxMSU5HX0NPTlZFTlRJT04gKGZ0eXBlKSA9IERXX0NDX25vcm1h bDsNCiANCisgIC8qIFJlY29yZCB3aGV0aGVyIHRoZSBmdW5jdGlvbiByZXR1 cm5zIG5vcm1hbGx5IHRvIGl0cyBjYWxsZXIgb3Igbm90DQorICAgICBpZiB0 aGUgRFdBUkYgcHJvZHVjZXIgc2V0IHRoYXQgaW5mb3JtYXRpb24uICAqLw0K KyAgYXR0ciA9IGR3YXJmMl9hdHRyIChkaWUsIERXX0FUX25vcmV0dXJuLCBj dSk7DQorICBpZiAoYXR0ciAmJiAoRFdfVU5TTkQgKGF0dHIpICE9IDApKQ0K KyAgICBUWVBFX05PX1JFVFVSTiAoZnR5cGUpID0gMTsNCisNCiAgIC8qIFdl IG5lZWQgdG8gYWRkIHRoZSBzdWJyb3V0aW5lIHR5cGUgdG8gdGhlIGRpZSBp bW1lZGlhdGVseSBzbw0KICAgICAgd2UgZG9uJ3QgaW5maW5pdGVseSByZWN1 cnNlIHdoZW4gZGVhbGluZyB3aXRoIHBhcmFtZXRlcnMNCiAgICAgIGRlY2xh cmVkIGFzIHRoZSBzYW1lIHN1YnJvdXRpbmUgdHlwZS4gICovDQpkaWZmIC0t Z2l0IGEvZ2RiL2dkYnR5cGVzLmggYi9nZGIvZ2RidHlwZXMuaA0KaW5kZXgg N2MwNmE0Zi4uYmE1Yzg1NyAxMDA2NDQNCi0tLSBhL2dkYi9nZGJ0eXBlcy5o DQorKysgYi9nZGIvZ2RidHlwZXMuaA0KQEAgLTEwMTksOSArMTAxOSwxNiBA QCBzdHJ1Y3QgZnVuY190eXBlDQogICB7DQogICAgIC8qICogVGhlIGNhbGxp bmcgY29udmVudGlvbiBmb3IgdGFyZ2V0cyBzdXBwb3J0aW5nIG11bHRpcGxl IEFCSXMuDQogICAgICAgIFJpZ2h0IG5vdyB0aGlzIGlzIG9ubHkgZmV0Y2hl ZCBmcm9tIHRoZSBEd2FyZi0yDQotICAgICAgIERXX0FUX2NhbGxpbmdfY29u dmVudGlvbiBhdHRyaWJ1dGUuICAqLw0KKyAgICAgICBEV19BVF9jYWxsaW5n X2NvbnZlbnRpb24gYXR0cmlidXRlLiAgVGhlIHZhbHVlIGlzIG9uZSBvZiB0 aGUNCisgICAgICAgRFdfQ0MgZW51bSBkd2FyZl9jYWxsaW5nX2NvbnZlbnRp b24gY29uc3RhbnRzLiAgKi8NCiANCi0gICAgdW5zaWduZWQgY2FsbGluZ19j b252ZW50aW9uOw0KKyAgICB1bnNpZ25lZCBjYWxsaW5nX2NvbnZlbnRpb24g OiA4Ow0KKw0KKyAgICAvKiAqIFdoZXRoZXIgdGhpcyBmdW5jdGlvbiBub3Jt YWxseSByZXR1cm5zIHRvIGl0cyBjYWxsZXIuICBJdCBpcw0KKyAgICAgICBz ZXQgZnJvbSB0aGUgRFdfQVRfbm9yZXR1cm4gYXR0cmlidXRlIGlmIHNldCBv biB0aGUNCisgICAgICAgRFdfVEFHX3N1YnByb2dyYW0uICAqLw0KKw0KKyAg ICB1bnNpZ25lZCBpbnQgaXNfbm9yZXR1cm4gOiAxOw0KIA0KICAgICAvKiAq IE9ubHkgdGhvc2UgRFdfVEFHX0dOVV9jYWxsX3NpdGUncyBpbiB0aGlzIGZ1 bmN0aW9uIHRoYXQgaGF2ZQ0KICAgICAgICBEV19BVF9HTlVfdGFpbF9jYWxs IHNldCBhcmUgbGlua2VkIGluIHRoaXMgbGlzdC4gIEZ1bmN0aW9uDQpAQCAt MTI0NSw2ICsxMjUyLDcgQEAgZXh0ZXJuIHZvaWQgYWxsb2NhdGVfZ25hdF9h dXhfdHlwZSAoc3RydWN0IHR5cGUgKik7DQogI2RlZmluZSBUWVBFX0dOQVRf U1BFQ0lGSUModGhpc3R5cGUpIFRZUEVfTUFJTl9UWVBFKHRoaXN0eXBlKS0+ dHlwZV9zcGVjaWZpYy5nbmF0X3N0dWZmDQogI2RlZmluZSBUWVBFX0RFU0NS SVBUSVZFX1RZUEUodGhpc3R5cGUpIFRZUEVfR05BVF9TUEVDSUZJQyh0aGlz dHlwZSktPmRlc2NyaXB0aXZlX3R5cGUNCiAjZGVmaW5lIFRZUEVfQ0FMTElO R19DT05WRU5USU9OKHRoaXN0eXBlKSBUWVBFX01BSU5fVFlQRSh0aGlzdHlw ZSktPnR5cGVfc3BlY2lmaWMuZnVuY19zdHVmZi0+Y2FsbGluZ19jb252ZW50 aW9uDQorI2RlZmluZSBUWVBFX05PX1JFVFVSTih0aGlzdHlwZSkgVFlQRV9N QUlOX1RZUEUodGhpc3R5cGUpLT50eXBlX3NwZWNpZmljLmZ1bmNfc3R1ZmYt PmlzX25vcmV0dXJuDQogI2RlZmluZSBUWVBFX1RBSUxfQ0FMTF9MSVNUKHRo aXN0eXBlKSBUWVBFX01BSU5fVFlQRSh0aGlzdHlwZSktPnR5cGVfc3BlY2lm aWMuZnVuY19zdHVmZi0+dGFpbF9jYWxsX2xpc3QNCiAjZGVmaW5lIFRZUEVf QkFTRUNMQVNTKHRoaXN0eXBlLGluZGV4KSBUWVBFX0ZJRUxEX1RZUEUodGhp c3R5cGUsIGluZGV4KQ0KICNkZWZpbmUgVFlQRV9OX0JBU0VDTEFTU0VTKHRo aXN0eXBlKSBUWVBFX0NQTFVTX1NQRUNJRklDKHRoaXN0eXBlKS0+bl9iYXNl Y2xhc3Nlcw0KZGlmZiAtLWdpdCBhL2dkYi9pbmZjbWQuYyBiL2dkYi9pbmZj bWQuYw0KaW5kZXggN2IyNjY2My4uOWExZmI4ZCAxMDA2NDQNCi0tLSBhL2dk Yi9pbmZjbWQuYw0KKysrIGIvZ2RiL2luZmNtZC5jDQpAQCAtMTg3Miw3ICsx ODcyLDE0IEBAIGZpbmlzaF9jb21tYW5kIChjaGFyICphcmcsIGludCBmcm9t X3R0eSkNCiAgICAgICBpZiAoZXhlY3V0aW9uX2RpcmVjdGlvbiA9PSBFWEVD X1JFVkVSU0UpDQogCXByaW50Zl9maWx0ZXJlZCAoXygiUnVuIGJhY2sgdG8g Y2FsbCBvZiAiKSk7DQogICAgICAgZWxzZQ0KLQlwcmludGZfZmlsdGVyZWQg KF8oIlJ1biB0aWxsIGV4aXQgZnJvbSAiKSk7DQorCXsNCisJICBpZiAoZnVu Y3Rpb24gIT0gTlVMTCAmJiBUWVBFX05PX1JFVFVSTiAoZnVuY3Rpb24tPnR5 cGUpDQorCSAgICAgICYmICFxdWVyeSAoXygid2FybmluZzogRnVuY3Rpb24g JXMgZG9lcyBub3QgcmV0dXJuIG5vcm1hbGx5LlxuIg0KKwkJCSAgICJUcnkg dG8gZmluaXNoIGFueXdheT8gIiksDQorCQkJIFNZTUJPTF9QUklOVF9OQU1F IChmdW5jdGlvbikpKQ0KKwkgICAgZXJyb3IgKF8oIk5vdCBjb25maXJtZWQu IikpOw0KKwkgIHByaW50Zl9maWx0ZXJlZCAoXygiUnVuIHRpbGwgZXhpdCBm cm9tICIpKTsNCisJfQ0KIA0KICAgICAgIHByaW50X3N0YWNrX2ZyYW1lIChn ZXRfc2VsZWN0ZWRfZnJhbWUgKE5VTEwpLCAxLCBMT0NBVElPTiwgMCk7DQog ICAgIH0NCmRpZmYgLS1naXQgYS9nZGIvc3RhY2suYyBiL2dkYi9zdGFjay5j DQppbmRleCAwMjAxZDBhLi41ZjJhM2RjIDEwMDY0NA0KLS0tIGEvZ2RiL3N0 YWNrLmMNCisrKyBiL2dkYi9zdGFjay5jDQpAQCAtMjQ2Miw4ICsyNDYyLDEy IEBAIHJldHVybl9jb21tYW5kIChjaGFyICpyZXR2YWxfZXhwLCBpbnQgZnJv bV90dHkpDQogCWNvbmZpcm1lZCA9IHF1ZXJ5IChfKCIlc01ha2Ugc2VsZWN0 ZWQgc3RhY2sgZnJhbWUgcmV0dXJuIG5vdz8gIiksDQogCQkJICAgcXVlcnlf cHJlZml4KTsNCiAgICAgICBlbHNlDQotCWNvbmZpcm1lZCA9IHF1ZXJ5IChf KCIlc01ha2UgJXMgcmV0dXJuIG5vdz8gIiksIHF1ZXJ5X3ByZWZpeCwNCi0J CQkgICBTWU1CT0xfUFJJTlRfTkFNRSAodGhpc2Z1bikpOw0KKwl7DQorCSAg aWYgKFRZUEVfTk9fUkVUVVJOICh0aGlzZnVuLT50eXBlKSkNCisJICAgIHdh cm5pbmcgKCJGdW5jdGlvbiBkb2VzIG5vdCByZXR1cm4gbm9ybWFsbHkgdG8g Y2FsbGVyLiIpOw0KKwkgIGNvbmZpcm1lZCA9IHF1ZXJ5IChfKCIlc01ha2Ug JXMgcmV0dXJuIG5vdz8gIiksIHF1ZXJ5X3ByZWZpeCwNCisJCQkgICAgIFNZ TUJPTF9QUklOVF9OQU1FICh0aGlzZnVuKSk7DQorCX0NCiAgICAgICBpZiAo IWNvbmZpcm1lZCkNCiAJZXJyb3IgKF8oIk5vdCBjb25maXJtZWQiKSk7DQog ICAgIH0NCmRpZmYgLS1naXQgYS9nZGIvdGVzdHN1aXRlL0NoYW5nZUxvZyBi L2dkYi90ZXN0c3VpdGUvQ2hhbmdlTG9nDQppbmRleCAxYTE3YmE0Li41YjUz Y2RkIDEwMDY0NA0KLS0tIGEvZ2RiL3Rlc3RzdWl0ZS9DaGFuZ2VMb2cNCisr KyBiL2dkYi90ZXN0c3VpdGUvQ2hhbmdlTG9nDQpAQCAtMSwzICsxLDEwIEBA DQorMjAxNS0wMS0xNSAgTWFyayBXaWVsYWFyZCAgPG1qd0ByZWRoYXQuY29t Pg0KKw0KKwkqIGdkYi5iYXNlL25vcmV0dXJuLXJldHVybi5jOiBOZXcgZmls ZS4NCisJKiBnZGIuYmFzZS9ub3JldHVybi1yZXR1cm4uZXhwOiBOZXcgZmls ZS4NCisJKiBnZGIuYmFzZS9ub3JldHVybi1maW5pc2guYzogTmV3IGZpbGUu DQorCSogZ2RiLmJhc2Uvbm9yZXR1cm4tZmluaXNoLmV4cDogTmV3IGZpbGUu DQorDQogMjAxNS0wMS0yMyAgUGVkcm8gQWx2ZXMgIDxwYWx2ZXNAcmVkaGF0 LmNvbT4NCiANCiAJKiBnZGIudGhyZWFkcy9jb250aW51ZS1wZW5kaW5nLWFm dGVyLXF1ZXJ5LmM6IE5ldyBmaWxlLg0KZGlmZiAtLWdpdCBhL2dkYi90ZXN0 c3VpdGUvZ2RiLmJhc2Uvbm9yZXR1cm4tZmluaXNoLmMgYi9nZGIvdGVzdHN1 aXRlL2dkYi5iYXNlL25vcmV0dXJuLWZpbmlzaC5jDQpuZXcgZmlsZSBtb2Rl IDEwMDY0NA0KaW5kZXggMDAwMDAwMC4uM2VjNDhjZA0KLS0tIC9kZXYvbnVs bA0KKysrIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuYmFzZS9ub3JldHVybi1maW5p c2guYw0KQEAgLTAsMCArMSwzMSBAQA0KKy8qIFRoaXMgdGVzdGNhc2UgaXMg cGFydCBvZiBHREIsIHRoZSBHTlUgZGVidWdnZXIuDQorDQorICAgQ29weXJp Z2h0IDIwMTUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuDQorDQor ICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkNCisgICBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieQ0KKyAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247 IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yDQorICAgKGF0 IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4NCisNCisgICBUaGlz IHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3 aWxsIGJlIHVzZWZ1bCwNCisgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7 IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZg0KKyAgIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRS4gIFNlZSB0aGUNCisgICBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLg0KKw0KKyAgIFlvdSBzaG91bGQgaGF2ZSBy ZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlDQorICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNl ZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uICAqLw0KKw0KKyNp bmNsdWRlIDxzdGRsaWIuaD4NCisNCit2b2lkIF9fYXR0cmlidXRlX18oKG5v cmV0dXJuKSkNCitub3JldHVybl9mdW5jICh2b2lkKQ0KK3sNCisgIGFib3J0 ICgpOw0KK30NCisNCitpbnQNCittYWluICh2b2lkKQ0KK3sNCisgIG5vcmV0 dXJuX2Z1bmMgKCk7DQorICByZXR1cm4gMDsNCit9DQpkaWZmIC0tZ2l0IGEv Z2RiL3Rlc3RzdWl0ZS9nZGIuYmFzZS9ub3JldHVybi1maW5pc2guZXhwIGIv Z2RiL3Rlc3RzdWl0ZS9nZGIuYmFzZS9ub3JldHVybi1maW5pc2guZXhwDQpu ZXcgZmlsZSBtb2RlIDEwMDY0NA0KaW5kZXggMDAwMDAwMC4uYTJhZTBkYg0K LS0tIC9kZXYvbnVsbA0KKysrIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuYmFzZS9u b3JldHVybi1maW5pc2guZXhwDQpAQCAtMCwwICsxLDUxIEBADQorIyBDb3B5 cmlnaHQgMjAxNSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4NCisN CisjIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJl ZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5DQorIyBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieQ0KKyMgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsg ZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3INCisjIChhdCB5 b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uDQorIw0KKyMgVGhpcyBw cm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2ls bCBiZSB1c2VmdWwsDQorIyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdp dGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZg0KKyMgTUVSQ0hB TlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZQ0KKyMgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9y IG1vcmUgZGV0YWlscy4NCisjDQorIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2 ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQ0K KyMgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNlZSA8aHR0 cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uDQorDQorc3RhbmRhcmRfdGVz dGZpbGUNCisNCitpZiBbcHJlcGFyZV9mb3JfdGVzdGluZyAiZmFpbGVkIHRv IHByZXBhcmUiICR7dGVzdGZpbGV9ICR7c3JjZmlsZX0ge2RlYnVnfV0gew0K KyAgICByZXR1cm4gLTENCit9DQorDQorcHJvYyBub3JldHVybl9maW5pc2hf dGVzdCB7IH0gew0KKyAgICBnbG9iYWwgZ2RiX3Byb21wdA0KKw0KKyAgICBp ZiB7ICEgWyBydW50b19tYWluIF0gfSB0aGVuIHsNCisJdW50ZXN0ZWQgJHt0 ZXN0ZmlsZX0uZXhwDQorCXJldHVybiAtMQ0KKyAgICB9DQorDQorICAgIGdk Yl9icmVha3BvaW50ICJub3JldHVybl9mdW5jIg0KKyAgICBnZGJfY29udGlu dWVfdG9fYnJlYWtwb2ludCAibm9yZXR1cm5fZnVuYyINCisNCisgICAgc2V0 IHRlc3QgImNhbmNlbCBmaW5pc2ggZnJvbSBub3JldHVybl9mdW5jIg0KKyAg ICBnZGJfdGVzdF9tdWx0aXBsZSAiZmluaXNoIiAkdGVzdCB7DQorCS1yZSAi d2FybmluZzogRnVuY3Rpb24gbm9yZXR1cm5fZnVuYyBkb2VzIG5vdCByZXR1 cm4gbm9ybWFsbHkiIHsNCisJICAgIHZlcmJvc2UgLWxvZyAic2F3IHdhcm5p bmciDQorCSAgICBleHBfY29udGludWUNCisJfQ0KKwktcmUgIlRyeSB0byBm aW5pc2ggYW55d2F5Lip5IG9yIG4uKiAkIiB7DQorCSAgICBzZW5kX2dkYiAi blxuIg0KKwkgICAgZXhwX2NvbnRpbnVlDQorCX0NCisJLXJlICIuKiRnZGJf cHJvbXB0ICQiIHsNCisJICAgIHBhc3MgJHRlc3QNCisJfQ0KKyAgIH0NCit9 DQorDQorY2xlYW5fcmVzdGFydCAke2JpbmZpbGV9DQorDQorbm9yZXR1cm5f ZmluaXNoX3Rlc3QNCmRpZmYgLS1naXQgYS9nZGIvdGVzdHN1aXRlL2dkYi5i YXNlL25vcmV0dXJuLXJldHVybi5jIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuYmFz ZS9ub3JldHVybi1yZXR1cm4uYw0KbmV3IGZpbGUgbW9kZSAxMDA2NDQNCmlu ZGV4IDAwMDAwMDAuLjNlYzQ4Y2QNCi0tLSAvZGV2L251bGwNCisrKyBiL2dk Yi90ZXN0c3VpdGUvZ2RiLmJhc2Uvbm9yZXR1cm4tcmV0dXJuLmMNCkBAIC0w LDAgKzEsMzEgQEANCisvKiBUaGlzIHRlc3RjYXNlIGlzIHBhcnQgb2YgR0RC LCB0aGUgR05VIGRlYnVnZ2VyLg0KKw0KKyAgIENvcHlyaWdodCAyMDE1IEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLg0KKw0KKyAgIFRoaXMgcHJv Z3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp dCBhbmQvb3IgbW9kaWZ5DQorICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkN CisgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVy c2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcg0KKyAgIChhdCB5b3VyIG9wdGlv bikgYW55IGxhdGVyIHZlcnNpb24uDQorDQorICAgVGhpcyBwcm9ncmFtIGlz IGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsDQorICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2 ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YNCisgICBNRVJDSEFOVEFCSUxJ VFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlDQorICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4NCisNCisgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQ0KKyAgIGFs b25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93 d3cuZ251Lm9yZy9saWNlbnNlcy8+LiAgKi8NCisNCisjaW5jbHVkZSA8c3Rk bGliLmg+DQorDQordm9pZCBfX2F0dHJpYnV0ZV9fKChub3JldHVybikpDQor bm9yZXR1cm5fZnVuYyAodm9pZCkNCit7DQorICBhYm9ydCAoKTsNCit9DQor DQoraW50DQorbWFpbiAodm9pZCkNCit7DQorICBub3JldHVybl9mdW5jICgp Ow0KKyAgcmV0dXJuIDA7DQorfQ0KZGlmZiAtLWdpdCBhL2dkYi90ZXN0c3Vp dGUvZ2RiLmJhc2Uvbm9yZXR1cm4tcmV0dXJuLmV4cCBiL2dkYi90ZXN0c3Vp dGUvZ2RiLmJhc2Uvbm9yZXR1cm4tcmV0dXJuLmV4cA0KbmV3IGZpbGUgbW9k ZSAxMDA2NDQNCmluZGV4IDAwMDAwMDAuLjhhNjRhM2UNCi0tLSAvZGV2L251 bGwNCisrKyBiL2dkYi90ZXN0c3VpdGUvZ2RiLmJhc2Uvbm9yZXR1cm4tcmV0 dXJuLmV4cA0KQEAgLTAsMCArMSw1MSBAQA0KKyMgQ29weXJpZ2h0IDIwMTUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuDQorDQorIyBUaGlzIHBy b2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUg aXQgYW5kL29yIG1vZGlmeQ0KKyMgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkN CisjIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJz aW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yDQorIyAoYXQgeW91ciBvcHRpb24p IGFueSBsYXRlciB2ZXJzaW9uLg0KKyMNCisjIFRoaXMgcHJvZ3JhbSBpcyBk aXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LA0KKyMgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4g dGhlIGltcGxpZWQgd2FycmFudHkgb2YNCisjIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUN CisjIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFp bHMuDQorIw0KKyMgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UNCisjIGFsb25nIHdp dGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251 Lm9yZy9saWNlbnNlcy8+Lg0KKw0KK3N0YW5kYXJkX3Rlc3RmaWxlDQorDQor aWYgW3ByZXBhcmVfZm9yX3Rlc3RpbmcgImZhaWxlZCB0byBwcmVwYXJlIiAk e3Rlc3RmaWxlfSAke3NyY2ZpbGV9IHtkZWJ1Z31dIHsNCisgICAgcmV0dXJu IC0xDQorfQ0KKw0KK3Byb2Mgbm9yZXR1cm5fdGVzdCB7IH0gew0KKyAgICBn bG9iYWwgZ2RiX3Byb21wdA0KKw0KKyAgICBpZiB7ICEgWyBydW50b19tYWlu IF0gfSB0aGVuIHsNCisJdW50ZXN0ZWQgJHt0ZXN0ZmlsZX0uZXhwDQorCXJl dHVybiAtMQ0KKyAgICB9DQorDQorICAgIGdkYl9icmVha3BvaW50ICJub3Jl dHVybl9mdW5jIg0KKyAgICBnZGJfY29udGludWVfdG9fYnJlYWtwb2ludCAi bm9yZXR1cm5fZnVuYyINCisNCisgICAgc2V0IHRlc3QgImNhbmNlbCByZXR1 cm4gZnJvbSBub3JldHVybl9mdW5jIg0KKyAgICBnZGJfdGVzdF9tdWx0aXBs ZSAicmV0dXJuIiAkdGVzdCB7DQorCS1yZSAid2FybmluZzogRnVuY3Rpb24g ZG9lcyBub3QgcmV0dXJuIG5vcm1hbGx5IHRvIGNhbGxlciIgew0KKwkgICAg dmVyYm9zZSAtbG9nICJzYXcgd2FybmluZyINCisJICAgIGV4cF9jb250aW51 ZQ0KKwl9DQorCS1yZSAiTWFrZSBub3JldHVybl9mdW5jIHJldHVybiBub3cu Knkgb3Igbi4gJCIgew0KKwkgICAgc2VuZF9nZGIgIm5cbiINCisJICAgIGV4 cF9jb250aW51ZQ0KKwl9DQorCS1yZSAiTm90IGNvbmZpcm1lZC4qJGdkYl9w cm9tcHQgJCIgew0KKwkgICAgcGFzcyAkdGVzdA0KKwl9DQorICAgfQ0KK30N CisNCitjbGVhbl9yZXN0YXJ0ICR7YmluZmlsZX0NCisNCitub3JldHVybl90 ZXN0DQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9DaGFuZ2VMb2cgYi9pbmNsdWRl L0NoYW5nZUxvZw0KaW5kZXggMzFmMWUxOC4uMjFiNmFlNiAxMDA2NDQNCi0t LSBhL2luY2x1ZGUvQ2hhbmdlTG9nDQorKysgYi9pbmNsdWRlL0NoYW5nZUxv Zw0KQEAgLTEsMyArMSw3IEBADQorMjAxNS0wMS0xNSAgTWFyayBXaWVsYWFy ZCAgPG1qd0ByZWRoYXQuY29tPg0KKw0KKwkqIGR3YXJmMi5kZWYgKERXX0FU X25vcmV0dXJuKTogTmV3IERXQVJGNSBhdHRyaWJ1dGUuDQorDQogMjAxNS0w MS0xNCAgSmFuLUJlbmVkaWN0IEdsYXcgIDxqYmdsYXdAbHVnLW93bC5kZT4N CiANCiAJKiBsaWJpYmVydHkuaDogTWVyZ2UgZnJvbSBHQ0MuDQpkaWZmIC0t Z2l0IGEvaW5jbHVkZS9kd2FyZjIuZGVmIGIvaW5jbHVkZS9kd2FyZjIuZGVm DQppbmRleCA1ZGEzYWUwLi4zYWVjZGZjIDEwMDY0NA0KLS0tIGEvaW5jbHVk ZS9kd2FyZjIuZGVmDQorKysgYi9pbmNsdWRlL2R3YXJmMi5kZWYNCkBAIC0z MDYsNiArMzA2LDggQEAgRFdfQVQgKERXX0FUX2RhdGFfYml0X29mZnNldCwg MHg2YikNCiBEV19BVCAoRFdfQVRfY29uc3RfZXhwciwgMHg2YykNCiBEV19B VCAoRFdfQVRfZW51bV9jbGFzcywgMHg2ZCkNCiBEV19BVCAoRFdfQVRfbGlu a2FnZV9uYW1lLCAweDZlKQ0KKy8qIERXQVJGIDUuICAqLw0KK0RXX0FUIChE V19BVF9ub3JldHVybiwgMHg4NykNCiANCiBEV19BVF9EVVAgKERXX0FUX2xv X3VzZXIsIDB4MjAwMCkgLyogSW1wbGVtZW50YXRpb24tZGVmaW5lZCByYW5n ZSBzdGFydC4gICovDQogRFdfQVRfRFVQIChEV19BVF9oaV91c2VyLCAweDNm ZmYpIC8qIEltcGxlbWVudGF0aW9uLWRlZmluZWQgcmFuZ2UgZW5kLiAgKi8N Ci0tIA0KMS44LjMuMQ0KDQo= --=-crnh20nHxsHFfFNVVzJ5--