simple_ilist.h Source File (original) (raw)

9#ifndef LLVM_ADT_SIMPLE_ILIST_H

10#define LLVM_ADT_SIMPLE_ILIST_H

17#include

18#include

19#include

20#include

21#include

22#include

24namespace llvm {

77template <typename T, class... Options>

81 typename ilist_detail::compute_node_options<T, Options...>::type> {

83 "Unrecognized node option!");

84 using OptionsT =

86 using list_base_type = typename OptionsT::list_base_type;

89public:

90 using value_type = typename OptionsT::value_type;

91 using pointer = typename OptionsT::pointer;

92 using reference = typename OptionsT::reference;

102

105

106

109

110

117

130

131

132 [[nodiscard]] bool empty() const { return Sentinel.empty(); }

133

134

136

141

142

144

145

147

148

150

151

153

154

156

157

159 list_base_type::insertBefore(*I.getNodePtr(), *this->getNodePtr(&Node));

161 }

162

163

164 template

169

170

171 template <class Cloner, class Disposer>

177

178

179

180

181

183

184

185 template

190

191

192

193

194

196 assert(I != end() && "Cannot remove end of list!");

198 return I;

199 }

200

201

202

203

205 list_base_type::removeRange(*First.getNodePtr(), *Last.getNodePtr());

207 }

208

209

210 template

212 auto Next = std::next(I);

214 dispose(&*I);

216 }

217

218

219 template

225

226

227

228

229 void clear() { Sentinel.reset(); }

230

231

235

236

240

241

245

246

248 list_base_type::transferBefore(*I.getNodePtr(), *First.getNodePtr(),

249 *Last.getNodePtr());

250 }

251

252

253

254

255

258

259

260

261

263 template void sort(Compare comp);

264

265};

266

267template <class T, class... Options>

268template

270 if (this == &RHS || RHS.empty())

271 return;

274 while (LI != LE) {

275 if (comp(*RI, *LI)) {

276

278 RI = std::find_if(RI, RE, [&](reference RV) { return !comp(RV, *LI); });

280 if (RI == RE)

281 return;

282 }

283 ++LI;

284 }

285

287}

288

289template <class T, class... Options>

290template

292

294 return;

295

296

298 while (End != end() && ++End != end()) {

300 ++End;

301 }

304

305

307 RHS.sort(comp);

309}

310

311}

312

313#endif

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static LoopDeletionResult merge(LoopDeletionResult A, LoopDeletionResult B)

static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")

typename OptionsT::reference reference

Definition simple_ilist.h:92

iterator eraseAndDispose(iterator First, iterator Last, Disposer dispose)

Remove a range of nodes and dispose of them.

Definition simple_ilist.h:220

iterator eraseAndDispose(iterator I, Disposer dispose)

Remove a node by iterator and dispose of it.

Definition simple_ilist.h:211

void splice(iterator I, simple_ilist &, iterator First, iterator Last)

Splice in a range of nodes from another list.

Definition simple_ilist.h:247

typename OptionsT::const_reference const_reference

Definition simple_ilist.h:94

simple_ilist(simple_ilist &&X)

Definition simple_ilist.h:111

simple_ilist & operator=(const simple_ilist &)=delete

size_t size_type

Definition simple_ilist.h:100

const_reverse_iterator rend() const

Definition simple_ilist.h:127

const_reverse_iterator rbegin() const

Definition simple_ilist.h:123

void splice(iterator I, simple_ilist &L2)

Splice in another list.

Definition simple_ilist.h:237

const_reference front() const

Definition simple_ilist.h:138

simple_ilist & operator=(simple_ilist &&X)

Definition simple_ilist.h:112

reference back()

Definition simple_ilist.h:139

void swap(simple_ilist &X)

Swap with another list in place using std::swap.

Definition simple_ilist.h:155

const_reference back() const

Definition simple_ilist.h:140

iterator erase(iterator I)

Remove a node by iterator; never deletes.

Definition simple_ilist.h:195

ilist_select_iterator_type< OptionsT, true, true > const_reverse_iterator

Definition simple_ilist.h:98

void sort(Compare comp)

Definition simple_ilist.h:291

void pop_back()

Remove the node at the back; never deletes.

Definition simple_ilist.h:152

simple_ilist(const simple_ilist &)=delete

ptrdiff_t difference_type

Definition simple_ilist.h:101

void push_front(reference Node)

Insert a node at the front; never copies.

Definition simple_ilist.h:143

void cloneFrom(const simple_ilist &L2, Cloner clone, Disposer dispose)

Clone another list.

Definition simple_ilist.h:172

iterator insert(iterator I, reference Node)

Insert a node by reference; never copies.

Definition simple_ilist.h:158

reverse_iterator rend()

Definition simple_ilist.h:126

ilist_select_iterator_type< OptionsT, true, false > reverse_iterator

Definition simple_ilist.h:97

void merge(simple_ilist &RHS, Compare comp)

Definition simple_ilist.h:269

void merge(simple_ilist &RHS)

Merge in another list.

Definition simple_ilist.h:256

const_iterator end() const

Definition simple_ilist.h:121

void clear()

Clear the list; never deletes.

Definition simple_ilist.h:229

iterator end()

Definition simple_ilist.h:120

void insert(iterator I, Iterator First, Iterator Last)

Insert a range of nodes; never copies.

Definition simple_ilist.h:165

const_iterator begin() const

Definition simple_ilist.h:119

bool empty() const

Check if the list is empty in constant time.

Definition simple_ilist.h:132

iterator begin()

Definition simple_ilist.h:118

void pop_front()

Remove the node at the front; never deletes.

Definition simple_ilist.h:149

ilist_select_iterator_type< OptionsT, false, false > iterator

Definition simple_ilist.h:95

iterator erase(iterator First, iterator Last)

Remove a range of nodes; never deletes.

Definition simple_ilist.h:204

typename OptionsT::value_type value_type

Definition simple_ilist.h:90

void push_back(reference Node)

Insert a node at the back; never copies.

Definition simple_ilist.h:146

typename OptionsT::const_pointer const_pointer

Definition simple_ilist.h:93

ilist_select_iterator_type< OptionsT, false, true > const_iterator

Definition simple_ilist.h:96

void sort()

Sort the list.

Definition simple_ilist.h:262

void splice(iterator I, simple_ilist &L2, iterator Node)

Splice in a node from another list.

Definition simple_ilist.h:242

reverse_iterator rbegin()

Definition simple_ilist.h:122

void remove(reference N)

Remove a node by reference; never deletes.

Definition simple_ilist.h:182

void clearAndDispose(Disposer dispose)

Clear the list and dispose of the nodes.

Definition simple_ilist.h:232

typename OptionsT::pointer pointer

Definition simple_ilist.h:91

size_type size() const

Calculate the size of the list in linear time.

Definition simple_ilist.h:135

void removeAndDispose(reference N, Disposer dispose)

Remove a node by reference and dispose of it.

Definition simple_ilist.h:186

reference front()

Definition simple_ilist.h:137

This file defines the ilist_node class template, which is a convenient base class for creating classe...

This is an optimization pass for GlobalISel generic memory operations.

std::conditional_t< OptionsT::has_iterator_bits, ilist_iterator_w_bits< OptionsT, IsReverse, IsConst >, ilist_iterator< OptionsT, IsReverse, IsConst > > ilist_select_iterator_type

void sort(IteratorTy Start, IteratorTy End)

@ First

Helpers to iterate all locations in the MemoryEffectsBase class.

FunctionAddr VTableAddr Next

void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)

Implement std::swap in terms of BitVector swap.

static node_type * getNodePtr(pointer N)

Check whether options are valid.