LLVM  14.0.0git
SpecialCaseList.h
Go to the documentation of this file.
1 //===-- SpecialCaseList.h - special case list for sanitizers ----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //===----------------------------------------------------------------------===//
7 //
8 // This is a utility class used to parse user-provided text files with
9 // "special case lists" for code sanitizers. Such files are used to
10 // define an "ABI list" for DataFlowSanitizer and allow/exclusion lists for
11 // sanitizers like AddressSanitizer or UndefinedBehaviorSanitizer.
12 //
13 // Empty lines and lines starting with "#" are ignored. Sections are defined
14 // using a '[section_name]' header and can be used to specify sanitizers the
15 // entries below it apply to. Section names are regular expressions, and
16 // entries without a section header match all sections (e.g. an '[*]' header
17 // is assumed.)
18 // The remaining lines should have the form:
19 // prefix:wildcard_expression[=category]
20 // If category is not specified, it is assumed to be empty string.
21 // Definitions of "prefix" and "category" are sanitizer-specific. For example,
22 // sanitizer exclusion support prefixes "src", "fun" and "global".
23 // Wildcard expressions define, respectively, source files, functions or
24 // globals which shouldn't be instrumented.
25 // Examples of categories:
26 // "functional": used in DFSan to list functions with pure functional
27 // semantics.
28 // "init": used in ASan exclusion list to disable initialization-order bugs
29 // detection for certain globals or source files.
30 // Full special case list file example:
31 // ---
32 // [address]
33 // # Excluded items:
34 // fun:*_ZN4base6subtle*
35 // global:*global_with_bad_access_or_initialization*
36 // global:*global_with_initialization_issues*=init
37 // type:*Namespace::ClassName*=init
38 // src:file_with_tricky_code.cc
39 // src:ignore-global-initializers-issues.cc=init
40 //
41 // [dataflow]
42 // # Functions with pure functional semantics:
43 // fun:cos=functional
44 // fun:sin=functional
45 // ---
46 // Note that the wild card is in fact an llvm::Regex, but * is automatically
47 // replaced with .*
48 //
49 //===----------------------------------------------------------------------===//
50 
51 #ifndef LLVM_SUPPORT_SPECIALCASELIST_H
52 #define LLVM_SUPPORT_SPECIALCASELIST_H
53 
54 #include "llvm/ADT/StringMap.h"
55 #include "llvm/Support/Regex.h"
57 #include <memory>
58 #include <string>
59 #include <vector>
60 
61 namespace llvm {
62 class MemoryBuffer;
63 class StringRef;
64 
65 namespace vfs {
66 class FileSystem;
67 }
68 
70 public:
71  /// Parses the special case list entries from files. On failure, returns
72  /// 0 and writes an error message to string.
73  static std::unique_ptr<SpecialCaseList>
74  create(const std::vector<std::string> &Paths, llvm::vfs::FileSystem &FS,
75  std::string &Error);
76  /// Parses the special case list from a memory buffer. On failure, returns
77  /// 0 and writes an error message to string.
78  static std::unique_ptr<SpecialCaseList> create(const MemoryBuffer *MB,
79  std::string &Error);
80  /// Parses the special case list entries from files. On failure, reports a
81  /// fatal error.
82  static std::unique_ptr<SpecialCaseList>
83  createOrDie(const std::vector<std::string> &Paths, llvm::vfs::FileSystem &FS);
84 
86 
87  /// Returns true, if special case list contains a line
88  /// \code
89  /// @Prefix:<E>=@Category
90  /// \endcode
91  /// where @Query satisfies wildcard expression <E> in a given @Section.
93  StringRef Category = StringRef()) const;
94 
95  /// Returns the line number corresponding to the special case list entry if
96  /// the special case list contains a line
97  /// \code
98  /// @Prefix:<E>=@Category
99  /// \endcode
100  /// where @Query satisfies wildcard expression <E> in a given @Section.
101  /// Returns zero if there is no exclusion entry corresponding to this
102  /// expression.
104  StringRef Category = StringRef()) const;
105 
106 protected:
107  // Implementations of the create*() functions that can also be used by derived
108  // classes.
109  bool createInternal(const std::vector<std::string> &Paths,
110  vfs::FileSystem &VFS, std::string &Error);
111  bool createInternal(const MemoryBuffer *MB, std::string &Error);
112 
113  SpecialCaseList() = default;
114  SpecialCaseList(SpecialCaseList const &) = delete;
115  SpecialCaseList &operator=(SpecialCaseList const &) = delete;
116 
117  /// Represents a set of regular expressions. Regular expressions which are
118  /// "literal" (i.e. no regex metacharacters) are stored in Strings. The
119  /// reason for doing so is efficiency; StringMap is much faster at matching
120  /// literal strings than Regex.
121  class Matcher {
122  public:
123  bool insert(std::string Regexp, unsigned LineNumber, std::string &REError);
124  // Returns the line number in the source file that this query matches to.
125  // Returns zero if no match is found.
126  unsigned match(StringRef Query) const;
127 
128  private:
129  StringMap<unsigned> Strings;
130  TrigramIndex Trigrams;
131  std::vector<std::pair<std::unique_ptr<Regex>, unsigned>> RegExes;
132  };
133 
135 
136  struct Section {
137  Section(std::unique_ptr<Matcher> M) : SectionMatcher(std::move(M)){};
138 
139  std::unique_ptr<Matcher> SectionMatcher;
141  };
142 
143  std::vector<Section> Sections;
144 
145  /// Parses just-constructed SpecialCaseList entries from a memory buffer.
146  bool parse(const MemoryBuffer *MB, StringMap<size_t> &SectionsMap,
147  std::string &Error);
148 
149  // Helper method for derived classes to search by Prefix, Query, and Category
150  // once they have already resolved a section entry.
151  unsigned inSectionBlame(const SectionEntries &Entries, StringRef Prefix,
152  StringRef Query, StringRef Category) const;
153 };
154 
155 } // namespace llvm
156 
157 #endif // LLVM_SUPPORT_SPECIALCASELIST_H
158 
llvm::SpecialCaseList
Definition: SpecialCaseList.h:69
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::SpecialCaseList::~SpecialCaseList
~SpecialCaseList()
Definition: SpecialCaseList.cpp:202
llvm::X86AS::FS
@ FS
Definition: X86.h:188
llvm::SpecialCaseList::inSection
bool inSection(StringRef Section, StringRef Prefix, StringRef Query, StringRef Category=StringRef()) const
Returns true, if special case list contains a line.
Definition: SpecialCaseList.cpp:204
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:164
llvm::SpecialCaseList::create
static std::unique_ptr< SpecialCaseList > create(const std::vector< std::string > &Paths, llvm::vfs::FileSystem &FS, std::string &Error)
Parses the special case list entries from files.
Definition: SpecialCaseList.cpp:74
llvm::SpecialCaseList::createInternal
bool createInternal(const std::vector< std::string > &Paths, vfs::FileSystem &VFS, std::string &Error)
Definition: SpecialCaseList.cpp:99
llvm::SpecialCaseList::inSectionBlame
unsigned inSectionBlame(StringRef Section, StringRef Prefix, StringRef Query, StringRef Category=StringRef()) const
Returns the line number corresponding to the special case list entry if the special case list contain...
Definition: SpecialCaseList.cpp:209
llvm::MemoryBuffer
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:50
llvm::SpecialCaseList::Section::SectionMatcher
std::unique_ptr< Matcher > SectionMatcher
Definition: SpecialCaseList.h:137
llvm::SpecialCaseList::operator=
SpecialCaseList & operator=(SpecialCaseList const &)=delete
llvm::SpecialCaseList::parse
bool parse(const MemoryBuffer *MB, StringMap< size_t > &SectionsMap, std::string &Error)
Parses just-constructed SpecialCaseList entries from a memory buffer.
Definition: SpecialCaseList.cpp:126
llvm::SpecialCaseList::Section
Definition: SpecialCaseList.h:136
StringMap.h
llvm::StringMap< unsigned >
llvm::SpecialCaseList::Sections
std::vector< Section > Sections
Definition: SpecialCaseList.h:143
llvm::SpecialCaseList::Matcher::insert
bool insert(std::string Regexp, unsigned LineNumber, std::string &REError)
Definition: SpecialCaseList.cpp:29
llvm::SpecialCaseList::SpecialCaseList
SpecialCaseList()=default
TrigramIndex.h
llvm::SpecialCaseList::Section::Entries
SectionEntries Entries
Definition: SpecialCaseList.h:140
llvm::SpecialCaseList::createOrDie
static std::unique_ptr< SpecialCaseList > createOrDie(const std::vector< std::string > &Paths, llvm::vfs::FileSystem &FS)
Parses the special case list entries from files.
Definition: SpecialCaseList.cpp:91
Regex.h
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1658
llvm::SpecialCaseList::Matcher::match
unsigned match(StringRef Query) const
Definition: SpecialCaseList.cpp:61
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::vfs::FileSystem
The virtual file system interface.
Definition: VirtualFileSystem.h:253
std
Definition: BitVector.h:838
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::SpecialCaseList::Matcher
Represents a set of regular expressions.
Definition: SpecialCaseList.h:121
llvm::SpecialCaseList::Section::Section
Section(std::unique_ptr< Matcher > M)
Definition: SpecialCaseList.h:137
llvm::TrigramIndex
Definition: TrigramIndex.h:38