1 //=== ErrnoModeling.h - Tracking value of 'errno'. -----------------*- 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 // Defines inter-checker API for using the system value 'errno'. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_ERRNOMODELING_H 14 #define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_ERRNOMODELING_H 15 16 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h" 17 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h" 18 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h" 19 #include <optional> 20 21 namespace clang { 22 namespace ento { 23 namespace errno_modeling { 24 25 /// Describe how reads and writes of \c errno are handled by the checker. 26 enum ErrnoCheckState : unsigned { 27 /// We do not know anything about 'errno'. 28 /// Read and write is always allowed. 29 Irrelevant = 0, 30 31 /// Value of 'errno' should be checked to find out if a previous function call 32 /// has failed. 33 /// When this state is set \c errno must be read by the program before a next 34 /// standard function call or other overwrite of \c errno follows, otherwise 35 /// a bug report is emitted. 36 MustBeChecked = 1, 37 38 /// Value of 'errno' is not allowed to be read, it can contain an unspecified 39 /// value. 40 /// When this state is set \c errno is not allowed to be read by the program 41 /// until it is overwritten or invalidated. 42 MustNotBeChecked = 2 43 }; 44 45 /// Returns the value of 'errno', if 'errno' was found in the AST. 46 std::optional<SVal> getErrnoValue(ProgramStateRef State); 47 48 /// Returns the errno check state, \c Errno_Irrelevant if 'errno' was not found 49 /// (this is not the only case for that value). 50 ErrnoCheckState getErrnoState(ProgramStateRef State); 51 52 /// Returns the location that points to the \c MemoryRegion where the 'errno' 53 /// value is stored. Returns \c std::nullopt if 'errno' was not found. Otherwise 54 /// it always returns a valid memory region in the system global memory space. 55 std::optional<Loc> getErrnoLoc(ProgramStateRef State); 56 57 /// Set value of 'errno' to any SVal, if possible. 58 /// The errno check state is set always when the 'errno' value is set. 59 ProgramStateRef setErrnoValue(ProgramStateRef State, 60 const LocationContext *LCtx, SVal Value, 61 ErrnoCheckState EState); 62 63 /// Set value of 'errno' to a concrete (signed) integer, if possible. 64 /// The errno check state is set always when the 'errno' value is set. 65 ProgramStateRef setErrnoValue(ProgramStateRef State, CheckerContext &C, 66 uint64_t Value, ErrnoCheckState EState); 67 68 /// Set the errno check state, do not modify the errno value. 69 ProgramStateRef setErrnoState(ProgramStateRef State, ErrnoCheckState EState); 70 71 /// Clear state of errno (make it irrelevant). 72 ProgramStateRef clearErrnoState(ProgramStateRef State); 73 74 /// Determine if a `Decl` node related to 'errno'. 75 /// This is true if the declaration is the errno variable or a function 76 /// that returns a pointer to the 'errno' value (usually the 'errno' macro is 77 /// defined with this function). \p D is not required to be a canonical 78 /// declaration. 79 bool isErrno(const Decl *D); 80 81 /// Produce a textual description about how \c errno is allowed to be used 82 /// (in a \c ErrnoCheckState). 83 /// The returned string is insertable into a longer warning message in the form 84 /// "the value 'errno' <...>". 85 /// Currently only the \c errno_modeling::MustNotBeChecked state is supported, 86 /// others are not used by the clients. 87 const char *describeErrnoCheckState(ErrnoCheckState CS); 88 89 /// Create a NoteTag that displays the message if the 'errno' memory region is 90 /// marked as interesting, and resets the interestingness. 91 const NoteTag *getErrnoNoteTag(CheckerContext &C, const std::string &Message); 92 93 /// Set errno state for the common case when a standard function is successful. 94 /// Set \c ErrnoCheckState to \c MustNotBeChecked (the \c errno value is not 95 /// affected). At the state transition a note tag created by 96 /// \c getNoteTagForStdSuccess can be used. 97 ProgramStateRef setErrnoForStdSuccess(ProgramStateRef State, CheckerContext &C); 98 99 /// Set errno state for the common case when a standard function fails. 100 /// Set \c errno value to be not equal to zero and \c ErrnoCheckState to 101 /// \c Irrelevant . The irrelevant errno state ensures that no related bug 102 /// report is emitted later and no note tag is needed. 103 /// \arg \c ErrnoSym Value to be used for \c errno and constrained to be 104 /// non-zero. 105 ProgramStateRef setErrnoForStdFailure(ProgramStateRef State, CheckerContext &C, 106 NonLoc ErrnoSym); 107 108 /// Set errno state for the common case when a standard function indicates 109 /// failure only by \c errno. Sets \c ErrnoCheckState to \c MustBeChecked, and 110 /// invalidates the errno region (clear of previous value). 111 /// At the state transition a note tag created by 112 /// \c getNoteTagForStdMustBeChecked can be used. 113 /// \arg \c InvalE Expression that causes invalidation of \c errno. 114 ProgramStateRef setErrnoStdMustBeChecked(ProgramStateRef State, 115 CheckerContext &C, const Expr *InvalE); 116 117 /// Generate the note tag that can be applied at the state generated by 118 /// \c setErrnoForStdSuccess . 119 /// \arg \c Fn Name of the (standard) function that is modeled. 120 const NoteTag *getNoteTagForStdSuccess(CheckerContext &C, llvm::StringRef Fn); 121 122 /// Generate the note tag that can be applied at the state generated by 123 /// \c setErrnoStdMustBeChecked . 124 /// \arg \c Fn Name of the (standard) function that is modeled. 125 const NoteTag *getNoteTagForStdMustBeChecked(CheckerContext &C, 126 llvm::StringRef Fn); 127 128 } // namespace errno_modeling 129 } // namespace ento 130 } // namespace clang 131 132 #endif // LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_ERRNOMODELING_H 133