217425 2020-10-07 04:12:19 -0700 REGRESSION(r268115) [GTK] Build failures with GCC 7 (Ubuntu 18.04) and GCC 8 (Debian Buster) 2020-10-19 19:15:58 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=217390 P2 Normal --- 1 lmoura lmoura annulen benjamin berto bugs-noreply cdumez clopez cmarcelo ews-watchlist gyuyoung.kim ryuan.choi sergio oldest_to_newest 1695499 0 lmoura 2020-10-07 04:12:19 -0700 Ubuntu 18.04: gcc 7.5.0 `<filesystem>` is available as `<experimental/filesystem>` (`std::experimental::filesystem` namespace) and needs `-lstdc++fs` Debian Buster: gcc 8.3.0 Also would need `-lstdc++fs` Tools/WebKitTestRunner/CMakeFiles/WebKitTestRunner.dir/TestOptions.cpp.o:TestOptions.cpp:function WTR::parseTestHeader(std::filesystem::__cxx11::path, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&): error: undefined reference to 'std::filesystem::status(std::filesystem::__cxx11::path const&)' Tools/WebKitTestRunner/CMakeFiles/WebKitTestRunner.dir/TestOptions.cpp.o:TestOptions.cpp:function WTR::featureDefaultsFromTestHeaderForTest(WTR::TestCommand const&): error: undefined reference to 'std::filesystem::__cxx11::path::_M_split_cmpts()' collect2: error: ld returned 1 exit status 1695500 1 berto 2020-10-07 04:35:05 -0700 From the GCC 9 changelog: Using the types and functions in <filesystem> does not require linking with -lstdc++fs now. So you can check for that. 1695501 2 410744 lmoura 2020-10-07 04:37:28 -0700 Created attachment 410744 Especulative fix for GCC 8 and older 1695511 3 410744 annulen 2020-10-07 05:26:31 -0700 Comment on attachment 410744 Especulative fix for GCC 8 and older View in context: https://bugs.webkit.org/attachment.cgi?id=410744&action=review > Source/cmake/WebKitCompilerFlags.cmake:140 > + if (${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS "9.0" AND NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang") This is not a correct condition, at very least it should use CMAKE_COMPILER_IS_GNUCXX to test for GCC. However, it also leaves Clang broken on Linux, where it uses libstdc++ from GCC by default[*]. Adding -lstdc++fs to compiler flags is also erroneous, because it is a linking flag. I think we need linking test here, if stdc++fs is accepted it should be added to global linker flags like it's done for SANITIZER_LINK_FLAGS. [*] While clang has an option for libc++, it needs to be installed separately, and produced binaries are not compatible with c++ libraries built against libc++ 1695512 4 annulen 2020-10-07 05:38:35 -0700 Probably the best approach would be to use check_cxx_source_compiles() with minimal <filesystem> usage. It should work like ATOMIC_TEST_SOURCE check in WebKitCompilerFlags.cmake and will be very similar in implementation. 1695786 5 lmoura 2020-10-07 20:55:52 -0700 (In reply to Konstantin Tokarev from comment #4) > Probably the best approach would be to use check_cxx_source_compiles() with > minimal <filesystem> usage. It should work like ATOMIC_TEST_SOURCE check in > WebKitCompilerFlags.cmake and will be very similar in implementation. Right, will check it. The original patch that introduced this issue was reverted in r268143. Btw, this filesystem issue with older gcc is still an issue within cmake: https://gitlab.kitware.com/cmake/cmake/-/issues/17834 1698017 6 411406 lmoura 2020-10-14 21:47:09 -0700 Created attachment 411406 Tentative patch with actual cmake test source Updated patch with sample program to test. Tested the patch against gcc-9/8/7 and clang-7. The original file (from LLVM) contains no copyright. Should it be added? 1698018 7 411406 lmoura 2020-10-14 21:52:40 -0700 Comment on attachment 411406 Tentative patch with actual cmake test source View in context: https://bugs.webkit.org/attachment.cgi?id=411406&action=review Some self comments. > Source/WTF/wtf/StdFilesystem.h:12 > +#elif HAVE(STD_EXPERIMENTAL_FILESYSTEM) Maybe USE(STD_EXPERTIMENTAL_FILESYSTEM) would have been better than HAVE? Also, given stdc++fs is added to WTR_Libraries only for GCC/CLANG, should this guard be here too? (Not sure how this would affect mac builds, especially for 10.14, which was the original target of this file) > Source/cmake/OptionsCommon.cmake:159 > + SET_AND_EXPOSE_TO_BUILD(HAVE_STD_EXPERIMENTAL_FILESYSTEM TRUE) Ditto. > Tools/WebKitTestRunner/CMakeLists.txt:32 > + ${WebKitTestRunner_LIBRARIES} I tried CMAKE_CXX_IMPLICIT_LINK_LIBRARIES but it seemed to be ignored. And adding to FLAGS caused it to come before the target file, still causing link errors. 1698019 8 lmoura 2020-10-14 22:06:54 -0700 Ah well. JSC bots (cross compiled) failed the check_cxx_source_runs check. I had to add it (instead of just compile) because in GCC 8 the <filesystem> test builds without stdc++fs, but segfaults at runtime. 1698039 9 annulen 2020-10-15 01:23:39 -0700 If it's not possible to change test to avoid segfault at run time, it's better to change policy to link stdc++fs by default, and omit it only if linking fails 1698070 10 clopez 2020-10-15 04:45:28 -0700 (In reply to Lauro Moura from comment #8) > Ah well. JSC bots (cross compiled) failed the check_cxx_source_runs check. > > I had to add it (instead of just compile) because in GCC 8 the <filesystem> > test builds without stdc++fs, but segfaults at runtime. This is a problem. Our build needs to be cross-compiler friendly. We build WebKit a lot for foreign architectures with Yocto and Buildroot We need to figure out of a way of doing this test without actually running the executable. Why this simple test compiles with GCC8 but WebKit doesn't? 1698471 11 lmoura 2020-10-15 22:18:15 -0700 (In reply to Carlos Alberto Lopez Perez from comment #10) > (In reply to Lauro Moura from comment #8) > > Ah well. JSC bots (cross compiled) failed the check_cxx_source_runs check. > > > > I had to add it (instead of just compile) because in GCC 8 the <filesystem> > > test builds without stdc++fs, but segfaults at runtime. > > This is a problem. Our build needs to be cross-compiler friendly. We build > WebKit a lot for foreign architectures with Yocto and Buildroot Yeah, this flew under my radar while testing the patch. > > We need to figure out of a way of doing this test without actually running > the executable. > > Why this simple test compiles with GCC8 but WebKit doesn't? Checking the bots errors again, I managed to reproduce WebKit's compile error with the snippet inside an ubuntu18 container. Meanwhile, in my Ubuntu 20 system, GCC8 compiled WebKit normally, segfaulting on std::filesystem::path destructor. (In reply to Konstantin Tokarev from comment #9) > If it's not possible to change test to avoid segfault at run time, it's > better to change policy to link stdc++fs by default, and omit it only if > linking fails The error in my previous paragraph led here, the same GCC8 error: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90050 It ended up being closed as invalid, with the solution for the reporter being to always link stdc++fs (at least with GCC8) 1698532 12 clopez 2020-10-16 04:52:07 -0700 (In reply to Lauro Moura from comment #11) > > > > We need to figure out of a way of doing this test without actually running > > the executable. > > > > Why this simple test compiles with GCC8 but WebKit doesn't? > > Checking the bots errors again, I managed to reproduce WebKit's compile > error with the snippet inside an ubuntu18 container. > > Meanwhile, in my Ubuntu 20 system, GCC8 compiled WebKit normally, > segfaulting on std::filesystem::path destructor. > > (In reply to Konstantin Tokarev from comment #9) > > If it's not possible to change test to avoid segfault at run time, it's > > better to change policy to link stdc++fs by default, and omit it only if > > linking fails > > The error in my previous paragraph led here, the same GCC8 error: > https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90050 > > It ended up being closed as invalid, with the solution for the reporter > being to always link stdc++fs (at least with GCC8) Ok. That is likely caused because you are using a newer libstdc++ (the one that comes with GCC9) with an older compiler (GCC8). This comment on that bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90050#c4 suggest also this. That is a very corner case that maybe we can leave unfixed for the moment. I expect that the version of GCC and libstdc++ should match, at least will do in the 99.9% of the real use cases. I think that when one uses a different version of GCC than libstdc++ is actually for using a newer version of the compiler and not an older one. I wonder what happens with Clang on Ubuntu20?: does this test fail to build without -lstdc++fs or builds but segfaults? if clang doesn't segfault then that indicates the issue is only with that weird combination of gcc8 with libstdc++-9, so I think we can leave that unfixed. 1699450 13 411801 lmoura 2020-10-19 14:48:40 -0700 Created attachment 411801 Patch with only compile check 1699464 14 411801 clopez 2020-10-19 15:04:53 -0700 Comment on attachment 411801 Patch with only compile check View in context: https://bugs.webkit.org/attachment.cgi?id=411801&action=review > Tools/WebKitTestRunner/CMakeLists.txt:33 > + set(WebKitTestRunner_LIBRARIES > + ${WebKitTestRunner_LIBRARIES} > + stdc++fs perhaps is maybe better to use here: list(APPEND WebKitTestRunner_LIBRARIES stdc++fs ) 1699578 15 411827 lmoura 2020-10-19 19:14:43 -0700 Created attachment 411827 Patch for landing Updated with APPEND. Mac wk1 failure is a flaky timeout failure. 1699579 16 lmoura 2020-10-19 19:15:58 -0700 Committed r268708: <https://trac.webkit.org/changeset/268708> 410744 2020-10-07 04:37:28 -0700 2020-10-14 21:47:04 -0700 Especulative fix for GCC 8 and older bug-217425-20201007083727.patch text/plain 2769 lmoura U3VidmVyc2lvbiBSZXZpc2lvbjogMjY4MTE5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDUzYWFmMGIwNjMxOWRmYWFmNTg0NTNj MmI4OGIxNDJjNTlhOTFmMmMuLmVkODk4ZjFlNjFkYjRlYjAwOTJmOTZlYWRlODMwNmVhN2NlNzM4 YmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMjAtMTAtMDcgIExhdXJvIE1vdXJhICA8bG1vdXJh QGlnYWxpYS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjY4MTE1KSBbR1RLXSBCdWlsZCBm YWlsdXJlcyB3aXRoIEdDQyA3IChVYnVudHUgMTguMDQpIGFuZCBHQ0MgOCAoRGViaWFuIEJ1c3Rl cikKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNzQy NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogd3Rm L1N0ZEZpbGVzeXN0ZW0uaDogQWxzbyBjaGVjayBmb3IgZXhwZXJpbWVudGFsL2ZpbGVzeXN0ZW0g YW5kCisgICAgICAgIGFsaWFzIGJlZm9yZSB1c2luZyB0aGUgZmFsbGJhY2sgdmVyc2lvbi4KKwog MjAyMC0xMC0wNiAgU2ltb24gRnJhc2VyICA8c2ltb24uZnJhc2VyQGFwcGxlLmNvbT4KIAogICAg ICAgICBSZWR1bmRhbnQgcmVuZGVyaW5nIHVwZGF0ZXMgY2FuIGJlIHNjaGVkdWxlZCBmcm9tIGlu c2lkZSBQYWdlOjp1cGRhdGVSZW5kZXJpbmcoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYv U3RkRmlsZXN5c3RlbS5oIGIvU291cmNlL1dURi93dGYvU3RkRmlsZXN5c3RlbS5oCmluZGV4IDVl ZTQ3MTljZWU5YmJiNWNmYWJlODQxNGYxY2JhMTk3NmFhYTk4YTQuLjdjY2RmZTc3YjViMDNjMjNi MDU1MWJhMzMwM2U4YzUwY2FhNmY0YTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1N0ZEZp bGVzeXN0ZW0uaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9TdGRGaWxlc3lzdGVtLmgKQEAgLTksNiAr OSwxMSBAQAogCiAjaWYgX19oYXNfaW5jbHVkZSg8ZmlsZXN5c3RlbT4pCiAjaW5jbHVkZSA8Zmls ZXN5c3RlbT4KKyNlbGlmIF9faGFzX2luY2x1ZGUoPGV4cGVyaW1lbnRhbC9maWxlc3l0ZW0+KQor I2luY2x1ZGUgPGV4cGVyaW1lbnRhbC9maWxlc3lzdGVtPgorbmFtZXNwYWNlIHN0ZCB7CituYW1l c3BhY2UgZmlsZXN5c3RlbSA9IHN0ZDo6ZXhwZXJpbWVudGFsOjpmaWxlc3lzdGVtOworfQogI2Vs c2UKIAogLyogSW1wb3J0cyBhIGNvcHkgb2YgPGZpbGVzeXN0ZW0+IGZyb20gcjM0MzgzOCBvZiB0 aGUgbGliYysrIHByb2plY3QuIFRoaXMKZGlmZiAtLWdpdCBhL1NvdXJjZS9jbWFrZS9XZWJLaXRD b21waWxlckZsYWdzLmNtYWtlIGIvU291cmNlL2NtYWtlL1dlYktpdENvbXBpbGVyRmxhZ3MuY21h a2UKaW5kZXggZmY4ZTc1Y2RkOTViZmZhZDFhZTQ3MTg4NjdhZTFmZTU2OWNlNzBhMS4uZGZjM2Rh OGVkN2RjMTMyYmQwMDAxMTM5ZGM2NGFiYjcxY2E0NDVkNyAxMDA2NDQKLS0tIGEvU291cmNlL2Nt YWtlL1dlYktpdENvbXBpbGVyRmxhZ3MuY21ha2UKKysrIGIvU291cmNlL2NtYWtlL1dlYktpdENv bXBpbGVyRmxhZ3MuY21ha2UKQEAgLTEzNiw2ICsxMzYsMTEgQEAgaWYgKENPTVBJTEVSX0lTX0dD Q19PUl9DTEFORykKICAgICAgICAgV0VCS0lUX1BSRVBFTkRfR0xPQkFMX0NYWF9GTEFHUygtV25v LWF0dHJpYnV0ZXMpCiAgICAgZW5kaWYgKCkKIAorICAgICMgPGZpbGV5c3RlbT4KKyAgICBpZiAo JHtDTUFLRV9DWFhfQ09NUElMRVJfVkVSU0lPTn0gVkVSU0lPTl9MRVNTICI5LjAiIEFORCBOT1Qg Q01BS0VfQ1hYX0NPTVBJTEVSX0lEIE1BVENIRVMgIkNsYW5nIikKKyAgICAgICAgV0VCS0lUX1BS RVBFTkRfR0xPQkFMX0NPTVBJTEVSX0ZMQUdTKC1sc3RkYysrZnMpCisgICAgZW5kaWYgKCkKKwog ICAgICMgLVdleHBhbnNpb24tdG8tZGVmaW5lZCBwcm9kdWNlcyBmYWxzZSBwb3NpdGl2ZXMgd2l0 aCBHQ0MgYnV0IG5vdCBDbGFuZwogICAgICMgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTE2NzY0MyNjMTMKICAgICBpZiAoQ01BS0VfQ09NUElMRVJfSVNfR05VQ1hYKQpk aWZmIC0tZ2l0IGEvQ2hhbmdlTG9nIGIvQ2hhbmdlTG9nCmluZGV4IGYwZTUyNzE3NjJiYzk2Nzkz M2I3ZjAzMTgyMWU5ZGVmNTBiOTcxZTUuLmRmMmNkNjY5YzZkZGU5MjM4OGJjOTgzYTgyNmY0NTRj MWJlZWZmZGIgMTAwNjQ0Ci0tLSBhL0NoYW5nZUxvZworKysgYi9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxMyBAQAorMjAyMC0xMC0wNyAgTGF1cm8gTW91cmEgIDxsbW91cmFAaWdhbGlhLmNvbT4KKwor ICAgICAgICBSRUdSRVNTSU9OKHIyNjgxMTUpIFtHVEtdIEJ1aWxkIGZhaWx1cmVzIHdpdGggR0ND IDcgKFVidW50dSAxOC4wNCkgYW5kIEdDQyA4IChEZWJpYW4gQnVzdGVyKQorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE3NDI1CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBTb3VyY2UvY21ha2UvV2ViS2l0 Q29tcGlsZXJGbGFncy5jbWFrZTogVXNlIC1sc3RkYysrZnMgZm9yIGdjYyA4IGFuZAorICAgICAg ICBvbGRlci4KKwogMjAyMC0xMC0wNCAgUnlhbiBIb3N0ZXRsZXIgIDxyaG9zdEBhcHBsZS5jb20+ CiAKICAgICAgICAgU3VibWlzc2lvbiBmYWlsdXJlIHdpdGggIm1ha2U6ICoqKiBObyBydWxlIHRv IG1ha2UgdGFyZ2V0IGBpbnN0YWxsc3JjJy4gU3RvcCIK 411406 2020-10-14 21:47:09 -0700 2020-10-19 14:48:34 -0700 Tentative patch with actual cmake test source bug-217425-20201015014708.patch text/plain 5551 lmoura U3VidmVyc2lvbiBSZXZpc2lvbjogMjY4NTA4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGMyNzE1NGYzOTEzZmEyMzAwMjU5YTIy NTQwMjQ0NGIwOGE0MjRiZTguLmFiODBkYjdlNzE5N2E1ZWY1MTY1MTA5MTU5ODE5Nzk5MTRjOWJm MzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAKKzIwMjAtMTAtMTQgIExhdXJvIE1vdXJhICA8bG1vdXJh QGlnYWxpYS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjY4MTE1KSBbR1RLXSBCdWlsZCBm YWlsdXJlcyB3aXRoIEdDQyA3IChVYnVudHUgMTguMDQpIGFuZCBHQ0MgOCAoRGViaWFuIEJ1c3Rl cikKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNzQy NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogd3Rm L1N0ZEZpbGVzeXN0ZW0uaDogQWRkIGZhbGxiYWNrIHRvIDxleHBlcmltZW50YWwvZmlsZXN5c3Rl bT4gaWYgYXZhaWxhYmxlLgorCiAyMDIwLTEwLTE0ICBSeW9zdWtlIE5pd2EgIDxybml3YUB3ZWJr aXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQgYnVpbGQgZml4LiBEaXNhYmxlIElQQyB0ZXN0 aW5nIEFQSSBvbiBub24tQ29jb2EgcGxhdGZvcm1zLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93 dGYvU3RkRmlsZXN5c3RlbS5oIGIvU291cmNlL1dURi93dGYvU3RkRmlsZXN5c3RlbS5oCmluZGV4 IDVlZTQ3MTljZWU5YmJiNWNmYWJlODQxNGYxY2JhMTk3NmFhYTk4YTQuLjRkNTlhMzNiN2NkZTcz MjFlMGY3ZWYyYWI4NzBlN2ZiZmY5ZjEyZmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1N0 ZEZpbGVzeXN0ZW0uaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9TdGRGaWxlc3lzdGVtLmgKQEAgLTks NiArOSwxMSBAQAogCiAjaWYgX19oYXNfaW5jbHVkZSg8ZmlsZXN5c3RlbT4pCiAjaW5jbHVkZSA8 ZmlsZXN5c3RlbT4KKyNlbGlmIEhBVkUoU1REX0VYUEVSSU1FTlRBTF9GSUxFU1lTVEVNKQorI2lu Y2x1ZGUgPGV4cGVyaW1lbnRhbC9maWxlc3lzdGVtPgorbmFtZXNwYWNlIHN0ZCB7CituYW1lc3Bh Y2UgZmlsZXN5c3RlbSA9IHN0ZDo6ZXhwZXJpbWVudGFsOjpmaWxlc3lzdGVtOworfQogI2Vsc2UK IAogLyogSW1wb3J0cyBhIGNvcHkgb2YgPGZpbGVzeXN0ZW0+IGZyb20gcjM0MzgzOCBvZiB0aGUg bGliYysrIHByb2plY3QuIFRoaXMKZGlmZiAtLWdpdCBhL1NvdXJjZS9jbWFrZS9PcHRpb25zQ29t bW9uLmNtYWtlIGIvU291cmNlL2NtYWtlL09wdGlvbnNDb21tb24uY21ha2UKaW5kZXggM2NjODU2 MGZlMTRiMTFkNGI2NzQzY2E5YzU5MDIzZTU4MGJiMzBhYi4uOWVmNDlkYjk3OTNkNzlmNzQzYjgz YzJmYTQ2OWQ3ZjEzNmZlYmMyYSAxMDA2NDQKLS0tIGEvU291cmNlL2NtYWtlL09wdGlvbnNDb21t b24uY21ha2UKKysrIGIvU291cmNlL2NtYWtlL09wdGlvbnNDb21tb24uY21ha2UKQEAgLTE1Mywz ICsxNTMsOCBAQCBjaGVja190eXBlX3NpemUoIl9faW50MTI4X3QiIElOVDEyOF9WQUxVRSkKIGlm IChIQVZFX0lOVDEyOF9WQUxVRSkKICAgU0VUX0FORF9FWFBPU0VfVE9fQlVJTEQoSEFWRV9JTlQx MjhfVCBJTlQxMjhfVkFMVUUpCiBlbmRpZiAoKQorCisjIENoZWNrIHdoZXRoZXIgZXhwZXJpbWVu dGFsL2ZpbGVzeXN0ZW0gaXMgdGhlIGZpbGVzeXN0ZW0gaW1wbCBhdmFpbGFibGUKK2lmIChTVERf RVhQRVJJTUVOVEFMX0ZJTEVTWVNURU1fSVNfQVZBSUxBQkxFKQorICBTRVRfQU5EX0VYUE9TRV9U T19CVUlMRChIQVZFX1NURF9FWFBFUklNRU5UQUxfRklMRVNZU1RFTSBUUlVFKQorZW5kaWYgKCkK ZGlmZiAtLWdpdCBhL1NvdXJjZS9jbWFrZS9XZWJLaXRDb21waWxlckZsYWdzLmNtYWtlIGIvU291 cmNlL2NtYWtlL1dlYktpdENvbXBpbGVyRmxhZ3MuY21ha2UKaW5kZXggZmY4ZTc1Y2RkOTViZmZh ZDFhZTQ3MTg4NjdhZTFmZTU2OWNlNzBhMS4uM2I1MWRiODc2OTlmNmEzZGY4YTVmNWI5NDU4ZmI5 MDdlNGQ5ZWVkMyAxMDA2NDQKLS0tIGEvU291cmNlL2NtYWtlL1dlYktpdENvbXBpbGVyRmxhZ3Mu Y21ha2UKKysrIGIvU291cmNlL2NtYWtlL1dlYktpdENvbXBpbGVyRmxhZ3MuY21ha2UKQEAgLTI4 Miw0ICsyODIsMjYgQEAgaWYgKENPTVBJTEVSX0lTX0dDQ19PUl9DTEFORykKICAgICAgICAgY2hl Y2tfY3h4X3NvdXJjZV9jb21waWxlcygiJHtBVE9NSUNfVEVTVF9TT1VSQ0V9IiBBVE9NSUNfSU5U NjRfUkVRVUlSRVNfTElCQVRPTUlDKQogICAgICAgICB1bnNldChDTUFLRV9SRVFVSVJFRF9MSUJS QVJJRVMpCiAgICAgZW5kaWYgKCkKKworICAgICMgPGZpbGVzeXN0ZW0+IHZzIDxleHBlcmltZW50 YWwvZmlsZXN5c3RlbT4KKyAgICBzZXQoRklMRVNZU1RFTV9URVNUX1NPVVJDRSAiCisgICAgICAg ICNpbmNsdWRlIDxmaWxlc3lzdGVtPgorICAgICAgICBpbnQgbWFpbigpIHsgc3RkOjpmaWxlc3lz dGVtOjpwYXRoIHAxKFwiXCIpOyBzdGQ6OmZpbGVzeXN0ZW06OnN0YXR1cyhwMSk7IH0KKyAgICAi KQorICAgIGluY2x1ZGUoQ2hlY2tDWFhTb3VyY2VSdW5zKQorICAgIHNldChDTUFLRV9SRVFVSVJF RF9GTEFHUyAiLS1zdGQ9YysrMTciKQorICAgIGNoZWNrX2N4eF9zb3VyY2VfcnVucygiJHtGSUxF U1lTVEVNX1RFU1RfU09VUkNFfSIgU1REX0ZJTEVTWVNURU1fSVNfQVZBSUxBQkxFKQorICAgIGlm IChOT1QgU1REX0ZJTEVTWVNURU1fSVNfQVZBSUxBQkxFKQorICAgICAgICBzZXQoRVhQRVJJTUVO VEFMX0ZJTEVTWVNURU1fVEVTVF9TT1VSQ0UgIgorICAgICAgICAgICAgI2luY2x1ZGUgPGV4cGVy aW1lbnRhbC9maWxlc3lzdGVtPgorICAgICAgICAgICAgaW50IG1haW4oKSB7CisgICAgICAgICAg ICAgICAgc3RkOjpleHBlcmltZW50YWw6OmZpbGVzeXN0ZW06OnBhdGggcDEoXCIvL2hvbWVcIik7 CisgICAgICAgICAgICAgICAgc3RkOjpleHBlcmltZW50YWw6OmZpbGVzeXN0ZW06OnN0YXR1cyhw MSk7CisgICAgICAgICAgICB9CisgICAgICAgICIpCisgICAgICAgIHNldChDTUFLRV9SRVFVSVJF RF9MSUJSQVJJRVMgc3RkYysrZnMpCisgICAgICAgIGNoZWNrX2N4eF9zb3VyY2VfcnVucygiJHtF WFBFUklNRU5UQUxfRklMRVNZU1RFTV9URVNUX1NPVVJDRX0iIFNURF9FWFBFUklNRU5UQUxfRklM RVNZU1RFTV9JU19BVkFJTEFCTEUpCisgICAgICAgIHVuc2V0KENNQUtFX1JFUVVJUkVEX0xJQlJB UklFUykKKyAgICBlbmRpZiAoKQorICAgIHVuc2V0KENNQUtFX1JFUVVJUkVEX0ZMQUdTKQogZW5k aWYgKCkKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRl eCA1YWE4MGZiMWFiMWM1Y2IxZjkwMTNkZjhmMzhhZDBmOWI4ZTRmZjViLi41NzY2NjE0NDFlZTY2 YWRlOWUzYWJhZmY2NGUxZTVmZGJkNWRhMjNlIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cK KysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMjAtMTAtMTQgIExhdXJv IE1vdXJhICA8bG1vdXJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjY4MTE1 KSBbR1RLXSBCdWlsZCBmYWlsdXJlcyB3aXRoIEdDQyA3IChVYnVudHUgMTguMDQpIGFuZCBHQ0Mg OCAoRGViaWFuIEJ1c3RlcikKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIxNzQyNQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogV2ViS2l0VGVzdFJ1bm5lci9DTWFrZUxpc3RzLnR4dDogTGluayB3aXRoIHN0 ZGMrK2ZzIGlmIHVzaW5nCisgICAgICAgIDxleHBlcmltZW50YWwvZmlsZXN5c3RlbT4uCisKIDIw MjAtMTAtMTQgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAgSVBD IHRlc3RpbmcgSlMgQVBJIHNob3VsZCBleHBvc2UgYSByZXBseSBhbmQgZGVzY3JpYmUgdGhlIGxp c3Qgb2YgYXJndW1lbnRzIGZvciBlYWNoIG1lc3NhZ2UKZGlmZiAtLWdpdCBhL1Rvb2xzL1dlYktp dFRlc3RSdW5uZXIvQ01ha2VMaXN0cy50eHQgYi9Ub29scy9XZWJLaXRUZXN0UnVubmVyL0NNYWtl TGlzdHMudHh0CmluZGV4IDQzNjRiYjg4NjliZGUzOTcyMzRhNzkzYzBkM2M4ZjkzNjU0ZTg5M2Uu LjBhNjdkYWI5Y2IxM2I0MjQyYTdlMDg2MmY4Nzk2YmQyMDA1NDU5MGMgMTAwNjQ0Ci0tLSBhL1Rv b2xzL1dlYktpdFRlc3RSdW5uZXIvQ01ha2VMaXN0cy50eHQKKysrIGIvVG9vbHMvV2ViS2l0VGVz dFJ1bm5lci9DTWFrZUxpc3RzLnR4dApAQCAtMjYsNiArMjYsMTUgQEAgc2V0KFdlYktpdFRlc3RS dW5uZXJfTElCUkFSSUVTCiAgICAgV2ViS2l0OjpXZWJLaXQKICkKIAoraWYgKENPTVBJTEVSX0lT X0dDQ19PUl9DTEFORykKKyAgICBpZiAoSEFWRV9TVERfRVhQRVJJTUVOVEFMX0ZJTEVTWVNURU0p CisgICAgICAgIHNldChXZWJLaXRUZXN0UnVubmVyX0xJQlJBUklFUworICAgICAgICAgICAgJHtX ZWJLaXRUZXN0UnVubmVyX0xJQlJBUklFU30KKyAgICAgICAgICAgIHN0ZGMrK2ZzCisgICAgICAg ICkKKyAgICBlbmRpZiAoKQorZW5kaWYgKCkKKwogc2V0KFdlYktpdFRlc3RSdW5uZXJfSU5DTFVE RV9ESVJFQ1RPUklFUwogICAgICR7Q01BS0VfQklOQVJZX0RJUn0KICAgICAke1dlYktpdFRlc3RS dW5uZXJfU0hBUkVEX0RJUn0KZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRl eCBhNGFlZjM5ZGFkNjU4MTM4MDRlZGMxNmM3NDU0MTBkMzY0NDM4MGNkLi43OTlhYWMxZTE2MGUx NzZhYmQ1MTYxOWI3NmYxYTFkYzdkNjJjZmFkIDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMjAtMTAtMTQgIExhdXJvIE1vdXJhICA8bG1v dXJhQGlnYWxpYS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjY4MTE1KSBbR1RLXSBCdWls ZCBmYWlsdXJlcyB3aXRoIEdDQyA3IChVYnVudHUgMTguMDQpIGFuZCBHQ0MgOCAoRGViaWFuIEJ1 c3RlcikKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIx NzQyNQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICog U291cmNlL2NtYWtlL09wdGlvbnNDb21tb24uY21ha2U6IEFkZCBhIEhBVkUgZGlyZWN0aXZlIHRv CisgICAgICAgIGNoZWNrIHdoZXRoZXIgPGV4cGVyaW1lbnRhbC9maWxlc3lzdGVtPiBpcyB0aGUg ZmlsZXN5c3RlbSBpbXBsCisgICAgICAgIGF2YWlsYWJsZS4KKyAgICAgICAgKiBTb3VyY2UvY21h a2UvV2ViS2l0Q29tcGlsZXJGbGFncy5jbWFrZTogVGVzdCBmaXJzdCB3aGV0aGVyCisgICAgICAg IDxmaWxlc3lzdGVtPiBjYW4gYmUgdXNlZCwgd2l0aCA8ZXhwZXJpbWVudGFsL2ZpbGVzdHlzdGVt PiBhcyBmYWxsYmFjay4KKwogMjAyMC0xMC0xNCAgWmFuIERvYmVyc2VrICA8emRvYmVyc2VrQGln YWxpYS5jb20+CiAKICAgICAgICAgUmVtb3ZlIEFDQ0VMRVJBVEVEXzJEX0NBTlZBUyBidWlsZCBm bGFncyBhbmQgZ3VhcmRlZCBjb2RlCg== 411801 2020-10-19 14:48:40 -0700 2020-10-19 19:14:38 -0700 Patch with only compile check bug-217425-20201019184838.patch text/plain 6103 lmoura U3VidmVyc2lvbiBSZXZpc2lvbjogMjY4NjY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDdhYWI1ZGEzOTI3YmUyZWExZDhkMTM4 MGY5YmU0ZDEwYmE5MmZjN2MuLmRiODFkNTkyOTBjMmJlZTE4ZjI5OWM1OGNhNTIzNDg0MzE1ZWJk OWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAKKzIwMjAtMTAtMTkgIExhdXJvIE1vdXJhICA8bG1vdXJh QGlnYWxpYS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjY4MTE1KSBbR1RLXSBCdWlsZCBm YWlsdXJlcyB3aXRoIEdDQyA3IChVYnVudHUgMTguMDQpIGFuZCBHQ0MgOCAoRGViaWFuIEJ1c3Rl cikKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNzQy NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogd3Rm L1N0ZEZpbGVzeXN0ZW0uaDogQWRkIGZhbGxiYWNrIHRvIDxleHBlcmltZW50YWwvZmlsZXN5c3Rl bT4gaWYgYXZhaWxhYmxlLgorCiAyMDIwLTEwLTE4ICBEYXZpZCBLaWx6ZXIgIDxkZGtpbHplckBh cHBsZS5jb20+CiAKICAgICAgICAgRml4IC1XZGVwcmVjYXRlZC1jb3B5IHdhcm5pbmdzIGluIFdU RiBhbmQgSmF2YVNjcmlwdENvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1N0ZEZpbGVz eXN0ZW0uaCBiL1NvdXJjZS9XVEYvd3RmL1N0ZEZpbGVzeXN0ZW0uaAppbmRleCA1ZWU0NzE5Y2Vl OWJiYjVjZmFiZTg0MTRmMWNiYTE5NzZhYWE5OGE0Li40ZDU5YTMzYjdjZGU3MzIxZTBmN2VmMmFi ODcwZTdmYmZmOWYxMmZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9TdGRGaWxlc3lzdGVt LmgKKysrIGIvU291cmNlL1dURi93dGYvU3RkRmlsZXN5c3RlbS5oCkBAIC05LDYgKzksMTEgQEAK IAogI2lmIF9faGFzX2luY2x1ZGUoPGZpbGVzeXN0ZW0+KQogI2luY2x1ZGUgPGZpbGVzeXN0ZW0+ CisjZWxpZiBIQVZFKFNURF9FWFBFUklNRU5UQUxfRklMRVNZU1RFTSkKKyNpbmNsdWRlIDxleHBl cmltZW50YWwvZmlsZXN5c3RlbT4KK25hbWVzcGFjZSBzdGQgeworbmFtZXNwYWNlIGZpbGVzeXN0 ZW0gPSBzdGQ6OmV4cGVyaW1lbnRhbDo6ZmlsZXN5c3RlbTsKK30KICNlbHNlCiAKIC8qIEltcG9y dHMgYSBjb3B5IG9mIDxmaWxlc3lzdGVtPiBmcm9tIHIzNDM4Mzggb2YgdGhlIGxpYmMrKyBwcm9q ZWN0LiBUaGlzCmRpZmYgLS1naXQgYS9Tb3VyY2UvY21ha2UvT3B0aW9uc0NvbW1vbi5jbWFrZSBi L1NvdXJjZS9jbWFrZS9PcHRpb25zQ29tbW9uLmNtYWtlCmluZGV4IDNjYzg1NjBmZTE0YjExZDRi Njc0M2NhOWM1OTAyM2U1ODBiYjMwYWIuLjllZjQ5ZGI5NzkzZDc5Zjc0M2I4M2MyZmE0NjlkN2Yx MzZmZWJjMmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9jbWFrZS9PcHRpb25zQ29tbW9uLmNtYWtlCisr KyBiL1NvdXJjZS9jbWFrZS9PcHRpb25zQ29tbW9uLmNtYWtlCkBAIC0xNTMsMyArMTUzLDggQEAg Y2hlY2tfdHlwZV9zaXplKCJfX2ludDEyOF90IiBJTlQxMjhfVkFMVUUpCiBpZiAoSEFWRV9JTlQx MjhfVkFMVUUpCiAgIFNFVF9BTkRfRVhQT1NFX1RPX0JVSUxEKEhBVkVfSU5UMTI4X1QgSU5UMTI4 X1ZBTFVFKQogZW5kaWYgKCkKKworIyBDaGVjayB3aGV0aGVyIGV4cGVyaW1lbnRhbC9maWxlc3lz dGVtIGlzIHRoZSBmaWxlc3lzdGVtIGltcGwgYXZhaWxhYmxlCitpZiAoU1REX0VYUEVSSU1FTlRB TF9GSUxFU1lTVEVNX0lTX0FWQUlMQUJMRSkKKyAgU0VUX0FORF9FWFBPU0VfVE9fQlVJTEQoSEFW RV9TVERfRVhQRVJJTUVOVEFMX0ZJTEVTWVNURU0gVFJVRSkKK2VuZGlmICgpCmRpZmYgLS1naXQg YS9Tb3VyY2UvY21ha2UvV2ViS2l0Q29tcGlsZXJGbGFncy5jbWFrZSBiL1NvdXJjZS9jbWFrZS9X ZWJLaXRDb21waWxlckZsYWdzLmNtYWtlCmluZGV4IGZmOGU3NWNkZDk1YmZmYWQxYWU0NzE4ODY3 YWUxZmU1NjljZTcwYTEuLjMxY2E1M2VkZDYzOWE1MWMzMDk3MjUyMzEzNDJmNDg1ZWEyYjg5ZTkg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9jbWFrZS9XZWJLaXRDb21waWxlckZsYWdzLmNtYWtlCisrKyBi L1NvdXJjZS9jbWFrZS9XZWJLaXRDb21waWxlckZsYWdzLmNtYWtlCkBAIC0yODIsNCArMjgyLDI1 IEBAIGlmIChDT01QSUxFUl9JU19HQ0NfT1JfQ0xBTkcpCiAgICAgICAgIGNoZWNrX2N4eF9zb3Vy Y2VfY29tcGlsZXMoIiR7QVRPTUlDX1RFU1RfU09VUkNFfSIgQVRPTUlDX0lOVDY0X1JFUVVJUkVT X0xJQkFUT01JQykKICAgICAgICAgdW5zZXQoQ01BS0VfUkVRVUlSRURfTElCUkFSSUVTKQogICAg IGVuZGlmICgpCisKKyAgICAjIDxmaWxlc3lzdGVtPiB2cyA8ZXhwZXJpbWVudGFsL2ZpbGVzeXN0 ZW0+CisgICAgc2V0KEZJTEVTWVNURU1fVEVTVF9TT1VSQ0UgIgorICAgICAgICAjaW5jbHVkZSA8 ZmlsZXN5c3RlbT4KKyAgICAgICAgaW50IG1haW4oKSB7IHN0ZDo6ZmlsZXN5c3RlbTo6cGF0aCBw MShcIlwiKTsgc3RkOjpmaWxlc3lzdGVtOjpzdGF0dXMocDEpOyB9CisgICAgIikKKyAgICBzZXQo Q01BS0VfUkVRVUlSRURfRkxBR1MgIi0tc3RkPWMrKzE3IikKKyAgICBjaGVja19jeHhfc291cmNl X2NvbXBpbGVzKCIke0ZJTEVTWVNURU1fVEVTVF9TT1VSQ0V9IiBTVERfRklMRVNZU1RFTV9JU19B VkFJTEFCTEUpCisgICAgaWYgKE5PVCBTVERfRklMRVNZU1RFTV9JU19BVkFJTEFCTEUpCisgICAg ICAgIHNldChFWFBFUklNRU5UQUxfRklMRVNZU1RFTV9URVNUX1NPVVJDRSAiCisgICAgICAgICAg ICAjaW5jbHVkZSA8ZXhwZXJpbWVudGFsL2ZpbGVzeXN0ZW0+CisgICAgICAgICAgICBpbnQgbWFp bigpIHsKKyAgICAgICAgICAgICAgICBzdGQ6OmV4cGVyaW1lbnRhbDo6ZmlsZXN5c3RlbTo6cGF0 aCBwMShcIi8vaG9tZVwiKTsKKyAgICAgICAgICAgICAgICBzdGQ6OmV4cGVyaW1lbnRhbDo6Zmls ZXN5c3RlbTo6c3RhdHVzKHAxKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgIikKKyAgICAgICAg c2V0KENNQUtFX1JFUVVJUkVEX0xJQlJBUklFUyBzdGRjKytmcykKKyAgICAgICAgY2hlY2tfY3h4 X3NvdXJjZV9jb21waWxlcygiJHtFWFBFUklNRU5UQUxfRklMRVNZU1RFTV9URVNUX1NPVVJDRX0i IFNURF9FWFBFUklNRU5UQUxfRklMRVNZU1RFTV9JU19BVkFJTEFCTEUpCisgICAgICAgIHVuc2V0 KENNQUtFX1JFUVVJUkVEX0xJQlJBUklFUykKKyAgICBlbmRpZiAoKQorICAgIHVuc2V0KENNQUtF X1JFUVVJUkVEX0ZMQUdTKQogZW5kaWYgKCkKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBi L1Rvb2xzL0NoYW5nZUxvZwppbmRleCA3OGU5NzJjZDc3YWY0YTljZGRhYTA3OWZhNjFlNGEwYTA1 YzAxYTZjLi40ZTYwNzAxODY5MDFmNmIwMWI2ZDFiYTUwYjg5MWIyNTIwNDg5M2YwIDEwMDY0NAot LS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMg QEAKKzIwMjAtMTAtMTkgIExhdXJvIE1vdXJhICA8bG1vdXJhQGlnYWxpYS5jb20+CisKKyAgICAg ICAgUkVHUkVTU0lPTihyMjY4MTE1KSBbR1RLXSBCdWlsZCBmYWlsdXJlcyB3aXRoIEdDQyA3IChV YnVudHUgMTguMDQpIGFuZCBHQ0MgOCAoRGViaWFuIEJ1c3RlcikKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNzQyNQorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViS2l0VGVzdFJ1bm5lci9DTWFrZUxp c3RzLnR4dDogTGluayB3aXRoIHN0ZGMrK2ZzIGlmIHVzaW5nCisgICAgICAgIDxleHBlcmltZW50 YWwvZmlsZXN5c3RlbT4uCisKIDIwMjAtMTAtMTggIExhdXJvIE1vdXJhICA8bG1vdXJhQGlnYWxp YS5jb20+CiAKICAgICAgICAgd2Via2l0Y29yZXB5OiBBbGxvdyBvbmUgcGFja2FnZSB0byByZXF1 aXJlIGFub3RoZXIgcGFja2FnZQpkaWZmIC0tZ2l0IGEvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9D TWFrZUxpc3RzLnR4dCBiL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvQ01ha2VMaXN0cy50eHQKaW5k ZXggYTBmZDA3ZTcyZDVjMjM1MjU3ZmI2MDA3ODM2ZmJkZDJlMDUyM2U2YS4uNTMwZGE5ZTU3NGU0 ODI2Y2UzMjlkZmQ2M2YzMDRlM2RjNWFjZTNhNyAxMDA2NDQKLS0tIGEvVG9vbHMvV2ViS2l0VGVz dFJ1bm5lci9DTWFrZUxpc3RzLnR4dAorKysgYi9Ub29scy9XZWJLaXRUZXN0UnVubmVyL0NNYWtl TGlzdHMudHh0CkBAIC0yNiw2ICsyNiwxNSBAQCBzZXQoV2ViS2l0VGVzdFJ1bm5lcl9MSUJSQVJJ RVMKICAgICBXZWJLaXQ6OldlYktpdAogKQogCitpZiAoQ09NUElMRVJfSVNfR0NDX09SX0NMQU5H KQorICAgIGlmIChIQVZFX1NURF9FWFBFUklNRU5UQUxfRklMRVNZU1RFTSkKKyAgICAgICAgc2V0 KFdlYktpdFRlc3RSdW5uZXJfTElCUkFSSUVTCisgICAgICAgICAgICAke1dlYktpdFRlc3RSdW5u ZXJfTElCUkFSSUVTfQorICAgICAgICAgICAgc3RkYysrZnMKKyAgICAgICAgKQorICAgIGVuZGlm ICgpCitlbmRpZiAoKQorCiBzZXQoV2ViS2l0VGVzdFJ1bm5lcl9JTkNMVURFX0RJUkVDVE9SSUVT CiAgICAgJHtDTUFLRV9CSU5BUllfRElSfQogICAgICR7V2ViS2l0VGVzdFJ1bm5lcl9TSEFSRURf RElSfQpkaWZmIC0tZ2l0IGEvQ2hhbmdlTG9nIGIvQ2hhbmdlTG9nCmluZGV4IGE0YWVmMzlkYWQ2 NTgxMzgwNGVkYzE2Yzc0NTQxMGQzNjQ0MzgwY2QuLmIxNzQzZDZjNzcyYjFkNWIzODI4Zjg3NDEy MjljYmQzMmQzMDA1NTAgMTAwNjQ0Ci0tLSBhL0NoYW5nZUxvZworKysgYi9DaGFuZ2VMb2cKQEAg LTEsMyArMSwyNyBAQAorMjAyMC0xMC0xOSAgTGF1cm8gTW91cmEgIDxsbW91cmFAaWdhbGlhLmNv bT4KKworICAgICAgICBSRUdSRVNTSU9OKHIyNjgxMTUpIFtHVEtdIEJ1aWxkIGZhaWx1cmVzIHdp dGggR0NDIDcgKFVidW50dSAxOC4wNCkgYW5kIEdDQyA4IChEZWJpYW4gQnVzdGVyKQorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE3NDI1CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhlIHJvb3QgY2F1c2Ug aXMgbGFjayBvZiBwcm9wZXIgPGZpbGVzeXN0ZW0+IHN1cHBvcnQgaW4gZ2NjNy84IChhbmQKKyAg ICAgICAgaW5jb21wYXRpYmlsaXR5IHdpdGggbGx2bSdzIGhlYWRlciB0aGF0IHdhcyBpbmNsdWRl ZCkuIEFzIHN1Y2gsIHdlCisgICAgICAgIG5lZWQgdG8gY2hlY2sgd2hldGhlciB0byB1c2UgPGZp bGVzeXN0ZW0+LCA8ZXhwZXJpbWVudGFsL2ZpbGVzeXN0ZW0+LAorICAgICAgICBvciBmYWxsYmFj ayB0byB0aGUgaW5jbHVkZWQgaGVhZGVyLgorCisgICAgICAgIE5vdGU6IEluIHNvbWUgc3lzdGVt cyBsaWtlIFVidW50dSAyMC4wNCwgZ2NjLTggY2FuIHVzZSBnY2MtOSdzCisgICAgICAgIGxpYnN0 ZGMrKyBhbmQgbGluayBzdWNjZXNzZnVsbHksIGJ1dCBydW5uaW5nIHdpbGwgZmFpbCBhcyBpdCBz aG91bGQKKyAgICAgICAgYWN0dWFsbHkgbGluayB3aXRoIGl0cyBsaWJzdGMrK2ZzIHRvIHByb3Zp ZGUgdGhlIGNvcnJlY3Qgc3ltYm9scy4gQXMKKyAgICAgICAgdGhpcyBpcyBzb21lIGNvcm5lciBj YXNlIChVYnVudHUncyAyMCBkZWZhdWx0IGdjYyBpcyA5KSwgTERGTEFHUworICAgICAgICBjYW4g YmUgdXNlZCB0byBvdmVyY29tZSB0aGlzLgorCisgICAgICAgICogU291cmNlL2NtYWtlL09wdGlv bnNDb21tb24uY21ha2U6IEFkZCBhIEhBVkUgZGlyZWN0aXZlIHRvCisgICAgICAgIGNoZWNrIHdo ZXRoZXIgPGV4cGVyaW1lbnRhbC9maWxlc3lzdGVtPiBpcyB0aGUgZmlsZXN5c3RlbSBpbXBsCisg ICAgICAgIGF2YWlsYWJsZS4KKyAgICAgICAgKiBTb3VyY2UvY21ha2UvV2ViS2l0Q29tcGlsZXJG bGFncy5jbWFrZTogVGVzdCBmaXJzdCB3aGV0aGVyCisgICAgICAgIDxmaWxlc3lzdGVtPiBjYW4g YmUgdXNlZCwgd2l0aCA8ZXhwZXJpbWVudGFsL2ZpbGVzdHlzdGVtPiBhcyBmYWxsYmFjay4KKwog MjAyMC0xMC0xNCAgWmFuIERvYmVyc2VrICA8emRvYmVyc2VrQGlnYWxpYS5jb20+CiAKICAgICAg ICAgUmVtb3ZlIEFDQ0VMRVJBVEVEXzJEX0NBTlZBUyBidWlsZCBmbGFncyBhbmQgZ3VhcmRlZCBj b2RlCg== 411827 2020-10-19 19:14:43 -0700 2020-10-19 19:14:43 -0700 Patch for landing bug-217425-20201019231441.patch text/plain 6122 lmoura U3VidmVyc2lvbiBSZXZpc2lvbjogMjY4Njk3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDgyYTZlMGM5NmU3MjU1ODZmOTI4MTA5 M2Q3NWNmOWVmNTNjNzdhOTYuLjY5Y2I0YTZlODE4OThkM2RlOWQwNTYxNWM5MGU1ZTJjMzcyZDMz YjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAKKzIwMjAtMTAtMTkgIExhdXJvIE1vdXJhICA8bG1vdXJh QGlnYWxpYS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjY4MTE1KSBbR1RLXSBCdWlsZCBm YWlsdXJlcyB3aXRoIEdDQyA3IChVYnVudHUgMTguMDQpIGFuZCBHQ0MgOCAoRGViaWFuIEJ1c3Rl cikKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNzQy NQorCisgICAgICAgIFJldmlld2VkIGJ5IENhcmxvcyBBbGJlcnRvIExvcGV6IFBlcmV6LgorCisg ICAgICAgICogd3RmL1N0ZEZpbGVzeXN0ZW0uaDogQWRkIGZhbGxiYWNrIHRvIDxleHBlcmltZW50 YWwvZmlsZXN5c3RlbT4gaWYgYXZhaWxhYmxlLgorCiAyMDIwLTEwLTE5ICBDaHJpcyBEdW1leiAg PGNkdW1lekBhcHBsZS5jb20+CiAKICAgICAgICAgW0dQVSBQcm9jZXNzXSBSZW1vdGVBdWRpb0Rl c3RpbmF0aW9uOjpyZW5kZXIoKSBzaG91bGQgbm90IG5lZWQgdG8gZGlzcGF0Y2ggdG8gdGhlIG1h aW4gdGhyZWFkIHRvIGRvIElQQwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvU3RkRmlsZXN5 c3RlbS5oIGIvU291cmNlL1dURi93dGYvU3RkRmlsZXN5c3RlbS5oCmluZGV4IDVlZTQ3MTljZWU5 YmJiNWNmYWJlODQxNGYxY2JhMTk3NmFhYTk4YTQuLjRkNTlhMzNiN2NkZTczMjFlMGY3ZWYyYWI4 NzBlN2ZiZmY5ZjEyZmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1N0ZEZpbGVzeXN0ZW0u aAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9TdGRGaWxlc3lzdGVtLmgKQEAgLTksNiArOSwxMSBAQAog CiAjaWYgX19oYXNfaW5jbHVkZSg8ZmlsZXN5c3RlbT4pCiAjaW5jbHVkZSA8ZmlsZXN5c3RlbT4K KyNlbGlmIEhBVkUoU1REX0VYUEVSSU1FTlRBTF9GSUxFU1lTVEVNKQorI2luY2x1ZGUgPGV4cGVy aW1lbnRhbC9maWxlc3lzdGVtPgorbmFtZXNwYWNlIHN0ZCB7CituYW1lc3BhY2UgZmlsZXN5c3Rl bSA9IHN0ZDo6ZXhwZXJpbWVudGFsOjpmaWxlc3lzdGVtOworfQogI2Vsc2UKIAogLyogSW1wb3J0 cyBhIGNvcHkgb2YgPGZpbGVzeXN0ZW0+IGZyb20gcjM0MzgzOCBvZiB0aGUgbGliYysrIHByb2pl Y3QuIFRoaXMKZGlmZiAtLWdpdCBhL1NvdXJjZS9jbWFrZS9PcHRpb25zQ29tbW9uLmNtYWtlIGIv U291cmNlL2NtYWtlL09wdGlvbnNDb21tb24uY21ha2UKaW5kZXggM2NjODU2MGZlMTRiMTFkNGI2 NzQzY2E5YzU5MDIzZTU4MGJiMzBhYi4uOWVmNDlkYjk3OTNkNzlmNzQzYjgzYzJmYTQ2OWQ3ZjEz NmZlYmMyYSAxMDA2NDQKLS0tIGEvU291cmNlL2NtYWtlL09wdGlvbnNDb21tb24uY21ha2UKKysr IGIvU291cmNlL2NtYWtlL09wdGlvbnNDb21tb24uY21ha2UKQEAgLTE1MywzICsxNTMsOCBAQCBj aGVja190eXBlX3NpemUoIl9faW50MTI4X3QiIElOVDEyOF9WQUxVRSkKIGlmIChIQVZFX0lOVDEy OF9WQUxVRSkKICAgU0VUX0FORF9FWFBPU0VfVE9fQlVJTEQoSEFWRV9JTlQxMjhfVCBJTlQxMjhf VkFMVUUpCiBlbmRpZiAoKQorCisjIENoZWNrIHdoZXRoZXIgZXhwZXJpbWVudGFsL2ZpbGVzeXN0 ZW0gaXMgdGhlIGZpbGVzeXN0ZW0gaW1wbCBhdmFpbGFibGUKK2lmIChTVERfRVhQRVJJTUVOVEFM X0ZJTEVTWVNURU1fSVNfQVZBSUxBQkxFKQorICBTRVRfQU5EX0VYUE9TRV9UT19CVUlMRChIQVZF X1NURF9FWFBFUklNRU5UQUxfRklMRVNZU1RFTSBUUlVFKQorZW5kaWYgKCkKZGlmZiAtLWdpdCBh L1NvdXJjZS9jbWFrZS9XZWJLaXRDb21waWxlckZsYWdzLmNtYWtlIGIvU291cmNlL2NtYWtlL1dl YktpdENvbXBpbGVyRmxhZ3MuY21ha2UKaW5kZXggZmY4ZTc1Y2RkOTViZmZhZDFhZTQ3MTg4Njdh ZTFmZTU2OWNlNzBhMS4uMzFjYTUzZWRkNjM5YTUxYzMwOTcyNTIzMTM0MmY0ODVlYTJiODllOSAx MDA2NDQKLS0tIGEvU291cmNlL2NtYWtlL1dlYktpdENvbXBpbGVyRmxhZ3MuY21ha2UKKysrIGIv U291cmNlL2NtYWtlL1dlYktpdENvbXBpbGVyRmxhZ3MuY21ha2UKQEAgLTI4Miw0ICsyODIsMjUg QEAgaWYgKENPTVBJTEVSX0lTX0dDQ19PUl9DTEFORykKICAgICAgICAgY2hlY2tfY3h4X3NvdXJj ZV9jb21waWxlcygiJHtBVE9NSUNfVEVTVF9TT1VSQ0V9IiBBVE9NSUNfSU5UNjRfUkVRVUlSRVNf TElCQVRPTUlDKQogICAgICAgICB1bnNldChDTUFLRV9SRVFVSVJFRF9MSUJSQVJJRVMpCiAgICAg ZW5kaWYgKCkKKworICAgICMgPGZpbGVzeXN0ZW0+IHZzIDxleHBlcmltZW50YWwvZmlsZXN5c3Rl bT4KKyAgICBzZXQoRklMRVNZU1RFTV9URVNUX1NPVVJDRSAiCisgICAgICAgICNpbmNsdWRlIDxm aWxlc3lzdGVtPgorICAgICAgICBpbnQgbWFpbigpIHsgc3RkOjpmaWxlc3lzdGVtOjpwYXRoIHAx KFwiXCIpOyBzdGQ6OmZpbGVzeXN0ZW06OnN0YXR1cyhwMSk7IH0KKyAgICAiKQorICAgIHNldChD TUFLRV9SRVFVSVJFRF9GTEFHUyAiLS1zdGQ9YysrMTciKQorICAgIGNoZWNrX2N4eF9zb3VyY2Vf Y29tcGlsZXMoIiR7RklMRVNZU1RFTV9URVNUX1NPVVJDRX0iIFNURF9GSUxFU1lTVEVNX0lTX0FW QUlMQUJMRSkKKyAgICBpZiAoTk9UIFNURF9GSUxFU1lTVEVNX0lTX0FWQUlMQUJMRSkKKyAgICAg ICAgc2V0KEVYUEVSSU1FTlRBTF9GSUxFU1lTVEVNX1RFU1RfU09VUkNFICIKKyAgICAgICAgICAg ICNpbmNsdWRlIDxleHBlcmltZW50YWwvZmlsZXN5c3RlbT4KKyAgICAgICAgICAgIGludCBtYWlu KCkgeworICAgICAgICAgICAgICAgIHN0ZDo6ZXhwZXJpbWVudGFsOjpmaWxlc3lzdGVtOjpwYXRo IHAxKFwiLy9ob21lXCIpOworICAgICAgICAgICAgICAgIHN0ZDo6ZXhwZXJpbWVudGFsOjpmaWxl c3lzdGVtOjpzdGF0dXMocDEpOworICAgICAgICAgICAgfQorICAgICAgICAiKQorICAgICAgICBz ZXQoQ01BS0VfUkVRVUlSRURfTElCUkFSSUVTIHN0ZGMrK2ZzKQorICAgICAgICBjaGVja19jeHhf c291cmNlX2NvbXBpbGVzKCIke0VYUEVSSU1FTlRBTF9GSUxFU1lTVEVNX1RFU1RfU09VUkNFfSIg U1REX0VYUEVSSU1FTlRBTF9GSUxFU1lTVEVNX0lTX0FWQUlMQUJMRSkKKyAgICAgICAgdW5zZXQo Q01BS0VfUkVRVUlSRURfTElCUkFSSUVTKQorICAgIGVuZGlmICgpCisgICAgdW5zZXQoQ01BS0Vf UkVRVUlSRURfRkxBR1MpCiBlbmRpZiAoKQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIv VG9vbHMvQ2hhbmdlTG9nCmluZGV4IGEwYjdhZTI3MWU3NTUwNWIxMDhmOWRiOTg0OTg3Njg2NWFk ODk1OWQuLjdlYTNlYWIzMjMwOTg1NDM4MGU3OWMxYTQ2NDY0MmFlMDg2ZTcwNDAgMTAwNjQ0Ci0t LSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBA QAorMjAyMC0xMC0xOSAgTGF1cm8gTW91cmEgIDxsbW91cmFAaWdhbGlhLmNvbT4KKworICAgICAg ICBSRUdSRVNTSU9OKHIyNjgxMTUpIFtHVEtdIEJ1aWxkIGZhaWx1cmVzIHdpdGggR0NDIDcgKFVi dW50dSAxOC4wNCkgYW5kIEdDQyA4IChEZWJpYW4gQnVzdGVyKQorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE3NDI1CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgQ2FybG9zIEFsYmVydG8gTG9wZXogUGVyZXouCisKKyAgICAgICAgKiBXZWJLaXRUZXN0UnVu bmVyL0NNYWtlTGlzdHMudHh0OiBMaW5rIHdpdGggc3RkYysrZnMgaWYgdXNpbmcKKyAgICAgICAg PGV4cGVyaW1lbnRhbC9maWxlc3lzdGVtPi4KKwogMjAyMC0xMC0xOSAgUnlhbiBIYWRkYWQgIDxy eWFuaGFkZGFkQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByZXZlcnRpbmcgcjI2 ODQ5NSwgcjI2ODU3MSwgYW5kIHIyNjg2ODIuCmRpZmYgLS1naXQgYS9Ub29scy9XZWJLaXRUZXN0 UnVubmVyL0NNYWtlTGlzdHMudHh0IGIvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9DTWFrZUxpc3Rz LnR4dAppbmRleCBhMGZkMDdlNzJkNWMyMzUyNTdmYjYwMDc4MzZmYmRkMmUwNTIzZTZhLi45OTM1 N2EwYjc4YzAzMTY4ODQ2NDcxYzI4YzJmMzQwYmQxZDQ5YmQ0IDEwMDY0NAotLS0gYS9Ub29scy9X ZWJLaXRUZXN0UnVubmVyL0NNYWtlTGlzdHMudHh0CisrKyBiL1Rvb2xzL1dlYktpdFRlc3RSdW5u ZXIvQ01ha2VMaXN0cy50eHQKQEAgLTI2LDYgKzI2LDEyIEBAIHNldChXZWJLaXRUZXN0UnVubmVy X0xJQlJBUklFUwogICAgIFdlYktpdDo6V2ViS2l0CiApCiAKK2lmIChDT01QSUxFUl9JU19HQ0Nf T1JfQ0xBTkcpCisgICAgaWYgKEhBVkVfU1REX0VYUEVSSU1FTlRBTF9GSUxFU1lTVEVNKQorICAg ICAgICBsaXN0KEFQUEVORCBXZWJLaXRUZXN0UnVubmVyX0xJQlJBUklFUyBzdGRjKytmcykKKyAg ICBlbmRpZiAoKQorZW5kaWYgKCkKKwogc2V0KFdlYktpdFRlc3RSdW5uZXJfSU5DTFVERV9ESVJF Q1RPUklFUwogICAgICR7Q01BS0VfQklOQVJZX0RJUn0KICAgICAke1dlYktpdFRlc3RSdW5uZXJf U0hBUkVEX0RJUn0KZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCBhNGFl ZjM5ZGFkNjU4MTM4MDRlZGMxNmM3NDU0MTBkMzY0NDM4MGNkLi4wNmZjZWE5Y2VmNWM2OGFhNjRi YmRkNDA4ZTA5NjA2MGNiNjY5OWVhIDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIvQ2hhbmdl TG9nCkBAIC0xLDMgKzEsMjcgQEAKKzIwMjAtMTAtMTkgIExhdXJvIE1vdXJhICA8bG1vdXJhQGln YWxpYS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjY4MTE1KSBbR1RLXSBCdWlsZCBmYWls dXJlcyB3aXRoIEdDQyA3IChVYnVudHUgMTguMDQpIGFuZCBHQ0MgOCAoRGViaWFuIEJ1c3RlcikK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIxNzQyNQor CisgICAgICAgIFJldmlld2VkIGJ5IENhcmxvcyBBbGJlcnRvIExvcGV6IFBlcmV6LgorCisgICAg ICAgIFRoZSByb290IGNhdXNlIGlzIGxhY2sgb2YgcHJvcGVyIDxmaWxlc3lzdGVtPiBzdXBwb3J0 IGluIGdjYzcvOCAoYW5kCisgICAgICAgIGluY29tcGF0aWJpbGl0eSB3aXRoIGxsdm0ncyBoZWFk ZXIgdGhhdCB3YXMgaW5jbHVkZWQpLiBBcyBzdWNoLCB3ZQorICAgICAgICBuZWVkIHRvIGNoZWNr IHdoZXRoZXIgdG8gdXNlIDxmaWxlc3lzdGVtPiwgPGV4cGVyaW1lbnRhbC9maWxlc3lzdGVtPiwK KyAgICAgICAgb3IgZmFsbGJhY2sgdG8gdGhlIGluY2x1ZGVkIGhlYWRlci4KKworICAgICAgICBO b3RlOiBJbiBzb21lIHN5c3RlbXMgbGlrZSBVYnVudHUgMjAuMDQsIGdjYy04IGNhbiB1c2UgZ2Nj LTkncworICAgICAgICBsaWJzdGRjKysgYW5kIGxpbmsgc3VjY2Vzc2Z1bGx5LCBidXQgcnVubmlu ZyB3aWxsIGZhaWwgYXMgaXQgc2hvdWxkCisgICAgICAgIGFjdHVhbGx5IGxpbmsgd2l0aCBpdHMg bGlic3RjKytmcyB0byBwcm92aWRlIHRoZSBjb3JyZWN0IHN5bWJvbHMuIEFzCisgICAgICAgIHRo aXMgaXMgc29tZSBjb3JuZXIgY2FzZSAoVWJ1bnR1J3MgMjAgZGVmYXVsdCBnY2MgaXMgOSksIExE RkxBR1MKKyAgICAgICAgY2FuIGJlIHVzZWQgdG8gb3ZlcmNvbWUgdGhpcy4KKworICAgICAgICAq IFNvdXJjZS9jbWFrZS9PcHRpb25zQ29tbW9uLmNtYWtlOiBBZGQgYSBIQVZFIGRpcmVjdGl2ZSB0 bworICAgICAgICBjaGVjayB3aGV0aGVyIDxleHBlcmltZW50YWwvZmlsZXN5c3RlbT4gaXMgdGhl IGZpbGVzeXN0ZW0gaW1wbAorICAgICAgICBhdmFpbGFibGUuCisgICAgICAgICogU291cmNlL2Nt YWtlL1dlYktpdENvbXBpbGVyRmxhZ3MuY21ha2U6IFRlc3QgZmlyc3Qgd2hldGhlcgorICAgICAg ICA8ZmlsZXN5c3RlbT4gY2FuIGJlIHVzZWQsIHdpdGggPGV4cGVyaW1lbnRhbC9maWxlc3R5c3Rl bT4gYXMgZmFsbGJhY2suCisKIDIwMjAtMTAtMTQgIFphbiBEb2JlcnNlayAgPHpkb2JlcnNla0Bp Z2FsaWEuY29tPgogCiAgICAgICAgIFJlbW92ZSBBQ0NFTEVSQVRFRF8yRF9DQU5WQVMgYnVpbGQg ZmxhZ3MgYW5kIGd1YXJkZWQgY29kZQo=