Comment implémenter le chargement des paramètres de démarrage dans Go

Les étudiants qui viennent d'apprendre le Go doivent avoir réfléchi au processus de démarrage du programme Go. Concernant cette question, vous pouvez lire l'article de Rao Da Comment fonctionne le programme Go. Aujourd'hui, nous réduisons le problème et apprenons comment le programme Go charge les paramètres de démarrage et comment analyser les paramètres.

Analyse des paramètres C

Les enfants qui ont étudié le langage C doivent être familiers avec argc et argv.

Les programmes C commencent toujours l'exécution à partir de la fonction principale main, et dans la fonction principale avec des paramètres, selon la convention, la dénomination de argc et argv sera utilisée comme paramètres de la fonction principale.

Parmi eux, argc (nombre d'arguments) représente le nombre de paramètres de ligne de commande, et argv (valeur de l'argument) est un tableau de pointeurs utilisé pour stocker les paramètres.

#include <stdio.h>

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;
}

Compilez et exécutez le code C ci-dessus, et le résultat est le suivant

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

Alors, comment obtenez-vous les paramètres de ligne de commande en langage Go ?

os.Args chargement

Comme C, le programme Go démarre l'exécution à partir de la fonction principale (niveau utilisateur), mais argc et argv ne sont pas définis dans la fonction principale.

Nous pouvons obtenir les paramètres de ligne de commande via la fonction os.Args.

package main

import (
 "fmt"
 "os"
)

func main() {
 for i, v := range os.Args {
  fmt.Printf("arg[%d]: %v\n", i, v)
 }
}

Compilez et exécutez la fonction 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

Identique à C, le premier paramètre représente également le fichier exécutable.

加载实现

下文我们需要展示一些 Go 汇编代码，为了方便读者理解，先通过两图了解 Go 汇编语言对 CPU 的重新抽象。

X86/AMD64 架构

Go 伪寄存器

Go汇编为了简化汇编代码的编写，引入了 PC、FP、SP、SB 四个伪寄存器。

四个伪寄存器加上其它的通用寄存器就是 Go 汇编语言对 CPU 的重新抽象。当然，该抽象的结构也适用于其它非 X86 类型的体系结构。

回到正题，命令行参数的解析过程是程序启动中的一部分内容。

以 linux amd64 系统为例，Go 程序的执行入口位于<span style="font-size: 15px;">runtime/rt0_linux_amd64.s</span>。

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

<span style="font-size: 15px;">_rt0_amd64</span>函数实现于 <span style="font-size: 15px;">runtime/asm_amd64.s</span>

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 寄存器。

<span style="font-size: 15px;">rt0_go</span>函数完成了 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 又被折腾回了栈内存 <span style="font-size: 15px;">0(SP)</span>和 <span style="font-size: 15px;">8(SP)</span> 中。

<span style="font-size: 15px;">args</span> 函数位于<span style="font-size: 15px;">runtime/runtime1.go</span>中

var (
 argc int32
 argv **byte
)

func args(c int32, v **byte) {
 argc = c
 argv = v
 sysargs(c, v)
}

在这里，argc 和 argv 分别被保存至变量<span style="font-size: 15px;">runtime.argc</span>和<span style="font-size: 15px;">runtime.argv</span>。

在<span style="font-size: 15px;">rt0_go</span>函数中调用执行完<span style="font-size: 15px;">args</span>函数后，还会执行<span style="font-size: 15px;">schedinit</span>。

func schedinit() {
  ...
 goargs()
 ...

<span style="font-size: 15px;">goargs</span>实现于<span style="font-size: 15px;">runtime/runtime1.go</span>

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 的 <span style="font-size: 15px;">string</span>类型，最终保存于<span style="font-size: 15px;">runtime.argslice</span>。

这里有个知识点，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 的信息保存至<span style="font-size: 15px;">runtime.argslice</span>中，那聪明的你一定能猜到os.Args方法就是读取的该slice。

在<span style="font-size: 15px;">os/proc.go</span>中，是它的实现

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

而<span style="font-size: 15px;">runtime_args</span>方法的实现是位于 <span style="font-size: 15px;">runtime/runtime.go</span>中的<span style="font-size: 15px;">os_runtime_args</span>函数

//go:linkname os_runtime_args os.runtime_args
func os_runtime_args() []string { return append([]string{}, argslice...) }

在这里实现了<span style="font-size: 15px;">runtime.argslice</span>的拷贝。至此，<span style="font-size: 15px;">os.Args</span>方法最终成功加载了命令行参数 argv 信息。

Résumé

Dans cet article, nous avons présenté comment Go peut utiliser <span style="font-size: 15px;">os.Args</span>解析程序启动时的命令行参数，并学习了它的实现过程。

在加载实现的源码学习中，我们发现如果从一个点出发，去追溯它的实现原理，这个过程并不复杂，希望童鞋们不要惧怕研究源码。

<span style="font-size: 15px;">os.Args</span>方法将命令行参数存储在字符串切片中，通过遍历即可提取它们。但在实际开发中我们一般不会直接使用<span style="font-size: 15px;">os.Args</span> os.Argsanalyse les paramètres de ligne de commande au démarrage du programme et apprend son processus d'implémentation.

🎜Lors de l'étude du code source de l'implémentation du chargement, nous avons constaté que si nous partons d'un point et retraçons son principe d'implémentation, nous espérons que les enfants n'auront pas peur d'étudier le code source. . 🎜🎜🎜🎜os.Args🎜🎜la méthode modifie les paramètres de ligne de commande Stockés dans des tranches de chaînes, ils peuvent être extraits par parcours. Mais dans le développement réel, nous ne l'utilisons généralement pas directement🎜🎜os.Args🎜 🎜 méthode, car Go nous fournit un package de drapeaux plus utile. Toutefois, pour des raisons de place, cette partie ne sera pas écrite ultérieurement. 🎜🎜🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!