Rename WTF_COMPILER_GCC_OR_CLANG to WTF_COMPILER_GCC_COMPATIBLE
authorHironori.Fujii@sony.com <Hironori.Fujii@sony.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 25 Sep 2018 03:05:13 +0000 (03:05 +0000)
committerHironori.Fujii@sony.com <Hironori.Fujii@sony.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 25 Sep 2018 03:05:13 +0000 (03:05 +0000)
https://bugs.webkit.org/show_bug.cgi?id=189733

Reviewed by Michael Catanzaro.

Source/bmalloc:

* bmalloc/BCompiler.h:

Source/JavaScriptCore:

* assembler/ARM64Assembler.h:
* assembler/ARMAssembler.h:
(JSC::ARMAssembler::cacheFlush):
* assembler/MacroAssemblerARM.cpp:
(JSC::isVFPPresent):
* assembler/MacroAssemblerARM64.cpp:
* assembler/MacroAssemblerARMv7.cpp:
* assembler/MacroAssemblerMIPS.cpp:
* assembler/MacroAssemblerX86Common.cpp:
* heap/HeapCell.cpp:
* heap/HeapCell.h:
* jit/HostCallReturnValue.h:
* jit/JIT.h:
* jit/JITOperations.cpp:
* jit/ThunkGenerators.cpp:
* runtime/ArrayConventions.cpp:
(JSC::clearArrayMemset):
* runtime/JSBigInt.cpp:
(JSC::JSBigInt::digitDiv):

Source/WebCore:

No new tests (No behavior change).

* platform/graphics/cpu/arm/filters/FELightingNEON.cpp:
* platform/graphics/cpu/arm/filters/FELightingNEON.h:
* platform/graphics/filters/FELighting.cpp:
(WebCore::FELighting::platformApply):
* platform/graphics/filters/FELighting.h:

Source/WTF:

Clang for Windows build enables WTF_COMPILER_CLANG and
WTF_COMPILER_MSVC, but disables WTF_COMPILER_GCC_OR_CLANG. It is
strange WTF_COMPILER_GCC_OR_CLANG is not enabled even though
WTF_COMPILER_CLANG is enabled. However, Clang for Windows imitates
MSVC, and codes for COMPILER(GCC_OR_CLANG) are for non MSVC. At
least at the moment, it is not feasible to define
WTF_COMPILER_GCC_OR_CLANG for Clang for Windows.

To solve the issue, this change renames WTF_COMPILER_GCC_OR_CLANG
to WTF_COMPILER_GCC_COMPATIBLE.

As an exception, I'd like to use IGNORE_WARNINGS_* macros even in
Clang for Windows builds.

* wtf/Assertions.cpp: Replaced COMPILER(GCC_OR_CLANG) with COMPILER(GCC_COMPATIBLE).
* wtf/Assertions.h: Ditto.
* wtf/Atomics.h: Ditto.
* wtf/CheckedArithmetic.h: Ditto.
* wtf/FastMalloc.h: Ditto.
* wtf/MathExtras.h: Ditto.
* wtf/Platform.h: Ditto.
* wtf/StdLibExtras.h: Ditto.
* wtf/Vector.h: Ditto.
* wtf/text/ASCIIFastPath.h: Ditto.
* wtf/Compiler.h:  Ditto. Replaced "COMPILER(GCC_OR_CLANG)" with "COMPILER(GCC) || COMPILER(CLANG)" of IGNORE_WARNINGS_* macros.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@236450 268f45cc-cd09-0410-ab3c-d52691b4dbfc

36 files changed:
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/assembler/ARM64Assembler.h
Source/JavaScriptCore/assembler/ARMAssembler.h
Source/JavaScriptCore/assembler/MacroAssemblerARM.cpp
Source/JavaScriptCore/assembler/MacroAssemblerARM64.cpp
Source/JavaScriptCore/assembler/MacroAssemblerARMv7.cpp
Source/JavaScriptCore/assembler/MacroAssemblerMIPS.cpp
Source/JavaScriptCore/assembler/MacroAssemblerX86Common.cpp
Source/JavaScriptCore/heap/HeapCell.cpp
Source/JavaScriptCore/heap/HeapCell.h
Source/JavaScriptCore/jit/HostCallReturnValue.cpp
Source/JavaScriptCore/jit/HostCallReturnValue.h
Source/JavaScriptCore/jit/JIT.h
Source/JavaScriptCore/jit/JITOperations.cpp
Source/JavaScriptCore/jit/ThunkGenerators.cpp
Source/JavaScriptCore/runtime/ArrayConventions.cpp
Source/JavaScriptCore/runtime/JSBigInt.cpp
Source/WTF/ChangeLog
Source/WTF/wtf/Assertions.cpp
Source/WTF/wtf/Assertions.h
Source/WTF/wtf/Atomics.h
Source/WTF/wtf/CheckedArithmetic.h
Source/WTF/wtf/Compiler.h
Source/WTF/wtf/FastMalloc.h
Source/WTF/wtf/MathExtras.h
Source/WTF/wtf/Platform.h
Source/WTF/wtf/StdLibExtras.h
Source/WTF/wtf/Vector.h
Source/WTF/wtf/text/ASCIIFastPath.h
Source/WebCore/ChangeLog
Source/WebCore/platform/graphics/cpu/arm/filters/FELightingNEON.cpp
Source/WebCore/platform/graphics/cpu/arm/filters/FELightingNEON.h
Source/WebCore/platform/graphics/filters/FELighting.cpp
Source/WebCore/platform/graphics/filters/FELighting.h
Source/bmalloc/ChangeLog
Source/bmalloc/bmalloc/BCompiler.h

index 7d33a4c..1f51816 100644 (file)
@@ -1,3 +1,30 @@
+2018-09-24  Fujii Hironori  <Hironori.Fujii@sony.com>
+
+        Rename WTF_COMPILER_GCC_OR_CLANG to WTF_COMPILER_GCC_COMPATIBLE
+        https://bugs.webkit.org/show_bug.cgi?id=189733
+
+        Reviewed by Michael Catanzaro.
+
+        * assembler/ARM64Assembler.h:
+        * assembler/ARMAssembler.h:
+        (JSC::ARMAssembler::cacheFlush):
+        * assembler/MacroAssemblerARM.cpp:
+        (JSC::isVFPPresent):
+        * assembler/MacroAssemblerARM64.cpp:
+        * assembler/MacroAssemblerARMv7.cpp:
+        * assembler/MacroAssemblerMIPS.cpp:
+        * assembler/MacroAssemblerX86Common.cpp:
+        * heap/HeapCell.cpp:
+        * heap/HeapCell.h:
+        * jit/HostCallReturnValue.h:
+        * jit/JIT.h:
+        * jit/JITOperations.cpp:
+        * jit/ThunkGenerators.cpp:
+        * runtime/ArrayConventions.cpp:
+        (JSC::clearArrayMemset):
+        * runtime/JSBigInt.cpp:
+        (JSC::JSBigInt::digitDiv):
+
 2018-09-24  Saam Barati  <sbarati@apple.com>
 
         Array.prototype.indexOf fast path needs to ensure the length is still valid after performing effects
index 3c9478e..2166e85 100644 (file)
@@ -2852,7 +2852,7 @@ public:
 
     unsigned debugOffset() { return m_buffer.debugOffset(); }
 
-#if OS(LINUX) && COMPILER(GCC_OR_CLANG)
+#if OS(LINUX) && COMPILER(GCC_COMPATIBLE)
     static inline void linuxPageFlush(uintptr_t begin, uintptr_t end)
     {
         __builtin___clear_cache(reinterpret_cast<char*>(begin), reinterpret_cast<char*>(end));
index 3554821..73cfbef 100644 (file)
@@ -1164,7 +1164,7 @@ namespace JSC {
             return AL | B | (offset & BranchOffsetMask);
         }
 
-#if OS(LINUX) && COMPILER(GCC_OR_CLANG)
+#if OS(LINUX) && COMPILER(GCC_COMPATIBLE)
         static inline void linuxPageFlush(uintptr_t begin, uintptr_t end)
         {
             asm volatile(
@@ -1184,7 +1184,7 @@ namespace JSC {
 
         static void cacheFlush(void* code, size_t size)
         {
-#if OS(LINUX) && COMPILER(GCC_OR_CLANG)
+#if OS(LINUX) && COMPILER(GCC_COMPATIBLE)
             size_t page = pageSize();
             uintptr_t current = reinterpret_cast<uintptr_t>(code);
             uintptr_t end = current + size;
index c6a3ab8..9574d6c 100644 (file)
@@ -60,7 +60,7 @@ static bool isVFPPresent()
     }
 #endif // OS(LINUX)
 
-#if (COMPILER(GCC_OR_CLANG) && defined(__VFP_FP__))
+#if (COMPILER(GCC_COMPATIBLE) && defined(__VFP_FP__))
     return true;
 #else
     return false;
@@ -103,7 +103,7 @@ extern "C" void ctiMasmProbeTrampoline();
 
 using namespace ARMRegisters;
 
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 
 // The following are offsets for Probe::State fields accessed
 // by the ctiMasmProbeTrampoline stub.
@@ -427,7 +427,7 @@ asm (
     "ldr       sp, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_SP_OFFSET) "]" "\n"
     "pop       { pc }" "\n"
 );
-#endif // COMPILER(GCC_OR_CLANG)
+#endif // COMPILER(GCC_COMPATIBLE)
 
 void MacroAssembler::probe(Probe::Function function, void* arg)
 {
index edfb442..c2be083 100644 (file)
@@ -44,7 +44,7 @@ extern "C" void ctiMasmProbeTrampoline();
 
 using namespace ARM64Registers;
 
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 
 // The following are offsets for Probe::State fields accessed
 // by the ctiMasmProbeTrampoline stub.
@@ -509,7 +509,7 @@ asm (
     "ldp       x29, x30, [sp], #" STRINGIZE_VALUE_OF(2 * PTR_SIZE) "\n"
     "ret" "\n"
 );
-#endif // COMPILER(GCC_OR_CLANG)
+#endif // COMPILER(GCC_COMPATIBLE)
 
 void MacroAssembler::probe(Probe::Function function, void* arg)
 {
index 5fdc0fc..ca053b4 100644 (file)
@@ -39,7 +39,7 @@ extern "C" void ctiMasmProbeTrampoline();
 
 using namespace ARMRegisters;
 
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 
 // The following are offsets for Probe::State fields accessed
 // by the ctiMasmProbeTrampoline stub.
@@ -365,7 +365,7 @@ asm (
     "ldr       sp, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_SP_OFFSET) "]" "\n"
     "pop       { pc }" "\n"
 );
-#endif // COMPILER(GCC_OR_CLANG)
+#endif // COMPILER(GCC_COMPATIBLE)
 
 void MacroAssembler::probe(Probe::Function function, void* arg)
 {
index 058c5b6..6278548 100644 (file)
@@ -40,7 +40,7 @@ extern "C" void ctiMasmProbeTrampoline();
 
 using namespace MIPSRegisters;
 
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 
 // The following are offsets for Probe::State fields accessed
 // by the ctiMasmProbeTrampoline stub.
@@ -550,7 +550,7 @@ asm (
     "nop" "\n"
     ".set pop" "\n"
 );
-#endif // COMPILER(GCC_OR_CLANG)
+#endif // COMPILER(GCC_COMPATIBLE)
 
 void MacroAssembler::probe(Probe::Function function, void* arg)
 {
index 43b8625..8b148cf 100644 (file)
@@ -171,7 +171,7 @@ static_assert((PROBE_EXECUTOR_OFFSET + PTR_SIZE) <= (PROBE_SIZE + OUT_SIZE), "Mu
 #undef PROBE_OFFSETOF
 
 #if CPU(X86)
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 asm (
     ".globl " SYMBOL_STRING(ctiMasmProbeTrampoline) "\n"
     HIDE_SYMBOL(ctiMasmProbeTrampoline) "\n"
@@ -511,7 +511,7 @@ extern "C" __declspec(naked) void ctiMasmProbeTrampoline()
 #endif // CPU(X86)
 
 #if CPU(X86_64)
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 asm (
     ".globl " SYMBOL_STRING(ctiMasmProbeTrampoline) "\n"
     HIDE_SYMBOL(ctiMasmProbeTrampoline) "\n"
@@ -705,7 +705,7 @@ asm (
     "popq %rbp" "\n"
     "ret" "\n"
 );
-#endif // COMPILER(GCC_OR_CLANG)
+#endif // COMPILER(GCC_COMPATIBLE)
 #endif // CPU(X86_64)
 
 // What code is emitted for the probe?
index f4f31fe..386fcd1 100644 (file)
@@ -42,7 +42,7 @@ bool HeapCell::isLive()
     return markedBlockHandle.isLive(this);
 }
 
-#if !COMPILER(GCC_OR_CLANG)
+#if !COMPILER(GCC_COMPATIBLE)
 void HeapCell::use() const
 {
 }
index eb59e8a..09ca433 100644 (file)
@@ -77,7 +77,7 @@ public:
     // Call use() after the last point where you need `this` pointer to be kept alive. You usually don't
     // need to use this, but it might be necessary if you're otherwise referring to an object's innards
     // but not the object itself.
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
     void use() const
     {
         asm volatile ("" : : "r"(this) : "memory");
index 1375bb9..95cccfb 100644 (file)
@@ -47,7 +47,7 @@ extern "C" EncodedJSValue HOST_CALL_RETURN_VALUE_OPTION getHostCallReturnValueWi
     return JSValue::encode(exec->vm().hostCallReturnValue);
 }
 
-#if COMPILER(GCC_OR_CLANG) && CPU(X86_64)
+#if COMPILER(GCC_COMPATIBLE) && CPU(X86_64)
 asm (
 ".globl " SYMBOL_STRING(getHostCallReturnValue) "\n"
 HIDE_SYMBOL(getHostCallReturnValue) "\n"
@@ -56,7 +56,7 @@ SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
     "jmp " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
 );
 
-#elif COMPILER(GCC_OR_CLANG) && CPU(X86)
+#elif COMPILER(GCC_COMPATIBLE) && CPU(X86)
 asm (
 ".text" "\n" \
 ".globl " SYMBOL_STRING(getHostCallReturnValue) "\n"
@@ -72,7 +72,7 @@ SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
     "ret\n"
 );
 
-#elif COMPILER(GCC_OR_CLANG) && CPU(ARM_THUMB2)
+#elif COMPILER(GCC_COMPATIBLE) && CPU(ARM_THUMB2)
 asm (
 ".text" "\n"
 ".align 2" "\n"
@@ -85,7 +85,7 @@ SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
     "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
 );
 
-#elif COMPILER(GCC_OR_CLANG) && CPU(ARM_TRADITIONAL)
+#elif COMPILER(GCC_COMPATIBLE) && CPU(ARM_TRADITIONAL)
 asm (
 ".text" "\n"
 ".globl " SYMBOL_STRING(getHostCallReturnValue) "\n"
@@ -107,7 +107,7 @@ SYMBOL_STRING(getHostCallReturnValue) ":" "\n"
      "b " LOCAL_REFERENCE(getHostCallReturnValueWithExecState) "\n"
 );
 
-#elif COMPILER(GCC_OR_CLANG) && CPU(MIPS)
+#elif COMPILER(GCC_COMPATIBLE) && CPU(MIPS)
 
 #if WTF_MIPS_PIC
 #define LOAD_FUNCTION_TO_T9(function) \
index d211d14..51987ea 100644 (file)
@@ -39,7 +39,7 @@ namespace JSC {
 
 extern "C" EncodedJSValue HOST_CALL_RETURN_VALUE_OPTION getHostCallReturnValue() REFERENCED_FROM_ASM WTF_INTERNAL;
 
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 
 // This is a public declaration only to convince CLANG not to elide it.
 extern "C" EncodedJSValue HOST_CALL_RETURN_VALUE_OPTION getHostCallReturnValueWithExecState(ExecState*) REFERENCED_FROM_ASM WTF_INTERNAL;
@@ -49,11 +49,11 @@ inline void initializeHostCallReturnValue()
     getHostCallReturnValueWithExecState(0);
 }
 
-#else // COMPILER(GCC_OR_CLANG)
+#else // COMPILER(GCC_COMPATIBLE)
 
 inline void initializeHostCallReturnValue() { }
 
-#endif // COMPILER(GCC_OR_CLANG)
+#endif // COMPILER(GCC_COMPATIBLE)
 
 } // namespace JSC
 
index 593d5bf..e92bdf8 100644 (file)
@@ -29,7 +29,7 @@
 
 // We've run into some problems where changing the size of the class JIT leads to
 // performance fluctuations. Try forcing alignment in an attempt to stabilize this.
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 #define JIT_CLASS_ALIGNMENT alignas(32)
 #else
 #define JIT_CLASS_ALIGNMENT
index 7aacf6b..fd425d8 100644 (file)
@@ -2462,10 +2462,10 @@ void JIT_OPERATION operationExceptionFuzz(ExecState* exec)
     NativeCallFrameTracer tracer(vm, exec);
     auto scope = DECLARE_THROW_SCOPE(*vm);
     UNUSED_PARAM(scope);
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
     void* returnPC = __builtin_return_address(0);
     doExceptionFuzzing(exec, scope, "JITOperations", returnPC);
-#endif // COMPILER(GCC_OR_CLANG)
+#endif // COMPILER(GCC_COMPATIBLE)
 }
 
 ALWAYS_INLINE static EncodedJSValue unprofiledAdd(ExecState* exec, EncodedJSValue encodedOp1, EncodedJSValue encodedOp2)
index dd5d830..febd5f2 100644 (file)
@@ -772,7 +772,7 @@ MacroAssemblerCodeRef<JITThunkPtrTag> sqrtThunkGenerator(VM* vm)
 enum MathThunkCallingConvention { };
 typedef MathThunkCallingConvention(*MathThunk)(MathThunkCallingConvention);
 
-#if CPU(X86_64) && COMPILER(GCC_OR_CLANG) && (OS(DARWIN) || OS(LINUX))
+#if CPU(X86_64) && COMPILER(GCC_COMPATIBLE) && (OS(DARWIN) || OS(LINUX))
 
 #define defineUnaryDoubleOpWrapper(function) \
     asm( \
@@ -790,7 +790,7 @@ typedef MathThunkCallingConvention(*MathThunk)(MathThunkCallingConvention);
     } \
     static MathThunk UnaryDoubleOpWrapper(function) = &function##Thunk;
 
-#elif CPU(X86) && COMPILER(GCC_OR_CLANG) && OS(LINUX) && defined(__PIC__)
+#elif CPU(X86) && COMPILER(GCC_COMPATIBLE) && OS(LINUX) && defined(__PIC__)
 #define defineUnaryDoubleOpWrapper(function) \
     asm( \
         ".text\n" \
@@ -814,7 +814,7 @@ typedef MathThunkCallingConvention(*MathThunk)(MathThunkCallingConvention);
     } \
     static MathThunk UnaryDoubleOpWrapper(function) = &function##Thunk;
 
-#elif CPU(X86) && COMPILER(GCC_OR_CLANG) && (OS(DARWIN) || OS(LINUX))
+#elif CPU(X86) && COMPILER(GCC_COMPATIBLE) && (OS(DARWIN) || OS(LINUX))
 #define defineUnaryDoubleOpWrapper(function) \
     asm( \
         ".text\n" \
@@ -834,7 +834,7 @@ typedef MathThunkCallingConvention(*MathThunk)(MathThunkCallingConvention);
     } \
     static MathThunk UnaryDoubleOpWrapper(function) = &function##Thunk;
 
-#elif CPU(ARM_THUMB2) && COMPILER(GCC_OR_CLANG) && PLATFORM(IOS)
+#elif CPU(ARM_THUMB2) && COMPILER(GCC_COMPATIBLE) && PLATFORM(IOS)
 
 #define defineUnaryDoubleOpWrapper(function) \
     asm( \
index 69a4789..95ad638 100644 (file)
@@ -33,7 +33,7 @@ namespace JSC {
 #if USE(JSVALUE64)
 void clearArrayMemset(WriteBarrier<Unknown>* base, unsigned count)
 {
-#if CPU(X86_64) && COMPILER(GCC_OR_CLANG)
+#if CPU(X86_64) && COMPILER(GCC_COMPATIBLE)
     uint64_t zero = 0;
     asm volatile (
         "rep stosq\n\t"
@@ -48,7 +48,7 @@ void clearArrayMemset(WriteBarrier<Unknown>* base, unsigned count)
 
 void clearArrayMemset(double* base, unsigned count)
 {
-#if CPU(X86_64) && COMPILER(GCC_OR_CLANG)
+#if CPU(X86_64) && COMPILER(GCC_COMPATIBLE)
     uint64_t pnan = bitwise_cast<uint64_t>(PNaN);
     asm volatile (
         "rep stosq\n\t"
index ba355bd..da529d3 100644 (file)
@@ -468,7 +468,7 @@ inline JSBigInt::Digit JSBigInt::digitPow(Digit base, Digit exponent)
 inline JSBigInt::Digit JSBigInt::digitDiv(Digit high, Digit low, Digit divisor, Digit& remainder)
 {
     ASSERT(high < divisor);
-#if CPU(X86_64) && COMPILER(GCC_OR_CLANG)
+#if CPU(X86_64) && COMPILER(GCC_COMPATIBLE)
     Digit quotient;
     Digit rem;
     __asm__("divq  %[divisor]"
@@ -479,7 +479,7 @@ inline JSBigInt::Digit JSBigInt::digitDiv(Digit high, Digit low, Digit divisor,
         : "d"(high), "a"(low), [divisor] "rm"(divisor));
     remainder = rem;
     return quotient;
-#elif CPU(X86) && COMPILER(GCC_OR_CLANG)
+#elif CPU(X86) && COMPILER(GCC_COMPATIBLE)
     Digit quotient;
     Digit rem;
     __asm__("divl  %[divisor]"
index 9f498d4..df746c4 100644 (file)
@@ -1,3 +1,36 @@
+2018-09-24  Fujii Hironori  <Hironori.Fujii@sony.com>
+
+        Rename WTF_COMPILER_GCC_OR_CLANG to WTF_COMPILER_GCC_COMPATIBLE
+        https://bugs.webkit.org/show_bug.cgi?id=189733
+
+        Reviewed by Michael Catanzaro.
+
+        Clang for Windows build enables WTF_COMPILER_CLANG and
+        WTF_COMPILER_MSVC, but disables WTF_COMPILER_GCC_OR_CLANG. It is
+        strange WTF_COMPILER_GCC_OR_CLANG is not enabled even though
+        WTF_COMPILER_CLANG is enabled. However, Clang for Windows imitates
+        MSVC, and codes for COMPILER(GCC_OR_CLANG) are for non MSVC. At
+        least at the moment, it is not feasible to define
+        WTF_COMPILER_GCC_OR_CLANG for Clang for Windows.
+
+        To solve the issue, this change renames WTF_COMPILER_GCC_OR_CLANG
+        to WTF_COMPILER_GCC_COMPATIBLE.
+
+        As an exception, I'd like to use IGNORE_WARNINGS_* macros even in
+        Clang for Windows builds.
+
+        * wtf/Assertions.cpp: Replaced COMPILER(GCC_OR_CLANG) with COMPILER(GCC_COMPATIBLE).
+        * wtf/Assertions.h: Ditto.
+        * wtf/Atomics.h: Ditto.
+        * wtf/CheckedArithmetic.h: Ditto.
+        * wtf/FastMalloc.h: Ditto.
+        * wtf/MathExtras.h: Ditto.
+        * wtf/Platform.h: Ditto.
+        * wtf/StdLibExtras.h: Ditto.
+        * wtf/Vector.h: Ditto.
+        * wtf/text/ASCIIFastPath.h: Ditto.
+        * wtf/Compiler.h:  Ditto. Replaced "COMPILER(GCC_OR_CLANG)" with "COMPILER(GCC) || COMPILER(CLANG)" of IGNORE_WARNINGS_* macros.
+
 2018-09-21  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
 
         [JSC] Enable LLInt ASM interpreter on X64 and ARM64 in non JIT configuration
index 2b9460a..4dbe184 100644 (file)
@@ -254,11 +254,11 @@ void WTFCrash()
 #else
     *(int *)(uintptr_t)0xbbadbeef = 0;
     // More reliable, but doesn't say BBADBEEF.
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
     __builtin_trap();
 #else
     ((void(*)())0)();
-#endif // COMPILER(GCC_OR_CLANG)
+#endif // COMPILER(GCC_COMPATIBLE)
 #endif // ASAN_ENABLED
 }
 #else
index f567a22..f782513 100644 (file)
@@ -55,7 +55,7 @@
 #include <type_traits>
 
 #if OS(WINDOWS)
-#if !COMPILER(GCC_OR_CLANG)
+#if !COMPILER(GCC_COMPATIBLE)
 extern "C" void _ReadWriteBarrier(void);
 #pragma intrinsic(_ReadWriteBarrier)
 #endif
@@ -102,7 +102,7 @@ extern "C" void _ReadWriteBarrier(void);
 #define RELEASE_LOG_DISABLED !(USE(OS_LOG))
 #endif
 
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 #define WTF_PRETTY_FUNCTION __PRETTY_FUNCTION__
 #else
 #define WTF_PRETTY_FUNCTION __FUNCTION__
@@ -111,7 +111,7 @@ extern "C" void _ReadWriteBarrier(void);
 #if COMPILER(MINGW)
 /* By default MinGW emits warnings when C99 format attributes are used, even if __USE_MINGW_ANSI_STDIO is defined */
 #define WTF_ATTRIBUTE_PRINTF(formatStringArgument, extraArguments) __attribute__((__format__(gnu_printf, formatStringArgument, extraArguments)))
-#elif COMPILER(GCC_OR_CLANG) && !defined(__OBJC__)
+#elif COMPILER(GCC_COMPATIBLE) && !defined(__OBJC__)
 /* WTF logging functions can process %@ in the format string to log a NSObject* but the printf format attribute
    emits a warning when %@ is used in the format string.  Until <rdar://problem/5195437> is resolved we can't include
    the attribute when being used from Objective-C code in case it decides to use %@. */
@@ -141,7 +141,7 @@ extern "C" {
 
    Signals are ignored by the crash reporter on OS X so we must do better.
 */
-#if COMPILER(GCC_OR_CLANG) || COMPILER(MSVC)
+#if COMPILER(GCC_COMPATIBLE) || COMPILER(MSVC)
 #define NO_RETURN_DUE_TO_CRASH NO_RETURN
 #else
 #define NO_RETURN_DUE_TO_CRASH
@@ -564,7 +564,7 @@ void isIntegralType(T, Types... types)
 
 inline void compilerFenceForCrash()
 {
-#if OS(WINDOWS) && !COMPILER(GCC_OR_CLANG)
+#if OS(WINDOWS) && !COMPILER(GCC_COMPATIBLE)
     _ReadWriteBarrier();
 #else
     asm volatile("" ::: "memory");
index 6d75f2a..61ffd48 100644 (file)
@@ -30,7 +30,7 @@
 #include <wtf/StdLibExtras.h>
 
 #if OS(WINDOWS)
-#if !COMPILER(GCC_OR_CLANG)
+#if !COMPILER(GCC_COMPATIBLE)
 extern "C" void _ReadWriteBarrier(void);
 #pragma intrinsic(_ReadWriteBarrier)
 #endif
@@ -242,7 +242,7 @@ inline T atomicExchange(T* location, T newValue, std::memory_order order = std::
 // to do things like register allocation and code motion over pure operations.
 inline void compilerFence()
 {
-#if OS(WINDOWS) && !COMPILER(GCC_OR_CLANG)
+#if OS(WINDOWS) && !COMPILER(GCC_COMPATIBLE)
     _ReadWriteBarrier();
 #else
     asm volatile("" ::: "memory");
index e668bf8..b93e363 100644 (file)
@@ -270,7 +270,7 @@ template <typename LHS, typename RHS, typename ResultType> struct ArithmeticOper
 
     static inline bool add(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
     {
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
         ResultType temp;
         if (__builtin_add_overflow(lhs, rhs, &temp))
             return false;
@@ -294,7 +294,7 @@ template <typename LHS, typename RHS, typename ResultType> struct ArithmeticOper
 
     static inline bool sub(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
     {
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
         ResultType temp;
         if (__builtin_sub_overflow(lhs, rhs, &temp))
             return false;
@@ -317,7 +317,7 @@ template <typename LHS, typename RHS, typename ResultType> struct ArithmeticOper
 
     static inline bool multiply(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
     {
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
         ResultType temp;
         if (__builtin_mul_overflow(lhs, rhs, &temp))
             return false;
@@ -356,7 +356,7 @@ template <typename LHS, typename RHS, typename ResultType> struct ArithmeticOper
     // LHS and RHS are unsigned types so bounds checks are nice and easy
     static inline bool add(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
     {
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
         ResultType temp;
         if (__builtin_add_overflow(lhs, rhs, &temp))
             return false;
@@ -373,7 +373,7 @@ template <typename LHS, typename RHS, typename ResultType> struct ArithmeticOper
 
     static inline bool sub(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
     {
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
         ResultType temp;
         if (__builtin_sub_overflow(lhs, rhs, &temp))
             return false;
@@ -390,7 +390,7 @@ template <typename LHS, typename RHS, typename ResultType> struct ArithmeticOper
 
     static inline bool multiply(LHS lhs, RHS rhs, ResultType& result) WARN_UNUSED_RETURN
     {
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
         ResultType temp;
         if (__builtin_mul_overflow(lhs, rhs, &temp))
             return false;
@@ -415,7 +415,7 @@ template <typename LHS, typename RHS, typename ResultType> struct ArithmeticOper
 template <typename ResultType> struct ArithmeticOperations<int, unsigned, ResultType, true, false> {
     static inline bool add(int64_t lhs, int64_t rhs, ResultType& result)
     {
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
         ResultType temp;
         if (__builtin_add_overflow(lhs, rhs, &temp))
             return false;
@@ -434,7 +434,7 @@ template <typename ResultType> struct ArithmeticOperations<int, unsigned, Result
     
     static inline bool sub(int64_t lhs, int64_t rhs, ResultType& result)
     {
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
         ResultType temp;
         if (__builtin_sub_overflow(lhs, rhs, &temp))
             return false;
@@ -453,7 +453,7 @@ template <typename ResultType> struct ArithmeticOperations<int, unsigned, Result
 
     static inline bool multiply(int64_t lhs, int64_t rhs, ResultType& result)
     {
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
         ResultType temp;
         if (__builtin_mul_overflow(lhs, rhs, &temp))
             return false;
index 90ce482..ce164f4 100644 (file)
 
 #endif // defined(__clang__)
 
-/* COMPILER(GCC_OR_CLANG) - GNU Compiler Collection or Clang */
+/* COMPILER(GCC_COMPATIBLE) - GNU Compiler Collection or compatibles */
 #if defined(__GNUC__)
-#define WTF_COMPILER_GCC_OR_CLANG 1
+#define WTF_COMPILER_GCC_COMPATIBLE 1
 #endif
 
 /* COMPILER(GCC) - GNU Compiler Collection */
 /* Note: This section must come after the Clang section since we check !COMPILER(CLANG) here. */
-#if COMPILER(GCC_OR_CLANG) && !COMPILER(CLANG)
+#if COMPILER(GCC_COMPATIBLE) && !COMPILER(CLANG)
 #define WTF_COMPILER_GCC 1
 
 #define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 
 #endif /* COMPILER(GCC) */
 
-#if COMPILER(GCC_OR_CLANG) && defined(NDEBUG) && !defined(__OPTIMIZE__) && !defined(RELEASE_WITHOUT_OPTIMIZATIONS)
+#if COMPILER(GCC_COMPATIBLE) && defined(NDEBUG) && !defined(__OPTIMIZE__) && !defined(RELEASE_WITHOUT_OPTIMIZATIONS)
 #error "Building release without compiler optimizations: WebKit will be slow. Set -DRELEASE_WITHOUT_OPTIMIZATIONS if this is intended."
 #endif
 
 
 /* In GCC functions marked with no_sanitize_address cannot call functions that are marked with always_inline and not marked with no_sanitize_address.
  * Therefore we need to give up on the enforcement of ALWAYS_INLINE when bulding with ASAN. https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368 */
-#if !defined(ALWAYS_INLINE) && COMPILER(GCC_OR_CLANG) && defined(NDEBUG) && !COMPILER(MINGW) && !(COMPILER(GCC) && ASAN_ENABLED)
+#if !defined(ALWAYS_INLINE) && COMPILER(GCC_COMPATIBLE) && defined(NDEBUG) && !COMPILER(MINGW) && !(COMPILER(GCC) && ASAN_ENABLED)
 #define ALWAYS_INLINE inline __attribute__((__always_inline__))
 #endif
 
 
 /* LIKELY */
 
-#if !defined(LIKELY) && COMPILER(GCC_OR_CLANG)
+#if !defined(LIKELY) && COMPILER(GCC_COMPATIBLE)
 #define LIKELY(x) __builtin_expect(!!(x), 1)
 #endif
 
 
 /* NEVER_INLINE */
 
-#if !defined(NEVER_INLINE) && COMPILER(GCC_OR_CLANG)
+#if !defined(NEVER_INLINE) && COMPILER(GCC_COMPATIBLE)
 #define NEVER_INLINE __attribute__((__noinline__))
 #endif
 
 
 /* NO_RETURN */
 
-#if !defined(NO_RETURN) && COMPILER(GCC_OR_CLANG)
+#if !defined(NO_RETURN) && COMPILER(GCC_COMPATIBLE)
 #define NO_RETURN __attribute((__noreturn__))
 #endif
 
 #endif
 
 /* RETURNS_NONNULL */
-#if !defined(RETURNS_NONNULL) && COMPILER(GCC_OR_CLANG)
+#if !defined(RETURNS_NONNULL) && COMPILER(GCC_COMPATIBLE)
 #define RETURNS_NONNULL __attribute__((returns_nonnull))
 #endif
 
 
 /* PURE_FUNCTION */
 
-#if !defined(PURE_FUNCTION) && COMPILER(GCC_OR_CLANG)
+#if !defined(PURE_FUNCTION) && COMPILER(GCC_COMPATIBLE)
 #define PURE_FUNCTION __attribute__((__pure__))
 #endif
 
 
 /* UNUSED_FUNCTION */
 
-#if !defined(UNUSED_FUNCTION) && COMPILER(GCC_OR_CLANG)
+#if !defined(UNUSED_FUNCTION) && COMPILER(GCC_COMPATIBLE)
 #define UNUSED_FUNCTION __attribute__((unused))
 #endif
 
 
 /* REFERENCED_FROM_ASM */
 
-#if !defined(REFERENCED_FROM_ASM) && COMPILER(GCC_OR_CLANG)
+#if !defined(REFERENCED_FROM_ASM) && COMPILER(GCC_COMPATIBLE)
 #define REFERENCED_FROM_ASM __attribute__((__used__))
 #endif
 
 
 /* UNLIKELY */
 
-#if !defined(UNLIKELY) && COMPILER(GCC_OR_CLANG)
+#if !defined(UNLIKELY) && COMPILER(GCC_COMPATIBLE)
 #define UNLIKELY(x) __builtin_expect(!!(x), 0)
 #endif
 
 
 /* WARN_UNUSED_RETURN */
 
-#if !defined(WARN_UNUSED_RETURN) && COMPILER(GCC_OR_CLANG)
+#if !defined(WARN_UNUSED_RETURN) && COMPILER(GCC_COMPATIBLE)
 #define WARN_UNUSED_RETURN __attribute__((__warn_unused_result__))
 #endif
 
 
 #define _COMPILER_WARNING_NAME(warning) "-W" warning
 
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC) || COMPILER(CLANG)
 #define IGNORE_WARNINGS_BEGIN_COND(cond, compiler, warning) \
     _Pragma(_COMPILER_STRINGIZE(compiler diagnostic push)) \
     _COMPILER_CONCAT(IGNORE_WARNINGS_BEGIN_IMPL_, cond)(compiler, warning)
 #define IGNORE_WARNINGS_BEGIN_IMPL(compiler, warning) \
     _IGNORE_WARNINGS_BEGIN_IMPL(compiler, _COMPILER_WARNING_NAME(warning))
 
-#endif // COMPILER(GCC_OR_CLANG)
+#endif // COMPILER(GCC) || COMPILER(CLANG)
 
 
 #if COMPILER(GCC)
 #define IGNORE_CLANG_WARNINGS_END
 #endif
 
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC) || COMPILER(CLANG)
 #define IGNORE_WARNINGS_BEGIN(warning) IGNORE_WARNINGS_BEGIN_IMPL(GCC, warning)
 #define IGNORE_WARNINGS_END IGNORE_WARNINGS_END_IMPL(GCC)
 #else
index 9d7d7ff..a30e25a 100644 (file)
@@ -250,9 +250,9 @@ using WTF::tryFastZeroedMalloc;
 using WTF::fastAlignedMalloc;
 using WTF::fastAlignedFree;
 
-#if COMPILER(GCC_OR_CLANG) && OS(DARWIN)
+#if COMPILER(GCC_COMPATIBLE) && OS(DARWIN)
 #define WTF_PRIVATE_INLINE __private_extern__ inline __attribute__((always_inline))
-#elif COMPILER(GCC_OR_CLANG)
+#elif COMPILER(GCC_COMPATIBLE)
 #define WTF_PRIVATE_INLINE inline __attribute__((always_inline))
 #elif COMPILER(MSVC)
 #define WTF_PRIVATE_INLINE __forceinline
index 512c160..9118112 100644 (file)
@@ -526,7 +526,7 @@ void shuffleVector(VectorType& vector, const RandomFunc& randomFunc)
 
 inline unsigned clz32(uint32_t number)
 {
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
     if (number)
         return __builtin_clz(number);
     return 32;
@@ -551,7 +551,7 @@ inline unsigned clz32(uint32_t number)
 
 inline unsigned clz64(uint64_t number)
 {
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
     if (number)
         return __builtin_clzll(number);
     return 64;
index 8835b89..87ed2fd 100644 (file)
 #define WTF_CPU_NEEDS_ALIGNED_ACCESS 1
 #endif
 
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 /* __LP64__ is not defined on 64bit Windows since it uses LLP64. Using __SIZEOF_POINTER__ is simpler. */
 #if __SIZEOF_POINTER__ == 8
 #define WTF_CPU_ADDRESS64 1
 
 /* CPU(BIG_ENDIAN) or CPU(MIDDLE_ENDIAN) or neither, as appropriate. */
 
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 #define WTF_CPU_BIG_ENDIAN 1
 #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 /* Configure the JIT */
 #if CPU(X86) && COMPILER(MSVC)
 #define JSC_HOST_CALL __fastcall
-#elif CPU(X86) && COMPILER(GCC_OR_CLANG)
+#elif CPU(X86) && COMPILER(GCC_COMPATIBLE)
 #define JSC_HOST_CALL __attribute__ ((fastcall))
 #else
 #define JSC_HOST_CALL
 #endif
 
 /* Configure the interpreter */
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 #define HAVE_COMPUTED_GOTO 1
 #endif
 
index 8892ff6..2cbea60 100644 (file)
@@ -81,7 +81,7 @@
  * - https://bugs.webkit.org/show_bug.cgi?id=38045
  * - http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43976
  */
-#if (CPU(ARM) || CPU(MIPS)) && COMPILER(GCC_OR_CLANG)
+#if (CPU(ARM) || CPU(MIPS)) && COMPILER(GCC_COMPATIBLE)
 template<typename Type>
 inline bool isPointerTypeAlignmentOkay(Type* ptr)
 {
@@ -168,7 +168,7 @@ inline size_t bitCount(uint64_t bits)
 // Macro that returns a compile time constant with the length of an array, but gives an error if passed a non-array.
 template<typename T, size_t Size> char (&ArrayLengthHelperFunction(T (&)[Size]))[Size];
 // GCC needs some help to deduce a 0 length array.
-#if COMPILER(GCC_OR_CLANG)
+#if COMPILER(GCC_COMPATIBLE)
 template<typename T> char (&ArrayLengthHelperFunction(T (&)[0]))[0];
 #endif
 #define WTF_ARRAY_LENGTH(array) sizeof(::WTF::ArrayLengthHelperFunction(array))
index cc8a248..d2bcf5a 100644 (file)
@@ -201,7 +201,7 @@ struct VectorFiller<true, T>
     static void uninitializedFill(T* dst, T* dstEnd, const T& val) 
     {
         static_assert(sizeof(T) == 1, "Size of type T should be equal to one!");
-#if COMPILER(GCC_OR_CLANG) && defined(_FORTIFY_SOURCE)
+#if COMPILER(GCC_COMPATIBLE) && defined(_FORTIFY_SOURCE)
         if (!__builtin_constant_p(dstEnd - dst) || (!(dstEnd - dst)))
 #endif
             memset(dst, val, dstEnd - dst);
index cc07efb..7e68f2b 100644 (file)
@@ -139,7 +139,7 @@ inline void copyLCharsFromUCharSource(LChar* destination, const UChar* source, s
         ASSERT(!(source[i] & 0xff00));
         destination[i] = static_cast<LChar>(source[i]);
     }
-#elif COMPILER(GCC_OR_CLANG) && CPU(ARM64) && !defined(__ILP32__) && defined(NDEBUG)
+#elif COMPILER(GCC_COMPATIBLE) && CPU(ARM64) && !defined(__ILP32__) && defined(NDEBUG)
     const LChar* const end = destination + length;
     const uintptr_t memoryAccessSize = 16;
 
@@ -160,7 +160,7 @@ inline void copyLCharsFromUCharSource(LChar* destination, const UChar* source, s
 
     while (destination != end)
         *destination++ = static_cast<LChar>(*source++);
-#elif COMPILER(GCC_OR_CLANG) && CPU(ARM_NEON) && !(CPU(BIG_ENDIAN) || CPU(MIDDLE_ENDIAN)) && defined(NDEBUG)
+#elif COMPILER(GCC_COMPATIBLE) && CPU(ARM_NEON) && !(CPU(BIG_ENDIAN) || CPU(MIDDLE_ENDIAN)) && defined(NDEBUG)
     const LChar* const end = destination + length;
     const uintptr_t memoryAccessSize = 8;
 
index 5c82f5e..ce5a163 100644 (file)
@@ -1,3 +1,18 @@
+2018-09-24  Fujii Hironori  <Hironori.Fujii@sony.com>
+
+        Rename WTF_COMPILER_GCC_OR_CLANG to WTF_COMPILER_GCC_COMPATIBLE
+        https://bugs.webkit.org/show_bug.cgi?id=189733
+
+        Reviewed by Michael Catanzaro.
+
+        No new tests (No behavior change).
+
+        * platform/graphics/cpu/arm/filters/FELightingNEON.cpp:
+        * platform/graphics/cpu/arm/filters/FELightingNEON.h:
+        * platform/graphics/filters/FELighting.cpp:
+        (WebCore::FELighting::platformApply):
+        * platform/graphics/filters/FELighting.h:
+
 2018-09-24  John Wilander  <wilander@apple.com>
 
         Cap lifetime of persistent cookies created client-side through document.cookie
index 73e32b8..64950d1 100644 (file)
@@ -27,7 +27,7 @@
 #include "config.h"
 #include "FELightingNEON.h"
 
-#if CPU(ARM_NEON) && CPU(ARM_TRADITIONAL) && COMPILER(GCC_OR_CLANG)
+#if CPU(ARM_NEON) && CPU(ARM_TRADITIONAL) && COMPILER(GCC_COMPATIBLE)
 
 namespace WebCore {
 
@@ -500,4 +500,4 @@ int FELighting::getPowerCoefficients(float exponent)
 
 } // namespace WebCore
 
-#endif // CPU(ARM_NEON) && COMPILER(GCC_OR_CLANG)
+#endif // CPU(ARM_NEON) && COMPILER(GCC_COMPATIBLE)
index b542a4c..8e9f0d1 100644 (file)
@@ -27,7 +27,7 @@
 #ifndef FELightingNEON_h
 #define FELightingNEON_h
 
-#if CPU(ARM_NEON) && CPU(ARM_TRADITIONAL) && COMPILER(GCC_OR_CLANG)
+#if CPU(ARM_NEON) && CPU(ARM_TRADITIONAL) && COMPILER(GCC_COMPATIBLE)
 
 #include "FELighting.h"
 #include "PointLightSource.h"
@@ -196,6 +196,6 @@ inline void FELighting::platformApplyNeon(const LightingData& data, const LightS
 
 } // namespace WebCore
 
-#endif // CPU(ARM_NEON) && COMPILER(GCC_OR_CLANG)
+#endif // CPU(ARM_NEON) && COMPILER(GCC_COMPATIBLE)
 
 #endif // FELightingNEON_h
index 781a798..8878808 100644 (file)
@@ -380,7 +380,7 @@ void FELighting::platformApplyGeneric(const LightingData& data, const LightSourc
 inline void FELighting::platformApply(const LightingData& data, const LightSource::PaintingData& paintingData)
 {
     // The selection here eventually should happen dynamically on some platforms.
-#if CPU(ARM_NEON) && CPU(ARM_TRADITIONAL) && COMPILER(GCC_OR_CLANG)
+#if CPU(ARM_NEON) && CPU(ARM_TRADITIONAL) && COMPILER(GCC_COMPATIBLE)
     platformApplyNeon(data, paintingData);
 #else
     platformApplyGeneric(data, paintingData);
index ce173e0..7f3ceec 100644 (file)
@@ -147,7 +147,7 @@ protected:
     void platformApplyGenericPaint(const LightingData&, const LightSource::PaintingData&, int startX, int startY);
     void platformApplyGeneric(const LightingData&, const LightSource::PaintingData&);
 
-#if CPU(ARM_NEON) && CPU(ARM_TRADITIONAL) && COMPILER(GCC_OR_CLANG)
+#if CPU(ARM_NEON) && CPU(ARM_TRADITIONAL) && COMPILER(GCC_COMPATIBLE)
     static int getPowerCoefficients(float exponent);
     inline void platformApplyNeon(const LightingData&, const LightSource::PaintingData&);
 #endif
index d469040..40e887d 100644 (file)
@@ -1,3 +1,12 @@
+2018-09-24  Fujii Hironori  <Hironori.Fujii@sony.com>
+
+        Rename WTF_COMPILER_GCC_OR_CLANG to WTF_COMPILER_GCC_COMPATIBLE
+        https://bugs.webkit.org/show_bug.cgi?id=189733
+
+        Reviewed by Michael Catanzaro.
+
+        * bmalloc/BCompiler.h:
+
 2018-08-27  Keith Rollin  <krollin@apple.com>
 
         Unreviewed build fix -- disable LTO for production builds
index 055326e..4ef835a 100644 (file)
 
 #define BASAN_ENABLED BCOMPILER_HAS_CLANG_FEATURE(address_sanitizer)
 
-/* BCOMPILER(GCC_OR_CLANG) - GNU Compiler Collection or Clang */
+/* BCOMPILER(GCC_COMPATIBLE) - GNU Compiler Collection or compatibles */
 
 #if defined(__GNUC__)
-#define BCOMPILER_GCC_OR_CLANG 1
+#define BCOMPILER_GCC_COMPATIBLE 1
 #endif
 
 /* BNO_RETURN */
 
-#if !defined(BNO_RETURN) && BCOMPILER(GCC_OR_CLANG)
+#if !defined(BNO_RETURN) && BCOMPILER(GCC_COMPATIBLE)
 #define BNO_RETURN __attribute((__noreturn__))
 #endif