Detailed explanation of panic source code in go

package main

import "fmt"

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

package main

import (
	"fmt"
	"time"
)

func main() {
	(1)

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

	go func() {
		(2)
		panic("3")
	}()
	()
	(4)
}

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

	panic("1 panic once")
}

// _panic saves an active panic//
// This marks go:notinheap because the value of _panic must be on the stack//
// The argp and link fields are stack pointers, but do not need special processing when the stack grows: because they are pointer types and// The _panic value is only on the stack, and normal stack pointer adjustments will handle them.//
//go:notinheap
type _panic struct {
	argp       // Pointer to defer call parameter during panic; cannot be moved - liblink known	arg       interface{}    // Panic parameters	link      *_panic        // link link to earlier panic	recovered bool           // Is the panic ending	aborted   bool           // Is the panic ignored}

// Implementation of predeclared function panicfunc gopanic(e interface{}) {
	gp := getg()
	// Determine whether it is on the system stack or on the user stack	// If executed on the system or signal stack, getg() will return g0 or gsignal of the current m	// Therefore, you can use == gp to determine the stack	// The panic on the system stack cannot be restored	if  != gp {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic on system stack")
	}
	// If panic occurs while malloc is in progress, it cannot be restored	if  != 0 {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic during malloc")
	}
	// Panic cannot be restored when preemption is prohibited	if  != "" {
		print("panic: ")
		printany(e)
		print("\n")
		print("preempt off reason: ")
		print()
		print("\n")
		throw("panic during preemptoff")
	}
	// Panic cannot be restored when g is locked on m	if  != 0 {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic holding locks")
	}

	// Here is what can be recovered	var p _panic
	 = e
	// panic saves the corresponding message and points to the previous panic link saved in the goroutine link list	 = gp._panic
	gp._panic = (*_panic)(noescape((&p)))

	(&runningPanicDefers, 1)

	for {
		// Start taking the defer call of the current goroutine one by one		d := gp._defer
		// No defer, exit the loop		if d == nil {
			break
		}

		// If defer started with an early panic or Goexit (and, because we go back here, this triggered a new panic),		// Take defer out of the linked list.  Earlier panic or Goexit will not continue to run.		if  {
			if d._panic != nil {
				d._panic.aborted = true
			}
			d._panic = nil
			 = nil
			gp._defer = 
			freedefer(d)
			continue
		}

		// Mark deferred as started		// If stack growth or garbage collection occurs before reflectcall starts execution		// Mark the defer has started execution, but it is still saved in the list, so traceback can find and update the parameter frame of this defer
		// Tag whether defer has been executed		 = true

		// Record the running delayed panic.		// If there is a new panic during the delayed call, then this panic		// D will be found in the list and the tag d._panic (this panic) will abort.		d._panic = (*_panic)(noescape((&p)))

		 = (getargp(0))

		reflectcall(nil, (), deferArgs(d), uint32(), uint32())
		 = nil

		// reflectcall has no panic.  Delete d		if gp._defer != d {
			throw("bad defer entry in panic")
		}
		d._panic = nil
		 = nil
		gp._defer = 

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

		pc := 
		sp := () // must be pointer so it gets adjusted during stack copy
		freedefer(d)
		if  {
			(&runningPanicDefers, -1)

			gp._panic = 
			// Ignored panic will be marked, but it remains in the list			// Move them out of the list here			for gp._panic != nil && gp._panic.aborted {
				gp._panic = gp._panic.link
			}
			if gp._panic == nil { // Must be done by signal				 = 0
			}
			// Pass information about recovery frames			gp.sigcode0 = uintptr(sp)
			gp.sigcode1 = pc
			// Call recovery and re-enter the scheduling loop and no longer return			mcall(recovery)
			// If you cannot re-enter the scheduling loop, the error cannot be restored			throw("recovery failed") // mcall should not return
		}
	}

	// Consume all defer calls and panic conservatively	// Because it is not safe to call any user code after freezing, we call preprintpanics to call	// All necessary Error and String methods to prepare panic strings before startpanic.	preprintpanics(gp._panic)

	fatalpanic(gp._panic) // Should not return	*(*int)(nil) = 0      // Unable to reach}

// reflectcall calls fn with a copy of n parameter bytes pointed to by arg.// After fn returns, reflectcall copies the n-retoffset result bytes back to arg+retoffset before returning.// If the result byte is re-copyed, the caller should pass the parameter frame type as argtype so that the call can perform appropriate write barriers during copying.// reflect Packet passes frame type.  In the runtime package, only one call copies the result back, i.e. cgocallbackg1,// And it does not pass the frame type, which means there is no call write barrier.  See the page for the call for reasons.//
// Package reflect access to this symbol via linknamefunc reflectcall(argtype *_type, fn, arg , argsize uint32, retoffset uint32)

// Expand the stack after the defer function calls recovery after panic occurs.  Then arrange to continue running.// Just like the caller of the defer function returns normally.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 <  ||  < sp) {
		print("recover: ", hex(sp), " not in [", hex(), ", ", hex(), "]\n")
		throw("bad recovery")
	}

	// Make deferproc return for this d	// Return to 1 at this time.  Calling the function will jump to the standard return end	 = sp
	 = pc
	 = 0
	 = 1
	gogo(&)
}

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/
// Execute predeclared function recovery.// Segmented stacks are not allowed because it requires reliably finding the stack segments of its caller.//
// TODO(rsc): Once we commit to CopyStackAlways,
// this doesn't need to be nosplit.
//go:nosplit
func gorecover(argp uintptr) interface{} {
	// Must be run in the function during panic as part of the defer call.	// Must be called from the topmost function (the function used in the defer statement).	// is the parameter pointer of the top-level defer function call.	// Compare the argp reported by the caller, and if it matches, the caller can recover.	gp := getg()
	p := gp._panic
	if p != nil && ! && argp == uintptr() {
		// Tag recovered		 = true
		return 
	}
	return nil
}

// go/src/runtime/
// fatalpanic implements irrecoverable panic.  Similar to fatalthrow,// If msgs != nil, fatalpanic is still able to print panic's message// and reduce runningPanicDeferss when main exits//
//go:nosplit
func fatalpanic(msgs *_panic) {
	// Return to the program count register pointer	pc := getcallerpc()
	// Return to the stack pointer	sp := getcallersp()
	// Return to the current G	gp := getg()
	var docrash bool
	// Switch to the system stack to avoid stack growth, which can lead to worse things if the runtime state is poor	systemstack(func() {
		if startpanic_m() && msgs != nil {
			// If there are panic messages and startpanic_m, you can try printing them
			// Setting startpanic_m will block the exit of main.			// So now we can start reducing runningPanicDefers			(&runningPanicDefers, -1)

			printpanics(msgs)
		}

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

	if docrash {
		// By crashing outside of the above systemstack call, the debugger will not be confused when generating backtracks.		// Function crashes are marked nosplit to avoid stack growth.		crash()
	}
	// Launch from the system	systemstack(func() {
		exit(2)
	})

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

// Print out the currently active panicfunc printpanics(p *_panic) {
	if  != nil {
		printpanics()
		print("\t")
	}
	print("panic: ")
	printany()
	if  {
		print(" [recovered]")
	}
	print("\n")
}