| // Copyright 2014 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
|
|
| //go:build ppc64 || ppc64le |
|
|
| |
|
|
| // For more details about how various memory models are |
| // enforced on POWER, the following paper provides more |
| // details about how they enforce C/C++ like models. This |
| // gives context about why the strange looking code |
| // sequences below work. |
| // |
| // http://www.rdrop.com/users/paulmck/scalability/paper/N2745r.2011.03.04a.html |
|
|
| // uint32 路Load(uint32 volatile* ptr) |
| TEXT 路Load(SB),NOSPLIT|NOFRAME,$-8-12 |
| MOVD ptr+0(FP), R3 |
| SYNC |
| MOVWZ 0(R3), R3 |
| CMPW R3, R3, CR7 |
| BC 4, 30, 1(PC) // bne- cr7,0x4 |
| ISYNC |
| MOVW R3, ret+8(FP) |
| RET |
|
|
| // uint8 路Load8(uint8 volatile* ptr) |
| TEXT 路Load8(SB),NOSPLIT|NOFRAME,$-8-9 |
| MOVD ptr+0(FP), R3 |
| SYNC |
| MOVBZ 0(R3), R3 |
| CMP R3, R3, CR7 |
| BC 4, 30, 1(PC) // bne- cr7,0x4 |
| ISYNC |
| MOVB R3, ret+8(FP) |
| RET |
|
|
| // uint64 路Load64(uint64 volatile* ptr) |
| TEXT 路Load64(SB),NOSPLIT|NOFRAME,$-8-16 |
| MOVD ptr+0(FP), R3 |
| SYNC |
| MOVD 0(R3), R3 |
| CMP R3, R3, CR7 |
| BC 4, 30, 1(PC) // bne- cr7,0x4 |
| ISYNC |
| MOVD R3, ret+8(FP) |
| RET |
|
|
| // void *路Loadp(void *volatile *ptr) |
| TEXT 路Loadp(SB),NOSPLIT|NOFRAME,$-8-16 |
| MOVD ptr+0(FP), R3 |
| SYNC |
| MOVD 0(R3), R3 |
| CMP R3, R3, CR7 |
| BC 4, 30, 1(PC) // bne- cr7,0x4 |
| ISYNC |
| MOVD R3, ret+8(FP) |
| RET |
|
|
| // uint32 路LoadAcq(uint32 volatile* ptr) |
| TEXT 路LoadAcq(SB),NOSPLIT|NOFRAME,$-8-12 |
| MOVD ptr+0(FP), R3 |
| MOVWZ 0(R3), R3 |
| CMPW R3, R3, CR7 |
| BC 4, 30, 1(PC) // bne- cr7, 0x4 |
| ISYNC |
| MOVW R3, ret+8(FP) |
| RET |
|
|
| // uint64 路LoadAcq64(uint64 volatile* ptr) |
| TEXT 路LoadAcq64(SB),NOSPLIT|NOFRAME,$-8-16 |
| MOVD ptr+0(FP), R3 |
| MOVD 0(R3), R3 |
| CMP R3, R3, CR7 |
| BC 4, 30, 1(PC) // bne- cr7, 0x4 |
| ISYNC |
| MOVD R3, ret+8(FP) |
| RET |
|
|
| // func Cas(ptr *int32, old, new int32) bool |
| // Atomically: |
| // if *ptr == old { |
| // *ptr = new |
| // return true |
| // } else { |
| // return false |
| // } |
| TEXT 路Cas(SB), NOSPLIT, $0-17 |
| MOVD ptr+0(FP), R3 |
| MOVWZ old+8(FP), R4 |
| MOVWZ new+12(FP), R5 |
| LWSYNC |
| cas_again: |
| LWAR (R3), R6 |
| CMPW R6, R4 |
| BNE cas_fail |
| STWCCC R5, (R3) |
| BNE cas_again |
| MOVD $1, R3 |
| LWSYNC |
| MOVB R3, ret+16(FP) |
| RET |
| cas_fail: |
| LWSYNC |
| MOVB R0, ret+16(FP) |
| RET |
|
|
| // func Cas64(ptr *uint64, old, new uint64) bool |
| // Atomically: |
| // if *ptr == old { |
| // *ptr = new |
| // return true |
| // } else { |
| // return false |
| // } |
| TEXT 路Cas64(SB), NOSPLIT, $0-25 |
| MOVD ptr+0(FP), R3 |
| MOVD old+8(FP), R4 |
| MOVD new+16(FP), R5 |
| LWSYNC |
| cas64_again: |
| LDAR (R3), R6 |
| CMP R6, R4 |
| BNE cas64_fail |
| STDCCC R5, (R3) |
| BNE cas64_again |
| MOVD $1, R3 |
| LWSYNC |
| MOVB R3, ret+24(FP) |
| RET |
| cas64_fail: |
| LWSYNC |
| MOVB R0, ret+24(FP) |
| RET |
|
|
| TEXT 路CasRel(SB), NOSPLIT, $0-17 |
| MOVD ptr+0(FP), R3 |
| MOVWZ old+8(FP), R4 |
| MOVWZ new+12(FP), R5 |
| LWSYNC |
| cas_again: |
| LWAR (R3), $0, R6 // 0 = Mutex release hint |
| CMPW R6, R4 |
| BNE cas_fail |
| STWCCC R5, (R3) |
| BNE cas_again |
| MOVD $1, R3 |
| MOVB R3, ret+16(FP) |
| RET |
| cas_fail: |
| MOVB R0, ret+16(FP) |
| RET |
|
|
| TEXT 路Casint32(SB), NOSPLIT, $0-17 |
| BR 路Cas(SB) |
|
|
| TEXT 路Casint64(SB), NOSPLIT, $0-25 |
| BR 路Cas64(SB) |
|
|
| TEXT 路Casuintptr(SB), NOSPLIT, $0-25 |
| BR 路Cas64(SB) |
|
|
| TEXT 路Loaduintptr(SB), NOSPLIT|NOFRAME, $0-16 |
| BR 路Load64(SB) |
|
|
| TEXT 路LoadAcquintptr(SB), NOSPLIT|NOFRAME, $0-16 |
| BR 路LoadAcq64(SB) |
|
|
| TEXT 路Loaduint(SB), NOSPLIT|NOFRAME, $0-16 |
| BR 路Load64(SB) |
|
|
| TEXT 路Storeint32(SB), NOSPLIT, $0-12 |
| BR 路Store(SB) |
|
|
| TEXT 路Storeint64(SB), NOSPLIT, $0-16 |
| BR 路Store64(SB) |
|
|
| TEXT 路Storeuintptr(SB), NOSPLIT, $0-16 |
| BR 路Store64(SB) |
|
|
| TEXT 路StoreReluintptr(SB), NOSPLIT, $0-16 |
| BR 路StoreRel64(SB) |
|
|
| TEXT 路Xadduintptr(SB), NOSPLIT, $0-24 |
| BR 路Xadd64(SB) |
|
|
| TEXT 路Loadint32(SB), NOSPLIT, $0-12 |
| BR 路Load(SB) |
|
|
| TEXT 路Loadint64(SB), NOSPLIT, $0-16 |
| BR 路Load64(SB) |
|
|
| TEXT 路Xaddint32(SB), NOSPLIT, $0-20 |
| BR 路Xadd(SB) |
|
|
| TEXT 路Xaddint64(SB), NOSPLIT, $0-24 |
| BR 路Xadd64(SB) |
|
|
| // func Casp1(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool |
| // Atomically: |
| // if *ptr == old { |
| // *ptr = new |
| // return true |
| // } else { |
| // return false |
| // } |
| TEXT 路Casp1(SB), NOSPLIT, $0-25 |
| BR 路Cas64(SB) |
|
|
| // uint32 xadd(uint32 volatile *ptr, int32 delta) |
| // Atomically: |
| // *val += delta; |
| // return *val; |
| TEXT 路Xadd(SB), NOSPLIT, $0-20 |
| MOVD ptr+0(FP), R4 |
| MOVW delta+8(FP), R5 |
| LWSYNC |
| LWAR (R4), R3 |
| ADD R5, R3 |
| STWCCC R3, (R4) |
| BNE -3(PC) |
| MOVW R3, ret+16(FP) |
| RET |
|
|
| // uint64 Xadd64(uint64 volatile *val, int64 delta) |
| // Atomically: |
| // *val += delta; |
| // return *val; |
| TEXT 路Xadd64(SB), NOSPLIT, $0-24 |
| MOVD ptr+0(FP), R4 |
| MOVD delta+8(FP), R5 |
| LWSYNC |
| LDAR (R4), R3 |
| ADD R5, R3 |
| STDCCC R3, (R4) |
| BNE -3(PC) |
| MOVD R3, ret+16(FP) |
| RET |
|
|
| // uint8 Xchg(ptr *uint8, new uint8) |
| // Atomically: |
| // old := *ptr; |
| // *ptr = new; |
| // return old; |
| TEXT 路Xchg8(SB), NOSPLIT, $0-17 |
| MOVD ptr+0(FP), R4 |
| MOVB new+8(FP), R5 |
| LWSYNC |
| LBAR (R4), R3 |
| STBCCC R5, (R4) |
| BNE -2(PC) |
| ISYNC |
| MOVB R3, ret+16(FP) |
| RET |
|
|
| // uint32 Xchg(ptr *uint32, new uint32) |
| // Atomically: |
| // old := *ptr; |
| // *ptr = new; |
| // return old; |
| TEXT 路Xchg(SB), NOSPLIT, $0-20 |
| MOVD ptr+0(FP), R4 |
| MOVW new+8(FP), R5 |
| LWSYNC |
| LWAR (R4), R3 |
| STWCCC R5, (R4) |
| BNE -2(PC) |
| ISYNC |
| MOVW R3, ret+16(FP) |
| RET |
|
|
| // uint64 Xchg64(ptr *uint64, new uint64) |
| // Atomically: |
| // old := *ptr; |
| // *ptr = new; |
| // return old; |
| TEXT 路Xchg64(SB), NOSPLIT, $0-24 |
| MOVD ptr+0(FP), R4 |
| MOVD new+8(FP), R5 |
| LWSYNC |
| LDAR (R4), R3 |
| STDCCC R5, (R4) |
| BNE -2(PC) |
| ISYNC |
| MOVD R3, ret+16(FP) |
| RET |
|
|
| TEXT 路Xchgint32(SB), NOSPLIT, $0-20 |
| BR 路Xchg(SB) |
|
|
| TEXT 路Xchgint64(SB), NOSPLIT, $0-24 |
| BR 路Xchg64(SB) |
|
|
| TEXT 路Xchguintptr(SB), NOSPLIT, $0-24 |
| BR 路Xchg64(SB) |
|
|
| TEXT 路StorepNoWB(SB), NOSPLIT, $0-16 |
| BR 路Store64(SB) |
|
|
| TEXT 路Store(SB), NOSPLIT, $0-12 |
| MOVD ptr+0(FP), R3 |
| MOVW val+8(FP), R4 |
| SYNC |
| MOVW R4, 0(R3) |
| RET |
|
|
| TEXT 路Store8(SB), NOSPLIT, $0-9 |
| MOVD ptr+0(FP), R3 |
| MOVB val+8(FP), R4 |
| SYNC |
| MOVB R4, 0(R3) |
| RET |
|
|
| TEXT 路Store64(SB), NOSPLIT, $0-16 |
| MOVD ptr+0(FP), R3 |
| MOVD val+8(FP), R4 |
| SYNC |
| MOVD R4, 0(R3) |
| RET |
|
|
| TEXT 路StoreRel(SB), NOSPLIT, $0-12 |
| MOVD ptr+0(FP), R3 |
| MOVW val+8(FP), R4 |
| LWSYNC |
| MOVW R4, 0(R3) |
| RET |
|
|
| TEXT 路StoreRel64(SB), NOSPLIT, $0-16 |
| MOVD ptr+0(FP), R3 |
| MOVD val+8(FP), R4 |
| LWSYNC |
| MOVD R4, 0(R3) |
| RET |
|
|
| // void 路Or8(byte volatile*, byte); |
| TEXT 路Or8(SB), NOSPLIT, $0-9 |
| MOVD ptr+0(FP), R3 |
| MOVBZ val+8(FP), R4 |
| LWSYNC |
| again: |
| LBAR (R3), R6 |
| OR R4, R6 |
| STBCCC R6, (R3) |
| BNE again |
| RET |
|
|
| // void 路And8(byte volatile*, byte); |
| TEXT 路And8(SB), NOSPLIT, $0-9 |
| MOVD ptr+0(FP), R3 |
| MOVBZ val+8(FP), R4 |
| LWSYNC |
| again: |
| LBAR (R3), R6 |
| AND R4, R6 |
| STBCCC R6, (R3) |
| BNE again |
| RET |
|
|
| // func Or(addr *uint32, v uint32) |
| TEXT 路Or(SB), NOSPLIT, $0-12 |
| MOVD ptr+0(FP), R3 |
| MOVW val+8(FP), R4 |
| LWSYNC |
| again: |
| LWAR (R3), R6 |
| OR R4, R6 |
| STWCCC R6, (R3) |
| BNE again |
| RET |
|
|
| // func And(addr *uint32, v uint32) |
| TEXT 路And(SB), NOSPLIT, $0-12 |
| MOVD ptr+0(FP), R3 |
| MOVW val+8(FP), R4 |
| LWSYNC |
| again: |
| LWAR (R3),R6 |
| AND R4, R6 |
| STWCCC R6, (R3) |
| BNE again |
| RET |
|
|
| // func Or32(addr *uint32, v uint32) old uint32 |
| TEXT 路Or32(SB), NOSPLIT, $0-20 |
| MOVD ptr+0(FP), R3 |
| MOVW val+8(FP), R4 |
| LWSYNC |
| again: |
| LWAR (R3), R6 |
| OR R4, R6, R7 |
| STWCCC R7, (R3) |
| BNE again |
| MOVW R6, ret+16(FP) |
| RET |
|
|
| // func And32(addr *uint32, v uint32) old uint32 |
| TEXT 路And32(SB), NOSPLIT, $0-20 |
| MOVD ptr+0(FP), R3 |
| MOVW val+8(FP), R4 |
| LWSYNC |
| again: |
| LWAR (R3),R6 |
| AND R4, R6, R7 |
| STWCCC R7, (R3) |
| BNE again |
| MOVW R6, ret+16(FP) |
| RET |
|
|
| // func Or64(addr *uint64, v uint64) old uint64 |
| TEXT 路Or64(SB), NOSPLIT, $0-24 |
| MOVD ptr+0(FP), R3 |
| MOVD val+8(FP), R4 |
| LWSYNC |
| again: |
| LDAR (R3), R6 |
| OR R4, R6, R7 |
| STDCCC R7, (R3) |
| BNE again |
| MOVD R6, ret+16(FP) |
| RET |
|
|
| // func And64(addr *uint64, v uint64) old uint64 |
| TEXT 路And64(SB), NOSPLIT, $0-24 |
| MOVD ptr+0(FP), R3 |
| MOVD val+8(FP), R4 |
| LWSYNC |
| again: |
| LDAR (R3),R6 |
| AND R4, R6, R7 |
| STDCCC R7, (R3) |
| BNE again |
| MOVD R6, ret+16(FP) |
| RET |
|
|
| // func Anduintptr(addr *uintptr, v uintptr) old uintptr |
| TEXT 路Anduintptr(SB), NOSPLIT, $0-24 |
| JMP 路And64(SB) |
|
|
| // func Oruintptr(addr *uintptr, v uintptr) old uintptr |
| TEXT 路Oruintptr(SB), NOSPLIT, $0-24 |
| JMP 路Or64(SB) |
|
|
