Go to the documentation of this file.
13 #ifndef LLVM_LIB_CODEGEN_SELECTIONDAG_SELECTIONDAGBUILDER_H
14 #define LLVM_LIB_CODEGEN_SELECTIONDAG_SELECTIONDAGBUILDER_H
43 class AtomicCmpXchgInst;
50 class CatchReturnInst;
51 class CatchSwitchInst;
53 class CleanupReturnInst;
55 class ConstrainedFPIntrinsic;
59 class DILocalVariable;
62 class FunctionLoweringInfo;
66 class GCStatepointInst;
72 class MachineBasicBlock;
79 class SwiftErrorValueTracking;
81 class TargetLibraryInfo;
85 class UnreachableInst;
105 class DanglingDebugInfo {
108 unsigned SDNodeOrder = 0;
111 DanglingDebugInfo() =
default;
117 unsigned getSDNodeOrder() {
return SDNodeOrder; }
121 typedef std::vector<DanglingDebugInfo> DanglingDebugInfoVector;
160 unsigned SDNodeOrder;
204 SDB->addSuccessorWithProb(Src, Dst, Prob);
213 std::unique_ptr<SDAGSwitchLowering>
SL;
280 return SDLoc(CurInst, SDNodeOrder);
321 unsigned Order,
bool IsVariadic);
333 assert(!
N.getNode() &&
"Already set a value for this node!");
339 assert(!
N.getNode() &&
"Already set a value for this node!");
359 bool IsMustTailCall,
const BasicBlock *EHPadBB =
nullptr);
367 const CallBase *Call,
unsigned ArgIdx,
368 unsigned NumArgs,
SDValue Callee,
369 Type *ReturnTy,
bool IsPatchPoint);
371 std::pair<SDValue, SDValue>
439 bool VarArgDisallowed,
440 bool ForceVoidReturnTy);
462 void addSuccessorWithProb(
487 void visitUnary(
const User &
I,
unsigned Opcode);
490 void visitBinary(
const User &
I,
unsigned Opcode);
491 void visitShift(
const User &
I,
unsigned Opcode);
492 void visitAdd(
const User &
I) { visitBinary(
I,
ISD::ADD); }
493 void visitFAdd(
const User &
I) { visitBinary(
I,
ISD::FADD); }
494 void visitSub(
const User &
I) { visitBinary(
I,
ISD::SUB); }
495 void visitFSub(
const User &
I) { visitBinary(
I,
ISD::FSUB); }
496 void visitMul(
const User &
I) { visitBinary(
I,
ISD::MUL); }
497 void visitFMul(
const User &
I) { visitBinary(
I,
ISD::FMUL); }
498 void visitURem(
const User &
I) { visitBinary(
I,
ISD::UREM); }
499 void visitSRem(
const User &
I) { visitBinary(
I,
ISD::SREM); }
500 void visitFRem(
const User &
I) { visitBinary(
I,
ISD::FREM); }
501 void visitUDiv(
const User &
I) { visitBinary(
I,
ISD::UDIV); }
502 void visitSDiv(
const User &
I);
503 void visitFDiv(
const User &
I) { visitBinary(
I,
ISD::FDIV); }
504 void visitAnd (
const User &
I) { visitBinary(
I,
ISD::AND); }
505 void visitOr (
const User &
I) { visitBinary(
I,
ISD::OR); }
506 void visitXor (
const User &
I) { visitBinary(
I,
ISD::XOR); }
507 void visitShl (
const User &
I) { visitShift(
I,
ISD::SHL); }
508 void visitLShr(
const User &
I) { visitShift(
I,
ISD::SRL); }
509 void visitAShr(
const User &
I) { visitShift(
I,
ISD::SRA); }
510 void visitICmp(
const User &
I);
511 void visitFCmp(
const User &
I);
513 void visitTrunc(
const User &
I);
514 void visitZExt(
const User &
I);
515 void visitSExt(
const User &
I);
516 void visitFPTrunc(
const User &
I);
517 void visitFPExt(
const User &
I);
518 void visitFPToUI(
const User &
I);
519 void visitFPToSI(
const User &
I);
520 void visitUIToFP(
const User &
I);
521 void visitSIToFP(
const User &
I);
522 void visitPtrToInt(
const User &
I);
523 void visitIntToPtr(
const User &
I);
524 void visitBitCast(
const User &
I);
525 void visitAddrSpaceCast(
const User &
I);
527 void visitExtractElement(
const User &
I);
528 void visitInsertElement(
const User &
I);
529 void visitShuffleVector(
const User &
I);
531 void visitExtractValue(
const User &
I);
532 void visitInsertValue(
const User &
I);
533 void visitLandingPad(
const LandingPadInst &LP);
535 void visitGetElementPtr(
const User &
I);
536 void visitSelect(
const User &
I);
538 void visitAlloca(
const AllocaInst &
I);
539 void visitLoad(
const LoadInst &
I);
540 void visitStore(
const StoreInst &
I);
541 void visitMaskedLoad(
const CallInst &
I,
bool IsExpanding =
false);
542 void visitMaskedStore(
const CallInst &
I,
bool IsCompressing =
false);
543 void visitMaskedGather(
const CallInst &
I);
544 void visitMaskedScatter(
const CallInst &
I);
545 void visitAtomicCmpXchg(
const AtomicCmpXchgInst &
I);
546 void visitAtomicRMW(
const AtomicRMWInst &
I);
547 void visitFence(
const FenceInst &
I);
548 void visitPHI(
const PHINode &
I);
549 void visitCall(
const CallInst &
I);
550 bool visitMemCmpBCmpCall(
const CallInst &
I);
551 bool visitMemPCpyCall(
const CallInst &
I);
552 bool visitMemChrCall(
const CallInst &
I);
553 bool visitStrCpyCall(
const CallInst &
I,
bool isStpcpy);
554 bool visitStrCmpCall(
const CallInst &
I);
555 bool visitStrLenCall(
const CallInst &
I);
556 bool visitStrNLenCall(
const CallInst &
I);
557 bool visitUnaryFloatCall(
const CallInst &
I,
unsigned Opcode);
558 bool visitBinaryFloatCall(
const CallInst &
I,
unsigned Opcode);
559 void visitAtomicLoad(
const LoadInst &
I);
560 void visitAtomicStore(
const StoreInst &
I);
561 void visitLoadFromSwiftError(
const LoadInst &
I);
562 void visitStoreToSwiftError(
const StoreInst &
I);
563 void visitFreeze(
const FreezeInst &
I);
565 void visitInlineAsm(
const CallBase &Call,
567 void visitIntrinsicCall(
const CallInst &
I,
unsigned Intrinsic);
568 void visitTargetIntrinsic(
const CallInst &
I,
unsigned Intrinsic);
569 void visitConstrainedFPIntrinsic(
const ConstrainedFPIntrinsic &FPI);
570 void visitVPLoadGather(
const VPIntrinsic &VPIntrin, EVT VT,
571 SmallVector<SDValue, 7> &OpValues,
bool IsGather);
572 void visitVPStoreScatter(
const VPIntrinsic &VPIntrin,
573 SmallVector<SDValue, 7> &OpValues,
bool IsScatter);
574 void visitVPStridedLoad(
const VPIntrinsic &VPIntrin, EVT VT,
575 SmallVectorImpl<SDValue> &OpValues);
576 void visitVPStridedStore(
const VPIntrinsic &VPIntrin,
577 SmallVectorImpl<SDValue> &OpValues);
578 void visitVPCmp(
const VPCmpIntrinsic &VPIntrin);
579 void visitVectorPredicationIntrinsic(
const VPIntrinsic &VPIntrin);
581 void visitVAStart(
const CallInst &
I);
582 void visitVAArg(
const VAArgInst &
I);
583 void visitVAEnd(
const CallInst &
I);
584 void visitVACopy(
const CallInst &
I);
585 void visitStackmap(
const CallInst &
I);
586 void visitPatchpoint(
const CallBase &CB,
const BasicBlock *EHPadBB =
nullptr);
589 void visitGCRelocate(
const GCRelocateInst &Relocate);
590 void visitGCResult(
const GCResultInst &
I);
592 void visitVectorReduce(
const CallInst &
I,
unsigned Intrinsic);
593 void visitVectorReverse(
const CallInst &
I);
594 void visitVectorSplice(
const CallInst &
I);
595 void visitStepVector(
const CallInst &
I);
597 void visitUserOp1(
const Instruction &
I) {
598 llvm_unreachable(
"UserOp1 should not exist at instruction selection time!");
600 void visitUserOp2(
const Instruction &
I) {
601 llvm_unreachable(
"UserOp2 should not exist at instruction selection time!");
604 void processIntegerCallValue(
const Instruction &
I,
605 SDValue Value,
bool IsSigned);
607 void HandlePHINodesInSuccessorBlocks(
const BasicBlock *LLVMBB);
609 void emitInlineAsmError(
const CallBase &Call,
const Twine &Message);
614 enum class FuncArgumentDbgValueKind {
623 bool EmitFuncArgumentDbgValue(
const Value *V, DILocalVariable *Variable,
624 DIExpression *Expr, DILocation *
DL,
625 FuncArgumentDbgValueKind
Kind,
629 MachineBasicBlock *NextBlock(MachineBasicBlock *
MBB);
633 void updateDAGForMaybeTailCall(SDValue MaybeTC);
636 SDDbgValue *getDbgValue(SDValue
N, DILocalVariable *Variable,
637 DIExpression *Expr,
const DebugLoc &dl,
638 unsigned DbgSDNodeOrder);
641 void lowerCallToExternalSymbol(
const CallInst &
I,
const char *FunctionName);
643 SDValue lowerStartEH(SDValue Chain,
const BasicBlock *EHPadBB,
645 SDValue lowerEndEH(SDValue Chain,
const InvokeInst *II,
710 const Value *V =
nullptr)
const;
725 unsigned MatchingIdx,
const SDLoc &dl,
739 #endif // LLVM_LIB_CODEGEN_SELECTIONDAG_SELECTIONDAGBUILDER_H
void LowerStatepoint(const GCStatepointInst &I, const BasicBlock *EHPadBB=nullptr)
DenseMap< MachineBasicBlock *, SmallVector< unsigned, 4 > > LPadToCallSiteMap
Map a landing pad to the call site indexes.
@ User
could "use" a pointer
void CopyValueToVirtualRegister(const Value *V, unsigned Reg, ISD::NodeType ExtendType=ISD::ANY_EXTEND)
This is an optimization pass for GlobalISel generic memory operations.
Return a value (possibly void), from a function.
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
A parsed version of the target data layout string in and methods for querying it.
void setValue(const Value *V, SDValue NewN)
SmallVector< SDValue, 8 > PendingLoads
Loads are not emitted to the program immediately.
SwitchLowering(FunctionLoweringInfo &funcinfo)
This structure is used to communicate between SelectionDAGBuilder and SDISel for the code generation ...
void CopyToExportRegsIfNeeded(const Value *V)
CopyToExportRegsIfNeeded - If the given value has virtual registers created for it,...
SmallVector< const Value *, 16 > Bases
Bases[i] is the base pointer for Ptrs[i].
bool occupiesMultipleRegs() const
Check if the total RegCount is greater than one.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
void visitJumpTable(SwitchCG::JumpTable &JT)
visitJumpTable - Emit JumpTable node in the current MBB
SDValue getValue(const Value *V)
getValue - Return an SDValue for the given Value.
Reg
All possible values of the reg field in the ModR/M byte.
ArrayRef< const Use > GCTransitionArgs
The list of gc transition arguments present in the gc.statepoint being lowered.
unsigned NumPatchBytes
The number of patchable bytes the call needs to get lowered into.
@ ANY_EXTEND
ANY_EXTEND - Used for integer types. The high bits are undefined.
Garbage collection metadata for a single function.
The instances of the Type class are immutable: once they are created, they are never changed.
void LowerCallSiteWithDeoptBundle(const CallBase *Call, SDValue Callee, const BasicBlock *EHPadBB)
const BasicBlock * EHPadBB
The exception handling unwind destination, in case this represents an invoke of gc....
CaseClusterVector::iterator CaseClusterIt
This class implements a map that also provides access to all stored values in a deterministic order.
void addDanglingDebugInfo(const DbgValueInst *DI, DebugLoc DL, unsigned Order)
Register a dbg_value which relies on a Value which we have not yet seen.
SDValue getCopyFromRegs(SelectionDAG &DAG, FunctionLoweringInfo &FuncInfo, const SDLoc &dl, SDValue &Chain, SDValue *Flag, const Value *V=nullptr) const
Emit a series of CopyFromReg nodes that copies from this value and returns the result as a ValueVTs v...
DenseMap< const Constant *, unsigned > ConstantsOut
bool isABIMangled() const
void visitSwitchCase(SwitchCG::CaseBlock &CB, MachineBasicBlock *SwitchBB)
visitSwitchCase - Emits the necessary code to represent a single node in the binary search tree resul...
void getCopyToRegs(SDValue Val, SelectionDAG &DAG, const SDLoc &dl, SDValue &Chain, SDValue *Flag, const Value *V=nullptr, ISD::NodeType PreferredExtendType=ISD::ANY_EXTEND) const
Emit a series of CopyToReg nodes that copies the specified value into the registers specified by this...
void visitBitTestHeader(SwitchCG::BitTestBlock &B, MachineBasicBlock *SwitchBB)
visitBitTestHeader - This function emits necessary code to produce value suitable for "bit tests"
LLVM Basic Block Representation.
ArrayRef< const Use > GCArgs
The full list of gc arguments to the gc.statepoint being lowered.
constexpr bool hasValue() const
Represents a gc.statepoint intrinsic call.
SmallVector< const Value *, 16 > Ptrs
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
SDValue lowerRangeToAssertZExt(SelectionDAG &DAG, const Instruction &I, SDValue Op)
This represents the llvm.dbg.value instruction.
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
SmallVector< unsigned, 4 > Regs
This list holds the registers assigned to the values.
const TargetLowering & getTargetLoweringInfo() const
Encapsulates all of the information needed to generate a stack protector check, and signals to isel w...
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
bool handleDebugValue(ArrayRef< const Value * > Values, DILocalVariable *Var, DIExpression *Expr, DebugLoc CurDL, DebugLoc InstDL, unsigned Order, bool IsVariadic)
For a given list of Values, attempt to create and record a SDDbgValue in the SelectionDAG.
void resolveOrClearDbgInfo()
Evict any dangling debug information, attempting to salvage it first.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
NodeType
ISD::NodeType enum - This enum defines the target-independent operators for a SelectionDAG.
Flag
These should be considered private to the implementation of the MCInstrDesc class.
void setUnusedArgValue(const Value *V, SDValue NewN)
void clearDanglingDebugInfo()
Clear the dangling debug information map.
void LowerDeoptimizeCall(const CallInst *CI)
@ AND
Bitwise operators - logical and, logical or, logical xor.
SelectionDAGBuilder(SelectionDAG &dag, FunctionLoweringInfo &funcinfo, SwiftErrorValueTracking &swifterror, CodeGenOpt::Level ol)
static BranchProbability getUnknown()
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
SDValue getMemoryRoot()
Return the current virtual root of the Selection DAG, flushing any PendingLoad items.
@ FADD
Simple binary floating point operators.
This struct represents the registers (physical or virtual) that a particular set of values is assigne...
MVT getFrameIndexTy(const DataLayout &DL) const
Return the type for frame index, which is determined by the alloca address space specified through th...
SDValue getValueImpl(const Value *V)
getValueImpl - Helper function for getValue and getNonRegisterValue.
void visitJumpTableHeader(SwitchCG::JumpTable &JT, SwitchCG::JumpTableHeader &JTH, MachineBasicBlock *SwitchBB)
visitJumpTableHeader - This function emits necessary code to produce index in the JumpTable from swit...
void salvageUnresolvedDbgValue(DanglingDebugInfo &DDI)
For the given dangling debuginfo record, perform last-ditch efforts to resolve the debuginfo to somet...
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
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
This is an important class for using LLVM in a threaded context.
SDValue getCopyFromRegs(const Value *V, Type *Ty)
If there was virtual register allocated for the value V emit CopyFromReg of the specified type Ty.
StatepointLoweringInfo(SelectionDAG &DAG)
SDValue LowerAsSTATEPOINT(StatepointLoweringInfo &SI)
Lower SLI into a STATEPOINT instruction.
virtual void addSuccessorWithProb(MachineBasicBlock *Src, MachineBasicBlock *Dst, BranchProbability Prob=BranchProbability::getUnknown()) override
StatepointLoweringState StatepointLowering
State used while lowering a statepoint sequence (gc_statepoint, gc_relocate, and gc_result).
const TargetLibraryInfo * LibInfo
This structure contains all information that is necessary for lowering calls.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Primary interface to the complete machine description for the target machine.
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
MVT getFrameIndexTy()
Returns the type of FrameIndex and TargetFrameIndex nodes.
StandardInstrumentations SI(Debug, VerifyEach)
SDAGSwitchLowering(SelectionDAGBuilder *sdb, FunctionLoweringInfo &funcinfo)
@ BasicBlock
Various leaf nodes.
SmallVector< std::pair< unsigned, TypeSize >, 4 > getRegsAndSizes() const
Return a list of registers and their sizes.
bool isExportableFromCurrentBlock(const Value *V, const BasicBlock *FromBB)
Describes a gc.statepoint or a gc.statepoint like thing for the purposes of lowering into a STATEPOIN...
SwiftErrorValueTracking & SwiftError
Information about the swifterror values used throughout the function.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
SmallVector< MVT, 4 > RegVTs
The value types of the registers.
SmallVector< MachineOperand, 4 > Cond
Analysis the ScalarEvolution expression for r is this
SelectionDAGBuilder - This is the common target-independent lowering implementation that is parameter...
std::vector< CaseCluster > CaseClusterVector
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
SDLoc getCurSDLoc() const
static const unsigned LowestSDNodeOrder
Lowest valid SDNodeOrder.
void init(GCFunctionInfo *gfi, AAResults *AA, const TargetLibraryInfo *li)
void resolveDanglingDebugInfo(const Value *V, SDValue Val)
If we saw an earlier dbg_value referring to V, generate the debug data structures now that we've seen...
bool HasTailCall
This is set to true if a call in the current block has been translated as a tail call.
StackProtectorDescriptor SPDescriptor
A StackProtectorDescriptor structure used to communicate stack protector information in between Selec...
TargetLowering::CallLoweringInfo CLI
Information regarding the underlying call instruction.
ArrayRef< const Use > DeoptState
The deoptimization state associated with this gc.statepoint call, if any.
Resume the propagation of an exception.
void AddInlineAsmOperands(unsigned Code, bool HasMatching, unsigned MatchingIdx, const SDLoc &dl, SelectionDAG &DAG, std::vector< SDValue > &Ops) const
Add this value to the specified inlineasm node operand list.
void visitSPDescriptorParent(StackProtectorDescriptor &SPD, MachineBasicBlock *ParentBB)
Codegen a new tail for a stack protector check ParentMBB which has had its tail spliced into a stack ...
void append(const RegsForValue &RHS)
Add the specified values to this one.
void LowerCallTo(const CallBase &CB, SDValue Callee, bool IsTailCall, bool IsMustTailCall, const BasicBlock *EHPadBB=nullptr)
const Instruction * StatepointInstr
The gc.statepoint instruction.
SmallVector< EVT, 4 > ValueVTs
The value types of the values, which may not be legal, and may need be promoted or synthesized from o...
const DataLayout & getDataLayout() const
FunctionLoweringInfo & FuncInfo
Information about the function as a whole.
Provides information about what library functions are available for the current target.
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation.
void LowerCallSiteWithDeoptBundleImpl(const CallBase *Call, SDValue Callee, const BasicBlock *EHPadBB, bool VarArgDisallowed, bool ForceVoidReturnTy)
Optional< CallingConv::ID > CallConv
Records if this value needs to be treated in an ABI dependant manner, different to normal type legali...
Indirect Branch Instruction.
@ ADD
Simple integer binary arithmetic operators.
SmallVector< const GCRelocateInst *, 16 > GCRelocates
The set of gc.relocate calls associated with this gc.statepoint.
StatepointFlags
The statepoint intrinsic accepts a set of flags as its third argument.
This class tracks both per-statepoint and per-selectiondag information.
@ SHL
Shift and rotation operations.
void visitBitTestCase(SwitchCG::BitTestBlock &BB, MachineBasicBlock *NextMBB, BranchProbability BranchProbToNext, unsigned Reg, SwitchCG::BitTestCase &B, MachineBasicBlock *SwitchBB)
visitBitTestCase - this function produces one "bit test"
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
SDValue getNonRegisterValue(const Value *V)
getNonRegisterValue - Return an SDValue for the given Value, but don't look in FuncInfo....
void LowerDeoptimizingReturn()
void FindMergedConditions(const Value *Cond, MachineBasicBlock *TBB, MachineBasicBlock *FBB, MachineBasicBlock *CurBB, MachineBasicBlock *SwitchBB, Instruction::BinaryOps Opc, BranchProbability TProb, BranchProbability FProb, bool InvertCond)
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
const char LLVMTargetMachineRef TM
This class represents a function call, abstracting a target machine's calling convention.
@ FNEG
Perform various unary floating-point operations inspired by libm.
void visitSPDescriptorFailure(StackProtectorDescriptor &SPD)
Codegen the failure basic block for a stack protector check.
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
This function has undefined behavior.
void EmitBranchForMergedCondition(const Value *Cond, MachineBasicBlock *TBB, MachineBasicBlock *FBB, MachineBasicBlock *CurBB, MachineBasicBlock *SwitchBB, BranchProbability TProb, BranchProbability FProb, bool InvertCond)
EmitBranchForMergedCondition - Helper method for FindMergedConditions.
std::unique_ptr< SDAGSwitchLowering > SL
std::pair< SDValue, SDValue > lowerInvokable(TargetLowering::CallLoweringInfo &CLI, const BasicBlock *EHPadBB=nullptr)
void clear()
Clear out the current SelectionDAG and the associated state and prepare this SelectionDAGBuilder obje...
Conditional or Unconditional Branch instruction.
void visit(const Instruction &I)
DebugLoc getCurDebugLoc() const
bool ShouldEmitAsBranches(const std::vector< SwitchCG::CaseBlock > &Cases)
If the set of cases should be emitted as a series of branches, return true.
LLVM Value Representation.
SmallVector< unsigned, 4 > RegCount
This list holds the number of registers for each value.
SDValue getRoot()
Similar to getMemoryRoot, but also flushes PendingConstrainedFP(Strict) items.
void UpdateSplitBlock(MachineBasicBlock *First, MachineBasicBlock *Last)
When an MBB was split during scheduling, update the references that need to refer to the last resulti...
void ExportFromCurrentBlock(const Value *V)
ExportFromCurrentBlock - If this condition isn't known to be exported from the current basic block,...
void populateCallLoweringInfo(TargetLowering::CallLoweringInfo &CLI, const CallBase *Call, unsigned ArgIdx, unsigned NumArgs, SDValue Callee, Type *ReturnTy, bool IsPatchPoint)
Populate a CallLowerinInfo (into CLI) based on the properties of the call being lowered.
void dropDanglingDebugInfo(const DILocalVariable *Variable, const DIExpression *Expr)
If we have dangling debug info that describes Variable, or an overlapping part of variable considerin...
A cluster of case labels.
SDValue getControlRoot()
Similar to getRoot, but instead of flushing all the PendingLoad items, flush all the PendingExports (...
GCFunctionInfo * GFI
Garbage collection metadata for the function.