Golang源码分析 | 程序引导过程

CentOS Linux release 7.2 (Final）
go version go1.16.3 linux/amd64
GNU gdb (GDB) Red Hat Enterprise Linux 7.6.1-80.el7

// main.go
package main

func main() {
        print("Hello world")
}
编译
  go build -gcflags "-N -l" -o simple main.go
使用gdb查看entry
gdb simple
(gdb) info files
Symbols from "/data/project/windeal/golang/simple/simple".
Local exec file:
        `/data/project/windeal/golang/simple/simple', file type elf64-x86-64.
        Entry point: 0x45cd80
        0x0000000000401000 - 0x000000000045ecb6 is .text
        0x000000000045f000 - 0x000000000048bdb5 is .rodata
        0x000000000048bf40 - 0x000000000048c3e0 is .typelink
        0x000000000048c3e0 - 0x000000000048c3e8 is .itablink
        0x000000000048c3e8 - 0x000000000048c3e8 is .gosymtab
        0x000000000048c400 - 0x00000000004c7b68 is .gopclntab
        0x00000000004c8000 - 0x00000000004c8020 is .go.buildinfo
        0x00000000004c8020 - 0x00000000004c9240 is .noptrdata
        0x00000000004c9240 - 0x00000000004cb3f0 is .data
        0x00000000004cb400 - 0x00000000004f86b0 is .bss
        0x00000000004f86c0 - 0x00000000004fd990 is .noptrbss
        0x0000000000400f9c - 0x0000000000401000 is .note.go.buildid
(gdb) 

(gdb) b *0x45cd80
Breakpoint 1 at 0x45cd80: file /data/opt/go/src/runtime/rt0_linux_amd64.s, line 8.
(gdb) 

rt0_linux_amd64.s 
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#include "textflag.h"

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

TEXT _rt0_amd64_linux_lib(SB),NOSPLIT,$0
 JMP _rt0_amd64_lib(SB)

// _rt0_amd64 is common startup code for most amd64 systems when using
// internal linking. This is the entry point for the program from the
// kernel for an ordinary -buildmode=exe program. The stack holds the
// number of arguments and the C-style argv.
TEXT _rt0_amd64(SB),NOSPLIT,$-8
 MOVQ 0(SP), DI // argc
 LEAQ 8(SP), SI // argv
 JMP runtime·rt0_go(SB)

// asm_amd64.s

// Defined as ABIInternal since it does not use the stack-based Go ABI (and
// in addition there are no calls to this entry point from Go code).
TEXT runtime·rt0_go<ABIInternal>(SB),NOSPLIT,$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 // 最后16位清0，实现16字节对齐
 MOVQ AX, 16(SP)
 MOVQ BX, 24(SP)

 // ......  

TEXT runtime·rt0_go<ABIInternal>(SB),NOSPLIT,$0
 ......
ok:
 ......
 MOVL 16(SP), AX  // copy argc
 MOVL AX, 0(SP)
 MOVQ 24(SP), AX  // copy argv
 MOVQ AX, 8(SP)
 ......

TEXT runtime·rt0_go<ABIInternal>(SB),NOSPLIT,$0
 ......
 // create istack out of the given (operating system) stack.
 // _cgo_init may update stackguard.
 MOVQ $runtime·g0(SB), DI   // DI = g0
 LEAQ (-64*1024+104)(SP), BX    
 MOVQ BX, g_stackguard0(DI)  // g0.stackguard0 = SP + (-64*1024+104)
 MOVQ BX, g_stackguard1(DI)  // g0.stackguard1 = SP + (-64*1024+104)
 MOVQ BX, (g_stack+stack_lo)(DI) // g0.stack.stack_lo = SP + (-64*1024+104)
 MOVQ SP, (g_stack+stack_hi)(DI) // g0.stack.stack_hi = SP + (-64*1024+104)

    // find out information about the processor we're on，确定CPU处理器信息
    MOVL $0, AX
    CPUID
    MOVL AX, SI
    CMPL AX, $0
    JE nocpuinfo

 LEAQ runtime·m0+m_tls(SB), DI // DI = m0.tls， 
 CALL runtime·settls(SB)     // 设置TLS， 还没完全看懂，待进一步分析

 // store through it, to make sure it works
 get_tls(BX)
 MOVQ $0x123, g(BX)
 MOVQ runtime·m0+m_tls(SB), AX
 CMPQ AX, $0x123    // 判断 TLS 是否设置成功
 JEQ 2(PC)       // 如果相等则向后跳转两条指令
 CALL runtime·abort(SB)   // 使用 INT 指令执行中断
ok:

 // set the per-goroutine and per-mach "registers"
 // g0和m0是全局变量，先获取他们的地址分别存在寄存器CX和AX
 get_tls(BX)
 LEAQ runtime·g0(SB), CX
 MOVQ CX, g(BX)
 LEAQ runtime·m0(SB), AX

 // 关联g0和m0 
 // save m->g0 = g0
 MOVQ CX, m_g0(AX)
 // save m0 to g0->m
 MOVQ AX, g_m(CX)

 CLD    // convention is D is always left cleared
 CALL runtime·check(SB)

 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)

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

func osinit() {
 ncpu = getproccount()        // 获取CPU核心数
 physHugePageSize = getHugePageSize()   // 获取内存物理页代销
 ......
 osArchInit() //  目前看是个空函数
}

 CALL runtime·schedinit(SB)

// The new G calls runtime·main.
func schedinit() {
 
   // 各种加锁
   ......

 // raceinit must be the first call to race detector.
 // In particular, it must be done before mallocinit below calls racemapshadow.
 _g_ := getg()
 if raceenabled {
  _g_.racectx, raceprocctx0 = raceinit()
 }

 sched.maxmcount = 10000

 // The world starts stopped.
 worldStopped()

   // 栈、内存分配器、调度器相关初始化
 moduledataverify()
 stackinit()   // 初始化执行栈
 mallocinit()  // 初始化内存分配器malloc
 fastrandinit() // must run before mcommoninit
 mcommoninit(_g_.m, -1)   // 初始化当前系统线程，只完成部分通用的初始化 
 cpuinit()       // must run before alginit
 alginit()       // maps must not be used before this call
 modulesinit()   // provides activeModules
 typelinksinit() // uses maps, activeModules
 itabsinit()     // uses activeModules

 sigsave(&_g_.m.sigmask)
 initSigmask = _g_.m.sigmask

 goargs()
 goenvs()
 parsedebugvars()
 gcinit()

   // 创建 P， 通过 CPU 核心数和 GOMAXPROCS 环境变量确定 P 的数量
 lock(&sched.lock)
 sched.lastpoll = uint64(nanotime())
 procs := ncpu
 if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
  procs = n
 }
 if procresize(procs) != nil {
  throw("unknown runnable goroutine during bootstrap")
 }
 unlock(&sched.lock)

 // World is effectively started now, as P's can run.
 worldStarted()

 // For cgocheck > 1, we turn on the write barrier at all times
 // and check all pointer writes. We can't do this until after
 // procresize because the write barrier needs a P.
 if debug.cgocheck > 1 {
  writeBarrier.cgo = true
  writeBarrier.enabled = true
  for _, p := range allp {
   p.wbBuf.reset()
  }
 }

 if buildVersion == "" {
  // Condition should never trigger. This code just serves
  // to ensure runtime·buildVersion is kept in the resulting binary.
  buildVersion = "unknown"
 }
 if len(modinfo) == 1 {
  // Condition should never trigger. This code just serves
  // to ensure runtime·modinfo is kept in the resulting binary.
  modinfo = ""
 }
}

 // create a new goroutine to start program
 MOVQ $runtime·mainPC(SB), AX  // entry, 主 goroutine 入口地址runtime.main
 PUSHQ AX
 PUSHQ $0   // arg size
 CALL runtime·newproc(SB)  // 创建执行单元，创建g
 POPQ AX
 POPQ AX

 // start this M
 CALL runtime·mstart(SB)   // 开始启动调度器的调度循环

 CALL runtime·abort(SB) // mstart should never return
 RET

 // Prevent dead-code elimination of debugCallV1, which is
 // intended to be called by debuggers.
 MOVQ $runtime·debugCallV1<ABIInternal>(SB), AX
RET

func newproc(siz int32, fn *funcval) {
 argp := add(unsafe.Pointer(&fn), sys.PtrSize)
 gp := getg()
 pc := getcallerpc()
 systemstack(func() {
  newg := newproc1(fn, argp, siz, gp, pc)

  _p_ := getg().m.p.ptr()
  runqput(_p_, newg, true)

  if mainStarted {
   wakep()
  }
 })
}

mstart()==>mstart1()==>schedule()