| Line 20... | Line 20... | 
      
        |  
 |  
 | 
      
        | INSTRUCTION (l_add) {
 | INSTRUCTION (l_add) {
 | 
      
        |   signed long temp1, temp2, temp3;
 |   signed long temp1, temp2, temp3;
 | 
      
        |   signed char temp4;
 |   signed char temp4;
 | 
      
        |  
 |  
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_arith;
 |   | 
      
        |   temp2 = (signed long)PARAM2;
 |   temp2 = (signed long)PARAM2;
 | 
      
        |   temp3 = (signed long)PARAM1;
 |   temp3 = (signed long)PARAM1;
 | 
      
        |   temp1 = temp2 + temp3;
 |   temp1 = temp2 + temp3;
 | 
      
        |   SET_PARAM0(temp1);
 |   SET_PARAM0(temp1);
 | 
      
        |   set_ov_flag (temp1);
 |   set_ov_flag (temp1);
 | 
      
        | Line 43... | Line 42... | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_addc) {
 | INSTRUCTION (l_addc) {
 | 
      
        |   signed long temp1, temp2, temp3;
 |   signed long temp1, temp2, temp3;
 | 
      
        |   signed char temp4;
 |   signed char temp4;
 | 
      
        |  
 |  
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_arith;
 |   | 
      
        |   temp2 = (signed long)PARAM2;
 |   temp2 = (signed long)PARAM2;
 | 
      
        |   temp3 = (signed long)PARAM1;
 |   temp3 = (signed long)PARAM1;
 | 
      
        |   temp1 = temp2 + temp3 + getsprbits(SPR_SR, SPR_SR_CY);
 |   temp1 = temp2 + temp3 + getsprbits(SPR_SR, SPR_SR_CY);
 | 
      
        |   SET_PARAM0(temp1);
 |   SET_PARAM0(temp1);
 | 
      
        |   set_ov_flag (temp1);
 |   set_ov_flag (temp1);
 | 
      
        | Line 64... | Line 62... | 
      
        |   if (temp4 == temp1)
 |   if (temp4 == temp1)
 | 
      
        |     or1k_mstats.byteadd++;
 |     or1k_mstats.byteadd++;
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sw) {
 | INSTRUCTION (l_sw) {
 | 
      
        |   int old_cyc = 0;
 |   int old_cyc = 0;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_store;
 |   | 
      
        |   IFF (config.cpu.sbuf_len) old_cyc = runtime.sim.mem_cycles;
 |   IFF (config.cpu.sbuf_len) old_cyc = runtime.sim.mem_cycles;
 | 
      
        |   set_mem32(PARAM0, PARAM1, &breakpoint);
 |   set_mem32(PARAM0, PARAM1, &breakpoint);
 | 
      
        |   if (config.cpu.sbuf_len) {
 |   if (config.cpu.sbuf_len) {
 | 
      
        |     int t = runtime.sim.mem_cycles;
 |     int t = runtime.sim.mem_cycles;
 | 
      
        |     runtime.sim.mem_cycles = old_cyc;
 |     runtime.sim.mem_cycles = old_cyc;
 | 
      
        |     sbuf_store (t - old_cyc);
 |     sbuf_store (t - old_cyc);
 | 
      
        |   }
 |   }
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sb) {
 | INSTRUCTION (l_sb) {
 | 
      
        |   int old_cyc = 0;
 |   int old_cyc = 0;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_store;
 |   | 
      
        |   IFF (config.cpu.sbuf_len) old_cyc = runtime.sim.mem_cycles;
 |   IFF (config.cpu.sbuf_len) old_cyc = runtime.sim.mem_cycles;
 | 
      
        |   set_mem8(PARAM0, PARAM1, &breakpoint);
 |   set_mem8(PARAM0, PARAM1, &breakpoint);
 | 
      
        |   if (config.cpu.sbuf_len) {
 |   if (config.cpu.sbuf_len) {
 | 
      
        |     int t = runtime.sim.mem_cycles;
 |     int t = runtime.sim.mem_cycles;
 | 
      
        |     runtime.sim.mem_cycles = old_cyc;
 |     runtime.sim.mem_cycles = old_cyc;
 | 
      
        |     sbuf_store (t- old_cyc);
 |     sbuf_store (t- old_cyc);
 | 
      
        |   }
 |   }
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sh) {
 | INSTRUCTION (l_sh) {
 | 
      
        |   int old_cyc = 0;
 |   int old_cyc = 0;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_store;
 |   | 
      
        |   IFF (config.cpu.sbuf_len) old_cyc = runtime.sim.mem_cycles;
 |   IFF (config.cpu.sbuf_len) old_cyc = runtime.sim.mem_cycles;
 | 
      
        |   set_mem16(PARAM0, PARAM1, &breakpoint);
 |   set_mem16(PARAM0, PARAM1, &breakpoint);
 | 
      
        |   if (config.cpu.sbuf_len) {
 |   if (config.cpu.sbuf_len) {
 | 
      
        |     int t = runtime.sim.mem_cycles;
 |     int t = runtime.sim.mem_cycles;
 | 
      
        |     runtime.sim.mem_cycles = old_cyc;
 |     runtime.sim.mem_cycles = old_cyc;
 | 
      
        |     sbuf_store (t - old_cyc);
 |     sbuf_store (t - old_cyc);
 | 
      
        |   }
 |   }
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_lwz) {
 | INSTRUCTION (l_lwz) {
 | 
      
        |   unsigned long val;
 |   unsigned long val;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_load;
 |   | 
      
        |   if (config.cpu.sbuf_len) sbuf_load ();
 |   if (config.cpu.sbuf_len) sbuf_load ();
 | 
      
        |   val = eval_mem32(PARAM1, &breakpoint);
 |   val = eval_mem32(PARAM1, &breakpoint);
 | 
      
        |   /* If eval operand produced exception don't set anything */
 |   /* If eval operand produced exception don't set anything */
 | 
      
        |   if (!pending.valid)
 |   if (!pending.valid)
 | 
      
        |     SET_PARAM0(val);
 |     SET_PARAM0(val);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_lbs) {
 | INSTRUCTION (l_lbs) {
 | 
      
        |   signed char val;
 |   signed char val;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_load;
 |   | 
      
        |   if (config.cpu.sbuf_len) sbuf_load ();
 |   if (config.cpu.sbuf_len) sbuf_load ();
 | 
      
        |   val = eval_mem8(PARAM1, &breakpoint);
 |   val = eval_mem8(PARAM1, &breakpoint);
 | 
      
        |   /* If eval opreand produced exception don't set anything */
 |   /* If eval opreand produced exception don't set anything */
 | 
      
        |   if (!pending.valid)
 |   if (!pending.valid)
 | 
      
        |     SET_PARAM0(val);
 |     SET_PARAM0(val);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_lbz) {
 | INSTRUCTION (l_lbz) {
 | 
      
        |   unsigned char val;
 |   unsigned char val;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_load;
 |   | 
      
        |   if (config.cpu.sbuf_len) sbuf_load ();
 |   if (config.cpu.sbuf_len) sbuf_load ();
 | 
      
        |   val = eval_mem8(PARAM1, &breakpoint);
 |   val = eval_mem8(PARAM1, &breakpoint);
 | 
      
        |   /* If eval opreand produced exception don't set anything */
 |   /* If eval opreand produced exception don't set anything */
 | 
      
        |   if (!pending.valid)
 |   if (!pending.valid)
 | 
      
        |     SET_PARAM0(val);
 |     SET_PARAM0(val);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_lhs) {
 | INSTRUCTION (l_lhs) {
 | 
      
        |   signed short val;
 |   signed short val;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_load;
 |   | 
      
        |   if (config.cpu.sbuf_len) sbuf_load ();
 |   if (config.cpu.sbuf_len) sbuf_load ();
 | 
      
        |   val = eval_mem16(PARAM1, &breakpoint);
 |   val = eval_mem16(PARAM1, &breakpoint);
 | 
      
        |   /* If eval opreand produced exception don't set anything */
 |   /* If eval opreand produced exception don't set anything */
 | 
      
        |   if (!pending.valid)
 |   if (!pending.valid)
 | 
      
        |     SET_PARAM0(val);
 |     SET_PARAM0(val);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_lhz) {
 | INSTRUCTION (l_lhz) {
 | 
      
        |   unsigned short val;
 |   unsigned short val;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_load;
 |   | 
      
        |   if (config.cpu.sbuf_len) sbuf_load ();
 |   if (config.cpu.sbuf_len) sbuf_load ();
 | 
      
        |   val = eval_mem16(PARAM1, &breakpoint);
 |   val = eval_mem16(PARAM1, &breakpoint);
 | 
      
        |   /* If eval opreand produced exception don't set anything */
 |   /* If eval opreand produced exception don't set anything */
 | 
      
        |   if (!pending.valid)
 |   if (!pending.valid)
 | 
      
        |     SET_PARAM0(val);
 |     SET_PARAM0(val);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_movhi) {
 | INSTRUCTION (l_movhi) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_movimm;
 |   | 
      
        |   SET_PARAM0(PARAM1 << 16);
 |   SET_PARAM0(PARAM1 << 16);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_and) {
 | INSTRUCTION (l_and) {
 | 
      
        |   unsigned long temp1;
 |   unsigned long temp1;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_arith;
 |   | 
      
        |   temp1 = PARAM1 & PARAM2;
 |   temp1 = PARAM1 & PARAM2;
 | 
      
        |   set_ov_flag (temp1);
 |   set_ov_flag (temp1);
 | 
      
        |   SET_PARAM0(temp1);
 |   SET_PARAM0(temp1);
 | 
      
        |   if (ARITH_SET_FLAG) {
 |   if (ARITH_SET_FLAG) {
 | 
      
        |     flag = temp1 == 0;
 |     flag = temp1 == 0;
 | 
      
        |     setsprbits(SPR_SR, SPR_SR_F, flag);
 |     setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        |   }
 |   }
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_or) {
 | INSTRUCTION (l_or) {
 | 
      
        |   unsigned long temp1;
 |   unsigned long temp1;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_arith;
 |   | 
      
        |   temp1 = PARAM1 | PARAM2;
 |   temp1 = PARAM1 | PARAM2;
 | 
      
        |   set_ov_flag (temp1);
 |   set_ov_flag (temp1);
 | 
      
        |   SET_PARAM0(temp1);
 |   SET_PARAM0(temp1);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_xor) {
 | INSTRUCTION (l_xor) {
 | 
      
        |   unsigned long temp1;
 |   unsigned long temp1;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_arith;
 |   | 
      
        |   temp1 = PARAM1 ^ PARAM2;
 |   temp1 = PARAM1 ^ PARAM2;
 | 
      
        |   set_ov_flag (temp1);
 |   set_ov_flag (temp1);
 | 
      
        |   SET_PARAM0(temp1);
 |   SET_PARAM0(temp1);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sub) {
 | INSTRUCTION (l_sub) {
 | 
      
        |   signed long temp1;
 |   signed long temp1;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_arith;
 |   | 
      
        |   temp1 = (signed long)PARAM1 - (signed long)PARAM2;
 |   temp1 = (signed long)PARAM1 - (signed long)PARAM2;
 | 
      
        |   set_ov_flag (temp1);
 |   set_ov_flag (temp1);
 | 
      
        |   SET_PARAM0(temp1);
 |   SET_PARAM0(temp1);
 | 
      
        | }
 | }
 | 
      
        | /*int mcount = 0;*/
 | /*int mcount = 0;*/
 | 
      
        | INSTRUCTION (l_mul) {
 | INSTRUCTION (l_mul) {
 | 
      
        |   signed long temp1;
 |   signed long temp1;
 | 
      
        |  
 |  
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_arith;
 |   | 
      
        |  
 |   | 
      
        |   temp1 = PARAM1 * PARAM2;
 |   temp1 = PARAM1 * PARAM2;
 | 
      
        |   set_ov_flag (temp1);
 |   set_ov_flag (temp1);
 | 
      
        |   SET_PARAM0(temp1);
 |   SET_PARAM0(temp1);
 | 
      
        |   /*if (!(mcount++ & 1023)) {
 |   /*if (!(mcount++ & 1023)) {
 | 
      
        |     PRINTF ("[%i]\n",mcount);
 |     PRINTF ("[%i]\n",mcount);
 | 
      
        |     }*/
 |     }*/
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_div) {
 | INSTRUCTION (l_div) {
 | 
      
        |   signed long temp3, temp2, temp1;
 |   signed long temp3, temp2, temp1;
 | 
      
        |  
 |  
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_arith;
 |   | 
      
        |   temp3 = PARAM2;
 |   temp3 = PARAM2;
 | 
      
        |   temp2 = PARAM1;
 |   temp2 = PARAM1;
 | 
      
        |   if (temp3)
 |   if (temp3)
 | 
      
        |     temp1 = temp2 / temp3;
 |     temp1 = temp2 / temp3;
 | 
      
        |   else {
 |   else {
 | 
      
        | Line 207... | Line 189... | 
      
        |   SET_PARAM0(temp1);
 |   SET_PARAM0(temp1);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_divu) {
 | INSTRUCTION (l_divu) {
 | 
      
        |   unsigned long temp3, temp2, temp1;
 |   unsigned long temp3, temp2, temp1;
 | 
      
        |  
 |  
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_arith;
 |   | 
      
        |   temp3 = PARAM2;
 |   temp3 = PARAM2;
 | 
      
        |   temp2 = PARAM1;
 |   temp2 = PARAM1;
 | 
      
        |   if (temp3)
 |   if (temp3)
 | 
      
        |     temp1 = temp2 / temp3;
 |     temp1 = temp2 / temp3;
 | 
      
        |   else {
 |   else {
 | 
      
        | Line 223... | Line 204... | 
      
        |   /* runtime.sim.cycles += 16; */
 |   /* runtime.sim.cycles += 16; */
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sll) {
 | INSTRUCTION (l_sll) {
 | 
      
        |   unsigned long temp1;
 |   unsigned long temp1;
 | 
      
        |  
 |  
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_shift;
 |   | 
      
        |  
 |   | 
      
        |   temp1 = PARAM1 << PARAM2;
 |   temp1 = PARAM1 << PARAM2;
 | 
      
        |   set_ov_flag (temp1);
 |   set_ov_flag (temp1);
 | 
      
        |   SET_PARAM0(temp1);
 |   SET_PARAM0(temp1);
 | 
      
        |   /* runtime.sim.cycles += 2; */
 |   /* runtime.sim.cycles += 2; */
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sra) {
 | INSTRUCTION (l_sra) {
 | 
      
        |   signed long temp1;
 |   signed long temp1;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_shift;
 |   | 
      
        |  
 |  
 | 
      
        |   temp1 = (signed)PARAM1 >> PARAM2;
 |   temp1 = (signed)PARAM1 >> PARAM2;
 | 
      
        |   set_ov_flag (temp1);
 |   set_ov_flag (temp1);
 | 
      
        |   SET_PARAM0(temp1);
 |   SET_PARAM0(temp1);
 | 
      
        |   /* runtime.sim.cycles += 2; */
 |   /* runtime.sim.cycles += 2; */
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_srl) {
 | INSTRUCTION (l_srl) {
 | 
      
        |   unsigned long temp1;
 |   unsigned long temp1;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_shift;
 |   | 
      
        |   temp1 = PARAM1 >> PARAM2;
 |   temp1 = PARAM1 >> PARAM2;
 | 
      
        |   set_ov_flag (temp1);
 |   set_ov_flag (temp1);
 | 
      
        |   SET_PARAM0(temp1);
 |   SET_PARAM0(temp1);
 | 
      
        |   /* runtime.sim.cycles += 2; */
 |   /* runtime.sim.cycles += 2; */
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_bf) {
 | INSTRUCTION (l_bf) {
 | 
      
        |   if (config.bpb.enabled) {
 |   if (config.bpb.enabled) {
 | 
      
        |     int fwd = (PARAM0 >= pc) ? 1 : 0;
 |     int fwd = (PARAM0 >= pc) ? 1 : 0;
 | 
      
        |     IFF (config.cpu.dependstats) current->func_unit = it_branch;
 |   | 
      
        |     or1k_mstats.bf[flag][fwd]++;
 |     or1k_mstats.bf[flag][fwd]++;
 | 
      
        |     bpb_update(current->insn_addr, flag);
 |     bpb_update(current->insn_addr, flag);
 | 
      
        |   }
 |   }
 | 
      
        |   if (flag) {
 |   if (flag) {
 | 
      
        |     pcdelay = pc + (signed)PARAM0 * 4;
 |     pcdelay = pc + (signed)PARAM0 * 4;
 | 
      
        | Line 265... | Line 241... | 
      
        |   }
 |   }
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_bnf) {
 | INSTRUCTION (l_bnf) {
 | 
      
        |   if (config.bpb.enabled) {
 |   if (config.bpb.enabled) {
 | 
      
        |     int fwd = (PARAM0 >= pc) ? 1 : 0;
 |     int fwd = (PARAM0 >= pc) ? 1 : 0;
 | 
      
        |     IFF (config.cpu.dependstats) current->func_unit = it_branch;
 |   | 
      
        |     or1k_mstats.bnf[!flag][fwd]++;
 |     or1k_mstats.bnf[!flag][fwd]++;
 | 
      
        |     bpb_update(current->insn_addr, flag == 0);
 |     bpb_update(current->insn_addr, flag == 0);
 | 
      
        |   }
 |   }
 | 
      
        |   if (flag == 0) {
 |   if (flag == 0) {
 | 
      
        |     pcdelay = pc + (signed)PARAM0 * 4;
 |     pcdelay = pc + (signed)PARAM0 * 4;
 | 
      
        | Line 279... | Line 254... | 
      
        |     btic_update(pc);
 |     btic_update(pc);
 | 
      
        |   }
 |   }
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_j) {
 | INSTRUCTION (l_j) {
 | 
      
        |   pcdelay = pc + (signed)PARAM0 * 4;
 |   pcdelay = pc + (signed)PARAM0 * 4;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_jump;
 |   | 
      
        |   next_delay_insn = 1;
 |   next_delay_insn = 1;
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_jal) {
 | INSTRUCTION (l_jal) {
 | 
      
        |   pcdelay = pc + (signed)PARAM0 * 4;
 |   pcdelay = pc + (signed)PARAM0 * 4;
 | 
      
        |  
 |  
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_jump;
 |   | 
      
        |   set_reg32(LINK_REGNO, pc + 8);
 |   set_reg32(LINK_REGNO, pc + 8);
 | 
      
        |   next_delay_insn = 1;
 |   next_delay_insn = 1;
 | 
      
        |   if (config.sim.profile) {
 |   if (config.sim.profile) {
 | 
      
        |     struct label_entry *tmp;
 |     struct label_entry *tmp;
 | 
      
        |     if (verify_memoryarea(pcdelay) && (tmp = get_label (pcdelay)))
 |     if (verify_memoryarea(pcdelay) && (tmp = get_label (pcdelay)))
 | 
      
        | Line 299... | Line 272... | 
      
        |       fprintf (runtime.sim.fprof, "+%08llX %08lX %08lX @%08lX\n",
 |       fprintf (runtime.sim.fprof, "+%08llX %08lX %08lX @%08lX\n",
 | 
      
        |                runtime.sim.cycles, pc + 8, pcdelay, pcdelay);
 |                runtime.sim.cycles, pc + 8, pcdelay, pcdelay);
 | 
      
        |   }
 |   }
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_jalr) {
 | INSTRUCTION (l_jalr) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_jump;
 |   | 
      
        |   pcdelay = PARAM0;
 |   pcdelay = PARAM0;
 | 
      
        |   set_reg32(LINK_REGNO, pc + 8);
 |   set_reg32(LINK_REGNO, pc + 8);
 | 
      
        |   next_delay_insn = 1;
 |   next_delay_insn = 1;
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_jr) {
 | INSTRUCTION (l_jr) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_jump;
 |   | 
      
        |   pcdelay = PARAM0;
 |   pcdelay = PARAM0;
 | 
      
        |   next_delay_insn = 1;
 |   next_delay_insn = 1;
 | 
      
        |   if (config.sim.profile)
 |   if (config.sim.profile)
 | 
      
        |     fprintf (runtime.sim.fprof, "-%08llX %08lX\n", runtime.sim.cycles, pcdelay);
 |     fprintf (runtime.sim.fprof, "-%08llX %08lX\n", runtime.sim.cycles, pcdelay);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_rfe) {
 | INSTRUCTION (l_rfe) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_exception;
 |   | 
      
        |   pcnext = mfspr(SPR_EPCR_BASE);
 |   pcnext = mfspr(SPR_EPCR_BASE);
 | 
      
        |   mtspr(SPR_SR, mfspr(SPR_ESR_BASE));
 |   mtspr(SPR_SR, mfspr(SPR_ESR_BASE));
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_nop) {
 | INSTRUCTION (l_nop) {
 | 
      
        |   unsigned long stackaddr;
 |   unsigned long stackaddr;
 | 
      
        |   int k = PARAM0;
 |   int k = PARAM0;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_nop;
 |   | 
      
        |   switch (k) {
 |   switch (k) {
 | 
      
        |     case NOP_NOP:
 |     case NOP_NOP:
 | 
      
        |       break;
 |       break;
 | 
      
        |     case NOP_EXIT:
 |     case NOP_EXIT:
 | 
      
        |       PRINTF("exit(%ld)\n", evalsim_reg32 (3));
 |       PRINTF("exit(%ld)\n", evalsim_reg32 (3));
 | 
      
        | Line 358... | Line 327... | 
      
        |       PRINTF("report %i (0x%lx);\n", k - NOP_REPORT_FIRST, evalsim_reg32(3));
 |       PRINTF("report %i (0x%lx);\n", k - NOP_REPORT_FIRST, evalsim_reg32(3));
 | 
      
        |       break;
 |       break;
 | 
      
        |   }
 |   }
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sfeq) {
 | INSTRUCTION (l_sfeq) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_compare;
 |   | 
      
        |   flag = PARAM0 == PARAM1;
 |   flag = PARAM0 == PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sfne) {
 | INSTRUCTION (l_sfne) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_compare;
 |   | 
      
        |   flag = PARAM0 != PARAM1;
 |   flag = PARAM0 != PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sfgts) {
 | INSTRUCTION (l_sfgts) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_compare;
 |   | 
      
        |   flag = (signed)PARAM0 > (signed)PARAM1;
 |   flag = (signed)PARAM0 > (signed)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sfges) {
 | INSTRUCTION (l_sfges) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_compare;
 |   | 
      
        |   flag = (signed)PARAM0 >= (signed)PARAM1;
 |   flag = (signed)PARAM0 >= (signed)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sflts) {
 | INSTRUCTION (l_sflts) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_compare;
 |   | 
      
        |   flag = (signed)PARAM0 < (signed)PARAM1;
 |   flag = (signed)PARAM0 < (signed)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sfles) {
 | INSTRUCTION (l_sfles) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_compare;
 |   | 
      
        |   flag = (signed)PARAM0 <= (signed)PARAM1;
 |   flag = (signed)PARAM0 <= (signed)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sfgtu) {
 | INSTRUCTION (l_sfgtu) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_compare;
 |   | 
      
        |   flag = (unsigned)PARAM0 > (unsigned)PARAM1;
 |   flag = (unsigned)PARAM0 > (unsigned)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sfgeu) {
 | INSTRUCTION (l_sfgeu) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_compare;
 |   | 
      
        |   flag = (unsigned)PARAM0 >= (unsigned)PARAM1;
 |   flag = (unsigned)PARAM0 >= (unsigned)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sfltu) {
 | INSTRUCTION (l_sfltu) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_compare;
 |   | 
      
        |   flag = (unsigned)PARAM0 < (unsigned)PARAM1;
 |   flag = (unsigned)PARAM0 < (unsigned)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_sfleu) {
 | INSTRUCTION (l_sfleu) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_compare;
 |   | 
      
        |   flag = (unsigned)PARAM0 <= (unsigned)PARAM1;
 |   flag = (unsigned)PARAM0 <= (unsigned)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_extbs) {
 | INSTRUCTION (l_extbs) {
 | 
      
        |   unsigned char x;
 |   unsigned char x;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_move;
 |   | 
      
        |   x = PARAM1;
 |   x = PARAM1;
 | 
      
        |   SET_PARAM0((signed long)x);
 |   SET_PARAM0((signed long)x);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_extbz) {
 | INSTRUCTION (l_extbz) {
 | 
      
        |   unsigned char x;
 |   unsigned char x;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_move;
 |   | 
      
        |   x = PARAM1;
 |   x = PARAM1;
 | 
      
        |   SET_PARAM0((unsigned long)x);
 |   SET_PARAM0((unsigned long)x);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_exths) {
 | INSTRUCTION (l_exths) {
 | 
      
        |   unsigned short x;
 |   unsigned short x;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_move;
 |   | 
      
        |   x = PARAM1;
 |   x = PARAM1;
 | 
      
        |   SET_PARAM0((signed long)x);
 |   SET_PARAM0((signed long)x);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_exthz) {
 | INSTRUCTION (l_exthz) {
 | 
      
        |   unsigned short x;
 |   unsigned short x;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_move;
 |   | 
      
        |   x = PARAM1;
 |   x = PARAM1;
 | 
      
        |   SET_PARAM0((unsigned long)x);
 |   SET_PARAM0((unsigned long)x);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_extws) {
 | INSTRUCTION (l_extws) {
 | 
      
        |   unsigned int x;
 |   unsigned int x;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_move;
 |   | 
      
        |   x = PARAM1;
 |   x = PARAM1;
 | 
      
        |   SET_PARAM0((signed long)x);
 |   SET_PARAM0((signed long)x);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_extwz) {
 | INSTRUCTION (l_extwz) {
 | 
      
        |   unsigned int x;
 |   unsigned int x;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_move;
 |   | 
      
        |   x = PARAM1;
 |   x = PARAM1;
 | 
      
        |   SET_PARAM0((unsigned long)x);
 |   SET_PARAM0((unsigned long)x);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_mtspr) {
 | INSTRUCTION (l_mtspr) {
 | 
      
        |   unsigned long regno = PARAM0 + PARAM2;
 |   unsigned long regno = PARAM0 + PARAM2;
 | 
      
        | Line 451... | Line 404... | 
      
        |  
 |  
 | 
      
        |   if (runtime.sim.fspr_log) {
 |   if (runtime.sim.fspr_log) {
 | 
      
        |     fprintf(runtime.sim.fspr_log, "Write to SPR  : [%08lX] <- [%08lX]\n", regno, value);
 |     fprintf(runtime.sim.fspr_log, "Write to SPR  : [%08lX] <- [%08lX]\n", regno, value);
 | 
      
        |   }
 |   }
 | 
      
        |  
 |  
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_move;
 |   | 
      
        |   if (mfspr(SPR_SR) & SPR_SR_SM)
 |   if (mfspr(SPR_SR) & SPR_SR_SM)
 | 
      
        |     mtspr(regno, value);
 |     mtspr(regno, value);
 | 
      
        |   else {
 |   else {
 | 
      
        |     PRINTF("WARNING: trying to write SPR while SR[SUPV] is cleared.\n");
 |     PRINTF("WARNING: trying to write SPR while SR[SUPV] is cleared.\n");
 | 
      
        |     runtime.sim.cont_run = 0;
 |     runtime.sim.cont_run = 0;
 | 
      
        | Line 467... | Line 419... | 
      
        |  
 |  
 | 
      
        |   if (runtime.sim.fspr_log) {
 |   if (runtime.sim.fspr_log) {
 | 
      
        |     fprintf(runtime.sim.fspr_log, "Read from SPR : [%08lX] -> [%08lX]\n", regno, value);
 |     fprintf(runtime.sim.fspr_log, "Read from SPR : [%08lX] -> [%08lX]\n", regno, value);
 | 
      
        |   }
 |   }
 | 
      
        |  
 |  
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_move;
 |   | 
      
        |   if (mfspr(SPR_SR) & SPR_SR_SM)
 |   if (mfspr(SPR_SR) & SPR_SR_SM)
 | 
      
        |     SET_PARAM0(value);
 |     SET_PARAM0(value);
 | 
      
        |   else {
 |   else {
 | 
      
        |     SET_PARAM0(0);
 |     SET_PARAM0(0);
 | 
      
        |     PRINTF("WARNING: trying to read SPR while SR[SUPV] is cleared.\n");
 |     PRINTF("WARNING: trying to read SPR while SR[SUPV] is cleared.\n");
 | 
      
        | Line 487... | Line 438... | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_mac) {
 | INSTRUCTION (l_mac) {
 | 
      
        |   sprword lo, hi;
 |   sprword lo, hi;
 | 
      
        |   LONGEST l;
 |   LONGEST l;
 | 
      
        |   long x, y;
 |   long x, y;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_mac;
 |   | 
      
        |   lo = mfspr (SPR_MACLO);
 |   lo = mfspr (SPR_MACLO);
 | 
      
        |   hi = mfspr (SPR_MACHI);
 |   hi = mfspr (SPR_MACHI);
 | 
      
        |   x = PARAM0;
 |   x = PARAM0;
 | 
      
        |   y = PARAM1;
 |   y = PARAM1;
 | 
      
        |   PRINTF ("[%08lx,%08lx]\t", (unsigned long)(x), (unsigned long)(y));
 |   PRINTF ("[%08lx,%08lx]\t", (unsigned long)(x), (unsigned long)(y));
 | 
      
        | Line 507... | Line 457... | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_msb) {
 | INSTRUCTION (l_msb) {
 | 
      
        |   sprword lo, hi;
 |   sprword lo, hi;
 | 
      
        |   LONGEST l;
 |   LONGEST l;
 | 
      
        |   long x, y;
 |   long x, y;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_mac;
 |   | 
      
        |   lo = mfspr (SPR_MACLO);
 |   lo = mfspr (SPR_MACLO);
 | 
      
        |   hi = mfspr (SPR_MACHI);
 |   hi = mfspr (SPR_MACHI);
 | 
      
        |   x = PARAM0;
 |   x = PARAM0;
 | 
      
        |   y = PARAM1;
 |   y = PARAM1;
 | 
      
        |   PRINTF ("[%08lx,%08lx]\t", (unsigned long)(x), (unsigned long)(y));
 |   PRINTF ("[%08lx,%08lx]\t", (unsigned long)(x), (unsigned long)(y));
 | 
      
        | Line 526... | Line 475... | 
      
        |   PRINTF ("(%08lx,%08lx)\n", hi, lo);
 |   PRINTF ("(%08lx,%08lx)\n", hi, lo);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_macrc) {
 | INSTRUCTION (l_macrc) {
 | 
      
        |   sprword lo, hi;
 |   sprword lo, hi;
 | 
      
        |   LONGEST l;
 |   LONGEST l;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_mac;
 |   | 
      
        |   /* No need for synchronization here -- all MAC instructions are 1 cycle long.  */
 |   /* No need for synchronization here -- all MAC instructions are 1 cycle long.  */
 | 
      
        |   lo =  mfspr (SPR_MACLO);
 |   lo =  mfspr (SPR_MACLO);
 | 
      
        |   hi =  mfspr (SPR_MACHI);
 |   hi =  mfspr (SPR_MACHI);
 | 
      
        |   l = (ULONGEST) lo | ((LONGEST)hi << 32);
 |   l = (ULONGEST) lo | ((LONGEST)hi << 32);
 | 
      
        |   l >>= 28;
 |   l >>= 28;
 | 
      
        | Line 538... | Line 486... | 
      
        |   SET_PARAM0((long)l);
 |   SET_PARAM0((long)l);
 | 
      
        |   mtspr (SPR_MACLO, 0);
 |   mtspr (SPR_MACLO, 0);
 | 
      
        |   mtspr (SPR_MACHI, 0);
 |   mtspr (SPR_MACHI, 0);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_cmov) {
 | INSTRUCTION (l_cmov) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_move;
 |   | 
      
        |   SET_PARAM0(flag ? PARAM1 : PARAM2);
 |   SET_PARAM0(flag ? PARAM1 : PARAM2);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (l_ff1) {
 | INSTRUCTION (l_ff1) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_arith;
 |   | 
      
        |   SET_PARAM0(ffs(PARAM1));
 |   SET_PARAM0(ffs(PARAM1));
 | 
      
        | }
 | }
 | 
      
        | /******* Floating point instructions *******/
 | /******* Floating point instructions *******/
 | 
      
        | /* Single precision */
 | /* Single precision */
 | 
      
        | INSTRUCTION (lf_add_s) {
 | INSTRUCTION (lf_add_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   SET_PARAM0((machword)((float)PARAM1 + (float)PARAM2));
 |   SET_PARAM0((machword)((float)PARAM1 + (float)PARAM2));
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_div_s) {
 | INSTRUCTION (lf_div_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   SET_PARAM0((machword)((float)PARAM1 / (float)PARAM2));
 |   SET_PARAM0((machword)((float)PARAM1 / (float)PARAM2));
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_ftoi_s) {
 | INSTRUCTION (lf_ftoi_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        | //  set_operand32(0, freg[get_operand(1)], &breakpoint);
 | //  set_operand32(0, freg[get_operand(1)], &breakpoint);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_itof_s) {
 | INSTRUCTION (lf_itof_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        | //  freg[get_operand(0)] = eval_operand32(1, &breakpoint);
 | //  freg[get_operand(0)] = eval_operand32(1, &breakpoint);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_madd_s) {
 | INSTRUCTION (lf_madd_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   SET_PARAM0((machword)((float)PARAM0 + (float)PARAM1 * (float)PARAM2));
 |   SET_PARAM0((machword)((float)PARAM0 + (float)PARAM1 * (float)PARAM2));
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_mul_s) {
 | INSTRUCTION (lf_mul_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   SET_PARAM0((machword)((float)PARAM1 * (float)PARAM2));
 |   SET_PARAM0((machword)((float)PARAM1 * (float)PARAM2));
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_rem_s) {
 | INSTRUCTION (lf_rem_s) {
 | 
      
        |   float temp = (float)PARAM1 / (float)PARAM2;
 |   float temp = (float)PARAM1 / (float)PARAM2;
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   SET_PARAM0(temp - (machword)temp);
 |   SET_PARAM0(temp - (machword)temp);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_sfeq_s) {
 | INSTRUCTION (lf_sfeq_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   flag = (float)PARAM0 == (float)PARAM1;
 |   flag = (float)PARAM0 == (float)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_sfge_s) {
 | INSTRUCTION (lf_sfge_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   flag = (float)PARAM0 >= (float)PARAM1;
 |   flag = (float)PARAM0 >= (float)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_sfgt_s) {
 | INSTRUCTION (lf_sfgt_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   flag = (float)PARAM0 > (float)PARAM1;
 |   flag = (float)PARAM0 > (float)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_sfle_s) {
 | INSTRUCTION (lf_sfle_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   flag = (float)PARAM0 <= (float)PARAM1;
 |   flag = (float)PARAM0 <= (float)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_sflt_s) {
 | INSTRUCTION (lf_sflt_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   flag = (float)PARAM0 < (float)PARAM1;
 |   flag = (float)PARAM0 < (float)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_sfne_s) {
 | INSTRUCTION (lf_sfne_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   flag = (float)PARAM0 != (float)PARAM1;
 |   flag = (float)PARAM0 != (float)PARAM1;
 | 
      
        |   setsprbits(SPR_SR, SPR_SR_F, flag);
 |   setsprbits(SPR_SR, SPR_SR_F, flag);
 | 
      
        | }
 | }
 | 
      
        | INSTRUCTION (lf_sub_s) {
 | INSTRUCTION (lf_sub_s) {
 | 
      
        |   IFF (config.cpu.dependstats) current->func_unit = it_float;
 |   | 
      
        |   SET_PARAM0((machword)((float)PARAM1 - (float)PARAM2));
 |   SET_PARAM0((machword)((float)PARAM1 - (float)PARAM2));
 | 
      
        | }
 | }
 | 
      
        |  
 |  
 | 
      
        | /******* Custom instructions *******/
 | /******* Custom instructions *******/
 | 
      
        | INSTRUCTION (l_cust1) {
 | INSTRUCTION (l_cust1) {
 |