/[dynamips]/upstream/dynamips-0.2.7-RC3/ppc32_x86_trans.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /upstream/dynamips-0.2.7-RC3/ppc32_x86_trans.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

upstream/dynamips-0.2.7-RC2/ppc32_x86_trans.c revision 8 by dpavlin, Sat Oct 6 16:24:54 2007 UTC upstream/dynamips-0.2.7-RC3/ppc32_x86_trans.c revision 9 by dpavlin, Sat Oct 6 16:26:06 2007 UTC
# Line 13  Line 13 
13  #include <fcntl.h>  #include <fcntl.h>
14    
15  #include "cpu.h"  #include "cpu.h"
16    #include "jit_op.h"
17  #include "ppc32_jit.h"  #include "ppc32_jit.h"
18  #include "ppc32_x86_trans.h"  #include "ppc32_x86_trans.h"
19  #include "memory.h"  #include "memory.h"
# Line 99  static m_uint32_t eflags_to_cr_unsigned[ Line 100  static m_uint32_t eflags_to_cr_unsigned[
100     0x02, 0x0a, 0x02, 0x0a, 0x02, 0x0a, 0x02, 0x0a,     0x02, 0x0a, 0x02, 0x0a, 0x02, 0x0a, 0x02, 0x0a,
101  };  };
102    
103  /* Dump regs */  /* Emit unhandled instruction code */
104  static void ppc32_emit_dump_regs(ppc32_jit_tcb_t *b);  static int ppc32_emit_unknown(cpu_ppc_t *cpu,ppc32_jit_tcb_t *b,
105                                  ppc_insn_t opcode);
106    
107  /* Load a 32 bit immediate value */  /* Load a 32 bit immediate value */
108  static inline void ppc32_load_imm(ppc32_jit_tcb_t *b,u_int reg,m_uint32_t val)  static forced_inline void ppc32_load_imm(u_char **ptr,u_int reg,m_uint32_t val)
109  {  {
110     if (val)     if (val)
111        x86_mov_reg_imm(b->jit_ptr,reg,val);        x86_mov_reg_imm(*ptr,reg,val);
112     else     else
113        x86_alu_reg_reg(b->jit_ptr,X86_XOR,reg,reg);        x86_alu_reg_reg(*ptr,X86_XOR,reg,reg);
114  }  }
115    
116  /* Set the Instruction Address (IA) register */  /* Set the Instruction Address (IA) register */
117  void ppc32_set_ia(ppc32_jit_tcb_t *b,m_uint32_t new_ia)  void ppc32_set_ia(u_char **ptr,m_uint32_t new_ia)
118  {  {
119     x86_mov_membase_imm(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,ia),new_ia,4);     x86_mov_membase_imm(*ptr,X86_EDI,OFFSET(cpu_ppc_t,ia),new_ia,4);
120  }  }
121    
122  /* Set the Link Register (LR) */  /* Set the Link Register (LR) */
123  void ppc32_set_lr(ppc32_jit_tcb_t *b,m_uint32_t new_lr)  static void ppc32_set_lr(jit_op_t *iop,m_uint32_t new_lr)
124  {    {  
125     x86_mov_membase_imm(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,lr),new_lr,4);     x86_mov_membase_imm(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,lr),new_lr,4);
126  }  }
127    
128  /*  /*
129   * Try to branch directly to the specified JIT block without returning to   * Try to branch directly to the specified JIT block without returning to
130   * main loop.   * main loop.
131   */   */
132  static void ppc32_try_direct_far_jump(cpu_ppc_t *cpu,ppc32_jit_tcb_t *b,  static void ppc32_try_direct_far_jump(cpu_ppc_t *cpu,jit_op_t *iop,
133                                        m_uint32_t new_ia)                                        m_uint32_t new_ia)
134  {  {
135     m_uint32_t new_page,ia_hash,ia_offset;     m_uint32_t new_page,ia_hash,ia_offset;
136     u_char *test1,*test2,*test3;     u_char *test1,*test2,*test3;
137    
138       /* Indicate that we throw %esi, %edx */
139       ppc32_op_emit_alter_host_reg(cpu,X86_ESI);
140       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
141    
142     new_page = new_ia & PPC32_MIN_PAGE_MASK;     new_page = new_ia & PPC32_MIN_PAGE_MASK;
143     ia_offset = (new_ia & PPC32_MIN_PAGE_IMASK) >> 2;     ia_offset = (new_ia & PPC32_MIN_PAGE_IMASK) >> 2;
144     ia_hash = ppc32_jit_get_ia_hash(new_ia);     ia_hash = ppc32_jit_get_ia_hash(new_ia);
145    
146     /* Get JIT block info in %edx */     /* Get JIT block info in %edx */
147     x86_mov_reg_membase(b->jit_ptr,X86_EBX,     x86_mov_reg_membase(iop->ob_ptr,X86_EBX,
148                         X86_EDI,OFFSET(cpu_ppc_t,exec_blk_map),4);                         X86_EDI,OFFSET(cpu_ppc_t,exec_blk_map),4);
149     x86_mov_reg_membase(b->jit_ptr,X86_EDX,X86_EBX,ia_hash*sizeof(void *),4);     x86_mov_reg_membase(iop->ob_ptr,X86_EDX,X86_EBX,ia_hash*sizeof(void *),4);
150    
151     /* no JIT block found ? */     /* no JIT block found ? */
152     x86_test_reg_reg(b->jit_ptr,X86_EDX,X86_EDX);     x86_test_reg_reg(iop->ob_ptr,X86_EDX,X86_EDX);
153     test1 = b->jit_ptr;     test1 = iop->ob_ptr;
154     x86_branch8(b->jit_ptr, X86_CC_Z, 0, 1);     x86_branch8(iop->ob_ptr, X86_CC_Z, 0, 1);
155    
156     /* Check block IA */     /* Check block IA */
157     x86_mov_reg_imm(b->jit_ptr,X86_EAX,new_page);     x86_mov_reg_imm(iop->ob_ptr,X86_ESI,new_page);
158     x86_alu_reg_membase(b->jit_ptr,X86_CMP,X86_EAX,X86_EDX,     x86_alu_reg_membase(iop->ob_ptr,X86_CMP,X86_ESI,X86_EDX,
159                         OFFSET(ppc32_jit_tcb_t,start_ia));                         OFFSET(ppc32_jit_tcb_t,start_ia));
160     test2 = b->jit_ptr;     test2 = iop->ob_ptr;
161     x86_branch8(b->jit_ptr, X86_CC_NE, 0, 1);     x86_branch8(iop->ob_ptr, X86_CC_NE, 0, 1);
162    
163     /* Jump to the code */     /* Jump to the code */
164     x86_mov_reg_membase(b->jit_ptr,X86_ESI,     x86_mov_reg_membase(iop->ob_ptr,X86_ESI,
165                         X86_EDX,OFFSET(ppc32_jit_tcb_t,jit_insn_ptr),4);                         X86_EDX,OFFSET(ppc32_jit_tcb_t,jit_insn_ptr),4);
166     x86_mov_reg_membase(b->jit_ptr,X86_EBX,     x86_mov_reg_membase(iop->ob_ptr,X86_EBX,
167                         X86_ESI,ia_offset * sizeof(void *),4);                         X86_ESI,ia_offset * sizeof(void *),4);
168        
169     x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);     x86_test_reg_reg(iop->ob_ptr,X86_EBX,X86_EBX);
170     test3 = b->jit_ptr;     test3 = iop->ob_ptr;
171     x86_branch8(b->jit_ptr, X86_CC_Z, 0, 1);     x86_branch8(iop->ob_ptr, X86_CC_Z, 0, 1);
172     x86_jump_reg(b->jit_ptr,X86_EBX);     x86_jump_reg(iop->ob_ptr,X86_EBX);
173    
174     /* Returns to caller... */     /* Returns to caller... */
175     x86_patch(test1,b->jit_ptr);     x86_patch(test1,iop->ob_ptr);
176     x86_patch(test2,b->jit_ptr);     x86_patch(test2,iop->ob_ptr);
177     x86_patch(test3,b->jit_ptr);     x86_patch(test3,iop->ob_ptr);
178    
179     ppc32_set_ia(b,new_ia);     ppc32_set_ia(&iop->ob_ptr,new_ia);
180     ppc32_jit_tcb_push_epilog(b);     ppc32_jit_tcb_push_epilog(&iop->ob_ptr);
181  }  }
182    
183  /* Set Jump */  /* Set Jump */
184  static void ppc32_set_jump(cpu_ppc_t *cpu,ppc32_jit_tcb_t *b,  static void ppc32_set_jump(cpu_ppc_t *cpu,ppc32_jit_tcb_t *b,jit_op_t *iop,
185                             m_uint32_t new_ia,int local_jump)                             m_uint32_t new_ia,int local_jump)
186  {        {      
187     int return_to_caller = FALSE;     int return_to_caller = FALSE;
# Line 185  static void ppc32_set_jump(cpu_ppc_t *cp Line 191  static void ppc32_set_jump(cpu_ppc_t *cp
191     if (cpu->sym_trace && !local_jump)     if (cpu->sym_trace && !local_jump)
192        return_to_caller = TRUE;        return_to_caller = TRUE;
193  #endif  #endif
194      
195     if (!return_to_caller && ppc32_jit_tcb_local_addr(b,new_ia,&jump_ptr)) {     if (!return_to_caller && ppc32_jit_tcb_local_addr(b,new_ia,&jump_ptr)) {
196        if (jump_ptr) {        ppc32_jit_tcb_record_patch(b,iop,iop->ob_ptr,new_ia);
197           x86_jump_code(b->jit_ptr,jump_ptr);        x86_jump32(iop->ob_ptr,0);
       } else {  
          ppc32_jit_tcb_record_patch(b,b->jit_ptr,new_ia);  
          x86_jump32(b->jit_ptr,0);  
       }  
198     } else {     } else {
199        if (cpu->exec_blk_direct_jump) {        if (cpu->exec_blk_direct_jump) {
200           /* Block lookup optimization */           /* Block lookup optimization */
201           ppc32_try_direct_far_jump(cpu,b,new_ia);           ppc32_try_direct_far_jump(cpu,iop,new_ia);
202        } else {        } else {
203           ppc32_set_ia(b,new_ia);           ppc32_set_ia(&iop->ob_ptr,new_ia);
204           ppc32_jit_tcb_push_epilog(b);           ppc32_jit_tcb_push_epilog(&iop->ob_ptr);
205        }        }
206     }     }
207  }  }
208    
209    /* Jump to the next page */
210    void ppc32_set_page_jump(cpu_ppc_t *cpu,ppc32_jit_tcb_t *b)
211    {
212       jit_op_t *iop,*op_list = NULL;
213    
214       cpu->gen->jit_op_current = &op_list;
215    
216       iop = ppc32_op_emit_insn_output(cpu,4,"set_page_jump");
217       ppc32_set_jump(cpu,b,iop,b->start_ia + PPC32_MIN_PAGE_SIZE,FALSE);
218       ppc32_op_insn_output(b,iop);
219    
220       jit_op_free_list(cpu->gen,op_list);
221       cpu->gen->jit_op_current = NULL;
222    }
223    
224  /* Load a GPR into the specified host register */  /* Load a GPR into the specified host register */
225  static forced_inline void ppc32_load_gpr(ppc32_jit_tcb_t *b,u_int host_reg,  static forced_inline void ppc32_load_gpr(u_char **ptr,u_int host_reg,
226                                           u_int ppc_reg)                                           u_int ppc_reg)
227  {  {
228     x86_mov_reg_membase(b->jit_ptr,host_reg,X86_EDI,REG_OFFSET(ppc_reg),4);     x86_mov_reg_membase(*ptr,host_reg,X86_EDI,REG_OFFSET(ppc_reg),4);
229  }  }
230    
231  /* Store contents for a host register into a GPR register */  /* Store contents for a host register into a GPR register */
232  static forced_inline void ppc32_store_gpr(ppc32_jit_tcb_t *b,u_int ppc_reg,  static forced_inline void ppc32_store_gpr(u_char **ptr,u_int ppc_reg,
233                                            u_int host_reg)                                            u_int host_reg)
234  {  {
235     x86_mov_membase_reg(b->jit_ptr,X86_EDI,REG_OFFSET(ppc_reg),host_reg,4);     x86_mov_membase_reg(*ptr,X86_EDI,REG_OFFSET(ppc_reg),host_reg,4);
236  }  }
237    
238  /* Apply an ALU operation on a GPR register and a host register */  /* Apply an ALU operation on a GPR register and a host register */
239  static forced_inline void ppc32_alu_gpr(ppc32_jit_tcb_t *b,u_int op,  static forced_inline void ppc32_alu_gpr(u_char **ptr,u_int op,
240                                          u_int host_reg,u_int ppc_reg)                                          u_int host_reg,u_int ppc_reg)
241  {  {
242     x86_alu_reg_membase(b->jit_ptr,op,host_reg,X86_EDI,REG_OFFSET(ppc_reg));     x86_alu_reg_membase(*ptr,op,host_reg,X86_EDI,REG_OFFSET(ppc_reg));
243  }  }
244    
245  /*  /*
# Line 244  static void ppc32_update_cr(ppc32_jit_tc Line 261  static void ppc32_update_cr(ppc32_jit_tc
261     x86_mov_reg_memindex(b->jit_ptr,X86_EAX,X86_EDX,0,X86_EAX,2,4);     x86_mov_reg_memindex(b->jit_ptr,X86_EAX,X86_EDX,0,X86_EAX,2,4);
262    
263     /* Check XER Summary of Overflow and report it */     /* Check XER Summary of Overflow and report it */
264     x86_mov_reg_membase(b->jit_ptr,X86_ESI,X86_EDI,OFFSET(cpu_ppc_t,xer),4);     x86_mov_reg_membase(b->jit_ptr,X86_EDX,X86_EDI,OFFSET(cpu_ppc_t,xer),4);
265     //x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_ESI,PPC32_XER_SO);     //x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_ESI,PPC32_XER_SO);
266     //x86_shift_reg_imm(b->jit_ptr,X86_SHR,X86_ESI,PPC32_XER_SO_BIT);     //x86_shift_reg_imm(b->jit_ptr,X86_SHR,X86_ESI,PPC32_XER_SO_BIT);
267     //x86_alu_reg_reg(b->jit_ptr,X86_OR,X86_EAX,X86_ESI);     //x86_alu_reg_reg(b->jit_ptr,X86_OR,X86_EAX,X86_ESI);
# Line 256  static void ppc32_update_cr(ppc32_jit_tc Line 273  static void ppc32_update_cr(ppc32_jit_tc
273    
274  /*  /*
275   * Update CR0 from %eflags   * Update CR0 from %eflags
276   * %eax, %ecx, %edx, %esi are modified.   * %eax, %edx, %esi are modified.
277   */   */
278  static void ppc32_update_cr0(ppc32_jit_tcb_t *b)  static void ppc32_update_cr0(ppc32_jit_tcb_t *b)
279  {  {
280     ppc32_update_cr(b,0,TRUE);     ppc32_update_cr(b,0,TRUE);
281  }  }
282    
283    /* Indicate registers modified by ppc32_update_cr() functions */
284    void ppc32_update_cr_set_altered_hreg(cpu_ppc_t *cpu)
285    {
286       /* Throw %eax and %edx, which are modifed by ppc32_update_cr() */
287       ppc32_op_emit_alter_host_reg(cpu,X86_EAX);
288       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
289    }
290    
291  /* Basic C call */  /* Basic C call */
292  static forced_inline void ppc32_emit_basic_c_call(ppc32_jit_tcb_t *b,void *f)  static forced_inline
293    void ppc32_emit_basic_c_call(u_char **ptr,void *f)
294  {  {
295     x86_mov_reg_imm(b->jit_ptr,X86_EBX,f);     x86_mov_reg_imm(*ptr,X86_EBX,f);
296     x86_call_reg(b->jit_ptr,X86_EBX);     x86_call_reg(*ptr,X86_EBX);
297  }  }
298    
299  /* Emit a simple call to a C function without any parameter */  /* Emit a simple call to a C function without any parameter */
300  static void ppc32_emit_c_call(ppc32_jit_tcb_t *b,void *f)  static void ppc32_emit_c_call(ppc32_jit_tcb_t *b,jit_op_t *iop,void *f)
301  {    {  
302     ppc32_set_ia(b,b->start_ia+((b->ppc_trans_pos-1)<<2));     ppc32_set_ia(&iop->ob_ptr,b->start_ia+(b->ppc_trans_pos << 2));
303     ppc32_emit_basic_c_call(b,f);     ppc32_emit_basic_c_call(&iop->ob_ptr,f);
304    }
305    
306    /* Increment the number of executed instructions (performance debugging) */
307    void ppc32_inc_perf_counter(ppc32_jit_tcb_t *b)
308    {
309       x86_alu_membase_imm(b->jit_ptr,X86_ADD,
310                           X86_EDI,OFFSET(cpu_ppc_t,perf_counter),1);
311       x86_alu_membase_imm(b->jit_ptr,X86_ADC,
312                           X86_EDI,OFFSET(cpu_ppc_t,perf_counter)+4,0);
313    }
314    
315    /* ======================================================================== */
316    
317    /* Initialize register mapping */
318    void ppc32_jit_init_hreg_mapping(cpu_ppc_t *cpu)
319    {
320       int avail_hregs[] = { X86_ESI, X86_EAX, X86_ECX, X86_EDX, -1 };
321       struct hreg_map *map;
322       int i,hreg;
323    
324       cpu->hreg_map_list = cpu->hreg_lru = NULL;
325    
326       /* Add the available registers to the map list */
327       for(i=0;avail_hregs[i]!=-1;i++) {
328          hreg = avail_hregs[i];
329          map = &cpu->hreg_map[hreg];
330    
331          /* Initialize mapping. At the beginning, no PPC reg is mapped */
332          map->flags = 0;
333          map->hreg  = hreg;
334          map->vreg  = -1;
335          ppc32_jit_insert_hreg_mru(cpu,map);
336       }
337    
338       /* Clear PPC registers mapping */
339       for(i=0;i<PPC32_GPR_NR;i++)
340          cpu->ppc_reg_map[i] = -1;
341    }
342    
343    /* Allocate a specific temp register */
344    static int ppc32_jit_get_tmp_hreg(cpu_ppc_t *cpu)
345    {
346       return(X86_EBX);
347    }
348    
349    /* ======================================================================== */
350    /* JIT operations (specific to target CPU).                                 */
351    /* ======================================================================== */
352    
353    /* INSN_OUTPUT */
354    void ppc32_op_insn_output(ppc32_jit_tcb_t *b,jit_op_t *op)
355    {
356       op->ob_final = b->jit_ptr;
357       memcpy(b->jit_ptr,op->ob_data,op->ob_ptr - op->ob_data);
358       b->jit_ptr += op->ob_ptr - op->ob_data;
359    
360       if ((op->ob_ptr - op->ob_data) >= jit_op_blk_sizes[op->ob_size_index]) {
361          printf("FAILURE: count=%d, size=%d\n",
362                 op->ob_ptr - op->ob_data, jit_op_blk_sizes[op->ob_size_index]);
363       }
364    }
365    
366    /* LOAD_GPR: p[0] = %host_reg, p[1] = %ppc_reg */
367    void ppc32_op_load_gpr(ppc32_jit_tcb_t *b,jit_op_t *op)
368    {
369       if (op->param[0] != JIT_OP_INV_REG)
370          ppc32_load_gpr(&b->jit_ptr,op->param[0],op->param[1]);
371  }  }
372    
373    /* STORE_GPR: p[0] = %host_reg, p[1] = %ppc_reg */
374    void ppc32_op_store_gpr(ppc32_jit_tcb_t *b,jit_op_t *op)
375    {
376       if (op->param[0] != JIT_OP_INV_REG)
377          ppc32_store_gpr(&b->jit_ptr,op->param[1],op->param[0]);
378    }
379    
380    /* UPDATE_FLAGS: p[0] = cr_field, p[1] = is_signed */
381    void ppc32_op_update_flags(ppc32_jit_tcb_t *b,jit_op_t *op)
382    {
383       if (op->param[0] != JIT_OP_INV_REG)
384          ppc32_update_cr(b,op->param[0],op->param[1]);
385    }
386    
387    /* MOVE_HOST_REG: p[0] = %host_dst_reg, p[1] = %host_src_reg */
388    void ppc32_op_move_host_reg(ppc32_jit_tcb_t *b,jit_op_t *op)
389    {
390       if ((op->param[0] != JIT_OP_INV_REG) && (op->param[1] != JIT_OP_INV_REG))
391          x86_mov_reg_reg(b->jit_ptr,op->param[0],op->param[1],4);
392    }
393    
394    /* SET_HOST_REG_IMM32: p[0] = %host_reg, p[1] = imm32 */
395    void ppc32_op_set_host_reg_imm32(ppc32_jit_tcb_t *b,jit_op_t *op)
396    {
397       if (op->param[0] != JIT_OP_INV_REG)
398          ppc32_load_imm(&b->jit_ptr,op->param[0],op->param[1]);
399    }
400    
401    /* ======================================================================== */
402    
403  /* Memory operation */  /* Memory operation */
404  static void ppc32_emit_memop(ppc32_jit_tcb_t *b,int op,int base,int offset,  static void ppc32_emit_memop(cpu_ppc_t *cpu,ppc32_jit_tcb_t *b,
405                               int target,int update)                               int op,int base,int offset,int target,int update)
406  {  {
407     m_uint32_t val = sign_extend(offset,16);     m_uint32_t val = sign_extend(offset,16);
408     u_char *test1;     u_char *test1;
409       jit_op_t *iop;
410    
411       /*
412        * Since an exception can be triggered, clear JIT state. This allows
413        * to use branch target tag (we can directly branch on this instruction).
414        */
415       ppc32_op_emit_basic_opcode(cpu,JIT_OP_BRANCH_TARGET);
416       ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
417    
418       iop = ppc32_op_emit_insn_output(cpu,5,"memop");
419    
420     /* Save PC for exception handling */     /* Save PC for exception handling */
421     ppc32_set_ia(b,b->start_ia+((b->ppc_trans_pos-1)<<2));     ppc32_set_ia(&iop->ob_ptr,b->start_ia+(b->ppc_trans_pos << 2));
422    
423     /* EDX = sign-extended offset */     /* EDX = sign-extended offset */
424     ppc32_load_imm(b,X86_EDX,val);     ppc32_load_imm(&iop->ob_ptr,X86_EDX,val);
425    
426     /* EDX = GPR[base] + sign-extended offset */     /* EDX = GPR[base] + sign-extended offset */
427     if (update || (base != 0))     if (update || (base != 0))
428        ppc32_alu_gpr(b,X86_ADD,X86_EDX,base);        ppc32_alu_gpr(&iop->ob_ptr,X86_ADD,X86_EDX,base);
429    
430     if (update)     if (update)
431        x86_mov_reg_reg(b->jit_ptr,X86_ESI,X86_EDX,4);        x86_mov_reg_reg(iop->ob_ptr,X86_ESI,X86_EDX,4);
432    
433     /* ECX = target register */     /* ECX = target register */
434     x86_mov_reg_imm(b->jit_ptr,X86_ECX,target);     x86_mov_reg_imm(iop->ob_ptr,X86_ECX,target);
435        
436     /* EAX = CPU instance pointer */     /* EAX = CPU instance pointer */
437     x86_mov_reg_reg(b->jit_ptr,X86_EAX,X86_EDI,4);     x86_mov_reg_reg(iop->ob_ptr,X86_EAX,X86_EDI,4);
438    
439     /* Call memory function */     /* Call memory function */
440     x86_call_membase(b->jit_ptr,X86_EDI,MEMOP_OFFSET(op));     x86_call_membase(iop->ob_ptr,X86_EDI,MEMOP_OFFSET(op));
441    
442     /* Exception ? */     /* Exception ? */
443     x86_test_reg_reg(b->jit_ptr,X86_EAX,X86_EAX);     x86_test_reg_reg(iop->ob_ptr,X86_EAX,X86_EAX);
444     test1 = b->jit_ptr;     test1 = iop->ob_ptr;
445     x86_branch8(b->jit_ptr, X86_CC_Z, 0, 1);     x86_branch8(iop->ob_ptr, X86_CC_Z, 0, 1);
446     ppc32_jit_tcb_push_epilog(b);     ppc32_jit_tcb_push_epilog(&iop->ob_ptr);
447     x86_patch(test1,b->jit_ptr);     x86_patch(test1,iop->ob_ptr);
448    
449     if (update)     if (update)
450        ppc32_store_gpr(b,base,X86_ESI);        ppc32_store_gpr(&iop->ob_ptr,base,X86_ESI);
451  }  }
452    
453  /* Memory operation (indexed) */  /* Memory operation (indexed) */
454  static void ppc32_emit_memop_idx(ppc32_jit_tcb_t *b,int op,int ra,int rb,  static void ppc32_emit_memop_idx(cpu_ppc_t *cpu,ppc32_jit_tcb_t *b,
455                                   int target,int update)                                   int op,int ra,int rb,int target,int update)
456  {  {
457     u_char *test1;     u_char *test1;
458       jit_op_t *iop;
459    
460       /*
461        * Since an exception can be triggered, clear JIT state. This allows
462        * to use branch target tag (we can directly branch on this instruction).
463        */
464       ppc32_op_emit_basic_opcode(cpu,JIT_OP_BRANCH_TARGET);
465       ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
466    
467       iop = ppc32_op_emit_insn_output(cpu,5,"memop_idx");
468    
469     /* Save PC for exception handling */     /* Save PC for exception handling */
470     ppc32_set_ia(b,b->start_ia+((b->ppc_trans_pos-1)<<2));     ppc32_set_ia(&iop->ob_ptr,b->start_ia+(b->ppc_trans_pos << 2));
471    
472     /* EDX = $rb */     /* EDX = $rb */
473     ppc32_load_gpr(b,X86_EDX,rb);     ppc32_load_gpr(&iop->ob_ptr,X86_EDX,rb);
474    
475     /* EDX = $rb + $ra */     /* EDX = $rb + $ra */
476     if (update || (ra != 0))     if (update || (ra != 0))
477        ppc32_alu_gpr(b,X86_ADD,X86_EDX,ra);        ppc32_alu_gpr(&iop->ob_ptr,X86_ADD,X86_EDX,ra);
478    
479     if (update)     if (update)
480        x86_mov_reg_reg(b->jit_ptr,X86_ESI,X86_EDX,4);        x86_mov_reg_reg(iop->ob_ptr,X86_ESI,X86_EDX,4);
481    
482     /* ECX = target register */     /* ECX = target register */
483     x86_mov_reg_imm(b->jit_ptr,X86_ECX,target);     x86_mov_reg_imm(iop->ob_ptr,X86_ECX,target);
484        
485     /* EAX = CPU instance pointer */     /* EAX = CPU instance pointer */
486     x86_mov_reg_reg(b->jit_ptr,X86_EAX,X86_EDI,4);     x86_mov_reg_reg(iop->ob_ptr,X86_EAX,X86_EDI,4);
487    
488     /* Call memory function */     /* Call memory function */
489     x86_call_membase(b->jit_ptr,X86_EDI,MEMOP_OFFSET(op));     x86_call_membase(iop->ob_ptr,X86_EDI,MEMOP_OFFSET(op));
490    
491     /* Exception ? */     /* Exception ? */
492     x86_test_reg_reg(b->jit_ptr,X86_EAX,X86_EAX);     x86_test_reg_reg(iop->ob_ptr,X86_EAX,X86_EAX);
493     test1 = b->jit_ptr;     test1 = iop->ob_ptr;
494     x86_branch8(b->jit_ptr, X86_CC_Z, 0, 1);     x86_branch8(iop->ob_ptr, X86_CC_Z, 0, 1);
495     ppc32_jit_tcb_push_epilog(b);     ppc32_jit_tcb_push_epilog(&iop->ob_ptr);
496     x86_patch(test1,b->jit_ptr);     x86_patch(test1,iop->ob_ptr);
497    
498     if (update)     if (update)
499        ppc32_store_gpr(b,ra,X86_ESI);        ppc32_store_gpr(&iop->ob_ptr,ra,X86_ESI);
500  }  }
501    
502  typedef void (*memop_fast_access)(ppc32_jit_tcb_t *b,int target);  typedef void (*memop_fast_access)(jit_op_t *iop,int target);
503    
504  /* Fast LBZ */  /* Fast LBZ */
505  static void ppc32_memop_fast_lbz(ppc32_jit_tcb_t *b,int target)  static void ppc32_memop_fast_lbz(jit_op_t *iop,int target)
506  {  {
507     x86_clear_reg(b->jit_ptr,X86_ECX);     x86_clear_reg(iop->ob_ptr,X86_ECX);
508     x86_mov_reg_memindex(b->jit_ptr,X86_ECX,X86_EAX,0,X86_EBX,0,1);     x86_mov_reg_memindex(iop->ob_ptr,X86_ECX,X86_EAX,0,X86_EBX,0,1);
509     ppc32_store_gpr(b,target,X86_ECX);     ppc32_store_gpr(&iop->ob_ptr,target,X86_ECX);
510  }  }
511    
512  /* Fast STB */  /* Fast STB */
513  static void ppc32_memop_fast_stb(ppc32_jit_tcb_t *b,int target)  static void ppc32_memop_fast_stb(jit_op_t *iop,int target)
514  {  {
515     ppc32_load_gpr(b,X86_EDX,target);     ppc32_load_gpr(&iop->ob_ptr,X86_EDX,target);
516     x86_mov_memindex_reg(b->jit_ptr,X86_EAX,0,X86_EBX,0,X86_EDX,1);     x86_mov_memindex_reg(iop->ob_ptr,X86_EAX,0,X86_EBX,0,X86_EDX,1);
517  }  }
518    
519  /* Fast LWZ */  /* Fast LWZ */
520  static void ppc32_memop_fast_lwz(ppc32_jit_tcb_t *b,int target)  static void ppc32_memop_fast_lwz(jit_op_t *iop,int target)
521  {  {
522     x86_mov_reg_memindex(b->jit_ptr,X86_EAX,X86_EAX,0,X86_EBX,0,4);     x86_mov_reg_memindex(iop->ob_ptr,X86_EAX,X86_EAX,0,X86_EBX,0,4);
523     x86_bswap(b->jit_ptr,X86_EAX);     x86_bswap(iop->ob_ptr,X86_EAX);
524     ppc32_store_gpr(b,target,X86_EAX);     ppc32_store_gpr(&iop->ob_ptr,target,X86_EAX);
525  }  }
526    
527  /* Fast STW */  /* Fast STW */
528  static void ppc32_memop_fast_stw(ppc32_jit_tcb_t *b,int target)  static void ppc32_memop_fast_stw(jit_op_t *iop,int target)
529  {  {
530     ppc32_load_gpr(b,X86_EDX,target);     ppc32_load_gpr(&iop->ob_ptr,X86_EDX,target);
531     x86_bswap(b->jit_ptr,X86_EDX);     x86_bswap(iop->ob_ptr,X86_EDX);
532     x86_mov_memindex_reg(b->jit_ptr,X86_EAX,0,X86_EBX,0,X86_EDX,4);     x86_mov_memindex_reg(iop->ob_ptr,X86_EAX,0,X86_EBX,0,X86_EDX,4);
533  }  }
534    
535  /* Fast memory operation */  /* Fast memory operation */
536  static void ppc32_emit_memop_fast(ppc32_jit_tcb_t *b,int write_op,int opcode,  static void ppc32_emit_memop_fast(cpu_ppc_t *cpu,ppc32_jit_tcb_t *b,
537                                      int write_op,int opcode,
538                                    int base,int offset,int target,                                    int base,int offset,int target,
539                                    memop_fast_access op_handler)                                    memop_fast_access op_handler)
540  {  {
541     m_uint32_t val = sign_extend(offset,16);     m_uint32_t val = sign_extend(offset,16);
542     u_char *test1,*test2,*p_exception,*p_exit;     u_char *test1,*test2,*p_exception,*p_exit;
543       jit_op_t *iop;
544    
545     test2 = NULL;     /*
546        * Since an exception can be triggered, clear JIT state. This allows
547        * to use branch target tag (we can directly branch on this instruction).
548        */
549       ppc32_op_emit_basic_opcode(cpu,JIT_OP_BRANCH_TARGET);
550       ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
551    
552     /* EBX = sign-extended offset */     iop = ppc32_op_emit_insn_output(cpu,5,"memop_fast");
    ppc32_load_imm(b,X86_EBX,val);  
553    
554     /* EBX = GPR[base] + sign-extended offset */     test2 = NULL;
555     if (base != 0)  
556        ppc32_alu_gpr(b,X86_ADD,X86_EBX,base);     if (val != 0) {
557          /* EBX = sign-extended offset */
558          ppc32_load_imm(&iop->ob_ptr,X86_EBX,val);
559    
560          /* EBX = GPR[base] + sign-extended offset */
561          if (base != 0)
562             ppc32_alu_gpr(&iop->ob_ptr,X86_ADD,X86_EBX,base);
563       } else {
564          if (base != 0)
565             ppc32_load_gpr(&iop->ob_ptr,X86_EBX,base);
566          else
567             ppc32_load_imm(&iop->ob_ptr,X86_EBX,0);
568       }
569    
570     /* EAX = mts32_entry index */     /* EAX = mts32_entry index */
571     x86_mov_reg_reg(b->jit_ptr,X86_EAX,X86_EBX,4);     x86_mov_reg_reg(iop->ob_ptr,X86_EAX,X86_EBX,4);
572     x86_shift_reg_imm(b->jit_ptr,X86_SHR,X86_EAX,MTS32_HASH_SHIFT);     x86_shift_reg_imm(iop->ob_ptr,X86_SHR,X86_EAX,MTS32_HASH_SHIFT);
573     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EAX,MTS32_HASH_MASK);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,X86_EAX,MTS32_HASH_MASK);
574    
575     /* EDX = mts32_entry */     /* EDX = mts32_entry */
576     x86_mov_reg_membase(b->jit_ptr,X86_EDX,     x86_mov_reg_membase(iop->ob_ptr,X86_EDX,
577                         X86_EDI,OFFSET(cpu_ppc_t,mts_cache[PPC32_MTS_DCACHE]),                         X86_EDI,OFFSET(cpu_ppc_t,mts_cache[PPC32_MTS_DCACHE]),
578                         4);                         4);
579     x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EAX,4);     x86_shift_reg_imm(iop->ob_ptr,X86_SHL,X86_EAX,4);
580     x86_alu_reg_reg(b->jit_ptr,X86_ADD,X86_EDX,X86_EAX);     x86_alu_reg_reg(iop->ob_ptr,X86_ADD,X86_EDX,X86_EAX);
581    
582     /* Compare virtual page address (ESI = vpage) */     /* Compare virtual page address (ESI = vpage) */
583     x86_mov_reg_reg(b->jit_ptr,X86_ESI,X86_EBX,4);     x86_mov_reg_reg(iop->ob_ptr,X86_ESI,X86_EBX,4);
584     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_ESI,PPC32_MIN_PAGE_MASK);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,X86_ESI,PPC32_MIN_PAGE_MASK);
585    
586     x86_alu_reg_membase(b->jit_ptr,X86_CMP,X86_ESI,X86_EDX,     x86_alu_reg_membase(iop->ob_ptr,X86_CMP,X86_ESI,X86_EDX,
587                         OFFSET(mts32_entry_t,gvpa));                         OFFSET(mts32_entry_t,gvpa));
588     test1 = b->jit_ptr;     test1 = iop->ob_ptr;
589     x86_branch8(b->jit_ptr, X86_CC_NZ, 0, 1);     x86_branch8(iop->ob_ptr, X86_CC_NZ, 0, 1);
590    
591     /* Test if we are writing to a COW page */     /* Test if we are writing to a COW page */
592     if (write_op) {     if (write_op) {
593        x86_test_membase_imm(b->jit_ptr,X86_EDX,OFFSET(mts32_entry_t,flags),        x86_test_membase_imm(iop->ob_ptr,X86_EDX,OFFSET(mts32_entry_t,flags),
594                             MTS_FLAG_COW|MTS_FLAG_EXEC);                             MTS_FLAG_COW|MTS_FLAG_EXEC);
595        test2 = b->jit_ptr;        test2 = iop->ob_ptr;
596        x86_branch8(b->jit_ptr, X86_CC_NZ, 0, 1);        x86_branch8(iop->ob_ptr, X86_CC_NZ, 0, 1);
597     }     }
598    
599     /* EBX = offset in page, EAX = Host Page Address */     /* EBX = offset in page, EAX = Host Page Address */
600     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,PPC32_MIN_PAGE_IMASK);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,X86_EBX,PPC32_MIN_PAGE_IMASK);
601     x86_mov_reg_membase(b->jit_ptr,X86_EAX,X86_EDX,OFFSET(mts32_entry_t,hpa),4);     x86_mov_reg_membase(iop->ob_ptr,X86_EAX,
602                           X86_EDX,OFFSET(mts32_entry_t,hpa),4);
603    
604     /* Memory access */     /* Memory access */
605     op_handler(b,target);     op_handler(iop,target);
606    
607     p_exit = b->jit_ptr;     p_exit = iop->ob_ptr;
608     x86_jump8(b->jit_ptr,0);     x86_jump8(iop->ob_ptr,0);
609    
610     /* === Slow lookup === */     /* === Slow lookup === */
611     x86_patch(test1,b->jit_ptr);     x86_patch(test1,iop->ob_ptr);
612     if (test2)     if (test2)
613        x86_patch(test2,b->jit_ptr);        x86_patch(test2,iop->ob_ptr);
614    
615     /* Update IA (EBX = vaddr) */     /* Update IA (EBX = vaddr) */
616     ppc32_set_ia(b,b->start_ia+((b->ppc_trans_pos-1)<<2));     ppc32_set_ia(&iop->ob_ptr,b->start_ia+(b->ppc_trans_pos << 2));
617    
618     /* EDX = virtual address */     /* EDX = virtual address */
619     x86_mov_reg_reg(b->jit_ptr,X86_EDX,X86_EBX,4);     x86_mov_reg_reg(iop->ob_ptr,X86_EDX,X86_EBX,4);
620    
621     /* ECX = target register */     /* ECX = target register */
622     x86_mov_reg_imm(b->jit_ptr,X86_ECX,target);     x86_mov_reg_imm(iop->ob_ptr,X86_ECX,target);
623    
624     /* EAX = CPU instance pointer */     /* EAX = CPU instance pointer */
625     x86_mov_reg_reg(b->jit_ptr,X86_EAX,X86_EDI,4);     x86_mov_reg_reg(iop->ob_ptr,X86_EAX,X86_EDI,4);
626    
627     /* Call memory function */     /* Call memory function */
628     x86_call_membase(b->jit_ptr,X86_EDI,MEMOP_OFFSET(opcode));     x86_call_membase(iop->ob_ptr,X86_EDI,MEMOP_OFFSET(opcode));
629    
630     /* Check for exception */     /* Check for exception */
631     x86_test_reg_reg(b->jit_ptr,X86_EAX,X86_EAX);     x86_test_reg_reg(iop->ob_ptr,X86_EAX,X86_EAX);
632     p_exception = b->jit_ptr;     p_exception = iop->ob_ptr;
633     x86_branch8(b->jit_ptr, X86_CC_Z, 0, 1);     x86_branch8(iop->ob_ptr, X86_CC_Z, 0, 1);
634     ppc32_jit_tcb_push_epilog(b);     ppc32_jit_tcb_push_epilog(&iop->ob_ptr);
   
    x86_patch(p_exit,b->jit_ptr);  
    x86_patch(p_exception,b->jit_ptr);  
 }  
   
 /* Virtual Breakpoint */  
 void ppc32_emit_breakpoint(ppc32_jit_tcb_t *b)  
 {  
    x86_mov_reg_reg(b->jit_ptr,X86_EAX,X86_EDI,4);  
    ppc32_emit_c_call(b,ppc32_run_breakpoint);  
 }  
   
 /* Unknown opcode handler */  
 static asmlinkage void ppc32_unknown_opcode(cpu_ppc_t *cpu,m_uint32_t opcode)  
 {  
    printf("PPC32: unhandled opcode 0x%8.8x at 0x%8.8x (lr=0x%8.8x)\n",  
           opcode,cpu->ia,cpu->lr);  
635    
636     ppc32_dump_regs(cpu->gen);     x86_patch(p_exit,iop->ob_ptr);
637     exit(1);     x86_patch(p_exception,iop->ob_ptr);
638  }  }
639    
640  /* Emit unhandled instruction code */  /* Emit unhandled instruction code */
# Line 497  static int ppc32_emit_unknown(cpu_ppc_t Line 642  static int ppc32_emit_unknown(cpu_ppc_t
642                                ppc_insn_t opcode)                                ppc_insn_t opcode)
643  {  {
644     u_char *test1;     u_char *test1;
645       jit_op_t *iop;
646    
647  #if 0           iop = ppc32_op_emit_insn_output(cpu,3,"unknown");
    x86_mov_reg_imm(b->jit_ptr,X86_EAX,opcode);  
    x86_alu_reg_imm(b->jit_ptr,X86_SUB,X86_ESP,4);  
    x86_push_reg(b->jit_ptr,X86_EAX);  
    x86_push_reg(b->jit_ptr,X86_EDI);  
    ppc32_emit_c_call(b,ppc32_unknown_opcode);  
    x86_alu_reg_imm(b->jit_ptr,X86_ADD,X86_ESP,12);  
 #endif  
648    
649     /* Update IA */     /* Update IA */
650     ppc32_set_ia(b,b->start_ia+((b->ppc_trans_pos-1)<<2));     ppc32_set_ia(&iop->ob_ptr,b->start_ia+(b->ppc_trans_pos << 2));
651    
652     /* Fallback to non-JIT mode */     /* Fallback to non-JIT mode */
653     x86_mov_reg_reg(b->jit_ptr,X86_EAX,X86_EDI,4);     x86_mov_reg_reg(iop->ob_ptr,X86_EAX,X86_EDI,4);
654     x86_mov_reg_imm(b->jit_ptr,X86_EDX,opcode);     x86_mov_reg_imm(iop->ob_ptr,X86_EDX,opcode);
655    
656     ppc32_emit_c_call(b,ppc32_exec_single_insn_ext);     ppc32_emit_c_call(b,iop,ppc32_exec_single_insn_ext);
657     x86_test_reg_reg(b->jit_ptr,X86_EAX,X86_EAX);     x86_test_reg_reg(iop->ob_ptr,X86_EAX,X86_EAX);
658     test1 = b->jit_ptr;     test1 = iop->ob_ptr;
659     x86_branch8(b->jit_ptr, X86_CC_Z, 0, 1);     x86_branch8(iop->ob_ptr, X86_CC_Z, 0, 1);
660     ppc32_jit_tcb_push_epilog(b);     ppc32_jit_tcb_push_epilog(&iop->ob_ptr);
661    
662     x86_patch(test1,b->jit_ptr);     x86_patch(test1,iop->ob_ptr);
    return(0);  
 }  
663    
664  /* Dump regs */     /* Signal this as an EOB to reset JIT state */
665  static void ppc32_emit_dump_regs(ppc32_jit_tcb_t *b)     ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
666  {       return(0);
    x86_mov_reg_membase(b->jit_ptr,X86_EAX,X86_EDI,OFFSET(cpu_ppc_t,gen),4);  
    x86_push_reg(b->jit_ptr,X86_EAX);  
    ppc32_emit_c_call(b,ppc32_dump_regs);  
    x86_alu_reg_imm(b->jit_ptr,X86_ADD,X86_ESP,4);  
667  }  }
668    
669  /* Increment the number of executed instructions (performance debugging) */  /* Virtual Breakpoint */
670  void ppc32_inc_perf_counter(ppc32_jit_tcb_t *b)  void ppc32_emit_breakpoint(cpu_ppc_t *cpu,ppc32_jit_tcb_t *b)
671  {  {
672     x86_alu_membase_imm(b->jit_ptr,X86_ADD,     jit_op_t *iop;
673                         X86_EDI,OFFSET(cpu_ppc_t,perf_counter),1);  
674     x86_alu_membase_imm(b->jit_ptr,X86_ADC,     iop = ppc32_op_emit_insn_output(cpu,2,"breakpoint");
675                         X86_EDI,OFFSET(cpu_ppc_t,perf_counter)+4,0);  
676       x86_mov_reg_reg(iop->ob_ptr,X86_EAX,X86_EDI,4);
677       ppc32_emit_c_call(b,iop,ppc32_run_breakpoint);
678    
679       /* Signal this as an EOB to to reset JIT state */
680       ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
681  }  }
682    
683  /* Check if there are pending IRQ */  /* Dump regs */
684  void ppc32_check_pending_irq(ppc32_jit_tcb_t *b)  static void ppc32_emit_dump_regs(cpu_ppc_t *cpu,ppc32_jit_tcb_t *b)
685  {  {  
686     u_char *test1;     jit_op_t *iop;
687    
688       iop = ppc32_op_emit_insn_output(cpu,2,"dump_regs");
689    
690     /* Check the pending IRQ flag */     x86_mov_reg_membase(iop->ob_ptr,X86_EAX,X86_EDI,OFFSET(cpu_ppc_t,gen),4);
691     x86_mov_reg_membase(b->jit_ptr,X86_EAX,     x86_push_reg(iop->ob_ptr,X86_EAX);
692                         X86_EDI,OFFSET(cpu_ppc_t,irq_check),4);     ppc32_emit_c_call(b,iop,ppc32_dump_regs);
693     x86_test_reg_reg(b->jit_ptr,X86_EAX,X86_EAX);     x86_alu_reg_imm(iop->ob_ptr,X86_ADD,X86_ESP,4);
    test1 = b->jit_ptr;  
    x86_branch8(b->jit_ptr, X86_CC_Z, 0, 1);  
   
    /* Save PC */  
    ppc32_set_ia(b,b->start_ia+((b->ppc_trans_pos-1)<<2));  
    ppc32_jit_tcb_push_epilog(b);  
694    
695     x86_patch(test1,b->jit_ptr);     /* Signal this as an EOB to to reset JIT state */
696       ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
697  }  }
698    
699  /* ======================================================================== */  /* ======================================================================== */
# Line 566  void ppc32_check_pending_irq(ppc32_jit_t Line 701  void ppc32_check_pending_irq(ppc32_jit_t
701  /* BLR - Branch to Link Register */  /* BLR - Branch to Link Register */
702  DECLARE_INSN(BLR)  DECLARE_INSN(BLR)
703  {  {
704     x86_mov_reg_membase(b->jit_ptr,X86_EDX,X86_EDI,OFFSET(cpu_ppc_t,lr),4);     jit_op_t *iop;
705     x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,ia),X86_EDX,4);     int hreg;
706    
707       ppc32_jit_start_hreg_seq(cpu,"blr");
708       hreg = ppc32_jit_alloc_hreg(cpu,-1);
709       ppc32_op_emit_alter_host_reg(cpu,hreg);
710    
711       iop = ppc32_op_emit_insn_output(cpu,2,"blr");
712    
713       x86_mov_reg_membase(iop->ob_ptr,hreg,X86_EDI,OFFSET(cpu_ppc_t,lr),4);
714       x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,ia),hreg,4);
715    
716     /* set the return address */     /* set the return address */
717     if (insn & 1)     if (insn & 1)
718        ppc32_set_lr(b,b->start_ia + (b->ppc_trans_pos << 2));        ppc32_set_lr(iop,b->start_ia + ((b->ppc_trans_pos+1) << 2));
719    
720       ppc32_jit_tcb_push_epilog(&iop->ob_ptr);
721       ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
722       ppc32_op_emit_branch_target(cpu,b,b->start_ia+((b->ppc_trans_pos+1) << 2));
723    
724     ppc32_jit_tcb_push_epilog(b);     ppc32_jit_close_hreg_seq(cpu);
725     return(0);     return(0);
726  }  }
727    
728  /* BCTR - Branch to Count Register */  /* BCTR - Branch to Count Register */
729  DECLARE_INSN(BCTR)  DECLARE_INSN(BCTR)
730  {  {
731     x86_mov_reg_membase(b->jit_ptr,X86_EDX,X86_EDI,OFFSET(cpu_ppc_t,ctr),4);     jit_op_t *iop;
732     x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,ia),X86_EDX,4);     int hreg;
733    
734       ppc32_jit_start_hreg_seq(cpu,"bctr");
735       hreg = ppc32_jit_alloc_hreg(cpu,-1);
736       ppc32_op_emit_alter_host_reg(cpu,hreg);
737    
738       iop = ppc32_op_emit_insn_output(cpu,2,"bctr");
739    
740       x86_mov_reg_membase(iop->ob_ptr,hreg,X86_EDI,OFFSET(cpu_ppc_t,ctr),4);
741       x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,ia),hreg,4);
742    
743     /* set the return address */     /* set the return address */
744     if (insn & 1)     if (insn & 1)
745        ppc32_set_lr(b,b->start_ia + (b->ppc_trans_pos << 2));        ppc32_set_lr(iop,b->start_ia + ((b->ppc_trans_pos+1) << 2));
746    
747       ppc32_jit_tcb_push_epilog(&iop->ob_ptr);
748       ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
749       ppc32_op_emit_branch_target(cpu,b,b->start_ia+((b->ppc_trans_pos+1) << 2));
750    
751     ppc32_jit_tcb_push_epilog(b);     ppc32_jit_close_hreg_seq(cpu);
752     return(0);     return(0);
753  }  }
754    
# Line 595  DECLARE_INSN(BCTR) Line 756  DECLARE_INSN(BCTR)
756  DECLARE_INSN(MFLR)  DECLARE_INSN(MFLR)
757  {  {
758     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
759         int hreg_rd;
760     x86_mov_reg_membase(b->jit_ptr,X86_EDX,X86_EDI,OFFSET(cpu_ppc_t,lr),4);     jit_op_t *iop;
761     ppc32_store_gpr(b,rd,X86_EDX);  
762       ppc32_jit_start_hreg_seq(cpu,"mflr");
763       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
764       iop = ppc32_op_emit_insn_output(cpu,1,"mflr");
765    
766       x86_mov_reg_membase(iop->ob_ptr,hreg_rd,X86_EDI,OFFSET(cpu_ppc_t,lr),4);
767       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
768    
769       ppc32_jit_close_hreg_seq(cpu);
770     return(0);     return(0);
771  }  }
772    
# Line 605  DECLARE_INSN(MFLR) Line 774  DECLARE_INSN(MFLR)
774  DECLARE_INSN(MTLR)  DECLARE_INSN(MTLR)
775  {  {
776     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
777       int hreg_rs;
778       jit_op_t *iop;
779      
780       ppc32_jit_start_hreg_seq(cpu,"mtlr");
781       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
782       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
783    
784     ppc32_load_gpr(b,X86_EDX,rs);     iop = ppc32_op_emit_insn_output(cpu,1,"mtlr");
785     x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,lr),X86_EDX,4);     x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,lr),hreg_rs,4);
786    
787       ppc32_jit_close_hreg_seq(cpu);
788     return(0);     return(0);
789  }  }
790    
# Line 615  DECLARE_INSN(MTLR) Line 792  DECLARE_INSN(MTLR)
792  DECLARE_INSN(MFCTR)  DECLARE_INSN(MFCTR)
793  {  {
794     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
795       int hreg_rd;
796       jit_op_t *iop;
797        
798     x86_mov_reg_membase(b->jit_ptr,X86_EDX,X86_EDI,OFFSET(cpu_ppc_t,ctr),4);     ppc32_jit_start_hreg_seq(cpu,"mfctr");
799     ppc32_store_gpr(b,rd,X86_EDX);     hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
800    
801       iop = ppc32_op_emit_insn_output(cpu,1,"mfctr");
802    
803       x86_mov_reg_membase(iop->ob_ptr,hreg_rd,X86_EDI,OFFSET(cpu_ppc_t,ctr),4);
804       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
805    
806       ppc32_jit_close_hreg_seq(cpu);
807     return(0);     return(0);
808  }  }
809    
# Line 625  DECLARE_INSN(MFCTR) Line 811  DECLARE_INSN(MFCTR)
811  DECLARE_INSN(MTCTR)  DECLARE_INSN(MTCTR)
812  {  {
813     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
814       int hreg_rs;
815       jit_op_t *iop;
816    
817       ppc32_jit_start_hreg_seq(cpu,"mtctr");
818       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
819       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
820    
821       iop = ppc32_op_emit_insn_output(cpu,1,"mtctr");
822       x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,ctr),hreg_rs,4);
823    
824     ppc32_load_gpr(b,X86_EDX,rs);     ppc32_jit_close_hreg_seq(cpu);
    x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,ctr),X86_EDX,4);  
825     return(0);     return(0);
826  }  }
827    
# Line 635  DECLARE_INSN(MTCTR) Line 829  DECLARE_INSN(MTCTR)
829  DECLARE_INSN(MFTBU)  DECLARE_INSN(MFTBU)
830  {  {
831     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
832       int hreg_rd;
833       jit_op_t *iop;
834    
835     x86_mov_reg_membase(b->jit_ptr,X86_EDX,X86_EDI,OFFSET(cpu_ppc_t,tb)+4,4);     ppc32_jit_start_hreg_seq(cpu,"mftbu");
836     ppc32_store_gpr(b,rd,X86_EDX);     hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
837    
838       iop = ppc32_op_emit_insn_output(cpu,1,"mftbu");
839    
840       x86_mov_reg_membase(iop->ob_ptr,hreg_rd,X86_EDI,OFFSET(cpu_ppc_t,tb)+4,4);
841       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
842    
843       ppc32_jit_close_hreg_seq(cpu);
844     return(0);     return(0);
845  }  }
846    
# Line 647  DECLARE_INSN(MFTBU) Line 850  DECLARE_INSN(MFTBU)
850  DECLARE_INSN(MFTBL)  DECLARE_INSN(MFTBL)
851  {  {
852     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
853       int hreg_rd,hreg_t0;
854       jit_op_t *iop;
855    
856       ppc32_jit_start_hreg_seq(cpu,"mftbl");
857       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
858       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
859    
860       iop = ppc32_op_emit_insn_output(cpu,3,"mftbl");
861    
862       x86_mov_reg_membase(iop->ob_ptr,hreg_rd,X86_EDI,OFFSET(cpu_ppc_t,tb),4);
863    
864     /* Increment the time base register */     /* Increment the time base register */
865     x86_mov_reg_membase(b->jit_ptr,X86_EDX,X86_EDI,OFFSET(cpu_ppc_t,tb),4);     x86_mov_reg_membase(iop->ob_ptr,hreg_rd,X86_EDI,OFFSET(cpu_ppc_t,tb),4);
866     x86_mov_reg_membase(b->jit_ptr,X86_EBX,X86_EDI,OFFSET(cpu_ppc_t,tb)+4,4);     x86_mov_reg_membase(iop->ob_ptr,hreg_t0,X86_EDI,OFFSET(cpu_ppc_t,tb)+4,4);
867     x86_alu_reg_imm(b->jit_ptr,X86_ADD,X86_EDX,PPC32_TB_INCREMENT);     x86_alu_reg_imm(iop->ob_ptr,X86_ADD,hreg_rd,PPC32_TB_INCREMENT);
868     x86_alu_reg_imm(b->jit_ptr,X86_ADC,X86_EBX,0);     x86_alu_reg_imm(iop->ob_ptr,X86_ADC,hreg_t0,0);
869     x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,tb),X86_EDX,4);     x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,tb),hreg_rd,4);
870     x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,tb)+4,X86_EBX,4);     x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,tb)+4,hreg_t0,4);
871    
872     ppc32_store_gpr(b,rd,X86_EDX);     ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
873    
874       ppc32_jit_close_hreg_seq(cpu);
875     return(0);     return(0);
876  }  }
877    
# Line 666  DECLARE_INSN(ADD) Line 881  DECLARE_INSN(ADD)
881     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
882     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
883     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
884       int hreg_rd,hreg_ra,hreg_rb;
885       jit_op_t *iop;
886    
887     /* $rd = $ra + $rb */     /* $rd = $ra + $rb */
888     ppc32_load_gpr(b,X86_EBX,ra);     ppc32_jit_start_hreg_seq(cpu,"add");
889     ppc32_alu_gpr(b,X86_ADD,X86_EBX,rb);     hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
890     ppc32_store_gpr(b,rd,X86_EBX);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
891       hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
892    
893       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
894       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
895    
896       iop = ppc32_op_emit_insn_output(cpu,2,"add");
897    
898       if (rd == ra)
899          x86_alu_reg_reg(iop->ob_ptr,X86_ADD,hreg_rd,hreg_rb);
900       else if (rd == rb)
901          x86_alu_reg_reg(iop->ob_ptr,X86_ADD,hreg_rd,hreg_ra);
902       else {
903          x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_ra,4);
904          x86_alu_reg_reg(iop->ob_ptr,X86_ADD,hreg_rd,hreg_rb);
905       }
906    
907       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
908    
909     if (insn & 1)     if (insn & 1)
910        ppc32_update_cr0(b);        ppc32_op_emit_update_flags(cpu,0,TRUE);
911            
912       ppc32_jit_close_hreg_seq(cpu);
913     return(0);     return(0);
914  }  }
915    
# Line 684  DECLARE_INSN(ADDC) Line 919  DECLARE_INSN(ADDC)
919     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
920     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
921     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
922       int hreg_rd,hreg_ra,hreg_rb,hreg_t0;
923       jit_op_t *iop;
924    
925     /* $rd = $ra + $rb */     /* $rd = $ra + $rb */
926     ppc32_load_gpr(b,X86_EBX,ra);     ppc32_jit_start_hreg_seq(cpu,"addc");
927     ppc32_alu_gpr(b,X86_ADD,X86_EBX,rb);     hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
928     ppc32_store_gpr(b,rd,X86_EBX);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
929       hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
930    
931     /* store the carry flag */     /* store the carry flag */
932     x86_set_reg(b->jit_ptr,X86_CC_C,X86_EAX,FALSE);     hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
933     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EAX,0x1);  
934     x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),X86_EAX,4);     ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
935       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
936    
937       iop = ppc32_op_emit_insn_output(cpu,2,"addc");
938    
939       if (rd == ra)
940          x86_alu_reg_reg(iop->ob_ptr,X86_ADD,hreg_rd,hreg_rb);
941       else if (rd == rb)
942          x86_alu_reg_reg(iop->ob_ptr,X86_ADD,hreg_rd,hreg_ra);
943       else {
944          x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_ra,4);
945          x86_alu_reg_reg(iop->ob_ptr,X86_ADD,hreg_rd,hreg_rb);
946       }
947    
948       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
949      
950       x86_set_reg(iop->ob_ptr,X86_CC_C,hreg_t0,FALSE);
951       x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x1);
952       x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),
953                           hreg_t0,4);
954    
955     if (insn & 1) {     if (insn & 1) {
956        x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);        x86_test_reg_reg(iop->ob_ptr,hreg_rd,hreg_rd);
957        ppc32_update_cr0(b);        ppc32_op_emit_update_flags(cpu,0,TRUE);
958     }     }
959          
960       ppc32_jit_close_hreg_seq(cpu);
961     return(0);     return(0);
962  }  }
963    
# Line 709  DECLARE_INSN(ADDE) Line 967  DECLARE_INSN(ADDE)
967     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
968     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
969     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
970       int hreg_ra,hreg_rb,hreg_rd,hreg_t0,hreg_t1;
971       jit_op_t *iop;
972    
973     /* $ra + carry */     ppc32_jit_start_hreg_seq(cpu,"adde");
974     ppc32_load_gpr(b,X86_ESI,ra);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
975     x86_alu_reg_membase(b->jit_ptr,X86_ADD,X86_ESI,     hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
976                         X86_EDI,OFFSET(cpu_ppc_t,xer_ca));     hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
    x86_set_reg(b->jit_ptr,X86_CC_C,X86_EAX,FALSE);  
977    
978     /* add $rb */     hreg_t0 = ppc32_jit_alloc_hreg(cpu,-1);
979     ppc32_alu_gpr(b,X86_ADD,X86_ESI,rb);     hreg_t1 = ppc32_jit_get_tmp_hreg(cpu);
    x86_set_reg(b->jit_ptr,X86_CC_C,X86_ECX,FALSE);  
980    
981     ppc32_store_gpr(b,rd,X86_ESI);     ppc32_op_emit_alter_host_reg(cpu,hreg_t0);
982       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
983       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
984    
985     /* store the carry flag */     iop = ppc32_op_emit_insn_output(cpu,3,"adde");
    x86_alu_reg_reg(b->jit_ptr,X86_OR,X86_EAX,X86_ECX);  
    x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EAX,0x1);  
986    
987     x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),X86_EAX,4);     /* $t0 = $ra + carry */
988       x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_t1,hreg_t1);
989       x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_ra,4);
990    
991       x86_alu_reg_membase(iop->ob_ptr,X86_ADD,hreg_t0,
992                           X86_EDI,OFFSET(cpu_ppc_t,xer_ca));
993       x86_set_reg(iop->ob_ptr,X86_CC_C,hreg_t1,FALSE);
994       x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),hreg_t1,4);
995    
996       /* $t0 += $rb */
997       x86_alu_reg_reg(iop->ob_ptr,X86_ADD,hreg_t0,hreg_rb);
998       x86_set_reg(iop->ob_ptr,X86_CC_C,hreg_t1,FALSE);
999       x86_alu_membase_reg(iop->ob_ptr,X86_OR,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),
1000                           hreg_t1);
1001    
1002     /* update cr0 */     /* update cr0 */
1003     if (insn & 1) {     if (insn & 1)
1004        x86_test_reg_reg(b->jit_ptr,X86_ESI,X86_ESI);        x86_test_reg_reg(iop->ob_ptr,hreg_t0,hreg_t0);
       ppc32_update_cr0(b);  
    }  
1005    
1006       x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_t0,4);
1007       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
1008    
1009       if (insn & 1)
1010          ppc32_op_emit_update_flags(cpu,0,TRUE);
1011    
1012       ppc32_jit_close_hreg_seq(cpu);
1013     return(0);     return(0);
1014  }  }
1015    
# Line 744  DECLARE_INSN(ADDI) Line 1020  DECLARE_INSN(ADDI)
1020     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1021     int imm = bits(insn,0,15);     int imm = bits(insn,0,15);
1022     m_uint32_t tmp = sign_extend_32(imm,16);     m_uint32_t tmp = sign_extend_32(imm,16);
1023       int hreg_rd,hreg_ra;
1024       jit_op_t *iop;
1025    
1026       /* $rd = $ra + imm */
1027       ppc32_jit_start_hreg_seq(cpu,"addi");
1028       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
1029    
1030     ppc32_load_imm(b,X86_EBX,tmp);     if (ra != 0) {
1031          hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1032          ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
1033    
1034     if (ra != 0)        iop = ppc32_op_emit_insn_output(cpu,2,"addi");
       x86_alu_reg_membase(b->jit_ptr,X86_ADD,X86_EBX,X86_EDI,REG_OFFSET(ra));  
1035    
1036     ppc32_store_gpr(b,rd,X86_EBX);        if (rd != ra)
1037             x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_ra,4);
1038    
1039          x86_alu_reg_imm(iop->ob_ptr,X86_ADD,hreg_rd,tmp);
1040       } else {
1041          iop = ppc32_op_emit_insn_output(cpu,1,"addi");
1042          ppc32_load_imm(&iop->ob_ptr,hreg_rd,tmp);
1043       }
1044    
1045       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
1046    
1047       ppc32_jit_close_hreg_seq(cpu);
1048     return(0);     return(0);
1049  }  }
1050    
# Line 761  DECLARE_INSN(ADDIC) Line 1055  DECLARE_INSN(ADDIC)
1055     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1056     int imm = bits(insn,0,15);     int imm = bits(insn,0,15);
1057     m_uint32_t tmp = sign_extend_32(imm,16);     m_uint32_t tmp = sign_extend_32(imm,16);
1058       int hreg_rd,hreg_ra;
1059       jit_op_t *iop;
1060    
1061       /* $rd = $ra + imm */
1062       ppc32_jit_start_hreg_seq(cpu,"addic");
1063       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
1064       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1065    
1066       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
1067    
1068       iop = ppc32_op_emit_insn_output(cpu,1,"addic");
1069    
1070       if (rd != ra)
1071          x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_ra,4);
1072    
1073       x86_alu_reg_imm(iop->ob_ptr,X86_ADD,hreg_rd,tmp);
1074       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
1075    
1076     ppc32_load_imm(b,X86_EAX,tmp);     x86_set_membase(iop->ob_ptr,X86_CC_C,
1077     ppc32_alu_gpr(b,X86_ADD,X86_EAX,ra);                     X86_EDI,OFFSET(cpu_ppc_t,xer_ca),FALSE);
1078     ppc32_store_gpr(b,rd,X86_EAX);  
1079     x86_set_membase(b->jit_ptr,X86_CC_C,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),FALSE);     ppc32_jit_close_hreg_seq(cpu);
1080     return(0);     return(0);
1081  }  }
1082    
# Line 776  DECLARE_INSN(ADDIC_dot) Line 1087  DECLARE_INSN(ADDIC_dot)
1087     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1088     int imm = bits(insn,0,15);     int imm = bits(insn,0,15);
1089     m_uint32_t tmp = sign_extend_32(imm,16);     m_uint32_t tmp = sign_extend_32(imm,16);
1090       int hreg_rd,hreg_ra;
1091       jit_op_t *iop;
1092    
1093       /* $rd = $ra + imm */
1094       ppc32_jit_start_hreg_seq(cpu,"addic.");
1095       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
1096       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1097    
1098       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
1099    
1100       iop = ppc32_op_emit_insn_output(cpu,1,"addic.");
1101    
1102       if (rd != ra)
1103          x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_ra,4);
1104    
1105     ppc32_load_imm(b,X86_EAX,tmp);     x86_alu_reg_imm(iop->ob_ptr,X86_ADD,hreg_rd,tmp);
1106     ppc32_alu_gpr(b,X86_ADD,X86_EAX,ra);     ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
    ppc32_store_gpr(b,rd,X86_EAX);  
    x86_set_membase(b->jit_ptr,X86_CC_C,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),FALSE);  
1107    
1108     x86_test_reg_reg(b->jit_ptr,X86_EAX,X86_EAX);     x86_set_membase(iop->ob_ptr,X86_CC_C,
1109     ppc32_update_cr0(b);                     X86_EDI,OFFSET(cpu_ppc_t,xer_ca),FALSE);
1110    
1111       ppc32_op_emit_update_flags(cpu,0,TRUE);
1112    
1113       ppc32_jit_close_hreg_seq(cpu);
1114     return(0);     return(0);
1115  }  }
1116    
# Line 793  DECLARE_INSN(ADDIS) Line 1120  DECLARE_INSN(ADDIS)
1120     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
1121     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1122     m_uint32_t imm = bits(insn,0,15);     m_uint32_t imm = bits(insn,0,15);
1123       m_uint32_t tmp = imm << 16;
1124       int hreg_rd,hreg_ra;
1125       jit_op_t *iop;
1126    
1127       /* $rd = $ra + (imm << 16) */
1128       ppc32_jit_start_hreg_seq(cpu,"addis");
1129       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
1130    
1131       if (ra != 0) {
1132          hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1133          ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
1134    
1135          iop = ppc32_op_emit_insn_output(cpu,1,"addis");
1136    
1137          if (rd != ra)
1138             x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_ra,4);
1139    
1140          x86_alu_reg_imm(iop->ob_ptr,X86_ADD,hreg_rd,tmp);
1141       } else {
1142          //iop = ppc32_op_emit_insn_output(cpu,1,"addis");
1143          //x86_mov_reg_imm(iop->ob_ptr,hreg_rd,tmp);
1144          ppc32_op_emit_set_host_reg_imm32(cpu,hreg_rd,tmp);
1145       }
1146    
1147       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
1148    
1149       ppc32_jit_close_hreg_seq(cpu);
1150       return(0);
1151    }
1152    
1153    /* ADDZE */
1154    DECLARE_INSN(ADDZE)
1155    {
1156       int rd = bits(insn,21,25);
1157       int ra = bits(insn,16,20);
1158       int hreg_rd,hreg_ra,hreg_t0;
1159       jit_op_t *iop;
1160    
1161     ppc32_load_imm(b,X86_EBX,imm << 16);     /* $rd = $ra + xer_ca + set_carry */
1162       ppc32_jit_start_hreg_seq(cpu,"addze");
1163       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
1164       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1165       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
1166    
1167     if (ra != 0)     ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
       x86_alu_reg_membase(b->jit_ptr,X86_ADD,X86_EBX,X86_EDI,REG_OFFSET(ra));  
1168    
1169     ppc32_store_gpr(b,rd,X86_EBX);     iop = ppc32_op_emit_insn_output(cpu,2,"addze");
1170    
1171       x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_t0,hreg_t0);
1172    
1173       if (rd != ra)
1174          x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_ra,4);
1175    
1176       x86_alu_reg_membase(iop->ob_ptr,X86_ADD,hreg_rd,
1177                           X86_EDI,OFFSET(cpu_ppc_t,xer_ca));
1178    
1179       x86_set_reg(iop->ob_ptr,X86_CC_C,hreg_t0,FALSE);
1180       x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),hreg_t0,4);
1181    
1182       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
1183    
1184       if (insn & 1)
1185          ppc32_op_emit_update_flags(cpu,0,TRUE);
1186    
1187       ppc32_jit_close_hreg_seq(cpu);
1188     return(0);     return(0);
1189  }  }
1190    
# Line 809  DECLARE_INSN(AND) Line 1194  DECLARE_INSN(AND)
1194     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
1195     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1196     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
1197       int hreg_rs,hreg_ra,hreg_rb;
1198       jit_op_t *iop;
1199    
1200       /* $ra = $rs & $rb */
1201       ppc32_jit_start_hreg_seq(cpu,"and");
1202       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
1203       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1204       hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
1205    
1206       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
1207       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
1208    
1209       iop = ppc32_op_emit_insn_output(cpu,1,"and");
1210    
1211       if (ra == rs)
1212          x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_ra,hreg_rb);
1213       else if (ra == rb)
1214          x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_ra,hreg_rs);
1215       else {
1216          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
1217          x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_ra,hreg_rb);
1218       }
1219    
1220     ppc32_load_gpr(b,X86_EBX,rs);     ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
    ppc32_alu_gpr(b,X86_AND,X86_EBX,rb);  
    ppc32_store_gpr(b,ra,X86_EBX);  
1221    
1222     if (insn & 1)     if (insn & 1)
1223        ppc32_update_cr0(b);        ppc32_op_emit_update_flags(cpu,0,TRUE);
1224    
1225       ppc32_jit_close_hreg_seq(cpu);
1226     return(0);     return(0);
1227  }  }
1228    
# Line 826  DECLARE_INSN(ANDC) Line 1232  DECLARE_INSN(ANDC)
1232     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
1233     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1234     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
1235       int hreg_rs,hreg_ra,hreg_rb,hreg_t0;
1236       jit_op_t *iop;
1237    
1238     /* $ra = $rs & ~$rb */     /* $ra = $rs & ~$rb */
1239     ppc32_load_gpr(b,X86_EBX,rb);     ppc32_jit_start_hreg_seq(cpu,"andc");
1240     x86_not_reg(b->jit_ptr,X86_EBX);     hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
1241     ppc32_alu_gpr(b,X86_AND,X86_EBX,rs);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1242     ppc32_store_gpr(b,ra,X86_EBX);     hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
1243    
1244       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
1245       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
1246    
1247       iop = ppc32_op_emit_insn_output(cpu,1,"andc");
1248    
1249       /* $t0 = ~$rb */
1250       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
1251       x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_rb,4);
1252       x86_not_reg(iop->ob_ptr,hreg_t0);
1253    
1254       /* $ra = $rs & $t0 */
1255       if (ra == rs)
1256          x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_ra,hreg_t0);
1257       else {
1258          x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_t0,hreg_rs);
1259          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_t0,4);
1260       }
1261    
1262       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
1263    
1264     if (insn & 1)     if (insn & 1)
1265        ppc32_update_cr0(b);        ppc32_op_emit_update_flags(cpu,0,TRUE);
1266    
1267       ppc32_jit_close_hreg_seq(cpu);
1268     return(0);     return(0);
1269  }  }
1270    
# Line 845  DECLARE_INSN(ANDI) Line 1274  DECLARE_INSN(ANDI)
1274     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
1275     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1276     m_uint16_t imm = bits(insn,0,15);     m_uint16_t imm = bits(insn,0,15);
1277       m_uint32_t tmp = imm;
1278       int hreg_rs,hreg_ra;
1279       jit_op_t *iop;
1280    
1281     /* $ra = $rs & imm */     /* $ra = $rs & imm */
1282     ppc32_load_imm(b,X86_EBX,imm);     ppc32_jit_start_hreg_seq(cpu,"andi");
1283     ppc32_alu_gpr(b,X86_AND,X86_EBX,rs);     hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
1284     ppc32_store_gpr(b,ra,X86_EBX);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1285    
1286       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
1287    
1288       iop = ppc32_op_emit_insn_output(cpu,2,"andi");
1289    
1290     ppc32_update_cr0(b);     if (ra != rs)
1291          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
1292    
1293       x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_ra,tmp);
1294       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
1295    
1296       ppc32_op_emit_update_flags(cpu,0,TRUE);
1297    
1298       ppc32_jit_close_hreg_seq(cpu);
1299     return(0);     return(0);
1300  }  }
1301    
# Line 861  DECLARE_INSN(ANDIS) Line 1305  DECLARE_INSN(ANDIS)
1305     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
1306     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1307     m_uint32_t imm = bits(insn,0,15);     m_uint32_t imm = bits(insn,0,15);
1308       m_uint32_t tmp = imm << 16;
1309       int hreg_rs,hreg_ra;
1310       jit_op_t *iop;
1311    
1312     /* $ra = $rs & imm */     /* $ra = $rs & imm */
1313     ppc32_load_imm(b,X86_EBX,imm << 16);     ppc32_jit_start_hreg_seq(cpu,"andis");
1314     ppc32_alu_gpr(b,X86_AND,X86_EBX,rs);     hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
1315     ppc32_store_gpr(b,ra,X86_EBX);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1316    
1317       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
1318    
1319     ppc32_update_cr0(b);     iop = ppc32_op_emit_insn_output(cpu,2,"andis");
1320    
1321       if (ra != rs)
1322          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
1323    
1324       x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_ra,tmp);
1325       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
1326    
1327       ppc32_op_emit_update_flags(cpu,0,TRUE);
1328    
1329       ppc32_jit_close_hreg_seq(cpu);
1330     return(0);     return(0);
1331  }  }
1332    
# Line 875  DECLARE_INSN(ANDIS) Line 1334  DECLARE_INSN(ANDIS)
1334  DECLARE_INSN(B)  DECLARE_INSN(B)
1335  {  {
1336     m_uint32_t offset = bits(insn,2,25);     m_uint32_t offset = bits(insn,2,25);
1337     m_uint64_t new_ia;     m_uint32_t new_ia;
1338       jit_op_t *iop;
1339    
1340       iop = ppc32_op_emit_insn_output(cpu,4,"b");
1341    
1342     /* compute the new ia */     /* compute the new ia */
1343     new_ia = b->start_ia + ((b->ppc_trans_pos-1) << 2);     new_ia = b->start_ia + (b->ppc_trans_pos << 2);
1344     new_ia += sign_extend(offset << 2,26);     new_ia += sign_extend(offset << 2,26);
1345     ppc32_set_jump(cpu,b,new_ia,1);     ppc32_set_jump(cpu,b,iop,new_ia,TRUE);
1346    
1347       ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
1348       ppc32_op_emit_branch_target(cpu,b,new_ia);
1349       ppc32_op_emit_branch_target(cpu,b,b->start_ia+((b->ppc_trans_pos+1) << 2));
1350     return(0);     return(0);
1351  }  }
1352    
# Line 888  DECLARE_INSN(B) Line 1354  DECLARE_INSN(B)
1354  DECLARE_INSN(BA)  DECLARE_INSN(BA)
1355  {  {
1356     m_uint32_t offset = bits(insn,2,25);     m_uint32_t offset = bits(insn,2,25);
1357     m_uint64_t new_ia;     m_uint32_t new_ia;
1358       jit_op_t *iop;
1359    
1360       iop = ppc32_op_emit_insn_output(cpu,4,"ba");
1361    
1362     /* compute the new ia */     /* compute the new ia */
1363     new_ia = sign_extend(offset << 2,26);     new_ia = sign_extend(offset << 2,26);
1364     ppc32_set_jump(cpu,b,new_ia,1);     ppc32_set_jump(cpu,b,iop,new_ia,TRUE);
1365    
1366       ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
1367       ppc32_op_emit_branch_target(cpu,b,new_ia);
1368       ppc32_op_emit_branch_target(cpu,b,b->start_ia+((b->ppc_trans_pos+1) << 2));
1369     return(0);     return(0);
1370  }  }
1371    
# Line 900  DECLARE_INSN(BA) Line 1373  DECLARE_INSN(BA)
1373  DECLARE_INSN(BL)  DECLARE_INSN(BL)
1374  {  {
1375     m_uint32_t offset = bits(insn,2,25);     m_uint32_t offset = bits(insn,2,25);
1376     m_uint64_t new_ia;     m_uint32_t new_ia;
1377       jit_op_t *iop;
1378    
1379       iop = ppc32_op_emit_insn_output(cpu,4,"bl");
1380    
1381     /* compute the new ia */     /* compute the new ia */
1382     new_ia = b->start_ia + ((b->ppc_trans_pos-1) << 2);     new_ia = b->start_ia + (b->ppc_trans_pos << 2);
1383     new_ia += sign_extend(offset << 2,26);     new_ia += sign_extend(offset << 2,26);
1384    
1385     /* set the return address */     /* set the return address */
1386     ppc32_set_lr(b,b->start_ia + (b->ppc_trans_pos << 2));     ppc32_set_lr(iop,b->start_ia + ((b->ppc_trans_pos+1) << 2));
1387       ppc32_set_jump(cpu,b,iop,new_ia,TRUE);
1388    
1389     ppc32_set_jump(cpu,b,new_ia,1);     ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
1390       ppc32_op_emit_branch_target(cpu,b,new_ia);
1391       ppc32_op_emit_branch_target(cpu,b,b->start_ia+((b->ppc_trans_pos+1) << 2));
1392     return(0);     return(0);
1393  }  }
1394    
# Line 917  DECLARE_INSN(BL) Line 1396  DECLARE_INSN(BL)
1396  DECLARE_INSN(BLA)  DECLARE_INSN(BLA)
1397  {  {
1398     m_uint32_t offset = bits(insn,2,25);     m_uint32_t offset = bits(insn,2,25);
1399     m_uint64_t new_ia;     m_uint32_t new_ia;
1400       jit_op_t *iop;
1401    
1402       iop = ppc32_op_emit_insn_output(cpu,4,"bla");
1403    
1404     /* compute the new ia */     /* compute the new ia */
1405     new_ia = sign_extend(offset << 2,26);     new_ia = sign_extend(offset << 2,26);
1406    
1407     /* set the return address */     /* set the return address */
1408     ppc32_set_lr(b,b->start_ia + (b->ppc_trans_pos << 2));     ppc32_set_lr(iop,b->start_ia + ((b->ppc_trans_pos+1) << 2));
1409       ppc32_set_jump(cpu,b,iop,new_ia,TRUE);
1410    
1411     ppc32_set_jump(cpu,b,new_ia,1);     ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
1412       ppc32_op_emit_branch_target(cpu,b,new_ia);
1413       ppc32_op_emit_branch_target(cpu,b,b->start_ia+((b->ppc_trans_pos+1) << 2));
1414     return(0);     return(0);
1415  }  }
1416    
# Line 935  DECLARE_INSN(BCC) Line 1420  DECLARE_INSN(BCC)
1420     int bo = bits(insn,21,25);     int bo = bits(insn,21,25);
1421     int bi = bits(insn,16,20);     int bi = bits(insn,16,20);
1422     int bd = bits(insn,2,15);     int bd = bits(insn,2,15);
1423       jit_op_t *iop;
1424     u_int cr_field,cr_bit;     u_int cr_field,cr_bit;
1425     m_uint32_t new_ia;     m_uint32_t new_ia;
1426     u_char *jump_ptr;     u_char *jump_ptr;
1427     int local_jump;     int local_jump;
1428     int cond;     int cond;
1429    
1430       ppc32_op_emit_basic_opcode(cpu,JIT_OP_BRANCH_JUMP);
1431    
1432       iop = ppc32_op_emit_insn_output(cpu,5,"bcc");
1433    
1434     /* Get the wanted value for the condition bit */     /* Get the wanted value for the condition bit */
1435     cond = (bo >> 3) & 0x1;     cond = (bo >> 3) & 0x1;
1436    
1437     /* Set the return address */     /* Set the return address */
1438     if (insn & 1)     if (insn & 1) {
1439        ppc32_set_lr(b,b->start_ia + (b->ppc_trans_pos << 2));        ppc32_set_lr(iop,b->start_ia + ((b->ppc_trans_pos+1) << 2));
1440          ppc32_op_emit_branch_target(cpu,b,b->start_ia+((b->ppc_trans_pos+1)<<2));
1441       }
1442    
1443     /* Compute the new ia */     /* Compute the new ia */
1444     new_ia = sign_extend_32(bd << 2,16);     new_ia = sign_extend_32(bd << 2,16);
1445     if (!(insn & 0x02))     if (!(insn & 0x02))
1446        new_ia += b->start_ia + ((b->ppc_trans_pos-1) << 2);        new_ia += b->start_ia + (b->ppc_trans_pos << 2);
1447    
1448     /* Test the condition bit */     /* Test the condition bit */
1449     cr_field = ppc32_get_cr_field(bi);     cr_field = ppc32_get_cr_field(bi);
1450     cr_bit = ppc32_get_cr_bit(bi);     cr_bit = ppc32_get_cr_bit(bi);
1451    
1452     x86_test_membase_imm(b->jit_ptr,     ppc32_op_emit_require_flags(cpu,cr_field);
1453    
1454       x86_test_membase_imm(iop->ob_ptr,
1455                          X86_EDI,PPC32_CR_FIELD_OFFSET(cr_field),                          X86_EDI,PPC32_CR_FIELD_OFFSET(cr_field),
1456                          (1 << cr_bit));                          (1 << cr_bit));
1457    
# Line 968  DECLARE_INSN(BCC) Line 1462  DECLARE_INSN(BCC)
1462      * page or not.      * page or not.
1463      */      */
1464     if (local_jump) {     if (local_jump) {
1465        if (jump_ptr) {        ppc32_jit_tcb_record_patch(b,iop,iop->ob_ptr,new_ia);
1466           x86_branch(b->jit_ptr,(cond) ? X86_CC_NZ : X86_CC_Z,jump_ptr,FALSE);        x86_branch32(iop->ob_ptr,(cond) ? X86_CC_NZ : X86_CC_Z,0,FALSE);
       } else {  
          ppc32_jit_tcb_record_patch(b,b->jit_ptr,new_ia);  
          x86_branch32(b->jit_ptr,(cond) ? X86_CC_NZ : X86_CC_Z,0,FALSE);  
       }  
1467     } else {       } else {  
1468        jump_ptr = b->jit_ptr;        jump_ptr = iop->ob_ptr;
1469        x86_branch32(b->jit_ptr,(cond) ? X86_CC_Z : X86_CC_NZ,0,FALSE);        x86_branch32(iop->ob_ptr,(cond) ? X86_CC_Z : X86_CC_NZ,0,FALSE);
1470        ppc32_set_jump(cpu,b,new_ia,TRUE);        ppc32_set_jump(cpu,b,iop,new_ia,TRUE);
1471        x86_patch(jump_ptr,b->jit_ptr);        x86_patch(jump_ptr,iop->ob_ptr);
1472     }     }
1473    
1474       ppc32_op_emit_branch_target(cpu,b,new_ia);
1475     return(0);     return(0);
1476  }  }
1477    
# Line 990  DECLARE_INSN(BC) Line 1481  DECLARE_INSN(BC)
1481     int bo = bits(insn,21,25);     int bo = bits(insn,21,25);
1482     int bi = bits(insn,16,20);     int bi = bits(insn,16,20);
1483     int bd = bits(insn,2,15);     int bd = bits(insn,2,15);
1484       int hreg_t0,hreg_t1;
1485       jit_op_t *iop;
1486     u_int cr_field,cr_bit;     u_int cr_field,cr_bit;
1487     m_uint32_t new_ia;     m_uint32_t new_ia;
1488     u_char *jump_ptr;     u_char *jump_ptr;
1489     int local_jump;     int local_jump;
1490     int cond,ctr;     int cond,ctr;
1491    
1492       ppc32_op_emit_basic_opcode(cpu,JIT_OP_BRANCH_JUMP);
1493    
1494       iop = ppc32_op_emit_insn_output(cpu,5,"bc");
1495    
1496       ppc32_jit_start_hreg_seq(cpu,"bc");
1497       hreg_t0 = ppc32_jit_alloc_hreg(cpu,-1);
1498       hreg_t1 = ppc32_jit_get_tmp_hreg(cpu);
1499    
1500       ppc32_op_emit_alter_host_reg(cpu,hreg_t0);
1501    
1502     /* Get the wanted value for the condition bit and CTR value */     /* Get the wanted value for the condition bit and CTR value */
1503     cond = (bo >> 3) & 0x1;     cond = (bo >> 3) & 0x1;
1504     ctr  = (bo >> 1) & 0x1;     ctr  = (bo >> 1) & 0x1;
1505    
1506     /* Set the return address */     /* Set the return address */
1507     if (insn & 1)     if (insn & 1) {
1508        ppc32_set_lr(b,b->start_ia + (b->ppc_trans_pos << 2));        ppc32_set_lr(iop,b->start_ia + ((b->ppc_trans_pos+1) << 2));
1509          ppc32_op_emit_branch_target(cpu,b,b->start_ia+((b->ppc_trans_pos+1)<<2));
1510       }
1511    
1512     /* Compute the new ia */     /* Compute the new ia */
1513     new_ia = sign_extend_32(bd << 2,16);     new_ia = sign_extend_32(bd << 2,16);
1514     if (!(insn & 0x02))     if (!(insn & 0x02))
1515        new_ia += b->start_ia + ((b->ppc_trans_pos-1) << 2);        new_ia += b->start_ia + (b->ppc_trans_pos << 2);
1516    
1517     x86_mov_reg_imm(b->jit_ptr,X86_EAX,1);     x86_mov_reg_imm(iop->ob_ptr,hreg_t0,1);
1518    
1519     /* Decrement the count register */     /* Decrement the count register */
1520     if (!(bo & 0x04)) {     if (!(bo & 0x04)) {
1521        x86_dec_membase(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,ctr));        x86_dec_membase(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,ctr));
1522        x86_set_reg(b->jit_ptr,(ctr) ? X86_CC_Z : X86_CC_NZ,X86_EBX,FALSE);        x86_set_reg(iop->ob_ptr,(ctr) ? X86_CC_Z : X86_CC_NZ,hreg_t1,FALSE);
1523        x86_alu_reg_reg(b->jit_ptr,X86_AND,X86_EAX,X86_EBX);        x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_t0,hreg_t1);
1524     }     }
1525    
1526     /* Test the condition bit */     /* Test the condition bit */
# Line 1023  DECLARE_INSN(BC) Line 1528  DECLARE_INSN(BC)
1528        cr_field = ppc32_get_cr_field(bi);        cr_field = ppc32_get_cr_field(bi);
1529        cr_bit = ppc32_get_cr_bit(bi);        cr_bit = ppc32_get_cr_bit(bi);
1530    
1531        x86_test_membase_imm(b->jit_ptr,        ppc32_op_emit_require_flags(cpu,cr_field);
1532    
1533          x86_test_membase_imm(iop->ob_ptr,
1534                             X86_EDI,PPC32_CR_FIELD_OFFSET(cr_field),                             X86_EDI,PPC32_CR_FIELD_OFFSET(cr_field),
1535                             (1 << cr_bit));                             (1 << cr_bit));
1536    
1537        x86_set_reg(b->jit_ptr,(cond) ? X86_CC_NZ : X86_CC_Z,X86_ECX,FALSE);        x86_set_reg(iop->ob_ptr,(cond) ? X86_CC_NZ : X86_CC_Z,hreg_t1,FALSE);
1538        x86_alu_reg_reg(b->jit_ptr,X86_AND,X86_EAX,X86_ECX);        x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_t0,hreg_t1);
1539     }     }
1540    
1541     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EAX,0x01);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x01);
1542    
1543     local_jump = ppc32_jit_tcb_local_addr(b,new_ia,&jump_ptr);     local_jump = ppc32_jit_tcb_local_addr(b,new_ia,&jump_ptr);
1544    
# Line 1040  DECLARE_INSN(BC) Line 1547  DECLARE_INSN(BC)
1547      * page or not.      * page or not.
1548      */      */
1549     if (local_jump) {     if (local_jump) {
1550        if (jump_ptr) {        ppc32_jit_tcb_record_patch(b,iop,iop->ob_ptr,new_ia);
1551           x86_branch(b->jit_ptr,X86_CC_NZ,jump_ptr,FALSE);        x86_branch32(iop->ob_ptr,X86_CC_NZ,0,FALSE);
       } else {  
          ppc32_jit_tcb_record_patch(b,b->jit_ptr,new_ia);  
          x86_branch32(b->jit_ptr,X86_CC_NZ,0,FALSE);  
       }  
1552     } else {       } else {  
1553        jump_ptr = b->jit_ptr;        jump_ptr = iop->ob_ptr;
1554        x86_branch32(b->jit_ptr,X86_CC_Z,0,FALSE);        x86_branch32(iop->ob_ptr,X86_CC_Z,0,FALSE);
1555        ppc32_set_jump(cpu,b,new_ia,TRUE);        ppc32_set_jump(cpu,b,iop,new_ia,TRUE);
1556        x86_patch(jump_ptr,b->jit_ptr);        x86_patch(jump_ptr,iop->ob_ptr);
1557     }     }
1558    
1559       ppc32_op_emit_branch_target(cpu,b,new_ia);
1560    
1561       ppc32_jit_close_hreg_seq(cpu);
1562     return(0);     return(0);
1563  }  }
1564    
# Line 1062  DECLARE_INSN(BCLR) Line 1568  DECLARE_INSN(BCLR)
1568     int bo = bits(insn,21,25);     int bo = bits(insn,21,25);
1569     int bi = bits(insn,16,20);     int bi = bits(insn,16,20);
1570     int bd = bits(insn,2,15);     int bd = bits(insn,2,15);
1571       int hreg_t0,hreg_t1;
1572       jit_op_t *iop;
1573     u_int cr_field,cr_bit;     u_int cr_field,cr_bit;
1574     m_uint32_t new_ia;     m_uint32_t new_ia;
1575     u_char *jump_ptr;     u_char *jump_ptr;
1576     int cond,ctr;     int cond,ctr;
1577    
1578       ppc32_jit_start_hreg_seq(cpu,"bclr");
1579       hreg_t0 = ppc32_jit_alloc_hreg(cpu,-1);
1580       hreg_t1 = ppc32_jit_get_tmp_hreg(cpu);
1581    
1582       ppc32_op_emit_alter_host_reg(cpu,hreg_t0);
1583    
1584       iop = ppc32_op_emit_insn_output(cpu,5,"bclr");
1585    
1586     /* Get the wanted value for the condition bit and CTR value */     /* Get the wanted value for the condition bit and CTR value */
1587     cond = (bo >> 3) & 0x1;     cond = (bo >> 3) & 0x1;
1588     ctr  = (bo >> 1) & 0x1;     ctr  = (bo >> 1) & 0x1;
# Line 1074  DECLARE_INSN(BCLR) Line 1590  DECLARE_INSN(BCLR)
1590     /* Compute the new ia */     /* Compute the new ia */
1591     new_ia = sign_extend_32(bd << 2,16);     new_ia = sign_extend_32(bd << 2,16);
1592     if (!(insn & 0x02))     if (!(insn & 0x02))
1593        new_ia += b->start_ia + ((b->ppc_trans_pos-1) << 2);        new_ia += b->start_ia + (b->ppc_trans_pos << 2);
1594    
1595     ppc32_load_imm(b,X86_EAX,1);     x86_mov_reg_imm(iop->ob_ptr,hreg_t0,1);
1596    
1597     /* Decrement the count register */     /* Decrement the count register */
1598     if (!(bo & 0x04)) {     if (!(bo & 0x04)) {
1599        x86_dec_membase(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,ctr));        x86_dec_membase(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,ctr));
1600        x86_set_reg(b->jit_ptr,(ctr) ? X86_CC_Z : X86_CC_NZ,X86_EBX,FALSE);        x86_set_reg(iop->ob_ptr,(ctr) ? X86_CC_Z : X86_CC_NZ,hreg_t1,FALSE);
1601        x86_alu_reg_reg(b->jit_ptr,X86_AND,X86_EAX,X86_EBX);        x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_t0,hreg_t1);
1602     }     }
1603    
1604     /* Test the condition bit */     /* Test the condition bit */
# Line 1090  DECLARE_INSN(BCLR) Line 1606  DECLARE_INSN(BCLR)
1606        cr_field = ppc32_get_cr_field(bi);        cr_field = ppc32_get_cr_field(bi);
1607        cr_bit = ppc32_get_cr_bit(bi);        cr_bit = ppc32_get_cr_bit(bi);
1608    
1609        x86_test_membase_imm(b->jit_ptr,        ppc32_op_emit_require_flags(cpu,cr_field);
1610    
1611          x86_test_membase_imm(iop->ob_ptr,
1612                             X86_EDI,PPC32_CR_FIELD_OFFSET(cr_field),                             X86_EDI,PPC32_CR_FIELD_OFFSET(cr_field),
1613                             (1 << cr_bit));                             (1 << cr_bit));
1614    
1615        x86_set_reg(b->jit_ptr,(cond) ? X86_CC_NZ : X86_CC_Z,X86_ECX,FALSE);        x86_set_reg(iop->ob_ptr,(cond) ? X86_CC_NZ : X86_CC_Z,hreg_t1,FALSE);
1616        x86_alu_reg_reg(b->jit_ptr,X86_AND,X86_EAX,X86_ECX);        x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_t0,hreg_t1);
1617     }     }
1618    
1619     /* Set the return address */     /* Set the return address */
1620     x86_mov_reg_membase(b->jit_ptr,X86_EDX,X86_EDI,OFFSET(cpu_ppc_t,lr),4);     x86_mov_reg_membase(iop->ob_ptr,hreg_t1,X86_EDI,OFFSET(cpu_ppc_t,lr),4);
1621    
1622     if (insn & 1)     if (insn & 1) {
1623        ppc32_set_lr(b,b->start_ia + (b->ppc_trans_pos << 2));        ppc32_set_lr(iop,b->start_ia + ((b->ppc_trans_pos+1) << 2));
1624          ppc32_op_emit_branch_target(cpu,b,b->start_ia+((b->ppc_trans_pos+1)<<2));
1625       }
1626    
1627     /* Branching */     /* Branching */
1628     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EAX,0x01);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x01);
1629    
1630       jump_ptr = iop->ob_ptr;
1631       x86_branch32(iop->ob_ptr,X86_CC_Z,0,FALSE);
1632    
1633       x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t1,0xFFFFFFFC);
1634       x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,ia),hreg_t1,4);
1635       ppc32_jit_tcb_push_epilog(&iop->ob_ptr);
1636    
1637     jump_ptr = b->jit_ptr;     x86_patch(jump_ptr,iop->ob_ptr);
    x86_branch32(b->jit_ptr,X86_CC_Z,0,FALSE);  
1638    
1639     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EDX,0xFFFFFFFC);     ppc32_op_emit_basic_opcode(cpu,JIT_OP_EOB);
    x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,ia),X86_EDX,4);  
    ppc32_jit_tcb_push_epilog(b);  
1640    
1641     x86_patch(jump_ptr,b->jit_ptr);     ppc32_jit_close_hreg_seq(cpu);
1642     return(0);     return(0);
1643  }  }
1644    
# Line 1124  DECLARE_INSN(CMP) Line 1648  DECLARE_INSN(CMP)
1648     int rd = bits(insn,23,25);     int rd = bits(insn,23,25);
1649     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1650     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
1651       int hreg_ra,hreg_rb;
1652       jit_op_t *iop;
1653      
1654       ppc32_jit_start_hreg_seq(cpu,"cmp");
1655       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1656       hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
1657    
1658       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
1659       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
1660    
1661       iop = ppc32_op_emit_insn_output(cpu,1,"cmp");
1662    
1663     ppc32_load_gpr(b,X86_EBX,ra);     x86_alu_reg_reg(iop->ob_ptr,X86_CMP,hreg_ra,hreg_rb);
1664     ppc32_alu_gpr(b,X86_CMP,X86_EBX,rb);     ppc32_op_emit_update_flags(cpu,rd,TRUE);
1665     ppc32_update_cr(b,rd,TRUE);  
1666       ppc32_jit_close_hreg_seq(cpu);
1667     return(0);     return(0);
1668  }  }
1669    
# Line 1138  DECLARE_INSN(CMPI) Line 1674  DECLARE_INSN(CMPI)
1674     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1675     m_uint16_t imm = bits(insn,0,15);     m_uint16_t imm = bits(insn,0,15);
1676     m_uint32_t tmp = sign_extend_32(imm,16);     m_uint32_t tmp = sign_extend_32(imm,16);
1677       int hreg_ra;
1678       jit_op_t *iop;
1679    
1680       ppc32_jit_start_hreg_seq(cpu,"cmpi");
1681       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1682       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
1683    
1684     ppc32_load_imm(b,X86_EBX,tmp);     iop = ppc32_op_emit_insn_output(cpu,1,"cmpi");
    ppc32_load_gpr(b,X86_ESI,ra);  
    x86_alu_reg_reg(b->jit_ptr,X86_CMP,X86_ESI,X86_EBX);  
1685    
1686     ppc32_update_cr(b,rd,TRUE);     x86_alu_reg_imm(iop->ob_ptr,X86_CMP,hreg_ra,tmp);
1687       ppc32_op_emit_update_flags(cpu,rd,TRUE);
1688    
1689       ppc32_jit_close_hreg_seq(cpu);
1690     return(0);     return(0);
1691  }  }
1692    
# Line 1153  DECLARE_INSN(CMPL) Line 1696  DECLARE_INSN(CMPL)
1696     int rd = bits(insn,23,25);     int rd = bits(insn,23,25);
1697     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1698     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
1699       int hreg_ra,hreg_rb;
1700       jit_op_t *iop;
1701      
1702       ppc32_jit_start_hreg_seq(cpu,"cmpl");
1703       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1704       hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
1705    
1706       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
1707       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
1708    
1709       iop = ppc32_op_emit_insn_output(cpu,1,"cmpl");
1710    
1711     ppc32_load_gpr(b,X86_EAX,ra);     x86_alu_reg_reg(iop->ob_ptr,X86_CMP,hreg_ra,hreg_rb);
1712     ppc32_alu_gpr(b,X86_CMP,X86_EAX,rb);     ppc32_op_emit_update_flags(cpu,rd,FALSE);
1713     ppc32_update_cr(b,rd,FALSE);  
1714       ppc32_jit_close_hreg_seq(cpu);
1715     return(0);     return(0);
1716  }  }
1717    
# Line 1165  DECLARE_INSN(CMPLI) Line 1720  DECLARE_INSN(CMPLI)
1720  {  {
1721     int rd = bits(insn,23,25);     int rd = bits(insn,23,25);
1722     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
1723     m_uint16_t imm = bits(insn,0,15);     m_uint32_t imm = bits(insn,0,15);
1724       int hreg_ra;
1725       jit_op_t *iop;
1726    
1727       ppc32_jit_start_hreg_seq(cpu,"cmpli");
1728       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
1729       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
1730    
1731     ppc32_load_imm(b,X86_EBX,imm);     iop = ppc32_op_emit_insn_output(cpu,1,"cmpli");
    ppc32_load_gpr(b,X86_ESI,ra);  
    x86_alu_reg_reg(b->jit_ptr,X86_CMP,X86_ESI,X86_EBX);  
1732    
1733     ppc32_update_cr(b,rd,FALSE);     x86_alu_reg_imm(iop->ob_ptr,X86_CMP,hreg_ra,imm);
1734       ppc32_op_emit_update_flags(cpu,rd,FALSE);
1735    
1736       ppc32_jit_close_hreg_seq(cpu);
1737     return(0);     return(0);
1738  }  }
1739    
# Line 1181  DECLARE_INSN(CRAND) Line 1743  DECLARE_INSN(CRAND)
1743     int bd = bits(insn,21,25);     int bd = bits(insn,21,25);
1744     int bb = bits(insn,16,20);     int bb = bits(insn,16,20);
1745     int ba = bits(insn,11,15);     int ba = bits(insn,11,15);
1746       int hreg_t0;
1747       jit_op_t *iop;
1748    
1749       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
1750    
1751       ppc32_jit_start_hreg_seq(cpu,"crand");
1752       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
1753       ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
1754    
1755       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(ba));
1756       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bb));
1757       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bd));
1758    
1759       iop = ppc32_op_emit_insn_output(cpu,3,"crand");
1760    
1761     /* test $ba bit */     /* test $ba bit */
1762     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
1763                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),
1764                          (1 << ppc32_get_cr_bit(ba)));                          (1 << ppc32_get_cr_bit(ba)));
1765     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EAX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,X86_EDX,FALSE);
1766    
1767     /* test $bb bit */     /* test $bb bit */
1768     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
1769                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),
1770                          (1 << ppc32_get_cr_bit(bb)));                          (1 << ppc32_get_cr_bit(bb)));
1771     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EBX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,hreg_t0,FALSE);
1772        
1773     /* result of AND between $ba and $bb */     /* result of AND between $ba and $bb */
1774     x86_alu_reg_reg(b->jit_ptr,X86_AND,X86_EBX,X86_EAX);     x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_t0,X86_EDX);
1775     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,0x01);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x01);
1776        
1777     /* set/clear $bd bit depending on the result */     /* set/clear $bd bit depending on the result */
1778     x86_alu_membase_imm(b->jit_ptr,X86_AND,     x86_alu_membase_imm(iop->ob_ptr,X86_AND,
1779                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
1780                         ~(1 << ppc32_get_cr_bit(bd)));                         ~(1 << ppc32_get_cr_bit(bd)));
1781    
1782     x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EBX,ppc32_get_cr_bit(bd));     x86_shift_reg_imm(iop->ob_ptr,X86_SHL,hreg_t0,ppc32_get_cr_bit(bd));
1783     x86_alu_membase_reg(b->jit_ptr,X86_OR,     x86_alu_membase_reg(iop->ob_ptr,X86_OR,
1784                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
1785                         X86_EBX);                         hreg_t0);
1786    
1787       ppc32_jit_close_hreg_seq(cpu);
1788     return(0);     return(0);
1789  }  }
1790    
# Line 1216  DECLARE_INSN(CRANDC) Line 1794  DECLARE_INSN(CRANDC)
1794     int bd = bits(insn,21,25);     int bd = bits(insn,21,25);
1795     int bb = bits(insn,16,20);     int bb = bits(insn,16,20);
1796     int ba = bits(insn,11,15);     int ba = bits(insn,11,15);
1797       int hreg_t0;
1798       jit_op_t *iop;
1799    
1800       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
1801    
1802       ppc32_jit_start_hreg_seq(cpu,"crandc");
1803       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
1804       ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
1805    
1806       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(ba));
1807       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bb));
1808       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bd));
1809    
1810       iop = ppc32_op_emit_insn_output(cpu,3,"crandc");
1811    
1812     /* test $ba bit */     /* test $ba bit */
1813     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
1814                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),
1815                          (1 << ppc32_get_cr_bit(ba)));                          (1 << ppc32_get_cr_bit(ba)));
1816     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EAX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,X86_EDX,FALSE);
1817    
1818     /* test $bb bit */     /* test $bb bit */
1819     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
1820                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),
1821                          (1 << ppc32_get_cr_bit(bb)));                          (1 << ppc32_get_cr_bit(bb)));
1822     x86_set_reg(b->jit_ptr,X86_CC_Z,X86_EBX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_Z,hreg_t0,FALSE);
1823        
1824     /* result of AND between $ba and $bb */     /* result of AND between $ba and $bb */
1825     x86_alu_reg_reg(b->jit_ptr,X86_AND,X86_EBX,X86_EAX);     x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_t0,X86_EDX);
1826     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,0x01);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x01);
1827        
1828     /* set/clear $bd bit depending on the result */     /* set/clear $bd bit depending on the result */
1829     x86_alu_membase_imm(b->jit_ptr,X86_AND,     x86_alu_membase_imm(iop->ob_ptr,X86_AND,
1830                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
1831                         ~(1 << ppc32_get_cr_bit(bd)));                         ~(1 << ppc32_get_cr_bit(bd)));
1832    
1833     x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EBX,ppc32_get_cr_bit(bd));     x86_shift_reg_imm(iop->ob_ptr,X86_SHL,hreg_t0,ppc32_get_cr_bit(bd));
1834     x86_alu_membase_reg(b->jit_ptr,X86_OR,     x86_alu_membase_reg(iop->ob_ptr,X86_OR,
1835                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
1836                         X86_EBX);                         hreg_t0);
1837    
1838       ppc32_jit_close_hreg_seq(cpu);
1839     return(0);     return(0);
1840  }  }
1841    
# Line 1251  DECLARE_INSN(CREQV) Line 1845  DECLARE_INSN(CREQV)
1845     int bd = bits(insn,21,25);     int bd = bits(insn,21,25);
1846     int bb = bits(insn,16,20);     int bb = bits(insn,16,20);
1847     int ba = bits(insn,11,15);     int ba = bits(insn,11,15);
1848       int hreg_t0;
1849       jit_op_t *iop;
1850    
1851       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
1852    
1853       ppc32_jit_start_hreg_seq(cpu,"creqv");
1854       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
1855       ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
1856    
1857       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(ba));
1858       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bb));
1859       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bd));
1860    
1861       iop = ppc32_op_emit_insn_output(cpu,3,"creqv");
1862    
1863     /* test $ba bit */     /* test $ba bit */
1864     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
1865                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),
1866                          (1 << ppc32_get_cr_bit(ba)));                          (1 << ppc32_get_cr_bit(ba)));
1867     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EAX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,X86_EDX,FALSE);
1868    
1869     /* test $bb bit */     /* test $bb bit */
1870     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
1871                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),
1872                          (1 << ppc32_get_cr_bit(bb)));                          (1 << ppc32_get_cr_bit(bb)));
1873     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EBX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,hreg_t0,FALSE);
1874        
1875     /* result of XOR between $ba and $bb */     /* result of XOR between $ba and $bb */
1876     x86_alu_reg_reg(b->jit_ptr,X86_XOR,X86_EBX,X86_EAX);     x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_t0,X86_EDX);
1877     x86_not_reg(b->jit_ptr,X86_EBX);     x86_not_reg(iop->ob_ptr,hreg_t0);
1878     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,0x01);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x01);
1879        
1880     /* set/clear $bd bit depending on the result */     /* set/clear $bd bit depending on the result */
1881     x86_alu_membase_imm(b->jit_ptr,X86_AND,     x86_alu_membase_imm(iop->ob_ptr,X86_AND,
1882                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
1883                         ~(1 << ppc32_get_cr_bit(bd)));                         ~(1 << ppc32_get_cr_bit(bd)));
1884    
1885     x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EBX,ppc32_get_cr_bit(bd));     x86_shift_reg_imm(iop->ob_ptr,X86_SHL,hreg_t0,ppc32_get_cr_bit(bd));
1886     x86_alu_membase_reg(b->jit_ptr,X86_OR,     x86_alu_membase_reg(iop->ob_ptr,X86_OR,
1887                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
1888                         X86_EBX);                         hreg_t0);
1889    
1890       ppc32_jit_close_hreg_seq(cpu);
1891     return(0);     return(0);
1892  }  }
1893    
# Line 1287  DECLARE_INSN(CRNAND) Line 1897  DECLARE_INSN(CRNAND)
1897     int bd = bits(insn,21,25);     int bd = bits(insn,21,25);
1898     int bb = bits(insn,16,20);     int bb = bits(insn,16,20);
1899     int ba = bits(insn,11,15);     int ba = bits(insn,11,15);
1900       int hreg_t0;
1901       jit_op_t *iop;
1902    
1903       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
1904    
1905       ppc32_jit_start_hreg_seq(cpu,"crnand");
1906       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
1907       ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
1908    
1909       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(ba));
1910       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bb));
1911       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bd));
1912    
1913       iop = ppc32_op_emit_insn_output(cpu,3,"crnand");
1914    
1915     /* test $ba bit */     /* test $ba bit */
1916     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
1917                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),
1918                          (1 << ppc32_get_cr_bit(ba)));                          (1 << ppc32_get_cr_bit(ba)));
1919     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EAX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,X86_EDX,FALSE);
1920    
1921     /* test $bb bit */     /* test $bb bit */
1922     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
1923                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),
1924                          (1 << ppc32_get_cr_bit(bb)));                          (1 << ppc32_get_cr_bit(bb)));
1925     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EBX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,hreg_t0,FALSE);
1926        
1927     /* result of NAND between $ba and $bb */     /* result of NAND between $ba and $bb */
1928     x86_alu_reg_reg(b->jit_ptr,X86_AND,X86_EBX,X86_EAX);     x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_t0,X86_EDX);
1929     x86_not_reg(b->jit_ptr,X86_EBX);     x86_not_reg(iop->ob_ptr,hreg_t0);
1930     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,0x01);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x01);
1931        
1932     /* set/clear $bd bit depending on the result */     /* set/clear $bd bit depending on the result */
1933     x86_alu_membase_imm(b->jit_ptr,X86_AND,     x86_alu_membase_imm(iop->ob_ptr,X86_AND,
1934                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
1935                         ~(1 << ppc32_get_cr_bit(bd)));                         ~(1 << ppc32_get_cr_bit(bd)));
1936    
1937     x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EBX,ppc32_get_cr_bit(bd));     x86_shift_reg_imm(iop->ob_ptr,X86_SHL,hreg_t0,ppc32_get_cr_bit(bd));
1938     x86_alu_membase_reg(b->jit_ptr,X86_OR,     x86_alu_membase_reg(iop->ob_ptr,X86_OR,
1939                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
1940                         X86_EBX);                         hreg_t0);
1941    
1942       ppc32_jit_close_hreg_seq(cpu);
1943     return(0);     return(0);
1944  }  }
1945    
# Line 1323  DECLARE_INSN(CRNOR) Line 1949  DECLARE_INSN(CRNOR)
1949     int bd = bits(insn,21,25);     int bd = bits(insn,21,25);
1950     int bb = bits(insn,16,20);     int bb = bits(insn,16,20);
1951     int ba = bits(insn,11,15);     int ba = bits(insn,11,15);
1952       int hreg_t0;
1953       jit_op_t *iop;
1954    
1955       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
1956    
1957       ppc32_jit_start_hreg_seq(cpu,"crnor");
1958       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
1959       ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
1960    
1961       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(ba));
1962       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bb));
1963       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bd));
1964    
1965       iop = ppc32_op_emit_insn_output(cpu,3,"crnor");
1966    
1967     /* test $ba bit */     /* test $ba bit */
1968     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
1969                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),
1970                          (1 << ppc32_get_cr_bit(ba)));                          (1 << ppc32_get_cr_bit(ba)));
1971     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EAX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,X86_EDX,FALSE);
1972    
1973     /* test $bb bit */     /* test $bb bit */
1974     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
1975                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),
1976                          (1 << ppc32_get_cr_bit(bb)));                          (1 << ppc32_get_cr_bit(bb)));
1977     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EBX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,hreg_t0,FALSE);
1978        
1979     /* result of NOR between $ba and $bb */     /* result of NOR between $ba and $bb */
1980     x86_alu_reg_reg(b->jit_ptr,X86_OR,X86_EBX,X86_EAX);     x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_t0,X86_EDX);
1981     x86_not_reg(b->jit_ptr,X86_EBX);     x86_not_reg(iop->ob_ptr,hreg_t0);
1982     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,0x01);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x01);
1983        
1984     /* set/clear $bd bit depending on the result */     /* set/clear $bd bit depending on the result */
1985     x86_alu_membase_imm(b->jit_ptr,X86_AND,     x86_alu_membase_imm(iop->ob_ptr,X86_AND,
1986                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
1987                         ~(1 << ppc32_get_cr_bit(bd)));                         ~(1 << ppc32_get_cr_bit(bd)));
1988    
1989     x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EBX,ppc32_get_cr_bit(bd));     x86_shift_reg_imm(iop->ob_ptr,X86_SHL,hreg_t0,ppc32_get_cr_bit(bd));
1990     x86_alu_membase_reg(b->jit_ptr,X86_OR,     x86_alu_membase_reg(iop->ob_ptr,X86_OR,
1991                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
1992                         X86_EBX);                         hreg_t0);
1993    
1994       ppc32_jit_close_hreg_seq(cpu);
1995     return(0);     return(0);
1996  }  }
1997    
# Line 1359  DECLARE_INSN(CROR) Line 2001  DECLARE_INSN(CROR)
2001     int bd = bits(insn,21,25);     int bd = bits(insn,21,25);
2002     int bb = bits(insn,16,20);     int bb = bits(insn,16,20);
2003     int ba = bits(insn,11,15);     int ba = bits(insn,11,15);
2004       int hreg_t0;
2005       jit_op_t *iop;
2006    
2007       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
2008    
2009       ppc32_jit_start_hreg_seq(cpu,"cror");
2010       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
2011       ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
2012    
2013       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(ba));
2014       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bb));
2015       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bd));
2016    
2017       iop = ppc32_op_emit_insn_output(cpu,3,"cror");
2018    
2019     /* test $ba bit */     /* test $ba bit */
2020     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
2021                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),
2022                          (1 << ppc32_get_cr_bit(ba)));                          (1 << ppc32_get_cr_bit(ba)));
2023     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EAX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,X86_EDX,FALSE);
2024    
2025     /* test $bb bit */     /* test $bb bit */
2026     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
2027                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),
2028                          (1 << ppc32_get_cr_bit(bb)));                          (1 << ppc32_get_cr_bit(bb)));
2029     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EBX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,hreg_t0,FALSE);
2030        
2031     /* result of OR between $ba and $bb */     /* result of OR between $ba and $bb */
2032     x86_alu_reg_reg(b->jit_ptr,X86_OR,X86_EBX,X86_EAX);     x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_t0,X86_EDX);
2033     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,0x01);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x01);
2034        
2035     /* set/clear $bd bit depending on the result */     /* set/clear $bd bit depending on the result */
2036     x86_alu_membase_imm(b->jit_ptr,X86_AND,     x86_alu_membase_imm(iop->ob_ptr,X86_AND,
2037                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
2038                         ~(1 << ppc32_get_cr_bit(bd)));                         ~(1 << ppc32_get_cr_bit(bd)));
2039    
2040     x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EBX,ppc32_get_cr_bit(bd));     x86_shift_reg_imm(iop->ob_ptr,X86_SHL,hreg_t0,ppc32_get_cr_bit(bd));
2041     x86_alu_membase_reg(b->jit_ptr,X86_OR,     x86_alu_membase_reg(iop->ob_ptr,X86_OR,
2042                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
2043                         X86_EBX);                         hreg_t0);
2044    
2045       ppc32_jit_close_hreg_seq(cpu);
2046     return(0);     return(0);
2047  }  }
2048    
# Line 1394  DECLARE_INSN(CRORC) Line 2052  DECLARE_INSN(CRORC)
2052     int bd = bits(insn,21,25);     int bd = bits(insn,21,25);
2053     int bb = bits(insn,16,20);     int bb = bits(insn,16,20);
2054     int ba = bits(insn,11,15);     int ba = bits(insn,11,15);
2055       int hreg_t0;
2056       jit_op_t *iop;
2057    
2058       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
2059    
2060       ppc32_jit_start_hreg_seq(cpu,"crorc");
2061       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
2062       ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
2063    
2064       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(ba));
2065       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bb));
2066       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bd));
2067    
2068       iop = ppc32_op_emit_insn_output(cpu,3,"crorc");
2069    
2070     /* test $ba bit */     /* test $ba bit */
2071     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
2072                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),
2073                          (1 << ppc32_get_cr_bit(ba)));                          (1 << ppc32_get_cr_bit(ba)));
2074     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EAX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,X86_EDX,FALSE);
2075    
2076     /* test $bb bit */     /* test $bb bit */
2077     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
2078                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),
2079                          (1 << ppc32_get_cr_bit(bb)));                          (1 << ppc32_get_cr_bit(bb)));
2080     x86_set_reg(b->jit_ptr,X86_CC_Z,X86_EBX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_Z,hreg_t0,FALSE);
2081        
2082     /* result of ORC between $ba and $bb */     /* result of ORC between $ba and $bb */
2083     x86_alu_reg_reg(b->jit_ptr,X86_OR,X86_EBX,X86_EAX);     x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_t0,X86_EDX);
2084     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,0x01);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x01);
2085        
2086     /* set/clear $bd bit depending on the result */     /* set/clear $bd bit depending on the result */
2087     x86_alu_membase_imm(b->jit_ptr,X86_AND,     x86_alu_membase_imm(iop->ob_ptr,X86_AND,
2088                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
2089                         ~(1 << ppc32_get_cr_bit(bd)));                         ~(1 << ppc32_get_cr_bit(bd)));
2090    
2091     x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EBX,ppc32_get_cr_bit(bd));     x86_shift_reg_imm(iop->ob_ptr,X86_SHL,hreg_t0,ppc32_get_cr_bit(bd));
2092     x86_alu_membase_reg(b->jit_ptr,X86_OR,     x86_alu_membase_reg(iop->ob_ptr,X86_OR,
2093                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
2094                         X86_EBX);                         hreg_t0);
2095    
2096       ppc32_jit_close_hreg_seq(cpu);
2097     return(0);     return(0);
2098  }  }
2099    
# Line 1429  DECLARE_INSN(CRXOR) Line 2103  DECLARE_INSN(CRXOR)
2103     int bd = bits(insn,21,25);     int bd = bits(insn,21,25);
2104     int bb = bits(insn,16,20);     int bb = bits(insn,16,20);
2105     int ba = bits(insn,11,15);     int ba = bits(insn,11,15);
2106       int hreg_t0;
2107       jit_op_t *iop;
2108    
2109       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
2110    
2111       ppc32_jit_start_hreg_seq(cpu,"crxor");
2112       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
2113       ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
2114    
2115       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(ba));
2116       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bb));
2117       ppc32_op_emit_require_flags(cpu,ppc32_get_cr_field(bd));
2118    
2119       iop = ppc32_op_emit_insn_output(cpu,3,"crxor");
2120    
2121     /* test $ba bit */     /* test $ba bit */
2122     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
2123                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(ba)),
2124                          (1 << ppc32_get_cr_bit(ba)));                          (1 << ppc32_get_cr_bit(ba)));
2125     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EAX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,X86_EDX,FALSE);
2126    
2127     /* test $bb bit */     /* test $bb bit */
2128     x86_test_membase_imm(b->jit_ptr,     x86_test_membase_imm(iop->ob_ptr,
2129                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),                          X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bb)),
2130                          (1 << ppc32_get_cr_bit(bb)));                          (1 << ppc32_get_cr_bit(bb)));
2131     x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_EBX,FALSE);     x86_set_reg(iop->ob_ptr,X86_CC_NZ,hreg_t0,FALSE);
2132        
2133     /* result of XOR between $ba and $bb */     /* result of XOR between $ba and $bb */
2134     x86_alu_reg_reg(b->jit_ptr,X86_XOR,X86_EBX,X86_EAX);     x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_t0,X86_EDX);
2135     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,0x01);     x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x01);
2136        
2137     /* set/clear $bd bit depending on the result */     /* set/clear $bd bit depending on the result */
2138     x86_alu_membase_imm(b->jit_ptr,X86_AND,     x86_alu_membase_imm(iop->ob_ptr,X86_AND,
2139                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
2140                         ~(1 << ppc32_get_cr_bit(bd)));                         ~(1 << ppc32_get_cr_bit(bd)));
2141    
2142     x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EBX,ppc32_get_cr_bit(bd));     x86_shift_reg_imm(iop->ob_ptr,X86_SHL,hreg_t0,ppc32_get_cr_bit(bd));
2143     x86_alu_membase_reg(b->jit_ptr,X86_OR,     x86_alu_membase_reg(iop->ob_ptr,X86_OR,
2144                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),                         X86_EDI,PPC32_CR_FIELD_OFFSET(ppc32_get_cr_field(bd)),
2145                         X86_EBX);                         hreg_t0);
2146    
2147       ppc32_jit_close_hreg_seq(cpu);
2148     return(0);     return(0);
2149  }  }
2150    
# Line 1464  DECLARE_INSN(DIVWU) Line 2154  DECLARE_INSN(DIVWU)
2154     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
2155     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2156     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2157       int hreg_rb;
2158       jit_op_t *iop;
2159    
2160     ppc32_load_gpr(b,X86_EAX,ra);     ppc32_jit_start_hreg_seq(cpu,"divwu");
2161     ppc32_load_gpr(b,X86_EBX,rb);     ppc32_jit_alloc_hreg_forced(cpu,X86_EAX);
2162     ppc32_load_imm(b,X86_EDX,0);     ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
2163       hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
2164    
2165       /* $rd = $ra / $rb */
2166       ppc32_op_emit_load_gpr(cpu,X86_EAX,ra);
2167       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
2168    
2169     x86_div_reg(b->jit_ptr,X86_EBX,0);     iop = ppc32_op_emit_insn_output(cpu,2,"divwu");
2170     ppc32_store_gpr(b,rd,X86_EAX);     ppc32_load_imm(&iop->ob_ptr,X86_EDX,0);
2171    
2172     if (insn & 1) {     x86_div_reg(iop->ob_ptr,hreg_rb,0);
2173        x86_test_reg_reg(b->jit_ptr,X86_EAX,X86_EAX);  
2174        ppc32_update_cr0(b);     if (insn & 1)
2175     }        x86_test_reg_reg(iop->ob_ptr,X86_EAX,X86_EAX);
2176      
2177       ppc32_op_emit_store_gpr(cpu,rd,X86_EAX);
2178    
2179       if (insn & 1)
2180          ppc32_op_emit_update_flags(cpu,0,TRUE);
2181    
2182       /* edx:eax are directly modified: throw them */
2183       ppc32_op_emit_alter_host_reg(cpu,X86_EAX);
2184       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
2185    
2186       ppc32_jit_close_hreg_seq(cpu);
2187     return(0);     return(0);
2188  }  }
2189    
# Line 1486  DECLARE_INSN(EQV) Line 2193  DECLARE_INSN(EQV)
2193     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
2194     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2195     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2196       int hreg_rs,hreg_ra,hreg_rb;
2197       jit_op_t *iop;
2198    
2199     /* $ra = ~($rs ^ $rb) */     /* $ra = ~($rs ^ $rb) */
2200     ppc32_load_gpr(b,X86_EBX,rs);     ppc32_jit_start_hreg_seq(cpu,"eqv");
2201     ppc32_alu_gpr(b,X86_XOR,X86_EBX,rb);     hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
2202     x86_not_reg(b->jit_ptr,X86_EBX);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
2203     ppc32_store_gpr(b,ra,X86_EBX);     hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
2204    
2205     if (insn & 1) {     ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
2206        x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);     ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
2207        ppc32_update_cr0(b);  
2208       iop = ppc32_op_emit_insn_output(cpu,1,"eqv");
2209    
2210       if (ra == rs)
2211          x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_ra,hreg_rb);
2212       else if (ra == rb)
2213          x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_ra,hreg_rs);
2214       else {
2215          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
2216          x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_ra,hreg_rb);
2217     }     }
2218    
2219       x86_not_reg(iop->ob_ptr,hreg_ra);
2220    
2221       if (insn & 1)
2222          x86_test_reg_reg(iop->ob_ptr,hreg_ra,hreg_ra);
2223    
2224       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
2225    
2226       if (insn & 1)
2227          ppc32_op_emit_update_flags(cpu,0,TRUE);
2228    
2229       ppc32_jit_close_hreg_seq(cpu);
2230     return(0);     return(0);
2231  }  }
2232    
# Line 1506  DECLARE_INSN(EXTSB) Line 2235  DECLARE_INSN(EXTSB)
2235  {    {  
2236     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
2237     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2238       int hreg_rs,hreg_ra;
2239       jit_op_t *iop;
2240    
2241     ppc32_load_gpr(b,X86_EBX,rs);     /* $ra = extsb($rs) */
2242     x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EBX,24);     ppc32_jit_start_hreg_seq(cpu,"extsb");
2243     x86_shift_reg_imm(b->jit_ptr,X86_SAR,X86_EBX,24);     hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
2244     ppc32_store_gpr(b,ra,X86_EBX);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
2245    
2246     if (insn & 1) {     ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
2247        x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);  
2248        ppc32_update_cr0(b);     iop = ppc32_op_emit_insn_output(cpu,2,"extsb");
2249     }  
2250       if (rs != ra)
2251          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
2252    
2253       x86_shift_reg_imm(iop->ob_ptr,X86_SHL,hreg_ra,24);
2254       x86_shift_reg_imm(iop->ob_ptr,X86_SAR,hreg_ra,24);
2255    
2256       if (insn & 1)
2257          x86_test_reg_reg(iop->ob_ptr,hreg_ra,hreg_ra);
2258    
2259       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
2260    
2261       if (insn & 1)
2262          ppc32_op_emit_update_flags(cpu,0,TRUE);
2263    
2264       ppc32_jit_close_hreg_seq(cpu);
2265     return(0);     return(0);
2266  }  }
2267    
# Line 1525  DECLARE_INSN(EXTSH) Line 2270  DECLARE_INSN(EXTSH)
2270  {    {  
2271     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
2272     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2273       int hreg_rs,hreg_ra;
2274       jit_op_t *iop;
2275    
2276     ppc32_load_gpr(b,X86_EBX,rs);     /* $ra = extsh($rs) */
2277     x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EBX,16);     ppc32_jit_start_hreg_seq(cpu,"extsh");
2278     x86_shift_reg_imm(b->jit_ptr,X86_SAR,X86_EBX,16);     hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
2279     ppc32_store_gpr(b,ra,X86_EBX);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
2280    
2281     if (insn & 1) {     ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
2282        x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);  
2283        ppc32_update_cr0(b);     iop = ppc32_op_emit_insn_output(cpu,2,"extsh");
2284     }  
2285       if (rs != ra)
2286          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
2287    
2288       x86_shift_reg_imm(iop->ob_ptr,X86_SHL,hreg_ra,16);
2289       x86_shift_reg_imm(iop->ob_ptr,X86_SAR,hreg_ra,16);
2290    
2291       if (insn & 1)
2292          x86_test_reg_reg(iop->ob_ptr,hreg_ra,hreg_ra);
2293    
2294       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
2295    
2296       if (insn & 1)
2297          ppc32_op_emit_update_flags(cpu,0,TRUE);
2298    
2299       ppc32_jit_close_hreg_seq(cpu);
2300     return(0);     return(0);
2301  }  }
2302    
# Line 1546  DECLARE_INSN(LBZ) Line 2307  DECLARE_INSN(LBZ)
2307     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2308     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
2309    
2310     //ppc32_emit_memop(b,PPC_MEMOP_LBZ,ra,offset,rs,0);     //ppc32_emit_memop(cpu,b,PPC_MEMOP_LBZ,ra,offset,rs,0);
2311     ppc32_emit_memop_fast(b,0,PPC_MEMOP_LBZ,ra,offset,rs,ppc32_memop_fast_lbz);     ppc32_emit_memop_fast(cpu,b,0,PPC_MEMOP_LBZ,ra,offset,rs,
2312                             ppc32_memop_fast_lbz);
2313     return(0);     return(0);
2314  }  }
2315    
# Line 1558  DECLARE_INSN(LBZU) Line 2320  DECLARE_INSN(LBZU)
2320     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2321     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
2322    
2323     ppc32_emit_memop(b,PPC_MEMOP_LBZ,ra,offset,rs,1);     ppc32_emit_memop(cpu,b,PPC_MEMOP_LBZ,ra,offset,rs,1);
2324     return(0);     return(0);
2325  }  }
2326    
# Line 1569  DECLARE_INSN(LBZUX) Line 2331  DECLARE_INSN(LBZUX)
2331     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2332     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2333    
2334     ppc32_emit_memop_idx(b,PPC_MEMOP_LBZ,ra,rb,rs,1);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_LBZ,ra,rb,rs,1);
2335     return(0);     return(0);
2336  }  }
2337    
# Line 1580  DECLARE_INSN(LBZX) Line 2342  DECLARE_INSN(LBZX)
2342     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2343     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2344    
2345     ppc32_emit_memop_idx(b,PPC_MEMOP_LBZ,ra,rb,rs,0);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_LBZ,ra,rb,rs,0);
2346     return(0);     return(0);
2347  }  }
2348    
# Line 1591  DECLARE_INSN(LHA) Line 2353  DECLARE_INSN(LHA)
2353     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2354     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
2355    
2356     ppc32_emit_memop(b,PPC_MEMOP_LHA,ra,offset,rs,0);     ppc32_emit_memop(cpu,b,PPC_MEMOP_LHA,ra,offset,rs,0);
2357     return(0);     return(0);
2358  }  }
2359    
# Line 1602  DECLARE_INSN(LHAU) Line 2364  DECLARE_INSN(LHAU)
2364     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2365     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
2366    
2367     ppc32_emit_memop(b,PPC_MEMOP_LHA,ra,offset,rs,1);     ppc32_emit_memop(cpu,b,PPC_MEMOP_LHA,ra,offset,rs,1);
2368     return(0);     return(0);
2369  }  }
2370    
# Line 1613  DECLARE_INSN(LHAUX) Line 2375  DECLARE_INSN(LHAUX)
2375     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2376     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2377    
2378     ppc32_emit_memop_idx(b,PPC_MEMOP_LHA,ra,rb,rs,1);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_LHA,ra,rb,rs,1);
2379     return(0);     return(0);
2380  }  }
2381    
# Line 1624  DECLARE_INSN(LHAX) Line 2386  DECLARE_INSN(LHAX)
2386     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2387     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2388    
2389     ppc32_emit_memop_idx(b,PPC_MEMOP_LHA,ra,rb,rs,0);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_LHA,ra,rb,rs,0);
2390     return(0);     return(0);
2391  }  }
2392    
# Line 1635  DECLARE_INSN(LHZ) Line 2397  DECLARE_INSN(LHZ)
2397     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2398     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
2399    
2400     ppc32_emit_memop(b,PPC_MEMOP_LHZ,ra,offset,rs,0);     ppc32_emit_memop(cpu,b,PPC_MEMOP_LHZ,ra,offset,rs,0);
2401     return(0);     return(0);
2402  }  }
2403    
# Line 1646  DECLARE_INSN(LHZU) Line 2408  DECLARE_INSN(LHZU)
2408     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2409     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
2410    
2411     ppc32_emit_memop(b,PPC_MEMOP_LHZ,ra,offset,rs,1);     ppc32_emit_memop(cpu,b,PPC_MEMOP_LHZ,ra,offset,rs,1);
2412     return(0);     return(0);
2413  }  }
2414    
# Line 1657  DECLARE_INSN(LHZUX) Line 2419  DECLARE_INSN(LHZUX)
2419     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2420     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2421    
2422     ppc32_emit_memop_idx(b,PPC_MEMOP_LHZ,ra,rb,rs,1);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_LHZ,ra,rb,rs,1);
2423     return(0);     return(0);
2424  }  }
2425    
# Line 1668  DECLARE_INSN(LHZX) Line 2430  DECLARE_INSN(LHZX)
2430     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2431     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2432    
2433     ppc32_emit_memop_idx(b,PPC_MEMOP_LHZ,ra,rb,rs,0);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_LHZ,ra,rb,rs,0);
2434     return(0);     return(0);
2435  }  }
2436    
# Line 1680  DECLARE_INSN(LWZ) Line 2442  DECLARE_INSN(LWZ)
2442     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
2443    
2444     //ppc32_emit_memop(b,PPC_MEMOP_LWZ,ra,offset,rs,0);     //ppc32_emit_memop(b,PPC_MEMOP_LWZ,ra,offset,rs,0);
2445     ppc32_emit_memop_fast(b,0,PPC_MEMOP_LWZ,ra,offset,rs,ppc32_memop_fast_lwz);     ppc32_emit_memop_fast(cpu,b,0,PPC_MEMOP_LWZ,ra,offset,rs,
2446                             ppc32_memop_fast_lwz);
2447     return(0);     return(0);
2448  }  }
2449    
# Line 1691  DECLARE_INSN(LWZU) Line 2454  DECLARE_INSN(LWZU)
2454     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2455     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
2456    
2457     ppc32_emit_memop(b,PPC_MEMOP_LWZ,ra,offset,rs,1);     ppc32_emit_memop(cpu,b,PPC_MEMOP_LWZ,ra,offset,rs,1);
2458     return(0);     return(0);
2459  }  }
2460    
# Line 1702  DECLARE_INSN(LWZUX) Line 2465  DECLARE_INSN(LWZUX)
2465     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2466     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2467    
2468     ppc32_emit_memop_idx(b,PPC_MEMOP_LWZ,ra,rb,rs,1);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_LWZ,ra,rb,rs,1);
2469     return(0);     return(0);
2470  }  }
2471    
# Line 1713  DECLARE_INSN(LWZX) Line 2476  DECLARE_INSN(LWZX)
2476     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2477     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2478    
2479     ppc32_emit_memop_idx(b,PPC_MEMOP_LWZ,ra,rb,rs,0);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_LWZ,ra,rb,rs,0);
2480     return(0);     return(0);
2481  }  }
2482    
# Line 1722  DECLARE_INSN(MCRF) Line 2485  DECLARE_INSN(MCRF)
2485  {  {
2486     int rd = bits(insn,23,25);     int rd = bits(insn,23,25);
2487     int rs = bits(insn,18,20);     int rs = bits(insn,18,20);
2488       int hreg_t0;
2489       jit_op_t *iop;
2490    
2491       ppc32_jit_start_hreg_seq(cpu,"mcrf");
2492       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);  
2493       ppc32_op_emit_require_flags(cpu,rs);
2494    
2495       iop = ppc32_op_emit_insn_output(cpu,1,"mcrf");
2496    
2497     /* Load "rs" field in %edx */     /* Load "rs" field in %edx */
2498     x86_mov_reg_membase(b->jit_ptr,X86_EDX,X86_EDI,PPC32_CR_FIELD_OFFSET(rs),4);     x86_mov_reg_membase(iop->ob_ptr,hreg_t0,
2499                           X86_EDI,PPC32_CR_FIELD_OFFSET(rs),4);
2500    
2501     /* Store it in "rd" field */     /* Store it in "rd" field */
2502     x86_mov_membase_reg(b->jit_ptr,X86_EDI,PPC32_CR_FIELD_OFFSET(rd),X86_EDX,4);     x86_mov_membase_reg(iop->ob_ptr,X86_EDI,PPC32_CR_FIELD_OFFSET(rd),
2503                           hreg_t0,4);
2504    
2505       ppc32_jit_close_hreg_seq(cpu);
2506     return(0);     return(0);
2507  }  }
2508    
# Line 1735  DECLARE_INSN(MCRF) Line 2510  DECLARE_INSN(MCRF)
2510  DECLARE_INSN(MFCR)  DECLARE_INSN(MFCR)
2511  {  {
2512     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
2513       int hreg_rd,hreg_t0;
2514       jit_op_t *iop;
2515     int i;     int i;
2516    
2517     x86_alu_reg_reg(b->jit_ptr,X86_XOR,X86_EAX,X86_EAX);     ppc32_jit_start_hreg_seq(cpu,"mfcr");
2518       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
2519       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
2520       ppc32_op_emit_require_flags(cpu,JIT_OP_PPC_ALL_FLAGS);
2521    
2522       iop = ppc32_op_emit_insn_output(cpu,3,"mfcr");
2523    
2524       x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_rd,hreg_rd);
2525    
2526     for(i=0;i<8;i++) {     for(i=0;i<8;i++) {
2527        /* load field in %edx */        /* load field in %edx */
2528        x86_mov_reg_membase(b->jit_ptr,X86_EDX,        x86_mov_reg_membase(iop->ob_ptr,hreg_t0,
2529                            X86_EDI,PPC32_CR_FIELD_OFFSET(i),4);                            X86_EDI,PPC32_CR_FIELD_OFFSET(i),4);
2530        x86_shift_reg_imm(b->jit_ptr,X86_SHL,X86_EAX,4);        x86_shift_reg_imm(iop->ob_ptr,X86_SHL,hreg_rd,4);
2531        x86_alu_reg_reg(b->jit_ptr,X86_OR,X86_EAX,X86_EDX);        x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_rd,hreg_t0);
2532     }     }
2533    
2534     ppc32_store_gpr(b,rd,X86_EAX);     ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
2535    
2536       ppc32_jit_close_hreg_seq(cpu);
2537     return(0);     return(0);
2538  }  }
2539    
# Line 1755  DECLARE_INSN(MFCR) Line 2541  DECLARE_INSN(MFCR)
2541  DECLARE_INSN(MFMSR)  DECLARE_INSN(MFMSR)
2542  {  {
2543     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
2544       int hreg_rd;
2545       jit_op_t *iop;
2546    
2547     x86_mov_reg_membase(b->jit_ptr,X86_EAX,X86_EDI,OFFSET(cpu_ppc_t,msr),4);     ppc32_jit_start_hreg_seq(cpu,"mfmsr");
2548     ppc32_store_gpr(b,rd,X86_EAX);     hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
2549    
2550       iop = ppc32_op_emit_insn_output(cpu,1,"mfmsr");
2551       x86_mov_reg_membase(iop->ob_ptr,hreg_rd,X86_EDI,OFFSET(cpu_ppc_t,msr),4);
2552       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
2553    
2554       ppc32_jit_close_hreg_seq(cpu);
2555     return(0);     return(0);
2556  }  }
2557    
# Line 1766  DECLARE_INSN(MFSR) Line 2560  DECLARE_INSN(MFSR)
2560  {  {
2561     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
2562     int sr = bits(insn,16,19);     int sr = bits(insn,16,19);
2563       int hreg_rd;
2564       jit_op_t *iop;
2565    
2566       ppc32_jit_start_hreg_seq(cpu,"mfsr");
2567       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
2568    
2569     x86_mov_reg_membase(b->jit_ptr,X86_EAX,     iop = ppc32_op_emit_insn_output(cpu,1,"mfsr");
2570    
2571       x86_mov_reg_membase(iop->ob_ptr,hreg_rd,
2572                         X86_EDI,(OFFSET(cpu_ppc_t,sr) + (sr << 2)),4);                         X86_EDI,(OFFSET(cpu_ppc_t,sr) + (sr << 2)),4);
2573     ppc32_store_gpr(b,rd,X86_EAX);     ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
2574    
2575       ppc32_jit_close_hreg_seq(cpu);
2576     return(0);     return(0);
2577  }  }
2578    
# Line 1778  DECLARE_INSN(MTCRF) Line 2581  DECLARE_INSN(MTCRF)
2581  {  {
2582     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
2583     int crm = bits(insn,12,19);     int crm = bits(insn,12,19);
2584       int hreg_rs,hreg_t0;
2585       jit_op_t *iop;
2586     int i;     int i;
2587    
2588     ppc32_load_gpr(b,X86_EDX,rs);     ppc32_jit_start_hreg_seq(cpu,"mtcrf");
2589       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
2590       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
2591    
2592       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
2593    
2594       iop = ppc32_op_emit_insn_output(cpu,3,"mtcrf");
2595    
2596     for(i=0;i<8;i++)     for(i=0;i<8;i++)
2597        if (crm & (1 << (7 - i))) {        if (crm & (1 << (7 - i))) {
2598           x86_mov_reg_reg(b->jit_ptr,X86_EAX,X86_EDX,4);           x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_rs,4);
2599    
2600           if (i != 7)           if (i != 7)
2601              x86_shift_reg_imm(b->jit_ptr,X86_SHR,X86_EAX,28 - (i << 2));              x86_shift_reg_imm(iop->ob_ptr,X86_SHR,hreg_t0,28 - (i << 2));
2602    
2603           x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EAX,0x0F);           x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x0F);
2604           x86_mov_membase_reg(b->jit_ptr,X86_EDI,PPC32_CR_FIELD_OFFSET(i),           x86_mov_membase_reg(iop->ob_ptr,X86_EDI,PPC32_CR_FIELD_OFFSET(i),
2605                               X86_EAX,4);                               hreg_t0,4);
2606        }        }
2607    
2608       ppc32_op_emit_basic_opcode(cpu,JIT_OP_TRASH_FLAGS);
2609    
2610       ppc32_jit_close_hreg_seq(cpu);
2611     return(0);     return(0);
2612  }  }
2613    
# Line 1803  DECLARE_INSN(MULHW) Line 2617  DECLARE_INSN(MULHW)
2617     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
2618     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2619     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2620       int hreg_rb;
2621       jit_op_t *iop;
2622    
2623     ppc32_load_gpr(b,X86_EAX,ra);     ppc32_jit_start_hreg_seq(cpu,"mulhw");
2624     ppc32_load_gpr(b,X86_EBX,rb);     ppc32_jit_alloc_hreg_forced(cpu,X86_EAX);
2625     x86_mul_reg(b->jit_ptr,X86_EBX,1);     ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
2626     ppc32_store_gpr(b,rd,X86_EDX);     hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
2627    
2628       ppc32_op_emit_load_gpr(cpu,X86_EAX,ra);
2629       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
2630    
2631       /* rd = hi(ra * rb) */
2632       iop = ppc32_op_emit_insn_output(cpu,2,"mulhw");
2633       x86_mul_reg(iop->ob_ptr,hreg_rb,1);
2634    
2635     if (insn & 1) {     if (insn & 1)
2636        x86_test_reg_reg(b->jit_ptr,X86_EDX,X86_EDX);        x86_test_reg_reg(iop->ob_ptr,X86_EDX,X86_EDX);
2637        ppc32_update_cr0(b);  
2638     }     ppc32_op_emit_store_gpr(cpu,rd,X86_EDX);
2639    
2640       if (insn & 1)
2641          ppc32_op_emit_update_flags(cpu,0,TRUE);
2642    
2643       /* edx:eax are directly modified: throw them */
2644       ppc32_op_emit_alter_host_reg(cpu,X86_EAX);
2645       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
2646    
2647       ppc32_jit_close_hreg_seq(cpu);
2648     return(0);     return(0);
2649  }  }
2650    
# Line 1823  DECLARE_INSN(MULHWU) Line 2654  DECLARE_INSN(MULHWU)
2654     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
2655     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2656     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2657       int hreg_rb;
2658       jit_op_t *iop;
2659    
2660     ppc32_load_gpr(b,X86_EAX,ra);     ppc32_jit_start_hreg_seq(cpu,"mulhwu");
2661     ppc32_load_gpr(b,X86_EBX,rb);     ppc32_jit_alloc_hreg_forced(cpu,X86_EAX);
2662     x86_mul_reg(b->jit_ptr,X86_EBX,0);     ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
2663     ppc32_store_gpr(b,rd,X86_EDX);     hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
2664    
2665       ppc32_op_emit_load_gpr(cpu,X86_EAX,ra);
2666       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
2667    
2668       /* rd = hi(ra * rb) */
2669       iop = ppc32_op_emit_insn_output(cpu,2,"mulhwu");
2670       x86_mul_reg(iop->ob_ptr,hreg_rb,0);
2671    
2672     if (insn & 1) {     if (insn & 1)
2673        x86_test_reg_reg(b->jit_ptr,X86_EDX,X86_EDX);        x86_test_reg_reg(iop->ob_ptr,X86_EDX,X86_EDX);
       ppc32_update_cr0(b);  
    }  
2674    
2675       ppc32_op_emit_store_gpr(cpu,rd,X86_EDX);
2676    
2677       if (insn & 1)
2678          ppc32_op_emit_update_flags(cpu,0,TRUE);
2679    
2680       /* edx:eax are directly modified: throw them */
2681       ppc32_op_emit_alter_host_reg(cpu,X86_EAX);
2682       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
2683    
2684       ppc32_jit_close_hreg_seq(cpu);
2685     return(0);     return(0);
2686  }  }
2687    
# Line 1843  DECLARE_INSN(MULLI) Line 2691  DECLARE_INSN(MULLI)
2691     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
2692     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2693     m_uint32_t imm = bits(insn,0,15);     m_uint32_t imm = bits(insn,0,15);
2694       int hreg_t0;
2695       jit_op_t *iop;
2696    
2697       ppc32_jit_start_hreg_seq(cpu,"mulli");
2698       ppc32_jit_alloc_hreg_forced(cpu,X86_EAX);
2699       ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
2700       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
2701    
2702       ppc32_op_emit_load_gpr(cpu,X86_EAX,ra);
2703    
2704     ppc32_load_gpr(b,X86_EAX,ra);     /* rd = lo(ra * imm) */
2705     ppc32_load_imm(b,X86_EBX,sign_extend_32(imm,16));     iop = ppc32_op_emit_insn_output(cpu,2,"mulli");
2706    
2707     x86_mul_reg(b->jit_ptr,X86_EBX,1);     ppc32_load_imm(&iop->ob_ptr,hreg_t0,sign_extend_32(imm,16));
2708     ppc32_store_gpr(b,rd,X86_EAX);     x86_mul_reg(iop->ob_ptr,hreg_t0,1);
2709       ppc32_op_emit_store_gpr(cpu,rd,X86_EAX);
2710    
2711       /* edx:eax are directly modified: throw them */
2712       ppc32_op_emit_alter_host_reg(cpu,X86_EAX);
2713       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
2714    
2715       ppc32_jit_close_hreg_seq(cpu);
2716     return(0);     return(0);
2717  }  }
2718    
# Line 1858  DECLARE_INSN(MULLW) Line 2722  DECLARE_INSN(MULLW)
2722     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
2723     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2724     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2725       int hreg_rb;
2726       jit_op_t *iop;
2727    
2728     ppc32_load_gpr(b,X86_EAX,ra);     ppc32_jit_start_hreg_seq(cpu,"mullw");
2729     ppc32_load_gpr(b,X86_EBX,rb);     ppc32_jit_alloc_hreg_forced(cpu,X86_EAX);
2730     x86_mul_reg(b->jit_ptr,X86_EBX,1);     ppc32_jit_alloc_hreg_forced(cpu,X86_EDX);
2731     ppc32_store_gpr(b,rd,X86_EAX);     hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
2732    
2733       ppc32_op_emit_load_gpr(cpu,X86_EAX,ra);
2734       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
2735    
2736       /* rd = lo(ra * rb) */
2737       iop = ppc32_op_emit_insn_output(cpu,2,"mullw");
2738       x86_mul_reg(iop->ob_ptr,hreg_rb,1);
2739    
2740     if (insn & 1) {     if (insn & 1)
2741        x86_test_reg_reg(b->jit_ptr,X86_EAX,X86_EAX);        x86_test_reg_reg(iop->ob_ptr,X86_EAX,X86_EAX);
2742        ppc32_update_cr0(b);  
2743     }     ppc32_op_emit_store_gpr(cpu,rd,X86_EAX);
2744    
2745       if (insn & 1)
2746          ppc32_op_emit_update_flags(cpu,0,TRUE);
2747    
2748       /* edx:eax are directly modified: throw them */
2749       ppc32_op_emit_alter_host_reg(cpu,X86_EAX);
2750       ppc32_op_emit_alter_host_reg(cpu,X86_EDX);
2751    
2752       ppc32_jit_close_hreg_seq(cpu);
2753     return(0);     return(0);
2754  }  }
2755    
# Line 1878  DECLARE_INSN(NAND) Line 2759  DECLARE_INSN(NAND)
2759     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
2760     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2761     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2762       int hreg_rs,hreg_ra,hreg_rb;
2763       jit_op_t *iop;
2764    
2765     /* $ra = ~($rs & $rb) */     /* $ra = ~($rs & $rb) */
2766     ppc32_load_gpr(b,X86_EBX,rs);     ppc32_jit_start_hreg_seq(cpu,"nand");
2767     ppc32_alu_gpr(b,X86_AND,X86_EBX,rb);     hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
2768     x86_not_reg(b->jit_ptr,X86_EBX);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
2769     ppc32_store_gpr(b,ra,X86_EBX);     hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
2770    
2771     if (insn & 1) {     ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
2772        x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);     ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
2773        ppc32_update_cr0(b);  
2774       iop = ppc32_op_emit_insn_output(cpu,2,"nand");
2775    
2776       if (ra == rs)
2777          x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_ra,hreg_rb);
2778       else if (ra == rb)
2779          x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_ra,hreg_rs);
2780       else {
2781          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
2782          x86_alu_reg_reg(iop->ob_ptr,X86_AND,hreg_ra,hreg_rb);
2783     }     }
2784    
2785       x86_not_reg(iop->ob_ptr,hreg_ra);
2786    
2787       if (insn & 1)
2788          x86_test_reg_reg(iop->ob_ptr,hreg_ra,hreg_ra);
2789    
2790       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
2791    
2792       if (insn & 1)
2793          ppc32_op_emit_update_flags(cpu,0,TRUE);
2794    
2795       ppc32_jit_close_hreg_seq(cpu);
2796     return(0);     return(0);
2797  }  }
2798    
# Line 1898  DECLARE_INSN(NEG) Line 2801  DECLARE_INSN(NEG)
2801  {  {
2802     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
2803     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2804       int hreg_rd,hreg_ra;
2805       jit_op_t *iop;
2806    
2807     ppc32_load_gpr(b,X86_EBX,ra);     /* $rd = neg($ra) */
2808     x86_neg_reg(b->jit_ptr,X86_EBX);     ppc32_jit_start_hreg_seq(cpu,"neg");
2809     ppc32_store_gpr(b,rd,X86_EBX);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
2810       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
2811    
2812     if (insn & 1) {     ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
2813        x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);  
2814        ppc32_update_cr0(b);     iop = ppc32_op_emit_insn_output(cpu,1,"neg");
2815     }  
2816       if (rd != ra)
2817          x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_ra,4);
2818    
2819       x86_neg_reg(iop->ob_ptr,hreg_rd);
2820    
2821       if (insn & 1)
2822          x86_test_reg_reg(iop->ob_ptr,hreg_rd,hreg_rd);
2823    
2824       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
2825    
2826       if (insn & 1)
2827          ppc32_op_emit_update_flags(cpu,0,TRUE);
2828    
2829       ppc32_jit_close_hreg_seq(cpu);
2830     return(0);     return(0);
2831  }  }
2832    
# Line 1917  DECLARE_INSN(NOR) Line 2836  DECLARE_INSN(NOR)
2836     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
2837     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2838     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2839       int hreg_rs,hreg_ra,hreg_rb;
2840       jit_op_t *iop;
2841    
2842     /* $ra = ~($rs | $rb) */     /* $ra = ~($rs | $rb) */
2843     ppc32_load_gpr(b,X86_EBX,rs);     ppc32_jit_start_hreg_seq(cpu,"nor");
2844     ppc32_alu_gpr(b,X86_OR,X86_EBX,rb);     hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
2845     x86_not_reg(b->jit_ptr,X86_EBX);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
2846     ppc32_store_gpr(b,ra,X86_EBX);     hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
2847    
2848     if (insn & 1) {     ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
2849        x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);     ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
2850        ppc32_update_cr0(b);  
2851       iop = ppc32_op_emit_insn_output(cpu,2,"nor");
2852    
2853       if (ra == rs)
2854          x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_ra,hreg_rb);
2855       else if (ra == rb)
2856          x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_ra,hreg_rs);
2857       else {
2858          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
2859          x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_ra,hreg_rb);
2860     }     }
2861    
2862       x86_not_reg(iop->ob_ptr,hreg_ra);
2863    
2864       if (insn & 1)
2865          x86_test_reg_reg(iop->ob_ptr,hreg_ra,hreg_ra);
2866    
2867       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
2868    
2869       if (insn & 1)
2870          ppc32_op_emit_update_flags(cpu,0,TRUE);
2871    
2872       ppc32_jit_close_hreg_seq(cpu);
2873     return(0);     return(0);
2874  }  }
2875    
# Line 1938  DECLARE_INSN(OR) Line 2879  DECLARE_INSN(OR)
2879     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
2880     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2881     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2882       int hreg_rs,hreg_ra,hreg_rb;
2883       jit_op_t *iop;
2884    
2885     ppc32_load_gpr(b,X86_ECX,rs);     /* $ra = $rs | $rb */
2886       ppc32_jit_start_hreg_seq(cpu,"or");
2887       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
2888       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
2889       hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
2890    
2891     if (rs != rb)     /* special optimization for move/nop operation */
2892        ppc32_alu_gpr(b,X86_OR,X86_ECX,rb);     if (rs == rb) {
2893          ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
2894          iop = ppc32_op_emit_insn_output(cpu,2,"or");
2895    
2896     ppc32_store_gpr(b,ra,X86_ECX);        if (ra != rs)
2897             x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
2898    
2899     if (insn & 1) {        if (insn & 1)
2900        if (rs == rb)           x86_test_reg_reg(iop->ob_ptr,hreg_ra,hreg_ra);
2901           x86_test_reg_reg(b->jit_ptr,X86_ECX,X86_ECX);  
2902        ppc32_update_cr0(b);        ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
2903    
2904          if (insn & 1)
2905             ppc32_op_emit_update_flags(cpu,0,TRUE);
2906    
2907          ppc32_jit_close_hreg_seq(cpu);
2908          return(0);
2909     }     }
2910    
2911       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
2912       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
2913    
2914       iop = ppc32_op_emit_insn_output(cpu,2,"or");
2915    
2916       if (ra == rs) {
2917          x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_ra,hreg_rb);
2918       } else if (ra == rb)
2919          x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_ra,hreg_rs);
2920       else {
2921          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
2922          x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_ra,hreg_rb);
2923       }
2924    
2925       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
2926    
2927       if (insn & 1)
2928          ppc32_op_emit_update_flags(cpu,0,TRUE);
2929    
2930       ppc32_jit_close_hreg_seq(cpu);
2931     return(0);     return(0);
2932  }  }
2933    
# Line 1961  DECLARE_INSN(ORC) Line 2937  DECLARE_INSN(ORC)
2937     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
2938     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2939     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
2940       int hreg_rs,hreg_ra,hreg_rb,hreg_t0;
2941       jit_op_t *iop;
2942    
2943     /* $ra = $rs | ~$rb */     /* $ra = $rs & ~$rb */
2944     ppc32_load_gpr(b,X86_EBX,rb);     ppc32_jit_start_hreg_seq(cpu,"orc");
2945     x86_not_reg(b->jit_ptr,X86_EBX);     hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
2946     ppc32_alu_gpr(b,X86_OR,X86_EBX,rs);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
2947     ppc32_store_gpr(b,ra,X86_EBX);     hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
2948    
2949       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
2950       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
2951    
2952       iop = ppc32_op_emit_insn_output(cpu,1,"orc");
2953    
2954       /* $t0 = ~$rb */
2955       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
2956       x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_rb,4);
2957       x86_not_reg(iop->ob_ptr,hreg_t0);
2958    
2959       /* $ra = $rs | $t0 */
2960       if (ra == rs)
2961          x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_ra,hreg_t0);
2962       else {
2963          x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_t0,hreg_rs);
2964          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_t0,4);
2965       }
2966    
2967       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
2968    
2969     if (insn & 1)     if (insn & 1)
2970        ppc32_update_cr0(b);        ppc32_op_emit_update_flags(cpu,0,TRUE);
2971    
2972       ppc32_jit_close_hreg_seq(cpu);
2973     return(0);     return(0);
2974  }  }
2975    
# Line 1980  DECLARE_INSN(ORI) Line 2979  DECLARE_INSN(ORI)
2979     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
2980     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
2981     m_uint16_t imm = bits(insn,0,15);     m_uint16_t imm = bits(insn,0,15);
2982       m_uint32_t tmp = imm;
2983       int hreg_rs,hreg_ra;
2984       jit_op_t *iop;
2985    
2986     /* $ra = $rs | imm */     /* $ra = $rs | imm */
2987     ppc32_load_imm(b,X86_EBX,imm);     ppc32_jit_start_hreg_seq(cpu,"ori");
2988     ppc32_alu_gpr(b,X86_OR,X86_EBX,rs);     hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
2989     ppc32_store_gpr(b,ra,X86_EBX);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
2990    
2991       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
2992    
2993       iop = ppc32_op_emit_insn_output(cpu,1,"ori");
2994    
2995       if (ra != rs)
2996          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
2997    
2998       x86_alu_reg_imm(iop->ob_ptr,X86_OR,hreg_ra,tmp);
2999       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
3000    
3001       ppc32_jit_close_hreg_seq(cpu);
3002     return(0);     return(0);
3003  }  }
3004    
# Line 1993  DECLARE_INSN(ORIS) Line 3007  DECLARE_INSN(ORIS)
3007  {  {
3008     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
3009     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3010     m_uint32_t imm = bits(insn,0,15);     m_uint16_t imm = bits(insn,0,15);
3011       m_uint32_t tmp = imm << 16;
3012       int hreg_rs,hreg_ra;
3013       jit_op_t *iop;
3014    
3015       /* $ra = $rs | imm */
3016       ppc32_jit_start_hreg_seq(cpu,"oris");
3017       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
3018       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3019    
3020       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
3021    
3022       iop = ppc32_op_emit_insn_output(cpu,1,"oris");
3023    
3024       if (ra != rs)
3025          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
3026    
3027       x86_alu_reg_imm(iop->ob_ptr,X86_OR,hreg_ra,tmp);
3028       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
3029    
3030     /* $ra = $rs | (imm << 16) */     ppc32_jit_close_hreg_seq(cpu);
    ppc32_load_imm(b,X86_EBX,imm << 16);  
    ppc32_alu_gpr(b,X86_OR,X86_EBX,rs);  
    ppc32_store_gpr(b,ra,X86_EBX);  
3031     return(0);     return(0);
3032  }  }
3033    
# Line 2011  DECLARE_INSN(RLWIMI) Line 3040  DECLARE_INSN(RLWIMI)
3040     int mb = bits(insn,6,10);     int mb = bits(insn,6,10);
3041     int me = bits(insn,1,5);     int me = bits(insn,1,5);
3042     register m_uint32_t mask;     register m_uint32_t mask;
3043       int hreg_rs,hreg_ra,hreg_t0;
3044       jit_op_t *iop;
3045    
3046       ppc32_jit_start_hreg_seq(cpu,"rlwimi");
3047       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
3048       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
3049       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3050    
3051       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
3052       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
3053    
3054     mask = ppc32_rotate_mask(mb,me);     mask = ppc32_rotate_mask(mb,me);
3055    
3056     /* Apply inverse mask to %eax "ra" */     iop = ppc32_op_emit_insn_output(cpu,2,"rlwimi");
3057     ppc32_load_gpr(b,X86_EAX,ra);  
3058       /* Apply inverse mask to $ra */
3059     if (mask != 0)     if (mask != 0)
3060        x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EAX,~mask);        x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_ra,~mask);
3061    
3062     /* Rotate %ebx ("rs") of "sh" bits and apply the mask */     /* Rotate $rs of "sh" bits and apply the mask */
3063     ppc32_load_gpr(b,X86_EBX,rs);     x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_rs,4);
3064    
3065     if (sh != 0)     if (sh != 0)
3066     x86_shift_reg_imm(b->jit_ptr,X86_ROL,X86_EBX,sh);        x86_shift_reg_imm(iop->ob_ptr,X86_ROL,hreg_t0,sh);
3067    
3068     if (mask != 0xFFFFFFFF)     if (mask != 0xFFFFFFFF)
3069        x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,mask);        x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,mask);
3070    
3071     /* Store the result */     /* Store the result */
3072     x86_alu_reg_reg(b->jit_ptr,X86_OR,X86_EBX,X86_EAX);     x86_alu_reg_reg(iop->ob_ptr,X86_OR,hreg_ra,hreg_t0);
3073     ppc32_store_gpr(b,ra,X86_EBX);     ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
3074    
3075     if (insn & 1)     if (insn & 1)
3076        ppc32_update_cr0(b);        ppc32_op_emit_update_flags(cpu,0,TRUE);
3077    
3078       ppc32_jit_close_hreg_seq(cpu);
3079     return(0);     return(0);
3080  }  }
3081    
# Line 2047  DECLARE_INSN(RLWINM) Line 3088  DECLARE_INSN(RLWINM)
3088     int mb = bits(insn,6,10);     int mb = bits(insn,6,10);
3089     int me = bits(insn,1,5);     int me = bits(insn,1,5);
3090     register m_uint32_t mask;     register m_uint32_t mask;
3091       int hreg_rs,hreg_ra;
3092       jit_op_t *iop;
3093    
3094       ppc32_jit_start_hreg_seq(cpu,"rlwinm");
3095       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
3096       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3097    
3098       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
3099    
3100       iop = ppc32_op_emit_insn_output(cpu,2,"rlwinm");
3101    
3102       /* Rotate $rs of "sh" bits and apply the mask */
3103     mask = ppc32_rotate_mask(mb,me);     mask = ppc32_rotate_mask(mb,me);
3104    
3105     /* Rotate %ebx ("rs") of "sh" bits and apply the mask */     if (rs != ra)
3106     ppc32_load_gpr(b,X86_EBX,rs);        x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
3107    
3108     if (sh != 0)     if (sh != 0)
3109        x86_shift_reg_imm(b->jit_ptr,X86_ROL,X86_EBX,sh);        x86_shift_reg_imm(iop->ob_ptr,X86_ROL,hreg_ra,sh);
3110    
3111     if (mask != 0xFFFFFFFF)     if (mask != 0xFFFFFFFF)
3112        x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,mask);        x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_ra,mask);
3113    
3114     ppc32_store_gpr(b,ra,X86_EBX);     if (insn & 1)
3115          x86_test_reg_reg(iop->ob_ptr,hreg_ra,hreg_ra);
3116    
3117     if (insn & 1) {     ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
       x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);  
       ppc32_update_cr0(b);  
    }  
3118    
3119       if (insn & 1)
3120          ppc32_op_emit_update_flags(cpu,0,TRUE);
3121    
3122       ppc32_jit_close_hreg_seq(cpu);
3123     return(0);     return(0);
3124  }  }
3125    
# Line 2078  DECLARE_INSN(RLWNM) Line 3132  DECLARE_INSN(RLWNM)
3132     int mb = bits(insn,6,10);     int mb = bits(insn,6,10);
3133     int me = bits(insn,1,5);     int me = bits(insn,1,5);
3134     register m_uint32_t mask;     register m_uint32_t mask;
3135       int hreg_rs,hreg_ra,hreg_t0;
3136       jit_op_t *iop;
3137    
3138     mask = ppc32_rotate_mask(mb,me);     /* ecx is directly modified: throw it */
3139       ppc32_op_emit_alter_host_reg(cpu,X86_ECX);
3140    
3141       ppc32_jit_start_hreg_seq(cpu,"rlwnm");
3142       ppc32_jit_alloc_hreg_forced(cpu,X86_ECX);
3143    
3144       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
3145       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
3146       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3147    
3148       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
3149       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
3150       ppc32_op_emit_load_gpr(cpu,X86_ECX,rb);
3151    
3152       iop = ppc32_op_emit_insn_output(cpu,2,"rlwnm");
3153    
3154     /* Load the shift register ("sh") */     /* Load the shift register ("sh") */
3155     ppc32_load_gpr(b,X86_ECX,rb);     mask = ppc32_rotate_mask(mb,me);
3156    
3157     /* Rotate %ebx ("rs") and apply the mask */     /* Rotate $rs and apply the mask */
3158     ppc32_load_gpr(b,X86_EBX,rs);     x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_rs,4);
3159     x86_shift_reg(b->jit_ptr,X86_ROL,X86_EBX);  
3160       x86_shift_reg(iop->ob_ptr,X86_ROL,hreg_t0);
3161    
3162     if (mask != 0xFFFFFFFF)     if (mask != 0xFFFFFFFF)
3163        x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EBX,mask);        x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,mask);
3164    
3165     ppc32_store_gpr(b,ra,X86_EBX);     x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_t0,4);
3166    
3167     if (insn & 1) {     if (insn & 1)
3168        x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);        x86_test_reg_reg(iop->ob_ptr,hreg_ra,hreg_ra);
3169        ppc32_update_cr0(b);  
3170     }     ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
3171    
3172       if (insn & 1)
3173          ppc32_op_emit_update_flags(cpu,0,TRUE);
3174    
3175       ppc32_jit_close_hreg_seq(cpu);
3176     return(0);     return(0);
3177  }  }
3178    
# Line 2108  DECLARE_INSN(SLW) Line 3183  DECLARE_INSN(SLW)
3183     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3184     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3185     u_char *test1;     u_char *test1;
3186       int hreg_rs,hreg_ra,hreg_t0;
3187       jit_op_t *iop;
3188    
3189     /* If count >= 32, then null result */     /* ecx is directly modified: throw it */
3190     ppc32_load_gpr(b,X86_ECX,rb);     ppc32_op_emit_alter_host_reg(cpu,X86_ECX);
    x86_alu_reg_reg(b->jit_ptr,X86_XOR,X86_EBX,X86_EBX);  
   
    x86_test_reg_imm(b->jit_ptr,X86_ECX,0x20);  
    test1 = b->jit_ptr;  
    x86_branch8(b->jit_ptr, X86_CC_NZ, 0, 1);  
3191    
3192     ppc32_load_gpr(b,X86_EBX,rs);     ppc32_jit_start_hreg_seq(cpu,"slw");
3193     x86_shift_reg(b->jit_ptr,X86_SHL,X86_EBX);     ppc32_jit_alloc_hreg_forced(cpu,X86_ECX);
3194       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
3195       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
3196       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3197    
3198       /* $ra = $rs << $rb. If count >= 32, then null result */
3199       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
3200       ppc32_op_emit_load_gpr(cpu,X86_ECX,rb);
3201    
3202       iop = ppc32_op_emit_insn_output(cpu,3,"slw");
3203    
3204       x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_t0,hreg_t0);
3205       x86_test_reg_imm(iop->ob_ptr,X86_ECX,0x20);
3206       test1 = iop->ob_ptr;
3207       x86_branch8(iop->ob_ptr, X86_CC_NZ, 0, 1);
3208    
3209       x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_rs,4);
3210       x86_shift_reg(iop->ob_ptr,X86_SHL,hreg_t0);
3211      
3212       /* store the result */
3213       x86_patch(test1,iop->ob_ptr);
3214       x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_t0,4);
3215    
3216     /* Store the result */     if (insn & 1)
3217     x86_patch(test1,b->jit_ptr);        x86_test_reg_reg(iop->ob_ptr,hreg_ra,hreg_ra);
    ppc32_store_gpr(b,ra,X86_EBX);  
3218    
3219     if (insn & 1) {     ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
3220        x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);    
3221        ppc32_update_cr0(b);     if (insn & 1)
3222     }        ppc32_op_emit_update_flags(cpu,0,TRUE);
3223    
3224       ppc32_jit_close_hreg_seq(cpu);
3225     return(0);     return(0);
3226  }  }
3227    
# Line 2139  DECLARE_INSN(SRAWI) Line 3232  DECLARE_INSN(SRAWI)
3232     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3233     int sh = bits(insn,11,15);     int sh = bits(insn,11,15);
3234     register m_uint32_t mask;     register m_uint32_t mask;
3235       int hreg_rs,hreg_ra,hreg_t0;
3236       jit_op_t *iop;
3237    
3238     mask = ~(0xFFFFFFFFU << sh);     ppc32_jit_start_hreg_seq(cpu,"srawi");
3239       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
3240       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
3241       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3242    
3243     /* $ra = (int32)$rs >> sh */     /* $ra = (int32)$rs >> sh */
3244     ppc32_load_gpr(b,X86_EBX,rs);     ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
    x86_mov_reg_reg(b->jit_ptr,X86_ESI,X86_EBX,4);  
    x86_shift_reg_imm(b->jit_ptr,X86_SAR,X86_EBX,sh);  
    ppc32_store_gpr(b,ra,X86_EBX);  
   
    /* test the sign-bit of gpr[rs] */  
    x86_test_reg_reg(b->jit_ptr,X86_ESI,X86_ESI);  
    x86_set_reg(b->jit_ptr,X86_CC_LT,X86_EAX,TRUE);  
   
    x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_ESI,mask);  
    x86_set_reg(b->jit_ptr,X86_CC_NZ,X86_ECX,TRUE);  
     
    x86_alu_reg_reg(b->jit_ptr,X86_AND,X86_ECX,X86_EAX);  
    x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_ECX,0x1);  
    x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),X86_ECX,4);  
3245    
3246     if (insn & 1) {     iop = ppc32_op_emit_insn_output(cpu,3,"srawi");
3247        x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);     x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_rs,4);
3248        ppc32_update_cr0(b);    
3249     }     if (ra != rs)
3250          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
3251       x86_shift_reg_imm(iop->ob_ptr,X86_SAR,hreg_ra,sh);
3252    
3253       /* set XER_CA depending on the result */
3254       mask = ~(0xFFFFFFFFU << sh) | 0x80000000;
3255    
3256       x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,mask);
3257       x86_alu_reg_imm(iop->ob_ptr,X86_CMP,hreg_t0,0x80000000);
3258       x86_set_reg(iop->ob_ptr,X86_CC_A,hreg_t0,FALSE);
3259       x86_alu_reg_imm(iop->ob_ptr,X86_AND,hreg_t0,0x1);
3260       x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),hreg_t0,4);
3261    
3262       if (insn & 1)
3263          x86_test_reg_reg(iop->ob_ptr,hreg_ra,hreg_ra);
3264    
3265       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
3266      
3267       if (insn & 1)
3268          ppc32_op_emit_update_flags(cpu,0,TRUE);
3269    
3270       ppc32_jit_close_hreg_seq(cpu);
3271     return(0);     return(0);
3272  }  }
3273    
# Line 2174  DECLARE_INSN(SRW) Line 3278  DECLARE_INSN(SRW)
3278     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3279     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3280     u_char *test1;     u_char *test1;
3281       int hreg_rs,hreg_ra,hreg_t0;
3282       jit_op_t *iop;
3283    
3284     /* If count >= 32, then null result */     /* ecx is directly modified: throw it */
3285     ppc32_load_gpr(b,X86_ECX,rb);     ppc32_op_emit_alter_host_reg(cpu,X86_ECX);
    x86_alu_reg_reg(b->jit_ptr,X86_XOR,X86_EBX,X86_EBX);  
   
    x86_test_reg_imm(b->jit_ptr,X86_ECX,0x20);  
    test1 = b->jit_ptr;  
    x86_branch8(b->jit_ptr, X86_CC_NZ, 0, 1);  
3286    
3287     ppc32_load_gpr(b,X86_EBX,rs);     ppc32_jit_start_hreg_seq(cpu,"srw");
3288     x86_shift_reg(b->jit_ptr,X86_SHR,X86_EBX);     ppc32_jit_alloc_hreg_forced(cpu,X86_ECX);
3289       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
3290       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
3291       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3292    
3293       /* $ra = $rs >> $rb. If count >= 32, then null result */
3294       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
3295       ppc32_op_emit_load_gpr(cpu,X86_ECX,rb);
3296    
3297       iop = ppc32_op_emit_insn_output(cpu,3,"srw");
3298    
3299       x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_t0,hreg_t0);
3300       x86_test_reg_imm(iop->ob_ptr,X86_ECX,0x20);
3301       test1 = iop->ob_ptr;
3302       x86_branch8(iop->ob_ptr, X86_CC_NZ, 0, 1);
3303    
3304       x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_rs,4);
3305       x86_shift_reg(iop->ob_ptr,X86_SHR,hreg_t0);
3306      
3307       /* store the result */
3308       x86_patch(test1,iop->ob_ptr);
3309       x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_t0,4);
3310    
3311     /* Store the result */     if (insn & 1)
3312     x86_patch(test1,b->jit_ptr);        x86_test_reg_reg(iop->ob_ptr,hreg_ra,hreg_ra);
    ppc32_store_gpr(b,ra,X86_EBX);  
3313    
3314     if (insn & 1) {     ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
3315        x86_test_reg_reg(b->jit_ptr,X86_EBX,X86_EBX);    
3316        ppc32_update_cr0(b);     if (insn & 1)
3317     }        ppc32_op_emit_update_flags(cpu,0,TRUE);
3318            
3319       ppc32_jit_close_hreg_seq(cpu);
3320     return(0);     return(0);
3321  }  }
3322    
# Line 2206  DECLARE_INSN(STB) Line 3328  DECLARE_INSN(STB)
3328     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
3329    
3330     //ppc32_emit_memop(b,PPC_MEMOP_STB,ra,offset,rs,0);     //ppc32_emit_memop(b,PPC_MEMOP_STB,ra,offset,rs,0);
3331     ppc32_emit_memop_fast(b,1,PPC_MEMOP_STB,ra,offset,rs,ppc32_memop_fast_stb);     ppc32_emit_memop_fast(cpu,b,1,PPC_MEMOP_STB,ra,offset,rs,
3332                             ppc32_memop_fast_stb);
3333     return(0);     return(0);
3334  }  }
3335    
# Line 2217  DECLARE_INSN(STBU) Line 3340  DECLARE_INSN(STBU)
3340     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3341     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
3342    
3343     ppc32_emit_memop(b,PPC_MEMOP_STB,ra,offset,rs,1);     ppc32_emit_memop(cpu,b,PPC_MEMOP_STB,ra,offset,rs,1);
3344     return(0);     return(0);
3345  }  }
3346    
# Line 2228  DECLARE_INSN(STBUX) Line 3351  DECLARE_INSN(STBUX)
3351     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3352     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3353    
3354     ppc32_emit_memop_idx(b,PPC_MEMOP_STB,ra,rb,rs,1);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_STB,ra,rb,rs,1);
3355     return(0);     return(0);
3356  }  }
3357    
# Line 2239  DECLARE_INSN(STBX) Line 3362  DECLARE_INSN(STBX)
3362     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3363     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3364    
3365     ppc32_emit_memop_idx(b,PPC_MEMOP_STB,ra,rb,rs,0);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_STB,ra,rb,rs,0);
3366     return(0);     return(0);
3367  }  }
3368    
# Line 2250  DECLARE_INSN(STH) Line 3373  DECLARE_INSN(STH)
3373     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3374     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
3375    
3376     ppc32_emit_memop(b,PPC_MEMOP_STH,ra,offset,rs,0);     ppc32_emit_memop(cpu,b,PPC_MEMOP_STH,ra,offset,rs,0);
3377     return(0);     return(0);
3378  }  }
3379    
# Line 2261  DECLARE_INSN(STHU) Line 3384  DECLARE_INSN(STHU)
3384     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3385     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
3386    
3387     ppc32_emit_memop(b,PPC_MEMOP_STH,ra,offset,rs,1);     ppc32_emit_memop(cpu,b,PPC_MEMOP_STH,ra,offset,rs,1);
3388     return(0);     return(0);
3389  }  }
3390    
# Line 2272  DECLARE_INSN(STHUX) Line 3395  DECLARE_INSN(STHUX)
3395     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3396     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3397    
3398     ppc32_emit_memop_idx(b,PPC_MEMOP_STH,ra,rb,rs,1);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_STH,ra,rb,rs,1);
3399     return(0);     return(0);
3400  }  }
3401    
# Line 2283  DECLARE_INSN(STHX) Line 3406  DECLARE_INSN(STHX)
3406     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3407     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3408    
3409     ppc32_emit_memop_idx(b,PPC_MEMOP_STH,ra,rb,rs,0);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_STH,ra,rb,rs,0);
3410     return(0);     return(0);
3411  }  }
3412    
# Line 2295  DECLARE_INSN(STW) Line 3418  DECLARE_INSN(STW)
3418     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
3419    
3420     //ppc32_emit_memop(b,PPC_MEMOP_STW,ra,offset,rs,0);     //ppc32_emit_memop(b,PPC_MEMOP_STW,ra,offset,rs,0);
3421     ppc32_emit_memop_fast(b,1,PPC_MEMOP_STW,ra,offset,rs,ppc32_memop_fast_stw);     ppc32_emit_memop_fast(cpu,b,1,PPC_MEMOP_STW,ra,offset,rs,
3422                             ppc32_memop_fast_stw);
3423     return(0);     return(0);
3424  }  }
3425    
# Line 2306  DECLARE_INSN(STWU) Line 3430  DECLARE_INSN(STWU)
3430     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3431     m_uint16_t offset = bits(insn,0,15);     m_uint16_t offset = bits(insn,0,15);
3432    
3433     ppc32_emit_memop(b,PPC_MEMOP_STW,ra,offset,rs,1);     ppc32_emit_memop(cpu,b,PPC_MEMOP_STW,ra,offset,rs,1);
3434     return(0);     return(0);
3435  }  }
3436    
# Line 2317  DECLARE_INSN(STWUX) Line 3441  DECLARE_INSN(STWUX)
3441     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3442     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3443    
3444     ppc32_emit_memop_idx(b,PPC_MEMOP_STW,ra,rb,rs,1);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_STW,ra,rb,rs,1);
3445     return(0);     return(0);
3446  }  }
3447    
# Line 2328  DECLARE_INSN(STWX) Line 3452  DECLARE_INSN(STWX)
3452     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3453     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3454    
3455     ppc32_emit_memop_idx(b,PPC_MEMOP_STW,ra,rb,rs,0);     ppc32_emit_memop_idx(cpu,b,PPC_MEMOP_STW,ra,rb,rs,0);
3456     return(0);     return(0);
3457  }  }
3458    
# Line 2338  DECLARE_INSN(SUBF) Line 3462  DECLARE_INSN(SUBF)
3462     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
3463     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3464     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3465       int hreg_rd,hreg_ra,hreg_rb,hreg_t0;
3466       jit_op_t *iop;
3467    
3468       /* $rd = $rb - $ra */
3469       ppc32_jit_start_hreg_seq(cpu,"subf");
3470       hreg_t0 = ppc32_jit_get_tmp_hreg(cpu);
3471    
3472       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
3473       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3474       hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
3475    
3476       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
3477       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
3478    
3479       iop = ppc32_op_emit_insn_output(cpu,2,"subf");
3480    
3481       if (rd == rb)
3482          x86_alu_reg_reg(iop->ob_ptr,X86_SUB,hreg_rd,hreg_ra);
3483       else if (rd == ra) {
3484          x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_rb,4);
3485          x86_alu_reg_reg(iop->ob_ptr,X86_SUB,hreg_t0,hreg_ra);
3486          x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_t0,4);
3487       } else {
3488          x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_rb,4);
3489          x86_alu_reg_reg(iop->ob_ptr,X86_SUB,hreg_rd,hreg_ra);
3490       }
3491    
3492     /* $rd = $rb - $rb */     ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
    ppc32_load_gpr(b,X86_EBX,rb);  
    ppc32_alu_gpr(b,X86_SUB,X86_EBX,ra);  
    ppc32_store_gpr(b,rd,X86_EBX);  
3493    
3494     if (insn & 1)     if (insn & 1)
3495        ppc32_update_cr0(b);        ppc32_op_emit_update_flags(cpu,0,TRUE);
3496          
3497       ppc32_jit_close_hreg_seq(cpu);
3498     return(0);     return(0);
3499  }  }
3500    
# Line 2356  DECLARE_INSN(SUBFC) Line 3504  DECLARE_INSN(SUBFC)
3504     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
3505     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3506     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3507       int hreg_ra,hreg_rb,hreg_rd,hreg_t0,hreg_t1;
3508       jit_op_t *iop;
3509    
3510     /* ~$ra + 1 */     /* $rd = ~$ra + 1 + $rb */
3511     ppc32_load_gpr(b,X86_ESI,ra);     ppc32_jit_start_hreg_seq(cpu,"subfc");
3512     x86_not_reg(b->jit_ptr,X86_ESI);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3513     x86_alu_reg_imm(b->jit_ptr,X86_ADD,X86_ESI,1);     hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
3514     x86_set_reg(b->jit_ptr,X86_CC_C,X86_EAX,FALSE);     hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
3515    
3516     /* add $rb */     hreg_t0 = ppc32_jit_alloc_hreg(cpu,-1);
3517     ppc32_alu_gpr(b,X86_ADD,X86_ESI,rb);     hreg_t1 = ppc32_jit_get_tmp_hreg(cpu);
3518     x86_set_reg(b->jit_ptr,X86_CC_C,X86_ECX,FALSE);  
3519       ppc32_op_emit_alter_host_reg(cpu,hreg_t0);
3520       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
3521       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
3522    
3523       iop = ppc32_op_emit_insn_output(cpu,3,"subfc");
3524    
3525       x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_t1,hreg_t1);
3526    
3527       /* $t0 = ~$ra + 1 */
3528       x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_ra,4);
3529       x86_not_reg(iop->ob_ptr,hreg_t0);
3530       x86_alu_reg_imm(iop->ob_ptr,X86_ADD,hreg_t0,1);
3531       x86_set_reg(iop->ob_ptr,X86_CC_C,hreg_t1,FALSE);
3532       x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),hreg_t1,4);
3533    
3534       /* $t0 += $rb */
3535       x86_alu_reg_reg(iop->ob_ptr,X86_ADD,hreg_t0,hreg_rb);
3536       x86_set_reg(iop->ob_ptr,X86_CC_C,hreg_t1,FALSE);
3537       x86_alu_membase_reg(iop->ob_ptr,X86_OR,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),
3538                           hreg_t1);
3539    
3540     ppc32_store_gpr(b,rd,X86_ESI);     x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_t0,4);
3541    
3542     /* store the carry flag */     if (insn & 1)
3543     x86_alu_reg_reg(b->jit_ptr,X86_OR,X86_EAX,X86_ECX);        x86_test_reg_reg(iop->ob_ptr,hreg_rd,hreg_rd);
    x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EAX,0x1);  
3544    
3545     x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),X86_EAX,4);     ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
3546    
3547     /* update cr0 */     /* update cr0 */
3548     if (insn & 1) {     if (insn & 1)
       x86_test_reg_reg(b->jit_ptr,X86_ESI,X86_ESI);  
3549        ppc32_update_cr0(b);        ppc32_update_cr0(b);
    }  
3550    
3551       ppc32_jit_close_hreg_seq(cpu);
3552     return(0);     return(0);
3553  }  }
3554    
# Line 2390  DECLARE_INSN(SUBFE) Line 3558  DECLARE_INSN(SUBFE)
3558     int rd = bits(insn,21,25);     int rd = bits(insn,21,25);
3559     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3560     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3561       int hreg_ra,hreg_rb,hreg_rd,hreg_t0,hreg_t1;
3562       jit_op_t *iop;
3563    
3564     /* ~$ra + carry */     /* $rd = ~$ra + $carry (xer_ca) + $rb */
3565     ppc32_load_gpr(b,X86_ESI,ra);     ppc32_jit_start_hreg_seq(cpu,"subfe");
3566     x86_not_reg(b->jit_ptr,X86_ESI);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3567     x86_alu_reg_membase(b->jit_ptr,X86_ADD,X86_ESI,     hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
3568       hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
3569    
3570       hreg_t0 = ppc32_jit_alloc_hreg(cpu,-1);
3571       hreg_t1 = ppc32_jit_get_tmp_hreg(cpu);
3572    
3573       ppc32_op_emit_alter_host_reg(cpu,hreg_t0);
3574       ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
3575       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
3576    
3577       iop = ppc32_op_emit_insn_output(cpu,3,"subfe");
3578    
3579       x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_t1,hreg_t1);
3580    
3581       /* $t0 = ~$ra + $carry */
3582       x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_ra,4);
3583       x86_not_reg(iop->ob_ptr,hreg_t0);
3584       x86_alu_reg_membase(iop->ob_ptr,X86_ADD,hreg_t0,
3585                         X86_EDI,OFFSET(cpu_ppc_t,xer_ca));                         X86_EDI,OFFSET(cpu_ppc_t,xer_ca));
    x86_set_reg(b->jit_ptr,X86_CC_C,X86_EAX,FALSE);  
3586    
3587     /* add $rb */     x86_set_reg(iop->ob_ptr,X86_CC_C,hreg_t1,FALSE);
3588     ppc32_alu_gpr(b,X86_ADD,X86_ESI,rb);     x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),hreg_t1,4);
    x86_set_reg(b->jit_ptr,X86_CC_C,X86_ECX,FALSE);  
3589    
3590     ppc32_store_gpr(b,rd,X86_ESI);     /* $t0 += $rb */
3591       x86_alu_reg_reg(iop->ob_ptr,X86_ADD,hreg_t0,hreg_rb);
3592       x86_set_reg(iop->ob_ptr,X86_CC_C,hreg_t1,FALSE);
3593       x86_alu_membase_reg(iop->ob_ptr,X86_OR,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),
3594                           hreg_t1);
3595    
3596     /* store the carry flag */     x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_t0,4);
3597     x86_alu_reg_reg(b->jit_ptr,X86_OR,X86_EAX,X86_ECX);  
3598     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EAX,0x1);     if (insn & 1)
3599     x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),X86_EAX,4);        x86_test_reg_reg(iop->ob_ptr,hreg_rd,hreg_rd);
3600    
3601       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
3602    
3603     /* update cr0 */     /* update cr0 */
3604     if (insn & 1) {     if (insn & 1)
       x86_test_reg_reg(b->jit_ptr,X86_ESI,X86_ESI);  
3605        ppc32_update_cr0(b);        ppc32_update_cr0(b);
    }  
3606    
3607       ppc32_jit_close_hreg_seq(cpu);
3608     return(0);     return(0);
3609  }  }
3610    
# Line 2425  DECLARE_INSN(SUBFIC) Line 3615  DECLARE_INSN(SUBFIC)
3615     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3616     m_uint16_t imm = bits(insn,0,15);     m_uint16_t imm = bits(insn,0,15);
3617     m_uint32_t tmp = sign_extend_32(imm,16);     m_uint32_t tmp = sign_extend_32(imm,16);
3618       int hreg_ra,hreg_rd,hreg_t0,hreg_t1;
3619       jit_op_t *iop;
3620    
3621     /* ~$ra + 1 */     /* $rd = ~$ra + 1 + sign_extend(imm,16) */
3622     ppc32_load_gpr(b,X86_ESI,ra);     ppc32_jit_start_hreg_seq(cpu,"subfic");
3623     x86_not_reg(b->jit_ptr,X86_ESI);     hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3624     x86_alu_reg_imm(b->jit_ptr,X86_ADD,X86_ESI,1);     hreg_rd = ppc32_jit_alloc_hreg(cpu,rd);
    x86_set_reg(b->jit_ptr,X86_CC_C,X86_EAX,FALSE);  
   
    /* add sign-extended $immediate */  
    x86_alu_reg_imm(b->jit_ptr,X86_ADD,X86_ESI,tmp);  
    x86_set_reg(b->jit_ptr,X86_CC_C,X86_ECX,FALSE);  
3625    
3626     ppc32_store_gpr(b,rd,X86_ESI);     hreg_t0 = ppc32_jit_alloc_hreg(cpu,-1);
3627       hreg_t1 = ppc32_jit_get_tmp_hreg(cpu);
3628    
3629     /* store the carry flag */     ppc32_op_emit_alter_host_reg(cpu,hreg_t0);
3630     x86_alu_reg_reg(b->jit_ptr,X86_OR,X86_EAX,X86_ECX);     ppc32_op_emit_load_gpr(cpu,hreg_ra,ra);
3631     x86_alu_reg_imm(b->jit_ptr,X86_AND,X86_EAX,0x1);  
3632       iop = ppc32_op_emit_insn_output(cpu,3,"subfic");
3633    
3634       x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_t1,hreg_t1);
3635    
3636       /* $t0 = ~$ra + 1 */
3637       x86_mov_reg_reg(iop->ob_ptr,hreg_t0,hreg_ra,4);
3638       x86_not_reg(iop->ob_ptr,hreg_t0);
3639       x86_alu_reg_imm(iop->ob_ptr,X86_ADD,hreg_t0,1);
3640    
3641       x86_set_reg(iop->ob_ptr,X86_CC_C,hreg_t1,FALSE);
3642       x86_mov_membase_reg(iop->ob_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),hreg_t1,4);
3643    
3644       /* $t0 += sign_extend(imm,16) */
3645       x86_alu_reg_imm(iop->ob_ptr,X86_ADD,hreg_t0,tmp);
3646       x86_set_reg(iop->ob_ptr,X86_CC_C,hreg_t1,FALSE);
3647       x86_alu_membase_reg(iop->ob_ptr,X86_OR,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),
3648                           hreg_t1);
3649    
3650     x86_mov_membase_reg(b->jit_ptr,X86_EDI,OFFSET(cpu_ppc_t,xer_ca),X86_EAX,4);     x86_mov_reg_reg(iop->ob_ptr,hreg_rd,hreg_t0,4);
3651       ppc32_op_emit_store_gpr(cpu,rd,hreg_rd);
3652      
3653       ppc32_jit_close_hreg_seq(cpu);
3654     return(0);     return(0);
3655  }  }
3656    
# Line 2458  DECLARE_INSN(XOR) Line 3666  DECLARE_INSN(XOR)
3666     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
3667     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3668     int rb = bits(insn,11,15);     int rb = bits(insn,11,15);
3669       int hreg_rs,hreg_ra,hreg_rb;
3670       jit_op_t *iop;
3671    
3672       /* $ra = $rs ^ $rb */
3673       ppc32_jit_start_hreg_seq(cpu,"xor");
3674       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
3675       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3676       hreg_rb = ppc32_jit_alloc_hreg(cpu,rb);
3677    
3678       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
3679       ppc32_op_emit_load_gpr(cpu,hreg_rb,rb);
3680    
3681       iop = ppc32_op_emit_insn_output(cpu,1,"xor");
3682    
3683       if (ra == rs)
3684          x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_ra,hreg_rb);
3685       else if (ra == rb)
3686          x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_ra,hreg_rs);
3687       else {
3688          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
3689          x86_alu_reg_reg(iop->ob_ptr,X86_XOR,hreg_ra,hreg_rb);
3690       }
3691    
3692     ppc32_load_gpr(b,X86_EBX,rs);     ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
    ppc32_alu_gpr(b,X86_XOR,X86_EBX,rb);  
    ppc32_store_gpr(b,ra,X86_EBX);  
3693    
3694     if (insn & 1)     if (insn & 1)
3695        ppc32_update_cr0(b);        ppc32_op_emit_update_flags(cpu,0,TRUE);
3696    
3697       ppc32_jit_close_hreg_seq(cpu);
3698     return(0);     return(0);
3699  }  }
3700    
# Line 2475  DECLARE_INSN(XORI) Line 3704  DECLARE_INSN(XORI)
3704     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
3705     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3706     m_uint32_t imm = bits(insn,0,15);     m_uint32_t imm = bits(insn,0,15);
3707       int hreg_rs,hreg_ra;
3708       jit_op_t *iop;
3709    
3710       /* $ra = $rs ^ imm */
3711       ppc32_jit_start_hreg_seq(cpu,"xori");
3712       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
3713       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3714    
3715       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
3716    
3717       iop = ppc32_op_emit_insn_output(cpu,1,"xori");
3718    
3719       if (ra != rs)
3720          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
3721    
3722     ppc32_load_imm(b,X86_EBX,imm);     x86_alu_reg_imm(iop->ob_ptr,X86_XOR,hreg_ra,imm);
3723     ppc32_alu_gpr(b,X86_XOR,X86_EBX,rs);     ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
3724     ppc32_store_gpr(b,ra,X86_EBX);  
3725       ppc32_jit_close_hreg_seq(cpu);
3726     return(0);     return(0);
3727  }  }
3728    
# Line 2487  DECLARE_INSN(XORIS) Line 3731  DECLARE_INSN(XORIS)
3731  {  {
3732     int rs = bits(insn,21,25);     int rs = bits(insn,21,25);
3733     int ra = bits(insn,16,20);     int ra = bits(insn,16,20);
3734     m_uint32_t imm = bits(insn,0,15);     m_uint16_t imm = bits(insn,0,15);
3735       m_uint32_t tmp = imm << 16;
3736       int hreg_rs,hreg_ra;
3737       jit_op_t *iop;
3738    
3739       /* $ra = $rs ^ (imm << 16) */
3740       ppc32_jit_start_hreg_seq(cpu,"xoris");
3741       hreg_rs = ppc32_jit_alloc_hreg(cpu,rs);
3742       hreg_ra = ppc32_jit_alloc_hreg(cpu,ra);
3743    
3744       ppc32_op_emit_load_gpr(cpu,hreg_rs,rs);
3745    
3746       iop = ppc32_op_emit_insn_output(cpu,1,"xoris");
3747    
3748       if (ra != rs)
3749          x86_mov_reg_reg(iop->ob_ptr,hreg_ra,hreg_rs,4);
3750    
3751       x86_alu_reg_imm(iop->ob_ptr,X86_XOR,hreg_ra,tmp);
3752       ppc32_op_emit_store_gpr(cpu,ra,hreg_ra);
3753    
3754     ppc32_load_imm(b,X86_EBX,imm << 16);     ppc32_jit_close_hreg_seq(cpu);
    ppc32_alu_gpr(b,X86_XOR,X86_EBX,rs);  
    ppc32_store_gpr(b,ra,X86_EBX);  
3755     return(0);     return(0);
3756  }  }
3757    
# Line 2512  struct ppc32_insn_tag ppc32_insn_tags[] Line 3772  struct ppc32_insn_tag ppc32_insn_tags[]
3772     { ppc32_emit_ADDIC      , 0xfc000000 , 0x30000000 },     { ppc32_emit_ADDIC      , 0xfc000000 , 0x30000000 },
3773     { ppc32_emit_ADDIC_dot  , 0xfc000000 , 0x34000000 },     { ppc32_emit_ADDIC_dot  , 0xfc000000 , 0x34000000 },
3774     { ppc32_emit_ADDIS      , 0xfc000000 , 0x3c000000 },     { ppc32_emit_ADDIS      , 0xfc000000 , 0x3c000000 },
3775       { ppc32_emit_ADDZE      , 0xfc00fffe , 0x7c000194 },
3776     { ppc32_emit_AND        , 0xfc0007fe , 0x7c000038 },     { ppc32_emit_AND        , 0xfc0007fe , 0x7c000038 },
3777     { ppc32_emit_ANDC       , 0xfc0007fe , 0x7c000078 },     { ppc32_emit_ANDC       , 0xfc0007fe , 0x7c000078 },
3778     { ppc32_emit_ANDI       , 0xfc000000 , 0x70000000 },     { ppc32_emit_ANDI       , 0xfc000000 , 0x70000000 },
Legend:
Removed from v.8  
changed lines
  Added in v.9
  ViewVC Help
Powered by ViewVC 1.1.26