Skip to content

GitLab

T
tangled
Commit 5ae81039 authored by Michael Lippautz's avatar Michael Lippautz Committed by Commit Bot
Browse files
Options

heap: Few trace traits cleanups 

- Use struct for AdjustPointerTrait.
- Replace TraceIfEnabled with TraceIfNeeded
- Avoid nullptr checks where the next call would anyways crash on
  dispatch

Bug: 1019191
Change-Id: Ib28d3b6c125623bac9a0bbbeda87dfa37528aa48
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1893061
Commit-Queue: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: default avatarOmer Katz <omerkatz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#712130}
parent 251d5b14
Hide whitespace changes
Inline Side-by-side
Showing with 40 additions and 80 deletions
third_party/blink/renderer/platform/heap/trace_traits.h
View file @ 5ae81039
...@@ -29,61 +29,47 @@ template <typename T> ...@@ -29,61 +29,47 @@ template <typename T>
class WeakMember; class WeakMember;
template <typename T, bool = NeedsAdjustPointer<T>::value> template <typename T, bool = NeedsAdjustPointer<T>::value>
class AdjustPointerTrait; struct AdjustPointerTrait;
template <typename T> template <typename T>
class AdjustPointerTrait<T, false> { struct AdjustPointerTrait<T, false> {
STATIC_ONLY(AdjustPointerTrait); STATIC_ONLY(AdjustPointerTrait);
public:
static TraceDescriptor GetTraceDescriptor(void* self) { static TraceDescriptor GetTraceDescriptor(void* self) {
return {self, TraceTrait<T>::Trace}; return {self, TraceTrait<T>::Trace};
} }
static HeapObjectHeader* GetHeapObjectHeader(void* self) { static HeapObjectHeader* GetHeapObjectHeader(void* self) {
#if DCHECK_IS_ON()
HeapObjectHeader::CheckFromPayload(self);
#endif
return HeapObjectHeader::FromPayload(self); return HeapObjectHeader::FromPayload(self);
} }
}; };
template <typename T> template <typename T>
class AdjustPointerTrait<T, true> { struct AdjustPointerTrait<T, true> {
STATIC_ONLY(AdjustPointerTrait); STATIC_ONLY(AdjustPointerTrait);
public: static TraceDescriptor GetTraceDescriptor(void* self) {
static TraceDescriptor GetTraceDescriptor(const T* self) { return static_cast<T*>(self)->GetTraceDescriptor();
DCHECK(self);
return self->GetTraceDescriptor();
} }
static HeapObjectHeader* GetHeapObjectHeader(const T* self) { static HeapObjectHeader* GetHeapObjectHeader(void* self) {
DCHECK(self); return static_cast<T*>(self)->GetHeapObjectHeader();
return self->GetHeapObjectHeader();
} }
}; };
template <typename T, bool isTraceable> template <typename T, bool = WTF::IsTraceable<T>::value>
struct TraceIfEnabled; struct TraceIfNeeded;
template <typename T> template <typename T>
struct TraceIfEnabled<T, false> { struct TraceIfNeeded<T, false> {
STATIC_ONLY(TraceIfEnabled); STATIC_ONLY(TraceIfNeeded);
template <typename VisitorDispatcher> static void Trace(blink::Visitor*, T&) {}
static void Trace(VisitorDispatcher, T&) {
static_assert(!WTF::IsTraceable<T>::value, "T should not be traced");
}
}; };
template <typename T> template <typename T>
struct TraceIfEnabled<T, true> { struct TraceIfNeeded<T, true> {
STATIC_ONLY(TraceIfEnabled); STATIC_ONLY(TraceIfNeeded);
template <typename VisitorDispatcher> static void Trace(blink::Visitor* visitor, T& t) { visitor->Trace(t); }
static void Trace(VisitorDispatcher visitor, T& t) {
static_assert(WTF::IsTraceable<T>::value, "T should not be traced");
visitor->Trace(t);
}
}; };
template <WTF::WeakHandlingFlag weakness, template <WTF::WeakHandlingFlag weakness,
...@@ -104,8 +90,7 @@ struct TraceCollectionIfEnabled<weakness, ...@@ -104,8 +90,7 @@ struct TraceCollectionIfEnabled<weakness,
static bool IsAlive(T&) { return true; } static bool IsAlive(T&) { return true; }
template <typename VisitorDispatcher> static bool Trace(blink::Visitor*, void*) {
static bool Trace(VisitorDispatcher, void*) {
static_assert(!WTF::IsTraceableInCollectionTrait<Traits>::value, static_assert(!WTF::IsTraceableInCollectionTrait<Traits>::value,
"T should not be traced"); "T should not be traced");
return false; return false;
...@@ -119,8 +104,8 @@ struct TraceCollectionIfEnabled<WTF::kNoWeakHandling, ...@@ -119,8 +104,8 @@ struct TraceCollectionIfEnabled<WTF::kNoWeakHandling,
false, false,
WTF::kWeakHandling> { WTF::kWeakHandling> {
STATIC_ONLY(TraceCollectionIfEnabled); STATIC_ONLY(TraceCollectionIfEnabled);
template <typename VisitorDispatcher>
static bool Trace(VisitorDispatcher visitor, void* t) { static bool Trace(blink::Visitor* visitor, void* t) {
return WTF::TraceInCollectionTrait<WTF::kNoWeakHandling, T, Traits>::Trace( return WTF::TraceInCollectionTrait<WTF::kNoWeakHandling, T, Traits>::Trace(
visitor, *reinterpret_cast<T*>(t)); visitor, *reinterpret_cast<T*>(t));
} }
...@@ -138,8 +123,7 @@ struct TraceCollectionIfEnabled { ...@@ -138,8 +123,7 @@ struct TraceCollectionIfEnabled {
return WTF::TraceInCollectionTrait<weakness, T, Traits>::IsAlive(traceable); return WTF::TraceInCollectionTrait<weakness, T, Traits>::IsAlive(traceable);
} }
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, void* t) {
static bool Trace(VisitorDispatcher visitor, void* t) {
static_assert(WTF::IsTraceableInCollectionTrait<Traits>::value || static_assert(WTF::IsTraceableInCollectionTrait<Traits>::value ||
weakness == WTF::kWeakHandling, weakness == WTF::kWeakHandling,
"Traits should be traced"); "Traits should be traced");
...@@ -199,8 +183,7 @@ struct TraceTrait<HeapVectorBacking<T, Traits>> { ...@@ -199,8 +183,7 @@ struct TraceTrait<HeapVectorBacking<T, Traits>> {
return {self, TraceTrait<Backing>::Trace}; return {self, TraceTrait<Backing>::Trace};
} }
template <typename VisitorDispatcher> static void Trace(blink::Visitor* visitor, void* self) {
static void Trace(VisitorDispatcher visitor, void* self) {
static_assert(!WTF::IsWeak<T>::value, static_assert(!WTF::IsWeak<T>::value,
"Weakness is not supported in HeapVector and HeapDeque"); "Weakness is not supported in HeapVector and HeapDeque");
if (WTF::IsTraceableInCollectionTrait<Traits>::value) { if (WTF::IsTraceableInCollectionTrait<Traits>::value) {
...@@ -284,12 +267,9 @@ struct TraceTrait<std::pair<T, U>> { ...@@ -284,12 +267,9 @@ struct TraceTrait<std::pair<T, U>> {
STATIC_ONLY(TraceTrait); STATIC_ONLY(TraceTrait);
public: public:
static const bool kFirstIsTraceable = WTF::IsTraceable<T>::value; static void Trace(blink::Visitor* visitor, std::pair<T, U>* pair) {
static const bool kSecondIsTraceable = WTF::IsTraceable<U>::value; TraceIfNeeded<T>::Trace(visitor, pair->first);
template <typename VisitorDispatcher> TraceIfNeeded<U>::Trace(visitor, pair->second);
static void Trace(VisitorDispatcher visitor, std::pair<T, U>* pair) {
TraceIfEnabled<T, kFirstIsTraceable>::Trace(visitor, pair->first);
TraceIfEnabled<U, kSecondIsTraceable>::Trace(visitor, pair->second);
} }
}; };
...@@ -302,20 +282,13 @@ struct TraceTrait<base::Optional<T>> { ...@@ -302,20 +282,13 @@ struct TraceTrait<base::Optional<T>> {
STATIC_ONLY(TraceTrait); STATIC_ONLY(TraceTrait);
public: public:
template <typename VisitorDispatcher> static void Trace(blink::Visitor* visitor, base::Optional<T>* optional) {
static void Trace(VisitorDispatcher visitor, base::Optional<T>* optional) {
if (*optional != base::nullopt) { if (*optional != base::nullopt) {
TraceIfEnabled<T, WTF::IsTraceable<T>::value>::Trace(visitor, TraceIfNeeded<T>::Trace(visitor, optional->value());
optional->value());
} }
} }
}; };
template <typename T>
struct TraceIfNeeded : public TraceIfEnabled<T, WTF::IsTraceable<T>::value> {
STATIC_ONLY(TraceIfNeeded);
};
// The parameter Strongify serve as an override for weak handling. If it is set // The parameter Strongify serve as an override for weak handling. If it is set
// to true, we ignore the kWeakHandlingFlag provided by the traits and always // to true, we ignore the kWeakHandlingFlag provided by the traits and always
// trace strongly (i.e. using kNoWeakHandling). // trace strongly (i.e. using kNoWeakHandling).
...@@ -386,8 +359,7 @@ template <typename T, typename Traits> ...@@ -386,8 +359,7 @@ template <typename T, typename Traits>
struct TraceNoWeakHandlingInCollectionHelper<blink::WeakMember<T>, struct TraceNoWeakHandlingInCollectionHelper<blink::WeakMember<T>,
Traits, Traits,
kWeakHandling> { kWeakHandling> {
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, blink::WeakMember<T>& t) {
static bool Trace(VisitorDispatcher visitor, blink::WeakMember<T>& t) {
visitor->Trace(t.Get()); visitor->Trace(t.Get());
return false; return false;
} }
...@@ -395,8 +367,7 @@ struct TraceNoWeakHandlingInCollectionHelper<blink::WeakMember<T>, ...@@ -395,8 +367,7 @@ struct TraceNoWeakHandlingInCollectionHelper<blink::WeakMember<T>,
template <typename T, typename Traits> template <typename T, typename Traits>
struct TraceNoWeakHandlingInCollectionHelper<T, Traits, kNoWeakHandling> { struct TraceNoWeakHandlingInCollectionHelper<T, Traits, kNoWeakHandling> {
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, T& t) {
static bool Trace(VisitorDispatcher visitor, T& t) {
static_assert(IsTraceableInCollectionTrait<Traits>::value, static_assert(IsTraceableInCollectionTrait<Traits>::value,
"T should not be traced"); "T should not be traced");
visitor->Trace(t); visitor->Trace(t);
...@@ -414,8 +385,7 @@ template <typename T, typename Traits> ...@@ -414,8 +385,7 @@ template <typename T, typename Traits>
struct TraceInCollectionTrait<kNoWeakHandling, T, Traits> { struct TraceInCollectionTrait<kNoWeakHandling, T, Traits> {
static bool IsAlive(T& t) { return true; } static bool IsAlive(T& t) { return true; }
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, T& t) {
static bool Trace(VisitorDispatcher visitor, T& t) {
return TraceNoWeakHandlingInCollectionHelper<T, Traits>::Trace(visitor, t); return TraceNoWeakHandlingInCollectionHelper<T, Traits>::Trace(visitor, t);
} }
}; };
...@@ -442,8 +412,7 @@ template <typename T, typename Traits> ...@@ -442,8 +412,7 @@ template <typename T, typename Traits>
struct TraceInCollectionTrait<kNoWeakHandling, struct TraceInCollectionTrait<kNoWeakHandling,
blink::HeapVectorBacking<T, Traits>, blink::HeapVectorBacking<T, Traits>,
void> { void> {
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, void* self) {
static bool Trace(VisitorDispatcher visitor, void* self) {
// HeapVectorBacking does not know the exact size of the vector // HeapVectorBacking does not know the exact size of the vector
// and just knows the capacity of the vector. Due to the constraint, // and just knows the capacity of the vector. Due to the constraint,
// HeapVectorBacking can support only the following objects: // HeapVectorBacking can support only the following objects:
...@@ -487,13 +456,13 @@ struct TraceInCollectionTrait<kNoWeakHandling, ...@@ -487,13 +456,13 @@ struct TraceInCollectionTrait<kNoWeakHandling,
for (unsigned i = 0; i < length; ++i) { for (unsigned i = 0; i < length; ++i) {
char* element = pointer + i * sizeof(T); char* element = pointer + i * sizeof(T);
if (blink::VTableInitialized(element)) if (blink::VTableInitialized(element))
blink::TraceIfEnabled< blink::TraceIfNeeded<
T, IsTraceableInCollectionTrait<Traits>::value>::Trace(visitor, T, IsTraceableInCollectionTrait<Traits>::value>::Trace(visitor,
array[i]); array[i]);
} }
} else { } else {
for (size_t i = 0; i < length; ++i) for (size_t i = 0; i < length; ++i)
blink::TraceIfEnabled< blink::TraceIfNeeded<
T, IsTraceableInCollectionTrait<Traits>::value>::Trace(visitor, T, IsTraceableInCollectionTrait<Traits>::value>::Trace(visitor,
array[i]); array[i]);
} }
...@@ -510,8 +479,7 @@ struct TraceHashTableBackingInCollectionTrait { ...@@ -510,8 +479,7 @@ struct TraceHashTableBackingInCollectionTrait {
using Value = typename Table::ValueType; using Value = typename Table::ValueType;
using Traits = typename Table::ValueTraits; using Traits = typename Table::ValueTraits;
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, void* self) {
static bool Trace(VisitorDispatcher visitor, void* self) {
static_assert(IsTraceableInCollectionTrait<Traits>::value || static_assert(IsTraceableInCollectionTrait<Traits>::value ||
Traits::kWeakHandlingFlag == kWeakHandling, Traits::kWeakHandlingFlag == kWeakHandling,
"Table should not be traced"); "Table should not be traced");
...@@ -537,8 +505,7 @@ template <typename Table> ...@@ -537,8 +505,7 @@ template <typename Table>
struct TraceInCollectionTrait<kNoWeakHandling, struct TraceInCollectionTrait<kNoWeakHandling,
blink::HeapHashTableBacking<Table>, blink::HeapHashTableBacking<Table>,
void> { void> {
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, void* self) {
static bool Trace(VisitorDispatcher visitor, void* self) {
return TraceHashTableBackingInCollectionTrait<kNoWeakHandling, return TraceHashTableBackingInCollectionTrait<kNoWeakHandling,
Table>::Trace(visitor, self); Table>::Trace(visitor, self);
} }
...@@ -548,8 +515,7 @@ template <typename Table> ...@@ -548,8 +515,7 @@ template <typename Table>
struct TraceInCollectionTrait<kWeakHandling, struct TraceInCollectionTrait<kWeakHandling,
blink::HeapHashTableBacking<Table>, blink::HeapHashTableBacking<Table>,
void> { void> {
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, void* self) {
static bool Trace(VisitorDispatcher visitor, void* self) {
return TraceHashTableBackingInCollectionTrait<kWeakHandling, Table>::Trace( return TraceHashTableBackingInCollectionTrait<kWeakHandling, Table>::Trace(
visitor, self); visitor, self);
} }
...@@ -585,8 +551,7 @@ struct TraceInCollectionTrait< ...@@ -585,8 +551,7 @@ struct TraceInCollectionTrait<
blink::HeapListHashSetAllocator<T, inlineCapacity>>; blink::HeapListHashSetAllocator<T, inlineCapacity>>;
using Table = HashTable<Node*, U, V, W, X, Y, blink::HeapAllocator>; using Table = HashTable<Node*, U, V, W, X, Y, blink::HeapAllocator>;
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, void* self) {
static bool Trace(VisitorDispatcher visitor, void* self) {
Node** array = reinterpret_cast<Node**>(self); Node** array = reinterpret_cast<Node**>(self);
blink::HeapObjectHeader* header = blink::HeapObjectHeader* header =
blink::HeapObjectHeader::FromPayload(self); blink::HeapObjectHeader::FromPayload(self);
...@@ -609,8 +574,7 @@ template <typename Key, typename Value, typename Traits> ...@@ -609,8 +574,7 @@ template <typename Key, typename Value, typename Traits>
struct TraceInCollectionTrait<kNoWeakHandling, struct TraceInCollectionTrait<kNoWeakHandling,
KeyValuePair<Key, Value>, KeyValuePair<Key, Value>,
Traits> { Traits> {
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, KeyValuePair<Key, Value>& self) {
static bool Trace(VisitorDispatcher visitor, KeyValuePair<Key, Value>& self) {
static_assert(IsTraceableInCollectionTrait<Traits>::value || static_assert(IsTraceableInCollectionTrait<Traits>::value ||
Traits::kWeakHandlingFlag == WTF::kWeakHandling, Traits::kWeakHandlingFlag == WTF::kWeakHandling,
"T should not be traced"); "T should not be traced");
...@@ -650,8 +614,7 @@ struct TraceInCollectionTrait<kWeakHandling, KeyValuePair<Key, Value>, Traits> { ...@@ -650,8 +614,7 @@ struct TraceInCollectionTrait<kWeakHandling, KeyValuePair<Key, Value>, Traits> {
false>::IsAlive(self.key, self.value); false>::IsAlive(self.key, self.value);
} }
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, KeyValuePair<Key, Value>& self) {
static bool Trace(VisitorDispatcher visitor, KeyValuePair<Key, Value>& self) {
// This is the core of the ephemeron-like functionality. If there is // This is the core of the ephemeron-like functionality. If there is
// weakness on the key side then we first check whether there are // weakness on the key side then we first check whether there are
// dead weak pointers on that side, and if there are we don't mark the // dead weak pointers on that side, and if there are we don't mark the
...@@ -697,8 +660,7 @@ struct TraceInCollectionTrait<kNoWeakHandling, ...@@ -697,8 +660,7 @@ struct TraceInCollectionTrait<kNoWeakHandling,
typename Traits::ValueTraits>::IsAlive(self.value_); typename Traits::ValueTraits>::IsAlive(self.value_);
} }
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, LinkedHashSetNode<Value>& self) {
static bool Trace(VisitorDispatcher visitor, LinkedHashSetNode<Value>& self) {
static_assert(IsTraceableInCollectionTrait<Traits>::value || static_assert(IsTraceableInCollectionTrait<Traits>::value ||
Traits::kWeakHandlingFlag == WTF::kWeakHandling, Traits::kWeakHandlingFlag == WTF::kWeakHandling,
"T should not be traced"); "T should not be traced");
...@@ -716,8 +678,7 @@ struct TraceInCollectionTrait<kWeakHandling, LinkedHashSetNode<Value>, Traits> { ...@@ -716,8 +678,7 @@ struct TraceInCollectionTrait<kWeakHandling, LinkedHashSetNode<Value>, Traits> {
typename Traits::ValueTraits>::IsAlive(self.value_); typename Traits::ValueTraits>::IsAlive(self.value_);
} }
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, LinkedHashSetNode<Value>& self) {
static bool Trace(VisitorDispatcher visitor, LinkedHashSetNode<Value>& self) {
return TraceInCollectionTrait< return TraceInCollectionTrait<
kWeakHandling, Value, typename Traits::ValueTraits>::Trace(visitor, kWeakHandling, Value, typename Traits::ValueTraits>::Trace(visitor,
self.value_); self.value_);
...@@ -736,8 +697,7 @@ struct TraceInCollectionTrait< ...@@ -736,8 +697,7 @@ struct TraceInCollectionTrait<
ListHashSetNode<Value, ListHashSetNode<Value,
blink::HeapListHashSetAllocator<Value, inlineCapacity>>; blink::HeapListHashSetAllocator<Value, inlineCapacity>>;
template <typename VisitorDispatcher> static bool Trace(blink::Visitor* visitor, Node* node) {
static bool Trace(VisitorDispatcher visitor, Node* node) {
static_assert(IsTraceableInCollectionTrait<Traits>::value || static_assert(IsTraceableInCollectionTrait<Traits>::value ||
Traits::kWeakHandlingFlag == WTF::kWeakHandling, Traits::kWeakHandlingFlag == WTF::kWeakHandling,
"T should not be traced"); "T should not be traced");
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment