cvsuser     02/08/13 11:03:44

  Modified:    .        jit.c
               include/parrot jit.h
               jit/alpha jit_emit.h
               jit/arm  jit_emit.h
               jit/i386 jit_emit.h
               jit/ppc  core.jit jit_emit.h
               jit/sun4 jit_emit.h
  Log:
  Extends the register allocator to allocate float registers.
  
  Revision  Changes    Path
  1.28      +89 -13    parrot/jit.c
  
  Index: jit.c
  ===================================================================
  RCS file: /cvs/public/parrot/jit.c,v
  retrieving revision 1.27
  retrieving revision 1.28
  diff -u -w -r1.27 -r1.28
  --- jit.c     9 Aug 2002 04:26:46 -0000       1.27
  +++ jit.c     13 Aug 2002 18:00:34 -0000      1.28
  @@ -1,7 +1,7 @@
   /*
    * jit.c
    *
  - * $Id: jit.c,v 1.27 2002/08/09 04:26:46 grunblatt Exp $
  + * $Id: jit.c,v 1.28 2002/08/13 18:00:34 grunblatt Exp $
    */
   
   #include <parrot/parrot.h>
  @@ -122,8 +122,12 @@
       cur_section->begin = code_start;
       cur_section->jit_op_count = 0;
       /* Init the register usage */ 
  -    for (i = 0; i < NUM_REGISTERS; i++)
  +    for (i = 0; i < NUM_REGISTERS; i++) {
           cur_section->int_reg_usage[i] = i;
  +#if FLOAT_REGITERS_TO_MAP
  +        cur_section->float_reg_usage[i] = i;
  +#endif
  +    }
       
       cur_op = code_start;
       while (cur_op < code_end) { 
  @@ -155,6 +159,17 @@
                           cur_section->int_reg_dir[*(cur_op + argn)] |= 
                               PARROT_ARGDIR_OUT;
                   }
  +#if FLOAT_REGITERS_TO_MAP
  +                else if (op_info->types[argn] == PARROT_ARG_N) {
  +                    if ((!cur_section->float_reg_count[*(cur_op + argn)]++) &&
  +                        (op_info->dirs[argn] & PARROT_ARGDIR_IN)) 
  +                            cur_section->float_reg_dir[*(cur_op + argn)] |=
  +                                PARROT_ARGDIR_IN;
  +                    if (op_info->dirs[argn] & PARROT_ARGDIR_OUT)
  +                        cur_section->float_reg_dir[*(cur_op + argn)] |= 
  +                            PARROT_ARGDIR_OUT;
  +                }
  +#endif
               }
               /* If we are here means the current section is jitted, so if the
                  next opcode is not end the section. */
  @@ -194,13 +209,21 @@
               /* Set to 0 the register count, just in case ... */
               memset(cur_section->int_reg_count, 0, 
                   NUM_REGISTERS * sizeof(INTVAL));
  +#if FLOAT_REGITERS_TO_MAP
  +            memset(cur_section->float_reg_count, 0, 
  +                NUM_REGISTERS * sizeof(INTVAL));
  +#endif
               /* No next section yet */
               cur_section->next=NULL;
               /* 0 jitted opcodes  */
               cur_section->jit_op_count = 0;
               /* Init the register usage */ 
  -            for (i = 0; i < NUM_REGISTERS; i++)
  +            for (i = 0; i < NUM_REGISTERS; i++) {
                   cur_section->int_reg_usage[i] = i;
  +#if FLOAT_REGITERS_TO_MAP
  +                cur_section->float_reg_usage[i] = i;
  +#endif
  +            }
           } 
          
           /* Move to the next opcode */
  @@ -220,18 +243,26 @@
       while (cur_section) {
           /* Test register 0 first */
           if (cur_section->int_reg_count[0])
  -            cur_section->registers_used = 1;
  +            cur_section->int_registers_used = 1;
  +#if FLOAT_REGITERS_TO_MAP
  +        if (cur_section->float_reg_count[0])
  +            cur_section->float_registers_used = 1;
  +#endif
           /* Sort the registers by the usage,
              Start from the register number 1 since we compare it with the    
              previous one */
           for (i = 1; i < NUM_REGISTERS; i++) {
               /* If the register is not used continue to the next one */
  -            if (!cur_section->int_reg_count[i])
  +            if (!cur_section->int_reg_count[i] && !cur_section->float_reg_count[i])
                   continue;
               /* Count the number of hardware registers that is going to be
                  used in this section */
  -            if (cur_section->registers_used < MAX_REGITERS_TO_MAP)
  -                cur_section->registers_used++;
  +            if (cur_section->int_registers_used < INT_REGITERS_TO_MAP)
  +                cur_section->int_registers_used++;
  +#if FLOAT_REGITERS_TO_MAP
  +            if (cur_section->float_registers_used < FLOAT_REGITERS_TO_MAP)
  +                cur_section->float_registers_used++;
  +#endif
               
               /* Any register before this one */
               for (j = 0; j < i; j++) {
  @@ -251,6 +282,22 @@
                       /* Continue with the next register */
                       break;
                   }
  +#if FLOAT_REGITERS_TO_MAP
  +                if (cur_section->float_reg_count[i] > 
  +                  cur_section->float_reg_count[cur_section->float_reg_usage[j]])
  +                {
  +                    /* Move all the registers from the j'th position to
  +                       the next one */
  +                    for (k = i; k > j; k--)
  +                        cur_section->float_reg_usage[k] = 
  +                            cur_section->float_reg_usage[k - 1];
  +                    
  +                    /* Update the position of the register */
  +                    cur_section->float_reg_usage[j] = i;
  +                    /* Continue with the next register */
  +                    break;
  +                }
  +#endif
               }
           }
           /* Set the branch target of this section, that is the section where
  @@ -289,17 +336,31 @@
                   /* If the argument is an integer register */
                   if (op_info->types[op_arg] == PARROT_ARG_I) {
                       /* If the argument is in most used list */
  -                    for (i = 0; i < MAX_REGITERS_TO_MAP; i++)
  +                    for (i = 0; i < INT_REGITERS_TO_MAP; i++)
                           if (cur_op[op_arg] == 
                               (opcode_t)cur_section->int_reg_usage[i])
                           {
                               map[cur_op + op_arg - code_start] =
  -                                register_map[i];
  +                                intval_map[i];
                               cur_section->maps++;
                               break;
                           }
                   }
  -            
  +#if FLOAT_REGITERS_TO_MAP
  +                /* If the argument is a float register */
  +                if (op_info->types[op_arg] == PARROT_ARG_N) {
  +                    /* If the argument is in most used list */
  +                    for (i = 0; i < FLOAT_REGITERS_TO_MAP; i++)
  +                        if (cur_op[op_arg] == 
  +                            (opcode_t)cur_section->float_reg_usage[i])
  +                        {
  +                            map[cur_op + op_arg - code_start] =
  +                                floatval_map[i];
  +                            cur_section->maps++;
  +                            break;
  +                        }
  +                }
  +#endif
               }
   
               /* Move to the next opcode */
  @@ -328,8 +389,19 @@
           fprintf(stderr, "\n\tInt register direction:\t");
           for (i = 0; i < NUM_REGISTERS; i++)
               fprintf(stderr, "%i ", (int)cur_section->int_reg_dir[i]);
  -        fprintf(stderr, "\n\tRegisters used:\t%i\n", 
  -            cur_section->registers_used);
  +        fprintf(stderr, "\n\tInt registers used:\t%i\n", 
  +            cur_section->int_registers_used);
  +        fprintf(stderr, "\tFloat register count:\t");
  +        for (i = 0; i < NUM_REGISTERS; i++)
  +            fprintf(stderr, "%i ", cur_section->float_reg_count[i]);
  +        fprintf(stderr, "\n\tFloat register usage:\t");
  +        for (i = 0; i < NUM_REGISTERS; i++)
  +            fprintf(stderr, "%i ", cur_section->float_reg_usage[i]);
  +        fprintf(stderr, "\n\tFloat register direction:\t");
  +        for (i = 0; i < NUM_REGISTERS; i++)
  +            fprintf(stderr, "%i ", (int)cur_section->float_reg_dir[i]);
  +        fprintf(stderr, "\n\tFloat Registers used:\t%i\n", 
  +            cur_section->float_registers_used);
           fprintf(stderr, "\tJit opcodes:\t%i\n", cur_section->jit_op_count);
           fprintf(stderr, "\tTotal opcodes:\t%i\n", cur_section->op_count);
           cur_section = cur_section->next;
  @@ -356,7 +428,11 @@
       jit_info.optimizer = optimize_jit(interpreter,pc,code_start,code_end); 
   
       /* Attach the register map to the jit_info structure */
  -    jit_info.register_map = register_map;
  +    jit_info.intval_map = intval_map;
  +#if FLOAT_REGITERS_TO_MAP
  +    jit_info.floatval_map = floatval_map;
  +#endif
  +
   
       /* Byte code size in opcode_t's */
       jit_info.arena.map_size = (code_end - code_start) + 1;
  
  
  
  1.19      +30 -22    parrot/include/parrot/jit.h
  
  Index: jit.h
  ===================================================================
  RCS file: /cvs/public/parrot/include/parrot/jit.h,v
  retrieving revision 1.18
  retrieving revision 1.19
  diff -u -w -r1.18 -r1.19
  --- jit.h     5 Aug 2002 03:09:10 -0000       1.18
  +++ jit.h     13 Aug 2002 18:01:06 -0000      1.19
  @@ -1,7 +1,7 @@
   /*
    * jit.h
    *
  - * $Id: jit.h,v 1.18 2002/08/05 03:09:10 grunblatt Exp $
  + * $Id: jit.h,v 1.19 2002/08/13 18:01:06 grunblatt Exp $
    */
   
   #ifndef JIT_H_GUARD
  @@ -87,17 +87,20 @@
    *                  section.
    *  int_reg_usage:  An array with the registers sorted by the usage.
    *  int_reg_dir:    If the register needs to be loaded or saved.
  - *  arena:          The first arena for this section, or NULL if the section is
  - *                  in the arena inlined in jit_info.
  - *  registers_used: The number of used registers.
  + *  float_reg_count:    Same as int_ but for floats.
  + *  float_reg_usage:    Same as int_ but for floats.
  + *  float_reg_dir:      Same as int_ but for floats.
  + *  arena:              The first arena for this section, or NULL if the 
  + *                      section is in the arena inlined in jit_info.
  + *  int_registers_used: The number of used registers.
    *  maps:           Total maps done. 
    *  jit_op_count:   How many opcodes are jitted.
    *  op_count:       Opcodes in this section.
  - *  load_size:      The size of the register load instructions to be skipped in
  - *                  an in-section branch.
  + *  load_size:          The size of the register load instructions to be 
  + *                      skipped in an in-section branch.
    *  type:           If this section is a jitted one or not.
  - *  branch_target:  The section where execution continues if this section ends
  - *                  at a branch source the targeted section is used.
  + *  branch_target:      The section where execution continues if this section 
  + *                      ends at a branch source the targeted section is used.
    */
   
   typedef struct Parrot_jit_optimizer_section *Parrot_jit_optimizer_section_ptr;
  @@ -108,8 +111,12 @@
       Parrot_jit_register_count_t          int_reg_count[NUM_REGISTERS];
       Parrot_jit_register_usage_t          int_reg_usage[NUM_REGISTERS];
       Parrot_jit_register_dir_t            int_reg_dir[NUM_REGISTERS];
  +    unsigned char                        int_registers_used;
  +    Parrot_jit_register_count_t          float_reg_count[NUM_REGISTERS];
  +    Parrot_jit_register_usage_t          float_reg_usage[NUM_REGISTERS];
  +    Parrot_jit_register_dir_t            float_reg_dir[NUM_REGISTERS];
  +    unsigned char                        float_registers_used;
       Parrot_jit_arena_t                  *arena;
  -    unsigned char                        registers_used;
       unsigned int                         maps;
       unsigned int                         jit_op_count;
       unsigned int                         op_count;
  @@ -153,7 +160,7 @@
       INTVAL                          *slot_ptr;
   } Parrot_jit_constant_pool_t;
   
  -/*  Parrot_jit_info
  +/*  Parrot_jit_info_t
    *      All the information needed to jit the bytecode will be here.
    *      
    *  prev_op:        The previous opcode in this section.
  @@ -174,7 +181,8 @@
       Parrot_jit_arena_t               arena;
       Parrot_jit_optimizer_t          *optimizer;
       Parrot_jit_constant_pool_t      *constant_pool;
  -    char                            *register_map;
  +    char                            *intval_map;
  +    char                            *floatval_map;
   } Parrot_jit_info_t;
   
   #define Parrot_jit_fixup_target(jit_info, fixup) \
  
  
  
  1.5       +4 -3      parrot/jit/alpha/jit_emit.h
  
  Index: jit_emit.h
  ===================================================================
  RCS file: /cvs/public/parrot/jit/alpha/jit_emit.h,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -w -r1.4 -r1.5
  --- jit_emit.h        4 Aug 2002 21:41:52 -0000       1.4
  +++ jit_emit.h        13 Aug 2002 18:01:38 -0000      1.5
  @@ -3,7 +3,7 @@
    * 
    * ALPHA
    *
  - * $Id: jit_emit.h,v 1.4 2002/08/04 21:41:52 grunblatt Exp $
  + * $Id: jit_emit.h,v 1.5 2002/08/13 18:01:38 grunblatt Exp $
    */
   
   /*  Register usage:
  @@ -502,9 +502,10 @@
   #else
   
   #  define REQUIRES_CONSTANT_POOL 1
  -#  define MAX_REGITERS_TO_MAP 21
  +#  define INT_IREGITERS_TO_MAP 21
  +#  define FLOAT_REGITERS_TO_MAP 0
   
  -char register_map[MAX_REGITERS_TO_MAP] =
  +char intval_map[INT_REGITERS_TO_MAP] =
       { REG1_t0, REG2_t1, REG3_t2, REG4_t3, REG5_t4, REG6_t5, REG7_t6, REG12_s3,
         REG13_s4, REG14_s5, REG16_a0, REG17_a1, REG18_a2, REG19_a3, REG20_a4,
         REG21_a5, REG22_t8, REG23_t9, REG24_t10, REG25_t11, REG28_at };
  
  
  
  1.8       +4 -3      parrot/jit/arm/jit_emit.h
  
  Index: jit_emit.h
  ===================================================================
  RCS file: /cvs/public/parrot/jit/arm/jit_emit.h,v
  retrieving revision 1.7
  retrieving revision 1.8
  diff -u -w -r1.7 -r1.8
  --- jit_emit.h        7 Aug 2002 00:52:18 -0000       1.7
  +++ jit_emit.h        13 Aug 2002 18:02:09 -0000      1.8
  @@ -3,7 +3,7 @@
    * 
    * ARM (I think this is all ARM2 or later, although it is APCS-32)
    *
  - * $Id: jit_emit.h,v 1.7 2002/08/07 00:52:18 grunblatt Exp $
  + * $Id: jit_emit.h,v 1.8 2002/08/13 18:02:09 grunblatt Exp $
    */
   
   #ifdef ARM
  @@ -984,9 +984,10 @@
   #else
   
   #  define REQUIRES_CONSTANT_POOL 0
  -#  define MAX_REGITERS_TO_MAP 10
  +#  define INT_REGITERS_TO_MAP 10
  +#  define FLOAT_REGITERS_TO_MAP 0
   
  -char register_map[MAX_REGITERS_TO_MAP] =
  +char register_map[INT_REGITERS_TO_MAP] =
       { r0, r1, r2, r3, r4, r5, r6, r7, r8, r12 };
   
   static void
  
  
  
  1.7       +15 -14    parrot/jit/i386/jit_emit.h
  
  Index: jit_emit.h
  ===================================================================
  RCS file: /cvs/public/parrot/jit/i386/jit_emit.h,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -w -r1.6 -r1.7
  --- jit_emit.h        4 Aug 2002 21:42:55 -0000       1.6
  +++ jit_emit.h        13 Aug 2002 18:02:41 -0000      1.7
  @@ -1,10 +1,10 @@
   /*
  -** jit_emit.h
  -** 
  -** i386
  -**
  -** $Id: jit_emit.h,v 1.6 2002/08/04 21:42:55 grunblatt Exp $
  -**/
  + * jit_emit.h
  + * 
  + * i386
  + *
  + * $Id: jit_emit.h,v 1.7 2002/08/13 18:02:41 grunblatt Exp $
  + */
   
   /* Register codes */
   #define emit_None 0 
  @@ -990,11 +990,11 @@
                             struct Parrot_Interp * interpreter)
   {
       Parrot_jit_optimizer_section_t *cur_se = jit_info->optimizer->cur_section;
  -    int i = cur_se->registers_used;
  +    int i = cur_se->int_registers_used;
   
       while (i--)
           if (cur_se->int_reg_dir[cur_se->int_reg_usage[i]] & PARROT_ARGDIR_IN)
  -            emit_movl_m_r(jit_info->native_ptr, jit_info->register_map[i],
  +            emit_movl_m_r(jit_info->native_ptr, jit_info->intval_map[i],
                   &interpreter->ctx.int_reg.registers[cur_se->int_reg_usage[i]]);
   
       /* The total size of the loads */
  @@ -1011,23 +1011,24 @@
                             struct Parrot_Interp * interpreter)
   {
       Parrot_jit_optimizer_section_t *cur_se = jit_info->optimizer->cur_section;
  -    int i = cur_se->registers_used;
  +    int i = cur_se->int_registers_used;
   
       while (i--)
           if (cur_se->int_reg_dir[cur_se->int_reg_usage[i]] & PARROT_ARGDIR_OUT)
  -            emit_movl_r_m(jit_info->native_ptr, jit_info->register_map[i],
  +            emit_movl_r_m(jit_info->native_ptr, jit_info->intval_map[i],
                   &interpreter->ctx.int_reg.registers[cur_se->int_reg_usage[i]]);
   }
   
  -#else /* DEFINE_ROUTINES */
  +#else /* JIT_EMIT */
   
   #  define REQUIRES_CONSTANT_POOL 0
  -#  define MAX_REGITERS_TO_MAP 4
  +#  define INT_REGITERS_TO_MAP 4
  +#  define FLOAT_REGITERS_TO_MAP 0
   
  -char register_map[MAX_REGITERS_TO_MAP] =
  +char intval_map[INT_REGITERS_TO_MAP] =
       { emit_EDI, emit_EBX, emit_EDX, emit_ECX };
   
  -#endif /* DEFINE_ROUTINES */
  +#endif /* JIT_EMIT */
   
   /*
    * Local variables:
  
  
  
  1.5       +558 -187  parrot/jit/ppc/core.jit
  
  Index: core.jit
  ===================================================================
  RCS file: /cvs/public/parrot/jit/ppc/core.jit,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -w -r1.4 -r1.5
  --- core.jit  10 Aug 2002 16:45:51 -0000      1.4
  +++ core.jit  13 Aug 2002 18:03:12 -0000      1.5
  @@ -2,7 +2,7 @@
   ; ppc/core.jit
   ;
   ;
  -; $Id: core.jit,v 1.4 2002/08/10 16:45:51 grunblatt Exp $
  +; $Id: core.jit,v 1.5 2002/08/13 18:03:12 grunblatt Exp $
   ;
   
   Parrot_end {
  @@ -40,10 +40,16 @@
   }
   
   Parrot_set_n_nc {
  +    if (MAP[1]) {
  +        emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  +        emit_lfd(NATIVECODE, MAP[1], 0, r12);
  +    }
  +    else {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
       emit_lfd(NATIVECODE, r12, 0, r12);
       emit_stfd_r(NATIVECODE, r12, &NUM_REG[1]); 
   }
  +}
   
   Parrot_neg_i_i {
       if (MAP[1] && MAP[2]) {
  @@ -507,71 +513,281 @@
   }
   
   Parrot_neg_n_n {
  -        emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -        emit_fneg(NATIVECODE, r12, r12);
  -        emit_stfd_r(NATIVECODE, r12, &NUM_REG[1]);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fneg(NATIVECODE, MAP[1], MAP[2]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fneg(NATIVECODE, MAP[1], f12);
  +    }
  +    else if (MAP[2]) {
  +        emit_fneg(NATIVECODE, f12, MAP[2]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fneg(NATIVECODE, f12, f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
   }
   
   Parrot_abs_n_n {
  -        emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -        emit_fabs(NATIVECODE, r12, r12);
  -        emit_stfd_r(NATIVECODE, r12, &NUM_REG[1]);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fabs(NATIVECODE, MAP[1], MAP[2]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fabs(NATIVECODE, MAP[1], f12);
  +    }
  +    else if (MAP[2]) {
  +        emit_fabs(NATIVECODE, f12, MAP[2]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fabs(NATIVECODE, f12, f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
   }
   
   Parrot_add_n_n_n {
  -        emit_lfd_r(NATIVECODE, r11, &NUM_REG[2]);
  -        emit_lfd_r(NATIVECODE, r12, &NUM_REG[3]);
  -        emit_fadd(NATIVECODE, r12, r11, r12);
  -        emit_stfd_r(NATIVECODE, r12, &NUM_REG[1]);
  +    if (MAP[1] && MAP[2] && MAP[3]) {
  +        emit_fadd(NATIVECODE, MAP[1], MAP[2], MAP[3]);
  +    }
  +    else if (MAP[1] && MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fadd(NATIVECODE, MAP[1], MAP[2], f12);
  +    }
  +    else if (MAP[1] && MAP[3]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fadd(NATIVECODE, MAP[1], MAP[3], f12);
  +    }
  +    else if (MAP[2] && MAP[3]) {
  +        emit_fadd(NATIVECODE, f12, MAP[2], MAP[3]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fadd(NATIVECODE, MAP[1], f11, f12);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fadd(NATIVECODE, f12, MAP[2], f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else if (MAP[3]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fadd(NATIVECODE, f12, MAP[3], f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fadd(NATIVECODE, f12, f11, f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
   }
   
   Parrot_add_n_n {
  -        emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  -        emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -        emit_fadd(NATIVECODE, r12, r11, r12);
  -        emit_stfd_r(NATIVECODE, r12, &NUM_REG[1]);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fadd(NATIVECODE, MAP[1], MAP[1], MAP[2]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fadd(NATIVECODE, MAP[1], MAP[1], f12);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +        emit_fadd(NATIVECODE, f12, f12, MAP[2]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fadd(NATIVECODE, f12, f11, f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
   }
   
   Parrot_div_n_n_n {
  -        emit_lfd_r(NATIVECODE, r11, &NUM_REG[2]);
  -        emit_lfd_r(NATIVECODE, r12, &NUM_REG[3]);
  -        emit_fdiv(NATIVECODE, r12, r11, r12);
  -        emit_stfd_r(NATIVECODE, r12, &NUM_REG[1]);
  +    if (MAP[1] && MAP[2] && MAP[3]) {
  +        emit_fdiv(NATIVECODE, MAP[1], MAP[2], MAP[3]);
  +    }
  +    else if (MAP[1] && MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fdiv(NATIVECODE, MAP[1], MAP[2], f12);
  +    }
  +    else if (MAP[1] && MAP[3]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fdiv(NATIVECODE, MAP[1], f12, MAP[3]);
  +    }
  +    else if (MAP[2] && MAP[3]) {
  +        emit_fdiv(NATIVECODE, f12, MAP[2], MAP[3]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fdiv(NATIVECODE, MAP[1], f11, f12);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fdiv(NATIVECODE, f12, MAP[2], f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else if (MAP[3]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fdiv(NATIVECODE, f12, f12, MAP[3]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fdiv(NATIVECODE, f12, f11, f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
   }
   
   Parrot_div_n_n {
  -        emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  -        emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -        emit_fdiv(NATIVECODE, r12, r11, r12);
  -        emit_stfd_r(NATIVECODE, r12, &NUM_REG[1]);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fdiv(NATIVECODE, MAP[1], MAP[1], MAP[2]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fdiv(NATIVECODE, MAP[1], MAP[1], f12);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +        emit_fdiv(NATIVECODE, f12, f12, MAP[2]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fdiv(NATIVECODE, f12, f11, f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
   }
   
   Parrot_mul_n_n_n {
  -        emit_lfd_r(NATIVECODE, r11, &NUM_REG[2]);
  -        emit_lfd_r(NATIVECODE, r12, &NUM_REG[3]);
  -        emit_fmul(NATIVECODE, r12, r11, r12);
  -        emit_stfd_r(NATIVECODE, r12, &NUM_REG[1]);
  +    if (MAP[1] && MAP[2] && MAP[3]) {
  +        emit_fmul(NATIVECODE, MAP[1], MAP[2], MAP[3]);
  +    }
  +    else if (MAP[1] && MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fmul(NATIVECODE, MAP[1], MAP[2], f12);
  +    }
  +    else if (MAP[1] && MAP[3]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fmul(NATIVECODE, MAP[1], f12, MAP[3]);
  +    }
  +    else if (MAP[2] && MAP[3]) {
  +        emit_fmul(NATIVECODE, f12, MAP[2], MAP[3]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fmul(NATIVECODE, MAP[1], f11, f12);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fmul(NATIVECODE, f12, MAP[2], f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else if (MAP[3]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fmul(NATIVECODE, f12, f12, MAP[3]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fmul(NATIVECODE, f12, f11, f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
   }
   
   Parrot_mul_n_n {
  -        emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  -        emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -        emit_fmul(NATIVECODE, r12, r11, r12);
  -        emit_stfd_r(NATIVECODE, r12, &NUM_REG[1]);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fmul(NATIVECODE, MAP[1], MAP[1], MAP[2]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fmul(NATIVECODE, MAP[1], MAP[1], f12);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +        emit_fmul(NATIVECODE, f12, f12, MAP[2]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fmul(NATIVECODE, f12, f11, f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
   }
   
   Parrot_sub_n_n_n {
  -        emit_lfd_r(NATIVECODE, r11, &NUM_REG[2]);
  -        emit_lfd_r(NATIVECODE, r12, &NUM_REG[3]);
  -        emit_fsub(NATIVECODE, r12, r11, r12);
  -        emit_stfd_r(NATIVECODE, r12, &NUM_REG[1]);
  +    if (MAP[1] && MAP[2] && MAP[3]) {
  +        emit_fsub(NATIVECODE, MAP[1], MAP[2], MAP[3]);
  +    }
  +    else if (MAP[1] && MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fsub(NATIVECODE, MAP[1], MAP[2], f12);
  +    }
  +    else if (MAP[1] && MAP[3]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fsub(NATIVECODE, MAP[1], f12, MAP[3]);
  +    }
  +    else if (MAP[2] && MAP[3]) {
  +        emit_fsub(NATIVECODE, f12, MAP[2], MAP[3]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fsub(NATIVECODE, MAP[1], f11, f12);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fsub(NATIVECODE, f12, MAP[2], f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else if (MAP[3]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fsub(NATIVECODE, f12, f12, MAP[3]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[3]);
  +        emit_fsub(NATIVECODE, f12, f11, f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
   }
   
   Parrot_sub_n_n {
  -        emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  -        emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -        emit_fsub(NATIVECODE, r12, r11, r12);
  -        emit_stfd_r(NATIVECODE, r12, &NUM_REG[1]);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fsub(NATIVECODE, MAP[1], MAP[1], MAP[2]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fsub(NATIVECODE, MAP[1], MAP[1], f12);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +        emit_fsub(NATIVECODE, f12, f12, MAP[2]);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fsub(NATIVECODE, f12, f11, f12);
  +        emit_stfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +    }
   }
   
   Parrot_if_i_ic {
  @@ -636,10 +852,8 @@
   }
   
   Parrot_gt_ic_ic_ic {
  -    emit_imm32(NATIVECODE, r11, *INT_CONST[1]);
  -    emit_imm32(NATIVECODE, r12, *INT_CONST[2]);
  -    emit_cmp(NATIVECODE, r12, r11);
  -    emit_bc(jit_info, BGT, *INT_CONST[3]);
  +    if (*INT_CONST[1] > *INT_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
   }
   
   Parrot_eq_i_i_ic {
  @@ -693,10 +907,8 @@
   }
   
   Parrot_eq_ic_ic_ic {
  -    emit_imm32(NATIVECODE, r11, *INT_CONST[1]);
  -    emit_imm32(NATIVECODE, r12, *INT_CONST[2]);
  -    emit_cmp(NATIVECODE, r12, r11);
  -    emit_bc(jit_info, BEQ, *INT_CONST[3]);
  +    if (*INT_CONST[1] == *INT_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
   }
   
   Parrot_ge_i_i_ic {
  @@ -750,10 +962,8 @@
   }
   
   Parrot_ge_ic_ic_ic {
  -    emit_imm32(NATIVECODE, r11, *INT_CONST[1]);
  -    emit_imm32(NATIVECODE, r12, *INT_CONST[2]);
  -    emit_cmp(NATIVECODE, r12, r11);
  -    emit_bc(jit_info, BGE, *INT_CONST[3]);
  +    if (*INT_CONST[1] >= *INT_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
   }
   
   Parrot_lt_i_i_ic {
  @@ -807,10 +1017,8 @@
   }
   
   Parrot_lt_ic_ic_ic {
  -    emit_imm32(NATIVECODE, r11, *INT_CONST[1]);
  -    emit_imm32(NATIVECODE, r12, *INT_CONST[2]);
  -    emit_cmp(NATIVECODE, r12, r11);
  -    emit_bc(jit_info, BLT, *INT_CONST[3]);
  +    if (*INT_CONST[1] < *INT_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
   }
   
   Parrot_le_i_i_ic {
  @@ -864,10 +1072,8 @@
   }
   
   Parrot_le_ic_ic_ic {
  -    emit_imm32(NATIVECODE, r11, *INT_CONST[1]);
  -    emit_imm32(NATIVECODE, r12, *INT_CONST[2]);
  -    emit_cmp(NATIVECODE, r12, r11);
  -    emit_bc(jit_info, BLE, *INT_CONST[3]);
  +    if (*INT_CONST[1] <= *INT_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
   }
   
   Parrot_ne_i_i_ic {
  @@ -921,201 +1127,366 @@
   }
   
   Parrot_ne_ic_ic_ic {
  -    emit_imm32(NATIVECODE, r11, *INT_CONST[1]);
  -    emit_imm32(NATIVECODE, r12, *INT_CONST[2]);
  -    emit_cmp(NATIVECODE, r12, r11);
  -    emit_bc(jit_info, BNE, *INT_CONST[3]);
  +    if (*INT_CONST[1] != *INT_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
   }
   
   Parrot_gt_n_n_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fcmp(NATIVECODE, MAP[1], MAP[2]);
       emit_bc(jit_info, BGT, *INT_CONST[3]);
   }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
  +        emit_bc(jit_info, BGT, *INT_CONST[3]);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
  +        emit_bc(jit_info, BGT, *INT_CONST[3]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, f11, f12);
  +        emit_bc(jit_info, BGT, *INT_CONST[3]);
  +    }
  +}
   
   Parrot_gt_n_nc_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  +    if (MAP[1]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
  +        emit_bc(jit_info, BGT, *INT_CONST[3]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f11, f12);
       emit_bc(jit_info, BGT, *INT_CONST[3]);
   }
  +}
   
   Parrot_gt_nc_n_ic {
  +    if (MAP[2]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
       emit_bc(jit_info, BGT, *INT_CONST[3]);
   }
  -
  -Parrot_gt_nc_nc_ic {
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, f11);
       emit_bc(jit_info, BGT, *INT_CONST[3]);
   }
  +}
  +
  +Parrot_gt_nc_nc_ic {
  +    if (*NUM_CONST[1] > *NUM_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
  +}
   
   Parrot_eq_n_n_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fcmp(NATIVECODE, MAP[1], MAP[2]);
       emit_bc(jit_info, BEQ, *INT_CONST[3]);
   }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
  +        emit_bc(jit_info, BEQ, *INT_CONST[3]);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
  +        emit_bc(jit_info, BEQ, *INT_CONST[3]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, f11, f12);
  +        emit_bc(jit_info, BEQ, *INT_CONST[3]);
  +    }
  +}
   
   Parrot_eq_n_nc_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  +    if (MAP[1]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
       emit_bc(jit_info, BEQ, *INT_CONST[3]);
   }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f11, f12);
  +        emit_bc(jit_info, BEQ, *INT_CONST[3]);
  +    }
  +}
   
   Parrot_eq_nc_n_ic {
  +    if (MAP[2]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
       emit_bc(jit_info, BEQ, *INT_CONST[3]);
   }
  -
  -Parrot_eq_nc_nc_ic {
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, f11);
       emit_bc(jit_info, BEQ, *INT_CONST[3]);
   }
  +}
  +
  +Parrot_eq_nc_nc_ic {
  +    if (*NUM_CONST[1] == *NUM_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
  +}
   
   Parrot_ge_n_n_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fcmp(NATIVECODE, MAP[1], MAP[2]);
  +        emit_bc(jit_info, BGE, *INT_CONST[3]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
       emit_bc(jit_info, BGE, *INT_CONST[3]);
   }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
  +        emit_bc(jit_info, BGE, *INT_CONST[3]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, f11, f12);
  +        emit_bc(jit_info, BGE, *INT_CONST[3]);
  +    }
  +}
   
   Parrot_ge_n_nc_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  +    if (MAP[1]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
       emit_bc(jit_info, BGE, *INT_CONST[3]);
   }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f11, f12);
  +        emit_bc(jit_info, BGE, *INT_CONST[3]);
  +    }
  +}
   
   Parrot_ge_nc_n_ic {
  +    if (MAP[2]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
       emit_bc(jit_info, BGE, *INT_CONST[3]);
   }
  -
  -Parrot_ge_nc_nc_ic {
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, f11);
       emit_bc(jit_info, BGE, *INT_CONST[3]);
   }
  +}
  +
  +Parrot_ge_nc_nc_ic {
  +    if (*NUM_CONST[1] >= *NUM_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
  +}
   
   Parrot_lt_n_n_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fcmp(NATIVECODE, MAP[1], MAP[2]);
  +        emit_bc(jit_info, BLT, *INT_CONST[3]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
  +        emit_bc(jit_info, BLT, *INT_CONST[3]);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
  +        emit_bc(jit_info, BLT, *INT_CONST[3]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, f11, f12);
       emit_bc(jit_info, BLT, *INT_CONST[3]);
   }
  +}
   
   Parrot_lt_n_nc_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  +    if (MAP[1]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
  +        emit_bc(jit_info, BLT, *INT_CONST[3]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f11, f12);
       emit_bc(jit_info, BLT, *INT_CONST[3]);
   }
  +}
   
   Parrot_lt_nc_n_ic {
  +    if (MAP[2]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
       emit_bc(jit_info, BLT, *INT_CONST[3]);
   }
  -
  -Parrot_lt_nc_nc_ic {
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, f11);
       emit_bc(jit_info, BLT, *INT_CONST[3]);
   }
  +}
  +
  +Parrot_lt_nc_nc_ic {
  +    if (*NUM_CONST[1] < *NUM_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
  +}
   
   Parrot_le_n_n_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fcmp(NATIVECODE, MAP[1], MAP[2]);
  +        emit_bc(jit_info, BLE, *INT_CONST[3]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
  +        emit_bc(jit_info, BLE, *INT_CONST[3]);
  +    }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
       emit_bc(jit_info, BLE, *INT_CONST[3]);
   }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, f11, f12);
  +        emit_bc(jit_info, BLE, *INT_CONST[3]);
  +    }
  +}
   
   Parrot_le_n_nc_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  +    if (MAP[1]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
  +        emit_bc(jit_info, BLE, *INT_CONST[3]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f11, f12);
       emit_bc(jit_info, BLE, *INT_CONST[3]);
   }
  +}
   
   Parrot_le_nc_n_ic {
  +    if (MAP[2]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
       emit_bc(jit_info, BLE, *INT_CONST[3]);
   }
  -
  -Parrot_le_nc_nc_ic {
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, f11);
       emit_bc(jit_info, BLE, *INT_CONST[3]);
   }
  +}
  +
  +Parrot_le_nc_nc_ic {
  +    if (*NUM_CONST[1] <= *NUM_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
  +}
   
   Parrot_ne_n_n_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +    if (MAP[1] && MAP[2]) {
  +        emit_fcmp(NATIVECODE, MAP[1], MAP[2]);
  +        emit_bc(jit_info, BNE, *INT_CONST[3]);
  +    }
  +    else if (MAP[1]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
       emit_bc(jit_info, BNE, *INT_CONST[3]);
   }
  +    else if (MAP[2]) {
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[1]);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
  +        emit_bc(jit_info, BNE, *INT_CONST[3]);
  +    }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_lfd_r(NATIVECODE, f12, &NUM_REG[2]);
  +        emit_fcmp(NATIVECODE, f11, f12);
  +        emit_bc(jit_info, BNE, *INT_CONST[3]);
  +    }
  +}
   
   Parrot_ne_n_nc_ic {
  -    emit_lfd_r(NATIVECODE, r11, &NUM_REG[1]);
  +    if (MAP[1]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, MAP[1], f12);
       emit_bc(jit_info, BNE, *INT_CONST[3]);
   }
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[1]);
  +        emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f11, f12);
  +        emit_bc(jit_info, BNE, *INT_CONST[3]);
  +    }
  +}
   
   Parrot_ne_nc_n_ic {
  +    if (MAP[2]) {
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_lfd_r(NATIVECODE, r12, &NUM_REG[2]);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, MAP[2]);
       emit_bc(jit_info, BNE, *INT_CONST[3]);
   }
  -
  -Parrot_ne_nc_nc_ic {
  +    else {
  +        emit_lfd_r(NATIVECODE, f11, &NUM_REG[2]);
       emit_imm32(NATIVECODE, r12, &NUM_CONST[1]);
  -    emit_lfd(NATIVECODE, r11, 0, r12);
  -    emit_imm32(NATIVECODE, r12, &NUM_CONST[2]);
  -    emit_lfd(NATIVECODE, r12, 0, r12);
  -    emit_fcmp(NATIVECODE, r11, r12);
  +        emit_lfd(NATIVECODE, f12, 0, r12);
  +        emit_fcmp(NATIVECODE, f12, f11);
       emit_bc(jit_info, BNE, *INT_CONST[3]);
   }
  +}
   
  +Parrot_ne_nc_nc_ic {
  +    if (*NUM_CONST[1] != *NUM_CONST[2])
  +        emit_b(jit_info, *INT_CONST[3]);
  +}
  
  
  
  1.9       +114 -18   parrot/jit/ppc/jit_emit.h
  
  Index: jit_emit.h
  ===================================================================
  RCS file: /cvs/public/parrot/jit/ppc/jit_emit.h,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -w -r1.8 -r1.9
  --- jit_emit.h        10 Aug 2002 17:07:38 -0000      1.8
  +++ jit_emit.h        13 Aug 2002 18:03:12 -0000      1.9
  @@ -3,7 +3,7 @@
    * 
    * PPC
    *
  - * $Id: jit_emit.h,v 1.8 2002/08/10 17:07:38 grunblatt Exp $
  + * $Id: jit_emit.h,v 1.9 2002/08/13 18:03:12 grunblatt Exp $
    */
    
   #include <unistd.h>
  @@ -46,11 +46,46 @@
       r29,
       r30,
       r31
  -} ppc_register_t;
  +} ppc_iregister_t;
  +
  +typedef enum {
  +    f0,
  +    f1,
  +    f2,
  +    f3,
  +    f4,
  +    f5,
  +    f6,
  +    f7,
  +    f8,
  +    f9,
  +    f10,
  +    f11,
  +    f12,
  +    f13,
  +    f14,
  +    f15,
  +    f16,
  +    f17,
  +    f18,
  +    f19,
  +    f20,
  +    f21,
  +    f22,
  +    f23,
  +    f24,
  +    f25,
  +    f26,
  +    f27,
  +    f28,
  +    f29,
  +    f30,
  +    f31
  +} ppc_fregister_t;
   
   #if JIT_EMIT
   
  -enum { JIT_PPC_CALL, JIT_PPC_BRANCH };
  +enum { JIT_PPC_CALL, JIT_PPC_BRANCH, JIT_PPC_UBRANCH };
   
   #define emit_op(op) (op << 2)
   
  @@ -127,11 +162,12 @@
    *
    */
   
  -#define emit_bx(pc, type, disp) \
  -  *(pc++) = emit_op(18) | disp >> 24; \
  -  *(pc++) = disp >> 16; \
  -  *(pc++) = disp >> 8; \
  -  *(pc++) = disp | type
  +  
  +#define _emit_bx(pc, type, disp) \
  +  *(pc++) = (char)(18 << 2 | disp >> 24); \
  +  *(pc++) = (char)(disp >> 16); \
  +  *(pc++) = (char)(disp >> 8); \
  +  *(pc++) = (char)(disp | type)
   
   #define emit_b(pc, disp) \
     emit_bx(pc, 0, disp)
  @@ -455,8 +491,36 @@
       
       }
       _emit_bc(jit_info->native_ptr, cond, offset, 0, 0);
  +}
  +
  +static void
  +emit_bx(Parrot_jit_info_t *jit_info, char type, opcode_t disp)
  +{
  +    opcode_t opcode = jit_info->op_i + disp;
  +    int offset;
  +
  +    if(opcode <= jit_info->op_i) {
  +        offset = jit_info->arena.op_map[opcode].offset -
  +            (jit_info->native_ptr - jit_info->arena.start);
  +        if (jit_info->optimizer->cur_section->branch_target ==
  +            jit_info->optimizer->cur_section)
  +                offset +=
  +                    jit_info->optimizer->cur_section->branch_target->load_size;
  +    } else {
  +        offset = 0;
  +        Parrot_jit_newfixup(jit_info); 
  +        jit_info->arena.fixups->type = JIT_PPC_UBRANCH;
  +        jit_info->arena.fixups->param.opcode = opcode;
  +
  +        if (jit_info->optimizer->cur_section->branch_target ==
  +            jit_info->optimizer->cur_section)
  +                jit_info->arena.fixups->skip =
  +                    jit_info->optimizer->cur_section->branch_target->load_size;
   
   }
  +    _emit_bx(jit_info->native_ptr, type, offset);
  +}
  + 
   
   /* Store a CPU register back to a Parrot register. */
   
  @@ -506,7 +570,7 @@
       jit_info->arena.fixups->param.fptr =
           (void (*)(void))interpreter->op_func_table[*(jit_info->cur_op)];
   
  -    emit_bl(jit_info->native_ptr, 0);
  +    _emit_bx(jit_info->native_ptr, 1, 0);
   }
      
   void
  @@ -544,9 +608,18 @@
                   *(fixup_ptr++) |= (char)d & ~3;
                   break;
   
  +            case JIT_PPC_UBRANCH:
  +                fixup_ptr = Parrot_jit_fixup_target(jit_info, fixup);
  +                d = jit_info->arena.op_map[fixup->param.opcode].offset
  +                    - fixup->native_offset + fixup->skip;
  +                *(fixup_ptr++) = (char)(d >> 24) & 3;
  +                *(fixup_ptr++) = (char)(d >> 16);
  +                *(fixup_ptr++) = (char)(d >> 8);
  +                *(fixup_ptr++) |= (char)d & ~3;
  +                break;
  +
               case JIT_PPC_BRANCH:
                   fixup_ptr = Parrot_jit_fixup_target(jit_info, fixup);
  -                /* I guess param.fptr is number of insns? */
                   d = jit_info->arena.op_map[fixup->param.opcode].offset
                       - fixup->native_offset + fixup->skip;
                   fixup_ptr += 2;
  @@ -568,14 +641,22 @@
       struct Parrot_Interp *interpreter)
   {
       Parrot_jit_optimizer_section_t *cur_se = jit_info->optimizer->cur_section;
  -    int i = cur_se->registers_used;
  +    int i = cur_se->int_registers_used;
   
       while (i--)
           if (cur_se->int_reg_dir[cur_se->int_reg_usage[i]] & PARROT_ARGDIR_IN) {
  -            emit_lwz_r(jit_info->native_ptr, jit_info->register_map[i],
  +            emit_lwz_r(jit_info->native_ptr, jit_info->intval_map[i],
                   &interpreter->ctx.int_reg.registers[cur_se->int_reg_usage[i]]);
           }
   
  +    i = cur_se->float_registers_used;
  +    while (i--)
  +      if (cur_se->float_reg_dir[cur_se->float_reg_usage[i]] & 
  +        PARROT_ARGDIR_IN) {
  +            emit_lfd_r(jit_info->native_ptr, jit_info->floatval_map[i],
  +              &interpreter->ctx.num_reg.registers[cur_se->float_reg_usage[i]]);
  +      }
  +
       /* The total size of the loads */
       if (!jit_info->optimizer->cur_section->load_size)
           jit_info->optimizer->cur_section->load_size = jit_info->native_ptr -
  @@ -589,30 +670,45 @@
       struct Parrot_Interp * interpreter)
   {
       Parrot_jit_optimizer_section_t *cur_se = jit_info->optimizer->cur_section;
  -    int i = cur_se->registers_used;
  +    int i = cur_se->int_registers_used;
   
       while (i--)
           if (cur_se->int_reg_dir[cur_se->int_reg_usage[i]] & PARROT_ARGDIR_OUT) {
  -            emit_stw_r(jit_info->native_ptr, jit_info->register_map[i],
  +            emit_stw_r(jit_info->native_ptr, jit_info->intval_map[i],
                   &interpreter->ctx.int_reg.registers[cur_se->int_reg_usage[i]]);
           }
  +
  +    i = cur_se->float_registers_used;
  +    while (i--)
  +      if (cur_se->float_reg_dir[cur_se->float_reg_usage[i]] & 
  +        PARROT_ARGDIR_OUT) {
  +            emit_stfd_r(jit_info->native_ptr, jit_info->floatval_map[i],
  +              &interpreter->ctx.num_reg.registers[cur_se->float_reg_usage[i]]);
  +      }
   }
   
   #else
   
   #  define REQUIRES_CONSTANT_POOL 0
  -#  define MAX_REGITERS_TO_MAP 25
  +#  define INT_REGITERS_TO_MAP 25
  +#  define FLOAT_REGITERS_TO_MAP 29
   
   /* Reserved:
    * r13 interpreter
    * r14 op_map
    * r15 code_start
    */
  -char register_map[MAX_REGITERS_TO_MAP] =
  +
  +char intval_map[INT_REGITERS_TO_MAP] =
       { r16, r17, r18, r19, r20, r21, r22, r23, 
         r24, r25, r26, r27, r28, r29, r30, r31,
         r2, r3, r4, r5, r6, r7, r8, r9, r10 };
         
  +char floatval_map[FLOAT_REGITERS_TO_MAP] =
  +    { r13, r14, r15, r16, r17, r18, r19, r20, r21,
  +      r22, r23, r24, r25, r26, r27, r28, r29, r30,
  +      r31, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10 };
  +
   static void
   ppc_sync_cache (void *_start, void *_end)
   {   
  
  
  
  1.10      +4 -3      parrot/jit/sun4/jit_emit.h
  
  Index: jit_emit.h
  ===================================================================
  RCS file: /cvs/public/parrot/jit/sun4/jit_emit.h,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -w -r1.9 -r1.10
  --- jit_emit.h        5 Aug 2002 16:33:33 -0000       1.9
  +++ jit_emit.h        13 Aug 2002 18:03:44 -0000      1.10
  @@ -3,7 +3,7 @@
   **
   ** SPARC
   **
  -** $Id: jit_emit.h,v 1.9 2002/08/05 16:33:33 grunblatt Exp $
  +** $Id: jit_emit.h,v 1.10 2002/08/13 18:03:44 grunblatt Exp $
   **/
   
   /* 
  @@ -588,9 +588,10 @@
   #else
   
   #  define REQUIRES_CONSTANT_POOL 0
  -#  define MAX_REGITERS_TO_MAP 1
  +#  define INT_REGITERS_TO_MAP 1
  +#  define FLOAT_REGITERS_TO_MAP 0
   
  -char register_map[MAX_REGITERS_TO_MAP] = { emitm_l(0) }; 
  +char register_map[INT_REGITERS_TO_MAP] = { emitm_l(0) }; 
   
   #endif
   
  
  
  


Reply via email to