diff --git a/src/3rdparty/masm/assembler/ARM64Assembler.h b/src/3rdparty/masm/assembler/ARM64Assembler.h
index ca6b33d39a..05a680a75f 100644
--- a/src/3rdparty/masm/assembler/ARM64Assembler.h
+++ b/src/3rdparty/masm/assembler/ARM64Assembler.h
@@ -3024,7 +3024,7 @@ public:
 #if OS(IOS)
         sys_cache_control(kCacheFunctionPrepareForExecution, code, size);
 #elif OS(LINUX)
-        size_t page = pageSize();
+        size_t page = qtpageSize();
         uintptr_t current = reinterpret_cast<uintptr_t>(code);
         uintptr_t end = current + size;
         uintptr_t firstPageEnd = (current & ~(page - 1)) + page;
diff --git a/src/3rdparty/masm/assembler/ARMv7Assembler.h b/src/3rdparty/masm/assembler/ARMv7Assembler.h
index 03cb9f42f8..cdd37c1620 100644
--- a/src/3rdparty/masm/assembler/ARMv7Assembler.h
+++ b/src/3rdparty/masm/assembler/ARMv7Assembler.h
@@ -2342,7 +2342,7 @@ public:
 #if OS(IOS)
         sys_cache_control(kCacheFunctionPrepareForExecution, code, size);
 #elif OS(LINUX)
-        size_t page = pageSize();
+        size_t page = qtpageSize();
         uintptr_t current = reinterpret_cast<uintptr_t>(code);
         uintptr_t end = current + size;
         uintptr_t firstPageEnd = (current & ~(page - 1)) + page;
diff --git a/src/3rdparty/masm/stubs/ExecutableAllocator.h b/src/3rdparty/masm/stubs/ExecutableAllocator.h
index f984704023..a86453226c 100644
--- a/src/3rdparty/masm/stubs/ExecutableAllocator.h
+++ b/src/3rdparty/masm/stubs/ExecutableAllocator.h
@@ -111,7 +111,7 @@ struct ExecutableAllocator {
 
     static void makeWritable(void* addr, size_t size)
     {
-        quintptr pageSize = WTF::pageSize();
+        quintptr pageSize = WTF::qtpageSize();
         quintptr iaddr = reinterpret_cast<quintptr>(addr);
         quintptr roundAddr = iaddr & ~(pageSize - 1);
         size = size + (iaddr - roundAddr);
@@ -146,7 +146,7 @@ struct ExecutableAllocator {
 
     static void makeExecutable(void* addr, size_t size)
     {
-        quintptr pageSize = WTF::pageSize();
+        quintptr pageSize = WTF::qtpageSize();
         quintptr iaddr = reinterpret_cast<quintptr>(addr);
         quintptr roundAddr = iaddr & ~(pageSize - 1);
         size = size + (iaddr - roundAddr);
diff --git a/src/3rdparty/masm/wtf/BumpPointerAllocator.h b/src/3rdparty/masm/wtf/BumpPointerAllocator.h
index 3b2cfd974a..2ef36c5ee7 100644
--- a/src/3rdparty/masm/wtf/BumpPointerAllocator.h
+++ b/src/3rdparty/masm/wtf/BumpPointerAllocator.h
@@ -112,7 +112,7 @@ private:
         if (minimumCapacity < sizeof(BumpPointerPool))
             return 0;
 
-        size_t poolSize = std::max(static_cast<size_t>(MINIMUM_BUMP_POOL_SIZE), WTF::pageSize());
+        size_t poolSize = std::max(static_cast<size_t>(MINIMUM_BUMP_POOL_SIZE), WTF::qtpageSize());
         while (poolSize < minimumCapacity) {
             poolSize <<= 1;
             // The following if check relies on MINIMUM_BUMP_POOL_SIZE being a power of 2!
diff --git a/src/3rdparty/masm/wtf/OSAllocatorPosix.cpp b/src/3rdparty/masm/wtf/OSAllocatorPosix.cpp
index d59fdcd675..b9c4243708 100644
--- a/src/3rdparty/masm/wtf/OSAllocatorPosix.cpp
+++ b/src/3rdparty/masm/wtf/OSAllocatorPosix.cpp
@@ -188,8 +188,8 @@ void* OSAllocator::reserveAndCommit(size_t bytes, Usage usage, bool writable, bo
         // mprotect results in multiple references to the code region.  This
         // breaks the madvise based mechanism we use to return physical memory
         // to the OS.
-        mmap(result, pageSize(), PROT_NONE, MAP_FIXED | MAP_PRIVATE | MAP_ANON, fd, 0);
-        mmap(static_cast<char*>(result) + bytes - pageSize(), pageSize(), PROT_NONE, MAP_FIXED | MAP_PRIVATE | MAP_ANON, fd, 0);
+        mmap(result, qtpageSize(), PROT_NONE, MAP_FIXED | MAP_PRIVATE | MAP_ANON, fd, 0);
+        mmap(static_cast<char*>(result) + bytes - qtpageSize(), qtpageSize(), PROT_NONE, MAP_FIXED | MAP_PRIVATE | MAP_ANON, fd, 0);
     }
 
 #if OS(LINUX)
@@ -267,7 +267,7 @@ bool OSAllocator::canAllocateExecutableMemory()
     if (executable)
         flags |= MAP_JIT;
 #endif
-    const auto size = pageSize();
+    const auto size = qtpageSize();
     void *testPage = mmap(nullptr, size, PROT_READ | PROT_WRITE | PROT_EXEC, flags, /*fd*/-1, /*offset*/0);
     if (testPage == MAP_FAILED)
         return false;
diff --git a/src/3rdparty/masm/wtf/OSAllocatorWin.cpp b/src/3rdparty/masm/wtf/OSAllocatorWin.cpp
index bb934264ab..9518b69a8c 100644
--- a/src/3rdparty/masm/wtf/OSAllocatorWin.cpp
+++ b/src/3rdparty/masm/wtf/OSAllocatorWin.cpp
@@ -56,7 +56,7 @@ void* OSAllocator::reserveAndCommit(size_t bytes, Usage, bool writable, bool exe
     if (!result)
         CRASH();
     if (includesGuardPages) {
-        size_t guardSize = pageSize();
+        size_t guardSize = qtpageSize();
         DWORD oldProtect;
         if (!VirtualProtect(result, guardSize, protection(false, false), &oldProtect) ||
             !VirtualProtect(static_cast<char*>(result) + bytes - guardSize, guardSize,
diff --git a/src/3rdparty/masm/wtf/OSAllocatorWinRT.cpp b/src/3rdparty/masm/wtf/OSAllocatorWinRT.cpp
index 4cebc35cce..457b390ba6 100644
--- a/src/3rdparty/masm/wtf/OSAllocatorWinRT.cpp
+++ b/src/3rdparty/masm/wtf/OSAllocatorWinRT.cpp
@@ -66,7 +66,7 @@ void* OSAllocator::reserveAndCommit(size_t bytes, Usage, bool writable, bool exe
                                  protection(writable, executable));
 
     if (includesGuardPages && qt_winrt_use_jit) {
-        size_t guardSize = pageSize();
+        size_t guardSize = qtpageSize();
         DWORD oldProtect;
         if (!VirtualProtectFromApp(result, guardSize, protection(false, false), &oldProtect) ||
             !VirtualProtectFromApp(static_cast<char*>(result) + bytes - guardSize, guardSize,
diff --git a/src/3rdparty/masm/wtf/PageAllocationAligned.cpp b/src/3rdparty/masm/wtf/PageAllocationAligned.cpp
index 90c2fd61db..2d10cb4082 100644
--- a/src/3rdparty/masm/wtf/PageAllocationAligned.cpp
+++ b/src/3rdparty/masm/wtf/PageAllocationAligned.cpp
@@ -48,7 +48,7 @@ PageAllocationAligned PageAllocationAligned::allocate(size_t size, size_t alignm
     vm_map(current_task(), &address, size, alignmentMask, flags, MEMORY_OBJECT_NULL, 0, FALSE, protection, PROT_READ | PROT_WRITE, VM_INHERIT_DEFAULT);
     return PageAllocationAligned(reinterpret_cast<void*>(address), size);
 #else
-    size_t alignmentDelta = alignment - pageSize();
+    size_t alignmentDelta = alignment - qtpageSize();
 
     // Resererve with suffcient additional VM to correctly align.
     size_t reservationSize = size + alignmentDelta;
diff --git a/src/3rdparty/masm/wtf/PageBlock.cpp b/src/3rdparty/masm/wtf/PageBlock.cpp
index e715ed262a..3d7f2d7e93 100644
--- a/src/3rdparty/masm/wtf/PageBlock.cpp
+++ b/src/3rdparty/masm/wtf/PageBlock.cpp
@@ -64,7 +64,7 @@ inline size_t systemPageSize()
 
 #endif
 
-size_t pageSize()
+size_t qtpageSize()
 {
     if (!s_pageSize)
         s_pageSize = systemPageSize();
@@ -75,7 +75,7 @@ size_t pageSize()
 size_t pageMask()
 {
     if (!s_pageMask)
-        s_pageMask = ~(pageSize() - 1);
+        s_pageMask = ~(qtpageSize() - 1);
     return s_pageMask;
 }
 
diff --git a/src/3rdparty/masm/wtf/PageBlock.h b/src/3rdparty/masm/wtf/PageBlock.h
index 09e4048239..f4c43e804a 100644
--- a/src/3rdparty/masm/wtf/PageBlock.h
+++ b/src/3rdparty/masm/wtf/PageBlock.h
@@ -28,10 +28,10 @@
 
 namespace WTF {
 
-WTF_EXPORT_PRIVATE size_t pageSize();
+WTF_EXPORT_PRIVATE size_t qtpageSize();
 WTF_EXPORT_PRIVATE size_t pageMask();
-inline bool isPageAligned(void* address) { return !(reinterpret_cast<intptr_t>(address) & (pageSize() - 1)); }
-inline bool isPageAligned(size_t size) { return !(size & (pageSize() - 1)); }
+inline bool isPageAligned(void* address) { return !(reinterpret_cast<intptr_t>(address) & (qtpageSize() - 1)); }
+inline bool isPageAligned(size_t size) { return !(size & (qtpageSize() - 1)); }
 inline bool isPowerOfTwo(size_t size) { return !(size & (size - 1)); }
 
 class PageBlock {
@@ -70,14 +70,14 @@ inline PageBlock::PageBlock()
 
 inline PageBlock::PageBlock(void* base, size_t size, bool hasGuardPages)
     : m_realBase(base)
-    , m_base(static_cast<char*>(base) + ((base && hasGuardPages) ? pageSize() : 0))
+    , m_base(static_cast<char*>(base) + ((base && hasGuardPages) ? qtpageSize() : 0))
     , m_size(size)
 {
 }
 
 } // namespace WTF
 
-using WTF::pageSize;
+using WTF::qtpageSize;
 using WTF::isPageAligned;
 using WTF::isPageAligned;
 using WTF::isPowerOfTwo;
diff --git a/src/qml/jsruntime/qv4executableallocator.cpp b/src/qml/jsruntime/qv4executableallocator.cpp
index c06773d3c5..53ce02842c 100644
--- a/src/qml/jsruntime/qv4executableallocator.cpp
+++ b/src/qml/jsruntime/qv4executableallocator.cpp
@@ -186,7 +186,7 @@ ExecutableAllocator::Allocation *ExecutableAllocator::allocate(size_t size)
 
     if (!allocation) {
         ChunkOfPages *chunk = new ChunkOfPages;
-        size_t allocSize = WTF::roundUpToMultipleOf(WTF::pageSize(), size);
+        size_t allocSize = WTF::roundUpToMultipleOf(WTF::qtpageSize(), size);
         chunk->pages = new WTF::PageAllocation(WTF::PageAllocation::allocate(allocSize, OSAllocator::JSJITCodePages));
         chunks.insert(reinterpret_cast<quintptr>(chunk->pages->base()) - 1, chunk);
         allocation = new Allocation;
diff --git a/src/qml/jsruntime/qv4persistent.cpp b/src/qml/jsruntime/qv4persistent.cpp
index f4901e3e4d..f3df86cb43 100644
--- a/src/qml/jsruntime/qv4persistent.cpp
+++ b/src/qml/jsruntime/qv4persistent.cpp
@@ -57,7 +57,7 @@ struct Header {
     int freeList;
 };
 
-static const int kEntriesPerPage = int((WTF::pageSize() - sizeof(Header)) / sizeof(Value));
+static const int kEntriesPerPage = int((WTF::qtpageSize() - sizeof(Header)) / sizeof(Value));
 
 struct Page {
     Header header;
@@ -65,7 +65,7 @@ struct Page {
 };
 
 Page *getPage(Value *val) {
-   return reinterpret_cast<Page *>(reinterpret_cast<quintptr>(val) & ~((quintptr)(WTF::pageSize() - 1)));
+   return reinterpret_cast<Page *>(reinterpret_cast<quintptr>(val) & ~((quintptr)(WTF::qtpageSize() - 1)));
 }
 
 QML_NEARLY_ALWAYS_INLINE void insertInFront(PersistentValueStorage *storage, Page *p)
@@ -87,10 +87,10 @@ QML_NEARLY_ALWAYS_INLINE void unlink(Page *p)
 
 Page *allocatePage(PersistentValueStorage *storage)
 {
-    PageAllocation page = WTF::PageAllocation::allocate(WTF::pageSize());
+    PageAllocation page = WTF::PageAllocation::allocate(WTF::qtpageSize());
     Page *p = reinterpret_cast<Page *>(page.base());
 
-    Q_ASSERT(!((quintptr)p & (WTF::pageSize() - 1)));
+    Q_ASSERT(!((quintptr)p & (WTF::qtpageSize() - 1)));
 
     p->header.engine = storage->engine;
     p->header.alloc = page;
diff --git a/src/qml/memory/qv4mm.cpp b/src/qml/memory/qv4mm.cpp
index 06caf04e5a..2b5faaf513 100644
--- a/src/qml/memory/qv4mm.cpp
+++ b/src/qml/memory/qv4mm.cpp
@@ -175,7 +175,7 @@ struct MemorySegment {
             ++index;
         }
 
-        size_t pageSize = WTF::pageSize();
+        size_t pageSize = WTF::qtpageSize();
         size = (size + pageSize - 1) & ~(pageSize - 1);
 #if !defined(Q_OS_LINUX) && !defined(Q_OS_WIN)
         // Linux and Windows zero out pages that have been decommitted and get committed again.
@@ -236,7 +236,7 @@ struct ChunkAllocator {
 
     size_t requiredChunkSize(size_t size) {
         size += Chunk::HeaderSize; // space required for the Chunk header
-        size_t pageSize = WTF::pageSize();
+        size_t pageSize = WTF::qtpageSize();
         size = (size + pageSize - 1) & ~(pageSize - 1); // align to page sizes
         if (size < Chunk::ChunkSize)
             size = Chunk::ChunkSize;
@@ -674,7 +674,7 @@ HeapItem *HugeItemAllocator::allocate(size_t size) {
     if (size >= MemorySegment::SegmentSize/2) {
         // too large to handle through the ChunkAllocator, let's get our own memory segement
         size += Chunk::HeaderSize; // space required for the Chunk header
-        size_t pageSize = WTF::pageSize();
+        size_t pageSize = WTF::qtpageSize();
         size = (size + pageSize - 1) & ~(pageSize - 1); // align to page sizes
         m = new MemorySegment(size);
         c = m->allocate(size);
