contrib/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.h

   1 //===-- sanitizer_flag_parser.h ---------------------------------*- 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 //
  10 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef SANITIZER_FLAG_REGISTRY_H
  15 #define SANITIZER_FLAG_REGISTRY_H
  16
  17 #include "sanitizer_internal_defs.h"
  18 #include "sanitizer_libc.h"
  19 #include "sanitizer_common.h"
  20
  21 namespace __sanitizer {
  22
  23 class FlagHandlerBase {
  24  public:
  25   virtual bool Parse(const char *value) { return false; }
  26 };
  27
  28 template <typename T>
  29 class FlagHandler : public FlagHandlerBase {
  30   T *t_;
  31
  32  public:
  33   explicit FlagHandler(T *t) : t_(t) {}
  34   bool Parse(const char *value) final;
  35 };
  36
  37 inline bool ParseBool(const char *value, bool *b) {
  38   if (internal_strcmp(value, "0") == 0 ||
  39       internal_strcmp(value, "no") == 0 ||
  40       internal_strcmp(value, "false") == 0) {
  41     *b = false;
  42     return true;
  43   }
  44   if (internal_strcmp(value, "1") == 0 ||
  45       internal_strcmp(value, "yes") == 0 ||
  46       internal_strcmp(value, "true") == 0) {
  47     *b = true;
  48     return true;
  49   }
  50   return false;
  51 }
  52
  53 template <>
  54 inline bool FlagHandler<bool>::Parse(const char *value) {
  55   if (ParseBool(value, t_)) return true;
  56   Printf("ERROR: Invalid value for bool option: '%s'\n", value);
  57   return false;
  58 }
  59
  60 template <>
  61 inline bool FlagHandler<HandleSignalMode>::Parse(const char *value) {
  62   bool b;
  63   if (ParseBool(value, &b)) {
  64     *t_ = b ? kHandleSignalYes : kHandleSignalNo;
  65     return true;
  66   }
  67   Printf("ERROR: Invalid value for signal handler option: '%s'\n", value);
  68   return false;
  69 }
  70
  71 template <>
  72 inline bool FlagHandler<const char *>::Parse(const char *value) {
  73   *t_ = internal_strdup(value);
  74   return true;
  75 }
  76
  77 template <>
  78 inline bool FlagHandler<int>::Parse(const char *value) {
  79   char *value_end;
  80   *t_ = internal_simple_strtoll(value, &value_end, 10);
  81   bool ok = *value_end == 0;
  82   if (!ok) Printf("ERROR: Invalid value for int option: '%s'\n", value);
  83   return ok;
  84 }
  85
  86 template <>
  87 inline bool FlagHandler<uptr>::Parse(const char *value) {
  88   char *value_end;
  89   *t_ = internal_simple_strtoll(value, &value_end, 10);
  90   bool ok = *value_end == 0;
  91   if (!ok) Printf("ERROR: Invalid value for uptr option: '%s'\n", value);
  92   return ok;
  93 }
  94
  95 class FlagParser {
  96   static const int kMaxFlags = 200;
  97   struct Flag {
  98     const char *name;
  99     const char *desc;
 100     FlagHandlerBase *handler;
 101   } *flags_;
 102   int n_flags_;
 103
 104   const char *buf_;
 105   uptr pos_;
 106
 107  public:
 108   FlagParser();
 109   void RegisterHandler(const char *name, FlagHandlerBase *handler,
 110                        const char *desc);
 111   void ParseString(const char *s);
 112   bool ParseFile(const char *path, bool ignore_missing);
 113   void PrintFlagDescriptions();
 114
 115   static LowLevelAllocator Alloc;
 116
 117  private:
 118   void fatal_error(const char *err);
 119   bool is_space(char c);
 120   void skip_whitespace();
 121   void parse_flags();
 122   void parse_flag();
 123   bool run_handler(const char *name, const char *value);
 124   char *ll_strndup(const char *s, uptr n);
 125 };
 126
 127 template <typename T>
 128 static void RegisterFlag(FlagParser *parser, const char *name, const char *desc,
 129                          T *var) {
 130   FlagHandler<T> *fh = new (FlagParser::Alloc) FlagHandler<T>(var);  // NOLINT
 131   parser->RegisterHandler(name, fh, desc);
 132 }
 133
 134 void ReportUnrecognizedFlags();
 135
 136 }  // namespace __sanitizer
 137
 138 #endif  // SANITIZER_FLAG_REGISTRY_H