- OpCache:
. Fixed bug #78654 (Incorrectly computed opcache checksum on files with
non-ascii characters). (mhagstrand)
+ . Fixed bug #76535 (Opcache does not replay compile-time warnings). (Nikita)
- PCRE:
. Don't ignore invalid escape sequences. (sjon)
. Introduce DOMParentNode and DOMChildNode with new traversal and manipulation APIs
RFC: https://wiki.php.net/rfc/dom_living_standard_api
+- Opcache:
+ . If the opcache.record_warnings ini setting is enabled, opcache will record
+ compile-time warnings and replay them on the next include, even if it is
+ served from cache.
+
- Zip:
. Extension updated to version 1.19.0
. New ZipArchive::lastId property to get index value of last added entry.
static zend_op_array *(*accelerator_orig_compile_file)(zend_file_handle *file_handle, int type);
static int (*accelerator_orig_zend_stream_open_function)(const char *filename, zend_file_handle *handle );
static zend_string *(*accelerator_orig_zend_resolve_path)(const char *filename, size_t filename_len);
+static void (*accelerator_orig_zend_error_cb)(int type, const char *error_filename, const uint32_t error_lineno, const char *format, va_list args);
static zif_handler orig_chdir = NULL;
static ZEND_INI_MH((*orig_include_path_on_modify)) = NULL;
static int (*orig_post_startup_cb)(void);
}
}
+static void persistent_error_cb(int type, const char *error_filename, const uint32_t error_lineno, const char *format, va_list args) {
+ if (ZCG(record_warnings)) {
+ zend_recorded_warning *warning = emalloc(sizeof(zend_recorded_warning));
+ va_list args_copy;
+ warning->type = type;
+ warning->error_lineno = error_lineno;
+ warning->error_filename = zend_string_init(error_filename, strlen(error_filename), 0);
+ va_copy(args_copy, args);
+ warning->error_message = zend_vstrpprintf(0, format, args_copy);
+ va_end(args_copy);
+
+ ZCG(num_warnings)++;
+ ZCG(warnings) = erealloc(ZCG(warnings), sizeof(zend_recorded_warning) * ZCG(num_warnings));
+ ZCG(warnings)[ZCG(num_warnings)-1] = warning;
+ }
+ accelerator_orig_zend_error_cb(type, error_filename, error_lineno, format, args);
+}
+
+/* Hack to get us a va_list to pass to zend_error_cb. */
+static void replay_warning_helper(const zend_recorded_warning *warning, ...) {
+ va_list va;
+ va_start(va, warning);
+ accelerator_orig_zend_error_cb(
+ warning->type, ZSTR_VAL(warning->error_filename), warning->error_lineno, "%s", va);
+ va_end(va);
+}
+
+static void replay_warnings(zend_persistent_script *script) {
+ for (uint32_t i = 0; i < script->num_warnings; i++) {
+ zend_recorded_warning *warning = script->warnings[i];
+ replay_warning_helper(warning, ZSTR_VAL(warning->error_message));
+ }
+}
+
+static void free_recorded_warnings() {
+ if (!ZCG(num_warnings)) {
+ return;
+ }
+
+ for (uint32_t i = 0; i < ZCG(num_warnings); i++) {
+ zend_recorded_warning *warning = ZCG(warnings)[i];
+ zend_string_release(warning->error_filename);
+ zend_string_release(warning->error_message);
+ efree(warning);
+ }
+ efree(ZCG(warnings));
+ ZCG(warnings) = NULL;
+ ZCG(num_warnings) = 0;
+}
+
static zend_persistent_script *opcache_compile_file(zend_file_handle *file_handle, int type, const char *key, zend_op_array **op_array_p)
{
zend_persistent_script *new_persistent_script;
/* Override them with ours */
ZVAL_UNDEF(&EG(user_error_handler));
+ ZCG(record_warnings) = ZCG(accel_directives).record_warnings;
+ ZCG(num_warnings) = 0;
+ ZCG(warnings) = NULL;
zend_try {
orig_compiler_options = CG(compiler_options);
/* Restore originals */
CG(active_op_array) = orig_active_op_array;
EG(user_error_handler) = orig_user_error_handler;
+ ZCG(record_warnings) = 0;
if (!op_array) {
/* compilation failed */
+ free_recorded_warnings();
if (do_bailout) {
zend_bailout();
}
(op_array->fn_flags & ZEND_ACC_EARLY_BINDING) ?
zend_build_delayed_early_binding_list(op_array) :
(uint32_t)-1;
+ new_persistent_script->num_warnings = ZCG(num_warnings);
+ new_persistent_script->warnings = ZCG(warnings);
+ ZCG(num_warnings) = 0;
+ ZCG(warnings) = NULL;
efree(op_array); /* we have valid persistent_script, so it's safe to free op_array */
}
}
}
+ replay_warnings(persistent_script);
zend_file_handle_dtor(file_handle);
if (persistent_script->ping_auto_globals_mask) {
}
}
}
+ replay_warnings(persistent_script);
zend_file_handle_dtor(file_handle);
from_shared_memory = 1;
}
accelerator_orig_zend_resolve_path = zend_resolve_path;
zend_resolve_path = persistent_zend_resolve_path;
+ /* Override error callback, so we can store errors that occur during compilation */
+ accelerator_orig_zend_error_cb = zend_error_cb;
+ zend_error_cb = persistent_error_cb;
+
/* Override chdir() function */
if ((func = zend_hash_str_find_ptr(CG(function_table), "chdir", sizeof("chdir")-1)) != NULL &&
func->type == ZEND_INTERNAL_FUNCTION) {
ACCEL_RESTART_USER /* restart scheduled by opcache_reset() */
} zend_accel_restart_reason;
+typedef struct _zend_recorded_warning {
+ int type;
+ uint32_t error_lineno;
+ zend_string *error_filename;
+ zend_string *error_message;
+} zend_recorded_warning;
+
typedef struct _zend_persistent_script {
zend_script script;
zend_long compiler_halt_offset; /* position of __HALT_COMPILER or -1 */
zend_bool corrupted;
zend_bool is_phar;
zend_bool empty;
+ uint32_t num_warnings;
+ zend_recorded_warning **warnings;
void *mem; /* shared memory area used by script structures */
size_t size; /* size of used shared memory */
zend_bool validate_timestamps;
zend_bool revalidate_path;
zend_bool save_comments;
+ zend_bool record_warnings;
zend_bool protect_memory;
zend_bool file_override_enabled;
zend_bool enable_cli;
void *arena_mem;
zend_persistent_script *current_persistent_script;
zend_bool is_immutable_class;
+ /* Temporary storage for warnings before they are moved into persistent_script. */
+ zend_bool record_warnings;
+ uint32_t num_warnings;
+ zend_recorded_warning **warnings;
/* cache to save hash lookup on the same INCLUDE opcode */
const zend_op *cache_opline;
zend_persistent_script *cache_persistent_script;
--- /dev/null
+<?php
+
+declare(unknown=1);
--- /dev/null
+--TEST--
+Opcache should replay compilation warnings if opcache.record_warnings=1
+--INI--
+opcache.record_warnings=1
+--FILE--
+<?php
+
+require __DIR__ . '/warning_replay.inc';
+require __DIR__ . '/warning_replay.inc';
+
+?>
+--EXPECTF--
+Warning: Unsupported declare 'unknown' in %swarning_replay.inc on line 3
+
+Warning: Unsupported declare 'unknown' in %swarning_replay.inc on line 3
STD_PHP_INI_BOOLEAN("opcache.protect_memory" , "0" , PHP_INI_SYSTEM, OnUpdateBool, accel_directives.protect_memory, zend_accel_globals, accel_globals)
STD_PHP_INI_BOOLEAN("opcache.save_comments" , "1" , PHP_INI_SYSTEM, OnUpdateBool, accel_directives.save_comments, zend_accel_globals, accel_globals)
+ STD_PHP_INI_BOOLEAN("opcache.record_warnings" , "0" , PHP_INI_SYSTEM, OnUpdateBool, accel_directives.record_warnings, zend_accel_globals, accel_globals)
STD_PHP_INI_ENTRY("opcache.optimization_level" , DEFAULT_OPTIMIZATION_LEVEL , PHP_INI_SYSTEM, OnUpdateLong, accel_directives.optimization_level, zend_accel_globals, accel_globals)
STD_PHP_INI_ENTRY("opcache.opt_debug_level" , "0" , PHP_INI_SYSTEM, OnUpdateLong, accel_directives.opt_debug_level, zend_accel_globals, accel_globals)
add_assoc_bool(&directives, "opcache.protect_memory", ZCG(accel_directives).protect_memory);
add_assoc_bool(&directives, "opcache.save_comments", ZCG(accel_directives).save_comments);
+ add_assoc_bool(&directives, "opcache.record_warnings", ZCG(accel_directives).record_warnings);
add_assoc_bool(&directives, "opcache.enable_file_override", ZCG(accel_directives).file_override_enabled);
add_assoc_long(&directives, "opcache.optimization_level", ZCG(accel_directives).optimization_level);
ZEND_MAP_PTR_INIT(ce->static_members_table, &ce->default_static_members_table);
}
+static void zend_file_cache_serialize_warnings(
+ zend_persistent_script *script, zend_file_cache_metainfo *info, void *buf)
+{
+ if (script->warnings) {
+ zend_recorded_warning **warnings;
+ SERIALIZE_PTR(script->warnings);
+ warnings = script->warnings;
+ UNSERIALIZE_PTR(warnings);
+
+ for (uint32_t i = 0; i < script->num_warnings; i++) {
+ zend_recorded_warning *warning;
+ SERIALIZE_PTR(warnings[i]);
+ warning = warnings[i];
+ UNSERIALIZE_PTR(warning);
+ SERIALIZE_STR(warning->error_filename);
+ SERIALIZE_STR(warning->error_message);
+ }
+ }
+}
+
static void zend_file_cache_serialize(zend_persistent_script *script,
zend_file_cache_metainfo *info,
void *buf)
zend_file_cache_serialize_hash(&new_script->script.class_table, script, info, buf, zend_file_cache_serialize_class);
zend_file_cache_serialize_hash(&new_script->script.function_table, script, info, buf, zend_file_cache_serialize_func);
zend_file_cache_serialize_op_array(&new_script->script.main_op_array, script, info, buf);
+ zend_file_cache_serialize_warnings(new_script, info, buf);
SERIALIZE_PTR(new_script->arena_mem);
new_script->mem = NULL;
}
}
+static void zend_file_cache_unserialize_warnings(zend_persistent_script *script, void *buf)
+{
+ if (script->warnings) {
+ UNSERIALIZE_PTR(script->warnings);
+ for (uint32_t i = 0; i < script->num_warnings; i++) {
+ UNSERIALIZE_PTR(script->warnings[i]);
+ UNSERIALIZE_STR(script->warnings[i]->error_filename);
+ UNSERIALIZE_STR(script->warnings[i]->error_message);
+ }
+ }
+}
+
static void zend_file_cache_unserialize(zend_persistent_script *script,
void *buf)
{
zend_file_cache_unserialize_hash(&script->script.function_table,
script, buf, zend_file_cache_unserialize_func, ZEND_FUNCTION_DTOR);
zend_file_cache_unserialize_op_array(&script->script.main_op_array, script, buf);
+ zend_file_cache_unserialize_warnings(script, buf);
UNSERIALIZE_PTR(script->arena_mem);
}
} ZEND_HASH_FOREACH_END();
}
+static void zend_persist_warnings(zend_persistent_script *script) {
+ if (script->warnings) {
+ script->warnings = zend_shared_memdup_free(
+ script->warnings, script->num_warnings * sizeof(zend_recorded_warning *));
+ for (uint32_t i = 0; i < script->num_warnings; i++) {
+ script->warnings[i] = zend_shared_memdup_free(
+ script->warnings[i], sizeof(zend_recorded_warning));
+ zend_accel_store_string(script->warnings[i]->error_filename);
+ zend_accel_store_string(script->warnings[i]->error_message);
+ }
+ }
+}
+
zend_persistent_script *zend_accel_script_persist(zend_persistent_script *script, const char **key, unsigned int key_length, int for_shm)
{
Bucket *p;
zend_persist_op_array(&p->val);
} ZEND_HASH_FOREACH_END();
zend_persist_op_array_ex(&script->script.main_op_array, script);
+ zend_persist_warnings(script);
if (for_shm) {
ZCSG(map_ptr_last) = CG(map_ptr_last);
} ZEND_HASH_FOREACH_END();
}
+static void zend_persist_warnings_calc(zend_persistent_script *script) {
+ ADD_SIZE(script->num_warnings * sizeof(zend_recorded_warning *));
+ for (uint32_t i = 0; i < script->num_warnings; i++) {
+ ADD_SIZE(sizeof(zend_recorded_warning));
+ ADD_STRING(script->warnings[i]->error_filename);
+ ADD_STRING(script->warnings[i]->error_message);
+ }
+}
+
uint32_t zend_accel_script_persist_calc(zend_persistent_script *new_persistent_script, const char *key, unsigned int key_length, int for_shm)
{
Bucket *p;
zend_persist_op_array_calc(&p->val);
} ZEND_HASH_FOREACH_END();
zend_persist_op_array_calc_ex(&new_persistent_script->script.main_op_array);
+ zend_persist_warnings_calc(new_persistent_script);
#if defined(__AVX__) || defined(__SSE2__)
/* Align size to 64-byte boundary */
; size of the optimized code.
;opcache.save_comments=1
+; If enabled, compilation warnings (including notices and deprecations) will
+; be recorded and replayed each time a file is included. Otherwise, compilation
+; warnings will only be emitted when the file is first cached.
+;opcache.record_warnings=0
+
; Allow file existence override (file_exists, etc.) performance feature.
;opcache.enable_file_override=0
; size of the optimized code.
;opcache.save_comments=1
+; If enabled, compilation warnings (including notices and deprecations) will
+; be recorded and replayed each time a file is included. Otherwise, compilation
+; warnings will only be emitted when the file is first cached.
+;opcache.record_warnings=0
+
; Allow file existence override (file_exists, etc.) performance feature.
;opcache.enable_file_override=0
projects / php / commitdiff