If-satser i programmeringsspråket Go
If-satser i Go
Först och främst beror vårt val av Go på att språket, bland moderna programmeringsspråk, besitter den mest "estetiska" assemblerkoden, och att dess syntaktiska effektivitet ofta är överlägsen även i jämförelse med klassiska språk.
Nu när vi i föregående lektion har förstått hur ett enkelt Go-program fungerar, ska vi omedelbart jämföra Go och Assembly rad för rad.
Källkod
Redan i Go, och i ännu högre grad i moderna kompilatorer inklusive GCC, utförs automatisk optimering av förgreningssatser som saknar praktisk betydelse. C-kompilatorer som GCC och Clang utför mycket aggressiv optimering vid branschstandarden -O2, vilket innebär att den era då en programmerare kunde förvänta sig att kompilatorn var fullständigt transparent i praktiken avslutades redan under sena 1900-talet.
Följaktligen får koden endast betydelse om vi tillhandahåller villkor som är svåra för kompilatorn att förutsäga och omvandla till andra konstruktioner.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Om detta ersätts med något förutsägbart som x = 10, där förgreningen kan tas bort,
10 // kommer kompilatorn att optimera bort förgreningen.
11 // För att studera detta direkt i assembly i C skulle man använda -O0 eller liknande,
12 // eller använda externa värden som är oförutsägbara för kompilatorn.
13 // Eftersom denna sektion behandlar modern programmering använder vi inte metoder
14 // för att inaktivera binäroptimering i 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}
I detta fall översätts förgreningssatsen direkt till maskinkod eftersom kompilatorn inte kan förutsäga indata.
Assemblerkod
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)
Genom att använda go tool kan vi på ett pedagogiskt sätt se exakt vilken syntax som motsvarar vilken assemblerkod.
Eftersom vi i denna lektion studerar jämförelsesatser och if-förgreningar, bör vi fokusera på ett fåtal rader.
CMPQ-instruktion & JL-instruktion
CMPQ-instruktionen används för att jämföra 4-byte (4-word) datatyper, där namnet härleds från CoMPare Quadword.
Om vi betraktar minnesadressen 0x47a84e ser vi syntaxen CMPQ os.Args+8(SB), $0x2.
I detta fall jämför programmet antalet mottagna argument med det hexadecimala värdet 0x2 (vilket helt enkelt är 2).
Därefter utförs en hoppinstruktion via JL om argumenten är färre än 2 (det vill säga om programmet endast körs med sig självt som argument). Detta står för Jump, Less than.
Om argumenten var färre än 2 vid den föregående jämförelsen hoppar programmet till adressen 0x47a8b0, där en JGE-instruktion återfinns.
Eftersom denna konstruktion använder AX-registret måste vi dock förstå vad värdet i registret representerar.
MOVQ-instruktion
Därefter måste vi förstå hur data extraheras genom att använda CX-registret för att lagra startadressen för datan.
Om vi granskar intervallet 0x47858-0x47863 ser vi hur denna operation utförs stegvis.
Först infogas startadressen för argumentarrayen i CX-registret med kommandot MOVQ os.Args(SB), CX. Här krävs en förståelse för Go-strängtypen.
En string i Go är en struct som består av 16 byte, uppdelad i två 8-byte-element.
| struct | 8 byte | 8 byte |
|---|---|---|
| string | mem address | string length |
Visuellt ser det ut enligt ovan; de första 8 byten lagrar strängens startadress och de efterföljande 8 byten lagrar strängens längd.
Följaktligen lagras strängens adress i AX-registret och strängens längd i BX-registret.
CALL
I tidigare inlägg, när vi granskat funktioner i runtime, har vi noterat instruktionen CALL.
Denna prefixeras framför funktioner som används i Go och innebär bokstavligen att en funktion anropas. Därefter används CALL-funktionen för att konvertera strängen till ett heltal, men var heltalet lagras framgår inte direkt i funktionen då det är abstraherat.
CMPQ-instruktion & JGE-instruktion
Om vi återgår till adressen 0x47a86c ser vi att instruktionen jämför strängens adress med talet 0xa (10 i decimal form)!
Detta innebär att eftersom programmet inte längre använder det aktuella argumentet, har kompilatorn skrivit över strängens position för att skapa utrymme för heltalsvariabeln x.
Detta är essensen av den aggressiva optimering som sker i språk som Go.
Därefter dyker instruktionen JGE upp, vilket är en förkortning för Jump, Greater or Equals. Denna konstruktion frågar alltså om jämförelseobjektet är större än eller lika med värdet.
Därmed är jämförelseriktningen i x < 10 omvänd jämfört med den ursprungliga koden!
I maskinkod är det nämligen mer intuitivt och sparar en instruktion att proaktivt hoppa över kod när ett villkor inte är uppfyllt, snarare än att utföra en jämförelse och sedan kontrollera om den inte stämmer.
Denna form av optimering är klassisk och förekommer frekvent även i kompilatorer med betydligt lägre optimeringsnivå än vad som visas i exemplet med strconv.Atoi, varför den är värdefull att känna till.
Genom att tillämpa denna insikt kan man skapa källkod som ser annorlunda ut men som resulterar i identisk assemblerkod.
Exempel på spegelvänd kod
Genom att använda nedanstående skript kan man verifiera att ett Bash-skript skapar två källkoder som är 100 % spegelvända, och att assemblerkoden för main blir exakt densamma när man exkluderar metadata som varierar vid kompilering.
1#!/usr/bin/env bash
2
3# 1. Fullständig rensning av tidigare filer och kataloger
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. Skapande av källkod för originalversionen (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. Skapande av källkod för spegelvänd version (main_from_asm.go)
36# Strukturen synkroniseras för att kompilatorn ska använda samma optimeringsmall (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 // Genom att utgå från 10 och behålla x < 10-strukturen,
56 // antar kompilatorn samma JGE-mekanism och blockplacering som i main.go.
57 if x < 10 {
58 println(s1)
59 } else {
60 println(s2)
61 }
62}
63EOF
64
65# 4. Byggprocess för båda källkoderna i samma katalogmiljö
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. Extrahering av assemblerkod för main.main med 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# Filtrering av ren instruktionsuppsättning (Opcode & Operands)
80# genom att exkludera virtuella adresser, offset och maskinkod
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. Verifiering av strukturell integritet via 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 "===> [Framgång] main.main maskinkodslogik i båda binärerna är 100 % identisk! <==="
90 echo "Genom att synkronisera kompilatorns optimeringspipeline har vi erhållit identisk assemblerkod."
91else
92 echo "===> [Misslyckande] Skillnader i assemblerkodens struktur har identifierats. <==="
93 diff -u orig_pure.asm asm_pure.asm
94fi
95echo "------------------------------------------------------------"
Vid körning av skriptet erhålls följande resultat:
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===> [Framgång] main.main maskinkodslogik i båda binärerna är 100 % identisk! <===
9Genom att synkronisera kompilatorns optimeringspipeline har vi erhållit identisk assemblerkod.
10------------------------------------------------------------
Slutsats
Programmeringsspråk erbjuder omfattande abstraktioner, men bakom dessa döljer sig intressanta och aggressiva optimeringar. Genom att utnyttja detta kan vi skapa kod som ser olika ut i källtext men genererar identisk assemblerkod. Om man har ett intresse för lågnivåprogrammering och stöter på proprietär mjukvara skriven i Go, är det inte omöjligt att återskapa källkoden genom att dekompilera och analysera assemblerkoden.
Nästa lektion
I nästa lektion kommer vi att utforska select-case-satsen, som erbjuder ytterligare intressanta aspekter utöver if-satser.