1 //===--- SanitizerArgs.h - Arguments for sanitizer tools -------*- C++ -*-===// 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 #ifndef CLANG_LIB_DRIVER_SANITIZERARGS_H_ 10 #define CLANG_LIB_DRIVER_SANITIZERARGS_H_ 11 12 #include <string> 13 14 #include "llvm/Option/Arg.h" 15 #include "llvm/Option/ArgList.h" 16 17 namespace clang { 18 namespace driver { 19 20 class Driver; 21 class ToolChain; 22 23 class SanitizerArgs { 24 /// Assign ordinals to sanitizer flags. We'll use the ordinal values as 25 /// bit positions within \c Kind. 26 enum SanitizeOrdinal { 27 #define SANITIZER(NAME, ID) SO_##ID, 28 #define SANITIZER_GROUP(NAME, ID, ALIAS) SO_##ID##Group, 29 #include "clang/Basic/Sanitizers.def" 30 SO_Count 31 }; 32 33 /// Bugs to catch at runtime. 34 enum SanitizeKind { 35 #define SANITIZER(NAME, ID) ID = 1 << SO_##ID, 36 #define SANITIZER_GROUP(NAME, ID, ALIAS) \ 37 ID = ALIAS, ID##Group = 1 << SO_##ID##Group, 38 #include "clang/Basic/Sanitizers.def" 39 NeedsAsanRt = Address, 40 NeedsTsanRt = Thread, 41 NeedsMsanRt = Memory, 42 NeedsDfsanRt = DataFlow, 43 NeedsLeakDetection = Leak, 44 NeedsUbsanRt = Undefined | Integer, 45 NotAllowedWithTrap = Vptr, 46 HasZeroBaseShadow = Thread | Memory | DataFlow 47 }; 48 unsigned Kind; 49 50 std::string BlacklistFile; 51 bool MsanTrackOrigins; 52 bool AsanZeroBaseShadow; 53 bool UbsanTrapOnError; 54 55 public: 56 SanitizerArgs(); 57 /// Parses the sanitizer arguments from an argument list. 58 SanitizerArgs(const ToolChain &TC, const llvm::opt::ArgList &Args); 59 needsAsanRt()60 bool needsAsanRt() const { return Kind & NeedsAsanRt; } needsTsanRt()61 bool needsTsanRt() const { return Kind & NeedsTsanRt; } needsMsanRt()62 bool needsMsanRt() const { return Kind & NeedsMsanRt; } needsLeakDetection()63 bool needsLeakDetection() const { return Kind & NeedsLeakDetection; } needsLsanRt()64 bool needsLsanRt() const { 65 return needsLeakDetection() && !needsAsanRt(); 66 } needsUbsanRt()67 bool needsUbsanRt() const { 68 return !UbsanTrapOnError && (Kind & NeedsUbsanRt); 69 } needsDfsanRt()70 bool needsDfsanRt() const { return Kind & NeedsDfsanRt; } 71 sanitizesVptr()72 bool sanitizesVptr() const { return Kind & Vptr; } notAllowedWithTrap()73 bool notAllowedWithTrap() const { return Kind & NotAllowedWithTrap; } hasZeroBaseShadow()74 bool hasZeroBaseShadow() const { 75 return (Kind & HasZeroBaseShadow) || AsanZeroBaseShadow; 76 } 77 void addArgs(const llvm::opt::ArgList &Args, 78 llvm::opt::ArgStringList &CmdArgs) const; 79 80 private: 81 void clear(); 82 83 /// Parse a single value from a -fsanitize= or -fno-sanitize= value list. 84 /// Returns OR of members of the \c SanitizeKind enumeration, or \c 0 85 /// if \p Value is not known. 86 static unsigned parse(const char *Value); 87 88 /// Parse a -fsanitize= or -fno-sanitize= argument's values, diagnosing any 89 /// invalid components. 90 static unsigned parse(const Driver &D, const llvm::opt::Arg *A, 91 bool DiagnoseErrors); 92 93 /// Parse a single flag of the form -f[no]sanitize=, or 94 /// -f*-sanitizer. Sets the masks defining required change of Kind value. 95 /// Returns true if the flag was parsed successfully. 96 static bool parse(const Driver &D, const llvm::opt::ArgList &Args, 97 const llvm::opt::Arg *A, unsigned &Add, unsigned &Remove, 98 bool DiagnoseErrors); 99 100 /// Produce an argument string from ArgList \p Args, which shows how it 101 /// provides a sanitizer kind in \p Mask. For example, the argument list 102 /// "-fsanitize=thread,vptr -faddress-sanitizer" with mask \c NeedsUbsanRt 103 /// would produce "-fsanitize=vptr". 104 static std::string lastArgumentForKind(const Driver &D, 105 const llvm::opt::ArgList &Args, 106 unsigned Kind); 107 108 /// Produce an argument string from argument \p A, which shows how it provides 109 /// a value in \p Mask. For instance, the argument 110 /// "-fsanitize=address,alignment" with mask \c NeedsUbsanRt would produce 111 /// "-fsanitize=alignment". 112 static std::string describeSanitizeArg(const llvm::opt::ArgList &Args, 113 const llvm::opt::Arg *A, 114 unsigned Mask); 115 116 static bool getDefaultBlacklistForKind(const Driver &D, unsigned Kind, 117 std::string &BLPath); 118 119 /// Return the smallest superset of sanitizer set \p Kinds such that each 120 /// member of each group whose flag is set in \p Kinds has its flag set in the 121 /// result. 122 static unsigned expandGroups(unsigned Kinds); 123 124 /// Return the subset of \p Kinds supported by toolchain \p TC. If 125 /// \p DiagnoseErrors is true, produce an error diagnostic for each sanitizer 126 /// removed from \p Kinds. 127 static unsigned filterUnsupportedKinds(const ToolChain &TC, unsigned Kinds, 128 const llvm::opt::ArgList &Args, 129 const llvm::opt::Arg *A, 130 bool DiagnoseErrors, 131 unsigned &DiagnosedKinds); 132 133 /// The flags in \p Mask are unsupported by \p TC. If present in \p Kinds, 134 /// remove them and produce an error diagnostic referring to \p A if 135 /// \p DiagnoseErrors is true. 136 static void filterUnsupportedMask(const ToolChain &TC, unsigned &Kinds, 137 unsigned Mask, 138 const llvm::opt::ArgList &Args, 139 const llvm::opt::Arg *A, 140 bool DiagnoseErrors, 141 unsigned &DiagnosedKinds); 142 }; 143 144 } // namespace driver 145 } // namespace clang 146 147 #endif // CLANG_LIB_DRIVER_SANITIZERARGS_H_ 148