libsanitizer/sanitizer_common/sanitizer_flags.cpp

   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 (GetGlobalLowLevelAllocator())
 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 (GetGlobalLowLevelAllocator())
 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