Address review comments

Author: david-arm

llvm/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h

@@ -434,9 +434,9 @@ class LoopVectorizationLegality {
 
   /// Return a vector of all potentially faulting pointers in a loop with
   /// uncountable early exits.
-  const SmallVectorImpl<std::pair<const SCEV *, Type *>> *
+  ArrayRef<std::pair<const SCEV *, Type *>>
   getPotentiallyFaultingPointers() const {
-    return &PotentiallyFaultingPtrs;
+    return PotentiallyFaultingPtrs;
   }
 
   /// Returns a HistogramInfo* for the given instruction if it was determined
@@ -547,7 +547,7 @@ class LoopVectorizationLegality {
   /// Returns true if all loads in the loop contained in \p Loads can be
   /// analyzed as potentially faulting. Any loads that may fault are added to
   /// the member variable PotentiallyFaultingPtrs.
-  bool analyzePotentiallyFaultingLoads(SmallVectorImpl<LoadInst *> *Loads);
+  bool analyzePotentiallyFaultingLoads(SmallVectorImpl<LoadInst *> &Loads);
 
   /// Return true if all of the instructions in the block can be speculatively
   /// executed, and record the loads/stores that require masking.

llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

@@ -1603,17 +1603,20 @@ bool LoopVectorizationLegality::canVectorizeLoopNestCFG(
 }
 
 bool LoopVectorizationLegality::analyzePotentiallyFaultingLoads(
-    SmallVectorImpl<LoadInst *> *Loads) {
+    SmallVectorImpl<LoadInst *> &Loads) {
   LLVM_DEBUG(dbgs() << "LV: Looking for potentially faulting loads in loop "
                        "with uncountable early exit:\n");
-  for (LoadInst *LI : *Loads) {
+  for (LoadInst *LI : Loads) {
     LLVM_DEBUG(dbgs() << "LV:   Load: " << *LI << '\n');
-    Value *Ptr = LI->getPointerOperand();
-    if (!Ptr)
+    if (LI->getPointerAddressSpace())
       return false;
+
+    Value *Ptr = LI->getPointerOperand();
     const SCEV *PtrExpr = PSE.getSCEV(Ptr);
     const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(PtrExpr);
     // TODO: Deal with loop invariant pointers.
+    // NOTE: The reasoning below is only safe if the load executes at least
+    // once.
     if (!AR || AR->getLoop() != TheLoop || !AR->isAffine())
       return false;
     auto Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(*PSE.getSE()));
@@ -1785,7 +1788,7 @@ bool LoopVectorizationLegality::isVectorizableEarlyExitLoop() {
 
   if (!NonDerefLoads.empty()) {
     if (!TTI->getMinPageSize() ||
-        !analyzePotentiallyFaultingLoads(&NonDerefLoads)) {
+        !analyzePotentiallyFaultingLoads(NonDerefLoads)) {
       PotentiallyFaultingPtrs.clear();
       reportVectorizationFailure(
           "Loop may fault",

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

@@ -2170,13 +2170,13 @@ class GeneratedRTChecks {
 } // namespace
 
 static void addPointerAlignmentChecks(
-    const SmallVectorImpl<std::pair<const SCEV *, Type *>> *Ptrs, Function *F,
+    ArrayRef<std::pair<const SCEV *, Type *>> Ptrs, Function *F,
     PredicatedScalarEvolution &PSE, TargetTransformInfo *TTI, ElementCount VF,
     unsigned IC) {
   ScalarEvolution *SE = PSE.getSE();
   const DataLayout &DL = SE->getDataLayout();
 
-  for (auto Ptr : *Ptrs) {
+  for (auto Ptr : Ptrs) {
     Type *PtrIntType = DL.getIntPtrType(Ptr.first->getType());
     APInt EltSize(PtrIntType->getScalarSizeInBits(),
                   DL.getTypeStoreSize(Ptr.second).getFixedValue());
@@ -2186,7 +2186,7 @@ static void addPointerAlignmentChecks(
         SE->getMulExpr(ScevEC, SE->getConstant(EltSize),
                        (SCEV::NoWrapFlags)(SCEV::FlagNSW | SCEV::FlagNUW));
     const SCEV *Rem = SE->getURemExpr(Start, Align);
-    PSE.addPredicate(*(SE->getEqualPredicate(Rem, SE->getZero(PtrIntType))));
+    PSE.addPredicate(*SE->getEqualPredicate(Rem, SE->getZero(PtrIntType)));
   }
 }