all: use a custom sync package

The sync package is strongly tied to the runtime, so it's easier to
implement a new one. Besides, it's pretty big so it's better to replace
it.

src/runtime/sync.go

@@ -1,13 +1 @@
 package runtime
-
-// This file contains support code for the sync package.
-
-//go:linkname registerPoolCleanup sync.runtime_registerPoolCleanup
-func registerPoolCleanup(cleanup func()) {
-	// Ignore.
-}
-
-//go:linkname notifyListCheck sync.runtime_notifyListCheck
-func notifyListCheck(size uintptr) {
-	// Ignore.
-}

src/sync/mutex.go

@@ -0,0 +1,52 @@
+package sync
+
+// These mutexes assume there is only one thread of operation: no goroutines,
+// interrupts or anything else.
+
+type Mutex struct {
+	locked bool
+}
+
+func (m *Mutex) Lock() {
+	if m.locked {
+		panic("todo: block on locked mutex")
+	}
+	m.locked = true
+}
+
+func (m *Mutex) Unlock() {
+	if !m.locked {
+		panic("sync: unlock of unlocked Mutex")
+	}
+	m.locked = false
+}
+
+type RWMutex struct {
+	m       Mutex
+	readers uint32
+}
+
+func (rw *RWMutex) Lock() {
+	rw.m.Lock()
+}
+
+func (rw *RWMutex) Unlock() {
+	rw.m.Unlock()
+}
+
+func (rw *RWMutex) RLock() {
+	if rw.readers == 0 {
+		rw.m.Lock()
+	}
+	rw.readers++
+}
+
+func (rw *RWMutex) RUnlock() {
+	if rw.readers == 0 {
+		panic("sync: unlock of unlocked RWMutex")
+	}
+	rw.readers--
+	if rw.readers == 0 {
+		rw.m.Unlock()
+	}
+}

src/sync/once.go

@@ -0,0 +1,16 @@
+package sync
+
+type Once struct {
+	done bool
+	m    Mutex
+}
+
+func (o *Once) Do(f func()) {
+	o.m.Lock()
+	defer o.m.Unlock()
+	if o.done {
+		return
+	}
+	o.done = true
+	f()
+}