Merge remote-tracking branch 'origin/master' into native-tls

* origin/master:
  updated NEWS
  PowerPC64 support for add and sub with overflow check
  PowerPC64 support for operators with overflow check
  Fixed bug #68583 Crash in timeout thread
  Reduced size of zend_op on 64-bit systems.
  Make ZEND_INIT_FCALL keep predcalculted size of necessary stack space in opline->op1.num to avoid its recalculation on each execution.
  Removed unused variables
  Improved array_merge() and array_replace() (1-st array may be added using simple procedure).
  Replaced zendi_convert_to_long() with _zval_get_long_func()
  Moved zend_is_true() from zend_execute.h/zend_execute_API.c into zend_operators.h/zend_operators.c. Splited the most expensive part of inline i_zend_is_true() into a separate zend_object_is_true(). Replaced zendi_convert_to_long() with cals to zend_is_true().
  Revert "Save one xor instr"
  Save one xor instr

Conflicts:
	Zend/zend_execute_API.c

Author: weltling

Zend/zend.c

@@ -731,9 +731,6 @@ void zend_shutdown(TSRMLS_D) /* {{{ */
 {
 #ifdef ZEND_SIGNALS
 	zend_signal_shutdown(TSRMLS_C);
-#endif
-#ifdef ZEND_WIN32
-	zend_shutdown_timeout_thread();
 #endif
 	zend_destroy_rsrc_list(&EG(persistent_list) TSRMLS_CC);
 	if (EG(active))

Zend/zend_compile.c

@@ -32,12 +32,6 @@
 #include "zend_language_scanner.h"
 #include "zend_inheritance.h"
 
-#define CONSTANT_EX(op_array, op) \
-	(op_array)->literals[op]
-
-#define CONSTANT(op) \
-	CONSTANT_EX(CG(active_op_array), op)
-
 #define SET_NODE(target, src) do { \
 		target ## _type = (src)->op_type; \
 		if ((src)->op_type == IS_CONST) { \
@@ -50,7 +44,7 @@
 #define GET_NODE(target, src) do { \
 		(target)->op_type = src ## _type; \
 		if ((target)->op_type == IS_CONST) { \
-			(target)->u.constant = CONSTANT(src.constant); \
+			ZVAL_COPY_VALUE(&(target)->u.constant, CT_CONSTANT(src)); \
 		} else { \
 			(target)->u.op = src; \
 		} \
@@ -291,11 +285,11 @@ static int lookup_cv(zend_op_array *op_array, zend_string* name TSRMLS_DC) /* {{
 
 void zend_del_literal(zend_op_array *op_array, int n) /* {{{ */
 {
-	zval_dtor(&CONSTANT_EX(op_array, n));
+	zval_dtor(CT_CONSTANT_EX(op_array, n));
 	if (n + 1 == op_array->last_literal) {
 		op_array->last_literal--;
 	} else {
-		ZVAL_UNDEF(&CONSTANT_EX(op_array, n));
+		ZVAL_UNDEF(CT_CONSTANT_EX(op_array, n));
 	}
 }
 /* }}} */
@@ -310,7 +304,7 @@ static inline void zend_insert_literal(zend_op_array *op_array, zval *zv, int li
 			Z_TYPE_FLAGS_P(zv) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
 		}
 	}
-	ZVAL_COPY_VALUE(&CONSTANT_EX(op_array, literal_position), zv);
+	ZVAL_COPY_VALUE(CT_CONSTANT_EX(op_array, literal_position), zv);
 	Z_CACHE_SLOT(op_array->literals[literal_position]) = -1;
 }
 /* }}} */
@@ -752,13 +746,13 @@ static void str_dtor(zval *zv)  /* {{{ */ {
 void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */
 {
 	zend_label *dest;
-	zend_long current, distance;
+	int current, distance;
 	zval *label;
 
 	if (pass2) {
-		label = opline->op2.zv;
+		label = RT_CONSTANT(op_array, opline->op2);
 	} else {
-		label = &CONSTANT_EX(op_array, opline->op2.constant);
+		label = CT_CONSTANT_EX(op_array, opline->op2.constant);
 	}
 	if (CG(context).labels == NULL ||
 	    (dest = zend_hash_find_ptr(CG(context).labels, Z_STR_P(label))) == NULL) {
@@ -888,11 +882,11 @@ ZEND_API int do_bind_function(const zend_op_array *op_array, const zend_op *opli
 	zval *op1, *op2;
 
 	if (compile_time) {
-		op1 = &CONSTANT_EX(op_array, opline->op1.constant);
-		op2 = &CONSTANT_EX(op_array, opline->op2.constant);
+		op1 = CT_CONSTANT_EX(op_array, opline->op1.constant);
+		op2 = CT_CONSTANT_EX(op_array, opline->op2.constant);
 	} else {
-		op1 = opline->op1.zv;
-		op2 = opline->op2.zv;
+		op1 = RT_CONSTANT(op_array, opline->op1);
+		op2 = RT_CONSTANT(op_array, opline->op2);
 	}
 
 	function = zend_hash_find_ptr(function_table, Z_STR_P(op1));
@@ -928,11 +922,11 @@ ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const ze
 	zval *op1, *op2;
 
 	if (compile_time) {
-		op1 = &CONSTANT_EX(op_array, opline->op1.constant);
-		op2 = &CONSTANT_EX(op_array, opline->op2.constant);
+		op1 = CT_CONSTANT_EX(op_array, opline->op1.constant);
+		op2 = CT_CONSTANT_EX(op_array, opline->op2.constant);
 	} else {
-		op1 = opline->op1.zv;
-		op2 = opline->op2.zv;
+		op1 = RT_CONSTANT(op_array, opline->op1);
+		op2 = RT_CONSTANT(op_array, opline->op2);
 	}
 	if ((ce = zend_hash_find_ptr(class_table, Z_STR_P(op1))) == NULL) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", Z_STRVAL_P(op1));
@@ -965,11 +959,11 @@ ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array
 	zval *op1, *op2;
 
 	if (compile_time) {
-		op1 = &CONSTANT_EX(op_array, opline->op1.constant);
-		op2 = &CONSTANT_EX(op_array, opline->op2.constant);
+		op1 = CT_CONSTANT_EX(op_array, opline->op1.constant);
+		op2 = CT_CONSTANT_EX(op_array, opline->op2.constant);
 	} else {
-		op1 = opline->op1.zv;
-		op2 = opline->op2.zv;
+		op1 = RT_CONSTANT(op_array, opline->op1);
+		op2 = RT_CONSTANT(op_array, opline->op2);
 	}
 
 	ce = zend_hash_find_ptr(class_table, Z_STR_P(op1));
@@ -1032,7 +1026,7 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */
 				zval *parent_name;
 				zend_class_entry *ce;
 
-				parent_name = &CONSTANT(fetch_class_opline->op2.constant);
+				parent_name = CT_CONSTANT(fetch_class_opline->op2);
 				if (((ce = zend_lookup_class(Z_STR_P(parent_name) TSRMLS_CC)) == NULL) ||
 				    ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) &&
 				     (ce->type == ZEND_INTERNAL_CLASS))) {
@@ -1071,7 +1065,7 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */
 			return;
 	}
 
-	zend_hash_del(table, Z_STR(CONSTANT(opline->op1.constant)));
+	zend_hash_del(table, Z_STR_P(CT_CONSTANT(opline->op1)));
 	zend_del_literal(CG(active_op_array), opline->op1.constant);
 	zend_del_literal(CG(active_op_array), opline->op2.constant);
 	MAKE_NOP(opline);
@@ -1087,7 +1081,7 @@ ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS
 
 		CG(in_compilation) = 1;
 		while (opline_num != -1) {
-			if ((ce = zend_lookup_class(Z_STR_P(op_array->opcodes[opline_num-1].op2.zv) TSRMLS_CC)) != NULL) {
+			if ((ce = zend_lookup_class(Z_STR_P(RT_CONSTANT(op_array, op_array->opcodes[opline_num-1].op2)) TSRMLS_CC)) != NULL) {
 				do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), ce, 0 TSRMLS_CC);
 			}
 			opline_num = op_array->opcodes[opline_num].result.opline_num;
@@ -2112,7 +2106,7 @@ static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t
 
 	opline = zend_delayed_emit_op(result, ZEND_FETCH_OBJ_R, &obj_node, &prop_node TSRMLS_CC);
 	if (opline->op2_type == IS_CONST) {
-		convert_to_string(&CONSTANT(opline->op2.constant));
+		convert_to_string(CT_CONSTANT(opline->op2));
 		zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
 	}
 
@@ -2509,6 +2503,10 @@ void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function *
 	opline = &CG(active_op_array)->opcodes[opnum_init];
 	opline->extended_value = arg_count;
 
+	if (opline->opcode == ZEND_INIT_FCALL) {
+		opline->op1.num = zend_vm_calc_used_stack(arg_count, fbc);
+	}
+
 	call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0);
 	opline = zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
 	opline->op1.num = call_flags;
@@ -2662,7 +2660,7 @@ static int zend_try_compile_ct_bound_init_user_func(zend_ast *name_ast, uint32_t
 
 	opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, NULL TSRMLS_CC);
 	opline->extended_value = num_args;
-
+	opline->op1.num = zend_vm_calc_used_stack(num_args, fbc);
 	opline->op2_type = IS_CONST;
 	LITERAL_STR(opline->op2, lcname);
 	zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
@@ -3515,7 +3513,7 @@ void zend_compile_switch(zend_ast *ast TSRMLS_DC) /* {{{ */
 		opline = zend_emit_op(NULL, ZEND_CASE, &expr_node, &cond_node TSRMLS_CC);
 		SET_NODE(opline->result, &case_node);
 		if (opline->op1_type == IS_CONST) {
-			zval_copy_ctor(&CONSTANT(opline->op1.constant));
+			zval_copy_ctor(CT_CONSTANT(opline->op1));
 		}
 
 		jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0 TSRMLS_CC);

Zend/zend_compile.h

@@ -56,13 +56,34 @@ typedef struct _zend_compiler_context {
 	HashTable *labels;
 } zend_compiler_context;
 
+/* On 64-bi systems less optimal, but more compact VM code leads to better
+ * performance. So on 32-bit systems we use absolute addresses for jump
+ * targets and constants, but on 64-bit systems realtive 32-bit offsets */
+#if SIZEOF_SIZE_T == 4
+# define ZEND_USE_ABS_JMP_ADDR      1
+# define ZEND_USE_ABS_CONST_ADDR    1
+# define ZEND_EX_USE_LITERALS       0
+# define ZEND_EX_USE_RUN_TIME_CACHE 1
+#else
+# define ZEND_USE_ABS_JMP_ADDR      0
+# define ZEND_USE_ABS_CONST_ADDR    0
+# define ZEND_EX_USE_LITERALS       1
+# define ZEND_EX_USE_RUN_TIME_CACHE 1
+#endif
+
 typedef union _znode_op {
 	uint32_t      constant;
 	uint32_t      var;
 	uint32_t      num;
 	uint32_t      opline_num; /*  Needs to be signed */
+#if ZEND_USE_ABS_JMP_ADDR
 	zend_op       *jmp_addr;
+#else
+	uint32_t      jmp_offset;
+#endif
+#if ZEND_USE_ABS_CONST_ADDR
 	zval          *zv;
+#endif
 } znode_op;
 
 typedef struct _znode { /* used only during compilation */
@@ -112,8 +133,8 @@ struct _zend_op {
 	znode_op op1;
 	znode_op op2;
 	znode_op result;
-	zend_ulong extended_value;
-	uint lineno;
+	uint32_t extended_value;
+	uint32_t lineno;
 	zend_uchar opcode;
 	zend_uchar op1_type;
 	zend_uchar op2_type;
@@ -374,12 +395,17 @@ typedef enum _zend_call_kind {
 struct _zend_execute_data {
 	const zend_op       *opline;           /* executed opline                */
 	zend_execute_data   *call;             /* current call                   */
-	void               **run_time_cache;
+	zval                *return_value;
 	zend_function       *func;             /* executed op_array              */
 	zval                 This;
+#if ZEND_EX_USE_RUN_TIME_CACHE
+	void               **run_time_cache;
+#endif
+#if ZEND_EX_USE_LITERALS
+	zval                *literals;
+#endif
 	zend_class_entry    *called_scope;
 	zend_execute_data   *prev_execute_data;
-	zval                *return_value;
 	zend_array          *symbol_table;
 };
 
@@ -430,6 +456,136 @@ struct _zend_execute_data {
 
 #define EX_VAR_TO_NUM(n)		(ZEND_CALL_VAR(NULL, n) - ZEND_CALL_VAR_NUM(NULL, 0))
 
+#define ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline_num) \
+	((char*)&(op_array)->opcodes[opline_num] - (char*)(opline))
+
+#define ZEND_OFFSET_TO_OPLINE(base, offset) \
+	((zend_op*)(((char*)(base)) + (int)offset))
+
+#define ZEND_OFFSET_TO_OPLINE_NUM(op_array, base, offset) \
+	(ZEND_OFFSET_TO_OPLINE(base, offset) - op_array->opcodes)
+
+#if ZEND_USE_ABS_JMP_ADDR
+
+/* run-time jump target */
+# define OP_JMP_ADDR(opline, node) \
+	(node).jmp_addr
+
+/* convert jump target from compile-time to run-time */
+# define ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, node) do { \
+		(node).jmp_addr = (op_array)->opcodes + (node).opline_num; \
+	} while (0)
+
+/* convert jump target back from run-time to compile-time */
+# define ZEND_PASS_TWO_UNDO_JMP_TARGET(op_array, opline, node) do { \
+		(node).opline_num = (node).jmp_addr - (op_array)->opcodes; \
+	} while (0)
+
+#else
+
+/* run-time jump target */
+# define OP_JMP_ADDR(opline, node) \
+	ZEND_OFFSET_TO_OPLINE(opline, (node).jmp_offset)
+
+/* convert jump target from compile-time to run-time */
+# define ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, node) do { \
+		(node).jmp_offset = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, (node).opline_num); \
+	} while (0)
+
+/* convert jump target back from run-time to compile-time */
+# define ZEND_PASS_TWO_UNDO_JMP_TARGET(op_array, opline, node) do { \
+		(node).opline_num = ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, (node).jmp_offset); \
+	} while (0)		
+
+#endif
+
+/* constant-time constant */
+# define CT_CONSTANT_EX(op_array, num) \
+	((op_array)->literals + (num))
+
+# define CT_CONSTANT(node) \
+	CT_CONSTANT_EX(CG(active_op_array), (node).constant)
+
+#if ZEND_USE_ABS_CONST_ADDR
+
+/* run-time constant */
+# define RT_CONSTANT_EX(base, node) \
+	(node).zv
+
+/* convert constant from compile-time to run-time */
+# define ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, node) do { \
+		(node).zv = CT_CONSTANT_EX(op_array, (node).constant); \
+	} while (0)
+
+/* convert constant back from run-time to compile-time */
+# define ZEND_PASS_TWO_UNDO_CONSTANT(op_array, node) do { \
+		(node).constant = (node).zv - (op_array)->literals; \
+	} while (0)
+
+#else
+
+/* run-time constant */
+# define RT_CONSTANT_EX(base, node) \
+	((zval*)(((char*)(base)) + (node).constant))
+
+/* convert constant from compile-time to run-time */
+# define ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, node) do { \
+		(node).constant *= sizeof(zval); \
+	} while (0)
+
+/* convert constant back from run-time to compile-time (do nothing) */
+# define ZEND_PASS_TWO_UNDO_CONSTANT(op_array, node) do { \
+		(node).constant /= sizeof(zval); \
+	} while (0)
+
+#endif
+
+#if ZEND_EX_USE_LITERALS
+
+# define EX_LITERALS() \
+	EX(literals)
+
+# define EX_LOAD_LITERALS(op_array) do { \
+		EX(literals) = (op_array)->literals; \
+	} while (0)
+
+#else
+
+# define EX_LITERALS() \
+	EX(func)->op_array.literals
+
+# define EX_LOAD_LITERALS(op_array) do { \
+	} while (0)
+
+#endif
+
+/* run-time constant */
+#define RT_CONSTANT(op_array, node) \
+	RT_CONSTANT_EX((op_array)->literals, node)
+
+/* constant in currently executed function */
+#define EX_CONSTANT(node) \
+	RT_CONSTANT_EX(EX_LITERALS(), node)
+
+#if ZEND_EX_USE_RUN_TIME_CACHE
+
+# define EX_RUN_TIME_CACHE() \
+	EX(run_time_cache)
+
+# define EX_LOAD_RUN_TIME_CACHE(op_array) do { \
+		EX(run_time_cache) = (op_array)->run_time_cache; \
+	} while (0)
+
+#else
+
+# define EX_RUN_TIME_CACHE() \
+	EX(func)->op_array.run_time_cache
+
+# define EX_LOAD_RUN_TIME_CACHE(op_array) do { \
+	} while (0)
+
+#endif
+
 #define IS_CONST	(1<<0)
 #define IS_TMP_VAR	(1<<1)
 #define IS_VAR		(1<<2)