atomic_mipsx.go

     1  // Copyright 2016 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  //go:build mips || mipsle
     6  
     7  // Export some functions via linkname to assembly in sync/atomic.
     8  //
     9  //go:linkname Xadd64
    10  //go:linkname Xchg64
    11  //go:linkname Cas64
    12  //go:linkname Load64
    13  //go:linkname Store64
    14  
    15  package atomic
    16  
    17  import (
    18  	"internal/cpu"
    19  	"unsafe"
    20  )
    21  
    22  // TODO implement lock striping
    23  var lock struct {
    24  	state uint32
    25  	pad   [cpu.CacheLinePadSize - 4]byte
    26  }
    27  
    28  //go:noescape
    29  func spinLock(state *uint32)
    30  
    31  //go:noescape
    32  func spinUnlock(state *uint32)
    33  
    34  //go:nosplit
    35  func lockAndCheck(addr *uint64) {
    36  	// ensure 8-byte alignment
    37  	if uintptr(unsafe.Pointer(addr))&7 != 0 {
    38  		panicUnaligned()
    39  	}
    40  	// force dereference before taking lock
    41  	_ = *addr
    42  
    43  	spinLock(&lock.state)
    44  }
    45  
    46  //go:nosplit
    47  func unlock() {
    48  	spinUnlock(&lock.state)
    49  }
    50  
    51  //go:nosplit
    52  func Xadd64(addr *uint64, delta int64) (new uint64) {
    53  	lockAndCheck(addr)
    54  
    55  	new = *addr + uint64(delta)
    56  	*addr = new
    57  
    58  	unlock()
    59  	return
    60  }
    61  
    62  //go:nosplit
    63  func Xchg64(addr *uint64, new uint64) (old uint64) {
    64  	lockAndCheck(addr)
    65  
    66  	old = *addr
    67  	*addr = new
    68  
    69  	unlock()
    70  	return
    71  }
    72  
    73  //go:nosplit
    74  func Cas64(addr *uint64, old, new uint64) (swapped bool) {
    75  	lockAndCheck(addr)
    76  
    77  	if (*addr) == old {
    78  		*addr = new
    79  		unlock()
    80  		return true
    81  	}
    82  
    83  	unlock()
    84  	return false
    85  }
    86  
    87  //go:nosplit
    88  func Load64(addr *uint64) (val uint64) {
    89  	lockAndCheck(addr)
    90  
    91  	val = *addr
    92  
    93  	unlock()
    94  	return
    95  }
    96  
    97  //go:nosplit
    98  func Store64(addr *uint64, val uint64) {
    99  	lockAndCheck(addr)
   100  
   101  	*addr = val
   102  
   103  	unlock()
   104  	return
   105  }
   106  
   107  //go:noescape
   108  func Xadd(ptr *uint32, delta int32) uint32
   109  
   110  //go:noescape
   111  func Xadduintptr(ptr *uintptr, delta uintptr) uintptr
   112  
   113  //go:noescape
   114  func Xchg(ptr *uint32, new uint32) uint32
   115  
   116  //go:noescape
   117  func Xchguintptr(ptr *uintptr, new uintptr) uintptr
   118  
   119  //go:noescape
   120  func Load(ptr *uint32) uint32
   121  
   122  //go:noescape
   123  func Load8(ptr *uint8) uint8
   124  
   125  // NO go:noescape annotation; *ptr escapes if result escapes (#31525)
   126  func Loadp(ptr unsafe.Pointer) unsafe.Pointer
   127  
   128  //go:noescape
   129  func LoadAcq(ptr *uint32) uint32
   130  
   131  //go:noescape
   132  func LoadAcquintptr(ptr *uintptr) uintptr
   133  
   134  //go:noescape
   135  func And8(ptr *uint8, val uint8)
   136  
   137  //go:noescape
   138  func Or8(ptr *uint8, val uint8)
   139  
   140  //go:noescape
   141  func And(ptr *uint32, val uint32)
   142  
   143  //go:noescape
   144  func Or(ptr *uint32, val uint32)
   145  
   146  //go:noescape
   147  func Store(ptr *uint32, val uint32)
   148  
   149  //go:noescape
   150  func Store8(ptr *uint8, val uint8)
   151  
   152  // NO go:noescape annotation; see atomic_pointer.go.
   153  func StorepNoWB(ptr unsafe.Pointer, val unsafe.Pointer)
   154  
   155  //go:noescape
   156  func StoreRel(ptr *uint32, val uint32)
   157  
   158  //go:noescape
   159  func StoreReluintptr(ptr *uintptr, val uintptr)
   160  
   161  //go:noescape
   162  func CasRel(addr *uint32, old, new uint32) bool
   163
View as plain text