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

Question

Al compilar Linux desde cero, me doy cuenta de que hay códigos de compilación que aparecen 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 lo siguiente

• [CC] - Compila el archivo C en un archivo de objeto designado. El archivo de objeto contiene el código de ensamblador archicture de ese archivo .c. Como también podría referirse a partes fuera de su alcance. Por ejemplo, llamar a otra función en otro archivo .c. Las llamadas a función se dejan abiertas dentro del archivo de objeto, que luego es incluido por el vinculador. Por lo tanto,
• [LD] es el proceso de vincular los objetos compilados entre sí y conectar las llamadas de función que el compilador ha dejado abiertas. Sin embargo, muchas partes están vinculadas entre sí como la parte central del núcleo, mientras que algunas partes se quedan fuera. Y así puede ver
• [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 unidos entre sí en la parte monolítica del kernel. Pero en su lugar se puede insertar cuando se inicia el kernel.

Answer 2

Debe mostrar:

• CC al compilar una parte fundamental del núcleo
• CC [M] al compilar un módulo
• LD al vincular

Answer 3

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

Encuentra lo hace un código

Simplemente ejecute:

make SHELL='sh -x' 

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

Si GrEP la salida de IHEX, nos encontramos con 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.

encontrar dónde un código se define

Cada comando del núcleo se debe definir con algo como:

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

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

para la configuración de cantidad de información (por ejemplo V=1 y make -s) para trabajar.

Así que, en general, sólo hay que

git grep 'cmd.* = CODE' 

encontrar CODE.

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

obtener la lista de todos los códigos

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

de 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 la [M] proviene de la target specific variables:

$(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] 

Se llama entonces 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);    \ 

donde 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 vaya a incluirse en el archivo Makefile de nivel superior.

LD

Hay algunas 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)