Welche Codes wie CC, LD und CC[M] werden beim Kompilieren des Linux-Kernels ausgegeben?

Question

Beim Kompilieren von Linux von Grund auf fällt mir auf, dass beim Kompilieren Kompilierungscodes angezeigt werden.

Zum Beispiel CC-Dateiname, LD-Dateiname, CC[M]-Dateiname.

Was bedeuten diese Codes?

Answer 1

Die verschiedenen Markierungen geben das Folgende an

an

.
• [cc] - kompiliert die C-Datei in eine ausgewiesene Objektdatei.Die Objektdatei enthält den Archicture Assembler-Code dieser .c-Datei.Da kann es auch Teile außerhalb des Umfangs referenzieren.Anrufen einer weiteren Funktion in einer anderen .c-Datei.Die Funktionsaufrufe bleiben innerhalb der Objektdatei offen, die später vom Linker enthalten ist.Deshalb
• [ld] ist die Proces, die zusammengestellten Objekte zusammen zu verbinden, und verdrahten die Funktionsaufrufe, die vom Compiler offen gelassen wurden.Viele Teile sind jedoch als Kernteil des Kernels miteinander verbunden, während einige Teile ausgelassen werden.Und somit sehen Sie
• [cc (m)] für diese Teile, die als Punkte zusammengestellt werden, die zur Laufzeit in den Kernel geladen werden sollen.Aber die nicht zusammen im monolithischen Teil des Kernels miteinander verbunden sind.Aber stattdessen kann eingesetzt werden, wenn der Kernel gebootet wird.

Answer 2

Nehmen wir ein konkretes Beispiel und finden heraus, was es im Kernel 4.1 bewirkt, z.B. IHEX.

Finden Sie heraus, was ein Code bewirkt

Lauf einfach:

make SHELL='sh -x'

Wie das funktioniert: https://stackoverflow.com/a/32010960/895245

Wenn wir die Ausgabe durchsuchen IHEX, wir finden die Zeilen:

+ 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

Daraus schließen wir IHEX tut ein objcopy -Iihex.

Finden Sie heraus, wo ein Code definiert ist

Jeder Kernelbefehl muss wie folgt definiert werden:

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

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

für die Ausführlichkeitseinstellungen (z.B. V=1 Und make -s) arbeiten.

Im Allgemeinen muss man es also einfach tun

git grep 'cmd.* = CODE'

finden CODE.

Ich habe ausführlich erklärt, wie dieses System funktioniert: https://stackoverflow.com/a/32023861/895245

Holen Sie sich die Liste aller Codes

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

CC und CC [M]

Definiert in scripts/Makefile.build:

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

und das [M] kommt von auf spezifische Variablen abzielen:

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

Der Aufruf erfolgt dann über:

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

Wo if_changed_rule ist definiert in scripts/Kbuild.include als:

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

Und Kbuild.include wird in das Makefile der obersten Ebene eingefügt.

LD

Es gibt einige Versionen, aber die einfachste scheint zu sein:

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)

und 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

Es sollte zeigen:

.
• CC beim Kompilieren eines Kernteils des Kernels
• CC [M] beim Kompilieren eines Moduls
• LD beim Verknüpfen von