Moje ulubione opcje kompilacji dla Go
Te przydatne opcje kompilacji Go mogą pomóc lepiej zrozumieć proces kompilacji Go.
Jedną z najbardziej satysfakcjonujących części nauki nowego języka programowania jest wreszcie uruchomienie pliku wykonywalnego i uzyskanie pożądanych wyników. Kiedy odkryłem język programowania Go, zacząłem od przeczytania kilku przykładowych programów, aby zapoznać się ze składnią, a następnie napisałem małe programy testowe. Z biegiem czasu takie podejście pomogło mi zapoznać się z kompilacją i budowaniem programu.
Opcje kompilacji dostępne dla Go umożliwiają uzyskanie większej kontroli nad procesem kompilacji. Mogą również dostarczyć dodatkowych informacji, które pomogą podzielić proces na mniejsze części. W tym artykule zademonstruję niektóre z opcji, z których korzystałem. Uwaga: używam terminów kompiluj i kompiluj , aby oznaczać to samo.
Pierwsze kroki z Go
Używam Go w wersji 1.16.7; jednakże podane tutaj polecenie powinno działać również w najnowszych wersjach. Jeśli nie masz zainstalowanego Go, możesz pobrać go ze strony Go i postępować zgodnie z instrukcjami instalacji. Sprawdź zainstalowaną wersję, otwierając polecenie Monit i wpisując:
$ go versionOdpowiedź powinna wyglądać tak, w zależności od wersji.
go version go1.16.7 linux/amd64
$Podstawowa kompilacja i wykonywanie programów Go
Zacznę od przykładowego programu Go, który po prostu wypisuje na ekranie „Hello World”.
$ cat hello.go
package main
import "fmt"
func main() {
fmt.Println("Hello World")
}
$
Zanim omówię bardziej zaawansowane opcje, wyjaśnię, jak skompilować przykładowy program Go. Używam opcji build , po której następuje nazwa pliku źródłowego programu Go, czyli w tym przypadku hello.go.
$ go build hello.goJeśli wszystko działa poprawnie, w bieżącym katalogu powinieneś zobaczyć plik wykonywalny o nazwie hello. Możesz sprawdzić, czy jest to binarny format wykonywalny ELF (na platformie Linux), używając polecenia file. Możesz także go uruchomić i sprawdzić, czy wyświetli się komunikat „Hello World”.
$ ls
hello hello.go
$
$ file ./hello
./hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
$
$ ./hello
Hello World
$Go udostępnia przydatną opcję run na wypadek, gdybyś nie chciał mieć wynikowego pliku binarnego i zamiast tego chciał sprawdzić, czy program działa poprawnie i wypisuje żądane dane wyjściowe. Pamiętaj, że nawet jeśli nie widzisz pliku wykonywalnego w bieżącym katalogu, Go nadal kompiluje i tworzy gdzieś plik wykonywalny, uruchamia go, a następnie usuwa z systemu. Wyjaśnię to w dalszej części tego artykułu.
$ go run hello.go
Hello World
$
$ ls
hello.go
$Pod maską
Powyższe polecenia działały błyskawicznie, uruchamiając mój program przy minimalnym wysiłku. Jeśli jednak chcesz dowiedzieć się, co Go robi pod maską, aby skompilować te programy, Go udostępnia opcję -x, która wypisuje wszystko, co Go robi, aby utworzyć plik wykonywalny.
Szybki rzut oka mówi, że Go tworzy tymczasowy katalog roboczy w /tmp, tworzy plik wykonywalny, a następnie przenosi go do bieżącego katalogu, w którym znajdował się źródłowy program Go.
$ go build -x hello.go
WORK=/tmp/go-build1944767317
mkdir -p $WORK/b001/
<< snip >>
mkdir -p $WORK/b001/exe/
cd .
/usr/lib/golang/pkg/tool/linux_amd64/link -o $WORK \
/b001/exe/a.out -importcfg $WORK/b001 \
/importcfg.link -buildmode=exe -buildid=K26hEYzgDkqJjx2Hf-wz/\
nDueg0kBjIygx25rYwbK/W-eJaGIOdPEWgwC6o546 \
/K26hEYzgDkqJjx2Hf-wz -extld=gcc /root/.cache/go-build /cc \
/cc72cb2f4fbb61229885fc434995964a7a4d6e10692a23cc0ada6707c5d3435b-d
/usr/lib/golang/pkg/tool/linux_amd64/buildid -w $WORK \
/b001/exe/a.out # internal
mv $WORK/b001/exe/a.out hello
rm -r $WORK/b001/Pomaga to rozwiązać tajemnice, gdy program działa, ale w bieżącym katalogu nie jest tworzony żaden plik wykonywalny. Użycie -x pokazuje, że plik wykonywalny rzeczywiście został utworzony w katalogu roboczym /tmp i został wykonany. Jednak w przeciwieństwie do opcji build plik wykonywalny nie został przeniesiony do bieżącego katalogu, co sprawiało wrażenie, że nie utworzono żadnego pliku wykonywalnego.
$ go run -x hello.go
mkdir -p $WORK/b001/exe/
cd .
/usr/lib/golang/pkg/tool/linux_amd64/link -o $WORK/b001 \
/exe/hello -importcfg $WORK/b001/importcfg.link -s -w -buildmode=exe -buildid=hK3wnAP20DapUDeuvAAS/E_TzkbzwXz6tM5dEC8Mx \
/7HYBzuaDGVdaZwSMEWAa/hK3wnAP20DapUDeuvAAS -extld=gcc \
/root/.cache/go-build/75/ \
7531fcf5e48444eed677bfc5cda1276a52b73c62ebac3aa99da3c4094fa57dc3-d
$WORK/b001/exe/hello
Hello WorldNaśladuj kompilację bez tworzenia pliku wykonywalnego
Szałóżmy, że nie chcesz kompilować programu i utworzyć rzeczywistego pliku binarnego, ale chcesz zobaczyć wszystkie etapy procesu. Można to zrobić, używając opcji kompilacji -n, która wypisuje kroki, które normalnie wykonywałaby bez tworzenia pliku binarnego.
$ go build -n hello.goZapisz katalogi tymczasowe
Dużo pracy dzieje się w katalogu roboczym /tmp, który jest usuwany po utworzeniu i uruchomieniu pliku wykonywalnego. A co jeśli chcesz zobaczyć, jakie pliki powstały w procesie kompilacji? Go udostępnia opcję -work, której można użyć podczas kompilacji programu. Opcja -work oprócz uruchomienia programu wypisuje ścieżkę do katalogu roboczego, ale nie usuwa go później, więc możesz przejść do tego katalogu i sprawdzić wszystkie pliki utworzone podczas kompilacji proces.
$ go run -work hello.go
WORK=/tmp/go-build3209320645
Hello World
$
$ find /tmp/go-build3209320645
/tmp/go-build3209320645
/tmp/go-build3209320645/b001
/tmp/go-build3209320645/b001/importcfg.link
/tmp/go-build3209320645/b001/exe
/tmp/go-build3209320645/b001/exe/hello
$
$ /tmp/go-build3209320645/b001/exe/hello
Hello World
$Alternatywne opcje kompilacji
Co się stanie, jeśli zamiast korzystać z magii kompilacji/uruchamiania Go, zechcesz skompilować program ręcznie i otrzymać plik wykonywalny, który będzie można uruchomić bezpośrednio w systemie operacyjnym (w tym przypadku Linux)? Proces ten można podzielić na dwie części: kompilację i linkowanie. Użyj opcji tool, aby zobaczyć, jak to działa.
Najpierw użyj opcji tool Compare, aby utworzyć wynikowy plik archiwum ar, który zawiera plik pośredni .o. Następnie użyj opcji tool link w tym pliku hello.o, aby utworzyć ostateczny plik wykonywalny, który można następnie uruchomić.
$ go tool compile hello.go
$
$ file hello.o
hello.o: current ar archive
$
$ ar t hello.o
__.PKGDEF
_go_.o
$
$ go tool link -o hello hello.o
$
$ file hello
hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
$
$ ./hello
Hello World
$
Aby zajrzeć głębiej w proces łączenia podczas tworzenia pliku wykonywalnego z pliku hello.o, możesz użyć opcji -v, która wyszukuje plik runtime.a zawarty w każdym pliku wykonywalnym Go.
$ go tool link -v -o hello hello.o
HEADER = -H5 -T0x401000 -R0x1000
searching for runtime.a in /usr/lib/golang/pkg/linux_amd64/runtime.a
82052 symbols, 18774 reachable
1 package symbols, 1106 hashed symbols, 77185 non-package symbols, 3760 external symbols
81968 liveness data
$Opcje kompilacji krzyżowej
Teraz, gdy wyjaśniłem kompilację programu w Go, zademonstruję, jak Go pozwala na zbudowanie pliku wykonywalnego przeznaczonego dla różnych architektur sprzętowych i systemów operacyjnych poprzez podanie dwóch zmiennych środowiskowych — GOOS i GOARCH — przed właściwą kompilacją polecenie .
Dlaczego to ma znaczenie? Możesz zobaczyć przykład, gdy plik wykonywalny stworzony dla architektury ARM (aarch64) nie będzie działać na architekturze Intel (x86_64) i generuje błąd formatu Exec.
Dzięki tym opcjom tworzenie wieloplatformowych plików binarnych jest banalne.
$ GOOS=linux GOARCH=arm64 go build hello.go
$
$ file ./hello
./hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked, not stripped
$
$ ./hello
bash: ./hello: cannot execute binary file: Exec format error
$
$ uname -m
x86_64
$Możesz przeczytać mój wcześniejszy wpis na blogu o moich doświadczeniach z kompilacją krzyżową za pomocą Go, aby dowiedzieć się więcej.
Zobacz podstawowe instrukcje montażu
Kod źródłowy nie jest bezpośrednio konwertowany na plik wykonywalny, chociaż generuje pośredni format asemblera, który jest następnie składany w plik wykonywalny. W Go jest to mapowane na pośredni format montażu, a nie na podstawowe instrukcje montażu sprzętu.
Aby wyświetlić ten pośredni format zestawu, użyj -gcflags, po którym następuje -S podany w poleceniu kompilacji. To polecenie wyświetla instrukcje montażu.
$ go build -gcflags="-S" hello.go
# command-line-arguments
"".main STEXT size=138 args=0x0 locals=0x58 funcid=0x0
0x0000 00000 (/test/hello.go:5) TEXT "".main(SB), ABIInternal, $88-0
0x0000 00000 (/test/hello.go:5) MOVQ (TLS), CX
0x0009 00009 (/test/hello.go:5) CMPQ SP, 16(CX)
0x000d 00013 (/test/hello.go:5) PCDATA $0, $-2
0x000d 00013 (/test/hello.go:5) JLS 128
<< snip >>
$Możesz także użyć opcji objdump -s, jak pokazano poniżej, aby zobaczyć instrukcje asemblowania dla programu wykonywalnego, który został już skompilowany.
$ ls
hello hello.go
$
$
$ go tool objdump -s main.main hello
TEXT main.main(SB) /test/hello.go
hello.go:5 0x4975a0 64488b0c25f8ffffff MOVQ FS:0xfffffff8, CX
hello.go:5 0x4975a9 483b6110 CMPQ 0x10(CX), SP
hello.go:5 0x4975ad 7671 JBE 0x497620
hello.go:5 0x4975af 4883ec58 SUBQ $0x58, SP
hello.go:6 0x4975d8 4889442448 MOVQ AX, 0x48(SP)
<< snip >>
$Usuń pliki binarne, aby zmniejszyć ich rozmiar
Pliki binarne Go są zazwyczaj duże. Na przykład prosty program Hello World tworzy plik binarny o rozmiarze 1,9M.
$ go build hello.go
$
$ du -sh hello
1.9M hello
$
$ file hello
hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
$Aby zmniejszyć rozmiar wynikowego pliku binarnego, możesz usunąć informacje niepotrzebne podczas wykonywania. Użycie flagi -ldflags, po której następuje flaga -s -w, powoduje, że wynikowy plik binarny jest nieco jaśniejszy i wynosi 1,3M.
$ go build -ldflags="-s -w" hello.go
$
$ du -sh hello
1.3M hello
$
$ file hello
hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, stripped
$Wniosek
Mam nadzieję, że ten artykuł przedstawił Ci kilka przydatnych opcji kompilacji Go, które pomogą Ci lepiej zrozumieć proces kompilacji Go. Dodatkowe informacje na temat procesu kompilacji i innych interesujących opcji można znaleźć w sekcji pomocy:
$ go help build