[LV] Add debug output to print interleaved groups

[anna]

Summary

Add interleaved groups available after interleave analysis is done.
See updated tests.

[anna]

shall I go ahead and land this? Simple enough change.

[fhahn]

llvm/lib/Analysis/VectorUtils.cpp

31

IMO it would be fine to print this with general debug?

llvm/test/Transforms/LoopVectorize/X86/vector_ptr_load_store.ll

1

unrelated change?

[anna]

llvm/lib/Analysis/VectorUtils.cpp

31

Sure, it would update many tests, but that would be better I suppose to see what happens.

llvm/test/Transforms/LoopVectorize/X86/vector_ptr_load_store.ll

1

With the -debug flag it was printing out the interleaved groups as well, which I felt takes away focus from the main check lines.

[Ayal]

llvm/include/llvm/Analysis/VectorUtils.h

654

Would it be better to have InterleaveGroup::print(raw_ostream &OS) take care of dumping its members, possibly along with their indices, designated InsertPos, and IG's Factor/Reverse/Alignment attributes?
Under #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

llvm/include/llvm/Analysis/VectorUtils.h

InterleaveGroup(InstTy *Instr, int32_t Stride, Align Alignment)
     Reverse = Stride < 0;
     Members[0] = Instr;
   }
 
   bool isReverse() const { return Reverse; }
   uint32_t getFactor() const { return Factor; }
   Align getAlign() const { return Alignment; }
   uint32_t getNumMembers() const { return Members.size(); }
+  SmallVector<InstTy *> getMembers() const {
+    SmallVector<InstTy *> Mems;
+    for (auto &It : Members)
+      Mems.push_back(It.second);
+    return Mems;
+  }
 
   /// Try to insert a new member \p Instr with index \p Index and
   /// alignment \p NewAlign. The index is related to the leader and it could be
   /// negative if it is the new leader.
   ///
   /// \returns false if the instruction doesn't belong to the group.
   bool insertMember(InstTy *Instr, int32_t Index, Align NewAlign) {
     // Make sure the key fits in an int32_t.

llvm/lib/Analysis/VectorUtils.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/CommandLine.h"
 
 #define DEBUG_TYPE "vectorutils"
 
+const char VerboseDebug[] = DEBUG_TYPE "-verbose";
+
 using namespace llvm;
 using namespace llvm::PatternMatch;
 
 /// Maximum factor for an interleaved memory access.
 static cl::opt<unsigned> MaxInterleaveGroupFactor(
     "max-interleave-group-factor", cl::Hidden,
     cl::desc("Maximum factor for an interleaved access group (default = 8)"),
     cl::init(8));
for (auto *Group : StoreGroups) {
     if (InvalidateGroupIfMemberMayWrap(Group, 0, std::string("first")))
       continue;
     for (int Index = Group->getFactor() - 1; Index > 0; Index--)
       if (Group->getMember(Index)) {
         InvalidateGroupIfMemberMayWrap(Group, Index, std::string("last"));
         break;
       }
   }
+  // Print out all load and store groups
+  DEBUG_WITH_TYPE(VerboseDebug, {
+      dbgs() << "Interleaved Groups\n";
+  for (InterleaveGroup<Instruction> *IG : getInterleaveGroups()) {
+    dbgs() << "Group with members: "<< "\n";
+    for (auto *I : IG->getMembers()) {
+      dbgs() << *I << "\n";
+    }    
+  }
+  });
 }
 
 void InterleavedAccessInfo::invalidateGroupsRequiringScalarEpilogue() {
   // If no group had triggered the requirement to create an epilogue loop,
   // there is nothing to do.
   if (!requiresScalarEpilogue())
     return;
 

llvm/test/Transforms/LoopVectorize/X86/interleaved-accesses-use-after-free.ll

 ; REQUIRES: asserts
 ; RUN: opt -passes=loop-vectorize -debug-only=loop-accesses -force-vector-width=4 -disable-output %s 2>&1 | FileCheck %s -check-prefix=LOOP-ACCESS
-; RUN: opt -passes=loop-vectorize -debug-only=vectorutils -force-vector-width=4 -disable-output %s 2>&1 | FileCheck %s
+; RUN: opt -passes=loop-vectorize -debug-only=vectorutils -debug-only=vectorutils-verbose -force-vector-width=4 -disable-output %s 2>&1 | FileCheck %s
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-redhat-linux-gnu"
 
 %struct.foo = type { ptr, ptr, ptr }
 %struct.pluto = type <{ %struct.wombat, %struct.spam, %struct.wibble, [6 x i8] }>
 %struct.wombat = type { %struct.barney }
 %struct.barney = type { %struct.widget }
 %struct.widget = type { %struct.hoge }

 ; CHECK: LV: Inserted:  store ptr %load7, ptr %getelementptr, align 8
 ; CHECK:     into the interleave group with  store ptr null, ptr %phi5
 
 ; CHECK: LV: Creating an interleave group with:  store ptr null, ptr %getelementptr13, align 8
 ; CHECK: LV: Inserted:  store ptr null, ptr %phi6, align 8
 ; CHECK:     into the interleave group with  store ptr null, ptr %getelementptr13
 ; CHECK: LV: Invalidated store group due to dependence between   store ptr %load7, ptr %getelementptr, align 8 and   store ptr null, ptr %getelementptr13, align 8
 ; CHECK-NOT: LV: Invalidated store group due to dependence between
-
+; CHECK: Interleaved Groups
+; CHECK: Group with members: 
+; CHECK:   %load7 = load ptr, ptr %phi6, align 8
+; CHECK: Group with members: 
+; CHECK:   %load12 = load ptr, ptr %phi6, align 8
 ; Note: The (only) invalidated store group is the one containing A (store ptr %load7, ptr %getelementptr, align 8) which is:
 ; Group with instructions:  
 ;   store ptr null, ptr %phi5, align 8
 ;   store ptr %load7, ptr %getelementptr, align 8
 ;   store ptr %load12, ptr %getelementptr11, align 8
 define void @test(ptr %arg, ptr %arg1) local_unnamed_addr #0 {
 bb:
   br label %bb2

llvm/test/Transforms/LoopVectorize/X86/vector_ptr_load_store.ll

-; RUN: opt -passes=loop-vectorize -mcpu=corei7-avx -debug -S < %s 2>&1 | FileCheck %s
+; RUN: opt -passes=loop-vectorize -mcpu=corei7-avx -debug-only=loop-vectorize -S < %s 2>&1 | FileCheck %s
 ; REQUIRES: asserts
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.8.0"
 
 %0 = type { ptr, %1 }
 %1 = type { ptr, i32 }