Merge remote-tracking branch 'origin/native-tls'POST_NATIVE_TLS_MERGE

1 files changed, 83 insertions, 83 deletions

diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
index d27f5bf6f6..b9baa5bd9a 100644
--- a/Zend/zend_operators.h
+++ b/Zend/zend_operators.h
@@ -44,31 +44,31 @@
 #define LONG_SIGN_MASK (((zend_long)1) << (8*sizeof(zend_long)-1))
 
 BEGIN_EXTERN_C()
-ZEND_API int add_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int sub_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int mul_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int pow_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int boolean_not_function(zval *result, zval *op1 TSRMLS_DC);
-ZEND_API int bitwise_not_function(zval *result, zval *op1 TSRMLS_DC);
-ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int shift_left_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-
-ZEND_API int is_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int is_not_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int is_not_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-
-ZEND_API zend_bool instanceof_function_ex(const zend_class_entry *instance_ce, const zend_class_entry *ce, zend_bool interfaces_only TSRMLS_DC);
-ZEND_API zend_bool instanceof_function(const zend_class_entry *instance_ce, const zend_class_entry *ce TSRMLS_DC);
+ZEND_API int add_function(zval *result, zval *op1, zval *op2);
+ZEND_API int sub_function(zval *result, zval *op1, zval *op2);
+ZEND_API int mul_function(zval *result, zval *op1, zval *op2);
+ZEND_API int pow_function(zval *result, zval *op1, zval *op2);
+ZEND_API int div_function(zval *result, zval *op1, zval *op2);
+ZEND_API int mod_function(zval *result, zval *op1, zval *op2);
+ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2);
+ZEND_API int boolean_not_function(zval *result, zval *op1);
+ZEND_API int bitwise_not_function(zval *result, zval *op1);
+ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2);
+ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2);
+ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2);
+ZEND_API int shift_left_function(zval *result, zval *op1, zval *op2);
+ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2);
+ZEND_API int concat_function(zval *result, zval *op1, zval *op2);
+
+ZEND_API int is_equal_function(zval *result, zval *op1, zval *op2);
+ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2);
+ZEND_API int is_not_identical_function(zval *result, zval *op1, zval *op2);
+ZEND_API int is_not_equal_function(zval *result, zval *op1, zval *op2);
+ZEND_API int is_smaller_function(zval *result, zval *op1, zval *op2);
+ZEND_API int is_smaller_or_equal_function(zval *result, zval *op1, zval *op2);
+
+ZEND_API zend_bool instanceof_function_ex(const zend_class_entry *instance_ce, const zend_class_entry *ce, zend_bool interfaces_only);
+ZEND_API zend_bool instanceof_function(const zend_class_entry *instance_ce, const zend_class_entry *ce);
 
 /**
  * Checks whether the string "str" with length "length" is numeric. The value
@@ -221,7 +221,7 @@ BEGIN_EXTERN_C()
 ZEND_API int increment_function(zval *op1);
 ZEND_API int decrement_function(zval *op2);
 
-ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC);
+ZEND_API void convert_scalar_to_number(zval *op);
 ZEND_API void _convert_to_cstring(zval *op ZEND_FILE_LINE_DC);
 ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC);
 ZEND_API void convert_to_long(zval *op);
@@ -235,23 +235,23 @@ ZEND_API void multi_convert_to_long_ex(int argc, ...);
 ZEND_API void multi_convert_to_double_ex(int argc, ...);
 ZEND_API void multi_convert_to_string_ex(int argc, ...);
 
-ZEND_API zend_long _zval_get_long_func(zval *op TSRMLS_DC);
-ZEND_API double _zval_get_double_func(zval *op TSRMLS_DC);
-ZEND_API zend_string *_zval_get_string_func(zval *op TSRMLS_DC);
+ZEND_API zend_long _zval_get_long_func(zval *op);
+ZEND_API double _zval_get_double_func(zval *op);
+ZEND_API zend_string *_zval_get_string_func(zval *op);
 
-static zend_always_inline zend_long _zval_get_long(zval *op TSRMLS_DC) {
-	return Z_TYPE_P(op) == IS_LONG ? Z_LVAL_P(op) : _zval_get_long_func(op TSRMLS_CC);
+static zend_always_inline zend_long _zval_get_long(zval *op) {
+	return Z_TYPE_P(op) == IS_LONG ? Z_LVAL_P(op) : _zval_get_long_func(op);
 }
-static zend_always_inline double _zval_get_double(zval *op TSRMLS_DC) {
-	return Z_TYPE_P(op) == IS_DOUBLE ? Z_DVAL_P(op) : _zval_get_double_func(op TSRMLS_CC);
+static zend_always_inline double _zval_get_double(zval *op) {
+	return Z_TYPE_P(op) == IS_DOUBLE ? Z_DVAL_P(op) : _zval_get_double_func(op);
 }
-static zend_always_inline zend_string *_zval_get_string(zval *op TSRMLS_DC) {
-	return Z_TYPE_P(op) == IS_STRING ? zend_string_copy(Z_STR_P(op)) : _zval_get_string_func(op TSRMLS_CC);
+static zend_always_inline zend_string *_zval_get_string(zval *op) {
+	return Z_TYPE_P(op) == IS_STRING ? zend_string_copy(Z_STR_P(op)) : _zval_get_string_func(op);
 }
 
-#define zval_get_long(op) _zval_get_long((op) TSRMLS_CC)
-#define zval_get_double(op) _zval_get_double((op) TSRMLS_CC)
-#define zval_get_string(op) _zval_get_string((op) TSRMLS_CC)
+#define zval_get_long(op) _zval_get_long((op))
+#define zval_get_double(op) _zval_get_double((op))
+#define zval_get_string(op) _zval_get_string((op))
 
 ZEND_API int add_char_to_string(zval *result, const zval *op1, const zval *op2);
 ZEND_API int add_string_to_string(zval *result, const zval *op1, const zval *op2);
@@ -259,13 +259,13 @@ ZEND_API int add_string_to_string(zval *result, const zval *op1, const zval *op2
 #define convert_to_string(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_string((op) ZEND_FILE_LINE_CC); }
 
 
-ZEND_API int zend_is_true(zval *op TSRMLS_DC);
-ZEND_API int zend_object_is_true(zval *op TSRMLS_DC);
+ZEND_API int zend_is_true(zval *op);
+ZEND_API int zend_object_is_true(zval *op);
 
 #define zval_is_true(op) \
-	zend_is_true(op TSRMLS_CC)
+	zend_is_true(op)
 
-static zend_always_inline int i_zend_is_true(zval *op TSRMLS_DC)
+static zend_always_inline int i_zend_is_true(zval *op)
 {
 	int result;
 
@@ -300,7 +300,7 @@ again:
 			result = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
 			break;
 		case IS_OBJECT:
-			result = zend_object_is_true(op TSRMLS_CC);
+			result = zend_object_is_true(op);
 			break;
 		case IS_REFERENCE:
 			op = Z_REFVAL_P(op);
@@ -313,13 +313,13 @@ again:
 	return result;
 }
 
-ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int string_compare_function_ex(zval *result, zval *op1, zval *op2, zend_bool case_insensitive TSRMLS_DC);
-ZEND_API int string_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
-ZEND_API int string_case_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
+ZEND_API int compare_function(zval *result, zval *op1, zval *op2);
+ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2);
+ZEND_API int string_compare_function_ex(zval *result, zval *op1, zval *op2, zend_bool case_insensitive);
+ZEND_API int string_compare_function(zval *result, zval *op1, zval *op2);
+ZEND_API int string_case_compare_function(zval *result, zval *op1, zval *op2);
 #if HAVE_STRCOLL
-ZEND_API int string_locale_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
+ZEND_API int string_locale_compare_function(zval *result, zval *op1, zval *op2);
 #endif
 
 ZEND_API void zend_str_tolower(char *str, size_t length);
@@ -338,9 +338,9 @@ ZEND_API int zend_binary_strcasecmp_l(const char *s1, size_t len1, const char *s
 ZEND_API int zend_binary_strncasecmp_l(const char *s1, size_t len1, const char *s2, size_t len2, size_t length);
 
 ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2);
-ZEND_API void zend_compare_symbol_tables(zval *result, HashTable *ht1, HashTable *ht2 TSRMLS_DC);
-ZEND_API void zend_compare_arrays(zval *result, zval *a1, zval *a2 TSRMLS_DC);
-ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2 TSRMLS_DC);
+ZEND_API void zend_compare_symbol_tables(zval *result, HashTable *ht1, HashTable *ht2);
+ZEND_API void zend_compare_arrays(zval *result, zval *a1, zval *a2);
+ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2);
 
 ZEND_API int zend_atoi(const char *str, int str_len);
 ZEND_API zend_long zend_atol(const char *str, int str_len);
@@ -400,7 +400,7 @@ ZEND_API void zend_locale_sprintf_double(zval *op ZEND_FILE_LINE_DC);
 #define convert_scalar_to_number_ex(pzv)							\
 	if (Z_TYPE_P(pzv)!=IS_LONG && Z_TYPE_P(pzv)!=IS_DOUBLE) {		\
 		SEPARATE_ZVAL_IF_NOT_REF(pzv);								\
-		convert_scalar_to_number(pzv TSRMLS_CC);					\
+		convert_scalar_to_number(pzv);					\
 	}
 
 #if HAVE_SETLOCALE && defined(ZEND_WIN32) && !defined(ZTS) && defined(_MSC_VER) && (_MSC_VER >= 1400)
@@ -558,7 +558,7 @@ static zend_always_inline int fast_decrement_function(zval *op1)
 	return decrement_function(op1);
 }
 
-static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *op2)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
@@ -666,10 +666,10 @@ static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *o
 			return SUCCESS;
 		}
 	}
-	return add_function(result, op1, op2 TSRMLS_CC);
+	return add_function(result, op1, op2);
 }
 
-static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *op2)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
@@ -779,10 +779,10 @@ static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *o
 			return SUCCESS;
 		}
 	}
-	return sub_function(result, op1, op2 TSRMLS_CC);
+	return sub_function(result, op1, op2);
 }
 
-static zend_always_inline int fast_mul_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline int fast_mul_function(zval *result, zval *op1, zval *op2)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
@@ -804,10 +804,10 @@ static zend_always_inline int fast_mul_function(zval *result, zval *op1, zval *o
 			return SUCCESS;
 		}
 	}
-	return mul_function(result, op1, op2 TSRMLS_CC);
+	return mul_function(result, op1, op2);
 }
 
-static zend_always_inline int fast_div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline int fast_div_function(zval *result, zval *op1, zval *op2)
 {
 #if 0
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG) && 0) {
@@ -855,10 +855,10 @@ static zend_always_inline int fast_div_function(zval *result, zval *op1, zval *o
 		}
 	}
 #endif
-	return div_function(result, op1, op2 TSRMLS_CC);
+	return div_function(result, op1, op2);
 }
 
-static zend_always_inline int fast_mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline int fast_mod_function(zval *result, zval *op1, zval *op2)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
@@ -875,10 +875,10 @@ static zend_always_inline int fast_mod_function(zval *result, zval *op1, zval *o
 			return SUCCESS;
 		}
 	}
-	return mod_function(result, op1, op2 TSRMLS_CC);
+	return mod_function(result, op1, op2);
 }
 
-static zend_always_inline int fast_equal_check_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline int fast_equal_check_function(zval *result, zval *op1, zval *op2)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
@@ -908,11 +908,11 @@ static zend_always_inline int fast_equal_check_function(zval *result, zval *op1,
 			}
 		}
 	}
-	compare_function(result, op1, op2 TSRMLS_CC);
+	compare_function(result, op1, op2);
 	return Z_LVAL_P(result) == 0;
 }
 
-static zend_always_inline void fast_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_equal_function(zval *result, zval *op1, zval *op2)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
@@ -950,11 +950,11 @@ static zend_always_inline void fast_equal_function(zval *result, zval *op1, zval
 			}
 		}
 	}
-	compare_function(result, op1, op2 TSRMLS_CC);
+	compare_function(result, op1, op2);
 	ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
 }
 
-static zend_always_inline void fast_not_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_not_equal_function(zval *result, zval *op1, zval *op2)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
@@ -992,11 +992,11 @@ static zend_always_inline void fast_not_equal_function(zval *result, zval *op1,
 			}
 		}
 	}
-	compare_function(result, op1, op2 TSRMLS_CC);
+	compare_function(result, op1, op2);
 	ZVAL_BOOL(result, Z_LVAL_P(result) != 0);
 }
 
-static zend_always_inline void fast_is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_is_smaller_function(zval *result, zval *op1, zval *op2)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
@@ -1015,11 +1015,11 @@ static zend_always_inline void fast_is_smaller_function(zval *result, zval *op1,
 			return;
 		}
 	}
-	compare_function(result, op1, op2 TSRMLS_CC);
+	compare_function(result, op1, op2);
 	ZVAL_BOOL(result, Z_LVAL_P(result) < 0);
 }
 
-static zend_always_inline void fast_is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_is_smaller_or_equal_function(zval *result, zval *op1, zval *op2)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
@@ -1038,26 +1038,26 @@ static zend_always_inline void fast_is_smaller_or_equal_function(zval *result, z
 			return;
 		}
 	}
-	compare_function(result, op1, op2 TSRMLS_CC);
+	compare_function(result, op1, op2);
 	ZVAL_BOOL(result, Z_LVAL_P(result) <= 0);
 }
 
-static zend_always_inline void fast_is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_is_identical_function(zval *result, zval *op1, zval *op2)
 {
 	if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
 		ZVAL_BOOL(result, 0);
 		return;
 	}
-	is_identical_function(result, op1, op2 TSRMLS_CC);
+	is_identical_function(result, op1, op2);
 }
 
-static zend_always_inline void fast_is_not_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_is_not_identical_function(zval *result, zval *op1, zval *op2)
 {
 	if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
 		ZVAL_BOOL(result, 1);
 		return;
 	}
-	is_identical_function(result, op1, op2 TSRMLS_CC);
+	is_identical_function(result, op1, op2);
 	ZVAL_BOOL(result, Z_TYPE_P(result) != IS_TRUE);
 }
 
@@ -1068,15 +1068,15 @@ static zend_always_inline void fast_is_not_identical_function(zval *result, zval
 		&& EXPECTED(Z_OBJ_HANDLER_P(op1, set))) {                                                          \
 		int ret;                                                                                           \
 		zval rv;                                                                                           \
-		zval *objval = Z_OBJ_HANDLER_P(op1, get)(op1, &rv TSRMLS_CC);                                      \
+		zval *objval = Z_OBJ_HANDLER_P(op1, get)(op1, &rv);                                      \
 		Z_ADDREF_P(objval);                                                                                \
-		ret = binary_op(objval, objval, op2 TSRMLS_CC);                                                    \
-		Z_OBJ_HANDLER_P(op1, set)(op1, objval TSRMLS_CC);                                                  \
+		ret = binary_op(objval, objval, op2);                                                    \
+		Z_OBJ_HANDLER_P(op1, set)(op1, objval);                                                  \
 		zval_ptr_dtor(objval);                                                                             \
 		return ret;                                                                                        \
 	} else if (UNEXPECTED(Z_TYPE_P(op1) == IS_OBJECT)                                                      \
 		&& UNEXPECTED(Z_OBJ_HANDLER_P(op1, do_operation))) {                                               \
-		if (EXPECTED(SUCCESS == Z_OBJ_HANDLER_P(op1, do_operation)(opcode, result, op1, op2 TSRMLS_CC))) { \
+		if (EXPECTED(SUCCESS == Z_OBJ_HANDLER_P(op1, do_operation)(opcode, result, op1, op2))) { \
 			return SUCCESS;                                                                                \
 		}                                                                                                  \
 	}
@@ -1084,7 +1084,7 @@ static zend_always_inline void fast_is_not_identical_function(zval *result, zval
 #define ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(opcode)                                                       \
 	if (UNEXPECTED(Z_TYPE_P(op2) == IS_OBJECT)                                                             \
 		&& UNEXPECTED(Z_OBJ_HANDLER_P(op2, do_operation))                                                  \
-		&& EXPECTED(SUCCESS == Z_OBJ_HANDLER_P(op2, do_operation)(opcode, result, op1, op2 TSRMLS_CC))) {  \
+		&& EXPECTED(SUCCESS == Z_OBJ_HANDLER_P(op2, do_operation)(opcode, result, op1, op2))) {  \
 		return SUCCESS;                                                                                    \
 	}
 
@@ -1096,7 +1096,7 @@ static zend_always_inline void fast_is_not_identical_function(zval *result, zval
 #define ZEND_TRY_UNARY_OBJECT_OPERATION(opcode)                                                            \
 	if (UNEXPECTED(Z_TYPE_P(op1) == IS_OBJECT)                                                             \
 		&& UNEXPECTED(Z_OBJ_HANDLER_P(op1, do_operation))                                                  \
-		&& EXPECTED(SUCCESS == Z_OBJ_HANDLER_P(op1, do_operation)(opcode, result, op1, NULL TSRMLS_CC))) { \
+		&& EXPECTED(SUCCESS == Z_OBJ_HANDLER_P(op1, do_operation)(opcode, result, op1, NULL))) { \
 		return SUCCESS;                                                                                    \
 	}