summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/cpu/drcumlsh.h
blob: 2a9a3f3c9410aa5b51a93f229720098e8c74b41c (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
/***************************************************************************

    drcumlsh.h

    Shorthand definitions for the universal machine language.

    Copyright Aaron Giles
    Released for general non-commercial use under the MAME license
    Visit http://mamedev.org for licensing and usage restrictions.

***************************************************************************/

#pragma once

#ifndef __DRCUMLSH_H__
#define __DRCUMLSH_H__

#include "drcuml.h"



/***************************************************************************
    CONSTANTS
***************************************************************************/

/* shorthand for conditions */
#define IF_Z		DRCUML_COND_Z
#define IF_NZ		DRCUML_COND_NZ
#define IF_S		DRCUML_COND_S
#define IF_NS		DRCUML_COND_NS
#define IF_C		DRCUML_COND_C
#define IF_NC		DRCUML_COND_NC
#define IF_V		DRCUML_COND_V
#define IF_NV		DRCUML_COND_NV
#define IF_U		DRCUML_COND_U
#define IF_NU		DRCUML_COND_NU
#define IF_E		DRCUML_COND_E
#define IF_NE		DRCUML_COND_NE
#define IF_A		DRCUML_COND_A
#define IF_AE		DRCUML_COND_AE
#define IF_B		DRCUML_COND_B
#define IF_BE		DRCUML_COND_BE
#define IF_G		DRCUML_COND_G
#define IF_GE		DRCUML_COND_GE
#define IF_L		DRCUML_COND_L
#define IF_LE		DRCUML_COND_LE
#define IF_ALWAYS	DRCUML_COND_ALWAYS



/***************************************************************************
    MACROS
***************************************************************************/

/* macros for wrapping parameters */
#define NONE				DRCUML_PTYPE_NONE, 0
#define IMM(x)				DRCUML_PTYPE_IMMEDIATE, (x)
#define IREG(x)				DRCUML_PTYPE_INT_REGISTER, (DRCUML_REG_I0 + (x))
#define FREG(x)				DRCUML_PTYPE_FLOAT_REGISTER, (DRCUML_REG_F0 + (x))
#define MVAR(x)				DRCUML_PTYPE_MAPVAR, (DRCUML_MAPVAR_M0 + (x))
#define MEM(x)				DRCUML_PTYPE_MEMORY, (FPTR)(x)
#define PARAM(t,v)			(t), (v)



/***************************************************************************
    INLINE FUNCTIONS
***************************************************************************/

/* ----- Compile-time Opcodes ----- */
#define UML_HANDLE(block, handle)							do { drcuml_block_append_1(block, DRCUML_OP_HANDLE,  4, IF_ALWAYS,  MEM(handle)); } while (0)
#define UML_HASH(block, mode, pc)							do { drcuml_block_append_2(block, DRCUML_OP_HASH,    4, IF_ALWAYS,  IMM(mode), IMM(pc)); } while (0)
#define UML_LABEL(block, label)								do { drcuml_block_append_1(block, DRCUML_OP_LABEL,   4, IF_ALWAYS,  IMM(label)); } while (0)
#define UML_COMMENT/*(block, format, ...)*/					drcuml_add_comment
#define UML_MAPVAR(block, mapvar, value)					do { drcuml_block_append_2(block, DRCUML_OP_MAPVAR,  4, IF_ALWAYS,  mapvar, IMM(value)); } while (0)


/* ----- Control Flow Operations ----- */
#define UML_NOP(block)										do { drcuml_block_append_0(block, DRCUML_OP_NOP,     4, IF_ALWAYS); } while (0)
#define UML_DEBUG(block, pc)								do { drcuml_block_append_1(block, DRCUML_OP_DEBUG,   4, IF_ALWAYS,  pc); } while (0)
#define UML_EXIT(block, param)								do { drcuml_block_append_1(block, DRCUML_OP_EXIT,    4, IF_ALWAYS,  param); } while (0)
#define UML_EXITc(block, cond, param)						do { drcuml_block_append_1(block, DRCUML_OP_EXIT,    4, cond,       param); } while (0)
#define UML_HASHJMP(block, mode, pc, handle)				do { drcuml_block_append_3(block, DRCUML_OP_HASHJMP, 4, IF_ALWAYS,  mode, pc, MEM(handle)); } while (0)
#define UML_JMP(block, label)								do { drcuml_block_append_1(block, DRCUML_OP_JMP,     4, IF_ALWAYS,  IMM(label)); } while (0)
#define UML_JMPc(block, cond, label)						do { drcuml_block_append_1(block, DRCUML_OP_JMP,     4, cond,       IMM(label)); } while (0)
#define UML_JMPH(block, handle)								do { drcuml_block_append_1(block, DRCUML_OP_JMPH,    4, IF_ALWAYS,  MEM(handle)); } while (0)
#define UML_JMPHc(block, cond, handle)						do { drcuml_block_append_1(block, DRCUML_OP_JMPH,    4, cond,       MEM(handle)); } while (0)
#define UML_EXH(block, handle, param)						do { drcuml_block_append_2(block, DRCUML_OP_EXH,     4, IF_ALWAYS,  MEM(handle), param); } while (0)
#define UML_EXHc(block, cond, handle, param)				do { drcuml_block_append_2(block, DRCUML_OP_EXH,     4, cond,       MEM(handle), param); } while (0)
#define UML_CALLH(block, handle)							do { drcuml_block_append_1(block, DRCUML_OP_CALLH,   4, IF_ALWAYS,  MEM(handle)); } while (0)
#define UML_CALLHc(block, cond, handle)						do { drcuml_block_append_1(block, DRCUML_OP_CALLH,   4, cond,       MEM(handle)); } while (0)
#define UML_RET(block)										do { drcuml_block_append_0(block, DRCUML_OP_RET,     4, IF_ALWAYS); } while (0)
#define UML_RETc(block, cond)								do { drcuml_block_append_0(block, DRCUML_OP_RET,     4, cond); } while (0)
#define UML_CALLC(block, func, ptr)							do { drcuml_block_append_2(block, DRCUML_OP_CALLC,   4, IF_ALWAYS,  MEM(func), MEM(ptr)); } while (0)
#define UML_CALLCc(block, cond, func, ptr)					do { drcuml_block_append_2(block, DRCUML_OP_CALLC,   4, cond,       MEM(func), MEM(ptr)); } while (0)
#define UML_RECOVER(block, dst, mapvar)						do { drcuml_block_append_2(block, DRCUML_OP_RECOVER, 4, IF_ALWAYS,  dst, mapvar); } while (0)


/* ----- Internal Register Operations ----- */
#define UML_SETFMOD(block, mode)							do { drcuml_block_append_1(block, DRCUML_OP_SETFMOD, 4, IF_ALWAYS,  mode); } while (0)
#define UML_GETFMOD(block, dst)								do { drcuml_block_append_1(block, DRCUML_OP_GETFMOD, 4, IF_ALWAYS,  dst); } while (0)
#define UML_GETEXP(block, dst)								do { drcuml_block_append_1(block, DRCUML_OP_GETEXP,  4, IF_ALWAYS,  dst); } while (0)
#define UML_GETFLGS(block, dst, flags)						do { drcuml_block_append_2(block, DRCUML_OP_GETFLGS, 4, IF_ALWAYS,  dst, IMM(flags)); } while (0)
#define UML_SAVE(block, dst)								do { drcuml_block_append_1(block, DRCUML_OP_SAVE,    4, IF_ALWAYS,  MEM(dst)); } while (0)
#define UML_RESTORE(block, src)								do { drcuml_block_append_1(block, DRCUML_OP_RESTORE, 4, IF_ALWAYS,  MEM(src)); } while (0)


/* ----- 32-Bit Integer Operations ----- */
#define UML_LOAD(block, dst, base, index, size)				do { drcuml_block_append_4(block, DRCUML_OP_LOAD,    4, IF_ALWAYS,  dst, MEM(base), index, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_LOADS(block, dst, base, index, size)			do { drcuml_block_append_4(block, DRCUML_OP_LOADS,   4, IF_ALWAYS,  dst, MEM(base), index, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_STORE(block, base, index, src1, size)			do { drcuml_block_append_4(block, DRCUML_OP_STORE,   4, IF_ALWAYS,  MEM(base), index, src1, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_READ(block, dst, src1, spsize)					do { drcuml_block_append_3(block, DRCUML_OP_READ,    4, IF_ALWAYS,  dst, src1, IMM(DRCUML_SPSIZE_##spsize)); } while (0)
#define UML_READM(block, dst, src1, mask, spsize)			do { drcuml_block_append_4(block, DRCUML_OP_READM,   4, IF_ALWAYS,  dst, src1, mask, IMM(DRCUML_SPSIZE_##spsize)); } while (0)
#define UML_WRITE(block, dst, src1, spsize)					do { drcuml_block_append_3(block, DRCUML_OP_WRITE,   4, IF_ALWAYS,  dst, src1, IMM(DRCUML_SPSIZE_##spsize)); } while (0)
#define UML_WRITEM(block, dst, src1, mask, spsize)			do { drcuml_block_append_4(block, DRCUML_OP_WRITEM,  4, IF_ALWAYS,  dst, src1, mask, IMM(DRCUML_SPSIZE_##spsize)); } while (0)
#define UML_CARRY(block, src, bitnum)						do { drcuml_block_append_2(block, DRCUML_OP_CARRY,   4, IF_ALWAYS,  src, bitnum); } while (0)
#define UML_SETc(block, cond, dst)							do { drcuml_block_append_1(block, DRCUML_OP_SET,     4, cond,       dst); } while (0)
#define UML_MOV(block, dst, src1)							do { drcuml_block_append_2(block, DRCUML_OP_MOV,     4, IF_ALWAYS,  dst, src1); } while (0)
#define UML_MOVc(block, cond, dst, src1)					do { drcuml_block_append_2(block, DRCUML_OP_MOV,     4, cond,       dst, src1); } while (0)
#define UML_SEXT(block, dst, src1, size)					do { drcuml_block_append_3(block, DRCUML_OP_SEXT,    4, IF_ALWAYS,  dst, src1, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_ROLAND(block, dst, src, shift, mask)			do { drcuml_block_append_4(block, DRCUML_OP_ROLAND,  4, IF_ALWAYS,  dst, src, shift, mask); } while (0)
#define UML_ROLINS(block, dst, src, shift, mask)			do { drcuml_block_append_4(block, DRCUML_OP_ROLINS,  4, IF_ALWAYS,  dst, src, shift, mask); } while (0)
#define UML_ADD(block, dst, src1, src2)						do { drcuml_block_append_3(block, DRCUML_OP_ADD,     4, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_ADDC(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_ADDC,    4, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_SUB(block, dst, src1, src2)						do { drcuml_block_append_3(block, DRCUML_OP_SUB,     4, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_SUBB(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_SUBB,    4, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_CMP(block, src1, src2)							do { drcuml_block_append_2(block, DRCUML_OP_CMP,     4, IF_ALWAYS,  src1, src2); } while (0)
#define UML_MULU(block, dst, edst, src1, src2)				do { drcuml_block_append_4(block, DRCUML_OP_MULU,    4, IF_ALWAYS,  dst, edst, src1, src2); } while (0)
#define UML_MULS(block, dst, edst, src1, src2)				do { drcuml_block_append_4(block, DRCUML_OP_MULS,    4, IF_ALWAYS,  dst, edst, src1, src2); } while (0)
#define UML_DIVU(block, dst, edst, src1, src2)				do { drcuml_block_append_4(block, DRCUML_OP_DIVU,    4, IF_ALWAYS,  dst, edst, src1, src2); } while (0)
#define UML_DIVS(block, dst, edst, src1, src2)				do { drcuml_block_append_4(block, DRCUML_OP_DIVS,    4, IF_ALWAYS,  dst, edst, src1, src2); } while (0)
#define UML_AND(block, dst, src1, src2)						do { drcuml_block_append_3(block, DRCUML_OP_AND,     4, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_TEST(block, src1, src2)							do { drcuml_block_append_2(block, DRCUML_OP_TEST,    4, IF_ALWAYS,  src1, src2); } while (0)
#define UML_OR(block, dst, src1, src2)						do { drcuml_block_append_3(block, DRCUML_OP_OR,      4, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_XOR(block, dst, src1, src2)						do { drcuml_block_append_3(block, DRCUML_OP_XOR,     4, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_LZCNT(block, dst, src)							do { drcuml_block_append_2(block, DRCUML_OP_LZCNT,   4, IF_ALWAYS,  dst, src); } while (0)
#define UML_BSWAP(block, dst, src)							do { drcuml_block_append_2(block, DRCUML_OP_BSWAP,   4, IF_ALWAYS,  dst, src); } while (0)
#define UML_SHL(block, dst, src, count)						do { drcuml_block_append_3(block, DRCUML_OP_SHL,     4, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_SHR(block, dst, src, count)						do { drcuml_block_append_3(block, DRCUML_OP_SHR,     4, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_SAR(block, dst, src, count)						do { drcuml_block_append_3(block, DRCUML_OP_SAR,     4, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_ROL(block, dst, src, count)						do { drcuml_block_append_3(block, DRCUML_OP_ROL,     4, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_ROLC(block, dst, src, count)					do { drcuml_block_append_3(block, DRCUML_OP_ROLC,    4, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_ROR(block, dst, src, count)						do { drcuml_block_append_3(block, DRCUML_OP_ROR,     4, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_RORC(block, dst, src, count)					do { drcuml_block_append_3(block, DRCUML_OP_RORC,    4, IF_ALWAYS,  dst, src, count); } while (0)


/* ----- 64-Bit Integer Operations ----- */
#define UML_DLOAD(block, dst, base, index, size)			do { drcuml_block_append_4(block, DRCUML_OP_LOAD,    8, IF_ALWAYS,  dst, MEM(base), index, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_DLOADS(block, dst, base, index, size)			do { drcuml_block_append_4(block, DRCUML_OP_LOADS,   8, IF_ALWAYS,  dst, MEM(base), index, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_DSTORE(block, base, index, src1, size)			do { drcuml_block_append_4(block, DRCUML_OP_STORE,   8, IF_ALWAYS,  MEM(base), index, src1, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_DREAD(block, dst, src1, spsize)					do { drcuml_block_append_3(block, DRCUML_OP_READ,    8, IF_ALWAYS,  dst, src1, IMM(DRCUML_SPSIZE_##spsize)); } while (0)
#define UML_DREADM(block, dst, src1, mask, spsize)			do { drcuml_block_append_4(block, DRCUML_OP_READM,   8, IF_ALWAYS,  dst, src1, mask, IMM(DRCUML_SPSIZE_##spsize)); } while (0)
#define UML_DWRITE(block, dst, src1, spsize)				do { drcuml_block_append_3(block, DRCUML_OP_WRITE,   8, IF_ALWAYS,  dst, src1, IMM(DRCUML_SPSIZE_##spsize)); } while (0)
#define UML_DWRITEM(block, dst, src1, mask, spsize)			do { drcuml_block_append_4(block, DRCUML_OP_WRITEM,  8, IF_ALWAYS,  dst, src1, mask, IMM(DRCUML_SPSIZE_##spsize)); } while (0)
#define UML_DCARRY(block, src, bitnum)						do { drcuml_block_append_2(block, DRCUML_OP_CARRY,   8, IF_ALWAYS,  src, bitnum); } while (0)
#define UML_DSETc(block, cond, dst)							do { drcuml_block_append_1(block, DRCUML_OP_SET,     8, cond,       dst); } while (0)
#define UML_DMOV(block, dst, src1)							do { drcuml_block_append_2(block, DRCUML_OP_MOV,     8, IF_ALWAYS,  dst, src1); } while (0)
#define UML_DMOVc(block, cond, dst, src1)					do { drcuml_block_append_2(block, DRCUML_OP_MOV,     8, cond,       dst, src1); } while (0)
#define UML_DSEXT(block, dst, src1, size)					do { drcuml_block_append_3(block, DRCUML_OP_SEXT,    8, IF_ALWAYS,  dst, src1, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_DROLAND(block, dst, src, shift, mask)			do { drcuml_block_append_4(block, DRCUML_OP_ROLAND,  8, IF_ALWAYS,  dst, src, shift, mask); } while (0)
#define UML_DROLINS(block, dst, src, shift, mask)			do { drcuml_block_append_4(block, DRCUML_OP_ROLINS,  8, IF_ALWAYS,  dst, src, shift, mask); } while (0)
#define UML_DADD(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_ADD,     8, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_DADDC(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_ADDC,    8, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_DSUB(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_SUB,     8, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_DSUBB(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_SUBB,    8, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_DCMP(block, src1, src2)							do { drcuml_block_append_2(block, DRCUML_OP_CMP,     8, IF_ALWAYS,  src1, src2); } while (0)
#define UML_DMULU(block, dst, edst, src1, src2)				do { drcuml_block_append_4(block, DRCUML_OP_MULU,    8, IF_ALWAYS,  dst, edst, src1, src2); } while (0)
#define UML_DMULS(block, dst, edst, src1, src2)				do { drcuml_block_append_4(block, DRCUML_OP_MULS,    8, IF_ALWAYS,  dst, edst, src1, src2); } while (0)
#define UML_DDIVU(block, dst, edst, src1, src2)				do { drcuml_block_append_4(block, DRCUML_OP_DIVU,    8, IF_ALWAYS,  dst, edst, src1, src2); } while (0)
#define UML_DDIVS(block, dst, edst, src1, src2)				do { drcuml_block_append_4(block, DRCUML_OP_DIVS,    8, IF_ALWAYS,  dst, edst, src1, src2); } while (0)
#define UML_DAND(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_AND,     8, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_DTEST(block, src1, src2)						do { drcuml_block_append_2(block, DRCUML_OP_TEST,    8, IF_ALWAYS,  src1, src2); } while (0)
#define UML_DOR(block, dst, src1, src2)						do { drcuml_block_append_3(block, DRCUML_OP_OR,      8, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_DXOR(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_XOR,     8, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_DSHL(block, dst, src, count)					do { drcuml_block_append_3(block, DRCUML_OP_SHL,     8, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_DSHR(block, dst, src, count)					do { drcuml_block_append_3(block, DRCUML_OP_SHR,     8, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_DSAR(block, dst, src, count)					do { drcuml_block_append_3(block, DRCUML_OP_SAR,     8, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_DROL(block, dst, src, count)					do { drcuml_block_append_3(block, DRCUML_OP_ROL,     8, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_DROLC(block, dst, src, count)					do { drcuml_block_append_3(block, DRCUML_OP_ROLC,    8, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_DROR(block, dst, src, count)					do { drcuml_block_append_3(block, DRCUML_OP_ROR,     8, IF_ALWAYS,  dst, src, count); } while (0)
#define UML_DRORC(block, dst, src, count)					do { drcuml_block_append_3(block, DRCUML_OP_RORC,    8, IF_ALWAYS,  dst, src, count); } while (0)


/* ----- 32-bit Floating Point Arithmetic Operations ----- */
#define UML_FSLOAD(block, dst, base, index)					do { drcuml_block_append_3(block, DRCUML_OP_FLOAD,   4, IF_ALWAYS,  dst, MEM(base), index); } while (0)
#define UML_FSSTORE(block, base, index, src1)				do { drcuml_block_append_3(block, DRCUML_OP_FSTORE,  4, IF_ALWAYS,  MEM(base), index, src1); } while (0)
#define UML_FSREAD(block, dst, src1, space)					do { drcuml_block_append_3(block, DRCUML_OP_FREAD,   4, IF_ALWAYS,  dst, src1, IMM(ADDRESS_SPACE_##space)); } while (0)
#define UML_FSWRITE(block, dst, src1, space)				do { drcuml_block_append_3(block, DRCUML_OP_FWRITE,  4, IF_ALWAYS,  dst, src1, IMM(ADDRESS_SPACE_##space)); } while (0)
#define UML_FSMOV(block, dst, src1)							do { drcuml_block_append_2(block, DRCUML_OP_FMOV,    4, IF_ALWAYS,  dst, src1); } while (0)
#define UML_FSMOVc(block, cond, dst, src1)					do { drcuml_block_append_2(block, DRCUML_OP_FMOV,    4, cond,       dst, src1); } while (0)
#define UML_FSTOINT(block, dst, src1, size, round)			do { drcuml_block_append_4(block, DRCUML_OP_FTOINT,  4, IF_ALWAYS,  dst, src1, IMM(DRCUML_SIZE_##size), IMM(DRCUML_FMOD_##round)); } while (0)
#define UML_FSFRINT(block, dst, src1, size)					do { drcuml_block_append_3(block, DRCUML_OP_FFRINT,  4, IF_ALWAYS,  dst, src1, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_FSFRFLT(block, dst, src1, size)					do { drcuml_block_append_3(block, DRCUML_OP_FFRFLT,  4, IF_ALWAYS,  dst, src1, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_FSADD(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_FADD,    4, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_FSSUB(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_FSUB,    4, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_FSCMP(block, src1, src2)						do { drcuml_block_append_2(block, DRCUML_OP_FCMP,    4, IF_ALWAYS,  src1, src2); } while (0)
#define UML_FSMUL(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_FMUL,    4, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_FSDIV(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_FDIV,    4, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_FSNEG(block, dst, src1)							do { drcuml_block_append_2(block, DRCUML_OP_FNEG,    4, IF_ALWAYS,  dst, src1); } while (0)
#define UML_FSABS(block, dst, src1)							do { drcuml_block_append_2(block, DRCUML_OP_FABS,    4, IF_ALWAYS,  dst, src1); } while (0)
#define UML_FSSQRT(block, dst, src1)						do { drcuml_block_append_2(block, DRCUML_OP_FSQRT,   4, IF_ALWAYS,  dst, src1); } while (0)
#define UML_FSRECIP(block, dst, src1)						do { drcuml_block_append_2(block, DRCUML_OP_FRECIP,  4, IF_ALWAYS,  dst, src1); } while (0)
#define UML_FSRSQRT(block, dst, src1)						do { drcuml_block_append_2(block, DRCUML_OP_FRSQRT,  4, IF_ALWAYS,  dst, src1); } while (0)


/* ----- 64-bit Floating Point Arithmetic Operations ----- */
#define UML_FDLOAD(block, dst, base, index)					do { drcuml_block_append_3(block, DRCUML_OP_FLOAD,   8, IF_ALWAYS,  dst, MEM(base), index); } while (0)
#define UML_FDSTORE(block, base, index, src1)				do { drcuml_block_append_3(block, DRCUML_OP_FSTORE,  8, IF_ALWAYS,  MEM(base), index, src1); } while (0)
#define UML_FDREAD(block, dst, src1, space)					do { drcuml_block_append_3(block, DRCUML_OP_FREAD,   8, IF_ALWAYS,  dst, src1, IMM(ADDRESS_SPACE_##space)); } while (0)
#define UML_FDWRITE(block, dst, src1, space)				do { drcuml_block_append_3(block, DRCUML_OP_FWRITE,  8, IF_ALWAYS,  dst, src1, IMM(ADDRESS_SPACE_##space)); } while (0)
#define UML_FDMOV(block, dst, src1)							do { drcuml_block_append_2(block, DRCUML_OP_FMOV,    8, IF_ALWAYS,  dst, src1); } while (0)
#define UML_FDMOVc(block, cond, dst, src1)					do { drcuml_block_append_2(block, DRCUML_OP_FMOV,    8, cond,       dst, src1); } while (0)
#define UML_FDTOINT(block, dst, src1, size, round)			do { drcuml_block_append_4(block, DRCUML_OP_FTOINT,  8, IF_ALWAYS,  dst, src1, IMM(DRCUML_SIZE_##size), IMM(DRCUML_FMOD_##round)); } while (0)
#define UML_FDFRINT(block, dst, src1, size)					do { drcuml_block_append_3(block, DRCUML_OP_FFRINT,  8, IF_ALWAYS,  dst, src1, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_FDFRFLT(block, dst, src1, size)					do { drcuml_block_append_3(block, DRCUML_OP_FFRFLT,  8, IF_ALWAYS,  dst, src1, IMM(DRCUML_SIZE_##size)); } while (0)
#define UML_FDRNDS(block, dst, src1)						do { drcuml_block_append_2(block, DRCUML_OP_FRNDS,   8, IF_ALWAYS,  dst, src1); } while (0)
#define UML_FDADD(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_FADD,    8, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_FDSUB(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_FSUB,    8, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_FDCMP(block, src1, src2)						do { drcuml_block_append_2(block, DRCUML_OP_FCMP,    8, IF_ALWAYS,  src1, src2); } while (0)
#define UML_FDMUL(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_FMUL,    8, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_FDDIV(block, dst, src1, src2)					do { drcuml_block_append_3(block, DRCUML_OP_FDIV,    8, IF_ALWAYS,  dst, src1, src2); } while (0)
#define UML_FDNEG(block, dst, src1)							do { drcuml_block_append_2(block, DRCUML_OP_FNEG,    8, IF_ALWAYS,  dst, src1); } while (0)
#define UML_FDABS(block, dst, src1)							do { drcuml_block_append_2(block, DRCUML_OP_FABS,    8, IF_ALWAYS,  dst, src1); } while (0)
#define UML_FDSQRT(block, dst, src1)						do { drcuml_block_append_2(block, DRCUML_OP_FSQRT,   8, IF_ALWAYS,  dst, src1); } while (0)
#define UML_FDRECIP(block, dst, src1)						do { drcuml_block_append_2(block, DRCUML_OP_FRECIP,  8, IF_ALWAYS,  dst, src1); } while (0)
#define UML_FDRSQRT(block, dst, src1)						do { drcuml_block_append_2(block, DRCUML_OP_FRSQRT,  8, IF_ALWAYS,  dst, src1); } while (0)


#endif