Bob Young wrote:
-----Original Message-----
From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]
Behalf Of Richard Fish
Sent: Wednesday, June 07, 2006 9:24 PM
To: gentoo-user@lists.gentoo.org
Subject: Re: [gentoo-user] gcc-4.1.1
On 6/7/06, Bob Young <[EMAIL PROTECTED]> wrote:
chain. At the end of the first emerge -e system you may have a
new compiler,
but that new compiler was built with the old compiler.
This is false. Gcc uses itself to build itself. It uses the system
compiler to build an initial version of itself, and then uses that
version to build itself. And then for good measure, it uses that
version to build the final version. It's called a 3-stage bootstrap,
and is documented in the file INSTALL/build.html in the gcc sources.
You can also look at /usr/portage/eclass/toolchain.eclass to determine
that Gentoo uses the "bootstrap-lean" target by default.
No, sorry that's just wrong. gcc is slotted, if the above were true there
would be no need for gcc-config in order to select a default compiler. When
a new compiler is emerged, it does *not* automatically become the default
system compiler, it must be selected, and that can only happen after it has
successfully been emerged. The first time a new gcc compiler is emerged, it
is indeed built with the previous version of the compiler that is currently
istalled as the system default.
xgcc is built with the previous system compiler. Then xgcc is used to
build the new gcc for installation. The final install is a self-built
gcc and is not built by the previous system compiler.
Frankly, anybody who claims that gcc needs to be merged twice so it
can be built with itself and produce better object code does not have
a clue what they are talking about and you should simply disregard
anything else they have to say about what is necessary/useful when
upgrading gcc.
It does have to be emerged twice in order for it to be built with itself,
anybody who thinks otherwise doesn't understand the basic principles of
compiling and linking.
I think you have ignored what the previous poster suggested.
happen before glibc is rebuilt are linked against a glibc that was built
with the old compiler.
And guess what difference this makes to the end result. None.
Nada. Nothing.
Because for basically every program on your system, they are
*dynamically linked* against glibc.
Are you absolutely 100% sure that every single system utility and
application is *dynamically* linked, and that no apps or utilities anywhere
in the system specifies *static* linking?
There are a few statically linked programs that will include glibc
internally. These are used only for system recovery purposes...there
is no need to worry about them at all.
Really, so people who intentionally and specifically want to upgrade
absolutely *everything* should not worry about what gets left out because
Richard says it's unimportant?
The issue is about upgrading gcc and even the gcc upgrade howto recommends
an emerge -e world. It's clear that gcc it self at least has to be emerged
twice in order to build the new gcc *with* the new gcc.
Wrong. The gcc package builds a bootstrap compiler (the new version),
called xgcc and then it uses that to build [after some tests] the final
installed gcc. A single emerge of gcc will create a compiler that was
built by itself.
Thus, if you move from 3.3.4 to 4.1.0:
emerge -u gcc
You WILL have a gcc that was compiled by a 4.1.0 compiler.
Whether this is
strictly necessary or not is certaintly debatable, but since it executes
fairly quickly, and seems a prudent step, I'd argue that it's a reasonable
course. Of course a selecting the new gcc as the default with gcc-config is
also required in between, but that's self evident. Adding gcc-config, glibc,
binutils, libstdc++-v3, quickly covers the most important parts of the basic
tool chain, and covers most utilities or apps that might specify static
linking, and executes much much faster than an emerge -e system.
There is no value to having glibc or libstdc++-v3 in the first line.
There is no value at all to doing that twice.
Twice is the only way to build the new gcc *with* the new gcc. I should have
added the gcc-config select command in between, but I thought that was
pretty clearly necessary.
You didn't pay attention to what he wrote. I hope perhaps my post made
it more clear.
Tom Veldhouse
--
gentoo-user@gentoo.org mailing list
