[macOS] Standardize dynamic library paths using @rpath (#1146)

Author: perazz

src/fpm.f90

@@ -604,6 +604,12 @@ subroutine cmd_run(settings,test)
                 if (settings%runner/=' ')     run_cmd = settings%runner_command()//' '//run_cmd
                 if (allocated(settings%args)) run_cmd = run_cmd//" "//settings%args
 
+                ! System Integrity Protection will not propagate the .dylib environment variables
+                ! to the child process: add paths manually
+                if (get_os_type()==OS_MACOS)  run_cmd = "env DYLD_LIBRARY_PATH=" // &
+                                                         get_env("DYLD_LIBRARY_PATH","") // &
+                                                         " " // run_cmd
+
                 call run(run_cmd,echo=settings%verbose,exitstat=stat(i))                
 
             else
@@ -809,8 +815,7 @@ function save_library_path() result(path)
     case (OS_WINDOWS)
         path = get_env("PATH", default="")
     case (OS_MACOS)
-        ! macOS does not use LD_LIBRARY_PATH by default for `.dylib`
-        allocate(character(0) :: path)
+        path = get_env("DYLD_LIBRARY_PATH", default="")
     case default ! UNIX/Linux
         path = get_env("LD_LIBRARY_PATH", default="")
     end select
@@ -823,7 +828,7 @@ subroutine set_library_path(model, targets, error)
     type(error_t), allocatable, intent(out) :: error
 
     type(string_t), allocatable :: shared_lib_dirs(:)
-    character(len=:), allocatable :: new_path, sep
+    character(len=:), allocatable :: new_path, sep, current
     logical :: success
     integer :: i
 
@@ -839,30 +844,32 @@ subroutine set_library_path(model, targets, error)
     end select
 
     ! Join the directories into a path string
-    ! Manually join paths
     new_path = ""
     do i = 1, size(shared_lib_dirs)
         if (i > 1) new_path = new_path // sep
         new_path = new_path // shared_lib_dirs(i)%s
     end do    
+    
+    ! Get current library path
+    current = save_library_path()
 
     ! Set the appropriate environment variable
     select case (get_os_type())
     case (OS_WINDOWS)
-        success = set_env("PATH", new_path // sep // get_env("PATH", default=""))
+        success = set_env("PATH", new_path // sep // current)
     case (OS_MACOS)
-        ! Typically not required for local .dylib use, noop or DYLD_LIBRARY_PATH if needed
-        success = .true.
+        success = set_env("DYLD_LIBRARY_PATH", new_path // sep // current)
     case default ! UNIX/Linux
-        success = set_env("LD_LIBRARY_PATH", new_path // sep // get_env("LD_LIBRARY_PATH", default=""))
+        success = set_env("LD_LIBRARY_PATH", new_path // sep // current)
     end select
 
-    if (.not.success) call fatal_error(error," Cannot set library path: "//new_path)
+    if (.not.success) call fatal_error(error,"Cannot set library path: "//new_path)
 
 end subroutine set_library_path
 
+
 !> Restore a previously saved runtime library path
-subroutine restore_library_path(saved_path,error)
+subroutine restore_library_path(saved_path, error)
     character(*), intent(in) :: saved_path
     type(error_t), allocatable, intent(out) :: error
     logical :: success
@@ -871,16 +878,16 @@ subroutine restore_library_path(saved_path,error)
     case (OS_WINDOWS)
         success = set_env("PATH", saved_path)
     case (OS_MACOS)
-        ! noop
-        success = .true.
+        success = set_env("DYLD_LIBRARY_PATH", saved_path)
     case default ! UNIX/Linux
         success = set_env("LD_LIBRARY_PATH", saved_path)
     end select
 
-    if (.not.success) call fatal_error(error, "Cannot restore library path "//saved_path)
+    if (.not.success) call fatal_error(error, "Cannot restore library path: "//saved_path)
 
 end subroutine restore_library_path
 
 
 
+
 end module fpm

src/fpm/installer.f90

@@ -5,10 +5,11 @@
 !> to any directory within the prefix.
 module fpm_installer
   use, intrinsic :: iso_fortran_env, only : output_unit
-  use fpm_environment, only : get_os_type, os_is_unix, OS_WINDOWS
+  use fpm_environment, only : get_os_type, os_is_unix, OS_WINDOWS, OS_MACOS
   use fpm_error, only : error_t, fatal_error
   use fpm_targets, only: build_target_t, FPM_TARGET_ARCHIVE, FPM_TARGET_SHARED, FPM_TARGET_NAME
-  use fpm_filesystem, only : join_path, mkdir, exists, unix_path, windows_path, get_local_prefix
+  use fpm_filesystem, only : join_path, mkdir, exists, unix_path, windows_path, get_local_prefix, &
+      basename
 
   implicit none
   private
@@ -37,6 +38,8 @@ module fpm_installer
     !> Cached operating system
     integer :: os
   contains
+    !> Evaluate the installation path
+    procedure :: install_destination  
     !> Install an executable in its correct subdirectory
     procedure :: install_executable
     !> Install a library in its correct subdirectory
@@ -51,6 +54,7 @@ module fpm_installer
     procedure :: run
     !> Create a new directory in the prefix, type-bound for unit testing purposes
     procedure :: make_dir
+
   end type installer_t
 
   !> Default name of the binary subdirectory
@@ -177,6 +181,8 @@ subroutine install_executable(self, executable, error)
     !> Error handling
     type(error_t), allocatable, intent(out) :: error
     integer :: ll
+    
+    character(len=:), allocatable :: exe_path, cmd
 
     if (.not.os_is_unix(self%os)) then
         ll = len(executable)
@@ -185,9 +191,26 @@ subroutine install_executable(self, executable, error)
             return
         end if
     end if
-
+    
     call self%install(executable, self%bindir, error)
 
+    ! on MacOS, add two relative paths for search of dynamic library dependencies: 
+    add_rpath: if (self%os==OS_MACOS) then  
+        
+        exe_path = join_path(self%install_destination(self%bindir) , basename(executable))
+        
+        ! First path: for bin/lib/include structure
+        cmd = "install_name_tool -add_rpath @executable_path/../lib " // exe_path
+        call self%run(cmd, error)
+        if (allocated(error)) return
+
+        ! Second path: same as executable folder
+        cmd = "install_name_tool -add_rpath @executable_path " // exe_path
+        call self%run(cmd, error)
+        if (allocated(error)) return
+        
+    end if add_rpath
+
   end subroutine install_executable
 
   !> Install a library in its correct subdirectory
@@ -278,12 +301,7 @@ subroutine install(self, source, destination, error)
 
     character(len=:), allocatable :: install_dest
 
-    install_dest = join_path(self%prefix, destination)
-    if (os_is_unix(self%os)) then
-      install_dest = unix_path(install_dest)
-    else
-      install_dest = windows_path(install_dest)
-    end if
+    install_dest = self%install_destination(destination)
     call self%make_dir(install_dest, error)
     if (allocated(error)) return
 
@@ -303,6 +321,24 @@ subroutine install(self, source, destination, error)
     if (allocated(error)) return
 
   end subroutine install
+  
+  !> Evaluate the installation path
+  function install_destination(self, destination) result(install_dest)
+    !> Instance of the installer
+    class(installer_t), intent(inout) :: self
+    !> Path to the destination inside the prefix
+    character(len=*), intent(in) :: destination    
+    
+    character(len=:), allocatable :: install_dest
+
+    install_dest = join_path(self%prefix, destination)
+    if (os_is_unix(self%os)) then
+      install_dest = unix_path(install_dest)
+    else
+      install_dest = windows_path(install_dest)
+    end if    
+    
+  end function install_destination
 
   !> Create a new directory in the prefix
   subroutine make_dir(self, dir, error)

src/fpm_compiler.F90

@@ -105,6 +105,10 @@ module fpm_compiler
     procedure :: get_main_flags
     !> Get library export flags
     procedure :: get_export_flags    
+    !> Get library install name flags
+    procedure :: get_install_name_flags
+    !> Generate header padding flags for macOS executables
+    procedure :: get_headerpad_flags
     !> Compile a Fortran object
     procedure :: compile_fortran
     !> Compile a C object
@@ -1117,6 +1121,48 @@ function get_export_flags(self, target_dir, target_name) result(export_flags)
 
 end function get_export_flags
 
+!>
+!> Generate `install_name` flag for a shared library build on macOS
+!>
+function get_install_name_flags(self, target_dir, target_name) result(flags)
+    class(compiler_t), intent(in) :: self
+    character(len=*), intent(in) :: target_dir, target_name
+    character(len=:), allocatable :: flags
+    character(len=:), allocatable :: library_file
+
+    if (get_os_type() /= OS_MACOS) then
+        flags = ""
+        return
+    end if
+
+    ! Shared library basename (e.g., libfoo.dylib)
+    if (str_ends_with(target_name, ".dylib")) then
+        library_file = target_name        
+    else
+        library_file = library_filename(target_name,.true.,.false.,OS_MACOS)
+    end if
+    
+    flags = " -Wl,-install_name,@rpath/" // library_file
+
+end function get_install_name_flags
+
+!>
+!> Generate header padding flags for install_name_tool compatibility on macOS
+!>
+function get_headerpad_flags(self) result(flags)
+    class(compiler_t), intent(in) :: self
+    character(len=:), allocatable :: flags
+
+    if (get_os_type() /= OS_MACOS) then
+        flags = ""
+        return
+    end if
+
+    ! Reserve enough space in the Mach-O header to safely add two install_name or rpath later
+    flags = " -Wl,-headerpad,0x200"
+
+end function get_headerpad_flags
+
 !> Create new compiler instance
 subroutine new_compiler(self, fc, cc, cxx, echo, verbose)
     !> New instance of the compiler

src/fpm_targets.f90

@@ -1142,8 +1142,13 @@ subroutine resolve_target_linking(targets, model, library, error)
                     target%link_flags = target%link_flags // " " // &
                                         model%compiler%get_export_flags(target%output_dir,target%package_name)
 
+                    ! Add install_name flag (macOS only)
+                    target%link_flags = target%link_flags // " " // &
+                                        model%compiler%get_install_name_flags(target%output_dir, target%package_name)                    
+                    
                     ! Add global link flags (e.g., system-wide libraries)
-                    target%link_flags = target%link_flags // " " // global_link_flags                
+                    target%link_flags = target%link_flags // " " // global_link_flags     
+                            
 
                 case (FPM_TARGET_EXECUTABLE)
 
@@ -1176,7 +1181,12 @@ subroutine resolve_target_linking(targets, model, library, error)
                         target%link_flags = model%get_package_libraries_link(target%package_name, &
                                                                             target%link_flags, &
                                                                             error=error, &
-                                                                            exclude_self=.not.has_self_lib)                                                
+                                                                            exclude_self=.not.has_self_lib)   
+                                                                            
+                        
+                        ! On macOS, add room for 2 install_name_tool paths
+                        target%link_flags = target%link_flags // model%compiler%get_headerpad_flags()
+                        
                     end if
 
                     if (allocated(target%link_libraries)) then