LLVM 19.0.0git
Macros | Typedefs | Functions | Variables
Local.cpp File Reference
#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>

Go to the source code of this file.

Macros

#define DEBUG_TYPE   "local"
 

Typedefs

using PredBlockVector = SmallVector< BasicBlock *, 16 >
 
using IncomingValueMap = DenseMap< BasicBlock *, Value * >
 
using DbgValReplacement = std::optional< DIExpression * >
 A replacement for a dbg.value expression.
 

Functions

 STATISTIC (NumRemoved, "Number of unreachable basic blocks removed")
 
 STATISTIC (NumPHICSEs, "Number of PHI's that got CSE'd")
 
static bool areAllUsesEqual (Instruction *I)
 areAllUsesEqual - Check whether the uses of a value are all the same.
 
static bool simplifyAndDCEInstruction (Instruction *I, SmallSetVector< Instruction *, 16 > &WorkList, const DataLayout &DL, const TargetLibraryInfo *TLI)
 
static bool CanMergeValues (Value *First, Value *Second)
 Return true if we can choose one of these values to use in place of the other.
 
static bool CanPropagatePredecessorsForPHIs (BasicBlock *BB, BasicBlock *Succ, const SmallPtrSetImpl< BasicBlock * > &BBPreds)
 Return true if we can fold BB, an almost-empty BB ending in an unconditional branch to Succ, into Succ.
 
static ValueselectIncomingValueForBlock (Value *OldVal, BasicBlock *BB, IncomingValueMap &IncomingValues)
 Determines the value to use as the phi node input for a block.
 
static void gatherIncomingValuesToPhi (PHINode *PN, IncomingValueMap &IncomingValues)
 Create a map from block to value for the operands of a given phi.
 
static void replaceUndefValuesInPhi (PHINode *PN, const IncomingValueMap &IncomingValues)
 Replace the incoming undef values to a phi with the values from a block-to-value map.
 
static bool CanRedirectPredsOfEmptyBBToSucc (BasicBlock *BB, BasicBlock *Succ, const SmallPtrSetImpl< BasicBlock * > &BBPreds, const SmallPtrSetImpl< BasicBlock * > &SuccPreds, BasicBlock *&CommonPred)
 
static void redirectValuesFromPredecessorsToPhi (BasicBlock *BB, const PredBlockVector &BBPreds, PHINode *PN, BasicBlock *CommonPred)
 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.
 
static bool EliminateDuplicatePHINodesNaiveImpl (BasicBlock *BB, SmallPtrSetImpl< PHINode * > &ToRemove)
 
static bool EliminateDuplicatePHINodesSetBasedImpl (BasicBlock *BB, SmallPtrSetImpl< PHINode * > &ToRemove)
 
static bool PhiHasDebugValue (DILocalVariable *DIVar, DIExpression *DIExpr, PHINode *APN)
 ===------------------------------------------------------------------—===// Dbg Intrinsic utilities
 
static bool valueCoversEntireFragment (Type *ValTy, DbgVariableIntrinsic *DII)
 Check if the alloc size of ValTy is large enough to cover the variable (or fragment of the variable) described by DII.
 
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)
 
static bool isArray (AllocaInst *AI)
 Determine whether this alloca is either a VLA or an array.
 
static bool isStructure (AllocaInst *AI)
 Determine whether this alloca is a structure.
 
static void insertDbgVariableRecordsForPHIs (BasicBlock *BB, SmallVectorImpl< PHINode * > &InsertedPHIs)
 
static void updateOneDbgValueForAlloca (const DebugLoc &Loc, DILocalVariable *DIVar, DIExpression *DIExpr, Value *NewAddress, DbgValueInst *DVI, DbgVariableRecord *DVR, DIBuilder &Builder, int Offset)
 
template<typename T >
static void salvageDbgAssignAddress (T *Assign)
 
ValuegetSalvageOpsForGEP (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)
 
ValuegetSalvageOpsForBinOp (BinaryOperator *BI, uint64_t CurrentLocOps, SmallVectorImpl< uint64_t > &Opcodes, SmallVectorImpl< Value * > &AdditionalValues)
 
uint64_t getDwarfOpForIcmpPred (CmpInst::Predicate Pred)
 
ValuegetSalvageOpsForIcmpOp (ICmpInst *Icmp, uint64_t CurrentLocOps, SmallVectorImpl< uint64_t > &Opcodes, SmallVectorImpl< Value * > &AdditionalValues)
 
static bool rewriteDebugUsers (Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT, function_ref< DbgValReplacement(DbgVariableIntrinsic &DII)> RewriteExpr, function_ref< DbgValReplacement(DbgVariableRecord &DVR)> RewriteDVRExpr)
 Point debug users of From to To using exprs given by RewriteExpr, possibly moving/undefing users to prevent use-before-def.
 
static bool isBitCastSemanticsPreserving (const DataLayout &DL, Type *FromTy, Type *ToTy)
 Check if a bitcast between a value of type FromTy to type ToTy would losslessly preserve the bits and semantics of the value.
 
static bool markAliveBlocks (Function &F, SmallPtrSetImpl< BasicBlock * > &Reachable, DomTreeUpdater *DTU=nullptr)
 
template<typename RootType , typename ShouldReplaceFn >
static unsigned replaceDominatedUsesWith (Value *From, Value *To, const RootType &Root, const ShouldReplaceFn &ShouldReplace)
 
static const std::optional< BitPart > & collectBitParts (Value *V, bool MatchBSwaps, bool MatchBitReversals, std::map< Value *, std::optional< BitPart > > &BPS, int Depth, bool &FoundRoot)
 Analyze the specified subexpression and see if it is capable of providing pieces of a bswap or bitreverse.
 
static bool bitTransformIsCorrectForBSwap (unsigned From, unsigned To, unsigned BitWidth)
 
static bool bitTransformIsCorrectForBitReverse (unsigned From, unsigned To, unsigned BitWidth)
 

Variables

cl::opt< boolUseNewDbgInfoFormat
 
static cl::opt< boolPHICSEDebugHash ("phicse-debug-hash", cl::init(false), 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< unsignedPHICSENumPHISmallSize ("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 const unsigned BitPartRecursionMaxDepth = 48
 

Macro Definition Documentation

◆ DEBUG_TYPE

#define DEBUG_TYPE   "local"

Definition at line 93 of file Local.cpp.

Typedef Documentation

◆ DbgValReplacement

using DbgValReplacement = std::optional<DIExpression *>

A replacement for a dbg.value expression.

Definition at line 2596 of file Local.cpp.

◆ IncomingValueMap

Definition at line 922 of file Local.cpp.

◆ PredBlockVector

Definition at line 921 of file Local.cpp.

Function Documentation

◆ areAllUsesEqual()

static bool areAllUsesEqual ( Instruction I)
static

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.

Definition at line 632 of file Local.cpp.

References I.

Referenced by llvm::RecursivelyDeleteDeadPHINode().

◆ bitTransformIsCorrectForBitReverse()

static bool bitTransformIsCorrectForBitReverse ( unsigned  From,
unsigned  To,
unsigned  BitWidth 
)
static

Definition at line 3998 of file Local.cpp.

References llvm::BitWidth, and From.

Referenced by llvm::recognizeBSwapOrBitReverseIdiom().

◆ bitTransformIsCorrectForBSwap()

static bool bitTransformIsCorrectForBSwap ( unsigned  From,
unsigned  To,
unsigned  BitWidth 
)
static

Definition at line 3987 of file Local.cpp.

References llvm::BitWidth, and From.

Referenced by llvm::recognizeBSwapOrBitReverseIdiom().

◆ CanMergeValues()

static bool CanMergeValues ( Value First,
Value Second 
)
static

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.

Definition at line 856 of file Local.cpp.

References llvm::First.

Referenced by CanPropagatePredecessorsForPHIs().

◆ CanPropagatePredecessorsForPHIs()

static bool CanPropagatePredecessorsForPHIs ( BasicBlock BB,
BasicBlock Succ,
const SmallPtrSetImpl< BasicBlock * > &  BBPreds 
)
static

◆ CanRedirectPredsOfEmptyBBToSucc()

static bool CanRedirectPredsOfEmptyBBToSucc ( BasicBlock BB,
BasicBlock Succ,
const SmallPtrSetImpl< BasicBlock * > &  BBPreds,
const SmallPtrSetImpl< BasicBlock * > &  SuccPreds,
BasicBlock *&  CommonPred 
)
static

◆ collectBitParts()

static const std::optional< BitPart > & collectBitParts ( Value V,
bool  MatchBSwaps,
bool  MatchBitReversals,
std::map< Value *, std::optional< BitPart > > &  BPS,
int  Depth,
bool FoundRoot 
)
static

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 BPS map. Because of this 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 BPS, we must use a container that does not invalidate internal references (std::map instead of DenseMap).

Definition at line 3767 of file Local.cpp.

References A, B, BitPartRecursionMaxDepth, llvm::BitWidth, llvm::CallingConv::C, collectBitParts(), llvm::dbgs(), llvm::Depth, for(), getIntrinsicID(), llvm::APInt::getZExtValue(), I, LHS, LLVM_DEBUG, llvm::PatternMatch::m_And(), llvm::PatternMatch::m_APInt(), llvm::PatternMatch::m_BitReverse(), llvm::PatternMatch::m_BSwap(), llvm::PatternMatch::m_FShl(), llvm::PatternMatch::m_FShr(), llvm::PatternMatch::m_LogicalShift(), llvm::PatternMatch::m_Or(), llvm::PatternMatch::m_Trunc(), llvm::PatternMatch::m_Value(), llvm::PatternMatch::m_ZExt(), llvm::PatternMatch::match(), P, llvm::APInt::popcount(), RHS, llvm::APInt::uge(), X, and Y.

Referenced by collectBitParts(), and llvm::recognizeBSwapOrBitReverseIdiom().

◆ EliminateDuplicatePHINodesNaiveImpl()

static bool EliminateDuplicatePHINodesNaiveImpl ( BasicBlock BB,
SmallPtrSetImpl< PHINode * > &  ToRemove 
)
static

◆ EliminateDuplicatePHINodesSetBasedImpl()

static bool EliminateDuplicatePHINodesSetBasedImpl ( BasicBlock BB,
SmallPtrSetImpl< PHINode * > &  ToRemove 
)
static

◆ gatherIncomingValuesToPhi()

static void gatherIncomingValuesToPhi ( PHINode PN,
IncomingValueMap IncomingValues 
)
static

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 PN.

Parameters
PNThe phi we are collecting the map for.
IncomingValues[out] The map from block to value for this phi.

Definition at line 961 of file Local.cpp.

References llvm::PHINode::getIncomingBlock(), llvm::PHINode::getIncomingValue(), llvm::PHINode::getNumIncomingValues(), and llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >::insert().

Referenced by redirectValuesFromPredecessorsToPhi().

◆ getDwarfOpForBinOp()

uint64_t getDwarfOpForBinOp ( Instruction::BinaryOps  Opcode)

Definition at line 2417 of file Local.cpp.

Referenced by getSalvageOpsForBinOp().

◆ getDwarfOpForIcmpPred()

uint64_t getDwarfOpForIcmpPred ( CmpInst::Predicate  Pred)

◆ getSalvageOpsForBinOp()

Value * getSalvageOpsForBinOp ( BinaryOperator BI,
uint64_t  CurrentLocOps,
SmallVectorImpl< uint64_t > &  Opcodes,
SmallVectorImpl< Value * > &  AdditionalValues 
)

◆ getSalvageOpsForGEP()

Value * getSalvageOpsForGEP ( GetElementPtrInst GEP,
const DataLayout DL,
uint64_t  CurrentLocOps,
SmallVectorImpl< uint64_t > &  Opcodes,
SmallVectorImpl< Value * > &  AdditionalValues 
)

◆ getSalvageOpsForIcmpOp()

Value * getSalvageOpsForIcmpOp ( ICmpInst Icmp,
uint64_t  CurrentLocOps,
SmallVectorImpl< uint64_t > &  Opcodes,
SmallVectorImpl< Value * > &  AdditionalValues 
)

◆ handleSSAValueOperands()

static void handleSSAValueOperands ( uint64_t  CurrentLocOps,
SmallVectorImpl< uint64_t > &  Opcodes,
SmallVectorImpl< Value * > &  AdditionalValues,
Instruction I 
)
static

◆ insertDbgValueOrDbgVariableRecord()

static void insertDbgValueOrDbgVariableRecord ( DIBuilder Builder,
Value DV,
DILocalVariable DIVar,
DIExpression DIExpr,
const DebugLoc NewLoc,
BasicBlock::iterator  Instr 
)
static

◆ insertDbgValueOrDbgVariableRecordAfter()

static void insertDbgValueOrDbgVariableRecordAfter ( DIBuilder Builder,
Value DV,
DILocalVariable DIVar,
DIExpression DIExpr,
const DebugLoc NewLoc,
BasicBlock::iterator  Instr 
)
static

◆ insertDbgVariableRecordsForPHIs()

static void insertDbgVariableRecordsForPHIs ( BasicBlock BB,
SmallVectorImpl< PHINode * > &  InsertedPHIs 
)
static

◆ isArray()

static bool isArray ( AllocaInst AI)
static

Determine whether this alloca is either a VLA or an array.

Definition at line 1875 of file Local.cpp.

References llvm::AllocaInst::getAllocatedType(), llvm::AllocaInst::isArrayAllocation(), and llvm::Type::isArrayTy().

Referenced by llvm::LowerDbgDeclare().

◆ isBitCastSemanticsPreserving()

static bool isBitCastSemanticsPreserving ( const DataLayout DL,
Type FromTy,
Type ToTy 
)
static

Check if a bitcast between a value of type FromTy to type ToTy would losslessly preserve the bits and semantics of the value.

This predicate is symmetric, i.e swapping FromTy and 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.

Definition at line 2699 of file Local.cpp.

References DL, and llvm::Type::isIntOrPtrTy().

Referenced by llvm::replaceAllDbgUsesWith().

◆ isStructure()

static bool isStructure ( AllocaInst AI)
static

Determine whether this alloca is a structure.

Definition at line 1881 of file Local.cpp.

References llvm::AllocaInst::getAllocatedType(), and llvm::Type::isStructTy().

Referenced by llvm::LowerDbgDeclare().

◆ markAliveBlocks()

static bool markAliveBlocks ( Function F,
SmallPtrSetImpl< BasicBlock * > &  Reachable,
DomTreeUpdater DTU = nullptr 
)
static

◆ PhiHasDebugValue()

static bool PhiHasDebugValue ( DILocalVariable DIVar,
DIExpression DIExpr,
PHINode APN 
)
static

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

See if there is a dbg.value intrinsic for DIVar for the PHI node.

Definition at line 1573 of file Local.cpp.

References assert(), llvm::findDbgValues(), and llvm::is_contained().

Referenced by llvm::ConvertDebugDeclareToDebugValue().

◆ redirectValuesFromPredecessorsToPhi()

static void redirectValuesFromPredecessorsToPhi ( BasicBlock BB,
const PredBlockVector BBPreds,
PHINode PN,
BasicBlock CommonPred 
)
static

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.

Parameters
BBThe block with the value flowing into the phi.
BBPredsThe predecessors of BB.
PNThe phi that we are updating.
CommonPredThe common predecessor of BB and PN's BasicBlock

Definition at line 1051 of file Local.cpp.

References llvm::PHINode::addIncoming(), assert(), gatherIncomingValuesToPhi(), llvm::PHINode::getIncomingBlock(), llvm::PHINode::getIncomingValue(), llvm::PHINode::getIncomingValueForBlock(), llvm::PHINode::getNumIncomingValues(), getParent(), llvm::PHINode::removeIncomingValue(), replaceUndefValuesInPhi(), selectIncomingValueForBlock(), and llvm::SmallVectorBase< Size_T >::size().

Referenced by llvm::TryToSimplifyUncondBranchFromEmptyBlock().

◆ replaceDominatedUsesWith()

template<typename RootType , typename ShouldReplaceFn >
static unsigned replaceDominatedUsesWith ( Value From,
Value To,
const RootType &  Root,
const ShouldReplaceFn &  ShouldReplace 
)
static

◆ replaceUndefValuesInPhi()

static void replaceUndefValuesInPhi ( PHINode PN,
const IncomingValueMap IncomingValues 
)
static

◆ rewriteDebugUsers()

static bool rewriteDebugUsers ( Instruction From,
Value To,
Instruction DomPoint,
DominatorTree DT,
function_ref< DbgValReplacement(DbgVariableIntrinsic &DII)>  RewriteExpr,
function_ref< DbgValReplacement(DbgVariableRecord &DVR)>  RewriteDVRExpr 
)
static

◆ salvageDbgAssignAddress()

template<typename T >
static void salvageDbgAssignAddress ( T Assign)
static

◆ selectIncomingValueForBlock()

static Value * selectIncomingValueForBlock ( Value OldVal,
BasicBlock BB,
IncomingValueMap IncomingValues 
)
static

Determines the value to use as the phi node input for a block.

Select between OldVal any value that we know flows from BB to a particular phi on the basis of which one (if either) is not undef. Update IncomingValues based on the selected value.

Parameters
OldValThe value we are considering selecting.
BBThe block that the value flows in from.
IncomingValuesA map from block-to-value for other phi inputs that we have examined.
Returns
the selected value.

Definition at line 936 of file Local.cpp.

References assert(), llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >::count(), llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >::end(), llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >::find(), and llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >::insert().

Referenced by redirectValuesFromPredecessorsToPhi().

◆ simplifyAndDCEInstruction()

static bool simplifyAndDCEInstruction ( Instruction I,
SmallSetVector< Instruction *, 16 > &  WorkList,
const DataLayout DL,
const TargetLibraryInfo TLI 
)
static

◆ STATISTIC() [1/2]

STATISTIC ( NumPHICSEs  ,
"Number of PHI's that got CSE'd"   
)

◆ STATISTIC() [2/2]

STATISTIC ( NumRemoved  ,
"Number of unreachable basic blocks removed"   
)

◆ updateOneDbgValueForAlloca()

static void updateOneDbgValueForAlloca ( const DebugLoc Loc,
DILocalVariable DIVar,
DIExpression DIExpr,
Value NewAddress,
DbgValueInst DVI,
DbgVariableRecord DVR,
DIBuilder Builder,
int  Offset 
)
static

◆ valueCoversEntireFragment() [1/2]

static bool valueCoversEntireFragment ( Type ValTy,
DbgVariableIntrinsic DII 
)
static

Check if the alloc size of ValTy is large enough to cover the variable (or fragment of the variable) described by 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.

Definition at line 1603 of file Local.cpp.

References assert(), DL, llvm::DIExpression::getActiveBits(), llvm::Module::getDataLayout(), llvm::DbgVariableIntrinsic::getExpression(), llvm::TypeSize::getFixed(), llvm::Instruction::getModule(), llvm::DbgVariableIntrinsic::getNumVariableLocationOps(), llvm::DbgVariableIntrinsic::getVariable(), llvm::DbgVariableIntrinsic::getVariableLocationOp(), and llvm::DbgVariableIntrinsic::isAddressOfVariable().

Referenced by llvm::ConvertDebugDeclareToDebugValue().

◆ valueCoversEntireFragment() [2/2]

static bool valueCoversEntireFragment ( Type ValTy,
DbgVariableRecord DVR 
)
static

Variable Documentation

◆ BitPartRecursionMaxDepth

const unsigned BitPartRecursionMaxDepth = 48
static

Definition at line 117 of file Local.cpp.

Referenced by collectBitParts().

◆ PHICSEDebugHash

cl::opt< bool > PHICSEDebugHash("phicse-debug-hash", cl::init(false), cl::Hidden, cl::desc("Perform extra assertion checking to verify that PHINodes's hash " "function is well-behaved w.r.t. its isEqual predicate")) ( "phicse-debug-hash"  ,
cl::init(false)  ,
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

◆ PHICSENumPHISmallSize

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.")) ( "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

◆ UseNewDbgInfoFormat

cl::opt<bool> UseNewDbgInfoFormat
extern