[AIX] Add improved interface for retrieving load module paths

[Jonathan.Crowther]

Summary

Implemented (for AIX) a function to take any function and return the path of the load module it is located in. Used this function to implement getMainExecutable for AIX (instead of incorrectly attempting to use /proc) Additionally, fixed multiple locations where getMainExecutable was used incorrectly.

[hubert.reinterpretcast]

llvm/include/llvm/Support/FileUtilities.h

44 ↗

(On Diff #238095)

I'm not sure that this function should handle failure by returning an empty string. The error condition can be made explicit by making the return type of the function llvm::Expected<SmallString<128>>.

[hubert.reinterpretcast]

llvm/include/llvm/Support/FileUtilities.h

38 ↗

(On Diff #238095)

This should be an internal function in the .cpp file implementing the following function. It should not be declared in an interface .h file.

42 ↗

(On Diff #238095)

The description of FileUtilities.h does not seem to encompass what this function does. Perhaps SystemUtils.h works better? fyi, when posting patches to Phabricator, the "full context" (using diff -U <large number>) should be provided.

[stevewan]

Provided that you have squashed all changes into the latest commit in your branch, git diff HEAD^ -U10000 should emit the context you need. Adjust the number of lines of context accordingly to fit the size of your files.

[Jonathan.Crowther]

Addressed comments by moving getLoadModuleFilnameForFunction to llvm/lib/Support/SystemUtils.cpp

[xingxue]

LGTM.

[hubert.reinterpretcast]

llvm/lib/Support/Unix/Path.inc

243

The "expected" here is not checked for doing the error handling (soft-fail in this case). It appears LLVM_ENABLE_ABI_BREAKING_CHECKS would help to catch these.

[hubert.reinterpretcast]

llvm/lib/Support/Unix/Path.inc

243

Ping @Jonathan.Crowther.

clang/lib/Tooling/CompilationDatabase.cpp

 // which don't support these options.
 struct FilterUnusedFlags {
   bool operator() (StringRef S) {
     return (S == "-no-integrated-as") || S.startswith("-Wa,");
   }
 };
 
 std::string GetClangToolCommand() {
-  static int Dummy;
+  void *MainAddr = (void *)(intptr_t)GetClangToolCommand;
   std::string ClangExecutable =
-      llvm::sys::fs::getMainExecutable("clang", (void *)&Dummy);
+      llvm::sys::fs::getMainExecutable("clang", MainAddr);
   SmallString<128> ClangToolPath;
   ClangToolPath = llvm::sys::path::parent_path(ClangExecutable);
   llvm::sys::path::append(ClangToolPath, "clang-tool");
   return ClangToolPath.str();
 }
 
 } // namespace
 

clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp

reportError(createStringError(errc::invalid_argument,
                                       Twine(HostTargetNum)));
   }
 
   if (Error)
     return 1;
 
   // Save the current executable directory as it will be useful to find other
   // tools.
-  BundlerExecutable = sys::fs::getMainExecutable(argv[0], &BundlerExecutable);
+  void *MainAddr = (void *)(intptr_t)PrintVersion;
+  BundlerExecutable = sys::fs::getMainExecutable(argv[0], MainAddr);
 
   if (llvm::Error Err = Unbundle ? UnbundleFiles() : BundleFiles()) {
     reportError(std::move(Err));
     return 1;
   }
   return 0;
 }

clang/tools/libclang/CIndexer.cpp

 #ifdef _WIN32
 #include <windows.h>
 #elif defined(_AIX)
 #include <errno.h>
 #include <sys/ldr.h>
 #else
 #include <dlfcn.h>
 #endif
+#include <llvm/Support/SystemUtils.h>
 
 using namespace clang;
 
-#ifdef _AIX
-namespace clang {
-namespace {
-
-template <typename LibClangPathType>
-void getClangResourcesPathImplAIX(LibClangPathType &LibClangPath) {
-  int PrevErrno = errno;
-
-  size_t BufSize = 2048u;
-  std::unique_ptr<char[]> Buf;
-  while (true) {
-    Buf = std::make_unique<char []>(BufSize);
-    errno = 0;
-    int Ret = loadquery(L_GETXINFO, Buf.get(), (unsigned int)BufSize);
-    if (Ret != -1)
-      break; // loadquery() was successful.
-    if (errno != ENOMEM)
-      llvm_unreachable("Encountered an unexpected loadquery() failure");
-
-    // errno == ENOMEM; try to allocate more memory.
-    if ((BufSize & ~((-1u) >> 1u)) != 0u)
-      llvm::report_fatal_error("BufSize needed for loadquery() too large");
-
-    Buf.release();
-    BufSize <<= 1u;
-  }
-
-  // Extract the function entry point from the function descriptor.
-  uint64_t EntryAddr =
-      reinterpret_cast<uintptr_t &>(clang_createTranslationUnit);
-
-  // Loop to locate the function entry point in the loadquery() results.
-  ld_xinfo *CurInfo = reinterpret_cast<ld_xinfo *>(Buf.get());
-  while (true) {
-    uint64_t CurTextStart = (uint64_t)CurInfo->ldinfo_textorg;
-    uint64_t CurTextEnd = CurTextStart + CurInfo->ldinfo_textsize;
-    if (CurTextStart <= EntryAddr && EntryAddr < CurTextEnd)
-      break; // Successfully located.
-
-    if (CurInfo->ldinfo_next == 0u)
-      llvm::report_fatal_error("Cannot locate entry point in "
-                               "the loadquery() results");
-    CurInfo = reinterpret_cast<ld_xinfo *>(reinterpret_cast<char *>(CurInfo) +
-                                           CurInfo->ldinfo_next);
-  }
-
-  LibClangPath += reinterpret_cast<char *>(CurInfo) + CurInfo->ldinfo_filename;
-  errno = PrevErrno;
-}
-
-} // end anonymous namespace
-} // end namespace clang
-#endif
-
 const std::string &CIndexer::getClangResourcesPath() {
   // Did we already compute the path?
   if (!ResourcesPath.empty())
     return ResourcesPath;
 
   SmallString<128> LibClangPath;
 
   // Find the location where this library lives (libclang.dylib).
#if CYGWIN_VERSION_API_MAJOR > 0 || CYGWIN_VERSION_API_MINOR >= 181
   cygwin_conv_path(CCP_WIN_A_TO_POSIX, w32path, path, MAX_PATH);
 #else
   cygwin_conv_to_full_posix_path(w32path, path);
 #endif
 #endif
 
   LibClangPath += path;
 #elif defined(_AIX)
-  getClangResourcesPathImplAIX(LibClangPath);
+  LibClangPath +=
+      llvm::getLoadModuleFilenameForFunction(clang_createTranslationUnit)
+      ->c_str();
 #else
   // This silly cast below avoids a C++ warning.
   Dl_info info;
   if (dladdr((void *)(uintptr_t)clang_createTranslationUnit, &info) == 0)
     llvm_unreachable("Call to dladdr() failed");
 
   // We now have the CIndex directory, locate clang relative to it.
   LibClangPath += info.dli_fname;

llvm/include/llvm/Support/SystemUtils.h

 //===- SystemUtils.h - Utilities to do low-level system stuff ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains functions used to do a variety of low-level, often
 // system-specific, tasks.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_SYSTEMUTILS_H
 #define LLVM_SUPPORT_SYSTEMUTILS_H
 
+#include <llvm/Support/Error.h>
+
 namespace llvm {
   class raw_ostream;
 
 /// Determine if the raw_ostream provided is connected to a terminal. If so,
 /// generate a warning message to errs() advising against display of bitcode
 /// and return true. Otherwise just return false.
 /// Check for output written to a console
 bool CheckBitcodeOutputToConsole(
   raw_ostream &stream_to_check, ///< The stream to be checked
   bool print_warning = true     ///< Control whether warnings are printed
 );
 
+llvm::Expected<SmallString<128>>
+getLoadModuleFilenameForFunctionImpl(void (*Func)(void));
+
+template <typename FuncAddrType>
+llvm::Expected<SmallString<128>>
+getLoadModuleFilenameForFunction(FuncAddrType FuncAddr) {
+  void (*FP)(void) = reinterpret_cast<void (*)(void)>(FuncAddr);
+  return getLoadModuleFilenameForFunctionImpl(FP);
+}
+
 } // End llvm namespace
 
 #endif

llvm/lib/Support/SystemUtils.cpp

 //===- SystemUtils.cpp - Utilities for low-level system tasks -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains functions used to do a variety of low-level, often
 // system-specific, tasks.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/SystemUtils.h"
 #include "llvm/Support/raw_ostream.h"
+
+// These typedefs are needed for sys/ldr.h to work on AIX
+#if defined(_AIX)
+typedef unsigned int uint;
+typedef unsigned short ushort;
+typedef void *__ptr64;
+static_assert(sizeof(__ptr64) == 8u, "__ptr64 size error.");
+#include <sys/ldr.h>
+#include <errno.h>
+#endif
+
 using namespace llvm;
 
 bool llvm::CheckBitcodeOutputToConsole(raw_ostream &stream_to_check,
                                        bool print_warning) {
   if (stream_to_check.is_displayed()) {
     if (print_warning) {
       errs() << "WARNING: You're attempting to print out a bitcode file.\n"
                 "This is inadvisable as it may cause display problems. If\n"
                 "you REALLY want to taste LLVM bitcode first-hand, you\n"
                 "can force output with the `-f' option.\n\n";
     }
     return true;
   }
   return false;
 }
+
+#if defined(_AIX)
+// Returns the name of the load module that contains the entry point of the
+// function referenced by fp.
+static SmallString<128> getLoadModuleFilenameForFunctionAIX(void (*fp)(void)) {
+  int PrevErrno = errno;
+
+  size_t BufSize = 2048u;
+  std::unique_ptr<char[]> Buf;
+  while (true) {
+    Buf = std::make_unique<char []>(BufSize);
+    errno = 0;
+    int Ret = loadquery(L_GETXINFO, Buf.get(), (unsigned int)BufSize);
+    if (Ret != -1)
+      break; // loadquery() was successful.
+    if (errno != ENOMEM)
+      llvm_unreachable("Encountered an unexpected loadquery() failure");
+
+    // errno == ENOMEM; try to allocate more memory.
+    if ((BufSize & ~((-1u) >> 1u)) != 0u)
+      llvm::report_fatal_error("BufSize needed for loadquery() too large");
+
+    Buf.release();
+    BufSize <<= 1u;
+  }
+
+  // Extract the function entry point from the function descriptor.
+  uint64_t EntryAddr = *reinterpret_cast<uintptr_t *>(fp);
+
+  // Loop to locate the function entry point in the loadquery() results.
+  ld_xinfo *CurInfo = reinterpret_cast<ld_xinfo *>(Buf.get());
+  while (true) {
+    uint64_t CurTextStart = (uint64_t)CurInfo->ldinfo_textorg;
+    uint64_t CurTextEnd = CurTextStart + CurInfo->ldinfo_textsize;
+    if (CurTextStart <= EntryAddr && EntryAddr < CurTextEnd)
+      break; // Successfully located.
+
+    if (CurInfo->ldinfo_next == 0u)
+      llvm::report_fatal_error("Cannot locate entry point in "
+                               "the loadquery() results");
+    CurInfo = reinterpret_cast<ld_xinfo *>(reinterpret_cast<char *>(CurInfo) +
+                                           CurInfo->ldinfo_next);
+  }
+
+  errno = PrevErrno;
+  char *filename = reinterpret_cast<char *>(CurInfo) + CurInfo->ldinfo_filename;
+  return SmallString<128>(filename);
+}
+#endif
+
+llvm::Expected<SmallString<128>>
+llvm::getLoadModuleFilenameForFunctionImpl(void (*fp)(void)) {
+  if (!fp) {
+    return createStringError(std::errc::invalid_argument,
+                 "Function address can not be found");
+  }
+#if defined(_AIX)
+  return getLoadModuleFilenameForFunctionAIX(fp);
+#endif
+  llvm::report_fatal_error(
+      "getLoadModuleFilenameForFunction not implemented on this platform");
+}
+

llvm/lib/Support/Unix/Path.inc

 #endif
 #if defined(HAVE_LINUX_SMB_H)
 #include <linux/smb.h>
 #endif
 #endif
 #include <sys/vfs.h>
 #elif defined(_AIX)
 #include <sys/statfs.h>
+#include <llvm/Support/SystemUtils.h>
 
 // <sys/vmount.h> depends on `uint` to be a typedef from <sys/types.h> to
 // `uint_t`; however, <sys/types.h> does not always declare `uint`. We provide
 // the typedef prior to including <sys/vmount.h> to work around this issue.
 typedef uint_t uint;
 #include <sys/vmount.h>
 #else
 #include <sys/mount.h>
for (;;) {
     }
     p++;
   }
 #endif
   // Fall back to argv[0] if auxiliary vectors are not available.
   if (getprogpath(exe_path, argv0) != NULL)
     return exe_path;
 #elif defined(__NetBSD__) || defined(__OpenBSD__) || defined(__minix) ||       \
-    defined(__DragonFly__) || defined(__FreeBSD_kernel__) || defined(_AIX)
+    defined(__DragonFly__) || defined(__FreeBSD_kernel__)
   const char *curproc = "/proc/curproc/file";
   char exe_path[PATH_MAX];
   if (sys::fs::exists(curproc)) {
     ssize_t len = readlink(curproc, exe_path, sizeof(exe_path));
     if (len > 0) {
       // Null terminate the string for realpath. readlink never null
       // terminates its output.
       len = std::min(len, ssize_t(sizeof(exe_path) - 1));
       exe_path[len] = '\0';
       return exe_path;
     }
   }
   // If we don't have procfs mounted, fall back to argv[0]
   if (getprogpath(exe_path, argv0) != NULL)
     return exe_path;
+#elif defined(_AIX)
+  return getLoadModuleFilenameForFunction(MainAddr)->c_str();
 #elif defined(__linux__) || defined(__CYGWIN__) || defined(__gnu_hurd__)
   char exe_path[MAXPATHLEN];
   const char *aPath = "/proc/self/exe";
   if (sys::fs::exists(aPath)) {
     // /proc is not always mounted under Linux (chroot for example).
     ssize_t len = readlink(aPath, exe_path, sizeof(exe_path));
     if (len < 0)
       return "";

llvm/unittests/Support/ProgramTest.cpp

 using namespace llvm;
 using namespace sys;
 
 static cl::opt<std::string>
 ProgramTestStringArg1("program-test-string-arg1");
 static cl::opt<std::string>
 ProgramTestStringArg2("program-test-string-arg2");
 
+void DummyFunction() {}
+
 class ProgramEnvTest : public testing::Test {
   std::vector<StringRef> EnvTable;
   std::vector<std::string> EnvStorage;
 
 protected:
   void SetUp() override {
     auto EnvP = [] {
 #if defined(_WIN32)

 };
 
 #ifdef _WIN32
 TEST_F(ProgramEnvTest, CreateProcessLongPath) {
   if (getenv("LLVM_PROGRAM_TEST_LONG_PATH"))
     exit(0);
 
   // getMainExecutable returns an absolute path; prepend the long-path prefix.
-  std::string MyAbsExe =
-      sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
+  void *MainAddr = (void *)(intptr_t)DummyFunction;
+  std::string MyAbsExe = sys::fs::getMainExecutable(TestMainArgv0, MainAddr);
   std::string MyExe;
   if (!StringRef(MyAbsExe).startswith("\\\\?\\"))
     MyExe.append("\\\\?\\");
   MyExe.append(MyAbsExe);
 
   StringRef ArgV[] = {MyExe,
                       "--gtest_filter=ProgramEnvTest.CreateProcessLongPath"};
 
TEST_F(ProgramEnvTest, CreateProcessTrailingSlash) {
   if (getenv("LLVM_PROGRAM_TEST_CHILD")) {
     if (ProgramTestStringArg1 == "has\\\\ trailing\\" &&
         ProgramTestStringArg2 == "has\\\\ trailing\\") {
       exit(0);  // Success!  The arguments were passed and parsed.
     }
     exit(1);
   }
 
-  std::string my_exe =
-      sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
+  void *MainAddr = (void *)(intptr_t)DummyFunction;
+  std::string my_exe = sys::fs::getMainExecutable(TestMainArgv0, MainAddr);
   StringRef argv[] = {
       my_exe,
       "--gtest_filter=ProgramEnvTest.CreateProcessTrailingSlash",
       "-program-test-string-arg1",
       "has\\\\ trailing\\",
       "-program-test-string-arg2",
       "has\\\\ trailing\\"};
 

 TEST_F(ProgramEnvTest, TestExecuteNoWait) {
   using namespace llvm::sys;
 
   if (getenv("LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT")) {
     sleep_for(/*seconds*/ 1);
     exit(0);
   }
 
-  std::string Executable =
-      sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
+  void *MainAddr = (void *)(intptr_t)DummyFunction;
+  std::string Executable = sys::fs::getMainExecutable(TestMainArgv0, MainAddr);
   StringRef argv[] = {Executable,
                       "--gtest_filter=ProgramEnvTest.TestExecuteNoWait"};
 
   // Add LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT to the environment of the child.
   addEnvVar("LLVM_PROGRAM_TEST_EXECUTE_NO_WAIT=1");
 
   std::string Error;
   bool ExecutionFailed;

 TEST_F(ProgramEnvTest, TestExecuteAndWaitTimeout) {
   using namespace llvm::sys;
 
   if (getenv("LLVM_PROGRAM_TEST_TIMEOUT")) {
     sleep_for(/*seconds*/ 10);
     exit(0);
   }
 
-  std::string Executable =
-      sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
+  void *MainAddr = (void *)(intptr_t)DummyFunction;
+  std::string Executable = sys::fs::getMainExecutable(TestMainArgv0, MainAddr);
   StringRef argv[] = {
       Executable, "--gtest_filter=ProgramEnvTest.TestExecuteAndWaitTimeout"};
 
   // Add LLVM_PROGRAM_TEST_TIMEOUT to the environment of the child.
  addEnvVar("LLVM_PROGRAM_TEST_TIMEOUT=1");
 
   std::string Error;
   bool ExecutionFailed;