1 /*
2 +----------------------------------------------------------------------+
3 | Zend OPcache |
4 +----------------------------------------------------------------------+
5 | Copyright (c) The PHP Group |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 3.01 of the PHP license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | https://www.php.net/license/3_01.txt |
11 | If you did not receive a copy of the PHP license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@php.net so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Andi Gutmans <andi@php.net> |
16 | Zeev Suraski <zeev@php.net> |
17 | Stanislav Malyshev <stas@zend.com> |
18 | Dmitry Stogov <dmitry@php.net> |
19 +----------------------------------------------------------------------+
20 */
21
22 #include "zend.h"
23 #include "ZendAccelerator.h"
24 #include "zend_persist.h"
25 #include "zend_extensions.h"
26 #include "zend_shared_alloc.h"
27 #include "zend_operators.h"
28 #include "zend_attributes.h"
29 #include "zend_constants.h"
30
31 #define ADD_DUP_SIZE(m,s) ZCG(current_persistent_script)->size += zend_shared_memdup_size((void*)m, s)
32 #define ADD_SIZE(m) ZCG(current_persistent_script)->size += ZEND_ALIGNED_SIZE(m)
33
34 # define ADD_STRING(str) ADD_DUP_SIZE((str), _ZSTR_STRUCT_SIZE(ZSTR_LEN(str)))
35
36 # define ADD_INTERNED_STRING(str) do { \
37 if (ZCG(current_persistent_script)->corrupted) { \
38 ADD_STRING(str); \
39 } else if (!IS_ACCEL_INTERNED(str)) { \
40 zend_string *tmp = accel_new_interned_string(str); \
41 if (tmp != (str)) { \
42 (str) = tmp; \
43 } else { \
44 ADD_STRING(str); \
45 } \
46 } \
47 } while (0)
48
49 static void zend_persist_zval_calc(zval *z);
50 static void zend_persist_op_array_calc(zval *zv);
51
zend_hash_persist_calc(HashTable * ht)52 static void zend_hash_persist_calc(HashTable *ht)
53 {
54 if ((HT_FLAGS(ht) & HASH_FLAG_UNINITIALIZED) || ht->nNumUsed == 0) {
55 return;
56 }
57
58 if (HT_IS_PACKED(ht)) {
59 ADD_SIZE(HT_PACKED_USED_SIZE(ht));
60 } else if (ht->nNumUsed > HT_MIN_SIZE && ht->nNumUsed < (uint32_t)(-(int32_t)ht->nTableMask) / 4) {
61 /* compact table */
62 uint32_t hash_size;
63
64 hash_size = (uint32_t)(-(int32_t)ht->nTableMask);
65 while (hash_size >> 2 > ht->nNumUsed) {
66 hash_size >>= 1;
67 }
68 ADD_SIZE(hash_size * sizeof(uint32_t) + ht->nNumUsed * sizeof(Bucket));
69 } else {
70 ADD_SIZE(HT_USED_SIZE(ht));
71 }
72 }
73
zend_persist_ast_calc(zend_ast * ast)74 static void zend_persist_ast_calc(zend_ast *ast)
75 {
76 uint32_t i;
77
78 if (ast->kind == ZEND_AST_ZVAL || ast->kind == ZEND_AST_CONSTANT) {
79 ADD_SIZE(sizeof(zend_ast_zval));
80 zend_persist_zval_calc(&((zend_ast_zval*)(ast))->val);
81 } else if (zend_ast_is_list(ast)) {
82 zend_ast_list *list = zend_ast_get_list(ast);
83 ADD_SIZE(sizeof(zend_ast_list) - sizeof(zend_ast *) + sizeof(zend_ast *) * list->children);
84 for (i = 0; i < list->children; i++) {
85 if (list->child[i]) {
86 zend_persist_ast_calc(list->child[i]);
87 }
88 }
89 } else {
90 uint32_t children = zend_ast_get_num_children(ast);
91 ADD_SIZE(sizeof(zend_ast) - sizeof(zend_ast *) + sizeof(zend_ast *) * children);
92 for (i = 0; i < children; i++) {
93 if (ast->child[i]) {
94 zend_persist_ast_calc(ast->child[i]);
95 }
96 }
97 }
98 }
99
zend_persist_zval_calc(zval * z)100 static void zend_persist_zval_calc(zval *z)
101 {
102 uint32_t size;
103
104 switch (Z_TYPE_P(z)) {
105 case IS_STRING:
106 ADD_INTERNED_STRING(Z_STR_P(z));
107 if (ZSTR_IS_INTERNED(Z_STR_P(z))) {
108 Z_TYPE_FLAGS_P(z) = 0;
109 }
110 break;
111 case IS_ARRAY:
112 if (!ZCG(current_persistent_script)->corrupted
113 && zend_accel_in_shm(Z_ARR_P(z))) {
114 return;
115 }
116 size = zend_shared_memdup_size(Z_ARR_P(z), sizeof(zend_array));
117 if (size) {
118 HashTable *ht = Z_ARRVAL_P(z);
119
120 ADD_SIZE(size);
121 zend_hash_persist_calc(ht);
122 if (HT_IS_PACKED(ht)) {
123 zval *zv;
124
125 ZEND_HASH_PACKED_FOREACH_VAL(Z_ARRVAL_P(z), zv) {
126 zend_persist_zval_calc(zv);
127 } ZEND_HASH_FOREACH_END();
128 } else {
129 Bucket *p;
130
131 ZEND_HASH_MAP_FOREACH_BUCKET(Z_ARRVAL_P(z), p) {
132 if (p->key) {
133 ADD_INTERNED_STRING(p->key);
134 }
135 zend_persist_zval_calc(&p->val);
136 } ZEND_HASH_FOREACH_END();
137 }
138 }
139 break;
140 case IS_CONSTANT_AST:
141 if (ZCG(current_persistent_script)->corrupted
142 || !zend_accel_in_shm(Z_AST_P(z))) {
143 size = zend_shared_memdup_size(Z_AST_P(z), sizeof(zend_ast_ref));
144 if (size) {
145 ADD_SIZE(size);
146 zend_persist_ast_calc(Z_ASTVAL_P(z));
147 }
148 }
149 break;
150 default:
151 ZEND_ASSERT(Z_TYPE_P(z) < IS_STRING);
152 break;
153 }
154 }
155
zend_persist_attributes_calc(HashTable * attributes)156 static void zend_persist_attributes_calc(HashTable *attributes)
157 {
158 if (!zend_shared_alloc_get_xlat_entry(attributes)
159 && (ZCG(current_persistent_script)->corrupted
160 || !zend_accel_in_shm(attributes))) {
161 zend_attribute *attr;
162 uint32_t i;
163
164 zend_shared_alloc_register_xlat_entry(attributes, attributes);
165 ADD_SIZE(sizeof(HashTable));
166 zend_hash_persist_calc(attributes);
167
168 ZEND_HASH_PACKED_FOREACH_PTR(attributes, attr) {
169 ADD_SIZE(ZEND_ATTRIBUTE_SIZE(attr->argc));
170 ADD_INTERNED_STRING(attr->name);
171 ADD_INTERNED_STRING(attr->lcname);
172
173 for (i = 0; i < attr->argc; i++) {
174 if (attr->args[i].name) {
175 ADD_INTERNED_STRING(attr->args[i].name);
176 }
177 zend_persist_zval_calc(&attr->args[i].value);
178 }
179 } ZEND_HASH_FOREACH_END();
180 }
181 }
182
zend_persist_type_calc(zend_type * type)183 static void zend_persist_type_calc(zend_type *type)
184 {
185 if (ZEND_TYPE_HAS_LIST(*type)) {
186 ADD_SIZE(ZEND_TYPE_LIST_SIZE(ZEND_TYPE_LIST(*type)->num_types));
187 }
188
189 zend_type *single_type;
190 ZEND_TYPE_FOREACH(*type, single_type) {
191 if (ZEND_TYPE_HAS_LIST(*single_type)) {
192 zend_persist_type_calc(single_type);
193 continue;
194 }
195 if (ZEND_TYPE_HAS_NAME(*single_type)) {
196 zend_string *type_name = ZEND_TYPE_NAME(*single_type);
197 ADD_INTERNED_STRING(type_name);
198 ZEND_TYPE_SET_PTR(*single_type, type_name);
199 }
200 } ZEND_TYPE_FOREACH_END();
201 }
202
zend_persist_op_array_calc_ex(zend_op_array * op_array)203 static void zend_persist_op_array_calc_ex(zend_op_array *op_array)
204 {
205 if (op_array->function_name) {
206 zend_string *old_name = op_array->function_name;
207 ADD_INTERNED_STRING(op_array->function_name);
208 /* Remember old function name, so it can be released multiple times if shared. */
209 if (op_array->function_name != old_name
210 && !zend_shared_alloc_get_xlat_entry(&op_array->function_name)) {
211 zend_shared_alloc_register_xlat_entry(&op_array->function_name, old_name);
212 }
213 }
214
215 if (op_array->scope) {
216 if (zend_shared_alloc_get_xlat_entry(op_array->opcodes)) {
217 /* already stored */
218 ADD_SIZE(ZEND_ALIGNED_SIZE(zend_extensions_op_array_persist_calc(op_array)));
219 return;
220 }
221 }
222
223 if (op_array->scope
224 && !(op_array->fn_flags & ZEND_ACC_CLOSURE)
225 && (op_array->scope->ce_flags & ZEND_ACC_CACHED)) {
226 return;
227 }
228
229 if (op_array->static_variables && !zend_accel_in_shm(op_array->static_variables)) {
230 if (!zend_shared_alloc_get_xlat_entry(op_array->static_variables)) {
231 Bucket *p;
232
233 zend_shared_alloc_register_xlat_entry(op_array->static_variables, op_array->static_variables);
234 ADD_SIZE(sizeof(HashTable));
235 zend_hash_persist_calc(op_array->static_variables);
236 ZEND_HASH_MAP_FOREACH_BUCKET(op_array->static_variables, p) {
237 ZEND_ASSERT(p->key != NULL);
238 ADD_INTERNED_STRING(p->key);
239 zend_persist_zval_calc(&p->val);
240 } ZEND_HASH_FOREACH_END();
241 }
242 }
243
244 if (op_array->literals) {
245 zval *p = op_array->literals;
246 zval *end = p + op_array->last_literal;
247 ADD_SIZE(sizeof(zval) * op_array->last_literal);
248 while (p < end) {
249 zend_persist_zval_calc(p);
250 p++;
251 }
252 }
253
254 zend_shared_alloc_register_xlat_entry(op_array->opcodes, op_array->opcodes);
255 ADD_SIZE(sizeof(zend_op) * op_array->last);
256
257 if (op_array->filename) {
258 ADD_STRING(op_array->filename);
259 }
260
261 if (op_array->arg_info) {
262 zend_arg_info *arg_info = op_array->arg_info;
263 uint32_t num_args = op_array->num_args;
264 uint32_t i;
265
266 if (op_array->fn_flags & ZEND_ACC_VARIADIC) {
267 num_args++;
268 }
269 if (op_array->fn_flags & ZEND_ACC_HAS_RETURN_TYPE) {
270 arg_info--;
271 num_args++;
272 }
273 ADD_SIZE(sizeof(zend_arg_info) * num_args);
274 for (i = 0; i < num_args; i++) {
275 if (arg_info[i].name) {
276 ADD_INTERNED_STRING(arg_info[i].name);
277 }
278 zend_persist_type_calc(&arg_info[i].type);
279 }
280 }
281
282 if (op_array->live_range) {
283 ADD_SIZE(sizeof(zend_live_range) * op_array->last_live_range);
284 }
285
286 if (ZCG(accel_directives).save_comments && op_array->doc_comment) {
287 ADD_STRING(op_array->doc_comment);
288 }
289
290 if (op_array->attributes) {
291 zend_persist_attributes_calc(op_array->attributes);
292 }
293
294 if (op_array->try_catch_array) {
295 ADD_SIZE(sizeof(zend_try_catch_element) * op_array->last_try_catch);
296 }
297
298 if (op_array->vars) {
299 int i;
300
301 ADD_SIZE(sizeof(zend_string*) * op_array->last_var);
302 for (i = 0; i < op_array->last_var; i++) {
303 ADD_INTERNED_STRING(op_array->vars[i]);
304 }
305 }
306
307 if (op_array->num_dynamic_func_defs) {
308 ADD_SIZE(sizeof(void *) * op_array->num_dynamic_func_defs);
309 for (uint32_t i = 0; i < op_array->num_dynamic_func_defs; i++) {
310 zval tmp;
311 ZVAL_PTR(&tmp, op_array->dynamic_func_defs[i]);
312 zend_persist_op_array_calc(&tmp);
313 }
314 }
315
316 ADD_SIZE(ZEND_ALIGNED_SIZE(zend_extensions_op_array_persist_calc(op_array)));
317 }
318
zend_persist_op_array_calc(zval * zv)319 static void zend_persist_op_array_calc(zval *zv)
320 {
321 zend_op_array *op_array = Z_PTR_P(zv);
322 ZEND_ASSERT(op_array->type == ZEND_USER_FUNCTION);
323 if (!zend_shared_alloc_get_xlat_entry(op_array)) {
324 zend_shared_alloc_register_xlat_entry(op_array, op_array);
325 ADD_SIZE(sizeof(zend_op_array));
326 zend_persist_op_array_calc_ex(op_array);
327 } else {
328 /* This can happen during preloading, if a dynamic function definition is declared. */
329 }
330 }
331
zend_persist_class_method_calc(zval * zv)332 static void zend_persist_class_method_calc(zval *zv)
333 {
334 zend_op_array *op_array = Z_PTR_P(zv);
335 zend_op_array *old_op_array;
336
337 if (op_array->type != ZEND_USER_FUNCTION) {
338 ZEND_ASSERT(op_array->type == ZEND_INTERNAL_FUNCTION);
339 if (op_array->fn_flags & ZEND_ACC_ARENA_ALLOCATED) {
340 old_op_array = zend_shared_alloc_get_xlat_entry(op_array);
341 if (!old_op_array) {
342 ADD_SIZE(sizeof(zend_internal_function));
343 zend_shared_alloc_register_xlat_entry(op_array, Z_PTR_P(zv));
344 }
345 }
346 return;
347 }
348
349 if ((op_array->fn_flags & ZEND_ACC_IMMUTABLE)
350 && !ZCG(current_persistent_script)->corrupted
351 && zend_accel_in_shm(op_array)) {
352 zend_shared_alloc_register_xlat_entry(op_array, op_array);
353 return;
354 }
355
356 old_op_array = zend_shared_alloc_get_xlat_entry(op_array);
357 if (!old_op_array) {
358 ADD_SIZE(sizeof(zend_op_array));
359 zend_persist_op_array_calc_ex(Z_PTR_P(zv));
360 zend_shared_alloc_register_xlat_entry(op_array, Z_PTR_P(zv));
361 } else {
362 /* If op_array is shared, the function name refcount is still incremented for each use,
363 * so we need to release it here. We remembered the original function name in xlat. */
364 zend_string *old_function_name =
365 zend_shared_alloc_get_xlat_entry(&old_op_array->function_name);
366 if (old_function_name) {
367 zend_string_release_ex(old_function_name, 0);
368 }
369 }
370 }
371
zend_persist_property_info_calc(zend_property_info * prop)372 static void zend_persist_property_info_calc(zend_property_info *prop)
373 {
374 ADD_SIZE(sizeof(zend_property_info));
375 ADD_INTERNED_STRING(prop->name);
376 zend_persist_type_calc(&prop->type);
377 if (ZCG(accel_directives).save_comments && prop->doc_comment) {
378 ADD_STRING(prop->doc_comment);
379 }
380 if (prop->attributes) {
381 zend_persist_attributes_calc(prop->attributes);
382 }
383 }
384
zend_persist_class_constant_calc(zval * zv)385 static void zend_persist_class_constant_calc(zval *zv)
386 {
387 zend_class_constant *c = Z_PTR_P(zv);
388
389 if (!zend_shared_alloc_get_xlat_entry(c)) {
390 if (((c->ce->ce_flags & ZEND_ACC_IMMUTABLE) && !(Z_CONSTANT_FLAGS(c->value) & CONST_OWNED))
391 || c->ce->type == ZEND_INTERNAL_CLASS) {
392 /* Class constant comes from a different file in shm or internal class, keep existing pointer. */
393 return;
394 }
395 if (!ZCG(current_persistent_script)->corrupted
396 && zend_accel_in_shm(Z_PTR_P(zv))) {
397 return;
398 }
399 zend_shared_alloc_register_xlat_entry(c, c);
400 ADD_SIZE(sizeof(zend_class_constant));
401 zend_persist_zval_calc(&c->value);
402 if (ZCG(accel_directives).save_comments && c->doc_comment) {
403 ADD_STRING(c->doc_comment);
404 }
405 if (c->attributes) {
406 zend_persist_attributes_calc(c->attributes);
407 }
408 }
409 }
410
zend_persist_class_entry_calc(zend_class_entry * ce)411 void zend_persist_class_entry_calc(zend_class_entry *ce)
412 {
413 Bucket *p;
414
415 if (ce->type == ZEND_USER_CLASS) {
416 /* The same zend_class_entry may be reused by class_alias */
417 if (zend_shared_alloc_get_xlat_entry(ce)) {
418 return;
419 }
420 zend_shared_alloc_register_xlat_entry(ce, ce);
421
422 ADD_SIZE(sizeof(zend_class_entry));
423
424 if (!(ce->ce_flags & ZEND_ACC_CACHED)) {
425 ADD_INTERNED_STRING(ce->name);
426 if (ce->parent_name && !(ce->ce_flags & ZEND_ACC_LINKED)) {
427 ADD_INTERNED_STRING(ce->parent_name);
428 }
429 }
430
431 zend_hash_persist_calc(&ce->function_table);
432 ZEND_HASH_MAP_FOREACH_BUCKET(&ce->function_table, p) {
433 ZEND_ASSERT(p->key != NULL);
434 ADD_INTERNED_STRING(p->key);
435 zend_persist_class_method_calc(&p->val);
436 } ZEND_HASH_FOREACH_END();
437 if (ce->default_properties_table) {
438 int i;
439
440 ADD_SIZE(sizeof(zval) * ce->default_properties_count);
441 for (i = 0; i < ce->default_properties_count; i++) {
442 zend_persist_zval_calc(&ce->default_properties_table[i]);
443 }
444 }
445 if (ce->default_static_members_table) {
446 int i;
447
448 ADD_SIZE(sizeof(zval) * ce->default_static_members_count);
449 for (i = 0; i < ce->default_static_members_count; i++) {
450 if (Z_TYPE(ce->default_static_members_table[i]) != IS_INDIRECT) {
451 zend_persist_zval_calc(&ce->default_static_members_table[i]);
452 }
453 }
454 }
455 zend_hash_persist_calc(&ce->constants_table);
456 ZEND_HASH_MAP_FOREACH_BUCKET(&ce->constants_table, p) {
457 ZEND_ASSERT(p->key != NULL);
458 ADD_INTERNED_STRING(p->key);
459 zend_persist_class_constant_calc(&p->val);
460 } ZEND_HASH_FOREACH_END();
461
462 zend_hash_persist_calc(&ce->properties_info);
463 ZEND_HASH_MAP_FOREACH_BUCKET(&ce->properties_info, p) {
464 zend_property_info *prop = Z_PTR(p->val);
465 ZEND_ASSERT(p->key != NULL);
466 ADD_INTERNED_STRING(p->key);
467 if (prop->ce == ce) {
468 zend_persist_property_info_calc(prop);
469 }
470 } ZEND_HASH_FOREACH_END();
471
472 if (ce->properties_info_table) {
473 ADD_SIZE(sizeof(zend_property_info *) * ce->default_properties_count);
474 }
475
476 if (ce->num_interfaces && (ce->ce_flags & ZEND_ACC_LINKED)) {
477 ADD_SIZE(sizeof(zend_class_entry*) * ce->num_interfaces);
478 }
479
480 if (ce->iterator_funcs_ptr) {
481 ADD_SIZE(sizeof(zend_class_iterator_funcs));
482 }
483 if (ce->arrayaccess_funcs_ptr) {
484 ADD_SIZE(sizeof(zend_class_arrayaccess_funcs));
485 }
486
487 if (ce->ce_flags & ZEND_ACC_CACHED) {
488 return;
489 }
490
491 if (ce->info.user.filename) {
492 ADD_STRING(ce->info.user.filename);
493 }
494
495 if (ZCG(accel_directives).save_comments && ce->info.user.doc_comment) {
496 ADD_STRING(ce->info.user.doc_comment);
497 }
498
499 if (ce->attributes) {
500 zend_persist_attributes_calc(ce->attributes);
501 }
502
503 if (ce->num_interfaces) {
504 uint32_t i;
505
506 if (!(ce->ce_flags & ZEND_ACC_LINKED)) {
507 for (i = 0; i < ce->num_interfaces; i++) {
508 ADD_INTERNED_STRING(ce->interface_names[i].name);
509 ADD_INTERNED_STRING(ce->interface_names[i].lc_name);
510 }
511 ADD_SIZE(sizeof(zend_class_name) * ce->num_interfaces);
512 }
513 }
514
515 if (ce->num_traits) {
516 uint32_t i;
517
518 for (i = 0; i < ce->num_traits; i++) {
519 ADD_INTERNED_STRING(ce->trait_names[i].name);
520 ADD_INTERNED_STRING(ce->trait_names[i].lc_name);
521 }
522 ADD_SIZE(sizeof(zend_class_name) * ce->num_traits);
523
524 if (ce->trait_aliases) {
525 i = 0;
526 while (ce->trait_aliases[i]) {
527 if (ce->trait_aliases[i]->trait_method.method_name) {
528 ADD_INTERNED_STRING(ce->trait_aliases[i]->trait_method.method_name);
529 }
530 if (ce->trait_aliases[i]->trait_method.class_name) {
531 ADD_INTERNED_STRING(ce->trait_aliases[i]->trait_method.class_name);
532 }
533
534 if (ce->trait_aliases[i]->alias) {
535 ADD_INTERNED_STRING(ce->trait_aliases[i]->alias);
536 }
537 ADD_SIZE(sizeof(zend_trait_alias));
538 i++;
539 }
540 ADD_SIZE(sizeof(zend_trait_alias*) * (i + 1));
541 }
542
543 if (ce->trait_precedences) {
544 int j;
545
546 i = 0;
547 while (ce->trait_precedences[i]) {
548 ADD_INTERNED_STRING(ce->trait_precedences[i]->trait_method.method_name);
549 ADD_INTERNED_STRING(ce->trait_precedences[i]->trait_method.class_name);
550
551 for (j = 0; j < ce->trait_precedences[i]->num_excludes; j++) {
552 ADD_INTERNED_STRING(ce->trait_precedences[i]->exclude_class_names[j]);
553 }
554 ADD_SIZE(sizeof(zend_trait_precedence) + (ce->trait_precedences[i]->num_excludes - 1) * sizeof(zend_string*));
555 i++;
556 }
557 ADD_SIZE(sizeof(zend_trait_precedence*) * (i + 1));
558 }
559 }
560 }
561 }
562
zend_accel_persist_class_table_calc(HashTable * class_table)563 static void zend_accel_persist_class_table_calc(HashTable *class_table)
564 {
565 Bucket *p;
566
567 zend_hash_persist_calc(class_table);
568 ZEND_HASH_MAP_FOREACH_BUCKET(class_table, p) {
569 ZEND_ASSERT(p->key != NULL);
570 ADD_INTERNED_STRING(p->key);
571 zend_persist_class_entry_calc(Z_CE(p->val));
572 } ZEND_HASH_FOREACH_END();
573 }
574
zend_persist_warnings_calc(uint32_t num_warnings,zend_error_info ** warnings)575 void zend_persist_warnings_calc(uint32_t num_warnings, zend_error_info **warnings) {
576 ADD_SIZE(num_warnings * sizeof(zend_error_info *));
577 for (uint32_t i = 0; i < num_warnings; i++) {
578 ADD_SIZE(sizeof(zend_error_info));
579 ADD_STRING(warnings[i]->filename);
580 ADD_STRING(warnings[i]->message);
581 }
582 }
583
zend_persist_early_bindings_calc(uint32_t num_early_bindings,zend_early_binding * early_bindings)584 static void zend_persist_early_bindings_calc(
585 uint32_t num_early_bindings, zend_early_binding *early_bindings)
586 {
587 ADD_SIZE(sizeof(zend_early_binding) * num_early_bindings);
588 for (uint32_t i = 0; i < num_early_bindings; i++) {
589 zend_early_binding *early_binding = &early_bindings[i];
590 ADD_INTERNED_STRING(early_binding->lcname);
591 ADD_INTERNED_STRING(early_binding->rtd_key);
592 ADD_INTERNED_STRING(early_binding->lc_parent_name);
593 }
594 }
595
zend_accel_script_persist_calc(zend_persistent_script * new_persistent_script,int for_shm)596 uint32_t zend_accel_script_persist_calc(zend_persistent_script *new_persistent_script, int for_shm)
597 {
598 Bucket *p;
599
600 new_persistent_script->mem = NULL;
601 new_persistent_script->size = 0;
602 new_persistent_script->corrupted = false;
603 ZCG(current_persistent_script) = new_persistent_script;
604
605 if (!for_shm) {
606 /* script is not going to be saved in SHM */
607 new_persistent_script->corrupted = true;
608 }
609
610 ADD_SIZE(sizeof(zend_persistent_script));
611 ADD_INTERNED_STRING(new_persistent_script->script.filename);
612
613 #if defined(__AVX__) || defined(__SSE2__)
614 /* Align size to 64-byte boundary */
615 new_persistent_script->size = (new_persistent_script->size + 63) & ~63;
616 #endif
617
618 if (new_persistent_script->script.class_table.nNumUsed != new_persistent_script->script.class_table.nNumOfElements) {
619 zend_hash_rehash(&new_persistent_script->script.class_table);
620 }
621 zend_accel_persist_class_table_calc(&new_persistent_script->script.class_table);
622 if (new_persistent_script->script.function_table.nNumUsed != new_persistent_script->script.function_table.nNumOfElements) {
623 zend_hash_rehash(&new_persistent_script->script.function_table);
624 }
625 zend_hash_persist_calc(&new_persistent_script->script.function_table);
626 ZEND_HASH_MAP_FOREACH_BUCKET(&new_persistent_script->script.function_table, p) {
627 ZEND_ASSERT(p->key != NULL);
628 ADD_INTERNED_STRING(p->key);
629 zend_persist_op_array_calc(&p->val);
630 } ZEND_HASH_FOREACH_END();
631 zend_persist_op_array_calc_ex(&new_persistent_script->script.main_op_array);
632 zend_persist_warnings_calc(
633 new_persistent_script->num_warnings, new_persistent_script->warnings);
634 zend_persist_early_bindings_calc(
635 new_persistent_script->num_early_bindings, new_persistent_script->early_bindings);
636
637 new_persistent_script->corrupted = false;
638
639 ZCG(current_persistent_script) = NULL;
640
641 return new_persistent_script->size;
642 }
643
