Return -1 to signal execute_data reloading

Instead of returning -opline. This simplifies JIT as we can simply
return -1 for VM_ENTER/VM_LEAVE. However, this implies that EX(opline) must be
in sync.

Author: arnaud-lb

Zend/zend_vm_execute.h

@@ -1944,9 +1944,9 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name)
                             out($f,"# define ZEND_VM_ENTER()           opline = EG(current_execute_data)->opline; ZEND_VM_ENTER_EX()\n");
                             out($f,"# define ZEND_VM_LEAVE()           return  2\n");
                             out($f,"#else\n");
-                            out($f,"# define ZEND_VM_ENTER_EX()        return (zend_op*)-(uintptr_t)opline\n");
-                            out($f,"# define ZEND_VM_ENTER()           execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_ENTER_EX()\n");
-                            out($f,"# define ZEND_VM_LEAVE()           return (zend_op*)-(uintptr_t)opline\n");
+                            out($f,"# define ZEND_VM_ENTER_EX()        return (zend_op*)-1\n");
+                            out($f,"# define ZEND_VM_ENTER()           ZEND_VM_ENTER_EX()\n");
+                            out($f,"# define ZEND_VM_LEAVE()           return (zend_op*)-1\n");
                             out($f,"#endif\n");
                             out($f,"#define ZEND_VM_INTERRUPT()      ZEND_VM_TAIL_CALL(zend_interrupt_helper".($spec?"_SPEC":"")."(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));\n");
                             out($f,"#define ZEND_VM_LOOP_INTERRUPT() zend_interrupt_helper".($spec?"_SPEC":"")."(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);\n");
@@ -2181,8 +2181,8 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name)
                                 $m[1]."return;\n" .
                                 "#else\n" .
                                 $m[1]."if (EXPECTED(opline != NULL)) {\n" .
-                                $m[1]."\topline = (zend_op*)-(uintptr_t)opline;\n".
                                 $m[1]."\texecute_data = EG(current_execute_data);\n".
+                                $m[1]."\topline = EX(opline);\n".
                                 $m[1]."\tZEND_VM_LOOP_INTERRUPT_CHECK();\n".
                                 $m[1]."} else {\n" .
                                 "# ifdef ZEND_VM_IP_GLOBAL_REG\n" .

Zend/zend_vm_gen.php

@@ -145,7 +145,6 @@ extern "C" {
 #define ir_MOD_I64(_op1, _op2)            ir_BINARY_OP_I64(IR_MOD, (_op1), (_op2))
 
 #define ir_NEG(_type, _op1)               ir_UNARY_OP(IR_NEG, (_type), (_op1))
-#define ir_NEG_A(_op1)                    ir_UNARY_OP_A(IR_NEG, (_op1))
 #define ir_NEG_C(_op1)                    ir_UNARY_OP_C(IR_NEG, (_op1))
 #define ir_NEG_I8(_op1)                   ir_UNARY_OP_I8(IR_NEG, (_op1))
 #define ir_NEG_I16(_op1)                  ir_UNARY_OP_I16(IR_NEG, (_op1))

ext/opcache/jit/ir/ir_builder.h

@@ -1885,6 +1885,7 @@ static void zend_jit_check_timeout(zend_jit_ctx *jit, const zend_op *opline, con
 
 		ir_IF_TRUE_cold(if_timeout);
 		jit_LOAD_IP_ADDR(jit, opline);
+		ir_STORE(jit_EX(opline), ir_CONST_ADDR(opline));
 		ir_IJMP(jit_STUB_ADDR(jit, jit_stub_interrupt_handler));
 		ir_IF_FALSE(if_timeout);
 	}
@@ -2011,7 +2012,7 @@ static int zend_jit_interrupt_handler_stub(zend_jit_ctx *jit)
 	if (GCC_GLOBAL_REGS) {
 		ir_TAILCALL(IR_VOID, ir_LOAD_A(jit_IP(jit)));
 	} else {
-		ir_RETURN(ir_NEG_A(jit_IP(jit))); // ZEND_VM_ENTER
+		ir_RETURN(ir_CONST_ADDR(-1)); // ZEND_VM_ENTER
 	}
 	return 1;
 }
@@ -2206,13 +2207,13 @@ static int zend_jit_leave_throw_stub(zend_jit_ctx *jit)
 	// JIT: opline = EG(exception_op);
 	jit_LOAD_IP(jit, jit_EG(exception_op));
 
-	if (GCC_GLOBAL_REGS) {
-		ir_STORE(jit_EX(opline), jit_IP(jit));
+	ir_STORE(jit_EX(opline), jit_IP(jit));
 
+	if (GCC_GLOBAL_REGS) {
 		// JIT: HANDLE_EXCEPTION()
 		ir_IJMP(jit_STUB_ADDR(jit, jit_stub_exception_handler));
 	} else {
-		ir_RETURN(ir_NEG_A(jit_IP(jit))); // ZEND_VM_LEAVE
+		ir_RETURN(ir_CONST_ADDR(-1)); // ZEND_VM_LEAVE
 	}
 
 	return 1;
@@ -2407,8 +2408,8 @@ static int zend_jit_trace_escape_stub(zend_jit_ctx *jit)
 	if (GCC_GLOBAL_REGS) {
 		ir_TAILCALL(IR_VOID, ir_LOAD_A(jit_IP(jit)));
 	} else {
-		// TODO: tailcall?
-		ir_RETURN(ir_NEG_A(jit_IP(jit))); // ZEND_VM_ENTER
+		ir_STORE(jit_EX(opline), jit_IP(jit)); // TODO: do we need this?
+		ir_RETURN(ir_CONST_ADDR(-1)); // ZEND_VM_ENTER
 	}
 
 	return 1;
@@ -2434,8 +2435,7 @@ static int zend_jit_trace_exit_stub(zend_jit_ctx *jit)
 		jit_STORE_IP(jit, ref);
 		ir_TAILCALL(IR_VOID, ir_LOAD_A(jit_IP(jit)));
 	} else {
-		ref = ir_LOAD_A(jit_EX(opline));
-		ir_RETURN(ir_NEG_A(ref)); // ZEND_VM_ENTER
+		ir_RETURN(ir_CONST_ADDR(-1)); // ZEND_VM_ENTER
 	}
 
 	ir_IF_FALSE(if_zero);
@@ -2458,13 +2458,9 @@ static int zend_jit_trace_exit_stub(zend_jit_ctx *jit)
 #if defined(IR_TARGET_X86)
 		addr = ir_CAST_FC_FUNC(addr);
 #endif
-		ref = ir_CALL_2(IR_ADDR, addr, jit_FP(jit), jit_IP(jit));
-		// Force reload execute_ex in VM
-		ir_ref is_positive = ir_IF(ir_GE(ref, ir_CONST_I32(0)));
-		ir_IF_TRUE(is_positive);
-		ir_RETURN(ir_NEG_A(ref)); // ZEND_VM_ENTER
-		ir_IF_FALSE(is_positive);
-		ir_RETURN(ref);
+		ir_CALL_2(IR_ADDR, addr, jit_FP(jit), jit_IP(jit));
+		ir_GUARD(ir_GT(ref, ir_CONST_I32(0)), jit_STUB_ADDR(jit, jit_stub_trace_halt));
+		ir_RETURN(ir_CONST_ADDR(-1)); // ZEND_VM_ENTER
 	}
 
 	return 1;
@@ -4213,13 +4209,8 @@ static int zend_jit_tail_handler(zend_jit_ctx *jit, const zend_op *opline)
 		  || opline->opcode == ZEND_MATCH_ERROR
 		  || opline->opcode == ZEND_THROW
 		  || opline->opcode == ZEND_VERIFY_NEVER_TYPE)) {
-			ir_ref ip = ir_CALL_2(IR_ADDR, ir_CONST_FC_FUNC(handler), jit_FP(jit), jit_IP(jit));
-			// Force reload execute_ex in VM (TODO: check if we actually need this)
-			ir_ref is_positive = ir_IF(ir_GE(ip, ir_CONST_I32(0)));
-			ir_IF_TRUE(is_positive);
-			ir_RETURN(ir_NEG_A(ip)); // ZEND_VM_ENTER
-			ir_IF_FALSE(is_positive);
-			ir_RETURN(ip);
+			ir_CALL_2(IR_ADDR, ir_CONST_FC_FUNC(handler), jit_FP(jit), jit_IP(jit));
+			ir_RETURN(ir_CONST_ADDR(-1)); // ZEND_VM_ENTER
 		} else {
 			ir_TAILCALL_2(IR_ADDR, ir_CONST_FC_FUNC(handler), jit_FP(jit), jit_IP(jit));
 		}
@@ -7977,6 +7968,7 @@ static int zend_jit_escape_if_undef(zend_jit_ctx *jit, int var, uint32_t flags,
 	}
 
 	jit_LOAD_IP_ADDR(jit, opline - 1);
+	ir_STORE(jit_EX(opline), ir_CONST_ADDR(opline));
 	ir_IJMP(jit_STUB_ADDR(jit, jit_stub_trace_escape));
 
 	ir_IF_TRUE(if_def);
@@ -10236,6 +10228,7 @@ static int zend_jit_do_fcall(zend_jit_ctx *jit, const zend_op *opline, const zen
 					}
 					if (zend_accel_in_shm(func->op_array.opcodes)) {
 						jit_LOAD_IP_ADDR(jit, func->op_array.opcodes + num_args);
+						ir_STORE(jit_EX(opline), ir_CONST_ADDR(func->op_array.opcodes + num_args));
 					} else {
 						if (!func_ref) {
 							func_ref = ir_LOAD_A(jit_CALL(rx, func));
@@ -10245,6 +10238,7 @@ static int zend_jit_do_fcall(zend_jit_ctx *jit, const zend_op *opline, const zen
 							ip = ir_ADD_OFFSET(ip, num_args * sizeof(zend_op));
 						}
 						jit_LOAD_IP(jit, ip);
+						ir_STORE(jit_EX(opline), ip);
 					}
 
 					if (!trace && op_array == &func->op_array && call_num_args >= op_array->required_num_args) {
@@ -10267,6 +10261,7 @@ static int zend_jit_do_fcall(zend_jit_ctx *jit, const zend_op *opline, const zen
 						ip = ir_LOAD_A(ir_ADD_OFFSET(func_ref, offsetof(zend_op_array, opcodes)));
 					}
 					jit_LOAD_IP(jit, ip);
+					ir_STORE(jit_EX(opline), ip);
 					helper = ir_CONST_FC_FUNC(zend_jit_copy_extra_args_helper);
 				} else {
 					helper = ir_CONST_FC_FUNC(zend_jit_copy_extra_args_helper_no_skip_recv);
@@ -10291,6 +10286,7 @@ static int zend_jit_do_fcall(zend_jit_ctx *jit, const zend_op *opline, const zen
 				ip = ir_LOAD_A(ir_ADD_OFFSET(func_ref, offsetof(zend_op_array, opcodes)));
 			}
 			jit_LOAD_IP(jit, ip);
+			ir_STORE(jit_EX(opline), ip);
 
 			// JIT: num_args = EX_NUM_ARGS();
 			ir_ref num_args, first_extra_arg;
@@ -10448,7 +10444,7 @@ static int zend_jit_do_fcall(zend_jit_ctx *jit, const zend_op *opline, const zen
 				if (GCC_GLOBAL_REGS) {
 					ir_TAILCALL(IR_VOID, ir_LOAD_A(jit_IP(jit)));
 				} else {
-					ir_RETURN(ir_NEG_A(jit_IP(jit))); // ZEND_VM_ENTER
+					ir_RETURN(ir_CONST_ADDR(-1)); // ZEND_VM_ENTER
 				}
 			} while (0);
 
@@ -10682,10 +10678,12 @@ static int zend_jit_do_fcall(zend_jit_ctx *jit, const zend_op *opline, const zen
 
 		if ((!trace || !func) && opline->opcode != ZEND_DO_ICALL) {
 			jit_LOAD_IP_ADDR(jit, opline + 1);
+			ir_STORE(jit_EX(opline), ir_CONST_ADDR(opline + 1));
 		} else if (trace
 		 && trace->op == ZEND_JIT_TRACE_END
 		 && trace->stop >= ZEND_JIT_TRACE_STOP_INTERPRETER) {
 			jit_LOAD_IP_ADDR(jit, opline + 1);
+			ir_STORE(jit_EX(opline), ir_CONST_ADDR(opline + 1));
 		}
 	}
 
@@ -11216,7 +11214,7 @@ static int zend_jit_leave_func(zend_jit_ctx         *jit,
 	if (GCC_GLOBAL_REGS) {
 		ir_TAILCALL(IR_VOID, ir_LOAD_A(jit_IP(jit)));
 	} else {
-		ir_RETURN(ir_NEG_A(jit_IP(jit))); // ZEND_VM_LEAVE
+		ir_RETURN(ir_CONST_ADDR(-1)); // ZEND_VM_LEAVE
 	}
 
 	jit->b = -1;
@@ -17346,7 +17344,7 @@ static int zend_jit_trace_return(zend_jit_ctx *jit, bool original_handler, const
 				return 1;
 			}
 		}
-		ir_RETURN(ir_NEG_A(jit_IP(jit))); // ZEND_VM_RETURN
+		ir_RETURN(ir_CONST_ADDR(-1)); // ZEND_VM_LEAVE
 	}
 	return 1;
 }