143754 2015-04-15 06:13:12 -0700 [W32] weakCompareAndSwap assembler code is not used when building with MinGW GCC 2015-11-17 02:34:55 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED INVALID P2 Normal --- 133028 1 lrn1986 webkit-unassigned benjamin cgarcia cmarcelo commit-queue lrn1986 ossy oldest_to_newest 1085449 0 lrn1986 2015-04-15 06:13:12 -0700 The ifdef says OS(WINDOWS), but means COMPILER(MSVC) 1085483 1 250789 lrn1986 2015-04-15 08:28:39 -0700 Created attachment 250789 [GTK][W32] Allow MinGW-GCC to use GCC asm code for weakCompareAndSwap OS(WINDOWS) != COMPILER(MSVC) 1085496 2 250789 ossy 2015-04-15 09:14:47 -0700 Comment on attachment 250789 [GTK][W32] Allow MinGW-GCC to use GCC asm code for weakCompareAndSwap View in context: https://bugs.webkit.org/attachment.cgi?id=250789&action=review > Source/JavaScriptCore/ChangeLog:8 > + [W32] Fixup dummy HeapStatistics implementation > + > + GCC warns that exitWithFailure is marked as noreturn, but it does return: > + ../webkitgtk-2.4.8/Source/JavaScriptCore/heap/HeapStatistics.cpp:135:1: warning: 'noreturn' function does return > + > + Call exit(-1) to indicate that no, there is no returning from here. It is unrelated to this patch. > Source/JavaScriptCore/ChangeLog:16 > + * heap/HeapStatistics.cpp: > + (JSC::HeapStatistics::exitWithFailure): ditto > Source/WTF/wtf/Atomics.h:263 > -#if !OS(WINDOWS) && (CPU(X86) || CPU(X86_64)) > +#if (!OS(WINDOWS) || COMPILER(GCC)) && (CPU(X86) || CPU(X86_64)) I think OS(WINDOWS) is very confusing and isn't good at all, COMPILER(GCC) && (CPU(X86) || CPU(X86_64)) would be better. 1085511 3 250797 lrn1986 2015-04-15 09:39:46 -0700 Created attachment 250797 Allow MinGW-GCC to use GCC asm code for weakCompareAndSwap OS(WINDOWS) != COMPILER(MSVC) Use COMPILER(GCC) as suggested. 1085523 4 250797 ossy 2015-04-15 09:47:30 -0700 Comment on attachment 250797 Allow MinGW-GCC to use GCC asm code for weakCompareAndSwap View in context: https://bugs.webkit.org/attachment.cgi?id=250797&action=review > Source/WTF/ChangeLog:12 > + Allow MinGW-GCC to use GCC asm code for weakCompareAndSwap > + > + OS(WINDOWS) != COMPILER(MSVC) > + Use COMPILER(GCC) as suggested. > + > + [W32] weakCompareAndSwap assembler code is not used when building with MinGW GCC > + https://bugs.webkit.org/show_bug.cgi?id=143754 > + > + Reviewed by NOBODY (OOPS!). > + [W32] weakCompareAndSwap assembler code is not used when building with MinGW GCC https://bugs.webkit.org/show_bug.cgi?id=143754 Reviewed by NOBODY (OOPS!). ... everyting else ... 1087824 5 251436 lrn1986 2015-04-23 08:34:26 -0700 Created attachment 251436 Allow MinGW-GCC to use GCC asm code for weakCompareAndSwap This version does so for *all* variants of this functions, not just the one that needs it to compile. Also uses saner conditions and explains the ones that are not as sane. The code compiles and runs with this, but i can't be sure that i was able to test all the cases where this function is used. 1095856 6 cgarcia 2015-05-18 23:51:10 -0700 Committed to 2.4 http://trac.webkit.org/changeset/184552 I've committed this unreviewed to 2.4 since it's needed to fix the win32 build, but for trunk someone should review this. 1128476 7 ossy 2015-09-24 06:52:27 -0700 After https://trac.webkit.org/changeset/190103 we don't need assembly CAS anymore. 1142502 8 251436 ossy 2015-11-17 02:34:55 -0800 Comment on attachment 251436 Allow MinGW-GCC to use GCC asm code for weakCompareAndSwap Cleared review? from attachment 251436 so that this bug does not appear in http://webkit.org/pending-review. If you would like this patch reviewed, please attach it to a new bug (or re-open this bug before marking it for review again). 250789 2015-04-15 08:28:39 -0700 2015-04-15 09:39:46 -0700 [GTK][W32] Allow MinGW-GCC to use GCC asm code for weakCompareAndSwap GTKW32-Allow-MinGW-GCC-to-use-GCC-asm-code-for-wea.patch text/plain 2151 lrn1986 RnJvbSBjNGFkZTBkZWIzNTJlZjQ0YjIyYTNmYWQ3NjcxN2I3ZmY3ZDRjNmE4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/PUQwPUEwPUQxPTgzPUQxPTgxPUQwPUJCPUQw PUIwPUQwPUJEPTIwPUQwPTk4PUQwPUI2PUQwPUIxPz0KID0/VVRGLTg/cT89RDE9ODM9RDA9QkI9 RDA9QjA9RDE9ODI9RDA9QkU9RDA9QjI/PSA8bHJuMTk4NkBnbWFpbC5jb20+CkRhdGU6IE1vbiwg MTMgQXByIDIwMTUgMDA6NDY6NDggKzAwMDAKU3ViamVjdDogW1BBVENIXSBbR1RLXVtXMzJdIEFs bG93IE1pbkdXLUdDQyB0byB1c2UgR0NDIGFzbSBjb2RlIGZvcgogd2Vha0NvbXBhcmVBbmRTd2Fw CgpPUyhXSU5ET1dTKSAhPSBDT01QSUxFUihNU1ZDKQoKaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE0Mzc1NAotLS0KIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VM b2cgfCAxNyArKysrKysrKysrKysrKysrKwogU291cmNlL1dURi93dGYvQXRvbWljcy5oICAgICAg ICB8ICAyICstCiAyIGZpbGVzIGNoYW5nZWQsIDE4IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24o LSkKCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCBhNWNmZWI0Li5hYWY4ZjMxIDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAorMjAxNS0wNC0xNSAg0KDRg9GB0LvQ sNC9INCY0LbQsdGD0LvQsNGC0L7QsiAgPGxybjE5ODZAZ21haWwuY29tPgorCisgICAgICAgIFtX MzJdIEZpeHVwIGR1bW15IEhlYXBTdGF0aXN0aWNzIGltcGxlbWVudGF0aW9uCisKKyAgICAgICAg R0NDIHdhcm5zIHRoYXQgZXhpdFdpdGhGYWlsdXJlIGlzIG1hcmtlZCBhcyBub3JldHVybiwgYnV0 IGl0IGRvZXMgcmV0dXJuOgorICAgICAgICAuLi93ZWJraXRndGstMi40LjgvU291cmNlL0phdmFT Y3JpcHRDb3JlL2hlYXAvSGVhcFN0YXRpc3RpY3MuY3BwOjEzNToxOiB3YXJuaW5nOiAnbm9yZXR1 cm4nIGZ1bmN0aW9uIGRvZXMgcmV0dXJuCisKKyAgICAgICAgQ2FsbCBleGl0KC0xKSB0byBpbmRp Y2F0ZSB0aGF0IG5vLCB0aGVyZSBpcyBubyByZXR1cm5pbmcgZnJvbSBoZXJlLgorCisgICAgICAg IFtXMzJdIHdlYWtDb21wYXJlQW5kU3dhcCBhc3NlbWJsZXIgY29kZSBpcyBub3QgdXNlZCB3aGVu IGJ1aWxkaW5nIHdpdGggTWluR1cgR0NDCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xNDM3NTQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIGhlYXAvSGVhcFN0YXRpc3RpY3MuY3BwOgorICAgICAgICAoSlND OjpIZWFwU3RhdGlzdGljczo6ZXhpdFdpdGhGYWlsdXJlKToKKwogMjAxNC0wOC0xOSAgTWFnbnVz IEdyYW5iZXJnICA8em9ycnlAZ2VudG9vLm9yZz4KIAogICAgICAgICBURVhUUkVMIGluIGxpYmph dmFzY3JpcHRjb3JlZ3RrLTEuMC5zby4wLjExLjAgb24geDg2IChvciBpNTg2KQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dURi93dGYvQXRvbWljcy5oIGIvU291cmNlL1dURi93dGYvQXRvbWljcy5oCmlu ZGV4IDNkMThlM2UuLmU2ZGE4OTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL0F0b21pY3Mu aAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9BdG9taWNzLmgKQEAgLTI2MCw3ICsyNjAsNyBAQCBpbmxp bmUgdm9pZCBtZW1vcnlCYXJyaWVyQmVmb3JlVW5sb2NrKCkgeyBjb21waWxlckZlbmNlKCk7IH0K IGlubGluZSBib29sIHdlYWtDb21wYXJlQW5kU3dhcCh1aW50OF90KiBsb2NhdGlvbiwgdWludDhf dCBleHBlY3RlZCwgdWludDhfdCBuZXdWYWx1ZSkKIHsKICNpZiBFTkFCTEUoQ09NUEFSRV9BTkRf U1dBUCkKLSNpZiAhT1MoV0lORE9XUykgJiYgKENQVShYODYpIHx8IENQVShYODZfNjQpKQorI2lm ICghT1MoV0lORE9XUykgfHwgQ09NUElMRVIoR0NDKSkgJiYgKENQVShYODYpIHx8IENQVShYODZf NjQpKQogICAgIHVuc2lnbmVkIGNoYXIgcmVzdWx0OwogICAgIGFzbSB2b2xhdGlsZSgKICAgICAg ICAgImxvY2s7IGNtcHhjaGdiICUzLCAlMlxuXHQiCi0tIAoxLjguNS4z 250797 2015-04-15 09:39:46 -0700 2015-04-23 08:34:26 -0700 Allow MinGW-GCC to use GCC asm code for weakCompareAndSwap Allow-MinGW-GCC-to-use-GCC-asm-code-for-weakCompar.patch text/plain 1966 lrn1986 RnJvbSA0NWVkOTQzYTU2YzMyYTM2ZWU4MmYzY2I5YTA3M2M4MDFkN2Q2NzliIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/PUQwPUEwPUQxPTgzPUQxPTgxPUQwPUJCPUQw PUIwPUQwPUJEPTIwPUQwPTk4PUQwPUI2PUQwPUIxPz0KID0/VVRGLTg/cT89RDE9ODM9RDA9QkI9 RDA9QjA9RDE9ODI9RDA9QkU9RDA9QjI/PSA8bHJuMTk4NkBnbWFpbC5jb20+CkRhdGU6IE1vbiwg MTMgQXByIDIwMTUgMDA6NDY6NDggKzAwMDAKU3ViamVjdDogW1BBVENIXSBBbGxvdyBNaW5HVy1H Q0MgdG8gdXNlIEdDQyBhc20gY29kZSBmb3Igd2Vha0NvbXBhcmVBbmRTd2FwCgpPUyhXSU5ET1dT KSAhPSBDT01QSUxFUihNU1ZDKQpVc2UgQ09NUElMRVIoR0NDKSBhcyBzdWdnZXN0ZWQuCgpodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQzNzU0Ci0tLQogU291cmNlL1dU Ri9DaGFuZ2VMb2cgICAgIHwgMTUgKysrKysrKysrKysrKysrCiBTb3VyY2UvV1RGL3d0Zi9BdG9t aWNzLmggfCAgMiArLQogMiBmaWxlcyBjaGFuZ2VkLCAxNiBpbnNlcnRpb25zKCspLCAxIGRlbGV0 aW9uKC0pCgpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV1RGL0No YW5nZUxvZwppbmRleCA2MzZhOGQ0Li5lZjcxODI3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL0No YW5nZUxvZworKysgYi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDIwIEBACiAyMDE1 LTA0LTE1ICDQoNGD0YHQu9Cw0L0g0JjQttCx0YPQu9Cw0YLQvtCyICA8bHJuMTk4NkBnbWFpbC5j b20+CiAKKyAgICAgICAgQWxsb3cgTWluR1ctR0NDIHRvIHVzZSBHQ0MgYXNtIGNvZGUgZm9yIHdl YWtDb21wYXJlQW5kU3dhcAorCisgICAgICAgIE9TKFdJTkRPV1MpICE9IENPTVBJTEVSKE1TVkMp CisgICAgICAgIFVzZSBDT01QSUxFUihHQ0MpIGFzIHN1Z2dlc3RlZC4KKworICAgICAgICBbVzMy XSB3ZWFrQ29tcGFyZUFuZFN3YXAgYXNzZW1ibGVyIGNvZGUgaXMgbm90IHVzZWQgd2hlbiBidWls ZGluZyB3aXRoIE1pbkdXIEdDQworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTQzNzU0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgKiB3dGYvQXRvbWljcy5oOgorICAgICAgICAoV1RGOjp3ZWFrQ29tcGFyZUFu ZFN3YXApOgorCisyMDE1LTA0LTE1ICDQoNGD0YHQu9Cw0L0g0JjQttCx0YPQu9Cw0YLQvtCyICA8 bHJuMTk4NkBnbWFpbC5jb20+CisKICAgICAgICAgRG9uJ3QgaW5jbHVkZSBub24tZXhpc3Rpbmcg V1RGL1dURkhlYWRlckRldGVjdGlvbi5oIGluIDIuNC54CiAKICAgICAgICAgV1RGL1dURkhlYWRl ckRldGVjdGlvbi5oIHNlZW1zIHRvIGJlIGZyb20gc29tZSBvdGhlciB1bml2ZXJzZSwKZGlmZiAt LWdpdCBhL1NvdXJjZS9XVEYvd3RmL0F0b21pY3MuaCBiL1NvdXJjZS9XVEYvd3RmL0F0b21pY3Mu aAppbmRleCAzZDE4ZTNlLi4xMWRiY2NlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9BdG9t aWNzLmgKKysrIGIvU291cmNlL1dURi93dGYvQXRvbWljcy5oCkBAIC0yNjAsNyArMjYwLDcgQEAg aW5saW5lIHZvaWQgbWVtb3J5QmFycmllckJlZm9yZVVubG9jaygpIHsgY29tcGlsZXJGZW5jZSgp OyB9CiBpbmxpbmUgYm9vbCB3ZWFrQ29tcGFyZUFuZFN3YXAodWludDhfdCogbG9jYXRpb24sIHVp bnQ4X3QgZXhwZWN0ZWQsIHVpbnQ4X3QgbmV3VmFsdWUpCiB7CiAjaWYgRU5BQkxFKENPTVBBUkVf QU5EX1NXQVApCi0jaWYgIU9TKFdJTkRPV1MpICYmIChDUFUoWDg2KSB8fCBDUFUoWDg2XzY0KSkK KyNpZiBDT01QSUxFUihHQ0MpICYmIChDUFUoWDg2KSB8fCBDUFUoWDg2XzY0KSkKICAgICB1bnNp Z25lZCBjaGFyIHJlc3VsdDsKICAgICBhc20gdm9sYXRpbGUoCiAgICAgICAgICJsb2NrOyBjbXB4 Y2hnYiAlMywgJTJcblx0IgotLSAKMS44LjUuMw== 251436 2015-04-23 08:34:26 -0700 2015-11-17 02:34:55 -0800 Allow MinGW-GCC to use GCC asm code for weakCompareAndSwap Allow-MinGW-GCC-to-use-GCC-asm-code-for-weakCompar.patch text/plain 3790 lrn1986 RnJvbSBlMTdmZDk5ZjExOWI1ZTQ2OTg5ZjQ3ZjYzOTZhNTQzZjhjM2YxMGNhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/PUQwPUEwPUQxPTgzPUQxPTgxPUQwPUJCPUQw PUIwPUQwPUJEPTIwPUQwPTk4PUQwPUI2PUQwPUIxPz0KID0/VVRGLTg/cT89RDE9ODM9RDA9QkI9 RDA9QjA9RDE9ODI9RDA9QkU9RDA9QjI/PSA8bHJuMTk4NkBnbWFpbC5jb20+CkRhdGU6IFRodSwg MTYgQXByIDIwMTUgMTE6MzQ6MDYgKzAwMDAKU3ViamVjdDogW1BBVENIXSBBbGxvdyBNaW5HVy1H Q0MgdG8gdXNlIEdDQyBhc20gY29kZSBmb3Igd2Vha0NvbXBhcmVBbmRTd2FwCgpodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQzNzU0Ci0tLQogU291cmNlL1dURi9DaGFu Z2VMb2cgICAgIHwgMTMgKysrKysrKysrKysrKwogU291cmNlL1dURi93dGYvQXRvbWljcy5oIHwg MTQgKysrKysrKystLS0tLS0KIDIgZmlsZXMgY2hhbmdlZCwgMjEgaW5zZXJ0aW9ucygrKSwgNiBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5nZUxvZyBiL1NvdXJjZS9X VEYvQ2hhbmdlTG9nCmluZGV4IDYzNmE4ZDQuLmEyMjUwOWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X VEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAK KzIwMTUtMDQtMTYgINCg0YPRgdC70LDQvSDQmNC20LHRg9C70LDRgtC+0LIgIDxscm4xOTg2QGdt YWlsLmNvbT4KKworICAgICAgICBbVzMyXSB3ZWFrQ29tcGFyZUFuZFN3YXAgYXNzZW1ibGVyIGNv ZGUgaXMgbm90IHVzZWQgd2hlbiBidWlsZGluZyB3aXRoIE1pbkdXIEdDQworICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQzNzU0CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWxsb3cgTWluR1ctR0NDIHRvIHVz ZSBHQ0MgYXNtIGNvZGUgZm9yIHdlYWtDb21wYXJlQW5kU3dhcC4KKworICAgICAgICAqIHd0Zi9B dG9taWNzLmg6CisgICAgICAgIChXVEY6Ong4Nl9tZmVuY2UpOgorICAgICAgICAoV1RGOjp3ZWFr Q29tcGFyZUFuZFN3YXApOgorCiAyMDE1LTA0LTE1ICDQoNGD0YHQu9Cw0L0g0JjQttCx0YPQu9Cw 0YLQvtCyICA8bHJuMTk4NkBnbWFpbC5jb20+CiAKICAgICAgICAgRG9uJ3QgaW5jbHVkZSBub24t ZXhpc3RpbmcgV1RGL1dURkhlYWRlckRldGVjdGlvbi5oIGluIDIuNC54CmRpZmYgLS1naXQgYS9T b3VyY2UvV1RGL3d0Zi9BdG9taWNzLmggYi9Tb3VyY2UvV1RGL3d0Zi9BdG9taWNzLmgKaW5kZXgg M2QxOGUzZS4uMTI4N2I1NiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvQXRvbWljcy5oCisr KyBiL1NvdXJjZS9XVEYvd3RmL0F0b21pY3MuaApAQCAtNzIsNyArNzIsNyBAQCBleHRlcm4gIkMi IHZvaWQgX1JlYWRXcml0ZUJhcnJpZXIodm9pZCk7CiAKIG5hbWVzcGFjZSBXVEYgewogCi0jaWYg T1MoV0lORE9XUykKKyNpZiBPUyhXSU5ET1dTKSAmJiAhQ09NUElMRVIoR0NDKQogaW5saW5lIGJv b2wgd2Vha0NvbXBhcmVBbmRTd2FwKHZvbGF0aWxlIHVuc2lnbmVkKiBsb2NhdGlvbiwgdW5zaWdu ZWQgZXhwZWN0ZWQsIHVuc2lnbmVkIG5ld1ZhbHVlKQogewogI2lmIE9TKFdJTkNFKQpAQCAtODYs NyArODYsNyBAQCBpbmxpbmUgYm9vbCB3ZWFrQ29tcGFyZUFuZFN3YXAodm9pZCp2b2xhdGlsZSog bG9jYXRpb24sIHZvaWQqIGV4cGVjdGVkLCB2b2lkKiBuZQogewogICAgIHJldHVybiBJbnRlcmxv Y2tlZENvbXBhcmVFeGNoYW5nZVBvaW50ZXIobG9jYXRpb24sIG5ld1ZhbHVlLCBleHBlY3RlZCkg PT0gZXhwZWN0ZWQ7CiB9Ci0jZWxzZSAvLyBPUyhXSU5ET1dTKSAtLT4gbm90IHdpbmRvd3MKKyNl bHNlIC8vIE9TKFdJTkRPV1MpICYmICFDT01QSUxFUihHQ0MpIC0tPiBub3Qgd2luZG93cywgYnV0 IG1heWJlIG1pbmd3CiBpbmxpbmUgYm9vbCB3ZWFrQ29tcGFyZUFuZFN3YXAodm9sYXRpbGUgdW5z aWduZWQqIGxvY2F0aW9uLCB1bnNpZ25lZCBleHBlY3RlZCwgdW5zaWduZWQgbmV3VmFsdWUpIAog ewogI2lmIEVOQUJMRShDT01QQVJFX0FORF9TV0FQKQpAQCAtMTc4LDcgKzE3OCw3IEBAIGlubGlu ZSBib29sIHdlYWtDb21wYXJlQW5kU3dhcCh2b2lkKnZvbGF0aWxlKiBsb2NhdGlvbiwgdm9pZCog ZXhwZWN0ZWQsIHZvaWQqIG5lCiAgICAgcmV0dXJuIDA7CiAjZW5kaWYgLy8gRU5BQkxFKENPTVBB UkVfQU5EX1NXQVApCiB9Ci0jZW5kaWYgLy8gT1MoV0lORE9XUykgKGVuZCBvZiB0aGUgbm90LXdp bmRvd3MgY2FzZSkKKyNlbmRpZiAvLyBPUyhXSU5ET1dTKSAmJiAhQ09NUElMRVIoR0NDKSAoZW5k IG9mIHRoZSBub3Qtd2luZG93cyAoYnV0IG1heWJlIG1pbmd3KSBjYXNlKQogCiBpbmxpbmUgYm9v bCB3ZWFrQ29tcGFyZUFuZFN3YXBVSW50UHRyKHZvbGF0aWxlIHVpbnRwdHJfdCogbG9jYXRpb24s IHVpbnRwdHJfdCBleHBlY3RlZCwgdWludHB0cl90IG5ld1ZhbHVlKQogewpAQCAtMjI4LDcgKzIy OCw3IEBAIGlubGluZSB2b2lkIG1lbW9yeUJhcnJpZXJCZWZvcmVVbmxvY2soKSB7IGFybVY3X2Rt YigpOyB9CiAKIGlubGluZSB2b2lkIHg4Nl9tZmVuY2UoKQogewotI2lmIE9TKFdJTkRPV1MpCisj aWYgT1MoV0lORE9XUykgJiYgIUNPTVBJTEVSKEdDQykKICAgICAvLyBJIHRoaW5rIHRoYXQgdGhp cyBkb2VzIHRoZSBlcXVpdmFsZW50IG9mIGEgZHVtbXkgaW50ZXJsb2NrZWQgaW5zdHJ1Y3Rpb24s CiAgICAgLy8gaW5zdGVhZCBvZiB1c2luZyB0aGUgJ21mZW5jZScgaW5zdHJ1Y3Rpb24sIGF0IGxl YXN0IGFjY29yZGluZyB0byBNU0ROLiBJCiAgICAgLy8ga25vdyB0aGF0IGl0IGlzIGVxdWl2YWxl bnQgZm9yIG91ciBwdXJwb3NlcywgYnV0IGl0IHdvdWxkIGJlIGdvb2QgdG8KQEAgLTI2MCw3ICsy NjAsOCBAQCBpbmxpbmUgdm9pZCBtZW1vcnlCYXJyaWVyQmVmb3JlVW5sb2NrKCkgeyBjb21waWxl ckZlbmNlKCk7IH0KIGlubGluZSBib29sIHdlYWtDb21wYXJlQW5kU3dhcCh1aW50OF90KiBsb2Nh dGlvbiwgdWludDhfdCBleHBlY3RlZCwgdWludDhfdCBuZXdWYWx1ZSkKIHsKICNpZiBFTkFCTEUo Q09NUEFSRV9BTkRfU1dBUCkKLSNpZiAhT1MoV0lORE9XUykgJiYgKENQVShYODYpIHx8IENQVShY ODZfNjQpKQorI2lmICFDT01QSUxFUihNU1ZDKSAmJiAoQ1BVKFg4NikgfHwgQ1BVKFg4Nl82NCkp CisgICAgLy8gIUNPTVBJTEVSKE1TVkMpIGhlcmUgbWVhbnMgIkFTTV9TWU5UQVgoQVRfQU5EX1Qp IgogICAgIHVuc2lnbmVkIGNoYXIgcmVzdWx0OwogICAgIGFzbSB2b2xhdGlsZSgKICAgICAgICAg ImxvY2s7IGNtcHhjaGdiICUzLCAlMlxuXHQiCkBAIC0yNzAsNyArMjcxLDggQEAgaW5saW5lIGJv b2wgd2Vha0NvbXBhcmVBbmRTd2FwKHVpbnQ4X3QqIGxvY2F0aW9uLCB1aW50OF90IGV4cGVjdGVk LCB1aW50OF90IG5ld1YKICAgICAgICAgOiAibWVtb3J5IgogICAgICAgICApOwogICAgIHJldHVy biByZXN1bHQ7Ci0jZWxpZiBPUyhXSU5ET1dTKSAmJiBDUFUoWDg2KQorI2VsaWYgQ09NUElMRVIo TVNWQykgJiYgQ1BVKFg4NikKKyAgICAvLyBDT01QSUxFUihNU1ZDKSBoZXJlIG1lYW5zICJBU01f U1lOVEFYKElOVEVMKSIKICAgICAvLyBGSVhNRTogV2UgbmVlZCBhIDY0LWJpdCBBU00gaW1wbGVt ZW50YXRpb24sIGJ1dCB0aGlzIGNhbm5vdCBiZSBpbmxpbmUgZHVlIHRvCiAgICAgLy8gTWljcm9z b2Z0J3MgZGVjaXNpb24gdG8gZXhjbHVkZSBpdCBmcm9tIHRoZSBjb21waWxlci4KICAgICBib29s IHJlc3VsdCA9IGZhbHNlOwotLSAKMS44LjUuMw==