Attachment #21963 for bug #19775

View Details Raw Unified Return to Bug 19775

| Differences between




// Page-level allocator
static SpinLock pageheap_lock = SPINLOCK_INITIALIZER;
static uint64_t pageheap_memory[(sizeof(TCMalloc_PageHeap) + sizeof(uint64_t) - 1) / sizeof(uint64_t)];
static bool phinited = false;

// Avoid extra level of indirection by making "pageheap" be just an alias
// of pageheap_memory.
typedef union {
    uint64_t* m_memory;
    TCMalloc_PageHeap* m_pageHeap;
} PageHeapUnion;




#define WTF_PLATFORM_X86_64 1
#endif

/* PLATFORM(SPARC) */
#if   defined(__sparc__) \
   || defined(__sparc) \
#define WTF_PLATFORM_SPARC 1
#define WTF_PLATFORM_BIG_ENDIAN 1
#endif

/* For undefined platforms */
#if !defined(WTF_PLATFORM_BIG_ENDIAN) && !defined(WTF_PLATFORM_MIDDLE_ENDIAN)
#include <sys/param.h>
#if __BYTE_ORDER == __BIG_ENDIAN
#define WTF_PLATFORM_BIG_ENDIAN 1
#elif  __BYTE_ORDER == __PDP_ENDIAN
#define WTF_PLATFORM_MIDDLE_ENDIAN 1
#endif
#endif

/* Compiler */

/* COMPILER(MSVC) */



        static const size_t m_inlineBufferSize = inlineCapacity * sizeof(T);
        T* inlineBuffer() { return reinterpret_cast<T*>(&m_inlineBuffer); }

        uuint64_t m_inlineBuffer[(m_inlineBufferSize + sizeof(uint64_t) - 1) / sizeof(uint64_t)];
        char m_inlineBuffer[m_inlineBufferSize];
    };

    template<typename T, size_t inlineCapacity = 0>

Lines 94-100 static inline bool equal(StringImpl* string, const UChar* characters, unsigned l a/WebCore/platform/text/AtomicString.cpp_sec1
- a/WebCore/platform/text/AtomicString.cpp -1 / +1 lines
94	if (string->length() != length)	94	if (string->length() != length)
95	return false;	95	return false;
96		96
97	#if PLATFORM(ARM)	97	#if PLATFORM(ARM) \|\| PLATFORM(SPARC)
98	const UChar* stringCharacters = string->characters();	98	const UChar* stringCharacters = string->characters();
99	for (unsigned i = 0; i != length; ++i) {	99	for (unsigned i = 0; i != length; ++i) {
100	if (stringCharacters++ != characters++)	100	if (stringCharacters++ != characters++)

Return to Bug 19775

Lines 1820-1832 static TCMalloc_Central_FreeListPadded central_cache[kNumClasses]; a/JavaScriptCore/wtf/FastMalloc.cpp_sec1
- a/JavaScriptCore/wtf/FastMalloc.cpp -2 / +2 lines
1820		1820
1821	// Page-level allocator	1821	// Page-level allocator
1822	static SpinLock pageheap_lock = SPINLOCK_INITIALIZER;	1822	static SpinLock pageheap_lock = SPINLOCK_INITIALIZER;
1823	static void* pageheap_memory[(sizeof(TCMalloc_PageHeap) + sizeof(void) - 1) / sizeof(void)];	1823	static uint64_t pageheap_memory[(sizeof(TCMalloc_PageHeap) + sizeof(uint64_t) - 1) / sizeof(uint64_t)];
1824	static bool phinited = false;	1824	static bool phinited = false;
1825		1825
1826	// Avoid extra level of indirection by making "pageheap" be just an alias	1826	// Avoid extra level of indirection by making "pageheap" be just an alias
1827	// of pageheap_memory.	1827	// of pageheap_memory.
1828	typedef union {	1828	typedef union {
1829	void* m_memory;	1829	uint64_t* m_memory;
1830	TCMalloc_PageHeap* m_pageHeap;	1830	TCMalloc_PageHeap* m_pageHeap;
1831	} PageHeapUnion;	1831	} PageHeapUnion;
1832		1832

Lines 172-177 a/JavaScriptCore/wtf/Platform.h_sec1
- a/JavaScriptCore/wtf/Platform.h +17 lines
172	#define WTF_PLATFORM_X86_64 1	172	#define WTF_PLATFORM_X86_64 1
173	#endif	173	#endif
174		174
		175	/* PLATFORM(SPARC) */
		176	#if defined(__sparc__) \
		177	\|\| defined(__sparc) \
		178	#define WTF_PLATFORM_SPARC 1
		179	#define WTF_PLATFORM_BIG_ENDIAN 1
		180	#endif
		181
		182	/* For undefined platforms */
		183	#if !defined(WTF_PLATFORM_BIG_ENDIAN) && !defined(WTF_PLATFORM_MIDDLE_ENDIAN)
		184	#include <sys/param.h>
		185	#if __BYTE_ORDER == __BIG_ENDIAN
		186	#define WTF_PLATFORM_BIG_ENDIAN 1
		187	#elif __BYTE_ORDER == __PDP_ENDIAN
		188	#define WTF_PLATFORM_MIDDLE_ENDIAN 1
		189	#endif
		190	#endif
		191
175	/* Compiler */	192	/* Compiler */
176		193
177	/* COMPILER(MSVC) */	194	/* COMPILER(MSVC) */

Lines 383-390 namespace WTF { a/JavaScriptCore/wtf/Vector.h_sec1
- a/JavaScriptCore/wtf/Vector.h -2 / +1 lines
383	static const size_t m_inlineBufferSize = inlineCapacity * sizeof(T);	383	static const size_t m_inlineBufferSize = inlineCapacity * sizeof(T);
384	T* inlineBuffer() { return reinterpret_cast<T*>(&m_inlineBuffer); }	384	T* inlineBuffer() { return reinterpret_cast<T*>(&m_inlineBuffer); }
385		385
386	// FIXME: Nothing guarantees this buffer is appropriately aligned to hold objects of type T.	386	uuint64_t m_inlineBuffer[(m_inlineBufferSize + sizeof(uint64_t) - 1) / sizeof(uint64_t)];
387	char m_inlineBuffer[m_inlineBufferSize];
388	};	387	};
389		388
390	template<typename T, size_t inlineCapacity = 0>	389	template<typename T, size_t inlineCapacity = 0>