[Sanitizer] Plug a leak in POSIXSymbolizer::FindModuleForAddresss happening after module load/unload

[timurrrr]

lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc

355

This change is not required *right now* as POSIXSymbolizer is placement new'd on a mmap'ed memory block, but let's set the default values explicitly just in case.

372

Please note this code assumed LoadedModule is trivially default constructable, which wasn't the case strictly speaking as the implicit default constructor was not available.

411

The comment was well said :)

[samsonov]

LGTM. Thanks for fixing this!

[timurrrr]

r233257, thanks!

lib/sanitizer_common/sanitizer_common.h

uptr InternalBinarySearch(const Container &v, uptr first, uptr last,
   }
   return not_found;
 }
 
 // Represents a binary loaded into virtual memory (e.g. this can be an
 // executable or a shared object).
 class LoadedModule {
  public:
+  LoadedModule() : full_name_(nullptr), base_address_(0) {}
   LoadedModule(const char *module_name, uptr base_address);
   void clear();
   void addAddressRange(uptr beg, uptr end, bool executable);
   bool containsAddress(uptr address) const;
 
   const char *full_name() const { return full_name_; }
   uptr base_address() const { return base_address_; }
 

lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc

public:
   static InternalSymbolizer *get(LowLevelAllocator *alloc) { return 0; }
 };
 
 #endif  // SANITIZER_SUPPORTS_WEAK_HOOKS
 
 class POSIXSymbolizer : public Symbolizer {
  public:
   explicit POSIXSymbolizer(IntrusiveList<SymbolizerTool> tools)
-      : Symbolizer(tools) {}
+      : Symbolizer(tools), n_modules_(0), modules_fresh_(false) {}
 
  private:
   const char *PlatformDemangle(const char *name) override {
     return DemangleCXXABI(name);
   }
 
   void PlatformPrepareForSandboxing() override {
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
     // Cache /proc/self/exe on Linux.
     CacheBinaryName();
 #endif
   }
 
   LoadedModule *FindModuleForAddress(uptr address) {
     bool modules_were_reloaded = false;
-    if (modules_ == 0 || !modules_fresh_) {
-      modules_ = (LoadedModule*)(symbolizer_allocator_.Allocate(
-          kMaxNumberOfModuleContexts * sizeof(LoadedModule)));
-      CHECK(modules_);
+    if (!modules_fresh_) {
+      for (uptr i = 0; i < n_modules_; i++)
+        modules_[i].clear();
       n_modules_ = GetListOfModules(modules_, kMaxNumberOfModuleContexts,
                                     /* filter */ 0);
       CHECK_GT(n_modules_, 0);
       CHECK_LT(n_modules_, kMaxNumberOfModuleContexts);
       modules_fresh_ = true;
       modules_were_reloaded = true;
     }
     for (uptr i = 0; i < n_modules_; i++) {
if (module == 0)
       return false;
     *module_name = module->full_name();
     *module_offset = address - module->base_address();
     return true;
   }
 
   // 16K loaded modules should be enough for everyone.
   static const uptr kMaxNumberOfModuleContexts = 1 << 14;
-  LoadedModule *modules_;  // Array of module descriptions is leaked.
+  LoadedModule modules_[kMaxNumberOfModuleContexts];
   uptr n_modules_;
   // If stale, need to reload the modules before looking up addresses.
   bool modules_fresh_;
 };
 
 static SymbolizerTool *ChooseExternalSymbolizer(LowLevelAllocator *allocator) {
   const char *path = common_flags()->external_symbolizer_path;
   const char *binary_name = path ? StripModuleName(path) : "";