1 //===-- MPIChecker.cpp - Checker Entry Point Class --------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// This file defines the main class of MPI-Checker which serves as an entry
12 /// point. It is created once for each translation unit analysed.
13 /// The checker defines path-sensitive checks, to verify correct usage of the
16 //===----------------------------------------------------------------------===//
18 #include "MPIChecker.h"
19 #include "../ClangSACheckers.h"
25 void MPIChecker::checkDoubleNonblocking(const CallEvent &PreCallEvent,
26 CheckerContext &Ctx) const {
27 if (!FuncClassifier->isNonBlockingType(PreCallEvent.getCalleeIdentifier())) {
30 const MemRegion *const MR =
31 PreCallEvent.getArgSVal(PreCallEvent.getNumArgs() - 1).getAsRegion();
34 const ElementRegion *const ER = dyn_cast<ElementRegion>(MR);
36 // The region must be typed, in order to reason about it.
37 if (!isa<TypedRegion>(MR) || (ER && !isa<TypedRegion>(ER->getSuperRegion())))
40 ProgramStateRef State = Ctx.getState();
41 const Request *const Req = State->get<RequestMap>(MR);
43 // double nonblocking detected
44 if (Req && Req->CurrentState == Request::State::Nonblocking) {
45 ExplodedNode *ErrorNode = Ctx.generateNonFatalErrorNode();
46 BReporter.reportDoubleNonblocking(PreCallEvent, *Req, MR, ErrorNode,
47 Ctx.getBugReporter());
48 Ctx.addTransition(ErrorNode->getState(), ErrorNode);
52 State = State->set<RequestMap>(MR, Request::State::Nonblocking);
53 Ctx.addTransition(State);
57 void MPIChecker::checkUnmatchedWaits(const CallEvent &PreCallEvent,
58 CheckerContext &Ctx) const {
59 if (!FuncClassifier->isWaitType(PreCallEvent.getCalleeIdentifier()))
61 const MemRegion *const MR = topRegionUsedByWait(PreCallEvent);
64 const ElementRegion *const ER = dyn_cast<ElementRegion>(MR);
66 // The region must be typed, in order to reason about it.
67 if (!isa<TypedRegion>(MR) || (ER && !isa<TypedRegion>(ER->getSuperRegion())))
70 llvm::SmallVector<const MemRegion *, 2> ReqRegions;
71 allRegionsUsedByWait(ReqRegions, MR, PreCallEvent, Ctx);
72 if (ReqRegions.empty())
75 ProgramStateRef State = Ctx.getState();
76 static CheckerProgramPointTag Tag("MPI-Checker", "UnmatchedWait");
77 ExplodedNode *ErrorNode{nullptr};
79 // Check all request regions used by the wait function.
80 for (const auto &ReqRegion : ReqRegions) {
81 const Request *const Req = State->get<RequestMap>(ReqRegion);
82 State = State->set<RequestMap>(ReqRegion, Request::State::Wait);
85 ErrorNode = Ctx.generateNonFatalErrorNode(State, &Tag);
86 State = ErrorNode->getState();
88 // A wait has no matching nonblocking call.
89 BReporter.reportUnmatchedWait(PreCallEvent, ReqRegion, ErrorNode,
90 Ctx.getBugReporter());
95 Ctx.addTransition(State);
97 Ctx.addTransition(State, ErrorNode);
101 void MPIChecker::checkMissingWaits(SymbolReaper &SymReaper,
102 CheckerContext &Ctx) const {
103 if (!SymReaper.hasDeadSymbols())
106 ProgramStateRef State = Ctx.getState();
107 const auto &Requests = State->get<RequestMap>();
108 if (Requests.isEmpty())
111 static CheckerProgramPointTag Tag("MPI-Checker", "MissingWait");
112 ExplodedNode *ErrorNode{nullptr};
114 auto ReqMap = State->get<RequestMap>();
115 for (const auto &Req : ReqMap) {
116 if (!SymReaper.isLiveRegion(Req.first)) {
117 if (Req.second.CurrentState == Request::State::Nonblocking) {
120 ErrorNode = Ctx.generateNonFatalErrorNode(State, &Tag);
121 State = ErrorNode->getState();
123 BReporter.reportMissingWait(Req.second, Req.first, ErrorNode,
124 Ctx.getBugReporter());
126 State = State->remove<RequestMap>(Req.first);
130 // Transition to update the state regarding removed requests.
132 Ctx.addTransition(State);
134 Ctx.addTransition(State, ErrorNode);
138 const MemRegion *MPIChecker::topRegionUsedByWait(const CallEvent &CE) const {
140 if (FuncClassifier->isMPI_Wait(CE.getCalleeIdentifier())) {
141 return CE.getArgSVal(0).getAsRegion();
142 } else if (FuncClassifier->isMPI_Waitall(CE.getCalleeIdentifier())) {
143 return CE.getArgSVal(1).getAsRegion();
145 return (const MemRegion *)nullptr;
149 void MPIChecker::allRegionsUsedByWait(
150 llvm::SmallVector<const MemRegion *, 2> &ReqRegions,
151 const MemRegion *const MR, const CallEvent &CE, CheckerContext &Ctx) const {
153 MemRegionManager *const RegionManager = MR->getMemRegionManager();
155 if (FuncClassifier->isMPI_Waitall(CE.getCalleeIdentifier())) {
156 const SubRegion *SuperRegion{nullptr};
157 if (const ElementRegion *const ER = MR->getAs<ElementRegion>()) {
158 SuperRegion = cast<SubRegion>(ER->getSuperRegion());
161 // A single request is passed to MPI_Waitall.
163 ReqRegions.push_back(MR);
167 const auto &Size = Ctx.getStoreManager().getSizeInElements(
168 Ctx.getState(), SuperRegion,
169 CE.getArgExpr(1)->getType()->getPointeeType());
170 const llvm::APSInt &ArrSize = Size.getAs<nonloc::ConcreteInt>()->getValue();
172 for (size_t i = 0; i < ArrSize; ++i) {
173 const NonLoc Idx = Ctx.getSValBuilder().makeArrayIndex(i);
175 const ElementRegion *const ER = RegionManager->getElementRegion(
176 CE.getArgExpr(1)->getType()->getPointeeType(), Idx, SuperRegion,
177 Ctx.getASTContext());
179 ReqRegions.push_back(ER->getAs<MemRegion>());
181 } else if (FuncClassifier->isMPI_Wait(CE.getCalleeIdentifier())) {
182 ReqRegions.push_back(MR);
186 } // end of namespace: mpi
187 } // end of namespace: ento
188 } // end of namespace: clang
190 // Registers the checker for static analysis.
191 void clang::ento::registerMPIChecker(CheckerManager &MGR) {
192 MGR.registerChecker<clang::ento::mpi::MPIChecker>();