[llvm] r185165 - LoopVectorize: Use static function instead of DebugLocSetter class

Eric Christopher echristo at gmail.com
Fri Jun 28 11:28:07 PDT 2013


The pointer induction variable doesn't have a location? Possibly
created from somewhere else or does the instruction not have one
coming out of clang?

-eric

On Fri, Jun 28, 2013 at 11:22 AM, Arnold Schwaighofer
<aschwaighofer at apple.com> wrote:
> It happens for example when we create a canonical induction variable and there is only a pointer induction variable in the original loop.
>
>
> On Jun 28, 2013, at 12:48 PM, Eric Christopher <echristo at gmail.com> wrote:
>
>> I was going to ask about this yesterday, this is definitely much nicer.
>>
>> Curious how often the else condition fires - it really shouldn't, but
>> I can see it happen on occasion.
>>
>> -eric
>>
>> On Fri, Jun 28, 2013 at 9:26 AM, Arnold Schwaighofer
>> <aschwaighofer at apple.com> wrote:
>>> Author: arnolds
>>> Date: Fri Jun 28 11:26:54 2013
>>> New Revision: 185165
>>>
>>> URL: http://llvm.org/viewvc/llvm-project?rev=185165&view=rev
>>> Log:
>>> LoopVectorize: Use static function instead of DebugLocSetter class
>>>
>>> I used the class to safely reset the state of the builder's debug location.  I
>>> think I have caught all places where we need to set the debug location to a new
>>> one. Therefore, we can replace the class by a function that just sets the debug
>>> location.
>>>
>>> Modified:
>>>    llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp
>>>
>>> Modified: llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp
>>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp?rev=185165&r1=185164&r2=185165&view=diff
>>> ==============================================================================
>>> --- llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp (original)
>>> +++ llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp Fri Jun 28 11:26:54 2013
>>> @@ -326,30 +326,6 @@ private:
>>>   EdgeMaskCache MaskCache;
>>> };
>>>
>>> -/// \brief Set/reset the debug location in the IR builder using the RAII idiom.
>>> -class DebugLocSetter {
>>> -  IRBuilder<> &Builder;
>>> -  DebugLoc OldDL;
>>> -
>>> -  DebugLocSetter(const DebugLocSetter&);
>>> -  DebugLocSetter &operator=(const DebugLocSetter&);
>>> -
>>> -public:
>>> -  /// \brief Set the debug location in the IRBuilder 'B' using the instruction
>>> -  /// 'Inst'.
>>> -  DebugLocSetter(IRBuilder<> &B, Instruction *Inst) : Builder(B) {
>>> -    OldDL = Builder.getCurrentDebugLocation();
>>> -    // Handle null instructions gracefully. This is so we can use a dyn_cast on
>>> -    // values without nowing it is an instruction.
>>> -    if (Inst)
>>> -      Builder.SetCurrentDebugLocation(Inst->getDebugLoc());
>>> -  }
>>> -
>>> -  ~DebugLocSetter() {
>>> -    Builder.SetCurrentDebugLocation(OldDL);
>>> -  }
>>> -};
>>> -
>>> /// \brief Look for a meaningful debug location on the instruction or it's
>>> /// operands.
>>> static Instruction *getDebugLocFromInstOrOperands(Instruction *I) {
>>> @@ -369,6 +345,15 @@ static Instruction *getDebugLocFromInstO
>>>   return I;
>>> }
>>>
>>> +/// \brief Set the debug location in the builder using the debug location in the
>>> +/// instruction.
>>> +static void setDebugLocFromInst(IRBuilder<> &B, const Instruction *Inst) {
>>> +  if (Inst)
>>> +    B.SetCurrentDebugLocation(Inst->getDebugLoc());
>>> +  else
>>> +    B.SetCurrentDebugLocation(DebugLoc());
>>> +}
>>> +
>>> /// \brief Check if conditionally executed loads are hoistable.
>>> ///
>>> /// This class has two functions: isHoistableLoad and canHoistAllLoads.
>>> @@ -1238,7 +1223,7 @@ void InnerLoopVectorizer::vectorizeMemor
>>>   // Handle consecutive loads/stores.
>>>   GetElementPtrInst *Gep = dyn_cast<GetElementPtrInst>(Ptr);
>>>   if (Gep && Legal->isInductionVariable(Gep->getPointerOperand())) {
>>> -    DebugLocSetter SetDL(Builder, Gep);
>>> +    setDebugLocFromInst(Builder, Gep);
>>>     Value *PtrOperand = Gep->getPointerOperand();
>>>     Value *FirstBasePtr = getVectorValue(PtrOperand)[0];
>>>     FirstBasePtr = Builder.CreateExtractElement(FirstBasePtr, Zero);
>>> @@ -1249,7 +1234,7 @@ void InnerLoopVectorizer::vectorizeMemor
>>>     Gep2->setName("gep.indvar.base");
>>>     Ptr = Builder.Insert(Gep2);
>>>   } else if (Gep) {
>>> -    DebugLocSetter SetDL(Builder, Gep);
>>> +    setDebugLocFromInst(Builder, Gep);
>>>     assert(SE->isLoopInvariant(SE->getSCEV(Gep->getPointerOperand()),
>>>                                OrigLoop) && "Base ptr must be invariant");
>>>
>>> @@ -1282,7 +1267,7 @@ void InnerLoopVectorizer::vectorizeMemor
>>>   } else {
>>>     // Use the induction element ptr.
>>>     assert(isa<PHINode>(Ptr) && "Invalid induction ptr");
>>> -    DebugLocSetter SetDL(Builder, cast<Instruction>(Ptr));
>>> +    setDebugLocFromInst(Builder, cast<Instruction>(Ptr));
>>>     VectorParts &PtrVal = getVectorValue(Ptr);
>>>     Ptr = Builder.CreateExtractElement(PtrVal[0], Zero);
>>>   }
>>> @@ -1291,7 +1276,7 @@ void InnerLoopVectorizer::vectorizeMemor
>>>   if (SI) {
>>>     assert(!Legal->isUniform(SI->getPointerOperand()) &&
>>>            "We do not allow storing to uniform addresses");
>>> -    DebugLocSetter SetDL(Builder, SI);
>>> +    setDebugLocFromInst(Builder, SI);
>>>     // We don't want to update the value in the map as it might be used in
>>>     // another expression. So don't use a reference type for "StoredVal".
>>>     VectorParts StoredVal = getVectorValue(SI->getValueOperand());
>>> @@ -1318,7 +1303,7 @@ void InnerLoopVectorizer::vectorizeMemor
>>>
>>>   // Handle loads.
>>>   assert(LI && "Must have a load instruction");
>>> -  DebugLocSetter SetDL(Builder, LI);
>>> +  setDebugLocFromInst(Builder, LI);
>>>   for (unsigned Part = 0; Part < UF; ++Part) {
>>>     // Calculate the pointer for the specific unroll-part.
>>>     Value *PartPtr = Builder.CreateGEP(Ptr, Builder.getInt32(Part * VF));
>>> @@ -1342,7 +1327,7 @@ void InnerLoopVectorizer::scalarizeInstr
>>>   // Holds vector parameters or scalars, in case of uniform vals.
>>>   SmallVector<VectorParts, 4> Params;
>>>
>>> -  DebugLocSetter SetDL(Builder, Instr);
>>> +  setDebugLocFromInst(Builder, Instr);
>>>
>>>   // Find all of the vectorized parameters.
>>>   for (unsigned op = 0, e = Instr->getNumOperands(); op != e; ++op) {
>>> @@ -1571,7 +1556,7 @@ InnerLoopVectorizer::createEmptyLoop(Loo
>>>   Builder.SetInsertPoint(VecBody->getFirstInsertionPt());
>>>
>>>   // Generate the induction variable.
>>> -  DebugLocSetter SetDL(Builder, getDebugLocFromInstOrOperands(OldInduction));
>>> +  setDebugLocFromInst(Builder, getDebugLocFromInstOrOperands(OldInduction));
>>>   Induction = Builder.CreatePHI(IdxTy, 2, "index");
>>>   // The loop step is equal to the vectorization factor (num of SIMD elements)
>>>   // times the unroll factor (num of SIMD instructions).
>>> @@ -1580,8 +1565,8 @@ InnerLoopVectorizer::createEmptyLoop(Loo
>>>   // This is the IR builder that we use to add all of the logic for bypassing
>>>   // the new vector loop.
>>>   IRBuilder<> BypassBuilder(BypassBlock->getTerminator());
>>> -  DebugLocSetter SetDLByPass(BypassBuilder,
>>> -                             getDebugLocFromInstOrOperands(OldInduction));
>>> +  setDebugLocFromInst(BypassBuilder,
>>> +                      getDebugLocFromInstOrOperands(OldInduction));
>>>
>>>   // We may need to extend the index in case there is a type mismatch.
>>>   // We know that the count starts at zero and does not overflow.
>>> @@ -2061,6 +2046,9 @@ InnerLoopVectorizer::vectorizeLoop(LoopV
>>>     LoopVectorizationLegality::ReductionDescriptor RdxDesc =
>>>     (*Legal->getReductionVars())[RdxPhi];
>>>
>>> +    setDebugLocFromInst(Builder,
>>> +                        dyn_cast<Instruction>((Value*)RdxDesc.StartValue));
>>> +
>>>     // We need to generate a reduction vector from the incoming scalar.
>>>     // To do so, we need to generate the 'identity' vector and overide
>>>     // one of the elements with the incoming scalar reduction. We need
>>> @@ -2118,11 +2106,10 @@ InnerLoopVectorizer::vectorizeLoop(LoopV
>>>     Builder.SetInsertPoint(LoopMiddleBlock->getFirstInsertionPt());
>>>
>>>     VectorParts RdxParts;
>>> +    setDebugLocFromInst(Builder, RdxDesc.LoopExitInstr);
>>>     for (unsigned part = 0; part < UF; ++part) {
>>>       // This PHINode contains the vectorized reduction variable, or
>>>       // the initial value vector, if we bypass the vector loop.
>>> -      DebugLocSetter SetDL(Builder, RdxDesc.LoopExitInstr);
>>> -
>>>       VectorParts &RdxExitVal = getVectorValue(RdxDesc.LoopExitInstr);
>>>       PHINode *NewPhi = Builder.CreatePHI(VecTy, 2, "rdx.vec.exit.phi");
>>>       Value *StartVal = (part == 0) ? VectorStart : Identity;
>>> @@ -2135,9 +2122,8 @@ InnerLoopVectorizer::vectorizeLoop(LoopV
>>>     // Reduce all of the unrolled parts into a single vector.
>>>     Value *ReducedPartRdx = RdxParts[0];
>>>     unsigned Op = getReductionBinOp(RdxDesc.Kind);
>>> +    setDebugLocFromInst(Builder, dyn_cast<Instruction>(ReducedPartRdx));
>>>     for (unsigned part = 1; part < UF; ++part) {
>>> -      DebugLocSetter SetDL(Builder, dyn_cast<Instruction>(RdxParts[part]));
>>> -
>>>       if (Op != Instruction::ICmp && Op != Instruction::FCmp)
>>>         ReducedPartRdx = Builder.CreateBinOp((Instruction::BinaryOps)Op,
>>>                                              RdxParts[part], ReducedPartRdx,
>>> @@ -2155,7 +2141,6 @@ InnerLoopVectorizer::vectorizeLoop(LoopV
>>>     Value *TmpVec = ReducedPartRdx;
>>>     SmallVector<Constant*, 32> ShuffleMask(VF, 0);
>>>     for (unsigned i = VF; i != 1; i >>= 1) {
>>> -      DebugLocSetter SetDL(Builder, dyn_cast<Instruction>(ReducedPartRdx));
>>>       // Move the upper half of the vector to the lower half.
>>>       for (unsigned j = 0; j != i/2; ++j)
>>>         ShuffleMask[j] = Builder.getInt32(i/2 + j);
>>> @@ -2178,11 +2163,7 @@ InnerLoopVectorizer::vectorizeLoop(LoopV
>>>     }
>>>
>>>     // The result is in the first element of the vector.
>>> -    Value *Scalar0;
>>> -    {
>>> -      DebugLocSetter SetDL(Builder, dyn_cast<Instruction>(ReducedPartRdx));
>>> -      Scalar0 = Builder.CreateExtractElement(TmpVec, Builder.getInt32(0));
>>> -    }
>>> +    Value *Scalar0 = Builder.CreateExtractElement(TmpVec, Builder.getInt32(0));
>>>
>>>     // Now, we need to fix the users of the reduction variable
>>>     // inside and outside of the scalar remainder loop.
>>> @@ -2315,9 +2296,9 @@ InnerLoopVectorizer::vectorizeBlockInLoo
>>>         continue;
>>>       }
>>>
>>> +      setDebugLocFromInst(Builder, P);
>>>       // Check for PHI nodes that are lowered to vector selects.
>>>       if (P->getParent() != OrigLoop->getHeader()) {
>>> -        DebugLocSetter SetDL(Builder, P);
>>>         // We know that all PHIs in non header blocks are converted into
>>>         // selects, so we don't have to worry about the insertion order and we
>>>         // can just use the builder.
>>> @@ -2360,8 +2341,6 @@ InnerLoopVectorizer::vectorizeBlockInLoo
>>>       LoopVectorizationLegality::InductionInfo II =
>>>         Legal->getInductionVars()->lookup(P);
>>>
>>> -      DebugLocSetter SetDL(Builder, P);
>>> -
>>>       switch (II.IK) {
>>>       case LoopVectorizationLegality::IK_NoInduction:
>>>         llvm_unreachable("Unknown induction");
>>> @@ -2469,7 +2448,7 @@ InnerLoopVectorizer::vectorizeBlockInLoo
>>>     case Instruction::Xor: {
>>>       // Just widen binops.
>>>       BinaryOperator *BinOp = dyn_cast<BinaryOperator>(it);
>>> -      DebugLocSetter SetDL(Builder, BinOp);
>>> +      setDebugLocFromInst(Builder, BinOp);
>>>       VectorParts &A = getVectorValue(it->getOperand(0));
>>>       VectorParts &B = getVectorValue(it->getOperand(1));
>>>
>>> @@ -2496,7 +2475,7 @@ InnerLoopVectorizer::vectorizeBlockInLoo
>>>       // instruction with a scalar condition. Otherwise, use vector-select.
>>>       bool InvariantCond = SE->isLoopInvariant(SE->getSCEV(it->getOperand(0)),
>>>                                                OrigLoop);
>>> -      DebugLocSetter SetDL(Builder, it);
>>> +      setDebugLocFromInst(Builder, it);
>>>
>>>       // The condition can be loop invariant  but still defined inside the
>>>       // loop. This means that we can't just use the original 'cond' value.
>>> @@ -2521,7 +2500,7 @@ InnerLoopVectorizer::vectorizeBlockInLoo
>>>       // Widen compares. Generate vector compares.
>>>       bool FCmp = (it->getOpcode() == Instruction::FCmp);
>>>       CmpInst *Cmp = dyn_cast<CmpInst>(it);
>>> -      DebugLocSetter SetDL(Builder, it);
>>> +      setDebugLocFromInst(Builder, it);
>>>       VectorParts &A = getVectorValue(it->getOperand(0));
>>>       VectorParts &B = getVectorValue(it->getOperand(1));
>>>       for (unsigned Part = 0; Part < UF; ++Part) {
>>> @@ -2552,7 +2531,7 @@ InnerLoopVectorizer::vectorizeBlockInLoo
>>>     case Instruction::FPTrunc:
>>>     case Instruction::BitCast: {
>>>       CastInst *CI = dyn_cast<CastInst>(it);
>>> -      DebugLocSetter SetDL(Builder, it);
>>> +      setDebugLocFromInst(Builder, it);
>>>       /// Optimize the special case where the source is the induction
>>>       /// variable. Notice that we can only optimize the 'trunc' case
>>>       /// because: a. FP conversions lose precision, b. sext/zext may wrap,
>>> @@ -2579,8 +2558,7 @@ InnerLoopVectorizer::vectorizeBlockInLoo
>>>       // Ignore dbg intrinsics.
>>>       if (isa<DbgInfoIntrinsic>(it))
>>>         break;
>>> -
>>> -      DebugLocSetter SetDL(Builder, it);
>>> +      setDebugLocFromInst(Builder, it);
>>>
>>>       Module *M = BB->getParent()->getParent();
>>>       CallInst *CI = cast<CallInst>(it);
>>>
>>>
>>> _______________________________________________
>>> llvm-commits mailing list
>>> llvm-commits at cs.uiuc.edu
>>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>



More information about the llvm-commits mailing list