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