Rework submodule installation (#70)

* Rework submodule installation - use add_subdirectory(... EXCLUDE_FROM_ALL) + explicit installation of deps - install all library deps to lib/omnitrace - internal builds of dyninst use libomnitrace-rt for binary rewriting - support libdyninstAPI_RT not in LD_LIBRARY_PATH when dyninst built internally * Update ubuntu-focal to test full dyninst install * Use RelWithDebInfo because Dyninst segfaults with MinSizeRel * Fix ubuntu-focal.yml install step
2022-06-28 16:32:07 -05:00
@@ -7,7 +7,6 @@ on:
    branches: [ main, develop ]

 env:
-  BUILD_TYPE: Release
  ELFUTILS_DOWNLOAD_VERSION: 0.186
  OMNITRACE_VERBOSE: 1
  OMNITRACE_CI: ON
@@ -19,6 +18,21 @@ jobs:
      matrix:
        compiler: ['g++']
        mpi: [ '', 'libmpich-dev mpich', 'libopenmpi-dev openmpi-bin libfabric-dev' ]
+        boost: ['OFF']
+        tbb: ['OFF']
+        build-type: ['Release']
+        python: ['ON']
+        ompt: ['ON']
+        papi: ['ON']
+        include:
+        - compiler: 'g++'
+          mpi: ''
+          boost: 'ON'
+          tbb: 'ON'
+          build-type: 'Release'
+          python: 'OFF'
+          ompt: 'OFF'
+          papi: 'OFF'

    steps:
    - uses: actions/checkout@v2
@@ -48,16 +62,19 @@ jobs:
        cmake -B ${{ github.workspace }}/build
          -DCMAKE_C_COMPILER=$(echo '${{ matrix.compiler }}' | sed 's/+/c/g')
          -DCMAKE_CXX_COMPILER=${{ matrix.compiler }}
-          -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }}
+          -DCMAKE_BUILD_TYPE=${{ matrix.build-type }}
          -DCMAKE_INSTALL_PREFIX=/opt/omnitrace
          -DOMNITRACE_BUILD_TESTING=ON
          -DOMNITRACE_BUILD_DYNINST=ON
          -DOMNITRACE_USE_MPI=${USE_MPI}
          -DOMNITRACE_USE_HIP=OFF
-          -DOMNITRACE_USE_PYTHON=ON
-          -DOMNITRACE_USE_OMPT=ON
+          -DOMNITRACE_USE_PYTHON=${{ matrix.python }}
+          -DOMNITRACE_USE_OMPT=${{ matrix.ompt }}
+          -DOMNITRACE_USE_PAPI=${{ matrix.papi }}
          -DDYNINST_BUILD_ELFUTILS=ON
          -DDYNINST_BUILD_LIBIBERTY=ON
+          -DDYNINST_BUILD_TBB=${{ matrix.tbb }}
+          -DDYNINST_BUILD_BOOST=${{ matrix.boost }}
          -DDYNINST_BUILD_SHARED_LIBS=ON
          -DDYNINST_BUILD_STATIC_LIBS=OFF
          -DDYNINST_ELFUTILS_DOWNLOAD_VERSION=${{ env.ELFUTILS_DOWNLOAD_VERSION }}
@@ -67,10 +84,6 @@ jobs:
      run:
        cmake --build ${{ github.workspace }}/build --target all --parallel 2 -- VERBOSE=1

-    - name: Install
-      run:
-        cmake --build ${{ github.workspace }}/build --target install --parallel 2
-
    - name: Test
      timeout-minutes: 45
      working-directory: ${{ github.workspace }}/build
@@ -78,6 +91,13 @@ jobs:
        ctest -V -N -O ${{ github.workspace }}/build/omnitrace-ctest-${{ github.job }}-commands.log &&
        ctest -V --output-log ${{ github.workspace }}/build/omnitrace-ctest-${{ github.job }}.log --stop-on-failure

+    - name: Install
+      working-directory: ${{ github.workspace }}/build
+      run: |
+        cpack -G STGZ
+        mkdir -p /opt/omnitrace
+        ./omnitrace-*.sh --prefix=/opt/omnitrace --exclude-subdir --skip-license
+
    - name: Test Install
      timeout-minutes: 10
      run: |
@@ -1,15 +1,4 @@
-if(DYNINST_BUILD_ELFUTILS AND DYNINST_ELFUTILS_DOWNLOAD_VERSION)
-    omnitrace_add_feature(DYNINST_ELFUTILS_DOWNLOAD_VERSION "ElfUtils download version")
-    foreach(_LIB dw elf)
-        install(
-            PROGRAMS
-                ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/dyninst-tpls/lib/lib${_LIB}${CMAKE_SHARED_LIBRARY_SUFFIX}
-                ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/dyninst-tpls/lib/lib${_LIB}${CMAKE_SHARED_LIBRARY_SUFFIX}.1
-                ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/dyninst-tpls/lib/lib${_LIB}-${DYNINST_ELFUTILS_DOWNLOAD_VERSION}${CMAKE_SHARED_LIBRARY_SUFFIX}
-            DESTINATION ${CMAKE_INSTALL_LIBDIR}/dyninst-tpls/lib
-            OPTIONAL)
-    endforeach()
-endif()
+# configure packaging

 function(omnitrace_parse_release)
    if(EXISTS /etc/lsb-release AND NOT IS_DIRECTORY /etc/lsb-release)
@@ -781,4 +781,57 @@ function(OMNITRACE_FIND_SHARED_LIBRARY)
    find_library(${ARGN})
 endfunction()

+function(OMNITRACE_INSTALL_TPL _TPL_TARGET _NEW_NAME _BUILD_TREE_DIR)
+    get_target_property(_TPL_VERSION ${_TPL_TARGET} VERSION)
+    get_target_property(_TPL_SOVERSION ${_TPL_TARGET} SOVERSION)
+    get_target_property(_TPL_NAME ${_TPL_TARGET} OUTPUT_NAME)
+    set(_TPL_PREFIX ${CMAKE_SHARED_LIBRARY_PREFIX})
+    set(_TPL_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX})
+
+    foreach(_TAIL ${_TPL_SUFFIX} ${_TPL_SUFFIX}.${_TPL_SOVERSION}
+                  ${_TPL_SUFFIX}.${_TPL_VERSION})
+        set(_INP ${_TPL_PREFIX}${_TPL_NAME}${_TAIL})
+        set(_OUT ${_TPL_PREFIX}${_NEW_NAME}${_TAIL})
+    endforeach()
+
+    # build tree symbolic links
+    add_custom_target(
+        ${_NEW_NAME}-library ALL
+        ${CMAKE_COMMAND} -E create_symlink $<TARGET_FILE:${_TPL_TARGET}>
+        ${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_VERSION}
+        COMMAND
+            ${CMAKE_COMMAND} -E create_symlink
+            ${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_VERSION}
+            ${_BUILD_TREE_DIR}/${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_SOVERSION}
+        COMMAND
+            ${CMAKE_COMMAND} -E create_symlink
+            ${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_SOVERSION}
+            ${_BUILD_TREE_DIR}/${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}
+        WORKING_DIRECTORY ${_BUILD_TREE_DIR}
+        DEPENDS ${_TPL_TARGET}
+        COMMENT "Creating ${_NEW_NAME} symbolic links to ${_TPL_TARGET}...")
+
+    install(
+        FILES $<TARGET_FILE:${_TPL_TARGET}>
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        RENAME ${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_VERSION})
+
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/install-tree
+        COMMAND
+            ${CMAKE_COMMAND} -E create_symlink
+            ${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_VERSION}
+            ${PROJECT_BINARY_DIR}/install-tree/${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_SOVERSION}
+        COMMAND
+            ${CMAKE_COMMAND} -E create_symlink
+            ${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_SOVERSION}
+            ${PROJECT_BINARY_DIR}/install-tree/${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX})
+    install(
+        FILES
+            ${PROJECT_BINARY_DIR}/install-tree/${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_SOVERSION}
+            ${PROJECT_BINARY_DIR}/install-tree/${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}
+        DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+endfunction()
+
 cmake_policy(POP)
@@ -208,14 +208,50 @@ if(OMNITRACE_BUILD_DYNINST)

    omnitrace_save_variables(PIC VARIABLES CMAKE_POSITION_INDEPENDENT_CODE)
    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-    add_subdirectory(external/dyninst)
+    set(DYNINST_TPL_INSTALL_PREFIX
+        "omnitrace"
+        CACHE PATH "Third-party library install-tree install prefix" FORCE)
+    set(DYNINST_TPL_INSTALL_LIB_DIR
+        "omnitrace"
+        CACHE PATH "Third-party library install-tree install library prefix" FORCE)
+    add_subdirectory(external/dyninst EXCLUDE_FROM_ALL)
    omnitrace_restore_variables(PIC VARIABLES CMAKE_POSITION_INDEPENDENT_CODE)

    add_library(Dyninst::Dyninst INTERFACE IMPORTED)
-    foreach(_LIB common dyninstAPI parseAPI instructionAPI symtabAPI stackwalk Boost TBB)
+    foreach(_LIB common dyninstAPI parseAPI instructionAPI symtabAPI stackwalk)
        target_link_libraries(Dyninst::Dyninst INTERFACE Dyninst::${_LIB})
    endforeach()

+    foreach(
+        _LIB
+        common
+        dynDwarf
+        dynElf
+        dyninstAPI
+        dyninstAPI_RT
+        instructionAPI
+        parseAPI
+        patchAPI
+        pcontrol
+        stackwalk
+        symtabAPI)
+        if(TARGET ${_LIB})
+            install(
+                TARGETS ${_LIB}
+                DESTINATION ${CMAKE_INSTALL_LIBDIR}/omnitrace
+                PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_LIBDIR}/omnitrace/include)
+        endif()
+    endforeach()
+
+    omnitrace_install_tpl(dyninstAPI_RT omnitrace-rt "${PROJECT_BINARY_DIR}")
+
+    # for packaging
+    install(
+        DIRECTORY ${DYNINST_TPL_STAGING_PREFIX}/lib/
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/omnitrace
+        FILES_MATCHING
+        PATTERN "*${CMAKE_SHARED_LIBRARY_SUFFIX}*")
+
    target_link_libraries(omnitrace-dyninst INTERFACE Dyninst::Dyninst)

    set(OMNITRACE_DYNINST_API_RT
@@ -529,7 +565,16 @@ if(CMAKE_BUILD_TYPE STREQUAL "Debug")
        CACHE BOOL "" FORCE)
 endif()

-add_subdirectory(external/timemory)
+add_subdirectory(external/timemory EXCLUDE_FROM_ALL)
+
+install(TARGETS gotcha DESTINATION ${CMAKE_INSTALL_LIBDIR}/omnitrace)
+if(OMNITRACE_BUILD_LIBUNWIND)
+    install(
+        DIRECTORY ${PROJECT_BINARY_DIR}/external/timemory/external/libunwind/install/lib/
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/omnitrace
+        FILES_MATCHING
+        PATTERN "*${CMAKE_SHARED_LIBRARY_SUFFIX}*")
+endif()

 omnitrace_restore_variables(
    BUILD_CONFIG VARIABLES BUILD_SHARED_LIBS BUILD_STATIC_LIBS
@@ -590,7 +635,7 @@ if(NOT TARGET PTL::ptl-shared)
    set(CMAKE_CXX_VISIBILITY_PRESET "hidden")
    set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)

-    add_subdirectory(external/PTL)
+    add_subdirectory(external/PTL EXCLUDE_FROM_ALL)

    omnitrace_restore_variables(
        BUILD_CONFIG
@@ -1,7 +1,6 @@
 # executable RPATH
 set(OMNITRACE_EXE_INSTALL_RPATH
-    "\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}:\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}/omnitrace:\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}/timemory/libunwind:\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}/dyninst-tpls/lib"
-    )
+    "\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}:\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}/omnitrace")

 # executables
 add_subdirectory(omnitrace-avail)
@@ -36,6 +36,10 @@ set_target_properties(
               INSTALL_RPATH_USE_LINK_PATH ON
               INSTALL_RPATH "${OMNITRACE_EXE_INSTALL_RPATH}")

+if(OMNITRACE_BUILD_DYNINST)
+    target_compile_definitions(omnitrace-exe PRIVATE OMNITRACE_BUILD_DYNINST=1)
+endif()
+
 omnitrace_strip_target(omnitrace-exe)

 if(CMAKE_BUILD_TYPE MATCHES "^(DEBUG|Debug)")
@@ -24,6 +24,7 @@
 #include "fwd.hpp"

 #include <cstring>
+#include <iterator>
 #include <timemory/config.hpp>
 #include <timemory/hash.hpp>
 #include <timemory/manager.hpp>
@@ -128,12 +129,20 @@ strset_t                                   print_formats        = { "txt", "json
 std::string                                modfunc_dump_dir     = {};
 auto regex_opts = std::regex_constants::egrep | std::regex_constants::optimize;

+#if defined(DYNINST_API_RT)
+auto _dyn_api_rt_paths = tim::delimit(DYNINST_API_RT, ":");
+#else
+auto _dyn_api_rt_paths = std::vector<std::string>{};
+#endif
+
 std::string
 get_absolute_exe_filepath(std::string exe_name, const std::string& env_path = "PATH");

 std::string
-get_absolute_lib_filepath(std::string        lib_name,
-                          const std::string& env_path = "LD_LIBRARY_PATH");
+get_absolute_lib_filepath(std::string              lib_name,
+                          const std::string&       env_path  = "LD_LIBRARY_PATH",
+                          std::vector<std::string> suffixes  = {},
+                          std::vector<std::string> fallbacks = {});

 bool
 file_exists(const std::string& name);
@@ -143,6 +152,9 @@ get_realpath(const std::string&);

 std::string
 get_cwd();
+
+void
+find_dyn_api_rt();
 }  // namespace

 //======================================================================================//
@@ -154,36 +166,8 @@ get_cwd();
 int
 main(int argc, char** argv)
 {
-#if defined(DYNINST_API_RT)
-    auto _dyn_api_rt_paths = tim::delimit(DYNINST_API_RT, ":");
-#else
-    auto _dyn_api_rt_paths = std::vector<std::string>{};
-#endif
-    auto _dyn_api_rt_abs = get_absolute_lib_filepath("libdyninstAPI_RT.so");
-    _dyn_api_rt_paths.insert(_dyn_api_rt_paths.begin(), _dyn_api_rt_abs);
-    for(auto&& itr : _dyn_api_rt_paths)
-    {
-        auto _file_exists = [](const std::string& _fname) {
-            struct stat _buffer;
-            if(stat(_fname.c_str(), &_buffer) == 0)
-                return (S_ISREG(_buffer.st_mode) != 0 || S_ISLNK(_buffer.st_mode) != 0);
-            return false;
-        };
-        if(_file_exists(itr))
-            tim::set_env<string_t>("DYNINSTAPI_RT_LIB", itr, 0);
-        else if(_file_exists(TIMEMORY_JOIN('/', itr, "libdyninstAPI_RT.so")))
-            tim::set_env<string_t>("DYNINSTAPI_RT_LIB",
-                                   TIMEMORY_JOIN('/', itr, "libdyninstAPI_RT.so"), 0);
-        else if(_file_exists(TIMEMORY_JOIN('/', itr, "libdyninstAPI_RT.a")))
-            tim::set_env<string_t>("DYNINSTAPI_RT_LIB",
-                                   TIMEMORY_JOIN('/', itr, "libdyninstAPI_RT.a"), 0);
-    }
-    verbprintf(0, "DYNINST_API_RT: %s\n",
-               tim::get_env<string_t>("DYNINSTAPI_RT_LIB", "").c_str());
-
    argv0 = argv[0];

-    bpatch                              = std::make_shared<patch_t>();
    address_space_t*      addr_space    = nullptr;
    string_t              mutname       = {};
    string_t              outfile       = {};
@@ -201,16 +185,6 @@ main(int argc, char** argv)
        { &overlapping_module_functions, false },
    };

-    bpatch->setTypeChecking(true);
-    bpatch->setSaveFPR(true);
-    bpatch->setDelayedParsing(true);
-    bpatch->setDebugParsing(false);
-    bpatch->setInstrStackFrames(false);
-    bpatch->setLivenessAnalysis(false);
-    bpatch->setBaseTrampDeletion(false);
-    bpatch->setTrampRecursive(false);
-    bpatch->setMergeTramp(true);
-
    std::set<std::string> dyninst_defs = { "TypeChecking", "SaveFPR", "DelayedParsing",
                                           "MergeTramp" };

@@ -733,7 +707,15 @@ main(int argc, char** argv)
        .count(1)
        .dtype("int")
        .action([](parser_t& p) { batch_size = p.get<size_t>("batch-size"); });
-
+    parser.add_argument({ "--dyninst-rt" }, "Path(s) to the dyninstAPI_RT library")
+        .dtype("filepath")
+        .min_count(1)
+        .action([](parser_t& _p) {
+            auto _v = _p.get<strvec_t>("dyninst-rt");
+            std::copy(_dyn_api_rt_paths.begin(), _dyn_api_rt_paths.end(),
+                      std::back_inserter(_v));
+            std::swap(_dyn_api_rt_paths, _v);
+        });
    parser
        .add_argument({ "--dyninst-options" },
                      "Advanced dyninst options: BPatch::set<OPTION>(bool), e.g. "
@@ -931,6 +913,8 @@ main(int argc, char** argv)
    //
    //----------------------------------------------------------------------------------//

+    find_dyn_api_rt();
+
    int dyninst_verb = 2;
    if(parser.exists("dyninst-options"))
    {
@@ -945,6 +929,17 @@ main(int argc, char** argv)
        return _ret;
    };

+    bpatch = std::make_shared<patch_t>();
+    bpatch->setTypeChecking(true);
+    bpatch->setSaveFPR(true);
+    bpatch->setDelayedParsing(true);
+    bpatch->setDebugParsing(false);
+    bpatch->setInstrStackFrames(false);
+    bpatch->setLivenessAnalysis(false);
+    bpatch->setBaseTrampDeletion(false);
+    bpatch->setTrampRecursive(false);
+    bpatch->setMergeTramp(true);
+
    bpatch->setTypeChecking(get_dyninst_option("TypeChecking"));
    bpatch->setSaveFPR(get_dyninst_option("SaveFPR"));
    bpatch->setDelayedParsing(get_dyninst_option("DelayedParsing"));
@@ -2247,7 +2242,9 @@ get_absolute_exe_filepath(std::string exe_name, const std::string& env_path)
 //======================================================================================//
 //
 std::string
-get_absolute_lib_filepath(std::string lib_name, const std::string& env_path)
+get_absolute_lib_filepath(std::string lib_name, const std::string& env_path,
+                          std::vector<std::string> suffixes,
+                          std::vector<std::string> fallbacks)
 {
    if(!lib_name.empty() && (!file_exists(lib_name) ||
                             std::regex_match(lib_name, std::regex("^[A-Za-z0-9].*"))))
@@ -2255,6 +2252,7 @@ get_absolute_lib_filepath(std::string lib_name, const std::string& env_path)
        auto _lib_orig = lib_name;
        auto _paths    = tim::delimit(
            std::string{ ".:" } + tim::get_env<std::string>(env_path, ""), ":");
+        std::copy(fallbacks.begin(), fallbacks.end(), std::back_inserter(_paths));
        for(auto& pitr : _paths)
        {
            if(file_exists(TIMEMORY_JOIN('/', pitr, lib_name)))
@@ -2264,6 +2262,17 @@ get_absolute_lib_filepath(std::string lib_name, const std::string& env_path)
                           lib_name.c_str());
                break;
            }
+            for(auto& sitr : suffixes)
+            {
+                if(sitr.empty()) continue;
+                if(file_exists(TIMEMORY_JOIN('/', pitr, sitr, lib_name)))
+                {
+                    lib_name = get_realpath(TIMEMORY_JOIN('/', pitr, sitr, lib_name));
+                    verbprintf(1, "Resolved '%s' to '%s'...\n", _lib_orig.c_str(),
+                               lib_name.c_str());
+                    break;
+                }
+            }
        }

        if(!file_exists(lib_name))
@@ -2307,4 +2316,93 @@ get_cwd()
    char cwd[PATH_MAX];
    return std::string{ getcwd(cwd, PATH_MAX) };
 }
+
+using tim::dirname;
+
+void
+find_dyn_api_rt()
+{
+    auto _exe_path = dirname(::get_realpath("/proc/self/exe"));
+
+    strvec_t _suffixes  = {};
+    strvec_t _fallbacks = {};
+
+    if(strcmp(::basename(_exe_path.c_str()), "bin") == 0)
+    {
+        _suffixes.emplace_back("omnitrace");
+        _suffixes.emplace_back("../lib");
+        _suffixes.emplace_back("../lib/omnitrace");
+        _fallbacks.emplace_back(_exe_path);
+    }
+    else
+    {
+        _fallbacks.emplace_back(tim::get_env<std::string>("PWD", "."));
+    }
+
+    std::copy(_dyn_api_rt_paths.begin(), _dyn_api_rt_paths.end(),
+              std::back_inserter(_fallbacks));
+
+#if defined(OMNITRACE_BUILD_DYNINST)
+    std::string _dyn_api_rt_base =
+        (binary_rewrite) ? "libomnitrace-rt" : "libdyninstAPI_RT";
+#else
+    std::string _dyn_api_rt_base = "libdyninstAPI_RT";
+#endif
+
+    auto _dyn_api_rt_abs = get_absolute_lib_filepath(
+        _dyn_api_rt_base + ".so", "LD_LIBRARY_PATH", _suffixes, _fallbacks);
+
+    if(_dyn_api_rt_abs != _dyn_api_rt_base + ".so")
+        _dyn_api_rt_paths.insert(_dyn_api_rt_paths.begin(), _dyn_api_rt_abs);
+    else
+    {
+        auto _dyn_api_rt_abs = get_absolute_lib_filepath(
+            _dyn_api_rt_base + ".a", "LIBRARY_PATH", _suffixes, _fallbacks);
+        if(_dyn_api_rt_abs != _dyn_api_rt_base + ".a")
+            _dyn_api_rt_paths.insert(_dyn_api_rt_paths.begin(), _dyn_api_rt_abs);
+    }
+
+    auto _rewriter_paths = tim::get_env<std::string>("DYNINST_REWRITER_PATHS", "");
+    for(auto itr : _dyn_api_rt_paths)
+    {
+        auto _file_exists = [](const std::string& _fname) {
+            struct stat _buffer;
+            if(stat(_fname.c_str(), &_buffer) == 0)
+                return (S_ISREG(_buffer.st_mode) != 0 || S_ISLNK(_buffer.st_mode) != 0);
+            return false;
+        };
+
+        auto _export = [&_rewriter_paths, &_file_exists](std::string _fname) {
+            int _overwrite =
+                (_file_exists(tim::get_env<string_t>("DYNINSTAPI_RT_LIB", ""))) ? 0 : 1;
+            tim::set_env<string_t>("DYNINSTAPI_RT_LIB", _fname, _overwrite);
+            _fname = tim::get_env<string_t>("DYNINSTAPI_RT_LIB", _fname);
+            tim::set_env<string_t>("DYNINST_REWRITER_PATHS",
+                                   TIMEMORY_JOIN(':', dirname(_fname), _rewriter_paths),
+                                   1);
+        };
+
+        auto _resolved = [&](std::string _fname) {
+            if(_file_exists(_fname))
+            {
+                _export(_fname);
+                return true;
+            }
+            _fname = get_absolute_lib_filepath(_fname, "LD_LIBRARY_PATH", _suffixes,
+                                               _fallbacks);
+            if(_file_exists(_fname))
+            {
+                _export(_fname);
+                return true;
+            }
+            return false;
+        };
+
+        if(_resolved(itr)) break;
+        if(_resolved(TIMEMORY_JOIN('/', itr, _dyn_api_rt_base + ".so"))) break;
+        if(_resolved(TIMEMORY_JOIN('/', itr, _dyn_api_rt_base + ".a"))) break;
+    }
+    auto _v = tim::get_env<string_t>("DYNINSTAPI_RT_LIB", "");
+    verbprintf(0, "DYNINST_API_RT: %s\n", (_v.empty()) ? "<unknown>" : _v.c_str());
+}
 }  // namespace
@@ -13,13 +13,8 @@ if(_INSTALL_RPATH)
    list(REMOVE_DUPLICATES _INSTALL_RPATH)
 endif()
 string(REPLACE ";" ":" _INSTALL_RPATH "${_INSTALL_RPATH}")
-string(
-    REPLACE
-        "::"
-        ":"
-        OMNITRACE_LIB_INSTALL_RPATH
-        "\$ORIGIN:\$ORIGIN/omnitrace:\$ORIGIN/timemory/libunwind:\$ORIGIN/dyninst-tpls/libs:${_INSTALL_RPATH}"
-    )
+string(REPLACE "::" ":" OMNITRACE_LIB_INSTALL_RPATH
+               "\$ORIGIN:\$ORIGIN/omnitrace:${_INSTALL_RPATH}")

 add_subdirectory(common)
 add_subdirectory(omnitrace)