Move x86 dependent code out from platform independed parts.

diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c
index 4863c2b8c8e55393a7c5c3f9677566085043290b..edee5f2573b39f5f78fb516c1612309ce3101e83 100644 (file)
--- a/ext/opcache/jit/zend_jit.c
+++ b/ext/opcache/jit/zend_jit.c
@@ -1510,7 +1510,7 @@ static int zend_jit_try_allocate_free_reg(const zend_op_array *op_array, const z
                                if (!ZEND_REGSET_IN(*hints, it->reg) &&
                                    /* TODO: Avoid most often scratch registers. Find a better way ??? */
                                    (!current->used_as_hint ||
-                                    (it->reg != ZREG_R0 && it->reg != ZREG_R1 && it->reg != ZREG_XMM0 && it->reg != ZREG_XMM1))) {
+                                    !ZEND_REGSET_IN(zend_jit_get_low_priority_regset(), it->reg))) {
                                        hint = it->reg;
                                }
                        } else {
@@ -1640,10 +1640,7 @@ static int zend_jit_try_allocate_free_reg(const zend_op_array *op_array, const z
        low_priority_regs = *hints;
        if (current->used_as_hint) {
                /* TODO: Avoid most often scratch registers. Find a better way ??? */
-               ZEND_REGSET_INCL(low_priority_regs, ZREG_R0);
-               ZEND_REGSET_INCL(low_priority_regs, ZREG_R1);
-               ZEND_REGSET_INCL(low_priority_regs, ZREG_XMM0);
-               ZEND_REGSET_INCL(low_priority_regs, ZREG_XMM1);
+               low_priority_regs = ZEND_REGSET_UNION(low_priority_regs, zend_jit_get_low_priority_regset());
        }
 
        ZEND_REGSET_FOREACH(available, i) {

diff --git a/ext/opcache/jit/zend_jit_trace.c b/ext/opcache/jit/zend_jit_trace.c
index 80ce45605e891d800e323e393f7cb0847e7903a4..ff52edad49328efae124bf00f4a8696c270cd0d0 100644 (file)
--- a/ext/opcache/jit/zend_jit_trace.c
+++ b/ext/opcache/jit/zend_jit_trace.c
@@ -3260,7 +3260,7 @@ static int zend_jit_trace_deoptimization(dasm_State             **Dst,
                                                return 0;
                                        }
                                } else {
-                                       if (reg == ZREG_ZVAL_COPY_R0
+                                       if (reg == ZREG_ZVAL_COPY_GPR0
                                         &&!zend_jit_escape_if_undef_r0(Dst, i, flags, opline)) {
                                                return 0;
                                        }
@@ -6911,7 +6911,7 @@ static void zend_jit_dump_exit_info(zend_jit_trace_info *t)
                                fprintf(stderr, " ");
                                zend_dump_var(op_array, (j < op_array->last_var) ? IS_CV : 0, j);
                                fprintf(stderr, ":unknown(zval_try_addref)");
-                       } else if (STACK_REG(stack, j) == ZREG_ZVAL_COPY_R0) {
+                       } else if (STACK_REG(stack, j) == ZREG_ZVAL_COPY_GPR0) {
                                fprintf(stderr, " ");
                                zend_dump_var(op_array, (j < op_array->last_var) ? IS_CV : 0, j);
                                fprintf(stderr, ":unknown(zval_copy(%s))", zend_reg_name[0]);
@@ -7402,7 +7402,7 @@ int ZEND_FASTCALL zend_jit_trace_exit(uint32_t exit_num, zend_jit_registers_buf
        zend_jit_trace_stack *stack = t->stack_map + t->exit_info[exit_num].stack_offset;
 
        if (t->exit_info[exit_num].flags & ZEND_JIT_EXIT_RESTORE_CALL) {
-               zend_execute_data *call = (zend_execute_data *)regs->r[ZREG_RX];
+               zend_execute_data *call = (zend_execute_data *)regs->gpr[ZREG_RX];
                call->prev_execute_data = EX(call);
                EX(call) = call;
        }
@@ -7413,7 +7413,7 @@ int ZEND_FASTCALL zend_jit_trace_exit(uint32_t exit_num, zend_jit_registers_buf
                                zend_long val;
 
                                if (STACK_REG(stack, i) < ZREG_NUM) {
-                                       val = regs->r[STACK_REG(stack, i)];
+                                       val = regs->gpr[STACK_REG(stack, i)];
                                } else if (STACK_REG(stack, i) == ZREG_LONG_MIN) {
                                        val = ZEND_LONG_MIN;
                                } else if (STACK_REG(stack, i) == ZREG_LONG_MAX) {
@@ -7426,7 +7426,7 @@ int ZEND_FASTCALL zend_jit_trace_exit(uint32_t exit_num, zend_jit_registers_buf
                                double val;
 
                                if (STACK_REG(stack, i) < ZREG_NUM) {
-                                       val = regs->xmm[STACK_REG(stack, i) - ZREG_XMM0];
+                                       val = regs->fpr[STACK_REG(stack, i) - ZREG_FIRST_FPR];
                                } else if (STACK_REG(stack, i) == ZREG_LONG_MIN_MINUS_1) {
                                        val = (double)ZEND_LONG_MIN - 1.0;
                                } else if (STACK_REG(stack, i) == ZREG_LONG_MAX_PLUS_1) {
@@ -7444,8 +7444,8 @@ int ZEND_FASTCALL zend_jit_trace_exit(uint32_t exit_num, zend_jit_registers_buf
                                ZVAL_NULL(EX_VAR_NUM(i));
                        } else if (STACK_REG(stack, i) == ZREG_ZVAL_TRY_ADDREF) {
                                Z_TRY_ADDREF_P(EX_VAR_NUM(i));
-                       } else if (STACK_REG(stack, i) == ZREG_ZVAL_COPY_R0) {
-                               zval *val = (zval*)regs->r[0];
+                       } else if (STACK_REG(stack, i) == ZREG_ZVAL_COPY_GPR0) {
+                               zval *val = (zval*)regs->gpr[0];
 
                                if (UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)) {
                                        /* Undefined array index or property */
@@ -7486,7 +7486,7 @@ int ZEND_FASTCALL zend_jit_trace_exit(uint32_t exit_num, zend_jit_registers_buf
                        }
                }
                if (t->exit_info[exit_num].flags & ZEND_JIT_EXIT_METHOD_CALL) {
-                       zend_function *func = (zend_function*)regs->r[0];
+                       zend_function *func = (zend_function*)regs->gpr[0];
 
                        if (UNEXPECTED(func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
                                zend_string_release_ex(func->common.function_name, 0);

diff --git a/ext/opcache/jit/zend_jit_x86.dasc b/ext/opcache/jit/zend_jit_x86.dasc
index 73f97be95bcec5ca3869b5e97485110519a1b2d0..142b08eed68d61a52d6330ee8e94be5a4a3c90d4 100644 (file)
--- a/ext/opcache/jit/zend_jit_x86.dasc
+++ b/ext/opcache/jit/zend_jit_x86.dasc
@@ -3144,7 +3144,7 @@ static int zend_jit_trace_begin(dasm_State **Dst, uint32_t trace_num, zend_jit_t
                                if (STACK_REG(parent_stack, i) != ZREG_NONE) {
                                        if (STACK_REG(parent_stack, i) < ZREG_NUM) {
                                                ZEND_REGSET_EXCL(regset, STACK_REG(parent_stack, i));
-                                       } else if (STACK_REG(parent_stack, i) == ZREG_ZVAL_COPY_R0) {
+                                       } else if (STACK_REG(parent_stack, i) == ZREG_ZVAL_COPY_GPR0) {
                                                ZEND_REGSET_EXCL(regset, ZREG_R0);
                                        }
                                }
@@ -3941,7 +3941,7 @@ static int zend_jit_store_const(dasm_State **Dst, int var, zend_reg reg)
                |       GET_ZVAL_PTR r1, dst
                |       GC_ADDREF r1
                |1:
-       } else if (reg == ZREG_ZVAL_COPY_R0) {
+       } else if (reg == ZREG_ZVAL_COPY_GPR0) {
                zend_jit_addr val_addr = ZEND_ADDR_MEM_ZVAL(ZREG_R0, 0);
 
                |       ZVAL_COPY_VALUE dst, -1, val_addr, -1, ZREG_R1, ZREG_R2
@@ -11724,7 +11724,7 @@ static int zend_jit_fetch_dim_read(dasm_State        **Dst,
                if (!(op2_info & ((MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF) - (MAY_BE_STRING|MAY_BE_LONG)))) {
                        old_info = STACK_INFO(stack, EX_VAR_TO_NUM(opline->result.var));
                        SET_STACK_TYPE(stack, EX_VAR_TO_NUM(opline->result.var), IS_UNKNOWN, 1);
-                       SET_STACK_REG(stack, EX_VAR_TO_NUM(opline->result.var), ZREG_ZVAL_COPY_R0);
+                       SET_STACK_REG(stack, EX_VAR_TO_NUM(opline->result.var), ZREG_ZVAL_COPY_GPR0);
                        exit_point = zend_jit_trace_get_exit_point(opline+1, flags);
                        SET_STACK_INFO(stack, EX_VAR_TO_NUM(opline->result.var), old_info);
                        res_exit_addr = zend_jit_trace_get_exit_addr(exit_point);
@@ -12987,7 +12987,7 @@ static int zend_jit_fetch_obj(dasm_State          **Dst,
 
                        old_info = STACK_INFO(stack, EX_VAR_TO_NUM(opline->result.var));
                        SET_STACK_TYPE(stack, EX_VAR_TO_NUM(opline->result.var), IS_UNKNOWN, 1);
-                       SET_STACK_REG(stack, EX_VAR_TO_NUM(opline->result.var), ZREG_ZVAL_COPY_R0);
+                       SET_STACK_REG(stack, EX_VAR_TO_NUM(opline->result.var), ZREG_ZVAL_COPY_GPR0);
                        exit_point = zend_jit_trace_get_exit_point(opline+1, flags);
                        SET_STACK_INFO(stack, EX_VAR_TO_NUM(opline->result.var), old_info);
                        exit_addr = zend_jit_trace_get_exit_addr(exit_point);
@@ -15021,7 +15021,7 @@ static int zend_jit_fetch_constant(dasm_State          **Dst,
                const void *exit_addr = NULL;
 
                SET_STACK_TYPE(stack, EX_VAR_TO_NUM(opline->result.var), IS_UNKNOWN, 1);
-               SET_STACK_REG(stack, EX_VAR_TO_NUM(opline->result.var), ZREG_ZVAL_COPY_R0);
+               SET_STACK_REG(stack, EX_VAR_TO_NUM(opline->result.var), ZREG_ZVAL_COPY_GPR0);
                exit_point = zend_jit_trace_get_exit_point(opline+1, 0);
                SET_STACK_INFO(stack, EX_VAR_TO_NUM(opline->result.var), old_info);
                exit_addr = zend_jit_trace_get_exit_addr(exit_point);
@@ -15785,6 +15785,17 @@ static zend_regset zend_jit_get_scratch_regset(const zend_op *opline, const zend
        return regset;
 }
 
+static zend_regset zend_jit_get_low_priority_regset(void)
+{
+       zend_regset regset = ZEND_REGSET_EMPTY;
+
+       ZEND_REGSET_INCL(regset, ZREG_R0);
+       ZEND_REGSET_INCL(regset, ZREG_R1);
+       ZEND_REGSET_INCL(regset, ZREG_XMM0);
+       ZEND_REGSET_INCL(regset, ZREG_XMM1);
+       return regset;
+}
+
 #if defined(__clang__)
 # pragma clang diagnostic pop
 #endif

diff --git a/ext/opcache/jit/zend_jit_x86.h b/ext/opcache/jit/zend_jit_x86.h
index e9476ebb3185e929a50b6a57bf4bb61cb318a91f..d47c5be056a3d855a95de78e34dbd7b123777c36 100644 (file)
--- a/ext/opcache/jit/zend_jit_x86.h
+++ b/ext/opcache/jit/zend_jit_x86.h
@@ -74,19 +74,21 @@ typedef enum _zend_reg {
        ZREG_NULL,
 
        ZREG_ZVAL_TRY_ADDREF,
-       ZREG_ZVAL_COPY_R0,
+       ZREG_ZVAL_COPY_GPR0,
 } zend_reg;
 
 typedef struct _zend_jit_registers_buf {
 #if defined(__x86_64__) || defined(_WIN64)
-       uint64_t r[16];
-       double xmm[16];
+       uint64_t gpr[16]; /* general purpose integer register */
+       double   fpr[16]; /* floating point registers */
 #else
-       uint32_t r[8];
-       double xmm[8];
+       uint32_t gpr[8]; /* general purpose integer register */
+       double   fpr[8]; /* floating point registers */
 #endif
 } zend_jit_registers_buf;
 
+#define ZREG_FIRST_FPR ZREG_XMM0
+
 #define ZREG_RAX ZREG_R0
 #define ZREG_RCX ZREG_R1
 #define ZREG_RDX ZREG_R2