[Sanitizer] Use ProcessMaps in symbolizer to get module name and offset.

sanitizer_common/sanitizer_symbolizer.cc

 //===-- sanitizer_symbolizer.cc -------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This is a stub for LLVM-based symbolizer.
@@ skipping 35 matching lines @@
     if (name == 0) {
       name = full_name;
     } else {
       name++;
     }
   }
 };
 
 class Symbolizer {
  public:
-  Symbolizer() {
-    modules_ = 0;
+  void GetModuleDescriptions() {
     ProcessMaps proc_maps;
     uptr start, end, offset;
     char *module_name = (char*)InternalAlloc(kMaxModuleNameLength);
     ModuleDesc *prev_module = 0;
     while (proc_maps.Next(&start, &end, &offset, module_name,
                           kMaxModuleNameLength)) {
       void *mem = InternalAlloc(sizeof(ModuleDesc));
       ModuleDesc *cur_module = new(mem) ModuleDesc(start, end, offset,
                                                    module_name);
       if (!prev_module) {
         modules_ = cur_module;
       } else {
         prev_module->next = cur_module;
       }
       prev_module = cur_module;
     }
     InternalFree(module_name);
   }
 
-  bool FillAddressInfo(uptr addr, AddressInfo *info) {
+  uptr SymbolizeCode(uptr addr, AddressInfo *frames, uptr max_frames) {
+    if (max_frames == 0)
+      return 0;
+    AddressInfo *info = &frames[0];
     info->Clear();
     info->address = addr;
+    if (modules_ == 0) {
+      GetModuleDescriptions();
+    }
     bool first = true;
     for (ModuleDesc *module = modules_; module; module = module->next) {
       if (addr >= module->start && addr < module->end) {
         info->module = internal_strdup(module->full_name);
-        // Don't subtract 'start' for the first entry. Don't ask me why.
+        // Don't subtract 'start' for the first entry:
+        // * If a binary is compiled w/o -pie, then the first entry in
+        //   process maps is likely the binary itself (all dynamic libs
+        //   are mapped higher in address space). For such a binary,
+        //   instruction offset in binary coincides with the actual
+        //   instruction address in virtual memory (as code section
+        //   is mapped to a fixed memory range).
+        // * If a binary is compiled with -pie, all the modules are
+        //   mapped high at address space (in particular, higher than
+        //   shadow memory of the tool), so the module can't be the
+        //   first entry.
         info->module_offset = (addr - (first ? 0 : module->start)) +
                               module->offset;
         // FIXME: Fill other fields here as well: create debug
         // context for a given module and fetch file/line info from it.
         info->function = 0;
         info->file = 0;
         info->line = 0;
         info->column = 0;
-        return true;
+        return 1;
       }
       first = false;
     }
-    return false;
+    return 0;
   }
 
  private:
   ModuleDesc *modules_;  // List of module descriptions is leaked.
 };
 
-static Symbolizer *symbolizer;
-
-static Symbolizer *GetSymbolizer() {
-  if (!symbolizer) {
-    void *mem = InternalAlloc(sizeof(Symbolizer));
-    symbolizer = new(mem) Symbolizer();
-  }
-  return symbolizer;
-}
+static Symbolizer symbolizer;
 
 uptr SymbolizeCode(uptr address, AddressInfo *frames, uptr max_frames) {
-  if (max_frames == 0)
-    return 0;
-  return GetSymbolizer()->FillAddressInfo(address, &frames[0]);
+  return symbolizer.SymbolizeCode(address, frames, max_frames);
 }
 
 }  // namespace __sanitizer