include/llvm/Transforms/Utils/SpecialCaseList.h

   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 for instrumentation passes (like AddressSanitizer
  10 // or ThreadSanitizer) to avoid instrumenting some functions or global
  11 // variables based on a user-supplied list.
  12 //
  13 // The list can also specify categories for specific globals, which can be used
  14 // to instruct an instrumentation pass to treat certain functions or global
  15 // variables in a specific way, such as by omitting certain aspects of
  16 // instrumentation while keeping others, or informing the instrumentation pass
  17 // that a specific uninstrumentable function has certain semantics, thus
  18 // allowing the pass to instrument callers according to those semantics.
  19 //
  20 // For example, AddressSanitizer uses the "init" category for globals whose
  21 // initializers should not be instrumented, but which in all other respects
  22 // should be instrumented.
  23 //
  24 // Each line contains a prefix, followed by a colon and a wild card expression,
  25 // followed optionally by an equals sign and an instrumentation-specific
  26 // category.  Empty lines and lines starting with "#" are ignored.
  27 // ---
  28 // # Blacklisted items:
  29 // fun:*_ZN4base6subtle*
  30 // global:*global_with_bad_access_or_initialization*
  31 // global:*global_with_initialization_issues*=init
  32 // type:*Namespace::ClassName*=init
  33 // src:file_with_tricky_code.cc
  34 // src:ignore-global-initializers-issues.cc=init
  35 //
  36 // # Functions with pure functional semantics:
  37 // fun:cos=functional
  38 // fun:sin=functional
  39 // ---
  40 // Note that the wild card is in fact an llvm::Regex, but * is automatically
  41 // replaced with .*
  42 // This is similar to the "ignore" feature of ThreadSanitizer.
  43 // http://code.google.com/p/data-race-test/wiki/ThreadSanitizerIgnores
  44 //
  45 //===----------------------------------------------------------------------===//
  46 //
  47
  48 #include "llvm/ADT/StringMap.h"
  49
  50 namespace llvm {
  51 class Function;
  52 class GlobalVariable;
  53 class MemoryBuffer;
  54 class Module;
  55 class Regex;
  56 class StringRef;
  57
  58 class SpecialCaseList {
  59  public:
  60   // FIXME: Switch all users to factories and remove these constructors.
  61   SpecialCaseList(const StringRef Path);
  62   SpecialCaseList(const MemoryBuffer *MB);
  63
  64   /// Parses the special case list from a file. If Path is empty, returns
  65   /// an empty special case list. On failure, returns 0 and writes an error
  66   /// message to string.
  67   static SpecialCaseList *create(const StringRef Path, std::string &Error);
  68   /// Parses the special case list from a memory buffer. On failure, returns
  69   /// 0 and writes an error message to string.
  70   static SpecialCaseList *create(const MemoryBuffer *MB, std::string &Error);
  71   /// Parses the special case list from a file. On failure, reports a fatal
  72   /// error.
  73   static SpecialCaseList *createOrDie(const StringRef Path);
  74
  75   ~SpecialCaseList();
  76
  77   /// Returns whether either this function or its source file are listed in the
  78   /// given category, which may be omitted to search the empty category.
  79   bool isIn(const Function &F, const StringRef Category = StringRef()) const;
  80
  81   /// Returns whether this global, its type or its source file are listed in the
  82   /// given category, which may be omitted to search the empty category.
  83   bool isIn(const GlobalVariable &G,
  84             const StringRef Category = StringRef()) const;
  85
  86   /// Returns whether this module is listed in the given category, which may be
  87   /// omitted to search the empty category.
  88   bool isIn(const Module &M, const StringRef Category = StringRef()) const;
  89
  90   /// Returns whether either this function or its source file are listed in any
  91   /// category.  Category will contain the name of an arbitrary category in
  92   /// which this function is listed.
  93   bool findCategory(const Function &F, StringRef &Category) const;
  94
  95   /// Returns whether this global, its type or its source file are listed in any
  96   /// category.  Category will contain the name of an arbitrary category in
  97   /// which this global is listed.
  98   bool findCategory(const GlobalVariable &G, StringRef &Category) const;
  99
 100   /// Returns whether this module is listed in any category.  Category will
 101   /// contain the name of an arbitrary category in which this module is listed.
 102   bool findCategory(const Module &M, StringRef &Category) const;
 103
 104  private:
 105   SpecialCaseList(SpecialCaseList const &) LLVM_DELETED_FUNCTION;
 106   SpecialCaseList &operator=(SpecialCaseList const &) LLVM_DELETED_FUNCTION;
 107
 108   struct Entry;
 109   StringMap<StringMap<Entry> > Entries;
 110
 111   SpecialCaseList();
 112   /// Parses just-constructed SpecialCaseList entries from a memory buffer.
 113   bool parse(const MemoryBuffer *MB, std::string &Error);
 114
 115   bool findCategory(const StringRef Section, const StringRef Query,
 116                     StringRef &Category) const;
 117   bool inSectionCategory(const StringRef Section, const StringRef Query,
 118                          const StringRef Category) const;
 119 };
 120
 121 }  // namespace llvm