Attachment #435892 for bug #582522

Lines 156-164 Link Here

(-)qt-everywhere-opensource-src-4.8.7.old/src/3rdparty/javascriptcore/JavaScriptCore/runtime/Structure.cpp (-3 / +4 lines)
156	Structure::~Structure()	156	Structure::~Structure()
157	{	157	{
158	if (m_previous) {	158	if (m_previous) {
159	if (m_nameInPrevious)	159	if (m_nameInPrevious) {
160	m_previous->table.remove(StructureTransitionTableHash::Key(RefPtr<UString::Rep>(m_nameInPrevious.get()), m_attributesInPrevious), m_specificValueInPrevious);	160	unsigned attrInPrev = m_attributesInPrevious;
161	else	161	m_previous->table.remove(StructureTransitionTableHash::Key(RefPtr<UString::Rep>(m_nameInPrevious.get()), attrInPrev), m_specificValueInPrevious);
		162	} else
162	m_previous->table.removeAnonymousSlotTransition(m_anonymousSlotsInPrevious);	163	m_previous->table.removeAnonymousSlotTransition(m_anonymousSlotsInPrevious);
163		164
164	}	165	}

Lines 316-323 Link Here

(-)qt-everywhere-opensource-src-4.8.7.old/src/3rdparty/javascriptcore/JavaScriptCore/runtime/Structure.h (-2 / +4 lines)
316	Structure* existingTransition = singleTransition();	316	Structure* existingTransition = singleTransition();
317	TransitionTable* transitionTable = new TransitionTable;	317	TransitionTable* transitionTable = new TransitionTable;
318	setTransitionTable(transitionTable);	318	setTransitionTable(transitionTable);
319	if (existingTransition)	319	if (existingTransition) {
320	add(StructureTransitionTableHash::Key(RefPtr<UString::Rep>(existingTransition->m_nameInPrevious.get()), existingTransition->m_attributesInPrevious), existingTransition, existingTransition->m_specificValueInPrevious);	320	const unsigned attrsInPrev = existingTransition->m_attributesInPrevious;
		321	add(StructureTransitionTableHash::Key(RefPtr<UString::Rep>(existingTransition->m_nameInPrevious.get()), attrsInPrev), existingTransition, existingTransition->m_specificValueInPrevious);
		322	}
321	}	323	}
322	} // namespace JSC	324	} // namespace JSC
323		325





    using std::swap;

    // Work around MSVC's standard library, whose swap for pairs does not swap by component.
    template<typename T> inline void hashTableSwap(T& a, T& b)
    {
        swap(a, b);
    }

    template<typename T, typename U> inline void hashTableSwap(pair<T, U>& a, pair<T, U>& b)
    template<typename T, typename U> inline void swap(pair<T, U>& a, pair<T, U>& b)
    {
        swap(a.first, b.first);
        swap(a.second, b.second);
    }
#endif

    template<typename T, bool useSwap> struct Mover;
    template<typename T> struct Mover<T, true> { static void move(T& from, T& to) { hashTableSwap(from, to); } };
    template<typename T> struct Mover<T, false> { static void move(T& from, T& to) { to = from; } };

    template<typename Key, typename Value, typename HashFunctions> class IdentityHashTranslator {

Lines 76-81 Link Here

(-)qt-everywhere-opensource-src-4.8.7.old/src/3rdparty/javascriptcore/JavaScriptCore/wtf/Platform.h (+3 lines)
76	#if defined(__GNUC__) && !COMPILER(RVCT)	76	#if defined(__GNUC__) && !COMPILER(RVCT)
77	#define WTF_COMPILER_GCC 1	77	#define WTF_COMPILER_GCC 1
78	#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)	78	#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
		79	#define GCC_VERSION_AT_LEAST(major, minor, patch) (GCC_VERSION >= (major * 10000 + minor * 100 + patch))
		80	/* Define this for !GCC compilers, just so we can write things like GCC_VERSION_AT_LEAST(4, 1, 0). */
		81	#define GCC_VERSION_AT_LEAST(major, minor, patch) 0
79	#endif	82	#endif
80		83
81	/* COMPILER(MINGW) - MinGW GCC */	84	/* COMPILER(MINGW) - MinGW GCC */

Lines 26-31 Link Here

(-)qt-everywhere-opensource-src-4.8.7.old/src/3rdparty/javascriptcore/JavaScriptCore/wtf/TypeTraits.h (-10 / +14 lines)
26		26
27	#if (defined(__GLIBCXX__) && (__GLIBCXX__ >= 20070724) && defined(__GXX_EXPERIMENTAL_CXX0X__)) \|\| (defined(_MSC_VER) && (_MSC_VER >= 1600))	27	#if (defined(__GLIBCXX__) && (__GLIBCXX__ >= 20070724) && defined(__GXX_EXPERIMENTAL_CXX0X__)) \|\| (defined(_MSC_VER) && (_MSC_VER >= 1600))
28	#include <type_traits>	28	#include <type_traits>
		29	#if defined(__GLIBCXX__) && (__GLIBCXX__ >= 20070724) && defined(__GXX_EXPERIMENTAL_CXX0X__)
		30	#include <tr1/memory>
		31	#endif
29	#endif	32	#endif
30		33
31	namespace WTF {	34	namespace WTF {
Lines 166-178 Link Here
166	typedef T Type;	169	typedef T Type;
167	};	170	};
168		171
169	#if (defined(__GLIBCXX__) && (__GLIBCXX__ >= 20070724) && defined(__GXX_EXPERIMENTAL_CXX0X__)) \|\| (defined(_MSC_VER) && (_MSC_VER >= 1600))	172	#if COMPILER(CLANG) \|\| GCC_VERSION_AT_LEAST(4, 6, 0) \|\| (defined(_MSC_VER) && (_MSC_VER >= 1400) && (_MSC_VER < 1600) && !defined(__INTEL_COMPILER))
170		173	// VC8 (VS2005) and later has __has_trivial_constructor and __has_trivial_destructor,
		174	// but the implementation returns false for built-in types. We add the extra IsPod condition to
		175	// work around this.
		176	template <typename T> struct HasTrivialConstructor {
		177	static const bool value = __has_trivial_constructor(T) \|\| IsPod<RemoveConstVolatile<T> >::value;
		178	};
		179	template <typename T> struct HasTrivialDestructor {
		180	static const bool value = __has_trivial_destructor(T) \|\| IsPod<RemoveConstVolatile<T> >::value;
		181	};
		182	#elif (defined(__GLIBCXX__) && (__GLIBCXX__ >= 20070724) && defined(__GXX_EXPERIMENTAL_CXX0X__)) \|\| (defined(_MSC_VER) && (_MSC_VER >= 1600))
171	// GCC's libstdc++ 20070724 and later supports C++ TR1 type_traits in the std namespace.	183	// GCC's libstdc++ 20070724 and later supports C++ TR1 type_traits in the std namespace.
172	// VC10 (VS2010) and later support C++ TR1 type_traits in the std::tr1 namespace.	184	// VC10 (VS2010) and later support C++ TR1 type_traits in the std::tr1 namespace.
173	template<typename T> struct HasTrivialConstructor : public std::tr1::has_trivial_constructor<T> { };	185	template<typename T> struct HasTrivialConstructor : public std::tr1::has_trivial_constructor<T> { };
174	template<typename T> struct HasTrivialDestructor : public std::tr1::has_trivial_destructor<T> { };	186	template<typename T> struct HasTrivialDestructor : public std::tr1::has_trivial_destructor<T> { };
175
176	#else	187	#else
177		188
178	// This compiler doesn't provide type traits, so we provide basic HasTrivialConstructor	189	// This compiler doesn't provide type traits, so we provide basic HasTrivialConstructor
Lines 189-203 Link Here
189	typedef IntegralConstant<bool, true> true_type;	200	typedef IntegralConstant<bool, true> true_type;
190	typedef IntegralConstant<bool, false> false_type;	201	typedef IntegralConstant<bool, false> false_type;
191		202
192	#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__INTEL_COMPILER)
193	// VC8 (VS2005) and later have built-in compiler support for HasTrivialConstructor / HasTrivialDestructor,
194	// but for some unexplained reason it doesn't work on built-in types.
195	template <typename T> struct HasTrivialConstructor : public IntegralConstant<bool, __has_trivial_constructor(T)>{ };
196	template <typename T> struct HasTrivialDestructor : public IntegralConstant<bool, __has_trivial_destructor(T)>{ };
197	#else
198	template <typename T> struct HasTrivialConstructor : public false_type{ };	203	template <typename T> struct HasTrivialConstructor : public false_type{ };
199	template <typename T> struct HasTrivialDestructor : public false_type{ };	204	template <typename T> struct HasTrivialDestructor : public false_type{ };
200	#endif
201		205
202	template <typename T> struct HasTrivialConstructor<T*> : public true_type{ };	206	template <typename T> struct HasTrivialConstructor<T*> : public true_type{ };
203	template <typename T> struct HasTrivialDestructor<T*> : public true_type{ };	207	template <typename T> struct HasTrivialDestructor<T*> : public true_type{ };

Lines 719-725 Link Here

(-)qt-everywhere-opensource-src-4.8.7.old/src/3rdparty/javascriptcore/JavaScriptCore/yarr/RegexCompiler.cpp (-1 / +1 lines)
719		719
720	constructor.setupOffsets();	720	constructor.setupOffsets();
721		721
722	return false;	722	return NULL;
723	};	723	};
724		724
725		725

Return to bug 582522

Lines 257-275 Link Here

(-)qt-everywhere-opensource-src-4.8.7.old/src/3rdparty/javascriptcore/JavaScriptCore/wtf/HashTable.h (-6 / +7 lines)
257		257
258	using std::swap;	258	using std::swap;
259		259
260	#if !COMPILER(MSVC) && !OS(QNX) && !defined(_LIBCPP_VERSION)	260	// Work around MSVC's standard library, whose swap for pairs does not swap by component.
261	// The Dinkumware C++ library (used by MSVC and QNX) and clang's libc++ have a swap for pairs defined.	261	template<typename T> inline void hashTableSwap(T& a, T& b)
		262	{
		263	swap(a, b);
		264	}
262		265
263	// swap pairs by component, in case of pair members that specialize swap	266	template<typename T, typename U> inline void hashTableSwap(pair<T, U>& a, pair<T, U>& b)
264	template<typename T, typename U> inline void swap(pair<T, U>& a, pair<T, U>& b)
265	{	267	{
266	swap(a.first, b.first);	268	swap(a.first, b.first);
267	swap(a.second, b.second);	269	swap(a.second, b.second);
268	}	270	}
269	#endif
270		271
271	template<typename T, bool useSwap> struct Mover;	272	template<typename T, bool useSwap> struct Mover;
272	template<typename T> struct Mover<T, true> { static void move(T& from, T& to) { swap(from, to); } };	273	template<typename T> struct Mover<T, true> { static void move(T& from, T& to) { hashTableSwap(from, to); } };
273	template<typename T> struct Mover<T, false> { static void move(T& from, T& to) { to = from; } };	274	template<typename T> struct Mover<T, false> { static void move(T& from, T& to) { to = from; } };
274		275
275	template<typename Key, typename Value, typename HashFunctions> class IdentityHashTranslator {	276	template<typename Key, typename Value, typename HashFunctions> class IdentityHashTranslator {