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 
16 #include "clang/AST/OperationKinds.h"
17 #include "clang/AST/Stmt.h"
18 #include "clang/Basic/OperatorKinds.h"
19 #include <optional>
20 #include <tuple>
21 
22 namespace clang {
23 
24 class Expr;
25 class VarDecl;
26 class QualType;
27 class Preprocessor;
28 
29 namespace ento {
30 
31 bool containsMacro(const Stmt *S);
32 bool containsEnum(const Stmt *S);
33 bool containsStaticLocal(const Stmt *S);
34 bool containsBuiltinOffsetOf(const Stmt *S);
35 template <class T> bool containsStmt(const Stmt *S) {
36   if (isa<T>(S))
37       return true;
38 
39   for (const Stmt *Child : S->children())
40     if (Child && containsStmt<T>(Child))
41       return true;
42 
43   return false;
44 }
45 
46 std::pair<const clang::VarDecl *, const clang::Expr *>
47 parseAssignment(const Stmt *S);
48 
49 // Do not reorder! The getMostNullable method relies on the order.
50 // Optimization: Most pointers expected to be unspecified. When a symbol has an
51 // unspecified or nonnull type non of the rules would indicate any problem for
52 // that symbol. For this reason only nullable and contradicted nullability are
53 // stored for a symbol. When a symbol is already contradicted, it can not be
54 // casted back to nullable.
55 enum class Nullability : char {
56   Contradicted, // Tracked nullability is contradicted by an explicit cast. Do
57                 // not report any nullability related issue for this symbol.
58                 // This nullability is propagated aggressively to avoid false
59                 // positive results. See the comment on getMostNullable method.
60   Nullable,
61   Unspecified,
62   Nonnull
63 };
64 
65 /// Get nullability annotation for a given type.
66 Nullability getNullabilityAnnotation(QualType Type);
67 
68 /// Try to parse the value of a defined preprocessor macro. We can only parse
69 /// simple expressions that consist of an optional minus sign token and then a
70 /// token for an integer. If we cannot parse the value then std::nullopt is
71 /// returned.
72 std::optional<int> tryExpandAsInteger(StringRef Macro, const Preprocessor &PP);
73 
74 class OperatorKind {
75   union {
76     BinaryOperatorKind Bin;
77     UnaryOperatorKind Un;
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 
86   BinaryOperatorKind GetBinaryOpUnsafe() const {
87     assert(IsBinary && "cannot get binary operator - we have a unary operator");
88     return Op.Bin;
89   }
90 
91   std::optional<BinaryOperatorKind> GetBinaryOp() const {
92     if (IsBinary)
93       return Op.Bin;
94     return {};
95   }
96 
97   UnaryOperatorKind GetUnaryOpUnsafe() const {
98     assert(!IsBinary &&
99            "cannot get unary operator - we have a binary operator");
100     return Op.Un;
101   }
102 
103   std::optional<UnaryOperatorKind> GetUnaryOp() const {
104     if (!IsBinary)
105       return Op.Un;
106     return {};
107   }
108 };
109 
110 OperatorKind operationKindFromOverloadedOperator(OverloadedOperatorKind OOK,
111                                                  bool IsBinary);
112 
113 } // namespace ento
114 
115 } // namespace clang
116 
117 #endif
118