Remove path searching

Author: jakeegan

compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp

@@ -384,7 +384,7 @@ uptr ReadBinaryName(char *buf, uptr buf_len) {
   }
 
   // Find the binary in the env PATH.
-  if ((path = FindPathToBinaryOrLibrary(binary_name)) != nullptr)
+  if ((path = FindPathToBinary(binary_name)) != nullptr)
     return internal_snprintf(buf, buf_len, "%s", path);
 
   return 0;

compiler-rt/lib/sanitizer_common/sanitizer_common.cpp

@@ -275,12 +275,6 @@ const char *GetProcessName() {
   return process_name_cache_str;
 }
 
-const char *GetBinaryName() {
-  if (binary_name_cache_str[0] == '\0')
-    ReadBinaryName(binary_name_cache_str, sizeof(binary_name_cache_str));
-  return binary_name_cache_str;
-}
-
 static uptr ReadProcessName(/*out*/ char *buf, uptr buf_len) {
   ReadLongProcessName(buf, buf_len);
   char *s = const_cast<char *>(StripModuleName(buf));

compiler-rt/lib/sanitizer_common/sanitizer_common.h

@@ -290,7 +290,6 @@ uptr ReadBinaryNameCached(/*out*/char *buf, uptr buf_len);
 uptr ReadBinaryDir(/*out*/ char *buf, uptr buf_len);
 uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len);
 const char *GetProcessName();
-const char *GetBinaryName();
 void UpdateProcessName();
 void CacheBinaryName();
 void DisableCoreDumperIfNecessary();

compiler-rt/lib/sanitizer_common/sanitizer_file.cpp

@@ -203,12 +203,12 @@ bool ReadFileToVector(const char *file_name,
 
 static const char kPathSeparator = SANITIZER_WINDOWS ? ';' : ':';
 
-char *FindPathToBinaryOrLibrary(const char *name, const char *env_string) {
+char *FindPathToBinary(const char *name, const char *env_string) {
   if (FileExists(name)) {
     return internal_strdup(name);
   }
 
-  const char *path = GetEnv(env_string);
+  const char *path = GetEnv("PATH");
   if (!path)
     return nullptr;
   uptr name_len = internal_strlen(name);

compiler-rt/lib/sanitizer_common/sanitizer_file.h

@@ -79,8 +79,7 @@ bool SupportsColoredOutput(fd_t fd);
 const char *GetPwd();
 bool FileExists(const char *filename);
 bool DirExists(const char *path);
-char *FindPathToBinaryOrLibrary(const char *name,
-                                const char *env_string = "PATH");
+char *FindPathToBinary(const char *name);
 bool IsPathSeparator(const char c);
 bool IsAbsolutePath(const char *path);
 // Returns true on success, false on failure.

compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h

@@ -40,6 +40,9 @@ class MemoryMappedSegment {
  public:
   explicit MemoryMappedSegment(char *buff = nullptr, uptr size = 0)
       : filename(buff), filename_size(size), data_(nullptr) {}
+  explicit MemoryMappedSegment(char *buff, uptr size, char *display_buff, uptr display_size)
+      : filename(buff), filename_size(size), displayname(display_buff),
+      displayname_size(display_size), data_(nullptr) {}
   ~MemoryMappedSegment() {}
 
   bool IsReadable() const { return protection & kProtectionRead; }
@@ -54,6 +57,8 @@ class MemoryMappedSegment {
   uptr offset;
   char *filename;  // owned by caller
   uptr filename_size;
+  char *displayname;
+  uptr displayname_size;
   uptr protection;
   ModuleArch arch;
   u8 uuid[kModuleUUIDSize];

compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp

@@ -102,68 +102,24 @@ bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
     segment->protection |= kProtectionShared;
 
   if (segment->filename && mapIter->pr_pathoff) {
-    if (type == MA_MAINDATA || type == MA_MAINEXEC) {
-      // AIX procmap does not print full name for the binary, however when using
-      // llvm-symbolizer, it requires the binary must be with full name.
-      const char *BinaryName = GetBinaryName();
-      uptr len =
-          Min((uptr)(internal_strlen(BinaryName)), segment->filename_size - 1);
-      internal_strncpy(segment->filename, BinaryName, len);
-      segment->filename[len] = 0;
-    } else {
-      // AIX library may exist as xxx.a[yyy.o], to find the path to xxx.a,
-      // the [yyy.o] part needs to be removed.
-
-      // TODO FIXME
-      const char *pathPtr = data_.proc_self_maps.data + mapIter->pr_pathoff;
-      uptr len = Min((uptr)internal_strlen(pathPtr),
-                     segment->filename_size - 1);
-      internal_strncpy(segment->filename, pathPtr, len);
-      segment->filename[len] = 0;
-      // AIX procmap does not print full name for user's library , however when
-      // use llvm-symbolizer, it requires the library must be with full name.
-      if ((type == MA_SLIBTEXT || type == MA_PLIBDATA) &&
-          segment->filename[0] != '/') {
-        // First check if the library is in the directory where the binary is
-        // executed. On AIX, there is no need to put library in same dir with
-        // the binary to path search envs.
-        char *path = nullptr;
-        char buf[kMaxPathLength];
-        unsigned buf_len = kMaxPathLength;
-        bool found = false;
-        if ((path = internal_getcwd(buf, buf_len)) != nullptr) {
-          // if the path is too long, don't do other search either.
-          if (internal_strlen(path) > segment->filename_size - 1)
-            found = true;
-          else {
-            internal_snprintf(
-                buf + internal_strlen(path),
-                segment->filename_size - 1 - internal_strlen(path), "/%s",
-                segment->filename);
-            if (FileExists(buf)) {
-              uptr len =
-                  Min((uptr)(internal_strlen(buf)), segment->filename_size - 1);
-              internal_strncpy(segment->filename, buf, len);
-              segment->filename[len] = 0;
-              found = true;
-            }
-          }
-        }
-        if (!found) {
-          const char *LibName =
-              FindPathToBinaryOrLibrary(segment->filename, "LIBPATH");
-          CHECK(LibName);
-          uptr len =
-              Min((uptr)(internal_strlen(LibName)), segment->filename_size - 1);
-          internal_strncpy(segment->filename, LibName, len);
-          segment->filename[len] = 0;
-	  found = true;
-        }
-        CHECK(found);
-      }
-    }
+    uptr len;
+    constexpr unsigned BUFFER_SIZE = 128;
+    char objPath[BUFFER_SIZE] = {};
+    // Use path /proc/<pid>/object/<object_id> to pass to the symbolizer.
+    internal_snprintf(objPath, BUFFER_SIZE, "/proc/%d/object/%s", internal_getpid(), mapIter->pr_mapname);
+    len = Min((uptr)internal_strlen(objPath), segment->filename_size - 1);
+    internal_strncpy(segment->filename, objPath, len);
+    segment->filename[len] = 0;
+
+    // We don't have the full path to user libraries, so we use what we have available as the
+    // display name.
+    const char *displayPath = data_.proc_self_maps.data + mapIter->pr_pathoff;
+    len = Min((uptr)internal_strlen(displayPath), segment->displayname_size - 1);
+    internal_strncpy(segment->displayname, displayPath, len);
+    segment->displayname[len] = 0;
   } else if (segment->filename) {
     segment->filename[0] = 0;
+    segment->displayname[0] = 0;
   }
 
   assert(mapIter->pr_off == 0 && "expect a zero offset into module.");

compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cpp

@@ -121,9 +121,21 @@ void MemoryMappingLayout::DumpListOfModules(
     InternalMmapVectorNoCtor<LoadedModule> *modules) {
   Reset();
   InternalMmapVector<char> module_name(kMaxPathLength);
+#if SANITIZER_AIX
+  InternalMmapVector<char> module_displayname(kMaxPathLength);
+  MemoryMappedSegment segment(module_name.data(), module_name.size(),
+                              module_displayname.data(), module_displayname.size());
+#else
   MemoryMappedSegment segment(module_name.data(), module_name.size());
+#endif
   for (uptr i = 0; Next(&segment); i++) {
+// On AIX, filename contains /proc/<pid>/object/<object_id> to pass to the symbolizer, so we use displayname to
+// contain the real path to present to users
+#if SANITIZER_AIX
+    const char *cur_name = segment.displayname;
+#else
     const char *cur_name = segment.filename;
+#endif
     if (cur_name[0] == '\0')
       continue;
     // Don't subtract 'cur_beg' from the first entry:

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp

@@ -472,17 +472,17 @@ static SymbolizerTool *ChooseExternalSymbolizer(LowLevelAllocator *allocator) {
   // Otherwise symbolizer program is unknown, let's search $PATH
   CHECK(path == nullptr);
 #if SANITIZER_APPLE
-  if (const char *found_path = FindPathToBinaryOrLibrary("atos")) {
+  if (const char *found_path = FindPathToBinary("atos")) {
     VReport(2, "Using atos found at: %s\n", found_path);
     return new(*allocator) AtosSymbolizer(found_path, allocator);
   }
 #endif  // SANITIZER_APPLE
-  if (const char *found_path = FindPathToBinaryOrLibrary("llvm-symbolizer")) {
+  if (const char *found_path = FindPathToBinary("llvm-symbolizer")) {
     VReport(2, "Using llvm-symbolizer found at: %s\n", found_path);
     return new(*allocator) LLVMSymbolizer(found_path, allocator);
   }
   if (common_flags()->allow_addr2line) {
-    if (const char *found_path = FindPathToBinaryOrLibrary("addr2line")) {
+    if (const char *found_path = FindPathToBinary("addr2line")) {
       VReport(2, "Using addr2line found at: %s\n", found_path);
       return new(*allocator) Addr2LinePool(found_path, allocator);
     }

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_win.cpp

@@ -289,7 +289,7 @@ static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
   }
 
   const char *path =
-      user_path ? user_path : FindPathToBinaryOrLibrary("llvm-symbolizer.exe");
+      user_path ? user_path : FindPathToBinary("llvm-symbolizer.exe");
   if (path) {
     if (user_path && user_path[0] == '\0') {
       VReport(2, "External symbolizer is explicitly disabled.\n");

compiler-rt/lib/sanitizer_common/tests/sanitizer_common_test.cpp

@@ -325,20 +325,20 @@ INSTANTIATE_TEST_SUITE_P(SortAndDedupTest, SortAndDedupTest,
                          ::testing::ValuesIn(kSortAndDedupTests));
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
-TEST(SanitizerCommon, FindPathToBinaryOrLibrary) {
-  char *true_path = FindPathToBinaryOrLibrary("true");
+TEST(SanitizerCommon, FindPathToBinary) {
+  char *true_path = FindPathToBinary("true");
   EXPECT_NE((char*)0, internal_strstr(true_path, "/bin/true"));
   InternalFree(true_path);
-  EXPECT_EQ(0, FindPathToBinaryOrLibrary("unexisting_binary.ergjeorj"));
+  EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj"));
 }
 #elif SANITIZER_WINDOWS
-TEST(SanitizerCommon, FindPathToBinaryOrLibrary) {
+TEST(SanitizerCommon, FindPathToBinary) {
   // ntdll.dll should be on PATH in all supported test environments on all
   // supported Windows versions.
-  char *ntdll_path = FindPathToBinaryOrLibrary("ntdll.dll");
+  char *ntdll_path = FindPathToBinary("ntdll.dll");
   EXPECT_NE((char*)0, internal_strstr(ntdll_path, "ntdll.dll"));
   InternalFree(ntdll_path);
-  EXPECT_EQ(0, FindPathToBinaryOrLibrary("unexisting_binary.ergjeorj"));
+  EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj"));
 }
 #endif