GoSudaAnalyse der AMD64-Assemblercodegenerierung und Verzweigungsbefehle für Go-Bedingungsanweisungen (if)
If-Anweisungen in der Programmiersprache Go
Zunächst ist anzumerken, dass wir Go gewählt haben, weil Go unter den modernen Sprachen dasjenige ist, dessen Assembler am „schönsten" ausfällt, und seine syntaktische Effizienz im Vergleich zu klassischen Sprachen mitunter sogar überwältigend ist.
Nachdem wir im vorherigen Kurs die Funktionsweise eines einfachen Go-Programms verstanden haben, wollen wir nun Go und Assembly zeilenweise miteinander vergleichen.
Quellcode
Zunächst ist festzuhalten, dass moderne Compiler, und zwar nicht nur Go, sondern sogar einschließlich GCC, Verzweigungen, die keinen Zweck erfüllen, automatisch optimieren. Auch die C-Compiler GCC und Clang führen bei der branchenüblichen Optimierungsstufe -O2 sehr aggressive Optimierungen durch; die Ära, in der Programmierer dem Compiler nur schwer vollständig vertrauen konnten, ist somit spätestens seit dem Ende des 20. Jahrhunderts tatsächlich abgeschlossen.
Daher ist es nur dann sinnvoll, Bedingungen so zu gestalten, dass sie aus Sicht des Compilers schwer vorhersagbar sind und sich nicht ohne Weiteres durch andere Konstrukte ersetzen lassen.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Wenn man dies durch etwas Vorhersagbares wie x = 10 ersetzt, das die Verzweigung entfernen lässt,
10 // optimiert der Compiler und entfernt die Verzweigung.
11 // Um dies direkt in Assembly zu betrachten, setzt man in C beispielsweise -O0 oder
12 // lässt den Compiler einen für ihn nicht vorhersagbaren externen Wert verwenden.
13 // Da dieser Abschnitt moderne Programmierung behandelt, verwenden wir nicht
14 // den Weg, die binäre Optimierung von Go abzuschalten.
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 diesem Fall kann der Compiler die Eingabe nicht vorhersagen, daher wird die Verzweigung unverändert in Maschinencode übersetzt.
Assemblersprache
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)
Das go-Werkzeug (go tool) zeigt auf komfortable Weise an, welche Anweisung welchem Assembler-Code entspricht.
Da wir in diesem Kurs Vergleichsoperationen und if-Verzweigungen behandeln, genügt es, einige wenige Zeilen zu betrachten.
CMPQ-Befehl und JL-Befehl
Der Befehl CMPQ dient dem Vergleich von Operanden mit einer Größe von 4 Byte (4 Wörter); seine Bezeichnung leitet sich von CoMPareQuadword ab und wurde daher zu CMPQ verkürzt.
Betrachtet man die Speicheradresse 0x47a84e, findet sich dort die Anweisung CMPQ os.Args+8(SB), $0x2.
In diesem Fall vergleicht das Programm die Anzahl der übergebenen Argumente mit dem hexadezimalen Wert 0x2 (also schlicht der Zahl 2).
Anschließend wird mittels JL abhängig vom Vergleichsergebnis ein Sprung ausgeführt, sofern die Anzahl der Argumente kleiner als 2 ist (also wenn nur das Programm selbst als Argument vorhanden ist). JL steht für Jump, Less than. Bei einem Ergebnis, bei dem die Argumentanzahl kleiner als 2 war, springt die Ausführung zur Adresse 0x47a8b0; dort befindet sich jedoch ein JGE.
Da in dieser Anweisung das Register AX verwendet wird, muss man allerdings wissen, welcher Wert im Register gespeichert ist.
MOVQ-Befehl
Danach ist zu klären, wie das Register CX genutzt wird, um die Anfangsadresse der Daten zu speichern, und wie die eigentlichen Daten nach dem Lesen der Adresse extrahiert werden.
Im Bereich 0x47a858-0x47a863 wird diese Operation schrittweise ausgeführt.
Zunächst wird die Anfangsadresse des Argumentfeldes mit dem Befehl MOVQ os.Args(SB), CX in das Register CX geladen. Dabei muss man den Stringtyp von Go verstehen.
Ein string in Go ist eine Struktur, die aus zwei Daten zu je 8 Byte besteht und insgesamt 16 Byte umfasst.
| struct | 8 byte | 8 byte |
|---|---|---|
| string | mem address | string length |
Veranschaulicht sieht dies wie oben aus: Die ersten 8 Byte enthalten die Anfangsadresse des Strings, die folgenden 8 Byte die Länge des Strings.
Daher wird die Adresse des Strings im Register AX und die Länge des Strings im Register BX gespeichert.
CALL
Auch in dem vorherigen Beitrag stand bei der Betrachtung von Funktionen des runtime-Pakets der Befehl CALL.
Dieser steht vor den Funktionen, die in Go verwendet werden, und bedeutet wörtlich, dass eine Funktion aufgerufen wird. Anschließend wird mithilfe eines CALL-Aufrufs der String in eine Ganzzahl umgewandelt; wohin diese Ganzzahl gespeichert wird, ist dabei in der Funktion abstrahiert und nicht sichtbar.
CMPQ-Befehl und JGE-Befehl
Kehren wir nun zur Adresse 0x47a86c zurück: Der Befehl vergleicht die Adresse des Strings mit der Zahl 0xa (dezimal 10)!
Das bedeutet, dass das Programm die Argumente nicht weiter benötigt und deshalb den Speicherplatz des Strings überschreibt, um die Stelle der ganzzahligen Variablen x zu schaffen.
Dies ist das eigentliche Wesen der aggressiven Optimierung, wie sie unter anderem in Go vorgenommen wird.
Danach erscheint der Befehl JGE, der eine Abkürzung für Jump, Greater or Equals ist. Diese Anweisung prüft daher, ob der Wert im Vergleich größer oder gleich ist.
Somit lautet die Bedingung nicht genau wie im Quellcode x < 10, sondern die Vergleichsrichtung ist umgekehrt!
Dies geschieht auf Maschinenebene, weil es unmittelbarer ist und einen Befehl einspart, bei Nichterfüllung der Bedingung vorab zu springen, statt im Falle der Erfüllung einen Vergleich auszuführen und anschließend erneut zu prüfen, ob die Bedingung nicht zutrifft.
Diese Optimierung ist sehr klassisch; im Unterschied zum oben betrachteten Beispiel von strconv.Atoi tritt sie häufig auch bei Compilern mit eher geringem Optimierungsniveau auf. Deshalb ist es nützlich, sie zu kennen.
Wendet man diesen Zusammenhang gezielt an, lässt sich somit ein Quellcode erzeugen, der sich zwar im Wortlaut unterscheidet, auf Assembler-Ebene jedoch zu 100 % identisch ist.
Spiegelbildliche Codebeispiele
Mit dem folgenden Skript kann ein Bash-Skript zwei zu 100 % spiegelbildliche Quellcodes erzeugen; anschließend lässt sich nachweisen, dass unter Ausschluss der jeweils variierenden Metadaten nur main betrachtet exakt dieselbe Assembler-Ausgabe entsteht.
1#!/usr/bin/env bash
2
3# 1. Vollständige Bereinigung vorhandener Restdateien und Verzeichnisse
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. Schreiben des Quellcodes der Originalversion (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. Schreiben des spiegelbildlichen Quellcodes (main_from_asm.go)
36# Die Operatorstruktur wird vollständig symmetrisch abgeglichen, damit der Compiler dieselbe JGE-Vorlage verwendet
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 // Wenn man sich an 10 orientiert und die Struktur x < 10 beibehält, übernimmt der Compiler
56 // exakt denselben JGE-Mechanismus und dieselbe Blockanordnung wie bei main.go.
57 if x < 10 {
58 println(s1)
59 } else {
60 println(s2)
61 }
62}
63EOF
64
65# 4. Kompilieren beider Quellen in identischer Verzeichnis- und Dateinamenumgebung
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. Extraktion der reinen main.main-Assembler-Funktion mittels 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# Entfernen der virtuellen Adressen, Offsets und Maschinencode-Bytes,
80# Filterung ausschließlich der ausführbaren Befehlsfelder (Opcode & Operanden)
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. Überprüfung der Struktur der Maschinenbefehle per 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 "------------------------------------------------------------"
Führt man das Skript tatsächlich aus, erhält man folgende Informationen.
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------------------------------------------------------------
Fazit
Programmiersprachen bieten zahlreiche Abstraktionen, doch hinter diesen Abstraktionen verbergen sich überaus interessante und aggressive Optimierungen. Ferner konnte durch gezielte Ausnutzung dieses Verhaltens spiegelbildlicher Code erzeugt werden, dessen Quellcode sich unterscheidet, dessen Assembler-Ausgabe jedoch identisch ist. Wer sich für die Tiefen der Maschinenebene interessiert und auf proprietäre Software in Go stößt, für den ist es vermutlich nicht unmöglich, den Assembler zu zerlegen und daraus den Quellcode zu rekonstruieren.
Nächste Lerneinheit
In der nächsten Einheit werden wir uns neben if-Anweisungen mit der ebenfalls spannenden select-case-Anweisung beschäftigen.