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