2 * m68k micro operations
4 * Copyright (c) 2006-2007 CodeSourcery
5 * Written by Paul Brook
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include "m68k-qreg.h"
26 #define offsetof(type, field) ((size_t) &((type *)0)->field)
29 static long qreg_offsets
[] = {
30 #define DEFO32(name, offset) offsetof(CPUState, offset),
31 #define DEFR(name, reg, mode) -1,
32 #define DEFF64(name, offset) offsetof(CPUState, offset),
37 #define CPU_FP_STATUS env->fp_status
39 #define RAISE_EXCEPTION(n) do { \
40 env->exception_index = n; \
44 #define get_op helper_get_op
45 #define set_op helper_set_op
46 #define get_opf64 helper_get_opf64
47 #define set_opf64 helper_set_opf64
51 if (qreg
>= TARGET_NUM_QREGS
) {
52 return env
->qregs
[qreg
- TARGET_NUM_QREGS
];
53 } else if (qreg
== QREG_T0
) {
56 return *(uint32_t *)(((long)env
) + qreg_offsets
[qreg
]);
60 void set_op(int qreg
, uint32_t val
)
62 if (qreg
>= TARGET_NUM_QREGS
) {
63 env
->qregs
[qreg
- TARGET_NUM_QREGS
] = val
;
64 } else if (qreg
== QREG_T0
) {
67 *(uint32_t *)(((long)env
) + qreg_offsets
[qreg
]) = val
;
71 float64
get_opf64(int qreg
)
73 if (qreg
< TARGET_NUM_QREGS
) {
74 return *(float64
*)(((long)env
) + qreg_offsets
[qreg
]);
76 return *(float64
*)&env
->qregs
[qreg
- TARGET_NUM_QREGS
];
80 void set_opf64(int qreg
, float64 val
)
82 if (qreg
< TARGET_NUM_QREGS
) {
83 *(float64
*)(((long)env
) + qreg_offsets
[qreg
]) = val
;
85 *(float64
*)&env
->qregs
[qreg
- TARGET_NUM_QREGS
] = val
;
89 #define OP(name) void OPPROTO glue(op_,name) (void)
93 set_op(PARAM1
, get_op(PARAM2
));
99 set_op(PARAM1
, PARAM2
);
105 set_opf64(PARAM1
, get_opf64(PARAM2
));
111 set_opf64(PARAM1
, 0);
117 uint32_t op2
= get_op(PARAM2
);
118 uint32_t op3
= get_op(PARAM3
);
119 set_op(PARAM1
, op2
+ op3
);
125 uint32_t op2
= get_op(PARAM2
);
126 uint32_t op3
= get_op(PARAM3
);
127 set_op(PARAM1
, op2
- op3
);
133 uint32_t op2
= get_op(PARAM2
);
134 uint32_t op3
= get_op(PARAM3
);
135 set_op(PARAM1
, op2
* op3
);
141 uint32_t arg
= get_op(PARAM2
);
142 set_op(PARAM1
, ~arg
);
148 uint32_t arg
= get_op(PARAM2
);
149 set_op(PARAM1
, -arg
);
155 uint32_t arg
= get_op(PARAM2
);
156 arg
= (arg
>> 24) | (arg
<< 24)
157 | ((arg
>> 16) & 0xff00) | ((arg
<< 16) & 0xff0000);
164 uint32_t op1
= get_op(PARAM1
);
165 uint32_t op2
= get_op(PARAM2
);
167 env
->cc_dest
&= ~CCF_Z
;
169 env
->cc_dest
|= CCF_Z
;
175 uint32_t op1
= get_op(PARAM1
);
176 uint32_t op2
= get_op(PARAM2
);
179 env
->cc_x
= (op1
<= op2
);
180 env
->cc_op
= CC_OP_SUBX
;
181 res
= op1
- (op2
+ 1);
183 env
->cc_x
= (op1
< op2
);
184 env
->cc_op
= CC_OP_SUB
;
193 uint32_t op1
= get_op(PARAM1
);
194 uint32_t op2
= get_op(PARAM2
);
198 env
->cc_x
= (res
<= op2
);
199 env
->cc_op
= CC_OP_ADDX
;
202 env
->cc_x
= (res
< op2
);
203 env
->cc_op
= CC_OP_ADD
;
213 uint32_t op2
= get_op(PARAM2
);
214 uint32_t op3
= get_op(PARAM3
);
215 set_op(PARAM1
, op2
& op3
);
221 uint32_t op2
= get_op(PARAM2
);
222 uint32_t op3
= get_op(PARAM3
);
223 set_op(PARAM1
, op2
| op3
);
229 uint32_t op2
= get_op(PARAM2
);
230 uint32_t op3
= get_op(PARAM3
);
231 set_op(PARAM1
, op2
^ op3
);
238 uint32_t op2
= get_op(PARAM2
);
239 uint32_t op3
= get_op(PARAM3
);
242 set_op(PARAM1
, result
);
248 uint32_t op1
= get_op(PARAM1
);
249 uint32_t op2
= get_op(PARAM2
);
252 set_op(PARAM1
, result
);
253 env
->cc_x
= (op1
<< (op2
- 1)) & 1;
259 uint32_t op2
= get_op(PARAM2
);
260 uint32_t op3
= get_op(PARAM3
);
263 set_op(PARAM1
, result
);
269 uint32_t op1
= get_op(PARAM1
);
270 uint32_t op2
= get_op(PARAM2
);
273 set_op(PARAM1
, result
);
274 env
->cc_x
= (op1
>> (op2
- 1)) & 1;
280 int32_t op1
= get_op(PARAM1
);
281 uint32_t op2
= get_op(PARAM2
);
284 set_op(PARAM1
, result
);
285 env
->cc_x
= (op1
>> (op2
- 1)) & 1;
293 uint32_t op2
= get_op(PARAM2
);
294 set_op(PARAM1
, (uint8_t)op2
);
300 uint32_t op2
= get_op(PARAM2
);
301 set_op(PARAM1
, (int8_t)op2
);
307 uint32_t op2
= get_op(PARAM2
);
308 set_op(PARAM1
, (uint16_t)op2
);
314 uint32_t op2
= get_op(PARAM2
);
315 set_op(PARAM1
, (int16_t)op2
);
322 if (cc_op
== CC_OP_DYNAMIC
)
324 cpu_m68k_flush_flags(env
, cc_op
);
338 /* ??? This needs to make sure the throwing location is accurate. */
340 RAISE_EXCEPTION(EXCP_DIV0
);
344 /* Avoid using a PARAM1 of zero. This breaks dyngen because it uses
345 the address of a symbol, and gcc knows symbols can't have address
347 if (PARAM1
== 2 && quot
> 0xffff)
351 else if ((int32_t)quot
< 0)
355 env
->cc_dest
= flags
;
370 RAISE_EXCEPTION(EXCP_DIV0
);
374 if (PARAM1
== 2 && quot
!= (int16_t)quot
)
382 env
->cc_dest
= flags
;
386 /* Halt is special because it may be a semihosting call. */
389 RAISE_EXCEPTION(EXCP_HALT_INSN
);
396 RAISE_EXCEPTION(EXCP_HLT
);
402 RAISE_EXCEPTION(PARAM1
);
406 /* Floating point comparison sets flags differently to other instructions. */
412 src0
= get_opf64(PARAM2
);
413 src1
= get_opf64(PARAM3
);
414 set_opf64(PARAM1
, helper_sub_cmpf64(env
, src0
, src1
));
420 uint32_t op1
= get_op(PARAM1
);
427 uint32_t op1
= get_op(PARAM1
);
428 uint32_t op2
= get_op(PARAM2
);
429 env
->cc_x
= (op1
< op2
);
435 set_op(PARAM1
, env
->cc_x
);
441 uint32_t op1
= get_op(PARAM1
);
448 uint32_t op1
= get_op(PARAM1
);
449 uint32_t op2
= get_op(PARAM2
);
457 env
->fp_result
= get_opf64(PARAM1
);
466 /* These ops involve a function call, which probably requires a stack frame
467 and breaks things on some hosts. */
470 uint32_t arg
= get_op(PARAM1
);
478 uint32_t arg
= get_op(PARAM1
);
486 int32_t arg
= get_op(PARAM1
);
494 int32_t arg
= get_op(PARAM1
);
500 void OPPROTO
op_goto_tb0(void)
502 GOTO_TB(op_goto_tb0
, PARAM1
, 0);
505 void OPPROTO
op_goto_tb1(void)
507 GOTO_TB(op_goto_tb1
, PARAM1
, 1);
516 /* Floating point. */
519 set_op(PARAM1
, float64_to_int32(get_opf64(PARAM2
), &CPU_FP_STATUS
));
529 u
.f
= float64_to_float32(get_opf64(PARAM2
), &CPU_FP_STATUS
);
536 set_opf64(PARAM1
, int32_to_float64(get_op(PARAM2
), &CPU_FP_STATUS
));
546 u
.i
= get_op(PARAM2
);
547 set_opf64(PARAM1
, float32_to_float64(u
.f
, &CPU_FP_STATUS
));
553 float64 op0
= get_opf64(PARAM2
);
554 set_opf64(PARAM1
, float64_abs(op0
));
560 float64 op0
= get_opf64(PARAM2
);
561 set_opf64(PARAM1
, float64_chs(op0
));
567 float64 op0
= get_opf64(PARAM2
);
568 set_opf64(PARAM1
, float64_sqrt(op0
, &CPU_FP_STATUS
));
574 float64 op0
= get_opf64(PARAM2
);
575 float64 op1
= get_opf64(PARAM3
);
576 set_opf64(PARAM1
, float64_add(op0
, op1
, &CPU_FP_STATUS
));
582 float64 op0
= get_opf64(PARAM2
);
583 float64 op1
= get_opf64(PARAM3
);
584 set_opf64(PARAM1
, float64_sub(op0
, op1
, &CPU_FP_STATUS
));
590 float64 op0
= get_opf64(PARAM2
);
591 float64 op1
= get_opf64(PARAM3
);
592 set_opf64(PARAM1
, float64_mul(op0
, op1
, &CPU_FP_STATUS
));
598 float64 op0
= get_opf64(PARAM2
);
599 float64 op1
= get_opf64(PARAM3
);
600 set_opf64(PARAM1
, float64_div(op0
, op1
, &CPU_FP_STATUS
));
606 float64 op0
= get_opf64(PARAM2
);
607 set_opf64(PARAM1
, float64_round_to_int(op0
, &CPU_FP_STATUS
));
613 float64 op0
= get_opf64(PARAM2
);
614 set_opf64(PARAM1
, float64_trunc_to_int(op0
, &CPU_FP_STATUS
));
620 float64 op0
= get_opf64(PARAM2
);
621 float64 op1
= get_opf64(PARAM3
);
622 set_op(PARAM1
, float64_compare_quiet(op0
, op1
, &CPU_FP_STATUS
));
628 int op1
= get_op(PARAM1
);
629 uint32_t op2
= get_op(PARAM2
);
630 helper_movec(env
, op1
, op2
);
635 #define MEMSUFFIX _raw
638 #if !defined(CONFIG_USER_ONLY)
639 #define MEMSUFFIX _user
641 #define MEMSUFFIX _kernel