GoSudaGo-kielen ehtolauseen (if) AMD64-assemblykoodin generointi ja haaraamiskäskyjen analyysi
Go-kielen If-lauseet
Ensinnäkin, syy siihen, että valitsimme Go-kielen, on se, että Go on modernien kielten joukossa se, jonka assembly on "kauneinta", ja verrattuna klassisiin kieliin sen syntaksin tehokkuus on joskus jopa ylivoimainen.
Nyt kun ymmärsimme edellisessä luennossa yksinkertaisen Go-ohjelman toimintatavan, vertaillaan Goa ja Assemblya suoraan rivi riviltä.
Lähdekoodi
Ensinnäkin, Go:ssa, mutta myös modernit kääntäjät, GCC mukaan lukien, optimoivat automaattisesti haarautumat, joilla ei ole käyttötarkoitusta. GCC:n ja Clangin kaltaiset C-kielen kääntäjät suorittavat hyvin aggressiivisia optimointeja alan standardilla -O2, joten aika, jolloin ohjelmoijat eivät voineet luottaa kääntäjään täysin, päättyi lopullisesti jo 1900-luvun loppupuolella.
Siksi kääntäjän ennustettavissa olevat ehdot eivät ole merkityksellisiä, ellei niitä muotoilla niin, ettei kääntäjä pysty helposti ennustamaan niitä ja korvaamaan niitä toisella rakenteella.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Jos tämän korvaa ennustettavalla ja haarautumat poistettavissa olevalla arvolla, kuten x = 10,
10 // kääntäjä optimoi sen ja poistaa haarautuman.
11 // Siksi jos haluat tarkastella tätä suoraan assemblynä, C-kielessä käytetään esimerkiksi -O0:aa tai
12 // annetaan kääntäjän käyttää alun perin ennustamatonta ulkoista arvoa,
13 // mutta koska tämä osio käsittelee modernia ohjelmointia, emme käytä Go:n binäärioptimoinnin
14 // poistamista koskevaa menetelmää.
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}
Tässä tapauksessa kääntäjä ei voi ennustaa syötettä, joten haarautuma käännetään konekielelle sellaisenaan.
Assemblykieli
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)
Go:n työkalu (go tool) kertoo ystävällisesti, mikä lause vastaa mitäkin assemblyä, rivi riviltä.
Tällä kertaa opimme vertailulauseita ja if-haarautumia, joten riittää, että tarkastelemme muutamaa riviä.
CMPQ-käsky ja JL-käsky
CMPQ-käsky on tarkoitettu 4-tavuisten (4-sanaisten) tietotyyppien vertailuun, ja sen etymologia on CoMPareQuadword, lyhennettynä CMPQ:ksi.
Muistiosoitteessa 0x47a84e on lause CMPQ os.Args+8(SB), $0x2.
Tässä tapauksessa ohjelma vertaa syötettyjen argumenttien lukumäärää heksadesimaaliluvun 0x2 kanssa (eli yksinkertaisesti 2).
Tämän jälkeen tarkistetaan, onko argumentteja vähemmän kuin 2 (eli onko ohjelma itse ainoa argumentti), ja vertailun jälkeen suoritetaan hyppy JL-käskyllä. Tämä on lyhennys sanoista Jump, Less than, eli JL.
Jos edellisessä vertailussa argumentteja oli vähemmän kuin 2, hypätään osoitteeseen 0x47a8b0, jossa on JGE. Tässä lauseessa käytetään kuitenkin AX-rekisteriä, joten on tiedettävä, mitä rekisterissä säilytettävä arvo edustaa.
MOVQ-käsky
Seuraavaksi on ymmärrettävä, miten CX-rekisteriä käytetään tallentamaan datan aloitusosoite ja miten todellinen data poimitaan osoitteen luvun jälkeen.
Osoitealueella 0x47858-0x47863 tämä toimenpide suoritetaan vaiheittain.
Ensin argumenttitaulukon aloitusosoite sijoitetaan CX-rekisteriin käskyllä MOVQ os.Args(SB), CX. Tässä vaiheessa on ymmärrettävä Go:n merkkijonotyyppi.
Go:n string on rakenne, ja tämä rakenne koostuu kahdesta 8-tavuisesta tietoalkiosta, eli yhteensä 16 tavusta.
| struct | 8 byte | 8 byte |
|---|---|---|
| string | mem address | string length |
Visuaalisesti se näyttää yllä olevalta: ensimmäiset 8 tavua ovat merkkijonon aloitusosoite ja seuraavat 8 tavua merkkijonon pituus.
Näin ollen merkkijonon osoite tallennetaan AX-rekisteriin ja merkkijonon pituus BX-rekisteriin.
CALL
Edellisessä kirjoituksessa, kun tarkastelimme runtime-funktioita, niiden edessä oli CALL-käsky.
Se on merkitty Go:ssa käytettävien funktioiden eteen, ja se tarkoittaa suoraan, että jotakin funktiota kutsutaan, eli se on todellakin CALL. Tämän jälkeen CALL-funktiolla muunnetaan merkkijono kokonaisluvuksi, ja tässä vaiheessa ei näy, minne kokonaisluku tallennetaan, koska se on abstrahoitu funktioon.
CMPQ-käsky ja JGE-käsky
Palataan takaisin aiempaan osoitteeseen 0x47a86c. Käsky vertaa merkkijonon osoitetta lukuun 0xa (kymmenjärjestelmässä 10)!
Tämä tarkoittaa, että koska ohjelma ei enää käytä kyseistä argumenttia, merkkijonon paikka on korvattu kokonaislukumuuttujan x paikalla.
Tämä on Go-kielen ja muiden kielten aggressiivisen optimoinnin todellinen luonne.
Seuraavaksi esiin tulee JGE-käsky, joka on lyhennys sanoista Jump, Greater or Equals. Tämä lause siis kysyy, onko vertailtava arvo suurempi tai yhtä suuri kuin vertailukohde.
Näin ollen lause ei ole suoraan x < 10, vaan vertailun suunta on käännetty päinvastaiseksi!
Konekielessä on tehokkaampaa hypätä ennakoivasti yli, kun ehto ei täyty, kuin suorittaa vertailu kerran ehdon täyttyessä ja tarkistaa sen uudelleen, koska tämä on suoraviivaisempaa ja säästää yhden käskyn.
Tämä optimointi on hyvin klassinen, ja juuri siksi se esiintyy usein myös kääntäjissä, joiden optimointitaso on huomattavasti matalampi kuin edellä nähdyssä strconv.Atoi-esimerkissä, joten sen tunteminen on hyödyllistä.
Tätä kaavaa soveltamalla voidaan saada lähdekoodi, joka on erilainen, mutta vastaa assemblytasolla 100-prosenttisesti.
Peilikuvakoodiesimerkki
Alla olevalla skriptillä bash-skripti luo kaksi 100-prosenttisesti peilikuvamaista lähdekoodia ja voi todentaa, että kun jätetään pois kulloinkin vaihtelevat metatiedot ja tarkastellaan vain main-funktiota, saadaan täsmälleen sama assembly.
1#!/usr/bin/env bash
2
3# 1. Poistetaan kokonaan vanhat jäännöstiedostot ja hakemistot
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. Kirjoitetaan alkuperäisen version lähdekoodi (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. Kirjoitetaan peilikuvaversion lähdekoodi (main_from_asm.go)
36# Synkronoidaan operaattorirakenne täydellisesti symmetriseksi, jotta kääntäjä käyttää
37# optimointimallia (JGE) sellaisenaan
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 // Kun pidetään 10 vertailukohteena ja rakenne x < 10 säilytetään, kääntäjä
57 // valitsee täsmälleen saman JGE-mekanismin ja lohkojärjestyksen kuin main.go:ssa.
58 if x < 10 {
59 println(s1)
60 } else {
61 println(s2)
62 }
63}
64EOF
65
66# 4. Käännetään molemmat lähdekoodit samassa hakemisto- ja tiedostonimiympäristössä
67echo "[4/6] Compiling both sources inside 'test_dir'..."
68cp main.go test_dir/main.go
69cd test_dir && go build -o ../main_orig main.go && cd ..
70
71rm test_dir/main.go
72cp main_from_asm.go test_dir/main.go
73cd test_dir && go build -o ../main_asm main.go && cd ..
74
75# 5. Poimitaan puhdas main.main-assembly-funktio go tool objdumpilla
76echo "[5/6] Extracting main.main assembly sections..."
77go tool objdump -s "main\.main" main_orig > orig.asm
78go tool objdump -s "main\.main" main_asm > asm.asm
79
80# Poistetaan virtuaaliosoitteet, offsetit ja konekielen tavudatan teksti,
81# ja suodatetaan vain suoritettavat käskyt (Opcode & Operands)
82awk '{print $4, $5, $6, $7}' orig.asm > orig_pure.asm
83awk '{print $4, $5, $6, $7}' asm.asm > asm_pure.asm
84
85# 6. Tarkistetaan kahden konekielikäskyrakenteen erot diffillä
86echo "[6/6] Verifying assembly structural integrity via diff..."
87echo "------------------------------------------------------------"
88
89if diff orig_pure.asm asm_pure.asm > /dev/null; then
90 echo "===> [성공] 두 바이너리의 main.main 기계어 로직이 100% 일치합니다! <==="
91 echo "컴파일러의 최적화 파이프라인 가이드라인을 완벽하게 동기화하여 동일한 어셈블리를 얻었습니다."
92else
93 echo "===> [실패] 어셈블리 명령어 구조에 차이점이 발견되었습니다. <==="
94 diff -u orig_pure.asm asm_pure.asm
95fi
96echo "------------------------------------------------------------"
Kun ajat lähdekoodin itse, saat seuraavanlaisia tietoja.
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------------------------------------------------------------
Johtopäätös
Ohjelmointikielet tarjoavat paljon abstraktioita, mutta abstraktioiden takana piilee hyvin mielenkiintoisia ja aggressiivisia optimointeja. Tätä ominaisuutta hyödyntämällä pystyimme myös luomaan peilikuvamaisen koodin, jonka lähdekoodi on erilainen, mutta assembly on sama. Jos olet kiinnostunut matalan tason ohjelmoinnista ja kohtaat Go-kielellä kirjoitettua suljettua ohjelmistoa, on todennäköisesti mahdollista purkaa assembly ja palauttaa siitä lähdekoodi, vaikka se ei olisikaan helppoa.
Seuraava luento
Seuraavalla kerralla tutustumme If-lauseen lisäksi toiseen mielenkiintoiseen rakenteeseen, select-case-lauseeseen.