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