proc: support reading deferred calls' arguments on linux/arm64 (#2210)

Documentation/backend_test_health.md

@@ -3,10 +3,9 @@ Tests skipped by each supported backend:
 * 386 skipped = 2.1% (3/145)
 	* 1 broken
 	* 2 broken - cgo stacktraces
-* arm64 skipped = 2.8% (4/145)
+* arm64 skipped = 2.1% (3/145)
 	* 2 broken
 	* 1 broken - global variable symbolication
-	* 1 broken - reading defers
 * darwin/lldb skipped = 0.69% (1/145)
 	* 1 upstream issue
 * freebsd skipped = 7.6% (11/145)

pkg/proc/arch.go

@@ -15,6 +15,7 @@ type Arch struct {
 	breakpointInstruction []byte
 	breakInstrMovesPC     bool
 	derefTLS              bool
+	usesLR                bool // architecture uses a link register, also called RA on some architectures
 
 	// asmDecode decodes the assembly instruction starting at mem[0:] into asmInst.
 	// It assumes that the Loc and AtPC fields of asmInst have already been filled.

pkg/proc/arm64_arch.go

@@ -40,6 +40,7 @@ func ARM64Arch(goos string) *Arch {
 		DwarfRegisterToString:            arm64DwarfRegisterToString,
 		inhibitStepInto:                  func(*BinaryInfo, uint64) bool { return false },
 		asmDecode:                        arm64AsmDecode,
+		usesLR:                           true,
 	}
 }
 

pkg/proc/proc_test.go

@@ -4160,7 +4160,6 @@ func TestNextUnknownInstr(t *testing.T) {
 }
 
 func TestReadDeferArgs(t *testing.T) {
-	skipOn(t, "broken - reading defers", "arm64")
 	var tests = []struct {
 		frame, deferCall int
 		a, b             int64

pkg/proc/stack.go

@@ -660,13 +660,23 @@ func (d *Defer) EvalScope(thread Thread) (*EvalScope, error) {
 	}
 
 	// The arguments are stored immediately after the defer header struct, i.e.
-	// addr+sizeof(_defer). Since CFA in go is always the address of the first
-	// argument, that's what we use for the value of CFA.
-	// For SP we use CFA minus the size of one pointer because that would be
-	// the space occupied by pushing the return address on the stack during the
-	// CALL.
-	scope.Regs.CFA = (int64(d.variable.Addr) + d.variable.RealType.Common().ByteSize)
-	scope.Regs.Reg(scope.Regs.SPRegNum).Uint64Val = uint64(scope.Regs.CFA - int64(bi.Arch.PtrSize()))
+	// addr+sizeof(_defer).
+
+	if !bi.Arch.usesLR {
+		// On architectures that don't have a link register CFA is always the address of the first
+		// argument, that's what we use for the value of CFA.
+		// For SP we use CFA minus the size of one pointer because that would be
+		// the space occupied by pushing the return address on the stack during the
+		// CALL.
+		scope.Regs.CFA = (int64(d.variable.Addr) + d.variable.RealType.Common().ByteSize)
+		scope.Regs.Reg(scope.Regs.SPRegNum).Uint64Val = uint64(scope.Regs.CFA - int64(bi.Arch.PtrSize()))
+	} else {
+		// On architectures that have a link register CFA and SP have the same
+		// value but the address of the first argument is at CFA+ptrSize so we set
+		// CFA to the start of the argument frame minus one pointer size.
+		scope.Regs.CFA = int64(d.variable.Addr) + d.variable.RealType.Common().ByteSize - int64(bi.Arch.PtrSize())
+		scope.Regs.Reg(scope.Regs.SPRegNum).Uint64Val = uint64(scope.Regs.CFA)
+	}
 
 	rdr := scope.Fn.cu.image.dwarfReader
 	rdr.Seek(scope.Fn.offset)