contrib/llvm/tools/clang/lib/Driver/SanitizerArgs.cpp

   1 //===--- SanitizerArgs.cpp - Arguments for sanitizer tools  ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 #include "clang/Driver/SanitizerArgs.h"
  10 #include "Tools.h"
  11 #include "clang/Basic/Sanitizers.h"
  12 #include "clang/Driver/Driver.h"
  13 #include "clang/Driver/DriverDiagnostic.h"
  14 #include "clang/Driver/Options.h"
  15 #include "clang/Driver/ToolChain.h"
  16 #include "llvm/ADT/StringExtras.h"
  17 #include "llvm/ADT/StringSwitch.h"
  18 #include "llvm/Support/FileSystem.h"
  19 #include "llvm/Support/Path.h"
  20 #include "llvm/Support/SpecialCaseList.h"
  21 #include <memory>
  22
  23 using namespace clang;
  24 using namespace clang::SanitizerKind;
  25 using namespace clang::driver;
  26 using namespace llvm::opt;
  27
  28 enum : SanitizerMask {
  29   NeedsUbsanRt = Undefined | Integer | CFI,
  30   NeedsUbsanCxxRt = Vptr | CFI,
  31   NotAllowedWithTrap = Vptr,
  32   RequiresPIE = Memory | DataFlow,
  33   NeedsUnwindTables = Address | Thread | Memory | DataFlow,
  34   SupportsCoverage = Address | Memory | Leak | Undefined | Integer | DataFlow,
  35   RecoverableByDefault = Undefined | Integer,
  36   Unrecoverable = Address | Unreachable | Return,
  37   LegacyFsanitizeRecoverMask = Undefined | Integer,
  38   NeedsLTO = CFI,
  39   TrappingSupported =
  40       (Undefined & ~Vptr) | UnsignedIntegerOverflow | LocalBounds | CFI,
  41   TrappingDefault = CFI,
  42 };
  43
  44 enum CoverageFeature {
  45   CoverageFunc = 1 << 0,
  46   CoverageBB = 1 << 1,
  47   CoverageEdge = 1 << 2,
  48   CoverageIndirCall = 1 << 3,
  49   CoverageTraceBB = 1 << 4,
  50   CoverageTraceCmp = 1 << 5,
  51   Coverage8bitCounters = 1 << 6,
  52 };
  53
  54 /// Parse a -fsanitize= or -fno-sanitize= argument's values, diagnosing any
  55 /// invalid components. Returns a SanitizerMask.
  56 static SanitizerMask parseArgValues(const Driver &D, const llvm::opt::Arg *A,
  57                                     bool DiagnoseErrors);
  58
  59 /// Parse -f(no-)?sanitize-coverage= flag values, diagnosing any invalid
  60 /// components. Returns OR of members of \c CoverageFeature enumeration.
  61 static int parseCoverageFeatures(const Driver &D, const llvm::opt::Arg *A);
  62
  63 /// Produce an argument string from ArgList \p Args, which shows how it
  64 /// provides some sanitizer kind from \p Mask. For example, the argument list
  65 /// "-fsanitize=thread,vptr -fsanitize=address" with mask \c NeedsUbsanRt
  66 /// would produce "-fsanitize=vptr".
  67 static std::string lastArgumentForMask(const Driver &D,
  68                                        const llvm::opt::ArgList &Args,
  69                                        SanitizerMask Mask);
  70
  71 /// Produce an argument string from argument \p A, which shows how it provides
  72 /// a value in \p Mask. For instance, the argument
  73 /// "-fsanitize=address,alignment" with mask \c NeedsUbsanRt would produce
  74 /// "-fsanitize=alignment".
  75 static std::string describeSanitizeArg(const llvm::opt::Arg *A,
  76                                        SanitizerMask Mask);
  77
  78 /// Produce a string containing comma-separated names of sanitizers in \p
  79 /// Sanitizers set.
  80 static std::string toString(const clang::SanitizerSet &Sanitizers);
  81
  82 static bool getDefaultBlacklist(const Driver &D, SanitizerMask Kinds,
  83                                 std::string &BLPath) {
  84   const char *BlacklistFile = nullptr;
  85   if (Kinds & Address)
  86     BlacklistFile = "asan_blacklist.txt";
  87   else if (Kinds & Memory)
  88     BlacklistFile = "msan_blacklist.txt";
  89   else if (Kinds & Thread)
  90     BlacklistFile = "tsan_blacklist.txt";
  91   else if (Kinds & DataFlow)
  92     BlacklistFile = "dfsan_abilist.txt";
  93
  94   if (BlacklistFile) {
  95     clang::SmallString<64> Path(D.ResourceDir);
  96     llvm::sys::path::append(Path, BlacklistFile);
  97     BLPath = Path.str();
  98     return true;
  99   }
 100   return false;
 101 }
 102
 103 /// Sets group bits for every group that has at least one representative already
 104 /// enabled in \p Kinds.
 105 static SanitizerMask setGroupBits(SanitizerMask Kinds) {
 106 #define SANITIZER(NAME, ID)
 107 #define SANITIZER_GROUP(NAME, ID, ALIAS)                                       \
 108   if (Kinds & SanitizerKind::ID)                                               \
 109     Kinds |= SanitizerKind::ID##Group;
 110 #include "clang/Basic/Sanitizers.def"
 111   return Kinds;
 112 }
 113
 114 static SanitizerMask parseSanitizeTrapArgs(const Driver &D,
 115                                            const llvm::opt::ArgList &Args) {
 116   SanitizerMask TrapRemove = 0; // During the loop below, the accumulated set of
 117                                 // sanitizers disabled by the current sanitizer
 118                                 // argument or any argument after it.
 119   SanitizerMask TrappingKinds = 0;
 120   SanitizerMask TrappingSupportedWithGroups = setGroupBits(TrappingSupported);
 121
 122   for (ArgList::const_reverse_iterator I = Args.rbegin(), E = Args.rend();
 123        I != E; ++I) {
 124     const auto *Arg = *I;
 125     if (Arg->getOption().matches(options::OPT_fsanitize_trap_EQ)) {
 126       Arg->claim();
 127       SanitizerMask Add = parseArgValues(D, Arg, true);
 128       Add &= ~TrapRemove;
 129       if (SanitizerMask InvalidValues = Add & ~TrappingSupportedWithGroups) {
 130         SanitizerSet S;
 131         S.Mask = InvalidValues;
 132         D.Diag(diag::err_drv_unsupported_option_argument) << "-fsanitize-trap"
 133                                                           << toString(S);
 134       }
 135       TrappingKinds |= expandSanitizerGroups(Add) & ~TrapRemove;
 136     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_trap_EQ)) {
 137       Arg->claim();
 138       TrapRemove |= expandSanitizerGroups(parseArgValues(D, Arg, true));
 139     } else if (Arg->getOption().matches(
 140                    options::OPT_fsanitize_undefined_trap_on_error)) {
 141       Arg->claim();
 142       TrappingKinds |=
 143           expandSanitizerGroups(UndefinedGroup & ~TrapRemove) & ~TrapRemove;
 144     } else if (Arg->getOption().matches(
 145                    options::OPT_fno_sanitize_undefined_trap_on_error)) {
 146       Arg->claim();
 147       TrapRemove |= expandSanitizerGroups(UndefinedGroup);
 148     }
 149   }
 150
 151   // Apply default trapping behavior.
 152   TrappingKinds |= TrappingDefault & ~TrapRemove;
 153
 154   return TrappingKinds;
 155 }
 156
 157 bool SanitizerArgs::needsUbsanRt() const {
 158   return (Sanitizers.Mask & NeedsUbsanRt & ~TrapSanitizers.Mask) &&
 159          !Sanitizers.has(Address) &&
 160          !Sanitizers.has(Memory) &&
 161          !Sanitizers.has(Thread);
 162 }
 163
 164 bool SanitizerArgs::requiresPIE() const {
 165   return AsanZeroBaseShadow || (Sanitizers.Mask & RequiresPIE);
 166 }
 167
 168 bool SanitizerArgs::needsUnwindTables() const {
 169   return Sanitizers.Mask & NeedsUnwindTables;
 170 }
 171
 172 void SanitizerArgs::clear() {
 173   Sanitizers.clear();
 174   RecoverableSanitizers.clear();
 175   TrapSanitizers.clear();
 176   BlacklistFiles.clear();
 177   CoverageFeatures = 0;
 178   MsanTrackOrigins = 0;
 179   AsanFieldPadding = 0;
 180   AsanZeroBaseShadow = false;
 181   AsanSharedRuntime = false;
 182   LinkCXXRuntimes = false;
 183 }
 184
 185 SanitizerArgs::SanitizerArgs(const ToolChain &TC,
 186                              const llvm::opt::ArgList &Args) {
 187   clear();
 188   SanitizerMask AllRemove = 0;  // During the loop below, the accumulated set of
 189                                 // sanitizers disabled by the current sanitizer
 190                                 // argument or any argument after it.
 191   SanitizerMask AllAddedKinds = 0;  // Mask of all sanitizers ever enabled by
 192                                     // -fsanitize= flags (directly or via group
 193                                     // expansion), some of which may be disabled
 194                                     // later. Used to carefully prune
 195                                     // unused-argument diagnostics.
 196   SanitizerMask DiagnosedKinds = 0;  // All Kinds we have diagnosed up to now.
 197                                      // Used to deduplicate diagnostics.
 198   SanitizerMask Kinds = 0;
 199   const SanitizerMask Supported = setGroupBits(TC.getSupportedSanitizers());
 200   ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
 201
 202   const Driver &D = TC.getDriver();
 203   SanitizerMask TrappingKinds = parseSanitizeTrapArgs(D, Args);
 204   SanitizerMask InvalidTrappingKinds = TrappingKinds & NotAllowedWithTrap;
 205
 206   for (ArgList::const_reverse_iterator I = Args.rbegin(), E = Args.rend();
 207        I != E; ++I) {
 208     const auto *Arg = *I;
 209     if (Arg->getOption().matches(options::OPT_fsanitize_EQ)) {
 210       Arg->claim();
 211       SanitizerMask Add = parseArgValues(D, Arg, true);
 212       AllAddedKinds |= expandSanitizerGroups(Add);
 213
 214       // Avoid diagnosing any sanitizer which is disabled later.
 215       Add &= ~AllRemove;
 216       // At this point we have not expanded groups, so any unsupported
 217       // sanitizers in Add are those which have been explicitly enabled.
 218       // Diagnose them.
 219       if (SanitizerMask KindsToDiagnose =
 220               Add & InvalidTrappingKinds & ~DiagnosedKinds) {
 221         std::string Desc = describeSanitizeArg(*I, KindsToDiagnose);
 222         D.Diag(diag::err_drv_argument_not_allowed_with)
 223             << Desc << "-fsanitize-trap=undefined";
 224         DiagnosedKinds |= KindsToDiagnose;
 225       }
 226       Add &= ~InvalidTrappingKinds;
 227       if (SanitizerMask KindsToDiagnose = Add & ~Supported & ~DiagnosedKinds) {
 228         std::string Desc = describeSanitizeArg(*I, KindsToDiagnose);
 229         D.Diag(diag::err_drv_unsupported_opt_for_target)
 230             << Desc << TC.getTriple().str();
 231         DiagnosedKinds |= KindsToDiagnose;
 232       }
 233       Add &= Supported;
 234
 235       // Test for -fno-rtti + explicit -fsanitizer=vptr before expanding groups
 236       // so we don't error out if -fno-rtti and -fsanitize=undefined were
 237       // passed.
 238       if (Add & Vptr &&
 239           (RTTIMode == ToolChain::RM_DisabledImplicitly ||
 240            RTTIMode == ToolChain::RM_DisabledExplicitly)) {
 241         if (RTTIMode == ToolChain::RM_DisabledImplicitly)
 242           // Warn about not having rtti enabled if the vptr sanitizer is
 243           // explicitly enabled
 244           D.Diag(diag::warn_drv_disabling_vptr_no_rtti_default);
 245         else {
 246           const llvm::opt::Arg *NoRTTIArg = TC.getRTTIArg();
 247           assert(NoRTTIArg &&
 248                  "RTTI disabled explicitly but we have no argument!");
 249           D.Diag(diag::err_drv_argument_not_allowed_with)
 250               << "-fsanitize=vptr" << NoRTTIArg->getAsString(Args);
 251         }
 252
 253         // Take out the Vptr sanitizer from the enabled sanitizers
 254         AllRemove |= Vptr;
 255       }
 256
 257       Add = expandSanitizerGroups(Add);
 258       // Group expansion may have enabled a sanitizer which is disabled later.
 259       Add &= ~AllRemove;
 260       // Silently discard any unsupported sanitizers implicitly enabled through
 261       // group expansion.
 262       Add &= ~InvalidTrappingKinds;
 263       Add &= Supported;
 264
 265       Kinds |= Add;
 266     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_EQ)) {
 267       Arg->claim();
 268       SanitizerMask Remove = parseArgValues(D, Arg, true);
 269       AllRemove |= expandSanitizerGroups(Remove);
 270     }
 271   }
 272
 273   // We disable the vptr sanitizer if it was enabled by group expansion but RTTI
 274   // is disabled.
 275   if ((Kinds & Vptr) &&
 276       (RTTIMode == ToolChain::RM_DisabledImplicitly ||
 277        RTTIMode == ToolChain::RM_DisabledExplicitly)) {
 278     Kinds &= ~Vptr;
 279   }
 280
 281   // Check that LTO is enabled if we need it.
 282   if ((Kinds & NeedsLTO) && !D.IsUsingLTO(Args)) {
 283     D.Diag(diag::err_drv_argument_only_allowed_with)
 284         << lastArgumentForMask(D, Args, Kinds & NeedsLTO) << "-flto";
 285   }
 286
 287   // Report error if there are non-trapping sanitizers that require
 288   // c++abi-specific  parts of UBSan runtime, and they are not provided by the
 289   // toolchain. We don't have a good way to check the latter, so we just
 290   // check if the toolchan supports vptr.
 291   if (~Supported & Vptr) {
 292     if (SanitizerMask KindsToDiagnose =
 293             Kinds & ~TrappingKinds & NeedsUbsanCxxRt) {
 294       SanitizerSet S;
 295       S.Mask = KindsToDiagnose;
 296       D.Diag(diag::err_drv_unsupported_opt_for_target)
 297           << ("-fno-sanitize-trap=" + toString(S)) << TC.getTriple().str();
 298       Kinds &= ~KindsToDiagnose;
 299     }
 300   }
 301
 302   // Warn about incompatible groups of sanitizers.
 303   std::pair<SanitizerMask, SanitizerMask> IncompatibleGroups[] = {
 304       std::make_pair(Address, Thread), std::make_pair(Address, Memory),
 305       std::make_pair(Thread, Memory), std::make_pair(Leak, Thread),
 306       std::make_pair(Leak, Memory), std::make_pair(KernelAddress, Address),
 307       std::make_pair(KernelAddress, Leak),
 308       std::make_pair(KernelAddress, Thread),
 309       std::make_pair(KernelAddress, Memory)};
 310   for (auto G : IncompatibleGroups) {
 311     SanitizerMask Group = G.first;
 312     if (Kinds & Group) {
 313       if (SanitizerMask Incompatible = Kinds & G.second) {
 314         D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 315             << lastArgumentForMask(D, Args, Group)
 316             << lastArgumentForMask(D, Args, Incompatible);
 317         Kinds &= ~Incompatible;
 318       }
 319     }
 320   }
 321   // FIXME: Currently -fsanitize=leak is silently ignored in the presence of
 322   // -fsanitize=address. Perhaps it should print an error, or perhaps
 323   // -f(-no)sanitize=leak should change whether leak detection is enabled by
 324   // default in ASan?
 325
 326   // Parse -f(no-)?sanitize-recover flags.
 327   SanitizerMask RecoverableKinds = RecoverableByDefault;
 328   SanitizerMask DiagnosedUnrecoverableKinds = 0;
 329   for (const auto *Arg : Args) {
 330     const char *DeprecatedReplacement = nullptr;
 331     if (Arg->getOption().matches(options::OPT_fsanitize_recover)) {
 332       DeprecatedReplacement = "-fsanitize-recover=undefined,integer";
 333       RecoverableKinds |= expandSanitizerGroups(LegacyFsanitizeRecoverMask);
 334       Arg->claim();
 335     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_recover)) {
 336       DeprecatedReplacement = "-fno-sanitize-recover=undefined,integer";
 337       RecoverableKinds &= ~expandSanitizerGroups(LegacyFsanitizeRecoverMask);
 338       Arg->claim();
 339     } else if (Arg->getOption().matches(options::OPT_fsanitize_recover_EQ)) {
 340       SanitizerMask Add = parseArgValues(D, Arg, true);
 341       // Report error if user explicitly tries to recover from unrecoverable
 342       // sanitizer.
 343       if (SanitizerMask KindsToDiagnose =
 344               Add & Unrecoverable & ~DiagnosedUnrecoverableKinds) {
 345         SanitizerSet SetToDiagnose;
 346         SetToDiagnose.Mask |= KindsToDiagnose;
 347         D.Diag(diag::err_drv_unsupported_option_argument)
 348             << Arg->getOption().getName() << toString(SetToDiagnose);
 349         DiagnosedUnrecoverableKinds |= KindsToDiagnose;
 350       }
 351       RecoverableKinds |= expandSanitizerGroups(Add);
 352       Arg->claim();
 353     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_recover_EQ)) {
 354       RecoverableKinds &= ~expandSanitizerGroups(parseArgValues(D, Arg, true));
 355       Arg->claim();
 356     }
 357     if (DeprecatedReplacement) {
 358       D.Diag(diag::warn_drv_deprecated_arg) << Arg->getAsString(Args)
 359                                             << DeprecatedReplacement;
 360     }
 361   }
 362   RecoverableKinds &= Kinds;
 363   RecoverableKinds &= ~Unrecoverable;
 364
 365   TrappingKinds &= Kinds;
 366
 367   // Setup blacklist files.
 368   // Add default blacklist from resource directory.
 369   {
 370     std::string BLPath;
 371     if (getDefaultBlacklist(D, Kinds, BLPath) && llvm::sys::fs::exists(BLPath))
 372       BlacklistFiles.push_back(BLPath);
 373   }
 374   // Parse -f(no-)sanitize-blacklist options.
 375   for (const auto *Arg : Args) {
 376     if (Arg->getOption().matches(options::OPT_fsanitize_blacklist)) {
 377       Arg->claim();
 378       std::string BLPath = Arg->getValue();
 379       if (llvm::sys::fs::exists(BLPath))
 380         BlacklistFiles.push_back(BLPath);
 381       else
 382         D.Diag(clang::diag::err_drv_no_such_file) << BLPath;
 383     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_blacklist)) {
 384       Arg->claim();
 385       BlacklistFiles.clear();
 386     }
 387   }
 388   // Validate blacklists format.
 389   {
 390     std::string BLError;
 391     std::unique_ptr<llvm::SpecialCaseList> SCL(
 392         llvm::SpecialCaseList::create(BlacklistFiles, BLError));
 393     if (!SCL.get())
 394       D.Diag(clang::diag::err_drv_malformed_sanitizer_blacklist) << BLError;
 395   }
 396
 397   // Parse -f[no-]sanitize-memory-track-origins[=level] options.
 398   if (AllAddedKinds & Memory) {
 399     if (Arg *A =
 400             Args.getLastArg(options::OPT_fsanitize_memory_track_origins_EQ,
 401                             options::OPT_fsanitize_memory_track_origins,
 402                             options::OPT_fno_sanitize_memory_track_origins)) {
 403       if (A->getOption().matches(options::OPT_fsanitize_memory_track_origins)) {
 404         MsanTrackOrigins = 2;
 405       } else if (A->getOption().matches(
 406                      options::OPT_fno_sanitize_memory_track_origins)) {
 407         MsanTrackOrigins = 0;
 408       } else {
 409         StringRef S = A->getValue();
 410         if (S.getAsInteger(0, MsanTrackOrigins) || MsanTrackOrigins < 0 ||
 411             MsanTrackOrigins > 2) {
 412           D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
 413         }
 414       }
 415     }
 416   }
 417
 418   // Parse -f(no-)?sanitize-coverage flags if coverage is supported by the
 419   // enabled sanitizers.
 420   if (AllAddedKinds & SupportsCoverage) {
 421     for (const auto *Arg : Args) {
 422       if (Arg->getOption().matches(options::OPT_fsanitize_coverage)) {
 423         Arg->claim();
 424         int LegacySanitizeCoverage;
 425         if (Arg->getNumValues() == 1 &&
 426             !StringRef(Arg->getValue(0))
 427                  .getAsInteger(0, LegacySanitizeCoverage) &&
 428             LegacySanitizeCoverage >= 0 && LegacySanitizeCoverage <= 4) {
 429           // TODO: Add deprecation notice for this form.
 430           switch (LegacySanitizeCoverage) {
 431           case 0:
 432             CoverageFeatures = 0;
 433             break;
 434           case 1:
 435             CoverageFeatures = CoverageFunc;
 436             break;
 437           case 2:
 438             CoverageFeatures = CoverageBB;
 439             break;
 440           case 3:
 441             CoverageFeatures = CoverageEdge;
 442             break;
 443           case 4:
 444             CoverageFeatures = CoverageEdge | CoverageIndirCall;
 445             break;
 446           }
 447           continue;
 448         }
 449         CoverageFeatures |= parseCoverageFeatures(D, Arg);
 450       } else if (Arg->getOption().matches(options::OPT_fno_sanitize_coverage)) {
 451         Arg->claim();
 452         CoverageFeatures &= ~parseCoverageFeatures(D, Arg);
 453       }
 454     }
 455   }
 456   // Choose at most one coverage type: function, bb, or edge.
 457   if ((CoverageFeatures & CoverageFunc) && (CoverageFeatures & CoverageBB))
 458     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 459         << "-fsanitize-coverage=func"
 460         << "-fsanitize-coverage=bb";
 461   if ((CoverageFeatures & CoverageFunc) && (CoverageFeatures & CoverageEdge))
 462     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 463         << "-fsanitize-coverage=func"
 464         << "-fsanitize-coverage=edge";
 465   if ((CoverageFeatures & CoverageBB) && (CoverageFeatures & CoverageEdge))
 466     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 467         << "-fsanitize-coverage=bb"
 468         << "-fsanitize-coverage=edge";
 469   // Basic block tracing and 8-bit counters require some type of coverage
 470   // enabled.
 471   int CoverageTypes = CoverageFunc | CoverageBB | CoverageEdge;
 472   if ((CoverageFeatures & CoverageTraceBB) &&
 473       !(CoverageFeatures & CoverageTypes))
 474     D.Diag(clang::diag::err_drv_argument_only_allowed_with)
 475         << "-fsanitize-coverage=trace-bb"
 476         << "-fsanitize-coverage=(func|bb|edge)";
 477   if ((CoverageFeatures & Coverage8bitCounters) &&
 478       !(CoverageFeatures & CoverageTypes))
 479     D.Diag(clang::diag::err_drv_argument_only_allowed_with)
 480         << "-fsanitize-coverage=8bit-counters"
 481         << "-fsanitize-coverage=(func|bb|edge)";
 482
 483   if (AllAddedKinds & Address) {
 484     AsanSharedRuntime =
 485         Args.hasArg(options::OPT_shared_libasan) ||
 486         (TC.getTriple().getEnvironment() == llvm::Triple::Android);
 487     AsanZeroBaseShadow =
 488         (TC.getTriple().getEnvironment() == llvm::Triple::Android);
 489     if (Arg *A =
 490             Args.getLastArg(options::OPT_fsanitize_address_field_padding)) {
 491         StringRef S = A->getValue();
 492         // Legal values are 0 and 1, 2, but in future we may add more levels.
 493         if (S.getAsInteger(0, AsanFieldPadding) || AsanFieldPadding < 0 ||
 494             AsanFieldPadding > 2) {
 495           D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
 496         }
 497     }
 498
 499     if (Arg *WindowsDebugRTArg =
 500             Args.getLastArg(options::OPT__SLASH_MTd, options::OPT__SLASH_MT,
 501                             options::OPT__SLASH_MDd, options::OPT__SLASH_MD,
 502                             options::OPT__SLASH_LDd, options::OPT__SLASH_LD)) {
 503       switch (WindowsDebugRTArg->getOption().getID()) {
 504       case options::OPT__SLASH_MTd:
 505       case options::OPT__SLASH_MDd:
 506       case options::OPT__SLASH_LDd:
 507         D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 508             << WindowsDebugRTArg->getAsString(Args)
 509             << lastArgumentForMask(D, Args, Address);
 510         D.Diag(clang::diag::note_drv_address_sanitizer_debug_runtime);
 511       }
 512     }
 513   }
 514
 515   // Parse -link-cxx-sanitizer flag.
 516   LinkCXXRuntimes =
 517       Args.hasArg(options::OPT_fsanitize_link_cxx_runtime) || D.CCCIsCXX();
 518
 519   // Finally, initialize the set of available and recoverable sanitizers.
 520   Sanitizers.Mask |= Kinds;
 521   RecoverableSanitizers.Mask |= RecoverableKinds;
 522   TrapSanitizers.Mask |= TrappingKinds;
 523 }
 524
 525 static std::string toString(const clang::SanitizerSet &Sanitizers) {
 526   std::string Res;
 527 #define SANITIZER(NAME, ID)                                                    \
 528   if (Sanitizers.has(ID)) {                                                    \
 529     if (!Res.empty())                                                          \
 530       Res += ",";                                                              \
 531     Res += NAME;                                                               \
 532   }
 533 #include "clang/Basic/Sanitizers.def"
 534   return Res;
 535 }
 536
 537 void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
 538                             llvm::opt::ArgStringList &CmdArgs,
 539                             types::ID InputType) const {
 540   if (Sanitizers.empty())
 541     return;
 542   CmdArgs.push_back(Args.MakeArgString("-fsanitize=" + toString(Sanitizers)));
 543
 544   if (!RecoverableSanitizers.empty())
 545     CmdArgs.push_back(Args.MakeArgString("-fsanitize-recover=" +
 546                                          toString(RecoverableSanitizers)));
 547
 548   if (!TrapSanitizers.empty())
 549     CmdArgs.push_back(
 550         Args.MakeArgString("-fsanitize-trap=" + toString(TrapSanitizers)));
 551
 552   for (const auto &BLPath : BlacklistFiles) {
 553     SmallString<64> BlacklistOpt("-fsanitize-blacklist=");
 554     BlacklistOpt += BLPath;
 555     CmdArgs.push_back(Args.MakeArgString(BlacklistOpt));
 556   }
 557
 558   if (MsanTrackOrigins)
 559     CmdArgs.push_back(Args.MakeArgString("-fsanitize-memory-track-origins=" +
 560                                          llvm::utostr(MsanTrackOrigins)));
 561   if (AsanFieldPadding)
 562     CmdArgs.push_back(Args.MakeArgString("-fsanitize-address-field-padding=" +
 563                                          llvm::utostr(AsanFieldPadding)));
 564   // Translate available CoverageFeatures to corresponding clang-cc1 flags.
 565   std::pair<int, const char *> CoverageFlags[] = {
 566     std::make_pair(CoverageFunc, "-fsanitize-coverage-type=1"),
 567     std::make_pair(CoverageBB, "-fsanitize-coverage-type=2"),
 568     std::make_pair(CoverageEdge, "-fsanitize-coverage-type=3"),
 569     std::make_pair(CoverageIndirCall, "-fsanitize-coverage-indirect-calls"),
 570     std::make_pair(CoverageTraceBB, "-fsanitize-coverage-trace-bb"),
 571     std::make_pair(CoverageTraceCmp, "-fsanitize-coverage-trace-cmp"),
 572     std::make_pair(Coverage8bitCounters, "-fsanitize-coverage-8bit-counters")};
 573   for (auto F : CoverageFlags) {
 574     if (CoverageFeatures & F.first)
 575       CmdArgs.push_back(Args.MakeArgString(F.second));
 576   }
 577
 578
 579   // MSan: Workaround for PR16386.
 580   // ASan: This is mainly to help LSan with cases such as
 581   // https://code.google.com/p/address-sanitizer/issues/detail?id=373
 582   // We can't make this conditional on -fsanitize=leak, as that flag shouldn't
 583   // affect compilation.
 584   if (Sanitizers.has(Memory) || Sanitizers.has(Address))
 585     CmdArgs.push_back(Args.MakeArgString("-fno-assume-sane-operator-new"));
 586
 587   if (TC.getTriple().isOSWindows() && needsUbsanRt()) {
 588     // Instruct the code generator to embed linker directives in the object file
 589     // that cause the required runtime libraries to be linked.
 590     CmdArgs.push_back(Args.MakeArgString(
 591         "--dependent-lib=" + tools::getCompilerRT(TC, "ubsan_standalone")));
 592     if (types::isCXX(InputType))
 593       CmdArgs.push_back(
 594           Args.MakeArgString("--dependent-lib=" +
 595                              tools::getCompilerRT(TC, "ubsan_standalone_cxx")));
 596   }
 597 }
 598
 599 SanitizerMask parseArgValues(const Driver &D, const llvm::opt::Arg *A,
 600                              bool DiagnoseErrors) {
 601   assert((A->getOption().matches(options::OPT_fsanitize_EQ) ||
 602           A->getOption().matches(options::OPT_fno_sanitize_EQ) ||
 603           A->getOption().matches(options::OPT_fsanitize_recover_EQ) ||
 604           A->getOption().matches(options::OPT_fno_sanitize_recover_EQ) ||
 605           A->getOption().matches(options::OPT_fsanitize_trap_EQ) ||
 606           A->getOption().matches(options::OPT_fno_sanitize_trap_EQ)) &&
 607          "Invalid argument in parseArgValues!");
 608   SanitizerMask Kinds = 0;
 609   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
 610     const char *Value = A->getValue(i);
 611     SanitizerMask Kind;
 612     // Special case: don't accept -fsanitize=all.
 613     if (A->getOption().matches(options::OPT_fsanitize_EQ) &&
 614         0 == strcmp("all", Value))
 615       Kind = 0;
 616     else
 617       Kind = parseSanitizerValue(Value, /*AllowGroups=*/true);
 618
 619     if (Kind)
 620       Kinds |= Kind;
 621     else if (DiagnoseErrors)
 622       D.Diag(clang::diag::err_drv_unsupported_option_argument)
 623           << A->getOption().getName() << Value;
 624   }
 625   return Kinds;
 626 }
 627
 628 int parseCoverageFeatures(const Driver &D, const llvm::opt::Arg *A) {
 629   assert(A->getOption().matches(options::OPT_fsanitize_coverage) ||
 630          A->getOption().matches(options::OPT_fno_sanitize_coverage));
 631   int Features = 0;
 632   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
 633     const char *Value = A->getValue(i);
 634     int F = llvm::StringSwitch<int>(Value)
 635         .Case("func", CoverageFunc)
 636         .Case("bb", CoverageBB)
 637         .Case("edge", CoverageEdge)
 638         .Case("indirect-calls", CoverageIndirCall)
 639         .Case("trace-bb", CoverageTraceBB)
 640         .Case("trace-cmp", CoverageTraceCmp)
 641         .Case("8bit-counters", Coverage8bitCounters)
 642         .Default(0);
 643     if (F == 0)
 644       D.Diag(clang::diag::err_drv_unsupported_option_argument)
 645           << A->getOption().getName() << Value;
 646     Features |= F;
 647   }
 648   return Features;
 649 }
 650
 651 std::string lastArgumentForMask(const Driver &D, const llvm::opt::ArgList &Args,
 652                                 SanitizerMask Mask) {
 653   for (llvm::opt::ArgList::const_reverse_iterator I = Args.rbegin(),
 654                                                   E = Args.rend();
 655        I != E; ++I) {
 656     const auto *Arg = *I;
 657     if (Arg->getOption().matches(options::OPT_fsanitize_EQ)) {
 658       SanitizerMask AddKinds =
 659           expandSanitizerGroups(parseArgValues(D, Arg, false));
 660       if (AddKinds & Mask)
 661         return describeSanitizeArg(Arg, Mask);
 662     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_EQ)) {
 663       SanitizerMask RemoveKinds =
 664           expandSanitizerGroups(parseArgValues(D, Arg, false));
 665       Mask &= ~RemoveKinds;
 666     }
 667   }
 668   llvm_unreachable("arg list didn't provide expected value");
 669 }
 670
 671 std::string describeSanitizeArg(const llvm::opt::Arg *A, SanitizerMask Mask) {
 672   assert(A->getOption().matches(options::OPT_fsanitize_EQ)
 673          && "Invalid argument in describeSanitizerArg!");
 674
 675   std::string Sanitizers;
 676   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
 677     if (expandSanitizerGroups(
 678             parseSanitizerValue(A->getValue(i), /*AllowGroups=*/true)) &
 679         Mask) {
 680       if (!Sanitizers.empty())
 681         Sanitizers += ",";
 682       Sanitizers += A->getValue(i);
 683     }
 684   }
 685
 686   assert(!Sanitizers.empty() && "arg didn't provide expected value");
 687   return "-fsanitize=" + Sanitizers;
 688 }