GoSuda

Анализ на рънтайм структурата на управляваните езици и на асемблерния код за AMD64 в Go бинарни файлове

By Lee Yunjin views ...

Какво представлява управляемият език?

Управляемият език е език, който, за разлика от неуправляемите езици, при които изпълнението в голяма степен следва логиката, написана от програмиста, извършва в рамките на времето за изпълнение (runtime) задачи като събиране на отпадъци (GC), оптимизации по време на изпълнение, зелени нишки (green threads) и обработка на едновременност, като по този начин освобождава потребителя от необходимостта да извършва опасно управление на ниско ниво. При такива езици предимството е, че разработчикът може да се концентрира върху бизнес логиката и да се потопи в разработката, но от друга страна, поведението на действителната програма може да се различава от интуицията на програмиста, поради което понякога е необходима прецизна настройка на времето за изпълнение. Първо ще разгледаме Go, най-вярно следващия минималистичната философия сред управляемите езици и с прозрачен асемблерен код.

Структура на двоичния файл в Go

.text.data.gopclntab, .typelink и др.
Машинен код за изпълнениеДанни за съхранениеСекции на езиковото време за изпълнение

Тъй като Go не превежда един към един в машинен код както е написано от потребителя, логиката в секцията .text е тясно свързана със секциите на езиковото време за изпълнение. Освен това във асемблерния код на секцията .text се добавят функции, които потребителят не е писал, като например runtime.printnl(). Чрез това автоматично вмъкване на код Go помага на разработчика да се освободи от ръчното управление.

Разглеждане само на функцията main в Go

Първо, нека напишем прост примерен изходен файл main.go и да разгледаме main на машина с AMD64.

 1package main
 2
 3func sayHello(msg string) {
 4    println(msg)
 5}
 6
 7func main() {
 8    sayHello("Hello World")
 9}
10

След това компилираме по следния начин.

1go build main.go
2

За улеснено ниско ниво дебъгване Go предоставя go tool. За да видим само асемблерния код на функцията main от главния пакет, въвеждаме следната команда.

1go tool objdump -s "main\.main" ./main
2

Асемблерен код

 1TEXT main.main(SB) /home/yjlee/compare-assembly/go/main.go
 2  main.go:7             0x468f60                493b6610                CMPQ SP, 0x10(R14)
 3  main.go:7             0x468f64                762f                    JBE 0x468f95
 4  main.go:7             0x468f66                55                      PUSHQ BP
 5  main.go:7             0x468f67                4889e5                  MOVQ SP, BP
 6  main.go:7             0x468f6a                4883ec10                SUBQ $0x10, SP
 7  main.go:8             0x468f6e                90                      NOPL
 8  main.go:4             0x468f6f                e8cca3fcff              CALL runtime.printlock(SB)
 9  main.go:4             0x468f74                488d05da290100          LEAQ 0x129da(IP), AX
10  main.go:4             0x468f7b                bb0b000000              MOVL $0xb, BX
11  main.go:4             0x468f80                e83bacfcff              CALL runtime.printstring(SB)
12  main.go:4             0x468f85                e8f6a5fcff              CALL runtime.printnl(SB)
13  main.go:4             0x468f8a                e811a4fcff              CALL runtime.printunlock(SB)
14  main.go:9             0x468f8f                4883c410                ADDQ $0x10, SP
15  main.go:9             0x468f93                5d                      POPQ BP
16  main.go:9             0x468f94                c3                      RET
17  main.go:7             0x468f95                e8e6afffff              CALL runtime.morestack_noctxt.abi0(SB)
18  main.go:7             0x468f9a                ebc4                    JMP main.main(SB)
19
  • Сравнява се стойността на защитата на стека (stack guard), съхранена в регистъра на блока за управление на горутината (R14), с текущия указател на стека (SP) чрез CMPQ. Ако пространството е недостатъчно, се извършва скок (JBE) към входната точка 0x468f95 за разширяване на стека.
  • Предишният базов указател се запазва в стека чрез PUSHQ BP.
  • Текущият указател на стека (SP) се копира в базовия указател (BP), за да се фиксира начална точка на стека за функцията.
  • След това се заделя локално пространство в стека от 16 байта (SUBQ $0x10, SP) и с NOPL се запълват псевдоинструкции за подравняване на CPU кеша.
  • Извиква се runtime.printlock(SB), за да се вземе ключ за синхронизация на стандартния изход на низове в средата на времето за изпълнение на Go.
  • Инструкцията LEAQ записва началния адрес на константния низ ("Hello World") в AX, който според Go ABI се използва като първи параметър сред регистрите с общо предназначение.
  • След това стойността, определяща дължината на низа, се записва във втория регистър на параметър BX (MOVL $0xb, BX, т.е. 11 в десетичен запис).
  • Извиква се runtime.printstring(SB), който извежда на конзолата въз основа на предадените AX (адрес на данните) и BX (дължина).
  • За прехвърляне на нов ред се извиква runtime.printnl(SB).
  • Тъй като изходът е завършен, ключът се освобождава чрез runtime.printunlock(SB).
  • Със ADDQ $0x10, SP се възстановява заделената памет от 16 байта в стека.
  • Чрез POPQ BP се възстановява предишният базов указател.
  • Чрез RET управлението се връща към мястото, от което е извикана функцията.
  • Ако при първоначалната проверка на стека пространството е било недостатъчно, се извиква runtime.morestack_noctxt.abi0(SB) на адрес 0x468f95, за да се разшири динамично стекът на времето за изпълнение, както е характерно за управляемите езици.
  • След разширяването на стека се извършва връщане (JMP) към входната точка на main.main(SB). Както се вижда, асемблерният код на бизнес логиката е доста ясен и към него е прибавено само тънко управление от времето за изпълнение.

Когато няма оптимизация

Горната форма е резултат от автоматичното вграждане (inlining) на двете отделни функции от Go компилатора. Въпреки това, за целите на обучението, в този случай ще забраним вграждането на sayHello. За да постигнем това, компилираме изходния код със следния флаг.

1go build -gcflags="-l" main.go
2

Ако изведем резултата в терминала, ще забележим дублиращ се асемблерен код.

 1yjlee@elegant:~/compare-assembly/go$ go build -gcflags="-l" main.go
 2
 3go tool objdump -s "main\.sayHello" ./main
 4TEXT main.sayHello(SB) /home/yjlee/compare-assembly/go/main.go
 5  main.go:3             0x468f60                493b6610               CMPQ SP, 0x10(R14)
 6  main.go:3             0x468f64                7636                   JBE 0x468f9c
 7  main.go:3             0x468f66                55                     PUSHQ BP
 8  main.go:3             0x468f67                4889e5                 MOVQ SP, BP
 9  main.go:3             0x468f6a                4883ec10               SUBQ $0x10, SP
10  main.go:5             0x468f6e                4889442420             MOVQ AX, 0x20(SP)
11  main.go:5             0x468f73                48895c2428             MOVQ BX, 0x28(SP)
12  main.go:4             0x468f78                e8c3a3fcff             CALL runtime.printlock(SB)
13  main.go:4             0x468f7d                488b442420             MOVQ 0x20(SP), AX
14  main.go:4             0x468f82                488b5c2428             MOVQ 0x28(SP), BX
15  main.go:4             0x468f87                e834acfcff             CALL runtime.printstring(SB)
16  main.go:4             0x468f8c                e8efa5fcff             CALL runtime.printnl(SB)
17  main.go:4             0x468f91                e80aa4fcff             CALL runtime.printunlock(SB)
18  main.go:5             0x468f96                4883c410               ADDQ $0x10, SP
19  main.go:5             0x468f9a                5d                     POPQ BP
20  main.go:5             0x468f9b                c3                     RET
21  main.go:3             0x468f9c                4889442408             MOVQ AX, 0x8(SP)
22  main.go:3             0x468fa1                48895c2410             MOVQ BX, 0x10(SP)
23  main.go:3             0x468fa6                e8d5afffff             CALL runtime.morestack_noctxt.abi0(SB)
24  main.go:3             0x468fab                488b442408             MOVQ 0x8(SP), AX
25  main.go:3             0x468fb0                488b5c2410             MOVQ 0x10(SP), BX
26  main.go:3             0x468fb5                eba9                   JMP main.sayHello(SB)
27

Когато вграждането е деактивирано, за да се запазят параметрите (AX, BX) според конвенцията за извикване на функции, се вмъкват инструкции MOVQ, които записват стойностите отново в стека на отмествания 0x20(SP) и други. Следователно беше потвърдено, че именно тези ненужни операции за преместване на памет и разходите за извикване на функции са обект на оптимизация от компилатора.

Следващ път

Следващият път ще разгледаме оператори if и switch в Go. Ако има време впоследствие, ще анализираме и секциите на времето за изпълнение на Go.