Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysisContext.h
Line
Count
Source (jump to first uncovered line)
1
//===-- DataflowAnalysisContext.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
//  This file defines a DataflowAnalysisContext class that owns objects that
10
//  encompass the state of a program and stores context that is used during
11
//  dataflow analysis.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_DATAFLOWANALYSISCONTEXT_H
16
#define LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_DATAFLOWANALYSISCONTEXT_H
17
18
#include "clang/AST/Decl.h"
19
#include "clang/AST/Expr.h"
20
#include "clang/AST/TypeOrdering.h"
21
#include "clang/Analysis/FlowSensitive/Solver.h"
22
#include "clang/Analysis/FlowSensitive/StorageLocation.h"
23
#include "clang/Analysis/FlowSensitive/Value.h"
24
#include "llvm/ADT/DenseMap.h"
25
#include "llvm/ADT/DenseSet.h"
26
#include <cassert>
27
#include <memory>
28
#include <type_traits>
29
#include <utility>
30
#include <vector>
31
32
namespace clang {
33
namespace dataflow {
34
35
/// Skip past nodes that the CFG does not emit. These nodes are invisible to
36
/// flow-sensitive analysis, and should be ignored as they will effectively not
37
/// exist.
38
///
39
///   * `ParenExpr` - The CFG takes the operator precedence into account, but
40
///   otherwise omits the node afterwards.
41
///
42
///   * `ExprWithCleanups` - The CFG will generate the appropriate calls to
43
///   destructors and then omit the node.
44
///
45
const Expr &ignoreCFGOmittedNodes(const Expr &E);
46
const Stmt &ignoreCFGOmittedNodes(const Stmt &S);
47
48
/// Returns the set of all fields in the type.
49
llvm::DenseSet<const FieldDecl *> getObjectFields(QualType Type);
50
51
/// Owns objects that encompass the state of a program and stores context that
52
/// is used during dataflow analysis.
53
class DataflowAnalysisContext {
54
public:
55
  /// Constructs a dataflow analysis context.
56
  ///
57
  /// Requirements:
58
  ///
59
  ///  `S` must not be null.
60
  DataflowAnalysisContext(std::unique_ptr<Solver> S)
61
      : S(std::move(S)), TrueVal(createAtomicBoolValue()),
62
        FalseVal(createAtomicBoolValue()) {
63
    assert(this->S != nullptr);
64
  }
65
66
  /// Takes ownership of `Loc` and returns a reference to it.
67
  ///
68
  /// Requirements:
69
  ///
70
  ///  `Loc` must not be null.
71
  template <typename T>
72
  typename std::enable_if<std::is_base_of<StorageLocation, T>::value, T &>::type
73
3.10k
  takeOwnership(std::unique_ptr<T> Loc) {
74
3.10k
    assert(Loc != nullptr);
75
0
    Locs.push_back(std::move(Loc));
76
3.10k
    return *cast<T>(Locs.back().get());
77
3.10k
  }
std::__1::enable_if<std::is_base_of<clang::dataflow::StorageLocation, clang::dataflow::AggregateStorageLocation>::value, clang::dataflow::AggregateStorageLocation&>::type clang::dataflow::DataflowAnalysisContext::takeOwnership<clang::dataflow::AggregateStorageLocation>(std::__1::unique_ptr<clang::dataflow::AggregateStorageLocation, std::__1::default_delete<clang::dataflow::AggregateStorageLocation> >)
Line
Count
Source
73
1.55k
  takeOwnership(std::unique_ptr<T> Loc) {
74
1.55k
    assert(Loc != nullptr);
75
0
    Locs.push_back(std::move(Loc));
76
1.55k
    return *cast<T>(Locs.back().get());
77
1.55k
  }
std::__1::enable_if<std::is_base_of<clang::dataflow::StorageLocation, clang::dataflow::ScalarStorageLocation>::value, clang::dataflow::ScalarStorageLocation&>::type clang::dataflow::DataflowAnalysisContext::takeOwnership<clang::dataflow::ScalarStorageLocation>(std::__1::unique_ptr<clang::dataflow::ScalarStorageLocation, std::__1::default_delete<clang::dataflow::ScalarStorageLocation> >)
Line
Count
Source
73
1.55k
  takeOwnership(std::unique_ptr<T> Loc) {
74
1.55k
    assert(Loc != nullptr);
75
0
    Locs.push_back(std::move(Loc));
76
1.55k
    return *cast<T>(Locs.back().get());
77
1.55k
  }
78
79
  /// Takes ownership of `Val` and returns a reference to it.
80
  ///
81
  /// Requirements:
82
  ///
83
  ///  `Val` must not be null.
84
  template <typename T>
85
  typename std::enable_if<std::is_base_of<Value, T>::value, T &>::type
86
25.5k
  takeOwnership(std::unique_ptr<T> Val) {
87
25.5k
    assert(Val != nullptr);
88
0
    Vals.push_back(std::move(Val));
89
25.5k
    return *cast<T>(Vals.back().get());
90
25.5k
  }
std::__1::enable_if<std::is_base_of<clang::dataflow::Value, clang::dataflow::AtomicBoolValue>::value, clang::dataflow::AtomicBoolValue&>::type clang::dataflow::DataflowAnalysisContext::takeOwnership<clang::dataflow::AtomicBoolValue>(std::__1::unique_ptr<clang::dataflow::AtomicBoolValue, std::__1::default_delete<clang::dataflow::AtomicBoolValue> >)
Line
Count
Source
86
9.85k
  takeOwnership(std::unique_ptr<T> Val) {
87
9.85k
    assert(Val != nullptr);
88
0
    Vals.push_back(std::move(Val));
89
9.85k
    return *cast<T>(Vals.back().get());
90
9.85k
  }
std::__1::enable_if<std::is_base_of<clang::dataflow::Value, clang::dataflow::PointerValue>::value, clang::dataflow::PointerValue&>::type clang::dataflow::DataflowAnalysisContext::takeOwnership<clang::dataflow::PointerValue>(std::__1::unique_ptr<clang::dataflow::PointerValue, std::__1::default_delete<clang::dataflow::PointerValue> >)
Line
Count
Source
86
134
  takeOwnership(std::unique_ptr<T> Val) {
87
134
    assert(Val != nullptr);
88
0
    Vals.push_back(std::move(Val));
89
134
    return *cast<T>(Vals.back().get());
90
134
  }
std::__1::enable_if<std::is_base_of<clang::dataflow::Value, clang::dataflow::ConjunctionValue>::value, clang::dataflow::ConjunctionValue&>::type clang::dataflow::DataflowAnalysisContext::takeOwnership<clang::dataflow::ConjunctionValue>(std::__1::unique_ptr<clang::dataflow::ConjunctionValue, std::__1::default_delete<clang::dataflow::ConjunctionValue> >)
Line
Count
Source
86
2.84k
  takeOwnership(std::unique_ptr<T> Val) {
87
2.84k
    assert(Val != nullptr);
88
0
    Vals.push_back(std::move(Val));
89
2.84k
    return *cast<T>(Vals.back().get());
90
2.84k
  }
std::__1::enable_if<std::is_base_of<clang::dataflow::Value, clang::dataflow::DisjunctionValue>::value, clang::dataflow::DisjunctionValue&>::type clang::dataflow::DataflowAnalysisContext::takeOwnership<clang::dataflow::DisjunctionValue>(std::__1::unique_ptr<clang::dataflow::DisjunctionValue, std::__1::default_delete<clang::dataflow::DisjunctionValue> >)
Line
Count
Source
86
4.68k
  takeOwnership(std::unique_ptr<T> Val) {
87
4.68k
    assert(Val != nullptr);
88
0
    Vals.push_back(std::move(Val));
89
4.68k
    return *cast<T>(Vals.back().get());
90
4.68k
  }
std::__1::enable_if<std::is_base_of<clang::dataflow::Value, clang::dataflow::NegationValue>::value, clang::dataflow::NegationValue&>::type clang::dataflow::DataflowAnalysisContext::takeOwnership<clang::dataflow::NegationValue>(std::__1::unique_ptr<clang::dataflow::NegationValue, std::__1::default_delete<clang::dataflow::NegationValue> >)
Line
Count
Source
86
3.69k
  takeOwnership(std::unique_ptr<T> Val) {
87
3.69k
    assert(Val != nullptr);
88
0
    Vals.push_back(std::move(Val));
89
3.69k
    return *cast<T>(Vals.back().get());
90
3.69k
  }
std::__1::enable_if<std::is_base_of<clang::dataflow::Value, clang::dataflow::IntegerValue>::value, clang::dataflow::IntegerValue&>::type clang::dataflow::DataflowAnalysisContext::takeOwnership<clang::dataflow::IntegerValue>(std::__1::unique_ptr<clang::dataflow::IntegerValue, std::__1::default_delete<clang::dataflow::IntegerValue> >)
Line
Count
Source
86
611
  takeOwnership(std::unique_ptr<T> Val) {
87
611
    assert(Val != nullptr);
88
0
    Vals.push_back(std::move(Val));
89
611
    return *cast<T>(Vals.back().get());
90
611
  }
std::__1::enable_if<std::is_base_of<clang::dataflow::Value, clang::dataflow::ReferenceValue>::value, clang::dataflow::ReferenceValue&>::type clang::dataflow::DataflowAnalysisContext::takeOwnership<clang::dataflow::ReferenceValue>(std::__1::unique_ptr<clang::dataflow::ReferenceValue, std::__1::default_delete<clang::dataflow::ReferenceValue> >)
Line
Count
Source
86
2.21k
  takeOwnership(std::unique_ptr<T> Val) {
87
2.21k
    assert(Val != nullptr);
88
0
    Vals.push_back(std::move(Val));
89
2.21k
    return *cast<T>(Vals.back().get());
90
2.21k
  }
std::__1::enable_if<std::is_base_of<clang::dataflow::Value, clang::dataflow::StructValue>::value, clang::dataflow::StructValue&>::type clang::dataflow::DataflowAnalysisContext::takeOwnership<clang::dataflow::StructValue>(std::__1::unique_ptr<clang::dataflow::StructValue, std::__1::default_delete<clang::dataflow::StructValue> >)
Line
Count
Source
86
1.54k
  takeOwnership(std::unique_ptr<T> Val) {
87
1.54k
    assert(Val != nullptr);
88
0
    Vals.push_back(std::move(Val));
89
1.54k
    return *cast<T>(Vals.back().get());
90
1.54k
  }
91
92
  /// Returns a stable storage location appropriate for `Type`.
93
  ///
94
  /// Requirements:
95
  ///
96
  ///  `Type` must not be null.
97
  StorageLocation &getStableStorageLocation(QualType Type);
98
99
  /// Returns a stable storage location for `D`.
100
  StorageLocation &getStableStorageLocation(const VarDecl &D);
101
102
  /// Returns a stable storage location for `E`.
103
  StorageLocation &getStableStorageLocation(const Expr &E);
104
105
  /// Assigns `Loc` as the storage location of `D`.
106
  ///
107
  /// Requirements:
108
  ///
109
  ///  `D` must not be assigned a storage location.
110
642
  void setStorageLocation(const ValueDecl &D, StorageLocation &Loc) {
111
642
    assert(DeclToLoc.find(&D) == DeclToLoc.end());
112
0
    DeclToLoc[&D] = &Loc;
113
642
  }
114
115
  /// Returns the storage location assigned to `D` or null if `D` has no
116
  /// assigned storage location.
117
1.00k
  StorageLocation *getStorageLocation(const ValueDecl &D) const {
118
1.00k
    auto It = DeclToLoc.find(&D);
119
1.00k
    return It == DeclToLoc.end() ? 
nullptr642
:
It->second366
;
120
1.00k
  }
121
122
  /// Assigns `Loc` as the storage location of `E`.
123
  ///
124
  /// Requirements:
125
  ///
126
  ///  `E` must not be assigned a storage location.
127
1.69k
  void setStorageLocation(const Expr &E, StorageLocation &Loc) {
128
1.69k
    const Expr &CanonE = ignoreCFGOmittedNodes(E);
129
1.69k
    assert(ExprToLoc.find(&CanonE) == ExprToLoc.end());
130
0
    ExprToLoc[&CanonE] = &Loc;
131
1.69k
  }
132
133
  /// Returns the storage location assigned to `E` or null if `E` has no
134
  /// assigned storage location.
135
3.53k
  StorageLocation *getStorageLocation(const Expr &E) const {
136
3.53k
    auto It = ExprToLoc.find(&ignoreCFGOmittedNodes(E));
137
3.53k
    return It == ExprToLoc.end() ? 
nullptr1.69k
:
It->second1.83k
;
138
3.53k
  }
139
140
  /// Assigns `Loc` as the storage location of the `this` pointee.
141
  ///
142
  /// Requirements:
143
  ///
144
  ///  The `this` pointee must not be assigned a storage location.
145
8
  void setThisPointeeStorageLocation(StorageLocation &Loc) {
146
8
    assert(ThisPointeeLoc == nullptr);
147
0
    ThisPointeeLoc = &Loc;
148
8
  }
149
150
  /// Returns the storage location assigned to the `this` pointee or null if the
151
  /// `this` pointee has no assigned storage location.
152
48
  StorageLocation *getThisPointeeStorageLocation() const {
153
48
    return ThisPointeeLoc;
154
48
  }
155
156
  /// Returns a pointer value that represents a null pointer. Calls with
157
  /// `PointeeType` that are canonically equivalent will return the same result.
158
  /// A null `PointeeType` can be used for the pointee of `std::nullptr_t`.
159
  PointerValue &getOrCreateNullPointerValue(QualType PointeeType);
160
161
  /// Returns a symbolic boolean value that models a boolean literal equal to
162
  /// `Value`.
163
1.89k
  AtomicBoolValue &getBoolLiteralValue(bool Value) const {
164
1.89k
    return Value ? 
TrueVal1.04k
:
FalseVal851
;
165
1.89k
  }
166
167
  /// Creates an atomic boolean value.
168
9.85k
  AtomicBoolValue &createAtomicBoolValue() {
169
9.85k
    return takeOwnership(std::make_unique<AtomicBoolValue>());
170
9.85k
  }
171
172
  /// Returns a boolean value that represents the conjunction of `LHS` and
173
  /// `RHS`. Subsequent calls with the same arguments, regardless of their
174
  /// order, will return the same result. If the given boolean values represent
175
  /// the same value, the result will be the value itself.
176
  BoolValue &getOrCreateConjunction(BoolValue &LHS, BoolValue &RHS);
177
178
  /// Returns a boolean value that represents the disjunction of `LHS` and
179
  /// `RHS`. Subsequent calls with the same arguments, regardless of their
180
  /// order, will return the same result. If the given boolean values represent
181
  /// the same value, the result will be the value itself.
182
  BoolValue &getOrCreateDisjunction(BoolValue &LHS, BoolValue &RHS);
183
184
  /// Returns a boolean value that represents the negation of `Val`. Subsequent
185
  /// calls with the same argument will return the same result.
186
  BoolValue &getOrCreateNegation(BoolValue &Val);
187
188
  /// Returns a boolean value that represents `LHS => RHS`. Subsequent calls
189
  /// with the same arguments, will return the same result. If the given boolean
190
  /// values represent the same value, the result will be a value that
191
  /// represents the true boolean literal.
192
  BoolValue &getOrCreateImplication(BoolValue &LHS, BoolValue &RHS);
193
194
  /// Returns a boolean value that represents `LHS <=> RHS`. Subsequent calls
195
  /// with the same arguments, regardless of their order, will return the same
196
  /// result. If the given boolean values represent the same value, the result
197
  /// will be a value that represents the true boolean literal.
198
  BoolValue &getOrCreateIff(BoolValue &LHS, BoolValue &RHS);
199
200
  /// Creates a fresh flow condition and returns a token that identifies it. The
201
  /// token can be used to perform various operations on the flow condition such
202
  /// as adding constraints to it, forking it, joining it with another flow
203
  /// condition, or checking implications.
204
  AtomicBoolValue &makeFlowConditionToken();
205
206
  /// Adds `Constraint` to the flow condition identified by `Token`.
207
  void addFlowConditionConstraint(AtomicBoolValue &Token,
208
                                  BoolValue &Constraint);
209
210
  /// Creates a new flow condition with the same constraints as the flow
211
  /// condition identified by `Token` and returns its token.
212
  AtomicBoolValue &forkFlowCondition(AtomicBoolValue &Token);
213
214
  /// Creates a new flow condition that represents the disjunction of the flow
215
  /// conditions identified by `FirstToken` and `SecondToken`, and returns its
216
  /// token.
217
  AtomicBoolValue &joinFlowConditions(AtomicBoolValue &FirstToken,
218
                                      AtomicBoolValue &SecondToken);
219
220
  // FIXME: This function returns the flow condition expressed directly as its
221
  // constraints: (C1 AND C2 AND ...). This differs from the general approach in
222
  // the framework where a flow condition is represented as a token (an atomic
223
  // boolean) with dependencies and constraints tracked in `FlowConditionDeps`
224
  // and `FlowConditionConstraints`: (FC <=> C1 AND C2 AND ...).
225
  // Consider if we should make the representation of flow condition consistent,
226
  // returning an atomic boolean token with separate constraints instead.
227
  //
228
  /// Builds and returns the logical formula defining the flow condition
229
  /// identified by `Token`. If a value in the formula is present as a key in
230
  /// `Substitutions`, it will be substituted with the value it maps to.
231
  /// As an example, say we have flow condition tokens FC1, FC2, FC3 and
232
  /// FlowConditionConstraints: { FC1: C1,
233
  ///                             FC2: C2,
234
  ///                             FC3: (FC1 v FC2) ^ C3 }
235
  /// buildAndSubstituteFlowCondition(FC3, {{C1 -> C1'}}) will return a value
236
  /// corresponding to (C1' v C2) ^ C3.
237
  BoolValue &buildAndSubstituteFlowCondition(
238
      AtomicBoolValue &Token,
239
      llvm::DenseMap<AtomicBoolValue *, BoolValue *> Substitutions);
240
241
  /// Returns true if and only if the constraints of the flow condition
242
  /// identified by `Token` imply that `Val` is true.
243
  bool flowConditionImplies(AtomicBoolValue &Token, BoolValue &Val);
244
245
  /// Returns true if and only if the constraints of the flow condition
246
  /// identified by `Token` are always true.
247
  bool flowConditionIsTautology(AtomicBoolValue &Token);
248
249
  /// Returns true if `Val1` is equivalent to `Val2`.
250
  /// Note: This function doesn't take into account constraints on `Val1` and
251
  /// `Val2` imposed by the flow condition.
252
  bool equivalentBoolValues(BoolValue &Val1, BoolValue &Val2);
253
254
private:
255
  struct NullableQualTypeDenseMapInfo : private llvm::DenseMapInfo<QualType> {
256
41
    static QualType getEmptyKey() {
257
      // Allow a NULL `QualType` by using a different value as the empty key.
258
41
      return QualType::getFromOpaquePtr(reinterpret_cast<Type *>(1));
259
41
    }
260
261
    using DenseMapInfo::getHashValue;
262
    using DenseMapInfo::getTombstoneKey;
263
    using DenseMapInfo::isEqual;
264
  };
265
266
  /// Adds all constraints of the flow condition identified by `Token` and all
267
  /// of its transitive dependencies to `Constraints`. `VisitedTokens` is used
268
  /// to track tokens of flow conditions that were already visited by recursive
269
  /// calls.
270
  void addTransitiveFlowConditionConstraints(
271
      AtomicBoolValue &Token, llvm::DenseSet<BoolValue *> &Constraints,
272
      llvm::DenseSet<AtomicBoolValue *> &VisitedTokens);
273
274
  /// Returns the outcome of satisfiability checking on `Constraints`.
275
  /// Possible outcomes are:
276
  /// - `Satisfiable`: A satisfying assignment exists and is returned.
277
  /// - `Unsatisfiable`: A satisfying assignment does not exist.
278
  /// - `TimedOut`: The search for a satisfying assignment was not completed.
279
  Solver::Result querySolver(llvm::DenseSet<BoolValue *> Constraints);
280
281
  /// Returns true if the solver is able to prove that there is no satisfying
282
  /// assignment for `Constraints`
283
688
  bool isUnsatisfiable(llvm::DenseSet<BoolValue *> Constraints) {
284
688
    return querySolver(std::move(Constraints)).getStatus() ==
285
688
           Solver::Result::Status::Unsatisfiable;
286
688
  }
287
288
  /// Returns a boolean value as a result of substituting `Val` and its sub
289
  /// values based on entries in `SubstitutionsCache`. Intermediate results are
290
  /// stored in `SubstitutionsCache` to avoid reprocessing values that have
291
  /// already been visited.
292
  BoolValue &substituteBoolValue(
293
      BoolValue &Val,
294
      llvm::DenseMap<BoolValue *, BoolValue *> &SubstitutionsCache);
295
296
  /// Builds and returns the logical formula defining the flow condition
297
  /// identified by `Token`, sub values may be substituted based on entries in
298
  /// `SubstitutionsCache`. Intermediate results are stored in
299
  /// `SubstitutionsCache` to avoid reprocessing values that have already been
300
  /// visited.
301
  BoolValue &buildAndSubstituteFlowConditionWithCache(
302
      AtomicBoolValue &Token,
303
      llvm::DenseMap<BoolValue *, BoolValue *> &SubstitutionsCache);
304
305
  std::unique_ptr<Solver> S;
306
307
  // Storage for the state of a program.
308
  std::vector<std::unique_ptr<StorageLocation>> Locs;
309
  std::vector<std::unique_ptr<Value>> Vals;
310
311
  // Maps from program declarations and statements to storage locations that are
312
  // assigned to them. These assignments are global (aggregated across all basic
313
  // blocks) and are used to produce stable storage locations when the same
314
  // basic blocks are evaluated multiple times. The storage locations that are
315
  // in scope for a particular basic block are stored in `Environment`.
316
  llvm::DenseMap<const ValueDecl *, StorageLocation *> DeclToLoc;
317
  llvm::DenseMap<const Expr *, StorageLocation *> ExprToLoc;
318
319
  StorageLocation *ThisPointeeLoc = nullptr;
320
321
  // Null pointer values, keyed by the canonical pointee type.
322
  //
323
  // FIXME: The pointer values are indexed by the pointee types which are
324
  // required to initialize the `PointeeLoc` field in `PointerValue`. Consider
325
  // creating a type-independent `NullPointerValue` without a `PointeeLoc`
326
  // field.
327
  llvm::DenseMap<QualType, PointerValue *, NullableQualTypeDenseMapInfo>
328
      NullPointerVals;
329
330
  AtomicBoolValue &TrueVal;
331
  AtomicBoolValue &FalseVal;
332
333
  // Indices that are used to avoid recreating the same composite boolean
334
  // values.
335
  llvm::DenseMap<std::pair<BoolValue *, BoolValue *>, ConjunctionValue *>
336
      ConjunctionVals;
337
  llvm::DenseMap<std::pair<BoolValue *, BoolValue *>, DisjunctionValue *>
338
      DisjunctionVals;
339
  llvm::DenseMap<BoolValue *, NegationValue *> NegationVals;
340
341
  // Flow conditions are tracked symbolically: each unique flow condition is
342
  // associated with a fresh symbolic variable (token), bound to the clause that
343
  // defines the flow condition. Conceptually, each binding corresponds to an
344
  // "iff" of the form `FC <=> (C1 ^ C2 ^ ...)` where `FC` is a flow condition
345
  // token (an atomic boolean) and `Ci`s are the set of constraints in the flow
346
  // flow condition clause. The set of constraints (C1 ^ C2 ^ ...) are stored in
347
  // the `FlowConditionConstraints` map, keyed by the token of the flow
348
  // condition.
349
  //
350
  // Flow conditions depend on other flow conditions if they are created using
351
  // `forkFlowCondition` or `joinFlowConditions`. The graph of flow condition
352
  // dependencies is stored in the `FlowConditionDeps` map.
353
  llvm::DenseMap<AtomicBoolValue *, llvm::DenseSet<AtomicBoolValue *>>
354
      FlowConditionDeps;
355
  llvm::DenseMap<AtomicBoolValue *, BoolValue *> FlowConditionConstraints;
356
};
357
358
} // namespace dataflow
359
} // namespace clang
360
361
#endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_DATAFLOWANALYSISCONTEXT_H