[SCEV] Apply a single debug loc when expanding a SCEV

[vsk]

Summary

The SCEV expander currently applies debug locations to generated code
based on which location is set at the insertion point. This isn't always
the correct location to apply (see PR25630).

Following the suggestion in the bug report, this patch solves the
problem by introducing an overload of expandCodeFor() which accepts a
DebugLoc. This single location is applied to all instructions generated
while expanding a SCEV.

The existing expand...() methods are updated to use a special location
which conveys that line table information for the expanded code is
unknown. If the function has debug information attached, this special
location is <file>:0:0. Otherwise, the location is empty. The end result
should be conservatively correct.

The existing expand...() methods are also deprecated. My plan is to
audit calls to the deprecated methods and replace them, one-by-one, by
calls which set an appropriate DebugLoc.

Testing: check-llvm

Depends on D39982

[aprantl]

include/llvm/Analysis/ScalarEvolutionExpander.h

180

I think DebugLoc is already a value type, so there is no point in passing it by reference.

[aprantl]

unittests/Analysis/ScalarEvolutionTest.cpp

32

is this used anywhere?
the coding standard wants functions to begin with lower-case letters.

[vsk]

• Pass DebugLoc by value, and add a comment explaining what the PrintTo test helper does.

include/llvm/Analysis/ScalarEvolutionExpander.h

180

Will fix.

unittests/Analysis/ScalarEvolutionTest.cpp

32

Yes, it's used by gtest. I'll add a comment.

[aprantl]

include/llvm/Analysis/ScalarEvolutionExpander.h

182

shouldn't this be \deprecated with a backslash? and come before the declaration?

[vsk]

include/llvm/Analysis/ScalarEvolutionExpander.h

182

Ouch, I forgot the backslash. I'm not sure what you mean by 'come before the declaration' though - it looks like it's before the declaration already.

[aprantl]

include/llvm/Analysis/ScalarEvolutionExpander.h

182

it does indeed, sorry.

include/llvm/Analysis/ScalarEvolutionExpander.h

namespace llvm {
   /// in canonical form.
   ///
   /// Clients should create an instance of this class when rewriting is needed,
   /// and destroy it when finished to allow the release of the associated
   /// memory.
   class SCEVExpander : public SCEVVisitor<SCEVExpander, Value*> {
     ScalarEvolution &SE;
     const DataLayout &DL;
+    DebugLoc CurDbgLoc;
 
     // New instructions receive a name to identifies them with the current pass.
     const char* IVName;
 
     // InsertedExpressions caches Values for reuse, so must track RAUW.
     DenseMap<std::pair<const SCEV *, Instruction *>, TrackingVH<Value>>
         InsertedExpressions;
 
class SCEVExpander : public SCEVVisitor<SCEVExpander, Value*> {
     // the object is destroyed. This includes the debug location.  Duplicated
     // from InsertPointGuard to add SetInsertPoint() which is used to updated
     // InsertPointGuards stack when insert points are moved during SCEV
     // expansion.
     class SCEVInsertPointGuard {
       IRBuilderBase &Builder;
       AssertingVH<BasicBlock> Block;
       BasicBlock::iterator Point;
-      DebugLoc DbgLoc;
       SCEVExpander *SE;
 
       SCEVInsertPointGuard(const SCEVInsertPointGuard &) = delete;
       SCEVInsertPointGuard &operator=(const SCEVInsertPointGuard &) = delete;
 
     public:
       SCEVInsertPointGuard(IRBuilderBase &B, SCEVExpander *SE)
           : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()),
-            DbgLoc(B.getCurrentDebugLocation()), SE(SE) {
+            SE(SE) {
         SE->InsertPointGuards.push_back(this);
       }
 
       ~SCEVInsertPointGuard() {
         // These guards should always created/destroyed in FIFO order since they
         // are used to guard lexically scoped blocks of code in
         // ScalarEvolutionExpander.
         assert(SE->InsertPointGuards.back() == this);
         SE->InsertPointGuards.pop_back();
         Builder.restoreIP(IRBuilderBase::InsertPoint(Block, Point));
-        Builder.SetCurrentDebugLocation(DbgLoc);
       }
 
       BasicBlock::iterator GetInsertPoint() const { return Point; }
       void SetInsertPoint(BasicBlock::iterator I) { Point = I; }
     };
 
     /// Stack of pointers to saved insert points, used to keep insert points
     /// consistent when instructions are moved.
bool isHighCostExpansion(const SCEV *Expr, Loop *L,
       SmallPtrSet<const SCEV *, 8> Processed;
       return isHighCostExpansionHelper(Expr, L, At, Processed);
     }
 
     /// This method returns the canonical induction variable of the specified
     /// type for the specified loop (inserting one if there is none).  A
     /// canonical induction variable starts at zero and steps by one on each
     /// iteration.
+    PHINode *getOrInsertCanonicalInductionVariable(const Loop *L,
+                                                   DebugLoc DbgLoc, Type *Ty);
+
+    /// deprecated{Please use the overload which requires a DebugLoc.}
     PHINode *getOrInsertCanonicalInductionVariable(const Loop *L, Type *Ty);
 
     /// Return the induction variable increment's IV operand.
     Instruction *getIVIncOperand(Instruction *IncV, Instruction *InsertPos,
                                  bool allowScale);
 
     /// Utility for hoisting an IV increment.
     bool hoistIVInc(Instruction *IncV, Instruction *InsertPos);
 
     /// replace congruent phis with their most canonical representative. Return
     /// the number of phis eliminated.
     unsigned replaceCongruentIVs(Loop *L, const DominatorTree *DT,
                                  SmallVectorImpl<WeakTrackingVH> &DeadInsts,
                                  const TargetTransformInfo *TTI = nullptr);
 
     /// Insert code to directly compute the specified SCEV expression into the
     /// program.  The inserted code is inserted into the specified block.
+    Value *expandCodeFor(const SCEV *SH, DebugLoc DbgLoc, Type *Ty,
+                         Instruction *I);
+
+    /// deprecated{Please use the overload which requires a DebugLoc.}
     Value *expandCodeFor(const SCEV *SH, Type *Ty, Instruction *I);
 
     /// Insert code to directly compute the specified SCEV expression into the
     /// program.  The inserted code is inserted into the SCEVExpander's current
     /// insertion point. If a type is specified, the result will be expanded to
     /// have that type, with a cast if necessary.
-    Value *expandCodeFor(const SCEV *SH, Type *Ty = nullptr);
+    Value *expandCodeFor(const SCEV *SH, DebugLoc DbgLoc, Type *Ty = nullptr);
 
+    /// deprecated{Please use the overload which requires a DebugLoc.}
+    Value *expandCodeFor(const SCEV *SH, Type *Ty = nullptr);
 
     /// Generates a code sequence that evaluates this predicate.  The inserted
     /// instructions will be at position \p Loc.  The result will be of type i1
     /// and will have a value of 0 when the predicate is false and 1 otherwise.
+    Value *expandCodeForPredicate(const SCEVPredicate *Pred, DebugLoc DbgLoc,
+                                  Instruction *Loc);
+
+    /// deprecated{Please use the overload which requires a DebugLoc.}
     Value *expandCodeForPredicate(const SCEVPredicate *Pred, Instruction *Loc);
 
     /// A specialized variant of expandCodeForPredicate, handling the case when
     /// we are expanding code for a SCEVEqualPredicate.
+    Value *expandEqualPredicate(const SCEVEqualPredicate *Pred, DebugLoc DbgLoc,
+                                Instruction *Loc);
+
+    /// deprecated{Please use the overload which requires a DebugLoc.}
     Value *expandEqualPredicate(const SCEVEqualPredicate *Pred,
                                 Instruction *Loc);
 
     /// Generates code that evaluates if the \p AR expression will overflow.
+    Value *generateOverflowCheck(const SCEVAddRecExpr *AR, DebugLoc DbgLoc,
+                                 Instruction *Loc, bool Signed);
+
+    /// deprecated{Please use the overload which requires a DebugLoc.}
     Value *generateOverflowCheck(const SCEVAddRecExpr *AR, Instruction *Loc,
                                  bool Signed);
 
     /// A specialized variant of expandCodeForPredicate, handling the case when
     /// we are expanding code for a SCEVWrapPredicate.
+    Value *expandWrapPredicate(const SCEVWrapPredicate *P, DebugLoc DbgLoc,
+                               Instruction *Loc);
+
+    /// deprecated{Please use the overload which requires a DebugLoc.}
     Value *expandWrapPredicate(const SCEVWrapPredicate *P, Instruction *Loc);
 
     /// A specialized variant of expandCodeForPredicate, handling the case when
     /// we are expanding code for a SCEVUnionPredicate.
+    Value *expandUnionPredicate(const SCEVUnionPredicate *Pred, DebugLoc DbgLoc,
+                                Instruction *Loc);
+
+    /// deprecated{Please use the overload which requires a DebugLoc.}
     Value *expandUnionPredicate(const SCEVUnionPredicate *Pred,
                                 Instruction *Loc);
 
+    /// Get the debug location which should be used for instructions without
+    /// a clear correspondence to a source location.
+    DebugLoc getUnknownDebugLocation(Instruction *Loc = nullptr) {
+      return IRBuilderBase::getUnknownDebugLocation(Loc);
+    }
+
     /// Set the current IV increment loop and position.
     void setIVIncInsertPos(const Loop *L, Instruction *Pos) {
       assert(!CanonicalMode &&
              "IV increment positions are not supported in CanonicalMode");
       IVIncInsertLoop = L;
       IVIncInsertPos = Pos;
     }
 
#endif
     void disableCanonicalMode() { CanonicalMode = false; }
 
     void enableLSRMode() { LSRMode = true; }
 
     /// Set the current insertion point. This is useful if multiple calls to
     /// expandCodeFor() are going to be made with the same insert point and the
     /// insert point may be moved during one of the expansions (e.g. if the
     /// insert point is not a block terminator).
+    ///
+    /// Note: This does not change the current debug location.
     void setInsertPoint(Instruction *IP) {
       assert(IP);
-      Builder.SetInsertPoint(IP);
+      Builder.setInsertPoint(IP, CurDbgLoc);
     }
 
     /// Clear the current insertion point. This is useful if the instruction
     /// that had been serving as the insertion point may have been deleted.
     void clearInsertPoint() {
       Builder.ClearInsertionPoint();
     }
 
PHINode *getAddRecExprPHILiterally(const SCEVAddRecExpr *Normalized,
                                        bool &InvertStep);
     Value *expandIVInc(PHINode *PN, Value *StepV, const Loop *L,
                        Type *ExpandTy, Type *IntTy, bool useSubtract);
 
     void hoistBeforePos(DominatorTree *DT, Instruction *InstToHoist,
                         Instruction *Pos, PHINode *LoopPhi);
 
     void fixupInsertPoints(Instruction *I);
+
+    void setInsertPoint(BasicBlock *BB, BasicBlock::iterator I);
+
+    void setDbgLoc(DebugLoc DbgLoc);
+
+    void setInsertPointAndDbgLoc(Instruction *I, DebugLoc DbgLoc);
   };
 }
 
 #endif

lib/Analysis/ScalarEvolutionExpander.cpp

for (; ScanLimit; --IP, --ScanLimit) {
       if (IP->getOpcode() == (unsigned)Opcode && IP->getOperand(0) == LHS &&
           IP->getOperand(1) == RHS)
         return &*IP;
       if (IP == BlockBegin) break;
     }
   }
 
   // Save the original insertion point so we can restore it when we're done.
-  DebugLoc Loc = Builder.GetInsertPoint()->getDebugLoc();
   SCEVInsertPointGuard Guard(Builder, this);
 
   // Move the insertion point out of as many loops as we can.
   while (const Loop *L = SE.LI.getLoopFor(Builder.GetInsertBlock())) {
     if (!L->isLoopInvariant(LHS) || !L->isLoopInvariant(RHS)) break;
     BasicBlock *Preheader = L->getLoopPreheader();
     if (!Preheader) break;
 
     // Ok, move up a level.
-    Builder.SetInsertPoint(Preheader->getTerminator());
+    setInsertPoint(Preheader->getTerminator());
   }
 
   // If we haven't found this binop, insert it.
   Instruction *BO = cast<Instruction>(Builder.CreateBinOp(Opcode, LHS, RHS));
-  BO->setDebugLoc(Loc);
   rememberInstruction(BO);
 
   return BO;
 }
 
 /// FactorOutConstant - Test if S is divisible by Factor, using signed
 /// division. If so, update S with Factor divided out and return true.
 /// S need not be evenly divisible if a reasonable remainder can be
for (;;) {
     }
 
     // Record the scaled array index for this level of the type. If
     // we didn't find any operands that could be factored, tentatively
     // assume that element zero was selected (since the zero offset
     // would obviously be folded away).
     Value *Scaled = ScaledOps.empty() ?
                     Constant::getNullValue(Ty) :
-                    expandCodeFor(SE.getAddExpr(ScaledOps), Ty);
+                    expandCodeFor(SE.getAddExpr(ScaledOps), CurDbgLoc, Ty);
     GepIndices.push_back(Scaled);
 
     // Collect struct field index operands.
     while (StructType *STy = dyn_cast<StructType>(ElTy)) {
       bool FoundFieldNo = false;
       // An empty struct has no fields.
       if (STy->getNumElements() == 0) break;
       // Field offsets are known. See if a constant offset falls within any of
if (!AnyNonZeroIndices) {
     // Cast the base to i8*.
     V = InsertNoopCastOfTo(V,
        Type::getInt8PtrTy(Ty->getContext(), PTy->getAddressSpace()));
 
     assert(!isa<Instruction>(V) ||
            SE.DT.dominates(cast<Instruction>(V), &*Builder.GetInsertPoint()));
 
     // Expand the operands for a plain byte offset.
-    Value *Idx = expandCodeFor(SE.getAddExpr(Ops), Ty);
+    Value *Idx = expandCodeFor(SE.getAddExpr(Ops), CurDbgLoc, Ty);
 
     // Fold a GEP with constant operands.
     if (Constant *CLHS = dyn_cast<Constant>(V))
       if (Constant *CRHS = dyn_cast<Constant>(Idx))
         return ConstantExpr::getGetElementPtr(Type::getInt8Ty(Ty->getContext()),
                                               CLHS, CRHS);
 
     // Do a quick scan to see if we have this GEP nearby.  If so, reuse it.
if (!AnyNonZeroIndices) {
 
     // Move the insertion point out of as many loops as we can.
     while (const Loop *L = SE.LI.getLoopFor(Builder.GetInsertBlock())) {
       if (!L->isLoopInvariant(V) || !L->isLoopInvariant(Idx)) break;
       BasicBlock *Preheader = L->getLoopPreheader();
       if (!Preheader) break;
 
       // Ok, move up a level.
-      Builder.SetInsertPoint(Preheader->getTerminator());
+      setInsertPoint(Preheader->getTerminator());
     }
 
     // Emit a GEP.
     Value *GEP = Builder.CreateGEP(Builder.getInt8Ty(), V, Idx, "uglygep");
     rememberInstruction(GEP);
 
     return GEP;
   }
while (const Loop *L = SE.LI.getLoopFor(Builder.GetInsertBlock())) {
 
       if (AnyIndexNotLoopInvariant)
         break;
 
       BasicBlock *Preheader = L->getLoopPreheader();
       if (!Preheader) break;
 
       // Ok, move up a level.
-      Builder.SetInsertPoint(Preheader->getTerminator());
+      setInsertPoint(Preheader->getTerminator());
     }
 
     // Insert a pretty getelementptr. Note that this GEP is not marked inbounds,
     // because ScalarEvolution may have changed the address arithmetic to
     // compute a value which is beyond the end of the allocated object.
     Value *Casted = V;
     if (V->getType() != PTy)
       Casted = InsertNoopCastOfTo(Casted, PTy);
if (!Sum) {
       SmallVector<const SCEV *, 4> NewOps;
       NewOps.push_back(isa<Instruction>(Sum) ? SE.getUnknown(Sum) :
                                                SE.getSCEV(Sum));
       for (++I; I != E && I->first == CurLoop; ++I)
         NewOps.push_back(I->second);
       Sum = expandAddToGEP(NewOps.begin(), NewOps.end(), PTy, Ty, expand(Op));
     } else if (Op->isNonConstantNegative()) {
       // Instead of doing a negate and add, just do a subtract.
-      Value *W = expandCodeFor(SE.getNegativeSCEV(Op), Ty);
+      Value *W = expandCodeFor(SE.getNegativeSCEV(Op), CurDbgLoc, Ty);
       Sum = InsertNoopCastOfTo(Sum, Ty);
       Sum = InsertBinop(Instruction::Sub, Sum, W);
       ++I;
     } else {
       // A simple add.
-      Value *W = expandCodeFor(Op, Ty);
+      Value *W = expandCodeFor(Op, CurDbgLoc, Ty);
       Sum = InsertNoopCastOfTo(Sum, Ty);
       // Canonicalize a constant to the RHS.
       if (isa<Constant>(Sum)) std::swap(Sum, W);
       Sum = InsertBinop(Instruction::Add, Sum, W);
       ++I;
     }
   }
 
const auto ExpandOpBinPowN = [this, &I, &OpsAndLoops, &Ty]() {
     while (E != OpsAndLoops.end() && *I == *E && Exponent != MaxExponent) {
       ++Exponent;
       ++E;
     }
     assert(Exponent > 0 && "Trying to calculate a zeroth exponent of operand?");
 
     // Calculate powers with exponents 1, 2, 4, 8 etc. and include those of them
     // that are needed into the result.
-    Value *P = expandCodeFor(I->second, Ty);
+    Value *P = expandCodeFor(I->second, CurDbgLoc, Ty);
     Value *Result = nullptr;
     if (Exponent & 1)
       Result = P;
     for (uint64_t BinExp = 2; BinExp <= Exponent; BinExp <<= 1) {
       P = InsertBinop(Instruction::Mul, P, P);
       if (Exponent & BinExp)
         Result = Result ? InsertBinop(Instruction::Mul, Result, P) : P;
     }
Value *SCEVExpander::visitMulExpr(const SCEVMulExpr *S) {
   }
 
   return Prod;
 }
 
 Value *SCEVExpander::visitUDivExpr(const SCEVUDivExpr *S) {
   Type *Ty = SE.getEffectiveSCEVType(S->getType());
 
-  Value *LHS = expandCodeFor(S->getLHS(), Ty);
+  Value *LHS = expandCodeFor(S->getLHS(), CurDbgLoc, Ty);
   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(S->getRHS())) {
     const APInt &RHS = SC->getAPInt();
     if (RHS.isPowerOf2())
       return InsertBinop(Instruction::LShr, LHS,
                          ConstantInt::get(Ty, RHS.logBase2()));
   }
 
-  Value *RHS = expandCodeFor(S->getRHS(), Ty);
+  Value *RHS = expandCodeFor(S->getRHS(), CurDbgLoc, Ty);
   return InsertBinop(Instruction::UDiv, LHS, RHS);
 }
 
 /// Move parts of Base into Rest to leave Base with the minimal
 /// expression that provides a pointer operand suitable for a
 /// GEP expansion.
 static void ExposePointerBase(const SCEV *&Base, const SCEV *&Rest,
                               ScalarEvolution &SE) {

 /// 'I' is being moved.  If this fixup is not done and 'I' is moved to a
 /// different block, the inconsistent insert point (with a mismatched
 /// Instruction and Block) can lead to an instruction being inserted in a block
 /// other than its parent.
 void SCEVExpander::fixupInsertPoints(Instruction *I) {
   BasicBlock::iterator It(*I);
   BasicBlock::iterator NewInsertPt = std::next(It);
   if (Builder.GetInsertPoint() == It)
-    Builder.SetInsertPoint(&*NewInsertPt);
+    setInsertPoint(&*NewInsertPt);
   for (auto *InsertPtGuard : InsertPointGuards)
     if (InsertPtGuard->GetInsertPoint() == It)
       InsertPtGuard->SetInsertPoint(NewInsertPt);
 }
 
 /// hoistStep - Attempt to hoist a simple IV increment above InsertPos to make
 /// it available to other uses in this loop. Recursively hoist any operands,
 /// until we reach a value that dominates InsertPos.
SCEVExpander::getAddRecExprPHILiterally(const SCEVAddRecExpr *Normalized,
   // SavedIncLoops.swap(PostIncLoops), but we generally have a single element,
   // so it's not worth implementing SmallPtrSet::swap.
   PostIncLoopSet SavedPostIncLoops = PostIncLoops;
   PostIncLoops.clear();
 
   // Expand code for the start value into the loop preheader.
   assert(L->getLoopPreheader() &&
          "Can't expand add recurrences without a loop preheader!");
-  Value *StartV = expandCodeFor(Normalized->getStart(), ExpandTy,
+  Value *StartV = expandCodeFor(Normalized->getStart(), CurDbgLoc, ExpandTy,
                                 L->getLoopPreheader()->getTerminator());
 
   // StartV must have been be inserted into L's preheader to dominate the new
   // phi.
   assert(!isa<Instruction>(StartV) ||
          SE.DT.properlyDominates(cast<Instruction>(StartV)->getParent(),
                                  L->getHeader()));
 
   // Expand code for the step value. Do this before creating the PHI so that PHI
   // reuse code doesn't see an incomplete PHI.
   const SCEV *Step = Normalized->getStepRecurrence(SE);
   // If the stride is negative, insert a sub instead of an add for the increment
   // (unless it's a constant, because subtracts of constants are canonicalized
   // to adds).
   bool useSubtract = !ExpandTy->isPointerTy() && Step->isNonConstantNegative();
   if (useSubtract)
     Step = SE.getNegativeSCEV(Step);
   // Expand the step somewhere that dominates the loop header.
-  Value *StepV = expandCodeFor(Step, IntTy, &L->getHeader()->front());
+  Value *StepV =
+      expandCodeFor(Step, CurDbgLoc, IntTy, &L->getHeader()->front());
 
   // The no-wrap behavior proved by IsIncrement(NUW|NSW) is only applicable if
   // we actually do emit an addition.  It does not apply if we emit a
   // subtraction.
   bool IncrementIsNUW = !useSubtract && IsIncrementNUW(SE, Normalized);
   bool IncrementIsNSW = !useSubtract && IsIncrementNSW(SE, Normalized);
 
   // Create the PHI.
   BasicBlock *Header = L->getHeader();
-  Builder.SetInsertPoint(Header, Header->begin());
+  setInsertPoint(Header, Header->begin());
   pred_iterator HPB = pred_begin(Header), HPE = pred_end(Header);
   PHINode *PN = Builder.CreatePHI(ExpandTy, std::distance(HPB, HPE),
                                   Twine(IVName) + ".iv");
   rememberInstruction(PN);
 
   // Create the step instructions and populate the PHI.
   for (pred_iterator HPI = HPB; HPI != HPE; ++HPI) {
     BasicBlock *Pred = *HPI;
 
     // Add a start value.
     if (!L->contains(Pred)) {
       PN->addIncoming(StartV, Pred);
       continue;
     }
 
     // Create a step value and add it to the PHI.
     // If IVIncInsertLoop is non-null and equal to the addrec's loop, insert the
     // instructions at IVIncInsertPos.
     Instruction *InsertPos = L == IVIncInsertLoop ?
       IVIncInsertPos : Pred->getTerminator();
-    Builder.SetInsertPoint(InsertPos);
+    setInsertPoint(InsertPos);
     Value *IncV = expandIVInc(PN, StepV, L, ExpandTy, IntTy, useSubtract);
 
     if (isa<OverflowingBinaryOperator>(IncV)) {
       if (IncrementIsNUW)
         cast<BinaryOperator>(IncV)->setHasNoUnsignedWrap();
       if (IncrementIsNSW)
         cast<BinaryOperator>(IncV)->setHasNoSignedWrap();
     }
if (isa<Instruction>(Result) &&
       bool useSubtract =
         !ExpandTy->isPointerTy() && Step->isNonConstantNegative();
       if (useSubtract)
         Step = SE.getNegativeSCEV(Step);
       Value *StepV;
       {
         // Expand the step somewhere that dominates the loop header.
         SCEVInsertPointGuard Guard(Builder, this);
-        StepV = expandCodeFor(Step, IntTy, &L->getHeader()->front());
+        StepV = expandCodeFor(Step, CurDbgLoc, IntTy, &L->getHeader()->front());
       }
       Result = expandIVInc(PN, StepV, L, ExpandTy, IntTy, useSubtract);
     }
   }
 
   // We have decided to reuse an induction variable of a dominating loop. Apply
   // truncation and/or invertion of the step.
   if (TruncTy) {
     Type *ResTy = Result->getType();
     // Normalize the result type.
     if (ResTy != SE.getEffectiveSCEVType(ResTy))
       Result = InsertNoopCastOfTo(Result, SE.getEffectiveSCEVType(ResTy));
     // Truncate the result.
     if (TruncTy != Result->getType()) {
       Result = Builder.CreateTrunc(Result, TruncTy);
       rememberInstruction(Result);
     }
     // Invert the result.
     if (InvertStep) {
-      Result = Builder.CreateSub(expandCodeFor(Normalized->getStart(), TruncTy),
-                                 Result);
+      Result = Builder.CreateSub(
+          expandCodeFor(Normalized->getStart(), CurDbgLoc, TruncTy), Result);
       rememberInstruction(Result);
     }
   }
 
   // Re-apply any non-loop-dominating scale.
   if (PostLoopScale) {
     assert(S->isAffine() && "Can't linearly scale non-affine recurrences.");
     Result = InsertNoopCastOfTo(Result, IntTy);
     Result = Builder.CreateMul(Result,
-                               expandCodeFor(PostLoopScale, IntTy));
+                               expandCodeFor(PostLoopScale, CurDbgLoc, IntTy));
     rememberInstruction(Result);
   }
 
   // Re-apply any non-loop-dominating offset.
   if (PostLoopOffset) {
     if (PointerType *PTy = dyn_cast<PointerType>(ExpandTy)) {
       if (Result->getType()->isIntegerTy()) {
-        Value *Base = expandCodeFor(PostLoopOffset, ExpandTy);
+        Value *Base = expandCodeFor(PostLoopOffset, CurDbgLoc, ExpandTy);
         const SCEV *const OffsetArray[1] = {SE.getUnknown(Result)};
         Result = expandAddToGEP(OffsetArray, OffsetArray + 1, PTy, IntTy, Base);
       } else {
         const SCEV *const OffsetArray[1] = {PostLoopOffset};
         Result =
             expandAddToGEP(OffsetArray, OffsetArray + 1, PTy, IntTy, Result);
       }
     } else {
       Result = InsertNoopCastOfTo(Result, IntTy);
-      Result = Builder.CreateAdd(Result,
-                                 expandCodeFor(PostLoopOffset, IntTy));
+      Result = Builder.CreateAdd(
+          Result, expandCodeFor(PostLoopOffset, CurDbgLoc, IntTy));
       rememberInstruction(Result);
     }
   }
 
   return Result;
 }
 
 Value *SCEVExpander::visitAddRecExpr(const SCEVAddRecExpr *S) {
if (CanonicalIV &&
       SE.getTypeSizeInBits(Ty)) {
     SmallVector<const SCEV *, 4> NewOps(S->getNumOperands());
     for (unsigned i = 0, e = S->getNumOperands(); i != e; ++i)
       NewOps[i] = SE.getAnyExtendExpr(S->op_begin()[i], CanonicalIV->getType());
     Value *V = expand(SE.getAddRecExpr(NewOps, S->getLoop(),
                                        S->getNoWrapFlags(SCEV::FlagNW)));
     BasicBlock::iterator NewInsertPt =
         findInsertPointAfter(cast<Instruction>(V), Builder.GetInsertBlock());
-    V = expandCodeFor(SE.getTruncateExpr(SE.getUnknown(V), Ty), nullptr,
-                      &*NewInsertPt);
+    V = expandCodeFor(SE.getTruncateExpr(SE.getUnknown(V), Ty), CurDbgLoc,
+                      nullptr, &*NewInsertPt);
     return V;
   }
 
   // {X,+,F} --> X + {0,+,F}
   if (!S->getStart()->isZero()) {
     SmallVector<const SCEV *, 4> NewOps(S->op_begin(), S->op_end());
     NewOps[0] = SE.getConstant(Ty, 0);
     const SCEV *Rest = SE.getAddRecExpr(NewOps, L,
for (pred_iterator HPI = HPB; HPI != HPE; ++HPI) {
       }
 
       if (L->contains(HP)) {
         // Insert a unit add instruction right before the terminator
         // corresponding to the back-edge.
         Instruction *Add = BinaryOperator::CreateAdd(CanonicalIV, One,
                                                      "indvar.next",
                                                      HP->getTerminator());
-        Add->setDebugLoc(HP->getTerminator()->getDebugLoc());
+        Add->setDebugLoc(CurDbgLoc);
         rememberInstruction(Add);
         CanonicalIV->addIncoming(Add, HP);
       } else {
         CanonicalIV->addIncoming(Constant::getNullValue(Ty), HP);
       }
     }
   }
 
Value *SCEVExpander::visitAddRecExpr(const SCEVAddRecExpr *S) {
 
   // Truncate the result down to the original type, if needed.
   const SCEV *T = SE.getTruncateOrNoop(V, Ty);
   return expand(T);
 }
 
 Value *SCEVExpander::visitTruncateExpr(const SCEVTruncateExpr *S) {
   Type *Ty = SE.getEffectiveSCEVType(S->getType());
-  Value *V = expandCodeFor(S->getOperand(),
+  Value *V = expandCodeFor(S->getOperand(), CurDbgLoc,
                            SE.getEffectiveSCEVType(S->getOperand()->getType()));
   Value *I = Builder.CreateTrunc(V, Ty);
   rememberInstruction(I);
   return I;
 }
 
 Value *SCEVExpander::visitZeroExtendExpr(const SCEVZeroExtendExpr *S) {
   Type *Ty = SE.getEffectiveSCEVType(S->getType());
-  Value *V = expandCodeFor(S->getOperand(),
+  Value *V = expandCodeFor(S->getOperand(), CurDbgLoc,
                            SE.getEffectiveSCEVType(S->getOperand()->getType()));
   Value *I = Builder.CreateZExt(V, Ty);
   rememberInstruction(I);
   return I;
 }
 
 Value *SCEVExpander::visitSignExtendExpr(const SCEVSignExtendExpr *S) {
   Type *Ty = SE.getEffectiveSCEVType(S->getType());
-  Value *V = expandCodeFor(S->getOperand(),
+  Value *V = expandCodeFor(S->getOperand(), CurDbgLoc,
                            SE.getEffectiveSCEVType(S->getOperand()->getType()));
   Value *I = Builder.CreateSExt(V, Ty);
   rememberInstruction(I);
   return I;
 }
 
 Value *SCEVExpander::visitSMaxExpr(const SCEVSMaxExpr *S) {
   Value *LHS = expand(S->getOperand(S->getNumOperands()-1));
   Type *Ty = LHS->getType();
   for (int i = S->getNumOperands()-2; i >= 0; --i) {
     // In the case of mixed integer and pointer types, do the
     // rest of the comparisons as integer.
     if (S->getOperand(i)->getType() != Ty) {
       Ty = SE.getEffectiveSCEVType(Ty);
       LHS = InsertNoopCastOfTo(LHS, Ty);
     }
-    Value *RHS = expandCodeFor(S->getOperand(i), Ty);
+    Value *RHS = expandCodeFor(S->getOperand(i), CurDbgLoc, Ty);
     Value *ICmp = Builder.CreateICmpSGT(LHS, RHS);
     rememberInstruction(ICmp);
     Value *Sel = Builder.CreateSelect(ICmp, LHS, RHS, "smax");
     rememberInstruction(Sel);
     LHS = Sel;
   }
   // In the case of mixed integer and pointer types, cast the
   // final result back to the pointer type.
   if (LHS->getType() != S->getType())
     LHS = InsertNoopCastOfTo(LHS, S->getType());
   return LHS;
 }
 
 Value *SCEVExpander::visitUMaxExpr(const SCEVUMaxExpr *S) {
   Value *LHS = expand(S->getOperand(S->getNumOperands()-1));
   Type *Ty = LHS->getType();
   for (int i = S->getNumOperands()-2; i >= 0; --i) {
     // In the case of mixed integer and pointer types, do the
     // rest of the comparisons as integer.
     if (S->getOperand(i)->getType() != Ty) {
       Ty = SE.getEffectiveSCEVType(Ty);
       LHS = InsertNoopCastOfTo(LHS, Ty);
     }
-    Value *RHS = expandCodeFor(S->getOperand(i), Ty);
+    Value *RHS = expandCodeFor(S->getOperand(i), CurDbgLoc, Ty);
     Value *ICmp = Builder.CreateICmpUGT(LHS, RHS);
     rememberInstruction(ICmp);
     Value *Sel = Builder.CreateSelect(ICmp, LHS, RHS, "umax");
     rememberInstruction(Sel);
     LHS = Sel;
   }
   // In the case of mixed integer and pointer types, cast the
   // final result back to the pointer type.
   if (LHS->getType() != S->getType())
     LHS = InsertNoopCastOfTo(LHS, S->getType());
   return LHS;
 }
 
-Value *SCEVExpander::expandCodeFor(const SCEV *SH, Type *Ty,
+Value *SCEVExpander::expandCodeFor(const SCEV *SH, DebugLoc DbgLoc, Type *Ty,
                                    Instruction *IP) {
-  setInsertPoint(IP);
-  return expandCodeFor(SH, Ty);
+  setInsertPointAndDbgLoc(IP, DbgLoc);
+  return expandCodeFor(SH, DbgLoc, Ty);
 }
 
-Value *SCEVExpander::expandCodeFor(const SCEV *SH, Type *Ty) {
+Value *SCEVExpander::expandCodeFor(const SCEV *SH, DebugLoc DbgLoc, Type *Ty) {
   // Expand the code for this SCEV.
+  setDbgLoc(DbgLoc);
   Value *V = expand(SH);
   if (Ty) {
     assert(SE.getTypeSizeInBits(Ty) == SE.getTypeSizeInBits(SH->getType()) &&
            "non-trivial casts should be done with the SCEVs directly!");
     V = InsertNoopCastOfTo(V, Ty);
   }
   return V;
 }
for (Loop *L = SE.LI.getLoopFor(Builder.GetInsertBlock());;
     }
 
   // Check to see if we already expanded this here.
   auto I = InsertedExpressions.find(std::make_pair(S, InsertPt));
   if (I != InsertedExpressions.end())
     return I->second;
 
   SCEVInsertPointGuard Guard(Builder, this);
-  Builder.SetInsertPoint(InsertPt);
+  setInsertPoint(InsertPt);
 
   // Expand the expression into instructions.
   ScalarEvolution::ValueOffsetPair VO = FindValueInExprValueMap(S, InsertPt);
   Value *V = VO.first;
 
   if (!V)
     V = visit(S);
   else if (VO.second) {
void SCEVExpander::rememberInstruction(Value *I) {
   else
     InsertedValues.insert(I);
 }
 
 /// getOrInsertCanonicalInductionVariable - This method returns the
 /// canonical induction variable of the specified type for the specified
 /// loop (inserting one if there is none).  A canonical induction variable
 /// starts at zero and steps by one on each iteration.
-PHINode *
-SCEVExpander::getOrInsertCanonicalInductionVariable(const Loop *L,
+PHINode *SCEVExpander::getOrInsertCanonicalInductionVariable(const Loop *L,
+                                                             DebugLoc DbgLoc,
                                                              Type *Ty) {
   assert(Ty->isIntegerTy() && "Can only insert integer induction variables!");
 
   // Build a SCEV for {0,+,1}<L>.
   // Conservatively use FlagAnyWrap for now.
   const SCEV *H = SE.getAddRecExpr(SE.getConstant(Ty, 0),
                                    SE.getConstant(Ty, 1), L, SCEV::FlagAnyWrap);
 
   // Emit code for it.
   SCEVInsertPointGuard Guard(Builder, this);
-  PHINode *V =
-      cast<PHINode>(expandCodeFor(H, nullptr, &L->getHeader()->front()));
+  PHINode *V = cast<PHINode>(
+      expandCodeFor(H, CurDbgLoc, nullptr, &L->getHeader()->front()));
 
   return V;
 }
 
 /// replaceCongruentIVs - Check for congruent phis in this loop header and
 /// replace them with their most canonical representative. Return the number of
 /// phis eliminated.
 ///
bool SCEVExpander::isHighCostExpansionHelper(
   }
 
   // If we haven't recognized an expensive SCEV pattern, assume it's an
   // expression produced by program code.
   return false;
 }
 
 Value *SCEVExpander::expandCodeForPredicate(const SCEVPredicate *Pred,
-                                            Instruction *IP) {
+                                            DebugLoc DbgLoc, Instruction *IP) {
   assert(IP);
   switch (Pred->getKind()) {
   case SCEVPredicate::P_Union:
-    return expandUnionPredicate(cast<SCEVUnionPredicate>(Pred), IP);
+    return expandUnionPredicate(cast<SCEVUnionPredicate>(Pred), DbgLoc, IP);
   case SCEVPredicate::P_Equal:
-    return expandEqualPredicate(cast<SCEVEqualPredicate>(Pred), IP);
+    return expandEqualPredicate(cast<SCEVEqualPredicate>(Pred), DbgLoc, IP);
   case SCEVPredicate::P_Wrap: {
     auto *AddRecPred = cast<SCEVWrapPredicate>(Pred);
-    return expandWrapPredicate(AddRecPred, IP);
+    return expandWrapPredicate(AddRecPred, DbgLoc, IP);
   }
   }
   llvm_unreachable("Unknown SCEV predicate type");
 }
 
 Value *SCEVExpander::expandEqualPredicate(const SCEVEqualPredicate *Pred,
-                                          Instruction *IP) {
-  Value *Expr0 = expandCodeFor(Pred->getLHS(), Pred->getLHS()->getType(), IP);
-  Value *Expr1 = expandCodeFor(Pred->getRHS(), Pred->getRHS()->getType(), IP);
+                                          DebugLoc DbgLoc, Instruction *IP) {
+  Value *Expr0 =
+      expandCodeFor(Pred->getLHS(), DbgLoc, Pred->getLHS()->getType(), IP);
+  Value *Expr1 =
+      expandCodeFor(Pred->getRHS(), DbgLoc, Pred->getRHS()->getType(), IP);
 
-  Builder.SetInsertPoint(IP);
+  setInsertPointAndDbgLoc(IP, DbgLoc);
   auto *I = Builder.CreateICmpNE(Expr0, Expr1, "ident.check");
   return I;
 }
 
 Value *SCEVExpander::generateOverflowCheck(const SCEVAddRecExpr *AR,
-                                           Instruction *Loc, bool Signed) {
+                                           DebugLoc DbgLoc, Instruction *Loc,
+                                           bool Signed) {
   assert(AR->isAffine() && "Cannot generate RT check for "
                            "non-affine expression");
 
   SCEVUnionPredicate Pred;
   const SCEV *ExitCount =
       SE.getPredicatedBackedgeTakenCount(AR->getLoop(), Pred);
 
   assert(ExitCount != SE.getCouldNotCompute() && "Invalid loop count");
 
   const SCEV *Step = AR->getStepRecurrence(SE);
   const SCEV *Start = AR->getStart();
 
   unsigned SrcBits = SE.getTypeSizeInBits(ExitCount->getType());
   unsigned DstBits = SE.getTypeSizeInBits(AR->getType());
 
   // The expression {Start,+,Step} has nusw/nssw if
   //   Step < 0, Start - |Step| * Backedge <= Start
   //   Step >= 0, Start + |Step| * Backedge > Start
   // and |Step| * Backedge doesn't unsigned overflow.
 
   IntegerType *CountTy = IntegerType::get(Loc->getContext(), SrcBits);
-  Builder.SetInsertPoint(Loc);
-  Value *TripCountVal = expandCodeFor(ExitCount, CountTy, Loc);
+  setInsertPointAndDbgLoc(Loc, DbgLoc);
+  Value *TripCountVal = expandCodeFor(ExitCount, DbgLoc, CountTy, Loc);
 
   IntegerType *Ty =
       IntegerType::get(Loc->getContext(), SE.getTypeSizeInBits(AR->getType()));
 
-  Value *StepValue = expandCodeFor(Step, Ty, Loc);
-  Value *NegStepValue = expandCodeFor(SE.getNegativeSCEV(Step), Ty, Loc);
-  Value *StartValue = expandCodeFor(Start, Ty, Loc);
+  Value *StepValue = expandCodeFor(Step, DbgLoc, Ty, Loc);
+  Value *NegStepValue =
+      expandCodeFor(SE.getNegativeSCEV(Step), DbgLoc, Ty, Loc);
+  Value *StartValue = expandCodeFor(Start, DbgLoc, Ty, Loc);
 
   ConstantInt *Zero =
       ConstantInt::get(Loc->getContext(), APInt::getNullValue(DstBits));
 
-  Builder.SetInsertPoint(Loc);
+  setInsertPointAndDbgLoc(Loc, DbgLoc);
   // Compute |Step|
   Value *StepCompare = Builder.CreateICmp(ICmpInst::ICMP_SLT, StepValue, Zero);
   Value *AbsStep = Builder.CreateSelect(StepCompare, NegStepValue, StepValue);
 
   // Get the backedge taken count and truncate or extended to the AR type.
   Value *TruncTripCount = Builder.CreateZExtOrTrunc(TripCountVal, Ty);
   auto *MulF = Intrinsic::getDeclaration(Loc->getModule(),
                                          Intrinsic::umul_with_overflow, Ty);
if (SE.getTypeSizeInBits(CountTy) > SE.getTypeSizeInBits(Ty)) {
     EndCheck = Builder.CreateOr(EndCheck, BackedgeCheck);
   }
 
   EndCheck = Builder.CreateOr(EndCheck, OfMul);
   return EndCheck;
 }
 
 Value *SCEVExpander::expandWrapPredicate(const SCEVWrapPredicate *Pred,
-                                         Instruction *IP) {
+                                         DebugLoc DbgLoc, Instruction *IP) {
   const auto *A = cast<SCEVAddRecExpr>(Pred->getExpr());
   Value *NSSWCheck = nullptr, *NUSWCheck = nullptr;
 
   // Add a check for NUSW
   if (Pred->getFlags() & SCEVWrapPredicate::IncrementNUSW)
-    NUSWCheck = generateOverflowCheck(A, IP, false);
+    NUSWCheck = generateOverflowCheck(A, DbgLoc, IP, false);
 
   // Add a check for NSSW
   if (Pred->getFlags() & SCEVWrapPredicate::IncrementNSSW)
-    NSSWCheck = generateOverflowCheck(A, IP, true);
+    NSSWCheck = generateOverflowCheck(A, DbgLoc, IP, true);
 
   if (NUSWCheck && NSSWCheck)
     return Builder.CreateOr(NUSWCheck, NSSWCheck);
 
   if (NUSWCheck)
     return NUSWCheck;
 
   if (NSSWCheck)
     return NSSWCheck;
 
   return ConstantInt::getFalse(IP->getContext());
 }
 
 Value *SCEVExpander::expandUnionPredicate(const SCEVUnionPredicate *Union,
-                                          Instruction *IP) {
+                                          DebugLoc DbgLoc, Instruction *IP) {
   auto *BoolType = IntegerType::get(IP->getContext(), 1);
   Value *Check = ConstantInt::getNullValue(BoolType);
 
   // Loop over all checks in this set.
   for (auto Pred : Union->getPredicates()) {
-    auto *NextCheck = expandCodeForPredicate(Pred, IP);
-    Builder.SetInsertPoint(IP);
+    auto *NextCheck = expandCodeForPredicate(Pred, DbgLoc, IP);
+    setInsertPointAndDbgLoc(IP, DbgLoc);
     Check = Builder.CreateOr(Check, NextCheck);
   }
 
   return Check;
 }
 
+/// Deprecated instruction generation methods.
+
+PHINode *SCEVExpander::getOrInsertCanonicalInductionVariable(const Loop *L,
+                                                             Type *Ty) {
+  return getOrInsertCanonicalInductionVariable(L, getUnknownDebugLocation(),
+                                               Ty);
+}
+
+Value *SCEVExpander::expandCodeFor(const SCEV *SH, Type *Ty, Instruction *I) {
+  return expandCodeFor(SH, getUnknownDebugLocation(I), Ty, I);
+}
+
+Value *SCEVExpander::expandCodeFor(const SCEV *SH, Type *Ty) {
+  return expandCodeFor(SH, getUnknownDebugLocation(), Ty);
+}
+
+Value *SCEVExpander::expandCodeForPredicate(const SCEVPredicate *Pred,
+                                            Instruction *Loc) {
+  return expandCodeForPredicate(Pred, getUnknownDebugLocation(Loc), Loc);
+}
+
+Value *SCEVExpander::expandEqualPredicate(const SCEVEqualPredicate *Pred,
+                                          Instruction *Loc) {
+  return expandEqualPredicate(Pred, getUnknownDebugLocation(Loc), Loc);
+}
+
+Value *SCEVExpander::generateOverflowCheck(const SCEVAddRecExpr *AR,
+                                           Instruction *Loc, bool Signed) {
+  return generateOverflowCheck(AR, getUnknownDebugLocation(Loc), Loc, Signed);
+}
+
+Value *SCEVExpander::expandWrapPredicate(const SCEVWrapPredicate *P,
+                                         Instruction *Loc) {
+  return expandWrapPredicate(P, getUnknownDebugLocation(Loc), Loc);
+}
+
+Value *SCEVExpander::expandUnionPredicate(const SCEVUnionPredicate *Pred,
+                                          Instruction *Loc) {
+  return expandUnionPredicate(Pred, getUnknownDebugLocation(Loc), Loc);
+}
+
+/// Helpers for insertion point and debug location updates.
+
+void SCEVExpander::setInsertPoint(BasicBlock *BB, BasicBlock::iterator I) {
+  Builder.setInsertPoint(BB, I, CurDbgLoc);
+}
+
+void SCEVExpander::setInsertPointAndDbgLoc(Instruction *I, DebugLoc DbgLoc) {
+  CurDbgLoc = DbgLoc;
+  Builder.setInsertPoint(I, DbgLoc);
+}
+
+void SCEVExpander::setDbgLoc(DebugLoc DbgLoc) {
+  CurDbgLoc = DbgLoc;
+  Builder.SetCurrentDebugLocation(CurDbgLoc);
+}
+
 namespace {
 // Search for a SCEV subexpression that is not safe to expand.  Any expression
 // that may expand to a !isSafeToSpeculativelyExecute value is unsafe, namely
 // UDiv expressions. We don't know if the UDiv is derived from an IR divide
 // instruction, but the important thing is that we prove the denominator is
 // nonzero before expansion.
 //
 // IVUsers already checks that IV-derived expressions are safe. So this check is

unittests/Analysis/ScalarEvolutionTest.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/ScalarEvolutionExpander.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/SourceMgr.h"
 #include "gtest/gtest.h"
 
 namespace llvm {
+
+// Used by gtest to pretty-print EXPECT failures.
+void PrintTo(const DebugLoc &L, ::std::ostream *os) {
+  std::string S;
+  {
+    raw_string_ostream SOS(S);
+    L.print(SOS);
+  }
+  *os << S;
+}
+
 namespace {
 
 // We use this fixture to ensure that we clean up ScalarEvolution before
 // deleting the PassManager.
 class ScalarEvolutionsTest : public testing::Test {
 protected:
   LLVMContext Context;
   Module M;
   TargetLibraryInfoImpl TLII;
   TargetLibraryInfo TLI;
 
   std::unique_ptr<AssumptionCache> AC;
   std::unique_ptr<DominatorTree> DT;
   std::unique_ptr<LoopInfo> LI;
+  std::unique_ptr<DIBuilder> DIB;
 
   ScalarEvolutionsTest() : M("", Context), TLII(), TLI(TLII) {}
 
   ScalarEvolution buildSE(Function &F) {
     AC.reset(new AssumptionCache(F));
     DT.reset(new DominatorTree(F));
     LI.reset(new LoopInfo(*DT));
     return ScalarEvolution(F, TLI, *AC, *DT, *LI);
   }
 
+  DISubprogram *buildDebugInfo(Function &F) {
+    DIB = llvm::make_unique<DIBuilder>(M);
+    auto File = DIB->createFile("tmp.cpp", "/");
+    auto CU = DIB->createCompileUnit(dwarf::DW_LANG_C_plus_plus_11,
+                                     DIB->createFile("tmp.cpp", "/"), "", true,
+                                     "", 0);
+    auto SPType = DIB->createSubroutineType(DIB->getOrCreateTypeArray(None));
+    auto SP = DIB->createFunction(CU, F.getName(), F.getName(), File, 1, SPType,
+                                  false, true, 1);
+    return SP;
+  }
+
   void runWithSE(
       Module &M, StringRef FuncName,
       function_ref<void(Function &F, LoopInfo &LI, ScalarEvolution &SE)> Test) {
     auto *F = M.getFunction(FuncName);
     ASSERT_NE(F, nullptr) << "Could not find " << FuncName;
     ScalarEvolution SE = buildSE(*F);
     Test(*F, *LI, SE);
   }
+
+  /// Useful for testing SCEVExpander.
+  std::tuple<Function *, CastInst *, BranchInst *> buildTestCaseForPR30213();
 };
 
 TEST_F(ScalarEvolutionsTest, SCEVUnknownRAUW) {
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
                                               std::vector<Type *>(), false);
   Function *F = cast<Function>(M.getOrInsertFunction("f", FTy));
   BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
   ReturnInst::Create(Context, nullptr, BB);
TEST_F(ScalarEvolutionsTest, SimplifiedPHI) {
 
   // At some point, only the first call to getSCEV returned the simplified
   // SCEVConstant and later calls just returned a SCEVUnknown referencing the
   // PHI node.
   EXPECT_EQ(S1, ZeroConst);
   EXPECT_EQ(S1, S2);
 }
 
-TEST_F(ScalarEvolutionsTest, ExpandPtrTypeSCEV) {
+std::tuple<Function *, CastInst *, BranchInst *>
+ScalarEvolutionsTest::buildTestCaseForPR30213() {
   // It is to test the fix for PR30213. It exercises the branch in scev
   // expansion when the value in ValueOffsetPair is a ptr and the offset
   // is not divisible by the elem type size of value.
   auto *I8Ty = Type::getInt8Ty(Context);
   auto *I8PtrTy = Type::getInt8PtrTy(Context);
   auto *I32Ty = Type::getInt32Ty(Context);
   auto *I32PtrTy = Type::getInt32PtrTy(Context);
   FunctionType *FTy =
GetElementPtrInst *Gep1 =
       GetElementPtrInst::Create(I8Ty, CastA, Ci32, "gep1", Br);
   GetElementPtrInst *Gep2 = GetElementPtrInst::Create(
       I8Ty, UndefValue::get(I8PtrTy), Ci32, "gep2", Br);
   CmpInst *Cmp = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_ULT,
                                  UndefValue::get(I8PtrTy), CastA, "cmp", Br);
   SelectInst *Sel = SelectInst::Create(Cmp, Gep1, Gep2, "select", Br);
   CastInst *CastB =
       CastInst::CreateBitOrPointerCast(Sel, I32PtrTy, "bitcast2", Br);
+  return {F, CastB, Br};
+}
 
+TEST_F(ScalarEvolutionsTest, ExpandPtrTypeSCEV) {
+  Function *F;
+  CastInst *CastB;
+  BranchInst *Br;
+  std::tie(F, CastB, Br) = buildTestCaseForPR30213();
   ScalarEvolution SE = buildSE(*F);
   auto *S = SE.getSCEV(CastB);
   SCEVExpander Exp(SE, M.getDataLayout(), "expander");
   Value *V =
       Exp.expandCodeFor(cast<SCEVAddExpr>(S)->getOperand(1), nullptr, Br);
 
   // Expect the expansion code contains:
   //   %0 = bitcast i32* %bitcast2 to i8*
   //   %uglygep = getelementptr i8, i8* %0, i64 -1
   //   %1 = bitcast i8* %uglygep to i32*
   EXPECT_TRUE(isa<BitCastInst>(V));
   Instruction *Gep = cast<Instruction>(V)->getPrevNode();
   EXPECT_TRUE(isa<GetElementPtrInst>(Gep));
   EXPECT_TRUE(isa<ConstantInt>(Gep->getOperand(1)));
   EXPECT_EQ(cast<ConstantInt>(Gep->getOperand(1))->getSExtValue(), -1);
   EXPECT_TRUE(isa<BitCastInst>(Gep->getPrevNode()));
+
+  // Make sure we get an empty debug loc when the function has no debug info.
+  EXPECT_EQ(cast<Instruction>(V)->getDebugLoc(), DebugLoc());
+}
+
+TEST_F(ScalarEvolutionsTest, ExpandWithSpecifiedDebugLoc) {
+  Function *F;
+  CastInst *CastB;
+  BranchInst *Br;
+  std::tie(F, CastB, Br) = buildTestCaseForPR30213();
+  ScalarEvolution SE = buildSE(*F);
+  auto *S = SE.getSCEV(CastB);
+  SCEVExpander Exp(SE, M.getDataLayout(), "expander");
+  DISubprogram *SP = buildDebugInfo(*F);
+
+  // Attach DL2 to inserted insts, instead of copying the debug loc from the
+  // insertion point.
+  DebugLoc DL1 = DebugLoc::get(1, 0, SP);
+  Br->setDebugLoc(DL1);
+  DebugLoc DL2 = DebugLoc::get(1, 1, SP);
+  Value *V =
+      Exp.expandCodeFor(cast<SCEVAddExpr>(S)->getOperand(1), DL2, nullptr, Br);
+
+  Instruction *Gep = cast<Instruction>(V)->getPrevNode();
+  EXPECT_EQ(Gep->getDebugLoc(), DL2);
+  EXPECT_EQ(cast<BitCastInst>(Gep->getPrevNode())->getDebugLoc(), DL2);
+}
+
+TEST_F(ScalarEvolutionsTest, ExpandWithDefaultDebugLoc) {
+  Function *F;
+  CastInst *CastB;
+  BranchInst *Br;
+  std::tie(F, CastB, Br) = buildTestCaseForPR30213();
+  ScalarEvolution SE = buildSE(*F);
+  auto *S = SE.getSCEV(CastB);
+  SCEVExpander Exp(SE, M.getDataLayout(), "expander");
+  DISubprogram *SP = buildDebugInfo(*F);
+
+  // If the function has debug info, but no debug loc was specified in the call
+  // to expandCodeFor(), use the default location.
+  DebugLoc DL1 = DebugLoc::get(1, 0, SP);
+  Br->setDebugLoc(DL1);
+  Value *V =
+      Exp.expandCodeFor(cast<SCEVAddExpr>(S)->getOperand(1), nullptr, Br);
+
+  DebugLoc DefaultLoc = DebugLoc::get(0, 0, SP);
+  Instruction *Gep = cast<Instruction>(V)->getPrevNode();
+  EXPECT_EQ(Gep->getDebugLoc(), DefaultLoc);
+  EXPECT_EQ(cast<BitCastInst>(Gep->getPrevNode())->getDebugLoc(), DefaultLoc);
+  EXPECT_EQ(DefaultLoc, Exp.getUnknownDebugLocation(Br));
 }
 
 static Instruction *getInstructionByName(Function &F, StringRef Name) {
   for (auto &I : instructions(F))
     if (I.getName() == Name)
       return &I;
   llvm_unreachable("Expected to find instruction!");
 }