1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1998-2018 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 <xinchen.h@zend.com> |
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
28 #ifdef __SSE2__
29 # include <mmintrin.h>
30 # include <emmintrin.h>
31 #endif
32
33 #ifdef WORDS_BIGENDIAN
34 # define ZEND_ENDIAN_LOHI(lo, hi) hi; lo;
35 # define ZEND_ENDIAN_LOHI_3(lo, mi, hi) hi; mi; lo;
36 # define ZEND_ENDIAN_LOHI_4(a, b, c, d) d; c; b; a;
37 # define ZEND_ENDIAN_LOHI_C(lo, hi) hi, lo
38 # define ZEND_ENDIAN_LOHI_C_3(lo, mi, hi) hi, mi, lo,
39 # define ZEND_ENDIAN_LOHI_C_4(a, b, c, d) d, c, b, a
40 #else
41 # define ZEND_ENDIAN_LOHI(lo, hi) lo; hi;
42 # define ZEND_ENDIAN_LOHI_3(lo, mi, hi) lo; mi; hi;
43 # define ZEND_ENDIAN_LOHI_4(a, b, c, d) a; b; c; d;
44 # define ZEND_ENDIAN_LOHI_C(lo, hi) lo, hi
45 # define ZEND_ENDIAN_LOHI_C_3(lo, mi, hi) lo, mi, hi,
46 # define ZEND_ENDIAN_LOHI_C_4(a, b, c, d) a, b, c, d
47 #endif
48
49 typedef unsigned char zend_bool;
50 typedef unsigned char zend_uchar;
51
52 typedef enum {
53 SUCCESS = 0,
54 FAILURE = -1, /* this MUST stay a negative number, or it may affect functions! */
55 } ZEND_RESULT_CODE;
56
57 #ifdef ZEND_ENABLE_ZVAL_LONG64
58 # ifdef ZEND_WIN32
59 # define ZEND_SIZE_MAX _UI64_MAX
60 # else
61 # define ZEND_SIZE_MAX SIZE_MAX
62 # endif
63 #else
64 # if defined(ZEND_WIN32)
65 # define ZEND_SIZE_MAX _UI32_MAX
66 # else
67 # define ZEND_SIZE_MAX SIZE_MAX
68 # endif
69 #endif
70
71 typedef intptr_t zend_intptr_t;
72 typedef uintptr_t zend_uintptr_t;
73
74 #ifdef ZTS
75 #define ZEND_TLS static TSRM_TLS
76 #define ZEND_EXT_TLS TSRM_TLS
77 #else
78 #define ZEND_TLS static
79 #define ZEND_EXT_TLS
80 #endif
81
82 typedef struct _zend_object_handlers zend_object_handlers;
83 typedef struct _zend_class_entry zend_class_entry;
84 typedef union _zend_function zend_function;
85 typedef struct _zend_execute_data zend_execute_data;
86
87 typedef struct _zval_struct zval;
88
89 typedef struct _zend_refcounted zend_refcounted;
90 typedef struct _zend_string zend_string;
91 typedef struct _zend_array zend_array;
92 typedef struct _zend_object zend_object;
93 typedef struct _zend_resource zend_resource;
94 typedef struct _zend_reference zend_reference;
95 typedef struct _zend_ast_ref zend_ast_ref;
96 typedef struct _zend_ast zend_ast;
97
98 typedef int (*compare_func_t)(const void *, const void *);
99 typedef void (*swap_func_t)(void *, void *);
100 typedef void (*sort_func_t)(void *, size_t, size_t, compare_func_t, swap_func_t);
101 typedef void (*dtor_func_t)(zval *pDest);
102 typedef void (*copy_ctor_func_t)(zval *pElement);
103
104 /*
105 * zend_type - is an abstraction layer to represent information about type hint.
106 * It shouldn't be used directly. Only through ZEND_TYPE_* macros.
107 *
108 * ZEND_TYPE_IS_SET() - checks if type-hint exists
109 * ZEND_TYPE_IS_CODE() - checks if type-hint refer to standard type
110 * ZEND_TYPE_IS_CLASS() - checks if type-hint refer to some class
111 *
112 * ZEND_TYPE_NAME() - returns referenced class name
113 * ZEND_TYPE_CE() - returns referenced class entry
114 * ZEND_TYPE_CODE() - returns standard type code (e.g. IS_LONG, _IS_BOOL)
115 *
116 * ZEND_TYPE_ALLOW_NULL() - checks if NULL is allowed
117 *
118 * ZEND_TYPE_ENCODE() and ZEND_TYPE_ENCODE_CLASS() should be used for
119 * construction.
120 */
121
122 typedef uintptr_t zend_type;
123
124 #define ZEND_TYPE_IS_SET(t) \
125 ((t) > Z_L(1))
126
127 #define ZEND_TYPE_IS_CODE(t) \
128 (((t) > Z_L(1)) && ((t) <= Z_L(0x1ff)))
129
130 #define ZEND_TYPE_IS_CLASS(t) \
131 ((t) > Z_L(0x1ff))
132
133 #define ZEND_TYPE_NAME(t) \
134 ((zend_string*)((t) & ~Z_L(0x3)))
135
136 #define ZEND_TYPE_CE(t) \
137 ((zend_class_entry*)((t) & ~Z_L(0x3)))
138
139 #define ZEND_TYPE_CODE(t) \
140 ((t) >> Z_L(1))
141
142 #define ZEND_TYPE_ALLOW_NULL(t) \
143 (((t) & Z_L(0x1)) != 0)
144
145 #define ZEND_TYPE_ENCODE(code, allow_null) \
146 (((code) << Z_L(1)) | ((allow_null) ? Z_L(0x1) : Z_L(0x0)))
147
148 #define ZEND_TYPE_ENCODE_CLASS(class_name, allow_null) \
149 (((uintptr_t)(class_name)) | ((allow_null) ? Z_L(0x1) : Z_L(0)))
150
151 #define ZEND_TYPE_ENCODE_CLASS_CONST_0(class_name) \
152 ((zend_type) class_name)
153 #define ZEND_TYPE_ENCODE_CLASS_CONST_1(class_name) \
154 ((zend_type) "?" class_name)
155 #define ZEND_TYPE_ENCODE_CLASS_CONST_Q2(macro, class_name) \
156 macro(class_name)
157 #define ZEND_TYPE_ENCODE_CLASS_CONST_Q1(allow_null, class_name) \
158 ZEND_TYPE_ENCODE_CLASS_CONST_Q2(ZEND_TYPE_ENCODE_CLASS_CONST_ ##allow_null, class_name)
159 #define ZEND_TYPE_ENCODE_CLASS_CONST(class_name, allow_null) \
160 ZEND_TYPE_ENCODE_CLASS_CONST_Q1(allow_null, class_name)
161
162 typedef union _zend_value {
163 zend_long lval; /* long value */
164 double dval; /* double value */
165 zend_refcounted *counted;
166 zend_string *str;
167 zend_array *arr;
168 zend_object *obj;
169 zend_resource *res;
170 zend_reference *ref;
171 zend_ast_ref *ast;
172 zval *zv;
173 void *ptr;
174 zend_class_entry *ce;
175 zend_function *func;
176 struct {
177 uint32_t w1;
178 uint32_t w2;
179 } ww;
180 } zend_value;
181
182 struct _zval_struct {
183 zend_value value; /* value */
184 union {
185 struct {
186 ZEND_ENDIAN_LOHI_3(
187 zend_uchar type, /* active type */
188 zend_uchar type_flags,
189 union {
190 uint16_t call_info; /* call info for EX(This) */
191 uint16_t extra; /* not further specified */
192 } u)
193 } v;
194 uint32_t type_info;
195 } u1;
196 union {
197 uint32_t next; /* hash collision chain */
198 uint32_t cache_slot; /* cache slot (for RECV_INIT) */
199 uint32_t opline_num; /* opline number (for FAST_CALL) */
200 uint32_t lineno; /* line number (for ast nodes) */
201 uint32_t num_args; /* arguments number for EX(This) */
202 uint32_t fe_pos; /* foreach position */
203 uint32_t fe_iter_idx; /* foreach iterator index */
204 uint32_t access_flags; /* class constant access flags */
205 uint32_t property_guard; /* single property guard */
206 uint32_t constant_flags; /* constant flags */
207 uint32_t extra; /* not further specified */
208 } u2;
209 };
210
211 typedef struct _zend_refcounted_h {
212 uint32_t refcount; /* reference counter 32-bit */
213 union {
214 uint32_t type_info;
215 } u;
216 } zend_refcounted_h;
217
218 struct _zend_refcounted {
219 zend_refcounted_h gc;
220 };
221
222 struct _zend_string {
223 zend_refcounted_h gc;
224 zend_ulong h; /* hash value */
225 size_t len;
226 char val[1];
227 };
228
229 typedef struct _Bucket {
230 zval val;
231 zend_ulong h; /* hash value (or numeric index) */
232 zend_string *key; /* string key or NULL for numerics */
233 } Bucket;
234
235 typedef struct _zend_array HashTable;
236
237 struct _zend_array {
238 zend_refcounted_h gc;
239 union {
240 struct {
241 ZEND_ENDIAN_LOHI_4(
242 zend_uchar flags,
243 zend_uchar _unused,
244 zend_uchar nIteratorsCount,
245 zend_uchar _unused2)
246 } v;
247 uint32_t flags;
248 } u;
249 uint32_t nTableMask;
250 Bucket *arData;
251 uint32_t nNumUsed;
252 uint32_t nNumOfElements;
253 uint32_t nTableSize;
254 uint32_t nInternalPointer;
255 zend_long nNextFreeElement;
256 dtor_func_t pDestructor;
257 };
258
259 /*
260 * HashTable Data Layout
261 * =====================
262 *
263 * +=============================+
264 * | HT_HASH(ht, ht->nTableMask) |
265 * | ... |
266 * | HT_HASH(ht, -1) |
267 * +-----------------------------+
268 * ht->arData ---> | Bucket[0] |
269 * | ... |
270 * | Bucket[ht->nTableSize-1] |
271 * +=============================+
272 */
273
274 #define HT_INVALID_IDX ((uint32_t) -1)
275
276 #define HT_MIN_MASK ((uint32_t) -2)
277 #define HT_MIN_SIZE 8
278
279 #if SIZEOF_SIZE_T == 4
280 # define HT_MAX_SIZE 0x04000000 /* small enough to avoid overflow checks */
281 # define HT_HASH_TO_BUCKET_EX(data, idx) \
282 ((Bucket*)((char*)(data) + (idx)))
283 # define HT_IDX_TO_HASH(idx) \
284 ((idx) * sizeof(Bucket))
285 # define HT_HASH_TO_IDX(idx) \
286 ((idx) / sizeof(Bucket))
287 #elif SIZEOF_SIZE_T == 8
288 # define HT_MAX_SIZE 0x80000000
289 # define HT_HASH_TO_BUCKET_EX(data, idx) \
290 ((data) + (idx))
291 # define HT_IDX_TO_HASH(idx) \
292 (idx)
293 # define HT_HASH_TO_IDX(idx) \
294 (idx)
295 #else
296 # error "Unknown SIZEOF_SIZE_T"
297 #endif
298
299 #define HT_HASH_EX(data, idx) \
300 ((uint32_t*)(data))[(int32_t)(idx)]
301 #define HT_HASH(ht, idx) \
302 HT_HASH_EX((ht)->arData, idx)
303
304 #define HT_SIZE_TO_MASK(nTableSize) \
305 ((uint32_t)(-((nTableSize) + (nTableSize))))
306 #define HT_HASH_SIZE(nTableMask) \
307 (((size_t)(uint32_t)-(int32_t)(nTableMask)) * sizeof(uint32_t))
308 #define HT_DATA_SIZE(nTableSize) \
309 ((size_t)(nTableSize) * sizeof(Bucket))
310 #define HT_SIZE_EX(nTableSize, nTableMask) \
311 (HT_DATA_SIZE((nTableSize)) + HT_HASH_SIZE((nTableMask)))
312 #define HT_SIZE(ht) \
313 HT_SIZE_EX((ht)->nTableSize, (ht)->nTableMask)
314 #define HT_USED_SIZE(ht) \
315 (HT_HASH_SIZE((ht)->nTableMask) + ((size_t)(ht)->nNumUsed * sizeof(Bucket)))
316 #ifdef __SSE2__
317 # define HT_HASH_RESET(ht) do { \
318 char *p = (char*)&HT_HASH(ht, (ht)->nTableMask); \
319 size_t size = HT_HASH_SIZE((ht)->nTableMask); \
320 __m128i xmm0 = _mm_setzero_si128(); \
321 xmm0 = _mm_cmpeq_epi8(xmm0, xmm0); \
322 ZEND_ASSERT(size >= 64 && ((size & 0x3f) == 0)); \
323 do { \
324 _mm_storeu_si128((__m128i*)p, xmm0); \
325 _mm_storeu_si128((__m128i*)(p+16), xmm0); \
326 _mm_storeu_si128((__m128i*)(p+32), xmm0); \
327 _mm_storeu_si128((__m128i*)(p+48), xmm0); \
328 p += 64; \
329 size -= 64; \
330 } while (size != 0); \
331 } while (0)
332 #else
333 # define HT_HASH_RESET(ht) \
334 memset(&HT_HASH(ht, (ht)->nTableMask), HT_INVALID_IDX, HT_HASH_SIZE((ht)->nTableMask))
335 #endif
336 #define HT_HASH_RESET_PACKED(ht) do { \
337 HT_HASH(ht, -2) = HT_INVALID_IDX; \
338 HT_HASH(ht, -1) = HT_INVALID_IDX; \
339 } while (0)
340 #define HT_HASH_TO_BUCKET(ht, idx) \
341 HT_HASH_TO_BUCKET_EX((ht)->arData, idx)
342
343 #define HT_SET_DATA_ADDR(ht, ptr) do { \
344 (ht)->arData = (Bucket*)(((char*)(ptr)) + HT_HASH_SIZE((ht)->nTableMask)); \
345 } while (0)
346 #define HT_GET_DATA_ADDR(ht) \
347 ((char*)((ht)->arData) - HT_HASH_SIZE((ht)->nTableMask))
348
349 typedef uint32_t HashPosition;
350
351 typedef struct _HashTableIterator {
352 HashTable *ht;
353 HashPosition pos;
354 } HashTableIterator;
355
356 struct _zend_object {
357 zend_refcounted_h gc;
358 uint32_t handle; // TODO: may be removed ???
359 zend_class_entry *ce;
360 const zend_object_handlers *handlers;
361 HashTable *properties;
362 zval properties_table[1];
363 };
364
365 struct _zend_resource {
366 zend_refcounted_h gc;
367 int handle; // TODO: may be removed ???
368 int type;
369 void *ptr;
370 };
371
372 struct _zend_reference {
373 zend_refcounted_h gc;
374 zval val;
375 };
376
377 struct _zend_ast_ref {
378 zend_refcounted_h gc;
379 /*zend_ast ast; zend_ast follows the zend_ast_ref structure */
380 };
381
382 /* regular data types */
383 #define IS_UNDEF 0
384 #define IS_NULL 1
385 #define IS_FALSE 2
386 #define IS_TRUE 3
387 #define IS_LONG 4
388 #define IS_DOUBLE 5
389 #define IS_STRING 6
390 #define IS_ARRAY 7
391 #define IS_OBJECT 8
392 #define IS_RESOURCE 9
393 #define IS_REFERENCE 10
394
395 /* constant expressions */
396 #define IS_CONSTANT_AST 11
397
398 /* internal types */
399 #define IS_INDIRECT 13
400 #define IS_PTR 14
401 #define _IS_ERROR 15
402
403 /* fake types used only for type hinting (Z_TYPE(zv) can not use them) */
404 #define _IS_BOOL 16
405 #define IS_CALLABLE 17
406 #define IS_ITERABLE 18
407 #define IS_VOID 19
408 #define _IS_NUMBER 20
409
zval_get_type(const zval * pz)410 static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
411 return pz->u1.v.type;
412 }
413
414 #define ZEND_SAME_FAKE_TYPE(faketype, realtype) ( \
415 (faketype) == (realtype) \
416 || ((faketype) == _IS_BOOL && ((realtype) == IS_TRUE || (realtype) == IS_FALSE)) \
417 )
418
419 /* we should never set just Z_TYPE, we should set Z_TYPE_INFO */
420 #define Z_TYPE(zval) zval_get_type(&(zval))
421 #define Z_TYPE_P(zval_p) Z_TYPE(*(zval_p))
422
423 #define Z_TYPE_FLAGS(zval) (zval).u1.v.type_flags
424 #define Z_TYPE_FLAGS_P(zval_p) Z_TYPE_FLAGS(*(zval_p))
425
426 #define Z_TYPE_INFO(zval) (zval).u1.type_info
427 #define Z_TYPE_INFO_P(zval_p) Z_TYPE_INFO(*(zval_p))
428
429 #define Z_NEXT(zval) (zval).u2.next
430 #define Z_NEXT_P(zval_p) Z_NEXT(*(zval_p))
431
432 #define Z_CACHE_SLOT(zval) (zval).u2.cache_slot
433 #define Z_CACHE_SLOT_P(zval_p) Z_CACHE_SLOT(*(zval_p))
434
435 #define Z_LINENO(zval) (zval).u2.lineno
436 #define Z_LINENO_P(zval_p) Z_LINENO(*(zval_p))
437
438 #define Z_OPLINE_NUM(zval) (zval).u2.opline_num
439 #define Z_OPLINE_NUM_P(zval_p) Z_OPLINE_NUM(*(zval_p))
440
441 #define Z_FE_POS(zval) (zval).u2.fe_pos
442 #define Z_FE_POS_P(zval_p) Z_FE_POS(*(zval_p))
443
444 #define Z_FE_ITER(zval) (zval).u2.fe_iter_idx
445 #define Z_FE_ITER_P(zval_p) Z_FE_ITER(*(zval_p))
446
447 #define Z_ACCESS_FLAGS(zval) (zval).u2.access_flags
448 #define Z_ACCESS_FLAGS_P(zval_p) Z_ACCESS_FLAGS(*(zval_p))
449
450 #define Z_PROPERTY_GUARD(zval) (zval).u2.property_guard
451 #define Z_PROPERTY_GUARD_P(zval_p) Z_PROPERTY_GUARD(*(zval_p))
452
453 #define Z_CONSTANT_FLAGS(zval) (zval).u2.constant_flags
454 #define Z_CONSTANT_FLAGS_P(zval_p) Z_CONSTANT_FLAGS(*(zval_p))
455
456 #define Z_EXTRA(zval) (zval).u2.extra
457 #define Z_EXTRA_P(zval_p) Z_EXTRA(*(zval_p))
458
459 #define Z_COUNTED(zval) (zval).value.counted
460 #define Z_COUNTED_P(zval_p) Z_COUNTED(*(zval_p))
461
462 #define Z_TYPE_MASK 0xff
463 #define Z_TYPE_FLAGS_MASK 0xff00
464
465 #define Z_TYPE_FLAGS_SHIFT 8
466
467 #define GC_REFCOUNT(p) zend_gc_refcount(&(p)->gc)
468 #define GC_SET_REFCOUNT(p, rc) zend_gc_set_refcount(&(p)->gc, rc)
469 #define GC_ADDREF(p) zend_gc_addref(&(p)->gc)
470 #define GC_DELREF(p) zend_gc_delref(&(p)->gc)
471 #define GC_ADDREF_EX(p, rc) zend_gc_addref_ex(&(p)->gc, rc)
472 #define GC_DELREF_EX(p, rc) zend_gc_delref_ex(&(p)->gc, rc)
473
474 #define GC_TYPE_MASK 0x0000000f
475 #define GC_FLAGS_MASK 0x000003f0
476 #define GC_INFO_MASK 0xfffffc00
477 #define GC_FLAGS_SHIFT 0
478 #define GC_INFO_SHIFT 10
479
zval_gc_type(uint32_t gc_type_info)480 static zend_always_inline zend_uchar zval_gc_type(uint32_t gc_type_info) {
481 return (gc_type_info & GC_TYPE_MASK);
482 }
483
zval_gc_flags(uint32_t gc_type_info)484 static zend_always_inline uint32_t zval_gc_flags(uint32_t gc_type_info) {
485 return (gc_type_info >> GC_FLAGS_SHIFT) & (GC_FLAGS_MASK >> GC_FLAGS_SHIFT);
486 }
487
zval_gc_info(uint32_t gc_type_info)488 static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) {
489 return (gc_type_info >> GC_INFO_SHIFT);
490 }
491
492 #define GC_TYPE_INFO(p) (p)->gc.u.type_info
493 #define GC_TYPE(p) zval_gc_type(GC_TYPE_INFO(p))
494 #define GC_FLAGS(p) zval_gc_flags(GC_TYPE_INFO(p))
495 #define GC_INFO(p) zval_gc_info(GC_TYPE_INFO(p))
496
497 #define GC_ADD_FLAGS(p, flags) do { \
498 GC_TYPE_INFO(p) |= (flags) << GC_FLAGS_SHIFT; \
499 } while (0)
500 #define GC_DEL_FLAGS(p, flags) do { \
501 GC_TYPE_INFO(p) &= ~((flags) << GC_FLAGS_SHIFT); \
502 } while (0)
503
504 #define Z_GC_TYPE(zval) GC_TYPE(Z_COUNTED(zval))
505 #define Z_GC_TYPE_P(zval_p) Z_GC_TYPE(*(zval_p))
506
507 #define Z_GC_FLAGS(zval) GC_FLAGS(Z_COUNTED(zval))
508 #define Z_GC_FLAGS_P(zval_p) Z_GC_FLAGS(*(zval_p))
509
510 #define Z_GC_INFO(zval) GC_INFO(Z_COUNTED(zval))
511 #define Z_GC_INFO_P(zval_p) Z_GC_INFO(*(zval_p))
512 #define Z_GC_TYPE_INFO(zval) GC_TYPE_INFO(Z_COUNTED(zval))
513 #define Z_GC_TYPE_INFO_P(zval_p) Z_GC_TYPE_INFO(*(zval_p))
514
515 /* zval_gc_flags(zval.value->gc.u.type_info) (common flags) */
516 #define GC_COLLECTABLE (1<<4)
517 #define GC_PROTECTED (1<<5) /* used for recursion detection */
518 #define GC_IMMUTABLE (1<<6) /* can't be canged in place */
519 #define GC_PERSISTENT (1<<7) /* allocated using malloc */
520 #define GC_PERSISTENT_LOCAL (1<<8) /* persistent, but thread-local */
521
522 #define GC_ARRAY (IS_ARRAY | (GC_COLLECTABLE << GC_FLAGS_SHIFT))
523 #define GC_OBJECT (IS_OBJECT | (GC_COLLECTABLE << GC_FLAGS_SHIFT))
524
525 /* zval.u1.v.type_flags */
526 #define IS_TYPE_REFCOUNTED (1<<0)
527
528 #if 1
529 /* This optimized version assumes that we have a single "type_flag" */
530 # define Z_TYPE_INFO_REFCOUNTED(t) (((t) & Z_TYPE_FLAGS_MASK) != 0)
531 #else
532 # define Z_TYPE_INFO_REFCOUNTED(t) (((t) & (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT)) != 0)
533 #endif
534
535 /* extended types */
536 #define IS_INTERNED_STRING_EX IS_STRING
537
538 #define IS_STRING_EX (IS_STRING | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT))
539 #define IS_ARRAY_EX (IS_ARRAY | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT))
540 #define IS_OBJECT_EX (IS_OBJECT | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT))
541 #define IS_RESOURCE_EX (IS_RESOURCE | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT))
542 #define IS_REFERENCE_EX (IS_REFERENCE | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT))
543
544 #define IS_CONSTANT_AST_EX (IS_CONSTANT_AST | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT))
545
546 /* string flags (zval.value->gc.u.flags) */
547 #define IS_STR_INTERNED GC_IMMUTABLE /* interned string */
548 #define IS_STR_PERSISTENT GC_PERSISTENT /* allocated using malloc */
549 #define IS_STR_PERMANENT (1<<8) /* relives request boundary */
550
551 /* array flags */
552 #define IS_ARRAY_IMMUTABLE GC_IMMUTABLE
553 #define IS_ARRAY_PERSISTENT GC_PERSISTENT
554
555 /* object flags (zval.value->gc.u.flags) */
556 #define IS_OBJ_DESTRUCTOR_CALLED (1<<8)
557 #define IS_OBJ_FREE_CALLED (1<<9)
558
559 #define OBJ_FLAGS(obj) GC_FLAGS(obj)
560
561 /* Recursion protection macros must be used only for arrays and objects */
562 #define GC_IS_RECURSIVE(p) \
563 (GC_FLAGS(p) & GC_PROTECTED)
564
565 #define GC_PROTECT_RECURSION(p) do { \
566 GC_ADD_FLAGS(p, GC_PROTECTED); \
567 } while (0)
568
569 #define GC_UNPROTECT_RECURSION(p) do { \
570 GC_DEL_FLAGS(p, GC_PROTECTED); \
571 } while (0)
572
573 #define GC_TRY_PROTECT_RECURSION(p) do { \
574 if (!(GC_FLAGS(p) & GC_IMMUTABLE)) GC_PROTECT_RECURSION(p); \
575 } while (0)
576
577 #define GC_TRY_UNPROTECT_RECURSION(p) do { \
578 if (!(GC_FLAGS(p) & GC_IMMUTABLE)) GC_UNPROTECT_RECURSION(p); \
579 } while (0)
580
581 #define Z_IS_RECURSIVE(zval) GC_IS_RECURSIVE(Z_COUNTED(zval))
582 #define Z_PROTECT_RECURSION(zval) GC_PROTECT_RECURSION(Z_COUNTED(zval))
583 #define Z_UNPROTECT_RECURSION(zval) GC_UNPROTECT_RECURSION(Z_COUNTED(zval))
584 #define Z_IS_RECURSIVE_P(zv) Z_IS_RECURSIVE(*(zv))
585 #define Z_PROTECT_RECURSION_P(zv) Z_PROTECT_RECURSION(*(zv))
586 #define Z_UNPROTECT_RECURSION_P(zv) Z_UNPROTECT_RECURSION(*(zv))
587
588 /* All data types < IS_STRING have their constructor/destructors skipped */
589 #define Z_CONSTANT(zval) (Z_TYPE(zval) == IS_CONSTANT_AST)
590 #define Z_CONSTANT_P(zval_p) Z_CONSTANT(*(zval_p))
591
592 #if 1
593 /* This optimized version assumes that we have a single "type_flag" */
594 #define Z_REFCOUNTED(zval) (Z_TYPE_FLAGS(zval) != 0)
595 #else
596 #define Z_REFCOUNTED(zval) ((Z_TYPE_FLAGS(zval) & IS_TYPE_REFCOUNTED) != 0)
597 #endif
598 #define Z_REFCOUNTED_P(zval_p) Z_REFCOUNTED(*(zval_p))
599
600 /* deprecated: (COPYABLE is the same as IS_ARRAY) */
601 #define Z_COPYABLE(zval) (Z_TYPE(zval) == IS_ARRAY)
602 #define Z_COPYABLE_P(zval_p) Z_COPYABLE(*(zval_p))
603
604 /* deprecated: (IMMUTABLE is the same as IS_ARRAY && !REFCOUNTED) */
605 #define Z_IMMUTABLE(zval) (Z_TYPE_INFO(zval) == IS_ARRAY)
606 #define Z_IMMUTABLE_P(zval_p) Z_IMMUTABLE(*(zval_p))
607 #define Z_OPT_IMMUTABLE(zval) Z_IMMUTABLE(zval_p)
608 #define Z_OPT_IMMUTABLE_P(zval_p) Z_IMMUTABLE(*(zval_p))
609
610 /* the following Z_OPT_* macros make better code when Z_TYPE_INFO accessed before */
611 #define Z_OPT_TYPE(zval) (Z_TYPE_INFO(zval) & Z_TYPE_MASK)
612 #define Z_OPT_TYPE_P(zval_p) Z_OPT_TYPE(*(zval_p))
613
614 #define Z_OPT_CONSTANT(zval) (Z_OPT_TYPE(zval) == IS_CONSTANT_AST)
615 #define Z_OPT_CONSTANT_P(zval_p) Z_OPT_CONSTANT(*(zval_p))
616
617 #define Z_OPT_REFCOUNTED(zval) Z_TYPE_INFO_REFCOUNTED(Z_TYPE_INFO(zval))
618 #define Z_OPT_REFCOUNTED_P(zval_p) Z_OPT_REFCOUNTED(*(zval_p))
619
620 /* deprecated: (COPYABLE is the same as IS_ARRAY) */
621 #define Z_OPT_COPYABLE(zval) (Z_OPT_TYPE(zval) == IS_ARRAY)
622 #define Z_OPT_COPYABLE_P(zval_p) Z_OPT_COPYABLE(*(zval_p))
623
624 #define Z_OPT_ISREF(zval) (Z_OPT_TYPE(zval) == IS_REFERENCE)
625 #define Z_OPT_ISREF_P(zval_p) Z_OPT_ISREF(*(zval_p))
626
627 #define Z_ISREF(zval) (Z_TYPE(zval) == IS_REFERENCE)
628 #define Z_ISREF_P(zval_p) Z_ISREF(*(zval_p))
629
630 #define Z_ISUNDEF(zval) (Z_TYPE(zval) == IS_UNDEF)
631 #define Z_ISUNDEF_P(zval_p) Z_ISUNDEF(*(zval_p))
632
633 #define Z_ISNULL(zval) (Z_TYPE(zval) == IS_NULL)
634 #define Z_ISNULL_P(zval_p) Z_ISNULL(*(zval_p))
635
636 #define Z_ISERROR(zval) (Z_TYPE(zval) == _IS_ERROR)
637 #define Z_ISERROR_P(zval_p) Z_ISERROR(*(zval_p))
638
639 #define Z_LVAL(zval) (zval).value.lval
640 #define Z_LVAL_P(zval_p) Z_LVAL(*(zval_p))
641
642 #define Z_DVAL(zval) (zval).value.dval
643 #define Z_DVAL_P(zval_p) Z_DVAL(*(zval_p))
644
645 #define Z_STR(zval) (zval).value.str
646 #define Z_STR_P(zval_p) Z_STR(*(zval_p))
647
648 #define Z_STRVAL(zval) ZSTR_VAL(Z_STR(zval))
649 #define Z_STRVAL_P(zval_p) Z_STRVAL(*(zval_p))
650
651 #define Z_STRLEN(zval) ZSTR_LEN(Z_STR(zval))
652 #define Z_STRLEN_P(zval_p) Z_STRLEN(*(zval_p))
653
654 #define Z_STRHASH(zval) ZSTR_HASH(Z_STR(zval))
655 #define Z_STRHASH_P(zval_p) Z_STRHASH(*(zval_p))
656
657 #define Z_ARR(zval) (zval).value.arr
658 #define Z_ARR_P(zval_p) Z_ARR(*(zval_p))
659
660 #define Z_ARRVAL(zval) Z_ARR(zval)
661 #define Z_ARRVAL_P(zval_p) Z_ARRVAL(*(zval_p))
662
663 #define Z_OBJ(zval) (zval).value.obj
664 #define Z_OBJ_P(zval_p) Z_OBJ(*(zval_p))
665
666 #define Z_OBJ_HT(zval) Z_OBJ(zval)->handlers
667 #define Z_OBJ_HT_P(zval_p) Z_OBJ_HT(*(zval_p))
668
669 #define Z_OBJ_HANDLER(zval, hf) Z_OBJ_HT((zval))->hf
670 #define Z_OBJ_HANDLER_P(zv_p, hf) Z_OBJ_HANDLER(*(zv_p), hf)
671
672 #define Z_OBJ_HANDLE(zval) (Z_OBJ((zval)))->handle
673 #define Z_OBJ_HANDLE_P(zval_p) Z_OBJ_HANDLE(*(zval_p))
674
675 #define Z_OBJCE(zval) (Z_OBJ(zval)->ce)
676 #define Z_OBJCE_P(zval_p) Z_OBJCE(*(zval_p))
677
678 #define Z_OBJPROP(zval) Z_OBJ_HT((zval))->get_properties(&(zval))
679 #define Z_OBJPROP_P(zval_p) Z_OBJPROP(*(zval_p))
680
681 #define Z_OBJDEBUG(zval,tmp) (Z_OBJ_HANDLER((zval),get_debug_info)?Z_OBJ_HANDLER((zval),get_debug_info)(&(zval),&tmp):(tmp=0,Z_OBJ_HANDLER((zval),get_properties)?Z_OBJPROP(zval):NULL))
682 #define Z_OBJDEBUG_P(zval_p,tmp) Z_OBJDEBUG(*(zval_p), tmp)
683
684 #define Z_RES(zval) (zval).value.res
685 #define Z_RES_P(zval_p) Z_RES(*zval_p)
686
687 #define Z_RES_HANDLE(zval) Z_RES(zval)->handle
688 #define Z_RES_HANDLE_P(zval_p) Z_RES_HANDLE(*zval_p)
689
690 #define Z_RES_TYPE(zval) Z_RES(zval)->type
691 #define Z_RES_TYPE_P(zval_p) Z_RES_TYPE(*zval_p)
692
693 #define Z_RES_VAL(zval) Z_RES(zval)->ptr
694 #define Z_RES_VAL_P(zval_p) Z_RES_VAL(*zval_p)
695
696 #define Z_REF(zval) (zval).value.ref
697 #define Z_REF_P(zval_p) Z_REF(*(zval_p))
698
699 #define Z_REFVAL(zval) &Z_REF(zval)->val
700 #define Z_REFVAL_P(zval_p) Z_REFVAL(*(zval_p))
701
702 #define Z_AST(zval) (zval).value.ast
703 #define Z_AST_P(zval_p) Z_AST(*(zval_p))
704
705 #define GC_AST(p) ((zend_ast*)(((char*)p) + sizeof(zend_ast_ref)))
706
707 #define Z_ASTVAL(zval) GC_AST(Z_AST(zval))
708 #define Z_ASTVAL_P(zval_p) Z_ASTVAL(*(zval_p))
709
710 #define Z_INDIRECT(zval) (zval).value.zv
711 #define Z_INDIRECT_P(zval_p) Z_INDIRECT(*(zval_p))
712
713 #define Z_CE(zval) (zval).value.ce
714 #define Z_CE_P(zval_p) Z_CE(*(zval_p))
715
716 #define Z_FUNC(zval) (zval).value.func
717 #define Z_FUNC_P(zval_p) Z_FUNC(*(zval_p))
718
719 #define Z_PTR(zval) (zval).value.ptr
720 #define Z_PTR_P(zval_p) Z_PTR(*(zval_p))
721
722 #define ZVAL_UNDEF(z) do { \
723 Z_TYPE_INFO_P(z) = IS_UNDEF; \
724 } while (0)
725
726 #define ZVAL_NULL(z) do { \
727 Z_TYPE_INFO_P(z) = IS_NULL; \
728 } while (0)
729
730 #define ZVAL_FALSE(z) do { \
731 Z_TYPE_INFO_P(z) = IS_FALSE; \
732 } while (0)
733
734 #define ZVAL_TRUE(z) do { \
735 Z_TYPE_INFO_P(z) = IS_TRUE; \
736 } while (0)
737
738 #define ZVAL_BOOL(z, b) do { \
739 Z_TYPE_INFO_P(z) = \
740 (b) ? IS_TRUE : IS_FALSE; \
741 } while (0)
742
743 #define ZVAL_LONG(z, l) { \
744 zval *__z = (z); \
745 Z_LVAL_P(__z) = l; \
746 Z_TYPE_INFO_P(__z) = IS_LONG; \
747 }
748
749 #define ZVAL_DOUBLE(z, d) { \
750 zval *__z = (z); \
751 Z_DVAL_P(__z) = d; \
752 Z_TYPE_INFO_P(__z) = IS_DOUBLE; \
753 }
754
755 #define ZVAL_STR(z, s) do { \
756 zval *__z = (z); \
757 zend_string *__s = (s); \
758 Z_STR_P(__z) = __s; \
759 /* interned strings support */ \
760 Z_TYPE_INFO_P(__z) = ZSTR_IS_INTERNED(__s) ? \
761 IS_INTERNED_STRING_EX : \
762 IS_STRING_EX; \
763 } while (0)
764
765 #define ZVAL_INTERNED_STR(z, s) do { \
766 zval *__z = (z); \
767 zend_string *__s = (s); \
768 Z_STR_P(__z) = __s; \
769 Z_TYPE_INFO_P(__z) = IS_INTERNED_STRING_EX; \
770 } while (0)
771
772 #define ZVAL_NEW_STR(z, s) do { \
773 zval *__z = (z); \
774 zend_string *__s = (s); \
775 Z_STR_P(__z) = __s; \
776 Z_TYPE_INFO_P(__z) = IS_STRING_EX; \
777 } while (0)
778
779 #define ZVAL_STR_COPY(z, s) do { \
780 zval *__z = (z); \
781 zend_string *__s = (s); \
782 Z_STR_P(__z) = __s; \
783 /* interned strings support */ \
784 if (ZSTR_IS_INTERNED(__s)) { \
785 Z_TYPE_INFO_P(__z) = IS_INTERNED_STRING_EX; \
786 } else { \
787 GC_ADDREF(__s); \
788 Z_TYPE_INFO_P(__z) = IS_STRING_EX; \
789 } \
790 } while (0)
791
792 #define ZVAL_ARR(z, a) do { \
793 zend_array *__arr = (a); \
794 zval *__z = (z); \
795 Z_ARR_P(__z) = __arr; \
796 Z_TYPE_INFO_P(__z) = IS_ARRAY_EX; \
797 } while (0)
798
799 #define ZVAL_NEW_ARR(z) do { \
800 zval *__z = (z); \
801 zend_array *_arr = \
802 (zend_array *) emalloc(sizeof(zend_array)); \
803 Z_ARR_P(__z) = _arr; \
804 Z_TYPE_INFO_P(__z) = IS_ARRAY_EX; \
805 } while (0)
806
807 #define ZVAL_NEW_PERSISTENT_ARR(z) do { \
808 zval *__z = (z); \
809 zend_array *_arr = \
810 (zend_array *) malloc(sizeof(zend_array)); \
811 Z_ARR_P(__z) = _arr; \
812 Z_TYPE_INFO_P(__z) = IS_ARRAY_EX; \
813 } while (0)
814
815 #define ZVAL_OBJ(z, o) do { \
816 zval *__z = (z); \
817 Z_OBJ_P(__z) = (o); \
818 Z_TYPE_INFO_P(__z) = IS_OBJECT_EX; \
819 } while (0)
820
821 #define ZVAL_RES(z, r) do { \
822 zval *__z = (z); \
823 Z_RES_P(__z) = (r); \
824 Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX; \
825 } while (0)
826
827 #define ZVAL_NEW_RES(z, h, p, t) do { \
828 zend_resource *_res = \
829 (zend_resource *) emalloc(sizeof(zend_resource)); \
830 zval *__z; \
831 GC_SET_REFCOUNT(_res, 1); \
832 GC_TYPE_INFO(_res) = IS_RESOURCE; \
833 _res->handle = (h); \
834 _res->type = (t); \
835 _res->ptr = (p); \
836 __z = (z); \
837 Z_RES_P(__z) = _res; \
838 Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX; \
839 } while (0)
840
841 #define ZVAL_NEW_PERSISTENT_RES(z, h, p, t) do { \
842 zend_resource *_res = \
843 (zend_resource *) malloc(sizeof(zend_resource)); \
844 zval *__z; \
845 GC_SET_REFCOUNT(_res, 1); \
846 GC_TYPE_INFO(_res) = IS_RESOURCE | \
847 (GC_PERSISTENT << GC_FLAGS_SHIFT); \
848 _res->handle = (h); \
849 _res->type = (t); \
850 _res->ptr = (p); \
851 __z = (z); \
852 Z_RES_P(__z) = _res; \
853 Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX; \
854 } while (0)
855
856 #define ZVAL_REF(z, r) do { \
857 zval *__z = (z); \
858 Z_REF_P(__z) = (r); \
859 Z_TYPE_INFO_P(__z) = IS_REFERENCE_EX; \
860 } while (0)
861
862 #define ZVAL_NEW_EMPTY_REF(z) do { \
863 zend_reference *_ref = \
864 (zend_reference *) emalloc(sizeof(zend_reference)); \
865 GC_SET_REFCOUNT(_ref, 1); \
866 GC_TYPE_INFO(_ref) = IS_REFERENCE; \
867 Z_REF_P(z) = _ref; \
868 Z_TYPE_INFO_P(z) = IS_REFERENCE_EX; \
869 } while (0)
870
871 #define ZVAL_NEW_REF(z, r) do { \
872 zend_reference *_ref = \
873 (zend_reference *) emalloc(sizeof(zend_reference)); \
874 GC_SET_REFCOUNT(_ref, 1); \
875 GC_TYPE_INFO(_ref) = IS_REFERENCE; \
876 ZVAL_COPY_VALUE(&_ref->val, r); \
877 Z_REF_P(z) = _ref; \
878 Z_TYPE_INFO_P(z) = IS_REFERENCE_EX; \
879 } while (0)
880
881 #define ZVAL_MAKE_REF_EX(z, refcount) do { \
882 zval *_z = (z); \
883 zend_reference *_ref = \
884 (zend_reference *) emalloc(sizeof(zend_reference)); \
885 GC_SET_REFCOUNT(_ref, (refcount)); \
886 GC_TYPE_INFO(_ref) = IS_REFERENCE; \
887 ZVAL_COPY_VALUE(&_ref->val, _z); \
888 Z_REF_P(_z) = _ref; \
889 Z_TYPE_INFO_P(_z) = IS_REFERENCE_EX; \
890 } while (0)
891
892 #define ZVAL_NEW_PERSISTENT_REF(z, r) do { \
893 zend_reference *_ref = \
894 (zend_reference *) malloc(sizeof(zend_reference)); \
895 GC_SET_REFCOUNT(_ref, 1); \
896 GC_TYPE_INFO(_ref) = IS_REFERENCE | \
897 (GC_PERSISTENT << GC_FLAGS_SHIFT); \
898 ZVAL_COPY_VALUE(&_ref->val, r); \
899 Z_REF_P(z) = _ref; \
900 Z_TYPE_INFO_P(z) = IS_REFERENCE_EX; \
901 } while (0)
902
903 #define ZVAL_AST(z, ast) do { \
904 zval *__z = (z); \
905 Z_AST_P(__z) = ast; \
906 Z_TYPE_INFO_P(__z) = IS_CONSTANT_AST_EX; \
907 } while (0)
908
909 #define ZVAL_INDIRECT(z, v) do { \
910 Z_INDIRECT_P(z) = (v); \
911 Z_TYPE_INFO_P(z) = IS_INDIRECT; \
912 } while (0)
913
914 #define ZVAL_PTR(z, p) do { \
915 Z_PTR_P(z) = (p); \
916 Z_TYPE_INFO_P(z) = IS_PTR; \
917 } while (0)
918
919 #define ZVAL_FUNC(z, f) do { \
920 Z_FUNC_P(z) = (f); \
921 Z_TYPE_INFO_P(z) = IS_PTR; \
922 } while (0)
923
924 #define ZVAL_CE(z, c) do { \
925 Z_CE_P(z) = (c); \
926 Z_TYPE_INFO_P(z) = IS_PTR; \
927 } while (0)
928
929 #define ZVAL_ERROR(z) do { \
930 Z_TYPE_INFO_P(z) = _IS_ERROR; \
931 } while (0)
932
933 #define Z_REFCOUNT_P(pz) zval_refcount_p(pz)
934 #define Z_SET_REFCOUNT_P(pz, rc) zval_set_refcount_p(pz, rc)
935 #define Z_ADDREF_P(pz) zval_addref_p(pz)
936 #define Z_DELREF_P(pz) zval_delref_p(pz)
937
938 #define Z_REFCOUNT(z) Z_REFCOUNT_P(&(z))
939 #define Z_SET_REFCOUNT(z, rc) Z_SET_REFCOUNT_P(&(z), rc)
940 #define Z_ADDREF(z) Z_ADDREF_P(&(z))
941 #define Z_DELREF(z) Z_DELREF_P(&(z))
942
943 #define Z_TRY_ADDREF_P(pz) do { \
944 if (Z_REFCOUNTED_P((pz))) { \
945 Z_ADDREF_P((pz)); \
946 } \
947 } while (0)
948
949 #define Z_TRY_DELREF_P(pz) do { \
950 if (Z_REFCOUNTED_P((pz))) { \
951 Z_DELREF_P((pz)); \
952 } \
953 } while (0)
954
955 #define Z_TRY_ADDREF(z) Z_TRY_ADDREF_P(&(z))
956 #define Z_TRY_DELREF(z) Z_TRY_DELREF_P(&(z))
957
958 #ifndef ZEND_RC_DEBUG
959 # define ZEND_RC_DEBUG 0
960 #endif
961
962 #if ZEND_RC_DEBUG
963 extern ZEND_API zend_bool zend_rc_debug;
964 # define ZEND_RC_MOD_CHECK(p) do { \
965 if (zend_rc_debug) { \
966 ZEND_ASSERT(!(zval_gc_flags((p)->u.type_info) & GC_IMMUTABLE)); \
967 ZEND_ASSERT((zval_gc_flags((p)->u.type_info) & (GC_PERSISTENT|GC_PERSISTENT_LOCAL)) != GC_PERSISTENT); \
968 } \
969 } while (0)
970 # define GC_MAKE_PERSISTENT_LOCAL(p) do { \
971 GC_ADD_FLAGS(p, GC_PERSISTENT_LOCAL); \
972 } while (0)
973 #else
974 # define ZEND_RC_MOD_CHECK(p) \
975 do { } while (0)
976 # define GC_MAKE_PERSISTENT_LOCAL(p) \
977 do { } while (0)
978 #endif
979
zend_gc_refcount(const zend_refcounted_h * p)980 static zend_always_inline uint32_t zend_gc_refcount(const zend_refcounted_h *p) {
981 return p->refcount;
982 }
983
zend_gc_set_refcount(zend_refcounted_h * p,uint32_t rc)984 static zend_always_inline uint32_t zend_gc_set_refcount(zend_refcounted_h *p, uint32_t rc) {
985 p->refcount = rc;
986 return p->refcount;
987 }
988
zend_gc_addref(zend_refcounted_h * p)989 static zend_always_inline uint32_t zend_gc_addref(zend_refcounted_h *p) {
990 ZEND_RC_MOD_CHECK(p);
991 return ++(p->refcount);
992 }
993
zend_gc_delref(zend_refcounted_h * p)994 static zend_always_inline uint32_t zend_gc_delref(zend_refcounted_h *p) {
995 ZEND_RC_MOD_CHECK(p);
996 return --(p->refcount);
997 }
998
zend_gc_addref_ex(zend_refcounted_h * p,uint32_t rc)999 static zend_always_inline uint32_t zend_gc_addref_ex(zend_refcounted_h *p, uint32_t rc) {
1000 ZEND_RC_MOD_CHECK(p);
1001 p->refcount += rc;
1002 return p->refcount;
1003 }
1004
zend_gc_delref_ex(zend_refcounted_h * p,uint32_t rc)1005 static zend_always_inline uint32_t zend_gc_delref_ex(zend_refcounted_h *p, uint32_t rc) {
1006 ZEND_RC_MOD_CHECK(p);
1007 p->refcount -= rc;
1008 return p->refcount;
1009 }
1010
zval_refcount_p(const zval * pz)1011 static zend_always_inline uint32_t zval_refcount_p(const zval* pz) {
1012 #if ZEND_DEBUG
1013 ZEND_ASSERT(Z_REFCOUNTED_P(pz) || Z_TYPE_P(pz) == IS_ARRAY);
1014 #endif
1015 return GC_REFCOUNT(Z_COUNTED_P(pz));
1016 }
1017
zval_set_refcount_p(zval * pz,uint32_t rc)1018 static zend_always_inline uint32_t zval_set_refcount_p(zval* pz, uint32_t rc) {
1019 ZEND_ASSERT(Z_REFCOUNTED_P(pz));
1020 return GC_SET_REFCOUNT(Z_COUNTED_P(pz), rc);
1021 }
1022
zval_addref_p(zval * pz)1023 static zend_always_inline uint32_t zval_addref_p(zval* pz) {
1024 ZEND_ASSERT(Z_REFCOUNTED_P(pz));
1025 return GC_ADDREF(Z_COUNTED_P(pz));
1026 }
1027
zval_delref_p(zval * pz)1028 static zend_always_inline uint32_t zval_delref_p(zval* pz) {
1029 ZEND_ASSERT(Z_REFCOUNTED_P(pz));
1030 return GC_DELREF(Z_COUNTED_P(pz));
1031 }
1032
1033 #if SIZEOF_SIZE_T == 4
1034 # define ZVAL_COPY_VALUE_EX(z, v, gc, t) \
1035 do { \
1036 uint32_t _w2 = v->value.ww.w2; \
1037 Z_COUNTED_P(z) = gc; \
1038 z->value.ww.w2 = _w2; \
1039 Z_TYPE_INFO_P(z) = t; \
1040 } while (0)
1041 #elif SIZEOF_SIZE_T == 8
1042 # define ZVAL_COPY_VALUE_EX(z, v, gc, t) \
1043 do { \
1044 Z_COUNTED_P(z) = gc; \
1045 Z_TYPE_INFO_P(z) = t; \
1046 } while (0)
1047 #else
1048 # error "Unknown SIZEOF_SIZE_T"
1049 #endif
1050
1051 #define ZVAL_COPY_VALUE(z, v) \
1052 do { \
1053 zval *_z1 = (z); \
1054 const zval *_z2 = (v); \
1055 zend_refcounted *_gc = Z_COUNTED_P(_z2); \
1056 uint32_t _t = Z_TYPE_INFO_P(_z2); \
1057 ZVAL_COPY_VALUE_EX(_z1, _z2, _gc, _t); \
1058 } while (0)
1059
1060 #define ZVAL_COPY(z, v) \
1061 do { \
1062 zval *_z1 = (z); \
1063 const zval *_z2 = (v); \
1064 zend_refcounted *_gc = Z_COUNTED_P(_z2); \
1065 uint32_t _t = Z_TYPE_INFO_P(_z2); \
1066 ZVAL_COPY_VALUE_EX(_z1, _z2, _gc, _t); \
1067 if (Z_TYPE_INFO_REFCOUNTED(_t)) { \
1068 GC_ADDREF(_gc); \
1069 } \
1070 } while (0)
1071
1072 #define ZVAL_DUP(z, v) \
1073 do { \
1074 zval *_z1 = (z); \
1075 const zval *_z2 = (v); \
1076 zend_refcounted *_gc = Z_COUNTED_P(_z2); \
1077 uint32_t _t = Z_TYPE_INFO_P(_z2); \
1078 if ((_t & Z_TYPE_MASK) == IS_ARRAY) { \
1079 ZVAL_ARR(_z1, zend_array_dup((zend_array*)_gc));\
1080 } else { \
1081 if (Z_TYPE_INFO_REFCOUNTED(_t)) { \
1082 GC_ADDREF(_gc); \
1083 } \
1084 ZVAL_COPY_VALUE_EX(_z1, _z2, _gc, _t); \
1085 } \
1086 } while (0)
1087
1088
1089 /* ZVAL_COPY_OR_DUP() should be used instead of ZVAL_COPY() and ZVAL_DUP()
1090 * in all places where the source may be a persistent zval.
1091 */
1092 #define ZVAL_COPY_OR_DUP(z, v) \
1093 do { \
1094 zval *_z1 = (z); \
1095 const zval *_z2 = (v); \
1096 zend_refcounted *_gc = Z_COUNTED_P(_z2); \
1097 uint32_t _t = Z_TYPE_INFO_P(_z2); \
1098 ZVAL_COPY_VALUE_EX(_z1, _z2, _gc, _t); \
1099 if (Z_TYPE_INFO_REFCOUNTED(_t)) { \
1100 if (EXPECTED(!(GC_FLAGS(_gc) & GC_PERSISTENT))) { \
1101 GC_ADDREF(_gc); \
1102 } else { \
1103 zval_copy_ctor_func(_z1); \
1104 } \
1105 } \
1106 } while (0)
1107
1108 #define ZVAL_DEREF(z) do { \
1109 if (UNEXPECTED(Z_ISREF_P(z))) { \
1110 (z) = Z_REFVAL_P(z); \
1111 } \
1112 } while (0)
1113
1114 #define ZVAL_DEINDIRECT(z) do { \
1115 if (Z_TYPE_P(z) == IS_INDIRECT) { \
1116 (z) = Z_INDIRECT_P(z); \
1117 } \
1118 } while (0)
1119
1120 #define ZVAL_OPT_DEREF(z) do { \
1121 if (UNEXPECTED(Z_OPT_ISREF_P(z))) { \
1122 (z) = Z_REFVAL_P(z); \
1123 } \
1124 } while (0)
1125
1126 #define ZVAL_MAKE_REF(zv) do { \
1127 zval *__zv = (zv); \
1128 if (!Z_ISREF_P(__zv)) { \
1129 ZVAL_NEW_REF(__zv, __zv); \
1130 } \
1131 } while (0)
1132
1133 #define ZVAL_UNREF(z) do { \
1134 zval *_z = (z); \
1135 zend_reference *ref; \
1136 ZEND_ASSERT(Z_ISREF_P(_z)); \
1137 ref = Z_REF_P(_z); \
1138 ZVAL_COPY_VALUE(_z, &ref->val); \
1139 efree_size(ref, sizeof(zend_reference)); \
1140 } while (0)
1141
1142 #define ZVAL_COPY_DEREF(z, v) do { \
1143 zval *_z3 = (v); \
1144 if (Z_OPT_REFCOUNTED_P(_z3)) { \
1145 if (UNEXPECTED(Z_OPT_ISREF_P(_z3))) { \
1146 _z3 = Z_REFVAL_P(_z3); \
1147 if (Z_OPT_REFCOUNTED_P(_z3)) { \
1148 Z_ADDREF_P(_z3); \
1149 } \
1150 } else { \
1151 Z_ADDREF_P(_z3); \
1152 } \
1153 } \
1154 ZVAL_COPY_VALUE(z, _z3); \
1155 } while (0)
1156
1157
1158 #define SEPARATE_STRING(zv) do { \
1159 zval *_zv = (zv); \
1160 if (Z_REFCOUNT_P(_zv) > 1) { \
1161 zend_string *_str = Z_STR_P(_zv); \
1162 ZEND_ASSERT(Z_REFCOUNTED_P(_zv)); \
1163 ZEND_ASSERT(!ZSTR_IS_INTERNED(_str)); \
1164 Z_DELREF_P(_zv); \
1165 ZVAL_NEW_STR(_zv, zend_string_init( \
1166 ZSTR_VAL(_str), ZSTR_LEN(_str), 0)); \
1167 } \
1168 } while (0)
1169
1170 #define SEPARATE_ARRAY(zv) do { \
1171 zval *_zv = (zv); \
1172 zend_array *_arr = Z_ARR_P(_zv); \
1173 if (UNEXPECTED(GC_REFCOUNT(_arr) > 1)) { \
1174 if (Z_REFCOUNTED_P(_zv)) { \
1175 GC_DELREF(_arr); \
1176 } \
1177 ZVAL_ARR(_zv, zend_array_dup(_arr)); \
1178 } \
1179 } while (0)
1180
1181 #define SEPARATE_ZVAL_IF_NOT_REF(zv) do { \
1182 zval *__zv = (zv); \
1183 if (Z_TYPE_P(__zv) == IS_ARRAY) { \
1184 if (Z_REFCOUNT_P(__zv) > 1) { \
1185 if (Z_REFCOUNTED_P(__zv)) { \
1186 Z_DELREF_P(__zv); \
1187 } \
1188 ZVAL_ARR(__zv, zend_array_dup(Z_ARR_P(__zv)));\
1189 } \
1190 } \
1191 } while (0)
1192
1193 #define SEPARATE_ZVAL_NOREF(zv) do { \
1194 zval *_zv = (zv); \
1195 ZEND_ASSERT(Z_TYPE_P(_zv) != IS_REFERENCE); \
1196 SEPARATE_ZVAL_IF_NOT_REF(_zv); \
1197 } while (0)
1198
1199 #define SEPARATE_ZVAL(zv) do { \
1200 zval *_zv = (zv); \
1201 if (Z_ISREF_P(_zv)) { \
1202 zend_reference *_r = Z_REF_P(_zv); \
1203 ZVAL_COPY_VALUE(_zv, &_r->val); \
1204 if (GC_DELREF(_r) == 0) { \
1205 efree_size(_r, sizeof(zend_reference)); \
1206 } else if (Z_OPT_TYPE_P(_zv) == IS_ARRAY) { \
1207 ZVAL_ARR(_zv, zend_array_dup(Z_ARR_P(_zv)));\
1208 break; \
1209 } else if (Z_OPT_REFCOUNTED_P(_zv)) { \
1210 Z_ADDREF_P(_zv); \
1211 break; \
1212 } \
1213 } \
1214 SEPARATE_ZVAL_IF_NOT_REF(_zv); \
1215 } while (0)
1216
1217 #define SEPARATE_ARG_IF_REF(varptr) do { \
1218 ZVAL_DEREF(varptr); \
1219 if (Z_REFCOUNTED_P(varptr)) { \
1220 Z_ADDREF_P(varptr); \
1221 } \
1222 } while (0)
1223
1224 #endif /* ZEND_TYPES_H */
1225
1226 /*
1227 * Local variables:
1228 * tab-width: 4
1229 * c-basic-offset: 4
1230 * indent-tabs-mode: t
1231 * End:
1232 * vim600: sw=4 ts=4 fdm=marker
1233 * vim<600: sw=4 ts=4
1234 */
1235
