139854 2014-12-20 18:15:12 -0800 Simplify saturated integer add/sub 2015-05-14 21:39:30 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 benjamin benjamin andersca cmarcelo commit-queue darin kling mitz oldest_to_newest 1057293 0 benjamin 2014-12-20 18:15:12 -0800 Use the overflow builtins when available for the trivial saturated arithmetic 1057294 1 243611 benjamin 2014-12-20 18:17:20 -0800 Created attachment 243611 Patch 1057300 2 243611 darin 2014-12-20 19:50:32 -0800 Comment on attachment 243611 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=243611&action=review Not sure why the patch didn’t apply. > Source/WTF/wtf/Compiler.h:38 > +/* COMPILER_HAS_BUILTIN() - wether the compiler supports a particular builtin. */ "whether" is misspelled here Anders chose a different approach for __has_feature, a different macro for each feature. His approach can work for compilers that don’t use __has_feature or for checks that somehow need to be more complex. I suggest we follow the same pattern for __has_builtin and not add a general COMPILER_HAS_BUILTIN. > Source/WTF/wtf/SaturatedArithmetic.h:45 > + result = std::numeric_limits<int>::max() + (static_cast<uint32_t>(a) >> 31); Would be nicer to structure things this so this line of code was shared. I imagine code more like this: inline bool sadd_overflow(int32_t a, int32_t b, int32_t* result) { #if COMPILER_SUPPORTS(BUILTIN_SADD_OVERFLOW) return __builtin_sadd_overflow(a, b, &result); #else uint32_t ua = a; uint32_t ub = b; uint32_t uresult = ua + ub; *result = uresult; // Can only overflow if the signed bit of the two values match. If the signed // bit of the result and one of the values differ it did overflow. return !((ua ^ ub) >> 31) & (uresult ^ ua) >> 31; #endif } inline int32_t saturatedAddition(int32_t a, int32_b) { int32_t result; if (__builtin_sadd_overflow(a, b, &result)) result = std::numeric_limits<int>::max() + (static_cast<uint32_t>(a) >> 31); return result; } 1057309 3 benjamin 2014-12-21 00:02:24 -0800 (In reply to comment #2) > Anders chose a different approach for __has_feature, a different macro for > each feature. His approach can work for compilers that don’t use > __has_feature or for checks that somehow need to be more complex. I suggest > we follow the same pattern for __has_builtin and not add a general > COMPILER_HAS_BUILTIN. This is not completely similar. The features are standard features that a compiler supports or don't support. Builtins have different names and behavior depending on the compiler. MSVC uses completely different names for its builtins. If we really want to abstract all of that, we will need 2 macros for each builtins: one to know if the builtin is defined, and one to abstract the name between compilers. 1057334 4 darin 2014-12-21 17:23:15 -0800 (In reply to comment #3) > (In reply to comment #2) > > Anders chose a different approach for __has_feature, a different macro for > > each feature. His approach can work for compilers that don’t use > > __has_feature or for checks that somehow need to be more complex. I suggest > > we follow the same pattern for __has_builtin and not add a general > > COMPILER_HAS_BUILTIN. > > This is not completely similar. > > The features are standard features that a compiler supports or don't support. > > Builtins have different names and behavior depending on the compiler. MSVC > uses completely different names for its builtins. OK. I’m still not certain this is the right design for compiler-independent macros to guard compiler-specific built-in. I can imagine two different compilers having built-ins with the same name but different arguments or semantics, and I’m not sure how COMPILER_HAS_BUILTIN(x) would be helpful for that case. I think that COMPILER_HAS_CLANG_BUILTIN(x) might be a more honest name for this macro if we might need a different one for different sets of built-ins. 1057384 5 andersca 2014-12-22 09:10:03 -0800 (In reply to comment #4) > (In reply to comment #3) > > (In reply to comment #2) > > > Anders chose a different approach for __has_feature, a different macro for > > > each feature. His approach can work for compilers that don’t use > > > __has_feature or for checks that somehow need to be more complex. I suggest > > > we follow the same pattern for __has_builtin and not add a general > > > COMPILER_HAS_BUILTIN. > > > > This is not completely similar. > > > > The features are standard features that a compiler supports or don't support. > > > > Builtins have different names and behavior depending on the compiler. MSVC > > uses completely different names for its builtins. > > OK. I’m still not certain this is the right design for compiler-independent > macros to guard compiler-specific built-in. I can imagine two different > compilers having built-ins with the same name but different arguments or > semantics, and I’m not sure how COMPILER_HAS_BUILTIN(x) would be helpful for > that case. I think that COMPILER_HAS_CLANG_BUILTIN(x) might be a more honest > name for this macro if we might need a different one for different sets of > built-ins. I agree with Darin, other compilers are going to be different enough that we should have separate feature macros. 1057540 6 243662 benjamin 2014-12-22 21:02:27 -0800 Created attachment 243662 Patch 1057541 7 commit-queue 2014-12-22 21:03:22 -0800 Attachment 243662 did not pass style-queue: ERROR: Source/WTF/wtf/SaturatedArithmetic.h:50: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:58: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:62: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:45: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:50: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:58: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:62: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:50: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:58: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:62: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:80: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:92: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:75: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:80: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:92: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:80: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:92: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] Total errors found: 17 in 3 files If any of these errors are false positives, please file a bug against check-webkit-style. 1057549 8 243662 darin 2014-12-22 22:33:02 -0800 Comment on attachment 243662 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=243662&action=review > Source/WTF/wtf/Compiler.h:38 > +/* COMPILER_HAS_BUILTIN() - wether the compiler supports a particular builtin. */ Comment still has the old name. > Source/WTF/wtf/SaturatedArithmetic.h:54 > uint32_t result = ua + ub; Need to name the local variable something different, and also put the result into the reference passed in. Maybe: uint32_t uresult = ua + ub; result = uresult; And then use uresult below instead of result. Or maybe you can just use result directly, but not sure if that would be right for the expression below. > Source/WTF/wtf/SaturatedArithmetic.h:66 > + result = std::numeric_limits<int>::max() + (static_cast<uint32_t>(a) >> 31); It’s a little strange that we use int32_t type for the arguments, but just <int> for the template argument. > Source/WTF/wtf/SaturatedArithmetic.h:70 > +inline bool signedSubstractOverflows(int32_t a, int32_t b, int32_t& result) Typo here: "substract" with an extra "s". > Source/WTF/wtf/SaturatedArithmetic.h:84 > uint32_t result = ua - ub; Ditto. > Source/WTF/wtf/SaturatedArithmetic.h:96 > + result = std::numeric_limits<int>::max() + (static_cast<uint32_t>(a) >> 31); Ditto. 1057636 9 243687 benjamin 2014-12-23 13:06:27 -0800 Created attachment 243687 Patch 1057637 10 commit-queue 2014-12-23 13:08:18 -0800 Attachment 243687 did not pass style-queue: ERROR: Source/WTF/wtf/SaturatedArithmetic.h:50: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:55: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:59: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:63: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:45: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:50: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:55: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:59: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:63: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:50: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:55: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:59: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:63: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:81: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:86: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:94: Wrong number of spaces before statement. (expected: 8) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:76: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:81: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:86: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:94: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:81: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:86: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] ERROR: Source/WTF/wtf/SaturatedArithmetic.h:94: Wrong number of spaces before statement. (expected: 12) [whitespace/indent] [4] Total errors found: 23 in 3 files If any of these errors are false positives, please file a bug against check-webkit-style. 1057726 11 243687 darin 2014-12-23 18:01:40 -0800 Comment on attachment 243687 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=243687&action=review > Source/WTF/wtf/SaturatedArithmetic.h:48 > +#if CPU(ARM_THUMB2) > + asm("qadd %[sum], %[addend], %[augend]" > + : [sum]"=r"(result) > + : [augend]"r"(a), [addend]"r"(b) > + : /* Nothing is clobbered. */ > + ); > + return false; I don’t think this is exactly right. I think this conditional part should be in the saturatedAddition function below, not here. It’s a way to do saturated addition, not a way to do an addition and detect overflow. > Source/WTF/wtf/SaturatedArithmetic.h:55 > + result = static_cast<int32_t>(uresult); I don’t think we need a cast here, unless it’s maybe to prevent warnings with certain compilers? > Source/WTF/wtf/SaturatedArithmetic.h:59 > + return !((ua ^ ub) >> 31) & (result ^ ua) >> 31; I think this should use uresult instead of result (as you do below in signedSubtractOverflows. But if it’s OK for this to use a signed integer here, then we don’t need uresult at all. > Source/WTF/wtf/SaturatedArithmetic.h:79 > +#if CPU(ARM_THUMB2) > + asm("qsub %[difference], %[minuend], %[subtrahend]" > + : [difference]"=r"(result) > + : [minuend]"r"(a), [subtrahend]"r"(b) > + : /* Nothing is clobbered. */ > + ); > + return false; Same comment as above. > Source/WTF/wtf/SaturatedArithmetic.h:86 > + result = static_cast<int32_t>(uresult); Same comment as above. 1057792 12 benjamin 2014-12-24 18:46:34 -0800 Committed r177729: <http://trac.webkit.org/changeset/177729> 1057798 13 benjamin 2014-12-24 18:59:44 -0800 I hope I did not mess up this time :) I kept the cast for people who enable the warnings. 1057814 14 darin 2014-12-24 22:14:11 -0800 Looks like saturated subtract might is broken: result = std::numeric_limits<uint32_t>::max() + (static_cast<uint32_t>(a) >> 31); I think that should be std::numeric_limits<int32_t>::max(). Also, technically to get defined overflow behavior I think we need to cast that to uint32_t in both places it is used. But that’s just a pedantic nitpick that doesn’t really matter. 1057826 15 ap 2014-12-24 23:29:26 -0800 Yes, this broke an API test: [ RUN ] WTF.SaturatedArithmeticSubtraction /Volumes/Data/slave/yosemite-debug/build/Tools/TestWebKitAPI/Tests/WTF/SaturatedArithmeticOperations.cpp:89: Failure Value of: 2147483647 Expected: saturatedSubtraction(2147483647 - 1, -2) Which is: -1 [ FAILED ] WTF.SaturatedArithmeticSubtraction (1 ms) 1057844 16 ap 2014-12-25 10:49:28 -0800 > I think that should be std::numeric_limits<int32_t>::max(). Landed this change in <http://trac.webkit.org/r177736> after verifying that it fixes API tests locally. 1057941 17 mitz 2014-12-26 17:18:20 -0800 (In reply to comment #12) > Committed r177729: <http://trac.webkit.org/changeset/177729> I reverted that use of __builtin_s{add,sub}_overflow in <http://trac.webkit.org/r177753>, because it was causing a compiler used at Apple to crash. 1095026 18 mitz 2015-05-14 21:39:30 -0700 (In reply to comment #17) > (In reply to comment #12) > > Committed r177729: <http://trac.webkit.org/changeset/177729> > > I reverted that use of __builtin_s{add,sub}_overflow in > <http://trac.webkit.org/r177753>, because it was causing a compiler used at > Apple to crash. I reverted the reversion in <http://trac.webkit.org/r184369>. 243611 2014-12-20 18:17:20 -0800 2014-12-22 21:02:25 -0800 Patch bug-139854-20141220181720.patch text/plain 3570 benjamin U3VidmVyc2lvbiBSZXZpc2lvbjogMTc3NjIyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDllYjc3M2NlMGNiOTIyZGQwNTI2Yjcy NGYwZWMwYTNkYzdiNGY0MTUuLjBiMjI1MmQ3OTdjMzI4OTI4N2Y4ZDUzMWRjNmE0NjhmYTAwMTEy NDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTQtMTItMjAgIEJlbmphbWluIFBvdWxhaW4gIDxi ZW5qYW1pbkB3ZWJraXQub3JnPgorCisgICAgICAgIFVzZSB0aGUgb3ZlcmZsb3cgYnVpbHRpbnMg d2hlbiBhdmFpbGFibGUgZm9yIHRoZSB0cml2aWFsIHNhdHVyYXRlZCBhcml0aG1ldGljCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzk4NTQKKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHd0Zi9Db21waWxl ci5oOgorICAgICAgICBNYWtlIGEgd3JhcHBlciBmb3IgX19oYXNfYnVpbHRpbiBmb3IgY29tcGls ZXJzIHRoYXQgZG8gbm90IHN1cHBvcnQgaXQuCisKKyAgICAgICAgKiB3dGYvU2F0dXJhdGVkQXJp dGhtZXRpYy5oOgorICAgICAgICAoc2F0dXJhdGVkQWRkaXRpb24pOgorICAgICAgICAoc2F0dXJh dGVkU3VidHJhY3Rpb24pOgorICAgICAgICBVc2UgdGhlIGJ1aWx0aW5zIHdoZW4gcG9zc2libGUg aW5zdGVhZCBvZiByZWludmVudGluZyB0aGUgd2hlZWwuCisKIDIwMTQtMTItMjAgIEVyaWMgQ2Fy bHNvbiAgPGVyaWMuY2FybHNvbkBhcHBsZS5jb20+CiAKICAgICAgICAgW2lPU10gYWRkIG9wdGlt aXplZCBmdWxsc2NyZWVuIEFQSQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvQ29tcGlsZXIu aCBiL1NvdXJjZS9XVEYvd3RmL0NvbXBpbGVyLmgKaW5kZXggMmIxYTFhMDI2MWZkMzc0Y2M3NTEy YjYyNDBkNjMzOWQwZGZhMDY1Ny4uODY5MTNkYmRkMWVhZjllYWJmZTQ0YWVmNzk1YTI2YzdkNGNi MjE4YyAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvQ29tcGlsZXIuaAorKysgYi9Tb3VyY2Uv V1RGL3d0Zi9Db21waWxlci5oCkBAIC0zNSw2ICszNSwxMyBAQAogLyogQ09NUElMRVJfUVVJUkso KSAtIHdoZXRoZXIgdGhlIGNvbXBpbGVyIGJlaW5nIHVzZWQgdG8gYnVpbGQgdGhlIHByb2plY3Qg cmVxdWlyZXMgYSBnaXZlbiBxdWlyay4gKi8KICNkZWZpbmUgQ09NUElMRVJfUVVJUksoV1RGX0NP TVBJTEVSX1FVSVJLKSAoZGVmaW5lZCBXVEZfQ09NUElMRVJfUVVJUktfIyNXVEZfQ09NUElMRVJf UVVJUksgICYmIFdURl9DT01QSUxFUl9RVUlSS18jI1dURl9DT01QSUxFUl9RVUlSSykKIAorLyog Q09NUElMRVJfSEFTX0JVSUxUSU4oKSAtIHdldGhlciB0aGUgY29tcGlsZXIgc3VwcG9ydHMgYSBw YXJ0aWN1bGFyIGJ1aWx0aW4uICovCisjaWZkZWYgX19oYXNfYnVpbHRpbgorI2RlZmluZSBDT01Q SUxFUl9IQVNfQlVJTFRJTih4KSBfX2hhc19idWlsdGluKHgpCisjZWxzZQorI2RlZmluZSBDT01Q SUxFUl9IQVNfQlVJTFRJTih4KSAwCisjZW5kaWYKKwogLyogPT09PSBDT01QSUxFUigpIC0gcHJp bWFyeSBkZXRlY3Rpb24gb2YgdGhlIGNvbXBpbGVyIGJlaW5nIHVzZWQgdG8gYnVpbGQgdGhlIHBy b2plY3QsIGluIGFscGhhYmV0aWNhbCBvcmRlciA9PT09ICovCiAKIC8qIENPTVBJTEVSKENMQU5H KSAtIENsYW5nICAqLwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvU2F0dXJhdGVkQXJpdGht ZXRpYy5oIGIvU291cmNlL1dURi93dGYvU2F0dXJhdGVkQXJpdGhtZXRpYy5oCmluZGV4IGNmOWU4 ZTE3ZWZiNTdkYjI2Yjc4YmJmNGIxYWUwM2I5ODhiNGIzYzYuLjViZGZjNTI0MzE5ZDZhYTRjNzAx MDk1M2Y0MWU1NTQ0MTAyYjdhMTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1NhdHVyYXRl ZEFyaXRobWV0aWMuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9TYXR1cmF0ZWRBcml0aG1ldGljLmgK QEAgLTEsNSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChjKSAyMDEyLCBHb29nbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKQEAg LTMxLDEyICszMiwxOSBAQAogI2lmbmRlZiBTYXR1cmF0ZWRBcml0aG1ldGljX2gKICNkZWZpbmUg U2F0dXJhdGVkQXJpdGhtZXRpY19oCiAKKyNpbmNsdWRlICJDb21waWxlci5oIgogI2luY2x1ZGUg PGxpbWl0cz4KICNpbmNsdWRlIDxzdGRpbnQuaD4KICNpbmNsdWRlIDxzdGRsaWIuaD4KIAogaW5s aW5lIGludDMyX3Qgc2F0dXJhdGVkQWRkaXRpb24oaW50MzJfdCBhLCBpbnQzMl90IGIpCiB7Cisj aWYgQ09NUElMRVJfSEFTX0JVSUxUSU4oX19idWlsdGluX3NhZGRfb3ZlcmZsb3cpCisgICAgaW50 MzJfdCByZXN1bHQ7CisgICAgaWYgKF9fYnVpbHRpbl9zYWRkX292ZXJmbG93KGEsIGIsICZyZXN1 bHQpKQorICAgICAgICByZXN1bHQgPSBzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1heCgpICsg KHN0YXRpY19jYXN0PHVpbnQzMl90PihhKSA+PiAzMSk7CisgICAgcmV0dXJuIHJlc3VsdDsKKyNl bHNlCiAgICAgdWludDMyX3QgdWEgPSBhOwogICAgIHVpbnQzMl90IHViID0gYjsKICAgICB1aW50 MzJfdCByZXN1bHQgPSB1YSArIHViOwpAQCAtNDcsMTAgKzU1LDE3IEBAIGlubGluZSBpbnQzMl90 IHNhdHVyYXRlZEFkZGl0aW9uKGludDMyX3QgYSwgaW50MzJfdCBiKQogICAgICAgICByZXN1bHQg PSBzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1heCgpICsgKHVhID4+IDMxKTsKIAogICAgIHJl dHVybiByZXN1bHQ7CisjZW5kaWYKIH0KIAogaW5saW5lIGludDMyX3Qgc2F0dXJhdGVkU3VidHJh Y3Rpb24oaW50MzJfdCBhLCBpbnQzMl90IGIpCiB7CisjaWYgQ09NUElMRVJfSEFTX0JVSUxUSU4o X19idWlsdGluX3NzdWJfb3ZlcmZsb3cpCisgICAgaW50MzJfdCByZXN1bHQ7CisgICAgaWYgKF9f YnVpbHRpbl9zc3ViX292ZXJmbG93KGEsIGIsICZyZXN1bHQpKQorICAgICAgICByZXN1bHQgPSBz dGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1heCgpICsgKHN0YXRpY19jYXN0PHVpbnQzMl90Pihh KSA+PiAzMSk7CisgICAgcmV0dXJuIHJlc3VsdDsKKyNlbHNlCiAgICAgdWludDMyX3QgdWEgPSBh OwogICAgIHVpbnQzMl90IHViID0gYjsKICAgICB1aW50MzJfdCByZXN1bHQgPSB1YSAtIHViOwpA QCAtNjEsNiArNzYsNyBAQCBpbmxpbmUgaW50MzJfdCBzYXR1cmF0ZWRTdWJ0cmFjdGlvbihpbnQz Ml90IGEsIGludDMyX3QgYikKICAgICAgICAgcmVzdWx0ID0gc3RkOjpudW1lcmljX2xpbWl0czxp bnQ+OjptYXgoKSArICh1YSA+PiAzMSk7CiAKICAgICByZXR1cm4gcmVzdWx0OworI2VuZGlmCiB9 CiAKICNlbmRpZiAvLyBTYXR1cmF0ZWRBcml0aG1ldGljX2gK 243662 2014-12-22 21:02:27 -0800 2014-12-23 13:06:20 -0800 Patch bug-139854-20141222210228.patch text/plain 4661 benjamin U3VidmVyc2lvbiBSZXZpc2lvbjogMTc3NjY0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDllYjc3M2NlMGNiOTIyZGQwNTI2Yjcy NGYwZWMwYTNkYzdiNGY0MTUuLjk2ZTk5ZDA1ZjU5ZjM2MWFkY2VjZjdmZjdiY2I5ODljNGQ5Nzgz MWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTQtMTItMjIgIEJlbmphbWluIFBvdWxhaW4gIDxi ZW5qYW1pbkB3ZWJraXQub3JnPgorCisgICAgICAgIFNpbXBsaWZ5IHNhdHVyYXRlZCBpbnRlZ2Vy IGFkZC9zdWIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTEzOTg1NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg ICogd3RmL0NvbXBpbGVyLmg6CisgICAgICAgIE1ha2UgYSB3cmFwcGVyIGZvciBfX2hhc19idWls dGluIGZvciBjb21waWxlcnMgdGhhdCBkbyBub3Qgc3VwcG9ydCBpdC4KKworICAgICAgICAqIHd0 Zi9TYXR1cmF0ZWRBcml0aG1ldGljLmg6CisgICAgICAgIChzYXR1cmF0ZWRBZGRpdGlvbik6Cisg ICAgICAgIChzYXR1cmF0ZWRTdWJ0cmFjdGlvbik6CisgICAgICAgIFVzZSB0aGUgYnVpbHRpbnMg d2hlbiBwb3NzaWJsZSBpbnN0ZWFkIG9mIHJlaW52ZW50aW5nIHRoZSB3aGVlbC4KKwogMjAxNC0x Mi0yMCAgRXJpYyBDYXJsc29uICA8ZXJpYy5jYXJsc29uQGFwcGxlLmNvbT4KIAogICAgICAgICBb aU9TXSBhZGQgb3B0aW1pemVkIGZ1bGxzY3JlZW4gQVBJCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RG L3d0Zi9Db21waWxlci5oIGIvU291cmNlL1dURi93dGYvQ29tcGlsZXIuaAppbmRleCAyYjFhMWEw MjYxZmQzNzRjYzc1MTJiNjI0MGQ2MzM5ZDBkZmEwNjU3Li5jZGFjZmViZTkwYjg0ZDRiZjRmMGMz M2Y5YWRiNWQxMGMyNDlhOTZlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9Db21waWxlci5o CisrKyBiL1NvdXJjZS9XVEYvd3RmL0NvbXBpbGVyLmgKQEAgLTM1LDYgKzM1LDEzIEBACiAvKiBD T01QSUxFUl9RVUlSSygpIC0gd2hldGhlciB0aGUgY29tcGlsZXIgYmVpbmcgdXNlZCB0byBidWls ZCB0aGUgcHJvamVjdCByZXF1aXJlcyBhIGdpdmVuIHF1aXJrLiAqLwogI2RlZmluZSBDT01QSUxF Ul9RVUlSSyhXVEZfQ09NUElMRVJfUVVJUkspIChkZWZpbmVkIFdURl9DT01QSUxFUl9RVUlSS18j I1dURl9DT01QSUxFUl9RVUlSSyAgJiYgV1RGX0NPTVBJTEVSX1FVSVJLXyMjV1RGX0NPTVBJTEVS X1FVSVJLKQogCisvKiBDT01QSUxFUl9IQVNfQlVJTFRJTigpIC0gd2V0aGVyIHRoZSBjb21waWxl ciBzdXBwb3J0cyBhIHBhcnRpY3VsYXIgYnVpbHRpbi4gKi8KKyNpZmRlZiBfX2hhc19idWlsdGlu CisjZGVmaW5lIENPTVBJTEVSX0hBU19DTEFOR19CVUlMVElOKHgpIF9faGFzX2J1aWx0aW4oeCkK KyNlbHNlCisjZGVmaW5lIENPTVBJTEVSX0hBU19DTEFOR19CVUlMVElOKHgpIDAKKyNlbmRpZgor CiAvKiA9PT09IENPTVBJTEVSKCkgLSBwcmltYXJ5IGRldGVjdGlvbiBvZiB0aGUgY29tcGlsZXIg YmVpbmcgdXNlZCB0byBidWlsZCB0aGUgcHJvamVjdCwgaW4gYWxwaGFiZXRpY2FsIG9yZGVyID09 PT0gKi8KIAogLyogQ09NUElMRVIoQ0xBTkcpIC0gQ2xhbmcgICovCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV1RGL3d0Zi9TYXR1cmF0ZWRBcml0aG1ldGljLmggYi9Tb3VyY2UvV1RGL3d0Zi9TYXR1cmF0 ZWRBcml0aG1ldGljLmgKaW5kZXggY2Y5ZThlMTdlZmI1N2RiMjZiNzhiYmY0YjFhZTAzYjk4OGI0 YjNjNi4uYjQxYjQyMDg3OWU2MzU0OGM1MDM2Y2FkMGVhZWE5OTEzMjZiNzNlOCAxMDA2NDQKLS0t IGEvU291cmNlL1dURi93dGYvU2F0dXJhdGVkQXJpdGhtZXRpYy5oCisrKyBiL1NvdXJjZS9XVEYv d3RmL1NhdHVyYXRlZEFyaXRobWV0aWMuaApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmln aHQgKGMpIDIwMTIsIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmln aHQgKEMpIDIwMTQgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zIGFyZQpAQCAtMzEsMzUgKzMyLDY4IEBACiAjaWZuZGVmIFNhdHVy YXRlZEFyaXRobWV0aWNfaAogI2RlZmluZSBTYXR1cmF0ZWRBcml0aG1ldGljX2gKIAorI2luY2x1 ZGUgIkNvbXBpbGVyLmgiCiAjaW5jbHVkZSA8bGltaXRzPgogI2luY2x1ZGUgPHN0ZGludC5oPgog I2luY2x1ZGUgPHN0ZGxpYi5oPgogCi1pbmxpbmUgaW50MzJfdCBzYXR1cmF0ZWRBZGRpdGlvbihp bnQzMl90IGEsIGludDMyX3QgYikKK2lubGluZSBib29sIHNpZ25lZEFkZE92ZXJmbG93cyhpbnQz Ml90IGEsIGludDMyX3QgYiwgaW50MzJfdCYgcmVzdWx0KQogeworI2lmIENQVShBUk1fVEhVTUIy KQorICAgIGFzbSgicWFkZCAlW3N1bV0sICVbYWRkZW5kXSwgJVthdWdlbmRdIgorICAgICAgICA6 IFtzdW1dIj1yIihyZXN1bHQpCisgICAgICAgIDogW2F1Z2VuZF0iciIoYSksIFthZGRlbmRdInIi KGIpCisgICAgICAgIDogLyogTm90aGluZyBpcyBjbG9iYmVyZWQuICovCisgICAgKTsKKyAgICBy ZXR1cm4gZmFsc2U7CisjZWxpZiBDT01QSUxFUl9IQVNfQ0xBTkdfQlVJTFRJTihfX2J1aWx0aW5f c2FkZF9vdmVyZmxvdykKKyAgICByZXR1cm4gX19idWlsdGluX3NhZGRfb3ZlcmZsb3coYSwgYiwg JnJlc3VsdCk7CisjZWxzZQogICAgIHVpbnQzMl90IHVhID0gYTsKICAgICB1aW50MzJfdCB1YiA9 IGI7CiAgICAgdWludDMyX3QgcmVzdWx0ID0gdWEgKyB1YjsKIAogICAgIC8vIENhbiBvbmx5IG92 ZXJmbG93IGlmIHRoZSBzaWduZWQgYml0IG9mIHRoZSB0d28gdmFsdWVzIG1hdGNoLiBJZiB0aGUg c2lnbmVkCiAgICAgLy8gYml0IG9mIHRoZSByZXN1bHQgYW5kIG9uZSBvZiB0aGUgdmFsdWVzIGRp ZmZlciBpdCBkaWQgb3ZlcmZsb3cuCi0gICAgaWYgKCEoKHVhIF4gdWIpID4+IDMxKSAmIChyZXN1 bHQgXiB1YSkgPj4gMzEpCi0gICAgICAgIHJlc3VsdCA9IHN0ZDo6bnVtZXJpY19saW1pdHM8aW50 Pjo6bWF4KCkgKyAodWEgPj4gMzEpOworICAgIHJldHVybiAhKCh1YSBeIHViKSA+PiAzMSkgJiAo cmVzdWx0IF4gdWEpID4+IDMxOworI2VuZGlmCit9CiAKK2lubGluZSBpbnQzMl90IHNhdHVyYXRl ZEFkZGl0aW9uKGludDMyX3QgYSwgaW50MzJfdCBiKQoreworICAgIGludDMyX3QgcmVzdWx0Owor ICAgIGlmIChzaWduZWRBZGRPdmVyZmxvd3MoYSwgYiwgcmVzdWx0KSkKKyAgICAgICAgcmVzdWx0 ID0gc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+OjptYXgoKSArIChzdGF0aWNfY2FzdDx1aW50MzJf dD4oYSkgPj4gMzEpOwogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKLWlubGluZSBpbnQzMl90IHNh dHVyYXRlZFN1YnRyYWN0aW9uKGludDMyX3QgYSwgaW50MzJfdCBiKQoraW5saW5lIGJvb2wgc2ln bmVkU3Vic3RyYWN0T3ZlcmZsb3dzKGludDMyX3QgYSwgaW50MzJfdCBiLCBpbnQzMl90JiByZXN1 bHQpCiB7CisjaWYgQ1BVKEFSTV9USFVNQjIpCisgICAgYXNtKCJxc3ViICVbZGlmZmVyZW5jZV0s ICVbbWludWVuZF0sICVbc3VidHJhaGVuZF0iCisgICAgICAgIDogW2RpZmZlcmVuY2VdIj1yIihy ZXN1bHQpCisgICAgICAgIDogW21pbnVlbmRdInIiKGEpLCBbc3VidHJhaGVuZF0iciIoYikKKyAg ICAgICAgOiAvKiBOb3RoaW5nIGlzIGNsb2JiZXJlZC4gKi8KKyAgICAgICAgKTsKKyAgICByZXR1 cm4gZmFsc2U7CisjZWxpZiBDT01QSUxFUl9IQVNfQ0xBTkdfQlVJTFRJTihfX2J1aWx0aW5fc3N1 Yl9vdmVyZmxvdykKKyAgICByZXR1cm4gX19idWlsdGluX3NzdWJfb3ZlcmZsb3coYSwgYiwgJnJl c3VsdCk7CisjZWxzZQogICAgIHVpbnQzMl90IHVhID0gYTsKICAgICB1aW50MzJfdCB1YiA9IGI7 CiAgICAgdWludDMyX3QgcmVzdWx0ID0gdWEgLSB1YjsKIAogICAgIC8vIENhbiBvbmx5IG92ZXJm bG93IGlmIHRoZSBzaWduZWQgYml0IG9mIHRoZSB0d28gdmFsdWVzIGRvIG5vdCBtYXRjaC4gSWYg dGhlCiAgICAgLy8gc2lnbmVkIGJpdCBvZiB0aGUgcmVzdWx0IGFuZCB0aGUgZmlyc3QgdmFsdWUg ZGlmZmVyIGl0IGRpZCBvdmVyZmxvdy4KLSAgICBpZiAoKHVhIF4gdWIpID4+IDMxICYgKHJlc3Vs dCBeIHVhKSA+PiAzMSkKLSAgICAgICAgcmVzdWx0ID0gc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+ OjptYXgoKSArICh1YSA+PiAzMSk7CisgICAgcmV0dXJuICh1YSBeIHViKSA+PiAzMSAmIChyZXN1 bHQgXiB1YSkgPj4gMzE7CisjZW5kaWYKK30KIAoraW5saW5lIGludDMyX3Qgc2F0dXJhdGVkU3Vi dHJhY3Rpb24oaW50MzJfdCBhLCBpbnQzMl90IGIpCit7CisgICAgaW50MzJfdCByZXN1bHQ7Cisg ICAgaWYgKHNpZ25lZFN1YnN0cmFjdE92ZXJmbG93cyhhLCBiLCByZXN1bHQpKQorICAgICAgICBy ZXN1bHQgPSBzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1heCgpICsgKHN0YXRpY19jYXN0PHVp bnQzMl90PihhKSA+PiAzMSk7CiAgICAgcmV0dXJuIHJlc3VsdDsKIH0KIAo= 243687 2014-12-23 13:06:27 -0800 2014-12-23 18:01:40 -0800 Patch bug-139854-20141223130627.patch text/plain 4893 benjamin U3VidmVyc2lvbiBSZXZpc2lvbjogMTc3NjY0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDllYjc3M2NlMGNiOTIyZGQwNTI2Yjcy NGYwZWMwYTNkYzdiNGY0MTUuLjI1OTU3MzA4MmJlM2IzYWRjYzhiNDAwOTczZmM4YTkyOGUxZDZi YjcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTQtMTItMjIgIEJlbmphbWluIFBvdWxhaW4gIDxi ZW5qYW1pbkB3ZWJraXQub3JnPgorCisgICAgICAgIFNpbXBsaWZ5IHNhdHVyYXRlZCBpbnRlZ2Vy IGFkZC9zdWIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTEzOTg1NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg ICogd3RmL0NvbXBpbGVyLmg6CisgICAgICAgIE1ha2UgYSB3cmFwcGVyIGZvciBfX2hhc19idWls dGluIGZvciBjb21waWxlcnMgdGhhdCBkbyBub3Qgc3VwcG9ydCBpdC4KKworICAgICAgICAqIHd0 Zi9TYXR1cmF0ZWRBcml0aG1ldGljLmg6CisgICAgICAgIChzYXR1cmF0ZWRBZGRpdGlvbik6Cisg ICAgICAgIChzYXR1cmF0ZWRTdWJ0cmFjdGlvbik6CisgICAgICAgIFVzZSB0aGUgYnVpbHRpbnMg d2hlbiBwb3NzaWJsZSBpbnN0ZWFkIG9mIHJlaW52ZW50aW5nIHRoZSB3aGVlbC4KKyAgICAgICAg T24gQVJNdjcsIHVzZSB0aGUgc2F0dXJhdGVkIG1hdGggaW5zdHJ1Y3Rpb25zLgorCiAyMDE0LTEy LTIwICBFcmljIENhcmxzb24gIDxlcmljLmNhcmxzb25AYXBwbGUuY29tPgogCiAgICAgICAgIFtp T1NdIGFkZCBvcHRpbWl6ZWQgZnVsbHNjcmVlbiBBUEkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYv d3RmL0NvbXBpbGVyLmggYi9Tb3VyY2UvV1RGL3d0Zi9Db21waWxlci5oCmluZGV4IDJiMWExYTAy NjFmZDM3NGNjNzUxMmI2MjQwZDYzMzlkMGRmYTA2NTcuLjM3Zjc4YTQ3ZjZhNWQxZGYxNTY2NTVl MjA4MThkNmQ5ZDk0M2ZkNGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL0NvbXBpbGVyLmgK KysrIGIvU291cmNlL1dURi93dGYvQ29tcGlsZXIuaApAQCAtMzUsNiArMzUsMTMgQEAKIC8qIENP TVBJTEVSX1FVSVJLKCkgLSB3aGV0aGVyIHRoZSBjb21waWxlciBiZWluZyB1c2VkIHRvIGJ1aWxk IHRoZSBwcm9qZWN0IHJlcXVpcmVzIGEgZ2l2ZW4gcXVpcmsuICovCiAjZGVmaW5lIENPTVBJTEVS X1FVSVJLKFdURl9DT01QSUxFUl9RVUlSSykgKGRlZmluZWQgV1RGX0NPTVBJTEVSX1FVSVJLXyMj V1RGX0NPTVBJTEVSX1FVSVJLICAmJiBXVEZfQ09NUElMRVJfUVVJUktfIyNXVEZfQ09NUElMRVJf UVVJUkspCiAKKy8qIENPTVBJTEVSX0hBU19DTEFOR19CVUlMVElOKCkgLSB3ZXRoZXIgdGhlIGNv bXBpbGVyIHN1cHBvcnRzIGEgcGFydGljdWxhciBjbGFuZyBidWlsdGluLiAqLworI2lmZGVmIF9f aGFzX2J1aWx0aW4KKyNkZWZpbmUgQ09NUElMRVJfSEFTX0NMQU5HX0JVSUxUSU4oeCkgX19oYXNf YnVpbHRpbih4KQorI2Vsc2UKKyNkZWZpbmUgQ09NUElMRVJfSEFTX0NMQU5HX0JVSUxUSU4oeCkg MAorI2VuZGlmCisKIC8qID09PT0gQ09NUElMRVIoKSAtIHByaW1hcnkgZGV0ZWN0aW9uIG9mIHRo ZSBjb21waWxlciBiZWluZyB1c2VkIHRvIGJ1aWxkIHRoZSBwcm9qZWN0LCBpbiBhbHBoYWJldGlj YWwgb3JkZXIgPT09PSAqLwogCiAvKiBDT01QSUxFUihDTEFORykgLSBDbGFuZyAgKi8KZGlmZiAt LWdpdCBhL1NvdXJjZS9XVEYvd3RmL1NhdHVyYXRlZEFyaXRobWV0aWMuaCBiL1NvdXJjZS9XVEYv d3RmL1NhdHVyYXRlZEFyaXRobWV0aWMuaAppbmRleCBjZjllOGUxN2VmYjU3ZGIyNmI3OGJiZjRi MWFlMDNiOTg4YjRiM2M2Li5iMmUzODRmMWUzYTVkYWM2MGZjYjBkZDA0ZmZkMTk0OGE3Y2E0ZDQw IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9TYXR1cmF0ZWRBcml0aG1ldGljLmgKKysrIGIv U291cmNlL1dURi93dGYvU2F0dXJhdGVkQXJpdGhtZXRpYy5oCkBAIC0xLDUgKzEsNiBAQAogLyoK ICAqIENvcHlyaWdodCAoYykgMjAxMiwgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqIENvcHlyaWdodCAoQykgMjAxNCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAg KgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCkBAIC0zMSwzNSArMzIsNzAgQEAKICNp Zm5kZWYgU2F0dXJhdGVkQXJpdGhtZXRpY19oCiAjZGVmaW5lIFNhdHVyYXRlZEFyaXRobWV0aWNf aAogCisjaW5jbHVkZSAiQ29tcGlsZXIuaCIKICNpbmNsdWRlIDxsaW1pdHM+CiAjaW5jbHVkZSA8 c3RkaW50Lmg+CiAjaW5jbHVkZSA8c3RkbGliLmg+CiAKLWlubGluZSBpbnQzMl90IHNhdHVyYXRl ZEFkZGl0aW9uKGludDMyX3QgYSwgaW50MzJfdCBiKQoraW5saW5lIGJvb2wgc2lnbmVkQWRkT3Zl cmZsb3dzKGludDMyX3QgYSwgaW50MzJfdCBiLCBpbnQzMl90JiByZXN1bHQpCiB7CisjaWYgQ1BV KEFSTV9USFVNQjIpCisgICAgYXNtKCJxYWRkICVbc3VtXSwgJVthZGRlbmRdLCAlW2F1Z2VuZF0i CisgICAgICAgIDogW3N1bV0iPXIiKHJlc3VsdCkKKyAgICAgICAgOiBbYXVnZW5kXSJyIihhKSwg W2FkZGVuZF0iciIoYikKKyAgICAgICAgOiAvKiBOb3RoaW5nIGlzIGNsb2JiZXJlZC4gKi8KKyAg ICApOworICAgIHJldHVybiBmYWxzZTsKKyNlbGlmIENPTVBJTEVSX0hBU19DTEFOR19CVUlMVElO KF9fYnVpbHRpbl9zYWRkX292ZXJmbG93KQorICAgIHJldHVybiBfX2J1aWx0aW5fc2FkZF9vdmVy ZmxvdyhhLCBiLCAmcmVzdWx0KTsKKyNlbHNlCiAgICAgdWludDMyX3QgdWEgPSBhOwogICAgIHVp bnQzMl90IHViID0gYjsKLSAgICB1aW50MzJfdCByZXN1bHQgPSB1YSArIHViOworICAgIHVpbnQz Ml90IHVyZXN1bHQgPSB1YSArIHViOworICAgIHJlc3VsdCA9IHN0YXRpY19jYXN0PGludDMyX3Q+ KHVyZXN1bHQpOwogCiAgICAgLy8gQ2FuIG9ubHkgb3ZlcmZsb3cgaWYgdGhlIHNpZ25lZCBiaXQg b2YgdGhlIHR3byB2YWx1ZXMgbWF0Y2guIElmIHRoZSBzaWduZWQKICAgICAvLyBiaXQgb2YgdGhl IHJlc3VsdCBhbmQgb25lIG9mIHRoZSB2YWx1ZXMgZGlmZmVyIGl0IGRpZCBvdmVyZmxvdy4KLSAg ICBpZiAoISgodWEgXiB1YikgPj4gMzEpICYgKHJlc3VsdCBeIHVhKSA+PiAzMSkKLSAgICAgICAg cmVzdWx0ID0gc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+OjptYXgoKSArICh1YSA+PiAzMSk7Cisg ICAgcmV0dXJuICEoKHVhIF4gdWIpID4+IDMxKSAmIChyZXN1bHQgXiB1YSkgPj4gMzE7CisjZW5k aWYKK30KIAoraW5saW5lIGludDMyX3Qgc2F0dXJhdGVkQWRkaXRpb24oaW50MzJfdCBhLCBpbnQz Ml90IGIpCit7CisgICAgaW50MzJfdCByZXN1bHQ7CisgICAgaWYgKHNpZ25lZEFkZE92ZXJmbG93 cyhhLCBiLCByZXN1bHQpKQorICAgICAgICByZXN1bHQgPSBzdGQ6Om51bWVyaWNfbGltaXRzPGlu dDMyX3Q+OjptYXgoKSArIChzdGF0aWNfY2FzdDx1aW50MzJfdD4oYSkgPj4gMzEpOwogICAgIHJl dHVybiByZXN1bHQ7CiB9CiAKLWlubGluZSBpbnQzMl90IHNhdHVyYXRlZFN1YnRyYWN0aW9uKGlu dDMyX3QgYSwgaW50MzJfdCBiKQoraW5saW5lIGJvb2wgc2lnbmVkU3VidHJhY3RPdmVyZmxvd3Mo aW50MzJfdCBhLCBpbnQzMl90IGIsIGludDMyX3QmIHJlc3VsdCkKIHsKKyNpZiBDUFUoQVJNX1RI VU1CMikKKyAgICBhc20oInFzdWIgJVtkaWZmZXJlbmNlXSwgJVttaW51ZW5kXSwgJVtzdWJ0cmFo ZW5kXSIKKyAgICAgICAgOiBbZGlmZmVyZW5jZV0iPXIiKHJlc3VsdCkKKyAgICAgICAgOiBbbWlu dWVuZF0iciIoYSksIFtzdWJ0cmFoZW5kXSJyIihiKQorICAgICAgICA6IC8qIE5vdGhpbmcgaXMg Y2xvYmJlcmVkLiAqLworICAgICAgICApOworICAgIHJldHVybiBmYWxzZTsKKyNlbGlmIENPTVBJ TEVSX0hBU19DTEFOR19CVUlMVElOKF9fYnVpbHRpbl9zc3ViX292ZXJmbG93KQorICAgIHJldHVy biBfX2J1aWx0aW5fc3N1Yl9vdmVyZmxvdyhhLCBiLCAmcmVzdWx0KTsKKyNlbHNlCiAgICAgdWlu dDMyX3QgdWEgPSBhOwogICAgIHVpbnQzMl90IHViID0gYjsKLSAgICB1aW50MzJfdCByZXN1bHQg PSB1YSAtIHViOworICAgIHVpbnQzMl90IHVyZXN1bHQgPSB1YSAtIHViOworICAgIHJlc3VsdCA9 IHN0YXRpY19jYXN0PGludDMyX3Q+KHVyZXN1bHQpOwogCiAgICAgLy8gQ2FuIG9ubHkgb3ZlcmZs b3cgaWYgdGhlIHNpZ25lZCBiaXQgb2YgdGhlIHR3byB2YWx1ZXMgZG8gbm90IG1hdGNoLiBJZiB0 aGUKICAgICAvLyBzaWduZWQgYml0IG9mIHRoZSByZXN1bHQgYW5kIHRoZSBmaXJzdCB2YWx1ZSBk aWZmZXIgaXQgZGlkIG92ZXJmbG93LgotICAgIGlmICgodWEgXiB1YikgPj4gMzEgJiAocmVzdWx0 IF4gdWEpID4+IDMxKQotICAgICAgICByZXN1bHQgPSBzdGQ6Om51bWVyaWNfbGltaXRzPGludD46 Om1heCgpICsgKHVhID4+IDMxKTsKKyAgICByZXR1cm4gKHVhIF4gdWIpID4+IDMxICYgKHVyZXN1 bHQgXiB1YSkgPj4gMzE7CisjZW5kaWYKK30KIAoraW5saW5lIGludDMyX3Qgc2F0dXJhdGVkU3Vi dHJhY3Rpb24oaW50MzJfdCBhLCBpbnQzMl90IGIpCit7CisgICAgaW50MzJfdCByZXN1bHQ7Cisg ICAgaWYgKHNpZ25lZFN1YnRyYWN0T3ZlcmZsb3dzKGEsIGIsIHJlc3VsdCkpCisgICAgICAgIHJl c3VsdCA9IHN0ZDo6bnVtZXJpY19saW1pdHM8dWludDMyX3Q+OjptYXgoKSArIChzdGF0aWNfY2Fz dDx1aW50MzJfdD4oYSkgPj4gMzEpOwogICAgIHJldHVybiByZXN1bHQ7CiB9CiAK