/* +----------------------------------------------------------------------+ | Zend OPcache | +----------------------------------------------------------------------+ | Copyright (c) The PHP Group | +----------------------------------------------------------------------+ | This source file is subject to version 3.01 of the PHP license, | | that is bundled with this package in the file LICENSE, and is | | available through the world-wide-web at the following url: | | https://www.php.net/license/3_01.txt | | If you did not receive a copy of the PHP license and are unable to | | obtain it through the world-wide-web, please send a note to | | license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Authors: Andi Gutmans | | Zeev Suraski | | Stanislav Malyshev | | Dmitry Stogov | +----------------------------------------------------------------------+ */ #include "zend_API.h" #include "zend_constants.h" #include "zend_inheritance.h" #include "zend_accelerator_util_funcs.h" #include "zend_persist.h" #include "zend_shared_alloc.h" #include "zend_observer.h" #ifdef __SSE2__ /* For SSE2 adler32 */ #include #endif typedef int (*id_function_t)(void *, void *); typedef void (*unique_copy_ctor_func_t)(void *pElement); zend_persistent_script* create_persistent_script(void) { zend_persistent_script *persistent_script = (zend_persistent_script *) emalloc(sizeof(zend_persistent_script)); memset(persistent_script, 0, sizeof(zend_persistent_script)); zend_hash_init(&persistent_script->script.function_table, 0, NULL, ZEND_FUNCTION_DTOR, 0); /* class_table is usually destroyed by free_persistent_script() that * overrides destructor. ZEND_CLASS_DTOR may be used by standard * PHP compiler */ zend_hash_init(&persistent_script->script.class_table, 0, NULL, ZEND_CLASS_DTOR, 0); return persistent_script; } void free_persistent_script(zend_persistent_script *persistent_script, int destroy_elements) { if (!destroy_elements) { /* Both the keys and values have been transferred into the global tables. * Set nNumUsed=0 to only deallocate the table, but not destroy any elements. */ persistent_script->script.function_table.nNumUsed = 0; persistent_script->script.class_table.nNumUsed = 0; } else { destroy_op_array(&persistent_script->script.main_op_array); } zend_hash_destroy(&persistent_script->script.function_table); zend_hash_destroy(&persistent_script->script.class_table); if (persistent_script->script.filename) { zend_string_release_ex(persistent_script->script.filename, 0); } if (persistent_script->warnings) { for (uint32_t i = 0; i < persistent_script->num_warnings; i++) { zend_error_info *info = persistent_script->warnings[i]; zend_string_release(info->filename); zend_string_release(info->message); efree(info); } efree(persistent_script->warnings); } zend_accel_free_delayed_early_binding_list(persistent_script); efree(persistent_script); } void zend_accel_move_user_functions(HashTable *src, uint32_t count, zend_script *script) { Bucket *p, *end; HashTable *dst; zend_string *filename; dtor_func_t orig_dtor; zend_function *function; if (!count) { return; } dst = &script->function_table; filename = script->main_op_array.filename; orig_dtor = src->pDestructor; src->pDestructor = NULL; zend_hash_extend(dst, count, 0); end = src->arData + src->nNumUsed; p = end - count; for (; p != end; p++) { if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue; function = Z_PTR(p->val); if (EXPECTED(function->type == ZEND_USER_FUNCTION) && EXPECTED(function->op_array.filename == filename)) { _zend_hash_append_ptr(dst, p->key, function); zend_hash_del_bucket(src, p); } } src->pDestructor = orig_dtor; } void zend_accel_move_user_classes(HashTable *src, uint32_t count, zend_script *script) { Bucket *p, *end; HashTable *dst; zend_string *filename; dtor_func_t orig_dtor; zend_class_entry *ce; if (!count) { return; } dst = &script->class_table; filename = script->main_op_array.filename; orig_dtor = src->pDestructor; src->pDestructor = NULL; zend_hash_extend(dst, count, 0); end = src->arData + src->nNumUsed; p = end - count; for (; p != end; p++) { if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue; ce = Z_PTR(p->val); if (EXPECTED(ce->type == ZEND_USER_CLASS) && EXPECTED(ce->info.user.filename == filename)) { _zend_hash_append_ptr(dst, p->key, ce); zend_hash_del_bucket(src, p); } } src->pDestructor = orig_dtor; } static zend_always_inline void _zend_accel_function_hash_copy(HashTable *target, HashTable *source, bool call_observers) { zend_function *function1, *function2; Bucket *p, *end; zval *t; zend_hash_extend(target, target->nNumUsed + source->nNumUsed, 0); p = source->arData; end = p + source->nNumUsed; for (; p != end; p++) { ZEND_ASSERT(Z_TYPE(p->val) != IS_UNDEF); ZEND_ASSERT(p->key); t = zend_hash_find_known_hash(target, p->key); if (UNEXPECTED(t != NULL)) { goto failure; } _zend_hash_append_ptr_ex(target, p->key, Z_PTR(p->val), 1); if (UNEXPECTED(call_observers) && *ZSTR_VAL(p->key)) { // if not rtd key _zend_observer_function_declared_notify(Z_PTR(p->val), p->key); } } target->nInternalPointer = 0; return; failure: function1 = Z_PTR(p->val); function2 = Z_PTR_P(t); CG(in_compilation) = 1; zend_set_compiled_filename(function1->op_array.filename); CG(zend_lineno) = function1->op_array.line_start; if (function2->type == ZEND_USER_FUNCTION && function2->op_array.last > 0) { zend_error_noreturn(E_ERROR, "Cannot redeclare function %s() (previously declared in %s:%d)", ZSTR_VAL(function1->common.function_name), ZSTR_VAL(function2->op_array.filename), (int)function2->op_array.line_start); } else { zend_error_noreturn(E_ERROR, "Cannot redeclare function %s()", ZSTR_VAL(function1->common.function_name)); } } static zend_always_inline void zend_accel_function_hash_copy(HashTable *target, HashTable *source) { _zend_accel_function_hash_copy(target, source, 0); } static zend_never_inline void zend_accel_function_hash_copy_notify(HashTable *target, HashTable *source) { _zend_accel_function_hash_copy(target, source, 1); } static zend_always_inline void _zend_accel_class_hash_copy(HashTable *target, HashTable *source, bool call_observers) { Bucket *p, *end; zval *t; zend_hash_extend(target, target->nNumUsed + source->nNumUsed, 0); p = source->arData; end = p + source->nNumUsed; for (; p != end; p++) { ZEND_ASSERT(Z_TYPE(p->val) != IS_UNDEF); ZEND_ASSERT(p->key); t = zend_hash_find_known_hash(target, p->key); if (UNEXPECTED(t != NULL)) { if (EXPECTED(ZSTR_LEN(p->key) > 0) && EXPECTED(ZSTR_VAL(p->key)[0] == 0)) { /* Runtime definition key. There are two circumstances under which the key can * already be defined: * 1. The file has been re-included without being changed in the meantime. In * this case we can keep the old value, because we know that the definition * hasn't changed. * 2. The file has been changed in the meantime, but the RTD key ends up colliding. * This would be a bug. * As we can't distinguish these cases, we assume that it is 1. and keep the old * value. */ continue; } else if (UNEXPECTED(!ZCG(accel_directives).ignore_dups)) { zend_class_entry *ce1 = Z_PTR(p->val); if (!(ce1->ce_flags & ZEND_ACC_ANON_CLASS)) { CG(in_compilation) = 1; zend_set_compiled_filename(ce1->info.user.filename); CG(zend_lineno) = ce1->info.user.line_start; zend_class_redeclaration_error(E_ERROR, Z_PTR_P(t)); return; } continue; } } else { zend_class_entry *ce = Z_PTR(p->val); _zend_hash_append_ptr_ex(target, p->key, Z_PTR(p->val), 1); if ((ce->ce_flags & ZEND_ACC_LINKED) && ZSTR_VAL(p->key)[0]) { if (ZSTR_HAS_CE_CACHE(ce->name)) { ZSTR_SET_CE_CACHE_EX(ce->name, ce, 0); } if (UNEXPECTED(call_observers)) { _zend_observer_class_linked_notify(ce, p->key); } } } } target->nInternalPointer = 0; } static zend_always_inline void zend_accel_class_hash_copy(HashTable *target, HashTable *source) { _zend_accel_class_hash_copy(target, source, 0); } static zend_never_inline void zend_accel_class_hash_copy_notify(HashTable *target, HashTable *source) { _zend_accel_class_hash_copy(target, source, 1); } void zend_accel_build_delayed_early_binding_list(zend_persistent_script *persistent_script) { zend_op_array *op_array = &persistent_script->script.main_op_array; if (!(op_array->fn_flags & ZEND_ACC_EARLY_BINDING)) { return; } zend_op *end = op_array->opcodes + op_array->last; for (zend_op *opline = op_array->opcodes; opline < end; opline++) { if (opline->opcode == ZEND_DECLARE_CLASS_DELAYED) { persistent_script->num_early_bindings++; } } zend_early_binding *early_binding = persistent_script->early_bindings = emalloc(sizeof(zend_early_binding) * persistent_script->num_early_bindings); for (zend_op *opline = op_array->opcodes; opline < end; opline++) { if (opline->opcode == ZEND_DECLARE_CLASS_DELAYED) { zval *lcname = RT_CONSTANT(opline, opline->op1); early_binding->lcname = zend_string_copy(Z_STR_P(lcname)); early_binding->rtd_key = zend_string_copy(Z_STR_P(lcname + 1)); early_binding->lc_parent_name = zend_string_copy(Z_STR_P(RT_CONSTANT(opline, opline->op2))); early_binding->cache_slot = (uint32_t) -1; early_binding++; } } } void zend_accel_finalize_delayed_early_binding_list(zend_persistent_script *persistent_script) { if (!persistent_script->num_early_bindings) { return; } zend_early_binding *early_binding = persistent_script->early_bindings; zend_early_binding *early_binding_end = early_binding + persistent_script->num_early_bindings; zend_op_array *op_array = &persistent_script->script.main_op_array; zend_op *opline_end = op_array->opcodes + op_array->last; for (zend_op *opline = op_array->opcodes; opline < opline_end; opline++) { if (opline->opcode == ZEND_DECLARE_CLASS_DELAYED) { zend_string *rtd_key = Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1); /* Skip early_binding entries that don't match, maybe their DECLARE_CLASS_DELAYED * was optimized away. */ while (!zend_string_equals(early_binding->rtd_key, rtd_key)) { early_binding++; if (early_binding >= early_binding_end) { return; } } early_binding->cache_slot = opline->extended_value; early_binding++; if (early_binding >= early_binding_end) { return; } } } } void zend_accel_free_delayed_early_binding_list(zend_persistent_script *persistent_script) { if (persistent_script->num_early_bindings) { for (uint32_t i = 0; i < persistent_script->num_early_bindings; i++) { zend_early_binding *early_binding = &persistent_script->early_bindings[i]; zend_string_release(early_binding->lcname); zend_string_release(early_binding->rtd_key); zend_string_release(early_binding->lc_parent_name); } efree(persistent_script->early_bindings); persistent_script->early_bindings = NULL; persistent_script->num_early_bindings = 0; } } static void zend_accel_do_delayed_early_binding( zend_persistent_script *persistent_script, zend_op_array *op_array) { ZEND_ASSERT(!ZEND_MAP_PTR(op_array->run_time_cache)); ZEND_ASSERT(op_array->fn_flags & ZEND_ACC_HEAP_RT_CACHE); void *run_time_cache = emalloc(op_array->cache_size); ZEND_MAP_PTR_INIT(op_array->run_time_cache, run_time_cache); memset(run_time_cache, 0, op_array->cache_size); zend_string *orig_compiled_filename = CG(compiled_filename); bool orig_in_compilation = CG(in_compilation); CG(compiled_filename) = persistent_script->script.filename; CG(in_compilation) = 1; for (uint32_t i = 0; i < persistent_script->num_early_bindings; i++) { zend_early_binding *early_binding = &persistent_script->early_bindings[i]; zend_class_entry *ce = zend_hash_find_ex_ptr(EG(class_table), early_binding->lcname, 1); if (!ce) { zval *zv = zend_hash_find_known_hash(EG(class_table), early_binding->rtd_key); if (zv) { zend_class_entry *orig_ce = Z_CE_P(zv); zend_class_entry *parent_ce = !(orig_ce->ce_flags & ZEND_ACC_LINKED) ? zend_hash_find_ex_ptr(EG(class_table), early_binding->lc_parent_name, 1) : NULL; if (parent_ce || (orig_ce->ce_flags & ZEND_ACC_LINKED)) { ce = zend_try_early_bind(orig_ce, parent_ce, early_binding->lcname, zv); } } if (ce && early_binding->cache_slot != (uint32_t) -1) { *(void**)((char*)run_time_cache + early_binding->cache_slot) = ce; } } } CG(compiled_filename) = orig_compiled_filename; CG(in_compilation) = orig_in_compilation; } zend_op_array* zend_accel_load_script(zend_persistent_script *persistent_script, int from_shared_memory) { zend_op_array *op_array; op_array = (zend_op_array *) emalloc(sizeof(zend_op_array)); *op_array = persistent_script->script.main_op_array; if (EXPECTED(from_shared_memory)) { if (ZCSG(map_ptr_last) > CG(map_ptr_last)) { zend_map_ptr_extend(ZCSG(map_ptr_last)); } /* Register __COMPILER_HALT_OFFSET__ constant */ if (persistent_script->compiler_halt_offset != 0 && persistent_script->script.filename) { zend_string *name; static const char haltoff[] = "__COMPILER_HALT_OFFSET__"; name = zend_mangle_property_name(haltoff, sizeof(haltoff) - 1, ZSTR_VAL(persistent_script->script.filename), ZSTR_LEN(persistent_script->script.filename), 0); if (!zend_hash_exists(EG(zend_constants), name)) { zend_register_long_constant(ZSTR_VAL(name), ZSTR_LEN(name), persistent_script->compiler_halt_offset, 0, 0); } zend_string_release_ex(name, 0); } } if (zend_hash_num_elements(&persistent_script->script.function_table) > 0) { if (EXPECTED(!zend_observer_function_declared_observed)) { zend_accel_function_hash_copy(CG(function_table), &persistent_script->script.function_table); } else { zend_accel_function_hash_copy_notify(CG(function_table), &persistent_script->script.function_table); } } if (zend_hash_num_elements(&persistent_script->script.class_table) > 0) { if (EXPECTED(!zend_observer_class_linked_observed)) { zend_accel_class_hash_copy(CG(class_table), &persistent_script->script.class_table); } else { zend_accel_class_hash_copy_notify(CG(class_table), &persistent_script->script.class_table); } } if (persistent_script->num_early_bindings) { zend_accel_do_delayed_early_binding(persistent_script, op_array); } if (UNEXPECTED(!from_shared_memory)) { free_persistent_script(persistent_script, 0); /* free only hashes */ } return op_array; } /* * zend_adler32() is based on zlib implementation * Computes the Adler-32 checksum of a data stream * * Copyright (C) 1995-2005 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h * * Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler * * This software is provided 'as-is', without any express or implied * warranty. In no event will the authors be held liable for any damages * arising from the use of this software. * * Permission is granted to anyone to use this software for any purpose, * including commercial applications, and to alter it and redistribute it * freely, subject to the following restrictions: * * 1. The origin of this software must not be misrepresented; you must not * claim that you wrote the original software. If you use this software * in a product, an acknowledgment in the product documentation would be * appreciated but is not required. * 2. Altered source versions must be plainly marked as such, and must not be * misrepresented as being the original software. * 3. This notice may not be removed or altered from any source distribution. * */ #define ADLER32_BASE 65521 /* largest prime smaller than 65536 */ #define ADLER32_NMAX 5552 /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ #define ADLER32_SCALAR_DO1(buf) {s1 += *(buf); s2 += s1;} #define ADLER32_SCALAR_DO2(buf, i) ADLER32_SCALAR_DO1(buf + i); ADLER32_SCALAR_DO1(buf + i + 1); #define ADLER32_SCALAR_DO4(buf, i) ADLER32_SCALAR_DO2(buf, i); ADLER32_SCALAR_DO2(buf, i + 2); #define ADLER32_SCALAR_DO8(buf, i) ADLER32_SCALAR_DO4(buf, i); ADLER32_SCALAR_DO4(buf, i + 4); #define ADLER32_SCALAR_DO16(buf) ADLER32_SCALAR_DO8(buf, 0); ADLER32_SCALAR_DO8(buf, 8); static zend_always_inline void adler32_do16_loop(unsigned char *buf, unsigned char *end, unsigned int *s1_out, unsigned int *s2_out) { unsigned int s1 = *s1_out; unsigned int s2 = *s2_out; #ifdef __SSE2__ const __m128i zero = _mm_setzero_si128(); __m128i accumulate_s2 = zero; unsigned int accumulate_s1 = 0; do { __m128i read = _mm_loadu_si128((__m128i *) buf); /* [A:P] */ /* Split the 8-bit-element vector into two 16-bit-element vectors where each element gets zero-extended from 8-bits to 16-bits */ __m128i lower = _mm_unpacklo_epi8(read, zero); /* [A:H] zero-extended to 16-bits */ __m128i higher = _mm_unpackhi_epi8(read, zero); /* [I:P] zero-extended to 16-bits */ lower = _mm_madd_epi16(lower, _mm_set_epi16(9, 10, 11, 12, 13, 14, 15, 16)); /* [A * 16:H * 9] */ higher = _mm_madd_epi16(higher, _mm_set_epi16(1, 2, 3, 4, 5, 6, 7, 8)); /* [I * 8:P * 1] */ /* We'll cheat here: it's difficult to add 16-bit elementwise, but we can do 32-bit additions. * The highest value the sum of two elements of the vectors can take is 0xff * 16 + 0xff * 8 < 0xffff. * That means there is no carry possible from 16->17 bits so the 32-bit addition is safe. */ __m128i sum = _mm_add_epi32(lower, higher); /* [A * 16 + I * 8:H * 9 + P * 1] */ accumulate_s2 = _mm_add_epi32(accumulate_s2, sum); accumulate_s1 += s1; /* Computes 8-bit element-wise abs(buf - zero) and then sums the elements into two 16 bit parts */ sum = _mm_sad_epu8(read, zero); s1 += _mm_cvtsi128_si32(sum) + _mm_extract_epi16(sum, 4); buf += 16; } while (buf != end); /* For convenience, let's do a rename of variables and let accumulate_s2 = [X, Y, Z, W] */ __m128i shuffled = _mm_shuffle_epi32(accumulate_s2, _MM_SHUFFLE(1, 0, 0, 2)); /* [Y, X, X, Z] */ accumulate_s2 = _mm_add_epi32(accumulate_s2, shuffled); /* [X + Y, Y + X, Z + X, W + Z] */ shuffled = _mm_shuffle_epi32(accumulate_s2, _MM_SHUFFLE(3, 3, 3, 3)); /* [X + Y, X + Y, X + Y, X + Y] */ accumulate_s2 = _mm_add_epi32(accumulate_s2, shuffled); /* [/, /, /, W + Z + X + Y] */ s2 += accumulate_s1 * 16 + _mm_cvtsi128_si32(accumulate_s2); #else do { ADLER32_SCALAR_DO16(buf); buf += 16; } while (buf != end); #endif *s1_out = s1; *s2_out = s2; } unsigned int zend_adler32(unsigned int checksum, unsigned char *buf, uint32_t len) { unsigned int s1 = checksum & 0xffff; unsigned int s2 = (checksum >> 16) & 0xffff; unsigned char *end; while (len >= ADLER32_NMAX) { len -= ADLER32_NMAX; end = buf + ADLER32_NMAX; adler32_do16_loop(buf, end, &s1, &s2); buf = end; s1 %= ADLER32_BASE; s2 %= ADLER32_BASE; } if (len) { if (len >= 16) { end = buf + (len & 0xfff0); len &= 0xf; adler32_do16_loop(buf, end, &s1, &s2); buf = end; } if (len) { end = buf + len; do { ADLER32_SCALAR_DO1(buf); buf++; } while (buf != end); } s1 %= ADLER32_BASE; s2 %= ADLER32_BASE; } return (s2 << 16) | s1; } unsigned int zend_accel_script_checksum(zend_persistent_script *persistent_script) { unsigned char *mem = (unsigned char*)persistent_script->mem; size_t size = persistent_script->size; size_t persistent_script_check_block_size = ((char *)&(persistent_script->dynamic_members)) - (char *)persistent_script; unsigned int checksum = ADLER32_INIT; if (mem < (unsigned char*)persistent_script) { checksum = zend_adler32(checksum, mem, (unsigned char*)persistent_script - mem); size -= (unsigned char*)persistent_script - mem; mem += (unsigned char*)persistent_script - mem; } zend_adler32(checksum, mem, persistent_script_check_block_size); mem += sizeof(*persistent_script); size -= sizeof(*persistent_script); if (size > 0) { checksum = zend_adler32(checksum, mem, size); } return checksum; }