1
package main
2

3
import "fmt"
4

5
func main() {
6
    fmt.Println("Hello World")
7
}

1
~ go build -v -x main.go
2
WORK=/tmp/go-build3785097308
3
command-line-arguments
4
mkdir -p $WORK/b001/
5
cat >/tmp/go-build3785097308/b001/importcfg << 'EOF' # internal
6
# import config
7
packagefile fmt=/root/.cache/go-build/5a/5a85274bbefd6702b95fe9edb05543e0787d85e1a7dd4a638459c0d94279347e-d
8
packagefile runtime=/root/.cache/go-build/47/47475b234b211c63b7b5248c5ffe186380c67b3a013d5e0a9bfc38ff287322ce-d
9
EOF
10
cd /root/blog-site/content/posts/golang
11
/usr/local/go/pkg/tool/linux_amd64/compile -o $WORK/b001/_pkg_.a -trimpath "$WORK/b001=>" -p main -complete -buildid 9Q9L-dT1lPKryT9M6MuW/9Q9L-dT1lPKryT9M6MuW -goversion go1.20.5 -c=4 -nolocalimports -importcfg $WORK/b001/importcfg -pack ./main.go
12
/usr/local/go/pkg/tool/linux_amd64/buildid -w $WORK/b001/_pkg_.a # internal
13
cp $WORK/b001/_pkg_.a /root/.cache/go-build/65/651f9497c1bf6bdb269656b49fdcc35dc17f28757633725d905c9a12834b70d8-d # internal
14
cat >/tmp/go-build3785097308/b001/importcfg.link << 'EOF' # internal
15
packagefile command-line-arguments=/tmp/go-build3785097308/b001/_pkg_.a
16
packagefile fmt=/root/.cache/go-build/5a/5a85274bbefd6702b95fe9edb05543e0787d85e1a7dd4a638459c0d94279347e-d
17
packagefile runtime=/root/.cache/go-build/47/47475b234b211c63b7b5248c5ffe186380c67b3a013d5e0a9bfc38ff287322ce-d
18
packagefile errors=/root/.cache/go-build/16/1614d1e860779bdd7e63b9ace048ed5c7a97b04fbf64c21e3d5d9ed474dc6127-d
19
packagefile internal/fmtsort=/root/.cache/go-build/38/387acd18f92d205195c39a0cd19fccf97740aca13e8ff884e8380ee620a42625-d
20
packagefile io=/root/.cache/go-build/db/db976f4d0ab0631112d3df9d84973615392ec449f518ab2fdd80f012add5e0ea-d
21
packagefile math=/root/.cache/go-build/9b/9b5cfacac4b76a1cd5bffe8ddf1205bd3311b3351271ef0478df6b24a330aac5-d
22
packagefile os=/root/.cache/go-build/54/543e805161b3797fca3138c85e870dae0b983b5820a9d1d27dfb32787dfb17a8-d
23
packagefile reflect=/root/.cache/go-build/ba/ba60b6d4a1e062811c877f7525496d90904df31d574ccddcafd18ab0765fd3e6-d
24
packagefile sort=/root/.cache/go-build/9c/9c22541614fe877a88f3a267fb9a282f736945c545901a4ab92f6c87295594f0-d
25
packagefile strconv=/root/.cache/go-build/61/61af2248c1b10fa37e5d7da74ce63bc2f3fc4b85d71c8a8d2472c6841263dbbc-d
26
packagefile sync=/root/.cache/go-build/af/af0c9e835f263130088c123bb71d9f528ead461fe081b137543a23a2e6880e0c-d
27
packagefile unicode/utf8=/root/.cache/go-build/55/55c78141439967c497ef1d8bcc1f724dd5b1fab6131ce80d6bc7ab4d338ac783-d
28
packagefile internal/abi=/root/.cache/go-build/b9/b9fe5f7abd9676969136c0fda934dee047633039cae77c70d282251609443bce-d
29
packagefile internal/bytealg=/root/.cache/go-build/b8/b87cc310d783a3a27ab80f0165651d417a52848d12f7adf3003d305eb87f3158-d
30
packagefile internal/coverage/rtcov=/root/.cache/go-build/bc/bc4d12e895fb104d560e6b4192e952d2829d8194cf8a274c5f104c35d80b9774-d
31
packagefile internal/cpu=/root/.cache/go-build/ae/ae7645e84cb76a1bf351f5ab1b823a97e845dfbdea48a8c3bd64010d853b20ee-d
32
packagefile internal/goarch=/root/.cache/go-build/e3/e3dc83e2820ca7ed5dbc544f0181cfd8829e3357e99876f40e5454c7abd3d7f7-d
33
packagefile internal/goexperiment=/root/.cache/go-build/ac/acdb750114f8d21a951104fb87a789b829c55e1269d8e2d5ede8e8109dceb514-d
34
packagefile internal/goos=/root/.cache/go-build/13/13c70de12e7d1cf949413b66cf278a25a60205c9fe2a48884df4cc75bf099dce-d
35
packagefile runtime/internal/atomic=/root/.cache/go-build/02/021d982fd31ceb193751ff630bd0a0708326e65bad78c10d35fe284dc2ddb667-d
36
packagefile runtime/internal/math=/root/.cache/go-build/e9/e9c1b787dae856726480d898196fec4bae10539b338bbb8373d00fe395fbb426-d
37
packagefile runtime/internal/sys=/root/.cache/go-build/f4/f4b5f90f461eb546868335e492567ea93fafc7616321907072ff597df87dd8bc-d
38
packagefile runtime/internal/syscall=/root/.cache/go-build/ba/baf2d32d6593f77b395fed92cf640776faf6fb971842ce63916341639d6d80e1-d
39
packagefile internal/reflectlite=/root/.cache/go-build/01/012b08e178a6c8e813d3c48a5a52d73e938eeec3182f79894f2ba716aae9412c-d
40
packagefile math/bits=/root/.cache/go-build/cb/cb87d7fb3a3d8b81084908cf252115ec4d0345b313c07eb3ee9929df39ac53f0-d
41
packagefile internal/itoa=/root/.cache/go-build/2e/2e1ffdf15257231907ed22bea794e71342406c8066cf719ed7c3c1a295926451-d
42
packagefile internal/poll=/root/.cache/go-build/dd/ddfa9bcc31f046a25a975333486f4ecddec59fb396184cbb6d2761492fc79e18-d
43
packagefile internal/safefilepath=/root/.cache/go-build/f1/f186c3bc25497814c5681b3bbbd5b8e4bbcf455c65dc4a833e9446db8ac538a3-d
44
packagefile internal/syscall/execenv=/root/.cache/go-build/8a/8a956c2b317f1c0d69bc02cbb6c6afb4fa7db43990bb723820e49c4949747892-d
45
packagefile internal/syscall/unix=/root/.cache/go-build/0d/0dd2c0be76cd7c72277a5b8391db4040f85182d4204ac8d43ae635730dc7fa67-d
46
packagefile internal/testlog=/root/.cache/go-build/34/34811ed3b55f7e3febc65f3d800e76be4adc05cfedea8fa873ace7b3092a6c07-d
47
packagefile io/fs=/root/.cache/go-build/31/3138290bc0a2bc085e7839ef4ab7ba901be8b10750897a7e671a23a48a8c1e41-d
48
packagefile sync/atomic=/root/.cache/go-build/5b/5bdd0d873301df7a24b744f11f78b678e44a684b6b4cd83829136aa69cac73f0-d
49
packagefile syscall=/root/.cache/go-build/3a/3a6c5bb22516cd974a1b3a14c01500d92d73d33785b098d6a79de53586937925-d
50
packagefile time=/root/.cache/go-build/7f/7f201b0f381f3a1af27c0a073b9f62698ab1d771b35a678e97f662bbbf1d30e0-d
51
packagefile internal/unsafeheader=/root/.cache/go-build/a5/a5d0da800ef285eedd4592c5c0343f7ca289a8e9611c69d90f42fae894fe4580-d
52
packagefile unicode=/root/.cache/go-build/2b/2be17f8a5ea974fc4bc4e294eb8d59a605226bb7b8ffa829b8417425bb792ff4-d
53
packagefile internal/race=/root/.cache/go-build/09/090603aeb000493ecd31846063b3fc479da8f548f6c94ecd6524ee0d3eee540f-d
54
packagefile internal/oserror=/root/.cache/go-build/25/25e65d202f732dc1c662bddad3dbbc0f733872a3033bf105f7734e562010d3f4-d
55
packagefile path=/root/.cache/go-build/2e/2ef225fea25de35eeec1b70589fa74f75a89f9aedf763fc4e507e81ee24e9e63-d
56
modinfo "0w\xaf\f\x92t\b\x02A\xe1\xc1\a\xe6\xd6\x18\xe6path\tcommand-line-arguments\nbuild\t-buildmode=exe\nbuild\t-compiler=gc\nbuild\tCGO_ENABLED=1\nbuild\tCGO_CFLAGS=\nbuild\tCGO_CPPFLAGS=\nbuild\tCGO_CXXFLAGS=\nbuild\tCGO_LDFLAGS=\nbuild\tGOARCH=amd64\nbuild\tGOOS=linux\nbuild\tGOAMD64=v1\n\xf92C1\x86\x18 r\x00\x82B\x10A\x16\xd8\xf2"
57
EOF
58
mkdir -p $WORK/b001/exe/
59
cd .
60
/usr/local/go/pkg/tool/linux_amd64/link -o $WORK/b001/exe/a.out -importcfg $WORK/b001/importcfg.link -buildmode=exe -buildid=GQ-8mEEisevO5bzTxqty/9Q9L-dT1lPKryT9M6MuW/QuqmoVROIoCDLHhaE7Hb/GQ-8mEEisevO5bzTxqty -extld=gcc $WORK/b001/_pkg_.a
61
/usr/local/go/pkg/tool/linux_amd64/buildid -w $WORK/b001/exe/a.out # internal
62
mv $WORK/b001/exe/a.out main
63
rm -r $WORK/b001/

1
#include "textflag.h"
2

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

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

1
// 声明数据地址 runtime·mainPC+0(SB)，大小为 4，值为 $runtime·main(SB)
2
// 注：SB 表示静态基指针(Static Base Pointer)，它是 Go 中的伪寄存器，用于表示全局数据和只读数据段的基地址(使用时根据符号所在段确定自己的值)
3
// 它的值是在程序加载到内存时由操作系统的程序加载器设置的
4
DATA  runtime·mainPC+0(SB)/4,$runtime·main(SB)
5
// 将 runtime·mainPC(SB) 声明为全局符号
6
GLOBL  runtime·mainPC(SB),RODATA,$4
7

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

17
TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
18
  // copy arguments forward on an even stack
19
  MOVQ  DI, AX    // argc
20
  MOVQ  SI, BX    // argv
21
  // 为局部变量和参数分配空间，将 argc 和 argv 分别后移到 24(SP) 和 32(SP)
22
  // 因为不同架构的入口函数参数数量可能不一致，比如在 x86-64 架构中传入的参数通常就包括：
23
  //argc(命令行参数数量)，argv(命令行参数数组指针)，envp(环境变量数组指针)，auxv(辅助向量，用于传递系统特定的信息)
24
  SUBQ  $(5*8), SP    // 3args 2auto
25
  // 操作堆栈前，确保栈指针是16字节对齐的，以避免性能下降或未定义行为。
26
  // 因为有些指令和操作都要求栈操作在16字节边界上进行。
27
  ANDQ  $~15, SP
28
  MOVQ  AX, 24(SP)
29
  MOVQ  BX, 32(SP)

1
  // 执行运行时检查，以确保环境符合 Go 运行时的要求
2
  CALL  runtime·check(SB)
3

4
  // 将之前后移的 argc 和 argv 复制到栈顶
5
  MOVL  24(SP), AX    // copy argc
6
  MOVL  AX, 0(SP)
7
  MOVQ  32(SP), AX    // copy argv
8
  MOVQ  AX, 8(SP)
9
  // 调用 runtime·args 函数，这个函数处理命令行参数和环境变量，将它们设置为 Go 程序可以使用的格式
10
  CALL  runtime·args(SB)
11
  // 调用 runtime·osinit 函数，这个函数初始化操作系统相关的功能，如信号处理
12
  CALL  runtime·osinit(SB)
13
  // 调用 runtime·schedinit 函数，这个函数初始化 Go 运行时的调度器
14
  CALL  runtime·schedinit(SB)
15

16
  // create a new goroutine to start program
17
  MOVQ  $runtime·mainPC(SB), AX    // entry
18
  PUSHQ  AX
19
  // 调用 runtime·newproc 函数，创建一个新的 goroutine 来执行 main 函数
20
  CALL  runtime·newproc(SB)
21
  POPQ  AX
22

23
  // start this M
24
  // 调用 runtime·mstart 函数，开始执行 Go 运行时的 M（机器），即启动 Go 调度器
25
  CALL  runtime·mstart(SB)
26

27
  // mstart 函数返回，程序中止
28
  CALL  runtime·abort(SB)  // mstart should never return
29
  RET

1
//go:linkname main_main main.main
2
func main_main()
3

4
// The main goroutine.
5
func main() {
6
  mp := getg().m
7

8
  // Racectx of m0->g0 is used only as the parent of the main goroutine.
9
  // It must not be used for anything else.
10
  mp.g0.racectx = 0
11

12
  // Max stack size is 1 GB on 64-bit, 250 MB on 32-bit.
13
  // Using decimal instead of binary GB and MB because
14
  // they look nicer in the stack overflow failure message.
15
  if goarch.PtrSize == 8 {
16
    maxstacksize = 1000000000
17
  } else {
18
    maxstacksize = 250000000
19
  }
20

21
  // An upper limit for max stack size. Used to avoid random crashes
22
  // after calling SetMaxStack and trying to allocate a stack that is too big,
23
  // since stackalloc works with 32-bit sizes.
24
  maxstackceiling = 2 * maxstacksize
25

26
  // Allow newproc to start new Ms.
27
  mainStarted = true
28

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

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

43
  if mp != &m0 {
44
    throw("runtime.main not on m0")
45
  }
46

47
  // Record when the world started.
48
  // Must be before doInit for tracing init.
49
  runtimeInitTime = nanotime()
50
  if runtimeInitTime == 0 {
51
    throw("nanotime returning zero")
52
  }
53

54
  if debug.inittrace != 0 {
55
    inittrace.id = getg().goid
56
    inittrace.active = true
57
  }
58

59
  doInit(&runtime_inittask) // Must be before defer.
60

61
  // Defer unlock so that runtime.Goexit during init does the unlock too.
62
  needUnlock := true
63
  defer func() {
64
    if needUnlock {
65
      unlockOSThread()
66
    }
67
  }()
68

69
  gcenable()
70

71
  main_init_done = make(chan bool)
72
  if iscgo {
73
    if _cgo_thread_start == nil {
74
      throw("_cgo_thread_start missing")
75
    }
76
    if GOOS != "windows" {
77
      if _cgo_setenv == nil {
78
        throw("_cgo_setenv missing")
79
      }
80
      if _cgo_unsetenv == nil {
81
        throw("_cgo_unsetenv missing")
82
      }
83
    }
84
    if _cgo_notify_runtime_init_done == nil {
85
      throw("_cgo_notify_runtime_init_done missing")
86
    }
87
    // Start the template thread in case we enter Go from
88
    // a C-created thread and need to create a new thread.
89
    startTemplateThread()
90
    cgocall(_cgo_notify_runtime_init_done, nil)
91
  }
92

93
  doInit(&main_inittask)
94

95
  // Disable init tracing after main init done to avoid overhead
96
  // of collecting statistics in malloc and newproc
97
  inittrace.active = false
98

99
  close(main_init_done)
100

101
  needUnlock = false
102
  unlockOSThread()
103

104
  if isarchive || islibrary {
105
    // A program compiled with -buildmode=c-archive or c-shared
106
    // has a main, but it is not executed.
107
    return
108
  }
109
  fn := main_main // make an indirect call, as the linker doesn't know the address of the main package when laying down the runtime
110
  fn()
111
  if raceenabled {
112
    runExitHooks(0) // run hooks now, since racefini does not return
113
    racefini()
114
  }
115

116
  // Make racy client program work: if panicking on
117
  // another goroutine at the same time as main returns,
118
  // let the other goroutine finish printing the panic trace.
119
  // Once it does, it will exit. See issues 3934 and 20018.
120
  if runningPanicDefers.Load() != 0 {
121
    // Running deferred functions should not take long.
122
    for c := 0; c < 1000; c++ {
123
      if runningPanicDefers.Load() == 0 {
124
        break
125
      }
126
      Gosched()
127
    }
128
  }
129
  if panicking.Load() != 0 {
130
    gopark(nil, nil, waitReasonPanicWait, traceEvGoStop, 1)
131
  }
132
  runExitHooks(0)
133

134
  exit(0)
135
  for {
136
    var x *int32
137
    *x = 0
138
  }
139
}

1
// 将 g0 存入 TLS
2
get_tls(BX)
3
LEAQ  runtime·g0(SB), CX
4
MOVQ  CX, g(BX)
5
// m0.g0 = g0
6
LEAQ  runtime·m0(SB), AX
7
MOVQ  CX, m_g0(AX)
8
// g0.m = m0
9
MOVQ  AX, g_m(CX)