1 //===-- sanitizer_flag_parser.h ---------------------------------*- 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 // 9 // This file is a part of ThreadSanitizer/AddressSanitizer runtime. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef SANITIZER_FLAG_REGISTRY_H 14 #define SANITIZER_FLAG_REGISTRY_H 15 16 #include "sanitizer_internal_defs.h" 17 #include "sanitizer_libc.h" 18 #include "sanitizer_common.h" 19 20 namespace __sanitizer { 21 22 class FlagHandlerBase { 23 public: 24 virtual bool Parse(const char *value) { return false; } 25 // Write the C string representation of the current value (truncated to fit) 26 // into the buffer of size `size`. Returns false if truncation occurred and 27 // returns true otherwise. 28 virtual bool Format(char *buffer, uptr size) { 29 if (size > 0) 30 buffer[0] = '\0'; 31 return false; 32 } 33 34 protected: 35 ~FlagHandlerBase() {} 36 37 inline bool FormatString(char *buffer, uptr size, const char *str_to_use) { 38 uptr num_symbols_should_write = 39 internal_snprintf(buffer, size, "%s", str_to_use); 40 return num_symbols_should_write < size; 41 } 42 }; 43 44 template <typename T> 45 class FlagHandler final : public FlagHandlerBase { 46 T *t_; 47 48 public: 49 explicit FlagHandler(T *t) : t_(t) {} 50 bool Parse(const char *value) final; 51 bool Format(char *buffer, uptr size) final; 52 }; 53 54 inline bool ParseBool(const char *value, bool *b) { 55 if (internal_strcmp(value, "0") == 0 || 56 internal_strcmp(value, "no") == 0 || 57 internal_strcmp(value, "false") == 0) { 58 *b = false; 59 return true; 60 } 61 if (internal_strcmp(value, "1") == 0 || 62 internal_strcmp(value, "yes") == 0 || 63 internal_strcmp(value, "true") == 0) { 64 *b = true; 65 return true; 66 } 67 return false; 68 } 69 70 template <> 71 inline bool FlagHandler<bool>::Parse(const char *value) { 72 if (ParseBool(value, t_)) return true; 73 Printf("ERROR: Invalid value for bool option: '%s'\n", value); 74 return false; 75 } 76 77 template <> 78 inline bool FlagHandler<bool>::Format(char *buffer, uptr size) { 79 return FormatString(buffer, size, *t_ ? "true" : "false"); 80 } 81 82 template <> 83 inline bool FlagHandler<HandleSignalMode>::Parse(const char *value) { 84 bool b; 85 if (ParseBool(value, &b)) { 86 *t_ = b ? kHandleSignalYes : kHandleSignalNo; 87 return true; 88 } 89 if (internal_strcmp(value, "2") == 0 || 90 internal_strcmp(value, "exclusive") == 0) { 91 *t_ = kHandleSignalExclusive; 92 return true; 93 } 94 Printf("ERROR: Invalid value for signal handler option: '%s'\n", value); 95 return false; 96 } 97 98 template <> 99 inline bool FlagHandler<HandleSignalMode>::Format(char *buffer, uptr size) { 100 uptr num_symbols_should_write = internal_snprintf(buffer, size, "%d", *t_); 101 return num_symbols_should_write < size; 102 } 103 104 template <> 105 inline bool FlagHandler<const char *>::Parse(const char *value) { 106 *t_ = value; 107 return true; 108 } 109 110 template <> 111 inline bool FlagHandler<const char *>::Format(char *buffer, uptr size) { 112 return FormatString(buffer, size, *t_); 113 } 114 115 template <> 116 inline bool FlagHandler<int>::Parse(const char *value) { 117 const char *value_end; 118 *t_ = internal_simple_strtoll(value, &value_end, 10); 119 bool ok = *value_end == 0; 120 if (!ok) Printf("ERROR: Invalid value for int option: '%s'\n", value); 121 return ok; 122 } 123 124 template <> 125 inline bool FlagHandler<int>::Format(char *buffer, uptr size) { 126 uptr num_symbols_should_write = internal_snprintf(buffer, size, "%d", *t_); 127 return num_symbols_should_write < size; 128 } 129 130 template <> 131 inline bool FlagHandler<uptr>::Parse(const char *value) { 132 const char *value_end; 133 *t_ = internal_simple_strtoll(value, &value_end, 10); 134 bool ok = *value_end == 0; 135 if (!ok) Printf("ERROR: Invalid value for uptr option: '%s'\n", value); 136 return ok; 137 } 138 139 template <> 140 inline bool FlagHandler<uptr>::Format(char *buffer, uptr size) { 141 uptr num_symbols_should_write = internal_snprintf(buffer, size, "0x%zx", *t_); 142 return num_symbols_should_write < size; 143 } 144 145 template <> 146 inline bool FlagHandler<s64>::Parse(const char *value) { 147 const char *value_end; 148 *t_ = internal_simple_strtoll(value, &value_end, 10); 149 bool ok = *value_end == 0; 150 if (!ok) Printf("ERROR: Invalid value for s64 option: '%s'\n", value); 151 return ok; 152 } 153 154 template <> 155 inline bool FlagHandler<s64>::Format(char *buffer, uptr size) { 156 uptr num_symbols_should_write = internal_snprintf(buffer, size, "%lld", *t_); 157 return num_symbols_should_write < size; 158 } 159 160 class FlagParser { 161 static const int kMaxFlags = 200; 162 struct Flag { 163 const char *name; 164 const char *desc; 165 FlagHandlerBase *handler; 166 } *flags_; 167 int n_flags_; 168 169 const char *buf_; 170 uptr pos_; 171 172 public: 173 FlagParser(); 174 void RegisterHandler(const char *name, FlagHandlerBase *handler, 175 const char *desc); 176 void ParseString(const char *s, const char *env_name = 0); 177 void ParseStringFromEnv(const char *env_name); 178 bool ParseFile(const char *path, bool ignore_missing); 179 void PrintFlagDescriptions(); 180 181 static LowLevelAllocator Alloc; 182 183 private: 184 void fatal_error(const char *err); 185 bool is_space(char c); 186 void skip_whitespace(); 187 void parse_flags(const char *env_option_name); 188 void parse_flag(const char *env_option_name); 189 bool run_handler(const char *name, const char *value); 190 char *ll_strndup(const char *s, uptr n); 191 }; 192 193 template <typename T> 194 static void RegisterFlag(FlagParser *parser, const char *name, const char *desc, 195 T *var) { 196 FlagHandler<T> *fh = new (FlagParser::Alloc) FlagHandler<T>(var); 197 parser->RegisterHandler(name, fh, desc); 198 } 199 200 void ReportUnrecognizedFlags(); 201 202 } // namespace __sanitizer 203 204 #endif // SANITIZER_FLAG_REGISTRY_H 205