add supporting of the sanitizer arguments into Clang on FreeBSD platform.

[kutuzov.viktor.84]

Summary

This patch provides the following functionality:

• allows the FreeBSD platform in the sanitizer argument filters;
• adds the linker cmdline args and RT libraries in according of specified sanitizer arguments (--sanitize=...) for the FreeBSD targets.

[rsmith]

This patch needs a corresponding set of tests in test/Driver.

Do the asan, msan, tsan, ubsan, ... test suites pass on freebsd with this change?

lib/Driver/Tools.cpp

1963

You mean, "in the freebsd directory"?

5889

Put the & on the right, please, since you're touching this line anyway =)

5896

Local variable names should start with an uppercase letter.

5899–5904

I think you only need a C++ stdlib if you're using certain parts of ubsan (asan, tsan, msan, and lsan shouldn't require it IIUC).

6027–6028

Please give this a more informative name rather than using a comment to describe what it is.

6029

ex |= ... ?

6058–6062

I would expect this either needs -whole-archive or needs to come at the end of the linker arguments? (None of the symbols in this archive will be needed at this point.)

[kutuzov.viktor.84]

Richard, here's updated patch. Thanks a lot for your comments.

[samsonov]

Could you please follow advice from http://llvm.org/docs/Phabricator.html and run smth. like "svn diff --diff-cmd=diff -x -U999999" (or use arc command-line interface to upload diffs), so that it's possible to see more context? Thanks.

lib/Driver/SanitizerArgs.cpp

249

IsPosix name is bad, Mac OS X is also Posix. You can just use "IsLinuxOrFreeBSD".
By the way, did you really check that TSan, MSan, DFSan all work on FreeBSD?

lib/Driver/Tools.cpp

1867

Please re-use/generalize addProfileRT() function.

1891

Please re-use/generalize addSanitizerRTFlagsLinux. I really don't like we duplicate the logic for calculating the name/location of sanitizer runtimes, adding --dynamic-list/--export-dynamic etc.

1910

To support previous comment - either comment is now wrong, or you forgot to add --export-dynamic here.

6116

I'd prefer to add -lpthread_p in addSanitizerRTLinkFlagsFreeBSD, as we do on Linux.

[kutuzov.viktor.84]

The same patch with full context.

[kcc]

tests please

[kutuzov.viktor.84]

Tests added.

Do the asan, msan, tsan, ubsan, ... test suites pass on freebsd with this change?

No, that require further changes in compiler-rt. The test suites are not enabled for FreeBSD yet.

[samsonov]

In this case it probably makes sense to keep that sanitizers as "unsupported" on FreeBSD for now.

[kutuzov.viktor.84]

They are currently not supported so we have no failures.

[kutuzov.viktor.84]

Tests updated so that they pass on both Linux and FreeBSD.

[samsonov]

Please address my comments in http://llvm-reviews.chandlerc.com/D2644#comment-4

[kutuzov.viktor.84]

Regarding handling of the "-lpthread*" option: I tried to move the code adding various libraries to addSanitizerRTLinkFlagsLinux[OrFreeBSD]() and that resulted in a somewhat larger function with a lot of conditions for different libraries. No problem with implementing it this way, but it seems the readability suffers significantly.

lib/Driver/SanitizerArgs.cpp

249

Yes, with corresponding changes applied (not submitted for review yet) we do support those on FreeBSD.

lib/Driver/Tools.cpp

1910

I will fix this, but just to make the logic clear: in this case we return true to let the caller know we should append "--export-dynamic".

[kutuzov.viktor.84]

Reworked as suggested.
Somehow missed your comments. Thanks, Alexey.

[kutuzov.viktor.84]

lib/Driver/Tools.cpp

219

By the way, do we really need the "Triple" parameter? It seems in all cases we get triple as just TC.getTriple().

[samsonov]

lib/Driver/SanitizerArgs.cpp

253

You haven't mailed the changes supporting tsan/msan/dfsan on FreeBSD. I suggest to keep filtering them for now, but leaving this up to you.

lib/Driver/Tools.cpp

232

OMG, it turned out there was the correct addProfileRTLinux(), and this function is long obsolete. I've fixed this problem in r201789.

1769

You can use a newly introduced getOSNameForCompilerRTLib() for that.

1799

Why do you need this?

• If the user specifies -rdynamic, --export-dynamic will be added to the link line anyway, no harm in duplicating this.
• -static is not supposed to work with ASan anyway.

6046

Why not re-use the whole chunk of code that calls add?sanRTLinux() in gnutools::Link::ConstructJob (factored out into a separate function)?

6058

Why don't you make use of "BeforeLibStdCXX" parameter of addSanitizerRTLinkFlagsLinux(), or even reuse addAsanRTLinux, addTSanRTLinux, and so on?

6072

You add -lrt because of sanitizers in this place, and you add -lpthread(_p)? in another place below. That's why I suggest to link in all the system libraries required by sanitizers in a single place (addSanitizerRTLinkFlags method). By the way, will the sanitizers actually work if the user specifies smth. like --nodefaultlibs? Maybe, it's fine to fail with link error in that case?

6145–6146

Do you have two if(NeedsDefaultLibs) { ... } blocks in a row?

[kutuzov.viktor.84]

OK, it looks there is a lot of details that require deep and careful analysis against recent revisions--more than I could do with the current level of the sanitizers support on FreeBSD. So, I propose we defer this patch untill we need it to run the tests and then make as small changes as possible and only if necessary. Please let me know if you think that would work. Thanks.

[samsonov]

OK, I don't mind it. I will hopefully do some cleanup/generalization for sanitizers support in the Driver code that will help you minimize the changes to enable them on FreeBSD.

[samsonov]

For the record: r202148 and r202150 should help in simplifying this patch.

[kutuzov.viktor.84]

Updated to leverage changes by Alexey Samsonov.

The change in getCompilerRTLibDir() is necessary as otherwise it yields "lib/freebsd10.0" on FreeBSD 10.0 whereas "lib/freebsd" (without the version number) is expected.

Thanks, Alexey!

[samsonov]

Please add a testcase. It should probably go to test/Driver/sanitizer-ld.c

lib/Driver/Tools.cpp

1741

Please note that we expect "darwin" directory on Mac OS X / iOS. Maybe it makes sense to special-case freebsd for now.

[kutuzov.viktor.84]

Fixed as suggested and supplied with tests.

[samsonov]

lib/Driver/Tools.cpp

1741

Please calculate os-specific dir in a separate variable. Also, why not just use "freebsd" constant for llvm::Triple::FreeBSD? Is it going to change?

test/Driver/sanitizer-ld.c

26 ↗

(On Diff #7644)

Please how CHECK-NOT lines work in the FileCheck man. Most likely you'll need to add CHECK-ASAN-FREEBSD-NOT: "-ldl" between all CHECK-ASAN-FREEBSD: lines. Or just add a single separate test case that would contain a single CHECK-NOT constraint for ldl.

27 ↗

(On Diff #7644)

I wonder if you can somehow match "freebsd" part of a path here.

49 ↗

(On Diff #7644)

This and the following test case doesn't seem to add any value. I think it's ok to drop them.

[kutuzov.viktor.84]

lib/Driver/Tools.cpp

1741

The idea is that given there may be more exceptions for which ToolChain::getOS() doesn't return the right thing, using Triple::getOSTypeName() seems to be the common way to get the dir name for them.

[kutuzov.viktor.84]

Updated.

Alexey, please let me know if you would prefer explicit "freebsd" instead of calling Triple::getOSTypeName(). Thanks.

[samsonov]

LGTM

lib/Driver/Tools.cpp

1742

Yes, please use explicit "freebsd" for now (and leave a comment why you're doing this).

1790

Remove newline here.

[kutuzov.viktor.84]

Committed as r204129.

lib/Driver/SanitizerArgs.cpp

 }
 
 unsigned SanitizerArgs::filterUnsupportedKinds(const ToolChain &TC,
                                                unsigned Kinds,
                                                const llvm::opt::ArgList &Args,
                                                const llvm::opt::Arg *A,
                                                bool DiagnoseErrors,
                                                unsigned &DiagnosedKinds) {
-  bool IsLinux = TC.getTriple().getOS() == llvm::Triple::Linux;
+  bool IsPosix = TC.getTriple().getOS() == llvm::Triple::Linux ||
+                 TC.getTriple().getOS() == llvm::Triple::FreeBSD;
   bool IsX86 = TC.getTriple().getArch() == llvm::Triple::x86;
   bool IsX86_64 = TC.getTriple().getArch() == llvm::Triple::x86_64;
-  if (!(IsLinux && IsX86_64)) {
+  if (!(IsPosix && IsX86_64)) {
     filterUnsupportedMask(TC, Kinds, Thread | Memory | DataFlow, Args, A,
                           DiagnoseErrors, DiagnosedKinds);
   }
-  if (!(IsLinux && (IsX86 || IsX86_64))) {
+  if (!(IsPosix && (IsX86 || IsX86_64))) {
     filterUnsupportedMask(TC, Kinds, Function, Args, A, DiagnoseErrors,
                           DiagnosedKinds);
   }
   return Kinds;
 }
 
 unsigned SanitizerArgs::parse(const Driver &D, const llvm::opt::Arg *A,
                               bool DiagnoseErrors) {

lib/Driver/Tools.cpp

if (isObjCAutoRefCount(Args)) {
     Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
     return true;
   }
   return Args.hasArg(options::OPT_fobjc_link_runtime);
 }
 
 static void addProfileRT(const ToolChain &TC, const ArgList &Args,
                          ArgStringList &CmdArgs,
                          llvm::Triple Triple) {
   if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
         Args.hasArg(options::OPT_fprofile_generate) ||
         Args.hasArg(options::OPT_fprofile_instr_generate) ||
         Args.hasArg(options::OPT_fcreate_profile) ||
         Args.hasArg(options::OPT_coverage)))
     return;
 
   // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
   // the link line. We cannot do the same thing because unlike gcov there is a
   // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
   // not supported by old linkers.
   std::string ProfileRT =
     std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a";
 
   CmdArgs.push_back(Args.MakeArgString(ProfileRT));
 }
 
 static bool forwardToGCC(const Option &O) {
   // Don't forward inputs from the original command line.  They are added from
   // InputInfoList.
   return O.getKind() != Option::InputClass &&

 // Until ARM libraries are build separately, we have them all in one library
 static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
   if (TC.getArch() == llvm::Triple::arm)
     return "arm";
   else
     return TC.getArchName();
 }
 
 static void addProfileRTLinux(
     const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
   if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
         Args.hasArg(options::OPT_fprofile_generate) ||
         Args.hasArg(options::OPT_fprofile_instr_generate) ||
         Args.hasArg(options::OPT_fcreate_profile) ||
         Args.hasArg(options::OPT_coverage)))
     return;
 
   // The profile runtime is located in the Linux library directory and has name
static void addSanitizerRTLinkFlagsLinux(
     const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
     const StringRef Sanitizer, bool BeforeLibStdCXX,
     bool ExportSymbols = true) {
   // Sanitizer runtime is located in the Linux library directory and
   // has name "libclang_rt.<Sanitizer>-<ArchName>.a".
   SmallString<128> LibSanitizer(TC.getDriver().ResourceDir);
   llvm::sys::path::append(
       LibSanitizer, "lib", "linux",
       (Twine("libclang_rt.") + Sanitizer + "-" +
           getArchNameForCompilerRTLib(TC) + ".a"));
 
   // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
   // etc.) so that the linker picks custom versions of the global 'operator
   // new' and 'operator delete' symbols. We take the extreme (but simple)
   // strategy of inserting it at the front of the link command. It also
   // needs to be forced to end up in the executable, so wrap it in
   // whole-archive.
   SmallVector<const char *, 3> LibSanitizerArgs;
   LibSanitizerArgs.push_back("-whole-archive");
   LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
   LibSanitizerArgs.push_back("-no-whole-archive");
 
   CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
                  LibSanitizerArgs.begin(), LibSanitizerArgs.end());
 
   CmdArgs.push_back("-lpthread");
   CmdArgs.push_back("-lrt");
   CmdArgs.push_back("-ldl");
   CmdArgs.push_back("-lm");
 
   // If possible, use a dynamic symbols file to export the symbols from the
   // runtime library. If we can't do so, use -export-dynamic instead to export
   // all symbols from the binary.
   if (ExportSymbols) {
     if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
       CmdArgs.push_back(
           Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
     else
       CmdArgs.push_back("-export-dynamic");
   }
 }
 
 /// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
 /// This needs to be called before we add the C run-time (malloc, etc).
 static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
                            ArgStringList &CmdArgs) {
   if (TC.getTriple().getEnvironment() == llvm::Triple::Android) {

 }
 
 static void addDfsanRTLinux(const ToolChain &TC, const ArgList &Args,
                             ArgStringList &CmdArgs) {
   if (!Args.hasArg(options::OPT_shared))
     addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "dfsan", true);
 }
 
+static void addProfileRTFreeBSD(
+    const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
+  if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
+        Args.hasArg(options::OPT_fprofile_generate) ||
+        Args.hasArg(options::OPT_fcreate_profile) ||
+        Args.hasArg(options::OPT_coverage)))
+    return;
+
+  // The profile runtime is located in the freebsd library directory and has
+  // name "libclang_rt.profile-<ArchName>.a".
+  SmallString<128> LibProfile(TC.getDriver().ResourceDir);
+  llvm::sys::path::append(
+      LibProfile, "lib", "freebsd",
+      Twine("libclang_rt.profile-") + TC.getArchName() + ".a");
+
+  CmdArgs.push_back(Args.MakeArgString(LibProfile));
+}
+
+// Append a name of a appropriate Sanitizer library into a list
+// of the linker arguments.
+// This function returns true if an appropriate .syms file for
+// the specified Sanitizer library does exist and has been added into the linker
+// argument list to export the proper dynamic symbols;
+// otherwise this function returns false.
+static bool addSanitizerRTLinkFlagFreeBSD(
+    const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
+    const StringRef Sanitizer) {
+  // Sanitizer runtime is located in the freebsd library directory and
+  // has name "libclang_rt.<Sanitizer>-<ArchName>.a".
+  SmallString<128> LibSanitizer(TC.getDriver().ResourceDir);
+  llvm::sys::path::append(
+      LibSanitizer, "lib", "freebsd",
+      (Twine("libclang_rt.") + Sanitizer + "-" + TC.getArchName() + ".a"));
+
+  CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
+
+  // If possible, use a dynamic symbols file to export the symbols from the
+  // runtime library. If we can't do so, use --export-dynamic instead to export
+  // all symbols from the binary.
+  const bool syms = llvm::sys::fs::exists(LibSanitizer + ".syms");
+  if (syms)
+    CmdArgs.push_back(
+        Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
+
+  return syms;
+}
+
 static bool shouldUseFramePointerForTarget(const ArgList &Args,
                                            const llvm::Triple &Triple) {
   switch (Triple.getArch()) {
   // Don't use a frame pointer on linux if optimizing for certain targets.
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el:
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:

 /// Add a CC1 option to specify the debug compilation directory.
 static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
   SmallString<128> cwd;
   if (!llvm::sys::fs::current_path(cwd)) {
     CmdArgs.push_back("-fdebug-compilation-dir");
     CmdArgs.push_back(Args.MakeArgString(cwd));
   }
 }
 
 static const char *SplitDebugName(const ArgList &Args,
                                   const InputInfoList &Inputs) {
   Arg *FinalOutput = Args.getLastArg(options::OPT_o);
   if (FinalOutput && Args.hasArg(options::OPT_c)) {
     SmallString<128> T(FinalOutput->getValue());
     llvm::sys::path::replace_extension(T, "dwo");
     return Args.MakeArgString(T);
   } else {
default:
              getToolChain().getArch() == llvm::Triple::sparcv9) {
     Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
                                       options::OPT_fpic, options::OPT_fno_pic,
                                       options::OPT_fPIE, options::OPT_fno_PIE,
                                       options::OPT_fpie, options::OPT_fno_pie);
     if (LastPICArg &&
         (LastPICArg->getOption().matches(options::OPT_fPIC) ||
          LastPICArg->getOption().matches(options::OPT_fpic) ||
          LastPICArg->getOption().matches(options::OPT_fPIE) ||
          LastPICArg->getOption().matches(options::OPT_fpie))) {
       CmdArgs.push_back("-KPIC");
     }
   }
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
                        options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (InputInfoList::const_iterator
          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
     const InputInfo &II = *it;
     CmdArgs.push_back(II.getFilename());
   }
 
   const char *Exec =
     Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
 }
 
 void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                  const InputInfo &Output,
                                  const InputInfoList &Inputs,
                                  const ArgList &Args,
                                  const char *LinkingOutput) const {
-  const toolchains::FreeBSD& ToolChain = 
+  const toolchains::FreeBSD &ToolChain =
     static_cast<const toolchains::FreeBSD&>(getToolChain());
   const Driver &D = ToolChain.getDriver();
+  const SanitizerArgs &Sanitize = ToolChain.getSanitizerArgs();
+  const bool IsPIE =
+    !Args.hasArg(options::OPT_shared) &&
+    (Args.hasArg(options::OPT_pie) || Sanitize.hasZeroBaseShadow());
+  const bool NeedsDefaultLibs =
+    !Args.hasArg(options::OPT_nostdlib) &&
+    !Args.hasArg(options::OPT_nodefaultlibs);
+  const bool NeedsCXXSanRt =
+    !Args.hasArg(options::OPT_shared) &&
+    (Sanitize.needsAsanRt() ||
+     Sanitize.needsTsanRt() ||
+     Sanitize.needsMsanRt() ||
+     Sanitize.needsLsanRt());
+  const bool NeedsUbsanRt = Sanitize.needsUbsanRt();
+  const bool NeedsSanRt = NeedsCXXSanRt || Sanitize.needsDfsanRt();
+  const bool NeedsCXXStdlib =
+    NeedsDefaultLibs &&
+    (D.CCCIsCXX() || NeedsUbsanRt);
+
   ArgStringList CmdArgs;
 
   // Silence warning for "clang -g foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_g_Group);
   // and "clang -emit-llvm foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
   // and for "clang -w foo.o -o foo". Other warning options are already
   // handled somewhere else.
   Args.ClaimAllArgs(options::OPT_w);
 
   if (!D.SysRoot.empty())
     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
 
-  if (Args.hasArg(options::OPT_pie))
+  if (IsPIE)
     CmdArgs.push_back("-pie");
 
   if (Args.hasArg(options::OPT_static)) {
     CmdArgs.push_back("-Bstatic");
   } else {
     if (Args.hasArg(options::OPT_rdynamic))
       CmdArgs.push_back("-export-dynamic");
     CmdArgs.push_back("--eh-frame-hdr");
void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
-  if (!Args.hasArg(options::OPT_nostdlib) &&
-      !Args.hasArg(options::OPT_nostartfiles)) {
+  if (NeedsDefaultLibs) {
     const char *crt1 = NULL;
     if (!Args.hasArg(options::OPT_shared)) {
       if (Args.hasArg(options::OPT_pg))
         crt1 = "gcrt1.o";
-      else if (Args.hasArg(options::OPT_pie))
+      else if (IsPIE)
         crt1 = "Scrt1.o";
       else
         crt1 = "crt1.o";
     }
     if (crt1)
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
 
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
 
     const char *crtbegin = NULL;
     if (Args.hasArg(options::OPT_static))
       crtbegin = "crtbeginT.o";
-    else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
+    else if (Args.hasArg(options::OPT_shared) || IsPIE)
       crtbegin = "crtbeginS.o";
     else
       crtbegin = "crtbegin.o";
 
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   const ToolChain::path_list Paths = ToolChain.getFilePaths();
   for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
        i != e; ++i)
     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_e);
   Args.AddAllArgs(CmdArgs, options::OPT_s);
   Args.AddAllArgs(CmdArgs, options::OPT_t);
   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
   Args.AddAllArgs(CmdArgs, options::OPT_r);
 
   if (D.IsUsingLTO(Args))
     AddGoldPlugin(ToolChain, Args, CmdArgs);
 
   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
 
-  if (!Args.hasArg(options::OPT_nostdlib) &&
-      !Args.hasArg(options::OPT_nodefaultlibs)) {
-    if (D.CCCIsCXX()) {
-      ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
+  // Call these before we add the C++ ABI library.
+  // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
+  // etc.) so that the linker picks custom versions of the global 'operator
+  // new' and 'operator delete' symbols. We take the extreme (but simple)
+  // strategy of inserting it at the front of the link command. It also
+  // needs to be forced to end up in the executable, so wrap it in
+  // whole-archive.
+  if (NeedsSanRt || NeedsUbsanRt) {
+    CmdArgs.push_back("-whole-archive");
+    if (NeedsUbsanRt) {
+      // Need a copy of sanitizer_common. This could come from another
+      // sanitizer runtime; if we're not including one, include our own copy.
+      if (!NeedsSanRt)
+        addSanitizerRTLinkFlagFreeBSD(ToolChain, Args, CmdArgs, "san");
+      addSanitizerRTLinkFlagFreeBSD(ToolChain, Args, CmdArgs, "ubsan");
+    }
+    bool NeedsExportDynamicOpt = false;
+    NeedsExportDynamicOpt |= (Sanitize.needsAsanRt() &&
+      !addSanitizerRTLinkFlagFreeBSD(ToolChain, Args, CmdArgs, "asan"));
+    NeedsExportDynamicOpt |= (Sanitize.needsTsanRt() &&
+      !addSanitizerRTLinkFlagFreeBSD(ToolChain, Args, CmdArgs, "tsan"));
+    NeedsExportDynamicOpt |= (Sanitize.needsMsanRt() &&
+      !addSanitizerRTLinkFlagFreeBSD(ToolChain, Args, CmdArgs, "msan"));
+    NeedsExportDynamicOpt |= (Sanitize.needsLsanRt() &&
+      !addSanitizerRTLinkFlagFreeBSD(ToolChain, Args, CmdArgs, "lsan"));
+    NeedsExportDynamicOpt |= (Sanitize.needsDfsanRt() &&
+      !addSanitizerRTLinkFlagFreeBSD(ToolChain, Args, CmdArgs, "dfsan"));
+
+    CmdArgs.push_back("-no-whole-archive");
+
+    // Force exporting of the dynamic symbols if it was not done before.
+    if (NeedsExportDynamicOpt &&
+        (!Args.hasArg(options::OPT_rdynamic) &&
+         !Args.hasArg(options::OPT_static)))
+      CmdArgs.push_back("--export-dynamic");
+
+    if (NeedsDefaultLibs)
+      CmdArgs.push_back("-lrt");
+  }
+
+  // The profile runtime also needs access to system libraries.
+  addProfileRTFreeBSD(ToolChain, Args, CmdArgs);
+
+  if (NeedsCXXStdlib)
+
+  if (NeedsUbsanRt && D.CCCIsCXX()) {
+    // Only include the bits of the runtime which need a C++ ABI library if
+    // we're linking in C++ mode.
+    CmdArgs.push_back("-whole-archive");
+    addSanitizerRTLinkFlagFreeBSD(ToolChain, Args, CmdArgs, "ubsan_cxx");
+    CmdArgs.push_back("-no-whole-archive");
+  }
+
+  if (NeedsDefaultLibs) {
+    if (D.CCCIsCXX()) {
       if (Args.hasArg(options::OPT_pg))
         CmdArgs.push_back("-lm_p");
       else
         CmdArgs.push_back("-lm");
     }
     // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
     // the default system libraries. Just mimic this for now.
     if (Args.hasArg(options::OPT_pg))
       CmdArgs.push_back("-lgcc_p");
     else
       CmdArgs.push_back("-lgcc");
     if (Args.hasArg(options::OPT_static)) {
       CmdArgs.push_back("-lgcc_eh");
     } else if (Args.hasArg(options::OPT_pg)) {
       CmdArgs.push_back("-lgcc_eh_p");
     } else {
       CmdArgs.push_back("--as-needed");
       CmdArgs.push_back("-lgcc_s");
       CmdArgs.push_back("--no-as-needed");
     }
 
-    if (Args.hasArg(options::OPT_pthread)) {
+    if (Args.hasArg(options::OPT_pthread) || NeedsSanRt || NeedsUbsanRt) {
       if (Args.hasArg(options::OPT_pg))
         CmdArgs.push_back("-lpthread_p");
       else
         CmdArgs.push_back("-lpthread");
     }
 
     if (Args.hasArg(options::OPT_pg)) {
       if (Args.hasArg(options::OPT_shared))
if (Args.hasArg(options::OPT_static)) {
       CmdArgs.push_back("-lgcc_eh_p");
     } else {
       CmdArgs.push_back("--as-needed");
       CmdArgs.push_back("-lgcc_s");
       CmdArgs.push_back("--no-as-needed");
     }
   }
 
-  if (!Args.hasArg(options::OPT_nostdlib) &&
-      !Args.hasArg(options::OPT_nostartfiles)) {
-    if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
+  if (NeedsDefaultLibs) {
+    if (Args.hasArg(options::OPT_shared) || IsPIE)
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
     else
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
   }
 
-  addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
-
-  const char *Exec =
-    Args.MakeArgString(ToolChain.GetProgramPath("ld"));
+  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
 }
 
 void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                      const InputInfo &Output,
                                      const InputInfoList &Inputs,
                                      const ArgList &Args,
                                      const char *LinkingOutput) const {

test/Driver/freebsd-sanitizers.c

+
+// RUN: %clang -no-canonical-prefixes -target i386-pc-freebsd \
+// RUN:     -fsanitize=address %s -### 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-ASAN-I386 %s
+// CHECK-ASAN-I386: "-whole-archive" "{{.*}}/lib/freebsd/libclang_rt.asan-i386.a" "-no-whole-archive"
+// CHECK-ASAN-I386: "--export-dynamic" "-lrt" "-lgcc"
+
+// RUN: %clang -no-canonical-prefixes -target x86_64-pc-freebsd \
+// RUN:     -fsanitize=address %s -### 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-ASAN-X86_64 %s
+// CHECK-ASAN-X86_64: "-whole-archive" "{{.*}}/lib/freebsd/libclang_rt.asan-x86_64.a" "-no-whole-archive"
+// CHECK-ASAN-X86_64: "--export-dynamic" "-lrt" "-lgcc"
+
+// RUN: %clang -no-canonical-prefixes -target i386-pc-freebsd \
+// RUN:     -fsanitize=undefined %s -### 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-UBSAN-I386 %s
+// CHECK-UBSAN-I386: "-whole-archive" "{{.*}}/freebsd/libclang_rt.san-i386.a" "{{.*}}/freebsd/libclang_rt.ubsan-i386.a" "-no-whole-archive"
+// CHECK-UBSAN-I386: "-lrt" "-lstdc++"
+
+// RUN: %clang -no-canonical-prefixes -target x86_64-pc-freebsd \
+// RUN:     -fsanitize=undefined %s -### 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-UBSAN-X86_64 %s
+// CHECK-UBSAN-X86_64: "-whole-archive" "{{.*}}/freebsd/libclang_rt.san-x86_64.a" "{{.*}}/freebsd/libclang_rt.ubsan-x86_64.a" "-no-whole-archive"
+// CHECK-UBSAN-X86_64: "-lrt" "-lstdc++"
+// CHECK-UBSAN-X86_64-NOT: libclang_rt.ubsan_cxx
+
+// RUN: %clangxx -no-canonical-prefixes -target x86_64-pc-freebsd \
+// RUN:     -fsanitize=undefined %s -### 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-UBSAN-CXX %s
+// CHECK-UBSAN-CXX: "-whole-archive" "{{.*}}/freebsd/libclang_rt.san-x86_64.a" "{{.*}}/freebsd/libclang_rt.ubsan-x86_64.a" "-no-whole-archive"
+// CHECK-UBSAN-CXX: "-lrt" "-lstdc++"
+// CHECK-UBSAN-CXX: "-whole-archive" "{{.*}}/freebsd/libclang_rt.ubsan_cxx-x86_64.a" "-no-whole-archive"