We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

[patch] initial SDL_atomic patch

SDL_atomic.patch (text/plain), 32.29 KB, created by bile on 2009-07-14 08:46:20 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: bile

Created: 2009-07-14 08:46:20 UTC

Size: 32.29 KB

patch

obsolete

>Index: test/Makefile.in
>===================================================================
>--- test/Makefile.in	(revision 2936)
>+++ test/Makefile.in	(working copy)
>@@ -7,7 +7,7 @@
> CFLAGS  = @CFLAGS@
> LIBS	= @LIBS@
> 
>-TARGETS = checkkeys$(EXE) graywin$(EXE) loopwave$(EXE) testaudioinfo$(EXE) testmultiaudio$(EXE) testalpha$(EXE) testbitmap$(EXE) testblitspeed$(EXE) testcdrom$(EXE) testcursor$(EXE) testdyngl$(EXE) testerror$(EXE) testfile$(EXE) testgamma$(EXE) testgl$(EXE) testgl2$(EXE) testhread$(EXE) testiconv$(EXE) testjoystick$(EXE) testkeys$(EXE) testlock$(EXE) testoverlay2$(EXE) testoverlay$(EXE) testpalette$(EXE) testplatform$(EXE) testsem$(EXE) testsprite$(EXE) testsprite2$(EXE) testtimer$(EXE) testver$(EXE) testvidinfo$(EXE) testwin$(EXE) testwm$(EXE) testwm2$(EXE) threadwin$(EXE) torturethread$(EXE) testloadso$(EXE)
>+TARGETS = checkkeys$(EXE) graywin$(EXE) loopwave$(EXE) testaudioinfo$(EXE) testmultiaudio$(EXE) testalpha$(EXE) testbitmap$(EXE) testblitspeed$(EXE) testcdrom$(EXE) testcursor$(EXE) testdyngl$(EXE) testerror$(EXE) testfile$(EXE) testgamma$(EXE) testgl$(EXE) testgl2$(EXE) testhread$(EXE) testiconv$(EXE) testjoystick$(EXE) testkeys$(EXE) testlock$(EXE) testoverlay2$(EXE) testoverlay$(EXE) testpalette$(EXE) testplatform$(EXE) testsem$(EXE) testsprite$(EXE) testsprite2$(EXE) testtimer$(EXE) testver$(EXE) testvidinfo$(EXE) testwin$(EXE) testwm$(EXE) testwm2$(EXE) threadwin$(EXE) torturethread$(EXE) testloadso$(EXE) testatomic$(EXE)
> 
> all: Makefile $(TARGETS)
> 
>@@ -125,6 +125,8 @@
> testloadso$(EXE): $(srcdir)/testloadso.c
> 	$(CC) -o $@ $? $(CFLAGS) $(LIBS)
> 
>+testatomic$(EXE): $(srcdir)/testatomic.c
>+	$(CC) -o $@ $? $(CFLAGS) $(LIBS)
> 
> clean:
> 	rm -f $(TARGETS)
>Index: test/testatomic.c
>===================================================================
>--- test/testatomic.c	(revision 0)
>+++ test/testatomic.c	(revision 0)
>@@ -0,0 +1,64 @@
>+#include "SDL.h"
>+
>+int
>+main(int argc, char** argv)
>+{
>+  int rv = 10;
>+  volatile int atomic;
>+
>+  SDL_atomic_int_set(&atomic, 10);
>+  if(SDL_atomic_int_get(&atomic) != 10)
>+    printf("Error: ");
>+  printf("SDL_atomic_int_set(atomic, 10): atomic-> %d\n",
>+         SDL_atomic_int_get(&atomic));
>+    
>+  SDL_atomic_int_add(&atomic, 10);
>+  if(SDL_atomic_int_get(&atomic) != 20)
>+    printf("Error: ");
>+  printf("SDL_atomic_int_add(atomic, 10): atomic-> %d\n",
>+         SDL_atomic_int_get(&atomic));
>+  
>+  rv = SDL_atomic_int_cmp_xchg(&atomic, 20, 30);
>+  if(rv != SDL_TRUE || SDL_atomic_int_get(&atomic) != 30)
>+    printf("Error: ");
>+  printf("SDL_atomic_int_cmp_xchg(atomic, 20, 30): rv-> %d, atomic-> %d\n",
>+         rv, SDL_atomic_int_get(&atomic));
>+  
>+  rv = SDL_atomic_int_cmp_xchg(&atomic, 20, 30);
>+  if(rv != SDL_FALSE || SDL_atomic_int_get(&atomic) != 30)
>+    printf("Error: ");
>+  printf("SDL_atomic_int_cmp_xchg(atomic, 20, 40): rv-> %d, atomic-> %d\n",
>+         rv, SDL_atomic_int_get(&atomic));
>+  
>+  rv = SDL_atomic_int_xchg_add(&atomic, 10);
>+  if(rv != 30 || SDL_atomic_int_get(&atomic) != 40)
>+    printf("Error: ");
>+  printf("SDL_atomic_int_xchg_add(atomic, 10): rv-> %d, atomic-> %d\n",
>+         rv, SDL_atomic_int_get(&atomic));
>+
>+  SDL_atomic_int_inc(&atomic);
>+  if(SDL_atomic_int_get(&atomic) != 41)
>+    printf("Error: ");
>+  printf("SDL_atomic_int_inc(atomic): atomic-> %d\n",
>+         SDL_atomic_int_get(&atomic));
>+
>+  rv = SDL_atomic_int_dec_test(&atomic);
>+  if(rv != SDL_FALSE || SDL_atomic_int_get(&atomic) != 40)
>+    printf("Error: ");
>+  printf("SDL_atomic_int_dec_test(atomic): rv-> %d, atomic-> %d\n",
>+         rv, SDL_atomic_int_get(&atomic));
>+  
>+  SDL_atomic_int_set(&atomic, 1);
>+  if(SDL_atomic_int_get(&atomic) != 1)
>+    printf("Error: ");    
>+    printf("SDL_atomic_int_set(atomic, 1): atomic-> %d\n",
>+           SDL_atomic_int_get(&atomic));
>+
>+  rv = SDL_atomic_int_dec_test(&atomic);
>+  if(rv != SDL_TRUE || SDL_atomic_int_get(&atomic) != 0)
>+    printf("Error: ");
>+  printf("SDL_atomic_int_dec_test(atomic): rv-> %d, atomic-> %d\n",
>+         rv, SDL_atomic_int_get(&atomic));
>+  
>+  return 0;
>+}
>Index: include/SDL_config_dreamcast.h
>===================================================================
>--- include/SDL_config_dreamcast.h	(revision 2936)
>+++ include/SDL_config_dreamcast.h	(working copy)
>@@ -36,6 +36,7 @@
> typedef signed long long int64_t;
> typedef unsigned long long uint64_t;
> typedef unsigned long uintptr_t;
>+#define SIZEOF_VOIDP 4
> #define SDL_HAS_64BIT_TYPE	1
> 
> /* Useful headers */
>Index: include/SDL_config.h.in
>===================================================================
>--- include/SDL_config.h.in	(revision 2936)
>+++ include/SDL_config.h.in	(working copy)
>@@ -44,6 +44,7 @@
> #undef int64_t
> #undef uint64_t
> #undef uintptr_t
>+#undef SIZEOF_VOIDP
> #undef SDL_HAS_64BIT_TYPE
> 
> /* Endianness */
>Index: include/SDL_atomic.h
>===================================================================
>--- include/SDL_atomic.h	(revision 0)
>+++ include/SDL_atomic.h	(revision 0)
>@@ -0,0 +1,674 @@
>+/*
>+    SDL - Simple DirectMedia Layer
>+    Copyright (C) 1997-2006 Sam Lantinga
>+
>+    This library is free software; you can redistribute it and/or
>+    modify it under the terms of the GNU Lesser General Public
>+    License as published by the Free Software Foundation; either
>+    version 2.1 of the License, or (at your option) any later version.
>+
>+    This library is distributed in the hope that it will be useful,
>+    but WITHOUT ANY WARRANTY; without even the implied warranty of
>+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+    Lesser General Public License for more details.
>+
>+    You should have received a copy of the GNU Lesser General Public
>+    License along with this library; if not, write to the Free Software
>+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
>+
>+    Sam Lantinga
>+    slouken@libsdl.org
>+ */
>+
>+/**
>+ * \file SDL_atomic.h
>+ *
>+ * Atomic int and pointer magic
>+ */
>+
>+#ifndef _SDL_atomic_h_
>+#define _SDL_atomic_h_
>+
>+
>+#include "SDL_stdinc.h"
>+#include "SDL_platform.h"
>+
>+#include "begin_code.h"
>+
>+/* Set up for C function definitions, even when using C++ */
>+#ifdef __cplusplus
>+/* *INDENT-OFF* */
>+extern "C" {
>+/* *INDENT-ON* */
>+#endif
>+
>+#if defined(__GNUC__) && (defined(i386) || defined(__i386__)  || defined(__x86_64__))
>+static __inline__ void
>+SDL_atomic_int_add(volatile int* atomic, int value)
>+{
>+  __asm__ __volatile__("lock;"
>+                       "addl %1, %0"
>+                       : "=m" (*atomic)
>+                       : "ir" (value),
>+                         "m" (*atomic));
>+}
>+
>+static __inline__ int
>+SDL_atomic_int_xchg_add(volatile int* atomic, int value)
>+{                                              
>+  int rv;                                    
>+  __asm__ __volatile__("lock;"               
>+                       "xaddl %0, %1"        
>+                       : "=r" (rv),          
>+                         "=m" (*atomic)    
>+                       : "0" (value),        
>+                         "m" (*atomic));   
>+  return rv;                                        
>+}
>+
>+static __inline__ SDL_bool
>+SDL_atomic_int_cmp_xchg(volatile int* atomic, int oldvalue, int newvalue)
>+{
>+  int rv;                                                      
>+  __asm__ __volatile__("lock;"                               
>+                       "cmpxchgl %2, %1"                     
>+                       : "=a" (rv),                          
>+                         "=m" (*atomic)             
>+                       : "r" (newvalue),                     
>+                         "m" (*atomic),                    
>+                         "0" (oldvalue));
>+  return (rv == oldvalue);                                          
>+}
>+
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  void* rv;
>+  __asm__ __volatile__("lock;"
>+# if defined(__x86_64__)                       
>+                       "cmpxchgq %q2, %1"
>+# else
>+                       "cmpxchgl %2, %1"
>+# endif                       
>+                       : "=a" (rv),
>+                         "=m" (*atomic)
>+                       : "r" (newvalue),
>+                         "m" (*atomic),
>+                         "0" (oldvalue));
>+  return (rv == oldvalue);
>+}
>+#elif defined(__GNUC__) && defined(__alpha__)
>+# define ATOMIC_MEMORY_BARRIER (__asm__ __volatile__ ("mb" : : : "memory"))
>+# define ATOMIC_INT_CMP_XCHG(atomic,value)              \
>+  ({                                                    \
>+    int rv,prev;                                        \
>+    __asm__ __volatile__("   mb\n"                      \
>+                         "1: ldl_l   %0,%2\n"           \
>+                         "   cmpeq   %0,%3,%1\n"        \
>+                         "   beq     %1,2f\n"           \
>+                         "   mov     %4,%1\n"           \
>+                         "   stl_c   %1,%2\n"           \
>+                         "   beq     %1,1b\n"           \
>+                         "   mb\n"                      \
>+                         "2:"                           \
>+                         : "=&r" (prev),                \
>+                           "=&r" (rv)                   \
>+                         : "m" (*(atomic)),             \
>+                           "Ir" (oldvalue),             \
>+                           "Ir" (newvalue)              \
>+                         : "memory");                   \
>+    (rv != 0);                                          \
>+  })
>+
>+# if (SIZEOF_VOIDP == 4)
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  int rv;
>+  void* prev;
>+  __asm__ __volatile__("   mb\n"
>+                       "1: ldl_l %0,%2\n"
>+                       "   cmpeq %0,%3,%1\n"
>+                       "   beq   $1,2f\n"
>+                       "   mov   %4,%1\n"
>+                       "   stl_c %1,%2\n"
>+                       "   beq   %1,1b\n"
>+                       "   mb\n"
>+                       "2:"
>+                       : "=&r" (prev),
>+                         "=&r" (rv)
>+                       : "m" (*atomic),
>+                         "Ir" (oldvalue),
>+                         "Ir" (newvalue)
>+                       : "memory");
>+  return (rv != 0);
>+}
>+# elif (SIZEOF_VOIDP == 8)
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  int rv;
>+  void* prev;
>+  __asm__ __volatile__("   mb\n"
>+                       "1: ldq_l %0,%2\n"
>+                       "   cmpeq %0,%3,%1\n"
>+                       "   beq   %1,2f\n"
>+                       "   mov   %4,%1\n"
>+                       "   stq_c %1,%2\n"
>+                       "   beq   %1,1b\n"
>+                       "   mb\n"
>+                       "2:"
>+                       : "=&r" (prev),
>+                         "=&r" (rv)
>+                       : "m" (*atomic),
>+                         "Ir" (oldvalue),
>+                         "Ir" (newvalue)
>+                       : "memory");
>+  return (rv != 0);
>+}
>+# else
>+#  error "Your system has an unsupported pointer size"  
>+# endif  /* SIZEOF_VOIDP */
>+#elif defined(__GNUC__) && defined(__sparc__)
>+# define ATOMIC_MEMORY_BARRIER                                          \
>+  (__asm__ __volatile__("membar #LoadLoad | #LoadStore"                 \
>+                        " | #StoreLoad | #StoreStore" : : : "memory"))
>+# define ATOMIC_INT_CMP_XCHG(atomic,oldvalue,newvalue)                  \
>+  ({                                                                    \
>+    int rv;                                                             \
>+    __asm__ __volatile__("cas [%4], %2, %0"                             \
>+                         : "=r" (rv), "=m" (*(atomic))                  \
>+                         : "r" (oldvalue), "m" (*(atomic)),             \
>+                         "r" (atomic), "0" (newvalue));                 \
>+    rv == oldvalue;                                                     \
>+  })
>+
>+# if (SIZEOF_VOIDP == 4)
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  void* rv;
>+  __asm__ __volatile__("cas [%4], %2, %0"
>+                       : "=r" (rv),
>+                         "=m" (*atomic)
>+                       : "r" (oldvalue),
>+                         "m" (*atomic),
>+                         "r" (atomic),
>+                         "0" (newvalue));
>+  return (rv == oldvalue);
>+}
>+# elif (SIZEOF_VOIDP == 8)
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  void* rv;
>+  void** a = atomic;
>+  __asm__ __volatile__("casx [%4], %2, %0"
>+                       : "=r" (rv),
>+                         "=m" (*a)
>+                       : "r" (oldvalue),
>+                         "m" (*a),
>+                         "r" (a),
>+                         "0" (newvalue));
>+  return (rv == oldvalue);
>+}
>+# else
>+#  error "Your system has an unsupported pointer size"
>+# endif /* SIZEOF_VOIDP */
>+#elif defined(__GNUC__) && (defined(__POWERPC__) || defined(__powerpc__) || defined(__ppc__) || defined(_M_PPC))
>+# define ATOMIC_MEMORY_BARRIER \
>+  (__asm__ __volatile__ ("sync" : : : "memory"))
>+static __inline__ void
>+SDL_atomic_int_add(volatile int* atomic, int value)
>+{                                           
>+  int rv,tmp;                                   
>+  __asm__ __volatile__("1: lwarx   %0,  0, %3\n" 
>+                       "   add     %1, %0, %4\n"
>+                       "   stwcx.  %1,  0, %3\n" 
>+                       "   bne-    1b"          
>+                       : "=&b" (rv),            
>+                         "=&r" (tmp),           
>+                         "=m" (*atomic)       
>+                       : "b" (atomic),          
>+                         "r" (value),           
>+                         "m" (*atomic)        
>+                       : "cr0",                 
>+                         "memory");             
>+}
>+
>+static __inline__ int
>+SDL_atomic_int_xchg_add(volatile int* atomic, int value)
>+{                                          
>+  int rv,tmp;                               
>+  __asm__ __volatile__("1: lwarx  %0, 0, %3\n"        
>+                       "   add    %1, %0, %4\n"       
>+                       "   stwcx. %1, 0, %3\n"        
>+                       "   bne-   1b"                 
>+                       : "=&b" (rv),                  
>+                         "=&r" (tmp),                 
>+                         "=m" (*atomic)
>+                       : "b" (atomic),                
>+                         "r" (value),                 
>+                         "m" (*atomic)
>+                       : "cr0",                       
>+                       "memory");                   
>+  return rv;                                                 
>+}
>+
>+# if (SIZEOF_VOIDP == 4)
>+static __inline__ SDL_bool
>+SDL_atomic_int_cmp_xchg(volatile int* atomic, int oldvalue, int newvalue)
>+{                                                        
>+  int rv;                                                 
>+  __asm__ __volatile__("   sync\n"                         
>+                       "1: lwarx   %0, 0, %1\n"           
>+                       "   subf.   %0, %2, %0\n"          
>+                       "   bne     2f\n"                  
>+                       "   stwcx.  %3, 0, %1\n"           
>+                       "   bne-    1b\n"                  
>+                       "2: isync"                         
>+                       : "=&r" (rv)                       
>+                       : "b" (atomic),                    
>+                         "r" (oldvalue),                  
>+                         "r"                              
>+                       : "cr0",                           
>+                         "memory");                         
>+  return (rv == 0);                                              
>+}
>+
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  void* rv;
>+  __asm__ __volatile__("sync\n"
>+                       "1: lwarx  %0,  0, %1\n"
>+                       "   subf.  %0, %2, %0\n"
>+                       "   bne    2f\n"
>+                       "   stwcx. %3,  0, %1\n"
>+                       "   bne-   1b\n"
>+                       "2: isync"
>+                       : "=&r" (rv)
>+                       : "b" (atomic),
>+                         "r" (oldvalue),
>+                         "r" (newvalue)
>+                       : "cr0",
>+                       "memory");
>+  return (rv == 0);
>+}
>+# elif (SIZEOF_VOIDP == 8)
>+static __inline__ SDL_bool
>+SDL_atomic_int_cmp_xchg(volatile int* atomic, int oldvalue, int newvalue)
>+{                                                        
>+  int rv;                                                 
>+  __asm__ __volatile__("   sync\n"                         
>+                       "1: lwarx   %0,  0, %1\n"
>+                       "   extsw   %0, %0\n"
>+                       "   subf.   %0, %2, %0\n"          
>+                       "   bne     2f\n"                  
>+                       "   stwcx.  %3,  0, %1\n"           
>+                       "   bne-    1b\n"                  
>+                       "2: isync"                         
>+                       : "=&r" (rv)                       
>+                       : "b" (atomic),                    
>+                         "r" (oldvalue),                  
>+                         "r"                              
>+                       : "cr0",                           
>+                         "memory");                         
>+  return (rv == 0);                                              
>+}
>+
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  void* rv;
>+  __asm__ __volatile__("sync\n"
>+                       "1: ldarx  %0,  0, %1\n"
>+                       "   subf.  %0, %2, %0\n"
>+                       "   bne    2f\n"
>+                       "   stdcx. %3,  0, %1\n"
>+                       "   bne-   1b\n"
>+                       "2: isync"
>+                       : "=&r" (rv)
>+                       : "b" (atomic),
>+                         "r" (oldvalue),
>+                         "r" (newvalue)
>+                       : "cr0",
>+                       "memory");
>+  return (rv == 0);
>+}
>+# else
>+#  error "Your system has an unsupported pointer size"
>+# endif /* SIZEOF_VOIDP */
>+#elif defined(__GNUC__) && (defined(__IA64__) || defined(__ia64__))
>+# define ATOMIC_MEMORY_BARRIER (__sync_synchronize())
>+# define SDL_atomic_int_xchg_add(atomic, value)     \
>+  (__sync_fetch_and_add((atomic),(value)))
>+# define SDL_atomic_int_add(atomic, value)                  \
>+  ((void)__sync_fetch_and_add((atomic),(value)))
>+# define SDL_atomic_int_cmp_xchg(atomic,oldvalue,newvalue)  \
>+  (__sync_bool_compare_and_swap((atomic),(oldvalue),(newvalue)))
>+# define SDL_atomic_ptr_cmp_xchg(atomic,oldvalue,newvalue)              \
>+  (__sync_bool_compare_and_swap((long*)(atomic),(long)(oldvalue),(long)(newvalue)))
>+#elif defined(__GNUC__) && defined(__LINUX__) && (defined(__mips__) || defined(__MIPS__))
>+static __inline__ int
>+SDL_atomic_int_xchg_add(volatile int* atomic, int value)
>+{                                            
>+  int rv,tmp;                                 
>+  __asm__ __volatile__("1:              \n"                 
>+                       ".set  push      \n"         
>+                       ".set  mips2     \n"        
>+                       "ll    %0,%3     \n"        
>+                       "addu  %1,%4,%0  \n"     
>+                       "sc    %1,%2     \n"        
>+                       ".set  pop       \n"          
>+                       "beqz  %1,1b     \n"        
>+                       : "=&r" (rv),          
>+                         "=&r" (tmp),         
>+                         "=m" (*atomic)     
>+                       : "m" (*atomic),     
>+                         "r" (value)          
>+                       : "memory");           
>+  return rv;                                         
>+}
>+
>+static __inline__ void
>+SDL_atomic_int_add(volatile int* atomic, int value)
>+{                                           
>+  int rv;                                    
>+  __asm__ __volatile__("1:               \n"                
>+                       ".set  push       \n"        
>+                       ".set  mips2      \n"       
>+                       "ll    %0,%2      \n"       
>+                       "addu  %0,%3,%0   \n"    
>+                       "sc    %0,%1      \n"       
>+                       ".set  pop        \n"         
>+                       "beqz  %0,1b      \n"       
>+                       : "=&r" (rv),         
>+                         "=m" (*atomic)    
>+                       : "m" (*atomic),    
>+                         "r" (value)         
>+                       : "memory");          
>+}
>+
>+static __inline__ SDL_bool
>+SDL_atomic_int_cmp_xchg(volatile int* atomic, int oldvalue, int newvalue)
>+{
>+  int rv;
>+  __asm__ __volatile__("     .set push        \n"
>+                       "     .set noat        \n"
>+                       "     .set mips3       \n"
>+                       "1:   ll   %0, %2      \n"
>+                       "     bne  %0, %z3, 2f \n"
>+                       "     .set mips0       \n"
>+                       "     move $1, %z4     \n"
>+                       "     .set mips3       \n"
>+                       "     sc   $1, %1      \n"
>+                       "     beqz $1, 1b      \n"
>+                       "     sync             \n"
>+                       "2:                    \n"
>+                       "     .set pop         \n"
>+                       : "=&r" (rv),
>+                         "=R" (*atomic)
>+                       : "R" (*atomic),
>+                         "Jr" (oldvalue),
>+                         "Jr" (newvalue)
>+                       : "memory");
>+  return (SDL_bool)rv;                  
>+}
>+
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{                                                     
>+  int rv;
>+  __asm__ __volatile__("     .set push        \n"
>+                       "     .set noat        \n"
>+                       "     .set mips3       \n"
>+# if defined(__mips64)
>+                       "1:   lld  %0, %2      \n"
>+# else
>+                       "1:   ll   %0, %2      \n"
>+# endif                       
>+                       "     bne  %0, %z3, 2f \n"
>+                       "     move $1, %z4     \n"
>+# if defined(__mips64)
>+                       "     sc   $1, %1      \n"
>+# else
>+                       "     scd  $1, %1      \n"
>+# endif                       
>+                       "     beqz $1, 1b      \n"
>+                       "     sync             \n"
>+                       "2:                    \n"
>+                       "     .set pop         \n"
>+                       : "=&r" (rv),
>+                         "=R" (*atomic)
>+                       : "R" (*atomic),
>+                         "Jr" (oldvalue),
>+                         "Jr" (newvalue)
>+                       : "memory");
>+  return (SDL_bool)rv;                                                  
>+}
>+#elif defined(__GNUC__) && defined(__m68k__)
>+static __inline__ int
>+SDL_atomic_int_xchg_add(volatile int* atomic, int value)
>+{                                          
>+  int rv = *atomic;
>+  int tmp;
>+  __asm__ __volatile__("1: move%.l %0,%1    \n"
>+                       "   add%.l  %2,%1    \n"
>+                       "   cas%.l  %0,%1,%3 \n"
>+                       "   jbne    1b       \n"
>+                       : "=d" (rv),
>+                         "=&d" (tmp)
>+                       : "d" (value),
>+                         "m" (*atomic),
>+                         "0" (rv)
>+                       : "memory");
>+  return rv;
>+}
>+
>+static __inline__ void
>+SDL_atomic_int_add(volatile int* atomic, int value)
>+{                                           
>+  __asm__ __volatile__("add%.l %0,%1"        
>+                       :                     
>+                       : "id" (value),       
>+                         "m" (*atomic)
>+                       : "memory");          
>+}
>+
>+static __inline__ SDL_bool
>+SDL_atomic_int_cmp_xchg(volatile int* atomic, int oldvalue, int newvalue)
>+{                                           
>+  char rv;                                   
>+  int readvalue;                             
>+  __asm__ __volatile__("cas%.l %2,%3,%1\n"   
>+                       "seq    %0"           
>+                       : "=dm" (rv),         
>+                         "=m" (*atomic),   
>+                         "=d" (readvalue)    
>+                       : "d" (newvalue),     
>+                         "m" (*atomic),    
>+                         "2" (oldvalue));    
>+    return rv;                                        
>+}
>+
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  char rv;                                   
>+  int readvalue;                             
>+  __asm__ __volatile__("cas%.l %2,%3,%1\n"   
>+                       "seq    %0"           
>+                       : "=dm" (rv),         
>+                         "=m" (*atomic),   
>+                         "=d" (readvalue)    
>+                       : "d" (newvalue),     
>+                         "m" (*atomic),    
>+                         "2" (oldvalue));    
>+    return rv;                                        
>+}
>+#elif defined(__GNUC__) && defined(__s390__)
>+# define ATOMIC_INT_CMP_XCHG(atomic,oldvalue,newvalue)  \
>+  ({                                                    \
>+    int rv = oldvalue;                                  \
>+    __asm__ __volatile__("cs %0, %2, %1"                \
>+                         : "+d" (rv),                   \
>+                           "=Q" (*(atomic))             \
>+                         : "d" (newvalue),              \
>+                           "m" (*(atomic))              \
>+                         : "cc");                       \
>+    rv == oldvalue;                                     \
>+  })
>+# if (SIZEOF_VOIDP == 4)
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  void* rv = oldvalue;
>+  __asm__ __volatile__("cs %0, %2, %1"
>+                       : "+d" (rv),
>+                         "=Q" (*atomic)
>+                       : "d" (newvalue),
>+                         "m" (*atomic)
>+                       : "cc");
>+  return (rv == oldvalue);
>+}
>+# elif (SIZEOF_VOIDP == 8)
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  void* rv = oldvalue;
>+  void** a = atomic;
>+  __asm__ __volatile__("csg %0, %2, %1"
>+                       : "+d" (rv),
>+                         "=Q" (*a)
>+                       : "d" ((long)(newvalue)),
>+                         "m" (*a)
>+                       : "cc");
>+  return (rv == oldvalue);
>+}
>+# else
>+#  error "Your system has an unsupported pointer size"
>+# endif /* SIZEOF_VOIDP */
>+#elif defined(__WIN32__)
>+# include <windows.h>
>+static __inline__ int
>+SDL_atomic_int_xchg_add(volatile int* atomic, int value)
>+{
>+  return InterlockedExchangeAdd(atomic, value);
>+}
>+
>+static __inline__ void
>+SDL_atomic_int_add(volatile int* atomic, int value)
>+{
>+  InterlockedExchangeAdd(atomic, value);
>+}
>+
>+# if (WINVER > 0X0400)
>+static __inline__ SDL_bool
>+SDL_atmoic_int_cmp_xchg(volatile int* atomic, int oldvalue, int newvalue)
>+{
>+  return ((SDL_bool)InterlockedCompareExchangePointer((PVOID*)atomic,
>+                                                      (PVOID)newvalue,
>+                                                      (PVOID)oldvalue) == oldvalue);
>+}
>+
>+
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  return (InterlockedCompareExchangePointer(atomic, newvalue, oldvalue) == oldvalue);
>+}
>+# else /* WINVER <= 0x0400 */
>+#  if (SIZEOF_VOIDP != 4)
>+#   error "InterlockedCompareExchangePointer needed"
>+#  endif
>+
>+static __inline__ SDL_bool
>+SDL_atomic_int_cmp_xchg(volatile int* atomic, int oldvalue, int newvalue)
>+{
>+  return (InterlockedCompareExchange(atomic, newvalue, oldvalue) == oldvalue);
>+}
>+
>+static __inline__ SDL_bool
>+SDL_atomic_ptr_cmp_xchg(volatile void** atomic, void* oldvalue, void* newvalue)
>+{
>+  return (InterlockedCompareExchange(atomic, newvalue, oldvalue) == oldvalue);
>+}
>+# endif
>+#else /* when all else fails */
>+# define SDL_ATOMIC_OPS_NOT_SUPPORTED
>+# warning "Atomic Ops for this platform not supported!"
>+static __inline__ int
>+SDL_atomic_int_xchg_add(volatile int* atomic, int value)
>+{                                           
>+  int rv = *atomic;                          
>+  *(atomic) += value;                        
>+  return rv;                                        
>+}
>+
>+static __inline__ SDL_bool
>+SDL_atomic_int_cmp_xchg(volatile int* atomic, int oldvalue, int newvalue)
>+{
>+  return (*atomic == oldvalue) ?  
>+    ((*atomic = newvalue), SDL_TRUE) : SDL_FALSE;
>+}
>+
>+static __inline__ void
>+SDL_atomic_int_add(volatile int* atomic, int value)
>+{
>+  *atomic += value;
>+}
>+#endif /* arch & platforms */
>+  
>+#ifdef ATOMIC_INT_CMP_XCHG
>+static __inline__ SDL_bool
>+SDL_atomic_int_cmp_xchg(volatile int* atomic, int oldvalue, int newvalue)
>+{
>+  return ATOMIC_INT_CMP_XCHG(atomic,oldvalue,newvalue);
>+}
>+
>+static __inline__ int
>+SDL_atomic_int_xchg_add(volatile int* atomic, int value)   
>+{                                                   
>+  int rv;                                            
>+  do                                                 
>+    rv = *atomic;                                
>+  while(!ATOMIC_INT_CMP_XCHG(atomic,rv,rv+value)); 
>+  return rv;                                                
>+}
>+
>+static __inline__ void
>+SDL_atomic_int_add(volatile int* atomic, int value)
>+{
>+  int rv;
>+  do
>+    rv = *atomic;
>+  while(!ATOMIC_INT_CMP_XCHG(atomic,rv,rv+value));
>+}
>+#endif /* ATOMIC_CMP_XCHG */
>+
>+#ifdef ATOMIC_MEMORY_BARRIER
>+# define SDL_atomic_int_get(atomic) \
>+  (ATOMIC_MEMORY_BARRIER,*(atomic))
>+# define SDL_atomic_int_set(atomic,value) \
>+  (*(atomic)=value,ATOMIC_MEMORY_BARRIER)
>+#else
>+# define SDL_atomic_int_get(atomic) (*(atomic))
>+# define SDL_atomic_int_set(atomic, newvalue) ((void)(*(atomic) = (newvalue)))
>+#endif /* MEMORY_BARRIER_NEEDED */
>+
>+#define SDL_atomic_int_inc(atomic) (SDL_atomic_int_add((atomic),1))
>+#define SDL_atomic_int_dec_test(atomic) (SDL_atomic_int_xchg_add((atomic),-1) == 1)
>+
>+/* Ends C function definitions when using C++ */
>+#ifdef __cplusplus
>+/* *INDENT-OFF* */
>+}
>+/* *INDENT-ON* */
>+#endif
>+
>+#include "close_code.h"
>+
>+#endif /* _SDL_atomic_h_ */
>+
>+/* vi: set ts=4 sw=4 expandtab: */
>Index: include/SDL_config_win32.h
>===================================================================
>--- include/SDL_config_win32.h	(revision 2936)
>+++ include/SDL_config_win32.h	(working copy)
>@@ -61,6 +61,12 @@
> #endif
> typedef unsigned int uintptr_t;
> #endif /* __GNUC__ || _MSC_VER */
>+
>+#ifdef _WIN64
>+# define SIZEOF_VOIDP 8
>+#else
>+# define SIZEOF_VOIDP 4
>+#endif
> #define SDL_HAS_64BIT_TYPE	1
> 
> /* Enabled for SDL 1.2 (binary compatibility) */
>Index: include/SDL_config_os2.h
>===================================================================
>--- include/SDL_config_os2.h	(revision 2936)
>+++ include/SDL_config_os2.h	(working copy)
>@@ -38,6 +38,7 @@
> typedef signed long long int64_t;
> typedef unsigned long long uint64_t;
> 
>+#define SIZEOF_VOIDP 4
> #define SDL_HAS_64BIT_TYPE	1
> 
> /* Use Watcom's LIBC */
>Index: include/SDL_config_macosx.h
>===================================================================
>--- include/SDL_config_macosx.h	(revision 2936)
>+++ include/SDL_config_macosx.h	(working copy)
>@@ -27,6 +27,7 @@
> 
> /* This is a set of defines to configure the SDL features */
> 
>+#define SIZEOF_VOIDP 4
> #define SDL_HAS_64BIT_TYPE	1
> 
> /* Useful headers */
>Index: include/SDL.h
>===================================================================
>--- include/SDL.h	(revision 2936)
>+++ include/SDL.h	(working copy)
>@@ -76,6 +76,7 @@
> 
> #include "SDL_main.h"
> #include "SDL_stdinc.h"
>+#include "SDL_atomic.h"
> #include "SDL_audio.h"
> #include "SDL_cdrom.h"
> #include "SDL_cpuinfo.h"
>Index: configure.in
>===================================================================
>--- configure.in	(revision 2936)
>+++ configure.in	(working copy)
>@@ -146,6 +146,7 @@
>     AC_CHECK_LIB(m, pow, [EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm"])
> fi
> 
>+AC_CHECK_SIZEOF(void*)
> if test x$have_inttypes != xyes; then
>     AC_CHECK_SIZEOF(char, 1)
>     AC_CHECK_SIZEOF(short, 2)

Actions: View | Diff

Attachments on bug 646: 339

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.