src/Unix/sysdeps.h

/*
 *  sysdeps.h - System dependent definitions for Linux
 *
 *  SheepShaver (C) 1997-2004 Christian Bauer and Marc Hellwig
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef SYSDEPS_H
#define SYSDEPS_H

#ifndef __STDC__
#error "Your compiler is not ANSI. Get a real one."
#endif

#include "config.h"
#include "user_strings_unix.h"

#ifndef STDC_HEADERS
#error "You don't have ANSI C header files."
#endif

#ifdef HAVE_UNISTD_H
# include <sys/types.h>
# include <unistd.h>
#endif

#include <netinet/in.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>

#ifdef HAVE_PTHREADS
# include <pthread.h>
#endif

#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#endif

#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif

// Define for external components
#define SHEEPSHAVER 1

// Mac and host address space are the same
#define REAL_ADDRESSING 1

#define POWERPC_ROM 1

#if EMULATED_PPC
// Handle interrupts asynchronously?
#define ASYNC_IRQ 0
// Mac ROM is write protected when banked memory is used
#if REAL_ADDRESSING || DIRECT_ADDRESSING
# define ROM_IS_WRITE_PROTECTED 0
# define USE_SCRATCHMEM_SUBTERFUGE 1
#else
# define ROM_IS_WRITE_PROTECTED 1
#endif
// Configure PowerPC emulator
#define PPC_CHECK_INTERRUPTS (ASYNC_IRQ ? 0 : 1)
#define PPC_DECODE_CACHE 1
#define PPC_FLIGHT_RECORDER 1
#define PPC_PROFILE_COMPILE_TIME 0
#define PPC_PROFILE_GENERIC_CALLS 0
#define KPX_MAX_CPUS 1
// direct block chaining is only tested on PPC right now
#if defined(__powerpc__)
#define DYNGEN_DIRECT_BLOCK_CHAINING 1
#endif
#else
// Mac ROM is write protected
#define ROM_IS_WRITE_PROTECTED 1
#define USE_SCRATCHMEM_SUBTERFUGE 0
#endif

// Data types
typedef unsigned char uint8;
typedef signed char int8;
#if SIZEOF_SHORT == 2
typedef unsigned short uint16;
typedef short int16;
#elif SIZEOF_INT == 2
typedef unsigned int uint16;
typedef int int16;
#else
#error "No 2 byte type, you lose."
#endif
#if SIZEOF_INT == 4
typedef unsigned int uint32;
typedef int int32;
#elif SIZEOF_LONG == 4
typedef unsigned long uint32;
typedef long int32;
#else
#error "No 4 byte type, you lose."
#endif
#if SIZEOF_LONG == 8
typedef unsigned long uint64;
typedef long int64;
#define VAL64(a) (a ## l)
#define UVAL64(a) (a ## ul)
#elif SIZEOF_LONG_LONG == 8
typedef unsigned long long uint64;
typedef long long int64;
#define VAL64(a) (a ## LL)
#define UVAL64(a) (a ## uLL)
#else
#error "No 8 byte type, you lose."
#endif
#if SIZEOF_VOID_P == 4
typedef uint32 uintptr;
typedef int32 intptr;
#elif SIZEOF_VOID_P == 8
typedef uint64 uintptr;
typedef int64 intptr;
#else
#error "Unsupported size of pointer"
#endif

/**
 *              Helper functions to byteswap data
 **/

#if defined(__GNUC__)
#if defined(__x86_64__) || defined(__i386__)
// Linux/AMD64 currently has no asm optimized bswap_32() in <byteswap.h>
#define opt_bswap_32 do_opt_bswap_32
static inline uint32 do_opt_bswap_32(uint32 x)
{
  uint32 v;
  __asm__ __volatile__ ("bswap %0" : "=r" (v) : "0" (x));
  return v;
}
#endif
#endif

#ifdef HAVE_BYTESWAP_H
#include <byteswap.h>
#endif

#ifdef  opt_bswap_16
#undef  bswap_16
#define bswap_16 opt_bswap_16
#endif
#ifndef bswap_16
#define bswap_16 generic_bswap_16
#endif

static inline uint16 generic_bswap_16(uint16 x)
{
  return ((x & 0xff) << 8) | ((x >> 8) & 0xff);
}

#ifdef  opt_bswap_32
#undef  bswap_32
#define bswap_32 opt_bswap_32
#endif
#ifndef bswap_32
#define bswap_32 generic_bswap_32
#endif

static inline uint32 generic_bswap_32(uint32 x)
{
  return (((x & 0xff000000) >> 24) |
                  ((x & 0x00ff0000) >>  8) |
                  ((x & 0x0000ff00) <<  8) |
                  ((x & 0x000000ff) << 24) );
}

#if defined(__i386__)
#define opt_bswap_64 do_opt_bswap_64
static inline uint64 do_opt_bswap_64(uint64 x)
{
  return (bswap_32(x >> 32) | (((uint64)bswap_32((uint32)x)) << 32));
}
#endif

#ifdef  opt_bswap_64
#undef  bswap_64
#define bswap_64 opt_bswap_64
#endif
#ifndef bswap_64
#define bswap_64 generic_bswap_64
#endif

static inline uint64 generic_bswap_64(uint64 x)
{
  return (((x & UVAL64(0xff00000000000000)) >> 56) |
                  ((x & UVAL64(0x00ff000000000000)) >> 40) |
                  ((x & UVAL64(0x0000ff0000000000)) >> 24) |
                  ((x & UVAL64(0x000000ff00000000)) >>  8) |
                  ((x & UVAL64(0x00000000ff000000)) <<  8) |
                  ((x & UVAL64(0x0000000000ff0000)) << 24) |
                  ((x & UVAL64(0x000000000000ff00)) << 40) |
                  ((x & UVAL64(0x00000000000000ff)) << 56) );
}

#ifdef WORDS_BIGENDIAN
static inline uint16 tswap16(uint16 x) { return x; }
static inline uint32 tswap32(uint32 x) { return x; }
static inline uint64 tswap64(uint64 x) { return x; }
#else
static inline uint16 tswap16(uint16 x) { return bswap_16(x); }
static inline uint32 tswap32(uint32 x) { return bswap_32(x); }
static inline uint64 tswap64(uint64 x) { return bswap_64(x); }
#endif

// spin locks
#ifdef __GNUC__

#if defined(__powerpc__) || defined(__ppc__)
#define HAVE_TEST_AND_SET 1
static inline int testandset(volatile int *p)
{
        int ret;
        __asm__ __volatile__("0:    lwarx       %0,0,%1\n"
                                                 "      xor.    %0,%3,%0\n"
                                                 "      bne             1f\n"
                                                 "      stwcx.  %2,0,%1\n"
                                                 "      bne-    0b\n"
                                                 "1:    "
                                                 : "=&r" (ret)
                                                 : "r" (p), "r" (1), "r" (0)
                                                 : "cr0", "memory");
        return ret;
}
#endif

#ifdef __i386__
#define HAVE_TEST_AND_SET 1
static inline int testandset(volatile int *p)
{
        int ret;
        long int readval;
        /* Note: the "xchg" instruction does not need a "lock" prefix */
        __asm__ __volatile__("xchgl %0, %1"
                                                 : "=r" (ret), "=m" (*p), "=a" (readval)
                                                 : "0" (1), "m" (*p)
                                                 : "memory");
        return ret;
}
#endif

#ifdef __s390__
#define HAVE_TEST_AND_SET 1
static inline int testandset(volatile int *p)
{
        int ret;

        __asm__ __volatile__("0: cs    %0,%1,0(%2)\n"
                                                 "   jl    0b"
                                                 : "=&d" (ret)
                                                 : "r" (1), "a" (p), "0" (*p) 
                                                 : "cc", "memory" );
        return ret;
}
#endif

#ifdef __alpha__
#define HAVE_TEST_AND_SET 1
static inline int testandset(volatile int *p)
{
        int ret;
        unsigned long one;

        __asm__ __volatile__("0:        mov 1,%2\n"
                                                 "      ldl_l %0,%1\n"
                                                 "      stl_c %2,%1\n"
                                                 "      beq %2,1f\n"
                                                 ".subsection 2\n"
                                                 "1:    br 0b\n"
                                                 ".previous"
                                                 : "=r" (ret), "=m" (*p), "=r" (one)
                                                 : "m" (*p));
        return ret;
}
#endif

#ifdef __sparc__
#define HAVE_TEST_AND_SET 1
static inline int testandset(volatile int *p)
{
        int ret;

        __asm__ __volatile__("ldstub    [%1], %0"
                                                 : "=r" (ret)
                                                 : "r" (p)
                                                 : "memory");

        return (ret ? 1 : 0);
}
#endif

#ifdef __arm__
#define HAVE_TEST_AND_SET 1
static inline int testandset(volatile int *p)
{
        register unsigned int ret;
        __asm__ __volatile__("swp %0, %1, [%2]"
                                                 : "=r"(ret)
                                                 : "0"(1), "r"(p));
        
        return ret;
}
#endif

#endif /* __GNUC__ */

#if HAVE_TEST_AND_SET
#define HAVE_SPINLOCKS 1
typedef volatile int spinlock_t;

static const spinlock_t SPIN_LOCK_UNLOCKED = 0;

static inline void spin_lock(spinlock_t *lock)
{
        while (testandset(lock));
}

static inline void spin_unlock(spinlock_t *lock)
{
        *lock = 0;
}

static inline int spin_trylock(spinlock_t *lock)
{
        return !testandset(lock);
}
#endif

// Time data type for Time Manager emulation
#ifdef HAVE_CLOCK_GETTIME
typedef struct timespec tm_time_t;
#else
typedef struct timeval tm_time_t;
#endif

// Timing functions
extern uint64 GetTicks_usec(void);
extern void Delay_usec(uint32 usec);

#if defined(HAVE_PTHREADS) || (defined(__linux__) && defined(__powerpc__))
// Setup pthread attributes
extern void Set_pthread_attr(pthread_attr_t *attr, int priority);
#endif

// Various definitions
typedef struct rgb_color {
        uint8           red;
        uint8           green;
        uint8           blue;
        uint8           alpha;
} rgb_color;

// X11 display fast locks
#ifdef HAVE_SPINLOCKS
#define X11_LOCK_TYPE spinlock_t
#define X11_LOCK_INIT SPIN_LOCK_UNLOCKED
#define XDisplayLock() spin_lock(&x_display_lock)
#define XDisplayUnlock() spin_unlock(&x_display_lock)
#elif defined(HAVE_PTHREADS)
#define X11_LOCK_TYPE pthread_mutex_t
#define X11_LOCK_INIT PTHREAD_MUTEX_INITIALIZER
#define XDisplayLock() pthread_mutex_lock(&x_display_lock);
#define XDisplayUnlock() pthread_mutex_unlock(&x_display_lock);
#else
#define XDisplayLock()
#define XDisplayUnlock()
#endif
#ifdef X11_LOCK_TYPE
extern X11_LOCK_TYPE x_display_lock;
#endif

// Macro for calling MacOS routines
#define CallMacOS(type, tvect) call_macos((uint32)tvect)
#define CallMacOS1(type, tvect, arg1) call_macos1((uint32)tvect, (uint32)arg1)
#define CallMacOS2(type, tvect, arg1, arg2) call_macos2((uint32)tvect, (uint32)arg1, (uint32)arg2)
#define CallMacOS3(type, tvect, arg1, arg2, arg3) call_macos3((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3)
#define CallMacOS4(type, tvect, arg1, arg2, arg3, arg4) call_macos4((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4)
#define CallMacOS5(type, tvect, arg1, arg2, arg3, arg4, arg5) call_macos5((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5)
#define CallMacOS6(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6) call_macos6((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5, (uint32)arg6)
#define CallMacOS7(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6, arg7) call_macos7((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5, (uint32)arg6, (uint32)arg7)

#ifdef __cplusplus
extern "C" {
#endif
extern uint32 call_macos(uint32 tvect);
extern uint32 call_macos1(uint32 tvect, uint32 arg1);
extern uint32 call_macos2(uint32 tvect, uint32 arg1, uint32 arg2);
extern uint32 call_macos3(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3);
extern uint32 call_macos4(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4);
extern uint32 call_macos5(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5);
extern uint32 call_macos6(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5, uint32 arg6);
extern uint32 call_macos7(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5, uint32 arg6, uint32 arg7);
#ifdef __cplusplus
}
#endif

#endif
Revision:	1.26
Committed:	2004-05-11T20:53:23Z (20 years, 6 months ago) by gbeauche
Content type:	text/plain
Branch:	MAIN
Changes since 1.25:	+4 -0 lines
Log Message:	direct block chaining, aka faster block dispatcher
#	User	Rev	Content
1	cebix	1.1	/*
2			* sysdeps.h - System dependent definitions for Linux
3			*
4	cebix	1.21	* SheepShaver (C) 1997-2004 Christian Bauer and Marc Hellwig
5	cebix	1.1	*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#ifndef SYSDEPS_H
22			#define SYSDEPS_H
23
24			#ifndef __STDC__
25			#error "Your compiler is not ANSI. Get a real one."
26			#endif
27
28			#include "config.h"
29			#include "user_strings_unix.h"
30
31			#ifndef STDC_HEADERS
32			#error "You don't have ANSI C header files."
33			#endif
34
35			#ifdef HAVE_UNISTD_H
36			# include <sys/types.h>
37			# include <unistd.h>
38			#endif
39
40			#include <netinet/in.h>
41			#include <assert.h>
42			#include <stdio.h>
43			#include <stdlib.h>
44			#include <string.h>
45			#include <signal.h>
46
47	gbeauche	1.24	#ifdef HAVE_PTHREADS
48			# include <pthread.h>
49			#endif
50
51	cebix	1.1	#ifdef HAVE_FCNTL_H
52			# include <fcntl.h>
53			#endif
54
55			#ifdef TIME_WITH_SYS_TIME
56			# include <sys/time.h>
57			# include <time.h>
58			#else
59			# ifdef HAVE_SYS_TIME_H
60			# include <sys/time.h>
61			# else
62			# include <time.h>
63			# endif
64			#endif
65
66	gbeauche	1.5	// Define for external components
67			#define SHEEPSHAVER 1
68
69	gbeauche	1.4	// Mac and host address space are the same
70			#define REAL_ADDRESSING 1
71
72	gbeauche	1.5	#define POWERPC_ROM 1
73
74			#if EMULATED_PPC
75	gbeauche	1.7	// Handle interrupts asynchronously?
76			#define ASYNC_IRQ 0
77	gbeauche	1.5	// Mac ROM is write protected when banked memory is used
78			#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
79			# define ROM_IS_WRITE_PROTECTED 0
80			# define USE_SCRATCHMEM_SUBTERFUGE 1
81	cebix	1.1	#else
82	gbeauche	1.5	# define ROM_IS_WRITE_PROTECTED 1
83			#endif
84	gbeauche	1.9	// Configure PowerPC emulator
85	gbeauche	1.13	#define PPC_CHECK_INTERRUPTS (ASYNC_IRQ ? 0 : 1)
86	gbeauche	1.14	#define PPC_DECODE_CACHE 1
87	gbeauche	1.10	#define PPC_FLIGHT_RECORDER 1
88	gbeauche	1.17	#define PPC_PROFILE_COMPILE_TIME 0
89			#define PPC_PROFILE_GENERIC_CALLS 0
90	gbeauche	1.16	#define KPX_MAX_CPUS 1
91	gbeauche	1.26	// direct block chaining is only tested on PPC right now
92			#if defined(__powerpc__)
93			#define DYNGEN_DIRECT_BLOCK_CHAINING 1
94			#endif
95	gbeauche	1.5	#else
96			// Mac ROM is write protected
97			#define ROM_IS_WRITE_PROTECTED 1
98			#define USE_SCRATCHMEM_SUBTERFUGE 0
99	cebix	1.1	#endif
100
101			// Data types
102			typedef unsigned char uint8;
103			typedef signed char int8;
104			#if SIZEOF_SHORT == 2
105			typedef unsigned short uint16;
106			typedef short int16;
107			#elif SIZEOF_INT == 2
108			typedef unsigned int uint16;
109			typedef int int16;
110			#else
111			#error "No 2 byte type, you lose."
112			#endif
113			#if SIZEOF_INT == 4
114			typedef unsigned int uint32;
115			typedef int int32;
116			#elif SIZEOF_LONG == 4
117			typedef unsigned long uint32;
118			typedef long int32;
119			#else
120			#error "No 4 byte type, you lose."
121			#endif
122			#if SIZEOF_LONG == 8
123			typedef unsigned long uint64;
124			typedef long int64;
125	gbeauche	1.3	#define VAL64(a) (a ## l)
126			#define UVAL64(a) (a ## ul)
127	cebix	1.1	#elif SIZEOF_LONG_LONG == 8
128			typedef unsigned long long uint64;
129			typedef long long int64;
130	gbeauche	1.3	#define VAL64(a) (a ## LL)
131			#define UVAL64(a) (a ## uLL)
132	cebix	1.1	#else
133			#error "No 8 byte type, you lose."
134			#endif
135	gbeauche	1.3	#if SIZEOF_VOID_P == 4
136			typedef uint32 uintptr;
137			typedef int32 intptr;
138			#elif SIZEOF_VOID_P == 8
139			typedef uint64 uintptr;
140			typedef int64 intptr;
141			#else
142			#error "Unsupported size of pointer"
143	gbeauche	1.5	#endif
144
145	gbeauche	1.15	/**
146			* Helper functions to byteswap data
147			**/
148
149			#if defined(__GNUC__)
150	gbeauche	1.23	#if defined(__x86_64__) \|\| defined(__i386__)
151	gbeauche	1.15	// Linux/AMD64 currently has no asm optimized bswap_32() in <byteswap.h>
152			#define opt_bswap_32 do_opt_bswap_32
153			static inline uint32 do_opt_bswap_32(uint32 x)
154			{
155			uint32 v;
156			__asm__ __volatile__ ("bswap %0" : "=r" (v) : "0" (x));
157			return v;
158			}
159			#endif
160			#endif
161
162	gbeauche	1.5	#ifdef HAVE_BYTESWAP_H
163			#include <byteswap.h>
164			#endif
165
166	gbeauche	1.15	#ifdef opt_bswap_16
167			#undef bswap_16
168			#define bswap_16 opt_bswap_16
169			#endif
170	gbeauche	1.5	#ifndef bswap_16
171			#define bswap_16 generic_bswap_16
172			#endif
173
174			static inline uint16 generic_bswap_16(uint16 x)
175			{
176			return ((x & 0xff) << 8) \| ((x >> 8) & 0xff);
177			}
178
179	gbeauche	1.15	#ifdef opt_bswap_32
180			#undef bswap_32
181			#define bswap_32 opt_bswap_32
182			#endif
183	gbeauche	1.5	#ifndef bswap_32
184			#define bswap_32 generic_bswap_32
185			#endif
186
187			static inline uint32 generic_bswap_32(uint32 x)
188			{
189			return (((x & 0xff000000) >> 24) \|
190			((x & 0x00ff0000) >> 8) \|
191			((x & 0x0000ff00) << 8) \|
192			((x & 0x000000ff) << 24) );
193			}
194	gbeauche	1.23
195			#if defined(__i386__)
196			#define opt_bswap_64 do_opt_bswap_64
197			static inline uint64 do_opt_bswap_64(uint64 x)
198			{
199			return (bswap_32(x >> 32) \| (((uint64)bswap_32((uint32)x)) << 32));
200			}
201			#endif
202	gbeauche	1.5
203	gbeauche	1.15	#ifdef opt_bswap_64
204			#undef bswap_64
205			#define bswap_64 opt_bswap_64
206			#endif
207	gbeauche	1.5	#ifndef bswap_64
208			#define bswap_64 generic_bswap_64
209			#endif
210
211			static inline uint64 generic_bswap_64(uint64 x)
212			{
213			return (((x & UVAL64(0xff00000000000000)) >> 56) \|
214			((x & UVAL64(0x00ff000000000000)) >> 40) \|
215			((x & UVAL64(0x0000ff0000000000)) >> 24) \|
216			((x & UVAL64(0x000000ff00000000)) >> 8) \|
217			((x & UVAL64(0x00000000ff000000)) << 8) \|
218			((x & UVAL64(0x0000000000ff0000)) << 24) \|
219			((x & UVAL64(0x000000000000ff00)) << 40) \|
220			((x & UVAL64(0x00000000000000ff)) << 56) );
221			}
222
223			#ifdef WORDS_BIGENDIAN
224			static inline uint16 tswap16(uint16 x) { return x; }
225			static inline uint32 tswap32(uint32 x) { return x; }
226			static inline uint64 tswap64(uint64 x) { return x; }
227			#else
228			static inline uint16 tswap16(uint16 x) { return bswap_16(x); }
229			static inline uint32 tswap32(uint32 x) { return bswap_32(x); }
230			static inline uint64 tswap64(uint64 x) { return bswap_64(x); }
231	gbeauche	1.3	#endif
232	cebix	1.1
233	gbeauche	1.6	// spin locks
234			#ifdef __GNUC__
235
236	gbeauche	1.22	#if defined(__powerpc__) \|\| defined(__ppc__)
237	gbeauche	1.6	#define HAVE_TEST_AND_SET 1
238	gbeauche	1.20	static inline int testandset(volatile int *p)
239	gbeauche	1.6	{
240			int ret;
241	gbeauche	1.22	__asm__ __volatile__("0: lwarx %0,0,%1\n"
242			" xor. %0,%3,%0\n"
243			" bne 1f\n"
244			" stwcx. %2,0,%1\n"
245			" bne- 0b\n"
246	gbeauche	1.6	"1: "
247			: "=&r" (ret)
248			: "r" (p), "r" (1), "r" (0)
249			: "cr0", "memory");
250			return ret;
251			}
252			#endif
253
254			#ifdef __i386__
255			#define HAVE_TEST_AND_SET 1
256	gbeauche	1.20	static inline int testandset(volatile int *p)
257	gbeauche	1.6	{
258	gbeauche	1.20	int ret;
259	gbeauche	1.6	long int readval;
260	gbeauche	1.20	/* Note: the "xchg" instruction does not need a "lock" prefix */
261			__asm__ __volatile__("xchgl %0, %1"
262			: "=r" (ret), "=m" (*p), "=a" (readval)
263			: "0" (1), "m" (*p)
264	gbeauche	1.6	: "memory");
265			return ret;
266			}
267			#endif
268
269			#ifdef __s390__
270			#define HAVE_TEST_AND_SET 1
271	gbeauche	1.20	static inline int testandset(volatile int *p)
272	gbeauche	1.6	{
273			int ret;
274
275			__asm__ __volatile__("0: cs %0,%1,0(%2)\n"
276			" jl 0b"
277			: "=&d" (ret)
278			: "r" (1), "a" (p), "0" (*p)
279			: "cc", "memory" );
280			return ret;
281			}
282			#endif
283
284			#ifdef __alpha__
285			#define HAVE_TEST_AND_SET 1
286	gbeauche	1.20	static inline int testandset(volatile int *p)
287	gbeauche	1.6	{
288			int ret;
289			unsigned long one;
290
291			__asm__ __volatile__("0: mov 1,%2\n"
292			" ldl_l %0,%1\n"
293			" stl_c %2,%1\n"
294			" beq %2,1f\n"
295			".subsection 2\n"
296			"1: br 0b\n"
297			".previous"
298			: "=r" (ret), "=m" (*p), "=r" (one)
299			: "m" (*p));
300			return ret;
301			}
302			#endif
303
304			#ifdef __sparc__
305			#define HAVE_TEST_AND_SET 1
306	gbeauche	1.20	static inline int testandset(volatile int *p)
307	gbeauche	1.6	{
308			int ret;
309
310			__asm__ __volatile__("ldstub [%1], %0"
311			: "=r" (ret)
312			: "r" (p)
313			: "memory");
314
315			return (ret ? 1 : 0);
316			}
317			#endif
318
319			#ifdef __arm__
320			#define HAVE_TEST_AND_SET 1
321	gbeauche	1.20	static inline int testandset(volatile int *p)
322	gbeauche	1.6	{
323			register unsigned int ret;
324			__asm__ __volatile__("swp %0, %1, [%2]"
325			: "=r"(ret)
326			: "0"(1), "r"(p));
327
328			return ret;
329			}
330			#endif
331
332			#endif /* __GNUC__ */
333
334			#if HAVE_TEST_AND_SET
335			#define HAVE_SPINLOCKS 1
336	gbeauche	1.20	typedef volatile int spinlock_t;
337	gbeauche	1.6
338	gbeauche	1.8	static const spinlock_t SPIN_LOCK_UNLOCKED = 0;
339	gbeauche	1.6
340			static inline void spin_lock(spinlock_t *lock)
341			{
342			while (testandset(lock));
343			}
344
345			static inline void spin_unlock(spinlock_t *lock)
346			{
347			*lock = 0;
348			}
349
350			static inline int spin_trylock(spinlock_t *lock)
351			{
352			return !testandset(lock);
353			}
354			#endif
355
356	cebix	1.1	// Time data type for Time Manager emulation
357			#ifdef HAVE_CLOCK_GETTIME
358			typedef struct timespec tm_time_t;
359			#else
360			typedef struct timeval tm_time_t;
361			#endif
362
363	gbeauche	1.18	// Timing functions
364			extern uint64 GetTicks_usec(void);
365			extern void Delay_usec(uint32 usec);
366
367	gbeauche	1.25	#if defined(HAVE_PTHREADS) \|\| (defined(__linux__) && defined(__powerpc__))
368	cebix	1.2	// Setup pthread attributes
369			extern void Set_pthread_attr(pthread_attr_t *attr, int priority);
370	gbeauche	1.24	#endif
371	cebix	1.2
372	cebix	1.1	// Various definitions
373			typedef struct rgb_color {
374			uint8 red;
375			uint8 green;
376			uint8 blue;
377			uint8 alpha;
378			} rgb_color;
379
380	gbeauche	1.19	// X11 display fast locks
381			#ifdef HAVE_SPINLOCKS
382			#define X11_LOCK_TYPE spinlock_t
383			#define X11_LOCK_INIT SPIN_LOCK_UNLOCKED
384			#define XDisplayLock() spin_lock(&x_display_lock)
385			#define XDisplayUnlock() spin_unlock(&x_display_lock)
386			#elif defined(HAVE_PTHREADS)
387			#define X11_LOCK_TYPE pthread_mutex_t
388			#define X11_LOCK_INIT PTHREAD_MUTEX_INITIALIZER
389			#define XDisplayLock() pthread_mutex_lock(&x_display_lock);
390			#define XDisplayUnlock() pthread_mutex_unlock(&x_display_lock);
391			#else
392			#define XDisplayLock()
393			#define XDisplayUnlock()
394			#endif
395			#ifdef X11_LOCK_TYPE
396			extern X11_LOCK_TYPE x_display_lock;
397			#endif
398
399	cebix	1.1	// Macro for calling MacOS routines
400			#define CallMacOS(type, tvect) call_macos((uint32)tvect)
401			#define CallMacOS1(type, tvect, arg1) call_macos1((uint32)tvect, (uint32)arg1)
402			#define CallMacOS2(type, tvect, arg1, arg2) call_macos2((uint32)tvect, (uint32)arg1, (uint32)arg2)
403			#define CallMacOS3(type, tvect, arg1, arg2, arg3) call_macos3((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3)
404			#define CallMacOS4(type, tvect, arg1, arg2, arg3, arg4) call_macos4((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4)
405			#define CallMacOS5(type, tvect, arg1, arg2, arg3, arg4, arg5) call_macos5((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5)
406			#define CallMacOS6(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6) call_macos6((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5, (uint32)arg6)
407			#define CallMacOS7(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6, arg7) call_macos7((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5, (uint32)arg6, (uint32)arg7)
408
409	gbeauche	1.3	#ifdef __cplusplus
410			extern "C" {
411			#endif
412			extern uint32 call_macos(uint32 tvect);
413			extern uint32 call_macos1(uint32 tvect, uint32 arg1);
414			extern uint32 call_macos2(uint32 tvect, uint32 arg1, uint32 arg2);
415			extern uint32 call_macos3(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3);
416			extern uint32 call_macos4(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4);
417			extern uint32 call_macos5(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5);
418			extern uint32 call_macos6(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5, uint32 arg6);
419			extern uint32 call_macos7(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5, uint32 arg6, uint32 arg7);
420			#ifdef __cplusplus
421			}
422			#endif
423	cebix	1.1
424			#endif