CSSValue Immediates: Change RefPtr<CSSValue> to store tagged pointers

Source/core/css/CSSValue.h

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 13 matching lines @@
 #include "core/CoreExport.h"
 #include "platform/heap/Handle.h"
 #include "platform/weborigin/KURL.h"
 #include "wtf/HashMap.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
+class CSSValue;
+
+struct CSSTaggedPtrValue {
+    // Variables for accessing parts of the tagged pointer.
+    // 32 bits = <value 25 bits><type 6 bits><tag 1 bit>
+    // 64 bits = <value 57 bits><type 6 bits><tag 1 bit>
+    unsigned flag : 1;
+    unsigned type : 6;
+#if CPU(32BIT)
+    unsigned long long value : 25;
+#elif CPU(64BIT)
+    unsigned long long value : 57;
+#endif
+};
+
+// In some cases, CSSValue is a tagged pointer. If isTaggedPtr() returns true,
+// |this| is an invalid pointer and member variables should not be accessed.
 class CORE_EXPORT CSSValue : public RefCountedWillBeGarbageCollectedFinalized<CSSValue> {
 public:
 #if ENABLE(OILPAN)
     // Override operator new to allocate CSSValue subtype objects onto
     // a dedicated heap.
     GC_PLUGIN_IGNORE("crbug.com/443854")
     void* operator new(size_t size)
     {
         return allocateObject(size, false);
     }
     static void* allocateObject(size_t size, bool isEager)
     {
         ThreadState* state = ThreadStateFor<ThreadingTrait<CSSValue>::Affinity>::state();
         return Heap::allocateOnHeapIndex(state, size, isEager ? ThreadState::EagerSweepHeapIndex : ThreadState::CSSValueHeapIndex, GCInfoTrait<CSSValue>::index());
     }
 #else
+    void ref()
+    {
+        if (!isTaggedPtr())
+            RefCountedBase::ref();
+    }
+
     // Override RefCounted's deref() to ensure operator delete is called on
     // the appropriate subclass type.
     void deref()
     {
-        if (derefBase())
+        if (!isTaggedPtr() && derefBase())
             destroy();
     }
 #endif // !ENABLE(OILPAN)
 
     String cssText() const;
 
-    bool isPrimitiveValue() const { return m_classType == PrimitiveClass; }
-    bool isValueList() const { return m_classType >= ValueListClass; }
+    bool isPrimitiveValue() const { return isTaggedPtr() || m_classType == PrimitiveClass; }
+    bool isValueList() const { return !isTaggedPtr() && m_classType >= ValueListClass; }
 
-    bool isBaseValueList() const { return m_classType == ValueListClass; }
+    bool isBaseValueList() const { return !isTaggedPtr() && m_classType == ValueListClass; }
 
-    bool isBorderImageSliceValue() const { return m_classType == BorderImageSliceClass; }
-    bool isCanvasValue() const { return m_classType == CanvasClass; }
-    bool isCursorImageValue() const { return m_classType == CursorImageClass; }
-    bool isCrossfadeValue() const { return m_classType == CrossfadeClass; }
-    bool isFontFeatureValue() const { return m_classType == FontFeatureClass; }
-    bool isFontFaceSrcValue() const { return m_classType == FontFaceSrcClass; }
-    bool isFunctionValue() const { return m_classType == FunctionClass; }
-    bool isImageGeneratorValue() const { return m_classType >= CanvasClass && m_classType <= RadialGradientClass; }
-    bool isGradientValue() const { return m_classType >= LinearGradientClass && m_classType <= RadialGradientClass; }
-    bool isImageSetValue() const { return m_classType == ImageSetClass; }
-    bool isImageValue() const { return m_classType == ImageClass; }
+    bool isBorderImageSliceValue() const { return !isTaggedPtr() && m_classType == BorderImageSliceClass; }
+    bool isCanvasValue() const { return !isTaggedPtr() && m_classType == CanvasClass; }
+    bool isCursorImageValue() const { return !isTaggedPtr() && m_classType == CursorImageClass; }
+    bool isCrossfadeValue() const { return !isTaggedPtr() && m_classType == CrossfadeClass; }
+    bool isFontFeatureValue() const { return !isTaggedPtr() && m_classType == FontFeatureClass; }
+    bool isFontFaceSrcValue() const { return !isTaggedPtr() && m_classType == FontFaceSrcClass; }
+    bool isFunctionValue() const { return !isTaggedPtr() && m_classType == FunctionClass; }
+    bool isImageGeneratorValue() const { return !isTaggedPtr() && m_classType >= CanvasClass && m_classType <= RadialGradientClass; }
+    bool isGradientValue() const { return !isTaggedPtr() && m_classType >= LinearGradientClass && m_classType <= RadialGradientClass; }
+    bool isImageSetValue() const { return !isTaggedPtr() && m_classType == ImageSetClass; }
+    bool isImageValue() const { return !isTaggedPtr() && m_classType == ImageClass; }
     bool isImplicitInitialValue() const;
-    bool isInheritedValue() const { return m_classType == InheritedClass; }
-    bool isInitialValue() const { return m_classType == InitialClass; }
-    bool isUnsetValue() const { return m_classType == UnsetClass; }
-    bool isCSSWideKeyword() const { return m_classType >= InheritedClass && m_classType <= UnsetClass; }
-    bool isLinearGradientValue() const { return m_classType == LinearGradientClass; }
-    bool isPathValue() const { return m_classType == PathClass; }
-    bool isRadialGradientValue() const { return m_classType == RadialGradientClass; }
-    bool isReflectValue() const { return m_classType == ReflectClass; }
-    bool isShadowValue() const { return m_classType == ShadowClass; }
-    bool isCubicBezierTimingFunctionValue() const { return m_classType == CubicBezierTimingFunctionClass; }
-    bool isStepsTimingFunctionValue() const { return m_classType == StepsTimingFunctionClass; }
-    bool isLineBoxContainValue() const { return m_classType == LineBoxContainClass; }
-    bool isCalcValue() const {return m_classType == CalculationClass; }
-    bool isGridTemplateAreasValue() const { return m_classType == GridTemplateAreasClass; }
-    bool isSVGDocumentValue() const { return m_classType == CSSSVGDocumentClass; }
-    bool isContentDistributionValue() const { return m_classType == CSSContentDistributionClass; }
-    bool isUnicodeRangeValue() const { return m_classType == UnicodeRangeClass; }
-    bool isGridLineNamesValue() const { return m_classType == GridLineNamesClass; }
+    bool isInheritedValue() const { return !isTaggedPtr() && m_classType == InheritedClass; }
+    bool isInitialValue() const { return !isTaggedPtr() && m_classType == InitialClass; }
+    bool isUnsetValue() const { return !isTaggedPtr() && m_classType == UnsetClass; }
+    bool isCSSWideKeyword() const { return !isTaggedPtr() && m_classType >= InheritedClass && m_classType <= UnsetClass; }
+    bool isLinearGradientValue() const { return !isTaggedPtr() && m_classType == LinearGradientClass; }
+    bool isPathValue() const { return !isTaggedPtr() && m_classType == PathClass; }
+    bool isRadialGradientValue() const { return !isTaggedPtr() && m_classType == RadialGradientClass; }
+    bool isReflectValue() const { return !isTaggedPtr() && m_classType == ReflectClass; }
+    bool isShadowValue() const { return !isTaggedPtr() && m_classType == ShadowClass; }
+    bool isCubicBezierTimingFunctionValue() const { return !isTaggedPtr() && m_classType == CubicBezierTimingFunctionClass; }
+    bool isStepsTimingFunctionValue() const { return !isTaggedPtr() && m_classType == StepsTimingFunctionClass; }
+    bool isLineBoxContainValue() const { return !isTaggedPtr() && m_classType == LineBoxContainClass; }
+    bool isCalcValue() const {return !isTaggedPtr() && m_classType == CalculationClass; }
+    bool isGridTemplateAreasValue() const { return !isTaggedPtr() && m_classType == GridTemplateAreasClass; }
+    bool isSVGDocumentValue() const { return !isTaggedPtr() && m_classType == CSSSVGDocumentClass; }
+    bool isContentDistributionValue() const { return !isTaggedPtr() && m_classType == CSSContentDistributionClass; }
+    bool isUnicodeRangeValue() const { return !isTaggedPtr() && m_classType == UnicodeRangeClass; }
+    bool isGridLineNamesValue() const { return !isTaggedPtr() && m_classType == GridLineNamesClass; }
 
     bool hasFailedOrCanceledSubresources() const;
 
     bool equals(const CSSValue&) const;
 
     void finalizeGarbageCollectedObject();
     DEFINE_INLINE_TRACE_AFTER_DISPATCH() { }
     DECLARE_TRACE();
 
     // ~CSSValue should be public, because non-public ~CSSValue causes C2248
@@ skipping 61 matching lines @@
 
     ClassType classType() const { return static_cast<ClassType>(m_classType); }
 
     explicit CSSValue(ClassType classType)
         : m_primitiveUnitType(0)
         , m_hasCachedCSSText(false)
         , m_isQuirkValue(false)
         , m_valueListSeparator(SpaceSeparator)
         , m_classType(classType)
     {
+        ASSERT(!isTaggedPtr());
     }
 
     // NOTE: This class is non-virtual for memory and performance reasons.
     // Don't go making it virtual again unless you know exactly what you're doing!
 
 private:
     void destroy();
 
 protected:
     // The bits in this section are only used by specific subclasses but kept here
     // to maximize struct packing.
 
     // CSSPrimitiveValue bits:
     unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitType
     mutable unsigned m_hasCachedCSSText : 1;
     unsigned m_isQuirkValue : 1;
 
     unsigned m_valueListSeparator : ValueListSeparatorBits;
 
 private:
     unsigned m_classType : ClassTypeBits; // ClassType
+
+    inline bool isTaggedPtr() const
+    {
+        return reinterpret_cast<uintptr_t>(this) & 1;
+    }
 };
 
 template<typename CSSValueType, size_t inlineCapacity>
 inline bool compareCSSValueVector(const WillBeHeapVector<RefPtrWillBeMember<CSSValueType>, inlineCapacity>& firstVector, const WillBeHeapVector<RefPtrWillBeMember<CSSValueType>, inlineCapacity>& secondVector)
 {
     size_t size = firstVector.size();
     if (size != secondVector.size())
         return false;
 
     for (size_t i = 0; i < size; i++) {
@@ skipping 34 matching lines @@
     if (!first || !second)
         return false;
     return first->equals(*second);
 }
 
 #define DEFINE_CSS_VALUE_TYPE_CASTS(thisType, predicate) \
     DEFINE_TYPE_CASTS(thisType, CSSValue, value, value->predicate, value.predicate)
 
 } // namespace blink
 
+namespace WTF {
+
+#if !ENABLE(OILPAN)
+// Must be defined *after* CSSValue to compile with the correct adopted() method.
+template<> inline PassRefPtr<blink::CSSValue> adoptRef(blink::CSSValue* p)
+{
+    // Immediates (non-pointers) end in a 1.
+    if (!(reinterpret_cast<uintptr_t>(p) & 1))
+        WTF::adopted(p);
+    return PassRefPtr<blink::CSSValue>(p, PassRefPtr<blink::CSSValue>::AdoptRef);
+}
+#endif
+
+} // namespace WTF
+
 #endif // CSSValue_h