Add outline versions of zend_string free/release APIs

Author: morrisonlevi

Zend/Optimizer/dfa_pass.c

@@ -265,7 +265,7 @@ static bool safe_instanceof(zend_class_entry *ce1, zend_class_entry *ce2) {
 	return instanceof_function(ce1, ce2);
 }
 
-static inline bool can_elide_list_type(
+static bool can_elide_list_type(
 	const zend_script *script, const zend_op_array *op_array,
 	const zend_ssa_var_info *use_info, zend_type type)
 {

Zend/Optimizer/zend_optimizer.c

@@ -247,7 +247,7 @@ static inline int zend_optimizer_add_literal_string(zend_op_array *op_array, zen
 	return zend_optimizer_add_literal(op_array, &zv);
 }
 
-static inline void drop_leading_backslash(zval *val) {
+static void drop_leading_backslash(zval *val) {
 	if (Z_STRVAL_P(val)[0] == '\\') {
 		zend_string *str = zend_string_init(Z_STRVAL_P(val) + 1, Z_STRLEN_P(val) - 1, 0);
 		zval_ptr_dtor_nogc(val);

Zend/zend.c

@@ -1573,7 +1573,7 @@ static ZEND_COLD void zend_error_va_list(
 {
 	zend_string *message = zend_vstrpprintf(0, format, args);
 	zend_error_zstr_at(orig_type, error_filename, error_lineno, message);
-	zend_string_release(message);
+	zend_string_release_outline(message);
 }
 
 static ZEND_COLD void get_filename_lineno(int type, zend_string **filename, uint32_t *lineno) {
@@ -2047,3 +2047,10 @@ ZEND_API void zend_alloc_ce_cache(zend_string *type_name)
 	GC_ADD_FLAGS(type_name, IS_STR_CLASS_NAME_MAP_PTR);
 	GC_SET_REFCOUNT(type_name, ret);
 }
+
+
+ZEND_API extern inline uint32_t zend_gc_refcount(const zend_refcounted_h *p);
+ZEND_API extern inline uint32_t zend_gc_delref(zend_refcounted_h *p);
+ZEND_API extern zend_always_inline uint8_t zval_gc_type(uint32_t gc_type_info);
+ZEND_API extern zend_always_inline uint32_t zval_gc_flags(uint32_t gc_type_info);
+ZEND_API extern zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info);

Zend/zend_API.c

@@ -104,7 +104,7 @@ ZEND_API ZEND_COLD void zend_wrong_property_read(zval *object, zval *property)
 	zend_string *tmp_property_name;
 	zend_string *property_name = zval_get_tmp_string(property, &tmp_property_name);
 	zend_error(E_WARNING, "Attempt to read property \"%s\" on %s", ZSTR_VAL(property_name), zend_zval_value_name(object));
-	zend_tmp_string_release(tmp_property_name);
+	zend_tmp_string_release_outline(tmp_property_name);
 }
 
 /* Argument parsing API -- andrei */
@@ -217,7 +217,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameters_none_error(void) /*
 
 	zend_argument_count_error("%s() expects exactly 0 arguments, %d given", ZSTR_VAL(func_name), num_args);
 
-	zend_string_release(func_name);
+	zend_string_release_outline(func_name);
 }
 /* }}} */
 
@@ -235,7 +235,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameters_count_error(uint32_t
 		num_args
 	);
 
-	zend_string_release(func_name);
+	zend_string_release_outline(func_name);
 }
 /* }}} */
 
@@ -405,7 +405,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_error_variadic(zend_class_en
 		arg_name ? " ($" : "", arg_name ? arg_name : "", arg_name ? ")" : "", message
 	);
 	efree(message);
-	zend_string_release(func_name);
+	zend_string_release_outline(func_name);
 }
 /* }}} */
 
@@ -510,9 +510,9 @@ static ZEND_COLD bool zend_null_arg_deprecated(const char *fallback_type, uint32
 		ZSTR_VAL(func_name), arg_num,
 		arg_name ? " ($" : "", arg_name ? arg_name : "", arg_name ? ")" : "",
 		type);
-	zend_string_release(func_name);
+	zend_string_release_outline(func_name);
 	if (type_str) {
-		zend_string_release(type_str);
+		zend_string_release_outline(type_str);
 	}
 	return !EG(exception);
 }
@@ -1225,7 +1225,7 @@ static zend_result zend_parse_va_args(uint32_t num_args, const char *type_spec,
 				num_args
 			);
 
-			zend_string_release(func_name);
+			zend_string_release_outline(func_name);
 		}
 		return FAILURE;
 	}
@@ -1873,7 +1873,7 @@ ZEND_API zend_result object_init_with_constructor(zval *arg, zend_class_entry *c
 			zend_hash_get_current_key(named_params, &arg_name, /* num_index */ NULL);
 			ZEND_ASSERT(arg_name != NULL);
 			zend_throw_error(NULL, "Unknown named parameter $%s", ZSTR_VAL(arg_name));
-			zend_string_release(arg_name);
+			zend_string_release_outline(arg_name);
 			/* Do not call destructor, free object, and set arg to IS_UNDEF */
 			zend_object_store_ctor_failed(obj);
 			zval_ptr_dtor(arg);
@@ -2619,7 +2619,7 @@ ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module, i
 	lcname = zend_new_interned_string(lcname);
 	if ((module_ptr = zend_hash_add_ptr(&module_registry, lcname, module)) == NULL) {
 		zend_error(E_CORE_WARNING, "Module \"%s\" is already loaded", module->name);
-		zend_string_release(lcname);
+		zend_string_release_outline(lcname);
 		return NULL;
 	}
 	module = module_ptr;
@@ -2630,7 +2630,7 @@ ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module, i
 
 	if (module->functions && zend_register_functions(NULL, module->functions, NULL, module_type)==FAILURE) {
 		zend_hash_del(&module_registry, lcname);
-		zend_string_release(lcname);
+		zend_string_release_outline(lcname);
 		EG(current_module) = NULL;
 		zend_error(E_CORE_WARNING,"%s: Unable to register functions, unable to load", module->name);
 		return NULL;

Zend/zend_API.h

@@ -900,7 +900,7 @@ static zend_always_inline zend_result zend_forbid_dynamic_call(void)
 		zend_string *function_or_method_name = get_active_function_or_method_name();
 		zend_throw_error(NULL, "Cannot call %.*s() dynamically",
 			(int) ZSTR_LEN(function_or_method_name), ZSTR_VAL(function_or_method_name));
-		zend_string_release(function_or_method_name);
+		zend_string_release_outline(function_or_method_name);
 		return FAILURE;
 	}
 

Zend/zend_ast.c

@@ -28,7 +28,7 @@
 
 ZEND_API zend_ast_process_t zend_ast_process = NULL;
 
-static inline void *zend_ast_alloc(size_t size) {
+static void *zend_ast_alloc(size_t size) {
 	return zend_arena_alloc(&CG(ast_arena), size);
 }
 
@@ -1193,10 +1193,10 @@ ZEND_API void ZEND_FASTCALL zend_ast_destroy(zend_ast *ast)
 		zend_ast_decl *decl = (zend_ast_decl *) ast;
 
 		if (decl->name) {
-		    zend_string_release_ex(decl->name, 0);
+		    zend_string_release_ex_outline(decl->name, 0);
 		}
 		if (decl->doc_comment) {
-			zend_string_release_ex(decl->doc_comment, 0);
+			zend_string_release_ex_outline(decl->doc_comment, 0);
 		}
 		zend_ast_destroy(decl->child[0]);
 		zend_ast_destroy(decl->child[1]);

Zend/zend_compile.c

@@ -4111,7 +4111,7 @@ static zend_result zend_compile_func_defined(znode *result, zend_ast_list *args)
 
 	name = zval_get_string(zend_ast_get_zval(args->child[0]));
 	if (zend_memrchr(ZSTR_VAL(name), '\\', ZSTR_LEN(name)) || zend_memrchr(ZSTR_VAL(name), ':', ZSTR_LEN(name))) {
-		zend_string_release_ex(name, 0);
+		zend_string_release_ex_outline(name, 0);
 		return FAILURE;
 	}
 
@@ -4280,7 +4280,7 @@ static zend_result zend_compile_func_cufa(znode *result, zend_ast_list *args, ze
 				opline = zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, &len_node);
 				opline->extended_value = Z_LVAL_P(zv);
 				zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL);
-				zend_string_release_ex(name, 0);
+				zend_string_release_ex_outline(name, 0);
 				return SUCCESS;
 			}
 		}
@@ -7534,7 +7534,7 @@ static void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32
 				&& (op_array->fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
 			zend_string *func_name = get_function_or_method_name((zend_function *) op_array);
 			zend_error(E_DEPRECATED, "%s(): Returning by reference from a void function is deprecated", ZSTR_VAL(func_name));
-			zend_string_release(func_name);
+			zend_string_release_outline(func_name);
 		}
 	} else {
 		if (list->children == 0) {
@@ -7670,7 +7670,7 @@ static void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32
 					"%s(): Optional parameter $%s declared before required parameter $%s "
 					"is implicitly treated as a required parameter",
 					ZSTR_VAL(func_name), ZSTR_VAL(name), ZSTR_VAL(zend_ast_get_str(required_param_ast->child[1])));
-				zend_string_release(func_name);
+				zend_string_release_outline(func_name);
 			}
 
 			/* Regardless of whether we issue a deprecation, convert this parameter into
@@ -10759,7 +10759,7 @@ static void zend_compile_class_const(znode *result, zend_ast *ast) /* {{{ */
 			zend_string *resolved_name = zend_resolve_class_name_ast(class_ast);
 			if (zend_try_ct_eval_class_const(&result->u.constant, resolved_name, const_str)) {
 				result->op_type = IS_CONST;
-				zend_string_release_ex(resolved_name, 0);
+				zend_string_release_ex_outline(resolved_name, 0);
 				return;
 			}
 			zend_string_release_ex(resolved_name, 0);

Zend/zend_constants.c

@@ -573,7 +573,7 @@ ZEND_API zend_result zend_register_constant(zend_constant *c)
 		|| zend_hash_add_constant(EG(zend_constants), name, c) == NULL
 	) {
 		zend_error(E_WARNING, "Constant %s already defined", ZSTR_VAL(name));
-		zend_string_release(c->name);
+		zend_string_release_outline(c->name);
 		if (!persistent) {
 			zval_ptr_dtor_nogc(&c->value);
 		}

Zend/zend_exceptions.c

@@ -844,7 +844,7 @@ ZEND_API ZEND_COLD zend_object *zend_throw_exception(zend_class_entry *exception
 	zend_string *msg_str = message ? zend_string_init(message, strlen(message), 0) : NULL;
 	zend_object *ex = zend_throw_exception_zstr(exception_ce, msg_str, code);
 	if (msg_str) {
-		zend_string_release(msg_str);
+		zend_string_release_outline(msg_str);
 	}
 	return ex;
 }
@@ -884,7 +884,7 @@ static void zend_error_va(int type, zend_string *file, uint32_t lineno, const ch
 	zend_string *message = zend_vstrpprintf(0, format, args);
 	zend_observer_error_notify(type, file, lineno, message);
 	zend_error_cb(type, file, lineno, message);
-	zend_string_release(message);
+	zend_string_release_outline(message);
 	va_end(args);
 }
 /* }}} */
@@ -908,8 +908,8 @@ ZEND_API ZEND_COLD zend_result zend_exception_error(zend_object *ex, int severit
 		zend_observer_error_notify(type, file, line, message);
 		zend_error_cb(type, file, line, message);
 
-		zend_string_release_ex(file, 0);
-		zend_string_release_ex(message, 0);
+		zend_string_release_ex_outline(file, 0);
+		zend_string_release_ex_outline(message, 0);
 	} else if (instanceof_function(ce_exception, zend_ce_throwable)) {
 		zval tmp;
 		zend_string *str, *file = NULL;
@@ -940,7 +940,7 @@ ZEND_API ZEND_COLD zend_result zend_exception_error(zend_object *ex, int severit
 				ZSTR_VAL(Z_OBJCE(zv)->name), ZSTR_VAL(ce_exception->name));
 
 			if (file) {
-				zend_string_release_ex(file, 0);
+				zend_string_release_ex_outline(file, 0);
 			}
 		}
 
@@ -952,8 +952,8 @@ ZEND_API ZEND_COLD zend_result zend_exception_error(zend_object *ex, int severit
 			(file && ZSTR_LEN(file) > 0) ? file : NULL, line,
 			"Uncaught %S\n  thrown", str);
 
-		zend_string_release_ex(str, 0);
-		zend_string_release_ex(file, 0);
+		zend_string_release_ex_outline(str, 0);
+		zend_string_release_ex_outline(file, 0);
 	} else if (ce_exception == &zend_ce_unwind_exit || ce_exception == &zend_ce_graceful_exit) {
 		/* We successfully unwound, nothing more to do.
 		 * We still return FAILURE in this case, as further execution should still be aborted. */