Communities

Writing
Writing
Codidact Meta
Codidact Meta
The Great Outdoors
The Great Outdoors
Photography & Video
Photography & Video
Scientific Speculation
Scientific Speculation
Cooking
Cooking
Electrical Engineering
Electrical Engineering
Judaism
Judaism
Languages & Linguistics
Languages & Linguistics
Software Development
Software Development
Mathematics
Mathematics
Christianity
Christianity
Code Golf
Code Golf
Music
Music
Physics
Physics
Linux Systems
Linux Systems
Power Users
Power Users
Tabletop RPGs
Tabletop RPGs
Notifications
Mark all as read
Q&A

Assert that some code is not present in the final binary, at compile or link time.

+3
−0

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.

Why does this post require moderator attention?
You might want to add some details to your flag.
Why should this post be closed?

0 comment threads

1 answer

+2
−0

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.

Why does this post require moderator attention?
You might want to add some details to your flag.

1 comment thread

Nice trick, would suggest different name for readability (2 comments)

Sign up to answer this question »