#include #include #include "php.h" #include "zend_extensions.h" #include "zend_compile.h" #include "zend_API.h" #include "zend_ini.h" #include "xcache.h" #include "align.h" #include "const_string.h" #include "processor.h" #include "stack.h" #include "xcache_globals.h" #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT extern unsigned int zend_hash_canary; #endif #ifndef NDEBUG #undef inline #define inline #endif typedef zval *zval_ptr; typedef zend_uchar zval_data_type; #ifdef IS_UNICODE typedef UChar zstr_uchar; #endif typedef char zstr_char; #define MAX_DUP_STR_LEN 256 /* export: typedef struct _xc_processor_t xc_processor_t; :export {{{ */ struct _xc_processor_t { char *p; zend_uint size; HashTable strings; HashTable zvalptrs; zend_bool reference; /* enable if to deal with reference */ zend_bool have_references; const xc_entry_t *xce_src; const xc_entry_t *xce_dst; const zend_class_entry *cache_ce; zend_uint cache_class_num; const zend_op *active_opcodes_src; zend_op *active_opcodes_dst; const zend_class_entry *active_class_entry_src; zend_class_entry *active_class_entry_dst; zend_uint active_class_num; zend_bool readonly_protection; /* wheather it's present */ }; /* }}} */ #ifdef HAVE_XCACHE_DPRINT static void xc_dprint_indent(int indent) { /* {{{ */ int i; for (i = 0; i < indent; i++) { fprintf(stderr, " "); } } /* }}} */ static void xc_dprint_str_len(const char *str, int len) { /* {{{ */ const unsigned char *p = (const unsigned char *) str; int i; for (i = 0; i < len; i++) { if (p[i] < 32 || p[i] == 127) { fprintf(stderr, "\\%03o", (unsigned int) p[i]); } else { fputc(p[i], stderr); } } } /* }}} */ #endif /* {{{ xc_zstrlen_char */ static inline int xc_zstrlen_char(zstr s) { return strlen(ZSTR_S(s)); } /* }}} */ #ifdef IS_UNICODE /* {{{ xc_zstrlen_uchar */ static inline int xc_zstrlen_uchar(zstr s) { int i; UChar *p = ZSTR_U(s); for (i = 0; *p; i++, p++) { /* empty */ } return i; } /* }}} */ /* {{{ xc_zstrlen */ static inline int xc_zstrlen(int type, zstr s) { return type == IS_UNICODE ? xc_zstrlen_uchar(s) : xc_zstrlen_char(s); } /* }}} */ #else /* {{{ xc_zstrlen */ #define xc_zstrlen(dummy, s) xc_zstrlen_char(s) /* }}} */ #endif /* {{{ xc_calc_string_n */ static inline void xc_calc_string_n(xc_processor_t * processor, zend_uchar type, zstr str, long size) { int realsize = UNISW(size, (type == IS_UNICODE) ? UBYTES(size) : size); long dummy = 1; if (realsize > MAX_DUP_STR_LEN) { /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(char) * realsize; } else if (zend_u_hash_add(&processor->strings, type, str, size, (void *) &dummy, sizeof(dummy), NULL) == SUCCESS) { /* new string */ /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(char) * realsize; } } /* }}} */ /* {{{ xc_store_string_n */ static inline zstr xc_store_string_n(xc_processor_t * processor, zend_uchar type, zstr str, long size) { int realsize = UNISW(size, (type == IS_UNICODE) ? UBYTES(size) : size); zstr ret, *pret; if (realsize > MAX_DUP_STR_LEN) { /* allocate */ ZSTR_V(ret) = (char *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(char) * realsize; memcpy(ZSTR_V(ret), ZSTR_V(str), realsize); return ret; } if (zend_u_hash_find(&processor->strings, type, str, size, (void **) &pret) == SUCCESS) { return *pret; } /* new string */ /* allocate */ ZSTR_V(ret) = (char *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(char) * realsize; memcpy(ZSTR_V(ret), ZSTR_V(str), realsize); zend_u_hash_add(&processor->strings, type, str, size, (void *) &ret, sizeof(zstr), NULL); return ret; } /* }}} */ /* * {{{ xc_get_class_num return class_index + 1 */ static zend_ulong xc_get_class_num(xc_processor_t * processor, zend_class_entry * ce) { zend_ulong i; const xc_entry_t *xce = processor->xce_src; zend_class_entry *ceptr; if (processor->cache_ce == ce) { return processor->cache_class_num; } for (i = 0; i < xce->data.php->classinfo_cnt; i++) { ceptr = CestToCePtr(xce->data.php->classinfos[i].cest); if (ZCEP_REFCOUNT_PTR(ceptr) == ZCEP_REFCOUNT_PTR(ce)) { processor->cache_ce = ceptr; processor->cache_class_num = i + 1; return i + 1; } } assert(0); return (zend_ulong) - 1; } /* }}} */ /* {{{ xc_get_class */ #ifdef ZEND_ENGINE_2 static zend_class_entry * xc_get_class(xc_processor_t * processor, zend_ulong class_num) { /* must be parent or currrent class */ assert(class_num <= processor->active_class_num); return CestToCePtr(processor->xce_dst->data.php->classinfos[class_num - 1].cest); } #endif /* }}} */ #ifdef ZEND_ENGINE_2 /* fix method on store */ static void xc_fix_method(xc_processor_t * processor, zend_op_array * dst) { /* {{{ */ zend_function *zf = (zend_function *) dst; zend_class_entry *ce = processor->active_class_entry_dst; /* * Fixing up the default functions for objects here since we need to * compare with the newly allocated functions * * caveat: a sub-class method can have the same name as the parent~s * constructor and create problems. */ if (zf->common.fn_flags & ZEND_ACC_CTOR) { if (!ce->constructor) { ce->constructor = zf; } } else if (zf->common.fn_flags & ZEND_ACC_DTOR) { ce->destructor = zf; } else if (zf->common.fn_flags & ZEND_ACC_CLONE) { ce->clone = zf; } else { #define SET_IF_SAME_NAME(member) \ do { \ if (!strcasecmp(ZSTR_S(zf->common.function_name), #member)) { \ ce->member = zf; \ } \ } \ while(0) /* * if(ce->member && !strcmp(zf->common.function_name, * ce->member->common.function_name)) { \ */ SET_IF_SAME_NAME(__get); SET_IF_SAME_NAME(__set); #ifdef ZEND_ENGINE_2_1 SET_IF_SAME_NAME(__unset); SET_IF_SAME_NAME(__isset); #endif SET_IF_SAME_NAME(__call); #if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6 SET_IF_SAME_NAME(__tostring); #endif #undef SET_IF_SAME_NAME } } /* }}} */ #endif /* {{{ call op_array ctor handler */ extern zend_bool xc_have_op_array_ctor; static void xc_zend_extension_op_array_ctor_handler(zend_extension * extension, zend_op_array * op_array TSRMLS_DC) { if (extension->op_array_ctor) { extension->op_array_ctor(op_array); } } /* }}} */ /* * export: xc_entry_t *xc_processor_store_xc_entry_t(xc_entry_t *src * TSRMLS_DC); :export {{{ */ xc_entry_t * xc_processor_store_xc_entry_t(xc_entry_t * src TSRMLS_DC) { xc_entry_t *dst; xc_processor_t processor; memset(&processor, 0, sizeof(processor)); processor.reference = 1; /* calc size */ { zend_hash_init(&processor.strings, 0, NULL, NULL, 0); if (processor.reference) { zend_hash_init(&processor.zvalptrs, 0, NULL, NULL, 0); } processor.size = 0; /* allocate */ processor.size = ALIGN(processor.size + sizeof(src[0])); xc_calc_xc_entry_t(&processor, src TSRMLS_CC); if (processor.reference) { zend_hash_destroy(&processor.zvalptrs); } zend_hash_destroy(&processor.strings); } src->size = processor.size; src->have_references = processor.have_references; /* store {{{ */ { zend_hash_init(&processor.strings, 0, NULL, NULL, 0); if (processor.reference) { zend_hash_init(&processor.zvalptrs, 0, NULL, NULL, 0); } /* mem :) */ processor.p = (char *) src->cache->mem->handlers->malloc(src->cache->mem, processor.size); if (processor.p == NULL) { dst = NULL; goto err_alloc; } assert(processor.p == (char *) ALIGN(processor.p)); /* allocate */ dst = (xc_entry_t *) processor.p; processor.p = (char *) ALIGN(processor.p + sizeof(dst[0])); xc_store_xc_entry_t(&processor, dst, src TSRMLS_CC); err_alloc: if (processor.reference) { zend_hash_destroy(&processor.zvalptrs); } zend_hash_destroy(&processor.strings); } /* }}} */ return dst; } /* }}} */ /* * export: xc_entry_t *xc_processor_restore_xc_entry_t(xc_entry_t *dst, const * xc_entry_t *src, zend_bool readonly_protection TSRMLS_DC); :export {{{ */ xc_entry_t * xc_processor_restore_xc_entry_t(xc_entry_t * dst, const xc_entry_t * src, zend_bool readonly_protection TSRMLS_DC) { xc_processor_t processor; memset(&processor, 0, sizeof(processor)); processor.readonly_protection = readonly_protection; if (src->have_references) { processor.reference = 1; } if (processor.reference) { zend_hash_init(&processor.zvalptrs, 0, NULL, NULL, 0); } xc_restore_xc_entry_t(&processor, dst, src TSRMLS_CC); if (processor.reference) { zend_hash_destroy(&processor.zvalptrs); } return dst; } /* }}} */ /* * export: zval *xc_processor_restore_zval(zval *dst, const zval *src, * zend_bool have_references TSRMLS_DC); :export {{{ */ zval * xc_processor_restore_zval(zval * dst, const zval * src, zend_bool have_references TSRMLS_DC) { xc_processor_t processor; memset(&processor, 0, sizeof(processor)); processor.reference = have_references; if (processor.reference) { zend_hash_init(&processor.zvalptrs, 0, NULL, NULL, 0); zend_hash_add(&processor.zvalptrs, (char *) src, sizeof(src), (void *) &dst, sizeof(dst), NULL); } xc_restore_zval(&processor, dst, src TSRMLS_CC); if (processor.reference) { zend_hash_destroy(&processor.zvalptrs); } return dst; } /* }}} */ /* export: void xc_dprint(xc_entry_t *src, int indent TSRMLS_DC); :export {{{ */ #ifdef HAVE_XCACHE_DPRINT void xc_dprint(xc_entry_t * src, int indent TSRMLS_DC) { xc_dprint_xc_entry_t(src, indent TSRMLS_CC); } #endif /* }}} */ /* {{{ Pre-declare */ void xc_calc_zval(xc_processor_t * processor, const zval * const src TSRMLS_DC); static void inline xc_calc_zval_ptr(xc_processor_t * processor, const zval_ptr * const src TSRMLS_DC); void xc_calc_zend_op_array(xc_processor_t * processor, const zend_op_array * const src TSRMLS_DC); void xc_calc_zend_class_entry(xc_processor_t * processor, const zend_class_entry * const src TSRMLS_DC); #ifdef HAVE_XCACHE_CONSTANT static void inline xc_calc_zend_constant(xc_processor_t * processor, const zend_constant * const src TSRMLS_DC); #endif void xc_calc_zend_function(xc_processor_t * processor, const zend_function * const src TSRMLS_DC); void xc_calc_xc_entry_t(xc_processor_t * processor, const xc_entry_t * const src TSRMLS_DC); #ifdef ZEND_ENGINE_2 static void inline xc_calc_zend_property_info(xc_processor_t * processor, const zend_property_info * const src TSRMLS_DC); #endif /* }}} */ #ifdef IS_CV /* {{{ xc_calc_zend_compiled_variable */ static void inline xc_calc_zend_compiled_variable(xc_processor_t * processor, const zend_compiled_variable * const src TSRMLS_DC) { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->name, src->name_len + 1); } } else { if (ZSTR_S(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name, src->name_len + 1); } } #else if (ZSTR_S(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name, src->name_len + 1); } #endif } /* }}} */ #endif /* {{{ xc_calc_zend_uint */ static void inline xc_calc_zend_uint(xc_processor_t * processor, const zend_uint * const src TSRMLS_DC) { } /* }}} */ #ifndef ZEND_ENGINE_2 /* {{{ xc_calc_int */ static void inline xc_calc_int(xc_processor_t * processor, const int *const src TSRMLS_DC) { } /* }}} */ #endif #ifdef ZEND_ENGINE_2 /* {{{ xc_calc_zend_try_catch_element */ static void inline xc_calc_zend_try_catch_element(xc_processor_t * processor, const zend_try_catch_element * const src TSRMLS_DC) { } /* }}} */ #endif /* ifdef ZEND_ENGINE_2 */ /* {{{ xc_calc_zend_brk_cont_element */ static void inline xc_calc_zend_brk_cont_element(xc_processor_t * processor, const zend_brk_cont_element * const src TSRMLS_DC) { #ifdef ZEND_ENGINE_2_2 #ifndef IS_UNICODE #endif #endif } /* }}} */ /* {{{ xc_calc_HashTable_zval_ptr */ static void inline xc_calc_HashTable_zval_ptr(xc_processor_t * processor, const HashTable * const src TSRMLS_DC) { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(Bucket *) * src->nTableSize; for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(char) * bucketsize; if (sizeof(void *) == sizeof(zval_ptr)) { assert(sizeof(zval_ptr) == sizeof((((zval_ptr *) b->pData))[0])); xc_calc_zval_ptr( processor, ((zval_ptr *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zval_ptr) == sizeof((((zval_ptr *) b->pData))[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zval_ptr); xc_calc_zval_ptr( processor, ((zval_ptr *) b->pData) TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_calc_HashTable_zend_constant */ static void inline xc_calc_HashTable_zend_constant(xc_processor_t * processor, const HashTable * const src TSRMLS_DC) { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(Bucket *) * src->nTableSize; for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(char) * bucketsize; if (sizeof(void *) == sizeof(zend_constant)) { assert(sizeof(zend_constant) == sizeof((((zend_constant *) b->pData))[0])); xc_calc_zend_constant( processor, ((zend_constant *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_constant) == sizeof((((zend_constant *) b->pData))[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_constant); xc_calc_zend_constant( processor, ((zend_constant *) b->pData) TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } /* }}} */ #endif /* {{{ xc_calc_HashTable_zend_function */ /* * export: void xc_calc_HashTable_zend_function( * c_processor_t *processor, const HashTable * const src * SRMLS_DC ); :export */ void xc_calc_HashTable_zend_function(xc_processor_t * processor, const HashTable * const src TSRMLS_DC) { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(Bucket *) * src->nTableSize; for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(char) * bucketsize; if (sizeof(void *) == sizeof(zend_function)) { assert(sizeof(zend_function) == sizeof((((zend_function *) b->pData))[0])); xc_calc_zend_function( processor, ((zend_function *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_function) == sizeof((((zend_function *) b->pData))[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_function); xc_calc_zend_function( processor, ((zend_function *) b->pData) TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_calc_HashTable_zend_property_info */ static void inline xc_calc_HashTable_zend_property_info(xc_processor_t * processor, const HashTable * const src TSRMLS_DC) { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(Bucket *) * src->nTableSize; for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(char) * bucketsize; if (sizeof(void *) == sizeof(zend_property_info)) { assert(sizeof(zend_property_info) == sizeof((((zend_property_info *) b->pData))[0])); xc_calc_zend_property_info( processor, ((zend_property_info *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_property_info) == sizeof((((zend_property_info *) b->pData))[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_property_info); xc_calc_zend_property_info( processor, ((zend_property_info *) b->pData) TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } /* }}} */ #endif /* {{{ xc_calc_zval */ /* * export: void xc_calc_zval( * c_processor_t *processor, const zval * const src * SRMLS_DC ); :export */ void xc_calc_zval(xc_processor_t * processor, const zval * const src TSRMLS_DC) { /* Variable information */ switch (src->type & ~IS_CONSTANT_INDEX) { case IS_LONG: case IS_RESOURCE: case IS_BOOL: break; case IS_DOUBLE: break; case IS_NULL: break; case IS_CONSTANT: #ifdef IS_UNICODE if (UG(unicode)) { goto proc_unicode; } #endif case IS_STRING: #ifdef FLAG_IS_BC case FLAG_IS_BC: #endif if (src->value.str.val == NULL) { } else { xc_calc_string_n(processor, IS_STRING, ZSTR(src->value.str.val), src->value.str.len + 1); } break; #ifdef IS_UNICODE case IS_UNICODE: proc_unicode: #ifdef IS_UNICODE if (ZSTR_U(src->value.uni.val) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->value.uni.val, src->value.uni.len + 1); } #else if (ZSTR_S(src->value.uni.val) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->value.uni.val, src->value.uni.len + 1); } #endif break; #endif case IS_ARRAY: case IS_CONSTANT_ARRAY: if (src->value.ht) { assert(sizeof(HashTable) == sizeof((src->value.ht)[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(HashTable); xc_calc_HashTable_zval_ptr( processor, src->value.ht TSRMLS_CC ); } else { } break; case IS_OBJECT: #ifndef ZEND_ENGINE_2 if (src->value.obj.ce) { assert(sizeof(zend_class_entry) == sizeof((src->value.obj.ce)[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_class_entry); xc_calc_zend_class_entry( processor, src->value.obj.ce TSRMLS_CC ); } else { } if (src->value.obj.properties) { assert(sizeof(HashTable) == sizeof((src->value.obj.properties)[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(HashTable); xc_calc_HashTable_zval_ptr( processor, src->value.obj.properties TSRMLS_CC ); } else { } #endif break; default: assert(0); } } /* }}} */ /* {{{ xc_calc_zval_ptr */ static void inline xc_calc_zval_ptr(xc_processor_t * processor, const zval_ptr * const src TSRMLS_DC) { do { if (processor->reference) { zval_ptr *ppzv; if (zend_hash_find(&processor->zvalptrs, (char *) &src[0], sizeof(src[0]), (void **) &ppzv) == SUCCESS) { processor->have_references = 1; break; } } /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zval); if (processor->reference) { /* make dummy */ zval_ptr pzv = (zval_ptr) - 1; if (zend_hash_add(&processor->zvalptrs, (char *) &src[0], sizeof(src[0]), (void *) &pzv, sizeof(pzv), NULL) == SUCCESS) { /* first add, go on */ } else { assert(0); } } assert(sizeof(zval) == sizeof((src[0])[0])); xc_calc_zval( processor, src[0] TSRMLS_CC ); } while (0); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_calc_zend_arg_info */ static void inline xc_calc_zend_arg_info(xc_processor_t * processor, const zend_arg_info * const src TSRMLS_DC) { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->name, src->name_len + 1); } } else { if (ZSTR_S(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name, src->name_len + 1); } } #else if (ZSTR_S(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name, src->name_len + 1); } #endif #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->class_name) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->class_name, src->class_name_len + 1); } } else { if (ZSTR_S(src->class_name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->class_name, src->class_name_len + 1); } } #else if (ZSTR_S(src->class_name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->class_name, src->class_name_len + 1); } #endif } /* }}} */ #endif #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_calc_zend_constant */ static void inline xc_calc_zend_constant(xc_processor_t * processor, const zend_constant * const src TSRMLS_DC) { assert(sizeof(zval) == sizeof(src->value)); assert(sizeof(zval) == sizeof((&src->value)[0])); xc_calc_zval( processor, &src->value TSRMLS_CC ); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->name, src->name_len + 1); } } else { if (ZSTR_S(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name, src->name_len + 1); } } #else if (ZSTR_S(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name, src->name_len + 1); } #endif } /* }}} */ #endif /* {{{ xc_calc_zend_function */ /* * export: void xc_calc_zend_function( * c_processor_t *processor, const zend_function * const src * SRMLS_DC ); :export */ void xc_calc_zend_function(xc_processor_t * processor, const zend_function * const src TSRMLS_DC) { switch (src->type) { case ZEND_INTERNAL_FUNCTION: case ZEND_OVERLOADED_FUNCTION: break; case ZEND_USER_FUNCTION: case ZEND_EVAL_CODE: assert(sizeof(zend_op_array) == sizeof(src->op_array)); assert(sizeof(zend_op_array) == sizeof((&src->op_array)[0])); xc_calc_zend_op_array( processor, &src->op_array TSRMLS_CC ); break; default: assert(0); } } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_calc_zend_property_info */ static void inline xc_calc_zend_property_info(xc_processor_t * processor, const zend_property_info * const src TSRMLS_DC) { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->name, src->name_length + 1); } } else { if (ZSTR_S(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name, src->name_length + 1); } } #else if (ZSTR_S(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name, src->name_length + 1); } #endif #ifdef ZEND_ENGINE_2_1 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->doc_comment, src->doc_comment_len + 1); } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1); } #endif #endif #if defined(ZEND_ENGINE_2_2) && !defined(IS_UNICODE) if (src->ce) { } else { } #endif } /* }}} */ #endif /* {{{ xc_calc_zend_class_entry */ /* * export: void xc_calc_zend_class_entry( * c_processor_t *processor, const zend_class_entry * const src * SRMLS_DC ); :export */ void xc_calc_zend_class_entry(xc_processor_t * processor, const zend_class_entry * const src TSRMLS_DC) { processor->active_class_entry_src = src; #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->name, src->name_length + 1); } } else { if (ZSTR_S(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name, src->name_length + 1); } } #else if (ZSTR_S(src->name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name, src->name_length + 1); } #endif if (src->parent) { } else { } #ifdef ZEND_ENGINE_2 #else if (src->refcount) { assert(sizeof(int) == sizeof((src->refcount)[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(int); xc_calc_int( processor, src->refcount TSRMLS_CC ); } else { } #endif #ifdef ZEND_ENGINE_2 #endif assert(sizeof(HashTable) == sizeof(src->default_properties)); assert(sizeof(HashTable) == sizeof((&src->default_properties)[0])); xc_calc_HashTable_zval_ptr( processor, &src->default_properties TSRMLS_CC ); #ifdef ZEND_ENGINE_2 assert(sizeof(HashTable) == sizeof(src->properties_info)); assert(sizeof(HashTable) == sizeof((&src->properties_info)[0])); xc_calc_HashTable_zend_property_info( processor, &src->properties_info TSRMLS_CC ); #ifdef ZEND_ENGINE_2_1 assert(sizeof(HashTable) == sizeof(src->default_static_members)); assert(sizeof(HashTable) == sizeof((&src->default_static_members)[0])); xc_calc_HashTable_zval_ptr( processor, &src->default_static_members TSRMLS_CC ); #else if (src->static_members) { assert(sizeof(HashTable) == sizeof((src->static_members)[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(HashTable); xc_calc_HashTable_zval_ptr( processor, src->static_members TSRMLS_CC ); } else { } #endif assert(sizeof(HashTable) == sizeof(src->constants_table)); assert(sizeof(HashTable) == sizeof((&src->constants_table)[0])); xc_calc_HashTable_zval_ptr( processor, &src->constants_table TSRMLS_CC ); if (src->filename == NULL) { } else { xc_calc_string_n(processor, IS_STRING, ZSTR(src->filename), strlen(src->filename) + 1); } #ifdef ZEND_ENGINE_2_1 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->doc_comment, src->doc_comment_len + 1); } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1); } #endif #endif /* # NOT DONE */ /* deal with it inside xc_fix_method */ /* should be >5.1 */ #ifdef ZEND_ENGINE_2_1 #if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6 #endif #endif /* # NOT DONE */ #else #endif assert(sizeof(HashTable) == sizeof(src->function_table)); assert(sizeof(HashTable) == sizeof((&src->function_table)[0])); xc_calc_HashTable_zend_function( processor, &src->function_table TSRMLS_CC ); processor->active_class_entry_src = NULL; } /* }}} */ /* {{{ xc_calc_znode */ static void inline xc_calc_znode(xc_processor_t * processor, const znode * const src TSRMLS_DC) { #ifdef IS_CV #define XCACHE_IS_CV IS_CV #else /* compatible with zend optimizer */ #define XCACHE_IS_CV 16 #endif assert(src->op_type == IS_CONST || src->op_type == IS_VAR || src->op_type == XCACHE_IS_CV || src->op_type == IS_TMP_VAR || src->op_type == IS_UNUSED); #undef XCACHE_IS_CV switch (src->op_type) { case IS_CONST: assert(sizeof(zval) == sizeof(src->u.constant)); assert(sizeof(zval) == sizeof((&src->u.constant)[0])); xc_calc_zval( processor, &src->u.constant TSRMLS_CC ); break; case IS_VAR: case IS_TMP_VAR: #ifdef IS_CV case IS_CV: #else case 16: #endif break; case IS_UNUSED: #ifndef ZEND_ENGINE_2 #endif break; } } /* }}} */ /* {{{ xc_calc_zend_op */ /* * export: void xc_calc_zend_op( * c_processor_t *processor, const zend_op * const src * SRMLS_DC ); :export */ void xc_calc_zend_op(xc_processor_t * processor, const zend_op * const src TSRMLS_DC) { assert(sizeof(znode) == sizeof(src->result)); assert(sizeof(znode) == sizeof((&src->result)[0])); xc_calc_znode( processor, &src->result TSRMLS_CC ); assert(sizeof(znode) == sizeof(src->op1)); assert(sizeof(znode) == sizeof((&src->op1)[0])); xc_calc_znode( processor, &src->op1 TSRMLS_CC ); assert(sizeof(znode) == sizeof(src->op2)); assert(sizeof(znode) == sizeof((&src->op2)[0])); xc_calc_znode( processor, &src->op2 TSRMLS_CC ); #ifdef ZEND_ENGINE_2_1 /* is copying enough? */ #endif } /* }}} */ /* {{{ xc_calc_zend_op_array */ /* * export: void xc_calc_zend_op_array( * c_processor_t *processor, const zend_op_array * const src * SRMLS_DC ); :export */ void xc_calc_zend_op_array(xc_processor_t * processor, const zend_op_array * const src TSRMLS_DC) { do { zend_uint ii; int i; /* Common elements */ #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->function_name) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->function_name, xc_zstrlen_uchar(src->function_name) + 1); } } else { if (ZSTR_S(src->function_name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->function_name, xc_zstrlen_char(src->function_name) + 1); } } #else if (ZSTR_S(src->function_name) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->function_name, xc_zstrlen_char(src->function_name) + 1); } #endif #ifdef ZEND_ENGINE_2 if (src->arg_info) { /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_arg_info) * src->num_args; for (ii = 0; ii < src->num_args; ii++) { assert(sizeof(zend_arg_info) == sizeof(src->arg_info[ii])); assert(sizeof(zend_arg_info) == sizeof((&src->arg_info[ii])[0])); xc_calc_zend_arg_info( processor, &src->arg_info[ii] TSRMLS_CC ); } } else { } #else if (src->arg_types) { /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_uchar) * src->arg_types[0] + 1; } else { } #endif /* END of common elements */ #ifdef IS_UNICODE #endif if (src->refcount) { assert(sizeof(zend_uint) == sizeof((src->refcount)[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_uint); xc_calc_zend_uint( processor, src->refcount TSRMLS_CC ); } else { } if (src->opcodes) { /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_op) * src->last; for (ii = 0; ii < src->last; ii++) { assert(sizeof(zend_op) == sizeof(src->opcodes[ii])); assert(sizeof(zend_op) == sizeof((&src->opcodes[ii])[0])); xc_calc_zend_op( processor, &src->opcodes[ii] TSRMLS_CC ); } } else { } #ifdef IS_CV if (src->vars) { /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_compiled_variable) * src->last_var; for (i = 0; i < src->last_var; i++) { assert(sizeof(zend_compiled_variable) == sizeof(src->vars[i])); assert(sizeof(zend_compiled_variable) == sizeof((&src->vars[i])[0])); xc_calc_zend_compiled_variable( processor, &src->vars[i] TSRMLS_CC ); } } else { } #else #endif if (src->brk_cont_array) { /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_brk_cont_element) * src->last_brk_cont; for (ii = 0; ii < src->last_brk_cont; ii++) { assert(sizeof(zend_brk_cont_element) == sizeof(src->brk_cont_array[ii])); assert(sizeof(zend_brk_cont_element) == sizeof((&src->brk_cont_array[ii])[0])); xc_calc_zend_brk_cont_element( processor, &src->brk_cont_array[ii] TSRMLS_CC ); } } else { } #ifndef ZEND_ENGINE_2 #endif #ifdef ZEND_ENGINE_2 if (src->try_catch_array) { /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_try_catch_element) * src->last_try_catch; for (i = 0; i < src->last_try_catch; i++) { assert(sizeof(zend_try_catch_element) == sizeof(src->try_catch_array[i])); assert(sizeof(zend_try_catch_element) == sizeof((&src->try_catch_array[i])[0])); xc_calc_zend_try_catch_element( processor, &src->try_catch_array[i] TSRMLS_CC ); } } else { } #endif if (src->static_variables) { assert(sizeof(HashTable) == sizeof((src->static_variables)[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(HashTable); xc_calc_HashTable_zval_ptr( processor, src->static_variables TSRMLS_CC ); } else { } #ifdef ZEND_ENGINE_2 #endif if (src->filename == NULL) { } else { xc_calc_string_n(processor, IS_STRING, ZSTR(src->filename), strlen(src->filename) + 1); } #ifdef IS_UNICODE if (src->script_encoding == NULL) { } else { xc_calc_string_n(processor, IS_STRING, ZSTR(src->script_encoding), strlen(src->script_encoding) + 1); } #endif #ifdef ZEND_ENGINE_2 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->doc_comment, src->doc_comment_len + 1); } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1); } #endif #endif /* reserved */ #if defined(HARDENING_PATCH) && HARDENING_PATCH #endif } while (0); #ifdef ZEND_ENGINE_2 #endif #ifdef ZEND_ENGINE_2 if (src->scope) { } else { } #endif } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_calc_xc_constinfo_t */ static void inline xc_calc_xc_constinfo_t(xc_processor_t * processor, const xc_constinfo_t * const src TSRMLS_DC) { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->key, src->key_size); } } else { if (ZSTR_S(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->key, src->key_size); } } #else if (ZSTR_S(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->key, src->key_size); } #endif assert(sizeof(zend_constant) == sizeof(src->constant)); assert(sizeof(zend_constant) == sizeof((&src->constant)[0])); xc_calc_zend_constant( processor, &src->constant TSRMLS_CC ); } /* }}} */ #endif /* {{{ xc_calc_xc_funcinfo_t */ /* * export: void xc_calc_xc_funcinfo_t( * c_processor_t *processor, const xc_funcinfo_t * const src * SRMLS_DC ); :export */ void xc_calc_xc_funcinfo_t(xc_processor_t * processor, const xc_funcinfo_t * const src TSRMLS_DC) { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->key, src->key_size); } } else { if (ZSTR_S(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->key, src->key_size); } } #else if (ZSTR_S(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->key, src->key_size); } #endif assert(sizeof(zend_function) == sizeof(src->func)); assert(sizeof(zend_function) == sizeof((&src->func)[0])); xc_calc_zend_function( processor, &src->func TSRMLS_CC ); } /* }}} */ /* {{{ xc_calc_xc_classinfo_t */ /* * export: void xc_calc_xc_classinfo_t( * c_processor_t *processor, const xc_classinfo_t * const src * SRMLS_DC ); :export */ void xc_calc_xc_classinfo_t(xc_processor_t * processor, const xc_classinfo_t * const src TSRMLS_DC) { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->key, src->key_size); } } else { if (ZSTR_S(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->key, src->key_size); } } #else if (ZSTR_S(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->key, src->key_size); } #endif #ifdef ZEND_ENGINE_2 if (src->cest) { assert(sizeof(zend_class_entry) == sizeof((src->cest)[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_class_entry); xc_calc_zend_class_entry( processor, src->cest TSRMLS_CC ); } else { } #else assert(sizeof(zend_class_entry) == sizeof(src->cest)); assert(sizeof(zend_class_entry) == sizeof((&src->cest)[0])); xc_calc_zend_class_entry( processor, &src->cest TSRMLS_CC ); #endif } /* }}} */ #ifdef ZEND_ENGINE_2_1 /* {{{ xc_calc_xc_autoglobal_t */ static void inline xc_calc_xc_autoglobal_t(xc_processor_t * processor, const xc_autoglobal_t * const src TSRMLS_DC) { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->key, src->key_len + 1); } } else { if (ZSTR_S(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->key, src->key_len + 1); } } #else if (ZSTR_S(src->key) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->key, src->key_len + 1); } #endif } /* }}} */ #endif /* {{{ xc_calc_xc_entry_data_php_t */ static void inline xc_calc_xc_entry_data_php_t(xc_processor_t * processor, const xc_entry_data_php_t * const src TSRMLS_DC) { zend_uint i; #ifdef HAVE_INODE #endif if (src->op_array) { assert(sizeof(zend_op_array) == sizeof((src->op_array)[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(zend_op_array); xc_calc_zend_op_array( processor, src->op_array TSRMLS_CC ); } else { } #ifdef HAVE_XCACHE_CONSTANT if (src->constinfos) { /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(xc_constinfo_t) * src->constinfo_cnt; for (i = 0; i < src->constinfo_cnt; i++) { assert(sizeof(xc_constinfo_t) == sizeof(src->constinfos[i])); assert(sizeof(xc_constinfo_t) == sizeof((&src->constinfos[i])[0])); xc_calc_xc_constinfo_t( processor, &src->constinfos[i] TSRMLS_CC ); } } else { } #endif if (src->funcinfos) { /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(xc_funcinfo_t) * src->funcinfo_cnt; for (i = 0; i < src->funcinfo_cnt; i++) { assert(sizeof(xc_funcinfo_t) == sizeof(src->funcinfos[i])); assert(sizeof(xc_funcinfo_t) == sizeof((&src->funcinfos[i])[0])); xc_calc_xc_funcinfo_t( processor, &src->funcinfos[i] TSRMLS_CC ); } } else { } if (src->classinfos) { /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(xc_classinfo_t) * src->classinfo_cnt; for (i = 0; i < src->classinfo_cnt; i++) { assert(sizeof(xc_classinfo_t) == sizeof(src->classinfos[i])); assert(sizeof(xc_classinfo_t) == sizeof((&src->classinfos[i])[0])); xc_calc_xc_classinfo_t( processor, &src->classinfos[i] TSRMLS_CC ); } } else { } #ifdef ZEND_ENGINE_2_1 if (src->autoglobals) { /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(xc_autoglobal_t) * src->autoglobal_cnt; for (i = 0; i < src->autoglobal_cnt; i++) { assert(sizeof(xc_autoglobal_t) == sizeof(src->autoglobals[i])); assert(sizeof(xc_autoglobal_t) == sizeof((&src->autoglobals[i])[0])); xc_calc_xc_autoglobal_t( processor, &src->autoglobals[i] TSRMLS_CC ); } } else { } #endif } /* }}} */ /* {{{ xc_calc_xc_entry_data_var_t */ static void inline xc_calc_xc_entry_data_var_t(xc_processor_t * processor, const xc_entry_data_var_t * const src TSRMLS_DC) { assert(sizeof(zval_ptr) == sizeof((&src->value)[0])); xc_calc_zval_ptr( processor, &src->value TSRMLS_CC ); } /* }}} */ /* {{{ xc_calc_xc_entry_t */ /* * export: void xc_calc_xc_entry_t( * c_processor_t *processor, const xc_entry_t * const src * SRMLS_DC ); :export */ void xc_calc_xc_entry_t(xc_processor_t * processor, const xc_entry_t * const src TSRMLS_DC) { /* skip */ #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->name_type == IS_UNICODE) { } else { } #else #endif #ifdef IS_UNICODE #ifdef IS_UNICODE if (src->name_type == IS_UNICODE) { if (ZSTR_U(src->name.uni.val) == NULL) { } else { xc_calc_string_n(processor, IS_UNICODE, src->name.uni.val, src->name.uni.len + 1); } } else { if (ZSTR_S(src->name.uni.val) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name.uni.val, src->name.uni.len + 1); } } #else if (ZSTR_S(src->name.uni.val) == NULL) { } else { xc_calc_string_n(processor, IS_STRING, src->name.uni.val, src->name.uni.len + 1); } #endif #else if (src->name.str.val == NULL) { } else { xc_calc_string_n(processor, IS_STRING, ZSTR(src->name.str.val), src->name.str.len + 1); } #endif switch (src->type) { case XC_TYPE_PHP: if (src->data.php) { assert(sizeof(xc_entry_data_php_t) == sizeof((src->data.php)[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(xc_entry_data_php_t); xc_calc_xc_entry_data_php_t( processor, src->data.php TSRMLS_CC ); } else { } break; case XC_TYPE_VAR: if (src->data.var) { assert(sizeof(xc_entry_data_var_t) == sizeof((src->data.var)[0])); /* allocate */ processor->size = (size_t) ALIGN(processor->size); processor->size += sizeof(xc_entry_data_var_t); xc_calc_xc_entry_data_var_t( processor, src->data.var TSRMLS_CC ); } else { } break; default: assert(0); } } /* }}} */ /* {{{ Pre-declare */ void xc_store_zval(xc_processor_t * processor, zval * dst, const zval * const src TSRMLS_DC); static void inline xc_store_zval_ptr(xc_processor_t * processor, zval_ptr * dst, const zval_ptr * const src TSRMLS_DC); void xc_store_zend_op_array(xc_processor_t * processor, zend_op_array * dst, const zend_op_array * const src TSRMLS_DC); void xc_store_zend_class_entry(xc_processor_t * processor, zend_class_entry * dst, const zend_class_entry * const src TSRMLS_DC); #ifdef HAVE_XCACHE_CONSTANT static void inline xc_store_zend_constant(xc_processor_t * processor, zend_constant * dst, const zend_constant * const src TSRMLS_DC); #endif void xc_store_zend_function(xc_processor_t * processor, zend_function * dst, const zend_function * const src TSRMLS_DC); void xc_store_xc_entry_t(xc_processor_t * processor, xc_entry_t * dst, const xc_entry_t * const src TSRMLS_DC); #ifdef ZEND_ENGINE_2 static void inline xc_store_zend_property_info(xc_processor_t * processor, zend_property_info * dst, const zend_property_info * const src TSRMLS_DC); #endif /* }}} */ #ifdef IS_CV /* {{{ xc_store_zend_compiled_variable */ static void inline xc_store_zend_compiled_variable(xc_processor_t * processor, zend_compiled_variable * dst, const zend_compiled_variable * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_compiled_variable)); do { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { ZSTR_U(dst->name) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->name, src->name_len + 1)); ZSTR_U(dst->name) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->name)); } } else { if (ZSTR_S(src->name) == NULL) { } else { ZSTR_S(dst->name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name, src->name_len + 1)); ZSTR_S(dst->name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name)); } } #else if (ZSTR_S(src->name) == NULL) { } else { ZSTR_S(dst->name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name, src->name_len + 1)); ZSTR_S(dst->name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name)); } #endif } while (0); } /* }}} */ #endif /* {{{ xc_store_zend_uint */ static void inline xc_store_zend_uint(xc_processor_t * processor, zend_uint * dst, const zend_uint * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_uint)); do { dst[0] = src[0]; } while (0); } /* }}} */ #ifndef ZEND_ENGINE_2 /* {{{ xc_store_int */ static void inline xc_store_int(xc_processor_t * processor, int *dst, const int *const src TSRMLS_DC) { memcpy(dst, src, sizeof(int)); do { *dst = *src; } while (0); } /* }}} */ #endif #ifdef ZEND_ENGINE_2 /* {{{ xc_store_zend_try_catch_element */ static void inline xc_store_zend_try_catch_element(xc_processor_t * processor, zend_try_catch_element * dst, const zend_try_catch_element * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_try_catch_element)); do { } while (0); } /* }}} */ #endif /* ifdef ZEND_ENGINE_2 */ /* {{{ xc_store_zend_brk_cont_element */ static void inline xc_store_zend_brk_cont_element(xc_processor_t * processor, zend_brk_cont_element * dst, const zend_brk_cont_element * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_brk_cont_element)); do { #ifdef ZEND_ENGINE_2_2 #ifndef IS_UNICODE #endif #endif } while (0); } /* }}} */ /* {{{ xc_store_HashTable_zval_ptr */ static void inline xc_store_HashTable_zval_ptr(xc_processor_t * processor, HashTable * dst, const HashTable * const src TSRMLS_DC) { memcpy(dst, src, sizeof(HashTable)); do { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; uint n; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif dst->pInternalPointer = NULL; /* Used for element traversal */ dst->pListHead = NULL; /* allocate */ dst->arBuckets = (Bucket * *) (processor->p = (char *) ALIGN(processor->p)); memset(dst->arBuckets, 0, sizeof(Bucket *) * src->nTableSize); processor->p += sizeof(Bucket *) * src->nTableSize; for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ pnew = (Bucket *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(char) * bucketsize; memcpy(pnew, b, bucketsize); n = b->h & src->nTableMask; /* pnew into hash node chain */ pnew->pLast = NULL; if (dst->arBuckets[n]) { pnew->pNext = dst->arBuckets[n]; pnew->pNext->pLast = pnew; } else { pnew->pNext = NULL; } dst->arBuckets[n] = pnew; if (sizeof(void *) == sizeof(zval_ptr)) { pnew->pData = &pnew->pDataPtr; assert(sizeof(zval_ptr) == sizeof((((zval_ptr *) b->pData))[0])); xc_store_zval_ptr( processor, pnew->pData, ((zval_ptr *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zval_ptr) == sizeof((((zval_ptr *) b->pData))[0])); /* allocate */ pnew->pData = (zval_ptr *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zval_ptr); xc_store_zval_ptr( processor, pnew->pData, ((zval_ptr *) b->pData) TSRMLS_CC ); pnew->pData = (zval_ptr *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) pnew->pData); pnew->pDataPtr = NULL; } if (first) { dst->pListHead = pnew; first = 0; } /* flat link */ pnew->pListLast = prev; pnew->pListNext = NULL; if (prev) { prev->pListNext = pnew; } prev = pnew; } dst->pListTail = pnew; dst->pDestructor = src->pDestructor; #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } while (0); } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_store_HashTable_zend_constant */ static void inline xc_store_HashTable_zend_constant(xc_processor_t * processor, HashTable * dst, const HashTable * const src TSRMLS_DC) { memcpy(dst, src, sizeof(HashTable)); do { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; uint n; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif dst->pInternalPointer = NULL; /* Used for element traversal */ dst->pListHead = NULL; /* allocate */ dst->arBuckets = (Bucket * *) (processor->p = (char *) ALIGN(processor->p)); memset(dst->arBuckets, 0, sizeof(Bucket *) * src->nTableSize); processor->p += sizeof(Bucket *) * src->nTableSize; for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ pnew = (Bucket *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(char) * bucketsize; memcpy(pnew, b, bucketsize); n = b->h & src->nTableMask; /* pnew into hash node chain */ pnew->pLast = NULL; if (dst->arBuckets[n]) { pnew->pNext = dst->arBuckets[n]; pnew->pNext->pLast = pnew; } else { pnew->pNext = NULL; } dst->arBuckets[n] = pnew; if (sizeof(void *) == sizeof(zend_constant)) { pnew->pData = &pnew->pDataPtr; assert(sizeof(zend_constant) == sizeof((((zend_constant *) b->pData))[0])); xc_store_zend_constant( processor, pnew->pData, ((zend_constant *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_constant) == sizeof((((zend_constant *) b->pData))[0])); /* allocate */ pnew->pData = (zend_constant *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_constant); xc_store_zend_constant( processor, pnew->pData, ((zend_constant *) b->pData) TSRMLS_CC ); pnew->pData = (zend_constant *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) pnew->pData); pnew->pDataPtr = NULL; } if (first) { dst->pListHead = pnew; first = 0; } /* flat link */ pnew->pListLast = prev; pnew->pListNext = NULL; if (prev) { prev->pListNext = pnew; } prev = pnew; } dst->pListTail = pnew; dst->pDestructor = src->pDestructor; #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } while (0); } /* }}} */ #endif /* {{{ xc_store_HashTable_zend_function */ /* * export: void xc_store_HashTable_zend_function( * c_processor_t *processor, HashTable *dst, const HashTable * const src * SRMLS_DC ); :export */ void xc_store_HashTable_zend_function(xc_processor_t * processor, HashTable * dst, const HashTable * const src TSRMLS_DC) { memcpy(dst, src, sizeof(HashTable)); do { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; uint n; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif dst->pInternalPointer = NULL; /* Used for element traversal */ dst->pListHead = NULL; /* allocate */ dst->arBuckets = (Bucket * *) (processor->p = (char *) ALIGN(processor->p)); memset(dst->arBuckets, 0, sizeof(Bucket *) * src->nTableSize); processor->p += sizeof(Bucket *) * src->nTableSize; for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ pnew = (Bucket *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(char) * bucketsize; memcpy(pnew, b, bucketsize); n = b->h & src->nTableMask; /* pnew into hash node chain */ pnew->pLast = NULL; if (dst->arBuckets[n]) { pnew->pNext = dst->arBuckets[n]; pnew->pNext->pLast = pnew; } else { pnew->pNext = NULL; } dst->arBuckets[n] = pnew; if (sizeof(void *) == sizeof(zend_function)) { pnew->pData = &pnew->pDataPtr; assert(sizeof(zend_function) == sizeof((((zend_function *) b->pData))[0])); xc_store_zend_function( processor, pnew->pData, ((zend_function *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_function) == sizeof((((zend_function *) b->pData))[0])); /* allocate */ pnew->pData = (zend_function *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_function); xc_store_zend_function( processor, pnew->pData, ((zend_function *) b->pData) TSRMLS_CC ); pnew->pData = (zend_function *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) pnew->pData); pnew->pDataPtr = NULL; } if (first) { dst->pListHead = pnew; first = 0; } /* flat link */ pnew->pListLast = prev; pnew->pListNext = NULL; if (prev) { prev->pListNext = pnew; } prev = pnew; } dst->pListTail = pnew; dst->pDestructor = src->pDestructor; #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } while (0); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_store_HashTable_zend_property_info */ static void inline xc_store_HashTable_zend_property_info(xc_processor_t * processor, HashTable * dst, const HashTable * const src TSRMLS_DC) { memcpy(dst, src, sizeof(HashTable)); do { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; uint n; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif dst->pInternalPointer = NULL; /* Used for element traversal */ dst->pListHead = NULL; /* allocate */ dst->arBuckets = (Bucket * *) (processor->p = (char *) ALIGN(processor->p)); memset(dst->arBuckets, 0, sizeof(Bucket *) * src->nTableSize); processor->p += sizeof(Bucket *) * src->nTableSize; for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ pnew = (Bucket *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(char) * bucketsize; memcpy(pnew, b, bucketsize); n = b->h & src->nTableMask; /* pnew into hash node chain */ pnew->pLast = NULL; if (dst->arBuckets[n]) { pnew->pNext = dst->arBuckets[n]; pnew->pNext->pLast = pnew; } else { pnew->pNext = NULL; } dst->arBuckets[n] = pnew; if (sizeof(void *) == sizeof(zend_property_info)) { pnew->pData = &pnew->pDataPtr; assert(sizeof(zend_property_info) == sizeof((((zend_property_info *) b->pData))[0])); xc_store_zend_property_info( processor, pnew->pData, ((zend_property_info *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_property_info) == sizeof((((zend_property_info *) b->pData))[0])); /* allocate */ pnew->pData = (zend_property_info *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_property_info); xc_store_zend_property_info( processor, pnew->pData, ((zend_property_info *) b->pData) TSRMLS_CC ); pnew->pData = (zend_property_info *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) pnew->pData); pnew->pDataPtr = NULL; } if (first) { dst->pListHead = pnew; first = 0; } /* flat link */ pnew->pListLast = prev; pnew->pListNext = NULL; if (prev) { prev->pListNext = pnew; } prev = pnew; } dst->pListTail = pnew; dst->pDestructor = src->pDestructor; #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } while (0); } /* }}} */ #endif /* {{{ xc_store_zval */ /* * export: void xc_store_zval( * c_processor_t *processor, zval *dst, const zval * const src * SRMLS_DC ); :export */ void xc_store_zval(xc_processor_t * processor, zval * dst, const zval * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zval)); do { /* Variable information */ switch (src->type & ~IS_CONSTANT_INDEX) { case IS_LONG: case IS_RESOURCE: case IS_BOOL: break; case IS_DOUBLE: break; case IS_NULL: break; case IS_CONSTANT: #ifdef IS_UNICODE if (UG(unicode)) { goto proc_unicode; } #endif case IS_STRING: #ifdef FLAG_IS_BC case FLAG_IS_BC: #endif if (src->value.str.val == NULL) { } else { dst->value.str.val = ZSTR_S(xc_store_string_n(processor, IS_STRING, ZSTR(src->value.str.val), src->value.str.len + 1)); dst->value.str.val = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->value.str.val); } break; #ifdef IS_UNICODE case IS_UNICODE: proc_unicode: #ifdef IS_UNICODE if (ZSTR_U(src->value.uni.val) == NULL) { } else { ZSTR_U(dst->value.uni.val) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->value.uni.val, src->value.uni.len + 1)); ZSTR_U(dst->value.uni.val) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->value.uni.val)); } #else if (ZSTR_S(src->value.uni.val) == NULL) { } else { ZSTR_S(dst->value.uni.val) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->value.uni.val, src->value.uni.len + 1)); ZSTR_S(dst->value.uni.val) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->value.uni.val)); } #endif break; #endif case IS_ARRAY: case IS_CONSTANT_ARRAY: if (src->value.ht) { assert(sizeof(HashTable) == sizeof((src->value.ht)[0])); /* allocate */ dst->value.ht = (HashTable *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(HashTable); xc_store_HashTable_zval_ptr( processor, dst->value.ht, src->value.ht TSRMLS_CC ); dst->value.ht = (HashTable *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->value.ht); } else { } break; case IS_OBJECT: #ifndef ZEND_ENGINE_2 if (src->value.obj.ce) { assert(sizeof(zend_class_entry) == sizeof((src->value.obj.ce)[0])); /* allocate */ dst->value.obj.ce = (zend_class_entry *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_class_entry); xc_store_zend_class_entry( processor, dst->value.obj.ce, src->value.obj.ce TSRMLS_CC ); dst->value.obj.ce = (zend_class_entry *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->value.obj.ce); } else { } if (src->value.obj.properties) { assert(sizeof(HashTable) == sizeof((src->value.obj.properties)[0])); /* allocate */ dst->value.obj.properties = (HashTable *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(HashTable); xc_store_HashTable_zval_ptr( processor, dst->value.obj.properties, src->value.obj.properties TSRMLS_CC ); dst->value.obj.properties = (HashTable *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->value.obj.properties); } else { } #endif break; default: assert(0); } } while (0); } /* }}} */ /* {{{ xc_store_zval_ptr */ static void inline xc_store_zval_ptr(xc_processor_t * processor, zval_ptr * dst, const zval_ptr * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zval_ptr)); do { do { if (processor->reference) { zval_ptr *ppzv; if (zend_hash_find(&processor->zvalptrs, (char *) &src[0], sizeof(src[0]), (void **) &ppzv) == SUCCESS) { dst[0] = *ppzv; /* *dst is updated */ processor->have_references = 1; assert(xc_is_shm(dst[0])); break; } } /* allocate */ dst[0] = (zval *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zval); if (processor->reference) { zval_ptr pzv = dst[0]; pzv = (zval *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) pzv); if (zend_hash_add(&processor->zvalptrs, (char *) &src[0], sizeof(src[0]), (void *) &pzv, sizeof(pzv), NULL) == SUCCESS) { /* first add, go on */ } else { assert(0); } } assert(sizeof(zval) == sizeof((src[0])[0])); xc_store_zval( processor, dst[0], src[0] TSRMLS_CC ); dst[0] = (zval *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst[0]); } while (0); } while (0); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_store_zend_arg_info */ static void inline xc_store_zend_arg_info(xc_processor_t * processor, zend_arg_info * dst, const zend_arg_info * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_arg_info)); do { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { ZSTR_U(dst->name) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->name, src->name_len + 1)); ZSTR_U(dst->name) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->name)); } } else { if (ZSTR_S(src->name) == NULL) { } else { ZSTR_S(dst->name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name, src->name_len + 1)); ZSTR_S(dst->name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name)); } } #else if (ZSTR_S(src->name) == NULL) { } else { ZSTR_S(dst->name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name, src->name_len + 1)); ZSTR_S(dst->name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name)); } #endif #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->class_name) == NULL) { } else { ZSTR_U(dst->class_name) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->class_name, src->class_name_len + 1)); ZSTR_U(dst->class_name) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->class_name)); } } else { if (ZSTR_S(src->class_name) == NULL) { } else { ZSTR_S(dst->class_name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->class_name, src->class_name_len + 1)); ZSTR_S(dst->class_name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->class_name)); } } #else if (ZSTR_S(src->class_name) == NULL) { } else { ZSTR_S(dst->class_name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->class_name, src->class_name_len + 1)); ZSTR_S(dst->class_name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->class_name)); } #endif } while (0); } /* }}} */ #endif #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_store_zend_constant */ static void inline xc_store_zend_constant(xc_processor_t * processor, zend_constant * dst, const zend_constant * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_constant)); do { assert(sizeof(zval) == sizeof(src->value)); assert(sizeof(zval) == sizeof((&src->value)[0])); xc_store_zval( processor, &dst->value, &src->value TSRMLS_CC ); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { ZSTR_U(dst->name) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->name, src->name_len + 1)); ZSTR_U(dst->name) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->name)); } } else { if (ZSTR_S(src->name) == NULL) { } else { ZSTR_S(dst->name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name, src->name_len + 1)); ZSTR_S(dst->name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name)); } } #else if (ZSTR_S(src->name) == NULL) { } else { ZSTR_S(dst->name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name, src->name_len + 1)); ZSTR_S(dst->name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name)); } #endif } while (0); } /* }}} */ #endif /* {{{ xc_store_zend_function */ /* * export: void xc_store_zend_function( * c_processor_t *processor, zend_function *dst, const zend_function * const * src TSRMLS_DC * ); :export */ void xc_store_zend_function(xc_processor_t * processor, zend_function * dst, const zend_function * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_function)); do { switch (src->type) { case ZEND_INTERNAL_FUNCTION: case ZEND_OVERLOADED_FUNCTION: break; case ZEND_USER_FUNCTION: case ZEND_EVAL_CODE: assert(sizeof(zend_op_array) == sizeof(src->op_array)); assert(sizeof(zend_op_array) == sizeof((&src->op_array)[0])); xc_store_zend_op_array( processor, &dst->op_array, &src->op_array TSRMLS_CC ); break; default: assert(0); } } while (0); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_store_zend_property_info */ static void inline xc_store_zend_property_info(xc_processor_t * processor, zend_property_info * dst, const zend_property_info * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_property_info)); do { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { ZSTR_U(dst->name) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->name, src->name_length + 1)); ZSTR_U(dst->name) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->name)); } } else { if (ZSTR_S(src->name) == NULL) { } else { ZSTR_S(dst->name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name, src->name_length + 1)); ZSTR_S(dst->name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name)); } } #else if (ZSTR_S(src->name) == NULL) { } else { ZSTR_S(dst->name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name, src->name_length + 1)); ZSTR_S(dst->name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name)); } #endif #ifdef ZEND_ENGINE_2_1 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { ZSTR_U(dst->doc_comment) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->doc_comment, src->doc_comment_len + 1)); ZSTR_U(dst->doc_comment) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->doc_comment)); } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { ZSTR_S(dst->doc_comment) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1)); ZSTR_S(dst->doc_comment) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->doc_comment)); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { ZSTR_S(dst->doc_comment) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1)); ZSTR_S(dst->doc_comment) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->doc_comment)); } #endif #endif #if defined(ZEND_ENGINE_2_2) && !defined(IS_UNICODE) if (src->ce) { dst->ce = (zend_class_entry *) xc_get_class_num(processor, src->ce); } else { } #endif } while (0); } /* }}} */ #endif /* {{{ xc_store_zend_class_entry */ /* * export: void xc_store_zend_class_entry( * c_processor_t *processor, zend_class_entry *dst, const zend_class_entry * * const src * _DC ); :export */ void xc_store_zend_class_entry(xc_processor_t * processor, zend_class_entry * dst, const zend_class_entry * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_class_entry)); do { processor->active_class_entry_src = src; processor->active_class_entry_dst = dst; #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { ZSTR_U(dst->name) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->name, src->name_length + 1)); ZSTR_U(dst->name) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->name)); } } else { if (ZSTR_S(src->name) == NULL) { } else { ZSTR_S(dst->name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name, src->name_length + 1)); ZSTR_S(dst->name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name)); } } #else if (ZSTR_S(src->name) == NULL) { } else { ZSTR_S(dst->name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name, src->name_length + 1)); ZSTR_S(dst->name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name)); } #endif if (src->parent) { dst->parent = (zend_class_entry *) xc_get_class_num(processor, src->parent); } else { } #ifdef ZEND_ENGINE_2 #else if (src->refcount) { assert(sizeof(int) == sizeof((src->refcount)[0])); /* allocate */ dst->refcount = (int *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(int); xc_store_int( processor, dst->refcount, src->refcount TSRMLS_CC ); dst->refcount = (int *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->refcount); } else { } #endif #ifdef ZEND_ENGINE_2 #endif assert(sizeof(HashTable) == sizeof(src->default_properties)); assert(sizeof(HashTable) == sizeof((&src->default_properties)[0])); xc_store_HashTable_zval_ptr( processor, &dst->default_properties, &src->default_properties TSRMLS_CC ); dst->builtin_functions = src->builtin_functions; #ifdef ZEND_ENGINE_2 assert(sizeof(HashTable) == sizeof(src->properties_info)); assert(sizeof(HashTable) == sizeof((&src->properties_info)[0])); xc_store_HashTable_zend_property_info( processor, &dst->properties_info, &src->properties_info TSRMLS_CC ); #ifdef ZEND_ENGINE_2_1 assert(sizeof(HashTable) == sizeof(src->default_static_members)); assert(sizeof(HashTable) == sizeof((&src->default_static_members)[0])); xc_store_HashTable_zval_ptr( processor, &dst->default_static_members, &src->default_static_members TSRMLS_CC ); dst->static_members = &dst->default_static_members; #else if (src->static_members) { assert(sizeof(HashTable) == sizeof((src->static_members)[0])); /* allocate */ dst->static_members = (HashTable *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(HashTable); xc_store_HashTable_zval_ptr( processor, dst->static_members, src->static_members TSRMLS_CC ); dst->static_members = (HashTable *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->static_members); } else { } #endif assert(sizeof(HashTable) == sizeof(src->constants_table)); assert(sizeof(HashTable) == sizeof((&src->constants_table)[0])); xc_store_HashTable_zval_ptr( processor, &dst->constants_table, &src->constants_table TSRMLS_CC ); if (src->filename == NULL) { } else { dst->filename = ZSTR_S(xc_store_string_n(processor, IS_STRING, ZSTR(src->filename), strlen(src->filename) + 1)); dst->filename = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->filename); } #ifdef ZEND_ENGINE_2_1 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { ZSTR_U(dst->doc_comment) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->doc_comment, src->doc_comment_len + 1)); ZSTR_U(dst->doc_comment) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->doc_comment)); } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { ZSTR_S(dst->doc_comment) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1)); ZSTR_S(dst->doc_comment) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->doc_comment)); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { ZSTR_S(dst->doc_comment) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1)); ZSTR_S(dst->doc_comment) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->doc_comment)); } #endif #endif /* # NOT DONE */ /* deal with it inside xc_fix_method */ dst->constructor = NULL; /* should be >5.1 */ #ifdef ZEND_ENGINE_2_1 #if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6 #endif #endif /* # NOT DONE */ #else #endif assert(sizeof(HashTable) == sizeof(src->function_table)); assert(sizeof(HashTable) == sizeof((&src->function_table)[0])); xc_store_HashTable_zend_function( processor, &dst->function_table, &src->function_table TSRMLS_CC ); processor->active_class_entry_src = NULL; processor->active_class_entry_dst = NULL; } while (0); } /* }}} */ /* {{{ xc_store_znode */ static void inline xc_store_znode(xc_processor_t * processor, znode * dst, const znode * const src TSRMLS_DC) { memcpy(dst, src, sizeof(znode)); do { #ifdef IS_CV #define XCACHE_IS_CV IS_CV #else /* compatible with zend optimizer */ #define XCACHE_IS_CV 16 #endif assert(src->op_type == IS_CONST || src->op_type == IS_VAR || src->op_type == XCACHE_IS_CV || src->op_type == IS_TMP_VAR || src->op_type == IS_UNUSED); #undef XCACHE_IS_CV switch (src->op_type) { case IS_CONST: assert(sizeof(zval) == sizeof(src->u.constant)); assert(sizeof(zval) == sizeof((&src->u.constant)[0])); xc_store_zval( processor, &dst->u.constant, &src->u.constant TSRMLS_CC ); break; } } while (0); } /* }}} */ /* {{{ xc_store_zend_op */ /* * export: void xc_store_zend_op( * c_processor_t *processor, zend_op *dst, const zend_op * const src * SRMLS_DC ); :export */ void xc_store_zend_op(xc_processor_t * processor, zend_op * dst, const zend_op * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_op)); do { assert(sizeof(znode) == sizeof(src->result)); assert(sizeof(znode) == sizeof((&src->result)[0])); xc_store_znode( processor, &dst->result, &src->result TSRMLS_CC ); assert(sizeof(znode) == sizeof(src->op1)); assert(sizeof(znode) == sizeof((&src->op1)[0])); xc_store_znode( processor, &dst->op1, &src->op1 TSRMLS_CC ); assert(sizeof(znode) == sizeof(src->op2)); assert(sizeof(znode) == sizeof((&src->op2)[0])); xc_store_znode( processor, &dst->op2, &src->op2 TSRMLS_CC ); #ifdef ZEND_ENGINE_2_1 switch (src->opcode) { case ZEND_JMP: dst->op1.u.jmp_addr = processor->active_opcodes_dst + (src->op1.u.jmp_addr - processor->active_opcodes_src); break; case ZEND_JMPZ: case ZEND_JMPNZ: case ZEND_JMPZ_EX: case ZEND_JMPNZ_EX: dst->op2.u.jmp_addr = processor->active_opcodes_dst + (src->op2.u.jmp_addr - processor->active_opcodes_src); break; default: break; } /* is copying enough? */ #endif } while (0); } /* }}} */ /* {{{ xc_store_zend_op_array */ /* * export: void xc_store_zend_op_array( * c_processor_t *processor, zend_op_array *dst, const zend_op_array * const * src TSRMLS_DC * ); :export */ void xc_store_zend_op_array(xc_processor_t * processor, zend_op_array * dst, const zend_op_array * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_op_array)); do { do { zend_uint ii; int i; /* Common elements */ #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->function_name) == NULL) { } else { ZSTR_U(dst->function_name) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->function_name, xc_zstrlen_uchar(src->function_name) + 1)); ZSTR_U(dst->function_name) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->function_name)); } } else { if (ZSTR_S(src->function_name) == NULL) { } else { ZSTR_S(dst->function_name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->function_name, xc_zstrlen_char(src->function_name) + 1)); ZSTR_S(dst->function_name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->function_name)); } } #else if (ZSTR_S(src->function_name) == NULL) { } else { ZSTR_S(dst->function_name) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->function_name, xc_zstrlen_char(src->function_name) + 1)); ZSTR_S(dst->function_name) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->function_name)); } #endif #ifdef ZEND_ENGINE_2 if (src->arg_info) { /* allocate */ dst->arg_info = (zend_arg_info *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_arg_info) * src->num_args; for (ii = 0; ii < src->num_args; ii++) { assert(sizeof(zend_arg_info) == sizeof(src->arg_info[ii])); assert(sizeof(zend_arg_info) == sizeof((&src->arg_info[ii])[0])); xc_store_zend_arg_info( processor, &dst->arg_info[ii], &src->arg_info[ii] TSRMLS_CC ); } } else { } #else if (src->arg_types) { /* allocate */ dst->arg_types = (zend_uchar *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_uchar) * src->arg_types[0] + 1; memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0] + 1)); } else { } #endif /* END of common elements */ #ifdef IS_UNICODE #endif if (src->refcount) { assert(sizeof(zend_uint) == sizeof((src->refcount)[0])); /* allocate */ dst->refcount = (zend_uint *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_uint); xc_store_zend_uint( processor, dst->refcount, src->refcount TSRMLS_CC ); dst->refcount = (zend_uint *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->refcount); } else { } dst->refcount = (zend_uint *) processor->xce_src->cache->shm->handlers->to_readwrite(processor->xce_src->cache->shm, (char *) dst->refcount); dst->refcount[0] = 1; if (src->opcodes) { /* allocate */ dst->opcodes = (zend_op *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_op) * src->last; processor->active_opcodes_dst = dst->opcodes; processor->active_opcodes_src = src->opcodes; for (ii = 0; ii < src->last; ii++) { assert(sizeof(zend_op) == sizeof(src->opcodes[ii])); assert(sizeof(zend_op) == sizeof((&src->opcodes[ii])[0])); xc_store_zend_op( processor, &dst->opcodes[ii], &src->opcodes[ii] TSRMLS_CC ); } } else { processor->active_opcodes_dst = dst->opcodes; processor->active_opcodes_src = src->opcodes; } dst->size = src->last; #ifdef IS_CV if (src->vars) { /* allocate */ dst->vars = (zend_compiled_variable *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_compiled_variable) * src->last_var; for (i = 0; i < src->last_var; i++) { assert(sizeof(zend_compiled_variable) == sizeof(src->vars[i])); assert(sizeof(zend_compiled_variable) == sizeof((&src->vars[i])[0])); xc_store_zend_compiled_variable( processor, &dst->vars[i], &src->vars[i] TSRMLS_CC ); } } else { } dst->size_var = src->last_var; #else #endif if (src->brk_cont_array) { /* allocate */ dst->brk_cont_array = (zend_brk_cont_element *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_brk_cont_element) * src->last_brk_cont; for (ii = 0; ii < src->last_brk_cont; ii++) { assert(sizeof(zend_brk_cont_element) == sizeof(src->brk_cont_array[ii])); assert(sizeof(zend_brk_cont_element) == sizeof((&src->brk_cont_array[ii])[0])); xc_store_zend_brk_cont_element( processor, &dst->brk_cont_array[ii], &src->brk_cont_array[ii] TSRMLS_CC ); } } else { } #ifndef ZEND_ENGINE_2 #endif #ifdef ZEND_ENGINE_2 if (src->try_catch_array) { /* allocate */ dst->try_catch_array = (zend_try_catch_element *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_try_catch_element) * src->last_try_catch; for (i = 0; i < src->last_try_catch; i++) { assert(sizeof(zend_try_catch_element) == sizeof(src->try_catch_array[i])); assert(sizeof(zend_try_catch_element) == sizeof((&src->try_catch_array[i])[0])); xc_store_zend_try_catch_element( processor, &dst->try_catch_array[i], &src->try_catch_array[i] TSRMLS_CC ); } } else { } #endif if (src->static_variables) { assert(sizeof(HashTable) == sizeof((src->static_variables)[0])); /* allocate */ dst->static_variables = (HashTable *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(HashTable); xc_store_HashTable_zval_ptr( processor, dst->static_variables, src->static_variables TSRMLS_CC ); dst->static_variables = (HashTable *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->static_variables); } else { } #ifdef ZEND_ENGINE_2 #endif if (src->filename == NULL) { } else { dst->filename = ZSTR_S(xc_store_string_n(processor, IS_STRING, ZSTR(src->filename), strlen(src->filename) + 1)); dst->filename = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->filename); } #ifdef IS_UNICODE if (src->script_encoding == NULL) { } else { dst->script_encoding = ZSTR_S(xc_store_string_n(processor, IS_STRING, ZSTR(src->script_encoding), strlen(src->script_encoding) + 1)); dst->script_encoding = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->script_encoding); } #endif #ifdef ZEND_ENGINE_2 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { ZSTR_U(dst->doc_comment) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->doc_comment, src->doc_comment_len + 1)); ZSTR_U(dst->doc_comment) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->doc_comment)); } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { ZSTR_S(dst->doc_comment) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1)); ZSTR_S(dst->doc_comment) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->doc_comment)); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { ZSTR_S(dst->doc_comment) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->doc_comment, src->doc_comment_len + 1)); ZSTR_S(dst->doc_comment) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->doc_comment)); } #endif #endif /* reserved */ #if defined(HARDENING_PATCH) && HARDENING_PATCH #endif } while (0); #ifdef ZEND_ENGINE_2 dst->prototype = (processor->active_class_entry_src && src->prototype) ? (zend_function *) - 1 : NULL; #endif #ifdef ZEND_ENGINE_2 if (src->scope) { dst->scope = (zend_class_entry *) xc_get_class_num(processor, src->scope); } else { } #endif } while (0); } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_store_xc_constinfo_t */ static void inline xc_store_xc_constinfo_t(xc_processor_t * processor, xc_constinfo_t * dst, const xc_constinfo_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_constinfo_t)); do { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { ZSTR_U(dst->key) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->key, src->key_size)); ZSTR_U(dst->key) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->key)); } } else { if (ZSTR_S(src->key) == NULL) { } else { ZSTR_S(dst->key) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->key, src->key_size)); ZSTR_S(dst->key) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->key)); } } #else if (ZSTR_S(src->key) == NULL) { } else { ZSTR_S(dst->key) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->key, src->key_size)); ZSTR_S(dst->key) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->key)); } #endif assert(sizeof(zend_constant) == sizeof(src->constant)); assert(sizeof(zend_constant) == sizeof((&src->constant)[0])); xc_store_zend_constant( processor, &dst->constant, &src->constant TSRMLS_CC ); } while (0); } /* }}} */ #endif /* {{{ xc_store_xc_funcinfo_t */ /* * export: void xc_store_xc_funcinfo_t( * c_processor_t *processor, xc_funcinfo_t *dst, const xc_funcinfo_t * const * src TSRMLS_DC * ); :export */ void xc_store_xc_funcinfo_t(xc_processor_t * processor, xc_funcinfo_t * dst, const xc_funcinfo_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_funcinfo_t)); do { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { ZSTR_U(dst->key) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->key, src->key_size)); ZSTR_U(dst->key) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->key)); } } else { if (ZSTR_S(src->key) == NULL) { } else { ZSTR_S(dst->key) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->key, src->key_size)); ZSTR_S(dst->key) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->key)); } } #else if (ZSTR_S(src->key) == NULL) { } else { ZSTR_S(dst->key) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->key, src->key_size)); ZSTR_S(dst->key) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->key)); } #endif assert(sizeof(zend_function) == sizeof(src->func)); assert(sizeof(zend_function) == sizeof((&src->func)[0])); xc_store_zend_function( processor, &dst->func, &src->func TSRMLS_CC ); } while (0); } /* }}} */ /* {{{ xc_store_xc_classinfo_t */ /* * export: void xc_store_xc_classinfo_t( * c_processor_t *processor, xc_classinfo_t *dst, const xc_classinfo_t * * const src * _DC ); :export */ void xc_store_xc_classinfo_t(xc_processor_t * processor, xc_classinfo_t * dst, const xc_classinfo_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_classinfo_t)); do { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { ZSTR_U(dst->key) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->key, src->key_size)); ZSTR_U(dst->key) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->key)); } } else { if (ZSTR_S(src->key) == NULL) { } else { ZSTR_S(dst->key) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->key, src->key_size)); ZSTR_S(dst->key) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->key)); } } #else if (ZSTR_S(src->key) == NULL) { } else { ZSTR_S(dst->key) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->key, src->key_size)); ZSTR_S(dst->key) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->key)); } #endif #ifdef ZEND_ENGINE_2 if (src->cest) { assert(sizeof(zend_class_entry) == sizeof((src->cest)[0])); /* allocate */ dst->cest = (zend_class_entry *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_class_entry); xc_store_zend_class_entry( processor, dst->cest, src->cest TSRMLS_CC ); dst->cest = (zend_class_entry *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->cest); } else { } #else assert(sizeof(zend_class_entry) == sizeof(src->cest)); assert(sizeof(zend_class_entry) == sizeof((&src->cest)[0])); xc_store_zend_class_entry( processor, &dst->cest, &src->cest TSRMLS_CC ); #endif } while (0); } /* }}} */ #ifdef ZEND_ENGINE_2_1 /* {{{ xc_store_xc_autoglobal_t */ static void inline xc_store_xc_autoglobal_t(xc_processor_t * processor, xc_autoglobal_t * dst, const xc_autoglobal_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_autoglobal_t)); do { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { ZSTR_U(dst->key) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->key, src->key_len + 1)); ZSTR_U(dst->key) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->key)); } } else { if (ZSTR_S(src->key) == NULL) { } else { ZSTR_S(dst->key) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->key, src->key_len + 1)); ZSTR_S(dst->key) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->key)); } } #else if (ZSTR_S(src->key) == NULL) { } else { ZSTR_S(dst->key) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->key, src->key_len + 1)); ZSTR_S(dst->key) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->key)); } #endif } while (0); } /* }}} */ #endif /* {{{ xc_store_xc_entry_data_php_t */ static void inline xc_store_xc_entry_data_php_t(xc_processor_t * processor, xc_entry_data_php_t * dst, const xc_entry_data_php_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_entry_data_php_t)); do { zend_uint i; #ifdef HAVE_INODE #endif if (src->op_array) { assert(sizeof(zend_op_array) == sizeof((src->op_array)[0])); /* allocate */ dst->op_array = (zend_op_array *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(zend_op_array); xc_store_zend_op_array( processor, dst->op_array, src->op_array TSRMLS_CC ); dst->op_array = (zend_op_array *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->op_array); } else { } #ifdef HAVE_XCACHE_CONSTANT if (src->constinfos) { /* allocate */ dst->constinfos = (xc_constinfo_t *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(xc_constinfo_t) * src->constinfo_cnt; for (i = 0; i < src->constinfo_cnt; i++) { assert(sizeof(xc_constinfo_t) == sizeof(src->constinfos[i])); assert(sizeof(xc_constinfo_t) == sizeof((&src->constinfos[i])[0])); xc_store_xc_constinfo_t( processor, &dst->constinfos[i], &src->constinfos[i] TSRMLS_CC ); } } else { } #endif if (src->funcinfos) { /* allocate */ dst->funcinfos = (xc_funcinfo_t *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(xc_funcinfo_t) * src->funcinfo_cnt; for (i = 0; i < src->funcinfo_cnt; i++) { assert(sizeof(xc_funcinfo_t) == sizeof(src->funcinfos[i])); assert(sizeof(xc_funcinfo_t) == sizeof((&src->funcinfos[i])[0])); xc_store_xc_funcinfo_t( processor, &dst->funcinfos[i], &src->funcinfos[i] TSRMLS_CC ); } } else { } if (src->classinfos) { /* allocate */ dst->classinfos = (xc_classinfo_t *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(xc_classinfo_t) * src->classinfo_cnt; for (i = 0; i < src->classinfo_cnt; i++) { processor->active_class_num = i + 1; assert(sizeof(xc_classinfo_t) == sizeof(src->classinfos[i])); assert(sizeof(xc_classinfo_t) == sizeof((&src->classinfos[i])[0])); xc_store_xc_classinfo_t( processor, &dst->classinfos[i], &src->classinfos[i] TSRMLS_CC ); } } else { } #ifdef ZEND_ENGINE_2_1 if (src->autoglobals) { /* allocate */ dst->autoglobals = (xc_autoglobal_t *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(xc_autoglobal_t) * src->autoglobal_cnt; for (i = 0; i < src->autoglobal_cnt; i++) { processor->active_class_num = i + 1; assert(sizeof(xc_autoglobal_t) == sizeof(src->autoglobals[i])); assert(sizeof(xc_autoglobal_t) == sizeof((&src->autoglobals[i])[0])); xc_store_xc_autoglobal_t( processor, &dst->autoglobals[i], &src->autoglobals[i] TSRMLS_CC ); } } else { } #endif } while (0); } /* }}} */ /* {{{ xc_store_xc_entry_data_var_t */ static void inline xc_store_xc_entry_data_var_t(xc_processor_t * processor, xc_entry_data_var_t * dst, const xc_entry_data_var_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_entry_data_var_t)); do { assert(sizeof(zval_ptr) == sizeof((&src->value)[0])); xc_store_zval_ptr( processor, &dst->value, &src->value TSRMLS_CC ); } while (0); } /* }}} */ /* {{{ xc_store_xc_entry_t */ /* * export: void xc_store_xc_entry_t( * c_processor_t *processor, xc_entry_t *dst, const xc_entry_t * const src * SRMLS_DC ); :export */ void xc_store_xc_entry_t(xc_processor_t * processor, xc_entry_t * dst, const xc_entry_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_entry_t)); do { processor->xce_dst = dst; processor->xce_src = src; /* skip */ dst->refcount = 0; #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->name_type == IS_UNICODE) { } else { } #else #endif #ifdef IS_UNICODE #ifdef IS_UNICODE if (src->name_type == IS_UNICODE) { if (ZSTR_U(src->name.uni.val) == NULL) { } else { ZSTR_U(dst->name.uni.val) = ZSTR_U(xc_store_string_n(processor, IS_UNICODE, src->name.uni.val, src->name.uni.len + 1)); ZSTR_U(dst->name.uni.val) = (UChar *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_U(dst->name.uni.val)); } } else { if (ZSTR_S(src->name.uni.val) == NULL) { } else { ZSTR_S(dst->name.uni.val) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name.uni.val, src->name.uni.len + 1)); ZSTR_S(dst->name.uni.val) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name.uni.val)); } } #else if (ZSTR_S(src->name.uni.val) == NULL) { } else { ZSTR_S(dst->name.uni.val) = ZSTR_S(xc_store_string_n(processor, IS_STRING, src->name.uni.val, src->name.uni.len + 1)); ZSTR_S(dst->name.uni.val) = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) ZSTR_S(dst->name.uni.val)); } #endif #else if (src->name.str.val == NULL) { } else { dst->name.str.val = ZSTR_S(xc_store_string_n(processor, IS_STRING, ZSTR(src->name.str.val), src->name.str.len + 1)); dst->name.str.val = (char *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->name.str.val); } #endif switch (src->type) { case XC_TYPE_PHP: if (src->data.php) { assert(sizeof(xc_entry_data_php_t) == sizeof((src->data.php)[0])); /* allocate */ dst->data.php = (xc_entry_data_php_t *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(xc_entry_data_php_t); xc_store_xc_entry_data_php_t( processor, dst->data.php, src->data.php TSRMLS_CC ); dst->data.php = (xc_entry_data_php_t *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->data.php); } else { } break; case XC_TYPE_VAR: if (src->data.var) { assert(sizeof(xc_entry_data_var_t) == sizeof((src->data.var)[0])); /* allocate */ dst->data.var = (xc_entry_data_var_t *) (processor->p = (char *) ALIGN(processor->p)); processor->p += sizeof(xc_entry_data_var_t); xc_store_xc_entry_data_var_t( processor, dst->data.var, src->data.var TSRMLS_CC ); dst->data.var = (xc_entry_data_var_t *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *) dst->data.var); } else { } break; default: assert(0); } } while (0); } /* }}} */ /* {{{ Pre-declare */ void xc_restore_zval(xc_processor_t * processor, zval * dst, const zval * const src TSRMLS_DC); static void inline xc_restore_zval_ptr(xc_processor_t * processor, zval_ptr * dst, const zval_ptr * const src TSRMLS_DC); void xc_restore_zend_op_array(xc_processor_t * processor, zend_op_array * dst, const zend_op_array * const src TSRMLS_DC); void xc_restore_zend_class_entry(xc_processor_t * processor, zend_class_entry * dst, const zend_class_entry * const src TSRMLS_DC); #ifdef HAVE_XCACHE_CONSTANT static void inline xc_restore_zend_constant(xc_processor_t * processor, zend_constant * dst, const zend_constant * const src TSRMLS_DC); #endif void xc_restore_zend_function(xc_processor_t * processor, zend_function * dst, const zend_function * const src TSRMLS_DC); void xc_restore_xc_entry_t(xc_processor_t * processor, xc_entry_t * dst, const xc_entry_t * const src TSRMLS_DC); #ifdef ZEND_ENGINE_2 static void inline xc_restore_zend_property_info(xc_processor_t * processor, zend_property_info * dst, const zend_property_info * const src TSRMLS_DC); #endif /* }}} */ #ifdef IS_CV /* {{{ xc_restore_zend_compiled_variable */ static void inline xc_restore_zend_compiled_variable(xc_processor_t * processor, zend_compiled_variable * dst, const zend_compiled_variable * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_compiled_variable)); do { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { /* allocate */ ZSTR_U(dst->name) = (zstr_uchar *) emalloc(sizeof(zstr_uchar) * (src->name_len + 1)); memcpy(ZSTR_U(dst->name), ZSTR_U(src->name), sizeof(zstr_uchar) * (src->name_len + 1)); } } else { if (ZSTR_S(src->name) == NULL) { } else { /* allocate */ ZSTR_S(dst->name) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->name_len + 1)); memcpy(ZSTR_S(dst->name), ZSTR_S(src->name), sizeof(zstr_char) * (src->name_len + 1)); } } #else if (ZSTR_S(src->name) == NULL) { } else { /* allocate */ ZSTR_S(dst->name) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->name_len + 1)); memcpy(ZSTR_S(dst->name), ZSTR_S(src->name), sizeof(zstr_char) * (src->name_len + 1)); } #endif } while (0); } /* }}} */ #endif /* {{{ xc_restore_zend_uint */ static void inline xc_restore_zend_uint(xc_processor_t * processor, zend_uint * dst, const zend_uint * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_uint)); do { dst[0] = src[0]; } while (0); } /* }}} */ #ifndef ZEND_ENGINE_2 /* {{{ xc_restore_int */ static void inline xc_restore_int(xc_processor_t * processor, int *dst, const int *const src TSRMLS_DC) { memcpy(dst, src, sizeof(int)); do { *dst = *src; } while (0); } /* }}} */ #endif #ifdef ZEND_ENGINE_2 /* {{{ xc_restore_zend_try_catch_element */ static void inline xc_restore_zend_try_catch_element(xc_processor_t * processor, zend_try_catch_element * dst, const zend_try_catch_element * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_try_catch_element)); do { } while (0); } /* }}} */ #endif /* ifdef ZEND_ENGINE_2 */ /* {{{ xc_restore_zend_brk_cont_element */ static void inline xc_restore_zend_brk_cont_element(xc_processor_t * processor, zend_brk_cont_element * dst, const zend_brk_cont_element * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_brk_cont_element)); do { #ifdef ZEND_ENGINE_2_2 #ifndef IS_UNICODE #endif #endif } while (0); } /* }}} */ /* {{{ xc_restore_HashTable_zval_ptr */ static void inline xc_restore_HashTable_zval_ptr(xc_processor_t * processor, HashTable * dst, const HashTable * const src TSRMLS_DC) { memcpy(dst, src, sizeof(HashTable)); do { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; uint n; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT dst->canary = zend_hash_canary; #endif dst->pInternalPointer = NULL; /* Used for element traversal */ dst->pListHead = NULL; /* allocate */ dst->arBuckets = (Bucket * *) ecalloc(src->nTableSize, sizeof(Bucket *)); for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ pnew = (Bucket *) emalloc(sizeof(char) * bucketsize); memcpy(pnew, b, bucketsize); n = b->h & src->nTableMask; /* pnew into hash node chain */ pnew->pLast = NULL; if (dst->arBuckets[n]) { pnew->pNext = dst->arBuckets[n]; pnew->pNext->pLast = pnew; } else { pnew->pNext = NULL; } dst->arBuckets[n] = pnew; if (sizeof(void *) == sizeof(zval_ptr)) { pnew->pData = &pnew->pDataPtr; assert(sizeof(zval_ptr) == sizeof((((zval_ptr *) b->pData))[0])); xc_restore_zval_ptr( processor, pnew->pData, ((zval_ptr *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zval_ptr) == sizeof((((zval_ptr *) b->pData))[0])); /* allocate */ pnew->pData = (zval_ptr *) emalloc(sizeof(zval_ptr)); xc_restore_zval_ptr( processor, pnew->pData, ((zval_ptr *) b->pData) TSRMLS_CC ); pnew->pDataPtr = NULL; } if (first) { dst->pListHead = pnew; first = 0; } /* flat link */ pnew->pListLast = prev; pnew->pListNext = NULL; if (prev) { prev->pListNext = pnew; } prev = pnew; } dst->pListTail = pnew; dst->pDestructor = src->pDestructor; #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } while (0); } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_restore_HashTable_zend_constant */ static void inline xc_restore_HashTable_zend_constant(xc_processor_t * processor, HashTable * dst, const HashTable * const src TSRMLS_DC) { memcpy(dst, src, sizeof(HashTable)); do { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; uint n; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT dst->canary = zend_hash_canary; #endif dst->pInternalPointer = NULL; /* Used for element traversal */ dst->pListHead = NULL; /* allocate */ dst->arBuckets = (Bucket * *) ecalloc(src->nTableSize, sizeof(Bucket *)); for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ pnew = (Bucket *) emalloc(sizeof(char) * bucketsize); memcpy(pnew, b, bucketsize); n = b->h & src->nTableMask; /* pnew into hash node chain */ pnew->pLast = NULL; if (dst->arBuckets[n]) { pnew->pNext = dst->arBuckets[n]; pnew->pNext->pLast = pnew; } else { pnew->pNext = NULL; } dst->arBuckets[n] = pnew; if (sizeof(void *) == sizeof(zend_constant)) { pnew->pData = &pnew->pDataPtr; assert(sizeof(zend_constant) == sizeof((((zend_constant *) b->pData))[0])); xc_restore_zend_constant( processor, pnew->pData, ((zend_constant *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_constant) == sizeof((((zend_constant *) b->pData))[0])); /* allocate */ pnew->pData = (zend_constant *) emalloc(sizeof(zend_constant)); xc_restore_zend_constant( processor, pnew->pData, ((zend_constant *) b->pData) TSRMLS_CC ); pnew->pDataPtr = NULL; } if (first) { dst->pListHead = pnew; first = 0; } /* flat link */ pnew->pListLast = prev; pnew->pListNext = NULL; if (prev) { prev->pListNext = pnew; } prev = pnew; } dst->pListTail = pnew; dst->pDestructor = src->pDestructor; #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } while (0); } /* }}} */ #endif /* {{{ xc_restore_HashTable_zend_function */ /* * export: void xc_restore_HashTable_zend_function( * c_processor_t *processor, HashTable *dst, const HashTable * const src * SRMLS_DC ); :export */ void xc_restore_HashTable_zend_function(xc_processor_t * processor, HashTable * dst, const HashTable * const src TSRMLS_DC) { memcpy(dst, src, sizeof(HashTable)); do { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; uint n; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT dst->canary = zend_hash_canary; #endif dst->pInternalPointer = NULL; /* Used for element traversal */ dst->pListHead = NULL; /* allocate */ dst->arBuckets = (Bucket * *) ecalloc(src->nTableSize, sizeof(Bucket *)); for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ pnew = (Bucket *) emalloc(sizeof(char) * bucketsize); memcpy(pnew, b, bucketsize); n = b->h & src->nTableMask; /* pnew into hash node chain */ pnew->pLast = NULL; if (dst->arBuckets[n]) { pnew->pNext = dst->arBuckets[n]; pnew->pNext->pLast = pnew; } else { pnew->pNext = NULL; } dst->arBuckets[n] = pnew; if (sizeof(void *) == sizeof(zend_function)) { pnew->pData = &pnew->pDataPtr; assert(sizeof(zend_function) == sizeof((((zend_function *) b->pData))[0])); xc_restore_zend_function( processor, pnew->pData, ((zend_function *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_function) == sizeof((((zend_function *) b->pData))[0])); /* allocate */ pnew->pData = (zend_function *) emalloc(sizeof(zend_function)); xc_restore_zend_function( processor, pnew->pData, ((zend_function *) b->pData) TSRMLS_CC ); pnew->pDataPtr = NULL; } if (first) { dst->pListHead = pnew; first = 0; } /* flat link */ pnew->pListLast = prev; pnew->pListNext = NULL; if (prev) { prev->pListNext = pnew; } prev = pnew; } dst->pListTail = pnew; dst->pDestructor = src->pDestructor; #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } while (0); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_restore_HashTable_zend_property_info */ static void inline xc_restore_HashTable_zend_property_info(xc_processor_t * processor, HashTable * dst, const HashTable * const src TSRMLS_DC) { memcpy(dst, src, sizeof(HashTable)); do { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; uint n; int bucketsize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT dst->canary = zend_hash_canary; #endif dst->pInternalPointer = NULL; /* Used for element traversal */ dst->pListHead = NULL; /* allocate */ dst->arBuckets = (Bucket * *) ecalloc(src->nTableSize, sizeof(Bucket *)); for (b = src->pListHead; b != NULL; b = b->pListNext) { bucketsize = BUCKET_SIZE(b); /* allocate */ pnew = (Bucket *) emalloc(sizeof(char) * bucketsize); memcpy(pnew, b, bucketsize); n = b->h & src->nTableMask; /* pnew into hash node chain */ pnew->pLast = NULL; if (dst->arBuckets[n]) { pnew->pNext = dst->arBuckets[n]; pnew->pNext->pLast = pnew; } else { pnew->pNext = NULL; } dst->arBuckets[n] = pnew; if (sizeof(void *) == sizeof(zend_property_info)) { pnew->pData = &pnew->pDataPtr; assert(sizeof(zend_property_info) == sizeof((((zend_property_info *) b->pData))[0])); xc_restore_zend_property_info( processor, pnew->pData, ((zend_property_info *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_property_info) == sizeof((((zend_property_info *) b->pData))[0])); /* allocate */ pnew->pData = (zend_property_info *) emalloc(sizeof(zend_property_info)); xc_restore_zend_property_info( processor, pnew->pData, ((zend_property_info *) b->pData) TSRMLS_CC ); pnew->pDataPtr = NULL; } if (first) { dst->pListHead = pnew; first = 0; } /* flat link */ pnew->pListLast = prev; pnew->pListNext = NULL; if (prev) { prev->pListNext = pnew; } prev = pnew; } dst->pListTail = pnew; dst->pDestructor = src->pDestructor; #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } while (0); } /* }}} */ #endif /* {{{ xc_restore_zval */ /* * export: void xc_restore_zval( * c_processor_t *processor, zval *dst, const zval * const src * SRMLS_DC ); :export */ void xc_restore_zval(xc_processor_t * processor, zval * dst, const zval * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zval)); do { /* Variable information */ switch (src->type & ~IS_CONSTANT_INDEX) { case IS_LONG: case IS_RESOURCE: case IS_BOOL: break; case IS_DOUBLE: break; case IS_NULL: break; case IS_CONSTANT: #ifdef IS_UNICODE if (UG(unicode)) { goto proc_unicode; } #endif case IS_STRING: #ifdef FLAG_IS_BC case FLAG_IS_BC: #endif if (src->value.str.val == NULL) { } else { /* allocate */ dst->value.str.val = (char *) emalloc(sizeof(char) * (src->value.str.len + 1)); memcpy(dst->value.str.val, src->value.str.val, sizeof(char) * (src->value.str.len + 1)); } break; #ifdef IS_UNICODE case IS_UNICODE: proc_unicode: #ifdef IS_UNICODE if (ZSTR_U(src->value.uni.val) == NULL) { } else { /* allocate */ ZSTR_U(dst->value.uni.val) = (zstr_uchar *) emalloc(sizeof(zstr_uchar) * (src->value.uni.len + 1)); memcpy(ZSTR_U(dst->value.uni.val), ZSTR_U(src->value.uni.val), sizeof(zstr_uchar) * (src->value.uni.len + 1)); } #else if (ZSTR_S(src->value.uni.val) == NULL) { } else { /* allocate */ ZSTR_S(dst->value.uni.val) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->value.uni.len + 1)); memcpy(ZSTR_S(dst->value.uni.val), ZSTR_S(src->value.uni.val), sizeof(zstr_char) * (src->value.uni.len + 1)); } #endif break; #endif case IS_ARRAY: case IS_CONSTANT_ARRAY: if (src->value.ht) { assert(sizeof(HashTable) == sizeof((src->value.ht)[0])); /* allocate */ ALLOC_HASHTABLE(dst->value.ht); xc_restore_HashTable_zval_ptr( processor, dst->value.ht, src->value.ht TSRMLS_CC ); } else { } break; case IS_OBJECT: #ifndef ZEND_ENGINE_2 if (src->value.obj.ce) { assert(sizeof(zend_class_entry) == sizeof((src->value.obj.ce)[0])); /* allocate */ dst->value.obj.ce = (zend_class_entry *) emalloc(sizeof(zend_class_entry)); xc_restore_zend_class_entry( processor, dst->value.obj.ce, src->value.obj.ce TSRMLS_CC ); } else { } if (src->value.obj.properties) { assert(sizeof(HashTable) == sizeof((src->value.obj.properties)[0])); /* allocate */ ALLOC_HASHTABLE(dst->value.obj.properties); xc_restore_HashTable_zval_ptr( processor, dst->value.obj.properties, src->value.obj.properties TSRMLS_CC ); } else { } #endif break; default: assert(0); } } while (0); } /* }}} */ /* {{{ xc_restore_zval_ptr */ static void inline xc_restore_zval_ptr(xc_processor_t * processor, zval_ptr * dst, const zval_ptr * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zval_ptr)); do { do { if (processor->reference) { zval_ptr *ppzv; if (zend_hash_find(&processor->zvalptrs, (char *) &src[0], sizeof(src[0]), (void **) &ppzv) == SUCCESS) { dst[0] = *ppzv; /* *dst is updated */ assert(!xc_is_shm(dst[0])); break; } } /* allocate */ ALLOC_ZVAL(dst[0]); if (processor->reference) { zval_ptr pzv = dst[0]; if (zend_hash_add(&processor->zvalptrs, (char *) &src[0], sizeof(src[0]), (void *) &pzv, sizeof(pzv), NULL) == SUCCESS) { /* first add, go on */ } else { assert(0); } } assert(sizeof(zval) == sizeof((src[0])[0])); xc_restore_zval( processor, dst[0], src[0] TSRMLS_CC ); } while (0); } while (0); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_restore_zend_arg_info */ static void inline xc_restore_zend_arg_info(xc_processor_t * processor, zend_arg_info * dst, const zend_arg_info * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_arg_info)); do { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { /* allocate */ ZSTR_U(dst->name) = (zstr_uchar *) emalloc(sizeof(zstr_uchar) * (src->name_len + 1)); memcpy(ZSTR_U(dst->name), ZSTR_U(src->name), sizeof(zstr_uchar) * (src->name_len + 1)); } } else { if (ZSTR_S(src->name) == NULL) { } else { /* allocate */ ZSTR_S(dst->name) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->name_len + 1)); memcpy(ZSTR_S(dst->name), ZSTR_S(src->name), sizeof(zstr_char) * (src->name_len + 1)); } } #else if (ZSTR_S(src->name) == NULL) { } else { /* allocate */ ZSTR_S(dst->name) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->name_len + 1)); memcpy(ZSTR_S(dst->name), ZSTR_S(src->name), sizeof(zstr_char) * (src->name_len + 1)); } #endif #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->class_name) == NULL) { } else { /* allocate */ ZSTR_U(dst->class_name) = (zstr_uchar *) emalloc(sizeof(zstr_uchar) * (src->class_name_len + 1)); memcpy(ZSTR_U(dst->class_name), ZSTR_U(src->class_name), sizeof(zstr_uchar) * (src->class_name_len + 1)); } } else { if (ZSTR_S(src->class_name) == NULL) { } else { /* allocate */ ZSTR_S(dst->class_name) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->class_name_len + 1)); memcpy(ZSTR_S(dst->class_name), ZSTR_S(src->class_name), sizeof(zstr_char) * (src->class_name_len + 1)); } } #else if (ZSTR_S(src->class_name) == NULL) { } else { /* allocate */ ZSTR_S(dst->class_name) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->class_name_len + 1)); memcpy(ZSTR_S(dst->class_name), ZSTR_S(src->class_name), sizeof(zstr_char) * (src->class_name_len + 1)); } #endif } while (0); } /* }}} */ #endif #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_restore_zend_constant */ static void inline xc_restore_zend_constant(xc_processor_t * processor, zend_constant * dst, const zend_constant * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_constant)); do { assert(sizeof(zval) == sizeof(src->value)); assert(sizeof(zval) == sizeof((&src->value)[0])); xc_restore_zval( processor, &dst->value, &src->value TSRMLS_CC ); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { /* allocate */ ZSTR_U(dst->name) = (zstr_uchar *) malloc(sizeof(zstr_uchar) * (src->name_len + 1)); memcpy(ZSTR_U(dst->name), ZSTR_U(src->name), sizeof(zstr_uchar) * (src->name_len + 1)); } } else { if (ZSTR_S(src->name) == NULL) { } else { /* allocate */ ZSTR_S(dst->name) = (zstr_char *) malloc(sizeof(zstr_char) * (src->name_len + 1)); memcpy(ZSTR_S(dst->name), ZSTR_S(src->name), sizeof(zstr_char) * (src->name_len + 1)); } } #else if (ZSTR_S(src->name) == NULL) { } else { /* allocate */ ZSTR_S(dst->name) = (zstr_char *) malloc(sizeof(zstr_char) * (src->name_len + 1)); memcpy(ZSTR_S(dst->name), ZSTR_S(src->name), sizeof(zstr_char) * (src->name_len + 1)); } #endif } while (0); } /* }}} */ #endif /* {{{ xc_restore_zend_function */ /* * export: void xc_restore_zend_function( * c_processor_t *processor, zend_function *dst, const zend_function * const * src TSRMLS_DC ); * rt */ void xc_restore_zend_function(xc_processor_t * processor, zend_function * dst, const zend_function * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_function)); do { switch (src->type) { case ZEND_INTERNAL_FUNCTION: case ZEND_OVERLOADED_FUNCTION: break; case ZEND_USER_FUNCTION: case ZEND_EVAL_CODE: assert(sizeof(zend_op_array) == sizeof(src->op_array)); assert(sizeof(zend_op_array) == sizeof((&src->op_array)[0])); xc_restore_zend_op_array( processor, &dst->op_array, &src->op_array TSRMLS_CC ); break; default: assert(0); } } while (0); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_restore_zend_property_info */ static void inline xc_restore_zend_property_info(xc_processor_t * processor, zend_property_info * dst, const zend_property_info * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_property_info)); do { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { /* allocate */ ZSTR_U(dst->name) = (zstr_uchar *) emalloc(sizeof(zstr_uchar) * (src->name_length + 1)); memcpy(ZSTR_U(dst->name), ZSTR_U(src->name), sizeof(zstr_uchar) * (src->name_length + 1)); } } else { if (ZSTR_S(src->name) == NULL) { } else { /* allocate */ ZSTR_S(dst->name) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->name_length + 1)); memcpy(ZSTR_S(dst->name), ZSTR_S(src->name), sizeof(zstr_char) * (src->name_length + 1)); } } #else if (ZSTR_S(src->name) == NULL) { } else { /* allocate */ ZSTR_S(dst->name) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->name_length + 1)); memcpy(ZSTR_S(dst->name), ZSTR_S(src->name), sizeof(zstr_char) * (src->name_length + 1)); } #endif #ifdef ZEND_ENGINE_2_1 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { /* allocate */ ZSTR_U(dst->doc_comment) = (zstr_uchar *) emalloc(sizeof(zstr_uchar) * (src->doc_comment_len + 1)); memcpy(ZSTR_U(dst->doc_comment), ZSTR_U(src->doc_comment), sizeof(zstr_uchar) * (src->doc_comment_len + 1)); } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { /* allocate */ ZSTR_S(dst->doc_comment) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->doc_comment_len + 1)); memcpy(ZSTR_S(dst->doc_comment), ZSTR_S(src->doc_comment), sizeof(zstr_char) * (src->doc_comment_len + 1)); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { /* allocate */ ZSTR_S(dst->doc_comment) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->doc_comment_len + 1)); memcpy(ZSTR_S(dst->doc_comment), ZSTR_S(src->doc_comment), sizeof(zstr_char) * (src->doc_comment_len + 1)); } #endif #endif #if defined(ZEND_ENGINE_2_2) && !defined(IS_UNICODE) if (src->ce) { dst->ce = xc_get_class(processor, (zend_ulong) src->ce); } else { } #endif } while (0); } /* }}} */ #endif /* {{{ xc_restore_zend_class_entry */ /* * export: void xc_restore_zend_class_entry( * c_processor_t *processor, zend_class_entry *dst, const zend_class_entry * * const src TSRMLS_DC ); * export */ void xc_restore_zend_class_entry(xc_processor_t * processor, zend_class_entry * dst, const zend_class_entry * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_class_entry)); do { processor->active_class_entry_src = src; processor->active_class_entry_dst = dst; #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { /* allocate */ ZSTR_U(dst->name) = (zstr_uchar *) emalloc(sizeof(zstr_uchar) * (src->name_length + 1)); memcpy(ZSTR_U(dst->name), ZSTR_U(src->name), sizeof(zstr_uchar) * (src->name_length + 1)); } } else { if (ZSTR_S(src->name) == NULL) { } else { /* allocate */ ZSTR_S(dst->name) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->name_length + 1)); memcpy(ZSTR_S(dst->name), ZSTR_S(src->name), sizeof(zstr_char) * (src->name_length + 1)); } } #else if (ZSTR_S(src->name) == NULL) { } else { /* allocate */ ZSTR_S(dst->name) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->name_length + 1)); memcpy(ZSTR_S(dst->name), ZSTR_S(src->name), sizeof(zstr_char) * (src->name_length + 1)); } #endif #ifndef ZEND_ENGINE_2 /* just copy parent and resolve on install_class */ #else if (src->parent) { dst->parent = xc_get_class(processor, (zend_ulong) src->parent); } else { } #endif #ifdef ZEND_ENGINE_2 #else if (src->refcount) { assert(sizeof(int) == sizeof((src->refcount)[0])); /* allocate */ dst->refcount = (int *) emalloc(sizeof(int)); xc_restore_int( processor, dst->refcount, src->refcount TSRMLS_CC ); } else { } #endif #ifdef ZEND_ENGINE_2 #endif assert(sizeof(HashTable) == sizeof(src->default_properties)); assert(sizeof(HashTable) == sizeof((&src->default_properties)[0])); xc_restore_HashTable_zval_ptr( processor, &dst->default_properties, &src->default_properties TSRMLS_CC ); dst->builtin_functions = src->builtin_functions; #ifdef ZEND_ENGINE_2 assert(sizeof(HashTable) == sizeof(src->properties_info)); assert(sizeof(HashTable) == sizeof((&src->properties_info)[0])); xc_restore_HashTable_zend_property_info( processor, &dst->properties_info, &src->properties_info TSRMLS_CC ); #ifdef ZEND_ENGINE_2_1 assert(sizeof(HashTable) == sizeof(src->default_static_members)); assert(sizeof(HashTable) == sizeof((&src->default_static_members)[0])); xc_restore_HashTable_zval_ptr( processor, &dst->default_static_members, &src->default_static_members TSRMLS_CC ); dst->static_members = &dst->default_static_members; #else if (src->static_members) { assert(sizeof(HashTable) == sizeof((src->static_members)[0])); /* allocate */ ALLOC_HASHTABLE(dst->static_members); xc_restore_HashTable_zval_ptr( processor, dst->static_members, src->static_members TSRMLS_CC ); } else { } #endif assert(sizeof(HashTable) == sizeof(src->constants_table)); assert(sizeof(HashTable) == sizeof((&src->constants_table)[0])); xc_restore_HashTable_zval_ptr( processor, &dst->constants_table, &src->constants_table TSRMLS_CC ); if (src->num_interfaces) { /* allocate */ dst->interfaces = (zend_class_entry * *) ecalloc(src->num_interfaces, sizeof(zend_class_entry *)); } else { } #ifdef ZEND_ENGINE_2_1 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { /* allocate */ ZSTR_U(dst->doc_comment) = (zstr_uchar *) emalloc(sizeof(zstr_uchar) * (src->doc_comment_len + 1)); memcpy(ZSTR_U(dst->doc_comment), ZSTR_U(src->doc_comment), sizeof(zstr_uchar) * (src->doc_comment_len + 1)); } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { /* allocate */ ZSTR_S(dst->doc_comment) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->doc_comment_len + 1)); memcpy(ZSTR_S(dst->doc_comment), ZSTR_S(src->doc_comment), sizeof(zstr_char) * (src->doc_comment_len + 1)); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { /* allocate */ ZSTR_S(dst->doc_comment) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->doc_comment_len + 1)); memcpy(ZSTR_S(dst->doc_comment), ZSTR_S(src->doc_comment), sizeof(zstr_char) * (src->doc_comment_len + 1)); } #endif #endif /* # NOT DONE */ /* deal with it inside xc_fix_method */ dst->constructor = NULL; /* should be >5.1 */ #ifdef ZEND_ENGINE_2_1 #if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6 #endif #endif /* # NOT DONE */ #else #endif assert(sizeof(HashTable) == sizeof(src->function_table)); assert(sizeof(HashTable) == sizeof((&src->function_table)[0])); xc_restore_HashTable_zend_function( processor, &dst->function_table, &src->function_table TSRMLS_CC ); dst->function_table.pDestructor = ZEND_FUNCTION_DTOR; processor->active_class_entry_src = NULL; processor->active_class_entry_dst = NULL; } while (0); } /* }}} */ /* {{{ xc_restore_znode */ static void inline xc_restore_znode(xc_processor_t * processor, znode * dst, const znode * const src TSRMLS_DC) { memcpy(dst, src, sizeof(znode)); do { #ifdef IS_CV #define XCACHE_IS_CV IS_CV #else /* compatible with zend optimizer */ #define XCACHE_IS_CV 16 #endif assert(src->op_type == IS_CONST || src->op_type == IS_VAR || src->op_type == XCACHE_IS_CV || src->op_type == IS_TMP_VAR || src->op_type == IS_UNUSED); #undef XCACHE_IS_CV switch (src->op_type) { case IS_CONST: assert(sizeof(zval) == sizeof(src->u.constant)); assert(sizeof(zval) == sizeof((&src->u.constant)[0])); xc_restore_zval( processor, &dst->u.constant, &src->u.constant TSRMLS_CC ); break; } } while (0); } /* }}} */ /* {{{ xc_restore_zend_op */ /* * export: void xc_restore_zend_op( * c_processor_t *processor, zend_op *dst, const zend_op * const src * SRMLS_DC ); :export */ void xc_restore_zend_op(xc_processor_t * processor, zend_op * dst, const zend_op * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_op)); do { assert(sizeof(znode) == sizeof(src->result)); assert(sizeof(znode) == sizeof((&src->result)[0])); xc_restore_znode( processor, &dst->result, &src->result TSRMLS_CC ); assert(sizeof(znode) == sizeof(src->op1)); assert(sizeof(znode) == sizeof((&src->op1)[0])); xc_restore_znode( processor, &dst->op1, &src->op1 TSRMLS_CC ); assert(sizeof(znode) == sizeof(src->op2)); assert(sizeof(znode) == sizeof((&src->op2)[0])); xc_restore_znode( processor, &dst->op2, &src->op2 TSRMLS_CC ); #ifdef ZEND_ENGINE_2_1 switch (src->opcode) { case ZEND_JMP: dst->op1.u.jmp_addr = processor->active_opcodes_dst + (src->op1.u.jmp_addr - processor->active_opcodes_src); break; case ZEND_JMPZ: case ZEND_JMPNZ: case ZEND_JMPZ_EX: case ZEND_JMPNZ_EX: dst->op2.u.jmp_addr = processor->active_opcodes_dst + (src->op2.u.jmp_addr - processor->active_opcodes_src); break; default: break; } /* is copying enough? */ #endif } while (0); } /* }}} */ /* {{{ xc_restore_zend_op_array */ /* * export: void xc_restore_zend_op_array( * c_processor_t *processor, zend_op_array *dst, const zend_op_array * const * src TSRMLS_DC ); * rt */ void xc_restore_zend_op_array(xc_processor_t * processor, zend_op_array * dst, const zend_op_array * const src TSRMLS_DC) { memcpy(dst, src, sizeof(zend_op_array)); do { if (!processor->readonly_protection && !(src == processor->xce_src->data.php->op_array && processor->xce_src->data.php->have_early_binding)) { /* really fast shallow copy */ memcpy(dst, src, sizeof(src[0])); dst->refcount[0] = 1000; /* deep */ if (src->static_variables) { assert(sizeof(HashTable) == sizeof((src->static_variables)[0])); /* allocate */ ALLOC_HASHTABLE(dst->static_variables); xc_restore_HashTable_zval_ptr( processor, dst->static_variables, src->static_variables TSRMLS_CC ); } else { } } else do { zend_uint ii; int i; /* Common elements */ #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->function_name) == NULL) { } else { /* allocate */ ZSTR_U(dst->function_name) = (zstr_uchar *) emalloc(sizeof(zstr_uchar) * (xc_zstrlen_uchar(src->function_name) + 1)); memcpy(ZSTR_U(dst->function_name), ZSTR_U(src->function_name), sizeof(zstr_uchar) * (xc_zstrlen_uchar(src->function_name) + 1)); } } else { if (ZSTR_S(src->function_name) == NULL) { } else { /* allocate */ ZSTR_S(dst->function_name) = (zstr_char *) emalloc(sizeof(zstr_char) * (xc_zstrlen_char(src->function_name) + 1)); memcpy(ZSTR_S(dst->function_name), ZSTR_S(src->function_name), sizeof(zstr_char) * (xc_zstrlen_char(src->function_name) + 1)); } } #else if (ZSTR_S(src->function_name) == NULL) { } else { /* allocate */ ZSTR_S(dst->function_name) = (zstr_char *) emalloc(sizeof(zstr_char) * (xc_zstrlen_char(src->function_name) + 1)); memcpy(ZSTR_S(dst->function_name), ZSTR_S(src->function_name), sizeof(zstr_char) * (xc_zstrlen_char(src->function_name) + 1)); } #endif #ifdef ZEND_ENGINE_2 if (src->arg_info) { /* allocate */ dst->arg_info = (zend_arg_info *) emalloc(sizeof(zend_arg_info) * src->num_args); for (ii = 0; ii < src->num_args; ii++) { assert(sizeof(zend_arg_info) == sizeof(src->arg_info[ii])); assert(sizeof(zend_arg_info) == sizeof((&src->arg_info[ii])[0])); xc_restore_zend_arg_info( processor, &dst->arg_info[ii], &src->arg_info[ii] TSRMLS_CC ); } } else { } #else if (src->arg_types) { /* allocate */ dst->arg_types = (zend_uchar *) emalloc(sizeof(zend_uchar) * src->arg_types[0] + 1); memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0] + 1)); } else { } #endif /* END of common elements */ #ifdef IS_UNICODE #endif if (src->refcount) { assert(sizeof(zend_uint) == sizeof((src->refcount)[0])); /* allocate */ dst->refcount = (zend_uint *) emalloc(sizeof(zend_uint)); xc_restore_zend_uint( processor, dst->refcount, src->refcount TSRMLS_CC ); } else { } if (src->opcodes) { /* allocate */ dst->opcodes = (zend_op *) emalloc(sizeof(zend_op) * src->last); processor->active_opcodes_dst = dst->opcodes; processor->active_opcodes_src = src->opcodes; for (ii = 0; ii < src->last; ii++) { assert(sizeof(zend_op) == sizeof(src->opcodes[ii])); assert(sizeof(zend_op) == sizeof((&src->opcodes[ii])[0])); xc_restore_zend_op( processor, &dst->opcodes[ii], &src->opcodes[ii] TSRMLS_CC ); } } else { processor->active_opcodes_dst = dst->opcodes; processor->active_opcodes_src = src->opcodes; } dst->size = src->last; #ifdef IS_CV if (src->vars) { /* allocate */ dst->vars = (zend_compiled_variable *) emalloc(sizeof(zend_compiled_variable) * src->last_var); for (i = 0; i < src->last_var; i++) { assert(sizeof(zend_compiled_variable) == sizeof(src->vars[i])); assert(sizeof(zend_compiled_variable) == sizeof((&src->vars[i])[0])); xc_restore_zend_compiled_variable( processor, &dst->vars[i], &src->vars[i] TSRMLS_CC ); } } else { } dst->size_var = src->last_var; #else #endif if (src->brk_cont_array) { /* allocate */ dst->brk_cont_array = (zend_brk_cont_element *) emalloc(sizeof(zend_brk_cont_element) * src->last_brk_cont); for (ii = 0; ii < src->last_brk_cont; ii++) { assert(sizeof(zend_brk_cont_element) == sizeof(src->brk_cont_array[ii])); assert(sizeof(zend_brk_cont_element) == sizeof((&src->brk_cont_array[ii])[0])); xc_restore_zend_brk_cont_element( processor, &dst->brk_cont_array[ii], &src->brk_cont_array[ii] TSRMLS_CC ); } } else { } #ifndef ZEND_ENGINE_2 #endif #ifdef ZEND_ENGINE_2 if (src->try_catch_array) { /* allocate */ dst->try_catch_array = (zend_try_catch_element *) emalloc(sizeof(zend_try_catch_element) * src->last_try_catch); for (i = 0; i < src->last_try_catch; i++) { assert(sizeof(zend_try_catch_element) == sizeof(src->try_catch_array[i])); assert(sizeof(zend_try_catch_element) == sizeof((&src->try_catch_array[i])[0])); xc_restore_zend_try_catch_element( processor, &dst->try_catch_array[i], &src->try_catch_array[i] TSRMLS_CC ); } } else { } #endif if (src->static_variables) { assert(sizeof(HashTable) == sizeof((src->static_variables)[0])); /* allocate */ ALLOC_HASHTABLE(dst->static_variables); xc_restore_HashTable_zval_ptr( processor, dst->static_variables, src->static_variables TSRMLS_CC ); } else { } #ifdef ZEND_ENGINE_2 #endif #ifdef IS_UNICODE #endif #ifdef ZEND_ENGINE_2 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { /* allocate */ ZSTR_U(dst->doc_comment) = (zstr_uchar *) emalloc(sizeof(zstr_uchar) * (src->doc_comment_len + 1)); memcpy(ZSTR_U(dst->doc_comment), ZSTR_U(src->doc_comment), sizeof(zstr_uchar) * (src->doc_comment_len + 1)); } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { /* allocate */ ZSTR_S(dst->doc_comment) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->doc_comment_len + 1)); memcpy(ZSTR_S(dst->doc_comment), ZSTR_S(src->doc_comment), sizeof(zstr_char) * (src->doc_comment_len + 1)); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { /* allocate */ ZSTR_S(dst->doc_comment) = (zstr_char *) emalloc(sizeof(zstr_char) * (src->doc_comment_len + 1)); memcpy(ZSTR_S(dst->doc_comment), ZSTR_S(src->doc_comment), sizeof(zstr_char) * (src->doc_comment_len + 1)); } #endif #endif /* reserved */ #if defined(HARDENING_PATCH) && HARDENING_PATCH #endif } while (0); #ifdef ZEND_ENGINE_2 do { zend_function *parent; if (src->prototype != NULL && zend_u_hash_find(&(processor->active_class_entry_dst->parent->function_table), UG(unicode) ? IS_UNICODE : IS_STRING, src->function_name, xc_zstrlen(UG(unicode), src->function_name) + 1, (void **) &parent) == SUCCESS) { /* see do_inherit_method_check() */ if ((parent->common.fn_flags & ZEND_ACC_ABSTRACT)) { dst->prototype = parent; } else if (!(parent->common.fn_flags & ZEND_ACC_CTOR) || (parent->common.prototype && (parent->common.prototype->common.scope->ce_flags & ZEND_ACC_INTERFACE))) { /* * ctors only have a prototype if it * comes from an interface */ dst->prototype = parent->common.prototype ? parent->common.prototype : parent; } else { dst->prototype = NULL; } } else { dst->prototype = NULL; } } while (0); #endif #ifdef ZEND_ENGINE_2 if (src->scope) { dst->scope = xc_get_class(processor, (zend_ulong) src->scope); xc_fix_method(processor, dst); } #endif if (xc_have_op_array_ctor) { zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) xc_zend_extension_op_array_ctor_handler, dst TSRMLS_CC); } } while (0); } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_restore_xc_constinfo_t */ static void inline xc_restore_xc_constinfo_t(xc_processor_t * processor, xc_constinfo_t * dst, const xc_constinfo_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_constinfo_t)); do { #ifdef IS_UNICODE #endif assert(sizeof(zend_constant) == sizeof(src->constant)); assert(sizeof(zend_constant) == sizeof((&src->constant)[0])); xc_restore_zend_constant( processor, &dst->constant, &src->constant TSRMLS_CC ); } while (0); } /* }}} */ #endif /* {{{ xc_restore_xc_funcinfo_t */ /* * export: void xc_restore_xc_funcinfo_t( * c_processor_t *processor, xc_funcinfo_t *dst, const xc_funcinfo_t * const * src TSRMLS_DC ); * rt */ void xc_restore_xc_funcinfo_t(xc_processor_t * processor, xc_funcinfo_t * dst, const xc_funcinfo_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_funcinfo_t)); do { #ifdef IS_UNICODE #endif assert(sizeof(zend_function) == sizeof(src->func)); assert(sizeof(zend_function) == sizeof((&src->func)[0])); xc_restore_zend_function( processor, &dst->func, &src->func TSRMLS_CC ); } while (0); } /* }}} */ /* {{{ xc_restore_xc_classinfo_t */ /* * export: void xc_restore_xc_classinfo_t( * c_processor_t *processor, xc_classinfo_t *dst, const xc_classinfo_t * * const src TSRMLS_DC ); * export */ void xc_restore_xc_classinfo_t(xc_processor_t * processor, xc_classinfo_t * dst, const xc_classinfo_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_classinfo_t)); do { #ifdef IS_UNICODE #endif #ifdef ZEND_ENGINE_2 if (src->cest) { assert(sizeof(zend_class_entry) == sizeof((src->cest)[0])); /* allocate */ dst->cest = (zend_class_entry *) emalloc(sizeof(zend_class_entry)); xc_restore_zend_class_entry( processor, dst->cest, src->cest TSRMLS_CC ); } else { } #else assert(sizeof(zend_class_entry) == sizeof(src->cest)); assert(sizeof(zend_class_entry) == sizeof((&src->cest)[0])); xc_restore_zend_class_entry( processor, &dst->cest, &src->cest TSRMLS_CC ); #endif } while (0); } /* }}} */ #ifdef ZEND_ENGINE_2_1 /* {{{ xc_restore_xc_autoglobal_t */ static void inline xc_restore_xc_autoglobal_t(xc_processor_t * processor, xc_autoglobal_t * dst, const xc_autoglobal_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_autoglobal_t)); do { #ifdef IS_UNICODE #endif } while (0); } /* }}} */ #endif /* {{{ xc_restore_xc_entry_data_php_t */ static void inline xc_restore_xc_entry_data_php_t(xc_processor_t * processor, xc_entry_data_php_t * dst, const xc_entry_data_php_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_entry_data_php_t)); do { zend_uint i; #ifdef HAVE_INODE #endif if (src->op_array) { assert(sizeof(zend_op_array) == sizeof((src->op_array)[0])); /* allocate */ dst->op_array = (zend_op_array *) emalloc(sizeof(zend_op_array)); xc_restore_zend_op_array( processor, dst->op_array, src->op_array TSRMLS_CC ); } else { } #ifdef HAVE_XCACHE_CONSTANT if (src->constinfos) { /* allocate */ dst->constinfos = (xc_constinfo_t *) emalloc(sizeof(xc_constinfo_t) * src->constinfo_cnt); for (i = 0; i < src->constinfo_cnt; i++) { assert(sizeof(xc_constinfo_t) == sizeof(src->constinfos[i])); assert(sizeof(xc_constinfo_t) == sizeof((&src->constinfos[i])[0])); xc_restore_xc_constinfo_t( processor, &dst->constinfos[i], &src->constinfos[i] TSRMLS_CC ); } } else { } #endif if (src->funcinfos) { /* allocate */ dst->funcinfos = (xc_funcinfo_t *) emalloc(sizeof(xc_funcinfo_t) * src->funcinfo_cnt); for (i = 0; i < src->funcinfo_cnt; i++) { assert(sizeof(xc_funcinfo_t) == sizeof(src->funcinfos[i])); assert(sizeof(xc_funcinfo_t) == sizeof((&src->funcinfos[i])[0])); xc_restore_xc_funcinfo_t( processor, &dst->funcinfos[i], &src->funcinfos[i] TSRMLS_CC ); } } else { } if (src->classinfos) { /* allocate */ dst->classinfos = (xc_classinfo_t *) emalloc(sizeof(xc_classinfo_t) * src->classinfo_cnt); for (i = 0; i < src->classinfo_cnt; i++) { processor->active_class_num = i + 1; assert(sizeof(xc_classinfo_t) == sizeof(src->classinfos[i])); assert(sizeof(xc_classinfo_t) == sizeof((&src->classinfos[i])[0])); xc_restore_xc_classinfo_t( processor, &dst->classinfos[i], &src->classinfos[i] TSRMLS_CC ); } } else { } #ifdef ZEND_ENGINE_2_1 if (src->autoglobals) { /* allocate */ dst->autoglobals = (xc_autoglobal_t *) emalloc(sizeof(xc_autoglobal_t) * src->autoglobal_cnt); for (i = 0; i < src->autoglobal_cnt; i++) { processor->active_class_num = i + 1; assert(sizeof(xc_autoglobal_t) == sizeof(src->autoglobals[i])); assert(sizeof(xc_autoglobal_t) == sizeof((&src->autoglobals[i])[0])); xc_restore_xc_autoglobal_t( processor, &dst->autoglobals[i], &src->autoglobals[i] TSRMLS_CC ); } } else { } #endif } while (0); } /* }}} */ /* {{{ xc_restore_xc_entry_data_var_t */ static void inline xc_restore_xc_entry_data_var_t(xc_processor_t * processor, xc_entry_data_var_t * dst, const xc_entry_data_var_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_entry_data_var_t)); do { assert(sizeof(zval_ptr) == sizeof((&src->value)[0])); xc_restore_zval_ptr( processor, &dst->value, &src->value TSRMLS_CC ); } while (0); } /* }}} */ /* {{{ xc_restore_xc_entry_t */ /* * export: void xc_restore_xc_entry_t( * c_processor_t *processor, xc_entry_t *dst, const xc_entry_t * const src * SRMLS_DC ); :export */ void xc_restore_xc_entry_t(xc_processor_t * processor, xc_entry_t * dst, const xc_entry_t * const src TSRMLS_DC) { memcpy(dst, src, sizeof(xc_entry_t)); do { processor->xce_dst = dst; processor->xce_src = src; /* skip */ #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->name_type == IS_UNICODE) { } else { } #else #endif switch (src->type) { case XC_TYPE_PHP: if (src->data.php) { assert(sizeof(xc_entry_data_php_t) == sizeof((src->data.php)[0])); /* allocate */ dst->data.php = (xc_entry_data_php_t *) emalloc(sizeof(xc_entry_data_php_t)); xc_restore_xc_entry_data_php_t( processor, dst->data.php, src->data.php TSRMLS_CC ); } else { } break; case XC_TYPE_VAR: if (src->data.var) { assert(sizeof(xc_entry_data_var_t) == sizeof((src->data.var)[0])); /* allocate */ dst->data.var = (xc_entry_data_var_t *) emalloc(sizeof(xc_entry_data_var_t)); xc_restore_xc_entry_data_var_t( processor, dst->data.var, src->data.var TSRMLS_CC ); } else { } break; default: assert(0); } } while (0); } /* }}} */ #ifdef HAVE_XCACHE_DPRINT /* {{{ Pre-declare */ void xc_dprint_zval(const zval * const src, int indent TSRMLS_DC); static void inline xc_dprint_zval_ptr(const zval_ptr * const src, int indent TSRMLS_DC); void xc_dprint_zend_op_array(const zend_op_array * const src, int indent TSRMLS_DC); void xc_dprint_zend_class_entry(const zend_class_entry * const src, int indent TSRMLS_DC); #ifdef HAVE_XCACHE_CONSTANT static void inline xc_dprint_zend_constant(const zend_constant * const src, int indent TSRMLS_DC); #endif void xc_dprint_zend_function(const zend_function * const src, int indent TSRMLS_DC); void xc_dprint_xc_entry_t(const xc_entry_t * const src, int indent TSRMLS_DC); #ifdef ZEND_ENGINE_2 static void inline xc_dprint_zend_property_info(const zend_property_info * const src, int indent TSRMLS_DC); #endif /* }}} */ #ifdef IS_CV /* {{{ xc_dprint_zend_compiled_variable */ static void inline xc_dprint_zend_compiled_variable(const zend_compiled_variable * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "int:name_len:\t%d\n", src->name_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->name), src->name_len + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->name_len + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(ZSTR_S(src->name), src->name_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name_len + 1 - 1); } } #else if (ZSTR_S(src->name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(ZSTR_S(src->name), src->name_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name_len + 1 - 1); } #endif xc_dprint_indent(indent); fprintf(stderr, "ulong:hash_value:\t%lu\n", src->hash_value); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #endif /* {{{ xc_dprint_zend_uint */ static void inline xc_dprint_zend_uint(const zend_uint * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "%u\n", src[0]); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #ifndef ZEND_ENGINE_2 /* {{{ xc_dprint_int */ static void inline xc_dprint_int(const int *const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "%d\n", src[0]); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #endif #ifdef ZEND_ENGINE_2 /* {{{ xc_dprint_zend_try_catch_element */ static void inline xc_dprint_zend_try_catch_element(const zend_try_catch_element * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "zend_uint:try_op:\t%u\n", src->try_op); xc_dprint_indent(indent); fprintf(stderr, "zend_uint:catch_op:\t%u\n", src->catch_op); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #endif /* ifdef ZEND_ENGINE_2 */ /* {{{ xc_dprint_zend_brk_cont_element */ static void inline xc_dprint_zend_brk_cont_element(const zend_brk_cont_element * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; #ifdef ZEND_ENGINE_2_2 #ifndef IS_UNICODE xc_dprint_indent(indent); fprintf(stderr, "int:start:\t%d\n", src->start); #endif #endif xc_dprint_indent(indent); fprintf(stderr, "int:cont:\t%d\n", src->cont); xc_dprint_indent(indent); fprintf(stderr, "int:brk:\t%d\n", src->brk); xc_dprint_indent(indent); fprintf(stderr, "int:parent:\t%d\n", src->parent); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ /* {{{ xc_dprint_HashTable_zval_ptr */ static void inline xc_dprint_HashTable_zval_ptr(const HashTable * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT xc_dprint_indent(indent); fprintf(stderr, "unsigned int:canary:\t%u\n", src->canary); #endif xc_dprint_indent(indent); fprintf(stderr, "uint:nTableSize:\t%u\n", src->nTableSize); xc_dprint_indent(indent); fprintf(stderr, "uint:nTableMask:\t%u\n", src->nTableMask); xc_dprint_indent(indent); fprintf(stderr, "uint:nNumOfElements:\t%u\n", src->nNumOfElements); xc_dprint_indent(indent); fprintf(stderr, "ulong:nNextFreeElement:\t%lu\n", src->nNextFreeElement); /* allocate */ for (b = src->pListHead; b != NULL; b = b->pListNext) { /* allocate */ xc_dprint_indent(indent); fprintf(stderr, "zval_ptr:\""); xc_dprint_str_len(BUCKET_KEY_S(b), BUCKET_KEY_SIZE(b)); fprintf(stderr, "\" %d:h=%lu", BUCKET_KEY_SIZE(b), b->h); if (sizeof(void *) == sizeof(zval_ptr)) { assert(sizeof(zval_ptr) == sizeof((((zval_ptr *) b->pData))[0])); xc_dprint_zval_ptr( ((zval_ptr *) b->pData), indent TSRMLS_CC ); } else { assert(sizeof(zval_ptr) == sizeof((((zval_ptr *) b->pData))[0])); /* allocate */ xc_dprint_zval_ptr( ((zval_ptr *) b->pData), indent TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } xc_dprint_indent(indent); fprintf(stderr, "zend_bool:persistent:\t%u\n", src->persistent); #ifdef IS_UNICODE xc_dprint_indent(indent); fprintf(stderr, "zend_bool:unicode:\t%u\n", src->unicode); #endif xc_dprint_indent(indent); fprintf(stderr, "unsigned char:nApplyCount:\t%u\n", src->nApplyCount); xc_dprint_indent(indent); fprintf(stderr, "zend_bool:bApplyProtection:\t%u\n", src->bApplyProtection); #if ZEND_DEBUG xc_dprint_indent(indent); fprintf(stderr, "int:inconsistent:\t%d\n", src->inconsistent); #endif indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_dprint_HashTable_zend_constant */ static void inline xc_dprint_HashTable_zend_constant(const HashTable * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT xc_dprint_indent(indent); fprintf(stderr, "unsigned int:canary:\t%u\n", src->canary); #endif xc_dprint_indent(indent); fprintf(stderr, "uint:nTableSize:\t%u\n", src->nTableSize); xc_dprint_indent(indent); fprintf(stderr, "uint:nTableMask:\t%u\n", src->nTableMask); xc_dprint_indent(indent); fprintf(stderr, "uint:nNumOfElements:\t%u\n", src->nNumOfElements); xc_dprint_indent(indent); fprintf(stderr, "ulong:nNextFreeElement:\t%lu\n", src->nNextFreeElement); /* allocate */ for (b = src->pListHead; b != NULL; b = b->pListNext) { /* allocate */ xc_dprint_indent(indent); fprintf(stderr, "zend_constant:\""); xc_dprint_str_len(BUCKET_KEY_S(b), BUCKET_KEY_SIZE(b)); fprintf(stderr, "\" %d:h=%lu", BUCKET_KEY_SIZE(b), b->h); if (sizeof(void *) == sizeof(zend_constant)) { assert(sizeof(zend_constant) == sizeof((((zend_constant *) b->pData))[0])); xc_dprint_zend_constant( ((zend_constant *) b->pData), indent TSRMLS_CC ); } else { assert(sizeof(zend_constant) == sizeof((((zend_constant *) b->pData))[0])); /* allocate */ xc_dprint_zend_constant( ((zend_constant *) b->pData), indent TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } xc_dprint_indent(indent); fprintf(stderr, "zend_bool:persistent:\t%u\n", src->persistent); #ifdef IS_UNICODE xc_dprint_indent(indent); fprintf(stderr, "zend_bool:unicode:\t%u\n", src->unicode); #endif xc_dprint_indent(indent); fprintf(stderr, "unsigned char:nApplyCount:\t%u\n", src->nApplyCount); xc_dprint_indent(indent); fprintf(stderr, "zend_bool:bApplyProtection:\t%u\n", src->bApplyProtection); #if ZEND_DEBUG xc_dprint_indent(indent); fprintf(stderr, "int:inconsistent:\t%d\n", src->inconsistent); #endif indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #endif /* {{{ xc_dprint_HashTable_zend_function */ /* * export: void xc_dprint_HashTable_zend_function( * onst HashTable * const src, int indent * SRMLS_DC ); :export */ void xc_dprint_HashTable_zend_function(const HashTable * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT xc_dprint_indent(indent); fprintf(stderr, "unsigned int:canary:\t%u\n", src->canary); #endif xc_dprint_indent(indent); fprintf(stderr, "uint:nTableSize:\t%u\n", src->nTableSize); xc_dprint_indent(indent); fprintf(stderr, "uint:nTableMask:\t%u\n", src->nTableMask); xc_dprint_indent(indent); fprintf(stderr, "uint:nNumOfElements:\t%u\n", src->nNumOfElements); xc_dprint_indent(indent); fprintf(stderr, "ulong:nNextFreeElement:\t%lu\n", src->nNextFreeElement); /* allocate */ for (b = src->pListHead; b != NULL; b = b->pListNext) { /* allocate */ xc_dprint_indent(indent); fprintf(stderr, "zend_function:\""); xc_dprint_str_len(BUCKET_KEY_S(b), BUCKET_KEY_SIZE(b)); fprintf(stderr, "\" %d:h=%lu", BUCKET_KEY_SIZE(b), b->h); if (sizeof(void *) == sizeof(zend_function)) { assert(sizeof(zend_function) == sizeof((((zend_function *) b->pData))[0])); xc_dprint_zend_function( ((zend_function *) b->pData), indent TSRMLS_CC ); } else { assert(sizeof(zend_function) == sizeof((((zend_function *) b->pData))[0])); /* allocate */ xc_dprint_zend_function( ((zend_function *) b->pData), indent TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } xc_dprint_indent(indent); fprintf(stderr, "zend_bool:persistent:\t%u\n", src->persistent); #ifdef IS_UNICODE xc_dprint_indent(indent); fprintf(stderr, "zend_bool:unicode:\t%u\n", src->unicode); #endif xc_dprint_indent(indent); fprintf(stderr, "unsigned char:nApplyCount:\t%u\n", src->nApplyCount); xc_dprint_indent(indent); fprintf(stderr, "zend_bool:bApplyProtection:\t%u\n", src->bApplyProtection); #if ZEND_DEBUG xc_dprint_indent(indent); fprintf(stderr, "int:inconsistent:\t%d\n", src->inconsistent); #endif indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_dprint_HashTable_zend_property_info */ static void inline xc_dprint_HashTable_zend_property_info(const HashTable * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT xc_dprint_indent(indent); fprintf(stderr, "unsigned int:canary:\t%u\n", src->canary); #endif xc_dprint_indent(indent); fprintf(stderr, "uint:nTableSize:\t%u\n", src->nTableSize); xc_dprint_indent(indent); fprintf(stderr, "uint:nTableMask:\t%u\n", src->nTableMask); xc_dprint_indent(indent); fprintf(stderr, "uint:nNumOfElements:\t%u\n", src->nNumOfElements); xc_dprint_indent(indent); fprintf(stderr, "ulong:nNextFreeElement:\t%lu\n", src->nNextFreeElement); /* allocate */ for (b = src->pListHead; b != NULL; b = b->pListNext) { /* allocate */ xc_dprint_indent(indent); fprintf(stderr, "zend_property_info:\""); xc_dprint_str_len(BUCKET_KEY_S(b), BUCKET_KEY_SIZE(b)); fprintf(stderr, "\" %d:h=%lu", BUCKET_KEY_SIZE(b), b->h); if (sizeof(void *) == sizeof(zend_property_info)) { assert(sizeof(zend_property_info) == sizeof((((zend_property_info *) b->pData))[0])); xc_dprint_zend_property_info( ((zend_property_info *) b->pData), indent TSRMLS_CC ); } else { assert(sizeof(zend_property_info) == sizeof((((zend_property_info *) b->pData))[0])); /* allocate */ xc_dprint_zend_property_info( ((zend_property_info *) b->pData), indent TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } xc_dprint_indent(indent); fprintf(stderr, "zend_bool:persistent:\t%u\n", src->persistent); #ifdef IS_UNICODE xc_dprint_indent(indent); fprintf(stderr, "zend_bool:unicode:\t%u\n", src->unicode); #endif xc_dprint_indent(indent); fprintf(stderr, "unsigned char:nApplyCount:\t%u\n", src->nApplyCount); xc_dprint_indent(indent); fprintf(stderr, "zend_bool:bApplyProtection:\t%u\n", src->bApplyProtection); #if ZEND_DEBUG xc_dprint_indent(indent); fprintf(stderr, "int:inconsistent:\t%d\n", src->inconsistent); #endif indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #endif /* {{{ xc_dprint_zval */ /* * export: void xc_dprint_zval( const * zval * const src, int indent * SRMLS_DC ); :export */ void xc_dprint_zval(const zval * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; /* Variable information */ switch (src->type & ~IS_CONSTANT_INDEX) { case IS_LONG: case IS_RESOURCE: case IS_BOOL: xc_dprint_indent(indent); fprintf(stderr, "long:value.lval:\t%ld\n", src->value.lval); break; case IS_DOUBLE: xc_dprint_indent(indent); fprintf(stderr, "double:value.dval:\t%f\n", src->value.dval); break; case IS_NULL: xc_dprint_indent(indent); fprintf(stderr, "\tNULL\n"); break; case IS_CONSTANT: #ifdef IS_UNICODE if (UG(unicode)) { goto proc_unicode; } #endif case IS_STRING: #ifdef FLAG_IS_BC case FLAG_IS_BC: #endif xc_dprint_indent(indent); fprintf(stderr, "int:value.str.len:\t%d\n", src->value.str.len); if (src->value.str.val == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->value.str.val"); xc_dprint_str_len(src->value.str.val, src->value.str.len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->value.str.len + 1 - 1); } break; #ifdef IS_UNICODE case IS_UNICODE: proc_unicode: xc_dprint_indent(indent); fprintf(stderr, "int32_t:value.uni.len:\t%d\n", src->value.uni.len); #ifdef IS_UNICODE if (ZSTR_U(src->value.uni.val) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->value.uni.val), src->value.uni.len + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->value.uni.val"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->value.uni.len + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } #else if (ZSTR_S(src->value.uni.val) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->value.uni.val"); xc_dprint_str_len(ZSTR_S(src->value.uni.val), src->value.uni.len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->value.uni.len + 1 - 1); } #endif break; #endif case IS_ARRAY: case IS_CONSTANT_ARRAY: if (src->value.ht) { xc_dprint_indent(indent); fprintf(stderr, "HashTable:value.ht"); assert(sizeof(HashTable) == sizeof((src->value.ht)[0])); /* allocate */ xc_dprint_HashTable_zval_ptr( src->value.ht, indent TSRMLS_CC ); } else { xc_dprint_indent(indent); fprintf(stderr, "HashTable:value.ht:\tNULL\n"); } break; case IS_OBJECT: #ifndef ZEND_ENGINE_2 if (src->value.obj.ce) { xc_dprint_indent(indent); fprintf(stderr, "zend_class_entry:value.obj.ce"); assert(sizeof(zend_class_entry) == sizeof((src->value.obj.ce)[0])); /* allocate */ xc_dprint_zend_class_entry( src->value.obj.ce, indent TSRMLS_CC ); } else { xc_dprint_indent(indent); fprintf(stderr, "zend_class_entry:value.obj.ce:\tNULL\n"); } if (src->value.obj.properties) { xc_dprint_indent(indent); fprintf(stderr, "HashTable:value.obj.properties"); assert(sizeof(HashTable) == sizeof((src->value.obj.properties)[0])); /* allocate */ xc_dprint_HashTable_zval_ptr( src->value.obj.properties, indent TSRMLS_CC ); } else { xc_dprint_indent(indent); fprintf(stderr, "HashTable:value.obj.properties:\tNULL\n"); } #endif break; default: assert(0); } xc_dprint_indent(indent); fprintf(stderr, "zval_data_type:type:\t%d %s\n", src->type, xc_get_data_type(src->type)); xc_dprint_indent(indent); fprintf(stderr, "zend_uchar:is_ref:\t%u\n", src->is_ref); xc_dprint_indent(indent); fprintf(stderr, "zend_ushort:refcount:\t%hu\n", src->refcount); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ /* {{{ xc_dprint_zval_ptr */ static void inline xc_dprint_zval_ptr(const zval_ptr * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; do { /* allocate */ xc_dprint_indent(indent); fprintf(stderr, "[%p]", src[0]); assert(sizeof(zval) == sizeof((src[0])[0])); xc_dprint_zval( src[0], indent TSRMLS_CC ); } while (0); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_dprint_zend_arg_info */ static void inline xc_dprint_zend_arg_info(const zend_arg_info * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "zend_uint:name_len:\t%u\n", src->name_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->name), src->name_len + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->name_len + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(ZSTR_S(src->name), src->name_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name_len + 1 - 1); } } #else if (ZSTR_S(src->name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(ZSTR_S(src->name), src->name_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name_len + 1 - 1); } #endif xc_dprint_indent(indent); fprintf(stderr, "zend_uint:class_name_len:\t%u\n", src->class_name_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->class_name) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->class_name), src->class_name_len + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->class_name"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->class_name_len + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->class_name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->class_name"); xc_dprint_str_len(ZSTR_S(src->class_name), src->class_name_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->class_name_len + 1 - 1); } } #else if (ZSTR_S(src->class_name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->class_name"); xc_dprint_str_len(ZSTR_S(src->class_name), src->class_name_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->class_name_len + 1 - 1); } #endif xc_dprint_indent(indent); fprintf(stderr, "zend_bool:array_type_hint:\t%u\n", src->array_type_hint); xc_dprint_indent(indent); fprintf(stderr, "zend_bool:allow_null:\t%u\n", src->allow_null); xc_dprint_indent(indent); fprintf(stderr, "zend_bool:pass_by_reference:\t%u\n", src->pass_by_reference); xc_dprint_indent(indent); fprintf(stderr, "zend_bool:return_reference:\t%u\n", src->return_reference); xc_dprint_indent(indent); fprintf(stderr, "int:required_num_args:\t%d\n", src->required_num_args); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #endif #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_dprint_zend_constant */ static void inline xc_dprint_zend_constant(const zend_constant * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; assert(sizeof(zval) == sizeof(src->value)); xc_dprint_indent(indent); fprintf(stderr, "zval:value"); assert(sizeof(zval) == sizeof((&src->value)[0])); xc_dprint_zval( &src->value, indent TSRMLS_CC ); xc_dprint_indent(indent); fprintf(stderr, "int:flags:\t%d\n", src->flags); xc_dprint_indent(indent); fprintf(stderr, "uint:name_len:\t%u\n", src->name_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->name), src->name_len + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->name_len + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(ZSTR_S(src->name), src->name_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name_len + 1 - 1); } } #else if (ZSTR_S(src->name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(ZSTR_S(src->name), src->name_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name_len + 1 - 1); } #endif xc_dprint_indent(indent); fprintf(stderr, "int:module_number:\t%d\n", src->module_number); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #endif /* {{{ xc_dprint_zend_function */ /* * export: void xc_dprint_zend_function( * onst zend_function * const src, int indent * SRMLS_DC ); :export */ void xc_dprint_zend_function(const zend_function * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; switch (src->type) { case ZEND_INTERNAL_FUNCTION: case ZEND_OVERLOADED_FUNCTION: break; case ZEND_USER_FUNCTION: case ZEND_EVAL_CODE: assert(sizeof(zend_op_array) == sizeof(src->op_array)); xc_dprint_indent(indent); fprintf(stderr, "zend_op_array:op_array"); assert(sizeof(zend_op_array) == sizeof((&src->op_array)[0])); xc_dprint_zend_op_array( &src->op_array, indent TSRMLS_CC ); break; default: assert(0); } indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_dprint_zend_property_info */ static void inline xc_dprint_zend_property_info(const zend_property_info * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "zend_uint:flags:\t%u\n", src->flags); xc_dprint_indent(indent); fprintf(stderr, "int:name_length:\t%d\n", src->name_length); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->name), src->name_length + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->name_length + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(ZSTR_S(src->name), src->name_length + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name_length + 1 - 1); } } #else if (ZSTR_S(src->name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(ZSTR_S(src->name), src->name_length + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name_length + 1 - 1); } #endif xc_dprint_indent(indent); fprintf(stderr, "ulong:h:\t%lu\n", src->h); #ifdef ZEND_ENGINE_2_1 xc_dprint_indent(indent); fprintf(stderr, "int:doc_comment_len:\t%d\n", src->doc_comment_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->doc_comment), src->doc_comment_len + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->doc_comment"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->doc_comment_len + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->doc_comment"); xc_dprint_str_len(ZSTR_S(src->doc_comment), src->doc_comment_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->doc_comment_len + 1 - 1); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->doc_comment"); xc_dprint_str_len(ZSTR_S(src->doc_comment), src->doc_comment_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->doc_comment_len + 1 - 1); } #endif #endif #if defined(ZEND_ENGINE_2_2) && !defined(IS_UNICODE) if (src->ce) { } else { } #endif indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #endif /* {{{ xc_dprint_zend_class_entry */ /* * export: void xc_dprint_zend_class_entry( * onst zend_class_entry * const src, int indent * SRMLS_DC ); :export */ void xc_dprint_zend_class_entry(const zend_class_entry * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "char:type:\t%d\n", src->type); xc_dprint_indent(indent); fprintf(stderr, "zend_uint:name_length:\t%u\n", src->name_length); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->name), src->name_length + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->name_length + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(ZSTR_S(src->name), src->name_length + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name_length + 1 - 1); } } #else if (ZSTR_S(src->name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name"); xc_dprint_str_len(ZSTR_S(src->name), src->name_length + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name_length + 1 - 1); } #endif if (src->parent) { } else { } #ifdef ZEND_ENGINE_2 xc_dprint_indent(indent); fprintf(stderr, "int:refcount:\t%d\n", src->refcount); #else if (src->refcount) { xc_dprint_indent(indent); fprintf(stderr, "int:refcount"); assert(sizeof(int) == sizeof((src->refcount)[0])); /* allocate */ xc_dprint_int( src->refcount, indent TSRMLS_CC ); } else { xc_dprint_indent(indent); fprintf(stderr, "int:refcount:\tNULL\n"); } #endif xc_dprint_indent(indent); fprintf(stderr, "zend_bool:constants_updated:\t%u\n", src->constants_updated); #ifdef ZEND_ENGINE_2 xc_dprint_indent(indent); fprintf(stderr, "zend_uint:ce_flags:\t%u\n", src->ce_flags); #endif assert(sizeof(HashTable) == sizeof(src->default_properties)); xc_dprint_indent(indent); fprintf(stderr, "HashTable:default_properties"); assert(sizeof(HashTable) == sizeof((&src->default_properties)[0])); xc_dprint_HashTable_zval_ptr( &src->default_properties, indent TSRMLS_CC ); #ifdef ZEND_ENGINE_2 assert(sizeof(HashTable) == sizeof(src->properties_info)); xc_dprint_indent(indent); fprintf(stderr, "HashTable:properties_info"); assert(sizeof(HashTable) == sizeof((&src->properties_info)[0])); xc_dprint_HashTable_zend_property_info( &src->properties_info, indent TSRMLS_CC ); #ifdef ZEND_ENGINE_2_1 assert(sizeof(HashTable) == sizeof(src->default_static_members)); xc_dprint_indent(indent); fprintf(stderr, "HashTable:default_static_members"); assert(sizeof(HashTable) == sizeof((&src->default_static_members)[0])); xc_dprint_HashTable_zval_ptr( &src->default_static_members, indent TSRMLS_CC ); #else if (src->static_members) { xc_dprint_indent(indent); fprintf(stderr, "HashTable:static_members"); assert(sizeof(HashTable) == sizeof((src->static_members)[0])); /* allocate */ xc_dprint_HashTable_zval_ptr( src->static_members, indent TSRMLS_CC ); } else { xc_dprint_indent(indent); fprintf(stderr, "HashTable:static_members:\tNULL\n"); } #endif assert(sizeof(HashTable) == sizeof(src->constants_table)); xc_dprint_indent(indent); fprintf(stderr, "HashTable:constants_table"); assert(sizeof(HashTable) == sizeof((&src->constants_table)[0])); xc_dprint_HashTable_zval_ptr( &src->constants_table, indent TSRMLS_CC ); xc_dprint_indent(indent); fprintf(stderr, "zend_uint:num_interfaces:\t%u\n", src->num_interfaces); if (src->filename == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->filename"); xc_dprint_str_len(src->filename, strlen(src->filename) + 1 - 1); fprintf(stderr, "\" len=%d\n", strlen(src->filename) + 1 - 1); } xc_dprint_indent(indent); fprintf(stderr, "zend_uint:line_start:\t%u\n", src->line_start); xc_dprint_indent(indent); fprintf(stderr, "zend_uint:line_end:\t%u\n", src->line_end); #ifdef ZEND_ENGINE_2_1 xc_dprint_indent(indent); fprintf(stderr, "zend_uint:doc_comment_len:\t%u\n", src->doc_comment_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->doc_comment), src->doc_comment_len + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->doc_comment"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->doc_comment_len + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->doc_comment"); xc_dprint_str_len(ZSTR_S(src->doc_comment), src->doc_comment_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->doc_comment_len + 1 - 1); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->doc_comment"); xc_dprint_str_len(ZSTR_S(src->doc_comment), src->doc_comment_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->doc_comment_len + 1 - 1); } #endif #endif /* # NOT DONE */ /* deal with it inside xc_fix_method */ /* should be >5.1 */ #ifdef ZEND_ENGINE_2_1 #if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6 #endif #endif /* # NOT DONE */ #else #endif assert(sizeof(HashTable) == sizeof(src->function_table)); xc_dprint_indent(indent); fprintf(stderr, "HashTable:function_table"); assert(sizeof(HashTable) == sizeof((&src->function_table)[0])); xc_dprint_HashTable_zend_function( &src->function_table, indent TSRMLS_CC ); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ /* {{{ xc_dprint_znode */ static void inline xc_dprint_znode(const znode * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "int:op_type:\t%d %s\n", src->op_type, xc_get_op_type(src->op_type)); #ifdef IS_CV #define XCACHE_IS_CV IS_CV #else /* compatible with zend optimizer */ #define XCACHE_IS_CV 16 #endif assert(src->op_type == IS_CONST || src->op_type == IS_VAR || src->op_type == XCACHE_IS_CV || src->op_type == IS_TMP_VAR || src->op_type == IS_UNUSED); #undef XCACHE_IS_CV switch (src->op_type) { case IS_CONST: assert(sizeof(zval) == sizeof(src->u.constant)); xc_dprint_indent(indent); fprintf(stderr, "zval:u.constant"); assert(sizeof(zval) == sizeof((&src->u.constant)[0])); xc_dprint_zval( &src->u.constant, indent TSRMLS_CC ); break; case IS_VAR: case IS_TMP_VAR: #ifdef IS_CV case IS_CV: #else case 16: #endif xc_dprint_indent(indent); fprintf(stderr, "zend_uint:u.var:\t%u\n", src->u.var); xc_dprint_indent(indent); fprintf(stderr, "zend_uint:u.EA.type:\t%u\n", src->u.EA.type); break; case IS_UNUSED: xc_dprint_indent(indent); fprintf(stderr, "zend_uint:u.opline_num:\t%u\n", src->u.opline_num); #ifndef ZEND_ENGINE_2 xc_dprint_indent(indent); fprintf(stderr, "zend_uint:u.fetch_type:\t%u\n", src->u.fetch_type); #endif xc_dprint_indent(indent); fprintf(stderr, "zend_uint:u.EA.type:\t%u\n", src->u.EA.type); break; } indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ /* {{{ xc_dprint_zend_op */ /* * export: void xc_dprint_zend_op( const * zend_op * const src, int indent * SRMLS_DC ); :export */ void xc_dprint_zend_op(const zend_op * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "zend_uchar:opcode:\t%d %s\n", src->opcode, xc_get_opcode(src->opcode)); assert(sizeof(znode) == sizeof(src->result)); xc_dprint_indent(indent); fprintf(stderr, "znode:result"); assert(sizeof(znode) == sizeof((&src->result)[0])); xc_dprint_znode( &src->result, indent TSRMLS_CC ); assert(sizeof(znode) == sizeof(src->op1)); xc_dprint_indent(indent); fprintf(stderr, "znode:op1"); assert(sizeof(znode) == sizeof((&src->op1)[0])); xc_dprint_znode( &src->op1, indent TSRMLS_CC ); assert(sizeof(znode) == sizeof(src->op2)); xc_dprint_indent(indent); fprintf(stderr, "znode:op2"); assert(sizeof(znode) == sizeof((&src->op2)[0])); xc_dprint_znode( &src->op2, indent TSRMLS_CC ); xc_dprint_indent(indent); fprintf(stderr, "ulong:extended_value:\t%lu\n", src->extended_value); xc_dprint_indent(indent); fprintf(stderr, "uint:lineno:\t%u\n", src->lineno); #ifdef ZEND_ENGINE_2_1 /* is copying enough? */ #endif indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ /* {{{ xc_dprint_zend_op_array */ /* * export: void xc_dprint_zend_op_array( * onst zend_op_array * const src, int indent * SRMLS_DC ); :export */ void xc_dprint_zend_op_array(const zend_op_array * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; do { zend_uint ii; int i; /* Common elements */ xc_dprint_indent(indent); fprintf(stderr, "zend_uchar:type:\t%u\n", src->type); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->function_name) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->function_name), xc_zstrlen_uchar(src->function_name) + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->function_name"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", xc_zstrlen_uchar(src->function_name) + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->function_name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->function_name"); xc_dprint_str_len(ZSTR_S(src->function_name), xc_zstrlen_char(src->function_name) + 1 - 1); fprintf(stderr, "\" len=%d\n", xc_zstrlen_char(src->function_name) + 1 - 1); } } #else if (ZSTR_S(src->function_name) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->function_name"); xc_dprint_str_len(ZSTR_S(src->function_name), xc_zstrlen_char(src->function_name) + 1 - 1); fprintf(stderr, "\" len=%d\n", xc_zstrlen_char(src->function_name) + 1 - 1); } #endif #ifdef ZEND_ENGINE_2 xc_dprint_indent(indent); fprintf(stderr, "zend_uint:fn_flags:\t%u\n", src->fn_flags); if (src->arg_info) { /* allocate */ for (ii = 0; ii < src->num_args; ii++) { assert(sizeof(zend_arg_info) == sizeof(src->arg_info[ii])); xc_dprint_indent(indent); fprintf(stderr, "zend_arg_info:arg_info[ii]"); assert(sizeof(zend_arg_info) == sizeof((&src->arg_info[ii])[0])); xc_dprint_zend_arg_info( &src->arg_info[ii], indent TSRMLS_CC ); } } else { } xc_dprint_indent(indent); fprintf(stderr, "zend_uint:num_args:\t%u\n", src->num_args); xc_dprint_indent(indent); fprintf(stderr, "zend_uint:required_num_args:\t%u\n", src->required_num_args); xc_dprint_indent(indent); fprintf(stderr, "zend_bool:pass_rest_by_reference:\t%u\n", src->pass_rest_by_reference); #else if (src->arg_types) { /* allocate */ } else { } #endif xc_dprint_indent(indent); fprintf(stderr, "unsigned char:return_reference:\t%u\n", src->return_reference); /* END of common elements */ #ifdef IS_UNICODE #endif if (src->refcount) { xc_dprint_indent(indent); fprintf(stderr, "zend_uint:refcount"); assert(sizeof(zend_uint) == sizeof((src->refcount)[0])); /* allocate */ xc_dprint_zend_uint( src->refcount, indent TSRMLS_CC ); } else { xc_dprint_indent(indent); fprintf(stderr, "zend_uint:refcount:\tNULL\n"); } if (src->opcodes) { /* allocate */ for (ii = 0; ii < src->last; ii++) { assert(sizeof(zend_op) == sizeof(src->opcodes[ii])); xc_dprint_indent(indent); fprintf(stderr, "zend_op:opcodes[ii]"); assert(sizeof(zend_op) == sizeof((&src->opcodes[ii])[0])); xc_dprint_zend_op( &src->opcodes[ii], indent TSRMLS_CC ); } } else { } xc_dprint_indent(indent); fprintf(stderr, "zend_uint:last:\t%u\n", src->last); xc_dprint_indent(indent); fprintf(stderr, "zend_uint:size:\t%u\n", src->size); #ifdef IS_CV if (src->vars) { /* allocate */ for (i = 0; i < src->last_var; i++) { assert(sizeof(zend_compiled_variable) == sizeof(src->vars[i])); xc_dprint_indent(indent); fprintf(stderr, "zend_compiled_variable:vars[i]"); assert(sizeof(zend_compiled_variable) == sizeof((&src->vars[i])[0])); xc_dprint_zend_compiled_variable( &src->vars[i], indent TSRMLS_CC ); } } else { } xc_dprint_indent(indent); fprintf(stderr, "int:last_var:\t%d\n", src->last_var); xc_dprint_indent(indent); fprintf(stderr, "zend_uint:size_var:\t%u\n", src->size_var); #else #endif xc_dprint_indent(indent); fprintf(stderr, "zend_uint:T:\t%u\n", src->T); if (src->brk_cont_array) { /* allocate */ for (ii = 0; ii < src->last_brk_cont; ii++) { assert(sizeof(zend_brk_cont_element) == sizeof(src->brk_cont_array[ii])); xc_dprint_indent(indent); fprintf(stderr, "zend_brk_cont_element:brk_cont_array[ii]"); assert(sizeof(zend_brk_cont_element) == sizeof((&src->brk_cont_array[ii])[0])); xc_dprint_zend_brk_cont_element( &src->brk_cont_array[ii], indent TSRMLS_CC ); } } else { } xc_dprint_indent(indent); fprintf(stderr, "zend_uint:last_brk_cont:\t%u\n", src->last_brk_cont); xc_dprint_indent(indent); fprintf(stderr, "zend_uint:current_brk_cont:\t%u\n", src->current_brk_cont); #ifndef ZEND_ENGINE_2 xc_dprint_indent(indent); fprintf(stderr, "zend_bool:uses_globals:\t%u\n", src->uses_globals); #endif #ifdef ZEND_ENGINE_2 if (src->try_catch_array) { /* allocate */ for (i = 0; i < src->last_try_catch; i++) { assert(sizeof(zend_try_catch_element) == sizeof(src->try_catch_array[i])); xc_dprint_indent(indent); fprintf(stderr, "zend_try_catch_element:try_catch_array[i]"); assert(sizeof(zend_try_catch_element) == sizeof((&src->try_catch_array[i])[0])); xc_dprint_zend_try_catch_element( &src->try_catch_array[i], indent TSRMLS_CC ); } } else { } xc_dprint_indent(indent); fprintf(stderr, "int:last_try_catch:\t%d\n", src->last_try_catch); #endif if (src->static_variables) { xc_dprint_indent(indent); fprintf(stderr, "HashTable:static_variables"); assert(sizeof(HashTable) == sizeof((src->static_variables)[0])); /* allocate */ xc_dprint_HashTable_zval_ptr( src->static_variables, indent TSRMLS_CC ); } else { xc_dprint_indent(indent); fprintf(stderr, "HashTable:static_variables:\tNULL\n"); } xc_dprint_indent(indent); fprintf(stderr, "int:backpatch_count:\t%d\n", src->backpatch_count); xc_dprint_indent(indent); fprintf(stderr, "zend_bool:done_pass_two:\t%u\n", src->done_pass_two); #ifdef ZEND_ENGINE_2 xc_dprint_indent(indent); fprintf(stderr, "zend_bool:uses_this:\t%u\n", src->uses_this); #endif if (src->filename == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->filename"); xc_dprint_str_len(src->filename, strlen(src->filename) + 1 - 1); fprintf(stderr, "\" len=%d\n", strlen(src->filename) + 1 - 1); } #ifdef IS_UNICODE if (src->script_encoding == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->script_encoding"); xc_dprint_str_len(src->script_encoding, strlen(src->script_encoding) + 1 - 1); fprintf(stderr, "\" len=%d\n", strlen(src->script_encoding) + 1 - 1); } #endif #ifdef ZEND_ENGINE_2 xc_dprint_indent(indent); fprintf(stderr, "zend_uint:line_start:\t%u\n", src->line_start); xc_dprint_indent(indent); fprintf(stderr, "zend_uint:line_end:\t%u\n", src->line_end); xc_dprint_indent(indent); fprintf(stderr, "int:doc_comment_len:\t%d\n", src->doc_comment_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->doc_comment), src->doc_comment_len + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->doc_comment"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->doc_comment_len + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->doc_comment"); xc_dprint_str_len(ZSTR_S(src->doc_comment), src->doc_comment_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->doc_comment_len + 1 - 1); } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->doc_comment"); xc_dprint_str_len(ZSTR_S(src->doc_comment), src->doc_comment_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->doc_comment_len + 1 - 1); } #endif #endif /* reserved */ #if defined(HARDENING_PATCH) && HARDENING_PATCH xc_dprint_indent(indent); fprintf(stderr, "zend_bool:created_by_eval:\t%u\n", src->created_by_eval); #endif } while (0); #ifdef ZEND_ENGINE_2 #endif #ifdef ZEND_ENGINE_2 if (src->scope) { } else { } #endif indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_dprint_xc_constinfo_t */ static void inline xc_dprint_xc_constinfo_t(const xc_constinfo_t * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "zend_uint:key_size:\t%u\n", src->key_size); #ifdef IS_UNICODE xc_dprint_indent(indent); fprintf(stderr, "zend_uchar:type:\t%u\n", src->type); #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->key), src->key_size - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->key_size - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->key) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(ZSTR_S(src->key), src->key_size - 1); fprintf(stderr, "\" len=%d\n", src->key_size - 1); } } #else if (ZSTR_S(src->key) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(ZSTR_S(src->key), src->key_size - 1); fprintf(stderr, "\" len=%d\n", src->key_size - 1); } #endif assert(sizeof(zend_constant) == sizeof(src->constant)); xc_dprint_indent(indent); fprintf(stderr, "zend_constant:constant"); assert(sizeof(zend_constant) == sizeof((&src->constant)[0])); xc_dprint_zend_constant( &src->constant, indent TSRMLS_CC ); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #endif /* {{{ xc_dprint_xc_funcinfo_t */ /* * export: void xc_dprint_xc_funcinfo_t( * onst xc_funcinfo_t * const src, int indent * SRMLS_DC ); :export */ void xc_dprint_xc_funcinfo_t(const xc_funcinfo_t * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "zend_uint:key_size:\t%u\n", src->key_size); #ifdef IS_UNICODE xc_dprint_indent(indent); fprintf(stderr, "zend_uchar:type:\t%u\n", src->type); #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->key), src->key_size - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->key_size - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->key) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(ZSTR_S(src->key), src->key_size - 1); fprintf(stderr, "\" len=%d\n", src->key_size - 1); } } #else if (ZSTR_S(src->key) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(ZSTR_S(src->key), src->key_size - 1); fprintf(stderr, "\" len=%d\n", src->key_size - 1); } #endif assert(sizeof(zend_function) == sizeof(src->func)); xc_dprint_indent(indent); fprintf(stderr, "zend_function:func"); assert(sizeof(zend_function) == sizeof((&src->func)[0])); xc_dprint_zend_function( &src->func, indent TSRMLS_CC ); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ /* {{{ xc_dprint_xc_classinfo_t */ /* * export: void xc_dprint_xc_classinfo_t( * onst xc_classinfo_t * const src, int indent * SRMLS_DC ); :export */ void xc_dprint_xc_classinfo_t(const xc_classinfo_t * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "zend_uint:key_size:\t%u\n", src->key_size); #ifdef IS_UNICODE xc_dprint_indent(indent); fprintf(stderr, "zend_uchar:type:\t%u\n", src->type); #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->key), src->key_size - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->key_size - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->key) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(ZSTR_S(src->key), src->key_size - 1); fprintf(stderr, "\" len=%d\n", src->key_size - 1); } } #else if (ZSTR_S(src->key) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(ZSTR_S(src->key), src->key_size - 1); fprintf(stderr, "\" len=%d\n", src->key_size - 1); } #endif #ifdef ZEND_ENGINE_2 if (src->cest) { xc_dprint_indent(indent); fprintf(stderr, "zend_class_entry:cest"); assert(sizeof(zend_class_entry) == sizeof((src->cest)[0])); /* allocate */ xc_dprint_zend_class_entry( src->cest, indent TSRMLS_CC ); } else { xc_dprint_indent(indent); fprintf(stderr, "zend_class_entry:cest:\tNULL\n"); } #else assert(sizeof(zend_class_entry) == sizeof(src->cest)); xc_dprint_indent(indent); fprintf(stderr, "zend_class_entry:cest"); assert(sizeof(zend_class_entry) == sizeof((&src->cest)[0])); xc_dprint_zend_class_entry( &src->cest, indent TSRMLS_CC ); #endif xc_dprint_indent(indent); fprintf(stderr, "int:oplineno:\t%d\n", src->oplineno); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #ifdef ZEND_ENGINE_2_1 /* {{{ xc_dprint_xc_autoglobal_t */ static void inline xc_dprint_xc_autoglobal_t(const xc_autoglobal_t * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "zend_uint:key_len:\t%u\n", src->key_len); #ifdef IS_UNICODE xc_dprint_indent(indent); fprintf(stderr, "zend_uchar:type:\t%u\n", src->type); #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->key), src->key_len + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->key_len + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->key) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(ZSTR_S(src->key), src->key_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->key_len + 1 - 1); } } #else if (ZSTR_S(src->key) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->key"); xc_dprint_str_len(ZSTR_S(src->key), src->key_len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->key_len + 1 - 1); } #endif indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #endif /* {{{ xc_dprint_xc_entry_data_php_t */ static void inline xc_dprint_xc_entry_data_php_t(const xc_entry_data_php_t * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; zend_uint i; #ifdef HAVE_INODE xc_dprint_indent(indent); fprintf(stderr, "int:device:\t%d\n", src->device); xc_dprint_indent(indent); fprintf(stderr, "int:inode:\t%d\n", src->inode); #endif xc_dprint_indent(indent); fprintf(stderr, "size_t:sourcesize:\t%u\n", src->sourcesize); xc_dprint_indent(indent); fprintf(stderr, "time_t:mtime:\t%ld\n", src->mtime); if (src->op_array) { xc_dprint_indent(indent); fprintf(stderr, "zend_op_array:op_array"); assert(sizeof(zend_op_array) == sizeof((src->op_array)[0])); /* allocate */ xc_dprint_zend_op_array( src->op_array, indent TSRMLS_CC ); } else { xc_dprint_indent(indent); fprintf(stderr, "zend_op_array:op_array:\tNULL\n"); } #ifdef HAVE_XCACHE_CONSTANT xc_dprint_indent(indent); fprintf(stderr, "zend_uint:constinfo_cnt:\t%u\n", src->constinfo_cnt); if (src->constinfos) { /* allocate */ for (i = 0; i < src->constinfo_cnt; i++) { assert(sizeof(xc_constinfo_t) == sizeof(src->constinfos[i])); xc_dprint_indent(indent); fprintf(stderr, "xc_constinfo_t:constinfos[i]"); assert(sizeof(xc_constinfo_t) == sizeof((&src->constinfos[i])[0])); xc_dprint_xc_constinfo_t( &src->constinfos[i], indent TSRMLS_CC ); } } else { } #endif xc_dprint_indent(indent); fprintf(stderr, "zend_uint:funcinfo_cnt:\t%u\n", src->funcinfo_cnt); if (src->funcinfos) { /* allocate */ for (i = 0; i < src->funcinfo_cnt; i++) { assert(sizeof(xc_funcinfo_t) == sizeof(src->funcinfos[i])); xc_dprint_indent(indent); fprintf(stderr, "xc_funcinfo_t:funcinfos[i]"); assert(sizeof(xc_funcinfo_t) == sizeof((&src->funcinfos[i])[0])); xc_dprint_xc_funcinfo_t( &src->funcinfos[i], indent TSRMLS_CC ); } } else { } xc_dprint_indent(indent); fprintf(stderr, "zend_uint:classinfo_cnt:\t%u\n", src->classinfo_cnt); if (src->classinfos) { /* allocate */ for (i = 0; i < src->classinfo_cnt; i++) { assert(sizeof(xc_classinfo_t) == sizeof(src->classinfos[i])); xc_dprint_indent(indent); fprintf(stderr, "xc_classinfo_t:classinfos[i]"); assert(sizeof(xc_classinfo_t) == sizeof((&src->classinfos[i])[0])); xc_dprint_xc_classinfo_t( &src->classinfos[i], indent TSRMLS_CC ); } } else { } #ifdef ZEND_ENGINE_2_1 xc_dprint_indent(indent); fprintf(stderr, "zend_uint:autoglobal_cnt:\t%u\n", src->autoglobal_cnt); if (src->autoglobals) { /* allocate */ for (i = 0; i < src->autoglobal_cnt; i++) { assert(sizeof(xc_autoglobal_t) == sizeof(src->autoglobals[i])); xc_dprint_indent(indent); fprintf(stderr, "xc_autoglobal_t:autoglobals[i]"); assert(sizeof(xc_autoglobal_t) == sizeof((&src->autoglobals[i])[0])); xc_dprint_xc_autoglobal_t( &src->autoglobals[i], indent TSRMLS_CC ); } } else { } #endif xc_dprint_indent(indent); fprintf(stderr, "zend_bool:have_early_binding:\t%u\n", src->have_early_binding); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ /* {{{ xc_dprint_xc_entry_data_var_t */ static void inline xc_dprint_xc_entry_data_var_t(const xc_entry_data_var_t * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "zval:value"); assert(sizeof(zval_ptr) == sizeof((&src->value)[0])); xc_dprint_zval_ptr( &src->value, indent TSRMLS_CC ); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ /* {{{ xc_dprint_xc_entry_t */ /* * export: void xc_dprint_xc_entry_t( const * xc_entry_t * const src, int indent * SRMLS_DC ); :export */ void xc_dprint_xc_entry_t(const xc_entry_t * const src, int indent TSRMLS_DC) { fprintf(stderr, "%s", " {\n"); indent++; xc_dprint_indent(indent); fprintf(stderr, "xc_entry_type_t:type:\t%d\n", src->type); xc_dprint_indent(indent); fprintf(stderr, "size_t:size:\t%u\n", src->size); xc_dprint_indent(indent); fprintf(stderr, "xc_hash_value_t:hvalue:\t%lu\n", src->hvalue); /* skip */ xc_dprint_indent(indent); fprintf(stderr, "long:refcount:\t%ld\n", src->refcount); xc_dprint_indent(indent); fprintf(stderr, "time_t:ctime:\t%ld\n", src->ctime); xc_dprint_indent(indent); fprintf(stderr, "time_t:atime:\t%ld\n", src->atime); xc_dprint_indent(indent); fprintf(stderr, "time_t:dtime:\t%ld\n", src->dtime); xc_dprint_indent(indent); fprintf(stderr, "long:ttl:\t%ld\n", src->ttl); xc_dprint_indent(indent); fprintf(stderr, "zend_ulong:hits:\t%lu\n", src->hits); #ifdef IS_UNICODE xc_dprint_indent(indent); fprintf(stderr, "zend_uchar:name_type:\t%u\n", src->name_type); #endif #ifdef IS_UNICODE if (src->name_type == IS_UNICODE) { xc_dprint_indent(indent); fprintf(stderr, "int32_t:name.ustr.len:\t%d\n", src->name.ustr.len); } else { xc_dprint_indent(indent); fprintf(stderr, "int:name.str.len:\t%d\n", src->name.str.len); } #else xc_dprint_indent(indent); fprintf(stderr, "int:name.str.len:\t%d\n", src->name.str.len); #endif #ifdef IS_UNICODE #ifdef IS_UNICODE if (src->name_type == IS_UNICODE) { if (ZSTR_U(src->name.uni.val) == NULL) { } else { xc_dprint_indent(indent); #ifdef IS_UNICODE do { zval zv; zval reszv; int usecopy; INIT_ZVAL(zv); ZVAL_UNICODEL(&zv, (UChar *) (src->name.uni.val), src->name.uni.len + 1 - 1, 1); zend_make_printable_zval(&zv, &reszv, &usecopy); fprintf(stderr, "string:%s:\t\"", "dst->name.uni.val"); xc_dprint_str_len(Z_STRVAL(reszv), Z_STRLEN(reszv)); fprintf(stderr, "\" len=%d\n", src->name.uni.len + 1 - 1); if (usecopy) { zval_dtor(&reszv); } zval_dtor(&zv); } while (0); #endif } } else { if (ZSTR_S(src->name.uni.val) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name.uni.val"); xc_dprint_str_len(ZSTR_S(src->name.uni.val), src->name.uni.len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name.uni.len + 1 - 1); } } #else if (ZSTR_S(src->name.uni.val) == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name.uni.val"); xc_dprint_str_len(ZSTR_S(src->name.uni.val), src->name.uni.len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name.uni.len + 1 - 1); } #endif #else if (src->name.str.val == NULL) { } else { xc_dprint_indent(indent); fprintf(stderr, "string:%s:\t\"", "dst->name.str.val"); xc_dprint_str_len(src->name.str.val, src->name.str.len + 1 - 1); fprintf(stderr, "\" len=%d\n", src->name.str.len + 1 - 1); } #endif switch (src->type) { case XC_TYPE_PHP: if (src->data.php) { xc_dprint_indent(indent); fprintf(stderr, "xc_entry_data_php_t:data.php"); assert(sizeof(xc_entry_data_php_t) == sizeof((src->data.php)[0])); /* allocate */ xc_dprint_xc_entry_data_php_t( src->data.php, indent TSRMLS_CC ); } else { xc_dprint_indent(indent); fprintf(stderr, "xc_entry_data_php_t:data.php:\tNULL\n"); } break; case XC_TYPE_VAR: if (src->data.var) { xc_dprint_indent(indent); fprintf(stderr, "xc_entry_data_var_t:data.var"); assert(sizeof(xc_entry_data_var_t) == sizeof((src->data.var)[0])); /* allocate */ xc_dprint_xc_entry_data_var_t( src->data.var, indent TSRMLS_CC ); } else { xc_dprint_indent(indent); fprintf(stderr, "xc_entry_data_var_t:data.var:\tNULL\n"); } break; default: assert(0); } xc_dprint_indent(indent); fprintf(stderr, "zend_bool:have_references:\t%u\n", src->have_references); indent--; xc_dprint_indent(indent); fprintf(stderr, "}\n"); } /* }}} */ #endif /* HAVE_XCACHE_DPRINT */ #ifdef HAVE_XCACHE_DISASSEMBLER /* {{{ Pre-declare */ void xc_dasm_zval(zval * dst, const zval * const src TSRMLS_DC); static void inline xc_dasm_zval_ptr(zval * dst, const zval_ptr * const src TSRMLS_DC); void xc_dasm_zend_op_array(zval * dst, const zend_op_array * const src TSRMLS_DC); void xc_dasm_zend_class_entry(zval * dst, const zend_class_entry * const src TSRMLS_DC); #ifdef HAVE_XCACHE_CONSTANT static void inline xc_dasm_zend_constant(zval * dst, const zend_constant * const src TSRMLS_DC); #endif void xc_dasm_zend_function(zval * dst, const zend_function * const src TSRMLS_DC); void xc_dasm_xc_entry_t(zval * dst, const xc_entry_t * const src TSRMLS_DC); #ifdef ZEND_ENGINE_2 static void inline xc_dasm_zend_property_info(zval * dst, const zend_property_info * const src TSRMLS_DC); #endif /* }}} */ #ifdef IS_CV /* {{{ xc_dasm_zend_compiled_variable */ static void inline xc_dasm_zend_compiled_variable(zval * dst, const zend_compiled_variable * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("name_len"), (sizeof("name_len")), src->name_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_unicodel_ex(dst, ("name"), (sizeof("name")), src->name, src->name_len + 1 - 1, 1); } } else { if (ZSTR_S(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_stringl_ex(dst, ("name"), (sizeof("name")), src->name, src->name_len + 1 - 1, 1); } } #else if (ZSTR_S(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_stringl_ex(dst, ("name"), (sizeof("name")), src->name, src->name_len + 1 - 1, 1); } #endif add_assoc_long_ex(dst, ("hash_value"), (sizeof("hash_value")), src->hash_value); } /* }}} */ #endif /* {{{ xc_dasm_zend_uint */ static void inline xc_dasm_zend_uint(zval * dst, const zend_uint * const src TSRMLS_DC) { } /* }}} */ #ifndef ZEND_ENGINE_2 /* {{{ xc_dasm_int */ static void inline xc_dasm_int(zval * dst, const int *const src TSRMLS_DC) { } /* }}} */ #endif #ifdef ZEND_ENGINE_2 /* {{{ xc_dasm_zend_try_catch_element */ static void inline xc_dasm_zend_try_catch_element(zval * dst, const zend_try_catch_element * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("try_op"), (sizeof("try_op")), src->try_op); add_assoc_long_ex(dst, ("catch_op"), (sizeof("catch_op")), src->catch_op); } /* }}} */ #endif /* ifdef ZEND_ENGINE_2 */ /* {{{ xc_dasm_zend_brk_cont_element */ static void inline xc_dasm_zend_brk_cont_element(zval * dst, const zend_brk_cont_element * const src TSRMLS_DC) { #ifdef ZEND_ENGINE_2_2 #ifndef IS_UNICODE add_assoc_long_ex(dst, ("start"), (sizeof("start")), src->start); #endif #endif add_assoc_long_ex(dst, ("cont"), (sizeof("cont")), src->cont); add_assoc_long_ex(dst, ("brk"), (sizeof("brk")), src->brk); add_assoc_long_ex(dst, ("parent"), (sizeof("parent")), src->parent); } /* }}} */ /* {{{ xc_dasm_HashTable_zval_ptr */ static void inline xc_dasm_HashTable_zval_ptr(zval * dst, const HashTable * const src TSRMLS_DC) { Bucket *b; zval *zv; int bufsize = 2; char *buf = emalloc(bufsize); int keysize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif #if ZEND_DEBUG #endif #ifdef IS_UNICODE #endif for (b = src->pListHead; b != NULL; b = b->pListNext) { ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zval_ptr(zv, ((zval_ptr *) b->pData) TSRMLS_CC); keysize = BUCKET_KEY_SIZE(b) + 2; if (keysize > bufsize) { do { bufsize *= 2; } while (keysize > bufsize); buf = erealloc(buf, bufsize); } memcpy(buf, BUCKET_KEY_S(b), keysize); buf[keysize - 2] = buf[keysize - 1] = ""[0]; keysize = b->nKeyLength; #ifdef IS_UNICODE if (BUCKET_KEY_TYPE(b) == IS_UNICODE) { if (buf[0] == ""[0] && buf[1] == ""[0]) { keysize++; } } else #endif { if (buf[0] == ""[0]) { keysize++; } } add_u_assoc_zval_ex(dst, BUCKET_KEY_TYPE(b), buf, keysize, zv); } efree(buf); return; /* no check size */ } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_dasm_HashTable_zend_constant */ static void inline xc_dasm_HashTable_zend_constant(zval * dst, const HashTable * const src TSRMLS_DC) { Bucket *b; zval *zv; int bufsize = 2; char *buf = emalloc(bufsize); int keysize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif #if ZEND_DEBUG #endif #ifdef IS_UNICODE #endif for (b = src->pListHead; b != NULL; b = b->pListNext) { ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_constant(zv, ((zend_constant *) b->pData) TSRMLS_CC); keysize = BUCKET_KEY_SIZE(b) + 2; if (keysize > bufsize) { do { bufsize *= 2; } while (keysize > bufsize); buf = erealloc(buf, bufsize); } memcpy(buf, BUCKET_KEY_S(b), keysize); buf[keysize - 2] = buf[keysize - 1] = ""[0]; keysize = b->nKeyLength; #ifdef IS_UNICODE if (BUCKET_KEY_TYPE(b) == IS_UNICODE) { if (buf[0] == ""[0] && buf[1] == ""[0]) { keysize++; } } else #endif { if (buf[0] == ""[0]) { keysize++; } } add_u_assoc_zval_ex(dst, BUCKET_KEY_TYPE(b), buf, keysize, zv); } efree(buf); return; /* no check size */ } /* }}} */ #endif /* {{{ xc_dasm_HashTable_zend_function */ /* * export: void xc_dasm_HashTable_zend_function( * val *dst, const HashTable * const src * _DC ); :export */ void xc_dasm_HashTable_zend_function(zval * dst, const HashTable * const src TSRMLS_DC) { Bucket *b; zval *zv; int bufsize = 2; char *buf = emalloc(bufsize); int keysize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif #if ZEND_DEBUG #endif #ifdef IS_UNICODE #endif for (b = src->pListHead; b != NULL; b = b->pListNext) { ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_function(zv, ((zend_function *) b->pData) TSRMLS_CC); keysize = BUCKET_KEY_SIZE(b) + 2; if (keysize > bufsize) { do { bufsize *= 2; } while (keysize > bufsize); buf = erealloc(buf, bufsize); } memcpy(buf, BUCKET_KEY_S(b), keysize); buf[keysize - 2] = buf[keysize - 1] = ""[0]; keysize = b->nKeyLength; #ifdef IS_UNICODE if (BUCKET_KEY_TYPE(b) == IS_UNICODE) { if (buf[0] == ""[0] && buf[1] == ""[0]) { keysize++; } } else #endif { if (buf[0] == ""[0]) { keysize++; } } add_u_assoc_zval_ex(dst, BUCKET_KEY_TYPE(b), buf, keysize, zv); } efree(buf); return; /* no check size */ } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_dasm_HashTable_zend_property_info */ static void inline xc_dasm_HashTable_zend_property_info(zval * dst, const HashTable * const src TSRMLS_DC) { Bucket *b; zval *zv; int bufsize = 2; char *buf = emalloc(bufsize); int keysize; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT #endif #if ZEND_DEBUG #endif #ifdef IS_UNICODE #endif for (b = src->pListHead; b != NULL; b = b->pListNext) { ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_property_info(zv, ((zend_property_info *) b->pData) TSRMLS_CC); keysize = BUCKET_KEY_SIZE(b) + 2; if (keysize > bufsize) { do { bufsize *= 2; } while (keysize > bufsize); buf = erealloc(buf, bufsize); } memcpy(buf, BUCKET_KEY_S(b), keysize); buf[keysize - 2] = buf[keysize - 1] = ""[0]; keysize = b->nKeyLength; #ifdef IS_UNICODE if (BUCKET_KEY_TYPE(b) == IS_UNICODE) { if (buf[0] == ""[0] && buf[1] == ""[0]) { keysize++; } } else #endif { if (buf[0] == ""[0]) { keysize++; } } add_u_assoc_zval_ex(dst, BUCKET_KEY_TYPE(b), buf, keysize, zv); } efree(buf); return; /* no check size */ } /* }}} */ #endif /* {{{ xc_dasm_zval */ /* * export: void xc_dasm_zval( * val *dst, const zval * const src TSRMLS_DC * ); :export */ void xc_dasm_zval(zval * dst, const zval * const src TSRMLS_DC) { do { zval_dtor(dst); *dst = *src; zval_copy_ctor(dst); ZVAL_REFCOUNT(dst) = 1; } while (0); return; } /* }}} */ /* {{{ xc_dasm_zval_ptr */ static void inline xc_dasm_zval_ptr(zval * dst, const zval_ptr * const src TSRMLS_DC) { xc_dasm_zval(dst, src[0] TSRMLS_CC); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_dasm_zend_arg_info */ static void inline xc_dasm_zend_arg_info(zval * dst, const zend_arg_info * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("name_len"), (sizeof("name_len")), src->name_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_unicodel_ex(dst, ("name"), (sizeof("name")), src->name, src->name_len + 1 - 1, 1); } } else { if (ZSTR_S(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_stringl_ex(dst, ("name"), (sizeof("name")), src->name, src->name_len + 1 - 1, 1); } } #else if (ZSTR_S(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_stringl_ex(dst, ("name"), (sizeof("name")), src->name, src->name_len + 1 - 1, 1); } #endif add_assoc_long_ex(dst, ("class_name_len"), (sizeof("class_name_len")), src->class_name_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->class_name) == NULL) { add_assoc_null_ex(dst, ("class_name"), (sizeof("class_name"))); } else { add_assoc_unicodel_ex(dst, ("class_name"), (sizeof("class_name")), src->class_name, src->class_name_len + 1 - 1, 1); } } else { if (ZSTR_S(src->class_name) == NULL) { add_assoc_null_ex(dst, ("class_name"), (sizeof("class_name"))); } else { add_assoc_stringl_ex(dst, ("class_name"), (sizeof("class_name")), src->class_name, src->class_name_len + 1 - 1, 1); } } #else if (ZSTR_S(src->class_name) == NULL) { add_assoc_null_ex(dst, ("class_name"), (sizeof("class_name"))); } else { add_assoc_stringl_ex(dst, ("class_name"), (sizeof("class_name")), src->class_name, src->class_name_len + 1 - 1, 1); } #endif add_assoc_bool_ex(dst, ("array_type_hint"), (sizeof("array_type_hint")), src->array_type_hint ? 1 : 0); add_assoc_bool_ex(dst, ("allow_null"), (sizeof("allow_null")), src->allow_null ? 1 : 0); add_assoc_bool_ex(dst, ("pass_by_reference"), (sizeof("pass_by_reference")), src->pass_by_reference ? 1 : 0); add_assoc_bool_ex(dst, ("return_reference"), (sizeof("return_reference")), src->return_reference ? 1 : 0); add_assoc_long_ex(dst, ("required_num_args"), (sizeof("required_num_args")), src->required_num_args); } /* }}} */ #endif #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_dasm_zend_constant */ static void inline xc_dasm_zend_constant(zval * dst, const zend_constant * const src TSRMLS_DC) { assert(sizeof(zval) == sizeof(src->value)); assert(sizeof(zval) == sizeof((&src->value)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zval( zv, &src->value TSRMLS_CC ); add_assoc_zval_ex(dst, ("value"), (sizeof("value")), zv); } while (0); add_assoc_long_ex(dst, ("flags"), (sizeof("flags")), src->flags); add_assoc_long_ex(dst, ("name_len"), (sizeof("name_len")), src->name_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_unicodel_ex(dst, ("name"), (sizeof("name")), src->name, src->name_len + 1 - 1, 1); } } else { if (ZSTR_S(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_stringl_ex(dst, ("name"), (sizeof("name")), src->name, src->name_len + 1 - 1, 1); } } #else if (ZSTR_S(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_stringl_ex(dst, ("name"), (sizeof("name")), src->name, src->name_len + 1 - 1, 1); } #endif add_assoc_long_ex(dst, ("module_number"), (sizeof("module_number")), src->module_number); } /* }}} */ #endif /* {{{ xc_dasm_zend_function */ /* * export: void xc_dasm_zend_function( * val *dst, const zend_function * const src * _DC ); :export */ void xc_dasm_zend_function(zval * dst, const zend_function * const src TSRMLS_DC) { switch (src->type) { case ZEND_INTERNAL_FUNCTION: case ZEND_OVERLOADED_FUNCTION: break; case ZEND_USER_FUNCTION: case ZEND_EVAL_CODE: assert(sizeof(zend_op_array) == sizeof(src->op_array)); assert(sizeof(zend_op_array) == sizeof((&src->op_array)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_op_array( zv, &src->op_array TSRMLS_CC ); add_assoc_zval_ex(dst, ("op_array"), (sizeof("op_array")), zv); } while (0); break; default: assert(0); } } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_dasm_zend_property_info */ static void inline xc_dasm_zend_property_info(zval * dst, const zend_property_info * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("flags"), (sizeof("flags")), src->flags); add_assoc_long_ex(dst, ("name_length"), (sizeof("name_length")), src->name_length); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_unicodel_ex(dst, ("name"), (sizeof("name")), src->name, src->name_length + 1 - 1, 1); } } else { if (ZSTR_S(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_stringl_ex(dst, ("name"), (sizeof("name")), src->name, src->name_length + 1 - 1, 1); } } #else if (ZSTR_S(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_stringl_ex(dst, ("name"), (sizeof("name")), src->name, src->name_length + 1 - 1, 1); } #endif add_assoc_long_ex(dst, ("h"), (sizeof("h")), src->h); #ifdef ZEND_ENGINE_2_1 add_assoc_long_ex(dst, ("doc_comment_len"), (sizeof("doc_comment_len")), src->doc_comment_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { add_assoc_null_ex(dst, ("doc_comment"), (sizeof("doc_comment"))); } else { add_assoc_unicodel_ex(dst, ("doc_comment"), (sizeof("doc_comment")), src->doc_comment, src->doc_comment_len + 1 - 1, 1); } } else { if (ZSTR_S(src->doc_comment) == NULL) { add_assoc_null_ex(dst, ("doc_comment"), (sizeof("doc_comment"))); } else { add_assoc_stringl_ex(dst, ("doc_comment"), (sizeof("doc_comment")), src->doc_comment, src->doc_comment_len + 1 - 1, 1); } } #else if (ZSTR_S(src->doc_comment) == NULL) { add_assoc_null_ex(dst, ("doc_comment"), (sizeof("doc_comment"))); } else { add_assoc_stringl_ex(dst, ("doc_comment"), (sizeof("doc_comment")), src->doc_comment, src->doc_comment_len + 1 - 1, 1); } #endif #endif #if defined(ZEND_ENGINE_2_2) && !defined(IS_UNICODE) if (src->ce) { add_assoc_stringl_ex(dst, ("ce"), (sizeof("ce")), src->ce->name, strlen(src->ce->name), 1); } else { add_assoc_null_ex(dst, ("ce"), (sizeof("ce"))); } #endif } /* }}} */ #endif /* {{{ xc_dasm_zend_class_entry */ /* * export: void xc_dasm_zend_class_entry( * val *dst, const zend_class_entry * const src * SRMLS_DC ); :export */ void xc_dasm_zend_class_entry(zval * dst, const zend_class_entry * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("type"), (sizeof("type")), src->type); add_assoc_long_ex(dst, ("name_length"), (sizeof("name_length")), src->name_length); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_unicodel_ex(dst, ("name"), (sizeof("name")), src->name, src->name_length + 1 - 1, 1); } } else { if (ZSTR_S(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_stringl_ex(dst, ("name"), (sizeof("name")), src->name, src->name_length + 1 - 1, 1); } } #else if (ZSTR_S(src->name) == NULL) { add_assoc_null_ex(dst, ("name"), (sizeof("name"))); } else { add_assoc_stringl_ex(dst, ("name"), (sizeof("name")), src->name, src->name_length + 1 - 1, 1); } #endif if (src->parent) { add_assoc_stringl_ex(dst, ("parent"), (sizeof("parent")), src->parent->name, strlen(src->parent->name), 1); } else { add_assoc_null_ex(dst, ("parent"), (sizeof("parent"))); } #ifdef ZEND_ENGINE_2 add_assoc_long_ex(dst, ("refcount"), (sizeof("refcount")), src->refcount); #else if (src->refcount) { assert(sizeof(int) == sizeof((src->refcount)[0])); /* allocate */ do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_int( zv, src->refcount TSRMLS_CC ); add_assoc_zval_ex(dst, ("refcount"), (sizeof("refcount")), zv); } while (0); } else { add_assoc_null_ex(dst, ("refcount"), (sizeof("refcount"))); } #endif add_assoc_bool_ex(dst, ("constants_updated"), (sizeof("constants_updated")), src->constants_updated ? 1 : 0); #ifdef ZEND_ENGINE_2 add_assoc_long_ex(dst, ("ce_flags"), (sizeof("ce_flags")), src->ce_flags); #endif assert(sizeof(HashTable) == sizeof(src->default_properties)); assert(sizeof(HashTable) == sizeof((&src->default_properties)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_HashTable_zval_ptr( zv, &src->default_properties TSRMLS_CC ); add_assoc_zval_ex(dst, ("default_properties"), (sizeof("default_properties")), zv); } while (0); #ifdef ZEND_ENGINE_2 assert(sizeof(HashTable) == sizeof(src->properties_info)); assert(sizeof(HashTable) == sizeof((&src->properties_info)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_HashTable_zend_property_info( zv, &src->properties_info TSRMLS_CC ); add_assoc_zval_ex(dst, ("properties_info"), (sizeof("properties_info")), zv); } while (0); #ifdef ZEND_ENGINE_2_1 assert(sizeof(HashTable) == sizeof(src->default_static_members)); assert(sizeof(HashTable) == sizeof((&src->default_static_members)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_HashTable_zval_ptr( zv, &src->default_static_members TSRMLS_CC ); add_assoc_zval_ex(dst, ("default_static_members"), (sizeof("default_static_members")), zv); } while (0); #else if (src->static_members) { assert(sizeof(HashTable) == sizeof((src->static_members)[0])); /* allocate */ do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_HashTable_zval_ptr( zv, src->static_members TSRMLS_CC ); add_assoc_zval_ex(dst, ("static_members"), (sizeof("static_members")), zv); } while (0); } else { add_assoc_null_ex(dst, ("static_members"), (sizeof("static_members"))); } #endif assert(sizeof(HashTable) == sizeof(src->constants_table)); assert(sizeof(HashTable) == sizeof((&src->constants_table)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_HashTable_zval_ptr( zv, &src->constants_table TSRMLS_CC ); add_assoc_zval_ex(dst, ("constants_table"), (sizeof("constants_table")), zv); } while (0); if (src->num_interfaces) { /* zval *arr; ALLOC_INIT_ZVAL(arr); array_init(arr); for (i = 0; i < src->num_interfaces; i ++) { zval *zv; ALLOC_INIT_ZVAL(zv); ZVAL_STRING(src->num_interfaces); } add_assoc_zval_ex(dst, ("interfaces"), (sizeof("interfaces")), arr); */ } else { add_assoc_null_ex(dst, (""), (sizeof(""))); } add_assoc_long_ex(dst, ("num_interfaces"), (sizeof("num_interfaces")), src->num_interfaces); if (src->filename == NULL) { add_assoc_null_ex(dst, ("filename"), (sizeof("filename"))); } else { add_assoc_stringl_ex(dst, ("filename"), (sizeof("filename")), src->filename, strlen(src->filename) + 1 - 1, 1); } add_assoc_long_ex(dst, ("line_start"), (sizeof("line_start")), src->line_start); add_assoc_long_ex(dst, ("line_end"), (sizeof("line_end")), src->line_end); #ifdef ZEND_ENGINE_2_1 add_assoc_long_ex(dst, ("doc_comment_len"), (sizeof("doc_comment_len")), src->doc_comment_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { add_assoc_null_ex(dst, ("doc_comment"), (sizeof("doc_comment"))); } else { add_assoc_unicodel_ex(dst, ("doc_comment"), (sizeof("doc_comment")), src->doc_comment, src->doc_comment_len + 1 - 1, 1); } } else { if (ZSTR_S(src->doc_comment) == NULL) { add_assoc_null_ex(dst, ("doc_comment"), (sizeof("doc_comment"))); } else { add_assoc_stringl_ex(dst, ("doc_comment"), (sizeof("doc_comment")), src->doc_comment, src->doc_comment_len + 1 - 1, 1); } } #else if (ZSTR_S(src->doc_comment) == NULL) { add_assoc_null_ex(dst, ("doc_comment"), (sizeof("doc_comment"))); } else { add_assoc_stringl_ex(dst, ("doc_comment"), (sizeof("doc_comment")), src->doc_comment, src->doc_comment_len + 1 - 1, 1); } #endif #endif /* # NOT DONE */ /* deal with it inside xc_fix_method */ /* should be >5.1 */ #ifdef ZEND_ENGINE_2_1 #if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6 #endif #endif /* # NOT DONE */ #else #endif assert(sizeof(HashTable) == sizeof(src->function_table)); assert(sizeof(HashTable) == sizeof((&src->function_table)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_HashTable_zend_function( zv, &src->function_table TSRMLS_CC ); add_assoc_zval_ex(dst, ("function_table"), (sizeof("function_table")), zv); } while (0); } /* }}} */ /* {{{ xc_dasm_znode */ static void inline xc_dasm_znode(zval * dst, const znode * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("op_type"), (sizeof("op_type")), src->op_type); #ifdef IS_CV #define XCACHE_IS_CV IS_CV #else /* compatible with zend optimizer */ #define XCACHE_IS_CV 16 #endif assert(src->op_type == IS_CONST || src->op_type == IS_VAR || src->op_type == XCACHE_IS_CV || src->op_type == IS_TMP_VAR || src->op_type == IS_UNUSED); #undef XCACHE_IS_CV switch (src->op_type) { case IS_CONST: assert(sizeof(zval) == sizeof(src->u.constant)); assert(sizeof(zval) == sizeof((&src->u.constant)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zval( zv, &src->u.constant TSRMLS_CC ); add_assoc_zval_ex(dst, ("u.constant"), (sizeof("u.constant")), zv); } while (0); break; case IS_VAR: case IS_TMP_VAR: #ifdef IS_CV case IS_CV: #else case 16: #endif add_assoc_long_ex(dst, ("u.var"), (sizeof("u.var")), src->u.var); add_assoc_long_ex(dst, ("u.EA.type"), (sizeof("u.EA.type")), src->u.EA.type); break; case IS_UNUSED: add_assoc_long_ex(dst, ("u.var"), (sizeof("u.var")), src->u.var); add_assoc_long_ex(dst, ("u.opline_num"), (sizeof("u.opline_num")), src->u.opline_num); #ifndef ZEND_ENGINE_2 add_assoc_long_ex(dst, ("u.fetch_type"), (sizeof("u.fetch_type")), src->u.fetch_type); #endif add_assoc_long_ex(dst, ("u.EA.type"), (sizeof("u.EA.type")), src->u.EA.type); break; } } /* }}} */ /* {{{ xc_dasm_zend_op */ /* * export: void xc_dasm_zend_op( * val *dst, const zend_op * const src TSRMLS_DC * ); :export */ void xc_dasm_zend_op(zval * dst, const zend_op * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("opcode"), (sizeof("opcode")), src->opcode); assert(sizeof(znode) == sizeof(src->result)); assert(sizeof(znode) == sizeof((&src->result)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_znode( zv, &src->result TSRMLS_CC ); add_assoc_zval_ex(dst, ("result"), (sizeof("result")), zv); } while (0); assert(sizeof(znode) == sizeof(src->op1)); assert(sizeof(znode) == sizeof((&src->op1)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_znode( zv, &src->op1 TSRMLS_CC ); add_assoc_zval_ex(dst, ("op1"), (sizeof("op1")), zv); } while (0); assert(sizeof(znode) == sizeof(src->op2)); assert(sizeof(znode) == sizeof((&src->op2)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_znode( zv, &src->op2 TSRMLS_CC ); add_assoc_zval_ex(dst, ("op2"), (sizeof("op2")), zv); } while (0); add_assoc_long_ex(dst, ("extended_value"), (sizeof("extended_value")), src->extended_value); add_assoc_long_ex(dst, ("lineno"), (sizeof("lineno")), src->lineno); #ifdef ZEND_ENGINE_2_1 /* is copying enough? */ #endif } /* }}} */ /* {{{ xc_dasm_zend_op_array */ /* * export: void xc_dasm_zend_op_array( * val *dst, const zend_op_array * const src * _DC ); :export */ void xc_dasm_zend_op_array(zval * dst, const zend_op_array * const src TSRMLS_DC) { do { zend_uint ii; int i; /* Common elements */ add_assoc_long_ex(dst, ("type"), (sizeof("type")), src->type); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->function_name) == NULL) { add_assoc_null_ex(dst, ("function_name"), (sizeof("function_name"))); } else { add_assoc_unicodel_ex(dst, ("function_name"), (sizeof("function_name")), src->function_name, xc_zstrlen_uchar(src->function_name) + 1 - 1, 1); } } else { if (ZSTR_S(src->function_name) == NULL) { add_assoc_null_ex(dst, ("function_name"), (sizeof("function_name"))); } else { add_assoc_stringl_ex(dst, ("function_name"), (sizeof("function_name")), src->function_name, xc_zstrlen_char(src->function_name) + 1 - 1, 1); } } #else if (ZSTR_S(src->function_name) == NULL) { add_assoc_null_ex(dst, ("function_name"), (sizeof("function_name"))); } else { add_assoc_stringl_ex(dst, ("function_name"), (sizeof("function_name")), src->function_name, xc_zstrlen_char(src->function_name) + 1 - 1, 1); } #endif #ifdef ZEND_ENGINE_2 add_assoc_long_ex(dst, ("fn_flags"), (sizeof("fn_flags")), src->fn_flags); if (src->arg_info) { zval *arr; ALLOC_INIT_ZVAL(arr); array_init(arr); for (ii = 0; ii < src->num_args; ii++) { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_arg_info(zv, &(src->arg_info[ii]) TSRMLS_CC); add_next_index_zval(arr, zv); } add_assoc_zval_ex(dst, ("arg_info"), (sizeof("arg_info")), arr); } else { add_assoc_null_ex(dst, (""), (sizeof(""))); } add_assoc_long_ex(dst, ("num_args"), (sizeof("num_args")), src->num_args); add_assoc_long_ex(dst, ("required_num_args"), (sizeof("required_num_args")), src->required_num_args); add_assoc_bool_ex(dst, ("pass_rest_by_reference"), (sizeof("pass_rest_by_reference")), src->pass_rest_by_reference ? 1 : 0); #else if (src->arg_types) { /* allocate */ do { zend_uint ii; int i; zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); for (i = 0; i < src->arg_types[0]; i++) { add_next_index_long(zv, src->arg_types[i + 1]); } add_assoc_zval_ex(dst, ("arg_types"), (sizeof("arg_types")), zv); } while (0); } else { do { /* empty array */ zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); add_assoc_zval_ex(dst, ("arg_types"), (sizeof("arg_types")), zv); } while (0); } #endif add_assoc_long_ex(dst, ("return_reference"), (sizeof("return_reference")), src->return_reference); /* END of common elements */ #ifdef IS_UNICODE #endif if (src->refcount) { assert(sizeof(zend_uint) == sizeof((src->refcount)[0])); /* allocate */ do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_uint( zv, src->refcount TSRMLS_CC ); add_assoc_zval_ex(dst, ("refcount"), (sizeof("refcount")), zv); } while (0); } else { add_assoc_null_ex(dst, ("refcount"), (sizeof("refcount"))); } if (src->opcodes) { zval *arr; ALLOC_INIT_ZVAL(arr); array_init(arr); for (ii = 0; ii < src->last; ii++) { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_op(zv, &(src->opcodes[ii]) TSRMLS_CC); add_next_index_zval(arr, zv); } add_assoc_zval_ex(dst, ("opcodes"), (sizeof("opcodes")), arr); } else { add_assoc_null_ex(dst, (""), (sizeof(""))); } add_assoc_long_ex(dst, ("last"), (sizeof("last")), src->last); add_assoc_long_ex(dst, ("size"), (sizeof("size")), src->size); #ifdef IS_CV if (src->vars) { zval *arr; ALLOC_INIT_ZVAL(arr); array_init(arr); for (i = 0; i < src->last_var; i++) { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_compiled_variable(zv, &(src->vars[i]) TSRMLS_CC); add_next_index_zval(arr, zv); } add_assoc_zval_ex(dst, ("vars"), (sizeof("vars")), arr); } else { add_assoc_null_ex(dst, (""), (sizeof(""))); } add_assoc_long_ex(dst, ("last_var"), (sizeof("last_var")), src->last_var); add_assoc_long_ex(dst, ("size_var"), (sizeof("size_var")), src->size_var); #else #endif add_assoc_long_ex(dst, ("T"), (sizeof("T")), src->T); if (src->brk_cont_array) { zval *arr; ALLOC_INIT_ZVAL(arr); array_init(arr); for (ii = 0; ii < src->last_brk_cont; ii++) { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_brk_cont_element(zv, &(src->brk_cont_array[ii]) TSRMLS_CC); add_next_index_zval(arr, zv); } add_assoc_zval_ex(dst, ("brk_cont_array"), (sizeof("brk_cont_array")), arr); } else { add_assoc_null_ex(dst, (""), (sizeof(""))); } add_assoc_long_ex(dst, ("last_brk_cont"), (sizeof("last_brk_cont")), src->last_brk_cont); add_assoc_long_ex(dst, ("current_brk_cont"), (sizeof("current_brk_cont")), src->current_brk_cont); #ifndef ZEND_ENGINE_2 add_assoc_bool_ex(dst, ("uses_globals"), (sizeof("uses_globals")), src->uses_globals ? 1 : 0); #endif #ifdef ZEND_ENGINE_2 if (src->try_catch_array) { zval *arr; ALLOC_INIT_ZVAL(arr); array_init(arr); for (i = 0; i < src->last_try_catch; i++) { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_try_catch_element(zv, &(src->try_catch_array[i]) TSRMLS_CC); add_next_index_zval(arr, zv); } add_assoc_zval_ex(dst, ("try_catch_array"), (sizeof("try_catch_array")), arr); } else { add_assoc_null_ex(dst, (""), (sizeof(""))); } add_assoc_long_ex(dst, ("last_try_catch"), (sizeof("last_try_catch")), src->last_try_catch); #endif if (src->static_variables) { assert(sizeof(HashTable) == sizeof((src->static_variables)[0])); /* allocate */ do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_HashTable_zval_ptr( zv, src->static_variables TSRMLS_CC ); add_assoc_zval_ex(dst, ("static_variables"), (sizeof("static_variables")), zv); } while (0); } else { add_assoc_null_ex(dst, ("static_variables"), (sizeof("static_variables"))); } add_assoc_long_ex(dst, ("backpatch_count"), (sizeof("backpatch_count")), src->backpatch_count); add_assoc_bool_ex(dst, ("done_pass_two"), (sizeof("done_pass_two")), src->done_pass_two ? 1 : 0); #ifdef ZEND_ENGINE_2 add_assoc_bool_ex(dst, ("uses_this"), (sizeof("uses_this")), src->uses_this ? 1 : 0); #endif if (src->filename == NULL) { add_assoc_null_ex(dst, ("filename"), (sizeof("filename"))); } else { add_assoc_stringl_ex(dst, ("filename"), (sizeof("filename")), src->filename, strlen(src->filename) + 1 - 1, 1); } #ifdef IS_UNICODE if (src->script_encoding == NULL) { add_assoc_null_ex(dst, ("script_encoding"), (sizeof("script_encoding"))); } else { add_assoc_stringl_ex(dst, ("script_encoding"), (sizeof("script_encoding")), src->script_encoding, strlen(src->script_encoding) + 1 - 1, 1); } #endif #ifdef ZEND_ENGINE_2 add_assoc_long_ex(dst, ("line_start"), (sizeof("line_start")), src->line_start); add_assoc_long_ex(dst, ("line_end"), (sizeof("line_end")), src->line_end); add_assoc_long_ex(dst, ("doc_comment_len"), (sizeof("doc_comment_len")), src->doc_comment_len); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { add_assoc_null_ex(dst, ("doc_comment"), (sizeof("doc_comment"))); } else { add_assoc_unicodel_ex(dst, ("doc_comment"), (sizeof("doc_comment")), src->doc_comment, src->doc_comment_len + 1 - 1, 1); } } else { if (ZSTR_S(src->doc_comment) == NULL) { add_assoc_null_ex(dst, ("doc_comment"), (sizeof("doc_comment"))); } else { add_assoc_stringl_ex(dst, ("doc_comment"), (sizeof("doc_comment")), src->doc_comment, src->doc_comment_len + 1 - 1, 1); } } #else if (ZSTR_S(src->doc_comment) == NULL) { add_assoc_null_ex(dst, ("doc_comment"), (sizeof("doc_comment"))); } else { add_assoc_stringl_ex(dst, ("doc_comment"), (sizeof("doc_comment")), src->doc_comment, src->doc_comment_len + 1 - 1, 1); } #endif #endif /* reserved */ #if defined(HARDENING_PATCH) && HARDENING_PATCH add_assoc_bool_ex(dst, ("created_by_eval"), (sizeof("created_by_eval")), src->created_by_eval ? 1 : 0); #endif } while (0); #ifdef ZEND_ENGINE_2 add_assoc_null_ex(dst, (""), (sizeof(""))); #endif #ifdef ZEND_ENGINE_2 if (src->scope) { add_assoc_stringl_ex(dst, ("scope"), (sizeof("scope")), src->scope->name, strlen(src->scope->name), 1); } else { add_assoc_null_ex(dst, ("scope"), (sizeof("scope"))); } #endif } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_dasm_xc_constinfo_t */ static void inline xc_dasm_xc_constinfo_t(zval * dst, const xc_constinfo_t * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("key_size"), (sizeof("key_size")), src->key_size); #ifdef IS_UNICODE add_assoc_long_ex(dst, ("type"), (sizeof("type")), src->type); #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_unicodel_ex(dst, ("key"), (sizeof("key")), src->key, src->key_size - 1, 1); } } else { if (ZSTR_S(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_stringl_ex(dst, ("key"), (sizeof("key")), src->key, src->key_size - 1, 1); } } #else if (ZSTR_S(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_stringl_ex(dst, ("key"), (sizeof("key")), src->key, src->key_size - 1, 1); } #endif assert(sizeof(zend_constant) == sizeof(src->constant)); assert(sizeof(zend_constant) == sizeof((&src->constant)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_constant( zv, &src->constant TSRMLS_CC ); add_assoc_zval_ex(dst, ("constant"), (sizeof("constant")), zv); } while (0); } /* }}} */ #endif /* {{{ xc_dasm_xc_funcinfo_t */ /* * export: void xc_dasm_xc_funcinfo_t( * val *dst, const xc_funcinfo_t * const src * _DC ); :export */ void xc_dasm_xc_funcinfo_t(zval * dst, const xc_funcinfo_t * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("key_size"), (sizeof("key_size")), src->key_size); #ifdef IS_UNICODE add_assoc_long_ex(dst, ("type"), (sizeof("type")), src->type); #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_unicodel_ex(dst, ("key"), (sizeof("key")), src->key, src->key_size - 1, 1); } } else { if (ZSTR_S(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_stringl_ex(dst, ("key"), (sizeof("key")), src->key, src->key_size - 1, 1); } } #else if (ZSTR_S(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_stringl_ex(dst, ("key"), (sizeof("key")), src->key, src->key_size - 1, 1); } #endif assert(sizeof(zend_function) == sizeof(src->func)); assert(sizeof(zend_function) == sizeof((&src->func)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_function( zv, &src->func TSRMLS_CC ); add_assoc_zval_ex(dst, ("func"), (sizeof("func")), zv); } while (0); } /* }}} */ /* {{{ xc_dasm_xc_classinfo_t */ /* * export: void xc_dasm_xc_classinfo_t( * val *dst, const xc_classinfo_t * const src * _DC ); :export */ void xc_dasm_xc_classinfo_t(zval * dst, const xc_classinfo_t * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("key_size"), (sizeof("key_size")), src->key_size); #ifdef IS_UNICODE add_assoc_long_ex(dst, ("type"), (sizeof("type")), src->type); #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_unicodel_ex(dst, ("key"), (sizeof("key")), src->key, src->key_size - 1, 1); } } else { if (ZSTR_S(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_stringl_ex(dst, ("key"), (sizeof("key")), src->key, src->key_size - 1, 1); } } #else if (ZSTR_S(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_stringl_ex(dst, ("key"), (sizeof("key")), src->key, src->key_size - 1, 1); } #endif #ifdef ZEND_ENGINE_2 if (src->cest) { assert(sizeof(zend_class_entry) == sizeof((src->cest)[0])); /* allocate */ do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_class_entry( zv, src->cest TSRMLS_CC ); add_assoc_zval_ex(dst, ("cest"), (sizeof("cest")), zv); } while (0); } else { add_assoc_null_ex(dst, ("cest"), (sizeof("cest"))); } #else assert(sizeof(zend_class_entry) == sizeof(src->cest)); assert(sizeof(zend_class_entry) == sizeof((&src->cest)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_class_entry( zv, &src->cest TSRMLS_CC ); add_assoc_zval_ex(dst, ("cest"), (sizeof("cest")), zv); } while (0); #endif add_assoc_long_ex(dst, ("oplineno"), (sizeof("oplineno")), src->oplineno); } /* }}} */ #ifdef ZEND_ENGINE_2_1 /* {{{ xc_dasm_xc_autoglobal_t */ static void inline xc_dasm_xc_autoglobal_t(zval * dst, const xc_autoglobal_t * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("key_len"), (sizeof("key_len")), src->key_len); #ifdef IS_UNICODE add_assoc_long_ex(dst, ("type"), (sizeof("type")), src->type); #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_unicodel_ex(dst, ("key"), (sizeof("key")), src->key, src->key_len + 1 - 1, 1); } } else { if (ZSTR_S(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_stringl_ex(dst, ("key"), (sizeof("key")), src->key, src->key_len + 1 - 1, 1); } } #else if (ZSTR_S(src->key) == NULL) { add_assoc_null_ex(dst, ("key"), (sizeof("key"))); } else { add_assoc_stringl_ex(dst, ("key"), (sizeof("key")), src->key, src->key_len + 1 - 1, 1); } #endif } /* }}} */ #endif /* {{{ xc_dasm_xc_entry_data_php_t */ static void inline xc_dasm_xc_entry_data_php_t(zval * dst, const xc_entry_data_php_t * const src TSRMLS_DC) { zend_uint i; #ifdef HAVE_INODE add_assoc_long_ex(dst, ("device"), (sizeof("device")), src->device); add_assoc_long_ex(dst, ("inode"), (sizeof("inode")), src->inode); #endif add_assoc_long_ex(dst, ("sourcesize"), (sizeof("sourcesize")), src->sourcesize); add_assoc_long_ex(dst, ("mtime"), (sizeof("mtime")), src->mtime); if (src->op_array) { assert(sizeof(zend_op_array) == sizeof((src->op_array)[0])); /* allocate */ do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zend_op_array( zv, src->op_array TSRMLS_CC ); add_assoc_zval_ex(dst, ("op_array"), (sizeof("op_array")), zv); } while (0); } else { add_assoc_null_ex(dst, ("op_array"), (sizeof("op_array"))); } #ifdef HAVE_XCACHE_CONSTANT add_assoc_long_ex(dst, ("constinfo_cnt"), (sizeof("constinfo_cnt")), src->constinfo_cnt); if (src->constinfos) { zval *arr; ALLOC_INIT_ZVAL(arr); array_init(arr); for (i = 0; i < src->constinfo_cnt; i++) { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_xc_constinfo_t(zv, &(src->constinfos[i]) TSRMLS_CC); add_next_index_zval(arr, zv); } add_assoc_zval_ex(dst, ("constinfos"), (sizeof("constinfos")), arr); } else { add_assoc_null_ex(dst, (""), (sizeof(""))); } #endif add_assoc_long_ex(dst, ("funcinfo_cnt"), (sizeof("funcinfo_cnt")), src->funcinfo_cnt); if (src->funcinfos) { zval *arr; ALLOC_INIT_ZVAL(arr); array_init(arr); for (i = 0; i < src->funcinfo_cnt; i++) { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_xc_funcinfo_t(zv, &(src->funcinfos[i]) TSRMLS_CC); add_next_index_zval(arr, zv); } add_assoc_zval_ex(dst, ("funcinfos"), (sizeof("funcinfos")), arr); } else { add_assoc_null_ex(dst, (""), (sizeof(""))); } add_assoc_long_ex(dst, ("classinfo_cnt"), (sizeof("classinfo_cnt")), src->classinfo_cnt); if (src->classinfos) { zval *arr; ALLOC_INIT_ZVAL(arr); array_init(arr); for (i = 0; i < src->classinfo_cnt; i++) { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_xc_classinfo_t(zv, &(src->classinfos[i]) TSRMLS_CC); add_next_index_zval(arr, zv); } add_assoc_zval_ex(dst, ("classinfos"), (sizeof("classinfos")), arr); } else { add_assoc_null_ex(dst, (""), (sizeof(""))); } #ifdef ZEND_ENGINE_2_1 add_assoc_long_ex(dst, ("autoglobal_cnt"), (sizeof("autoglobal_cnt")), src->autoglobal_cnt); if (src->autoglobals) { zval *arr; ALLOC_INIT_ZVAL(arr); array_init(arr); for (i = 0; i < src->autoglobal_cnt; i++) { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_xc_autoglobal_t(zv, &(src->autoglobals[i]) TSRMLS_CC); add_next_index_zval(arr, zv); } add_assoc_zval_ex(dst, ("autoglobals"), (sizeof("autoglobals")), arr); } else { add_assoc_null_ex(dst, (""), (sizeof(""))); } #endif add_assoc_bool_ex(dst, ("have_early_binding"), (sizeof("have_early_binding")), src->have_early_binding ? 1 : 0); } /* }}} */ /* {{{ xc_dasm_xc_entry_data_var_t */ static void inline xc_dasm_xc_entry_data_var_t(zval * dst, const xc_entry_data_var_t * const src TSRMLS_DC) { assert(sizeof(zval_ptr) == sizeof((&src->value)[0])); do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_zval_ptr( zv, &src->value TSRMLS_CC ); add_assoc_zval_ex(dst, ("value"), (sizeof("value")), zv); } while (0); } /* }}} */ /* {{{ xc_dasm_xc_entry_t */ /* * export: void xc_dasm_xc_entry_t( * val *dst, const xc_entry_t * const src * _DC ); :export */ void xc_dasm_xc_entry_t(zval * dst, const xc_entry_t * const src TSRMLS_DC) { add_assoc_long_ex(dst, ("type"), (sizeof("type")), src->type); add_assoc_long_ex(dst, ("size"), (sizeof("size")), src->size); add_assoc_long_ex(dst, ("hvalue"), (sizeof("hvalue")), src->hvalue); /* skip */ add_assoc_long_ex(dst, ("refcount"), (sizeof("refcount")), src->refcount); add_assoc_long_ex(dst, ("ctime"), (sizeof("ctime")), src->ctime); add_assoc_long_ex(dst, ("atime"), (sizeof("atime")), src->atime); add_assoc_long_ex(dst, ("dtime"), (sizeof("dtime")), src->dtime); add_assoc_long_ex(dst, ("ttl"), (sizeof("ttl")), src->ttl); add_assoc_long_ex(dst, ("hits"), (sizeof("hits")), src->hits); #ifdef IS_UNICODE add_assoc_long_ex(dst, ("name_type"), (sizeof("name_type")), src->name_type); #endif #ifdef IS_UNICODE if (src->name_type == IS_UNICODE) { add_assoc_long_ex(dst, ("name.ustr.len"), (sizeof("name.ustr.len")), src->name.ustr.len); } else { add_assoc_long_ex(dst, ("name.str.len"), (sizeof("name.str.len")), src->name.str.len); } #else add_assoc_long_ex(dst, ("name.str.len"), (sizeof("name.str.len")), src->name.str.len); #endif #ifdef IS_UNICODE #ifdef IS_UNICODE if (src->name_type == IS_UNICODE) { if (ZSTR_U(src->name.uni.val) == NULL) { add_assoc_null_ex(dst, ("name.uni.val"), (sizeof("name.uni.val"))); } else { add_assoc_unicodel_ex(dst, ("name.uni.val"), (sizeof("name.uni.val")), src->name.uni.val, src->name.uni.len + 1 - 1, 1); } } else { if (ZSTR_S(src->name.uni.val) == NULL) { add_assoc_null_ex(dst, ("name.uni.val"), (sizeof("name.uni.val"))); } else { add_assoc_stringl_ex(dst, ("name.uni.val"), (sizeof("name.uni.val")), src->name.uni.val, src->name.uni.len + 1 - 1, 1); } } #else if (ZSTR_S(src->name.uni.val) == NULL) { add_assoc_null_ex(dst, ("name.uni.val"), (sizeof("name.uni.val"))); } else { add_assoc_stringl_ex(dst, ("name.uni.val"), (sizeof("name.uni.val")), src->name.uni.val, src->name.uni.len + 1 - 1, 1); } #endif #else if (src->name.str.val == NULL) { add_assoc_null_ex(dst, ("name.str.val"), (sizeof("name.str.val"))); } else { add_assoc_stringl_ex(dst, ("name.str.val"), (sizeof("name.str.val")), src->name.str.val, src->name.str.len + 1 - 1, 1); } #endif switch (src->type) { case XC_TYPE_PHP: if (src->data.php) { assert(sizeof(xc_entry_data_php_t) == sizeof((src->data.php)[0])); /* allocate */ do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_xc_entry_data_php_t( zv, src->data.php TSRMLS_CC ); add_assoc_zval_ex(dst, ("data.php"), (sizeof("data.php")), zv); } while (0); } else { add_assoc_null_ex(dst, ("data.php"), (sizeof("data.php"))); } break; case XC_TYPE_VAR: if (src->data.var) { assert(sizeof(xc_entry_data_var_t) == sizeof((src->data.var)[0])); /* allocate */ do { zval *zv; ALLOC_INIT_ZVAL(zv); array_init(zv); xc_dasm_xc_entry_data_var_t( zv, src->data.var TSRMLS_CC ); add_assoc_zval_ex(dst, ("data.var"), (sizeof("data.var")), zv); } while (0); } else { add_assoc_null_ex(dst, ("data.var"), (sizeof("data.var"))); } break; default: assert(0); } add_assoc_bool_ex(dst, ("have_references"), (sizeof("have_references")), src->have_references ? 1 : 0); } /* }}} */ #endif /* HAVE_XCACHE_DISASSEMBLER */ #ifdef HAVE_XCACHE_ASSEMBLER /* {{{ Pre-declare */ void xc_asm_zval(zval * dst, const zval * const src TSRMLS_DC); static void inline xc_asm_zval_ptr(zval_ptr * dst, const zval_ptr * const src TSRMLS_DC); void xc_asm_zend_op_array(zend_op_array * dst, const zend_op_array * const src TSRMLS_DC); void xc_asm_zend_class_entry(zend_class_entry * dst, const zend_class_entry * const src TSRMLS_DC); #ifdef HAVE_XCACHE_CONSTANT static void inline xc_asm_zend_constant(zend_constant * dst, const zend_constant * const src TSRMLS_DC); #endif void xc_asm_zend_function(zend_function * dst, const zend_function * const src TSRMLS_DC); void xc_asm_xc_entry_t(xc_entry_t * dst, const xc_entry_t * const src TSRMLS_DC); #ifdef ZEND_ENGINE_2 static void inline xc_asm_zend_property_info(zend_property_info * dst, const zend_property_info * const src TSRMLS_DC); #endif /* }}} */ #ifdef IS_CV /* {{{ xc_asm_zend_compiled_variable */ static void inline xc_asm_zend_compiled_variable(zend_compiled_variable * dst, const zend_compiled_variable * const src TSRMLS_DC) { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { } } else { if (ZSTR_S(src->name) == NULL) { } else { } } #else if (ZSTR_S(src->name) == NULL) { } else { } #endif } /* }}} */ #endif /* {{{ xc_asm_zend_uint */ static void inline xc_asm_zend_uint(zend_uint * dst, const zend_uint * const src TSRMLS_DC) { } /* }}} */ #ifndef ZEND_ENGINE_2 /* {{{ xc_asm_int */ static void inline xc_asm_int(int *dst, const int *const src TSRMLS_DC) { } /* }}} */ #endif #ifdef ZEND_ENGINE_2 /* {{{ xc_asm_zend_try_catch_element */ static void inline xc_asm_zend_try_catch_element(zend_try_catch_element * dst, const zend_try_catch_element * const src TSRMLS_DC) { } /* }}} */ #endif /* ifdef ZEND_ENGINE_2 */ /* {{{ xc_asm_zend_brk_cont_element */ static void inline xc_asm_zend_brk_cont_element(zend_brk_cont_element * dst, const zend_brk_cont_element * const src TSRMLS_DC) { #ifdef ZEND_ENGINE_2_2 #ifndef IS_UNICODE #endif #endif } /* }}} */ /* {{{ xc_asm_HashTable_zval_ptr */ static void inline xc_asm_HashTable_zval_ptr(HashTable * dst, const HashTable * const src TSRMLS_DC) { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT dst->canary = zend_hash_canary; #endif /* allocate */ for (b = src->pListHead; b != NULL; b = b->pListNext) { /* allocate */ if (sizeof(void *) == sizeof(zval_ptr)) { assert(sizeof(zval_ptr) == sizeof((((zval_ptr *) b->pData))[0])); xc_asm_zval_ptr( pnew->pData, ((zval_ptr *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zval_ptr) == sizeof((((zval_ptr *) b->pData))[0])); /* allocate */ xc_asm_zval_ptr( pnew->pData, ((zval_ptr *) b->pData) TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_asm_HashTable_zend_constant */ static void inline xc_asm_HashTable_zend_constant(HashTable * dst, const HashTable * const src TSRMLS_DC) { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT dst->canary = zend_hash_canary; #endif /* allocate */ for (b = src->pListHead; b != NULL; b = b->pListNext) { /* allocate */ if (sizeof(void *) == sizeof(zend_constant)) { assert(sizeof(zend_constant) == sizeof((((zend_constant *) b->pData))[0])); xc_asm_zend_constant( pnew->pData, ((zend_constant *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_constant) == sizeof((((zend_constant *) b->pData))[0])); /* allocate */ xc_asm_zend_constant( pnew->pData, ((zend_constant *) b->pData) TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } /* }}} */ #endif /* {{{ xc_asm_HashTable_zend_function */ /* * export: void xc_asm_HashTable_zend_function( * ashTable *dst, const HashTable * const src TSRMLS_DC ); * export */ void xc_asm_HashTable_zend_function(HashTable * dst, const HashTable * const src TSRMLS_DC) { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT dst->canary = zend_hash_canary; #endif /* allocate */ for (b = src->pListHead; b != NULL; b = b->pListNext) { /* allocate */ if (sizeof(void *) == sizeof(zend_function)) { assert(sizeof(zend_function) == sizeof((((zend_function *) b->pData))[0])); xc_asm_zend_function( pnew->pData, ((zend_function *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_function) == sizeof((((zend_function *) b->pData))[0])); /* allocate */ xc_asm_zend_function( pnew->pData, ((zend_function *) b->pData) TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_asm_HashTable_zend_property_info */ static void inline xc_asm_HashTable_zend_property_info(HashTable * dst, const HashTable * const src TSRMLS_DC) { Bucket *b, *pnew = NULL, *prev = NULL; zend_bool first = 1; #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT dst->canary = zend_hash_canary; #endif /* allocate */ for (b = src->pListHead; b != NULL; b = b->pListNext) { /* allocate */ if (sizeof(void *) == sizeof(zend_property_info)) { assert(sizeof(zend_property_info) == sizeof((((zend_property_info *) b->pData))[0])); xc_asm_zend_property_info( pnew->pData, ((zend_property_info *) b->pData) TSRMLS_CC ); } else { assert(sizeof(zend_property_info) == sizeof((((zend_property_info *) b->pData))[0])); /* allocate */ xc_asm_zend_property_info( pnew->pData, ((zend_property_info *) b->pData) TSRMLS_CC ); } if (first) { first = 0; } prev = pnew; } #ifdef IS_UNICODE #endif #if ZEND_DEBUG #endif } /* }}} */ #endif /* {{{ xc_asm_zval */ /* * export: void xc_asm_zval( * val *dst, const zval * const src TSRMLS_DC ); * rt */ void xc_asm_zval(zval * dst, const zval * const src TSRMLS_DC) { /* Variable information */ switch (src->type & ~IS_CONSTANT_INDEX) { case IS_LONG: case IS_RESOURCE: case IS_BOOL: break; case IS_DOUBLE: break; case IS_NULL: break; case IS_CONSTANT: #ifdef IS_UNICODE if (UG(unicode)) { goto proc_unicode; } #endif case IS_STRING: #ifdef FLAG_IS_BC case FLAG_IS_BC: #endif if (src->value.str.val == NULL) { } else { } break; #ifdef IS_UNICODE case IS_UNICODE: proc_unicode: #ifdef IS_UNICODE if (ZSTR_U(src->value.uni.val) == NULL) { } else { } #else if (ZSTR_S(src->value.uni.val) == NULL) { } else { } #endif break; #endif case IS_ARRAY: case IS_CONSTANT_ARRAY: if (src->value.ht) { assert(sizeof(HashTable) == sizeof((src->value.ht)[0])); /* allocate */ xc_asm_HashTable_zval_ptr( dst->value.ht, src->value.ht TSRMLS_CC ); } else { } break; case IS_OBJECT: #ifndef ZEND_ENGINE_2 if (src->value.obj.ce) { assert(sizeof(zend_class_entry) == sizeof((src->value.obj.ce)[0])); /* allocate */ xc_asm_zend_class_entry( dst->value.obj.ce, src->value.obj.ce TSRMLS_CC ); } else { } if (src->value.obj.properties) { assert(sizeof(HashTable) == sizeof((src->value.obj.properties)[0])); /* allocate */ xc_asm_HashTable_zval_ptr( dst->value.obj.properties, src->value.obj.properties TSRMLS_CC ); } else { } #endif break; default: assert(0); } } /* }}} */ /* {{{ xc_asm_zval_ptr */ static void inline xc_asm_zval_ptr(zval_ptr * dst, const zval_ptr * const src TSRMLS_DC) { do { /* allocate */ assert(sizeof(zval) == sizeof((src[0])[0])); xc_asm_zval( dst[0], src[0] TSRMLS_CC ); } while (0); } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_asm_zend_arg_info */ static void inline xc_asm_zend_arg_info(zend_arg_info * dst, const zend_arg_info * const src TSRMLS_DC) { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { } } else { if (ZSTR_S(src->name) == NULL) { } else { } } #else if (ZSTR_S(src->name) == NULL) { } else { } #endif #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->class_name) == NULL) { } else { } } else { if (ZSTR_S(src->class_name) == NULL) { } else { } } #else if (ZSTR_S(src->class_name) == NULL) { } else { } #endif } /* }}} */ #endif #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_asm_zend_constant */ static void inline xc_asm_zend_constant(zend_constant * dst, const zend_constant * const src TSRMLS_DC) { assert(sizeof(zval) == sizeof(src->value)); assert(sizeof(zval) == sizeof((&src->value)[0])); xc_asm_zval( &dst->value, &src->value TSRMLS_CC ); #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { } } else { if (ZSTR_S(src->name) == NULL) { } else { } } #else if (ZSTR_S(src->name) == NULL) { } else { } #endif } /* }}} */ #endif /* {{{ xc_asm_zend_function */ /* * export: void xc_asm_zend_function( * end_function *dst, const zend_function * const src TSRMLS_DC * ); :export */ void xc_asm_zend_function(zend_function * dst, const zend_function * const src TSRMLS_DC) { switch (src->type) { case ZEND_INTERNAL_FUNCTION: case ZEND_OVERLOADED_FUNCTION: break; case ZEND_USER_FUNCTION: case ZEND_EVAL_CODE: assert(sizeof(zend_op_array) == sizeof(src->op_array)); assert(sizeof(zend_op_array) == sizeof((&src->op_array)[0])); xc_asm_zend_op_array( &dst->op_array, &src->op_array TSRMLS_CC ); break; default: assert(0); } } /* }}} */ #ifdef ZEND_ENGINE_2 /* {{{ xc_asm_zend_property_info */ static void inline xc_asm_zend_property_info(zend_property_info * dst, const zend_property_info * const src TSRMLS_DC) { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { } } else { if (ZSTR_S(src->name) == NULL) { } else { } } #else if (ZSTR_S(src->name) == NULL) { } else { } #endif #ifdef ZEND_ENGINE_2_1 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { } #endif #endif #if defined(ZEND_ENGINE_2_2) && !defined(IS_UNICODE) if (src->ce) { } else { } #endif } /* }}} */ #endif /* {{{ xc_asm_zend_class_entry */ /* * export: void xc_asm_zend_class_entry( * end_class_entry *dst, const zend_class_entry * const src * _DC ); :export */ void xc_asm_zend_class_entry(zend_class_entry * dst, const zend_class_entry * const src TSRMLS_DC) { #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->name) == NULL) { } else { } } else { if (ZSTR_S(src->name) == NULL) { } else { } } #else if (ZSTR_S(src->name) == NULL) { } else { } #endif if (src->parent) { } else { } #ifdef ZEND_ENGINE_2 #else if (src->refcount) { assert(sizeof(int) == sizeof((src->refcount)[0])); /* allocate */ xc_asm_int( dst->refcount, src->refcount TSRMLS_CC ); } else { } #endif #ifdef ZEND_ENGINE_2 #endif assert(sizeof(HashTable) == sizeof(src->default_properties)); assert(sizeof(HashTable) == sizeof((&src->default_properties)[0])); xc_asm_HashTable_zval_ptr( &dst->default_properties, &src->default_properties TSRMLS_CC ); #ifdef ZEND_ENGINE_2 assert(sizeof(HashTable) == sizeof(src->properties_info)); assert(sizeof(HashTable) == sizeof((&src->properties_info)[0])); xc_asm_HashTable_zend_property_info( &dst->properties_info, &src->properties_info TSRMLS_CC ); #ifdef ZEND_ENGINE_2_1 assert(sizeof(HashTable) == sizeof(src->default_static_members)); assert(sizeof(HashTable) == sizeof((&src->default_static_members)[0])); xc_asm_HashTable_zval_ptr( &dst->default_static_members, &src->default_static_members TSRMLS_CC ); #else if (src->static_members) { assert(sizeof(HashTable) == sizeof((src->static_members)[0])); /* allocate */ xc_asm_HashTable_zval_ptr( dst->static_members, src->static_members TSRMLS_CC ); } else { } #endif assert(sizeof(HashTable) == sizeof(src->constants_table)); assert(sizeof(HashTable) == sizeof((&src->constants_table)[0])); xc_asm_HashTable_zval_ptr( &dst->constants_table, &src->constants_table TSRMLS_CC ); if (src->filename == NULL) { } else { } #ifdef ZEND_ENGINE_2_1 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { } #endif #endif /* # NOT DONE */ /* deal with it inside xc_fix_method */ /* should be >5.1 */ #ifdef ZEND_ENGINE_2_1 #if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6 #endif #endif /* # NOT DONE */ #else #endif assert(sizeof(HashTable) == sizeof(src->function_table)); assert(sizeof(HashTable) == sizeof((&src->function_table)[0])); xc_asm_HashTable_zend_function( &dst->function_table, &src->function_table TSRMLS_CC ); } /* }}} */ /* {{{ xc_asm_znode */ static void inline xc_asm_znode(znode * dst, const znode * const src TSRMLS_DC) { #ifdef IS_CV #define XCACHE_IS_CV IS_CV #else /* compatible with zend optimizer */ #define XCACHE_IS_CV 16 #endif assert(src->op_type == IS_CONST || src->op_type == IS_VAR || src->op_type == XCACHE_IS_CV || src->op_type == IS_TMP_VAR || src->op_type == IS_UNUSED); #undef XCACHE_IS_CV switch (src->op_type) { case IS_CONST: assert(sizeof(zval) == sizeof(src->u.constant)); assert(sizeof(zval) == sizeof((&src->u.constant)[0])); xc_asm_zval( &dst->u.constant, &src->u.constant TSRMLS_CC ); break; case IS_VAR: case IS_TMP_VAR: #ifdef IS_CV case IS_CV: #else case 16: #endif break; case IS_UNUSED: #ifndef ZEND_ENGINE_2 #endif break; } } /* }}} */ /* {{{ xc_asm_zend_op */ /* * export: void xc_asm_zend_op( * end_op *dst, const zend_op * const src TSRMLS_DC ); * export */ void xc_asm_zend_op(zend_op * dst, const zend_op * const src TSRMLS_DC) { assert(sizeof(znode) == sizeof(src->result)); assert(sizeof(znode) == sizeof((&src->result)[0])); xc_asm_znode( &dst->result, &src->result TSRMLS_CC ); assert(sizeof(znode) == sizeof(src->op1)); assert(sizeof(znode) == sizeof((&src->op1)[0])); xc_asm_znode( &dst->op1, &src->op1 TSRMLS_CC ); assert(sizeof(znode) == sizeof(src->op2)); assert(sizeof(znode) == sizeof((&src->op2)[0])); xc_asm_znode( &dst->op2, &src->op2 TSRMLS_CC ); #ifdef ZEND_ENGINE_2_1 /* is copying enough? */ #endif } /* }}} */ /* {{{ xc_asm_zend_op_array */ /* * export: void xc_asm_zend_op_array( * end_op_array *dst, const zend_op_array * const src TSRMLS_DC * ); :export */ void xc_asm_zend_op_array(zend_op_array * dst, const zend_op_array * const src TSRMLS_DC) { do { zend_uint ii; int i; /* Common elements */ #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->function_name) == NULL) { } else { } } else { if (ZSTR_S(src->function_name) == NULL) { } else { } } #else if (ZSTR_S(src->function_name) == NULL) { } else { } #endif #ifdef ZEND_ENGINE_2 if (src->arg_info) { /* allocate */ for (ii = 0; ii < src->num_args; ii++) { assert(sizeof(zend_arg_info) == sizeof(src->arg_info[ii])); assert(sizeof(zend_arg_info) == sizeof((&src->arg_info[ii])[0])); xc_asm_zend_arg_info( &dst->arg_info[ii], &src->arg_info[ii] TSRMLS_CC ); } } else { } #else if (src->arg_types) { /* allocate */ } else { } #endif /* END of common elements */ #ifdef IS_UNICODE #endif if (src->refcount) { assert(sizeof(zend_uint) == sizeof((src->refcount)[0])); /* allocate */ xc_asm_zend_uint( dst->refcount, src->refcount TSRMLS_CC ); } else { } if (src->opcodes) { /* allocate */ for (ii = 0; ii < src->last; ii++) { assert(sizeof(zend_op) == sizeof(src->opcodes[ii])); assert(sizeof(zend_op) == sizeof((&src->opcodes[ii])[0])); xc_asm_zend_op( &dst->opcodes[ii], &src->opcodes[ii] TSRMLS_CC ); } } else { } #ifdef IS_CV if (src->vars) { /* allocate */ for (i = 0; i < src->last_var; i++) { assert(sizeof(zend_compiled_variable) == sizeof(src->vars[i])); assert(sizeof(zend_compiled_variable) == sizeof((&src->vars[i])[0])); xc_asm_zend_compiled_variable( &dst->vars[i], &src->vars[i] TSRMLS_CC ); } } else { } #else #endif if (src->brk_cont_array) { /* allocate */ for (ii = 0; ii < src->last_brk_cont; ii++) { assert(sizeof(zend_brk_cont_element) == sizeof(src->brk_cont_array[ii])); assert(sizeof(zend_brk_cont_element) == sizeof((&src->brk_cont_array[ii])[0])); xc_asm_zend_brk_cont_element( &dst->brk_cont_array[ii], &src->brk_cont_array[ii] TSRMLS_CC ); } } else { } #ifndef ZEND_ENGINE_2 #endif #ifdef ZEND_ENGINE_2 if (src->try_catch_array) { /* allocate */ for (i = 0; i < src->last_try_catch; i++) { assert(sizeof(zend_try_catch_element) == sizeof(src->try_catch_array[i])); assert(sizeof(zend_try_catch_element) == sizeof((&src->try_catch_array[i])[0])); xc_asm_zend_try_catch_element( &dst->try_catch_array[i], &src->try_catch_array[i] TSRMLS_CC ); } } else { } #endif if (src->static_variables) { assert(sizeof(HashTable) == sizeof((src->static_variables)[0])); /* allocate */ xc_asm_HashTable_zval_ptr( dst->static_variables, src->static_variables TSRMLS_CC ); } else { } #ifdef ZEND_ENGINE_2 #endif if (src->filename == NULL) { } else { } #ifdef IS_UNICODE if (src->script_encoding == NULL) { } else { } #endif #ifdef ZEND_ENGINE_2 #ifdef IS_UNICODE if (UG(unicode)) { if (ZSTR_U(src->doc_comment) == NULL) { } else { } } else { if (ZSTR_S(src->doc_comment) == NULL) { } else { } } #else if (ZSTR_S(src->doc_comment) == NULL) { } else { } #endif #endif /* reserved */ #if defined(HARDENING_PATCH) && HARDENING_PATCH #endif } while (0); #ifdef ZEND_ENGINE_2 #endif #ifdef ZEND_ENGINE_2 if (src->scope) { } else { } #endif } /* }}} */ #ifdef HAVE_XCACHE_CONSTANT /* {{{ xc_asm_xc_constinfo_t */ static void inline xc_asm_xc_constinfo_t(xc_constinfo_t * dst, const xc_constinfo_t * const src TSRMLS_DC) { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { } } else { if (ZSTR_S(src->key) == NULL) { } else { } } #else if (ZSTR_S(src->key) == NULL) { } else { } #endif assert(sizeof(zend_constant) == sizeof(src->constant)); assert(sizeof(zend_constant) == sizeof((&src->constant)[0])); xc_asm_zend_constant( &dst->constant, &src->constant TSRMLS_CC ); } /* }}} */ #endif /* {{{ xc_asm_xc_funcinfo_t */ /* * export: void xc_asm_xc_funcinfo_t( * c_funcinfo_t *dst, const xc_funcinfo_t * const src TSRMLS_DC * ); :export */ void xc_asm_xc_funcinfo_t(xc_funcinfo_t * dst, const xc_funcinfo_t * const src TSRMLS_DC) { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { } } else { if (ZSTR_S(src->key) == NULL) { } else { } } #else if (ZSTR_S(src->key) == NULL) { } else { } #endif assert(sizeof(zend_function) == sizeof(src->func)); assert(sizeof(zend_function) == sizeof((&src->func)[0])); xc_asm_zend_function( &dst->func, &src->func TSRMLS_CC ); } /* }}} */ /* {{{ xc_asm_xc_classinfo_t */ /* * export: void xc_asm_xc_classinfo_t( * c_classinfo_t *dst, const xc_classinfo_t * const src * _DC ); :export */ void xc_asm_xc_classinfo_t(xc_classinfo_t * dst, const xc_classinfo_t * const src TSRMLS_DC) { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { } } else { if (ZSTR_S(src->key) == NULL) { } else { } } #else if (ZSTR_S(src->key) == NULL) { } else { } #endif #ifdef ZEND_ENGINE_2 if (src->cest) { assert(sizeof(zend_class_entry) == sizeof((src->cest)[0])); /* allocate */ xc_asm_zend_class_entry( dst->cest, src->cest TSRMLS_CC ); } else { } #else assert(sizeof(zend_class_entry) == sizeof(src->cest)); assert(sizeof(zend_class_entry) == sizeof((&src->cest)[0])); xc_asm_zend_class_entry( &dst->cest, &src->cest TSRMLS_CC ); #endif } /* }}} */ #ifdef ZEND_ENGINE_2_1 /* {{{ xc_asm_xc_autoglobal_t */ static void inline xc_asm_xc_autoglobal_t(xc_autoglobal_t * dst, const xc_autoglobal_t * const src TSRMLS_DC) { #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->type == IS_UNICODE) { if (ZSTR_U(src->key) == NULL) { } else { } } else { if (ZSTR_S(src->key) == NULL) { } else { } } #else if (ZSTR_S(src->key) == NULL) { } else { } #endif } /* }}} */ #endif /* {{{ xc_asm_xc_entry_data_php_t */ static void inline xc_asm_xc_entry_data_php_t(xc_entry_data_php_t * dst, const xc_entry_data_php_t * const src TSRMLS_DC) { zend_uint i; #ifdef HAVE_INODE #endif if (src->op_array) { assert(sizeof(zend_op_array) == sizeof((src->op_array)[0])); /* allocate */ xc_asm_zend_op_array( dst->op_array, src->op_array TSRMLS_CC ); } else { } #ifdef HAVE_XCACHE_CONSTANT if (src->constinfos) { /* allocate */ for (i = 0; i < src->constinfo_cnt; i++) { assert(sizeof(xc_constinfo_t) == sizeof(src->constinfos[i])); assert(sizeof(xc_constinfo_t) == sizeof((&src->constinfos[i])[0])); xc_asm_xc_constinfo_t( &dst->constinfos[i], &src->constinfos[i] TSRMLS_CC ); } } else { } #endif if (src->funcinfos) { /* allocate */ for (i = 0; i < src->funcinfo_cnt; i++) { assert(sizeof(xc_funcinfo_t) == sizeof(src->funcinfos[i])); assert(sizeof(xc_funcinfo_t) == sizeof((&src->funcinfos[i])[0])); xc_asm_xc_funcinfo_t( &dst->funcinfos[i], &src->funcinfos[i] TSRMLS_CC ); } } else { } if (src->classinfos) { /* allocate */ for (i = 0; i < src->classinfo_cnt; i++) { assert(sizeof(xc_classinfo_t) == sizeof(src->classinfos[i])); assert(sizeof(xc_classinfo_t) == sizeof((&src->classinfos[i])[0])); xc_asm_xc_classinfo_t( &dst->classinfos[i], &src->classinfos[i] TSRMLS_CC ); } } else { } #ifdef ZEND_ENGINE_2_1 if (src->autoglobals) { /* allocate */ for (i = 0; i < src->autoglobal_cnt; i++) { assert(sizeof(xc_autoglobal_t) == sizeof(src->autoglobals[i])); assert(sizeof(xc_autoglobal_t) == sizeof((&src->autoglobals[i])[0])); xc_asm_xc_autoglobal_t( &dst->autoglobals[i], &src->autoglobals[i] TSRMLS_CC ); } } else { } #endif } /* }}} */ /* {{{ xc_asm_xc_entry_data_var_t */ static void inline xc_asm_xc_entry_data_var_t(xc_entry_data_var_t * dst, const xc_entry_data_var_t * const src TSRMLS_DC) { assert(sizeof(zval_ptr) == sizeof((&src->value)[0])); xc_asm_zval_ptr( &dst->value, &src->value TSRMLS_CC ); } /* }}} */ /* {{{ xc_asm_xc_entry_t */ /* * export: void xc_asm_xc_entry_t( * c_entry_t *dst, const xc_entry_t * const src TSRMLS_DC * ); :export */ void xc_asm_xc_entry_t(xc_entry_t * dst, const xc_entry_t * const src TSRMLS_DC) { /* skip */ #ifdef IS_UNICODE #endif #ifdef IS_UNICODE if (src->name_type == IS_UNICODE) { } else { } #else #endif #ifdef IS_UNICODE #ifdef IS_UNICODE if (src->name_type == IS_UNICODE) { if (ZSTR_U(src->name.uni.val) == NULL) { } else { } } else { if (ZSTR_S(src->name.uni.val) == NULL) { } else { } } #else if (ZSTR_S(src->name.uni.val) == NULL) { } else { } #endif #else if (src->name.str.val == NULL) { } else { } #endif switch (src->type) { case XC_TYPE_PHP: if (src->data.php) { assert(sizeof(xc_entry_data_php_t) == sizeof((src->data.php)[0])); /* allocate */ xc_asm_xc_entry_data_php_t( dst->data.php, src->data.php TSRMLS_CC ); } else { } break; case XC_TYPE_VAR: if (src->data.var) { assert(sizeof(xc_entry_data_var_t) == sizeof((src->data.var)[0])); /* allocate */ xc_asm_xc_entry_data_var_t( dst->data.var, src->data.var TSRMLS_CC ); } else { } break; default: assert(0); } } /* }}} */ #endif /* HAVE_XCACHE_ASSEMBLER */