刚学 Go 的同学一定思考过 Go 程序的启动过程，关于这个问题可以看饶大的文章 Go 程序是怎样跑起来的。今天我们将问题缩小，来学习 Go 程序是怎么加载启动参数，以及如何进行参数解析。
C 参数解析
学习过 C 语言的童鞋，一定对 argc 和 argv 不会陌生。
C 程序总是从主函数 main 开始执行的，而在带参数的主函数中，依照惯例，会使用 argc 和 argv 的命名作为主函数参数。
其中，argc (argument count)代表的是命令行参数个数，argv(argument value) 是用来存放指向参数的指针数组。
-
#include
- int main(int argc, char *argv[])
- {
- printf("argc = %d\n",argc);
- printf("argv[0] = %s, argv[1] = %s, argv[2] = %s \n", argv[0], argv[1], argv[2]);
- return 0;
- }
编译执行以上 C 代码，得到输出如下
- $ gcc c_main.c -o main
- $ ./main foo bar sss ddd
- argc = 5
- argv[0] = ./main, argv[1] = foo, argv[2] = bar
那在 Go 语言中，又该如何获取命令行参数呢?
os.Args 加载
同 C 一样，Go 程序也是从 main 主函数开始(用户层)执行，但主函数中并没有定义 argc 和 argv。
我们可以通过 os.Args 函数，获取命令行参数。
- package main
- import (
- "fmt"
- "os"
- )
- func main() {
- for i, v := range os.Args {
- fmt.Printf("arg[%d]: %v\n", i, v)
- }
- }
编译执行 Go 函数
- $ go build main.go
- $ ./main foo bar sss ddd
- arg[0]: ./main
- arg[1]: foo
- arg[2]: bar
- arg[3]: sss
- arg[4]: ddd
同 C 一样，第一个参数也是代表可执行文件。
加载实现
下文我们需要展示一些 Go 汇编代码，为了方便读者理解，先通过两图了解 Go 汇编语言对 CPU 的重新抽象。
X86/AMD64 架构
Go 伪寄存器
Go汇编为了简化汇编代码的编写，引入了 PC、FP、SP、SB 四个伪寄存器。
四个伪寄存器加上其它的通用寄存器就是 Go 汇编语言对 CPU 的重新抽象。当然，该抽象的结构也适用于其它非 X86 类型的体系结构。
回到正题，命令行参数的解析过程是程序启动中的一部分内容。
以 linux amd64 系统为例，Go 程序的执行入口位于runtime/rt0_linux_amd64.s。
- TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
- JMP _rt0_amd64(SB)
_rt0_amd64函数实现于 runtime/asm_amd64.s
- TEXT _rt0_amd64(SB),NOSPLIT,$-8
- MOVQ 0(SP), DI // argc
- LEAQ 8(SP), SI // argv
- JMP runtime·rt0_go(SB)
看到 argc 和 argv 的身影了吗?在这里，它们从栈内存分别被加载到了 DI、SI 寄存器。
rt0_go函数完成了 runtime 的所有初始化工作，但我们这里仅关注 argc 和 argv 的处理过程。
- TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
- // copy arguments forward on an even stack
- MOVQ DI, AX // argc
- MOVQ SI, BX // argv
- SUBQ $(4*8+7), SP // 2args 2auto
- ANDQ $~15, SP
- MOVQ AX, 16(SP)
- MOVQ BX, 24(SP)
- ...
- MOVL 16(SP), AX // copy argc
- MOVL AX, 0(SP)
- MOVQ 24(SP), AX // copy argv
- MOVQ AX, 8(SP)
- CALL runtime·args(SB)
- CALL runtime·osinit(SB)
- CALL runtime·schedinit(SB)
- ...
经过一系列操作之后，argc 和 argv 又被折腾回了栈内存 0(SP)和 8(SP) 中。
args 函数位于runtime/runtime1.go中
- var (
- argc int32
- argv **byte
- )
- func args(c int32, v **byte) {
- argc = c
- argv = v
- sysargs(c, v)
- }
在这里，argc 和 argv 分别被保存至变量runtime.argc和runtime.argv。
在rt0_go函数中调用执行完args函数后，还会执行schedinit。
- func schedinit() {
- ...
- goargs()
- ...
goargs实现于runtime/runtime1.go
- var argslice []string
- func goargs() {
- if GOOS == "windows" {
- return
- }
- argslice = make([]string, argc)
- for i := int32(0); i < argc; i++ {
- argslice[i] = gostringnocopy(argv_index(argv, i))
- }
- }
该函数的目的是，将指向栈内存的命令行参数字符串指针，封装成 Go 的 string类型，最终保存于runtime.argslice。
这里有个知识点，Go 是如何将 C 字符串封装成 Go string 类型的呢?答案就在以下代码。
- func gostringnocopy(str *byte) string {
- ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}
- s := *(*string)(unsafe.Pointer(&ss))
- return s
- }
- func argv_index(argv **byte, i int32) *byte {
- return *(**byte)(add(unsafe.Pointer(argv), uintptr(i)*sys.PtrSize))
- }
- func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
- return unsafe.Pointer(uintptr(p) + x)
- }
此时，Go 已经将 argc 和 argv 的信息保存至runtime.argslice中，那聪明的你一定能猜到os.Args方法就是读取的该slice。
在os/proc.go中，是它的实现
- var Args []string
- func init() {
- if runtime.GOOS == "windows" {
- // Initialized in exec_windows.go.
- return
- }
- Args = runtime_args()
- }
- func runtime_args() []string // in package runtime
而runtime_args方法的实现是位于 runtime/runtime.go中的os_runtime_args函数
- //go:linkname os_runtime_args os.runtime_args
- func os_runtime_args() []string { return append([]string{}, argslice...) }
在这里实现了runtime.argslice的拷贝。至此，os.Args方法最终成功加载了命令行参数 argv 信息。
总结
本文我们介绍了 Go 可以利用os.Args解析程序启动时的命令行参数，并学习了它的实现过程。
在加载实现的源码学习中，我们发现如果从一个点出发，去追溯它的实现原理，这个过程并不复杂，希望童鞋们不要惧怕研究源码。
os.Args方法将命令行参数存储在字符串切片中，通过遍历即可提取它们。但在实际开发中我们一般不会直接使用os.Args方法，因为 Go 为我们提供了一个更好用的 flag 包。但鉴于篇幅原因，该部分的内容以后再写了。
参考
go语言高级编程--------汇编语言部分学习笔记：https://blog.csdn.net/cyq6239075/article/details/106480140
Go 程序是怎样跑起来的：https://mp.weixin.qq.com/s/Rewl0DKnq6CY53m5D3G2qw
原文链接：https://mp.weixin.qq.com/s/NYlAXYdfA0g8JpSdpksPGg
