How to build a shared library with fpm

[synthfi]

Newbie here

Not sure if I'm just not searching hard enough. Is it possible to build a shared library with fpm, kinda like how cargo can with cargo new <my_project> --lib ?

[milancurcic]

I don't think it's possible yet (@awvwgk or @LKedward can confirm), but for now you can do this step by hand. For example with GFortran:

milan@mars:~/Work/fortran$ fpm new --lib hello-shared
 + mkdir -p hello-shared
 + cd hello-shared
 + mkdir -p hello-shared/src
 + git init hello-shared
Initialized empty Git repository in /home/milan/Work/fortran/hello-shared/.git/
fpm: Leaving directory '/home'
milan@mars:~/Work/fortran$ cd hello-shared/
milan@mars:~/Work/fortran/hello-shared$ fpm build
 + mkdir -p build/dependencies
 + mkdir -p build/gfortran_2A42023B310FA28D
 + mkdir -p build/gfortran_2A42023B310FA28D/hello-shared/
 + gfortran -c ././src/hello-shared.f90  -Wall -Wextra -Wimplicit-interface -fPIC -fmax-errors=1 -g -fcheck=bounds -fcheck=array-temps -fbacktrace -fcoarray=single -J build/gfortran_2A42023B310FA28D -Ibuild/gfortran_2A42023B310FA28D -o build/gfortran_2A42023B310FA28D/hello-shared/src_hello-shared.f90.o
 + ar -rs build/gfortran_2A42023B310FA28D/hello-shared/libhello-shared.a build/gfortran_2A42023B310FA28D/hello-shared/src_hello-shared.f90.o
ar: creating build/gfortran_2A42023B310FA28D/hello-shared/libhello-shared.a
milan@mars:~/Work/fortran/hello-shared$ gfortran -shared build/gfortran_2A42023B310FA28D/hello-shared/*.o -o libhello-shared.so
milan@mars:~/Work/fortran/hello-shared$ ldd libhello-shared.so
	linux-vdso.so.1 (0x00007ffc477fb000)
	libgfortran.so.5 => /lib/x86_64-linux-gnu/libgfortran.so.5 (0x00007fd7af30c000)
	libquadmath.so.0 => /lib/x86_64-linux-gnu/libquadmath.so.0 (0x00007fd7af2c2000)
	libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007fd7af173000)
	libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007fd7af158000)
	libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fd7aef66000)
	/lib64/ld-linux-x86-64.so.2 (0x00007fd7af5f4000)

[awvwgk]

We currently mainly target the creation of executables with fpm. Libraries both static and dynamic are currently not really well supported, but on our roadmap, especially for compatibility with other non-Fortran languages. When using fpm only for Fortran projects, which are fpm compatible building (shared) libraries seldom comes up, however for projects which interface via C this is highly relevant.

There are a couple of things to consider when building shared libraries, especially when considering the particularities of different platforms (rpath linking on Unix, dlls/importlibs on Windows, ...), which we haven't designed yet.

[jacobwilliams]

Agree that this is a very important use case that we should eventually support (e.g., for building shared libs for use by Python). FoBiS has this feature, and it's the last remaining thing I use FoBiS for since I do need to build shared libs and it makes that very easy.

[jalvesz]

Hi, I wanted to continue the discussion around this topic. Since I'm trying to use more and more fpm, creation of shared libraries is a key step since I use them for (a) calling within an exe and (b) for Python APIs development.

I thought about some ideas for how to manage this from the fpm-user perspective, and then see if from there something can be implemented:

• On the fpm.toml file an option could be included such as

[install]
shared=true

• On the options side, maybe let the user include extra flags specific to the shared library with something like
  --flags_shared "<option>"

For instance: with gfortran on windows, doing gfortran -shared -static enables creating a standalone dll that does not depend on runtime libraries by creating a fatter binary.

With something like this, one could then invoke
fpm build --flags "<static_lib_options>" --flags_shared "<extra_options_for_shared_object>"

What are your thoughts ?

P.S.:

For a single file I have compiled the following compile patterns :

gfortran + linux

>gfortran -cpp -O3 -fpic -c <name>.f90
>gfortran -shared -o lib<name>.so <name>.o

gfortran + windows

>gfortran -cpp -O3 -fpic -c <name>.f90
>gfortran -shared -static -o lib<name>.so <name>.o

ifort + linux

>ifort -fpp -O3 -fpic -c <name>.f90
>ifort -shared -o lib<name>.so <name>.o

ifort + windows

>ifort -cpp -O3 -fpic -c <name>.f90
>ifort -dll -exe:<name>.dll <name>.obj

Here some findings that you might be aware of but just in case they can be useful:

• While the -fpp & -cpp are needed to preprocess the macros "#if" gfortran doesn't actually need the decorators, and only ifort on windows, thus one could write a subroutine like:

subroutine myfun(args) bind(c)
#if _WIN32 & __INTEL_COMPILER
    !DEC$ ATTRIBUTES DLLEXPORT :: myfun
#endif 
...
end subroutine

That will be portable with any permutation of (gfortran,ifort)+(windows,linux)

• While the "-fpic" flag on the GNU compiler side is needed to ensure Position Independent Code compilation for the shared object, using mingw64 seems to be unnecessary and just ignored.

[everythingfunctional]

The implementation of this feature doesn't seem too difficult (when creating static library, also create a shared library if it was asked for). I think the interesting design question is exactly how to expose the options to the user. My inclination is that fpm build and fpm install (and maybe run and test too) have a --shared option which instructs a shared library to be built. Then also a --shared_flags "options to shared lib creation" option is provided. There's probably some nuances and edge cases that need to be considered with respect to the various other compiler flags, but this probably gets us most of the way.