Was ist Compiler, Linker, Loader?

Ich wollte die Bedeutung und Funktionsweise von Compiler, Linker und Loader genau kennen. In Bezug auf jede Sprache vorzugsweise c ++.

=====> COMPILATION PROCESS <======

                     |
                     |---->  Input is Source file(.c)
                     |
                     V
            +=================+
            |                 |
            | C Preprocessor  |
            |                 |
            +=================+
                     |
                     | ---> Pure C file ( comd:cc -E <file.name> )
                     |
                     V
            +=================+
            |                 |
            | Lexical Analyzer|
            |                 |
            +-----------------+
            |                 |
            | Syntax Analyzer |
            |                 |
            +-----------------+
            |                 |
            | Semantic Analyze|
            |                 |
            +-----------------+
            |                 |
            | Pre Optimization|
            |                 |
            +-----------------+
            |                 |
            | Code generation |
            |                 |
            +-----------------+
            |                 |
            | Post Optimize   |
            |                 |
            +=================+
                     |
                     |--->  Assembly code (comd: cc -S <file.name> )
                     |
                     V
            +=================+
            |                 |
            |   Assembler     |
            |                 |
            +=================+
                     |
                     |--->  Object file (.obj) (comd: cc -c <file.name>)
                     |
                     V
            +=================+
            |     Linker      |
            |      and        |
            |     loader      |
            +=================+
                     |
                     |--->  Executable (.Exe/a.out) (com:cc <file.name> ) 
                     |
                     V
            Executable file(a.out)

C Präprozessor: -

Die C-Vorverarbeitung ist der erste Schritt bei der Kompilierung. Es behandelt:

1. #define Aussagen.
2. #include Aussagen.
3. Bedingte Anweisungen.
4. Makros

Der Zweck des Geräts besteht darin, die C-Quelldatei in eine reine C-Codedatei zu konvertieren.

C Zusammenstellung:

Das Gerät besteht aus sechs Schritten:

1) Lexikalischer Analysator:

Es kombiniert Zeichen in der Quelldatei zu einem "TOKEN". Ein Token ist eine Zeichenfolge ohne Leerzeichen, Tabulator und neue Zeile. Daher wird diese Kompilierungseinheit auch "TOKENIZER" genannt. Außerdem werden die Kommentare entfernt, Symboltabellen- und Verschiebungstabelleneinträge generiert.

2) Syntaktischer Analysator:

Dieses Gerät überprüft die Syntax im Code. Zum Beispiel:

{
    int a;
    int b;
    int c;
    int d;

    d = a + b - c *   ;
}

Der obige Code erzeugt den Analysefehler, da die Gleichung nicht ausgeglichen ist. Dieses Gerät überprüft dies intern, indem es den Parser-Baum wie folgt generiert:

                            =
                          /   \
                        d       -
                              /     \
                            +           *
                          /   \       /   \
                        a       b   c       ?

Daher wird dieses Gerät auch PARSER genannt.

3) Semantic Analyzer:

Diese Einheit überprüft die Bedeutung in den Anweisungen. Zum Beispiel:

{
    int i;
    int *p;

    p = i;
    -----
    -----
    -----
}

Der obige Code erzeugt den Fehler "Zuweisung eines inkompatiblen Typs".

4) Voroptimierung:

Diese Einheit ist unabhängig von der CPU, dh es gibt zwei Arten der Optimierung

1. Voroptimierung (CPU-unabhängig)
2. Postoptimierung (CPU-abhängig)

Dieses Gerät optimiert den Code in folgenden Formen:

• I) Beseitigung des toten Codes
• II) Beseitigung von Subcodes
• III) Schleifenoptimierung

I) Beseitigung des toten Codes:

Zum Beispiel:

{
    int a = 10;
    if ( a > 5 ) {
        /*
        ...
        */
    } else {
       /*
       ...
       */
    }
}

Hier kennt der Compiler den Wert von 'a' zur Kompilierungszeit, daher weiß er auch, dass die if-Bedingung immer wahr ist. Daher wird der else-Teil im Code entfernt.

II) Beseitigung von Subcodes:

Zum Beispiel:

{
    int a, b, c;
    int x, y;

    /*
    ...
    */

    x = a + b;
    y = a + b + c;

    /*
    ...
    */
}

kann wie folgt optimiert werden:

{
    int a, b, c;
    int x, y;

    /*
     ...
    */

    x = a + b;
    y = x + c;      // a + b is replaced by x

    /*
     ...
    */
}

III) Schleifenoptimierung:

Zum Beispiel:

{
    int a;
    for (i = 0; i < 1000; i++ ) {

    /*
     ...
    */

    a = 10;

    /*
     ...
    */
    }
}

Wenn im obigen Code 'a' lokal ist und nicht in der Schleife verwendet wird, kann es wie folgt optimiert werden:

{
    int a;
    a = 10;
    for (i = 0; i < 1000; i++ ) {
        /*
        ...
        */
    }
}

5) Codegenerierung:

Hier generiert der Compiler den Assemblycode, damit die am häufigsten verwendeten Variablen in den Registern gespeichert werden.

6) Nachoptimierung:

Hier ist die Optimierung CPU-abhängig. Angenommen, der Code enthält mehr als einen Sprung, dann werden sie wie folgt in einen konvertiert:

            -----
        jmp:<addr1>
<addr1> jmp:<addr2>
            -----
            -----

Die Steuerung springt direkt zum.

Dann ist die letzte Phase das Verknüpfen (wodurch eine ausführbare Datei oder Bibliothek erstellt wird). Wenn die ausführbare Datei ausgeführt wird, werden die erforderlichen Bibliotheken geladen.

• Ein Compiler liest, analysiert und übersetzt Code entweder in eine Objektdatei oder in eine Liste von Fehlermeldungen.
• Ein Linker kombiniert eine oder mehrere Objektdateien und möglicherweise einen Bibliothekscode in einer ausführbaren Datei, einer Bibliothek oder einer Liste von Fehlermeldungen.
• Ein Loader liest den ausführbaren Code in den Speicher, führt eine Adressübersetzung durch und versucht, das Programm auszuführen, was zu einem laufenden Programm oder einer Fehlermeldung (oder beidem) führt.

ASCII-Darstellung:

[Source Code] ---> Compiler ---> [Object code] --*
                                                 |
[Source Code] ---> Compiler ---> [Object code] --*--> Linker --> [Executable] ---> Loader 
                                                 |                                    |
[Source Code] ---> Compiler ---> [Object code] --*                                    |
                                                 |                                    |
                                 [Library file]--*                                    V
                                                                       [Running Executable in Memory]

Hoffe das hilft dir ein bisschen mehr.

Gehen Sie zunächst dieses Diagramm durch:

                         (img source->internet)

Sie erstellen einen Code und speichern dann die Datei (Quellcode)

Vorverarbeitung : - Wie der Name schon sagt, ist es nicht Teil der Kompilierung. Sie weisen den Compiler an, vor der eigentlichen Kompilierung die erforderliche Vorverarbeitung durchzuführen. Sie können diese Phase als Textersetzung oder als Interpretation spezieller Präprozessoranweisungen bezeichnen, die mit # gekennzeichnet sind.

Kompilierung : - Kompilierung ist ein Prozess, bei dem ein in einer Sprache geschriebenes Programm in eine andere Zielsprache übersetzt wird. Wenn es Fehler gibt, erkennt der Compiler diese und meldet sie.

Assemble : - Assemble-Code wird in Maschinencode übersetzt. Sie können Assembler als einen speziellen Typ von Complier bezeichnen.

Verknüpfen : - Wenn für diesen Code eine andere Quelldatei verknüpft werden muss, verknüpfen Sie sie mit dem Linker, um daraus eine ausführbare Datei zu machen.

Es gibt viele Prozesse, die danach ablaufen. Ja, Sie haben es erraten, hier kommt die Rolle des Laders:

Loader : - Lädt den ausführbaren Code in den Speicher. Programm und Datenstapel werden erstellt, das Register wird initialisiert.

Kleine zusätzliche Informationen: - http://www.geeksforgeeks.org/memory-layout-of-c-program/ , Sie können das Speicherlayout dort sehen.

Compiler: Es ist ein Programm, das ein Hochsprachenprogramm in ein Maschinensprachenprogramm übersetzt. Ein Compiler ist intelligenter als ein Assembler. Es prüft alle Arten von Grenzwerten, Bereichen, Fehlern usw. Die Programmlaufzeit ist jedoch länger und nimmt einen größeren Teil des Speichers ein. Es hat langsame Geschwindigkeit. Weil ein Compiler das gesamte Programm durchläuft und dann das gesamte Programm in Maschinencodes übersetzt. Wenn ein Compiler auf einem Computer ausgeführt wird und die Maschinencodes für denselben Computer erstellt, wird er als Self-Compiler oder residenter Compiler bezeichnet. Wenn ein Compiler hingegen auf einem Computer ausgeführt wird und die Maschinencodes für einen anderen Computer erstellt, wird er als Cross-Compiler bezeichnet.

Linker: In Hochsprachen werden einige integrierte Header-Dateien oder Bibliotheken gespeichert. Diese Bibliotheken sind vordefiniert und enthalten grundlegende Funktionen, die für die Ausführung des Programms unerlässlich sind. Diese Funktionen sind durch ein Programm namens Linker mit den Bibliotheken verbunden. Wenn der Linker keine Bibliothek einer Funktion findet, informiert er den Compiler und der Compiler generiert einen Fehler. Der Compiler ruft den Linker automatisch als letzten Schritt beim Kompilieren eines Programms auf. Nicht in Bibliotheken integriert, verknüpft es auch die benutzerdefinierten Funktionen mit den benutzerdefinierten Bibliotheken. Normalerweise wird ein längeres Programm in kleinere Unterprogramme unterteilt, die als Module bezeichnet werden. Und diese Module müssen kombiniert werden, um das Programm auszuführen. Das Kombinieren der Module erfolgt durch den Linker.

Loader: Loader ist ein Programm, das Maschinencodes eines Programms in den Systemspeicher lädt. In Computing ist ein Loader der Teil eines Betriebssystems, der für das Laden von Programmen verantwortlich ist. Dies ist eine der wesentlichen Phasen beim Starten eines Programms. Weil es Programme in den Speicher legt und sie für die Ausführung vorbereitet. Beim Laden eines Programms wird der Inhalt der ausführbaren Datei in den Speicher eingelesen. Sobald der Ladevorgang abgeschlossen ist, startet das Betriebssystem das Programm, indem es die Steuerung an den geladenen Programmcode übergibt. Alle Betriebssysteme, die das Laden von Programmen unterstützen, verfügen über Lader. In vielen Betriebssystemen befindet sich der Loader permanent im Speicher.

Wikipedia sollte eine gute Antwort haben, hier sind meine Gedanken:

• Compiler: Liest etwas.c Quelle, schreibt etwas.o Objekt.
• Linker: Fügt mehrere * .o-Dateien zu einem ausführbaren Programm zusammen.
• Loader: Code, der eine ausführbare Datei in den Speicher lädt und startet.

* *

erklärt in Bezug auf Linux / Unix-basierte Systeme, obwohl es ein Grundkonzept für alle anderen Computersysteme ist.

* *

Linker und Loader von LinuxJournal erklären dieses Konzept mit Klarheit. Es erklärt auch, wie der klassische Name a.out kam. (Assembler-Ausgabe)

Eine kurze Zusammenfassung,

c program --> [compiler] --> objectFile --> [linker] --> executable file (say, a.out)

Wir haben die ausführbare Datei, jetzt geben Sie diese Datei Ihrem Freund oder Ihrem Kunden, der diese Software benötigt :)

Wenn sie diese Software ausführen, geben Sie sie beispielsweise in die Befehlszeile ./a.out ein

execute in command line ./a.out --> [Loader] --> [execve] --> program is loaded in memory

Sobald das Programm in den Speicher geladen ist, wird die Steuerung auf dieses Programm übertragen, indem der PC (Programmzähler) auf die erste Anweisung von zeigt a.out

Compiler:

Es liest die Quelldatei vom Typ .c oder .cpp usw. und übersetzt diese in eine .o-Datei, die als Objektdatei bezeichnet wird.

Linker:

Es kombiniert die verschiedenen O-Dateien, die für mehrere Quelldateien generiert werden können, zu einer ausführbaren Datei (ELF-Format in GCC). Es gibt zwei Arten der Verknüpfung:

• statische Verknüpfung
• dynamische Verknüpfung

Lader:

Ein Programm, das die ausführbare Datei in den Primärspeicher des Computers lädt.

Eine ausführliche Studie zu diesen drei Phasen der Programmausführung unter Linux finden Sie hier .

Compiler-Änderungen überprüfen Ihren Quellcode auf Fehler und ändern ihn in Objektcode. Dies ist der Code, den das Betriebssystem ausführt.

Sie schreiben oft nicht ein ganzes Programm in einer einzigen Datei, daher verknüpft der Linker alle Ihre Objektcodedateien.

Ihr Programm wird nur ausgeführt, wenn es sich im Hauptspeicher befindet

• Compiler : Welche vom Menschen verständlichen Formate in maschinenverständliche Formate konvertieren
• Linker : Welche maschinenverständlichen Formate in betriebssystemverständliche Formate konvertieren
• Loader : ist eine Entität, die das Programm tatsächlich lädt und im RAM ausführt

Linker & Interpreter schließen sich gegenseitig aus. Interpreter erhalten Code zeilenweise und führen ihn zeilenweise aus.

• Compiler: Ein Sprachübersetzer, der ein vollständiges Programm in Maschinensprache konvertiert, um ein Programm zu erstellen, das der Computer vollständig verarbeiten kann.
• Linker: Hilfsprogramm, das eine oder mehrere kompilierte Objektdateien zu einer ausführbaren Datei oder einer anderen Objektdatei kombiniert.
• Loader: Lädt den ausführbaren Code in den Speicher, erstellt das Programm und den Datenstapel, initialisiert die Register und startet den laufenden Code.

Compiler Konvertiert den Quellcode in den Objektcode.

Linker Es kombiniert die mehreren Objektdateien zu einer einzigen ausführbaren Programmdatei.

Loader Lädt die ausführbare Datei in den Hauptspeicher.

Ein Compiler ist ein spezielles Programm, das Anweisungen verarbeitet, die in einer bestimmten Programmiersprache geschrieben sind, und diese in Maschinensprache oder "Code" umwandelt, den der Prozessor eines Computers verwendet

Ein Compiler übersetzt Codezeilen aus der Programmiersprache in die Maschinensprache.

Ein Linker stellt eine Verbindung zwischen zwei Programmen her.

Ein Loader lädt das Programm in den Speicher der Hauptdatenbank, des Programms usw.

Compiler: Es handelt sich um eine Systemsoftware, die den Fehler von Programmen, Objektdateien, Nachrichten usw. Korrigiert

Linker: Es handelt sich um eine Systemsoftware, die eine oder mehrere Objektdateien und möglicherweise einen Bibliothekscode zu einer exicutierbaren Bibliothek oder einer Fehlerliste kombiniert

Loader: Ein Programm, das die ausführbare Datei in den Primärspeicher des Computers lädt