[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.


git-svn-id: https://llvm.org/svn/llvm-project/compiler-rt/trunk@226453 91177308-0d34-0410-b5e6-96231b3b80d8

4 files changed, 21 insertions, 19 deletions

diff --git a/lib/msan/msan.cc b/lib/msan/msan.cc
index c8bd6039c..81c623498 100644
--- a/lib/msan/msan.cc
+++ b/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/lib/sanitizer_common/sanitizer_flag_parser.cc b/lib/sanitizer_common/sanitizer_flag_parser.cc
index fb6ac1066..64b4f5392 100644
--- a/lib/sanitizer_common/sanitizer_flag_parser.cc
+++ b/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/lib/sanitizer_common/sanitizer_flag_parser.h b/lib/sanitizer_common/sanitizer_flag_parser.h
index 27b91e0e7..b391cab41 100644
--- a/lib/sanitizer_common/sanitizer_flag_parser.h
+++ b/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/lib/sanitizer_common/sanitizer_flags.cc b/lib/sanitizer_common/sanitizer_flags.cc
index 8be50c39a..aa6c41705 100644
--- a/lib/sanitizer_common/sanitizer_flags.cc
+++ b/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");
 }