[scudo] Allow options to be defined at compile time

[cryptoad]

Summary

Allow for options to be defined at compile time, like is already the case for
other sanitizers, via SCUDO_DEFAULT_OPTIONS.

[alekseyshl]

lib/scudo/scudo_flags.cpp

40

Remove this extraneous comment.

43

Totally a nit, but maybe undef SCUDO_STRINGIZE and SCUDO_STRINGIZE_OPTIONS here, as we do with SCUDO_FLAG above?

Maybe it's time to have this definition in common and use it everywhere:
#define SANITIZER_STRINGIFY_(S) #S
#define SANITIZER_STRINGIFY(S) SANITIZER_STRINGIFY_(S)

[cryptoad]

lib/scudo/scudo_flags.cpp

43

I'm going to move it to common.
Current users of the macro would be ASan (flags), XRay (flags), Scudo (flags) and TSan (setjmp symbols).

[cryptoad]

Introduce a SANITIZER_STRINGIFY macro in sanitizer_internal_defs.h, used
by the various flags parsers (ASan, Scudo, XRay).

[alekseyshl]

What about TSan setjmp?

lib/asan/asan_flags.cc

35–36

Remove this comment.

[cryptoad]

Replace TSAN_STRING_SETJMP__ (forgotten on the first go).
Removed an extraneous comment.

Edit: wrong macro name.

[dberris]

LGTM for XRay.

lib/asan/asan_flags.cc

 
 Flags asan_flags_dont_use_directly;  // use via flags().
 
 static const char *MaybeCallAsanDefaultOptions() {
   return (&__asan_default_options) ? __asan_default_options() : "";
 }
 
 static const char *MaybeUseAsanDefaultOptionsCompileDefinition() {
 #ifdef ASAN_DEFAULT_OPTIONS
-// Stringize the macro value.
-# define ASAN_STRINGIZE(x) #x
-# define ASAN_STRINGIZE_OPTIONS(options) ASAN_STRINGIZE(options)
-  return ASAN_STRINGIZE_OPTIONS(ASAN_DEFAULT_OPTIONS);
+  return SANITIZER_STRINGIFY(ASAN_DEFAULT_OPTIONS);
 #else
   return "";
 #endif
 }
 
 void Flags::SetDefaults() {
 #define ASAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
 #include "asan_flags.inc"

lib/sanitizer_common/sanitizer_internal_defs.h

 #define SANITIZER_DEFS_H
 
 #include "sanitizer_platform.h"
 
 #ifndef SANITIZER_DEBUG
 # define SANITIZER_DEBUG 0
 #endif
 
+#define SANITIZER_STRINGIFY_(S) #S
+#define SANITIZER_STRINGIFY(S) SANITIZER_STRINGIFY_(S)
+
 // Only use SANITIZER_*ATTRIBUTE* before the function return type!
 #if SANITIZER_WINDOWS
 #if SANITIZER_IMPORT_INTERFACE
 # define SANITIZER_INTERFACE_ATTRIBUTE __declspec(dllimport)
 #else
 # define SANITIZER_INTERFACE_ATTRIBUTE __declspec(dllexport)
 #endif
 # define SANITIZER_WEAK_ATTRIBUTE

lib/scudo/scudo_flags.cpp

 
 static void RegisterScudoFlags(FlagParser *parser, Flags *f) {
 #define SCUDO_FLAG(Type, Name, DefaultValue, Description) \
   RegisterFlag(parser, #Name, Description, &f->Name);
 #include "scudo_flags.inc"
 #undef SCUDO_FLAG
 }
 
+static const char *getCompileDefinitionScudoDefaultOptions() {
+#ifdef SCUDO_DEFAULT_OPTIONS
+  return SANITIZER_STRINGIFY(SCUDO_DEFAULT_OPTIONS);
+#else
+  return "";
+#endif
+}
+
 static const char *getScudoDefaultOptions() {
   return (&__scudo_default_options) ? __scudo_default_options() : "";
 }
 
 void initFlags() {
   SetCommonFlagsDefaults();
   {
     CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.exitcode = 1;
     OverrideCommonFlags(cf);
   }
   Flags *f = getFlags();
   f->setDefaults();
 
   FlagParser ScudoParser;
   RegisterScudoFlags(&ScudoParser, f);
   RegisterCommonFlags(&ScudoParser);
 
+  // Override from compile definition.
+  ScudoParser.ParseString(getCompileDefinitionScudoDefaultOptions());
+
   // Override from user-specified string.
   ScudoParser.ParseString(getScudoDefaultOptions());
 
   // Override from environment.
   ScudoParser.ParseString(GetEnv("SCUDO_OPTIONS"));
 
   InitializeCommonFlags();
 

lib/tsan/rtl/tsan_interceptors.cc

 #define sigsetjmp_symname sigsetjmp
 #endif
 
 #define TSAN_INTERCEPTOR_SETJMP_(x) __interceptor_ ## x
 #define TSAN_INTERCEPTOR_SETJMP__(x) TSAN_INTERCEPTOR_SETJMP_(x)
 #define TSAN_INTERCEPTOR_SETJMP TSAN_INTERCEPTOR_SETJMP__(setjmp_symname)
 #define TSAN_INTERCEPTOR_SIGSETJMP TSAN_INTERCEPTOR_SETJMP__(sigsetjmp_symname)
 
-#define TSAN_STRING_SETJMP_(x) # x
-#define TSAN_STRING_SETJMP__(x) TSAN_STRING_SETJMP_(x)
-#define TSAN_STRING_SETJMP TSAN_STRING_SETJMP__(setjmp_symname)
-#define TSAN_STRING_SIGSETJMP TSAN_STRING_SETJMP__(sigsetjmp_symname)
+#define TSAN_STRING_SETJMP SANITIZER_STRINGIFY(setjmp_symname)
+#define TSAN_STRING_SIGSETJMP SANITIZER_STRINGIFY(sigsetjmp_symname)
 
 // Not called.  Merely to satisfy TSAN_INTERCEPT().
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE
 int TSAN_INTERCEPTOR_SETJMP(void *env);
 extern "C" int TSAN_INTERCEPTOR_SETJMP(void *env) {
   CHECK(0);
   return 0;
 }

lib/xray/xray_flags.cc

 // defaults that override the hard-coded defaults in the xray_flags.inc at
 // compile-time using the XRAY_DEFAULT_OPTIONS macro.
 static const char *useCompilerDefinedFlags() XRAY_NEVER_INSTRUMENT {
 #ifdef XRAY_DEFAULT_OPTIONS
 // Do the double-layered string conversion to prevent badly crafted strings
 // provided through the XRAY_DEFAULT_OPTIONS from causing compilation issues (or
 // changing the semantics of the implementation through the macro). This ensures
 // that we convert whatever XRAY_DEFAULT_OPTIONS is defined as a string literal.
-#define XRAY_STRINGIZE(x) #x
-#define XRAY_STRINGIZE_OPTIONS(options) XRAY_STRINGIZE(options)
-  return XRAY_STRINGIZE_OPTIONS(XRAY_DEFAULT_OPTIONS);
+  return SANITIZER_STRINGIFY(XRAY_DEFAULT_OPTIONS);
 #else
   return "";
 #endif
 }
 
 void initializeFlags() XRAY_NEVER_INSTRUMENT {
   SetCommonFlagsDefaults();
   auto *F = flags();