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   else if (Kinds & CFI)
94     BlacklistFile = "cfi_blacklist.txt";
95 
96   if (BlacklistFile) {
97     clang::SmallString<64> Path(D.ResourceDir);
98     llvm::sys::path::append(Path, BlacklistFile);
99     BLPath = Path.str();
100     return true;
101   }
102   return false;
103 }
104 
105 /// Sets group bits for every group that has at least one representative already
106 /// enabled in \p Kinds.
107 static SanitizerMask setGroupBits(SanitizerMask Kinds) {
108 #define SANITIZER(NAME, ID)
109 #define SANITIZER_GROUP(NAME, ID, ALIAS)                                       \
110   if (Kinds & SanitizerKind::ID)                                               \
111     Kinds |= SanitizerKind::ID##Group;
112 #include "clang/Basic/Sanitizers.def"
113   return Kinds;
114 }
115 
116 static SanitizerMask parseSanitizeTrapArgs(const Driver &D,
117                                            const llvm::opt::ArgList &Args) {
118   SanitizerMask TrapRemove = 0; // During the loop below, the accumulated set of
119                                 // sanitizers disabled by the current sanitizer
120                                 // argument or any argument after it.
121   SanitizerMask TrappingKinds = 0;
122   SanitizerMask TrappingSupportedWithGroups = setGroupBits(TrappingSupported);
123 
124   for (ArgList::const_reverse_iterator I = Args.rbegin(), E = Args.rend();
125        I != E; ++I) {
126     const auto *Arg = *I;
127     if (Arg->getOption().matches(options::OPT_fsanitize_trap_EQ)) {
128       Arg->claim();
129       SanitizerMask Add = parseArgValues(D, Arg, true);
130       Add &= ~TrapRemove;
131       if (SanitizerMask InvalidValues = Add & ~TrappingSupportedWithGroups) {
132         SanitizerSet S;
133         S.Mask = InvalidValues;
134         D.Diag(diag::err_drv_unsupported_option_argument) << "-fsanitize-trap"
135                                                           << toString(S);
136       }
137       TrappingKinds |= expandSanitizerGroups(Add) & ~TrapRemove;
138     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_trap_EQ)) {
139       Arg->claim();
140       TrapRemove |= expandSanitizerGroups(parseArgValues(D, Arg, true));
141     } else if (Arg->getOption().matches(
142                    options::OPT_fsanitize_undefined_trap_on_error)) {
143       Arg->claim();
144       TrappingKinds |=
145           expandSanitizerGroups(UndefinedGroup & ~TrapRemove) & ~TrapRemove;
146     } else if (Arg->getOption().matches(
147                    options::OPT_fno_sanitize_undefined_trap_on_error)) {
148       Arg->claim();
149       TrapRemove |= expandSanitizerGroups(UndefinedGroup);
150     }
151   }
152 
153   // Apply default trapping behavior.
154   TrappingKinds |= TrappingDefault & ~TrapRemove;
155 
156   return TrappingKinds;
157 }
158 
159 bool SanitizerArgs::needsUbsanRt() const {
160   return (Sanitizers.Mask & NeedsUbsanRt & ~TrapSanitizers.Mask) &&
161          !Sanitizers.has(Address) &&
162          !Sanitizers.has(Memory) &&
163          !Sanitizers.has(Thread);
164 }
165 
166 bool SanitizerArgs::requiresPIE() const {
167   return AsanZeroBaseShadow || (Sanitizers.Mask & RequiresPIE);
168 }
169 
170 bool SanitizerArgs::needsUnwindTables() const {
171   return Sanitizers.Mask & NeedsUnwindTables;
172 }
173 
174 void SanitizerArgs::clear() {
175   Sanitizers.clear();
176   RecoverableSanitizers.clear();
177   TrapSanitizers.clear();
178   BlacklistFiles.clear();
179   CoverageFeatures = 0;
180   MsanTrackOrigins = 0;
181   MsanUseAfterDtor = false;
182   AsanFieldPadding = 0;
183   AsanZeroBaseShadow = false;
184   AsanSharedRuntime = false;
185   LinkCXXRuntimes = false;
186 }
187 
188 SanitizerArgs::SanitizerArgs(const ToolChain &TC,
189                              const llvm::opt::ArgList &Args) {
190   clear();
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       Kinds |= Add;
269     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_EQ)) {
270       Arg->claim();
271       SanitizerMask Remove = parseArgValues(D, Arg, true);
272       AllRemove |= expandSanitizerGroups(Remove);
273     }
274   }
275 
276   // We disable the vptr sanitizer if it was enabled by group expansion but RTTI
277   // is disabled.
278   if ((Kinds & Vptr) &&
279       (RTTIMode == ToolChain::RM_DisabledImplicitly ||
280        RTTIMode == ToolChain::RM_DisabledExplicitly)) {
281     Kinds &= ~Vptr;
282   }
283 
284   // Check that LTO is enabled if we need it.
285   if ((Kinds & NeedsLTO) && !D.IsUsingLTO(Args)) {
286     D.Diag(diag::err_drv_argument_only_allowed_with)
287         << lastArgumentForMask(D, Args, Kinds & NeedsLTO) << "-flto";
288   }
289 
290   // Report error if there are non-trapping sanitizers that require
291   // c++abi-specific  parts of UBSan runtime, and they are not provided by the
292   // toolchain. We don't have a good way to check the latter, so we just
293   // check if the toolchan supports vptr.
294   if (~Supported & Vptr) {
295     SanitizerMask KindsToDiagnose = Kinds & ~TrappingKinds & NeedsUbsanCxxRt;
296     // The runtime library supports the Microsoft C++ ABI, but only well enough
297     // for CFI. FIXME: Remove this once we support vptr on Windows.
298     if (TC.getTriple().isOSWindows())
299       KindsToDiagnose &= ~CFI;
300     if (KindsToDiagnose) {
301       SanitizerSet S;
302       S.Mask = KindsToDiagnose;
303       D.Diag(diag::err_drv_unsupported_opt_for_target)
304           << ("-fno-sanitize-trap=" + toString(S)) << TC.getTriple().str();
305       Kinds &= ~KindsToDiagnose;
306     }
307   }
308 
309   // Warn about incompatible groups of sanitizers.
310   std::pair<SanitizerMask, SanitizerMask> IncompatibleGroups[] = {
311       std::make_pair(Address, Thread), std::make_pair(Address, Memory),
312       std::make_pair(Thread, Memory), std::make_pair(Leak, Thread),
313       std::make_pair(Leak, Memory), std::make_pair(KernelAddress, Address),
314       std::make_pair(KernelAddress, Leak),
315       std::make_pair(KernelAddress, Thread),
316       std::make_pair(KernelAddress, Memory)};
317   for (auto G : IncompatibleGroups) {
318     SanitizerMask Group = G.first;
319     if (Kinds & Group) {
320       if (SanitizerMask Incompatible = Kinds & G.second) {
321         D.Diag(clang::diag::err_drv_argument_not_allowed_with)
322             << lastArgumentForMask(D, Args, Group)
323             << lastArgumentForMask(D, Args, Incompatible);
324         Kinds &= ~Incompatible;
325       }
326     }
327   }
328   // FIXME: Currently -fsanitize=leak is silently ignored in the presence of
329   // -fsanitize=address. Perhaps it should print an error, or perhaps
330   // -f(-no)sanitize=leak should change whether leak detection is enabled by
331   // default in ASan?
332 
333   // Parse -f(no-)?sanitize-recover flags.
334   SanitizerMask RecoverableKinds = RecoverableByDefault;
335   SanitizerMask DiagnosedUnrecoverableKinds = 0;
336   for (const auto *Arg : Args) {
337     const char *DeprecatedReplacement = nullptr;
338     if (Arg->getOption().matches(options::OPT_fsanitize_recover)) {
339       DeprecatedReplacement = "-fsanitize-recover=undefined,integer";
340       RecoverableKinds |= expandSanitizerGroups(LegacyFsanitizeRecoverMask);
341       Arg->claim();
342     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_recover)) {
343       DeprecatedReplacement = "-fno-sanitize-recover=undefined,integer";
344       RecoverableKinds &= ~expandSanitizerGroups(LegacyFsanitizeRecoverMask);
345       Arg->claim();
346     } else if (Arg->getOption().matches(options::OPT_fsanitize_recover_EQ)) {
347       SanitizerMask Add = parseArgValues(D, Arg, true);
348       // Report error if user explicitly tries to recover from unrecoverable
349       // sanitizer.
350       if (SanitizerMask KindsToDiagnose =
351               Add & Unrecoverable & ~DiagnosedUnrecoverableKinds) {
352         SanitizerSet SetToDiagnose;
353         SetToDiagnose.Mask |= KindsToDiagnose;
354         D.Diag(diag::err_drv_unsupported_option_argument)
355             << Arg->getOption().getName() << toString(SetToDiagnose);
356         DiagnosedUnrecoverableKinds |= KindsToDiagnose;
357       }
358       RecoverableKinds |= expandSanitizerGroups(Add);
359       Arg->claim();
360     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_recover_EQ)) {
361       RecoverableKinds &= ~expandSanitizerGroups(parseArgValues(D, Arg, true));
362       Arg->claim();
363     }
364     if (DeprecatedReplacement) {
365       D.Diag(diag::warn_drv_deprecated_arg) << Arg->getAsString(Args)
366                                             << DeprecatedReplacement;
367     }
368   }
369   RecoverableKinds &= Kinds;
370   RecoverableKinds &= ~Unrecoverable;
371 
372   TrappingKinds &= Kinds;
373 
374   // Setup blacklist files.
375   // Add default blacklist from resource directory.
376   {
377     std::string BLPath;
378     if (getDefaultBlacklist(D, Kinds, BLPath) && llvm::sys::fs::exists(BLPath))
379       BlacklistFiles.push_back(BLPath);
380   }
381   // Parse -f(no-)sanitize-blacklist options.
382   for (const auto *Arg : Args) {
383     if (Arg->getOption().matches(options::OPT_fsanitize_blacklist)) {
384       Arg->claim();
385       std::string BLPath = Arg->getValue();
386       if (llvm::sys::fs::exists(BLPath))
387         BlacklistFiles.push_back(BLPath);
388       else
389         D.Diag(clang::diag::err_drv_no_such_file) << BLPath;
390     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_blacklist)) {
391       Arg->claim();
392       BlacklistFiles.clear();
393     }
394   }
395   // Validate blacklists format.
396   {
397     std::string BLError;
398     std::unique_ptr<llvm::SpecialCaseList> SCL(
399         llvm::SpecialCaseList::create(BlacklistFiles, BLError));
400     if (!SCL.get())
401       D.Diag(clang::diag::err_drv_malformed_sanitizer_blacklist) << BLError;
402   }
403 
404   // Parse -f[no-]sanitize-memory-track-origins[=level] options.
405   if (AllAddedKinds & Memory) {
406     if (Arg *A =
407             Args.getLastArg(options::OPT_fsanitize_memory_track_origins_EQ,
408                             options::OPT_fsanitize_memory_track_origins,
409                             options::OPT_fno_sanitize_memory_track_origins)) {
410       if (A->getOption().matches(options::OPT_fsanitize_memory_track_origins)) {
411         MsanTrackOrigins = 2;
412       } else if (A->getOption().matches(
413                      options::OPT_fno_sanitize_memory_track_origins)) {
414         MsanTrackOrigins = 0;
415       } else {
416         StringRef S = A->getValue();
417         if (S.getAsInteger(0, MsanTrackOrigins) || MsanTrackOrigins < 0 ||
418             MsanTrackOrigins > 2) {
419           D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
420         }
421       }
422     }
423     MsanUseAfterDtor =
424       Args.hasArg(options::OPT_fsanitize_memory_use_after_dtor);
425   }
426 
427   // Parse -f(no-)?sanitize-coverage flags if coverage is supported by the
428   // enabled sanitizers.
429   if (AllAddedKinds & SupportsCoverage) {
430     for (const auto *Arg : Args) {
431       if (Arg->getOption().matches(options::OPT_fsanitize_coverage)) {
432         Arg->claim();
433         int LegacySanitizeCoverage;
434         if (Arg->getNumValues() == 1 &&
435             !StringRef(Arg->getValue(0))
436                  .getAsInteger(0, LegacySanitizeCoverage) &&
437             LegacySanitizeCoverage >= 0 && LegacySanitizeCoverage <= 4) {
438           // TODO: Add deprecation notice for this form.
439           switch (LegacySanitizeCoverage) {
440           case 0:
441             CoverageFeatures = 0;
442             break;
443           case 1:
444             CoverageFeatures = CoverageFunc;
445             break;
446           case 2:
447             CoverageFeatures = CoverageBB;
448             break;
449           case 3:
450             CoverageFeatures = CoverageEdge;
451             break;
452           case 4:
453             CoverageFeatures = CoverageEdge | CoverageIndirCall;
454             break;
455           }
456           continue;
457         }
458         CoverageFeatures |= parseCoverageFeatures(D, Arg);
459       } else if (Arg->getOption().matches(options::OPT_fno_sanitize_coverage)) {
460         Arg->claim();
461         CoverageFeatures &= ~parseCoverageFeatures(D, Arg);
462       }
463     }
464   }
465   // Choose at most one coverage type: function, bb, or edge.
466   if ((CoverageFeatures & CoverageFunc) && (CoverageFeatures & CoverageBB))
467     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
468         << "-fsanitize-coverage=func"
469         << "-fsanitize-coverage=bb";
470   if ((CoverageFeatures & CoverageFunc) && (CoverageFeatures & CoverageEdge))
471     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
472         << "-fsanitize-coverage=func"
473         << "-fsanitize-coverage=edge";
474   if ((CoverageFeatures & CoverageBB) && (CoverageFeatures & CoverageEdge))
475     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
476         << "-fsanitize-coverage=bb"
477         << "-fsanitize-coverage=edge";
478   // Basic block tracing and 8-bit counters require some type of coverage
479   // enabled.
480   int CoverageTypes = CoverageFunc | CoverageBB | CoverageEdge;
481   if ((CoverageFeatures & CoverageTraceBB) &&
482       !(CoverageFeatures & CoverageTypes))
483     D.Diag(clang::diag::err_drv_argument_only_allowed_with)
484         << "-fsanitize-coverage=trace-bb"
485         << "-fsanitize-coverage=(func|bb|edge)";
486   if ((CoverageFeatures & Coverage8bitCounters) &&
487       !(CoverageFeatures & CoverageTypes))
488     D.Diag(clang::diag::err_drv_argument_only_allowed_with)
489         << "-fsanitize-coverage=8bit-counters"
490         << "-fsanitize-coverage=(func|bb|edge)";
491 
492   if (AllAddedKinds & Address) {
493     AsanSharedRuntime =
494         Args.hasArg(options::OPT_shared_libasan) ||
495         (TC.getTriple().getEnvironment() == llvm::Triple::Android);
496     AsanZeroBaseShadow =
497         (TC.getTriple().getEnvironment() == llvm::Triple::Android);
498     if (Arg *A =
499             Args.getLastArg(options::OPT_fsanitize_address_field_padding)) {
500         StringRef S = A->getValue();
501         // Legal values are 0 and 1, 2, but in future we may add more levels.
502         if (S.getAsInteger(0, AsanFieldPadding) || AsanFieldPadding < 0 ||
503             AsanFieldPadding > 2) {
504           D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
505         }
506     }
507 
508     if (Arg *WindowsDebugRTArg =
509             Args.getLastArg(options::OPT__SLASH_MTd, options::OPT__SLASH_MT,
510                             options::OPT__SLASH_MDd, options::OPT__SLASH_MD,
511                             options::OPT__SLASH_LDd, options::OPT__SLASH_LD)) {
512       switch (WindowsDebugRTArg->getOption().getID()) {
513       case options::OPT__SLASH_MTd:
514       case options::OPT__SLASH_MDd:
515       case options::OPT__SLASH_LDd:
516         D.Diag(clang::diag::err_drv_argument_not_allowed_with)
517             << WindowsDebugRTArg->getAsString(Args)
518             << lastArgumentForMask(D, Args, Address);
519         D.Diag(clang::diag::note_drv_address_sanitizer_debug_runtime);
520       }
521     }
522   }
523 
524   // Parse -link-cxx-sanitizer flag.
525   LinkCXXRuntimes =
526       Args.hasArg(options::OPT_fsanitize_link_cxx_runtime) || D.CCCIsCXX();
527 
528   // Finally, initialize the set of available and recoverable sanitizers.
529   Sanitizers.Mask |= Kinds;
530   RecoverableSanitizers.Mask |= RecoverableKinds;
531   TrapSanitizers.Mask |= TrappingKinds;
532 }
533 
534 static std::string toString(const clang::SanitizerSet &Sanitizers) {
535   std::string Res;
536 #define SANITIZER(NAME, ID)                                                    \
537   if (Sanitizers.has(ID)) {                                                    \
538     if (!Res.empty())                                                          \
539       Res += ",";                                                              \
540     Res += NAME;                                                               \
541   }
542 #include "clang/Basic/Sanitizers.def"
543   return Res;
544 }
545 
546 void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
547                             llvm::opt::ArgStringList &CmdArgs,
548                             types::ID InputType) const {
549   if (Sanitizers.empty())
550     return;
551   CmdArgs.push_back(Args.MakeArgString("-fsanitize=" + toString(Sanitizers)));
552 
553   if (!RecoverableSanitizers.empty())
554     CmdArgs.push_back(Args.MakeArgString("-fsanitize-recover=" +
555                                          toString(RecoverableSanitizers)));
556 
557   if (!TrapSanitizers.empty())
558     CmdArgs.push_back(
559         Args.MakeArgString("-fsanitize-trap=" + toString(TrapSanitizers)));
560 
561   for (const auto &BLPath : BlacklistFiles) {
562     SmallString<64> BlacklistOpt("-fsanitize-blacklist=");
563     BlacklistOpt += BLPath;
564     CmdArgs.push_back(Args.MakeArgString(BlacklistOpt));
565   }
566 
567   if (MsanTrackOrigins)
568     CmdArgs.push_back(Args.MakeArgString("-fsanitize-memory-track-origins=" +
569                                          llvm::utostr(MsanTrackOrigins)));
570 
571   if (MsanUseAfterDtor)
572     CmdArgs.push_back(Args.MakeArgString("-fsanitize-memory-use-after-dtor"));
573 
574   if (AsanFieldPadding)
575     CmdArgs.push_back(Args.MakeArgString("-fsanitize-address-field-padding=" +
576                                          llvm::utostr(AsanFieldPadding)));
577   // Translate available CoverageFeatures to corresponding clang-cc1 flags.
578   std::pair<int, const char *> CoverageFlags[] = {
579     std::make_pair(CoverageFunc, "-fsanitize-coverage-type=1"),
580     std::make_pair(CoverageBB, "-fsanitize-coverage-type=2"),
581     std::make_pair(CoverageEdge, "-fsanitize-coverage-type=3"),
582     std::make_pair(CoverageIndirCall, "-fsanitize-coverage-indirect-calls"),
583     std::make_pair(CoverageTraceBB, "-fsanitize-coverage-trace-bb"),
584     std::make_pair(CoverageTraceCmp, "-fsanitize-coverage-trace-cmp"),
585     std::make_pair(Coverage8bitCounters, "-fsanitize-coverage-8bit-counters")};
586   for (auto F : CoverageFlags) {
587     if (CoverageFeatures & F.first)
588       CmdArgs.push_back(Args.MakeArgString(F.second));
589   }
590 
591 
592   // MSan: Workaround for PR16386.
593   // ASan: This is mainly to help LSan with cases such as
594   // https://code.google.com/p/address-sanitizer/issues/detail?id=373
595   // We can't make this conditional on -fsanitize=leak, as that flag shouldn't
596   // affect compilation.
597   if (Sanitizers.has(Memory) || Sanitizers.has(Address))
598     CmdArgs.push_back(Args.MakeArgString("-fno-assume-sane-operator-new"));
599 
600   if (TC.getTriple().isOSWindows() && needsUbsanRt()) {
601     // Instruct the code generator to embed linker directives in the object file
602     // that cause the required runtime libraries to be linked.
603     CmdArgs.push_back(Args.MakeArgString(
604         "--dependent-lib=" + tools::getCompilerRT(TC, "ubsan_standalone")));
605     if (types::isCXX(InputType))
606       CmdArgs.push_back(
607           Args.MakeArgString("--dependent-lib=" +
608                              tools::getCompilerRT(TC, "ubsan_standalone_cxx")));
609   }
610 }
611 
612 SanitizerMask parseArgValues(const Driver &D, const llvm::opt::Arg *A,
613                              bool DiagnoseErrors) {
614   assert((A->getOption().matches(options::OPT_fsanitize_EQ) ||
615           A->getOption().matches(options::OPT_fno_sanitize_EQ) ||
616           A->getOption().matches(options::OPT_fsanitize_recover_EQ) ||
617           A->getOption().matches(options::OPT_fno_sanitize_recover_EQ) ||
618           A->getOption().matches(options::OPT_fsanitize_trap_EQ) ||
619           A->getOption().matches(options::OPT_fno_sanitize_trap_EQ)) &&
620          "Invalid argument in parseArgValues!");
621   SanitizerMask Kinds = 0;
622   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
623     const char *Value = A->getValue(i);
624     SanitizerMask Kind;
625     // Special case: don't accept -fsanitize=all.
626     if (A->getOption().matches(options::OPT_fsanitize_EQ) &&
627         0 == strcmp("all", Value))
628       Kind = 0;
629     else
630       Kind = parseSanitizerValue(Value, /*AllowGroups=*/true);
631 
632     if (Kind)
633       Kinds |= Kind;
634     else if (DiagnoseErrors)
635       D.Diag(clang::diag::err_drv_unsupported_option_argument)
636           << A->getOption().getName() << Value;
637   }
638   return Kinds;
639 }
640 
641 int parseCoverageFeatures(const Driver &D, const llvm::opt::Arg *A) {
642   assert(A->getOption().matches(options::OPT_fsanitize_coverage) ||
643          A->getOption().matches(options::OPT_fno_sanitize_coverage));
644   int Features = 0;
645   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
646     const char *Value = A->getValue(i);
647     int F = llvm::StringSwitch<int>(Value)
648         .Case("func", CoverageFunc)
649         .Case("bb", CoverageBB)
650         .Case("edge", CoverageEdge)
651         .Case("indirect-calls", CoverageIndirCall)
652         .Case("trace-bb", CoverageTraceBB)
653         .Case("trace-cmp", CoverageTraceCmp)
654         .Case("8bit-counters", Coverage8bitCounters)
655         .Default(0);
656     if (F == 0)
657       D.Diag(clang::diag::err_drv_unsupported_option_argument)
658           << A->getOption().getName() << Value;
659     Features |= F;
660   }
661   return Features;
662 }
663 
664 std::string lastArgumentForMask(const Driver &D, const llvm::opt::ArgList &Args,
665                                 SanitizerMask Mask) {
666   for (llvm::opt::ArgList::const_reverse_iterator I = Args.rbegin(),
667                                                   E = Args.rend();
668        I != E; ++I) {
669     const auto *Arg = *I;
670     if (Arg->getOption().matches(options::OPT_fsanitize_EQ)) {
671       SanitizerMask AddKinds =
672           expandSanitizerGroups(parseArgValues(D, Arg, false));
673       if (AddKinds & Mask)
674         return describeSanitizeArg(Arg, Mask);
675     } else if (Arg->getOption().matches(options::OPT_fno_sanitize_EQ)) {
676       SanitizerMask RemoveKinds =
677           expandSanitizerGroups(parseArgValues(D, Arg, false));
678       Mask &= ~RemoveKinds;
679     }
680   }
681   llvm_unreachable("arg list didn't provide expected value");
682 }
683 
684 std::string describeSanitizeArg(const llvm::opt::Arg *A, SanitizerMask Mask) {
685   assert(A->getOption().matches(options::OPT_fsanitize_EQ)
686          && "Invalid argument in describeSanitizerArg!");
687 
688   std::string Sanitizers;
689   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
690     if (expandSanitizerGroups(
691             parseSanitizerValue(A->getValue(i), /*AllowGroups=*/true)) &
692         Mask) {
693       if (!Sanitizers.empty())
694         Sanitizers += ",";
695       Sanitizers += A->getValue(i);
696     }
697   }
698 
699   assert(!Sanitizers.empty() && "arg didn't provide expected value");
700   return "-fsanitize=" + Sanitizers;
701 }
702