[SLPVectorizer] Don't deref std::end() of object

[JOE1994]

Summary

Dereferencing std::end() of an object can lead to undefined behavior
(e.g. segmentation fault, invalid memory access).

This commit updates SLPVectorizer to only dereference the iterator from
find_if_not() if it is not a std::end().

This prevents SLPVectorizer from crashing with certain workloads.

[fhahn]

Could you provide a test case?

[JOE1994]

Could you provide a test case?

I observed a compiler crash while compiling one of private benchmark programs at my company.
Crash happens during llvm::lto::LTO::runRegularLTO.

So far I haven't been successful in extracting a minimal reproducible example.

[JOE1994]

Code that calls find_if_not was added by commit d65cc8597792ab04142cd2214c46c5c167191bcd to improve compile time & scheduling resources.
Thus I expect that using V and OpValue as is when std::end() is returned shouldn't cause any issues.

This change doesn't cause any new LIT failures in llvm/test/Transforms/SLPVectorizer.

[ABataev]

Would be good to have tests

[JOE1994]

Abandoning this revision for the following reasons

• I've been unsuccessful at producing a reasonably reduced test case
• assertion failure not hit with opaque pointers enabled

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

 //===- SLPVectorizer.cpp - A bottom up SLP Vectorizer ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
Instruction &BoUpSLP::getLastInstructionInBundle(const TreeEntry *E) {
   Instruction *LastInst = nullptr;
 
   // Find the last instruction. The common case should be that BB has been
   // scheduled, and the last instruction is VL.back(). So we start with
   // VL.back() and iterate over schedule data until we reach the end of the
   // bundle. The end of the bundle is marked by null ScheduleData.
   if (BlocksSchedules.count(BB)) {
     Value *V = E->isOneOf(E->Scalars.back());
-    if (doesNotNeedToBeScheduled(V))
-      V = *find_if_not(E->Scalars, doesNotNeedToBeScheduled);
+    if (doesNotNeedToBeScheduled(V)) {
+      auto AltValIter = find_if_not(E->Scalars, doesNotNeedToBeScheduled);
+      if (AltValIter != std::end(E->Scalars))
+        V = *AltValIter;
+    }
     auto *Bundle = BlocksSchedules[BB]->getScheduleData(V);
     if (Bundle && Bundle->isPartOfBundle())
       for (; Bundle; Bundle = Bundle->NextInBundle)
         if (Bundle->OpValue == Bundle->Inst)
           LastInst = Bundle->Inst;
   }
 
   // LastInst can still be null at this point if there's either not an entry

 }
 
 void BoUpSLP::BlockScheduling::cancelScheduling(ArrayRef<Value *> VL,
                                                 Value *OpValue) {
   if (isa<PHINode>(OpValue) || isVectorLikeInstWithConstOps(OpValue) ||
       doesNotNeedToSchedule(VL))
     return;
 
-  if (doesNotNeedToBeScheduled(OpValue))
-    OpValue = *find_if_not(VL, doesNotNeedToBeScheduled);
+  if (doesNotNeedToBeScheduled(OpValue)) {
+    auto AltValIter = find_if_not(VL, doesNotNeedToBeScheduled);
+    if (AltValIter != std::end(VL))
+      OpValue = *AltValIter;
+  }
   ScheduleData *Bundle = getScheduleData(OpValue);
   LLVM_DEBUG(dbgs() << "SLP:  cancel scheduling of " << *Bundle << "\n");
   assert(!Bundle->IsScheduled &&
          "Can't cancel bundle which is already scheduled");
   assert(Bundle->isSchedulingEntity() &&
          (Bundle->isPartOfBundle() || needToScheduleSingleInstruction(VL)) &&
          "tried to unbundle something which is not a bundle");