LoopVersioning: Use default LAA runtimeCheck, When input check not provided.

[ashutosh.nema]

Summary

In this change enabled LoopVersioning utility to add runtime check
when input check is NULL. Earlier clients of loop versioning needs to
always pass runtime check. Now made this optional.
If user does not provide runtime check, LoopVersioning will use default
LoopAccessAnalysis runtime check.

[anemet]

include/llvm/Transforms/Utils/LoopVersioning.h

33–44

How about adding another constructor that does not take Checks instead? Then you should be able to initialize Checks with LAI.getRuntimePointerChecking()->getChecks().

I like the fact that LoopVersioning owns the checks. That keeps things simple.

[ashutosh.nema]

Sure Adam, will update it.

Thanks,
Ashutosh

[ashutosh.nema]

Incorporated comments from Adam.

[anemet]

lib/Transforms/Utils/LoopVersioning.cpp

34–40

Can't we initialize Checks in the constructor initializer list, i.e. Checks(LAI.getRuntimePointerChecking()->getChecks())?

Is the reason that getChecks return SmallVectorImpl rather than SmallVector<.., 4> ?

If yes then I think we should probably change getChecks to return SmallVector rather than SmallVectorImpl.

What do you think?

[ashutosh.nema]

lib/Transforms/Utils/LoopVersioning.cpp

34–40

Yes, that's the reason that getChecks return SmallVectorImpl rather than SmallVector<.., 4> ?

Will modify getChecks to return SmallVector rather than SmallVectorImpl.

Thanks,
Ashutosh

[ashutosh.nema]

Incorporated comments from Adam.

[anemet]

lib/Transforms/Utils/LoopVersioning.cpp

25–30

Please don't change the order of the member variables. It was nice how the required analyses were grouped all together.

I understand that you can't use LAI, the member, before you initialize it but you should be able to fix that by naming the parameter to the constructor differently, e.g., LAInfo or something and then use LAInfo when calling getChecks().

[ashutosh.nema]

Incorporated comments from Adam.

[anemet]

LGTM, thanks for fixing this.

[ashutosh.nema]

Thanks Adam.

I don’t have check in access, if possible can you please check in this change.

Regards,
Ashutosh

[ashutosh.nema]

r244763

include/llvm/Analysis/LoopAccessAnalysis.h

typedef std::pair<const CheckingPtrGroup *, const CheckingPtrGroup *>
       PointerCheck;
 
   /// \brief Generate the checks and store it.  This also performs the grouping
   /// of pointers to reduce the number of memchecks necessary.
   void generateChecks(MemoryDepChecker::DepCandidates &DepCands,
                       bool UseDependencies);
 
   /// \brief Returns the checks that generateChecks created.
-  const SmallVectorImpl<PointerCheck> &getChecks() const { return Checks; }
+  const SmallVector<PointerCheck, 4> &getChecks() const { return Checks; }
 
   /// \brief Decide if we need to add a check between two groups of pointers,
   /// according to needsChecking.
   bool needsChecking(const CheckingPtrGroup &M,
                      const CheckingPtrGroup &N) const;
 
   /// \brief Returns the number of run-time checks required according to
   /// needsChecking.

include/llvm/Transforms/Utils/LoopVersioning.h

 class LoopInfo;
 
 /// \brief This class emits a version of the loop where run-time checks ensure
 /// that may-alias pointers can't overlap.
 ///
 /// It currently only supports single-exit loops and assumes that the loop
 /// already has a preheader.
 class LoopVersioning {
 public:
+  /// \brief Expects MemCheck, LoopAccessInfo, Loop, LoopInfo, DominatorTree 
+  /// as input. It uses runtime check provided by user.
   LoopVersioning(SmallVector<RuntimePointerChecking::PointerCheck, 4> Checks,
                  const LoopAccessInfo &LAI, Loop *L, LoopInfo *LI,
                  DominatorTree *DT);
 
+  /// \brief Expects LoopAccessInfo, Loop, LoopInfo, DominatorTree as input.
+  /// It uses default runtime check provided by LoopAccessInfo.
+  LoopVersioning(const LoopAccessInfo &LAInfo, Loop *L, LoopInfo *LI,
+                 DominatorTree *DT);
+
   /// \brief Performs the CFG manipulation part of versioning the loop including
   /// the DominatorTree and LoopInfo updates.
   ///
   /// The loop that was used to construct the class will be the "versioned" loop
   /// i.e. the loop that will receive control if all the memchecks pass.
   ///
   /// This allows the loop transform pass to operate on the same loop regardless
   /// of whether versioning was necessary or not:

lib/Transforms/Utils/LoopVersioning.cpp

 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/LoopVersioning.h"
 
 using namespace llvm;
 
 LoopVersioning::LoopVersioning(
     SmallVector<RuntimePointerChecking::PointerCheck, 4> Checks,
     const LoopAccessInfo &LAI, Loop *L, LoopInfo *LI, DominatorTree *DT)
     : VersionedLoop(L), NonVersionedLoop(nullptr), Checks(std::move(Checks)),
       LAI(LAI), LI(LI), DT(DT) {
   assert(L->getExitBlock() && "No single exit block");
   assert(L->getLoopPreheader() && "No preheader");
 }
 
+LoopVersioning::LoopVersioning(const LoopAccessInfo &LAInfo, Loop *L,
+                               LoopInfo *LI, DominatorTree *DT)
+    : VersionedLoop(L), NonVersionedLoop(nullptr),
+      Checks(LAInfo.getRuntimePointerChecking()->getChecks()), LAI(LAInfo),
+      LI(LI), DT(DT) {
+  assert(L->getExitBlock() && "No single exit block");
+  assert(L->getLoopPreheader() && "No preheader");
+}
+
 void LoopVersioning::versionLoop(Pass *P) {
   Instruction *FirstCheckInst;
   Instruction *MemRuntimeCheck;
   // Add the memcheck in the original preheader (this is empty initially).
   BasicBlock *MemCheckBB = VersionedLoop->getLoopPreheader();
   std::tie(FirstCheckInst, MemRuntimeCheck) =
       LAI.addRuntimeChecks(MemCheckBB->getTerminator(), Checks);
   assert(MemRuntimeCheck && "called even though needsAnyChecking = false");