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   MsanUseAfterDtor = false;
 180   AsanFieldPadding = 0;
 181   AsanZeroBaseShadow = false;
 182   AsanSharedRuntime = false;
 183   LinkCXXRuntimes = false;
 184 }
 185
 186 SanitizerArgs::SanitizerArgs(const ToolChain &TC,
 187                              const llvm::opt::ArgList &Args) {
 188   clear();
 189   SanitizerMask AllRemove = 0;  // During the loop below, the accumulated set of
 190                                 // sanitizers disabled by the current sanitizer
 191                                 // argument or any argument after it.
 192   SanitizerMask AllAddedKinds = 0;  // Mask of all sanitizers ever enabled by
 193                                     // -fsanitize= flags (directly or via group
 194                                     // expansion), some of which may be disabled
 195                                     // later. Used to carefully prune
 196                                     // unused-argument diagnostics.
 197   SanitizerMask DiagnosedKinds = 0;  // All Kinds we have diagnosed up to now.
 198                                      // Used to deduplicate diagnostics.
 199   SanitizerMask Kinds = 0;
 200   const SanitizerMask Supported = setGroupBits(TC.getSupportedSanitizers());
 201   ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
 202
 203   const Driver &D = TC.getDriver();
 204   SanitizerMask TrappingKinds = parseSanitizeTrapArgs(D, Args);
 205   SanitizerMask InvalidTrappingKinds = TrappingKinds & NotAllowedWithTrap;
 206
 207   for (ArgList::const_reverse_iterator I = Args.rbegin(), E = Args.rend();
 208        I != E; ++I) {
 209     const auto *Arg = *I;
 210     if (Arg->getOption().matches(options::OPT_fsanitize_EQ)) {
 211       Arg->claim();
 212       SanitizerMask Add = parseArgValues(D, Arg, true);
 213       AllAddedKinds |= expandSanitizerGroups(Add);
 214
 215       // Avoid diagnosing any sanitizer which is disabled later.
 216       Add &= ~AllRemove;
 217       // At this point we have not expanded groups, so any unsupported
 218       // sanitizers in Add are those which have been explicitly enabled.
 219       // Diagnose them.
 220       if (SanitizerMask KindsToDiagnose =
 221               Add & InvalidTrappingKinds & ~DiagnosedKinds) {
 222         std::string Desc = describeSanitizeArg(*I, KindsToDiagnose);
 223         D.Diag(diag::err_drv_argument_not_allowed_with)
 224             << Desc << "-fsanitize-trap=undefined";
 225         DiagnosedKinds |= KindsToDiagnose;
 226       }
 227       Add &= ~InvalidTrappingKinds;
 228       if (SanitizerMask KindsToDiagnose = Add & ~Supported & ~DiagnosedKinds) {
 229         std::string Desc = describeSanitizeArg(*I, KindsToDiagnose);
 230         D.Diag(diag::err_drv_unsupported_opt_for_target)
 231             << Desc << TC.getTriple().str();
 232         DiagnosedKinds |= KindsToDiagnose;
 233       }
 234       Add &= Supported;
 235
 236       // Test for -fno-rtti + explicit -fsanitizer=vptr before expanding groups
 237       // so we don't error out if -fno-rtti and -fsanitize=undefined were
 238       // passed.
 239       if (Add & Vptr &&
 240           (RTTIMode == ToolChain::RM_DisabledImplicitly ||
 241            RTTIMode == ToolChain::RM_DisabledExplicitly)) {
 242         if (RTTIMode == ToolChain::RM_DisabledImplicitly)
 243           // Warn about not having rtti enabled if the vptr sanitizer is
 244           // explicitly enabled
 245           D.Diag(diag::warn_drv_disabling_vptr_no_rtti_default);
 246         else {
 247           const llvm::opt::Arg *NoRTTIArg = TC.getRTTIArg();
 248           assert(NoRTTIArg &&
 249                  "RTTI disabled explicitly but we have no argument!");
 250           D.Diag(diag::err_drv_argument_not_allowed_with)
 251               << "-fsanitize=vptr" << NoRTTIArg->getAsString(Args);
 252         }
 253
 254         // Take out the Vptr sanitizer from the enabled sanitizers
 255         AllRemove |= Vptr;
 256       }
 257
 258       Add = expandSanitizerGroups(Add);
 259       // Group expansion may have enabled a sanitizer which is disabled later.
 260       Add &= ~AllRemove;
 261       // Silently discard any unsupported sanitizers implicitly enabled through
 262       // group expansion.
 263       Add &= ~InvalidTrappingKinds;
 264       Add &= Supported;
 265
 266       Kinds |= Add;
 267     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_EQ)) {
 268       Arg->claim();
 269       SanitizerMask Remove = parseArgValues(D, Arg, true);
 270       AllRemove |= expandSanitizerGroups(Remove);
 271     }
 272   }
 273
 274   // We disable the vptr sanitizer if it was enabled by group expansion but RTTI
 275   // is disabled.
 276   if ((Kinds & Vptr) &&
 277       (RTTIMode == ToolChain::RM_DisabledImplicitly ||
 278        RTTIMode == ToolChain::RM_DisabledExplicitly)) {
 279     Kinds &= ~Vptr;
 280   }
 281
 282   // Check that LTO is enabled if we need it.
 283   if ((Kinds & NeedsLTO) && !D.IsUsingLTO(Args)) {
 284     D.Diag(diag::err_drv_argument_only_allowed_with)
 285         << lastArgumentForMask(D, Args, Kinds & NeedsLTO) << "-flto";
 286   }
 287
 288   // Report error if there are non-trapping sanitizers that require
 289   // c++abi-specific  parts of UBSan runtime, and they are not provided by the
 290   // toolchain. We don't have a good way to check the latter, so we just
 291   // check if the toolchan supports vptr.
 292   if (~Supported & Vptr) {
 293     SanitizerMask KindsToDiagnose = Kinds & ~TrappingKinds & NeedsUbsanCxxRt;
 294     // The runtime library supports the Microsoft C++ ABI, but only well enough
 295     // for CFI. FIXME: Remove this once we support vptr on Windows.
 296     if (TC.getTriple().isOSWindows())
 297       KindsToDiagnose &= ~CFI;
 298     if (KindsToDiagnose) {
 299       SanitizerSet S;
 300       S.Mask = KindsToDiagnose;
 301       D.Diag(diag::err_drv_unsupported_opt_for_target)
 302           << ("-fno-sanitize-trap=" + toString(S)) << TC.getTriple().str();
 303       Kinds &= ~KindsToDiagnose;
 304     }
 305   }
 306
 307   // Warn about incompatible groups of sanitizers.
 308   std::pair<SanitizerMask, SanitizerMask> IncompatibleGroups[] = {
 309       std::make_pair(Address, Thread), std::make_pair(Address, Memory),
 310       std::make_pair(Thread, Memory), std::make_pair(Leak, Thread),
 311       std::make_pair(Leak, Memory), std::make_pair(KernelAddress, Address),
 312       std::make_pair(KernelAddress, Leak),
 313       std::make_pair(KernelAddress, Thread),
 314       std::make_pair(KernelAddress, Memory)};
 315   for (auto G : IncompatibleGroups) {
 316     SanitizerMask Group = G.first;
 317     if (Kinds & Group) {
 318       if (SanitizerMask Incompatible = Kinds & G.second) {
 319         D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 320             << lastArgumentForMask(D, Args, Group)
 321             << lastArgumentForMask(D, Args, Incompatible);
 322         Kinds &= ~Incompatible;
 323       }
 324     }
 325   }
 326   // FIXME: Currently -fsanitize=leak is silently ignored in the presence of
 327   // -fsanitize=address. Perhaps it should print an error, or perhaps
 328   // -f(-no)sanitize=leak should change whether leak detection is enabled by
 329   // default in ASan?
 330
 331   // Parse -f(no-)?sanitize-recover flags.
 332   SanitizerMask RecoverableKinds = RecoverableByDefault;
 333   SanitizerMask DiagnosedUnrecoverableKinds = 0;
 334   for (const auto *Arg : Args) {
 335     const char *DeprecatedReplacement = nullptr;
 336     if (Arg->getOption().matches(options::OPT_fsanitize_recover)) {
 337       DeprecatedReplacement = "-fsanitize-recover=undefined,integer";
 338       RecoverableKinds |= expandSanitizerGroups(LegacyFsanitizeRecoverMask);
 339       Arg->claim();
 340     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_recover)) {
 341       DeprecatedReplacement = "-fno-sanitize-recover=undefined,integer";
 342       RecoverableKinds &= ~expandSanitizerGroups(LegacyFsanitizeRecoverMask);
 343       Arg->claim();
 344     } else if (Arg->getOption().matches(options::OPT_fsanitize_recover_EQ)) {
 345       SanitizerMask Add = parseArgValues(D, Arg, true);
 346       // Report error if user explicitly tries to recover from unrecoverable
 347       // sanitizer.
 348       if (SanitizerMask KindsToDiagnose =
 349               Add & Unrecoverable & ~DiagnosedUnrecoverableKinds) {
 350         SanitizerSet SetToDiagnose;
 351         SetToDiagnose.Mask |= KindsToDiagnose;
 352         D.Diag(diag::err_drv_unsupported_option_argument)
 353             << Arg->getOption().getName() << toString(SetToDiagnose);
 354         DiagnosedUnrecoverableKinds |= KindsToDiagnose;
 355       }
 356       RecoverableKinds |= expandSanitizerGroups(Add);
 357       Arg->claim();
 358     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_recover_EQ)) {
 359       RecoverableKinds &= ~expandSanitizerGroups(parseArgValues(D, Arg, true));
 360       Arg->claim();
 361     }
 362     if (DeprecatedReplacement) {
 363       D.Diag(diag::warn_drv_deprecated_arg) << Arg->getAsString(Args)
 364                                             << DeprecatedReplacement;
 365     }
 366   }
 367   RecoverableKinds &= Kinds;
 368   RecoverableKinds &= ~Unrecoverable;
 369
 370   TrappingKinds &= Kinds;
 371
 372   // Setup blacklist files.
 373   // Add default blacklist from resource directory.
 374   {
 375     std::string BLPath;
 376     if (getDefaultBlacklist(D, Kinds, BLPath) && llvm::sys::fs::exists(BLPath))
 377       BlacklistFiles.push_back(BLPath);
 378   }
 379   // Parse -f(no-)sanitize-blacklist options.
 380   for (const auto *Arg : Args) {
 381     if (Arg->getOption().matches(options::OPT_fsanitize_blacklist)) {
 382       Arg->claim();
 383       std::string BLPath = Arg->getValue();
 384       if (llvm::sys::fs::exists(BLPath))
 385         BlacklistFiles.push_back(BLPath);
 386       else
 387         D.Diag(clang::diag::err_drv_no_such_file) << BLPath;
 388     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_blacklist)) {
 389       Arg->claim();
 390       BlacklistFiles.clear();
 391     }
 392   }
 393   // Validate blacklists format.
 394   {
 395     std::string BLError;
 396     std::unique_ptr<llvm::SpecialCaseList> SCL(
 397         llvm::SpecialCaseList::create(BlacklistFiles, BLError));
 398     if (!SCL.get())
 399       D.Diag(clang::diag::err_drv_malformed_sanitizer_blacklist) << BLError;
 400   }
 401
 402   // Parse -f[no-]sanitize-memory-track-origins[=level] options.
 403   if (AllAddedKinds & Memory) {
 404     if (Arg *A =
 405             Args.getLastArg(options::OPT_fsanitize_memory_track_origins_EQ,
 406                             options::OPT_fsanitize_memory_track_origins,
 407                             options::OPT_fno_sanitize_memory_track_origins)) {
 408       if (A->getOption().matches(options::OPT_fsanitize_memory_track_origins)) {
 409         MsanTrackOrigins = 2;
 410       } else if (A->getOption().matches(
 411                      options::OPT_fno_sanitize_memory_track_origins)) {
 412         MsanTrackOrigins = 0;
 413       } else {
 414         StringRef S = A->getValue();
 415         if (S.getAsInteger(0, MsanTrackOrigins) || MsanTrackOrigins < 0 ||
 416             MsanTrackOrigins > 2) {
 417           D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
 418         }
 419       }
 420     }
 421     MsanUseAfterDtor =
 422       Args.hasArg(options::OPT_fsanitize_memory_use_after_dtor);
 423   }
 424
 425   // Parse -f(no-)?sanitize-coverage flags if coverage is supported by the
 426   // enabled sanitizers.
 427   if (AllAddedKinds & SupportsCoverage) {
 428     for (const auto *Arg : Args) {
 429       if (Arg->getOption().matches(options::OPT_fsanitize_coverage)) {
 430         Arg->claim();
 431         int LegacySanitizeCoverage;
 432         if (Arg->getNumValues() == 1 &&
 433             !StringRef(Arg->getValue(0))
 434                  .getAsInteger(0, LegacySanitizeCoverage) &&
 435             LegacySanitizeCoverage >= 0 && LegacySanitizeCoverage <= 4) {
 436           // TODO: Add deprecation notice for this form.
 437           switch (LegacySanitizeCoverage) {
 438           case 0:
 439             CoverageFeatures = 0;
 440             break;
 441           case 1:
 442             CoverageFeatures = CoverageFunc;
 443             break;
 444           case 2:
 445             CoverageFeatures = CoverageBB;
 446             break;
 447           case 3:
 448             CoverageFeatures = CoverageEdge;
 449             break;
 450           case 4:
 451             CoverageFeatures = CoverageEdge | CoverageIndirCall;
 452             break;
 453           }
 454           continue;
 455         }
 456         CoverageFeatures |= parseCoverageFeatures(D, Arg);
 457       } else if (Arg->getOption().matches(options::OPT_fno_sanitize_coverage)) {
 458         Arg->claim();
 459         CoverageFeatures &= ~parseCoverageFeatures(D, Arg);
 460       }
 461     }
 462   }
 463   // Choose at most one coverage type: function, bb, or edge.
 464   if ((CoverageFeatures & CoverageFunc) && (CoverageFeatures & CoverageBB))
 465     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 466         << "-fsanitize-coverage=func"
 467         << "-fsanitize-coverage=bb";
 468   if ((CoverageFeatures & CoverageFunc) && (CoverageFeatures & CoverageEdge))
 469     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 470         << "-fsanitize-coverage=func"
 471         << "-fsanitize-coverage=edge";
 472   if ((CoverageFeatures & CoverageBB) && (CoverageFeatures & CoverageEdge))
 473     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 474         << "-fsanitize-coverage=bb"
 475         << "-fsanitize-coverage=edge";
 476   // Basic block tracing and 8-bit counters require some type of coverage
 477   // enabled.
 478   int CoverageTypes = CoverageFunc | CoverageBB | CoverageEdge;
 479   if ((CoverageFeatures & CoverageTraceBB) &&
 480       !(CoverageFeatures & CoverageTypes))
 481     D.Diag(clang::diag::err_drv_argument_only_allowed_with)
 482         << "-fsanitize-coverage=trace-bb"
 483         << "-fsanitize-coverage=(func|bb|edge)";
 484   if ((CoverageFeatures & Coverage8bitCounters) &&
 485       !(CoverageFeatures & CoverageTypes))
 486     D.Diag(clang::diag::err_drv_argument_only_allowed_with)
 487         << "-fsanitize-coverage=8bit-counters"
 488         << "-fsanitize-coverage=(func|bb|edge)";
 489
 490   if (AllAddedKinds & Address) {
 491     AsanSharedRuntime =
 492         Args.hasArg(options::OPT_shared_libasan) ||
 493         (TC.getTriple().getEnvironment() == llvm::Triple::Android);
 494     AsanZeroBaseShadow =
 495         (TC.getTriple().getEnvironment() == llvm::Triple::Android);
 496     if (Arg *A =
 497             Args.getLastArg(options::OPT_fsanitize_address_field_padding)) {
 498         StringRef S = A->getValue();
 499         // Legal values are 0 and 1, 2, but in future we may add more levels.
 500         if (S.getAsInteger(0, AsanFieldPadding) || AsanFieldPadding < 0 ||
 501             AsanFieldPadding > 2) {
 502           D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
 503         }
 504     }
 505
 506     if (Arg *WindowsDebugRTArg =
 507             Args.getLastArg(options::OPT__SLASH_MTd, options::OPT__SLASH_MT,
 508                             options::OPT__SLASH_MDd, options::OPT__SLASH_MD,
 509                             options::OPT__SLASH_LDd, options::OPT__SLASH_LD)) {
 510       switch (WindowsDebugRTArg->getOption().getID()) {
 511       case options::OPT__SLASH_MTd:
 512       case options::OPT__SLASH_MDd:
 513       case options::OPT__SLASH_LDd:
 514         D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 515             << WindowsDebugRTArg->getAsString(Args)
 516             << lastArgumentForMask(D, Args, Address);
 517         D.Diag(clang::diag::note_drv_address_sanitizer_debug_runtime);
 518       }
 519     }
 520   }
 521
 522   // Parse -link-cxx-sanitizer flag.
 523   LinkCXXRuntimes =
 524       Args.hasArg(options::OPT_fsanitize_link_cxx_runtime) || D.CCCIsCXX();
 525
 526   // Finally, initialize the set of available and recoverable sanitizers.
 527   Sanitizers.Mask |= Kinds;
 528   RecoverableSanitizers.Mask |= RecoverableKinds;
 529   TrapSanitizers.Mask |= TrappingKinds;
 530 }
 531
 532 static std::string toString(const clang::SanitizerSet &Sanitizers) {
 533   std::string Res;
 534 #define SANITIZER(NAME, ID)                                                    \
 535   if (Sanitizers.has(ID)) {                                                    \
 536     if (!Res.empty())                                                          \
 537       Res += ",";                                                              \
 538     Res += NAME;                                                               \
 539   }
 540 #include "clang/Basic/Sanitizers.def"
 541   return Res;
 542 }
 543
 544 void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
 545                             llvm::opt::ArgStringList &CmdArgs,
 546                             types::ID InputType) const {
 547   if (Sanitizers.empty())
 548     return;
 549   CmdArgs.push_back(Args.MakeArgString("-fsanitize=" + toString(Sanitizers)));
 550
 551   if (!RecoverableSanitizers.empty())
 552     CmdArgs.push_back(Args.MakeArgString("-fsanitize-recover=" +
 553                                          toString(RecoverableSanitizers)));
 554
 555   if (!TrapSanitizers.empty())
 556     CmdArgs.push_back(
 557         Args.MakeArgString("-fsanitize-trap=" + toString(TrapSanitizers)));
 558
 559   for (const auto &BLPath : BlacklistFiles) {
 560     SmallString<64> BlacklistOpt("-fsanitize-blacklist=");
 561     BlacklistOpt += BLPath;
 562     CmdArgs.push_back(Args.MakeArgString(BlacklistOpt));
 563   }
 564
 565   if (MsanTrackOrigins)
 566     CmdArgs.push_back(Args.MakeArgString("-fsanitize-memory-track-origins=" +
 567                                          llvm::utostr(MsanTrackOrigins)));
 568
 569   if (MsanUseAfterDtor)
 570     CmdArgs.push_back(Args.MakeArgString("-fsanitize-memory-use-after-dtor"));
 571
 572   if (AsanFieldPadding)
 573     CmdArgs.push_back(Args.MakeArgString("-fsanitize-address-field-padding=" +
 574                                          llvm::utostr(AsanFieldPadding)));
 575   // Translate available CoverageFeatures to corresponding clang-cc1 flags.
 576   std::pair<int, const char *> CoverageFlags[] = {
 577     std::make_pair(CoverageFunc, "-fsanitize-coverage-type=1"),
 578     std::make_pair(CoverageBB, "-fsanitize-coverage-type=2"),
 579     std::make_pair(CoverageEdge, "-fsanitize-coverage-type=3"),
 580     std::make_pair(CoverageIndirCall, "-fsanitize-coverage-indirect-calls"),
 581     std::make_pair(CoverageTraceBB, "-fsanitize-coverage-trace-bb"),
 582     std::make_pair(CoverageTraceCmp, "-fsanitize-coverage-trace-cmp"),
 583     std::make_pair(Coverage8bitCounters, "-fsanitize-coverage-8bit-counters")};
 584   for (auto F : CoverageFlags) {
 585     if (CoverageFeatures & F.first)
 586       CmdArgs.push_back(Args.MakeArgString(F.second));
 587   }
 588
 589
 590   // MSan: Workaround for PR16386.
 591   // ASan: This is mainly to help LSan with cases such as
 592   // https://code.google.com/p/address-sanitizer/issues/detail?id=373
 593   // We can't make this conditional on -fsanitize=leak, as that flag shouldn't
 594   // affect compilation.
 595   if (Sanitizers.has(Memory) || Sanitizers.has(Address))
 596     CmdArgs.push_back(Args.MakeArgString("-fno-assume-sane-operator-new"));
 597
 598   if (TC.getTriple().isOSWindows() && needsUbsanRt()) {
 599     // Instruct the code generator to embed linker directives in the object file
 600     // that cause the required runtime libraries to be linked.
 601     CmdArgs.push_back(Args.MakeArgString(
 602         "--dependent-lib=" + tools::getCompilerRT(TC, "ubsan_standalone")));
 603     if (types::isCXX(InputType))
 604       CmdArgs.push_back(
 605           Args.MakeArgString("--dependent-lib=" +
 606                              tools::getCompilerRT(TC, "ubsan_standalone_cxx")));
 607   }
 608 }
 609
 610 SanitizerMask parseArgValues(const Driver &D, const llvm::opt::Arg *A,
 611                              bool DiagnoseErrors) {
 612   assert((A->getOption().matches(options::OPT_fsanitize_EQ) ||
 613           A->getOption().matches(options::OPT_fno_sanitize_EQ) ||
 614           A->getOption().matches(options::OPT_fsanitize_recover_EQ) ||
 615           A->getOption().matches(options::OPT_fno_sanitize_recover_EQ) ||
 616           A->getOption().matches(options::OPT_fsanitize_trap_EQ) ||
 617           A->getOption().matches(options::OPT_fno_sanitize_trap_EQ)) &&
 618          "Invalid argument in parseArgValues!");
 619   SanitizerMask Kinds = 0;
 620   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
 621     const char *Value = A->getValue(i);
 622     SanitizerMask Kind;
 623     // Special case: don't accept -fsanitize=all.
 624     if (A->getOption().matches(options::OPT_fsanitize_EQ) &&
 625         0 == strcmp("all", Value))
 626       Kind = 0;
 627     else
 628       Kind = parseSanitizerValue(Value, /*AllowGroups=*/true);
 629
 630     if (Kind)
 631       Kinds |= Kind;
 632     else if (DiagnoseErrors)
 633       D.Diag(clang::diag::err_drv_unsupported_option_argument)
 634           << A->getOption().getName() << Value;
 635   }
 636   return Kinds;
 637 }
 638
 639 int parseCoverageFeatures(const Driver &D, const llvm::opt::Arg *A) {
 640   assert(A->getOption().matches(options::OPT_fsanitize_coverage) ||
 641          A->getOption().matches(options::OPT_fno_sanitize_coverage));
 642   int Features = 0;
 643   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
 644     const char *Value = A->getValue(i);
 645     int F = llvm::StringSwitch<int>(Value)
 646         .Case("func", CoverageFunc)
 647         .Case("bb", CoverageBB)
 648         .Case("edge", CoverageEdge)
 649         .Case("indirect-calls", CoverageIndirCall)
 650         .Case("trace-bb", CoverageTraceBB)
 651         .Case("trace-cmp", CoverageTraceCmp)
 652         .Case("8bit-counters", Coverage8bitCounters)
 653         .Default(0);
 654     if (F == 0)
 655       D.Diag(clang::diag::err_drv_unsupported_option_argument)
 656           << A->getOption().getName() << Value;
 657     Features |= F;
 658   }
 659   return Features;
 660 }
 661
 662 std::string lastArgumentForMask(const Driver &D, const llvm::opt::ArgList &Args,
 663                                 SanitizerMask Mask) {
 664   for (llvm::opt::ArgList::const_reverse_iterator I = Args.rbegin(),
 665                                                   E = Args.rend();
 666        I != E; ++I) {
 667     const auto *Arg = *I;
 668     if (Arg->getOption().matches(options::OPT_fsanitize_EQ)) {
 669       SanitizerMask AddKinds =
 670           expandSanitizerGroups(parseArgValues(D, Arg, false));
 671       if (AddKinds & Mask)
 672         return describeSanitizeArg(Arg, Mask);
 673     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_EQ)) {
 674       SanitizerMask RemoveKinds =
 675           expandSanitizerGroups(parseArgValues(D, Arg, false));
 676       Mask &= ~RemoveKinds;
 677     }
 678   }
 679   llvm_unreachable("arg list didn't provide expected value");
 680 }
 681
 682 std::string describeSanitizeArg(const llvm::opt::Arg *A, SanitizerMask Mask) {
 683   assert(A->getOption().matches(options::OPT_fsanitize_EQ)
 684          && "Invalid argument in describeSanitizerArg!");
 685
 686   std::string Sanitizers;
 687   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
 688     if (expandSanitizerGroups(
 689             parseSanitizerValue(A->getValue(i), /*AllowGroups=*/true)) &
 690         Mask) {
 691       if (!Sanitizers.empty())
 692         Sanitizers += ",";
 693       Sanitizers += A->getValue(i);
 694     }
 695   }
 696
 697   assert(!Sanitizers.empty() && "arg didn't provide expected value");
 698   return "-fsanitize=" + Sanitizers;
 699 }