]> granicus.if.org Git - php/commitdiff
Refactor as to not use call info, but add the flag to the op_array.
authorAnthony Ferrara <ircmaxell@gmail.com>
Thu, 19 Mar 2015 17:30:11 +0000 (13:30 -0400)
committerAnthony Ferrara <ircmaxell@gmail.com>
Thu, 19 Mar 2015 17:30:11 +0000 (13:30 -0400)
Zend/zend.c
Zend/zend_API.c
Zend/zend_API.h
Zend/zend_compile.c
Zend/zend_compile.h
Zend/zend_vm_def.h
Zend/zend_vm_execute.h

index f54442a7edf62adcab283dbcb78647a969fce82b..6bb614fab50cce04227c3d54ac5ef824c096de4d 100644 (file)
@@ -1297,7 +1297,7 @@ ZEND_API void zend_internal_type_error(zend_bool strict, const char *format, ...
        va_start(va, format);
        zend_vspprintf(&message, 0, format, va);
        if (strict) {
-               zend_throw_exception(zend_get_type_exception(), message, 0);
+               zend_throw_exception(zend_get_type_exception(), message, E_ERROR);
        } else {
                zend_error(E_WARNING, message);
        }
index f86bb66c5384fb782f75ca3c55cb9d63b2e90b06..dac6f16754c29545dedd60ddea5123e664be4267 100644 (file)
@@ -151,7 +151,7 @@ ZEND_API int zend_copy_parameters_array(int param_count, zval *argument_array) /
 
 ZEND_API void zend_wrong_param_count(void) /* {{{ */
 {
-       if (ZEND_CALL_INFO(EG(current_execute_data)) & ZEND_CALL_STRICT_TYPEHINTS) {
+       if (EX_PREV_USES_STRICT_TYPES()) {
                zend_wrong_param_count_ex(1);
        } else {
                zend_wrong_param_count_ex(0);
@@ -802,7 +802,7 @@ ZEND_API int zend_parse_parameters_ex(int flags, int num_args, const char *type_
        va_list va;
        int retval;
 
-       if (ZEND_CALL_INFO(EG(current_execute_data)) & ZEND_CALL_STRICT_TYPEHINTS) {
+       if (EX_PREV_USES_STRICT_TYPES()) {
                flags |= ZEND_PARSE_PARAMS_STRICT;
        }
 
@@ -822,7 +822,7 @@ ZEND_API int zend_parse_parameters(int num_args, const char *type_spec, ...) /*
        int retval;
        int flags = 0;
 
-       if (ZEND_CALL_INFO(EG(current_execute_data)) & ZEND_CALL_STRICT_TYPEHINTS) {
+       if (EX_PREV_USES_STRICT_TYPES()) {
                flags |= ZEND_PARSE_PARAMS_STRICT;
        }
 
@@ -851,7 +851,7 @@ ZEND_API int zend_parse_method_parameters(int num_args, zval *this_ptr, const ch
         * wrong branch here. */
        zend_bool is_method = EG(current_execute_data)->func->common.scope != NULL;
 
-       if (ZEND_CALL_INFO(EG(current_execute_data)) & ZEND_CALL_STRICT_TYPEHINTS) {
+       if (EX_PREV_USES_STRICT_TYPES()) {
                flags |= ZEND_PARSE_PARAMS_STRICT;
        }
 
@@ -891,7 +891,7 @@ ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args, zval *this
        zval **object;
        zend_class_entry *ce;
 
-       if (ZEND_CALL_INFO(EG(current_execute_data)) & ZEND_CALL_STRICT_TYPEHINTS) {
+       if (EX_PREV_USES_STRICT_TYPES()) {
                flags |= ZEND_PARSE_PARAMS_STRICT;
        }
 
index 810e9b850f93af13f4311f2e5b30473eee596cdd..e0f39e98a21423a820762fa3df1b18ded32cbef0 100644 (file)
@@ -720,7 +720,7 @@ ZEND_API void zend_wrong_callback_error(int severity, int num, char *error, zend
 #define ZPP_ERROR_WRONG_COUNT    5
 
 #define ZEND_PARSE_PARAMETERS_START_EX(flags, min_num_args, max_num_args) do { \
-               zend_bool _strict = (EX_CALL_INFO() & ZEND_CALL_STRICT_TYPEHINTS) ? 1 : 0; \
+               zend_bool _strict = EX_PREV_USES_STRICT_TYPES(); \
                const int _flags = (flags) | (_strict ? ZEND_PARSE_PARAMS_STRICT : 0); \
                int _min_num_args = (min_num_args); \
                int _max_num_args = (max_num_args); \
index 5744ae3ad0fbb214ae471b426b123450b05a61ef..954412bf19fff310bc03492fb0408a64876aa41c 100644 (file)
@@ -188,7 +188,6 @@ static zend_always_inline zend_uchar zend_lookup_scalar_typehint_by_name(const z
 static void init_compiler_declarables(void) /* {{{ */
 {
        ZVAL_LONG(&CG(declarables).ticks, 0);
-       CG(declarables).strict_types = 0;
 }
 /* }}} */
 
@@ -1624,8 +1623,6 @@ void zend_do_end_compilation(void) /* {{{ */
 {
        CG(has_bracketed_namespaces) = 0;
        zend_end_namespace();
-       /* strict typehinting is per-file */
-       CG(declarables).strict_types = 0;
 }
 /* }}} */
 
@@ -1926,8 +1923,7 @@ static void zend_emit_return_type_check(znode *expr, zend_arg_info *return_info)
 
        if (return_info->type_hint != IS_UNDEF) {
                zend_op *opline = zend_emit_op(NULL, ZEND_VERIFY_RETURN_TYPE, expr, NULL);
-               opline->extended_value = (CG(declarables).strict_types ? ZEND_RETURN_TYPE_STRICT : 0)
-                        & (returns_reference ? ZEND_RETURN_TYPE_BYREF : 0);
+               opline->extended_value = (returns_reference ? ZEND_RETURN_REF : 0);
        }
 }
 /* }}} */
@@ -2716,8 +2712,7 @@ void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function *
                opline->op1.num = zend_vm_calc_used_stack(arg_count, fbc);
        }
 
-       call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0)
-               | (CG(declarables).strict_types ? ZEND_CALL_STRICT_TYPEHINTS : 0);
+       call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0);
        opline = zend_emit_op(result, zend_get_call_op(opline->opcode, fbc), NULL, NULL);
        opline->op1.num = call_flags;
 
@@ -3405,7 +3400,7 @@ void zend_compile_return(zend_ast *ast) /* {{{ */
                /* for scalar, weak return types, the value may be casted
                 * thus, for constants, we need to store them in a tmp var
                 */
-               if (expr_node.op_type == IS_CONST && !CG(declarables).strict_types) {
+               if (expr_node.op_type == IS_CONST && !(CG(active_op_array)->fn_flags & ZEND_ACC_STRICT_TYPES)) {
                        znode expr_node_copy = expr_node;
 
                        zend_emit_op_tmp(&expr_node, ZEND_QM_ASSIGN, &expr_node_copy, NULL);
@@ -4050,7 +4045,10 @@ void zend_compile_declare(zend_ast *ast) /* {{{ */
                                zend_error_noreturn(E_COMPILE_ERROR, "strict_types declaration must have 0 or 1 as its value");
                        }
 
-                       CG(declarables).strict_types = Z_LVAL(value_zv);
+                       if (Z_LVAL(value_zv) == 1) {
+                               CG(active_op_array)->fn_flags |= ZEND_ACC_STRICT_TYPES;
+                       }
+                       
                } else {
                        zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", name->val);
                }
@@ -4525,6 +4523,7 @@ void zend_compile_func_decl(znode *result, zend_ast *ast) /* {{{ */
 
        init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE);
 
+       op_array->fn_flags |= (orig_op_array->fn_flags & ZEND_ACC_STRICT_TYPES);
        op_array->fn_flags |= decl->flags;
        op_array->line_start = decl->start_lineno;
        op_array->line_end = decl->end_lineno;
index 2de832854c14fcb68ec6c3ad6b7878dee8c7ecb7..cedd5d680895cd89489b1fb04ceb2a1bcaa030b1 100644 (file)
@@ -252,6 +252,9 @@ typedef struct _zend_try_catch_element {
 /* Function has a return type hint (or class has such non-private function) */
 #define ZEND_ACC_HAS_RETURN_TYPE               0x40000000
 
+/* op_array uses strict mode types */
+#define ZEND_ACC_STRICT_TYPES                  0x80000000
+
 char *zend_visibility_string(uint32_t fn_flags);
 
 typedef struct _zend_property_info {
@@ -423,10 +426,6 @@ struct _zend_execute_data {
 #define ZEND_CALL_FREE_EXTRA_ARGS    (1 << 2) /* equal to IS_TYPE_REFCOUNTED */
 #define ZEND_CALL_CTOR               (1 << 3)
 #define ZEND_CALL_CTOR_RESULT_UNUSED (1 << 4)
-#define ZEND_CALL_STRICT_TYPEHINTS   (1 << 5)
-
-#define ZEND_RETURN_TYPE_STRICT        (1 << 0)
-#define ZEND_RETURN_TYPE_BYREF (1 << 1)
 
 #define ZEND_CALL_INFO(call) \
        (Z_TYPE_INFO((call)->This) >> 24)
@@ -462,7 +461,10 @@ struct _zend_execute_data {
 #define EX_CALL_INFO()                 ZEND_CALL_INFO(execute_data)
 #define EX_CALL_KIND()                 ZEND_CALL_KIND(execute_data)
 #define EX_NUM_ARGS()                  ZEND_CALL_NUM_ARGS(execute_data)
-#define EX_USES_STRICT_TYPES() ((EX_CALL_INFO() & ZEND_CALL_STRICT_TYPEHINTS) ? 1 : 0)
+
+#define EX_USES_STRICT_TYPES()         _EX_USES_STRICT_TYPES(EG(current_execute_data))
+#define EX_PREV_USES_STRICT_TYPES()    _EX_USES_STRICT_TYPES(EG(current_execute_data)->prev_execute_data)
+#define _EX_USES_STRICT_TYPES(ex_data) ((ex_data) && (ex_data)->func && ZEND_USER_CODE((ex_data)->func->type) && ((ex_data)->func->op_array.fn_flags & ZEND_ACC_STRICT_TYPES) ? 1 : 0)
 
 #define EX_VAR(n)                              ZEND_CALL_VAR(execute_data, n)
 #define EX_VAR_NUM(n)                  ZEND_CALL_VAR_NUM(execute_data, n)
index eb9f68e350cf1136b5593556b31b5f7cea20b83d..5b2cb561b223ab89f97a8a109dcd173fba11f22c 100644 (file)
@@ -3133,7 +3133,7 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV)
                        }
                }
        } else {
-               zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error);
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error);
                efree(error);
                func = (zend_function*)&zend_pass_function;
                called_scope = NULL;
@@ -3214,8 +3214,6 @@ ZEND_VM_HANDLER(129, ZEND_DO_ICALL, ANY, ANY)
        zend_function *fbc = call->func;
        zval *ret;
 
-       ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS);
-
        SAVE_OPLINE();
        EX(call) = call->prev_execute_data;
 
@@ -3263,8 +3261,6 @@ ZEND_VM_HANDLER(130, ZEND_DO_UCALL, ANY, ANY)
        zend_function *fbc = call->func;
        zval *ret;
 
-       ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS);
-
        SAVE_OPLINE();
        EX(call) = call->prev_execute_data;
 
@@ -3290,8 +3286,6 @@ ZEND_VM_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY)
        zend_function *fbc = call->func;
        zval *ret;
 
-       ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS);
-
        SAVE_OPLINE();
        EX(call) = call->prev_execute_data;
 
@@ -3396,8 +3390,6 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY)
        zend_object *object = Z_OBJ(call->This);
        zval *ret;
 
-       ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS);
-
        SAVE_OPLINE();
        EX(call) = call->prev_execute_data;
        if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) {
@@ -3608,7 +3600,7 @@ ZEND_VM_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV, UNUSED)
 
                retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
                
-               if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) {
+               if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) {
                        /* Does not return by reference */
                        SEPARATE_ZVAL(retval_ptr);
                } else {
@@ -3616,7 +3608,7 @@ ZEND_VM_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV, UNUSED)
                        SEPARATE_ZVAL_NOREF(retval_ptr);
                }
 
-               zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT);
+               zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES());
 #endif
        }
        CHECK_EXCEPTION();
@@ -4189,7 +4181,7 @@ ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, ANY, ANY)
                                ZEND_VM_C_GOTO(send_array);
                        }
                }
-               zend_error(E_WARNING, "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
                if (EX(call)->func->common.fn_flags & ZEND_ACC_CLOSURE) {
                        OBJ_RELEASE((zend_object*)EX(call)->func->common.prototype);
                }
@@ -4388,7 +4380,7 @@ ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY)
        } else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
                zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
 
-               zend_verify_arg_type(EX(func), arg_num, param, NULL, EX_USES_STRICT_TYPES());
+               zend_verify_arg_type(EX(func), arg_num, param, NULL, EX_PREV_USES_STRICT_TYPES());
                CHECK_EXCEPTION();
        }
 
@@ -4416,7 +4408,7 @@ ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST)
        }
 
        if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
-               zend_verify_arg_type(EX(func), arg_num, param, EX_CONSTANT(opline->op2), EX_USES_STRICT_TYPES());
+               zend_verify_arg_type(EX(func), arg_num, param, EX_CONSTANT(opline->op2), EX_PREV_USES_STRICT_TYPES());
        }
 
        CHECK_EXCEPTION();
@@ -7269,7 +7261,7 @@ ZEND_VM_HANDLER(121, ZEND_STRLEN, CONST|TMPVAR|CV, ANY)
 ZEND_VM_C_LABEL(try_strlen):
        if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
-       } else if (EXPECTED(0 == EX_USES_STRICT_TYPES())) {
+       } else if (EXPECTED(!EX_USES_STRICT_TYPES())) {
                if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
                        value = Z_REFVAL_P(value);
                        ZEND_VM_C_GOTO(try_strlen);
@@ -7293,11 +7285,11 @@ ZEND_VM_C_LABEL(try_strlen):
                        zval_dtor(&tmp);
                } else {
 ZEND_VM_C_LABEL(strlen_error):
-                       zend_error(E_WARNING, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+                       zend_internal_type_error(0, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               zend_type_error("strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+               zend_internal_type_error(1, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
        }
        FREE_OP1();
        CHECK_EXCEPTION();
index 8eb8bf8826c48f18b07f399a2197d7891743c6ad..89d42dd9db262d9e151e31b4dd090f0e3e71b676 100644 (file)
@@ -545,8 +545,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_HANDLER(ZEND_OPC
        zend_function *fbc = call->func;
        zval *ret;
 
-       ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS);
-
        SAVE_OPLINE();
        EX(call) = call->prev_execute_data;
 
@@ -594,8 +592,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_HANDLER(ZEND_OPC
        zend_function *fbc = call->func;
        zval *ret;
 
-       ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS);
-
        SAVE_OPLINE();
        EX(call) = call->prev_execute_data;
 
@@ -621,8 +617,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER(
        zend_function *fbc = call->func;
        zval *ret;
 
-       ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS);
-
        SAVE_OPLINE();
        EX(call) = call->prev_execute_data;
 
@@ -727,8 +721,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_HANDLER(ZEND_OPC
        zend_object *object = Z_OBJ(call->This);
        zval *ret;
 
-       ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS);
-
        SAVE_OPLINE();
        EX(call) = call->prev_execute_data;
        if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) {
@@ -1106,7 +1098,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O
                                goto send_array;
                        }
                }
-               zend_error(E_WARNING, "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
                if (EX(call)->func->common.fn_flags & ZEND_ACC_CLOSURE) {
                        OBJ_RELEASE((zend_object*)EX(call)->func->common.prototype);
                }
@@ -1226,7 +1218,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_
        } else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
                zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var);
 
-               zend_verify_arg_type(EX(func), arg_num, param, NULL, EX_USES_STRICT_TYPES());
+               zend_verify_arg_type(EX(func), arg_num, param, NULL, EX_PREV_USES_STRICT_TYPES());
                CHECK_EXCEPTION();
        }
 
@@ -2084,7 +2076,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(Z
        }
 
        if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
-               zend_verify_arg_type(EX(func), arg_num, param, EX_CONSTANT(opline->op2), EX_USES_STRICT_TYPES());
+               zend_verify_arg_type(EX(func), arg_num, param, EX_CONSTANT(opline->op2), EX_PREV_USES_STRICT_TYPES());
        }
 
        CHECK_EXCEPTION();
@@ -3815,7 +3807,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND
 try_strlen:
        if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
-       } else if (EXPECTED(0 == EX_USES_STRICT_TYPES())) {
+       } else if (EXPECTED(!EX_USES_STRICT_TYPES())) {
                if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
                        value = Z_REFVAL_P(value);
                        goto try_strlen;
@@ -3839,11 +3831,11 @@ try_strlen:
                        zval_dtor(&tmp);
                } else {
 strlen_error:
-                       zend_error(E_WARNING, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+                       zend_internal_type_error(0, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               zend_type_error("strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+               zend_internal_type_error(1, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
        }
 
        CHECK_EXCEPTION();
@@ -5107,7 +5099,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS
                        }
                }
        } else {
-               zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error);
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error);
                efree(error);
                func = (zend_function*)&zend_pass_function;
                called_scope = NULL;
@@ -6979,7 +6971,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_
 
                retval_ptr = EX_CONSTANT(opline->op1);
 
-               if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) {
+               if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) {
                        /* Does not return by reference */
                        SEPARATE_ZVAL(retval_ptr);
                } else {
@@ -6987,7 +6979,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_
                        SEPARATE_ZVAL_NOREF(retval_ptr);
                }
 
-               zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT);
+               zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES());
 #endif
        }
        CHECK_EXCEPTION();
@@ -8437,7 +8429,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H
                        }
                }
        } else {
-               zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error);
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error);
                efree(error);
                func = (zend_function*)&zend_pass_function;
                called_scope = NULL;
@@ -9950,7 +9942,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV
                        }
                }
        } else {
-               zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error);
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error);
                efree(error);
                func = (zend_function*)&zend_pass_function;
                called_scope = NULL;
@@ -11933,7 +11925,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UN
 
                retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1);
 
-               if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) {
+               if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) {
                        /* Does not return by reference */
                        SEPARATE_ZVAL(retval_ptr);
                } else {
@@ -11941,7 +11933,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UN
                        SEPARATE_ZVAL_NOREF(retval_ptr);
                }
 
-               zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT);
+               zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES());
 #endif
        }
        CHECK_EXCEPTION();
@@ -17287,7 +17279,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UN
 
                retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
 
-               if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) {
+               if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) {
                        /* Does not return by reference */
                        SEPARATE_ZVAL(retval_ptr);
                } else {
@@ -17295,7 +17287,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UN
                        SEPARATE_ZVAL_NOREF(retval_ptr);
                }
 
-               zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT);
+               zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES());
 #endif
        }
        CHECK_EXCEPTION();
@@ -22898,7 +22890,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED
 
                retval_ptr = NULL;
 
-               if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) {
+               if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) {
                        /* Does not return by reference */
                        SEPARATE_ZVAL(retval_ptr);
                } else {
@@ -22906,7 +22898,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED
                        SEPARATE_ZVAL_NOREF(retval_ptr);
                }
 
-               zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT);
+               zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES());
 #endif
        }
        CHECK_EXCEPTION();
@@ -27302,7 +27294,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OP
 try_strlen:
        if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
-       } else if (EXPECTED(0 == EX_USES_STRICT_TYPES())) {
+       } else if (EXPECTED(!EX_USES_STRICT_TYPES())) {
                if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
                        value = Z_REFVAL_P(value);
                        goto try_strlen;
@@ -27326,11 +27318,11 @@ try_strlen:
                        zval_dtor(&tmp);
                } else {
 strlen_error:
-                       zend_error(E_WARNING, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+                       zend_internal_type_error(0, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               zend_type_error("strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+               zend_internal_type_error(1, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
        }
 
        CHECK_EXCEPTION();
@@ -31838,7 +31830,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNU
 
                retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
 
-               if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) {
+               if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) {
                        /* Does not return by reference */
                        SEPARATE_ZVAL(retval_ptr);
                } else {
@@ -31846,7 +31838,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNU
                        SEPARATE_ZVAL_NOREF(retval_ptr);
                }
 
-               zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT);
+               zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES());
 #endif
        }
        CHECK_EXCEPTION();
@@ -37563,7 +37555,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEN
 try_strlen:
        if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
                ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
-       } else if (EXPECTED(0 == EX_USES_STRICT_TYPES())) {
+       } else if (EXPECTED(!EX_USES_STRICT_TYPES())) {
                if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
                        value = Z_REFVAL_P(value);
                        goto try_strlen;
@@ -37587,11 +37579,11 @@ try_strlen:
                        zval_dtor(&tmp);
                } else {
 strlen_error:
-                       zend_error(E_WARNING, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+                       zend_internal_type_error(0, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               zend_type_error("strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+               zend_internal_type_error(1, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
        }
        zval_ptr_dtor_nogc(free_op1);
        CHECK_EXCEPTION();