src/kpx_cpu/spcflags.h

 /*
  * UAE - The Un*x Amiga Emulator
  *
  * MC68000 emulation
  *
  * Copyright 1995 Bernd Schmidt
  */

#ifndef SPCFLAGS_H
#define SPCFLAGS_H

typedef uint32 spcflags_t;

enum {
        SPCFLAG_STOP                            = 0x01,
        SPCFLAG_INT                                     = 0x02,
        SPCFLAG_DOINT                           = 0x04,
        SPCFLAG_ENTER_MON                       = 0x08,
#if USE_JIT
        SPCFLAG_JIT_END_COMPILE         = 0x40,
        SPCFLAG_JIT_EXEC_RETURN         = 0x80,
#else
        SPCFLAG_JIT_END_COMPILE         = 0,
        SPCFLAG_JIT_EXEC_RETURN         = 0,
#endif
        
        SPCFLAG_ALL                                     = SPCFLAG_STOP
                                                                | SPCFLAG_INT
                                                                | SPCFLAG_DOINT
                                                                | SPCFLAG_ENTER_MON
                                                                | SPCFLAG_JIT_END_COMPILE
                                                                | SPCFLAG_JIT_EXEC_RETURN
                                                                ,
        
        SPCFLAG_ALL_BUT_EXEC_RETURN     = SPCFLAG_ALL & ~SPCFLAG_JIT_EXEC_RETURN
};

#define SPCFLAGS_TEST(m) \
        ((sheepshaver_cpu::spcflags & (m)) != 0)

/* Macro only used in m68k_reset() */
#define SPCFLAGS_INIT(m) do { \
        sheepshaver_cpu::spcflags = (m); \
} while (0)

#if !(ENABLE_EXCLUSIVE_SPCFLAGS)

#define SPCFLAGS_SET(m) do { \
        sheepshaver_cpu::spcflags |= (m); \
} while (0)

#define SPCFLAGS_CLEAR(m) do { \
        sheepshaver_cpu::spcflags &= ~(m); \
} while (0)

#elif defined(__i386__) && defined(X86_ASSEMBLY)

#define HAVE_HARDWARE_LOCKS

#define SPCFLAGS_SET(m) do { \
        __asm__ __volatile__("lock\n\torl %1,%0" : "=m" (sheepshaver_cpu::spcflags) : "i" ((m))); \
} while (0)

#define SPCFLAGS_CLEAR(m) do { \
        __asm__ __volatile__("lock\n\tandl %1,%0" : "=m" (sheepshaver_cpu::spcflags) : "i" (~(m))); \
} while (0)

#else

#undef HAVE_HARDWARE_LOCKS

#include "main.h"
extern B2_mutex *spcflags_lock;

#define SPCFLAGS_SET(m) do {                            \
        B2_lock_mutex(spcflags_lock);                   \
        sheepshaver_cpu::spcflags |= (m);               \
        B2_unlock_mutex(spcflags_lock);                 \
} while (0)

#define SPCFLAGS_CLEAR(m) do {                          \
        B2_lock_mutex(spcflags_lock);                   \
        sheepshaver_cpu::spcflags &= ~(m);              \
        B2_unlock_mutex(spcflags_lock);                 \
} while (0)

#endif

#endif /* SPCFLAGS_H */
Revision:	1.2
Committed:	2003-11-01T15:15:27Z (20 years, 7 months ago) by gbeauche
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	Integrate spcflags handling code to kpx_cpu core. We can also remove oldish EXEC_RETURN handling with a throw/catch mechanism since we do have a dependency on extra conditions (invalidated cache) that prevents fast execution loops.
#	Content
1	/*
2	* UAE - The Un*x Amiga Emulator
3	*
4	* MC68000 emulation
5	*
6	* Copyright 1995 Bernd Schmidt
7	*/
8
9	#ifndef SPCFLAGS_H
10	#define SPCFLAGS_H
11
12	typedef uint32 spcflags_t;
13
14	enum {
15	SPCFLAG_STOP = 0x01,
16	SPCFLAG_INT = 0x02,
17	SPCFLAG_DOINT = 0x04,
18	SPCFLAG_ENTER_MON = 0x08,
19	#if USE_JIT
20	SPCFLAG_JIT_END_COMPILE = 0x40,
21	SPCFLAG_JIT_EXEC_RETURN = 0x80,
22	#else
23	SPCFLAG_JIT_END_COMPILE = 0,
24	SPCFLAG_JIT_EXEC_RETURN = 0,
25	#endif
26
27	SPCFLAG_ALL = SPCFLAG_STOP
28	\| SPCFLAG_INT
29	\| SPCFLAG_DOINT
30	\| SPCFLAG_ENTER_MON
31	\| SPCFLAG_JIT_END_COMPILE
32	\| SPCFLAG_JIT_EXEC_RETURN
33	,
34
35	SPCFLAG_ALL_BUT_EXEC_RETURN = SPCFLAG_ALL & ~SPCFLAG_JIT_EXEC_RETURN
36	};
37
38	#define SPCFLAGS_TEST(m) \
39	((sheepshaver_cpu::spcflags & (m)) != 0)
40
41	/* Macro only used in m68k_reset() */
42	#define SPCFLAGS_INIT(m) do { \
43	sheepshaver_cpu::spcflags = (m); \
44	} while (0)
45
46	#if !(ENABLE_EXCLUSIVE_SPCFLAGS)
47
48	#define SPCFLAGS_SET(m) do { \
49	sheepshaver_cpu::spcflags \|= (m); \
50	} while (0)
51
52	#define SPCFLAGS_CLEAR(m) do { \
53	sheepshaver_cpu::spcflags &= ~(m); \
54	} while (0)
55
56	#elif defined(__i386__) && defined(X86_ASSEMBLY)
57
58	#define HAVE_HARDWARE_LOCKS
59
60	#define SPCFLAGS_SET(m) do { \
61	__asm__ __volatile__("lock\n\torl %1,%0" : "=m" (sheepshaver_cpu::spcflags) : "i" ((m))); \
62	} while (0)
63
64	#define SPCFLAGS_CLEAR(m) do { \
65	__asm__ __volatile__("lock\n\tandl %1,%0" : "=m" (sheepshaver_cpu::spcflags) : "i" (~(m))); \
66	} while (0)
67
68	#else
69
70	#undef HAVE_HARDWARE_LOCKS
71
72	#include "main.h"
73	extern B2_mutex *spcflags_lock;
74
75	#define SPCFLAGS_SET(m) do { \
76	B2_lock_mutex(spcflags_lock); \
77	sheepshaver_cpu::spcflags \|= (m); \
78	B2_unlock_mutex(spcflags_lock); \
79	} while (0)
80
81	#define SPCFLAGS_CLEAR(m) do { \
82	B2_lock_mutex(spcflags_lock); \
83	sheepshaver_cpu::spcflags &= ~(m); \
84	B2_unlock_mutex(spcflags_lock); \
85	} while (0)
86
87	#endif
88
89	#endif /* SPCFLAGS_H */