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 "ToolChains/CommonArgs.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 | Nullability | CFI,
  30   NeedsUbsanCxxRt = Vptr | CFI,
  31   NotAllowedWithTrap = Vptr,
  32   RequiresPIE = DataFlow,
  33   NeedsUnwindTables = Address | Thread | Memory | DataFlow,
  34   SupportsCoverage =
  35       Address | Memory | Leak | Undefined | Integer | Nullability | DataFlow,
  36   RecoverableByDefault = Undefined | Integer | Nullability,
  37   Unrecoverable = Unreachable | Return,
  38   LegacyFsanitizeRecoverMask = Undefined | Integer,
  39   NeedsLTO = CFI,
  40   TrappingSupported = (Undefined & ~Vptr) | UnsignedIntegerOverflow |
  41                       Nullability | LocalBounds | CFI,
  42   TrappingDefault = CFI,
  43   CFIClasses = CFIVCall | CFINVCall | CFIDerivedCast | CFIUnrelatedCast,
  44 };
  45
  46 enum CoverageFeature {
  47   CoverageFunc = 1 << 0,
  48   CoverageBB = 1 << 1,
  49   CoverageEdge = 1 << 2,
  50   CoverageIndirCall = 1 << 3,
  51   CoverageTraceBB = 1 << 4,
  52   CoverageTraceCmp = 1 << 5,
  53   CoverageTraceDiv = 1 << 6,
  54   CoverageTraceGep = 1 << 7,
  55   Coverage8bitCounters = 1 << 8,
  56   CoverageTracePC = 1 << 9,
  57   CoverageTracePCGuard = 1 << 10,
  58 };
  59
  60 /// Parse a -fsanitize= or -fno-sanitize= argument's values, diagnosing any
  61 /// invalid components. Returns a SanitizerMask.
  62 static SanitizerMask parseArgValues(const Driver &D, const llvm::opt::Arg *A,
  63                                     bool DiagnoseErrors);
  64
  65 /// Parse -f(no-)?sanitize-coverage= flag values, diagnosing any invalid
  66 /// components. Returns OR of members of \c CoverageFeature enumeration.
  67 static int parseCoverageFeatures(const Driver &D, const llvm::opt::Arg *A);
  68
  69 /// Produce an argument string from ArgList \p Args, which shows how it
  70 /// provides some sanitizer kind from \p Mask. For example, the argument list
  71 /// "-fsanitize=thread,vptr -fsanitize=address" with mask \c NeedsUbsanRt
  72 /// would produce "-fsanitize=vptr".
  73 static std::string lastArgumentForMask(const Driver &D,
  74                                        const llvm::opt::ArgList &Args,
  75                                        SanitizerMask Mask);
  76
  77 /// Produce an argument string from argument \p A, which shows how it provides
  78 /// a value in \p Mask. For instance, the argument
  79 /// "-fsanitize=address,alignment" with mask \c NeedsUbsanRt would produce
  80 /// "-fsanitize=alignment".
  81 static std::string describeSanitizeArg(const llvm::opt::Arg *A,
  82                                        SanitizerMask Mask);
  83
  84 /// Produce a string containing comma-separated names of sanitizers in \p
  85 /// Sanitizers set.
  86 static std::string toString(const clang::SanitizerSet &Sanitizers);
  87
  88 static bool getDefaultBlacklist(const Driver &D, SanitizerMask Kinds,
  89                                 std::string &BLPath) {
  90   const char *BlacklistFile = nullptr;
  91   if (Kinds & Address)
  92     BlacklistFile = "asan_blacklist.txt";
  93   else if (Kinds & Memory)
  94     BlacklistFile = "msan_blacklist.txt";
  95   else if (Kinds & Thread)
  96     BlacklistFile = "tsan_blacklist.txt";
  97   else if (Kinds & DataFlow)
  98     BlacklistFile = "dfsan_abilist.txt";
  99   else if (Kinds & CFI)
 100     BlacklistFile = "cfi_blacklist.txt";
 101
 102   if (BlacklistFile) {
 103     clang::SmallString<64> Path(D.ResourceDir);
 104     llvm::sys::path::append(Path, BlacklistFile);
 105     BLPath = Path.str();
 106     return true;
 107   }
 108   return false;
 109 }
 110
 111 /// Sets group bits for every group that has at least one representative already
 112 /// enabled in \p Kinds.
 113 static SanitizerMask setGroupBits(SanitizerMask Kinds) {
 114 #define SANITIZER(NAME, ID)
 115 #define SANITIZER_GROUP(NAME, ID, ALIAS)                                       \
 116   if (Kinds & SanitizerKind::ID)                                               \
 117     Kinds |= SanitizerKind::ID##Group;
 118 #include "clang/Basic/Sanitizers.def"
 119   return Kinds;
 120 }
 121
 122 static SanitizerMask parseSanitizeTrapArgs(const Driver &D,
 123                                            const llvm::opt::ArgList &Args) {
 124   SanitizerMask TrapRemove = 0; // During the loop below, the accumulated set of
 125                                 // sanitizers disabled by the current sanitizer
 126                                 // argument or any argument after it.
 127   SanitizerMask TrappingKinds = 0;
 128   SanitizerMask TrappingSupportedWithGroups = setGroupBits(TrappingSupported);
 129
 130   for (ArgList::const_reverse_iterator I = Args.rbegin(), E = Args.rend();
 131        I != E; ++I) {
 132     const auto *Arg = *I;
 133     if (Arg->getOption().matches(options::OPT_fsanitize_trap_EQ)) {
 134       Arg->claim();
 135       SanitizerMask Add = parseArgValues(D, Arg, true);
 136       Add &= ~TrapRemove;
 137       if (SanitizerMask InvalidValues = Add & ~TrappingSupportedWithGroups) {
 138         SanitizerSet S;
 139         S.Mask = InvalidValues;
 140         D.Diag(diag::err_drv_unsupported_option_argument) << "-fsanitize-trap"
 141                                                           << toString(S);
 142       }
 143       TrappingKinds |= expandSanitizerGroups(Add) & ~TrapRemove;
 144     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_trap_EQ)) {
 145       Arg->claim();
 146       TrapRemove |= expandSanitizerGroups(parseArgValues(D, Arg, true));
 147     } else if (Arg->getOption().matches(
 148                    options::OPT_fsanitize_undefined_trap_on_error)) {
 149       Arg->claim();
 150       TrappingKinds |=
 151           expandSanitizerGroups(UndefinedGroup & ~TrapRemove) & ~TrapRemove;
 152     } else if (Arg->getOption().matches(
 153                    options::OPT_fno_sanitize_undefined_trap_on_error)) {
 154       Arg->claim();
 155       TrapRemove |= expandSanitizerGroups(UndefinedGroup);
 156     }
 157   }
 158
 159   // Apply default trapping behavior.
 160   TrappingKinds |= TrappingDefault & ~TrapRemove;
 161
 162   return TrappingKinds;
 163 }
 164
 165 bool SanitizerArgs::needsUbsanRt() const {
 166   return ((Sanitizers.Mask & NeedsUbsanRt & ~TrapSanitizers.Mask) ||
 167           CoverageFeatures) &&
 168          !Sanitizers.has(Address) && !Sanitizers.has(Memory) &&
 169          !Sanitizers.has(Thread) && !Sanitizers.has(DataFlow) &&
 170          !Sanitizers.has(Leak) && !CfiCrossDso;
 171 }
 172
 173 bool SanitizerArgs::needsCfiRt() const {
 174   return !(Sanitizers.Mask & CFI & ~TrapSanitizers.Mask) && CfiCrossDso;
 175 }
 176
 177 bool SanitizerArgs::needsCfiDiagRt() const {
 178   return (Sanitizers.Mask & CFI & ~TrapSanitizers.Mask) && CfiCrossDso;
 179 }
 180
 181 bool SanitizerArgs::requiresPIE() const {
 182   return NeedPIE || (Sanitizers.Mask & RequiresPIE);
 183 }
 184
 185 bool SanitizerArgs::needsUnwindTables() const {
 186   return Sanitizers.Mask & NeedsUnwindTables;
 187 }
 188
 189 SanitizerArgs::SanitizerArgs(const ToolChain &TC,
 190                              const llvm::opt::ArgList &Args) {
 191   SanitizerMask AllRemove = 0;  // During the loop below, the accumulated set of
 192                                 // sanitizers disabled by the current sanitizer
 193                                 // argument or any argument after it.
 194   SanitizerMask AllAddedKinds = 0;  // Mask of all sanitizers ever enabled by
 195                                     // -fsanitize= flags (directly or via group
 196                                     // expansion), some of which may be disabled
 197                                     // later. Used to carefully prune
 198                                     // unused-argument diagnostics.
 199   SanitizerMask DiagnosedKinds = 0;  // All Kinds we have diagnosed up to now.
 200                                      // Used to deduplicate diagnostics.
 201   SanitizerMask Kinds = 0;
 202   const SanitizerMask Supported = setGroupBits(TC.getSupportedSanitizers());
 203   ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
 204
 205   const Driver &D = TC.getDriver();
 206   SanitizerMask TrappingKinds = parseSanitizeTrapArgs(D, Args);
 207   SanitizerMask InvalidTrappingKinds = TrappingKinds & NotAllowedWithTrap;
 208
 209   for (ArgList::const_reverse_iterator I = Args.rbegin(), E = Args.rend();
 210        I != E; ++I) {
 211     const auto *Arg = *I;
 212     if (Arg->getOption().matches(options::OPT_fsanitize_EQ)) {
 213       Arg->claim();
 214       SanitizerMask Add = parseArgValues(D, Arg, true);
 215       AllAddedKinds |= expandSanitizerGroups(Add);
 216
 217       // Avoid diagnosing any sanitizer which is disabled later.
 218       Add &= ~AllRemove;
 219       // At this point we have not expanded groups, so any unsupported
 220       // sanitizers in Add are those which have been explicitly enabled.
 221       // Diagnose them.
 222       if (SanitizerMask KindsToDiagnose =
 223               Add & InvalidTrappingKinds & ~DiagnosedKinds) {
 224         std::string Desc = describeSanitizeArg(*I, KindsToDiagnose);
 225         D.Diag(diag::err_drv_argument_not_allowed_with)
 226             << Desc << "-fsanitize-trap=undefined";
 227         DiagnosedKinds |= KindsToDiagnose;
 228       }
 229       Add &= ~InvalidTrappingKinds;
 230       if (SanitizerMask KindsToDiagnose = Add & ~Supported & ~DiagnosedKinds) {
 231         std::string Desc = describeSanitizeArg(*I, KindsToDiagnose);
 232         D.Diag(diag::err_drv_unsupported_opt_for_target)
 233             << Desc << TC.getTriple().str();
 234         DiagnosedKinds |= KindsToDiagnose;
 235       }
 236       Add &= Supported;
 237
 238       // Test for -fno-rtti + explicit -fsanitizer=vptr before expanding groups
 239       // so we don't error out if -fno-rtti and -fsanitize=undefined were
 240       // passed.
 241       if (Add & Vptr &&
 242           (RTTIMode == ToolChain::RM_DisabledImplicitly ||
 243            RTTIMode == ToolChain::RM_DisabledExplicitly)) {
 244         if (RTTIMode == ToolChain::RM_DisabledImplicitly)
 245           // Warn about not having rtti enabled if the vptr sanitizer is
 246           // explicitly enabled
 247           D.Diag(diag::warn_drv_disabling_vptr_no_rtti_default);
 248         else {
 249           const llvm::opt::Arg *NoRTTIArg = TC.getRTTIArg();
 250           assert(NoRTTIArg &&
 251                  "RTTI disabled explicitly but we have no argument!");
 252           D.Diag(diag::err_drv_argument_not_allowed_with)
 253               << "-fsanitize=vptr" << NoRTTIArg->getAsString(Args);
 254         }
 255
 256         // Take out the Vptr sanitizer from the enabled sanitizers
 257         AllRemove |= Vptr;
 258       }
 259
 260       Add = expandSanitizerGroups(Add);
 261       // Group expansion may have enabled a sanitizer which is disabled later.
 262       Add &= ~AllRemove;
 263       // Silently discard any unsupported sanitizers implicitly enabled through
 264       // group expansion.
 265       Add &= ~InvalidTrappingKinds;
 266       Add &= Supported;
 267
 268       // Enable coverage if the fuzzing flag is set.
 269       if (Add & Fuzzer)
 270         CoverageFeatures |= CoverageTracePCGuard | CoverageIndirCall | CoverageTraceCmp;
 271
 272       Kinds |= Add;
 273     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_EQ)) {
 274       Arg->claim();
 275       SanitizerMask Remove = parseArgValues(D, Arg, true);
 276       AllRemove |= expandSanitizerGroups(Remove);
 277     }
 278   }
 279
 280   // Enable toolchain specific default sanitizers if not explicitly disabled.
 281   Kinds |= TC.getDefaultSanitizers() & ~AllRemove;
 282
 283   // We disable the vptr sanitizer if it was enabled by group expansion but RTTI
 284   // is disabled.
 285   if ((Kinds & Vptr) &&
 286       (RTTIMode == ToolChain::RM_DisabledImplicitly ||
 287        RTTIMode == ToolChain::RM_DisabledExplicitly)) {
 288     Kinds &= ~Vptr;
 289   }
 290
 291   // Check that LTO is enabled if we need it.
 292   if ((Kinds & NeedsLTO) && !D.isUsingLTO()) {
 293     D.Diag(diag::err_drv_argument_only_allowed_with)
 294         << lastArgumentForMask(D, Args, Kinds & NeedsLTO) << "-flto";
 295   }
 296
 297   // Report error if there are non-trapping sanitizers that require
 298   // c++abi-specific  parts of UBSan runtime, and they are not provided by the
 299   // toolchain. We don't have a good way to check the latter, so we just
 300   // check if the toolchan supports vptr.
 301   if (~Supported & Vptr) {
 302     SanitizerMask KindsToDiagnose = Kinds & ~TrappingKinds & NeedsUbsanCxxRt;
 303     // The runtime library supports the Microsoft C++ ABI, but only well enough
 304     // for CFI. FIXME: Remove this once we support vptr on Windows.
 305     if (TC.getTriple().isOSWindows())
 306       KindsToDiagnose &= ~CFI;
 307     if (KindsToDiagnose) {
 308       SanitizerSet S;
 309       S.Mask = KindsToDiagnose;
 310       D.Diag(diag::err_drv_unsupported_opt_for_target)
 311           << ("-fno-sanitize-trap=" + toString(S)) << TC.getTriple().str();
 312       Kinds &= ~KindsToDiagnose;
 313     }
 314   }
 315
 316   // Warn about incompatible groups of sanitizers.
 317   std::pair<SanitizerMask, SanitizerMask> IncompatibleGroups[] = {
 318       std::make_pair(Address, Thread), std::make_pair(Address, Memory),
 319       std::make_pair(Thread, Memory), std::make_pair(Leak, Thread),
 320       std::make_pair(Leak, Memory), std::make_pair(KernelAddress, Address),
 321       std::make_pair(KernelAddress, Leak),
 322       std::make_pair(KernelAddress, Thread),
 323       std::make_pair(KernelAddress, Memory),
 324       std::make_pair(Efficiency, Address),
 325       std::make_pair(Efficiency, Leak),
 326       std::make_pair(Efficiency, Thread),
 327       std::make_pair(Efficiency, Memory),
 328       std::make_pair(Efficiency, KernelAddress)};
 329   for (auto G : IncompatibleGroups) {
 330     SanitizerMask Group = G.first;
 331     if (Kinds & Group) {
 332       if (SanitizerMask Incompatible = Kinds & G.second) {
 333         D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 334             << lastArgumentForMask(D, Args, Group)
 335             << lastArgumentForMask(D, Args, Incompatible);
 336         Kinds &= ~Incompatible;
 337       }
 338     }
 339   }
 340   // FIXME: Currently -fsanitize=leak is silently ignored in the presence of
 341   // -fsanitize=address. Perhaps it should print an error, or perhaps
 342   // -f(-no)sanitize=leak should change whether leak detection is enabled by
 343   // default in ASan?
 344
 345   // Parse -f(no-)?sanitize-recover flags.
 346   SanitizerMask RecoverableKinds = RecoverableByDefault;
 347   SanitizerMask DiagnosedUnrecoverableKinds = 0;
 348   for (const auto *Arg : Args) {
 349     const char *DeprecatedReplacement = nullptr;
 350     if (Arg->getOption().matches(options::OPT_fsanitize_recover)) {
 351       DeprecatedReplacement =
 352           "-fsanitize-recover=undefined,integer' or '-fsanitize-recover=all";
 353       RecoverableKinds |= expandSanitizerGroups(LegacyFsanitizeRecoverMask);
 354       Arg->claim();
 355     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_recover)) {
 356       DeprecatedReplacement = "-fno-sanitize-recover=undefined,integer' or "
 357                               "'-fno-sanitize-recover=all";
 358       RecoverableKinds &= ~expandSanitizerGroups(LegacyFsanitizeRecoverMask);
 359       Arg->claim();
 360     } else if (Arg->getOption().matches(options::OPT_fsanitize_recover_EQ)) {
 361       SanitizerMask Add = parseArgValues(D, Arg, true);
 362       // Report error if user explicitly tries to recover from unrecoverable
 363       // sanitizer.
 364       if (SanitizerMask KindsToDiagnose =
 365               Add & Unrecoverable & ~DiagnosedUnrecoverableKinds) {
 366         SanitizerSet SetToDiagnose;
 367         SetToDiagnose.Mask |= KindsToDiagnose;
 368         D.Diag(diag::err_drv_unsupported_option_argument)
 369             << Arg->getOption().getName() << toString(SetToDiagnose);
 370         DiagnosedUnrecoverableKinds |= KindsToDiagnose;
 371       }
 372       RecoverableKinds |= expandSanitizerGroups(Add);
 373       Arg->claim();
 374     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_recover_EQ)) {
 375       RecoverableKinds &= ~expandSanitizerGroups(parseArgValues(D, Arg, true));
 376       Arg->claim();
 377     }
 378     if (DeprecatedReplacement) {
 379       D.Diag(diag::warn_drv_deprecated_arg) << Arg->getAsString(Args)
 380                                             << DeprecatedReplacement;
 381     }
 382   }
 383   RecoverableKinds &= Kinds;
 384   RecoverableKinds &= ~Unrecoverable;
 385
 386   TrappingKinds &= Kinds;
 387
 388   // Setup blacklist files.
 389   // Add default blacklist from resource directory.
 390   {
 391     std::string BLPath;
 392     if (getDefaultBlacklist(D, Kinds, BLPath) && llvm::sys::fs::exists(BLPath))
 393       BlacklistFiles.push_back(BLPath);
 394   }
 395   // Parse -f(no-)sanitize-blacklist options.
 396   for (const auto *Arg : Args) {
 397     if (Arg->getOption().matches(options::OPT_fsanitize_blacklist)) {
 398       Arg->claim();
 399       std::string BLPath = Arg->getValue();
 400       if (llvm::sys::fs::exists(BLPath)) {
 401         BlacklistFiles.push_back(BLPath);
 402         ExtraDeps.push_back(BLPath);
 403       } else
 404         D.Diag(clang::diag::err_drv_no_such_file) << BLPath;
 405
 406     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_blacklist)) {
 407       Arg->claim();
 408       BlacklistFiles.clear();
 409       ExtraDeps.clear();
 410     }
 411   }
 412   // Validate blacklists format.
 413   {
 414     std::string BLError;
 415     std::unique_ptr<llvm::SpecialCaseList> SCL(
 416         llvm::SpecialCaseList::create(BlacklistFiles, BLError));
 417     if (!SCL.get())
 418       D.Diag(clang::diag::err_drv_malformed_sanitizer_blacklist) << BLError;
 419   }
 420
 421   // Parse -f[no-]sanitize-memory-track-origins[=level] options.
 422   if (AllAddedKinds & Memory) {
 423     if (Arg *A =
 424             Args.getLastArg(options::OPT_fsanitize_memory_track_origins_EQ,
 425                             options::OPT_fsanitize_memory_track_origins,
 426                             options::OPT_fno_sanitize_memory_track_origins)) {
 427       if (A->getOption().matches(options::OPT_fsanitize_memory_track_origins)) {
 428         MsanTrackOrigins = 2;
 429       } else if (A->getOption().matches(
 430                      options::OPT_fno_sanitize_memory_track_origins)) {
 431         MsanTrackOrigins = 0;
 432       } else {
 433         StringRef S = A->getValue();
 434         if (S.getAsInteger(0, MsanTrackOrigins) || MsanTrackOrigins < 0 ||
 435             MsanTrackOrigins > 2) {
 436           D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
 437         }
 438       }
 439     }
 440     MsanUseAfterDtor =
 441         Args.hasArg(options::OPT_fsanitize_memory_use_after_dtor);
 442     NeedPIE |= !(TC.getTriple().isOSLinux() &&
 443                  TC.getTriple().getArch() == llvm::Triple::x86_64);
 444   }
 445
 446   if (AllAddedKinds & Thread) {
 447     TsanMemoryAccess = Args.hasFlag(options::OPT_fsanitize_thread_memory_access,
 448                                     options::OPT_fno_sanitize_thread_memory_access,
 449                                     TsanMemoryAccess);
 450     TsanFuncEntryExit = Args.hasFlag(options::OPT_fsanitize_thread_func_entry_exit,
 451                                      options::OPT_fno_sanitize_thread_func_entry_exit,
 452                                      TsanFuncEntryExit);
 453     TsanAtomics = Args.hasFlag(options::OPT_fsanitize_thread_atomics,
 454                                options::OPT_fno_sanitize_thread_atomics,
 455                                TsanAtomics);
 456   }
 457
 458   if (AllAddedKinds & CFI) {
 459     CfiCrossDso = Args.hasFlag(options::OPT_fsanitize_cfi_cross_dso,
 460                                options::OPT_fno_sanitize_cfi_cross_dso, false);
 461     // Without PIE, external function address may resolve to a PLT record, which
 462     // can not be verified by the target module.
 463     NeedPIE |= CfiCrossDso;
 464   }
 465
 466   Stats = Args.hasFlag(options::OPT_fsanitize_stats,
 467                        options::OPT_fno_sanitize_stats, false);
 468
 469   // Parse -f(no-)?sanitize-coverage flags if coverage is supported by the
 470   // enabled sanitizers.
 471   for (const auto *Arg : Args) {
 472     if (Arg->getOption().matches(options::OPT_fsanitize_coverage)) {
 473       int LegacySanitizeCoverage;
 474       if (Arg->getNumValues() == 1 &&
 475           !StringRef(Arg->getValue(0))
 476                .getAsInteger(0, LegacySanitizeCoverage)) {
 477         CoverageFeatures = 0;
 478         Arg->claim();
 479         if (LegacySanitizeCoverage != 0) {
 480           D.Diag(diag::warn_drv_deprecated_arg)
 481               << Arg->getAsString(Args) << "-fsanitize-coverage=trace-pc-guard";
 482         }
 483         continue;
 484       }
 485       CoverageFeatures |= parseCoverageFeatures(D, Arg);
 486
 487       // Disable coverage and not claim the flags if there is at least one
 488       // non-supporting sanitizer.
 489       if (!(AllAddedKinds & ~setGroupBits(SupportsCoverage))) {
 490         Arg->claim();
 491       } else {
 492         CoverageFeatures = 0;
 493       }
 494     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_coverage)) {
 495       Arg->claim();
 496       CoverageFeatures &= ~parseCoverageFeatures(D, Arg);
 497     }
 498   }
 499   // Choose at most one coverage type: function, bb, or edge.
 500   if ((CoverageFeatures & CoverageFunc) && (CoverageFeatures & CoverageBB))
 501     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 502         << "-fsanitize-coverage=func"
 503         << "-fsanitize-coverage=bb";
 504   if ((CoverageFeatures & CoverageFunc) && (CoverageFeatures & CoverageEdge))
 505     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 506         << "-fsanitize-coverage=func"
 507         << "-fsanitize-coverage=edge";
 508   if ((CoverageFeatures & CoverageBB) && (CoverageFeatures & CoverageEdge))
 509     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 510         << "-fsanitize-coverage=bb"
 511         << "-fsanitize-coverage=edge";
 512   // Basic block tracing and 8-bit counters require some type of coverage
 513   // enabled.
 514   int CoverageTypes = CoverageFunc | CoverageBB | CoverageEdge;
 515   if (CoverageFeatures & CoverageTraceBB)
 516     D.Diag(clang::diag::warn_drv_deprecated_arg)
 517         << "-fsanitize-coverage=trace-bb"
 518         << "-fsanitize-coverage=trace-pc-guard";
 519   if (CoverageFeatures & Coverage8bitCounters)
 520     D.Diag(clang::diag::warn_drv_deprecated_arg)
 521         << "-fsanitize-coverage=8bit-counters"
 522         << "-fsanitize-coverage=trace-pc-guard";
 523   // trace-pc w/o func/bb/edge implies edge.
 524   if ((CoverageFeatures & (CoverageTracePC | CoverageTracePCGuard)) &&
 525       !(CoverageFeatures & CoverageTypes))
 526     CoverageFeatures |= CoverageEdge;
 527
 528   if (AllAddedKinds & Address) {
 529     AsanSharedRuntime =
 530         Args.hasArg(options::OPT_shared_libasan) || TC.getTriple().isAndroid();
 531     NeedPIE |= TC.getTriple().isAndroid();
 532     if (Arg *A =
 533             Args.getLastArg(options::OPT_fsanitize_address_field_padding)) {
 534         StringRef S = A->getValue();
 535         // Legal values are 0 and 1, 2, but in future we may add more levels.
 536         if (S.getAsInteger(0, AsanFieldPadding) || AsanFieldPadding < 0 ||
 537             AsanFieldPadding > 2) {
 538           D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
 539         }
 540     }
 541
 542     if (Arg *WindowsDebugRTArg =
 543             Args.getLastArg(options::OPT__SLASH_MTd, options::OPT__SLASH_MT,
 544                             options::OPT__SLASH_MDd, options::OPT__SLASH_MD,
 545                             options::OPT__SLASH_LDd, options::OPT__SLASH_LD)) {
 546       switch (WindowsDebugRTArg->getOption().getID()) {
 547       case options::OPT__SLASH_MTd:
 548       case options::OPT__SLASH_MDd:
 549       case options::OPT__SLASH_LDd:
 550         D.Diag(clang::diag::err_drv_argument_not_allowed_with)
 551             << WindowsDebugRTArg->getAsString(Args)
 552             << lastArgumentForMask(D, Args, Address);
 553         D.Diag(clang::diag::note_drv_address_sanitizer_debug_runtime);
 554       }
 555     }
 556
 557     if (Arg *A = Args.getLastArg(
 558             options::OPT_fsanitize_address_use_after_scope,
 559             options::OPT_fno_sanitize_address_use_after_scope)) {
 560       AsanUseAfterScope = A->getOption().getID() ==
 561                           options::OPT_fsanitize_address_use_after_scope;
 562     }
 563   }
 564
 565   // Parse -link-cxx-sanitizer flag.
 566   LinkCXXRuntimes =
 567       Args.hasArg(options::OPT_fsanitize_link_cxx_runtime) || D.CCCIsCXX();
 568
 569   // Finally, initialize the set of available and recoverable sanitizers.
 570   Sanitizers.Mask |= Kinds;
 571   RecoverableSanitizers.Mask |= RecoverableKinds;
 572   TrapSanitizers.Mask |= TrappingKinds;
 573 }
 574
 575 static std::string toString(const clang::SanitizerSet &Sanitizers) {
 576   std::string Res;
 577 #define SANITIZER(NAME, ID)                                                    \
 578   if (Sanitizers.has(ID)) {                                                    \
 579     if (!Res.empty())                                                          \
 580       Res += ",";                                                              \
 581     Res += NAME;                                                               \
 582   }
 583 #include "clang/Basic/Sanitizers.def"
 584   return Res;
 585 }
 586
 587 static void addIncludeLinkerOption(const ToolChain &TC,
 588                                    const llvm::opt::ArgList &Args,
 589                                    llvm::opt::ArgStringList &CmdArgs,
 590                                    StringRef SymbolName) {
 591   SmallString<64> LinkerOptionFlag;
 592   LinkerOptionFlag = "--linker-option=/include:";
 593   if (TC.getTriple().getArch() == llvm::Triple::x86) {
 594     // Win32 mangles C function names with a '_' prefix.
 595     LinkerOptionFlag += '_';
 596   }
 597   LinkerOptionFlag += SymbolName;
 598   CmdArgs.push_back(Args.MakeArgString(LinkerOptionFlag));
 599 }
 600
 601 void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
 602                             llvm::opt::ArgStringList &CmdArgs,
 603                             types::ID InputType) const {
 604   // NVPTX doesn't currently support sanitizers.  Bailing out here means that
 605   // e.g. -fsanitize=address applies only to host code, which is what we want
 606   // for now.
 607   if (TC.getTriple().isNVPTX())
 608     return;
 609
 610   // Translate available CoverageFeatures to corresponding clang-cc1 flags.
 611   // Do it even if Sanitizers.empty() since some forms of coverage don't require
 612   // sanitizers.
 613   std::pair<int, const char *> CoverageFlags[] = {
 614     std::make_pair(CoverageFunc, "-fsanitize-coverage-type=1"),
 615     std::make_pair(CoverageBB, "-fsanitize-coverage-type=2"),
 616     std::make_pair(CoverageEdge, "-fsanitize-coverage-type=3"),
 617     std::make_pair(CoverageIndirCall, "-fsanitize-coverage-indirect-calls"),
 618     std::make_pair(CoverageTraceBB, "-fsanitize-coverage-trace-bb"),
 619     std::make_pair(CoverageTraceCmp, "-fsanitize-coverage-trace-cmp"),
 620     std::make_pair(CoverageTraceDiv, "-fsanitize-coverage-trace-div"),
 621     std::make_pair(CoverageTraceGep, "-fsanitize-coverage-trace-gep"),
 622     std::make_pair(Coverage8bitCounters, "-fsanitize-coverage-8bit-counters"),
 623     std::make_pair(CoverageTracePC, "-fsanitize-coverage-trace-pc"),
 624     std::make_pair(CoverageTracePCGuard, "-fsanitize-coverage-trace-pc-guard")};
 625   for (auto F : CoverageFlags) {
 626     if (CoverageFeatures & F.first)
 627       CmdArgs.push_back(Args.MakeArgString(F.second));
 628   }
 629
 630   if (TC.getTriple().isOSWindows() && needsUbsanRt()) {
 631     // Instruct the code generator to embed linker directives in the object file
 632     // that cause the required runtime libraries to be linked.
 633     CmdArgs.push_back(Args.MakeArgString(
 634         "--dependent-lib=" + TC.getCompilerRT(Args, "ubsan_standalone")));
 635     if (types::isCXX(InputType))
 636       CmdArgs.push_back(Args.MakeArgString(
 637           "--dependent-lib=" + TC.getCompilerRT(Args, "ubsan_standalone_cxx")));
 638   }
 639   if (TC.getTriple().isOSWindows() && needsStatsRt()) {
 640     CmdArgs.push_back(Args.MakeArgString("--dependent-lib=" +
 641                                          TC.getCompilerRT(Args, "stats_client")));
 642
 643     // The main executable must export the stats runtime.
 644     // FIXME: Only exporting from the main executable (e.g. based on whether the
 645     // translation unit defines main()) would save a little space, but having
 646     // multiple copies of the runtime shouldn't hurt.
 647     CmdArgs.push_back(Args.MakeArgString("--dependent-lib=" +
 648                                          TC.getCompilerRT(Args, "stats")));
 649     addIncludeLinkerOption(TC, Args, CmdArgs, "__sanitizer_stats_register");
 650   }
 651
 652   if (Sanitizers.empty())
 653     return;
 654   CmdArgs.push_back(Args.MakeArgString("-fsanitize=" + toString(Sanitizers)));
 655
 656   if (!RecoverableSanitizers.empty())
 657     CmdArgs.push_back(Args.MakeArgString("-fsanitize-recover=" +
 658                                          toString(RecoverableSanitizers)));
 659
 660   if (!TrapSanitizers.empty())
 661     CmdArgs.push_back(
 662         Args.MakeArgString("-fsanitize-trap=" + toString(TrapSanitizers)));
 663
 664   for (const auto &BLPath : BlacklistFiles) {
 665     SmallString<64> BlacklistOpt("-fsanitize-blacklist=");
 666     BlacklistOpt += BLPath;
 667     CmdArgs.push_back(Args.MakeArgString(BlacklistOpt));
 668   }
 669   for (const auto &Dep : ExtraDeps) {
 670     SmallString<64> ExtraDepOpt("-fdepfile-entry=");
 671     ExtraDepOpt += Dep;
 672     CmdArgs.push_back(Args.MakeArgString(ExtraDepOpt));
 673   }
 674
 675   if (MsanTrackOrigins)
 676     CmdArgs.push_back(Args.MakeArgString("-fsanitize-memory-track-origins=" +
 677                                          llvm::utostr(MsanTrackOrigins)));
 678
 679   if (MsanUseAfterDtor)
 680     CmdArgs.push_back(Args.MakeArgString("-fsanitize-memory-use-after-dtor"));
 681
 682   // FIXME: Pass these parameters as function attributes, not as -llvm flags.
 683   if (!TsanMemoryAccess) {
 684     CmdArgs.push_back("-mllvm");
 685     CmdArgs.push_back("-tsan-instrument-memory-accesses=0");
 686     CmdArgs.push_back("-mllvm");
 687     CmdArgs.push_back("-tsan-instrument-memintrinsics=0");
 688   }
 689   if (!TsanFuncEntryExit) {
 690     CmdArgs.push_back("-mllvm");
 691     CmdArgs.push_back("-tsan-instrument-func-entry-exit=0");
 692   }
 693   if (!TsanAtomics) {
 694     CmdArgs.push_back("-mllvm");
 695     CmdArgs.push_back("-tsan-instrument-atomics=0");
 696   }
 697
 698   if (CfiCrossDso)
 699     CmdArgs.push_back(Args.MakeArgString("-fsanitize-cfi-cross-dso"));
 700
 701   if (Stats)
 702     CmdArgs.push_back(Args.MakeArgString("-fsanitize-stats"));
 703
 704   if (AsanFieldPadding)
 705     CmdArgs.push_back(Args.MakeArgString("-fsanitize-address-field-padding=" +
 706                                          llvm::utostr(AsanFieldPadding)));
 707
 708   if (AsanUseAfterScope)
 709     CmdArgs.push_back(Args.MakeArgString("-fsanitize-address-use-after-scope"));
 710
 711   // MSan: Workaround for PR16386.
 712   // ASan: This is mainly to help LSan with cases such as
 713   // https://code.google.com/p/address-sanitizer/issues/detail?id=373
 714   // We can't make this conditional on -fsanitize=leak, as that flag shouldn't
 715   // affect compilation.
 716   if (Sanitizers.has(Memory) || Sanitizers.has(Address))
 717     CmdArgs.push_back(Args.MakeArgString("-fno-assume-sane-operator-new"));
 718
 719   // Require -fvisibility= flag on non-Windows when compiling if vptr CFI is
 720   // enabled.
 721   if (Sanitizers.hasOneOf(CFIClasses) && !TC.getTriple().isOSWindows() &&
 722       !Args.hasArg(options::OPT_fvisibility_EQ)) {
 723     TC.getDriver().Diag(clang::diag::err_drv_argument_only_allowed_with)
 724         << lastArgumentForMask(TC.getDriver(), Args,
 725                                Sanitizers.Mask & CFIClasses)
 726         << "-fvisibility=";
 727   }
 728 }
 729
 730 SanitizerMask parseArgValues(const Driver &D, const llvm::opt::Arg *A,
 731                              bool DiagnoseErrors) {
 732   assert((A->getOption().matches(options::OPT_fsanitize_EQ) ||
 733           A->getOption().matches(options::OPT_fno_sanitize_EQ) ||
 734           A->getOption().matches(options::OPT_fsanitize_recover_EQ) ||
 735           A->getOption().matches(options::OPT_fno_sanitize_recover_EQ) ||
 736           A->getOption().matches(options::OPT_fsanitize_trap_EQ) ||
 737           A->getOption().matches(options::OPT_fno_sanitize_trap_EQ)) &&
 738          "Invalid argument in parseArgValues!");
 739   SanitizerMask Kinds = 0;
 740   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
 741     const char *Value = A->getValue(i);
 742     SanitizerMask Kind;
 743     // Special case: don't accept -fsanitize=all.
 744     if (A->getOption().matches(options::OPT_fsanitize_EQ) &&
 745         0 == strcmp("all", Value))
 746       Kind = 0;
 747     // Similarly, don't accept -fsanitize=efficiency-all.
 748     else if (A->getOption().matches(options::OPT_fsanitize_EQ) &&
 749         0 == strcmp("efficiency-all", Value))
 750       Kind = 0;
 751     else
 752       Kind = parseSanitizerValue(Value, /*AllowGroups=*/true);
 753
 754     if (Kind)
 755       Kinds |= Kind;
 756     else if (DiagnoseErrors)
 757       D.Diag(clang::diag::err_drv_unsupported_option_argument)
 758           << A->getOption().getName() << Value;
 759   }
 760   return Kinds;
 761 }
 762
 763 int parseCoverageFeatures(const Driver &D, const llvm::opt::Arg *A) {
 764   assert(A->getOption().matches(options::OPT_fsanitize_coverage) ||
 765          A->getOption().matches(options::OPT_fno_sanitize_coverage));
 766   int Features = 0;
 767   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
 768     const char *Value = A->getValue(i);
 769     int F = llvm::StringSwitch<int>(Value)
 770         .Case("func", CoverageFunc)
 771         .Case("bb", CoverageBB)
 772         .Case("edge", CoverageEdge)
 773         .Case("indirect-calls", CoverageIndirCall)
 774         .Case("trace-bb", CoverageTraceBB)
 775         .Case("trace-cmp", CoverageTraceCmp)
 776         .Case("trace-div", CoverageTraceDiv)
 777         .Case("trace-gep", CoverageTraceGep)
 778         .Case("8bit-counters", Coverage8bitCounters)
 779         .Case("trace-pc", CoverageTracePC)
 780         .Case("trace-pc-guard", CoverageTracePCGuard)
 781         .Default(0);
 782     if (F == 0)
 783       D.Diag(clang::diag::err_drv_unsupported_option_argument)
 784           << A->getOption().getName() << Value;
 785     Features |= F;
 786   }
 787   return Features;
 788 }
 789
 790 std::string lastArgumentForMask(const Driver &D, const llvm::opt::ArgList &Args,
 791                                 SanitizerMask Mask) {
 792   for (llvm::opt::ArgList::const_reverse_iterator I = Args.rbegin(),
 793                                                   E = Args.rend();
 794        I != E; ++I) {
 795     const auto *Arg = *I;
 796     if (Arg->getOption().matches(options::OPT_fsanitize_EQ)) {
 797       SanitizerMask AddKinds =
 798           expandSanitizerGroups(parseArgValues(D, Arg, false));
 799       if (AddKinds & Mask)
 800         return describeSanitizeArg(Arg, Mask);
 801     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_EQ)) {
 802       SanitizerMask RemoveKinds =
 803           expandSanitizerGroups(parseArgValues(D, Arg, false));
 804       Mask &= ~RemoveKinds;
 805     }
 806   }
 807   llvm_unreachable("arg list didn't provide expected value");
 808 }
 809
 810 std::string describeSanitizeArg(const llvm::opt::Arg *A, SanitizerMask Mask) {
 811   assert(A->getOption().matches(options::OPT_fsanitize_EQ)
 812          && "Invalid argument in describeSanitizerArg!");
 813
 814   std::string Sanitizers;
 815   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
 816     if (expandSanitizerGroups(
 817             parseSanitizerValue(A->getValue(i), /*AllowGroups=*/true)) &
 818         Mask) {
 819       if (!Sanitizers.empty())
 820         Sanitizers += ",";
 821       Sanitizers += A->getValue(i);
 822     }
 823   }
 824
 825   assert(!Sanitizers.empty() && "arg didn't provide expected value");
 826   return "-fsanitize=" + Sanitizers;
 827 }