1 files changed, 21 insertions, 105 deletions

diff --git a/include/clang/Driver/SanitizerArgs.h b/include/clang/Driver/SanitizerArgs.h
index c79c4714f4f9c..3524da0e7ffea 100644
--- a/include/clang/Driver/SanitizerArgs.h
+++ b/include/clang/Driver/SanitizerArgs.h
@@ -6,9 +6,10 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef CLANG_LIB_DRIVER_SANITIZERARGS_H_
-#define CLANG_LIB_DRIVER_SANITIZERARGS_H_
+#ifndef LLVM_CLANG_DRIVER_SANITIZERARGS_H
+#define LLVM_CLANG_DRIVER_SANITIZERARGS_H
 
+#include "clang/Basic/Sanitizers.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include <string>
@@ -20,131 +21,46 @@ 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, 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,
-    NeedsUnwindTables = Address | Thread | Memory | DataFlow
-  };
-  unsigned Kind;
+  SanitizerSet Sanitizers;
+  SanitizerSet RecoverableSanitizers;
 
   std::string BlacklistFile;
+  int SanitizeCoverage;
   int MsanTrackOrigins;
+  int AsanFieldPadding;
   bool AsanZeroBaseShadow;
   bool UbsanTrapOnError;
   bool AsanSharedRuntime;
+  bool LinkCXXRuntimes;
 
  public:
-  SanitizerArgs();
   /// Parses the sanitizer arguments from an argument list.
   SanitizerArgs(const ToolChain &TC, const llvm::opt::ArgList &Args);
 
-  bool needsAsanRt() const { return Kind & NeedsAsanRt; }
+  bool needsAsanRt() const { return Sanitizers.has(SanitizerKind::Address); }
   bool needsSharedAsanRt() const { return AsanSharedRuntime; }
-  bool needsTsanRt() const { return Kind & NeedsTsanRt; }
-  bool needsMsanRt() const { return Kind & NeedsMsanRt; }
-  bool needsLeakDetection() const { return Kind & NeedsLeakDetection; }
+  bool needsTsanRt() const { return Sanitizers.has(SanitizerKind::Thread); }
+  bool needsMsanRt() const { return Sanitizers.has(SanitizerKind::Memory); }
   bool needsLsanRt() const {
-    return needsLeakDetection() && !needsAsanRt();
-  }
-  bool needsUbsanRt() const {
-    return !UbsanTrapOnError && (Kind & NeedsUbsanRt);
+    return Sanitizers.has(SanitizerKind::Leak) &&
+           !Sanitizers.has(SanitizerKind::Address);
   }
-  bool needsDfsanRt() const { return Kind & NeedsDfsanRt; }
+  bool needsUbsanRt() const;
+  bool needsDfsanRt() const { return Sanitizers.has(SanitizerKind::DataFlow); }
 
-  bool sanitizesVptr() const { return Kind & Vptr; }
-  bool notAllowedWithTrap() const { return Kind & NotAllowedWithTrap; }
-  bool hasZeroBaseShadow() const {
-    return (Kind & HasZeroBaseShadow) || AsanZeroBaseShadow;
-  }
-  bool needsUnwindTables() const { return Kind & NeedsUnwindTables; }
+  bool sanitizesVptr() const { return Sanitizers.has(SanitizerKind::Vptr); }
+  bool requiresPIE() const;
+  bool needsUnwindTables() const;
+  bool linkCXXRuntimes() const { return LinkCXXRuntimes; }
   void addArgs(const llvm::opt::ArgList &Args,
                llvm::opt::ArgStringList &CmdArgs) const;
 
  private:
   void clear();
-
-  /// 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,
-                        bool DiagnoseErrors);
-
-  /// Parse a single flag of the form -f[no]sanitize=, or
-  /// -f*-sanitizer. Sets the masks defining required change of Kind value.
-  /// Returns true if the flag was parsed successfully.
-  static bool parse(const Driver &D, const llvm::opt::ArgList &Args,
-                    const llvm::opt::Arg *A, unsigned &Add, unsigned &Remove,
-                    bool DiagnoseErrors);
-
-  /// Produce an argument string from ArgList \p Args, which shows how it
-  /// provides a sanitizer kind in \p Mask. For example, the argument list
-  /// "-fsanitize=thread,vptr -fsanitize=address" with mask \c NeedsUbsanRt
-  /// would produce "-fsanitize=vptr".
-  static std::string lastArgumentForKind(const Driver &D,
-                                         const llvm::opt::ArgList &Args,
-                                         unsigned Kind);
-
-  /// Produce an argument string from argument \p A, which shows how it provides
-  /// a value in \p Mask. For instance, the argument
-  /// "-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,
-                                         unsigned &DiagnosedKinds);
-
-  /// 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,
-                                    unsigned &DiagnosedKinds);
+  bool getDefaultBlacklist(const Driver &D, std::string &BLPath);
 };
 
 }  // namespace driver
 }  // namespace clang
 
-#endif // CLANG_LIB_DRIVER_SANITIZERARGS_H_
+#endif