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