Kann gcc C-Code nach der Vorverarbeitung ausgeben?

Ich verwende eine Open-Source-Bibliothek, die viele Vorverarbeitungsanweisungen zu haben scheint, um viele andere Sprachen als C zu unterstützen. Damit ich studieren kann, was die Bibliothek tut, möchte ich den C-Code sehen, den ich nach der Vorverarbeitung kompiliere , mehr wie das, was ich schreiben würde.

Kann gcc (oder jedes andere in Linux allgemein verfügbare Tool) diese Bibliothek lesen, aber C-Code ausgeben, der die Vorverarbeitung in was auch immer konvertiert hat und auch von einem Menschen lesbar ist?

Ja. Übergeben Sie gcc die -E Möglichkeit. Dadurch wird vorverarbeiteter Quellcode ausgegeben.

cpp ist der Präprozessor.

Laufen cpp filename.c um den vorverarbeiteten Code auszugeben oder besser in eine Datei umzuleiten mit
cpp filename.c > filename.preprocessed.

-save-temps

Dies ist eine weitere gute Option, die Sie im Hinterkopf behalten sollten:

gcc -save-temps -c -o main.o main.c

Haupt c

#define INC 1

int myfunc(int i) {
    return i + INC;
}

und jetzt neben der normalen Ausgabe main.oenthält das aktuelle Arbeitsverzeichnis außerdem die folgenden Dateien:

• main.i ist die gewünschte vorbesessene Datei, die Folgendes enthält:

  # 1 "main.c"
  # 1 "<built-in>"
  # 1 "<command-line>"
  # 31 "<command-line>"
  # 1 "/usr/include/stdc-predef.h" 1 3 4
  # 32 "<command-line>" 2
  # 1 "main.c"
  
  
  int myfunc(int i) {
      return i + 1;
  }
  

• main.s ist ein Bonus 🙂 und enthält die generierte Assembly:

      .file   "main.c"
      .text
      .globl  myfunc
      .type   myfunc, @function
  myfunc:
  .LFB0:
      .cfi_startproc
      pushq   %rbp
      .cfi_def_cfa_offset 16
      .cfi_offset 6, -16
      movq    %rsp, %rbp
      .cfi_def_cfa_register 6
      movl    %edi, -4(%rbp)
      movl    -4(%rbp), %eax
      addl    $1, %eax
      popq    %rbp
      .cfi_def_cfa 7, 8
      ret
      .cfi_endproc
  .LFE0:
      .size   myfunc, .-myfunc
      .ident  "GCC: (Ubuntu 8.3.0-6ubuntu1) 8.3.0"
      .section    .note.GNU-stack,"",@progbits
  

Wenn Sie dies für eine große Anzahl von Dateien tun möchten, sollten Sie stattdessen Folgendes verwenden:

 -save-temps=obj

Dadurch werden die Zwischendateien im selben Verzeichnis wie die gespeichert -o Objektausgabe anstelle des aktuellen Arbeitsverzeichnisses, wodurch potenzielle Basisnamenkonflikte vermieden werden.

Der Vorteil dieser Option über -E ist, dass es einfach zu jedem Build-Skript hinzugefügt werden kann, ohne viel in den Build selbst einzugreifen.

Eine weitere coole Sache an dieser Option ist, wenn Sie hinzufügen -v:

gcc -save-temps -c -o main.o -v main.c

Es zeigt tatsächlich die expliziten Dateien, die anstelle von hässlichen temporären Dateien verwendet werden /tmpso ist es einfach, genau zu wissen, was vor sich geht, einschließlich der Vorverarbeitungs- / Kompilierungs- / Montageschritte:

/usr/lib/gcc/x86_64-linux-gnu/8/cc1 -E -quiet -v -imultiarch x86_64-linux-gnu main.c -mtune=generic -march=x86-64 -fpch-preprocess -fstack-protector-strong -Wformat -Wformat-security -o main.i
/usr/lib/gcc/x86_64-linux-gnu/8/cc1 -fpreprocessed main.i -quiet -dumpbase main.c -mtune=generic -march=x86-64 -auxbase-strip main.o -version -fstack-protector-strong -Wformat -Wformat-security -o main.s
as -v --64 -o main.o main.s

Getestet in Ubuntu 19.04 amd64, GCC 8.3.0.

CMake vordefinierte Ziele

CMake stellt automatisch Ziele für die vorverarbeitete Datei bereit:

make help

zeigt uns, was wir können:

make main.i

und dieses Ziel läuft:

Preprocessing C source to CMakeFiles/main.dir/main.c.i
/usr/bin/cc    -E /home/ciro/bak/hello/main.c > CMakeFiles/main.dir/main.c.i

so kann die Datei unter eingesehen werden CMakeFiles/main.dir/main.c.i

Getestet auf cmake 3.16.1.

Ich verwende gcc als Präprozessor (für HTML-Dateien). Es macht genau das, was Sie wollen. Es erweitert “#–“-Anweisungen und gibt dann eine lesbare Datei aus. (KEINER der anderen C/HTML-Präprozessoren, die ich ausprobiert habe, tut dies – sie verketten Zeilen, verschlucken Sonderzeichen usw.) Angenommen, Sie haben gcc installiert, lautet die Befehlszeile:

gcc -E -xc -P -C -traditional-cpp code_before.cpp > ​​code_after.cpp

(Muss nicht ‘cpp’ sein.) Es gibt eine ausgezeichnete Beschreibung dieser Verwendung unter http://www.cs.tut.fi/~jkorpela/html/cpre.html.

Das “-traditional-cpp” behält Leerzeichen und Tabulatoren bei.

Laufen:

gcc -E <file>.c

oder

g++ -E <file>.cpp

Angenommen, wir haben eine Datei als Message.cpp oder eine .c-Datei

Schritte 1: Vorverarbeitung (Argument -E)

g++ -E .\Message.cpp > P1

Die generierte P1-Datei enthält erweiterte Makros, und Inhalte und Kommentare der Header-Datei werden entfernt.

Schritt 2: Vorverarbeitete Datei in Assembly übersetzen (Argument -S). Diese Aufgabe übernimmt der Compiler

g++ -S .\Message.cpp

Ein Assembler (ASM) wird generiert (Message.s). Es hat den ganzen Assembler-Code.

Schritt 3: Assemblercode in Objektcode übersetzen. Hinweis: Message.s wurde in Schritt 2 generiert.

g++ -c .\Message.s

Eine Objektdatei mit dem Namen Message.o wird generiert. Es ist die binäre Form.

Schritt 4: Verknüpfen der Objektdatei. Diese Aufgabe übernimmt der Linker

g++ .\Message.o -o MessageApp

Hier wird eine exe-Datei MessageApp.exe generiert.

#include <iostream>
using namespace std;

//This a sample program
int main()
{
  cout << "Hello" << endl;
  cout << PQR(P,K) ;
  getchar();
  return 0;
}