//go:linkname syscall_syscall syscall.syscall
func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
	entersyscall()
	// (以下略)
}

func entersyscall() {
	reentersyscall(getcallerpc(), getcallersp())
}

// The goroutine g is about to enter a system call.
func reentersyscall(pc, sp uintptr) {
	// (一部抜粋)
	// 1. PとMを切り離す
	pp := _g_.m.p.ptr()
	pp.m = 0
	_g_.m.oldp.set(pp)
	_g_.m.p = 0
	// 2. PのステータスをPsyscallに変える
	atomic.Store(&pp.status, _Psyscall)
}

func sysmon() {
	// (一部抜粋)
	// retake P's blocked in syscalls
	// and preempt long running G's
	if retake(now)
}

func retake(now int64) uint32 {
	// (一部抜粋)
	if s == _Prunning || s == _Psyscall {
		// Preempt G if it's running for too long.
		preemptone(_p_)
	}
	if s == _Psyscall {
		handoffp(_p_)
	}
}

func handoffp(_p_ *p) {
    // (一部抜粋)
    startm(_p_, false)
	return
}

//go:linkname syscall_syscall syscall.syscall
func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
	entersyscall()
	libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall)), unsafe.Pointer(&fn))
	exitsyscall()
	return
}

// The goroutine g exited its system call.
// Arrange for it to run on a cpu again.
func exitsyscall() {
	// (一部抜粋)
	casgstatus(_g_, _Gsyscall, _Grunning)
}

epfd int32 = -1 // epoll descriptor

func netpollinit() {
	epfd = epollcreate1(_EPOLL_CLOEXEC) // epoll_create1関数でepollインスタンスを得る
}

// socket returns a network file descriptor that is ready for
// asynchronous I/O using the network poller.
func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error) {
	// (一部抜粋)
	if fd, err = newFD(s, family, sotype, net); // ネットワークI/Oに対応するfdを入手
	fd.dial(ctx, laddr, raddr, ctrlFn) // epollの監視対象に入れる
	return fd, nil
}

func sysmon() {
	// (一部抜粋)
	list := netpoll(0) // non-blocking - returns list of goroutines
	if !list.empty() {
		injectglist(&list) // adds each runnable G on the list to some run queue
	}
}

// netpoll checks for ready network connections.
// Returns list of goroutines that become runnable.
func netpoll(delay int64) gList {
	// (一部抜粋)
	// epollwaitは、epollインスタンス上でイベントがあったか監視して、
	// あったらその内容を第二引数に埋めて、イベント個数を返り値nに入れる
	var events [128]
	n := epollwait(epfd, &events[0], int32(len(events)), waitms)

	// epollwaitの結果から、Gのリストを作る
	var toRun gList
	for i := int32(0); i < n; i++ {
		ev := &events[i]
		if mode != 0 {
			pd := *(**pollDesc)(unsafe.Pointer(&ev.data))
			netpollready(&toRun, pd, mode)
		}
	}
	return toRun
}

// (一部抜粋)
// 2. グローバル変数g0とm0を用意
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)


// 3. 実行環境でのCPU数を取得
CALL	runtime·osinit(SB)
// 4. Pを起動
CALL	runtime·schedinit(SB)

// 5. mainゴールーチンの作成
// create a new goroutine to start program
MOVQ	$runtime·mainPC(SB), AX		// entry
PUSHQ	AX
PUSHQ	$0			// arg size
CALL	runtime·newproc(SB)
POPQ	AX
POPQ	AX

// 6. Mを起動させてスケジューラを呼ぶ
// start this M
CALL	runtime·mstart(SB)

var (
	m0           m
	g0           g
)

// 2. グローバル変数g0とm0を用意
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)

// 3. 実行環境でのCPU数を取得
CALL	runtime·osinit(SB)

// BSD interface for threading.
func osinit() {
	// pthread_create delayed until end of goenvs so that we
	// can look at the environment first.

	ncpu = getncpu()
	physPageSize = getPageSize()
}

var (
	ncpu       int32
)

// 4. Pを起動
CALL	runtime·schedinit(SB)

func schedinit() {
	// (一部抜粋)
	procs := ncpu
	if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
		procs = n
	}

	if procresize(procs) != nil {
		throw("unknown runnable goroutine during bootstrap")
	}
}

// Returns list of Ps with local work, they need to be scheduled by the caller.
func procresize(nprocs int32) *p {
	// (一部抜粋)
	// initialize new P's
	for i := old; i < nprocs; i++ {
		pp := allp[i]
		if pp == nil {
			pp = new(p)
		}
		pp.init(i)
	}

	// 1つPをとってきて、現在のMと繋げる
	p := allp[0]
	acquirep(p)

	// PのローカルキューにGがなくて
	// 他のPをアイドル状態にしていい状態なら
	// グローバル変数schedのpidleフィールドにアイドルなPsをストックしておく
	for i := nprocs - 1; i >= 0; i-- {
		p := allp[i]
		p.status = _Pidle
		if runqempty(p) {
			pidleput(p)
		}
	}
}

// 5. mainゴールーチンの作成
// create a new goroutine to start program
MOVQ	$runtime·mainPC(SB), AX		// entry
PUSHQ	AX
PUSHQ	$0			// arg size
CALL	runtime·newproc(SB)
POPQ	AX
POPQ	AX

// mainPC is a function value for runtime.main, to be passed to newproc.
// The reference to runtime.main is made via ABIInternal, since the
// actual function (not the ABI0 wrapper) is needed by newproc.
DATA	runtime·mainPC+0(SB)/8,$runtime·main<ABIInternal>(SB)
GLOBL	runtime·mainPC(SB),RODATA,$8

// The main goroutine.
func 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()
}

//go:linkname main_main main.main
func main_main()

// Create a new g running fn with siz bytes of arguments.
// Put it on the queue of g's waiting to run.
// The compiler turns a go statement into a call to this.
func newproc(siz int32, fn *funcval) {
	// (一部抜粋)
	newg := newproc1(fn, argp, siz, gp, pc)

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

// 6. Mを起動させてスケジューラを呼ぶ
// start this M
CALL	runtime·mstart(SB)

// mstart is the entry-point for new Ms.
// It is written in assembly, uses ABI0, is marked TOPFRAME, and calls mstart0.
func mstart()