Attachment 340969 Details for Bug 185861 – Patch

[patch] Patch

bug-185861-20180522200630.patch (text/plain), 36.63 KB, created by Yusuke Suzuki on 2018-05-22 04:06:31 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Yusuke Suzuki

Created: 2018-05-22 04:06:31 PDT

Size: 36.63 KB

patch

obsolete

>Subversion Revision: 232059
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 4a8e76f81fb93d9a81585985eb4bd9b592c0a7ef..c2fb8ed808335b05bf7b9414bd9573a1e7da9742 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,37 @@
>+2018-05-22  Yusuke Suzuki  <utatane.tea@gmail.com>
>+
>+        Use C++17 message-less static_assert
>+        https://bugs.webkit.org/show_bug.cgi?id=185861
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Use `static_assert(cond)` instead of `static_assert(cond, "")`.
>+
>+        * assembler/MacroAssemblerCodeRef.h:
>+        * bytecode/CodeBlockHash.cpp:
>+        (JSC::CodeBlockHash::CodeBlockHash):
>+        * bytecode/Instruction.h:
>+        * bytecode/ParseHash.cpp:
>+        (JSC::ParseHash::ParseHash):
>+        * dfg/DFGNode.h:
>+        * dfg/DFGSpeculativeJIT.cpp:
>+        (JSC::DFG::SpeculativeJIT::compileNewArrayBuffer):
>+        (JSC::DFG::SpeculativeJIT::compileWeakMapGet):
>+        * ftl/FTLLowerDFGToB3.cpp:
>+        (JSC::FTL::DFG::LowerDFGToB3::compileArrayPush):
>+        (JSC::FTL::DFG::LowerDFGToB3::compileWeakMapGet):
>+        * jit/JITOpcodes32_64.cpp:
>+        (JSC::JIT::emit_op_jeq_null):
>+        (JSC::JIT::emit_op_jneq_null):
>+        * llint/LLIntData.cpp:
>+        (JSC::LLInt::Data::performAssertions):
>+        * runtime/JSBigInt.cpp:
>+        (JSC::JSBigInt::inplaceMultiplyAdd):
>+        (JSC::JSBigInt::digitDiv):
>+        * runtime/NativeFunction.h:
>+        * runtime/TypedArrayType.h:
>+        * runtime/WeakMapImpl.h:
>+
> 2018-05-21  Yusuke Suzuki  <utatane.tea@gmail.com>
> 
>         Use more C++17
>diff --git a/Source/WTF/ChangeLog b/Source/WTF/ChangeLog
>index 44d39f0054404c2e104b9a1c5fd4e3716ecdd6ae..2412016931151268f96f2130ee6b4a39132877ff 100644
>--- a/Source/WTF/ChangeLog
>+++ b/Source/WTF/ChangeLog
>@@ -1,3 +1,28 @@
>+2018-05-22  Yusuke Suzuki  <utatane.tea@gmail.com>
>+
>+        Use C++17 message-less static_assert
>+        https://bugs.webkit.org/show_bug.cgi?id=185861
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * wtf/FastMalloc.h:
>+        * wtf/MallocPtr.h:
>+        * wtf/PtrTag.h:
>+        * wtf/Seconds.h:
>+        (WTF::Seconds::minutesAs const):
>+        (WTF::Seconds::secondsAs const):
>+        (WTF::Seconds::millisecondsAs const):
>+        (WTF::Seconds::microsecondsAs const):
>+        (WTF::Seconds::nanosecondsAs const):
>+        * wtf/StdLibExtras.h:
>+        (WTF::roundUpToMultipleOf):
>+        * wtf/SystemFree.h:
>+        * wtf/UniqueArray.h:
>+        (WTF::makeUniqueArray):
>+        * wtf/WTFAssertions.cpp:
>+        * wtf/text/StringImpl.h:
>+        * wtf/text/SymbolImpl.h:
>+
> 2018-05-21  Yusuke Suzuki  <utatane.tea@gmail.com>
> 
>         Use more C++17
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 5cb58510aa9fc755e02012539dbbfe4c499d22b8..814935b55270a6dc741f399a4061a1f85404e5f6 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,15 @@
>+2018-05-22  Yusuke Suzuki  <utatane.tea@gmail.com>
>+
>+        Use C++17 message-less static_assert
>+        https://bugs.webkit.org/show_bug.cgi?id=185861
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        No new tests (OOPS!).
>+
>+        * platform/KeyedCoding.h:
>+        (WebCore::KeyedDecoder::decodeBytes):
>+
> 2018-05-22  Yacine Bandou  <yacine.bandou_ext@softathome.com>
> 
>         [MSE][GStreamer] Fix the deadlock caused by bug 185242 (r231351)
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 1ed3e76dffaf9a13a9aa2d99c15bd270e39ed9e7..debaed5770a2363c52e682dcd5f3e55aca8f339b 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,15 @@
>+2018-05-22  Yusuke Suzuki  <utatane.tea@gmail.com>
>+
>+        Use C++17 message-less static_assert
>+        https://bugs.webkit.org/show_bug.cgi?id=185861
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * NetworkProcess/capture/json.hpp:
>+        * UIProcess/mac/LegacySessionStateCoding.cpp:
>+        (WebKit::HistoryEntryDataEncoder::encodeArithmeticType):
>+        (WebKit::HistoryEntryDataDecoder::decodeArithmeticType):
>+
> 2018-05-22  Carlos Garcia Campos  <cgarcia@igalia.com>
> 
>         Crash when loading a SVG image
>diff --git a/Source/bmalloc/ChangeLog b/Source/bmalloc/ChangeLog
>index 9cdb3656161f14ddcfbcc1d8ee532e7f20054bce..8c84d23a51a6f937b63c224607c0078a0e463992 100644
>--- a/Source/bmalloc/ChangeLog
>+++ b/Source/bmalloc/ChangeLog
>@@ -1,3 +1,14 @@
>+2018-05-22  Yusuke Suzuki  <utatane.tea@gmail.com>
>+
>+        Use C++17 message-less static_assert
>+        https://bugs.webkit.org/show_bug.cgi?id=185861
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * bmalloc/Algorithm.h:
>+        (bmalloc::isPowerOfTwo):
>+        * bmalloc/Gigacage.h:
>+
> 2018-05-22  Yusuke Suzuki  <utatane.tea@gmail.com>
> 
>         Define GIGACAGE_ALLOCATION_CAN_FAIL on Linux
>diff --git a/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.h b/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.h
>index fac8b86bc1bc92645eb03e718890e8180cb11c11..48433955a7b982dfc8479cdc76e3d86f162178fa 100644
>--- a/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.h
>+++ b/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.h
>@@ -161,9 +161,9 @@ class FunctionPtr {
>     template<PtrTag> friend class FunctionPtr;
> };
> 
>-static_assert(sizeof(FunctionPtr<CFunctionPtrTag>) == sizeof(void*), "");
>+static_assert(sizeof(FunctionPtr<CFunctionPtrTag>) == sizeof(void*));
> #if COMPILER_SUPPORTS(BUILTIN_IS_TRIVIALLY_COPYABLE)
>-static_assert(__is_trivially_copyable(FunctionPtr<CFunctionPtrTag>), "");
>+static_assert(__is_trivially_copyable(FunctionPtr<CFunctionPtrTag>));
> #endif
> 
> // ReturnAddressPtr:
>diff --git a/Source/JavaScriptCore/bytecode/CodeBlockHash.cpp b/Source/JavaScriptCore/bytecode/CodeBlockHash.cpp
>index ee1b03d8659772369e855a561627d8ae4c152755..96c3dc4c8ab30134895d34322a4b9f5ac47df8e0 100644
>--- a/Source/JavaScriptCore/bytecode/CodeBlockHash.cpp
>+++ b/Source/JavaScriptCore/bytecode/CodeBlockHash.cpp
>@@ -48,8 +48,8 @@ CodeBlockHash::CodeBlockHash(const SourceCode& sourceCode, CodeSpecializationKin
> 
>     if (m_hash == 0 || m_hash == 1)
>         m_hash += 0x2d5a93d0; // Ensures a non-zero hash, and gets us #Azero0 for CodeForCall and #Azero1 for CodeForConstruct.
>-    static_assert(static_cast<unsigned>(CodeForCall) == 0, "");
>-    static_assert(static_cast<unsigned>(CodeForConstruct) == 1, "");
>+    static_assert(static_cast<unsigned>(CodeForCall) == 0);
>+    static_assert(static_cast<unsigned>(CodeForConstruct) == 1);
>     m_hash ^= static_cast<unsigned>(kind);
>     ASSERT(m_hash);
> }
>diff --git a/Source/JavaScriptCore/bytecode/Instruction.h b/Source/JavaScriptCore/bytecode/Instruction.h
>index c133578b3263d3029845e48379a35960704a6efd..3a1b335592e07ec39ee971961b9639baff7062e1 100644
>--- a/Source/JavaScriptCore/bytecode/Instruction.h
>+++ b/Source/JavaScriptCore/bytecode/Instruction.h
>@@ -149,7 +149,7 @@ struct Instruction {
>     Instruction(StructureChain*);
>     Instruction(Structure*);
> };
>-static_assert(sizeof(Instruction) == sizeof(void*), "");
>+static_assert(sizeof(Instruction) == sizeof(void*));
> 
> } // namespace JSC
> 
>diff --git a/Source/JavaScriptCore/bytecode/ParseHash.cpp b/Source/JavaScriptCore/bytecode/ParseHash.cpp
>index cde1b085cb85328e29451c2f3e23b8ebbaa03252..a470e5fd92c86775d94194ebfa05bd934a3f86ac 100644
>--- a/Source/JavaScriptCore/bytecode/ParseHash.cpp
>+++ b/Source/JavaScriptCore/bytecode/ParseHash.cpp
>@@ -42,8 +42,8 @@ ParseHash::ParseHash(const SourceCode& sourceCode)
> 
>     if (hash == 0 || hash == 1)
>         hash += 0x2d5a93d0; // Ensures a non-zero hash, and gets us #Azero0 for CodeForCall and #Azero1 for CodeForConstruct.
>-    static_assert(static_cast<unsigned>(CodeForCall) == 0, "");
>-    static_assert(static_cast<unsigned>(CodeForConstruct) == 1, "");
>+    static_assert(static_cast<unsigned>(CodeForCall) == 0);
>+    static_assert(static_cast<unsigned>(CodeForConstruct) == 1);
>     unsigned hashForCall = hash ^ static_cast<unsigned>(CodeForCall);
>     unsigned hashForConstruct = hash ^ static_cast<unsigned>(CodeForConstruct);
> 
>diff --git a/Source/JavaScriptCore/dfg/DFGNode.h b/Source/JavaScriptCore/dfg/DFGNode.h
>index 6236309e62ee5ff53860b5dabbfe2b0b11d0af09..5d32632f6098d9f0a663f772ebe9b610031b7ef1 100644
>--- a/Source/JavaScriptCore/dfg/DFGNode.h
>+++ b/Source/JavaScriptCore/dfg/DFGNode.h
>@@ -114,8 +114,8 @@ struct NewArrayBufferData {
>         uint64_t asQuadWord;
>     };
> };
>-static_assert(sizeof(IndexingType) <= sizeof(unsigned), "");
>-static_assert(sizeof(NewArrayBufferData) == sizeof(uint64_t), "");
>+static_assert(sizeof(IndexingType) <= sizeof(unsigned));
>+static_assert(sizeof(NewArrayBufferData) == sizeof(uint64_t));
> 
> struct BranchTarget {
>     BranchTarget()
>diff --git a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>index 1d56d4657a783ddeebc62158fb297efa48ff0812..d07654970f9b56d1219d21d1e0eb818dbfaa0970 100644
>--- a/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>+++ b/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
>@@ -12057,7 +12057,7 @@ void SpeculativeJIT::compileNewArrayBuffer(Node* node)
>                 value = bitwise_cast<int64_t>(array->get(index).asNumber());
>             else
>                 value = JSValue::encode(array->get(index));
>-            static_assert(sizeof(double) == sizeof(JSValue), "");
>+            static_assert(sizeof(double) == sizeof(JSValue));
>             m_jit.store64(Imm64(value), MacroAssembler::Address(storageGPR, sizeof(JSValue) * index));
> #else
>             union {
>@@ -12069,7 +12069,7 @@ void SpeculativeJIT::compileNewArrayBuffer(Node* node)
>                 u.doubleValue = array->get(index).asNumber();
>             else
>                 u.encodedValue = JSValue::encode(array->get(index));
>-            static_assert(sizeof(double) == sizeof(JSValue), "");
>+            static_assert(sizeof(double) == sizeof(JSValue));
>             m_jit.store32(Imm32(u.halves[0]), MacroAssembler::Address(storageGPR, sizeof(JSValue) * index));
>             m_jit.store32(Imm32(u.halves[1]), MacroAssembler::Address(storageGPR, sizeof(JSValue) * index + sizeof(int32_t)));
> #endif
>@@ -12416,13 +12416,13 @@ void SpeculativeJIT::compileWeakMapGet(Node* node)
>     MacroAssembler::Label loop = m_jit.label();
>     m_jit.and32(maskGPR, indexGPR);
>     if (node->child1().useKind() == WeakSetObjectUse) {
>-        static_assert(sizeof(WeakMapBucket<WeakMapBucketDataKey>) == sizeof(void*), "");
>+        static_assert(sizeof(WeakMapBucket<WeakMapBucketDataKey>) == sizeof(void*));
>         m_jit.zeroExtend32ToPtr(indexGPR, bucketGPR);
>         m_jit.lshiftPtr(MacroAssembler::Imm32(sizeof(void*) == 4 ? 2 : 3), bucketGPR);
>         m_jit.addPtr(bufferGPR, bucketGPR);
>     } else {
>         ASSERT(node->child1().useKind() == WeakMapObjectUse);
>-        static_assert(sizeof(WeakMapBucket<WeakMapBucketDataKeyValue>) == 16, "");
>+        static_assert(sizeof(WeakMapBucket<WeakMapBucketDataKeyValue>) == 16);
>         m_jit.zeroExtend32ToPtr(indexGPR, bucketGPR);
>         m_jit.lshiftPtr(MacroAssembler::Imm32(4), bucketGPR);
>         m_jit.addPtr(bufferGPR, bucketGPR);
>diff --git a/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp b/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
>index 911d62ad5427ab15a3fc5c3a2d754fbb9861a144..52414f49f06a871377c14173ee8fde07000f98ca 100644
>--- a/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
>+++ b/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
>@@ -4524,7 +4524,7 @@ class LowerDFGToB3 {
> 
>             m_out.appendTo(slowPath, setup);
>             size_t scratchSize = sizeof(EncodedJSValue) * elementCount;
>-            static_assert(sizeof(EncodedJSValue) == sizeof(double), "");
>+            static_assert(sizeof(EncodedJSValue) == sizeof(double));
>             ASSERT(scratchSize);
>             ScratchBuffer* scratchBuffer = vm().scratchBufferForSize(scratchSize);
>             m_out.storePtr(m_out.constIntPtr(scratchSize), m_out.absolute(scratchBuffer->addressOfActiveLength()));
>@@ -9530,10 +9530,10 @@ class LowerDFGToB3 {
> 
>         LValue bucket;
>         if (m_node->child1().useKind() == WeakMapObjectUse) {
>-            static_assert(sizeof(WeakMapBucket<WeakMapBucketDataKeyValue>) == 16, "");
>+            static_assert(sizeof(WeakMapBucket<WeakMapBucketDataKeyValue>) == 16);
>             bucket = m_out.add(buffer, m_out.shl(m_out.zeroExt(index, Int64), m_out.constInt32(4)));
>         } else {
>-            static_assert(sizeof(WeakMapBucket<WeakMapBucketDataKey>) == 8, "");
>+            static_assert(sizeof(WeakMapBucket<WeakMapBucketDataKey>) == 8);
>             bucket = m_out.add(buffer, m_out.shl(m_out.zeroExt(index, Int64), m_out.constInt32(3)));
>         }
> 
>diff --git a/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp b/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp
>index 44955e359b749978ede12eb8e80f4903eaa9d133..84846cb4462de9162fa750863ae097c9821456a4 100644
>--- a/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp
>+++ b/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp
>@@ -387,7 +387,7 @@ void JIT::emit_op_jeq_null(Instruction* currentInstruction)
> 
>     // Now handle the immediate cases - undefined & null
>     isImmediate.link(this);
>-    static_assert((JSValue::UndefinedTag + 1 == JSValue::NullTag) && (JSValue::NullTag & 0x1), "");
>+    static_assert((JSValue::UndefinedTag + 1 == JSValue::NullTag) && (JSValue::NullTag & 0x1));
>     or32(TrustedImm32(1), regT1);
>     addJump(branchIfNull(regT1), target);
> 
>@@ -413,7 +413,7 @@ void JIT::emit_op_jneq_null(Instruction* currentInstruction)
>     // Now handle the immediate cases - undefined & null
>     isImmediate.link(this);
> 
>-    static_assert((JSValue::UndefinedTag + 1 == JSValue::NullTag) && (JSValue::NullTag & 0x1), "");
>+    static_assert((JSValue::UndefinedTag + 1 == JSValue::NullTag) && (JSValue::NullTag & 0x1));
>     or32(TrustedImm32(1), regT1);
>     addJump(branchIfNotNull(regT1), target);
> 
>diff --git a/Source/JavaScriptCore/llint/LLIntData.cpp b/Source/JavaScriptCore/llint/LLIntData.cpp
>index c93d15c74c58ff5d96aa0aad943413f085a3d92e..a7910b6bb07e27cf50e16a620e80f0be4e3ba5dc 100644
>--- a/Source/JavaScriptCore/llint/LLIntData.cpp
>+++ b/Source/JavaScriptCore/llint/LLIntData.cpp
>@@ -39,8 +39,6 @@
> #include "ShadowChicken.h"
> #include "WriteBarrier.h"
> 
>-#define STATIC_ASSERT(cond) static_assert(cond, "LLInt assumes " #cond)
>-
> namespace JSC { namespace LLInt {
> 
> Instruction Data::s_exceptionInstructions[maxOpcodeLength + 1] = { };
>@@ -87,18 +85,18 @@ void Data::performAssertions(VM& vm)
> #endif
>     const ptrdiff_t SlotSize = 8;
> 
>-    STATIC_ASSERT(sizeof(void*) == PtrSize);
>-    STATIC_ASSERT(sizeof(Register) == SlotSize);
>-    STATIC_ASSERT(CallFrame::headerSizeInRegisters == CallFrameHeaderSlots);
>+    static_assert(sizeof(void*) == PtrSize);
>+    static_assert(sizeof(Register) == SlotSize);
>+    static_assert(CallFrame::headerSizeInRegisters == CallFrameHeaderSlots);
> 
>     ASSERT(!CallFrame::callerFrameOffset());
>-    STATIC_ASSERT(CallerFrameAndPC::sizeInRegisters == (PtrSize * 2) / SlotSize);
>+    static_assert(CallerFrameAndPC::sizeInRegisters == (PtrSize * 2) / SlotSize);
>     ASSERT(CallFrame::returnPCOffset() == CallFrame::callerFrameOffset() + PtrSize);
>     ASSERT(CallFrameSlot::codeBlock * sizeof(Register) == CallFrame::returnPCOffset() + PtrSize);
>-    STATIC_ASSERT(CallFrameSlot::callee * sizeof(Register) == CallFrameSlot::codeBlock * sizeof(Register) + SlotSize);
>-    STATIC_ASSERT(CallFrameSlot::argumentCount * sizeof(Register) == CallFrameSlot::callee * sizeof(Register) + SlotSize);
>-    STATIC_ASSERT(CallFrameSlot::thisArgument * sizeof(Register) == CallFrameSlot::argumentCount * sizeof(Register) + SlotSize);
>-    STATIC_ASSERT(CallFrame::headerSizeInRegisters == CallFrameSlot::thisArgument);
>+    static_assert(CallFrameSlot::callee * sizeof(Register) == CallFrameSlot::codeBlock * sizeof(Register) + SlotSize);
>+    static_assert(CallFrameSlot::argumentCount * sizeof(Register) == CallFrameSlot::callee * sizeof(Register) + SlotSize);
>+    static_assert(CallFrameSlot::thisArgument * sizeof(Register) == CallFrameSlot::argumentCount * sizeof(Register) + SlotSize);
>+    static_assert(CallFrame::headerSizeInRegisters == CallFrameSlot::thisArgument);
> 
>     ASSERT(CallFrame::argumentOffsetIncludingThis(0) == CallFrameSlot::thisArgument);
> 
>@@ -110,32 +108,32 @@ void Data::performAssertions(VM& vm)
>     ASSERT(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload) == 0);
> #endif
> #if USE(JSVALUE32_64)
>-    STATIC_ASSERT(JSValue::Int32Tag == static_cast<unsigned>(-1));
>-    STATIC_ASSERT(JSValue::BooleanTag == static_cast<unsigned>(-2));
>-    STATIC_ASSERT(JSValue::NullTag == static_cast<unsigned>(-3));
>-    STATIC_ASSERT(JSValue::UndefinedTag == static_cast<unsigned>(-4));
>-    STATIC_ASSERT(JSValue::CellTag == static_cast<unsigned>(-5));
>-    STATIC_ASSERT(JSValue::EmptyValueTag == static_cast<unsigned>(-6));
>-    STATIC_ASSERT(JSValue::DeletedValueTag == static_cast<unsigned>(-7));
>-    STATIC_ASSERT(JSValue::LowestTag == static_cast<unsigned>(-7));
>+    static_assert(JSValue::Int32Tag == static_cast<unsigned>(-1));
>+    static_assert(JSValue::BooleanTag == static_cast<unsigned>(-2));
>+    static_assert(JSValue::NullTag == static_cast<unsigned>(-3));
>+    static_assert(JSValue::UndefinedTag == static_cast<unsigned>(-4));
>+    static_assert(JSValue::CellTag == static_cast<unsigned>(-5));
>+    static_assert(JSValue::EmptyValueTag == static_cast<unsigned>(-6));
>+    static_assert(JSValue::DeletedValueTag == static_cast<unsigned>(-7));
>+    static_assert(JSValue::LowestTag == static_cast<unsigned>(-7));
> #else
>-    STATIC_ASSERT(TagBitTypeOther == 0x2);
>-    STATIC_ASSERT(TagBitBool == 0x4);
>-    STATIC_ASSERT(TagBitUndefined == 0x8);
>-    STATIC_ASSERT(ValueEmpty == 0x0);
>-    STATIC_ASSERT(ValueFalse == (TagBitTypeOther | TagBitBool));
>-    STATIC_ASSERT(ValueTrue == (TagBitTypeOther | TagBitBool | 1));
>-    STATIC_ASSERT(ValueUndefined == (TagBitTypeOther | TagBitUndefined));
>-    STATIC_ASSERT(ValueNull == TagBitTypeOther);
>+    static_assert(TagBitTypeOther == 0x2);
>+    static_assert(TagBitBool == 0x4);
>+    static_assert(TagBitUndefined == 0x8);
>+    static_assert(ValueEmpty == 0x0);
>+    static_assert(ValueFalse == (TagBitTypeOther | TagBitBool));
>+    static_assert(ValueTrue == (TagBitTypeOther | TagBitBool | 1));
>+    static_assert(ValueUndefined == (TagBitTypeOther | TagBitUndefined));
>+    static_assert(ValueNull == TagBitTypeOther);
> #endif
> #if (CPU(X86_64) && !OS(WINDOWS)) || CPU(ARM64) || !ENABLE(JIT)
>-    STATIC_ASSERT(!maxFrameExtentForSlowPathCall);
>+    static_assert(!maxFrameExtentForSlowPathCall);
> #elif CPU(ARM)
>-    STATIC_ASSERT(maxFrameExtentForSlowPathCall == 24);
>+    static_assert(maxFrameExtentForSlowPathCall == 24);
> #elif CPU(X86) || CPU(MIPS)
>-    STATIC_ASSERT(maxFrameExtentForSlowPathCall == 40);
>+    static_assert(maxFrameExtentForSlowPathCall == 40);
> #elif CPU(X86_64) && OS(WINDOWS)
>-    STATIC_ASSERT(maxFrameExtentForSlowPathCall == 64);
>+    static_assert(maxFrameExtentForSlowPathCall == 64);
> #endif
> 
> #if !ENABLE(JIT) || USE(JSVALUE32_64)
>diff --git a/Source/JavaScriptCore/runtime/JSBigInt.cpp b/Source/JavaScriptCore/runtime/JSBigInt.cpp
>index 460775d248b998bc3e8b827b8b22757fd9d2dbc8..24e0052c2df78562da8be58b2fa65956873f4766 100644
>--- a/Source/JavaScriptCore/runtime/JSBigInt.cpp
>+++ b/Source/JavaScriptCore/runtime/JSBigInt.cpp
>@@ -54,8 +54,6 @@
> #include "ParseInt.h"
> #include <algorithm>
> 
>-#define STATIC_ASSERT(cond) static_assert(cond, "JSBigInt assumes " #cond)
>-
> namespace JSC {
> 
> const ClassInfo JSBigInt::s_info =
>@@ -244,8 +242,8 @@ inline bool JSBigInt::isZero()
> // Multiplies {this} with {factor} and adds {summand} to the result.
> inline void JSBigInt::inplaceMultiplyAdd(uintptr_t factor, uintptr_t summand)
> {
>-    STATIC_ASSERT(sizeof(factor) == sizeof(Digit));
>-    STATIC_ASSERT(sizeof(summand) == sizeof(Digit));
>+    static_assert(sizeof(factor) == sizeof(Digit));
>+    static_assert(sizeof(summand) == sizeof(Digit));
> 
>     internalMultiplyAdd(this, factor, summand, length(), this);
> }
>@@ -447,7 +445,7 @@ inline JSBigInt::Digit JSBigInt::digitDiv(Digit high, Digit low, Digit divisor,
> 
>     // {s} can be 0. "low >> digitBits == low" on x86, so we "&" it with
>     // {s_zero_mask} which is 0 if s == 0 and all 1-bits otherwise.
>-    STATIC_ASSERT(sizeof(intptr_t) == sizeof(Digit));
>+    static_assert(sizeof(intptr_t) == sizeof(Digit));
>     Digit sZeroMask = static_cast<Digit>(static_cast<intptr_t>(-s) >> (digitBits - 1));
>     Digit un32 = (high << s) | ((low >> (digitBits - s)) & sZeroMask);
>     Digit un10 = low << s;
>diff --git a/Source/JavaScriptCore/runtime/NativeFunction.h b/Source/JavaScriptCore/runtime/NativeFunction.h
>index d514443d6195047c2a010a03c2abb3296cbcbff3..d79d66c2bb8cc9a2fd939fe27364c47d899fef34 100644
>--- a/Source/JavaScriptCore/runtime/NativeFunction.h
>+++ b/Source/JavaScriptCore/runtime/NativeFunction.h
>@@ -101,8 +101,8 @@ struct TaggedNativeFunctionHash {
>     static const bool safeToCompareToEmptyOrDeleted = true;
> };
> 
>-static_assert(sizeof(NativeFunction) == sizeof(void*), "");
>-static_assert(sizeof(TaggedNativeFunction) == sizeof(void*), "");
>+static_assert(sizeof(NativeFunction) == sizeof(void*));
>+static_assert(sizeof(TaggedNativeFunction) == sizeof(void*));
> 
> } // namespace JSC
> 
>diff --git a/Source/JavaScriptCore/runtime/TypedArrayType.h b/Source/JavaScriptCore/runtime/TypedArrayType.h
>index 5230d759f641e0ada68c1b493ce8d7c969558e76..8dd869771bbc58a21112ec017d33ae0c095c0500 100644
>--- a/Source/JavaScriptCore/runtime/TypedArrayType.h
>+++ b/Source/JavaScriptCore/runtime/TypedArrayType.h
>@@ -55,11 +55,11 @@ enum TypedArrayType {
> };
> 
> #define ASSERT_TYPED_ARRAY_TYPE(name) \
>-    static_assert(static_cast<uint32_t>(Type ## name) == (static_cast<uint32_t>(name ## ArrayType) - FirstTypedArrayType + static_cast<uint32_t>(TypeInt8)), "");
>+    static_assert(static_cast<uint32_t>(Type ## name) == (static_cast<uint32_t>(name ## ArrayType) - FirstTypedArrayType + static_cast<uint32_t>(TypeInt8)));
>     FOR_EACH_TYPED_ARRAY_TYPE_EXCLUDING_DATA_VIEW(ASSERT_TYPED_ARRAY_TYPE)
> #undef ASSERT_TYPED_ARRAY_TYPE
> 
>-static_assert(TypeDataView == (DataViewType - FirstTypedArrayType + TypeInt8), "");
>+static_assert(TypeDataView == (DataViewType - FirstTypedArrayType + TypeInt8));
> 
> inline unsigned toIndex(TypedArrayType type)
> {
>diff --git a/Source/JavaScriptCore/runtime/WeakMapImpl.h b/Source/JavaScriptCore/runtime/WeakMapImpl.h
>index 1bf6350b08cdd106c7a8b6aee19658e53e879663..b87b01d5b0c79b8c879c35b9c9c2efabed626bb2 100644
>--- a/Source/JavaScriptCore/runtime/WeakMapImpl.h
>+++ b/Source/JavaScriptCore/runtime/WeakMapImpl.h
>@@ -38,7 +38,7 @@ struct WeakMapBucketDataKey {
>     static const HashTableType Type = HashTableType::Key;
>     WriteBarrier<JSObject> key;
> };
>-static_assert(sizeof(WeakMapBucketDataKey) == sizeof(void*), "");
>+static_assert(sizeof(WeakMapBucketDataKey) == sizeof(void*));
> 
> struct WeakMapBucketDataKeyValue {
>     static const HashTableType Type = HashTableType::KeyValue;
>@@ -48,7 +48,7 @@ struct WeakMapBucketDataKeyValue {
> #endif
>     WriteBarrier<Unknown> value;
> };
>-static_assert(sizeof(WeakMapBucketDataKeyValue) == 16, "");
>+static_assert(sizeof(WeakMapBucketDataKeyValue) == 16);
> 
> ALWAYS_INLINE uint32_t jsWeakMapHash(JSObject* key)
> {
>diff --git a/Source/WTF/wtf/FastMalloc.h b/Source/WTF/wtf/FastMalloc.h
>index 41ef69ff79b55a6ee86ab3c1fef120e16b7e639d..788ddb72f018d4af2c53fe13cbdf8ba36e958be9 100644
>--- a/Source/WTF/wtf/FastMalloc.h
>+++ b/Source/WTF/wtf/FastMalloc.h
>@@ -205,7 +205,7 @@ struct FastMalloc {
> 
> template<typename T>
> struct FastFree {
>-    static_assert(std::is_trivially_destructible<T>::value, "");
>+    static_assert(std::is_trivially_destructible<T>::value);
> 
>     void operator()(T* pointer) const
>     {
>@@ -215,7 +215,7 @@ struct FastFree {
> 
> template<typename T>
> struct FastFree<T[]> {
>-    static_assert(std::is_trivially_destructible<T>::value, "");
>+    static_assert(std::is_trivially_destructible<T>::value);
> 
>     void operator()(T* pointer) const
>     {
>diff --git a/Source/WTF/wtf/MallocPtr.h b/Source/WTF/wtf/MallocPtr.h
>index 66f10aa9bd5bba09ac561136ad35bf5e84e48fca..376292af46318f5c43c70f3589204f9ee7d8e3f3 100644
>--- a/Source/WTF/wtf/MallocPtr.h
>+++ b/Source/WTF/wtf/MallocPtr.h
>@@ -126,7 +126,7 @@ template<typename T, typename Malloc = FastMalloc> class MallocPtr {
>     T* m_ptr;
> };
> 
>-static_assert(sizeof(MallocPtr<int>) == sizeof(int*), "");
>+static_assert(sizeof(MallocPtr<int>) == sizeof(int*));
> 
> template<typename U> MallocPtr<U> adoptMallocPtr(U* ptr)
> {
>diff --git a/Source/WTF/wtf/PtrTag.h b/Source/WTF/wtf/PtrTag.h
>index 33e7202d665d93fcb50d6d07cbe8679614de9816..0c6839e729b830121a96e41b358171e5cfb267d3 100644
>--- a/Source/WTF/wtf/PtrTag.h
>+++ b/Source/WTF/wtf/PtrTag.h
>@@ -61,10 +61,10 @@ constexpr uintptr_t makePtrTagHash(const char (&str)[N])
> 
> #define WTF_DECLARE_PTRTAG(tag) \
>     constexpr PtrTag tag = static_cast<PtrTag>(WTF_PTRTAG_HASH(#tag)); \
>-    static_assert(tag != NoPtrTag && tag != CFunctionPtrTag, "");
>+    static_assert(tag != NoPtrTag && tag != CFunctionPtrTag);
> 
>-static_assert(static_cast<uintptr_t>(NoPtrTag) == static_cast<uintptr_t>(0), "");
>-static_assert(static_cast<uintptr_t>(CFunctionPtrTag) == static_cast<uintptr_t>(1), "");
>+static_assert(static_cast<uintptr_t>(NoPtrTag) == static_cast<uintptr_t>(0));
>+static_assert(static_cast<uintptr_t>(CFunctionPtrTag) == static_cast<uintptr_t>(1));
> 
> #if COMPILER(MSVC)
> #pragma warning(push)
>diff --git a/Source/WTF/wtf/Seconds.h b/Source/WTF/wtf/Seconds.h
>index 61086f3e46337ed739488fcb5f4d53e8b64c2810..0baaecd1dad2aa6d5f6d8ce3442c9b7c566ba18f 100644
>--- a/Source/WTF/wtf/Seconds.h
>+++ b/Source/WTF/wtf/Seconds.h
>@@ -54,11 +54,11 @@ class Seconds {
>     constexpr double nanoseconds() const { return microseconds() * 1000; }
> 
>     // Keep in mind that Seconds is held in double. If the value is not in range of 53bit integer, the result may not be precise.
>-    template<typename T> T minutesAs() const { static_assert(std::is_integral<T>::value, ""); return clampToAccepting64<T>(minutes()); }
>-    template<typename T> T secondsAs() const { static_assert(std::is_integral<T>::value, ""); return clampToAccepting64<T>(seconds()); }
>-    template<typename T> T millisecondsAs() const { static_assert(std::is_integral<T>::value, ""); return clampToAccepting64<T>(milliseconds()); }
>-    template<typename T> T microsecondsAs() const { static_assert(std::is_integral<T>::value, ""); return clampToAccepting64<T>(microseconds()); }
>-    template<typename T> T nanosecondsAs() const { static_assert(std::is_integral<T>::value, ""); return clampToAccepting64<T>(nanoseconds()); }
>+    template<typename T> T minutesAs() const { static_assert(std::is_integral<T>::value); return clampToAccepting64<T>(minutes()); }
>+    template<typename T> T secondsAs() const { static_assert(std::is_integral<T>::value); return clampToAccepting64<T>(seconds()); }
>+    template<typename T> T millisecondsAs() const { static_assert(std::is_integral<T>::value); return clampToAccepting64<T>(milliseconds()); }
>+    template<typename T> T microsecondsAs() const { static_assert(std::is_integral<T>::value); return clampToAccepting64<T>(microseconds()); }
>+    template<typename T> T nanosecondsAs() const { static_assert(std::is_integral<T>::value); return clampToAccepting64<T>(nanoseconds()); }
>     
>     static constexpr Seconds fromMinutes(double minutes)
>     {
>diff --git a/Source/WTF/wtf/StdLibExtras.h b/Source/WTF/wtf/StdLibExtras.h
>index 6e3c94d1a5052921dd85b8047ff5ef078bc0eba0..9b2ce1ac2c86bcec515c21354e6c7b17abd4bdbf 100644
>--- a/Source/WTF/wtf/StdLibExtras.h
>+++ b/Source/WTF/wtf/StdLibExtras.h
>@@ -199,7 +199,7 @@ template<size_t divisor> inline constexpr size_t roundUpToMultipleOf(size_t x)
> 
> template<size_t divisor, typename T> inline T* roundUpToMultipleOf(T* x)
> {
>-    static_assert(sizeof(T*) == sizeof(size_t), "");
>+    static_assert(sizeof(T*) == sizeof(size_t));
>     return reinterpret_cast<T*>(roundUpToMultipleOf<divisor>(reinterpret_cast<size_t>(x)));
> }
> 
>diff --git a/Source/WTF/wtf/SystemFree.h b/Source/WTF/wtf/SystemFree.h
>index 73b693f06838bcc8ccc83a468d4dbc3a8ab82f83..31dcd487594d1582a4a30050d942e8a6c724e2f7 100644
>--- a/Source/WTF/wtf/SystemFree.h
>+++ b/Source/WTF/wtf/SystemFree.h
>@@ -31,7 +31,7 @@ namespace WTF {
> 
> template<typename T>
> struct SystemFree {
>-    static_assert(std::is_trivially_destructible<T>::value, "");
>+    static_assert(std::is_trivially_destructible<T>::value);
> 
>     void operator()(T* pointer) const
>     {
>@@ -41,7 +41,7 @@ struct SystemFree {
> 
> template<typename T>
> struct SystemFree<T[]> {
>-    static_assert(std::is_trivially_destructible<T>::value, "");
>+    static_assert(std::is_trivially_destructible<T>::value);
> 
>     void operator()(T* pointer) const
>     {
>diff --git a/Source/WTF/wtf/UniqueArray.h b/Source/WTF/wtf/UniqueArray.h
>index a2b85853529311db46298535d3262c211a10426c..1ccdcceb609241b5617eea504788804b75559e2b 100644
>--- a/Source/WTF/wtf/UniqueArray.h
>+++ b/Source/WTF/wtf/UniqueArray.h
>@@ -44,7 +44,7 @@ struct UniqueArrayMaker<true, T> {
>         // If it is acceptable, we can just use Vector<T> instead. So this UniqueArray<T> only
>         // accepts the type T which has a trivial destructor. This allows us to skip calling
>         // destructors for N elements. And this allows UniqueArray<T> not to store its N size.
>-        static_assert(std::is_trivially_destructible<T>::value, "");
>+        static_assert(std::is_trivially_destructible<T>::value);
> 
>         // Do not use placement new like `new (storage) T[size]()`. `new T[size]()` requires
>         // larger storage than the `sizeof(T) * size` storage since it want to store `size`
>@@ -75,7 +75,7 @@ struct UniqueArrayMaker<false, T> {
> 
>         T value { };
>     };
>-    static_assert(sizeof(T) == sizeof(UniqueArrayElement), "");
>+    static_assert(sizeof(T) == sizeof(UniqueArrayElement));
> 
>     using ResultType = typename std::unique_ptr<T[], typename UniqueArrayElement::Deleter>;
> 
>@@ -91,7 +91,7 @@ using UniqueArray = typename UniqueArrayMaker<std::is_trivially_destructible<T>:
> template<typename T>
> UniqueArray<T> makeUniqueArray(size_t size)
> {
>-    static_assert(std::is_same<typename std::remove_extent<T>::type, T>::value, "");
>+    static_assert(std::is_same<typename std::remove_extent<T>::type, T>::value);
>     return UniqueArrayMaker<std::is_trivially_destructible<T>::value, T>::make(size);
> }
> 
>diff --git a/Source/WTF/wtf/WTFAssertions.cpp b/Source/WTF/wtf/WTFAssertions.cpp
>index 9870764cf021e1289bed1d12d8e5cf739836f910..bedcfe7875058fb2c68240dbe4489946811a69b1 100644
>--- a/Source/WTF/wtf/WTFAssertions.cpp
>+++ b/Source/WTF/wtf/WTFAssertions.cpp
>@@ -38,21 +38,21 @@ struct DummyStruct { };
> uintptr_t dummyPoison = 0;
> }
> 
>-static_assert(sizeof(Bag<DummyStruct>) == sizeof(void*), "");
>-static_assert(sizeof(PoisonedBag<Poison<dummyPoison>, DummyStruct>) == sizeof(void*), "");
>+static_assert(sizeof(Bag<DummyStruct>) == sizeof(void*));
>+static_assert(sizeof(PoisonedBag<Poison<dummyPoison>, DummyStruct>) == sizeof(void*));
> 
>-static_assert(sizeof(Ref<DummyStruct>) == sizeof(DummyStruct*), "");
>-static_assert(sizeof(PoisonedRef<Poison<dummyPoison>, DummyStruct>) == sizeof(DummyStruct*), "");
>+static_assert(sizeof(Ref<DummyStruct>) == sizeof(DummyStruct*));
>+static_assert(sizeof(PoisonedRef<Poison<dummyPoison>, DummyStruct>) == sizeof(DummyStruct*));
> 
>-static_assert(sizeof(RefPtr<DummyStruct>) == sizeof(DummyStruct*), "");
>-static_assert(sizeof(PoisonedRefPtr<Poison<dummyPoison>, DummyStruct>) == sizeof(DummyStruct*), "");
>+static_assert(sizeof(RefPtr<DummyStruct>) == sizeof(DummyStruct*));
>+static_assert(sizeof(PoisonedRefPtr<Poison<dummyPoison>, DummyStruct>) == sizeof(DummyStruct*));
> 
>-static_assert(sizeof(PoisonedUniquePtr<Poison<dummyPoison>, DummyStruct>) == sizeof(DummyStruct*), "");
>-static_assert(sizeof(PoisonedUniquePtr<Poison<dummyPoison>, int[]>) == sizeof(int*), "");
>-static_assert(sizeof(PoisonedUniquePtr<Poison<dummyPoison>, DummyStruct[]>) == sizeof(DummyStruct*), "");
>+static_assert(sizeof(PoisonedUniquePtr<Poison<dummyPoison>, DummyStruct>) == sizeof(DummyStruct*));
>+static_assert(sizeof(PoisonedUniquePtr<Poison<dummyPoison>, int[]>) == sizeof(int*));
>+static_assert(sizeof(PoisonedUniquePtr<Poison<dummyPoison>, DummyStruct[]>) == sizeof(DummyStruct*));
> 
>-static_assert(sizeof(RefCountedArray<DummyStruct>) == sizeof(void*), "");
>-static_assert(sizeof(PoisonedRefCountedArray<Poison<dummyPoison>, DummyStruct>) == sizeof(void*), "");
>+static_assert(sizeof(RefCountedArray<DummyStruct>) == sizeof(void*));
>+static_assert(sizeof(PoisonedRefCountedArray<Poison<dummyPoison>, DummyStruct>) == sizeof(void*));
>     
> } // namespace WTF
> 
>diff --git a/Source/WTF/wtf/text/StringImpl.h b/Source/WTF/wtf/text/StringImpl.h
>index af4ce6b62a9a79aaee307673070c77af4a65d227..32cdb10b417b7e33290dd4b085a5a77b371ec4ff 100644
>--- a/Source/WTF/wtf/text/StringImpl.h
>+++ b/Source/WTF/wtf/text/StringImpl.h
>@@ -517,7 +517,7 @@ class StringImpl : private StringImplShape {
> 
> using StaticStringImpl = StringImpl::StaticStringImpl;
> 
>-static_assert(sizeof(StringImpl) == sizeof(StaticStringImpl), "");
>+static_assert(sizeof(StringImpl) == sizeof(StaticStringImpl));
> 
> #if !ASSERT_DISABLED
> 
>diff --git a/Source/WTF/wtf/text/SymbolImpl.h b/Source/WTF/wtf/text/SymbolImpl.h
>index 42ff036f7fd568395fa7808bde748c4353e8e3d1..0b88d59ed8595e96e7a2db8f8aab67bec04ee629 100644
>--- a/Source/WTF/wtf/text/SymbolImpl.h
>+++ b/Source/WTF/wtf/text/SymbolImpl.h
>@@ -122,7 +122,7 @@ class SymbolImpl : public UniquedStringImpl {
>     unsigned m_hashForSymbol;
>     Flags m_flags { s_flagDefault };
> };
>-static_assert(sizeof(SymbolImpl) == sizeof(SymbolImpl::StaticSymbolImpl), "");
>+static_assert(sizeof(SymbolImpl) == sizeof(SymbolImpl::StaticSymbolImpl));
> 
> class PrivateSymbolImpl : public SymbolImpl {
> public:
>diff --git a/Source/WebCore/platform/KeyedCoding.h b/Source/WebCore/platform/KeyedCoding.h
>index 918401aa4dd3622e08f4e193077139f27c00251d..8d6986d47557809626430f9a391175e1fcd2dd4a 100644
>--- a/Source/WebCore/platform/KeyedCoding.h
>+++ b/Source/WebCore/platform/KeyedCoding.h
>@@ -51,7 +51,7 @@ class KeyedDecoder {
>     template<typename T>
>     bool decodeBytes(const String& key, Vector<T>& vector)
>     {
>-        static_assert(sizeof(T) == 1, "");
>+        static_assert(sizeof(T) == 1);
> 
>         size_t size;
>         const uint8_t* bytes;
>diff --git a/Source/WebKit/NetworkProcess/capture/json.hpp b/Source/WebKit/NetworkProcess/capture/json.hpp
>index 7c869787f19cc6c23b421f9c40aa0154332ae1a2..28fbff7108814f97eb668db5b34a9dd8026ce8a3 100644
>--- a/Source/WebKit/NetworkProcess/capture/json.hpp
>+++ b/Source/WebKit/NetworkProcess/capture/json.hpp
>@@ -11251,7 +11251,7 @@ class basic_json
>                 const auto x = parse_integral(&endptr, std::is_signed<T>());
> 
>                 // called right overload?
>-                static_assert(std::is_signed<T>() == std::is_signed<decltype(x)>(), "");
>+                static_assert(std::is_signed<T>() == std::is_signed<decltype(x)>());
> 
>                 value = static_cast<T>(x);
> 
>diff --git a/Source/WebKit/UIProcess/mac/LegacySessionStateCoding.cpp b/Source/WebKit/UIProcess/mac/LegacySessionStateCoding.cpp
>index 17f66b71779c0549cf68ae28165818a729d663fe..2a8ebec479cd4dcfa3cffc4c6a3cf52767a71834 100644
>--- a/Source/WebKit/UIProcess/mac/LegacySessionStateCoding.cpp
>+++ b/Source/WebKit/UIProcess/mac/LegacySessionStateCoding.cpp
>@@ -200,7 +200,7 @@ class HistoryEntryDataEncoder {
>     template<typename Type>
>     HistoryEntryDataEncoder& encodeArithmeticType(Type value)
>     {
>-        static_assert(std::is_arithmetic<Type>::value, "");
>+        static_assert(std::is_arithmetic<Type>::value);
> 
>         encodeFixedLengthData(reinterpret_cast<uint8_t*>(&value), sizeof(value), sizeof(value));
>         return *this;
>@@ -726,7 +726,7 @@ class HistoryEntryDataDecoder {
>     template<typename Type>
>     HistoryEntryDataDecoder& decodeArithmeticType(Type& value)
>     {
>-        static_assert(std::is_arithmetic<Type>::value, "");
>+        static_assert(std::is_arithmetic<Type>::value);
>         value = Type();
> 
>         decodeFixedLengthData(reinterpret_cast<uint8_t*>(&value), sizeof(value), sizeof(value));
>diff --git a/Source/bmalloc/bmalloc/Algorithm.h b/Source/bmalloc/bmalloc/Algorithm.h
>index e4e51a53a3e1a0a99362bbbc83c8ab5b010f1f77..fba835a4931ae4f75d706ea32e44809bfa67c0eb 100644
>--- a/Source/bmalloc/bmalloc/Algorithm.h
>+++ b/Source/bmalloc/bmalloc/Algorithm.h
>@@ -67,7 +67,7 @@ template<typename T> inline constexpr bool test(T value, uintptr_t mask)
> template <typename T>
> inline constexpr bool isPowerOfTwo(T size)
> {
>-    static_assert(std::is_integral<T>::value, "");
>+    static_assert(std::is_integral<T>::value);
>     return size && !(size & (size - 1));
> }
> 
>diff --git a/Source/bmalloc/bmalloc/Gigacage.h b/Source/bmalloc/bmalloc/Gigacage.h
>index 7839f86d61b07b26aa760b7092095169b16a2505..7671fdfcc92460383aa78724594735696b322a17 100644
>--- a/Source/bmalloc/bmalloc/Gigacage.h
>+++ b/Source/bmalloc/bmalloc/Gigacage.h
>@@ -50,8 +50,8 @@
> #define GIGACAGE_ALLOCATION_CAN_FAIL 1
> #endif
> 
>-static_assert(bmalloc::isPowerOfTwo(PRIMITIVE_GIGACAGE_SIZE), "");
>-static_assert(bmalloc::isPowerOfTwo(JSVALUE_GIGACAGE_SIZE), "");
>+static_assert(bmalloc::isPowerOfTwo(PRIMITIVE_GIGACAGE_SIZE));
>+static_assert(bmalloc::isPowerOfTwo(JSVALUE_GIGACAGE_SIZE));
> 
> #define GIGACAGE_SIZE_TO_MASK(size) ((size) - 1)
>

Flags:

andersca: review+

Actions: View | Formatted Diff | Diff

Attachments on bug 185861: 340969