Quels sont les codes tels que CC, LD et CC[M] générés lors de la compilation du noyau Linux ?

Question

En compilant Linux à partir de zéro, je me rends compte que des codes de compilation apparaissent lors de la compilation.

Par exemple nom de fichier CC, nom de fichier LD, nom de fichier CC[M].

Que signifient ces codes ?

Answer 1

Les différentes marques spécifient les éléments suivants

• [cc] - compile le fichier C dans un fichier d'objet désigné.Le fichier d'objet contient le code d'assembleur d'archicture de ce fichier .C.Comme cela pourrait également faire référence à des pièces extérieures à sa portée.Par exemple, appeler une autre fonction dans un autre fichier .c.Les appels de fonction sont laissés ouverts dans le fichier d'objet, qui est ultérieurement inclus par la liaison.Donc
• [LD] est le processus de reliant les objets compilés ensemble et signalez les appels de fonction laissés ouverts par le compilateur.Cependant, de nombreuses pièces sont reliées ensemble comme une partie centrale du noyau, tandis que certaines parties sont laissées de côté.Et ainsi vous voyez
• [CC (M)] Pour les parties compilées comme des points à charger dans le noyau au moment de l'exécution.Mais qui ne sont pas liés ensemble dans la partie monolithique du noyau.Mais peut plutôt être inséré lorsque le noyau est démarré.

Answer 2

Prenons un exemple spécifique et voyons ce qu'il fait dans le noyau 4.1, par ex. IHEX.

Trouver ce que fait un code

Exécutez simplement :

make SHELL='sh -x'

Comment ça marche : https://stackoverflow.com/a/32010960/895245

Si nous récupérons la sortie pour IHEX, on retrouve les lignes :

+ 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

nous concluons donc que IHEX fait un objcopy -Iihex.

Trouver où un code est défini

Chaque commande du noyau doit être définie avec quelque chose comme :

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

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

pour les paramètres de verbosité (par ex. V=1 et make -s) travailler.

Donc en général, il suffit de

git grep 'cmd.* = CODE'

trouver CODE.

J'ai expliqué en détail le fonctionnement de ce système : https://stackoverflow.com/a/32023861/895245

Obtenez la liste de tous les codes

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

CC et CC [M]

Défini dans scripts/Makefile.build:

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

et le [M] vient du cibler des variables spécifiques:

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

Il est ensuite appelé via :

$(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);                \

où if_changed_rule est défini dans scripts/Kbuild.include comme:

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

et Kbuild.include est inclus dans le Makefile de niveau supérieur.

LD

Il existe plusieurs versions, mais la plus simple semble être :

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)

et 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

Il devrait montrer :

• CC lors de la compilation d'une partie centrale du noyau
• CC [M] lors de la compilation d'un module
• LD lors de la liaison