Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
14 pmbaty 1
//===- Environment.h - Map from Stmt* to Locations/Values -------*- 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 defined the Environment and EnvironmentManager classes.
10
//
11
//===----------------------------------------------------------------------===//
12
 
13
#ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ENVIRONMENT_H
14
#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ENVIRONMENT_H
15
 
16
#include "clang/Analysis/AnalysisDeclContext.h"
17
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
18
#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
19
#include "llvm/ADT/ImmutableMap.h"
20
#include <utility>
21
 
22
namespace clang {
23
 
24
class Stmt;
25
 
26
namespace ento {
27
 
28
class SValBuilder;
29
class SymbolReaper;
30
 
31
/// An entry in the environment consists of a Stmt and an LocationContext.
32
/// This allows the environment to manage context-sensitive bindings,
33
/// which is essentially for modeling recursive function analysis, among
34
/// other things.
35
class EnvironmentEntry : public std::pair<const Stmt *,
36
                                          const StackFrameContext *> {
37
public:
38
  EnvironmentEntry(const Stmt *s, const LocationContext *L);
39
 
40
  const Stmt *getStmt() const { return first; }
41
  const LocationContext *getLocationContext() const { return second; }
42
 
43
  /// Profile an EnvironmentEntry for inclusion in a FoldingSet.
44
  static void Profile(llvm::FoldingSetNodeID &ID,
45
                      const EnvironmentEntry &E) {
46
    ID.AddPointer(E.getStmt());
47
    ID.AddPointer(E.getLocationContext());
48
  }
49
 
50
  void Profile(llvm::FoldingSetNodeID &ID) const {
51
    Profile(ID, *this);
52
  }
53
};
54
 
55
/// An immutable map from EnvironemntEntries to SVals.
56
class Environment {
57
private:
58
  friend class EnvironmentManager;
59
 
60
  using BindingsTy = llvm::ImmutableMap<EnvironmentEntry, SVal>;
61
 
62
  BindingsTy ExprBindings;
63
 
64
  Environment(BindingsTy eb) : ExprBindings(eb) {}
65
 
66
  SVal lookupExpr(const EnvironmentEntry &E) const;
67
 
68
public:
69
  using iterator = BindingsTy::iterator;
70
 
71
  iterator begin() const { return ExprBindings.begin(); }
72
  iterator end() const { return ExprBindings.end(); }
73
 
74
  /// Fetches the current binding of the expression in the
75
  /// Environment.
76
  SVal getSVal(const EnvironmentEntry &E, SValBuilder &svalBuilder) const;
77
 
78
  /// Profile - Profile the contents of an Environment object for use
79
  ///  in a FoldingSet.
80
  static void Profile(llvm::FoldingSetNodeID& ID, const Environment* env) {
81
    env->ExprBindings.Profile(ID);
82
  }
83
 
84
  /// Profile - Used to profile the contents of this object for inclusion
85
  ///  in a FoldingSet.
86
  void Profile(llvm::FoldingSetNodeID& ID) const {
87
    Profile(ID, this);
88
  }
89
 
90
  bool operator==(const Environment& RHS) const {
91
    return ExprBindings == RHS.ExprBindings;
92
  }
93
 
94
  void printJson(raw_ostream &Out, const ASTContext &Ctx,
95
                 const LocationContext *LCtx = nullptr, const char *NL = "\n",
96
                 unsigned int Space = 0, bool IsDot = false) const;
97
};
98
 
99
class EnvironmentManager {
100
private:
101
  using FactoryTy = Environment::BindingsTy::Factory;
102
 
103
  FactoryTy F;
104
 
105
public:
106
  EnvironmentManager(llvm::BumpPtrAllocator &Allocator) : F(Allocator) {}
107
 
108
  Environment getInitialEnvironment() {
109
    return Environment(F.getEmptyMap());
110
  }
111
 
112
  /// Bind a symbolic value to the given environment entry.
113
  Environment bindExpr(Environment Env, const EnvironmentEntry &E, SVal V,
114
                       bool Invalidate);
115
 
116
  Environment removeDeadBindings(Environment Env,
117
                                 SymbolReaper &SymReaper,
118
                                 ProgramStateRef state);
119
};
120
 
121
} // namespace ento
122
 
123
} // namespace clang
124
 
125
#endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ENVIRONMENT_H