107406 2013-01-20 17:48:59 -0800 Collapse PLATFORM(MAC)||PLATFORM(IOS) to just PLATFORM(MAC) 2013-01-29 06:37:31 -0800 1 1 1 Unclassified WebKit Platform 528+ (Nightly build) Unspecified Unspecified RESOLVED INVALID P2 Normal --- 1 laszlo.gombos webkit-unassigned abarth benjamin darin ddkilzer joepeck mjs ojan.autocc psolanki sam webkit.review.bot oldest_to_newest 811713 0 laszlo.gombos 2013-01-20 17:48:59 -0800 Collapse PLATFORM(MAC)||PLATFORM(IOS) to just PLATFORM(MAC) as PLATFORM(IOS) is a specialization of PLATFORM(MAC). PLATFORM(MAC) is always enabled when PLATFORM(IOS) is enabled. 811716 1 183694 laszlo.gombos 2013-01-20 18:04:30 -0800 Created attachment 183694 proposed change I found having both "PLATFORM(MAC) && !PLATFORM(IOS)" and "PLATFORM(MAC) || PLATFORM(IOS)" around to be slightly confusing. 812343 2 ddkilzer 2013-01-21 12:53:47 -0800 (In reply to comment #1) > Created an attachment (id=183694) [details] > proposed change > > I found having both "PLATFORM(MAC) && !PLATFORM(IOS)" and "PLATFORM(MAC) || PLATFORM(IOS)" around to be slightly confusing. Defining PLATFORM(MAC) when building PLATFORM(IOS) was just a convenience for the iOS port since (more often than not) the Mac and iOS platforms share code. It's also a messy convenience because in a tree where iOS is merged with open source, the following macros have to be defined in these cases: Mac only: PLATFORM(MAC) && !PLATFORM(IOS) iOS only: PLATFORM(IOS) Mac or iOS: PLATFORM(MAC) __or__ PLATFORM(MAC) || PLATFORM(IOS) I see two problems with this: 1. Having to use "PLATFORM(MAC) && !PLATFORM(IOS)" when you only want to build code for Mac. 2. Reading "PLATFORM(MAC)" doesn't really evoke "this code is for both Mac and iOS". A better long-term solution would be to: - Not define PLATFORM(MAC) when building PLATFORM(IOS). - Move uses of "PLATFORM(MAC) || PLATFORM(IOS)" to either a USE()/ENABLE() macro or some third PLATFORM() macro that is defined for both platforms. What about doing this instead for the near term: - Stop defining PLATFORM(MAC) when building for iOS. - Add a new PLATFORM(IOS_MAC) macro for cases when the code works for both (with the understanding that we will want to use a different name later since we don't have a good name today). - Replace "PLATFORM(MAC) || PLATFORM(IOS)" with "PLATFORM(IOS_MAC)". - Replace "PLATFORM(MAC) && !PLATFORM(IOS)" with just "PLATFORM(MAC)". Thoughts? 812351 3 benjamin 2013-01-21 13:05:50 -0800 I don't think we should block this patch because of future improvements. Most of the code already assume PLATFORM(MAC) implies PLATFORM(IOS). Other than that, I agree with your points. Maybe we could generalize OS(DARWIN) but I am afraid this will lead to many (OS(DARWIN) && !PLATFORM(QT)). Maybe - Replace "PLATFORM(MAC) || PLATFORM(IOS)" with "PLATFORM(IOS_MAC)". PLATFORM(APPLE_DARWIN)? PLATFORM(APPLE) - Replace "PLATFORM(MAC) && !PLATFORM(IOS)" with just "PLATFORM(MAC)". PLATFORM(OS_X)? 812364 4 abarth 2013-01-21 13:26:40 -0800 > Other than that, I agree with your points. > Maybe we could generalize OS(DARWIN) but I am afraid this will lead to many (OS(DARWIN) && !PLATFORM(QT)). > > Maybe > - Replace "PLATFORM(MAC) || PLATFORM(IOS)" with "PLATFORM(IOS_MAC)". > PLATFORM(APPLE_DARWIN)? > PLATFORM(APPLE) This is approach is most similar to the one we use for Chromium. We use PLATFORM(CHROMIUM) for the general approach and then use OS-specific macros in the cases where the details vary based on the operating system. You could also pick a more abstract name than PLATFORM(APPLE) if you might want to include Windows or other non-Apple operating systems in the future. For example, PLATFORM(TITANIUM) refers to a nice metal. :) 812483 5 darin 2013-01-21 17:15:13 -0800 Two thoughts here: 1) Renaming PLATFORM(MAC) since it’s sort of a base platform for both Mac and iOS sounds like a pretty good idea. 2) A bigger problem the extensive use of PLATFORM(MAC) and similar in the code instead of other derived more specific conditionals. It’s often a bug to have #if PLATFORM(MAC) somewhere; but we settle for that more often than we should. 812487 6 mjs 2013-01-21 17:23:08 -0800 (In reply to comment #5) > Two thoughts here: > > 1) Renaming PLATFORM(MAC) since it’s sort of a base platform for both Mac and iOS sounds like a pretty good idea. > > 2) A bigger problem the extensive use of PLATFORM(MAC) and similar in the code instead of other derived more specific conditionals. It’s often a bug to have #if PLATFORM(MAC) somewhere; but we settle for that more often than we should. My longstanding theory is that the PLATFORM macros should be phased out entirely in favor of more specific ones. That may take some work to achieve though. 812507 7 laszlo.gombos 2013-01-21 18:05:55 -0800 One of my motivations was to get a confirmation that _currently_ PLATFORM(IOS) assumes that PLATFORM(MAC) is defined so that I can continue to refactor the handling of ENABLE() defines. This is now confirmed. I tend to agree with Benjamin that while this patch does not make the situation a whole lot better at least it eliminates one of the ways to express "Mac or iOS". I think there needs to be a review of a standalone PLATFORM(MAC) guards before the situation can be significantly improved further. 813044 8 ddkilzer 2013-01-22 08:02:36 -0800 (In reply to comment #7) > I tend to agree with Benjamin that while this patch does not make the situation a whole lot better at least it eliminates one of the ways to express "Mac or iOS". My concern remains that collapsing "PLATFORM(MAC) || PLATFORM(IOS)" into "PLATFORM(MAC)" leads to a loss of information (if only documentation that this code should be compiled for iOS) so that when we stop defining PLATFORM(MAC) when building for iOS, we now have to go back and re-audit any place that PLATFORM(IOS) was dropped. There aren't many now, but there will be many more in the future. What if we defined a multi-platform macro like this? #define ANY_PLATFORM_3(WTF_FEATURE1, WTF_FEATURE2, WTF_FEATURE3) (PLATFORM(WTF_FEATURE1) || PLATFORM(WTF_FEATURE2) || PLATFORM(WTF_FEATURE3)) #define ANY_PLATFORM(WTF_FEATURE1, WTF_FEATURE2) (PLATFORM(WTF_FEATURE1) || PLATFORM(WTF_FEATURE2)) #define PLATFORM(WTF_FEATURE) (defined WTF_PLATFORM_##WTF_FEATURE && WTF_PLATFORM_##WTF_FEATURE) Then "PLATFORM(MAC) || PLATFORM(IOS)" would become "ANY_PLATFORM(IOS, MAC)". And we could collapse actual logic like this in GraphicsContext3D.h: #if PLATFORM(MAC) || PLATFORM(GTK) || PLATFORM(QT) || PLATFORM(EFL) || PLATFORM(BLACKBERRY) to something like this: #if ANY_PLATFORM_5(BLACKBERRY, EFL, GTK, MAC, QT) One (big?) downside to this is that it becomes much harder to search for all "PLATFORM(FOO)" macros using a purely text search. Not sure how often that is done, though. 813069 9 abarth 2013-01-22 08:51:26 -0800 IMHO "ANY_PLATFORM(IOS, MAC)" is worse than PLATFORM(MAC) || PLATFORM(IOS)" because it's harder to search for and mysterious whereas the latter is at least obvious in what it means. 817214 10 183694 ddkilzer 2013-01-26 10:39:08 -0800 Comment on attachment 183694 proposed change View in context: https://bugs.webkit.org/attachment.cgi?id=183694&action=review r- to incorporate suggested changes outside of Platform.h. > Source/JavaScriptCore/runtime/DatePrototype.cpp:65 > -#if PLATFORM(MAC) || PLATFORM(IOS) || (PLATFORM(WX) && OS(DARWIN)) || (PLATFORM(QT) && OS(DARWIN)) > +#if PLATFORM(MAC) || (PLATFORM(WX) && OS(DARWIN)) || (PLATFORM(QT) && OS(DARWIN)) > #include <CoreFoundation/CoreFoundation.h> This #if should probably be: #if USE(CF) However, this code would also now compile on the following platforms: PLATFORM(WIN) && !OS(WINCE) PLATFORM(CHROMIUM) && OS(DARWIN) The Chromium-on-Mac macro doesn't matter since Chromium uses V8. Not sure about !WinCE, though. > Source/JavaScriptCore/runtime/DatePrototype.cpp:128 > -#if PLATFORM(MAC) || PLATFORM(IOS) || (PLATFORM(WX) && OS(DARWIN)) || (PLATFORM(QT) && OS(DARWIN)) > +#if PLATFORM(MAC) || (PLATFORM(WX) && OS(DARWIN)) || (PLATFORM(QT) && OS(DARWIN)) Ditto about switching to #if USE(CF) here. > Source/WTF/wtf/Platform.h:473 > -#if PLATFORM(MAC) || PLATFORM(IOS) > +#if PLATFORM(MAC) I'm going to restate what's already been said, but we need to stop defining PLATFORM(MAC) when building PLATFORM(IOS) (and PLATFORM(IOS_SIMULATOR)) to make the decision explicit about whether a given piece of code supports both Mac and iOS, and to make Mac-only code not require "PLATFORM(MAC) && !PLATFORM(IOS)". I'll file a follow-up bug. The other thing I noticed about these uses of "PLATFORM(MAC) || PLATFORM(IOS)" in Platform.h is that' they're all defining other ENABLE() or USE() macros, which is exactly how they should be used since it makes it explicit about which platforms are defining each macro. To put it another way, using "PLATFORM(MAC) || PLATFORM(IOS)" in Platform.h is good, but using it outside of Platform.h means we're probably missing an ENABLE() or USE() macro. > Source/WebCore/config.h:148 > // CoreAnimation is available to IOS, Mac and Windows if using CG > -#if PLATFORM(MAC) || PLATFORM(IOS) || (PLATFORM(WIN) && USE(CG)) > +#if PLATFORM(MAC) || (PLATFORM(WIN) && USE(CG)) > #define WTF_USE_CA 1 > #endif This exact code is already in Source/WTF/wtf/Platform.h, and <wtf/Platform.h> is included in config.h above. It should just be removed. 817216 11 ddkilzer 2013-01-26 10:49:46 -0800 (In reply to comment #10) > (From update of attachment 183694 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=183694&action=review > > > Source/WTF/wtf/Platform.h:473 > > -#if PLATFORM(MAC) || PLATFORM(IOS) > > +#if PLATFORM(MAC) > > I'm going to restate what's already been said, but we need to stop defining PLATFORM(MAC) when building PLATFORM(IOS) (and PLATFORM(IOS_SIMULATOR)) to make the decision explicit about whether a given piece of code supports both Mac and iOS, and to make Mac-only code not require "PLATFORM(MAC) && !PLATFORM(IOS)". I'll file a follow-up bug. I filed Bug 108007. 818899 12 laszlo.gombos 2013-01-29 06:37:31 -0800 Thanks David for the review ! > > Source/JavaScriptCore/runtime/DatePrototype.cpp:65 > > -#if PLATFORM(MAC) || PLATFORM(IOS) || (PLATFORM(WX) && OS(DARWIN)) || (PLATFORM(QT) && OS(DARWIN)) > > +#if PLATFORM(MAC) || (PLATFORM(WX) && OS(DARWIN)) || (PLATFORM(QT) && OS(DARWIN)) > > #include <CoreFoundation/CoreFoundation.h> > > This #if should probably be: #if USE(CF) Filed bug to turn the guard to "OS(DARWIN) && USE(CF)" - see bug 108018. Filed a bug to get rid of "OS(DARWIN)" part and just use USE(CF) - see bug 108188 . Somewhat off topic - I also filed a bug for the Gtk Mac port to hit this code path - see bug 107492. > > Source/WebCore/config.h:148 > > // CoreAnimation is available to IOS, Mac and Windows if using CG > > -#if PLATFORM(MAC) || PLATFORM(IOS) || (PLATFORM(WIN) && USE(CG)) > > +#if PLATFORM(MAC) || (PLATFORM(WIN) && USE(CG)) > > #define WTF_USE_CA 1 > > #endif > > This exact code is already in Source/WTF/wtf/Platform.h, and <wtf/Platform.h> is included in config.h above. It should just be removed. Filed bug 108016 - it does not look like though that we can just remove these lines from config.h as that would break the WIN build. I think all the issues discussed here are now covered by the new bugs filed so I propose to close this bug. 183694 2013-01-20 18:04:30 -0800 2013-01-26 10:39:08 -0800 proposed change 107406.patch text/plain 6733 laszlo.gombos SW5kZXg6IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMTQwMjg2KQorKysgU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE1IEBA CisyMDEzLTAxLTIwICBMYXN6bG8gR29tYm9zICA8bC5nb21ib3NAc2Ftc3VuZy5jb20+CisKKyAg ICAgICAgQ29sbGFwc2UgUExBVEZPUk0oTUFDKXx8UExBVEZPUk0oSU9TKSB0byBqdXN0IFBMQVRG T1JNKE1BQykKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTEwNzQwNgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFBMQVRGT1JNKElPUykgaXMgYSBzcGVjaWFsaXphdGlvbiBvZiBQTEFURk9STShNQUMpLiBQTEFU Rk9STShNQUMpIGlzCisgICAgICAgIGFsd2F5cyBlbmFibGVkIHdoZW4gUExBVEZPUk0oSU9TKSBp cyBlbmFibGVkLgorCisgICAgICAgICogcnVudGltZS9EYXRlUHJvdG90eXBlLmNwcDoKKwogMjAx My0wMS0yMCAgR2VvZmZyZXkgR2FyZW4gIDxnZ2FyZW5AYXBwbGUuY29tPgogCiAgICAgICAgIFdl YWsgR0MgbWFwcyBzaG91bGQgYmUgZWFzaWVyIHRvIHVzZQpJbmRleDogU291cmNlL0phdmFTY3Jp cHRDb3JlL3J1bnRpbWUvRGF0ZVByb3RvdHlwZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL0ph dmFTY3JpcHRDb3JlL3J1bnRpbWUvRGF0ZVByb3RvdHlwZS5jcHAJKHJldmlzaW9uIDE0MDI4MikK KysrIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0RhdGVQcm90b3R5cGUuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC02MSw3ICs2MSw3IEBACiAjaW5jbHVkZSA8c3lzL3RpbWViLmg+CiAjZW5k aWYKIAotI2lmIFBMQVRGT1JNKE1BQykgfHwgUExBVEZPUk0oSU9TKSB8fCAoUExBVEZPUk0oV1gp ICYmIE9TKERBUldJTikpIHx8IChQTEFURk9STShRVCkgJiYgT1MoREFSV0lOKSkKKyNpZiBQTEFU Rk9STShNQUMpIHx8IChQTEFURk9STShXWCkgJiYgT1MoREFSV0lOKSkgfHwgKFBMQVRGT1JNKFFU KSAmJiBPUyhEQVJXSU4pKQogI2luY2x1ZGUgPENvcmVGb3VuZGF0aW9uL0NvcmVGb3VuZGF0aW9u Lmg+CiAjZWxpZiBVU0UoSUNVX1VOSUNPREUpCiAjaW5jbHVkZSA8dW5pY29kZS91ZGF0Lmg+CkBA IC0xMjUsNyArMTI1LDcgQEAgbmFtZXNwYWNlIEpTQyB7CiAKIGVudW0gTG9jYWxlRGF0ZVRpbWVG b3JtYXQgeyBMb2NhbGVEYXRlQW5kVGltZSwgTG9jYWxlRGF0ZSwgTG9jYWxlVGltZSB9OwogIAot I2lmIFBMQVRGT1JNKE1BQykgfHwgUExBVEZPUk0oSU9TKSB8fCAoUExBVEZPUk0oV1gpICYmIE9T KERBUldJTikpIHx8IChQTEFURk9STShRVCkgJiYgT1MoREFSV0lOKSkKKyNpZiBQTEFURk9STShN QUMpIHx8IChQTEFURk9STShXWCkgJiYgT1MoREFSV0lOKSkgfHwgKFBMQVRGT1JNKFFUKSAmJiBP UyhEQVJXSU4pKQogCiAvLyBGSVhNRTogU2luY2UgdGhpcyBpcyBzdXBlcmlvciB0byB0aGUgc3Ry ZnRpbWUtYmFzZWQgdmVyc2lvbiwgd2h5IGxpbWl0IHRoaXMgdG8gUExBVEZPUk0oTUFDKT8KIC8v IEluc3RlYWQgd2Ugc2hvdWxkIGNvbnNpZGVyIHVzaW5nIHRoaXMgd2hlbmV2ZXIgVVNFKENGKSBp cyB0cnVlLgpJbmRleDogU291cmNlL1dURi9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNl L1dURi9DaGFuZ2VMb2cJKHJldmlzaW9uIDE0MDI4NikKKysrIFNvdXJjZS9XVEYvQ2hhbmdlTG9n CSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTMtMDEtMjAgIExhc3psbyBHb21i b3MgIDxsLmdvbWJvc0BzYW1zdW5nLmNvbT4KKworICAgICAgICBDb2xsYXBzZSBQTEFURk9STShN QUMpfHxQTEFURk9STShJT1MpIHRvIGp1c3QgUExBVEZPUk0oTUFDKQorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTA3NDA2CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUExBVEZPUk0oSU9TKSBpcyBhIHNwZWNp YWxpemF0aW9uIG9mIFBMQVRGT1JNKE1BQykuIFBMQVRGT1JNKE1BQykgaXMKKyAgICAgICAgYWx3 YXlzIGVuYWJsZWQgd2hlbiBQTEFURk9STShJT1MpIGlzIGVuYWJsZWQuCisKKyAgICAgICAgKiB3 dGYvUGxhdGZvcm0uaDoKKwogMjAxMy0wMS0xOCAgTGFzemxvIEdvbWJvcyAgPGwuZ29tYm9zQHNh bXN1bmcuY29tPgogCiAgICAgICAgIFJlbW92ZSB1bm5lY2Vzc2FyeSBQTEFURk9STSgpIHRlc3Rz CkluZGV4OiBTb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybS5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9X VEYvd3RmL1BsYXRmb3JtLmgJKHJldmlzaW9uIDE0MDI4MikKKysrIFNvdXJjZS9XVEYvd3RmL1Bs YXRmb3JtLmgJKHdvcmtpbmcgY29weSkKQEAgLTQ3MCwxMCArNDcwLDEwIEBACiAvKiBHcmFwaGlj cyBlbmdpbmVzICovCiAKIC8qIFVTRShDRykgYW5kIFBMQVRGT1JNKENJKSAqLwotI2lmIFBMQVRG T1JNKE1BQykgfHwgUExBVEZPUk0oSU9TKQorI2lmIFBMQVRGT1JNKE1BQykKICNkZWZpbmUgV1RG X1VTRV9DRyAxCiAjZW5kaWYKLSNpZiBQTEFURk9STShNQUMpIHx8IFBMQVRGT1JNKElPUykgfHwg KFBMQVRGT1JNKFdJTikgJiYgVVNFKENHKSkKKyNpZiBQTEFURk9STShNQUMpIHx8IChQTEFURk9S TShXSU4pICYmIFVTRShDRykpCiAjZGVmaW5lIFdURl9VU0VfQ0EgMQogI2VuZGlmCiAKQEAgLTYz OSw3ICs2MzksNyBAQAogI2RlZmluZSBXVEZfVVNFX0NGTkVUV09SSyAxCiAjZW5kaWYKIAotI2lm IFVTRShDRk5FVFdPUkspIHx8IFBMQVRGT1JNKE1BQykgfHwgUExBVEZPUk0oSU9TKQorI2lmIFVT RShDRk5FVFdPUkspIHx8IFBMQVRGT1JNKE1BQykKICNkZWZpbmUgV1RGX1VTRV9DRlVSTENBQ0hF IDEKICNlbmRpZgogCkBAIC02NzEsNyArNjcxLDcgQEAKICNlbmRpZgogCiAjaWYgIWRlZmluZWQo SEFWRV9BQ0NFU1NJQklMSVRZKQotI2lmIFBMQVRGT1JNKElPUykgfHwgUExBVEZPUk0oTUFDKSB8 fCBQTEFURk9STShXSU4pIHx8IFBMQVRGT1JNKEdUSykgfHwgKFBMQVRGT1JNKENIUk9NSVVNKSAm JiAhT1MoQU5EUk9JRCkpIHx8IFBMQVRGT1JNKEVGTCkKKyNpZiBQTEFURk9STShNQUMpIHx8IFBM QVRGT1JNKFdJTikgfHwgUExBVEZPUk0oR1RLKSB8fCAoUExBVEZPUk0oQ0hST01JVU0pICYmICFP UyhBTkRST0lEKSkgfHwgUExBVEZPUk0oRUZMKQogI2RlZmluZSBIQVZFX0FDQ0VTU0lCSUxJVFkg MQogI2VuZGlmCiAjZW5kaWYgLyogIWRlZmluZWQoSEFWRV9BQ0NFU1NJQklMSVRZKSAqLwpAQCAt OTI2LDcgKzkyNiw3IEBACiAjaWYgIWRlZmluZWQoRU5BQkxFX0xMSU5UKSBcCiAgICAgJiYgRU5B QkxFKEpJVCkgXAogICAgICYmIChPUyhEQVJXSU4pIHx8IE9TKExJTlVYKSkgXAotICAgICYmIChQ TEFURk9STShNQUMpIHx8IFBMQVRGT1JNKElPUykgfHwgUExBVEZPUk0oR1RLKSB8fCBQTEFURk9S TShRVCkpIFwKKyAgICAmJiAoUExBVEZPUk0oTUFDKSB8fCBQTEFURk9STShHVEspIHx8IFBMQVRG T1JNKFFUKSkgXAogICAgICYmIChDUFUoWDg2KSB8fCBDUFUoWDg2XzY0KSB8fCBDUFUoQVJNX1RI VU1CMikgfHwgQ1BVKE1JUFMpKQogI2RlZmluZSBFTkFCTEVfTExJTlQgMQogI2VuZGlmCkBAIC0x MDU0LDExICsxMDU0LDExIEBACiAjZW5kaWYKIAogLyogQWNjZWxlcmF0ZWQgY29tcG9zaXRpbmcg Ki8KLSNpZiBQTEFURk9STShNQUMpIHx8IFBMQVRGT1JNKElPUykgfHwgUExBVEZPUk0oUVQpIHx8 IChQTEFURk9STShXSU4pICYmICFPUyhXSU5DRSkgJiYgIVBMQVRGT1JNKFdJTl9DQUlSTykpCisj aWYgUExBVEZPUk0oTUFDKSB8fCBQTEFURk9STShRVCkgfHwgKFBMQVRGT1JNKFdJTikgJiYgIU9T KFdJTkNFKSAmJiAhUExBVEZPUk0oV0lOX0NBSVJPKSkKICNkZWZpbmUgV1RGX1VTRV9BQ0NFTEVS QVRFRF9DT01QT1NJVElORyAxCiAjZW5kaWYKIAotI2lmIFBMQVRGT1JNKE1BQykgfHwgUExBVEZP Uk0oSU9TKQorI2lmIFBMQVRGT1JNKE1BQykKICNkZWZpbmUgRU5BQkxFX0NTU19JTUFHRV9TRVQg MQogI2VuZGlmCiAKQEAgLTEwODAsNyArMTA4MCw3IEBACiAjZGVmaW5lIFdURl9VU0VfQ09PUkRJ TkFURURfR1JBUEhJQ1MgMQogI2VuZGlmCiAKLSNpZiBQTEFURk9STShNQUMpIHx8IFBMQVRGT1JN KElPUykKKyNpZiBQTEFURk9STShNQUMpCiAjZGVmaW5lIFdURl9VU0VfUFJPVEVDVElPTl9TUEFD RV9BVVRIX0NBTExCQUNLIDEKICNlbmRpZgogCkBAIC0xMDk2LDcgKzEwOTYsNyBAQAogI2RlZmlu ZSBXVEZfUExBVEZPUk1fQ0ZORVRXT1JLIEVycm9yIFVTRV9tYWNyb19zaG91bGRfYmVfdXNlZF93 aXRoX0NGTkVUV09SSwogCiAvKiBGSVhNRTogRXZlbnR1YWxseSB3ZSBzaG91bGQgZW5hYmxlIHRo aXMgZm9yIGFsbCBwbGF0Zm9ybXMgYW5kIGdldCByaWQgb2YgdGhlIGRlZmluZS4gKi8KLSNpZiBQ TEFURk9STShJT1MpIHx8IFBMQVRGT1JNKE1BQykgfHwgUExBVEZPUk0oV0lOKSB8fCBQTEFURk9S TShRVCkgfHwgUExBVEZPUk0oR1RLKSB8fCBQTEFURk9STShFRkwpCisjaWYgUExBVEZPUk0oTUFD KSB8fCBQTEFURk9STShXSU4pIHx8IFBMQVRGT1JNKFFUKSB8fCBQTEFURk9STShHVEspIHx8IFBM QVRGT1JNKEVGTCkKICNkZWZpbmUgV1RGX1VTRV9QTEFURk9STV9TVFJBVEVHSUVTIDEKICNlbmRp ZgogCkBAIC0xMTQ2LDcgKzExNDYsNyBAQAogCiAjZGVmaW5lIEVOQUJMRV9PQkpFQ1RfTUFSS19M T0dHSU5HIDAKIAotI2lmICFkZWZpbmVkKEVOQUJMRV9QQVJBTExFTF9HQykgJiYgIUVOQUJMRShP QkpFQ1RfTUFSS19MT0dHSU5HKSAmJiAoUExBVEZPUk0oTUFDKSB8fCBQTEFURk9STShJT1MpIHx8 IFBMQVRGT1JNKEJMQUNLQkVSUlkpIHx8IFBMQVRGT1JNKEdUSykpICYmIEVOQUJMRShDT01QQVJF X0FORF9TV0FQKQorI2lmICFkZWZpbmVkKEVOQUJMRV9QQVJBTExFTF9HQykgJiYgIUVOQUJMRShP QkpFQ1RfTUFSS19MT0dHSU5HKSAmJiAoUExBVEZPUk0oTUFDKSB8fCBQTEFURk9STShCTEFDS0JF UlJZKSB8fCBQTEFURk9STShHVEspKSAmJiBFTkFCTEUoQ09NUEFSRV9BTkRfU1dBUCkKICNkZWZp bmUgRU5BQkxFX1BBUkFMTEVMX0dDIDEKICNlbGlmIFBMQVRGT1JNKFFUKQogLy8gUGFyYWxsZWwg R0MgaXMgdGVtcG9yYXJpbHkgZGlzYWJsZWQgb24gUXQgYmVjYXVzZSBvZiByZWd1bGFyIGNyYXNo ZXMsIHNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTA5NTcgZm9y IGRldGFpbHMKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBT b3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE0MDI4NikKKysrIFNvdXJjZS9XZWJD b3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE3IEBACisyMDEzLTAxLTIw ICBMYXN6bG8gR29tYm9zICA8bC5nb21ib3NAc2Ftc3VuZy5jb20+CisKKyAgICAgICAgQ29sbGFw c2UgUExBVEZPUk0oTUFDKXx8UExBVEZPUk0oSU9TKSB0byBqdXN0IFBMQVRGT1JNKE1BQykKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNzQwNgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFBMQVRGT1JNKElP UykgaXMgYSBzcGVjaWFsaXphdGlvbiBvZiBQTEFURk9STShNQUMpLiBQTEFURk9STShNQUMpIGlz CisgICAgICAgIGFsd2F5cyBlbmFibGVkIHdoZW4gUExBVEZPUk0oSU9TKSBpcyBlbmFibGVkLgor CisgICAgICAgIE5vIG5ldyB0ZXN0cyBhcyB0aGVyZSBpcyBubyBuZXcgZnVuY3Rpb25hbGl0eS4K KworICAgICAgICAqIGNvbmZpZy5oOgorCiAyMDEzLTAxLTIwICBZb3NoaWZ1bWkgSW5vdWUgIDx5 b3NpbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgRHJhZ2dpbmcgb3ZlciBhbiBlbGVtZW50IHdp dGggc2Nyb2xsYmFycyBzaG91bGQgc2Nyb2xsIHRoZSBlbGVtZW50IHdoZW4gZHJhZ2dpbmcgbmVh ciBlZGdlcwpJbmRleDogU291cmNlL1dlYkNvcmUvY29uZmlnLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL1dlYkNvcmUvY29uZmlnLmgJKHJldmlzaW9uIDE0MDI4MikKKysrIFNvdXJjZS9XZWJDb3Jl L2NvbmZpZy5oCSh3b3JraW5nIGNvcHkpCkBAIC0xNDMsNyArMTQzLDcgQEAgdHlwZWRlZiBmbG9h dCBDR0Zsb2F0OwogI2VuZGlmCiAKIC8vIENvcmVBbmltYXRpb24gaXMgYXZhaWxhYmxlIHRvIElP UywgTWFjIGFuZCBXaW5kb3dzIGlmIHVzaW5nIENHCi0jaWYgUExBVEZPUk0oTUFDKSB8fCBQTEFU Rk9STShJT1MpIHx8IChQTEFURk9STShXSU4pICYmIFVTRShDRykpCisjaWYgUExBVEZPUk0oTUFD KSB8fCAoUExBVEZPUk0oV0lOKSAmJiBVU0UoQ0cpKQogI2RlZmluZSBXVEZfVVNFX0NBIDEKICNl bmRpZgogCg==