An intrusive list node.
An intrusive list node.A base class to enable membership in intrusive lists, including simple_ilist, iplist, and ilist. The first template parameter is the value_type for the list.
An ilist node can be configured with compile-time options to change behaviour and/or add API.
To turn sentinel tracking on all the time, pass in the ilist_sentinel_tracking<true> template parameter. This also enables the isSentinel() function. The same option must be passed to the intrusive list. (ilist_sentinel_tracking<false> turns sentinel tracking off all the time.)
struct A {}; struct B {}; struct N : ilist_node<N, ilist_tag<A>>, ilist_node<N, ilist_tag<B>> {};
void foo() { simple_ilist<N, ilist_tag<A>> ListA; simple_ilist<N, ilist_tag<B>> ListB; N N1; ListA.push_back(N1); ListB.push_back(N1); } \endexample
#ifndef LLVM_ADT_ILIST_NODE_H
#define LLVM_ADT_ILIST_NODE_H
namespace ilist_detail {
struct NodeAccess;
}
template <class OptionsT, bool IsReverse, bool IsConst> class ilist_iterator;
template <class OptionsT> class ilist_sentinel;
template <class OptionsT> class ilist_node_impl : OptionsT::node_base_type {
using value_type = typename OptionsT::value_type;
using node_base_type = typename OptionsT::node_base_type;
using list_base_type = typename OptionsT::list_base_type;
friend typename OptionsT::list_base_type;
friend struct ilist_detail::NodeAccess;
friend class ilist_sentinel<OptionsT>;
friend class ilist_iterator<OptionsT,
false,
false>;
friend class ilist_iterator<OptionsT,
false,
true>;
friend class ilist_iterator<OptionsT,
true,
false>;
friend class ilist_iterator<OptionsT,
true,
true>;
protected:
private:
}
}
}
}
public:
}
}
using node_base_type::isKnownSentinel;
static_assert(OptionsT::is_sentinel_tracking_explicit,
"Use ilist_sentinel_tracking<true> to enable isSentinel()");
return node_base_type::isSentinel();
}
};
class ilist_node
: public ilist_node_impl<
typename ilist_detail::compute_node_options<T, Options...>::type> {
"Unrecognized node option!");
};
namespace ilist_detail {
struct NodeAccess {
protected:
template <class OptionsT>
static ilist_node_impl<OptionsT> *
getNodePtr(
typename OptionsT::pointer
N) {
}
template <class OptionsT>
static const ilist_node_impl<OptionsT> *
}
template <class OptionsT>
static typename OptionsT::pointer
getValuePtr(ilist_node_impl<OptionsT> *
N) {
return static_cast<typename OptionsT::pointer
>(
N);
}
template <class OptionsT>
static typename OptionsT::const_pointer
return static_cast<typename OptionsT::const_pointer
>(
N);
}
template <class OptionsT>
static ilist_node_impl<OptionsT> *
getPrev(ilist_node_impl<OptionsT> &
N) {
}
template <class OptionsT>
static ilist_node_impl<OptionsT> *
getNext(ilist_node_impl<OptionsT> &
N) {
}
template <class OptionsT>
static const ilist_node_impl<OptionsT> *
getPrev(
const ilist_node_impl<OptionsT> &
N) {
}
template <class OptionsT>
static const ilist_node_impl<OptionsT> *
getNext(
const ilist_node_impl<OptionsT> &
N) {
}
};
template <class OptionsT> struct SpecificNodeAccess : NodeAccess {
protected:
using pointer =
typename OptionsT::pointer;
return NodeAccess::getNodePtr<OptionsT>(
N);
}
return NodeAccess::getNodePtr<OptionsT>(
N);
}
return NodeAccess::getValuePtr<OptionsT>(
N);
}
return NodeAccess::getValuePtr<OptionsT>(
N);
}
};
}
template <class OptionsT>
class ilist_sentinel : public ilist_node_impl<OptionsT> {
public:
this->initializeSentinel();
}
this->setPrev(this);
this->setNext(this);
}
bool empty()
const {
return this == this->getPrev(); }
};
template <
typename NodeTy,
typename ParentTy,
class...
Options>
class ilist_node_with_parent : public ilist_node<NodeTy, Options...> {
protected:
private:
const ParentTy *getNodeParent() const {
return static_cast<const NodeTy *
>(
this)->
getParent();
}
public:
getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
return List.getPrevNode(*
static_cast<NodeTy *
>(
this));
}
}
getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
return List.getNextNode(*
static_cast<NodeTy *
>(
this));
}
}
};
}
#endif
static const Function * getParent(const Value *V)
Given that RA is a live value
ilist_node_impl()=default
bool isSentinel() const
Check whether this is the sentinel node.
ilist_iterator< OptionsT, false, false > self_iterator
friend class ilist_iterator< OptionsT, true, false >
friend class ilist_iterator< OptionsT, true, true >
ilist_iterator< OptionsT, true, false > reverse_self_iterator
ilist_iterator< OptionsT, false, true > const_self_iterator
friend class ilist_iterator< OptionsT, false, false >
friend class ilist_iterator< OptionsT, false, true >
reverse_self_iterator getReverseIterator()
ilist_iterator< OptionsT, true, true > const_reverse_self_iterator
self_iterator getIterator()
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
ilist_node_with_parent()=default
This is an optimization pass for GlobalISel generic memory operations.
static ilist_node_impl< OptionsT > * getPrev(ilist_node_impl< OptionsT > &N)
static ilist_node_impl< OptionsT > * getNext(ilist_node_impl< OptionsT > &N)
static ilist_node_impl< OptionsT > * getNodePtr(typename OptionsT::pointer N)
static OptionsT::pointer getValuePtr(ilist_node_impl< OptionsT > *N)
static pointer getValuePtr(node_type *N)
typename OptionsT::const_pointer const_pointer
ilist_node_impl< OptionsT > node_type
static node_type * getNodePtr(pointer N)
typename OptionsT::pointer pointer