Estaba revisando la página de manual de GCC, encontré la siguiente línea:

 file.i
           C source code that should not be preprocessed.

yo se que correr gcc -E foo.c detiene el compilador después del preprocesamiento; pero ¿cuál es la aplicación en el mundo real de crear .i archivos

También hay una manera de generar un .i archivos que no sean gcc foo.c -E > foo.i?

El .i Los archivos también se denominan “archivos C puros”. En etapa de preprocesamiento

1. Se incluirán archivos de encabezado.

2. Las macros serán reemplazadas.

3. Se eliminan los comentarios.

4. Se utiliza para la compilación condicional. Si miras el .i archivo se puede ver estas cosas.

Comando para generar .i el archivo es-

gcc -E foo.c -o foo.i

A file.i archivo es:

Código fuente C que no debe ser preprocesado.

Fuente: man gcc luego presione el botón / clave para buscar, y buscar “\.i“.
Pasos detallados: man gccluego presione el botón / clave para buscar, luego escriba \.iluego presione el botón Ingresar tecla, luego presione la tecla norte tecla repetidamente hasta que la encuentre.

Lo que esto significa es que un .i el archivo es código fuente preprocesadopor lo que ya ha sido preprocesado. Por lo tanto, ya contiene:

1. todos los archivos de encabezado incluidos
2. macros reemplazadas
3. y comentarios eliminados

… como dijo @Sathish en su respuesta.

También notará una tonelada de “comentarios” especiales agregados por gcc que ahora comienzan con el # carácter, como estos:

# 1 "main.c"  
# 1 "<built-in>"  
# 1 "<command-line>"  
# 1 "/usr/include/stdc-predef.h" 1 3 4  
# 1 "<command-line>" 2  
# 1 "main.c"  
# 44 "main.c"  
# 1 "/usr/include/stdio.h" 1 3 4  
# 27 "/usr/include/stdio.h" 3 4  
# 1 "/usr/include/features.h" 1 3 4  
# 374 "/usr/include/features.h" 3 4  
# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4  

No sé qué son ni qué hacen. Alguien por favor dígame si lo sabe.

Tenga en cuenta que un programa simple como este:

#include <stdio.h>

int main()
{
    printf("hello world\n");

    return 0;
}

Compilado con esto:

gcc -Wall -std=c99 -O0 -save-temps=obj main.c -o ./bin/main

producirá un main.i archivo que tiene unas 682 líneas de largo, con el main() La función que se muestra arriba está justo al final.

Cómo generar todos los archivos intermedios, incluido el .i archivos:

Mi preferencia es generar todo archivos intermedios (.i, .o, .sen lugar de solo el .i archivo usando -E) todo a la vez en un local bin carpeta en el proyecto usando el gcc -save-temps=obj opción como esta:

mkdir bin
gcc -save-temps=obj foo.c -o ./bin/foo

Ahora tiene los siguientes archivos en el directorio “foo/bin”:

foo     # compiled binary program (AKA: combined "object file", 
        # "executable", "binary", "program", or "machine code")
foo.i   # intermediate, preprocessed C file  
foo.o   # individual object file  
foo.s   # assembly file

Ejecute el programa, por supuesto, con:

./bin/foo

Notas sobre “archivos objeto” y “ejecutables”

Tenga en cuenta que el resultado final, el foo archivo ejecutable, se llama “programa binario compilado“, “programa“, (combinado) “archivo objeto“, “ejecutable“, “binario“, o solo “codigo de maquina“, o “unos y ceros(10101010). Es un archivo de objeto en formato de archivo de objetoal igual que el individuo *.o archivos de objeto que se combinan en uno por el enlazador para crearlo El enlazador combina todos *.o archivos de objeto en uno para hacer el final foo ejecutable, o combinado archivo de objeto.

El enlazador GNU (ld) el manual lo establece de la siguiente manera. Consulte la sección “3.1 Conceptos básicos de la secuencia de comandos del enlazador”: https://sourceware.org/binutils/docs/ld/Basic-Script-Concepts.html#Basic-Script-Concepts (énfasis añadido, así como el contenido entre corchetes []):

3.1 Conceptos básicos de la secuencia de comandos del enlazador

Necesitamos definir algunos conceptos básicos y vocabulario para describir el lenguaje de script del enlazador.

El enlazador combina archivos de entrada [individual *.o object files] en un archivo de salida único. El archivo de salida y cada archivo de entrada están en un formato de datos especial conocido como formato de archivo de objeto. Cada archivo se denomina archivo de objeto. El archivo de salida a menudo se denomina ejecutable, pero para nuestros propósitos también lo llamaremos archivo de objeto. Cada archivo de objeto tiene, entre otras cosas, una lista de secciones. A veces nos referimos a una sección en un archivo de entrada como un sección de entrada; De manera similar, una sección en el archivo de salida es un sección de salida.

Para más información. en archivos de objetos, también puede ver dos de mis otras respuestas aquí:

1. ¿Cómo averiguo en tiempo de compilación qué cantidad de memoria Flash y memoria dinámica (SRAM) de un STM32 se utiliza?
2. Convierta la salida `size` de binutils del formato “sysv” (`size –format=sysv my_executable`) al formato “berkeley” (`size –format=berkeley my_executable`)