LLVM
15.0.0git
|
#include "InstCombineInternal.h"
#include "llvm-c/Initialization.h"
#include "llvm-c/Transforms/InstCombine.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/None.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/AssumptionCache.h"
#include "llvm/Analysis/BasicAliasAnalysis.h"
#include "llvm/Analysis/BlockFrequencyInfo.h"
#include "llvm/Analysis/CFG.h"
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/Analysis/EHPersonalities.h"
#include "llvm/Analysis/GlobalsModRef.h"
#include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/Analysis/LazyBlockFrequencyInfo.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/MemoryBuiltins.h"
#include "llvm/Analysis/OptimizationRemarkEmitter.h"
#include "llvm/Analysis/ProfileSummaryInfo.h"
#include "llvm/Analysis/TargetFolder.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/Analysis/Utils/Local.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/Analysis/VectorUtils.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/CFG.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DIBuilder.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DebugInfo.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/GetElementPtrTypeIterator.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/LegacyPassManager.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/PatternMatch.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/InitializePasses.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/DebugCounter.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/KnownBits.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/InstCombine/InstCombine.h"
#include "llvm/Transforms/Utils/Local.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include "llvm/Transforms/Utils/InstructionWorklist.h"
Go to the source code of this file.
Classes | |
class | AliasScopeTracker |
Macros | |
#define | DEBUG_TYPE "instcombine" |
Functions | |
STATISTIC (NumWorklistIterations, "Number of instruction combining iterations performed") | |
STATISTIC (NumCombined, "Number of insts combined") | |
STATISTIC (NumConstProp, "Number of constant folds") | |
STATISTIC (NumDeadInst, "Number of dead inst eliminated") | |
STATISTIC (NumSunkInst, "Number of instructions sunk") | |
STATISTIC (NumExpand, "Number of expansions") | |
STATISTIC (NumFactor, "Number of factorizations") | |
STATISTIC (NumReassoc, "Number of reassociations") | |
DEBUG_COUNTER (VisitCounter, "instcombine-visit", "Controls which instructions are visited") | |
static bool | maintainNoSignedWrap (BinaryOperator &I, Value *B, Value *C) |
static bool | hasNoUnsignedWrap (BinaryOperator &I) |
static bool | hasNoSignedWrap (BinaryOperator &I) |
static void | ClearSubclassDataAfterReassociation (BinaryOperator &I) |
Conservatively clears subclassOptionalData after a reassociation or commutation. More... | |
static bool | simplifyAssocCastAssoc (BinaryOperator *BinOp1, InstCombinerImpl &IC) |
Combine constant operands of associative operations either before or after a cast to eliminate one of the associative operations: (op (cast (op X, C2)), C1) --> (cast (op X, op (C1, C2))) (op (cast (op X, C2)), C1) --> (op (cast X), op (C1, C2)) More... | |
static bool | leftDistributesOverRight (Instruction::BinaryOps LOp, Instruction::BinaryOps ROp) |
Return whether "X LOp (Y ROp Z)" is always equal to "(X LOp Y) ROp (X LOp Z)". More... | |
static bool | rightDistributesOverLeft (Instruction::BinaryOps LOp, Instruction::BinaryOps ROp) |
Return whether "(X LOp Y) ROp Z" is always equal to "(X ROp Z) LOp (Y ROp Z)". More... | |
static Value * | getIdentityValue (Instruction::BinaryOps Opcode, Value *V) |
This function returns identity value for given opcode, which can be used to factor patterns like (X * 2) + X ==> (X * 2) + (X * 1) ==> X * (2 + 1). More... | |
static Instruction::BinaryOps | getBinOpsForFactorization (Instruction::BinaryOps TopOpcode, BinaryOperator *Op, Value *&LHS, Value *&RHS) |
This function predicates factorization using distributive laws. More... | |
static Value * | foldOperationIntoSelectOperand (Instruction &I, Value *SO, InstCombiner::BuilderTy &Builder) |
static Value * | foldOperationIntoPhiValue (BinaryOperator *I, Value *InV, InstCombiner::BuilderTy &Builder) |
static Type * | findElementAtOffset (PointerType *PtrTy, int64_t IntOffset, SmallVectorImpl< Value * > &NewIndices, const DataLayout &DL) |
Given a pointer type and a constant offset, determine whether or not there is a sequence of GEP indices into the pointed type that will land us at the specified offset. More... | |
static bool | shouldMergeGEPs (GEPOperator &GEP, GEPOperator &Src) |
static bool | isMergedGEPInBounds (GEPOperator &GEP1, GEPOperator &GEP2) |
static Instruction * | foldSelectGEP (GetElementPtrInst &GEP, InstCombiner::BuilderTy &Builder) |
Thread a GEP operation with constant indices through the constant true/false arms of a select. More... | |
static bool | isNeverEqualToUnescapedAlloc (Value *V, const TargetLibraryInfo &TLI, Instruction *AI) |
static bool | isRemovableWrite (CallBase &CB, Value *UsedV, const TargetLibraryInfo &TLI) |
Given a call CB which uses an address UsedV, return true if we can prove the call's only possible effect is storing to V. More... | |
static bool | isAllocSiteRemovable (Instruction *AI, SmallVectorImpl< WeakTrackingVH > &Users, const TargetLibraryInfo &TLI) |
static Instruction * | tryToMoveFreeBeforeNullTest (CallInst &FI, const DataLayout &DL) |
Move the call to free before a NULL test. More... | |
static bool | isMustTailCall (Value *V) |
static bool | isCatchAll (EHPersonality Personality, Constant *TypeInfo) |
Return 'true' if the given typeinfo will match anything. More... | |
static bool | shorter_filter (const Value *LHS, const Value *RHS) |
static bool | SoleWriteToDeadLocal (Instruction *I, TargetLibraryInfo &TLI) |
Check for case where the call writes to an otherwise dead alloca. More... | |
static bool | TryToSinkInstruction (Instruction *I, BasicBlock *DestBlock, TargetLibraryInfo &TLI) |
Try to move the specified instruction from its current block into the beginning of DestBlock, which can only happen if it's safe to move the instruction past all of the instructions between it and the end of its block. More... | |
static bool | prepareICWorklistFromFunction (Function &F, const DataLayout &DL, const TargetLibraryInfo *TLI, InstructionWorklist &ICWorklist) |
Populate the IC worklist from a function, by walking it in depth-first order and adding all reachable code to the worklist. More... | |
static bool | combineInstructionsOverFunction (Function &F, InstructionWorklist &Worklist, AliasAnalysis *AA, AssumptionCache &AC, TargetLibraryInfo &TLI, TargetTransformInfo &TTI, DominatorTree &DT, OptimizationRemarkEmitter &ORE, BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI, unsigned MaxIterations, LoopInfo *LI) |
INITIALIZE_PASS_BEGIN (InstructionCombiningPass, "instcombine", "Combine redundant instructions", false, false) INITIALIZE_PASS_END(InstructionCombiningPass | |
void | LLVMInitializeInstCombine (LLVMPassRegistryRef R) |
void | LLVMAddInstructionCombiningPass (LLVMPassManagerRef PM) |
See llvm::createInstructionCombiningPass function. More... | |
Variables | |
static constexpr unsigned | InstCombineDefaultMaxIterations = 1000 |
static constexpr unsigned | InstCombineDefaultInfiniteLoopThreshold = 100 |
static cl::opt< bool > | EnableCodeSinking ("instcombine-code-sinking", cl::desc("Enable code sinking"), cl::init(true)) |
static cl::opt< unsigned > | MaxSinkNumUsers ("instcombine-max-sink-users", cl::init(32), cl::desc("Maximum number of undroppable users for instruction sinking")) |
static cl::opt< unsigned > | LimitMaxIterations ("instcombine-max-iterations", cl::desc("Limit the maximum number of instruction combining iterations"), cl::init(InstCombineDefaultMaxIterations)) |
static cl::opt< unsigned > | InfiniteLoopDetectionThreshold ("instcombine-infinite-loop-threshold", cl::desc("Number of instruction combining iterations considered an " "infinite loop"), cl::init(InstCombineDefaultInfiniteLoopThreshold), cl::Hidden) |
static cl::opt< unsigned > | MaxArraySize ("instcombine-maxarray-size", cl::init(1024), cl::desc("Maximum array size considered when doing a combine")) |
static cl::opt< unsigned > | ShouldLowerDbgDeclare ("instcombine-lower-dbg-declare", cl::Hidden, cl::init(true)) |
instcombine | |
Combine redundant | instructions |
Combine redundant | false |
#define DEBUG_TYPE "instcombine" |
Definition at line 110 of file InstructionCombining.cpp.
|
static |
Conservatively clears subclassOptionalData after a reassociation or commutation.
We preserve fast-math flags when applicable as they can be preserved.
Definition at line 311 of file InstructionCombining.cpp.
References I.
Referenced by llvm::InstCombinerImpl::SimplifyAssociativeOrCommutative().
|
static |
Builder - This is an IRBuilder that automatically inserts new instructions into the worklist when they are created.
Definition at line 4495 of file InstructionCombining.cpp.
References llvm::InstructionWorklist::add(), llvm::AMDGPUISD::BFI, Builder, llvm::dbgs(), DL, F, I, InfiniteLoopDetectionThreshold, LimitMaxIterations, LLVM_DEBUG, llvm::LowerDbgDeclare(), MaxArraySize, llvm::InstCombiner::MaxArraySizeForCombine, llvm::min(), prepareICWorklistFromFunction(), llvm::AssumptionCache::registerAssumption(), llvm::report_fatal_error(), llvm::InstCombinerImpl::run(), and ShouldLowerDbgDeclare.
Referenced by llvm::InstCombinePass::run(), and llvm::InstructionCombiningPass::runOnFunction().
DEBUG_COUNTER | ( | VisitCounter | , |
"instcombine-visit" | , | ||
"Controls which instructions are visited" | |||
) |
|
static |
Given a pointer type and a constant offset, determine whether or not there is a sequence of GEP indices into the pointed type that will land us at the specified offset.
If so, fill them into NewIndices and return the resultant element type, otherwise return null.
Definition at line 1376 of file InstructionCombining.cpp.
References DL, llvm::ConstantInt::get(), llvm::Type::getContext(), llvm::Type::getNonOpaquePointerElementType(), and llvm::Type::isSized().
Referenced by llvm::InstCombinerImpl::visitGEPOfBitcast().
|
static |
Definition at line 1114 of file InstructionCombining.cpp.
References Builder, llvm::ConstantExpr::get(), I, and std::swap().
Referenced by llvm::InstCombinerImpl::foldOpIntoPhi().
|
static |
Definition at line 996 of file InstructionCombining.cpp.
References llvm::CallBase::arg_size(), assert(), Builder, llvm::canConstantFoldCallTo(), llvm::ConstantExpr::get(), llvm::CallBase::getArgOperand(), llvm::CallBase::getCalledOperand(), llvm::IntrinsicInst::getIntrinsicID(), llvm::Value::getName(), getOpcode(), I, and std::swap().
Referenced by llvm::InstCombinerImpl::FoldOpIntoSelect().
|
static |
Thread a GEP operation with constant indices through the constant true/false arms of a select.
Definition at line 1928 of file InstructionCombining.cpp.
References Builder, Cond, llvm::SelectInst::Create(), GEP, llvm::PatternMatch::m_Constant(), llvm::PatternMatch::m_Instruction(), llvm::PatternMatch::m_Select(), llvm::PatternMatch::m_Value(), and llvm::PatternMatch::match().
Referenced by llvm::InstCombinerImpl::visitGetElementPtrInst().
|
static |
This function predicates factorization using distributive laws.
By default, it just returns the 'Op' inputs. But for special-cases like 'add(shl(X, 5), ...)', this function will have TopOpcode == Instruction::Add and Op = shl(X, 5). The 'shl' is treated as the more general 'mul X, 32' to allow more factorization opportunities.
Definition at line 615 of file InstructionCombining.cpp.
References llvm::MCID::Add, assert(), llvm::ConstantInt::get(), llvm::ConstantExpr::getShl(), LHS, llvm::PatternMatch::m_Constant(), llvm::PatternMatch::m_Shl(), llvm::PatternMatch::m_Value(), llvm::PatternMatch::match(), Mul, and RHS.
Referenced by llvm::InstCombinerImpl::SimplifyUsingDistributiveLaws().
|
static |
This function returns identity value for given opcode, which can be used to factor patterns like (X * 2) + X ==> (X * 2) + (X * 1) ==> X * (2 + 1).
Definition at line 602 of file InstructionCombining.cpp.
References llvm::ConstantExpr::getBinOpIdentity(), and llvm::Value::getType().
Referenced by llvm::InstCombinerImpl::SimplifyUsingDistributiveLaws().
|
static |
Definition at line 303 of file InstructionCombining.cpp.
References I.
Referenced by llvm::SDNode::print_details(), and llvm::InstCombinerImpl::SimplifyAssociativeOrCommutative().
|
static |
Definition at line 298 of file InstructionCombining.cpp.
References I.
Referenced by llvm::SDNode::print_details(), llvm::InstCombinerImpl::SimplifyAssociativeOrCommutative(), and llvm::InstCombinerImpl::visitLShr().
INITIALIZE_PASS_BEGIN | ( | InstructionCombiningPass | , |
"instcombine" | , | ||
"Combine redundant instructions" | , | ||
false | , | ||
false | |||
) |
|
static |
Definition at line 2700 of file InstructionCombining.cpp.
References assert(), llvm::MCID::Call, llvm::getAllocationFamily(), llvm::IntrinsicInst::getIntrinsicID(), llvm::User::getOperand(), I, llvm::ICmpInst::isEquality(), llvm::isFreeCall(), isNeverEqualToUnescapedAlloc(), llvm::isReallocLikeFn(), isRemovableWrite(), LLVM_FALLTHROUGH, llvm_unreachable, memcpy(), MI, llvm::SmallVectorImpl< T >::pop_back_val(), SI, llvm::SPII::Store, Users, and llvm::Value::users().
Referenced by llvm::InstCombinerImpl::visitAllocSite().
|
static |
Return 'true' if the given typeinfo will match anything.
Definition at line 3373 of file InstructionCombining.cpp.
References llvm::CoreCLR, llvm::GNU_Ada, llvm::GNU_C, llvm::GNU_C_SjLj, llvm::GNU_CXX, llvm::GNU_CXX_SjLj, llvm::GNU_ObjC, llvm::Constant::isNullValue(), llvm_unreachable, llvm::MSVC_CXX, llvm::MSVC_TableSEH, llvm::MSVC_X86SEH, llvm::Rust, llvm::Unknown, llvm::Wasm_CXX, and llvm::XL_CXX.
Referenced by llvm::InstCombinerImpl::visitLandingPadInst().
|
static |
Definition at line 1917 of file InstructionCombining.cpp.
References llvm::GEPOperator::hasAllZeroIndices(), and llvm::GEPOperator::isInBounds().
Referenced by llvm::InstCombinerImpl::visitGEPOfGEP().
|
static |
Definition at line 3050 of file InstructionCombining.cpp.
Referenced by llvm::SelectionDAGBuilder::LowerCallTo(), and llvm::InstCombinerImpl::visitReturnInst().
|
static |
Definition at line 2668 of file InstructionCombining.cpp.
References llvm::isAllocLikeFn().
Referenced by isAllocSiteRemovable().
|
static |
Given a call CB which uses an address UsedV, return true if we can prove the call's only possible effect is storing to V.
Definition at line 2680 of file InstructionCombining.cpp.
References llvm::CallBase::doesNotThrow(), llvm::MemoryLocation::getForDest(), llvm::Instruction::isTerminator(), llvm::MemoryLocation::Ptr, llvm::Value::use_empty(), and llvm::Instruction::willReturn().
Referenced by isAllocSiteRemovable().
|
static |
Return whether "X LOp (Y ROp Z)" is always equal to "(X LOp Y) ROp (X LOp Z)".
Definition at line 566 of file InstructionCombining.cpp.
References llvm::MCID::Add, and Mul.
Referenced by rightDistributesOverLeft(), llvm::InstCombinerImpl::SimplifyUsingDistributiveLaws(), and llvm::InstCombinerImpl::tryFactorization().
|
static |
Definition at line 275 of file InstructionCombining.cpp.
References llvm::MCID::Add, B, I, llvm::PatternMatch::m_APInt(), llvm::PatternMatch::match(), llvm::APInt::sadd_ov(), and llvm::APInt::ssub_ov().
Referenced by llvm::InstCombinerImpl::SimplifyAssociativeOrCommutative().
|
static |
Populate the IC worklist from a function, by walking it in depth-first order and adding all reachable code to the worklist.
This has a couple of tricks to make the code faster and more powerful. In particular, we constant fold and DCE instructions as we go, to avoid adding them to the worklist (this significantly speeds up instcombine on code where many instructions are dead or constant). Additionally, if we find a branch whose condition is a known constant, we only visit the reachable successors.
Definition at line 4372 of file InstructionCombining.cpp.
References AliasScopeTracker::analyse(), llvm::append_range(), BB, Cond, llvm::ConstantFoldConstant(), llvm::ConstantFoldInstruction(), llvm::SmallPtrSetImpl< PtrType >::count(), llvm::dbgs(), DL, F, llvm::SmallPtrSetImpl< PtrType >::insert(), llvm::isInstructionTriviallyDead(), AliasScopeTracker::isNoAliasScopeDeclDead(), LLVM_DEBUG, llvm::make_early_inc_range(), llvm::SmallVectorImpl< T >::pop_back_val(), llvm::InstructionWorklist::push(), llvm::removeAllNonTerminatorAndEHPadInstructions(), llvm::InstructionWorklist::reserve(), llvm::reverse(), llvm::salvageDebugInfo(), SI, and llvm::successors().
Referenced by combineInstructionsOverFunction().
|
static |
Return whether "(X LOp Y) ROp Z" is always equal to "(X ROp Z) LOp (Y ROp Z)".
Definition at line 587 of file InstructionCombining.cpp.
References llvm::Instruction::isBitwiseLogicOp(), llvm::Instruction::isCommutative(), llvm::Instruction::isShift(), and leftDistributesOverRight().
Referenced by llvm::InstCombinerImpl::SimplifyUsingDistributiveLaws(), and llvm::InstCombinerImpl::tryFactorization().
Definition at line 3401 of file InstructionCombining.cpp.
References llvm::Value::getType(), LHS, and RHS.
Referenced by llvm::InstCombinerImpl::visitLandingPadInst().
|
static |
Definition at line 1394 of file InstructionCombining.cpp.
References GEP.
Referenced by llvm::InstCombinerImpl::visitGEPOfGEP().
|
static |
Combine constant operands of associative operations either before or after a cast to eliminate one of the associative operations: (op (cast (op X, C2)), C1) --> (cast (op X, op (C1, C2))) (op (cast (op X, C2)), C1) --> (op (cast X), op (C1, C2))
Definition at line 327 of file InstructionCombining.cpp.
References C1, llvm::ConstantExpr::get(), llvm::ConstantExpr::getCast(), llvm::BinaryOperator::getOpcode(), llvm::User::getOperand(), llvm::Instruction::isBitwiseLogicOp(), llvm::PatternMatch::m_Constant(), llvm::PatternMatch::match(), and llvm::InstCombinerImpl::replaceOperand().
Referenced by llvm::InstCombinerImpl::SimplifyAssociativeOrCommutative().
|
static |
Check for case where the call writes to an otherwise dead alloca.
This shows up for unused out-params in idiomatic C/C++ code. Note that this helper only analyzes the write; doesn't check any other legality aspect.
Definition at line 3955 of file InstructionCombining.cpp.
References llvm::MemoryLocation::getForDest(), llvm::getUnderlyingObject(), I, llvm::SmallPtrSetImpl< PtrType >::insert(), llvm::SmallVectorImpl< T >::pop_back_val(), and llvm::MemoryLocation::Ptr.
Referenced by TryToSinkInstruction().
STATISTIC | ( | NumCombined | , |
"Number of insts combined" | |||
) |
STATISTIC | ( | NumDeadInst | , |
"Number of dead inst eliminated" | |||
) |
STATISTIC | ( | NumExpand | , |
"Number of expansions" | |||
) |
STATISTIC | ( | NumFactor | , |
"Number of factorizations" | |||
) |
STATISTIC | ( | NumReassoc | , |
"Number of reassociations" | |||
) |
STATISTIC | ( | NumSunkInst | , |
"Number of instructions sunk" | |||
) |
STATISTIC | ( | NumWorklistIterations | , |
"Number of instruction combining iterations performed" | |||
) |
|
static |
Move the call to free before a NULL test.
Check if this free is accessed after its argument has been test against NULL (property 0). If yes, it is legal to move this call in its predecessor block.
The move is performed only if the block containing the call to free will be removed, i.e.:
The profitability is out-of concern here and this function should be called only if the caller knows this transformation would be profitable (e.g., for code size).
Definition at line 2922 of file InstructionCombining.cpp.
References llvm::Function::addDereferenceableOrNullParamAttr(), assert(), Attrs, DL, llvm::CallBase::getArgOperand(), llvm::CallBase::getAttributes(), llvm::Value::getContext(), llvm::Attribute::getDereferenceableBytes(), llvm::Instruction::getParent(), llvm::BasicBlock::getSinglePredecessor(), llvm::BasicBlock::getTerminator(), llvm::CmpInst::ICMP_EQ, llvm::CmpInst::ICMP_NE, llvm::BasicBlock::instructionsWithoutDebug(), llvm::Attribute::isValid(), llvm::PatternMatch::m_Br(), llvm::PatternMatch::m_CombineOr(), llvm::PatternMatch::m_ICmp(), llvm::PatternMatch::m_Specific(), llvm::PatternMatch::m_UnconditionalBr(), llvm::PatternMatch::m_Zero(), llvm::make_early_inc_range(), llvm::PatternMatch::match(), llvm::CallBase::setAttributes(), and llvm::BasicBlock::size().
Referenced by llvm::InstCombinerImpl::visitFree().
|
static |
Try to move the specified instruction from its current block into the beginning of DestBlock, which can only happen if it's safe to move the instruction past all of the instructions between it and the end of its block.
FIXME: We could remove droppable uses that are not dominated by the new position.
Definition at line 4000 of file InstructionCombining.cpp.
References B, llvm::dbgs(), E, llvm::findDbgUsers(), llvm::BasicBlock::getFirstInsertionPt(), llvm::BasicBlock::getTerminator(), llvm::BasicBlock::getUniquePredecessor(), I, llvm::SmallSet< T, N, C >::insert(), LLVM_DEBUG, llvm::reverse(), llvm::salvageDebugInfoForDbgValues(), SoleWriteToDeadLocal(), and llvm::sort().
Referenced by llvm::InstCombinerImpl::run().
|
static |
Referenced by llvm::InstCombinerImpl::run().
Combine redundant false |
Definition at line 4655 of file InstructionCombining.cpp.
|
static |
Referenced by combineInstructionsOverFunction().
instcombine |
Definition at line 4654 of file InstructionCombining.cpp.
|
staticconstexpr |
Definition at line 132 of file InstructionCombining.cpp.
|
staticconstexpr |
Definition at line 130 of file InstructionCombining.cpp.
Combine redundant instructions |
Definition at line 4655 of file InstructionCombining.cpp.
|
static |
Referenced by combineInstructionsOverFunction().
|
static |
Referenced by combineInstructionsOverFunction().
|
static |
Referenced by llvm::InstCombinerImpl::run().
|
static |
Referenced by combineInstructionsOverFunction().