dotgnu-pnet-commits
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[dotgnu-pnet-commits] libjit ChangeLog jit/jit-rules-x86.ins


From: Aleksey Demakov
Subject: [dotgnu-pnet-commits] libjit ChangeLog jit/jit-rules-x86.ins
Date: Thu, 08 Jun 2006 17:11:26 +0000

CVSROOT:        /sources/dotgnu-pnet
Module name:    libjit
Changes by:     Aleksey Demakov <avd>   06/06/08 17:11:26

Modified files:
        .              : ChangeLog 
        jit            : jit-rules-x86.ins 

Log message:
        rewrite some manual rules to use regular pattern syntax

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/libjit/ChangeLog?cvsroot=dotgnu-pnet&r1=1.234&r2=1.235
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-rules-x86.ins?cvsroot=dotgnu-pnet&r1=1.4&r2=1.5

Patches:
Index: ChangeLog
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/ChangeLog,v
retrieving revision 1.234
retrieving revision 1.235
diff -u -b -r1.234 -r1.235
--- ChangeLog   3 Jun 2006 13:39:53 -0000       1.234
+++ ChangeLog   8 Jun 2006 17:11:26 -0000       1.235
@@ -1,4 +1,13 @@
-2006-06-03  avd  <address@hidden>
+2006-06-09  Aleksey Demakov  <address@hidden>
+
+       * jit/jit-rules-x86.ins: rewrite JIT_OP_STORE_RELATIVE_BYTE,
+       JIT_OP_STORE_RELATIVE_SHORT, JIT_OP_STORE_RELATIVE_LONG,
+       JIT_OP_STORE_RELATIVE_FLOAT32, JIT_OP_STORE_RELATIVE_FLOAT64,
+       JIT_OP_STORE_RELATIVE_NFLOAT, JIT_OP_STORE_ELEMENT_LONG,
+       JIT_OP_STORE_ELEMENT_NFLOAT rules to use regular pattern
+       syntax instead of manual.
+
+2006-06-03  Aleksey Demakov  <address@hidden>
 
        * jit/jit-rules-x86.ins: remove _jit_regs_free_reg() call from
        JIT_OP_RETURN_FLOAT32, JIT_OP_PUSH_FLOAT32, JIT_OP_RETURN_FLOAT64,

Index: jit/jit-rules-x86.ins
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-rules-x86.ins,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -b -r1.4 -r1.5
--- jit/jit-rules-x86.ins       3 Jun 2006 13:39:53 -0000       1.4
+++ jit/jit-rules-x86.ins       8 Jun 2006 17:11:26 -0000       1.5
@@ -2359,151 +2359,32 @@
                                                   
jit_type_get_size(jit_value_get_type(insn->dest)));
        }
 
-JIT_OP_STORE_RELATIVE_BYTE: manual
-       [] -> {
-               unsigned char *inst;
-               int reg, reg2;
-               if(insn->dest->is_constant)
-               {
-                       reg = insn->dest->address + insn->value2->address;
-                       if(insn->value1->is_constant)
-                       {
-                               inst = gen->posn.ptr;
-                               if(!jit_cache_check_for_n(&(gen->posn), 32))
-                               {
-                                       jit_cache_mark_full(&(gen->posn));
-                                       return;
-                               }
-                               x86_mov_mem_imm(inst, reg, 
insn->value1->address, 1);
-                       }
-                       else
-                       {
-                               reg2 = _jit_regs_load_value
-                                       (gen, insn->value1, 0,
-                                        (insn->flags & 
(JIT_INSN_VALUE1_NEXT_USE |
-                                                                        
JIT_INSN_VALUE1_LIVE)));
-                               inst = gen->posn.ptr;
-                               if(!jit_cache_check_for_n(&(gen->posn), 32))
-                               {
-                                       jit_cache_mark_full(&(gen->posn));
-                                       return;
-                               }
-                               reg2 = _jit_reg_info[reg2].cpu_reg;
-                               x86_mov_mem_reg(inst, reg, reg2, 1);
-                       }
-                       gen->posn.ptr = inst;
-               }
-               else
-               {
-                       reg = _jit_regs_load_value
-                               (gen, insn->dest, 0,
-                                (insn->flags & (JIT_INSN_DEST_NEXT_USE |
-                                                                
JIT_INSN_DEST_LIVE)));
-                       if(!(insn->value1->is_constant))
-                       {
-                               reg2 = _jit_regs_load_value
-                                       (gen, insn->value1, 0,
-                                        (insn->flags & 
(JIT_INSN_VALUE1_NEXT_USE |
-                                                                        
JIT_INSN_VALUE1_LIVE)));
-                               inst = gen->posn.ptr;
-                               if(!jit_cache_check_for_n(&(gen->posn), 32))
-                               {
-                                       jit_cache_mark_full(&(gen->posn));
-                                       return;
-                               }
-                               reg  = _jit_reg_info[reg].cpu_reg;
-                               reg2 = _jit_reg_info[reg2].cpu_reg;
-                               inst = mov_membase_reg_byte
-                                       (inst, reg, insn->value2->address, 
reg2);
-                               gen->posn.ptr = inst;
-                       }
-                       else
-                       {
-                               inst = gen->posn.ptr;
-                               if(!jit_cache_check_for_n(&(gen->posn), 32))
-                               {
-                                       jit_cache_mark_full(&(gen->posn));
-                                       return;
+JIT_OP_STORE_RELATIVE_BYTE: ternary
+       [imm, imm, imm] -> {
+               x86_mov_mem_imm(inst, $1 + $3, $2, 1);
                                }
-                               reg = _jit_reg_info[reg].cpu_reg;
-                               x86_mov_membase_imm(inst, reg, 
insn->value2->address,
-                                                                       
insn->value1->address, 1);
-                               gen->posn.ptr = inst;
+       [imm, reg("eax"|"ecx"|"edx"|"ebx"), imm] -> {
+               x86_mov_mem_reg(inst, $1 + $3, $2, 1);
                        }
+       [reg, imm, imm] -> {
+               x86_mov_membase_imm(inst, $1, $3, $2, 1);
                }
+       [reg, reg("eax"|"ecx"|"edx"|"ebx"), imm] -> {
+               x86_mov_membase_reg(inst, $1, $3, $2, 1);
        }
 
-JIT_OP_STORE_RELATIVE_SHORT: manual
-       [] -> {
-               unsigned char *inst;
-               int reg, reg2;
-               if(insn->dest->is_constant)
-               {
-                       reg = insn->dest->address + insn->value2->address;
-                       if(insn->value1->is_constant)
-                       {
-                               inst = gen->posn.ptr;
-                               if(!jit_cache_check_for_n(&(gen->posn), 32))
-                               {
-                                       jit_cache_mark_full(&(gen->posn));
-                                       return;
-                               }
-                               x86_mov_mem_imm(inst, reg, 
insn->value1->address, 2);
-                       }
-                       else
-                       {
-                               reg2 = _jit_regs_load_value
-                                       (gen, insn->value1, 0,
-                                        (insn->flags & 
(JIT_INSN_VALUE1_NEXT_USE |
-                                                                        
JIT_INSN_VALUE1_LIVE)));
-                               inst = gen->posn.ptr;
-                               if(!jit_cache_check_for_n(&(gen->posn), 32))
-                               {
-                                       jit_cache_mark_full(&(gen->posn));
-                                       return;
-                               }
-                               reg2 = _jit_reg_info[reg2].cpu_reg;
-                               x86_mov_mem_reg(inst, reg, reg2, 2);
-                       }
-                       gen->posn.ptr = inst;
-               }
-               else
-               {
-                       reg = _jit_regs_load_value
-                               (gen, insn->dest, 0,
-                                (insn->flags & (JIT_INSN_DEST_NEXT_USE |
-                                                                
JIT_INSN_DEST_LIVE)));
-                       if(!(insn->value1->is_constant))
-                       {
-                               reg2 = _jit_regs_load_value
-                                       (gen, insn->value1, 0,
-                                        (insn->flags & 
(JIT_INSN_VALUE1_NEXT_USE |
-                                                                        
JIT_INSN_VALUE1_LIVE)));
-                               inst = gen->posn.ptr;
-                               if(!jit_cache_check_for_n(&(gen->posn), 32))
-                               {
-                                       jit_cache_mark_full(&(gen->posn));
-                                       return;
-                               }
-                               reg  = _jit_reg_info[reg].cpu_reg;
-                               reg2 = _jit_reg_info[reg2].cpu_reg;
-                               x86_mov_membase_reg(inst, reg, 
insn->value2->address, reg2, 2);
-                               gen->posn.ptr = inst;
-                       }
-                       else
-                       {
-                               inst = gen->posn.ptr;
-                               if(!jit_cache_check_for_n(&(gen->posn), 32))
-                               {
-                                       jit_cache_mark_full(&(gen->posn));
-                                       return;
+JIT_OP_STORE_RELATIVE_SHORT: ternary
+       [imm, imm, imm] -> {
+               x86_mov_mem_imm(inst, $1 + $3, $2, 2);
                                }
-                               reg = _jit_reg_info[reg].cpu_reg;
-                               x86_mov_membase_imm(inst, reg, 
insn->value2->address,
-                                                                       
insn->value1->address, 2);
-                               gen->posn.ptr = inst;
+       [imm, reg, imm] -> {
+               x86_mov_mem_reg(inst, $1 + $3, $2, 2);
                        }
+       [reg, imm, imm] -> {
+               x86_mov_membase_imm(inst, $1, $3, $2, 2);
                }
+       [reg, reg, imm] -> {
+               x86_mov_membase_reg(inst, $1, $3, $2, 2);
        }
 
 JIT_OP_STORE_RELATIVE_INT: ternary
@@ -2520,182 +2401,58 @@
                x86_mov_membase_reg(inst, $1, $3, $2, 4);
        }
 
-JIT_OP_STORE_RELATIVE_LONG: manual
-       [] -> {
-               unsigned char *inst;
-               int reg = _jit_regs_load_value
-                       (gen, insn->dest, 0,
-                        (insn->flags & (JIT_INSN_DEST_NEXT_USE |
-                                                        JIT_INSN_DEST_LIVE)));
-               int reg2, reg3;
-               int frame_offset;
-               if(!(insn->value1->is_constant))
-               {
-                       _jit_regs_get_reg_pair(gen, reg, -1, -1, &reg2, &reg3);
-                       _jit_gen_fix_value(insn->value1);
-                       inst = gen->posn.ptr;
-                       if(!jit_cache_check_for_n(&(gen->posn), 32))
-                       {
-                               jit_cache_mark_full(&(gen->posn));
-                               return;
-                       }
-                       reg  = _jit_reg_info[reg].cpu_reg;
-                       reg2 = _jit_reg_info[reg2].cpu_reg;
-                       reg3 = _jit_reg_info[reg3].cpu_reg;
-                       frame_offset = insn->value1->frame_offset;
-                       x86_mov_reg_membase(inst, reg2, X86_EBP, frame_offset, 
4);
-                       x86_mov_reg_membase(inst, reg3, X86_EBP, frame_offset + 
4, 4);
-                       x86_mov_membase_reg(inst, reg, insn->value2->address, 
reg2, 4);
-                       x86_mov_membase_reg(inst, reg, insn->value2->address + 
4, reg3, 4);
-                       gen->posn.ptr = inst;
-               }
-               else
-               {
-                       jit_long const_value = 
jit_value_get_long_constant(insn->value1);
-                       inst = gen->posn.ptr;
-                       if(!jit_cache_check_for_n(&(gen->posn), 32))
-                       {
-                               jit_cache_mark_full(&(gen->posn));
-                               return;
-                       }
-                       reg = _jit_reg_info[reg].cpu_reg;
-                       x86_mov_membase_imm
-                               (inst, reg, insn->value2->address,
-                                (jit_int)(const_value & jit_max_uint), 4);
-                       x86_mov_membase_imm
-                               (inst, reg, insn->value2->address + 4,
-                                (jit_int)((const_value >> 32) & jit_max_uint), 
4);
-                       gen->posn.ptr = inst;
+JIT_OP_STORE_RELATIVE_LONG: ternary
+       [reg, imm, imm, scratch("?")] -> {
+               x86_mov_reg_mem(inst, $4, $2, 4);
+               x86_mov_membase_reg(inst, $1, $3, $4, 4);
+               x86_mov_reg_mem(inst, $4, $2 + 4, 4);
+               x86_mov_membase_reg(inst, $1, $3 + 4, $4, 4);
+       }
+       [reg, local, imm, scratch("?")] -> {
+               x86_mov_reg_membase(inst, $4, X86_EBP, $2, 4);
+               x86_mov_membase_reg(inst, $1, $3, $4, 4);
+               x86_mov_reg_membase(inst, $4, X86_EBP, $2 + 4, 4);
+               x86_mov_membase_reg(inst, $1, $3 + 4, $4, 4);
                }
+       [reg, lreg, imm] -> {
+               x86_mov_membase_reg(inst, $1, $3, $2, 4);
+               x86_mov_membase_reg(inst, $1, $3 + 4, %2, 4);
        }
 
-JIT_OP_STORE_RELATIVE_FLOAT32: manual
-       [] -> {
-               unsigned char *inst;
-               int reg = _jit_regs_load_value
-                       (gen, insn->dest, 0,
-                        (insn->flags & (JIT_INSN_DEST_NEXT_USE |
-                                                        JIT_INSN_DEST_LIVE)));
-               if(!(insn->value1->is_constant))
-               {
-                       _jit_regs_load_to_top
-                               (gen, insn->value1,
-                                (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
-                                                                
JIT_INSN_VALUE1_LIVE)), 8);
-                       inst = gen->posn.ptr;
-                       if(!jit_cache_check_for_n(&(gen->posn), 32))
-                       {
-                               jit_cache_mark_full(&(gen->posn));
-                               return;
-                       }
-                       reg = _jit_reg_info[reg].cpu_reg;
-                       x86_fst_membase(inst, reg, insn->value2->address, 0, 1);
-                       gen->posn.ptr = inst;
-               }
-               else
-               {
-                       inst = gen->posn.ptr;
-                       if(!jit_cache_check_for_n(&(gen->posn), 32))
-                       {
-                               jit_cache_mark_full(&(gen->posn));
-                               return;
-                       }
-                       reg = _jit_reg_info[reg].cpu_reg;
-                       x86_mov_membase_imm(inst, reg, insn->value2->address,
-                                                               *((int 
*)(insn->value1->address)), 4);
-                       gen->posn.ptr = inst;
+JIT_OP_STORE_RELATIVE_FLOAT32: ternary
+       [reg, imm, imm] -> {
+               x86_mov_membase_imm(inst, $1, $3, ((int *)($2))[0], 4);
                }
+       [reg, freg, imm] -> {
+               x86_fst_membase(inst, $1, $3, 0, 1);
        }
 
-JIT_OP_STORE_RELATIVE_FLOAT64: manual
-       [] -> {
-               unsigned char *inst;
-               int reg = _jit_regs_load_value
-                       (gen, insn->dest, 0,
-                        (insn->flags & (JIT_INSN_DEST_NEXT_USE |
-                                                        JIT_INSN_DEST_LIVE)));
-               if(!(insn->value1->is_constant))
-               {
-                       _jit_regs_load_to_top
-                               (gen, insn->value1,
-                                (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
-                                                                
JIT_INSN_VALUE1_LIVE)), 8);
-                       inst = gen->posn.ptr;
-                       if(!jit_cache_check_for_n(&(gen->posn), 32))
-                       {
-                               jit_cache_mark_full(&(gen->posn));
-                               return;
-                       }
-                       reg = _jit_reg_info[reg].cpu_reg;
-                       x86_fst_membase(inst, reg, insn->value2->address, 1, 1);
-                       gen->posn.ptr = inst;
-               }
-               else
-               {
-                       inst = gen->posn.ptr;
-                       if(!jit_cache_check_for_n(&(gen->posn), 32))
-                       {
-                               jit_cache_mark_full(&(gen->posn));
-                               return;
-                       }
-                       reg = _jit_reg_info[reg].cpu_reg;
-                       x86_mov_membase_imm(inst, reg, insn->value2->address,
-                                                               ((int 
*)(insn->value1->address))[0], 4);
-                       x86_mov_membase_imm(inst, reg, insn->value2->address + 
4,
-                                                               ((int 
*)(insn->value1->address))[1], 4);
-                       gen->posn.ptr = inst;
+JIT_OP_STORE_RELATIVE_FLOAT64: ternary
+       [reg, imm, imm] -> {
+               x86_mov_membase_imm(inst, $1, $3, ((int *)($2))[0], 4);
+               x86_mov_membase_imm(inst, $1, $3 + 4, ((int *)($2))[1], 4);
                }
+       [reg, freg, imm] -> {
+               x86_fst_membase(inst, $1, $3, 1, 1);
        }
 
-JIT_OP_STORE_RELATIVE_NFLOAT: manual
-       [] -> {
-               unsigned char *inst;
-               int reg = _jit_regs_load_value
-                       (gen, insn->dest, 0,
-                        (insn->flags & (JIT_INSN_DEST_NEXT_USE |
-                                                        JIT_INSN_DEST_LIVE)));
-               if(!(insn->value1->is_constant))
-               {
-                       _jit_regs_load_to_top
-                               (gen, insn->value1,
-                                (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
-                                                                
JIT_INSN_VALUE1_LIVE)), 8);
-                       inst = gen->posn.ptr;
-                       if(!jit_cache_check_for_n(&(gen->posn), 32))
-                       {
-                               jit_cache_mark_full(&(gen->posn));
-                               return;
-                       }
-                       reg = _jit_reg_info[reg].cpu_reg;
+JIT_OP_STORE_RELATIVE_NFLOAT: ternary
+       [reg, imm, imm] -> {
+               x86_mov_membase_imm(inst, $1, $3, ((int *)($2))[0], 4);
+               x86_mov_membase_imm(inst, $1, $3 + 4, ((int *)($2))[1], 4);
                        if(sizeof(jit_nfloat) != sizeof(jit_float64))
                        {
-                               x86_fst80_membase(inst, reg, 
insn->value2->address);
-                       }
-                       else
-                       {
-                               x86_fst_membase(inst, reg, 
insn->value2->address, 1, 1);
-                       }
-                       gen->posn.ptr = inst;
+                       x86_mov_membase_imm(inst, $1, $3 + 8, ((int *)($2))[2], 
4);
                }
-               else
-               {
-                       inst = gen->posn.ptr;
-                       if(!jit_cache_check_for_n(&(gen->posn), 32))
-                       {
-                               jit_cache_mark_full(&(gen->posn));
-                               return;
                        }
-                       reg = _jit_reg_info[reg].cpu_reg;
-                       x86_mov_membase_imm(inst, reg, insn->value2->address,
-                                                               ((int 
*)(insn->value1->address))[0], 4);
-                       x86_mov_membase_imm(inst, reg, insn->value2->address + 
4,
-                                                               ((int 
*)(insn->value1->address))[1], 4);
+       [reg, freg, imm] -> {
                        if(sizeof(jit_nfloat) != sizeof(jit_float64))
                        {
-                               x86_mov_membase_imm(inst, reg, 
insn->value2->address + 8,
-                                                                       ((int 
*)(insn->value1->address))[2], 4);
+                       x86_fst80_membase(inst, $1, $3);
                        }
-                       gen->posn.ptr = inst;
+               else
+               {
+                       x86_fst_membase(inst, $1, $3, 1, 1);
                }
        }
 
@@ -2895,42 +2652,22 @@
                x86_mov_memindex_reg(inst, $1, 0, $2, 2, $3, 4);
        }
 
-JIT_OP_STORE_ELEMENT_LONG: manual
-       [] -> {
-               unsigned char *inst;
-               int reg, reg2, reg3, reg4;
-               int frame_offset;
-
-               _jit_regs_force_out(gen, insn->value2, 1);
-               _jit_gen_fix_value(insn->value2);
-               reg = _jit_regs_load_value
-                       (gen, insn->dest, 0,
-                        (insn->flags & (JIT_INSN_DEST_NEXT_USE |
-                                                        JIT_INSN_DEST_LIVE)));
-               reg2 = _jit_regs_load_value
-                       (gen, insn->value1, 0,
-                        (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
-                                                        
JIT_INSN_VALUE1_LIVE)));
-               _jit_regs_get_reg_pair(gen, reg, reg2, -1, &reg3, &reg4);
-
-               inst = gen->posn.ptr;
-               if(!jit_cache_check_for_n(&(gen->posn), 32))
-               {
-                       jit_cache_mark_full(&(gen->posn));
-                       return;
-               }
-               reg = _jit_reg_info[reg].cpu_reg;
-               reg2 = _jit_reg_info[reg2].cpu_reg;
-               reg3 = _jit_reg_info[reg3].cpu_reg;
-               reg4 = _jit_reg_info[reg4].cpu_reg;
-               frame_offset = insn->value2->frame_offset;
-
-               x86_mov_reg_membase(inst, reg3, X86_EBP, frame_offset, 4);
-               x86_mov_reg_membase(inst, reg4, X86_EBP, frame_offset + 4, 4);
-               x86_mov_memindex_reg(inst, reg, 0, reg2, 3, reg3, 4);
-               x86_mov_memindex_reg(inst, reg, 4, reg2, 3, reg4, 4);
-
-               gen->posn.ptr = inst;
+JIT_OP_STORE_ELEMENT_LONG: ternary
+       [reg, reg, imm, scratch("?")] -> {
+               x86_mov_reg_mem(inst, $4, $3, 4);
+               x86_mov_memindex_reg(inst, $1, 0, $2, 3, $4, 4);
+               x86_mov_reg_mem(inst, $4, $3 + 4, 4);
+               x86_mov_memindex_reg(inst, $1, 4, $2, 3, $4, 4);
+       }
+       [reg, reg, local, scratch("?")] -> {
+               x86_mov_reg_membase(inst, $4, X86_EBP, $3, 4);
+               x86_mov_memindex_reg(inst, $1, 0, $2, 3, $4, 4);
+               x86_mov_reg_membase(inst, $4, X86_EBP, $3 + 4, 4);
+               x86_mov_memindex_reg(inst, $1, 4, $2, 3, $4, 4);
+       }
+       [reg, reg, lreg] -> {
+               x86_mov_memindex_reg(inst, $1, 0, $2, 3, $3, 4);
+               x86_mov_memindex_reg(inst, $1, 4, $2, 3, %3, 4);
        }
 
 JIT_OP_STORE_ELEMENT_FLOAT32: ternary
@@ -2943,44 +2680,15 @@
                x86_fst_memindex(inst, $1, 0, $2, 3, 1, 1);
        }
 
-JIT_OP_STORE_ELEMENT_NFLOAT: manual
-       [] -> {
-               unsigned char *inst;
-               int reg, reg2, reg3;
-
-               reg = _jit_regs_load_value
-                       (gen, insn->dest, 0,
-                        (insn->flags & (JIT_INSN_DEST_NEXT_USE | 
JIT_INSN_DEST_LIVE)));
-               reg2 = _jit_regs_load_value
-                       (gen, insn->value1, sizeof(jit_nfloat) != 
sizeof(jit_float64),
-                        (insn->flags & (JIT_INSN_VALUE1_NEXT_USE | 
JIT_INSN_VALUE1_LIVE)));
-               reg3 = _jit_regs_load_value
-                       (gen, insn->value2, 0,
-                        (insn->flags & (JIT_INSN_VALUE2_NEXT_USE | 
JIT_INSN_VALUE2_LIVE)));
-
-               inst = (unsigned char *)(gen->posn.ptr);
-               if(!jit_cache_check_for_n(&(gen->posn), 32))
-               {
-                       jit_cache_mark_full(&(gen->posn));
-                       return;
-               }
-
-               reg = _jit_reg_info[reg].cpu_reg;
-               reg2 = _jit_reg_info[reg2].cpu_reg;
-
-               if(sizeof(jit_nfloat) != sizeof(jit_float64))
-               {
+JIT_OP_STORE_ELEMENT_NFLOAT: ternary
+       [reg, +reg, freg, if("sizeof(jit_nfloat) != sizeof(jit_float64)")] -> {
                        /* lea reg2, [reg2 + reg2 * 2]  */
-                       x86_lea_memindex(inst, reg2, reg2, 0, reg2, 1);
+               x86_lea_memindex(inst, $2, $2, 0, $2, 1);
                        /* fst [reg2 * 4] */
-                       x86_fst80_memindex(inst, reg, 0, reg2, 2);
+               x86_fst80_memindex(inst, $1, 0, $2, 2);
                }
-               else
-               {
-                       x86_fst_memindex(inst, reg, 0, reg2, 3, 1, 1);
-               }
-
-               gen->posn.ptr = (unsigned char *)inst;
+       [reg, reg, freg, if("sizeof(jit_nfloat) == sizeof(jit_float64)")] -> {
+               x86_fst_memindex(inst, $1, 0, $2, 3, 1, 1);
        }
 
 /*




reply via email to

[Prev in Thread] Current Thread [Next in Thread]