1//===-- llvm/DebugProgramInstruction.h - Stream of debug info ---*- C++ -*-===// 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 7//===----------------------------------------------------------------------===// 9// Data structures for storing variable assignment information in LLVM. In the 10// dbg.value design, a dbg.value intrinsic specifies the position in a block 11// a source variable take on an LLVM Value: 13// %foo = add i32 1, %0 14// dbg.value(metadata i32 %foo, ...) 15// %bar = void call @ext(%foo); 17// and all information is stored in the Value / Metadata hierachy defined 18// elsewhere in LLVM. In the "DbgRecord" design, each instruction /may/ have a 19// connection with a DbgMarker, which identifies a position immediately before 20// the instruction, and each DbgMarker /may/ then have connections to DbgRecords 21// which record the variable assignment information. To illustrate: 23// %foo = add i32 1, %0 24// ; foo->DebugMarker == nullptr 25// ;; There are no variable assignments / debug records "in front" of 26// ;; the instruction for %foo, therefore it has no DebugMarker. 27// %bar = void call @ext(%foo) 28// ; bar->DebugMarker = { 29// ; StoredDbgRecords = { 30// ; DbgVariableRecord(metadata i32 %foo, ...) 33// ;; There is a debug-info record in front of the %bar instruction, 34// ;; thus it points at a DbgMarker object. That DbgMarker contains a 35// ;; DbgVariableRecord in its ilist, storing the equivalent information 36// ;; to the dbg.value above: the Value, DILocalVariable, etc. 38// This structure separates the two concerns of the position of the debug-info 39// in the function, and the Value that it refers to. It also creates a new 40// "place" in-between the Value / Metadata hierachy where we can customise 41// storage and allocation techniques to better suite debug-info workloads. 42// NB: as of the initial prototype, none of that has actually been attempted 45//===----------------------------------------------------------------------===// 47#ifndef LLVM_IR_DEBUGPROGRAMINSTRUCTION_H 48#define LLVM_IR_DEBUGPROGRAMINSTRUCTION_H 65classDbgVariableIntrinsic;
70classDbgVariableRecord;
73/// A typed tracking MDNode reference that does not require a definition for its 74/// parameter type. Necessary to avoid including DebugInfoMetadata.h, which has 75/// a significant impact on compile times if included in this file. 83 /// Construct from the templated type. 86 /// Construct from an \a MDNode. 88 /// Note: if \c Param does not have the template type, a verifier check will 89 /// fail, and accessors will crash. However, construction from other nodes 90 /// is supported in order to handle forward references when reading textual 94 /// Get the underlying type. 96 /// \pre !*this or \c isa<T>(getAsMDNode()). 99operatorT *()
const {
returnget(); }
106 /// Check for null in a way that is safe with broken debug info. 107explicitoperatorbool()
const{
return Ref; }
109 /// Return \c this as a \a MDNode. 113return Ref ==
Other.Ref;
116return Ref !=
Other.Ref;
120/// Base class for non-instruction debug metadata records that have positions 121/// within IR. Features various methods copied across from the Instruction 122/// class to aid ease-of-use. DbgRecords should always be linked into a 123/// DbgMarker's StoredDbgRecords list. The marker connects a DbgRecord back to 124/// its position in the BasicBlock. 126/// We need a discriminator for dyn/isa casts. In order to avoid paying for a 127/// vtable for "virtual" functions too, subclasses must add a new discriminator 128/// value (RecordKind) and cases to a few functions in the base class: 131/// isIdenticalToWhenDefined 132/// both print methods 133/// createDebugIntrinsic 136 /// Marker that this DbgRecord is linked into. 138 /// Subclass discriminator. 149 /// Methods that dispatch to subclass implementations. These need to be 150 /// manually updated when a new subclass is added. 157 /// Convert this DbgRecord back into an appropriate llvm.dbg.* intrinsic. 158 /// \p InsertBefore Optional position to insert this intrinsic. 159 /// \returns A new llvm.dbg.* intrinsic representiung this DbgRecord. 164 /// Same as isIdenticalToWhenDefined but checks DebugLoc too. 196// Some generic lambdas supporting intrinsic-based debug-info mean we need 197// to support both iterator and instruction position based insertion. 217 /// Similarly to Value, we avoid paying the cost of a vtable 218 /// by protecting the dtor and having deleteRecord dispatch 220 /// Use deleteRecord to delete a generic record. 229/// Records a position in IR for a source label (DILabel). Corresponds to the 230/// llvm.dbg.label intrinsic. 234 /// This constructor intentionally left private, so that it is only called via 235 /// "createUnresolvedDbgLabelRecord", which clearly expresses that it is for 242 /// For use during parsing; creates a DbgLabelRecord from as-of-yet unresolved 243 /// MDNodes. Trying to access the resulting DbgLabelRecord's fields before 244 /// they are resolved, or if they resolve to the wrong type, will result in a 259 /// Support type inquiry through isa, cast, and dyn_cast. 265/// Record of a variable value-assignment, aka a non instruction representation 266/// of the dbg.value intrinsic. 268/// This class inherits from DebugValueUser to allow LLVM's metadata facilities 269/// to update our references to metadata beneath our feet. 279End,
///< Marks the end of the concrete types. 280Any,
///< To indicate all LocationTypes in searches. 282 /// Classification of the debug-info record that this DbgVariableRecord 283 /// represents. Essentially, "does this correspond to a dbg.value, 284 /// dbg.declare, or dbg.assign?". 285 /// FIXME: We could use spare padding bits from DbgRecord for this. 288// NB: there is no explicit "Value" field in this class, it's effectively the 289// DebugValueUser superclass instead. The referred to Value can either be a 290// ValueAsMetadata or a DIArgList. 297 /// Create a new DbgVariableRecord representing the intrinsic \p DVI, for 298 /// example the assignment represented by a dbg.value. 301 /// Directly construct a new DbgVariableRecord representing a dbg.value 302 /// intrinsic assigning \p Location to the DV / Expr / DI variable. 312 /// Private constructor for creating new instances during parsing only. Only 313 /// called through `createUnresolvedDbgVariableRecord` below, which makes 314 /// clear that this is used for parsing only, and will later return a subclass 315 /// depending on which Type is passed. 321 /// Used to create DbgVariableRecords during parsing, where some metadata 322 /// references may still be unresolved. Although for some fields a generic 323 /// `Metadata*` argument is accepted for forward type-references, the verifier 324 /// and accessors will reject incorrect types later on. The function is used 325 /// for all types of DbgVariableRecords for simplicity while parsing, but 326 /// asserts if any necessary fields are empty or unused fields are not empty, 327 /// i.e. if the #dbg_assign fields are used for a non-dbg-assign type. 361 /// Iterator for ValueAsMetadata that internally uses direct pointer iteration 362 /// over either a ValueAsMetadata* or a ValueAsMetadata**, dereferencing to the 363 /// ValueAsMetadata . 366 std::bidirectional_iterator_tag, Value *> {
383 ? cast<ValueAsMetadata *>(
I)
384 : *cast<ValueAsMetadata **>(
I);
389 ? cast<ValueAsMetadata *>(
I)
390 : *cast<ValueAsMetadata **>(
I);
394if (
auto *VAM = dyn_cast<ValueAsMetadata *>(
I))
397I = cast<ValueAsMetadata **>(
I) + 1;
401if (
auto *VAM = dyn_cast<ValueAsMetadata *>(
I))
404I = cast<ValueAsMetadata **>(
I) - 1;
412 /// Get the locations corresponding to the variable referenced by the debug 413 /// info intrinsic. Depending on the intrinsic, this could be the 414 /// variable's value or its address. 420bool AllowEmpty =
false);
422 /// Adding a new location operand will always result in this intrinsic using 423 /// an ArgList, and must always be accompanied by a new expression that uses 431 /// Returns true if this DbgVariableRecord has no empty MDNodes in its 435 /// Does this describe the address of a local variable. True for dbg.addr 436 /// and dbg.declare, but not dbg.value, which describes its value. 439 /// Determine if this describes the value of a local variable. It is false for 440 /// dbg.declare, but true for dbg.value, which describes its value. 456 /// Returns the metadata operand for the first location description. i.e., 457 /// dbg intrinsic dbg.value,declare operand and dbg.assign 1st location 458 /// operand (the "value componenet"). Note the operand (singular) may be 459 /// a DIArgList which is a list of values. 466 /// Use of this should generally be avoided; instead, 467 /// replaceVariableLocationOp and addVariableLocationOps should be used where 468 /// possible to avoid creating invalid state. 470assert((isa<ValueAsMetadata>(NewLocation) || isa<DIArgList>(NewLocation) ||
471 isa<MDNode>(NewLocation)) &&
472"Location for a DbgVariableRecord must be either ValueAsMetadata or " 477 std::optional<DbgVariableFragmentInfo>
getFragment()
const;
478 /// Get the FragmentInfo for the variable if it exists, otherwise return a 479 /// FragmentInfo that covers the entire variable if the variable size is 480 /// known, otherwise return a zero-sized fragment. 488 /// Get the size (in bits) of the variable, or fragment of the variable that 495// Matches the definition of the Instruction version, equivalent to above but 496// without checking DbgLoc. 504 /// @name DbgAssign Methods 523 /// Kill the address component. 525 /// Check whether this kills the address component. This doesn't take into 526 /// account the position of the intrinsic, therefore a returned value of false 527 /// does not guarentee the address is a valid location for the variable at the 528 /// intrinsic's position in IR. 534 /// Convert this DbgVariableRecord back into a dbg.value intrinsic. 535 /// \p InsertBefore Optional position to insert this intrinsic. 536 /// \returns A new dbg.value intrinsic representiung this DbgVariableRecord. 540 /// Handle changes to the location of the Value(s) that we refer to happening 541 /// "under our feet". 547 /// Support type inquiry through isa, cast, and dyn_cast. 553/// Filter the DbgRecord range to DbgVariableRecord types only and downcast. 558 [](
DbgRecord &
E) {
return isa<DbgVariableRecord>(
E); }),
559 [](
DbgRecord &
E) {
return std::ref(cast<DbgVariableRecord>(
E)); });
562/// Per-instruction record of debug-info. If an Instruction is the position of 563/// some debugging information, it points at a DbgMarker storing that info. Each 564/// marker points back at the instruction that owns it. Various utilities are 565/// provided for manipulating the DbgRecords contained within this marker. 567/// This class has a rough surface area, because it's needed to preserve the 568/// one arefact that we can't yet eliminate from the intrinsic / dbg.value 569/// debug-info design: the order of records is significant, and duplicates can 570/// exist. Thus, if one has a run of debug-info records such as: 574/// and remove barinst, then the dbg.values must be preserved in the correct 575/// order. Hence, the use of iterators to select positions to insert things 576/// into, or the occasional InsertAtHead parameter indicating that new records 577/// should go at the start of the list. 579/// There are only five or six places in LLVM that truly rely on this ordering, 580/// which we can improve in the future. Additionally, many improvements in the 581/// way that debug-info is stored can be achieved in this class, at a future 586 /// Link back to the Instruction that owns this marker. Can be null during 587 /// operations that move a marker from one instruction to another. 590 /// List of DbgRecords, the non-instruction equivalent of llvm.dbg.* 591 /// intrinsics. There is a one-to-one relationship between each debug 592 /// intrinsic in a block and each DbgRecord once the representation has been 593 /// converted, and the ordering is meaningful in the same way. 600 /// Handle the removal of a marker: the position of debug-info has gone away, 601 /// but the stored debug records should not. Drop them onto the next 602 /// instruction, or otherwise work out what to do with them. 609 /// Implement operator<< on DbgMarker. 613 /// Produce a range over all the DbgRecords in this Marker. 617 /// Transfer any DbgRecords from \p Src into this DbgMarker. If \p 618 /// InsertAtHead is true, place them before existing DbgRecords, otherwise 621 /// Transfer the DbgRecords in \p Range from \p Src into this DbgMarker. If 622 /// \p InsertAtHead is true, place them before existing DbgRecords, otherwise 626 /// Insert a DbgRecord into this DbgMarker, at the end of the list. If 627 /// \p InsertAtHead is true, at the start. 629 /// Insert a DbgRecord prior to a DbgRecord contained within this marker. 631 /// Insert a DbgRecord after a DbgRecord contained within this marker. 633 /// Clone all DbgMarkers from \p From into this marker. There are numerous 634 /// options to customise the source/destination, due to gnarliness, see class 636 /// \p FromHere If non-null, copy from FromHere to the end of From's 638 /// \p InsertAtHead Place the cloned DbgRecords at the start of 640 /// \returns Range over all the newly cloned DbgRecords 644bool InsertAtHead =
false);
645 /// Erase all DbgRecords in this DbgMarker. 647 /// Erase a single DbgRecord from this marker. In an ideal future, we would 648 /// never erase an assignment in this way, but it's the equivalent to 649 /// erasing a debug intrinsic from a block. 652 /// We generally act like all llvm Instructions have a range of DbgRecords 653 /// attached to them, but in reality sometimes we don't allocate the DbgMarker 654 /// to save time and memory, but still have to return ranges of DbgRecords. 655 /// When we need to describe such an unallocated DbgRecord range, use this 656 /// static markers range instead. This will bite us if someone tries to insert 657 /// a DbgRecord in that range, but they should be using the Official (TM) API 672/// Inline helper to return a range of DbgRecords attached to a marker. It needs 673/// to be inlined as it's frequently called, but also come after the declaration 674/// of DbgMarker. Thus: it's pre-declared by users like Instruction, then an 675/// inlineable body defined here. 676inline iterator_range<simple_ilist<DbgRecord>::iterator>
685/// Used to temporarily set the debug info format of a function, module, or 686/// basic block for the duration of this object's lifetime, after which the 687/// prior state will be restored. 694 : Obj(Obj), OldState(Obj.IsNewDbgInfoFormat) {
695 Obj.setIsNewDbgInfoFormat(NewState);
706#endif// LLVM_IR_DEBUGPROGRAMINSTRUCTION_H MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
BlockVerifier::State From
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)
Machine Check Debug Module
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
This is the common base class for debug info intrinsics.
This represents the llvm.dbg.label instruction.
Records a position in IR for a source label (DILabel).
MDNode * getRawLabel() const
DbgLabelRecord * clone() const
static bool classof(const DbgRecord *E)
Support type inquiry through isa, cast, and dyn_cast.
void print(raw_ostream &O, bool IsForDebug=false) const
static DbgLabelRecord * createUnresolvedDbgLabelRecord(MDNode *Label, MDNode *DL)
For use during parsing; creates a DbgLabelRecord from as-of-yet unresolved MDNodes.
void setLabel(DILabel *NewLabel)
DILabel * getLabel() const
DbgLabelInst * createDebugIntrinsic(Module *M, Instruction *InsertBefore) const
Per-instruction record of debug-info.
static iterator_range< simple_ilist< DbgRecord >::iterator > getEmptyDbgRecordRange()
Instruction * MarkedInstr
Link back to the Instruction that owns this marker.
iterator_range< simple_ilist< DbgRecord >::iterator > cloneDebugInfoFrom(DbgMarker *From, std::optional< simple_ilist< DbgRecord >::iterator > FromHere, bool InsertAtHead=false)
Clone all DbgMarkers from From into this marker.
void insertDbgRecordAfter(DbgRecord *New, DbgRecord *InsertAfter)
Insert a DbgRecord after a DbgRecord contained within this marker.
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on DbgMarker.
void removeMarker()
Handle the removal of a marker: the position of debug-info has gone away, but the stored debug record...
void absorbDebugValues(DbgMarker &Src, bool InsertAtHead)
Transfer any DbgRecords from Src into this DbgMarker.
void dropDbgRecords()
Erase all DbgRecords in this DbgMarker.
iterator_range< simple_ilist< DbgRecord >::iterator > getDbgRecordRange()
Produce a range over all the DbgRecords in this Marker.
void dropOneDbgRecord(DbgRecord *DR)
Erase a single DbgRecord from this marker.
const BasicBlock * getParent() const
simple_ilist< DbgRecord > StoredDbgRecords
List of DbgRecords, the non-instruction equivalent of llvm.dbg.
void insertDbgRecord(DbgRecord *New, bool InsertAtHead)
Insert a DbgRecord into this DbgMarker, at the end of the list.
static DbgMarker EmptyDbgMarker
We generally act like all llvm Instructions have a range of DbgRecords attached to them,...
A typed tracking MDNode reference that does not require a definition for its parameter type.
T * get() const
Get the underlying type.
bool operator!=(const DbgRecordParamRef &Other) const
DbgRecordParamRef()=default
MDNode * getAsMDNode() const
Return this as a MDNode.
bool operator==(const DbgRecordParamRef &Other) const
Base class for non-instruction debug metadata records that have positions within IR.
void insertAfter(DbgRecord *InsertAfter)
void print(raw_ostream &O, bool IsForDebug=false) const
bool isEquivalentTo(const DbgRecord &R) const
Same as isIdenticalToWhenDefined but checks DebugLoc too.
DbgRecord(Kind RecordKind, DebugLoc DL)
simple_ilist< DbgRecord >::iterator self_iterator
DebugLoc getDebugLoc() const
DbgInfoIntrinsic * createDebugIntrinsic(Module *M, Instruction *InsertBefore) const
Convert this DbgRecord back into an appropriate llvm.dbg.
Kind RecordKind
Subclass discriminator.
void deleteRecord()
Methods that dispatch to subclass implementations.
void insertBefore(DbgRecord *InsertBefore)
~DbgRecord()=default
Similarly to Value, we avoid paying the cost of a vtable by protecting the dtor and having deleteReco...
DbgRecord * getNextNode()
void moveBefore(DbgRecord *MoveBefore)
simple_ilist< DbgRecord >::const_iterator const_self_iterator
Kind
Subclass discriminator.
void setDebugLoc(DebugLoc Loc)
const Instruction * getInstruction() const
void moveAfter(DbgRecord *MoveAfter)
bool isIdenticalToWhenDefined(const DbgRecord &R) const
Kind getRecordKind() const
const DbgMarker * getMarker() const
DbgMarker * Marker
Marker that this DbgRecord is linked into.
void setMarker(DbgMarker *M)
DbgRecord * clone() const
LLVMContext & getContext()
DbgRecord * getPrevNode()
const BasicBlock * getParent() const
This is the common base class for debug info intrinsics for variables.
Iterator for ValueAsMetadata that internally uses direct pointer iteration over either a ValueAsMetad...
location_op_iterator(ValueAsMetadata **MultiIter)
location_op_iterator & operator--()
location_op_iterator(ValueAsMetadata *SingleIter)
bool operator==(const location_op_iterator &RHS) const
location_op_iterator & operator++()
location_op_iterator & operator=(const location_op_iterator &R)
const Value * operator*() const
location_op_iterator(const location_op_iterator &R)
Record of a variable value-assignment, aka a non instruction representation of the dbg....
bool isEquivalentTo(const DbgVariableRecord &Other) const
LocationType getType() const
DbgRecordParamRef< DIExpression > Expression
bool isValueOfVariable() const
Determine if this describes the value of a local variable.
bool isKillAddress() const
Check whether this kills the address component.
void print(raw_ostream &O, bool IsForDebug=false) const
bool hasValidLocation() const
Returns true if this DbgVariableRecord has no empty MDNodes in its location list.
LocationType Type
Classification of the debug-info record that this DbgVariableRecord represents.
MDNode * getRawExpression() const
DbgRecordParamRef< DILocalVariable > Variable
void setAddressExpression(DIExpression *NewExpr)
bool isKillLocation() const
DIAssignID * getAssignID() const
DbgVariableFragmentInfo getFragmentOrEntireVariable() const
Get the FragmentInfo for the variable if it exists, otherwise return a FragmentInfo that covers the e...
MDNode * getRawAddressExpression() const
bool isAddressOfVariable() const
Does this describe the address of a local variable.
std::optional< uint64_t > getFragmentSizeInBits() const
Get the size (in bits) of the variable, or fragment of the variable that is described.
Value * getValue(unsigned OpIdx=0) const
DbgVariableRecord * clone() const
static DbgVariableRecord * createUnresolvedDbgVariableRecord(LocationType Type, Metadata *Val, MDNode *Variable, MDNode *Expression, MDNode *AssignID, Metadata *Address, MDNode *AddressExpression, MDNode *DI)
Used to create DbgVariableRecords during parsing, where some metadata references may still be unresol...
void setRawLocation(Metadata *NewLocation)
Use of this should generally be avoided; instead, replaceVariableLocationOp and addVariableLocationOp...
static DbgVariableRecord * createDbgVariableRecord(Value *Location, DILocalVariable *DV, DIExpression *Expr, const DILocation *DI)
static DbgVariableRecord * createDVRDeclare(Value *Address, DILocalVariable *DV, DIExpression *Expr, const DILocation *DI)
void setVariable(DILocalVariable *NewVar)
Value * getAddress() const
void setExpression(DIExpression *NewExpr)
DIExpression * getExpression() const
void handleChangedLocation(Metadata *NewLocation)
Handle changes to the location of the Value(s) that we refer to happening "under our feet".
Metadata * getRawAssignID() const
Value * getVariableLocationOp(unsigned OpIdx) const
void setKillAddress()
Kill the address component.
MDNode * getRawVariable() const
DILocalVariable * getVariable() const
static bool classof(const DbgRecord *E)
Support type inquiry through isa, cast, and dyn_cast.
void addVariableLocationOps(ArrayRef< Value * > NewValues, DIExpression *NewExpr)
Adding a new location operand will always result in this intrinsic using an ArgList,...
Metadata * getRawLocation() const
Returns the metadata operand for the first location description.
bool isDbgDeclare() const
void setAssignId(DIAssignID *New)
void setAddress(Value *V)
static DbgVariableRecord * createDVRAssign(Value *Val, DILocalVariable *Variable, DIExpression *Expression, DIAssignID *AssignID, Value *Address, DIExpression *AddressExpression, const DILocation *DI)
unsigned getNumVariableLocationOps() const
DbgVariableIntrinsic * createDebugIntrinsic(Module *M, Instruction *InsertBefore) const
Convert this DbgVariableRecord back into a dbg.value intrinsic.
Metadata * getRawAddress() const
void replaceVariableLocationOp(Value *OldValue, Value *NewValue, bool AllowEmpty=false)
@ End
Marks the end of the concrete types.
@ Any
To indicate all LocationTypes in searches.
std::optional< DbgVariableFragmentInfo > getFragment() const
static DbgVariableRecord * createLinkedDVRAssign(Instruction *LinkedInstr, Value *Val, DILocalVariable *Variable, DIExpression *Expression, Value *Address, DIExpression *AddressExpression, const DILocation *DI)
bool isIdenticalToWhenDefined(const DbgVariableRecord &Other) const
DbgRecordParamRef< DIExpression > AddressExpression
DIExpression * getAddressExpression() const
iterator_range< location_op_iterator > location_ops() const
Get the locations corresponding to the variable referenced by the debug info intrinsic.
Base class for tracking ValueAsMetadata/DIArgLists with user lookups and Owner callbacks outside of V...
std::array< Metadata *, 3 > DebugValues
void resetDebugValue(size_t Idx, Metadata *DebugValue)
Class representing an expression and its matching format.
This is an important class for using LLVM in a threaded context.
Root of the metadata hierarchy.
Manage lifetime of a slot tracker for printing IR.
A Module instance is used to store all the information related to an LLVM module.
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Used to temporarily set the debug info format of a function, module, or basic block for the duration ...
ScopedDbgInfoFormatSetter(T &Obj, bool NewState)
~ScopedDbgInfoFormatSetter()
The instances of the Type class are immutable: once they are created, they are never changed.
Value wrapper in the Metadata hierarchy.
static ValueAsMetadata * get(Value *V)
LLVM Value Representation.
self_iterator getIterator()
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.
A simple intrusive list implementation.
typename ilist_select_iterator_type< OptionsT::has_iterator_bits, OptionsT, false, false >::type iterator
typename ilist_select_iterator_type< OptionsT::has_iterator_bits, OptionsT, false, true >::type const_iterator
struct LLVMOpaqueDbgRecord * LLVMDbgRecordRef
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...
@ BasicBlock
Various leaf nodes.
This is an optimization pass for GlobalISel generic memory operations.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
auto map_range(ContainerTy &&C, FuncTy F)
iterator_range< filter_iterator< detail::IterOfRange< RangeT >, PredicateT > > make_filter_range(RangeT &&Range, PredicateT Pred)
Convenience function that takes a range of elements and a predicate, and return a new filter_iterator...
iterator_range< simple_ilist< DbgRecord >::iterator > getDbgRecordRange(DbgMarker *DebugMarker)
Inline helper to return a range of DbgRecords attached to a marker.
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)
Filter the DbgRecord range to DbgVariableRecord types only and downcast.
