Changes in default.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.cons/default.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.cons/default.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.cons/default.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.cons/default.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.cons/default.pass.cpp

7fc6a55688c816f5fc1a5481ae7af25be7500356 - Add include for 'test_macros.h' to all the tests that were missing them. Thanks to Zoe for the (big, but simple) patch. NFC intended.

Fri, 31 May 2019 18:35:30 +0000

Add include for 'test_macros.h' to all the tests that were missing them. Thanks to Zoe for the (big, but simple) patch. NFC intended.llvm-svn: 362252 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.cons/default.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.cons/default.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.cons/default.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.cons/default.pass.cpp

f2f2a6395fad5bd49a573fdf2b20072735d496f7 - Replace cplusplus comparisons and dialect has_feature checks with TEST_STD_VER.

Tue, 14 Jun 2016 21:31:42 +0000

Replace __cplusplus comparisons and dialect __has_feature checks with TEST_STD_VER.This is a huge cleanup that helps make the libc++ test suite more portable.Patch from STL@microsoft.com. Thanks STL!llvm-svn: 272716 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.cons/default.pass.cpp

5a83710e371fe68a06e6e3876c6a2c8b820a8976 - Move test into test/std subdirectory.

Sat, 20 Dec 2014 01:40:03 +0000

Move test into test/std subdirectory.llvm-svn: 224658 List of files: /llvm-project/libcxx/test/std/containers/sequences/deque/deque.cons/default.pass.cpp