[sanitizer] Define SANITIZER_GLIBC to refine SANITIZER_LINUX feature detection and support musl

[MaskRay]

Summary

Several #if SANITIZER_LINUX && !SANITIZER_ANDROID guards are replaced
with the more appropriate #if SANITIZER_GLIBC (the headers are glibc
extensions, not specific to Linux (i.e. if we ever support GNU/kFreeBSD
or Hurd, the guards may automatically work)).

Several #if SANITIZER_LINUX && !SANITIZER_ANDROID guards are refined
with #if SANITIZER_GLIBC (the definitions are available on Linux glibc,
but may not be available on other libc (e.g. musl) implementations).

This patch makes ninja asan cfi lsan msan stats tsan ubsan xray build on a musl based Linux distribution (apk install musl-libintl)
Notes about disabled interceptors for musl:

• SANITIZER_INTERCEPT_GLOB: musl does not implement GLOB_ALTDIRFUNC (GNU extension)
• Some ioctl structs and functions operating on them.
• SANITIZER_INTERCEPT___PRINTF_CHK: _FORTIFY_SOURCE functions are GNU extension
• SANITIZER_INTERCEPT___STRNDUP: dlsym(RTLD_NEXT, "__strndup") errors so a diagnostic is formed. The diagnostic uses write which hasn't been intercepted => SIGSEGV
• SANITIZER_INTERCEPT_*64: the _LARGEFILE64_SOURCE functions are glibc specific. musl does something like #define pread64 pread
• Disabled msg_iovlen msg_controllen cmsg_len checks: musl is conforming while many implementations (Linux/FreeBSD/NetBSD/Solaris) are non-conforming. Since we pick the glibc definition, exclude the checks for musl (incompatible sizes but compatible offsets)

Pass through LIBCXX_HAS_MUSL_LIBC to make check-msan/check-tsan able to build libc++ (https://bugs.llvm.org/show_bug.cgi?id=48618).

Many sanitizer features are available now.

% ninja check-asan
(known issues:
* ASAN_OPTIONS=fast_unwind_on_malloc=0 odr-violations hangs
)
...
Testing Time: 53.69s
  Unsupported      : 185
  Passed           : 512
  Expectedly Failed:   1
  Failed           :  12

% ninja check-ubsan check-ubsan-minimal check-memprof # all passed

% ninja check-cfi
( all cross-dso/)
...
Testing Time: 8.68s
  Unsupported      : 264
  Passed           :  80
  Expectedly Failed:   8
  Failed           :  32

% ninja check-lsan
(With GetTls (D93972), 10 failures)
Testing Time: 4.09s
  Unsupported:  7
  Passed     : 65
  Failed     : 22

% ninja check-msan
(Many are due to functions not marked unsupported.)
Testing Time: 23.09s
  Unsupported      :   6
  Passed           : 764
  Expectedly Failed:   2
  Failed           :  58

% ninja check-tsan
Testing Time: 23.21s
  Unsupported      :  86
  Passed           : 295
  Expectedly Failed:   1
  Failed           :  25

Used ASAN_OPTIONS=verbosity=2 to verify there is no unneeded interceptor.

Partly based on Jari Ronkainen's https://reviews.llvm.org/D63785#1921014

Note: we need to place _FILE_OFFSET_BITS above #include "sanitizer_platform.h" to avoid #define __USE_FILE_OFFSET64 1 in 32-bit ARM features.h

[MaskRay]

.

[MaskRay]

I pushed some trivial portability fixes.

Made some tests on Alpine Linux (musl based distribution) with this patch.

There is a GetTls assertion failure. Simply making
compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp:GetTls return 0
gets sanitizers into a quite decent situation.

% ninja check-asan
...
Testing Time: 332.62s
  Unsupported      : 177
  Passed           : 482
  Expectedly Failed:   1
  Failed           :  20

% ninja check-ubsan
... (TestCases/Misc/monitor.cpp failed)
Testing Time: 98.92s
  Unsupported      :  50
  Passed           : 596
  Expectedly Failed:   2
  Failed           :   8

% ninja check-memprof # all passed

% ninja check-cfi
...
Testing Time: 8.68s
  Unsupported      : 264
  Passed           :  80
  Expectedly Failed:   8
  Failed           :  32

check-xray all failed.

For msan/tsan, I'll need to figure out some libc++ related compile issues.

---

About GetTlsSize. It is used in two places (1) msan/tsan/lsan call AdjustStackSize (https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp#L407) in their pthread_create interceptors (https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/msan/msan_interceptors.cpp#L1037 ) (2) https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp#L547-L555 (this looks suspicious and can probably be removed; sent D93866)

[krytarowski]

Well... technically speaking GLIBC is at least: GNU/Linux, GNU/FreeBSD and HURD.

[MaskRay]

In D93848#2472833, @krytarowski wrote:

Well... technically speaking GLIBC is at least: GNU/Linux, GNU/FreeBSD and HURD.

Hurd and GNU/kFreeBSD are not supported. Even if they do, many defined(__GLIBC__) is inside a #if SANITIZER_LINUX, so they will work automatically.

/usr/include/features.h is needed to get __GLIBC__. tsan is built with a standalone sysroot so /usr/include/features.h is unavailable. So it is not straightforward to create a SANITIZER_GLIBC in lib/sanitizer_common/sanitizer_platform.h

[ronchaine]

Well... technically speaking GLIBC is at least: GNU/Linux, GNU/FreeBSD and HURD.

When I made the original patch, I was looking through what was defined in what standard, and SANITIZER_GNU (or __GLIBC__) here
without SANITIZER_LINUX should be available on those platforms. I can't say for certain since it's been a while since I made that, but
it *should* work on those platforms too. I used SANITIZER_LINUX && SANITIZER_GNU when both were needed by the standard.

If I made a mistake with those, I would concider it a bug.

I would also do declare the SANITIZER_GNU as well, while it can be just __GLIBC__ here in practice, it is not technically the same,
and it's more in line with the style of the rest of the file. It also allows some future-proofing if some platform is crazy enough to provide
GNU extensions without defining __GLIBC__ it could just be added to where we declare SANITIZER_GNU instead of needing to
figure out how to refactor the file again. (i.e. use SANITIZER_GNU to mean "we have GNU extensions")

[MaskRay]

In D93848#2472929, @ronchaine wrote:

Well... technically speaking GLIBC is at least: GNU/Linux, GNU/FreeBSD and HURD.

When I made the original patch, I was looking through what was defined in what standard, and SANITIZER_GNU (or __GLIBC__) here
without SANITIZER_LINUX should be available on those platforms. I can't say for certain since it's been a while since I made that, but
it *should* work on those platforms too. I used SANITIZER_LINUX && SANITIZER_GNU when both were needed by the standard.

If I made a mistake with those, I would concider it a bug.

I would also do declare the SANITIZER_GNU as well, while it can be just __GLIBC__ here in practice, it is not technically the same,
and it's more in line with the style of the rest of the file. It also allows some future-proofing if some platform is crazy enough to provide
GNU extensions without defining __GLIBC__ it could just be added to where we declare SANITIZER_GNU instead of needing to
figure out how to refactor the file again. (i.e. use SANITIZER_GNU to mean "we have GNU extensions")

I think having GLIBC in the macro name is important. There are GNU extensions and glibc headers. The problem with GNU is that it is less specific. Some platforms (FreeBSD) have implemented many GNU extensions (compiler extensions/ELF extensions) but may not provide the header files (obstack.h fstab.h ...; Some of the headers collide with Linux headers). For such headers, I guard them with nested #if SANITIZER_LINUX # ifdef __GLIBC__.

For things may likely work on non-Linux glibc, I just use`#ifdef GLIBC`, e.g.

#ifdef __GLIBC__
int glob_nomatch = GLOB_NOMATCH;  // musl has this but not the following, for simplicity just exclude all
int glob_altdirfunc = GLOB_ALTDIRFUNC;
#endif

In the end I still feel the current organization is great:)

[krytarowski]

In D93848#2472902, @MaskRay wrote:

In D93848#2472833, @krytarowski wrote:

Well... technically speaking GLIBC is at least: GNU/Linux, GNU/FreeBSD and HURD.

Hurd and GNU/kFreeBSD are not supported. Even if they do, many defined(__GLIBC__) is inside a #if SANITIZER_LINUX, so they will work automatically.

At least, GNU/kFreeBSD is supported in other components of LLVM and introducing it in sanitizers should be relatively simple. However I don't plan to maintain these targets myself.

In D93848#2472929, @ronchaine wrote:

I would also do declare the SANITIZER_GNU as well, while it can be just __GLIBC__ here in practice, it is not technically the same,
and it's more in line with the style of the rest of the file.

Please beware that __GNU__ is HURD, not Linux, thus SANITIZER_GNU should be HURD.

[ronchaine]

I think having GLIBC in the macro name is important. There are GNU extensions and glibc headers. The problem with GNU is that it is less specific. Some platforms (FreeBSD) have implemented many GNU extensions (compiler extensions/ELF extensions) but may not provide the header files (obstack.h fstab.h ...; Some of the headers collide with Linux headers). For such headers, I guard them with nested #if SANITIZER_LINUX # ifdef __GLIBC__.

Yeah, that makes sense.

In the end I still feel the current organization is great:)

I just feel like the defines should follow the specifications, otherwise this is just pushing the problem to the next libc.
If the defines followed specifications in the first place, musl wouldn't have needed special treatment to compile.

Please beware that GNU is HURD, not Linux, thus SANITIZER_GNU should be HURD.

Makes sense, I would just like that there would be something else than the __GLIBC__ macro, that would be
controlled inside platform interceptors, like the other defines there. I don't really care that much what it would
be named.

[MaskRay]

In D93848#2473073, @ronchaine wrote:

In the end I still feel the current organization is great:)

I just feel like the defines should follow the specifications, otherwise this is just pushing the problem to the next libc.
If the defines followed specifications in the first place, musl wouldn't have needed special treatment to compile.

Yes, I am aware. Several __GLIBC__ guards are really indeed glibc mess (conflicting with Linux header; likely available on other OSes glibc supports) so glibc instead of GNU is more appropriate.
These are things I think are highly glibc specific and other libc implementation adopting a few GNU extensions may not support (or even if they do decide support, annotating that on top of this patch should not be too difficult).

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

269

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

158–159

please clang format the patch and resolve clang-tidy warnings

[vitalybuka]

LGTM, I'll accept in a day or so if no other feedback

[MaskRay]

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

269

*Nod*
Will fix once the other comment is answered

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

158–159

The clang-tidy warning asks me to remove the spaces in # include.

IMO this will make it less readable. If you it looks fine I'll delete the spaces.

[vitalybuka]

check-asan on debian complains like thins:

ninja: Entering directory `../out/z/'
[0/1] Running the AddressSanitizer tests
FAIL: AddressSanitizer-i386-linux :: TestCases/Linux/pthread_create_version.cpp (551 of 1438)
******************** TEST 'AddressSanitizer-i386-linux :: TestCases/Linux/pthread_create_version.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';      /usr/local/google/home/vitalybuka/src/llvm.git/out/z/./bin/clang  --driver-mode=g++ -fsanitize=address -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -gline-tables-only  -m32  -std=c++11 -pthread /usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/test/asan/TestCases/Linux/pthread_create_version.cpp -o /usr/local/google/home/vitalybuka/src/llvm.git/out/z/projects/compiler-rt/test/asan/I386LinuxConfig/TestCases/Linux/Output/pthread_create_version.cpp.tmp &&  /usr/local/google/home/vitalybuka/src/llvm.git/out/z/projects/compiler-rt/test/asan/I386LinuxConfig/TestCases/Linux/Output/pthread_create_version.cpp.tmp 2>&1
--
Exit Code: 1

Command Output (stdout):
--
AddressSanitizer:DEADLYSIGNAL
=================================================================
==974260==ERROR: AddressSanitizer: SEGV on unknown address 0xfffffb40 (pc 0xf7bcca11 bp 0xffb65548 sp 0xffb654c0 T0)
==974260==The signal is caused by a WRITE memory access.
    #0 0xf7bcca11 in pthread_create@@GLIBC_2.1 (/lib/i386-linux-gnu/libpthread.so.0+0x8a11)
    #1 0xf7bcd42b in pthread_create@GLIBC_2.0 (/lib/i386-linux-gnu/libpthread.so.0+0x942b)
    #2 0x80caff0 in pthread_create /usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/lib/asan/asan_interceptors.cpp:230:14
    #3 0x81186b7 in main /usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/test/asan/TestCases/Linux/pthread_create_version.cpp:19:3
    #4 0xf79c9e45 in __libc_start_main (/lib/i386-linux-gnu/libc.so.6+0x1ee45)
    #5 0x8065321 in _start (/usr/local/google/home/vitalybuka/src/llvm.git/out/z/projects/compiler-rt/test/asan/I386LinuxConfig/TestCases/Linux/Output/pthread_create_version.cpp.tmp+0x8065321)

AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV (/lib/i386-linux-gnu/libpthread.so.0+0x8a11) in pthread_create@@GLIBC_2.1
==974260==ABORTING

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

158–159

Yes, that's what I am asking too. It's not worth of hassle correcting auto format in future.

[MaskRay]

In D93848#2473145, @vitalybuka wrote:

check-asan on debian complains like thins:

ninja: Entering directory `../out/z/'
[0/1] Running the AddressSanitizer tests
FAIL: AddressSanitizer-i386-linux :: TestCases/Linux/pthread_create_version.cpp (551 of 1438)
******************** TEST 'AddressSanitizer-i386-linux :: TestCases/Linux/pthread_create_version.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';      /usr/local/google/home/vitalybuka/src/llvm.git/out/z/./bin/clang  --driver-mode=g++ -fsanitize=address -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -gline-tables-only  -m32  -std=c++11 -pthread /usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/test/asan/TestCases/Linux/pthread_create_version.cpp -o /usr/local/google/home/vitalybuka/src/llvm.git/out/z/projects/compiler-rt/test/asan/I386LinuxConfig/TestCases/Linux/Output/pthread_create_version.cpp.tmp &&  /usr/local/google/home/vitalybuka/src/llvm.git/out/z/projects/compiler-rt/test/asan/I386LinuxConfig/TestCases/Linux/Output/pthread_create_version.cpp.tmp 2>&1
--
Exit Code: 1

Command Output (stdout):
--
AddressSanitizer:DEADLYSIGNAL
=================================================================
==974260==ERROR: AddressSanitizer: SEGV on unknown address 0xfffffb40 (pc 0xf7bcca11 bp 0xffb65548 sp 0xffb654c0 T0)
==974260==The signal is caused by a WRITE memory access.
    #0 0xf7bcca11 in pthread_create@@GLIBC_2.1 (/lib/i386-linux-gnu/libpthread.so.0+0x8a11)
    #1 0xf7bcd42b in pthread_create@GLIBC_2.0 (/lib/i386-linux-gnu/libpthread.so.0+0x942b)
    #2 0x80caff0 in pthread_create /usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/lib/asan/asan_interceptors.cpp:230:14
    #3 0x81186b7 in main /usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/test/asan/TestCases/Linux/pthread_create_version.cpp:19:3
    #4 0xf79c9e45 in __libc_start_main (/lib/i386-linux-gnu/libc.so.6+0x1ee45)
    #5 0x8065321 in _start (/usr/local/google/home/vitalybuka/src/llvm.git/out/z/projects/compiler-rt/test/asan/I386LinuxConfig/TestCases/Linux/Output/pthread_create_version.cpp.tmp+0x8065321)

AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV (/lib/i386-linux-gnu/libpthread.so.0+0x8a11) in pthread_create@@GLIBC_2.1
==974260==ABORTING

The problem is that __GLIBC__ is not defined in lib/interception/interception_linux.h (so the unversioned pthread_create is selected and fails on i386 rL248325).

#include <features.h> (or any other glibc header) needs to be included to get __GLIBC__. However, ninja tsan specifies --sysroot=. (lib/tsan/CMakeLists.txt:246) and /usr/include is not in the search path so features.h cannot be found by tsan.

Any thought making __GLIBC__ available on tsan?

[vitalybuka]

Can we add #include "sanitizer_common/sanitizer_glibc_version.h" into interception_linux.h ?

[MaskRay]

Address comments.

Properly set GLIBC in lib/interception/interception_linux.h

[vitalybuka]

compiler-rt/lib/interception/interception_linux.h

24

@eugenis @dvyukov I propose to remove sysroot=. from tsan. There was idea that we should do that for all sanitizers to avoid random unwanted includes, but now it looks to me as unnecessary hassle.

[krytarowski]

compiler-rt/lib/interception/interception_linux.cpp

67

dlvsym is available on NetBSD too.

compiler-rt/lib/interception/interception_linux.h

39

dlvsym is available on NetBSD too.

[emaste]

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

241–242

FreeBSD has glob(3), NetBSD probably does but I'm not certain. Is there an issue with intercepting glob there?

269

!LINUX_NOT_ANDROID seems confusing; how do FreeBSD/NetBSD factor into ioctl?

[MaskRay]

Enable dlvsym on NetBSD. Some other adjustment

[MaskRay]

compiler-rt/lib/interception/interception_linux.h

24

I second the idea.

It caused hassle to FreeBSD and NetBSD
https://bugs.llvm.org/show_bug.cgi?id=26651

[MaskRay]

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

241–242

This is related to

#ifdef __GLIBC__
int glob_nomatch = GLOB_NOMATCH;
int glob_altdirfunc = GLOB_ALTDIRFUNC;
#endif

glob is simple so I can send a separate patch for FreeBSD. I'll not make functional changes for *BSD in this patch, though.

269

ioctl is very complex. It requires many headers. This patch intends to be a NFC for non-Linux and I'll not touch ioctl for FreeBSD.

[MaskRay]

Drop --sysroot=.
Mark more glibc specific functions. Tested with ASAN_OPTIONS=verbosity=2.
Pushed a semarate commit. ninja check-ubsan passed now
UNSUPPORTED some tests separately. ninja check-asan has only 13 failures now (several symbolizer tests are related to a dead futex __sanitizer::BufferedStackTrace::Unwind->_Unwind_Backtrace->_Unwind_Find_FDE->__pthread_mutex_timedlock->__timedwait->__timedwait_cp->__futex4_cp. I don't investigate further)

[MaskRay]

Make check-msan build

[MaskRay]

Make ioctl work (some like struct termio have to be disabled)
FreeBSD does not have features.h. Add a guard
Tested Android

[MaskRay]

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

241–242

sanitizer_platform_limits_posix.h:752

__sanitizer_glob_t does not match FreeBSD include/glob.h. So glob cannot be enabled on FreeBSD.

[MaskRay]

Enable sendmsg/recvmsg on musl

Most implementations are non-conforming (FreeBSD/NetBSD/OpenBSD/Solaris/macOS/Linux). Exclude the size checks for the conforming musl fields.

[vitalybuka]

compiler-rt/lib/tsan/CMakeLists.txt

252 ↗

(On Diff #313988)

please extract this into a separate patch

[MaskRay]

Rebase on D93921 (Remove --sysroot=.)

[vitalybuka]

compiler-rt/lib/asan/asan_interceptors.h

63

what if we define SANITIZER_GLIBC in sanitizer_platform.h

as is if we remove include features.h, defined(GLIBC) will silently calculated as false.

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

192–194

[MaskRay]

compiler-rt/lib/asan/asan_interceptors.h

63

An undefined macro evaluates to 0. Adding SANITIZER_GLIBC does not seem to improve the situation...

[MaskRay]

Add parentheses around SI_GLIBC || something

[vitalybuka]

compiler-rt/lib/asan/asan_interceptors.h

63

My mistake.
Still we pretty sure that platform.h is included everywhere.
and it will make look these #ifs more consistent

[MaskRay]

Use SANITIZER_GLIBC

[aeubanks]

I believe this is causing issues on the Chrome Android bots:

FAILED: lib/asan/CMakeFiles/RTAsan_dynamic.aarch64.dir/asan_malloc_linux.cpp.o
/b/s/w/ir/cache/builder/src/third_party/llvm-build/Release+Asserts/bin/clang++ -DASAN_DYNAMIC=1 -I/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/.. --target=aarch64-linux-android21 --sysroot=/b/s/w/ir/cache/builder/src/third_party/android_ndk/toolchains/llvm/prebuilt/linux-x86_64/sysroot --gcc-toolchain=/b/s/w/ir/cache/builder/src/third_party/android_ndk/toolchains/llvm/prebuilt/linux-x86_64 -Wall -std=c++14 -Wno-unused-parameter -O3 -DNDEBUG -fPIC -fno-builtin -fno-exceptions -fomit-frame-pointer -funwind-tables -fno-stack-protector -fno-sanitize=safe-stack -fvisibility=hidden -fno-lto -O3 -gline-tables-only -Wno-gnu -Wno-variadic-macros -Wno-c99-extensions -nostdinc++ -fno-rtti -ftls-model=initial-exec -MD -MT lib/asan/CMakeFiles/RTAsan_dynamic.aarch64.dir/asan_malloc_linux.cpp.o -MF lib/asan/CMakeFiles/RTAsan_dynamic.aarch64.dir/asan_malloc_linux.cpp.o.d -o lib/asan/CMakeFiles/RTAsan_dynamic.aarch64.dir/asan_malloc_linux.cpp.o -c /b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/asan_malloc_linux.cpp
/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/asan_malloc_linux.cpp:262:3: error: unknown type name 'fake_mallinfo'

fake_mallinfo (*mallinfo)(void);
^

/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/asan_malloc_linux.cpp:277:53: error: use of undeclared identifier 'interceptor_mallinfo'; did you mean 'interceptor_malloc'?

WRAP(calloc),         WRAP(free),               WRAP(mallinfo),
                                                ^~~~~~~~~~~~~~
                                                __interceptor_malloc

/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/../interception/interception.h:149:18: note: expanded from macro 'WRAP'

define WRAP(x) __interceptor_ ## x

^

<scratch space>:144:1: note: expanded from here
interceptor_mallinfo
^
/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/asan_malloc_linux.cpp:140:1: note: 'interceptor_malloc' declared here
INTERCEPTOR(void*, malloc, uptr size) {
^
/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/../interception/interception.h:232:12: note: expanded from macro 'INTERCEPTOR'

ret_type WRAP(func)(__VA_ARGS__)
         ^

/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/../interception/interception.h:149:18: note: expanded from macro 'WRAP'

define WRAP(x) __interceptor_ ## x

^

<scratch space>:60:1: note: expanded from here
__interceptor_malloc
^

https://logs.chromium.org/logs/chromium/buildbucket/cr-buildbucket.appspot.com/8859402008562911568/+/steps/gclient_runhooks/0/stdout?format=raw

[MaskRay]

In D93848#2476055, @aeubanks wrote:

I believe this is causing issues on the Chrome Android bots:

FAILED: lib/asan/CMakeFiles/RTAsan_dynamic.aarch64.dir/asan_malloc_linux.cpp.o
/b/s/w/ir/cache/builder/src/third_party/llvm-build/Release+Asserts/bin/clang++ -DASAN_DYNAMIC=1 -I/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/.. --target=aarch64-linux-android21 --sysroot=/b/s/w/ir/cache/builder/src/third_party/android_ndk/toolchains/llvm/prebuilt/linux-x86_64/sysroot --gcc-toolchain=/b/s/w/ir/cache/builder/src/third_party/android_ndk/toolchains/llvm/prebuilt/linux-x86_64 -Wall -std=c++14 -Wno-unused-parameter -O3 -DNDEBUG -fPIC -fno-builtin -fno-exceptions -fomit-frame-pointer -funwind-tables -fno-stack-protector -fno-sanitize=safe-stack -fvisibility=hidden -fno-lto -O3 -gline-tables-only -Wno-gnu -Wno-variadic-macros -Wno-c99-extensions -nostdinc++ -fno-rtti -ftls-model=initial-exec -MD -MT lib/asan/CMakeFiles/RTAsan_dynamic.aarch64.dir/asan_malloc_linux.cpp.o -MF lib/asan/CMakeFiles/RTAsan_dynamic.aarch64.dir/asan_malloc_linux.cpp.o.d -o lib/asan/CMakeFiles/RTAsan_dynamic.aarch64.dir/asan_malloc_linux.cpp.o -c /b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/asan_malloc_linux.cpp
/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/asan_malloc_linux.cpp:262:3: error: unknown type name 'fake_mallinfo'

fake_mallinfo (*mallinfo)(void);
^

/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/asan_malloc_linux.cpp:277:53: error: use of undeclared identifier 'interceptor_mallinfo'; did you mean 'interceptor_malloc'?

WRAP(calloc),         WRAP(free),               WRAP(mallinfo),
                                                ^~~~~~~~~~~~~~
                                                __interceptor_malloc

/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/../interception/interception.h:149:18: note: expanded from macro 'WRAP'

define WRAP(x) __interceptor_ ## x

^

<scratch space>:144:1: note: expanded from here
interceptor_mallinfo
^
/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/asan_malloc_linux.cpp:140:1: note: 'interceptor_malloc' declared here
INTERCEPTOR(void*, malloc, uptr size) {
^
/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/../interception/interception.h:232:12: note: expanded from macro 'INTERCEPTOR'

ret_type WRAP(func)(__VA_ARGS__)
         ^

/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/../interception/interception.h:149:18: note: expanded from macro 'WRAP'

define WRAP(x) __interceptor_ ## x

^

<scratch space>:60:1: note: expanded from here
__interceptor_malloc
^

https://logs.chromium.org/logs/chromium/buildbucket/cr-buildbucket.appspot.com/8859402008562911568/+/steps/gclient_runhooks/0/stdout?format=raw

I was misled by a disabled mallinfo guard in tsan for Android. Bionic seems to provide mallinfo: D93970
(I don't know how to test, though)

[aeubanks]

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

24

compiler-rt/lib/hwasan/hwasan_setjmp.S includes sanitizer_platform.h. With this new include, on Android it ends up including C function declarations into a .S file which doesn't compile. https://crbug.com/1162741

[thakis]

Reverted in fe9976c02c09f105751f787ec998abeb3414a235 for now. If you could wait with relanding during working hours, that'd be super appreciated. Thanks!

[MaskRay]

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

24

Thanks for the information. This looks like an Android header file bug. Including features.h should not pull in additional random symbols which cause a compile error.

[ostannard]

This is causing a build failure on the 32-bit ARM bots:

/usr/local/bin/c++  -DHAVE_RPC_XDR_H=1 -D_DEBUG -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -D_LARGEFILE_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Iprojects/compiler-rt/lib/sanitizer_common -I/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common -Iinclude -I/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/llvm/include -I/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/.. -mcpu=cortex-a57 -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wstring-conversion -fdiagnostics-color -ffunction-sections -fdata-sections -Wall -std=c++14 -Wno-unused-parameter -O3     -march=armv7-a -mfloat-abi=hard -fPIC -fno-builtin -fno-exceptions -fomit-frame-pointer -funwind-tables -fno-stack-protector -fno-sanitize=safe-stack -fvisibility=hidden -fno-lto -O3 -gline-tables-only -Wno-gnu -Wno-variadic-macros -Wno-c99-extensions -nostdinc++ -fno-rtti -Wframe-larger-than=570 -Wglobal-constructors -UNDEBUG -std=c++14 -MD -MT projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommon.armhf.dir/sanitizer_platform_limits_posix.cpp.o -MF projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommon.armhf.dir/sanitizer_platform_limits_posix.cpp.o.d -o projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommon.armhf.dir/sanitizer_platform_limits_posix.cpp.o -c /home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp:1046:1: error: static_assert failed due to requirement 'sizeof (((__sanitizer::__sanitizer_dirent *)__null)->d_ino) == sizeof (((dirent *)__null)->d_ino)' ""
CHECK_SIZE_AND_OFFSET(dirent, d_ino);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h:1438:3: note: expanded from macro 'CHECK_SIZE_AND_OFFSET'
  COMPILER_CHECK(sizeof(((__sanitizer_##CLASS *)NULL)->MEMBER) == \
  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h:332:30: note: expanded from macro 'COMPILER_CHECK'
#define COMPILER_CHECK(pred) static_assert(pred, "")
                             ^             ~~~~
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp:1052:1: error: static_assert failed due to requirement 'sizeof (((__sanitizer::__sanitizer_dirent *)__null)->d_off) == sizeof (((dirent *)__null)->d_off)' ""
CHECK_SIZE_AND_OFFSET(dirent, d_off);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h:1438:3: note: expanded from macro 'CHECK_SIZE_AND_OFFSET'
  COMPILER_CHECK(sizeof(((__sanitizer_##CLASS *)NULL)->MEMBER) == \
  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h:332:30: note: expanded from macro 'COMPILER_CHECK'
#define COMPILER_CHECK(pred) static_assert(pred, "")
                             ^             ~~~~
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp:1052:1: error: static_assert failed due to requirement '__builtin_offsetof(__sanitizer::__sanitizer_dirent, d_off) == __builtin_offsetof(dirent, d_off)' ""
CHECK_SIZE_AND_OFFSET(dirent, d_off);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h:1440:3: note: expanded from macro 'CHECK_SIZE_AND_OFFSET'
  COMPILER_CHECK(offsetof(__sanitizer_##CLASS, MEMBER) ==         \
  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h:332:30: note: expanded from macro 'COMPILER_CHECK'
#define COMPILER_CHECK(pred) static_assert(pred, "")
                             ^             ~~~~
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp:1054:1: error: static_assert failed due to requirement '__builtin_offsetof(__sanitizer::__sanitizer_dirent, d_reclen) == __builtin_offsetof(dirent, d_reclen)' ""
CHECK_SIZE_AND_OFFSET(dirent, d_reclen);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h:1440:3: note: expanded from macro 'CHECK_SIZE_AND_OFFSET'
  COMPILER_CHECK(offsetof(__sanitizer_##CLASS, MEMBER) ==         \
  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/tcwg-buildslave/worker/clang-cmake-armv8-lld/llvm/compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h:332:30: note: expanded from macro 'COMPILER_CHECK'
#define COMPILER_CHECK(pred) static_assert(pred, "")
                             ^             ~~~~
4 errors generated.

Full log at http://lab.llvm.org:8011/#/builders/126/builds/1192. This is affecting quite a few bots (all of the ARM bots which build compiler-rt), so I've reverted it as 4839378ca05f88faed53ea25457fd93fcad93460 for now.

[MaskRay]

Move _FILE_OFFSET_BITS above to appease 32-bit ARM features.h
Add a release note

compiler-rt/cmake/Modules/AddCompilerRT.cmake

set(PASSTHROUGH_VARIABLES
     CMAKE_LINKER
     CMAKE_AR
     CMAKE_RANLIB
     CMAKE_NM
     CMAKE_OBJCOPY
     CMAKE_OBJDUMP
     CMAKE_STRIP
     CMAKE_SYSROOT
+    LIBCXX_HAS_MUSL_LIBC
     PYTHON_EXECUTABLE
     Python3_EXECUTABLE
     Python2_EXECUTABLE
     CMAKE_SYSTEM_NAME)
   foreach(variable ${PASSTHROUGH_VARIABLES})
     get_property(is_value_set CACHE ${variable} PROPERTY VALUE SET)
     if(${is_value_set})
       get_property(value CACHE ${variable} PROPERTY VALUE)

compiler-rt/lib/asan/asan_interceptors.h

 
 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
     SANITIZER_SOLARIS
 # define ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX 1
 #else
 # define ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX 0
 #endif
 
-#if (SANITIZER_LINUX && !SANITIZER_ANDROID) || SANITIZER_SOLARIS
+#if SANITIZER_GLIBC || SANITIZER_SOLARIS
 # define ASAN_INTERCEPT_SWAPCONTEXT 1
 #else
 # define ASAN_INTERCEPT_SWAPCONTEXT 0
 #endif
 
 #if !SANITIZER_WINDOWS
 # define ASAN_INTERCEPT_SIGLONGJMP 1
 #else
 # define ASAN_INTERCEPT_SIGLONGJMP 0
 #endif
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#if SANITIZER_GLIBC
 # define ASAN_INTERCEPT___LONGJMP_CHK 1
 #else
 # define ASAN_INTERCEPT___LONGJMP_CHK 0
 #endif
 
 #if ASAN_HAS_EXCEPTIONS && !SANITIZER_WINDOWS && !SANITIZER_SOLARIS && \
     !SANITIZER_NETBSD
 # define ASAN_INTERCEPT___CXA_THROW 1

 #endif
 
 #if SANITIZER_NETBSD
 # define ASAN_INTERCEPT_ATEXIT 1
 #else
 # define ASAN_INTERCEPT_ATEXIT 0
 #endif
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#if SANITIZER_GLIBC
 # define ASAN_INTERCEPT___STRDUP 1
 #else
 # define ASAN_INTERCEPT___STRDUP 0
 #endif
 
 #if SANITIZER_LINUX &&                                                \
     (defined(__arm__) || defined(__aarch64__) || defined(__i386__) || \
      defined(__x86_64__) || SANITIZER_RISCV64)

compiler-rt/lib/asan/tests/asan_test.cpp

char* MallocAndMemsetString(size_t size, char ch) {
   memset(s, ch, size);
   return s;
 }
 
 char* MallocAndMemsetString(size_t size) {
   return MallocAndMemsetString(size, 'z');
 }
 
-#if defined(__linux__) && !defined(__ANDROID__)
+#if SANITIZER_GLIBC
 #define READ_TEST(READ_N_BYTES)                                          \
   char *x = new char[10];                                                \
   int fd = open("/proc/self/stat", O_RDONLY);                            \
   ASSERT_GT(fd, 0);                                                      \
   EXPECT_DEATH(READ_N_BYTES,                                             \
                ASAN_PCRE_DOTALL                                          \
                "AddressSanitizer: heap-buffer-overflow"                  \
                ".* is located 0 bytes to the right of 10-byte region");  \
   close(fd);                                                             \
   delete [] x;                                                           \
 
 TEST(AddressSanitizer, pread) {
   READ_TEST(pread(fd, x, 15, 0));
 }
 
 TEST(AddressSanitizer, pread64) {
   READ_TEST(pread64(fd, x, 15, 0));
 }
 
 TEST(AddressSanitizer, read) {
   READ_TEST(read(fd, x, 15));
 }
-#endif  // defined(__linux__) && !defined(__ANDROID__)
+#endif  // SANITIZER_GLIBC
 
 // This test case fails
 // Clang optimizes memcpy/memset calls which lead to unaligned access
 TEST(AddressSanitizer, DISABLED_MemIntrinsicUnalignedAccessTest) {
   int size = Ident(4096);
   char *s = Ident((char*)malloc(size));
   EXPECT_DEATH(memset(s + size - 1, 0, 2), RightOOBWriteMessage(0));
   free(s);

compiler-rt/lib/interception/interception_linux.h

 
 #if !defined(INCLUDED_FROM_INTERCEPTION_LIB)
 # error "interception_linux.h should be included from interception library only"
 #endif
 
 #ifndef INTERCEPTION_LINUX_H
 #define INTERCEPTION_LINUX_H
 
 namespace __interception {
 bool InterceptFunction(const char *name, uptr *ptr_to_real, uptr func,
                        uptr wrapper);
 bool InterceptFunction(const char *name, const char *ver, uptr *ptr_to_real,
                        uptr func, uptr wrapper);
 }  // namespace __interception
 
 #define INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func) \
   ::__interception::InterceptFunction(            \
       #func,                                      \
       (::__interception::uptr *) & REAL(func),    \
       (::__interception::uptr) & (func),          \
       (::__interception::uptr) & WRAP(func))
 
-// Android and Solaris do not have dlvsym
-#if !SANITIZER_ANDROID && !SANITIZER_SOLARIS
+// dlvsym is a GNU extension supported by some other platforms.
+#if SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD
 #define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \
   ::__interception::InterceptFunction(                        \
       #func, symver,                                          \
       (::__interception::uptr *) & REAL(func),                \
       (::__interception::uptr) & (func),                      \
       (::__interception::uptr) & WRAP(func))
 #else
 #define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \
   INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)
-#endif  // !SANITIZER_ANDROID && !SANITIZER_SOLARIS
+#endif  // SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD
 
 #endif  // INTERCEPTION_LINUX_H
 #endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD ||
         // SANITIZER_SOLARIS

compiler-rt/lib/interception/interception_linux.cpp

 
 bool InterceptFunction(const char *name, uptr *ptr_to_real, uptr func,
                        uptr wrapper) {
   void *addr = GetFuncAddr(name, wrapper);
   *ptr_to_real = (uptr)addr;
   return addr && (func == wrapper);
 }
 
-// Android and Solaris do not have dlvsym
-#if !SANITIZER_ANDROID && !SANITIZER_SOLARIS
+// dlvsym is a GNU extension supported by some other platforms.
+#if SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD
 static void *GetFuncAddr(const char *name, const char *ver) {
   return dlvsym(RTLD_NEXT, name, ver);
 }
 
 bool InterceptFunction(const char *name, const char *ver, uptr *ptr_to_real,
                        uptr func, uptr wrapper) {
   void *addr = GetFuncAddr(name, ver);
   *ptr_to_real = (uptr)addr;
   return addr && (func == wrapper);
 }
-#endif  // !SANITIZER_ANDROID
+#endif  // SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD
 
 }  // namespace __interception
 
 #endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD ||
         // SANITIZER_SOLARIS

compiler-rt/lib/msan/tests/msan_test.cpp

 // <sys/shm.h> doesn't declare these functions in _KERNEL mode.
 void *shmat(int, const void *, int);
 int shmget(key_t, size_t, int);
 int shmctl(int, int, struct shmid_ds *);
 int shmdt(const void *);
 }
 #endif
 
+#if defined(__linux__) && !defined(__GLIBC__) && !defined(__ANDROID__)
+#define MUSL 1
+#endif
+
 #include <inttypes.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <wchar.h>
 #include <math.h>
 
 #include <arpa/inet.h>

 TEST(MemorySanitizer, gethostbyaddr) {
   in_addr_t addr = inet_addr("127.0.0.1");
   EXPECT_NOT_POISONED(addr);
   struct hostent *he = gethostbyaddr(&addr, sizeof(addr), AF_INET);
   ASSERT_NE((void *)NULL, he);
   EXPECT_HOSTENT_NOT_POISONED(he);
 }
 
-#if !defined(__NetBSD__)
+#if defined(__GLIBC__) || defined(__FreeBSD__)
 TEST(MemorySanitizer, gethostent_r) {
   sethostent(0);
   char buf[2000];
   struct hostent he;
   struct hostent *result;
   int err;
   int res = gethostent_r(&he, buf, sizeof(buf), &result, &err);
   ASSERT_EQ(0, res);
TEST(MemorySanitizer, shmat) {
 
   res = shmdt(q);
   ASSERT_EQ(0, res);
 
   res = shmctl(id, IPC_RMID, 0);
   ASSERT_GT(res, -1);
 }
 
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
+#ifdef __GLIBC__
 TEST(MemorySanitizer, random_r) {
   int32_t x;
   char z[64];
   memset(z, 0, sizeof(z));
 
   struct random_data buf;
   memset(&buf, 0, sizeof(buf));
 
TEST(MemorySanitizer, realpath_null) {
   const char* relpath = ".";
   char* res = realpath(relpath, NULL);
   printf("%d, %s\n", errno, strerror(errno));
   ASSERT_TRUE(res != NULL);
   EXPECT_NOT_POISONED(res[0]);
   free(res);
 }
 
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
+#ifdef __GLIBC__
 TEST(MemorySanitizer, canonicalize_file_name) {
   const char* relpath = ".";
   char* res = canonicalize_file_name(relpath);
   ASSERT_TRUE(res != NULL);
   EXPECT_NOT_POISONED(res[0]);
   free(res);
 }
 #endif
TEST(MemorySanitizer, func_name) {                             \
     EXPECT_NOT_POISONED((S8)e);                                  \
     freelocale(loc);                                             \
   }
 
 TEST_STRTO_INT(strtol, char, )
 TEST_STRTO_INT(strtoll, char, )
 TEST_STRTO_INT(strtoul, char, )
 TEST_STRTO_INT(strtoull, char, )
+#ifndef MUSL
 TEST_STRTO_INT(strtouq, char, )
+#endif
 
 TEST_STRTO_FLOAT(strtof, char, )
 TEST_STRTO_FLOAT(strtod, char, )
 TEST_STRTO_FLOAT(strtold, char, )
 
+#ifndef MUSL
 TEST_STRTO_FLOAT_LOC(strtof_l, char, )
 TEST_STRTO_FLOAT_LOC(strtod_l, char, )
 TEST_STRTO_FLOAT_LOC(strtold_l, char, )
 
 TEST_STRTO_INT_LOC(strtol_l, char, )
 TEST_STRTO_INT_LOC(strtoll_l, char, )
 TEST_STRTO_INT_LOC(strtoul_l, char, )
 TEST_STRTO_INT_LOC(strtoull_l, char, )
+#endif
 
 TEST_STRTO_INT(wcstol, wchar_t, L)
 TEST_STRTO_INT(wcstoll, wchar_t, L)
 TEST_STRTO_INT(wcstoul, wchar_t, L)
 TEST_STRTO_INT(wcstoull, wchar_t, L)
 
 TEST_STRTO_FLOAT(wcstof, wchar_t, L)
 TEST_STRTO_FLOAT(wcstod, wchar_t, L)
 TEST_STRTO_FLOAT(wcstold, wchar_t, L)
 
+#ifndef MUSL
 TEST_STRTO_FLOAT_LOC(wcstof_l, wchar_t, L)
 TEST_STRTO_FLOAT_LOC(wcstod_l, wchar_t, L)
 TEST_STRTO_FLOAT_LOC(wcstold_l, wchar_t, L)
 
 TEST_STRTO_INT_LOC(wcstol_l, wchar_t, L)
 TEST_STRTO_INT_LOC(wcstoll_l, wchar_t, L)
 TEST_STRTO_INT_LOC(wcstoul_l, wchar_t, L)
 TEST_STRTO_INT_LOC(wcstoull_l, wchar_t, L)
+#endif
 
 
 TEST(MemorySanitizer, strtoimax) {
   char *e;
   ASSERT_EQ(1, strtoimax("1", &e, 10));
   EXPECT_NOT_POISONED((S8) e);
 }
 

 TEST(MemorySanitizer, lgammal_r) {
   int sgn;
   long double res = lgammal_r(1.1, &sgn);
   ASSERT_NE(0.0, res);
   EXPECT_NOT_POISONED(sgn);
 }
 #endif
 
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
+#ifdef __GLIBC__
 TEST(MemorySanitizer, drand48_r) {
   struct drand48_data buf;
   srand48_r(0, &buf);
   double d;
   drand48_r(&buf, &d);
   EXPECT_NOT_POISONED(d);
 }
-#endif
 
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, lrand48_r) {
   struct drand48_data buf;
   srand48_r(0, &buf);
   long d;
   lrand48_r(&buf, &d);
   EXPECT_NOT_POISONED(d);
 }
 #endif
TEST(MemorySanitizer, getmntent) {
   ASSERT_NE(0U, strlen(mnt->mnt_type));
   ASSERT_NE(0U, strlen(mnt->mnt_opts));
   EXPECT_NOT_POISONED(mnt->mnt_freq);
   EXPECT_NOT_POISONED(mnt->mnt_passno);
   fclose(fp);
 }
 #endif
 
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
+#ifdef __GLIBC__
 TEST(MemorySanitizer, getmntent_r) {
   TempFstabFile fstabtmp;
   ASSERT_TRUE(fstabtmp.Create());
   FILE *fp = setmntent(fstabtmp.FileName(), "r");
 
   struct mntent mntbuf;
   char buf[1000];
   struct mntent *mnt = getmntent_r(fp, &mntbuf, buf, sizeof(buf));

 #if defined(__FreeBSD__)
   int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
 #elif defined(__NetBSD__)
   int mib[4] = { CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME};
 #endif
   int res = sysctl(mib, 4, buf, &sz, NULL, 0);
   ASSERT_EQ(0, res);
 }
-#elif defined(__GLIBC__)
+#elif defined(__GLIBC__) || defined(MUSL)
 static void GetProgramPath(char *buf, size_t sz) {
   extern char *program_invocation_name;
   int res = snprintf(buf, sz, "%s", program_invocation_name);
   ASSERT_GE(res, 0);
   ASSERT_LT((size_t)res, sz);
 }
 #else
 # error "TODO: port this"
TEST(MemorySanitizer, pthread_attr_get) {
   {
     void *v;
     size_t w;
     res = pthread_attr_getstack(&attr, &v, &w);
     ASSERT_EQ(0, res);
     EXPECT_NOT_POISONED(v);
     EXPECT_NOT_POISONED(w);
   }
-#if !defined(__NetBSD__)
+#ifdef __GLIBC__
   {
     cpu_set_t v;
     res = pthread_attr_getaffinity_np(&attr, sizeof(v), &v);
     ASSERT_EQ(0, res);
     EXPECT_NOT_POISONED(v);
   }
 #endif
   res = pthread_attr_destroy(&attr);

 
 TEST(MemorySanitizer, valloc) {
   void *a = valloc(100);
   uintptr_t PageSize = GetPageSize();
   EXPECT_EQ(0U, (uintptr_t)a % PageSize);
   free(a);
 }
 
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
+#ifdef __GLIBC__
 TEST(MemorySanitizer, pvalloc) {
   uintptr_t PageSize = GetPageSize();
   void *p = pvalloc(PageSize + 100);
   EXPECT_EQ(0U, (uintptr_t)p % PageSize);
   EXPECT_EQ(2 * PageSize, __sanitizer_get_allocated_size(p));
   free(p);
 
   p = pvalloc(0);  // pvalloc(0) should allocate at least one page.
TEST(MemorySanitizer, getpwent) {
   struct passwd *p = getpwent();
   ASSERT_TRUE(p != NULL);
   EXPECT_NOT_POISONED(p->pw_name);
   ASSERT_TRUE(p->pw_name != NULL);
   EXPECT_NOT_POISONED(p->pw_name[0]);
   EXPECT_NOT_POISONED(p->pw_uid);
 }
 
+#ifndef MUSL
 TEST(MemorySanitizer, getpwent_r) {
   struct passwd pwd;
   struct passwd *pwdres;
   char buf[10000];
   setpwent();
   int res = getpwent_r(&pwd, buf, sizeof(buf), &pwdres);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(pwd.pw_name);
   ASSERT_TRUE(pwd.pw_name != NULL);
   EXPECT_NOT_POISONED(pwd.pw_name[0]);
   EXPECT_NOT_POISONED(pwd.pw_uid);
   EXPECT_NOT_POISONED(pwdres);
 }
+#endif
 
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
+#ifdef __GLIBC__
 TEST(MemorySanitizer, fgetpwent) {
   FILE *fp = fopen("/etc/passwd", "r");
   struct passwd *p = fgetpwent(fp);
   ASSERT_TRUE(p != NULL);
   EXPECT_NOT_POISONED(p->pw_name);
   ASSERT_TRUE(p->pw_name != NULL);
   EXPECT_NOT_POISONED(p->pw_name[0]);
   EXPECT_NOT_POISONED(p->pw_uid);
   fclose(fp);
 }
 #endif
 
 TEST(MemorySanitizer, getgrent) {
   setgrent();
   struct group *p = getgrent();
   ASSERT_TRUE(p != NULL);
   EXPECT_NOT_POISONED(p->gr_name);
   ASSERT_TRUE(p->gr_name != NULL);
   EXPECT_NOT_POISONED(p->gr_name[0]);
   EXPECT_NOT_POISONED(p->gr_gid);
 }
 
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
+#ifdef __GLIBC__
 TEST(MemorySanitizer, fgetgrent) {
   FILE *fp = fopen("/etc/group", "r");
   struct group *grp = fgetgrent(fp);
   ASSERT_TRUE(grp != NULL);
   EXPECT_NOT_POISONED(grp->gr_name);
   ASSERT_TRUE(grp->gr_name != NULL);
   EXPECT_NOT_POISONED(grp->gr_name[0]);
   EXPECT_NOT_POISONED(grp->gr_gid);
   for (char **p = grp->gr_mem; *p; ++p) {
     EXPECT_NOT_POISONED((*p)[0]);
     EXPECT_TRUE(strlen(*p) > 0);
   }
   fclose(fp);
 }
 #endif
 
+#if defined(__GLIBC__) || defined(__FreeBSD__)
 TEST(MemorySanitizer, getgrent_r) {
   struct group grp;
   struct group *grpres;
   char buf[10000];
   setgrent();
   int res = getgrent_r(&grp, buf, sizeof(buf), &grpres);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(grp.gr_name);
   ASSERT_TRUE(grp.gr_name != NULL);
   EXPECT_NOT_POISONED(grp.gr_name[0]);
   EXPECT_NOT_POISONED(grp.gr_gid);
   EXPECT_NOT_POISONED(grpres);
 }
 
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, fgetgrent_r) {
   FILE *fp = fopen("/etc/group", "r");
   struct group grp;
   struct group *grpres;
   char buf[10000];
   setgrent();
   int res = fgetgrent_r(fp, &grp, buf, sizeof(buf), &grpres);
   ASSERT_EQ(0, res);

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

#if SANITIZER_LINUX
   _(SOUND_MIXER_WRITE_VOLUME, WRITE, sizeof(int));
   _(SOUND_PCM_READ_BITS, WRITE, sizeof(int));
   _(SOUND_PCM_READ_CHANNELS, WRITE, sizeof(int));
   _(SOUND_PCM_READ_FILTER, WRITE, sizeof(int));
   _(SOUND_PCM_READ_RATE, WRITE, sizeof(int));
   _(SOUND_PCM_WRITE_CHANNELS, WRITE, sizeof(int));
   _(SOUND_PCM_WRITE_FILTER, WRITE, sizeof(int));
   _(TCFLSH, NONE, 0);
+#if SANITIZER_GLIBC
   _(TCGETA, WRITE, struct_termio_sz);
+#endif
   _(TCGETS, WRITE, struct_termios_sz);
   _(TCSBRK, NONE, 0);
   _(TCSBRKP, NONE, 0);
+#if SANITIZER_GLIBC
   _(TCSETA, READ, struct_termio_sz);
   _(TCSETAF, READ, struct_termio_sz);
   _(TCSETAW, READ, struct_termio_sz);
+#endif
   _(TCSETS, READ, struct_termios_sz);
   _(TCSETSF, READ, struct_termios_sz);
   _(TCSETSW, READ, struct_termios_sz);
   _(TCXONC, NONE, 0);
   _(TIOCGLCKTRMIOS, WRITE, struct_termios_sz);
   _(TIOCGSOFTCAR, WRITE, sizeof(int));
   _(TIOCINQ, WRITE, sizeof(int));
   _(TIOCLINUX, READ, sizeof(char));
#endif
   _(VT_RELDISP, NONE, 0);
   _(VT_RESIZE, READ, struct_vt_sizes_sz);
   _(VT_RESIZEX, READ, struct_vt_consize_sz);
   _(VT_SENDSIG, NONE, 0);
   _(VT_SETMODE, READ, struct_vt_mode_sz);
   _(VT_WAITACTIVE, NONE, 0);
 #endif
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#if SANITIZER_GLIBC
   // _(SIOCDEVPLIP, WRITE, struct_ifreq_sz); // the same as EQL_ENSLAVE
   _(CYGETDEFTHRESH, WRITE, sizeof(int));
   _(CYGETDEFTIMEOUT, WRITE, sizeof(int));
   _(CYGETMON, WRITE, struct_cyclades_monitor_sz);
   _(CYGETTHRESH, WRITE, sizeof(int));
   _(CYGETTIMEOUT, WRITE, sizeof(int));
   _(CYSETDEFTHRESH, NONE, 0);
   _(CYSETDEFTIMEOUT, NONE, 0);

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

#ifdef _CS_GNU_LIBC_VERSION
   *minor = (*p == '.') ? internal_simple_strtoll(p + 1, &p, 10) : 0;
   *patch = (*p == '.') ? internal_simple_strtoll(p + 1, &p, 10) : 0;
   return true;
 #else
   return false;
 #endif
 }
 
-#if !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO && \
-    !SANITIZER_NETBSD && !SANITIZER_SOLARIS
+#if SANITIZER_GLIBC && !SANITIZER_GO
 static uptr g_tls_size;
 
 #ifdef __i386__
 #define CHECK_GET_TLS_STATIC_INFO_VERSION (!__GLIBC_PREREQ(2, 27))
 #else
 #define CHECK_GET_TLS_STATIC_INFO_VERSION 0
 #endif
 
else
     CallGetTls<GetTlsStaticInfoCall>(get_tls_static_info_ptr,
                                      &tls_size, &tls_align);
   if (tls_align < kStackAlign)
     tls_align = kStackAlign;
   g_tls_size = RoundUpTo(tls_size, tls_align);
 }
 #else
 void InitTlsSize() { }
-#endif
+#endif  // SANITIZER_GLIBC && !SANITIZER_GO
 
 #if (defined(__x86_64__) || defined(__i386__) || defined(__mips__) ||       \
      defined(__aarch64__) || defined(__powerpc64__) || defined(__s390__) || \
      defined(__arm__) || SANITIZER_RISCV64) &&                              \
     SANITIZER_LINUX && !SANITIZER_ANDROID
 // sizeof(struct pthread) from glibc.
 static atomic_uintptr_t thread_descriptor_size;
 

 
 #if !SANITIZER_GO
 uptr GetTlsSize() {
 #if SANITIZER_FREEBSD || SANITIZER_ANDROID || SANITIZER_NETBSD || \
     SANITIZER_SOLARIS
   uptr addr, size;
   GetTls(&addr, &size);
   return size;
-#elif defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64
+#elif SANITIZER_GLIBC
+#if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64
   return RoundUpTo(g_tls_size + TlsPreTcbSize(), 16);
 #else
   return g_tls_size;
 #endif
+#else
+  return 0;
+#endif
 }
 #endif
 
 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
                           uptr *tls_addr, uptr *tls_size) {
 #if SANITIZER_GO
   // Stub implementation for Go.
   *stk_addr = *stk_size = *tls_addr = *tls_size = 0;

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

 
 #if !defined(__linux__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \
   !defined(__APPLE__) && !defined(_WIN32) && \
   !defined(__Fuchsia__) && !defined(__rtems__) && \
   !(defined(__sun__) && defined(__svr4__))
 # error "This operating system is not supported"
 #endif
 
+// Get __GLIBC__ on a glibc platform. Exclude Android: features.h includes C
+// function declarations into a .S file which doesn't compile.
+// https://crbug.com/1162741
+#if __has_include(<features.h>) && !defined(__ANDROID__)
+#include <features.h>
+#endif
+
 #if defined(__linux__)
 # define SANITIZER_LINUX   1
 #else
 # define SANITIZER_LINUX   0
 #endif
 
+#if defined(__GLIBC__)
+# define SANITIZER_GLIBC   1
+#else
+# define SANITIZER_GLIBC   0
+#endif
+
 #if defined(__FreeBSD__)
 # define SANITIZER_FREEBSD 1
 #else
 # define SANITIZER_FREEBSD 0
 #endif
 
 #if defined(__NetBSD__)
 # define SANITIZER_NETBSD 1

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 #define SI_LINUX_NOT_ANDROID 1
 #else
 #define SI_LINUX_NOT_ANDROID 0
 #endif
 
+#if SANITIZER_GLIBC
+#define SI_GLIBC 1
+#else
+#define SI_GLIBC 0
+#endif
+
 #if SANITIZER_ANDROID
 #define SI_ANDROID 1
 #else
 #define SI_ANDROID 0
 #endif
 
 #if SANITIZER_FREEBSD
 #define SI_FREEBSD 1

 #define SANITIZER_INTERCEPT_MEMSET 1
 #define SANITIZER_INTERCEPT_MEMMOVE 1
 #define SANITIZER_INTERCEPT_MEMCPY 1
 #define SANITIZER_INTERCEPT_MEMCMP SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_BCMP \
   SANITIZER_INTERCEPT_MEMCMP &&  \
       ((SI_POSIX && _GNU_SOURCE) || SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_STRNDUP SI_POSIX
-#define SANITIZER_INTERCEPT___STRNDUP SI_LINUX_NOT_FREEBSD
+#define SANITIZER_INTERCEPT___STRNDUP SI_GLIBC
 #if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && \
     __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1070
 #define SI_MAC_DEPLOYMENT_BELOW_10_7 1
 #else
 #define SI_MAC_DEPLOYMENT_BELOW_10_7 0
 #endif
 // memmem on Darwin doesn't exist on 10.6
 // FIXME: enable memmem on Windows.
 #define SANITIZER_INTERCEPT_MEMMEM (SI_POSIX && !SI_MAC_DEPLOYMENT_BELOW_10_7)
 #define SANITIZER_INTERCEPT_MEMCHR SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_MEMRCHR (SI_FREEBSD || SI_LINUX || SI_NETBSD)
 
 #define SANITIZER_INTERCEPT_READ SI_POSIX
 #define SANITIZER_INTERCEPT_PREAD SI_POSIX
 #define SANITIZER_INTERCEPT_WRITE SI_POSIX
 #define SANITIZER_INTERCEPT_PWRITE SI_POSIX
 
 #define SANITIZER_INTERCEPT_FREAD SI_POSIX
 #define SANITIZER_INTERCEPT_FWRITE SI_POSIX
 #define SANITIZER_INTERCEPT_FGETS SI_POSIX
 #define SANITIZER_INTERCEPT_FPUTS SI_POSIX
 #define SANITIZER_INTERCEPT_PUTS SI_POSIX
 
-#define SANITIZER_INTERCEPT_PREAD64 SI_LINUX_NOT_ANDROID || SI_SOLARIS32
-#define SANITIZER_INTERCEPT_PWRITE64 SI_LINUX_NOT_ANDROID || SI_SOLARIS32
+#define SANITIZER_INTERCEPT_PREAD64 (SI_GLIBC || SI_SOLARIS32)
+#define SANITIZER_INTERCEPT_PWRITE64 (SI_GLIBC || SI_SOLARIS32)
 
 #define SANITIZER_INTERCEPT_READV SI_POSIX
 #define SANITIZER_INTERCEPT_WRITEV SI_POSIX
 
 #define SANITIZER_INTERCEPT_PREADV \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_PWRITEV SI_LINUX_NOT_ANDROID
-#define SANITIZER_INTERCEPT_PREADV64 SI_LINUX_NOT_ANDROID
-#define SANITIZER_INTERCEPT_PWRITEV64 SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PREADV64 SI_GLIBC
+#define SANITIZER_INTERCEPT_PWRITEV64 SI_GLIBC
 
 #define SANITIZER_INTERCEPT_PRCTL SI_LINUX
 
 #define SANITIZER_INTERCEPT_LOCALTIME_AND_FRIENDS SI_POSIX
 #define SANITIZER_INTERCEPT_STRPTIME SI_POSIX
 
 #define SANITIZER_INTERCEPT_SCANF SI_POSIX
-#define SANITIZER_INTERCEPT_ISOC99_SCANF SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_ISOC99_SCANF SI_GLIBC
 
 #ifndef SANITIZER_INTERCEPT_PRINTF
 #define SANITIZER_INTERCEPT_PRINTF SI_POSIX
 #define SANITIZER_INTERCEPT_PRINTF_L (SI_FREEBSD || SI_NETBSD)
-#define SANITIZER_INTERCEPT_ISOC99_PRINTF SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_ISOC99_PRINTF SI_GLIBC
 #endif
 
 #define SANITIZER_INTERCEPT___PRINTF_CHK \
-  (SANITIZER_INTERCEPT_PRINTF && SI_LINUX_NOT_ANDROID)
+  (SANITIZER_INTERCEPT_PRINTF && SI_GLIBC)
 
 #define SANITIZER_INTERCEPT_FREXP SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_FREXPF_FREXPL SI_POSIX
 
 #define SANITIZER_INTERCEPT_GETPWNAM_AND_FRIENDS SI_POSIX
 #define SANITIZER_INTERCEPT_GETPWNAM_R_AND_FRIENDS \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_GETPWENT \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
-#define SANITIZER_INTERCEPT_FGETGRENT_R \
-  (SI_FREEBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
+#define SANITIZER_INTERCEPT_FGETGRENT_R (SI_FREEBSD || SI_GLIBC || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_FGETPWENT SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_GETPWENT_R \
-  (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
-#define SANITIZER_INTERCEPT_FGETPWENT_R \
-  (SI_FREEBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
+  (SI_FREEBSD || SI_NETBSD || SI_GLIBC || SI_SOLARIS)
+#define SANITIZER_INTERCEPT_FGETPWENT_R (SI_FREEBSD || SI_GLIBC || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_SETPWENT \
   (SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_CLOCK_GETTIME \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_CLOCK_GETCPUCLOCKID SI_LINUX
 #define SANITIZER_INTERCEPT_GETITIMER SI_POSIX
 #define SANITIZER_INTERCEPT_TIME SI_POSIX
-#define SANITIZER_INTERCEPT_GLOB SI_LINUX_NOT_ANDROID || SI_SOLARIS
-#define SANITIZER_INTERCEPT_GLOB64 SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_GLOB (SI_GLIBC || SI_SOLARIS)
+#define SANITIZER_INTERCEPT_GLOB64 SI_GLIBC
 #define SANITIZER_INTERCEPT_WAIT SI_POSIX
 #define SANITIZER_INTERCEPT_INET SI_POSIX
 #define SANITIZER_INTERCEPT_PTHREAD_GETSCHEDPARAM SI_POSIX
 #define SANITIZER_INTERCEPT_GETADDRINFO SI_POSIX
 #define SANITIZER_INTERCEPT_GETNAMEINFO SI_POSIX
 #define SANITIZER_INTERCEPT_GETSOCKNAME SI_POSIX
 #define SANITIZER_INTERCEPT_GETHOSTBYNAME SI_POSIX
 #define SANITIZER_INTERCEPT_GETHOSTBYNAME2 SI_POSIX && !SI_SOLARIS
 #define SANITIZER_INTERCEPT_GETHOSTBYNAME_R \
   (SI_FREEBSD || SI_LINUX || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_GETHOSTBYNAME2_R \
   (SI_FREEBSD || SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_GETHOSTBYADDR_R \
   (SI_FREEBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
-#define SANITIZER_INTERCEPT_GETHOSTENT_R \
-  (SI_FREEBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
+#define SANITIZER_INTERCEPT_GETHOSTENT_R (SI_FREEBSD || SI_GLIBC || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_GETSOCKOPT SI_POSIX
 #define SANITIZER_INTERCEPT_ACCEPT SI_POSIX
 #define SANITIZER_INTERCEPT_ACCEPT4 (SI_LINUX_NOT_ANDROID || SI_NETBSD)
 #define SANITIZER_INTERCEPT_PACCEPT SI_NETBSD
 #define SANITIZER_INTERCEPT_MODF SI_POSIX
 #define SANITIZER_INTERCEPT_RECVMSG SI_POSIX
 #define SANITIZER_INTERCEPT_SENDMSG SI_POSIX
 #define SANITIZER_INTERCEPT_RECVMMSG SI_LINUX
 #define SANITIZER_INTERCEPT_SENDMMSG SI_LINUX
 #define SANITIZER_INTERCEPT_SYSMSG SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_GETPEERNAME SI_POSIX
 #define SANITIZER_INTERCEPT_IOCTL SI_POSIX
 #define SANITIZER_INTERCEPT_INET_ATON SI_POSIX
 #define SANITIZER_INTERCEPT_SYSINFO SI_LINUX
 #define SANITIZER_INTERCEPT_READDIR SI_POSIX
 #define SANITIZER_INTERCEPT_READDIR64 SI_LINUX_NOT_ANDROID || SI_SOLARIS32
 #if SI_LINUX_NOT_ANDROID &&                                                \
     (defined(__i386) || defined(__x86_64) || defined(__mips64) ||          \
      defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \
      defined(__s390__) || SANITIZER_RISCV64)

 #define SANITIZER_INTERCEPT_WCSNRTOMBS \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_WCRTOMB \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_WCTOMB \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_TCGETATTR SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_REALPATH SI_POSIX
-#define SANITIZER_INTERCEPT_CANONICALIZE_FILE_NAME \
-  (SI_LINUX_NOT_ANDROID || SI_SOLARIS)
+#define SANITIZER_INTERCEPT_CANONICALIZE_FILE_NAME (SI_GLIBC || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_CONFSTR \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_SCHED_GETAFFINITY SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_SCHED_GETPARAM SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_STRERROR SI_POSIX
 #define SANITIZER_INTERCEPT_STRERROR_R SI_POSIX
 #define SANITIZER_INTERCEPT_XPG_STRERROR_R SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_SCANDIR \

 #define SANITIZER_INTERCEPT_SIGTIMEDWAIT SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_SIGSETOPS \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_SIGSET_LOGICOPS SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_SIGPENDING SI_POSIX
 #define SANITIZER_INTERCEPT_SIGPROCMASK SI_POSIX
 #define SANITIZER_INTERCEPT_PTHREAD_SIGMASK SI_POSIX
 #define SANITIZER_INTERCEPT_BACKTRACE \
-  (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
+  (SI_FREEBSD || SI_NETBSD || SI_GLIBC || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_GETMNTENT SI_LINUX
 #define SANITIZER_INTERCEPT_GETMNTENT_R SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_STATFS \
   (SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_STATFS64 \
   (((SI_MAC && !TARGET_CPU_ARM64) && !SI_IOS) || SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_STATVFS \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_STATVFS64 SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_INITGROUPS SI_POSIX
 #define SANITIZER_INTERCEPT_ETHER_NTOA_ATON SI_POSIX
 #define SANITIZER_INTERCEPT_ETHER_HOST \
   (SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_ETHER_R (SI_FREEBSD || SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_SHMCTL                                       \
   (((SI_FREEBSD || SI_LINUX_NOT_ANDROID) && SANITIZER_WORDSIZE == 64) || \
    SI_NETBSD || SI_SOLARIS)  // NOLINT
-#define SANITIZER_INTERCEPT_RANDOM_R SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_RANDOM_R SI_GLIBC
 #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GET SI_POSIX
 #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETINHERITSCHED \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
-#define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETAFFINITY_NP SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETAFFINITY_NP SI_GLIBC
 #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GET_SCHED SI_POSIX
 #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPSHARED \
   (SI_POSIX && !SI_NETBSD)
 #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETTYPE SI_POSIX
 #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPROTOCOL \
   (SI_MAC || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPRIOCEILING \
   (SI_MAC || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETROBUST \
   (SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETROBUST_NP SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GETPSHARED \
   (SI_POSIX && !SI_NETBSD)
-#define SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GETKIND_NP SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GETKIND_NP SI_GLIBC
 #define SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GETPSHARED (SI_POSIX && !SI_NETBSD)
 #define SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GETCLOCK \
   (SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_PTHREAD_BARRIERATTR_GETPSHARED \
   (SI_LINUX_NOT_ANDROID && !SI_NETBSD)
 #define SANITIZER_INTERCEPT_THR_EXIT SI_FREEBSD
 #define SANITIZER_INTERCEPT_TMPNAM SI_POSIX
-#define SANITIZER_INTERCEPT_TMPNAM_R SI_LINUX_NOT_ANDROID || SI_SOLARIS
+#define SANITIZER_INTERCEPT_TMPNAM_R (SI_GLIBC || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_PTSNAME SI_LINUX
 #define SANITIZER_INTERCEPT_PTSNAME_R SI_LINUX
 #define SANITIZER_INTERCEPT_TTYNAME SI_POSIX
 #define SANITIZER_INTERCEPT_TTYNAME_R SI_POSIX
 #define SANITIZER_INTERCEPT_TEMPNAM SI_POSIX
 #define SANITIZER_INTERCEPT_SINCOS SI_LINUX || SI_SOLARIS
 #define SANITIZER_INTERCEPT_REMQUO SI_POSIX
 #define SANITIZER_INTERCEPT_REMQUOL (SI_POSIX && !SI_NETBSD)
 #define SANITIZER_INTERCEPT_LGAMMA SI_POSIX
 #define SANITIZER_INTERCEPT_LGAMMAL (SI_POSIX && !SI_NETBSD)
 #define SANITIZER_INTERCEPT_LGAMMA_R (SI_FREEBSD || SI_LINUX || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_LGAMMAL_R SI_LINUX_NOT_ANDROID || SI_SOLARIS
-#define SANITIZER_INTERCEPT_DRAND48_R SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_DRAND48_R SI_GLIBC
 #define SANITIZER_INTERCEPT_RAND_R \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_ICONV \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_TIMES SI_POSIX
 
 // FIXME: getline seems to be available on OSX 10.7
 #define SANITIZER_INTERCEPT_GETLINE \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 
 #define SANITIZER_INTERCEPT__EXIT \
   (SI_LINUX || SI_FREEBSD || SI_NETBSD || SI_MAC || SI_SOLARIS)
 
 #define SANITIZER_INTERCEPT_PTHREAD_MUTEX SI_POSIX
-#define SANITIZER_INTERCEPT___PTHREAD_MUTEX SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT___PTHREAD_MUTEX SI_GLIBC
 #define SANITIZER_INTERCEPT___LIBC_MUTEX SI_NETBSD
 #define SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP \
-  (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
+  (SI_FREEBSD || SI_NETBSD || SI_GLIBC || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_PTHREAD_GETNAME_NP \
-  (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
+  (SI_FREEBSD || SI_NETBSD || SI_GLIBC || SI_SOLARIS)
 
 #define SANITIZER_INTERCEPT_TLS_GET_ADDR \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 
 #define SANITIZER_INTERCEPT_LISTXATTR SI_LINUX
 #define SANITIZER_INTERCEPT_GETXATTR SI_LINUX
 #define SANITIZER_INTERCEPT_GETRESID SI_LINUX
 #define SANITIZER_INTERCEPT_GETIFADDRS \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_MAC || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_IF_INDEXTONAME \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_MAC || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_CAPGET SI_LINUX_NOT_ANDROID
 #if SI_LINUX && defined(__arm__)
 #define SANITIZER_INTERCEPT_AEABI_MEM 1
 #else
 #define SANITIZER_INTERCEPT_AEABI_MEM 0
 #endif
-#define SANITIZER_INTERCEPT___BZERO SI_MAC || SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT___BZERO SI_MAC || SI_GLIBC
 #define SANITIZER_INTERCEPT_BZERO SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_FTIME (!SI_FREEBSD && !SI_NETBSD && SI_POSIX)
-#define SANITIZER_INTERCEPT_XDR SI_LINUX_NOT_ANDROID || SI_SOLARIS
-#define SANITIZER_INTERCEPT_XDRREC SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_XDR (SI_GLIBC || SI_SOLARIS)
+#define SANITIZER_INTERCEPT_XDRREC SI_GLIBC
 #define SANITIZER_INTERCEPT_TSEARCH \
   (SI_LINUX_NOT_ANDROID || SI_MAC || SI_NETBSD || SI_SOLARIS)
-#define SANITIZER_INTERCEPT_LIBIO_INTERNALS SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_LIBIO_INTERNALS SI_GLIBC
 #define SANITIZER_INTERCEPT_FOPEN SI_POSIX
-#define SANITIZER_INTERCEPT_FOPEN64 SI_LINUX_NOT_ANDROID || SI_SOLARIS32
+#define SANITIZER_INTERCEPT_FOPEN64 (SI_GLIBC || SI_SOLARIS32)
 #define SANITIZER_INTERCEPT_OPEN_MEMSTREAM \
   (SI_LINUX_NOT_ANDROID || SI_NETBSD || SI_SOLARIS)
-#define SANITIZER_INTERCEPT_OBSTACK SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_OBSTACK SI_GLIBC
 #define SANITIZER_INTERCEPT_FFLUSH SI_POSIX
 #define SANITIZER_INTERCEPT_FCLOSE SI_POSIX
 
 #ifndef SANITIZER_INTERCEPT_DLOPEN_DLCLOSE
 #define SANITIZER_INTERCEPT_DLOPEN_DLCLOSE \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_MAC || SI_SOLARIS)
 #endif
 

 #define SANITIZER_INTERCEPT_UTMPX \
   (SI_LINUX_NOT_ANDROID || SI_MAC || SI_FREEBSD || SI_NETBSD)
 
 #define SANITIZER_INTERCEPT_GETLOADAVG \
   (SI_LINUX_NOT_ANDROID || SI_MAC || SI_FREEBSD || SI_NETBSD)
 
 #define SANITIZER_INTERCEPT_MMAP SI_POSIX
 #define SANITIZER_INTERCEPT_MMAP64 SI_LINUX_NOT_ANDROID
-#define SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO                             \
-  (!SI_FREEBSD && !SI_MAC && !SI_NETBSD && SI_NOT_FUCHSIA && SI_NOT_RTEMS && \
-   !SI_SOLARIS)  // NOLINT
+#define SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO (SI_GLIBC || SI_ANDROID)
 #define SANITIZER_INTERCEPT_MEMALIGN \
   (!SI_FREEBSD && !SI_MAC && !SI_NETBSD && SI_NOT_RTEMS)
-#define SANITIZER_INTERCEPT___LIBC_MEMALIGN                               \
-  (!SI_FREEBSD && !SI_MAC && !SI_NETBSD && !SI_OPENBSD && SI_NOT_RTEMS && \
-   !SI_ANDROID)  // NOLINT
-#define SANITIZER_INTERCEPT_PVALLOC                                          \
-  (!SI_FREEBSD && !SI_MAC && !SI_NETBSD && SI_NOT_FUCHSIA && SI_NOT_RTEMS && \
-   !SI_SOLARIS)  // NOLINT
-#define SANITIZER_INTERCEPT_CFREE                                            \
-  (!SI_FREEBSD && !SI_MAC && !SI_NETBSD && SI_NOT_FUCHSIA && SI_NOT_RTEMS && \
-   !SI_SOLARIS && !SANITIZER_ANDROID)  // NOLINT
+#define SANITIZER_INTERCEPT___LIBC_MEMALIGN SI_GLIBC
+#define SANITIZER_INTERCEPT_PVALLOC (SI_GLIBC || SI_ANDROID)
+#define SANITIZER_INTERCEPT_CFREE SI_GLIBC
 #define SANITIZER_INTERCEPT_REALLOCARRAY SI_POSIX
 #define SANITIZER_INTERCEPT_ALIGNED_ALLOC (!SI_MAC && SI_NOT_RTEMS)
 #define SANITIZER_INTERCEPT_MALLOC_USABLE_SIZE (!SI_MAC && !SI_NETBSD)
 #define SANITIZER_INTERCEPT_MCHECK_MPROBE SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_WCSCAT SI_POSIX
 #define SANITIZER_INTERCEPT_WCSDUP SI_POSIX
 #define SANITIZER_INTERCEPT_SIGNAL_AND_SIGACTION (!SI_WINDOWS && SI_NOT_FUCHSIA)
 #define SANITIZER_INTERCEPT_BSD_SIGNAL SI_ANDROID
#define SANITIZER_INTERCEPT_READLINKAT \
   (SI_POSIX && !SI_MAC_DEPLOYMENT_BELOW_10_10)
 
 #define SANITIZER_INTERCEPT_DEVNAME (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_DEVNAME_R (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_FGETLN (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_STRMODE (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_TTYENT SI_NETBSD
 #define SANITIZER_INTERCEPT_PROTOENT (SI_NETBSD || SI_LINUX)
-#define SANITIZER_INTERCEPT_PROTOENT_R (SI_LINUX_NOT_ANDROID)
+#define SANITIZER_INTERCEPT_PROTOENT_R SI_GLIBC
 #define SANITIZER_INTERCEPT_NETENT SI_NETBSD
 #define SANITIZER_INTERCEPT_SETVBUF \
   (SI_NETBSD || SI_FREEBSD || SI_LINUX || SI_MAC)
 #define SANITIZER_INTERCEPT_GETMNTINFO (SI_NETBSD || SI_FREEBSD || SI_MAC)
 #define SANITIZER_INTERCEPT_MI_VECTOR_HASH SI_NETBSD
 #define SANITIZER_INTERCEPT_GETVFSSTAT SI_NETBSD
 #define SANITIZER_INTERCEPT_REGEX (SI_NETBSD || SI_FREEBSD || SI_LINUX)
 #define SANITIZER_INTERCEPT_REGEXSUB SI_NETBSD

 #define SANITIZER_INTERCEPT_GETRANDOM \
   ((SI_LINUX && __GLIBC_PREREQ(2, 25)) || SI_FREEBSD)
 #define SANITIZER_INTERCEPT___CXA_ATEXIT SI_NETBSD
 #define SANITIZER_INTERCEPT_ATEXIT SI_NETBSD
 #define SANITIZER_INTERCEPT_PTHREAD_ATFORK SI_NETBSD
 #define SANITIZER_INTERCEPT_GETENTROPY SI_FREEBSD
 #define SANITIZER_INTERCEPT_QSORT \
   (SI_POSIX && !SI_IOSSIM && !SI_WATCHOS && !SI_TVOS && !SI_ANDROID)
-#define SANITIZER_INTERCEPT_QSORT_R (SI_LINUX && !SI_ANDROID)
+#define SANITIZER_INTERCEPT_QSORT_R SI_GLIBC
 // sigaltstack on i386 macOS cannot be intercepted due to setjmp()
 // calling it and assuming that it does not clobber registers.
 #define SANITIZER_INTERCEPT_SIGALTSTACK \
   (SI_POSIX && !(SANITIZER_MAC && SANITIZER_I386))
 #define SANITIZER_INTERCEPT_UNAME (SI_POSIX && !SI_FREEBSD)
 #define SANITIZER_INTERCEPT___XUNAME SI_FREEBSD
 
 #endif  // #ifndef SANITIZER_PLATFORM_INTERCEPTORS_H

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h

struct __sanitizer_msghdr {
   int msg_flags;
 };
 struct __sanitizer_cmsghdr {
   unsigned cmsg_len;
   int cmsg_level;
   int cmsg_type;
 };
 #else
+// In POSIX, int msg_iovlen; socklen_t msg_controllen; socklen_t cmsg_len; but
+// many implementations don't conform to the standard.
 struct __sanitizer_msghdr {
   void *msg_name;
   unsigned msg_namelen;
   struct __sanitizer_iovec *msg_iov;
   uptr msg_iovlen;
   void *msg_control;
   uptr msg_controllen;
   int msg_flags;

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

 //===-- sanitizer_platform_limits_posix.cpp -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of Sanitizer common code.
 //
 // Sizes and layouts of platform-specific POSIX data structures.
 //===----------------------------------------------------------------------===//
 
-#include "sanitizer_platform.h"
-
-#if SANITIZER_LINUX || SANITIZER_MAC
+#if defined(__linux__) || defined(__APPLE__)
 // Tests in this file assume that off_t-dependent data structures match the
 // libc ABI. For example, struct dirent here is what readdir() function (as
 // exported from libc) returns, and not the user-facing "dirent", which
 // depends on _FILE_OFFSET_BITS setting.
 // To get this "true" dirent definition, we undefine _FILE_OFFSET_BITS below.
-#ifdef _FILE_OFFSET_BITS
 #undef _FILE_OFFSET_BITS
 #endif
 
 // Must go after undef _FILE_OFFSET_BITS.
+#include "sanitizer_platform.h"
+
+#if SANITIZER_LINUX || SANITIZER_MAC
+// Must go after undef _FILE_OFFSET_BITS.
 #include "sanitizer_glibc_version.h"
 
 #include <arpa/inet.h>
 #include <dirent.h>
 #include <grp.h>
 #include <limits.h>
 #include <net/if.h>
 #include <netdb.h>
 #include <poll.h>
 #include <pthread.h>
 #include <pwd.h>
 #include <signal.h>
 #include <stddef.h>
+#include <stdio.h>
 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/times.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
 #include <termios.h>
 #include <time.h>
 #include <wchar.h>
 #include <regex.h>
 #if !SANITIZER_MAC
 #include <utmp.h>
 #endif
 
 #if !SANITIZER_IOS
 #include <net/route.h>
 #endif
 
 #if !SANITIZER_ANDROID
-#include <fstab.h>
 #include <sys/mount.h>
 #include <sys/timeb.h>
 #include <utmpx.h>
 #endif
 
 #if SANITIZER_LINUX
 #include <malloc.h>
 #include <mntent.h>

 #endif
 
 #if !SANITIZER_ANDROID
 #include <ifaddrs.h>
 #include <sys/ucontext.h>
 #include <wordexp.h>
 #endif
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
-#include <glob.h>
-#include <obstack.h>
-#include <mqueue.h>
+#if SANITIZER_LINUX
+#if SANITIZER_GLIBC
+#include <fstab.h>
 #include <net/if_ppp.h>
 #include <netax25/ax25.h>
 #include <netipx/ipx.h>
 #include <netrom/netrom.h>
+#include <obstack.h>
 #if HAVE_RPC_XDR_H
 # include <rpc/xdr.h>
 #endif
 #include <scsi/scsi.h>
-#include <sys/mtio.h>
+#else
+#include <linux/if_ppp.h>
+#include <linux/kd.h>
+#include <linux/ppp_defs.h>
+#endif  // SANITIZER_GLIBC
+
+#if SANITIZER_ANDROID
+#include <linux/mtio.h>
+#else
+#include <glob.h>
+#include <mqueue.h>
 #include <sys/kd.h>
+#include <sys/mtio.h>
 #include <sys/shm.h>
 #include <sys/statvfs.h>
 #include <sys/timex.h>
 #if defined(__mips64)
 # include <sys/procfs.h>
 #endif
 #include <sys/user.h>
 #include <linux/cyclades.h>
 #include <linux/if_eql.h>
 #include <linux/if_plip.h>
 #include <linux/lp.h>
 #include <linux/mroute.h>
 #include <linux/mroute6.h>
 #include <linux/scc.h>
 #include <linux/serial.h>
 #include <sys/msg.h>
 #include <sys/ipc.h>
 #include <crypt.h>
-#endif // SANITIZER_LINUX && !SANITIZER_ANDROID
+#endif  // SANITIZER_ANDROID
 
-#if SANITIZER_ANDROID
-#include <linux/kd.h>
-#include <linux/mtio.h>
-#include <linux/ppp_defs.h>
-#include <linux/if_ppp.h>
-#endif
-
-#if SANITIZER_LINUX
 #include <link.h>
 #include <sys/vfs.h>
 #include <sys/epoll.h>
 #include <linux/capability.h>
+#else
+#include <fstab.h>
 #endif // SANITIZER_LINUX
 
 #if SANITIZER_MAC
 #include <net/ethernet.h>
 #include <sys/filio.h>
 #include <sys/sockio.h>
 #endif
 
#endif // !SANITIZER_IOS && !(SANITIZER_MAC && TARGET_CPU_ARM64)
   unsigned struct_sched_param_sz = sizeof(struct sched_param);
   unsigned struct_regex_sz = sizeof(regex_t);
   unsigned struct_regmatch_sz = sizeof(regmatch_t);
 
 #if (SANITIZER_MAC && !TARGET_CPU_ARM64) && !SANITIZER_IOS
   unsigned struct_statfs64_sz = sizeof(struct statfs64);
 #endif // (SANITIZER_MAC && !TARGET_CPU_ARM64) && !SANITIZER_IOS
 
-#if !SANITIZER_ANDROID
+#if SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_MAC
   unsigned struct_fstab_sz = sizeof(struct fstab);
+#endif  // SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_MAC
+#if !SANITIZER_ANDROID
   unsigned struct_statfs_sz = sizeof(struct statfs);
   unsigned struct_sockaddr_sz = sizeof(struct sockaddr);
   unsigned ucontext_t_sz = sizeof(ucontext_t);
 #endif // !SANITIZER_ANDROID
 
 #if SANITIZER_LINUX
   unsigned struct_epoll_event_sz = sizeof(struct epoll_event);
   unsigned struct_sysinfo_sz = sizeof(struct sysinfo);
#endif
   }
 
 #if SANITIZER_LINUX
 unsigned struct_ElfW_Phdr_sz = sizeof(ElfW(Phdr));
 #elif SANITIZER_FREEBSD
 unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
 #endif
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#if SANITIZER_GLIBC
   int glob_nomatch = GLOB_NOMATCH;
   int glob_altdirfunc = GLOB_ALTDIRFUNC;
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID &&                               \
     (defined(__i386) || defined(__x86_64) || defined(__mips64) ||          \
      defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \
      defined(__s390__) || SANITIZER_RISCV64)
#if SANITIZER_LINUX
   unsigned struct_floppy_write_errors_sz = sizeof(struct floppy_write_errors);
   unsigned struct_format_descr_sz = sizeof(struct format_descr);
   unsigned struct_hd_driveid_sz = sizeof(struct hd_driveid);
   unsigned struct_hd_geometry_sz = sizeof(struct hd_geometry);
   unsigned struct_input_absinfo_sz = sizeof(struct input_absinfo);
   unsigned struct_input_id_sz = sizeof(struct input_id);
   unsigned struct_mtpos_sz = sizeof(struct mtpos);
   unsigned struct_rtentry_sz = sizeof(struct rtentry);
+#if SANITIZER_GLIBC || SANITIZER_ANDROID
   unsigned struct_termio_sz = sizeof(struct termio);
+#endif
   unsigned struct_vt_consize_sz = sizeof(struct vt_consize);
   unsigned struct_vt_sizes_sz = sizeof(struct vt_sizes);
   unsigned struct_vt_stat_sz = sizeof(struct vt_stat);
 #endif // SANITIZER_LINUX
 
 #if SANITIZER_LINUX
 #if SOUND_VERSION >= 0x040000
   unsigned struct_copr_buffer_sz = 0;
   unsigned struct_copr_debug_buf_sz = 0;
   unsigned struct_copr_msg_sz = 0;
 #else
   unsigned struct_copr_buffer_sz = sizeof(struct copr_buffer);
   unsigned struct_copr_debug_buf_sz = sizeof(struct copr_debug_buf);
   unsigned struct_copr_msg_sz = sizeof(struct copr_msg);
 #endif
   unsigned struct_midi_info_sz = sizeof(struct midi_info);
   unsigned struct_mtget_sz = sizeof(struct mtget);
   unsigned struct_mtop_sz = sizeof(struct mtop);
   unsigned struct_sbi_instrument_sz = sizeof(struct sbi_instrument);
   unsigned struct_seq_event_rec_sz = sizeof(struct seq_event_rec);
   unsigned struct_synth_info_sz = sizeof(struct synth_info);
   unsigned struct_vt_mode_sz = sizeof(struct vt_mode);
 #endif // SANITIZER_LINUX
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#if SANITIZER_GLIBC
   unsigned struct_ax25_parms_struct_sz = sizeof(struct ax25_parms_struct);
   unsigned struct_cyclades_monitor_sz = sizeof(struct cyclades_monitor);
 #if EV_VERSION > (0x010000)
   unsigned struct_input_keymap_entry_sz = sizeof(struct input_keymap_entry);
 #else
   unsigned struct_input_keymap_entry_sz = 0;
 #endif
   unsigned struct_ipx_config_data_sz = sizeof(struct ipx_config_data);
   unsigned struct_kbdiacrs_sz = sizeof(struct kbdiacrs);
   unsigned struct_kbentry_sz = sizeof(struct kbentry);
   unsigned struct_kbkeycode_sz = sizeof(struct kbkeycode);
   unsigned struct_kbsentry_sz = sizeof(struct kbsentry);
   unsigned struct_mtconfiginfo_sz = sizeof(struct mtconfiginfo);
   unsigned struct_nr_parms_struct_sz = sizeof(struct nr_parms_struct);
   unsigned struct_scc_modem_sz = sizeof(struct scc_modem);
   unsigned struct_scc_stat_sz = sizeof(struct scc_stat);
   unsigned struct_serial_multiport_struct_sz
       = sizeof(struct serial_multiport_struct);
   unsigned struct_serial_struct_sz = sizeof(struct serial_struct);
   unsigned struct_sockaddr_ax25_sz = sizeof(struct sockaddr_ax25);
   unsigned struct_unimapdesc_sz = sizeof(struct unimapdesc);
   unsigned struct_unimapinit_sz = sizeof(struct unimapinit);
-#endif // SANITIZER_LINUX && !SANITIZER_ANDROID
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
   unsigned struct_audio_buf_info_sz = sizeof(struct audio_buf_info);
   unsigned struct_ppp_stats_sz = sizeof(struct ppp_stats);
-#endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#endif  // SANITIZER_GLIBC
 
 #if !SANITIZER_ANDROID && !SANITIZER_MAC
   unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req);
   unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req);
 #endif
 
   const unsigned long __sanitizer_bufsiz = BUFSIZ;
 
#endif
   unsigned IOCTL_LPWAIT = LPWAIT;
   unsigned IOCTL_MTIOCGETCONFIG = MTIOCGETCONFIG;
   unsigned IOCTL_MTIOCSETCONFIG = MTIOCSETCONFIG;
   unsigned IOCTL_PIO_CMAP = PIO_CMAP;
   unsigned IOCTL_PIO_FONT = PIO_FONT;
   unsigned IOCTL_PIO_UNIMAP = PIO_UNIMAP;
   unsigned IOCTL_PIO_UNIMAPCLR = PIO_UNIMAPCLR;
   unsigned IOCTL_PIO_UNISCRNMAP = PIO_UNISCRNMAP;
+#if SANITIZER_GLIBC
   unsigned IOCTL_SCSI_IOCTL_GET_IDLUN = SCSI_IOCTL_GET_IDLUN;
   unsigned IOCTL_SCSI_IOCTL_PROBE_HOST = SCSI_IOCTL_PROBE_HOST;
   unsigned IOCTL_SCSI_IOCTL_TAGGED_DISABLE = SCSI_IOCTL_TAGGED_DISABLE;
   unsigned IOCTL_SCSI_IOCTL_TAGGED_ENABLE = SCSI_IOCTL_TAGGED_ENABLE;
   unsigned IOCTL_SIOCAIPXITFCRT = SIOCAIPXITFCRT;
   unsigned IOCTL_SIOCAIPXPRISLT = SIOCAIPXPRISLT;
   unsigned IOCTL_SIOCAX25ADDUID = SIOCAX25ADDUID;
   unsigned IOCTL_SIOCAX25DELUID = SIOCAX25DELUID;
   unsigned IOCTL_SIOCAX25GETPARMS = SIOCAX25GETPARMS;
   unsigned IOCTL_SIOCAX25GETUID = SIOCAX25GETUID;
   unsigned IOCTL_SIOCAX25NOUID = SIOCAX25NOUID;
   unsigned IOCTL_SIOCAX25SETPARMS = SIOCAX25SETPARMS;
   unsigned IOCTL_SIOCDEVPLIP = SIOCDEVPLIP;
   unsigned IOCTL_SIOCIPXCFGDATA = SIOCIPXCFGDATA;
   unsigned IOCTL_SIOCNRDECOBS = SIOCNRDECOBS;
   unsigned IOCTL_SIOCNRGETPARMS = SIOCNRGETPARMS;
   unsigned IOCTL_SIOCNRRTCTL = SIOCNRRTCTL;
   unsigned IOCTL_SIOCNRSETPARMS = SIOCNRSETPARMS;
+#endif
   unsigned IOCTL_TIOCGSERIAL = TIOCGSERIAL;
   unsigned IOCTL_TIOCSERGETMULTI = TIOCSERGETMULTI;
   unsigned IOCTL_TIOCSERSETMULTI = TIOCSERSETMULTI;
   unsigned IOCTL_TIOCSSERIAL = TIOCSSERIAL;
 #endif // SANITIZER_LINUX && !SANITIZER_ANDROID
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   unsigned IOCTL_GIO_SCRNMAP = GIO_SCRNMAP;

 // in.
 COMPILER_CHECK(sizeof(__sanitizer_dl_phdr_info) <= sizeof(dl_phdr_info));
 CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_addr);
 CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_name);
 CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phdr);
 CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phnum);
 #endif // SANITIZER_LINUX || SANITIZER_FREEBSD
 
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if SANITIZER_GLIBC || SANITIZER_FREEBSD
 CHECK_TYPE_SIZE(glob_t);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_pathc);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_pathv);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_offs);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_flags);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_closedir);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_readdir);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_opendir);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_lstat);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_stat);
-#endif
+#endif  // SANITIZER_GLIBC || SANITIZER_FREEBSD
 
 CHECK_TYPE_SIZE(addrinfo);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_flags);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_family);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_socktype);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_protocol);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_protocol);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_addrlen);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_canonname);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_addr);
 
 CHECK_TYPE_SIZE(hostent);
 CHECK_SIZE_AND_OFFSET(hostent, h_name);
 CHECK_SIZE_AND_OFFSET(hostent, h_aliases);
 CHECK_SIZE_AND_OFFSET(hostent, h_addrtype);
 CHECK_SIZE_AND_OFFSET(hostent, h_length);
 CHECK_SIZE_AND_OFFSET(hostent, h_addr_list);
 
 CHECK_TYPE_SIZE(iovec);
 CHECK_SIZE_AND_OFFSET(iovec, iov_base);
 CHECK_SIZE_AND_OFFSET(iovec, iov_len);
 
+// In POSIX, int msg_iovlen; socklen_t msg_controllen; socklen_t cmsg_len; but
+// many implementations don't conform to the standard. Since we pick the
+// non-conforming glibc definition, exclude the checks for musl (incompatible
+// sizes but compatible offsets).
 CHECK_TYPE_SIZE(msghdr);
 CHECK_SIZE_AND_OFFSET(msghdr, msg_name);
 CHECK_SIZE_AND_OFFSET(msghdr, msg_namelen);
 CHECK_SIZE_AND_OFFSET(msghdr, msg_iov);
+#if SANITIZER_GLIBC || SANITIZER_ANDROID
 CHECK_SIZE_AND_OFFSET(msghdr, msg_iovlen);
+#endif
 CHECK_SIZE_AND_OFFSET(msghdr, msg_control);
+#if SANITIZER_GLIBC || SANITIZER_ANDROID
 CHECK_SIZE_AND_OFFSET(msghdr, msg_controllen);
+#endif
 CHECK_SIZE_AND_OFFSET(msghdr, msg_flags);
 
 CHECK_TYPE_SIZE(cmsghdr);
+#if SANITIZER_GLIBC || SANITIZER_ANDROID
 CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_len);
+#endif
 CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_level);
 CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_type);
 
 #if SANITIZER_LINUX && (__ANDROID_API__ >= 21 || __GLIBC_PREREQ (2, 14))
 CHECK_TYPE_SIZE(mmsghdr);
 CHECK_SIZE_AND_OFFSET(mmsghdr, msg_hdr);
 CHECK_SIZE_AND_OFFSET(mmsghdr, msg_len);
 #endif

 CHECK_SIZE_AND_OFFSET(mntent, mnt_type);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_opts);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_freq);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_passno);
 #endif
 
 CHECK_TYPE_SIZE(ether_addr);
 
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if SANITIZER_GLIBC || SANITIZER_FREEBSD
 CHECK_TYPE_SIZE(ipc_perm);
 # if SANITIZER_FREEBSD
 CHECK_SIZE_AND_OFFSET(ipc_perm, key);
 CHECK_SIZE_AND_OFFSET(ipc_perm, seq);
 # else
 CHECK_SIZE_AND_OFFSET(ipc_perm, __key);
 CHECK_SIZE_AND_OFFSET(ipc_perm, __seq);
 # endif
COMPILER_CHECK(offsetof(__sanitizer_ifaddrs, ifa_dstaddr) ==
                offsetof(ifaddrs, ifa_ifu));
 # endif // SANITIZER_FREEBSD
 #else
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr);
 #endif // SANITIZER_LINUX
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_data);
 #endif
 
-#if SANITIZER_LINUX
+#if SANITIZER_GLIBC || SANITIZER_ANDROID
 COMPILER_CHECK(sizeof(__sanitizer_struct_mallinfo) == sizeof(struct mallinfo));
 #endif
 
 #if !SANITIZER_ANDROID
 CHECK_TYPE_SIZE(timeb);
 CHECK_SIZE_AND_OFFSET(timeb, time);
 CHECK_SIZE_AND_OFFSET(timeb, millitm);
 CHECK_SIZE_AND_OFFSET(timeb, timezone);

 CHECK_SIZE_AND_OFFSET(XDR, x_private);
 CHECK_SIZE_AND_OFFSET(XDR, x_base);
 CHECK_SIZE_AND_OFFSET(XDR, x_handy);
 COMPILER_CHECK(__sanitizer_XDR_ENCODE == XDR_ENCODE);
 COMPILER_CHECK(__sanitizer_XDR_DECODE == XDR_DECODE);
 COMPILER_CHECK(__sanitizer_XDR_FREE == XDR_FREE);
 #endif
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#if SANITIZER_GLIBC
 COMPILER_CHECK(sizeof(__sanitizer_FILE) <= sizeof(FILE));
 CHECK_SIZE_AND_OFFSET(FILE, _flags);
 CHECK_SIZE_AND_OFFSET(FILE, _IO_read_ptr);
 CHECK_SIZE_AND_OFFSET(FILE, _IO_read_end);
 CHECK_SIZE_AND_OFFSET(FILE, _IO_read_base);
 CHECK_SIZE_AND_OFFSET(FILE, _IO_write_ptr);
 CHECK_SIZE_AND_OFFSET(FILE, _IO_write_end);
 CHECK_SIZE_AND_OFFSET(FILE, _IO_write_base);
 CHECK_SIZE_AND_OFFSET(FILE, _IO_buf_base);
 CHECK_SIZE_AND_OFFSET(FILE, _IO_buf_end);
 CHECK_SIZE_AND_OFFSET(FILE, _IO_save_base);
 CHECK_SIZE_AND_OFFSET(FILE, _IO_backup_base);
 CHECK_SIZE_AND_OFFSET(FILE, _IO_save_end);
 CHECK_SIZE_AND_OFFSET(FILE, _markers);
 CHECK_SIZE_AND_OFFSET(FILE, _chain);
 CHECK_SIZE_AND_OFFSET(FILE, _fileno);
-#endif
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
 COMPILER_CHECK(sizeof(__sanitizer__obstack_chunk) <= sizeof(_obstack_chunk));
 CHECK_SIZE_AND_OFFSET(_obstack_chunk, limit);
 CHECK_SIZE_AND_OFFSET(_obstack_chunk, prev);
 CHECK_TYPE_SIZE(obstack);
 CHECK_SIZE_AND_OFFSET(obstack, chunk_size);
 CHECK_SIZE_AND_OFFSET(obstack, chunk);
 CHECK_SIZE_AND_OFFSET(obstack, object_base);
 CHECK_SIZE_AND_OFFSET(obstack, next_free);
 
 CHECK_TYPE_SIZE(cookie_io_functions_t);
 CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, read);
 CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, write);
 CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, seek);
 CHECK_SIZE_AND_OFFSET(cookie_io_functions_t, close);
-#endif
+#endif  // SANITIZER_GLIBC
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD
 CHECK_TYPE_SIZE(sem_t);
 #endif
 
 #if SANITIZER_LINUX && defined(__arm__)
 COMPILER_CHECK(ARM_VFPREGS_SIZE == ARM_VFPREGS_SIZE_ASAN);
 #endif
 
 #endif // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_MAC

compiler-rt/lib/sanitizer_common/sanitizer_procmaps_solaris.cpp

 //===-- sanitizer_procmaps_solaris.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Information about the process mappings (Solaris-specific parts).
 //===----------------------------------------------------------------------===//
 
+// Before Solaris 11.4, <procfs.h> doesn't work in a largefile environment.
+#undef _FILE_OFFSET_BITS
 #include "sanitizer_platform.h"
 #if SANITIZER_SOLARIS
 #include "sanitizer_common.h"
 #include "sanitizer_procmaps.h"
 
-// Before Solaris 11.4, <procfs.h> doesn't work in a largefile environment.
-#undef _FILE_OFFSET_BITS
 #include <procfs.h>
 #include <limits.h>
 
 namespace __sanitizer {
 
 void ReadProcMaps(ProcSelfMapsBuff *proc_maps) {
   if (!ReadFileToBuffer("/proc/self/xmap", &proc_maps->data,
                         &proc_maps->mmaped_size, &proc_maps->len)) {

compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

 
 #define stdout ((__sanitizer_FILE*)&__sF[1])
 #define stderr ((__sanitizer_FILE*)&__sF[2])
 
 #define nanosleep __nanosleep50
 #define vfork __vfork14
 #endif
 
-#if SANITIZER_ANDROID
-#define mallopt(a, b)
-#endif
-
 #ifdef __mips__
 const int kSigCount = 129;
 #else
 const int kSigCount = 65;
 #endif
 
 #ifdef __mips__
 struct ucontext_t {

 DECLARE_REAL_AND_INTERCEPTOR(void *, malloc, uptr size)
 DECLARE_REAL_AND_INTERCEPTOR(void, free, void *ptr)
 extern "C" void *pthread_self();
 extern "C" void _exit(int status);
 #if !SANITIZER_NETBSD
 extern "C" int fileno_unlocked(void *stream);
 extern "C" int dirfd(void *dirp);
 #endif
-#if !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_NETBSD
+#if SANITIZER_GLIBC
 extern "C" int mallopt(int param, int value);
 #endif
 #if SANITIZER_NETBSD
 extern __sanitizer_FILE __sF[];
 #else
 extern __sanitizer_FILE *stdout, *stderr;
 #endif
 #if !SANITIZER_FREEBSD && !SANITIZER_MAC && !SANITIZER_NETBSD

 void InitializeInterceptors() {
 #if !SANITIZER_MAC
   // We need to setup it early, because functions like dlsym() can call it.
   REAL(memset) = internal_memset;
   REAL(memcpy) = internal_memcpy;
 #endif
 
   // Instruct libc malloc to consume less memory.
-#if SANITIZER_LINUX
+#if SANITIZER_GLIBC
   mallopt(1, 0);  // M_MXFAST
   mallopt(-3, 32*1024);  // M_MMAP_THRESHOLD
 #endif
 
   new(interceptor_ctx()) InterceptorContext();
 
   InitializeCommonInterceptors();
   InitializeSignalInterceptors();

llvm/docs/ReleaseNotes.rst

 Changes to Sanitizers
 ---------------------
 
 The integer sanitizer `-fsanitize=integer` now has a new sanitizer:
 `-fsanitize=unsigned-shift-base`. It's not undefined behavior for an unsigned
 left shift to overflow (i.e. to shift bits out), but it has been the source of
 bugs and exploits in certain codebases in the past.
 
+Many Sanitizers (asan, cfi, lsan, msan, tsan, ubsan) have support for
+musl-based Linux distributions. Some of them may be rudimentary.
+
 External Open Source Projects Using LLVM 12
 ===========================================
 
 * A project...
 
 Additional Information
 ======================