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 /// Create a NoteTag that displays the message if the 'errno' memory region is 82 /// marked as interesting, and resets the interestingness. 83 const NoteTag *getErrnoNoteTag(CheckerContext &C, const std::string &Message); 84 85 /// Set errno state for the common case when a standard function is successful. 86 /// Set \c ErrnoCheckState to \c MustNotBeChecked (the \c errno value is not 87 /// affected). 88 ProgramStateRef setErrnoForStdSuccess(ProgramStateRef State, CheckerContext &C); 89 90 /// Set errno state for the common case when a standard function fails. 91 /// Set \c errno value to be not equal to zero and \c ErrnoCheckState to 92 /// \c Irrelevant . The irrelevant errno state ensures that no related bug 93 /// report is emitted later and no note tag is needed. 94 /// \arg \c ErrnoSym Value to be used for \c errno and constrained to be 95 /// non-zero. 96 ProgramStateRef setErrnoForStdFailure(ProgramStateRef State, CheckerContext &C, 97 NonLoc ErrnoSym); 98 99 /// Set errno state for the common case when a standard function indicates 100 /// failure only by \c errno. Sets \c ErrnoCheckState to \c MustBeChecked, and 101 /// invalidates the errno region (clear of previous value). 102 /// \arg \c InvalE Expression that causes invalidation of \c errno. 103 ProgramStateRef setErrnoStdMustBeChecked(ProgramStateRef State, 104 CheckerContext &C, const Expr *InvalE); 105 106 } // namespace errno_modeling 107 } // namespace ento 108 } // namespace clang 109 110 #endif // LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_ERRNOMODELING_H 111