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

   1 //===--- SanitizerArgs.cpp - Arguments for sanitizer tools  ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 #include "clang/Driver/SanitizerArgs.h"
  10 #include "clang/Driver/Driver.h"
  11 #include "clang/Driver/DriverDiagnostic.h"
  12 #include "clang/Driver/Options.h"
  13 #include "clang/Driver/ToolChain.h"
  14 #include "llvm/ADT/StringExtras.h"
  15 #include "llvm/ADT/StringSwitch.h"
  16 #include "llvm/Support/FileSystem.h"
  17 #include "llvm/Support/Path.h"
  18 #include "llvm/Support/SpecialCaseList.h"
  19 #include <memory>
  20
  21 using namespace clang::driver;
  22 using namespace llvm::opt;
  23
  24 void SanitizerArgs::clear() {
  25   Kind = 0;
  26   BlacklistFile = "";
  27   MsanTrackOrigins = 0;
  28   AsanZeroBaseShadow = false;
  29   UbsanTrapOnError = false;
  30   AsanSharedRuntime = false;
  31 }
  32
  33 SanitizerArgs::SanitizerArgs() {
  34   clear();
  35 }
  36
  37 SanitizerArgs::SanitizerArgs(const ToolChain &TC,
  38                              const llvm::opt::ArgList &Args) {
  39   clear();
  40   unsigned AllAdd = 0;  // All kinds of sanitizers that were turned on
  41                         // at least once (possibly, disabled further).
  42   unsigned AllRemove = 0;  // During the loop below, the accumulated set of
  43                            // sanitizers disabled by the current sanitizer
  44                            // argument or any argument after it.
  45   unsigned DiagnosedKinds = 0;  // All Kinds we have diagnosed up to now.
  46                                 // Used to deduplicate diagnostics.
  47   const Driver &D = TC.getDriver();
  48   for (ArgList::const_reverse_iterator I = Args.rbegin(), E = Args.rend();
  49        I != E; ++I) {
  50     unsigned Add, Remove;
  51     if (!parse(D, Args, *I, Add, Remove, true))
  52       continue;
  53     (*I)->claim();
  54
  55     AllAdd |= expandGroups(Add);
  56     AllRemove |= expandGroups(Remove);
  57
  58     // Avoid diagnosing any sanitizer which is disabled later.
  59     Add &= ~AllRemove;
  60     // At this point we have not expanded groups, so any unsupported sanitizers
  61     // in Add are those which have been explicitly enabled. Diagnose them.
  62     Add = filterUnsupportedKinds(TC, Add, Args, *I, /*DiagnoseErrors=*/true,
  63                                  DiagnosedKinds);
  64     Add = expandGroups(Add);
  65     // Group expansion may have enabled a sanitizer which is disabled later.
  66     Add &= ~AllRemove;
  67     // Silently discard any unsupported sanitizers implicitly enabled through
  68     // group expansion.
  69     Add = filterUnsupportedKinds(TC, Add, Args, *I, /*DiagnoseErrors=*/false,
  70                                  DiagnosedKinds);
  71
  72     Kind |= Add;
  73   }
  74
  75   UbsanTrapOnError =
  76     Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
  77                  options::OPT_fno_sanitize_undefined_trap_on_error, false);
  78
  79   // Warn about undefined sanitizer options that require runtime support.
  80   if (UbsanTrapOnError && notAllowedWithTrap()) {
  81     D.Diag(diag::err_drv_argument_not_allowed_with)
  82       << lastArgumentForKind(D, Args, NotAllowedWithTrap)
  83       << "-fsanitize-undefined-trap-on-error";
  84   }
  85
  86   // Only one runtime library can be used at once.
  87   bool NeedsAsan = needsAsanRt();
  88   bool NeedsTsan = needsTsanRt();
  89   bool NeedsMsan = needsMsanRt();
  90   bool NeedsLsan = needsLeakDetection();
  91   if (NeedsAsan && NeedsTsan)
  92     D.Diag(diag::err_drv_argument_not_allowed_with)
  93       << lastArgumentForKind(D, Args, NeedsAsanRt)
  94       << lastArgumentForKind(D, Args, NeedsTsanRt);
  95   if (NeedsAsan && NeedsMsan)
  96     D.Diag(diag::err_drv_argument_not_allowed_with)
  97       << lastArgumentForKind(D, Args, NeedsAsanRt)
  98       << lastArgumentForKind(D, Args, NeedsMsanRt);
  99   if (NeedsTsan && NeedsMsan)
 100     D.Diag(diag::err_drv_argument_not_allowed_with)
 101       << lastArgumentForKind(D, Args, NeedsTsanRt)
 102       << lastArgumentForKind(D, Args, NeedsMsanRt);
 103   if (NeedsLsan && NeedsTsan)
 104     D.Diag(diag::err_drv_argument_not_allowed_with)
 105       << lastArgumentForKind(D, Args, NeedsLeakDetection)
 106       << lastArgumentForKind(D, Args, NeedsTsanRt);
 107   if (NeedsLsan && NeedsMsan)
 108     D.Diag(diag::err_drv_argument_not_allowed_with)
 109       << lastArgumentForKind(D, Args, NeedsLeakDetection)
 110       << lastArgumentForKind(D, Args, NeedsMsanRt);
 111   // FIXME: Currently -fsanitize=leak is silently ignored in the presence of
 112   // -fsanitize=address. Perhaps it should print an error, or perhaps
 113   // -f(-no)sanitize=leak should change whether leak detection is enabled by
 114   // default in ASan?
 115
 116   // Parse -f(no-)sanitize-blacklist options.
 117   if (Arg *BLArg = Args.getLastArg(options::OPT_fsanitize_blacklist,
 118                                    options::OPT_fno_sanitize_blacklist)) {
 119     if (BLArg->getOption().matches(options::OPT_fsanitize_blacklist)) {
 120       std::string BLPath = BLArg->getValue();
 121       if (llvm::sys::fs::exists(BLPath)) {
 122         // Validate the blacklist format.
 123         std::string BLError;
 124         std::unique_ptr<llvm::SpecialCaseList> SCL(
 125             llvm::SpecialCaseList::create(BLPath, BLError));
 126         if (!SCL.get())
 127           D.Diag(diag::err_drv_malformed_sanitizer_blacklist) << BLError;
 128         else
 129           BlacklistFile = BLPath;
 130       } else {
 131         D.Diag(diag::err_drv_no_such_file) << BLPath;
 132       }
 133     }
 134   } else {
 135     // If no -fsanitize-blacklist option is specified, try to look up for
 136     // blacklist in the resource directory.
 137     std::string BLPath;
 138     if (getDefaultBlacklistForKind(D, Kind, BLPath) &&
 139         llvm::sys::fs::exists(BLPath))
 140       BlacklistFile = BLPath;
 141   }
 142
 143   // Parse -f[no-]sanitize-memory-track-origins[=level] options.
 144   if (NeedsMsan) {
 145     if (Arg *A =
 146             Args.getLastArg(options::OPT_fsanitize_memory_track_origins_EQ,
 147                             options::OPT_fsanitize_memory_track_origins,
 148                             options::OPT_fno_sanitize_memory_track_origins)) {
 149       if (A->getOption().matches(options::OPT_fsanitize_memory_track_origins)) {
 150         MsanTrackOrigins = 1;
 151       } else if (A->getOption().matches(
 152                      options::OPT_fno_sanitize_memory_track_origins)) {
 153         MsanTrackOrigins = 0;
 154       } else {
 155         StringRef S = A->getValue();
 156         if (S.getAsInteger(0, MsanTrackOrigins) || MsanTrackOrigins < 0 ||
 157             MsanTrackOrigins > 2) {
 158           D.Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
 159         }
 160       }
 161     }
 162   }
 163
 164   if (NeedsAsan) {
 165     AsanSharedRuntime =
 166         Args.hasArg(options::OPT_shared_libasan) ||
 167         (TC.getTriple().getEnvironment() == llvm::Triple::Android);
 168     AsanZeroBaseShadow =
 169         (TC.getTriple().getEnvironment() == llvm::Triple::Android);
 170   }
 171 }
 172
 173 void SanitizerArgs::addArgs(const llvm::opt::ArgList &Args,
 174                             llvm::opt::ArgStringList &CmdArgs) const {
 175   if (!Kind)
 176     return;
 177   SmallString<256> SanitizeOpt("-fsanitize=");
 178 #define SANITIZER(NAME, ID) \
 179   if (Kind & ID) \
 180     SanitizeOpt += NAME ",";
 181 #include "clang/Basic/Sanitizers.def"
 182   SanitizeOpt.pop_back();
 183   CmdArgs.push_back(Args.MakeArgString(SanitizeOpt));
 184   if (!BlacklistFile.empty()) {
 185     SmallString<64> BlacklistOpt("-fsanitize-blacklist=");
 186     BlacklistOpt += BlacklistFile;
 187     CmdArgs.push_back(Args.MakeArgString(BlacklistOpt));
 188   }
 189
 190   if (MsanTrackOrigins)
 191     CmdArgs.push_back(Args.MakeArgString("-fsanitize-memory-track-origins=" +
 192                                          llvm::utostr(MsanTrackOrigins)));
 193
 194   // Workaround for PR16386.
 195   if (needsMsanRt())
 196     CmdArgs.push_back(Args.MakeArgString("-fno-assume-sane-operator-new"));
 197 }
 198
 199 unsigned SanitizerArgs::parse(const char *Value) {
 200   unsigned ParsedKind = llvm::StringSwitch<SanitizeKind>(Value)
 201 #define SANITIZER(NAME, ID) .Case(NAME, ID)
 202 #define SANITIZER_GROUP(NAME, ID, ALIAS) .Case(NAME, ID##Group)
 203 #include "clang/Basic/Sanitizers.def"
 204     .Default(SanitizeKind());
 205   return ParsedKind;
 206 }
 207
 208 unsigned SanitizerArgs::expandGroups(unsigned Kinds) {
 209 #define SANITIZER(NAME, ID)
 210 #define SANITIZER_GROUP(NAME, ID, ALIAS) if (Kinds & ID##Group) Kinds |= ID;
 211 #include "clang/Basic/Sanitizers.def"
 212   return Kinds;
 213 }
 214
 215 void SanitizerArgs::filterUnsupportedMask(const ToolChain &TC, unsigned &Kinds,
 216                                           unsigned Mask,
 217                                           const llvm::opt::ArgList &Args,
 218                                           const llvm::opt::Arg *A,
 219                                           bool DiagnoseErrors,
 220                                           unsigned &DiagnosedKinds) {
 221   unsigned MaskedKinds = Kinds & Mask;
 222   if (!MaskedKinds)
 223     return;
 224   Kinds &= ~Mask;
 225   // Do we have new kinds to diagnose?
 226   if (DiagnoseErrors && (DiagnosedKinds & MaskedKinds) != MaskedKinds) {
 227     // Only diagnose the new kinds.
 228     std::string Desc =
 229         describeSanitizeArg(Args, A, MaskedKinds & ~DiagnosedKinds);
 230     TC.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
 231         << Desc << TC.getTriple().str();
 232     DiagnosedKinds |= MaskedKinds;
 233   }
 234 }
 235
 236 unsigned SanitizerArgs::filterUnsupportedKinds(const ToolChain &TC,
 237                                                unsigned Kinds,
 238                                                const llvm::opt::ArgList &Args,
 239                                                const llvm::opt::Arg *A,
 240                                                bool DiagnoseErrors,
 241                                                unsigned &DiagnosedKinds) {
 242   bool IsLinux = TC.getTriple().getOS() == llvm::Triple::Linux;
 243   bool IsX86 = TC.getTriple().getArch() == llvm::Triple::x86;
 244   bool IsX86_64 = TC.getTriple().getArch() == llvm::Triple::x86_64;
 245   if (!(IsLinux && IsX86_64)) {
 246     filterUnsupportedMask(TC, Kinds, Thread | Memory | DataFlow, Args, A,
 247                           DiagnoseErrors, DiagnosedKinds);
 248   }
 249   if (!(IsLinux && (IsX86 || IsX86_64))) {
 250     filterUnsupportedMask(TC, Kinds, Function, Args, A, DiagnoseErrors,
 251                           DiagnosedKinds);
 252   }
 253   return Kinds;
 254 }
 255
 256 unsigned SanitizerArgs::parse(const Driver &D, const llvm::opt::Arg *A,
 257                               bool DiagnoseErrors) {
 258   unsigned Kind = 0;
 259   for (unsigned I = 0, N = A->getNumValues(); I != N; ++I) {
 260     if (unsigned K = parse(A->getValue(I)))
 261       Kind |= K;
 262     else if (DiagnoseErrors)
 263       D.Diag(diag::err_drv_unsupported_option_argument)
 264         << A->getOption().getName() << A->getValue(I);
 265   }
 266   return Kind;
 267 }
 268
 269 bool SanitizerArgs::parse(const Driver &D, const llvm::opt::ArgList &Args,
 270                           const llvm::opt::Arg *A, unsigned &Add,
 271                           unsigned &Remove, bool DiagnoseErrors) {
 272   Add = 0;
 273   Remove = 0;
 274   if (A->getOption().matches(options::OPT_fsanitize_EQ)) {
 275     Add = parse(D, A, DiagnoseErrors);
 276   } else if (A->getOption().matches(options::OPT_fno_sanitize_EQ)) {
 277     Remove = parse(D, A, DiagnoseErrors);
 278   } else {
 279     // Flag is not relevant to sanitizers.
 280     return false;
 281   }
 282   return true;
 283 }
 284
 285 std::string SanitizerArgs::lastArgumentForKind(const Driver &D,
 286                                                const llvm::opt::ArgList &Args,
 287                                                unsigned Kind) {
 288   for (llvm::opt::ArgList::const_reverse_iterator I = Args.rbegin(),
 289                                                   E = Args.rend();
 290        I != E; ++I) {
 291     unsigned Add, Remove;
 292     if (parse(D, Args, *I, Add, Remove, false) &&
 293         (expandGroups(Add) & Kind))
 294       return describeSanitizeArg(Args, *I, Kind);
 295     Kind &= ~Remove;
 296   }
 297   llvm_unreachable("arg list didn't provide expected value");
 298 }
 299
 300 std::string SanitizerArgs::describeSanitizeArg(const llvm::opt::ArgList &Args,
 301                                                const llvm::opt::Arg *A,
 302                                                unsigned Mask) {
 303   if (!A->getOption().matches(options::OPT_fsanitize_EQ))
 304     return A->getAsString(Args);
 305
 306   std::string Sanitizers;
 307   for (unsigned I = 0, N = A->getNumValues(); I != N; ++I) {
 308     if (expandGroups(parse(A->getValue(I))) & Mask) {
 309       if (!Sanitizers.empty())
 310         Sanitizers += ",";
 311       Sanitizers += A->getValue(I);
 312     }
 313   }
 314
 315   assert(!Sanitizers.empty() && "arg didn't provide expected value");
 316   return "-fsanitize=" + Sanitizers;
 317 }
 318
 319 bool SanitizerArgs::getDefaultBlacklistForKind(const Driver &D, unsigned Kind,
 320                                                std::string &BLPath) {
 321   const char *BlacklistFile = nullptr;
 322   if (Kind & NeedsAsanRt)
 323     BlacklistFile = "asan_blacklist.txt";
 324   else if (Kind & NeedsMsanRt)
 325     BlacklistFile = "msan_blacklist.txt";
 326   else if (Kind & NeedsTsanRt)
 327     BlacklistFile = "tsan_blacklist.txt";
 328   else if (Kind & NeedsDfsanRt)
 329     BlacklistFile = "dfsan_abilist.txt";
 330
 331   if (BlacklistFile) {
 332     SmallString<64> Path(D.ResourceDir);
 333     llvm::sys::path::append(Path, BlacklistFile);
 334     BLPath = Path.str();
 335     return true;
 336   }
 337   return false;
 338 }