Should EDG define __OPTIMIZE__?

[ilazaric]

EDG over GCC defines macros like __GNUC__, so it might be nice to do __OPTIMIZE__ as well.

Though if you choose to do so, you might also want to think if #pragma GCC optimize should be supported,
because it changes __OPTIMIZE__ with GCC. https://godbolt.org/z/YTao871bY

Dunno how that support would look like, is optimize "O0" -> undefine, otherwise define as 1 sufficient?

Example I experienced

I ran into a hilarious composition of edge-casey behaviour recently related to this.
I tried compiling some code that uses fmt library: https://godbolt.org/z/8rxTzT5ro

// --c++26 -O2
#include <fmt/core.h>
#include <meta>

Because of no __OPTIMIZE__, fmt does #pragma GCC optimize "Og"
Removing fmt from the equation: https://godbolt.org/z/WPrTzY7ed

// --c++26 -O2
#pragma GCC optimize "Og"
#include <meta>

It turns out this is related to -fipa-icf-functions specifically, implied by -O2
We can simplify out the pragma with that knowledge: https://godbolt.org/z/YjcfzvaKb

// --c++26 -Og --c_to_obj_option -fipa-icf-functions
#include <meta>

This really doesn't have anything to do with reflection itself, but a snippet within triggers the bug.
Simplifying until my fingers hurt: https://godbolt.org/z/vEfovv8ax

// --c++26 -Og --c_to_obj_option -fipa-icf-functions
[[gnu::always_inline]]
inline constexpr auto a(auto& x) { return &x; }

[[gnu::always_inline]]
constexpr auto& r(auto& x) { return x; }

constexpr void c(auto ptr, auto arg) { *ptr = r(arg); }

struct S {
  char x, y;
  S() { c(a(x), '\0'); }
};

struct E { S s; };

void f() { throw E(); }

(IIRC a is std::addressof, r is std::forward, c is std::construct_at, S is std::string, E is std::meta::exception, and f is std::meta::access_context::via)

Taking a look at the C EDG emitted, and reducing: https://godbolt.org/z/Gbqvx14Eo

// gcc -Og -fipa-icf-functions
extern  /* COMDAT group: _Z1aIcEDaRT_ */ __inline__ __attribute__((__always_inline__)) char *_Z1aIcEDaRT_(char *x);
extern  /* COMDAT group: _Z1rIcERDaRT_ */ __inline__ __attribute__((__always_inline__)) char *_Z1rIcERDaRT_(char *x);
extern 
 /* COMDAT group: _Z1aIcEDaRT_ */ __inline__ __attribute__((__always_inline__)) char *_Z1aIcEDaRT_( char *__2_31_x) {
return __2_31_x;
}
 /* COMDAT group: _Z1rIcERDaRT_ */ __inline__ __attribute__((__always_inline__)) char *_Z1rIcERDaRT_( char *__7_25_x) {
return __7_25_x;
}

Making it a bit more readable: https://godbolt.org/z/Pcf7MhseP

// gcc -Og -fipa-icf-functions
#define INL __inline__ __attribute__((__always_inline__))

extern INL char *f(char *x);
extern INL char *g(char *x);

extern  INL char *f(char *x) { return x; }
INL char *g(char *x) { return x; }

Slight further reduction: https://godbolt.org/z/bzb8d7j4e

// gcc -Og -fipa-icf-functions
#define INL __inline__ __attribute__((__always_inline__))

INL void f(void);
INL void g(void);

void f(void) {}
void g(void) {}

This is a bug with GCC since 12, report: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=127703

Summary

• EDG doesn't define __OPTIMIZE__
• fmt is not testing __EDG__, so thinks it is just GCC, and because of no __OPTIMIZE__ does #pragma GCC optimize "Og"
• In combination with -O2, we are in effectively -Og -fipa-icf-functions compilation
• GCC has a bug with always_inline in -Og -fipa-icf-functions specifically

[dkolsen-pgi]

In my opinion, whether or not __OPTIMIZE__ is defined should be controlled by the driver of the overall compilation. I don't think the EDG front end should define it. But I have no objections to having the eccp driver defining it when appropriate.