I might be wrong, but I think that it is better to have these version constants to be #define-s and not P4 constants.

The rationale is that they really need to be examined at the compile-time and typically #ifdef is a more powerful mechanism, compared with the regular if() (or even a new, upcoming switch()) statement, simply because it can be used in any context whatsoever, while the P4 statements can only be used in a few, very limited places.

Obviously, if we change these version constants to become CPP defines, the problem at hand will go away on its own :)

The main issue with macros is that they are not represented in the compiler IR. They only exist in the preprocessor, and after substitution they completely disappear. So having a const is one way to preserve these values throughout the compilation process.

I'm confused... as a CPP define, the compiler has even less visibility. The version becomes just another integer literal. Isn't that a step in the wrong direction?

Looks like @mbudiu-vmw beat me to it.

The point is that in practice, these constants are used to modify the code before it is fed into the compiler, meaning that we want to see in the IR only whatever is left and not to see in the IR anything that we actually want to remove.

Also, for example, imagine the situation where you are using an extern, defined in one version of the architecture and not defined in another one (or, perhaps, the definitions are not quite the same). You cannot use an if() to choose between these instantiations, but it is very easily done using #ifdef.

This is a general issue that goes beyond just the version constants. If you want, we can always have a compromise where you define both, but that is not going to help with the original problem :)

I have tons of programs that have many different variations/profiles. Sometimes if() can be used and I do use it, but very often it can't be and then I have to use the preprocessor.