clang 19.0.0git
Consumed.h
Go to the documentation of this file.
1//===- Consumed.h -----------------------------------------------*- 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// A intra-procedural analysis for checking consumed properties. This is based,
10// in part, on research on linear types.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_CONSUMED_H
15#define LLVM_CLANG_ANALYSIS_ANALYSES_CONSUMED_H
16
18#include "clang/Analysis/CFG.h"
19#include "clang/Basic/LLVM.h"
22#include "llvm/ADT/DenseMap.h"
23#include "llvm/ADT/SmallVector.h"
24#include "llvm/ADT/StringRef.h"
25#include <list>
26#include <memory>
27#include <utility>
28#include <vector>
29
30namespace clang {
31
32class AnalysisDeclContext;
33class CXXBindTemporaryExpr;
34class FunctionDecl;
35class PostOrderCFGView;
36class Stmt;
37class VarDecl;
38
39namespace consumed {
40
42
44 // No state information for the given variable.
46
50 };
51
53 using DelayedDiag = std::pair<PartialDiagnosticAt, OptionalNotes>;
54 using DiagList = std::list<DelayedDiag>;
55
57 public:
59
60 /// Emit the warnings and notes left by the analysis.
61 virtual void emitDiagnostics() {}
62
63 /// Warn that a variable's state doesn't match at the entry and exit
64 /// of a loop.
65 ///
66 /// \param Loc -- The location of the end of the loop.
67 ///
68 /// \param VariableName -- The name of the variable that has a mismatched
69 /// state.
71 StringRef VariableName) {}
72
73 /// Warn about parameter typestate mismatches upon return.
74 ///
75 /// \param Loc -- The SourceLocation of the return statement.
76 ///
77 /// \param ExpectedState -- The state the return value was expected to be
78 /// in.
79 ///
80 /// \param ObservedState -- The state the return value was observed to be
81 /// in.
83 StringRef VariableName,
84 StringRef ExpectedState,
85 StringRef ObservedState) {}
86
87 // FIXME: Add documentation.
89 StringRef ExpectedState,
90 StringRef ObservedState) {}
91
92 // FIXME: This can be removed when the attr propagation fix for templated
93 // classes lands.
94 /// Warn about return typestates set for unconsumable types.
95 ///
96 /// \param Loc -- The location of the attributes.
97 ///
98 /// \param TypeName -- The name of the unconsumable type.
100 StringRef TypeName) {}
101
102 /// Warn about return typestate mismatches.
103 ///
104 /// \param Loc -- The SourceLocation of the return statement.
105 ///
106 /// \param ExpectedState -- The state the return value was expected to be
107 /// in.
108 ///
109 /// \param ObservedState -- The state the return value was observed to be
110 /// in.
112 StringRef ExpectedState,
113 StringRef ObservedState) {}
114
115 /// Warn about use-while-consumed errors.
116 /// \param MethodName -- The name of the method that was incorrectly
117 /// invoked.
118 ///
119 /// \param State -- The state the object was used in.
120 ///
121 /// \param Loc -- The SourceLocation of the method invocation.
122 virtual void warnUseOfTempInInvalidState(StringRef MethodName,
123 StringRef State,
124 SourceLocation Loc) {}
125
126 /// Warn about use-while-consumed errors.
127 /// \param MethodName -- The name of the method that was incorrectly
128 /// invoked.
129 ///
130 /// \param State -- The state the object was used in.
131 ///
132 /// \param VariableName -- The name of the variable that holds the unique
133 /// value.
134 ///
135 /// \param Loc -- The SourceLocation of the method invocation.
136 virtual void warnUseInInvalidState(StringRef MethodName,
137 StringRef VariableName,
138 StringRef State,
139 SourceLocation Loc) {}
140 };
141
143 using VarMapType = llvm::DenseMap<const VarDecl *, ConsumedState>;
144 using TmpMapType =
145 llvm::DenseMap<const CXXBindTemporaryExpr *, ConsumedState>;
146
147 protected:
148 bool Reachable = true;
149 const Stmt *From = nullptr;
150 VarMapType VarMap;
151 TmpMapType TmpMap;
152
153 public:
154 ConsumedStateMap() = default;
157
158 // The copy assignment operator is defined as deleted pending further
159 // motivation.
161
162 /// Warn if any of the parameters being tracked are not in the state
163 /// they were declared to be in upon return from a function.
165 ConsumedWarningsHandlerBase &WarningsHandler) const;
166
167 /// Clear the TmpMap.
168 void clearTemporaries();
169
170 /// Get the consumed state of a given variable.
171 ConsumedState getState(const VarDecl *Var) const;
172
173 /// Get the consumed state of a given temporary value.
175
176 /// Merge this state map with another map.
177 void intersect(const ConsumedStateMap &Other);
178
179 void intersectAtLoopHead(const CFGBlock *LoopHead, const CFGBlock *LoopBack,
180 const ConsumedStateMap *LoopBackStates,
181 ConsumedWarningsHandlerBase &WarningsHandler);
182
183 /// Return true if this block is reachable.
184 bool isReachable() const { return Reachable; }
185
186 /// Mark the block as unreachable.
187 void markUnreachable();
188
189 /// Set the source for a decision about the branching of states.
190 /// \param Source -- The statement that was the origin of a branching
191 /// decision.
192 void setSource(const Stmt *Source) { this->From = Source; }
193
194 /// Set the consumed state of a given variable.
195 void setState(const VarDecl *Var, ConsumedState State);
196
197 /// Set the consumed state of a given temporary value.
198 void setState(const CXXBindTemporaryExpr *Tmp, ConsumedState State);
199
200 /// Remove the temporary value from our state map.
201 void remove(const CXXBindTemporaryExpr *Tmp);
202
203 /// Tests to see if there is a mismatch in the states stored in two
204 /// maps.
205 ///
206 /// \param Other -- The second map to compare against.
207 bool operator!=(const ConsumedStateMap *Other) const;
208 };
209
211 std::vector<std::unique_ptr<ConsumedStateMap>> StateMapsArray;
212 std::vector<unsigned int> VisitOrder;
213
214 public:
215 ConsumedBlockInfo() = default;
216
217 ConsumedBlockInfo(unsigned int NumBlocks, PostOrderCFGView *SortedGraph)
218 : StateMapsArray(NumBlocks), VisitOrder(NumBlocks, 0) {
219 unsigned int VisitOrderCounter = 0;
220 for (const auto BI : *SortedGraph)
221 VisitOrder[BI->getBlockID()] = VisitOrderCounter++;
222 }
223
224 bool allBackEdgesVisited(const CFGBlock *CurrBlock,
225 const CFGBlock *TargetBlock);
226
227 void addInfo(const CFGBlock *Block, ConsumedStateMap *StateMap,
228 std::unique_ptr<ConsumedStateMap> &OwnedStateMap);
229 void addInfo(const CFGBlock *Block,
230 std::unique_ptr<ConsumedStateMap> StateMap);
231
233
234 void discardInfo(const CFGBlock *Block);
235
236 std::unique_ptr<ConsumedStateMap> getInfo(const CFGBlock *Block);
237
238 bool isBackEdge(const CFGBlock *From, const CFGBlock *To);
239 bool isBackEdgeTarget(const CFGBlock *Block);
240 };
241
242 /// A class that handles the analysis of uniqueness violations.
244 ConsumedBlockInfo BlockInfo;
245 std::unique_ptr<ConsumedStateMap> CurrStates;
246
247 ConsumedState ExpectedReturnState = CS_None;
248
249 void determineExpectedReturnState(AnalysisDeclContext &AC,
250 const FunctionDecl *D);
251 bool splitState(const CFGBlock *CurrBlock,
252 const ConsumedStmtVisitor &Visitor);
253
254 public:
256
259
260 ConsumedState getExpectedReturnState() const { return ExpectedReturnState; }
261
262 /// Check a function's CFG for consumed violations.
263 ///
264 /// We traverse the blocks in the CFG, keeping track of the state of each
265 /// value who's type has uniqueness annotations. If methods are invoked in
266 /// the wrong state a warning is issued. Each block in the CFG is traversed
267 /// exactly once.
268 void run(AnalysisDeclContext &AC);
269 };
270
271} // namespace consumed
272
273} // namespace clang
274
275#endif // LLVM_CLANG_ANALYSIS_ANALYSES_CONSUMED_H
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::SourceLocation class and associated facilities.
AnalysisDeclContext contains the context data for the function, method or block under analysis.
Represents a single basic block in a source-level CFG.
Definition: CFG.h:604
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1475
Represents a function declaration or definition.
Definition: Decl.h:1959
Encodes a location in the source.
Stmt - This represents one statement.
Definition: Stmt.h:84
Represents a variable declaration or definition.
Definition: Decl.h:918
A class that handles the analysis of uniqueness violations.
Definition: Consumed.h:243
ConsumedWarningsHandlerBase & WarningsHandler
Definition: Consumed.h:255
ConsumedState getExpectedReturnState() const
Definition: Consumed.h:260
ConsumedAnalyzer(ConsumedWarningsHandlerBase &WarningsHandler)
Definition: Consumed.h:257
void run(AnalysisDeclContext &AC)
Check a function's CFG for consumed violations.
Definition: Consumed.cpp:1304
ConsumedStateMap * borrowInfo(const CFGBlock *Block)
Definition: Consumed.cpp:1045
bool isBackEdgeTarget(const CFGBlock *Block)
Definition: Consumed.cpp:1072
std::unique_ptr< ConsumedStateMap > getInfo(const CFGBlock *Block)
Definition: Consumed.cpp:1057
ConsumedBlockInfo(unsigned int NumBlocks, PostOrderCFGView *SortedGraph)
Definition: Consumed.h:217
void addInfo(const CFGBlock *Block, ConsumedStateMap *StateMap, std::unique_ptr< ConsumedStateMap > &OwnedStateMap)
Definition: Consumed.cpp:1017
void discardInfo(const CFGBlock *Block)
Definition: Consumed.cpp:1052
bool allBackEdgesVisited(const CFGBlock *CurrBlock, const CFGBlock *TargetBlock)
Definition: Consumed.cpp:1003
bool isBackEdge(const CFGBlock *From, const CFGBlock *To)
Definition: Consumed.cpp:1065
bool isReachable() const
Return true if this block is reachable.
Definition: Consumed.h:184
void clearTemporaries()
Clear the TmpMap.
Definition: Consumed.cpp:1109
ConsumedStateMap & operator=(const ConsumedStateMap &)=delete
void checkParamsForReturnTypestate(SourceLocation BlameLoc, ConsumedWarningsHandlerBase &WarningsHandler) const
Warn if any of the parameters being tracked are not in the state they were declared to be in upon ret...
Definition: Consumed.cpp:1089
void intersect(const ConsumedStateMap &Other)
Merge this state map with another map.
Definition: Consumed.cpp:1132
ConsumedState getState(const VarDecl *Var) const
Get the consumed state of a given variable.
Definition: Consumed.cpp:1113
void intersectAtLoopHead(const CFGBlock *LoopHead, const CFGBlock *LoopBack, const ConsumedStateMap *LoopBackStates, ConsumedWarningsHandlerBase &WarningsHandler)
Definition: Consumed.cpp:1151
void remove(const CXXBindTemporaryExpr *Tmp)
Remove the temporary value from our state map.
Definition: Consumed.cpp:1187
void markUnreachable()
Mark the block as unreachable.
Definition: Consumed.cpp:1172
bool operator!=(const ConsumedStateMap *Other) const
Tests to see if there is a mismatch in the states stored in two maps.
Definition: Consumed.cpp:1191
ConsumedStateMap(const ConsumedStateMap &Other)
Definition: Consumed.h:155
void setState(const VarDecl *Var, ConsumedState State)
Set the consumed state of a given variable.
Definition: Consumed.cpp:1178
void setSource(const Stmt *Source)
Set the source for a decision about the branching of states.
Definition: Consumed.h:192
virtual void warnUseOfTempInInvalidState(StringRef MethodName, StringRef State, SourceLocation Loc)
Warn about use-while-consumed errors.
Definition: Consumed.h:122
virtual void warnParamTypestateMismatch(SourceLocation LOC, StringRef ExpectedState, StringRef ObservedState)
Definition: Consumed.h:88
virtual void warnLoopStateMismatch(SourceLocation Loc, StringRef VariableName)
Warn that a variable's state doesn't match at the entry and exit of a loop.
Definition: Consumed.h:70
virtual void warnUseInInvalidState(StringRef MethodName, StringRef VariableName, StringRef State, SourceLocation Loc)
Warn about use-while-consumed errors.
Definition: Consumed.h:136
virtual void emitDiagnostics()
Emit the warnings and notes left by the analysis.
Definition: Consumed.h:61
virtual void warnReturnTypestateMismatch(SourceLocation Loc, StringRef ExpectedState, StringRef ObservedState)
Warn about return typestate mismatches.
Definition: Consumed.h:111
virtual void warnReturnTypestateForUnconsumableType(SourceLocation Loc, StringRef TypeName)
Warn about return typestates set for unconsumable types.
Definition: Consumed.h:99
virtual void warnParamReturnTypestateMismatch(SourceLocation Loc, StringRef VariableName, StringRef ExpectedState, StringRef ObservedState)
Warn about parameter typestate mismatches upon return.
Definition: Consumed.h:82
std::list< DelayedDiag > DiagList
Definition: Consumed.h:54
std::pair< PartialDiagnosticAt, OptionalNotes > DelayedDiag
Definition: Consumed.h:53
The JSON file list parser is used to communicate input to InstallAPI.
@ Other
Other implicit parameter.