diff options
Diffstat (limited to 'llvm/lib/Transforms/Vectorize/LoopVectorize.cpp')
| -rw-r--r-- | llvm/lib/Transforms/Vectorize/LoopVectorize.cpp | 407 |
1 files changed, 184 insertions, 223 deletions
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp index 797111276ed..5c74ad5d851 100644 --- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp @@ -888,16 +888,17 @@ private: /// \brief The descriptor for a strided memory access. struct StrideDescriptor { - StrideDescriptor(int Stride, const SCEV *Scev, unsigned Size, + StrideDescriptor(int64_t Stride, const SCEV *Scev, uint64_t Size, unsigned Align) : Stride(Stride), Scev(Scev), Size(Size), Align(Align) {} - StrideDescriptor() : Stride(0), Scev(nullptr), Size(0), Align(0) {} + StrideDescriptor() = default; - int Stride; // The access's stride. It is negative for a reverse access. - const SCEV *Scev; // The scalar expression of this access - unsigned Size; // The size of the memory object. - unsigned Align; // The alignment of this access. + // The access's stride. It is negative for a reverse access. + int64_t Stride = 0; + const SCEV *Scev = nullptr; // The scalar expression of this access + uint64_t Size = 0; // The size of the memory object. + unsigned Align = 0; // The alignment of this access. }; /// \brief A type for holding instructions and their stride descriptors. @@ -2390,8 +2391,8 @@ void InnerLoopVectorizer::vectorizeMemoryInstruction(Instruction *Instr) { if (!Alignment) Alignment = DL.getABITypeAlignment(ScalarDataTy); unsigned AddressSpace = Ptr->getType()->getPointerAddressSpace(); - unsigned ScalarAllocatedSize = DL.getTypeAllocSize(ScalarDataTy); - unsigned VectorElementSize = DL.getTypeStoreSize(DataTy) / VF; + uint64_t ScalarAllocatedSize = DL.getTypeAllocSize(ScalarDataTy); + uint64_t VectorElementSize = DL.getTypeStoreSize(DataTy) / VF; if (SI && Legal->blockNeedsPredication(SI->getParent()) && !Legal->isMaskRequired(SI)) @@ -3031,11 +3032,10 @@ void InnerLoopVectorizer::createEmptyLoop() { // This variable saves the new starting index for the scalar loop. It is used // to test if there are any tail iterations left once the vector loop has // completed. - LoopVectorizationLegality::InductionList::iterator I, E; LoopVectorizationLegality::InductionList *List = Legal->getInductionVars(); - for (I = List->begin(), E = List->end(); I != E; ++I) { - PHINode *OrigPhi = I->first; - InductionDescriptor II = I->second; + for (auto &InductionEntry : *List) { + PHINode *OrigPhi = InductionEntry.first; + InductionDescriptor II = InductionEntry.second; // Create phi nodes to merge from the backedge-taken check block. PHINode *BCResumeVal = PHINode::Create( @@ -3065,8 +3065,8 @@ void InnerLoopVectorizer::createEmptyLoop() { // The old induction's phi node in the scalar body needs the truncated // value. - for (unsigned I = 0, E = LoopBypassBlocks.size(); I != E; ++I) - BCResumeVal->addIncoming(II.getStartValue(), LoopBypassBlocks[I]); + for (BasicBlock *BB : LoopBypassBlocks) + BCResumeVal->addIncoming(II.getStartValue(), BB); OrigPhi->setIncomingValue(BlockIdx, BCResumeVal); } @@ -3107,7 +3107,7 @@ void InnerLoopVectorizer::fixupIVUsers(PHINode *OrigPhi, const InductionDescriptor &II, Value *CountRoundDown, Value *EndValue, BasicBlock *MiddleBlock) { - // There are two kinds of external IV usages - those that use the value + // There are two kinds of external IV usages - those that use the value // computed in the last iteration (the PHI) and those that use the penultimate // value (the value that feeds into the phi from the loop latch). // We allow both, but they, obviously, have different values. @@ -3126,10 +3126,10 @@ void InnerLoopVectorizer::fixupIVUsers(PHINode *OrigPhi, assert(isa<PHINode>(UI) && "Expected LCSSA form"); // One corner case we have to handle is two IVs "chasing" each-other, // that is %IV2 = phi [...], [ %IV1, %latch ] - // In this case, if IV1 has an external use, we need to avoid adding both + // In this case, if IV1 has an external use, we need to avoid adding both // "last value of IV1" and "penultimate value of IV2". Since we don't know // which IV will be handled first, check we haven't handled this user yet. - PHINode *User = cast<PHINode>(UI); + auto *User = cast<PHINode>(UI); if (User->getBasicBlockIndex(MiddleBlock) == -1) User->addIncoming(EndValue, MiddleBlock); break; @@ -3140,13 +3140,13 @@ void InnerLoopVectorizer::fixupIVUsers(PHINode *OrigPhi, // The simplest way to get this is to recompute it from the constituent SCEVs, // that is Start + (Step * (CRD - 1)). for (User *U : OrigPhi->users()) { - Instruction *UI = cast<Instruction>(U); + auto *UI = cast<Instruction>(U); if (!OrigLoop->contains(UI)) { const DataLayout &DL = OrigLoop->getHeader()->getModule()->getDataLayout(); assert(isa<PHINode>(UI) && "Expected LCSSA form"); - PHINode *User = cast<PHINode>(UI); + auto *User = cast<PHINode>(UI); // As above, check we haven't already handled this user. if (User->getBasicBlockIndex(MiddleBlock) != -1) break; @@ -3157,7 +3157,7 @@ void InnerLoopVectorizer::fixupIVUsers(PHINode *OrigPhi, Value *CMO = B.CreateSExtOrTrunc(CountMinusOne, II.getStep()->getType(), "cast.cmo"); Value *Escape = II.transform(B, CMO, PSE.getSE(), DL); - Escape->setName("ind.escape"); + Escape->setName("ind.escape"); User->addIncoming(Escape, MiddleBlock); break; } @@ -3232,11 +3232,11 @@ static unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract, assert(Ty->isVectorTy() && "Can only scalarize vectors"); unsigned Cost = 0; - for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) { + for (unsigned I = 0, E = Ty->getVectorNumElements(); I < E; ++I) { if (Insert) - Cost += TTI.getVectorInstrCost(Instruction::InsertElement, Ty, i); + Cost += TTI.getVectorInstrCost(Instruction::InsertElement, Ty, I); if (Extract) - Cost += TTI.getVectorInstrCost(Instruction::ExtractElement, Ty, i); + Cost += TTI.getVectorInstrCost(Instruction::ExtractElement, Ty, I); } return Cost; @@ -3267,15 +3267,15 @@ static unsigned getVectorCallCost(CallInst *CI, unsigned VF, // Compute corresponding vector type for return value and arguments. Type *RetTy = ToVectorTy(ScalarRetTy, VF); - for (unsigned i = 0, ie = ScalarTys.size(); i != ie; ++i) - Tys.push_back(ToVectorTy(ScalarTys[i], VF)); + for (Type *ScalarTy : ScalarTys) + Tys.push_back(ToVectorTy(ScalarTy, VF)); // Compute costs of unpacking argument values for the scalar calls and // packing the return values to a vector. unsigned ScalarizationCost = getScalarizationOverhead(RetTy, true, false, TTI); - for (unsigned i = 0, ie = Tys.size(); i != ie; ++i) - ScalarizationCost += getScalarizationOverhead(Tys[i], false, true, TTI); + for (Type *Ty : Tys) + ScalarizationCost += getScalarizationOverhead(Ty, false, true, TTI); unsigned Cost = ScalarCallCost * VF + ScalarizationCost; @@ -3305,8 +3305,8 @@ static unsigned getVectorIntrinsicCost(CallInst *CI, unsigned VF, Type *RetTy = ToVectorTy(CI->getType(), VF); SmallVector<Type *, 4> Tys; - for (unsigned i = 0, ie = CI->getNumArgOperands(); i != ie; ++i) - Tys.push_back(ToVectorTy(CI->getArgOperand(i)->getType(), VF)); + for (Value *ArgOperand : CI->arg_operands()) + Tys.push_back(ToVectorTy(ArgOperand->getType(), VF)); FastMathFlags FMF; if (auto *FPMO = dyn_cast<FPMathOperator>(CI)) @@ -3316,13 +3316,13 @@ static unsigned getVectorIntrinsicCost(CallInst *CI, unsigned VF, } static Type *smallestIntegerVectorType(Type *T1, Type *T2) { - IntegerType *I1 = cast<IntegerType>(T1->getVectorElementType()); - IntegerType *I2 = cast<IntegerType>(T2->getVectorElementType()); + auto *I1 = cast<IntegerType>(T1->getVectorElementType()); + auto *I2 = cast<IntegerType>(T2->getVectorElementType()); return I1->getBitWidth() < I2->getBitWidth() ? T1 : T2; } static Type *largestIntegerVectorType(Type *T1, Type *T2) { - IntegerType *I1 = cast<IntegerType>(T1->getVectorElementType()); - IntegerType *I2 = cast<IntegerType>(T2->getVectorElementType()); + auto *I1 = cast<IntegerType>(T1->getVectorElementType()); + auto *I2 = cast<IntegerType>(T2->getVectorElementType()); return I1->getBitWidth() > I2->getBitWidth() ? T1 : T2; } @@ -3335,7 +3335,7 @@ void InnerLoopVectorizer::truncateToMinimalBitwidths() { for (const auto &KV : *MinBWs) { VectorParts &Parts = WidenMap.get(KV.first); for (Value *&I : Parts) { - if (Erased.count(I) || I->use_empty()) + if (Erased.count(I) || I->use_empty() || !isa<Instruction>(I)) continue; Type *OriginalTy = I->getType(); Type *ScalarTruncatedTy = @@ -3345,9 +3345,6 @@ void InnerLoopVectorizer::truncateToMinimalBitwidths() { if (TruncatedTy == OriginalTy) continue; - if (!isa<Instruction>(I)) - continue; - IRBuilder<> B(cast<Instruction>(I)); auto ShrinkOperand = [&](Value *V) -> Value * { if (auto *ZI = dyn_cast<ZExtInst>(V)) @@ -3359,19 +3356,19 @@ void InnerLoopVectorizer::truncateToMinimalBitwidths() { // The actual instruction modification depends on the instruction type, // unfortunately. Value *NewI = nullptr; - if (BinaryOperator *BO = dyn_cast<BinaryOperator>(I)) { + if (auto *BO = dyn_cast<BinaryOperator>(I)) { NewI = B.CreateBinOp(BO->getOpcode(), ShrinkOperand(BO->getOperand(0)), ShrinkOperand(BO->getOperand(1))); cast<BinaryOperator>(NewI)->copyIRFlags(I); - } else if (ICmpInst *CI = dyn_cast<ICmpInst>(I)) { + } else if (auto *CI = dyn_cast<ICmpInst>(I)) { NewI = B.CreateICmp(CI->getPredicate(), ShrinkOperand(CI->getOperand(0)), ShrinkOperand(CI->getOperand(1))); - } else if (SelectInst *SI = dyn_cast<SelectInst>(I)) { + } else if (auto *SI = dyn_cast<SelectInst>(I)) { NewI = B.CreateSelect(SI->getCondition(), ShrinkOperand(SI->getTrueValue()), ShrinkOperand(SI->getFalseValue())); - } else if (CastInst *CI = dyn_cast<CastInst>(I)) { + } else if (auto *CI = dyn_cast<CastInst>(I)) { switch (CI->getOpcode()) { default: llvm_unreachable("Unhandled cast!"); @@ -3389,7 +3386,7 @@ void InnerLoopVectorizer::truncateToMinimalBitwidths() { smallestIntegerVectorType(OriginalTy, TruncatedTy)); break; } - } else if (ShuffleVectorInst *SI = dyn_cast<ShuffleVectorInst>(I)) { + } else if (auto *SI = dyn_cast<ShuffleVectorInst>(I)) { auto Elements0 = SI->getOperand(0)->getType()->getVectorNumElements(); auto *O0 = B.CreateZExtOrTrunc( SI->getOperand(0), VectorType::get(ScalarTruncatedTy, Elements0)); @@ -3465,9 +3462,8 @@ void InnerLoopVectorizer::vectorizeLoop() { DFS.perform(LI); // Vectorize all of the blocks in the original loop. - for (LoopBlocksDFS::RPOIterator bb = DFS.beginRPO(), be = DFS.endRPO(); - bb != be; ++bb) - vectorizeBlockInLoop(*bb, &PHIsToFix); + for (BasicBlock *BB : make_range(DFS.beginRPO(), DFS.endRPO())) + vectorizeBlockInLoop(BB, &PHIsToFix); // Insert truncates and extends for any truncated instructions as hints to // InstCombine. @@ -3827,8 +3823,7 @@ void InnerLoopVectorizer::fixFirstOrderRecurrence(PHINode *Phi) { } // Fix the latch value of the new recurrence in the vector loop. - VecPhi->addIncoming(Incoming, - LI->getLoopFor(LoopVectorBody)->getLoopLatch()); + VecPhi->addIncoming(Incoming, LI->getLoopFor(LoopVectorBody)->getLoopLatch()); // Extract the last vector element in the middle block. This will be the // initial value for the recurrence when jumping to the scalar loop. @@ -3867,10 +3862,8 @@ void InnerLoopVectorizer::fixFirstOrderRecurrence(PHINode *Phi) { } void InnerLoopVectorizer::fixLCSSAPHIs() { - for (BasicBlock::iterator LEI = LoopExitBlock->begin(), - LEE = LoopExitBlock->end(); - LEI != LEE; ++LEI) { - PHINode *LCSSAPhi = dyn_cast<PHINode>(LEI); + for (Instruction &LEI : *LoopExitBlock) { + auto *LCSSAPhi = dyn_cast<PHINode>(&LEI); if (!LCSSAPhi) break; if (LCSSAPhi->getNumIncomingValues() == 1) @@ -4042,17 +4035,17 @@ void InnerLoopVectorizer::widenPHIInstruction( void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) { // For each instruction in the old loop. - for (BasicBlock::iterator it = BB->begin(), e = BB->end(); it != e; ++it) { - VectorParts &Entry = WidenMap.get(&*it); + for (Instruction &I : *BB) { + VectorParts &Entry = WidenMap.get(&I); - switch (it->getOpcode()) { + switch (I.getOpcode()) { case Instruction::Br: // Nothing to do for PHIs and BR, since we already took care of the // loop control flow instructions. continue; case Instruction::PHI: { // Vectorize PHINodes. - widenPHIInstruction(&*it, Entry, UF, VF, PV); + widenPHIInstruction(&I, Entry, UF, VF, PV); continue; } // End of PHI. @@ -4075,10 +4068,10 @@ void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) { case Instruction::Or: case Instruction::Xor: { // Just widen binops. - BinaryOperator *BinOp = dyn_cast<BinaryOperator>(it); + auto *BinOp = cast<BinaryOperator>(&I); setDebugLocFromInst(Builder, BinOp); - VectorParts &A = getVectorValue(it->getOperand(0)); - VectorParts &B = getVectorValue(it->getOperand(1)); + VectorParts &A = getVectorValue(BinOp->getOperand(0)); + VectorParts &B = getVectorValue(BinOp->getOperand(1)); // Use this vector value for all users of the original instruction. for (unsigned Part = 0; Part < UF; ++Part) { @@ -4090,7 +4083,7 @@ void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) { Entry[Part] = V; } - addMetadata(Entry, &*it); + addMetadata(Entry, BinOp); break; } case Instruction::Select: { @@ -4099,16 +4092,16 @@ void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) { // instruction with a scalar condition. Otherwise, use vector-select. auto *SE = PSE.getSE(); bool InvariantCond = - SE->isLoopInvariant(PSE.getSCEV(it->getOperand(0)), OrigLoop); - setDebugLocFromInst(Builder, &*it); + SE->isLoopInvariant(PSE.getSCEV(I.getOperand(0)), OrigLoop); + setDebugLocFromInst(Builder, &I); // The condition can be loop invariant but still defined inside the // loop. This means that we can't just use the original 'cond' value. // We have to take the 'vectorized' value and pick the first lane. // Instcombine will make this a no-op. - VectorParts &Cond = getVectorValue(it->getOperand(0)); - VectorParts &Op0 = getVectorValue(it->getOperand(1)); - VectorParts &Op1 = getVectorValue(it->getOperand(2)); + VectorParts &Cond = getVectorValue(I.getOperand(0)); + VectorParts &Op0 = getVectorValue(I.getOperand(1)); + VectorParts &Op1 = getVectorValue(I.getOperand(2)); Value *ScalarCond = (VF == 1) @@ -4120,36 +4113,36 @@ void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) { InvariantCond ? ScalarCond : Cond[Part], Op0[Part], Op1[Part]); } - addMetadata(Entry, &*it); + addMetadata(Entry, &I); break; } case Instruction::ICmp: case Instruction::FCmp: { // Widen compares. Generate vector compares. - bool FCmp = (it->getOpcode() == Instruction::FCmp); - CmpInst *Cmp = dyn_cast<CmpInst>(it); - setDebugLocFromInst(Builder, &*it); - VectorParts &A = getVectorValue(it->getOperand(0)); - VectorParts &B = getVectorValue(it->getOperand(1)); + bool FCmp = (I.getOpcode() == Instruction::FCmp); + auto *Cmp = dyn_cast<CmpInst>(&I); + setDebugLocFromInst(Builder, Cmp); + VectorParts &A = getVectorValue(Cmp->getOperand(0)); + VectorParts &B = getVectorValue(Cmp->getOperand(1)); for (unsigned Part = 0; Part < UF; ++Part) { Value *C = nullptr; if (FCmp) { C = Builder.CreateFCmp(Cmp->getPredicate(), A[Part], B[Part]); - cast<FCmpInst>(C)->copyFastMathFlags(&*it); + cast<FCmpInst>(C)->copyFastMathFlags(Cmp); } else { C = Builder.CreateICmp(Cmp->getPredicate(), A[Part], B[Part]); } Entry[Part] = C; } - addMetadata(Entry, &*it); + addMetadata(Entry, &I); break; } case Instruction::Store: case Instruction::Load: - vectorizeMemoryInstruction(&*it); + vectorizeMemoryInstruction(&I); break; case Instruction::ZExt: case Instruction::SExt: @@ -4163,8 +4156,8 @@ void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) { case Instruction::Trunc: case Instruction::FPTrunc: case Instruction::BitCast: { - CastInst *CI = dyn_cast<CastInst>(it); - setDebugLocFromInst(Builder, &*it); + auto *CI = dyn_cast<CastInst>(&I); + setDebugLocFromInst(Builder, CI); // Optimize the special case where the source is a constant integer // induction variable. Notice that we can only optimize the 'trunc' case @@ -4175,7 +4168,7 @@ void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) { ID.getConstIntStepValue()) { auto *TruncType = cast<IntegerType>(CI->getType()); widenIntInduction(OldInduction, Entry, TruncType); - addMetadata(Entry, &*it); + addMetadata(Entry, &I); break; } @@ -4183,33 +4176,33 @@ void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) { Type *DestTy = (VF == 1) ? CI->getType() : VectorType::get(CI->getType(), VF); - VectorParts &A = getVectorValue(it->getOperand(0)); + VectorParts &A = getVectorValue(CI->getOperand(0)); for (unsigned Part = 0; Part < UF; ++Part) Entry[Part] = Builder.CreateCast(CI->getOpcode(), A[Part], DestTy); - addMetadata(Entry, &*it); + addMetadata(Entry, &I); break; } case Instruction::Call: { // Ignore dbg intrinsics. - if (isa<DbgInfoIntrinsic>(it)) + if (isa<DbgInfoIntrinsic>(I)) break; - setDebugLocFromInst(Builder, &*it); + setDebugLocFromInst(Builder, &I); Module *M = BB->getParent()->getParent(); - CallInst *CI = cast<CallInst>(it); + auto *CI = cast<CallInst>(&I); StringRef FnName = CI->getCalledFunction()->getName(); Function *F = CI->getCalledFunction(); Type *RetTy = ToVectorTy(CI->getType(), VF); SmallVector<Type *, 4> Tys; - for (unsigned i = 0, ie = CI->getNumArgOperands(); i != ie; ++i) - Tys.push_back(ToVectorTy(CI->getArgOperand(i)->getType(), VF)); + for (Value *ArgOperand : CI->arg_operands()) + Tys.push_back(ToVectorTy(ArgOperand->getType(), VF)); Intrinsic::ID ID = getVectorIntrinsicIDForCall(CI, TLI); if (ID && (ID == Intrinsic::assume || ID == Intrinsic::lifetime_end || ID == Intrinsic::lifetime_start)) { - scalarizeInstruction(&*it); + scalarizeInstruction(&I); break; } // The flag shows whether we use Intrinsic or a usual Call for vectorized @@ -4220,7 +4213,7 @@ void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) { bool UseVectorIntrinsic = ID && getVectorIntrinsicCost(CI, VF, *TTI, TLI) <= CallCost; if (!UseVectorIntrinsic && NeedToScalarize) { - scalarizeInstruction(&*it); + scalarizeInstruction(&I); break; } @@ -4269,13 +4262,13 @@ void InnerLoopVectorizer::vectorizeBlockInLoop(BasicBlock *BB, PhiVector *PV) { Entry[Part] = V; } - addMetadata(Entry, &*it); + addMetadata(Entry, &I); break; } default: // All other instructions are unsupported. Scalarize them. - scalarizeInstruction(&*it); + scalarizeInstruction(&I); break; } // end of switch. } // end of for_each instr. @@ -4306,12 +4299,12 @@ void InnerLoopVectorizer::updateAnalysis() { /// Phi nodes with constant expressions that can trap are not safe to if /// convert. static bool canIfConvertPHINodes(BasicBlock *BB) { - for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) { - PHINode *Phi = dyn_cast<PHINode>(I); + for (Instruction &I : *BB) { + auto *Phi = dyn_cast<PHINode>(&I); if (!Phi) return true; - for (unsigned p = 0, e = Phi->getNumIncomingValues(); p != e; ++p) - if (Constant *C = dyn_cast<Constant>(Phi->getIncomingValue(p))) + for (Value *V : Phi->incoming_values()) + if (auto *C = dyn_cast<Constant>(V)) if (C->canTrap()) return false; } @@ -4330,29 +4323,21 @@ bool LoopVectorizationLegality::canVectorizeWithIfConvert() { SmallPtrSet<Value *, 8> SafePointes; // Collect safe addresses. - for (Loop::block_iterator BI = TheLoop->block_begin(), - BE = TheLoop->block_end(); - BI != BE; ++BI) { - BasicBlock *BB = *BI; - + for (BasicBlock *BB : TheLoop->blocks()) { if (blockNeedsPredication(BB)) continue; - for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) { - if (LoadInst *LI = dyn_cast<LoadInst>(I)) + for (Instruction &I : *BB) { + if (auto *LI = dyn_cast<LoadInst>(&I)) SafePointes.insert(LI->getPointerOperand()); - else if (StoreInst *SI = dyn_cast<StoreInst>(I)) + else if (auto *SI = dyn_cast<StoreInst>(&I)) SafePointes.insert(SI->getPointerOperand()); } } // Collect the blocks that need predication. BasicBlock *Header = TheLoop->getHeader(); - for (Loop::block_iterator BI = TheLoop->block_begin(), - BE = TheLoop->block_end(); - BI != BE; ++BI) { - BasicBlock *BB = *BI; - + for (BasicBlock *BB : TheLoop->blocks()) { // We don't support switch statements inside loops. if (!isa<BranchInst>(BB->getTerminator())) { emitAnalysis(VectorizationReport(BB->getTerminator()) @@ -4570,20 +4555,15 @@ bool LoopVectorizationLegality::canVectorizeInstrs() { F.getFnAttribute("no-nans-fp-math").getValueAsString() == "true"; // For each block in the loop. - for (Loop::block_iterator bb = TheLoop->block_begin(), - be = TheLoop->block_end(); - bb != be; ++bb) { - + for (BasicBlock *BB : TheLoop->blocks()) { // Scan the instructions in the block and look for hazards. - for (BasicBlock::iterator it = (*bb)->begin(), e = (*bb)->end(); it != e; - ++it) { - - if (PHINode *Phi = dyn_cast<PHINode>(it)) { + for (Instruction &I : *BB) { + if (auto *Phi = dyn_cast<PHINode>(&I)) { Type *PhiTy = Phi->getType(); // Check that this PHI type is allowed. if (!PhiTy->isIntegerTy() && !PhiTy->isFloatingPointTy() && !PhiTy->isPointerTy()) { - emitAnalysis(VectorizationReport(&*it) + emitAnalysis(VectorizationReport(Phi) << "loop control flow is not understood by vectorizer"); DEBUG(dbgs() << "LV: Found an non-int non-pointer PHI.\n"); return false; @@ -4592,12 +4572,12 @@ bool LoopVectorizationLegality::canVectorizeInstrs() { // If this PHINode is not in the header block, then we know that we // can convert it to select during if-conversion. No need to check if // the PHIs in this block are induction or reduction variables. - if (*bb != Header) { + if (BB != Header) { // Check that this instruction has no outside users or is an // identified reduction value with an outside user. - if (!hasOutsideLoopUser(TheLoop, &*it, AllowedExit)) + if (!hasOutsideLoopUser(TheLoop, Phi, AllowedExit)) continue; - emitAnalysis(VectorizationReport(&*it) + emitAnalysis(VectorizationReport(Phi) << "value could not be identified as " "an induction or reduction variable"); return false; @@ -4605,7 +4585,7 @@ bool LoopVectorizationLegality::canVectorizeInstrs() { // We only allow if-converted PHIs with exactly two incoming values. if (Phi->getNumIncomingValues() != 2) { - emitAnalysis(VectorizationReport(&*it) + emitAnalysis(VectorizationReport(Phi) << "control flow not understood by vectorizer"); DEBUG(dbgs() << "LV: Found an invalid PHI.\n"); return false; @@ -4634,11 +4614,11 @@ bool LoopVectorizationLegality::canVectorizeInstrs() { // As a last resort, coerce the PHI to a AddRec expression // and re-try classifying it a an induction PHI. if (InductionDescriptor::isInductionPHI(Phi, PSE, ID, true)) { - addInductionPhi(Phi, ID, AllowedExit); + addInductionPhi(Phi, ID, AllowedExit); continue; } - emitAnalysis(VectorizationReport(&*it) + emitAnalysis(VectorizationReport(Phi) << "value that could not be identified as " "reduction is used outside the loop"); DEBUG(dbgs() << "LV: Found an unidentified PHI." << *Phi << "\n"); @@ -4649,12 +4629,12 @@ bool LoopVectorizationLegality::canVectorizeInstrs() { // * Are debug info intrinsics. // * Have a mapping to an IR intrinsic. // * Have a vector version available. - CallInst *CI = dyn_cast<CallInst>(it); + auto *CI = dyn_cast<CallInst>(&I); if (CI && !getVectorIntrinsicIDForCall(CI, TLI) && !isa<DbgInfoIntrinsic>(CI) && !(CI->getCalledFunction() && TLI && TLI->isFunctionVectorizable(CI->getCalledFunction()->getName()))) { - emitAnalysis(VectorizationReport(&*it) + emitAnalysis(VectorizationReport(CI) << "call instruction cannot be vectorized"); DEBUG(dbgs() << "LV: Found a non-intrinsic, non-libfunc callsite.\n"); return false; @@ -4666,7 +4646,7 @@ bool LoopVectorizationLegality::canVectorizeInstrs() { getVectorIntrinsicIDForCall(CI, TLI), 1)) { auto *SE = PSE.getSE(); if (!SE->isLoopInvariant(PSE.getSCEV(CI->getOperand(1)), TheLoop)) { - emitAnalysis(VectorizationReport(&*it) + emitAnalysis(VectorizationReport(CI) << "intrinsic instruction cannot be vectorized"); DEBUG(dbgs() << "LV: Found unvectorizable intrinsic " << *CI << "\n"); return false; @@ -4675,17 +4655,17 @@ bool LoopVectorizationLegality::canVectorizeInstrs() { // Check that the instruction return type is vectorizable. // Also, we can't vectorize extractelement instructions. - if ((!VectorType::isValidElementType(it->getType()) && - !it->getType()->isVoidTy()) || - isa<ExtractElementInst>(it)) { - emitAnalysis(VectorizationReport(&*it) + if ((!VectorType::isValidElementType(I.getType()) && + !I.getType()->isVoidTy()) || + isa<ExtractElementInst>(I)) { + emitAnalysis(VectorizationReport(&I) << "instruction return type cannot be vectorized"); DEBUG(dbgs() << "LV: Found unvectorizable type.\n"); return false; } // Check that the stored type is vectorizable. - if (StoreInst *ST = dyn_cast<StoreInst>(it)) { + if (auto *ST = dyn_cast<StoreInst>(&I)) { Type *T = ST->getValueOperand()->getType(); if (!VectorType::isValidElementType(T)) { emitAnalysis(VectorizationReport(ST) @@ -4698,16 +4678,16 @@ bool LoopVectorizationLegality::canVectorizeInstrs() { // This applies to floating-point math operations and calls, not memory // operations, shuffles, or casts, as they don't change precision or // semantics. - } else if (it->getType()->isFloatingPointTy() && - (CI || it->isBinaryOp()) && !it->hasUnsafeAlgebra()) { + } else if (I.getType()->isFloatingPointTy() && (CI || I.isBinaryOp()) && + !I.hasUnsafeAlgebra()) { DEBUG(dbgs() << "LV: Found FP op with unsafe algebra.\n"); Hints->setPotentiallyUnsafe(); } // Reduction instructions are allowed to have exit users. // All other instructions must not have external users. - if (hasOutsideLoopUser(TheLoop, &*it, AllowedExit)) { - emitAnalysis(VectorizationReport(&*it) + if (hasOutsideLoopUser(TheLoop, &I, AllowedExit)) { + emitAnalysis(VectorizationReport(&I) << "value cannot be used outside the loop"); return false; } @@ -4755,7 +4735,7 @@ void LoopVectorizationLegality::collectLoopUniforms() { // Also add all consecutive pointer values; these values will be uniform // after vectorization (and subsequent cleanup). - for (auto *BB : TheLoop->getBlocks()) { + for (auto *BB : TheLoop->blocks()) { for (auto &I : *BB) { if (I.getType()->isPointerTy() && isConsecutivePtr(&I)) { Worklist.insert(&I); @@ -4775,8 +4755,8 @@ void LoopVectorizationLegality::collectLoopUniforms() { for (auto OV : I->operand_values()) { if (isOutOfScope(OV)) continue; - Instruction *OI = cast<Instruction>(OV); - if (std::all_of(OI->user_begin(), OI->user_end(), [&](User *U) -> bool { + auto *OI = cast<Instruction>(OV); + if (all_of(OI->users(), [&](User *U) -> bool { return isOutOfScope(U) || Worklist.count(cast<Instruction>(U)); })) { Worklist.insert(OI); @@ -4795,16 +4775,15 @@ void LoopVectorizationLegality::collectLoopUniforms() { for (auto &Induction : *getInductionVars()) { auto *PN = Induction.first; auto *UpdateV = PN->getIncomingValueForBlock(TheLoop->getLoopLatch()); - if (std::all_of(PN->user_begin(), PN->user_end(), - [&](User *U) -> bool { - return U == UpdateV || isOutOfScope(U) || - Worklist.count(cast<Instruction>(U)); - }) && - std::all_of(UpdateV->user_begin(), UpdateV->user_end(), - [&](User *U) -> bool { - return U == PN || isOutOfScope(U) || - Worklist.count(cast<Instruction>(U)); - })) { + if (all_of(PN->users(), + [&](User *U) -> bool { + return U == UpdateV || isOutOfScope(U) || + Worklist.count(cast<Instruction>(U)); + }) && + all_of(UpdateV->users(), [&](User *U) -> bool { + return U == PN || isOutOfScope(U) || + Worklist.count(cast<Instruction>(U)); + })) { Worklist.insert(cast<Instruction>(PN)); Worklist.insert(cast<Instruction>(UpdateV)); DEBUG(dbgs() << "LV: Found uniform instruction: " << *PN << "\n"); @@ -4859,17 +4838,16 @@ bool LoopVectorizationLegality::blockCanBePredicated( BasicBlock *BB, SmallPtrSetImpl<Value *> &SafePtrs) { const bool IsAnnotatedParallel = TheLoop->isAnnotatedParallel(); - for (BasicBlock::iterator it = BB->begin(), e = BB->end(); it != e; ++it) { + for (Instruction &I : *BB) { // Check that we don't have a constant expression that can trap as operand. - for (Instruction::op_iterator OI = it->op_begin(), OE = it->op_end(); - OI != OE; ++OI) { - if (Constant *C = dyn_cast<Constant>(*OI)) + for (Value *Operand : I.operands()) { + if (auto *C = dyn_cast<Constant>(Operand)) if (C->canTrap()) return false; } // We might be able to hoist the load. - if (it->mayReadFromMemory()) { - LoadInst *LI = dyn_cast<LoadInst>(it); + if (I.mayReadFromMemory()) { + auto *LI = dyn_cast<LoadInst>(&I); if (!LI) return false; if (!SafePtrs.count(LI->getPointerOperand())) { @@ -4886,8 +4864,8 @@ bool LoopVectorizationLegality::blockCanBePredicated( } // We don't predicate stores at the moment. - if (it->mayWriteToMemory()) { - StoreInst *SI = dyn_cast<StoreInst>(it); + if (I.mayWriteToMemory()) { + auto *SI = dyn_cast<StoreInst>(&I); // We only support predication of stores in basic blocks with one // predecessor. if (!SI) @@ -4908,11 +4886,11 @@ bool LoopVectorizationLegality::blockCanBePredicated( !isSinglePredecessor) return false; } - if (it->mayThrow()) + if (I.mayThrow()) return false; // The instructions below can trap. - switch (it->getOpcode()) { + switch (I.getOpcode()) { default: continue; case Instruction::UDiv: @@ -4940,9 +4918,7 @@ void InterleavedAccessInfo::collectConstStridedAccesses( // AccessList. LoopBlocksDFS DFS(TheLoop); DFS.perform(LI); - for (LoopBlocksDFS::RPOIterator I = DFS.beginRPO(), E = DFS.endRPO(); I != E; - ++I) { - BasicBlock *BB = *I; + for (BasicBlock *BB : make_range(DFS.beginRPO(), DFS.endRPO())) { bool IsPred = LoopAccessInfo::blockNeedsPredication(BB, TheLoop, DT); for (auto &I : *BB) { @@ -4961,15 +4937,15 @@ void InterleavedAccessInfo::collectConstStridedAccesses( auto &DL = TheLoop->getHeader()->getModule()->getDataLayout(); for (auto I : AccessList) { - LoadInst *LI = dyn_cast<LoadInst>(I); - StoreInst *SI = dyn_cast<StoreInst>(I); + auto *LI = dyn_cast<LoadInst>(I); + auto *SI = dyn_cast<StoreInst>(I); Value *Ptr = LI ? LI->getPointerOperand() : SI->getPointerOperand(); - int Stride = getPtrStride(PSE, Ptr, TheLoop, Strides); + int64_t Stride = getPtrStride(PSE, Ptr, TheLoop, Strides); const SCEV *Scev = replaceSymbolicStrideSCEV(PSE, Strides, Ptr); PointerType *PtrTy = dyn_cast<PointerType>(Ptr->getType()); - unsigned Size = DL.getTypeAllocSize(PtrTy->getElementType()); + uint64_t Size = DL.getTypeAllocSize(PtrTy->getElementType()); // An alignment of 0 means target ABI alignment. unsigned Align = LI ? LI->getAlignment() : SI->getAlignment(); @@ -5124,16 +5100,16 @@ void InterleavedAccessInfo::analyzeInterleaving( if (!DistToA) continue; - int DistanceToA = DistToA->getAPInt().getSExtValue(); + int64_t DistanceToA = DistToA->getAPInt().getSExtValue(); // Skip if the distance is not multiple of size as they are not in the // same group. - if (DistanceToA % static_cast<int>(DesA.Size)) + if (DistanceToA % static_cast<int64_t>(DesA.Size)) continue; // The index of B is the index of A plus the related index to A. int IndexB = - Group->getIndex(A) + DistanceToA / static_cast<int>(DesA.Size); + Group->getIndex(A) + DistanceToA / static_cast<int64_t>(DesA.Size); // Try to insert B into the group. if (Group->insertMember(B, IndexB, DesB.Align)) { @@ -5339,26 +5315,22 @@ LoopVectorizationCostModel::getSmallestAndWidestTypes() { const DataLayout &DL = TheFunction->getParent()->getDataLayout(); // For each block. - for (Loop::block_iterator bb = TheLoop->block_begin(), - be = TheLoop->block_end(); - bb != be; ++bb) { - BasicBlock *BB = *bb; - + for (BasicBlock *BB : TheLoop->blocks()) { // For each instruction in the loop. - for (BasicBlock::iterator it = BB->begin(), e = BB->end(); it != e; ++it) { - Type *T = it->getType(); + for (Instruction &I : *BB) { + Type *T = I.getType(); // Skip ignored values. - if (ValuesToIgnore.count(&*it)) + if (ValuesToIgnore.count(&I)) continue; // Only examine Loads, Stores and PHINodes. - if (!isa<LoadInst>(it) && !isa<StoreInst>(it) && !isa<PHINode>(it)) + if (!isa<LoadInst>(I) && !isa<StoreInst>(I) && !isa<PHINode>(I)) continue; // Examine PHI nodes that are reduction variables. Update the type to // account for the recurrence type. - if (PHINode *PN = dyn_cast<PHINode>(it)) { + if (auto *PN = dyn_cast<PHINode>(&I)) { if (!Legal->isReductionVariable(PN)) continue; RecurrenceDescriptor RdxDesc = (*Legal->getReductionVars())[PN]; @@ -5366,13 +5338,13 @@ LoopVectorizationCostModel::getSmallestAndWidestTypes() { } // Examine the stored values. - if (StoreInst *ST = dyn_cast<StoreInst>(it)) + if (auto *ST = dyn_cast<StoreInst>(&I)) T = ST->getValueOperand()->getType(); // Ignore loaded pointer types and stored pointer types that are not // consecutive. However, we do want to take consecutive stores/loads of // pointer vectors into account. - if (T->isPointerTy() && !isConsecutiveLoadOrStore(&*it)) + if (T->isPointerTy() && !isConsecutiveLoadOrStore(&I)) continue; MinWidth = std::min(MinWidth, @@ -5576,16 +5548,14 @@ LoopVectorizationCostModel::calculateRegisterUsage(ArrayRef<unsigned> VFs) { SmallPtrSet<Value *, 8> LoopInvariants; unsigned Index = 0; - for (LoopBlocksDFS::RPOIterator bb = DFS.beginRPO(), be = DFS.endRPO(); - bb != be; ++bb) { - RU.NumInstructions += (*bb)->size(); - for (Instruction &I : **bb) { + for (BasicBlock *BB : make_range(DFS.beginRPO(), DFS.endRPO())) { + RU.NumInstructions += BB->size(); + for (Instruction &I : *BB) { IdxToInstr[Index++] = &I; // Save the end location of each USE. - for (unsigned i = 0; i < I.getNumOperands(); ++i) { - Value *U = I.getOperand(i); - Instruction *Instr = dyn_cast<Instruction>(U); + for (Value *U : I.operands()) { + auto *Instr = dyn_cast<Instruction>(U); // Ignore non-instruction values such as arguments, constants, etc. if (!Instr) @@ -5609,9 +5579,8 @@ LoopVectorizationCostModel::calculateRegisterUsage(ArrayRef<unsigned> VFs) { DenseMap<unsigned, InstrList> TransposeEnds; // Transpose the EndPoints to a list of values that end at each index. - for (IntervalMap::iterator it = EndPoint.begin(), e = EndPoint.end(); it != e; - ++it) - TransposeEnds[it->second].push_back(it->first); + for (auto &Interval : EndPoint) + TransposeEnds[Interval.second].push_back(Interval.first); SmallSet<Instruction *, 8> OpenIntervals; @@ -5644,8 +5613,8 @@ LoopVectorizationCostModel::calculateRegisterUsage(ArrayRef<unsigned> VFs) { // Remove all of the instructions that end at this location. InstrList &List = TransposeEnds[i]; - for (unsigned int j = 0, e = List.size(); j < e; ++j) - OpenIntervals.erase(List[j]); + for (Instruction *ToRemove : List) + OpenIntervals.erase(ToRemove); // Skip ignored values. if (ValuesToIgnore.count(I)) @@ -5703,23 +5672,20 @@ LoopVectorizationCostModel::expectedCost(unsigned VF) { VectorizationCostTy Cost; // For each block. - for (Loop::block_iterator bb = TheLoop->block_begin(), - be = TheLoop->block_end(); - bb != be; ++bb) { + for (BasicBlock *BB : TheLoop->blocks()) { VectorizationCostTy BlockCost; - BasicBlock *BB = *bb; // For each instruction in the old loop. - for (BasicBlock::iterator it = BB->begin(), e = BB->end(); it != e; ++it) { + for (Instruction &I : *BB) { // Skip dbg intrinsics. - if (isa<DbgInfoIntrinsic>(it)) + if (isa<DbgInfoIntrinsic>(I)) continue; // Skip ignored values. - if (ValuesToIgnore.count(&*it)) + if (ValuesToIgnore.count(&I)) continue; - VectorizationCostTy C = getInstructionCost(&*it, VF); + VectorizationCostTy C = getInstructionCost(&I, VF); // Check if we should override the cost. if (ForceTargetInstructionCost.getNumOccurrences() > 0) @@ -5728,13 +5694,13 @@ LoopVectorizationCostModel::expectedCost(unsigned VF) { BlockCost.first += C.first; BlockCost.second |= C.second; DEBUG(dbgs() << "LV: Found an estimated cost of " << C.first << " for VF " - << VF << " For instruction: " << *it << '\n'); + << VF << " For instruction: " << I << '\n'); } // We assume that if-converted blocks have a 50% chance of being executed. // When the code is scalar then some of the blocks are avoided due to CF. // When the code is vectorized we execute all code paths. - if (VF == 1 && Legal->blockNeedsPredication(*bb)) + if (VF == 1 && Legal->blockNeedsPredication(BB)) BlockCost.first /= 2; Cost.first += BlockCost.first; @@ -5752,7 +5718,7 @@ LoopVectorizationCostModel::expectedCost(unsigned VF) { /// Using gather/scatter is possible when it is supported by target. static bool isGatherOrScatterLegal(Instruction *I, Value *Ptr, LoopVectorizationLegality *Legal) { - Type *DataTy = cast<PointerType>(Ptr->getType())->getElementType(); + auto *DataTy = cast<PointerType>(Ptr->getType())->getElementType(); return (isa<LoadInst>(I) && Legal->isLegalMaskedGather(DataTy)) || (isa<StoreInst>(I) && Legal->isLegalMaskedScatter(DataTy)); } @@ -5770,7 +5736,7 @@ static bool isLikelyComplexAddressComputation(Value *Ptr, LoopVectorizationLegality *Legal, ScalarEvolution *SE, const Loop *TheLoop) { - GetElementPtrInst *Gep = dyn_cast<GetElementPtrInst>(Ptr); + auto *Gep = dyn_cast<GetElementPtrInst>(Ptr); if (!Gep) return true; @@ -5795,7 +5761,7 @@ static bool isLikelyComplexAddressComputation(Value *Ptr, // Check the step is constant. const SCEV *Step = AddRec->getStepRecurrence(*SE); // Calculate the pointer stride and check if it is consecutive. - const SCEVConstant *C = dyn_cast<SCEVConstant>(Step); + const auto *C = dyn_cast<SCEVConstant>(Step); if (!C) return true; @@ -6008,8 +5974,8 @@ unsigned LoopVectorizationCostModel::getInstructionCost(Instruction *I, bool Reverse = ConsecutiveStride < 0; const DataLayout &DL = I->getModule()->getDataLayout(); - unsigned ScalarAllocatedSize = DL.getTypeAllocSize(ValTy); - unsigned VectorElementSize = DL.getTypeStoreSize(VectorTy) / VF; + uint64_t ScalarAllocatedSize = DL.getTypeAllocSize(ValTy); + uint64_t VectorElementSize = DL.getTypeStoreSize(VectorTy) / VF; if ((!ConsecutiveStride && !UseGatherOrScatter) || ScalarAllocatedSize != VectorElementSize) { bool IsComplexComputation = @@ -6156,11 +6122,11 @@ Pass *createLoopVectorizePass(bool NoUnrolling, bool AlwaysVectorize) { bool LoopVectorizationCostModel::isConsecutiveLoadOrStore(Instruction *Inst) { // Check for a store. - if (StoreInst *ST = dyn_cast<StoreInst>(Inst)) + if (auto *ST = dyn_cast<StoreInst>(Inst)) return Legal->isConsecutivePtr(ST->getPointerOperand()) != 0; // Check for a load. - if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) + if (auto *LI = dyn_cast<LoadInst>(Inst)) return Legal->isConsecutivePtr(LI->getPointerOperand()) != 0; return false; @@ -6191,15 +6157,13 @@ void LoopVectorizationCostModel::collectValuesToIgnore() { // the loop header PHI, or by GEPs. // FIXME: Need precise def-use analysis to determine if this instruction // variable will be vectorized. - if (std::all_of(PN->user_begin(), PN->user_end(), - [&](const User *U) -> bool { - return U == UpdateV || isa<GetElementPtrInst>(U); - }) && - std::all_of(UpdateV->user_begin(), UpdateV->user_end(), - [&](const User *U) -> bool { - return U == PN || isa<ICmpInst>(U) || - isa<GetElementPtrInst>(U); - })) { + if (all_of(PN->users(), + [&](const User *U) -> bool { + return U == UpdateV || isa<GetElementPtrInst>(U); + }) && + all_of(UpdateV->users(), [&](const User *U) -> bool { + return U == PN || isa<ICmpInst>(U) || isa<GetElementPtrInst>(U); + })) { VecValuesToIgnore.insert(PN); VecValuesToIgnore.insert(UpdateV); } @@ -6207,9 +6171,8 @@ void LoopVectorizationCostModel::collectValuesToIgnore() { // Ignore instructions that will not be vectorized. // This is for when VF > 1. - for (auto bb = TheLoop->block_begin(), be = TheLoop->block_end(); bb != be; - ++bb) { - for (auto &Inst : **bb) { + for (BasicBlock *BB : TheLoop->blocks()) { + for (auto &Inst : *BB) { switch (Inst.getOpcode()) case Instruction::GetElementPtr: { // Ignore GEP if its last operand is an induction variable so that it is @@ -6249,9 +6212,7 @@ void InnerLoopUnroller::scalarizeInstruction(Instruction *Instr, setDebugLocFromInst(Builder, Instr); // Find all of the vectorized parameters. - for (unsigned op = 0, e = Instr->getNumOperands(); op != e; ++op) { - Value *SrcOp = Instr->getOperand(op); - + for (Value *SrcOp : Instr->operands()) { // If we are accessing the old induction variable, use the new one. if (SrcOp == OldInduction) { Params.push_back(getVectorValue(SrcOp)); @@ -6336,7 +6297,7 @@ void InnerLoopUnroller::scalarizeInstruction(Instruction *Instr, } void InnerLoopUnroller::vectorizeMemoryInstruction(Instruction *Instr) { - StoreInst *SI = dyn_cast<StoreInst>(Instr); + auto *SI = dyn_cast<StoreInst>(Instr); bool IfPredicateStore = (SI && Legal->blockNeedsPredication(SI->getParent())); return scalarizeInstruction(Instr, IfPredicateStore); @@ -6363,9 +6324,9 @@ static void AddRuntimeUnrollDisableMetaData(Loop *L) { if (LoopID) { // First find existing loop unrolling disable metadata. for (unsigned i = 1, ie = LoopID->getNumOperands(); i < ie; ++i) { - MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i)); + auto *MD = dyn_cast<MDNode>(LoopID->getOperand(i)); if (MD) { - const MDString *S = dyn_cast<MDString>(MD->getOperand(0)); + const auto *S = dyn_cast<MDString>(MD->getOperand(0)); IsUnrollMetadata = S && S->getString().startswith("llvm.loop.unroll.disable"); } |
