GoSudaAnalisi delle istruzioni di diramazione e della generazione del codice assembly AMD64 per le istruzioni condizionali (if) in Go
Istruzioni if in Go
Innanzitutto, la ragione per cui abbiamo scelto Go è che, tra i linguaggi moderni, è quello il cui assembly risulta più "elegante", e in alcuni casi l'efficienza della sua sintassi è addirittura superiore a quella dei linguaggi classici.
Ora che abbiamo compreso il funzionamento di un semplice programma Go nella lezione precedente, confrontiamo direttamente Go e Assembly riga per riga.
Codice sorgente
Anzitutto, come in Go, anche i compilatori moderni, incluso GCC, ottimizzano automaticamente le istruzioni di diramazione che non hanno alcuno scopo. Anche i compilatori per il linguaggio C come GCC e Clang eseguono ottimizzazioni molto aggressive con -O2, lo standard del settore; l'epoca in cui era difficile affidarsi interamente al compilatore si è quindi ormai conclusa, completandosi alla fine del XX secolo.
Pertanto, per avere un senso, è necessario fornire condizioni che il compilatore non possa facilmente prevedere e sostituire con altre istruzioni.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Se si utilizza una condizione prevedibile e che permette di eliminare il ramo, come x = 10,
10 // il compilatore ottimizza e elimina il ramo.
11 // Pertanto, per osservare direttamente l'assembly di questo caso in C si usa -O0 oppure
12 // si fa in modo che il compilatore utilizzi un valore esterno imprevedibile,
13 // mentre questa sezione tratta la programmazione moderna, quindi
14 // non useremo il metodo di disattivare l'ottimizzazione binaria di Go.
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}
In questo caso, poiché il compilatore non può prevedere l'input, il ramo condizionale viene tradotto in linguaggio macchina così com'è.
Linguaggio assembly
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)
Il comando go tool, con grande comodità, indica una per una quali istruzioni corrispondono a quali righe di assembly.
Poiché in questa lezione impariamo le istruzioni di confronto e i rami if, è sufficiente prestare attenzione a poche righe.
Istruzioni CMPQ e JL
L'istruzione CMPQ serve a confrontare dati di tipo a 4 byte (4 word); deriva dall'abbreviazione di CoMPareQuadword, ridotta quindi a CMPQ.
Osservando l'indirizzo di memoria 0x47a84e, si trova l'istruzione CMPQ os.Args+8(SB), $0x2.
In questo caso, il programma confronta il numero di argomenti ricevuti con il valore esadecimale 0x2 (cioè semplicemente 2).
Successivamente, per verificare se gli argomenti sono inferiori a 2 (cioè se il programma stesso è l'unico argomento), viene eseguito un salto condizionale tramite JL. Questo significa Jump, "Less than", ovvero "salta se minore", abbreviato in JL.
Se, in base al confronto precedente, gli argomenti sono inferiori a 2, il programma salta all'indirizzo 0x47a8b0, dove si trova un'istruzione JGE.
Tuttavia, l'istruzione in questione utilizza il registro AX, quindi è necessario comprendere quale valore sia memorizzato in tale registro.
Istruzione MOVQ
Successivamente, bisogna capire come il registro CX venga utilizzato per memorizzare l'indirizzo iniziale dei dati, e come si intendano estrarre i dati effettivi dopo aver letto l'indirizzo.
Osservando l'intervallo 0x47858-0x47863, questa operazione viene eseguita per fasi.
Innanzitutto, l'indirizzo iniziale dell'array degli argomenti viene inserito nel registro CX tramite l'istruzione MOVQ os.Args(SB), CX. A questo punto è necessario comprendere il tipo stringa di Go.
Una string in Go è una struttura composta da due dati di 8 byte, per un totale di 16 byte.
| struct | 8 byte | 8 byte |
|---|---|---|
| string | mem address | string length |
Visivamente, la struttura è quella mostrata sopra: i primi 8 byte contengono l'indirizzo iniziale della stringa, mentre gli ultimi 8 byte contengono la lunghezza della stringa.
Pertanto, l'indirizzo della stringa viene memorizzato nel registro AX e la lunghezza della stringa nel registro BX.
CALL
Nei post precedenti, quando si esaminavano le funzioni del sistema runtime, comparivano istruzioni chiamate CALL.
Esse precedono le funzioni utilizzate in Go e indicano che una funzione viene chiamata, da cui il nome CALL. Successivamente, tramite la chiamata di funzione, la stringa viene convertita in un intero; tuttavia, non è visibile dove venga memorizzato l'intero, poiché ciò è astratto all'interno della funzione.
Istruzioni CMPQ e JGE
Tornando all'indirizzo 0x47a86c, l'istruzione confronta l'indirizzo della stringa con il numero 0xa (in decimale 10)!
Ciò significa che, poiché il programma non utilizza più quell'argomento, è stato sovrascritto nella posizione della stringa per creare lo spazio della variabile intera x.
Questa è la vera natura dell'ottimizzazione aggressiva che avviene in linguaggi come Go.
Successivamente compare l'istruzione JGE, abbreviazione di Jump, Greater or Equals, cioè "salta se maggiore o uguale". Pertanto, questa istruzione verifica se il valore è maggiore o uguale rispetto al termine di confronto.
Quindi, la direzione del confronto è invertita rispetto all'espressione x < 10 così com'è scritta!
Questo accade perché, a livello di linguaggio macchina, saltare in anticipo quando la condizione non è soddisfatta è più diretto e fa risparmiare un'istruzione, rispetto all'esecuzione del confronto nel caso in cui la condizione sia soddisfatta, seguita dalla verifica che non sia soddisfatta.
Questa ottimizzazione è molto classica; a differenza dell'esempio strconv.Atoi visto in precedenza, è un pattern che compare frequentemente anche nei compilatori con un livello di ottimizzazione piuttosto basso, per cui è utile conoscerlo.
Pertanto, applicando questo principio, è possibile ottenere sorgenti diversi che producono assembly identici al 100%.
Esempio di codice speculare
Eseguendo lo script seguente, lo script bash genera due sorgenti speculari al 100% e verifica che, considerando solo main e escludendo i metadati che cambiano di volta in volta, si ottenga un assembly esattamente identico.
1#!/usr/bin/env bash
2
3# 1. Inizializzazione completa dei file e delle directory residui
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. Scrittura del codice sorgente della versione originale (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. Scrittura del codice sorgente della versione speculare (main_from_asm.go)
36# Struttura degli operatori perfettamente simmetrica, affinché il compilatore utilizzi il template di ottimizzazione (JGE)
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 // Mantenendo la struttura x < 10 con 10 come riferimento, il compilatore
56 // adotta esattamente lo stesso meccanismo JGE e la stessa disposizione dei blocchi di main.go.
57 if x < 10 {
58 println(s1)
59 } else {
60 println(s2)
61 }
62}
63EOF
64
65# 4. Esecuzione della compilazione di entrambi i sorgenti nello stesso percorso di directory e nomi di file
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. Estrazione della sezione assembly pura di main.main tramite 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# Rimozione degli indirizzi virtuali, degli offset e dei dati dei byte macchina,
80# filtrando solo i campi delle istruzioni eseguibili dalla CPU (Opcode e Operandi)
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. Verifica della struttura delle istruzioni macchina tramite 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 "------------------------------------------------------------"
Eseguendo effettivamente lo script, si ottengono le seguenti informazioni.
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------------------------------------------------------------
Conclusione
I linguaggi di programmazione offrono molte astrazioni, ma dietro di esse si nascondono ottimizzazioni molto interessanti e aggressive. Inoltre, sfruttando questo aspetto in senso inverso, è stato possibile creare codice speculare, con sorgenti diversi ma assembly identico. Se si è interessati al basso livello e ci si imbatte in software proprietario scritto in Go, analizzare direttamente l'assembly per ricostruire il sorgente non sembra un'impresa impossibile.
Prossima lezione
Nella prossima lezione esamineremo l'istruzione if insieme a un'altra istruzione interessante, select-case.