[scan-build] fix warnings emitted on LLVM Transforms code base

[apelete]

Summary

Fix logic error warnings of the type "called C++ object pointer is
null" emitted by Clang Static Analyzer on the following files:

• lib/Transforms/Scalar/ScalarReplAggregates.cpp,
• lib/Transforms/Scalar/StructurizeCFG.cpp,
• lib/Transforms/Scalar/TailRecursionElimination.cpp,
• lib/Transforms/Scalar/RewriteStatepointsForGC.cpp,
• lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp,
• lib/Transforms/Scalar/ConstantHoisting.cpp,
• lib/Transforms/Vectorize/SLPVectorizer.cpp.

Signed-off-by: Apelete Seketeli <[e-mail]>

[reames]

Per issues raised on llvm-dev, not yet ready for review. Please update once general questions are resolved.

Marking as "request changes" purely to hide this from my active review queue until concerns are resolved.

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

bool InstCombiner::SimplifyStoreAtEndOfBlock(StoreInst &SI) {
   if (++PI != pred_end(DestBB))
     return false;
 
   // Bail out if all the relevant blocks aren't distinct (this can happen,
   // for example, if SI is in an infinite loop)
   if (StoreBB == DestBB || OtherBB == DestBB)
     return false;
 
+  assert(OtherBB && "BasicBlock needs to be not NULL");
+
   // Verify that the other block ends in a branch and is not otherwise empty.
   BasicBlock::iterator BBI(OtherBB->getTerminator());
   BranchInst *OtherBr = dyn_cast<BranchInst>(BBI);
   if (!OtherBr || BBI == OtherBB->begin())
     return false;
 
   // If the other block ends in an unconditional branch, check for the 'if then
   // else' case.  there is an instruction before the branch.

lib/Transforms/Scalar/ConstantHoisting.cpp

Instruction *ConstantHoisting::findMatInsertPt(Instruction *Inst,
   BasicBlock *IDom = DT->getNode(Inst->getParent())->getIDom()->getBlock();
   return IDom->getTerminator();
 }
 
 /// \brief Find an insertion point that dominates all uses.
 Instruction *ConstantHoisting::
 findConstantInsertionPoint(const ConstantInfo &ConstInfo) const {
   assert(!ConstInfo.RebasedConstants.empty() && "Invalid constant info entry.");
+  assert(Entry && "Entry basic block cannot be NULL");
   // Collect all basic blocks.
   SmallPtrSet<BasicBlock *, 8> BBs;
   for (auto const &RCI : ConstInfo.RebasedConstants)
     for (auto const &U : RCI.Uses)
       BBs.insert(findMatInsertPt(U.Inst, U.OpndIdx)->getParent());
 
   if (BBs.count(Entry))
     return &Entry->front();

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

#endif
       // Find the instruction which produces the base for each input.  We may
       // need to insert a bitcast.
       Value *Base = getBaseForInput(InVal, BaseEE);
       BaseEE->setOperand(0, Base);
     } else {
       auto *BaseIE = cast<InsertElementInst>(State.getBase());
       auto *BdvIE = cast<InsertElementInst>(BDV);
       auto UpdateOperand = [&](int OperandIdx) {
+        assert(BaseIE && "base InsertElementInst must not be NULL");
         Value *InVal = BdvIE->getOperand(OperandIdx);
         Value *Base = getBaseForInput(InVal, BaseIE);
         BaseIE->setOperand(OperandIdx, Base);
       };
       UpdateOperand(0); // vector operand
       UpdateOperand(1); // scalar operand
     }
 

lib/Transforms/Scalar/ScalarReplAggregates.cpp

for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E;) {
     }
   }
 }
 
 /// RewriteBitCast - Update a bitcast reference to the alloca being replaced
 /// and recursively continue updating all of its uses.
 void SROA::RewriteBitCast(BitCastInst *BC, AllocaInst *AI, uint64_t Offset,
                           SmallVectorImpl<AllocaInst *> &NewElts) {
+  assert((BC && AI) && "BitCast and Alloca cannot be null" );
   RewriteForScalarRepl(BC, AI, Offset, NewElts);
   if (BC->getOperand(0) != AI)
     return;
 
   // The bitcast references the original alloca.  Replace its uses with
   // references to the alloca containing offset zero (which is normally at
   // index zero, but might not be in cases involving structs with elements
   // of size zero).

lib/Transforms/Scalar/StructurizeCFG.cpp

BasicBlock *Flow = BasicBlock::Create(Context, FlowBlockName,
                                         Func, Insert);
   DT->addNewBlock(Flow, Dominator);
   ParentRegion->getRegionInfo()->setRegionFor(Flow, ParentRegion);
   return Flow;
 }
 
 /// \brief Create a new or reuse the previous node as flow node
 BasicBlock *StructurizeCFG::needPrefix(bool NeedEmpty) {
+  assert(PrevNode && "cannot reuse null PrevNode as flow node");
+
   BasicBlock *Entry = PrevNode->getEntry();
 
   if (!PrevNode->isSubRegion()) {
     killTerminator(Entry);
     if (!NeedEmpty || Entry->getFirstInsertionPt() == Entry->end())
       return Entry;
 
   }

lib/Transforms/Scalar/TailRecursionElimination.cpp

while (true) {
     --BBI;
   }
 
   // If this call is marked as a tail call, and if there are dynamic allocas in
   // the function, we cannot perform this optimization.
   if (CI->isTailCall() && CannotTailCallElimCallsMarkedTail)
     return nullptr;
 
+  assert(F && "BasicBlock parent did not have an enclosing method");
   // As a special case, detect code like this:
   //   double fabs(double f) { return __builtin_fabs(f); } // a 'fabs' call
   // and disable this xform in this case, because the code generator will
   // lower the call to fabs into inline code.
   if (BB == &F->getEntryBlock() &&
       FirstNonDbg(BB->front().getIterator()) == CI &&
       FirstNonDbg(std::next(BB->begin())) == TI && CI->getCalledFunction() &&
       !TTI->isLoweredToCall(CI->getCalledFunction())) {

lib/Transforms/Vectorize/SLPVectorizer.cpp

std::stable_sort(CSEWorkList.begin(), CSEWorkList.end(),
     return DT->properlyDominates(A, B);
   });
 
   // Perform O(N^2) search over the gather sequences and merge identical
   // instructions. TODO: We can further optimize this scan if we split the
   // instructions into different buckets based on the insert lane.
   SmallVector<Instruction *, 16> Visited;
   for (auto I = CSEWorkList.begin(), E = CSEWorkList.end(); I != E; ++I) {
+    assert((I && *I) && "worklist does not contain any reachable block");
     assert((I == CSEWorkList.begin() || !DT->dominates(*I, *std::prev(I))) &&
            "Worklist not sorted properly!");
     BasicBlock *BB = (*I)->getBlock();
     // For all instructions in blocks containing gather sequences:
     for (BasicBlock::iterator it = BB->begin(), e = BB->end(); it != e;) {
       Instruction *In = &*it++;
       if (!isa<InsertElementInst>(In) && !isa<ExtractElementInst>(In))
         continue;
if (ReSchedule) {
     initialFillReadyList(ReadyInsts);
   }
 
   DEBUG(dbgs() << "SLP: try schedule bundle " << *Bundle << " in block "
                << BB->getName() << "\n");
 
   calculateDependencies(Bundle, true, SLP);
 
+  assert(Bundle && "is an empty instruction bundle");
   // Now try to schedule the new bundle. As soon as the bundle is "ready" it
   // means that there are no cyclic dependencies and we can schedule it.
   // Note that's important that we don't "schedule" the bundle yet (see
   // cancelScheduling).
   while (!Bundle->isReady() && !ReadyInsts.empty()) {
 
     ScheduleData *pickedSD = ReadyInsts.back();
     ReadyInsts.pop_back();