[compiler-rt] Avoid memintrinsic calls inserted by the compiler

[melver]

Summary

D135716 introduced -ftrivial-auto-var-init=pattern where supported.
Unfortunately this introduces unwanted memset() for large stack arrays,
as shown by the new tests added for asan and msan (tsan already had this
test).

In general, the problem of compiler-inserted memintrinsic calls
(memset/memcpy/memmove) is not new to compiler-rt, and has been a
problem before.

To avoid introducing unwanted memintrinsic calls, we redefine
memintrinsics as __sanitizer_internal_mem* at the assembly level for
most source files automatically (where sanitizer_common_internal_defs.h
is included).

In few cases, redefining a symbol in this way causes issues for
interceptors, namely the memintrinsic interceptor themselves. For such
source files we have to selectively disable the redefinition.

Other alternatives have been considered, but simply do not work well in
the context of compiler-rt:

1. Linker --wrap: this does not work because --wrap only

	   applies to the final link, and would not apply when building
	   sanitizer static libraries.

2. Changing references to memset() via objcopy: this may work,

	   but due to the complexities of the build system, introducing
	   such a post-processing step for the right object files (in
	   particular object files defining memset cannot be touched)
	   seems infeasible.

The chosen solution works well (as shown by the tests). Other libraries
have chosen the same solution where nothing else works (see e.g. glibc's
"symbol-hacks.h").

v4:

• Add interface attribute to __sanitizer_internal_mem* declarations as well, as otherwise some compilers (MSVC) will complain.
• Add SANITIZER_COMMON_NO_REDEFINE_BUILTINS to source files using C++STL, since this could lead to ODR violations (see added comment).

v3:

• Don't use ALIAS() to alias internal_mem*() functions to __sanitizer_internal_mem*() functions, but just define them as ALWAYS_INLINE functions instead. This will work on darwin and windows.

v2:

• Fix ubsan_minimal build where compiler decides to insert memset/memcpy: ubsan_minimal has work without RTSanitizerCommonLibc, therefore do not redefine the builtins.
• Fix definition of internal_mem* functions with compilers that want the aliased function to already be defined before.
• Fix definition of __sanitizer_internal_mem* functions with compilers more pedantic about attribute placement around extern "C".

[melver]

• Add tests for asan and msan.
• Fix new issues for asan and msan.

[dvyukov]

Marco mentioned offline that there is nolibc build, which is broken for asan/msan now. So we need to fix these as well.

Some more complex alternatives:

• add compiler flag to emit only inline initialization
• add compiler flag to emit calls to special __sanitizer_memset functions
• add objcopy pass to sanitizer runtime builds to rename memcpy/memset calls

But these are more complex and elaborate, and this solution looks reasonable as well.

compiler-rt/test/asan/TestCases/Linux/check_memcpy.c

13

Since we use regexp, I would 1 line (callq|jmpq). Or have you copied this form from somewhere else?
This is also x86-specific, so can add REQUIRES directive.

[dvyukov]

Vitaly, do you want to take a look as well?

[melver]

• Simplify CHECK-NOT of tests.
• Add REQUIRES for x86.

[leonardchan]

Hmm if possible I'd prefer not to add these holes into the runtime since they kinda defeat the purpose of adding the auto-var-init flag, and I think adding UNINITIALIZED until a test passes seems kinda fragile.

I think what we'd want is just a way to ensure compiler-emitted memset/cpy calls go through the internal/unsanitized versions of those functions. I think the cheapest way to do this might be through --wrap=memset as a link flag and compiler-rt defines something like:

int memset(...) {
  return internal_memset(...);
}

[melver]

Rework solution and find compromise:

• avoid attribute((uninitialized)) where possible by redefining

	  memset at the asm level.

• use the attribute only where necessary (where redefining memset isn't

	  possible due to interceptors).

[melver]

In D151152#4370264, @leonardchan wrote:

Hmm if possible I'd prefer not to add these holes into the runtime since they kinda defeat the purpose of adding the auto-var-init flag, and I think adding UNINITIALIZED until a test passes seems kinda fragile.

I think what we'd want is just a way to ensure compiler-emitted memset/cpy calls go through the internal/unsanitized versions of those functions. I think the cheapest way to do this might be through --wrap=memset as a link flag and compiler-rt defines something like:

int memset(...) {
  return internal_memset(...);
}

--wrap doesn't work because it only applies to the final link (doesn't work for static lib sanitizers), which means that it would also wrap the to-be-sanitized binary's memset calls, which is wrong. Furthermore, claiming the symbol __wrap_memset globally is precluding others from using --wrap (we already have interceptors, we don't need more interception pain).

I reworked the solution to a compromise. Unfortunately if a memset interceptor exists it's a little difficult to redefine memset though, so in those TUs we still need the attribute.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary32.h

356

if possible, can we rely on sanitizer_redefine_builtins.h and avoid UNINITIALIZED?

compiler-rt/lib/sanitizer_common/sanitizer_redefine_builtins.h

21 ↗

(On Diff #525767)

no, it's a problem is even without auto-var-init
if this trick works please make it always

also memcpy

[vitalybuka]

also, isn't D135716 was NOOP as it has a typo?

compiler-rt/lib/sanitizer_common/sanitizer_redefine_builtins.h

21 ↗

(On Diff #525767)

no, it's a problem is even without auto-var-init
if this trick works please make it always

also memcpy

maybe even move this into _defs.h to make sure it's everywhere

[vitalybuka]

compiler-rt/CMakeLists.txt

520 ↗

(On Diff #525767)

as I wrote, don't do this
if the trick works, please use it always

time to time w have to debug crashes caused by accidental interceptor from " = {}".

compiler-rt/lib/asan/asan_stack.h

36

This is use of UNINITIALIZED as intended.
We don't want in initialize performance critical buffers.

compiler-rt/lib/ubsan/ubsan_diag.cpp

25

please reorder in a separate patch

compiler-rt/test/asan/TestCases/Linux/check_memcpy.c

11

Please use stronger --implicit-check-not instead of -NOT

[vitalybuka]

Some more complex alternatives:

• add compiler flag to emit only inline initialization

compiler can emit, but there are passes that replace some common patterns with memset. Probably suppressible with some attributes.
For sanitizer instrumentation we insert tsan_memset, asan_memset... etc

• add compiler flag to emit calls to special __sanitizer_memset functions

late pass to replace memset/memcpy with __internal_ like would be nice. But we never had a good motivation to fix this.

• add objcopy pass to sanitizer runtime builds to rename memcpy/memset calls

But these are more complex and elaborate, and this solution looks reasonable as well.

It would be grate if D151152 works.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_redefine_builtins.h

21 ↗

(On Diff #525767)

no, it's a problem is even without auto-var-init
if this trick works please make it always

also memcpy

maybe even move this into _defs.h to make sure it's everywhere

Or I guess it's going to conflict with interceptors?

[melver]

compiler-rt/lib/sanitizer_common/sanitizer_redefine_builtins.h

21 ↗

(On Diff #525767)

Interceptors make difficult to work everywhere. In general anything that includes sanitizer_common_interceptors.inc and wants the memset/cpy interceptor.

But let me try a little harder. glibc uses this solution, but they say clearly it's a bad hack: https://codebrowser.dev/glibc/glibc/sysdeps/generic/symbol-hacks.h.html

Maybe all it takes is moving interceptors for memset/cpy to the end of the source file (given that asm("f1 = f2") just turns into ".set f1, f2" in asm).

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_redefine_builtins.h

21 ↗

(On Diff #525767)

I guess we can move them into a separate cpp?
Like we do with sanitizer_signal_interceptors.inc

[melver]

• Rework solution to redefine builtins almost everywhere.

[melver]

• Also check memmove in tests.

[melver]

compiler-rt/lib/asan/asan_stack.h

36

Moved to separate patch.

compiler-rt/lib/ubsan/ubsan_diag.cpp

25

Removed entirely.

[vitalybuka]

Nice!

Not a strong request, but I assume D151552 has high chance of being reverted. To avoid conflicts, would be nice to land them with a couple of days of delay.

compiler-rt/lib/asan/asan_interceptors_memintrinsics.cpp

14 ↗

(On Diff #526035)

For consistently lets prefix sanitizer_common macros with SANITIZER_COMMON_
we don't follow that strictly, but it could be nice:
__NO_SANITIZER_REDEFINE_BUILTINS -> SANITIZER_COMMON_NO_REDEFINE_BUILTINS

[melver]

• Use SANITIZER_COMMON_NO_REDEFINE_BUILTINS for opt-out macro name.
• Do not use asm() hack with old MSVC compilers (not supported there).

[vitalybuka]

FYI @sivachandra

[thakis]

This doesn't build on mac: http://45.33.8.238/macm1/61839/step_4.txt

FAILED: stage2_unix/obj/compiler-rt/lib/sanitizer_common/sources.sanitizer_libc.o 
./bin/clang++ -MMD -MF stage2_unix/obj/compiler-rt/lib/sanitizer_common/sources.sanitizer_libc.o.d -o stage2_unix/obj/compiler-rt/lib/sanitizer_common/sources.sanitizer_libc.o -c ../../compiler-rt/lib/sanitizer_common/sanitizer_libc.cpp  -I../../compiler-rt/lib -mmacos-version-min=10.10 -O3 -fdiagnostics-color -Wall -Wextra -Wno-unused-parameter -Wdelete-non-virtual-dtor -Wstring-conversion -no-canonical-prefixes -Werror=date-time -isysroot ../../sysroot/MacOSX.sdk -Wpoison-system-directories -Wcovered-switch-default -fno-builtin -gline-tables-only -fPIC -funwind-tables -fvisibility=hidden -Werror=thread-safety -Werror=thread-safety-reference -Werror=thread-safety-beta -std=c++17 -fvisibility-inlines-hidden -fno-exceptions -fno-rtti
../../compiler-rt/lib/sanitizer_common/sanitizer_libc.cpp:109:5: error: aliases are not supported on darwin
  109 |     ALIAS(__sanitizer_internal_memcpy);
      |     ^
../../compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h:222:34: note: expanded from macro 'ALIAS'
  222 | # define ALIAS(x) __attribute__((alias(SANITIZER_STRINGIFY(x))))
      |                                  ^
../../compiler-rt/lib/sanitizer_common/sanitizer_libc.cpp:111:5: error: aliases are not supported on darwin
  111 |     ALIAS(__sanitizer_internal_memmove);
      |     ^
../../compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h:222:34: note: expanded from macro 'ALIAS'
  222 | # define ALIAS(x) __attribute__((alias(SANITIZER_STRINGIFY(x))))
      |                                  ^
../../compiler-rt/lib/sanitizer_common/sanitizer_libc.cpp:113:5: error: aliases are not supported on darwin
  113 |     ALIAS(__sanitizer_internal_memset);
      |     ^
../../compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h:222:34: note: expanded from macro 'ALIAS'
  222 | # define ALIAS(x) __attribute__((alias(SANITIZER_STRINGIFY(x))))
      |                                  ^
3 errors generated.

Please take a look, and revert for now if it takes a while to fix.

[vitalybuka]

Windows https://lab.llvm.org/buildbot/#/builders/127/builds/49136/steps/4/logs/stdio

[thakis]

Thanks for the revert!

If it's not too much trouble, if you could fold https://github.com/llvm/llvm-project/commit/3825910c7316cf62549bd31c503c48e7526adcc2 into this when relanding, that'd be great.

[thakis]

In D151152#4384558, @vitalybuka wrote:

Windows https://lab.llvm.org/buildbot/#/builders/127/builds/49136/steps/4/logs/stdio

I'm seeing a different error (using lld-link) on win: http://45.33.8.238/win/79321/step_4.txt

lld-link: error: stage2_win_x64/obj/compiler-rt/lib/asan/asan_shared_library.asan_activation.obj: memcpy should not refer to special section 0
[2124/2134] CXX obj/clang/unittests/Tooling/ToolingTests.SourceCodeTest.obj

[melver]

• Fix darwin and windows by defining internal_X() aliases as ALWAYS_INLINE functions instead.

[melver]

• Try to fix Windows builds.
• Fix ODR violations.

[fmayer]

Seems like the check_memcpy.c is broken: https://lab.llvm.org/buildbot/#/builders/37/builds/22633/steps/2/logs/stdio

[melver]

In D151152#4400149, @fmayer wrote:

Seems like the check_memcpy.c is broken: https://lab.llvm.org/buildbot/#/builders/37/builds/22633/steps/2/logs/stdio

Apparently this is expected because a similar exception exists for the tsan check_memcpy.c test: https://github.com/llvm/llvm-zorg/pull/38/files

[mstorsjo]

This broke linking the sanitizers for mingw targets. Building now fails with errors like these:

[330/350] Linking CXX shared library lib/windows/libclang_rt.asan_dynamic-x86_64.dll
FAILED: lib/windows/libclang_rt.asan_dynamic-x86_64.dll lib/windows/libclang_rt.asan_dynamic-x86_64.dll.a
[...]
ld.lld: error: lib/interception/CMakeFiles/RTInterception.x86_64.dir/interception_linux.cpp.obj: memcpy should not refer to special section 0
clang: error: linker command failed with exit code 1 (use -v to see invocation)

I see that this also was happening with clang-cl configurations, which was then fixed in caa2c1bacbd76c017ebbb4fd13861f0f66770299. I'll go ahead and push a change that changes _MSC_VER into _WIN32 there, to keep the same behaviour in mingw configs as in clang-cl configs.

[melver]

In D151152#4402854, @mstorsjo wrote:

This broke linking the sanitizers for mingw targets. Building now fails with errors like these:

[330/350] Linking CXX shared library lib/windows/libclang_rt.asan_dynamic-x86_64.dll
FAILED: lib/windows/libclang_rt.asan_dynamic-x86_64.dll lib/windows/libclang_rt.asan_dynamic-x86_64.dll.a
[...]
ld.lld: error: lib/interception/CMakeFiles/RTInterception.x86_64.dir/interception_linux.cpp.obj: memcpy should not refer to special section 0
clang: error: linker command failed with exit code 1 (use -v to see invocation)

I see that this also was happening with clang-cl configurations, which was then fixed in caa2c1bacbd76c017ebbb4fd13861f0f66770299. I'll go ahead and push a change that changes _MSC_VER into _WIN32 there, to keep the same behaviour in mingw configs as in clang-cl configs.

That sounds reasonable, thanks.

Getting it to work on Windows (when built with Clang) would be nice, because ftrivial-auto-var-init is also available on Windows (AFAIK). But I've deferred for now, because it seems rather tricky (likely needs some changes to the inline asm?).

[mstorsjo]

In D151152#4402874, @melver wrote:

Getting it to work on Windows (when built with Clang) would be nice, because ftrivial-auto-var-init is also available on Windows (AFAIK). But I've deferred for now, because it seems rather tricky (likely needs some changes to the inline asm?).

Yes, it seems like those kinds of symbol aliases don't quite work as expected/desired on COFF.

[jakubjelinek]

Note, this doesn't really work on SPARC Solaris when using the Solaris assembler, see https://gcc.gnu.org/PR112563 for details.

c
extern "C" void *memcpy (void *, const void *, decltype (sizeof 0)) __asm ("__sanitizer_internal_memcpy");
extern "C" void *memmove (void *, const void *, decltype (sizeof 0)) __asm ("__sanitizer_internal_memmove");
extern "C" void *memset (void *, int, decltype (sizeof 0)) __asm ("__sanitizer_internal_memset");

would work if -fno-builtin flag wouldn't be used, but for some reason it is.

c
extern "C" {
  static void *memcpy (void *, const void *, decltype (sizeof 0)) __attribute__ ((weakref ("__sanitizer_internal_memcpy")));
  static void *memmove (void *, const void *, decltype (sizeof 0)) __attribute__ ((weakref ("__sanitizer_internal_memmove")));
  static void *memset (void *, int, decltype (sizeof 0)) __attribute__ ((weakref ("__sanitizer_internal_memset")));
}

seems to work somehow, but explicit calls to the mem* or __builtin_mem* functions seem to be at least on SPARC less optimized (indirect calls rather than direct). But I bet compiler-rt doesn't really call the functions directly but calls __sanitizer_internal_mem* instead.

compiler-rt/lib/asan/asan_activation.cpp

 #undef ASAN_ACTIVATION_FLAG
 #undef COMMON_ACTIVATION_FLAG
 
     RegisterIncludeFlags(parser, cf);
   }
 
   void OverrideFromActivationFlags() {
     Flags f;
-    CommonFlags cf;
+    UNINITIALIZED CommonFlags cf;
     FlagParser parser;
     RegisterActivationFlags(&parser, &f, &cf);
 
     cf.SetDefaults();
     // Copy the current activation flags.
     allocator_options.CopyTo(&f, &cf);
     cf.malloc_context_size = malloc_context_size;
     f.poison_heap = poison_heap;

compiler-rt/lib/asan/asan_debugging.cpp

 }
 
 }  // namespace
 
 SANITIZER_INTERFACE_ATTRIBUTE
 const char *__asan_locate_address(uptr addr, char *name, uptr name_size,
                                   uptr *region_address_ptr,
                                   uptr *region_size_ptr) {
-  AddressDescription descr(addr);
+  UNINITIALIZED AddressDescription descr(addr);
   uptr region_address = 0;
   uptr region_size = 0;
   const char *region_kind = nullptr;
   if (name && name_size > 0) name[0] = 0;
 
   if (auto shadow = descr.AsShadow()) {
     // region_{address,size} are already 0
     switch (shadow->kind) {

compiler-rt/lib/asan/asan_descriptions.cpp

int globals_num = GetGlobalsForAddress(addr, descr->globals, descr->reg_sites,
                                          ARRAY_SIZE(descr->globals));
   descr->size = globals_num;
   descr->access_size = access_size;
   return globals_num != 0;
 }
 
 bool DescribeAddressIfGlobal(uptr addr, uptr access_size,
                              const char *bug_type) {
-  GlobalAddressDescription descr;
+  UNINITIALIZED GlobalAddressDescription descr;
   if (!GetGlobalAddressInformation(addr, access_size, &descr)) return false;
 
   descr.Print(bug_type);
   return true;
 }
 
 void ShadowAddressDescription::Print() const {
   Printf("Address %p is located in the %s area.\n", (void *)addr,

 void PrintAddressDescription(uptr addr, uptr access_size,
                              const char *bug_type) {
   ShadowAddressDescription shadow_descr;
   if (GetShadowAddressInformation(addr, &shadow_descr)) {
     shadow_descr.Print();
     return;
   }
 
-  GlobalAddressDescription global_descr;
+  UNINITIALIZED GlobalAddressDescription global_descr;
   if (GetGlobalAddressInformation(addr, access_size, &global_descr)) {
     global_descr.Print(bug_type);
     return;
   }
 
   StackAddressDescription stack_descr;
   if (GetStackAddressInformation(addr, access_size, &stack_descr)) {
     stack_descr.Print();

compiler-rt/lib/asan/asan_flags.cpp

 #include "asan_flags.inc"
 #undef ASAN_FLAG
 }
 
 void InitializeFlags() {
   // Set the default values and prepare for parsing ASan and common flags.
   SetCommonFlagsDefaults();
   {
-    CommonFlags cf;
+    UNINITIALIZED CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.detect_leaks = cf.detect_leaks && CAN_SANITIZE_LEAKS;
     cf.external_symbolizer_path = GetEnv("ASAN_SYMBOLIZER_PATH");
     cf.malloc_context_size = kDefaultMallocContextSize;
     cf.intercept_tls_get_addr = true;
     cf.exitcode = 1;
     OverrideCommonFlags(cf);
   }

compiler-rt/lib/asan/asan_interceptors.cpp

static void ClearShadowMemoryForContextStack(uptr stack, uptr ssize) {
   ssize += stack - bottom;
   ssize = RoundUpTo(ssize, PageSize);
   PoisonShadow(bottom, ssize, 0);
 }
 
 INTERCEPTOR(void, makecontext, struct ucontext_t *ucp, void (*func)(), int argc,
             ...) {
   va_list ap;
-  uptr args[64];
+  UNINITIALIZED uptr args[64];
   // We don't know a better way to forward ... into REAL function. We can
   // increase args size if neccecary.
   CHECK_LE(argc, ARRAY_SIZE(args));
   internal_memset(args, 0, sizeof(args));
   va_start(ap, argc);
   for (int i = 0; i < argc; ++i) args[i] = va_arg(ap, uptr);
   va_end(ap);
 

compiler-rt/lib/asan/asan_linux.cpp

if (ASAN_DYNAMIC) {
     }
   } else {
     if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) {
       // Ensure that dynamic runtime is not present. We should detect it
       // as early as possible, otherwise ASan interceptors could bind to
       // the functions in dynamic ASan runtime instead of the functions in
       // system libraries, causing crashes later in ASan initialization.
       MemoryMappingLayout proc_maps(/*cache_enabled*/ true);
-      char filename[PATH_MAX];
+      UNINITIALIZED char filename[PATH_MAX];
       MemoryMappedSegment segment(filename, sizeof(filename));
       while (proc_maps.Next(&segment)) {
         if (IsDynamicRTName(segment.filename)) {
           Report(
               "Your application is linked against "
               "incompatible ASan runtimes.\n");
           Die();
         }

compiler-rt/lib/asan/asan_report.cpp

private:
   static ErrorDescription current_error_;
   bool halt_on_error_;
 };
 
 ErrorDescription ScopedInErrorReport::current_error_(LINKER_INITIALIZED);
 
 void ReportDeadlySignal(const SignalContext &sig) {
   ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorDeadlySignal error(GetCurrentTidOrInvalid(), sig);
+  UNINITIALIZED ErrorDeadlySignal error(GetCurrentTidOrInvalid(), sig);
   in_report.ReportError(error);
 }
 
 void ReportDoubleFree(uptr addr, BufferedStackTrace *free_stack) {
   ScopedInErrorReport in_report;
-  ErrorDoubleFree error(GetCurrentTidOrInvalid(), free_stack, addr);
+  UNINITIALIZED ErrorDoubleFree error(GetCurrentTidOrInvalid(), free_stack,
+                                      addr);
   in_report.ReportError(error);
 }
 
 void ReportNewDeleteTypeMismatch(uptr addr, uptr delete_size,
                                  uptr delete_alignment,
                                  BufferedStackTrace *free_stack) {
   ScopedInErrorReport in_report;
-  ErrorNewDeleteTypeMismatch error(GetCurrentTidOrInvalid(), free_stack, addr,
-                                   delete_size, delete_alignment);
+  UNINITIALIZED ErrorNewDeleteTypeMismatch error(GetCurrentTidOrInvalid(),
+                                                 free_stack, addr, delete_size,
+                                                 delete_alignment);
   in_report.ReportError(error);
 }
 
 void ReportFreeNotMalloced(uptr addr, BufferedStackTrace *free_stack) {
   ScopedInErrorReport in_report;
-  ErrorFreeNotMalloced error(GetCurrentTidOrInvalid(), free_stack, addr);
+  UNINITIALIZED ErrorFreeNotMalloced error(GetCurrentTidOrInvalid(), free_stack,
+                                           addr);
   in_report.ReportError(error);
 }
 
 void ReportAllocTypeMismatch(uptr addr, BufferedStackTrace *free_stack,
                              AllocType alloc_type,
                              AllocType dealloc_type) {
   ScopedInErrorReport in_report;
-  ErrorAllocTypeMismatch error(GetCurrentTidOrInvalid(), free_stack, addr,
-                               alloc_type, dealloc_type);
+  UNINITIALIZED ErrorAllocTypeMismatch error(
+      GetCurrentTidOrInvalid(), free_stack, addr, alloc_type, dealloc_type);
   in_report.ReportError(error);
 }
 
 void ReportMallocUsableSizeNotOwned(uptr addr, BufferedStackTrace *stack) {
   ScopedInErrorReport in_report;
-  ErrorMallocUsableSizeNotOwned error(GetCurrentTidOrInvalid(), stack, addr);
+  UNINITIALIZED ErrorMallocUsableSizeNotOwned error(GetCurrentTidOrInvalid(),
+                                                    stack, addr);
   in_report.ReportError(error);
 }
 
 void ReportSanitizerGetAllocatedSizeNotOwned(uptr addr,
                                              BufferedStackTrace *stack) {
   ScopedInErrorReport in_report;
-  ErrorSanitizerGetAllocatedSizeNotOwned error(GetCurrentTidOrInvalid(), stack,
-                                               addr);
+  UNINITIALIZED ErrorSanitizerGetAllocatedSizeNotOwned error(
+      GetCurrentTidOrInvalid(), stack, addr);
   in_report.ReportError(error);
 }
 
 void ReportCallocOverflow(uptr count, uptr size, BufferedStackTrace *stack) {
   ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorCallocOverflow error(GetCurrentTidOrInvalid(), stack, count, size);
+  UNINITIALIZED ErrorCallocOverflow error(GetCurrentTidOrInvalid(), stack,
+                                          count, size);
   in_report.ReportError(error);
 }
 
 void ReportReallocArrayOverflow(uptr count, uptr size,
                                 BufferedStackTrace *stack) {
   ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorReallocArrayOverflow error(GetCurrentTidOrInvalid(), stack, count, size);
+  UNINITIALIZED ErrorReallocArrayOverflow error(GetCurrentTidOrInvalid(), stack,
+                                                count, size);
   in_report.ReportError(error);
 }
 
 void ReportPvallocOverflow(uptr size, BufferedStackTrace *stack) {
   ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorPvallocOverflow error(GetCurrentTidOrInvalid(), stack, size);
+  UNINITIALIZED ErrorPvallocOverflow error(GetCurrentTidOrInvalid(), stack,
+                                           size);
   in_report.ReportError(error);
 }
 
 void ReportInvalidAllocationAlignment(uptr alignment,
                                       BufferedStackTrace *stack) {
   ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorInvalidAllocationAlignment error(GetCurrentTidOrInvalid(), stack,
-                                        alignment);
+  UNINITIALIZED ErrorInvalidAllocationAlignment error(GetCurrentTidOrInvalid(),
+                                                      stack, alignment);
   in_report.ReportError(error);
 }
 
 void ReportInvalidAlignedAllocAlignment(uptr size, uptr alignment,
                                         BufferedStackTrace *stack) {
   ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorInvalidAlignedAllocAlignment error(GetCurrentTidOrInvalid(), stack,
-                                          size, alignment);
+  UNINITIALIZED ErrorInvalidAlignedAllocAlignment error(
+      GetCurrentTidOrInvalid(), stack, size, alignment);
   in_report.ReportError(error);
 }
 
 void ReportInvalidPosixMemalignAlignment(uptr alignment,
                                          BufferedStackTrace *stack) {
   ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorInvalidPosixMemalignAlignment error(GetCurrentTidOrInvalid(), stack,
-                                           alignment);
+  UNINITIALIZED ErrorInvalidPosixMemalignAlignment error(
+      GetCurrentTidOrInvalid(), stack, alignment);
   in_report.ReportError(error);
 }
 
 void ReportAllocationSizeTooBig(uptr user_size, uptr total_size, uptr max_size,
                                 BufferedStackTrace *stack) {
   ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorAllocationSizeTooBig error(GetCurrentTidOrInvalid(), stack, user_size,
-                                  total_size, max_size);
+  UNINITIALIZED ErrorAllocationSizeTooBig error(
+      GetCurrentTidOrInvalid(), stack, user_size, total_size, max_size);
   in_report.ReportError(error);
 }
 
 void ReportRssLimitExceeded(BufferedStackTrace *stack) {
   ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorRssLimitExceeded error(GetCurrentTidOrInvalid(), stack);
+  UNINITIALIZED ErrorRssLimitExceeded error(GetCurrentTidOrInvalid(), stack);
   in_report.ReportError(error);
 }
 
 void ReportOutOfMemory(uptr requested_size, BufferedStackTrace *stack) {
   ScopedInErrorReport in_report(/*fatal*/ true);
-  ErrorOutOfMemory error(GetCurrentTidOrInvalid(), stack, requested_size);
+  UNINITIALIZED ErrorOutOfMemory error(GetCurrentTidOrInvalid(), stack,
+                                       requested_size);
   in_report.ReportError(error);
 }
 
 void ReportStringFunctionMemoryRangesOverlap(const char *function,
                                              const char *offset1, uptr length1,
                                              const char *offset2, uptr length2,
                                              BufferedStackTrace *stack) {
   ScopedInErrorReport in_report;
-  ErrorStringFunctionMemoryRangesOverlap error(
+  UNINITIALIZED ErrorStringFunctionMemoryRangesOverlap error(
       GetCurrentTidOrInvalid(), stack, (uptr)offset1, length1, (uptr)offset2,
       length2, function);
   in_report.ReportError(error);
 }
 
 void ReportStringFunctionSizeOverflow(uptr offset, uptr size,
                                       BufferedStackTrace *stack) {
   ScopedInErrorReport in_report;
-  ErrorStringFunctionSizeOverflow error(GetCurrentTidOrInvalid(), stack, offset,
-                                        size);
+  UNINITIALIZED ErrorStringFunctionSizeOverflow error(GetCurrentTidOrInvalid(),
+                                                      stack, offset, size);
   in_report.ReportError(error);
 }
 
 void ReportBadParamsToAnnotateContiguousContainer(uptr beg, uptr end,
                                                   uptr old_mid, uptr new_mid,
                                                   BufferedStackTrace *stack) {
   ScopedInErrorReport in_report;
-  ErrorBadParamsToAnnotateContiguousContainer error(
+  UNINITIALIZED ErrorBadParamsToAnnotateContiguousContainer error(
       GetCurrentTidOrInvalid(), stack, beg, end, old_mid, new_mid);
   in_report.ReportError(error);
 }
 
 void ReportBadParamsToAnnotateDoubleEndedContiguousContainer(
     uptr storage_beg, uptr storage_end, uptr old_container_beg,
     uptr old_container_end, uptr new_container_beg, uptr new_container_end,
     BufferedStackTrace *stack) {
   ScopedInErrorReport in_report;
-  ErrorBadParamsToAnnotateDoubleEndedContiguousContainer error(
+  UNINITIALIZED ErrorBadParamsToAnnotateDoubleEndedContiguousContainer error(
       GetCurrentTidOrInvalid(), stack, storage_beg, storage_end,
       old_container_beg, old_container_end, new_container_beg,
       new_container_end);
   in_report.ReportError(error);
 }
 
 void ReportODRViolation(const __asan_global *g1, u32 stack_id1,
                         const __asan_global *g2, u32 stack_id2) {
   ScopedInErrorReport in_report;
-  ErrorODRViolation error(GetCurrentTidOrInvalid(), g1, stack_id1, g2,
-                          stack_id2);
+  UNINITIALIZED ErrorODRViolation error(GetCurrentTidOrInvalid(), g1, stack_id1,
+                                        g2, stack_id2);
   in_report.ReportError(error);
 }
 
 // ----------------------- CheckForInvalidPointerPair ----------- {{{1
 static NOINLINE void ReportInvalidPointerPair(uptr pc, uptr bp, uptr sp,
                                               uptr a1, uptr a2) {
   ScopedInErrorReport in_report;
-  ErrorInvalidPointerPair error(GetCurrentTidOrInvalid(), pc, bp, sp, a1, a2);
+  UNINITIALIZED ErrorInvalidPointerPair error(GetCurrentTidOrInvalid(), pc, bp,
+                                              sp, a1, a2);
   in_report.ReportError(error);
 }
 
 static bool IsInvalidPointerPair(uptr a1, uptr a2) {
   if (a1 == a2)
     return false;
 
   // 256B in shadow memory can be iterated quite fast
static bool IsInvalidPointerPair(uptr a1, uptr a2) {
   HeapAddressDescription hdesc1, hdesc2;
   if (GetHeapAddressInformation(left, 0, &hdesc1) &&
       hdesc1.chunk_access.access_type == kAccessTypeInside)
     return !GetHeapAddressInformation(right, 0, &hdesc2) ||
         hdesc2.chunk_access.access_type != kAccessTypeInside ||
         hdesc1.chunk_access.chunk_begin != hdesc2.chunk_access.chunk_begin;
 
   // check whether left is an address of a global variable
-  GlobalAddressDescription gdesc1, gdesc2;
+  UNINITIALIZED GlobalAddressDescription gdesc1;
+  UNINITIALIZED GlobalAddressDescription gdesc2;
   if (GetGlobalAddressInformation(left, 0, &gdesc1))
     return !GetGlobalAddressInformation(right - 1, 0, &gdesc2) ||
         !gdesc1.PointsInsideTheSameVariable(gdesc2);
 
   if (t->GetStackVariableShadowStart(right) ||
       GetHeapAddressInformation(right, 0, &hdesc2) ||
       GetGlobalAddressInformation(right - 1, 0, &gdesc2))
     return true;
void ReportGenericError(uptr pc, uptr bp, uptr sp, uptr addr, bool is_write,
   // instrumentation (assess false negatives). Instead of completely removing
   // some instrumentation, compiler can emit special calls into runtime
   // (e.g. __asan_report_exp_load1 instead of __asan_report_load1) and pass
   // mask of experiments (exp).
   // The reaction to a non-zero value of exp is to be defined.
   (void)exp;
 
   ScopedInErrorReport in_report(fatal);
-  ErrorGeneric error(GetCurrentTidOrInvalid(), pc, bp, sp, addr, is_write,
-                     access_size);
+  UNINITIALIZED ErrorGeneric error(GetCurrentTidOrInvalid(), pc, bp, sp, addr,
+                                   is_write, access_size);
   in_report.ReportError(error);
 }
 
 }  // namespace __asan
 
 // --------------------------- Interface --------------------- {{{1
 using namespace __asan;
 

compiler-rt/lib/asan/asan_stack.h

 u32 GetMallocContextSize();
 
 } // namespace __asan
 
 // NOTE: A Rule of thumb is to retrieve stack trace in the interceptors
 // as early as possible (in functions exposed to the user), as we generally
 // don't want stack trace to contain functions from ASan internals.
 
-#define GET_STACK_TRACE(max_size, fast)                          \
-  BufferedStackTrace stack;                                      \
-  if (max_size <= 2) {                                           \
-    stack.size = max_size;                                       \
-    if (max_size > 0) {                                          \
-      stack.top_frame_bp = GET_CURRENT_FRAME();                  \
-      stack.trace_buffer[0] = StackTrace::GetCurrentPc();        \
-      if (max_size > 1) stack.trace_buffer[1] = GET_CALLER_PC(); \
-    }                                                            \
-  } else {                                                       \
-    stack.Unwind(StackTrace::GetCurrentPc(),                     \
-                 GET_CURRENT_FRAME(), nullptr, fast, max_size);  \
+#define GET_STACK_TRACE(max_size, fast)                                    \
+  UNINITIALIZED BufferedStackTrace stack;                                  \
+  if (max_size <= 2) {                                                     \
+    stack.size = max_size;                                                 \
+    if (max_size > 0) {                                                    \
+      stack.top_frame_bp = GET_CURRENT_FRAME();                            \
+      stack.trace_buffer[0] = StackTrace::GetCurrentPc();                  \
+      if (max_size > 1)                                                    \
+        stack.trace_buffer[1] = GET_CALLER_PC();                           \
+    }                                                                      \
+  } else {                                                                 \
+    stack.Unwind(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(), nullptr, \
+                 fast, max_size);                                          \
   }
 
-#define GET_STACK_TRACE_FATAL(pc, bp)              \
-  BufferedStackTrace stack;                        \
-  stack.Unwind(pc, bp, nullptr,                    \
-               common_flags()->fast_unwind_on_fatal)
+#define GET_STACK_TRACE_FATAL(pc, bp)     \
+  UNINITIALIZED BufferedStackTrace stack; \
+  stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal)
 
 #define GET_STACK_TRACE_FATAL_HERE                                \
   GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_fatal)
 
 #define GET_STACK_TRACE_THREAD                                    \
   GET_STACK_TRACE(kStackTraceMax, true)
 
 #define GET_STACK_TRACE_MALLOC                                                 \

compiler-rt/lib/asan/asan_stats.cpp

 
 void FlushToDeadThreadStats(AsanStats *stats) {
   Lock lock(&dead_threads_stats_lock);
   dead_threads_stats.MergeFrom(stats);
   stats->Clear();
 }
 
 void FillMallocStatistics(AsanMallocStats *malloc_stats) {
-  AsanStats stats;
+  UNINITIALIZED AsanStats stats;
   GetAccumulatedStats(&stats);
   malloc_stats->blocks_in_use = stats.mallocs;
   malloc_stats->size_in_use = stats.malloced;
   malloc_stats->max_size_in_use = max_malloced_memory;
   malloc_stats->size_allocated = stats.mmaped;
 }
 
 AsanStats &GetCurrentThreadStats() {
   AsanThread *t = GetCurrentThread();
   return (t) ? t->stats() : unknown_thread_stats;
 }
 
 static void PrintAccumulatedStats() {
-  AsanStats stats;
+  UNINITIALIZED AsanStats stats;
   GetAccumulatedStats(&stats);
   // Use lock to keep reports from mixing up.
   Lock lock(&print_lock);
   stats.Print();
   StackDepotStats stack_depot_stats = StackDepotGetStats();
   Printf("Stats: StackDepot: %zd ids; %zdM allocated\n",
          stack_depot_stats.n_uniq_ids, stack_depot_stats.allocated >> 20);
   PrintInternalAllocatorStats();
 }
 
 }  // namespace __asan
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;
 
 uptr __sanitizer_get_current_allocated_bytes() {
-  AsanStats stats;
+  UNINITIALIZED AsanStats stats;
   GetAccumulatedStats(&stats);
   uptr malloced = stats.malloced;
   uptr freed = stats.freed;
   // Return sane value if malloced < freed due to racy
   // way we update accumulated stats.
   return (malloced > freed) ? malloced - freed : 1;
 }
 
 uptr __sanitizer_get_heap_size() {
-  AsanStats stats;
+  UNINITIALIZED AsanStats stats;
   GetAccumulatedStats(&stats);
   return stats.mmaped - stats.munmaped;
 }
 
 uptr __sanitizer_get_free_bytes() {
-  AsanStats stats;
+  UNINITIALIZED AsanStats stats;
   GetAccumulatedStats(&stats);
   uptr total_free = stats.mmaped
                   - stats.munmaped
                   + stats.really_freed;
   uptr total_used = stats.malloced
                   + stats.malloced_redzones;
   // Return sane value if total_free < total_used due to racy
   // way we update accumulated stats.

compiler-rt/lib/msan/msan.h

 // the previous origin id.
 u32 ChainOrigin(u32 id, StackTrace *stack);
 
 const int STACK_TRACE_TAG_POISON = StackTrace::TAG_CUSTOM + 1;
 const int STACK_TRACE_TAG_FIELDS = STACK_TRACE_TAG_POISON + 1;
 const int STACK_TRACE_TAG_VPTR = STACK_TRACE_TAG_FIELDS + 1;
 
 #define GET_MALLOC_STACK_TRACE                                            \
-  BufferedStackTrace stack;                                               \
+  UNINITIALIZED BufferedStackTrace stack;                                 \
   if (__msan_get_track_origins() && msan_inited)                          \
     stack.Unwind(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(),         \
                  nullptr, common_flags()->fast_unwind_on_malloc,          \
                  common_flags()->malloc_context_size)
 
 // For platforms which support slow unwinder only, we restrict the store context
 // size to 1, basically only storing the current pc. We do this because the slow
 // unwinder which is based on libunwind is not async signal safe and causes
 // random freezes in forking applications as well as in signal handlers.
 #define GET_STORE_STACK_TRACE_PC_BP(pc, bp)                                    \
-  BufferedStackTrace stack;                                                    \
+  UNINITIALIZED BufferedStackTrace stack;                                      \
   if (__msan_get_track_origins() > 1 && msan_inited) {                         \
     int size = flags()->store_context_size;                                    \
     if (!SANITIZER_CAN_FAST_UNWIND)                                            \
       size = Min(size, 1);                                                     \
     stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_malloc, size);\
   }
 
 #define GET_STORE_STACK_TRACE \
   GET_STORE_STACK_TRACE_PC_BP(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME())
 
 #define GET_FATAL_STACK_TRACE_PC_BP(pc, bp)                              \
-  BufferedStackTrace stack;                                              \
+  UNINITIALIZED BufferedStackTrace stack;                                \
   if (msan_inited) {                                                     \
     stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal); \
   }
 
 class ScopedThreadLocalStateBackup {
  public:
   ScopedThreadLocalStateBackup() { Backup(); }
   ~ScopedThreadLocalStateBackup() { Restore(); }

compiler-rt/lib/msan/msan.cpp

FlagHandlerKeepGoing *fh_keep_going =
       new (FlagParser::Alloc) FlagHandlerKeepGoing(&f->halt_on_error);
   parser->RegisterHandler("keep_going", fh_keep_going,
                           "deprecated, use halt_on_error");
 }
 
 static void InitializeFlags() {
   SetCommonFlagsDefaults();
   {
-    CommonFlags cf;
+    UNINITIALIZED CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.external_symbolizer_path = GetEnv("MSAN_SYMBOLIZER_PATH");
     cf.malloc_context_size = 20;
     cf.handle_ioctl = true;
     // FIXME: test and enable.
     cf.check_printf = false;
     cf.intercept_tls_get_addr = true;
     OverrideCommonFlags(cf);
#endif
 
   if (common_flags()->help) parser.PrintFlagDescriptions();
 
   // Check if deprecated exit_code MSan flag is set.
   if (f->exit_code != -1) {
     if (Verbosity())
       Printf("MSAN_OPTIONS=exit_code is deprecated! "
              "Please use MSAN_OPTIONS=exitcode instead.\n");
-    CommonFlags cf;
+    UNINITIALIZED CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.exitcode = f->exit_code;
     OverrideCommonFlags(cf);
   }
 
   // Check flag values:
   if (f->origin_history_size < 0 ||
       f->origin_history_size > Origin::kMaxDepth) {

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary32.h

if (kRandomShuffleChunks)
         // The random state is initialized from ASLR (PIE) and time.
         sci->rand_state = reinterpret_cast<uptr>(sci) ^ NanoTime();
     const uptr size = ClassIdToSize(class_id);
     const uptr n_chunks = kRegionSize / (size + kMetadataSize);
     const uptr max_count = TransferBatch::MaxCached(size);
     DCHECK_GT(max_count, 0);
     TransferBatch *b = nullptr;
     constexpr uptr kShuffleArraySize = 48;
-    uptr shuffle_array[kShuffleArraySize];
+    UNINITIALIZED uptr shuffle_array[kShuffleArraySize];
     uptr count = 0;
     for (uptr i = region; i < region + n_chunks * size; i += size) {
       shuffle_array[count++] = i;
       if (count == kShuffleArraySize) {
         if (UNLIKELY(!PopulateBatches(c, sci, class_id, &b, max_count,
                                       shuffle_array, count)))
           return false;
         count = 0;

compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector.h

public:
   // Adds edges from currently held locks to cur_node,
   // returns the number of added edges, and puts the sources of added edges
   // into added_edges[].
   // Should be called before onLockAfter.
   uptr addEdges(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, u32 stk,
                 int unique_tid) {
     ensureCurrentEpoch(dtls);
     uptr cur_idx = nodeToIndex(cur_node);
-    uptr added_edges[40];
+    UNINITIALIZED uptr added_edges[40];
     uptr n_added_edges = g_.addEdges(dtls->getLocks(current_epoch_), cur_idx,
                                      added_edges, ARRAY_SIZE(added_edges));
     for (uptr i = 0; i < n_added_edges; i++) {
       if (n_edges_ < ARRAY_SIZE(edges_)) {
         Edge e = {(u16)added_edges[i], (u16)cur_idx,
                   dtls->findLockContext(added_edges[i]), stk,
                   unique_tid};
         edges_[n_edges_++] = e;

compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h

 # define FORMAT(f, a)
 # define NOINLINE __declspec(noinline)
 # define NORETURN __declspec(noreturn)
 # define THREADLOCAL   __declspec(thread)
 # define LIKELY(x) (x)
 # define UNLIKELY(x) (x)
 # define PREFETCH(x) /* _mm_prefetch(x, _MM_HINT_NTA) */ (void)0
 # define WARN_UNUSED_RESULT
+# define UNINITIALIZED
 #else  // _MSC_VER
 # define ALWAYS_INLINE inline __attribute__((always_inline))
 # define ALIAS(x) __attribute__((alias(SANITIZER_STRINGIFY(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
 #  define PREFETCH(x) __asm__("prefetchnta (%0)" : : "r" (x))
 # else
 #  define PREFETCH(x) __builtin_prefetch(x)
 # endif
 # define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+# if __has_attribute(uninitialized)
+#  define UNINITIALIZED __attribute__((uninitialized))
+# else  // __has_attribute(uninitialized)
+#  define UNINITIALIZED
+# endif  // __has_attribute(uninitialized)
 #endif  // _MSC_VER
 
 #if !defined(_MSC_VER) || defined(__clang__)
 # define UNUSED __attribute__((unused))
 # define USED __attribute__((used))
 #else
 # define UNUSED
 # define USED

compiler-rt/lib/sanitizer_common/sanitizer_printf.cpp

 }
 
 static void NOINLINE SharedPrintfCode(bool append_pid, const char *format,
                                       va_list args) {
   // |local_buffer| is small enough not to overflow the stack and/or violate
   // the stack limit enforced by TSan (-Wframe-larger-than=512). On the other
   // hand, the bigger the buffer is, the more the chance the error report will
   // fit into it.
-  char local_buffer[400];
+  UNINITIALIZED char local_buffer[400];
   SharedPrintfCodeNoBuffer(append_pid, local_buffer, ARRAY_SIZE(local_buffer),
                            format, args);
 }
 
 void Printf(const char *format, ...) {
   va_list args;
   va_start(args, format);
   SharedPrintfCode(false, format, args);

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

RegisterFlag(parser, "second_deadlock_stack",
       "Report where each mutex is locked in deadlock reports",
       &f->second_deadlock_stack);
 }
 
 void InitializeFlags(Flags *f, const char *env, const char *env_option_name) {
   SetCommonFlagsDefaults();
   {
     // Override some common flags defaults.
-    CommonFlags cf;
+    UNINITIALIZED CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.external_symbolizer_path = GetEnv("TSAN_SYMBOLIZER_PATH");
     cf.allow_addr2line = true;
     if (SANITIZER_GO) {
       // Does not work as expected for Go: runtime handles SIGABRT and crashes.
       cf.abort_on_error = false;
       // Go does not have mutexes.
       cf.detect_deadlocks = false;

compiler-rt/lib/ubsan/ubsan_diag.cpp

 #include "ubsan_flags.h"
 #include "ubsan_monitor.h"
 #include "sanitizer_common/sanitizer_placement_new.h"
 #include "sanitizer_common/sanitizer_report_decorator.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "sanitizer_common/sanitizer_stacktrace_printer.h"
 #include "sanitizer_common/sanitizer_suppressions.h"
 #include "sanitizer_common/sanitizer_symbolizer.h"
 #include <stdio.h>
 
 using namespace __ubsan;
 
 // UBSan is combined with runtimes that already provide this functionality
 // (e.g., ASan) as well as runtimes that lack it (e.g., scudo). Tried to use
 // weak linkage to resolve this issue which is not portable and breaks on
 // Windows.
 // TODO(yln): This is a temporary workaround. GetStackTrace functions will be
 // removed in the future.
 void ubsan_GetStackTrace(BufferedStackTrace *stack, uptr max_depth, uptr pc,
                          uptr bp, void *context, bool request_fast) {
   uptr top = 0;
   uptr bottom = 0;
   GetThreadStackTopAndBottom(false, &top, &bottom);
   bool fast = StackTrace::WillUseFastUnwind(request_fast);
   stack->Unwind(max_depth, pc, bp, context, top, bottom, fast);
 }
 
 static void MaybePrintStackTrace(uptr pc, uptr bp) {
   // We assume that flags are already parsed, as UBSan runtime
   // will definitely be called when we print the first diagnostics message.
   if (!flags()->print_stacktrace)
     return;
 
-  BufferedStackTrace stack;
+  UNINITIALIZED BufferedStackTrace stack;
   ubsan_GetStackTrace(&stack, kStackTraceMax, pc, bp, nullptr,
                 common_flags()->fast_unwind_on_fatal);
   stack.Print();
 }
 
 static const char *ConvertTypeToString(ErrorType Type) {
   switch (Type) {
 #define UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName)                      \

compiler-rt/lib/ubsan/ubsan_flags.cpp

#define UBSAN_FLAG(Type, Name, DefaultValue, Description) \
   RegisterFlag(parser, #Name, Description, &f->Name);
 #include "ubsan_flags.inc"
 #undef UBSAN_FLAG
 }
 
 void InitializeFlags() {
   SetCommonFlagsDefaults();
   {
-    CommonFlags cf;
+    UNINITIALIZED CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.external_symbolizer_path = GetFlag("UBSAN_SYMBOLIZER_PATH");
     OverrideCommonFlags(cf);
   }
 
   Flags *f = flags();
   f->SetDefaults();
 

compiler-rt/test/asan/TestCases/Linux/check_memcpy.c

+// Verify runtime doesn't contain compiler-emitted memcpy/memmove calls.
+//
+// REQUIRES: shared_unwind, x86_64-target-arch
+
+// RUN: %clang_asan -O1 %s -o %t
+// RUN: llvm-objdump -d -l %t | FileCheck %s
+
+int main() { return 0; }
+
+// CHECK-NOT: {{(callq|jmpq) .*<(__interceptor_.*)?mem(cpy|set)>}}

compiler-rt/test/msan/Linux/check_memcpy.c

+// Verify runtime doesn't contain compiler-emitted memcpy/memmove calls.
+//
+// REQUIRES: shared_unwind, x86_64-target-arch
+
+// RUN: %clang_msan -O1 %s -o %t
+// RUN: llvm-objdump -d -l %t | FileCheck %s
+
+int main() { return 0; }
+
+// CHECK-NOT: {{(callq|jmpq) .*<(__interceptor_.*)?mem(cpy|set)>}}

compiler-rt/test/tsan/Linux/check_memcpy.c

 // Test that verifies TSan runtime doesn't contain compiler-emitted
 // memcpy/memmove calls. It builds the binary with TSan and check's
 // its objdump.
 
 // This could fail if using a static libunwind because that static libunwind
 // could be uninstrumented and contain memcpy/memmove calls not intercepted by
 // tsan.
-// REQUIRES: shared_unwind
+// REQUIRES: shared_unwind, x86_64-target-arch
 
 // RUN: %clang_tsan -O1 %s -o %t
 // RUN: llvm-objdump -d -l %t | FileCheck %s
 
-int main() {
-  return 0;
-}
-
-// CHECK-NOT: callq {{.*<(__interceptor_)?mem(cpy|set)>}}
-// tail calls:
-// CHECK-NOT: jmpq {{.*<(__interceptor_)?mem(cpy|set)>}}
+int main() { return 0; }
 
+// CHECK-NOT: {{(callq|jmpq) .*<(__interceptor_.*)?mem(cpy|set)>}}