¿Receta para compilar binutils y gcc juntos?

bootstrapping

Question

De acuerdo con las instrucciones de compilación de gcc , puede construir binutils simultáneamente con la creación de gcc (así como gmp, mpc, etc.).

Esto es lo que dice esa página:

Si también tiene la intención de crear binutils (ya sea para actualizar una instalación existente o para usar en lugar de las herramientas correspondientes de su sistema operativo), descomprima la distribución de binutils en el mismo directorio o en uno separado. En este último caso, agregue enlaces simbólicos a cualquier componente de los binutils que pretenda construir junto con el compilador (bfd, binutils, gas, gprof, ld, opcodes, ...) al directorio que contiene las fuentes GCC.

Del mismo modo, las bibliotecas GMP, MPFR y MPC se pueden construir automáticamente junto con GCC. Desempaquete las distribuciones de fuentes GMP, MPFR y / o MPC en el directorio que contiene las fuentes GCC y cambie el nombre de sus directorios a gmp, mpfr y mpc, respectivamente (o use enlaces simbólicos con el mismo nombre).

Esto funciona bien para gmp, mpc, mpfr, pero parece que no puedo hacer que compile todos los binutils. Tampoco puedo averiguar cómo hacer que construya el nuevo enlazador de oro de binutils. Las versiones en cuestión son gcc-4.4.2 y binutils-2.20.

Una instrucción paso a paso sería excelente (para mí y para otras personas que también tienen este problema).

Answer 1

Esto debería seguir siendo compatible, ya que se usa comúnmente para compilar compiladores cruzados.

De hecho, acabo de hacer esto con gcc 4.6.0 y binutils 2.21 (con gmp, mpc y mpfr en las versiones apropiadas), y lo siguiente parece funcionar bien:

• Obtenga todos los archivos de las cosas que va a construir (gcc-4.6.0.tar.bz2, binutils-2.21.tar.bz2, etc.) en un nuevo directorio, por ejemplo, src

• Deshágase de todos ellos en este directorio, por lo que terminará con gcc-4.6.0/ binutils-2.21/ gmp-5.0.2/ y más sentados uno junto al otro

  tar jxvf gcc-4.6.0.tar.bz2
  ... (unpack others here, watch file lists scroll past)

• cd gcc-4.6.0 y enlace simbólico los directorios gmp, mpc y mpfr sin sus números de versión en los enlaces, por ejemplo:

  ln -s ../gmp-5.0.2 gmp

• Ahora vincula todos los enlaces desde el directorio de binutils que no existe en el directorio de gcc, por lo que cualquier cosa que ya exista tendrá prioridad, pero las herramientas de binutils se verán visibles para la compilación:

  for file in ../binutils-2.21/* ; do ln -s "${file}" ; done

• Cambie un directorio y cree un directorio de compilación para compilar todo esto por separado a las fuentes (esto solía ser el método recomendado y tiende a ser más confiable que construir dentro del directorio de la fuente):

  cd .. ; mkdir build

• En este punto, debe tener un conjunto de directorios y enlaces que se parecen a esto:

  binutils-2.21/
  build/
  gcc-4.6.0/
  gmp -> ../gmp-5.0.2
  mpc -> ../mpc-0.9
  mpfr -> ../mpfr-3.0.1
  bfd -> ../binutils-2.21/bfd
  binutils -> ../binutils-2.21/binutils
  gas -> ../binutils-2.21/gas
  ... (lots more symlinks for binutils here, plus existing gcc stuff)
  gmp-5.0.2/
  mpc-0.9/
  mpfr-3.0.1/

• Configure todo el lote desde este directorio, con las opciones que necesite pasar para configurar:

  ../gcc-4.6.0/configure --prefix=/foo/bar --enable-languages=c,c++,ada

• Construya, espere, instale (probablemente querrá usar make -j4 o más aquí para obtener algunas compilaciones en paralelo, ya que tomará un tiempo):

  make -j4 ; make install

Agregue el destino a su ruta si no lo está ya (y quizás el directorio lib a LD_LIBRARY_PATH si está fuera de los especificados en /etc/ld.so.conf , como se menciona en los mensajes sobre la instalación de bibliotecas durante el paso de make install ), y todo debería estar en funcionamiento con esta nueva versión.

Probablemente valga la pena comprobar que está utilizando esta versión instalada una vez que haya abierto un nuevo shell, con:

 `which gcc`

y

 `which as`

..así como la versión es como esperas con:

 `gcc --version`

y

 `as --version`

... así como (por supuesto) probar que la versión instalada compila los ejecutables con algunos ejemplos simples antes de dejarlo suelto en su base de código :)

Edición: los comentarios a continuación contienen algunos conjuntos de versiones que se sabe que funcionan juntas. No todas las combinaciones funcionarán, por lo que es posible que tenga que pasar por una prueba y error para diferentes combinaciones a las mencionadas.

Edición mucho más posterior: gdb también es posible incluir en esta compilación (de nuevo requiere versiones de componentes compatibles - ver comentarios). Agregue esto como lo último después de binutils de una manera similar, usando for f in ../gdb-8.1.1/* ; do ln -s "${f}" ; done for f in ../gdb-8.1.1/* ; do ln -s "${f}" ; done for f in ../gdb-8.1.1/* ; do ln -s "${f}" ; done y la compilación lo recogerá automáticamente.

Answer 2

Lo que quiere hacer es llamar a un "árbol combinado" o una compilación de "in-tree binutils". Puede encontrar documentación sobre cómo proceder here y there .

Answer 3

Siempre construyo todo por separado. Una vez que haya creado e instalado binutils, gcc debería compilar --target siempre que le dé a cada script de configuración las mismas opciones de --target y --target :

binutils

$ ./configure --target=XYZ --prefix=/abc/def
$ make all install

A continuación, agregue la ruta (si es necesario):

$ export PATH="$PATH:/abc/def/bin"

y construir gcc:

$ ./configure --target=XYZ --prefix=/abc/def
$ make all-gcc install-gcc

Luego construya su libc y el resto de gcc si es necesario (¡quizás también un depurador!).