# Copyright 2005 Chris Thomasson




.align 16
# int refcount_ia32_init(
#   refcount_ia32_t*, 
#   int, 
#   refcount_ia32_fpdtor_t, 
#   void*)
.globl refcount_ia32_init
refcount_ia32_init:
  MOVL 4(%ESP), %ECX
  MOVL 8(%ESP), %EAX  
  CMPL $0, %EAX
  JLE refcount_ia32_init_failed
  MOVL 12(%ESP), %EDX
  MOVL %EAX, (%ECX)
  MOVL %EDX, 4(%ECX)
  MOVL 16(%ESP), %EDX
  MOVL %EDX, 8(%ECX)
  MOVL $1, %EAX
  RETL
  
refcount_ia32_init_failed:
  XORL %EAX, %EAX
RETL




.align 16
# void* refcount_ia32_state_load_depends(
#   refcount_ia32_t volatile*)
.globl refcount_ia32_state_load_depends
refcount_ia32_state_load_depends:
  MOVL 4(%ESP), %EAX  
  TESTL %EAX, %EAX
  JE refcount_ia32_state_load_depends_failed
  MOVL 8(%EAX), %EAX
  
refcount_ia32_state_load_depends_failed:
RETL




.align 16
# refcount_ia32_t* refcount_ia32_add_load_strong(
#   refcount_ia32_t* volatile*, 
#   int,
#   spinlock_ia32_table_t const*,
#   size_t)
.globl refcount_ia32_add_load_strong
refcount_ia32_add_load_strong:
  PUSHL %ESI
  PUSHL %EBX
  MOVL 12(%ESP), %ECX
  MOVL 20(%ESP), %EDX
  MOVL 16(%ESP), %ESI
  CMPL $0, %ESI
  JLE refcount_ia32_add_load_strong_failed

refcount_ia32_add_load_strong_retry:
  MOVL (%ECX), %EAX
  TESTL %EAX, %EAX
  JE refcount_ia32_add_load_strong_failed
  MOVL %EAX, %EBX
  IMUL $567, %EBX
  SHRL $8, %EBX
  ANDL $0xFF, %EBX
  IMUL 24(%ESP), %EBX
  LEAL (%EBX, %EDX), %EBX

refcount_ia32_add_load_strong_lock_retry:
  MOVL $1, %ESI
  XCHGL %ESI, (%EBX)
  TESTL %ESI, %ESI
  JNE refcount_ia32_add_load_strong_lock_pause_retry
  MOVL (%ECX), %ESI
  CMPL %ESI, %EAX
  JNE refcount_ia32_add_load_strong_unlock_retry 
  MOVL 16(%ESP), %ESI
  LOCK XADDL %ESI, (%EAX)
  CMPL $0, %ESI
  JLE refcount_ia32_add_load_strong_unlock_retry
  XORL %ESI, %ESI
  MOVL %ESI, (%EBX)
  POPL %EBX
  POPL %ESI
  RETL
  
refcount_ia32_add_load_strong_failed:
  XORL %EAX, %EAX  
  POPL %EBX
  POPL %ESI  
  RETL

refcount_ia32_add_load_strong_lock_pause_retry:
  PAUSE
  JMP refcount_ia32_add_load_strong_lock_retry

refcount_ia32_add_load_strong_unlock_retry:
  XORL %ESI, %ESI
  MOVL %ESI, (%EBX)
JMP refcount_ia32_add_load_strong_retry




.align 16
# int refcount_ia32_sub_strong(
#   refcount_ia32_t volatile*, 
#   int, 
#   spinlock_ia32_table_t const*, 
#   size_t)
.globl refcount_ia32_sub_strong
refcount_ia32_sub_strong:
  MOVL 4(%ESP), %EAX
  TESTL %EAX, %EAX
  JE refcount_ia32_sub_strong_skip
  MOVL 8(%ESP), %EDX
  CMPL $0, %EDX
  JLE refcount_ia32_sub_strong_skip 
  NEGL %EDX
  LOCK XADDL %EDX, (%EAX)
  JZ refcount_ia32_sub_strong_destroy
  JS refcount_ia32_sub_strong_destroy
  
refcount_ia32_sub_strong_skip:
  XORL %EAX, %EAX
  RETL

refcount_ia32_sub_strong_destroy:
  MOVL 12(%ESP), %EDX
  MOVL %EAX, %ECX
  IMUL $567, %ECX
  SHRL $8, %ECX
  ANDL $0xFF, %ECX
  IMUL 16(%ESP), %ECX
  LEAL (%ECX, %EDX), %ECX

refcount_ia32_sub_strong_lock_retry:
  MOVL $1, %EDX
  XCHGL %EDX, (%ECX)
  TESTL %EDX, %EDX
  JNE refcount_ia32_sub_strong_lock_pause_retry
  
  MOVL 4(%EAX), %EDX
  PUSHL 8(%EAX)
  XORL %EAX, %EAX
  MOVL %EAX, (%ECX)
  TESTL %EDX, %EDX
  JE refcount_ia32_sub_strong_done
  CALL *%EDX

refcount_ia32_sub_strong_done:
  POPL %EDX
  MOVL $1, %EAX
  RETL

refcount_ia32_sub_strong_lock_pause_retry:
  PAUSE
JMP refcount_ia32_sub_strong_lock_retry




.align 16
# void refcount_ia32_add_weak(
#   refcount_ia32_t volatile*, 
#   int)
.globl refcount_ia32_add_weak
refcount_ia32_add_weak:
  MOVL 4(%ESP), %ECX
  MOVL 8(%ESP), %EAX
  CMPL $0, %EAX
  JLE refcount_ia32_add_weak_done 
  LOCK XADDL %EAX, (%ECX)

refcount_ia32_add_weak_done:
RETL




.align 16
# refcount_ia32_t* refcount_ia32_add_swap_weak(
#   refcount_ia32_t* volatile*, 
#   refcount_ia32_t*, 
#   int)
.globl refcount_ia32_add_swap_weak
refcount_ia32_add_swap_weak:
  MOVL 4(%ESP), %ECX
  MOVL 8(%ESP), %EAX
  TESTL %EAX, %EAX
  JE refcount_swap_weak_execute
  MOVL 12(%ESP), %EDX
  CMPL $0, %EDX
  JLE refcount_swap_weak_execute
  LOCK XADDL %EDX, (%EAX)

refcount_swap_weak_execute:
  XCHGL %EAX, (%ECX)
RETL