GoSudaAnaliza generării codului de asamblare AMD64 pentru instrucțiunea condițională (if) din Go și a instrucțiunilor de salt
Instrucțiunea If în limbajul Go
Mai întâi, motivul pentru care am ales Go este că, dintre limbajele moderne, Go are cel mai „frumos" assembly, iar eficiența sintaxei sale este uneori copleșitoare chiar și în comparație cu limbajele clasice.
Acum, după ce am înțeles în lecția anterioară modul de funcționare al unui program Go simplu, să comparăm direct Go și Assembly, linie cu linie.
Codul sursă
În primul rând, la fel ca în Go, chiar și compilatoarele moderne, inclusiv GCC, optimizează automat ramificațiile care nu au niciun rost. Compilatoarele pentru limbajul C, precum GCC și Clang, efectuează optimizări foarte agresive la nivelul standard din industrie, -O2, așa că epoca în care programatorii nu puteau avea încredere deplină în compilator s-a încheiat, practic, încă de la sfârșitul secolului XX.
Prin urmare, din perspectiva compilatorului, o condiție trebuie formulată astfel încât să fie greu de prezis și de înlocuit cu o altă structură sintactică pentru a avea cel puțin un sens.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Dacă acest lucru este rezolvat cu ceva previzibil și care poate elimina ramificația, precum x = 10,
10 // compilatorul optimizează și elimină ramificația.
11 // Prin urmare, pentru a vedea direct un astfel de cod în assembly, în C se folosește -O0 sau similar,
12 // ori se face ca compilatorul să utilizeze o valoare externă imprevizibilă,
13 // iar această secțiune tratează programarea modernă, așa că nu folosim
14 // metoda dezactivării optimizărilor binare din 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}
În acest caz, deoarece compilatorul nu poate prezice intrarea, instrucțiunea de ramificație este tradusă în cod mașină exact așa cum este.
Limbajul 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)
Unealta go tool arată cu amabilitate ce instrucțiune de cod sursă corespunde fiecărei instrucțiuni de assembly.
Ceea ce trebuie să învățăm acum sunt structurile de comparație și de ramificație if, așa că este suficient să analizăm câteva linii.
Instrucțiunile CMPQ și JL
Instrucțiunea CMPQ este folosită pentru a compara valori de tip 4 octeți (4 cuvinte), iar denumirea provine de la CoMPareQuadword, prescurtată ca CMPQ.
La adresa de memorie 0x47a84e, se află instrucțiunea CMPQ os.Args+8(SB), $0x2.
În acest caz, programul compară numărul de argumente primite cu valoarea hexazecimală 0x2 (adică doar 2).
Apoi, pentru a verifica dacă argumentele sunt mai puține de 2 (adică dacă programul are doar propriul nume ca argument), se efectuează un salt condiționat prin JL. Acesta provine de la Jump, Less than, prescurtat JL.
Dacă, în urma comparației anterioare, argumentele sunt mai puține de 2, se sare la adresa 0x47a8b0, unde se află ADDQ, iar aici se folosește registrul AX, deci trebuie să cunoaștem natura valorii stocate în registru.
Instrucțiunea MOVQ
În continuare, trebuie să înțelegem cum este utilizat efectiv registrul CX pentru a stoca adresa de început a datelor, cum este citită adresa și cum se extrag apoi datele reale.
Analizând intervalul 0x47858-0x47863, operația este realizată pas cu pas.
Mai întâi, adresa de început a vectorului de argumente este introdusă în registrul CX prin instrucțiunea MOVQ os.Args(SB), CX. Pentru a înțelege acest pas, trebuie să înțelegem tipul string din Go.
Un string în Go este o structură, compusă din 2 valori de 8 octeți, adică 16 octeți în total.
| struct | 8 byte | 8 byte |
|---|---|---|
| string | mem address | string length |
Vizual, reprezentarea este cea de mai sus: primii 8 octeți conțin adresa de început a șirului, iar ultimii 8 octeți conțin lungimea șirului.
Prin urmare, adresa șirului este stocată în registrul AX, iar lungimea șirului în registrul BX.
CALL
În postarea anterioară, când am analizat funcțiile din pachetul runtime, apărea instrucțiunea CALL.
Aceasta se regăsește în fața funcțiilor utilizate în Go și înseamnă literal că se apelează o funcție. Apoi, prin funcția apelată, șirul este convertit într-un întreg, iar unde este stocat acel întreg nu este vizibil, fiind abstractizat în interiorul funcției. Nu este vizibil în funcție.
Instrucțiunile CMPQ și JGE
Revenind la adresa 0x47a86c, instrucțiunea compară adresa șirului cu numărul 0xa(10 în zecimal)!
Aceasta înseamnă că, deoarece programul nu mai folosește argumentul respectiv, compilatorul a suprascris poziția șirului pentru a crea spațiul variabilei întregi x.
Aceasta este esența optimizării agresive realizate de limbaje precum Go.
Apoi apare instrucțiunea JGE, prescurtarea de la Jump, Greater or Equals. Astfel, această structură verifică dacă valoarea este mai mare sau egală cu cea de comparat.
Prin urmare, nu este exact structura x < 10, ci direcția comparației este inversată față de x < 10!
Motivul este că, la nivel de cod mașină, este mai intuitiv și economisește o instrucțiune să sari anticipat atunci când condiția nu este îndeplinită, decât să execute comparația în cazul în care condiția este adevărată și apoi să verifice din nou dacă nu este îndeplinită.
Această optimizare este foarte clasică și, spre deosebire de exemplul strconv.Atoi de mai sus, apare frecvent și în compilatoarele cu un nivel de optimizare destul de redus, motiv pentru care merită reținută.
Astfel, aplicând această idee, putem obține surse diferite care produc assembly identic în proporție de 100%.
Exemplu de cod în oglindă
Cu ajutorul scriptului de mai jos, scriptul bash generează două surse care sunt 100% în oglindă și, după eliminarea metadatelor care variază de la o rulare la alta, se poate verifica faptul că, pentru doar main, se obține assembly exact identic.
1#!/usr/bin/env bash
2
3# 1. Curățarea completă a fișierelor și directoarelor rămase
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. Scrierea codului sursă al versiunii 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. Scrierea codului sursă al versiunii în oglindă (main_from_asm.go)
36# Structura operatorilor este sincronizată simetric astfel încât compilatorul să folosească același șablon de optimizare (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 // Menținând structura x < 10 cu 10 ca referință, compilatorul
56 // adoptă exact același mecanism JGE și aceeași plasare a blocurilor ca în main.go.
57 if x < 10 {
58 println(s1)
59 } else {
60 println(s2)
61 }
62}
63EOF
64
65# 4. Compilarea ambelor surse în același director și cu același nume de fișier
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. Extragerea secțiunilor de assembly ale funcției main.main cu 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# Eliminarea adreselor virtuale, a offsetelor și a textului cu octeții mașinii
80# și filtrarea doar a câmpurilor cu setul pur de instrucțiuni executate de CPU (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. Verificarea integrității structurale a instrucțiunilor mașinii prin 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 "===> [succes] Logica mașinii pentru main.main este identică în proporție de 100% în cele două binare! <==="
90 echo "Prin sincronizarea ghidurilor pipeline-ului de optimizare al compilatorului, s-a obținut același assembly."
91else
92 echo "===> [eșec] S-au identificat diferențe în structura instrucțiunilor assembly. <==="
93 diff -u orig_pure.asm asm_pure.asm
94fi
95echo "------------------------------------------------------------"
Rulând efectiv scriptul, se obțin informațiile de mai jos.
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===> [succes] Logica mașinii pentru main.main este identică în proporție de 100% în cele două binare! <===
9Prin sincronizarea ghidurilor pipeline-ului de optimizare al compilatorului, s-a obținut același assembly.
10------------------------------------------------------------
Concluzie
Limbajele de programare oferă multe abstractizări, dar în spatele acestora se ascund optimizări foarte interesante și agresive. De asemenea, valorificând această particularitate, am putut crea cod în oglindă care are surse diferite, dar assembly identic. Dacă ești interesat de nivelul scăzut și întâlnești software proprietar scris în Go, nu este imposibil să demontezi assembly-ul și să analizezi codul sursă pentru a-l reconstitui.
Lecția următoare
În lecția următoare vom analiza, pe lângă instrucțiunea if, și un alt subiect interesant: instrucțiunea select-case.