GoSuda

Analys av runtimestrukturen för hanterade språk och AMD64-assembler i Go-binärfiler

By Lee Yunjin views ...

Vad är ett hanterat språk?

Ett hanterat språk är ett språk som, till skillnad från ett ohanterat språk, det vill säga ett språk som i huvudsak bara utför den logik som programmeraren har skrivit, kör GC, runtime-optimeringar, gröna trådar, hantering av samtidighet och liknande funktioner i runtime, så att användaren inte behöver utföra farlig lågnivåhantering. För sådana språk finns fördelen att man kan koncentrera sig på affärslogiken och fullt ut fokusera på utvecklingen, men samtidigt kan programmerarens intuition skilja sig från hur programmet faktiskt beter sig, vilket ibland kräver noggrann runtime-tuning. Först ska vi titta på Go, det hanterade språk som är mest trogen en minimalistisk filosofi och vars assembler är tydlig.

Go-språkets binärstruktur

.text.data.gopclntab, .typelink m.fl.
Maskinkod som ska körasData som ska lagrasSpråkets runtime-sektioner

Eftersom Go inte översätter användarens kod till maskinkod på ett 1:1-sätt är logiken i .text-sektionen nära kopplad till språkets runtime-sektioner. Dessutom läggs funktioner som runtime.printnl() i .text-sektionens assembler, även om användaren inte har skrivit dem. Genom sådan automatisk kodinsättning hjälper Go utvecklaren att befrias från manuell hantering.

Att endast titta på main-funktionen i Go

Låt oss först skriva ett enkelt exempelprogram main.go och titta på main från AMD64-maskin.

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

Bygg sedan med följande kommando.

1go build main.go
2

Go stödjer lågnivåfelsökning via go tool. För att endast se assemblern för main-funktionen i main-paketet med go tool använder vi följande kommando.

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

Assembler

 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
  • Jämför stackramens tillgängliga utrymme för den aktuella goroutinen genom att använda CMPQ för att jämföra stackvakten i goroutinens kontrollblocksregister (R14) med den aktuella stackpekaren (SP). Om utrymmet är otillräckligt hoppar programmet (JBE) till inträdespunkten 0x468f95 för stackutökning.
  • Infoga PUSHQ BP för att spara den föregående basepekaren på stacken.
  • Kopiera den aktuella stackpekaren (SP) till basepekarregistret (BP) för att fixera stackens referenspunkt vid funktionens start.
  • Allokera därefter 16 byte lokalt variabelutrymme på stacken (SUBQ $0x10, SP) och använd NOPL för att fylla med en verkningslös instruktion, vilket utför CPU-cachejustering.
  • Anropa runtime.printlock(SB) för att ta låset och synkronisera Go-runtimes interna standardutmatning för strängar.
  • Använd instruktionen LEAQ för att lagra startadressen för den konstanta strängen ("Hello World") i AX, som enligt Go ABI-specifikationen används som första parameter.
  • Lagra därefter strängens längd i BX, som är den andra parameterregistret. (MOVL $0xb, BX, det vill säga 11 i decimal form)
  • Anropa runtime.printstring(SB) för att skriva ut till konsolen utifrån informationen i AX (dataadress) och BX (längd).
  • Anropa runtime.printnl(SB) för att hantera radbrytningen.
  • Eftersom utskriften är klar frigörs låset via runtime.printunlock(SB).
  • Återställ de 16 byte stackminne som allokerades med ADDQ $0x10, SP.
  • Återställ den ursprungliga basepekaren med POPQ BP.
  • Returnera kontrollen till anropspunkten med RET.
  • Om utrymmet var otillräckligt vid den första stackkontrollen anropas runtime.morestack_noctxt.abi0(SB) vid adressen 0x468f95 för att dynamiskt utöka stacken på det sätt som är typiskt för ett hanterat språk.
  • När stackutökningen är klar återvänder programmet (JMP) till ingångspunkten i main.main(SB). Som framgår är assemblern för affärslogiken ganska tydlig och har endast en tunn runtime-hantering tillagd.

När det inte finns några optimeringar

Ovanstående form är resultatet av att Go-kompilatorn automatiskt inlinar de två separata funktionerna och optimerar dem. För studiens skull kommer vi dock i detta fall att förhindra att sayHello inlinas. För att göra det kompilerar vi källkoden med följande flagga.

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

Om man skriver ut resultatet i terminalen hittar man överlappande assembler.

 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

När inlining inaktiveras infogas MOVQ-instruktioner som laddar om värden på stackpekarens offset, till exempel 0x20(SP), för att bevara parametrarna (AX, BX) enligt funktionsanropskonventionen. Det innebär att det är just dessa onödiga minnesflyttningar och anropskostnader som kompilatorns optimering riktar in sig på.

Nästa gång

Nästa gång kommer vi att behandla if- och switch-satser i Go. Om tiden finns kommer vi även att analysera Go:s runtime-sektioner.