Make the MemDepPrinter to print something

[dmikushin]

Summary

While exploring dependency analysis capabilities, I've discovered by current design MemDepPrinter has a print() function, which is never called anywhere. Thus, opt -print-memdeps never prints anything. This trivial patch change the pass to print the dependencies right from the function pass.

[dmikushin]

Example:

$ cat example.c
void vector_sum(int length, float* in1, float* in2, float* out)
{
	for (int i = 0; i < length; i++)
		out[i] = in1[i] + in2[i];
}

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
	if (argc != 2) return 1;

	int length = atoi(argv[1]);

	float* in1 = (float*)malloc(length * sizeof(float));
	float* in2 = (float*)malloc(length * sizeof(float));
	float* out = (float*)malloc(length * sizeof(float));
	for (int i = 0; i < length; i++)
	{
		in1[i] = drand48();
		in2[i] = drand48();
	}
	
	vector_sum(length, in1, in2, out);
	
	//printf("%f\n", out[length - 1]);
	
	return 0;
}

$ clang -emit-llvm -c -S -O1 example.c -o - | opt -memdep -print-memdeps -o /dev/null
Function vector_sum memory dependencies:

    Unknown in block %for.body
    Unknown in block %entry
  %0 = load float* %arrayidx, align 4, !tbaa !1

    Unknown in block %for.body
    Unknown in block %entry
  %1 = load float* %arrayidx2, align 4, !tbaa !1

    Def from:   %1 = load float* %arrayidx2, align 4, !tbaa !1
  store float %add, float* %arrayidx4, align 4, !tbaa !1


Function main memory dependencies:

    Unknown in block %entry
  %0 = load i8** %arrayidx, align 8, !tbaa !1

    Clobber from:   %0 = load i8** %arrayidx, align 8, !tbaa !1
  %call = tail call i32 @atoi(i8* %0) #3

    Clobber from:   %call = tail call i32 @atoi(i8* %0) #3
  %call1 = tail call noalias i8* @malloc(i64 %mul) #4

    Clobber from:   %call1 = tail call noalias i8* @malloc(i64 %mul) #4
  %call4 = tail call noalias i8* @malloc(i64 %mul) #4

    Clobber from:   %call4 = tail call noalias i8* @malloc(i64 %mul) #4
  %call7 = tail call noalias i8* @malloc(i64 %mul) #4

    Clobber in block %if.end from:   %call7 = tail call noalias i8* @malloc(i64 %mul) #4
    Clobber in block %for.body from:   store float %conv14, float* %arrayidx16, align 4, !tbaa !5
  %call10 = tail call double @drand48() #4

    Clobber from:   %call10 = tail call double @drand48() #4
  store float %conv11, float* %arrayidx12, align 4, !tbaa !5

    Clobber from:   store float %conv11, float* %arrayidx12, align 4, !tbaa !5
  %call13 = tail call double @drand48() #4

    Clobber from:   %call13 = tail call double @drand48() #4
  store float %conv14, float* %arrayidx16, align 4, !tbaa !5

    Clobber in block %if.end from:   %call7 = tail call noalias i8* @malloc(i64 %mul) #4
    Clobber in block %for.body from:   store float %conv14, float* %arrayidx16, align 4, !tbaa !5
  tail call void @vector_sum(i32 %call, float* %1, float* %2, float* %3)


Function atoi memory dependencies:

    NonFuncLocal
  %call = tail call i64 @strtol(i8* nocapture %__nptr, i8** null, i32 10) #3

[sunfish]

The print-memdeps pass was written to be used with opt's -analyze feature. If you run opt -print-memdeps -analyze, it prints.

[sunfish]

print is called from -analyze.

[dmikushin]

Hi Dan,

OK, I missed that because other -print-* passes are just printing to stderr without -analyze... So is -analyze necessary?

Also, I have a question: why for the store from 2 loads in the IR code below I get store having only single Def dependency on one of the loads, not on both of them?

Thanks,

• D.

define void @vector_sum(i32 %length, float* nocapture readonly %in1, float* nocapture readonly %in2, float* nocapture %out) #0 {
entry:
  %cmp9 = icmp sgt i32 %length, 0
  br i1 %cmp9, label %for.body, label %for.end

for.body:                     ; preds = %entry, %for.body
  %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %entry ]
  %arrayidx = getelementptr inbounds float* %in1, i64 %indvars.iv
  %0 = load float* %arrayidx, align 4, !tbaa !1
  %arrayidx2 = getelementptr inbounds float* %in2, i64 %indvars.iv
  %1 = load float* %arrayidx2, align 4, !tbaa !1
  %add = fadd float %0, %1
  %arrayidx4 = getelementptr inbounds float* %out, i64 %indvars.iv
  store float %add, float* %arrayidx4, align 4, !tbaa !1
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %lftr.wideiv = trunc i64 %indvars.iv.next to i32
  %exitcond = icmp eq i32 %lftr.wideiv, %length
  br i1 %exitcond, label %for.end, label %for.body

for.end:                      ; preds = %for.body, %entry
  ret void
}

$ clang -emit-llvm example.c -O1 -S -o - | opt -memdep -print-memdeps -o /dev/null

Function vector_sum memory dependencies:

    Unknown in block %for.body
    Unknown in block %entry
  %0 = load float* %arrayidx, align 4, !tbaa !1

    Unknown in block %for.body
    Unknown in block %entry
  %1 = load float* %arrayidx2, align 4, !tbaa !1

    Def from:   %1 = load float* %arrayidx2, align 4, !tbaa !1
  store float %add, float* %arrayidx4, align 4, !tbaa !1

[sunfish]

I am not presently using the memdep printer pass, so if it's not working properly, it's fine with me to remove it from the tree.

lib/Analysis/MemDepPrinter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/Passes.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/MemoryDependenceAnalysis.h"
 #include "llvm/Assembly/Writer.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/CallSite.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/InstIterator.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 namespace {
   struct MemDepPrinter : public FunctionPass {
     const Function *F;
struct MemDepPrinter : public FunctionPass {
 
     static char ID; // Pass identifcation, replacement for typeid
     MemDepPrinter() : FunctionPass(ID) {
       initializeMemDepPrinterPass(*PassRegistry::getPassRegistry());
     }
 
     virtual bool runOnFunction(Function &F);
 
-    void print(raw_ostream &OS, const Module * = 0) const;
-
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
       AU.addRequiredTransitive<AliasAnalysis>();
       AU.addRequiredTransitive<MemoryDependenceAnalysis>();
       AU.setPreservesAll();
     }
 
     virtual void releaseMemory() {
       Deps.clear();
static InstTypePair getInstTypePair(MemDepResult dep) {
       if (dep.isNonFuncLocal())
         return InstTypePair(dep.getInst(), NonFuncLocal);
       assert(dep.isUnknown() && "unexptected dependence type");
       return InstTypePair(dep.getInst(), Unknown);
     }
     static InstTypePair getInstTypePair(const Instruction* inst, DepType type) {
       return InstTypePair(inst, type);
     }
+    void print(raw_ostream &OS, const Module * = 0) const;
   };
 }
 
 char MemDepPrinter::ID = 0;
 INITIALIZE_PASS_BEGIN(MemDepPrinter, "print-memdeps",
                       "Print MemDeps of function", false, true)
 INITIALIZE_PASS_DEPENDENCY(MemoryDependenceAnalysis)
 INITIALIZE_PASS_END(MemDepPrinter, "print-memdeps",
if (!Res.isNonLocal()) {
       DepSet &InstDeps = Deps[Inst];
       for (SmallVectorImpl<NonLocalDepResult>::const_iterator
            I = NLDI.begin(), E = NLDI.end(); I != E; ++I) {
         const MemDepResult &Res = I->getResult();
         InstDeps.insert(std::make_pair(getInstTypePair(Res), I->getBB()));
       }
     }
   }
   
+  print(dbgs(), F.getParent());
+
   return false;
 }
 
 void MemDepPrinter::print(raw_ostream &OS, const Module *M) const {
+  OS << "Function " << F->getName() << " memory dependencies:\n\n";
   for (const_inst_iterator I = inst_begin(*F), E = inst_end(*F); I != E; ++I) {
     const Instruction *Inst = &*I;
 
     DepSetMap::const_iterator DI = Deps.find(Inst);
     if (DI == Deps.end())
       continue;
 
     const DepSet &InstDeps = DI->second;
for (DepSet::const_iterator I = InstDeps.begin(), E = InstDeps.end();
         DepInst->print(OS);
       }
       OS << "\n";
     }
 
     Inst->print(OS);
     OS << "\n\n";
   }
+  OS << "\n";
 }