¿Cuáles son los códigos como CC, LD y CC[M] que aparecen al compilar el kernel de Linux?

Question

Al compilar Linux desde cero, me doy cuenta de que aparecen códigos de compilación durante la compilación.

Por ejemplo, nombre de archivo CC, nombre de archivo LD, nombre de archivo CC[M].

¿Qué significan estos códigos?

Answer 1

Las diferentes marcas especifican el siguiente

• [CC]: compila el archivo C en un archivo de objeto designado.El archivo de objeto contiene el código del ensamblador de Archicture de ese archivo .c.Como también puede hacer referencia a partes fuera de su alcance.Por ejemplo, llamando a otra función en otro archivo .c.Las llamadas de función se dejan abiertas dentro del archivo de objeto, que más tarde se incluye en el enlazador.Por lo tanto
• [LD] es el proceso de vincular los objetos compilados, y alambre las llamadas de la función que se ha dejado abierta por el compilador.Sin embargo, muchas partes están unidas entre sí como la parte central del kernel, mientras que algunas partes quedan fuera.Y así ves
• [CC (M)] para aquellas partes que se compilan como puntos que se cargarán en el kernel en tiempo de ejecución.Pero que no están vinculados en la parte monolítica del núcleo.Pero en cambio se puede insertar cuando se inicia el kernel.

Answer 2

Tomemos un ejemplo específico y descubramos qué hace en el kernel 4.1, p. IHEX.

Encuentra lo que hace un código

Solo corre:

make SHELL='sh -x'

Cómo funciona eso: https://stackoverflow.com/a/32010960/895245

Si tomamos la salida para IHEX, encontramos las líneas:

+ echo   IHEX    firmware/e100/d101s_ucode.bin
  IHEX    firmware/e100/d101s_ucode.bin
+ objcopy -Iihex -Obinary /home/ciro/git/kernel/src/firmware/e100/d101s_ucode.bin.ihex firmware/e100/d101s_ucode.bin

entonces concluimos que IHEX hace un objcopy -Iihex.

Encuentra dónde se define un código

Cada comando del kernel debe definirse con algo como:

quiet_cmd_ihex  = IHEX    $@
      cmd_ihex  = $(OBJCOPY) -Iihex -Obinary $< $@

$(obj)/%: $(obj)/%.ihex
        $(call cmd,ihex)

para la configuración de detalle (p. ej. V=1 y make -s) trabajar.

Entonces, en general, solo tienes que

git grep 'cmd.* = CODE'

encontrar CODE.

He explicado detalladamente cómo funciona este sistema en: https://stackoverflow.com/a/32023861/895245

Obtenga la lista de todos los códigos

make | grep -E '^  ' | sort -uk1,1

CC y CC [M]

Definido en scripts/Makefile.build:

quiet_cmd_cc_o_c = CC $(quiet_modtag)  $@
      cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<

y el [M] viene del apuntar a variables específicas:

$(real-objs-m)        : quiet_modtag := [M]
$(real-objs-m:.o=.i)  : quiet_modtag := [M]
$(real-objs-m:.o=.s)  : quiet_modtag := [M]
$(real-objs-m:.o=.lst): quiet_modtag := [M]
$(obj-m)              : quiet_modtag := [M]

Luego se llama a través de:

$(obj)/%.o: $(src)/%.c $(recordmcount_source) FORCE
    [...]
    $(call if_changed_rule,cc_o_c)

define rule_cc_o_c
    [...]
    $(call echo-cmd,cc_o_c) $(cmd_cc_o_c);                \

dónde if_changed_rule se define en scripts/Kbuild.include como:

if_changed_rule = $(if $(strip $(any-prereq) $(arg-check) ),                 \
    @set -e;                                                             \
    $(rule_$(1)))

y Kbuild.include se incluye en el Makefile de nivel superior.

LD

Hay varias versiones, pero la más sencilla parece ser:

quiet_cmd_link_o_target = LD      $@
cmd_link_o_target = $(if $(strip $(obj-y)),\
              $(LD) $(ld_flags) -r -o $@ $(filter $(obj-y), $^) \
              $(cmd_secanalysis),\
              rm -f $@; $(AR) rcs$(KBUILD_ARFLAGS) $@)

$(builtin-target): $(obj-y) FORCE
    $(call if_changed,link_o_target)

y en scripts/Kbuild.include:

# Execute command if command has changed or prerequisite(s) are updated.
#
if_changed = $(if $(strip $(any-prereq) $(arg-check)),                       \
    @set -e;                                                             \
    $(echo-cmd) $(cmd_$(1));                                             \
    printf '%s\n' 'cmd_$@ := $(make-cmd)' > $(dot-target).cmd)

Answer 3

debería mostrar:

• CC al compilar una parte central del kernel
• CC [M] al compilar un módulo
• LD cuando vincula