195508 2019-03-08 18:45:13 -0800 [JSC] BuiltinExecutables should behave like a WeakSet instead of generic WeakHandleOwner for memory footprint 2019-03-11 12:01:13 -0700 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 ysuzuki ysuzuki darin ews-watchlist keith_miller mark.lam msaboff rmorisset saam webkit-bug-importer oldest_to_newest 1514308 0 ysuzuki 2019-03-08 18:45:13 -0800 Weak<> is not cheap feature in terms of memory. 1514320 1 364111 ysuzuki 2019-03-08 20:43:03 -0800 Created attachment 364111 Patch 1514321 2 364111 rmorisset 2019-03-08 20:55:37 -0800 Comment on attachment 364111 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=364111&action=review I like this change a lot. I would r=me it but I am not yet an official reviewer. > Source/JavaScriptCore/builtins/BuiltinExecutables.cpp:288 > +#undef DEFINE_BUILTIN_EXECUTABLES So we were undef-ing the wrong macro?! Good catch. 1514575 3 364111 darin 2019-03-10 13:45:43 -0700 Comment on attachment 364111 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=364111&action=review > Source/JavaScriptCore/builtins/BuiltinExecutables.cpp:264 > + for (UnlinkedFunctionExecutable*& executable : m_executables) { I know other people don’t agree, but I really prefer "auto&" in a case like this. > Source/JavaScriptCore/builtins/BuiltinExecutables.cpp:273 > + return SourceCode(m_combinedSourceProvider.copyRef(), s_##name - s_JSCCombinedCode, (s_##name - s_JSCCombinedCode) + length, 1, 1);\ The SourceCode { } syntax might be better to use here, giving slightly stricter type checking. And possibly just { } without the explicit SourceCode. > Source/JavaScriptCore/builtins/BuiltinExecutables.h:40 > +#define PUT_BUILTIN_CODE_ID(name, functionName, overriddenName, length) name, Do we want to also include an #undef for this one? Maybe a shorter name for the macro too, like BUILTIN_NAME_ONLY. > Source/JavaScriptCore/builtins/BuiltinExecutables.h:64 > + void finalizeUnconditionally(); > +private: Typically we leave a blank line before the private section. 1514633 4 364111 keith_miller 2019-03-10 17:13:09 -0700 Comment on attachment 364111 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=364111&action=review >> Source/JavaScriptCore/builtins/BuiltinExecutables.cpp:264 >> + for (UnlinkedFunctionExecutable*& executable : m_executables) { > > I know other people don’t agree, but I really prefer "auto&" in a case like this. In think case, I would personally use the full type as Yusuke did. I like using auto when the type isn't completely clear from the context. Here, it's not clear that the executables are UnlinkedFunctionExecutables rather than say ScriptExecutable. In a hypothetical world where indexing didn't take forever, I'd agree that the type shouldn't be needed. I should be able to ask my editor to get that information from the compiler. Alas, that world doesn't exist yet... :( 1514640 5 darin 2019-03-10 18:15:07 -0700 (In reply to Keith Miller from comment #4) > Comment on attachment 364111 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=364111&action=review > > >> Source/JavaScriptCore/builtins/BuiltinExecutables.cpp:264 > >> + for (UnlinkedFunctionExecutable*& executable : m_executables) { > > > > I know other people don’t agree, but I really prefer "auto&" in a case like this. > > In think case, I would personally use the full type as Yusuke did. I like > using auto when the type isn't completely clear from the context. Here, it's > not clear that the executables are UnlinkedFunctionExecutables rather than > say ScriptExecutable. > > In a hypothetical world where indexing didn't take forever, I'd agree that > the type shouldn't be needed. I should be able to ask my editor to get that > information from the compiler. Alas, that world doesn't exist yet... :( I’m going to try to not rehash the argument, but I will point out, once again, that we seem perfectly able to call functions and use the function results to call a member function without naming the type of each function result. I don’t think that a for loop value is different in this respect, unless the logic inside the loop is complex. It’s not as simple for me as "can you look up the type easily?". 1514899 6 364111 ysuzuki 2019-03-11 11:43:44 -0700 Comment on attachment 364111 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=364111&action=review >>>> Source/JavaScriptCore/builtins/BuiltinExecutables.cpp:264 >>>> + for (UnlinkedFunctionExecutable*& executable : m_executables) { >>> >>> I know other people don’t agree, but I really prefer "auto&" in a case like this. >> >> In think case, I would personally use the full type as Yusuke did. I like using auto when the type isn't completely clear from the context. Here, it's not clear that the executables are UnlinkedFunctionExecutables rather than say ScriptExecutable. >> >> In a hypothetical world where indexing didn't take forever, I'd agree that the type shouldn't be needed. I should be able to ask my editor to get that information from the compiler. Alas, that world doesn't exist yet... :( > > I’m going to try to not rehash the argument, but I will point out, once again, that we seem perfectly able to call functions and use the function results to call a member function without naming the type of each function result. I don’t think that a for loop value is different in this respect, unless the logic inside the loop is complex. > > It’s not as simple for me as "can you look up the type easily?". Personally, I like writing full-types as long as the type is meaningful (like, I don't like writing std::vector<int>::const_iterator etc.). So, maybe, `m_unlinkedExecutables` and `unlinkedExecutable` variable names would allow us to use `auto*&`, while keeping its type clear :) Fixed. >> Source/JavaScriptCore/builtins/BuiltinExecutables.cpp:273 >> + return SourceCode(m_combinedSourceProvider.copyRef(), s_##name - s_JSCCombinedCode, (s_##name - s_JSCCombinedCode) + length, 1, 1);\ > > The SourceCode { } syntax might be better to use here, giving slightly stricter type checking. And possibly just { } without the explicit SourceCode. Fixed. >> Source/JavaScriptCore/builtins/BuiltinExecutables.cpp:288 >> +#undef DEFINE_BUILTIN_EXECUTABLES > > So we were undef-ing the wrong macro?! Good catch. :) >> Source/JavaScriptCore/builtins/BuiltinExecutables.h:40 >> +#define PUT_BUILTIN_CODE_ID(name, functionName, overriddenName, length) name, > > Do we want to also include an #undef for this one? Maybe a shorter name for the macro too, like BUILTIN_NAME_ONLY. Yeah, fixed and changed. >> Source/JavaScriptCore/builtins/BuiltinExecutables.h:64 >> +private: > > Typically we leave a blank line before the private section. Fixed. 1514904 7 ysuzuki 2019-03-11 11:59:30 -0700 Committed r242722: <https://trac.webkit.org/changeset/242722> 1514909 8 webkit-bug-importer 2019-03-11 12:01:13 -0700 <rdar://problem/48775996> 364111 2019-03-08 20:43:03 -0800 2019-03-10 13:45:43 -0700 Patch bug-195508-20190308204303.patch text/plain 7743 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjQyNjcwCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAx YmM4YmRlZDlmNzY2YmY0ZjdlYjE1MzllZGZkYTEwMjUyNWNjYjNjLi5iYmZjNDk2ZGMyYmNkM2Iz YWVkYWZhZmFkZWUwYmNmYzc5MGZmMTg0IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzMyBAQAorMjAxOS0wMy0wOCAgWXVzdWtlIFN1enVraSAgPHlzdXp1a2lAYXBwbGUuY29t PgorCisgICAgICAgIFtKU0NdIEJ1aWx0aW5FeGVjdXRhYmxlcyBzaG91bGQgYmVoYXZlIGxpa2Ug YSBXZWFrU2V0IGluc3RlYWQgb2YgZ2VuZXJpYyBXZWFrSGFuZGxlT3duZXIgZm9yIG1lbW9yeSBm b290cHJpbnQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTE5NTUwOAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFdlYWs8PiBpcyBub3QgY2hlYXAgaW4gdGVybXMgb2YgbWVtb3J5IGZvb3RwcmludC4gV2UgYWxs b2NhdGUgV2Vha0Jsb2NrICgyNTYgYnl0ZXMpIGZvciBib29rLWtlZXBpbmcgV2Vhazw+LgorICAg ICAgICBDdXJyZW50bHkgQnVpbHRpbkV4ZWN1dGFibGVzIGhhcyAyMDMgV2Vhazw+IG1lbWJlcnMg YW5kIG1hbnkgV2Vha0Jsb2NrcyBhcmUgYWN0dWFsbHkgYWxsb2NhdGVkIGJlY2F1c2UKKyAgICAg ICAgbWFueSBVbmxpbmtlZEZ1bmN0aW9uRXhlY3V0YWJsZXMgaW4gQnVpbHRpbkV4ZWN1dGFibGVz IGFyZSBhbGxvY2F0ZWQgZHVyaW5nIEpTR2xvYmFsT2JqZWN0IGluaXRpYWxpemF0aW9uIHByb2Nl c3MuCisKKyAgICAgICAgVGhpcyBwYXRjaCBjaGFuZ2VzIHR3byB0aGluZ3MgaW4gQnVpbHRpbkV4 ZWN1dGFibGVzLgorCisgICAgICAgIDEuIFByZXZpb3VzbHkgd2UgaGF2ZSBtX3h4eFNvdXJjZUNv ZGUgZmllbGRzIHRvby4gQnV0IHdlIGRvIG5vdCBuZWVkIHRvIGtlZXAgaXQgc2luY2Ugd2Uga25v dyBob3cgdG8gcHJvZHVjZSBpdCB3aGVuIGl0IGlzIHJlcXVpcmVkLgorICAgICAgICAgICBXZSBn ZW5lcmF0ZSBTb3VyY2VDb2RlIGluIHh4eFNvdXJjZUNvZGUoKSBtZXRob2QgaW5zdGVhZCBvZiBq dXN0IHJldHVybmluZyBtX3h4eFNvdXJjZUNvZGUuIFRoaXMgcmVkdWNlcyBzaXplb2YoQnVpbHRp bkV4ZWN1dGFibGVzKSAyNCB4IDIwMyA9IDRLQi4KKworICAgICAgICAyLiBJbnN0ZWFkIG9mIHVz aW5nIFdlYWs8PiwgQnVpbHRpbkV4ZWN1dGFibGVzIGhvbGRzIHJhdyBhcnJheSBvZiBVbmxpbmtl ZEZ1bmN0aW9uRXhlY3V0YWJsZSouIEFuZCBIZWFwOjpmaW5hbGl6ZVVuY29uZGl0aW9uYWxGaW5h bGl6ZXJzKCkgY29ycmVjdGx5IGNsZWFycyBkZWFkIGV4ZWN1dGFibGVzLgorICAgICAgICAgICBU aGlzIGlzIHNpbWlsYXIgdG8gSlNXZWFrU2V0IGltcGxlbWVudGF0aW9uLiBBbmQgaXQgc2F2ZXMg V2Vha0Jsb2NrIGFsbG9jYXRpb25zLgorCisgICAgICAgICogYnVpbHRpbnMvQnVpbHRpbkV4ZWN1 dGFibGVzLmNwcDoKKyAgICAgICAgKEpTQzo6QnVpbHRpbkV4ZWN1dGFibGVzOjpCdWlsdGluRXhl Y3V0YWJsZXMpOgorICAgICAgICAoSlNDOjpCdWlsdGluRXhlY3V0YWJsZXM6OmZpbmFsaXplVW5j b25kaXRpb25hbGx5KToKKyAgICAgICAgKEpTQzo6SlNDX0ZPUkVBQ0hfQlVJTFRJTl9DT0RFKTog RGVsZXRlZC4KKyAgICAgICAgKEpTQzo6QnVpbHRpbkV4ZWN1dGFibGVzOjpmaW5hbGl6ZSk6IERl bGV0ZWQuCisgICAgICAgICogYnVpbHRpbnMvQnVpbHRpbkV4ZWN1dGFibGVzLmg6CisgICAgICAg IChKU0M6OkJ1aWx0aW5FeGVjdXRhYmxlczo6c3RhdGljX2Nhc3Q8dW5zaWduZWQ+KToKKyAgICAg ICAgKCk6IERlbGV0ZWQuCisgICAgICAgICogaGVhcC9IZWFwLmNwcDoKKyAgICAgICAgKEpTQzo6 SGVhcDo6ZmluYWxpemVVbmNvbmRpdGlvbmFsRmluYWxpemVycyk6CisKIDIwMTktMDMtMDggIE1h cmsgTGFtICA8bWFyay5sYW1AYXBwbGUuY29tPgogCiAgICAgICAgIFN0YWNrIG92ZXJmbG93IGNy YXNoIGluIEpTQzo6SlNPYmplY3Q6Omhhc0luc3RhbmNlLgpkaWZmIC0tZ2l0IGEvU291cmNlL0ph dmFTY3JpcHRDb3JlL2J1aWx0aW5zL0J1aWx0aW5FeGVjdXRhYmxlcy5jcHAgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvYnVpbHRpbnMvQnVpbHRpbkV4ZWN1dGFibGVzLmNwcAppbmRleCAyZDZmZTBl MzU0ODk4YzM4MTA0MmJhN2FjMDY4ODYyZGM0NzBjMjZlLi45NTk3OTZiOWEwNDVkZGFhZjk4ZmRl NmMwNGQ4ZGJlOTZiMTQwOTdkIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvYnVp bHRpbnMvQnVpbHRpbkV4ZWN1dGFibGVzLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv YnVpbHRpbnMvQnVpbHRpbkV4ZWN1dGFibGVzLmNwcApAQCAtMzcsOSArMzcsNiBAQCBuYW1lc3Bh Y2UgSlNDIHsKIEJ1aWx0aW5FeGVjdXRhYmxlczo6QnVpbHRpbkV4ZWN1dGFibGVzKFZNJiB2bSkK ICAgICA6IG1fdm0odm0pCiAgICAgLCBtX2NvbWJpbmVkU291cmNlUHJvdmlkZXIoU3RyaW5nU291 cmNlUHJvdmlkZXI6OmNyZWF0ZShTdHJpbmdJbXBsOjpjcmVhdGVGcm9tTGl0ZXJhbChzX0pTQ0Nv bWJpbmVkQ29kZSwgc19KU0NDb21iaW5lZENvZGVMZW5ndGgpLCB7IH0sIFVSTCgpKSkKLSNkZWZp bmUgSU5JVElBTElaRV9CVUlMVElOX1NPVVJDRV9NRU1CRVJTKG5hbWUsIGZ1bmN0aW9uTmFtZSwg b3ZlcnJpZGVOYW1lLCBsZW5ndGgpICwgbV8jI25hbWUjI1NvdXJjZShtX2NvbWJpbmVkU291cmNl UHJvdmlkZXIuY29weVJlZigpLCBzXyMjbmFtZSAtIHNfSlNDQ29tYmluZWRDb2RlLCAoc18jI25h bWUgLSBzX0pTQ0NvbWJpbmVkQ29kZSkgKyBsZW5ndGgsIDEsIDEpCi0gICAgSlNDX0ZPUkVBQ0hf QlVJTFRJTl9DT0RFKElOSVRJQUxJWkVfQlVJTFRJTl9TT1VSQ0VfTUVNQkVSUykKLSN1bmRlZiBJ TklUSUFMSVpFX0JVSUxUSU5fU09VUkNFX01FTUJFUlMKIHsKIH0KIApAQCAtMjYyLDIzICsyNTks MzIgQEAgVW5saW5rZWRGdW5jdGlvbkV4ZWN1dGFibGUqIEJ1aWx0aW5FeGVjdXRhYmxlczo6Y3Jl YXRlRXhlY3V0YWJsZShWTSYgdm0sIGNvbnN0IFMKICAgICByZXR1cm4gZnVuY3Rpb25FeGVjdXRh YmxlOwogfQogCi12b2lkIEJ1aWx0aW5FeGVjdXRhYmxlczo6ZmluYWxpemUoSGFuZGxlPFVua25v d24+LCB2b2lkKiBjb250ZXh0KQordm9pZCBCdWlsdGluRXhlY3V0YWJsZXM6OmZpbmFsaXplVW5j b25kaXRpb25hbGx5KCkKIHsKLSAgICBzdGF0aWNfY2FzdDxXZWFrPFVubGlua2VkRnVuY3Rpb25F eGVjdXRhYmxlPio+KGNvbnRleHQpLT5jbGVhcigpOworICAgIGZvciAoVW5saW5rZWRGdW5jdGlv bkV4ZWN1dGFibGUqJiBleGVjdXRhYmxlIDogbV9leGVjdXRhYmxlcykgeworICAgICAgICBpZiAo ZXhlY3V0YWJsZSAmJiAhSGVhcDo6aXNNYXJrZWQoZXhlY3V0YWJsZSkpCisgICAgICAgICAgICBl eGVjdXRhYmxlID0gbnVsbHB0cjsKKyAgICB9CiB9CiAKICNkZWZpbmUgREVGSU5FX0JVSUxUSU5f RVhFQ1VUQUJMRVMobmFtZSwgZnVuY3Rpb25OYW1lLCBvdmVycmlkZU5hbWUsIGxlbmd0aCkgXAor U291cmNlQ29kZSBCdWlsdGluRXhlY3V0YWJsZXM6Om5hbWUjI1NvdXJjZSgpIFwKK3tcCisgICAg cmV0dXJuIFNvdXJjZUNvZGUobV9jb21iaW5lZFNvdXJjZVByb3ZpZGVyLmNvcHlSZWYoKSwgc18j I25hbWUgLSBzX0pTQ0NvbWJpbmVkQ29kZSwgKHNfIyNuYW1lIC0gc19KU0NDb21iaW5lZENvZGUp ICsgbGVuZ3RoLCAxLCAxKTtcCit9XAorXAogVW5saW5rZWRGdW5jdGlvbkV4ZWN1dGFibGUqIEJ1 aWx0aW5FeGVjdXRhYmxlczo6bmFtZSMjRXhlY3V0YWJsZSgpIFwKIHtcCi0gICAgaWYgKCFtXyMj bmFtZSMjRXhlY3V0YWJsZSkge1wKKyAgICB1bnNpZ25lZCBpbmRleCA9IHN0YXRpY19jYXN0PHVu c2lnbmVkPihCdWlsdGluQ29kZUluZGV4OjpuYW1lKTtcCisgICAgaWYgKCFtX2V4ZWN1dGFibGVz W2luZGV4XSkge1wKICAgICAgICAgSWRlbnRpZmllciBleGVjdXRhYmxlTmFtZSA9IG1fdm0ucHJv cGVydHlOYW1lcy0+YnVpbHRpbk5hbWVzKCkuZnVuY3Rpb25OYW1lIyNQdWJsaWNOYW1lKCk7XAog ICAgICAgICBpZiAob3ZlcnJpZGVOYW1lKVwKICAgICAgICAgICAgIGV4ZWN1dGFibGVOYW1lID0g SWRlbnRpZmllcjo6ZnJvbVN0cmluZygmbV92bSwgb3ZlcnJpZGVOYW1lKTtcCi0gICAgICAgIG1f IyNuYW1lIyNFeGVjdXRhYmxlID0gV2VhazxVbmxpbmtlZEZ1bmN0aW9uRXhlY3V0YWJsZT4oY3Jl YXRlQnVpbHRpbkV4ZWN1dGFibGUobV8jI25hbWUjI1NvdXJjZSwgZXhlY3V0YWJsZU5hbWUsIHNf IyNuYW1lIyNDb25zdHJ1Y3RBYmlsaXR5KSwgdGhpcywgJm1fIyNuYW1lIyNFeGVjdXRhYmxlKTtc CisgICAgICAgIG1fZXhlY3V0YWJsZXNbaW5kZXhdID0gY3JlYXRlQnVpbHRpbkV4ZWN1dGFibGUo bmFtZSMjU291cmNlKCksIGV4ZWN1dGFibGVOYW1lLCBzXyMjbmFtZSMjQ29uc3RydWN0QWJpbGl0 eSk7XAogICAgIH1cCi0gICAgcmV0dXJuIG1fIyNuYW1lIyNFeGVjdXRhYmxlLmdldCgpO1wKKyAg ICByZXR1cm4gbV9leGVjdXRhYmxlc1tpbmRleF07XAogfQogSlNDX0ZPUkVBQ0hfQlVJTFRJTl9D T0RFKERFRklORV9CVUlMVElOX0VYRUNVVEFCTEVTKQotI3VuZGVmIEVYUE9TRV9CVUlMVElOX1NP VVJDRVMKKyN1bmRlZiBERUZJTkVfQlVJTFRJTl9FWEVDVVRBQkxFUwogCiB9CmRpZmYgLS1naXQg YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvYnVpbHRpbnMvQnVpbHRpbkV4ZWN1dGFibGVzLmggYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvYnVpbHRpbnMvQnVpbHRpbkV4ZWN1dGFibGVzLmgKaW5kZXgg NmRjYmVkZDQ3M2UxODZhNTM0NmMzODA0MWJlYzY5OWVkMGQ2MDZkOS4uY2UzMjQwMWJiZDUxMDVj YjFkZTNjMDhiNGU2YmU3ZjVlZGFlZjYzNCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL2J1aWx0aW5zL0J1aWx0aW5FeGVjdXRhYmxlcy5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9idWlsdGlucy9CdWlsdGluRXhlY3V0YWJsZXMuaApAQCAtMzcsMTQgKzM3LDIwIEBAIGNs YXNzIFVubGlua2VkRnVuY3Rpb25FeGVjdXRhYmxlOwogY2xhc3MgSWRlbnRpZmllcjsKIGNsYXNz IFZNOwogCi1jbGFzcyBCdWlsdGluRXhlY3V0YWJsZXMgZmluYWw6IHByaXZhdGUgV2Vha0hhbmRs ZU93bmVyIHsKKyNkZWZpbmUgUFVUX0JVSUxUSU5fQ09ERV9JRChuYW1lLCBmdW5jdGlvbk5hbWUs IG92ZXJyaWRkZW5OYW1lLCBsZW5ndGgpIG5hbWUsCitlbnVtIGNsYXNzIEJ1aWx0aW5Db2RlSW5k ZXggeworICAgIEpTQ19GT1JFQUNIX0JVSUxUSU5fQ09ERShQVVRfQlVJTFRJTl9DT0RFX0lEKQor ICAgIE51bWJlck9mQnVpbHRpbkNvZGVzCit9OworCitjbGFzcyBCdWlsdGluRXhlY3V0YWJsZXMg ewogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwogcHVibGljOgogICAgIGV4cGxpY2l0IEJ1 aWx0aW5FeGVjdXRhYmxlcyhWTSYpOwogCiAjZGVmaW5lIEVYUE9TRV9CVUlMVElOX0VYRUNVVEFC TEVTKG5hbWUsIGZ1bmN0aW9uTmFtZSwgb3ZlcnJpZGRlbk5hbWUsIGxlbmd0aCkgXAogVW5saW5r ZWRGdW5jdGlvbkV4ZWN1dGFibGUqIG5hbWUjI0V4ZWN1dGFibGUoKTsgXAotY29uc3QgU291cmNl Q29kZSYgbmFtZSMjU291cmNlKCkgeyByZXR1cm4gbV8jI25hbWUjI1NvdXJjZTsgfQorU291cmNl Q29kZSBuYW1lIyNTb3VyY2UoKTsKICAgICAKICAgICBKU0NfRk9SRUFDSF9CVUlMVElOX0NPREUo RVhQT1NFX0JVSUxUSU5fRVhFQ1VUQUJMRVMpCiAjdW5kZWYgRVhQT1NFX0JVSUxUSU5fRVhFQ1VU QUJMRVMKQEAgLTUzLDE5ICs1OSwxNSBAQCBjb25zdCBTb3VyY2VDb2RlJiBuYW1lIyNTb3VyY2Uo KSB7IHJldHVybiBtXyMjbmFtZSMjU291cmNlOyB9CiAgICAgVW5saW5rZWRGdW5jdGlvbkV4ZWN1 dGFibGUqIGNyZWF0ZURlZmF1bHRDb25zdHJ1Y3RvcihDb25zdHJ1Y3RvcktpbmQsIGNvbnN0IElk ZW50aWZpZXImIG5hbWUpOwogCiAgICAgc3RhdGljIFVubGlua2VkRnVuY3Rpb25FeGVjdXRhYmxl KiBjcmVhdGVFeGVjdXRhYmxlKFZNJiwgY29uc3QgU291cmNlQ29kZSYsIGNvbnN0IElkZW50aWZp ZXImLCBDb25zdHJ1Y3RvcktpbmQsIENvbnN0cnVjdEFiaWxpdHkpOwotcHJpdmF0ZToKLSAgICB2 b2lkIGZpbmFsaXplKEhhbmRsZTxVbmtub3duPiwgdm9pZCogY29udGV4dCkgb3ZlcnJpZGU7CiAK KyAgICB2b2lkIGZpbmFsaXplVW5jb25kaXRpb25hbGx5KCk7Citwcml2YXRlOgogICAgIFZNJiBt X3ZtOwogCiAgICAgVW5saW5rZWRGdW5jdGlvbkV4ZWN1dGFibGUqIGNyZWF0ZUJ1aWx0aW5FeGVj dXRhYmxlKGNvbnN0IFNvdXJjZUNvZGUmLCBjb25zdCBJZGVudGlmaWVyJiwgQ29uc3RydWN0QWJp bGl0eSk7CiAKICAgICBSZWY8U3RyaW5nU291cmNlUHJvdmlkZXI+IG1fY29tYmluZWRTb3VyY2VQ cm92aWRlcjsKLSNkZWZpbmUgREVDTEFSRV9CVUlMVElOX1NPVVJDRV9NRU1CRVJTKG5hbWUsIGZ1 bmN0aW9uTmFtZSwgb3ZlcnJpZGRlbk5hbWUsIGxlbmd0aClcCi0gICAgU291cmNlQ29kZSBtXyMj bmFtZSMjU291cmNlOyBcCi0gICAgV2VhazxVbmxpbmtlZEZ1bmN0aW9uRXhlY3V0YWJsZT4gbV8j I25hbWUjI0V4ZWN1dGFibGU7Ci0gICAgSlNDX0ZPUkVBQ0hfQlVJTFRJTl9DT0RFKERFQ0xBUkVf QlVJTFRJTl9TT1VSQ0VfTUVNQkVSUykKLSN1bmRlZiBERUNMQVJFX0JVSUxUSU5fU09VUkNFX01F TUJFUlMKKyAgICBVbmxpbmtlZEZ1bmN0aW9uRXhlY3V0YWJsZSogbV9leGVjdXRhYmxlc1tzdGF0 aWNfY2FzdDx1bnNpZ25lZD4oQnVpbHRpbkNvZGVJbmRleDo6TnVtYmVyT2ZCdWlsdGluQ29kZXMp XSB7IH07CiB9OwogCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9I ZWFwLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL0hlYXAuY3BwCmluZGV4IDA5NGE3 ODUyYjk3MmUyMThmNTk4NzIzNWFhOWFjYjc2ODFhNzhjNTAuLjIzMDcxMWUyNWQzODE5ZjRiY2Fl YWFlNGYwYjhiMDU0OTkzMTE5NzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9o ZWFwL0hlYXAuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL0hlYXAuY3BwCkBA IC0yMiw2ICsyMiw3IEBACiAjaW5jbHVkZSAiSGVhcC5oIgogCiAjaW5jbHVkZSAiQmxvY2tEaXJl Y3RvcnlJbmxpbmVzLmgiCisjaW5jbHVkZSAiQnVpbHRpbkV4ZWN1dGFibGVzLmgiCiAjaW5jbHVk ZSAiQ29kZUJsb2NrLmgiCiAjaW5jbHVkZSAiQ29kZUJsb2NrU2V0SW5saW5lcy5oIgogI2luY2x1 ZGUgIkNvbGxlY3RpbmdTY29wZS5oIgpAQCAtNTU5LDYgKzU2MCw3IEBAIHZvaWQgSGVhcDo6Zmlu YWxpemVNYXJrZWRVbmNvbmRpdGlvbmFsRmluYWxpemVycyhDZWxsU2V0JiBjZWxsU2V0KQogCiB2 b2lkIEhlYXA6OmZpbmFsaXplVW5jb25kaXRpb25hbEZpbmFsaXplcnMoKQogeworICAgIHZtKCkt PmJ1aWx0aW5FeGVjdXRhYmxlcygpLT5maW5hbGl6ZVVuY29uZGl0aW9uYWxseSgpOwogICAgIGlm ICh2bSgpLT5tX2luZmVycmVkVmFsdWVTcGFjZSkKICAgICAgICAgZmluYWxpemVNYXJrZWRVbmNv bmRpdGlvbmFsRmluYWxpemVyczxJbmZlcnJlZFZhbHVlPih2bSgpLT5tX2luZmVycmVkVmFsdWVT cGFjZS0+c3BhY2UpOwogICAgIHZtKCktPmZvckVhY2hDb2RlQmxvY2tTcGFjZSgK