return 0;
}
+typedef struct _zend_tssa {
+ zend_ssa ssa;
+ const zend_op **tssa_opcodes;
+} zend_tssa;
+
static zend_ssa *zend_jit_trace_build_tssa(zend_jit_trace_rec *trace_buffer, uint32_t parent_trace, uint32_t exit_num, zend_script *script, const zend_op_array **op_arrays, int *num_op_arrays_ptr)
{
zend_ssa *tssa;
*num_op_arrays_ptr = num_op_arrays;
/* 2. Construct TSSA */
- tssa = zend_arena_calloc(&CG(arena), 1, sizeof(zend_ssa));
+ tssa = zend_arena_calloc(&CG(arena), 1, sizeof(zend_tssa));
tssa->cfg.blocks = zend_arena_calloc(&CG(arena), 2, sizeof(zend_basic_block));
tssa->blocks = zend_arena_calloc(&CG(arena), 2, sizeof(zend_ssa_block));
tssa->cfg.predecessors = zend_arena_calloc(&CG(arena), 2, sizeof(int));
memset(ssa_ops, -1, ssa_ops_count * sizeof(zend_ssa_op));
ssa_opcodes = zend_arena_calloc(&CG(arena), ssa_ops_count, sizeof(zend_op*));
JIT_G(current_frame) = frame = (zend_jit_trace_stack_frame*)((char*)zend_arena_alloc(&CG(arena), stack_bottom + stack_size) + stack_bottom);
+ ((zend_tssa*)tssa)->tssa_opcodes = ssa_opcodes;
if (trace_buffer->stop == ZEND_JIT_TRACE_STOP_LOOP) {
tssa->cfg.blocks_count = 2;
return tssa;
}
+static int zend_jit_trace_try_allocate_free_reg(zend_jit_trace_rec *trace_buffer, const zend_op **ssa_opcodes, zend_ssa *ssa, zend_lifetime_interval *current, zend_regset available, zend_regset *hints, zend_lifetime_interval *active, zend_lifetime_interval *inactive, zend_lifetime_interval **list, zend_lifetime_interval **free)
+{
+ zend_lifetime_interval *it;
+ uint32_t freeUntilPos[ZREG_NUM];
+ uint32_t pos, pos2;
+ zend_reg i, reg, reg2;
+ zend_reg hint = ZREG_NONE;
+ zend_regset low_priority_regs;
+ zend_life_range *range;
+
+ if ((ssa->var_info[current->ssa_var].type & MAY_BE_ANY) == MAY_BE_DOUBLE) {
+ available = ZEND_REGSET_INTERSECTION(available, ZEND_REGSET_FP);
+ } else {
+ available = ZEND_REGSET_INTERSECTION(available, ZEND_REGSET_GP);
+ }
+
+ /* TODO: Allow usage of preserved registers ???
+ * Their values have to be stored in prologuee and restored in epilogue
+ */
+ available = ZEND_REGSET_DIFFERENCE(available, ZEND_REGSET_PRESERVED);
+
+ if (ZEND_REGSET_IS_EMPTY(available)) {
+ return 0;
+ }
+
+ /* Set freeUntilPos of all physical registers to maxInt */
+ for (i = 0; i < ZREG_NUM; i++) {
+ freeUntilPos[i] = 0xffffffff;
+ }
+
+ /* for each interval it in active do */
+ /* freeUntilPos[it.reg] = 0 */
+ it = active;
+ if (ssa->vars[current->ssa_var].definition == current->range.start) {
+ while (it) {
+ if (current->range.start != zend_interval_end(it)) {
+ freeUntilPos[it->reg] = 0;
+ } else if (zend_jit_may_reuse_reg(ssa_opcodes[current->range.start], ssa->ops + current->range.start, ssa, current->ssa_var, it->ssa_var)) {
+ 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))) {
+ hint = it->reg;
+ }
+ } else {
+ freeUntilPos[it->reg] = 0;
+ }
+ it = it->list_next;
+ }
+ } else {
+ while (it) {
+ freeUntilPos[it->reg] = 0;
+ it = it->list_next;
+ }
+ }
+ if (current->hint) {
+ hint = current->hint->reg;
+ if (hint != ZREG_NONE && current->hint->used_as_hint == current) {
+ ZEND_REGSET_EXCL(*hints, hint);
+ }
+ }
+
+ /* See "Linear Scan Register Allocation on SSA Form", Christian Wimmer and
+ Michael Franz, CGO'10 (2010), Figure 6. */
+ if (current->split) {
+ /* for each interval it in inactive intersecting with current do */
+ /* freeUntilPos[it.reg] = next intersection of it with current */
+ it = inactive;
+ while (it) {
+ uint32_t next = zend_interval_intersection(current, it);
+
+ //ZEND_ASSERT(next != 0xffffffff && !current->split);
+ if (next < freeUntilPos[it->reg]) {
+ freeUntilPos[it->reg] = next;
+ }
+ it = it->list_next;
+ }
+ }
+
+ /* Handle Scratch Registers */
+ /* TODO: Optimize ??? */
+ range = ¤t->range;
+ do {
+ uint32_t line = range->start;
+ zend_regset regset;
+ zend_reg reg;
+
+ if (ssa->ops[line].op1_def == current->ssa_var ||
+ ssa->ops[line].op2_def == current->ssa_var ||
+ ssa->ops[line].result_def == current->ssa_var) {
+ line++;
+ }
+ while (line <= range->end) {
+ regset = zend_jit_get_scratch_regset(
+ ssa_opcodes[line],
+ ssa->ops + line,
+ // TODO: Support for nested call frames ???
+ trace_buffer->op_array, ssa, current->ssa_var);
+ ZEND_REGSET_FOREACH(regset, reg) {
+ if (line < freeUntilPos[reg]) {
+ freeUntilPos[reg] = line;
+ }
+ } ZEND_REGSET_FOREACH_END();
+ line++;
+ }
+ range = range->next;
+ } while (range);
+
+#if 0
+ /* Coalesing */
+ if (ssa->vars[current->ssa_var].definition == current->start) {
+ zend_op *opline = op_array->opcodes + current->start;
+ int hint = -1;
+
+ switch (opline->opcode) {
+ case ZEND_ASSIGN:
+ hint = ssa->ops[current->start].op2_use;
+ case ZEND_QM_ASSIGN:
+ hint = ssa->ops[current->start].op1_use;
+ break;
+ case ZEND_ADD:
+ case ZEND_SUB:
+ case ZEND_MUL:
+ hint = ssa->ops[current->start].op1_use;
+ break;
+ case ZEND_ASSIGN_OP:
+ if (opline->extended_value == ZEND_ADD
+ || opline->extended_value == ZEND_SUB
+ || opline->extended_value == ZEND_MUL) {
+ hint = ssa->ops[current->start].op1_use;
+ }
+ break;
+ }
+ if (hint >= 0) {
+ }
+ }
+#endif
+
+ if (hint != ZREG_NONE && freeUntilPos[hint] > zend_interval_end(current)) {
+ current->reg = hint;
+ if (current->used_as_hint) {
+ ZEND_REGSET_INCL(*hints, hint);
+ }
+ return 1;
+ }
+
+ pos = 0; reg = ZREG_NONE;
+ pos2 = 0; reg2 = ZREG_NONE;
+ 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);
+ }
+
+ ZEND_REGSET_FOREACH(available, i) {
+ if (ZEND_REGSET_IN(low_priority_regs, i)) {
+ if (freeUntilPos[i] > pos2) {
+ reg2 = i;
+ pos2 = freeUntilPos[i];
+ }
+ } else if (freeUntilPos[i] > pos) {
+ reg = i;
+ pos = freeUntilPos[i];
+ }
+ } ZEND_REGSET_FOREACH_END();
+
+ if (reg == ZREG_NONE) {
+ if (reg2 != ZREG_NONE) {
+ reg = reg2;
+ pos = pos2;
+ reg2 = ZREG_NONE;
+ }
+ }
+
+ if (reg == ZREG_NONE) {
+ /* no register available without spilling */
+ return 0;
+ } else if (zend_interval_end(current) < pos) {
+ /* register available for the whole interval */
+ current->reg = reg;
+ if (current->used_as_hint) {
+ ZEND_REGSET_INCL(*hints, reg);
+ }
+ return 1;
+#if 0
+ // TODO: allow low prioirity register usage
+ } else if (reg2 != ZREG_NONE && zend_interval_end(current) < pos2) {
+ /* register available for the whole interval */
+ current->reg = reg2;
+ if (current->used_as_hint) {
+ ZEND_REGSET_INCL(*hints, reg2);
+ }
+ return 1;
+#endif
+ } else {
+ /* TODO: enable interval splitting ??? */
+ /* register available for the first part of the interval */
+ if (1 || zend_jit_split_interval(current, pos, list, free) != SUCCESS) {
+ return 0;
+ }
+ current->reg = reg;
+ if (current->used_as_hint) {
+ ZEND_REGSET_INCL(*hints, reg);
+ }
+ return 1;
+ }
+}
+
+static zend_lifetime_interval* zend_jit_trace_linear_scan(zend_jit_trace_rec *trace_buffer, const zend_op **ssa_opcodes, zend_ssa *ssa, zend_lifetime_interval *list)
+{
+ zend_lifetime_interval *unhandled, *active, *inactive, *handled, *free;
+ zend_lifetime_interval *current, **p, *q;
+ uint32_t position;
+ zend_regset available = ZEND_REGSET_UNION(ZEND_REGSET_GP, ZEND_REGSET_FP);
+ zend_regset hints = ZEND_REGSET_EMPTY;
+
+ unhandled = list;
+ /* active = inactive = handled = free = {} */
+ active = inactive = handled = free = NULL;
+ while (unhandled != NULL) {
+ current = unhandled;
+ unhandled = unhandled->list_next;
+ position = current->range.start;
+
+ p = &active;
+ while (*p) {
+ uint32_t end = zend_interval_end(*p);
+
+ q = *p;
+ if (end < position) {
+ /* move ival from active to handled */
+ ZEND_REGSET_INCL(available, q->reg);
+ *p = q->list_next;
+ q->list_next = handled;
+ handled = q;
+ } else if (!zend_interval_covers(q, position)) {
+ /* move ival from active to inactive */
+ ZEND_REGSET_INCL(available, q->reg);
+ *p = q->list_next;
+ q->list_next = inactive;
+ inactive = q;
+ } else {
+ p = &q->list_next;
+ }
+ }
+
+ p = &inactive;
+ while (*p) {
+ uint32_t end = zend_interval_end(*p);
+
+ q = *p;
+ if (end < position) {
+ /* move ival from inactive to handled */
+ *p = q->list_next;
+ q->list_next = handled;
+ handled = q;
+ } else if (zend_interval_covers(q, position)) {
+ /* move ival from inactive to active */
+ ZEND_REGSET_EXCL(available, q->reg);
+ *p = q->list_next;
+ q->list_next = active;
+ active = q;
+ } else {
+ p = &q->list_next;
+ }
+ }
+
+ if (zend_jit_trace_try_allocate_free_reg(trace_buffer, ssa_opcodes, ssa, current, available, &hints, active, inactive, &unhandled, &free) ||
+ zend_jit_allocate_blocked_reg()) {
+ ZEND_REGSET_EXCL(available, current->reg);
+ current->list_next = active;
+ active = current;
+ } else {
+ current->list_next = free;
+ free = current;
+ }
+ }
+
+ /* move active to handled */
+ while (active) {
+ current = active;
+ active = active->list_next;
+ current->list_next = handled;
+ handled = current;
+ }
+
+ /* move inactive to handled */
+ while (inactive) {
+ current = inactive;
+ inactive = inactive->list_next;
+ current->list_next = handled;
+ handled = current;
+ }
+
+ return handled;
+}
+
+static zend_lifetime_interval** zend_jit_trace_allocate_registers(zend_jit_trace_rec *trace_buffer, zend_ssa *ssa)
+{
+ const zend_op **ssa_opcodes = ((zend_tssa*)ssa)->tssa_opcodes;
+ zend_jit_trace_rec *p;
+ const zend_op_array *op_array;
+ const zend_ssa_op *ssa_op;
+ int i, j, idx, count, level;
+ int *start, *end;
+ zend_lifetime_interval **intervals, *list;
+ void *checkpoint;
+ ALLOCA_FLAG(use_heap);
+
+ ZEND_ASSERT(ssa->var_info != NULL);
+
+ start =do_alloca(sizeof(int) * ssa->vars_count * 2, use_heap);
+ if (!start) {
+ return NULL;
+ }
+ end = start + ssa->vars_count;
+
+ memset(start, -1, sizeof(int) * ssa->vars_count * 2);
+
+ op_array = trace_buffer->op_array;
+ count = 0;
+
+ i = 0;
+ j = op_array->last_var;
+ if (trace_buffer->start != ZEND_JIT_TRACE_START_ENTER) {
+ j += op_array->T;
+ }
+ while (i < j) {
+ /* We don't start intervals for variables used in Phi */
+ if ((ssa->vars[i].use_chain >= 0 /*|| ssa->vars[i].phi_use_chain*/)
+ && zend_jit_var_supports_reg(ssa, i)) {
+ start[i] = 0;
+ count++;
+ }
+ i++;
+ }
+
+ if (trace_buffer->stop == ZEND_JIT_TRACE_STOP_LOOP) {
+ zend_ssa_phi *phi = ssa->blocks[1].phis;
+
+ while (phi) {
+ if (ssa->vars[phi->ssa_var].use_chain >= 0
+ && zend_jit_var_supports_reg(ssa, phi->ssa_var)) {
+ start[phi->ssa_var] = 0;
+ count++;
+ }
+ phi = phi->next;
+ }
+ }
+
+ p = trace_buffer + ZEND_JIT_TRACE_START_REC_SIZE;
+ level = 0;
+ ssa_op = ssa->ops;
+ idx = 0;
+ for (;;p++) {
+ if (p->op == ZEND_JIT_TRACE_VM) {
+ const zend_op *opline = p->opline;
+ int len;
+ zend_bool support_opline;
+
+ support_opline =
+ zend_jit_opline_supports_reg(op_array, ssa, opline, ssa_op);
+ if (support_opline) {
+ if (ssa_op->op1_use >= 0
+ && start[ssa_op->op1_use] >= 0
+ && !zend_ssa_is_no_val_use(opline, ssa_op, ssa_op->op1_use)) {
+ end[ssa_op->op1_use] = idx;
+ }
+ if (ssa_op->op2_use >= 0
+ && start[ssa_op->op2_use] >= 0
+ && !zend_ssa_is_no_val_use(opline, ssa_op, ssa_op->op2_use)) {
+ end[ssa_op->op2_use] = idx;
+ }
+ if (ssa_op->result_use >= 0
+ && start[ssa_op->result_use] >= 0
+ && !zend_ssa_is_no_val_use(opline, ssa_op, ssa_op->result_use)) {
+ end[ssa_op->result_use] = idx;
+ }
+ if (ssa_op->result_def >= 0
+ && (ssa->vars[ssa_op->result_def].use_chain >= 0
+ || ssa->vars[ssa_op->result_def].phi_use_chain)
+ && zend_jit_var_supports_reg(ssa, ssa_op->result_def)) {
+ start[ssa_op->result_def] = idx;
+ count++;
+ }
+ if (ssa_op->op1_def >= 0
+ && (ssa->vars[ssa_op->op1_def].use_chain >= 0
+ || ssa->vars[ssa_op->op1_def].phi_use_chain)
+ && zend_jit_var_supports_reg(ssa, ssa_op->op1_def)) {
+ start[ssa_op->op1_def] = idx;
+ count++;
+ }
+ if (ssa_op->op2_def >= 0
+ && (ssa->vars[ssa_op->op2_def].use_chain >= 0
+ || ssa->vars[ssa_op->op2_def].phi_use_chain)
+ && zend_jit_var_supports_reg(ssa, ssa_op->op2_def)) {
+ start[ssa_op->op2_def] = idx;
+ count++;
+ }
+ } else {
+ if (ssa_op->op1_use >= 0
+ && start[ssa_op->op1_use] >= 0
+ && !zend_ssa_is_no_val_use(opline, ssa_op, ssa_op->op1_use)) {
+ start[ssa_op->op1_use] = -1;
+ end[ssa_op->op1_use] = -1;
+ count--;
+ }
+ if (ssa_op->op2_use >= 0
+ && start[ssa_op->op2_use] >= 0
+ && !zend_ssa_is_no_val_use(opline, ssa_op, ssa_op->op2_use)) {
+ start[ssa_op->op2_use] = -1;
+ end[ssa_op->op2_use] = -1;
+ count--;
+ }
+ if (ssa_op->result_use >= 0
+ && start[ssa_op->result_use] >= 0
+ && !zend_ssa_is_no_val_use(opline, ssa_op, ssa_op->result_use)) {
+ start[ssa_op->result_use] = -1;
+ end[ssa_op->result_use] = -1;
+ count--;
+ }
+ }
+
+ len = zend_jit_trace_op_len(opline);
+ switch (opline->opcode) {
+ case ZEND_ASSIGN_DIM:
+ case ZEND_ASSIGN_OBJ:
+ case ZEND_ASSIGN_STATIC_PROP:
+ case ZEND_ASSIGN_DIM_OP:
+ case ZEND_ASSIGN_OBJ_OP:
+ case ZEND_ASSIGN_STATIC_PROP_OP:
+ case ZEND_ASSIGN_OBJ_REF:
+ case ZEND_ASSIGN_STATIC_PROP_REF:
+ /* OP_DATA */
+ ssa_op++;
+ opline++;
+ if (support_opline) {
+ if (ssa_op->op1_use >= 0
+ && start[ssa_op->op1_use] >= 0
+ && !zend_ssa_is_no_val_use(opline, ssa_op, ssa_op->op1_use)) {
+ end[ssa_op->op1_use] = idx;
+ }
+ if (ssa_op->op1_def >= 0
+ && (ssa->vars[ssa_op->op1_def].use_chain >= 0
+ || ssa->vars[ssa_op->op1_def].phi_use_chain)
+ && zend_jit_var_supports_reg(ssa, ssa_op->op1_def)) {
+ start[ssa_op->op1_def] = idx;
+ count++;
+ }
+ } else {
+ if (ssa_op->op1_use >= 0
+ && start[ssa_op->op1_use] >= 0
+ && !zend_ssa_is_no_val_use(opline, ssa_op, ssa_op->op1_use)) {
+ start[ssa_op->op1_use] = -1;
+ end[ssa_op->op1_use] = -1;
+ count--;
+ }
+ }
+ ssa_op++;
+ opline++;
+ idx+=2;
+ break;
+ case ZEND_RECV_INIT:
+ ssa_op++;
+ opline++;
+ idx++;
+ while (opline->opcode == ZEND_RECV_INIT) {
+ /* RECV_INIT doesn't support registers */
+ ssa_op++;
+ opline++;
+ idx++;
+ }
+ break;
+ case ZEND_BIND_GLOBAL:
+ ssa_op++;
+ opline++;
+ idx++;
+ while (opline->opcode == ZEND_BIND_GLOBAL) {
+ /* BIND_GLOBAL doesn't support registers */
+ ssa_op++;
+ opline++;
+ idx++;
+ }
+ break;
+ default:
+ ssa_op += len;
+ idx += len;
+ break;
+ }
+ } else if (p->op == ZEND_JIT_TRACE_ENTER) {
+ op_array = p->op_array;
+ /* New call frames */
+ i = op_array->last_var;
+ j = p->first_ssa_var;
+ while (i) {
+ if (ssa->vars[j].use_chain >= 0
+ && zend_jit_var_supports_reg(ssa, j)) {
+ start[j] = idx;
+ count++;
+ }
+ j++;
+ i--;
+ }
+ level++;
+ } else if (p->op == ZEND_JIT_TRACE_BACK) {
+ // TODO: Close exiting call frames ???
+ op_array = p->op_array;
+ if (level == 0) {
+ /* New return frames */
+ i = op_array->last_var + op_array->T;
+ j = p->first_ssa_var;
+ while (i) {
+ if (ssa->vars[j].use_chain >= 0
+ && zend_jit_var_supports_reg(ssa, j)) {
+ start[j] = idx;
+ count++;
+ }
+ j++;
+ i--;
+ }
+ } else {
+ level--;
+ }
+ } else if (p->op == ZEND_JIT_TRACE_END) {
+ break;
+ }
+ }
+
+ if (trace_buffer->stop == ZEND_JIT_TRACE_STOP_LOOP) {
+ zend_ssa_phi *phi = ssa->blocks[1].phis;
+
+ while (phi) {
+ if (start[phi->sources[1]] >= 0) {
+ end[phi->sources[1]] = idx - 1;
+ }
+ phi = phi->next;
+ }
+ }
+
+ if (!count) {
+ free_alloca(start, use_heap);
+ return NULL;
+ }
+
+ checkpoint = zend_arena_checkpoint(CG(arena));
+ intervals = zend_arena_calloc(&CG(arena), ssa->vars_count, sizeof(zend_lifetime_interval));
+ memset(intervals, 0, sizeof(zend_lifetime_interval*) * ssa->vars_count);
+ list = zend_arena_alloc(&CG(arena), sizeof(zend_lifetime_interval) * count);
+ j = 0;
+//fprintf(stderr, "(%d)\n", count);
+ for (i = 0; i < ssa->vars_count; i++) {
+ if (start[i] >= 0) {
+ if (end[i] < 0) {
+ // TODO: ???
+ end[i] = idx;
+ // continue;
+ }
+//fprintf(stderr, "#%d: %d..%d\n", i, start[i], end[i]);
+ ZEND_ASSERT(j < count);
+ intervals[i] = &list[j];
+ list[j].ssa_var = i;
+ list[j].reg = ZREG_NONE;
+ list[j].split = 0;
+ list[j].store = 0;
+ list[j].load = 0;
+ list[j].range.start = start[i];
+ list[j].range.end = end[i];
+ list[j].range.next = NULL;
+ list[j].hint = NULL;
+ list[j].used_as_hint = NULL;
+ list[j].list_next = NULL;
+ j++;
+ }
+ }
+ ZEND_ASSERT(j == count);
+ free_alloca(start, use_heap);
+ start = end = NULL;
+
+ /* Add hints */
+ if (trace_buffer->stop == ZEND_JIT_TRACE_STOP_LOOP) {
+ zend_ssa_phi *phi = ssa->blocks[1].phis;
+
+ while (phi) {
+ if (intervals[phi->ssa_var]) {
+ if (intervals[phi->sources[1]]) {
+ intervals[phi->sources[1]]->hint = intervals[phi->ssa_var];
+ }
+ }
+ phi = phi->next;
+ }
+ }
+
+ for (i = 0; i < ssa->vars_count; i++) {
+ if (intervals[i] && !intervals[i]->hint) {
+
+ if (ssa->vars[i].definition >= 0) {
+ uint32_t line = ssa->vars[i].definition;
+ const zend_op *opline = ssa_opcodes[line];
+
+ switch (opline->opcode) {
+ case ZEND_QM_ASSIGN:
+ case ZEND_POST_INC:
+ case ZEND_POST_DEC:
+ if (ssa->ops[line].op1_use >= 0 &&
+ intervals[ssa->ops[line].op1_use] &&
+ (i == ssa->ops[line].op1_def ||
+ (i == ssa->ops[line].result_def &&
+ (ssa->ops[line].op1_def < 0 ||
+ !intervals[ssa->ops[line].op1_def])))) {
+ zend_jit_add_hint(intervals, i, ssa->ops[line].op1_use);
+ }
+ break;
+ case ZEND_SEND_VAR:
+ case ZEND_PRE_INC:
+ case ZEND_PRE_DEC:
+ if (i == ssa->ops[line].op1_def &&
+ ssa->ops[line].op1_use >= 0 &&
+ intervals[ssa->ops[line].op1_use]) {
+ zend_jit_add_hint(intervals, i, ssa->ops[line].op1_use);
+ }
+ break;
+ case ZEND_ASSIGN:
+ if (ssa->ops[line].op2_use >= 0 &&
+ intervals[ssa->ops[line].op2_use] &&
+ (i == ssa->ops[line].op2_def ||
+ (i == ssa->ops[line].op1_def &&
+ (ssa->ops[line].op2_def < 0 ||
+ !intervals[ssa->ops[line].op2_def])) ||
+ (i == ssa->ops[line].result_def &&
+ (ssa->ops[line].op2_def < 0 ||
+ !intervals[ssa->ops[line].op2_def]) &&
+ (ssa->ops[line].op1_def < 0 ||
+ !intervals[ssa->ops[line].op1_def])))) {
+ zend_jit_add_hint(intervals, i, ssa->ops[line].op2_use);
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ list = zend_jit_sort_intervals(intervals, ssa->vars_count);
+
+ if (list) {
+ zend_lifetime_interval *ival = list;
+ while (ival) {
+ if (ival->hint) {
+ ival->hint->used_as_hint = ival;
+ }
+ ival = ival->list_next;
+ }
+
+ if (ZCG(accel_directives).jit_debug & ZEND_JIT_DEBUG_REG_ALLOC) {
+ // TODO: Support for nested call frames ???
+ op_array = trace_buffer->op_array;
+ ival = list;
+ while (ival) {
+ zend_life_range *range;
+ int var_num = ssa->vars[ival->ssa_var].var;
+
+ fprintf(stderr, "#%d.", ival->ssa_var);
+ // TODO: Support for nested call frames ???
+ zend_dump_var(op_array, (var_num < op_array->last_var ? IS_CV : 0), var_num);
+ fprintf(stderr, ": %u-%u", ival->range.start, ival->range.end);
+ range = ival->range.next;
+ while (range) {
+ fprintf(stderr, ", %u-%u", range->start, range->end);
+ range = range->next;
+ }
+ if (ival->load) {
+ fprintf(stderr, " load");
+ }
+ if (ival->store) {
+ fprintf(stderr, " store");
+ }
+ if (ival->hint) {
+ var_num = ssa->vars[ival->hint->ssa_var].var;
+ fprintf(stderr, " hint=#%d.", ival->hint->ssa_var);
+ // TODO: Support for nested call frames ???
+ zend_dump_var(op_array, (var_num < op_array->last_var ? IS_CV : 0), var_num);
+ }
+ fprintf(stderr, "\n");
+ ival = ival->list_next;
+ }
+ fprintf(stderr, "\n");
+ }
+ }
+
+ /* Linear Scan Register Allocation */
+ list = zend_jit_trace_linear_scan(trace_buffer, ssa_opcodes, ssa, list);
+
+ if (list) {
+ zend_lifetime_interval *ival, *next;
+
+ memset(intervals, 0, ssa->vars_count * sizeof(zend_lifetime_interval*));
+ ival = list;
+ while (ival != NULL) {
+ ZEND_ASSERT(ival->reg != ZREG_NONE);
+ next = ival->list_next;
+ ival->list_next = intervals[ival->ssa_var];
+ intervals[ival->ssa_var] = ival;
+ ival = next;
+ }
+
+ /* SSA resolution */
+ if (trace_buffer->stop == ZEND_JIT_TRACE_STOP_LOOP) {
+ zend_ssa_phi *phi = ssa->blocks[1].phis;
+
+ while (phi) {
+ int def = phi->ssa_var;
+ int use = phi->sources[1];
+
+ if (intervals[def]) {
+ if (!intervals[use]) {
+ intervals[def]->load = 1;
+ } else if (intervals[def]->reg != intervals[use]->reg) {
+ intervals[def]->load = 1;
+ intervals[use]->store = 1;
+ }
+ } else if (intervals[use]) {
+ intervals[use]->store = 1;
+ }
+ phi = phi->next;
+ }
+ }
+
+ // Remove useless register allocation ???
+ // Remove intervals used once ???
+
+ if (ZCG(accel_directives).jit_debug & ZEND_JIT_DEBUG_REG_ALLOC) {
+ // TODO: Support for nested call frames ???
+ fprintf(stderr, "---- TRACE %d Allocated Live Ranges\n", ZEND_JIT_TRACE_NUM);
+ for (i = 0; i < ssa->vars_count; i++) {
+ ival = intervals[i];
+ while (ival) {
+ zend_life_range *range;
+ int var_num = ssa->vars[ival->ssa_var].var;
+
+ fprintf(stderr, "#%d.", ival->ssa_var);
+ zend_dump_var(op_array, (var_num < op_array->last_var ? IS_CV : 0), var_num);
+ fprintf(stderr, ": %u-%u", ival->range.start, ival->range.end);
+ range = ival->range.next;
+ while (range) {
+ fprintf(stderr, ", %u-%u", range->start, range->end);
+ range = range->next;
+ }
+ fprintf(stderr, " (%s)", zend_reg_name[ival->reg]);
+ if (ival->load) {
+ fprintf(stderr, " load");
+ }
+ if (ival->store) {
+ fprintf(stderr, " store");
+ }
+ if (ival->hint) {
+ var_num = ssa->vars[ival->hint->ssa_var].var;
+ fprintf(stderr, " hint=#%d.", ival->hint->ssa_var);
+ zend_dump_var(op_array, (var_num < op_array->last_var ? IS_CV : 0), var_num);
+ if (ival->hint->reg != ZREG_NONE) {
+ fprintf(stderr, " (%s)", zend_reg_name[ival->hint->reg]);
+ }
+ }
+ fprintf(stderr, "\n");
+ ival = ival->list_next;
+ }
+ }
+ fprintf(stderr, "\n");
+ }
+
+ return intervals;
+ }
+
+ zend_arena_release(&CG(arena), checkpoint); //???
+ return NULL;
+}
+
static const void *zend_jit_trace(zend_jit_trace_rec *trace_buffer, uint32_t parent_trace, uint32_t exit_num)
{
const void *handler = NULL;
ssa = zend_jit_trace_build_tssa(trace_buffer, parent_trace, exit_num, script, op_arrays, &num_op_arrays);
+ /* Register allocation */
+ if (zend_jit_reg_alloc) {
+ ra = zend_jit_trace_allocate_registers(trace_buffer, ssa);
+ }
+
p = trace_buffer;
ZEND_ASSERT(p->op == ZEND_JIT_TRACE_START);
op_array = p->op_array;
(zend_jit_op_array_trace_extension*)ZEND_FUNC_INFO(op_array);
op_array_ssa = &jit_extension->func_info.ssa;
- // TODO: register allocation ???
-
dasm_growpc(&dasm_state, 1); /* trace needs just one global label for loop */
zend_jit_align_func(&dasm_state);
SET_STACK_TYPE(stack, i, concrete_type(info));
}
}
+ if (ra) {
+ zend_ssa_phi *phi = ssa->vars[i].phi_use_chain;
+ if (phi && ra[phi->ssa_var] && !ra[phi->ssa_var]->load) {
+ if (!zend_jit_load_var(&dasm_state, ssa->var_info[i].type, i, ra[phi->ssa_var]->reg)) {
+ goto jit_failure;
+ }
+ }
+ }
}
}
projects / php / commitdiff