Skip to content

Commit 378e1b0

Browse files
dstogovdstogov
committed
Merge branch 'PHP-8.4'
* PHP-8.4: Update IR
2 parents 2042fd3 + dd404dc commit 378e1b0

File tree

4 files changed

+136
-42
lines changed

4 files changed

+136
-42
lines changed

‎ext/opcache/jit/ir/ir.c‎

Lines changed: 46 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -974,7 +974,7 @@ ir_ref ir_folding(ir_ctx *ctx, uint32_t opt, ir_ref op1, ir_ref op2, ir_ref op3,
974974
} while (1);
975975

976976
ir_fold_restart:
977-
if (!(ctx->flags2 & IR_OPT_IN_SCCP)) {
977+
if (!ctx->use_lists) {
978978
op1_insn = ctx->ir_base + op1;
979979
op2_insn = ctx->ir_base + op2;
980980
op3_insn = ctx->ir_base + op3;
@@ -987,7 +987,7 @@ ir_ref ir_folding(ir_ctx *ctx, uint32_t opt, ir_ref op1, ir_ref op2, ir_ref op3,
987987
return IR_FOLD_DO_RESTART;
988988
}
989989
ir_fold_cse:
990-
if (!(ctx->flags2 & IR_OPT_IN_SCCP)) {
990+
if (!ctx->use_lists) {
991991
/* Local CSE */
992992
ref = _ir_fold_cse(ctx, opt, op1, op2, op3);
993993
if (ref) {
@@ -1017,7 +1017,7 @@ ir_ref ir_folding(ir_ctx *ctx, uint32_t opt, ir_ref op1, ir_ref op2, ir_ref op3,
10171017
return IR_FOLD_DO_CSE;
10181018
}
10191019
ir_fold_emit:
1020-
if (!(ctx->flags2 & IR_OPT_IN_SCCP)) {
1020+
if (!ctx->use_lists) {
10211021
return ir_emit(ctx, opt, op1, op2, op3);
10221022
} else {
10231023
ctx->fold_insn.optx = opt;
@@ -1027,14 +1027,14 @@ ir_ref ir_folding(ir_ctx *ctx, uint32_t opt, ir_ref op1, ir_ref op2, ir_ref op3,
10271027
return IR_FOLD_DO_EMIT;
10281028
}
10291029
ir_fold_copy:
1030-
if (!(ctx->flags2 & IR_OPT_IN_SCCP)) {
1030+
if (!ctx->use_lists) {
10311031
return ref;
10321032
} else {
10331033
ctx->fold_insn.op1 = ref;
10341034
return IR_FOLD_DO_COPY;
10351035
}
10361036
ir_fold_const:
1037-
if (!(ctx->flags2 & IR_OPT_IN_SCCP)) {
1037+
if (!ctx->use_lists) {
10381038
return ir_const(ctx, val, IR_OPT_TYPE(opt));
10391039
} else {
10401040
ctx->fold_insn.opt = IR_OPT(IR_OPT_TYPE(opt), IR_OPT_TYPE(opt));
@@ -2015,7 +2015,7 @@ ir_alias ir_check_partial_aliasing(const ir_ctx *ctx, ir_ref addr1, ir_ref addr2
20152015
return IR_MAY_ALIAS;
20162016
}
20172017

2018-
IR_ALWAYS_INLINE ir_ref ir_find_aliasing_load_i(ir_ctx *ctx, ir_ref ref, ir_type type, ir_ref addr, ir_ref limit, bool allow_casting)
2018+
IR_ALWAYS_INLINE ir_ref ir_find_aliasing_load_i(ir_ctx *ctx, ir_ref ref, ir_type type, ir_ref addr, ir_ref limit)
20192019
{
20202020
ir_insn *insn;
20212021
uint32_t modified_regset = 0;
@@ -2026,13 +2026,11 @@ IR_ALWAYS_INLINE ir_ref ir_find_aliasing_load_i(ir_ctx *ctx, ir_ref ref, ir_type
20262026
if (insn->op2 == addr) {
20272027
if (insn->type == type) {
20282028
return ref; /* load forwarding (L2L) */
2029-
} else if (!allow_casting) {
2030-
/* pass */
20312029
} else if (ir_type_size[insn->type] == ir_type_size[type]) {
2032-
return ir_fold1(ctx, IR_OPT(IR_BITCAST, type), ref); /* load forwarding with bitcast (L2L) */
2030+
return ref; /* load forwarding with bitcast (L2L) */
20332031
} else if (ir_type_size[insn->type] > ir_type_size[type]
20342032
&& IR_IS_TYPE_INT(type) && IR_IS_TYPE_INT(insn->type)) {
2035-
return ir_fold1(ctx, IR_OPT(IR_TRUNC, type), ref); /* partial load forwarding (L2L) */
2033+
return ref; /* partial load forwarding (L2L) */
20362034
}
20372035
}
20382036
} else if (insn->op == IR_STORE) {
@@ -2045,13 +2043,11 @@ IR_ALWAYS_INLINE ir_ref ir_find_aliasing_load_i(ir_ctx *ctx, ir_ref ref, ir_type
20452043
return IR_UNUSED;
20462044
} else if (type2 == type) {
20472045
return insn->op3; /* store forwarding (S2L) */
2048-
} else if (!allow_casting) {
2049-
return IR_UNUSED;
20502046
} else if (ir_type_size[type2] == ir_type_size[type]) {
2051-
return ir_fold1(ctx, IR_OPT(IR_BITCAST, type), insn->op3); /* store forwarding with bitcast (S2L) */
2047+
return insn->op3; /* store forwarding with bitcast (S2L) */
20522048
} else if (ir_type_size[type2] > ir_type_size[type]
20532049
&& IR_IS_TYPE_INT(type) && IR_IS_TYPE_INT(type2)) {
2054-
return ir_fold1(ctx, IR_OPT(IR_TRUNC, type), insn->op3); /* partial store forwarding (S2L) */
2050+
return insn->op3; /* partial store forwarding (S2L) */
20552051
} else {
20562052
return IR_UNUSED;
20572053
}
@@ -2071,10 +2067,10 @@ IR_ALWAYS_INLINE ir_ref ir_find_aliasing_load_i(ir_ctx *ctx, ir_ref ref, ir_type
20712067

20722068
ir_ref ir_find_aliasing_load(ir_ctx *ctx, ir_ref ref, ir_type type, ir_ref addr)
20732069
{
2074-
return ir_find_aliasing_load_i(ctx, ref, type, addr, (addr > 0 && addr < ref) ? addr : 1, 0);
2070+
return ir_find_aliasing_load_i(ctx, ref, type, addr, (addr > 0 && addr < ref) ? addr : 1);
20752071
}
20762072

2077-
IR_ALWAYS_INLINE ir_ref ir_find_aliasing_vload_i(ir_ctx *ctx, ir_ref ref, ir_type type, ir_ref var, bool allow_casting)
2073+
IR_ALWAYS_INLINE ir_ref ir_find_aliasing_vload_i(ir_ctx *ctx, ir_ref ref, ir_type type, ir_ref var)
20782074
{
20792075
ir_insn *insn;
20802076

@@ -2084,8 +2080,6 @@ IR_ALWAYS_INLINE ir_ref ir_find_aliasing_vload_i(ir_ctx *ctx, ir_ref ref, ir_typ
20842080
if (insn->op2 == var) {
20852081
if (insn->type == type) {
20862082
return ref; /* load forwarding (L2L) */
2087-
} else if (!allow_casting) {
2088-
/* pass */;
20892083
} else if (ir_type_size[insn->type] == ir_type_size[type]) {
20902084
return ir_fold1(ctx, IR_OPT(IR_BITCAST, type), ref); /* load forwarding with bitcast (L2L) */
20912085
} else if (ir_type_size[insn->type] > ir_type_size[type]
@@ -2099,8 +2093,6 @@ IR_ALWAYS_INLINE ir_ref ir_find_aliasing_vload_i(ir_ctx *ctx, ir_ref ref, ir_typ
20992093
if (insn->op2 == var) {
21002094
if (type2 == type) {
21012095
return insn->op3; /* store forwarding (S2L) */
2102-
} else if (!allow_casting) {
2103-
break;
21042096
} else if (ir_type_size[type2] == ir_type_size[type]) {
21052097
return ir_fold1(ctx, IR_OPT(IR_BITCAST, type), insn->op3); /* store forwarding with bitcast (S2L) */
21062098
} else if (ir_type_size[type2] > ir_type_size[type]
@@ -2121,7 +2113,7 @@ IR_ALWAYS_INLINE ir_ref ir_find_aliasing_vload_i(ir_ctx *ctx, ir_ref ref, ir_typ
21212113

21222114
ir_ref ir_find_aliasing_vload(ir_ctx *ctx, ir_ref ref, ir_type type, ir_ref var)
21232115
{
2124-
return ir_find_aliasing_vload_i(ctx, ref, type, var, 0);
2116+
return ir_find_aliasing_vload_i(ctx, ref, type, var);
21252117
}
21262118

21272119
IR_ALWAYS_INLINE ir_ref ir_find_aliasing_store_i(ir_ctx *ctx, ir_ref ref, ir_ref addr, ir_ref val, ir_ref limit)
@@ -3120,16 +3112,23 @@ void _ir_AFREE(ir_ctx *ctx, ir_ref size)
31203112

31213113
ir_ref _ir_VLOAD(ir_ctx *ctx, ir_type type, ir_ref var)
31223114
{
3123-
ir_ref ref = IR_UNUSED;
3115+
ir_ref ref;
31243116

31253117
IR_ASSERT(ctx->control);
31263118
if (EXPECTED(ctx->flags & IR_OPT_FOLDING)) {
3127-
ref = ir_find_aliasing_vload_i(ctx, ctx->control, type, var, 1);
3128-
}
3129-
if (!ref) {
3130-
ctx->control = ref = ir_emit2(ctx, IR_OPT(IR_VLOAD, type), ctx->control, var);
3119+
ref = ir_find_aliasing_vload_i(ctx, ctx->control, type, var);
3120+
if (ref) {
3121+
ir_insn *insn = &ctx->ir_base[ref];
3122+
if (insn->type == type) {
3123+
return ref;
3124+
} else if (ir_type_size[insn->type] == ir_type_size[type]) {
3125+
return ir_fold1(ctx, IR_OPT(IR_BITCAST, type), ref); /* load forwarding with bitcast (L2L) */
3126+
} else {
3127+
return ir_fold1(ctx, IR_OPT(IR_TRUNC, type), ref); /* partial load forwarding (L2L) */
3128+
}
3129+
}
31313130
}
3132-
return ref;
3131+
return ctx->control = ir_emit2(ctx, IR_OPT(IR_VLOAD, type), ctx->control, var);
31333132
}
31343133

31353134
void _ir_VSTORE(ir_ctx *ctx, ir_ref var, ir_ref val)
@@ -3164,22 +3163,36 @@ void _ir_RSTORE(ir_ctx *ctx, ir_ref reg, ir_ref val)
31643163

31653164
ir_ref _ir_LOAD(ir_ctx *ctx, ir_type type, ir_ref addr)
31663165
{
3167-
ir_ref ref = IR_UNUSED;
3166+
ir_ref ref;
31683167

31693168
IR_ASSERT(ctx->control);
31703169
if (EXPECTED(ctx->flags & IR_OPT_FOLDING)) {
3171-
ref = ir_find_aliasing_load_i(ctx, ctx->control, type, addr, (addr > 0) ? addr : 1, 1);
3172-
}
3173-
if (!ref) {
3174-
ctx->control = ref = ir_emit2(ctx, IR_OPT(IR_LOAD, type), ctx->control, addr);
3170+
if (ctx->ir_base[addr].op == IR_VADDR) {
3171+
return _ir_VLOAD(ctx, type, ctx->ir_base[addr].op1);
3172+
}
3173+
ref = ir_find_aliasing_load_i(ctx, ctx->control, type, addr, (addr > 0) ? addr : 1);
3174+
if (ref) {
3175+
ir_insn *insn = &ctx->ir_base[ref];
3176+
if (insn->type == type) {
3177+
return ref;
3178+
} else if (ir_type_size[insn->type] == ir_type_size[type]) {
3179+
return ir_fold1(ctx, IR_OPT(IR_BITCAST, type), ref); /* load forwarding with bitcast (L2L) */
3180+
} else {
3181+
return ir_fold1(ctx, IR_OPT(IR_TRUNC, type), ref); /* partial load forwarding (L2L) */
3182+
}
3183+
}
31753184
}
3176-
return ref;
3185+
return ctx->control = ir_emit2(ctx, IR_OPT(IR_LOAD, type), ctx->control, addr);
31773186
}
31783187

31793188
void _ir_STORE(ir_ctx *ctx, ir_ref addr, ir_ref val)
31803189
{
31813190
IR_ASSERT(ctx->control);
31823191
if (EXPECTED(ctx->flags & IR_OPT_FOLDING)) {
3192+
if (ctx->ir_base[addr].op == IR_VADDR) {
3193+
_ir_VSTORE(ctx, ctx->ir_base[addr].op1, val);
3194+
return;
3195+
}
31833196
if (ir_find_aliasing_store_i(ctx, ctx->control, addr, val, (addr > 0) ? addr : 1)) {
31843197
/* dead STORE */
31853198
return;

‎ext/opcache/jit/ir/ir.h‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -960,9 +960,7 @@ IR_ALWAYS_INLINE void *ir_jit_compile(ir_ctx *ctx, int opt_level, size_t *size)
960960
|| !ir_mem2ssa(ctx)) {
961961
return NULL;
962962
}
963-
if (opt_level > 1) {
964-
ir_reset_cfg(ctx);
965-
}
963+
ir_reset_cfg(ctx);
966964
}
967965

968966
if (opt_level > 1) {

‎ext/opcache/jit/ir/ir_fold.h‎

Lines changed: 60 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1469,6 +1469,27 @@ IR_FOLD(EQ(SEXT, C_ADDR))
14691469
op1 = op1_insn->op1;
14701470
op2 = IR_UNUSED;
14711471
IR_FOLD_RESTART;
1472+
} else {
1473+
ir_type type = ctx->ir_base[op1_insn->op1].type;
1474+
1475+
if (IR_IS_TYPE_SIGNED(type)) {
1476+
switch (ir_type_size[type]) {
1477+
case 1: val.i64 = op2_insn->val.i8; break;
1478+
case 2: val.i64 = op2_insn->val.i16; break;
1479+
case 4: val.i64 = op2_insn->val.i32; break;
1480+
default: val.u64 = op2_insn->val.u64; break;
1481+
}
1482+
} else {
1483+
switch (ir_type_size[type]) {
1484+
case 1: val.u64 = op2_insn->val.u8; break;
1485+
case 2: val.u64 = op2_insn->val.u16; break;
1486+
case 4: val.u64 = op2_insn->val.u32; break;
1487+
default: val.u64 = op2_insn->val.u64; break;
1488+
}
1489+
}
1490+
op1 = op1_insn->op1;
1491+
op2 = ir_const(ctx, val, type);
1492+
IR_FOLD_RESTART;
14721493
}
14731494
IR_FOLD_NEXT;
14741495
}
@@ -1490,6 +1511,27 @@ IR_FOLD(NE(SEXT, C_ADDR))
14901511
{
14911512
if (op2_insn->val.u64 == 0 && ctx->ir_base[op1_insn->op1].type == IR_BOOL) {
14921513
IR_FOLD_COPY(op1_insn->op1);
1514+
} else {
1515+
ir_type type = ctx->ir_base[op1_insn->op1].type;
1516+
1517+
if (IR_IS_TYPE_SIGNED(type)) {
1518+
switch (ir_type_size[type]) {
1519+
case 1: val.i64 = op2_insn->val.i8; break;
1520+
case 2: val.i64 = op2_insn->val.i16; break;
1521+
case 4: val.i64 = op2_insn->val.i32; break;
1522+
default: val.u64 = op2_insn->val.u64; break;
1523+
}
1524+
} else {
1525+
switch (ir_type_size[type]) {
1526+
case 1: val.u64 = op2_insn->val.u8; break;
1527+
case 2: val.u64 = op2_insn->val.u16; break;
1528+
case 4: val.u64 = op2_insn->val.u32; break;
1529+
default: val.u64 = op2_insn->val.u64; break;
1530+
}
1531+
}
1532+
op1 = op1_insn->op1;
1533+
op2 = ir_const(ctx, val, type);
1534+
IR_FOLD_RESTART;
14931535
}
14941536
IR_FOLD_NEXT;
14951537
}
@@ -1586,6 +1628,24 @@ IR_FOLD(SUB_OV(_, C_ADDR))
15861628
IR_FOLD_NEXT;
15871629
}
15881630

1631+
/* This rule is useful for ADD(0, SYM) => SYM */
1632+
IR_FOLD(ADD(C_U8, _))
1633+
IR_FOLD(ADD(C_U16, _))
1634+
IR_FOLD(ADD(C_U32, _))
1635+
IR_FOLD(ADD(C_U64, _))
1636+
IR_FOLD(ADD(C_I8, _))
1637+
IR_FOLD(ADD(C_I16, _))
1638+
IR_FOLD(ADD(C_I32, _))
1639+
IR_FOLD(ADD(C_I64, _))
1640+
IR_FOLD(ADD(C_ADDR, _))
1641+
{
1642+
if (op1_insn->val.u64 == 0) {
1643+
/* 0 + a => a */
1644+
IR_FOLD_COPY(op2);
1645+
}
1646+
IR_FOLD_NEXT;
1647+
}
1648+
15891649
IR_FOLD(SUB(C_I8, _))
15901650
IR_FOLD(SUB(C_I16, _))
15911651
IR_FOLD(SUB(C_I32, _))

‎ext/opcache/jit/ir/ir_sccp.c‎

Lines changed: 29 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -3009,17 +3009,41 @@ void ir_iter_opt(ir_ctx *ctx, ir_bitqueue *worklist)
30093009
} else if (insn->op == IR_LOAD) {
30103010
val = ir_find_aliasing_load(ctx, insn->op1, insn->type, insn->op2);
30113011
if (val) {
3012+
ir_insn *val_insn;
30123013
ir_ref prev, next;
30133014

3014-
remove_load:
3015+
remove_aliased_load:
30153016
prev = insn->op1;
30163017
next = ir_next_control(ctx, i);
30173018
ctx->ir_base[next].op1 = prev;
30183019
ir_use_list_remove_one(ctx, i, next);
30193020
ir_use_list_replace_one(ctx, prev, i, next);
30203021
insn->op1 = IR_UNUSED;
30213022

3022-
ir_iter_replace_insn(ctx, i, val, worklist);
3023+
val_insn = &ctx->ir_base[val];
3024+
if (val_insn->type == insn->type) {
3025+
ir_iter_replace_insn(ctx, i, val, worklist);
3026+
} else {
3027+
IR_ASSERT(!IR_IS_CONST_REF(insn->op2));
3028+
ir_use_list_remove_one(ctx, insn->op2, i);
3029+
if (ir_is_dead(ctx, insn->op2)) {
3030+
/* schedule DCE */
3031+
ir_bitqueue_add(worklist, insn->op2);
3032+
}
3033+
if (!IR_IS_CONST_REF(val)) {
3034+
ir_use_list_add(ctx, val, i);
3035+
}
3036+
if (ir_type_size[val_insn->type] == ir_type_size[insn->type]) {
3037+
/* load forwarding with bitcast (L2L) */
3038+
insn->optx = IR_OPTX(IR_BITCAST, insn->type, 1);
3039+
} else {
3040+
/* partial load forwarding (L2L) */
3041+
insn->optx = IR_OPTX(IR_TRUNC, insn->type, 1);
3042+
}
3043+
insn->op1 = val;
3044+
insn->op2 = IR_UNUSED;
3045+
ir_bitqueue_add(worklist, i);
3046+
}
30233047
}
30243048
} else if (insn->op == IR_STORE) {
30253049
if (ir_find_aliasing_store(ctx, insn->op1, insn->op2, insn->op3)) {
@@ -3049,7 +3073,7 @@ void ir_iter_opt(ir_ctx *ctx, ir_bitqueue *worklist)
30493073
} else if (insn->op == IR_VLOAD) {
30503074
val = ir_find_aliasing_vload(ctx, insn->op1, insn->type, insn->op2);
30513075
if (val) {
3052-
goto remove_load;
3076+
goto remove_aliased_load;
30533077
}
30543078
} else if (insn->op == IR_VSTORE) {
30553079
if (ir_find_aliasing_vstore(ctx, insn->op1, insn->op2, insn->op3)) {
@@ -3080,13 +3104,14 @@ int ir_sccp(ir_ctx *ctx)
30803104
ir_bitqueue sccp_worklist, iter_worklist;
30813105
ir_insn *_values;
30823106

3083-
ctx->flags2 |= IR_OPT_IN_SCCP;
30843107
ir_bitqueue_init(&iter_worklist, ctx->insns_count);
30853108
ir_bitqueue_init(&sccp_worklist, ctx->insns_count);
30863109
_values = ir_mem_calloc(ctx->insns_count, sizeof(ir_insn));
30873110

3111+
ctx->flags2 |= IR_OPT_IN_SCCP;
30883112
ir_sccp_analyze(ctx, _values, &sccp_worklist, &iter_worklist);
30893113
ir_sccp_transform(ctx, _values, &sccp_worklist, &iter_worklist);
3114+
ctx->flags2 &= ~IR_OPT_IN_SCCP;
30903115

30913116
ir_mem_free(_values);
30923117
ir_bitqueue_free(&sccp_worklist);
@@ -3097,7 +3122,5 @@ int ir_sccp(ir_ctx *ctx)
30973122

30983123
ir_bitqueue_free(&iter_worklist);
30993124

3100-
ctx->flags2 &= ~IR_OPT_IN_SCCP;
3101-
31023125
return 1;
31033126
}

0 commit comments

Comments
 (0)