clang  14.0.0git
MPIChecker.cpp
Go to the documentation of this file.
1 //===-- MPIChecker.cpp - Checker Entry Point Class --------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// This file defines the main class of MPI-Checker which serves as an entry
11 /// point. It is created once for each translation unit analysed.
12 /// The checker defines path-sensitive checks, to verify correct usage of the
13 /// MPI API.
14 ///
15 //===----------------------------------------------------------------------===//
16 
17 #include "MPIChecker.h"
20 
21 namespace clang {
22 namespace ento {
23 namespace mpi {
24 
26  CheckerContext &Ctx) const {
27  if (!FuncClassifier->isNonBlockingType(PreCallEvent.getCalleeIdentifier())) {
28  return;
29  }
30  const MemRegion *const MR =
31  PreCallEvent.getArgSVal(PreCallEvent.getNumArgs() - 1).getAsRegion();
32  if (!MR)
33  return;
34  const ElementRegion *const ER = dyn_cast<ElementRegion>(MR);
35 
36  // The region must be typed, in order to reason about it.
37  if (!isa<TypedRegion>(MR) || (ER && !isa<TypedRegion>(ER->getSuperRegion())))
38  return;
39 
41  const Request *const Req = State->get<RequestMap>(MR);
42 
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);
49  }
50  // no error
51  else {
52  State = State->set<RequestMap>(MR, Request::State::Nonblocking);
53  Ctx.addTransition(State);
54  }
55 }
56 
57 void MPIChecker::checkUnmatchedWaits(const CallEvent &PreCallEvent,
58  CheckerContext &Ctx) const {
59  if (!FuncClassifier->isWaitType(PreCallEvent.getCalleeIdentifier()))
60  return;
61  const MemRegion *const MR = topRegionUsedByWait(PreCallEvent);
62  if (!MR)
63  return;
64  const ElementRegion *const ER = dyn_cast<ElementRegion>(MR);
65 
66  // The region must be typed, in order to reason about it.
67  if (!isa<TypedRegion>(MR) || (ER && !isa<TypedRegion>(ER->getSuperRegion())))
68  return;
69 
71  allRegionsUsedByWait(ReqRegions, MR, PreCallEvent, Ctx);
72  if (ReqRegions.empty())
73  return;
74 
76  static CheckerProgramPointTag Tag("MPI-Checker", "UnmatchedWait");
77  ExplodedNode *ErrorNode{nullptr};
78 
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);
83  if (!Req) {
84  if (!ErrorNode) {
85  ErrorNode = Ctx.generateNonFatalErrorNode(State, &Tag);
86  State = ErrorNode->getState();
87  }
88  // A wait has no matching nonblocking call.
89  BReporter.reportUnmatchedWait(PreCallEvent, ReqRegion, ErrorNode,
90  Ctx.getBugReporter());
91  }
92  }
93 
94  if (!ErrorNode) {
95  Ctx.addTransition(State);
96  } else {
97  Ctx.addTransition(State, ErrorNode);
98  }
99 }
100 
102  CheckerContext &Ctx) const {
104  const auto &Requests = State->get<RequestMap>();
105  if (Requests.isEmpty())
106  return;
107 
108  static CheckerProgramPointTag Tag("MPI-Checker", "MissingWait");
109  ExplodedNode *ErrorNode{nullptr};
110 
111  auto ReqMap = State->get<RequestMap>();
112  for (const auto &Req : ReqMap) {
113  if (!SymReaper.isLiveRegion(Req.first)) {
114  if (Req.second.CurrentState == Request::State::Nonblocking) {
115 
116  if (!ErrorNode) {
117  ErrorNode = Ctx.generateNonFatalErrorNode(State, &Tag);
118  State = ErrorNode->getState();
119  }
120  BReporter.reportMissingWait(Req.second, Req.first, ErrorNode,
121  Ctx.getBugReporter());
122  }
123  State = State->remove<RequestMap>(Req.first);
124  }
125  }
126 
127  // Transition to update the state regarding removed requests.
128  if (!ErrorNode) {
129  Ctx.addTransition(State);
130  } else {
131  Ctx.addTransition(State, ErrorNode);
132  }
133 }
134 
135 const MemRegion *MPIChecker::topRegionUsedByWait(const CallEvent &CE) const {
136 
137  if (FuncClassifier->isMPI_Wait(CE.getCalleeIdentifier())) {
138  return CE.getArgSVal(0).getAsRegion();
139  } else if (FuncClassifier->isMPI_Waitall(CE.getCalleeIdentifier())) {
140  return CE.getArgSVal(1).getAsRegion();
141  } else {
142  return (const MemRegion *)nullptr;
143  }
144 }
145 
146 void MPIChecker::allRegionsUsedByWait(
148  const MemRegion *const MR, const CallEvent &CE, CheckerContext &Ctx) const {
149 
150  MemRegionManager &RegionManager = MR->getMemRegionManager();
151 
152  if (FuncClassifier->isMPI_Waitall(CE.getCalleeIdentifier())) {
153  const SubRegion *SuperRegion{nullptr};
154  if (const ElementRegion *const ER = MR->getAs<ElementRegion>()) {
155  SuperRegion = cast<SubRegion>(ER->getSuperRegion());
156  }
157 
158  // A single request is passed to MPI_Waitall.
159  if (!SuperRegion) {
160  ReqRegions.push_back(MR);
161  return;
162  }
163 
164  DefinedOrUnknownSVal ElementCount = getDynamicElementCount(
165  Ctx.getState(), SuperRegion, Ctx.getSValBuilder(),
166  CE.getArgExpr(1)->getType()->getPointeeType());
167  const llvm::APSInt &ArrSize =
168  ElementCount.getAs<nonloc::ConcreteInt>()->getValue();
169 
170  for (size_t i = 0; i < ArrSize; ++i) {
171  const NonLoc Idx = Ctx.getSValBuilder().makeArrayIndex(i);
172 
173  const ElementRegion *const ER = RegionManager.getElementRegion(
174  CE.getArgExpr(1)->getType()->getPointeeType(), Idx, SuperRegion,
175  Ctx.getASTContext());
176 
177  ReqRegions.push_back(ER->getAs<MemRegion>());
178  }
179  } else if (FuncClassifier->isMPI_Wait(CE.getCalleeIdentifier())) {
180  ReqRegions.push_back(MR);
181  }
182 }
183 
184 } // end of namespace: mpi
185 } // end of namespace: ento
186 } // end of namespace: clang
187 
188 // Registers the checker for static analysis.
189 void clang::ento::registerMPIChecker(CheckerManager &MGR) {
190  MGR.registerChecker<clang::ento::mpi::MPIChecker>();
191 }
192 
193 bool clang::ento::shouldRegisterMPIChecker(const CheckerManager &mgr) {
194  return true;
195 }
DynamicExtent.h
clang::ento::MemRegion::getMemRegionManager
virtual MemRegionManager & getMemRegionManager() const =0
clang::ento::SVal::getAsRegion
const MemRegion * getAsRegion() const
Definition: SVals.cpp:131
clang::ento::mpi::MPIChecker::checkDoubleNonblocking
void checkDoubleNonblocking(const clang::ento::CallEvent &PreCallEvent, clang::ento::CheckerContext &Ctx) const
Checks if a request is used by nonblocking calls multiple times in sequence without intermediate wait...
Definition: MPIChecker.cpp:25
MPIChecker.h
llvm::SmallVector
Definition: LLVM.h:38
clang::ento::CheckerContext::generateNonFatalErrorNode
ExplodedNode * generateNonFatalErrorNode(ProgramStateRef State=nullptr, const ProgramPointTag *Tag=nullptr)
Generate a transition to a node that will be used to report an error.
Definition: CheckerContext.h:220
clang::ento::ExplodedNode
Definition: ExplodedGraph.h:65
clang::ento::mpi::Request::CurrentState
const State CurrentState
Definition: MPITypes.h:41
clang::ento::CheckerContext::getState
const ProgramStateRef & getState() const
Definition: CheckerContext.h:71
clang::ento::mpi::MPIChecker::checkMissingWaits
void checkMissingWaits(clang::ento::SymbolReaper &SymReaper, clang::ento::CheckerContext &Ctx) const
Check if a nonblocking call is not matched by a wait.
Definition: MPIChecker.cpp:101
getValue
static SVal getValue(SVal val, SValBuilder &svalBuilder)
Definition: ArrayBoundCheckerV2.cpp:277
clang::ento::MemRegion
MemRegion - The root abstract class for all memory regions.
Definition: MemRegion.h:94
APSInt
llvm::APSInt APSInt
Definition: ByteCodeEmitter.cpp:19
clang::ento::mpi::MPIBugReporter::reportDoubleNonblocking
void reportDoubleNonblocking(const CallEvent &MPICallEvent, const Request &Req, const MemRegion *const RequestRegion, const ExplodedNode *const ExplNode, BugReporter &BReporter) const
Report duplicate request use by nonblocking calls without intermediate wait.
Definition: MPIBugReporter.cpp:23
clang::ento::ExplodedNode::getState
const ProgramStateRef & getState() const
Definition: ExplodedGraph.h:169
BuiltinCheckerRegistration.h
clang::ento::mpi::MPIChecker
Definition: MPIChecker.h:30
clang::ento::mpi::Request
Definition: MPITypes.h:27
clang::ento::CheckerContext::addTransition
ExplodedNode * addTransition(ProgramStateRef State=nullptr, const ProgramPointTag *Tag=nullptr)
Generates a new transition in the program state graph (ExplodedGraph).
Definition: CheckerContext.h:166
clang::ento::SymbolReaper
A class responsible for cleaning up unused symbols.
Definition: SymbolManager.h:505
clang::ento::getDynamicElementCount
DefinedOrUnknownSVal getDynamicElementCount(ProgramStateRef State, const MemRegion *MR, SValBuilder &SVB, QualType Ty)
clang::ento::ElementRegion
ElementRegion is used to represent both array elements and casts.
Definition: MemRegion.h:1141
clang::ento::SymbolReaper::isLiveRegion
bool isLiveRegion(const MemRegion *region)
Definition: SymbolManager.cpp:408
clang::ento::SubRegion::getSuperRegion
const MemRegion * getSuperRegion() const
Definition: MemRegion.h:447
clang::ento::mpi::RequestMap
Definition: MPITypes.h:48
State
LineState State
Definition: UnwrappedLineFormatter.cpp:986
clang::ento::CallEvent::getNumArgs
virtual unsigned getNumArgs() const =0
Returns the number of arguments (explicit and implicit).
clang::ento::mpi::MPIBugReporter::reportUnmatchedWait
void reportUnmatchedWait(const CallEvent &CE, const MemRegion *const RequestRegion, const ExplodedNode *const ExplNode, BugReporter &BReporter) const
Report a wait on a request that has not been used at all before.
Definition: MPIBugReporter.cpp:69
clang::ento::mpi::MPIChecker::checkUnmatchedWaits
void checkUnmatchedWaits(const clang::ento::CallEvent &PreCallEvent, clang::ento::CheckerContext &Ctx) const
Checks if the request used by the wait function was not used at all before.
Definition: MPIChecker.cpp:57
clang::ento::CheckerContext::getBugReporter
BugReporter & getBugReporter()
Definition: CheckerContext.h:102
clang
Definition: CalledOnceCheck.h:17
clang::ento::CheckerProgramPointTag
Tag that can use a checker name as a message provider (see SimpleProgramPointTag).
Definition: Checker.h:510
clang::ento::CallEvent
Represents an abstract call to a function or method along a particular path.
Definition: CallEvent.h:143
clang::ento::CallEvent::getArgSVal
virtual SVal getArgSVal(unsigned Index) const
Returns the value of a given argument at the time of the call.
Definition: CallEvent.cpp:387
clang::ento::CheckerContext
Definition: CheckerContext.h:23
clang::ento::CallEvent::getCalleeIdentifier
const IdentifierInfo * getCalleeIdentifier() const
Returns the name of the callee, if its name is a simple identifier.
Definition: CallEvent.h:345
clang::ento::mpi::MPIBugReporter::reportMissingWait
void reportMissingWait(const Request &Req, const MemRegion *const RequestRegion, const ExplodedNode *const ExplNode, BugReporter &BReporter) const
Report a missing wait for a nonblocking call.
Definition: MPIBugReporter.cpp:49
llvm::IntrusiveRefCntPtr< const ProgramState >