clang  10.0.0svn
UninitializedValues.h
Go to the documentation of this file.
1 //=- UninitializedValues.h - Finding uses of uninitialized 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 defines APIs for invoking and reported uninitialized values
10 // warnings.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_UNINITIALIZEDVALUES_H
15 #define LLVM_CLANG_ANALYSIS_ANALYSES_UNINITIALIZEDVALUES_H
16 
17 #include "clang/Basic/LLVM.h"
18 #include "llvm/ADT/SmallVector.h"
19 
20 namespace clang {
21 
22 class AnalysisDeclContext;
23 class CFG;
24 class DeclContext;
25 class Expr;
26 class Stmt;
27 class VarDecl;
28 
29 /// A use of a variable, which might be uninitialized.
30 class UninitUse {
31 public:
32  struct Branch {
33  const Stmt *Terminator;
34  unsigned Output;
35  };
36 
37 private:
38  /// The expression which uses this variable.
39  const Expr *User;
40 
41  /// Is this use uninitialized whenever the function is called?
42  bool UninitAfterCall = false;
43 
44  /// Is this use uninitialized whenever the variable declaration is reached?
45  bool UninitAfterDecl = false;
46 
47  /// Does this use always see an uninitialized value?
48  bool AlwaysUninit;
49 
50  /// This use is always uninitialized if it occurs after any of these branches
51  /// is taken.
52  SmallVector<Branch, 2> UninitBranches;
53 
54 public:
55  UninitUse(const Expr *User, bool AlwaysUninit)
56  : User(User), AlwaysUninit(AlwaysUninit) {}
57 
59  UninitBranches.push_back(B);
60  }
61 
62  void setUninitAfterCall() { UninitAfterCall = true; }
63  void setUninitAfterDecl() { UninitAfterDecl = true; }
64 
65  /// Get the expression containing the uninitialized use.
66  const Expr *getUser() const { return User; }
67 
68  /// The kind of uninitialized use.
69  enum Kind {
70  /// The use might be uninitialized.
72 
73  /// The use is uninitialized whenever a certain branch is taken.
75 
76  /// The use is uninitialized the first time it is reached after we reach
77  /// the variable's declaration.
79 
80  /// The use is uninitialized the first time it is reached after the function
81  /// is called.
83 
84  /// The use is always uninitialized.
86  };
87 
88  /// Get the kind of uninitialized use.
89  Kind getKind() const {
90  return AlwaysUninit ? Always :
91  UninitAfterCall ? AfterCall :
92  UninitAfterDecl ? AfterDecl :
94  }
95 
97 
98  /// Branches which inevitably result in the variable being used uninitialized.
99  branch_iterator branch_begin() const { return UninitBranches.begin(); }
100  branch_iterator branch_end() const { return UninitBranches.end(); }
101  bool branch_empty() const { return UninitBranches.empty(); }
102 };
103 
105 public:
106  UninitVariablesHandler() = default;
107  virtual ~UninitVariablesHandler();
108 
109  /// Called when the uninitialized variable is used at the given expression.
110  virtual void handleUseOfUninitVariable(const VarDecl *vd,
111  const UninitUse &use) {}
112 
113  /// Called when the uninitialized variable analysis detects the
114  /// idiom 'int x = x'. All other uses of 'x' within the initializer
115  /// are handled by handleUseOfUninitVariable.
116  virtual void handleSelfInit(const VarDecl *vd) {}
117 };
118 
121  unsigned NumBlockVisits;
122 };
123 
124 void runUninitializedVariablesAnalysis(const DeclContext &dc, const CFG &cfg,
126  UninitVariablesHandler &handler,
128 
129 } // namespace clang
130 
131 #endif // LLVM_CLANG_ANALYSIS_ANALYSES_UNINITIALIZEDVALUES_H
Stmt - This represents one statement.
Definition: Stmt.h:66
bool branch_empty() const
The use is uninitialized whenever a certain branch is taken.
Represents a variable declaration or definition.
Definition: Decl.h:812
The use might be uninitialized.
branch_iterator branch_end() const
Kind getKind() const
Get the kind of uninitialized use.
branch_iterator branch_begin() const
Branches which inevitably result in the variable being used uninitialized.
AnalysisDeclContext contains the context data for the function or method under analysis.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
Kind
The kind of uninitialized use.
This represents one expression.
Definition: Expr.h:108
Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt...
Definition: CFG.h:1225
virtual void handleSelfInit(const VarDecl *vd)
Called when the uninitialized variable analysis detects the idiom &#39;int x = x&#39;.
void runUninitializedVariablesAnalysis(const DeclContext &dc, const CFG &cfg, AnalysisDeclContext &ac, UninitVariablesHandler &handler, UninitVariablesAnalysisStats &stats)
UninitUse(const Expr *User, bool AlwaysUninit)
A use of a variable, which might be uninitialized.
virtual void handleUseOfUninitVariable(const VarDecl *vd, const UninitUse &use)
Called when the uninitialized variable is used at the given expression.
The use is uninitialized the first time it is reached after we reach the variable&#39;s declaration...
SmallVectorImpl< Branch >::const_iterator branch_iterator
Dataflow Directional Tag Classes.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
const Expr * getUser() const
Get the expression containing the uninitialized use.
The use is always uninitialized.
The use is uninitialized the first time it is reached after the function is called.
void addUninitBranch(Branch B)