| //===- Local.h - Functions to perform local transformations -----*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This family of functions perform various local transformations to the |
| // program. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_TRANSFORMS_UTILS_LOCAL_H |
| #define LLVM_TRANSFORMS_UTILS_LOCAL_H |
| |
| #include "llvm/ADT/ArrayRef.h" |
| #include "llvm/IR/Dominators.h" |
| #include "llvm/Support/CommandLine.h" |
| #include "llvm/Transforms/Utils/SimplifyCFGOptions.h" |
| #include <cstdint> |
| |
| namespace llvm { |
| |
| class DataLayout; |
| class Value; |
| class WeakTrackingVH; |
| class WeakVH; |
| template <typename T> class SmallVectorImpl; |
| class AAResults; |
| class AllocaInst; |
| class AssumptionCache; |
| class BasicBlock; |
| class BranchInst; |
| class CallBase; |
| class CallInst; |
| class DbgVariableIntrinsic; |
| class DIBuilder; |
| class DomTreeUpdater; |
| class Function; |
| class Instruction; |
| class InvokeInst; |
| class LoadInst; |
| class MDNode; |
| class MemorySSAUpdater; |
| class PHINode; |
| class StoreInst; |
| class TargetLibraryInfo; |
| class TargetTransformInfo; |
| |
| //===----------------------------------------------------------------------===// |
| // Local constant propagation. |
| // |
| |
| /// If a terminator instruction is predicated on a constant value, convert it |
| /// into an unconditional branch to the constant destination. |
| /// This is a nontrivial operation because the successors of this basic block |
| /// must have their PHI nodes updated. |
| /// Also calls RecursivelyDeleteTriviallyDeadInstructions() on any branch/switch |
| /// conditions and indirectbr addresses this might make dead if |
| /// DeleteDeadConditions is true. |
| bool ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions = false, |
| const TargetLibraryInfo *TLI = nullptr, |
| DomTreeUpdater *DTU = nullptr); |
| |
| //===----------------------------------------------------------------------===// |
| // Local dead code elimination. |
| // |
| |
| /// Return true if the result produced by the instruction is not used, and the |
| /// instruction will return. Certain side-effecting instructions are also |
| /// considered dead if there are no uses of the instruction. |
| bool isInstructionTriviallyDead(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. This is equivalent to checking whether |
| /// isInstructionTriviallyDead would be true if the use count was 0. |
| bool wouldInstructionBeTriviallyDead(Instruction *I, |
| const TargetLibraryInfo *TLI = nullptr); |
| |
| /// Return true if the result produced by the instruction has no side effects on |
| /// any paths other than where it is used. This is less conservative than |
| /// wouldInstructionBeTriviallyDead which is based on the assumption |
| /// that the use count will be 0. An example usage of this API is for |
| /// identifying instructions that can be sunk down to use(s). |
| bool wouldInstructionBeTriviallyDeadOnUnusedPaths( |
| Instruction *I, const TargetLibraryInfo *TLI = nullptr); |
| |
| /// If the specified value is a trivially dead instruction, delete it. |
| /// If that makes any of its operands trivially dead, delete them too, |
| /// recursively. Return true if any instructions were deleted. |
| bool RecursivelyDeleteTriviallyDeadInstructions( |
| Value *V, const TargetLibraryInfo *TLI = nullptr, |
| MemorySSAUpdater *MSSAU = nullptr, |
| std::function<void(Value *)> AboutToDeleteCallback = |
| std::function<void(Value *)>()); |
| |
| /// Delete all of the instructions in `DeadInsts`, and all other instructions |
| /// that deleting these in turn causes to be trivially dead. |
| /// |
| /// The initial instructions in the provided vector must all have empty use |
| /// lists and satisfy `isInstructionTriviallyDead`. |
| /// |
| /// `DeadInsts` will be used as scratch storage for this routine and will be |
| /// empty afterward. |
| void RecursivelyDeleteTriviallyDeadInstructions( |
| 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 trivially dead. These will be ignored. |
| /// Returns true if any changes were made, i.e. any instructions trivially dead |
| /// were found and deleted. |
| bool RecursivelyDeleteTriviallyDeadInstructionsPermissive( |
| SmallVectorImpl<WeakTrackingVH> &DeadInsts, |
| const TargetLibraryInfo *TLI = nullptr, MemorySSAUpdater *MSSAU = nullptr, |
| std::function<void(Value *)> AboutToDeleteCallback = |
| std::function<void(Value *)>()); |
| |
| /// If the specified value is an effectively dead PHI node, due to being a |
| /// def-use chain of single-use nodes that either forms a cycle or is terminated |
| /// by a trivially dead instruction, delete it. If that makes any of its |
| /// operands trivially dead, delete them too, recursively. Return true if a |
| /// change was made. |
| bool RecursivelyDeleteDeadPHINode(PHINode *PN, |
| const TargetLibraryInfo *TLI = nullptr, |
| MemorySSAUpdater *MSSAU = nullptr); |
| |
| /// Scan the specified basic block and try to simplify any instructions in it |
| /// and recursively delete dead instructions. |
| /// |
| /// This returns true if it changed the code, note that it can delete |
| /// instructions in other blocks as well in this block. |
| bool SimplifyInstructionsInBlock(BasicBlock *BB, |
| const TargetLibraryInfo *TLI = nullptr); |
| |
| /// Replace all the uses of an SSA value in @llvm.dbg intrinsics with |
| /// undef. This is useful for signaling that a variable, e.g. has been |
| /// found dead and hence it's unavailable at a given program point. |
| /// Returns true if the dbg values have been changed. |
| bool replaceDbgUsesWithUndef(Instruction *I); |
| |
| //===----------------------------------------------------------------------===// |
| // Control Flow Graph Restructuring. |
| // |
| |
| /// BB is a block with one predecessor and its predecessor is known to have one |
| /// successor (BB!). Eliminate the edge between them, moving the instructions in |
| /// the predecessor into BB. This deletes the predecessor block. |
| void MergeBasicBlockIntoOnlyPred(BasicBlock *BB, DomTreeUpdater *DTU = nullptr); |
| |
| /// BB is known to contain an unconditional branch, and contains no instructions |
| /// other than PHI nodes, potential debug intrinsics and the branch. If |
| /// possible, eliminate BB by rewriting all the predecessors to branch to the |
| /// successor block and return true. If we can't transform, return false. |
| bool TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB, |
| DomTreeUpdater *DTU = nullptr); |
| |
| /// Check for and eliminate duplicate PHI nodes in this block. This doesn't try |
| /// to be clever about PHI nodes which differ only in the order of the incoming |
| /// values, but instcombine orders them so it usually won't matter. |
| bool EliminateDuplicatePHINodes(BasicBlock *BB); |
| |
| /// This function is used to do simplification of a CFG. For example, it |
| /// adjusts branches to branches to eliminate the extra hop, it eliminates |
| /// unreachable basic blocks, and does other peephole optimization of the CFG. |
| /// It returns true if a modification was made, possibly deleting the basic |
| /// block that was pointed to. LoopHeaders is an optional input parameter |
| /// providing the set of loop headers that SimplifyCFG should not eliminate. |
| extern cl::opt<bool> RequireAndPreserveDomTree; |
| bool simplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI, |
| DomTreeUpdater *DTU = nullptr, |
| const SimplifyCFGOptions &Options = {}, |
| ArrayRef<WeakVH> LoopHeaders = {}); |
| |
| /// This function is used to flatten a CFG. For example, it uses parallel-and |
| /// and parallel-or mode to collapse if-conditions and merge if-regions with |
| /// identical statements. |
| bool FlattenCFG(BasicBlock *BB, AAResults *AA = nullptr); |
| |
| /// If this basic block is ONLY a setcc and a branch, and if a predecessor |
| /// branches to us and one of our successors, fold the setcc into the |
| /// predecessor and use logical operations to pick the right destination. |
| bool FoldBranchToCommonDest(BranchInst *BI, llvm::DomTreeUpdater *DTU = nullptr, |
| MemorySSAUpdater *MSSAU = nullptr, |
| const TargetTransformInfo *TTI = nullptr, |
| unsigned BonusInstThreshold = 1); |
| |
| /// This function takes a virtual register computed by an Instruction and |
| /// replaces it with a slot in the stack frame, allocated via alloca. |
| /// This allows the CFG to be changed around without fear of invalidating the |
| /// SSA information for the value. It returns the pointer to the alloca inserted |
| /// to create a stack slot for X. |
| AllocaInst *DemoteRegToStack(Instruction &X, |
| bool VolatileLoads = false, |
| Instruction *AllocaPoint = nullptr); |
| |
| /// This function takes a virtual register computed by a phi node and replaces |
| /// it with a slot in the stack frame, allocated via alloca. The phi node is |
| /// deleted and it returns the pointer to the alloca inserted. |
| AllocaInst *DemotePHIToStack(PHINode *P, Instruction *AllocaPoint = nullptr); |
| |
| /// Try to ensure that the alignment of \p V is at least \p PrefAlign bytes. If |
| /// the owning object can be modified and has an alignment less than \p |
| /// PrefAlign, it will be increased and \p PrefAlign returned. If the alignment |
| /// cannot be increased, the known alignment of the value is returned. |
| /// |
| /// It is not always possible to modify the alignment of the underlying object, |
| /// so if alignment is important, a more reliable approach is to simply align |
| /// all global variables and allocation instructions to their preferred |
| /// alignment from the beginning. |
| Align getOrEnforceKnownAlignment(Value *V, MaybeAlign PrefAlign, |
| const DataLayout &DL, |
| const Instruction *CxtI = nullptr, |
| AssumptionCache *AC = nullptr, |
| const DominatorTree *DT = nullptr); |
| |
| /// Try to infer an alignment for the specified pointer. |
| inline Align getKnownAlignment(Value *V, const DataLayout &DL, |
| const Instruction *CxtI = nullptr, |
| AssumptionCache *AC = nullptr, |
| const DominatorTree *DT = nullptr) { |
| return getOrEnforceKnownAlignment(V, MaybeAlign(), DL, CxtI, AC, DT); |
| } |
| |
| /// Create a call that matches the invoke \p II in terms of arguments, |
| /// attributes, debug information, etc. The call is not placed in a block and it |
| /// will not have a name. The invoke instruction is not removed, nor are the |
| /// uses replaced by the new call. |
| CallInst *createCallMatchingInvoke(InvokeInst *II); |
| |
| /// This function converts the specified invoek into a normall call. |
| CallInst *changeToCall(InvokeInst *II, DomTreeUpdater *DTU = nullptr); |
| |
| ///===---------------------------------------------------------------------===// |
| /// Dbg Intrinsic utilities |
| /// |
| |
| /// Inserts a llvm.dbg.value intrinsic before a store to an alloca'd value |
| /// that has an associated llvm.dbg.declare or llvm.dbg.addr intrinsic. |
| void ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII, |
| StoreInst *SI, DIBuilder &Builder); |
| |
| /// Inserts a llvm.dbg.value intrinsic before a load of an alloca'd value |
| /// that has an associated llvm.dbg.declare or llvm.dbg.addr intrinsic. |
| void ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII, |
| LoadInst *LI, DIBuilder &Builder); |
| |
| /// Inserts a llvm.dbg.value intrinsic after a phi that has an associated |
| /// llvm.dbg.declare or llvm.dbg.addr intrinsic. |
| void ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII, |
| PHINode *LI, DIBuilder &Builder); |
| |
| /// Lowers llvm.dbg.declare intrinsics into appropriate set of |
| /// llvm.dbg.value intrinsics. |
| bool LowerDbgDeclare(Function &F); |
| |
| /// Propagate dbg.value intrinsics through the newly inserted PHIs. |
| void insertDebugValuesForPHIs(BasicBlock *BB, |
| SmallVectorImpl<PHINode *> &InsertedPHIs); |
| |
| /// Replaces llvm.dbg.declare instruction when the address it |
| /// describes is replaced with a new value. If Deref is true, an |
| /// additional DW_OP_deref is prepended to the expression. If Offset |
| /// is non-zero, a constant displacement is added to the expression |
| /// (between the optional Deref operations). Offset can be negative. |
| bool replaceDbgDeclare(Value *Address, Value *NewAddress, DIBuilder &Builder, |
| uint8_t DIExprFlags, int Offset); |
| |
| /// Replaces multiple llvm.dbg.value instructions when the alloca it describes |
| /// is replaced with a new value. If Offset is non-zero, a constant displacement |
| /// is added to the expression (after the mandatory Deref). Offset can be |
| /// negative. New llvm.dbg.value instructions are inserted at the locations of |
| /// the instructions they replace. |
| void replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress, |
| DIBuilder &Builder, int Offset = 0); |
| |
| /// Assuming the instruction \p I is going to be deleted, attempt to salvage |
| /// debug users of \p I by writing the effect of \p I in a DIExpression. If it |
| /// cannot be salvaged changes its debug uses to undef. |
| void salvageDebugInfo(Instruction &I); |
| |
| |
| /// Implementation of salvageDebugInfo, applying only to instructions in |
| /// \p Insns, rather than all debug users from findDbgUsers( \p I). |
| /// Returns true if any debug users were updated. |
| /// Mark undef if salvaging cannot be completed. |
| void salvageDebugInfoForDbgValues(Instruction &I, |
| ArrayRef<DbgVariableIntrinsic *> Insns); |
| |
| /// Given an instruction \p I and DIExpression \p DIExpr operating on |
| /// it, append the effects of \p I to the DIExpression operand list |
| /// \p Ops, or return \p nullptr if it cannot be salvaged. |
| /// \p CurrentLocOps is the number of SSA values referenced by the |
| /// incoming \p Ops. \return the first non-constant operand |
| /// implicitly referred to by Ops. If \p I references more than one |
| /// non-constant operand, any additional operands are added to |
| /// \p AdditionalValues. |
| /// |
| /// \example |
| //// |
| /// I = add %a, i32 1 |
| /// |
| /// Return = %a |
| /// Ops = llvm::dwarf::DW_OP_lit1 llvm::dwarf::DW_OP_add |
| /// |
| /// I = add %a, %b |
| /// |
| /// Return = %a |
| /// Ops = llvm::dwarf::DW_OP_LLVM_arg0 llvm::dwarf::DW_OP_add |
| /// AdditionalValues = %b |
| Value *salvageDebugInfoImpl(Instruction &I, uint64_t CurrentLocOps, |
| SmallVectorImpl<uint64_t> &Ops, |
| SmallVectorImpl<Value *> &AdditionalValues); |
| |
| /// Point debug users of \p From to \p To or salvage them. Use this function |
| /// only when replacing all uses of \p From with \p To, with a guarantee that |
| /// \p From is going to be deleted. |
| /// |
| /// Follow these rules to prevent use-before-def of \p To: |
| /// . If \p To is a linked Instruction, set \p DomPoint to \p To. |
| /// . If \p To is an unlinked Instruction, set \p DomPoint to the Instruction |
| /// \p To will be inserted after. |
| /// . If \p To is not an Instruction (e.g a Constant), the choice of |
| /// \p DomPoint is arbitrary. Pick \p From for simplicity. |
| /// |
| /// If a debug user cannot be preserved without reordering variable updates or |
| /// introducing a use-before-def, it is either salvaged (\ref salvageDebugInfo) |
| /// or deleted. Returns true if any debug users were updated. |
| bool replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint, |
| DominatorTree &DT); |
| |
| /// Remove all instructions from a basic block other than its terminator |
| /// and any present EH pad instructions. Returns a pair where the first element |
| /// is the number of instructions (excluding debug info instrinsics) that have |
| /// been removed, and the second element is the number of debug info intrinsics |
| /// that have been removed. |
| std::pair<unsigned, unsigned> |
| removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB); |
| |
| /// Insert an unreachable instruction before the specified |
| /// instruction, making it and the rest of the code in the block dead. |
| unsigned changeToUnreachable(Instruction *I, bool PreserveLCSSA = false, |
| DomTreeUpdater *DTU = nullptr, |
| MemorySSAUpdater *MSSAU = nullptr); |
| |
| /// Convert the CallInst to InvokeInst with the specified unwind edge basic |
| /// block. This also splits the basic block where CI is located, because |
| /// InvokeInst is a terminator instruction. Returns the newly split basic |
| /// block. |
| BasicBlock *changeToInvokeAndSplitBasicBlock(CallInst *CI, |
| BasicBlock *UnwindEdge, |
| DomTreeUpdater *DTU = nullptr); |
| |
| /// Replace 'BB's terminator with one that does not have an unwind successor |
| /// block. Rewrites `invoke` to `call`, etc. Updates any PHIs in unwind |
| /// successor. |
| /// |
| /// \param BB Block whose terminator will be replaced. Its terminator must |
| /// have an unwind successor. |
| void removeUnwindEdge(BasicBlock *BB, DomTreeUpdater *DTU = nullptr); |
| |
| /// Remove all blocks that can not be reached from the function's entry. |
| /// |
| /// Returns true if any basic block was removed. |
| bool removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU = nullptr, |
| MemorySSAUpdater *MSSAU = nullptr); |
| |
| /// Combine the metadata of two instructions so that K can replace J. Some |
| /// metadata kinds can only be kept if K does not move, meaning it dominated |
| /// J in the original IR. |
| /// |
| /// Metadata not listed as known via KnownIDs is removed |
| void combineMetadata(Instruction *K, const Instruction *J, |
| ArrayRef<unsigned> KnownIDs, bool DoesKMove); |
| |
| /// Combine the metadata of two instructions so that K can replace J. This |
| /// specifically handles the case of CSE-like transformations. Some |
| /// metadata can only be kept if K dominates J. For this to be correct, |
| /// K cannot be hoisted. |
| /// |
| /// Unknown metadata is removed. |
| void combineMetadataForCSE(Instruction *K, const Instruction *J, |
| bool DoesKMove); |
| |
| /// Copy the metadata from the source instruction to the destination (the |
| /// replacement for the source instruction). |
| void copyMetadataForLoad(LoadInst &Dest, const LoadInst &Source); |
| |
| /// Patch the replacement so that it is not more restrictive than the value |
| /// being replaced. It assumes that the replacement does not get moved from |
| /// its original position. |
| void patchReplacementInstruction(Instruction *I, Value *Repl); |
| |
| // Replace each use of 'From' with 'To', if that use does not belong to basic |
| // block where 'From' is defined. Returns the number of replacements made. |
| unsigned replaceNonLocalUsesWith(Instruction *From, Value *To); |
| |
| /// Replace each use of 'From' with 'To' if that use is dominated by |
| /// the given edge. Returns the number of replacements made. |
| 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 end of the given BasicBlock. Returns the number of replacements made. |
| unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT, |
| const BasicBlock *BB); |
| |
| /// Return true if this call calls a gc leaf function. |
| /// |
| /// A leaf function is a function that does not safepoint the thread during its |
| /// execution. During a call or invoke to such a function, the callers stack |
| /// does not have to be made parseable. |
| /// |
| /// Most passes can and should ignore this information, and it is only used |
| /// during lowering by the GC infrastructure. |
| bool callsGCLeafFunction(const CallBase *Call, const TargetLibraryInfo &TLI); |
| |
| /// Copy a nonnull metadata node to a new load instruction. |
| /// |
| /// This handles mapping it to range metadata if the new load is an integer |
| /// load instead of a pointer load. |
| void copyNonnullMetadata(const LoadInst &OldLI, MDNode *N, LoadInst &NewLI); |
| |
| /// Copy a range metadata node to a new load instruction. |
| /// |
| /// This handles mapping it to nonnull metadata if the new load is a pointer |
| /// load instead of an integer load and the range doesn't cover null. |
| void copyRangeMetadata(const DataLayout &DL, const LoadInst &OldLI, MDNode *N, |
| LoadInst &NewLI); |
| |
| /// Remove the debug intrinsic instructions for the given instruction. |
| void dropDebugUsers(Instruction &I); |
| |
| /// Hoist all of the instructions in the \p IfBlock to the dominant block |
| /// \p DomBlock, by moving its instructions to the insertion point \p InsertPt. |
| /// |
| /// The moved instructions receive the insertion point debug location values |
| /// (DILocations) and their debug intrinsic instructions are removed. |
| void hoistAllInstructionsInto(BasicBlock *DomBlock, Instruction *InsertPt, |
| BasicBlock *BB); |
| |
| //===----------------------------------------------------------------------===// |
| // Intrinsic pattern matching |
| // |
| |
| /// Try to match a bswap or bitreverse idiom. |
| /// |
| /// If an idiom is matched, an intrinsic call is inserted before \c I. Any added |
| /// instructions are returned in \c InsertedInsts. They will all have been added |
| /// to a basic block. |
| /// |
| /// A bitreverse idiom normally requires around 2*BW nodes to be searched (where |
| /// BW is the bitwidth of the integer type). A bswap idiom requires anywhere up |
| /// to BW / 4 nodes to be searched, so is significantly faster. |
| /// |
| /// This function returns true on a successful match or false otherwise. |
| bool recognizeBSwapOrBitReverseIdiom( |
| Instruction *I, bool MatchBSwaps, bool MatchBitReversals, |
| SmallVectorImpl<Instruction *> &InsertedInsts); |
| |
| //===----------------------------------------------------------------------===// |
| // Sanitizer utilities |
| // |
| |
| /// Given a CallInst, check if it calls a string function known to CodeGen, |
| /// and mark it with NoBuiltin if so. To be used by sanitizers that intend |
| /// to intercept string functions and want to avoid converting them to target |
| /// specific instructions. |
| void maybeMarkSanitizerLibraryCallNoBuiltin(CallInst *CI, |
| const TargetLibraryInfo *TLI); |
| |
| //===----------------------------------------------------------------------===// |
| // Transform predicates |
| // |
| |
| /// Given an instruction, is it legal to set operand OpIdx to a non-constant |
| /// value? |
| bool canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx); |
| |
| //===----------------------------------------------------------------------===// |
| // Value helper functions |
| // |
| |
| /// Invert the given true/false value, possibly reusing an existing copy. |
| Value *invertCondition(Value *Condition); |
| |
| |
| //===----------------------------------------------------------------------===// |
| // Assorted |
| // |
| |
| /// If we can infer one attribute from another on the declaration of a |
| /// function, explicitly materialize the maximal set in the IR. |
| bool inferAttributesFromOthers(Function &F); |
| |
| } // end namespace llvm |
| |
| #endif // LLVM_TRANSFORMS_UTILS_LOCAL_H |