LLVM: include/llvm/IR/BasicBlock.h Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13#ifndef LLVM_IR_BASICBLOCK_H
14#define LLVM_IR_BASICBLOCK_H
15
28#include
29#include
30#include
31
32namespace llvm {
33
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61class BasicBlock final : public Value,
63public:
66
67private:
68
70
71 unsigned Number = ~0u;
72
75
78
79public:
80
81
84
85
86
87
89
90
91
92
94
96 assert(getParent() && "only basic blocks in functions have valid numbers");
97 return Number;
98 }
99
100
101
102
103
105
106
107
108
110
111
112
114
116
117
118
119
121
122
123
124
126
127
129
130
133
134
135
136
137
139
140
141
142
143
144
147 std::optionalDbgRecord::self\_iterator Pos);
148
149private:
150 void setParent(Function *parent);
151
152
153
154
155
156
160
161public:
163 BasicBlock &operator=(const BasicBlock &) = delete;
165
166
168
169
174
175
183 ilist_iterator_bits,
184 ilist_parent>;
185
186
187
192 InstListType::iterator InsertPos);
193 friend void Instruction::moveBeforeImpl(BasicBlock &BB,
194 InstListType::iterator I,
195 bool Preserve);
198 const Instruction *From, std::optionalDbgRecord::self\_iterator FromHere,
199 bool InsertAtHead);
200
201
202
203
204
205
206 static BasicBlock *Create(LLVMContext &Context, const Twine &Name = "",
207 Function *Parent = nullptr,
208 BasicBlock *InsertBefore = nullptr) {
209 return new BasicBlock(Context, Name, Parent, InsertBefore);
210 }
211
212
215
216
217
218
219
222 return const_cast<Module *>(
223 static_cast<const BasicBlock *>(this)->getModule());
224 }
225
226
227
228
230
231
232
234 if (InstList.empty() || !InstList.back().isTerminator())
235 return nullptr;
236 return &InstList.back();
237 }
240 static_cast<const BasicBlock *>(this)->getTerminator());
241 }
242
243
244
245
248 return const_cast<CallInst *>(
249 static_cast<const BasicBlock *>(this)->getTerminatingDeoptimizeCall());
250 }
251
252
253
254
255
258 return const_cast<CallInst *>(static_cast<const BasicBlock *>(this)
259 ->getPostdominatingDeoptimizeCall());
260 }
261
262
263
264
267 return const_cast<CallInst *>(
268 static_cast<const BasicBlock *>(this)->getTerminatingMustTailCall());
269 }
270
271
272
273
274
275
276
277
278
279
281 "getFirstNonPHIIt") const
284 "getFirstNonPHIIt") Instruction *getFirstNonPHI();
285
286
287
288
289
290
291
292
293
294
298 static_cast<const BasicBlock *>(this)->getFirstNonPHIIt().getNonConst();
299 It.setHeadBit(true);
300 return It;
301 }
302
303
304
305
309 return static_cast<const BasicBlock *>(this)
311 .getNonConst();
312 }
313
314
315
316
321 return static_cast<const BasicBlock *>(this)
323 .getNonConst();
324 }
325
326
327
328
329
332 return static_cast<const BasicBlock *>(this)
334 .getNonConst();
335 }
336
337
338
341 return static_cast<const BasicBlock *>(this)
343 .getNonConst();
344 }
345
346
347
348
352 static_cast<const BasicBlock *>(this)->getFirstMayFaultInst());
353 }
354
355
356
357
362
363
364
365
369
370
373 std::function<bool(const Instruction &)>>::difference_type
375
376
378
379
380
381
383
384
385
390
391
392
394
395
396
397
398
399
400
403
404
405
408 return const_cast<BasicBlock *>(
409 static_cast<const BasicBlock *>(this)->getSinglePredecessor());
410 }
411
412
413
414
415
416
417
420 return const_cast<BasicBlock *>(
421 static_cast<const BasicBlock *>(this)->getUniquePredecessor());
422 }
423
424
426
427
429
430
431
432
433
436 return const_cast<BasicBlock *>(
437 static_cast<const BasicBlock *>(this)->getSingleSuccessor());
438 }
439
440
441
442
443
446 return const_cast<BasicBlock *>(
447 static_cast<const BasicBlock *>(this)->getUniqueSuccessor());
448 }
449
450
451
453 bool ShouldPreserveUseListOrder = false,
454 bool IsForDebug = false) const;
455
456
457
458
460 iterator It = InstList.begin();
461
462
463
464 It.setHeadBit(true);
465 return It;
466 }
469 It.setHeadBit(true);
470 return It;
471 }
474
479
480 inline size_t size() const { return InstList.size(); }
481 inline bool empty() const { return InstList.empty(); }
486
487
488 template
489 class phi_iterator_impl
491 std::forward_iterator_tag, PHINodeT> {
492 friend BasicBlock;
493
494 PHINodeT *PN;
495
497
498 public:
499
500
502
503
504 template <typename PHINodeU, typename BBIteratorU,
505 typename = std::enable_if_t<
506 std::is_convertible<PHINodeU *, PHINodeT *>::value>>
509
510 bool operator==(const phi_iterator_impl &Arg) const { return PN == Arg.PN; }
511
513
514 using phi_iterator_impl::iterator_facade_base::operator++;
516 assert(PN && "Cannot increment the end iterator!");
518 return *this;
519 }
520 };
524
525
526
527
529 return const_cast<BasicBlock *>(this)->phis();
530 }
532
533private:
534
535
536
537
538 const InstListType &getInstList() const { return InstList; }
539 InstListType &getInstList() { return InstList; }
540
541
542
543 static InstListType BasicBlock::*getSublistAccess(Instruction *) {
544 return &BasicBlock::InstList;
545 }
546
547
548
549
550 void spliceDebugInfoEmptyBlock(BasicBlock::iterator ToIt, BasicBlock *FromBB,
553
554
555
556
557
564
565 enum {
566 HasAddressTaken = 1 << 0,
567 InstrOrderValid = 1 << 1,
568 };
569
570 void setHasAddressTaken(bool B) {
571 if (B)
573 else
575 }
576
577
578
579 void setValueSubclassData(unsigned short D) {
581 }
582
583public:
584
586
587
589 return V->getValueID() == Value::BasicBlockVal;
590 }
591
592
593
594
595
596
597
598
599
601
602
603
604
605
606
607
609 bool KeepOneInputPHIs = false);
610
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
632 bool Before = false);
634 bool Before = false) {
636 }
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
656 const Twine &BBName = "");
660
661
665
666
667
670 auto FromItNext = std::next(FromIt);
671
672 if (ToIt == FromIt || ToIt == FromItNext)
673 return;
674 splice(ToIt, FromBB, FromIt, FromItNext);
675 }
676
677
678
682
683
684
687
688
689
693
694
695
697
698
699
701
702
703
705
706
708
709
710
711
712
714
715
719 static_cast<const BasicBlock *>(this)->getLandingPadInst());
720 }
721
722
724
725
726
728
730
731
735
736
741
742
744
745
746
747
748
749
750
751
752
754};
755
756
758
759
760
762
763#ifdef NDEBUG
764
765
767#endif
768
769
770
771
776
779 It.setHeadBit(true);
780 return It;
781 }
782
785 reinterpret_cast<void *>(It.getNodePtr())) ^
787 }
788
791 return LHS == RHS && LHS.getHeadBit() == RHS.getHeadBit();
792 }
793};
794
795}
796
797#endif
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)
#define LLVM_ABI_FOR_TEST
This file defines the DenseMap class.
Iterator to walk just the phi nodes in the basic block.
Definition BasicBlock.h:491
bool operator==(const phi_iterator_impl &Arg) const
Definition BasicBlock.h:510
phi_iterator_impl(const phi_iterator_impl< PHINodeU, BBIteratorU > &Arg)
Definition BasicBlock.h:507
PHINodeT & operator*() const
Definition BasicBlock.h:512
phi_iterator_impl()=default
phi_iterator_impl & operator++()
Definition BasicBlock.h:515
LLVM Basic Block Representation.
Definition BasicBlock.h:62
LLVM_ABI BasicBlock::iterator erase(BasicBlock::iterator FromIt, BasicBlock::iterator ToIt)
Erases a range of instructions from FromIt to (not including) ToIt.
LLVM_ABI LLVM_DEPRECATED("Use iterators as instruction positions", "getFirstNonPHIIt") const Instruction *getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
phi_iterator_impl<> phi_iterator
Definition BasicBlock.h:521
LLVM_ABI void replaceSuccessorsPhiUsesWith(BasicBlock *Old, BasicBlock *New)
Update all phi nodes in this basic block's successors to refer to basic block New instead of basic bl...
BasicBlock(const BasicBlock &)=delete
iterator end()
Definition BasicBlock.h:472
unsigned getNumber() const
Definition BasicBlock.h:95
Instruction * getFirstMayFaultInst()
Definition BasicBlock.h:350
iterator begin()
Instruction iterator methods.
Definition BasicBlock.h:459
LLVM_ABI void deleteTrailingDbgRecords()
Delete any trailing DbgRecords at the end of this block, see setTrailingDbgRecords.
iterator_range< const_phi_iterator > phis() const
Returns a range that iterates over the phis in the basic block.
Definition BasicBlock.h:528
LLVM_ABI const LandingPadInst * getLandingPadInst() const
Return the landingpad instruction associated with the landing pad.
LLVM_ABI void setTrailingDbgRecords(DbgMarker *M)
Record that the collection of DbgRecords in M "trails" after the last instruction of this block.
LLVM_ABI const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
const Function * getParent() const
Return the enclosing method, or null if none.
Definition BasicBlock.h:213
reverse_iterator rbegin()
Definition BasicBlock.h:475
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast.
Definition BasicBlock.h:588
InstListType::iterator getFirstNonPHIOrDbgOrLifetime(bool SkipPseudoOp=true)
Definition BasicBlock.h:320
LLVM_ABI void renumberInstructions()
Renumber instructions and mark the ordering as valid.
LLVM_ABI iterator_range< filter_iterator< BasicBlock::const_iterator, std::function< bool(const Instruction &)> > > instructionsWithoutDebug(bool SkipPseudoOp=true) const
Return a const iterator range over the instructions in the block, skipping any debug instructions.
bool empty() const
Definition BasicBlock.h:481
LLVM_ABI DbgMarker * createMarker(Instruction *I)
Attach a DbgMarker to the given instruction.
BasicBlock * splitBasicBlock(Instruction *I, const Twine &BBName="", bool Before=false)
Definition BasicBlock.h:633
const Instruction & back() const
Definition BasicBlock.h:484
LLVM_ABI BasicBlock * splitBasicBlockBefore(iterator I, const Twine &BBName="")
Split the basic block into two basic blocks at the specified instruction and insert the new basic blo...
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches,...
Definition BasicBlock.h:690
LLVM_ABI InstListType::const_iterator getFirstNonPHIIt() const
Returns an iterator to the first instruction in this block that is not a PHINode instruction.
LLVM_ABI void insertDbgRecordBefore(DbgRecord *DR, InstListType::iterator Here)
Insert a DbgRecord into a block at the position given by Here.
BasicBlock * splitBasicBlockBefore(Instruction *I, const Twine &BBName="")
Definition BasicBlock.h:657
void invalidateOrders()
Mark instruction ordering invalid. Done on every instruction insert.
Definition BasicBlock.h:737
friend void Instruction::removeFromParent()
LLVM_ABI void convertToNewDbgValues()
Convert variable location debugging information stored in dbg.value intrinsics into DbgMarkers / DbgR...
LLVM_ABI void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW=nullptr, bool ShouldPreserveUseListOrder=false, bool IsForDebug=false) const
Print the basic block to an output stream with an optional AssemblyAnnotationWriter.
InstListType::const_iterator const_iterator
Definition BasicBlock.h:171
BasicBlock * getUniqueSuccessor()
Definition BasicBlock.h:445
Module * getModule()
Definition BasicBlock.h:221
Instruction & front()
Definition BasicBlock.h:483
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition BasicBlock.h:206
BasicBlock * getSingleSuccessor()
Definition BasicBlock.h:435
friend BasicBlock::iterator Instruction::eraseFromParent()
LLVM_ABI bool isEntryBlock() const
Return true if this is the entry block of the containing function.
LLVM_ABI ValueSymbolTable * getValueSymbolTable()
Returns a pointer to the symbol table if one exists.
BasicBlock * getUniquePredecessor()
Definition BasicBlock.h:419
LLVM_ABI void moveAfter(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it right after MovePos in the function M...
LLVM_ABI InstListType::const_iterator getFirstNonPHIOrDbg(bool SkipPseudoOp=true) const
Returns a pointer to the first instruction in this block that is not a PHINode or a debug intrinsic,...
LLVM_ABI bool hasNPredecessors(unsigned N) const
Return true if this block has exactly N predecessors.
LLVM_ABI BasicBlock * splitBasicBlock(iterator I, const Twine &BBName="", bool Before=false)
Split the basic block into two basic blocks at the specified instruction.
BasicBlock * getSinglePredecessor()
Definition BasicBlock.h:407
LLVM_ABI void convertFromNewDbgValues()
Convert variable location debugging information stored in DbgMarkers and DbgRecords into the dbg....
LLVM_ABI const BasicBlock * getUniqueSuccessor() const
Return the successor of this block if it has a unique successor.
LLVM_ABI const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
LLVM_ABI std::optional< uint64_t > getIrrLoopHeaderWeight() const
const Instruction & front() const
Definition BasicBlock.h:482
LLVM_ABI void dumpDbgValues() const
LLVM_ABI const CallInst * getTerminatingDeoptimizeCall() const
Returns the call instruction calling @llvm.experimental.deoptimize prior to the terminating return in...
Instruction & back()
Definition BasicBlock.h:485
InstListType::reverse_iterator reverse_iterator
Definition BasicBlock.h:172
LLVM_ABI void replacePhiUsesWith(BasicBlock *Old, BasicBlock *New)
Update all phi nodes in this basic block to refer to basic block New instead of basic block Old.
LLVM_ABI const BasicBlock * getUniquePredecessor() const
Return the predecessor of this block if it has a unique predecessor block.
LLVM_ABI const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
SymbolTableList< Instruction, ilist_iterator_bits< true >, ilist_parent< BasicBlock > > InstListType
Definition BasicBlock.h:64
LLVM_ABI void flushTerminatorDbgRecords()
Eject any debug-info trailing at the end of a block.
void splice(BasicBlock::iterator ToIt, BasicBlock *FromBB, BasicBlock::iterator FromIt)
Transfer one instruction from FromBB at FromIt to this basic block at ToIt.
Definition BasicBlock.h:668
Function * getParent()
Definition BasicBlock.h:214
InstListType::iterator getFirstNonPHIOrDbg(bool SkipPseudoOp=true)
Definition BasicBlock.h:308
LLVM_ABI const DataLayout & getDataLayout() const
Get the data layout of the module this basic block belongs to.
const_reverse_iterator rend() const
Definition BasicBlock.h:478
reverse_iterator rend()
Definition BasicBlock.h:477
LLVM_ABI void insertDbgRecordAfter(DbgRecord *DR, Instruction *I)
Insert a DbgRecord into a block at the position given by I.
LLVM_ABI_FOR_TEST void validateInstrOrdering() const
Asserts that instruction order numbers are marked invalid, or that they are in ascending order.
LLVM_ABI DbgMarker * getMarker(InstListType::iterator It)
Return the DbgMarker for the position given by It, so that DbgRecords can be inserted there.
LLVM_ABI filter_iterator< BasicBlock::const_iterator, std::function< bool(constInstruction &)> >::difference_type sizeWithoutDebug() const
Return the size of the basic block ignoring debug instructions.
InstListType::iterator iterator
Instruction iterators...
Definition BasicBlock.h:170
LLVM_ABI LLVMContext & getContext() const
Get the context in which this basic block lives.
CallInst * getPostdominatingDeoptimizeCall()
Definition BasicBlock.h:257
const_iterator begin() const
Definition BasicBlock.h:467
LLVM_ABI const_iterator getFirstNonPHIOrDbgOrAlloca() const
Returns an iterator to the first instruction in this block that is not a PHINode, a debug intrinsic,...
friend class BlockAddress
Definition BasicBlock.h:73
Instruction * getTerminator()
Definition BasicBlock.h:238
BasicBlock & operator=(const BasicBlock &)=delete
iterator getFirstNonPHIOrDbgOrAlloca()
Definition BasicBlock.h:340
CallInst * getTerminatingDeoptimizeCall()
Definition BasicBlock.h:247
friend class Function
Definition BasicBlock.h:69
LLVM_ABI void dropAllReferences()
Cause all subinstructions to "let go" of all the references that said subinstructions are maintaining...
size_t size() const
Definition BasicBlock.h:480
LLVM_ABI void reinsertInstInDbgRecords(Instruction *I, std::optional< DbgRecord::self_iterator > Pos)
In rare circumstances instructions can be speculatively removed from blocks, and then be re-inserted ...
void moveBefore(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it into the function that MovePos lives ...
Definition BasicBlock.h:386
LLVM_ABI InstListType::const_iterator getFirstNonPHIOrDbgOrLifetime(bool SkipPseudoOp=true) const
Returns a pointer to the first instruction in this block that is not a PHINode, a debug intrinsic,...
LLVM_ABI bool isLandingPad() const
Return true if this basic block is a landing pad.
InstListType::const_reverse_iterator const_reverse_iterator
Definition BasicBlock.h:173
bool isEHPad() const
Return true if this basic block is an exception handling block.
Definition BasicBlock.h:707
LLVM_ABI DbgMarker * getTrailingDbgRecords()
Fetch the collection of DbgRecords that "trail" after the last instruction of this block,...
CallInst * getTerminatingMustTailCall()
Definition BasicBlock.h:266
phi_iterator_impl< const PHINode, BasicBlock::const_iterator > const_phi_iterator
Definition BasicBlock.h:522
LLVM_ABI bool canSplitPredecessors() const
const_iterator end() const
Definition BasicBlock.h:473
LLVM_ABI const CallInst * getTerminatingMustTailCall() const
Returns the call instruction marked 'musttail' prior to the terminating return instruction of this ba...
friend BasicBlock::iterator Instruction::insertInto(BasicBlock *BB, BasicBlock::iterator It)
LLVM_ABI bool isLegalToHoistInto() const
Return true if it is legal to hoist instructions into this block.
LLVM_ABI bool hasNPredecessorsOrMore(unsigned N) const
Return true if this block has N predecessors or more.
bool isInstrOrderValid() const
Returns true if the Order field of child Instructions is valid.
Definition BasicBlock.h:732
LLVM_ABI const CallInst * getPostdominatingDeoptimizeCall() const
Returns the call instruction calling @llvm.experimental.deoptimize that is present either in current ...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition BasicBlock.h:233
LLVM_ABI DbgMarker * getNextMarker(Instruction *I)
Return the DbgMarker for the position that comes after I.
LLVM_ABI const Instruction * getFirstMayFaultInst() const
Returns the first potential AsynchEH faulty instruction currently it checks for loads/stores (which m...
void splice(BasicBlock::iterator ToIt, BasicBlock *FromBB)
Transfer all instructions from FromBB to this basic block at ToIt.
Definition BasicBlock.h:662
const_reverse_iterator rbegin() const
Definition BasicBlock.h:476
LandingPadInst * getLandingPadInst()
Definition BasicBlock.h:717
LLVM_ABI const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
iterator getFirstInsertionPt()
Definition BasicBlock.h:331
LLVM_ABI void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs=false)
Update PHI nodes in this BasicBlock before removal of predecessor Pred.
This class represents a function call, abstracting a target machine's calling convention.
A parsed version of the target data layout string in and methods for querying it.
Per-instruction record of debug-info.
Base class for non-instruction debug metadata records that have positions within IR.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
LLVM_ABI void removeFromParent()
This method unlinks 'this' from the containing basic block, but does not delete it.
LLVM_ABI iterator_range< simple_ilist< DbgRecord >::iterator > cloneDebugInfoFrom(const Instruction *From, std::optional< simple_ilist< DbgRecord >::iterator > FromHere=std::nullopt, bool InsertAtHead=false)
Clone any debug-info attached to From onto this instruction.
LLVM_ABI void insertBefore(InstListType::iterator InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified position.
LLVM_ABI InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
LLVM_ABI void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction.
LLVM_ABI InstListType::iterator insertInto(BasicBlock *ParentBB, InstListType::iterator It)
Inserts an unlinked instruction into ParentBB at position It and returns the iterator of the inserted...
This is an important class for using LLVM in a threaded context.
The landingpad instruction holds all of the information necessary to generate correct exception handl...
A Module instance is used to store all the information related to an LLVM module.
List that automatically updates parent links and symbol tables.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
This class provides a symbol table of name/value pairs.
LLVM_ABI Value(Type *Ty, unsigned scid)
unsigned char SubclassOptionalData
Hold subclass data that can be dropped.
void setValueSubclassData(unsigned short D)
self_iterator getIterator()
An ilist node that can access its parent list.
ilist_node_with_parent()=default
typename base_list_type::const_reverse_iterator const_reverse_iterator
typename base_list_type::reverse_iterator reverse_iterator
typename base_list_type::iterator iterator
typename base_list_type::const_iterator const_iterator
CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of ...
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
struct LLVMOpaqueBasicBlock * LLVMBasicBlockRef
Represents a basic block of instructions in LLVM IR.
This file defines classes to implement an intrusive doubly linked list class (i.e.
This file defines the ilist_node class template, which is a convenient base class for creating classe...
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
decltype(auto) dyn_cast(const From &Val)
dyn_cast - Return the argument parameter cast to the specified type.
LLVM_ABI BasicBlock::iterator skipDebugIntrinsics(BasicBlock::iterator It)
Advance It while it points to a debug instruction and return the result.
filter_iterator_impl< WrappedIteratorT, PredicateT, detail::fwd_or_bidi_tag< WrappedIteratorT > > filter_iterator
Defines filter_iterator to a suitable specialization of filter_iterator_impl, based on the underlying...
static BasicBlock::iterator getEmptyKey()
Definition BasicBlock.h:773
static unsigned getHashValue(const BasicBlock::iterator &It)
Definition BasicBlock.h:783
static bool isEqual(const BasicBlock::iterator &LHS, const BasicBlock::iterator &RHS)
Definition BasicBlock.h:789
static BasicBlock::iterator getTombstoneKey()
Definition BasicBlock.h:777
An information struct used to provide DenseMap with the various necessary components for a given valu...
Option to add extra bits to the ilist_iterator.
Option to add a pointer to this list's owner in every node.