//===- Local.cpp - Functions to perform local transformations -------------===// // // 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. // //===----------------------------------------------------------------------===// #include "llvm/Transforms/Utils/Local.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMapInfo.h" #include "llvm/ADT/DenseSet.h" #include "llvm/ADT/Hashing.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SetVector.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/Statistic.h" #include "llvm/Analysis/AssumeBundleQueries.h" #include "llvm/Analysis/ConstantFolding.h" #include "llvm/Analysis/DomTreeUpdater.h" #include "llvm/Analysis/InstructionSimplify.h" #include "llvm/Analysis/MemoryBuiltins.h" #include "llvm/Analysis/MemorySSAUpdater.h" #include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/Analysis/ValueTracking.h" #include "llvm/Analysis/VectorUtils.h" #include "llvm/BinaryFormat/Dwarf.h" #include "llvm/IR/Argument.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/BasicBlock.h" #include "llvm/IR/CFG.h" #include "llvm/IR/Constant.h" #include "llvm/IR/ConstantRange.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DIBuilder.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/DebugInfo.h" #include "llvm/IR/DebugInfoMetadata.h" #include "llvm/IR/DebugLoc.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Dominators.h" #include "llvm/IR/EHPersonalities.h" #include "llvm/IR/Function.h" #include "llvm/IR/GetElementPtrTypeIterator.h" #include "llvm/IR/GlobalObject.h" #include "llvm/IR/IRBuilder.h" #include "llvm/IR/InstrTypes.h" #include "llvm/IR/Instruction.h" #include "llvm/IR/Instructions.h" #include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/Intrinsics.h" #include "llvm/IR/IntrinsicsWebAssembly.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/MDBuilder.h" #include "llvm/IR/MemoryModelRelaxationAnnotations.h" #include "llvm/IR/Metadata.h" #include "llvm/IR/Module.h" #include "llvm/IR/PatternMatch.h" #include "llvm/IR/ProfDataUtils.h" #include "llvm/IR/Type.h" #include "llvm/IR/Use.h" #include "llvm/IR/User.h" #include "llvm/IR/Value.h" #include "llvm/IR/ValueHandle.h" #include "llvm/Support/Casting.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/KnownBits.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Transforms/Utils/BasicBlockUtils.h" #include "llvm/Transforms/Utils/ValueMapper.h" #include <algorithm> #include <cassert> #include <cstdint> #include <iterator> #include <map> #include <optional> #include <utility> usingnamespacellvm; usingnamespacellvm::PatternMatch; extern cl::opt<bool> UseNewDbgInfoFormat; #define DEBUG_TYPE … STATISTIC(NumRemoved, "Number of unreachable basic blocks removed"); STATISTIC(NumPHICSEs, "Number of PHI's that got CSE'd"); static cl::opt<bool> PHICSEDebugHash( "phicse-debug-hash", #ifdef EXPENSIVE_CHECKS cl::init(true), #else cl::init(false), #endif cl::Hidden, cl::desc("Perform extra assertion checking to verify that PHINodes's hash " "function is well-behaved w.r.t. its isEqual predicate")); static cl::opt<unsigned> PHICSENumPHISmallSize( "phicse-num-phi-smallsize", cl::init(32), cl::Hidden, cl::desc( "When the basic block contains not more than this number of PHI nodes, " "perform a (faster!) exhaustive search instead of set-driven one.")); static cl::opt<unsigned> MaxPhiEntriesIncreaseAfterRemovingEmptyBlock( "max-phi-entries-increase-after-removing-empty-block", cl::init(1000), cl::Hidden, cl::desc("Stop removing an empty block if removing it will introduce more " "than this number of phi entries in its successor")); // Max recursion depth for collectBitParts used when detecting bswap and // bitreverse idioms. static const unsigned BitPartRecursionMaxDepth = …; //===----------------------------------------------------------------------===// // Local constant propagation. // /// ConstantFoldTerminator - 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 llvm::ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions, const TargetLibraryInfo *TLI, DomTreeUpdater *DTU) { … } //===----------------------------------------------------------------------===// // Local dead code elimination. // /// isInstructionTriviallyDead - Return true if the result produced by the /// instruction is not used, and the instruction has no side effects. /// bool llvm::isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI) { … } bool llvm::wouldInstructionBeTriviallyDeadOnUnusedPaths( Instruction *I, const TargetLibraryInfo *TLI) { … } bool llvm::wouldInstructionBeTriviallyDead(const Instruction *I, const TargetLibraryInfo *TLI) { … } /// RecursivelyDeleteTriviallyDeadInstructions - 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 llvm::RecursivelyDeleteTriviallyDeadInstructions( Value *V, const TargetLibraryInfo *TLI, MemorySSAUpdater *MSSAU, std::function<void(Value *)> AboutToDeleteCallback) { … } bool llvm::RecursivelyDeleteTriviallyDeadInstructionsPermissive( SmallVectorImpl<WeakTrackingVH> &DeadInsts, const TargetLibraryInfo *TLI, MemorySSAUpdater *MSSAU, std::function<void(Value *)> AboutToDeleteCallback) { … } void llvm::RecursivelyDeleteTriviallyDeadInstructions( SmallVectorImpl<WeakTrackingVH> &DeadInsts, const TargetLibraryInfo *TLI, MemorySSAUpdater *MSSAU, std::function<void(Value *)> AboutToDeleteCallback) { … } bool llvm::replaceDbgUsesWithUndef(Instruction *I) { … } /// areAllUsesEqual - Check whether the uses of a value are all the same. /// This is similar to Instruction::hasOneUse() except this will also return /// true when there are no uses or multiple uses that all refer to the same /// value. static bool areAllUsesEqual(Instruction *I) { … } /// RecursivelyDeleteDeadPHINode - 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 llvm::RecursivelyDeleteDeadPHINode(PHINode *PN, const TargetLibraryInfo *TLI, llvm::MemorySSAUpdater *MSSAU) { … } static bool simplifyAndDCEInstruction(Instruction *I, SmallSetVector<Instruction *, 16> &WorkList, const DataLayout &DL, const TargetLibraryInfo *TLI) { … } /// SimplifyInstructionsInBlock - 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 llvm::SimplifyInstructionsInBlock(BasicBlock *BB, const TargetLibraryInfo *TLI) { … } //===----------------------------------------------------------------------===// // Control Flow Graph Restructuring. // void llvm::MergeBasicBlockIntoOnlyPred(BasicBlock *DestBB, DomTreeUpdater *DTU) { … } /// Return true if we can choose one of these values to use in place of the /// other. Note that we will always choose the non-undef value to keep. static bool CanMergeValues(Value *First, Value *Second) { … } /// Return true if we can fold BB, an almost-empty BB ending in an unconditional /// branch to Succ, into Succ. /// /// Assumption: Succ is the single successor for BB. static bool CanPropagatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ, const SmallPtrSetImpl<BasicBlock *> &BBPreds) { … } PredBlockVector; IncomingValueMap; /// Determines the value to use as the phi node input for a block. /// /// Select between \p OldVal any value that we know flows from \p BB /// to a particular phi on the basis of which one (if either) is not /// undef. Update IncomingValues based on the selected value. /// /// \param OldVal The value we are considering selecting. /// \param BB The block that the value flows in from. /// \param IncomingValues A map from block-to-value for other phi inputs /// that we have examined. /// /// \returns the selected value. static Value *selectIncomingValueForBlock(Value *OldVal, BasicBlock *BB, IncomingValueMap &IncomingValues) { … } /// Create a map from block to value for the operands of a /// given phi. /// /// Create a map from block to value for each non-undef value flowing /// into \p PN. /// /// \param PN The phi we are collecting the map for. /// \param IncomingValues [out] The map from block to value for this phi. static void gatherIncomingValuesToPhi(PHINode *PN, IncomingValueMap &IncomingValues) { … } /// Replace the incoming undef values to a phi with the values /// from a block-to-value map. /// /// \param PN The phi we are replacing the undefs in. /// \param IncomingValues A map from block to value. static void replaceUndefValuesInPhi(PHINode *PN, const IncomingValueMap &IncomingValues) { … } // Only when they shares a single common predecessor, return true. // Only handles cases when BB can't be merged while its predecessors can be // redirected. static bool CanRedirectPredsOfEmptyBBToSucc(BasicBlock *BB, BasicBlock *Succ, const SmallPtrSetImpl<BasicBlock *> &BBPreds, const SmallPtrSetImpl<BasicBlock *> &SuccPreds, BasicBlock *&CommonPred) { … } /// Check whether removing \p BB will make the phis in its \p Succ have too /// many incoming entries. This function does not check whether \p BB is /// foldable or not. static bool introduceTooManyPhiEntries(BasicBlock *BB, BasicBlock *Succ) { … } /// Replace a value flowing from a block to a phi with /// potentially multiple instances of that value flowing from the /// block's predecessors to the phi. /// /// \param BB The block with the value flowing into the phi. /// \param BBPreds The predecessors of BB. /// \param PN The phi that we are updating. /// \param CommonPred The common predecessor of BB and PN's BasicBlock static void redirectValuesFromPredecessorsToPhi(BasicBlock *BB, const PredBlockVector &BBPreds, PHINode *PN, BasicBlock *CommonPred) { … } bool llvm::TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB, DomTreeUpdater *DTU) { … } static bool EliminateDuplicatePHINodesNaiveImpl(BasicBlock *BB, SmallPtrSetImpl<PHINode *> &ToRemove) { … } static bool EliminateDuplicatePHINodesSetBasedImpl(BasicBlock *BB, SmallPtrSetImpl<PHINode *> &ToRemove) { … } bool llvm::EliminateDuplicatePHINodes(BasicBlock *BB, SmallPtrSetImpl<PHINode *> &ToRemove) { … } bool llvm::EliminateDuplicatePHINodes(BasicBlock *BB) { … } Align llvm::tryEnforceAlignment(Value *V, Align PrefAlign, const DataLayout &DL) { … } Align llvm::getOrEnforceKnownAlignment(Value *V, MaybeAlign PrefAlign, const DataLayout &DL, const Instruction *CxtI, AssumptionCache *AC, const DominatorTree *DT) { … } ///===---------------------------------------------------------------------===// /// Dbg Intrinsic utilities /// /// See if there is a dbg.value intrinsic for DIVar for the PHI node. static bool PhiHasDebugValue(DILocalVariable *DIVar, DIExpression *DIExpr, PHINode *APN) { … } /// Check if the alloc size of \p ValTy is large enough to cover the variable /// (or fragment of the variable) described by \p DII. /// /// This is primarily intended as a helper for the different /// ConvertDebugDeclareToDebugValue functions. The dbg.declare that is converted /// describes an alloca'd variable, so we need to use the alloc size of the /// value when doing the comparison. E.g. an i1 value will be identified as /// covering an n-bit fragment, if the store size of i1 is at least n bits. static bool valueCoversEntireFragment(Type *ValTy, DbgVariableIntrinsic *DII) { … } // RemoveDIs: duplicate implementation of the above, using DbgVariableRecords, // the replacement for dbg.values. static bool valueCoversEntireFragment(Type *ValTy, DbgVariableRecord *DVR) { … } static void insertDbgValueOrDbgVariableRecord(DIBuilder &Builder, Value *DV, DILocalVariable *DIVar, DIExpression *DIExpr, const DebugLoc &NewLoc, BasicBlock::iterator Instr) { … } static void insertDbgValueOrDbgVariableRecordAfter( DIBuilder &Builder, Value *DV, DILocalVariable *DIVar, DIExpression *DIExpr, const DebugLoc &NewLoc, BasicBlock::iterator Instr) { … } /// Inserts a llvm.dbg.value intrinsic before a store to an alloca'd value /// that has an associated llvm.dbg.declare intrinsic. void llvm::ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII, StoreInst *SI, DIBuilder &Builder) { … } static DIExpression *dropInitialDeref(const DIExpression *DIExpr) { … } void llvm::InsertDebugValueAtStoreLoc(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 intrinsic. void llvm::ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII, LoadInst *LI, DIBuilder &Builder) { … } void llvm::ConvertDebugDeclareToDebugValue(DbgVariableRecord *DVR, StoreInst *SI, DIBuilder &Builder) { … } void llvm::InsertDebugValueAtStoreLoc(DbgVariableRecord *DVR, StoreInst *SI, DIBuilder &Builder) { … } /// Inserts a llvm.dbg.value intrinsic after a phi that has an associated /// llvm.dbg.declare intrinsic. void llvm::ConvertDebugDeclareToDebugValue(DbgVariableIntrinsic *DII, PHINode *APN, DIBuilder &Builder) { … } void llvm::ConvertDebugDeclareToDebugValue(DbgVariableRecord *DVR, LoadInst *LI, DIBuilder &Builder) { … } /// Determine whether this alloca is either a VLA or an array. static bool isArray(AllocaInst *AI) { … } /// Determine whether this alloca is a structure. static bool isStructure(AllocaInst *AI) { … } void llvm::ConvertDebugDeclareToDebugValue(DbgVariableRecord *DVR, PHINode *APN, DIBuilder &Builder) { … } /// LowerDbgDeclare - Lowers llvm.dbg.declare intrinsics into appropriate set /// of llvm.dbg.value intrinsics. bool llvm::LowerDbgDeclare(Function &F) { … } // RemoveDIs: re-implementation of insertDebugValuesForPHIs, but which pulls the // debug-info out of the block's DbgVariableRecords rather than dbg.value // intrinsics. static void insertDbgVariableRecordsForPHIs(BasicBlock *BB, SmallVectorImpl<PHINode *> &InsertedPHIs) { … } /// Propagate dbg.value intrinsics through the newly inserted PHIs. void llvm::insertDebugValuesForPHIs(BasicBlock *BB, SmallVectorImpl<PHINode *> &InsertedPHIs) { … } bool llvm::replaceDbgDeclare(Value *Address, Value *NewAddress, DIBuilder &Builder, uint8_t DIExprFlags, int Offset) { … } static void updateOneDbgValueForAlloca(const DebugLoc &Loc, DILocalVariable *DIVar, DIExpression *DIExpr, Value *NewAddress, DbgValueInst *DVI, DbgVariableRecord *DVR, DIBuilder &Builder, int Offset) { … } void llvm::replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress, DIBuilder &Builder, int Offset) { … } /// Where possible to salvage debug information for \p I do so. /// If not possible mark undef. void llvm::salvageDebugInfo(Instruction &I) { … } template <typename T> static void salvageDbgAssignAddress(T *Assign) { … } void llvm::salvageDebugInfoForDbgValues( Instruction &I, ArrayRef<DbgVariableIntrinsic *> DbgUsers, ArrayRef<DbgVariableRecord *> DPUsers) { … } Value *getSalvageOpsForGEP(GetElementPtrInst *GEP, const DataLayout &DL, uint64_t CurrentLocOps, SmallVectorImpl<uint64_t> &Opcodes, SmallVectorImpl<Value *> &AdditionalValues) { … } uint64_t getDwarfOpForBinOp(Instruction::BinaryOps Opcode) { … } static void handleSSAValueOperands(uint64_t CurrentLocOps, SmallVectorImpl<uint64_t> &Opcodes, SmallVectorImpl<Value *> &AdditionalValues, Instruction *I) { … } Value *getSalvageOpsForBinOp(BinaryOperator *BI, uint64_t CurrentLocOps, SmallVectorImpl<uint64_t> &Opcodes, SmallVectorImpl<Value *> &AdditionalValues) { … } uint64_t getDwarfOpForIcmpPred(CmpInst::Predicate Pred) { … } Value *getSalvageOpsForIcmpOp(ICmpInst *Icmp, uint64_t CurrentLocOps, SmallVectorImpl<uint64_t> &Opcodes, SmallVectorImpl<Value *> &AdditionalValues) { … } Value *llvm::salvageDebugInfoImpl(Instruction &I, uint64_t CurrentLocOps, SmallVectorImpl<uint64_t> &Ops, SmallVectorImpl<Value *> &AdditionalValues) { … } /// A replacement for a dbg.value expression. DbgValReplacement; /// Point debug users of \p From to \p To using exprs given by \p RewriteExpr, /// possibly moving/undefing users to prevent use-before-def. Returns true if /// changes are made. static bool rewriteDebugUsers( Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT, function_ref<DbgValReplacement(DbgVariableIntrinsic &DII)> RewriteExpr, function_ref<DbgValReplacement(DbgVariableRecord &DVR)> RewriteDVRExpr) { … } /// Check if a bitcast between a value of type \p FromTy to type \p ToTy would /// losslessly preserve the bits and semantics of the value. This predicate is /// symmetric, i.e swapping \p FromTy and \p ToTy should give the same result. /// /// Note that Type::canLosslesslyBitCastTo is not suitable here because it /// allows semantically unequivalent bitcasts, such as <2 x i64> -> <4 x i32>, /// and also does not allow lossless pointer <-> integer conversions. static bool isBitCastSemanticsPreserving(const DataLayout &DL, Type *FromTy, Type *ToTy) { … } bool llvm::replaceAllDbgUsesWith(Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT) { … } bool llvm::handleUnreachableTerminator( Instruction *I, SmallVectorImpl<Value *> &PoisonedValues) { … } std::pair<unsigned, unsigned> llvm::removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB) { … } unsigned llvm::changeToUnreachable(Instruction *I, bool PreserveLCSSA, DomTreeUpdater *DTU, MemorySSAUpdater *MSSAU) { … } CallInst *llvm::createCallMatchingInvoke(InvokeInst *II) { … } // changeToCall - Convert the specified invoke into a normal call. CallInst *llvm::changeToCall(InvokeInst *II, DomTreeUpdater *DTU) { … } BasicBlock *llvm::changeToInvokeAndSplitBasicBlock(CallInst *CI, BasicBlock *UnwindEdge, DomTreeUpdater *DTU) { … } static bool markAliveBlocks(Function &F, SmallPtrSetImpl<BasicBlock *> &Reachable, DomTreeUpdater *DTU = nullptr) { … } Instruction *llvm::removeUnwindEdge(BasicBlock *BB, DomTreeUpdater *DTU) { … } /// removeUnreachableBlocks - Remove blocks that are not reachable, even /// if they are in a dead cycle. Return true if a change was made, false /// otherwise. bool llvm::removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU, MemorySSAUpdater *MSSAU) { … } void llvm::combineMetadata(Instruction *K, const Instruction *J, ArrayRef<unsigned> KnownIDs, bool DoesKMove) { … } void llvm::combineMetadataForCSE(Instruction *K, const Instruction *J, bool KDominatesJ) { … } void llvm::copyMetadataForLoad(LoadInst &Dest, const LoadInst &Source) { … } void llvm::patchReplacementInstruction(Instruction *I, Value *Repl) { … } template <typename RootType, typename ShouldReplaceFn> static unsigned replaceDominatedUsesWith(Value *From, Value *To, const RootType &Root, const ShouldReplaceFn &ShouldReplace) { … } unsigned llvm::replaceNonLocalUsesWith(Instruction *From, Value *To) { … } unsigned llvm::replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Root) { … } unsigned llvm::replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT, const BasicBlock *BB) { … } unsigned llvm::replaceDominatedUsesWithIf( Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Root, function_ref<bool(const Use &U, const Value *To)> ShouldReplace) { … } unsigned llvm::replaceDominatedUsesWithIf( Value *From, Value *To, DominatorTree &DT, const BasicBlock *BB, function_ref<bool(const Use &U, const Value *To)> ShouldReplace) { … } bool llvm::callsGCLeafFunction(const CallBase *Call, const TargetLibraryInfo &TLI) { … } void llvm::copyNonnullMetadata(const LoadInst &OldLI, MDNode *N, LoadInst &NewLI) { … } void llvm::copyRangeMetadata(const DataLayout &DL, const LoadInst &OldLI, MDNode *N, LoadInst &NewLI) { … } void llvm::dropDebugUsers(Instruction &I) { … } void llvm::hoistAllInstructionsInto(BasicBlock *DomBlock, Instruction *InsertPt, BasicBlock *BB) { … } DIExpression *llvm::getExpressionForConstant(DIBuilder &DIB, const Constant &C, Type &Ty) { … } void llvm::remapDebugVariable(ValueToValueMapTy &Mapping, Instruction *Inst) { … } namespace { /// A potential constituent of a bitreverse or bswap expression. See /// collectBitParts for a fuller explanation. struct BitPart { … }; } // end anonymous namespace /// Analyze the specified subexpression and see if it is capable of providing /// pieces of a bswap or bitreverse. The subexpression provides a potential /// piece of a bswap or bitreverse if it can be proved that each non-zero bit in /// the output of the expression came from a corresponding bit in some other /// value. This function is recursive, and the end result is a mapping of /// bitnumber to bitnumber. It is the caller's responsibility to validate that /// the bitnumber to bitnumber mapping is correct for a bswap or bitreverse. /// /// For example, if the current subexpression if "(shl i32 %X, 24)" then we know /// that the expression deposits the low byte of %X into the high byte of the /// result and that all other bits are zero. This expression is accepted and a /// BitPart is returned with Provider set to %X and Provenance[24-31] set to /// [0-7]. /// /// For vector types, all analysis is performed at the per-element level. No /// cross-element analysis is supported (shuffle/insertion/reduction), and all /// constant masks must be splatted across all elements. /// /// To avoid revisiting values, the BitPart results are memoized into the /// provided map. To avoid unnecessary copying of BitParts, BitParts are /// constructed in-place in the \c BPS map. Because of this \c BPS needs to /// store BitParts objects, not pointers. As we need the concept of a nullptr /// BitParts (Value has been analyzed and the analysis failed), we an Optional /// type instead to provide the same functionality. /// /// Because we pass around references into \c BPS, we must use a container that /// does not invalidate internal references (std::map instead of DenseMap). static const std::optional<BitPart> & collectBitParts(Value *V, bool MatchBSwaps, bool MatchBitReversals, std::map<Value *, std::optional<BitPart>> &BPS, int Depth, bool &FoundRoot) { … } static bool bitTransformIsCorrectForBSwap(unsigned From, unsigned To, unsigned BitWidth) { … } static bool bitTransformIsCorrectForBitReverse(unsigned From, unsigned To, unsigned BitWidth) { … } bool llvm::recognizeBSwapOrBitReverseIdiom( Instruction *I, bool MatchBSwaps, bool MatchBitReversals, SmallVectorImpl<Instruction *> &InsertedInsts) { … } // CodeGen has special handling for some string functions that may replace // them with target-specific intrinsics. Since that'd skip our interceptors // in ASan/MSan/TSan/DFSan, and thus make us miss some memory accesses, // we mark affected calls as NoBuiltin, which will disable optimization // in CodeGen. void llvm::maybeMarkSanitizerLibraryCallNoBuiltin( CallInst *CI, const TargetLibraryInfo *TLI) { … } bool llvm::canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx) { … } Value *llvm::invertCondition(Value *Condition) { … } bool llvm::inferAttributesFromOthers(Function &F) { … }
Codebase Browser
llvm