There are some header defined functions without the inline keyword

[rafaelpfreire]

Some of the functions in the file vectorfp16e.h (namely to_float and to_float16 and its multiple signatures) are not defined as inline functions which end up giving me a multiple definition error in case this header file is included more the once by other files.

[AgnerF]

These functions are too big for inlining to be optimal. The #ifndef VECTORFP16E_H should prevent the file from being included more than once in the same module. The functions are declared static which should prevent multiple instances in different modules from clashing. The file may have been messed with if you get a linker error. Please try to reload the original version.

[rafaelpfreire]

Thanks for your fast response!

Before giving you my rationale, I'd like to kindly ask you to try this yourself. Create the following files on the same directory of this library source code and run the following gcc commands (my machine march is alderlake)

header1.h

#pragma once

#include "vectorfp16.h"

Vec16f my_function1();

header1.c

#include "header1.h"

Vec16f my_function1() {
    static Vec16h my_var{0.0f};
    return to_float(my_var++);
}

header2.h

#pragma once

#include "vectorfp16.h"

Vec16f my_function2();

header2.c

#include "header2.h"

Vec16f my_function2() {
    static Vec16h my_var{1.0f};
    return to_float(my_var++);
}

main.c

#include "header1.h"
#include "header2.h"

int main() {
    Vec16f a = my_function1();
    Vec16f b = my_function2();
    return 0;
}

g++ -I./ -march=alderlake -c header1.c -o header1.o
g++ -I./ -march=alderlake -c header2.c -o header2.o
g++ -I./ -march=alderlake -c main.c -o main.o
g++ -march=alderlake main.o header1.o header2.o -o my_binary

The last link command gives me this error

/usr/bin/ld: header1.o: in function `to_float(Vec16h)':
header1.c:(.text+0x334): multiple definition of `to_float(Vec16h)'; main.o:main.c:(.text+0x1fa): first defined here
/usr/bin/ld: header1.o: in function `to_float16(Vec16f)':
header1.c:(.text+0x39e): multiple definition of `to_float16(Vec16f)'; main.o:main.c:(.text+0x264): first defined here
/usr/bin/ld: header2.o: in function `to_float(Vec16h)':
header2.c:(.text+0x334): multiple definition of `to_float(Vec16h)'; main.o:main.c:(.text+0x1fa): first defined here
/usr/bin/ld: header2.o: in function `to_float16(Vec16f)':
header2.c:(.text+0x39e): multiple definition of `to_float16(Vec16f)'; main.o:main.c:(.text+0x264): first defined here
collect2: error: ld returned 1 exit status

The thing is that nothing is compiled (i.e. turned into machine code) in the header file itself. The C files that include the header files are the ones that end up with the function symbol. So even with include guards and the static keyword, the to_float symbol end up in both header1.o and header2.o, because they are the ones that actually "defined" the function, which violates the One Definition Rule (ODR).

# You'll find exactly the same symbols in both object files
objdump -d header1.o | grep to_float
objdump -d header2.o | grep to_float

This has nothing to do with performance. The only way to the "define" a free function in a header file is by making it inline, so it won't be actually translated to a symbol when you include the header and compile the code. The other two ways would be using a function template or define the function inside a class, which will make it implicitly inlined anyway.

If you really don't want it to be inline, you should declare it in a header file and define it in a C file. But I don't think you're willing to do this because the idea of this library is to be header only as I understood.

[AgnerF]

A static nonmember function has internal linkage. There should be no name clash. Can you please try if other compilers do the same?
A possible solution, though clumsy, would be to make the function a template

[rafaelpfreire]

Same thing with clang

$ clang++ -march=alderlake main.o header1.o header2.o -o my_binary
/usr/bin/ld: header1.o: in function `to_float(Vec16h)':
header1.c:(.text+0x0): multiple definition of `to_float(Vec16h)'; main.o:main.c:(.text+0x0): first defined here
/usr/bin/ld: header1.o: in function `to_float16(Vec16f)':
header1.c:(.text+0xe0): multiple definition of `to_float16(Vec16f)'; main.o:main.c:(.text+0xe0): first defined here
/usr/bin/ld: header2.o: in function `to_float(Vec16h)':
header2.c:(.text+0x0): multiple definition of `to_float(Vec16h)'; main.o:main.c:(.text+0x0): first defined here
/usr/bin/ld: header2.o: in function `to_float16(Vec16f)':
header2.c:(.text+0xe0): multiple definition of `to_float16(Vec16f)'; main.o:main.c:(.text+0xe0): first defined here

$ clang++ --version
Ubuntu clang version 14.0.0-1ubuntu1.1
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin

[AgnerF]

I don't understand why this happens. The function has internal linkage according to https://en.cppreference.com/w/cpp/language/storage_duration.html

[rafaelpfreire]

It's true that a static nonmember function has internal linkage. This means that the function could only be found within the translation unit that it was defined. However, a header file can't be considered a translation unit and defining a free function static in the header is a contradiction. Which translation unit should this function be visible in this case since it wasn't defined in a translation unit? You are expecting the compiler to make a copy with a different namespace for each of the object files, but apparently it's not what it's doing.

[rafaelpfreire]

If you declare a function static in the header and make the definition in the C file, this function can't be accessed anywhere else except the given C file. In this case the scope is very well defined. However, when you declare and define a function static in the header (which is not a translation unit), the compiler definitely isn't creating a unique symbol for each of the files that are including it.