[clang] Update clang driver to include san_common to compiler-rt libraries when necessary.

[mpividori]

Summary

This diff include changes to clang Driver related to previous modifications in compiler-rt: https://reviews.llvm.org/D28359

[kcc]

I am not a fan of any such changes as they complicate things further.
Also, will the GCC build system and GCC driver have to change as well?

Does it actually fix any problem that exists today?

[eugenis]

also, what about shared-libasan? Do we split san_common into separate shared library, too?

[mpividori]

Thanks for your comments.
I took a different direction, so I will abandon this diff since I don't need these changes any more.
Thanks.

lib/Driver/Tools.cpp

 static void
 collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
                          SmallVectorImpl<StringRef> &SharedRuntimes,
                          SmallVectorImpl<StringRef> &StaticRuntimes,
                          SmallVectorImpl<StringRef> &NonWholeStaticRuntimes,
                          SmallVectorImpl<StringRef> &HelperStaticRuntimes,
                          SmallVectorImpl<StringRef> &RequiredSymbols) {
   const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
+  bool NeedSanCommon = false;
   // Collect shared runtimes.
   if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
     SharedRuntimes.push_back("asan");
   }
   // The stats_client library is also statically linked into DSOs.
   if (SanArgs.needsStatsRt())
     StaticRuntimes.push_back("stats_client");
 
   // Collect static runtimes.
   if (Args.hasArg(options::OPT_shared) || TC.getTriple().isAndroid()) {
     // Don't link static runtimes into DSOs or if compiling for Android.
     return;
   }
   if (SanArgs.needsAsanRt()) {
     if (SanArgs.needsSharedAsanRt()) {
       HelperStaticRuntimes.push_back("asan-preinit");
     } else {
       StaticRuntimes.push_back("asan");
+      NeedSanCommon = true;
       if (SanArgs.linkCXXRuntimes())
         StaticRuntimes.push_back("asan_cxx");
     }
   }
-  if (SanArgs.needsDfsanRt())
+  if (SanArgs.needsDfsanRt()) {
     StaticRuntimes.push_back("dfsan");
-  if (SanArgs.needsLsanRt())
+    NeedSanCommon = true;
+  }
+  if (SanArgs.needsLsanRt()) {
     StaticRuntimes.push_back("lsan");
+    NeedSanCommon = true;
+  }
   if (SanArgs.needsMsanRt()) {
     StaticRuntimes.push_back("msan");
+    NeedSanCommon = true;
     if (SanArgs.linkCXXRuntimes())
       StaticRuntimes.push_back("msan_cxx");
   }
   if (SanArgs.needsTsanRt()) {
     StaticRuntimes.push_back("tsan");
+    NeedSanCommon = true;
     if (SanArgs.linkCXXRuntimes())
       StaticRuntimes.push_back("tsan_cxx");
   }
   if (SanArgs.needsUbsanRt()) {
     StaticRuntimes.push_back("ubsan_standalone");
+    NeedSanCommon = true;
     if (SanArgs.linkCXXRuntimes())
       StaticRuntimes.push_back("ubsan_standalone_cxx");
   }
   if (SanArgs.needsSafeStackRt())
     StaticRuntimes.push_back("safestack");
-  if (SanArgs.needsCfiRt())
+  if (SanArgs.needsCfiRt()) {
     StaticRuntimes.push_back("cfi");
+    NeedSanCommon = true;
+  }
   if (SanArgs.needsCfiDiagRt()) {
     StaticRuntimes.push_back("cfi_diag");
+    NeedSanCommon = true;
     if (SanArgs.linkCXXRuntimes())
       StaticRuntimes.push_back("ubsan_standalone_cxx");
   }
   if (SanArgs.needsStatsRt()) {
     NonWholeStaticRuntimes.push_back("stats");
+    NeedSanCommon = true;
     RequiredSymbols.push_back("__sanitizer_stats_register");
   }
-  if (SanArgs.needsEsanRt())
+  if (SanArgs.needsEsanRt()) {
     StaticRuntimes.push_back("esan");
+    NeedSanCommon = true;
+  }
+  if (NeedSanCommon)
+    StaticRuntimes.push_back("san_common");
 }
 
 // Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
 // C runtime, etc). Returns true if sanitizer system deps need to be linked in.
 static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
                                  ArgStringList &CmdArgs) {
   SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
       NonWholeStaticRuntimes, HelperStaticRuntimes, RequiredSymbols;

 }
 
 static bool addXRayRuntime(const ToolChain &TC, const ArgList &Args,
                            ArgStringList &CmdArgs) {
   if (Args.hasFlag(options::OPT_fxray_instrument,
                    options::OPT_fnoxray_instrument, false)) {
     CmdArgs.push_back("-whole-archive");
     CmdArgs.push_back(TC.getCompilerRTArgString(Args, "xray", false));
+    CmdArgs.push_back(TC.getCompilerRTArgString(Args, "san_common", false));
     CmdArgs.push_back("-no-whole-archive");
     return true;
   }
   return false;
 }
 
 static void linkXRayRuntimeDeps(const ToolChain &TC, const ArgList &Args,
                                 ArgStringList &CmdArgs) {
if (TC.getSanitizerArgs().needsSharedAsanRt() ||
       // to ensure proper SEH handling.
       CmdArgs.push_back(Args.MakeArgString(
           TC.getArch() == llvm::Triple::x86
               ? "-include:___asan_seh_interceptor"
               : "-include:__asan_seh_interceptor"));
     } else if (DLL) {
       CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
     } else {
-      for (const auto &Lib : {"asan", "asan_cxx"})
+      for (const auto &Lib : {"asan", "asan_cxx", "san_common"})
         CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
     }
   }
 
   Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
 
   if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
                    options::OPT_fno_openmp, false)) {