Allow a specific function to be undefined, as long as it's never called at runtime

Question

I have several source files, which are compiled and linked into several executables. Some executables don't link some of the files.

I'm getting undefined reference errors, because the calls to the missing functions are still present in the code, even though they will never happen at runtime. I'm looking for a way to disable those errors (and if the call actually happens, crashing is fine).

Ultimately, this boils down to following: (I want this code to build and run)

1.h

#pragma once

struct A
{
    /*??*/ void foo();
    /*??*/ void bar();
};

1.cpp

#include "1.h"

int main()
{
    A a;

    a.foo(); // foo!

    volatile bool f = false;
    if (f)
        a.bar();
}

2.cpp

#include <iostream>

#include "1.h"

void A::foo() {std::cout << "foo\n";}

This obviously gives me undefined reference errors.

I want to support MSVC, MinGW, Linux, and Emscripten.

For Linux and Emscripten, I found that adding __attribute__((__weak__)) to the declarations (at /**/) does exactly what I want (no linker errors, calling an undefined function crashes at runtime).

For MSVC, I found this pragma: _Pragma("comment(linker, \"/alternatename:??=fallback\")"), where ?? is the mangled name of such a function, and fallback is the name of the fallback symbol, which can be something like extern "C" const std::nullptr_t fallback = nullptr;.

I can use a macro to insert the function name into the pragma, so I end up with:

struct A
{
    MAYBE_UNDEFINED(mangled_name_of_foo) void foo();
    MAYBE_UNDEFINED(mangled_name_of_bar) void bar();
};

, which expands to the pragma on MSVC, and to __attribute__((__weak__)) otherwise.

But I'm still having issues with MinGW. Adding __attribute__((__weak__)) like on Linux doesn't work, the resulting application segfaults on a.foo(); (bug report).

It starts working if the definitions don't see __attribute__((__weak__)) (so it needs to be conditionally disabled with macros), but I really don't like the syntax.

Having to define a unique macro per source file to conditionally add __weak__ is annoying, so I'm looking for a more bearable syntax to do the same thing. Ideally just a macro I can just add to the declarations and/or definitions.

I also tried "weak aliases" on MinGW, but no cigar:

#ifndef FOO
#define FOO
#endif

struct A
{
    FOO void foo();
    FOO void bar();
};

Then, in a separate source file:

extern "C" void fallback() {}
#define FOO __attribute__((__weak__, __alias__("fallback")))
#include "1.h"

This still gives me undefined references, unless I add __weak__ to the declarations as well, at which point the code links, but crashes at a.foo(); (which makes it no different to not having weak aliases at all, and just leaving weak functions undefined).

You could make `foo` and `bar` null function pointers then have wherever those functions are defined set the pointers on load? — Alan Birtles, Aug 14 '23 at 14:22
The code provided **has** to link `A::bar`. If it were changed to `constexpr bool f = false;` and `if constexpr (f) a.bar();` then it won't link `A::bar`. — Eljay, Aug 14 '23 at 14:24
@AlanBirtles I'm trying to make this change as unintrusive as possible. I'm trying to add this to an existing codebase, so I'm trying to write a simple macro I can slap onto those functions, without forcing my teammates to write the code to load each individual function pointer. — HolyBlackCat, Aug 14 '23 at 14:25
@Eljay Well, and I don't want to link it. That's the question. I found ways to do that on all platforms I care about, except one. — HolyBlackCat, Aug 14 '23 at 14:26
I guess having a "fallback lib" implementing the functions and linking it last is not an option for you... — fabian, Aug 14 '23 at 17:46
The gnu linker scans from left to right and uses the first matching symbol it finds so by putting fall backs on the end of your linker command they would only be used to clear up any remaining unresolved symbols — Alan Birtles, Aug 14 '23 at 22:15
@AlanBirtles I tried it, but LD gives me duplicate definition errors. [Here's the code](https://pastebin.com/2Qh6aa8U), and the command is: `rm -f lib2.a lib3.a && g++ -c 2.cpp && g++ -c 3.cpp && ar cr lib2.a 2.o && ar cr lib3.a 3.o && g++ 1.cpp -L. -l2 -l3`. I think I remember reading something about linker ignoring duplicate symbols, but that was for the MSVC linker, not GNU. — HolyBlackCat, Aug 15 '23 at 06:41
https://stackoverflow.com/questions/5669328/force-ignore-duplicate-symbols — Alan Birtles, Aug 15 '23 at 06:53

Allow a specific function to be undefined, as long as it's never called at runtime

0 Answers0