Changeset 24059 in webkit for trunk/JavaScriptCore/wtf/HashTable.h

Timestamp:

Jul 6, 2007, 5:09:08 AM (18 years ago)

Author:

mjs

Message:

JavaScriptCore:

Reviewed by Antti.

• <rdar://problem/5311093> JavaScriptCore fails to build with strict-aliasing warnings

• Configurations/Base.xcconfig: Re-enable -Wstrict-aliasing
• bindings/jni/jni_utility.cpp: (KJS::Bindings::getJNIEnv): Type-pun via a union instead of a pointer cast.
• wtf/HashMap.h: (WTF::): Instead of doing type-punned assignments via pointer cast, do one of three things: (1) assign directly w/o cast if storage type matches real type; (2) assign using cast via union if type does not need reffing; (3) copy with memcpy and ref/deref manually if type needs reffing. This is ok peref-wise because memcpy of a constant length gets optomized. HashTraits are now expected to make ref()/deref() take the storage type, not the true type.
• wtf/HashSet.h: (WTF::): Same basic idea.
• wtf/HashTable.h: (WTF::): Added Assigner template for use by HashMap/HashSet. Change RefCounter to call ref() and deref() via storage type, avoiding the need to type-pun. (WTF::RefCounter::ref): ditto (WTF::RefCounter::deref): ditto
• wtf/HashTraits.h: (WTF::): Change ref() and deref() for RefPtr HashTraits to take the storage type; cast via union to pointer type.
• wtf/FastMalloc.cpp: (WTF::TCMalloc_PageHeap::init): Changed from constructor to init function so this can go in a union. (WTF::): redefine pageheap macro in terms of getPageHeap(). (WTF::getPageHeap): new inline function, helper for pageheap macro. This hides the cast in a union. (WTF::TCMalloc_ThreadCache::InitModule): Call init() instead of using placement new to initialize page heap.
• wtf/TCPageMap.h: (TCMalloc_PageMap1::init): Changed from constructor to init function. (TCMalloc_PageMap2::init): ditto (TCMalloc_PageMap3::init): ditto

WebCore:

Reviewed by Antti.

• <rdar://problem/5311093> JavaScriptCore fails to build with strict-aliasing warnings

• platform/StringHash.h: (WTF::): Adapt to newer way to do storage types.

File:

• trunk/JavaScriptCore/wtf/HashTable.h (modified) (4 diffs)

trunk/JavaScriptCore/wtf/HashTable.h

@@ -851 +851 @@
     };
 
-    template<bool needsRef, typename ValueTraits> struct RefCounterBase;
-
-    template<typename ValueTraits>
-    struct RefCounterBase<false, ValueTraits> {
-        typedef typename ValueTraits::TraitType ValueType;
-        static void ref(const ValueType&) { }
-        static void deref(const ValueType&) { }
-    };
-
-    template<typename ValueTraits>
-    struct RefCounterBase<true, ValueTraits> {
-        typedef typename ValueTraits::TraitType ValueType;
-        static void ref(const ValueType& v) { ValueTraits::ref(*(const ValueType*)&v); }
-        static void deref(const ValueType& v) { ValueTraits::deref(*(const ValueType*)&v); }
+    template<bool needsRef, typename ValueTraits, typename ValueStorageTraits> struct RefCounterBase;
+
+    template<typename ValueTraits, typename ValueStorageTraits>
+    struct RefCounterBase<false, ValueTraits, ValueStorageTraits> {
+        typedef typename ValueStorageTraits::TraitType ValueStorageType;
+        static void ref(const ValueStorageType&) { }
+        static void deref(const ValueStorageType&) { }
+    };
+
+    template<typename ValueTraits, typename ValueStorageTraits>
+    struct RefCounterBase<true, ValueTraits, ValueStorageTraits> {
+        typedef typename ValueStorageTraits::TraitType ValueStorageType;
+        static void ref(const ValueStorageType& v) { ValueTraits::ref(v); }
+        static void deref(const ValueStorageType& v) { ValueTraits::deref(v); }
     };
 
@@ -871 +871 @@
         typedef typename ValueStorageTraits::TraitType ValueStorageType;
         static const bool needsRef = NeedsRef<ValueTraits, ValueStorageTraits>::value;
-        typedef RefCounterBase<needsRef, ValueTraits> Base;
-        static void ref(const ValueStorageType& v) { Base::ref(*(const ValueType*)&v); }
-        static void deref(const ValueStorageType& v) { Base::deref(*(const ValueType*)&v); }
+        typedef RefCounterBase<needsRef, ValueTraits, ValueStorageTraits> Base;
+        static void ref(const ValueStorageType& v) { Base::ref(v); }
+        static void deref(const ValueStorageType& v) { Base::deref(v); }
     };
 
@@ -885 +885 @@
         static const bool firstNeedsRef = NeedsRef<FirstTraits, FirstStorageTraits>::value;
         static const bool secondNeedsRef = NeedsRef<SecondTraits, SecondStorageTraits>::value;
-        typedef RefCounterBase<firstNeedsRef, FirstTraits> FirstBase;
-        typedef RefCounterBase<secondNeedsRef, SecondTraits> SecondBase;
+        typedef RefCounterBase<firstNeedsRef, FirstTraits, FirstStorageTraits> FirstBase;
+        typedef RefCounterBase<secondNeedsRef, SecondTraits, SecondStorageTraits> SecondBase;
         static void ref(const ValueStorageType& v) {
-            FirstBase::ref(*(const FirstType*)&v.first);
-            SecondBase::ref(*(const SecondType*)&v.second);
+            FirstBase::ref(v.first);
+            SecondBase::ref(v.second);
         }
         static void deref(const ValueStorageType& v) {
-            FirstBase::deref(*(const FirstType*)&v.first);
-            SecondBase::deref(*(const SecondType*)&v.second);
+            FirstBase::deref(v.first);
+            SecondBase::deref(v.second);
         }
     };
@@ -938 +938 @@
     };
 
+    // helper template for HashMap and HashSet.
+    template<bool needsRef, typename FromType, typename ToType, typename FromTraits> struct Assigner;
+    
+    template<typename FromType, typename ToType, typename FromTraits> struct Assigner<false, FromType, ToType, FromTraits> {
+        typedef union { 
+            FromType m_from; 
+            ToType m_to; 
+        } UnionType;
+
+        static void assign(const FromType& from, ToType& to) { reinterpret_cast<UnionType*>(&to)->m_from = from; }
+    };
+    
+    template<typename FromType, typename ToType, typename FromTraits> struct Assigner<true, FromType, ToType, FromTraits> {
+        static void assign(const FromType& from, ToType& to) 
+        { 
+            ToType oldTo = to; 
+            memcpy(&to, &from, sizeof(FromType)); 
+            FromTraits::ref(to);
+            FromTraits::deref(oldTo);
+        }
+    };
+    
+    template<typename FromType, typename FromTraits> struct Assigner<false, FromType, FromType, FromTraits> {
+        static void assign(const FromType& from, FromType& to) { to = from; }
+    };    
+    
+    template<typename FromType, typename FromTraits> struct Assigner<true, FromType, FromType, FromTraits> {
+        static void assign(const FromType& from, FromType& to) { to = from; }
+    };    
+
 } // namespace WTF