[analyzer] MPIChecker: add defensive checking (check against nullptr)

[danix800]

Summary

ExplodedNode might be null and shoud be checked conventionally.

Fixes https://github.com/llvm/llvm-project/issues/64647

[steakhal]

Makes sense.
Would thus test crash without the early returns? And now they wouldn't?

[danix800]

In D158858#4617510, @steakhal wrote:

Makes sense.
Would thus test crash without the early returns? And now they wouldn't?

Yes, the original crash shown in https://godbolt.org/z/39P7W6KPa

[steakhal]

Thanks. Feel free to merge this (before any of the others).

clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp

if (!isa<TypedRegion>(MR) || (ER && !isa<TypedRegion>(ER->getSuperRegion())))
     return;
 
   ProgramStateRef State = Ctx.getState();
   const Request *const Req = State->get<RequestMap>(MR);
 
   // double nonblocking detected
   if (Req && Req->CurrentState == Request::State::Nonblocking) {
     ExplodedNode *ErrorNode = Ctx.generateNonFatalErrorNode();
+    if (!ErrorNode)
+      return;
+
     BReporter.reportDoubleNonblocking(PreCallEvent, *Req, MR, ErrorNode,
                                       Ctx.getBugReporter());
     Ctx.addTransition(ErrorNode->getState(), ErrorNode);
   }
   // no error
   else {
     State = State->set<RequestMap>(MR, Request::State::Nonblocking);
     Ctx.addTransition(State);
void MPIChecker::checkUnmatchedWaits(const CallEvent &PreCallEvent,
 
   // Check all request regions used by the wait function.
   for (const auto &ReqRegion : ReqRegions) {
     const Request *const Req = State->get<RequestMap>(ReqRegion);
     State = State->set<RequestMap>(ReqRegion, Request::State::Wait);
     if (!Req) {
       if (!ErrorNode) {
         ErrorNode = Ctx.generateNonFatalErrorNode(State, &Tag);
+        if (!ErrorNode)
+          break;
+
         State = ErrorNode->getState();
       }
       // A wait has no matching nonblocking call.
       BReporter.reportUnmatchedWait(PreCallEvent, ReqRegion, ErrorNode,
                                     Ctx.getBugReporter());
     }
   }
 
void MPIChecker::checkMissingWaits(SymbolReaper &SymReaper,
 
   auto ReqMap = State->get<RequestMap>();
   for (const auto &Req : ReqMap) {
     if (!SymReaper.isLiveRegion(Req.first)) {
       if (Req.second.CurrentState == Request::State::Nonblocking) {
 
         if (!ErrorNode) {
           ErrorNode = Ctx.generateNonFatalErrorNode(State, &Tag);
+          if (!ErrorNode)
+            break;
+
           State = ErrorNode->getState();
         }
         BReporter.reportMissingWait(Req.second, Req.first, ErrorNode,
                                     Ctx.getBugReporter());
       }
       State = State->remove<RequestMap>(Req.first);
     }
   }

clang/test/Analysis/mpichecker.cpp

void externFunctions1() {
   callWaitExtern(&req);
 } // expected-warning{{Request 'req' has no matching wait.}}
 
 void externFunctions2() {
   MPI_Request req;
   void callNonblockingExtern(MPI_Request *req);
   callNonblockingExtern(&req);
 }
+
+bool contains();
+void gh64647() {
+  if (contains()) {
+    MPI_Request request_item;
+    MPI_Wait(&request_item, MPI_STATUS_IGNORE);
+    // expected-warning@-1 {{Request 'request_item' has no matching nonblocking call.}}
+  }
+  gh64647();
+}