The checker assumed that it could safely cast an SVal to Nonloc. This surfaced because, with std::ranges, we can unintentionally match on other APIs as well, thus increasing the likelihood of violating checker assumptions about the context it's invoked. https://godbolt.org/z/13vEb3K76 See the discourse post on CallDescriptions and std::ranges here. https://discourse.llvm.org/t/calldescriptions-should-not-skip-the-ranges-part-in-std-names-when-matching/73076 Fixes https://github.com/llvm/llvm-project/issues/65009 Differential Revision: https://reviews.llvm.org/D158968
If the non-iterator side of an iterator operation `+`, `+=`, `-` or `-=` is `UndefinedVal` an assertions happens. This small fix prevents this. Patch by Adam Balogh. Reviewed By: NoQ Differential Revision: https://reviews.llvm.org/D85424
The patch that introduces handling iterators implemented as pointers may cause crash in some projects because pointer difference is mistakenly handled as pointer decrement. (Similair case for iterators implemented as class instances are already handled correctly.) This patch fixes this issue. The second case that causes crash is comparison of an iterator implemented as pointer and a null-pointer. This patch contains a fix for this issue as well. The third case which causes crash is that the checker mistakenly considers all integers as nonloc::ConcreteInt when handling an increment or decrement of an iterator implemented as pointers. This patch adds a fix for this too. The last case where crashes were detected is when checking for success of an std::advance() operation. Since the modeling of iterators implemented as pointers is still incomplete this may result in an assertion. This patch replaces the assertion with an early exit and adds a FIXME there. Differential Revision: https://reviews.llvm.org/D83295
Iterators are an abstraction of pointers and in some data structures iterators may be implemented by pointers. This patch adds support for iterators implemented as pointers in all the iterator checkers (including iterator modeling). Differential Revision: https://reviews.llvm.org/D82185
Summary: Some function path may lead to crash. Fixed using local variable outside the scope through a pointer. Fixed minor misspellings. Added regression test. This patch covers a bug https://bugs.llvm.org/show_bug.cgi?id=41485 Reviewed By: baloghadamsoftware Differential Revision: https://reviews.llvm.org/D78289
Container operations such as `push_back()`, `pop_front()` etc. increment and decrement the abstract begin and end symbols of containers. This patch introduces note tags to `ContainerModeling` to track these changes. This helps the user to better identify the source of errors related to containers and iterators. Differential Revision: https://reviews.llvm.org/D73720
Upon calling one of the functions `std::advance()`, `std::prev()` and `std::next()` iterators could get out of their valid range which leads to undefined behavior. If all these funcions are inlined together with the functions they call internally (e.g. `__advance()` called by `std::advance()` in some implementations) the error is detected by `IteratorRangeChecker` but the bug location is inside the STL implementation. Even worse, if the budget runs out and one of the calls is not inlined the bug remains undetected. This patch fixes this behavior: all the bugs are detected at the point of the STL function invocation. Differential Revision: https://reviews.llvm.org/D76379
The recently committed debug.IteratorDebugging checker enables standalone white-box testing of the modelling of containers and iterators. For the three checkers based on iterator modelling only simple tests are needed. Differential Revision: https://reviews.llvm.org/D70123
Range errors (dereferencing or incrementing the past-the-end iterator or decrementing the iterator of the first element of the range) and access of invalidated iterators lead to undefined behavior. There is no point to continue the analysis after such an error on the same execution path, but terminate it by a sink node (fatal error). This also improves the performance and helps avoiding double reports (e.g. in case of nested iterators). Differential Revision: https://reviews.llvm.org/D62893 llvm-svn: 370314
Iterators differences were mistakenly handled as random decrements which causes an assertion. This patch fixes this. llvm-svn: 367802