How does the gorecover funtion get its argp parameter?

What is the logic in golang runtime source code that the recover called by a nested deferred function receives a different panic from the panic of the current goroutine?

and how does the gorecover funtion get its argp parameter?

This answer only tell me about the principle,
Why recover() does not work in a nested deferred function?

but I want to figure out the detail of the golang runtime implementation.

My demo code:

package main

import "fmt"

func main() {
	defer func() {
		fmt.Println("enter defer 1")
		defer func() {
			fmt.Println("enter defer 2")
			recover()
			// if e := recover(); e != nil {
			// 	fmt.Println("recover")
			// }
			fmt.Println("exit defer 2")
		}()
		fmt.Println("exit defer 1")
	}()
	panic(404)
}

My output

➜  cmd git:(master) ✗ go run main.go                              
enter defer 1
exit defer 1
enter defer 2
exit defer 2
panic: 404

goroutine 1 [running]:
main.main()
        /Users/polar/code/leetcode/leetcode-go/demo/defer-demo/cmd2/main.go:18 +0x49
exit status 2

I tried to debug to get more informations in this block of golang runtime source code:

the golang runtime source code about recover function.

// /Paht/to/go/src/runtime/panic.go
func gorecover(argp uintptr) any {
	// Must be in a function running as part of a deferred call during the panic.
	// Must be called from the topmost function of the call
	// (the function used in the defer statement).
	// p.argp is the argument pointer of that topmost deferred function call.
	// Compare against argp reported by caller.
	// If they match, the caller is the one who can recover.
	gp := getg()
	p := gp._panic
	if p != nil && !p.goexit && !p.recovered && argp == uintptr(p.argp) {
		p.recovered = true
		return p.arg
	}
	return nil
}

Here are what I got:

The value of gp._panic is

*runtime._panic 
{argp: unsafe.Pointer(0xc00007be58), 
arg: interface {}(int) 404, 
link: *runtime._panic nil, 
pc: 0, 
sp: unsafe.Pointer(0x0), 
recovered: false, 
aborted: false, 
goexit: false}

The value of argp is

(unreadable could not find loclist entry at 0x2ffec for address 0x1036d0a)

From https://go.dev/ref/spec#Handling_panics

> The return value of recover is nil if any of the following conditions holds:
>
> - panic's argument was nil;
> - the goroutine is not panicking;
> - recover was not called directly by a deferred function.

(emph mine)

The last bullet point is your case.
Only the "defer 1" is directly defered. Your "defer 2" is not defered for main (but for defer 1 only and that function didn't panic: It's not on the call stack being unwound during panic).

(It really helps peeking at the language spec: The spec is short and clear and often helpful.)