github.com/shogo82148/std@v1.22.1-0.20240327122250-4e474527810c/internal/runtime/atomic/atomic_wasm.go (about)

     1  // Copyright 2018 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  // TODO(neelance): implement with actual atomic operations as soon as threads are available
     6  // See https://github.com/WebAssembly/design/issues/1073
     7  
     8  // Export some functions via linkname to assembly in sync/atomic.
     9  //
    10  //go:linkname Load
    11  //go:linkname Loadp
    12  //go:linkname Load64
    13  //go:linkname Loadint32
    14  //go:linkname Loadint64
    15  //go:linkname Loaduintptr
    16  //go:linkname Xadd
    17  //go:linkname Xaddint32
    18  //go:linkname Xaddint64
    19  //go:linkname Xadd64
    20  //go:linkname Xadduintptr
    21  //go:linkname Xchg
    22  //go:linkname Xchg64
    23  //go:linkname Xchgint32
    24  //go:linkname Xchgint64
    25  //go:linkname Xchguintptr
    26  //go:linkname Cas
    27  //go:linkname Cas64
    28  //go:linkname Casint32
    29  //go:linkname Casint64
    30  //go:linkname Casuintptr
    31  //go:linkname Store
    32  //go:linkname Store64
    33  //go:linkname Storeint32
    34  //go:linkname Storeint64
    35  //go:linkname Storeuintptr
    36  
    37  package atomic
    38  
    39  import "github.com/shogo82148/std/unsafe"
    40  
    41  //go:nosplit
    42  //go:noinline
    43  func Load(ptr *uint32) uint32
    44  
    45  //go:nosplit
    46  //go:noinline
    47  func Loadp(ptr unsafe.Pointer) unsafe.Pointer
    48  
    49  //go:nosplit
    50  //go:noinline
    51  func LoadAcq(ptr *uint32) uint32
    52  
    53  //go:nosplit
    54  //go:noinline
    55  func LoadAcq64(ptr *uint64) uint64
    56  
    57  //go:nosplit
    58  //go:noinline
    59  func LoadAcquintptr(ptr *uintptr) uintptr
    60  
    61  //go:nosplit
    62  //go:noinline
    63  func Load8(ptr *uint8) uint8
    64  
    65  //go:nosplit
    66  //go:noinline
    67  func Load64(ptr *uint64) uint64
    68  
    69  //go:nosplit
    70  //go:noinline
    71  func Xadd(ptr *uint32, delta int32) uint32
    72  
    73  //go:nosplit
    74  //go:noinline
    75  func Xadd64(ptr *uint64, delta int64) uint64
    76  
    77  //go:nosplit
    78  //go:noinline
    79  func Xadduintptr(ptr *uintptr, delta uintptr) uintptr
    80  
    81  //go:nosplit
    82  //go:noinline
    83  func Xchg(ptr *uint32, new uint32) uint32
    84  
    85  //go:nosplit
    86  //go:noinline
    87  func Xchg64(ptr *uint64, new uint64) uint64
    88  
    89  //go:nosplit
    90  //go:noinline
    91  func Xchgint32(ptr *int32, new int32) int32
    92  
    93  //go:nosplit
    94  //go:noinline
    95  func Xchgint64(ptr *int64, new int64) int64
    96  
    97  //go:nosplit
    98  //go:noinline
    99  func Xchguintptr(ptr *uintptr, new uintptr) uintptr
   100  
   101  //go:nosplit
   102  //go:noinline
   103  func And8(ptr *uint8, val uint8)
   104  
   105  //go:nosplit
   106  //go:noinline
   107  func Or8(ptr *uint8, val uint8)
   108  
   109  //go:nosplit
   110  //go:noinline
   111  func And(ptr *uint32, val uint32)
   112  
   113  //go:nosplit
   114  //go:noinline
   115  func Or(ptr *uint32, val uint32)
   116  
   117  //go:nosplit
   118  //go:noinline
   119  func Cas64(ptr *uint64, old, new uint64) bool
   120  
   121  //go:nosplit
   122  //go:noinline
   123  func Store(ptr *uint32, val uint32)
   124  
   125  //go:nosplit
   126  //go:noinline
   127  func StoreRel(ptr *uint32, val uint32)
   128  
   129  //go:nosplit
   130  //go:noinline
   131  func StoreRel64(ptr *uint64, val uint64)
   132  
   133  //go:nosplit
   134  //go:noinline
   135  func StoreReluintptr(ptr *uintptr, val uintptr)
   136  
   137  //go:nosplit
   138  //go:noinline
   139  func Store8(ptr *uint8, val uint8)
   140  
   141  //go:nosplit
   142  //go:noinline
   143  func Store64(ptr *uint64, val uint64)
   144  
   145  // StorepNoWB performs *ptr = val atomically and without a write
   146  // barrier.
   147  //
   148  // NO go:noescape annotation; see atomic_pointer.go.
   149  func StorepNoWB(ptr unsafe.Pointer, val unsafe.Pointer)
   150  
   151  //go:nosplit
   152  //go:noinline
   153  func Casint32(ptr *int32, old, new int32) bool
   154  
   155  //go:nosplit
   156  //go:noinline
   157  func Casint64(ptr *int64, old, new int64) bool
   158  
   159  //go:nosplit
   160  //go:noinline
   161  func Cas(ptr *uint32, old, new uint32) bool
   162  
   163  //go:nosplit
   164  //go:noinline
   165  func Casp1(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
   166  
   167  //go:nosplit
   168  //go:noinline
   169  func Casuintptr(ptr *uintptr, old, new uintptr) bool
   170  
   171  //go:nosplit
   172  //go:noinline
   173  func CasRel(ptr *uint32, old, new uint32) bool
   174  
   175  //go:nosplit
   176  //go:noinline
   177  func Storeint32(ptr *int32, new int32)
   178  
   179  //go:nosplit
   180  //go:noinline
   181  func Storeint64(ptr *int64, new int64)
   182  
   183  //go:nosplit
   184  //go:noinline
   185  func Storeuintptr(ptr *uintptr, new uintptr)
   186  
   187  //go:nosplit
   188  //go:noinline
   189  func Loaduintptr(ptr *uintptr) uintptr
   190  
   191  //go:nosplit
   192  //go:noinline
   193  func Loaduint(ptr *uint) uint
   194  
   195  //go:nosplit
   196  //go:noinline
   197  func Loadint32(ptr *int32) int32
   198  
   199  //go:nosplit
   200  //go:noinline
   201  func Loadint64(ptr *int64) int64
   202  
   203  //go:nosplit
   204  //go:noinline
   205  func Xaddint32(ptr *int32, delta int32) int32
   206  
   207  //go:nosplit
   208  //go:noinline
   209  func Xaddint64(ptr *int64, delta int64) int64