OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [rel-0-3-0-rc1/] [or1ksim/] [cpu/] [or32/] [op.c] - Blame information for rev 1678

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1452 nogj 
/* op.c -- Micro operations for the recompiler
2 
   Copyright (C) 2005 György `nog' Jeney, nog@sdf.lonestar.org
3 
 
4 
This file is part of OpenRISC 1000 Architectural Simulator.
5 
 
6 
This program is free software; you can redistribute it and/or modify
7 
it under the terms of the GNU General Public License as published by
8 
the Free Software Foundation; either version 2 of the License, or
9 
(at your option) any later version.
10 
 
11 
This program 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
14 
GNU General Public License for more details.
15 
 
16 
You should have received a copy of the GNU General Public License
17 
along with this program; if not, write to the Free Software
18 
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
19 
 
20 
 
21 
#include <stdio.h>
22 
#include <stdint.h>
23 
#include <stdlib.h>
24 
 
25 
#include "config.h"
26 
 
27 
#ifdef HAVE_INTTYPES_H
28 
#include <inttypes.h>
29 
#endif
30 
 
31 
#include "port.h"
32 
#include "arch.h"
33 
#include "spr_defs.h"
34 
#include "opcode/or32.h"
35 
#include "sim-config.h"
36 
#include "except.h"
37 
#include "abstract.h"
38 
#include "execute.h"
39 
#include "sprs.h"
40 
#include "sched.h"
41 
 
42 
#include "op_support.h"
43 
 
44 
#include "i386_regs.h"
45 
 
46 
#include "dyn_rec.h"
47 
 
48 
/* This must be here since the function in op_i386.h use this variable */
49 
register struct cpu_state *env asm(CPU_STATE_REG);
50 
 
51 
#include "op_i386.h"
52 
 
53 
/*
54 1549 nogj 
 * WARNING: Before going of and wildly editing everything in this file remember
55 1452 nogj 
 * the following about its contents:
56 
 * 1) The `functions' don't EVER return.  In otherwords haveing return state-
57 
 *    ments _anywere_ in this file is likely not to work.  This is because
58 
 *    dyngen just strips away the ret from the end of the function and just uses
59 
 *    the function `body'.  If a ret statement is executed _anyware_ inside the
60 
 *    dynamicly generated code, then it is undefined were we shall jump to.
61 
 * 2) Because of 1), try not to have overly complicated functions.  In too
62 
 *    complicated functions, gcc may decide to generate premature `exits'.  This
63 
 *    is what passing the -fno-reorder-blocks command line switch to gcc helps
64 
 *    with.  This is ofcourse not desired and is rather flaky as we don't (and
65 
 *    can't) control the kind of code that gcc generates: It may work for one
66 
 *    and break for another.  The less branches there are the less likely it is
67 
 *    that a premature return shall occur.
68 
 * 3) If gcc decides that it is going to be a basterd then it will optimise a
69 
 *    very simple condition (if/switch) with a premature exit.  But gcc can't
70 
 *    fuck ME over!  Just stick a FORCE_RET; at the END of the offending
71 
 *    function.
72 
 * 4) All operations must start with `op_'.  dyngen ignores all other functions.
73 
 * 5) Local variables are depriciated: They hinder performance.
74 
 * 6) Function calls are expensive as the stack has to be shifted (twice).
75 
 */
76 
 
77 
/*#define __or_dynop __attribute__((noreturn))*/
78 
#define __or_dynop
79 
 
80 
/* Temporaries to hold the (simulated) registers in */
81 
register uint32_t t0 asm(T0_REG);
82 
register uint32_t t1 asm(T1_REG);
83 
register uint32_t t2 asm(T2_REG);
84 
 
85 
#define OP_PARAM1 ((uorreg_t)(&__op_param1))
86 
#define OP_PARAM2 ((uorreg_t)(&__op_param2))
87 
#define OP_PARAM3 ((uorreg_t)(&__op_param3))
88 
 
89 
extern uorreg_t __op_param1;
90 
extern uorreg_t __op_param2;
91 
extern uorreg_t __op_param3;
92 
 
93 
 
94 1678 nogj 
static inline void save_t_bound(oraddr_t pc)
95 1452 nogj 
{
96 1678 nogj 
  int reg;
97 
 
98 
  pc = (pc & config.immu.page_offset_mask) / 4;
99 
  reg = env->curr_page->ts_bound[pc];
100 
 
101 
  if(reg & 0x1f)
102 
    env->reg[reg & 0x1f] = t0;
103 
 
104 
  if((reg >> 5) & 0x1f)
105 
    env->reg[(reg >> 5) & 0x1f] = t1;
106 
 
107 
  if((reg >> 10) & 0x1f)
108 
    env->reg[(reg >> 10) & 0x1f] = t2;
109 1452 nogj 
}
110 
 
111 
void do_sched_wrap(void)
112 
{
113 
  upd_sim_cycles();
114 1678 nogj 
  save_t_bound(env->pc - 4);
115 1452 nogj 
  do_scheduler();
116 
}
117 
 
118 1481 nogj 
/* do_scheduler wrapper for instructions that are in the delay slot */
119 
void do_sched_wrap_delay(void)
120 
{
121 
  upd_sim_cycles();
122 
  do_scheduler();
123 
}
124 
 
125 
void enter_dyn_code(oraddr_t addr, struct dyn_page *dp)
126 
{
127 1678 nogj 
  uint16_t reg = 0;
128 1481 nogj 
 
129 1483 nogj 
  addr &= config.immu.pagesize - 1;
130 1481 nogj 
  addr >>= 2;
131 
 
132 1678 nogj 
  if(addr)
133 
    reg = dp->ts_bound[addr - 1];
134 1481 nogj 
 
135 
  if(reg & 0x1f)
136 
    t0 = cpu_state.reg[reg & 0x1f];
137 
 
138 
  if((reg >> 5) & 0x1f)
139 
    t1 = cpu_state.reg[(reg >> 5) & 0x1f];
140 
 
141 
  if((reg >> 10) & 0x1f)
142 
    t2 = cpu_state.reg[(reg >> 10) & 0x1f];
143 
 
144 
  or_longjmp(dp->locs[addr]);
145 
}
146 
 
147 1452 nogj 
 
148 1481 nogj 
__or_dynop void op_set_pc_pc_delay(void)
149 1452 nogj 
{
150 1481 nogj 
  env->sprs[SPR_PPC] = get_pc();
151 
  /* pc_delay is pulled back 4 since imediatly after this is run, the scheduler
152 
   * runs which also increments it by 4 */
153 
  set_pc(env->pc_delay - 4);
154 1452 nogj 
}
155 
 
156 
__or_dynop void op_set_pc_delay_imm(void)
157 
{
158 
  env->pc_delay = get_pc() + (orreg_t)OP_PARAM1;
159 
  env->delay_insn = 1;
160 
}
161 
 
162 
__or_dynop void op_set_pc_delay_pc(void)
163 
{
164 
  env->pc_delay = get_pc();
165 
  env->delay_insn = 1;
166 
}
167 
 
168 
__or_dynop void op_clear_pc_delay(void)
169 
{
170 
  env->pc_delay = 0;
171 
  env->delay_insn = 1;
172 
}
173 
 
174 
__or_dynop void op_do_jump(void)
175 
{
176 1481 nogj 
  do_jump(get_pc());
177 
}
178 
 
179 
__or_dynop void op_do_jump_delay(void)
180 
{
181 1452 nogj 
  do_jump(env->pc_delay);
182 
}
183 
 
184 1481 nogj 
__or_dynop void op_clear_delay_insn(void)
185 1452 nogj 
{
186 1481 nogj 
  env->delay_insn = 0;
187 1452 nogj 
}
188 
 
189 1481 nogj 
__or_dynop void op_set_delay_insn(void)
190 1452 nogj 
{
191 1481 nogj 
  env->delay_insn = 1;
192 1452 nogj 
}
193 
 
194 1481 nogj 
__or_dynop void op_check_delay_slot(void)
195 1452 nogj 
{
196 1481 nogj 
  if(!env->delay_insn)
197 
    OP_JUMP(OP_PARAM1);
198 1452 nogj 
}
199 
 
200 
__or_dynop void op_jmp_imm(void)
201 
{
202 
  OP_JUMP(OP_PARAM1);
203 
}
204 
 
205 
__or_dynop void op_set_flag(void)
206 
{
207 
  env->sprs[SPR_SR] |= SPR_SR_F;
208 
}
209 
 
210 
__or_dynop void op_clear_flag(void)
211 
{
212 
  env->sprs[SPR_SR] &= ~SPR_SR_F;
213 
}
214 
 
215 1481 nogj 
/* Used for the l.bf instruction.  Therefore if the flag is not set, jump over
216 
 * all the jumping stuff */
217 1452 nogj 
__or_dynop void op_check_flag(void)
218 
{
219 1481 nogj 
  if(!(env->sprs[SPR_SR] & SPR_SR_F)) {
220 
    HANDLE_SCHED(do_sched_wrap, "no_sched_chk_flg");
221 
    OP_JUMP(OP_PARAM1);
222 
  }
223 
}
224 
 
225 
/* Used for l.bf if the delay slot instruction is on another page */
226 
__or_dynop void op_check_flag_delay(void)
227 
{
228 1452 nogj 
  if(env->sprs[SPR_SR] & SPR_SR_F) {
229 1481 nogj 
    env->delay_insn = 1;
230 1452 nogj 
    env->pc_delay = get_pc() + (orreg_t)OP_PARAM1;
231 
  }
232 
}
233 
 
234 1481 nogj 
/* Used for the l.bnf instruction.  Therefore if the flag is set, jump over all
235 
 * the jumping stuff */
236 1452 nogj 
__or_dynop void op_check_not_flag(void)
237 
{
238 1481 nogj 
  if(env->sprs[SPR_SR] & SPR_SR_F) {
239 
    HANDLE_SCHED(do_sched_wrap, "no_sched_chk_not_flg");
240 
    OP_JUMP(OP_PARAM1);
241 
  }
242 
}
243 
 
244 
/* Used for l.bnf if the delay slot instruction is on another page */
245 
__or_dynop void op_check_not_flag_delay(void)
246 
{
247 1452 nogj 
  if(!(env->sprs[SPR_SR] & SPR_SR_F)) {
248 1481 nogj 
    env->delay_insn = 1;
249 1452 nogj 
    env->pc_delay = get_pc() + (orreg_t)OP_PARAM1;
250 
  }
251 
}
252 
 
253 1481 nogj 
__or_dynop void op_add_pc(void)
254 1452 nogj 
{
255 1481 nogj 
  /* FIXME: Optimise */
256 
  set_pc(get_pc() + OP_PARAM1);
257 1452 nogj 
}
258 
 
259 
__or_dynop void op_nop_exit(void)
260 
{
261 
  upd_sim_cycles();
262 
  op_support_nop_exit();
263 
  FORCE_RET;
264 
}
265 
 
266 
__or_dynop void op_nop_reset(void)
267 
{
268 
  upd_sim_cycles();
269 
  op_support_nop_reset();
270 1481 nogj 
  do_jump(EXCEPT_RESET);
271 1452 nogj 
}
272 
 
273 
__or_dynop void op_nop_printf(void)
274 
{
275 
  upd_sim_cycles();
276 
  op_support_nop_printf();
277 
  FORCE_RET;
278 
}
279 
 
280 
__or_dynop void op_nop_report(void)
281 
{
282 
  upd_sim_cycles();
283 
  op_support_nop_report();
284 
  FORCE_RET;
285 
}
286 
 
287 
__or_dynop void op_nop_report_imm(void)
288 
{
289 
  upd_sim_cycles();
290 
  op_support_nop_report_imm(OP_PARAM1);
291 
}
292 
 
293 1657 nogj 
__or_dynop void op_analysis(void)
294 1452 nogj 
{
295 1657 nogj 
  env->iqueue.insn_index = OP_PARAM1;
296 
  env->iqueue.insn = OP_PARAM2;
297 
  env->iqueue.insn_addr = get_pc();
298 
  op_support_analysis();
299 
  FORCE_RET;
300 1452 nogj 
}
301 
 
302 1657 nogj 
__or_dynop void op_move_gpr1_pc_delay(void)
303 
{
304 
  env->pc_delay = env->reg[1];
305 
  env->delay_insn = 1;
306 
}
307 1452 nogj 
 
308 1657 nogj 
__or_dynop void op_move_gpr2_pc_delay(void)
309 1452 nogj 
{
310 1657 nogj 
  env->pc_delay = env->reg[2];
311 
  env->delay_insn = 1;
312 1452 nogj 
}
313 
 
314 1657 nogj 
__or_dynop void op_move_gpr3_pc_delay(void)
315 1452 nogj 
{
316 1657 nogj 
  env->pc_delay = env->reg[3];
317 
  env->delay_insn = 1;
318 1452 nogj 
}
319 
 
320 1657 nogj 
__or_dynop void op_move_gpr4_pc_delay(void)
321 
{
322 
  env->pc_delay = env->reg[4];
323 
  env->delay_insn = 1;
324 
}
325 1452 nogj 
 
326 1657 nogj 
__or_dynop void op_move_gpr5_pc_delay(void)
327 1452 nogj 
{
328 1657 nogj 
  env->pc_delay = env->reg[5];
329 
  env->delay_insn = 1;
330 1452 nogj 
}
331 
 
332 1657 nogj 
__or_dynop void op_move_gpr6_pc_delay(void)
333 1452 nogj 
{
334 1657 nogj 
  env->pc_delay = env->reg[6];
335 
  env->delay_insn = 1;
336 1452 nogj 
}
337 
 
338 1657 nogj 
__or_dynop void op_move_gpr7_pc_delay(void)
339 1452 nogj 
{
340 1657 nogj 
  env->pc_delay = env->reg[7];
341 
  env->delay_insn = 1;
342 1452 nogj 
}
343 
 
344 1657 nogj 
__or_dynop void op_move_gpr8_pc_delay(void)
345 1452 nogj 
{
346 1657 nogj 
  env->pc_delay = env->reg[8];
347 
  env->delay_insn = 1;
348 1452 nogj 
}
349 
 
350 1657 nogj 
__or_dynop void op_move_gpr9_pc_delay(void)
351 
{
352 
  env->pc_delay = env->reg[9];
353 
  env->delay_insn = 1;
354 
}
355 
 
356 
__or_dynop void op_move_gpr10_pc_delay(void)
357 
{
358 
  env->pc_delay = env->reg[10];
359 
  env->delay_insn = 1;
360 
}
361 
 
362 
__or_dynop void op_move_gpr11_pc_delay(void)
363 
{
364 
  env->pc_delay = env->reg[11];
365 
  env->delay_insn = 1;
366 
}
367 
 
368 
__or_dynop void op_move_gpr12_pc_delay(void)
369 
{
370 
  env->pc_delay = env->reg[12];
371 
  env->delay_insn = 1;
372 
}
373 
 
374 
__or_dynop void op_move_gpr13_pc_delay(void)
375 
{
376 
  env->pc_delay = env->reg[13];
377 
  env->delay_insn = 1;
378 
}
379 
 
380 
__or_dynop void op_move_gpr14_pc_delay(void)
381 
{
382 
  env->pc_delay = env->reg[14];
383 
  env->delay_insn = 1;
384 
}
385 
 
386 
__or_dynop void op_move_gpr15_pc_delay(void)
387 
{
388 
  env->pc_delay = env->reg[15];
389 
  env->delay_insn = 1;
390 
}
391 
 
392 
__or_dynop void op_move_gpr16_pc_delay(void)
393 
{
394 
  env->pc_delay = env->reg[16];
395 
  env->delay_insn = 1;
396 
}
397 
 
398 
__or_dynop void op_move_gpr17_pc_delay(void)
399 
{
400 
  env->pc_delay = env->reg[17];
401 
  env->delay_insn = 1;
402 
}
403 
 
404 
__or_dynop void op_move_gpr18_pc_delay(void)
405 
{
406 
  env->pc_delay = env->reg[18];
407 
  env->delay_insn = 1;
408 
}
409 
 
410 
__or_dynop void op_move_gpr19_pc_delay(void)
411 
{
412 
  env->pc_delay = env->reg[19];
413 
  env->delay_insn = 1;
414 
}
415 
 
416 
__or_dynop void op_move_gpr20_pc_delay(void)
417 
{
418 
  env->pc_delay = env->reg[20];
419 
  env->delay_insn = 1;
420 
}
421 
 
422 
__or_dynop void op_move_gpr21_pc_delay(void)
423 
{
424 
  env->pc_delay = env->reg[21];
425 
  env->delay_insn = 1;
426 
}
427 
 
428 
__or_dynop void op_move_gpr22_pc_delay(void)
429 
{
430 
  env->pc_delay = env->reg[22];
431 
  env->delay_insn = 1;
432 
}
433 
 
434 
__or_dynop void op_move_gpr23_pc_delay(void)
435 
{
436 
  env->pc_delay = env->reg[23];
437 
  env->delay_insn = 1;
438 
}
439 
 
440 
__or_dynop void op_move_gpr24_pc_delay(void)
441 
{
442 
  env->pc_delay = env->reg[24];
443 
  env->delay_insn = 1;
444 
}
445 
 
446 
__or_dynop void op_move_gpr25_pc_delay(void)
447 
{
448 
  env->pc_delay = env->reg[25];
449 
  env->delay_insn = 1;
450 
}
451 
 
452 
__or_dynop void op_move_gpr26_pc_delay(void)
453 
{
454 
  env->pc_delay = env->reg[26];
455 
  env->delay_insn = 1;
456 
}
457 
 
458 
__or_dynop void op_move_gpr27_pc_delay(void)
459 
{
460 
  env->pc_delay = env->reg[27];
461 
  env->delay_insn = 1;
462 
}
463 
 
464 
__or_dynop void op_move_gpr28_pc_delay(void)
465 
{
466 
  env->pc_delay = env->reg[28];
467 
  env->delay_insn = 1;
468 
}
469 
 
470 
__or_dynop void op_move_gpr29_pc_delay(void)
471 
{
472 
  env->pc_delay = env->reg[29];
473 
  env->delay_insn = 1;
474 
}
475 
 
476 
__or_dynop void op_move_gpr30_pc_delay(void)
477 
{
478 
  env->pc_delay = env->reg[30];
479 
  env->delay_insn = 1;
480 
}
481 
 
482 
__or_dynop void op_move_gpr31_pc_delay(void)
483 
{
484 
  env->pc_delay = env->reg[31];
485 
  env->delay_insn = 1;
486 
}
487 
 
488 
#define OP_FILE "op_1t_op.h"
489 
#include "op_1t.h"
490 
#undef OP_FILE
491 1658 nogj 
 
492 
#define OP_FILE "op_2t_op.h"
493 
#include "op_2t.h"
494 
#undef OP_FILE
495 1660 nogj 
 
496 
#define OP_FILE "op_3t_op.h"
497 
#include "op_3t.h"
498 
#undef OP_FILE
499 
 
500 1661 nogj 
#define OP_FILE "op_arith_op.h"
501 1452 nogj 
#define OP_EXTRA
502 
 
503 
#define OP /
504 1661 nogj 
#define OP_CAST(x) (orreg_t)(x)
505 1452 nogj 
#define OP_NAME div
506 1661 nogj 
#include "op_3t.h"
507 1452 nogj 
#undef OP_NAME
508 
#undef OP_CAST
509 
#undef OP
510 
 
511 
#define OP /
512 1661 nogj 
#define OP_CAST(x) (x)
513 1452 nogj 
#define OP_NAME divu
514 1661 nogj 
#include "op_3t.h"
515 1452 nogj 
#undef OP_NAME
516 
#undef OP_CAST
517 
#undef OP
518 
 
519 
#define OP *
520 1661 nogj 
#define OP_CAST(x) (x)
521 1452 nogj 
#define OP_NAME mulu
522 1661 nogj 
#include "op_3t.h"
523 1452 nogj 
#undef OP_NAME
524 
#undef OP_CAST
525 
#undef OP
526 
 
527 
#define OP -
528 1661 nogj 
#define OP_CAST(x) (orreg_t)(x)
529 1452 nogj 
#define OP_NAME sub
530 1661 nogj 
#include "op_3t.h"
531 1452 nogj 
#undef OP_NAME
532 
#undef OP_CAST
533 
#undef OP
534 
 
535 
#undef OP_EXTRA
536 
 
537 
#define OP_EXTRA + ((env->sprs[SPR_SR] & SPR_SR_CY) >> 10)
538 
#define OP +
539 1661 nogj 
#define OP_CAST(x) (orreg_t)(x)
540 1452 nogj 
#define OP_NAME addc
541 1661 nogj 
#include "op_3t.h"
542 
#include "op_2t.h"
543 1452 nogj 
#undef OP_NAME
544 
#undef OP_CAST
545 
#undef OP
546 
 
547 
#undef OP_EXTRA
548 
#define OP_EXTRA
549 
 
550 
#define OP +
551 1661 nogj 
#define OP_CAST(x) (orreg_t)(x)
552 1452 nogj 
#define OP_NAME add
553 1661 nogj 
#include "op_3t.h"
554 
#include "op_2t.h"
555 1452 nogj 
#undef OP_NAME
556 
#undef OP_CAST
557 
#undef OP
558 
 
559 
#define OP &
560 1661 nogj 
#define OP_CAST(x) (x)
561 1452 nogj 
#define OP_NAME and
562 1661 nogj 
#include "op_3t.h"
563 
#include "op_2t.h"
564 1452 nogj 
#undef OP_NAME
565 
#undef OP_CAST
566 
#undef OP
567 
 
568 
#define OP *
569 1661 nogj 
#define OP_CAST(x) (orreg_t)(x)
570 1452 nogj 
#define OP_NAME mul
571 1661 nogj 
#include "op_3t.h"
572 
#include "op_2t.h"
573 1452 nogj 
#undef OP_NAME
574 
#undef OP_CAST
575 
#undef OP
576 
 
577 
#define OP |
578 1661 nogj 
#define OP_CAST(x) (x)
579 1452 nogj 
#define OP_NAME or
580 1661 nogj 
#include "op_3t.h"
581 
#include "op_2t.h"
582 1452 nogj 
#undef OP_NAME
583 
#undef OP_CAST
584 
#undef OP
585 
 
586 
#define OP <<
587 1661 nogj 
#define OP_CAST(x) (x)
588 1452 nogj 
#define OP_NAME sll
589 1661 nogj 
#include "op_3t.h"
590 
#include "op_2t.h"
591 1452 nogj 
#undef OP_NAME
592 
#undef OP_CAST
593 
#undef OP
594 
 
595 
#define OP >>
596 1661 nogj 
#define OP_CAST(x) (orreg_t)(x)
597 1452 nogj 
#define OP_NAME sra
598 1661 nogj 
#include "op_3t.h"
599 
#include "op_2t.h"
600 1452 nogj 
#undef OP_NAME
601 
#undef OP_CAST
602 
#undef OP
603 
 
604 
#define OP >>
605 1661 nogj 
#define OP_CAST(x) (x)
606 1452 nogj 
#define OP_NAME srl
607 1661 nogj 
#include "op_3t.h"
608 
#include "op_2t.h"
609 1452 nogj 
#undef OP_NAME
610 
#undef OP_CAST
611 
#undef OP
612 
 
613 
#define OP ^
614 1661 nogj 
#define OP_CAST(x) (x)
615 1452 nogj 
#define OP_NAME xor
616 1661 nogj 
#include "op_3t.h"
617 
#include "op_2t.h"
618 1452 nogj 
#undef OP_NAME
619 
#undef OP_CAST
620 
#undef OP
621 
 
622 
#undef OP_EXTRA
623 1661 nogj 
#undef OP_FILE
624 1452 nogj 
 
625 1662 nogj 
#define OP_FILE "op_extend_op.h"
626 
 
627 1452 nogj 
#define EXT_NAME extbs
628 
#define EXT_TYPE int8_t
629 
#define EXT_CAST (orreg_t)
630 1662 nogj 
#include "op_2t.h"
631 1452 nogj 
#undef EXT_CAST
632 
#undef EXT_TYPE
633 
#undef EXT_NAME
634 
 
635 
#define EXT_NAME extbz
636 
#define EXT_TYPE uint8_t
637 
#define EXT_CAST (uorreg_t)
638 1662 nogj 
#include "op_2t.h"
639 1452 nogj 
#undef EXT_CAST
640 
#undef EXT_TYPE
641 
#undef EXT_NAME
642 
 
643 
#define EXT_NAME exths
644 
#define EXT_TYPE int16_t
645 
#define EXT_CAST (orreg_t)
646 1662 nogj 
#include "op_2t.h"
647 1452 nogj 
#undef EXT_CAST
648 
#undef EXT_TYPE
649 
#undef EXT_NAME
650 
 
651 
#define EXT_NAME exthz
652 
#define EXT_TYPE uint16_t
653 
#define EXT_CAST (uorreg_t)
654 1662 nogj 
#include "op_2t.h"
655 1452 nogj 
#undef EXT_CAST
656 
#undef EXT_TYPE
657 
#undef EXT_NAME
658 
 
659 1662 nogj 
#undef OP_FILE
660 
 
661 1663 nogj 
#define OP_FILE "op_comp_op.h"
662 
 
663 1452 nogj 
#define COMP ==
664 
#define COMP_NAME sfeq
665 1663 nogj 
#define COMP_CAST(x) (x)
666 
#include "op_2t.h"
667 
#include "op_1t.h"
668 1452 nogj 
#undef COMP_CAST
669 
#undef COMP_NAME
670 
#undef COMP
671 
 
672 
#define COMP !=
673 
#define COMP_NAME sfne
674 1663 nogj 
#define COMP_CAST(x) (x)
675 
#include "op_2t.h"
676 
#include "op_1t.h"
677 1452 nogj 
#undef COMP_CAST
678 
#undef COMP_NAME
679 
#undef COMP
680 
 
681 
#define COMP >
682 
#define COMP_NAME sfgtu
683 1663 nogj 
#define COMP_CAST(x) (x)
684 
#include "op_2t.h"
685 
#include "op_1t.h"
686 1452 nogj 
#undef COMP_CAST
687 
#undef COMP_NAME
688 
#undef COMP
689 
 
690 
#define COMP >=
691 
#define COMP_NAME sfgeu
692 1663 nogj 
#define COMP_CAST(x) (x)
693 
#include "op_2t.h"
694 
#include "op_1t.h"
695 1452 nogj 
#undef COMP_CAST
696 
#undef COMP_NAME
697 
#undef COMP
698 
 
699 
#define COMP <
700 
#define COMP_NAME sfltu
701 1663 nogj 
#define COMP_CAST(x) (x)
702 
#include "op_2t.h"
703 
#include "op_1t.h"
704 1452 nogj 
#undef COMP_CAST
705 
#undef COMP_NAME
706 
#undef COMP
707 
 
708 
#define COMP <=
709 
#define COMP_NAME sfleu
710 1663 nogj 
#define COMP_CAST(x) (x)
711 
#include "op_2t.h"
712 
#include "op_1t.h"
713 1452 nogj 
#undef COMP_CAST
714 
#undef COMP_NAME
715 
#undef COMP
716 
 
717 
#define COMP >
718 
#define COMP_NAME sfgts
719 1663 nogj 
#define COMP_CAST(x) (orreg_t)(x)
720 
#include "op_2t.h"
721 
#include "op_1t.h"
722 1452 nogj 
#undef COMP_CAST
723 
#undef COMP_NAME
724 
#undef COMP
725 
 
726 
#define COMP >=
727 
#define COMP_NAME sfges
728 1663 nogj 
#define COMP_CAST(x) (orreg_t)(x)
729 
#include "op_2t.h"
730 
#include "op_1t.h"
731 1452 nogj 
#undef COMP_CAST
732 
#undef COMP_NAME
733 
#undef COMP
734 
 
735 
#define COMP <
736 
#define COMP_NAME sflts
737 1663 nogj 
#define COMP_CAST(x) (orreg_t)(x)
738 
#include "op_2t.h"
739 
#include "op_1t.h"
740 1452 nogj 
#undef COMP_CAST
741 
#undef COMP_NAME
742 
#undef COMP
743 
 
744 
#define COMP <=
745 
#define COMP_NAME sfles
746 1663 nogj 
#define COMP_CAST(x) (orreg_t)(x)
747 
#include "op_2t.h"
748 
#include "op_1t.h"
749 1452 nogj 
#undef COMP_CAST
750 
#undef COMP_NAME
751 
#undef COMP
752 
 
753 1663 nogj 
#undef OP_FILE
754 
 
755 1657 nogj 
#define OP_FILE "op_t_reg_mov_op.h"
756 
#include "op_1t.h"
757 
#undef OP_FILE
758 1452 nogj 
 
759 1664 nogj 
#define OP_FILE "op_mftspr_op.h"
760 
#include "op_1t.h"
761 
#include "op_2t.h"
762 
#undef OP_FILE
763 1452 nogj 
#include "op_mftspr_op.h"
764 
 
765 1665 nogj 
#define OP_FILE "op_mac_op.h"
766 1452 nogj 
 
767 
#define OP +=
768 
#define OP_NAME mac
769 1665 nogj 
#include "op_2t.h"
770 1452 nogj 
#undef OP_NAME
771 
#undef OP
772 
 
773 
#define OP -=
774 
#define OP_NAME msb
775 1665 nogj 
#include "op_2t.h"
776 1452 nogj 
#undef OP_NAME
777 
#undef OP
778 
 
779 1665 nogj 
#undef OP_FILE
780 
 
781 1666 nogj 
#define OP_FILE "op_lwhb_op.h"
782 
 
783 1452 nogj 
#define LS_OP_NAME lbz
784 
#define LS_OP_CAST
785 
#define LS_OP_FUNC eval_mem8
786 1666 nogj 
#include "op_2t.h"
787 
#include "op_1t.h"
788 1452 nogj 
#undef LS_OP_FUNC
789 
#undef LS_OP_CAST
790 
#undef LS_OP_NAME
791 
 
792 
#define LS_OP_NAME lbs
793 
#define LS_OP_CAST (int8_t)
794 
#define LS_OP_FUNC eval_mem8
795 1666 nogj 
#include "op_2t.h"
796 
#include "op_1t.h"
797 1452 nogj 
#undef LS_OP_FUNC
798 
#undef LS_OP_CAST
799 
#undef LS_OP_NAME
800 
 
801 
#define LS_OP_NAME lhz
802 
#define LS_OP_CAST
803 
#define LS_OP_FUNC eval_mem16
804 1666 nogj 
#include "op_2t.h"
805 
#include "op_1t.h"
806 1452 nogj 
#undef LS_OP_FUNC
807 
#undef LS_OP_CAST
808 
#undef LS_OP_NAME
809 
 
810 
#define LS_OP_NAME lhs
811 
#define LS_OP_CAST (int16_t)
812 
#define LS_OP_FUNC eval_mem16
813 1666 nogj 
#include "op_2t.h"
814 
#include "op_1t.h"
815 1452 nogj 
#undef LS_OP_FUNC
816 
#undef LS_OP_CAST
817 
#undef LS_OP_NAME
818 
 
819 
#define LS_OP_NAME lwz
820 
#define LS_OP_CAST
821 
#define LS_OP_FUNC eval_mem32
822 1666 nogj 
#include "op_2t.h"
823 
#include "op_1t.h"
824 1452 nogj 
#undef LS_OP_FUNC
825 
#undef LS_OP_CAST
826 
#undef LS_OP_NAME
827 
 
828 
#define LS_OP_NAME lws
829 
#define LS_OP_CAST (int32_t)
830 
#define LS_OP_FUNC eval_mem32
831 1666 nogj 
#include "op_2t.h"
832 
#include "op_1t.h"
833 1452 nogj 
#undef LS_OP_FUNC
834 
#undef LS_OP_CAST
835 
#undef LS_OP_NAME
836 
 
837 1666 nogj 
#undef OP_FILE
838 
 
839 1667 nogj 
#define OP_FILE "op_swhb_op.h"
840 
 
841 1452 nogj 
#define S_OP_NAME sb
842 
#define S_FUNC set_mem8
843 
#include "op_swhb_op.h"
844 1667 nogj 
#include "op_2t.h"
845 
#include "op_1t.h"
846 1452 nogj 
#undef S_FUNC
847 
#undef S_OP_NAME
848 
 
849 
#define S_OP_NAME sh
850 
#define S_FUNC set_mem16
851 
#include "op_swhb_op.h"
852 1667 nogj 
#include "op_2t.h"
853 
#include "op_1t.h"
854 1452 nogj 
#undef S_FUNC
855 
#undef S_OP_NAME
856 
 
857 
#define S_OP_NAME sw
858 
#define S_FUNC set_mem32
859 
#include "op_swhb_op.h"
860 1667 nogj 
#include "op_2t.h"
861 
#include "op_1t.h"
862 1452 nogj 
#undef S_FUNC
863 
#undef S_OP_NAME
864 
 
865 
__or_dynop void op_join_mem_cycles(void)
866 
{
867 
  join_mem_cycles();
868 
}
869 
 
870 
__or_dynop void op_store_link_addr_gpr(void)
871 
{
872 
  env->reg[LINK_REGNO] = get_pc() + 8;
873 
}
874 
 
875 
__or_dynop void op_prep_rfe(void)
876 
{
877 
  env->sprs[SPR_SR] = env->sprs[SPR_ESR_BASE] | SPR_SR_FO;
878 
  env->sprs[SPR_PPC] = get_pc();
879 1481 nogj 
  set_pc(env->sprs[SPR_EPCR_BASE] - 4);
880 1452 nogj 
}
881 
 
882 
static inline void prep_except(oraddr_t epcr_base)
883 
{
884 
  env->sprs[SPR_EPCR_BASE] = epcr_base;
885 
 
886 
  env->sprs[SPR_ESR_BASE] = env->sprs[SPR_SR];
887 
 
888 
  /* Address translation is always disabled when starting exception. */
889 
  env->sprs[SPR_SR] &= ~SPR_SR_DME;
890 
  env->sprs[SPR_SR] &= ~SPR_SR_IME;
891 
 
892 
  env->sprs[SPR_SR] &= ~SPR_SR_OVE;   /* Disable overflow flag exception. */
893 
 
894 
  env->sprs[SPR_SR] |= SPR_SR_SM;     /* SUPV mode */
895 
  env->sprs[SPR_SR] &= ~(SPR_SR_IEE | SPR_SR_TEE);    /* Disable interrupts. */
896 
}
897 
 
898 
__or_dynop void op_set_except_pc(void)
899 
{
900 
  set_pc(OP_PARAM1);
901 
}
902 
 
903 
/* Before the code in op_{sys,trap}{,_delay} gets run, the scheduler runs.
904 
 * Therefore the pc will point to the instruction after the l.sys or l.trap
905 
 * instruction */
906 
__or_dynop void op_prep_sys_delay(void)
907 
{
908 
  env->delay_insn = 0;
909 
  prep_except(get_pc() - 4);
910 1481 nogj 
  set_pc(EXCEPT_SYSCALL - 4);
911 1452 nogj 
}
912 
 
913 
__or_dynop void op_prep_sys(void)
914 
{
915 
  prep_except(get_pc() + 4);
916 1481 nogj 
  set_pc(EXCEPT_SYSCALL - 4);
917 1452 nogj 
}
918 
 
919 
__or_dynop void op_prep_trap_delay(void)
920 
{
921 
  env->delay_insn = 0;
922 
  prep_except(get_pc() - 4);
923 1481 nogj 
  set_pc(EXCEPT_TRAP - 4);
924 1452 nogj 
}
925 
 
926 
__or_dynop void op_prep_trap(void)
927 
{
928 
  prep_except(get_pc());
929 1481 nogj 
  set_pc(EXCEPT_TRAP - 4);
930 1452 nogj 
}
931 
 
932 
/* FIXME: This `instruction' should be split up like the l.trap and l.sys
933 
 * instructions are done */
934 
__or_dynop void op_illegal_delay(void)
935 
{
936 
  env->delay_insn = 0;
937 
  env->sprs[SPR_EEAR_BASE] = get_pc() - 4;
938 1481 nogj 
  do_jump(EXCEPT_ILLEGAL - 4);
939 1452 nogj 
}
940 
 
941 
__or_dynop void op_illegal(void)
942 
{
943 
  env->sprs[SPR_EEAR_BASE] = get_pc();
944 1481 nogj 
  do_jump(EXCEPT_ILLEGAL);
945 1452 nogj 
}
946 
 
947 
__or_dynop void op_do_sched(void)
948 
{
949 1481 nogj 
  HANDLE_SCHED(do_sched_wrap, "no_sched");
950 1452 nogj 
}
951 
 
952 1481 nogj 
__or_dynop void op_do_sched_delay(void)
953 
{
954 
  HANDLE_SCHED(do_sched_wrap_delay, "no_sched_delay");
955 
}
956 
 
957 1452 nogj 
__or_dynop void op_macc(void)
958 
{
959 
  env->sprs[SPR_MACLO] = 0;
960 
  env->sprs[SPR_MACHI] = 0;
961 
}
962 
 
963 
__or_dynop void op_store_insn_ea(void)
964 
{
965 
  env->insn_ea = OP_PARAM1;
966 
}
967 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.