[BACK]Return to sljitNativeMIPS_common.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre / sljit

Diff for /embedaddon/pcre/sljit/sljitNativeMIPS_common.c between versions 1.1.1.2 and 1.1.1.3

version 1.1.1.2, 2012/02/21 23:50:25 version 1.1.1.3, 2012/10/09 09:19:18
Line 39  typedef sljit_ui sljit_ins; Line 39  typedef sljit_ui sljit_ins;
 #define TMP_REG1        (SLJIT_NO_REGISTERS + 1)  #define TMP_REG1        (SLJIT_NO_REGISTERS + 1)
 #define TMP_REG2        (SLJIT_NO_REGISTERS + 2)  #define TMP_REG2        (SLJIT_NO_REGISTERS + 2)
 #define TMP_REG3        (SLJIT_NO_REGISTERS + 3)  #define TMP_REG3        (SLJIT_NO_REGISTERS + 3)
 #define REAL_STACK_PTR  (SLJIT_NO_REGISTERS + 4)  
   
 /* For position independent code, t9 must contain the function address. */  /* For position independent code, t9 must contain the function address. */
 #define PIC_ADDR_REG            TMP_REG2  #define PIC_ADDR_REG            TMP_REG2
Line 174  typedef sljit_ui sljit_ins; Line 173  typedef sljit_ui sljit_ins;
 #define UIMM_MAX        (0xffff)  #define UIMM_MAX        (0xffff)
   
 static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 6] = {  static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 6] = {
  0, 2, 5, 6, 3, 8, 17, 18, 19, 20, 21, 16, 4, 25, 9, 29  0, 2, 5, 6, 3, 8, 16, 17, 18, 19, 20, 29, 4, 25, 9
 };  };
   
 /* dest_reg is the absolute name of the register  /* dest_reg is the absolute name of the register
Line 464  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct s Line 463  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct s
   
         compiler->temporaries = temporaries;          compiler->temporaries = temporaries;
         compiler->saveds = saveds;          compiler->saveds = saveds;
   #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
           compiler->logical_local_size = local_size;
   #endif
   
        compiler->has_locals = local_size > 0;        local_size += (saveds + 1 + 4) * sizeof(sljit_w);
        local_size += (saveds + 2 + 4) * sizeof(sljit_w); 
         local_size = (local_size + 15) & ~0xf;          local_size = (local_size + 15) & ~0xf;
         compiler->local_size = local_size;          compiler->local_size = local_size;
   
         if (local_size <= SIMM_MAX) {          if (local_size <= SIMM_MAX) {
                 /* Frequent case. */                  /* Frequent case. */
                FAIL_IF(push_inst(compiler, ADDIU_W | S(REAL_STACK_PTR) | T(REAL_STACK_PTR) | IMM(-local_size), DR(REAL_STACK_PTR)));                FAIL_IF(push_inst(compiler, ADDIU_W | S(SLJIT_LOCALS_REG) | T(SLJIT_LOCALS_REG) | IMM(-local_size), DR(SLJIT_LOCALS_REG)));
                base = S(REAL_STACK_PTR);                base = S(SLJIT_LOCALS_REG);
         }          }
         else {          else {
                 FAIL_IF(load_immediate(compiler, DR(TMP_REG1), local_size));                  FAIL_IF(load_immediate(compiler, DR(TMP_REG1), local_size));
                FAIL_IF(push_inst(compiler, ADDU_W | S(REAL_STACK_PTR) | TA(0) | D(TMP_REG2), DR(TMP_REG2)));                FAIL_IF(push_inst(compiler, ADDU_W | S(SLJIT_LOCALS_REG) | TA(0) | D(TMP_REG2), DR(TMP_REG2)));
                FAIL_IF(push_inst(compiler, SUBU_W | S(REAL_STACK_PTR) | T(TMP_REG1) | D(REAL_STACK_PTR), DR(REAL_STACK_PTR)));                FAIL_IF(push_inst(compiler, SUBU_W | S(SLJIT_LOCALS_REG) | T(TMP_REG1) | D(SLJIT_LOCALS_REG), DR(SLJIT_LOCALS_REG)));
                 base = S(TMP_REG2);                  base = S(TMP_REG2);
                 local_size = 0;                  local_size = 0;
         }          }
   
         FAIL_IF(push_inst(compiler, STACK_STORE | base | TA(RETURN_ADDR_REG) | IMM(local_size - 1 * (int)sizeof(sljit_w)), MOVABLE_INS));          FAIL_IF(push_inst(compiler, STACK_STORE | base | TA(RETURN_ADDR_REG) | IMM(local_size - 1 * (int)sizeof(sljit_w)), MOVABLE_INS));
         if (compiler->has_locals)  
                 FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_LOCALS_REG) | IMM(local_size - 2 * (int)sizeof(sljit_w)), MOVABLE_INS));  
         if (saveds >= 1)          if (saveds >= 1)
                FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG1) | IMM(local_size - 3 * (int)sizeof(sljit_w)), MOVABLE_INS));                FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG1) | IMM(local_size - 2 * (int)sizeof(sljit_w)), MOVABLE_INS));
         if (saveds >= 2)          if (saveds >= 2)
                FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG2) | IMM(local_size - 4 * (int)sizeof(sljit_w)), MOVABLE_INS));                FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG2) | IMM(local_size - 3 * (int)sizeof(sljit_w)), MOVABLE_INS));
         if (saveds >= 3)          if (saveds >= 3)
                FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG3) | IMM(local_size - 5 * (int)sizeof(sljit_w)), MOVABLE_INS));                FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG3) | IMM(local_size - 4 * (int)sizeof(sljit_w)), MOVABLE_INS));
         if (saveds >= 4)          if (saveds >= 4)
                FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_EREG1) | IMM(local_size - 6 * (int)sizeof(sljit_w)), MOVABLE_INS));                FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_EREG1) | IMM(local_size - 5 * (int)sizeof(sljit_w)), MOVABLE_INS));
         if (saveds >= 5)          if (saveds >= 5)
                FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_EREG2) | IMM(local_size - 7 * (int)sizeof(sljit_w)), MOVABLE_INS));                FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_EREG2) | IMM(local_size - 6 * (int)sizeof(sljit_w)), MOVABLE_INS));
   
         if (compiler->has_locals)  
                 FAIL_IF(push_inst(compiler, ADDIU_W | S(REAL_STACK_PTR) | T(SLJIT_LOCALS_REG) | IMM(4 * sizeof(sljit_w)), DR(SLJIT_LOCALS_REG)));  
   
         if (args >= 1)          if (args >= 1)
                 FAIL_IF(push_inst(compiler, ADDU_W | SA(4) | TA(0) | D(SLJIT_SAVED_REG1), DR(SLJIT_SAVED_REG1)));                  FAIL_IF(push_inst(compiler, ADDU_W | SA(4) | TA(0) | D(SLJIT_SAVED_REG1), DR(SLJIT_SAVED_REG1)));
         if (args >= 2)          if (args >= 2)
Line 517  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct Line 513  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct
   
         compiler->temporaries = temporaries;          compiler->temporaries = temporaries;
         compiler->saveds = saveds;          compiler->saveds = saveds;
   #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
           compiler->logical_local_size = local_size;
   #endif
   
        compiler->has_locals = local_size > 0;        local_size += (saveds + 1 + 4) * sizeof(sljit_w);
        local_size += (saveds + 2 + 4) * sizeof(sljit_w); 
         compiler->local_size = (local_size + 15) & ~0xf;          compiler->local_size = (local_size + 15) & ~0xf;
 }  }
   
Line 530  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct  Line 528  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct 
   
         CHECK_ERROR();          CHECK_ERROR();
         check_sljit_emit_return(compiler, op, src, srcw);          check_sljit_emit_return(compiler, op, src, srcw);
           ADJUST_LOCAL_OFFSET(src, srcw);
   
         FAIL_IF(emit_mov_before_return(compiler, op, src, srcw));          FAIL_IF(emit_mov_before_return(compiler, op, src, srcw));
   
         local_size = compiler->local_size;          local_size = compiler->local_size;
         if (local_size <= SIMM_MAX)          if (local_size <= SIMM_MAX)
                base = S(REAL_STACK_PTR);                base = S(SLJIT_LOCALS_REG);
         else {          else {
                 FAIL_IF(load_immediate(compiler, DR(TMP_REG1), local_size));                  FAIL_IF(load_immediate(compiler, DR(TMP_REG1), local_size));
                FAIL_IF(push_inst(compiler, ADDU_W | S(REAL_STACK_PTR) | T(TMP_REG1) | D(TMP_REG1), DR(TMP_REG1)));                FAIL_IF(push_inst(compiler, ADDU_W | S(SLJIT_LOCALS_REG) | T(TMP_REG1) | D(TMP_REG1), DR(TMP_REG1)));
                 base = S(TMP_REG1);                  base = S(TMP_REG1);
                 local_size = 0;                  local_size = 0;
         }          }
   
         FAIL_IF(push_inst(compiler, STACK_LOAD | base | TA(RETURN_ADDR_REG) | IMM(local_size - 1 * (int)sizeof(sljit_w)), RETURN_ADDR_REG));          FAIL_IF(push_inst(compiler, STACK_LOAD | base | TA(RETURN_ADDR_REG) | IMM(local_size - 1 * (int)sizeof(sljit_w)), RETURN_ADDR_REG));
         if (compiler->saveds >= 5)          if (compiler->saveds >= 5)
                FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_EREG2) | IMM(local_size - 7 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_EREG2)));                FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_EREG2) | IMM(local_size - 6 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_EREG2)));
         if (compiler->saveds >= 4)          if (compiler->saveds >= 4)
                FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_EREG1) | IMM(local_size - 6 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_EREG1)));                FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_EREG1) | IMM(local_size - 5 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_EREG1)));
         if (compiler->saveds >= 3)          if (compiler->saveds >= 3)
                FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG3) | IMM(local_size - 5 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_REG3)));                FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG3) | IMM(local_size - 4 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_REG3)));
         if (compiler->saveds >= 2)          if (compiler->saveds >= 2)
                FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG2) | IMM(local_size - 4 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_REG2)));                FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG2) | IMM(local_size - 3 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_REG2)));
         if (compiler->saveds >= 1)          if (compiler->saveds >= 1)
                FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG1) | IMM(local_size - 3 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_REG1)));                FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG1) | IMM(local_size - 2 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_REG1)));
        if (compiler->has_locals) 
                FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_LOCALS_REG) | IMM(local_size - 2 * (int)sizeof(sljit_w)), DR(SLJIT_LOCALS_REG))); 
   
         FAIL_IF(push_inst(compiler, JR | SA(RETURN_ADDR_REG), UNMOVABLE_INS));          FAIL_IF(push_inst(compiler, JR | SA(RETURN_ADDR_REG), UNMOVABLE_INS));
         if (compiler->local_size <= SIMM_MAX)          if (compiler->local_size <= SIMM_MAX)
                return push_inst(compiler, ADDIU_W | S(REAL_STACK_PTR) | T(REAL_STACK_PTR) | IMM(compiler->local_size), UNMOVABLE_INS);                return push_inst(compiler, ADDIU_W | S(SLJIT_LOCALS_REG) | T(SLJIT_LOCALS_REG) | IMM(compiler->local_size), UNMOVABLE_INS);
         else          else
                return push_inst(compiler, ADDU_W | S(TMP_REG1) | TA(0) | D(REAL_STACK_PTR), UNMOVABLE_INS);                return push_inst(compiler, ADDU_W | S(TMP_REG1) | TA(0) | D(SLJIT_LOCALS_REG), UNMOVABLE_INS);
 }  }
   
 #undef STACK_STORE  #undef STACK_STORE
Line 956  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op1(struct slj Line 953  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op1(struct slj
   
         CHECK_ERROR();          CHECK_ERROR();
         check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);          check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);
           ADJUST_LOCAL_OFFSET(dst, dstw);
           ADJUST_LOCAL_OFFSET(src, srcw);
   
         SLJIT_COMPILE_ASSERT(SLJIT_MOV + 7 == SLJIT_MOVU, movu_offset);          SLJIT_COMPILE_ASSERT(SLJIT_MOV + 7 == SLJIT_MOVU, movu_offset);
   
Line 1029  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op2(struct slj Line 1028  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op2(struct slj
   
         CHECK_ERROR();          CHECK_ERROR();
         check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w);          check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
           ADJUST_LOCAL_OFFSET(dst, dstw);
           ADJUST_LOCAL_OFFSET(src1, src1w);
           ADJUST_LOCAL_OFFSET(src2, src2w);
   
         switch (GET_OPCODE(op)) {          switch (GET_OPCODE(op)) {
         case SLJIT_ADD:          case SLJIT_ADD:
Line 1260  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sl Line 1262  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sl
 /*  Other instructions                                                   */  /*  Other instructions                                                   */
 /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
   
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw, int args, int temporaries, int saveds, int local_size)SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw)
 {  {
         CHECK_ERROR();          CHECK_ERROR();
        check_sljit_emit_fast_enter(compiler, dst, dstw, args, temporaries, saveds, local_size);        check_sljit_emit_fast_enter(compiler, dst, dstw);
         ADJUST_LOCAL_OFFSET(dst, dstw);
   
         compiler->temporaries = temporaries;  
         compiler->saveds = saveds;  
   
         compiler->has_locals = local_size > 0;  
         local_size += (saveds + 2 + 4) * sizeof(sljit_w);  
         compiler->local_size = (local_size + 15) & ~0xf;  
   
         if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS)          if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS)
                 return push_inst(compiler, ADDU_W | SA(RETURN_ADDR_REG) | TA(0) | D(dst), DR(dst));                  return push_inst(compiler, ADDU_W | SA(RETURN_ADDR_REG) | TA(0) | D(dst), DR(dst));
         else if (dst & SLJIT_MEM)          else if (dst & SLJIT_MEM)
Line 1283  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(st Line 1279  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(st
 {  {
         CHECK_ERROR();          CHECK_ERROR();
         check_sljit_emit_fast_return(compiler, src, srcw);          check_sljit_emit_fast_return(compiler, src, srcw);
           ADJUST_LOCAL_OFFSET(src, srcw);
   
         if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS)          if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS)
                 FAIL_IF(push_inst(compiler, ADDU_W | S(src) | TA(0) | DA(RETURN_ADDR_REG), RETURN_ADDR_REG));                  FAIL_IF(push_inst(compiler, ADDU_W | S(src) | TA(0) | DA(RETURN_ADDR_REG), RETURN_ADDR_REG));
Line 1468  SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit Line 1465  SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit
   
         CHECK_ERROR_PTR();          CHECK_ERROR_PTR();
         check_sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w);          check_sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w);
           ADJUST_LOCAL_OFFSET(src1, src1w);
           ADJUST_LOCAL_OFFSET(src2, src2w);
   
         compiler->cache_arg = 0;          compiler->cache_arg = 0;
         compiler->cache_argw = 0;          compiler->cache_argw = 0;
Line 1671  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct s Line 1670  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct s
   
         CHECK_ERROR();          CHECK_ERROR();
         check_sljit_emit_ijump(compiler, type, src, srcw);          check_sljit_emit_ijump(compiler, type, src, srcw);
           ADJUST_LOCAL_OFFSET(src, srcw);
   
         if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS) {          if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS) {
                 if (DR(src) != 4)                  if (DR(src) != 4)
Line 1727  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_cond_value(str Line 1727  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_cond_value(str
   
         CHECK_ERROR();          CHECK_ERROR();
         check_sljit_emit_cond_value(compiler, op, dst, dstw, type);          check_sljit_emit_cond_value(compiler, op, dst, dstw, type);
           ADJUST_LOCAL_OFFSET(dst, dstw);
   
         if (dst == SLJIT_UNUSED)          if (dst == SLJIT_UNUSED)
                 return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
Line 1814  SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emi Line 1815  SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emi
   
         CHECK_ERROR_PTR();          CHECK_ERROR_PTR();
         check_sljit_emit_const(compiler, dst, dstw, init_value);          check_sljit_emit_const(compiler, dst, dstw, init_value);
           ADJUST_LOCAL_OFFSET(dst, dstw);
   
         const_ = (struct sljit_const*)ensure_abuf(compiler, sizeof(struct sljit_const));          const_ = (struct sljit_const*)ensure_abuf(compiler, sizeof(struct sljit_const));
         PTR_FAIL_IF(!const_);          PTR_FAIL_IF(!const_);
Removed from v.1.1.1.2  
changed lines
  Added in v.1.1.1.3

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>