Welcome to Software Development on Codidact!
Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.
Post History
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...
#9: Post edited
by
Dirk Herrmann
·
2022-06-24T14:52:39Z (over 2 years ago)
Small typo, formatting
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.
- ```c
- #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 bast, 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.
- I'd like to assert that some code can be optimized out, and is not present in the final binary object.
- ```c
- #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.
#8: Post edited
by
alx
·
2022-06-23T13:28:13Z (over 2 years ago)
- I'd like to assert that some code can be optimized out, and is not present in the final binary object.
- ```c
- #define CONSTANT 0
- static int foo(void);
- void bar(void)
- {
- if (CONSTANT) {
- foo();
- }
- }
[[compile_or_link_time_bomb_A]]- static int foo(void)
- {
compile_or_link_time_bomb_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 bast, 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.
- I'd like to assert that some code can be optimized out, and is not present in the final binary object.
- ```c
- #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 bast, 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.
#7: Post edited
by
alx
·
2022-06-23T12:58:42Z (over 2 years ago)
- I'd like to assert that some code can be optimized out, and is not present in the final binary object.
- ```c
#define ZERO 0- static int foo(void);
- void bar(void)
- {
if (ZERO) {- foo();
- }
- }
- [[compile_or_link_time_bomb_A]]
- static int foo(void)
- {
- compile_or_link_time_bomb_B();
- }
- ```
Attributes, builtins, expressions, ..., everything is fair play, as long as it _guarantees_ that the program is not built with `foo()`, unless `#define ZERO 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 bast, 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.
- I'd like to assert that some code can be optimized out, and is not present in the final binary object.
- ```c
- #define CONSTANT 0
- static int foo(void);
- void bar(void)
- {
- if (CONSTANT) {
- foo();
- }
- }
- [[compile_or_link_time_bomb_A]]
- static int foo(void)
- {
- compile_or_link_time_bomb_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 bast, 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.
#6: Post edited
by
alx
·
2022-06-23T12:57:58Z (over 2 years ago)
- I'd like to assert that some code can be optimized out, and is not present in the final binary object.
- ```c
- #define ZERO 0
- static int foo(void);
- void bar(void)
- {
- if (ZERO) {
- foo();
- }
- }
- [[compile_or_link_time_bomb_A]]
- static int foo(void)
- {
- compile_or_link_time_bomb_B();
- }
- ```
Attributes, builtins, expressions, ..., everything is fair play, as long as it _guarantees_ that the program is not built with `foo()`.- 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 bast, 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.
- I'd like to assert that some code can be optimized out, and is not present in the final binary object.
- ```c
- #define ZERO 0
- static int foo(void);
- void bar(void)
- {
- if (ZERO) {
- foo();
- }
- }
- [[compile_or_link_time_bomb_A]]
- static int foo(void)
- {
- compile_or_link_time_bomb_B();
- }
- ```
- Attributes, builtins, expressions, ..., everything is fair play, as long as it _guarantees_ that the program is not built with `foo()`, unless `#define ZERO 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 bast, 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.
#5: Post edited
by
alx
·
2022-06-23T12:53:42Z (over 2 years ago)
Assert that some code is not compiled, at compile or link time.
- Assert that some code is not present in the final binary, at compile or link time.
#4: Post edited
by
alx
·
2022-06-23T12:53:07Z (over 2 years ago)
Assert that some code is not compiled (translated), at compile or link time.
- Assert that some code is not compiled, at compile or link time.
#3: Post edited
by
alx
·
2022-06-23T12:47:00Z (over 2 years ago)
- I'd like to assert that some code can be optimized out, and is not present in the final binary object.
- ```c
- #define ZERO 0
- static int foo(void);
- void bar(void)
- {
- if (ZERO) {
- foo();
- }
- }
- [[compile_or_link_time_bomb_A]]
- static int foo(void)
- {
- compile_or_link_time_bomb_B();
- }
- ```
- Attributes, builtins, expressions, ..., everything is fair play, as long as it _guarantees_ that the program is not built with `foo()`.
I'd like the compiler (or linker, but preferably the compiler) to warn/error if `foo()` is used.In the bast, this would 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.
- I'd like to assert that some code can be optimized out, and is not present in the final binary object.
- ```c
- #define ZERO 0
- static int foo(void);
- void bar(void)
- {
- if (ZERO) {
- foo();
- }
- }
- [[compile_or_link_time_bomb_A]]
- static int foo(void)
- {
- compile_or_link_time_bomb_B();
- }
- ```
- Attributes, builtins, expressions, ..., everything is fair play, as long as it _guarantees_ that the program is not built with `foo()`.
- 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 bast, 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.
#2: Post edited
by
alx
·
2022-06-23T12:46:24Z (over 2 years ago)
- I'd like to assert that some code can be optimized out, and is not present in the final binary object.
- ```c
- #define ZERO 0
- static int foo(void);
- void bar(void)
- {
- if (ZERO) {
- foo();
- }
- }
- [[compile_or_link_time_bomb_A]]
- static int foo(void)
- {
- compile_or_link_time_bomb_B();
- }
- ```
- Attributes, builtins, expressions, ..., everything is fair play, as long as it _guarantees_ that the program is not built with `foo()`.
I'd like the compiler (or linker, but preferably the compiler) to warn/error if ZERO is defined to 1, and the code is compiled.- In the bast, this would 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.
- I'd like to assert that some code can be optimized out, and is not present in the final binary object.
- ```c
- #define ZERO 0
- static int foo(void);
- void bar(void)
- {
- if (ZERO) {
- foo();
- }
- }
- [[compile_or_link_time_bomb_A]]
- static int foo(void)
- {
- compile_or_link_time_bomb_B();
- }
- ```
- Attributes, builtins, expressions, ..., everything is fair play, as long as it _guarantees_ that the program is not built with `foo()`.
- I'd like the compiler (or linker, but preferably the compiler) to warn/error if `foo()` is used.
- In the bast, this would 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: Initial revision
by
alx
·
2022-06-23T12:45:14Z (over 2 years ago)
Assert that some code is not compiled (translated), 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.
```c
#define ZERO 0
static int foo(void);
void bar(void)
{
if (ZERO) {
foo();
}
}
[[compile_or_link_time_bomb_A]]
static int foo(void)
{
compile_or_link_time_bomb_B();
}
```
Attributes, builtins, expressions, ..., everything is fair play, as long as it _guarantees_ that the program is not built with `foo()`.
I'd like the compiler (or linker, but preferably the compiler) to warn/error if ZERO is defined to 1, and the code is compiled.
In the bast, this would 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.