Podmienka If v jazyku Go
Príkaz If v jazyku Go
V prvom rade sme si zvolili Go preto, lebo spomedzi moderných jazykov má Go naj„krajší“ assembly kód a v porovnaní s klasickými jazykmi je efektivita jeho syntaxe často až ohromujúca.
Keďže sme v predchádzajúcej lekcii pochopili základný spôsob fungovania jednoduchého programu v jazyku Go, poďme priamo porovnať Go a Assembly riadok po riadku.
Zdrojový kód
V prvom rade, ako je to aj v Go, dokonca aj moderné kompilátory vrátane GCC automaticky optimalizujú vetviace príkazy, ktoré nemajú opodstatnenie. Keďže aj kompilátory jazyka C, ako GCC či Clang, vykonávajú pri priemyselnom štandarde -O2 veľmi agresívne optimalizácie, éra, v ktorej programátor nemohol plne dôverovať kompilátoru, sa definitívne skončila už koncom 20. storočia.
Preto má zmysel zadávať len také podmienky, ktoré kompilátor z pohľadu predikcie nedokáže ľahko zmeniť na iné konštrukcie.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Ak toto nahradíme niečím predvídateľným, ako x = 10,
10 // kde možno vetvenie odstrániť, kompilátor ho optimalizáciou vymaže.
11 // Preto, ak si chcete takéto veci prezrieť priamo v assembly, v jazyku C
12 // by ste použili napríklad -O0, alebo by ste prinútili kompilátor použiť
13 // externú hodnotu, ktorú nemožno predvídať. Keďže táto sekcia sa venuje
14 // modernému programovaniu, metódu vypnutia optimalizácie binárnych súborov
15 // v Go nepoužijeme.
16 if len(os.Args) < 2 {
17 return
18 }
19 x, _ := strconv.Atoi(os.Args[1])
20
21 if x < 10 {
22 println("X is smaller than 10")
23 } else {
24 println("X is larger or same as 10")
25 }
26}
V tomto prípade sa vetviaci príkaz preloží do strojového kódu tak, ako je, pretože kompilátor nedokáže predpovedať vstup.
Assembly jazyk
1TEXT main.main(SB) /home/yjlee/introduction-to-golang/learn-golang/if-and-switch/golang-if/main.go
2 main.go:8 0x47a840 493b6610 CMPQ SP, 0x10(R14)
3 main.go:8 0x47a844 7670 JBE 0x47a8b6
4 main.go:8 0x47a846 55 PUSHQ BP
5 main.go:8 0x47a847 4889e5 MOVQ SP, BP
6 main.go:8 0x47a84a 4883ec10 SUBQ $0x10, SP
7 main.go:15 0x47a84e 48833d12fb0a0002 CMPQ os.Args+8(SB), $0x2
8 main.go:15 0x47a856 7c58 JL 0x47a8b0
9 main.go:15 0x47a858 488b0d01fb0a00 MOVQ os.Args(SB), CX
10 main.go:18 0x47a85f 488b4110 MOVQ 0x10(CX), AX
11 main.go:18 0x47a863 488b5918 MOVQ 0x18(CX), BX
12 main.go:18 0x47a867 e834e8ffff CALL strconv.Atoi(SB)
13 main.go:20 0x47a86c 4883f80a CMPQ AX, $0xa
14 main.go:20 0x47a870 7d1d JGE 0x47a88f
15 main.go:21 0x47a872 e809befbff CALL runtime.printlock(SB)
16 main.go:21 0x47a877 488d0519f50100 LEAQ 0x1f519(IP), AX
17 main.go:21 0x47a87e bb15000000 MOVL $0x15, BX
18 main.go:21 0x47a883 e878c6fbff CALL runtime.printstring(SB)
19 main.go:21 0x47a888 e853befbff CALL runtime.printunlock(SB)
20 main.go:21 0x47a88d eb1b JMP 0x47a8aa
21 main.go:23 0x47a88f e8ecbdfbff CALL runtime.printlock(SB)
22 main.go:23 0x47a894 488d05c8040200 LEAQ 0x204c8(IP), AX
23 main.go:23 0x47a89b bb1a000000 MOVL $0x1a, BX
24 main.go:23 0x47a8a0 e85bc6fbff CALL runtime.printstring(SB)
25 main.go:23 0x47a8a5 e836befbff CALL runtime.printunlock(SB)
26 main.go:25 0x47a8aa 4883c410 ADDQ $0x10, SP
27 main.go:25 0x47a8ae 5d POPQ BP
28 main.go:25 0x47a8af c3 RET
29 main.go:16 0x47a8b0 4883c410 ADDQ $0x10, SP
30 main.go:16 0x47a8b4 5d POPQ BP
31 main.go:16 0x47a8b5 c3 RET
32 main.go:8 0x47a8b6 e845f0feff CALL runtime.morestack_noctxt.abi0(SB)
33 main.go:8 0x47a8bb eb83 JMP main.main(SB)
Pomocou nástroja go tool nám systém láskavo ukáže, ktorý príkaz zodpovedá ktorému assembly kódu.
Keďže sa v tejto lekcii učíme o porovnávacích príkazoch a vetvení if, zameriame sa na niekoľko riadkov.
Inštrukcia CMPQ & Inštrukcia JL
Inštrukcia CMPQ slúži na porovnanie 4-bajtových (4-word) dátových typov a jej názov je odvodený od CoMPareQuadword, skrátene CMPQ.
Ak sa pozrieme na pamäťovú adresu 0x47a84e, nájdeme tam príkaz CMPQ os.Args+8(SB), $0x2.
V tomto prípade program porovnáva počet prijatých argumentov s hexadecimálnou hodnotou 0x2 (teda jednoducho číslom 2).
Následne sa pomocou JL vykoná skok po porovnaní, ak je počet argumentov menší ako 2 (teda ak je jediným argumentom samotný program). Názov je skratkou pre Jump, Less than.
Ak bol pri predchádzajúcej operácii porovnania počet argumentov menší ako 2, program skočí na adresu 0x47a8b0, kde sa nachádza príkaz JGE.
Keďže však táto konštrukcia používa register AX, musíme zistiť, čo presne je v registri uložené.
Inštrukcia MOVQ
Následne musíme pochopiť, ako sa pomocou registra 'CX' ukladá počiatočná adresa dát a ako sa po prečítaní adresy extrahujú skutočné údaje.
Ak sa pozrieme na rozsah 0x47858-0x47863, uvidíme, že túto operáciu vykonáva postupne.
Najprv sa počiatočná adresa poľa argumentov vloží do registra CX pomocou príkazu MOVQ os.Args(SB), CX. V tomto momente musíme rozumieť dátovému typu string v jazyku Go.
Typ string v Go je štruktúra, ktorá sa skladá z dvoch 8-bajtových položiek, teda má celkovo 16 bajtov.
| struct | 8 byte | 8 byte |
|---|---|---|
| string | mem address | string length |
Vizuálne to vyzerá takto: prvých 8 bajtov obsahuje počiatočnú adresu reťazca a nasledujúcich 8 bajtov obsahuje dĺžku reťazca.
Preto sa adresa reťazca uloží do registra AX a dĺžka reťazca do registra BX.
CALL
Aj pri predchádzajúcich príspevkoch, keď sme sa pozerali na funkcie typu runtime, bol prítomný príkaz CALL.
Tento príkaz sa nachádza pred funkciami používanými v Go a doslova znamená volať (call) danú funkciu. Následne sa pomocou funkcie CALL prevádza reťazec na celé číslo, pričom v samotnej funkcii nie je zrejmé, kde sa toto číslo ukladá, keďže je to abstrahované.
Inštrukcia CMPQ & Inštrukcia JGE
Keď sa vrátime k adrese 0x47a86c, príkaz porovnáva adresu reťazca s číslom 0xa (v desiatkovej sústave 10)!
To znamená, že keďže program už daný argument v kóde nepoužíva, prepísal miesto reťazca, aby vytvoril priestor pre celočíselnú premennú x.
Toto je podstata agresívnej optimalizácie, ktorá prebieha v jazykoch ako Go.
Následne sa objaví inštrukcia JGE, čo je skratka pre Jump, Greater or Equals. Tento príkaz sa teda pýta, či je hodnota väčšia alebo rovná porovnávanému objektu.
Preto to nie je priamo x < 10, ale smer porovnania je v príkaze obrátený!
Je to preto, lebo v strojovom kóde je prednostné preskočenie pri nesplnení podmienky intuitívnejšie a šetrí jeden inštrukčný cyklus v porovnaní s vykonaním porovnania a následným overovaním zhody.
Táto optimalizácia je veľmi klasická, a preto sa na rozdiel od príkladu strconv.Atoi často vyskytuje aj v kompilátoroch s oveľa nižšou úrovňou optimalizácie, takže je dobré o nej vedieť.
Ak tieto poznatky aplikujeme, môžeme získať zdrojové kódy, ktoré sa líšia, ale na úrovni assembly sú identické.
Príklad zrkadlového kódu
Pomocou nasledujúceho skriptu môžete overiť, že Bash skript vytvorí dva zrkadlovo identické zdrojové kódy, ktoré po odstránení meniacich sa metadát produkujú pri pohľade na funkciu main presne rovnaký assembly kód.
1#!/usr/bin/env bash
2
3# 1. Úplná inicializácia a vymazanie starých súborov a adresárov
4echo "[1/6] Cleaning up old artifacts..."
5rm -rf test_dir main_orig main_asm orig.asm asm.asm orig_pure.asm asm_pure.asm
6mkdir -p test_dir
7
8# 2. Vytvorenie zdrojového kódu pôvodnej verzie (main.go)
9echo "[2/6] Generating main.go..."
10cat << 'EOF' > main.go
11package main
12
13import (
14 "os"
15 "strconv"
16)
17
18func main() {
19 if len(os.Args) < 2 {
20 return
21 }
22 x, _ := strconv.Atoi(os.Args[1])
23
24 s1 := "X is smaller than 10"
25 s2 := "X is larger or same as 10"
26
27 if x < 10 {
28 println(s1)
29 } else {
30 println(s2)
31 }
32}
33EOF
34
35# 3. Vytvorenie zdrojového kódu zrkadlovej verzie (main_from_asm.go)
36# Synchronizácia štruktúry operátorov tak, aby kompilátor použil optimalizačnú šablónu (JGE)
37echo "[3/6] Generating main_from_asm.go..."
38cat << 'EOF' > main_from_asm.go
39package main
40
41import (
42 "os"
43 "strconv"
44)
45
46func main() {
47 if len(os.Args) < 2 {
48 return
49 }
50 x, _ := strconv.Atoi(os.Args[1])
51
52 s1 := "X is smaller than 10"
53 s2 := "X is larger or same as 10"
54
55 // Ak zachováme štruktúru x < 10 na základe čísla 10, kompilátor
56 // prijme presne rovnaký mechanizmus JGE a rozloženie blokov ako v main.go.
57 if x < 10 {
58 println(s1)
59 } else {
60 println(s2)
61 }
62}
63EOF
64
65# 4. Zostavenie oboch zdrojov v rovnakom adresári a prostredí
66echo "[4/6] Compiling both sources inside 'test_dir'..."
67cp main.go test_dir/main.go
68cd test_dir && go build -o ../main_orig main.go && cd ..
69
70rm test_dir/main.go
71cp main_from_asm.go test_dir/main.go
72cd test_dir && go build -o ../main_asm main.go && cd ..
73
74# 5. Extrakcia čistej assembly funkcie main.main pomocou go tool objdump
75echo "[5/6] Extracting main.main assembly sections..."
76go tool objdump -s "main\.main" main_orig > orig.asm
77go tool objdump -s "main\.main" main_asm > asm.asm
78
79# Odstránenie virtuálnych adries, offsetov a dát strojového kódu
80# a filtrovanie iba poľa čistých inštrukcií (Opcode & Operands), ktoré vykonáva CPU
81awk '{print $4, $5, $6, $7}' orig.asm > orig_pure.asm
82awk '{print $4, $5, $6, $7}' asm.asm > asm_pure.asm
83
84# 6. Overenie rozdielov v štruktúre strojových inštrukcií
85echo "[6/6] Verifying assembly structural integrity via diff..."
86echo "------------------------------------------------------------"
87
88if diff orig_pure.asm asm_pure.asm > /dev/null; then
89 echo "===> [Úspech] Logika strojového kódu main.main oboch binárnych súborov je 100 % zhodná! <==="
90 echo "Dokonalou synchronizáciou smerníc optimalizačného potrubia kompilátora sme získali identický assembly kód."
91else
92 echo "===> [Zlyhanie] Boli zistené rozdiely v štruktúre assembly inštrukcií. <==="
93 diff -u orig_pure.asm asm_pure.asm
94fi
95echo "------------------------------------------------------------"
Pri spustení skriptu získame nasledujúce informácie:
1[1/6] Cleaning up old artifacts...
2[2/6] Generating main.go...
3[3/6] Generating main_from_asm.go...
4[4/6] Compiling both sources inside 'test_dir'...
5[5/6] Extracting main.main assembly sections...
6[6/6] Verifying assembly structural integrity via diff...
7------------------------------------------------------------
8===> [Úspech] Logika strojového kódu main.main oboch binárnych súborov je 100 % zhodná! <===
9Dokonalou synchronizáciou smerníc optimalizačného potrubia kompilátora sme získali identický assembly kód.
10------------------------------------------------------------
Záver
Videli sme, že programovacie jazyky poskytujú mnoho úrovní abstrakcie, no pod nimi sa skrývajú veľmi zaujímavé a agresívne optimalizácie. Okrem toho sme dokázali tieto poznatky využiť na vytvorenie zrkadlového kódu, ktorý má odlišný zdroj, ale identický assembly. Ak sa zaujímate o nízkoúrovňové programovanie a narazíte na proprietárny softvér napísaný v Go, rekonštrukcia zdrojového kódu pomocou dekompilácie a analýzy assembly kódu nemusí byť nemožná.
Ďalšia lekcia
V nasledujúcej časti sa pozrieme na príkaz select-case, ktorý ponúka ďalšie zaujímavé možnosti okrem príkazu If.