If utasítás a Go programozási nyelvben
If-utasítás a Go nyelvben
Először is, azért választottuk a Go nyelvet, mert a modern nyelvek közül a Go assemblyje a „legszebb”, és még a klasszikus nyelvekkel összehasonlítva is előfordul, hogy szintaxisának hatékonysága elsöprő erejű.
Mivel az előző előadásban már megértettük az egyszerű Go programok működési elvét, hasonlítsuk össze közvetlenül a Go és az Assembly kódját soronként.
Forráskód
Kezdésként fontos megjegyezni, hogy bár ez a Go esetében is igaz, a modern fordítóprogramok – beleértve a GCC-t is – automatikusan optimalizálják azokat a vezérlési szerkezeteket, amelyeknek nincs gyakorlati jelentőségük. Mivel a C-nyelvi fordítók, mint a GCC vagy a Clang, az ipari szabványnak számító -O2 szinten igen agresszív optimalizációt hajtanak végre, a 20. század vége óta eljutottunk oda, hogy a programozó már nem bízhat teljes mértékben a fordítóban.
Következésképpen a kód csak akkor bír valódi jelentőséggel, ha olyan feltételeket adunk meg, amelyeket a fordító szempontjából nehéz előre jelezni és más szerkezetekre konvertálni.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Ha ezt x = 10-hez hasonló, kiszámítható értékkel helyettesítjük,
10 // amelynél az elágazás törölhető, a fordító optimalizál és eltávolítja az elágazást.
11 // Ezért, ha ezt közvetlenül assembly szinten szeretnénk megvizsgálni,
12 // C nyelvben -O0 beállítást használunk, vagy eleve olyan külső értékeket,
13 // amelyeket a fordító nem tud előre jelezni. Mivel ez a szakasz a modern
14 // programozással foglalkozik, nem kapcsoljuk ki a Go bináris optimalizációját.
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}
Ebben az esetben, mivel a fordító nem tudja előre jelezni a bemenetet, az elágazási utasítás változtatás nélkül kerül gépi kódú fordításra.
Assembly nyelv
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)
A go tool használata lehetővé teszi számunkra, hogy pontosan lássuk, melyik utasítás melyik assembly kódrészletnek felel meg.
Mivel most az összehasonlító utasításokat és az if-elágazásokat tanulmányozzuk, néhány sorra különösen érdemes odafigyelnünk.
CMPQ utasítás és JL utasítás
A CMPQ utasítás 4 bájtos (4 szavas) adattípusok összehasonlítására szolgál; az elnevezés a CoMPareQuadword rövidítése.
A 0x47a84e memória címen a CMPQ os.Args+8(SB), $0x2 utasítás látható.
Ez a programnak átadott argumentumok számát hasonlítja össze a hexadecimális 0x2 (azaz 2) értékkel.
Ezt követően az JL utasítás hajt végre ugrást, ha az argumentumok száma kisebb, mint 2 (azaz ha csak a program neve az egyetlen argumentum). Ez a Jump, Less than rövidítése.
Ha az előző összehasonlítás alapján az argumentumok száma kevesebb volt 2-nél, a program a 0x47a8b0 címre ugrik, ahol egy JGE utasítás található.
Mivel azonban ez a kifejezés az AX regisztert használja, tisztában kell lennünk a regiszterben tárolt érték mibenlétével.
MOVQ utasítás
Ezt követően meg kell értenünk, hogyan tárolja a program az adatok kezdőcímét a 'CX' regiszter segítségével, és hogyan olvassa ki a tényleges adatokat a cím elérése után.
A 0x47858-0x47863 tartomány lépésenként hajtja végre ezt a műveletet.
Először az argumentumtömb kezdőcímét töltjük be a CX regiszterbe a MOVQ os.Args(SB), CX paranccsal. Ehhez meg kell értenünk a Go string típusának felépítését.
A Go string típusa egy struktúra, amely két 8 bájtos adatból, összesen 16 bájtból áll.
| struct | 8 byte | 8 byte |
|---|---|---|
| string | mem address | string length |
Vizuálisan ábrázolva: az első 8 bájt a string kezdőcímét, a hátsó 8 bájt pedig a string hosszát tárolja.
Ennek megfelelően a string címét az AX regiszterbe, a hosszát pedig a BX regiszterbe helyezzük.
CALL
A korábbi bejegyzésekben a runtime függvények vizsgálatakor már találkoztunk a CALL paranccsal.
Ez a Go által használt függvények előtt áll, és szó szerint egy függvény meghívását jelenti. Ezt követően a CALL függvény segítségével konvertáljuk a stringet egész számmá, ahol a függvény absztrakciója miatt nem látható közvetlenül, hogy hová menti az eredményt.
CMPQ utasítás és JGE utasítás
Visszatérve a 0x47a86c címre, az utasítás a string címét és a 0xa (decimális 10) értéket hasonlítja össze!
Ez azt jelenti, hogy mivel a program a továbbiakban már nem használja az adott argumentumot, a fordító felülírta a string helyét, hogy létrehozza az x egész változó számára szükséges területet.
Ez az agresszív optimalizáció valósága a Go nyelvben.
Ezt követi a JGE utasítás, amely a Jump, Greater or Equals rövidítése. Így ez az utasítás azt vizsgálja, hogy az érték nagyobb-e vagy egyenlő-e a vizsgált mennyiséggel.
Emiatt az x < 10 kifejezés nem közvetlenül, hanem megfordított összehasonlítási iránnyal szerepel!
Ez azért van, mert a gépi kódban az ugrás akkor történik meg, ha a feltétel nem teljesül; ez intuitívabb és egy utasítással kevesebb, mint ha a feltétel teljesülését vizsgálnánk, majd újra ellenőriznénk a nem teljesülését.
Ez az optimalizáció igen klasszikus minta, és a fenti strconv.Atoi példával ellentétben gyakran megjelenik az alacsonyabb szintű optimalizációt végző fordítókban is, ezért érdemes ismerni.
Ennek alkalmazásával olyan forráskódokat is létrehozhatunk, amelyek különbözőek, de assembly szinten 100%-osan megegyeznek.
Tükörkép kód példa
Az alábbi parancsfájl segítségével ellenőrizhető, hogy két forráskód – a metaadatoktól eltekintve – pontosan azonos assembly kódot eredményez a main függvény esetében.
1#!/usr/bin/env bash
2
3# 1. Meglévő fájlok és könyvtárak teljes törlése
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. Eredeti forráskód generálása (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. Tükörkép forráskód generálása (main_from_asm.go)
36# Az operátorstruktúra szimmetrikus szinkronizálása a fordító optimalizációs sablonjának (JGE) betartásával
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 // A 10-et referenciaként használva az x < 10 struktúra megőrzése biztosítja,
56 // hogy a fordító a main.go-val azonos JGE mechanizmust és blokkelrendezést alkalmazza.
57 if x < 10 {
58 println(s1)
59 } else {
60 println(s2)
61 }
62}
63EOF
64
65# 4. Fordítás azonos könyvtár és fájlnév környezetben
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. A go tool objdump használata a tiszta main.main assembly függvény kinyerésére
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# Virtuális címek, offsetek és gépi kódú bájtok eltávolítása,
80# csak a CPU által futtatott tiszta parancskészlet (Opcode & Operands) szűrése
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. A két gépi kódú struktúra diff ellenőrzése
85echo "[6/6] Verifying assembly structural integrity via diff..."
86echo "------------------------------------------------------------"
87
88if diff orig_pure.asm asm_pure.asm > /dev/null; then
89 echo "===> [Siker] A két bináris main.main gépi kódú logikája 100%-ban megegyezik! <==="
90 echo "A fordító optimalizációs folyamatának összehangolásával azonos assembly kódot értünk el."
91else
92 echo "===> [Hiba] Eltérések találhatók az assembly utasítások szerkezetében. <==="
93 diff -u orig_pure.asm asm_pure.asm
94fi
95echo "------------------------------------------------------------"
A kód futtatásakor a következő eredményeket kapjuk:
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===> [Siker] A két bináris main.main gépi kódú logikája 100%-ban megegyezik! <===
9A fordító optimalizációs folyamatának összehangolásával azonos assembly kódot értünk el.
10------------------------------------------------------------
Következtetés
Láthattuk, hogy bár a programozási nyelvek számos absztrakciót kínálnak, az absztrakciók mögött rendkívül érdekes és agresszív optimalizációk rejtőznek. Ennek kihasználásával képesek voltunk különböző forráskódokból teljesen azonos assembly kódú "tükörképeket" készíteni. Ha valaki érdeklődik az alacsony szintű működés iránt, és Go nyelven írt zárt forráskódú szoftverrel találkozik, a kód visszafejtése és az assembly elemzése nem tűnik lehetetlen feladatnak.
Következő előadás
A következő alkalommal az If-utasítás mellett egy másik izgalmas szerkezettel, a select-case utasítással foglalkozunk.