RFR: 8302460: System C++ Compiler for cross compiling gcc is dangerously wrong

[Julian Waters]

On Tue, 14 Feb 2023 17:07:13 GMT, Erik Joelsson <erikj at openjdk.org> wrote:

> I'm not sure I'm understanding the problem here. I think the uppercase `CC` is a remnant of Solaris support. In Solaris Studio, the C++ compiler is uppercase and the C compiler lowercase. What is this resolving to for you? Could it be that on a mac case insensitive file system it resolves to `cc` which in turn resolves to `clang`? I'm not familiar with `c++` as a launcher, but I see on my local Linux host, this resolves to g++ and on my mac to clang++. The drawback of going with a standard launcher like this is that we have a harder time knowing which toolchain type it is.
> 
> Dropping Solaris support for `CC` should be fine, but if we add `c++` it should probably be after `g++`. In the Solaris case, we wanted to be sure we got Solaris Studio and not GCC, but now I think we prefer the known `g++` over the potentially unknown `c++`.

`c++` is indeed the alias of the C++ Compiler that is used for compiling C++ for the build platform, much like `cc` is for C. On my end, the uppercase `CC` ends up resolving to `gcc`, likely because `CC` doesn't exist (at least on some platforms), so the next best fallback of `cc` is chosen, which quite understandably makes the linker give up on life when compiling something like `adlc` which was written in C++



> Erik is probably right that this was created for Solaris, but using "CC" (in upper case) is afaik a long-standing Unix tradition. It is a bit hard too google, but see e.g. https://users.cs.cf.ac.uk/dave/C/node3.html#SECTION00312000000000000000. I think we should not remove it, but we might add other aliases, and we might discuss the order.
> 
> I agree with Erik that trying the g++ explicitly first is a good idea. I think we should keep CC, but it can be lower priority, so in that case the preferred order would be `g++ c++ CC`.
> 
> But I am also curious to what problem you experienced?

For one, when testing this on WSL and an Ubuntu VM, build tools written in C++ such as `adlc` started getting compiled as C, which turned out about as well as you might expect :P

I don't know about shifting the order that these are searched though, `cc` and `c++` are explicitly listed as the compilers meant for "this" platform (the one we are building on), which seems to be explicitly what we want here. Wouldn't searching for `g++` first (and correspondingly swapping `gcc` as the first search for C as well) risk returning the compiler for `--openjdk-target` as the build compiler? (I also had the worry that leaving `CC` as the last search would risk returning `gcc` if the build platform exhausts every other possible compiler and the uppercase `CC` is not present, but after some thought it sounds very unlikely to happen)

-------------

PR: https://git.openjdk.org/jdk/pull/12558