Teach MemDepPrinter about NonLocal MemDepResults

[njw45]

Summary

MemDepPrinter currently fails an assertion when it tries to print a NonLocal MemDepResult. This commit adds support for printing NonLocal results, but as there are now five DepTypes it can print I had to change the std::pair of PointerIntPair and basic block pointer it used into a std::tuple.

(lldb) f 5
frame #5: 0x000000010182744b opt`(anonymous namespace)::MemDepPrinter::getInstTypePair(dep=MemDepResult at   0x00007fff5fbfd510) + 267 at MemDepPrinter.cpp:70
   67  	        return InstTypePair(dep.getInst(), Def);
   68  	      if (dep.isNonFuncLocal())
   69  	        return InstTypePair(dep.getInst(), NonFuncLocal);
-> 70  	      assert(dep.isUnknown() && "unexpected dependence type");
   71  	      return InstTypePair(dep.getInst(), Unknown);
   72  	    }
   73  	    static InstTypePair getInstTypePair(const Instruction* inst, DepType type) {
(lldb) p dep
(llvm::MemDepResult) $0 = {
  Value = (Value = 7)
}

[njw45]

Hi committers - could someone review http://reviews.llvm.org/D5914 for me?
I was using the MemDepPrinter to diagnose an issue with the
MemoryDependenceAnalysis and noticed the MemDepPrinter kept failing an
assert condition as it isn't capable of printing NonLocal dependencies.
Thanks -

Nick

lib/Analysis/MemDepPrinter.cpp

 
 namespace {
   struct MemDepPrinter : public FunctionPass {
     const Function *F;
 
     enum DepType {
       Clobber = 0,
       Def,
+      NonLocal,
       NonFuncLocal,
       Unknown
     };
 
     static const char *const DepTypeStr[];
 
-    typedef PointerIntPair<const Instruction *, 2, DepType> InstTypePair;
-    typedef std::pair<InstTypePair, const BasicBlock *> Dep;
+    typedef std::tuple<const Instruction *, DepType, const BasicBlock *> Dep;
     typedef SmallSetVector<Dep, 4> DepSet;
     typedef DenseMap<const Instruction *, DepSet> DepSetMap;
     DepSetMap Deps;
 
     static char ID; // Pass identifcation, replacement for typeid
     MemDepPrinter() : FunctionPass(ID) {
       initializeMemDepPrinterPass(*PassRegistry::getPassRegistry());
     }
struct MemDepPrinter : public FunctionPass {
     }
 
     void releaseMemory() override {
       Deps.clear();
       F = nullptr;
     }
 
   private:
-    static InstTypePair getInstTypePair(MemDepResult dep) {
+    static Dep getDep(MemDepResult dep, const BasicBlock * bb) {
       if (dep.isClobber())
-        return InstTypePair(dep.getInst(), Clobber);
+        return std::make_tuple(dep.getInst(), Clobber, bb);
       if (dep.isDef())
-        return InstTypePair(dep.getInst(), Def);
+        return std::make_tuple(dep.getInst(), Def, bb);
       if (dep.isNonFuncLocal())
-        return InstTypePair(dep.getInst(), NonFuncLocal);
+        return std::make_tuple(dep.getInst(), NonFuncLocal, bb);
+      if (dep.isNonLocal())
+        return std::make_tuple(dep.getInst(), NonLocal, bb);
       assert(dep.isUnknown() && "unexpected dependence type");
-      return InstTypePair(dep.getInst(), Unknown);
+      return std::make_tuple(dep.getInst(), Unknown, bb);
     }
-    static InstTypePair getInstTypePair(const Instruction* inst, DepType type) {
-      return InstTypePair(inst, type);
+    static Dep getDep(
+      const Instruction* inst, DepType type, const BasicBlock * bb) {
+      return std::make_tuple(inst, type, bb);
     }
   };
 }
 
 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",
                       "Print MemDeps of function", false, true)
 
 FunctionPass *llvm::createMemDepPrinter() {
   return new MemDepPrinter();
 }
 
 const char *const MemDepPrinter::DepTypeStr[]
-  = {"Clobber", "Def", "NonFuncLocal", "Unknown"};
+  = {"Clobber", "Def", "NonLocal", "NonFuncLocal", "Unknown"};
 
 bool MemDepPrinter::runOnFunction(Function &F) {
   this->F = &F;
   AliasAnalysis &AA = getAnalysis<AliasAnalysis>();
   MemoryDependenceAnalysis &MDA = getAnalysis<MemoryDependenceAnalysis>();
 
   // All this code uses non-const interfaces because MemDep is not
   // const-friendly, though nothing is actually modified.
   for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
     Instruction *Inst = &*I;
 
     if (!Inst->mayReadFromMemory() && !Inst->mayWriteToMemory())
       continue;
 
     MemDepResult Res = MDA.getDependency(Inst);
     if (!Res.isNonLocal()) {
-      Deps[Inst].insert(std::make_pair(getInstTypePair(Res),
-                                       static_cast<BasicBlock *>(nullptr)));
+      Deps[Inst].insert(getDep(Res, nullptr));
     } else if (CallSite CS = cast<Value>(Inst)) {
       const MemoryDependenceAnalysis::NonLocalDepInfo &NLDI =
         MDA.getNonLocalCallDependency(CS);
 
       DepSet &InstDeps = Deps[Inst];
       for (MemoryDependenceAnalysis::NonLocalDepInfo::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()));
+        InstDeps.insert(getDep(Res, I->getBB()));
       }
     } else {
       SmallVector<NonLocalDepResult, 4> NLDI;
       if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
         if (!LI->isUnordered()) {
           // FIXME: Handle atomic/volatile loads.
-          Deps[Inst].insert(std::make_pair(getInstTypePair(nullptr, Unknown),
-                                           static_cast<BasicBlock *>(nullptr)));
+          Deps[Inst].insert(getDep(nullptr, Unknown, nullptr));
           continue;
         }
         AliasAnalysis::Location Loc = AA.getLocation(LI);
         MDA.getNonLocalPointerDependency(Loc, true, LI->getParent(), NLDI);
       } else if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
         if (!SI->isUnordered()) {
           // FIXME: Handle atomic/volatile stores.
-          Deps[Inst].insert(std::make_pair(getInstTypePair(nullptr, Unknown),
-                                           static_cast<BasicBlock *>(nullptr)));
+          Deps[Inst].insert(getDep(nullptr, Unknown, nullptr));
           continue;
         }
         AliasAnalysis::Location Loc = AA.getLocation(SI);
         MDA.getNonLocalPointerDependency(Loc, false, SI->getParent(), NLDI);
       } else if (VAArgInst *VI = dyn_cast<VAArgInst>(Inst)) {
         AliasAnalysis::Location Loc = AA.getLocation(VI);
         MDA.getNonLocalPointerDependency(Loc, false, VI->getParent(), NLDI);
       } else {
         llvm_unreachable("Unknown memory instruction!");
       }
 
       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()));
+        InstDeps.insert(getDep(Res, I->getBB()));
       }
     }
   }
 
   return false;
 }
 
 void MemDepPrinter::print(raw_ostream &OS, const Module *M) const {
   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();
          I != E; ++I) {
-      const Instruction *DepInst = I->first.getPointer();
-      DepType type = I->first.getInt();
-      const BasicBlock *DepBB = I->second;
+      const Instruction *DepInst = std::get<0>(*I);
+      DepType type = std::get<1>(*I);
+      const BasicBlock *DepBB = std::get<2>(*I);
 
       OS << "    ";
       OS << DepTypeStr[type];
       if (DepBB) {
         OS << " in block ";
         DepBB->printAsOperand(OS, /*PrintType=*/false, M);
       }
       if (DepInst) {