Assert that some code is not present in the final binary, at compile or link time.
I'd like to assert that some code can be optimized out, and is not present in the final binary object.
#define CONSTANT 0
#if (!CONSTANT)
[[landmine_A]]
#endif
static int foo(void);
void bar(void)
{
if (CONSTANT) {
foo();
}
}
static int foo(void)
{
if (!CONSTANT)
landmine_B();
}
Attributes, builtins, expressions, ..., everything is fair play, as long as it guarantees that the program is not built with foo(), unless #define CONSTANT 1.
I'd like the compiler (or linker, but preferably the compiler) to warn/error if foo() is used, but not if it's inside an if (0).
In the past, this could probably be achieved by __builtin_unreachable();, and the corresponding warning, but it's ignored nowadays...
An option (the one in use, which I'm trying to improve), is to build conditionally foo, but then I also need to use preprocessor stuff at call site, which I don't entirely like, because it hides code to the compiler, so I need to test multiple configurations.
1 answer
Calling an undefined function will have that behavior at link time:
landmine.c:
#ifndef CONSTANT
#define CONSTANT 0
#endif
#define landmine(e) do \
{ \
if (e) \
undefined_function(); \
} while (0)
void undefined_function(void);
[[gnu::noipa]] static void foo0(void);
[[gnu::noipa]] static void foo1(void);
int main(void)
{
CONSTANT ? foo1() : foo0();
}
static void foo0(void)
{
landmine(!CONSTANT);
}
static void foo1(void)
{
landmine(!CONSTANT);
}
alx@asus5775:~/tmp$ cc -Wall -Wextra -O3 -DCONSTANT=1 landmine.c alx@asus5775:~/tmp$ cc -Wall -Wextra -O3 -DCONSTANT=0 landmine.c /usr/bin/ld: /tmp/ccmIFcBz.o: in function `foo0': landmine.c:(.text+0x1): undefined reference to `undefined_function' collect2: error: ld returned 1 exit status
I used [[gnu::noipa]] just to check which function is triggering the landmine, and it is foo0 as expected, and only when CONSTANT == 0.
It would be nicer to have a compile-time landmine, but link-time is good enough.
0 comment threads