Go 程式是怎樣跑起來的

来源:https://www.cnblogs.com/qcrao-2018/archive/2019/07/03/11124360.html
-Advertisement-
Play Games

Go程式是怎樣跑起來的？本文從編碼、編譯、彙編、鏈接、運行、退出這些環節一一探索。 ...


目錄

剛開始寫這篇文章的時候，目標非常大，想要探索 Go 程式的一生：編碼、編譯、彙編、鏈接、運行、退出。它的每一步具體如何進行，力圖弄清 Go 程式的這一生。

在這個過程中，我又複習了一遍《程式員的自我修養》。這是一本講編譯、鏈接的書，非常詳細，值得一看！數年前，我第一次看到這本書的書名，就非常喜歡。因為它模仿了周星馳喜劇之王里出現的一本書 ——《演員的自我修養》。心嚮往之！

在開始本文之前，先推薦一位頭條大佬的博客——《面向信仰編程》，他的 Go 編譯系列文章，非常有深度，直接深入編譯器源代碼，我是看了很多遍了。博客鏈接可以從參考資料里獲取。

理想很大，實現的難度也是非常大。為了避免砸了“深度解密”這個牌子，這次起了個更溫和的名字，嘿嘿。

引入

我們從一個 Hello World 的例子開始：

package main

import "fmt"

func main() {
    fmt.Println("hello world")
}

當我用我那價值 1800 元的 cherry 鍵盤瀟灑地敲完上面的 hello world 代碼時，保存在硬碟上的 hello.go 文件就是一個位元組序列了，每個位元組代表一個字元。

用 vim 打開 hello.go 文件，在命令行模式下，輸入命令：

:%!xxd

就能在 vim 里以十六進位查看文件內容：

hex .go

最左邊的一列代表地址值，中間一列代表文本對應的 ASCII 字元，最右邊的列就是我們的代碼。再在終端里執行 man ascii：

ASCII

和 ASCII 字元表一對比，就能發現，中間的列和最右邊的列是一一對應的。也就是說，剛剛寫完的 hello.go 文件都是由 ASCII 字元表示的，它被稱為文本文件，其他文件被稱為二進位文件。

當然，更深入地看，電腦中的所有數據，像磁碟文件、網路中的數據其實都是一串比特位組成，取決於如何看待它。在不同的情景下，一個相同的位元組序列可能表示成一個整數、浮點數、字元串或者是機器指令。

而像 hello.go 這個文件，8 個 bit，也就是一個位元組看成一個單位（假定源程式的字元都是 ASCII 碼），最終解釋成人類能讀懂的 Go 源碼。

Go 程式並不能直接運行，每條 Go 語句必須轉化為一系列的低級機器語言指令，將這些指令打包到一起，並以二進位磁碟文件的形式存儲起來，也就是可執行目標文件。

從源文件到可執行目標文件的轉化過程：

compile

完成以上各個階段的就是 Go 編譯系統。你肯定知道大名鼎鼎的 GCC（GNU Compile Collection），中文名為 GNU 編譯器套裝，它支持像 C，C++，Java，Python，Objective-C，Ada，Fortran，Pascal，能夠為很多不同的機器生成機器碼。

可執行目標文件可以直接在機器上執行。一般而言，先執行一些初始化的工作；找到 main 函數的入口，執行用戶寫的代碼；執行完成後，main 函數退出；再執行一些收尾的工作，整個過程完畢。

在接下來的文章里，我們將探索編譯和運行的過程。

編譯鏈接概述

Go 源碼里的編譯器源碼位於 src/cmd/compile 路徑下，鏈接器源碼位於 src/cmd/link 路徑下。

編譯過程

我比較喜歡用 IDE（集成開發環境）來寫代碼， Go 源碼用的 Goland，有時候直接點擊 IDE 菜單欄里的“運行”按鈕，程式就跑起來了。這實際上隱含了編譯和鏈接的過程，我們通常將編譯和鏈接合併到一起的過程稱為構建（Build）。

編譯過程就是對源文件進行詞法分析、語法分析、語義分析、優化，最後生成彙編代碼文件，以 .s 作為文件尾碼。

之後，彙編器會將彙編代碼轉變成機器可以執行的指令。由於每一條彙編語句幾乎都與一條機器指令相對應，所以只是一個簡單的一一對應，比較簡單，沒有語法、語義分析，也沒有優化這些步驟。

編譯器是將高級語言翻譯成機器語言的一個工具，編譯過程一般分為 6 步：掃描、語法分析、語義分析、源代碼優化、代碼生成、目標代碼優化。下圖來自《程式員的自我修養》：

編譯過程總覽

詞法分析

通過前面的例子，我們知道，Go 程式文件在機器看來不過是一堆二進位位。我們能讀懂，是因為 Goland 按照 ASCII 碼（實際上是 UTF-8）把這堆二進位位進行了編碼。例如，把 8個 bit 位分成一組，對應一個字元，通過對照 ASCII 碼表就可以查出來。

當把所有的二進位位都對應成了 ASCII 碼字元後，我們就能看到有意義的字元串。它可能是關鍵字，例如：package；可能是字元串，例如：“Hello World”。

詞法分析其實幹的就是這個。輸入是原始的 Go 程式文件，在詞法分析器看來，就是一堆二進位位，根本不知道是什麼東西，經過它的分析後，變成有意義的記號。簡單來說，詞法分析是電腦科學中將字元序列轉換為標記（token）序列的過程。

我們來看一下維基百科上給出的定義：

詞法分析（lexical analysis）是電腦科學中將字元序列轉換為標記（token）序列的過程。進行詞法分析的程式或者函數叫作詞法分析器（lexical analyzer，簡稱lexer），也叫掃描器（scanner）。詞法分析器一般以函數的形式存在，供語法分析器調用。

.go 文件被輸入到掃描器（Scanner），它使用一種類似於有限狀態機的演算法，將源代碼的字元系列分割成一系列的記號（Token）。

記號一般分為這幾類：關鍵字、標識符、字面量（包含數字、字元串）、特殊符號（如加號、等號）。

例如，對於如下的代碼：

slice[i] = i * (2 + 6)

總共包含 16 個非空字元，經過掃描後，

記號 類型
slice 標識符
[ 左方括弧
i 標識符
] 右方括弧
= 賦值
i 標識符
* 乘號
( 左圓括弧
2 數字
+ 加號
6 數字
) 右圓括弧

上面的例子源自《程式員的自我修養》，主要講解編譯、鏈接相關的內容，很精彩，推薦研讀。

Go 語言（本文的 Go 版本是 1.9.2）掃描器支持的 Token 在源碼中的路徑：

src/cmd/compile/internal/syntax/token.go

感受一下：

var tokstrings = [...]string{
    // source control
    _EOF: "EOF",

    // names and literals
    _Name:    "name",
    _Literal: "literal",

    // operators and operations
    _Operator: "op",
    _AssignOp: "op=",
    _IncOp:    "opop",
    _Assign:   "=",
    _Define:   ":=",
    _Arrow:    "<-",
    _Star:     "*",

    // delimitors
    _Lparen:    "(",
    _Lbrack:    "[",
    _Lbrace:    "{",
    _Rparen:    ")",
    _Rbrack:    "]",
    _Rbrace:    "}",
    _Comma:     ",",
    _Semi:      ";",
    _Colon:     ":",
    _Dot:       ".",
    _DotDotDot: "...",

    // keywords
    _Break:       "break",
    _Case:        "case",
    _Chan:        "chan",
    _Const:       "const",
    _Continue:    "continue",
    _Default:     "default",
    _Defer:       "defer",
    _Else:        "else",
    _Fallthrough: "fallthrough",
    _For:         "for",
    _Func:        "func",
    _Go:          "go",
    _Goto:        "goto",
    _If:          "if",
    _Import:      "import",
    _Interface:   "interface",
    _Map:         "map",
    _Package:     "package",
    _Range:       "range",
    _Return:      "return",
    _Select:      "select",
    _Struct:      "struct",
    _Switch:      "switch",
    _Type:        "type",
    _Var:         "var",
}

還是比較熟悉的，包括名稱和字面量、操作符、分隔符和關鍵字。

而掃描器的路徑是：

src/cmd/compile/internal/syntax/scanner.go

其中最關鍵的函數就是 next 函數，它不斷地讀取下一個字元（不是下一個位元組，因為 Go 語言支持 Unicode 編碼，並不是像我們前面舉得 ASCII 碼的例子，一個字元只有一個位元組），直到這些字元可以構成一個 Token。

func (s *scanner) next() {
// ……

redo:
    // skip white space
    c := s.getr()
    for c == ' ' || c == '\t' || c == '\n' && !nlsemi || c == '\r' {
        c = s.getr()
    }

    // token start
    s.line, s.col = s.source.line0, s.source.col0

    if isLetter(c) || c >= utf8.RuneSelf && s.isIdentRune(c, true) {
        s.ident()
        return
    }

    switch c {
    // ……

    case '\n':
        s.lit = "newline"
        s.tok = _Semi

    case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
        s.number(c)
        
    // ……
    
   default:
        s.tok = 0
        s.error(fmt.Sprintf("invalid character %#U", c))
        goto redo
    return

assignop:
    if c == '=' {
        s.tok = _AssignOp
        return
    }
    s.ungetr()
    s.tok = _Operator
}

代碼的主要邏輯就是通過 c := s.getr() 獲取下一個未被解析的字元，並且會跳過之後的空格、回車、換行、tab 字元，然後進入一個大的 switch-case 語句，匹配各種不同的情形，最終可以解析出一個 Token，並且把相關的行、列數字記錄下來，這樣就完成一次解析過程。

當前包中的詞法分析器 scanner 也只是為上層提供了 next 方法，詞法解析的過程都是惰性的，只有在上層的解析器需要時才會調用 next 獲取最新的 Token。

語法分析

上一步生成的 Token 序列，需要經過進一步處理，生成一棵以表達式為結點的語法樹。

比如最開始的那個例子，slice[i] = i * (2 + 6)，得到的一棵語法樹如下：

語法樹

整個語句被看作是一個賦值表達式，左子樹是一個數組表達式，右子樹是一個乘法表達式；數組表達式由 2 個符號表達式組成；乘號表達式則是由一個符號表達式和一個加號表達式組成；加號表達式則是由兩個數字組成。符號和數字是最小的表達式，它們不能再被分解，通常作為樹的葉子節點。

語法分析的過程可以檢測一些形式上的錯誤，例如：括弧是否缺少一半，+ 號表達式缺少一個操作數等。

語法分析是根據某種特定的形式文法（Grammar）對 Token 序列構成的輸入文本進行分析並確定其語法結構的一種過程。

語義分析

語法分析完成後，我們並不知道語句的具體意義是什麼。像上面的 * 號的兩棵子樹如果是兩個指針，這是不合法的，但語法分析檢測不出來，語義分析就是乾這個事。

編譯期所能檢查的是靜態語義，可以認為這是在“代碼”階段，包括變數類型的匹配、轉換等。例如，將一個浮點值賦給一個指針變數的時候，明顯的類型不匹配，就會報編譯錯誤。而對於運行期間才會出現的錯誤：不小心除了一個 0 ，語義分析是沒辦法檢測的。

語義分析階段完成之後，會在每個節點上標註上類型：

語義分析完成

Go 語言編譯器在這一階段檢查常量、類型、函數聲明以及變數賦值語句的類型，然後檢查哈希中鍵的類型。實現類型檢查的函數通常都是幾千行的巨型 switch/case 語句。

類型檢查是 Go 語言編譯的第二個階段，在詞法和語法分析之後我們得到了每個文件對應的抽象語法樹，隨後的類型檢查會遍歷抽象語法樹中的節點，對每個節點的類型進行檢驗，找出其中存在的語法錯誤。

在這個過程中也可能會對抽象語法樹進行改寫，這不僅能夠去除一些不會被執行的代碼對編譯進行優化提高執行效率，而且也會修改 make、new 等關鍵字對應節點的操作類型。

例如比較常用的 make 關鍵字，用它可以創建各種類型，如 slice，map，channel 等等。到這一步的時候，對於 make 關鍵字，也就是 OMAKE 節點，會先檢查它的參數類型，根據類型的不同，進入相應的分支。如果參數類型是 slice，就會進入 TSLICE case 分支，檢查 len 和 cap 是否滿足要求，如 len <= cap。最後節點類型會從 OMAKE 改成 OMAKESLICE。

中間代碼生成

我們知道，編譯過程一般可以分為前端和後端，前端生成和平臺無關的中間代碼，後端會針對不同的平臺，生成不同的機器碼。

前面詞法分析、語法分析、語義分析等都屬於編譯器前端，之後的階段屬於編譯器後端。

編譯過程有很多優化的環節，在這個環節是指源代碼級別的優化。它將語法樹轉換成中間代碼，它是語法樹的順序表示。

中間代碼一般和目標機器以及運行時環境無關，它有幾種常見的形式：三地址碼、P-代碼。例如，最基本的三地址碼是這樣的：

x = y op z

表示變數 y 和 變數 z 進行 op 操作後，賦值給 x。op 可以是數學運算，例如加減乘除。

前面我們舉的例子可以寫成如下的形式：

t1 = 2 + 6
t2 = i * t1
slice[i] = t2

這裡 2 + 6 是可以直接計算出來的，這樣就把 t1 這個臨時變數“優化”掉了，而且 t1 變數可以重覆利用，因此 t2 也可以“優化”掉。優化之後：

t1 = i * 8
slice[i] = t1

Go 語言的中間代碼表示形式為 SSA（Static Single-Assignment，靜態單賦值），之所以稱之為單賦值，是因為每個名字在 SSA 中僅被賦值一次。。

這一階段會根據 CPU 的架構設置相應的用於生成中間代碼的變數，例如編譯器使用的指針和寄存器的大小、可用寄存器列表等。中間代碼生成和機器碼生成這兩部分會共用相同的設置。

在生成中間代碼之前，會對抽象語法樹中節點的一些元素進行替換。這裡引用《面向信仰編程》編譯原理相關博客里的一張圖：

builtin mapping

例如對於 map 的操作 m[i]，在這裡會被轉換成 mapacess 或 mapassign。

Go 語言的主程式在執行時會調用 runtime 中的函數，也就是說關鍵字和內置函數的功能其實是由語言的編譯器和運行時共同完成的。

中間代碼的生成過程其實就是從 AST 抽象語法樹到 SSA 中間代碼的轉換過程，在這期間會對語法樹中的關鍵字在進行一次更新，更新後的語法樹會經過多輪處理轉變最後的 SSA 中間代碼。

目標代碼生成與優化

不同機器的機器字長、寄存器等等都不一樣，意味著在不同機器上跑的機器碼是不一樣的。最後一步的目的就是要生成能在不同 CPU 架構上運行的代碼。

為了榨乾機器的每一滴油水，目標代碼優化器會對一些指令進行優化，例如使用移位指令代替乘法指令等。

這塊實在沒能力深入，幸好也不需要深入。對於應用層的軟體開發工程師來說，瞭解一下就可以了。

鏈接過程

編譯過程是針對單個文件進行的，文件與文件之間不可避免地要引用定義在其他模塊的全局變數或者函數，這些變數或函數的地址只有在此階段才能確定。

鏈接過程就是要把編譯器生成的一個個目標文件鏈接成可執行文件。最終得到的文件是分成各種段的，比如數據段、代碼段、BSS段等等，運行時會被裝載到記憶體中。各個段具有不同的讀寫、執行屬性，保護了程式的安全運行。

這部分內容，推薦看《程式員的自我修養》和《深入理解電腦系統》。

Go 程式啟動

仍然使用 hello-world 項目的例子。在項目根目錄下執行：

go build -gcflags "-N -l" -o hello src/main.go

-gcflags "-N -l" 是為了關閉編譯器優化和函數內聯，防止後面在設置斷點的時候找不到相對應的代碼位置。

得到了可執行文件 hello，執行：

[qcrao@qcrao hello-world]$ gdb hello

進入 gdb 調試模式，執行 info files，得到可執行文件的文件頭，列出了各種段：

gdb info

同時，我們也得到了入口地址：0x450e20。

(gdb) b *0x450e20
Breakpoint 1 at 0x450e20: file /usr/local/go/src/runtime/rt0_linux_amd64.s, line 8.

這就是 Go 程式的入口地址，我是在 linux 上運行的，所以入口文件為 src/runtime/rt0_linux_amd64.s，runtime 目錄下有各種不同名稱的程式入口文件，支持各種操作系統和架構，代碼為：

TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
    LEAQ    8(SP), SI // argv
    MOVQ    0(SP), DI // argc
    MOVQ    $main(SB), AX
    JMP AX

主要是把 argc，argv 從記憶體拉到了寄存器。這裡 LEAQ 是計算記憶體地址，然後把記憶體地址本身放進寄存器里，也就是把 argv 的地址放到了 SI 寄存器中。最後跳轉到：

TEXT main(SB),NOSPLIT,$-8
    MOVQ    $runtime·rt0_go(SB), AX
    JMP AX

繼續跳轉到 runtime·rt0_go(SB)，位置：/usr/local/go/src/runtime/asm_amd64.s，代碼：

TEXT runtime·rt0_go(SB),NOSPLIT,$0
    // 省略很多 CPU 相關的特性標誌位檢查的代碼
    // 主要是看不懂，^_^
    
    // ………………………………
    
    // 下麵是最後調用的一些函數，比較重要
    // 初始化執行文件的絕對路徑
    CALL    runtime·args(SB)
    // 初始化 CPU 個數和記憶體頁大小
    CALL    runtime·osinit(SB)
    // 初始化命令行參數、環境變數、gc、棧空間、記憶體管理、所有 P 實例、HASH演算法等
    CALL    runtime·schedinit(SB)

    // 要在 main goroutine 上運行的函數
    MOVQ    $runtime·mainPC(SB), AX     // entry
    PUSHQ   AX
    PUSHQ   $0          // arg size
    
    // 新建一個 goroutine，該 goroutine 綁定 runtime.main，放在 P 的本地隊列，等待調度
    CALL    runtime·newproc(SB)
    POPQ    AX
    POPQ    AX

    // 啟動M，開始調度goroutine
    CALL    runtime·mstart(SB)

    MOVL    $0xf1, 0xf1  // crash
    RET

    
DATA    runtime·mainPC+0(SB)/8,$runtime·main(SB)
GLOBL   runtime·mainPC(SB),RODATA,$8

參考文獻里的一篇文章【探索 golang 程式啟動過程】研究得比較深入，總結下：

  1. 檢查運行平臺的CPU，設置好程式運行需要相關標誌。
  1. TLS的初始化。
  2. runtime.args、runtime.osinit、runtime.schedinit 三個方法做好程式運行需要的各種變數與調度器。
  3. runtime.newproc創建新的goroutine用於綁定用戶寫的main方法。
  4. runtime.mstart開始goroutine的調度。

最後用一張圖來總結 go bootstrap 過程吧：

golang bootstrap

main 函數里執行的一些重要的操作包括：新建一個線程執行 sysmon 函數，定期垃圾回收和調度搶占；啟動 gc；執行所有的 init 函數等等。

上面是啟動過程，看一下退出過程：

當 main 函數執行結束之後，會執行 exit(0) 來退出進程。若執行 exit(0) 後，進程沒有退出，main 函數最後的代碼會一直訪問非法地址：

exit(0)
for {
    var x *int32
    *x = 0
}

正常情況下，一旦出現非法地址訪問，系統會把進程殺死，用這樣的方法確保進程退出。

關於程式退出這一段的闡述來自群聊《golang runtime 閱讀》，又是一個高階的讀源碼的組織，github 主頁見參考資料。

當然 Go 程式啟動這一部分其實還會涉及到 fork 一個新進程、裝載可執行文件，控制權轉移等問題。還是推薦看前面的兩本書，我覺得我不會寫得更好，就不敘述了。

GoRoot 和 GoPath

GoRoot 是 Go 的安裝路徑。mac 或 unix 是在 /usr/local/go 路徑上，來看下這裡都裝了些什麼：

/usr/local/go

bin 目錄下麵：

bin

pkg 目錄下麵：

pkg

Go 工具目錄如下，其中比較重要的有編譯器 compile，鏈接器 link：

pkg/tool

GoPath 的作用在於提供一個可以尋找 .go 源碼的路徑，它是一個工作空間的概念，可以設置多個目錄。Go 官方要求，GoPath 下麵需要包含三個文件夾：

src
pkg
bin

src 存放源文件，pkg 存放源文件編譯後的庫文件，尾碼為 .a；bin 則存放可執行文件。

Go 命令詳解

直接在終端執行：

go

就能得到和 go 相關的命令簡介：

go commands

和編譯相關的命令主要是：

go build
go install
go run

go build

go build 用來編譯指定 packages 里的源碼文件以及它們的依賴包，編譯的時候會到 $GoPath/src/package 路徑下尋找源碼文件。go build 還可以直接編譯指定的源碼文件，並且可以同時指定多個。

通過執行 go help build 命令得到 go build 的使用方法：

usage: go build [-o output] [-i] [build flags] [packages]

-o 只能在編譯單個包的時候出現，它指定輸出的可執行文件的名字。

-i 會安裝編譯目標所依賴的包，安裝是指生成與代碼包相對應的 .a 文件，即靜態庫文件（後面要參與鏈接），並且放置到當前工作區的 pkg 目錄下，且庫文件的目錄層級和源碼層級一致。

至於 build flags 參數，build, clean, get, install, list, run, test 這些命令會共用一套：

參數 作用
-a 強制重新編譯所有涉及到的包，包括標準庫中的代碼包，這會重寫 /usr/local/go 目錄下的 .a 文件
-n 列印命令執行過程，不真正執行
-p n 指定編譯過程中命令執行的並行數，n 預設為 CPU 核數
-race 檢測並報告程式中的數據競爭問題
-v 列印命令執行過程中所涉及到的代碼包名稱
-x 列印命令執行過程中所涉及到的命令，並執行
-work 列印編譯過程中的臨時文件夾。通常情況下，編譯完成後會被刪除

我們知道，Go 語言的源碼文件分為三類：命令源碼、庫源碼、測試源碼。

命令源碼文件：是 Go 程式的入口，包含 func main() 函數，且第一行用 package main 聲明屬於 main 包。

庫源碼文件：主要是各種函數、介面等，例如工具類的函數。

測試源碼文件：以 _test.go 為尾碼的文件，用於測試程式的功能和性能。

註意，go build 會忽略 *_test.go 文件。

我們通過一個很簡單的例子來演示 go build 命令。我用 Goland 新建了一個 hello-world 項目（為了展示引用自定義的包，和之前的 hello-world 程式不同），項目的結構如下：

example structure

最左邊可以看到項目的結構，包含三個文件夾：bin，pkg，src。其中 src 目錄下有一個 main.go，裡面定義了 main 函數，是整個項目的入口，也就是前面提過的所謂的命令源碼文件；src 目錄下還有一個 util 目錄，裡面有 util.go 文件，定義了一個可以獲取本機 IP 地址的函數，也就是所謂的庫源碼文件。

中間是 main.go 的源碼，引用了兩個包，一個是標準庫的 fmt；一個是 util 包，util 的導入路徑是 util。所謂的導入路徑是指相對於 Go 的源碼目錄 $GoRoot/src 或者 $GoPath/src 的下的子路徑。例如 main 包里引用的 fmt 的源碼路徑是 /usr/local/go/src/fmt，而 util 的源碼路徑是 /Users/qcrao/hello-world/src/util，正好我們設置的 GoPath = /Users/qcrao/hello-world。

最右邊是庫函數的源碼，實現了獲取本機 IP 的函數。

在 src 目錄下，直接執行 go build 命令，在同級目錄生成了一個可執行文件，文件名為 src，使用 ./src 命令直接執行，輸出：

hello world!
Local IP: 192.168.1.3

我們也可以指定生成的可執行文件的名稱：

go build -o bin/hello

這樣，在 bin 目錄下會生成一個可執行文件，運行結果和上面的 src 一樣。

其實，util 包可以單獨被編譯。我們可以在項目根目錄下執行：

go build util

編譯程式會去 $GoPath/src 路徑找 util 包（其實是找文件夾）。還可以在 ./src/util 目錄下直接執行 go build 編譯。

當然，直接編譯庫源碼文件不會生成 .a 文件，因為：

go build 命令在編譯只包含庫源碼文件的代碼包（或者同時編譯多個代碼包）時，只會做檢查性的編譯，而不會輸出任何結果文件。

為了展示整個編譯鏈接的運行過程，我們在項目根目錄執行如下的命令：

go build -v -x -work -o bin/hello src/main.go

-v 會列印所編譯過的包名字，-x 列印編譯期間所執行的命令，-work 列印編譯期間生成的臨時文件路徑，並且編譯完成之後不會被刪除。

執行結果：

編譯過程

從結果來看，圖中用箭頭標註了本次編譯過程涉及 2 個包：util，command-line-arguments。第二個包比較詭異，源碼里根本就沒有這個名字好嗎？其實這是 go build 命令檢測到 [packages] 處填的是一個 .go 文件，因此創建了一個虛擬的包：command-line-arguments。

同時，用紅框圈出了 compile, link，也就是先編譯了 util 包和 main.go 文件，分別得到 .a 文件，之後將兩者進行鏈接，最終生成可執行文件，並且移動到 bin 目錄下，改名為 hello。

另外，第一行顯示了編譯過程中的工作目錄，此目錄的文件結構是：

臨時工作目錄

可以看到，和 hello-world 目錄的層級基本一致。command-line-arguments 就是虛擬的 main.go 文件所處的包。exe 目錄下的可執行文件在最後一步被移動到了 bin 目錄下，所以這裡是空的。

整體來看，go build 在執行時，會先遞歸尋找 main.go 所依賴的包，以及依賴的依賴，直至最底層的包。這裡可以是深度優先遍歷也可以是寬度優先遍歷。如果發現有迴圈依賴，就會直接退出，這也是經常會發生的迴圈引用編譯錯誤。

正常情況下，這些依賴關係會形成一棵倒著生長的樹，樹根在最上面，就是 main.go 文件，最下麵是沒有任何其他依賴的包。編譯器會從最左的節點所代表的包開始挨個編譯，完成之後，再去編譯上一層的包。

這裡，引用郝林老師幾年前在 github 上發表的 go 命令教程，可以從參考資料找到原文地址。

從代碼包編譯的角度來說，如果代碼包 A 依賴代碼包 B，則稱代碼包 B 是代碼包 A 的依賴代碼包（以下簡稱依賴包），代碼包 A 是代碼包 B 的觸發代碼包（以下簡稱觸發包）。

執行 go build 命令的電腦如果擁有多個邏輯 CPU 核心，那麼編譯代碼包的順序可能會存在一些不確定性。但是，它一定會滿足這樣的約束條件：依賴代碼包 -> 當前代碼包 -> 觸發代碼包。

順便推薦一個瀏覽器插件 Octotree，在看 github 項目的時候，此插件可以在瀏覽器里直接展示整個項目的文件結構，非常方便：

github 插件

到這裡，你一定會發現，對於 hello-wrold 文件夾下的 pkg 目錄好像一直沒有涉及到。

其實，pkg 目錄下麵應該存放的是涉及到的庫文件編譯後的包，也就是一些 .a 文件。但是 go build 執行過程中，這些 .a 文件放在臨時文件夾中，編譯完成後會被直接刪掉，因此一般不會用到。

前面我們提到過，在 go build 命令裡加上 -i 參數會安裝這些庫文件編譯的包，也就是這些 .a 文件會放到 pkg 目錄下。

在項目根目錄執行 go build -i src/main.go 後，pkg 目錄里增加了 util.a 文件：

pkg

darwin_amd64 表示的是：

GOOS 和 GOARCH。這兩個環境變數不用我們設置，系統預設的。

GOOS 是 Go 所在的操作系統類型，GOARCH 是 Go 所在的計算架構。

Mac 平臺上這個目錄名就是 darwin_amd64。

生成了 util.a 文件後，再次編譯的時候，就不會再重新編譯 util.go 文件，加快了編譯速度。

同時，在根目錄下生成了名稱為 main 的可執行文件，這是以 main.go 的文件名命令的。

hello-world 這個項目的代碼已經上傳到了 github 項目 Go-Questions，這個項目由問題導入，企圖串連 Go 的所有知識點，正在完善，期待你的 star。 地址見參考資料【Go-Questions hello-world項目】。

go install

go install 用於編譯並安裝指定的代碼包及它們的依賴包。相比 go build，它只是多了一個“安裝編譯後的結果文件到指定目錄”的步驟。

還是使用之前 hello-world 項目的例子，我們先將 pkg 目錄刪掉，在項目根目錄執行：

go install src/main.go

或者

go install util

兩者都會在根目錄下新建一個 pkg 目錄，並且生成一個 util.a 文件。

並且，在執行前者的時候，會在 GOBIN 目錄下生成名為 main 的可執行文件。

所以，運行 go install 命令，庫源碼包對應的 .a 文件會被放置到 pkg 目錄下，命令源碼包生成的可執行文件會被放到 GOBIN 目錄。

go install 在 GoPath 有多個目錄的時候，會產生一些問題，具體可以去看郝林老師的 Go 命令教程，這裡不展開了。

go run

go run 用於編譯並運行命令源碼文件。

在 hello-world 項目的根目錄，執行 go run 命令：

go run -x -work src/main.go

-x 可以列印整個過程涉及到的命令，-work 可以看到臨時的工作目錄：

go run 過程

從上圖中可以看到，仍然是先編譯，再連接，最後直接執行，並列印出了執行結果。

第一行列印的就是工作目錄，最終生成的可執行文件就是放置於此：

go run 結果

main 就是最終生成的可執行文件。

總結

這次的話題太大了，困難重重。從編譯原理到 go 啟動時的流程，到 go 命令原理，每個話題單獨抽出來都可以寫很多。

幸好有一些很不錯的書和博客文章可以去參考。這篇文章就作為一個引子，你可以跟隨參考資料里推薦的一些內容去發散。

參考資料

【《程式員的自我修養》全書】https://book.douban.com/subject/3652388/

【面向信仰編程 編譯過程概述】https://draveness.me/golang-compile-intro

【golang runtime 閱讀】https://github.com/zboya/golang_runtime_reading

【Go-Questions hello-world項目】https://github.com/qcrao/Go-Questions/tree/master/examples/hello-world

【雨痕大佬的 Go 語言學習筆記】https://github.com/qyuhen/book

【vim 以 16 進位文本】https://www.cnblogs.com/meibenjin/archive/2012/12/06/2806396.html

【Go 編譯命令執行過程】https://halfrost.com/go_command/

【Go 命令執行過程】https://github.com/hyper0x/go_command_tutorial

【Go 詞法分析】https://ggaaooppeenngg.github.io/zh-CN/2016/04/01/go-lexer-%E8%AF%8D%E6%B3%95%E5%88%86%E6%9E%90/

【曹大博客 golang 與 ast】http://xargin.com/ast/

【Golang 詞法解析器，scanner 源碼分析】https://blog.csdn.net/zhaoruixiang1111/article/details/89892435

【Gopath Explained】https://flaviocopes.com/go-gopath/

【Understanding the GOPATH】https://www.digitalocean.com/community/tutorials/understanding-the-gopath

【討論】https://stackoverflow.com/questions/7970390/what-should-be-the-values-of-gopath-and-goroot

【Go 官方 Gopath】https://golang.org/cmd/go/#hdr-GOPATH_environment_variable

【Go package 的探索】https://mp.weixin.qq.com/s/OizVLXfZ6EC1jI-NL7HqeA

【Go 官方 關於 Go 項目的組織結構】https://golang.org/doc/code.html

【Go modules】https://www.melvinvivas.com/go-version-1-11-modules/

【Golang Installation, Setup, GOPATH, and Go Workspace】https://www.callicoder.com/golang-installation-setup-gopath-workspace/

【編譯、鏈接過程鏈接】https://mikespook.com/2013/11/%E7%BF%BB%E8%AF%91-go-build-%E5%91%BD%E4%BB%A4%E6%98%AF%E5%A6%82%E4%BD%95%E5%B7%A5%E4%BD%9C%E7%9A%84%EF%BC%9F/

【1.5 編譯器由 go 語言完成】https://www.infoq.cn/article/2015/08/go-1-5

【Go 編譯過程系列文章】https://www.ctolib.com/topics-3724.html

【曹大 go bootstrap】https://github.com/cch123/golang-notes/blob/master/bootstrap.md

【golang 啟動流程】https://blog.iceinto.com/posts/go/start/

【探索 golang 程式啟動過程】http://cbsheng.github.io/posts/%E6%8E%A2%E7%B4%A2golang%E7%A8%8B%E5%BA%8F%E5%90%AF%E5%8A%A8%E8%BF%87%E7%A8%8B/

【探索 goroutine 的創建】http://cbsheng.github.io/posts/%E6%8E%A2%E7%B4%A2goroutine%E7%9A%84%E5%88%9B%E5%BB%BA/

QR


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • margin 外邊距合併問題
    一、兄弟元素的外邊距合併 效果圖如下：（二者之間的間距為100px，不是150px） 二、嵌套元素的外邊距合併 對於兩個嵌套關係的元素，如果父元素中沒有內容或者內容在子元素的後面並且沒有上內邊距及邊框，則父元素的上邊距會與子元素的上外邊距發生合併，且值為最大的那個上外邊距，同時該值作為父元素的上外邊 ...
  • Vue學習之npm常用命令及參數小結（十四）
    NPM幾個常用命令和參數的意思： 安裝模塊如不指定版本號 預設會安裝最新的版本 安裝指定版本的模塊 這個命令會在當前目錄生成一個package.json文件，這個文件中會記錄一些關於項目的信息，比如：項目的作者，git地址，入口文件、命令設置、項目名稱和版本號等等，一般情況下這個文件是必須要有的，方 ...
  • 使用MUI框架實現JQ購物車增減
    // 購物車數量減少$('.reduce').click(function () { addMinus(this,0)});// 購物車數量增加$('.increase').click(function () { addMinus(this,1)});function addMinus(t,stat ...
  • Vue學習之Webpack基本使用小結（十三）
    一、新建dist 文件夾； 二、新建src文件夾： 在其下麵創建 css 、js 、images文件夾及 index.html、main.js(這是項目Js的主入口） 三、html中簡單創建一個列表； main.js中設置單雙行變色； 四、由於ES6太高級，瀏覽器解析不了，需要轉換為低級的能識別的版 ...
  • 跟我學SpringCloud | 第三篇：服務的提供與Feign調用
    跟我學SpringCloud | 第三篇：服務的提供與Feign調用 上一篇，我們介紹了註冊中心的搭建，包括集群環境嚇註冊中心的搭建，這篇文章介紹一下如何使用註冊中心，創建一個服務的提供者，使用一個簡單的客戶端去調用服務端提供的服務。 本篇文章中需要三個角色，分別是服務的提供者，服務的消費者，還有一 ...
  • Spring Cloud微服務架構升級總結
    ↵ 【編者的話】微服務的概念源於 2014 年 3 月 Martin Fowler 所寫的一篇文章“Microservices”。文中內容提到：微服務架構是一種架構模式，它提倡將單一應用程式劃分成一組小的服務，服務之間互相協調、互相配合，為用戶提供最終價值。 背景 應用系統的架構歷史 什麼是微服務？ ...
  • CQRS之旅——旅程7(增加彈性和優化性能)
    我們旅程的最後階段的三個主要目標是使系統對故障更具彈性，提高UI的響應能力，並確保我們的設計是可伸縮的。加強系統的工作主要集中在訂單和註冊限界上下文中的RegistrationProcessManager類。性能改進工作的重點是當訂單創建時UI與領域域模型的交互方式。 ...
  • 你竟然沒用 Maven 構建項目？
    一年前，當我和小伙伴小龍一起做一個外包項目的時候，受到了嚴重的鄙視。我那時候還不知道 Maven，所以搭建項目用的還是最原始的方式，小龍不得已在導入項目的時候花了很長時間去下載項目依賴的開源類庫。 出於對我的尊重，小龍沒有破口大罵，而是非常委婉地說了一句：“二哥，你好歹也有一定的知名度了，竟然沒用 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類