Changes in insert_iter_iter.pass.cpp

f376a3bba1900942f75092a7c2ea100a28e7cbac - Work around GCC test failure that is caused by enabling optimizations. (#73998)

Sun, 03 Dec 2023 05:43:41 +0000

Work around GCC test failure that is caused by enabling optimizations. (#73998)While trying to work around MSAN/TSAN build timeouts, we enabled optimizations on some tests. This caused GCC to start complaining that some values may be uninitialized. I believe GCC is wrong, but more investigation is needed. The values are initialized when the variable `__g` is either < 0 or >= 0. Which only leaves out NaN I believe, which is likely well into UB land anyway. However, more investigation needed. List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

f19571ee781de932390e8983267263f504e99e1f - [libc++] Revert "Compile MSAN/TSAN failing test with -O1 (#73555)"

Fri, 01 Dec 2023 14:02:16 +0000

[libc++] Revert "Compile MSAN/TSAN failing test with -O1 (#73555)"This reverts commit 61aef978d6ab1553c48bbd9bf807a277b22451c1, whichbroke the CI on GCC. List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

61aef978d6ab1553c48bbd9bf807a277b22451c1 - Compile MSAN/TSAN failing test with -O1 (#73555)

Wed, 29 Nov 2023 23:01:18 +0000

Compile MSAN/TSAN failing test with -O1 (#73555)This attempts to fix flakes on the bots where the modified test times out while running under sanitizers. Turning on the optimizer for just this test appears to mostly fix the issue. List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

10ec9276d40024c23a481e6671dad1521151dd85 - [2a/3][ASan][libcxx] std::deque annotations

Thu, 01 Jun 2023 05:13:24 +0000

[2a/3][ASan][libcxx] std::deque annotationsThis revision is a part of a series of patches extending AddressSanitizer C++ container overflow detection capabilities by adding annotations, similar to those existing in `std::vector`, to `std::string` and `std::deque` collections. These changes allow ASan to detect cases when the instrumented program accesses memory which is internally allocated by the collection but is still not in-use (accesses before or after the stored elements for `std::deque`, or between the size and capacity bounds for `std::string`).The motivation for the research and those changes was a bug, found by Trail of Bits, in a real code where an out-of-bounds read could happen as two strings were compared via a std::equals function that took `iter1_begin`, `iter1_end`, `iter2_begin` iterators (with a custom comparison function). When object `iter1` was longer than `iter2`, read out-of-bounds on `iter2` could happen. Container sanitization would detect it.This revision introduces annotations for `std::deque`. Each chunk of the container can now be annotated using the `__sanitizer_annotate_double_ended_contiguous_container` function, which was added in the rG1c5ad6d2c01294a0decde43a88e9c27d7437d157. Any attempt to access poisoned memory will trigger an ASan error. Although false negatives are rare, they are possible due to limitations in the ASan API, where a few (usually up to 7) bytes before the container may remain unpoisoned. There are no false positives in the same way as with `std::vector` annotations.This patch only supports objects (deques) that use the standard allocator. However, it can be easily extended to support all allocators, as suggested in the D146815 revision.Furthermore, the patch includes the addition of the `is_double_ended_contiguous_container_asan_correct` function to `libcxx/test/support/asan_testing.h`. This function can be used to verify whether a `std::deque` object has been correctly annotated.Finally, the patch extends the unit tests to verify ASan annotations (added LIBCPP_ASSERTs).If a program is compiled without ASan, all helper functions will be no-ops. In binaries with ASan, there is a negligible performance impact since the code from the change is only executed when the deque container changes in size and it’s proportional to the change. It is important to note that regardless of whether or not these changes are in use, every access to the container's memory is instrumented.If you have any questions, please email:- advenam.tacet@trailofbits.com- disconnect3d@trailofbits.comReviewed By: #libc, philnikDifferential Revision: https://reviews.llvm.org/D132092 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

520c7fbbd0356f135a19cc764ff70e7f52ba11a0 - [libc++] Mark slow tests as unsupported on GCC

Mon, 12 Jun 2023 18:21:47 +0000

[libc++] Mark slow tests as unsupported on GCCSome tests in our test suite are unbelievably slow on GCC due to theuse of the always_inline attribute. See [1] for more details.This patch introduces the GCC-ALWAYS_INLINE-FIXME lit feature todisable tests that are plagued by that issue. At the same time, itmoves several existing tests from ad-hoc `UNSUPPORTED: gcc-12` markupto the new GCC-ALWAYS_INLINE-FIXME feature, and marks the slowest testsreported by the CI as `UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME`.[1]: https://discourse.llvm.org/t/rfc-stop-supporting-extern-instantiations-with-gcc/71277/1Differential Revision: https://reviews.llvm.org/D152736 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

1ab4438920b5ed9dc848b9a6f84c254f07a69f15 - Revert "[2a/3][ASan][libcxx] std::deque annotations"

Wed, 31 May 2023 20:31:49 +0000

Revert "[2a/3][ASan][libcxx] std::deque annotations"This reverts commit 605b9c76e093f6ed713b3fea47cb9726b346edeb. List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

605b9c76e093f6ed713b3fea47cb9726b346edeb - [2a/3][ASan][libcxx] std::deque annotations

Wed, 24 May 2023 21:26:14 +0000

[2a/3][ASan][libcxx] std::deque annotationsThis revision is a part of a series of patches extending AddressSanitizer C++ container overflow detection capabilities by adding annotations, similar to those existing in std::vector, to std::string and `std::deque` collections. These changes allow ASan to detect cases when the instrumented program accesses memory which is internally allocated by the collection but is still not in-use (accesses before or after the stored elements for `std::deque`, or between the size and capacity bounds for `std::string`).The motivation for the research and those changes was a bug, found by Trail of Bits, in a real code where an out-of-bounds read could happen as two strings were compared via a std::equals function that took `iter1_begin`, `iter1_end`, `iter2_begin` iterators (with a custom comparison function). When object `iter1` was longer than `iter2`, read out-of-bounds on `iter2` could happen. Container sanitization would detect it.This revision introduces annotations for `std::deque`. Each chunk of the container can now be annotated using the `__sanitizer_annotate_double_ended_contiguous_container` function, which was added in the rG1c5ad6d2c01294a0decde43a88e9c27d7437d157. Any attempt to access poisoned memory will trigger an ASan error. Although false negatives are rare, they are possible due to limitations in the ASan API, where a few (usually up to 7) bytes before the container may remain unpoisoned. There are no false positives in the same way as with `std::vector` annotations.This patch only supports objects (deques) that use the standard allocator. However, it can be easily extended to support all allocators, as suggested in the D146815 revision.Furthermore, the patch includes the addition of the `is_double_ended_contiguous_container_asan_correct` function to libcxx/test/support/asan_testing.h. This function can be used to verify whether a `std::deque` object has been correctly annotated.Finally, the patch extends the unit tests to verify ASan annotations (added LIBCPP_ASSERTs).If a program is compiled without ASan, all helper functions will be no-ops. In binaries with ASan, there is a negligible performance impact since the code from the change is only executed when the deque container changes in size and it’s proportional to the change. It is important to note that regardless of whether or not these changes are in use, every access to the container's memory is instrumented.Reviewed By: #libc, philnikSpies: vitalybuka, hans, mikhail.ramalho, Enna1, #sanitizers, philnik, libcxx-commitsDifferential Revision: https://reviews.llvm.org/D132092 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

bb13ed231a20e79d7ccd1571015dc78efdef3a46 - Revert "[2a/3][ASan][libcxx] std::deque annotations"

Sat, 06 May 2023 07:21:17 +0000

Revert "[2a/3][ASan][libcxx] std::deque annotations"https://lab.llvm.org/buildbot/#/builders/168/builds/13310https://lab.llvm.org/buildbot/#/builders/239/builds/2107This reverts commit 9a5f283139201ba5878780c06c97e4ad1f5eac39. List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

9a5f283139201ba5878780c06c97e4ad1f5eac39 - [2a/3][ASan][libcxx] std::deque annotations

Fri, 05 May 2023 16:09:34 +0000

[2a/3][ASan][libcxx] std::deque annotationsThis revision is a part of a series of patches extending AddressSanitizer C++ container overflow detection capabilities by adding annotations, similar to those existing in std::vector, to std::string and `std::deque` collections. These changes allow ASan to detect cases when the instrumented program accesses memory which is internally allocated by the collection but is still not in-use (accesses before or after the stored elements for `std::deque`, or between the size and capacity bounds for `std::string`).The motivation for the research and those changes was a bug, found by Trail of Bits, in a real code where an out-of-bounds read could happen as two strings were compared via a std::equals function that took `iter1_begin`, `iter1_end`, `iter2_begin` iterators (with a custom comparison function). When object `iter1` was longer than `iter2`, read out-of-bounds on `iter2` could happen. Container sanitization would detect it.This revision introduces annotations for `std::deque`. Each chunk of the container can now be annotated using the `__sanitizer_annotate_double_ended_contiguous_container` function, which was added in the rG1c5ad6d2c01294a0decde43a88e9c27d7437d157. Any attempt to access poisoned memory will trigger an ASan error. Although false negatives are rare, they are possible due to limitations in the ASan API, where a few (usually up to 7) bytes before the container may remain unpoisoned. There are no false positives in the same way as with `std::vector` annotations.This patch only supports objects (deques) that use the standard allocator. However, it can be easily extended to support all allocators, as suggested in the D146815 revision.Furthermore, the patch includes the addition of the `is_double_ended_contiguous_container_asan_correct` function to libcxx/test/support/asan_testing.h. This function can be used to verify whether a `std::deque` object has been correctly annotated.Finally, the patch extends the unit tests to verify ASan annotations (added LIBCPP_ASSERTs).If a program is compiled without ASan, all helper functions will be no-ops. In binaries with ASan, there is a negligible performance impact since the code from the change is only executed when the deque container changes in size and it’s proportional to the change. It is important to note that regardless of whether or not these changes are in use, every access to the container's memory is instrumented.Reviewed By: #libc, philnikSpies: mikhail.ramalho, Enna1, #sanitizers, philnik, libcxx-commitsDifferential Revision: https://reviews.llvm.org/D132092 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

f33d7493a5b175844d275c4fb452ba0833df71b4 - [libc++] [test] Qualify `distance` as `std::distance` in a lot of tests. NFCI.

Sun, 13 Feb 2022 19:46:29 +0000

[libc++] [test] Qualify `distance` as `std::distance` in a lot of tests. NFCI.We shouldn't be calling `distance` via ADL -- and neither should anybodyin the wild be calling it via ADL, so it's not like we need to testthis ADL ability of `distance` in particular.Differential Revision: https://reviews.llvm.org/D119685 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

16bf43398a62604e6a4146deeb1c43dfa1e78e04 - [libc++] Comma-operator-proof a lot of algorithm/container code.

Wed, 08 Sep 2021 01:35:37 +0000

[libc++] Comma-operator-proof a lot of algorithm/container code.Detected by evil-izing the widely used `MoveOnly` testing type.I had to patch some tests that were themselves using its comma operator,but I think that's a worthwhile cost in order to catch more placesin our headers that needed comma-proofing.The trick here is that even `++ptr, SomeClass()` can find a comma operatorby ADL, if `ptr` is of type `Evil*`. (A comma between two operandsof non-class-or-enum type is always treated as the built-incomma, without ADL. But if either operand is class-or-enum, thenADL happens for _both_ operands' types.)Differential Revision: https://reviews.llvm.org/D109414 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

773ae4412468433c134e668b4047c94f4599e0fd - [libcxx][nfc] prefixes test type `input_iterator` with `cpp17_`

Sat, 24 Apr 2021 21:31:23 +0000

[libcxx][nfc] prefixes test type `input_iterator` with `cpp17_`C++20 revised the definition of what it means to be an iterator. Whileall _Cpp17InputIterators_ satisfy `std::input_iterator`, the reverseisn't true. D100271 introduces a new test adaptor to accommodate thisnew definition (`cpp20_input_iterator`).In order to help readers immediately distinguish which input iteratoradaptor is _Cpp17InputIterator_, the current `input_iterator` adaptorhas been prefixed with `cpp17_`.Differential Revision: https://reviews.llvm.org/D101242 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

2df59c50688c122bbcae7467d3eaf862c3ea3088 - Support tests in freestanding

Mon, 04 Feb 2019 20:31:13 +0000

Support tests in freestandingSummary:Freestanding is *weird*. The standard allows it to differ in a bunch of oddmanners from regular C++, and the committee would like to improve thatsituation. I'd like to make libc++ behave better with what freestanding shouldbe, so that it can be a tool we use in improving the standard. To do that weneed to try stuff out, both with "freestanding the language mode" and"freestanding the library subset".Let's start with the super basic: run the libc++ tests in freestanding, usingclang as the compiler, and see what works. The easiest hack to do this:In utils/libcxx/test/config.py add: self.cxx.compile_flags += ['-ffreestanding']Run the tests and they all fail.Why? Because in freestanding `main` isn't special. This "not special" propertyhas two effects: main doesn't get mangled, and main isn't allowed to omit its`return` statement. The first means main gets mangled and the linker can'tcreate a valid executable for us to test. The second means we spew out warnings(ew) and the compiler doesn't insert the `return` we omitted, and main justfalls of the end and does whatever undefined behavior (if you're luck, ud2leading to non-zero return code).Let's start my work with the basics. This patch changes all libc++ tests todeclare `main` as `int main(int, char**` so it mangles consistently (enabling usto declare another `extern "C"` main for freestanding which calls the mangledone), and adds `return 0;` to all places where it was missing. This touches 6124files, and I apologize.The former was done with The Magic Of Sed.The later was done with a (not quite correct but decent) clang tool: https://gist.github.com/jfbastien/793819ff360baa845483dde81170feedThis works for most tests, though I did have to adjust a few places when e.g.the test runs with `-x c`, macros are used for main (such as for the filesystemtests), etc.Once this is in we can create a freestanding bot which will prevent furtherregressions. After that, we can start the real work of supporting C++freestanding fairly well in libc++.Reviewers: ldionne, mclow.lists, EricWFSubscribers: christof, jkorous, dexonsmith, arphaman, miyuki, libcxx-commitsDifferential Revision: https://reviews.llvm.org/D57624llvm-svn: 353086 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

57b08b0944046a6a57ee9b7b479181f548a5b9b4 - Update more file headers across all of the LLVM projects in the monorepo

Sat, 19 Jan 2019 10:56:40 +0000

Update more file headers across all of the LLVM projects in the monorepoto reflect the new license. These used slightly different spellings thatdefeated my regular expressions.We understand that people may be surprised that we're moving the headerentirely to discuss the new license. We checked this carefully with theFoundation's lawyer and we believe this is the correct approach.Essentially, all code in the project is now made available by the LLVMproject under our new license, so you will see that the license headersinclude that license only. Some of our contributors have contributedcode under our old license, and accordingly, we have retained a copy ofour old license notice in the top-level files in each project andrepository.llvm-svn: 351648 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

fbfb2ab63e94f1b0c248cd810ae3fb35889d99b6 - [libcxx] [test] D27021: Fix MSVC warning C4389 "signed/unsigned mismatch", part 8/12.

Tue, 06 Dec 2016 01:12:34 +0000

[libcxx] [test] D27021: Fix MSVC warning C4389 "signed/unsigned mismatch", part 8/12.Add static_cast when comparing distance() to size().These replacements were performed programmatically with regex_replace():const vector> reg_fmt = { { regex(R"(assert$(\w+)\.size\($ == std::distance$(\w+, \w+)$\))"), "assert($1.size() == static_cast(std::distance($2)))" }, { regex(R"(assert$distance\((\w+\.begin\($, \w+\.end)\) == (\w+)\.size\))"), "assert(static_cast(distance($1)) == $2.size())" }, { regex(R"(assert$std::distance\((\w+\.\w*begin\($, \w+\.\w*end)\) == (\w+)\.size\))"), "assert(static_cast(std::distance($1)) == $2.size())" },};Also, include when it wasn't already being included.llvm-svn: 288745 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

a11d322f0d5530a4da67aa77ad1137c63f874288 - [libcxx] [test] D27014: Fix MSVC warning C4018 "signed/unsigned mismatch", part 2/12.

Wed, 23 Nov 2016 22:01:58 +0000

[libcxx] [test] D27014: Fix MSVC warning C4018 "signed/unsigned mismatch", part 2/12.Add static_cast when comparing int to std::size_t.Also, include when it wasn't already being included.llvm-svn: 287822 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

69a4f66114eed30c06d403bf3cb1e2e9360a20d4 - [libc++] Fix stack_allocator

Sat, 08 Oct 2016 00:56:22 +0000

[libc++] Fix stack_allocatorSummary:To quote STL the problems with stack allocator are">"stack_allocator is seriously nonconformant to N4582 17.6.3.5 [allocator.requirements].> First, it lacks a rebinding constructor. (The nested "struct rebind" isn't sufficient.)> Second, it lacks templated equality/inequality.> Third, it completely ignores alignment.> Finally, and most severely, the Standard forbids its existence. Allocators are forbidden from returning memory "inside themselves". This requirement is implied by the Standard's requirements for rebinding and equality. It's permitted to return memory from a separate buffer object on the stack, though."This patch attempts to address all of those issues.First, instead of storing the buffer inside the allocator I've change `stack_allocator` to accept the buffer as an argument.Second, in order to fix rebinding I changed the parameter list from `` to ``. This allows allocator rebindingbetween types that have different sizes. Third, I added copy and rebinding constructors and assignment operators.And finally I fixed the allocation logic to always return properly aligned storage.Reviewers: mclow.lists, howard.hinnant, STL_MSFTSubscribers: cfe-commitsDifferential Revision: https://reviews.llvm.org/D25154llvm-svn: 283631 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

c45b673d5db23b9ccc92d371200a386f1bb47b47 - Fix warnings in deque tests

Sun, 19 Jul 2015 00:31:54 +0000

Fix warnings in deque testsllvm-svn: 242632 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

861d0ea2aa3dbb251f3ee0bcc811af5cd629fba6 - Fix more issues exposed by -pedantic-errors in c++03 mode

Tue, 10 Feb 2015 17:20:18 +0000

Fix more issues exposed by -pedantic-errors in c++03 modellvm-svn: 228711 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

949389c395edffc54f3551cbb595065a6f4e6a78 - We had two identical files named 'MoveOnly.h' in the test suite. Move one to support/, remove the other, and update all the tests that included them. No functionality change.

Wed, 28 Jan 2015 21:22:53 +0000

We had two identical files named 'MoveOnly.h' in the test suite. Move one to support/, remove the other, and update all the tests that included them. No functionality change.llvm-svn: 227370 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp