Quali sono i codici come l'uscita CC, LD e CC [M] quando si compila il kernel Linux?

Question

Durante la compilazione di Linux da zero mi rendo conto che ci sono codici di compilazione che appaiono durante la compilazione.

Ad esempio Nome file CC, FileName LD, CC [M] Nome file.

Cosa significano questi codici?

Answer 1

I diversi segni specificano il seguente

.
• [cc] - Compila il file C in un file oggetto designato.Il file dell'oggetto contiene il codice ARCHIMCURE Assembler di quel file .c.Come potrebbe anche fare riferimento a parti al di fuori del suo ambito.Ad esempio, chiamare un'altra funzione in un altro file .C.Le chiamate di funzione vengono lasciate aperte all'interno del file oggetto, che viene successivamente incluso dal linker.Pertanto
• [LD] è il proces di collegare insieme gli oggetti compilati e collegare le chiamate di funzione che è stata lasciata aperta dal compilatore.Tuttavia, molte parti sono collegate insieme come la parte centrale del kernel, mentre alcune parti sono lasciate fuori.E così vedi
• [cc (m)] per quelle parti compilate come punti da caricare nel kernel in fase di esecuzione.Ma che non sono collegati insieme nella parte monolitica del kernel.Ma invece può essere inserito quando il kernel viene avviato.

Answer 2

Prendiamo un esempio specifico e capire cosa fa nel kernel 4.1, ad es. IHEX.

Trova cosa fa un codice

Basta correre:

make SHELL='sh -x'

.

Come funziona: https://stackoverflow.com/a/32010960/895245

Se grepiamo l'uscita per IHEX, troviamo le linee:

+ 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

.

Quindi concludiamo che IHEX fa un objcopy -Iihex.

trova dove viene definito un codice

Ogni comando del kernel deve essere definito con qualcosa come:

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

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

.

Per le impostazioni della verbosità (E.G. V=1 e make -s) per funzionare.

Così in generale, devi solo

git grep 'cmd.* = CODE'

.

per trovare CODE.

Ho spiegato in dettaglio come funziona questo sistema: https://stackoverflow.com/a/32023861/295245-

Ottieni l'elenco di tutti i codici

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

.

cc e cc [m]

Definito in scripts/Makefile.build:

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

.

e il [M] deriva da Variabili specifiche di destinazione :

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

.

viene quindi chiamato tramite:

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

.

dove if_changed_rule è definito in scripts/Kbuild.include come:

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

.

e Kbuild.include viene incluso nel makefile di livello superiore.

LD

Ci sono alcune versioni, ma il più semplice sembra essere:

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)

.

e in 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

Dovrebbe mostrare:

.
• CC quando si compila una parte principale del kernel
• CC [M] durante la compilazione di un modulo
• LD durante il collegamento