Transitive dependencies with different linkage to third-party libraries - cmake

Question

I have a little bit of a convoluted question. I have a 3rd party dependency, which comes in static (libthird.a) and shared pic form (libthird.so).
I have a library, util, that depends on libthird.
And I have applications that depend on util that want to link libthird statically, and I have some shared libraries I need to produce that depend on util and need to link libthird dynamically.
My current (working) approach is something like the following:
add_library(third INTERFACE)
target_link_libraries(third INTERFACE /path/to/libthird.a)
add_library(third_shared INTERFACE)
target_link_libraries(third_shared INTERFACE /path/to/libthird.so)
add_library(util ${UTIL_SOURCES})
add_library(util_shared ${UTIL_SOURCES}) # same sources again!!
target_link_libraries(util PUBLIC third)
target_link_libraries(util_shared PUBLIC third_shared)
add_executable(some_app ...)
target_link_libraries(some_app PRIVATE util)
add_library(some_shared_object ...)
target_link_libraries(some_shared_object PUBLIC util_shared)
This works. But I'm building util (and, in reality, another half dozen libraries or so) twice... just to get different linker dependencies. Is there a saner way of doing this in cmake?
If I just target_link_libraries() on the top-level some_app and some_shared_object, I get the linker flags emitted in the wrong order, since util does depend on third.

Answer 1

The approach that you're taking is definitely one I've seen and also used myself before. It is fine if it is used for a small archive and/or one-off usage.
For the following examples, I assume a project structure like the following:
foo/
CMakeLists.txt
include/
foo.h
src/
foo.c
So, I've also (naively?) used the following approach based on the knowledge that you can create (on Unix-based systems at least) a shared library from a static archive.
project(foo C)
set(SOURCES
"src/foo.c")
set(LIBNAME "foo")
add_library(${LIBNAME} STATIC ${SOURCES})
target_include_directories(${LIBNAME} PUBLIC "include")
target_compile_options(${LIBNAME} PUBLIC "-fPIC")
#
get_property(CUR_PREFIX TARGET ${LIBNAME} PROPERTY PREFIX)
get_property(CUR_SUFFIX TARGET ${LIBNAME} PROPERTY SUFFIX)
get_property(CUR_NAME TARGET ${LIBNAME} PROPERTY NAME)
get_property(CUR_OUTPUT_NAME TARGET ${LIBNAME} PROPERTY OUTPUT_NAME)
get_property(CUR_ARCHIVE_OUTPUT_NAME TARGET ${LIBNAME} PROPERTY ARCHIVE_OUTPUT_NAME)
message(STATUS "prefix: ${CUR_PREFIX}")
message(STATUS "suffix: ${CUR_SUFFIX}")
message(STATUS "name: ${CUR_NAME}")
message(STATUS "output name: ${CUR_OUTPUT_NAME}")
message(STATUS "archive name: ${CUR_ARCHIVE_OUTPUT_NAME}")
add_custom_command(TARGET ${LIBNAME} POST_BUILD
COMMAND ${CMAKE_C_COMPILER} -shared -o libfoo.so -Wl,--whole-archive libfoo.a -Wl,--no-whole-archive
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
My unresolved problem with this approach is that I haven't found a reliable and portable way to get the name of the static archive (libfoo.a). Hence, all those message commands for the target properties; they might behave differently on your platforms.
The most efficient way, that is also well-supported by cmake, is to use an object library:
# cmake file
cmake_minimum_required(VERSION 3.2)
project(foo C)
set(SOURCES
"src/foo.c")
set(LIBNAME "foo")
set(LIBNAME_OBJ "${LIBNAME}_obj")
add_library(${LIBNAME_OBJ} OBJECT ${SOURCES})
target_include_directories(${LIBNAME_OBJ} PUBLIC "include")
target_compile_options(${LIBNAME_OBJ} PUBLIC "-fPIC")
#
add_library(${LIBNAME} SHARED $<TARGET_OBJECTS:${LIBNAME_OBJ}>)
add_library(${LIBNAME}_static STATIC $<TARGET_OBJECTS:${LIBNAME_OBJ}>)
All examples were tested with cmake version 3.6.1.
Hope this helps. Let us know, if you've found a better way.