1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 2.00 of the Zend 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 | http://www.zend.com/license/2_00.txt. |
11 | If you did not receive a copy of the Zend license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@zend.com so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Andi Gutmans <andi@php.net> |
16 | Zeev Suraski <zeev@php.net> |
17 | Dmitry Stogov <dmitry@php.net> |
18 | Xinchen Hui <laruence@php.net> |
19 +----------------------------------------------------------------------+
20 */
21
22 #ifndef ZEND_TYPES_H
23 #define ZEND_TYPES_H
24
25 #include "zend_portability.h"
26 #include "zend_long.h"
27 #include <stdbool.h>
28
29 #ifdef __SSE2__
30 # include <mmintrin.h>
31 # include <emmintrin.h>
32 #endif
33
34 #ifdef WORDS_BIGENDIAN
35 # define ZEND_ENDIAN_LOHI(lo, hi) hi; lo;
36 # define ZEND_ENDIAN_LOHI_3(lo, mi, hi) hi; mi; lo;
37 # define ZEND_ENDIAN_LOHI_4(a, b, c, d) d; c; b; a;
38 # define ZEND_ENDIAN_LOHI_C(lo, hi) hi, lo
39 # define ZEND_ENDIAN_LOHI_C_3(lo, mi, hi) hi, mi, lo,
40 # define ZEND_ENDIAN_LOHI_C_4(a, b, c, d) d, c, b, a
41 #else
42 # define ZEND_ENDIAN_LOHI(lo, hi) lo; hi;
43 # define ZEND_ENDIAN_LOHI_3(lo, mi, hi) lo; mi; hi;
44 # define ZEND_ENDIAN_LOHI_4(a, b, c, d) a; b; c; d;
45 # define ZEND_ENDIAN_LOHI_C(lo, hi) lo, hi
46 # define ZEND_ENDIAN_LOHI_C_3(lo, mi, hi) lo, mi, hi,
47 # define ZEND_ENDIAN_LOHI_C_4(a, b, c, d) a, b, c, d
48 #endif
49
50 typedef bool zend_bool;
51 typedef unsigned char zend_uchar;
52
53 typedef enum {
54 SUCCESS = 0,
55 FAILURE = -1, /* this MUST stay a negative number, or it may affect functions! */
56 } ZEND_RESULT_CODE;
57
58 typedef ZEND_RESULT_CODE zend_result;
59
60 #ifdef ZEND_ENABLE_ZVAL_LONG64
61 # ifdef ZEND_WIN32
62 # define ZEND_SIZE_MAX _UI64_MAX
63 # else
64 # define ZEND_SIZE_MAX SIZE_MAX
65 # endif
66 #else
67 # if defined(ZEND_WIN32)
68 # define ZEND_SIZE_MAX _UI32_MAX
69 # else
70 # define ZEND_SIZE_MAX SIZE_MAX
71 # endif
72 #endif
73
74 typedef intptr_t zend_intptr_t;
75 typedef uintptr_t zend_uintptr_t;
76
77 #ifdef ZTS
78 #define ZEND_TLS static TSRM_TLS
79 #define ZEND_EXT_TLS TSRM_TLS
80 #else
81 #define ZEND_TLS static
82 #define ZEND_EXT_TLS
83 #endif
84
85 typedef struct _zend_object_handlers zend_object_handlers;
86 typedef struct _zend_class_entry zend_class_entry;
87 typedef union _zend_function zend_function;
88 typedef struct _zend_execute_data zend_execute_data;
89
90 typedef struct _zval_struct zval;
91
92 typedef struct _zend_refcounted zend_refcounted;
93 typedef struct _zend_string zend_string;
94 typedef struct _zend_array zend_array;
95 typedef struct _zend_object zend_object;
96 typedef struct _zend_resource zend_resource;
97 typedef struct _zend_reference zend_reference;
98 typedef struct _zend_ast_ref zend_ast_ref;
99 typedef struct _zend_ast zend_ast;
100
101 typedef int (*compare_func_t)(const void *, const void *);
102 typedef void (*swap_func_t)(void *, void *);
103 typedef void (*sort_func_t)(void *, size_t, size_t, compare_func_t, swap_func_t);
104 typedef void (*dtor_func_t)(zval *pDest);
105 typedef void (*copy_ctor_func_t)(zval *pElement);
106
107 /*
108 * zend_type - is an abstraction layer to represent information about type hint.
109 * It shouldn't be used directly. Only through ZEND_TYPE_* macros.
110 *
111 * ZEND_TYPE_IS_SET() - checks if there is a type-hint
112 * ZEND_TYPE_IS_ONLY_MASK() - checks if type-hint refer to standard type only
113 * ZEND_TYPE_IS_COMPLEX() - checks if type is a type_list, or contains a class either as a CE or as a name
114 * ZEND_TYPE_HAS_NAME() - checks if type-hint contains some class as zend_string *
115 * ZEND_TYPE_IS_INTERSECTION() - checks if the type_list represents an intersection type list
116 * ZEND_TYPE_IS_UNION() - checks if the type_list represents a union type list
117 *
118 * ZEND_TYPE_NAME() - returns referenced class name
119 * ZEND_TYPE_PURE_MASK() - returns MAY_BE_* type mask
120 * ZEND_TYPE_FULL_MASK() - returns MAY_BE_* type mask together with other flags
121 *
122 * ZEND_TYPE_ALLOW_NULL() - checks if NULL is allowed
123 *
124 * ZEND_TYPE_INIT_*() should be used for construction.
125 */
126
127 typedef struct {
128 /* Not using a union here, because there's no good way to initialize them
129 * in a way that is supported in both C and C++ (designated initializers
130 * are only supported since C++20). */
131 void *ptr;
132 uint32_t type_mask;
133 /* TODO: We could use the extra 32-bit of padding on 64-bit systems. */
134 } zend_type;
135
136 typedef struct {
137 uint32_t num_types;
138 zend_type types[1];
139 } zend_type_list;
140
141 #define _ZEND_TYPE_EXTRA_FLAGS_SHIFT 25
142 #define _ZEND_TYPE_MASK ((1u << 25) - 1)
143 /* Only one of these bits may be set. */
144 #define _ZEND_TYPE_NAME_BIT (1u << 24)
145 #define _ZEND_TYPE_LIST_BIT (1u << 22)
146 #define _ZEND_TYPE_KIND_MASK (_ZEND_TYPE_LIST_BIT|_ZEND_TYPE_NAME_BIT)
147 /* TODO: bit 21 is not used */
148 /* Whether the type list is arena allocated */
149 #define _ZEND_TYPE_ARENA_BIT (1u << 20)
150 /* Whether the type list is an intersection type */
151 #define _ZEND_TYPE_INTERSECTION_BIT (1u << 19)
152 /* Whether the type is a union type */
153 #define _ZEND_TYPE_UNION_BIT (1u << 18)
154 /* Type mask excluding the flags above. */
155 #define _ZEND_TYPE_MAY_BE_MASK ((1u << 18) - 1)
156 /* Must have same value as MAY_BE_NULL */
157 #define _ZEND_TYPE_NULLABLE_BIT 0x2u
158
159 #define ZEND_TYPE_IS_SET(t) \
160 (((t).type_mask & _ZEND_TYPE_MASK) != 0)
161
162 /* If a type is complex it means it's either a list with a union or intersection,
163 * or the void pointer is a class name */
164 #define ZEND_TYPE_IS_COMPLEX(t) \
165 ((((t).type_mask) & _ZEND_TYPE_KIND_MASK) != 0)
166
167 #define ZEND_TYPE_HAS_NAME(t) \
168 ((((t).type_mask) & _ZEND_TYPE_NAME_BIT) != 0)
169
170 #define ZEND_TYPE_HAS_LIST(t) \
171 ((((t).type_mask) & _ZEND_TYPE_LIST_BIT) != 0)
172
173 #define ZEND_TYPE_IS_INTERSECTION(t) \
174 ((((t).type_mask) & _ZEND_TYPE_INTERSECTION_BIT) != 0)
175
176 #define ZEND_TYPE_IS_UNION(t) \
177 ((((t).type_mask) & _ZEND_TYPE_UNION_BIT) != 0)
178
179 #define ZEND_TYPE_USES_ARENA(t) \
180 ((((t).type_mask) & _ZEND_TYPE_ARENA_BIT) != 0)
181
182 #define ZEND_TYPE_IS_ONLY_MASK(t) \
183 (ZEND_TYPE_IS_SET(t) && (t).ptr == NULL)
184
185 #define ZEND_TYPE_NAME(t) \
186 ((zend_string *) (t).ptr)
187
188 #define ZEND_TYPE_LITERAL_NAME(t) \
189 ((const char *) (t).ptr)
190
191 #define ZEND_TYPE_LIST(t) \
192 ((zend_type_list *) (t).ptr)
193
194 #define ZEND_TYPE_LIST_SIZE(num_types) \
195 (sizeof(zend_type_list) + ((num_types) - 1) * sizeof(zend_type))
196
197 /* This iterates over a zend_type_list. */
198 #define ZEND_TYPE_LIST_FOREACH(list, type_ptr) do { \
199 zend_type *_list = (list)->types; \
200 zend_type *_end = _list + (list)->num_types; \
201 for (; _list < _end; _list++) { \
202 type_ptr = _list;
203
204 #define ZEND_TYPE_LIST_FOREACH_END() \
205 } \
206 } while (0)
207
208 /* This iterates over any zend_type. If it's a type list, all list elements will
209 * be visited. If it's a single type, only the single type is visited. */
210 #define ZEND_TYPE_FOREACH(type, type_ptr) do { \
211 zend_type *_cur, *_end; \
212 if (ZEND_TYPE_HAS_LIST(type)) { \
213 zend_type_list *_list = ZEND_TYPE_LIST(type); \
214 _cur = _list->types; \
215 _end = _cur + _list->num_types; \
216 } else { \
217 _cur = &(type); \
218 _end = _cur + 1; \
219 } \
220 do { \
221 type_ptr = _cur;
222
223 #define ZEND_TYPE_FOREACH_END() \
224 } while (++_cur < _end); \
225 } while (0)
226
227 #define ZEND_TYPE_SET_PTR(t, _ptr) \
228 ((t).ptr = (_ptr))
229
230 #define ZEND_TYPE_SET_PTR_AND_KIND(t, _ptr, kind_bit) do { \
231 (t).ptr = (_ptr); \
232 (t).type_mask &= ~_ZEND_TYPE_KIND_MASK; \
233 (t).type_mask |= (kind_bit); \
234 } while (0)
235
236 #define ZEND_TYPE_SET_LIST(t, list) \
237 ZEND_TYPE_SET_PTR_AND_KIND(t, list, _ZEND_TYPE_LIST_BIT)
238
239 /* FULL_MASK() includes the MAY_BE_* type mask, as well as additional metadata bits.
240 * The PURE_MASK() only includes the MAY_BE_* type mask. */
241 #define ZEND_TYPE_FULL_MASK(t) \
242 ((t).type_mask)
243
244 #define ZEND_TYPE_PURE_MASK(t) \
245 ((t).type_mask & _ZEND_TYPE_MAY_BE_MASK)
246
247 #define ZEND_TYPE_FULL_MASK_WITHOUT_NULL(t) \
248 ((t).type_mask & ~_ZEND_TYPE_NULLABLE_BIT)
249
250 #define ZEND_TYPE_PURE_MASK_WITHOUT_NULL(t) \
251 ((t).type_mask & _ZEND_TYPE_MAY_BE_MASK & ~_ZEND_TYPE_NULLABLE_BIT)
252
253 #define ZEND_TYPE_CONTAINS_CODE(t, code) \
254 (((t).type_mask & (1u << (code))) != 0)
255
256 #define ZEND_TYPE_ALLOW_NULL(t) \
257 (((t).type_mask & _ZEND_TYPE_NULLABLE_BIT) != 0)
258
259 #define ZEND_TYPE_INIT_NONE(extra_flags) \
260 { NULL, (extra_flags) }
261
262 #define ZEND_TYPE_INIT_MASK(_type_mask) \
263 { NULL, (_type_mask) }
264
265 #define ZEND_TYPE_INIT_CODE(code, allow_null, extra_flags) \
266 ZEND_TYPE_INIT_MASK(((code) == _IS_BOOL ? MAY_BE_BOOL : ((code) == IS_MIXED ? MAY_BE_ANY : (1 << (code)))) \
267 | ((allow_null) ? _ZEND_TYPE_NULLABLE_BIT : 0) | (extra_flags))
268
269 #define ZEND_TYPE_INIT_PTR(ptr, type_kind, allow_null, extra_flags) \
270 { (void *) (ptr), \
271 (type_kind) | ((allow_null) ? _ZEND_TYPE_NULLABLE_BIT : 0) | (extra_flags) }
272
273 #define ZEND_TYPE_INIT_PTR_MASK(ptr, type_mask) \
274 { (void *) (ptr), (type_mask) }
275
276 #define ZEND_TYPE_INIT_UNION(ptr, extra_flags) \
277 { (void *) (ptr), (_ZEND_TYPE_LIST_BIT|_ZEND_TYPE_UNION_BIT) | (extra_flags) }
278
279 #define ZEND_TYPE_INIT_CLASS(class_name, allow_null, extra_flags) \
280 ZEND_TYPE_INIT_PTR(class_name, _ZEND_TYPE_NAME_BIT, allow_null, extra_flags)
281
282 #define ZEND_TYPE_INIT_CLASS_CONST(class_name, allow_null, extra_flags) \
283 ZEND_TYPE_INIT_PTR(class_name, _ZEND_TYPE_NAME_BIT, allow_null, extra_flags)
284
285 #define ZEND_TYPE_INIT_CLASS_CONST_MASK(class_name, type_mask) \
286 ZEND_TYPE_INIT_PTR_MASK(class_name, _ZEND_TYPE_NAME_BIT | (type_mask))
287
288 typedef union _zend_value {
289 zend_long lval; /* long value */
290 double dval; /* double value */
291 zend_refcounted *counted;
292 zend_string *str;
293 zend_array *arr;
294 zend_object *obj;
295 zend_resource *res;
296 zend_reference *ref;
297 zend_ast_ref *ast;
298 zval *zv;
299 void *ptr;
300 zend_class_entry *ce;
301 zend_function *func;
302 struct {
303 uint32_t w1;
304 uint32_t w2;
305 } ww;
306 } zend_value;
307
308 struct _zval_struct {
309 zend_value value; /* value */
310 union {
311 uint32_t type_info;
312 struct {
313 ZEND_ENDIAN_LOHI_3(
314 zend_uchar type, /* active type */
315 zend_uchar type_flags,
316 union {
317 uint16_t extra; /* not further specified */
318 } u)
319 } v;
320 } u1;
321 union {
322 uint32_t next; /* hash collision chain */
323 uint32_t cache_slot; /* cache slot (for RECV_INIT) */
324 uint32_t opline_num; /* opline number (for FAST_CALL) */
325 uint32_t lineno; /* line number (for ast nodes) */
326 uint32_t num_args; /* arguments number for EX(This) */
327 uint32_t fe_pos; /* foreach position */
328 uint32_t fe_iter_idx; /* foreach iterator index */
329 uint32_t property_guard; /* single property guard */
330 uint32_t constant_flags; /* constant flags */
331 uint32_t extra; /* not further specified */
332 } u2;
333 };
334
335 typedef struct _zend_refcounted_h {
336 uint32_t refcount; /* reference counter 32-bit */
337 union {
338 uint32_t type_info;
339 } u;
340 } zend_refcounted_h;
341
342 struct _zend_refcounted {
343 zend_refcounted_h gc;
344 };
345
346 struct _zend_string {
347 zend_refcounted_h gc;
348 zend_ulong h; /* hash value */
349 size_t len;
350 char val[1];
351 };
352
353 typedef struct _Bucket {
354 zval val;
355 zend_ulong h; /* hash value (or numeric index) */
356 zend_string *key; /* string key or NULL for numerics */
357 } Bucket;
358
359 typedef struct _zend_array HashTable;
360
361 struct _zend_array {
362 zend_refcounted_h gc;
363 union {
364 struct {
365 ZEND_ENDIAN_LOHI_4(
366 zend_uchar flags,
367 zend_uchar _unused,
368 zend_uchar nIteratorsCount,
369 zend_uchar _unused2)
370 } v;
371 uint32_t flags;
372 } u;
373 uint32_t nTableMask;
374 Bucket *arData;
375 uint32_t nNumUsed;
376 uint32_t nNumOfElements;
377 uint32_t nTableSize;
378 uint32_t nInternalPointer;
379 zend_long nNextFreeElement;
380 dtor_func_t pDestructor;
381 };
382
383 /*
384 * HashTable Data Layout
385 * =====================
386 *
387 * +=============================+
388 * | HT_HASH(ht, ht->nTableMask) |
389 * | ... |
390 * | HT_HASH(ht, -1) |
391 * +-----------------------------+
392 * ht->arData ---> | Bucket[0] |
393 * | ... |
394 * | Bucket[ht->nTableSize-1] |
395 * +=============================+
396 */
397
398 #define HT_INVALID_IDX ((uint32_t) -1)
399
400 #define HT_MIN_MASK ((uint32_t) -2)
401 #define HT_MIN_SIZE 8
402
403 /* HT_MAX_SIZE is chosen to satisfy the following constraints:
404 * - HT_SIZE_TO_MASK(HT_MAX_SIZE) != 0
405 * - HT_SIZE_EX(HT_MAX_SIZE, HT_SIZE_TO_MASK(HT_MAX_SIZE)) does not overflow or
406 * wrapparound, and is <= the addressable space size
407 * - HT_MAX_SIZE must be a power of two:
408 * (nTableSize<HT_MAX_SIZE ? nTableSize+nTableSize : nTableSize) <= HT_MAX_SIZE
409 */
410 #if SIZEOF_SIZE_T == 4
411 # define HT_MAX_SIZE 0x02000000
412 # define HT_HASH_TO_BUCKET_EX(data, idx) \
413 ((Bucket*)((char*)(data) + (idx)))
414 # define HT_IDX_TO_HASH(idx) \
415 ((idx) * sizeof(Bucket))
416 # define HT_HASH_TO_IDX(idx) \
417 ((idx) / sizeof(Bucket))
418 #elif SIZEOF_SIZE_T == 8
419 # define HT_MAX_SIZE 0x40000000
420 # define HT_HASH_TO_BUCKET_EX(data, idx) \
421 ((data) + (idx))
422 # define HT_IDX_TO_HASH(idx) \
423 (idx)
424 # define HT_HASH_TO_IDX(idx) \
425 (idx)
426 #else
427 # error "Unknown SIZEOF_SIZE_T"
428 #endif
429
430 #define HT_HASH_EX(data, idx) \
431 ((uint32_t*)(data))[(int32_t)(idx)]
432 #define HT_HASH(ht, idx) \
433 HT_HASH_EX((ht)->arData, idx)
434
435 #define HT_SIZE_TO_MASK(nTableSize) \
436 ((uint32_t)(-((nTableSize) + (nTableSize))))
437 #define HT_HASH_SIZE(nTableMask) \
438 (((size_t)-(uint32_t)(nTableMask)) * sizeof(uint32_t))
439 #define HT_DATA_SIZE(nTableSize) \
440 ((size_t)(nTableSize) * sizeof(Bucket))
441 #define HT_SIZE_EX(nTableSize, nTableMask) \
442 (HT_DATA_SIZE((nTableSize)) + HT_HASH_SIZE((nTableMask)))
443 #define HT_SIZE(ht) \
444 HT_SIZE_EX((ht)->nTableSize, (ht)->nTableMask)
445 #define HT_USED_SIZE(ht) \
446 (HT_HASH_SIZE((ht)->nTableMask) + ((size_t)(ht)->nNumUsed * sizeof(Bucket)))
447 #ifdef __SSE2__
448 # define HT_HASH_RESET(ht) do { \
449 char *p = (char*)&HT_HASH(ht, (ht)->nTableMask); \
450 size_t size = HT_HASH_SIZE((ht)->nTableMask); \
451 __m128i xmm0 = _mm_setzero_si128(); \
452 xmm0 = _mm_cmpeq_epi8(xmm0, xmm0); \
453 ZEND_ASSERT(size >= 64 && ((size & 0x3f) == 0)); \
454 do { \
455 _mm_storeu_si128((__m128i*)p, xmm0); \
456 _mm_storeu_si128((__m128i*)(p+16), xmm0); \
457 _mm_storeu_si128((__m128i*)(p+32), xmm0); \
458 _mm_storeu_si128((__m128i*)(p+48), xmm0); \
459 p += 64; \
460 size -= 64; \
461 } while (size != 0); \
462 } while (0)
463 #else
464 # define HT_HASH_RESET(ht) \
465 memset(&HT_HASH(ht, (ht)->nTableMask), HT_INVALID_IDX, HT_HASH_SIZE((ht)->nTableMask))
466 #endif
467 #define HT_HASH_RESET_PACKED(ht) do { \
468 HT_HASH(ht, -2) = HT_INVALID_IDX; \
469 HT_HASH(ht, -1) = HT_INVALID_IDX; \
470 } while (0)
471 #define HT_HASH_TO_BUCKET(ht, idx) \
472 HT_HASH_TO_BUCKET_EX((ht)->arData, idx)
473
474 #define HT_SET_DATA_ADDR(ht, ptr) do { \
475 (ht)->arData = (Bucket*)(((char*)(ptr)) + HT_HASH_SIZE((ht)->nTableMask)); \
476 } while (0)
477 #define HT_GET_DATA_ADDR(ht) \
478 ((char*)((ht)->arData) - HT_HASH_SIZE((ht)->nTableMask))
479
480 typedef uint32_t HashPosition;
481
482 typedef struct _HashTableIterator {
483 HashTable *ht;
484 HashPosition pos;
485 } HashTableIterator;
486
487 struct _zend_object {
488 zend_refcounted_h gc;
489 uint32_t handle; // TODO: may be removed ???
490 zend_class_entry *ce;
491 const zend_object_handlers *handlers;
492 HashTable *properties;
493 zval properties_table[1];
494 };
495
496 struct _zend_resource {
497 zend_refcounted_h gc;
498 zend_long handle; // TODO: may be removed ???
499 int type;
500 void *ptr;
501 };
502
503 typedef struct {
504 size_t num;
505 size_t num_allocated;
506 struct _zend_property_info *ptr[1];
507 } zend_property_info_list;
508
509 typedef union {
510 struct _zend_property_info *ptr;
511 uintptr_t list;
512 } zend_property_info_source_list;
513
514 #define ZEND_PROPERTY_INFO_SOURCE_FROM_LIST(list) (0x1 | (uintptr_t) (list))
515 #define ZEND_PROPERTY_INFO_SOURCE_TO_LIST(list) ((zend_property_info_list *) ((list) & ~0x1))
516 #define ZEND_PROPERTY_INFO_SOURCE_IS_LIST(list) ((list) & 0x1)
517
518 struct _zend_reference {
519 zend_refcounted_h gc;
520 zval val;
521 zend_property_info_source_list sources;
522 };
523
524 struct _zend_ast_ref {
525 zend_refcounted_h gc;
526 /*zend_ast ast; zend_ast follows the zend_ast_ref structure */
527 };
528
529 /* Regular data types: Must be in sync with zend_variables.c. */
530 #define IS_UNDEF 0
531 #define IS_NULL 1
532 #define IS_FALSE 2
533 #define IS_TRUE 3
534 #define IS_LONG 4
535 #define IS_DOUBLE 5
536 #define IS_STRING 6
537 #define IS_ARRAY 7
538 #define IS_OBJECT 8
539 #define IS_RESOURCE 9
540 #define IS_REFERENCE 10
541 #define IS_CONSTANT_AST 11 /* Constant expressions */
542
543 /* Fake types used only for type hinting.
544 * These are allowed to overlap with the types below. */
545 #define IS_CALLABLE 12
546 #define IS_ITERABLE 13
547 #define IS_VOID 14
548 #define IS_STATIC 15
549 #define IS_MIXED 16
550 #define IS_NEVER 17
551
552 /* internal types */
553 #define IS_INDIRECT 12
554 #define IS_PTR 13
555 #define IS_ALIAS_PTR 14
556 #define _IS_ERROR 15
557
558 /* used for casts */
559 #define _IS_BOOL 18
560 #define _IS_NUMBER 19
561
zval_get_type(const zval * pz)562 static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
563 return pz->u1.v.type;
564 }
565
566 #define ZEND_SAME_FAKE_TYPE(faketype, realtype) ( \
567 (faketype) == (realtype) \
568 || ((faketype) == _IS_BOOL && ((realtype) == IS_TRUE || (realtype) == IS_FALSE)) \
569 )
570
571 /* we should never set just Z_TYPE, we should set Z_TYPE_INFO */
572 #define Z_TYPE(zval) zval_get_type(&(zval))
573 #define Z_TYPE_P(zval_p) Z_TYPE(*(zval_p))
574
575 #define Z_TYPE_FLAGS(zval) (zval).u1.v.type_flags
576 #define Z_TYPE_FLAGS_P(zval_p) Z_TYPE_FLAGS(*(zval_p))
577
578 #define Z_TYPE_INFO(zval) (zval).u1.type_info
579 #define Z_TYPE_INFO_P(zval_p) Z_TYPE_INFO(*(zval_p))
580
581 #define Z_NEXT(zval) (zval).u2.next
582 #define Z_NEXT_P(zval_p) Z_NEXT(*(zval_p))
583
584 #define Z_CACHE_SLOT(zval) (zval).u2.cache_slot
585 #define Z_CACHE_SLOT_P(zval_p) Z_CACHE_SLOT(*(zval_p))
586
587 #define Z_LINENO(zval) (zval).u2.lineno
588 #define Z_LINENO_P(zval_p) Z_LINENO(*(zval_p))
589
590 #define Z_OPLINE_NUM(zval) (zval).u2.opline_num
591 #define Z_OPLINE_NUM_P(zval_p) Z_OPLINE_NUM(*(zval_p))
592
593 #define Z_FE_POS(zval) (zval).u2.fe_pos
594 #define Z_FE_POS_P(zval_p) Z_FE_POS(*(zval_p))
595
596 #define Z_FE_ITER(zval) (zval).u2.fe_iter_idx
597 #define Z_FE_ITER_P(zval_p) Z_FE_ITER(*(zval_p))
598
599 #define Z_PROPERTY_GUARD(zval) (zval).u2.property_guard
600 #define Z_PROPERTY_GUARD_P(zval_p) Z_PROPERTY_GUARD(*(zval_p))
601
602 #define Z_CONSTANT_FLAGS(zval) (zval).u2.constant_flags
603 #define Z_CONSTANT_FLAGS_P(zval_p) Z_CONSTANT_FLAGS(*(zval_p))
604
605 #define Z_EXTRA(zval) (zval).u2.extra
606 #define Z_EXTRA_P(zval_p) Z_EXTRA(*(zval_p))
607
608 #define Z_COUNTED(zval) (zval).value.counted
609 #define Z_COUNTED_P(zval_p) Z_COUNTED(*(zval_p))
610
611 #define Z_TYPE_MASK 0xff
612 #define Z_TYPE_FLAGS_MASK 0xff00
613
614 #define Z_TYPE_FLAGS_SHIFT 8
615
616 #define GC_REFCOUNT(p) zend_gc_refcount(&(p)->gc)
617 #define GC_SET_REFCOUNT(p, rc) zend_gc_set_refcount(&(p)->gc, rc)
618 #define GC_ADDREF(p) zend_gc_addref(&(p)->gc)
619 #define GC_DELREF(p) zend_gc_delref(&(p)->gc)
620 #define GC_ADDREF_EX(p, rc) zend_gc_addref_ex(&(p)->gc, rc)
621 #define GC_DELREF_EX(p, rc) zend_gc_delref_ex(&(p)->gc, rc)
622 #define GC_TRY_ADDREF(p) zend_gc_try_addref(&(p)->gc)
623 #define GC_TRY_DELREF(p) zend_gc_try_delref(&(p)->gc)
624
625 #define GC_TYPE_MASK 0x0000000f
626 #define GC_FLAGS_MASK 0x000003f0
627 #define GC_INFO_MASK 0xfffffc00
628 #define GC_FLAGS_SHIFT 0
629 #define GC_INFO_SHIFT 10
630
zval_gc_type(uint32_t gc_type_info)631 static zend_always_inline zend_uchar zval_gc_type(uint32_t gc_type_info) {
632 return (gc_type_info & GC_TYPE_MASK);
633 }
634
zval_gc_flags(uint32_t gc_type_info)635 static zend_always_inline uint32_t zval_gc_flags(uint32_t gc_type_info) {
636 return (gc_type_info >> GC_FLAGS_SHIFT) & (GC_FLAGS_MASK >> GC_FLAGS_SHIFT);
637 }
638
zval_gc_info(uint32_t gc_type_info)639 static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) {
640 return (gc_type_info >> GC_INFO_SHIFT);
641 }
642
643 #define GC_TYPE_INFO(p) (p)->gc.u.type_info
644 #define GC_TYPE(p) zval_gc_type(GC_TYPE_INFO(p))
645 #define GC_FLAGS(p) zval_gc_flags(GC_TYPE_INFO(p))
646 #define GC_INFO(p) zval_gc_info(GC_TYPE_INFO(p))
647
648 #define GC_ADD_FLAGS(p, flags) do { \
649 GC_TYPE_INFO(p) |= (flags) << GC_FLAGS_SHIFT; \
650 } while (0)
651 #define GC_DEL_FLAGS(p, flags) do { \
652 GC_TYPE_INFO(p) &= ~((flags) << GC_FLAGS_SHIFT); \
653 } while (0)
654
655 #define Z_GC_TYPE(zval) GC_TYPE(Z_COUNTED(zval))
656 #define Z_GC_TYPE_P(zval_p) Z_GC_TYPE(*(zval_p))
657
658 #define Z_GC_FLAGS(zval) GC_FLAGS(Z_COUNTED(zval))
659 #define Z_GC_FLAGS_P(zval_p) Z_GC_FLAGS(*(zval_p))
660
661 #define Z_GC_INFO(zval) GC_INFO(Z_COUNTED(zval))
662 #define Z_GC_INFO_P(zval_p) Z_GC_INFO(*(zval_p))
663 #define Z_GC_TYPE_INFO(zval) GC_TYPE_INFO(Z_COUNTED(zval))
664 #define Z_GC_TYPE_INFO_P(zval_p) Z_GC_TYPE_INFO(*(zval_p))
665
666 /* zval_gc_flags(zval.value->gc.u.type_info) (common flags) */
667 #define GC_NOT_COLLECTABLE (1<<4)
668 #define GC_PROTECTED (1<<5) /* used for recursion detection */
669 #define GC_IMMUTABLE (1<<6) /* can't be changed in place */
670 #define GC_PERSISTENT (1<<7) /* allocated using malloc */
671 #define GC_PERSISTENT_LOCAL (1<<8) /* persistent, but thread-local */
672
673 #define GC_NULL (IS_NULL | (GC_NOT_COLLECTABLE << GC_FLAGS_SHIFT))
674 #define GC_STRING (IS_STRING | (GC_NOT_COLLECTABLE << GC_FLAGS_SHIFT))
675 #define GC_ARRAY IS_ARRAY
676 #define GC_OBJECT IS_OBJECT
677 #define GC_RESOURCE (IS_RESOURCE | (GC_NOT_COLLECTABLE << GC_FLAGS_SHIFT))
678 #define GC_REFERENCE (IS_REFERENCE | (GC_NOT_COLLECTABLE << GC_FLAGS_SHIFT))
679 #define GC_CONSTANT_AST (IS_CONSTANT_AST | (GC_NOT_COLLECTABLE << GC_FLAGS_SHIFT))
680
681 /* zval.u1.v.type_flags */
682 #define IS_TYPE_REFCOUNTED (1<<0)
683 #define IS_TYPE_COLLECTABLE (1<<1)
684
685 #if 1
686 /* This optimized version assumes that we have a single "type_flag" */
687 /* IS_TYPE_COLLECTABLE may be used only with IS_TYPE_REFCOUNTED */
688 # define Z_TYPE_INFO_REFCOUNTED(t) (((t) & Z_TYPE_FLAGS_MASK) != 0)
689 #else
690 # define Z_TYPE_INFO_REFCOUNTED(t) (((t) & (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT)) != 0)
691 #endif
692
693 /* extended types */
694 #define IS_INTERNED_STRING_EX IS_STRING
695
696 #define IS_STRING_EX (IS_STRING | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT))
697 #define IS_ARRAY_EX (IS_ARRAY | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT) | (IS_TYPE_COLLECTABLE << Z_TYPE_FLAGS_SHIFT))
698 #define IS_OBJECT_EX (IS_OBJECT | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT) | (IS_TYPE_COLLECTABLE << Z_TYPE_FLAGS_SHIFT))
699 #define IS_RESOURCE_EX (IS_RESOURCE | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT))
700 #define IS_REFERENCE_EX (IS_REFERENCE | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT))
701
702 #define IS_CONSTANT_AST_EX (IS_CONSTANT_AST | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT))
703
704 /* string flags (zval.value->gc.u.flags) */
705 #define IS_STR_CLASS_NAME_MAP_PTR GC_PROTECTED /* refcount is a map_ptr offset of class_entry */
706 #define IS_STR_INTERNED GC_IMMUTABLE /* interned string */
707 #define IS_STR_PERSISTENT GC_PERSISTENT /* allocated using malloc */
708 #define IS_STR_PERMANENT (1<<8) /* relives request boundary */
709 #define IS_STR_VALID_UTF8 (1<<9) /* valid UTF-8 according to PCRE */
710
711 /* array flags */
712 #define IS_ARRAY_IMMUTABLE GC_IMMUTABLE
713 #define IS_ARRAY_PERSISTENT GC_PERSISTENT
714
715 /* object flags (zval.value->gc.u.flags) */
716 #define IS_OBJ_WEAKLY_REFERENCED GC_PERSISTENT
717 #define IS_OBJ_DESTRUCTOR_CALLED (1<<8)
718 #define IS_OBJ_FREE_CALLED (1<<9)
719
720 #define OBJ_FLAGS(obj) GC_FLAGS(obj)
721
722 /* Fast class cache */
723 #define ZSTR_HAS_CE_CACHE(s) (GC_FLAGS(s) & IS_STR_CLASS_NAME_MAP_PTR)
724 #define ZSTR_GET_CE_CACHE(s) ZSTR_GET_CE_CACHE_EX(s, 1)
725 #define ZSTR_SET_CE_CACHE(s, ce) ZSTR_SET_CE_CACHE_EX(s, ce, 1)
726
727 #define ZSTR_VALID_CE_CACHE(s) EXPECTED((GC_REFCOUNT(s)-1)/sizeof(void *) < CG(map_ptr_last))
728
729 #define ZSTR_GET_CE_CACHE_EX(s, validate) \
730 ((!(validate) || ZSTR_VALID_CE_CACHE(s)) ? GET_CE_CACHE(GC_REFCOUNT(s)) : NULL)
731
732 #define ZSTR_SET_CE_CACHE_EX(s, ce, validate) do { \
733 if (!(validate) || ZSTR_VALID_CE_CACHE(s)) { \
734 ZEND_ASSERT((validate) || ZSTR_VALID_CE_CACHE(s)); \
735 SET_CE_CACHE(GC_REFCOUNT(s), ce); \
736 } \
737 } while (0)
738
739 #define GET_CE_CACHE(ce_cache) \
740 (*(zend_class_entry **)ZEND_MAP_PTR_OFFSET2PTR(ce_cache))
741
742 #define SET_CE_CACHE(ce_cache, ce) do { \
743 *((zend_class_entry **)ZEND_MAP_PTR_OFFSET2PTR(ce_cache)) = ce; \
744 } while (0)
745
746 /* Recursion protection macros must be used only for arrays and objects */
747 #define GC_IS_RECURSIVE(p) \
748 (GC_FLAGS(p) & GC_PROTECTED)
749
750 #define GC_PROTECT_RECURSION(p) do { \
751 GC_ADD_FLAGS(p, GC_PROTECTED); \
752 } while (0)
753
754 #define GC_UNPROTECT_RECURSION(p) do { \
755 GC_DEL_FLAGS(p, GC_PROTECTED); \
756 } while (0)
757
758 #define GC_TRY_PROTECT_RECURSION(p) do { \
759 if (!(GC_FLAGS(p) & GC_IMMUTABLE)) GC_PROTECT_RECURSION(p); \
760 } while (0)
761
762 #define GC_TRY_UNPROTECT_RECURSION(p) do { \
763 if (!(GC_FLAGS(p) & GC_IMMUTABLE)) GC_UNPROTECT_RECURSION(p); \
764 } while (0)
765
766 #define Z_IS_RECURSIVE(zval) GC_IS_RECURSIVE(Z_COUNTED(zval))
767 #define Z_PROTECT_RECURSION(zval) GC_PROTECT_RECURSION(Z_COUNTED(zval))
768 #define Z_UNPROTECT_RECURSION(zval) GC_UNPROTECT_RECURSION(Z_COUNTED(zval))
769 #define Z_IS_RECURSIVE_P(zv) Z_IS_RECURSIVE(*(zv))
770 #define Z_PROTECT_RECURSION_P(zv) Z_PROTECT_RECURSION(*(zv))
771 #define Z_UNPROTECT_RECURSION_P(zv) Z_UNPROTECT_RECURSION(*(zv))
772
773 /* All data types < IS_STRING have their constructor/destructors skipped */
774 #define Z_CONSTANT(zval) (Z_TYPE(zval) == IS_CONSTANT_AST)
775 #define Z_CONSTANT_P(zval_p) Z_CONSTANT(*(zval_p))
776
777 #if 1
778 /* This optimized version assumes that we have a single "type_flag" */
779 /* IS_TYPE_COLLECTABLE may be used only with IS_TYPE_REFCOUNTED */
780 #define Z_REFCOUNTED(zval) (Z_TYPE_FLAGS(zval) != 0)
781 #else
782 #define Z_REFCOUNTED(zval) ((Z_TYPE_FLAGS(zval) & IS_TYPE_REFCOUNTED) != 0)
783 #endif
784 #define Z_REFCOUNTED_P(zval_p) Z_REFCOUNTED(*(zval_p))
785
786 #define Z_COLLECTABLE(zval) ((Z_TYPE_FLAGS(zval) & IS_TYPE_COLLECTABLE) != 0)
787 #define Z_COLLECTABLE_P(zval_p) Z_COLLECTABLE(*(zval_p))
788
789 /* deprecated: (COPYABLE is the same as IS_ARRAY) */
790 #define Z_COPYABLE(zval) (Z_TYPE(zval) == IS_ARRAY)
791 #define Z_COPYABLE_P(zval_p) Z_COPYABLE(*(zval_p))
792
793 /* deprecated: (IMMUTABLE is the same as IS_ARRAY && !REFCOUNTED) */
794 #define Z_IMMUTABLE(zval) (Z_TYPE_INFO(zval) == IS_ARRAY)
795 #define Z_IMMUTABLE_P(zval_p) Z_IMMUTABLE(*(zval_p))
796 #define Z_OPT_IMMUTABLE(zval) Z_IMMUTABLE(zval_p)
797 #define Z_OPT_IMMUTABLE_P(zval_p) Z_IMMUTABLE(*(zval_p))
798
799 /* the following Z_OPT_* macros make better code when Z_TYPE_INFO accessed before */
800 #define Z_OPT_TYPE(zval) (Z_TYPE_INFO(zval) & Z_TYPE_MASK)
801 #define Z_OPT_TYPE_P(zval_p) Z_OPT_TYPE(*(zval_p))
802
803 #define Z_OPT_CONSTANT(zval) (Z_OPT_TYPE(zval) == IS_CONSTANT_AST)
804 #define Z_OPT_CONSTANT_P(zval_p) Z_OPT_CONSTANT(*(zval_p))
805
806 #define Z_OPT_REFCOUNTED(zval) Z_TYPE_INFO_REFCOUNTED(Z_TYPE_INFO(zval))
807 #define Z_OPT_REFCOUNTED_P(zval_p) Z_OPT_REFCOUNTED(*(zval_p))
808
809 /* deprecated: (COPYABLE is the same as IS_ARRAY) */
810 #define Z_OPT_COPYABLE(zval) (Z_OPT_TYPE(zval) == IS_ARRAY)
811 #define Z_OPT_COPYABLE_P(zval_p) Z_OPT_COPYABLE(*(zval_p))
812
813 #define Z_OPT_ISREF(zval) (Z_OPT_TYPE(zval) == IS_REFERENCE)
814 #define Z_OPT_ISREF_P(zval_p) Z_OPT_ISREF(*(zval_p))
815
816 #define Z_ISREF(zval) (Z_TYPE(zval) == IS_REFERENCE)
817 #define Z_ISREF_P(zval_p) Z_ISREF(*(zval_p))
818
819 #define Z_ISUNDEF(zval) (Z_TYPE(zval) == IS_UNDEF)
820 #define Z_ISUNDEF_P(zval_p) Z_ISUNDEF(*(zval_p))
821
822 #define Z_ISNULL(zval) (Z_TYPE(zval) == IS_NULL)
823 #define Z_ISNULL_P(zval_p) Z_ISNULL(*(zval_p))
824
825 #define Z_ISERROR(zval) (Z_TYPE(zval) == _IS_ERROR)
826 #define Z_ISERROR_P(zval_p) Z_ISERROR(*(zval_p))
827
828 #define Z_LVAL(zval) (zval).value.lval
829 #define Z_LVAL_P(zval_p) Z_LVAL(*(zval_p))
830
831 #define Z_DVAL(zval) (zval).value.dval
832 #define Z_DVAL_P(zval_p) Z_DVAL(*(zval_p))
833
834 #define Z_STR(zval) (zval).value.str
835 #define Z_STR_P(zval_p) Z_STR(*(zval_p))
836
837 #define Z_STRVAL(zval) ZSTR_VAL(Z_STR(zval))
838 #define Z_STRVAL_P(zval_p) Z_STRVAL(*(zval_p))
839
840 #define Z_STRLEN(zval) ZSTR_LEN(Z_STR(zval))
841 #define Z_STRLEN_P(zval_p) Z_STRLEN(*(zval_p))
842
843 #define Z_STRHASH(zval) ZSTR_HASH(Z_STR(zval))
844 #define Z_STRHASH_P(zval_p) Z_STRHASH(*(zval_p))
845
846 #define Z_ARR(zval) (zval).value.arr
847 #define Z_ARR_P(zval_p) Z_ARR(*(zval_p))
848
849 #define Z_ARRVAL(zval) Z_ARR(zval)
850 #define Z_ARRVAL_P(zval_p) Z_ARRVAL(*(zval_p))
851
852 #define Z_OBJ(zval) (zval).value.obj
853 #define Z_OBJ_P(zval_p) Z_OBJ(*(zval_p))
854
855 #define Z_OBJ_HT(zval) Z_OBJ(zval)->handlers
856 #define Z_OBJ_HT_P(zval_p) Z_OBJ_HT(*(zval_p))
857
858 #define Z_OBJ_HANDLER(zval, hf) Z_OBJ_HT((zval))->hf
859 #define Z_OBJ_HANDLER_P(zv_p, hf) Z_OBJ_HANDLER(*(zv_p), hf)
860
861 #define Z_OBJ_HANDLE(zval) (Z_OBJ((zval)))->handle
862 #define Z_OBJ_HANDLE_P(zval_p) Z_OBJ_HANDLE(*(zval_p))
863
864 #define Z_OBJCE(zval) (Z_OBJ(zval)->ce)
865 #define Z_OBJCE_P(zval_p) Z_OBJCE(*(zval_p))
866
867 #define Z_OBJPROP(zval) Z_OBJ_HT((zval))->get_properties(Z_OBJ(zval))
868 #define Z_OBJPROP_P(zval_p) Z_OBJPROP(*(zval_p))
869
870 #define Z_RES(zval) (zval).value.res
871 #define Z_RES_P(zval_p) Z_RES(*zval_p)
872
873 #define Z_RES_HANDLE(zval) Z_RES(zval)->handle
874 #define Z_RES_HANDLE_P(zval_p) Z_RES_HANDLE(*zval_p)
875
876 #define Z_RES_TYPE(zval) Z_RES(zval)->type
877 #define Z_RES_TYPE_P(zval_p) Z_RES_TYPE(*zval_p)
878
879 #define Z_RES_VAL(zval) Z_RES(zval)->ptr
880 #define Z_RES_VAL_P(zval_p) Z_RES_VAL(*zval_p)
881
882 #define Z_REF(zval) (zval).value.ref
883 #define Z_REF_P(zval_p) Z_REF(*(zval_p))
884
885 #define Z_REFVAL(zval) &Z_REF(zval)->val
886 #define Z_REFVAL_P(zval_p) Z_REFVAL(*(zval_p))
887
888 #define Z_AST(zval) (zval).value.ast
889 #define Z_AST_P(zval_p) Z_AST(*(zval_p))
890
891 #define GC_AST(p) ((zend_ast*)(((char*)p) + sizeof(zend_ast_ref)))
892
893 #define Z_ASTVAL(zval) GC_AST(Z_AST(zval))
894 #define Z_ASTVAL_P(zval_p) Z_ASTVAL(*(zval_p))
895
896 #define Z_INDIRECT(zval) (zval).value.zv
897 #define Z_INDIRECT_P(zval_p) Z_INDIRECT(*(zval_p))
898
899 #define Z_CE(zval) (zval).value.ce
900 #define Z_CE_P(zval_p) Z_CE(*(zval_p))
901
902 #define Z_FUNC(zval) (zval).value.func
903 #define Z_FUNC_P(zval_p) Z_FUNC(*(zval_p))
904
905 #define Z_PTR(zval) (zval).value.ptr
906 #define Z_PTR_P(zval_p) Z_PTR(*(zval_p))
907
908 #define ZVAL_UNDEF(z) do { \
909 Z_TYPE_INFO_P(z) = IS_UNDEF; \
910 } while (0)
911
912 #define ZVAL_NULL(z) do { \
913 Z_TYPE_INFO_P(z) = IS_NULL; \
914 } while (0)
915
916 #define ZVAL_FALSE(z) do { \
917 Z_TYPE_INFO_P(z) = IS_FALSE; \
918 } while (0)
919
920 #define ZVAL_TRUE(z) do { \
921 Z_TYPE_INFO_P(z) = IS_TRUE; \
922 } while (0)
923
924 #define ZVAL_BOOL(z, b) do { \
925 Z_TYPE_INFO_P(z) = \
926 (b) ? IS_TRUE : IS_FALSE; \
927 } while (0)
928
929 #define ZVAL_LONG(z, l) do { \
930 zval *__z = (z); \
931 Z_LVAL_P(__z) = l; \
932 Z_TYPE_INFO_P(__z) = IS_LONG; \
933 } while (0)
934
935 #define ZVAL_DOUBLE(z, d) do { \
936 zval *__z = (z); \
937 Z_DVAL_P(__z) = d; \
938 Z_TYPE_INFO_P(__z) = IS_DOUBLE; \
939 } while (0)
940
941 #define ZVAL_STR(z, s) do { \
942 zval *__z = (z); \
943 zend_string *__s = (s); \
944 Z_STR_P(__z) = __s; \
945 /* interned strings support */ \
946 Z_TYPE_INFO_P(__z) = ZSTR_IS_INTERNED(__s) ? \
947 IS_INTERNED_STRING_EX : \
948 IS_STRING_EX; \
949 } while (0)
950
951 #define ZVAL_INTERNED_STR(z, s) do { \
952 zval *__z = (z); \
953 zend_string *__s = (s); \
954 Z_STR_P(__z) = __s; \
955 Z_TYPE_INFO_P(__z) = IS_INTERNED_STRING_EX; \
956 } while (0)
957
958 #define ZVAL_NEW_STR(z, s) do { \
959 zval *__z = (z); \
960 zend_string *__s = (s); \
961 Z_STR_P(__z) = __s; \
962 Z_TYPE_INFO_P(__z) = IS_STRING_EX; \
963 } while (0)
964
965 #define ZVAL_STR_COPY(z, s) do { \
966 zval *__z = (z); \
967 zend_string *__s = (s); \
968 Z_STR_P(__z) = __s; \
969 /* interned strings support */ \
970 if (ZSTR_IS_INTERNED(__s)) { \
971 Z_TYPE_INFO_P(__z) = IS_INTERNED_STRING_EX; \
972 } else { \
973 GC_ADDREF(__s); \
974 Z_TYPE_INFO_P(__z) = IS_STRING_EX; \
975 } \
976 } while (0)
977
978 #define ZVAL_ARR(z, a) do { \
979 zend_array *__arr = (a); \
980 zval *__z = (z); \
981 Z_ARR_P(__z) = __arr; \
982 Z_TYPE_INFO_P(__z) = IS_ARRAY_EX; \
983 } while (0)
984
985 #define ZVAL_NEW_PERSISTENT_ARR(z) do { \
986 zval *__z = (z); \
987 zend_array *_arr = \
988 (zend_array *) malloc(sizeof(zend_array)); \
989 Z_ARR_P(__z) = _arr; \
990 Z_TYPE_INFO_P(__z) = IS_ARRAY_EX; \
991 } while (0)
992
993 #define ZVAL_OBJ(z, o) do { \
994 zval *__z = (z); \
995 Z_OBJ_P(__z) = (o); \
996 Z_TYPE_INFO_P(__z) = IS_OBJECT_EX; \
997 } while (0)
998
999 #define ZVAL_OBJ_COPY(z, o) do { \
1000 zval *__z = (z); \
1001 zend_object *__o = (o); \
1002 GC_ADDREF(__o); \
1003 Z_OBJ_P(__z) = __o; \
1004 Z_TYPE_INFO_P(__z) = IS_OBJECT_EX; \
1005 } while (0)
1006
1007 #define ZVAL_RES(z, r) do { \
1008 zval *__z = (z); \
1009 Z_RES_P(__z) = (r); \
1010 Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX; \
1011 } while (0)
1012
1013 #define ZVAL_NEW_RES(z, h, p, t) do { \
1014 zend_resource *_res = \
1015 (zend_resource *) emalloc(sizeof(zend_resource)); \
1016 zval *__z; \
1017 GC_SET_REFCOUNT(_res, 1); \
1018 GC_TYPE_INFO(_res) = GC_RESOURCE; \
1019 _res->handle = (h); \
1020 _res->type = (t); \
1021 _res->ptr = (p); \
1022 __z = (z); \
1023 Z_RES_P(__z) = _res; \
1024 Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX; \
1025 } while (0)
1026
1027 #define ZVAL_NEW_PERSISTENT_RES(z, h, p, t) do { \
1028 zend_resource *_res = \
1029 (zend_resource *) malloc(sizeof(zend_resource)); \
1030 zval *__z; \
1031 GC_SET_REFCOUNT(_res, 1); \
1032 GC_TYPE_INFO(_res) = GC_RESOURCE | \
1033 (GC_PERSISTENT << GC_FLAGS_SHIFT); \
1034 _res->handle = (h); \
1035 _res->type = (t); \
1036 _res->ptr = (p); \
1037 __z = (z); \
1038 Z_RES_P(__z) = _res; \
1039 Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX; \
1040 } while (0)
1041
1042 #define ZVAL_REF(z, r) do { \
1043 zval *__z = (z); \
1044 Z_REF_P(__z) = (r); \
1045 Z_TYPE_INFO_P(__z) = IS_REFERENCE_EX; \
1046 } while (0)
1047
1048 #define ZVAL_NEW_EMPTY_REF(z) do { \
1049 zend_reference *_ref = \
1050 (zend_reference *) emalloc(sizeof(zend_reference)); \
1051 GC_SET_REFCOUNT(_ref, 1); \
1052 GC_TYPE_INFO(_ref) = GC_REFERENCE; \
1053 _ref->sources.ptr = NULL; \
1054 Z_REF_P(z) = _ref; \
1055 Z_TYPE_INFO_P(z) = IS_REFERENCE_EX; \
1056 } while (0)
1057
1058 #define ZVAL_NEW_REF(z, r) do { \
1059 zend_reference *_ref = \
1060 (zend_reference *) emalloc(sizeof(zend_reference)); \
1061 GC_SET_REFCOUNT(_ref, 1); \
1062 GC_TYPE_INFO(_ref) = GC_REFERENCE; \
1063 ZVAL_COPY_VALUE(&_ref->val, r); \
1064 _ref->sources.ptr = NULL; \
1065 Z_REF_P(z) = _ref; \
1066 Z_TYPE_INFO_P(z) = IS_REFERENCE_EX; \
1067 } while (0)
1068
1069 #define ZVAL_MAKE_REF_EX(z, refcount) do { \
1070 zval *_z = (z); \
1071 zend_reference *_ref = \
1072 (zend_reference *) emalloc(sizeof(zend_reference)); \
1073 GC_SET_REFCOUNT(_ref, (refcount)); \
1074 GC_TYPE_INFO(_ref) = GC_REFERENCE; \
1075 ZVAL_COPY_VALUE(&_ref->val, _z); \
1076 _ref->sources.ptr = NULL; \
1077 Z_REF_P(_z) = _ref; \
1078 Z_TYPE_INFO_P(_z) = IS_REFERENCE_EX; \
1079 } while (0)
1080
1081 #define ZVAL_NEW_PERSISTENT_REF(z, r) do { \
1082 zend_reference *_ref = \
1083 (zend_reference *) malloc(sizeof(zend_reference)); \
1084 GC_SET_REFCOUNT(_ref, 1); \
1085 GC_TYPE_INFO(_ref) = GC_REFERENCE | \
1086 (GC_PERSISTENT << GC_FLAGS_SHIFT); \
1087 ZVAL_COPY_VALUE(&_ref->val, r); \
1088 _ref->sources.ptr = NULL; \
1089 Z_REF_P(z) = _ref; \
1090 Z_TYPE_INFO_P(z) = IS_REFERENCE_EX; \
1091 } while (0)
1092
1093 #define ZVAL_AST(z, ast) do { \
1094 zval *__z = (z); \
1095 Z_AST_P(__z) = ast; \
1096 Z_TYPE_INFO_P(__z) = IS_CONSTANT_AST_EX; \
1097 } while (0)
1098
1099 #define ZVAL_INDIRECT(z, v) do { \
1100 Z_INDIRECT_P(z) = (v); \
1101 Z_TYPE_INFO_P(z) = IS_INDIRECT; \
1102 } while (0)
1103
1104 #define ZVAL_PTR(z, p) do { \
1105 Z_PTR_P(z) = (p); \
1106 Z_TYPE_INFO_P(z) = IS_PTR; \
1107 } while (0)
1108
1109 #define ZVAL_FUNC(z, f) do { \
1110 Z_FUNC_P(z) = (f); \
1111 Z_TYPE_INFO_P(z) = IS_PTR; \
1112 } while (0)
1113
1114 #define ZVAL_CE(z, c) do { \
1115 Z_CE_P(z) = (c); \
1116 Z_TYPE_INFO_P(z) = IS_PTR; \
1117 } while (0)
1118
1119 #define ZVAL_ALIAS_PTR(z, p) do { \
1120 Z_PTR_P(z) = (p); \
1121 Z_TYPE_INFO_P(z) = IS_ALIAS_PTR; \
1122 } while (0)
1123
1124 #define ZVAL_ERROR(z) do { \
1125 Z_TYPE_INFO_P(z) = _IS_ERROR; \
1126 } while (0)
1127
1128 #define Z_REFCOUNT_P(pz) zval_refcount_p(pz)
1129 #define Z_SET_REFCOUNT_P(pz, rc) zval_set_refcount_p(pz, rc)
1130 #define Z_ADDREF_P(pz) zval_addref_p(pz)
1131 #define Z_DELREF_P(pz) zval_delref_p(pz)
1132
1133 #define Z_REFCOUNT(z) Z_REFCOUNT_P(&(z))
1134 #define Z_SET_REFCOUNT(z, rc) Z_SET_REFCOUNT_P(&(z), rc)
1135 #define Z_ADDREF(z) Z_ADDREF_P(&(z))
1136 #define Z_DELREF(z) Z_DELREF_P(&(z))
1137
1138 #define Z_TRY_ADDREF_P(pz) do { \
1139 if (Z_REFCOUNTED_P((pz))) { \
1140 Z_ADDREF_P((pz)); \
1141 } \
1142 } while (0)
1143
1144 #define Z_TRY_DELREF_P(pz) do { \
1145 if (Z_REFCOUNTED_P((pz))) { \
1146 Z_DELREF_P((pz)); \
1147 } \
1148 } while (0)
1149
1150 #define Z_TRY_ADDREF(z) Z_TRY_ADDREF_P(&(z))
1151 #define Z_TRY_DELREF(z) Z_TRY_DELREF_P(&(z))
1152
1153 #ifndef ZEND_RC_DEBUG
1154 # define ZEND_RC_DEBUG 0
1155 #endif
1156
1157 #if ZEND_RC_DEBUG
1158 extern ZEND_API bool zend_rc_debug;
1159 /* The GC_PERSISTENT flag is reused for IS_OBJ_WEAKLY_REFERENCED on objects.
1160 * Skip checks for OBJECT/NULL type to avoid interpreting the flag incorrectly. */
1161 # define ZEND_RC_MOD_CHECK(p) do { \
1162 if (zend_rc_debug) { \
1163 zend_uchar type = zval_gc_type((p)->u.type_info); \
1164 if (type != IS_OBJECT && type != IS_NULL) { \
1165 ZEND_ASSERT(!(zval_gc_flags((p)->u.type_info) & GC_IMMUTABLE)); \
1166 ZEND_ASSERT((zval_gc_flags((p)->u.type_info) & (GC_PERSISTENT|GC_PERSISTENT_LOCAL)) != GC_PERSISTENT); \
1167 } \
1168 } \
1169 } while (0)
1170 # define GC_MAKE_PERSISTENT_LOCAL(p) do { \
1171 GC_ADD_FLAGS(p, GC_PERSISTENT_LOCAL); \
1172 } while (0)
1173 #else
1174 # define ZEND_RC_MOD_CHECK(p) \
1175 do { } while (0)
1176 # define GC_MAKE_PERSISTENT_LOCAL(p) \
1177 do { } while (0)
1178 #endif
1179
zend_gc_refcount(const zend_refcounted_h * p)1180 static zend_always_inline uint32_t zend_gc_refcount(const zend_refcounted_h *p) {
1181 return p->refcount;
1182 }
1183
zend_gc_set_refcount(zend_refcounted_h * p,uint32_t rc)1184 static zend_always_inline uint32_t zend_gc_set_refcount(zend_refcounted_h *p, uint32_t rc) {
1185 p->refcount = rc;
1186 return p->refcount;
1187 }
1188
zend_gc_addref(zend_refcounted_h * p)1189 static zend_always_inline uint32_t zend_gc_addref(zend_refcounted_h *p) {
1190 ZEND_RC_MOD_CHECK(p);
1191 return ++(p->refcount);
1192 }
1193
zend_gc_try_addref(zend_refcounted_h * p)1194 static zend_always_inline void zend_gc_try_addref(zend_refcounted_h *p) {
1195 if (!(p->u.type_info & GC_IMMUTABLE)) {
1196 ZEND_RC_MOD_CHECK(p);
1197 ++p->refcount;
1198 }
1199 }
1200
zend_gc_try_delref(zend_refcounted_h * p)1201 static zend_always_inline void zend_gc_try_delref(zend_refcounted_h *p) {
1202 if (!(p->u.type_info & GC_IMMUTABLE)) {
1203 ZEND_RC_MOD_CHECK(p);
1204 --p->refcount;
1205 }
1206 }
1207
zend_gc_delref(zend_refcounted_h * p)1208 static zend_always_inline uint32_t zend_gc_delref(zend_refcounted_h *p) {
1209 ZEND_ASSERT(p->refcount > 0);
1210 ZEND_RC_MOD_CHECK(p);
1211 return --(p->refcount);
1212 }
1213
zend_gc_addref_ex(zend_refcounted_h * p,uint32_t rc)1214 static zend_always_inline uint32_t zend_gc_addref_ex(zend_refcounted_h *p, uint32_t rc) {
1215 ZEND_RC_MOD_CHECK(p);
1216 p->refcount += rc;
1217 return p->refcount;
1218 }
1219
zend_gc_delref_ex(zend_refcounted_h * p,uint32_t rc)1220 static zend_always_inline uint32_t zend_gc_delref_ex(zend_refcounted_h *p, uint32_t rc) {
1221 ZEND_RC_MOD_CHECK(p);
1222 p->refcount -= rc;
1223 return p->refcount;
1224 }
1225
zval_refcount_p(const zval * pz)1226 static zend_always_inline uint32_t zval_refcount_p(const zval* pz) {
1227 #if ZEND_DEBUG
1228 ZEND_ASSERT(Z_REFCOUNTED_P(pz) || Z_TYPE_P(pz) == IS_ARRAY);
1229 #endif
1230 return GC_REFCOUNT(Z_COUNTED_P(pz));
1231 }
1232
zval_set_refcount_p(zval * pz,uint32_t rc)1233 static zend_always_inline uint32_t zval_set_refcount_p(zval* pz, uint32_t rc) {
1234 ZEND_ASSERT(Z_REFCOUNTED_P(pz));
1235 return GC_SET_REFCOUNT(Z_COUNTED_P(pz), rc);
1236 }
1237
zval_addref_p(zval * pz)1238 static zend_always_inline uint32_t zval_addref_p(zval* pz) {
1239 ZEND_ASSERT(Z_REFCOUNTED_P(pz));
1240 return GC_ADDREF(Z_COUNTED_P(pz));
1241 }
1242
zval_delref_p(zval * pz)1243 static zend_always_inline uint32_t zval_delref_p(zval* pz) {
1244 ZEND_ASSERT(Z_REFCOUNTED_P(pz));
1245 return GC_DELREF(Z_COUNTED_P(pz));
1246 }
1247
1248 #if SIZEOF_SIZE_T == 4
1249 # define ZVAL_COPY_VALUE_EX(z, v, gc, t) \
1250 do { \
1251 uint32_t _w2 = v->value.ww.w2; \
1252 Z_COUNTED_P(z) = gc; \
1253 z->value.ww.w2 = _w2; \
1254 Z_TYPE_INFO_P(z) = t; \
1255 } while (0)
1256 #elif SIZEOF_SIZE_T == 8
1257 # define ZVAL_COPY_VALUE_EX(z, v, gc, t) \
1258 do { \
1259 Z_COUNTED_P(z) = gc; \
1260 Z_TYPE_INFO_P(z) = t; \
1261 } while (0)
1262 #else
1263 # error "Unknown SIZEOF_SIZE_T"
1264 #endif
1265
1266 #define ZVAL_COPY_VALUE(z, v) \
1267 do { \
1268 zval *_z1 = (z); \
1269 const zval *_z2 = (v); \
1270 zend_refcounted *_gc = Z_COUNTED_P(_z2); \
1271 uint32_t _t = Z_TYPE_INFO_P(_z2); \
1272 ZVAL_COPY_VALUE_EX(_z1, _z2, _gc, _t); \
1273 } while (0)
1274
1275 #define ZVAL_COPY(z, v) \
1276 do { \
1277 zval *_z1 = (z); \
1278 const zval *_z2 = (v); \
1279 zend_refcounted *_gc = Z_COUNTED_P(_z2); \
1280 uint32_t _t = Z_TYPE_INFO_P(_z2); \
1281 ZVAL_COPY_VALUE_EX(_z1, _z2, _gc, _t); \
1282 if (Z_TYPE_INFO_REFCOUNTED(_t)) { \
1283 GC_ADDREF(_gc); \
1284 } \
1285 } while (0)
1286
1287 #define ZVAL_DUP(z, v) \
1288 do { \
1289 zval *_z1 = (z); \
1290 const zval *_z2 = (v); \
1291 zend_refcounted *_gc = Z_COUNTED_P(_z2); \
1292 uint32_t _t = Z_TYPE_INFO_P(_z2); \
1293 if ((_t & Z_TYPE_MASK) == IS_ARRAY) { \
1294 ZVAL_ARR(_z1, zend_array_dup((zend_array*)_gc));\
1295 } else { \
1296 if (Z_TYPE_INFO_REFCOUNTED(_t)) { \
1297 GC_ADDREF(_gc); \
1298 } \
1299 ZVAL_COPY_VALUE_EX(_z1, _z2, _gc, _t); \
1300 } \
1301 } while (0)
1302
1303
1304 /* ZVAL_COPY_OR_DUP() should be used instead of ZVAL_COPY() and ZVAL_DUP()
1305 * in all places where the source may be a persistent zval.
1306 */
1307 #define ZVAL_COPY_OR_DUP(z, v) \
1308 do { \
1309 zval *_z1 = (z); \
1310 const zval *_z2 = (v); \
1311 zend_refcounted *_gc = Z_COUNTED_P(_z2); \
1312 uint32_t _t = Z_TYPE_INFO_P(_z2); \
1313 ZVAL_COPY_VALUE_EX(_z1, _z2, _gc, _t); \
1314 if (Z_TYPE_INFO_REFCOUNTED(_t)) { \
1315 /* Objects reuse PERSISTENT as WEAKLY_REFERENCED */ \
1316 if (EXPECTED(!(GC_FLAGS(_gc) & GC_PERSISTENT) \
1317 || GC_TYPE(_gc) == IS_OBJECT)) { \
1318 GC_ADDREF(_gc); \
1319 } else { \
1320 zval_copy_ctor_func(_z1); \
1321 } \
1322 } \
1323 } while (0)
1324
1325 #define ZVAL_DEREF(z) do { \
1326 if (UNEXPECTED(Z_ISREF_P(z))) { \
1327 (z) = Z_REFVAL_P(z); \
1328 } \
1329 } while (0)
1330
1331 #define ZVAL_DEINDIRECT(z) do { \
1332 if (Z_TYPE_P(z) == IS_INDIRECT) { \
1333 (z) = Z_INDIRECT_P(z); \
1334 } \
1335 } while (0)
1336
1337 #define ZVAL_OPT_DEREF(z) do { \
1338 if (UNEXPECTED(Z_OPT_ISREF_P(z))) { \
1339 (z) = Z_REFVAL_P(z); \
1340 } \
1341 } while (0)
1342
1343 #define ZVAL_MAKE_REF(zv) do { \
1344 zval *__zv = (zv); \
1345 if (!Z_ISREF_P(__zv)) { \
1346 ZVAL_NEW_REF(__zv, __zv); \
1347 } \
1348 } while (0)
1349
1350 #define ZVAL_UNREF(z) do { \
1351 zval *_z = (z); \
1352 zend_reference *ref; \
1353 ZEND_ASSERT(Z_ISREF_P(_z)); \
1354 ref = Z_REF_P(_z); \
1355 ZVAL_COPY_VALUE(_z, &ref->val); \
1356 efree_size(ref, sizeof(zend_reference)); \
1357 } while (0)
1358
1359 #define ZVAL_COPY_DEREF(z, v) do { \
1360 zval *_z3 = (v); \
1361 if (Z_OPT_REFCOUNTED_P(_z3)) { \
1362 if (UNEXPECTED(Z_OPT_ISREF_P(_z3))) { \
1363 _z3 = Z_REFVAL_P(_z3); \
1364 if (Z_OPT_REFCOUNTED_P(_z3)) { \
1365 Z_ADDREF_P(_z3); \
1366 } \
1367 } else { \
1368 Z_ADDREF_P(_z3); \
1369 } \
1370 } \
1371 ZVAL_COPY_VALUE(z, _z3); \
1372 } while (0)
1373
1374
1375 #define SEPARATE_STRING(zv) do { \
1376 zval *_zv = (zv); \
1377 if (Z_REFCOUNT_P(_zv) > 1) { \
1378 zend_string *_str = Z_STR_P(_zv); \
1379 ZEND_ASSERT(Z_REFCOUNTED_P(_zv)); \
1380 ZEND_ASSERT(!ZSTR_IS_INTERNED(_str)); \
1381 ZVAL_NEW_STR(_zv, zend_string_init( \
1382 ZSTR_VAL(_str), ZSTR_LEN(_str), 0)); \
1383 GC_DELREF(_str); \
1384 } \
1385 } while (0)
1386
1387 #define SEPARATE_ARRAY(zv) do { \
1388 zval *__zv = (zv); \
1389 zend_array *_arr = Z_ARR_P(__zv); \
1390 if (UNEXPECTED(GC_REFCOUNT(_arr) > 1)) { \
1391 ZVAL_ARR(__zv, zend_array_dup(_arr)); \
1392 GC_TRY_DELREF(_arr); \
1393 } \
1394 } while (0)
1395
1396 #define SEPARATE_ZVAL_NOREF(zv) do { \
1397 zval *_zv = (zv); \
1398 ZEND_ASSERT(Z_TYPE_P(_zv) != IS_REFERENCE); \
1399 if (Z_TYPE_P(_zv) == IS_ARRAY) { \
1400 SEPARATE_ARRAY(_zv); \
1401 } \
1402 } while (0)
1403
1404 #define SEPARATE_ZVAL(zv) do { \
1405 zval *_zv = (zv); \
1406 if (Z_ISREF_P(_zv)) { \
1407 zend_reference *_r = Z_REF_P(_zv); \
1408 ZVAL_COPY_VALUE(_zv, &_r->val); \
1409 if (GC_DELREF(_r) == 0) { \
1410 efree_size(_r, sizeof(zend_reference)); \
1411 } else if (Z_OPT_TYPE_P(_zv) == IS_ARRAY) { \
1412 ZVAL_ARR(_zv, zend_array_dup(Z_ARR_P(_zv)));\
1413 break; \
1414 } else if (Z_OPT_REFCOUNTED_P(_zv)) { \
1415 Z_ADDREF_P(_zv); \
1416 break; \
1417 } \
1418 } \
1419 if (Z_TYPE_P(_zv) == IS_ARRAY) { \
1420 SEPARATE_ARRAY(_zv); \
1421 } \
1422 } while (0)
1423
1424 /* Properties store a flag distinguishing unset and uninitialized properties
1425 * (both use IS_UNDEF type) in the Z_EXTRA space. As such we also need to copy
1426 * the Z_EXTRA space when copying property default values etc. We define separate
1427 * macros for this purpose, so this workaround is easier to remove in the future. */
1428 #define IS_PROP_UNINIT 1
1429 #define Z_PROP_FLAG_P(z) Z_EXTRA_P(z)
1430 #define ZVAL_COPY_VALUE_PROP(z, v) \
1431 do { *(z) = *(v); } while (0)
1432 #define ZVAL_COPY_PROP(z, v) \
1433 do { ZVAL_COPY(z, v); Z_PROP_FLAG_P(z) = Z_PROP_FLAG_P(v); } while (0)
1434 #define ZVAL_COPY_OR_DUP_PROP(z, v) \
1435 do { ZVAL_COPY_OR_DUP(z, v); Z_PROP_FLAG_P(z) = Z_PROP_FLAG_P(v); } while (0)
1436
1437
1438 #endif /* ZEND_TYPES_H */
1439
