Local.h (original) (raw)

Given an instruction I and DIExpression DIExpr operating on it, append the effects of I to the DIExpression operand list Ops, or return nullptr if it cannot be salvaged.

Given an instruction I and DIExpression DIExpr operating on it, append the effects of I to the DIExpression operand list Ops, or return nullptr if it cannot be salvaged.CurrentLocOps is the number of SSA values referenced by the incoming Ops.

Return = a Ops = llvm::dwarf::DW_OP_LLVM_arg0 llvm::dwarf::DW_OP_add AdditionalValues = b

#ifndef LLVM_TRANSFORMS_UTILS_LOCAL_H

#define LLVM_TRANSFORMS_UTILS_LOCAL_H

#include

class DataLayout;

class Value;

class WeakTrackingVH;

class WeakVH;

template class SmallVectorImpl;

class AAResults;

class AllocaInst;

class AssumptionCache;

class BasicBlock;

class BranchInst;

class CallBase;

class CallInst;

class DIBuilder;

class DomTreeUpdater;

class Function;

class Instruction;

class InvokeInst;

class LoadInst;

class MDNode;

class MemorySSAUpdater;

class PHINode;

class StoreInst;

class TargetLibraryInfo;

class TargetTransformInfo;

bool DeleteDeadConditions = false,

const TargetLibraryInfo *TLI = nullptr,

DomTreeUpdater *DTU = nullptr);

const TargetLibraryInfo *TLI = nullptr);

Instruction *I, const TargetLibraryInfo *TLI = nullptr);

Value *V, const TargetLibraryInfo *TLI = nullptr,

MemorySSAUpdater *MSSAU = nullptr,

std::function<void(Value *)> AboutToDeleteCallback =

std::function<void(Value *)>());

SmallVectorImpl &DeadInsts,

const TargetLibraryInfo *TLI = nullptr, MemorySSAUpdater *MSSAU = nullptr,

std::function<void(Value *)> AboutToDeleteCallback =

std::function<void(Value *)>());

SmallVectorImpl &DeadInsts,

const TargetLibraryInfo *TLI = nullptr, MemorySSAUpdater *MSSAU = nullptr,

std::function<void(Value *)> AboutToDeleteCallback =

std::function<void(Value *)>());

const TargetLibraryInfo *TLI = nullptr,

MemorySSAUpdater *MSSAU = nullptr);

const TargetLibraryInfo *TLI = nullptr);

DomTreeUpdater *DTU = nullptr);

SmallPtrSetImpl<PHINode *> &ToRemove);

DomTreeUpdater *DTU = nullptr,

const SimplifyCFGOptions &Options = {},

MemorySSAUpdater *MSSAU = nullptr,

const TargetTransformInfo *TTI = nullptr,

unsigned BonusInstThreshold = 1);

Instruction &X, bool VolatileLoads = false,

std::optionalBasicBlock::iterator AllocaPoint = std::nullopt);

PHINode *P, std::optionalBasicBlock::iterator AllocaPoint = std::nullopt);

const DataLayout &DL);

const DataLayout &DL,

const Instruction *CxtI = nullptr,

AssumptionCache *AC = nullptr,

const DominatorTree *DT = nullptr);

const Instruction *CxtI = nullptr,

AssumptionCache *AC = nullptr,

const DominatorTree *DT = nullptr) {

}

DIBuilder &Builder);

StoreInst *SI,

DIBuilder &Builder);

LoadInst *LI, DIBuilder &Builder);

PHINode *LI, DIBuilder &Builder);

SmallVectorImpl<PHINode *> &InsertedPHIs);

DIBuilder &Builder, uint8_t DIExprFlags,

DIBuilder &Builder, int Offset = 0);

SmallVectorImpl<uint64_t> &Ops,

SmallVectorImpl<Value *> &AdditionalValues);

Instruction &DomPoint, DominatorTree &DT);

SmallVectorImpl<Value *> &PoisonedValues);

bool PreserveLCSSA = false,

DomTreeUpdater *DTU = nullptr,

MemorySSAUpdater *MSSAU = nullptr);

DomTreeUpdater *DTU = nullptr);

DomTreeUpdater *DTU = nullptr,

MemorySSAUpdater *MSSAU = nullptr);

bool DoesKMove);

DominatorTree &DT,

const BasicBlockEdge &Edge);

DominatorTree &DT,

const BasicBlock *BB);

DominatorTree &DT,

const Instruction *I);

Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Edge,

function_ref<bool(const Use &U, const Value *To)> ShouldReplace);

Value *From, Value *To, DominatorTree &DT, const BasicBlock *BB,

function_ref<bool(const Use &U, const Value *To)> ShouldReplace);

Value *From, Value *To, DominatorTree &DT, const Instruction *I,

function_ref<bool(const Use &U, const Value *To)> ShouldReplace);

const TargetLibraryInfo &TLI);

LoadInst &NewLI);

MDNode *N, LoadInst &NewLI);

Instruction *InsertPt, BasicBlock *BB);

const Constant &C, Type &Ty);

bool MatchBitReversals,

SmallVectorImpl<Instruction *> &InsertedInsts);

const TargetLibraryInfo *TLI);

struct OverflowTracking {

#ifndef NDEBUG

std::optional Opcode;

#endif

};

}

#endif

ReachingDefInfo InstSet & ToRemove

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")

const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]

MachineInstr unsigned OpIdx

uint64_t IntrinsicInst * II

StandardInstrumentations SI(Mod->getContext(), Debug, VerifyEach)

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

template class LLVM_TEMPLATE_ABI opt< bool >

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ABI unsigned removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB)

Remove all instructions from a basic block other than its terminator and any present EH pad instructi...

LLVM_ABI bool RecursivelyDeleteTriviallyDeadInstructions(Value *V, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr, std::function< void(Value *)> AboutToDeleteCallback=std::function< void(Value *)>())

If the specified value is a trivially dead instruction, delete it.

LLVM_ABI BasicBlock * changeToInvokeAndSplitBasicBlock(CallInst *CI, BasicBlock *UnwindEdge, DomTreeUpdater *DTU=nullptr)

Convert the CallInst to InvokeInst with the specified unwind edge basic block.

LLVM_ABI bool ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions=false, const TargetLibraryInfo *TLI=nullptr, DomTreeUpdater *DTU=nullptr)

If a terminator instruction is predicated on a constant value, convert it into an unconditional branc...

LLVM_ABI bool FlattenCFG(BasicBlock *BB, AAResults *AA=nullptr)

This function is used to flatten a CFG.

LLVM_ABI unsigned replaceDominatedUsesWithIf(Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Edge, function_ref< bool(const Use &U, const Value *To)> ShouldReplace)

Replace each use of 'From' with 'To' if that use is dominated by the given edge and the callback Shou...

LLVM_ABI unsigned replaceNonLocalUsesWith(Instruction *From, Value *To)

LLVM_ABI void salvageDebugInfo(const MachineRegisterInfo &MRI, MachineInstr &MI)

Assuming the instruction MI is going to be deleted, attempt to salvage debug users of MI by writing t...

LLVM_ABI CallInst * changeToCall(InvokeInst *II, DomTreeUpdater *DTU=nullptr)

This function converts the specified invoke into a normal call.

LLVM_ABI void copyMetadataForLoad(LoadInst &Dest, const LoadInst &Source)

Copy the metadata from the source instruction to the destination (the replacement for the source inst...

LLVM_ABI void InsertDebugValueAtStoreLoc(DbgVariableRecord *DVR, StoreInst *SI, DIBuilder &Builder)

===------------------------------------------------------------------—===// Dbg Intrinsic utilities

LLVM_ABI void remapDebugVariable(ValueToValueMapTy &Mapping, Instruction *Inst)

Remap the operands of the debug records attached to Inst, and the operands of Inst itself if it's a d...

LLVM_ABI bool SimplifyInstructionsInBlock(BasicBlock *BB, const TargetLibraryInfo *TLI=nullptr)

Scan the specified basic block and try to simplify any instructions in it and recursively delete dead...

LLVM_ABI void insertDebugValuesForPHIs(BasicBlock *BB, SmallVectorImpl< PHINode * > &InsertedPHIs)

Propagate dbg.value intrinsics through the newly inserted PHIs.

LLVM_ABI bool handleUnreachableTerminator(Instruction *I, SmallVectorImpl< Value * > &PoisonedValues)

If a terminator in an unreachable basic block has an operand of type Instruction, transform it into p...

LLVM_ABI AllocaInst * DemoteRegToStack(Instruction &X, bool VolatileLoads=false, std::optional< BasicBlock::iterator > AllocaPoint=std::nullopt)

This function takes a virtual register computed by an Instruction and replaces it with a slot in the ...

Align getKnownAlignment(Value *V, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)

Try to infer an alignment for the specified pointer.

LLVM_ABI bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)

Return true if the result produced by the instruction is not used, and the instruction will return.

LLVM_ABI AllocaInst * DemotePHIToStack(PHINode *P, std::optional< BasicBlock::iterator > AllocaPoint=std::nullopt)

This function takes a virtual register computed by a phi node and replaces it with a slot in the stac...

LLVM_ABI bool TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB, DomTreeUpdater *DTU=nullptr)

BB is known to contain an unconditional branch, and contains no instructions other than PHI nodes,...

LLVM_ABI bool recognizeBSwapOrBitReverseIdiom(Instruction *I, bool MatchBSwaps, bool MatchBitReversals, SmallVectorImpl< Instruction * > &InsertedInsts)

Try to match a bswap or bitreverse idiom.

LLVM_ABI Align getOrEnforceKnownAlignment(Value *V, MaybeAlign PrefAlign, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)

Try to ensure that the alignment of V is at least PrefAlign bytes.

LLVM_ABI bool wouldInstructionBeTriviallyDeadOnUnusedPaths(Instruction *I, const TargetLibraryInfo *TLI=nullptr)

Return true if the result produced by the instruction has no side effects on any paths other than whe...

LLVM_ABI bool LowerDbgDeclare(Function &F)

Lowers dbg.declare records into appropriate set of dbg.value records.

LLVM_ABI DIExpression * getExpressionForConstant(DIBuilder &DIB, const Constant &C, Type &Ty)

Given a constant, create a debug information expression.

LLVM_ABI CallInst * createCallMatchingInvoke(InvokeInst *II)

Create a call that matches the invoke II in terms of arguments, attributes, debug information,...

LLVM_ABI void ConvertDebugDeclareToDebugValue(DbgVariableRecord *DVR, StoreInst *SI, DIBuilder &Builder)

Inserts a dbg.value record before a store to an alloca'd value that has an associated dbg....

LLVM_ABI Instruction * removeUnwindEdge(BasicBlock *BB, DomTreeUpdater *DTU=nullptr)

Replace 'BB's terminator with one that does not have an unwind successor block.

LLVM_ABI bool wouldInstructionBeTriviallyDead(const Instruction *I, const TargetLibraryInfo *TLI=nullptr)

Return true if the result produced by the instruction would have no side effects if it was not used.

LLVM_ABI void patchReplacementInstruction(Instruction *I, Value *Repl)

Patch the replacement so that it is not more restrictive than the value being replaced.

LLVM_ABI void salvageDebugInfoForDbgValues(Instruction &I, ArrayRef< DbgVariableRecord * > DPInsns)

Implementation of salvageDebugInfo, applying only to instructions in Insns, rather than all debug use...

LLVM_ABI unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Edge)

Replace each use of 'From' with 'To' if that use is dominated by the given edge.

LLVM_ABI unsigned changeToUnreachable(Instruction *I, bool PreserveLCSSA=false, DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr)

Insert an unreachable instruction before the specified instruction, making it and the rest of the cod...

LLVM_ABI bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT)

Point debug users of From to To or salvage them.

LLVM_ABI Value * salvageDebugInfoImpl(Instruction &I, uint64_t CurrentLocOps, SmallVectorImpl< uint64_t > &Ops, SmallVectorImpl< Value * > &AdditionalValues)

LLVM_ABI void combineMetadataForCSE(Instruction *K, const Instruction *J, bool DoesKMove)

Combine the metadata of two instructions so that K can replace J.

LLVM_ABI void dropDebugUsers(Instruction &I)

Remove the debug intrinsic instructions for the given instruction.

LLVM_ABI void MergeBasicBlockIntoOnlyPred(BasicBlock *BB, DomTreeUpdater *DTU=nullptr)

BB is a block with one predecessor and its predecessor is known to have one successor (BB!...

LLVM_ABI cl::opt< bool > RequireAndPreserveDomTree

This function is used to do simplification of a CFG.

LLVM_ABI bool replaceDbgUsesWithUndef(Instruction *I)

Replace all the uses of an SSA value in @llvm.dbg intrinsics with undef.

LLVM_ABI void hoistAllInstructionsInto(BasicBlock *DomBlock, Instruction *InsertPt, BasicBlock *BB)

Hoist all of the instructions in the IfBlock to the dominant block DomBlock, by moving its instructio...

LLVM_ABI void copyRangeMetadata(const DataLayout &DL, const LoadInst &OldLI, MDNode *N, LoadInst &NewLI)

Copy a range metadata node to a new load instruction.

LLVM_ABI void copyNonnullMetadata(const LoadInst &OldLI, MDNode *N, LoadInst &NewLI)

Copy a nonnull metadata node to a new load instruction.

LLVM_ABI bool canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx)

Given an instruction, is it legal to set operand OpIdx to a non-constant value?

LLVM_ABI void replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress, DIBuilder &Builder, int Offset=0)

Replaces multiple dbg.value records when the alloca it describes is replaced with a new value.

LLVM_ABI Align tryEnforceAlignment(Value *V, Align PrefAlign, const DataLayout &DL)

If the specified pointer points to an object that we control, try to modify the object's alignment to...

ArrayRef(const T &OneElt) -> ArrayRef< T >

LLVM_ABI bool RecursivelyDeleteTriviallyDeadInstructionsPermissive(SmallVectorImpl< WeakTrackingVH > &DeadInsts, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr, std::function< void(Value *)> AboutToDeleteCallback=std::function< void(Value *)>())

Same functionality as RecursivelyDeleteTriviallyDeadInstructions, but allow instructions that are not...

ValueMap< const Value *, WeakTrackingVH > ValueToValueMapTy

LLVM_ABI bool simplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI, DomTreeUpdater *DTU=nullptr, const SimplifyCFGOptions &Options={}, ArrayRef< WeakVH > LoopHeaders={})

LLVM_ABI void combineAAMetadata(Instruction *K, const Instruction *J)

Combine metadata of two instructions, where instruction J is a memory access that has been merged int...

LLVM_ABI bool RecursivelyDeleteDeadPHINode(PHINode *PN, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr)

If the specified value is an effectively dead PHI node, due to being a def-use chain of single-use no...

LLVM_ABI bool foldBranchToCommonDest(BranchInst *BI, llvm::DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr, const TargetTransformInfo *TTI=nullptr, unsigned BonusInstThreshold=1)

If this basic block is ONLY a setcc and a branch, and if a predecessor branches to us and one of our ...

LLVM_ABI bool inferAttributesFromOthers(Function &F)

If we can infer one attribute from another on the declaration of a function, explicitly materialize t...

LLVM_ABI Value * invertCondition(Value *Condition)

Invert the given true/false value, possibly reusing an existing copy.

LLVM_ABI void maybeMarkSanitizerLibraryCallNoBuiltin(CallInst *CI, const TargetLibraryInfo *TLI)

Given a CallInst, check if it calls a string function known to CodeGen, and mark it with NoBuiltin if...

LLVM_ABI bool removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr)

Remove all blocks that can not be reached from the function's entry.

LLVM_ABI bool EliminateDuplicatePHINodes(BasicBlock *BB)

Check for and eliminate duplicate PHI nodes in this block.

LLVM_ABI bool callsGCLeafFunction(const CallBase *Call, const TargetLibraryInfo &TLI)

Return true if this call calls a gc leaf function.

LLVM_ABI bool replaceDbgDeclare(Value *Address, Value *NewAddress, DIBuilder &Builder, uint8_t DIExprFlags, int Offset)

Replaces dbg.declare record when the address it describes is replaced with a new value.

LLVM_ABI void mergeFlags(Instruction &I)

Merge in the no-wrap flags from I.

OverflowTracking()=default

LLVM_ABI void applyFlags(Instruction &I)

Apply the no-wrap flags to I if applicable.