[sanitizer] Switch flag parsing to LowLevelAlloc.

InternalAlloc is quite complex and its behavior may depend on the values of
flags. As such, it should not be used while parsing flags.

Sadly, LowLevelAlloc does not support deallocation of memory.

llvm-svn: 226453

diff --git a/compiler-rt/lib/msan/msan.cc b/compiler-rt/lib/msan/msan.cc
index c8bd603..81c6234 100644 (file)
--- a/compiler-rt/lib/msan/msan.cc
+++ b/compiler-rt/lib/msan/msan.cc
@@ -125,8 +125,8 @@ void RegisterMsanFlags(FlagParser *parser, Flags *f) {
 #include "msan_flags.inc"
 #undef MSAN_FLAG
 
-  FlagHandlerKeepGoing *fh_keep_going =
-      new (INTERNAL_ALLOC) FlagHandlerKeepGoing(&f->halt_on_error);  // NOLINT
+  FlagHandlerKeepGoing *fh_keep_going = new (FlagParser::Alloc)  // NOLINT
+      FlagHandlerKeepGoing(&f->halt_on_error);
   parser->RegisterHandler("keep_going", fh_keep_going,
                           "deprecated, use halt_on_error");
 }

diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.cc b/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.cc
index fb6ac10..64b4f53 100644 (file)
--- a/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.cc
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.cc
@@ -17,10 +17,19 @@
 #include "sanitizer_libc.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_flag_parser.h"
-#include "sanitizer_allocator_internal.h"
 
 namespace __sanitizer {
 
+LowLevelAllocator FlagParser::Alloc;
+
+char *FlagParser::ll_strndup(const char *s, uptr n) {
+  uptr len = internal_strnlen(s, n);
+  char *s2 = (char*)Alloc.Allocate(len + 1);
+  internal_memcpy(s2, s, len);
+  s2[len] = 0;
+  return s2;
+}
+
 void FlagParser::PrintFlagDescriptions() {
   Printf("Available flags for %s:\n", SanitizerToolName);
   for (int i = 0; i < n_flags_; ++i)
@@ -45,7 +54,7 @@ void FlagParser::parse_flag() {
   uptr name_start = pos_;
   while (buf_[pos_] != 0 && buf_[pos_] != '=' && !is_space(buf_[pos_])) ++pos_;
   if (buf_[pos_] != '=') fatal_error("expected '='");
-  char *name = internal_strndup(buf_ + name_start, pos_ - name_start);
+  char *name = ll_strndup(buf_ + name_start, pos_ - name_start);
 
   uptr value_start = ++pos_;
   char *value;
@@ -53,19 +62,17 @@ void FlagParser::parse_flag() {
     char quote = buf_[pos_++];
     while (buf_[pos_] != 0 && buf_[pos_] != quote) ++pos_;
     if (buf_[pos_] == 0) fatal_error("unterminated string");
-    value = internal_strndup(buf_ + value_start + 1, pos_ - value_start - 1);
+    value = ll_strndup(buf_ + value_start + 1, pos_ - value_start - 1);
     ++pos_; // consume the closing quote
   } else {
     while (buf_[pos_] != 0 && !is_space(buf_[pos_])) ++pos_;
     if (buf_[pos_] != 0 && !is_space(buf_[pos_]))
       fatal_error("expected separator or eol");
-    value = internal_strndup(buf_ + value_start, pos_ - value_start);
+    value = ll_strndup(buf_ + value_start, pos_ - value_start);
   }
 
   bool res = run_handler(name, value);
   if (!res) fatal_error("Flag parsing failed.");
-  InternalFree(name);
-  InternalFree(value);
 }
 
 void FlagParser::parse_flags() {
@@ -113,13 +120,7 @@ void FlagParser::RegisterHandler(const char *name, FlagHandlerBase *handler,
 }
 
 FlagParser::FlagParser() : n_flags_(0), buf_(nullptr), pos_(0) {
-  flags_ = (Flag *)InternalAlloc(sizeof(Flag) * kMaxFlags);
-}
-
-FlagParser::~FlagParser() {
-  for (int i = 0; i < n_flags_; ++i)
-    InternalFree(flags_[i].handler);
-  InternalFree(flags_);
+  flags_ = (Flag *)Alloc.Allocate(sizeof(Flag) * kMaxFlags);
 }
 
 }  // namespace __sanitizer

diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.h b/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.h
index 27b91e0..b391cab 100644 (file)
--- a/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.h
@@ -17,7 +17,6 @@
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_common.h"
-#include "sanitizer_allocator_internal.h"
 
 namespace __sanitizer {
 
@@ -91,12 +90,13 @@ class FlagParser {
 
  public:
   FlagParser();
-  ~FlagParser();
   void RegisterHandler(const char *name, FlagHandlerBase *handler,
                        const char *desc);
   void ParseString(const char *s);
   void PrintFlagDescriptions();
 
+  static LowLevelAllocator Alloc;
+
  private:
   void fatal_error(const char *err);
   bool is_space(char c);
@@ -104,12 +104,13 @@ class FlagParser {
   void parse_flags();
   void parse_flag();
   bool run_handler(const char *name, const char *value);
+  char *ll_strndup(const char *s, uptr n);
 };
 
 template <typename T>
 static void RegisterFlag(FlagParser *parser, const char *name, const char *desc,
                          T *var) {
-  FlagHandler<T> *fh = new (INTERNAL_ALLOC) FlagHandler<T>(var);  // NOLINT
+  FlagHandler<T> *fh = new (FlagParser::Alloc) FlagHandler<T>(var);  // NOLINT
   parser->RegisterHandler(name, fh, desc);
 }
 

diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_flags.cc b/compiler-rt/lib/sanitizer_common/sanitizer_flags.cc
index 8be50c3..aa6c417 100644 (file)
--- a/compiler-rt/lib/sanitizer_common/sanitizer_flags.cc
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_flags.cc
@@ -75,7 +75,7 @@ void RegisterCommonFlags(FlagParser *parser, CommonFlags *cf) {
 #undef COMMON_FLAG
 
   FlagHandlerInclude *fh_include =
-      new (INTERNAL_ALLOC) FlagHandlerInclude(parser);  // NOLINT
+      new (FlagParser::Alloc) FlagHandlerInclude(parser);  // NOLINT
   parser->RegisterHandler("include", fh_include,
                           "read more options from the given file");
 }