关于golang:Golang内部构件第5部分运行时引导程序

32次阅读

共计 5755 个字符，预计需要花费 15 分钟才能阅读完成。

疏导过程是理解 Go 运行时如何工作的要害。如果您想持续应用 Go，学习它是必不可少的。因而，咱们的 Golang Internals 系列的第五局部专门探讨 Go 运行时，尤其是 Go 疏导过程。这次您将理解：

  • 自举
  • 可调整大小的堆栈实现
  • 外部 TLS 施行

请留神，这篇文章蕴含许多汇编代码，您至多须要一些基础知识能力持续（这里是 Go 汇编程序的疾速指南）。

寻找一个切入点

首先，咱们须要找到启动 Go 程序后立刻执行的性能。为此，咱们将编写一个简略的 Go 利用。

package main

func main() {print(123)
}

而后，咱们须要对其进行编译和链接。

go tool compile -N -l -S main.go

这将 6.out 在您的当前目录中创立一个名为的可执行文件。下一步波及 objdump 工具，该工具特定于 Linux。Windows 和 Mac 用户能够找到类似物或齐全跳过此步骤。当初，运行以下命令。

objdump -f 6.out

您应该取得输入，其中将蕴含起始地址。

6.out:     file format elf64-x86-64
architecture: i386:x86-64, flags 0x00000112:
EXEC_P, HAS_SYMS, D_PAGED
start address 0x000000000042f160

接下来，咱们须要反汇编可执行文件，并找到哪个函数位于该地址。

objdump -d 6.out > disassemble.txt

而后，咱们须要关上 disassemble.txt 文件并搜寻42f160。咱们失去的输入如下所示

000000000042f160 <_rt0_amd64_linux>:
  42f160:    48 8d 74 24 08               lea    0x8(%rsp),%rsi
  42f165:    48 8b 3c 24                  mov    (%rsp),%rdi
  42f169:    48 8d 05 10 00 00 00     lea    0x10(%rip),%rax        # 42f180 <main>
  42f170:    ff e0                            jmpq   *%rax

很好，咱们找到了！我的操作系统和体系结构的入口点是一个名为的函数_rt0_amd64_linux。

起始程序

当初，咱们须要在 Go 运行时源中找到此函数。它位于 rt0_linux_amd64.s 文件中。如果查看 Go 运行时程序包，则能够找到许多带有与操作系统和体系结构名称相干的后缀的文件名。构建运行时程序包时，仅抉择与以后 OS 和体系结构绝对应的文件。其余的被跳过。让咱们认真看一下 rt0_linux_amd64.s。

TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
    LEAQ    8(SP), SI // argv
    MOVQ    0(SP), DI // argc
    MOVQ    $main(SB), AX
    JMP    AX

TEXT main(SB),NOSPLIT,$-8
    MOVQ    $runtime·rt0_go(SB), AX
    JMP    AX

该 _rt0_amd64_linux 性能是非常简单的。它调用 main 函数并将参数（argc和 argv）保留在寄存器（DI 和SI）中。参数位于堆栈中，并且能够通过 SP（堆栈指针）寄存器进行拜访。次要性能也很简略。它调用的runtime.rt0_go 函数更长且更简单，因而咱们将其分成小局部并别离形容。第一局部是这样的。

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)

在这里，咱们将一些先前保留的命令行参数值放入 AX 并BX缩小堆栈指针。咱们还为另外两个四字节变量增加了空间，并将其调整为 16 位对齐。最初，咱们将参数移回堆栈。

// create istack out of the given (operating system) stack.
// _cgo_init may update stackguard.
MOVQ    $runtime·g0(SB), DI
LEAQ    (-64*1024+104)(SP), BX
MOVQ    BX, g_stackguard0(DI)
MOVQ    BX, g_stackguard1(DI)
MOVQ    BX, (g_stack+stack_lo)(DI)
MOVQ    SP, (g_stack+stack_hi)(DI)

第二局部比拟辣手。首先，咱们将全局 runtime.g0 变量的地址加载到 DI 寄存器中。此变量在 proc1.go 文件中定义，并且属于该 runtime,g 类型。将为 goroutine 零碎中的每个变量创立此类型的变量。如您所料，runtime.g0 形容了 root goroutine。而后，咱们初始化形容 root 堆栈的字段 goroutine。的意义stack.lo 和stack.hi该当明确。这些是指向 current 的堆栈开始和完结的指针 goroutine，然而stackguard0andstackguard1 字段是什么？为了了解这一点，咱们须要搁置对该 runtime.rt0_go 函数的钻研，并认真钻研 Go 中的堆栈增长。

Go 中可调整大小的堆栈实现

Go 语言应用可调整大小的堆栈。每一个都 goroutine 从一个小的堆栈开始，并且每当达到某个阈值时，它的大小就会更改。显然，有一种办法能够查看咱们是否已达到此阈值。实际上，查看是在每个性能的开始执行的。为了理解它的工作原理，让咱们用该 -S 标记再编译一次示例程序（这将显示生成的汇编代码）。次要性能的开始看起来像这样。

"".main t=1 size=48 value=0 args=0x0 locals=0x8
0x0000 00000 (test.go:3)    TEXT    "".main+0(SB),$8-0
0x0000 00000 (test.go:3)    MOVQ    (TLS),CX
0x0009 00009 (test.go:3)    CMPQ    SP,16(CX)
0x000d 00013 (test.go:3)    JHI ,22
0x000f 00015 (test.go:3)    CALL    ,runtime.morestack_noctxt(SB)
0x0014 00020 (test.go:3)    JMP ,0
0x0016 00022 (test.go:3)    SUBQ    $8,SP

首先，咱们将值从线程本地存储（TLS）加载到 CX 寄存器（咱们曾经在上一篇文章中解释了 TLS 是什么）。此值始终蕴含一个指向 runtime.g 与 current 对应的构造的指针 goroutine。而后，咱们将堆栈指针与runtime.g 构造中位于 16 个字节偏移处的值进行比拟。咱们能够轻松地计算出这对应于该 stackguard0 字段。

因而，这就是咱们查看是否已达到堆栈阈值的形式。如果尚未达到，则查看失败。在这种状况下，咱们将 runtime.morestack_noctxt 重复调用该函数，直到为堆栈调配了足够的内存为止。该 stackguard1 字段的工作形式与极为类似 stackguard0，然而它在 C 堆栈增长序言中应用，而不是在 Go 中应用。的外部运作runtime.morestack_noctxt 形式也是一个十分乏味的话题，但咱们将在稍后进行探讨。当初，让咱们回到疏导过程。

Go 自举的进一步考察

咱们将通过查看 runtime.rt0_go 函数中代码的下一部分来开始启动序列。

// find out information about the processor we're on
    MOVQ    $0, AX
    CPUID
    CMPQ    AX, $0
    JE    nocpuinfo

    // Figure out how to serialize RDTSC.
    // On Intel processors LFENCE is enough. AMD requires MFENCE.
    // Don't know about the rest, so let's do MFENCE.
    CMPL    BX, $0x756E6547  // "Genu"
    JNE    notintel
    CMPL    DX, $0x49656E69  // "ineI"
    JNE    notintel
    CMPL    CX, $0x6C65746E  // "ntel"
    JNE    notintel
    MOVB    $1, runtime·lfenceBeforeRdtsc(SB)
notintel:

    MOVQ    $1, AX
    CPUID
    MOVL    CX, runtime·cpuid_ecx(SB)
    MOVL    DX, runtime·cpuid_edx(SB)
nocpuinfo:

这部分对于了解 Go 的次要概念不是至关重要的，因而咱们将对其进行简要介绍。在这里，咱们试图找出正在应用的处理器。如果是 Intel，则设置 runtime·lfenceBeforeRdtsc 变量。该 runtime·cputicks 办法是惟一应用此变量的中央。此办法利用不同的汇编器指令来获取 cpu ticks 依赖于的值 runtime·lfenceBeforeRdtsc。最初，咱们调用 CPUID 汇编程序指令，执行该指令，而后将后果保留在runtime·cpuid_ecx 和runtime·cpuid_edx变量中。这些在 alg.go 文件中应用，以抉择计算机体系结构自身反对的适当哈希算法。

好的，让咱们持续查看代码的另一部分。

// if there is an _cgo_init, call it.
MOVQ    _cgo_init(SB), AX
TESTQ    AX, AX
JZ    needtls
// g0 already in DI
MOVQ    DI, CX    // Win64 uses CX for first parameter
MOVQ    $setg_gcc<>(SB), SI
CALL    AX

// update stackguard after _cgo_init
MOVQ    $runtime·g0(SB), CX
MOVQ    (g_stack+stack_lo)(CX), AX
ADDQ    $const__StackGuard, AX
MOVQ    AX, g_stackguard0(CX)
MOVQ    AX, g_stackguard1(CX)

CMPL    runtime·iswindows(SB), $0
JEQ ok

该片段仅在 cgo 启用时执行。

下一个代码片段负责设置 TLS。

needtls:
    // skip TLS setup on Plan 9
    CMPL    runtime·isplan9(SB), $1
    JEQ ok
    // skip TLS setup on Solaris
    CMPL    runtime·issolaris(SB), $1
    JEQ ok

    LEAQ    runtime·tls0(SB), DI
    CALL    runtime·settls(SB)

    // store through it, to make sure it works
    get_tls(BX)
    MOVQ    $0x123, g(BX)
    MOVQ    runtime·tls0(SB), AX
    CMPQ    AX, $0x123
    JEQ 2(PC)
    MOVL    AX, 0    // abort

咱们之前曾经提到过 TLS。当初，是时候理解它是如何实现的了

外部 TLS 施行

如果认真看一下后面的代码片段，您将很容易了解理论工作中仅有的几行。

LEAQ    runtime·tls0(SB), DI
CALL    runtime·settls(SB)

当您的操作系统不反对 TLS 设置时，所有其余所有内容都将用于跳过 TLS 设置，并查看 TLS 是否失常工作。下面的两行将 runtime·tls0 变量的地址存储在 DI 寄存器中并调用该 runtime·settls 函数。该性能的代码如下所示。

// set tls base to DI
TEXT runtime·settls(SB),NOSPLIT,$32
    ADDQ    $8, DI    // ELF wants to use -8(FS)

    MOVQ    DI, SI
    MOVQ    $0x1002, DI    // ARCH_SET_FS
    MOVQ    $158, AX    // arch_prctl
    SYSCALL
    CMPQ    AX, $0xfffffffffffff001
    JLS    2(PC)
    MOVL    $0xf1, 0xf1  // crash
    RET

从正文中，咱们能够理解到此函数进行 arch_prctl 零碎调用并 ARCH_SET_FS 作为参数传递。咱们还能够看到，该零碎调用为FS 段寄存器设置了根底。在咱们的例子中，咱们将 TLS 设置为指向 runtime·tls0 变量。

您还记得咱们在主函数的汇编代码结尾看到的指令吗？

0x0000 00000 (test.go:3)    MOVQ    (TLS),CX

后面咱们曾经解释过，它将 runtime.g 构造实例的地址加载到 CX 寄存器中。此构造形容了以后构造，goroutine并存储在线程本地存储中。当初，咱们能够找到并理解如何将此指令转换为机器汇编程序。如果关上先前创立的 disassembly.txt 文件并查找该 main.main 函数，则其中的第一条指令应如下所示。

400c00:       64 48 8b 0c 25 f0 ff    mov    %fs:0xfffffffffffffff0,%rcx

本指令（%fs:0xfffffffffffffff0）中的冒号代表分段寻址（您能够在本教程中浏览更多内容）。

返回开始程序

最初，让咱们看一下 runtime.rt0_go 函数的最初两局部。

// set the per-goroutine and per-mach "registers"
get_tls(BX)
LEAQ    runtime·g0(SB), CX
MOVQ    CX, g(BX)
LEAQ    runtime·m0(SB), AX
// save m->g0 = g0
MOVQ    CX, m_g0(AX)
// save m0 to g0->m
MOVQ    AX, g_m(CX)

在这里，咱们将 TLS 地址加载到 BX 寄存器中，并将 runtime·g0 变量的地址保留在 TLS 中。咱们还初始化 runtime.m0 变量。如果 runtime.g0 代表 root goroutine，则 runtime.m0 对应于用于运行 root 的根操作系统线程 goroutine。咱们可能须要认真看看runtime.g0 和runtime.m0构造在行将到来的博客文章。

开始序列的最初一部分将初始化参数并调用不同的函数，但这是独自探讨的主题。因而，咱们理解了疏导过程的外部机制，并理解了如何实现堆栈。为了后退，咱们须要剖析开始序列的最初一部分，这将是咱们下一篇博客文章的主题。

正文完
golang
发表至： golang
2021-03-30
 0
指针值类型-内存布局
关于golang:学习笔记带你十天轻松搞定-Go-微服务系列三-用户服务
关于golang:Go-语言的字符串使用
关于golang:Radix压缩字典树的原理以及Go语言实现代码