Go 如何实现启动参数的加载

开发 后端
今天我们将问题缩小,来学习 Go 程序是怎么加载启动参数,以及如何进行参数解析。

刚学 Go 的同学一定思考过 Go 程序的启动过程,关于这个问题可以看饶大的文章 Go 程序是怎样跑起来的。今天我们将问题缩小,来学习 Go 程序是怎么加载启动参数,以及如何进行参数解析。

C 参数解析

学习过 C 语言的童鞋,一定对 argc 和 argv 不会陌生。

C 程序总是从主函数 main 开始执行的,而在带参数的主函数中,依照惯例,会使用 argc 和 argv 的命名作为主函数参数。

其中,argc (argument count)代表的是命令行参数个数,argv(argument value) 是用来存放指向参数的指针数组。

  1. #include <stdio.h> 
  2.  
  3. int main(int argc, char *argv[]) 
  4.  printf("argc = %d\n",argc); 
  5.  printf("argv[0] = %s, argv[1] = %s, argv[2] = %s \n", argv[0], argv[1], argv[2]); 
  6.  return 0; 

编译执行以上 C 代码,得到输出如下

  1. $ gcc c_main.c -o main 
  2. $ ./main foo bar sss ddd 
  3. argc = 5 
  4. argv[0] = ./main, argv[1] = foo, argv[2] = bar 

那在 Go 语言中,又该如何获取命令行参数呢?

os.Args 加载

同 C 一样,Go 程序也是从 main 主函数开始(用户层)执行,但主函数中并没有定义 argc 和 argv。

我们可以通过 os.Args 函数,获取命令行参数。

  1. package main 
  2.  
  3. import ( 
  4.  "fmt" 
  5.  "os" 
  6.  
  7. func main() { 
  8.  for i, v := range os.Args { 
  9.   fmt.Printf("arg[%d]: %v\n", i, v) 
  10.  } 

编译执行 Go 函数

  1.  $ go build main.go 
  2.  $ ./main foo bar sss ddd 
  3. arg[0]: ./main 
  4. arg[1]: foo 
  5. arg[2]: bar 
  6. arg[3]: sss 
  7. 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。

  1. TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8 
  2.     JMP _rt0_amd64(SB) 

_rt0_amd64函数实现于 runtime/asm_amd64.s

  1. TEXT _rt0_amd64(SB),NOSPLIT,$-8 
  2.     MOVQ    0(SP), DI   // argc 
  3.     LEAQ    8(SP), SI   // argv 
  4.     JMP runtime·rt0_go(SB) 

看到 argc 和 argv 的身影了吗?在这里,它们从栈内存分别被加载到了 DI、SI 寄存器。

rt0_go函数完成了 runtime 的所有初始化工作,但我们这里仅关注 argc 和 argv 的处理过程。

  1. TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0 
  2.     // copy arguments forward on an even stack 
  3.     MOVQ    DI, AX      // argc 
  4.     MOVQ    SI, BX      // argv 
  5.     SUBQ    $(4*8+7), SP        // 2args 2auto 
  6.     ANDQ    $~15, SP 
  7.     MOVQ    AX, 16(SP) 
  8.     MOVQ    BX, 24(SP) 
  9.     ... 
  10.     MOVL    16(SP), AX      // copy argc 
  11.     MOVL    AX, 0(SP) 
  12.     MOVQ    24(SP), AX      // copy argv 
  13.     MOVQ    AX, 8(SP) 
  14.     CALL    runtime·args(SB) 
  15.     CALL    runtime·osinit(SB) 
  16.     CALL    runtime·schedinit(SB) 
  17.     ... 

经过一系列操作之后,argc 和 argv 又被折腾回了栈内存 0(SP)和 8(SP) 中。

args 函数位于runtime/runtime1.go中

  1. var ( 
  2.  argc int32 
  3.  argv **byte 
  4.  
  5. func args(c int32, v **byte) { 
  6.  argc = c 
  7.  argv = v 
  8.  sysargs(c, v) 

在这里,argc 和 argv 分别被保存至变量runtime.argc和runtime.argv。

在rt0_go函数中调用执行完args函数后,还会执行schedinit。

  1. func schedinit() { 
  2.   ... 
  3.  goargs() 
  4.  ... 

goargs实现于runtime/runtime1.go

  1. var argslice []string 
  2.  
  3. func goargs() { 
  4.  if GOOS == "windows" { 
  5.   return 
  6.  } 
  7.  argslice = make([]string, argc) 
  8.  for i := int32(0); i < argc; i++ { 
  9.   argslice[i] = gostringnocopy(argv_index(argv, i)) 
  10.  } 

该函数的目的是,将指向栈内存的命令行参数字符串指针,封装成 Go 的 string类型,最终保存于runtime.argslice。

这里有个知识点,Go 是如何将 C 字符串封装成 Go string 类型的呢?答案就在以下代码。

  1. func gostringnocopy(str *byte) string { 
  2.  ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)} 
  3.  s := *(*string)(unsafe.Pointer(&ss)) 
  4.  return s 
  5.  
  6. func argv_index(argv **byte, i int32) *byte { 
  7.  return *(**byte)(add(unsafe.Pointer(argv), uintptr(i)*sys.PtrSize)) 
  8.  
  9. func add(p unsafe.Pointer, x uintptr) unsafe.Pointer { 
  10.  return unsafe.Pointer(uintptr(p) + x) 

此时,Go 已经将 argc 和 argv 的信息保存至runtime.argslice中,那聪明的你一定能猜到os.Args方法就是读取的该slice。

在os/proc.go中,是它的实现

  1. var Args []string 
  2.  
  3. func init() { 
  4.  if runtime.GOOS == "windows" { 
  5.   // Initialized in exec_windows.go. 
  6.   return 
  7.  } 
  8.  Args = runtime_args() 
  9.  
  10. func runtime_args() []string // in package runtime 

而runtime_args方法的实现是位于 runtime/runtime.go中的os_runtime_args函数

  1. //go:linkname os_runtime_args os.runtime_args 
  2. 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

 

责任编辑:武晓燕 来源: Golang技术分享
相关推荐

2020-02-20 14:20:28

Windows 10启动程序加载时间

2021-04-09 20:04:34

区块链Go加密

2020-03-17 10:24:12

Go语言停止写障碍

2020-12-30 08:01:07

Java隔离加载

2017-11-16 15:25:54

Go语言算法代码

2024-10-15 10:00:06

2023-08-10 08:00:42

令牌限流器计数器

2021-07-12 10:24:36

Go装饰器代码

2021-01-21 05:45:07

Go字数统计

2023-11-07 10:19:08

2021-06-09 07:15:20

Go枚举技巧

2023-02-26 01:37:57

goORM代码

2018-10-19 10:45:13

WindowsWindows10应用程序

2021-07-02 06:34:53

Go语言sysmon

2019-12-11 16:21:30

Python参数化测试框架

2009-06-04 20:14:20

2023-09-27 08:14:56

2022-06-04 12:25:10

解密加密过滤器

2021-05-20 08:54:16

Go面向对象

2020-09-04 11:02:47

Java技巧参数
点赞
收藏

51CTO技术栈公众号