ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/SheepShaver/src/Unix/sysdeps.h
(Generate patch)

Comparing SheepShaver/src/Unix/sysdeps.h (file contents):
Revision 1.3 by gbeauche, 2003-01-04T12:23:39Z vs.
Revision 1.14 by gbeauche, 2003-11-11T11:32:24Z

# Line 59 | Line 59
59   # endif
60   #endif
61  
62 < // Are we using a PPC emulator or the real thing?
63 < #ifdef __powerpc__
64 < #define EMULATED_PPC 0
65 < #else
66 < #define EMULATED_PPC 1
67 < #endif
62 > // Define for external components
63 > #define SHEEPSHAVER 1
64 >
65 > // Mac and host address space are the same
66 > #define REAL_ADDRESSING 1
67  
68   #define POWERPC_ROM 1
69  
70 + #if EMULATED_PPC
71 + // Handle interrupts asynchronously?
72 + #define ASYNC_IRQ 0
73 + // Mac ROM is write protected when banked memory is used
74 + #if REAL_ADDRESSING || DIRECT_ADDRESSING
75 + # define ROM_IS_WRITE_PROTECTED 0
76 + # define USE_SCRATCHMEM_SUBTERFUGE 1
77 + #else
78 + # define ROM_IS_WRITE_PROTECTED 1
79 + #endif
80 + // Configure PowerPC emulator
81 + #define PPC_CHECK_INTERRUPTS (ASYNC_IRQ ? 0 : 1)
82 + #define PPC_DECODE_CACHE 1
83 + #define PPC_FLIGHT_RECORDER 1
84 + #else
85 + // Mac ROM is write protected
86 + #define ROM_IS_WRITE_PROTECTED 1
87 + #define USE_SCRATCHMEM_SUBTERFUGE 0
88 + #endif
89 +
90   // Data types
91   typedef unsigned char uint8;
92   typedef signed char int8;
# Line 112 | Line 131 | typedef int64 intptr;
131   #error "Unsupported size of pointer"
132   #endif
133  
134 + // Helper functions to byteswap data
135 + #ifdef HAVE_BYTESWAP_H
136 + #include <byteswap.h>
137 + #endif
138 +
139 + #ifndef bswap_16
140 + #define bswap_16 generic_bswap_16
141 + #endif
142 +
143 + static inline uint16 generic_bswap_16(uint16 x)
144 + {
145 +  return ((x & 0xff) << 8) | ((x >> 8) & 0xff);
146 + }
147 +
148 + #ifndef bswap_32
149 + #define bswap_32 generic_bswap_32
150 + #endif
151 +
152 + static inline uint32 generic_bswap_32(uint32 x)
153 + {
154 +  return (((x & 0xff000000) >> 24) |
155 +                  ((x & 0x00ff0000) >>  8) |
156 +                  ((x & 0x0000ff00) <<  8) |
157 +                  ((x & 0x000000ff) << 24) );
158 + }
159 +
160 + #ifndef bswap_64
161 + #define bswap_64 generic_bswap_64
162 + #endif
163 +
164 + static inline uint64 generic_bswap_64(uint64 x)
165 + {
166 +  return (((x & UVAL64(0xff00000000000000)) >> 56) |
167 +                  ((x & UVAL64(0x00ff000000000000)) >> 40) |
168 +                  ((x & UVAL64(0x0000ff0000000000)) >> 24) |
169 +                  ((x & UVAL64(0x000000ff00000000)) >>  8) |
170 +                  ((x & UVAL64(0x00000000ff000000)) <<  8) |
171 +                  ((x & UVAL64(0x0000000000ff0000)) << 24) |
172 +                  ((x & UVAL64(0x000000000000ff00)) << 40) |
173 +                  ((x & UVAL64(0x00000000000000ff)) << 56) );
174 + }
175 +
176 + #ifdef WORDS_BIGENDIAN
177 + static inline uint16 tswap16(uint16 x) { return x; }
178 + static inline uint32 tswap32(uint32 x) { return x; }
179 + static inline uint64 tswap64(uint64 x) { return x; }
180 + #else
181 + static inline uint16 tswap16(uint16 x) { return bswap_16(x); }
182 + static inline uint32 tswap32(uint32 x) { return bswap_32(x); }
183 + static inline uint64 tswap64(uint64 x) { return bswap_64(x); }
184 + #endif
185 +
186 + // spin locks
187 + #ifdef __GNUC__
188 +
189 + #ifdef __powerpc__
190 + #define HAVE_TEST_AND_SET 1
191 + static inline int testandset(int *p)
192 + {
193 +        int ret;
194 +        __asm__ __volatile__("0:    lwarx %0,0,%1 ;"
195 +                                                 "      xor. %0,%3,%0;"
196 +                                                 "      bne 1f;"
197 +                                                 "      stwcx. %2,0,%1;"
198 +                                                 "      bne- 0b;"
199 +                                                 "1:    "
200 +                                                 : "=&r" (ret)
201 +                                                 : "r" (p), "r" (1), "r" (0)
202 +                                                 : "cr0", "memory");
203 +        return ret;
204 + }
205 + #endif
206 +
207 + #ifdef __i386__
208 + #define HAVE_TEST_AND_SET 1
209 + static inline int testandset(int *p)
210 + {
211 +        char ret;
212 +        long int readval;
213 +        
214 +        __asm__ __volatile__("lock; cmpxchgl %3, %1; sete %0"
215 +                                                 : "=q" (ret), "=m" (*p), "=a" (readval)
216 +                                                 : "r" (1), "m" (*p), "a" (0)
217 +                                                 : "memory");
218 +        return ret;
219 + }
220 + #endif
221 +
222 + #ifdef __s390__
223 + #define HAVE_TEST_AND_SET 1
224 + static inline int testandset(int *p)
225 + {
226 +        int ret;
227 +
228 +        __asm__ __volatile__("0: cs    %0,%1,0(%2)\n"
229 +                                                 "   jl    0b"
230 +                                                 : "=&d" (ret)
231 +                                                 : "r" (1), "a" (p), "0" (*p)
232 +                                                 : "cc", "memory" );
233 +        return ret;
234 + }
235 + #endif
236 +
237 + #ifdef __alpha__
238 + #define HAVE_TEST_AND_SET 1
239 + static inline int testandset(int *p)
240 + {
241 +        int ret;
242 +        unsigned long one;
243 +
244 +        __asm__ __volatile__("0:        mov 1,%2\n"
245 +                                                 "      ldl_l %0,%1\n"
246 +                                                 "      stl_c %2,%1\n"
247 +                                                 "      beq %2,1f\n"
248 +                                                 ".subsection 2\n"
249 +                                                 "1:    br 0b\n"
250 +                                                 ".previous"
251 +                                                 : "=r" (ret), "=m" (*p), "=r" (one)
252 +                                                 : "m" (*p));
253 +        return ret;
254 + }
255 + #endif
256 +
257 + #ifdef __sparc__
258 + #define HAVE_TEST_AND_SET 1
259 + static inline int testandset(int *p)
260 + {
261 +        int ret;
262 +
263 +        __asm__ __volatile__("ldstub    [%1], %0"
264 +                                                 : "=r" (ret)
265 +                                                 : "r" (p)
266 +                                                 : "memory");
267 +
268 +        return (ret ? 1 : 0);
269 + }
270 + #endif
271 +
272 + #ifdef __arm__
273 + #define HAVE_TEST_AND_SET 1
274 + static inline int testandset(int *p)
275 + {
276 +        register unsigned int ret;
277 +        __asm__ __volatile__("swp %0, %1, [%2]"
278 +                                                 : "=r"(ret)
279 +                                                 : "0"(1), "r"(p));
280 +        
281 +        return ret;
282 + }
283 + #endif
284 +
285 + #endif /* __GNUC__ */
286 +
287 + #if HAVE_TEST_AND_SET
288 + #define HAVE_SPINLOCKS 1
289 + typedef int spinlock_t;
290 +
291 + static const spinlock_t SPIN_LOCK_UNLOCKED = 0;
292 +
293 + static inline void spin_lock(spinlock_t *lock)
294 + {
295 +        while (testandset(lock));
296 + }
297 +
298 + static inline void spin_unlock(spinlock_t *lock)
299 + {
300 +        *lock = 0;
301 + }
302 +
303 + static inline int spin_trylock(spinlock_t *lock)
304 + {
305 +        return !testandset(lock);
306 + }
307 + #endif
308 +
309   // Time data type for Time Manager emulation
310   #ifdef HAVE_CLOCK_GETTIME
311   typedef struct timespec tm_time_t;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines