GoSudaАнализ генерирането на AMD64 асемблерен код за условни конструкции (if) в Go и инструкциите за условен преход
Операторът if в Go
Първо, причината да изберем Go е, че сред съвременните езици Go има най-„красивия“ асемблер, а ефективността на неговите конструкции понякога дори значително надминава тази на класическите езици.
Сега, след като в предишния урок разбрахме как работи една проста Go програма, нека веднага сравним Go и Assembly ред по ред.
Изходен код
Първо, както при Go, така и при съвременните компилатори, включително GCC, се извършва автоматична оптимизация на клонове, които нямат смисъл. Компилаторите за C, като GCC и Clang, при стандартното за индустрията ниво -O2 прилагат много агресивни оптимизации, така че епохата, в която програмистите трудно можеха да разчитат напълно на компилатора, всъщност бе окончателно отминала още от края на XX век.
Следователно, за да има смисъл, трябва да се зададат условия, които компилаторът трудно може да предвиди и да замени с друга конструкция.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // Ако това заменим с нещо предсказуемо, като x = 10, при което клонът може да бъде премахнат,
10 // компилаторът ще оптимизира кода и ще премахне клона.
11 // Затова, ако искаме да видим това директно на ниво асемблер, в C се използва например -O0,
12 // или компилаторът се принуждава да използва непредсказуема външна стойност,
13 // но тъй като тази секция разглежда съвременното програмиране, няма да използваме
14 // метод, който изключва оптимизациите на бинарния файл в 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}
В този случай, тъй като входните данни не могат да бъдат предвидени от компилатора, клонът се превежда в машинен код без промяна.
Асемблерен код
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, както е любезно, показва една по една кои конструкции на кода съответстват на кой асемблерен код.
Тъй като в този урок ще научим за операторите за сравнение и за клонението if, е достатъчно да обърнем внимание на няколко реда.
Инструкциите CMPQ и JL
Инструкцията CMPQ служи за сравняване на данни от тип 4 байта (4 думи), а нейното название произлиза от CoMPareQuadword, съкратено до CMPQ.
Ако погледнем паметния адрес 0x47a84e, там се намира конструкцията CMPQ os.Args+8(SB), $0x2.
В този случай се сравнява броят на подадените на програмата аргументи с шестнадесетичното число 0x2 (т.е. просто 2).
След това, чрез JL се извършва скок след сравнението, ако броят на аргументите е по-малък от 2 (т.е. ако програмата няма други аргументи освен собственото си име). Тоест това е съкращение от Jump, Less than', т.е. JL.
Ако при предишната операция за сравнение аргументите са по-малко от 2, се извършва скок към адрес 0x47a8b0, където се намира JGE.
Но тъй като в тази конструкция се използва регистърът AX, трябва да разберем каква е стойността, съхранена в регистъра.
Инструкцията MOVQ
След това трябва да разберем как, като се използва регистърът 'CX', се записва началният адрес на данните и как се извличат реалните данни след прочитане на адреса.
Ако разгледаме диапазона 0x47858-0x47863, тази операция се извършва на етапи.
Първо, началният адрес на масива с аргументи се записва в регистър CX с инструкцията MOVQ os.Args(SB), CX. Тук е необходимо да разберем типа string в Go.
string в Go е структура, която се състои от 2 данни по 8 байта, т.е. общо 16 байта.
| struct | 8 байта | 8 байта |
|---|---|---|
| string | адрес в паметта | дължина на низа |
Визуално това може да се представи както по-горе: първите 8 байта съдържат началния адрес на низа, а следващите 8 байта съдържат дължината на низа.
Следователно адресът на низа се записва в регистъра AX, а дължината на низа в регистъра BX.
CALL
В предишната публикация също, когато разгледахме функциите от runtime, към тях беше прикачена инструкцията CALL.
Тя се поставя пред функциите, използвани в Go, и означава, че се извиква определена функция, което буквално е и значението на CALL. След това с помощта на функция CALL низът се преобразува в цяло число, като къде се съхранява цялото число не се вижда, защото е абстрахирано във функцията.
Инструкциите CMPQ и JGE
Връщайки се към адреса 0x47a86c, инструкцията сравнява адреса на низа с числото 0xa (в десетична система 10)!
Това означава, че тъй като в програмата този аргумент вече не се използва, е презаписан на мястото на низа, за да се създаде място за целочислената променлива x.
Ето в какво се състои агресивната оптимизация, извършвана в езици като Go.
След това се появява инструкцията JGE, която е съкращение от Jump, Greater or Equals. Следователно тази конструкция проверява дали стойността е по-голяма или равна при сравнение с целта.
Следователно не е записано точно като x < 10, а x < 10 е представено с обърната посока на сравнението!
В машинния код това е така, защото предварително прескачането, когато условието не е изпълнено, е по-интуитивно и спестява 1 инструкция в сравнение с извършването на сравнение веднъж при изпълнено условие и след това повторна проверка дали не е изпълнено.
Тази оптимизация е много класическа и за разлика от примера strconv.Atoi, който видяхме по-горе, е често срещан модел дори при компилатори с доста ниско ниво на оптимизация, затова е добре да се знае.
Следователно, ако приложим тези особености, можем да получим изходни кодове, които са различни, но на ниво асемблер съвпадат на 100%.
Примери за огледален код
С помощта на скрипта по-долу може да се провери, че bash скриптът създава два изходни кода, които са 100% огледални, и че след изключване на метаданните, които се променят при всяко изпълнение, при разглеждане само на main се получава точно същият асемблерен код.
1#!/usr/bin/env bash
2
3# 1. Пълно почистване на старите остатъчни файлове и директории
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. Създаване на изходния код на оригиналната версия (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. Създаване на изходния код на огледалната версия (main_from_asm.go)
36# Структурата на операторите е напълно синхронизирана симетрично, така че компилаторът да използва същия оптимизационен шаблон (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 // Ако запазим x < 10 като структура, като се базираме на 10, компилаторът
56 // ще използва точно същия механизъм JGE и разположение на блоковете като main.go.
57 switch {
58 case x < 10:
59 println(s1)
60 default:
61 println(s2)
62 }
63}
64EOF
65
66# 4. Компилиране на всеки от двата източника в същата директория и със същото име на файл
67echo "[4/6] Compiling both sources inside 'test_dir'..."
68cp main.go test_dir/main.go
69cd test_dir && go build -o ../main_orig main.go && cd ..
70rm test_dir/main.go
71
72cp main_from_asm.go test_dir/main.go
73cd test_dir && go build -o ../main_asm main.go && cd ..
74
75# 5. Извличане на чистата асемблерна функция main.main с помощта на go tool objdump
76echo "[5/6] Extracting main.main assembly sections..."
77go tool objdump -s "main\.main" main_orig > orig.asm
78go tool objdump -s "main\.main" main_asm > asm.asm
79
80# Премахване на виртуалните адреси, отместванията и текста с машинните байтове
81# и филтриране само на полетата с чистия набор инструкции (Opcode и Operands), които ще се изпълняват от процесора
82awk '{print $4, $5, $6, $7}' orig.asm > orig_pure.asm
83awk '{print $4, $5, $6, $7}' asm.asm > asm_pure.asm
84
85# 6. Проверка на различията между структурите на двете машинни инструкции чрез diff
86echo "[6/6] Verifying assembly structural integrity via diff..."
87echo "------------------------------------------------------------"
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 "------------------------------------------------------------"
При реалното изпълнение на скрипта се получава следната информация.
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------------------------------------------------------------
Заключение
Програмните езици предлагат много абстракции, но зад тях се крият много интересни и агресивни оптимизации. Също така, като използвахме тези особености в обратна посока, успяхме да създадем огледален код, при който изходните кодове са различни, а асемблерният код е същият. Ако се интересувате от ниско ниво и се сблъскате с патентован софтуер, написан на Go, вероятно би било възможно, макар и не лесно, да се възстанови изходният код чрез директно дисасемблиране и анализ на асемблерния код.
Следващ урок
В следващия урок ще разгледаме оператора if и друг интересен оператор: select-case.