package main

import "fmt"

func main() {
	fmt.Println(1)
	func() {
		fmt.Println(2)
		panic("3")
	}()
	fmt.Println(4)
}

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println(1)

	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()

	go func() {
		fmt.Println(2)
		panic("3")
	}()
	time.Sleep(time.Second)
	fmt.Println(4)
}

func main() {
	defer fmt.Println("in main")
	defer func() {
		defer func() {
			panic("3 panic again and again")
		}()
		panic("2 panic again")
	}()

	panic("1 panic once")
}

// _panic 保存了一個活躍的 panic
//
// 這個標記了 go:notinheap 因為 _panic 的值必須位于棧上
//
// argp 和 link 字段為棧指針，但在棧增長時不需要特殊處理：因為他們是指針類型且
// _panic 值只位于棧上，正常的棧指針調整會處理他們。
//
//go:notinheap
type _panic struct {
	argp      unsafe.Pointer // panic 期間 defer 調用參數的指針; 無法移動 - liblink 已知
	arg       interface{}    // panic的參數
	link      *_panic        // link 鏈接到更早的 panic
	recovered bool           // panic是否結束
	aborted   bool           // panic是否被忽略
}

// 預先聲明的函數 panic 的實現
func gopanic(e interface{}) {
	gp := getg()
	// 判斷在系統棧上還是在用戶棧上
	// 如果執行在系統或信號棧時，getg() 會返回當前 m 的 g0 或 gsignal
	// 因此可以通過 gp.m.curg == gp 來判斷所在棧
	// 系統棧上的 panic 無法恢復
	if gp.m.curg != gp {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic on system stack")
	}
	// 如果正在進行 malloc 時發生 panic 也無法恢復
	if gp.m.mallocing != 0 {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic during malloc")
	}
	// 在禁止搶占時發生 panic 也無法恢復
	if gp.m.preemptoff != "" {
		print("panic: ")
		printany(e)
		print("\n")
		print("preempt off reason: ")
		print(gp.m.preemptoff)
		print("\n")
		throw("panic during preemptoff")
	}
	// 在 g 鎖在 m 上時發生 panic 也無法恢復
	if gp.m.locks != 0 {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic holding locks")
	}

	// 下面是可以恢復的
	var p _panic
	p.arg = e
	// panic 保存了對應的消息，并指向了保存在 goroutine 鏈表中先前的 panic 鏈表
	p.link = gp._panic
	gp._panic = (*_panic)(noescape(unsafe.Pointer(p)))

	atomic.Xadd(runningPanicDefers, 1)

	for {
		// 開始逐個取當前 goroutine 的 defer 調用
		d := gp._defer
		// 沒有defer，退出循環
		if d == nil {
			break
		}

		// 如果 defer 是由早期的 panic 或 Goexit 開始的（并且，因為我們回到這里，這引發了新的 panic），
		// 則將 defer 帶離鏈表。更早的 panic 或 Goexit 將無法繼續運行。
		if d.started {
			if d._panic != nil {
				d._panic.aborted = true
			}
			d._panic = nil
			d.fn = nil
			gp._defer = d.link
			freedefer(d)
			continue
		}

		// 將deferred標記為started
		// 如果棧增長或者垃圾回收在 reflectcall 開始執行 d.fn 前發生
		// 標記 defer 已經開始執行，但仍將其保存在列表中，從而 traceback 可以找到并更新這個 defer 的參數幀

		// 標記defer是否已經執行
		d.started = true

		// 記錄正在運行的延遲的panic。
		// 如果在延遲調用期間有新的panic，那么這個panic
		// 將在列表中找到d，并將標記d._panic(此panic)中止。
		d._panic = (*_panic)(noescape(unsafe.Pointer(p)))

		p.argp = unsafe.Pointer(getargp(0))

		reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))
		p.argp = nil

		// reflectcall沒有panic。刪除d
		if gp._defer != d {
			throw("bad defer entry in panic")
		}
		d._panic = nil
		d.fn = nil
		gp._defer = d.link

		// trigger shrinkage to test stack copy. See stack_test.go:TestStackPanic
		//GC()

		pc := d.pc
		sp := unsafe.Pointer(d.sp) // must be pointer so it gets adjusted during stack copy
		freedefer(d)
		if p.recovered {
			atomic.Xadd(runningPanicDefers, -1)

			gp._panic = p.link
			// 忽略的 panic 會被標記，但仍然保留在 g.panic 列表中
			// 這里將它們移出列表
			for gp._panic != nil  gp._panic.aborted {
				gp._panic = gp._panic.link
			}
			if gp._panic == nil { // 必須由 signal 完成
				gp.sig = 0
			}
			// 傳遞關于恢復幀的信息
			gp.sigcode0 = uintptr(sp)
			gp.sigcode1 = pc
			// 調用 recover，并重新進入調度循環，不再返回
			mcall(recovery)
			// 如果無法重新進入調度循環，則無法恢復錯誤
			throw("recovery failed") // mcall should not return
		}
	}

	// 消耗完所有的 defer 調用，保守地進行 panic
	// 因為在凍結之后調用任意用戶代碼是不安全的，所以我們調用 preprintpanics 來調用
	// 所有必要的 Error 和 String 方法來在 startpanic 之前準備 panic 字符串。
	preprintpanics(gp._panic)

	fatalpanic(gp._panic) // 不應該返回
	*(*int)(nil) = 0      // 無法觸及
}

// reflectcall 使用 arg 指向的 n 個參數字節的副本調用 fn。
// fn 返回后，reflectcall 在返回之前將 n-retoffset 結果字節復制回 arg+retoffset。
// 如果重新復制結果字節，則調用者應將參數幀類型作為 argtype 傳遞，以便該調用可以在復制期間執行適當的寫障礙。
// reflect 包傳遞幀類型。在 runtime 包中，只有一個調用將結果復制回來，即 cgocallbackg1，
// 并且它不傳遞幀類型，這意味著沒有調用寫障礙。參見該調用的頁面了解相關理由。
//
// 包 reflect 通過 linkname 訪問此符號
func reflectcall(argtype *_type, fn, arg unsafe.Pointer, argsize uint32, retoffset uint32)

// 在發生 panic 后 defer 函數調用 recover 后展開棧。然后安排繼續運行，
// 就像 defer 函數的調用方正常返回一樣。
func recovery(gp *g) {
	// Info about defer passed in G struct.
	sp := gp.sigcode0
	pc := gp.sigcode1

	// d's arguments need to be in the stack.
	if sp != 0  (sp  gp.stack.lo || gp.stack.hi  sp) {
		print("recover: ", hex(sp), " not in [", hex(gp.stack.lo), ", ", hex(gp.stack.hi), "]\n")
		throw("bad recovery")
	}

	// 使 deferproc 為此 d 返回
	// 這時候返回 1。調用函數將跳轉到標準的返回尾聲
	gp.sched.sp = sp
	gp.sched.pc = pc
	gp.sched.lr = 0
	gp.sched.ret = 1
	gogo(gp.sched)
}

func deferproc(siz int32, fn *funcval) { // arguments of fn follow fn
	...

	// deferproc returns 0 normally.
	// a deferred func that stops a panic
	// makes the deferproc return 1.
	// the code the compiler generates always
	// checks the return value and jumps to the
	// end of the function if deferproc returns != 0.
	return0()
	// No code can go here - the C return register has
	// been set and must not be clobbered.
}

// go/src/runtime/panic.go
// 執行預先聲明的函數 recover。
// 不允許分段棧，因為它需要可靠地找到其調用者的棧段。
//
// TODO(rsc): Once we commit to CopyStackAlways,
// this doesn't need to be nosplit.
//go:nosplit
func gorecover(argp uintptr) interface{} {
	// 必須在 panic 期間作為 defer 調用的一部分在函數中運行。
	// 必須從調用的最頂層函數（ defer 語句中使用的函數）調用。
	// p.argp 是最頂層 defer 函數調用的參數指針。
	// 比較調用方報告的 argp，如果匹配，則調用者可以恢復。
	gp := getg()
	p := gp._panic
	if p != nil  !p.recovered  argp == uintptr(p.argp) {
		// 標記recovered
		p.recovered = true
		return p.arg
	}
	return nil
}

// go/src/runtime/panic.go
// fatalpanic 實現了不可恢復的 panic。類似于 fatalthrow，
// 如果 msgs != nil，則 fatalpanic 仍然能夠打印 panic 的消息
// 并在 main 在退出時候減少 runningPanicDeferss
//
//go:nosplit
func fatalpanic(msgs *_panic) {
	// 返回程序計數寄存器指針
	pc := getcallerpc()
	// 返回堆棧指針
	sp := getcallersp()
	// 返回當前G
	gp := getg()
	var docrash bool
	// 切換到系統棧來避免棧增長，如果運行時狀態較差則可能導致更糟糕的事情
	systemstack(func() {
		if startpanic_m()  msgs != nil {
			// 有 panic 消息和 startpanic_m 則可以嘗試打印它們

			// startpanic_m 設置 panic 會從阻止 main 的退出，
			// 因此現在可以開始減少 runningPanicDefers 了
			atomic.Xadd(runningPanicDefers, -1)

			printpanics(msgs)
		}

		docrash = dopanic_m(gp, pc, sp)
	})

	if docrash {
		// 通過在上述 systemstack 調用之外崩潰，調試器在生成回溯時不會混淆。
		// 函數崩潰標記為 nosplit 以避免堆棧增長。
		crash()
	}
	// 從系統推出
	systemstack(func() {
		exit(2)
	})

	*(*int)(nil) = 0 // not reached
}

// 打印出當前活動的panic
func printpanics(p *_panic) {
	if p.link != nil {
		printpanics(p.link)
		print("\t")
	}
	print("panic: ")
	printany(p.arg)
	if p.recovered {
		print(" [recovered]")
	}
	print("\n")
}