If-lause Go-ohjelmointikielessä
If-lause Go-kielellä
Aluksi on todettava, että valitsimme Go-kielen siksi, että modernien kielten joukossa sen assembly on "kauneinta", ja verrattuna klassisiin kieliin sen syntaksin tehokkuus on toisinaan suorastaan ylivoimaista.
Nyt kun olemme edellisellä luennolla ymmärtäneet yksinkertaisen Go-ohjelman toimintaperiaatteen, vertailemme välittömästi Go-koodia ja Assemblya rivi riviltä.
Lähdekoodi
Ensinnäkin, kuten Go-kielen kohdalla, myös modernit kääntäjät GCC mukaan lukien optimoivat automaattisesti sellaiset haarautumislauseet, joilla ei ole merkitystä. Koska C-kielen kääntäjät, kuten GCC ja Clang, suorittavat erittäin aggressiivista optimointia alan standardin mukaisella -O2-tasolla, 1900-luvun loppupuolelta lähtien on ollut selvää, ettei ohjelmoija voi enää täysin luottaa kääntäjään.
Tämän vuoksi koodissa on käytettävä ehtoja, joita kääntäjän on vaikea ennustaa ja muuttaa toisiksi rakenteiksi, jotta koodilla olisi vähintäänkin merkitystä.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Jos tämä korvataan ennustettavalla arvolla, kuten x = 10,
10 // jolloin haarautuminen voidaan poistaa,
11 // kääntäjä optimoi koodin ja poistaa haaran.
12 // Tämän vuoksi, jotta tällaista voisi tarkastella assembly-tasolla,
13 // C-kielessä käytettäisiin esimerkiksi -O0-asetusta,
14 // tai kääntäjä pakotettaisiin käyttämään ulkoisia, ennustamattomia arvoja.
15 // Koska tämä osio käsittelee modernia ohjelmointia,
16 // emme poista Go-kielen binäärioptimointia käytöstä.
17 if len(os.Args) < 2 {
18 return
19 }
20 x, _ := strconv.Atoi(os.Args[1])
21
22 if x < 10 {
23 println("X is smaller than 10")
24 } else {
25 println("X is larger or same as 10")
26 }
27}
Tässä tapauksessa, koska kääntäjä ei voi ennustaa syötettä, haarautumislause käännetään sellaisenaan konekielelle.
Assembly-kieli
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 tool -työkalua käyttämällä saamme ystävällisesti tietää, mikä syntaksi vastaa mitäkin assembly-koodia.
Koska opiskelemme nyt vertailu- ja if-haarautumislauseita, meidän tulee kiinnittää huomiota muutamiin riveihin.
CMPQ- ja JL-käskyt
CMPQ-käsky on tarkoitettu 4 tavun (4 sanan) tietoalkioiden vertailuun, ja sen nimi tulee sanoista CoMPare Quadword.
Muistiosoitteessa 0x47a84e näemme lausekkeen CMPQ os.Args+8(SB), $0x2.
Tässä tapauksessa ohjelma vertaa sille annettujen argumenttien määrää heksadesimaalilukuun 0x2 (eli 2).
Tämän jälkeen, jos argumentteja on vähemmän kuin 2 (eli vain ohjelman nimi), suoritetaan hyppy JL-käskyllä. Se on lyhenne sanoista Jump Less than.
Jos argumentteja oli vähemmän kuin 2, hypätään osoitteeseen 0x47a8b0, jossa on JGE-käsky.
Koska tässä lausekkeessa käytetään kuitenkin AX-rekisteriä, meidän on ymmärrettävä rekisteriin tallennetun arvon luonne.
MOVQ-käsky
Seuraavaksi meidän on ymmärrettävä, miten tietoa luetaan ja miten se puretaan käyttämällä CX-rekisteriä tietojen alkiosoitteen tallentamiseen.
Alue 0x47858-0x47863 suorittaa tämän toiminnon vaiheittain.
Ensinnäkin argumenttitaulukon alkiosoite asetetaan CX-rekisteriin MOVQ os.Args(SB), CX -käskyllä. Tässä yhteydessä on ymmärrettävä Go-kielen merkkijonotyyppi.
Go-kielen string on rakenteeltaan struct, joka koostuu kahdesta 8 tavun tiedosta, yhteensä 16 tavusta.
| struct | 8 tavua | 8 tavua |
|---|---|---|
| string | muistiosoite | merkkijonon pituus |
Visuaalisesti esitettynä rakenne on yllä olevan mukainen: ensimmäiset 8 tavua sisältävät merkkijonon alkiosoitteen ja jälkimmäiset 8 tavua merkkijonon pituuden.
Siten merkkijonon osoite tallennetaan AX-rekisteriin ja pituus BX-rekisteriin.
CALL
Aiemmissakin postauksissa, kun tarkastelimme runtime-funktioita, näimme CALL-käskyn.
Tämä etuliite on käytössä Go-kielen funktioiden edessä, ja se tarkoittaa kirjaimellisesti, että funktiota kutsutaan. Tämän jälkeen CALL-funktiota käytetään merkkijonon muuntamiseen kokonaisluvuksi, mutta se, mihin kokonaisluku tallennetaan, ei näy funktiossa abstraktion vuoksi.
CMPQ- ja JGE-käskyt
Palatessamme aiempaan osoitteeseen 0x47a86c, huomaamme, että käsky vertaa merkkijonon osoitetta lukuun 0xa (desimaalilukuna 10)!
Tämä tarkoittaa, että koska kyseistä argumenttia ei enää käytetä ohjelmassa, muistipaikka on ylikirjoitettu kokonaislukumuuttujan x tallentamiseksi.
Tämä on Go-kielen kaltaisissa kielissä tapahtuvan aggressiivisen optimoinnin todellinen luonne.
Tämän jälkeen esiintyy JGE-käsky, joka on lyhenne sanoista Jump Greater or Equals. Siten tämä lauseke kysyy, onko arvo suurempi tai yhtä suuri kuin vertailukohde.
Siten kyseessä ei ole suoraan x < 10 -lauseke, vaan vertailun suunta on käännetty!
Tämä johtuu siitä, että konekielellä ehdon ohittaminen silloin, kun se ei täyty, on intuitiivisempaa ja säästää yhden käskyn verran tilaa verrattuna siihen, että ehto tarkistettaisiin ja sen jälkeen tarkistettaisiin uudelleen, täyttyykö se.
Tällainen optimointi on hyvin klassista, ja toisin kuin strconv.Atoi-esimerkissä, se esiintyy usein myös kääntäjissä, joiden optimointitaso on huomattavasti matalampi.
Tätä hyödyntämällä voidaan luoda lähdekoodia, joka on eri näköistä, mutta assembly-tasolla 100-prosenttisesti identtistä.
Peilikuva-koodiesimerkki
Alla olevan skriptin avulla voit todentaa, että Bash-skripti luo kaksi peilikuva-lähdekoodia, jotka tuottavat täsmälleen saman assembly-koodin main-funktion osalta, kun metatiedot jätetään huomioimatta.
1#!/usr/bin/env bash
2
3# 1. Vanhojen tiedostojen ja hakemistojen alustus
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. Alkuperäisen version lähdekoodin luonti (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. Peilikuvaversion lähdekoodin luonti (main_from_asm.go)
36# Kääntäjä käyttää optimointimallia (JGE) siten, että operaattorirakenne on täysin symmetrinen
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 // Käyttämällä 10 vertailukohtana ja säilyttämällä x < 10 -rakenteen,
56 // kääntäjä käyttää samaa JGE-mekanismia ja lohkosijoittelua kuin main.go.
57 if x < 10 {
58 println(s1)
59 } else {
60 println(s2)
61 }
62}
63EOF
64
65# 4. Käännökset samassa hakemistossa ja tiedostonimellä
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. go tool objdumpin käyttö puhtaan main.main assembly-funktion erottamiseen
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# Poistetaan virtuaaliosoitteet, offsetit ja konekielinen tavudata,
80# ja suodatetaan vain CPU:n suorittamat käskyt (Opcode & Operands)
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. Kahden konekielisen rakenteen diff-varmennus
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 "Kääntäjän optimointiputken ohjeistus on synkronoitu täydellisesti samanlaisen assembly-koodin saamiseksi."
91else
92 echo "===> [실패] 어셈블리 명령어 구조에 차이점이 발견되었습니다. <==="
93 diff -u orig_pure.asm asm_pure.asm
94fi
95echo "------------------------------------------------------------"
Skriptiä suoritettaessa saadaan seuraavat tiedot:
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% 일치합니다! <===
9Kääntäjän optimointiputken ohjeistus on synkronoitu täydellisesti samanlaisen assembly-koodin saamiseksi.
10------------------------------------------------------------
Johtopäätös
Ohjelmointikielet tarjoavat paljon abstraktioita, mutta niiden takana piilee mielenkiintoisia ja aggressiivisia optimointeja. Näitä hyödyntämällä on mahdollista luoda koodia, jonka lähde on eri, mutta assembly-koodi identtistä. Jos olet kiinnostunut matalan tason asioista ja kohtaat Go-kielellä kirjoitetun suljetun ohjelmiston, sen lähdekoodin palauttaminen assembly-koodia purkamalla ei ole täysin mahdotonta.
Seuraava luento
Seuraavalla kerralla käsittelemme select-case-lauseketta, joka tarjoaa if-lauseen ohella omat mielenkiintoiset piirteensä.