SanitizerArgs: add ability to filter/diagnose unsupported sanitizers.

[pcc]

Summary

The sanitizers whose supported set of platforms I am sure of are now diagnosed
if enabled explicitly on an unsupported platform. Unsupported sanitizers which
are enabled implicitly (as part of a larger group) are silently disabled. As a
side effect, this makes SanitizerArgs parsing toolchain-dependent (and thus
essentially reverts r188058), and moves SanitizerArgs ownership to ToolChain.

[samsonov]

+Richard, who reviewed the original patch

I support this change.

include/clang/Driver/SanitizerArgs.h

119

Can you add a comment for these functions?

lib/Driver/SanitizerArgs.cpp

230

This part:

if (Kinds & Foo) {
  Kinds &= ~Foo;
  <...>
}

can be factored out into a separate function.

[rsmith]

Yes, moving ownership of the SanitizerArgs from Driver to ToolChain makes sense to me; the latter is parameterized by a set of command-line arguments, the former is not. I also support this change =)

[pcc]

• Address reviewer comments

[samsonov]

lib/Driver/SanitizerArgs.cpp

229

Do an early return here instead.

243

-fsanitize=thread is also unsupported in this case.

lib/Driver/ToolChains.cpp

301

Can you move this piece to filterUnsupportedKinds?

316

Can you move this piece to filterUnsupportedKinds?

[pcc]

lib/Driver/SanitizerArgs.cpp

229

Done.

243

Added.

lib/Driver/ToolChains.cpp

301

I think so. The logic behind isTargetIPhoneOS() and isTargetIOSSimulator() is in Darwin::AddDeploymentTarget and is rather more complex than my translation (e.g. it checks certain flags). This branch was untested though, so I'm inclined to change the logic and let Apple folks fix this if it causes a problem.

316

Likewise.

[pcc]

• Address reviewer comments

[glider]

lib/Driver/ToolChains.cpp

301

The reason behind the check for "isTargetIPhoneOS() && !isTargetIOSSimulator()" in ASan (added by me) was to prevent people from trying ASan on the real iOS devices where it doesn't work, but let them use ASan for iossim builds.
I'd love to keep this check, if possible.

[samsonov]

include/clang/Basic/DiagnosticDriverKinds.td

66 ↗

(On Diff #5116)

separate commit?

include/clang/Driver/SanitizerArgs.h

136

Kind is actually a Mask. There is no FlagName parameter. Consider fixing parameter names and comment.

lib/Driver/SanitizerArgs.cpp

50

please remove blank lines in added block

233

ditto

247

I'd appreciate booleans like "IsLinux", "IsX86" etc. for brevity.

259

Make sure you agree with glider@ on this part. I think it would be fine to revert this piece to get the patch committed, leave a FIXME, and deal with/refactor this part later.

[pcc]

• Address reviewer comments

include/clang/Basic/DiagnosticDriverKinds.td

66 ↗

(On Diff #5116)

Yeah, this would go with whichever commit removes the isTargetIOS checks.

include/clang/Driver/SanitizerArgs.h

136

Updated.

lib/Driver/SanitizerArgs.cpp

50

Done.

233

Done.

247

Done.

259

After investigating how Xcode builds iOS stuff on Darwin I think I've come to the conclusion that the driver sees the wrong triple, so my change wouldn't work. Reverted to be dealt with later.

[rsmith]

lib/Driver/SanitizerArgs.cpp

47–52

If I say:

clang -target triple -fsanitize=foo,bar -fno-sanitize=bar

and bar is not supported on triple, I don't think we should diagnose it.

[pcc]

• Avoid diagnosing unsupported sanitizers which are added then removed

lib/Driver/SanitizerArgs.cpp

47–52

Agree, done.

[rsmith]

lib/Driver/SanitizerArgs.cpp

51

Hmm, should we mask out AllAdd here too? We don't want to issue two diagnostics for -fsanitize=bad -fsanitize=bad. But on the other hand diagnosing -fsanitize=bad -fsanitize=group-including-bad might be nice. Ugh. Maybe what we want is a limit of one diagnostic per problem?

120–123

This looks a bit strange. We won't diagnose

-fsanitize=address -fno-sanitize=address -fsanitize=init-order

Following the principle of later arguments overriding earlier ones, I would have expected a diagnostic for that, but not for:

-fsanitize=address -fsanitize=init-order -fno-sanitize=address

Seems to be a pre-existing oddness, though.

[pcc]

• Address review comments

lib/Driver/SanitizerArgs.cpp

51

Yes, masking out AllAdd doesn't seem like it will work trivially. Deduplicating in filterUnsupportedMask by accumulating a mask of diagnosed kinds seems to work, although (as the new test shows) we don't give the best diagnostics in the world sometimes.

120–123

*shrug* I'll let Alexey comment on this, as he introduced this behavior in r173670.

[samsonov]

The change looks good to me.

lib/Driver/SanitizerArgs.cpp

46

Please less blank lines here

120–123

Yes, that one is tricky :( I planned to remove this code together with -fsanitize=init-order option, so I'd rather not heavily modify it.

256

ditto

[pcc]

• Remove blank lines

[pcc]

Closed by commit rL193875 (authored by @pcc).

include/clang/Driver/Driver.h

private:
 
   /// \brief Cache of all the ToolChains in use by the driver.
   ///
   /// This maps from the string representation of a triple to a ToolChain
   /// created targeting that triple. The driver owns all the ToolChain objects
   /// stored in it, and will clean them up when torn down.
   mutable llvm::StringMap<ToolChain *> ToolChains;
 
-  /// Parsed arguments passed to sanitizer tools.
-  mutable llvm::OwningPtr<SanitizerArgs> SanitizerArguments;
-
 private:
   /// TranslateInputArgs - Create a new derived argument list from the input
   /// arguments, after applying the standard argument translations.
   llvm::opt::DerivedArgList *
   TranslateInputArgs(const llvm::opt::InputArgList &Args) const;
 
   // getFinalPhase - Determine which compilation mode we are in and record 
   // which option we used to determine the final phase.
private:
 
   /// @}
 
   /// \brief Get bitmasks for which option flags to include and exclude based on
   /// the driver mode.
   std::pair<unsigned, unsigned> getIncludeExcludeOptionFlagMasks() const;
 
 public:
-  /// \brief Returns parsed arguments to sanitizer tools.
-  const SanitizerArgs &
-  getOrParseSanitizerArgs(const llvm::opt::ArgList &Args) const;
-
   /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and
   /// return the grouped values as integers. Numbers which are not
   /// provided are set to 0.
   ///
   /// \return True if the entire string was parsed (9.2), or all
   /// groups were parsed (10.3.5extrastuff). HadExtra is true if all
   /// groups were parsed but extra characters remain at the end.
   static bool GetReleaseVersion(const char *Str, unsigned &Major,
                                 unsigned &Minor, unsigned &Micro,
                                 bool &HadExtra);
 };
 
 } // end namespace driver
 } // end namespace clang
 
 #endif

include/clang/Driver/SanitizerArgs.h

 class Driver;
 class ToolChain;
 
 class SanitizerArgs {
   /// Assign ordinals to sanitizer flags. We'll use the ordinal values as
   /// bit positions within \c Kind.
   enum SanitizeOrdinal {
 #define SANITIZER(NAME, ID) SO_##ID,
+#define SANITIZER_GROUP(NAME, ID, ALIAS) SO_##ID##Group,
 #include "clang/Basic/Sanitizers.def"
     SO_Count
   };
 
   /// Bugs to catch at runtime.
   enum SanitizeKind {
 #define SANITIZER(NAME, ID) ID = 1 << SO_##ID,
-#define SANITIZER_GROUP(NAME, ID, ALIAS) ID = ALIAS,
+#define SANITIZER_GROUP(NAME, ID, ALIAS)                                       \
+  ID = ALIAS, ID##Group = 1 << SO_##ID##Group,
 #include "clang/Basic/Sanitizers.def"
     NeedsAsanRt = Address,
     NeedsTsanRt = Thread,
     NeedsMsanRt = Memory,
     NeedsDfsanRt = DataFlow,
     NeedsLeakDetection = Leak,
     NeedsUbsanRt = Undefined | Integer,
     NotAllowedWithTrap = Vptr,
     HasZeroBaseShadow = Thread | Memory | DataFlow
   };
   unsigned Kind;
 
   std::string BlacklistFile;
   bool MsanTrackOrigins;
-  enum AsanZeroBaseShadowKind {
-    AZBSK_Default,  // Default value is toolchain-specific.
-    AZBSK_On,
-    AZBSK_Off
-  } AsanZeroBaseShadow;
+  bool AsanZeroBaseShadow;
   bool UbsanTrapOnError;
 
  public:
   SanitizerArgs();
   /// Parses the sanitizer arguments from an argument list.
-  SanitizerArgs(const Driver &D, const llvm::opt::ArgList &Args);
+  SanitizerArgs(const ToolChain &TC, const llvm::opt::ArgList &Args);
 
   bool needsAsanRt() const { return Kind & NeedsAsanRt; }
   bool needsTsanRt() const { return Kind & NeedsTsanRt; }
   bool needsMsanRt() const { return Kind & NeedsMsanRt; }
   bool needsLeakDetection() const { return Kind & NeedsLeakDetection; }
   bool needsLsanRt() const {
     return needsLeakDetection() && !needsAsanRt();
   }
   bool needsUbsanRt() const {
     return !UbsanTrapOnError && (Kind & NeedsUbsanRt);
   }
   bool needsDfsanRt() const { return Kind & NeedsDfsanRt; }
 
   bool sanitizesVptr() const { return Kind & Vptr; }
   bool notAllowedWithTrap() const { return Kind & NotAllowedWithTrap; }
-  bool hasZeroBaseShadow(const ToolChain &TC) const {
-    return (Kind & HasZeroBaseShadow) || hasAsanZeroBaseShadow(TC);
+  bool hasZeroBaseShadow() const {
+    return (Kind & HasZeroBaseShadow) || AsanZeroBaseShadow;
   }
-  void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
+  void addArgs(const llvm::opt::ArgList &Args,
                llvm::opt::ArgStringList &CmdArgs) const;
 
  private:
   void clear();
 
-  bool hasAsanZeroBaseShadow(const ToolChain &TC) const;
-
   /// Parse a single value from a -fsanitize= or -fno-sanitize= value list.
   /// Returns OR of members of the \c SanitizeKind enumeration, or \c 0
   /// if \p Value is not known.
   static unsigned parse(const char *Value);
 
   /// Parse a -fsanitize= or -fno-sanitize= argument's values, diagnosing any
   /// invalid components.
   static unsigned parse(const Driver &D, const llvm::opt::Arg *A,
private:
   /// "-fsanitize=address,alignment" with mask \c NeedsUbsanRt would produce
   /// "-fsanitize=alignment".
   static std::string describeSanitizeArg(const llvm::opt::ArgList &Args,
                                          const llvm::opt::Arg *A,
                                          unsigned Mask);
 
   static bool getDefaultBlacklistForKind(const Driver &D, unsigned Kind,
                                          std::string &BLPath);
+
+  /// Return the smallest superset of sanitizer set \p Kinds such that each
+  /// member of each group whose flag is set in \p Kinds has its flag set in the
+  /// result.
+  static unsigned expandGroups(unsigned Kinds);
+
+  /// Return the subset of \p Kinds supported by toolchain \p TC.  If
+  /// \p DiagnoseErrors is true, produce an error diagnostic for each sanitizer
+  /// removed from \p Kinds.
+  static unsigned filterUnsupportedKinds(const ToolChain &TC, unsigned Kinds,
+                                         const llvm::opt::ArgList &Args,
+                                         const llvm::opt::Arg *A,
+                                         bool DiagnoseErrors);
+
+  /// The flags in \p Mask are unsupported by \p TC.  If present in \p Kinds,
+  /// remove them and produce an error diagnostic referring to \p A if
+  /// \p DiagnoseErrors is true.
+  static void filterUnsupportedMask(const ToolChain &TC, unsigned &Kinds,
+                                    unsigned Mask,
+                                    const llvm::opt::ArgList &Args,
+                                    const llvm::opt::Arg *A,
+                                    bool DiagnoseErrors);
 };
 
 }  // namespace driver
 }  // namespace clang
 
 #endif // CLANG_LIB_DRIVER_SANITIZERARGS_H_

include/clang/Driver/ToolChain.h

private:
   mutable OwningPtr<Tool> Clang;
   mutable OwningPtr<Tool> Assemble;
   mutable OwningPtr<Tool> Link;
   Tool *getClang() const;
   Tool *getAssemble() const;
   Tool *getLink() const;
   Tool *getClangAs() const;
 
+  mutable OwningPtr<SanitizerArgs> SanitizerArguments;
+
 protected:
   ToolChain(const Driver &D, const llvm::Triple &T,
             const llvm::opt::ArgList &Args);
 
   virtual Tool *buildAssembler() const;
   virtual Tool *buildLinker() const;
   virtual Tool *getTool(Action::ActionClass AC) const;
 

lib/Driver/Driver.cpp

 #include "InputInfo.h"
 #include "ToolChains.h"
 #include "clang/Basic/Version.h"
 #include "clang/Driver/Action.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Job.h"
 #include "clang/Driver/Options.h"
-#include "clang/Driver/SanitizerArgs.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/Arg.h"
if (Mode == CLMode) {
     IncludedFlagsBitmask |= options::CLOption;
     IncludedFlagsBitmask |= options::CoreOption;
   } else {
     ExcludedFlagsBitmask |= options::CLOption;
   }
 
   return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);
 }
-
-const SanitizerArgs &
-Driver::getOrParseSanitizerArgs(const ArgList &Args) const {
-  if (!SanitizerArguments.get())
-    SanitizerArguments.reset(new SanitizerArgs(*this, Args));
-  return *SanitizerArguments.get();
-}

lib/Driver/SanitizerArgs.cpp

 
 using namespace clang::driver;
 using namespace llvm::opt;
 
 void SanitizerArgs::clear() {
   Kind = 0;
   BlacklistFile = "";
   MsanTrackOrigins = false;
-  AsanZeroBaseShadow = AZBSK_Default;
+  AsanZeroBaseShadow = false;
   UbsanTrapOnError = false;
 }
 
 SanitizerArgs::SanitizerArgs() {
   clear();
 }
 
-SanitizerArgs::SanitizerArgs(const Driver &D, const llvm::opt::ArgList &Args) {
+SanitizerArgs::SanitizerArgs(const ToolChain &TC, const llvm::opt::ArgList &Args) {
   clear();
   unsigned AllKinds = 0;  // All kinds of sanitizers that were turned on
                           // at least once (possibly, disabled further).
+  const Driver &D = TC.getDriver();
   for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I) {
     unsigned Add, Remove;
     if (!parse(D, Args, *I, Add, Remove, true))
       continue;
     (*I)->claim();
+
+    // At this point we have not expanded groups, so any unsupported sanitizers
+    // in Add are those which have been explicitly enabled. Diagnose them.
+    Add = filterUnsupportedKinds(TC, Add, Args, *I, /*DiagnoseErrors=*/true);
+    Add = expandGroups(Add);
+    // Silently discard any unsupported sanitizers implicitly enabled through
+    // group expansion.
+    Add = filterUnsupportedKinds(TC, Add, Args, *I, /*DiagnoseErrors=*/false);
+
     Kind |= Add;
     Kind &= ~Remove;
     AllKinds |= Add;
   }
 
   UbsanTrapOnError =
     Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
     Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
SanitizerArgs::SanitizerArgs(const ToolChain &TC, const llvm::opt::ArgList &Args) {
   // FIXME: Currenly -fsanitize=leak is silently ignored in the presence of
   // -fsanitize=address. Perhaps it should print an error, or perhaps
   // -f(-no)sanitize=leak should change whether leak detection is enabled by
   // default in ASan?
 
   // If -fsanitize contains extra features of ASan, it should also
   // explicitly contain -fsanitize=address (probably, turned off later in the
   // command line).
   if ((Kind & AddressFull) != 0 && (AllKinds & Address) == 0)
     D.Diag(diag::warn_drv_unused_sanitizer)
      << lastArgumentForKind(D, Args, AddressFull)
      << "-fsanitize=address";
 
   // Parse -f(no-)sanitize-blacklist options.
   if (Arg *BLArg = Args.getLastArg(options::OPT_fsanitize_blacklist,
                                    options::OPT_fno_sanitize_blacklist)) {
     if (BLArg->getOption().matches(options::OPT_fsanitize_blacklist)) {
       std::string BLPath = BLArg->getValue();
       if (llvm::sys::fs::exists(BLPath)) {
         // Validate the blacklist format.
SanitizerArgs::SanitizerArgs(const ToolChain &TC, const llvm::opt::ArgList &Args) {
   if (NeedsMsan)
     MsanTrackOrigins =
       Args.hasFlag(options::OPT_fsanitize_memory_track_origins,
                    options::OPT_fno_sanitize_memory_track_origins,
                    /* Default */false);
 
   // Parse -f(no-)sanitize-address-zero-base-shadow options.
   if (NeedsAsan) {
-    if (Arg *A = Args.getLastArg(
-        options::OPT_fsanitize_address_zero_base_shadow,
-        options::OPT_fno_sanitize_address_zero_base_shadow))
-      AsanZeroBaseShadow = A->getOption().matches(
-                               options::OPT_fsanitize_address_zero_base_shadow)
-                               ? AZBSK_On
-                               : AZBSK_Off;
+    bool IsAndroid = (TC.getTriple().getEnvironment() == llvm::Triple::Android);
+    bool ZeroBaseShadowDefault = IsAndroid;
+    AsanZeroBaseShadow =
+        Args.hasFlag(options::OPT_fsanitize_address_zero_base_shadow,
+                     options::OPT_fno_sanitize_address_zero_base_shadow,
+                     ZeroBaseShadowDefault);
+    // Zero-base shadow is a requirement on Android.
+    if (IsAndroid && !AsanZeroBaseShadow) {
+      D.Diag(diag::err_drv_argument_not_allowed_with)
+          << "-fno-sanitize-address-zero-base-shadow"
+          << lastArgumentForKind(D, Args, Address);
+    }
   }
 }
 
-void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
+void SanitizerArgs::addArgs(const llvm::opt::ArgList &Args,
                             llvm::opt::ArgStringList &CmdArgs) const {
   if (!Kind)
     return;
-  const Driver &D = TC.getDriver();
   SmallString<256> SanitizeOpt("-fsanitize=");
 #define SANITIZER(NAME, ID) \
   if (Kind & ID) \
     SanitizeOpt += NAME ",";
 #include "clang/Basic/Sanitizers.def"
   SanitizeOpt.pop_back();
   CmdArgs.push_back(Args.MakeArgString(SanitizeOpt));
   if (!BlacklistFile.empty()) {
     SmallString<64> BlacklistOpt("-fsanitize-blacklist=");
     BlacklistOpt += BlacklistFile;
     CmdArgs.push_back(Args.MakeArgString(BlacklistOpt));
   }
 
   if (MsanTrackOrigins)
     CmdArgs.push_back(Args.MakeArgString("-fsanitize-memory-track-origins"));
 
-  if (needsAsanRt()) {
-    if (hasAsanZeroBaseShadow(TC)) {
-      CmdArgs.push_back(
-          Args.MakeArgString("-fsanitize-address-zero-base-shadow"));
-    } else if (TC.getTriple().getEnvironment() == llvm::Triple::Android) {
-      // Zero-base shadow is a requirement on Android.
-      D.Diag(diag::err_drv_argument_not_allowed_with)
-          << "-fno-sanitize-address-zero-base-shadow"
-          << lastArgumentForKind(D, Args, Address);
-    }
-  }
+  if (AsanZeroBaseShadow)
 
   // Workaround for PR16386.
   if (needsMsanRt())
     CmdArgs.push_back(Args.MakeArgString("-fno-assume-sane-operator-new"));
 }
 
-bool SanitizerArgs::hasAsanZeroBaseShadow(const ToolChain &TC) const {
-  if (!needsAsanRt())
-    return false;
-  if (AsanZeroBaseShadow != AZBSK_Default)
-    return AsanZeroBaseShadow == AZBSK_On;
-  // Zero-base shadow is used by default only on Android.
-  return TC.getTriple().getEnvironment() == llvm::Triple::Android;
-}
-
 unsigned SanitizerArgs::parse(const char *Value) {
   unsigned ParsedKind = llvm::StringSwitch<SanitizeKind>(Value)
 #define SANITIZER(NAME, ID) .Case(NAME, ID)
-#define SANITIZER_GROUP(NAME, ID, ALIAS) .Case(NAME, ID)
+#define SANITIZER_GROUP(NAME, ID, ALIAS) .Case(NAME, ID##Group)
 #include "clang/Basic/Sanitizers.def"
     .Default(SanitizeKind());
   // Assume -fsanitize=address implies -fsanitize=init-order,use-after-return.
   // FIXME: This should be either specified in Sanitizers.def, or go away when
   // we get rid of "-fsanitize=init-order,use-after-return" flags at all.
   if (ParsedKind & Address)
     ParsedKind |= InitOrder | UseAfterReturn;
   return ParsedKind;
 }
 
+unsigned SanitizerArgs::expandGroups(unsigned Kinds) {
+#define SANITIZER(NAME, ID)
+#define SANITIZER_GROUP(NAME, ID, ALIAS) if (Kinds & ID##Group) Kinds |= ID;
+#include "clang/Basic/Sanitizers.def"
+  return Kinds;
+}
+
+void SanitizerArgs::filterUnsupportedMask(const ToolChain &TC, unsigned &Kinds,
+                                          unsigned Mask,
+                                          const llvm::opt::ArgList &Args,
+                                          const llvm::opt::Arg *A,
+                                          bool DiagnoseErrors) {
+  if (!(Kinds & Mask))
+    return;
+  Kinds &= ~Mask;
+  if (DiagnoseErrors) {
+    std::string Desc = describeSanitizeArg(Args, A, Mask);
+    TC.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
+        << Desc << TC.getTriple().str();
+  }
+}
+
+unsigned SanitizerArgs::filterUnsupportedKinds(const ToolChain &TC,
+                                               unsigned Kinds,
+                                               const llvm::opt::ArgList &Args,
+                                               const llvm::opt::Arg *A,
+                                               bool DiagnoseErrors) {
+  bool IsLinux = TC.getTriple().getOS() == llvm::Triple::Linux;
+  bool IsX86 = TC.getTriple().getArch() == llvm::Triple::x86;
+  bool IsX86_64 = TC.getTriple().getArch() == llvm::Triple::x86_64;
+
+  if (!(IsLinux && IsX86_64)) {
+    filterUnsupportedMask(TC, Kinds, Thread | Memory | DataFlow, Args, A,
+                          DiagnoseErrors);
+  }
+
+  if (!(IsLinux && (IsX86 || IsX86_64))) {
+    filterUnsupportedMask(TC, Kinds, Function, Args, A, DiagnoseErrors);
+  }
+
+  return Kinds;
+}
+
 unsigned SanitizerArgs::parse(const Driver &D, const llvm::opt::Arg *A,
                               bool DiagnoseErrors) {
   unsigned Kind = 0;
   for (unsigned I = 0, N = A->getNumValues(); I != N; ++I) {
     if (unsigned K = parse(A->getValue(I)))
       Kind |= K;
     else if (DiagnoseErrors)
       D.Diag(diag::err_drv_unsupported_option_argument)

 std::string SanitizerArgs::lastArgumentForKind(const Driver &D,
                                                const llvm::opt::ArgList &Args,
                                                unsigned Kind) {
   for (llvm::opt::ArgList::const_reverse_iterator I = Args.rbegin(),
                                                   E = Args.rend();
        I != E; ++I) {
     unsigned Add, Remove;
     if (parse(D, Args, *I, Add, Remove, false) &&
-        (Add & Kind))
+        (expandGroups(Add) & Kind))
       return describeSanitizeArg(Args, *I, Kind);
     Kind &= ~Remove;
   }
   llvm_unreachable("arg list didn't provide expected value");
 }
 
 std::string SanitizerArgs::describeSanitizeArg(const llvm::opt::ArgList &Args,
                                                const llvm::opt::Arg *A,
                                                unsigned Mask) {
   if (!A->getOption().matches(options::OPT_fsanitize_EQ))
     return A->getAsString(Args);
 
   for (unsigned I = 0, N = A->getNumValues(); I != N; ++I)
-    if (parse(A->getValue(I)) & Mask)
+    if (expandGroups(parse(A->getValue(I))) & Mask)
       return std::string("-fsanitize=") + A->getValue(I);
 
   llvm_unreachable("arg didn't provide expected value");
 }
 
 bool SanitizerArgs::getDefaultBlacklistForKind(const Driver &D, unsigned Kind,
                                                std::string &BLPath) {
   const char *BlacklistFile = 0;

lib/Driver/ToolChain.cpp

 //===--- ToolChain.cpp - Collections of tools for one platform ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Tools.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Driver/Action.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
+#include "clang/Driver/SanitizerArgs.h"
 #include "clang/Driver/ToolChain.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 using namespace clang::driver;

 
 bool ToolChain::useIntegratedAs() const {
   return Args.hasFlag(options::OPT_integrated_as,
                       options::OPT_no_integrated_as,
                       IsIntegratedAssemblerDefault());
 }
 
 const SanitizerArgs& ToolChain::getSanitizerArgs() const {
-  return D.getOrParseSanitizerArgs(Args);
+  if (!SanitizerArguments.get())
+    SanitizerArguments.reset(new SanitizerArgs(*this, Args));
+  return *SanitizerArguments.get();
 }
 
 std::string ToolChain::getDefaultUniversalArchName() const {
   // In universal driver terms, the arch name accepted by -arch isn't exactly
   // the same as the ones that appear in the triple. Roughly speaking, this is
   // an inverse of the darwin::getArchTypeForDarwinArchName() function, but the
   // only interesting special case is powerpc.
   switch (Triple.getArch()) {

lib/Driver/ToolChains.cpp

if (Args.hasArg(options::OPT_fprofile_arcs) ||
     // Select the appropriate runtime library for the target.
     if (isTargetIPhoneOS()) {
       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_ios.a");
     } else {
       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_osx.a");
     }
   }
 
-  const SanitizerArgs &Sanitize = getDriver().getOrParseSanitizerArgs(Args);
+  const SanitizerArgs &Sanitize = getSanitizerArgs();
 
   // Add Ubsan runtime library, if required.
   if (Sanitize.needsUbsanRt()) {
+    // FIXME: Move this check to SanitizerArgs::filterUnsupportedKinds.
     if (isTargetIPhoneOS()) {
       getDriver().Diag(diag::err_drv_clang_unsupported_per_platform)
         << "-fsanitize=undefined";
     } else {
       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ubsan_osx.a", true);
 
       // The Ubsan runtime library requires C++.
       AddCXXStdlibLibArgs(Args, CmdArgs);
     }
   }
 
   // Add ASAN runtime library, if required. Dynamic libraries and bundles
   // should not be linked with the runtime library.
   if (Sanitize.needsAsanRt()) {
+    // FIXME: Move this check to SanitizerArgs::filterUnsupportedKinds.
     if (isTargetIPhoneOS() && !isTargetIOSSimulator()) {
       getDriver().Diag(diag::err_drv_clang_unsupported_per_platform)
         << "-fsanitize=address";
     } else {
       if (!Args.hasArg(options::OPT_dynamiclib) &&
           !Args.hasArg(options::OPT_bundle)) {
         // The ASAN runtime library requires C++.
         AddCXXStdlibLibArgs(Args, CmdArgs);
       }
for (unsigned i = 0; i < llvm::array_lengthof(IncludePathCandidates); ++i) {
     if (addLibStdCXXIncludePaths(
             IncludePathCandidates[i],
             TripleStr + MultiLibSuffix + BiarchSuffix, DriverArgs, CC1Args))
       break;
   }
 }
 
 bool Linux::isPIEDefault() const {
-  return getSanitizerArgs().hasZeroBaseShadow(*this);
+  return getSanitizerArgs().hasZeroBaseShadow();
 }
 
 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
 
 DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
   : Generic_ELF(D, Triple, Args) {
 
   // Path mangling to find libexec

lib/Driver/Tools.cpp

#endif
   Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
   // AltiVec language extensions aren't relevant for assembling.
   if (!isa<PreprocessJobAction>(JA) || 
       Output.getType() != types::TY_PP_Asm)
     Args.AddLastArg(CmdArgs, options::OPT_faltivec);
   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
   Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
 
-  const SanitizerArgs &Sanitize = D.getOrParseSanitizerArgs(Args);
-  Sanitize.addArgs(getToolChain(), Args, CmdArgs);
+  const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
+  Sanitize.addArgs(Args, CmdArgs);
 
   if (!Args.hasFlag(options::OPT_fsanitize_recover,
                     options::OPT_fno_sanitize_recover,
                     true))
     CmdArgs.push_back("-fno-sanitize-recover");
 
   if (Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
       Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                   const InputInfoList &Inputs,
                                   const ArgList &Args,
                                   const char *LinkingOutput) const {
   const toolchains::Linux& ToolChain =
     static_cast<const toolchains::Linux&>(getToolChain());
   const Driver &D = ToolChain.getDriver();
   const bool isAndroid =
     ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
-  const SanitizerArgs &Sanitize = D.getOrParseSanitizerArgs(Args);
+  const SanitizerArgs &Sanitize = ToolChain.getSanitizerArgs();
   const bool IsPIE =
     !Args.hasArg(options::OPT_shared) &&
-    (Args.hasArg(options::OPT_pie) || Sanitize.hasZeroBaseShadow(ToolChain));
+    (Args.hasArg(options::OPT_pie) || Sanitize.hasZeroBaseShadow());
 
   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
if (DLL) {
     CmdArgs.push_back(Args.MakeArgString("-dll"));
 
     SmallString<128> ImplibName(Output.getFilename());
     llvm::sys::path::replace_extension(ImplibName, "lib");
     CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
                                          ImplibName.str()));
   }
 
-  if (getToolChain().getDriver().getOrParseSanitizerArgs(Args).needsAsanRt()) {
+  if (getToolChain().getSanitizerArgs().needsAsanRt()) {
     CmdArgs.push_back(Args.MakeArgString("-debug"));
     CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
     SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir);
     llvm::sys::path::append(LibSanitizer, "lib", "windows");
     if (DLL) {
       llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib");
     } else {
       llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib");

test/Driver/fsanitize.c

 // RUN: %clang -target x86_64-linux-gnu -fcatch-undefined-behavior %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined-trap -fsanitize-undefined-trap-on-error %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP
 // RUN: %clang -target x86_64-linux-gnu -fsanitize-undefined-trap-on-error -fsanitize=undefined-trap %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-TRAP
 // CHECK-UNDEFINED-TRAP: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|shift|unreachable|return|vla-bound|alignment|null|object-size|float-cast-overflow|bounds|enum|bool),?){14}"}}
 // CHECK-UNDEFINED-TRAP: "-fsanitize-undefined-trap-on-error"
 
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED
 // CHECK-UNDEFINED: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|function|shift|unreachable|return|vla-bound|alignment|null|vptr|object-size|float-cast-overflow|bounds|enum|bool),?){16}"}}
 
+// RUN: %clang -target x86_64-apple-darwin10 -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UNDEFINED-DARWIN
+// CHECK-UNDEFINED-DARWIN: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|shift|unreachable|return|vla-bound|alignment|null|vptr|object-size|float-cast-overflow|bounds|enum|bool),?){15}"}}
+
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=integer %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-INTEGER
 // CHECK-INTEGER: "-fsanitize={{((signed-integer-overflow|unsigned-integer-overflow|integer-divide-by-zero|shift),?){4}"}}
 
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=thread,undefined -fno-thread-sanitizer -fno-sanitize=float-cast-overflow,vptr,bool,enum %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-PARTIAL-UNDEFINED
 // CHECK-PARTIAL-UNDEFINED: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|float-divide-by-zero|function|shift|unreachable|return|vla-bound|alignment|null|object-size|bounds),?){12}"}}
 
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=address-full %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN-FULL
 // CHECK-ASAN-FULL: "-fsanitize={{((address|init-order|use-after-return|use-after-scope),?){4}"}}

 // CHECK-SANA-SANL-NO-SANA: "-fsanitize=leak"
 
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=memory %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MSAN
 // CHECK-MSAN: "-fno-assume-sane-operator-new"
 
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=zzz %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DIAG1
 // CHECK-DIAG1: unsupported argument 'zzz' to option 'fsanitize='
 // CHECK-DIAG1-NOT: unsupported argument 'zzz' to option 'fsanitize='
+
+// RUN: %clang -target i686-linux-gnu -fsanitize=memory %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MSAN-X86
+// CHECK-MSAN-X86: error: unsupported option '-fsanitize=memory' for target 'i686--linux-gnu'
+
+// 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=function %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FSAN-DARWIN
+// CHECK-FSAN-DARWIN: unsupported option '-fsanitize=function' for target 'x86_64-apple-darwin10'

test/Driver/tsan.c

-// RUN: %clang     -target i386-unknown-unknown -fsanitize=thread %s -S -emit-llvm -o - | FileCheck %s
-// RUN: %clang -O1 -target i386-unknown-unknown -fsanitize=thread %s -S -emit-llvm -o - | FileCheck %s
-// RUN: %clang -O2 -target i386-unknown-unknown -fsanitize=thread %s -S -emit-llvm -o - | FileCheck %s
-// RUN: %clang -O3 -target i386-unknown-unknown -fsanitize=thread %s -S -emit-llvm -o - | FileCheck %s
-// RUN: %clang     -target i386-unknown-unknown -fsanitize=thread  %s -S -emit-llvm -o - | FileCheck %s
+// RUN: %clang     -target x86_64-unknown-linux -fsanitize=thread %s -S -emit-llvm -o - | FileCheck %s
+// RUN: %clang -O1 -target x86_64-unknown-linux -fsanitize=thread %s -S -emit-llvm -o - | FileCheck %s
+// RUN: %clang -O2 -target x86_64-unknown-linux -fsanitize=thread %s -S -emit-llvm -o - | FileCheck %s
+// RUN: %clang -O3 -target x86_64-unknown-linux -fsanitize=thread %s -S -emit-llvm -o - | FileCheck %s
+// RUN: %clang     -target x86_64-unknown-linux -fsanitize=thread  %s -S -emit-llvm -o - | FileCheck %s
 // Verify that -fsanitize=thread invokes tsan instrumentation.
 
 int foo(int *a) { return *a; }
 // CHECK: __tsan_init