runtime篇四：panic

type _panic struct {
	argp      unsafe.Pointer // 指向defer调用时参数的指针
	arg       any            // panic参数
	link      *_panic        // 连接到更早的_panic
	pc        uintptr        // 程序计数器
	sp        unsafe.Pointer // 栈指针
	recovered bool           // 当前panic是否被recover恢复
	aborted   bool           // 当前panic是否被中止
	goexit    bool           // 是否调用了runtime.Goexit
}

func gopanic(e any) {
	gp := getg()         // 获取当前g

    // ...
    // 此处省略部分代码

	var p _panic
	p.arg = e          // panic参数
	p.link = gp._panic // 头插
	gp._panic = (*_panic)(noescape(unsafe.Pointer(&p)))

	// 省略defer调用部分

	// ran out of deferred calls - old-school panic now
	// Because it is unsafe to call arbitrary user code after freezing
	// the world, we call preprintpanics to invoke all necessary Error
	// and String methods to prepare the panic strings before startpanic.
	preprintpanics(gp._panic)

	fatalpanic(gp._panic) // should not return
	*(*int)(nil) = 0      // not reached
}

func fatalpanic(msgs *_panic) {
	pc := getcallerpc()
	sp := getcallersp()
	gp := getg()
	var docrash bool
	// Switch to the system stack to avoid any stack growth, which
	// may make things worse if the runtime is in a bad state.

    // 切换到系统栈以避免用户栈增长
	systemstack(func() {
        // startpanic_m在应该打印panic信息时返回true
		if startpanic_m() && msgs != nil { // 
			atomic.Xadd(&runningPanicDefers, -1)

			printpanics(msgs) // 打印panic信息
		}

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

	if docrash {
		crash()
	}

	systemstack(func() {
		exit(2)
	})

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

func gopanic(e any) {
	gp := getg()         // 获取当前g

    // 省略部分代码

	var p _panic
	p.arg = e          // panic参数
	p.link = gp._panic // 头插
	gp._panic = (*_panic)(noescape(unsafe.Pointer(&p))) // 将当前这个panic赋值给当前defer

	atomic.Xadd(&runningPanicDefers, 1)

	// By calculating getcallerpc/getcallersp here, we avoid scanning the
	// gopanic frame (stack scanning is slow...)
	addOneOpenDeferFrame(gp, getcallerpc(), unsafe.Pointer(getcallersp())) // 这里添加了一个open-code defer

    // 检查g中是否还存在defer调用
	for {
		d := gp._defer // 尝试获取_defer
		if d == nil { // 如果没有设置_defer，则直接跳出
			break
		}

        // 如果defer被更早的panic或Goexit启动了（或者在程序到达这里之前，又触发了一个新的panic），
		// 则将当前defer移出defer链表，先前的panic将不再执行，但确保先前的Goexit继续执行

		if d.started { // defer已经被启动了
			if d._panic != nil { // defer函数中也存在panic
				d._panic.aborted = true // 终止defer的panic
			}
			d._panic = nil
			if !d.openDefer { // 未使用开放编码
				d.fn = nil
				gp._defer = d.link // 继续检查下一个defer
				freedefer(d)
				continue
			}
		}
		// Mark defer as started, but keep on list, so that traceback
		// can find and update the defer's argument frame if stack growth
		// or a garbage collection happens before executing d.fn.
		d.started = true // 将defer标记为启动

		// Record the panic that is running the defer.
		// If there is a new panic during the deferred call, that panic
		// will find d in the list and will mark d._panic (this panic) aborted.
		d._panic = (*_panic)(noescape(unsafe.Pointer(&p))) // 将当前panic赋值給defer

		done := true
		if d.openDefer {
			done = runOpenDeferFrame(gp, d)
			if done && !d._panic.recovered {
				addOneOpenDeferFrame(gp, 0, nil)
			}
		} else {
			p.argp = unsafe.Pointer(getargp())
			d.fn() // 调用defer函数
		}
		p.argp = nil

		// Deferred function did not panic. Remove d.
		if gp._defer != d {
			throw("bad defer entry in panic")
		}
		d._panic = nil

		// 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
		if done { // 如果完成了defer函数
			d.fn = nil
			gp._defer = d.link
			freedefer(d)
		}
		if p.recovered { // 如果panic被recover，则继续执行下一个panic
			// 省略recover部分
		}
	}

	preprintpanics(gp._panic)

	fatalpanic(gp._panic) // should not return
	*(*int)(nil) = 0      // not reached
}

1│ package main
2│
3│ func main() {
4│     defer func() {
5│         panic("2")
6│     }()
7│     panic("1")
8│ }

func gorecover(argp uintptr) any {
	gp := getg()
	p := gp._panic
	if p != nil && !p.goexit && !p.recovered && argp == uintptr(p.argp) {
		p.recovered = true
		return p.arg
	}
	return nil
}

1 │ package main
2 │
3 │ func main() {
4 │     defer func() {
5 │         if r := recover(); r != nil {
6 │             println(r)
7 │         }
8 │     }()
9 │     panic("1")
10│ }

1 │func gopanic(e any) {
2 │    ...
3 │    for {
4 │        d := gp._defer // panic退出程序前，要执行defer
5 │        if d == nil {
6 │            break
7 │        }
8 │
9 │        ...
10│
11│        if p.recovered { // 如果panic被recover，则继续执行下一个panic
12│            gp._panic = p.link
13│            if gp._panic != nil && gp._panic.goexit && gp._panic.aborted {
14│                // A normal recover would bypass/abort the Goexit.  Instead,
15│                // we return to the processing loop of the Goexit.
16│                gp.sigcode0 = uintptr(gp._panic.sp)
17│                gp.sigcode1 = uintptr(gp._panic.pc)
18│                mcall(recovery)
19│                throw("bypassed recovery failed") // mcall should not return
20│            }
21│            atomic.Xadd(&runningPanicDefers, -1)
22│
23│            // After a recover, remove any remaining non-started,
24│            // open-coded defer entries, since the corresponding defers
25│            // will be executed normally (inline). Any such entry will
26│            // become stale once we run the corresponding defers inline
27│            // and exit the associated stack frame. We only remove up to
28│            // the first started (in-progress) open defer entry, not
29│            // including the current frame, since any higher entries will
30│            // be from a higher panic in progress, and will still be
31│            // needed.
32│            d := gp._defer
33│            var prev *_defer
34│            if !done {
35│                // Skip our current frame, if not done. It is
36│                // needed to complete any remaining defers in
37│                // deferreturn()
38│                prev = d
39│                d = d.link
40│            }
41│            for d != nil { // 这里去除了已经开始的open defer
42│                // 暂时省略
43│            }
44│
45│            gp._panic = p.link
46│            // Aborted panics are marked but remain on the g.panic list.
47│            // Remove them from the list.
48│            for gp._panic != nil && gp._panic.aborted {
49│                gp._panic = gp._panic.link
50│            }
51│            if gp._panic == nil { // must be done with signal
52│                gp.sig = 0
53│            }
54│            // Pass information about recovering frame to recovery.
55│            gp.sigcode0 = uintptr(sp)
56│            gp.sigcode1 = pc
57│            mcall(recovery)
58│            throw("recovery failed") // mcall should not return
59│        }
60│    }
61│
62│    // ...
63│}

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")
	}

	// Make the deferproc for this d return again,
	// this time returning 1. The calling function will
	// jump to the standard return epilogue.
	gp.sched.sp = sp
	gp.sched.pc = pc
	gp.sched.lr = 0
	gp.sched.ret = 1
	gogo(&gp.sched)
}

func main() {
	defer recover()
	panic("1")
}

if p != nil && !p.goexit && !p.recovered && argp == uintptr(p.argp) {
	p.recovered = true
	return p.arg
}

func main() {
	defer func() { // topdefer
		fmt.Println(recover())
	}()

	defer panic(3) // defer3
	defer panic(2) // defer2
	defer panic(1) // defer1
	panic(0)
}

if d.started {
	if d._panic != nil {
		d._panic.aborted = true
	}
	d._panic = nil
	if !d.openDefer {
		d.fn = nil
		gp._defer = d.link
		freedefer(d)
		continue
	}
}

for gp._panic != nil && gp._panic.aborted {
	gp._panic = gp._panic.link
}

func gorecover(argp uintptr) any {
	gp := getg()
	p := gp._panic
	if p != nil && !p.goexit && !p.recovered && argp == uintptr(p.argp) {
		p.recovered = true
		return p.arg
	}
	return nil
}

func fatalpanic(msgs *_panic) {
	// ...

	systemstack(func() {
		exit(2)
	})

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