1 //===-- sanitizer_flags.cpp -----------------------------------------------===//
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 #include "sanitizer_flags.h"
14 
15 #include "sanitizer_common.h"
16 #include "sanitizer_flag_parser.h"
17 #include "sanitizer_libc.h"
18 #include "sanitizer_linux.h"
19 #include "sanitizer_list.h"
20 
21 namespace __sanitizer {
22 
23 CommonFlags common_flags_dont_use;
24 
25 void CommonFlags::SetDefaults() {
26 #define COMMON_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
27 #include "sanitizer_flags.inc"
28 #undef COMMON_FLAG
29 }
30 
31 void CommonFlags::CopyFrom(const CommonFlags &other) {
32   internal_memcpy(this, &other, sizeof(*this));
33 }
34 
35 // Copy the string from "s" to "out", making the following substitutions:
36 // %b = binary basename
37 // %p = pid
38 // %d = binary directory
39 void SubstituteForFlagValue(const char *s, char *out, uptr out_size) {
40   char *out_end = out + out_size;
41   while (*s && out < out_end - 1) {
42     if (s[0] != '%') {
43       *out++ = *s++;
44       continue;
45     }
46     switch (s[1]) {
47       case 'b': {
48         const char *base = GetProcessName();
49         CHECK(base);
50         while (*base && out < out_end - 1)
51           *out++ = *base++;
52         s += 2; // skip "%b"
53         break;
54       }
55       case 'p': {
56         int pid = internal_getpid();
57         char buf[32];
58         char *buf_pos = buf + 32;
59         do {
60           *--buf_pos = (pid % 10) + '0';
61           pid /= 10;
62         } while (pid);
63         while (buf_pos < buf + 32 && out < out_end - 1)
64           *out++ = *buf_pos++;
65         s += 2; // skip "%p"
66         break;
67       }
68       case 'd': {
69         uptr len = ReadBinaryDir(out, out_end - out);
70         out += len;
71         s += 2;  // skip "%d"
72         break;
73       }
74       default:
75         *out++ = *s++;
76         break;
77     }
78   }
79   CHECK(out < out_end - 1);
80   *out = '\0';
81 }
82 
83 class FlagHandlerInclude final : public FlagHandlerBase {
84   FlagParser *parser_;
85   bool ignore_missing_;
86   const char *original_path_;
87 
88  public:
89   explicit FlagHandlerInclude(FlagParser *parser, bool ignore_missing)
90       : parser_(parser), ignore_missing_(ignore_missing), original_path_("") {}
91   bool Parse(const char *value) final {
92     original_path_ = value;
93     if (internal_strchr(value, '%')) {
94       char *buf = (char *)MmapOrDie(kMaxPathLength, "FlagHandlerInclude");
95       SubstituteForFlagValue(value, buf, kMaxPathLength);
96       bool res = parser_->ParseFile(buf, ignore_missing_);
97       UnmapOrDie(buf, kMaxPathLength);
98       return res;
99     }
100     return parser_->ParseFile(value, ignore_missing_);
101   }
102   bool Format(char *buffer, uptr size) override {
103     // Note `original_path_` isn't actually what's parsed due to `%`
104     // substitutions. Printing the substituted path would require holding onto
105     // mmap'ed memory.
106     return FormatString(buffer, size, original_path_);
107   }
108 };
109 
110 void RegisterIncludeFlags(FlagParser *parser, CommonFlags *cf) {
111   FlagHandlerInclude *fh_include = new (FlagParser::Alloc)
112       FlagHandlerInclude(parser, /*ignore_missing*/ false);
113   parser->RegisterHandler("include", fh_include,
114                           "read more options from the given file");
115   FlagHandlerInclude *fh_include_if_exists = new (FlagParser::Alloc)
116       FlagHandlerInclude(parser, /*ignore_missing*/ true);
117   parser->RegisterHandler(
118       "include_if_exists", fh_include_if_exists,
119       "read more options from the given file (if it exists)");
120 }
121 
122 void RegisterCommonFlags(FlagParser *parser, CommonFlags *cf) {
123 #define COMMON_FLAG(Type, Name, DefaultValue, Description) \
124   RegisterFlag(parser, #Name, Description, &cf->Name);
125 #include "sanitizer_flags.inc"
126 #undef COMMON_FLAG
127 
128   RegisterIncludeFlags(parser, cf);
129 }
130 
131 void InitializeCommonFlags(CommonFlags *cf) {
132   // need to record coverage to generate coverage report.
133   cf->coverage |= cf->html_cov_report;
134   SetVerbosity(cf->verbosity);
135 
136   InitializePlatformCommonFlags(cf);
137 }
138 
139 }  // namespace __sanitizer
140