Wie Go das Laden von Startparametern implementiert

Studenten, die gerade erst Go gelernt haben, müssen über den Startvorgang des Go-Programms nachgedacht haben. Zu diesem Thema können Sie den Artikel von Rao Da lesen Wie das Go-Programm läuft. Heute grenzen wir das Problem ein und erfahren, wie das Go-Programm Startparameter lädt und wie die Parameter analysiert werden.

C-Parameteranalyse

Kinder, die C-Sprache gelernt haben, müssen mit argc und argv vertraut sein.

C-Programme starten die Ausführung immer von der Hauptfunktion main aus, und in der Hauptfunktion mit Parametern werden gemäß der Konvention die Namen argc und argv als Hauptfunktionsparameter verwendet.

Unter diesen stellt argc (Argument Count) die Anzahl der Befehlszeilenparameter dar und argv (Argument Value) ist ein Array von Zeigern, die zum Speichern von Parametern verwendet werden.

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

Kompilieren Sie den obigen C-Code und führen Sie ihn aus. Die Ausgabe lautet wie folgt:

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

Wie erhalten Sie also die Befehlszeilenparameter in der Go-Sprache?

os.Args wird geladen

Wie C startet das Go-Programm die Ausführung von der Hauptfunktion (Benutzerebene), argc und argv sind jedoch nicht in der Hauptfunktion definiert.

Wir können Befehlszeilenparameter über die Funktion os.Args abrufen.

package main

import (
 "fmt"
 "os"
)

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

Go-Funktion kompilieren und ausführen

 $ go build main.go
 $ ./main foo bar sss ddd
arg[0]: ./main
arg[1]: foo
arg[2]: bar
arg[3]: sss
arg[4]: ddd

Wie bei C stellt der erste Parameter auch die ausführbare Datei dar.

加载实现

下文我们需要展示一些 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 信息。

Zusammenfassung

In diesem Artikel haben wir vorgestellt, wie Go <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. Argsparst die Befehlszeilenparameter, wenn das Programm gestartet wird, und lernt seinen Implementierungsprozess.

🎜Während des Studiums des Quellcodes der Ladeimplementierung haben wir festgestellt, dass der Prozess nicht kompliziert ist, wenn wir von einem Punkt aus beginnen und dessen Implementierungsprinzip verfolgen. Wir hoffen, dass Kinder keine Angst vor dem Studium des Quellcodes haben . 🎜🎜🎜🎜os.Args🎜🎜method ändert Befehlszeilenparameter Sie werden in String-Slices gespeichert und können durch Durchlaufen extrahiert werden. In der tatsächlichen Entwicklung verwenden wir es jedoch im Allgemeinen nicht direkt - links: 2px;Schriftfamilie: „Operator Mono“, Consolas, Monaco, Menlo, monospace;Wortumbruch: break-all;Hintergrund: rgba(14, 210, 247, 0.15);“>🎜os.Args🎜 🎜-Methode, da Go uns ein nützlicheres Flag-Paket bietet. Aus Platzgründen wird dieser Teil jedoch nicht später geschrieben. 🎜🎜🎜🎜

Das obige ist der detaillierte Inhalt vonWie Go das Laden von Startparametern implementiert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!