MPI-Checker: move MPIFunctionClassifier.h

[Alexander_Droste]

Summary

This patch moves the MPIFunctionClassifier header to clang/include/clang/StaticAnalyzer/Checkers,
in order to make it accessible in other parts of the architecture.

[alexfh]

Specifically, this header is going to be used in the corresponding clang-tidy check (see the dependent revision).

[zaks.anna]

LGTM

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.h

 /// MPI API.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPICHECKER_H
 #define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPICHECKER_H
 
 #include "MPIBugReporter.h"
-#include "MPIFunctionClassifier.h"
 #include "MPITypes.h"
+#include "clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 
 namespace clang {
 namespace ento {
 namespace mpi {
 
 class MPIChecker : public Checker<check::PreCall, check::DeadSymbols> {
 public:
-  MPIChecker() : BReporter(*this) { }
+  MPIChecker() : BReporter(*this) {}
 
   // path-sensitive callbacks
   void checkPreCall(const CallEvent &CE, CheckerContext &Ctx) const {
     dynamicInit(Ctx);
     checkUnmatchedWaits(CE, Ctx);
     checkDoubleNonblocking(CE, Ctx);
   }
 
   void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &Ctx) const {
     dynamicInit(Ctx);
     checkMissingWaits(SymReaper, Ctx);
   }
 
   void dynamicInit(CheckerContext &Ctx) const {
     if (FuncClassifier)
       return;
     const_cast<std::unique_ptr<MPIFunctionClassifier> &>(FuncClassifier)
         .reset(new MPIFunctionClassifier{Ctx.getASTContext()});
-
   }
 
   /// Checks if a request is used by nonblocking calls multiple times
   /// in sequence without intermediate wait. The check contains a guard,
   /// in order to only inspect nonblocking functions.
   ///
   /// \param PreCallEvent MPI call to verify
   void checkDoubleNonblocking(const clang::ento::CallEvent &PreCallEvent,

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();
-    BReporter.reportDoubleNonblocking(PreCallEvent, *Req, MR, ErrorNode, Ctx.getBugReporter());
+    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);
   }
 }
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);
         State = ErrorNode->getState();
       }
       // A wait has no matching nonblocking call.
-      BReporter.reportUnmatchedWait(PreCallEvent, ReqRegion, ErrorNode, Ctx.getBugReporter());
+      BReporter.reportUnmatchedWait(PreCallEvent, ReqRegion, ErrorNode,
+                                    Ctx.getBugReporter());
     }
   }
 
   if (!ErrorNode) {
     Ctx.addTransition(State);
   } else {
     Ctx.addTransition(State, ErrorNode);
   }
void MPIChecker::checkMissingWaits(SymbolReaper &SymReaper,
   for (const auto &Req : ReqMap) {
     if (!SymReaper.isLiveRegion(Req.first)) {
       if (Req.second.CurrentState == Request::State::Nonblocking) {
 
         if (!ErrorNode) {
           ErrorNode = Ctx.generateNonFatalErrorNode(State, &Tag);
           State = ErrorNode->getState();
         }
-        BReporter.reportMissingWait(Req.second, Req.first, ErrorNode, Ctx.getBugReporter());
+        BReporter.reportMissingWait(Req.second, Req.first, ErrorNode,
+                                    Ctx.getBugReporter());
       }
       State = State->remove<RequestMap>(Req.first);
     }
   }
 
   // Transition to update the state regarding removed requests.
   if (!ErrorNode) {
     Ctx.addTransition(State);

lib/StaticAnalyzer/Checkers/MPI-Checker/MPIFunctionClassifier.cpp

 //===-- MPIFunctionClassifier.cpp - classifies MPI functions ----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file defines functionality to identify and classify MPI functions.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "MPIFunctionClassifier.h"
+#include "clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace clang {
 namespace ento {
 namespace mpi {
 
 void MPIFunctionClassifier::identifierInit(ASTContext &ASTCtx) {
   // Initialize function identifiers.

lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h

 /// class defines a wrapper class, in order to make MPI requests trackable for
 /// path-sensitive analysis.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPITYPES_H
 #define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_MPICHECKER_MPITYPES_H
 
-#include "MPIFunctionClassifier.h"
+#include "clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "llvm/ADT/SmallSet.h"
 
 namespace clang {
 namespace ento {
 namespace mpi {
 
 class Request {

 // available in an arbitrary amount of translation units.
 struct RequestMap {};
 typedef llvm::ImmutableMap<const clang::ento::MemRegion *,
                            clang::ento::mpi::Request>
     RequestMapImpl;
 
 } // end of namespace: mpi
 
-
 template <>
 struct ProgramStateTrait<mpi::RequestMap>
     : public ProgramStatePartialTrait<mpi::RequestMapImpl> {
   static void *GDMIndex() {
     static int index = 0;
     return &index;
   }
 };
 
 } // end of namespace: ento
 } // end of namespace: clang
 #endif