}
char CodeGenPrepare::ID = 0;
-static void *initializeCodeGenPreparePassOnce(PassRegistry &Registry) {
- initializeTargetLibraryInfoPass(Registry);
- PassInfo *PI = new PassInfo(
- "Optimize for code generation", "codegenprepare", &CodeGenPrepare::ID,
- PassInfo::NormalCtor_t(callDefaultCtor<CodeGenPrepare>), false, false,
- PassInfo::TargetMachineCtor_t(callTargetMachineCtor<CodeGenPrepare>));
- Registry.registerPass(*PI, true);
- return PI;
-}
-
-void llvm::initializeCodeGenPreparePass(PassRegistry &Registry) {
- CALL_ONCE_INITIALIZATION(initializeCodeGenPreparePassOnce)
-}
+INITIALIZE_TM_PASS(CodeGenPrepare, "codegenprepare",
+ "Optimize for code generation", false, false)
FunctionPass *llvm::createCodeGenPreparePass(const TargetMachine *TM) {
return new CodeGenPrepare(TM);
PromotedInsts.clear();
ModifiedDT = false;
- if (TM) TLI = TM->getTargetLowering();
+ if (TM)
+ TLI = TM->getSubtargetImpl()->getTargetLowering();
TLInfo = &getAnalysis<TargetLibraryInfo>();
DominatorTreeWrapperPass *DTWP =
getAnalysisIfAvailable<DominatorTreeWrapperPass>();
/// 1. Truncate instruction
/// 2. And instruction and the imm is a mask of the low bits:
/// imm & (imm+1) == 0
-bool isExtractBitsCandidateUse(Instruction *User) {
+static bool isExtractBitsCandidateUse(Instruction *User) {
if (!isa<TruncInst>(User)) {
if (User->getOpcode() != Instruction::And ||
!isa<ConstantInt>(User->getOperand(1)))
/// SinkShiftAndTruncate - sink both shift and truncate instruction
/// to the use of truncate's BB.
-bool
+static bool
SinkShiftAndTruncate(BinaryOperator *ShiftI, Instruction *User, ConstantInt *CI,
DenseMap<BasicBlock *, BinaryOperator *> &InsertedShifts,
const TargetLowering &TLI) {
if (!ISDOpcode)
continue;
- // If the use is actually a legal node, there will not be an implicit
- // truncate.
+ // If the use is actually a legal node, there will not be an
+ // implicit truncate.
+ // FIXME: always querying the result type is just an
+ // approximation; some nodes' legality is determined by the
+ // operand or other means. There's no good way to find out though.
if (TLI.isOperationLegalOrCustom(ISDOpcode,
- EVT::getEVT(TruncUser->getType())))
+ EVT::getEVT(TruncUser->getType(), true)))
continue;
// Don't bother for PHI nodes.
}
return true;
}
- // Lower all uses of llvm.safe.[us]{div|rem}...
- if (II &&
- (II->getIntrinsicID() == Intrinsic::safe_sdiv ||
- II->getIntrinsicID() == Intrinsic::safe_udiv ||
- II->getIntrinsicID() == Intrinsic::safe_srem ||
- II->getIntrinsicID() == Intrinsic::safe_urem)) {
- // Given
- // result_struct = type {iN, i1}
- // %R = call result_struct llvm.safe.sdiv.iN(iN %x, iN %y)
- // Expand it to actual IR, which produces result to the same variable %R.
- // First element of the result %R.1 is the result of division, second
- // element shows whether the division was correct or not.
- // If %y is 0, %R.1 is 0, %R.2 is 1. (1)
- // If %x is minSignedValue and %y is -1, %R.1 is %x, %R.2 is 1. (2)
- // In other cases %R.1 is (sdiv %x, %y), %R.2 is 0. (3)
- //
- // Similar applies to srem, udiv, and urem builtins, except that in unsigned
- // variants we don't check condition (2).
-
- bool IsSigned;
- BinaryOperator::BinaryOps Op;
- switch (II->getIntrinsicID()) {
- case Intrinsic::safe_sdiv:
- IsSigned = true;
- Op = Instruction::SDiv;
- break;
- case Intrinsic::safe_udiv:
- IsSigned = false;
- Op = Instruction::UDiv;
- break;
- case Intrinsic::safe_srem:
- IsSigned = true;
- Op = Instruction::SRem;
- break;
- case Intrinsic::safe_urem:
- IsSigned = false;
- Op = Instruction::URem;
- break;
- default:
- llvm_unreachable("Only Div/Rem intrinsics are handled here.");
- }
-
- Value *LHS = II->getOperand(0), *RHS = II->getOperand(1);
- bool DivWellDefined = TLI && TLI->isDivWellDefined();
-
- bool ResultNeeded[2] = {false, false};
- SmallVector<User*, 1> ResultsUsers[2];
- bool BadCase = false;
- for (User *U: II->users()) {
- ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(U);
- if (!EVI || EVI->getNumIndices() > 1 || EVI->getIndices()[0] > 1) {
- BadCase = true;
- break;
- }
- ResultNeeded[EVI->getIndices()[0]] = true;
- ResultsUsers[EVI->getIndices()[0]].push_back(U);
- }
- // Behave conservatively, if there is an unusual user of the results.
- if (BadCase)
- ResultNeeded[0] = ResultNeeded[1] = true;
-
- // Early exit if non of the results is ever used.
- if (!ResultNeeded[0] && !ResultNeeded[1]) {
- II->eraseFromParent();
- return true;
- }
-
- // Early exit if the second result (flag) isn't used and target
- // div-instruction computes exactly what we want to get as the first result
- // and never traps.
- if (ResultNeeded[0] && !ResultNeeded[1] && DivWellDefined) {
- BinaryOperator *Div = BinaryOperator::Create(Op, LHS, RHS);
- Div->insertAfter(II);
- for (User *U: ResultsUsers[0]) {
- Instruction *UserInst = dyn_cast<Instruction>(U);
- assert(UserInst && "Unexpected null-instruction");
- UserInst->replaceAllUsesWith(Div);
- UserInst->eraseFromParent();
- }
- II->eraseFromParent();
- CurInstIterator = Div;
- ModifiedDT = true;
- return true;
- }
-
- Value *MinusOne = Constant::getAllOnesValue(LHS->getType());
- Value *Zero = Constant::getNullValue(LHS->getType());
-
- // Split the original BB and create other basic blocks that will be used
- // for checks.
- BasicBlock *StartBB = II->getParent();
- BasicBlock::iterator SplitPt = ++(BasicBlock::iterator(II));
- BasicBlock *NextBB = StartBB->splitBasicBlock(SplitPt, "div.end");
-
- BasicBlock *DivByZeroBB;
- DivByZeroBB = BasicBlock::Create(II->getContext(), "div.divz",
- NextBB->getParent(), NextBB);
- BranchInst::Create(NextBB, DivByZeroBB);
- BasicBlock *DivBB = BasicBlock::Create(II->getContext(), "div.div",
- NextBB->getParent(), NextBB);
- BranchInst::Create(NextBB, DivBB);
-
- // For signed variants, check the condition (2):
- // LHS == SignedMinValue, RHS == -1.
- Value *CmpMinusOne;
- Value *CmpMinValue;
- BasicBlock *ChkDivMinBB;
- BasicBlock *DivMinBB;
- Value *MinValue;
- if (IsSigned) {
- APInt SignedMinValue =
- APInt::getSignedMinValue(LHS->getType()->getPrimitiveSizeInBits());
- MinValue = Constant::getIntegerValue(LHS->getType(), SignedMinValue);
- ChkDivMinBB = BasicBlock::Create(II->getContext(), "div.chkdivmin",
- NextBB->getParent(), NextBB);
- BranchInst::Create(NextBB, ChkDivMinBB);
- DivMinBB = BasicBlock::Create(II->getContext(), "div.divmin",
- NextBB->getParent(), NextBB);
- BranchInst::Create(NextBB, DivMinBB);
- CmpMinusOne = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_EQ,
- RHS, MinusOne, "cmp.rhs.minus.one",
- ChkDivMinBB->getTerminator());
- CmpMinValue = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_EQ,
- LHS, MinValue, "cmp.lhs.signed.min",
- ChkDivMinBB->getTerminator());
- BinaryOperator *CmpSignedOvf = BinaryOperator::Create(Instruction::And,
- CmpMinusOne,
- CmpMinValue);
- // Here we're interested in the case when both %x is TMin and %y is -1.
- // In this case the result will overflow.
- // If that's not the case, we can perform usual division. These blocks
- // will be inserted after DivByZero, so the division will be safe.
- CmpSignedOvf->insertBefore(ChkDivMinBB->getTerminator());
- BranchInst::Create(DivMinBB, DivBB, CmpSignedOvf,
- ChkDivMinBB->getTerminator());
- ChkDivMinBB->getTerminator()->eraseFromParent();
- }
-
- // Check the condition (1):
- // RHS == 0.
- Value *CmpDivZero = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_EQ,
- RHS, Zero, "cmp.rhs.zero",
- StartBB->getTerminator());
-
- // If RHS != 0, we want to check condition (2) in signed case, or proceed
- // to usual division in unsigned case.
- BranchInst::Create(DivByZeroBB, IsSigned ? ChkDivMinBB : DivBB, CmpDivZero,
- StartBB->getTerminator());
- StartBB->getTerminator()->eraseFromParent();
-
- // At the moment we have all the control flow created. We just need to
- // insert DIV and PHI (if needed) to get the result value.
- Instruction *DivRes, *FlagRes;
- Instruction *InsPoint = nullptr;
- if (ResultNeeded[0]) {
- BinaryOperator *Div = BinaryOperator::Create(Op, LHS, RHS);
- if (DivWellDefined) {
- // The result value is the result of DIV operation placed right at the
- // original place of the intrinsic.
- Div->insertAfter(II);
- DivRes = Div;
- } else {
- // The result is a PHI-node.
- Div->insertBefore(DivBB->getTerminator());
- PHINode *DivResPN =
- PHINode::Create(LHS->getType(), IsSigned ? 3 : 2, "div.res.phi",
- NextBB->begin());
- DivResPN->addIncoming(Div, DivBB);
- DivResPN->addIncoming(Zero, DivByZeroBB);
- if (IsSigned)
- DivResPN->addIncoming(MinValue, DivMinBB);
- DivRes = DivResPN;
- InsPoint = DivResPN;
- }
- }
-
- // Prepare a value for the second result (flag) if it is needed.
- if (ResultNeeded[1]) {
- Type *FlagTy = II->getType()->getStructElementType(1);
- PHINode *FlagResPN =
- PHINode::Create(FlagTy, IsSigned ? 3 : 2, "div.flag.phi",
- NextBB->begin());
- FlagResPN->addIncoming(Constant::getNullValue(FlagTy), DivBB);
- FlagResPN->addIncoming(Constant::getAllOnesValue(FlagTy), DivByZeroBB);
- if (IsSigned)
- FlagResPN->addIncoming(Constant::getAllOnesValue(FlagTy), DivMinBB);
- FlagRes = FlagResPN;
- if (!InsPoint)
- InsPoint = FlagRes;
- }
-
- // If possible, propagate the results to the user. Otherwise, create alloca,
- // and create a struct with the results on stack.
- if (!BadCase) {
- if (ResultNeeded[0]) {
- for (User *U: ResultsUsers[0]) {
- Instruction *UserInst = dyn_cast<Instruction>(U);
- assert(UserInst && "Unexpected null-instruction");
- UserInst->replaceAllUsesWith(DivRes);
- UserInst->eraseFromParent();
- }
- }
- if (ResultNeeded[1]) {
- for (User *FlagU: ResultsUsers[1]) {
- Instruction *FlagUInst = dyn_cast<Instruction>(FlagU);
- FlagUInst->replaceAllUsesWith(FlagRes);
- FlagUInst->eraseFromParent();
- }
- }
- } else {
- // Create alloca, store our new values to it, and then load the final
- // result from it.
- Constant *Idx0 = ConstantInt::get(Type::getInt32Ty(II->getContext()), 0);
- Constant *Idx1 = ConstantInt::get(Type::getInt32Ty(II->getContext()), 1);
- Value *Idxs_DivRes[2] = {Idx0, Idx0};
- Value *Idxs_FlagRes[2] = {Idx0, Idx1};
- Value *NewRes = new llvm::AllocaInst(II->getType(), 0, "div.res.ptr", II);
- Instruction *ResDivAddr = GetElementPtrInst::Create(NewRes, Idxs_DivRes);
- Instruction *ResFlagAddr =
- GetElementPtrInst::Create(NewRes, Idxs_FlagRes);
- ResDivAddr->insertAfter(InsPoint);
- ResFlagAddr->insertAfter(ResDivAddr);
- StoreInst *StoreResDiv = new StoreInst(DivRes, ResDivAddr);
- StoreInst *StoreResFlag = new StoreInst(FlagRes, ResFlagAddr);
- StoreResDiv->insertAfter(ResFlagAddr);
- StoreResFlag->insertAfter(StoreResDiv);
- LoadInst *LoadRes = new LoadInst(NewRes, "div.res");
- LoadRes->insertAfter(StoreResFlag);
- II->replaceAllUsesWith(LoadRes);
- }
-
- II->eraseFromParent();
- CurInstIterator = StartBB->end();
- ModifiedDT = true;
- return true;
- }
if (II && TLI) {
SmallVector<Value*, 2> PtrOps;
NeedPlus = true;
}
- if (BaseOffs)
- OS << (NeedPlus ? " + " : "") << BaseOffs, NeedPlus = true;
+ if (BaseOffs) {
+ OS << (NeedPlus ? " + " : "")
+ << BaseOffs;
+ NeedPlus = true;
+ }
if (BaseReg) {
OS << (NeedPlus ? " + " : "")
/// \brief Build a truncate instruction.
class TruncBuilder : public TypePromotionAction {
+ Value *Val;
public:
/// \brief Build a truncate instruction of \p Opnd producing a \p Ty
/// result.
/// trunc Opnd to Ty.
TruncBuilder(Instruction *Opnd, Type *Ty) : TypePromotionAction(Opnd) {
IRBuilder<> Builder(Opnd);
- Inst = cast<Instruction>(Builder.CreateTrunc(Opnd, Ty, "promoted"));
- DEBUG(dbgs() << "Do: TruncBuilder: " << *Inst << "\n");
+ Val = Builder.CreateTrunc(Opnd, Ty, "promoted");
+ DEBUG(dbgs() << "Do: TruncBuilder: " << *Val << "\n");
}
- /// \brief Get the built instruction.
- Instruction *getBuiltInstruction() { return Inst; }
+ /// \brief Get the built value.
+ Value *getBuiltValue() { return Val; }
/// \brief Remove the built instruction.
void undo() override {
- DEBUG(dbgs() << "Undo: TruncBuilder: " << *Inst << "\n");
- Inst->eraseFromParent();
+ DEBUG(dbgs() << "Undo: TruncBuilder: " << *Val << "\n");
+ if (Instruction *IVal = dyn_cast<Instruction>(Val))
+ IVal->eraseFromParent();
}
};
/// \brief Build a sign extension instruction.
class SExtBuilder : public TypePromotionAction {
+ Value *Val;
public:
/// \brief Build a sign extension instruction of \p Opnd producing a \p Ty
/// result.
/// sext Opnd to Ty.
SExtBuilder(Instruction *InsertPt, Value *Opnd, Type *Ty)
- : TypePromotionAction(Inst) {
+ : TypePromotionAction(InsertPt) {
IRBuilder<> Builder(InsertPt);
- Inst = cast<Instruction>(Builder.CreateSExt(Opnd, Ty, "promoted"));
- DEBUG(dbgs() << "Do: SExtBuilder: " << *Inst << "\n");
+ Val = Builder.CreateSExt(Opnd, Ty, "promoted");
+ DEBUG(dbgs() << "Do: SExtBuilder: " << *Val << "\n");
}
- /// \brief Get the built instruction.
- Instruction *getBuiltInstruction() { return Inst; }
+ /// \brief Get the built value.
+ Value *getBuiltValue() { return Val; }
/// \brief Remove the built instruction.
void undo() override {
- DEBUG(dbgs() << "Undo: SExtBuilder: " << *Inst << "\n");
- Inst->eraseFromParent();
+ DEBUG(dbgs() << "Undo: SExtBuilder: " << *Val << "\n");
+ if (Instruction *IVal = dyn_cast<Instruction>(Val))
+ IVal->eraseFromParent();
+ }
+ };
+
+ /// \brief Build a zero extension instruction.
+ class ZExtBuilder : public TypePromotionAction {
+ Value *Val;
+ public:
+ /// \brief Build a zero extension instruction of \p Opnd producing a \p Ty
+ /// result.
+ /// zext Opnd to Ty.
+ ZExtBuilder(Instruction *InsertPt, Value *Opnd, Type *Ty)
+ : TypePromotionAction(InsertPt) {
+ IRBuilder<> Builder(InsertPt);
+ Val = Builder.CreateZExt(Opnd, Ty, "promoted");
+ DEBUG(dbgs() << "Do: ZExtBuilder: " << *Val << "\n");
+ }
+
+ /// \brief Get the built value.
+ Value *getBuiltValue() { return Val; }
+
+ /// \brief Remove the built instruction.
+ void undo() override {
+ DEBUG(dbgs() << "Undo: ZExtBuilder: " << *Val << "\n");
+ if (Instruction *IVal = dyn_cast<Instruction>(Val))
+ IVal->eraseFromParent();
}
};
/// Same as Value::mutateType.
void mutateType(Instruction *Inst, Type *NewTy);
/// Same as IRBuilder::createTrunc.
- Instruction *createTrunc(Instruction *Opnd, Type *Ty);
+ Value *createTrunc(Instruction *Opnd, Type *Ty);
/// Same as IRBuilder::createSExt.
- Instruction *createSExt(Instruction *Inst, Value *Opnd, Type *Ty);
+ Value *createSExt(Instruction *Inst, Value *Opnd, Type *Ty);
+ /// Same as IRBuilder::createZExt.
+ Value *createZExt(Instruction *Inst, Value *Opnd, Type *Ty);
/// Same as Instruction::moveBefore.
void moveBefore(Instruction *Inst, Instruction *Before);
/// @}
Actions.push_back(make_unique<TypePromotionTransaction::TypeMutator>(Inst, NewTy));
}
-Instruction *TypePromotionTransaction::createTrunc(Instruction *Opnd,
- Type *Ty) {
+Value *TypePromotionTransaction::createTrunc(Instruction *Opnd,
+ Type *Ty) {
std::unique_ptr<TruncBuilder> Ptr(new TruncBuilder(Opnd, Ty));
- Instruction *I = Ptr->getBuiltInstruction();
+ Value *Val = Ptr->getBuiltValue();
Actions.push_back(std::move(Ptr));
- return I;
+ return Val;
}
-Instruction *TypePromotionTransaction::createSExt(Instruction *Inst,
- Value *Opnd, Type *Ty) {
+Value *TypePromotionTransaction::createSExt(Instruction *Inst,
+ Value *Opnd, Type *Ty) {
std::unique_ptr<SExtBuilder> Ptr(new SExtBuilder(Inst, Opnd, Ty));
- Instruction *I = Ptr->getBuiltInstruction();
+ Value *Val = Ptr->getBuiltValue();
+ Actions.push_back(std::move(Ptr));
+ return Val;
+}
+
+Value *TypePromotionTransaction::createZExt(Instruction *Inst,
+ Value *Opnd, Type *Ty) {
+ std::unique_ptr<ZExtBuilder> Ptr(new ZExtBuilder(Inst, Opnd, Ty));
+ Value *Val = Ptr->getBuiltValue();
Actions.push_back(std::move(Ptr));
- return I;
+ return Val;
}
void TypePromotionTransaction::moveBefore(Instruction *Inst,
static bool MightBeFoldableInst(Instruction *I) {
switch (I->getOpcode()) {
case Instruction::BitCast:
+ case Instruction::AddrSpaceCast:
// Don't touch identity bitcasts.
if (I->getType() == I->getOperand(0)->getType())
return false;
}
/// \brief Utility function to promote the operand of \p SExt when this
- /// operand is a promotable trunc or sext.
+ /// operand is a promotable trunc or sext or zext.
/// \p PromotedInsts maps the instructions to their type before promotion.
/// \p CreatedInsts[out] contains how many non-free instructions have been
/// created to promote the operand of SExt.
/// Should never be called directly.
/// \return The promoted value which is used instead of SExt.
- static Value *promoteOperandForTruncAndSExt(Instruction *SExt,
- TypePromotionTransaction &TPT,
- InstrToOrigTy &PromotedInsts,
- unsigned &CreatedInsts);
+ static Value *promoteOperandForTruncAndAnyExt(Instruction *SExt,
+ TypePromotionTransaction &TPT,
+ InstrToOrigTy &PromotedInsts,
+ unsigned &CreatedInsts);
/// \brief Utility function to promote the operand of \p SExt when this
/// operand is promotable and is not a supported trunc or sext.
bool TypePromotionHelper::canGetThrough(const Instruction *Inst,
Type *ConsideredSExtType,
const InstrToOrigTy &PromotedInsts) {
- // We can always get through sext.
- if (isa<SExtInst>(Inst))
+ // We can always get through sext or zext.
+ if (isa<SExtInst>(Inst) || isa<ZExtInst>(Inst))
return true;
// We can get through binary operator, if it is legal. In other words, the
// SExt or Trunc instructions.
// Return the related handler.
- if (isa<SExtInst>(SExtOpnd) || isa<TruncInst>(SExtOpnd))
- return promoteOperandForTruncAndSExt;
+ if (isa<SExtInst>(SExtOpnd) || isa<TruncInst>(SExtOpnd) ||
+ isa<ZExtInst>(SExtOpnd))
+ return promoteOperandForTruncAndAnyExt;
// Regular instruction.
// Abort early if we will have to insert non-free instructions.
return promoteOperandForOther;
}
-Value *TypePromotionHelper::promoteOperandForTruncAndSExt(
+Value *TypePromotionHelper::promoteOperandForTruncAndAnyExt(
llvm::Instruction *SExt, TypePromotionTransaction &TPT,
InstrToOrigTy &PromotedInsts, unsigned &CreatedInsts) {
// By construction, the operand of SExt is an instruction. Otherwise we cannot
// get through it and this method should not be called.
Instruction *SExtOpnd = cast<Instruction>(SExt->getOperand(0));
- // Replace sext(trunc(opnd)) or sext(sext(opnd))
- // => sext(opnd).
- TPT.setOperand(SExt, 0, SExtOpnd->getOperand(0));
+ Value *ExtVal = SExt;
+ if (isa<ZExtInst>(SExtOpnd)) {
+ // Replace sext(zext(opnd))
+ // => zext(opnd).
+ Value *ZExt =
+ TPT.createZExt(SExt, SExtOpnd->getOperand(0), SExt->getType());
+ TPT.replaceAllUsesWith(SExt, ZExt);
+ TPT.eraseInstruction(SExt);
+ ExtVal = ZExt;
+ } else {
+ // Replace sext(trunc(opnd)) or sext(sext(opnd))
+ // => sext(opnd).
+ TPT.setOperand(SExt, 0, SExtOpnd->getOperand(0));
+ }
CreatedInsts = 0;
// Remove dead code.
if (SExtOpnd->use_empty())
TPT.eraseInstruction(SExtOpnd);
- // Check if the sext is still needed.
- if (SExt->getType() != SExt->getOperand(0)->getType())
- return SExt;
+ // Check if the extension is still needed.
+ Instruction *ExtInst = dyn_cast<Instruction>(ExtVal);
+ if (!ExtInst || ExtInst->getType() != ExtInst->getOperand(0)->getType())
+ return ExtVal;
- // At this point we have: sext ty opnd to ty.
- // Reassign the uses of SExt to the opnd and remove SExt.
- Value *NextVal = SExt->getOperand(0);
- TPT.eraseInstruction(SExt, NextVal);
+ // At this point we have: ext ty opnd to ty.
+ // Reassign the uses of ExtInst to the opnd and remove ExtInst.
+ Value *NextVal = ExtInst->getOperand(0);
+ TPT.eraseInstruction(ExtInst, NextVal);
return NextVal;
}
// All its uses, but SExt, will need to use a truncated value of the
// promoted version.
// Create the truncate now.
- Instruction *Trunc = TPT.createTrunc(SExt, SExtOpnd->getType());
- Trunc->removeFromParent();
- // Insert it just after the definition.
- Trunc->insertAfter(SExtOpnd);
+ Value *Trunc = TPT.createTrunc(SExt, SExtOpnd->getType());
+ if (Instruction *ITrunc = dyn_cast<Instruction>(Trunc)) {
+ ITrunc->removeFromParent();
+ // Insert it just after the definition.
+ ITrunc->insertAfter(SExtOpnd);
+ }
TPT.replaceAllUsesWith(SExtOpnd, Trunc);
// Restore the operand of SExt (which has been replace by the previous call
if (!SExtForOpnd) {
// If yes, create a new one.
DEBUG(dbgs() << "More operands to sext\n");
- SExtForOpnd = TPT.createSExt(SExt, Opnd, SExt->getType());
+ SExtForOpnd =
+ cast<Instruction>(TPT.createSExt(SExt, Opnd, SExt->getType()));
++CreatedInsts;
}
return MatchAddr(AddrInst->getOperand(0), Depth);
return false;
case Instruction::BitCast:
+ case Instruction::AddrSpaceCast:
// BitCast is always a noop, and we can handle it as long as it is
// int->int or pointer->pointer (we don't want int<->fp or something).
if ((AddrInst->getOperand(0)->getType()->isPointerTy() ||
case Instruction::Shl: {
// Can only handle X*C and X << C.
ConstantInt *RHS = dyn_cast<ConstantInt>(AddrInst->getOperand(1));
- if (!RHS) return false;
+ if (!RHS)
+ return false;
int64_t Scale = RHS->getSExtValue();
if (Opcode == Instruction::Shl)
Scale = 1LL << Scale;
return true;
}
case Instruction::SExt: {
+ Instruction *SExt = dyn_cast<Instruction>(AddrInst);
+ if (!SExt)
+ return false;
+
// Try to move this sext out of the way of the addressing mode.
- Instruction *SExt = cast<Instruction>(AddrInst);
// Ask for a method for doing so.
TypePromotionHelper::Action TPH = TypePromotionHelper::getAction(
SExt, InsertedTruncs, TLI, PromotedInsts);
/// Add the ultimately found memory instructions to MemoryUses.
static bool FindAllMemoryUses(Instruction *I,
SmallVectorImpl<std::pair<Instruction*,unsigned> > &MemoryUses,
- SmallPtrSet<Instruction*, 16> &ConsideredInsts,
+ SmallPtrSetImpl<Instruction*> &ConsideredInsts,
const TargetLowering &TLI) {
// If we already considered this instruction, we're done.
if (!ConsideredInsts.insert(I))
Value *&SunkAddr = SunkAddrs[Addr];
if (SunkAddr) {
DEBUG(dbgs() << "CGP: Reusing nonlocal addrmode: " << AddrMode << " for "
- << *MemoryInst);
+ << *MemoryInst << "\n");
if (SunkAddr->getType() != Addr->getType())
SunkAddr = Builder.CreateBitCast(SunkAddr, Addr->getType());
} else if (AddrSinkUsingGEPs || (!AddrSinkUsingGEPs.getNumOccurrences() &&
// By default, we use the GEP-based method when AA is used later. This
// prevents new inttoptr/ptrtoint pairs from degrading AA capabilities.
DEBUG(dbgs() << "CGP: SINKING nonlocal addrmode: " << AddrMode << " for "
- << *MemoryInst);
+ << *MemoryInst << "\n");
Type *IntPtrTy = TLI->getDataLayout()->getIntPtrType(Addr->getType());
Value *ResultPtr = nullptr, *ResultIndex = nullptr;
}
} else {
DEBUG(dbgs() << "CGP: SINKING nonlocal addrmode: " << AddrMode << " for "
- << *MemoryInst);
+ << *MemoryInst << "\n");
Type *IntPtrTy = TLI->getDataLayout()->getIntPtrType(Addr->getType());
Value *Result = nullptr;
// the original IR value was tossed in favor of a constant back when
// the AddrMode was created we need to bail out gracefully if widths
// do not match instead of extending it.
- Instruction *I = dyn_cast<Instruction>(Result);
+ Instruction *I = dyn_cast_or_null<Instruction>(Result);
if (I && (Result != AddrMode.BaseReg))
I->eraseFromParent();
return false;
projects / oota-llvm.git / blobdiff