gwj / at91sam9263 · Commits

Commit 5ce042b1cf4bfdff3bb746f620d68f532d3d6503

Authored by edgar_igl
1 parent fe6f943f

Remove dyngen leftovers. 

git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@4963 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 2 changed files with 0 additions and 1044 deletions
target-cris/op.c deleted 100644 → 0
  View file @fe6f943
1   -/*
2   - * CRIS emulation micro-operations for qemu.
3   - *
4   - * Copyright (c) 2007 Edgar E. Iglesias, Axis Communications AB.
5   - *
6   - * This library is free software; you can redistribute it and/or
7   - * modify it under the terms of the GNU Lesser General Public
8   - * License as published by the Free Software Foundation; either
9   - * version 2 of the License, or (at your option) any later version.
10   - *
11   - * This library is distributed in the hope that it will be useful,
12   - * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14   - * Lesser General Public License for more details.
15   - *
16   - * You should have received a copy of the GNU Lesser General Public
17   - * License along with this library; if not, write to the Free Software
18   - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19   - */
20   -#include "exec.h"
21   -#include "host-utils.h"
22   -
23   -#define REGNAME r0
24   -#define REG (env->regs[0])
25   -#include "op_template.h"
26   -
27   -#define REGNAME r1
28   -#define REG (env->regs[1])
29   -#include "op_template.h"
30   -
31   -#define REGNAME r2
32   -#define REG (env->regs[2])
33   -#include "op_template.h"
34   -
35   -#define REGNAME r3
36   -#define REG (env->regs[3])
37   -#include "op_template.h"
38   -
39   -#define REGNAME r4
40   -#define REG (env->regs[4])
41   -#include "op_template.h"
42   -
43   -#define REGNAME r5
44   -#define REG (env->regs[5])
45   -#include "op_template.h"
46   -
47   -#define REGNAME r6
48   -#define REG (env->regs[6])
49   -#include "op_template.h"
50   -
51   -#define REGNAME r7
52   -#define REG (env->regs[7])
53   -#include "op_template.h"
54   -
55   -#define REGNAME r8
56   -#define REG (env->regs[8])
57   -#include "op_template.h"
58   -
59   -#define REGNAME r9
60   -#define REG (env->regs[9])
61   -#include "op_template.h"
62   -
63   -#define REGNAME r10
64   -#define REG (env->regs[10])
65   -#include "op_template.h"
66   -
67   -#define REGNAME r11
68   -#define REG (env->regs[11])
69   -#include "op_template.h"
70   -
71   -#define REGNAME r12
72   -#define REG (env->regs[12])
73   -#include "op_template.h"
74   -
75   -#define REGNAME r13
76   -#define REG (env->regs[13])
77   -#include "op_template.h"
78   -
79   -#define REGNAME r14
80   -#define REG (env->regs[14])
81   -#include "op_template.h"
82   -
83   -#define REGNAME r15
84   -#define REG (env->regs[15])
85   -#include "op_template.h"
86   -
87   -
88   -#define REGNAME p0
89   -#define REG (env->pregs[0])
90   -#include "op_template.h"
91   -
92   -#define REGNAME p1
93   -#define REG (env->pregs[1])
94   -#include "op_template.h"
95   -
96   -#define REGNAME p2
97   -#define REG (env->pregs[2])
98   -#include "op_template.h"
99   -
100   -#define REGNAME p3
101   -#define REG (env->pregs[3])
102   -#include "op_template.h"
103   -
104   -#define REGNAME p4
105   -#define REG (env->pregs[4])
106   -#include "op_template.h"
107   -
108   -#define REGNAME p5
109   -#define REG (env->pregs[5])
110   -#include "op_template.h"
111   -
112   -#define REGNAME p6
113   -#define REG (env->pregs[6])
114   -#include "op_template.h"
115   -
116   -#define REGNAME p7
117   -#define REG (env->pregs[7])
118   -#include "op_template.h"
119   -
120   -#define REGNAME p8
121   -#define REG (env->pregs[8])
122   -#include "op_template.h"
123   -
124   -#define REGNAME p9
125   -#define REG (env->pregs[9])
126   -#include "op_template.h"
127   -
128   -#define REGNAME p10
129   -#define REG (env->pregs[10])
130   -#include "op_template.h"
131   -
132   -#define REGNAME p11
133   -#define REG (env->pregs[11])
134   -#include "op_template.h"
135   -
136   -#define REGNAME p12
137   -#define REG (env->pregs[12])
138   -#include "op_template.h"
139   -
140   -#define REGNAME p13
141   -#define REG (env->pregs[13])
142   -#include "op_template.h"
143   -
144   -#define REGNAME p14
145   -#define REG (env->pregs[14])
146   -#include "op_template.h"
147   -
148   -#define REGNAME p15
149   -#define REG (env->pregs[15])
150   -#include "op_template.h"
151   -
152   -/* Microcode. */
153   -
154   -void OPPROTO op_break_im(void)
155   -{
156   - env->trap_vector = PARAM1;
157   - env->exception_index = EXCP_BREAK;
158   - cpu_loop_exit();
159   -}
160   -
161   -void OPPROTO op_debug(void)
162   -{
163   - env->exception_index = EXCP_DEBUG;
164   - cpu_loop_exit();
165   -}
166   -
167   -void OPPROTO op_exec_insn(void)
168   -{
169   - env->stats.exec_insns++;
170   - RETURN();
171   -}
172   -void OPPROTO op_exec_load(void)
173   -{
174   - env->stats.exec_loads++;
175   - RETURN();
176   -}
177   -void OPPROTO op_exec_store(void)
178   -{
179   - env->stats.exec_stores++;
180   - RETURN();
181   -}
182   -
183   -void OPPROTO op_ccs_lshift (void)
184   -{
185   - uint32_t ccs;
186   -
187   - /* Apply the ccs shift. */
188   - ccs = env->pregs[PR_CCS];
189   - ccs = (ccs & 0xc0000000) | ((ccs << 12) >> 2);
190   - env->pregs[PR_CCS] = ccs;
191   - RETURN();
192   -}
193   -void OPPROTO op_ccs_rshift (void)
194   -{
195   - register uint32_t ccs;
196   -
197   - /* Apply the ccs shift. */
198   - ccs = env->pregs[PR_CCS];
199   - ccs = (ccs & 0xc0000000) | ((ccs & 0x0fffffff) >> 10);
200   - if (ccs & U_FLAG)
201   - {
202   - /* Enter user mode. */
203   - env->ksp = env->regs[R_SP];
204   - env->regs[R_SP] = env->pregs[PR_USP];
205   - }
206   -
207   - env->pregs[PR_CCS] = ccs;
208   -
209   - RETURN();
210   -}
211   -
212   -void OPPROTO op_setf (void)
213   -{
214   - if (!(env->pregs[PR_CCS] & U_FLAG) && (PARAM1 & U_FLAG))
215   - {
216   - /* Enter user mode. */
217   - env->ksp = env->regs[R_SP];
218   - env->regs[R_SP] = env->pregs[PR_USP];
219   - }
220   -
221   - env->pregs[PR_CCS] |= PARAM1;
222   - RETURN();
223   -}
224   -
225   -void OPPROTO op_clrf (void)
226   -{
227   - env->pregs[PR_CCS] &= ~PARAM1;
228   - RETURN();
229   -}
230   -
231   -void OPPROTO op_movl_debug1_T0 (void)
232   -{
233   - env->debug1 = T0;
234   - RETURN();
235   -}
236   -
237   -void OPPROTO op_movl_debug2_T0 (void)
238   -{
239   - env->debug2 = T0;
240   - RETURN();
241   -}
242   -
243   -void OPPROTO op_movl_debug3_T0 (void)
244   -{
245   - env->debug3 = T0;
246   - RETURN();
247   -}
248   -void OPPROTO op_movl_debug1_T1 (void)
249   -{
250   - env->debug1 = T1;
251   - RETURN();
252   -}
253   -
254   -void OPPROTO op_movl_debug2_T1 (void)
255   -{
256   - env->debug2 = T1;
257   - RETURN();
258   -}
259   -
260   -void OPPROTO op_movl_debug3_T1 (void)
261   -{
262   - env->debug3 = T1;
263   - RETURN();
264   -}
265   -void OPPROTO op_movl_debug3_im (void)
266   -{
267   - env->debug3 = PARAM1;
268   - RETURN();
269   -}
270   -void OPPROTO op_movl_T0_flags (void)
271   -{
272   - T0 = env->pregs[PR_CCS];
273   - RETURN();
274   -}
275   -void OPPROTO op_movl_flags_T0 (void)
276   -{
277   - env->pregs[PR_CCS] = T0;
278   - RETURN();
279   -}
280   -
281   -void OPPROTO op_movl_sreg_T0 (void)
282   -{
283   - uint32_t srs;
284   - srs = env->pregs[PR_SRS];
285   - srs &= 3;
286   -
287   - env->sregs[srs][PARAM1] = T0;
288   - RETURN();
289   -}
290   -
291   -void OPPROTO op_movl_tlb_hi_T0 (void)
292   -{
293   - uint32_t srs;
294   - srs = env->pregs[PR_SRS];
295   - if (srs == 1 || srs == 2)
296   - {
297   - /* Writes to tlb-hi write to mm_cause as a side effect. */
298   - env->sregs[SFR_RW_MM_TLB_HI] = T0;
299   - env->sregs[SFR_R_MM_CAUSE] = T0;
300   - }
301   - RETURN();
302   -}
303   -
304   -void OPPROTO op_movl_tlb_lo_T0 (void)
305   -{
306   - uint32_t srs;
307   -
308   - env->pregs[PR_SRS] &= 3;
309   - srs = env->pregs[PR_SRS];
310   -
311   - if (srs == 1 || srs == 2)
312   - {
313   - uint32_t set;
314   - uint32_t idx;
315   - uint32_t lo, hi;
316   -
317   - idx = set = env->sregs[SFR_RW_MM_TLB_SEL];
318   - set >>= 4;
319   - set &= 3;
320   -
321   - idx &= 15;
322   - /* We've just made a write to tlb_lo. */
323   - lo = env->sregs[SFR_RW_MM_TLB_LO];
324   - /* Writes are done via r_mm_cause. */
325   - hi = env->sregs[SFR_R_MM_CAUSE];
326   - env->tlbsets[srs - 1][set][idx].lo = lo;
327   - env->tlbsets[srs - 1][set][idx].hi = hi;
328   - }
329   - RETURN();
330   -}
331   -
332   -void OPPROTO op_movl_T0_sreg (void)
333   -{
334   - uint32_t srs;
335   - env->pregs[PR_SRS] &= 3;
336   - srs = env->pregs[PR_SRS];
337   -
338   - if (srs == 1 || srs == 2)
339   - {
340   - uint32_t set;
341   - uint32_t idx;
342   - uint32_t lo, hi;
343   -
344   - idx = set = env->sregs[SFR_RW_MM_TLB_SEL];
345   - set >>= 4;
346   - set &= 3;
347   - idx &= 15;
348   -
349   - /* Update the mirror regs. */
350   - hi = env->tlbsets[srs - 1][set][idx].hi;
351   - lo = env->tlbsets[srs - 1][set][idx].lo;
352   - env->sregs[SFR_RW_MM_TLB_HI] = hi;
353   - env->sregs[SFR_RW_MM_TLB_LO] = lo;
354   - }
355   - T0 = env->sregs[srs][PARAM1];
356   - RETURN();
357   -}
358   -
359   -void OPPROTO op_update_cc (void)
360   -{
361   - env->cc_op = PARAM1;
362   - env->cc_dest = PARAM2;
363   - env->cc_src = PARAM3;
364   - RETURN();
365   -}
366   -
367   -void OPPROTO op_update_cc_op (void)
368   -{
369   - env->cc_op = PARAM1;
370   - RETURN();
371   -}
372   -
373   -void OPPROTO op_update_cc_mask (void)
374   -{
375   - env->cc_mask = PARAM1;
376   - RETURN();
377   -}
378   -
379   -void OPPROTO op_update_cc_dest_T0 (void)
380   -{
381   - env->cc_dest = T0;
382   - RETURN();
383   -}
384   -
385   -void OPPROTO op_update_cc_result_T0 (void)
386   -{
387   - env->cc_result = T0;
388   - RETURN();
389   -}
390   -
391   -void OPPROTO op_update_cc_size_im (void)
392   -{
393   - env->cc_size = PARAM1;
394   - RETURN();
395   -}
396   -
397   -void OPPROTO op_update_cc_src_T1 (void)
398   -{
399   - env->cc_src = T1;
400   - RETURN();
401   -}
402   -void OPPROTO op_update_cc_x (void)
403   -{
404   - env->cc_x_live = PARAM1;
405   - env->cc_x = PARAM2;
406   - RETURN();
407   -}
408   -
409   -void OPPROTO op_extb_T0_T0 (void)
410   -{
411   - T0 = ((int8_t)T0);
412   - RETURN();
413   -}
414   -void OPPROTO op_extb_T1_T0 (void)
415   -{
416   - T1 = ((int8_t)T0);
417   - RETURN();
418   -}
419   -void OPPROTO op_extb_T1_T1 (void)
420   -{
421   - T1 = ((int8_t)T1);
422   - RETURN();
423   -}
424   -void OPPROTO op_zextb_T0_T0 (void)
425   -{
426   - T0 = ((uint8_t)T0);
427   - RETURN();
428   -}
429   -void OPPROTO op_zextb_T1_T0 (void)
430   -{
431   - T1 = ((uint8_t)T0);
432   - RETURN();
433   -}
434   -void OPPROTO op_zextb_T1_T1 (void)
435   -{
436   - T1 = ((uint8_t)T1);
437   - RETURN();
438   -}
439   -void OPPROTO op_extw_T0_T0 (void)
440   -{
441   - T0 = ((int16_t)T0);
442   - RETURN();
443   -}
444   -void OPPROTO op_extw_T1_T0 (void)
445   -{
446   - T1 = ((int16_t)T0);
447   - RETURN();
448   -}
449   -void OPPROTO op_extw_T1_T1 (void)
450   -{
451   - T1 = ((int16_t)T1);
452   - RETURN();
453   -}
454   -
455   -void OPPROTO op_zextw_T0_T0 (void)
456   -{
457   - T0 = ((uint16_t)T0);
458   - RETURN();
459   -}
460   -void OPPROTO op_zextw_T1_T0 (void)
461   -{
462   - T1 = ((uint16_t)T0);
463   - RETURN();
464   -}
465   -
466   -void OPPROTO op_zextw_T1_T1 (void)
467   -{
468   - T1 = ((uint16_t)T1);
469   - RETURN();
470   -}
471   -
472   -void OPPROTO op_movl_T0_im (void)
473   -{
474   - T0 = PARAM1;
475   - RETURN();
476   -}
477   -void OPPROTO op_movl_T1_im (void)
478   -{
479   - T1 = PARAM1;
480   - RETURN();
481   -}
482   -
483   -void OPPROTO op_addl_T0_im (void)
484   -{
485   - T0 += PARAM1;
486   - RETURN();
487   -}
488   -
489   -void OPPROTO op_addl_T1_im (void)
490   -{
491   - T1 += PARAM1;
492   - RETURN();
493   -
494   -}
495   -void OPPROTO op_subl_T0_im (void)
496   -{
497   - T0 -= PARAM1;
498   - RETURN();
499   -}
500   -
501   -void OPPROTO op_addxl_T0_C (void)
502   -{
503   - if (env->pregs[PR_CCS] & X_FLAG)
504   - T0 += !!(env->pregs[PR_CCS] & C_FLAG);
505   - RETURN();
506   -}
507   -void OPPROTO op_subxl_T0_C (void)
508   -{
509   - if (env->pregs[PR_CCS] & X_FLAG)
510   - T0 -= !!(env->pregs[PR_CCS] & C_FLAG);
511   - RETURN();
512   -}
513   -void OPPROTO op_addl_T0_C (void)
514   -{
515   - T0 += !!(env->pregs[PR_CCS] & C_FLAG);
516   - RETURN();
517   -}
518   -void OPPROTO op_addl_T0_R (void)
519   -{
520   - T0 += !!(env->pregs[PR_CCS] & R_FLAG);
521   - RETURN();
522   -}
523   -
524   -void OPPROTO op_clr_R (void)
525   -{
526   - env->pregs[PR_CCS] &= ~R_FLAG;
527   - RETURN();
528   -}
529   -
530   -
531   -void OPPROTO op_andl_T0_im (void)
532   -{
533   - T0 &= PARAM1;
534   - RETURN();
535   -}
536   -
537   -void OPPROTO op_andl_T1_im (void)
538   -{
539   - T1 &= PARAM1;
540   - RETURN();
541   -}
542   -
543   -void OPPROTO op_movl_T0_T1 (void)
544   -{
545   - T0 = T1;
546   - RETURN();
547   -}
548   -
549   -void OPPROTO op_swp_T0_T1 (void)
550   -{
551   - T0 ^= T1;
552   - T1 ^= T0;
553   - T0 ^= T1;
554   - RETURN();
555   -}
556   -
557   -void OPPROTO op_movl_T1_T0 (void)
558   -{
559   - T1 = T0;
560   - RETURN();
561   -}
562   -
563   -void OPPROTO op_movl_pc_T0 (void)
564   -{
565   - env->pc = T0;
566   - RETURN();
567   -}
568   -
569   -void OPPROTO op_movl_T0_0 (void)
570   -{
571   - T0 = 0;
572   - RETURN();
573   -}
574   -
575   -void OPPROTO op_addl_T0_T1 (void)
576   -{
577   - T0 += T1;
578   - RETURN();
579   -}
580   -
581   -void OPPROTO op_subl_T0_T1 (void)
582   -{
583   - T0 -= T1;
584   - RETURN();
585   -}
586   -
587   -void OPPROTO op_absl_T1_T1 (void)
588   -{
589   - int32_t st = T1;
590   -
591   - T1 = st < 0 ? -st : st;
592   - RETURN();
593   -}
594   -
595   -void OPPROTO op_muls_T0_T1 (void)
596   -{
597   - int64_t tmp, t0 ,t1;
598   -
599   - /* cast into signed values to make GCC sign extend these babies. */
600   - t0 = (int32_t)T0;
601   - t1 = (int32_t)T1;
602   -
603   - tmp = t0 * t1;
604   - T0 = tmp & 0xffffffff;
605   - env->pregs[PR_MOF] = tmp >> 32;
606   - RETURN();
607   -}
608   -
609   -void OPPROTO op_mulu_T0_T1 (void)
610   -{
611   - uint64_t tmp, t0 ,t1;
612   - t0 = T0;
613   - t1 = T1;
614   -
615   - tmp = t0 * t1;
616   - T0 = tmp & 0xffffffff;
617   - env->pregs[PR_MOF] = tmp >> 32;
618   - RETURN();
619   -}
620   -
621   -void OPPROTO op_dstep_T0_T1 (void)
622   -{
623   - T0 <<= 1;
624   - if (T0 >= T1)
625   - T0 -= T1;
626   - RETURN();
627   -}
628   -
629   -void OPPROTO op_orl_T0_T1 (void)
630   -{
631   - T0 |= T1;
632   - RETURN();
633   -}
634   -
635   -void OPPROTO op_andl_T0_T1 (void)
636   -{
637   - T0 &= T1;
638   - RETURN();
639   -}
640   -
641   -void OPPROTO op_xorl_T0_T1 (void)
642   -{
643   - T0 ^= T1;
644   - RETURN();
645   -}
646   -
647   -void OPPROTO op_lsll_T0_T1 (void)
648   -{
649   - int s = T1;
650   - if (s > 31)
651   - T0 = 0;
652   - else
653   - T0 <<= s;
654   - RETURN();
655   -}
656   -
657   -void OPPROTO op_lsll_T0_im (void)
658   -{
659   - T0 <<= PARAM1;
660   - RETURN();
661   -}
662   -
663   -void OPPROTO op_lsrl_T0_T1 (void)
664   -{
665   - int s = T1;
666   - if (s > 31)
667   - T0 = 0;
668   - else
669   - T0 >>= s;
670   - RETURN();
671   -}
672   -
673   -/* Rely on GCC emitting an arithmetic shift for signed right shifts. */
674   -void OPPROTO op_asrl_T0_T1 (void)
675   -{
676   - int s = T1;
677   - if (s > 31)
678   - T0 = T0 & 0x80000000 ? -1 : 0;
679   - else
680   - T0 = (int32_t)T0 >> s;
681   - RETURN();
682   -}
683   -
684   -void OPPROTO op_btst_T0_T1 (void)
685   -{
686   - /* FIXME: clean this up. */
687   -
688   - /* des ref:
689   - The N flag is set according to the selected bit in the dest reg.
690   - The Z flag is set if the selected bit and all bits to the right are
691   - zero.
692   - The X flag is cleared.
693   - Other flags are left untouched.
694   - The destination reg is not affected.*/
695   - unsigned int fz, sbit, bset, mask, masked_t0;
696   -
697   - sbit = T1 & 31;
698   - bset = !!(T0 & (1 << sbit));
699   - mask = sbit == 31 ? -1 : (1 << (sbit + 1)) - 1;
700   - masked_t0 = T0 & mask;
701   - fz = !(masked_t0 | bset);
702   -
703   - /* Clear the X, N and Z flags. */
704   - T0 = env->pregs[PR_CCS] & ~(X_FLAG | N_FLAG | Z_FLAG);
705   - /* Set the N and Z flags accordingly. */
706   - T0 |= (bset << 3) | (fz << 2);
707   - RETURN();
708   -}
709   -
710   -void OPPROTO op_bound_T0_T1 (void)
711   -{
712   - if (T0 > T1)
713   - T0 = T1;
714   - RETURN();
715   -}
716   -
717   -void OPPROTO op_lz_T0_T1 (void)
718   -{
719   - T0 = clz32(T1);
720   - RETURN();
721   -}
722   -
723   -void OPPROTO op_negl_T0_T1 (void)
724   -{
725   - T0 = -T1;
726   - RETURN();
727   -}
728   -
729   -void OPPROTO op_negl_T1_T1 (void)
730   -{
731   - T1 = -T1;
732   - RETURN();
733   -}
734   -
735   -void OPPROTO op_not_T0_T0 (void)
736   -{
737   - T0 = ~(T0);
738   - RETURN();
739   -}
740   -void OPPROTO op_not_T1_T1 (void)
741   -{
742   - T1 = ~(T1);
743   - RETURN();
744   -}
745   -
746   -void OPPROTO op_swapw_T0_T0 (void)
747   -{
748   - T0 = (T0 << 16) | ((T0 >> 16));
749   - RETURN();
750   -}
751   -
752   -void OPPROTO op_swapb_T0_T0 (void)
753   -{
754   - T0 = ((T0 << 8) & 0xff00ff00) | ((T0 >> 8) & 0x00ff00ff);
755   - RETURN();
756   -}
757   -
758   -void OPPROTO op_swapr_T0_T0 (void)
759   -{
760   - T0 = (((T0 << 7) & 0x80808080) |
761   - ((T0 << 5) & 0x40404040) |
762   - ((T0 << 3) & 0x20202020) |
763   - ((T0 << 1) & 0x10101010) |
764   - ((T0 >> 1) & 0x08080808) |
765   - ((T0 >> 3) & 0x04040404) |
766   - ((T0 >> 5) & 0x02020202) |
767   - ((T0 >> 7) & 0x01010101));
768   - RETURN();
769   -}
770   -
771   -void OPPROTO op_tst_cc_eq (void) {
772   - uint32_t flags = env->pregs[PR_CCS];
773   - int z_set;
774   -
775   - z_set = !!(flags & Z_FLAG);
776   - T0 = z_set;
777   - RETURN();
778   -}
779   -
780   -void OPPROTO op_tst_cc_eq_fast (void) {
781   - T0 = !(env->cc_result);
782   - RETURN();
783   -}
784   -
785   -void OPPROTO op_tst_cc_ne (void) {
786   - uint32_t flags = env->pregs[PR_CCS];
787   - int z_set;
788   -
789   - z_set = !!(flags & Z_FLAG);
790   - T0 = !z_set;
791   - RETURN();
792   -}
793   -void OPPROTO op_tst_cc_ne_fast (void) {
794   - T0 = !!(env->cc_result);
795   - RETURN();
796   -}
797   -
798   -void OPPROTO op_tst_cc_cc (void) {
799   - uint32_t flags = env->pregs[PR_CCS];
800   - int c_set;
801   -
802   - c_set = !!(flags & C_FLAG);
803   - T0 = !c_set;
804   - RETURN();
805   -}
806   -void OPPROTO op_tst_cc_cs (void) {
807   - uint32_t flags = env->pregs[PR_CCS];
808   - int c_set;
809   -
810   - c_set = !!(flags & C_FLAG);
811   - T0 = c_set;
812   - RETURN();
813   -}
814   -
815   -void OPPROTO op_tst_cc_vc (void) {
816   - uint32_t flags = env->pregs[PR_CCS];
817   - int v_set;
818   -
819   - v_set = !!(flags & V_FLAG);
820   - T0 = !v_set;
821   - RETURN();
822   -}
823   -void OPPROTO op_tst_cc_vs (void) {
824   - uint32_t flags = env->pregs[PR_CCS];
825   - int v_set;
826   -
827   - v_set = !!(flags & V_FLAG);
828   - T0 = v_set;
829   - RETURN();
830   -}
831   -void OPPROTO op_tst_cc_pl (void) {
832   - uint32_t flags = env->pregs[PR_CCS];
833   - int n_set;
834   -
835   - n_set = !!(flags & N_FLAG);
836   - T0 = !n_set;
837   - RETURN();
838   -}
839   -void OPPROTO op_tst_cc_pl_fast (void) {
840   - T0 = ((int32_t)env->cc_result) >= 0;
841   - RETURN();
842   -}
843   -
844   -void OPPROTO op_tst_cc_mi (void) {
845   - uint32_t flags = env->pregs[PR_CCS];
846   - int n_set;
847   -
848   - n_set = !!(flags & N_FLAG);
849   - T0 = n_set;
850   - RETURN();
851   -}
852   -void OPPROTO op_tst_cc_mi_fast (void) {
853   - T0 = ((int32_t)env->cc_result) < 0;
854   - RETURN();
855   -}
856   -
857   -void OPPROTO op_tst_cc_ls (void) {
858   - uint32_t flags = env->pregs[PR_CCS];
859   - int c_set;
860   - int z_set;
861   -
862   - c_set = !!(flags & C_FLAG);
863   - z_set = !!(flags & Z_FLAG);
864   - T0 = c_set || z_set;
865   - RETURN();
866   -}
867   -void OPPROTO op_tst_cc_hi (void) {
868   - uint32_t flags = env->pregs[PR_CCS];
869   - int z_set;
870   - int c_set;
871   -
872   - z_set = !!(flags & Z_FLAG);
873   - c_set = !!(flags & C_FLAG);
874   - T0 = !c_set && !z_set;
875   - RETURN();
876   -
877   -}
878   -
879   -void OPPROTO op_tst_cc_ge (void) {
880   - uint32_t flags = env->pregs[PR_CCS];
881   - int n_set;
882   - int v_set;
883   -
884   - n_set = !!(flags & N_FLAG);
885   - v_set = !!(flags & V_FLAG);
886   - T0 = (n_set && v_set) || (!n_set && !v_set);
887   - RETURN();
888   -}
889   -
890   -void OPPROTO op_tst_cc_ge_fast (void) {
891   - T0 = ((int32_t)env->cc_src < (int32_t)env->cc_dest);
892   - RETURN();
893   -}
894   -
895   -void OPPROTO op_tst_cc_lt (void) {
896   - uint32_t flags = env->pregs[PR_CCS];
897   - int n_set;
898   - int v_set;
899   -
900   - n_set = !!(flags & N_FLAG);
901   - v_set = !!(flags & V_FLAG);
902   - T0 = (n_set && !v_set) || (!n_set && v_set);
903   - RETURN();
904   -}
905   -
906   -void OPPROTO op_tst_cc_gt (void) {
907   - uint32_t flags = env->pregs[PR_CCS];
908   - int n_set;
909   - int v_set;
910   - int z_set;
911   -
912   - n_set = !!(flags & N_FLAG);
913   - v_set = !!(flags & V_FLAG);
914   - z_set = !!(flags & Z_FLAG);
915   - T0 = (n_set && v_set && !z_set)
916   - || (!n_set && !v_set && !z_set);
917   - RETURN();
918   -}
919   -
920   -void OPPROTO op_tst_cc_le (void) {
921   - uint32_t flags = env->pregs[PR_CCS];
922   - int n_set;
923   - int v_set;
924   - int z_set;
925   -
926   - n_set = !!(flags & N_FLAG);
927   - v_set = !!(flags & V_FLAG);
928   - z_set = !!(flags & Z_FLAG);
929   - T0 = z_set || (n_set && !v_set) || (!n_set && v_set);
930   - RETURN();
931   -}
932   -
933   -void OPPROTO op_tst_cc_p (void) {
934   - uint32_t flags = env->pregs[PR_CCS];
935   - int p_set;
936   -
937   - p_set = !!(flags & P_FLAG);
938   - T0 = p_set;
939   - RETURN();
940   -}
941   -
942   -/* Evaluate the if the branch should be taken or not. Needs to be done in
943   - the original sequence. The acutal branch is rescheduled to right after the
944   - delay-slot. */
945   -void OPPROTO op_evaluate_bcc (void)
946   -{
947   - env->btaken = T0;
948   - RETURN();
949   -}
950   -
951   -/* this one is used on every alu op, optimize it!. */
952   -void OPPROTO op_goto_if_not_x (void)
953   -{
954   - if (env->pregs[PR_CCS] & X_FLAG)
955   - GOTO_LABEL_PARAM(1);
956   - RETURN();
957   -}
958   -
959   -void OPPROTO op_cc_jmp (void)
960   -{
961   - if (env->btaken)
962   - env->pc = PARAM1;
963   - else
964   - env->pc = PARAM2;
965   - RETURN();
966   -}
967   -
968   -void OPPROTO op_cc_ngoto (void)
969   -{
970   - if (!env->btaken)
971   - GOTO_LABEL_PARAM(1);
972   - RETURN();
973   -}
974   -
975   -void OPPROTO op_movl_btarget_T0 (void)
976   -{
977   - env->btarget = T0;
978   - RETURN();
979   -}
980   -
981   -void OPPROTO op_jmp1 (void)
982   -{
983   - env->pc = env->btarget;
984   - RETURN();
985   -}
target-cris/op_mem.c deleted 100644 → 0
  View file @fe6f943
1   -/*
2   - * CRIS memory access (load and store) micro operations.
3   - *
4   - * Copyright (c) 2007 Edgar E. Iglesias, Axis Communications AB.
5   - *
6   - * This library is free software; you can redistribute it and/or
7   - * modify it under the terms of the GNU Lesser General Public
8   - * License as published by the Free Software Foundation; either
9   - * version 2 of the License, or (at your option) any later version.
10   - *
11   - * This library is distributed in the hope that it will be useful,
12   - * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14   - * Lesser General Public License for more details.
15   - *
16   - * You should have received a copy of the GNU Lesser General Public
17   - * License along with this library; if not, write to the Free Software
18   - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19   - */
20   -
21   -void glue(op_ldb_T0_T0, MEMSUFFIX) (void) {
22   - T0 = glue(ldsb, MEMSUFFIX) (T0);
23   - RETURN();
24   -}
25   -
26   -void glue(op_ldub_T0_T0, MEMSUFFIX) (void) {
27   - T0 = glue(ldub, MEMSUFFIX) (T0);
28   - RETURN();
29   -}
30   -
31   -void glue(op_stb_T0_T1, MEMSUFFIX) (void) {
32   - glue(stb, MEMSUFFIX) (T0, T1);
33   - RETURN();
34   -}
35   -
36   -void glue(op_ldw_T0_T0, MEMSUFFIX) (void) {
37   - T0 = glue(ldsw, MEMSUFFIX) (T0);
38   - RETURN();
39   -}
40   -
41   -void glue(op_lduw_T0_T0, MEMSUFFIX) (void) {
42   - T0 = glue(lduw, MEMSUFFIX) (T0);
43   - RETURN();
44   -}
45   -
46   -void glue(op_stw_T0_T1, MEMSUFFIX) (void) {
47   - glue(stw, MEMSUFFIX) (T0, T1);
48   - RETURN();
49   -}
50   -
51   -void glue(op_ldl_T0_T0, MEMSUFFIX) (void) {
52   - T0 = glue(ldl, MEMSUFFIX) (T0);
53   - RETURN();
54   -}
55   -
56   -void glue(op_stl_T0_T1, MEMSUFFIX) (void) {
57   - glue(stl, MEMSUFFIX) (T0, T1);
58   - RETURN();
59   -}