src/Unix/sysdeps.h

/*
 *  sysdeps.h - System dependent definitions for Linux
 *
 *  SheepShaver (C) 1997-2005 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 <stddef.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

// Fix offsetof() on FreeBSD and GCC >= 3.4
#if defined(__FreeBSD__) && defined(__cplusplus)
#undef offsetof
/* The cast to "char &" below avoids problems with user-defined
   "operator &", which can appear in a POD type.  */
#define offsetof(TYPE, MEMBER)                          \
  (__offsetof__ (reinterpret_cast <size_t>              \
                 (&reinterpret_cast <char &>            \
                  (static_cast<TYPE *> (0)->MEMBER))))
#endif

// Define for external components
#define SHEEPSHAVER 1

// Always use Real Addressing mode on native architectures
// Otherwise, use Direct Addressing mode if NATMEM_OFFSET is set
#if !defined(EMULATED_PPC)
#define REAL_ADDRESSING 1
#include "ppc_asm.tmpl"
#elif defined(NATMEM_OFFSET)
#define DIRECT_ADDRESSING 1
#else
#define REAL_ADDRESSING 1
#endif

// Always use the complete non-stubs Ethernet driver
#define USE_ETHER_FULL_DRIVER 1

#define POWERPC_ROM 1

#if EMULATED_PPC
// 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_REENTRANT_JIT 1
#define PPC_CHECK_INTERRUPTS 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
#if ENABLE_DYNGEN
#define PPC_ENABLE_JIT 1
#endif
#if defined(__i386__)
#define DYNGEN_ASM_OPTS 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 macros to annotate likely branch directions
 **/

#if __GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
#define likely(x)               __builtin_expect((x),1)
#define unlikely(x)             __builtin_expect((x),0)
#endif
#ifndef likely
#define likely(x)               (x)
#endif
#ifndef unlikely
#define unlikely(x)             (x)
#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

#if defined(__i386__) || defined(__x86_64__)
#define HAVE_TEST_AND_SET 1
static inline int testandset(volatile int *p)
{
        long int ret;
        /* Note: the "xchg" instruction does not need a "lock" prefix */
        __asm__ __volatile__("xchgl %k0, %1"
                                                 : "=r" (ret), "=m" (*p)
                                                 : "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__ */

typedef volatile int spinlock_t;

static const spinlock_t SPIN_LOCK_UNLOCKED = 0;

#if defined(HAVE_TEST_AND_SET) && defined(HAVE_PTHREADS)
// There is nothing to lock if we are not in an multithreaded environment
#define HAVE_SPINLOCKS 1
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);
}
#else
static inline void spin_lock(spinlock_t *lock)
{
}

static inline void spin_unlock(spinlock_t *lock)
{
}

static inline int spin_trylock(spinlock_t *lock)
{
        return 1;
}
#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

/* Define codes for all the float formats that we know of.
 * Though we only handle IEEE format.  */
#define UNKNOWN_FLOAT_FORMAT 0
#define IEEE_FLOAT_FORMAT 1
#define VAX_FLOAT_FORMAT 2
#define IBM_FLOAT_FORMAT 3
#define C4X_FLOAT_FORMAT 4

// High-precision timing
#if defined(HAVE_PTHREADS) && defined(HAVE_CLOCK_NANOSLEEP)
#define PRECISE_TIMING 1
#define PRECISE_TIMING_POSIX 1
#endif

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

#ifdef HAVE_PTHREADS
// 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
#if 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);
#elif defined(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)
#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((uintptr)tvect)
#define CallMacOS1(type, tvect, arg1) call_macos1((uintptr)tvect, (uintptr)arg1)
#define CallMacOS2(type, tvect, arg1, arg2) call_macos2((uintptr)tvect, (uintptr)arg1, (uintptr)arg2)
#define CallMacOS3(type, tvect, arg1, arg2, arg3) call_macos3((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3)
#define CallMacOS4(type, tvect, arg1, arg2, arg3, arg4) call_macos4((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4)
#define CallMacOS5(type, tvect, arg1, arg2, arg3, arg4, arg5) call_macos5((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5)
#define CallMacOS6(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6) call_macos6((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5, (uintptr)arg6)
#define CallMacOS7(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6, arg7) call_macos7((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5, (uintptr)arg6, (uintptr)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.51
Committed:	2006-04-01T21:41:18Z (18 years, 7 months ago) by gbeauche
Content type:	text/plain
Branch:	MAIN
Changes since 1.50:	+15 -0 lines
Log Message:	Helper macros to annotate likely branch directions. Colateral effect: this also fixes build with GCC 4.1 (ppc-dyngen-ops.cpp) since the branches are re-ordered in a way there is now only one exit-point in op_jump_next_A0().
#	User	Rev	Content
1	cebix	1.1	/*
2			* sysdeps.h - System dependent definitions for Linux
3			*
4	gbeauche	1.36	* SheepShaver (C) 1997-2005 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	gbeauche	1.37	#include <stddef.h>
45	cebix	1.1	#include <string.h>
46			#include <signal.h>
47
48	gbeauche	1.24	#ifdef HAVE_PTHREADS
49			# include <pthread.h>
50			#endif
51
52	cebix	1.1	#ifdef HAVE_FCNTL_H
53			# include <fcntl.h>
54			#endif
55
56			#ifdef TIME_WITH_SYS_TIME
57			# include <sys/time.h>
58			# include <time.h>
59			#else
60			# ifdef HAVE_SYS_TIME_H
61			# include <sys/time.h>
62			# else
63			# include <time.h>
64			# endif
65			#endif
66
67	gbeauche	1.37	// Fix offsetof() on FreeBSD and GCC >= 3.4
68			#if defined(__FreeBSD__) && defined(__cplusplus)
69			#undef offsetof
70			/* The cast to "char &" below avoids problems with user-defined
71			"operator &", which can appear in a POD type. */
72			#define offsetof(TYPE, MEMBER) \
73			(__offsetof__ (reinterpret_cast <size_t> \
74			(&reinterpret_cast <char &> \
75			(static_cast<TYPE *> (0)->MEMBER))))
76			#endif
77
78	gbeauche	1.5	// Define for external components
79			#define SHEEPSHAVER 1
80
81	gbeauche	1.34	// Always use Real Addressing mode on native architectures
82			// Otherwise, use Direct Addressing mode if NATMEM_OFFSET is set
83	gbeauche	1.35	#if !defined(EMULATED_PPC)
84	gbeauche	1.4	#define REAL_ADDRESSING 1
85	gbeauche	1.39	#include "ppc_asm.tmpl"
86	gbeauche	1.35	#elif defined(NATMEM_OFFSET)
87			#define DIRECT_ADDRESSING 1
88	gbeauche	1.34	#else
89	gbeauche	1.35	#define REAL_ADDRESSING 1
90	gbeauche	1.34	#endif
91	gbeauche	1.4
92	gbeauche	1.48	// Always use the complete non-stubs Ethernet driver
93			#define USE_ETHER_FULL_DRIVER 1
94
95	gbeauche	1.5	#define POWERPC_ROM 1
96
97			#if EMULATED_PPC
98			// Mac ROM is write protected when banked memory is used
99			#if REAL_ADDRESSING \|\| DIRECT_ADDRESSING
100			# define ROM_IS_WRITE_PROTECTED 0
101			# define USE_SCRATCHMEM_SUBTERFUGE 1
102	cebix	1.1	#else
103	gbeauche	1.5	# define ROM_IS_WRITE_PROTECTED 1
104			#endif
105	gbeauche	1.9	// Configure PowerPC emulator
106	gbeauche	1.29	#define PPC_REENTRANT_JIT 1
107	gbeauche	1.30	#define PPC_CHECK_INTERRUPTS 1
108	gbeauche	1.14	#define PPC_DECODE_CACHE 1
109	gbeauche	1.10	#define PPC_FLIGHT_RECORDER 1
110	gbeauche	1.17	#define PPC_PROFILE_COMPILE_TIME 0
111			#define PPC_PROFILE_GENERIC_CALLS 0
112	gbeauche	1.16	#define KPX_MAX_CPUS 1
113	gbeauche	1.33	#if ENABLE_DYNGEN
114			#define PPC_ENABLE_JIT 1
115			#endif
116	gbeauche	1.28	#if defined(__i386__)
117			#define DYNGEN_ASM_OPTS 1
118			#endif
119	gbeauche	1.5	#else
120			// Mac ROM is write protected
121			#define ROM_IS_WRITE_PROTECTED 1
122			#define USE_SCRATCHMEM_SUBTERFUGE 0
123	cebix	1.1	#endif
124
125			// Data types
126			typedef unsigned char uint8;
127			typedef signed char int8;
128			#if SIZEOF_SHORT == 2
129			typedef unsigned short uint16;
130			typedef short int16;
131			#elif SIZEOF_INT == 2
132			typedef unsigned int uint16;
133			typedef int int16;
134			#else
135			#error "No 2 byte type, you lose."
136			#endif
137			#if SIZEOF_INT == 4
138			typedef unsigned int uint32;
139			typedef int int32;
140			#elif SIZEOF_LONG == 4
141			typedef unsigned long uint32;
142			typedef long int32;
143			#else
144			#error "No 4 byte type, you lose."
145			#endif
146			#if SIZEOF_LONG == 8
147			typedef unsigned long uint64;
148			typedef long int64;
149	gbeauche	1.3	#define VAL64(a) (a ## l)
150			#define UVAL64(a) (a ## ul)
151	cebix	1.1	#elif SIZEOF_LONG_LONG == 8
152			typedef unsigned long long uint64;
153			typedef long long int64;
154	gbeauche	1.3	#define VAL64(a) (a ## LL)
155			#define UVAL64(a) (a ## uLL)
156	cebix	1.1	#else
157			#error "No 8 byte type, you lose."
158			#endif
159	gbeauche	1.3	#if SIZEOF_VOID_P == 4
160			typedef uint32 uintptr;
161			typedef int32 intptr;
162			#elif SIZEOF_VOID_P == 8
163			typedef uint64 uintptr;
164			typedef int64 intptr;
165			#else
166			#error "Unsupported size of pointer"
167	gbeauche	1.5	#endif
168
169	gbeauche	1.15	/**
170	gbeauche	1.51	* Helper macros to annotate likely branch directions
171			**/
172
173			#if __GNUC__ >= 3 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
174			#define likely(x) __builtin_expect((x),1)
175			#define unlikely(x) __builtin_expect((x),0)
176			#endif
177			#ifndef likely
178			#define likely(x) (x)
179			#endif
180			#ifndef unlikely
181			#define unlikely(x) (x)
182			#endif
183
184			/**
185	gbeauche	1.15	* Helper functions to byteswap data
186			**/
187
188			#if defined(__GNUC__)
189	gbeauche	1.23	#if defined(__x86_64__) \|\| defined(__i386__)
190	gbeauche	1.15	// Linux/AMD64 currently has no asm optimized bswap_32() in <byteswap.h>
191			#define opt_bswap_32 do_opt_bswap_32
192			static inline uint32 do_opt_bswap_32(uint32 x)
193			{
194			uint32 v;
195			__asm__ __volatile__ ("bswap %0" : "=r" (v) : "0" (x));
196			return v;
197			}
198			#endif
199			#endif
200
201	gbeauche	1.5	#ifdef HAVE_BYTESWAP_H
202			#include <byteswap.h>
203			#endif
204
205	gbeauche	1.15	#ifdef opt_bswap_16
206			#undef bswap_16
207			#define bswap_16 opt_bswap_16
208			#endif
209	gbeauche	1.5	#ifndef bswap_16
210			#define bswap_16 generic_bswap_16
211			#endif
212
213			static inline uint16 generic_bswap_16(uint16 x)
214			{
215			return ((x & 0xff) << 8) \| ((x >> 8) & 0xff);
216			}
217
218	gbeauche	1.15	#ifdef opt_bswap_32
219			#undef bswap_32
220			#define bswap_32 opt_bswap_32
221			#endif
222	gbeauche	1.5	#ifndef bswap_32
223			#define bswap_32 generic_bswap_32
224			#endif
225
226			static inline uint32 generic_bswap_32(uint32 x)
227			{
228			return (((x & 0xff000000) >> 24) \|
229			((x & 0x00ff0000) >> 8) \|
230			((x & 0x0000ff00) << 8) \|
231			((x & 0x000000ff) << 24) );
232			}
233	gbeauche	1.23
234			#if defined(__i386__)
235			#define opt_bswap_64 do_opt_bswap_64
236			static inline uint64 do_opt_bswap_64(uint64 x)
237			{
238			return (bswap_32(x >> 32) \| (((uint64)bswap_32((uint32)x)) << 32));
239			}
240			#endif
241	gbeauche	1.5
242	gbeauche	1.15	#ifdef opt_bswap_64
243			#undef bswap_64
244			#define bswap_64 opt_bswap_64
245			#endif
246	gbeauche	1.5	#ifndef bswap_64
247			#define bswap_64 generic_bswap_64
248			#endif
249
250			static inline uint64 generic_bswap_64(uint64 x)
251			{
252			return (((x & UVAL64(0xff00000000000000)) >> 56) \|
253			((x & UVAL64(0x00ff000000000000)) >> 40) \|
254			((x & UVAL64(0x0000ff0000000000)) >> 24) \|
255			((x & UVAL64(0x000000ff00000000)) >> 8) \|
256			((x & UVAL64(0x00000000ff000000)) << 8) \|
257			((x & UVAL64(0x0000000000ff0000)) << 24) \|
258			((x & UVAL64(0x000000000000ff00)) << 40) \|
259			((x & UVAL64(0x00000000000000ff)) << 56) );
260			}
261
262			#ifdef WORDS_BIGENDIAN
263			static inline uint16 tswap16(uint16 x) { return x; }
264			static inline uint32 tswap32(uint32 x) { return x; }
265			static inline uint64 tswap64(uint64 x) { return x; }
266			#else
267			static inline uint16 tswap16(uint16 x) { return bswap_16(x); }
268			static inline uint32 tswap32(uint32 x) { return bswap_32(x); }
269			static inline uint64 tswap64(uint64 x) { return bswap_64(x); }
270	gbeauche	1.3	#endif
271	cebix	1.1
272	gbeauche	1.6	// spin locks
273			#ifdef __GNUC__
274
275	gbeauche	1.22	#if defined(__powerpc__) \|\| defined(__ppc__)
276	gbeauche	1.6	#define HAVE_TEST_AND_SET 1
277	gbeauche	1.20	static inline int testandset(volatile int *p)
278	gbeauche	1.6	{
279			int ret;
280	gbeauche	1.22	__asm__ __volatile__("0: lwarx %0,0,%1\n"
281			" xor. %0,%3,%0\n"
282			" bne 1f\n"
283			" stwcx. %2,0,%1\n"
284			" bne- 0b\n"
285	gbeauche	1.6	"1: "
286			: "=&r" (ret)
287			: "r" (p), "r" (1), "r" (0)
288			: "cr0", "memory");
289			return ret;
290			}
291			#endif
292
293	gbeauche	1.45	#if defined(__i386__) \|\| defined(__x86_64__)
294	gbeauche	1.6	#define HAVE_TEST_AND_SET 1
295	gbeauche	1.20	static inline int testandset(volatile int *p)
296	gbeauche	1.6	{
297	gbeauche	1.31	long int ret;
298	gbeauche	1.20	/* Note: the "xchg" instruction does not need a "lock" prefix */
299	gbeauche	1.31	__asm__ __volatile__("xchgl %k0, %1"
300			: "=r" (ret), "=m" (*p)
301	gbeauche	1.20	: "0" (1), "m" (*p)
302	gbeauche	1.6	: "memory");
303			return ret;
304			}
305			#endif
306
307			#ifdef __s390__
308			#define HAVE_TEST_AND_SET 1
309	gbeauche	1.20	static inline int testandset(volatile int *p)
310	gbeauche	1.6	{
311			int ret;
312
313			__asm__ __volatile__("0: cs %0,%1,0(%2)\n"
314			" jl 0b"
315			: "=&d" (ret)
316			: "r" (1), "a" (p), "0" (*p)
317			: "cc", "memory" );
318			return ret;
319			}
320			#endif
321
322			#ifdef __alpha__
323			#define HAVE_TEST_AND_SET 1
324	gbeauche	1.20	static inline int testandset(volatile int *p)
325	gbeauche	1.6	{
326			int ret;
327			unsigned long one;
328
329			__asm__ __volatile__("0: mov 1,%2\n"
330			" ldl_l %0,%1\n"
331			" stl_c %2,%1\n"
332			" beq %2,1f\n"
333			".subsection 2\n"
334			"1: br 0b\n"
335			".previous"
336			: "=r" (ret), "=m" (*p), "=r" (one)
337			: "m" (*p));
338			return ret;
339			}
340			#endif
341
342			#ifdef __sparc__
343			#define HAVE_TEST_AND_SET 1
344	gbeauche	1.20	static inline int testandset(volatile int *p)
345	gbeauche	1.6	{
346			int ret;
347
348			__asm__ __volatile__("ldstub [%1], %0"
349			: "=r" (ret)
350			: "r" (p)
351			: "memory");
352
353			return (ret ? 1 : 0);
354			}
355			#endif
356
357			#ifdef __arm__
358			#define HAVE_TEST_AND_SET 1
359	gbeauche	1.20	static inline int testandset(volatile int *p)
360	gbeauche	1.6	{
361			register unsigned int ret;
362			__asm__ __volatile__("swp %0, %1, [%2]"
363			: "=r"(ret)
364			: "0"(1), "r"(p));
365
366			return ret;
367			}
368			#endif
369
370			#endif /* __GNUC__ */
371
372	gbeauche	1.20	typedef volatile int spinlock_t;
373	gbeauche	1.6
374	gbeauche	1.8	static const spinlock_t SPIN_LOCK_UNLOCKED = 0;
375	gbeauche	1.6
376	gbeauche	1.44	#if defined(HAVE_TEST_AND_SET) && defined(HAVE_PTHREADS)
377			// There is nothing to lock if we are not in an multithreaded environment
378	gbeauche	1.32	#define HAVE_SPINLOCKS 1
379	gbeauche	1.6	static inline void spin_lock(spinlock_t *lock)
380			{
381			while (testandset(lock));
382			}
383
384			static inline void spin_unlock(spinlock_t *lock)
385			{
386			*lock = 0;
387			}
388
389			static inline int spin_trylock(spinlock_t *lock)
390			{
391			return !testandset(lock);
392			}
393	gbeauche	1.32	#else
394			static inline void spin_lock(spinlock_t *lock)
395			{
396			}
397
398			static inline void spin_unlock(spinlock_t *lock)
399			{
400			}
401
402			static inline int spin_trylock(spinlock_t *lock)
403			{
404			return 1;
405			}
406	gbeauche	1.6	#endif
407
408	cebix	1.1	// Time data type for Time Manager emulation
409			#ifdef HAVE_CLOCK_GETTIME
410			typedef struct timespec tm_time_t;
411			#else
412			typedef struct timeval tm_time_t;
413			#endif
414
415	gbeauche	1.42	/* Define codes for all the float formats that we know of.
416			* Though we only handle IEEE format. */
417			#define UNKNOWN_FLOAT_FORMAT 0
418			#define IEEE_FLOAT_FORMAT 1
419			#define VAX_FLOAT_FORMAT 2
420			#define IBM_FLOAT_FORMAT 3
421			#define C4X_FLOAT_FORMAT 4
422
423	gbeauche	1.40	// High-precision timing
424	gbeauche	1.46	#if defined(HAVE_PTHREADS) && defined(HAVE_CLOCK_NANOSLEEP)
425	gbeauche	1.40	#define PRECISE_TIMING 1
426			#define PRECISE_TIMING_POSIX 1
427			#endif
428
429	gbeauche	1.18	// Timing functions
430			extern uint64 GetTicks_usec(void);
431			extern void Delay_usec(uint32 usec);
432
433	gbeauche	1.43	#ifdef HAVE_PTHREADS
434	cebix	1.2	// Setup pthread attributes
435			extern void Set_pthread_attr(pthread_attr_t *attr, int priority);
436	gbeauche	1.24	#endif
437	cebix	1.2
438	cebix	1.1	// Various definitions
439			typedef struct rgb_color {
440			uint8 red;
441			uint8 green;
442			uint8 blue;
443			uint8 alpha;
444			} rgb_color;
445
446	gbeauche	1.19	// X11 display fast locks
447	gbeauche	1.44	#if defined(HAVE_PTHREADS)
448			#define X11_LOCK_TYPE pthread_mutex_t
449			#define X11_LOCK_INIT PTHREAD_MUTEX_INITIALIZER
450			#define XDisplayLock() pthread_mutex_lock(&x_display_lock);
451			#define XDisplayUnlock() pthread_mutex_unlock(&x_display_lock);
452			#elif defined(HAVE_SPINLOCKS)
453	gbeauche	1.19	#define X11_LOCK_TYPE spinlock_t
454			#define X11_LOCK_INIT SPIN_LOCK_UNLOCKED
455			#define XDisplayLock() spin_lock(&x_display_lock)
456			#define XDisplayUnlock() spin_unlock(&x_display_lock)
457			#else
458			#define XDisplayLock()
459			#define XDisplayUnlock()
460			#endif
461			#ifdef X11_LOCK_TYPE
462			extern X11_LOCK_TYPE x_display_lock;
463			#endif
464
465	cebix	1.1	// Macro for calling MacOS routines
466	gbeauche	1.34	#define CallMacOS(type, tvect) call_macos((uintptr)tvect)
467			#define CallMacOS1(type, tvect, arg1) call_macos1((uintptr)tvect, (uintptr)arg1)
468			#define CallMacOS2(type, tvect, arg1, arg2) call_macos2((uintptr)tvect, (uintptr)arg1, (uintptr)arg2)
469			#define CallMacOS3(type, tvect, arg1, arg2, arg3) call_macos3((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3)
470			#define CallMacOS4(type, tvect, arg1, arg2, arg3, arg4) call_macos4((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4)
471			#define CallMacOS5(type, tvect, arg1, arg2, arg3, arg4, arg5) call_macos5((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5)
472			#define CallMacOS6(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6) call_macos6((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5, (uintptr)arg6)
473			#define CallMacOS7(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6, arg7) call_macos7((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5, (uintptr)arg6, (uintptr)arg7)
474	cebix	1.1
475	gbeauche	1.3	#ifdef __cplusplus
476			extern "C" {
477			#endif
478			extern uint32 call_macos(uint32 tvect);
479			extern uint32 call_macos1(uint32 tvect, uint32 arg1);
480			extern uint32 call_macos2(uint32 tvect, uint32 arg1, uint32 arg2);
481			extern uint32 call_macos3(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3);
482			extern uint32 call_macos4(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4);
483			extern uint32 call_macos5(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5);
484			extern uint32 call_macos6(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5, uint32 arg6);
485			extern uint32 call_macos7(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5, uint32 arg6, uint32 arg7);
486			#ifdef __cplusplus
487			}
488			#endif
489	cebix	1.1
490			#endif