LLVM  15.0.0git
ilist.h
Go to the documentation of this file.
1 //==-- llvm/ADT/ilist.h - Intrusive Linked List Template ---------*- C++ -*-==//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// This file defines classes to implement an intrusive doubly linked list class
11 /// (i.e. each node of the list must contain a next and previous field for the
12 /// list.
13 ///
14 /// The ilist class itself should be a plug in replacement for list. This list
15 /// replacement does not provide a constant time size() method, so be careful to
16 /// use empty() when you really want to know if it's empty.
17 ///
18 /// The ilist class is implemented as a circular list. The list itself contains
19 /// a sentinel node, whose Next points at begin() and whose Prev points at
20 /// rbegin(). The sentinel node itself serves as end() and rend().
21 ///
22 //===----------------------------------------------------------------------===//
23 
24 #ifndef LLVM_ADT_ILIST_H
25 #define LLVM_ADT_ILIST_H
26 
27 #include "llvm/ADT/simple_ilist.h"
28 #include <cassert>
29 #include <cstddef>
30 #include <iterator>
31 
32 namespace llvm {
33 
34 /// Use delete by default for iplist and ilist.
35 ///
36 /// Specialize this to get different behaviour for ownership-related API. (If
37 /// you really want ownership semantics, consider using std::list or building
38 /// something like \a BumpPtrList.)
39 ///
40 /// \see ilist_noalloc_traits
41 template <typename NodeTy> struct ilist_alloc_traits {
42  static void deleteNode(NodeTy *V) { delete V; }
43 };
44 
45 /// Custom traits to do nothing on deletion.
46 ///
47 /// Specialize ilist_alloc_traits to inherit from this to disable the
48 /// non-intrusive deletion in iplist (which implies ownership).
49 ///
50 /// If you want purely intrusive semantics with no callbacks, consider using \a
51 /// simple_ilist instead.
52 ///
53 /// \code
54 /// template <>
55 /// struct ilist_alloc_traits<MyType> : ilist_noalloc_traits<MyType> {};
56 /// \endcode
57 template <typename NodeTy> struct ilist_noalloc_traits {
58  static void deleteNode(NodeTy *V) {}
59 };
60 
61 /// Callbacks do nothing by default in iplist and ilist.
62 ///
63 /// Specialize this for to use callbacks for when nodes change their list
64 /// membership.
65 template <typename NodeTy> struct ilist_callback_traits {
66  void addNodeToList(NodeTy *) {}
67  void removeNodeFromList(NodeTy *) {}
68 
69  /// Callback before transferring nodes to this list. The nodes may already be
70  /// in this same list.
71  template <class Iterator>
72  void transferNodesFromList(ilist_callback_traits &OldList, Iterator /*first*/,
73  Iterator /*last*/) {
74  (void)OldList;
75  }
76 };
77 
78 /// A fragment for template traits for intrusive list that provides default
79 /// node related operations.
80 ///
81 /// TODO: Remove this layer of indirection. It's not necessary.
82 template <typename NodeTy>
84  ilist_callback_traits<NodeTy> {};
85 
86 /// Template traits for intrusive list.
87 ///
88 /// Customize callbacks and allocation semantics.
89 template <typename NodeTy>
90 struct ilist_traits : public ilist_node_traits<NodeTy> {};
91 
92 /// Const traits should never be instantiated.
93 template <typename Ty> struct ilist_traits<const Ty> {};
94 
95 namespace ilist_detail {
96 
97 template <class T> T &make();
98 
99 /// Type trait to check for a traits class that has a getNext member (as a
100 /// canary for any of the ilist_nextprev_traits API).
101 template <class TraitsT, class NodeT> struct HasGetNext {
102  typedef char Yes[1];
103  typedef char No[2];
104  template <size_t N> struct SFINAE {};
105 
106  template <class U>
107  static Yes &test(U *I, decltype(I->getNext(&make<NodeT>())) * = nullptr);
108  template <class> static No &test(...);
109 
110 public:
111  static const bool value = sizeof(test<TraitsT>(nullptr)) == sizeof(Yes);
112 };
113 
114 /// Type trait to check for a traits class that has a createSentinel member (as
115 /// a canary for any of the ilist_sentinel_traits API).
116 template <class TraitsT> struct HasCreateSentinel {
117  typedef char Yes[1];
118  typedef char No[2];
119 
120  template <class U>
121  static Yes &test(U *I, decltype(I->createSentinel()) * = nullptr);
122  template <class> static No &test(...);
123 
124 public:
125  static const bool value = sizeof(test<TraitsT>(nullptr)) == sizeof(Yes);
126 };
127 
128 /// Type trait to check for a traits class that has a createNode member.
129 /// Allocation should be managed in a wrapper class, instead of in
130 /// ilist_traits.
131 template <class TraitsT, class NodeT> struct HasCreateNode {
132  typedef char Yes[1];
133  typedef char No[2];
134  template <size_t N> struct SFINAE {};
135 
136  template <class U>
137  static Yes &test(U *I, decltype(I->createNode(make<NodeT>())) * = 0);
138  template <class> static No &test(...);
139 
140 public:
141  static const bool value = sizeof(test<TraitsT>(nullptr)) == sizeof(Yes);
142 };
143 
144 template <class TraitsT, class NodeT> struct HasObsoleteCustomization {
148 };
149 
150 } // end namespace ilist_detail
151 
152 //===----------------------------------------------------------------------===//
153 //
154 /// A wrapper around an intrusive list with callbacks and non-intrusive
155 /// ownership.
156 ///
157 /// This wraps a purely intrusive list (like simple_ilist) with a configurable
158 /// traits class. The traits can implement callbacks and customize the
159 /// ownership semantics.
160 ///
161 /// This is a subset of ilist functionality that can safely be used on nodes of
162 /// polymorphic types, i.e. a heterogeneous list with a common base class that
163 /// holds the next/prev pointers. The only state of the list itself is an
164 /// ilist_sentinel, which holds pointers to the first and last nodes in the
165 /// list.
166 template <class IntrusiveListT, class TraitsT>
169 
170 public:
181  typedef
183 
184 private:
185  // TODO: Drop this assertion and the transitive type traits anytime after
186  // v4.0 is branched (i.e,. keep them for one release to help out-of-tree code
187  // update).
188  static_assert(
190  "ilist customization points have changed!");
191 
192  static bool op_less(const_reference L, const_reference R) { return L < R; }
193  static bool op_equal(const_reference L, const_reference R) { return L == R; }
194 
195 public:
196  iplist_impl() = default;
197 
198  iplist_impl(const iplist_impl &) = delete;
199  iplist_impl &operator=(const iplist_impl &) = delete;
200 
202  : TraitsT(std::move(static_cast<TraitsT &>(X))),
203  IntrusiveListT(std::move(static_cast<IntrusiveListT &>(X))) {}
205  *static_cast<TraitsT *>(this) = std::move(static_cast<TraitsT &>(X));
206  *static_cast<IntrusiveListT *>(this) =
207  std::move(static_cast<IntrusiveListT &>(X));
208  return *this;
209  }
210 
212 
213  // Miscellaneous inspection routines.
214  size_type max_size() const { return size_type(-1); }
215 
216  using base_list_type::begin;
217  using base_list_type::end;
219  using base_list_type::rend;
220  using base_list_type::empty;
221  using base_list_type::front;
222  using base_list_type::back;
223 
225  assert(0 && "Swap does not use list traits callback correctly yet!");
227  }
228 
230  this->addNodeToList(New); // Notify traits that we added a node...
231  return base_list_type::insert(where, *New);
232  }
233 
235  return this->insert(where, new value_type(New));
236  }
237 
239  if (empty())
240  return insert(begin(), New);
241  else
242  return insert(++where, New);
243  }
244 
245  /// Clone another list.
246  template <class Cloner> void cloneFrom(const iplist_impl &L2, Cloner clone) {
247  clear();
248  for (const_reference V : L2)
249  push_back(clone(V));
250  }
251 
253  pointer Node = &*IT++;
254  this->removeNodeFromList(Node); // Notify traits that we removed a node...
256  return Node;
257  }
258 
260  iterator MutIt = IT;
261  return remove(MutIt);
262  }
263 
266 
267  // erase - remove a node from the controlled sequence... and delete it.
269  this->deleteNode(remove(where));
270  return where;
271  }
272 
275 
276  /// Remove all nodes from the list like clear(), but do not call
277  /// removeNodeFromList() or deleteNode().
278  ///
279  /// This should only be used immediately before freeing nodes in bulk to
280  /// avoid traversing the list and bringing all the nodes into cache.
282 
283 private:
284  // transfer - The heart of the splice function. Move linked list nodes from
285  // [first, last) into position.
286  //
287  void transfer(iterator position, iplist_impl &L2, iterator first, iterator last) {
288  if (position == last)
289  return;
290 
291  // Notify traits we moved the nodes...
292  this->transferNodesFromList(L2, first, last);
293 
294  base_list_type::splice(position, L2, first, last);
295  }
296 
297 public:
298  //===----------------------------------------------------------------------===
299  // Functionality derived from other functions defined above...
300  //
301 
302  using base_list_type::size;
303 
305  while (first != last)
306  first = erase(first);
307  return last;
308  }
309 
310  void clear() { erase(begin(), end()); }
311 
312  // Front and back inserters...
315  void pop_front() {
316  assert(!empty() && "pop_front() on empty list!");
317  erase(begin());
318  }
319  void pop_back() {
320  assert(!empty() && "pop_back() on empty list!");
321  iterator t = end(); erase(--t);
322  }
323 
324  // Special forms of insert...
325  template<class InIt> void insert(iterator where, InIt first, InIt last) {
326  for (; first != last; ++first) insert(where, *first);
327  }
328 
329  // Splice members - defined in terms of transfer...
330  void splice(iterator where, iplist_impl &L2) {
331  if (!L2.empty())
332  transfer(where, L2, L2.begin(), L2.end());
333  }
334  void splice(iterator where, iplist_impl &L2, iterator first) {
335  iterator last = first; ++last;
336  if (where == first || where == last) return; // No change
337  transfer(where, L2, first, last);
338  }
340  if (first != last) transfer(where, L2, first, last);
341  }
343  splice(where, L2, iterator(N));
344  }
346  splice(where, L2, iterator(N));
347  }
348 
349  template <class Compare>
350  void merge(iplist_impl &Right, Compare comp) {
351  if (this == &Right)
352  return;
353  this->transferNodesFromList(Right, Right.begin(), Right.end());
355  }
356  void merge(iplist_impl &Right) { return merge(Right, op_less); }
357 
358  using base_list_type::sort;
359 
360  /// Get the previous node, or \c nullptr for the list head.
362  auto I = N.getIterator();
363  if (I == begin())
364  return nullptr;
365  return &*std::prev(I);
366  }
367  /// Get the previous node, or \c nullptr for the list head.
369  return getPrevNode(const_cast<reference >(N));
370  }
371 
372  /// Get the next node, or \c nullptr for the list tail.
374  auto Next = std::next(N.getIterator());
375  if (Next == end())
376  return nullptr;
377  return &*Next;
378  }
379  /// Get the next node, or \c nullptr for the list tail.
381  return getNextNode(const_cast<reference >(N));
382  }
383 };
384 
385 /// An intrusive list with ownership and callbacks specified/controlled by
386 /// ilist_traits, only with API safe for polymorphic types.
387 ///
388 /// The \p Options parameters are the same as those for \a simple_ilist. See
389 /// there for a description of what's available.
390 template <class T, class... Options>
391 class iplist
392  : public iplist_impl<simple_ilist<T, Options...>, ilist_traits<T>> {
393  using iplist_impl_type = typename iplist::iplist_impl;
394 
395 public:
396  iplist() = default;
397 
398  iplist(const iplist &X) = delete;
399  iplist &operator=(const iplist &X) = delete;
400 
401  iplist(iplist &&X) : iplist_impl_type(std::move(X)) {}
403  *static_cast<iplist_impl_type *>(this) = std::move(X);
404  return *this;
405  }
406 };
407 
408 template <class T, class... Options> using ilist = iplist<T, Options...>;
409 
410 } // end namespace llvm
411 
412 namespace std {
413 
414  // Ensure that swap uses the fast list swap...
415  template<class Ty>
416  void swap(llvm::iplist<Ty> &Left, llvm::iplist<Ty> &Right) {
417  Left.swap(Right);
418  }
419 
420 } // end namespace std
421 
422 #endif // LLVM_ADT_ILIST_H
llvm::iplist_impl::erase
iterator erase(reference IT)
Definition: ilist.h:274
llvm::iplist_impl::clear
void clear()
Definition: ilist.h:310
llvm::binaryformat::last
@ last
Definition: Swift.h:19
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::ilist_detail::HasGetNext::No
char No[2]
Definition: ilist.h:103
llvm::iplist_impl::merge
void merge(iplist_impl &Right)
Definition: ilist.h:356
llvm::sys::path::rbegin
reverse_iterator rbegin(StringRef path, Style style=Style::native)
Get reverse begin iterator over path.
Definition: Path.cpp:297
llvm::iplist_impl::push_back
void push_back(pointer val)
Definition: ilist.h:314
llvm::iplist_impl::difference_type
base_list_type::difference_type difference_type
Definition: ilist.h:177
llvm::ilist_detail::HasGetNext::Yes
char Yes[1]
Definition: ilist.h:102
llvm::iplist_impl::pop_front
void pop_front()
Definition: ilist.h:315
llvm::iplist_impl::clearAndLeakNodesUnsafely
void clearAndLeakNodesUnsafely()
Remove all nodes from the list like clear(), but do not call removeNodeFromList() or deleteNode().
Definition: ilist.h:281
llvm::iplist_impl::pointer
base_list_type::pointer pointer
Definition: ilist.h:171
llvm::simple_ilist< llvm::AliasSet, Options... >::const_pointer
typename OptionsT::const_pointer const_pointer
Definition: simple_ilist.h:93
llvm::iplist_impl::erase
iterator erase(iterator first, iterator last)
Definition: ilist.h:304
llvm::iplist_impl::getNextNode
pointer getNextNode(reference N) const
Get the next node, or nullptr for the list tail.
Definition: ilist.h:373
llvm::ilist_detail::HasCreateSentinel
Type trait to check for a traits class that has a createSentinel member (as a canary for any of the i...
Definition: ilist.h:116
Right
Vector Shift Left Right
Definition: README_P9.txt:118
llvm::iplist_impl::const_reverse_iterator
base_list_type::const_reverse_iterator const_reverse_iterator
Definition: ilist.h:182
IT
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::values(clEnumValN(DefaultIT, "arm-default-it", "Generate any type of IT block"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow complex IT blocks")))
llvm::ilist_callback_traits
Callbacks do nothing by default in iplist and ilist.
Definition: ilist.h:65
llvm::iplist_impl::insert
void insert(iterator where, InIt first, InIt last)
Definition: ilist.h:325
llvm::sys::path::end
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:235
llvm::sys::path::begin
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:226
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::ilist_detail::HasGetNext::SFINAE
Definition: ilist.h:104
llvm::ilist_detail::HasCreateNode::test
static Yes & test(U *I, decltype(I->createNode(make< NodeT >())) *=0)
llvm::iplist_impl::remove
pointer remove(iterator &IT)
Definition: ilist.h:252
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::iplist_impl::cloneFrom
void cloneFrom(const iplist_impl &L2, Cloner clone)
Clone another list.
Definition: ilist.h:246
llvm::iplist
An intrusive list with ownership and callbacks specified/controlled by ilist_traits,...
Definition: ilist.h:391
llvm::iplist_impl::operator=
iplist_impl & operator=(iplist_impl &&X)
Definition: ilist.h:204
llvm::iplist_impl::splice
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:330
size_t
llvm::simple_ilist< llvm::AliasSet, Options... >::value_type
typename OptionsT::value_type value_type
Definition: simple_ilist.h:90
llvm::iplist_impl::erase
iterator erase(iterator where)
Definition: ilist.h:268
llvm::ilist_detail::HasObsoleteCustomization
Definition: ilist.h:144
llvm::iplist_impl::const_reference
base_list_type::const_reference const_reference
Definition: ilist.h:174
llvm::iplist_impl::getPrevNode
pointer getPrevNode(reference N) const
Get the previous node, or nullptr for the list head.
Definition: ilist.h:361
clear
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:149
llvm::simple_ilist< llvm::AliasSet, Options... >::reference
typename OptionsT::reference reference
Definition: simple_ilist.h:92
llvm::ilist_noalloc_traits::deleteNode
static void deleteNode(NodeTy *V)
Definition: ilist.h:58
llvm::iplist_impl::swap
void swap(iplist_impl &RHS)
Definition: ilist.h:224
llvm::iplist_impl::erase
iterator erase(pointer IT)
Definition: ilist.h:273
L2
add sub stmia L5 ldr L2
Definition: README.txt:201
ptrdiff_t
llvm::iplist_impl::push_front
void push_front(pointer val)
Definition: ilist.h:313
llvm::iplist_impl::splice
void splice(iterator where, iplist_impl &L2, reference N)
Definition: ilist.h:342
llvm::iplist_impl::iplist_impl
iplist_impl(iplist_impl &&X)
Definition: ilist.h:201
llvm::iplist_impl::splice
void splice(iterator where, iplist_impl &L2, iterator first)
Definition: ilist.h:334
t
bitcast float %x to i32 %s=and i32 %t, 2147483647 %d=bitcast i32 %s to float ret float %d } declare float @fabsf(float %n) define float @bar(float %x) nounwind { %d=call float @fabsf(float %x) ret float %d } This IR(from PR6194):target datalayout="e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target triple="x86_64-apple-darwin10.0.0" %0=type { double, double } %struct.float3=type { float, float, float } define void @test(%0, %struct.float3 *nocapture %res) nounwind noinline ssp { entry:%tmp18=extractvalue %0 %0, 0 t
Definition: README-SSE.txt:788
llvm::iplist::iplist
iplist(iplist &&X)
Definition: ilist.h:401
llvm::iplist_impl::operator=
iplist_impl & operator=(const iplist_impl &)=delete
llvm::ilist_detail::HasCreateSentinel::value
static const bool value
Definition: ilist.h:125
merge
static LoopDeletionResult merge(LoopDeletionResult A, LoopDeletionResult B)
Definition: LoopDeletion.cpp:53
llvm::iplist_impl
A wrapper around an intrusive list with callbacks and non-intrusive ownership.
Definition: ilist.h:167
llvm::ilist_detail::HasCreateNode::No
char No[2]
Definition: ilist.h:133
Options
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
Definition: PassBuilderBindings.cpp:48
llvm::ilist_detail::make
T & make()
llvm::iplist_impl::reference
base_list_type::reference reference
Definition: ilist.h:173
llvm::ilist_detail::HasCreateNode
Type trait to check for a traits class that has a createNode member.
Definition: ilist.h:131
llvm::iplist_impl::reverse_iterator
base_list_type::reverse_iterator reverse_iterator
Definition: ilist.h:180
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
llvm::ilist_detail::HasCreateSentinel::Yes
char Yes[1]
Definition: ilist.h:117
llvm::iplist_impl::const_pointer
base_list_type::const_pointer const_pointer
Definition: ilist.h:172
llvm::ilist_traits
Template traits for intrusive list.
Definition: ilist.h:90
llvm::iplist_impl::merge
void merge(iplist_impl &Right, Compare comp)
Definition: ilist.h:350
llvm::ilist_node_traits
A fragment for template traits for intrusive list that provides default node related operations.
Definition: ilist.h:83
val
The initial backend is deliberately restricted to z10 We should add support for later architectures at some point If an asm ties an i32 r result to an i64 the input will be treated as an leaving the upper bits uninitialised For i64 store i32 val
Definition: README.txt:15
std::swap
void swap(llvm::iplist< Ty > &Left, llvm::iplist< Ty > &Right)
Definition: ilist.h:416
llvm::iplist_impl::~iplist_impl
~iplist_impl()
Definition: ilist.h:211
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::iplist_impl::iterator
base_list_type::iterator iterator
Definition: ilist.h:178
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::iplist::iplist
iplist()=default
llvm::ilist_detail::HasCreateSentinel::test
static Yes & test(U *I, decltype(I->createSentinel()) *=nullptr)
I
#define I(x, y, z)
Definition: MD5.cpp:58
size
i< reg-> size
Definition: README.txt:166
llvm::ilist_alloc_traits
Use delete by default for iplist and ilist.
Definition: ilist.h:41
llvm::simple_ilist< llvm::AliasSet, Options... >::const_reference
typename OptionsT::const_reference const_reference
Definition: simple_ilist.h:94
llvm::ilist_detail::HasGetNext::test
static Yes & test(U *I, decltype(I->getNext(&make< NodeT >())) *=nullptr)
llvm::iplist_impl::remove
pointer remove(pointer IT)
Definition: ilist.h:264
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1675
std::swap
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:853
TraitsT
llvm::iplist_impl::getPrevNode
const_pointer getPrevNode(const_reference N) const
Get the previous node, or nullptr for the list head.
Definition: ilist.h:368
llvm::iplist_impl::remove
pointer remove(reference IT)
Definition: ilist.h:265
Compare
QP Compare Ordered outs ins xscmpudp No builtin are required Or llvm fcmp order unorder compare DP QP Compare builtin are required DP Compare
Definition: README_P9.txt:309
llvm::sys::fs::remove
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
llvm::ilist_noalloc_traits
Custom traits to do nothing on deletion.
Definition: ilist.h:57
IntrusiveListT
llvm::iplist_impl::insert
iterator insert(iterator where, const_reference New)
Definition: ilist.h:234
llvm::ilist_callback_traits::addNodeToList
void addNodeToList(NodeTy *)
When an MBB is added to an MF, we need to update the parent pointer of the MBB, the MBB numbering,...
Definition: ilist.h:66
llvm::iplist_impl::max_size
size_type max_size() const
Definition: ilist.h:214
Node
Definition: ItaniumDemangle.h:155
llvm::iplist_impl::iplist_impl
iplist_impl()=default
llvm::iplist_impl::getNextNode
const_pointer getNextNode(const_reference N) const
Get the next node, or nullptr for the list tail.
Definition: ilist.h:380
llvm::iplist_impl::remove
pointer remove(const iterator &IT)
Definition: ilist.h:259
llvm::iplist_impl::value_type
base_list_type::value_type value_type
Definition: ilist.h:175
llvm::empty
constexpr bool empty(const T &RangeOrContainer)
Test whether RangeOrContainer is empty. Similar to C++17 std::empty.
Definition: STLExtras.h:268
std
Definition: BitVector.h:851
llvm::ilist_iterator
Iterator for intrusive lists based on ilist_node.
Definition: ilist_iterator.h:57
llvm::iplist_impl::pop_back
void pop_back()
Definition: ilist.h:319
llvm::ilist_callback_traits::removeNodeFromList
void removeNodeFromList(NodeTy *)
Definition: ilist.h:67
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1562
llvm::iplist::operator=
iplist & operator=(iplist &&X)
Definition: ilist.h:402
llvm::ilist_detail::HasGetNext
Type trait to check for a traits class that has a getNext member (as a canary for any of the ilist_ne...
Definition: ilist.h:101
llvm::iplist_impl::insertAfter
iterator insertAfter(iterator where, pointer New)
Definition: ilist.h:238
llvm::iplist_impl::insert
iterator insert(iterator where, pointer New)
Definition: ilist.h:229
llvm::iplist_impl::splice
void splice(iterator where, iplist_impl &L2, iterator first, iterator last)
Definition: ilist.h:339
llvm::ilist_alloc_traits::deleteNode
static void deleteNode(NodeTy *V)
Definition: ilist.h:42
llvm::iplist_impl::size_type
base_list_type::size_type size_type
Definition: ilist.h:176
N
#define N
llvm::iplist_impl::const_iterator
base_list_type::const_iterator const_iterator
Definition: ilist.h:179
simple_ilist.h
llvm::ilist_detail::HasCreateNode::Yes
char Yes[1]
Definition: ilist.h:132
llvm::sys::path::rend
reverse_iterator rend(StringRef path)
Get reverse end iterator over path.
Definition: Path.cpp:306
llvm::ilist_detail::HasCreateNode::value
static const bool value
Definition: ilist.h:141
llvm::iplist_impl::splice
void splice(iterator where, iplist_impl &L2, pointer N)
Definition: ilist.h:345
llvm::ilist_detail::HasGetNext::value
static const bool value
Definition: ilist.h:111
llvm::simple_ilist< llvm::AliasSet, Options... >::pointer
typename OptionsT::pointer pointer
Definition: simple_ilist.h:91
llvm::ilist_detail::HasCreateSentinel::No
char No[2]
Definition: ilist.h:118
llvm::ilist_detail::HasObsoleteCustomization::value
static const bool value
Definition: ilist.h:145
llvm::ilist_callback_traits::transferNodesFromList
void transferNodesFromList(ilist_callback_traits &OldList, Iterator, Iterator)
Callback before transferring nodes to this list.
Definition: ilist.h:72
llvm::ilist_detail::HasCreateNode::SFINAE
Definition: ilist.h:134
llvm::iplist::operator=
iplist & operator=(const iplist &X)=delete