usb-bsd: convert to QOM
[qemu.git] / target-cris / op_helper.c
1 /*
2 * CRIS helper routines
3 *
4 * Copyright (c) 2007 AXIS Communications
5 * Written by Edgar E. Iglesias
6 *
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.
11 *
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 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "cpu.h"
22 #include "dyngen-exec.h"
23 #include "mmu.h"
24 #include "helper.h"
25 #include "host-utils.h"
26
27 //#define CRIS_OP_HELPER_DEBUG
28
29
30 #ifdef CRIS_OP_HELPER_DEBUG
31 #define D(x) x
32 #define D_LOG(...) qemu_log(__VA__ARGS__)
33 #else
34 #define D(x)
35 #define D_LOG(...) do { } while (0)
36 #endif
37
38 #if !defined(CONFIG_USER_ONLY)
39 #include "softmmu_exec.h"
40
41 #define MMUSUFFIX _mmu
42
43 #define SHIFT 0
44 #include "softmmu_template.h"
45
46 #define SHIFT 1
47 #include "softmmu_template.h"
48
49 #define SHIFT 2
50 #include "softmmu_template.h"
51
52 #define SHIFT 3
53 #include "softmmu_template.h"
54
55 /* Try to fill the TLB and return an exception if error. If retaddr is
56 NULL, it means that the function was called in C code (i.e. not
57 from generated code or from helper.c) */
58 /* XXX: fix it to restore all registers */
59 void tlb_fill(CPUState *env1, target_ulong addr, int is_write, int mmu_idx,
60 void *retaddr)
61 {
62 TranslationBlock *tb;
63 CPUState *saved_env;
64 unsigned long pc;
65 int ret;
66
67 saved_env = env;
68 env = env1;
69
70 D_LOG("%s pc=%x tpc=%x ra=%x\n", __func__,
71 env->pc, env->debug1, retaddr);
72 ret = cpu_cris_handle_mmu_fault(env, addr, is_write, mmu_idx);
73 if (unlikely(ret)) {
74 if (retaddr) {
75 /* now we have a real cpu fault */
76 pc = (unsigned long)retaddr;
77 tb = tb_find_pc(pc);
78 if (tb) {
79 /* the PC is inside the translated code. It means that we have
80 a virtual CPU fault */
81 cpu_restore_state(tb, env, pc);
82
83 /* Evaluate flags after retranslation. */
84 helper_top_evaluate_flags();
85 }
86 }
87 cpu_loop_exit(env);
88 }
89 env = saved_env;
90 }
91
92 #endif
93
94 void helper_raise_exception(uint32_t index)
95 {
96 env->exception_index = index;
97 cpu_loop_exit(env);
98 }
99
100 void helper_tlb_flush_pid(uint32_t pid)
101 {
102 #if !defined(CONFIG_USER_ONLY)
103 pid &= 0xff;
104 if (pid != (env->pregs[PR_PID] & 0xff))
105 cris_mmu_flush_pid(env, env->pregs[PR_PID]);
106 #endif
107 }
108
109 void helper_spc_write(uint32_t new_spc)
110 {
111 #if !defined(CONFIG_USER_ONLY)
112 tlb_flush_page(env, env->pregs[PR_SPC]);
113 tlb_flush_page(env, new_spc);
114 #endif
115 }
116
117 void helper_dump(uint32_t a0, uint32_t a1, uint32_t a2)
118 {
119 qemu_log("%s: a0=%x a1=%x\n", __func__, a0, a1);
120 }
121
122 /* Used by the tlb decoder. */
123 #define EXTRACT_FIELD(src, start, end) \
124 (((src) >> start) & ((1 << (end - start + 1)) - 1))
125
126 void helper_movl_sreg_reg (uint32_t sreg, uint32_t reg)
127 {
128 uint32_t srs;
129 srs = env->pregs[PR_SRS];
130 srs &= 3;
131 env->sregs[srs][sreg] = env->regs[reg];
132
133 #if !defined(CONFIG_USER_ONLY)
134 if (srs == 1 || srs == 2) {
135 if (sreg == 6) {
136 /* Writes to tlb-hi write to mm_cause as a side
137 effect. */
138 env->sregs[SFR_RW_MM_TLB_HI] = env->regs[reg];
139 env->sregs[SFR_R_MM_CAUSE] = env->regs[reg];
140 }
141 else if (sreg == 5) {
142 uint32_t set;
143 uint32_t idx;
144 uint32_t lo, hi;
145 uint32_t vaddr;
146 int tlb_v;
147
148 idx = set = env->sregs[SFR_RW_MM_TLB_SEL];
149 set >>= 4;
150 set &= 3;
151
152 idx &= 15;
153 /* We've just made a write to tlb_lo. */
154 lo = env->sregs[SFR_RW_MM_TLB_LO];
155 /* Writes are done via r_mm_cause. */
156 hi = env->sregs[SFR_R_MM_CAUSE];
157
158 vaddr = EXTRACT_FIELD(env->tlbsets[srs-1][set][idx].hi,
159 13, 31);
160 vaddr <<= TARGET_PAGE_BITS;
161 tlb_v = EXTRACT_FIELD(env->tlbsets[srs-1][set][idx].lo,
162 3, 3);
163 env->tlbsets[srs - 1][set][idx].lo = lo;
164 env->tlbsets[srs - 1][set][idx].hi = hi;
165
166 D_LOG("tlb flush vaddr=%x v=%d pc=%x\n",
167 vaddr, tlb_v, env->pc);
168 if (tlb_v) {
169 tlb_flush_page(env, vaddr);
170 }
171 }
172 }
173 #endif
174 }
175
176 void helper_movl_reg_sreg (uint32_t reg, uint32_t sreg)
177 {
178 uint32_t srs;
179 env->pregs[PR_SRS] &= 3;
180 srs = env->pregs[PR_SRS];
181
182 #if !defined(CONFIG_USER_ONLY)
183 if (srs == 1 || srs == 2)
184 {
185 uint32_t set;
186 uint32_t idx;
187 uint32_t lo, hi;
188
189 idx = set = env->sregs[SFR_RW_MM_TLB_SEL];
190 set >>= 4;
191 set &= 3;
192 idx &= 15;
193
194 /* Update the mirror regs. */
195 hi = env->tlbsets[srs - 1][set][idx].hi;
196 lo = env->tlbsets[srs - 1][set][idx].lo;
197 env->sregs[SFR_RW_MM_TLB_HI] = hi;
198 env->sregs[SFR_RW_MM_TLB_LO] = lo;
199 }
200 #endif
201 env->regs[reg] = env->sregs[srs][sreg];
202 }
203
204 static void cris_ccs_rshift(CPUState *env)
205 {
206 uint32_t ccs;
207
208 /* Apply the ccs shift. */
209 ccs = env->pregs[PR_CCS];
210 ccs = (ccs & 0xc0000000) | ((ccs & 0x0fffffff) >> 10);
211 if (ccs & U_FLAG)
212 {
213 /* Enter user mode. */
214 env->ksp = env->regs[R_SP];
215 env->regs[R_SP] = env->pregs[PR_USP];
216 }
217
218 env->pregs[PR_CCS] = ccs;
219 }
220
221 void helper_rfe(void)
222 {
223 int rflag = env->pregs[PR_CCS] & R_FLAG;
224
225 D_LOG("rfe: erp=%x pid=%x ccs=%x btarget=%x\n",
226 env->pregs[PR_ERP], env->pregs[PR_PID],
227 env->pregs[PR_CCS],
228 env->btarget);
229
230 cris_ccs_rshift(env);
231
232 /* RFE sets the P_FLAG only if the R_FLAG is not set. */
233 if (!rflag)
234 env->pregs[PR_CCS] |= P_FLAG;
235 }
236
237 void helper_rfn(void)
238 {
239 int rflag = env->pregs[PR_CCS] & R_FLAG;
240
241 D_LOG("rfn: erp=%x pid=%x ccs=%x btarget=%x\n",
242 env->pregs[PR_ERP], env->pregs[PR_PID],
243 env->pregs[PR_CCS],
244 env->btarget);
245
246 cris_ccs_rshift(env);
247
248 /* Set the P_FLAG only if the R_FLAG is not set. */
249 if (!rflag)
250 env->pregs[PR_CCS] |= P_FLAG;
251
252 /* Always set the M flag. */
253 env->pregs[PR_CCS] |= M_FLAG;
254 }
255
256 uint32_t helper_lz(uint32_t t0)
257 {
258 return clz32(t0);
259 }
260
261 uint32_t helper_btst(uint32_t t0, uint32_t t1, uint32_t ccs)
262 {
263 /* FIXME: clean this up. */
264
265 /* des ref:
266 The N flag is set according to the selected bit in the dest reg.
267 The Z flag is set if the selected bit and all bits to the right are
268 zero.
269 The X flag is cleared.
270 Other flags are left untouched.
271 The destination reg is not affected.*/
272 unsigned int fz, sbit, bset, mask, masked_t0;
273
274 sbit = t1 & 31;
275 bset = !!(t0 & (1 << sbit));
276 mask = sbit == 31 ? -1 : (1 << (sbit + 1)) - 1;
277 masked_t0 = t0 & mask;
278 fz = !(masked_t0 | bset);
279
280 /* Clear the X, N and Z flags. */
281 ccs = ccs & ~(X_FLAG | N_FLAG | Z_FLAG);
282 if (env->pregs[PR_VR] < 32)
283 ccs &= ~(V_FLAG | C_FLAG);
284 /* Set the N and Z flags accordingly. */
285 ccs |= (bset << 3) | (fz << 2);
286 return ccs;
287 }
288
289 static inline uint32_t evaluate_flags_writeback(uint32_t flags, uint32_t ccs)
290 {
291 unsigned int x, z, mask;
292
293 /* Extended arithmetics, leave the z flag alone. */
294 x = env->cc_x;
295 mask = env->cc_mask | X_FLAG;
296 if (x) {
297 z = flags & Z_FLAG;
298 mask = mask & ~z;
299 }
300 flags &= mask;
301
302 /* all insn clear the x-flag except setf or clrf. */
303 ccs &= ~mask;
304 ccs |= flags;
305 return ccs;
306 }
307
308 uint32_t helper_evaluate_flags_muls(uint32_t ccs, uint32_t res, uint32_t mof)
309 {
310 uint32_t flags = 0;
311 int64_t tmp;
312 int dneg;
313
314 dneg = ((int32_t)res) < 0;
315
316 tmp = mof;
317 tmp <<= 32;
318 tmp |= res;
319 if (tmp == 0)
320 flags |= Z_FLAG;
321 else if (tmp < 0)
322 flags |= N_FLAG;
323 if ((dneg && mof != -1)
324 || (!dneg && mof != 0))
325 flags |= V_FLAG;
326 return evaluate_flags_writeback(flags, ccs);
327 }
328
329 uint32_t helper_evaluate_flags_mulu(uint32_t ccs, uint32_t res, uint32_t mof)
330 {
331 uint32_t flags = 0;
332 uint64_t tmp;
333
334 tmp = mof;
335 tmp <<= 32;
336 tmp |= res;
337 if (tmp == 0)
338 flags |= Z_FLAG;
339 else if (tmp >> 63)
340 flags |= N_FLAG;
341 if (mof)
342 flags |= V_FLAG;
343
344 return evaluate_flags_writeback(flags, ccs);
345 }
346
347 uint32_t helper_evaluate_flags_mcp(uint32_t ccs,
348 uint32_t src, uint32_t dst, uint32_t res)
349 {
350 uint32_t flags = 0;
351
352 src = src & 0x80000000;
353 dst = dst & 0x80000000;
354
355 if ((res & 0x80000000L) != 0L)
356 {
357 flags |= N_FLAG;
358 if (!src && !dst)
359 flags |= V_FLAG;
360 else if (src & dst)
361 flags |= R_FLAG;
362 }
363 else
364 {
365 if (res == 0L)
366 flags |= Z_FLAG;
367 if (src & dst)
368 flags |= V_FLAG;
369 if (dst | src)
370 flags |= R_FLAG;
371 }
372
373 return evaluate_flags_writeback(flags, ccs);
374 }
375
376 uint32_t helper_evaluate_flags_alu_4(uint32_t ccs,
377 uint32_t src, uint32_t dst, uint32_t res)
378 {
379 uint32_t flags = 0;
380
381 src = src & 0x80000000;
382 dst = dst & 0x80000000;
383
384 if ((res & 0x80000000L) != 0L)
385 {
386 flags |= N_FLAG;
387 if (!src && !dst)
388 flags |= V_FLAG;
389 else if (src & dst)
390 flags |= C_FLAG;
391 }
392 else
393 {
394 if (res == 0L)
395 flags |= Z_FLAG;
396 if (src & dst)
397 flags |= V_FLAG;
398 if (dst | src)
399 flags |= C_FLAG;
400 }
401
402 return evaluate_flags_writeback(flags, ccs);
403 }
404
405 uint32_t helper_evaluate_flags_sub_4(uint32_t ccs,
406 uint32_t src, uint32_t dst, uint32_t res)
407 {
408 uint32_t flags = 0;
409
410 src = (~src) & 0x80000000;
411 dst = dst & 0x80000000;
412
413 if ((res & 0x80000000L) != 0L)
414 {
415 flags |= N_FLAG;
416 if (!src && !dst)
417 flags |= V_FLAG;
418 else if (src & dst)
419 flags |= C_FLAG;
420 }
421 else
422 {
423 if (res == 0L)
424 flags |= Z_FLAG;
425 if (src & dst)
426 flags |= V_FLAG;
427 if (dst | src)
428 flags |= C_FLAG;
429 }
430
431 flags ^= C_FLAG;
432 return evaluate_flags_writeback(flags, ccs);
433 }
434
435 uint32_t helper_evaluate_flags_move_4(uint32_t ccs, uint32_t res)
436 {
437 uint32_t flags = 0;
438
439 if ((int32_t)res < 0)
440 flags |= N_FLAG;
441 else if (res == 0L)
442 flags |= Z_FLAG;
443
444 return evaluate_flags_writeback(flags, ccs);
445 }
446 uint32_t helper_evaluate_flags_move_2(uint32_t ccs, uint32_t res)
447 {
448 uint32_t flags = 0;
449
450 if ((int16_t)res < 0L)
451 flags |= N_FLAG;
452 else if (res == 0)
453 flags |= Z_FLAG;
454
455 return evaluate_flags_writeback(flags, ccs);
456 }
457
458 /* TODO: This is expensive. We could split things up and only evaluate part of
459 CCR on a need to know basis. For now, we simply re-evaluate everything. */
460 void helper_evaluate_flags(void)
461 {
462 uint32_t src, dst, res;
463 uint32_t flags = 0;
464
465 src = env->cc_src;
466 dst = env->cc_dest;
467 res = env->cc_result;
468
469 if (env->cc_op == CC_OP_SUB || env->cc_op == CC_OP_CMP)
470 src = ~src;
471
472 /* Now, evaluate the flags. This stuff is based on
473 Per Zander's CRISv10 simulator. */
474 switch (env->cc_size)
475 {
476 case 1:
477 if ((res & 0x80L) != 0L)
478 {
479 flags |= N_FLAG;
480 if (((src & 0x80L) == 0L)
481 && ((dst & 0x80L) == 0L))
482 {
483 flags |= V_FLAG;
484 }
485 else if (((src & 0x80L) != 0L)
486 && ((dst & 0x80L) != 0L))
487 {
488 flags |= C_FLAG;
489 }
490 }
491 else
492 {
493 if ((res & 0xFFL) == 0L)
494 {
495 flags |= Z_FLAG;
496 }
497 if (((src & 0x80L) != 0L)
498 && ((dst & 0x80L) != 0L))
499 {
500 flags |= V_FLAG;
501 }
502 if ((dst & 0x80L) != 0L
503 || (src & 0x80L) != 0L)
504 {
505 flags |= C_FLAG;
506 }
507 }
508 break;
509 case 2:
510 if ((res & 0x8000L) != 0L)
511 {
512 flags |= N_FLAG;
513 if (((src & 0x8000L) == 0L)
514 && ((dst & 0x8000L) == 0L))
515 {
516 flags |= V_FLAG;
517 }
518 else if (((src & 0x8000L) != 0L)
519 && ((dst & 0x8000L) != 0L))
520 {
521 flags |= C_FLAG;
522 }
523 }
524 else
525 {
526 if ((res & 0xFFFFL) == 0L)
527 {
528 flags |= Z_FLAG;
529 }
530 if (((src & 0x8000L) != 0L)
531 && ((dst & 0x8000L) != 0L))
532 {
533 flags |= V_FLAG;
534 }
535 if ((dst & 0x8000L) != 0L
536 || (src & 0x8000L) != 0L)
537 {
538 flags |= C_FLAG;
539 }
540 }
541 break;
542 case 4:
543 if ((res & 0x80000000L) != 0L)
544 {
545 flags |= N_FLAG;
546 if (((src & 0x80000000L) == 0L)
547 && ((dst & 0x80000000L) == 0L))
548 {
549 flags |= V_FLAG;
550 }
551 else if (((src & 0x80000000L) != 0L) &&
552 ((dst & 0x80000000L) != 0L))
553 {
554 flags |= C_FLAG;
555 }
556 }
557 else
558 {
559 if (res == 0L)
560 flags |= Z_FLAG;
561 if (((src & 0x80000000L) != 0L)
562 && ((dst & 0x80000000L) != 0L))
563 flags |= V_FLAG;
564 if ((dst & 0x80000000L) != 0L
565 || (src & 0x80000000L) != 0L)
566 flags |= C_FLAG;
567 }
568 break;
569 default:
570 break;
571 }
572
573 if (env->cc_op == CC_OP_SUB || env->cc_op == CC_OP_CMP)
574 flags ^= C_FLAG;
575
576 env->pregs[PR_CCS] = evaluate_flags_writeback(flags, env->pregs[PR_CCS]);
577 }
578
579 void helper_top_evaluate_flags(void)
580 {
581 switch (env->cc_op)
582 {
583 case CC_OP_MCP:
584 env->pregs[PR_CCS] = helper_evaluate_flags_mcp(
585 env->pregs[PR_CCS], env->cc_src,
586 env->cc_dest, env->cc_result);
587 break;
588 case CC_OP_MULS:
589 env->pregs[PR_CCS] = helper_evaluate_flags_muls(
590 env->pregs[PR_CCS], env->cc_result,
591 env->pregs[PR_MOF]);
592 break;
593 case CC_OP_MULU:
594 env->pregs[PR_CCS] = helper_evaluate_flags_mulu(
595 env->pregs[PR_CCS], env->cc_result,
596 env->pregs[PR_MOF]);
597 break;
598 case CC_OP_MOVE:
599 case CC_OP_AND:
600 case CC_OP_OR:
601 case CC_OP_XOR:
602 case CC_OP_ASR:
603 case CC_OP_LSR:
604 case CC_OP_LSL:
605 switch (env->cc_size)
606 {
607 case 4:
608 env->pregs[PR_CCS] =
609 helper_evaluate_flags_move_4(
610 env->pregs[PR_CCS],
611 env->cc_result);
612 break;
613 case 2:
614 env->pregs[PR_CCS] =
615 helper_evaluate_flags_move_2(
616 env->pregs[PR_CCS],
617 env->cc_result);
618 break;
619 default:
620 helper_evaluate_flags();
621 break;
622 }
623 break;
624 case CC_OP_FLAGS:
625 /* live. */
626 break;
627 case CC_OP_SUB:
628 case CC_OP_CMP:
629 if (env->cc_size == 4)
630 env->pregs[PR_CCS] =
631 helper_evaluate_flags_sub_4(
632 env->pregs[PR_CCS],
633 env->cc_src, env->cc_dest,
634 env->cc_result);
635 else
636 helper_evaluate_flags();
637 break;
638 default:
639 {
640 switch (env->cc_size)
641 {
642 case 4:
643 env->pregs[PR_CCS] =
644 helper_evaluate_flags_alu_4(
645 env->pregs[PR_CCS],
646 env->cc_src, env->cc_dest,
647 env->cc_result);
648 break;
649 default:
650 helper_evaluate_flags();
651 break;
652 }
653 }
654 break;
655 }
656 }