Příkaz If v jazyce Go
Příkaz If v jazyce Go
Důvodem, proč jsme zvolili Go, je především skutečnost, že mezi moderními jazyky má Go jeden z „nejkrásnějších“ výstupů assembleru a ve srovnání s klasickými jazyky je efektivita jeho syntaxe často naprosto ohromující.
Nyní, když jsme v minulé lekci pochopili, jak funguje jednoduchý program v Go, pojďme si přímo porovnat kód v Go a v assembleru řádek po řádku.
Zdrojový kód
Především, podobně jako v Go, i moderní kompilátory včetně GCC automaticky optimalizují větvení kódu, která nemají žádný smysl. Kompilátory jazyka C, jako jsou GCC či Clang, provádějí velmi agresivní optimalizace již při průmyslovém standardu -O2, takže éra, kdy programátor nemohl kompilátorům plně důvěřovat, byla v podstatě završena již na konci 20. století.
Proto má smysl pouze taková podmínka, kterou kompilátor z hlediska predikce nedokáže snadno změnit na jiný výraz.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Pokud toto nahradíme něčím předvídatelným, jako je x = 10,
10 // kde lze větvení odstranit, kompilátor jej optimalizuje a větev smaže.
11 // Aby bylo možné toto pozorovat přímo v assembleru, v jazyce C se používá např. -O0,
12 // nebo se od začátku používají externí hodnoty, které kompilátor nemůže předvídat.
13 // Protože se tato sekce zabývá moderním programováním, metodu vypnutí
14 // optimalizace binárních souborů 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 případě, protože kompilátor nemůže předpovědět vstup, je příkaz větvení přeložen do strojového kódu beze změny.
Jazyk symbolických instrukcí (Assembler)
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)
Pomocí go tool lze laskavě zjistit, který příkaz odpovídá kterému řádku v assembleru.
Jelikož se tentokrát učíme porovnávání a větvení if, zaměříme se na několik konkrétních řádků.
Instrukce CMPQ & JL
Instrukce CMPQ slouží k porovnávání 4bajtových (4-word) datových typů a její název je odvozen od CoMPare Quadword, zkráceně CMPQ.
Podíváme-li se na paměťovou adresu 0x47a84e, vidíme příkaz CMPQ os.Args+8(SB), $0x2.
V tomto případě program porovnává počet přijatých argumentů s hexadecimální hodnotou 0x2 (tedy jednoduše 2).
Následně, pokud je počet argumentů menší než 2 (tj. pokud je jediným argumentem samotný program), provede se skok pomocí JL. To je zkratka pro Jump, Less than. Pokud byl argument menší než 2, program skočí na adresu 0x47a8b0, kde se nachází JGE.
Protože však tento výraz používá registr AX, musíme znát podstatu hodnoty uložené v tomto registru.
Instrukce MOVQ
Dále musíme vědět, jakým způsobem se ukládá počáteční adresa dat pomocí registru CX a jak se po přečtení adresy extrahují skutečná data.
V rozsahu 0x47858-0x47863 se tato operace provádí postupně.
Nejprve se počáteční adresa pole argumentů vloží do registru CX pomocí příkazu MOVQ os.Args(SB), CX. Zde je nutné pochopit datový typ string v Go.
Typ string v Go je struktura složená ze dvou 8bajtových hodnot, celkem tedy 16 bajtů.
| struct | 8 bajtů | 8 bajtů |
|---|---|---|
| string | mem address | string length |
Vizualizováno výše, prvních 8 bajtů obsahuje počáteční adresu řetězce a druhých 8 bajtů jeho délku.
Adresa řetězce je tedy uložena v registru AX a délka řetězce v registru BX.
CALL
I v předchozích příspěvcích jsme u funkcí řady runtime viděli příkaz CALL.
Tento příkaz předchází funkcím používaným v Go a znamená doslova „volání“ (call) dané funkce. Následně se pomocí funkce CALL převede řetězec na celé číslo, přičemž v rámci abstrakce funkce není vidět, kam se toto číslo ukládá.
Instrukce CMPQ & JGE
Vrátíme-li se k adrese 0x47a86c, vidíme, že instrukce porovnává adresu řetězce s číslem 0xa (desítkově 10)!
To znamená, že protože program již daný argument nepoužívá, přepsal místo, kde byl řetězec, aby vytvořil prostor pro celočíselnou proměnnou x.
Toto je podstata agresivní optimalizace, která probíhá v jazycích jako Go.
Poté následuje instrukce JGE, což je zkratka pro Jump, Greater or Equals. Tento příkaz se tedy ptá, zda je hodnota větší nebo rovna porovnávané hodnotě.
Výraz x < 10 tedy není v assembleru přímočaře implementován, ale směr porovnání je obrácen na x < 10!
Je to proto, že ve strojovém kódu je preventivní přeskočení (skip) v případě nesplnění podmínky intuitivnější a šetří jednu instrukci oproti tomu, aby se provedlo porovnání při splnění podmínky a následně se znovu ověřovalo, zda není nesplněna.
Tato optimalizace je velmi klasická a na rozdíl od příkladu se strconv.Atoi se často objevuje i u kompilátorů s mnohem nižší úrovní optimalizace, proto je dobré o ní vědět.
Aplikací těchto poznatků lze dosáhnout toho, že i při odlišném zdrojovém kódu získáme na úrovni assembleru 100% identický kód.
Příklad zrcadlového kódu
Pomocí níže uvedeného skriptu lze ověřit, že Bash skript vytvoří dva zdrojové kódy, které jsou 100% zrcadlové, a po odstranění proměnlivých metadat získáme při pohledu na funkci main naprosto identický assembler.
1#!/usr/bin/env bash
2
3# 1. Úplná inicializace a odstranění starých souborů a adresářů
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. Vytvoření zdrojového kódu původní verze (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. Vytvoření zdrojového kódu zrcadlové verze (main_from_asm.go)
36# Struktura operátorů je dokonale symetricky synchronizována tak,
37# aby kompilátor použil optimalizační šablonu (JGE) beze změny.
38echo "[3/6] Generating main_from_asm.go..."
39cat << 'EOF' > main_from_asm.go
40package main
41
42import (
43 "os"
44 "strconv"
45)
46
47func main() {
48 if len(os.Args) < 2 {
49 return
50 }
51 x, _ := strconv.Atoi(os.Args[1])
52
53 s1 := "X is smaller than 10"
54 s2 := "X is larger or same as 10"
55
56 // Zachováním struktury x < 10 s referenční hodnotou 10
57 // přijme kompilátor naprosto stejný mechanismus JGE a rozmístění bloků
58 // jako v případě main.go.
59 if x < 10 {
60 println(s1)
61 } else {
62 println(s2)
63 }
64}
65EOF
66
67# 4. Sestavení obou verzí ve stejném adresáři a se stejným názvem souboru
68echo "[4/6] Compiling both sources inside 'test_dir'..."
69cp main.go test_dir/main.go
70cd test_dir && go build -o ../main_orig main.go && cd ..
71
72rm test_dir/main.go
73cp main_from_asm.go test_dir/main.go
74cd test_dir && go build -o ../main_asm main.go && cd ..
75
76# 5. Extrakce čisté funkce main.main pomocí go tool objdump
77echo "[5/6] Extracting main.main assembly sections..."
78go tool objdump -s "main\.main" main_orig > orig.asm
79go tool objdump -s "main\.main" main_asm > asm.asm
80
81# Odstranění virtuálních adres, offsetů a binárních dat strojového kódu
82# a filtrace pouze pole s instrukcemi (Opcode & Operands), které CPU vykonává
83awk '{print $4, $5, $6, $7}' orig.asm > orig_pure.asm
84awk '{print $4, $5, $6, $7}' asm.asm > asm_pure.asm
85
86# 6. Ověření rozdílu (diff) struktury strojových instrukcí
87echo "[6/6] Verifying assembly structural integrity via diff..."
88echo "------------------------------------------------------------"
89
90if diff orig_pure.asm asm_pure.asm > /dev/null; then
91 echo "===> [Úspěch] Logika strojového kódu main.main u obou binárních souborů je 100% shodná! <==="
92 echo "Díky dokonalé synchronizaci s optimalizačními pravidly kompilátoru jsme získali identický assembler."
93else
94 echo "===> [Selhání] Ve struktuře instrukcí assembleru byly nalezeny rozdíly. <==="
95 diff -u orig_pure.asm asm_pure.asm
96fi
97echo "------------------------------------------------------------"
Při spuštění skriptu získáte následující informace:
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===> [Úspěch] Logika strojového kódu main.main u obou binárních souborů je 100% shodná! <===
9Díky dokonalé synchronizaci s optimalizačními pravidly kompilátoru jsme získali identický assembler.
10------------------------------------------------------------
Závěr
Programovací jazyky poskytují mnoho úrovní abstrakce, ale pod nimi se skrývají velmi zajímavé a agresivní optimalizace. Využitím těchto znalostí jsme dokázali vytvořit zrcadlový kód, který se liší ve zdrojové podobě, ale v assembleru je identický. Pokud vás zajímá nízkoúrovňové programování a narazíte na proprietární software napsaný v Go, nebude nemožné analyzovat jej přímou dekompilací assembleru a pokusit se o rekonstrukci zdrojového kódu.
Příští lekce
V příští lekci se podíváme na příkaz select-case, který nabízí další zajímavosti podobně jako příkaz If.