Add back the message for printing null pointers that was removed in r210497

[rtrieu]

Summary

Add back the message for printing null pointers that was removed in r210497

[reames]

The revised changes appear to reintroduce the behaviour which was removed. Seems fine to me.

[spatel]

Is anything holding up this patch? I think this caused:
http://llvm.org/bugs/show_bug.cgi?id=20040

[rtrieu]

I have submitted this at r211430.

lib/Analysis/IPA/CallGraphSCCPass.cpp

public:
 
     void getAnalysisUsage(AnalysisUsage &AU) const override {
       AU.setPreservesAll();
     }
 
     bool runOnSCC(CallGraphSCC &SCC) override {
       Out << Banner;
       for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
-        assert((*I)->getFunction() && "Expecting non-null Function");
+        if ((*I)->getFunction())
           (*I)->getFunction()->print(Out);
+        else
+          Out << "Printing <null> Function";
       }
       return false;
     }
   };
   
 } // end anonymous namespace.
 
 char PrintCallGraphPass::ID = 0;
 
 Pass *CallGraphSCCPass::createPrinterPass(raw_ostream &O,
                                           const std::string &Banner) const {
   return new PrintCallGraphPass(Banner, O);
 }
 

lib/Analysis/IVUsers.cpp

for (ilist<IVStrideUse>::const_iterator UI = IVUses.begin(),
     for (PostIncLoopSet::const_iterator
          I = UI->PostIncLoops.begin(),
          E = UI->PostIncLoops.end(); I != E; ++I) {
       OS << " (post-inc with loop ";
       (*I)->getHeader()->printAsOperand(OS, false);
       OS << ")";
     }
     OS << " in  ";
-    assert(UI->getUser() != nullptr && "Expected non-null User");
+    if (UI->getUser())
       UI->getUser()->print(OS);
+    else
+      OS << "Printing <null> User";
     OS << '\n';
   }
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 void IVUsers::dump() const {
   print(dbgs());
 }

lib/Analysis/LoopPass.cpp

void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   bool runOnLoop(Loop *L, LPPassManager &) override {
     Out << Banner;
     for (Loop::block_iterator b = L->block_begin(), be = L->block_end();
          b != be;
          ++b) {
-      assert((*b) != nullptr && "Expecting non-null block");
+      if (*b)
         (*b)->print(Out);
+      else
+        Out << "Printing <null> block";
     }
     return false;
   }
 };
 
 char PrintLoopPass::ID = 0;
 }
 

lib/Analysis/RegionPass.cpp

public:
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 
   bool runOnRegion(Region *R, RGPassManager &RGM) override {
     Out << Banner;
     for (const auto &BB : R->blocks()) {
-      assert(BB != nullptr && "Expecting non-null Block");
+      if (BB)
         BB->print(Out);
+      else
+        Out << "Printing <null> Block";
     }
 
     return false;
   }
 };
 
 char PrintRegionPass::ID = 0;
 }  //end anonymous namespace

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP) {
   APInt API = CFP->getValueAPF().bitcastToAPInt();
 
   // First print a comment with what we think the original floating-point value
   // should have been.
   if (AP.isVerbose()) {
     SmallString<8> StrVal;
     CFP->getValueAPF().toString(StrVal);
 
-    assert(CFP->getType() != nullptr && "Expecting non-null Type");
+    if (CFP->getType())
       CFP->getType()->print(AP.OutStreamer.GetCommentOS());
+    else
+      AP.OutStreamer.GetCommentOS() << "Printing <null> Type";
     AP.OutStreamer.GetCommentOS() << ' ' << StrVal << '\n';
   }
 
   // Now iterate through the APInt chunks, emitting them in endian-correct
   // order, possibly with a smaller chunk at beginning/end (e.g. for x87 80-bit
   // floats).
   unsigned NumBytes = API.getBitWidth() / 8;
   unsigned TrailingBytes = NumBytes % sizeof(uint64_t);

lib/IR/Core.cpp

 void LLVMDumpType(LLVMTypeRef Ty) {
   return unwrap(Ty)->dump();
 }
 
 char *LLVMPrintTypeToString(LLVMTypeRef Ty) {
   std::string buf;
   raw_string_ostream os(buf);
 
-  assert(unwrap(Ty) != nullptr && "Expecting non-null Type");
+  if (unwrap(Ty))
     unwrap(Ty)->print(os);
+  else
+    os << "Printing <null> Type";
+
   os.flush();
 
   return strdup(buf.c_str());
 }
 
 /*--.. Operations on integer types .........................................--*/
 
 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C)  {

 void LLVMDumpValue(LLVMValueRef Val) {
   unwrap(Val)->dump();
 }
 
 char* LLVMPrintValueToString(LLVMValueRef Val) {
   std::string buf;
   raw_string_ostream os(buf);
 
-  assert(unwrap(Val) != nullptr && "Expecting non-null Value");
+  if (unwrap(Val))
     unwrap(Val)->print(os);
+  else
+    os << "Printing <null> Value";
+
   os.flush();
 
   return strdup(buf.c_str());
 }
 
 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal) {
   unwrap(OldVal)->replaceAllUsesWith(unwrap(NewVal));
 }

lib/Transforms/Instrumentation/DebugIR.cpp

if (VMap) {
       Value *mapped = VMap->lookup(V);
       if (mapped && LineTable.getLine(mapped, Line))
         return true;
     }
     return false;
   }
 
   std::string getTypeName(Type *T) {
-    assert(T != nullptr && "Expecting non-null Type");
     std::string TypeName;
     raw_string_ostream TypeStream(TypeName);
+    if (T)
       T->print(TypeStream);
+    else
+      TypeStream << "Printing <null> Type";
     TypeStream.flush();
     return TypeName;
   }
 
   /// Returns the MDNode that represents type T if it is already created, or 0
   /// if it is not.
   MDNode *getType(const Type *T) {
     typedef DenseMap<const Type *, MDNode *>::const_iterator TypeNodeIter;