[sanitizer] Do not mmap FlagParser::flags_

[leonardchan]

Summary

Instead, make it a static array that's part of the FlagParser. The advantage this has is helping reduce fragmentation from needing to anonymously mmap this array via the LowLevelAllocator. This will instead place the array on the stack. Functionally, the only difference is that the array will not be zero-initialized, but all used elements are explicitly initialized via the flag handlers.

[MaskRay]

LGTM. I think consuming max * sizeof(Flag) stack space should be fine.

compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.h

 }
 
 class FlagParser {
   static const int kMaxFlags = 200;
   struct Flag {
     const char *name;
     const char *desc;
     FlagHandlerBase *handler;
-  } *flags_;
+  } flags_[kMaxFlags];
   int n_flags_;
 
   const char *buf_;
   uptr pos_;
 
  public:
   FlagParser();
   void RegisterHandler(const char *name, FlagHandlerBase *handler,

compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.cpp

void FlagParser::RegisterHandler(const char *name, FlagHandlerBase *handler,
                                  const char *desc) {
   CHECK_LT(n_flags_, kMaxFlags);
   flags_[n_flags_].name = name;
   flags_[n_flags_].desc = desc;
   flags_[n_flags_].handler = handler;
   ++n_flags_;
 }
 
-FlagParser::FlagParser() : n_flags_(0), buf_(nullptr), pos_(0) {
-  flags_ =
-      (Flag *)GetGlobalLowLevelAllocator().Allocate(sizeof(Flag) * kMaxFlags);
-}
+FlagParser::FlagParser() : n_flags_(0), buf_(nullptr), pos_(0) {}
 
 }  // namespace __sanitizer