GoSudaGenerování assembly kódu AMD64 pro podmínkový příkaz (if) v jazyce Go a analýza větvicích instrukcí
If příkaz v jazyce Go
Nejprve je třeba uvést, že jsme si jako jazyk pro výuku zvolili Go proto, že mezi moderními jazyky má Go z hlediska assembleru jedny z nejelegantnějších výstupů a jeho syntaktická efektivita je v porovnání i s klasickými jazyky místy přímo převažující.
Nyní, když jsme v předchozí lekci pochopili, jak funguje jednoduchý program v Go, porovnejme přímo Go a Assembly řádek po řádku.
Zdrojový kód
Nejprve je třeba zdůraznit, že stejně jako u Go i moderní kompilátory včetně GCC automaticky optimalizují větvení, které nemá smysl provádět. I C kompilátory GCC a Clang provádějí při průmyslovém standardu -O2 velmi agresivní optimalizace, takže doba, kdy programátor nemohl kompilátoru plně důvěřovat, skončila již koncem 20. století.
Proto podmínka musí být zvolena tak, aby ji kompilátor nedokázal předvídat a nahradit jinou konstrukcí; teprve pak má smysl.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Pokud bychom to nahradili podmínkou předvídatelnou, jako je x = 10, která dokáže větvení odstranit,
10 // kompilátor ji optimalizuje a větvení odstraní.
11 // Pokud bychom chtěli tuto situaci sledovat přímo v assembleru, u jazyka C bychom použili například -O0,
12 // nebo bychom kompilátoru předali externí hodnotu, kterou nedokáže předvídat,
13 // ale protože tato sekce pojednává o moderním programování,
14 // nepoužijeme u Go způsob vypnutí binární optimalizace.
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ě kompilátor nemůže předem znát vstup, takže větvení je přeloženo do strojového kódu beze změny.
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)
Nástroj go tool nám laskavě ukáže, který zdrojový příkaz odpovídá kterým instrukcím assembleru.
Protože se v této lekci učíme porovnávací a podmíněné větvicí příkazy, stačí sledovat několik řádků.
Instrukce CMPQ a JL
Instrukce CMPQ slouží k porovnání datových typů o velikosti 4 bajtů (4 slova); její název vznikl zkrácením z CoMPareQuadword na CMPQ.
Na paměťové adrese 0x47a84e najdeme instrukci CMPQ os.Args+8(SB), $0x2.
V tomto případě program porovnává počet předaných argumentů s hexadecimálním číslem 0x2 (tedy prostě 2).
Poté se pomocí JL provede podmíněný skok, pokud je počet argumentů menší než 2 (tedy pokud je program jediným argumentem sám sebe). JL je zkratka z Jump, Less than.
Pokud byl počet argumentů při předchozím porovnání menší než 2, skáče se na adresu 0x47a8b0, kde se však nachází JGE.
Protože však tato část pracuje s registrem AX, je třeba vědět, jaká hodnota je v registru uložena.
Instrukce MOVQ
Dále je nutné pochopit, jak se pomocí registru CX uloží počáteční adresa dat a jak se z přečtené adresy extrahují skutečná data.
Rozsah 0x47a858-0x47a863 tuto operaci provádí po krocích.
Nejprve se pomocí instrukce MOVQ os.Args(SB), CX vloží počáteční adresa pole argumentů do registru CX. V této souvislosti je třeba porozumět tomu, jak Go reprezentuje typ string.
Typ string v Go je struktura složená ze dvou 8bajtových hodnot, celkem tedy 16 bajtů.
| struct | 8 byte | 8 byte |
|---|---|---|
| string | mem address | string length |
Graficky to vypadá takto: prvních 8 bajtů obsahuje počáteční adresu řetězce a dalších 8 bajtů jeho délku.
Adresa řetězce se tedy ukládá do registru AX a délka řetězce do registru BX.
CALL
V předchozím článku jsme u funkcí z balíčku runtime také viděli instrukci CALL.
Ta se objevuje před funkcemi používanými v Go a doslova znamená volání funkce. Následně se pomocí volání funkce převádí řetězec na celé číslo, přičemž není vidět, kam se toto číslo ukládá, protože je to skryto uvnitř funkce.
Instrukce CMPQ a JGE
Vraťme se k adrese 0x47a86c: instrukce porovnává adresu řetězce s číslem 0xa (desítkově 10)!
To znamená, že program již tento argument dále nepoužívá, a proto byl přepsán na místě řetězce, čímž vznikl prostor pro celočíselnou proměnnou x.
Právě to je podstata agresivní optimalizace, kterou provádí například jazyk Go.
Následně se objevuje instrukce JGE, jejíž zkratka znamená Jump, Greater or Equals. Tato instrukce tedy ověřuje, zda je hodnota větší nebo rovna porovnávané hodnotě.
Podmínka x < 10 tedy není v assembleru přímo zapsána, a směr porovnání je obrácen!
Důvod je ten, že při nesplnění podmínky se přeskočí blok bez dalšího porovnání, což je přímočařejší než provést porovnání při splnění podmínky a poté znovu ověřovat, zda podmínka neplatí, a navíc se tím ušetří jedna instrukce.
Tato optimalizace je velmi klasická, a proto se často objevuje i u kompilátorů s mnohem nižší úrovní optimalizace, takže stojí za to ji znát.
Využijeme-li tuto vlastnost, lze získat zdrojové kódy, které se od sebe liší, ale na úrovni assembleru jsou zcela shodné.
Příklad zrcadlového kódu
Pomocí následujícího skriptu lze v Bash vytvořit dva zdrojové soubory, které jsou 100% zrcadlové, a po odstranění metadat, která se mezi buildy mění, ověřit, že funkce main má přesně shodný assembler.
1#!/usr/bin/env bash
2
3# 1. Úplné vyčištění zbylý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í zrcadlové verze zdrojového kódu (main_from_asm.go)
36# Kompilátor použije stejnou šablonu optimalizace (JGE) díky zcela symetrické struktuře operátorů
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 // Pokud zachováme strukturu x < 10 vzhledem k hodnotě 10, kompilátor
56 // přijme přesně stejný mechanismus JGE a stejné rozmístění bloků jako u main.go.
57 if x < 10 {
58 println(s1)
59 } else {
60 println(s2)
61 }
62}
63EOF
64
65# 4. Sestavení obou zdrojů ve stejném adresáři a se stejným názvem souboru
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. Extrakce čistého assembleru funkce main.main pomocí 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# Odstranění virtuálních adres, offsetů a textových dat strojových bajtů
80# a filtrování pouze čistých instrukcí (Opcode a operandy), které CPU provádí
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. Ověření strukturální shody instrukcí pomocí 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 "------------------------------------------------------------"
Po spuštění skriptu získáme následující výstup.
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ávěr
Programovací jazyky nabízejí mnoho abstrakcí, avšak za těmito abstrakcemi se skrývají velmi zajímavé a agresivní optimalizace. Tuto vlastnost jsme dokázali využít k vytvoření zrcadlových kódů, které se liší zdrojově, ale v assembleru jsou shodné. Pokud se zajímáte o nízkou úroveň a narazíte na proprietární software napsaný v Go, není pravděpodobně nemožné rozebrat assembler a zrekonstruovat zdrojový kód.
Další lekce
V příští lekci se podíváme na příkaz select-case, který je dalším zajímavým tématem vedle If příkazu.