This is an archive of the discontinued LLVM Phabricator instance.

Differential D25885

[docs] Update the TSan and MSan docs to refer to the new no_sanitize attribute
ClosedPublic

Authored by zaks.anna on Oct 21 2016, 4:26 PM.

Details

Reviewers
kcc
dvyukov
Commits
rG80de16f65319: [docs] Update the TSan and MSan docs to refer to the new no_sanitize attribute
rC285349: [docs] Update the TSan and MSan docs to refer to the new no_sanitize attribute
rL285349: [docs] Update the TSan and MSan docs to refer to the new no_sanitize attribute
Summary

TSan and MSan were the only remaining sanitizers referring to the deprecated attribute for issue suppression. Update the docs to recommend __attribute__((no_sanitize("..."))) instead.

Diff Detail

Event Timeline

zaks.anna updated this revision to Diff 75501.Oct 21 2016, 4:26 PM
zaks.anna retitled this revision from to [docs] Update the TSan and MSan docs to refer to the new no_sanitize attribute .
zaks.anna updated this object.
zaks.anna added reviewers: kcc, dvyukov.
zaks.anna added subscribers: llvm-commits, kubamracek.
kcc accepted this revision.Oct 27 2016, 1:03 PM
kcc edited edge metadata.

LGTM, sorry for delay

This revision is now accepted and ready to land.Oct 27 2016, 1:03 PM
Closed by commit rL285349: [docs] Update the TSan and MSan docs to refer to the new no_sanitize attribute (authored by zaks). · Explain WhyOct 27 2016, 2:48 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
docs/
10 lines
10 lines

Diff 75501

docs/MemorySanitizer.rst

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
.. code-block:: c .. code-block:: c
#if defined(__has_feature) #if defined(__has_feature)
# if __has_feature(memory_sanitizer) # if __has_feature(memory_sanitizer)
// code that builds only under MemorySanitizer // code that builds only under MemorySanitizer
# endif # endif
#endif #endif
``__attribute__((no_sanitize_memory))`` ``__attribute__((no_sanitize("memory")))``
----------------------------------------------- -----------------------------------------------
Some code should not be checked by MemorySanitizer. One may use the function Some code should not be checked by MemorySanitizer. One may use the function
attribute `no_sanitize_memory` to disable uninitialized checks in a particular attribute ``no_sanitize("memory")`` to disable uninitialized checks in a
function. MemorySanitizer may still instrument such functions to avoid false particular function. MemorySanitizer may still instrument such functions to
positives. This attribute may not be supported by other compilers, so we avoid false positives. This attribute may not be supported by other compilers,
suggest to use it together with ``__has_feature(memory_sanitizer)``. so we suggest to use it together with ``__has_feature(memory_sanitizer)``.
Blacklist Blacklist
--------- ---------
MemorySanitizer supports ``src`` and ``fun`` entity types in MemorySanitizer supports ``src`` and ``fun`` entity types in
:doc:`SanitizerSpecialCaseList`, that can be used to relax MemorySanitizer :doc:`SanitizerSpecialCaseList`, that can be used to relax MemorySanitizer
checks for certain source files and functions. All "Use of uninitialized value" checks for certain source files and functions. All "Use of uninitialized value"
warnings will be suppressed and all values loaded from memory will be warnings will be suppressed and all values loaded from memory will be
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

docs/ThreadSanitizer.rst

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
.. code-block:: c .. code-block:: c
#if defined(__has_feature) #if defined(__has_feature)
# if __has_feature(thread_sanitizer) # if __has_feature(thread_sanitizer)
// code that builds only under ThreadSanitizer // code that builds only under ThreadSanitizer
# endif # endif
#endif #endif
``__attribute__((no_sanitize_thread))`` ``__attribute__((no_sanitize("thread")))``
----------------------------------------------- -----------------------------------------------
Some code should not be instrumented by ThreadSanitizer. One may use the Some code should not be instrumented by ThreadSanitizer. One may use the
function attribute `no_sanitize_thread` to disable instrumentation of plain function attribute ``no_sanitize("thread")`` to disable instrumentation of plain
(non-atomic) loads/stores in a particular function. ThreadSanitizer still (non-atomic) loads/stores in a particular function. ThreadSanitizer still
instruments such functions to avoid false positives and provide meaningful stack instruments such functions to avoid false positives and provide meaningful stack
traces. This attribute may not be supported by other compilers, so we suggest traces. This attribute may not be supported by other compilers, so we suggest
to use it together with ``__has_feature(thread_sanitizer)``. to use it together with ``__has_feature(thread_sanitizer)``.
Blacklist Blacklist
--------- ---------
ThreadSanitizer supports ``src`` and ``fun`` entity types in ThreadSanitizer supports ``src`` and ``fun`` entity types in
:doc:`SanitizerSpecialCaseList`, that can be used to suppress data race reports :doc:`SanitizerSpecialCaseList`, that can be used to suppress data race reports
in the specified source files or functions. Unlike functions marked with in the specified source files or functions. Unlike functions marked with
`no_sanitize_thread` attribute, blacklisted functions are not instrumented at ``no_sanitize("thread")`` attribute, blacklisted functions are not instrumented
all. This can lead to false positives due to missed synchronization via atomic at all. This can lead to false positives due to missed synchronization via
operations and missed stack frames in reports. atomic operations and missed stack frames in reports.
Limitations Limitations
----------- -----------
* ThreadSanitizer uses more real memory than a native run. At the default * ThreadSanitizer uses more real memory than a native run. At the default
settings the memory overhead is 5x plus 1Mb per each thread. Settings with 3x settings the memory overhead is 5x plus 1Mb per each thread. Settings with 3x
(less accurate analysis) and 9x (more accurate analysis) overhead are also (less accurate analysis) and 9x (more accurate analysis) overhead are also
available. available.
Show All 22 Lines