[sanitizer] Add a variant of "include" flag that does not abort on missing file and support process name substitution.

[eugenis]

Summary

include_if_exists=/path/to/asan/options reads flags from the file if it is present.
"%b" in the include file path (for both variants of the flag) is replaced with the basename of the main executable.

[samsonov]

LGTM

lib/sanitizer_common/sanitizer_flags.cc

68

I would be prefer smth. more verbose like "optional_include", but this is optional.

[samsonov]

lib/sanitizer_common/sanitizer_flags.cc

48

Add a comment that out should be at least kMaxPathLength. Also, you don't seem to actually trim s to this. constant if necessary. Consider using InternalScopedString *out and out->append() instead.

55

if base was trimmed, you would advance pointer t too far, and may make an out-of-bound write on the next iteration.

[eugenis]

Renamed the option to a more obvious name.
Do you think we should change "%b" to something else? "b" stands for basename (as in man 1 basename). Maybe %n?

[samsonov]

I have no strong preference. %b looks okay.

[eugenis]

fixed oob issues

[samsonov]

LGTM

[eugenis]

Thanks. Committed as r242853.

lib/asan/asan_activation.cc

 #define ASAN_ACTIVATION_FLAG(Type, Name) \
   RegisterFlag(parser, #Name, "", &f->Name);
 #define COMMON_ACTIVATION_FLAG(Type, Name) \
   RegisterFlag(parser, #Name, "", &cf->Name);
 #include "asan_activation_flags.inc"
 #undef ASAN_ACTIVATION_FLAG
 #undef COMMON_ACTIVATION_FLAG
 
-    RegisterIncludeFlag(parser, cf);
+    RegisterIncludeFlags(parser, cf);
   }
 
   void OverrideFromActivationFlags() {
     Flags f;
     CommonFlags cf;
     FlagParser parser;
     RegisterActivationFlags(&parser, &f, &cf);
 

lib/sanitizer_common/sanitizer_flag_parser.h

class FlagParser {
   const char *buf_;
   uptr pos_;
 
  public:
   FlagParser();
   void RegisterHandler(const char *name, FlagHandlerBase *handler,
                        const char *desc);
   void ParseString(const char *s);
+  bool ParseFile(const char *path, bool ignore_missing);
   void PrintFlagDescriptions();
 
   static LowLevelAllocator Alloc;
 
  private:
   void fatal_error(const char *err);
   bool is_space(char c);
   void skip_whitespace();

lib/sanitizer_common/sanitizer_flag_parser.cc

void FlagParser::ParseString(const char *s) {
   pos_ = 0;
 
   parse_flags();
 
   buf_ = old_buf_;
   pos_ = old_pos_;
 }
 
+bool FlagParser::ParseFile(const char *path, bool ignore_missing) {
+  static const uptr kMaxIncludeSize = 1 << 15;
+  char *data;
+  uptr data_mapped_size;
+  error_t err;
+  uptr len = ReadFileToBuffer(path, &data, &data_mapped_size,
+                              Max(kMaxIncludeSize, GetPageSizeCached()), &err);
+  if (!len) {
+    if (ignore_missing)
+      return true;
+    Printf("Failed to read options from '%s': error %d\n", path, err);
+    return false;
+  }
+  ParseString(data);
+  UnmapOrDie(data, data_mapped_size);
+  return true;
+}
+
 bool FlagParser::run_handler(const char *name, const char *value) {
   for (int i = 0; i < n_flags_; ++i) {
     if (internal_strcmp(name, flags_[i].name) == 0)
       return flags_[i].handler->Parse(value);
   }
   // Unrecognized flag. This is not a fatal error, we may print a warning later.
   unknown_flags.Add(name);
   return true;

lib/sanitizer_common/sanitizer_flags.h

 // the first time).
 inline void OverrideCommonFlags(const CommonFlags &cf) {
   common_flags_dont_use.CopyFrom(cf);
 }
 
 class FlagParser;
 void RegisterCommonFlags(FlagParser *parser,
                          CommonFlags *cf = &common_flags_dont_use);
-void RegisterIncludeFlag(FlagParser *parser, CommonFlags *cf);
+void RegisterIncludeFlags(FlagParser *parser, CommonFlags *cf);
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FLAGS_H

lib/sanitizer_common/sanitizer_flags.cc

 #include "sanitizer_flags.inc"
 #undef COMMON_FLAG
 }
 
 void CommonFlags::CopyFrom(const CommonFlags &other) {
   internal_memcpy(this, &other, sizeof(*this));
 }
 
 class FlagHandlerInclude : public FlagHandlerBase {
-  static const uptr kMaxIncludeSize = 1 << 15;
   FlagParser *parser_;
+  bool ignore_missing_;
 
  public:
-  explicit FlagHandlerInclude(FlagParser *parser) : parser_(parser) {}
+  explicit FlagHandlerInclude(FlagParser *parser, bool ignore_missing)
+      : parser_(parser), ignore_missing_(ignore_missing) {}
   bool Parse(const char *value) final {
-    char *data;
-    uptr data_mapped_size;
-    error_t err;
-    uptr len =
-      ReadFileToBuffer(value, &data, &data_mapped_size,
-                       Max(kMaxIncludeSize, GetPageSizeCached()), &err);
-    if (!len) {
-      Printf("Failed to read options from '%s': error %d\n", value, err);
-      return false;
-    }
-    parser_->ParseString(data);
-    UnmapOrDie(data, data_mapped_size);
-    return true;
+    return parser_->ParseFile(value, ignore_missing_);
   }
 };
 
-void RegisterIncludeFlag(FlagParser *parser, CommonFlags *cf) {
+void RegisterIncludeFlags(FlagParser *parser, CommonFlags *cf) {
   FlagHandlerInclude *fh_include =
-      new (FlagParser::Alloc) FlagHandlerInclude(parser);  // NOLINT
+      new (FlagParser::Alloc) FlagHandlerInclude(parser, false); // NOLINT
   parser->RegisterHandler("include", fh_include,
                           "read more options from the given file");
+  FlagHandlerInclude *fh_include_ignore_missing =
+      new (FlagParser::Alloc) FlagHandlerInclude(parser, true); // NOLINT
+  parser->RegisterHandler(
+      "include?", fh_include_ignore_missing,
+      "read more options from the given file (if it exists)");
 }
 
 void RegisterCommonFlags(FlagParser *parser, CommonFlags *cf) {
 #define COMMON_FLAG(Type, Name, DefaultValue, Description) \
   RegisterFlag(parser, #Name, Description, &cf->Name);
 #include "sanitizer_flags.inc"
 #undef COMMON_FLAG
 
-  RegisterIncludeFlag(parser, cf);
+  RegisterIncludeFlags(parser, cf);
 }
 
 }  // namespace __sanitizer

test/sanitizer_common/TestCases/options-include.cc

 // RUN: %clangxx -O0 %s -o %t
 // RUN: echo -e "symbolize=1\ninclude='%t.options2.txt'" >%t.options1.txt
 // RUN: echo -e "help=1\n" >%t.options2.txt
 // RUN: cat %t.options1.txt
 // RUN: cat %t.options2.txt
 // RUN: %tool_options="help=0:include='%t.options1.txt'" %run %t 2>&1 | tee %t.out
-// RUN: FileCheck %s --check-prefix=CHECK-VERBOSITY1 <%t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITH-HELP --check-prefix=CHECK-FOUND <%t.out
 // RUN: %tool_options="include='%t.options1.txt',help=0" %run %t 2>&1 | tee %t.out
-// RUN: FileCheck %s --check-prefix=CHECK-VERBOSITY0 <%t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITHOUT-HELP --check-prefix=CHECK-FOUND <%t.out
 // RUN: %tool_options="include='%t.options-not-found.txt',help=1" not %run %t 2>&1 | tee %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-NOT-FOUND < %t.out
+// RUN: %tool_options="include?='%t.options-not-found.txt',help=1" %run %t 2>&1 | tee %t.out
+// RUN: FileCheck %s --check-prefix=CHECK-WITH-HELP --check-prefix=CHECK-FOUND < %t.out
 
 #include <stdio.h>
 
 int main() {
   fprintf(stderr, "done\n");
 }
 
-// CHECK-VERBOSITY1: Available flags for
-// CHECK-VERBOSITY0-NOT: Available flags for
+// CHECK-WITH-HELP: Available flags for
+// CHECK-WITHOUT-HELP-NOT: Available flags for
+// CHECK-FOUND-NOT: Failed to read options from
 // CHECK-NOT-FOUND: Failed to read options from