LLVM  3.7.0
SpecialCaseList.h
Go to the documentation of this file.
1 //===-- SpecialCaseList.h - special case list for sanitizers ----*- 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 // This is a utility class used to parse user-provided text files with
10 // "special case lists" for code sanitizers. Such files are used to
11 // define "ABI list" for DataFlowSanitizer and blacklists for another sanitizers
12 // like AddressSanitizer or UndefinedBehaviorSanitizer.
13 //
14 // Empty lines and lines starting with "#" are ignored. All the rest lines
15 // should have the form:
16 // section:wildcard_expression[=category]
17 // If category is not specified, it is assumed to be empty string.
18 // Definitions of "section" and "category" are sanitizer-specific. For example,
19 // sanitizer blacklists support sections "src", "fun" and "global".
20 // Wildcard expressions define, respectively, source files, functions or
21 // globals which shouldn't be instrumented.
22 // Examples of categories:
23 // "functional": used in DFSan to list functions with pure functional
24 // semantics.
25 // "init": used in ASan blacklist to disable initialization-order bugs
26 // detection for certain globals or source files.
27 // Full special case list file example:
28 // ---
29 // # Blacklisted items:
30 // fun:*_ZN4base6subtle*
31 // global:*global_with_bad_access_or_initialization*
32 // global:*global_with_initialization_issues*=init
33 // type:*Namespace::ClassName*=init
34 // src:file_with_tricky_code.cc
35 // src:ignore-global-initializers-issues.cc=init
36 //
37 // # Functions with pure functional semantics:
38 // fun:cos=functional
39 // fun:sin=functional
40 // ---
41 // Note that the wild card is in fact an llvm::Regex, but * is automatically
42 // replaced with .*
43 // This is similar to the "ignore" feature of ThreadSanitizer.
44 // http://code.google.com/p/data-race-test/wiki/ThreadSanitizerIgnores
45 //
46 //===----------------------------------------------------------------------===//
47 
48 #ifndef LLVM_SUPPORT_SPECIALCASELIST_H
49 #define LLVM_SUPPORT_SPECIALCASELIST_H
50 
51 #include "llvm/ADT/StringMap.h"
52 #include <string>
53 #include <vector>
54 
55 namespace llvm {
56 class MemoryBuffer;
57 class Regex;
58 class StringRef;
59 
61 public:
62  /// Parses the special case list entries from files. On failure, returns
63  /// 0 and writes an error message to string.
64  static std::unique_ptr<SpecialCaseList>
65  create(const std::vector<std::string> &Paths, std::string &Error);
66  /// Parses the special case list from a memory buffer. On failure, returns
67  /// 0 and writes an error message to string.
68  static std::unique_ptr<SpecialCaseList> create(const MemoryBuffer *MB,
69  std::string &Error);
70  /// Parses the special case list entries from files. On failure, reports a
71  /// fatal error.
72  static std::unique_ptr<SpecialCaseList>
73  createOrDie(const std::vector<std::string> &Paths);
74 
76 
77  /// Returns true, if special case list contains a line
78  /// \code
79  /// @Section:<E>=@Category
80  /// \endcode
81  /// and @Query satisfies a wildcard expression <E>.
83  StringRef Category = StringRef()) const;
84 
85 private:
86  SpecialCaseList(SpecialCaseList const &) = delete;
87  SpecialCaseList &operator=(SpecialCaseList const &) = delete;
88 
89  struct Entry;
92  bool IsCompiled;
93 
95  /// Parses just-constructed SpecialCaseList entries from a memory buffer.
96  bool parse(const MemoryBuffer *MB, std::string &Error);
97  /// compile() should be called once, after parsing all the memory buffers.
98  void compile();
99 };
100 
101 } // namespace llvm
102 
103 #endif // LLVM_SUPPORT_SPECIALCASELIST_H
104 
static std::unique_ptr< SpecialCaseList > createOrDie(const std::vector< std::string > &Paths)
Parses the special case list entries from files.
Definition: regcomp.c:64
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:37
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:214
Represents a set of regular expressions.
bool inSection(StringRef Section, StringRef Query, StringRef Category=StringRef()) const
Returns true, if special case list contains a line.
static std::unique_ptr< SpecialCaseList > create(const std::vector< std::string > &Paths, std::string &Error)
Parses the special case list entries from files.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40