ubsan: Allow programs to use setenv to configure ubsan_standalone.

[pcc]

Summary

Previously ubsan_standalone used the GetEnv function to read the
environment variables UBSAN_OPTIONS and UBSAN_SYMBOLIZER_PATH. The
problem with GetEnv is that it does not respect changes to the
environment variables made using the libc setenv function, which
prevents clients from setting environment variables to configure
ubsan before loading ubsan-instrumented libraries.

The reason why we have GetEnv is that some runtimes need to read
environment variables while they initialize using .preinit_array,
and getenv does not work while .preinit_array functions are being
called. However, it is unnecessary for ubsan_standalone to initialize
that early. So this change switches ubsan_standalone to using getenv
and removes the .preinit_array entry. The static version of the runtime
still ends up being initialized using a C++ constructor that exists
to support the shared runtime.

[vitalybuka]

we have interceptors for nicer support of deadly signals, so probably we'd like to install them ASAP
also there is weak __ubsan_default_options() which can be used instead of setenv

[vitalybuka]

it was added here https://reviews.llvm.org/rL213983

[pcc]

In D39827#920047, @vitalybuka wrote:

we have interceptors for nicer support of deadly signals, so probably we'd like to install them ASAP

I'm not sure if that is too important, especially since a user has the choice of using (e.g.) ubsan+asan if they want early interception of signals.

also there is weak __ubsan_default_options() which can be used instead of setenv

That won't always work. I'm thinking about the Android app use case where you may have multiple ubsan-instrumented libraries and a main program written in another language that wants to configure the runtime.

it was added here https://reviews.llvm.org/rL213983

I found that change, but it does not explain why ubsan would want .preinit_array specifically instead of .init_array (aside from consistency with other sanitizers).

[vitalybuka]

Then I don't have anything particular against this patch.

compiler-rt/trunk/lib/ubsan/CMakeLists.txt

add_compiler_rt_object_libraries(RTUbsan_standalone
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       SOURCES ${UBSAN_STANDALONE_SOURCES}
       CFLAGS ${UBSAN_STANDALONE_CFLAGS})
 
     # Standalone UBSan runtimes.
     add_compiler_rt_runtime(clang_rt.ubsan_standalone
       STATIC
       ARCHS ${UBSAN_SUPPORTED_ARCH}
-      SOURCES ubsan_init_standalone_preinit.cc
       OBJECT_LIBS RTSanitizerCommon
               RTSanitizerCommonLibc
               RTUbsan
               RTUbsan_standalone
               RTInterception
       CFLAGS ${UBSAN_CFLAGS}
       PARENT_TARGET ubsan)
 

compiler-rt/trunk/lib/ubsan/ubsan_flags.cc

 
 #include "ubsan_platform.h"
 #if CAN_SANITIZE_UB
 #include "ubsan_flags.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_flag_parser.h"
 
+#include <stdlib.h>
+
 namespace __ubsan {
 
 const char *MaybeCallUbsanDefaultOptions() {
   return (&__ubsan_default_options) ? __ubsan_default_options() : "";
 }
 
 Flags ubsan_flags;
 

 }
 
 void InitializeFlags() {
   SetCommonFlagsDefaults();
   {
     CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.print_summary = false;
-    cf.external_symbolizer_path = GetEnv("UBSAN_SYMBOLIZER_PATH");
+    cf.external_symbolizer_path = getenv("UBSAN_SYMBOLIZER_PATH");
     OverrideCommonFlags(cf);
   }
 
   Flags *f = flags();
   f->SetDefaults();
 
   FlagParser parser;
   RegisterCommonFlags(&parser);
   RegisterUbsanFlags(&parser, f);
 
   // Override from user-specified string.
   parser.ParseString(MaybeCallUbsanDefaultOptions());
   // Override from environment variable.
-  parser.ParseString(GetEnv("UBSAN_OPTIONS"));
+  parser.ParseString(getenv("UBSAN_OPTIONS"));
   InitializeCommonFlags();
   if (Verbosity()) ReportUnrecognizedFlags();
 
   if (common_flags()->help) parser.PrintFlagDescriptions();
 }
 
 }  // namespace __ubsan
 
 SANITIZER_INTERFACE_WEAK_DEF(const char *, __ubsan_default_options, void) {
   return "";
 }
 
 #endif  // CAN_SANITIZE_UB

compiler-rt/trunk/lib/ubsan/ubsan_init_standalone_preinit.cc

-//===-- ubsan_init_standalone_preinit.cc
-//------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// Initialization of standalone UBSan runtime.
-//
-//===----------------------------------------------------------------------===//
-
-#include "ubsan_platform.h"
-#if !CAN_SANITIZE_UB
-#error "UBSan is not supported on this platform!"
-#endif
-
-#include "sanitizer_common/sanitizer_internal_defs.h"
-#include "ubsan_init.h"
-#include "ubsan_signals_standalone.h"
-
-#if SANITIZER_CAN_USE_PREINIT_ARRAY
-
-namespace __ubsan {
-
-static void PreInitAsStandalone() {
-  InitAsStandalone();
-  InitializeDeadlySignals();
-}
-
-} // namespace __ubsan
-
-__attribute__((section(".preinit_array"), used)) void (*__local_ubsan_preinit)(
-    void) = __ubsan::PreInitAsStandalone;
-#endif // SANITIZER_CAN_USE_PREINIT_ARRAY