136616 2014-09-07 17:53:21 -0700 Introduce COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE) and use it 2014-09-09 14:11:56 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 mjs mjs benjamin cmarcelo commit-queue fpizlo oldest_to_newest 1033761 0 mjs 2014-09-07 17:53:21 -0700 Introduce COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE) and use it 1033762 1 237761 mjs 2014-09-07 17:55:16 -0700 Created attachment 237761 Patch 1033767 2 mjs 2014-09-07 18:04:29 -0700 Testing this for arm32/64 to see if it fixes the build issues. 1033769 3 237761 darin 2014-09-07 18:11:19 -0700 Comment on attachment 237761 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=237761&action=review I find the name of this a bit oblique and even possibly ambiguous. a) To “consider unreachable code” could be to correctly consider whether code is unreachable and complain if any such code is included. b) Or to “consider unreachable code” could be to compile unreachable code, as a matter of policy or even compiler ignorance, and evaluate the properties of that code as if it was reachable, warning about missing return statements and uninitialized variables and such. I think you mean (b), but I had thought you meant (a). What’s undeniable is that it is indeed a compiler quirk. And that this name is long enough that we could revise it with a global replace. > Source/JavaScriptCore/jsc.cpp:368 > -#if !COMPILER(CLANG) && !COMPILER(MSVC) > +#if COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE) > return true; > #endif We will now compile in this return statement on MSVC; is that an intentional change? 1033770 4 mjs 2014-09-07 18:23:59 -0700 (In reply to comment #3) > (From update of attachment 237761 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=237761&action=review > > > Source/JavaScriptCore/jsc.cpp:368 > > -#if !COMPILER(CLANG) && !COMPILER(MSVC) > > +#if COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE) > > return true; > > #endif > > We will now compile in this return statement on MSVC; is that an intentional change? I'm not sure if MSVC requires excluding this code, or just doesn't require including it. My plan was for the EWS bot to tell me if this change is wrong. 1033777 5 mjs 2014-09-07 19:17:09 -0700 Committed r173370: <http://trac.webkit.org/changeset/173370> 1033921 6 fpizlo 2014-09-08 12:25:23 -0700 This is really gross. I think it's a step in the wrong direction to introduce #if-based control flow all over the place. Isn't there some alternative that doesn't involve uglifying the code? 1033974 7 mjs 2014-09-08 15:42:21 -0700 (In reply to comment #6) > This is really gross. I think it's a step in the wrong direction to introduce #if-based control flow all over the place. > > Isn't there some alternative that doesn't involve uglifying the code? Here's the constraints: - Some non-clang compilers (GCC and perhaps MSVC, don't know for sure) analyze dead code paths when determining things like variables that may be uninitialized. So if we leave the #if'd code out, we get warnings in those. - New clang has a warning for unreachable code which seems kinda useful in theory (though not sure it has caught any real issues for us yet). It will give warnings if we leave the #if'd code in. Alternatives I can think of: - Drop support for non-clang compilers (probably not practical if MSVC is one of the compilers to spuriously warn without this code). - Lower warning levels on gcc so it doesn't check for uninitialized variables at all. - Turn clang's unreachable code warning back off. I can't think of a solution that keeps all the warnings on and avoids #ifs. I guess one possibility is we could make RELEASE_ASSERT() take a block as an extra parameter, which would hide the #if in RELEASE_ASSERT but would still be ugly. I'm not sure if any of these is ideal. I have nothing against turning the warning off the warning. I just tried to fix the build without expressing an opinion on that. 1033976 8 fpizlo 2014-09-08 15:57:10 -0700 (In reply to comment #7) > (In reply to comment #6) > > This is really gross. I think it's a step in the wrong direction to introduce #if-based control flow all over the place. > > > > Isn't there some alternative that doesn't involve uglifying the code? > > Here's the constraints: > > - Some non-clang compilers (GCC and perhaps MSVC, don't know for sure) analyze dead code paths when determining things like variables that may be uninitialized. So if we leave the #if'd code out, we get warnings in those. > > - New clang has a warning for unreachable code which seems kinda useful in theory (though not sure it has caught any real issues for us yet). It will give warnings if we leave the #if'd code in. > > Alternatives I can think of: > - Drop support for non-clang compilers (probably not practical if MSVC is one of the compilers to spuriously warn without this code). > - Lower warning levels on gcc so it doesn't check for uninitialized variables at all. > - Turn clang's unreachable code warning back off. I suspect that this last option is better than uglification. > > I can't think of a solution that keeps all the warnings on and avoids #ifs. I guess one possibility is we could make RELEASE_ASSERT() take a block as an extra parameter, which would hide the #if in RELEASE_ASSERT but would still be ugly. > > > I'm not sure if any of these is ideal. I have nothing against turning the warning off the warning. I just tried to fix the build without expressing an opinion on that. Does the unreachable code warning require guarding things like a "break" or "return" after a "CRASH()"? It seems from your patch that it doesn't; for example: default: RELEASE_ASSERT_NOT_REACHED(); +#if COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE) clippedValue = 0; // Make some compilers, and mhahnenberg, happy. +#endif break; } If this is true, then I propose a new macro, which I will call DEAD_DEF() for now because I haven't thought of a better name, yet: #if COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE) #define DEAD_DEF(definition) do { definition } while (false) #else #define DEAD_DEF(definition) do { } while (false) #endif Then the change above, from DFGOSRExitCompilerCommon.cpp, would just be: default: RELEASE_ASSERT_NOT_REACHED(); - clippedValue = 0; // Make some compilers, and mhahnenberg, happy. + DEAD_DEF(clippedValue = 0); // Make some compilers, and mhahnenberg, happy. break; } 1033983 9 mjs 2014-09-08 16:29:49 -0700 (In reply to comment #8) > (In reply to comment #7) > > (In reply to comment #6) > > > This is really gross. I think it's a step in the wrong direction to introduce #if-based control flow all over the place. > > > > > > Isn't there some alternative that doesn't involve uglifying the code? > > > > Here's the constraints: > > > > - Some non-clang compilers (GCC and perhaps MSVC, don't know for sure) analyze dead code paths when determining things like variables that may be uninitialized. So if we leave the #if'd code out, we get warnings in those. > > > > - New clang has a warning for unreachable code which seems kinda useful in theory (though not sure it has caught any real issues for us yet). It will give warnings if we leave the #if'd code in. > > > > Alternatives I can think of: > > - Drop support for non-clang compilers (probably not practical if MSVC is one of the compilers to spuriously warn without this code). > > - Lower warning levels on gcc so it doesn't check for uninitialized variables at all. > > - Turn clang's unreachable code warning back off. > > I suspect that this last option is better than uglification. > > > > > I can't think of a solution that keeps all the warnings on and avoids #ifs. I guess one possibility is we could make RELEASE_ASSERT() take a block as an extra parameter, which would hide the #if in RELEASE_ASSERT but would still be ugly. > > > > > > I'm not sure if any of these is ideal. I have nothing against turning the warning off the warning. I just tried to fix the build without expressing an opinion on that. > > Does the unreachable code warning require guarding things like a "break" or "return" after a "CRASH()"? It seems from your patch that it doesn't; for example: > > default: > RELEASE_ASSERT_NOT_REACHED(); > +#if COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE) > clippedValue = 0; // Make some compilers, and mhahnenberg, happy. > +#endif > break; > } > > If this is true, then I propose a new macro, which I will call DEAD_DEF() for now because I haven't thought of a better name, yet: > > #if COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE) > #define DEAD_DEF(definition) do { definition } while (false) > #else > #define DEAD_DEF(definition) do { } while (false) > #endif > > Then the change above, from DFGOSRExitCompilerCommon.cpp, would just be: > > default: > RELEASE_ASSERT_NOT_REACHED(); > - clippedValue = 0; // Make some compilers, and mhahnenberg, happy. > + DEAD_DEF(clippedValue = 0); // Make some compilers, and mhahnenberg, happy. > break; > } That is totally reasonable and I considered doing it that way. In some cases there are returns inside the #if's, but that is compatible with this approach AFAICT. Instead of DEAD_DEF I would just call the macro UNREACHABLE() (or maybe DEAD()). The statement need not be a definition or assignment. I can post a patch along those lines if you liked it. 1033984 10 fpizlo 2014-09-08 16:31:13 -0700 (In reply to comment #9) > (In reply to comment #8) > > (In reply to comment #7) > > > (In reply to comment #6) > > > > This is really gross. I think it's a step in the wrong direction to introduce #if-based control flow all over the place. > > > > > > > > Isn't there some alternative that doesn't involve uglifying the code? > > > > > > Here's the constraints: > > > > > > - Some non-clang compilers (GCC and perhaps MSVC, don't know for sure) analyze dead code paths when determining things like variables that may be uninitialized. So if we leave the #if'd code out, we get warnings in those. > > > > > > - New clang has a warning for unreachable code which seems kinda useful in theory (though not sure it has caught any real issues for us yet). It will give warnings if we leave the #if'd code in. > > > > > > Alternatives I can think of: > > > - Drop support for non-clang compilers (probably not practical if MSVC is one of the compilers to spuriously warn without this code). > > > - Lower warning levels on gcc so it doesn't check for uninitialized variables at all. > > > - Turn clang's unreachable code warning back off. > > > > I suspect that this last option is better than uglification. > > > > > > > > I can't think of a solution that keeps all the warnings on and avoids #ifs. I guess one possibility is we could make RELEASE_ASSERT() take a block as an extra parameter, which would hide the #if in RELEASE_ASSERT but would still be ugly. > > > > > > > > > I'm not sure if any of these is ideal. I have nothing against turning the warning off the warning. I just tried to fix the build without expressing an opinion on that. > > > > Does the unreachable code warning require guarding things like a "break" or "return" after a "CRASH()"? It seems from your patch that it doesn't; for example: > > > > default: > > RELEASE_ASSERT_NOT_REACHED(); > > +#if COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE) > > clippedValue = 0; // Make some compilers, and mhahnenberg, happy. > > +#endif > > break; > > } > > > > If this is true, then I propose a new macro, which I will call DEAD_DEF() for now because I haven't thought of a better name, yet: > > > > #if COMPILER_QUIRK(CONSIDERS_UNREACHABLE_CODE) > > #define DEAD_DEF(definition) do { definition } while (false) > > #else > > #define DEAD_DEF(definition) do { } while (false) > > #endif > > > > Then the change above, from DFGOSRExitCompilerCommon.cpp, would just be: > > > > default: > > RELEASE_ASSERT_NOT_REACHED(); > > - clippedValue = 0; // Make some compilers, and mhahnenberg, happy. > > + DEAD_DEF(clippedValue = 0); // Make some compilers, and mhahnenberg, happy. > > break; > > } > > That is totally reasonable and I considered doing it that way. In some cases there are returns inside the #if's, but that is compatible with this approach AFAICT. > > Instead of DEAD_DEF I would just call the macro UNREACHABLE() (or maybe DEAD()). The statement need not be a definition or assignment. I can post a patch along those lines if you liked it. Yes, this sounds great! 1034165 11 mjs 2014-09-09 14:11:56 -0700 (In reply to comment #10) > (In reply to comment #9) > > Instead of DEAD_DEF I would just call the macro UNREACHABLE() (or maybe DEAD()). The statement need not be a definition or assignment. I can post a patch along those lines if you liked it. > > Yes, this sounds great! https://bugs.webkit.org/show_bug.cgi?id=136679 237761 2014-09-07 17:55:16 -0700 2014-09-07 18:11:17 -0700 Patch bug-136616-20140907175511.patch text/plain 7864 mjs SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMTczMzY4KQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDMxIEBA CisyMDE0LTA5LTA3ICBNYWNpZWogU3RhY2hvd2lhayAgPG1qc0BhcHBsZS5jb20+CisKKyAgICAg ICAgSW50cm9kdWNlIENPTVBJTEVSX1FVSVJLKENPTlNJREVSU19VTlJFQUNIQUJMRV9DT0RFKSBh bmQgdXNlIGl0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0xMzY2MTYKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKyAgICAgICAg CisgICAgICAgIE1hbnkgY29tcGlsZXJzIHdpbGwgYW5hbHl6ZSB1bnJlY2hhYmxlIGNvZGUgcGF0 aHMgKGUuZy4gYWZ0ZXIgYW4KKyAgICAgICAgdW5yZWFjaGFibGUgY29kZSBwYXRoKSwgc28gc29t ZXRpbWVzIHRoZXkgbmVlZCBkZWFkIGNvZGUgaW5pdGlhbGl6YXRpb25zLgorICAgICAgICBCdXQg Y2xhbmcgd2l0aCBzdWl0YWJsZSB3YXJuaW5ncyB3aWxsIGNvbXBsYWluIGFib3V0IHVucmVhY2hh YmxlIGNvZGUuIFNvCisgICAgICAgIHVzZSB0aGUgcXVpcmsgdG8gaW5jbHVkZSBpdCBjb25kaXRp b25hbGx5LgorCisgICAgICAgICogYnl0ZWNvZGUvQ29kZUJsb2NrLmNwcDoKKyAgICAgICAgKEpT Qzo6Q29kZUJsb2NrOjpwcmludEdldEJ5SWRPcCk6CisgICAgICAgICogZGZnL0RGR09TUkV4aXRD b21waWxlckNvbW1vbi5jcHA6CisgICAgICAgIChKU0M6OkRGRzo6aGFuZGxlRXhpdENvdW50cyk6 CisgICAgICAgICogZGZnL0RGR1BsYW4uY3BwOgorICAgICAgICAoSlNDOjpERkc6OlBsYW46OmNv bXBpbGVJblRocmVhZCk6CisgICAgICAgICogZGZnL0RGR1NwZWN1bGF0aXZlSklULmNwcDoKKyAg ICAgICAgKEpTQzo6REZHOjpTcGVjdWxhdGl2ZUpJVDo6c2lsZW50U2F2ZVBsYW5Gb3JHUFIpOgor ICAgICAgICAqIGpzYy5jcHA6CisgICAgICAgICogcnVudGltZS9KU0FycmF5LmNwcDoKKyAgICAg ICAgKEpTQzo6SlNBcnJheTo6ZmlsbEFyZ0xpc3QpOgorICAgICAgICAoSlNDOjpKU0FycmF5Ojpj b3B5VG9Bcmd1bWVudHMpOgorICAgICAgICAqIHJ1bnRpbWUvUmVnRXhwLmNwcDoKKyAgICAgICAg KEpTQzo6UmVnRXhwOjpjb21waWxlKToKKyAgICAgICAgKEpTQzo6UmVnRXhwOjpjb21waWxlTWF0 Y2hPbmx5KToKKwogMjAxNC0wOS0wNiAgRGFyaW4gQWRsZXIgIDxkYXJpbkBhcHBsZS5jb20+CiAK ICAgICAgICAgTWFrZSB1cGRhdGVzIHN1Z2dlc3RlZCBieSBuZXcgdmVyc2lvbiBvZiBYY29kZQpJ bmRleDogU291cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNl L0phdmFTY3JpcHRDb3JlL2pzYy5jcHAJKHJldmlzaW9uIDE3MzM2OCkKKysrIFNvdXJjZS9KYXZh U2NyaXB0Q29yZS9qc2MuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNjMsNyArMzYzLDcgQEAgcHVi bGljOgogICAgIHN0YXRpYyBOT19SRVRVUk5fRFVFX1RPX0NSQVNIIGJvb2wgZGVsZXRlUHJvcGVy dHkoSlNDZWxsKiwgRXhlY1N0YXRlKiwgUHJvcGVydHlOYW1lKQogICAgIHsKICAgICAgICAgUkVM RUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKLSNpZiAhQ09NUElMRVIoQ0xBTkcpICYmICFDT01Q SUxFUihNU1ZDKQorI2lmIENPTVBJTEVSX1FVSVJLKENPTlNJREVSU19VTlJFQUNIQUJMRV9DT0RF KQogICAgICAgICByZXR1cm4gdHJ1ZTsKICNlbmRpZgogICAgIH0KSW5kZXg6IFNvdXJjZS9KYXZh U2NyaXB0Q29yZS9ieXRlY29kZS9Db2RlQmxvY2suY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9K YXZhU2NyaXB0Q29yZS9ieXRlY29kZS9Db2RlQmxvY2suY3BwCShyZXZpc2lvbiAxNzMzNjgpCisr KyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvYnl0ZWNvZGUvQ29kZUJsb2NrLmNwcAkod29ya2luZyBj b3B5KQpAQCAtMjc5LDcgKzI3OSw5IEBAIHZvaWQgQ29kZUJsb2NrOjpwcmludEdldEJ5SWRPcChQ cmludFN0cmUKICAgICAgICAgYnJlYWs7CiAgICAgZGVmYXVsdDoKICAgICAgICAgUkVMRUFTRV9B U1NFUlRfTk9UX1JFQUNIRUQoKTsKKyNpZiBDT01QSUxFUl9RVUlSSyhDT05TSURFUlNfVU5SRUFD SEFCTEVfQ09ERSkKICAgICAgICAgb3AgPSAwOworI2VuZGlmCiAgICAgfQogICAgIGludCByMCA9 ICgrK2l0KS0+dS5vcGVyYW5kOwogICAgIGludCByMSA9ICgrK2l0KS0+dS5vcGVyYW5kOwpJbmRl eDogU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdPU1JFeGl0Q29tcGlsZXJDb21tb24uY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHT1NSRXhpdENvbXBp bGVyQ29tbW9uLmNwcAkocmV2aXNpb24gMTczMzY4KQorKysgU291cmNlL0phdmFTY3JpcHRDb3Jl L2RmZy9ERkdPU1JFeGl0Q29tcGlsZXJDb21tb24uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMjMs NyArMTIzLDkgQEAgdm9pZCBoYW5kbGVFeGl0Q291bnRzKENDYWxsSGVscGVycyYgaml0LAogICAg ICAgICBicmVhazsKICAgICBkZWZhdWx0OgogICAgICAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVB Q0hFRCgpOworI2lmIENPTVBJTEVSX1FVSVJLKENPTlNJREVSU19VTlJFQUNIQUJMRV9DT0RFKQog ICAgICAgICBjbGlwcGVkVmFsdWUgPSAwOyAvLyBNYWtlIHNvbWUgY29tcGlsZXJzLCBhbmQgbWhh aG5lbmJlcmcsIGhhcHB5LgorI2VuZGlmCiAgICAgICAgIGJyZWFrOwogICAgIH0KICAgICBqaXQu c3RvcmUzMihBc3NlbWJseUhlbHBlcnM6OlRydXN0ZWRJbW0zMigtY2xpcHBlZFZhbHVlKSwgQXNz ZW1ibHlIZWxwZXJzOjpBZGRyZXNzKEdQUkluZm86OnJlZ1QwLCBDb2RlQmxvY2s6Om9mZnNldE9m SklURXhlY3V0ZUNvdW50ZXIoKSkpOwpJbmRleDogU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9E RkdQbGFuLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR1Bs YW4uY3BwCShyZXZpc2lvbiAxNzMzNjgpCisrKyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RG R1BsYW4uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xODEsNyArMTgxLDkgQEAgdm9pZCBQbGFuOjpj b21waWxlSW5UaHJlYWQoTG9uZ0xpdmVkU3RhdAogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAg IGRlZmF1bHQ6CiAgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworI2lm IENPTVBJTEVSX1FVSVJLKENPTlNJREVSU19VTlJFQUNIQUJMRV9DT0RFKQogICAgICAgICAgICAg cGF0aE5hbWUgPSAiIjsKKyNlbmRpZgogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KICAg ICAgICAgZG91YmxlIG5vdyA9IGN1cnJlbnRUaW1lTVMoKTsKSW5kZXg6IFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS9kZmcvREZHU3BlY3VsYXRpdmVKSVQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9K YXZhU2NyaXB0Q29yZS9kZmcvREZHU3BlY3VsYXRpdmVKSVQuY3BwCShyZXZpc2lvbiAxNzMzNjgp CisrKyBTb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR1NwZWN1bGF0aXZlSklULmNwcAkod29y a2luZyBjb3B5KQpAQCAtMzMxLDcgKzMzMSw5IEBAIFNpbGVudFJlZ2lzdGVyU2F2ZVBsYW4gU3Bl Y3VsYXRpdmVKSVQ6OnMKICAgICB9IGVsc2UgaWYgKHJlZ2lzdGVyRm9ybWF0ID09IERhdGFGb3Jt YXRCb29sZWFuKSB7CiAjaWYgVVNFKEpTVkFMVUU2NCkKICAgICAgICAgUkVMRUFTRV9BU1NFUlRf Tk9UX1JFQUNIRUQoKTsKKyNpZiBDT01QSUxFUl9RVUlSSyhDT05TSURFUlNfVU5SRUFDSEFCTEVf Q09ERSkKICAgICAgICAgZmlsbEFjdGlvbiA9IERvTm90aGluZ0ZvckZpbGw7CisjZW5kaWYKICNl bGlmIFVTRShKU1ZBTFVFMzJfNjQpCiAgICAgICAgIEFTU0VSVChpbmZvLmdwcigpID09IHNvdXJj ZSk7CiAgICAgICAgIGlmIChub2RlLT5oYXNDb25zdGFudCgpKSB7CkBAIC0zNjcsNyArMzY5LDkg QEAgU2lsZW50UmVnaXN0ZXJTYXZlUGxhbiBTcGVjdWxhdGl2ZUpJVDo6cwogICAgICAgICAgICAg ZmlsbEFjdGlvbiA9IExvYWQ2NDsKICAgICAgICAgZWxzZSB7CiAgICAgICAgICAgICBSRUxFQVNF X0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworI2lmICFDT01QSUxFUihDTEFORykKICAgICAgICAgICAg IGZpbGxBY3Rpb24gPSBMb2FkNjQ7IC8vIE1ha2UgR0NDIGhhcHB5LgorI2VuZGlmCiAgICAgICAg IH0KICAgICB9IGVsc2UgaWYgKHJlZ2lzdGVyRm9ybWF0ID09IERhdGFGb3JtYXRTdHJpY3RJbnQ1 MikgewogICAgICAgICBpZiAobm9kZS0+aGFzQ29uc3RhbnQoKSkKQEAgLTM4MCw3ICszODQsOSBA QCBTaWxlbnRSZWdpc3RlclNhdmVQbGFuIFNwZWN1bGF0aXZlSklUOjpzCiAgICAgICAgICAgICBm aWxsQWN0aW9uID0gTG9hZDY0OwogICAgICAgICBlbHNlIHsKICAgICAgICAgICAgIFJFTEVBU0Vf QVNTRVJUX05PVF9SRUFDSEVEKCk7CisjaWYgIUNPTVBJTEVSKENMQU5HKQogICAgICAgICAgICAg ZmlsbEFjdGlvbiA9IExvYWQ2NDsgLy8gTWFrZSBHQ0MgaGFwcHkuCisjZW5kaWYKICAgICAgICAg fQogICAgIH0gZWxzZSB7CiAgICAgICAgIEFTU0VSVChyZWdpc3RlckZvcm1hdCAmIERhdGFGb3Jt YXRKUyk7CkluZGV4OiBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0FycmF5LmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0FycmF5LmNwcAko cmV2aXNpb24gMTczMzY4KQorKysgU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNBcnJh eS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE1NTMsNyArMTU1Myw3IEBAIHZvaWQgSlNBcnJheTo6 ZmlsbEFyZ0xpc3QoRXhlY1N0YXRlKiBleGUKICAgICAgICAgCiAgICAgZGVmYXVsdDoKICAgICAg ICAgQ1JBU0goKTsKLSNpZiAhQ09NUElMRVIoQ0xBTkcpCisjaWYgQ09NUElMRVJfUVVJUksoQ09O U0lERVJTX1VOUkVBQ0hBQkxFX0NPREUpCiAgICAgICAgIHZlY3RvciA9IDA7CiAgICAgICAgIHZl Y3RvckVuZCA9IDA7CiAgICAgICAgIGJyZWFrOwpAQCAtMTYxNyw3ICsxNjE3LDcgQEAgdm9pZCBK U0FycmF5Ojpjb3B5VG9Bcmd1bWVudHMoRXhlY1N0YXRlKgogICAgICAgICAKICAgICBkZWZhdWx0 OgogICAgICAgICBDUkFTSCgpOwotI2lmICFDT01QSUxFUihDTEFORykKKyNpZiBDT01QSUxFUl9R VUlSSyhDT05TSURFUlNfVU5SRUFDSEFCTEVfQ09ERSkKICAgICAgICAgdmVjdG9yID0gMDsKICAg ICAgICAgdmVjdG9yRW5kID0gMDsKICAgICAgICAgYnJlYWs7CkluZGV4OiBTb3VyY2UvSmF2YVNj cmlwdENvcmUvcnVudGltZS9SZWdFeHAuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL1JlZ0V4cC5jcHAJKHJldmlzaW9uIDE3MzM2OCkKKysrIFNvdXJjZS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL1JlZ0V4cC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI3Myw4 ICsyNzMsMTAgQEAgdm9pZCBSZWdFeHA6OmNvbXBpbGUoVk0qIHZtLCBZYXJyOjpZYXJyQwogICAg IFlhcnI6OllhcnJQYXR0ZXJuIHBhdHRlcm4obV9wYXR0ZXJuU3RyaW5nLCBpZ25vcmVDYXNlKCks IG11bHRpbGluZSgpLCAmbV9jb25zdHJ1Y3Rpb25FcnJvcik7CiAgICAgaWYgKG1fY29uc3RydWN0 aW9uRXJyb3IpIHsKICAgICAgICAgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyNpZiBD T01QSUxFUl9RVUlSSyhDT05TSURFUlNfVU5SRUFDSEFCTEVfQ09ERSkKICAgICAgICAgbV9zdGF0 ZSA9IFBhcnNlRXJyb3I7CiAgICAgICAgIHJldHVybjsKKyNlbmRpZgogICAgIH0KICAgICBBU1NF UlQobV9udW1TdWJwYXR0ZXJucyA9PSBwYXR0ZXJuLm1fbnVtU3VicGF0dGVybnMpOwogCkBAIC0z OTYsOCArMzk4LDEwIEBAIHZvaWQgUmVnRXhwOjpjb21waWxlTWF0Y2hPbmx5KFZNKiB2bSwgWWEK ICAgICBZYXJyOjpZYXJyUGF0dGVybiBwYXR0ZXJuKG1fcGF0dGVyblN0cmluZywgaWdub3JlQ2Fz ZSgpLCBtdWx0aWxpbmUoKSwgJm1fY29uc3RydWN0aW9uRXJyb3IpOwogICAgIGlmIChtX2NvbnN0 cnVjdGlvbkVycm9yKSB7CiAgICAgICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFDSEVEKCk7Cisj aWYgQ09NUElMRVJfUVVJUksoQ09OU0lERVJTX1VOUkVBQ0hBQkxFX0NPREUpCiAgICAgICAgIG1f c3RhdGUgPSBQYXJzZUVycm9yOwogICAgICAgICByZXR1cm47CisjZW5kaWYKICAgICB9CiAgICAg QVNTRVJUKG1fbnVtU3VicGF0dGVybnMgPT0gcGF0dGVybi5tX251bVN1YnBhdHRlcm5zKTsKIApJ bmRleDogU291cmNlL1dURi9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dURi9DaGFu Z2VMb2cJKHJldmlzaW9uIDE3MzM2OCkKKysrIFNvdXJjZS9XVEYvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTIgQEAKKzIwMTQtMDktMDcgIE1hY2llaiBTdGFjaG93aWFrICA8 bWpzQGFwcGxlLmNvbT4KKworICAgICAgICBJbnRyb2R1Y2UgQ09NUElMRVJfUVVJUksoQ09OU0lE RVJTX1VOUkVBQ0hBQkxFX0NPREUpIGFuZCB1c2UgaXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNjYxNgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgICogd3RmL0NvbXBpbGVyLmg6IERlZmluZSB0aGUgcXVp cmsgZm9yIGFsbCBjb21waWxlcnMgYnV0IGNsYW5nLgorCiAyMDE0LTA5LTA2ICBTYW0gV2Vpbmln ICA8c2FtQHdlYmtpdC5vcmc+CiAKICAgICAgICAgWFBDUHRyIHNob3VsZCBiZSBjb252ZXJ0ZWQg aW50byBhbiBhbGwgcHVycG9zZSBzbWFydCBwb2ludGVyIGZvciBvc19vYmplY3RzCkluZGV4OiBT b3VyY2UvV1RGL3d0Zi9Db21waWxlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XVEYvd3RmL0Nv bXBpbGVyLmgJKHJldmlzaW9uIDE3MzM2OCkKKysrIFNvdXJjZS9XVEYvd3RmL0NvbXBpbGVyLmgJ KHdvcmtpbmcgY29weSkKQEAgLTc0LDYgKzc0LDEwIEBACiAjZGVmaW5lIFdURl9DT01QSUxFUl9T VVBQT1JUU19DWFhfVVNFUl9MSVRFUkFMUyAxCiAjZW5kaWYKIAorI2lmICFDT01QSUxFUihDTEFO RykKKyNkZWZpbmUgV1RGX0NPTVBJTEVSX1FVSVJLX0NPTlNJREVSU19VTlJFQUNIQUJMRV9DT0RF IDEKKyNlbmRpZgorCiAjaWYgQ09NUElMRVIoR0NDKSAmJiAhQ09NUElMRVIoQ0xBTkcpICYmIGRl ZmluZWQoX19TVERDX1ZFUlNJT05fXykgJiYgX19TVERDX1ZFUlNJT05fXyA+PSAyMDExMTJMCiAj ZGVmaW5lIFdURl9DT01QSUxFUl9TVVBQT1JUU19DX1NUQVRJQ19BU1NFUlQgMQogI2VuZGlmCg==