[compiler-rt] Symbolizer refactoring: Turn FillAddressAndModuleInfo into FillModuleInfo

[kubamracek]

Summary

Part of http://reviews.llvm.org/D7827. We no longer need to set the addr field in FillAddressAndModuleInfo, because it's now always used right after creating the struct with the address already set.

[samsonov]

LGTM. Thank you!

[kubamracek]

Landed in r231061.

lib/sanitizer_common/sanitizer_symbolizer.h

struct AddressInfo {
 
   char *file;
   int line;
   int column;
 
   AddressInfo();
   // Deletes all strings and resets all fields.
   void Clear();
-  void FillAddressAndModuleInfo(uptr addr, const char *mod_name,
-                                uptr mod_offset);
+  void FillModuleInfo(const char *mod_name, uptr mod_offset);
 };
 
 // Linked list of symbolized frames (each frame is described by AddressInfo).
 struct SymbolizedStack {
   SymbolizedStack *next;
   AddressInfo info;
   static SymbolizedStack *New(uptr addr);
   // Deletes current, and all subsequent frames in the linked list.

lib/sanitizer_common/sanitizer_symbolizer.cc

 void AddressInfo::Clear() {
   InternalFree(module);
   InternalFree(function);
   InternalFree(file);
   internal_memset(this, 0, sizeof(AddressInfo));
   function_offset = kUnknown;
 }
 
-void AddressInfo::FillAddressAndModuleInfo(uptr addr, const char *mod_name,
-                                           uptr mod_offset) {
-  address = addr;
+void AddressInfo::FillModuleInfo(const char *mod_name, uptr mod_offset) {
   module = internal_strdup(mod_name);
   module_offset = mod_offset;
 }
 
 SymbolizedStack::SymbolizedStack() : next(nullptr), info() {}
 
 SymbolizedStack *SymbolizedStack::New(uptr addr) {
   void *mem = InternalAlloc(sizeof(SymbolizedStack));

lib/sanitizer_common/sanitizer_symbolizer_libbacktrace.cc

struct SymbolizeCodeCallbackArg {
   SymbolizedStack *last;
   uptr frames_symbolized;
 
   AddressInfo *get_new_frame(uintptr_t addr) {
     CHECK(last);
     if (frames_symbolized > 0) {
       SymbolizedStack *cur = SymbolizedStack::New(addr);
       AddressInfo *info = &cur->info;
-      info->FillAddressAndModuleInfo(addr, first->info.module,
-                                     first->info.module_offset);
+      info->FillModuleInfo(first->info.module, first->info.module_offset);
       last->next = cur;
       last = cur;
     }
     CHECK_EQ(addr, first->info.address);
     CHECK_EQ(addr, last->info.address);
     return &last->info;
   }
 };

lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cc

if (function_name[0] == '\0') {
       break;
     }
     SymbolizedStack *cur;
     if (top_frame) {
       cur = res;
       top_frame = false;
     } else {
       cur = SymbolizedStack::New(res->info.address);
-      cur->info.FillAddressAndModuleInfo(res->info.address, res->info.module,
-                                         res->info.module_offset);
+      cur->info.FillModuleInfo(res->info.module, res->info.module_offset);
       last->next = cur;
       last = cur;
     }
 
     AddressInfo *info = &cur->info;
     info->function = function_name;
     // Parse <file>:<line>:<column> buffer.
     char *file_line_info = 0;
public:
   SymbolizedStack *SymbolizePC(uptr addr) override {
     BlockingMutexLock l(&mu_);
     const char *module_name;
     uptr module_offset;
     SymbolizedStack *res = SymbolizedStack::New(addr);
     if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset))
       return res;
     // Always fill data about module name and offset.
-    res->info.FillAddressAndModuleInfo(addr, module_name, module_offset);
+    res->info.FillModuleInfo(module_name, module_offset);
     // First, try to use libbacktrace symbolizer (if it's available).
     if (libbacktrace_symbolizer_ != 0) {
       mu_.CheckLocked();
       if (libbacktrace_symbolizer_->SymbolizePC(addr, res))
         return res;
     }
     if (SymbolizerTool *tool = GetSymbolizerTool()) {
       SymbolizerScope sym_scope(this);

lib/sanitizer_common/sanitizer_symbolizer_win.cc

if (got_fileline) {
       frame->info.file = internal_strdup(line_info.FileName);
       frame->info.line = line_info.LineNumber;
     }
 
     IMAGEHLP_MODULE64 mod_info;
     internal_memset(&mod_info, 0, sizeof(mod_info));
     mod_info.SizeOfStruct = sizeof(mod_info);
     if (SymGetModuleInfo64(GetCurrentProcess(), addr, &mod_info))
-      frame->info.FillAddressAndModuleInfo(addr, mod_info.ImageName,
-                                           addr - (uptr)mod_info.BaseOfImage);
+      frame->info.FillModuleInfo(mod_info.ImageName,
     return frame;
   }
 
   bool CanReturnFileLineInfo() override {
     return true;
   }
 
   const char *Demangle(const char *name) override {