> I "native" compiler is defined as one where host==target. Anything > else is something we call a "cross-compiler".
For the purposes of stage1, "native" only means "runs on the build machine, produces code that runs on the build machine". Since the compiler used to build stage1 is *not* guaranteed to be gcc, we can't state "native means same host triplet" because system compilers don't always have host triplets. It's meaningless to be more specific than "runs on, builds for" and a 32 bit binary that produces 64 bit executables *is* "native" if it runs on the build machine, and produces code that runs on the build machine. Specifically, we do *NOT* require that two independent native compilers, one of which is used to build stage1, produce link compatible objects. We could, for example, have a 32 bit COFF compiler as the system compiler, and have gcc configured as an ELF compiler. We've assumed compatibility in the past, and gotten burned. The new bootstrap procedures avoid this assumption, and assure us that all the parts of the compiler (libiberty, libcpp, gcc, libgcc for later stages) are built with the same tools. We *do* require that all the compilers *built* during a boostrap produce compatible objects, and in the ideal case, produce identical objects. > Only if you assume a "cross" compiler and a true native compiler > generate different code. I certainly hope that isn't the case. > > Why not? It's a pretty strong statement to assume they generate > *exactly* the same code under all circumstances and it seems > unnecessary. It is most definitely neccessary that GCC produce the same code regardless of which compiler it is built with, assuming that the compiler it is built with is not itself buggy. That's called "portability". The mistake here is confusing "gcc configured as a cross compiler" with "native gcc built with a cross compiler". Two copies of gcc, both configured for the same target and built from the same sources, should produce identical objects regardless of how they are built or what they run on. A cross compiler and a native compiler targeting the same CPU chip, that's a different story.
