Manba kodidan mashina kodigacha

Yozgan kodingiz protsessorga yetib borguncha bir necha bosqichdan o'tadi. Bu bo'limda o'sha yo'lni haqiqiy vositalar bilan ko'rib chiqamiz.

To'rt bosqich #

Har bosqichni alohida bajarib ko'rish mumkin:

gcc -E d.c -o d.i      # 1. preprotsessor
gcc -S d.i -o d.s      # 2. kompilyator
gcc -c d.s -o d.o      # 3. assembler
gcc d.o   -o d         # 4. bog'lovchi

Har bosqich nima qilganini raqamlarda ko'ramiz. Manba fayl atigi 8 qator edi:

Farq qayerdan keldi? #include <stdio.h> qatori butun bir sarlavha faylini ichiga ko'chirdi - undagi yuzlab e'lon bilan birga.

Preprotsessorning o'zi C tilini umuman tushunmaydi. U faqat matn almashtiradi: #include ni fayl mazmuniga, #define ni uning qiymatiga.

Buni ko'rish oson - preprotsessordan keyin main shunday ko'rinadi:

int main(void) {
    printf("%s, arxitektura!\n", "Salom");
    return 0;
}

#define bilan e'lon qilingan nom o'z qiymatiga almashtirilgan, #include esa yuqorida ochilgan.

Diqqat qiling: SALOM makrosi preprotsessordan keyin yo'qolgan - uning o'rnida "Salom" matni turibdi. Preprotsessor shunchaki matn almashtiradi, C tilini tushunmaydi ham.

Odatda gcc hammasini bir chaqiruvda bajaradi, shuning uchun bu bosqichlar ko'rinmaydi.

Kompilyator nima qiladi? #

Endi eng qiziq bosqich - C kodi assemblerga aylanishi. Bir xil funksiyani ikki xil optimallashtirish darajasida ko'ramiz:

Bir xil C funksiyasini ikki xil optimallashtirish darajasida kompilyatsiya qilamiz:

int kvadratlar_yigindisi(int n) {
    int jami = 0;
    for (int i = 1; i <= n; i++) {
        jami += i * i;
    }
    return jami;
}

Natijalarni solishtiramiz:

Komandalar soni bir xil. Farq faqat oxirgi ustunda - va u hal qiluvchi.

-O0 da har o'zgaruvchi xotirada saqlanadi va har murojaatda o'qib-yoziladi:

kvadratlar_yigindisi:
   push rbp
   mov rbp, rsp
   mov DWORD PTR -20[rbp], edi
   mov DWORD PTR -4[rbp], 0
   mov DWORD PTR -8[rbp], 1
   jmp .L2
.L3:
   mov eax, DWORD PTR -8[rbp]
   imul eax, eax

-O2 da esa hamma narsa registrda qoladi:

kvadratlar_yigindisi:
   test edi, edi
   jle .L4
   add edi, 1
   mov eax, 1
   xor edx, edx
.L3:
   mov ecx, eax
   imul ecx, eax
   add eax, 1
   add edx, ecx
   cmp eax, edi
   jne .L3
   mov eax, edx
   ret

[rbp] ko'rinishidagi murojaatlar - bu xotira. Ikkinchi ro'yxatda ular umuman yo'q.

9-bo'limda ko'rgan edik: registrga murojaat bir takt, xotiraga esa yuzlab takt. Kompilyator aynan shu farqni yo'q qildi.

Komandalar soni bir xil chiqdi. Lekin uchinchi ustunga qarang: xotiraga murojaat -O0 da to'qqizta, -O2 da nolta.

Bu 9 va 14-bo'limlardagi bilimning amaliy tasdig'i: optimallashtiruvchi kompilyatorning asosiy ishi - o'zgaruvchilarni registrda ushlab turish.

-O0 dagi mov DWORD PTR -4[rbp], eax - bu "stekdagi o'zgaruvchiga yozish". -O2 da esa o'sha o'zgaruvchi butun halqa davomida edx registrida qoladi.

Optimallashtirish turlari #

Kompilyator o'nlab usul qo'llaydi. Eng muhimlari:

Oxirgi ikkitasi 4 va 16-bo'limlardagi mavzularga bevosita bog'liq.

Xulosa #

• Kompilyatsiya to'rt bosqich: preprotsessor, kompilyator, assembler, bog'lovchi.
• Preprotsessor shunchaki matn almashtiradi - C tilini tushunmaydi.
• #include <stdio.h> sakkiz qatorlik faylni yuzlab qatorga aylantiradi.
• Bog'lovchi printf kabi havolalarni haqiqiy manzil bilan almashtiradi.
• Bog'lash statik (fayl ichiga) yoki dinamik (ishga tushirishda) bo'ladi.
• -O0 da har o'zgaruvchi xotirada, -O2 da esa registrda.
• Bizning misolda -O2 xotiraga murojaatni to'qqizdan nolga tushirdi.
• Asosiy optimallashtirishlar: registrga joylashtirish, o'lik kod, inline, halqa yoyish.
• -O3 har doim ham -O2 dan tez emas - kod kattalashib keshga zarar berishi mumkin.
• Aniqlanmagan xulq kompilyatorga xavfli farazlar qilishga ruxsat beradi.

Keyingi, yakuniy bo'limda 13-bo'limdagi mashinamizga assembler yozamiz va butun zanjirni yopamiz.