[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

257 ↗

(On Diff #196356)

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

257 ↗

(On Diff #196356)

Done in rL359150.

[kcc]

compiler-rt/lib/sanitizer_common/sanitizer_printf.h

12 ↗

(On Diff #196541)

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

12 ↗

(On Diff #196541)

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 ↗

(On Diff #196552)

few more?

compiler-rt/lib/sanitizer_common/sanitizer_variadic_printf.h

19 ↗

(On Diff #196552)

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/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"
 
+#include <stdarg.h>
+
 #if defined(_MSC_VER) && !defined(__clang__)
 extern "C" void _ReadWriteBarrier();
 #pragma intrinsic(_ReadWriteBarrier)
 #endif
 
 namespace __sanitizer {
 
 struct AddressInfo;

 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 VariadicPrintf(const char *format, va_list ap);
 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 {                                                                   \

compiler-rt/lib/sanitizer_common/sanitizer_printf.cc

 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);
 }