Update to go1.24.0

src/runtime/race.go

@@ -14,16 +14,49 @@ import (
 // Public race detection API, present iff build with -race.
 
 func RaceRead(addr unsafe.Pointer)
+
+//go:linkname race_Read internal/race.Read
+//go:nosplit
+func race_Read(addr unsafe.Pointer) {
+	RaceRead(addr)
+}
+
 func RaceWrite(addr unsafe.Pointer)
+
+//go:linkname race_Write internal/race.Write
+//go:nosplit
+func race_Write(addr unsafe.Pointer) {
+	RaceWrite(addr)
+}
+
 func RaceReadRange(addr unsafe.Pointer, len int)
+
+//go:linkname race_ReadRange internal/race.ReadRange
+//go:nosplit
+func race_ReadRange(addr unsafe.Pointer, len int) {
+	RaceReadRange(addr, len)
+}
+
 func RaceWriteRange(addr unsafe.Pointer, len int)
 
+//go:linkname race_WriteRange internal/race.WriteRange
+//go:nosplit
+func race_WriteRange(addr unsafe.Pointer, len int) {
+	RaceWriteRange(addr, len)
+}
+
 func RaceErrors() int {
 	var n uint64
 	racecall(&__tsan_report_count, uintptr(unsafe.Pointer(&n)), 0, 0, 0)
 	return int(n)
 }
 
+//go:linkname race_Errors internal/race.Errors
+//go:nosplit
+func race_Errors() int {
+	return RaceErrors()
+}
+
 // RaceAcquire/RaceRelease/RaceReleaseMerge establish happens-before relations
 // between goroutines. These inform the race detector about actual synchronization
 // that it can't see for some reason (e.g. synchronization within RaceDisable/RaceEnable
@@ -38,6 +71,12 @@ func RaceAcquire(addr unsafe.Pointer) {
 	raceacquire(addr)
 }
 
+//go:linkname race_Acquire internal/race.Acquire
+//go:nosplit
+func race_Acquire(addr unsafe.Pointer) {
+	RaceAcquire(addr)
+}
+
 // RaceRelease performs a release operation on addr that
 // can synchronize with a later RaceAcquire on addr.
 //
@@ -49,6 +88,12 @@ func RaceRelease(addr unsafe.Pointer) {
 	racerelease(addr)
 }
 
+//go:linkname race_Release internal/race.Release
+//go:nosplit
+func race_Release(addr unsafe.Pointer) {
+	RaceRelease(addr)
+}
+
 // RaceReleaseMerge is like RaceRelease, but also establishes a happens-before
 // relation with the preceding RaceRelease or RaceReleaseMerge on addr.
 //
@@ -60,6 +105,12 @@ func RaceReleaseMerge(addr unsafe.Pointer) {
 	racereleasemerge(addr)
 }
 
+//go:linkname race_ReleaseMerge internal/race.ReleaseMerge
+//go:nosplit
+func race_ReleaseMerge(addr unsafe.Pointer) {
+	RaceReleaseMerge(addr)
+}
+
 // RaceDisable disables handling of race synchronization events in the current goroutine.
 // Handling is re-enabled with RaceEnable. RaceDisable/RaceEnable can be nested.
 // Non-synchronization events (memory accesses, function entry/exit) still affect
@@ -74,6 +125,12 @@ func RaceDisable() {
 	gp.raceignore++
 }
 
+//go:linkname race_Disable internal/race.Disable
+//go:nosplit
+func race_Disable() {
+	RaceDisable()
+}
+
 // RaceEnable re-enables handling of race events in the current goroutine.
 //
 //go:nosplit
@@ -85,6 +142,12 @@ func RaceEnable() {
 	}
 }
 
+//go:linkname race_Enable internal/race.Enable
+//go:nosplit
+func race_Enable() {
+	RaceEnable()
+}
+
 // Private interface for the runtime.
 
 const raceenabled = true
@@ -105,6 +168,11 @@ func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
 	}
 }
 
+//go:linkname race_ReadObjectPC internal/race.ReadObjectPC
+func race_ReadObjectPC(t *abi.Type, addr unsafe.Pointer, callerpc, pc uintptr) {
+	raceReadObjectPC(t, addr, callerpc, pc)
+}
+
 func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
 	kind := t.Kind_ & abi.KindMask
 	if kind == abi.Array || kind == abi.Struct {
@@ -118,12 +186,27 @@ func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
 	}
 }
 
+//go:linkname race_WriteObjectPC internal/race.WriteObjectPC
+func race_WriteObjectPC(t *abi.Type, addr unsafe.Pointer, callerpc, pc uintptr) {
+	raceWriteObjectPC(t, addr, callerpc, pc)
+}
+
 //go:noescape
 func racereadpc(addr unsafe.Pointer, callpc, pc uintptr)
 
 //go:noescape
 func racewritepc(addr unsafe.Pointer, callpc, pc uintptr)
 
+//go:linkname race_ReadPC internal/race.ReadPC
+func race_ReadPC(addr unsafe.Pointer, callerpc, pc uintptr) {
+	racereadpc(addr, callerpc, pc)
+}
+
+//go:linkname race_WritePC internal/race.WritePC
+func race_WritePC(addr unsafe.Pointer, callerpc, pc uintptr) {
+	racewritepc(addr, callerpc, pc)
+}
+
 type symbolizeCodeContext struct {
 	pc   uintptr
 	fn   *byte