[scudo][standalone] Introduce platform specific code & mutexes

[cryptoad]

Summary

This CL adds the platform specific code for Fuchsia, Linux & Android,
as well as some tests related to those (more tests to come later).
While some of it is pretty much a straight port of the existing scudo &
sanitizer_common code, the memory mapping functions have been reworked
a bit to fit the limited usage scenario that Scudo has for them.

For Fuchsia, I can now track the Vmar/Vmo pair for memory mappings if
there is an intent to grow or decommit some mapping (that will be
useful for the Primary).

[mcgrathr]

I only really looked at the Fuchsia code.

lib/scudo/standalone/common.h

141

Parens?

150

Is it really useful to have MAP_ERROR instead of just using nullptr here?
In the traditional mmap interface, MAP_FAILED is not 0 because it's sometimes possible to actually mmap address 0.
But that's not relevant here, so why not just stick the standard C++?

lib/scudo/standalone/fuchsia.cc

32

We mostly just use __builtin_trap() directly.

51

Use _zx_vmar_allocate, the new API. Parameters are in a different order, and flags are spelled ZX_VM_* rather than ZX_VM_FLAG_*.

67

You're only using VMARs you created yourself, so why use a syscall to get the bounds rather than keeping track locally?

177

Why doesn't this just call libc's getenv?

186

Use _zx_futex_wait. It just needs an extra ZX_HANDLE_INVALID parameter (second to last).

200

_zx

203

Where does the magic 256 constant come from?
If it's part of the getRandom API then it should be a macro or constexpr in the OS-independent headers.

212

There no need for locking around this.

lib/scudo/standalone/internal_defs.h

38

Why not just use C++ standard alignas?

128

Why not use <cstdint>?

[cryptoad]

Addressing some of Roland's review comments.

[cryptoad]

lib/scudo/standalone/common.h

150

Personal preference here. I thought that sanitizer_common was bad at mixing null & (void *)-1 for errors, and it did try to map 0 in some places.
So I went with all MAP_FAILED type error for map functions.
Though I am not opposed to all nullptr.

lib/scudo/standalone/fuchsia.cc

67

It was mostly for storage reasons.
The vmar+vmo fits in a u64 which works well. Keeping the base & size would require 2 extra uptr, which to be fair is not the end of the world.
The extra 16 bytes would be for every secondary backed allocation & for every region of the primary.
I am open to doing either.

177

I went the way it was done in sanitizer_common.
Part of the reason being that on some platform (Android), getenv would not work when called either too early or from the init process for example.
If this is not case for Fuchsia, happy to switch.

203

256 is a magic Linux related constant.
getrandom doesn't get interrupted for sizes < 256.
And when reading /dev/urandom, reads of up to 256 bytes will return as many bytes as are requested and will not be interrupted by a signal handler.
Since we don't use large random streams of bytes, I enforced 256.
I will put that in the common header.

lib/scudo/standalone/internal_defs.h

128

Right, it's mostly a sanitizer_common artifact, I haven't revisited it.
cstdint might not work with -nostdinc++ but stdint.h might.

[cryptoad]

clang-format the changes.

[mcgrathr]

lib/scudo/standalone/common.h

150

I'd prefer we completely avoid casting bogons to pointer types if we can.

lib/scudo/standalone/fuchsia.cc

67

Give it some comments about the trade-offs of storage cost vs syscall cost and we can optimize later.

177

There should be no problem on Fuchsia and if something crops up we can figure it out.

203

OK, then I think a static_assert(NewConstantForMaxSize <= ZX_CPRNG_DRAW_MAX_LEN) is what we want here.

lib/scudo/standalone/internal_defs.h

128

<stdint.h> is already used here, so just use that.

[cryptoad]

Address additional comments by Roland:

• map() now returns nullptr on error;
• New constant for max random length & associated static_assert;
• use getenv() on Fuchsia;
• Comments on storage vs syscall for vmar ranges;
• remove integer constants, replaced by stdint.h

[cryptoad]

Correct comment typo.

[dmmoore415]

lib/scudo/standalone/fuchsia.cc

63

sp: alternive

132

Shouldn't you at least check and log a bad status here?

150

while there's not much we can do if these things fail, maybe we should at least log them so that leaks can be discovered. There are several other cases like this. Is it Fuchsia style to ignore failures on things like this?

[cryptoad]

Correcting spelling mistake in comment.

[cryptoad]

lib/scudo/standalone/fuchsia.cc

132

I am going to have to defer to people who know more about the internals than I do: in which situations can closing a handle (or destroying a vmar) fail? Is it recoverable? Most of the code I see in musl for example doesn't check for that.

[mcgrathr]

lib/scudo/standalone/fuchsia.cc

132

They should never fail. If they do it's probably a bug somewhere so having a panic wouldn't hurt. I think the only expected error cases for those are for a bad handle, which would indicate a bug in this code or some catastrophic clobberation.

[cryptoad]

CHECK'ing the success (ZX_OK) of close & destroy operations.

[cryptoad]

Rebasing.

[morehouse]

lib/scudo/standalone/common.h

90

What is this used for?

123

If we will always get the page size through this function call (and not the global variable), this could be simplified to:

static PageSizeCached = getPageSizeSlow();
return PageSizeCached;

172

What's this here for?

lib/scudo/standalone/linux.cc

50

Since we will be mapping PROT_NONE in the scenario, I believe MAP_NORESERVE is unnecessary. I.e., the OS won't reserve swap space anyway since the memory cannot be accessed.

54

Does Scudo actually do MAP_FIXED? If so, why?

59

Considering we just did a system call, this path optimization doesn't provide any substantial benefit.

72

Another unnecessary path optimization.

78

Should we check errno for EAGAIN here?

85

reinterpret_cast? Here and below

104

Should this be cached, as it is in sanitizer_common?

119

static_cast? Same for below.

lib/scudo/standalone/linux.h

56

Why is this 8 when sanitizer_common uses 6?

lib/scudo/standalone/mutex.h

40

With a u8, we might wraparound and do 10 more "quick yields" on a long lock. Should we bump this up to u32 to reduce chance of this happening?

58

Are these constructors ever used? If not, maybe just use SpinMutex(const SpinMutex &) = delete.

101

Maybe make these deleted too.

[cryptoad]

Thanks Matt! Textual answers only for now, code changes will follow.

lib/scudo/standalone/common.h

90

shuffle will be used for randomizing arrays in the Primary & Quarantine.
Both haven't been checked in yet but will be in a few check-ins (once all the "common" files make it in).
A similar function can be found in sanitizer_common, use will be very similar if not identical.

123

AFAIR those constructs end up in an initialization function being created and run with the global ctors which I am generally trying to avoid.
I will give it a try.

172

It's a common function used by the Primary & Secondary (not checked in yet).
It probably could find a home somewhere else, I am going to remove it for now.

lib/scudo/standalone/linux.cc

50

I will revisit that.

54

We MAP_FIXED inside memory that was reserved with PROT_NONE.
The two usage scenario are:

• mapping on demand in the Primary, basically extending regions;
• mapping secondary allocations with guard pages on either side;

59

I will change that.

72

I will change that.

78

Good point, I didn't think of it. It is indeed probably useful to retry in that scenario rather than wait for another opportunity.

85

I will change that.

104

In the current state of things it's only called once for the initialization of the Shared TSD registry.
I figured caching was not needed (I don't think sanitizer_common use it more than once either).

119

I will change that.

lib/scudo/standalone/linux.h

56

It changed somewhat recently (https://android-review.googlesource.com/c/platform/bionic/+/847554).
Right now I am testing on platforms that still have 8, but it will have to be change to 6 for Q.

lib/scudo/standalone/mutex.h

40

I will change that.

58

I will change that.

101

I will change that.

[mcgrathr]

lib/scudo/standalone/common.h

123

A static local ctor is different from a global ctor (and harder to notice from examining the object files).
Each is problematic in its own different way.
I think both should be completely ruled out for the scudo internals.
That's a hard requirement for Fuchsia anyway, and it seems like a good thing to do universally.
Of course any kind of constexpr initialization (i.e. "linker-initialized") is OK.

[cryptoad]

Addressing various comments from Matt's review.

[morehouse]

lib/scudo/standalone/mutex.h

58

I think operator= needs to be deleted as well to avoid copies. Below as well.

lib/scudo/standalone/tests/map_test.cc

52

This boilerplate would be a good candidate to put in a test setup class.

65

Maybe we should combine these with the above tests since they will only cost ~1 line each then.

[vitalybuka]

also this patch includes to many unrelated changes

lib/scudo/standalone/internal_defs.h

126

Why not to use static_assert directly
Same for INLINE

lib/scudo/standalone/linux.cc

42

sysconf can be intercepted, e.g. in Google internal code

107

I assume this comment is for "#if defined"
could you move it there?

119

do you need static_cast here?

lib/scudo/standalone/linux.h

56

please run clang-format

lib/scudo/standalone/mutex.h

46

this if does not look atomic
atomic_compare_exchange?

[cryptoad]

Currently OOO so addressing mostly the easy to deal with comments.

lib/scudo/standalone/internal_defs.h

126

Personal preference here: I like the consistency.
For inline, it's so that the function attributes all are cased identically.
For the static assert, it's more because of habit with the current sanitizer code (since it used a macro). The macro isn't great with Werror due to unused typedefs, but static_assert is supported widely enough.
I am not opposed to changing to changing static_assert everywhere, but I would like to keep INLINE for consistency.
Let me know.

lib/scudo/standalone/linux.cc

42

Will that code not work if the code is intercepted? Current sanitizer code returns EXEC_PAGESIZE for Linux, should I just use that? If so it feel like it could go in the headers instead and that would optimize a bunch of code.

107

Well, my comment was more about the UNUSED attribute for Blocking in the function prototype, hence the position here.
Technically it only matters for the #if defined block indeed. Let me know what you think makes more sense.

119

Yes, the ssize_t is signed and the compiler complains about signed vs unsigned comparison otherwise.

lib/scudo/standalone/linux.h

56

It is currently clang-format'd but with -style=llvm which doesn't enforce the 2 space prior to comment if that's the thing you are referring to.

lib/scudo/standalone/mutex.h

46

Good point. So this is current how it's done in sanitizer_common and I didn't put additional thought into it.
Maybe the atomicity was too costly given that the state would eventually settle to something consistent?
cc: @kcc @dvyukov

lib/scudo/standalone/tests/map_test.cc

65

I'll do that. I initially went for full separation of Death Tests but it's not worth it.

[cryptoad]

Deleting the operator= for the mutex & lock classes.

[cryptoad]

Handle EAGAIN for madvice.
Reorganize the map tests to lower the code cost of death tests (~1 line).

[morehouse]

Linux-specific and common code LGTM. Will let Fuschia people comment on that part.

[vitalybuka]

LGTM

lib/scudo/standalone/internal_defs.h

126

I would prefer standard keyword when possible.
static_assert was probably not available at that time.
Not sure why they decided to use INLINE.

I don't have strong opinion on that. Feel free to keep either way.

lib/scudo/standalone/linux.cc

42

It depends.
You are likely going to use this in initialization, and interceptor may try to allocate memory using SCUDO. I guess it's fine to keep it as-is and resolve if we hit this problem.

107

either way is OK

lib/scudo/standalone/linux.h

56

Yep, spaces.
Then it's my mistake, please keep is as it's set by clang-format.

lib/scudo/standalone/mutex.h

46

If you are going to submit as-is maybe some TODO or other comment here?

[kcc]

lib/scudo/standalone/mutex.h

46

This is dvyukov's original code, but it looks just fine as is.
First load is a quick check: is the lock most likely unlocked now?
The second exchange is the actual atomic part.

[cryptoad]

Rebasing.

[brzycki]

Hello @cryptoad , I am seeing compiler build failures starting with the commit for this patch (sha 41aba567d991c2bd551c ).

There are actually two breaks I've seen. The first is a linker error when attempting to add i386 and x86_64 objects together on an Ubuntu 18.04 LTS host:

[1840/4478] : && /usr/bin/clang++-6.0 -fPIC -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -std=c++11 -Wall -Wextra -Wno-unused-parameter -Wwrite-string
s -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-con
version -fdiagnostics-color -ffunction-sections -fdata-sections -Wall -std=c++11 -Wno-unused-parameter -O3  -Wl,-z,defs -Wl,-z,nodelete -shared -Wl,-soname,libRTScudoStandalone.test.i386.so -o
 lib/libRTScudoStandalone.test.i386.so projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/common.cc.o projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoS
tandalone.i386.dir/fuchsia.cc.o projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/linux.cc.o   && :
FAILED: lib/libRTScudoStandalone.test.i386.so
: && /usr/bin/clang++-6.0 -fPIC -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -std=c++11 -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++11 -Wno-unused-parameter -O3  -Wl,-z,defs -Wl,-z,nodelete -shared -Wl,-soname,libRTScudoStandalone.test.i386.so -o lib/libRTScudoStandalone.test.i386.so projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/common.cc.o projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/fuchsia.cc.o projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/linux.cc.o   && :
/usr/bin/ld: i386 architecture of input file `projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/common.cc.o' is incompatible with i386:x86-64 output
/usr/bin/ld: i386 architecture of input file `projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/fuchsia.cc.o' is incompatible with i386:x86-64 output
/usr/bin/ld: i386 architecture of input file `projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/linux.cc.o' is incompatible with i386:x86-64 output
/usr/bin/ld: projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/common.cc.o: file class ELFCLASS32 incompatible with ELFCLASS64
/usr/bin/ld: final link failed: File in wrong format
clang: error: linker command failed with exit code 1 (use -v to see invocation)

which I suspect are partly caused by CMake detecting i386 and x86_64 support for Compiler-RT:

-- Looking for __i386__
-- Looking for __i386__ - found
-- Compiler-RT supported architectures: x86_64;i386
-- Performing Test COMPILER_RT_HAS_STD_C11_FLAG
-- Performing Test COMPILER_RT_HAS_STD_C11_FLAG - Success
-- Performing Test COMPILER_RT_HAS_VISIBILITY_HIDDEN_FLAG
-- Performing Test COMPILER_RT_HAS_VISIBILITY_HIDDEN_FLAG - Success
-- Performing Test COMPILER_RT_HAS_OMIT_FRAME_POINTER_FLAG
-- Performing Test COMPILER_RT_HAS_OMIT_FRAME_POINTER_FLAG - Success
-- Performing Test COMPILER_RT_HAS_FREESTANDING_FLAG
-- Performing Test COMPILER_RT_HAS_FREESTANDING_FLAG - Success
-- Performing Test COMPILER_RT_HAS_XRAY_COMPILER_FLAG
-- Performing Test COMPILER_RT_HAS_XRAY_COMPILER_FLAG - Success
-- Performing Test COMPILER_RT_HAS_ATOMIC_KEYWORD
-- Performing Test COMPILER_RT_HAS_ATOMIC_KEYWORD - Success
-- Builtin supported architectures: i386;x86_64

The second compiler failure is due to clock_gettime undefined on RHEL 6.7 hosts:

[2428/3976] : && /tools/build/gcc-8.2.0/bin/g++ -fPIC -fPIC -fvisibility-inlines-hidden -Werror=date-time -std=c++11 -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wc
ast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wno-comment
 -fdiagnostics-color -ffunction-sections -fdata-sections -Wall -std=c++11 -Wno-unused-parameter -O3  -Wl,-z,defs -Wl,-z,nodelete -shared -Wl,-soname,libRTScudoStandalone.test.x86_64.so -o lib/
libRTScudoStandalone.test.x86_64.so projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.x86_64.dir/common.cc.o projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoSt
andalone.x86_64.dir/fuchsia.cc.o projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.x86_64.dir/linux.cc.o   && :
FAILED: lib/libRTScudoStandalone.test.x86_64.so
: && /tools/build/gcc-8.2.0/bin/g++ -fPIC -fPIC -fvisibility-inlines-hidden -Werror=date-time -std=c++11 -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wno-comment -fdiagnostics-color -ffunction-sections -fdata-sections -Wall -std=c++11 -Wno-unused-parameter -O3  -Wl,-z,defs -Wl,-z,nodelete -shared -Wl,-soname,libRTScudoStandalone.test.x86_64.so -o lib/libRTScudoStandalone.test.x86_64.so projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.x86_64.dir/common.cc.o projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.x86_64.dir/fuchsia.cc.o projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.x86_64.dir/linux.cc.o   && :
projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.x86_64.dir/linux.cc.o: In function `scudo::getMonotonicTime()':
linux.cc:(.text._ZN5scudo16getMonotonicTimeEv+0xd): undefined reference to `clock_gettime'
collect2: error: ld returned 1 exit status

I suspect this is due to glibc being very old :

$ rpm -qa | grep ^glibc-2
glibc-2.12-1.166.el6_7.7.i686
glibc-2.12-1.166.el6_7.7.x86_64

The glibc maintainers moved clock_*() from librt to libc in version 2.17. This means some builds require -lrt for linking while others do not. And yes, this is ancient code but the folks at RedHat move at glacial speed when upgrading core packages in RHEL. They just barely moved to glibc 2.17 in RHEL 7.

I don't have patches for these yet but I wanted to inform you in case you may be aware of quick fixes/workarounds for these issues.

[cryptoad]

Ack, will look into it. I do not have the setups to repro those locally so it might take a little while.
Feel free to submit something if you come up with it quicker than I can.

[cryptoad]

I assume the rt issue can be fixed with:
append_list_if(COMPILER_RT_HAS_LIBRT -lrt LINK_FLAGS)
in the standalone tests CMakeLists.txt.
I am unclear as to what the solution is for the i386 vs x64 issue, as I also have both and running test for both without issue.

[brzycki]

@cryptoad the following (terribly hacky) patch successfully builds for me on Ubuntu 18.04 LTS:

diff --git a/compiler-rt/cmake/base-config-ix.cmake b/compiler-rt/cmake/base-config-ix.cmake
index ee9426b715d..8cc1e922f50 100644
--- a/compiler-rt/cmake/base-config-ix.cmake
+++ b/compiler-rt/cmake/base-config-ix.cmake
@@ -161,7 +161,7 @@ macro(test_targets)
           endif()
         else()
           test_target_arch(x86_64 "" "-m64")
-          test_target_arch(i386 __i386__ "-m32")
+          #test_target_arch(i386 __i386__ "-m32")
         endif()
       else()
         if (CMAKE_SIZEOF_VOID_P EQUAL 4)

I'm about to test it on RHEL 6.7 to see if the two are orthogonal or related (I suspect the former).

It's interesting you have no problems building i386. For reference here is my cmake configuration line:

cmake -G Ninja  -D CMAKE_C_COMPILER=/usr/bin/clang-6.0 -D CMAKE_CXX_COMPILER=/usr/bin/clang++-6.0 -D CMAKE_BUILD_TYPE=Debug -D CMAKE_INSTALL_PREFIX=/work/b.rzycki/upstream/install -D LLVM_TOOL_CLANG_BUILD=ON -D LIBCXX_INCLUDE_BENCHMARKS=ON -D BUILD_SHARED_LIBS=ON -D LLVM_ENABLE_ASSERTIONS=ON  -D LLVM_TARGETS_TO_BUILD=X86 /work/b.rzycki/upstream/llvm-project/llvm

[brzycki]

I'm about to test it on RHEL 6.7 to see if the two are orthogonal or related (I suspect the former).

As expected, it did not fix RHEL 6.7. I am now trying your append_list_if(COMPILER_RT_HAS_LIBRT -lrt LINK_FLAGS) suggestion.

[brzycki]

append_list_if(COMPILER_RT_HAS_LIBRT -lrt LINK_FLAGS) did not work, nor did list(APPEND LINK_FLAGS -lrt) for RHEL 6.7.

I noticed this code failure path is a spawned cmake instance within the Ninja build. It starts by trying to build libfuzzer support for libcxx:

[1225/3976] cd /tmp/tmp.DxqFrKPwdj/build/llvm/projects/compiler-rt/lib/fuzzer/libcxx_fuzzer_x86_64-bins && /tools/build/cmake-3.13.4/bin/cmake -DCMAKE_SHARED_LINKER_FLAGS=
-DCMAKE_MODULE_LINKER_FLAGS= -DCMAKE_EXE_LINKER_FLAGS= -DCMAKE_INSTALL_PREFIX=/tmp/bmr/4 -DCMAKE_MAKE_PROGRAM=/tools/build/ninja-1.9.0/ninja -DCMAKE_LINKER=/usr/bin/ld -DCM
AKE_AR=/usr/bin/ar -DCMAKE_RANLIB=/usr/bin/ranlib -DCMAKE_NM=/usr/bin/nm -DCMAKE_OBJCOPY=/usr/bin/objcopy -DCMAKE_OBJDUMP=/usr/bin/objdump -DCMAKE_STRIP=/usr/bin/strip -DCMAKE_C_COMPILER=/sarc
-c/compiler_tmp/tools/build/gcc-8.2.0/bin/gcc -DCMAKE_CXX_COMPILER=/tools/build/gcc-8.2.0/bin/g++ "-DCMAKE_C_FLAGS=-m64 " "-DCMAKE_CXX_FLAGS=-m64 " -DCMAKE_BUILD_TYPE=Relea
se -DLLVM_PATH=/tmp/tmp.DxqFrKPwdj/src/llvm -DLLVM_BINARY_DIR=/tmp/tmp.DxqFrKPwdj/build/llvm/projects/compiler-rt/lib/fuzzer/libcxx_fuzzer_x86_64 -DLLVM_LIBRARY_OUTPUT_INTDIR=/tmp/tmp.DxqFrKPw
dj/build/llvm/projects/compiler-rt/lib/fuzzer/libcxx_fuzzer_x86_64/lib -DCOMPILER_RT_LIBCXX_PATH=/tmp/tmp.DxqFrKPwdj/src/llvm/projects/libcxx -DCOMPILER_RT_LIBCXXABI_PATH=/tmp/tmp.DxqFrKPwdj/s
rc/llvm/projects/libcxxabi -DCMAKE_CXX_COMPILER_WORKS=ON -DLIBCXX_ABI_NAMESPACE=Fuzzer -GNinja /tmp/tmp.DxqFrKPwdj/src/llvm/projects/compiler-rt/cmake/Modules/CustomLibcxx && /sarc-c/compiler_
tmp/tools/build/cmake-3.13.4/bin/cmake -E touch /tmp/tmp.DxqFrKPwdj/build/llvm/projects/compiler-rt/lib/fuzzer/libcxx_fuzzer_x86_64-stamps//libcxx_fuzzer_x86_64-configure
Re-run cmake no build system arguments
-- The C compiler identification is GNU 8.2.0
-- The CXX compiler identification is GNU 8.2.0
...

I am creating symlinks at the start of the build:

cd "$BT_SRCD/llvm/tools"
ln -s ../../polly
ln -s ../../clang

cd "$BT_SRCD/llvm/projects"
ln -s "../../libcxx"
ln -s "../../libcxxabi"
ln -s "../../compiler-rt"

Are you possibly not building with libcxx and libcxxabi?

[cryptoad]

I managed to repro the issue:
/usr/bin/ld: projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/common.cc.o: file class ELFCLASS32 incompatible with ELFCLASS64
with your cmake parameters.
Trying to figure out what's up.

[cryptoad]

AFAICT, the compilation invocation that is failing should have a -m32 for it to succeed which is not there. The following succeeds (with the extra -m32):

.../llvm-build/gcc/bin/clang++ -fPIC -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -std=c++11 -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 -Wall -std=c++11 -Wno-unused-parameter -g  -Wl,-z,defs -Wl,-z,nodelete -shared -Wl,-soname,libRTScudoStandalone.test.i386.so -o lib/libRTScudoStandalone.test.i386.so projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/common.cc.o projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/fuchsia.cc.o projects/compiler-rt/lib/scudo/standalone/CMakeFiles/RTScudoStandalone.i386.dir/linux.cc.o  -m32

The -m32 seems to be added to the CMAKE_C_FLAGS variable but is not.
The different between my build that succeeds and this one boils down to -DCMAKE_C_COMPILER=$HOME/llvm-build/gcc/bin/clang vs CC=$HOME/llvm-build/gcc/bin/clang for me.
I am still not fully sure how to get around that.

[cryptoad]

I seemed to have fixed it locally:

add_library("RTScudoStandalone.test.${arch}" STATIC
  $<TARGET_OBJECTS:RTScudoStandalone.${arch}>)

The STATIC was missing. Let me know if that works for you.

[brzycki]

In D58184#1413905, @cryptoad wrote:

I seemed to have fixed it locally:

add_library("RTScudoStandalone.test.${arch}" STATIC
  $<TARGET_OBJECTS:RTScudoStandalone.${arch}>)

The STATIC was missing. Let me know if that works for you.

Yes, that worked for me as well on Ubuntu. Thank you! I was deep in the bowels of recursive CMake macros when I noticed your update. I will also try this on RHEL 6.7 to see if it fixes it for clock_gettime(). I know you don't have that environment so I'll have to figure that one out if it doesn't work.

[cryptoad]

In D58184#1413986, @brzycki wrote:

Yes, that worked for me as well on Ubuntu. Thank you! I was deep in the bowels of recursive CMake macros when I noticed your update. I will also try this on RHEL 6.7 to see if it fixes it for clock_gettime(). I know you don't have that environment so I'll have to figure that one out if it doesn't work.

Cool. Feel free to send it out if you want, or I'll do it when I am done with my current CL.
For the RHEL I thought linking against librt would do, but I don't have a way to debug it locally fast.

[brzycki]

In D58184#1414009, @cryptoad wrote:

Cool. Feel free to send it out if you want, or I'll do it when I am done with my current CL.
For the RHEL I thought linking against librt would do, but I don't have a way to debug it locally fast.

Good news: the patch fixes the RHEL 6.7 build issues as well.

If you could push the patch I'd appreciate it. I can't get to it today or tomorrow, the soonest would probably be Monday. If that's the case for you too I can do so Monday AM.

lib/scudo/standalone/CMakeLists.txt

 append_list_if(COMPILER_RT_HAS_NODEFAULTLIBS_FLAG -nodefaultlibs SCUDO_LINK_FLAGS)
 
 if(ANDROID)
 # Put the shared library in the global group. For more details, see
 # android-changes-for-ndk-developers.md#changes-to-library-search-order
   append_list_if(COMPILER_RT_HAS_Z_GLOBAL -Wl,-z,global SCUDO_LINK_FLAGS)
 endif()
 
-set(SCUDO_SOURCES empty.cc)
+set(SCUDO_SOURCES
+  common.cc
+  fuchsia.cc
+  linux.cc)
 
 set(SCUDO_HEADERS
   platform.h
   internal_defs.h
   atomic_helpers.h
-  list.h)
+  list.h
+  mutex.h
+  linux.h)
 
 if(COMPILER_RT_HAS_SCUDO_STANDALONE)
+  add_compiler_rt_object_libraries(RTScudoStandalone
+    ARCHS ${SCUDO_STANDALONE_SUPPORTED_ARCH}
+    SOURCES ${SCUDO_SOURCES}
+    ADDITIONAL_HEADERS ${SCUDO_HEADERS}
+    CFLAGS ${SCUDO_CFLAGS})
+
   add_compiler_rt_runtime(clang_rt.scudo_standalone
     STATIC
-    ARCHS ${SCUDO_SUPPORTED_ARCH}
+    ARCHS ${SCUDO_STANDALONE_SUPPORTED_ARCH}
     SOURCES ${SCUDO_SOURCES}
     ADDITIONAL_HEADERS ${SCUDO_HEADERS}
     CFLAGS ${SCUDO_CFLAGS}
     PARENT_TARGET scudo_standalone)
 
   if(COMPILER_RT_INCLUDE_TESTS)
     add_subdirectory(tests)
   endif()
 endif()

lib/scudo/standalone/atomic_helpers.h

 struct atomic_u32 {
   typedef u32 Type;
   volatile Type ValDoNotUse;
 };
 
 struct atomic_u64 {
   typedef u64 Type;
   // On 32-bit platforms u64 is not necessarily aligned on 8 bytes.
-  volatile ALIGNED(8) Type ValDoNotUse;
+  ALIGNED(8) volatile Type ValDoNotUse;
 };
 
 struct atomic_uptr {
   typedef uptr Type;
   volatile Type ValDoNotUse;
 };
 
 template <typename T>

lib/scudo/standalone/common.h

+//===-- common.h ------------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SCUDO_COMMON_H_
+#define SCUDO_COMMON_H_
+
+#include "internal_defs.h"
+
+#include <stddef.h>
+#include <string.h>
+
+namespace scudo {
+
+template <class Dest, class Source> INLINE Dest bit_cast(const Source &S) {
+  COMPILER_CHECK(sizeof(Dest) == sizeof(Source));
+  Dest D;
+  memcpy(&D, &S, sizeof(D));
+  return D;
+}
+
+INLINE constexpr uptr roundUpTo(uptr X, uptr Boundary) {
+  return (X + Boundary - 1) & ~(Boundary - 1);
+}
+
+INLINE constexpr uptr RoundDownTo(uptr X, uptr Boundary) {
+  return X & ~(Boundary - 1);
+}
+
+INLINE constexpr bool isAligned(uptr X, uptr Alignment) {
+  return (X & (Alignment - 1)) == 0;
+}
+
+template <class T> constexpr T Min(T A, T B) { return A < B ? A : B; }
+
+template <class T> constexpr T Max(T A, T B) { return A > B ? A : B; }
+
+template <class T> void Swap(T &A, T &B) {
+  T Tmp = A;
+  A = B;
+  B = Tmp;
+}
+
+INLINE bool isPowerOfTwo(uptr X) { return (X & (X - 1)) == 0; }
+
+INLINE uptr getMostSignificantSetBitIndex(uptr X) {
+  DCHECK_NE(X, 0U);
+  return SCUDO_WORDSIZE - 1U - static_cast<uptr>(__builtin_clzl(X));
+}
+
+INLINE uptr roundUpToPowerOfTwo(uptr Size) {
+  DCHECK(Size);
+  if (isPowerOfTwo(Size))
+    return Size;
+  const uptr Up = getMostSignificantSetBitIndex(Size);
+  DCHECK_LT(Size, (1UL << (Up + 1)));
+  DCHECK_GT(Size, (1UL << Up));
+  return 1UL << (Up + 1);
+}
+
+INLINE uptr getLeastSignificantSetBitIndex(uptr X) {
+  DCHECK_NE(X, 0U);
+  return static_cast<uptr>(__builtin_ctzll(X));
+}
+
+INLINE uptr getLog2(uptr X) {
+  DCHECK(isPowerOfTwo(X));
+  return getLeastSignificantSetBitIndex(X);
+}
+
+INLINE u32 getRandomU32(u32 *State) {
+  // ANSI C linear congruential PRNG (16-bit output).
+  // return (*State = *State * 1103515245 + 12345) >> 16;
+  // XorShift (32-bit output).
+  *State ^= *State << 13;
+  *State ^= *State >> 17;
+  *State ^= *State << 5;
+  return *State;
+}
+
+INLINE u32 getRandomModN(u32 *State, u32 N) {
+  return getRandomU32(State) % N; // [0, N)
+}
+
+template <typename T> INLINE void shuffle(T *A, u32 N, u32 *RandState) {
+  if (N <= 1)
+    return;
+  u32 State = *RandState;
+  for (u32 I = N - 1; I > 0; I--)
+    Swap(A[I], A[getRandomModN(&State, I + 1)]);
+  *RandState = State;
+}
+
+// Hardware specific inlinable functions.
+
+INLINE void yieldProcessor(u8 Count) {
+#if defined(__i386__) || defined(__x86_64__)
+  __asm__ __volatile__("" ::: "memory");
+  for (u8 I = 0; I < Count; I++)
+    __asm__ __volatile__("pause");
+#elif defined(__aarch64__) || defined(__arm__)
+  __asm__ __volatile__("" ::: "memory");
+  for (u8 I = 0; I < Count; I++)
+    __asm__ __volatile__("yield");
+#endif
+  __asm__ __volatile__("" ::: "memory");
+}
+
+// Platform specific functions.
+
+void yieldPlatform();
+
+extern uptr PageSizeCached;
+uptr getPageSizeSlow();
+INLINE uptr getPageSizeCached() {
+  if (LIKELY(PageSizeCached))
+    return PageSizeCached;
+  return getPageSizeSlow();
+}
+
+u32 getNumberOfCPUs();
+
+const char *getEnv(const char *Name);
+
+u64 getMonotonicTime();
+
+// Our randomness gathering function is limited to 256 bytes to ensure we get
+// as many bytes as requested, and avoid interruptions (on Linux).
+constexpr uptr MaxRandomLength = 256U;
+bool getRandom(void *Buffer, uptr Length, bool Blocking = false);
+
+// Platform memory mapping functions.
+
+#define MAP_ALLOWNOMEM (1U << 0)
+#define MAP_NOACCESS (1U << 1)
+#define MAP_RESIZABLE (1U << 2)
+
+// Our platform memory mapping use is restricted to 3 scenarios:
+// - reserve memory at a random address (MAP_NOACCESS);
+// - commit memory in a previously reserved space;
+// - commit memory at a random address.
+// As such, only a subset of parameters combinations is valid, which is checked
+// by the function implementation. The Extra parameter allows to pass opaque
+// platform specific data to the function.
+// Returns nullptr on error or dies if MAP_ALLOWNOMEM is not specified.
+void *map(void *Addr, uptr Size, const char *Name, uptr Flags = 0,
+          u64 *Extra = nullptr);
+
+// Indicates that we are getting rid of the whole mapping, which might have
+// further consequences on Extra, depending on the platform.
+#define UNMAP_ALL (1U << 0)
+
+void unmap(void *Addr, uptr Size, uptr Flags = 0, u64 *Extra = nullptr);
+
+void releasePagesToOS(uptr BaseAddress, uptr Offset, uptr Size,
+                      u64 *Extra = nullptr);
+
+// Internal map & unmap fatal error. This must not call map().
+void NORETURN dieOnMapUnmapError(bool OutOfMemory = false);
+
+// Logging related functions.
+
+void setAbortMessage(const char *Message);
+
+} // namespace scudo
+
+extern "C" typedef void (*IterateCb)(uintptr_t Base, size_t Size, void *Arg);
+
+#endif // SCUDO_COMMON_H_

lib/scudo/standalone/common.cc

+//===-- common.cc -----------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "common.h"
+#include "atomic_helpers.h"
+
+namespace scudo {
+
+uptr PageSizeCached;
+uptr getPageSize();
+
+uptr getPageSizeSlow() {
+  PageSizeCached = getPageSize();
+  CHECK_NE(PageSizeCached, 0);
+  return PageSizeCached;
+}
+
+// Fatal internal map() or unmap() error (potentially OOM related).
+void NORETURN dieOnMapUnmapError(bool OutOfMemory) {
+  outputRaw("Scudo ERROR: internal map or unmap failure");
+  if (OutOfMemory)
+    outputRaw(" (OOM)");
+  outputRaw("\n");
+  die();
+}
+
+} // namespace scudo

lib/scudo/standalone/empty.cc

-//===-- empty.cc ------------------------------------------------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "atomic_helpers.h"
-#include "list.h"

lib/scudo/standalone/fuchsia.cc

+//===-- fuchsia.cc ----------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "platform.h"
+
+#if SCUDO_FUCHSIA
+
+#include "common.h"
+#include "mutex.h"
+
+#include <limits.h> // for PAGE_SIZE
+#include <stdlib.h> // for abort()
+#include <zircon/process.h>
+#include <zircon/sanitizer.h>
+#include <zircon/syscalls.h>
+
+namespace scudo {
+
+void yieldPlatform() {
+  const zx_status_t Status = _zx_nanosleep(0);
+  CHECK_EQ(Status, ZX_OK);
+}
+
+uptr getPageSize() { return PAGE_SIZE; }
+
+void NORETURN die() { __builtin_trap(); }
+
+// We zero-initialize the Extra parameter of map(), make sure this is consistent
+// with ZX_HANDLE_INVALID.
+COMPILER_CHECK(ZX_HANDLE_INVALID == 0);
+
+struct MapInfo {
+  zx_handle_t Vmar;
+  zx_handle_t Vmo;
+};
+COMPILER_CHECK(sizeof(MapInfo) == sizeof(u64));
+
+static void *allocateVmar(uptr Size, MapInfo *Info, bool AllowNoMem) {
+  // Only scenario so far.
+  DCHECK(Info);
+  DCHECK_EQ(Info->Vmar, ZX_HANDLE_INVALID);
+
+  uintptr_t P;
+  const zx_status_t Status = _zx_vmar_allocate(
+      _zx_vmar_root_self(),
+      ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC, 0,
+      Size, &Info->Vmar, &P);
+  if (Status != ZX_OK) {
+    if (Status != ZX_ERR_NO_MEMORY || !AllowNoMem)
+      dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY);
+    return nullptr;
+  }
+  return reinterpret_cast<void *>(P);
+}
+
+// Returns the offset of an address range in a Vmar, while checking that said
+// range fully belongs to the Vmar. A alternive would be to keep track of both
+// the base & length to avoid calling this. The tradeoff being a system call vs
+// two extra uptr of storage.
+// TODO(kostyak): revisit the implications of both options.
+static uint64_t getOffsetInVmar(zx_handle_t Vmar, void *Addr, uintptr_t Size) {
+  zx_info_vmar_t Info;
+  const zx_status_t Status = _zx_object_get_info(
+      Vmar, ZX_INFO_VMAR, &Info, sizeof(Info), nullptr, nullptr);
+  CHECK_EQ(Status, ZX_OK);
+  const uint64_t Offset = reinterpret_cast<uintptr_t>(Addr) - Info.base;
+  CHECK_LE(Offset, Info.base + Info.len);
+  CHECK_LE(Offset + Size, Info.base + Info.len);
+  return Offset;
+}
+
+void *map(void *Addr, uptr Size, const char *Name, uptr Flags, u64 *Extra) {
+  DCHECK_EQ(Size % PAGE_SIZE, 0);
+  const bool AllowNoMem = !!(Flags & MAP_ALLOWNOMEM);
+  MapInfo *Info = reinterpret_cast<MapInfo *>(Extra);
+
+  // For MAP_NOACCESS, just allocate a Vmar and return.
+  if (Flags & MAP_NOACCESS)
+    return allocateVmar(Size, Info, AllowNoMem);
+
+  const zx_handle_t Vmar = Info ? Info->Vmar : _zx_vmar_root_self();
+  CHECK_NE(Vmar, ZX_HANDLE_INVALID);
+
+  zx_status_t Status;
+  zx_handle_t Vmo;
+  uint64_t VmoSize = 0;
+  if (Info && Info->Vmo != ZX_HANDLE_INVALID) {
+    // If a Vmo was specified, it's a resize operation.
+    CHECK(Addr);
+    DCHECK(Flags & MAP_RESIZABLE);
+    Vmo = Info->Vmo;
+    Status = _zx_vmo_get_size(Vmo, &VmoSize);
+    if (Status == ZX_OK)
+      Status = _zx_vmo_set_size(Vmo, VmoSize + Size);
+    if (Status != ZX_OK) {
+      if (Status != ZX_ERR_NO_MEMORY || !AllowNoMem)
+        dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY);
+      return nullptr;
+    }
+  } else {
+    // Otherwise, create a Vmo and set its name.
+    Status = _zx_vmo_create(Size, 0, &Vmo);
+    if (Status != ZX_OK) {
+      if (Status != ZX_ERR_NO_MEMORY || !AllowNoMem)
+        dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY);
+      return nullptr;
+    }
+    uptr N = 0;
+    while (Name[N])
+      N++;
+    _zx_object_set_property(Vmo, ZX_PROP_NAME, Name, N);
+  }
+
+  uintptr_t P;
+  zx_vm_option_t MapFlags = ZX_VM_PERM_READ | ZX_VM_PERM_WRITE;
+  const uint64_t Offset = Addr ? getOffsetInVmar(Vmar, Addr, Size) : 0;
+  if (Offset)
+    MapFlags |= ZX_VM_SPECIFIC;
+  Status = _zx_vmar_map(Vmar, MapFlags, Offset, Vmo, VmoSize, Size, &P);
+  // No need to track the Vmo if we don't intend on resizing it. Close it.
+  if (Flags & MAP_RESIZABLE) {
+    DCHECK(Info);
+    DCHECK_EQ(Info->Vmo, ZX_HANDLE_INVALID);
+    Info->Vmo = Vmo;
+  } else {
+    _zx_handle_close(Vmo);
+  }
+  if (Status != ZX_OK) {
+    if (Status != ZX_ERR_NO_MEMORY || !AllowNoMem)
+      dieOnMapUnmapError(Status == ZX_ERR_NO_MEMORY);
+    return nullptr;
+  }
+
+  return reinterpret_cast<void *>(P);
+}
+
+void unmap(void *Addr, uptr Size, uptr Flags, u64 *Extra) {
+  MapInfo *Info = reinterpret_cast<MapInfo *>(Extra);
+  if (Flags & UNMAP_ALL) {
+    DCHECK_NE(Info, nullptr);
+    const zx_handle_t Vmar = Info->Vmar;
+    DCHECK_NE(Vmar, _zx_vmar_root_self());
+    // Destroying the vmar effectively unmaps the whole mapping.
+    _zx_vmar_destroy(Vmar);
+    _zx_handle_close(Vmar);
+  } else {
+    const zx_handle_t Vmar = Info ? Info->Vmar : _zx_vmar_root_self();
+    const zx_status_t Status =
+        _zx_vmar_unmap(Vmar, reinterpret_cast<uintptr_t>(Addr), Size);
+    if (Status != ZX_OK)
+      dieOnMapUnmapError();
+  }
+  if (Info) {
+    if (Info->Vmo != ZX_HANDLE_INVALID)
+      _zx_handle_close(Info->Vmo);
+    Info->Vmo = ZX_HANDLE_INVALID;
+    Info->Vmar = ZX_HANDLE_INVALID;
+  }
+}
+
+void releasePagesToOS(uptr BaseAddress, uptr Offset, uptr Size, u64 *Extra) {
+  MapInfo *Info = reinterpret_cast<MapInfo *>(Extra);
+  DCHECK(Info);
+  DCHECK_NE(Info->Vmar, ZX_HANDLE_INVALID);
+  DCHECK_NE(Info->Vmo, ZX_HANDLE_INVALID);
+  const zx_status_t Status =
+      _zx_vmo_op_range(Info->Vmo, ZX_VMO_OP_DECOMMIT, Offset, Size, NULL, 0);
+  CHECK_EQ(Status, ZX_OK);
+}
+
+const char *getEnv(const char *Name) { return getenv(Name); }
+
+void BlockingMutex::wait() {
+  const zx_status_t Status =
+      _zx_futex_wait(reinterpret_cast<zx_futex_t *>(OpaqueStorage), MtxSleeping,
+                     ZX_HANDLE_INVALID, ZX_TIME_INFINITE);
+  if (Status != ZX_ERR_BAD_STATE)
+    CHECK_EQ(Status, ZX_OK); // Normal race
+}
+
+void BlockingMutex::wake() {
+  const zx_status_t Status =
+      _zx_futex_wake(reinterpret_cast<zx_futex_t *>(OpaqueStorage), 1);
+  CHECK_EQ(Status, ZX_OK);
+}
+
+u64 getMonotonicTime() { return _zx_clock_get(ZX_CLOCK_MONOTONIC); }
+
+u32 getNumberOfCPUs() { return _zx_system_get_num_cpus(); }
+
+bool getRandom(void *Buffer, uptr Length, bool Blocking) {
+  COMPILER_CHECK(MaxRandomLength <= ZX_CPRNG_DRAW_MAX_LEN);
+  if (!Buffer || !Length || Length > MaxRandomLength)
+    return false;
+  _zx_cprng_draw(Buffer, Length);
+  return true;
+}
+
+void outputRaw(const char *Buffer) {
+  uptr N = 0;
+  while (Buffer[N])
+    N++;
+  __sanitizer_log_write(Buffer, N);
+}
+
+void setAbortMessage(const char *Message) {}
+
+} // namespace scudo
+
+#endif // SCUDO_FUCHSIA

lib/scudo/standalone/internal_defs.h

 //===-- internal_defs.h -----------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_INTERNAL_DEFS_H_
 #define SCUDO_INTERNAL_DEFS_H_
 
 #include "platform.h"
 
+#include <stdint.h>
+
 #ifndef SCUDO_DEBUG
 #define SCUDO_DEBUG 0
 #endif
 
 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
 
 // String related macros.
 
 #define STRINGIFY_(S) #S
 #define STRINGIFY(S) STRINGIFY_(S)
 #define CONCATENATE_(S, C) S##C
 #define CONCATENATE(S, C) CONCATENATE_(S, C)
 
 // Attributes & builtins related macros.
 
 #define INTERFACE __attribute__((visibility("default")))
 #define WEAK __attribute__((weak))
 #define INLINE inline
 #define ALWAYS_INLINE inline __attribute__((always_inline))
 #define ALIAS(x) __attribute__((alias(x)))
+// Please only use the ALIGNED macro before the type. Using ALIGNED after the
+// variable declaration is not portable.
 #define ALIGNED(x) __attribute__((aligned(x)))
 #define FORMAT(f, a) __attribute__((format(printf, f, a)))
 #define NOINLINE __attribute__((noinline))
 #define NORETURN __attribute__((noreturn))
 #define THREADLOCAL __thread
 #define LIKELY(x) __builtin_expect(!!(x), 1)
 #define UNLIKELY(x) __builtin_expect(!!(x), 0)
 #if defined(__i386__) || defined(__x86_64__)
 // __builtin_prefetch(x) generates prefetchnt0 on x86

 typedef unsigned short u16;
 typedef unsigned int u32;
 typedef unsigned long long u64;
 typedef signed char s8;
 typedef signed short s16;
 typedef signed int s32;
 typedef signed long long s64;
 
-// Various integer constants.
-
-#undef __INT64_C
-#undef __UINT64_C
-#undef UINTPTR_MAX
-#if SCUDO_WORDSIZE == 64U
-#define __INT64_C(c) c##L
-#define __UINT64_C(c) c##UL
-#define UINTPTR_MAX (18446744073709551615UL)
-#else
-#define __INT64_C(c) c##LL
-#define __UINT64_C(c) c##ULL
-#define UINTPTR_MAX (4294967295U)
-#endif // SCUDO_WORDSIZE == 64U
-#undef INT32_MIN
-#define INT32_MIN (-2147483647 - 1)
-#undef INT32_MAX
-#define INT32_MAX (2147483647)
-#undef UINT32_MAX
-#define UINT32_MAX (4294967295U)
-#undef INT64_MIN
-#define INT64_MIN (-__INT64_C(9223372036854775807) - 1)
-#undef INT64_MAX
-#define INT64_MAX (__INT64_C(9223372036854775807))
-#undef UINT64_MAX
-#define UINT64_MAX (__UINT64_C(18446744073709551615))
+// The following two functions have platform specific implementations.
+void outputRaw(const char *Buffer);
+void NORETURN die();
 
-enum LinkerInitialized { LINKER_INITIALIZED = 0 };
+#define RAW_CHECK_MSG(Expr, Msg)                                               \
+  do {                                                                         \
+    if (UNLIKELY(!(Expr))) {                                                   \
+      outputRaw(Msg);                                                          \
+      die();                                                                   \
+    }                                                                          \
+  } while (false)
 
-// Various CHECK related macros.
+#define RAW_CHECK(Expr) RAW_CHECK_MSG(Expr, #Expr)
 
-#define COMPILER_CHECK(Pred) static_assert(Pred, "")
-
-// TODO(kostyak): implement at a later check-in.
+// TODO(kostyak): use reportCheckFailed when checked-in.
 #define CHECK_IMPL(c1, op, c2)                                                 \
   do {                                                                         \
+    u64 v1 = (u64)(c1);                                                        \
+    u64 v2 = (u64)(c2);                                                        \
+    if (UNLIKELY(!(v1 op v2))) {                                               \
+      outputRaw("CHECK failed: (" #c1 ") " #op " (" #c2 ")\n");                \
+      die();                                                                   \
+    }                                                                          \
   } while (false)
 
 #define CHECK(a) CHECK_IMPL((a), !=, 0)
 #define CHECK_EQ(a, b) CHECK_IMPL((a), ==, (b))
 #define CHECK_NE(a, b) CHECK_IMPL((a), !=, (b))
 #define CHECK_LT(a, b) CHECK_IMPL((a), <, (b))
 #define CHECK_LE(a, b) CHECK_IMPL((a), <=, (b))
 #define CHECK_GT(a, b) CHECK_IMPL((a), >, (b))

 #define DCHECK_EQ(a, b)
 #define DCHECK_NE(a, b)
 #define DCHECK_LT(a, b)
 #define DCHECK_LE(a, b)
 #define DCHECK_GT(a, b)
 #define DCHECK_GE(a, b)
 #endif
 
-// TODO(kostyak): implement at a later check-in.
+// The superfluous die() call effectively makes this macro NORETURN.
 #define UNREACHABLE(msg)                                                       \
   do {                                                                         \
-  } while (false)
+    CHECK(0 && msg);                                                           \
+    die();                                                                     \
+  } while (0)
+
+#define COMPILER_CHECK(Pred) static_assert(Pred, "")
+
+enum LinkerInitialized { LINKER_INITIALIZED = 0 };
 
 } // namespace scudo
 
 #endif // SCUDO_INTERNAL_DEFS_H_

lib/scudo/standalone/linux.h

+//===-- linux.h -------------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SCUDO_LINUX_H_
+#define SCUDO_LINUX_H_
+
+#include "platform.h"
+
+#if SCUDO_LINUX
+
+namespace scudo {
+
+#if SCUDO_ANDROID
+
+#if defined(__aarch64__)
+#define __get_tls()                                                            \
+  ({                                                                           \
+    void **__v;                                                                \
+    __asm__("mrs %0, tpidr_el0" : "=r"(__v));                                  \
+    __v;                                                                       \
+  })
+#elif defined(__arm__)
+#define __get_tls()                                                            \
+  ({                                                                           \
+    void **__v;                                                                \
+    __asm__("mrc p15, 0, %0, c13, c0, 3" : "=r"(__v));                         \
+    __v;                                                                       \
+  })
+#elif defined(__i386__)
+#define __get_tls()                                                            \
+  ({                                                                           \
+    void **__v;                                                                \
+    __asm__("movl %%gs:0, %0" : "=r"(__v));                                    \
+    __v;                                                                       \
+  })
+#elif defined(__x86_64__)
+#define __get_tls()                                                            \
+  ({                                                                           \
+    void **__v;                                                                \
+    __asm__("mov %%fs:0, %0" : "=r"(__v));                                     \
+    __v;                                                                       \
+  })
+#else
+#error "Unsupported architecture."
+#endif
+
+// The Android Bionic team has allocated a TLS slot for sanitizers starting
+// with Q, given that Android currently doesn't support ELF TLS. It is used to
+// store sanitizer thread specific data.
+static const int TLS_SLOT_SANITIZER = 8; // TODO(kostyak): 6 for Q!!
+
+ALWAYS_INLINE uptr *getAndroidTlsPtr() {
+  return reinterpret_cast<uptr *>(&__get_tls()[TLS_SLOT_SANITIZER]);
+}
+
+#endif // SCUDO_ANDROID
+
+} // namespace scudo
+
+#endif // SCUDO_LINUX
+
+#endif // SCUDO_LINUX_H_

lib/scudo/standalone/linux.cc

+//===-- linux.cc ------------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "platform.h"
+
+#if SCUDO_LINUX
+
+#include "common.h"
+#include "linux.h"
+#include "mutex.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/futex.h>
+#include <sched.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+
+#if SCUDO_ANDROID
+#include <sys/prctl.h>
+// Definitions of prctl arguments to set a vma name in Android kernels.
+#define ANDROID_PR_SET_VMA 0x53564d41
+#define ANDROID_PR_SET_VMA_ANON_NAME 0
+#endif
+
+namespace scudo {
+
+void yieldPlatform() { sched_yield(); }
+
+uptr getPageSize() { return static_cast<uptr>(sysconf(_SC_PAGESIZE)); }
+
+void NORETURN die() { abort(); }
+
+void *map(void *Addr, uptr Size, UNUSED const char *Name, uptr Flags,
+          UNUSED u64 *Extra) {
+  int MmapFlags = MAP_PRIVATE | MAP_ANON;
+  if (Flags & MAP_NOACCESS)
+    MmapFlags |= MAP_NORESERVE;
+  if (Addr) {
+    // Currently no scenario for a noaccess mapping with a fixed address.
+    DCHECK_EQ(Flags & MAP_NOACCESS, 0);
+    MmapFlags |= MAP_FIXED;
+  }
+  const int MmapProt =
+      (Flags & MAP_NOACCESS) ? PROT_NONE : PROT_READ | PROT_WRITE;
+  void *P = mmap(Addr, Size, MmapProt, MmapFlags, -1, 0);
+  if (UNLIKELY(P == MAP_FAILED)) {
+    if (!(Flags & MAP_ALLOWNOMEM) || errno != ENOMEM)
+      dieOnMapUnmapError(errno == ENOMEM);
+    return nullptr;
+  }
+#if SCUDO_ANDROID
+  if (!(Flags & MAP_NOACCESS))
+    prctl(ANDROID_PR_SET_VMA, ANDROID_PR_SET_VMA_ANON_NAME, P, Size, Name);
+#endif
+  return P;
+}
+
+void unmap(void *Addr, uptr Size, UNUSED uptr Flags, UNUSED u64 *Extra) {
+  if (UNLIKELY(munmap(Addr, Size) != 0))
+    dieOnMapUnmapError();
+}
+
+void releasePagesToOS(uptr BaseAddress, uptr Offset, uptr Size,
+                      UNUSED u64 *Extra) {
+  madvise(reinterpret_cast<void *>(BaseAddress + Offset), Size, MADV_DONTNEED);
+}
+
+// Calling getenv should be fine (c)(tm) at any time.
+const char *getEnv(const char *Name) { return getenv(Name); }
+
+void BlockingMutex::wait() {
+  syscall(SYS_futex, (uptr)OpaqueStorage, FUTEX_WAIT_PRIVATE, MtxSleeping,
+          nullptr, nullptr, 0);
+}
+
+void BlockingMutex::wake() {
+  syscall(SYS_futex, (uptr)OpaqueStorage, FUTEX_WAKE_PRIVATE, 1, nullptr,
+          nullptr, 0);
+}
+
+u64 getMonotonicTime() {
+  timespec TS;
+  clock_gettime(CLOCK_MONOTONIC, &TS);
+  return static_cast<u64>(TS.tv_sec) * (1000ULL * 1000 * 1000) +
+         static_cast<u64>(TS.tv_nsec);
+}
+
+u32 getNumberOfCPUs() {
+  cpu_set_t CPUs;
+  CHECK_EQ(sched_getaffinity(0, sizeof(cpu_set_t), &CPUs), 0);
+  return static_cast<u32>(CPU_COUNT(&CPUs));
+}
+
+// Blocking is possibly unused if the getrandom block is not compiled in.
+bool getRandom(void *Buffer, uptr Length, UNUSED bool Blocking) {
+  if (!Buffer || !Length || Length > MaxRandomLength)
+    return false;
+  ssize_t ReadBytes;
+#if defined(SYS_getrandom)
+#if !defined(GRND_NONBLOCK)
+#define GRND_NONBLOCK 1
+#endif
+  // Up to 256 bytes, getrandom will not be interrupted.
+  ReadBytes =
+      syscall(SYS_getrandom, Buffer, Length, Blocking ? 0 : GRND_NONBLOCK);
+  if (ReadBytes == (ssize_t)Length)
+    return true;
+#endif // defined(SYS_getrandom)
+  // Up to 256 bytes, a read off /dev/urandom will not be interrupted.
+  // Blocking is moot here, O_NONBLOCK has no effect when opening /dev/urandom.
+  const int FileDesc = open("/dev/urandom", O_RDONLY);
+  if (FileDesc == -1)
+    return false;
+  ReadBytes = read(FileDesc, Buffer, Length);
+  close(FileDesc);
+  return (ReadBytes == (ssize_t)Length);
+}
+
+void outputRaw(const char *Buffer) {
+  static StaticSpinMutex Mutex;
+  SpinMutexLock L(&Mutex);
+  uptr N = 0;
+  while (Buffer[N])
+    N++;
+  write(2, Buffer, N);
+}
+
+extern "C" WEAK void android_set_abort_message(const char *);
+
+void setAbortMessage(const char *Message) {
+  if (&android_set_abort_message)
+    android_set_abort_message(Message);
+}
+
+} // namespace scudo
+
+#endif // SCUDO_LINUX

lib/scudo/standalone/mutex.h

+//===-- mutex.h -------------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SCUDO_MUTEX_H_
+#define SCUDO_MUTEX_H_
+
+#include "atomic_helpers.h"
+#include "common.h"
+
+namespace scudo {
+
+class StaticSpinMutex {
+public:
+  void init() { atomic_store_relaxed(&State, 0); }
+
+  void lock() {
+    if (tryLock())
+      return;
+    lockSlow();
+  }
+
+  bool tryLock() {
+    return atomic_exchange(&State, 1, memory_order_acquire) == 0;
+  }
+
+  void unlock() { atomic_store(&State, 0, memory_order_release); }
+
+  void checkLocked() { CHECK_EQ(atomic_load_relaxed(&State), 1); }
+
+private:
+  atomic_u8 State;
+
+  void NOINLINE lockSlow() {
+    for (u8 I = 0;; I++) {
+      if (I < 10)
+        yieldProcessor(10);
+      else
+        yieldPlatform();
+      if (atomic_load_relaxed(&State) == 0 &&
+          atomic_exchange(&State, 1, memory_order_acquire) == 0)
+        return;
+    }
+  }
+};
+
+class SpinMutex : public StaticSpinMutex {
+public:
+  SpinMutex() { init(); }
+
+private:
+  SpinMutex(const SpinMutex &);
+  void operator=(const SpinMutex &);
+};
+
+enum MutexState { MtxUnlocked = 0, MtxLocked = 1, MtxSleeping = 2 };
+
+class BlockingMutex {
+public:
+  explicit constexpr BlockingMutex(LinkerInitialized) : OpaqueStorage{0} {}
+  BlockingMutex() { memset(this, 0, sizeof(*this)); }
+  void wait();
+  void wake();
+  void lock() {
+    atomic_u32 *M = reinterpret_cast<atomic_u32 *>(&OpaqueStorage);
+    if (atomic_exchange(M, MtxLocked, memory_order_acquire) == MtxUnlocked)
+      return;
+    while (atomic_exchange(M, MtxSleeping, memory_order_acquire) != MtxUnlocked)
+      wait();
+  }
+  void unlock() {
+    atomic_u32 *M = reinterpret_cast<atomic_u32 *>(&OpaqueStorage);
+    const u32 V = atomic_exchange(M, MtxUnlocked, memory_order_release);
+    DCHECK_NE(V, MtxUnlocked);
+    if (V == MtxSleeping)
+      wake();
+  }
+  void checkLocked() {
+    atomic_u32 *M = reinterpret_cast<atomic_u32 *>(&OpaqueStorage);
+    CHECK_NE(MtxUnlocked, atomic_load_relaxed(M));
+  }
+
+private:
+  uptr OpaqueStorage[1];
+};
+
+template <typename MutexType> class GenericScopedLock {
+public:
+  explicit GenericScopedLock(MutexType *M) : Mutex(M) { Mutex->lock(); }
+  ~GenericScopedLock() { Mutex->unlock(); }
+
+private:
+  MutexType *Mutex;
+
+  GenericScopedLock(const GenericScopedLock &);
+  void operator=(const GenericScopedLock &);
+};
+
+typedef GenericScopedLock<StaticSpinMutex> SpinMutexLock;
+typedef GenericScopedLock<BlockingMutex> BlockingMutexLock;
+
+} // namespace scudo
+
+#endif // SCUDO_MUTEX_H_

lib/scudo/standalone/tests/CMakeLists.txt

 # add_scudo_unittest(<name>
 #                   SOURCES <sources list>
 #                   HEADERS <extra headers list>)
 macro(add_scudo_unittest testname)
   cmake_parse_arguments(TEST "" "" "SOURCES;HEADERS" ${ARGN})
   if(COMPILER_RT_HAS_SCUDO_STANDALONE)
     foreach(arch ${SCUDO_TEST_ARCH})
       set(ScudoUnitTestsObjects)
+      add_library("RTScudoStandalone.test.${arch}"
+        $<TARGET_OBJECTS:RTScudoStandalone.${arch}>)
       generate_compiler_rt_tests(ScudoUnitTestsObjects ScudoUnitTests
         "${testname}-${arch}-Test" ${arch}
-        SOURCES ${TEST_SOURCES} ${COMPILER_RT_GTEST_SOURCE} 
+        SOURCES ${TEST_SOURCES} ${COMPILER_RT_GTEST_SOURCE}
         COMPILE_DEPS ${TEST_HEADERS}
         DEPS gtest scudo_standalone
+        RUNTIME RTScudoStandalone.test.${arch}
         CFLAGS ${SCUDO_UNITTEST_CFLAGS}
         LINK_FLAGS ${LINK_FLAGS})
     endforeach()
   endif()
 endmacro()
 
 set(SCUDO_UNIT_TEST_SOURCES
   atomic_test.cc
   list_test.cc
+  map_test.cc
+  mutex_test.cc
   scudo_unit_test_main.cc)
 
 add_scudo_unittest(ScudoUnitTest
   SOURCES ${SCUDO_UNIT_TEST_SOURCES})

lib/scudo/standalone/tests/atomic_test.cc

for (u64 I = 0; I < 100; I++) {
     Val.A.ValDoNotUse = (Type)-1;
     atomic_store(&Val.A, (Type)V, StoreMO);
     EXPECT_EQ(Val.A.ValDoNotUse, (Type)V);
   }
   EXPECT_EQ(Val.Magic0, (Type)-3);
   EXPECT_EQ(Val.Magic1, (Type)-3);
 }
 
-TEST(ScudoStandalone, AtomicStoreLoad) {
+TEST(ScudoAtomicTest, AtomicStoreLoad) {
   checkStoreLoad<atomic_u8, memory_order_relaxed, memory_order_relaxed>();
   checkStoreLoad<atomic_u8, memory_order_consume, memory_order_relaxed>();
   checkStoreLoad<atomic_u8, memory_order_acquire, memory_order_relaxed>();
   checkStoreLoad<atomic_u8, memory_order_relaxed, memory_order_release>();
   checkStoreLoad<atomic_u8, memory_order_seq_cst, memory_order_seq_cst>();
 
   checkStoreLoad<atomic_u16, memory_order_relaxed, memory_order_relaxed>();
   checkStoreLoad<atomic_u16, memory_order_consume, memory_order_relaxed>();
typedef typename T::Type Type;
     EXPECT_TRUE(atomic_compare_exchange_weak(reinterpret_cast<T *>(&V), &OldVal,
                                              NewVal, memory_order_relaxed));
     EXPECT_FALSE(atomic_compare_exchange_weak(
         reinterpret_cast<T *>(&V), &OldVal, NewVal, memory_order_relaxed));
     EXPECT_EQ(NewVal, OldVal);
   }
 }
 
-TEST(ScudoStandalone, AtomicCompareExchangeTest) {
+TEST(ScudoAtomicTest, AtomicCompareExchangeTest) {
   checkAtomicCompareExchange<atomic_u8>();
   checkAtomicCompareExchange<atomic_u16>();
   checkAtomicCompareExchange<atomic_u32>();
   checkAtomicCompareExchange<atomic_u64>();
   checkAtomicCompareExchange<atomic_uptr>();
 }
 
 } // namespace scudo

lib/scudo/standalone/tests/list_test.cc

static void checkList(List *L, ListItem *I1, ListItem *I2 = nullptr,
   }
   if (I6) {
     EXPECT_EQ(L->front(), I6);
     L->pop_front();
   }
   EXPECT_TRUE(L->empty());
 }
 
-TEST(ScudoSandalone, IntrusiveList) {
+TEST(ScudoListTest, IntrusiveList) {
   ListItem Items[6];
   EXPECT_EQ(StaticList.size(), 0U);
 
   List L;
   L.clear();
 
   ListItem *X = &Items[0];
   ListItem *Y = &Items[1];
TEST(ScudoListTest, IntrusiveList) {
 
   setList(&L1, X, Y);
   setList(&L2);
   L1.append_front(&L2);
   checkList(&L1, X, Y);
   EXPECT_TRUE(L2.empty());
 }
 
-TEST(ScudoStandalone, IntrusiveListAppendEmpty) {
+TEST(ScudoListTest, IntrusiveListAppendEmpty) {
   ListItem I;
   List L;
   L.clear();
   L.push_back(&I);
   List L2;
   L2.clear();
   L.append_back(&L2);
   EXPECT_EQ(L.back(), &I);
   EXPECT_EQ(L.front(), &I);
   EXPECT_EQ(L.size(), 1U);
   L.append_front(&L2);
   EXPECT_EQ(L.back(), &I);
   EXPECT_EQ(L.front(), &I);
   EXPECT_EQ(L.size(), 1U);
 }

lib/scudo/standalone/tests/map_test.cc

+//===-- map_test.cc----------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "common.h"
+
+#include "gtest/gtest.h"
+
+#include <string.h>
+
+const char *MappingName = "scudo:test";
+
+TEST(ScudoMapTest, MapNoAccessUnmap) {
+  const scudo::uptr Size = 4 * scudo::getPageSizeCached();
+  scudo::u64 PlatformData = 0;
+  void *P = scudo::map(nullptr, Size, MappingName, MAP_NOACCESS, &PlatformData);
+  EXPECT_NE(P, nullptr);
+  scudo::unmap(P, Size, UNMAP_ALL, &PlatformData);
+}
+
+TEST(ScudoMapTest, MapUnmap) {
+  const scudo::uptr Size = 4 * scudo::getPageSizeCached();
+  scudo::u64 PlatformData = 0;
+  void *P = scudo::map(nullptr, Size, MappingName, 0, &PlatformData);
+  EXPECT_NE(P, nullptr);
+  memset(P, 0xaa, Size);
+  scudo::unmap(P, Size, 0, &PlatformData);
+}
+
+TEST(ScudoMapTest, MapWithGuardUnmap) {
+  const scudo::uptr PageSize = scudo::getPageSizeCached();
+  const scudo::uptr Size = 4 * PageSize;
+  scudo::u64 PlatformData = 0;
+  void *P = scudo::map(nullptr, Size + 2 * PageSize, MappingName, MAP_NOACCESS,
+                       &PlatformData);
+  EXPECT_NE(P, nullptr);
+  void *Q =
+      reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(P) + PageSize);
+  EXPECT_EQ(scudo::map(Q, Size, MappingName, 0, &PlatformData), Q);
+  memset(Q, 0xaa, Size);
+  scudo::unmap(P, Size + 2 * PageSize, UNMAP_ALL, &PlatformData);
+}
+
+TEST(ScudoMapTest, MapGrowUnmap) {
+  const scudo::uptr PageSize = scudo::getPageSizeCached();
+  const scudo::uptr Size = 4 * PageSize;
+  scudo::u64 PlatformData = 0;
+  void *P = scudo::map(nullptr, Size, MappingName, MAP_NOACCESS, &PlatformData);
+  EXPECT_NE(P, nullptr);
+  void *Q =
+      reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(P) + PageSize);
+  EXPECT_EQ(scudo::map(Q, PageSize, MappingName, 0, &PlatformData), Q);
+  memset(Q, 0xaa, PageSize);
+  Q = reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(Q) + PageSize);
+  EXPECT_EQ(scudo::map(Q, PageSize, MappingName, 0, &PlatformData), Q);
+  memset(Q, 0xbb, PageSize);
+  scudo::unmap(P, Size, UNMAP_ALL, &PlatformData);
+}
+
+// Death tests
+
+TEST(ScudoMapDeathTest, MapNoAccessWrite) {
+  const scudo::uptr Size = 4 * scudo::getPageSizeCached();
+  scudo::u64 PlatformData = 0;
+  void *P = scudo::map(nullptr, Size, MappingName, MAP_NOACCESS, &PlatformData);
+  EXPECT_NE(P, nullptr);
+  EXPECT_DEATH(memset(P, 0xaa, Size), "");
+}
+
+TEST(ScudoMapDeathTest, MapUnmap) {
+  const scudo::uptr Size = 4 * scudo::getPageSizeCached();
+  scudo::u64 PlatformData = 0;
+  void *P = scudo::map(nullptr, Size, MappingName, 0, &PlatformData);
+  EXPECT_NE(P, nullptr);
+  memset(P, 0xaa, Size);
+  scudo::unmap(P, Size, 0, &PlatformData);
+  EXPECT_DEATH(memset(P, 0xbb, Size), "");
+}
+
+TEST(ScudoMapDeathTest, MapWithGuardUnmap) {
+  const scudo::uptr PageSize = scudo::getPageSizeCached();
+  const scudo::uptr Size = 4 * PageSize;
+  scudo::u64 PlatformData = 0;
+  void *P = scudo::map(nullptr, Size + 2 * PageSize, MappingName, MAP_NOACCESS,
+                       &PlatformData);
+  EXPECT_NE(P, nullptr);
+  void *Q =
+      reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(P) + PageSize);
+  EXPECT_EQ(scudo::map(Q, Size, MappingName, 0, &PlatformData), Q);
+  EXPECT_DEATH(memset(Q, 0xaa, Size + 1), "");
+}

lib/scudo/standalone/tests/mutex_test.cc

+//===-- mutex_test.cc--------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mutex.h"
+
+#include "gtest/gtest.h"
+
+#include <string.h>
+
+template <typename MutexType> class TestData {
+public:
+  explicit TestData(MutexType *M) : Mutex(M) {
+    for (scudo::u32 I = 0; I < Size; I++)
+      Data[I] = 0;
+  }
+
+  void write() {
+    Lock L(Mutex);
+    T V0 = Data[0];
+    for (scudo::u32 I = 0; I < Size; I++) {
+      EXPECT_EQ(Data[I], V0);
+      Data[I]++;
+    }
+  }
+
+  void tryWrite() {
+    if (!Mutex->tryLock())
+      return;
+    T V0 = Data[0];
+    for (scudo::u32 I = 0; I < Size; I++) {
+      EXPECT_EQ(Data[I], V0);
+      Data[I]++;
+    }
+    Mutex->unlock();
+  }
+
+  void backoff() {
+    volatile T LocalData[Size] = {};
+    for (scudo::u32 I = 0; I < Size; I++) {
+      LocalData[I]++;
+      EXPECT_EQ(LocalData[I], 1U);
+    }
+  }
+
+private:
+  typedef scudo::GenericScopedLock<MutexType> Lock;
+  static const scudo::u32 Size = 64U;
+  typedef scudo::u64 T;
+  MutexType *Mutex;
+  ALIGNED(SCUDO_CACHE_LINE_SIZE) T Data[Size];
+};
+
+const scudo::u32 NumberOfThreads = 8;
+#if SCUDO_DEBUG
+const scudo::u32 NumberOfIterations = 4 * 1024;
+#else
+const scudo::u32 NumberOfIterations = 16 * 1024;
+#endif
+
+template <typename MutexType> static void *lockThread(void *Param) {
+  TestData<MutexType> *Data = reinterpret_cast<TestData<MutexType> *>(Param);
+  for (scudo::u32 I = 0; I < NumberOfIterations; I++) {
+    Data->write();
+    Data->backoff();
+  }
+  return 0;
+}
+
+template <typename MutexType> static void *tryThread(void *Param) {
+  TestData<MutexType> *Data = reinterpret_cast<TestData<MutexType> *>(Param);
+  for (scudo::u32 I = 0; I < NumberOfIterations; I++) {
+    Data->tryWrite();
+    Data->backoff();
+  }
+  return 0;
+}
+
+template <typename MutexType> static void checkLocked(MutexType *M) {
+  scudo::GenericScopedLock<MutexType> L(M);
+  M->checkLocked();
+}
+
+TEST(ScudoMutexTest, SpinMutex) {
+  scudo::SpinMutex M;
+  M.init();
+  TestData<scudo::SpinMutex> Data(&M);
+  pthread_t Threads[NumberOfThreads];
+  for (scudo::u32 I = 0; I < NumberOfThreads; I++)
+    pthread_create(&Threads[I], 0, lockThread<scudo::SpinMutex>, &Data);
+  for (scudo::u32 I = 0; I < NumberOfThreads; I++)
+    pthread_join(Threads[I], 0);
+}
+
+TEST(ScudoMutexTest, SpinMutexTry) {
+  scudo::SpinMutex M;
+  M.init();
+  TestData<scudo::SpinMutex> Data(&M);
+  pthread_t Threads[NumberOfThreads];
+  for (scudo::u32 I = 0; I < NumberOfThreads; I++)
+    pthread_create(&Threads[I], 0, tryThread<scudo::SpinMutex>, &Data);
+  for (scudo::u32 I = 0; I < NumberOfThreads; I++)
+    pthread_join(Threads[I], 0);
+}
+
+TEST(ScudoMutexTest, BlockingMutex) {
+  scudo::u64 MutexMemory[1024] = {};
+  scudo::BlockingMutex *M =
+      new (MutexMemory) scudo::BlockingMutex(scudo::LINKER_INITIALIZED);
+  TestData<scudo::BlockingMutex> Data(M);
+  pthread_t Threads[NumberOfThreads];
+  for (scudo::u32 I = 0; I < NumberOfThreads; I++)
+    pthread_create(&Threads[I], 0, lockThread<scudo::BlockingMutex>, &Data);
+  for (scudo::u32 I = 0; I < NumberOfThreads; I++)
+    pthread_join(Threads[I], 0);
+  checkLocked(M);
+}