github.com/primecitizens/pcz/std@v0.2.1/core/atomic/atomic_s390x.go (about)

     1  // SPDX-License-Identifier: Apache-2.0
     2  // Copyright 2023 The Prime Citizens
     3  //
     4  // Copyright 2016 The Go Authors. All rights reserved.
     5  // Use of this source code is governed by a BSD-style
     6  // license that can be found in the LICENSE file.
     7  
     8  //go:build s390x
     9  
    10  package atomic
    11  
    12  import "unsafe"
    13  
    14  //
    15  // Store
    16  //
    17  
    18  //go:noescape
    19  func Store8(ptr *uint8, val uint8)
    20  
    21  //go:noescape
    22  func Store32(ptr *uint32, val uint32)
    23  
    24  //go:noescape
    25  func Store64(ptr *uint64, val uint64)
    26  
    27  // NO go:noescape annotation; see atomic_pointer.go.
    28  func StorePointer(ptr unsafe.Pointer, val unsafe.Pointer)
    29  
    30  //
    31  // StoreRel
    32  //
    33  
    34  //go:nosplit
    35  //go:noinline
    36  func StoreRel32(ptr *uint32, val uint32) {
    37  	*ptr = val
    38  }
    39  
    40  //go:nosplit
    41  //go:noinline
    42  func StoreRel64(ptr *uint64, val uint64) {
    43  	*ptr = val
    44  }
    45  
    46  //go:nosplit
    47  //go:noinline
    48  func StoreRelUintptr(ptr *uintptr, val uintptr) {
    49  	*ptr = val
    50  }
    51  
    52  //
    53  // Load
    54  //
    55  
    56  //go:nosplit
    57  //go:noinline
    58  func Load8(ptr *uint8) uint8 {
    59  	return *ptr
    60  }
    61  
    62  //go:nosplit
    63  //go:noinline
    64  func Load32(ptr *uint32) uint32 {
    65  	return *ptr
    66  }
    67  
    68  //go:nosplit
    69  //go:noinline
    70  func Load64(ptr *uint64) uint64 {
    71  	return *ptr
    72  }
    73  
    74  //go:nosplit
    75  //go:noinline
    76  func LoadPointer(ptr unsafe.Pointer) unsafe.Pointer {
    77  	return *(*unsafe.Pointer)(ptr)
    78  }
    79  
    80  //
    81  // LoadAcq
    82  //
    83  
    84  //go:nosplit
    85  //go:noinline
    86  func LoadAcq32(ptr *uint32) uint32 {
    87  	return *ptr
    88  }
    89  
    90  //go:nosplit
    91  //go:noinline
    92  func LoadAcq64(ptr *uint64) uint64 {
    93  	return *ptr
    94  }
    95  
    96  //go:nosplit
    97  //go:noinline
    98  func LoadAcqUintptr(ptr *uintptr) uintptr {
    99  	return *ptr
   100  }
   101  
   102  //
   103  // bitwise
   104  //
   105  // NOTE: Do not add atomicxor8 (XOR is not idempotent).
   106  
   107  //go:noescape
   108  func And8(ptr *uint8, val uint8)
   109  
   110  //go:noescape
   111  func And32(ptr *uint32, val uint32)
   112  
   113  //go:noescape
   114  func Or8(ptr *uint8, val uint8)
   115  
   116  //go:noescape
   117  func Or32(ptr *uint32, val uint32)
   118  
   119  //
   120  // Swap
   121  //
   122  
   123  //go:noescape
   124  func Swap32(ptr *uint32, new uint32) uint32
   125  
   126  //go:noescape
   127  func Swap64(ptr *uint64, new uint64) uint64
   128  
   129  //go:noescape
   130  func SwapUintptr(ptr *uintptr, new uintptr) uintptr
   131  
   132  //
   133  // Add
   134  //
   135  
   136  //go:noescape
   137  func Add32(ptr *uint32, delta int32) uint32
   138  
   139  //go:noescape
   140  func Add64(ptr *uint64, delta int64) uint64
   141  
   142  //go:noescape
   143  func AddUintptr(ptr *uintptr, delta uintptr) uintptr
   144  
   145  //
   146  // Compare and swap
   147  //
   148  
   149  //go:noescape
   150  func Cas64(ptr *uint64, old, new uint64) bool
   151  
   152  //go:noescape
   153  func CasRel32(ptr *uint32, old, new uint32) bool