Go語言之程序符號重命名

作者： fooree 2021-10-09 07:52:01

開發后端

Go程序源代碼中，關鍵字、接口、類型、常量、變量、方法、函數、字段、標簽（label）等等的名稱都可以稱為符號。

[[427663]]

Go程序源代碼中，關鍵字、接口、類型、常量、變量、方法、函數、字段、標簽(label)等等的名稱都可以稱為符號。

Go可執行程序中，符號表主要包含兩種類型的符號：

數據對象(Data object)
函數(Function)

一般情況下(不是絕對的)，在源代碼編譯為可執行程序的過程中，

關鍵字、局部變量、標簽會轉變為指令、數據或者消失，而不再是符號
接口、類型、全局常量會被保存為不可變數據，而不再是符號
函數、方法、全局變量、全局常量會被重命名，保存在符號表中

本文主要總結了函數、方法、全局變量在編譯過程中通用的重命名規則，不討論類似內聯優化、閉包、非空接口、編譯器生成等復雜的情況。

規則

Go 1.18版本之前符號重命名常見規則列表如下：

包名.變量名
包名.函數名
包名.函數名.funcN
包名.函數名.funcN.N
包名.類型.函數名
包名.類型.函數名.funcN
包名.類型.函數名.funcN.N
包名.(*類型).函數名
包名.(*類型).函數名.funcN
包名.(*類型).函數名.funcN.N
模塊名/包名.變量名
模塊名/包名.函數名
模塊名/包名.函數名.funcN
模塊名/包名.函數名.funcN.N
模塊名/包名.類型.函數名
模塊名/包名.類型.函數名.funcN
模塊名/包名.類型.函數名.funcN.N
模塊名/包名.(*類型).函數名
模塊名/包名.(*類型).函數名.funcN
模塊名/包名.(*類型).函數名.funcN.N
包名.init
包名.init.N
模塊名/包名.init
模塊名/包名.init.N

以上規則羅列過于詳細，主要是因為包含了過多的匿名函數命名規則;本文會縮小分類粒度進行歸納：

普通函數
匿名函數
方法
全局常量
模塊
初始化函數

環境

OS : Ubuntu 20.04.2 LTS; x86_64 
Go : go version go1.16.2 linux/amd64

代碼清單

完整代碼已經上傳到 Github 倉庫：https://github.com/fooree/go-names

目錄和文件結構如下：

go.mod

module github.com/fooree/go-names 
 
go 1.16

main.go

package main 
 
import ( 
  "debug/elf" 
  "fmt" 
  "github.com/fooree/go-names/internal" 
  "github.com/fooree/go-names/internal/foo" 
  "github.com/fooree/go-names/internal/foo/ree" 
  "os" 
  "path/filepath" 
  "reflect" 
  "sort" 
  "strings" 
  "time" 
) 
 
//go:noinline 
func anonymousType() { 
  t := reflect.TypeOf(struct { 
    Name string 
  }{ 
    Name: "Jack", 
  }) 
  fmt.Printf("name=%s, string=%s, addres=%p\n", t.Name(), t.String(), t) 
} 
 
func main() { 
  anonymousType() 
  ree.Run() 
  foo.Y.Foo() 
  internal.X.Foo() 
   
  name, _ := filepath.Abs(os.Args[0]) 
  file, err := elf.Open(name) 
  if err != nil { 
    panic(err) 
  } 
  defer func() { _ = file.Close() }() 
  symbols, err := file.Symbols() 
  if err != nil { 
    panic(err) 
  } 
 
  slice := make([]string, 0, 100) 
  for _, symbol := range symbols { 
    const module = "github.com/fooree/go-names" 
    const name = "main" 
    if strings.HasPrefix(symbol.Name, module) || strings.HasPrefix(symbol.Name, name) { 
      slice = append(slice, symbol.Name) 
    } 
  } 
 
  go func() { 
    sort.Slice(slice, func(i, j int) bool { 
      return slice[i] < slice[j] 
    }) 
    go func() { 
      fmt.Println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~") 
    }() 
  }() 
 
  time.Sleep(time.Second) 
 
  for _, sym := range slice { 
    fmt.Println(sym) 
  } 
}

internal/a.go

package internal 
 
import ( 
  "fmt" 
  "reflect" 
) 
 
type Foo interface { 
  Foo() 
} 
 
type Int int 
 
var X Int 
 
//go:noinline 
func (i *Int) Foo() { 
  t := reflect.TypeOf(i) 
  go func() { 
    fmt.Printf("i am Int, name=%s, string=%s\n", t.Name(), t.String()) 
  }() 
} 
 
func init() { 
  X = Int(0x123) 
} 
 
func init() { 
  fmt.Println("X =", X) 
}

internal/foo/b.go

package foo 
 
import ( 
  "fmt" 
  "reflect" 
) 
 
type Ree struct { 
  Name string 
} 
 
//go:noinline 
func (r Ree) Foo() { 
  anonymousType() 
  t := reflect.TypeOf(r) 
  fmt.Printf("i am Ree, name=%s, string=%s\n", t.Name(), t.String()) 
} 
 
//go:noinline 
func anonymousType() { 
  t := reflect.TypeOf(struct { 
    Name string 
  }{ 
    Name: "Jack", 
  }) 
  fmt.Printf("name=%s, string=%s, addres=%p\n", t.Name(), t.String(), t) 
} 
 
var Y = Ree{"Rose"} 
 
func init() { 
  fmt.Println("Y =",Y) 
}

internal/foo/ree/c.go

package ree 
 
import "sort" 
 
var arr = []int{1, 5, 6, 2, 7, 3, 7, 2} 
 
func Run() { 
  sort.Slice(arr, func(i, j int) bool { 
    return arr[i]<arr[j] 
  }) 
}

查看符號表

編譯以上代碼并執行，在執行過程中，對可執行程序本身進行符號解析，過濾并輸出以上代碼中定義的符號。

普通函數

在Go語言中，所有的代碼都必須位于某個包(package)中。

在Go語言中，最特殊的一個包名是main，無論它所在的目錄名稱是什么，編譯后該包下的符號都必須以 main.開頭。

在Go語言中，最特殊的一個函數是main包中的main函數，其編譯之后的符號名稱為main.main，Go運行時將該函數作為程序的入口。

main包中的其它有名稱的函數，都會被編譯器重命名為“包名.函數名”的格式，例如main.anonymousType。

匿名函數

顧名思義，匿名函數就是沒有名稱的函數。

函數中定義的匿名函數，會被重命名為“包名.函數名.funcN”的格式，其中N是一個可遞增的數字。

例如，在以上代碼清單中，

main函數里defer關鍵字后的func() { _ = file.Close() }()是第一個匿名函數，被重命名為main.main.func1。

main函數里go關鍵字后的func是第二個匿名函數，被重命名為main.main.func2。

main.main.func2函數里又定義了兩個匿名函數，它們不再被重命名為funcN格式，而是被重命名為funcN.N格式，分別為main.main.func2.1和main.main.func2.2。

方法

專屬于某一個數據類型的函數，稱為方法。

方法，只不過是語法層面的一個稱謂而已，其本質就是函數;方法的接受者就是其第一個參數，所以方法至少有一個參數。

在 A Tour of Go (https://tour.golang.org/methods/1) 中，對函數的定義為：

A method is a function with a special receiver argument.

方法的定義格式有兩種：

1.接受者為數據類型

例如，reflect/value.go源文件中的Elem方法：

func (v Value) Elem() Value { 
    // 此處省略方法代碼 
}

2.接受者為指針類型

例如，reflect/value.go源文件中的Value方法：

func (it *MapIter) Value() Value {  
    // 此處省略方法代碼 
}

通常情況下，以上兩種格式的方法定義，對應的重命名規則分別如下：

包名.類型.方法名，例如：reflect.Value.Elem

包名.(*類型).方法名，例如：reflect.(*MapIter).Value

實際情況是：編譯過程中的方法重命名規則要復雜的多。后續其他的專題文章會逐漸介紹。

方法中如果包含匿名函數，重命名規則是在其后追加funcN或funcN.N。

全局變量

全局變量的重命名規則是“包名.變量名”。

例如os/proc.go源文件中定義的Args變量。

包層級

在Go語言中，一個包可以包含和定義其他的包，這是通過子目錄實現的，從而形成了包的層級結構。

如果包存在層級結構，則使用“/”進行包名之間的連接，從而實現包的編譯重命名。

例如，io/fs/源碼目錄中定義包名是fs，該包中的變量和函數，在編譯后它們的包名都是“io/fs”。

模塊

模塊(module)是Go語言的依賴管理工具。

一個模塊一般會包含一個或多個包(package)。

模塊中的包、函數、方法、全局變量、匿名函數的重命名規則與以上總結的規則一致，只是需要增加前綴“模塊名/”。

例如，文本代碼清單中定義的模塊名稱是github.com/fooree/go-names，模塊中定義的符號重命名如下：

github.com/fooree/go-names/internal.(*Int).Foo        // 方法名 
github.com/fooree/go-names/internal.(*Int).Foo.func1  // 匿名函數 
github.com/fooree/go-names/internal.X                 // 全局變量 
github.com/fooree/go-names/internal/foo.Ree.Foo       // 方法名 
github.com/fooree/go-names/internal/foo.Y             // 全局變量 
github.com/fooree/go-names/internal/foo.anonymousType // 函數名 
github.com/fooree/go-names/internal/foo/ree.Run       // 函數名 
github.com/fooree/go-names/internal/foo/ree.Run.func1 // 匿名函數 
github.com/fooree/go-names/internal/foo/ree.arr

初始化函數

關于初始化函數的重命名規則，請閱讀【Go】初始化函數。

結語

本文總結了一些基本的符號重命名規則。

本文轉載自微信公眾號「Golang In Memory」，可以通過以下二維碼關注。轉載本文請聯系Golang In Memory公眾號。

責任編輯：武曉燕來源： Golang In Memory

Go 程序重命名