197060 2019-04-18 09:28:09 -0700 WebCore: auto-initialize stack variables 2020-01-24 11:57:49 -0800 1 1 1 Unclassified WebKit WebCore Misc. WebKit Nightly Build Unspecified Unspecified ASSIGNED InRadar P2 Normal --- 1 jfbastien krollin ap bfulgham dean_johnson fpizlo jfbastien krollin mjs webkit-bug-importer oldest_to_newest 1528466 0 jfbastien 2019-04-18 09:28:09 -0700 Clang added support for C / C++ variable auto-initialization. The build’s CFLAGS / CCFLAGS can use the following flag: -ftrivial-auto-var-init=pattern An Xcode setting can also be used, which will enable said flag if it's available in clang. Variable auto-initialization will affect stack variables as follows: - Initialize all integers and pointers to repeated 0xAA byte pattern - Initialize all floating point values to “negative NaN with repeated 0xFF payload” (i.e. float32 is 0xFFFFFFFF and float64 is 0xFFFFFFFFFFFFFFFF) - Initialize aggregate types in the same way, and their padding (structs, classes, vectors, arrays, variable-length arrays, unions) The optimizer will then get rid of redundant initializations (if it doesn't, please file bugs on clang). This means that attackers can’t exploit uninitialized stack variables as easily because they can’t leave a value on the stack / in a register and use it later in a manner which the program wasn’t designed to handle. This currently increases binary size by 1%–2% and, in some cases, has a similar or smaller performance impact.We’ve put effort in reducing this impact, but the compiler can still be improved to reduce this impact. Concretely, WebCore on x86-64 grows by 1.9% on a recent clang (though we've done more optimizations since this measurement). We ran performance numbers on benchmarks we find important and Dean said "looking at the results, I think we have enough evidence to say it doesn't appear to be a regression". As a workaround when performance impact is unacceptable, the compiler isn't optimizing things away, and you've manually validated that code was correct, you can mark the corresponding stack variable as follows: struct uninitialized_struct __attribute((uninitialized)); int uninitalized_array[42] __attribute((uninitialized)); int uninitialized_scalar __attribute((uninitialized)); Of course, you then have no protection of that variable from uninitialized usage! 1528469 1 jfbastien 2019-04-18 09:32:10 -0700 <rdar://problem/50018087> 1528470 2 jfbastien 2019-04-18 09:32:16 -0700 <rdar://problem/50018087> 1528471 3 webkit-bug-importer 2019-04-18 09:32:23 -0700 <rdar://problem/50018144> 1528472 4 webkit-bug-importer 2019-04-18 09:32:41 -0700 <rdar://problem/50018155> 1528473 5 367730 jfbastien 2019-04-18 09:33:07 -0700 Created attachment 367730 patch 1528497 6 367730 ap 2019-04-18 10:37:55 -0700 Comment on attachment 367730 patch Please add a ChangeLog. r- on this technicality. Also some questions and suggestions. 1. I can see how this can be somewhat perf neutral on optimized builds, but what does this do to debug builds? We don't want tests to become slower in debug mode. 2. How does this interact with UBSan, will we still be getting diagnostics for uninitialized variables? I think that it's still a net win even if this breaks this aspect of UBSan functionality, but it would be useful to know how exactly it works. 3. Similarly, how does this interact with static analysis, will clang static analyzer now think that all these variables are initialized? 4. For the 1.9% WebCore size regression, I'm assuming that all of that are additional initializations, so it's quite surprising that so much new code isn't registering on benchmarks. Is there some explanation for that? 5. There was a discussion about initializing all variables by default recently in bug 196855, with regards to silencing Coverity warnings. The idea that it's OK to introduce some perf regressions as long as our current benchmark suite can't detect those is not universally agreed upon. The right place to discuss that is the webkit-dev mailing list. 1528500 7 367734 jfbastien 2019-04-18 10:45:23 -0700 Created attachment 367734 patch Add changelog 1528506 8 jfbastien 2019-04-18 10:52:44 -0700 (In reply to Alexey Proskuryakov from comment #6) > Comment on attachment 367730 [details] > patch > > Please add a ChangeLog. r- on this technicality. Also some questions and > suggestions. Done. > 1. I can see how this can be somewhat perf neutral on optimized builds, but > what does this do to debug builds? We don't want tests to become slower in > debug mode. It generates more code in debug builds, but we didn't measure the performance impact. If debug performance matters I suggest not just using -O0 because it's quite terrible. There's a handful of optimizations that you could turn on that would compile *faster* or slightly slower (depends which) while still generating totally debuggable code. There's also ongoing work to create a better low-optimization pipeline in LLVM. I think this discussion should be held separately from this patch. > 2. How does this interact with UBSan, will we still be getting diagnostics > for uninitialized variables? I think that it's still a net win even if this > breaks this aspect of UBSan functionality, but it would be useful to know > how exactly it works. It doesn't interact with UBSan. UBSan also doesn't give you diagnostics for uninitialized variables. Only msan does this for stack values. > 3. Similarly, how does this interact with static analysis, will clang static > analyzer now think that all these variables are initialized? It doesn't interact with static analysis (nor the warnings). The diagnostics remain unchanged. > 4. For the 1.9% WebCore size regression, I'm assuming that all of that are > additional initializations, so it's quite surprising that so much new code > isn't registering on benchmarks. Is there some explanation for that? Yes, I've sent detailed information to the folks I've CC'ed to the review. Some is caused by large stack buffers, some is new code (when memset / memcpy gets inlined), and some is rodata globals that get memcpy'd to the stack (because that particular stack variable is big and isn't a repeated byte pattern). This in turn influences inlining decisions. If you want all the details please look at the related radars, I've done extensive measurements and optimizations. Keep in mind that there's still ongoing work to optimize this further (by myself and others in the LLVM project). > 5. There was a discussion about initializing all variables by default > recently in bug 196855, with regards to silencing Coverity warnings. The > idea that it's OK to introduce some perf regressions as long as our current > benchmark suite can't detect those is not universally agreed upon. The right > place to discuss that is the webkit-dev mailing list. I don't follow webkit-dev, but I suggest reading the radar and related ones for the discussions that have happened. 1528538 9 367734 ap 2019-04-18 13:01:44 -0700 Comment on attachment 367734 patch > I don't follow webkit-dev, but I suggest reading the radar and related ones for the discussions that have happened. What I'm saying is that we shouldn't make such policy changes without a webkit-dev discussion. 1528772 10 ap 2019-04-19 09:13:45 -0700 > It doesn't interact with UBSan. UBSan also doesn't give you diagnostics for uninitialized variables. Only msan does this for stack values. OK. Does it break MSan uninitialized variable diagnostics? If it doesn't explicitly interact with it, it probably does break it, as variables are now initialized. 1528782 11 jfbastien 2019-04-19 10:09:36 -0700 (In reply to Alexey Proskuryakov from comment #10) > > It doesn't interact with UBSan. UBSan also doesn't give you diagnostics for uninitialized variables. Only msan does this for stack values. > > OK. Does it break MSan uninitialized variable diagnostics? If it doesn't > explicitly interact with it, it probably does break it, as variables are now > initialized. This patch turns on auto-init for platforms that build with Xcode. Which of those do you run msan on? 1528975 12 ap 2019-04-19 17:27:21 -0700 Currently none, but we are very interested in enabling diagnostics of this kind. 367730 2019-04-18 09:33:07 -0700 2019-04-18 10:45:23 -0700 patch 0001-WebCore-auto-initialize-stack-variables.patch text/plain 3293 jfbastien RnJvbSAzYjJlN2NjM2IyOTQyOTMyMWI4NDA5YTJhMjhkZGRiNjhlM2VlMTgyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBUaHUsIDE4IEFwciAyMDE5IDA5OjI4OjU3IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gV2ViQ29y ZTogYXV0by1pbml0aWFsaXplIHN0YWNrIHZhcmlhYmxlcwpNSU1FLVZlcnNpb246IDEuMApDb250 ZW50LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNv ZGluZzogOGJpdAoKQ2xhbmcgYWRkZWQgc3VwcG9ydCBmb3IgQyAvIEMrKyB2YXJpYWJsZSBhdXRv LWluaXRpYWxpemF0aW9uLgoKVGhlIGJ1aWxk4oCZcyBDRkxBR1MgLyBDQ0ZMQUdTIGNhbiB1c2Ug dGhlIGZvbGxvd2luZyBmbGFnOgogIC1mdHJpdmlhbC1hdXRvLXZhci1pbml0PXBhdHRlcm4KQW4g WGNvZGUgc2V0dGluZyBjYW4gYWxzbyBiZSB1c2VkLCB3aGljaCB3aWxsIGVuYWJsZSBzYWlkIGZs YWcgaWYgaXQncyBhdmFpbGFibGUgaW4gY2xhbmcuCgpWYXJpYWJsZSBhdXRvLWluaXRpYWxpemF0 aW9uIHdpbGwgYWZmZWN0IHN0YWNrIHZhcmlhYmxlcyBhcyBmb2xsb3dzOgogLSBJbml0aWFsaXpl IGFsbCBpbnRlZ2VycyBhbmQgcG9pbnRlcnMgdG8gcmVwZWF0ZWQgMHhBQSBieXRlIHBhdHRlcm4K IC0gSW5pdGlhbGl6ZSBhbGwgZmxvYXRpbmcgcG9pbnQgdmFsdWVzIHRvIOKAnG5lZ2F0aXZlIE5h TiB3aXRoIHJlcGVhdGVkIDB4RkYgcGF5bG9hZOKAnSAoaS5lLiBmbG9hdDMyIGlzIDB4RkZGRkZG RkYgYW5kIGZsb2F0NjQgaXMgMHhGRkZGRkZGRkZGRkZGRkZGKQogLSBJbml0aWFsaXplIGFnZ3Jl Z2F0ZSB0eXBlcyBpbiB0aGUgc2FtZSB3YXksIGFuZCB0aGVpciBwYWRkaW5nIChzdHJ1Y3RzLCBj bGFzc2VzLCB2ZWN0b3JzLCBhcnJheXMsIHZhcmlhYmxlLWxlbmd0aCBhcnJheXMsIHVuaW9ucykK VGhlIG9wdGltaXplciB3aWxsIHRoZW4gZ2V0IHJpZCBvZiByZWR1bmRhbnQgaW5pdGlhbGl6YXRp b25zIChpZiBpdCBkb2Vzbid0LCBwbGVhc2UgZmlsZSBidWdzIG9uIGNsYW5nKS4KClRoaXMgbWVh bnMgdGhhdCBhdHRhY2tlcnMgY2Fu4oCZdCBleHBsb2l0IHVuaW5pdGlhbGl6ZWQgc3RhY2sgdmFy aWFibGVzIGFzIGVhc2lseSBiZWNhdXNlIHRoZXkgY2Fu4oCZdCBsZWF2ZSBhIHZhbHVlIG9uIHRo ZSBzdGFjayAvIGluIGEgcmVnaXN0ZXIgYW5kIHVzZSBpdCBsYXRlciBpbiBhIG1hbm5lciB3aGlj aCB0aGUgcHJvZ3JhbSB3YXNu4oCZdCBkZXNpZ25lZCB0byBoYW5kbGUuCgpUaGlzIGN1cnJlbnRs eSBpbmNyZWFzZXMgYmluYXJ5IHNpemUgYnkgMSXigJMyJSBhbmQsIGluIHNvbWUgY2FzZXMsIGhh cyBhIHNpbWlsYXIgb3Igc21hbGxlciBwZXJmb3JtYW5jZSBpbXBhY3QuV2XigJl2ZSBwdXQgZWZm b3J0IGluIHJlZHVjaW5nIHRoaXMgaW1wYWN0LCBidXQgdGhlIGNvbXBpbGVyIGNhbiBzdGlsbCBi ZSBpbXByb3ZlZCB0byByZWR1Y2UgdGhpcyBpbXBhY3QuIENvbmNyZXRlbHksIFdlYkNvcmUgb24g eDg2LTY0IGdyb3dzIGJ5IDEuOSUgb24gYSByZWNlbnQgY2xhbmcgKHRob3VnaCB3ZSd2ZSBkb25l IG1vcmUgb3B0aW1pemF0aW9ucyBzaW5jZSB0aGlzIG1lYXN1cmVtZW50KS4gV2UgcmFuIHBlcmZv cm1hbmNlIG51bWJlcnMgb24gYmVuY2htYXJrcyB3ZSBmaW5kIGltcG9ydGFudCBhbmQgRGVhbiBz YWlkICJsb29raW5nIGF0IHRoZSByZXN1bHRzLCBJIHRoaW5rIHdlIGhhdmUgZW5vdWdoIGV2aWRl bmNlIHRvIHNheSBpdCBkb2Vzbid0IGFwcGVhciB0byBiZSBhIHJlZ3Jlc3Npb24iLgoKQXMgYSB3 b3JrYXJvdW5kIHdoZW4gcGVyZm9ybWFuY2UgaW1wYWN0IGlzIHVuYWNjZXB0YWJsZSwgdGhlIGNv bXBpbGVyIGlzbid0IG9wdGltaXppbmcgdGhpbmdzIGF3YXksIGFuZCB5b3UndmUgbWFudWFsbHkg dmFsaWRhdGVkIHRoYXQgY29kZSB3YXMgY29ycmVjdCwgeW91IGNhbiBtYXJrIHRoZSBjb3JyZXNw b25kaW5nIHN0YWNrIHZhcmlhYmxlIGFzIGZvbGxvd3M6CiAgc3RydWN0IHVuaW5pdGlhbGl6ZWRf c3RydWN0IF9fYXR0cmlidXRlKCh1bmluaXRpYWxpemVkKSk7CiAgaW50IHVuaW5pdGFsaXplZF9h cnJheVs0Ml0gX19hdHRyaWJ1dGUoKHVuaW5pdGlhbGl6ZWQpKTsKICBpbnQgdW5pbml0aWFsaXpl ZF9zY2FsYXIgX19hdHRyaWJ1dGUoKHVuaW5pdGlhbGl6ZWQpKTsKT2YgY291cnNlLCB5b3UgdGhl biBoYXZlIG5vIHByb3RlY3Rpb24gb2YgdGhhdCB2YXJpYWJsZSBmcm9tIHVuaW5pdGlhbGl6ZWQg dXNhZ2UhCgo8cmRhcjovL3Byb2JsZW0vNTAwMTgwODc+Ci0tLQogU291cmNlL1dlYkNvcmUvQ29u ZmlndXJhdGlvbnMvQmFzZS54Y2NvbmZpZyB8IDEgKwogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0 aW9uKCspCgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ29uZmlndXJhdGlvbnMvQmFzZS54 Y2NvbmZpZyBiL1NvdXJjZS9XZWJDb3JlL0NvbmZpZ3VyYXRpb25zL0Jhc2UueGNjb25maWcKaW5k ZXggMjJiYjU0Yjg2YzEuLjQ5NGI2NTllZDI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9D b25maWd1cmF0aW9ucy9CYXNlLnhjY29uZmlnCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NvbmZpZ3Vy YXRpb25zL0Jhc2UueGNjb25maWcKQEAgLTg4LDYgKzg4LDcgQEAgR0NDX1dBUk5fU0lHTl9DT01Q QVJFID0gWUVTOwogR0NDX1dBUk5fVU5JTklUSUFMSVpFRF9BVVRPUyA9IFlFUzsKIEdDQ19XQVJO X1VOVVNFRF9GVU5DVElPTiA9IFlFUzsKIEdDQ19XQVJOX1VOVVNFRF9WQVJJQUJMRSA9IFlFUzsK K0NMQU5HX1RSSVZJQUxfQVVUT19WQVJfSU5JVCA9IHBhdHRlcm47CiBXQVJOSU5HX0NGTEFHUyA9 IC1XYWxsIC1XZXh0cmEgLVdjYXN0LXF1YWwgLVdjaGFyLXN1YnNjcmlwdHMgLVdleHRyYS10b2tl bnMgLVdmb3JtYXQ9MiAtV2luaXQtc2VsZiAtV21pc3NpbmctZm9ybWF0LWF0dHJpYnV0ZSAtV21p c3Npbmctbm9yZXR1cm4gLVdwYWNrZWQgLVdwb2ludGVyLWFyaXRoIC1XcmVkdW5kYW50LWRlY2xz IC1XdW5kZWYgLVd3cml0ZS1zdHJpbmdzIC1XZXhpdC10aW1lLWRlc3RydWN0b3JzIC1XZ2xvYmFs LWNvbnN0cnVjdG9ycyAtV3RhdXRvbG9naWNhbC1jb21wYXJlIC1XaW1wbGljaXQtZmFsbHRocm91 Z2ggLVduby11bmtub3duLXdhcm5pbmctb3B0aW9uOwogCiBUQVJHRVRfTUFDX09TX1hfVkVSU0lP Tl9NQUpPUiA9ICQoVEFSR0VUX01BQ19PU19YX1ZFUlNJT05fTUFKT1IkKE1BQ09TWF9ERVBMT1lN RU5UX1RBUkdFVDpzdWZmaXg6aWRlbnRpZmllcikpOwotLSAKMi4xNy4wCgo= 367734 2019-04-18 10:45:23 -0700 2019-04-18 13:01:44 -0700 patch 0001-WebCore-auto-initialize-stack-variables.patch text/plain 6224 jfbastien RnJvbSAyZDE2MGM1YTAyNzY3NWQyMWE5MDgxNjA4ZDM0ODY4MjEzZGEyMmQzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBUaHUsIDE4IEFwciAyMDE5IDA5OjI4OjU3IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gV2ViQ29y ZTogYXV0by1pbml0aWFsaXplIHN0YWNrIHZhcmlhYmxlcwpNSU1FLVZlcnNpb246IDEuMApDb250 ZW50LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNv ZGluZzogOGJpdAoKQ2xhbmcgYWRkZWQgc3VwcG9ydCBmb3IgQyAvIEMrKyB2YXJpYWJsZSBhdXRv LWluaXRpYWxpemF0aW9uLgoKVGhlIGJ1aWxk4oCZcyBDRkxBR1MgLyBDQ0ZMQUdTIGNhbiB1c2Ug dGhlIGZvbGxvd2luZyBmbGFnOgogIC1mdHJpdmlhbC1hdXRvLXZhci1pbml0PXBhdHRlcm4KQW4g WGNvZGUgc2V0dGluZyBjYW4gYWxzbyBiZSB1c2VkLCB3aGljaCB3aWxsIGVuYWJsZSBzYWlkIGZs YWcgaWYgaXQncyBhdmFpbGFibGUgaW4gY2xhbmcuCgpWYXJpYWJsZSBhdXRvLWluaXRpYWxpemF0 aW9uIHdpbGwgYWZmZWN0IHN0YWNrIHZhcmlhYmxlcyBhcyBmb2xsb3dzOgogLSBJbml0aWFsaXpl IGFsbCBpbnRlZ2VycyBhbmQgcG9pbnRlcnMgdG8gcmVwZWF0ZWQgMHhBQSBieXRlIHBhdHRlcm4K IC0gSW5pdGlhbGl6ZSBhbGwgZmxvYXRpbmcgcG9pbnQgdmFsdWVzIHRvIOKAnG5lZ2F0aXZlIE5h TiB3aXRoIHJlcGVhdGVkIDB4RkYgcGF5bG9hZOKAnSAoaS5lLiBmbG9hdDMyIGlzIDB4RkZGRkZG RkYgYW5kIGZsb2F0NjQgaXMgMHhGRkZGRkZGRkZGRkZGRkZGKQogLSBJbml0aWFsaXplIGFnZ3Jl Z2F0ZSB0eXBlcyBpbiB0aGUgc2FtZSB3YXksIGFuZCB0aGVpciBwYWRkaW5nIChzdHJ1Y3RzLCBj bGFzc2VzLCB2ZWN0b3JzLCBhcnJheXMsIHZhcmlhYmxlLWxlbmd0aCBhcnJheXMsIHVuaW9ucykK VGhlIG9wdGltaXplciB3aWxsIHRoZW4gZ2V0IHJpZCBvZiByZWR1bmRhbnQgaW5pdGlhbGl6YXRp b25zIChpZiBpdCBkb2Vzbid0LCBwbGVhc2UgZmlsZSBidWdzIG9uIGNsYW5nKS4KClRoaXMgbWVh bnMgdGhhdCBhdHRhY2tlcnMgY2Fu4oCZdCBleHBsb2l0IHVuaW5pdGlhbGl6ZWQgc3RhY2sgdmFy aWFibGVzIGFzIGVhc2lseSBiZWNhdXNlIHRoZXkgY2Fu4oCZdCBsZWF2ZSBhIHZhbHVlIG9uIHRo ZSBzdGFjayAvIGluIGEgcmVnaXN0ZXIgYW5kIHVzZSBpdCBsYXRlciBpbiBhIG1hbm5lciB3aGlj aCB0aGUgcHJvZ3JhbSB3YXNu4oCZdCBkZXNpZ25lZCB0byBoYW5kbGUuCgpUaGlzIGN1cnJlbnRs eSBpbmNyZWFzZXMgYmluYXJ5IHNpemUgYnkgMSXigJMyJSBhbmQsIGluIHNvbWUgY2FzZXMsIGhh cyBhIHNpbWlsYXIgb3Igc21hbGxlciBwZXJmb3JtYW5jZSBpbXBhY3QuV2XigJl2ZSBwdXQgZWZm b3J0IGluIHJlZHVjaW5nIHRoaXMgaW1wYWN0LCBidXQgdGhlIGNvbXBpbGVyIGNhbiBzdGlsbCBi ZSBpbXByb3ZlZCB0byByZWR1Y2UgdGhpcyBpbXBhY3QuIENvbmNyZXRlbHksIFdlYkNvcmUgb24g eDg2LTY0IGdyb3dzIGJ5IDEuOSUgb24gYSByZWNlbnQgY2xhbmcgKHRob3VnaCB3ZSd2ZSBkb25l IG1vcmUgb3B0aW1pemF0aW9ucyBzaW5jZSB0aGlzIG1lYXN1cmVtZW50KS4gV2UgcmFuIHBlcmZv cm1hbmNlIG51bWJlcnMgb24gYmVuY2htYXJrcyB3ZSBmaW5kIGltcG9ydGFudCBhbmQgRGVhbiBz YWlkICJsb29raW5nIGF0IHRoZSByZXN1bHRzLCBJIHRoaW5rIHdlIGhhdmUgZW5vdWdoIGV2aWRl bmNlIHRvIHNheSBpdCBkb2Vzbid0IGFwcGVhciB0byBiZSBhIHJlZ3Jlc3Npb24iLgoKQXMgYSB3 b3JrYXJvdW5kIHdoZW4gcGVyZm9ybWFuY2UgaW1wYWN0IGlzIHVuYWNjZXB0YWJsZSwgdGhlIGNv bXBpbGVyIGlzbid0IG9wdGltaXppbmcgdGhpbmdzIGF3YXksIGFuZCB5b3UndmUgbWFudWFsbHkg dmFsaWRhdGVkIHRoYXQgY29kZSB3YXMgY29ycmVjdCwgeW91IGNhbiBtYXJrIHRoZSBjb3JyZXNw b25kaW5nIHN0YWNrIHZhcmlhYmxlIGFzIGZvbGxvd3M6CiAgc3RydWN0IHVuaW5pdGlhbGl6ZWRf c3RydWN0IF9fYXR0cmlidXRlKCh1bmluaXRpYWxpemVkKSk7CiAgaW50IHVuaW5pdGFsaXplZF9h cnJheVs0Ml0gX19hdHRyaWJ1dGUoKHVuaW5pdGlhbGl6ZWQpKTsKICBpbnQgdW5pbml0aWFsaXpl ZF9zY2FsYXIgX19hdHRyaWJ1dGUoKHVuaW5pdGlhbGl6ZWQpKTsKT2YgY291cnNlLCB5b3UgdGhl biBoYXZlIG5vIHByb3RlY3Rpb24gb2YgdGhhdCB2YXJpYWJsZSBmcm9tIHVuaW5pdGlhbGl6ZWQg dXNhZ2UhCgo8cmRhcjovL3Byb2JsZW0vNTAwMTgwODc+Ci0tLQogU291cmNlL1dlYkNvcmUvQ2hh bmdlTG9nICAgICAgICAgICAgICAgICAgICB8IDQ4ICsrKysrKysrKysrKysrKysrKysrKwogU291 cmNlL1dlYkNvcmUvQ29uZmlndXJhdGlvbnMvQmFzZS54Y2NvbmZpZyB8ICAxICsKIDIgZmlsZXMg Y2hhbmdlZCwgNDkgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA5MDEyMTFjOTFlZC4uMjQy MTQwMWFjMWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1MSBAQAorMjAxOS0wNC0xOCBKRiBCYXN0 aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgorCisgICAgICAgIFdlYkNvcmU6IEFkb3B0IGNsYW5n J3MgdmFyaWFibGUgYXV0by1pbml0aWFsaXphdGlvbiB3aXRoIHNlbnRpbmVsCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xOTcwNjAKKyAgICAgICAgPHJk YXI6Ly9wcm9ibGVtLzUwMDE4MDg3PgorCisgICAgICAgIENsYW5nIGFkZGVkIHN1cHBvcnQgZm9y IEMgLyBDKysgdmFyaWFibGUgYXV0by1pbml0aWFsaXphdGlvbi4KKworICAgICAgICBUaGUgYnVp bGTigJlzIENGTEFHUyAvIENDRkxBR1MgY2FuIHVzZSB0aGUgZm9sbG93aW5nIGZsYWc6CisgICAg ICAgICAgLWZ0cml2aWFsLWF1dG8tdmFyLWluaXQ9cGF0dGVybgorICAgICAgICBBbiBYY29kZSBz ZXR0aW5nIGNhbiBhbHNvIGJlIHVzZWQsIHdoaWNoIHdpbGwgZW5hYmxlIHNhaWQgZmxhZyBpZgor ICAgICAgICBpdCdzIGF2YWlsYWJsZSBpbiBjbGFuZy4KKworICAgICAgICBWYXJpYWJsZSBhdXRv LWluaXRpYWxpemF0aW9uIHdpbGwgYWZmZWN0IHN0YWNrIHZhcmlhYmxlcyBhcyBmb2xsb3dzOgor ICAgICAgICAtIEluaXRpYWxpemUgYWxsIGludGVnZXJzIGFuZCBwb2ludGVycyB0byByZXBlYXRl ZCAweEFBIGJ5dGUgcGF0dGVybgorICAgICAgICAtIEluaXRpYWxpemUgYWxsIGZsb2F0aW5nIHBv aW50IHZhbHVlcyB0byDigJxuZWdhdGl2ZSBOYU4gd2l0aAorICAgICAgICAgIHJlcGVhdGVkIDB4 RkYgcGF5bG9hZOKAnSAoaS5lLiBmbG9hdDMyIGlzIDB4RkZGRkZGRkYgYW5kIGZsb2F0NjQgaXMK KyAgICAgICAgICAweEZGRkZGRkZGRkZGRkZGRkYpCisgICAgICAgIC0gSW5pdGlhbGl6ZSBhZ2dy ZWdhdGUgdHlwZXMgaW4gdGhlIHNhbWUgd2F5LCBhbmQgdGhlaXIgcGFkZGluZworICAgICAgICBU aGUgb3B0aW1pemVyIHdpbGwgdGhlbiBnZXQgcmlkIG9mIHJlZHVuZGFudCBpbml0aWFsaXphdGlv bnMgKGlmCisgICAgICAgIGl0IGRvZXNuJ3QsIHBsZWFzZSBmaWxlIGJ1Z3Mgb24gY2xhbmcpLgor CisgICAgICAgIFRoaXMgbWVhbnMgdGhhdCBhdHRhY2tlcnMgY2Fu4oCZdCBleHBsb2l0IHVuaW5p dGlhbGl6ZWQgc3RhY2sKKyAgICAgICAgdmFyaWFibGVzIGFzIGVhc2lseSBiZWNhdXNlIHRoZXkg Y2Fu4oCZdCBsZWF2ZSBhIHZhbHVlIG9uIHRoZSBzdGFjaworICAgICAgICBvciBpbiBhIHJlZ2lz dGVyIGFuZCB1c2UgaXQgbGF0ZXIgaW4gYSBtYW5uZXIgd2hpY2ggdGhlIHByb2dyYW0KKyAgICAg ICAgd2FzbuKAmXQgZGVzaWduZWQgdG8gaGFuZGxlLgorCisgICAgICAgIFRoaXMgY3VycmVudGx5 IGluY3JlYXNlcyBiaW5hcnkgc2l6ZSBieSAxJeKAkzIlIGFuZCwgaW4gc29tZSBjYXNlcywKKyAg ICAgICAgaGFzIGEgc2ltaWxhciBvciBzbWFsbGVyIHBlcmZvcm1hbmNlIGltcGFjdC5XZeKAmXZl IHB1dCBlZmZvcnQgaW4KKyAgICAgICAgcmVkdWNpbmcgdGhpcyBpbXBhY3QsIGJ1dCB0aGUgY29t cGlsZXIgY2FuIHN0aWxsIGJlIGltcHJvdmVkIHRvCisgICAgICAgIHJlZHVjZSB0aGlzIGltcGFj dC4gQ29uY3JldGVseSwgV2ViQ29yZSBvbiB4ODYtNjQgZ3Jvd3MgYnkgMS45JSBvbgorICAgICAg ICBhIHJlY2VudCBjbGFuZyAodGhvdWdoIHdlJ3ZlIGRvbmUgbW9yZSBvcHRpbWl6YXRpb25zIHNp bmNlIHRoaXMKKyAgICAgICAgbWVhc3VyZW1lbnQpLiBXZSByYW4gcGVyZm9ybWFuY2UgbnVtYmVy cyBvbiBiZW5jaG1hcmtzIHdlIGZpbmQKKyAgICAgICAgaW1wb3J0YW50IGFuZCBEZWFuIHNhaWQg Imxvb2tpbmcgYXQgdGhlIHJlc3VsdHMsIEkgdGhpbmsgd2UgaGF2ZQorICAgICAgICBlbm91Z2gg ZXZpZGVuY2UgdG8gc2F5IGl0IGRvZXNuJ3QgYXBwZWFyIHRvIGJlIGEgcmVncmVzc2lvbiIuCisK KyAgICAgICAgQXMgYSB3b3JrYXJvdW5kIHdoZW4gcGVyZm9ybWFuY2UgaW1wYWN0IGlzIHVuYWNj ZXB0YWJsZSwgdGhlCisgICAgICAgIGNvbXBpbGVyIGlzbid0IG9wdGltaXppbmcgdGhpbmdzIGF3 YXksIGFuZCB5b3UndmUgbWFudWFsbHkKKyAgICAgICAgdmFsaWRhdGVkIHRoYXQgY29kZSB3YXMg Y29ycmVjdCwgeW91IGNhbiBtYXJrIHRoZSBjb3JyZXNwb25kaW5nCisgICAgICAgIHN0YWNrIHZh cmlhYmxlIGFzIGZvbGxvd3M6CisgICAgICAgICAgc3RydWN0IHVuaW5pdGlhbGl6ZWRfc3RydWN0 IF9fYXR0cmlidXRlKCh1bmluaXRpYWxpemVkKSk7CisgICAgICAgICAgaW50IHVuaW5pdGFsaXpl ZF9hcnJheVs0Ml0gX19hdHRyaWJ1dGUoKHVuaW5pdGlhbGl6ZWQpKTsKKyAgICAgICAgICBpbnQg dW5pbml0aWFsaXplZF9zY2FsYXIgX19hdHRyaWJ1dGUoKHVuaW5pdGlhbGl6ZWQpKTsKKyAgICAg ICAgT2YgY291cnNlLCB5b3UgdGhlbiBoYXZlIG5vIHByb3RlY3Rpb24gb2YgdGhhdCB2YXJpYWJs ZSBmcm9tCisgICAgICAgIHVuaW5pdGlhbGl6ZWQgdXNhZ2UhCisKKyAgICAgICAgKiBDb25maWd1 cmF0aW9ucy9CYXNlLnhjY29uZmlnOiBBZGQgWGNvZGUgZmxhZyBmb3IgYXV0by1pbml0CisKIDIw MTktMDMtMDYgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CiAKICAgICAg ICAgTW92ZSBSZW5kZXJPYmplY3Q6OmlzVHJhbnNwYXJlbnRPckZ1bGx5Q2xpcHBlZFJlc3BlY3Rp bmdQYXJlbnRGcmFtZXMoKSB0byBSZW5kZXJMYXllcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvQ29uZmlndXJhdGlvbnMvQmFzZS54Y2NvbmZpZyBiL1NvdXJjZS9XZWJDb3JlL0NvbmZpZ3Vy YXRpb25zL0Jhc2UueGNjb25maWcKaW5kZXggMjJiYjU0Yjg2YzEuLjQ5NGI2NTllZDI5IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Db25maWd1cmF0aW9ucy9CYXNlLnhjY29uZmlnCisrKyBi L1NvdXJjZS9XZWJDb3JlL0NvbmZpZ3VyYXRpb25zL0Jhc2UueGNjb25maWcKQEAgLTg4LDYgKzg4 LDcgQEAgR0NDX1dBUk5fU0lHTl9DT01QQVJFID0gWUVTOwogR0NDX1dBUk5fVU5JTklUSUFMSVpF RF9BVVRPUyA9IFlFUzsKIEdDQ19XQVJOX1VOVVNFRF9GVU5DVElPTiA9IFlFUzsKIEdDQ19XQVJO X1VOVVNFRF9WQVJJQUJMRSA9IFlFUzsKK0NMQU5HX1RSSVZJQUxfQVVUT19WQVJfSU5JVCA9IHBh dHRlcm47CiBXQVJOSU5HX0NGTEFHUyA9IC1XYWxsIC1XZXh0cmEgLVdjYXN0LXF1YWwgLVdjaGFy LXN1YnNjcmlwdHMgLVdleHRyYS10b2tlbnMgLVdmb3JtYXQ9MiAtV2luaXQtc2VsZiAtV21pc3Np bmctZm9ybWF0LWF0dHJpYnV0ZSAtV21pc3Npbmctbm9yZXR1cm4gLVdwYWNrZWQgLVdwb2ludGVy LWFyaXRoIC1XcmVkdW5kYW50LWRlY2xzIC1XdW5kZWYgLVd3cml0ZS1zdHJpbmdzIC1XZXhpdC10 aW1lLWRlc3RydWN0b3JzIC1XZ2xvYmFsLWNvbnN0cnVjdG9ycyAtV3RhdXRvbG9naWNhbC1jb21w YXJlIC1XaW1wbGljaXQtZmFsbHRocm91Z2ggLVduby11bmtub3duLXdhcm5pbmctb3B0aW9uOwog CiBUQVJHRVRfTUFDX09TX1hfVkVSU0lPTl9NQUpPUiA9ICQoVEFSR0VUX01BQ19PU19YX1ZFUlNJ T05fTUFKT1IkKE1BQ09TWF9ERVBMT1lNRU5UX1RBUkdFVDpzdWZmaXg6aWRlbnRpZmllcikpOwot LSAKMi4xNy4wCgo=