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 ↗

(On Diff #6969)

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 ↗

(On Diff #6969)

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

227–228

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 ↗

(On Diff #7178)

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

227–228

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

1820

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

1856

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.

6190

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

6202

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

6216

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?

6238

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

1779

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

1779

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

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

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

57

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

1779

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

1780

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

1843

Remove newline here.

[kutuzov.viktor.84]

Committed as r204129.

lib/Driver/Tools.cpp

 /// \brief Determine whether we are linking the ObjC runtime.
 static bool isObjCRuntimeLinked(const ArgList &Args) {
   if (isObjCAutoRefCount(Args)) {
     Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
     return true;
   }
   return Args.hasArg(options::OPT_fobjc_link_runtime);
 }
 
 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 &&
          !O.hasFlag(options::DriverOption) &&
          !O.hasFlag(options::LinkerInput);
 }
 
 void Clang::AddPreprocessingOptions(Compilation &C,
if (TC.getArch() == llvm::Triple::arm)
     return "arm";
   else
     return TC.getArchName();
 }
 
 static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
   // The runtimes are located in the OS-specific resource directory.
   SmallString<128> Res(TC.getDriver().ResourceDir);
-  llvm::sys::path::append(Res, "lib", TC.getOS());
+  const llvm::Triple &Triple = TC.getTriple();
+  StringRef OSLibName = Triple.getOS() == llvm::Triple::FreeBSD ?
+    Triple.getOSTypeName(Triple.getOS()) : TC.getOS();
+  llvm::sys::path::append(Res, "lib", OSLibName);
   return Res;
 }
 
 // This adds the static libclang_rt.arch.a directly to the command line
 // FIXME: Make sure we can also emit shared objects if they're requested
 // and available, check for possible errors, etc.
 static void addClangRTLinux(
     const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
static void addProfileRT(
 
   CmdArgs.push_back(Args.MakeArgString(LibProfile));
 }
 
 static void addSanitizerRTLinkFlags(
     const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
     const StringRef Sanitizer, bool BeforeLibStdCXX,
     bool ExportSymbols = true) {
   // Sanitizer runtime has name "libclang_rt.<Sanitizer>-<ArchName>.a".
   SmallString<128> LibSanitizer = getCompilerRTLibDir(TC);
   llvm::sys::path::append(LibSanitizer,
                           (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");
 
+  // There's no libdl on FreeBSD.
+  if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
+    CmdArgs.push_back("-ldl");
+
   // 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 addAsanRT(const ToolChain &TC, const ArgList &Args,
                       ArgStringList &CmdArgs) {
   if (TC.getTriple().getEnvironment() == llvm::Triple::Android) {
     SmallString<128> LibAsan = getCompilerRTLibDir(TC);
     llvm::sys::path::append(LibAsan,
                             (Twine("libclang_rt.asan-") +
                              getArchNameForCompilerRTLib(TC) + "-android.so"));
     CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
   } else {
     if (!Args.hasArg(options::OPT_shared))
       addSanitizerRTLinkFlags(TC, Args, CmdArgs, "asan", true);
   }
 }
 
 /// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
 /// This needs to be called before we add the C run-time (malloc, etc).
 static void addTsanRT(const ToolChain &TC, const ArgList &Args,
                       ArgStringList &CmdArgs) {
   if (!Args.hasArg(options::OPT_shared))
     addSanitizerRTLinkFlags(TC, Args, CmdArgs, "tsan", true);
 }
 
 /// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
 /// This needs to be called before we add the C run-time (malloc, etc).
 static void addMsanRT(const ToolChain &TC, const ArgList &Args,
                       ArgStringList &CmdArgs) {
   if (!Args.hasArg(options::OPT_shared))
     addSanitizerRTLinkFlags(TC, Args, CmdArgs, "msan", true);
 }
 
 /// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
 /// This needs to be called before we add the C run-time (malloc, etc).
 static void addLsanRT(const ToolChain &TC, const ArgList &Args,
                       ArgStringList &CmdArgs) {
   if (!Args.hasArg(options::OPT_shared))
     addSanitizerRTLinkFlags(TC, Args, CmdArgs, "lsan", true);
 }
 
 /// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
 /// (Linux).
 static void addUbsanRT(const ToolChain &TC, const ArgList &Args,
                        ArgStringList &CmdArgs, bool IsCXX,
                        bool HasOtherSanitizerRt) {
   // Need a copy of sanitizer_common. This could come from another sanitizer
   // runtime; if we're not including one, include our own copy.
   if (!HasOtherSanitizerRt)
     addSanitizerRTLinkFlags(TC, Args, CmdArgs, "san", true, false);
 
   addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan", false);
 
   // Only include the bits of the runtime which need a C++ ABI library if
   // we're linking in C++ mode.
   if (IsCXX)
     addSanitizerRTLinkFlags(TC, Args, CmdArgs, "ubsan_cxx", false);
 }
 
 static void addDfsanRT(const ToolChain &TC, const ArgList &Args,
static bool shouldUseFramePointerForTarget(const ArgList &Args,
   case llvm::Triple::x86_64:
     if (Triple.isOSLinux())
       if (Arg *A = Args.getLastArg(options::OPT_O_Group))
         if (!A->getOption().matches(options::OPT_O0))
           return false;
     return true;
   case llvm::Triple::xcore:
     return false;
   default:
     return true;
   }
 }
 
 static bool shouldUseFramePointer(const ArgList &Args,
                                   const llvm::Triple &Triple) {
   if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
                                options::OPT_fomit_frame_pointer))
if ((!Args.hasArg(options::OPT_nostdlib)) &&
     CmdArgs.push_back("-e");
     CmdArgs.push_back("__start");
   }
 
   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");
     CmdArgs.push_back("-Bdynamic");
     if (Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back("-shared");
     } else {
       CmdArgs.push_back("-dynamic-linker");
       CmdArgs.push_back("/usr/libexec/ld.so");
     }
   }
 
   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 (!Args.hasArg(options::OPT_shared)) {
       if (Args.hasArg(options::OPT_pg))
         CmdArgs.push_back(Args.MakeArgString(
                                 getToolChain().GetFilePath("gcrt0.o")));
else if (getToolChain().getArch() == llvm::Triple::mips ||
 
     addAssemblerKPIC(Args, CmdArgs);
   } else if (getToolChain().getArch() == llvm::Triple::arm ||
              getToolChain().getArch() == llvm::Triple::thumb) {
     const Driver &D = getToolChain().getDriver();
     const llvm::Triple &Triple = getToolChain().getTriple();
     StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
 
     if (FloatABI == "hard") {
       CmdArgs.push_back("-mfpu=vfp");
     } else {
       CmdArgs.push_back("-mfpu=softvfp");
     }
 
     switch(getToolChain().getTriple().getEnvironment()) {
     case llvm::Triple::GNUEABIHF:
     case llvm::Triple::GNUEABI:
     case llvm::Triple::EABI:
       CmdArgs.push_back("-meabi=5");
else if (getToolChain().getArch() == llvm::Triple::mips ||
     addAssemblerKPIC(Args, CmdArgs);
   }
 
   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,
if (Args.hasArg(options::OPT_static)) {
     }
     if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
       llvm::Triple::ArchType Arch = ToolChain.getArch();
       if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
           Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
         CmdArgs.push_back("--hash-style=both");
       }
     }
     CmdArgs.push_back("--enable-new-dtags");
   }
 
   // When building 32-bit code on FreeBSD/amd64, we have to explicitly
   // instruct ld in the base system to link 32-bit code.
   if (ToolChain.getArch() == llvm::Triple::x86) {
     CmdArgs.push_back("-m");
     CmdArgs.push_back("elf_i386_fbsd");
   }
void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     if (D.CCCIsCXX()) {
       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
       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_pg))
         CmdArgs.push_back("-lpthread_p");
       else
         CmdArgs.push_back("-lpthread");
     }
 
     if (Args.hasArg(options::OPT_pg)) {
       if (Args.hasArg(options::OPT_shared))
         CmdArgs.push_back("-lc");
       else
         CmdArgs.push_back("-lc_p");
       CmdArgs.push_back("-lgcc_p");
     } else {
       CmdArgs.push_back("-lc");
       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_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     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")));
   }
 
+  addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
+
   addProfileRT(ToolChain, Args, CmdArgs);
 
   const char *Exec =
     Args.MakeArgString(ToolChain.GetProgramPath("ld"));
   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
 }
 
 void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,

test/Driver/sanitizer-ld.c

 // CHECK-ASAN-LINUX-NOT: "-lc"
 // CHECK-ASAN-LINUX: libclang_rt.asan-i386.a"
 // CHECK-ASAN-LINUX: "-lpthread"
 // CHECK-ASAN-LINUX: "-lrt"
 // CHECK-ASAN-LINUX: "-ldl"
 // CHECK-ASAN-LINUX-NOT: "-export-dynamic"
 // CHECK-ASAN-LINUX: "--dynamic-list={{.*}}libclang_rt.asan-i386.a.syms"
 
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target i386-unknown-freebsd -fsanitize=address \
+// RUN:     -resource-dir=%S/Inputs/resource_dir \
+// RUN:     --sysroot=%S/Inputs/basic_freebsd_tree \
+// RUN:   | FileCheck --check-prefix=CHECK-ASAN-FREEBSD %s
+//
+// CHECK-ASAN-FREEBSD: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
+// CHECK-ASAN-FREEBSD-NOT: "-lc"
+// CHECK-ASAN-FREEBSD: freebsd/libclang_rt.asan-i386.a"
+// CHECK-ASAN-FREEBSD: "-lpthread"
+// CHECK-ASAN-FREEBSD: "-lrt"
+// CHECK-ASAN-FREEBSD: "-export-dynamic"
+// CHECK-ASAN-FREEBSD-NOT: "--dynamic-list"
+
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target i386-unknown-freebsd -fsanitize=address \
+// RUN:     -resource-dir=%S/Inputs/resource_dir \
+// RUN:     --sysroot=%S/Inputs/basic_freebsd_tree \
+// RUN:   | FileCheck --check-prefix=CHECK-ASAN-FREEBSD-LDL %s
+//
+// CHECK-ASAN-FREEBSD-LDL: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
+// CHECK-ASAN-FREEBSD-LDL-NOT: "-ldl"
+
 // RUN: %clangxx -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target i386-unknown-linux -fsanitize=address \
 // RUN:     -resource-dir=%S/Inputs/empty_resource_dir \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-ASAN-LINUX-CXX %s
 //
 // CHECK-ASAN-LINUX-CXX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
 // CHECK-ASAN-LINUX-CXX-NOT: "-lc"
 // CHECK-ASAN-LINUX-CXX: "-whole-archive" "{{.*}}libclang_rt.asan-i386.a" "-no-whole-archive"
 // CHECK-ASAN-LINUX-CXX: "-lpthread"
 // CHECK-ASAN-LINUX-CXX: "-lrt"
 // CHECK-ASAN-LINUX-CXX: "-ldl"
 // CHECK-ASAN-LINUX-CXX: "-export-dynamic"
 // CHECK-ASAN-LINUX-CXX-NOT: "--dynamic-list"
 // CHECK-ASAN-LINUX-CXX: stdc++
 
 // RUN: %clang -no-canonical-prefixes %s -### -o /dev/null -fsanitize=address \
 // RUN:     -target i386-unknown-linux --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:     -lstdc++ -static 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-ASAN-LINUX-CXX-STATIC %s
 //
 // CHECK-ASAN-LINUX-CXX-STATIC: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
 // CHECK-ASAN-LINUX-CXX-STATIC-NOT: stdc++
 // CHECK-ASAN-LINUX-CXX-STATIC: "-whole-archive" "{{.*}}libclang_rt.asan-i386.a" "-no-whole-archive"
 // CHECK-ASAN-LINUX-CXX-STATIC: stdc++