[Driver] Sanitizer support based on runtime library presence

[george.karpenkov]

Summary

The runtime libraries of sanitizers are built in compiler-rt, and Clang can be built without compiler-rt, or compiler-rt can be configured to only build certain sanitizers. The driver should provide reasonable diagnostics and not a link-time error when a runtime library is missing.

This patch changes the driver for OS X to only support sanitizers of which we can find the runtime libraries. The discussion for this patch explains the rationale.

[beanz]

Mostly formatting comments. I think for the most part this is the right way to go, but I don't really feel qualified to approve this. The one thing I'm not sure about on this is, do we really want this to be darwin-only? I kinda think it might be nice if we unified this behavior across all platforms.

lib/Driver/SanitizerArgs.cpp

204 ↗

(On Diff #41862)

80 col

240 ↗

(On Diff #41862)

Also 80 col violation.

Please clang-format.

lib/Driver/ToolChains.cpp

1243 ↗

(On Diff #41862)

I'm not super familiar with the driver code, but I wonder if this can't be better abstracted.

I'd really like to see all operating systems have the same behavior for this, so I think much of the code can be shared.

If the runtime library exists for a sanitizer (any sanitizer) I don't see any reason clang shouldn't then support the flags.

1258 ↗

(On Diff #41862)

Last time I'll comment this, please clang-format.

[kubamracek]

Applying clang-format.

[kubamracek]

The one thing I'm not sure about on this is, do we really want this to be darwin-only? I kinda think it might be nice if we unified this behavior across all platforms.
... I wonder if this can't be better abstracted.
I'd really like to see all operating systems have the same behavior for this, so I think much of the code can be shared.
If the runtime library exists for a sanitizer (any sanitizer) I don't see any reason clang shouldn't then support the flags.

On Darwin, the situation is easier, because all the supported sanitizers are dylibs. The code to link the runtimes is very different on every platform (Darwin, Linux, FreeBSD, Windows). Alexey, can you comment on this? Does this change make sense for Linux as well?

[samsonov]

include/clang/Driver/ToolChain.h

410 ↗

(On Diff #42041)

I don't think this is relevant to ToolChain at all. SanitizerArgs has TrappingSupported mask, which is what you should need: if you don't have runtimes for all sanitizers you're enabling, and *some* of these sanitizers support trapping, driver may advise to use this flag.

lib/Driver/ToolChains.cpp

360 ↗

(On Diff #42041)

Can we teach ToolChain (or at least Darwin toolchain) to return us OS name instead?

369 ↗

(On Diff #42041)

Oh no, please don't return a StringRef which points to temporary.

test/Driver/fsanitize.c

14 ↗

(On Diff #42041)

I find this diagnostic misleading :-/ It's not the case that -fsanitize=undefined *requires* you to additionally provide -fsanitize-trap=undefined. It requires having a UBSan runtime library available. Or, if you can't provide it (it's not available on your system), you can workaround this by using -fsanitize-trap. The latter should be a suggestion, really.

33 ↗

(On Diff #42041)

Nice catch, please commit this fix as a separate change.

214 ↗

(On Diff #42041)

Why not resource_dir_darwin_sanitizers here and below?

221 ↗

(On Diff #42041)

Again, I feel like we're lying to users here: -fsanitize=thread *is* supported for this target, it just requires building a runtime.

[kubamracek]

test/Driver/fsanitize.c

221 ↗

(On Diff #42041)

I'd like to see this from the point-of-view of a binary distribution. If the binary distribution (e.g. the one from llvm.org or Apple's Clang in Xcode) doesn't contain a runtime library, then the sanitizer is *not* supported in that distribution. Also, see http://reviews.llvm.org/D14846, we'd like to have CMake options to select which runtimes will be built. If you deliberately choose not to build ThreadSanitizer, then that sanitizer is *not* supported in your version of Clang. If you're experimenting and porting a runtime to a new platform, then this sanitizer *is* supported in your version of Clang.

[beanz]

test/Driver/fsanitize.c

221 ↗

(On Diff #42041)

Maybe the point is we should have a different error message for cases where the runtime is just missing. Something like "runtime components for '-fsanitize=thread' not available"

[samsonov]

test/Driver/fsanitize.c

221 ↗

(On Diff #42041)

I see, so essentially you want to use a different approach for determining sanitizer availability (on OS X for now): if the library is present, then we support sanitizer, otherwise we don't: i.e. the binary distribution is the source of truth, not the list of sanitizers hardcoded into Clang driver source code. I'm fine with that, and see why it would make sense.

It's just that error message looks misleading: the problem is not TSan is unsupported for target, it's just unavailable in this distribution for one reason or another.

[zaks.anna]

I see, so essentially you want to use a different approach for determining sanitizer availability (on OS X for now): if the library is present, then we support
sanitizer, otherwise we don't: i.e. the binary distribution is the source of truth, not the list of sanitizers hardcoded into Clang driver source code. I'm fine with
that, and see why it would make sense.

Correct.

It's just that error message looks misleading: the problem is not TSan is unsupported for target, it's just unavailable in this distribution for one reason or
another.

The main advantage of the error message Kuba has right now is that it is user friendly. A sanitizer IS unsupported for the given target in the given distribution if the library is missing. Saying something along the lines of "runtime components for '-fsanitize=thread' not available" is vague. For example, does it mean that the user needs to install the runtime components in some other way?

[samsonov]

In D15225#328218, @zaks.anna wrote:

I see, so essentially you want to use a different approach for determining sanitizer availability (on OS X for now): if the library is present, then we support
sanitizer, otherwise we don't: i.e. the binary distribution is the source of truth, not the list of sanitizers hardcoded into Clang driver source code. I'm fine with
that, and see why it would make sense.

Correct.

It's just that error message looks misleading: the problem is not TSan is unsupported for target, it's just unavailable in this distribution for one reason or
another.

The main advantage of the error message Kuba has right now is that it is user friendly. A sanitizer IS unsupported for the given target in the given distribution if the library is missing. Saying something along the lines of "runtime components for '-fsanitize=thread' not available" is vague. For example, does it mean that the user needs to install the runtime components in some other way?

s/unsupported/unavailable? I don't know, is there a way to install runtime components for ASan if your distribution doesn't happen to have one (that must be tricky, as the version of ASan should match the version of the compiler). Anyway, you're in much better position to make a judgement here, leaving this to you.

I believe, at least part of this patch will be superseded by http://reviews.llvm.org/D15624? Feel free to update this one when the latter lands.

[zaks.anna]

I don't know, is there a way to install runtime components for ASan if your distribution doesn't happen to have one (that must be tricky, as the version of ASan should match the version of the compiler).

Correct, there is no recommended way of installing the libraries on top of the existing toolchain.

[ygribov]

test/Driver/fsanitize.c

221 ↗

(On Diff #42041)

the binary distribution is the source of truth, not the list of sanitizers hardcoded into Clang driver source code.

This will not work for cross-compilers. It _may_ be ok for OSX but not for other platforms.

[kubamracek]

test/Driver/fsanitize.c

221 ↗

(On Diff #42041)

Why not? On Linux, there are statically-linked sanitizers, if you want to cross-compile, you need to have the runtime libraries for the target. And dynamic libraries are a similar story – they're version-tied to the compiler and your compiler should really have the libraries of the sanitizers that it supports.

[ygribov]

test/Driver/fsanitize.c

221 ↗

(On Diff #42041)

Ah, for some strange reason I thought that you were searching runtime lib in sysroot rather than compiler root.

[zaks.anna]

LGTM.

Any other comments to this?

[beanz]

It looks like @samsonov had quite a few valid review comments that are still unresolved. I know he hasn't been active lately, but I think those points deserve discussion.

-Chris

[zaks.anna]

I missed that! Sorry about that.

[george.karpenkov]

Attempt #2: reduced version of this patch, without ubsan support.

[kubamracek]

This looks great to me, but someone else should review this as well.

[george.karpenkov]

@delcypher Could you take a look?
@kcc Any objections?

[delcypher]

Seems mostly fine apart from some minor nits.

If I'm honest I don't see any reason why this should be Darwin specific. Sure the naming convention and location of the runtime libraries is different for other platforms but other than that the same logic used here is applicable.
I don't feel that strongly about it and we could refactor later if other platforms need this if you really don't want to support this for other platforms.

clang/lib/Driver/ToolChains/Darwin.h

134

Why is this a SmallString<128> but in other places we're just using std::string?

427

I don't like this name very much. Given that the path is relative to the directory containing the library, what this function really does is given the file name for a sanitizer library. Mentioning "relative" is just confusing.

Wouldn't something like getSanitizerLibName() or getNameForSanitizerLib() be much clearer?

clang/test/Driver/darwin-asan-nofortify.c

3

Are these -resource-dir %S/Inputs/resource_dir needed because compiler-rt might not be present and now the driver checks for these?

[delcypher]

clang/lib/Driver/ToolChains/Darwin.cpp

2298

I feel that we should assert that Res doesn't already contain the SanitizerKind we are decided whether or not to set.
E.g.

assert(!(Res & SanitizerKind::Address));
if (sanitizerRuntimeExists("asan")) {
  Res |= SanitizerKind::Address;
}

[george.karpenkov]

@delcypher sorry i don't agree with the change requests.
@mracek any comments?

clang/lib/Driver/ToolChains/Darwin.cpp

2298

I'm not sure it would be worth crashing the driver.

clang/lib/Driver/ToolChains/Darwin.h

134

For driver it does not matter which datastructure to use.
Here SmallString is used because that's what is more convenient to return.

427

Then it's not clear whether the returned path is relative or absolute though.

clang/test/Driver/darwin-asan-nofortify.c

3

By default -resource-dir points to the resource dir in the "bin" directory. The contents of that is sort of random, and depends on what ninja commands have you ran before.

[delcypher]

clang/lib/Driver/ToolChains/Darwin.cpp

2298

Asserts are usually off in shipping compilers. If an assumption is being violated, as a developer it's better than you know about it during debugging.

clang/lib/Driver/ToolChains/Darwin.h

427

The name implies that it's a file name and not a path. It could be getSanitizerLibFileName() or getFileNameForSanitizerLib() but that seemed a little verbose.

[delcypher]

clang/lib/Driver/ToolChains/Darwin.h

425

You might want to update that comment to not mention "Relative path"

[delcypher]

@george.karpenkov Other than the comment that probably needs updating, LGTM.

[rnk]

+@thakis @hans

I think this broke Chromium's distributed Mac ASan build.

I personally found the error message confusing for the reasons that @samsonov mentioned back in 2015. It's not that ASan wasn't supported on the platform, it's just that the runtime library didn't happen to exist on the system performing compilation. If this is going to be based on a filesystem test, the diagnostic should be more mechanical in nature, i.e. actually tell the user that some required file doesn't exist.

In the meantime, I would like to revert this. I don't think our distributed build use case is that exotic, and I expect other users of distcc and icecreamcc will have similar issues with this change.

[george.karpenkov]

@rnk could you clarify how did it break the distributed asanified build? If the slave compiler supports asan it should have this runtime, right?

[george.karpenkov]

@rnk Regarding the error message, would it be possible to compromise on something like "sanitizer runtime not available"?
I understand that the exact error message would be very useful for you, but it's just confusing for a user getting a toolchain with Xcode, since they can't just add the required file into the toolchain.

[rnk]

In D15225#1183132, @george.karpenkov wrote:

@rnk could you clarify how did it break the distributed asanified build? If the slave compiler supports asan it should have this runtime, right?

Most open source distributed build systems wrap only compilation steps, not link steps. There's no reason to ship the runtime library just for compilation.

In D15225#1183135, @george.karpenkov wrote:

@rnk Regarding the error message, would it be possible to compromise on something like "sanitizer runtime not available"?
I understand that the exact error message would be very useful for you, but it's just confusing for a user getting a toolchain with Xcode, since they can't just add the required file into the toolchain.

I think you are underestimating the likelihood that users will repackage and redistribute the C/C++ toolchain parts of the XCode as part of their normal build processes. I think in principle it's better for clang to remain self-contained, for it to just "know" which platforms have working sanitizer libraries. It feels like this change is trying to check whether the link will succeed during compilation, which is kind of putting the cart before the horse.

[george.karpenkov]

it's just that the runtime library didn't happen to exist on the system performing compilation

But then conceptually, the compiler toolchain on the system performing compilation is not fully supporting asan, right?
It works for producing asanified object files, but fails with a link error if you wanted to produce an asanified executable.

[george.karpenkov]

@rnk OK I see, we've accidentally posted comments nearly simultaneously.

[george.karpenkov]

@rnk changing subjects: will you be at the LLVM social on Thursday? Could we discuss it there?

[rnk]

In D15225#1183318, @george.karpenkov wrote:

@rnk changing subjects: will you be at the LLVM social on Thursday? Could we discuss it there?

Yes, we can and should, but I'd like update chromium's copy of clang before then.

[george.karpenkov]

@rnk OK it's fine with me to revert it now and then we see what can be done.

[george.karpenkov]

@rnk As discussed, would it be acceptable for you to just have empty sanitizer runtime files in the resource directory?

[rnk]

In D15225#1191304, @george.karpenkov wrote:

@rnk As discussed, would it be acceptable for you to just have empty sanitizer runtime files in the resource directory?

I was talking to @beanz, and he suggested adding a cmake flag, something like CLANG_UNSUPPORTED_SANITIZERS=asan;ubsan;tsan;msan etc to control this. Alternatively, it could be a positive list of supported sanitizers, whatever is preferable.

I think my main objection to this is that while it's convenient from a packaging perspective, it ascribes too much significance to the existence or non-existence of some library files that aren't needed during compilation in the first place.

Changing the wording from "not supported" to "not available" doesn't seem that helpful. It would still lead someone down the path of needing to read the clang source code to understand that some library files are missing, whereas a link error would be more obvious.

It's also easy to imagine scenarios where the user has a slightly non-standard link setup and the runtime library ultimately doesn't come from the resource directory. For example, users checking out compiler-rt and building these libraries themselves, perhaps with additional instrumentation.

Overall, I feel like this is too tight coupling.

[rnk]

I got some actual data. The way we package clang today, the extracted installation is 134.83M, and lib/clang/7.0.0/lib/darwin/* is 13M, so it's a 10% increase. It would be worth it to us to replace these with empty files if this change does land, but again, I'd rather not go this direction, which would require special logic just for the darwin parts of compiler-rt.

clang/lib/Driver/ToolChains/Darwin.h

 namespace toolchains {
 
 class LLVM_LIBRARY_VISIBILITY MachO : public ToolChain {
 protected:
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
   Tool *getTool(Action::ActionClass AC) const override;
 
+  /// \return Directory to find the runtime library in.
+  SmallString<128> runtimeLibDir(bool IsEmbedded=false) const;
+
 private:
   mutable std::unique_ptr<tools::darwin::Lipo> Lipo;
   mutable std::unique_ptr<tools::darwin::Dsymutil> Dsymutil;
   mutable std::unique_ptr<tools::darwin::VerifyDebug> VerifyDebug;
 
 public:
   MachO(const Driver &D, const llvm::Triple &Triple,
         const llvm::opt::ArgList &Args);
public:
   bool SupportsProfiling() const override;
 
   bool UseDwarfDebugFlags() const override;
 
   llvm::ExceptionHandling
   GetExceptionModel(const llvm::opt::ArgList &Args) const override {
     return llvm::ExceptionHandling::None;
   }
-
   /// }
 };
 
 /// Darwin - The base Darwin tool chain.
 class LLVM_LIBRARY_VISIBILITY Darwin : public MachO {
 public:
   /// Whether the information on the target has been initialized.
   //
protected:
 
   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                              llvm::opt::ArgStringList &CC1Args,
                              Action::OffloadKind DeviceOffloadKind) const override;
 
   StringRef getPlatformFamily() const;
   StringRef getOSLibraryNameSuffix() const;
 
+  /// \return Relative path to the filename for the library
+  /// containing the sanitizer {@code SanitizerName}.
+  std::string sanitizerToRelativeLibName(StringRef SanitizerName,
+                                         bool Shared = true) const;
+
 public:
   static StringRef getSDKName(StringRef isysroot);
 
   /// }
   /// @name ToolChain Implementation
   /// {
 
   // Darwin tools support multiple architecture (e.g., i386 and x86_64) and
public:
   llvm::ExceptionHandling GetExceptionModel(
       const llvm::opt::ArgList &Args) const override;
 
   bool SupportsEmbeddedBitcode() const override;
 
   SanitizerMask getSupportedSanitizers() const override;
 
   void printVerboseInfo(raw_ostream &OS) const override;
+
+private:
+  /// \return Whether the runtime corresponding to the given
+  /// sanitizer exists in the toolchain.
+  bool sanitizerRuntimeExists(StringRef SanitizerName,
+                              bool Shared = true) const;
 };
 
 /// DarwinClang - The Darwin toolchain used by Clang.
 class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
 public:
   DarwinClang(const Driver &D, const llvm::Triple &Triple,
               const llvm::opt::ArgList &Args);
 

clang/lib/Driver/ToolChains/Darwin.cpp

 unsigned DarwinClang::GetDefaultDwarfVersion() const {
   // Default to use DWARF 2 on OS X 10.10 / iOS 8 and lower.
   if ((isTargetMacOS() && isMacosxVersionLT(10, 11)) ||
       (isTargetIOSBased() && isIPhoneOSVersionLT(9)))
     return 2;
   return 4;
 }
 
+SmallString<128> MachO::runtimeLibDir(bool IsEmbedded) const {
+  SmallString<128> Dir(getDriver().ResourceDir);
+  llvm::sys::path::append(
+      Dir, "lib", IsEmbedded ? "macho_embedded" : "darwin");
+  return Dir;
+}
+
+std::string Darwin::sanitizerToRelativeLibName(StringRef SanitizerName,
+                                              bool Shared) const {
+  return (Twine("libclang_rt.") + SanitizerName + "_" +
+                      getOSLibraryNameSuffix() +
+                      (Shared ? "_dynamic.dylib" : ".a")).str();
+
+}
+
 void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
                               StringRef DarwinLibName,
                               RuntimeLinkOptions Opts) const {
-  SmallString<128> Dir(getDriver().ResourceDir);
-  llvm::sys::path::append(
-      Dir, "lib", (Opts & RLO_IsEmbedded) ? "macho_embedded" : "darwin");
 
+  SmallString<128> Dir = runtimeLibDir(Opts & RLO_IsEmbedded);
   SmallString<128> P(Dir);
   llvm::sys::path::append(P, DarwinLibName);
 
   // For now, allow missing resource libraries to support developers who may
   // not have compiler-rt checked out or integrated into their build (unless
   // we explicitly force linking with this library).
   if ((Opts & RLO_AlwaysLink) || getVFS().exists(P)) {
     const char *LibArg = Args.MakeArgString(P);
void Darwin::addProfileRTLibs(const ArgList &Args,
   }
 }
 
 void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
                                           ArgStringList &CmdArgs,
                                           StringRef Sanitizer,
                                           bool Shared) const {
   auto RLO = RuntimeLinkOptions(RLO_AlwaysLink | (Shared ? RLO_AddRPath : 0U));
-  AddLinkRuntimeLib(Args, CmdArgs,
-                    (Twine("libclang_rt.") + Sanitizer + "_" +
-                     getOSLibraryNameSuffix() +
-                     (Shared ? "_dynamic.dylib" : ".a"))
-                        .str(),
-                    RLO);
+  std::string SanitizerRelFilename =
+      sanitizerToRelativeLibName(Sanitizer, Shared);
+  AddLinkRuntimeLib(Args, CmdArgs, SanitizerRelFilename, RLO);
 }
 
 ToolChain::RuntimeLibType DarwinClang::GetRuntimeLibType(
     const ArgList &Args) const {
   if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
     StringRef Value = A->getValue();
     if (Value != "compiler-rt")
       getDriver().Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
if (isTargetIOSBased() || isTargetWatchOSBased() ||
       (isTargetMacOS() && !isMacosxVersionLT(10, 6)))
     return;
   getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
 }
 
 SanitizerMask Darwin::getSupportedSanitizers() const {
   const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
   SanitizerMask Res = ToolChain::getSupportedSanitizers();
+
+  if (sanitizerRuntimeExists("asan"))
     Res |= SanitizerKind::Address;
+  if (sanitizerRuntimeExists("lsan"))
     Res |= SanitizerKind::Leak;
+  if (sanitizerRuntimeExists("fuzzer", /*Shared=*/false)) {
     Res |= SanitizerKind::Fuzzer;
     Res |= SanitizerKind::FuzzerNoLink;
+  }
   Res |= SanitizerKind::Function;
-  if (isTargetMacOS()) {
-    if (!isMacosxVersionLT(10, 9))
-      Res |= SanitizerKind::Vptr;
+  if (isTargetMacOS() && !isMacosxVersionLT(10, 9))
+  if (isTargetMacOS())
     Res |= SanitizerKind::SafeStack;
-    if (IsX86_64)
-      Res |= SanitizerKind::Thread;
-  } else if (isTargetIOSSimulator() || isTargetTvOSSimulator()) {
-    if (IsX86_64)
-      Res |= SanitizerKind::Thread;
-  }
+
+  if (sanitizerRuntimeExists("tsan") && IsX86_64 &&
+      (isTargetMacOS() || isTargetIOSSimulator() || isTargetTvOSSimulator()))
+
   return Res;
 }
 
 void Darwin::printVerboseInfo(raw_ostream &OS) const {
   CudaInstallation.print(OS);
 }
+
+bool Darwin::sanitizerRuntimeExists(StringRef SanitizerName,
+                                    bool Shared) const {
+    std::string RelName = sanitizerToRelativeLibName(SanitizerName, Shared);
+    SmallString<128> Dir = runtimeLibDir();
+    SmallString<128> AbsName(Dir);
+    llvm::sys::path::append(AbsName, RelName);
+    return getVFS().exists(AbsName);
+}

clang/test/Driver/darwin-asan-nofortify.c

 // Make sure AddressSanitizer disables _FORTIFY_SOURCE on Darwin.
 
-// RUN: %clang -fsanitize=address  %s -E -dM -target x86_64-darwin | FileCheck %s
+// RUN: %clang -fsanitize=address  %s -E -dM -target x86_64-darwin -resource-dir %S/Inputs/resource_dir | FileCheck %s
 
 // CHECK: #define _FORTIFY_SOURCE 0

clang/test/Driver/darwin-sanitizer-ld.c

 // Test sanitizer link flags on Darwin.
 
 // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   -stdlib=platform -fsanitize=address %s -o %t.o 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-ASAN %s
 
 // CHECK-ASAN: "{{.*}}ld{{(.exe)?}}"
 // CHECK-ASAN-NOT: "-lstdc++"
 // CHECK-ASAN-NOT: "-lc++"
 // CHECK-ASAN: libclang_rt.asan_osx_dynamic.dylib"
 // CHECK-ASAN: "-rpath" "@executable_path"
 // CHECK-ASAN: "-rpath" "{{.*}}lib{{.*}}darwin"
 
 // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \
+// RUN:   -resource-dir %S/Inputs/fake_resource_dir \
+// RUN:   -stdlib=platform -fsanitize=address %s -o %t.o 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-LOAD-FAIL %s
+
+// CHECK-LOAD-FAIL: error: unsupported option '-fsanitize=address' for target 'x86_64--darwin'
+
+// RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   -fPIC -shared -fsanitize=address %s -o %t.so 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-DYN-ASAN %s
 
 // CHECK-DYN-ASAN: "{{.*}}ld{{(.exe)?}}"
 // CHECK-DYN-ASAN: "-dylib"
 // CHECK-DYN-ASAN: libclang_rt.asan_osx_dynamic.dylib"
 // CHECK-DYN-ASAN: "-rpath" "@executable_path"
 // CHECK-DYN-ASAN: "-rpath" "{{.*}}lib{{.*}}darwin"
 
 // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   -stdlib=platform -fsanitize=undefined %s -o %t.o 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-UBSAN %s
 
 // CHECK-UBSAN: "{{.*}}ld{{(.exe)?}}"
 // CHECK-UBSAN-NOT: "-lstdc++"
 // CHECK-UBSAN-NOT: "-lc++"
 // CHECK-UBSAN: libclang_rt.ubsan_osx_dynamic.dylib"
 // CHECK-UBSAN: "-rpath" "@executable_path"
 // CHECK-UBSAN: "-rpath" "{{.*}}lib{{.*}}darwin"
 
 // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \
 // RUN:   -fsanitize=bounds -fsanitize-undefined-trap-on-error \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   %s -o %t.o 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-BOUNDS %s
 
 // CHECK-BOUNDS: "{{.*}}ld{{(.exe)?}}"
 // CHECK-BOUNDS-NOT: libclang_rt.ubsan_osx.a"
 
 // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \
 // RUN:   -fPIC -shared -fsanitize=undefined %s -o %t.so 2>&1 \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   | FileCheck --check-prefix=CHECK-DYN-UBSAN %s
 
 // CHECK-DYN-UBSAN: "{{.*}}ld{{(.exe)?}}"
 // CHECK-DYN-UBSAN: "-dylib"
 // CHECK-DYN-UBSAN: libclang_rt.ubsan_osx_dynamic.dylib"
 // CHECK-DYN-UBSAN: "-rpath" "@executable_path"
 // CHECK-DYN-UBSAN: "-rpath" "{{.*}}lib{{.*}}darwin"
 
 // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \
 // RUN:   -fsanitize=bounds -fsanitize-undefined-trap-on-error \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   %s -o %t.so -fPIC -shared 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-DYN-BOUNDS %s
 
 // CHECK-DYN-BOUNDS: "{{.*}}ld{{(.exe)?}}"
 // CHECK-DYN-BOUNDS-NOT: ubsan_osx
 
 // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \
 // RUN:   -stdlib=platform -fsanitize=address -mios-simulator-version-min=7.0 \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   %s -o %t.o 2>&1 | FileCheck --check-prefix=CHECK-ASAN-IOSSIM %s
 
 // CHECK-ASAN-IOSSIM: "{{.*}}ld{{(.exe)?}}"
 // CHECK-ASAN-IOSSIM-NOT: "-lstdc++"
 // CHECK-ASAN-IOSSIM-NOT: "-lc++"
 // CHECK-ASAN-IOSSIM: libclang_rt.asan_iossim_dynamic.dylib"
 // CHECK-ASAN-IOSSIM: "-rpath" "@executable_path"
 // CHECK-ASAN-IOSSIM: "-rpath" "{{.*}}lib{{.*}}darwin"
 
 // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   -stdlib=platform -fsanitize=address \
 // RUN:   -mtvos-simulator-version-min=8.3.0 %s -o %t.o 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-ASAN-TVOSSIM %s
 
 // CHECK-ASAN-TVOSSIM: "{{.*}}ld{{(.exe)?}}"
 // CHECK-ASAN-TVOSSIM-NOT: "-lstdc++"
 // CHECK-ASAN-TVOSSIM-NOT: "-lc++"
 // CHECK-ASAN-TVOSSIM: libclang_rt.asan_tvossim_dynamic.dylib"
 // CHECK-ASAN-TVOSSIM: "-rpath" "@executable_path"
 // CHECK-ASAN-TVOSSIM: "-rpath" "{{.*}}lib{{.*}}darwin"
 
 // RUN: %clang -no-canonical-prefixes -### -target x86_64-darwin \
 // RUN:   -stdlib=platform -fsanitize=address \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   -mwatchos-simulator-version-min=2.0.0 %s -o %t.o 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-ASAN-WATCHOSSIM %s
 
 // CHECK-ASAN-WATCHOSSIM: "{{.*}}ld{{(.exe)?}}"
 // CHECK-ASAN-WATCHOSSIM-NOT: "-lstdc++"
 // CHECK-ASAN-WATCHOSSIM-NOT: "-lc++"
 // CHECK-ASAN-WATCHOSSIM: libclang_rt.asan_watchossim_dynamic.dylib"
 // CHECK-ASAN-WATCHOSSIM: "-rpath" "@executable_path"
 // CHECK-ASAN-WATCHOSSIM: "-rpath" "{{.*}}lib{{.*}}darwin"
 
 // RUN: %clang -no-canonical-prefixes -### -target armv7-apple-ios  \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   -stdlib=platform -fsanitize=address -miphoneos-version-min=7 \
 // RUN:   %s -o %t.o 2>&1 | FileCheck --check-prefix=CHECK-ASAN-IOS %s
 
 // CHECK-ASAN-IOS: "{{.*}}ld{{(.exe)?}}"
 // CHECK-ASAN-IOS-NOT: "-lstdc++"
 // CHECK-ASAN-IOS-NOT: "-lc++"
 // CHECK-ASAN-IOS: libclang_rt.asan_ios_dynamic.dylib"
 // CHECK-ASAN-IOS: "-rpath" "@executable_path"
 // CHECK-ASAN-IOS: "-rpath" "{{.*}}lib{{.*}}darwin"
 
 // RUN: %clang -no-canonical-prefixes -### -target arm64-apple-tvos \
 // RUN:   -stdlib=platform -fsanitize=address -mtvos-version-min=8.3 \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   %s -o %t.o 2>&1 | FileCheck --check-prefix=CHECK-ASAN-TVOS %s
 
 // CHECK-ASAN-TVOS: "{{.*}}ld{{(.exe)?}}"
 // CHECK-ASAN-TVOS-NOT: "-lstdc++"
 // CHECK-ASAN-TVOS-NOT: "-lc++"
 // CHECK-ASAN-TVOS: libclang_rt.asan_tvos_dynamic.dylib"
 // CHECK-ASAN-TVOS: "-rpath" "@executable_path"
 // CHECK-ASAN-TVOS: "-rpath" "{{.*}}lib{{.*}}darwin"
 
 // RUN: %clang -no-canonical-prefixes -### -target armv7k-apple-watchos \
 // RUN:   -stdlib=platform -fsanitize=address -mwatchos-version-min=2.0 \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
 // RUN:   %s -o %t.o 2>&1 | FileCheck --check-prefix=CHECK-ASAN-WATCHOS %s
 
 // CHECK-ASAN-WATCHOS: "{{.*}}ld{{(.exe)?}}"
 // CHECK-ASAN-WATCHOS-NOT: "-lstdc++"
 // CHECK-ASAN-WATCHOS-NOT: "-lc++"
 // CHECK-ASAN-WATCHOS: libclang_rt.asan_watchos_dynamic.dylib"
 // CHECK-ASAN-WATCHOS: "-rpath" "@executable_path"
 // CHECK-ASAN-WATCHOS: "-rpath" "{{.*}}lib{{.*}}darwin"

clang/test/Driver/fsanitize.c

 // CHECK-DIAG1-NOT: unsupported argument 'zzz' to option 'fsanitize='
 
 // RUN: %clang -target x86_64-apple-darwin10 -fsanitize=memory %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MSAN-DARWIN
 // CHECK-MSAN-DARWIN: unsupported option '-fsanitize=memory' for target 'x86_64-apple-darwin10'
 
 // RUN: %clang -target x86_64-apple-darwin10 -fsanitize=memory -fno-sanitize=memory %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MSAN-NOMSAN-DARWIN
 // CHECK-MSAN-NOMSAN-DARWIN-NOT: unsupported option
 
-// RUN: %clang -target x86_64-apple-darwin10 -fsanitize=memory -fsanitize=thread,memory %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MSAN-TSAN-MSAN-DARWIN
+// RUN: %clang -target x86_64-apple-darwin10 -fsanitize=memory -fsanitize=thread,memory -resource-dir %S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MSAN-TSAN-MSAN-DARWIN
 // CHECK-MSAN-TSAN-MSAN-DARWIN: unsupported option '-fsanitize=memory' for target 'x86_64-apple-darwin10'
 // CHECK-MSAN-TSAN-MSAN-DARWIN-NOT: unsupported option
 
-// RUN: %clang -target x86_64-apple-darwin10 -fsanitize=thread,memory -fsanitize=memory %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-MSAN-MSAN-DARWIN
+// RUN: %clang -target x86_64-apple-darwin10 -fsanitize=thread,memory -fsanitize=memory -resource-dir %S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-MSAN-MSAN-DARWIN
 // CHECK-TSAN-MSAN-MSAN-DARWIN: unsupported option '-fsanitize=memory' for target 'x86_64-apple-darwin10'
 // CHECK-TSAN-MSAN-MSAN-DARWIN-NOT: unsupported option
 
-// RUN: %clang -target x86_64-apple-darwin -fsanitize=thread %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-X86-64-DARWIN
+// RUN: %clang -target x86_64-apple-darwin -fsanitize=thread -resource-dir %S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-X86-64-DARWIN
 // CHECK-TSAN-X86-64-DARWIN-NOT: unsupported option
 
-// RUN: %clang -target x86_64-apple-iossimulator -fsanitize=thread %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-X86-64-IOSSIMULATOR
+// RUN: %clang -target x86_64-apple-iossimulator -fsanitize=thread -resource-dir %S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-X86-64-IOSSIMULATOR
 // CHECK-TSAN-X86-64-IOSSIMULATOR-NOT: unsupported option
 
-// RUN: %clang -target x86_64-apple-tvossimulator -fsanitize=thread %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-X86-64-TVOSSIMULATOR
+// RUN: %clang -target x86_64-apple-tvossimulator -fsanitize=thread -resource-dir %S/Inputs/resource_dir  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-X86-64-TVOSSIMULATOR
 // CHECK-TSAN-X86-64-TVOSSIMULATOR-NOT: unsupported option
 
-// RUN: %clang -target i386-apple-darwin -fsanitize=thread %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-I386-DARWIN
+// RUN: %clang -target i386-apple-darwin -fsanitize=thread -resource-dir %S/Inputs/resource_dir  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-I386-DARWIN
 // CHECK-TSAN-I386-DARWIN: unsupported option '-fsanitize=thread' for target 'i386-apple-darwin'
 
 // RUN: %clang -target arm-apple-ios -fsanitize=thread %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-ARM-IOS
 // CHECK-TSAN-ARM-IOS: unsupported option '-fsanitize=thread' for target 'arm-apple-ios'
 
 // RUN: %clang -target i386-apple-iossimulator -fsanitize=thread %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-I386-IOSSIMULATOR
 // CHECK-TSAN-I386-IOSSIMULATOR: unsupported option '-fsanitize=thread' for target 'i386-apple-iossimulator-simulator'
 

 
 // RUN: %clang -target i386-pc-openbsd -fsanitize=memory %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MSAN-OPENBSD
 // CHECK-MSAN-OPENBSD: unsupported option '-fsanitize=memory' for target 'i386-pc-openbsd'
 
 // RUN: %clang -target i386-pc-openbsd -fsanitize=efficiency-cache-frag %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ESAN-OPENBSD
 // RUN: %clang -target i386-pc-openbsd -fsanitize=efficiency-working-set %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ESAN-OPENBSD
 // CHECK-ESAN-OPENBSD: error: unsupported option '-fsanitize=efficiency-{{.*}}' for target 'i386-pc-openbsd'
 
-// RUN: %clang -target x86_64-apple-darwin -fsanitize=leak %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-X86-64-DARWIN
+// RUN: %clang -target x86_64-apple-darwin -fsanitize=leak -resource-dir %S/Inputs/resource_dir  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-X86-64-DARWIN
 // CHECK-LSAN-X86-64-DARWIN-NOT: unsupported option
 
-// RUN: %clang -target x86_64-apple-iossimulator -fsanitize=leak %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-X86-64-IOSSIMULATOR
+// RUN: %clang -target x86_64-apple-iossimulator -fsanitize=leak -resource-dir %S/Inputs/resource_dir  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-X86-64-IOSSIMULATOR
 // CHECK-LSAN-X86-64-IOSSIMULATOR-NOT: unsupported option
 
-// RUN: %clang -target x86_64-apple-tvossimulator -fsanitize=leak %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-X86-64-TVOSSIMULATOR
+// RUN: %clang -target x86_64-apple-tvossimulator -fsanitize=leak -resource-dir %S/Inputs/resource_dir  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-X86-64-TVOSSIMULATOR
 // CHECK-LSAN-X86-64-TVOSSIMULATOR-NOT: unsupported option
 
-// RUN: %clang -target i386-apple-darwin -fsanitize=leak %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-I386-DARWIN
+// RUN: %clang -target i386-apple-darwin -fsanitize=leak -resource-dir %S/Inputs/resource_dir  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-I386-DARWIN
 // CHECK-LSAN-I386-DARWIN-NOT: unsupported option
 
-// RUN: %clang -target arm-apple-ios -fsanitize=leak %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-ARM-IOS
+// RUN: %clang -target arm-apple-ios -fsanitize=leak -resource-dir %S/Inputs/resource_dir  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-ARM-IOS
 // CHECK-LSAN-ARM-IOS-NOT: unsupported option
 
-// RUN: %clang -target i386-apple-iossimulator -fsanitize=leak %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-I386-IOSSIMULATOR
+// RUN: %clang -target i386-apple-iossimulator -fsanitize=leak -resource-dir %S/Inputs/resource_dir  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-I386-IOSSIMULATOR
 // CHECK-LSAN-I386-IOSSIMULATOR-NOT: unsupported option
 
-// RUN: %clang -target i386-apple-tvossimulator -fsanitize=leak %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-I386-TVOSSIMULATOR
+// RUN: %clang -target i386-apple-tvossimulator -fsanitize=leak -resource-dir %S/Inputs/resource_dir  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-LSAN-I386-TVOSSIMULATOR
 // CHECK-LSAN-I386-TVOSSIMULATOR-NOT: unsupported option
 
 // RUN: %clang -target i686-linux-gnu -fsanitize=efficiency-cache-frag %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ESAN-X86
 // RUN: %clang -target i686-linux-gnu -fsanitize=efficiency-working-set %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ESAN-X86
 // CHECK-ESAN-X86: error: unsupported option '-fsanitize=efficiency-{{.*}}' for target 'i686--linux-gnu'
 
 // RUN: %clang -target x86_64-apple-darwin10 -fsanitize=efficiency-cache-frag %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ESAN-DARWIN
 // RUN: %clang -target x86_64-apple-darwin10 -fsanitize=efficiency-working-set %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ESAN-DARWIN

clang/test/Driver/fuzzer.c

 // Test flags inserted by -fsanitize=fuzzer.
 
-// RUN: %clang -fsanitize=fuzzer %s -target x86_64-apple-darwin14 -### 2>&1 | FileCheck --check-prefixes=CHECK-FUZZER-LIB,CHECK-COVERAGE-FLAGS %s
+// RUN: %clang -fsanitize=fuzzer %s -target x86_64-apple-darwin14 -resource-dir %S/Inputs/resource_dir -### 2>&1 | FileCheck --check-prefixes=CHECK-FUZZER-LIB,CHECK-COVERAGE-FLAGS %s
 //
 // CHECK-FUZZER-LIB: libclang_rt.fuzzer
 // CHECK-COVERAGE: -fsanitize-coverage-inline-8bit-counters
 // CHECK-COVERAGE-SAME: -fsanitize-coverage-indirect-calls
 // CHECK-COVERAGE-SAME: -fsanitize-coverage-trace-cmp
 // CHECK-COVERAGE-SAME: -fsanitize-coverage-pc-table
 
-// RUN: %clang -fsanitize=fuzzer -target i386-unknown-linux -stdlib=platform %s -### 2>&1 | FileCheck --check-prefixes=CHECK-LIBCXX-LINUX %s
+// RUN: %clang -fsanitize=fuzzer -target i386-unknown-linux -stdlib=platform -resource-dir %S/Inputs/resource_dir %s -### 2>&1 | FileCheck --check-prefixes=CHECK-LIBCXX-LINUX %s
 //
 // CHECK-LIBCXX-LINUX: -lstdc++
 
-// RUN: %clang -target x86_64-apple-darwin14 -fsanitize=fuzzer %s -### 2>&1 | FileCheck --check-prefixes=CHECK-LIBCXX-DARWIN %s
+// RUN: %clang -target x86_64-apple-darwin14 -fsanitize=fuzzer -resource-dir %S/Inputs/resource_dir %s -### 2>&1 | FileCheck --check-prefixes=CHECK-LIBCXX-DARWIN %s
 //
 // CHECK-LIBCXX-DARWIN: -lc++
 
 
 // Check that we don't link in libFuzzer.a when producing a shared object.
-// RUN: %clang -fsanitize=fuzzer %s -shared -o %t.so -### 2>&1 | FileCheck --check-prefixes=CHECK-NOLIB-SO %s
+// RUN: %clang -fsanitize=fuzzer %s -shared -o %t.so -resource-dir %S/Inputs/resource_dir -### 2>&1 | FileCheck --check-prefixes=CHECK-NOLIB-SO %s
 // CHECK-NOLIB-SO-NOT: libclang_rt.libfuzzer
 
 // Check that we don't link in libFuzzer when compiling with -fsanitize=fuzzer-no-link.
-// RUN: %clang -fsanitize=fuzzer-no-link %s -target x86_64-apple-darwin14 -### 2>&1 | FileCheck --check-prefixes=CHECK-NOLIB,CHECK-COV %s
+// RUN: %clang -fsanitize=fuzzer-no-link %s -target x86_64-apple-darwin14 -resource-dir %S/Inputs/resource_dir -### 2>&1 | FileCheck --check-prefixes=CHECK-NOLIB,CHECK-COV %s
 // CHECK-NOLIB-NOT: libclang_rt.libfuzzer
 // CHECK-COV: -fsanitize-coverage-inline-8bit-counters
 
 // RUN: %clang -fsanitize=fuzzer -fsanitize-coverage=trace-pc %s -### 2>&1 | FileCheck --check-prefixes=CHECK-MSG %s
 // CHECK-MSG-NOT: argument unused during compilation
 
 int LLVMFuzzerTestOneInput(const char *Data, long Size) {
   return 0;
 }

clang/test/Driver/sanitizer-ld.c

 // RUN:     --sysroot=%S/Inputs/basic_android_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-CFI-CROSS-DSO-DIAG-ANDROID %s
 // CHECK-CFI-CROSS-DSO-DIAG-ANDROID: "{{.*}}ld{{(.exe)?}}"
 // CHECK-CFI-CROSS-DSO-DIAG-ANDROID: "{{[^"]*}}libclang_rt.ubsan_standalone-aarch64-android.so"
 // CHECK-CFI-CROSS-DSO-DIAG-ANDROID: "-export-dynamic-symbol=__cfi_check"
 
 // RUN: %clangxx -fsanitize=address %s -### -o %t.o 2>&1 \
 // RUN:     -mmacosx-version-min=10.6 \
+// RUN:     -resource-dir=%S/Inputs/resource_dir \
 // RUN:     -target x86_64-apple-darwin13.4.0 -fuse-ld=ld -stdlib=platform \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-ASAN-DARWIN106-CXX %s
 // CHECK-ASAN-DARWIN106-CXX: "{{.*}}ld{{(.exe)?}}"
 // CHECK-ASAN-DARWIN106-CXX: libclang_rt.asan_osx_dynamic.dylib
 // CHECK-ASAN-DARWIN106-CXX-NOT: -lc++abi
 
 // RUN: %clangxx -fsanitize=leak %s -### -o %t.o 2>&1 \
 // RUN:     -mmacosx-version-min=10.6 \
+// RUN:     -resource-dir=%S/Inputs/resource_dir \
 // RUN:     -target x86_64-apple-darwin13.4.0 -fuse-ld=ld -stdlib=platform \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-LSAN-DARWIN106-CXX %s
 // CHECK-LSAN-DARWIN106-CXX: "{{.*}}ld{{(.exe)?}}"
 // CHECK-LSAN-DARWIN106-CXX: libclang_rt.lsan_osx_dynamic.dylib
 // CHECK-LSAN-DARWIN106-CXX-NOT: -lc++abi
 
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \

 // RUN:   | FileCheck --check-prefix=CHECK-CFI-STATS-LINUX %s
 // CHECK-CFI-STATS-LINUX: "{{.*}}ld{{(.exe)?}}"
 // CHECK-CFI-STATS-LINUX: "--whole-archive" "{{[^"]*}}libclang_rt.stats_client-x86_64.a" "--no-whole-archive"
 // CHECK-CFI-STATS-LINUX-NOT: "--whole-archive"
 // CHECK-CFI-STATS-LINUX: "{{[^"]*}}libclang_rt.stats-x86_64.a"
 
 // RUN: %clang -fsanitize=cfi -fsanitize-stats %s -### -o %t.o 2>&1 \
 // RUN:     -target x86_64-apple-darwin -fuse-ld=ld \
+// RUN:     -resource-dir=%S/Inputs/resource_dir \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-CFI-STATS-DARWIN %s
 // CHECK-CFI-STATS-DARWIN: "{{.*}}ld{{(.exe)?}}"
 // CHECK-CFI-STATS-DARWIN: "{{[^"]*}}libclang_rt.stats_client_osx.a"
 // CHECK-CFI-STATS-DARWIN: "{{[^"]*}}libclang_rt.stats_osx_dynamic.dylib"
 
 // RUN: %clang -fsanitize=cfi -fsanitize-stats %s -### -o %t.o 2>&1 \
 // RUN:     -target x86_64-pc-windows \