Update display name logic

Author: jakeegan

compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp

@@ -492,6 +492,22 @@ u64 MonotonicNanoTime() {
   return (u64)ts.tv_sec * (1000ULL * 1000 * 1000) + ts.tv_nsec;
 }
 
+void DumpProcessMap() {
+MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+  const sptr kBufSize = 4095;
+  char *filename = (char*)MmapOrDie(kBufSize, __func__);
+  char *displayname = (char*)MmapOrDie(kBufSize, __func__);
+  MemoryMappedSegment segment(filename, kBufSize, displayname, kBufSize);
+  Report("Process memory map follows:\n");
+  while (proc_maps.Next(&segment)) {
+    Printf("\t%p-%p\t%s\n", (void *)segment.start, (void *)segment.end,
+           segment.displayname);
+  }
+  Report("End of process memory map.\n");
+  UnmapOrDie(filename, kBufSize);
+  UnmapOrDie(displayname, kBufSize);
+}
+
 // FIXME implement on this platform.
 void GetMemoryProfile(fill_profile_f cb, uptr *stats) {}
 

compiler-rt/lib/sanitizer_common/sanitizer_common.cpp

@@ -171,6 +171,10 @@ void LoadedModule::set(const char *module_name, uptr base_address,
   instrumented_ = instrumented;
 }
 
+void LoadedModule::setDisplayName(const char *display_name) {
+  display_name_ = internal_strdup(display_name); 
+}
+
 void LoadedModule::setUuid(const char *uuid, uptr size) {
   if (size > kModuleUUIDSize)
     size = kModuleUUIDSize;
@@ -180,9 +184,11 @@ void LoadedModule::setUuid(const char *uuid, uptr size) {
 
 void LoadedModule::clear() {
   InternalFree(full_name_);
+  InternalFree(display_name_);
   base_address_ = 0;
   max_address_ = 0;
   full_name_ = nullptr;
+  display_name_ = nullptr;
   arch_ = kModuleArchUnknown;
   internal_memset(uuid_, 0, kModuleUUIDSize);
   instrumented_ = false;

compiler-rt/lib/sanitizer_common/sanitizer_common.h

@@ -831,6 +831,7 @@ class LoadedModule {
  public:
   LoadedModule()
       : full_name_(nullptr),
+        display_name_(nullptr),
         base_address_(0),
         max_address_(0),
         arch_(kModuleArchUnknown),
@@ -842,13 +843,15 @@ class LoadedModule {
   void set(const char *module_name, uptr base_address);
   void set(const char *module_name, uptr base_address, ModuleArch arch,
            u8 uuid[kModuleUUIDSize], bool instrumented);
+  void setDisplayName(const char *display_name);
   void setUuid(const char *uuid, uptr size);
   void clear();
   void addAddressRange(uptr beg, uptr end, bool executable, bool writable,
                        const char *name = nullptr);
   bool containsAddress(uptr address) const;
 
   const char *full_name() const { return full_name_; }
+  const char *display_name() const {return display_name_;}
   uptr base_address() const { return base_address_; }
   uptr max_address() const { return max_address_; }
   ModuleArch arch() const { return arch_; }
@@ -879,6 +882,7 @@ class LoadedModule {
 
  private:
   char *full_name_;  // Owned.
+  char *display_name_;
   uptr base_address_;
   uptr max_address_;
   ModuleArch arch_;

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp

@@ -416,18 +416,19 @@ bool MmapFixedSuperNoReserve(uptr fixed_addr, uptr size, const char *name) {
 }
 
 uptr ReservedAddressRange::Init(uptr size, const char *name, uptr fixed_addr) {
+# if !SANITIZER_AIX
+   base_ = fixed_addr ? MmapFixedNoAccess(fixed_addr, size, name)
+                      : MmapNoAccess(size);
+# else
   // AIX can not mmap on a mmaped memory, so init it as read/write so we won't
   // mmap on this memory again.
-#  if SANITIZER_AIX
   if (fixed_addr) {
     MmapFixed(fixed_addr, size, MAP_PRIVATE | MAP_FIXED | MAP_ANON, name);
     base_ = (void *)fixed_addr;
-  } else
+  } else {
     base_ = (void *)internal_mmap(nullptr, size, PROT_READ | PROT_WRITE,
                                   MAP_PRIVATE | MAP_ANON, -1, 0);
-#  else
-  base_ = fixed_addr ? MmapFixedNoAccess(fixed_addr, size, name)
-                     : MmapNoAccess(size);
+  }
 #  endif
   size_ = size;
   name_ = name;

compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp

@@ -106,6 +106,7 @@ bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
     constexpr unsigned BUFFER_SIZE = 128;
     char objPath[BUFFER_SIZE] = {};
     // Use path /proc/<pid>/object/<object_id> to pass to the symbolizer.
+    // TODO: Append the archive member name if it exists.
     internal_snprintf(objPath, BUFFER_SIZE, "/proc/%d/object/%s",
                       internal_getpid(), mapIter->pr_mapname);
     len = Min((uptr)internal_strlen(objPath), segment->filename_size - 1);
@@ -114,6 +115,7 @@ bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
 
     // We don't have the full path to user libraries, so we use what we have
     // available as the display name.
+    // TODO: Append the archive member name if it exists.
     const char *displayPath = data_.proc_self_maps.data + mapIter->pr_pathoff;
     len =
         Min((uptr)internal_strlen(displayPath), segment->displayname_size - 1);
@@ -133,6 +135,38 @@ bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
   return true;
 }
 
+void MemoryMappingLayout::DumpListOfModules(
+    InternalMmapVectorNoCtor<LoadedModule> *modules) {
+  Reset();
+  InternalMmapVector<char> module_name(kMaxPathLength);
+  InternalMmapVector<char> module_displayname(kMaxPathLength);
+  MemoryMappedSegment segment(module_name.data(), module_name.size(),
+                              module_displayname.data(),
+                              module_displayname.size());
+  for (uptr i = 0; Next(&segment); i++) {
+    const char *cur_name = segment.filename;
+    if (cur_name[0] == '\0')
+      continue;
+    // Don't subtract 'cur_beg' from 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.
+    uptr base_address = (i ? segment.start : 0) - segment.offset;
+    LoadedModule cur_module;
+    cur_module.set(cur_name, base_address);
+    cur_module.setDisplayName(segment.displayname);
+    segment.AddAddressRanges(&cur_module);
+    modules->push_back(cur_module);
+  }
+}
+
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_AIX

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_printer.cpp

@@ -242,9 +242,13 @@ void FormattedStackTracePrinter::RenderFrame(InternalScopedString *buffer,
         RenderSourceLocation(buffer, info->file, info->line, info->column,
                              vs_style, strip_path_prefix);
       } else if (info->module) {
+#if SANITIZER_AIX
+        RenderModuleLocation(buffer, info->module_display, info->module_offset,
+                             info->module_arch, strip_path_prefix);
+#else
         RenderModuleLocation(buffer, info->module, info->module_offset,
                              info->module_arch, strip_path_prefix);
-
+#endif
 #if !SANITIZER_APPLE
         MaybeBuildIdToBuffer(*info, /*PrefixSpace=*/true, buffer);
 #endif
@@ -258,8 +262,13 @@ void FormattedStackTracePrinter::RenderFrame(InternalScopedString *buffer,
         // There PCs are not meaningful.
       } else if (info->module) {
         // Always strip the module name for %M.
+#if SANITIZER_AIX
+        RenderModuleLocation(buffer, StripModuleName(info->module_display),
+                             info->module_offset, info->module_arch, "");
+#else
         RenderModuleLocation(buffer, StripModuleName(info->module),
                              info->module_offset, info->module_arch, "");
+#endif
 #if !SANITIZER_APPLE
         MaybeBuildIdToBuffer(*info, /*PrefixSpace=*/true, buffer);
 #endif

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cpp

@@ -29,6 +29,7 @@ AddressInfo::AddressInfo() {
 
 void AddressInfo::Clear() {
   InternalFree(module);
+  InternalFree(module_display);
   InternalFree(function);
   InternalFree(file);
   internal_memset(this, 0, sizeof(AddressInfo));
@@ -46,6 +47,9 @@ void AddressInfo::FillModuleInfo(const char *mod_name, uptr mod_offset,
 
 void AddressInfo::FillModuleInfo(const LoadedModule &mod) {
   module = internal_strdup(mod.full_name());
+#if SANITIZER_AIX
+  module_display = internal_strdup(mod.display_name());
+#endif
   module_offset = address - mod.base_address();
   module_arch = mod.arch();
   if (mod.uuid_size())

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.h

@@ -30,6 +30,7 @@ struct AddressInfo {
   uptr address;
 
   char *module;
+  char *module_display;
   uptr module_offset;
   ModuleArch module_arch;
   u8 uuid[kModuleUUIDSize];