[sanitizer_common] Expose a variadic version of the sanitizer Printf function.

[hctim]

Summary

Allows users of sanitizer printf() to create wrappers around the sanitizer Printf function. Used in GWP-ASan to allow us to default-provide a function pointer to Printf(), as the signature taken by GWP-ASan arguments has an 'int' return type.

[kcc]

compiler-rt/lib/sanitizer_common/sanitizer_common.h

25

No, please don't include any system headers here.
Will need to find some other way.

[eugenis]

Is this meant as a test-only thing?
I don't think we want sanitizer Printf anywhere close to production.

IMHO, we could use printf() in gwpasan directly, with a guard against recursive malloc.

compiler-rt/lib/sanitizer_common/sanitizer_common.h

25

stdarg could be fine...

[hctim]

In D60589#1463704, @eugenis wrote:

Is this meant as a test-only thing?

This is meant to be the default printf() implementation for GwpAsan, for if the allocator doesn't provide us with its own printf().

In D60589#1463704, @eugenis wrote:

I don't think we want sanitizer Printf anywhere close to production.

Don't we already do this with HWASan/etc?

In D60589#1463704, @eugenis wrote:

IMHO, we could use printf() in gwpasan directly, with a guard against recursive malloc.

I don't think this will work in a signal-safe manner. The only times that GwpAsan calls printf() is in the signal handler, and even if we temporarily disable sampled allocations, we still are exercising non-reentrant functions in a signal handler.

[eugenis]

IMHO, we could use printf() in gwpasan directly, with a guard against recursive malloc.

I don't think this will work in a signal-safe manner. The only times that GwpAsan calls printf() is in the signal handler, and even if we temporarily disable sampled allocations, we still are exercising non-reentrant functions in a signal handler.

Right, I did not think of this.

I don't think stdarg.h is dangerous. You could also move the declaration to a separate header.

@kcc ?

[hctim]

• Changed sanitizer printf functions to be in their own header, rather than in sanitizer_common. This primarily is useful to avoid having system libraries in sanitizer_common.h.

@kcc: WDYT about this instead?

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector.h

253–254

Removing these comments LGTM, but it should be done in a separate patch

[hctim]

Rebased after rL359150.

compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector.h

253–254

Done in rL359150.

[kcc]

compiler-rt/lib/sanitizer_common/sanitizer_printf.h

13

Well, no, that's not any better.
We *have* to avoid std headers in most .cc files and absolutely have to avoid them
in header files that are included into most .cc files.

Sadly, the sanitizer run-time is not your common C++ program :(

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_printf.h

13

How about we move the include into a separate header, sanitizer_vprintf.h, and never use it anywhere?

[hctim]

• Moved variadic printf decl into its own header file.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_bitvector.h

153

few more?

compiler-rt/lib/sanitizer_common/sanitizer_variadic_printf.h

19

VariadicPrintf -> Printf?

[vitalybuka]

maybe wait @eugenis or @kcc

[hctim]

After discussing offline, we've decided to change the user code to require the printf function as void printf(const char* fmt, ...) instead of the cstdlib int printf(const char* fmt, ...), which allows us to pass the function pointer from __sanitizer::Printf() directly rather than wrapping it.

This change is no longer needed.

compiler-rt/lib/hwasan/hwasan_dynamic_shadow.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "hwasan.h"
 #include "hwasan_dynamic_shadow.h"
 #include "hwasan_mapping.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_posix.h"
+#include "sanitizer_common/sanitizer_printf.h"
 
 #include <elf.h>
 #include <link.h>
 
 // The code in this file needs to run in an unrelocated binary. It should not
 // access any external symbol, including its own non-hidden globals.
 
 namespace __hwasan {

compiler-rt/lib/msan/msan_linux.cc

 #include <unistd.h>
 #include <unwind.h>
 #include <execinfo.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_procmaps.h"
+#include "sanitizer_common/sanitizer_printf.h"
 
 namespace __msan {
 
 void ReportMapRange(const char *descr, uptr beg, uptr size) {
   if (size > 0) {
     uptr end = beg + size - 1;
     VPrintf(1, "%s : %p - %p\n", descr, beg, end);
   }

compiler-rt/lib/sanitizer_common/CMakeLists.txt

set(SANITIZER_IMPL_HEADERS
   sanitizer_placement_new.h
   sanitizer_platform.h
   sanitizer_platform_interceptors.h
   sanitizer_platform_limits_netbsd.h
   sanitizer_platform_limits_openbsd.h
   sanitizer_platform_limits_posix.h
   sanitizer_platform_limits_solaris.h
   sanitizer_posix.h
+  sanitizer_printf.h
   sanitizer_procmaps.h
   sanitizer_quarantine.h
   sanitizer_report_decorator.h
   sanitizer_ring_buffer.h
   sanitizer_rtems.h
   sanitizer_signal_interceptors.inc
   sanitizer_stackdepot.h
   sanitizer_stackdepotbase.h
set(SANITIZER_IMPL_HEADERS
   sanitizer_symbolizer_rtems.h
   sanitizer_syscall_generic.inc
   sanitizer_syscall_linux_aarch64.inc
   sanitizer_syscall_linux_arm.inc
   sanitizer_syscall_linux_x86_64.inc
   sanitizer_syscalls_netbsd.inc
   sanitizer_thread_registry.h
   sanitizer_tls_get_addr.h
+  sanitizer_variadic_printf.h
   sanitizer_vector.h
   sanitizer_win.h
   sanitizer_win_defs.h
   sanitizer_win_dll_thunk.h
   sanitizer_win_weak_interception.h
   )
 
 include_directories(..)

compiler-rt/lib/sanitizer_common/sanitizer_allocator.h

 
 #include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_lfstack.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_list.h"
 #include "sanitizer_local_address_space_view.h"
 #include "sanitizer_mutex.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 #include "sanitizer_type_traits.h"
 
 namespace __sanitizer {
 
 // Allows the tools to name their allocations appropriately.
 extern const char *PrimaryAllocatorName;
 extern const char *SecondaryAllocatorName;

compiler-rt/lib/sanitizer_common/sanitizer_allocator.cc

 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_allocator.h"
 
 #include "sanitizer_allocator_checks.h"
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_atomic.h"
 #include "sanitizer_common.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 // Default allocator names.
 const char *PrimaryAllocatorName = "SizeClassAllocator";
 const char *SecondaryAllocatorName = "LargeMmapAllocator";
 
 // ThreadSanitizer for Go uses libc malloc/free.

compiler-rt/lib/sanitizer_common/sanitizer_allocator_report.cc

 /// Shared allocator error reporting for ThreadSanitizer, MemorySanitizer, etc.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_allocator.h"
 #include "sanitizer_allocator_report.h"
 #include "sanitizer_common.h"
 #include "sanitizer_report_decorator.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 class ScopedAllocatorErrorReport {
  public:
   ScopedAllocatorErrorReport(const char *error_summary_,
                              const StackTrace *stack_)
       : error_summary(error_summary_),

compiler-rt/lib/sanitizer_common/sanitizer_bitvector.h

bool setBit(uptr idx) {
     uptr i0 = idx0(idx);
     uptr i1 = idx1(idx);
     uptr i2 = idx2(idx);
     if (!l1_[i0].getBit(i1)) {
       l1_[i0].setBit(i1);
       l2_[i0][i1].clear();
     }
     bool res = l2_[i0][i1].setBit(i2);
-    // Printf("%s: %zd => %zd %zd %zd; %d\n", __func__,
-    // idx, i0, i1, i2, res);
     return res;
   }
 
   bool clearBit(uptr idx) {
     check(idx);
     uptr i0 = idx0(idx);
     uptr i1 = idx1(idx);
     uptr i2 = idx2(idx);
     bool res = false;
     if (l1_[i0].getBit(i1)) {
       res = l2_[i0][i1].clearBit(i2);
       if (l2_[i0][i1].empty())
         l1_[i0].clearBit(i1);
     }
     return res;
   }
 
   bool getBit(uptr idx) const {
     check(idx);
     uptr i0 = idx0(idx);
     uptr i1 = idx1(idx);
     uptr i2 = idx2(idx);
-    // Printf("%s: %zd => %zd %zd %zd\n", __func__, idx, i0, i1, i2);
     return l1_[i0].getBit(i1) && l2_[i0][i1].getBit(i2);
   }
 
   uptr getAndClearFirstOne() {
     for (uptr i0 = 0; i0 < kLevel1Size; i0++) {
       if (l1_[i0].empty()) continue;
       uptr i1 = l1_[i0].getAndClearFirstOne();
       uptr i2 = l2_[i0][i1].getAndClearFirstOne();
       if (!l2_[i0][i1].empty())
         l1_[i0].setBit(i1);
       uptr res = i0 * BV::kSize * BV::kSize + i1 * BV::kSize + i2;
-      // Printf("getAndClearFirstOne: %zd %zd %zd => %zd\n", i0, i1, i2, res);
       return res;
     }
     CHECK(0);
     return 0;
   }
 
   // Do "this |= v" and return whether new bits have been added.
   bool setUnion(const TwoLevelBitVector &v) {
public:
     bool hasNext() const {
       if (it1_.hasNext()) return true;
       for (uptr i = i0_; i < kLevel1Size; i++)
         if (!bv_.l1_[i].empty()) return true;
       return false;
     }
 
     uptr next() {
-      // Printf("++++: %zd %zd; %d %d; size %zd\n", i0_, i1_, it1_.hasNext(),
-      //       it2_.hasNext(), kSize);
       if (!it1_.hasNext() && !it2_.hasNext()) {
         for (; i0_ < kLevel1Size; i0_++) {
           if (bv_.l1_[i0_].empty()) continue;
           it1_ = typename BV::Iterator(bv_.l1_[i0_]);
-          // Printf("+i0: %zd %zd; %d %d; size %zd\n", i0_, i1_, it1_.hasNext(),
-          //   it2_.hasNext(), kSize);
           break;
         }
       }
       if (!it2_.hasNext()) {
         CHECK(it1_.hasNext());
         i1_ = it1_.next();
         it2_ = typename BV::Iterator(bv_.l2_[i0_][i1_]);
-        // Printf("++i1: %zd %zd; %d %d; size %zd\n", i0_, i1_, it1_.hasNext(),
-        //       it2_.hasNext(), kSize);
       }
       CHECK(it2_.hasNext());
       uptr i2 = it2_.next();
       uptr res = i0_ * BV::kSize * BV::kSize + i1_ * BV::kSize + i2;
-      // Printf("+ret: %zd %zd; %d %d; size %zd; res: %zd\n", i0_, i1_,
-      //       it1_.hasNext(), it2_.hasNext(), kSize, res);
       if (!it1_.hasNext() && !it2_.hasNext())
         i0_++;
       return res;
     }
 
    private:
     const TwoLevelBitVector &bv_;
     uptr i0_, i1_;

compiler-rt/lib/sanitizer_common/sanitizer_common.h

 
 #include "sanitizer_flags.h"
 #include "sanitizer_interface_internal.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_list.h"
 #include "sanitizer_mutex.h"
 
 #if defined(_MSC_VER) && !defined(__clang__)
 extern "C" void _ReadWriteBarrier();
 #pragma intrinsic(_ReadWriteBarrier)
 #endif
 
 namespace __sanitizer {
 
 struct AddressInfo;
 struct BufferedStackTrace;

 // Passing NULL removes the callback.
 void SetLowLevelAllocateCallback(LowLevelAllocateCallback callback);
 
 // IO
 void CatastrophicErrorWrite(const char *buffer, uptr length);
 void RawWrite(const char *buffer);
 bool ColorizeReports();
 void RemoveANSIEscapeSequencesFromString(char *buffer);
-void Printf(const char *format, ...);
-void Report(const char *format, ...);
-void SetPrintfAndReportCallback(void (*callback)(const char *));
-#define VReport(level, ...)                                              \
-  do {                                                                   \
-    if ((uptr)Verbosity() >= (level)) Report(__VA_ARGS__); \
-  } while (0)
-#define VPrintf(level, ...)                                              \
-  do {                                                                   \
-    if ((uptr)Verbosity() >= (level)) Printf(__VA_ARGS__); \
-  } while (0)
 
 // Lock sanitizer error reporting and protects against nested errors.
 class ScopedErrorReportLock {
  public:
   ScopedErrorReportLock();
   ~ScopedErrorReportLock();
 
   static void CheckLocked();

compiler-rt/lib/sanitizer_common/sanitizer_common.cc

 
 #include "sanitizer_common.h"
 #include "sanitizer_allocator_interface.h"
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_atomic.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 const char *SanitizerToolName = "SanitizerTool";
 
 atomic_uint32_t current_verbosity;
 uptr PageSizeCached;
 u32 NumberOfCPUsCached;

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

 //   COMMON_INTERCEPTOR_STRNDUP_IMPL
 //===----------------------------------------------------------------------===//
 
 #include "interception/interception.h"
 #include "sanitizer_addrhashmap.h"
 #include "sanitizer_errno.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_platform_interceptors.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_symbolizer.h"
 #include "sanitizer_tls_get_addr.h"
 
 #include <stdarg.h>
 
 #if SANITIZER_INTERCEPTOR_HOOKS
 #define CALL_WEAK_INTERCEPTOR_HOOK(f, ...) f(__VA_ARGS__);
 #define DECLARE_WEAK_INTERCEPTOR_HOOK(f, ...) \

compiler-rt/lib/sanitizer_common/sanitizer_common_libcdep.cc

 //===-- sanitizer_common_libcdep.cc ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_allocator_interface.h"
 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 
-
 namespace __sanitizer {
 
 static void (*SoftRssLimitExceededCallback)(bool exceeded);
 void SetSoftRssLimitExceededCallback(void (*Callback)(bool exceeded)) {
   CHECK_EQ(SoftRssLimitExceededCallback, nullptr);
   SoftRssLimitExceededCallback = Callback;
 }
 

compiler-rt/lib/sanitizer_common/sanitizer_common_nolibc.cc

 //===-- sanitizer_common_nolibc.cc ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains stubs for libc function to facilitate optional use of
 // libc in no-libcdep sources.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 #include "sanitizer_common.h"
 #include "sanitizer_libc.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 // The Windows implementations of these functions use the win32 API directly,
 // bypassing libc.
 #if !SANITIZER_WINDOWS
 #if SANITIZER_LINUX
 void LogMessageOnPrintf(const char *str) {}

compiler-rt/lib/sanitizer_common/sanitizer_coverage_fuchsia.cc

 // data out to somewhere that it can be fed into the sancov tool (where and
 // how is not our problem).
 
 #include "sanitizer_platform.h"
 #if SANITIZER_FUCHSIA
 #include "sanitizer_atomic.h"
 #include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_symbolizer_fuchsia.h"
 
 #include <zircon/process.h>
 #include <zircon/sanitizer.h>
 #include <zircon/syscalls.h>
 
 using namespace __sanitizer;  // NOLINT
 

compiler-rt/lib/sanitizer_common/sanitizer_coverage_libcdep_new.cc

 #include "sanitizer_platform.h"
 
 #if !SANITIZER_FUCHSIA
 #include "sancov_flags.h"
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_atomic.h"
 #include "sanitizer_common.h"
 #include "sanitizer_file.h"
+#include "sanitizer_printf.h"
 
 using namespace __sanitizer;
 
 using AddressRange = LoadedModule::AddressRange;
 
 namespace __sancov {
 namespace {
 

compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_DEADLOCK_DETECTOR_H
 #define SANITIZER_DEADLOCK_DETECTOR_H
 
 #include "sanitizer_bvgraph.h"
 #include "sanitizer_common.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 // Thread-local state for DeadlockDetector.
 // It contains the locks currently held by the owning thread.
 template <class BV>
 class DeadlockDetectorTLS {
  public:
uptr addEdges(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, u32 stk,
     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;
       }
     }
     return n_added_edges;
   }
 
   bool findEdge(uptr from_node, uptr to_node, u32 *stk_from, u32 *stk_to,
                 int *unique_tid) {
     uptr from_idx = nodeToIndex(from_node);
     uptr to_idx = nodeToIndex(to_node);
     for (uptr i = 0; i < n_edges_; i++) {

compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector1.cc

 //===-- sanitizer_deadlock_detector1.cc -----------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Deadlock detector implementation based on NxN adjacency bit matrix.
 //
 //===----------------------------------------------------------------------===//
 
-#include "sanitizer_deadlock_detector_interface.h"
-#include "sanitizer_deadlock_detector.h"
 #include "sanitizer_allocator_internal.h"
-#include "sanitizer_placement_new.h"
+#include "sanitizer_deadlock_detector.h"
+#include "sanitizer_deadlock_detector_interface.h"
 #include "sanitizer_mutex.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_printf.h"
 
 #if SANITIZER_DEADLOCK_DETECTOR_VERSION == 1
 
 namespace __sanitizer {
 
 typedef TwoLevelBitVector<> DDBV;  // DeadlockDetector's bit vector.
 
 struct DDPhysicalThread {

compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector2.cc

 //===-- sanitizer_deadlock_detector2.cc -----------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Deadlock detector implementation based on adjacency lists.
 //
 //===----------------------------------------------------------------------===//
 
-#include "sanitizer_deadlock_detector_interface.h"
-#include "sanitizer_common.h"
 #include "sanitizer_allocator_internal.h"
-#include "sanitizer_placement_new.h"
+#include "sanitizer_common.h"
+#include "sanitizer_deadlock_detector_interface.h"
 #include "sanitizer_mutex.h"
+#include "sanitizer_placement_new.h"
+#include "sanitizer_printf.h"
 
 #if SANITIZER_DEADLOCK_DETECTOR_VERSION == 2
 
 namespace __sanitizer {
 
 const int kMaxNesting = 64;
 const u32 kNoId = -1;
 const u32 kEndId = -2;

compiler-rt/lib/sanitizer_common/sanitizer_file.cc

 //===---------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 
 #if !SANITIZER_FUCHSIA
 
 #include "sanitizer_common.h"
 #include "sanitizer_file.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 void CatastrophicErrorWrite(const char *buffer, uptr length) {
   WriteToFile(kStderrFd, buffer, length);
 }
 
 StaticSpinMutex report_file_mu;

compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.h

 //===-- sanitizer_flag_parser.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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_FLAG_REGISTRY_H
 #define SANITIZER_FLAG_REGISTRY_H
 
+#include "sanitizer_common.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
-#include "sanitizer_common.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 class FlagHandlerBase {
  public:
   virtual bool Parse(const char *value) { return false; }
 
  protected:

compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.cc

 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_flag_parser.h"
 
 #include "sanitizer_common.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_flag_parser.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 LowLevelAllocator FlagParser::Alloc;
 
 class UnknownFlags {
   static const int kMaxUnknownFlags = 20;
   const char *unknown_flags_[kMaxUnknownFlags];

compiler-rt/lib/sanitizer_common/sanitizer_fuchsia.cc

 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_fuchsia.h"
 #if SANITIZER_FUCHSIA
 
 #include "sanitizer_common.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_mutex.h"
+#include "sanitizer_printf.h"
 
 #include <limits.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <zircon/errors.h>
 #include <zircon/process.h>
 #include <zircon/syscalls.h>

compiler-rt/lib/sanitizer_common/sanitizer_libignore.cc

 //===-- sanitizer_libignore.cc --------------------------------------------===//
 //
 // 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 "sanitizer_platform.h"
 
 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC || \
     SANITIZER_NETBSD || SANITIZER_OPENBSD
 
-#include "sanitizer_libignore.h"
 #include "sanitizer_flags.h"
+#include "sanitizer_libignore.h"
 #include "sanitizer_posix.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 
 namespace __sanitizer {
 
 LibIgnore::LibIgnore(LinkerInitialized) {
 }
 
 void LibIgnore::AddIgnoredLibrary(const char *name_templ) {

compiler-rt/lib/sanitizer_common/sanitizer_linux.cc

 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_getauxval.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_linux.h"
 #include "sanitizer_mutex.h"
 #include "sanitizer_placement_new.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 
 #if SANITIZER_LINUX
 #include <asm/param.h>
 #endif
 
 // For mips64, syscall(__NR_stat) fills the buffer in the 'struct kernel_stat'
 // format. Struct kernel_stat is defined as 'struct stat' in asm/stat.h. To

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cc

 #include "sanitizer_atomic.h"
 #include "sanitizer_common.h"
 #include "sanitizer_file.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_freebsd.h"
 #include "sanitizer_getauxval.h"
 #include "sanitizer_linux.h"
 #include "sanitizer_placement_new.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 
 #include <dlfcn.h>  // for dlsym()
 #include <link.h>
 #include <pthread.h>
 #include <signal.h>
 #include <sys/resource.h>
 #include <syslog.h>

compiler-rt/lib/sanitizer_common/sanitizer_linux_s390.cc

 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 
 #if SANITIZER_LINUX && SANITIZER_S390
 
 #include "sanitizer_libc.h"
 #include "sanitizer_linux.h"
+#include "sanitizer_printf.h"
 
 #include <errno.h>
 #include <sys/syscall.h>
 #include <sys/utsname.h>
 #include <unistd.h>
 
 namespace __sanitizer {
 

compiler-rt/lib/sanitizer_common/sanitizer_mac.cc

 
 #include "sanitizer_common.h"
 #include "sanitizer_file.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_platform_limits_posix.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 
 #if !SANITIZER_IOS
 #include <crt_externs.h>  // for _NSGetEnviron
 #else
 extern char **environ;
 #endif
 

compiler-rt/lib/sanitizer_common/sanitizer_netbsd.cc

 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_getauxval.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_linux.h"
 #include "sanitizer_mutex.h"
 #include "sanitizer_placement_new.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 
 #include <sys/param.h>
 #include <sys/types.h>
 
 #include <sys/exec.h>
 #include <sys/mman.h>
 #include <sys/ptrace.h>

compiler-rt/lib/sanitizer_common/sanitizer_openbsd.cc

 #include <stdio.h>
 
 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_platform_limits_posix.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <pthread.h>
 #include <sched.h>
 #include <signal.h>

compiler-rt/lib/sanitizer_common/sanitizer_posix.cc

 
 #if SANITIZER_POSIX
 
 #include "sanitizer_common.h"
 #include "sanitizer_file.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_posix.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <sys/mman.h>
 
 #if SANITIZER_FREEBSD

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cc

 
 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_platform_limits_netbsd.h"
 #include "sanitizer_platform_limits_openbsd.h"
 #include "sanitizer_platform_limits_posix.h"
 #include "sanitizer_platform_limits_solaris.h"
 #include "sanitizer_posix.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/mman.h>

compiler-rt/lib/sanitizer_common/sanitizer_printf.h

+//===-- sanitizer_printf.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 SANITIZER_PRINTF_H
+#define SANITIZER_PRINTF_H
+
+namespace __sanitizer {
+
+void Printf(const char *format, ...);
+void Report(const char *format, ...);
+void SetPrintfAndReportCallback(void (*callback)(const char *));
+#define VReport(level, ...)                                              \
+  do {                                                                   \
+    if ((uptr)Verbosity() >= (level)) Report(__VA_ARGS__); \
+  } while (0)
+#define VPrintf(level, ...)                                              \
+  do {                                                                   \
+    if ((uptr)Verbosity() >= (level)) Printf(__VA_ARGS__); \
+  } while (0)
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_PRINTF_H

compiler-rt/lib/sanitizer_common/sanitizer_printf.cc

 // Internal printf function, used inside run-time libraries.
 // We can't use libc printf because we intercept some of the functions used
 // inside it.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_libc.h"
+#include "sanitizer_printf.h"
 
 #include <stdio.h>
 #include <stdarg.h>
 
 #if SANITIZER_WINDOWS && defined(_MSC_VER) && _MSC_VER < 1800 &&               \
       !defined(va_copy)
 # define va_copy(dst, src) ((dst) = (src))
 #endif

 FORMAT(1, 2)
 void Printf(const char *format, ...) {
   va_list args;
   va_start(args, format);
   SharedPrintfCode(false, format, args);
   va_end(args);
 }
 
+void VariadicPrintf(const char *format, va_list ap) {
+  SharedPrintfCode(false, format, ap);
+}
+
 // Like Printf, but prints the current PID before the output string.
 FORMAT(1, 2)
 void Report(const char *format, ...) {
   va_list args;
   va_start(args, format);
   SharedPrintfCode(true, format, args);
   va_end(args);
 }

compiler-rt/lib/sanitizer_common/sanitizer_quarantine.h

 // oldest memory is recycled.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_QUARANTINE_H
 #define SANITIZER_QUARANTINE_H
 
 #include "sanitizer_internal_defs.h"
-#include "sanitizer_mutex.h"
 #include "sanitizer_list.h"
+#include "sanitizer_mutex.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 template<typename Node> class QuarantineCache;
 
 struct QuarantineBatch {
   static const uptr kSize = 1021;
   QuarantineBatch *next;

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cc

 //===-- sanitizer_stacktrace_libcdep.cc -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common.h"
 #include "sanitizer_placement_new.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_stacktrace.h"
 #include "sanitizer_stacktrace_printer.h"
 #include "sanitizer_symbolizer.h"
 
 namespace __sanitizer {
 
 void StackTrace::Print() const {
   if (trace == nullptr || size == 0) {

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cc

 //===-- sanitizer_common.cc -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between sanitizers' run-time libraries.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_stacktrace_printer.h"
 #include "sanitizer_file.h"
 #include "sanitizer_fuchsia.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 // sanitizer_symbolizer_markup.cc implements these differently.
 #if !SANITIZER_SYMBOLIZER_MARKUP
 
 static const char *StripFunctionName(const char *function, const char *prefix) {
   if (!function) return nullptr;

compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

 #endif
 
 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_linux.h"
 #include "sanitizer_mutex.h"
 #include "sanitizer_placement_new.h"
+#include "sanitizer_printf.h"
 
 // Sufficiently old kernel headers don't provide this value, but we can still
 // call prctl with it. If the runtime kernel is new enough, the prctl call will
 // have the desired effect; if the kernel is too old, the call will error and we
 // can ignore said error.
 #ifndef PR_SET_PTRACER
 #define PR_SET_PTRACER 0x59616d61
 #endif

compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld_mac.cc

 
 #if SANITIZER_MAC && (defined(__x86_64__) || defined(__aarch64__) || \
                       defined(__i386))
 
 #include <mach/mach.h>
 #include <mach/thread_info.h>
 #include <pthread.h>
 
+#include "sanitizer_printf.h"
 #include "sanitizer_stoptheworld.h"
 
 namespace __sanitizer {
 typedef struct {
   tid_t tid;
   thread_t thread;
 } SuspendedThreadInfo;
 

compiler-rt/lib/sanitizer_common/sanitizer_suppressions.cc

 //===-- sanitizer_suppressions.cc -----------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Suppression parsing/matching code.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_suppressions.h"
 
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_common.h"
-#include "sanitizer_flags.h"
 #include "sanitizer_file.h"
+#include "sanitizer_flags.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_placement_new.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 SuppressionContext::SuppressionContext(const char *suppression_types[],
                                        int suppression_types_num)
     : suppression_types_(suppression_types),
       suppression_types_num_(suppression_types_num),
       can_parse_(true) {

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc

 //===-- sanitizer_symbolizer_libcdep.cc -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_internal_defs.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_symbolizer_internal.h"
 
 namespace __sanitizer {
 
 Symbolizer *Symbolizer::GetOrInit() {
   SpinMutexLock l(&init_mu_);
   if (symbolizer_)
     return symbolizer_;

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc

 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_common.h"
 #include "sanitizer_file.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_linux.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_posix.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 #include "sanitizer_symbolizer_internal.h"
 #include "sanitizer_symbolizer_libbacktrace.h"
 #include "sanitizer_symbolizer_mac.h"
 
 #include <dlfcn.h>   // for dlsym()
 #include <errno.h>
 #include <stdint.h>

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_report.cc

 //===-- sanitizer_symbolizer_report.cc ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// This file is shared between AddressSanitizer and other sanitizer run-time
 /// libraries and implements symbolized reports related functions.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common.h"
 #include "sanitizer_file.h"
 #include "sanitizer_flags.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_procmaps.h"
 #include "sanitizer_report_decorator.h"
 #include "sanitizer_stacktrace.h"
 #include "sanitizer_stacktrace_printer.h"
 #include "sanitizer_symbolizer.h"
 
 #if SANITIZER_POSIX
 # include "sanitizer_posix.h"

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_win.cc

 // run-time libraries.
 // Windows-specific implementation of symbolizer parts.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 #if SANITIZER_WINDOWS
 
 #include "sanitizer_dbghelp.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_symbolizer_internal.h"
 
 namespace __sanitizer {
 
 decltype(::StackWalk64) *StackWalk64;
 decltype(::SymCleanup) *SymCleanup;
 decltype(::SymFromAddr) *SymFromAddr;
 decltype(::SymFunctionTableAccess64) *SymFunctionTableAccess64;

compiler-rt/lib/sanitizer_common/sanitizer_termination.cc

 //===-- sanitizer_termination.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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// This file contains the Sanitizer termination functions CheckFailed and Die,
 /// and the callback functionalities associated with them.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common.h"
 #include "sanitizer_libc.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 
 static const int kMaxNumOfInternalDieCallbacks = 5;
 static DieCallbackType InternalDieCallbacks[kMaxNumOfInternalDieCallbacks];
 
 bool AddDieCallback(DieCallbackType callback) {
   for (int i = 0; i < kMaxNumOfInternalDieCallbacks; i++) {

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cc

 //===-- sanitizer_thread_registry.cc --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between sanitizer tools.
 //
 // General thread bookkeeping functionality.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_thread_registry.h"
 
+#include "sanitizer_printf.h"
+
 namespace __sanitizer {
 
 ThreadContextBase::ThreadContextBase(u32 tid)
     : tid(tid), unique_id(0), reuse_count(), os_id(0), user_id(0),
       status(ThreadStatusInvalid), detached(false),
       thread_type(ThreadType::Regular), parent_tid(0), next(0) {
   name[0] = '\0';
   atomic_store(&thread_destroyed, 0, memory_order_release);

compiler-rt/lib/sanitizer_common/sanitizer_tls_get_addr.cc

 //===-- sanitizer_tls_get_addr.cc -----------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Handle the __tls_get_addr call.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_tls_get_addr.h"
 
 #include "sanitizer_flags.h"
 #include "sanitizer_platform_interceptors.h"
+#include "sanitizer_printf.h"
 
 namespace __sanitizer {
 #if SANITIZER_INTERCEPT_TLS_GET_ADDR
 
 // The actual parameter that comes to __tls_get_addr
 // is a pointer to a struct with two words in it:
 struct TlsGetAddrParam {
   uptr dso_id;

compiler-rt/lib/sanitizer_common/sanitizer_unwind_linux_libcdep.cc

 //===-- sanitizer_unwind_linux_libcdep.cc ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the unwind.h-based (aka "slow") stack unwinding routines
 // available to the tools on Linux, Android, NetBSD, FreeBSD, and Solaris.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
     SANITIZER_SOLARIS
 #include "sanitizer_common.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_stacktrace.h"
 
 #if SANITIZER_ANDROID
 #include <dlfcn.h>  // for dlopen()
 #endif
 
 #if SANITIZER_FREEBSD
 #define _GNU_SOURCE  // to declare _Unwind_Backtrace() from <unwind.h>

compiler-rt/lib/sanitizer_common/sanitizer_variadic_printf.h

+//===-- sanitizer_variadic_printf.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 SANITIZER_VARIADIC_PRINTF_H
+#define SANITIZER_VARIADIC_PRINTF_H
+
+// Note: This file contains the variadic version of printf, so that general
+// dependencies on santiier_printf.h do not have to transiently depend on
+// <stdarg.h>.
+
+#include <stdarg.h>
+
+namespace __sanitizer {
+void VariadicPrintf(const char *format, va_list ap);
+} // namespace __sanitizer
+
+#endif // SANITIZER_VARIADIC_PRINTF_H

compiler-rt/lib/sanitizer_common/sanitizer_win.cc

 #include <psapi.h>
 #include <stdlib.h>
 
 #include "sanitizer_common.h"
 #include "sanitizer_file.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_mutex.h"
 #include "sanitizer_placement_new.h"
+#include "sanitizer_printf.h"
 #include "sanitizer_win_defs.h"
 
 #if defined(PSAPI_VERSION) && PSAPI_VERSION == 1
 #pragma comment(lib, "psapi")
 #endif
 #if SANITIZER_WIN_TRACE
 #include <traceloggingprovider.h>
 //  Windows trace logging provider init

compiler-rt/lib/sanitizer_common/tests/sanitizer_allocator_testlib.cc

  sanitizer_common/tests/sanitizer_allocator_testlib.cc \
  $(\ls sanitizer_common/sanitizer_*.cc | grep -v sanitizer_common_nolibc.cc) \
   sanitizer_common/sanitizer_linux_x86_64.S \
  -shared -lpthread -o testmalloc.so
 LD_PRELOAD=`pwd`/testmalloc.so /your/app
 */
 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_printf.h"
 #include <stddef.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
 #include <pthread.h>
 
 #ifndef SANITIZER_MALLOC_HOOK
 # define SANITIZER_MALLOC_HOOK(p, s)

compiler-rt/lib/sanitizer_common/tests/sanitizer_format_interceptor_test.cc

 //===----------------------------------------------------------------------===//
 #include <algorithm>
 #include <vector>
 
 #include "interception/interception.h"
 #include "sanitizer_test_utils.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_printf.h"
 #include "gtest/gtest.h"
 
 using namespace __sanitizer;
 
 #define COMMON_INTERCEPTOR_READ_WRITE_RANGE(ctx, ptr, size)                    \
   do {                                                                         \
     ((std::vector<unsigned> *)ctx)->push_back(size);                           \
     ptr = ptr;                                                                 \

compiler-rt/lib/sanitizer_common/tests/sanitizer_ioctl_test.cc

 
 #include <linux/input.h>
 #include <vector>
 
 #include "interception/interception.h"
 #include "sanitizer_test_utils.h"
 #include "sanitizer_common/sanitizer_platform_limits_posix.h"
 #include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_printf.h"
 #include "gtest/gtest.h"
 
 
 using namespace __sanitizer;
 
 #define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, sz) \
   do {                                              \
     (void) ctx;                                     \

compiler-rt/lib/stats/stats.cc

 //===-- stats.cc ----------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Sanitizer statistics gathering. Manages statistics for a process and is
 // responsible for writing the report file.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_file.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_printf.h"
 #if SANITIZER_POSIX
 #include "sanitizer_common/sanitizer_posix.h"
 #endif
 #include "sanitizer_common/sanitizer_symbolizer.h"
 #include "stats/stats.h"
 #if SANITIZER_POSIX
 #include <signal.h>
 #endif

compiler-rt/lib/tsan/rtl/tsan_dense_alloc.h

 // allocates/free indices of objects and provide a functionality to map
 // the index onto the real pointer. The index is u32, that is, 2 times smaller
 // than uptr (hense the Dense prefix).
 //===----------------------------------------------------------------------===//
 #ifndef TSAN_DENSE_ALLOC_H
 #define TSAN_DENSE_ALLOC_H
 
 #include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_printf.h"
 #include "tsan_defs.h"
 #include "tsan_mutex.h"
 
 namespace __tsan {
 
 class DenseSlabAllocCache {
   static const uptr kSize = 128;
   typedef u32 IndexT;

compiler-rt/lib/ubsan/ubsan_diag.cc

 
 #include "ubsan_platform.h"
 #if CAN_SANITIZE_UB
 #include "ubsan_diag.h"
 #include "ubsan_init.h"
 #include "ubsan_flags.h"
 #include "ubsan_monitor.h"
 #include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_printf.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;

compiler-rt/lib/xray/xray_allocator.h

 //
 //===----------------------------------------------------------------------===//
 #ifndef XRAY_ALLOCATOR_H
 #define XRAY_ALLOCATOR_H
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_mutex.h"
+#include "sanitizer_common/sanitizer_printf.h"
 #if SANITIZER_FUCHSIA
 #include <zircon/process.h>
 #include <zircon/status.h>
 #include <zircon/syscalls.h>
 #else
 #include "sanitizer_common/sanitizer_posix.h"
 #endif
 #include "xray_defs.h"

compiler-rt/lib/xray/xray_x86_64.cc

 #include "cpuid.h"
 #include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_printf.h"
 #if !SANITIZER_FUCHSIA
 #include "sanitizer_common/sanitizer_posix.h"
 #endif
 #include "xray_defs.h"
 #include "xray_interface_internal.h"
 
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD || SANITIZER_MAC
 #include <sys/types.h>