How can I "link" a CMake object library to another CMake object library?

Question

I have a main -> that calls a function from object2 -> that calls a function from object1. Both object2 and object1 are CMake object libraries. Objects are passed along the chain using $<TARGET_OBJECTS:xxx and usage requirements using target_link_libraries.

Project structure:

project
 |-- main
 |    |-- main.c
 |-- object2
 |    |-- object2.h
 |    |-- object2.c
 |-- object1
 |    |-- object1.h
 |    |-- object1.c
 |-- CMakeLists.txt

Contents of

// CMakeLists.txt

project(objlibs)

# Object library 1
add_library(ObjectLibrary1 OBJECT object1/object1.c)
target_include_directories(ObjectLibrary1 INTERFACE object1)

# Object library 2
add_library(ObjectLibrary2 OBJECT object2/object2.c $<TARGET_OBJECTS:ObjectLibrary1>)
target_include_directories(ObjectLibrary2 INTERFACE object2)
target_link_libraries(ObjectLibrary2 PUBLIC ObjectLibrary1)

# Final executable or library
add_executable(MyTarget
    main/main.c
    $<TARGET_OBJECTS:ObjectLibrary2>
)
target_link_libraries(MyTarget PRIVATE ObjectLibrary2)

Trying to build, I get a linker error.

ld.exe: CMakeFiles/ObjectLibrary2.dir/object2/object2.obj:object2.c:(.text+0x18): undefined reference to `obj1func'
collect2.exe: error: ld returned 1 exit status
ninja: build stopped: subcommand failed.

I noticed that if I modify the add_executable statement as follows (i.e. adding the $<TARGET_OBJECTS:ObjectLibrary1> line), linking goes through without issues.

add_executable(MyTarget
    main/main.c
    $<TARGET_OBJECTS:ObjectLibrary2>
    $<TARGET_OBJECTS:ObjectLibrary1>
)

Since ObjectLibrary2 requires a symbol (the very obj1func) from ObjectLibrary1, I would expect that $<TARGET_OBJECTS:ObjectLibrary1> (as shown in my working try) would be redundant.

CMake version: 3.25.2

// object1.h
#ifndef OBJECT1_H
#define OBJECT1_H
void obj1func(void);
#endif // OBJECT1_H

// object1.c
#include "object1.h"
#include <stdio.h>
void obj1func(void){
    printf("obj1func\n");
}

// object2.h
#ifndef OBJECT2_H
#define OBJECT2_H
void obj2func(void);
#endif // OBJECT2_H

// object2.c
#include "object2.h"
#include <stdio.h>
#include "object1.h"
void obj2func(void){
    printf("obj2func\n");
    obj1func();
}

// main.c
#include <stdio.h>
#include "object2.h"
int main(){
    printf("Hello world\n");
    obj2func();
}

I have tried the above with all combinations:

• WSL (Ubuntu 20.04.5 LTS), Ninja (1.10.0), clang (10.0.0)
• WSL (Ubuntu 20.04.5 LTS), makefiles (4.2.1), gcc (9.4.0)
• Windows (10 22H2 19045.2486), Visual Studio 16, MSVC (19.29.30146.0)
• Windows (10 22H2 19045.2486), Ninja (1.11.0), clang (15.0.0)
• Windows (10 22H2 19045.2486), makefiles (4.3 for Win32), gcc (12.2.0)

The sequence of cmake commands is as follows. Out of source, so that I can quickly rm -rf the build tree/artifacts; building in source makes no difference.

cmake -B build/main -S .
cmake --build build/main --config Debug --verbose --clean-first

In all cases, the issue persists.

Answer 1

EDIT: Illustrated my answer. Please note that they might be inaccuracies here, as it's been some time since I've studied this.

I've added this graph to better illustrate what I tried to explain in the comments/here. It shows a very simplified and probably not as accurate demonstration of what happens when you link a static library (which is an archive of object files with a symbol index). Note that index is probably not the correct term, but rather symbol table (suggest an edit if you find inaccuracies please).

┌─────┐ linking    ┌────────┐
│lib.a├─┬─────────►│some.elf│
└─────┘ │       ▲  └────────┘
        │u      │
        │n      │
        │p      │p u
        │a      │a p
        │c      │c d
        │k      │k a
        ▼       │  t
     ┌─────┐    │i e
     │index│    │n
     └─────┴┐   │t i
            │l  │o n
            │o  │  d
            │o  │  e
            │k  │  x
            │u  │
            │p  │
  ┌───┐   ┌─▼─┐ │
  │a.o│   │b.o├─┘
  └───┘   └───┘

If you wish to "link" object files, then the equivalent isn't linking but rather packing them into their "final resting place" and updating the symbol table so that the binary knows where this symbol is located. Which in your case is the executable file.

Hence why adding the Object1Library into the executable doesn't yield any errors.

Linking object files doens't make any sense, beacuse object files are missing this symbol table, they are just symbols. So if you "just link" then you aren't updating anything in the object file.

What you want to do is outlined below:

Either add_library and pack the object files into an archive with a symbol table or

add them to the executable via add_executable which adds them to the executable and updates the symbol table there or

just create a new object file altogether.

---

To expand on my comments I will start by posting a link to a different SO question explaining the difference between object files and libraries. There is a huge misconception between what is what here, especially because CMake coined the term "Object libraries".

In short: think of objects as a collection of symbols. While a library is not just a collection of symbols but also has (let's call it) some form of a map to these symbols.

Linking an object file to an object file doesn't make sense if you think about it that way. It makes sense to create some archive with this map that tells the linker where to look for individual symbols.

Your sample will break and give the error if I remove the Object1Library object files from the add_executable.

To fix this we can create this "dummy archive" like so:

add_library(dummy_archive STATIC) #Note that I'm not adding any files!
target_link_libraries(dummy_archive ObjectLibrary2 ObjectLibrary1)

add_executable(MyTarget main/main.c)
target_link_libraries(MyTarget PRIVATE dummy_archive)

Try to add this snippet and you will see it finally works. This is "how you link object libraries together".