GoSudaAnalýza generovania assemblerového kódu pre AMD64 a inštrukcií vetvenia pre podmienený príkaz (if) v jazyku Go
If príkaz v jazyku Go
Najskôr, dôvod, prečo sme si vybrali Go, je ten, že Go má spomedzi moderných jazykov najkrajší assembly a jeho syntaktická efektívnosť je v porovnaní s klasickými jazykmi niekedy dokonca presvedčivá.
Teraz, keď sme v predchádzajúcej lekcii pochopili, ako funguje jednoduchý program v Go, porovnajme priamo Go a Assembly riadok po riadku.
Zdrojový kód
Najprv, rovnako ako v Go, aj moderné kompilátory vrátane GCC automaticky optimalizujú vetvenia, ktoré nemajú zmysel. GCC a Clang, teda kompilátory jazyka C, vykonávajú veľmi agresívne optimalizácie už pri štandardnej úrovni -O2, takže éra, v ktorej programátor nemohol kompilátoru plne dôverovať, sa v skutočnosti skončila už koncom 20. storočia.
Preto má podmienka zmysel len vtedy, ak jej dáme také podmienky, ktoré kompilátor nedokáže ľahko predvídať a nahradiť inou konštrukciou.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Ak by sme to nahradili niečím predvídateľným a odstrániteľným, ako napríklad x = 10,
10 // kompilátor by optimalizoval a odstránil vetvenie.
11 // Preto ak chceme takéto veci priamo pozorovať v assembly, v jazyku C použijeme napríklad -O0
12 // alebo necháme kompilátor používať nepredvídateľnú externú hodnotu,
13 // ale keďže táto sekcia sa zaoberá moderným programovaním, metódu
14 // vypnutia binárnej optimalizácie v Go nepoužijeme.
15 if len(os.Args) < 2 {
16 return
17 }
18 x, _ := strconv.Atoi(os.Args[1])
19
20 if x < 10 {
21 println("X is smaller than 10")
22 } else {
23 println("X is larger or same as 10")
24 }
25}
V tomto prípade kompilátor nedokáže predvídať vstup, preto sa podmienka preloží do strojového kódu bez zmien.
Assembly
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)
Nástroj go tool nám ochotne ukáže, ktorá konštrukcia zodpovedá ktorej assembly inštrukcii.
Keďže sa teraz učíme porovnania a vetvenie pomocou if, stačí sledovať niekoľko riadkov.
CMPQ inštrukcia a JL inštrukcia
Inštrukcia CMPQ slúži na porovnanie 4-bajtových (4-slovových) dátových typov a jej názov pochádza zo skratky CoMPareQuadword, teda CMPQ.
Na adrese pamäte 0x47a84e sa nachádza konštrukcia 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 2).
Potom sa pomocou JL vykoná skok, ak je počet argumentov menší ako 2 (čiže ak je program jediným argumentom). JL je skratka pre Jump, Less than, teda JL.
Ak bol výsledok predchádzajúceho porovnania taký, že argumentov bolo menej ako 2, program skočí na adresu 0x47a8b0, kde sa nachádza JGE.
Keďže však táto konštrukcia používa register AX, musíme poznať, aký význam má hodnota uložená v registri.
Inštrukcia MOVQ
Ďalej je potrebné pochopiť, ako sa pomocou registra CX uloží počiatočná adresa dát a ako sa z tejto adresy extrahujú skutočné údaje.
Na rozsahu 0x47858-0x47863 vidíme, že táto operácia prebieha postupne.
Najprv sa počiatočná adresa poľa argumentov vloží do registra CX pomocou inštrukcie MOVQ os.Args(SB), CX. Pritom je potrebné pochopiť typ string v jazyku Go.
string v Go je štruktúra, ktorá sa skladá z dvoch 8-bajtových údajov, čo je spolu 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 jeho dĺžku.
Preto sa adresa reťazca uloží do registra AX a dĺžka reťazca do registra BX.
CALL
V predchádzajúcom príspevku sme pri pohľade na funkcie z balíka runtime videli inštrukciu CALL.
Tá sa nachádza pred funkciami používanými v Go a znamená, že sa volá nejaká funkcia, teda doslova CALL. Následne sa pomocou volania funkcie reťazec prevedie na celé číslo, pričom sa nevidí, kam sa toto číslo ukladá, pretože je to abstrahované vo funkcii.
CMPQ inštrukcia a JGE inštrukcia
Vráťme sa k adrese 0x47a86c: inštrukcia porovnáva adresu reťazca s číslom 0xa (v desiatkovej sústave 10)!
To znamená, že program už daný argument ďalej nepoužíva, a preto prepísal ním miesto pre celočíselnú premennú x.
Toto je podstata agresívnej optimalizácie, ktorá sa v jazyku Go a podobných jazykoch vykonáva.
Potom sa objaví inštrukcia JGE, ktorá je skratkou pre Jump, Greater or Equals. Táto konštrukcia teda kontroluje, či je hodnota väčšia alebo rovná porovnávanej hodnote.
Konštrukcia tak nie je presne x < 10, ale smer porovnania je obrátený oproti x < 10!
Dôvod je, že v strojovom kóde je priamejšie a úspornejšie preskočiť blok hneď, ak podmienka neplatí, než najprv vykonať porovnanie pre prípad splnenia podmienky a až potom znova overovať, či neplatí. Týmto sa ušetrí jedna inštrukcia.
Táto optimalizácia je veľmi klasická, preto sa s ňou často stretneme aj v kompilátoroch s oveľa menej pokročilou optimalizáciou ako pri príklade strconv.Atoi, takže je dobré si ju zapamätať.
Ak sa tento princíp využije, dá sa získať zdrojový kód, ktorý sa líši, no na úrovni assembly je zhodný na 100 %.
Príklad zrkadlového kódu
Pomocou nižšie uvedeného skriptu môže bash skript vytvoriť dva 100% zrkadlové zdrojové súbory a overiť, že po odstránení metadát, ktoré sa pri každom zostavení líšia, sa pri pohľade iba na main získa presne rovnaký assembly kód.
1#!/usr/bin/env bash
2
3# 1. Úplné vyčistenie zvyšný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 zrkadlovej verzie zdrojového kódu (main_from_asm.go)
36# Úplná symetrická synchronizácia štruktúry operátorov, aby kompilátor použil rovnaký optimalizačný vzor (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 sa za referenčnú hodnotu zvolí 10 a zachová sa štruktúra x < 10, kompilátor
56 // použije 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 s rovnakým názvom súboru
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 textu strojových bajtov
80# a filtrovanie iba čistého zoznamu inštrukcií (Opcode & Operands), ktoré vykoná 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 štruktúry strojových inštrukcií pomocou diff
85echo "[6/6] Verifying assembly structural integrity via diff..."
86echo "------------------------------------------------------------"
87
88if diff orig_pure.asm asm_pure.asm > /dev/null; then
89 echo "===> [성공] 두 바이너리의 main.main 기계어 로직이 100% 일치합니다! <==="
90 echo "컴파일러의 최적화 파이프라인 가이드라인을 완벽하게 동기화하여 동일한 어셈블리를 얻었습니다."
91else
92 echo "===> [실패] 어셈블리 명령어 구조에 차이점이 발견되었습니다. <==="
93 diff -u orig_pure.asm asm_pure.asm
94fi
95echo "------------------------------------------------------------"
Keď sa zdrojový kód skutočne spustí, 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===> [성공] 두 바이너리의 main.main 기계어 로직이 100% 일치합니다! <===
9컴파일러의 최적화 파이프라인 가이드라인을 완벽하게 동기화하여 동일한 어셈블리를 얻었습니다.
10------------------------------------------------------------
Záver
Programovacie jazyky poskytujú veľa abstrakcií, no za nimi sa skrývajú veľmi zaujímavé a agresívne optimalizácie. Tiež sme sa ukázali, že tieto poznatky môžeme obrátiť vo svoj prospech a vytvoriť zrkadlový kód, ktorý má odlišný zdrojový text, ale rovnaký assembly. Ak sa zaujímate o nízkoúrovňové programovanie a stretnete sa s proprietárnym softvérom napísaným v Go, nie je nemožné rozobrať jeho assembly a obnoviť zdrojový kód.
Nasledujúca lekcia
V budúcej lekcii sa pozrieme na If príkaz a ďalší zaujímavý príkaz select-case.