! -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- ! ! ***** BEGIN LICENSE BLOCK ***** ! Version: MPL 1.1/GPL 2.0/LGPL 2.1 ! ! The contents of this file are subject to the Mozilla Public License Version ! 1.1 (the "License"); you may not use this file except in compliance with ! the License. You may obtain a copy of the License at ! http://www.mozilla.org/MPL/ ! ! Software distributed under the License is distributed on an "AS IS" basis, ! WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License ! for the specific language governing rights and limitations under the ! License. ! ! The Original Code is the Netscape Portable Runtime (NSPR). ! ! The Initial Developer of the Original Code is ! Netscape Communications Corporation. ! Portions created by the Initial Developer are Copyright (C) 1998-2000 ! the Initial Developer. All Rights Reserved. ! ! Contributor(s): ! ! Alternatively, the contents of this file may be used under the terms of ! either the GNU General Public License Version 2 or later (the "GPL"), or ! the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), ! in which case the provisions of the GPL or the LGPL are applicable instead ! of those above. If you wish to allow use of your version of this file only ! under the terms of either the GPL or the LGPL, and not to allow others to ! use your version of this file under the terms of the MPL, indicate your ! decision by deleting the provisions above and replace them with the notice ! and other provisions required by the GPL or the LGPL. If you do not delete ! the provisions above, a recipient may use your version of this file under ! the terms of any one of the MPL, the GPL or the LGPL. ! ! ***** END LICENSE BLOCK ***** ! ! atomic increment, decrement and swap routines for V8+ sparc (ultrasparc) ! using CAS (compare-and-swap) atomic instructions ! ! this MUST be compiled with an ultrasparc-aware assembler ! ! standard asm linkage macros; this module must be compiled ! with the -P option (use C preprocessor) #include ! ====================================================================== ! ! Perform the sequence a = a + 1 atomically with respect to other ! fetch-and-adds to location a in a wait-free fashion. ! ! usage : val = PR_AtomicIncrement(address) ! return: current value (you'd think this would be old val) ! ! ----------------------- ! Note on REGISTER USAGE: ! as this is a LEAF procedure, a new stack frame is not created; ! we use the caller's stack frame so what would normally be %i (input) ! registers are actually %o (output registers). Also, we must not ! overwrite the contents of %l (local) registers as they are not ! assumed to be volatile during calls. ! ! So, the registers used are: ! %o0 [input] - the address of the value to increment ! %o1 [local] - work register ! %o2 [local] - work register ! %o3 [local] - work register ! ----------------------- ENTRY(_MD_AtomicIncrement) ! standard assembler/ELF prologue retryAI: ld [%o0], %o2 ! set o2 to the current value add %o2, 0x1, %o3 ! calc the new value mov %o3, %o1 ! save the return value cas [%o0], %o2, %o3 ! atomically set if o0 hasn't changed cmp %o2, %o3 ! see if we set the value bne retryAI ! if not, try again nop ! empty out the branch pipeline retl ! return back to the caller mov %o1, %o0 ! set the return code to the new value SET_SIZE(_MD_AtomicIncrement) ! standard assembler/ELF epilogue ! ! end ! ! ====================================================================== ! ! ====================================================================== ! ! Perform the sequence a = a - 1 atomically with respect to other ! fetch-and-decs to location a in a wait-free fashion. ! ! usage : val = PR_AtomicDecrement(address) ! return: current value (you'd think this would be old val) ! ! ----------------------- ! Note on REGISTER USAGE: ! as this is a LEAF procedure, a new stack frame is not created; ! we use the caller's stack frame so what would normally be %i (input) ! registers are actually %o (output registers). Also, we must not ! overwrite the contents of %l (local) registers as they are not ! assumed to be volatile during calls. ! ! So, the registers used are: ! %o0 [input] - the address of the value to increment ! %o1 [local] - work register ! %o2 [local] - work register ! %o3 [local] - work register ! ----------------------- ENTRY(_MD_AtomicDecrement) ! standard assembler/ELF prologue retryAD: ld [%o0], %o2 ! set o2 to the current value sub %o2, 0x1, %o3 ! calc the new value mov %o3, %o1 ! save the return value cas [%o0], %o2, %o3 ! atomically set if o0 hasn't changed cmp %o2, %o3 ! see if we set the value bne retryAD ! if not, try again nop ! empty out the branch pipeline retl ! return back to the caller mov %o1, %o0 ! set the return code to the new value SET_SIZE(_MD_AtomicDecrement) ! standard assembler/ELF epilogue ! ! end ! ! ====================================================================== ! ! ====================================================================== ! ! Perform the sequence a = b atomically with respect to other ! fetch-and-stores to location a in a wait-free fashion. ! ! usage : old_val = PR_AtomicSet(address, newval) ! ! ----------------------- ! Note on REGISTER USAGE: ! as this is a LEAF procedure, a new stack frame is not created; ! we use the caller's stack frame so what would normally be %i (input) ! registers are actually %o (output registers). Also, we must not ! overwrite the contents of %l (local) registers as they are not ! assumed to be volatile during calls. ! ! So, the registers used are: ! %o0 [input] - the address of the value to increment ! %o1 [input] - the new value to set for [%o0] ! %o2 [local] - work register ! %o3 [local] - work register ! ----------------------- ENTRY(_MD_AtomicSet) ! standard assembler/ELF prologue retryAS: ld [%o0], %o2 ! set o2 to the current value mov %o1, %o3 ! set up the new value cas [%o0], %o2, %o3 ! atomically set if o0 hasn't changed cmp %o2, %o3 ! see if we set the value bne retryAS ! if not, try again nop ! empty out the branch pipeline retl ! return back to the caller mov %o3, %o0 ! set the return code to the prev value SET_SIZE(_MD_AtomicSet) ! standard assembler/ELF epilogue ! ! end ! ! ====================================================================== ! ! ====================================================================== ! ! Perform the sequence a = a + b atomically with respect to other ! fetch-and-adds to location a in a wait-free fashion. ! ! usage : newval = PR_AtomicAdd(address, val) ! return: the value after addition ! ENTRY(_MD_AtomicAdd) ! standard assembler/ELF prologue retryAA: ld [%o0], %o2 ! set o2 to the current value add %o2, %o1, %o3 ! calc the new value mov %o3, %o4 ! save the return value cas [%o0], %o2, %o3 ! atomically set if o0 hasn't changed cmp %o2, %o3 ! see if we set the value bne retryAA ! if not, try again nop ! empty out the branch pipeline retl ! return back to the caller mov %o4, %o0 ! set the return code to the new value SET_SIZE(_MD_AtomicAdd) ! standard assembler/ELF epilogue ! ! end !