75#define DEBUG_TYPE "consthoist"
77STATISTIC(NumConstantsHoisted,
"Number of constants hoisted");
78STATISTIC(NumConstantsRebased,
"Number of constants rebased");
82 cl::desc(
"Enable the use of the block frequency analysis to reduce the "
83 "chance to execute const materialization more frequently than "
84 "without hoisting."));
88 cl::desc(
"Try hoisting constant gep expressions"));
92 cl::desc(
"Do not rebase if number of dependent constants of a Base is less "
126char ConstantHoistingLegacyPass::ID = 0;
129 "Constant Hoisting",
false,
false)
138 return new ConstantHoistingLegacyPass();
142bool ConstantHoistingLegacyPass::runOnFunction(
Function &Fn) {
143 if (skipFunction(Fn))
146 LLVM_DEBUG(
dbgs() <<
"********** Begin Constant Hoisting **********\n");
150 Impl.runImpl(Fn, getAnalysis<TargetTransformInfoWrapperPass>().getTTI(Fn),
151 getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
153 ? &getAnalysis<BlockFrequencyInfoWrapperPass>().getBFI()
156 &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI());
158 LLVM_DEBUG(
dbgs() <<
"********** End Constant Hoisting **********\n");
163void ConstantHoistingPass::collectMatInsertPts(
173 unsigned Idx)
const {
178 if (
auto CastInst = dyn_cast<Instruction>(Opnd))
184 if (!isa<PHINode>(Inst) && !Inst->
isEHPad())
189 assert(Entry != Inst->
getParent() &&
"PHI or landing pad in entry block!");
191 if (
Idx != ~0U && isa<PHINode>(Inst)) {
192 InsertionBlock = cast<PHINode>(Inst)->getIncomingBlock(
Idx);
193 if (!InsertionBlock->
isEHPad()) {
204 while (IDom->getBlock()->isEHPad()) {
205 assert(Entry != IDom->getBlock() &&
"eh pad in entry block");
206 IDom = IDom->getIDom();
209 return IDom->getBlock()->getTerminator()->getIterator();
218 assert(!BBs.
count(Entry) &&
"Assume Entry is not in BBs");
225 for (
auto *BB : BBs) {
242 "Entry doens't dominate current Node");
252 Candidates.
insert(Path.begin(), Path.end());
263 if (Candidates.
count(ChildDomNode->getBlock()))
264 Orders.
push_back(ChildDomNode->getBlock());
269 using InsertPtsCostPair =
278 auto &InsertPts = InsertPtsMap[
Node].first;
284 if (InsertPtsFreq > BFI.getBlockFreq(
Node) ||
285 (InsertPtsFreq == BFI.getBlockFreq(
Node) && InsertPts.size() > 1))
288 BBs.
insert(InsertPts.begin(), InsertPts.end());
295 auto &ParentInsertPts = InsertPtsMap[Parent].first;
305 (InsertPtsFreq > BFI.getBlockFreq(
Node) ||
306 (InsertPtsFreq == BFI.getBlockFreq(
Node) && InsertPts.size() > 1)))) {
308 ParentPtsFreq += BFI.getBlockFreq(
Node);
310 ParentInsertPts.insert(InsertPts.begin(), InsertPts.end());
311 ParentPtsFreq += InsertPtsFreq;
318ConstantHoistingPass::findConstantInsertionPoint(
327 BBs.
insert(MatInsertPt->getParent());
329 if (BBs.
count(Entry)) {
337 InsertPts.
insert(BB->getFirstInsertionPt());
341 while (BBs.size() >= 2) {
343 BB1 = BBs.pop_back_val();
344 BB2 = BBs.pop_back_val();
352 assert((BBs.size() == 1) &&
"Expected only one element.");
354 InsertPts.
insert(findMatInsertPt(&FirstInst));
364void ConstantHoistingPass::collectConstantCandidates(
373 if (
auto IntrInst = dyn_cast<IntrinsicInst>(Inst))
386 ConstPtrUnionType Cand = ConstInt;
387 std::tie(Itr, Inserted) = ConstCandMap.insert(std::make_pair(Cand, 0));
390 Itr->second = ConstIntCandVec.size() - 1;
394 <<
"Collect constant " << *ConstInt <<
" from " << *Inst
395 <<
" with cost " <<
Cost <<
'\n';
396 else dbgs() <<
"Collect constant " << *ConstInt
397 <<
" indirectly from " << *Inst <<
" via "
404void ConstantHoistingPass::collectConstantCandidates(
419 auto *GEPO = cast<GEPOperator>(ConstExpr);
425 if (!GEPO->isInBounds())
428 if (!GEPO->accumulateConstantOffset(*DL,
Offset))
441 ConstCandVecType &ExprCandVec = ConstGEPCandMap[BaseGV];
444 ConstPtrUnionType Cand = ConstExpr;
445 std::tie(Itr, Inserted) = ConstCandMap.insert(std::make_pair(Cand, 0));
450 Itr->second = ExprCandVec.size() - 1;
456void ConstantHoistingPass::collectConstantCandidates(
457 ConstCandMapType &ConstCandMap,
Instruction *Inst,
unsigned Idx) {
461 if (
auto ConstInt = dyn_cast<ConstantInt>(Opnd)) {
462 collectConstantCandidates(ConstCandMap, Inst,
Idx, ConstInt);
467 if (
auto CastInst = dyn_cast<Instruction>(Opnd)) {
476 collectConstantCandidates(ConstCandMap, Inst,
Idx, ConstInt);
482 if (
auto ConstExpr = dyn_cast<ConstantExpr>(Opnd)) {
485 collectConstantCandidates(ConstCandMap, Inst,
Idx, ConstExpr);
491 if (
auto ConstInt = dyn_cast<ConstantInt>(ConstExpr->
getOperand(0))) {
494 collectConstantCandidates(ConstCandMap, Inst,
Idx, ConstInt);
502void ConstantHoistingPass::collectConstantCandidates(
503 ConstCandMapType &ConstCandMap,
Instruction *Inst) {
516 collectConstantCandidates(ConstCandMap, Inst,
Idx);
523void ConstantHoistingPass::collectConstantCandidates(
Function &Fn) {
524 ConstCandMapType ConstCandMap;
531 collectConstantCandidates(ConstCandMap, &Inst);
541 std::optional<APInt> Res;
542 unsigned BW = V1.
getBitWidth() > V2.getBitWidth() ?
545 uint64_t LimVal2 = V2.getLimitedValue();
547 if (LimVal1 == ~0ULL || LimVal2 == ~0ULL)
551 return APInt(BW, Diff,
true);
578ConstantHoistingPass::maximizeConstantsInRange(ConstCandVecType::iterator S,
579 ConstCandVecType::iterator E,
580 ConstCandVecType::iterator &MaxCostItr) {
581 unsigned NumUses = 0;
583 if (!OptForSize || std::distance(S,E) > 100) {
584 for (
auto ConstCand = S; ConstCand != E; ++ConstCand) {
585 NumUses += ConstCand->Uses.size();
586 if (ConstCand->CumulativeCost > MaxCostItr->CumulativeCost)
587 MaxCostItr = ConstCand;
594 for (
auto ConstCand = S; ConstCand != E; ++ConstCand) {
595 auto Value = ConstCand->ConstInt->getValue();
596 Type *Ty = ConstCand->ConstInt->getType();
598 NumUses += ConstCand->Uses.size();
599 LLVM_DEBUG(
dbgs() <<
"= Constant: " << ConstCand->ConstInt->getValue()
602 for (
auto User : ConstCand->Uses) {
603 unsigned Opcode =
User.Inst->getOpcode();
604 unsigned OpndIdx =
User.OpndIdx;
609 for (
auto C2 = S; C2 != E; ++C2) {
611 C2->ConstInt->getValue(), ConstCand->ConstInt->getValue());
617 <<
"has penalty: " << ImmCosts <<
"\n"
618 <<
"Adjusted cost: " <<
Cost <<
"\n");
623 if (
Cost > MaxCost) {
625 MaxCostItr = ConstCand;
626 LLVM_DEBUG(
dbgs() <<
"New candidate: " << MaxCostItr->ConstInt->getValue()
635void ConstantHoistingPass::findAndMakeBaseConstant(
636 ConstCandVecType::iterator S, ConstCandVecType::iterator E,
639 unsigned NumUses = maximizeConstantsInRange(S, E, MaxCostItr);
653 for (
auto ConstCand = S; ConstCand != E; ++ConstCand) {
654 APInt Diff = ConstCand->ConstInt->getValue() - ConstInt->
getValue();
655 Constant *
Offset = Diff == 0 ? nullptr : ConstantInt::get(Ty, Diff);
657 ConstCand->ConstExpr ? ConstCand->ConstExpr->getType() :
nullptr;
661 ConstInfoVec.
push_back(std::move(ConstInfo));
666void ConstantHoistingPass::findBaseConstants(
GlobalVariable *BaseGV) {
669 ConstCandVecType &ConstCandVec = BaseGV ?
670 ConstGEPCandMap[BaseGV] : ConstIntCandVec;
671 ConstInfoVecType &ConstInfoVec = BaseGV ?
672 ConstGEPInfoMap[BaseGV] : ConstIntInfoVec;
678 return LHS.ConstInt->getBitWidth() <
RHS.ConstInt->getBitWidth();
679 return LHS.ConstInt->getValue().ult(
RHS.ConstInt->getValue());
684 auto MinValItr = ConstCandVec.begin();
685 for (
auto CC = std::next(ConstCandVec.begin()), E = ConstCandVec.end();
687 if (MinValItr->ConstInt->getType() ==
CC->ConstInt->getType()) {
688 Type *MemUseValTy =
nullptr;
689 for (
auto &U :
CC->Uses) {
691 if (
LoadInst *LI = dyn_cast<LoadInst>(UI)) {
692 MemUseValTy = LI->getType();
694 }
else if (
StoreInst *SI = dyn_cast<StoreInst>(UI)) {
696 if (
SI->getPointerOperand() ==
SI->getOperand(
U.OpndIdx)) {
697 MemUseValTy =
SI->getValueOperand()->getType();
704 APInt Diff =
CC->ConstInt->getValue() - MinValItr->ConstInt->getValue();
716 findAndMakeBaseConstant(MinValItr,
CC, ConstInfoVec);
721 findAndMakeBaseConstant(MinValItr, ConstCandVec.end(), ConstInfoVec);
731 if (
auto PHI = dyn_cast<PHINode>(Inst)) {
739 for (
unsigned i = 0; i <
Idx; ++i) {
740 if (
PHI->getIncomingBlock(i) == IncomingBB) {
741 Value *IncomingVal =
PHI->getIncomingValue(i);
755 UserAdjustment *Adj) {
759 if (!Adj->Offset && Adj->Ty && Adj->Ty !=
Base->getType())
766 "mat_gep", Adj->MatInsertPt);
769 Adj->MatInsertPt->getIterator());
774 "const_mat", Adj->MatInsertPt->getIterator());
777 <<
" + " << *Adj->Offset <<
") in BB "
782 Value *Opnd = Adj->User.Inst->getOperand(Adj->User.OpndIdx);
785 if (isa<ConstantInt>(Opnd)) {
787 if (!
updateOperand(Adj->User.Inst, Adj->User.OpndIdx, Mat) && Adj->Offset)
794 if (
auto CastInst = dyn_cast<Instruction>(Opnd)) {
799 if (!ClonedCastInst) {
806 <<
"To : " << *ClonedCastInst <<
'\n');
810 updateOperand(Adj->User.Inst, Adj->User.OpndIdx, ClonedCastInst);
816 if (
auto ConstExpr = dyn_cast<ConstantExpr>(Opnd)) {
817 if (isa<GEPOperator>(ConstExpr)) {
824 assert(ConstExpr->
isCast() &&
"ConstExpr should be a cast");
830 ConstExprInst->
setDebugLoc(Adj->User.Inst->getDebugLoc());
832 LLVM_DEBUG(
dbgs() <<
"Create instruction: " << *ConstExprInst <<
'\n'
833 <<
"From : " << *ConstExpr <<
'\n');
835 if (!
updateOperand(Adj->User.Inst, Adj->User.OpndIdx, ConstExprInst)) {
847bool ConstantHoistingPass::emitBaseConstants(
GlobalVariable *BaseGV) {
848 bool MadeChange =
false;
850 BaseGV ? ConstGEPInfoMap[BaseGV] : ConstIntInfoVec;
855 findConstantInsertionPoint(ConstInfo, MatInsertPts);
860 unsigned UsesNum = 0;
861 unsigned ReBasesNum = 0;
862 unsigned NotRebasedNum = 0;
869 UsesNum += RCI.Uses.size();
870 for (
auto const &U : RCI.Uses) {
875 if (IPSet.size() == 1 ||
876 DT->
dominates(IP->getParent(), OrigMatInsertBB))
877 ToBeRebased.
emplace_back(RCI.Offset, RCI.Ty, MatInsertPt, U);
884 NotRebasedNum += ToBeRebased.
size();
892 assert(BaseGV &&
"A base constant expression must have an base GV");
900 Base->setDebugLoc(IP->getDebugLoc());
903 <<
") to BB " << IP->getParent()->
getName() <<
'\n'
907 for (UserAdjustment &R : ToBeRebased) {
908 emitBaseConstants(
Base, &R);
912 Base->getDebugLoc(),
R.User.Inst->getDebugLoc()));
914 assert(!
Base->use_empty() &&
"The use list is empty!?");
916 "All uses should be instructions.");
922 assert(UsesNum == (ReBasesNum + NotRebasedNum) &&
923 "Not all uses are rebased");
925 NumConstantsHoisted++;
938void ConstantHoistingPass::deleteDeadCastInst()
const {
939 for (
auto const &
I : ClonedCastMap)
940 if (
I.first->use_empty())
941 I.first->eraseFromParent();
953 this->Entry = &Entry;
955 this->OptForSize = Entry.getParent()->hasOptSize() ||
960 collectConstantCandidates(Fn);
964 if (!ConstIntCandVec.empty())
965 findBaseConstants(
nullptr);
966 for (
const auto &MapEntry : ConstGEPCandMap)
967 if (!MapEntry.second.empty())
968 findBaseConstants(MapEntry.first);
972 bool MadeChange =
false;
973 if (!ConstIntInfoVec.
empty())
974 MadeChange = emitBaseConstants(
nullptr);
975 for (
const auto &MapEntry : ConstGEPInfoMap)
976 if (!MapEntry.second.empty())
977 MadeChange |= emitBaseConstants(MapEntry.first);
981 deleteDeadCastInst();
This file implements a class to represent arbitrary precision integral constant values and operations...
static bool updateOperand(Instruction *Inst, unsigned Idx, Instruction *Mat)
Updates the operand at Idx in instruction Inst with the result of instruction Mat.
static void findBestInsertionSet(DominatorTree &DT, BlockFrequencyInfo &BFI, BasicBlock *Entry, SetVector< BasicBlock * > &BBs)
Given BBs as input, find another set of BBs which collectively dominates BBs and have the minimal sum...
static cl::opt< unsigned > MinNumOfDependentToRebase("consthoist-min-num-to-rebase", cl::desc("Do not rebase if number of dependent constants of a Base is less " "than this number."), cl::init(0), cl::Hidden)
static cl::opt< bool > ConstHoistWithBlockFrequency("consthoist-with-block-frequency", cl::init(true), cl::Hidden, cl::desc("Enable the use of the block frequency analysis to reduce the " "chance to execute const materialization more frequently than " "without hoisting."))
static cl::opt< bool > ConstHoistGEP("consthoist-gep", cl::init(false), cl::Hidden, cl::desc("Try hoisting constant gep expressions"))
static std::optional< APInt > calculateOffsetDiff(const APInt &V1, const APInt &V2)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines the DenseMap class.
static bool isCandidate(const MachineInstr *MI, Register &DefedReg, Register FrameReg)
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Class for arbitrary precision integers.
unsigned getBitWidth() const
Return the number of bits in the APInt.
uint64_t getLimitedValue(uint64_t Limit=UINT64_MAX) const
If this value is smaller than the specified limit, return it, otherwise return the limit value.
int64_t getSExtValue() const
Get sign extended value.
A container for analyses that lazily runs them and caches their results.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
void setPreservesCFG()
This function should be called by the pass, iff they do not:
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
const Function * getParent() const
Return the enclosing method, or null if none.
InstListType::iterator iterator
Instruction iterators...
bool isEHPad() const
Return true if this basic block is an exception handling block.
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name, BasicBlock::iterator InsertBefore)
Construct a binary instruction, given the opcode and the two operands.
This class represents a no-op cast from one type to another.
Analysis pass which computes BlockFrequencyInfo.
Legacy analysis pass which computes BlockFrequencyInfo.
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Represents analyses that only rely on functions' control flow.
This is the base class for all instructions that perform data casts.
A constant value that is initialized with an expression using other constant values.
bool isCast() const
Return true if this is a convert constant expression.
Instruction * getAsInstruction() const
Returns an Instruction which implements the same operation as this ConstantExpr.
bool runImpl(Function &F, TargetTransformInfo &TTI, DominatorTree &DT, BlockFrequencyInfo *BFI, BasicBlock &Entry, ProfileSummaryInfo *PSI)
Optimize expensive integer constants in the given function.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
This is the shared class of boolean and integer constants.
IntegerType * getIntegerType() const
Variant of the getType() method to always return an IntegerType, which reduces the amount of casting ...
const APInt & getValue() const
Return the constant as an APInt value reference.
This is an important base class in LLVM.
static DILocation * getMergedLocation(DILocation *LocA, DILocation *LocB)
When two instructions are combined into a single instruction we also need to combine the original loc...
IntegerType * getIndexType(LLVMContext &C, unsigned AddressSpace) const
Returns the type of a GEP index in AddressSpace.
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT > iterator
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
void reserve(size_type NumEntries)
Grow the densemap so that it can contain at least NumEntries items before resizing again.
iterator_range< iterator > children()
DomTreeNodeBase * getIDom() const
Analysis pass which computes a DominatorTree.
DomTreeNodeBase< NodeT > * getNode(const NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
Legacy analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
bool isReachableFromEntry(const Use &U) const
Provide an overload for a Use.
Instruction * findNearestCommonDominator(Instruction *I1, Instruction *I2) const
Find the nearest instruction I that dominates both I1 and I2, in the sense that a result produced bef...
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
FunctionPass class - This class is used to implement most global optimizations.
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
const BasicBlock & getEntryBlock() const
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr, BasicBlock::iterator InsertBefore)
Module * getParent()
Get the module that this global value is contained inside of...
PointerType * getType() const
Global values are always pointers.
std::optional< CostType > getValue() const
This function is intended to be used as sparingly as possible, since the class provides the full rang...
Instruction * clone() const
Create a copy of 'this' instruction that is identical in all ways except the following:
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction.
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
const BasicBlock * getParent() const
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction.
Class to represent integer types.
An instruction for reading from memory.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
void preserveSet()
Mark an analysis set as preserved.
An analysis pass based on the new PM to deliver ProfileSummaryInfo.
An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
Analysis providing profile information.
A vector that has set insertion semantics.
void clear()
Completely clear the SetVector.
size_type count(const key_type &key) const
Count the number of elements of a given key in the SetVector.
bool empty() const
Determine if the SetVector is empty or not.
bool insert(const value_type &X)
Insert a new element into the SetVector.
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
reference emplace_back(ArgTypes &&... Args)
void push_back(const T &Elt)
An instruction for storing to memory.
StringRef - Represent a constant reference to a string, i.e.
Analysis pass providing the TargetTransformInfo.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
static IntegerType * getInt8Ty(LLVMContext &C)
static IntegerType * getInt32Ty(LLVMContext &C)
void setOperand(unsigned i, Value *Val)
Value * getOperand(unsigned i) const
unsigned getNumOperands() const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
StringRef getName() const
Return a constant reference to the value's name.
self_iterator getIterator()
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
void stable_sort(R &&Range)
FunctionPass * createConstantHoistingPass()
bool shouldOptimizeForSize(const MachineFunction *MF, ProfileSummaryInfo *PSI, const MachineBlockFrequencyInfo *BFI, PGSOQueryType QueryType=PGSOQueryType::Other)
Returns true if machine function MF is suggested to be size-optimized based on the profile.
auto reverse(ContainerTy &&C)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
bool canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx)
Given an instruction, is it legal to set operand OpIdx to a non-constant value?
void initializeConstantHoistingLegacyPassPass(PassRegistry &)
Keeps track of a constant candidate and its uses.
A base constant and all its rebased constants.
RebasedConstantListType RebasedConstants
Keeps track of the user of a constant and the operand index where the constant is used.
This represents a constant that has been rebased with respect to a base constant.