Go Bootstrap

gdb main
(gdb) info files
Symbols from "/home/rj/main".
Local exec file:
	`/home/rj/main', file type elf64-x86-64.
	Entry point: 0x464820
	0x0000000000401000 - 0x000000000049910a is .text
	0x000000000049a000 - 0x00000000004ddd06 is .rodata
	0x00000000004ddee0 - 0x00000000004de614 is .typelink
	0x00000000004de618 - 0x00000000004de668 is .itablink
	0x00000000004de668 - 0x00000000004de668 is .gosymtab
	0x00000000004de680 - 0x000000000053da83 is .gopclntab
	0x000000000053e000 - 0x000000000053e020 is .go.buildinfo
	0x000000000053e020 - 0x000000000054c4c0 is .noptrdata
	0x000000000054c4c0 - 0x0000000000553930 is .data
	0x0000000000553940 - 0x0000000000583250 is .bss
	0x0000000000583260 - 0x00000000005860e8 is .noptrbss
	0x0000000000400f9c - 0x0000000000401000 is .note.go.buildid
(gdb) b *0x464820
Breakpoint 1 at 0x464820: file F:/Go/src/runtime/rt0_linux_amd64.s, line 8.

// The main goroutine.
func main() {
	g := getg()
	// Allow newproc to start new Ms.
	mainStarted = true

	if GOARCH != "wasm" { // no threads on wasm yet, so no sysmon
		systemstack(func() {
			newm(sysmon, nil, -1)
		})
	}

	// Lock the main goroutine onto this, the main OS thread,
	// during initialization. Most programs won't care, but a few
	// do require certain calls to be made by the main thread.
	// Those can arrange for main.main to run in the main thread
	// by calling runtime.LockOSThread during initialization
	// to preserve the lock.
	lockOSThread()

	if g.m != &m0 {
		throw("runtime.main not on m0")
	}

	doInit(&runtime_inittask) // must be before defer
	if nanotime() == 0 {
		throw("nanotime returning zero")
	}

	// Defer unlock so that runtime.Goexit during init does the unlock too.
	needUnlock := true
	defer func() {
		if needUnlock {
			unlockOSThread()
		}
	}()

	// Record when the world started.
	runtimeInitTime = nanotime()

	gcenable()

	main_init_done = make(chan bool)
	if iscgo {
		if _cgo_thread_start == nil {
			throw("_cgo_thread_start missing")
		}
		if GOOS != "windows" {
			if _cgo_setenv == nil {
				throw("_cgo_setenv missing")
			}
			if _cgo_unsetenv == nil {
				throw("_cgo_unsetenv missing")
			}
		}
		if _cgo_notify_runtime_init_done == nil {
			throw("_cgo_notify_runtime_init_done missing")
		}
		// Start the template thread in case we enter Go from
		// a C-created thread and need to create a new thread.
		startTemplateThread()
		cgocall(_cgo_notify_runtime_init_done, nil)
	}

	doInit(&main_inittask)

	close(main_init_done)

	needUnlock = false
	unlockOSThread()

	if isarchive || islibrary {
		// A program compiled with -buildmode=c-archive or c-shared
		// has a main, but it is not executed.
		return
	}
	fn := main_main // make an indirect call, as the linker doesn't know the address of the main package when laying down the runtime
	fn()
	if raceenabled {
		racefini()
	}

	// Make racy client program work: if panicking on
	// another goroutine at the same time as main returns,
	// let the other goroutine finish printing the panic trace.
	// Once it does, it will exit. See issues 3934 and 20018.
	if atomic.Load(&runningPanicDefers) != 0 {
		// Running deferred functions should not take long.
		for c := 0; c < 1000; c++ {
			if atomic.Load(&runningPanicDefers) == 0 {
				break
			}
			Gosched()
		}
	}
	if atomic.Load(&panicking) != 0 {
		gopark(nil, nil, waitReasonPanicWait, traceEvGoStop, 1)
	}

	exit(0)
	for {
		var x *int32
		*x = 0
	}
}

// The main goroutine.
func main() {
	g := getg()
	// 设置main为已启动，以此来运行启动新的M
	mainStarted = true
	// 启动sysmon后台线程，该线程不需要绑定P
	if GOARCH != "wasm" { // no threads on wasm yet, so no sysmon
		systemstack(func() {
			newm(sysmon, nil, -1)
		})
	}
	// main goroutine必须运行在m0上
	if g.m != &m0 {
		throw("runtime.main not on m0")
	}
	// 执行runtime init
	doInit(&runtime_inittask) // must be before defer
	// gc启动
	gcenable()
    // 执行用户的main.init(即运行main函数之前的那些init操作)
	doInit(&main_inittask)
    // 执行用户的main.main(运行main函数)
	fn := main_main // make an indirect call, as the linker doesn't know the address of the main package when laying down the runtime
	fn()
	// 退出程序
	exit(0)
	// 访问非法地址，保证程序一定能够退出(被系统杀死)
	for {
		var x *int32
		*x = 0
	}
}