Какие знаешь этапы выполнения кода в компилируемом языке?

Этапы выполнения кода в компилируемом языке

Компилируемые языки (C, C++, Rust, Go) проходят несколько этапов преобразования исходного кода в исполняемый файл. Понимание этих этапов критично для оптимизации и отладки.

1. Препроцессинг (Preprocessing)

Этот этап выполняется перед компиляцией и обрабатывает препроцессорные директивы.

// Включение файлов
#include <stdio.h>        // Из стандартной библиотеки
#include "myheader.h"     // Из текущей директории

// Макроси
#define MAX 100
#define SQUARE(x) ((x) * (x))

// Условная компиляция
#ifdef DEBUG
    printf("Debug mode\n");
#endif

// Результат препроцессинга — исходный код со всеми расширениями

На этом этапе:

• Раскрываются #include директивы
• Раскрываются макросы
• Убираются комментарии
• Обрабатывается условная компиляция

Результат: расширенный исходный код (обычно файл .i для C).

2. Лексический анализ (Lexical Analysis)

Компилятор превращает исходный код в tokens (лексемы).

// Исходный код
int x = 42;

// Tokens
INT IDENTIFIER("x") ASSIGN NUMBER(42) SEMICOLON

Лексер определяет:

• Ключевые слова (int, if, while)
• Идентификаторы (имена переменных)
• Числа, строки
• Операторы (+, -, *)
• Пунктуация

3. Синтаксический анализ (Parsing)

Проверяется структура кода — строится Abstract Syntax Tree (AST).

Код: int x = 42;

AST:
VariableDeclaration
├── Type: int
├── Name: x
└── Initializer: 42

Парсер проверяет:

• Правильность синтаксиса
• Структуру выражений
• Скобки, точки с запятой

Если синтаксис неправильный — компилятор выдаёт ошибку:

int x = 42  // ошибка: нет точки с запятой

4. Семантический анализ (Semantic Analysis)

Проверяется значение и типы.

int x = 42;
int y = x + 10;     // OK: int + int = int
int z = x + "hello";  // Ошибка: int + string несовместимо
int a = x;          // OK: присвоение совместимых типов
undeclared_var = 5; // Ошибка: переменная не объявлена

Проверяются:

• Совместимость типов
• Объявлена ли переменная
• Имеет ли функция правильное количество аргументов
• Области видимости

5. Оптимизация (Optimization)

Компилятор улучшает производительность и размер кода.

// Исходный код
int result = 5 + 3;

// После оптимизации (constant folding)
int result = 8;  // Выражение вычислено на этапе компиляции

// Еще пример: dead code elimination
int x = 10;
if (false) {
    x = 20;  // Этот код удалится
}

// Loop unrolling
for (int i = 0; i < 4; i++) {
    result += arr[i];
}
// Может быть заменен на:
result += arr[0] + arr[1] + arr[2] + arr[3];

Типы оптимизаций:

• Constant folding — вычисление констант во время компиляции
• Dead code elimination — удаление неиспользуемого кода
• Inlining — вставка кода функции вместо вызова
• Loop unrolling — развёртывание циклов
• Common subexpression elimination — удаление дублирующихся вычислений

6. Генерация кода (Code Generation)

Компилятор создаёт assembly код для целевой архитектуры (x86, ARM и т.д.).

// C код
int x = 5;
int y = x + 3;

// Assembly (x86-64)
mov eax, 5      ; x = 5
add eax, 3      ; x + 3
mov ebx, eax    ; y = результат

Ассемблер специфичен для каждой архитектуры:

• x86-64 для современных ПК
• ARM для мобильных устройств
• MIPS для встроенных систем

7. Ассемблирование (Assembly)

Ассемблер преобразует assembly текст в машинный код (объектный файл .o).

Assembly:          Машинный код:
mov eax, 5   →    89 c3 (бинарные инструкции)
add eax, 3   →    01 c3

Результат: объектный файл с машинным кодом и таблицей символов.

8. Линкирование (Linking)

Линкер соединяет несколько объектных файлов в один исполняемый файл и разрешает внешние ссылки.

# Компиляция множества файлов
gcc -c main.c -o main.o
gcc -c utils.c -o utils.o
gcc -c math.c -o math.o

# Линкирование
gcc main.o utils.o math.o -o program

Линкер выполняет:

• Разрешение символов (где определена функция, которую мы вызываем)
• Связывание объектных файлов
• Добавление стандартной библиотеки
• Установку точки входа (main)
• Создание таблицы переходов

// main.c
extern int add(int, int);  // Ссылка на внешнюю функцию

int main() {
    int result = add(5, 3);
}

// utils.c
int add(int a, int b) {
    return a + b;  // Определение функции
}
// Линкер свяжет эту функцию с вызовом из main.c

9. Загрузка и выполнение (Loading and Execution)

Операционная система загружает исполняемый файл в память и начинает выполнение.

Диск: program (исполняемый файл)
  ↓ (загрузчик ОС)
Оперативная память:
  [Machine Code]
  [Data]
  [Stack]
  [Heap]
  ↓ (CPU выполняет инструкции)
Результат

При загрузке:

• Операционная система создаёт процесс
• Выделяет память (код, данные, стек, heap)
• Устанавливает переменные окружения
• Вызывает инструкцию по адресу main

Полный цикл

Исходный код (.c)
    ↓ (Препроцессинг)
Расширенный код
    ↓ (Лексический анализ)
Tokens
    ↓ (Синтаксический анализ)
AST
    ↓ (Семантический анализ)
Проверенный AST
    ↓ (Оптимизация)
Оптимизированный код
    ↓ (Генерация кода)
Assembly код
    ↓ (Ассемблирование)
Объектный файл (.o)
    ↓ (Линкирование)
Исполняемый файл
    ↓ (Загрузка и выполнение)
Результат в памяти

Команда компиляции с видимостью этапов

# Остановиться после препроцессинга
gcc -E main.c -o main.i

# Остановиться после ассемблирования
gcc -c main.c -o main.o

# Вся цепочка с подробностью
gcc -v main.c -o program

Отличие от интерпретируемых языков

В интерпретируемых языках (Python, JavaScript):

• Нет фазы компиляции
• Код выполняется построчно интерпретатором
• Ошибки типов проявляются во время выполнения
• Медленнее, но гибче

В компилируемых языках:

• Вся проверка выполняется до запуска
• Исполняемый файл готов и оптимизирован
• Быстрее, но менее гибко

Python: гибридный подход

Python технически скомпилирует исходный код в bytecode (.pyc файлы), а потом bytecode интерпретируется виртуальной машиной Python. Это гибрид между компиляцией и интерпретацией.