clang  14.0.0git
CheckerHelpers.h
Go to the documentation of this file.
1 //== CheckerHelpers.h - Helper functions for checkers ------------*- 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 CheckerVisitor.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CHECKERHELPERS_H
14 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CHECKERHELPERS_H
15 
17 #include "clang/AST/Stmt.h"
19 #include "llvm/ADT/Optional.h"
20 #include <tuple>
21 
22 namespace clang {
23 
24 class Expr;
25 class VarDecl;
26 class QualType;
27 class AttributedType;
28 class Preprocessor;
29 
30 namespace ento {
31 
32 bool containsMacro(const Stmt *S);
33 bool containsEnum(const Stmt *S);
34 bool containsStaticLocal(const Stmt *S);
35 bool containsBuiltinOffsetOf(const Stmt *S);
36 template <class T> bool containsStmt(const Stmt *S) {
37  if (isa<T>(S))
38  return true;
39 
40  for (const Stmt *Child : S->children())
41  if (Child && containsStmt<T>(Child))
42  return true;
43 
44  return false;
45 }
46 
47 std::pair<const clang::VarDecl *, const clang::Expr *>
48 parseAssignment(const Stmt *S);
49 
50 // Do not reorder! The getMostNullable method relies on the order.
51 // Optimization: Most pointers expected to be unspecified. When a symbol has an
52 // unspecified or nonnull type non of the rules would indicate any problem for
53 // that symbol. For this reason only nullable and contradicted nullability are
54 // stored for a symbol. When a symbol is already contradicted, it can not be
55 // casted back to nullable.
56 enum class Nullability : char {
57  Contradicted, // Tracked nullability is contradicted by an explicit cast. Do
58  // not report any nullability related issue for this symbol.
59  // This nullability is propagated aggressively to avoid false
60  // positive results. See the comment on getMostNullable method.
61  Nullable,
63  Nonnull
64 };
65 
66 /// Get nullability annotation for a given type.
68 
69 /// Try to parse the value of a defined preprocessor macro. We can only parse
70 /// simple expressions that consist of an optional minus sign token and then a
71 /// token for an integer. If we cannot parse the value then None is returned.
72 llvm::Optional<int> tryExpandAsInteger(StringRef Macro, const Preprocessor &PP);
73 
74 class OperatorKind {
75  union {
78  } Op;
79  bool IsBinary;
80 
81 public:
82  explicit OperatorKind(BinaryOperatorKind Bin) : Op{Bin}, IsBinary{true} {}
83  explicit OperatorKind(UnaryOperatorKind Un) : IsBinary{false} { Op.Un = Un; }
84  bool IsBinaryOp() const { return IsBinary; }
85 
87  assert(IsBinary && "cannot get binary operator - we have a unary operator");
88  return Op.Bin;
89  }
90 
92  if (IsBinary)
93  return Op.Bin;
94  return {};
95  }
96 
98  assert(!IsBinary &&
99  "cannot get unary operator - we have a binary operator");
100  return Op.Un;
101  }
102 
104  if (!IsBinary)
105  return Op.Un;
106  return {};
107  }
108 };
109 
111  bool IsBinary);
112 
113 } // namespace ento
114 
115 } // namespace clang
116 
117 #endif
clang::ento::OperatorKind::OperatorKind
OperatorKind(UnaryOperatorKind Un)
Definition: CheckerHelpers.h:83
clang::ento::Nullability
Nullability
Definition: CheckerHelpers.h:56
clang::ento::OperatorKind::GetUnaryOpUnsafe
UnaryOperatorKind GetUnaryOpUnsafe() const
Definition: CheckerHelpers.h:97
clang::ento::Nullability::Contradicted
@ Contradicted
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:673
clang::CodeGen::AlignmentSource::AttributedType
@ AttributedType
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
llvm::Optional
Definition: LLVM.h:40
clang::ento::containsStaticLocal
bool containsStaticLocal(const Stmt *S)
Definition: CheckerHelpers.cpp:52
clang::ento::OperatorKind::GetUnaryOp
Optional< UnaryOperatorKind > GetUnaryOp() const
Definition: CheckerHelpers.h:103
clang::ento::containsBuiltinOffsetOf
bool containsBuiltinOffsetOf(const Stmt *S)
Definition: CheckerHelpers.cpp:68
clang::ento::OperatorKind::IsBinaryOp
bool IsBinaryOp() const
Definition: CheckerHelpers.h:84
clang::ento::tryExpandAsInteger
llvm::Optional< int > tryExpandAsInteger(StringRef Macro, const Preprocessor &PP)
Try to parse the value of a defined preprocessor macro.
Definition: CheckerHelpers.cpp:113
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1490
clang::ento::parseAssignment
std::pair< const clang::VarDecl *, const clang::Expr * > parseAssignment(const Stmt *S)
Definition: CheckerHelpers.cpp:81
OperatorKinds.h
clang::ento::OperatorKind::GetBinaryOp
Optional< BinaryOperatorKind > GetBinaryOp() const
Definition: CheckerHelpers.h:91
clang::ento::Nullability::Nonnull
@ Nonnull
clang::ento::Nullability::Nullable
@ Nullable
clang::ento::OperatorKind::GetBinaryOpUnsafe
BinaryOperatorKind GetBinaryOpUnsafe() const
Definition: CheckerHelpers.h:86
clang::ento::OperatorKind::OperatorKind
OperatorKind(BinaryOperatorKind Bin)
Definition: CheckerHelpers.h:82
clang::ento::containsStmt
bool containsStmt(const Stmt *S)
Definition: CheckerHelpers.h:36
OperationKinds.h
clang::OverloadedOperatorKind
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
clang::ento::operationKindFromOverloadedOperator
OperatorKind operationKindFromOverloadedOperator(OverloadedOperatorKind OOK, bool IsBinary)
Definition: CheckerHelpers.cpp:151
clang::UnaryOperatorKind
UnaryOperatorKind
Definition: OperationKinds.h:30
clang::BinaryOperatorKind
BinaryOperatorKind
Definition: OperationKinds.h:25
clang::ento::getNullabilityAnnotation
Nullability getNullabilityAnnotation(QualType Type)
Get nullability annotation for a given type.
Definition: CheckerHelpers.cpp:102
clang
Definition: CalledOnceCheck.h:17
clang::ento::containsEnum
bool containsEnum(const Stmt *S)
Definition: CheckerHelpers.cpp:38
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:69
clang::ento::OperatorKind::Un
UnaryOperatorKind Un
Definition: CheckerHelpers.h:77
clang::ento::Nullability::Unspecified
@ Unspecified
Stmt.h
clang::ento::OperatorKind::Bin
BinaryOperatorKind Bin
Definition: CheckerHelpers.h:76
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:130
clang::ento::containsMacro
bool containsMacro(const Stmt *S)
Definition: CheckerHelpers.cpp:23
clang::ento::OperatorKind
Definition: CheckerHelpers.h:74