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 +----------------------------------------------------------------------+
19 */
20
21 #ifndef ZEND_OPERATORS_H
22 #define ZEND_OPERATORS_H
23
24 #include <errno.h>
25 #include <math.h>
26 #include <assert.h>
27 #include <stddef.h>
28
29 #ifdef HAVE_IEEEFP_H
30 #include <ieeefp.h>
31 #endif
32
33 #include "zend_portability.h"
34 #include "zend_strtod.h"
35 #include "zend_multiply.h"
36 #include "zend_object_handlers.h"
37
38 #define LONG_SIGN_MASK ZEND_LONG_MIN
39
40 BEGIN_EXTERN_C()
41 ZEND_API zend_result ZEND_FASTCALL add_function(zval *result, zval *op1, zval *op2);
42 ZEND_API zend_result ZEND_FASTCALL sub_function(zval *result, zval *op1, zval *op2);
43 ZEND_API zend_result ZEND_FASTCALL mul_function(zval *result, zval *op1, zval *op2);
44 ZEND_API zend_result ZEND_FASTCALL pow_function(zval *result, zval *op1, zval *op2);
45 ZEND_API zend_result ZEND_FASTCALL div_function(zval *result, zval *op1, zval *op2);
46 ZEND_API zend_result ZEND_FASTCALL mod_function(zval *result, zval *op1, zval *op2);
47 ZEND_API zend_result ZEND_FASTCALL boolean_xor_function(zval *result, zval *op1, zval *op2);
48 ZEND_API zend_result ZEND_FASTCALL boolean_not_function(zval *result, zval *op1);
49 ZEND_API zend_result ZEND_FASTCALL bitwise_not_function(zval *result, zval *op1);
50 ZEND_API zend_result ZEND_FASTCALL bitwise_or_function(zval *result, zval *op1, zval *op2);
51 ZEND_API zend_result ZEND_FASTCALL bitwise_and_function(zval *result, zval *op1, zval *op2);
52 ZEND_API zend_result ZEND_FASTCALL bitwise_xor_function(zval *result, zval *op1, zval *op2);
53 ZEND_API zend_result ZEND_FASTCALL shift_left_function(zval *result, zval *op1, zval *op2);
54 ZEND_API zend_result ZEND_FASTCALL shift_right_function(zval *result, zval *op1, zval *op2);
55 ZEND_API zend_result ZEND_FASTCALL concat_function(zval *result, zval *op1, zval *op2);
56
57 ZEND_API zend_bool ZEND_FASTCALL zend_is_identical(zval *op1, zval *op2);
58
59 ZEND_API zend_result ZEND_FASTCALL is_equal_function(zval *result, zval *op1, zval *op2);
60 ZEND_API zend_result ZEND_FASTCALL is_identical_function(zval *result, zval *op1, zval *op2);
61 ZEND_API zend_result ZEND_FASTCALL is_not_identical_function(zval *result, zval *op1, zval *op2);
62 ZEND_API zend_result ZEND_FASTCALL is_not_equal_function(zval *result, zval *op1, zval *op2);
63 ZEND_API zend_result ZEND_FASTCALL is_smaller_function(zval *result, zval *op1, zval *op2);
64 ZEND_API zend_result ZEND_FASTCALL is_smaller_or_equal_function(zval *result, zval *op1, zval *op2);
65
66 ZEND_API zend_bool ZEND_FASTCALL zend_class_implements_interface(const zend_class_entry *class_ce, const zend_class_entry *interface_ce);
67 ZEND_API zend_bool ZEND_FASTCALL instanceof_function_slow(const zend_class_entry *instance_ce, const zend_class_entry *ce);
68
instanceof_function(const zend_class_entry * instance_ce,const zend_class_entry * ce)69 static zend_always_inline zend_bool instanceof_function(
70 const zend_class_entry *instance_ce, const zend_class_entry *ce) {
71 return instance_ce == ce || instanceof_function_slow(instance_ce, ce);
72 }
73
74 /**
75 * Checks whether the string "str" with length "length" is numeric. The value
76 * of allow_errors determines whether it's required to be entirely numeric, or
77 * just its prefix. Leading whitespace is allowed.
78 *
79 * The function returns 0 if the string did not contain a valid number; IS_LONG
80 * if it contained a number that fits within the range of a long; or IS_DOUBLE
81 * if the number was out of long range or contained a decimal point/exponent.
82 * The number's value is returned into the respective pointer, *lval or *dval,
83 * if that pointer is not NULL.
84 *
85 * This variant also gives information if a string that represents an integer
86 * could not be represented as such due to overflow. It writes 1 to oflow_info
87 * if the integer is larger than ZEND_LONG_MAX and -1 if it's smaller than ZEND_LONG_MIN.
88 */
89 ZEND_API zend_uchar ZEND_FASTCALL _is_numeric_string_ex(const char *str, size_t length, zend_long *lval,
90 double *dval, bool allow_errors, int *oflow_info, bool *trailing_data);
91
92 ZEND_API const char* ZEND_FASTCALL zend_memnstr_ex(const char *haystack, const char *needle, size_t needle_len, const char *end);
93 ZEND_API const char* ZEND_FASTCALL zend_memnrstr_ex(const char *haystack, const char *needle, size_t needle_len, const char *end);
94
95 #if SIZEOF_ZEND_LONG == 4
96 # define ZEND_DOUBLE_FITS_LONG(d) (!((d) > (double)ZEND_LONG_MAX || (d) < (double)ZEND_LONG_MIN))
97 #else
98 /* >= as (double)ZEND_LONG_MAX is outside signed range */
99 # define ZEND_DOUBLE_FITS_LONG(d) (!((d) >= (double)ZEND_LONG_MAX || (d) < (double)ZEND_LONG_MIN))
100 #endif
101
102 ZEND_API zend_long ZEND_FASTCALL zend_dval_to_lval_slow(double d);
103
zend_dval_to_lval(double d)104 static zend_always_inline zend_long zend_dval_to_lval(double d)
105 {
106 if (UNEXPECTED(!zend_finite(d)) || UNEXPECTED(zend_isnan(d))) {
107 return 0;
108 } else if (!ZEND_DOUBLE_FITS_LONG(d)) {
109 return zend_dval_to_lval_slow(d);
110 }
111 return (zend_long)d;
112 }
113
zend_dval_to_lval_cap(double d)114 static zend_always_inline zend_long zend_dval_to_lval_cap(double d)
115 {
116 if (UNEXPECTED(!zend_finite(d)) || UNEXPECTED(zend_isnan(d))) {
117 return 0;
118 } else if (!ZEND_DOUBLE_FITS_LONG(d)) {
119 return (d > 0 ? ZEND_LONG_MAX : ZEND_LONG_MIN);
120 }
121 return (zend_long)d;
122 }
123 /* }}} */
124
125 #define ZEND_IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
126 #define ZEND_IS_XDIGIT(c) (((c) >= 'A' && (c) <= 'F') || ((c) >= 'a' && (c) <= 'f'))
127
is_numeric_string_ex(const char * str,size_t length,zend_long * lval,double * dval,bool allow_errors,int * oflow_info,bool * trailing_data)128 static zend_always_inline zend_uchar is_numeric_string_ex(const char *str, size_t length, zend_long *lval,
129 double *dval, bool allow_errors, int *oflow_info, bool *trailing_data)
130 {
131 if (*str > '9') {
132 return 0;
133 }
134 return _is_numeric_string_ex(str, length, lval, dval, allow_errors, oflow_info, trailing_data);
135 }
136
is_numeric_string(const char * str,size_t length,zend_long * lval,double * dval,bool allow_errors)137 static zend_always_inline zend_uchar is_numeric_string(const char *str, size_t length, zend_long *lval, double *dval, bool allow_errors) {
138 return is_numeric_string_ex(str, length, lval, dval, allow_errors, NULL, NULL);
139 }
140
141 ZEND_API zend_uchar ZEND_FASTCALL is_numeric_str_function(const zend_string *str, zend_long *lval, double *dval);
142
143 static zend_always_inline const char *
zend_memnstr(const char * haystack,const char * needle,size_t needle_len,const char * end)144 zend_memnstr(const char *haystack, const char *needle, size_t needle_len, const char *end)
145 {
146 const char *p = haystack;
147 ptrdiff_t off_p;
148 size_t off_s;
149
150 if (needle_len == 0) {
151 return p;
152 }
153
154 if (needle_len == 1) {
155 return (const char *)memchr(p, *needle, (end-p));
156 }
157
158 off_p = end - haystack;
159 off_s = (off_p > 0) ? (size_t)off_p : 0;
160
161 if (needle_len > off_s) {
162 return NULL;
163 }
164
165 if (EXPECTED(off_s < 1024 || needle_len < 9)) { /* glibc memchr is faster when needle is too short */
166 const char ne = needle[needle_len-1];
167 end -= needle_len;
168
169 while (p <= end) {
170 if ((p = (const char *)memchr(p, *needle, (end-p+1))) && ne == p[needle_len-1]) {
171 if (!memcmp(needle+1, p+1, needle_len-2)) {
172 return p;
173 }
174 }
175
176 if (p == NULL) {
177 return NULL;
178 }
179
180 p++;
181 }
182
183 return NULL;
184 } else {
185 return zend_memnstr_ex(haystack, needle, needle_len, end);
186 }
187 }
188
zend_memrchr(const void * s,int c,size_t n)189 static zend_always_inline const void *zend_memrchr(const void *s, int c, size_t n)
190 {
191 const unsigned char *e;
192 if (0 == n) {
193 return NULL;
194 }
195
196 for (e = (const unsigned char *)s + n - 1; e >= (const unsigned char *)s; e--) {
197 if (*e == (const unsigned char)c) {
198 return (const void *)e;
199 }
200 }
201 return NULL;
202 }
203
204
205 static zend_always_inline const char *
zend_memnrstr(const char * haystack,const char * needle,size_t needle_len,const char * end)206 zend_memnrstr(const char *haystack, const char *needle, size_t needle_len, const char *end)
207 {
208 const char *p = end;
209 ptrdiff_t off_p;
210 size_t off_s;
211
212 if (needle_len == 0) {
213 return p;
214 }
215
216 if (needle_len == 1) {
217 return (const char *)zend_memrchr(haystack, *needle, (p - haystack));
218 }
219
220 off_p = end - haystack;
221 off_s = (off_p > 0) ? (size_t)off_p : 0;
222
223 if (needle_len > off_s) {
224 return NULL;
225 }
226
227 if (EXPECTED(off_s < 1024 || needle_len < 3)) {
228 const char ne = needle[needle_len-1];
229 p -= needle_len;
230
231 do {
232 p = (const char *)zend_memrchr(haystack, *needle, (p - haystack) + 1);
233 if (!p) {
234 return NULL;
235 }
236 if (ne == p[needle_len-1] && !memcmp(needle + 1, p + 1, needle_len - 2)) {
237 return p;
238 }
239 } while (p-- >= haystack);
240
241 return NULL;
242 } else {
243 return zend_memnrstr_ex(haystack, needle, needle_len, end);
244 }
245 }
246
247 ZEND_API zend_result ZEND_FASTCALL increment_function(zval *op1);
248 ZEND_API zend_result ZEND_FASTCALL decrement_function(zval *op2);
249
250 ZEND_API void ZEND_FASTCALL convert_scalar_to_number(zval *op);
251 ZEND_API void ZEND_FASTCALL _convert_to_string(zval *op);
252 ZEND_API void ZEND_FASTCALL convert_to_long(zval *op);
253 ZEND_API void ZEND_FASTCALL convert_to_double(zval *op);
254 ZEND_API void ZEND_FASTCALL convert_to_long_base(zval *op, int base);
255 ZEND_API void ZEND_FASTCALL convert_to_null(zval *op);
256 ZEND_API void ZEND_FASTCALL convert_to_boolean(zval *op);
257 ZEND_API void ZEND_FASTCALL convert_to_array(zval *op);
258 ZEND_API void ZEND_FASTCALL convert_to_object(zval *op);
259
260 ZEND_API zend_long ZEND_FASTCALL zval_get_long_func(zval *op);
261 ZEND_API double ZEND_FASTCALL zval_get_double_func(zval *op);
262 ZEND_API zend_string* ZEND_FASTCALL zval_get_string_func(zval *op);
263 ZEND_API zend_string* ZEND_FASTCALL zval_try_get_string_func(zval *op);
264
zval_get_long(zval * op)265 static zend_always_inline zend_long zval_get_long(zval *op) {
266 return EXPECTED(Z_TYPE_P(op) == IS_LONG) ? Z_LVAL_P(op) : zval_get_long_func(op);
267 }
zval_get_double(zval * op)268 static zend_always_inline double zval_get_double(zval *op) {
269 return EXPECTED(Z_TYPE_P(op) == IS_DOUBLE) ? Z_DVAL_P(op) : zval_get_double_func(op);
270 }
zval_get_string(zval * op)271 static zend_always_inline zend_string *zval_get_string(zval *op) {
272 return EXPECTED(Z_TYPE_P(op) == IS_STRING) ? zend_string_copy(Z_STR_P(op)) : zval_get_string_func(op);
273 }
274
zval_get_tmp_string(zval * op,zend_string ** tmp)275 static zend_always_inline zend_string *zval_get_tmp_string(zval *op, zend_string **tmp) {
276 if (EXPECTED(Z_TYPE_P(op) == IS_STRING)) {
277 *tmp = NULL;
278 return Z_STR_P(op);
279 } else {
280 return *tmp = zval_get_string_func(op);
281 }
282 }
zend_tmp_string_release(zend_string * tmp)283 static zend_always_inline void zend_tmp_string_release(zend_string *tmp) {
284 if (UNEXPECTED(tmp)) {
285 zend_string_release_ex(tmp, 0);
286 }
287 }
288
289 /* Like zval_get_string, but returns NULL if the conversion fails with an exception. */
zval_try_get_string(zval * op)290 static zend_always_inline zend_string *zval_try_get_string(zval *op) {
291 if (EXPECTED(Z_TYPE_P(op) == IS_STRING)) {
292 zend_string *ret = zend_string_copy(Z_STR_P(op));
293 ZEND_ASSUME(ret != NULL);
294 return ret;
295 } else {
296 return zval_try_get_string_func(op);
297 }
298 }
299
300 /* Like zval_get_tmp_string, but returns NULL if the conversion fails with an exception. */
zval_try_get_tmp_string(zval * op,zend_string ** tmp)301 static zend_always_inline zend_string *zval_try_get_tmp_string(zval *op, zend_string **tmp) {
302 if (EXPECTED(Z_TYPE_P(op) == IS_STRING)) {
303 zend_string *ret = Z_STR_P(op);
304 *tmp = NULL;
305 ZEND_ASSUME(ret != NULL);
306 return ret;
307 } else {
308 return *tmp = zval_try_get_string_func(op);
309 }
310 }
311
312 /* Like convert_to_string(), but returns whether the conversion succeeded and does not modify the
313 * zval in-place if it fails. */
314 ZEND_API zend_bool ZEND_FASTCALL _try_convert_to_string(zval *op);
try_convert_to_string(zval * op)315 static zend_always_inline zend_bool try_convert_to_string(zval *op) {
316 if (Z_TYPE_P(op) == IS_STRING) {
317 return 1;
318 }
319 return _try_convert_to_string(op);
320 }
321
322 /* Compatibility macros for 7.2 and below */
323 #define _zval_get_long(op) zval_get_long(op)
324 #define _zval_get_double(op) zval_get_double(op)
325 #define _zval_get_string(op) zval_get_string(op)
326 #define _zval_get_long_func(op) zval_get_long_func(op)
327 #define _zval_get_double_func(op) zval_get_double_func(op)
328 #define _zval_get_string_func(op) zval_get_string_func(op)
329
330 #define convert_to_string(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_string((op)); }
331
332
333 ZEND_API int ZEND_FASTCALL zend_is_true(zval *op);
334 ZEND_API bool ZEND_FASTCALL zend_object_is_true(zval *op);
335
336 #define zval_is_true(op) \
337 zend_is_true(op)
338
i_zend_is_true(zval * op)339 static zend_always_inline bool i_zend_is_true(zval *op)
340 {
341 bool result = 0;
342
343 again:
344 switch (Z_TYPE_P(op)) {
345 case IS_TRUE:
346 result = 1;
347 break;
348 case IS_LONG:
349 if (Z_LVAL_P(op)) {
350 result = 1;
351 }
352 break;
353 case IS_DOUBLE:
354 if (Z_DVAL_P(op)) {
355 result = 1;
356 }
357 break;
358 case IS_STRING:
359 if (Z_STRLEN_P(op) > 1 || (Z_STRLEN_P(op) && Z_STRVAL_P(op)[0] != '0')) {
360 result = 1;
361 }
362 break;
363 case IS_ARRAY:
364 if (zend_hash_num_elements(Z_ARRVAL_P(op))) {
365 result = 1;
366 }
367 break;
368 case IS_OBJECT:
369 if (EXPECTED(Z_OBJ_HT_P(op)->cast_object == zend_std_cast_object_tostring)) {
370 result = 1;
371 } else {
372 result = zend_object_is_true(op);
373 }
374 break;
375 case IS_RESOURCE:
376 if (EXPECTED(Z_RES_HANDLE_P(op))) {
377 result = 1;
378 }
379 break;
380 case IS_REFERENCE:
381 op = Z_REFVAL_P(op);
382 goto again;
383 break;
384 default:
385 break;
386 }
387 return result;
388 }
389
390 /* Indicate that two values cannot be compared. This value should be returned for both orderings
391 * of the operands. This implies that all of ==, <, <= and >, >= will return false, because we
392 * canonicalize >/>= to </<= with swapped operands. */
393 // TODO: Use a different value to allow an actual distinction here.
394 #define ZEND_UNCOMPARABLE 1
395
396 ZEND_API int ZEND_FASTCALL zend_compare(zval *op1, zval *op2);
397
398 ZEND_API int ZEND_FASTCALL compare_function(zval *result, zval *op1, zval *op2);
399
400 ZEND_API int ZEND_FASTCALL numeric_compare_function(zval *op1, zval *op2);
401 ZEND_API int ZEND_FASTCALL string_compare_function_ex(zval *op1, zval *op2, zend_bool case_insensitive);
402 ZEND_API int ZEND_FASTCALL string_compare_function(zval *op1, zval *op2);
403 ZEND_API int ZEND_FASTCALL string_case_compare_function(zval *op1, zval *op2);
404 ZEND_API int ZEND_FASTCALL string_locale_compare_function(zval *op1, zval *op2);
405
406 ZEND_API void ZEND_FASTCALL zend_str_tolower(char *str, size_t length);
407 ZEND_API char* ZEND_FASTCALL zend_str_tolower_copy(char *dest, const char *source, size_t length);
408 ZEND_API char* ZEND_FASTCALL zend_str_tolower_dup(const char *source, size_t length);
409 ZEND_API char* ZEND_FASTCALL zend_str_tolower_dup_ex(const char *source, size_t length);
410 ZEND_API zend_string* ZEND_FASTCALL zend_string_tolower_ex(zend_string *str, bool persistent);
411
412 #define zend_string_tolower(str) zend_string_tolower_ex(str, 0)
413
414 ZEND_API int ZEND_FASTCALL zend_binary_zval_strcmp(zval *s1, zval *s2);
415 ZEND_API int ZEND_FASTCALL zend_binary_zval_strncmp(zval *s1, zval *s2, zval *s3);
416 ZEND_API int ZEND_FASTCALL zend_binary_zval_strcasecmp(zval *s1, zval *s2);
417 ZEND_API int ZEND_FASTCALL zend_binary_zval_strncasecmp(zval *s1, zval *s2, zval *s3);
418 ZEND_API int ZEND_FASTCALL zend_binary_strcmp(const char *s1, size_t len1, const char *s2, size_t len2);
419 ZEND_API int ZEND_FASTCALL zend_binary_strncmp(const char *s1, size_t len1, const char *s2, size_t len2, size_t length);
420 ZEND_API int ZEND_FASTCALL zend_binary_strcasecmp(const char *s1, size_t len1, const char *s2, size_t len2);
421 ZEND_API int ZEND_FASTCALL zend_binary_strncasecmp(const char *s1, size_t len1, const char *s2, size_t len2, size_t length);
422 ZEND_API int ZEND_FASTCALL zend_binary_strcasecmp_l(const char *s1, size_t len1, const char *s2, size_t len2);
423 ZEND_API int ZEND_FASTCALL zend_binary_strncasecmp_l(const char *s1, size_t len1, const char *s2, size_t len2, size_t length);
424
425 ZEND_API bool ZEND_FASTCALL zendi_smart_streq(zend_string *s1, zend_string *s2);
426 ZEND_API int ZEND_FASTCALL zendi_smart_strcmp(zend_string *s1, zend_string *s2);
427 ZEND_API int ZEND_FASTCALL zend_compare_symbol_tables(HashTable *ht1, HashTable *ht2);
428 ZEND_API int ZEND_FASTCALL zend_compare_arrays(zval *a1, zval *a2);
429 ZEND_API int ZEND_FASTCALL zend_compare_objects(zval *o1, zval *o2);
430
431 ZEND_API int ZEND_FASTCALL zend_atoi(const char *str, size_t str_len);
432 ZEND_API zend_long ZEND_FASTCALL zend_atol(const char *str, size_t str_len);
433
434 ZEND_API void ZEND_FASTCALL zend_locale_sprintf_double(zval *op ZEND_FILE_LINE_DC);
435
436 #define convert_to_ex_master(pzv, lower_type, upper_type) \
437 if (Z_TYPE_P(pzv)!=upper_type) { \
438 convert_to_##lower_type(pzv); \
439 }
440
441 #define convert_to_explicit_type(pzv, type) \
442 do { \
443 switch (type) { \
444 case IS_NULL: \
445 convert_to_null(pzv); \
446 break; \
447 case IS_LONG: \
448 convert_to_long(pzv); \
449 break; \
450 case IS_DOUBLE: \
451 convert_to_double(pzv); \
452 break; \
453 case _IS_BOOL: \
454 convert_to_boolean(pzv); \
455 break; \
456 case IS_ARRAY: \
457 convert_to_array(pzv); \
458 break; \
459 case IS_OBJECT: \
460 convert_to_object(pzv); \
461 break; \
462 case IS_STRING: \
463 convert_to_string(pzv); \
464 break; \
465 default: \
466 assert(0); \
467 break; \
468 } \
469 } while (0);
470
471 #define convert_to_explicit_type_ex(pzv, str_type) \
472 if (Z_TYPE_P(pzv) != str_type) { \
473 convert_to_explicit_type(pzv, str_type); \
474 }
475
476 #define convert_to_boolean_ex(pzv) do { \
477 if (Z_TYPE_INFO_P(pzv) > IS_TRUE) { \
478 convert_to_boolean(pzv); \
479 } else if (Z_TYPE_INFO_P(pzv) < IS_FALSE) { \
480 ZVAL_FALSE(pzv); \
481 } \
482 } while (0)
483 #define convert_to_long_ex(pzv) convert_to_ex_master(pzv, long, IS_LONG)
484 #define convert_to_double_ex(pzv) convert_to_ex_master(pzv, double, IS_DOUBLE)
485 #define convert_to_string_ex(pzv) convert_to_ex_master(pzv, string, IS_STRING)
486 #define convert_to_array_ex(pzv) convert_to_ex_master(pzv, array, IS_ARRAY)
487 #define convert_to_object_ex(pzv) convert_to_ex_master(pzv, object, IS_OBJECT)
488 #define convert_to_null_ex(pzv) convert_to_ex_master(pzv, null, IS_NULL)
489
490 #define convert_scalar_to_number_ex(pzv) \
491 if (Z_TYPE_P(pzv)!=IS_LONG && Z_TYPE_P(pzv)!=IS_DOUBLE) { \
492 convert_scalar_to_number(pzv); \
493 }
494
495 #if defined(ZEND_WIN32) && !defined(ZTS) && defined(_MSC_VER)
496 /* This performance improvement of tolower() on Windows gives 10-18% on bench.php */
497 #define ZEND_USE_TOLOWER_L 1
498 #endif
499
500 #ifdef ZEND_USE_TOLOWER_L
501 ZEND_API void zend_update_current_locale(void);
502 #else
503 #define zend_update_current_locale()
504 #endif
505
506 /* The offset in bytes between the value and type fields of a zval */
507 #define ZVAL_OFFSETOF_TYPE \
508 (offsetof(zval, u1.type_info) - offsetof(zval, value))
509
510 #if defined(HAVE_ASM_GOTO) && !__has_feature(memory_sanitizer)
511 # define ZEND_USE_ASM_ARITHMETIC 1
512 #else
513 # define ZEND_USE_ASM_ARITHMETIC 0
514 #endif
515
fast_long_increment_function(zval * op1)516 static zend_always_inline void fast_long_increment_function(zval *op1)
517 {
518 #if ZEND_USE_ASM_ARITHMETIC && defined(__i386__) && !(4 == __GNUC__ && 8 == __GNUC_MINOR__)
519 __asm__ goto(
520 "addl $1,(%0)\n\t"
521 "jo %l1\n"
522 :
523 : "r"(&op1->value)
524 : "cc", "memory"
525 : overflow);
526 return;
527 overflow: ZEND_ATTRIBUTE_COLD_LABEL
528 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MAX + 1.0);
529 #elif ZEND_USE_ASM_ARITHMETIC && defined(__x86_64__)
530 __asm__ goto(
531 "addq $1,(%0)\n\t"
532 "jo %l1\n"
533 :
534 : "r"(&op1->value)
535 : "cc", "memory"
536 : overflow);
537 return;
538 overflow: ZEND_ATTRIBUTE_COLD_LABEL
539 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MAX + 1.0);
540 #elif ZEND_USE_ASM_ARITHMETIC && defined(__aarch64__)
541 __asm__ goto (
542 "ldr x5, [%0]\n\t"
543 "adds x5, x5, 1\n\t"
544 "bvs %l1\n"
545 "str x5, [%0]"
546 :
547 : "r"(&op1->value)
548 : "x5", "cc", "memory"
549 : overflow);
550 return;
551 overflow: ZEND_ATTRIBUTE_COLD_LABEL
552 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MAX + 1.0);
553 #elif PHP_HAVE_BUILTIN_SADDL_OVERFLOW && SIZEOF_LONG == SIZEOF_ZEND_LONG
554 long lresult;
555 if (UNEXPECTED(__builtin_saddl_overflow(Z_LVAL_P(op1), 1, &lresult))) {
556 /* switch to double */
557 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MAX + 1.0);
558 } else {
559 Z_LVAL_P(op1) = lresult;
560 }
561 #elif PHP_HAVE_BUILTIN_SADDLL_OVERFLOW && SIZEOF_LONG_LONG == SIZEOF_ZEND_LONG
562 long long llresult;
563 if (UNEXPECTED(__builtin_saddll_overflow(Z_LVAL_P(op1), 1, &llresult))) {
564 /* switch to double */
565 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MAX + 1.0);
566 } else {
567 Z_LVAL_P(op1) = llresult;
568 }
569 #else
570 if (UNEXPECTED(Z_LVAL_P(op1) == ZEND_LONG_MAX)) {
571 /* switch to double */
572 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MAX + 1.0);
573 } else {
574 Z_LVAL_P(op1)++;
575 }
576 #endif
577 }
578
fast_long_decrement_function(zval * op1)579 static zend_always_inline void fast_long_decrement_function(zval *op1)
580 {
581 #if ZEND_USE_ASM_ARITHMETIC && defined(__i386__) && !(4 == __GNUC__ && 8 == __GNUC_MINOR__)
582 __asm__ goto(
583 "subl $1,(%0)\n\t"
584 "jo %l1\n"
585 :
586 : "r"(&op1->value)
587 : "cc", "memory"
588 : overflow);
589 return;
590 overflow: ZEND_ATTRIBUTE_COLD_LABEL
591 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MIN - 1.0);
592 #elif ZEND_USE_ASM_ARITHMETIC && defined(__x86_64__)
593 __asm__ goto(
594 "subq $1,(%0)\n\t"
595 "jo %l1\n"
596 :
597 : "r"(&op1->value)
598 : "cc", "memory"
599 : overflow);
600 return;
601 overflow: ZEND_ATTRIBUTE_COLD_LABEL
602 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MIN - 1.0);
603 #elif ZEND_USE_ASM_ARITHMETIC && defined(__aarch64__)
604 __asm__ goto (
605 "ldr x5, [%0]\n\t"
606 "subs x5 ,x5, 1\n\t"
607 "bvs %l1\n"
608 "str x5, [%0]"
609 :
610 : "r"(&op1->value)
611 : "x5", "cc", "memory"
612 : overflow);
613 return;
614 overflow: ZEND_ATTRIBUTE_COLD_LABEL
615 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MIN - 1.0);
616 #elif PHP_HAVE_BUILTIN_SSUBL_OVERFLOW && SIZEOF_LONG == SIZEOF_ZEND_LONG
617 long lresult;
618 if (UNEXPECTED(__builtin_ssubl_overflow(Z_LVAL_P(op1), 1, &lresult))) {
619 /* switch to double */
620 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MIN - 1.0);
621 } else {
622 Z_LVAL_P(op1) = lresult;
623 }
624 #elif PHP_HAVE_BUILTIN_SSUBLL_OVERFLOW && SIZEOF_LONG_LONG == SIZEOF_ZEND_LONG
625 long long llresult;
626 if (UNEXPECTED(__builtin_ssubll_overflow(Z_LVAL_P(op1), 1, &llresult))) {
627 /* switch to double */
628 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MIN - 1.0);
629 } else {
630 Z_LVAL_P(op1) = llresult;
631 }
632 #else
633 if (UNEXPECTED(Z_LVAL_P(op1) == ZEND_LONG_MIN)) {
634 /* switch to double */
635 ZVAL_DOUBLE(op1, (double)ZEND_LONG_MIN - 1.0);
636 } else {
637 Z_LVAL_P(op1)--;
638 }
639 #endif
640 }
641
fast_long_add_function(zval * result,zval * op1,zval * op2)642 static zend_always_inline void fast_long_add_function(zval *result, zval *op1, zval *op2)
643 {
644 #if ZEND_USE_ASM_ARITHMETIC && defined(__i386__) && !(4 == __GNUC__ && 8 == __GNUC_MINOR__)
645 __asm__ goto(
646 "movl (%1), %%eax\n\t"
647 "addl (%2), %%eax\n\t"
648 "jo %l5\n\t"
649 "movl %%eax, (%0)\n\t"
650 "movl %3, %c4(%0)\n"
651 :
652 : "r"(&result->value),
653 "r"(&op1->value),
654 "r"(&op2->value),
655 "n"(IS_LONG),
656 "n"(ZVAL_OFFSETOF_TYPE)
657 : "eax","cc", "memory"
658 : overflow);
659 return;
660 overflow: ZEND_ATTRIBUTE_COLD_LABEL
661 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2));
662 #elif ZEND_USE_ASM_ARITHMETIC && defined(__x86_64__)
663 __asm__ goto(
664 "movq (%1), %%rax\n\t"
665 "addq (%2), %%rax\n\t"
666 "jo %l5\n\t"
667 "movq %%rax, (%0)\n\t"
668 "movl %3, %c4(%0)\n"
669 :
670 : "r"(&result->value),
671 "r"(&op1->value),
672 "r"(&op2->value),
673 "n"(IS_LONG),
674 "n"(ZVAL_OFFSETOF_TYPE)
675 : "rax","cc", "memory"
676 : overflow);
677 return;
678 overflow: ZEND_ATTRIBUTE_COLD_LABEL
679 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2));
680 #elif ZEND_USE_ASM_ARITHMETIC && defined(__aarch64__)
681 __asm__ goto(
682 "ldr x5, [%1]\n\t"
683 "ldr x6, [%2]\n\t"
684 "adds x5, x5, x6\n\t"
685 "bvs %l5\n\t"
686 "mov w6, %3\n\t"
687 "str x5, [%0]\n\t"
688 "str w6, [%0, %c4]\n"
689 :
690 : "r"(&result->value),
691 "r"(&op1->value),
692 "r"(&op2->value),
693 "n"(IS_LONG),
694 "n"(ZVAL_OFFSETOF_TYPE)
695 : "x5", "x6", "cc", "memory"
696 : overflow);
697 return;
698 overflow: ZEND_ATTRIBUTE_COLD_LABEL
699 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2));
700 #elif PHP_HAVE_BUILTIN_SADDL_OVERFLOW && SIZEOF_LONG == SIZEOF_ZEND_LONG
701 long lresult;
702 if (UNEXPECTED(__builtin_saddl_overflow(Z_LVAL_P(op1), Z_LVAL_P(op2), &lresult))) {
703 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2));
704 } else {
705 ZVAL_LONG(result, lresult);
706 }
707 #elif PHP_HAVE_BUILTIN_SADDLL_OVERFLOW && SIZEOF_LONG_LONG == SIZEOF_ZEND_LONG
708 long long llresult;
709 if (UNEXPECTED(__builtin_saddll_overflow(Z_LVAL_P(op1), Z_LVAL_P(op2), &llresult))) {
710 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2));
711 } else {
712 ZVAL_LONG(result, llresult);
713 }
714 #else
715 /*
716 * 'result' may alias with op1 or op2, so we need to
717 * ensure that 'result' is not updated until after we
718 * have read the values of op1 and op2.
719 */
720
721 if (UNEXPECTED((Z_LVAL_P(op1) & LONG_SIGN_MASK) == (Z_LVAL_P(op2) & LONG_SIGN_MASK)
722 && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != ((Z_LVAL_P(op1) + Z_LVAL_P(op2)) & LONG_SIGN_MASK))) {
723 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2));
724 } else {
725 ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
726 }
727 #endif
728 }
729
fast_add_function(zval * result,zval * op1,zval * op2)730 static zend_always_inline zend_result fast_add_function(zval *result, zval *op1, zval *op2)
731 {
732 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
733 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
734 fast_long_add_function(result, op1, op2);
735 return SUCCESS;
736 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
737 ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));
738 return SUCCESS;
739 }
740 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
741 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
742 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
743 return SUCCESS;
744 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
745 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));
746 return SUCCESS;
747 }
748 }
749 return add_function(result, op1, op2);
750 }
751
fast_long_sub_function(zval * result,zval * op1,zval * op2)752 static zend_always_inline void fast_long_sub_function(zval *result, zval *op1, zval *op2)
753 {
754 #if ZEND_USE_ASM_ARITHMETIC && defined(__i386__) && !(4 == __GNUC__ && 8 == __GNUC_MINOR__)
755 __asm__ goto(
756 "movl (%1), %%eax\n\t"
757 "subl (%2), %%eax\n\t"
758 "jo %l5\n\t"
759 "movl %%eax, (%0)\n\t"
760 "movl %3, %c4(%0)\n"
761 :
762 : "r"(&result->value),
763 "r"(&op1->value),
764 "r"(&op2->value),
765 "n"(IS_LONG),
766 "n"(ZVAL_OFFSETOF_TYPE)
767 : "eax","cc", "memory"
768 : overflow);
769 return;
770 overflow: ZEND_ATTRIBUTE_COLD_LABEL
771 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2));
772 #elif ZEND_USE_ASM_ARITHMETIC && defined(__x86_64__)
773 __asm__ goto(
774 "movq (%1), %%rax\n\t"
775 "subq (%2), %%rax\n\t"
776 "jo %l5\n\t"
777 "movq %%rax, (%0)\n\t"
778 "movl %3, %c4(%0)\n"
779 :
780 : "r"(&result->value),
781 "r"(&op1->value),
782 "r"(&op2->value),
783 "n"(IS_LONG),
784 "n"(ZVAL_OFFSETOF_TYPE)
785 : "rax","cc", "memory"
786 : overflow);
787 return;
788 overflow: ZEND_ATTRIBUTE_COLD_LABEL
789 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2));
790 #elif ZEND_USE_ASM_ARITHMETIC && defined(__aarch64__)
791 __asm__ goto(
792 "ldr x5, [%1]\n\t"
793 "ldr x6, [%2]\n\t"
794 "subs x5, x5, x6\n\t"
795 "bvs %l5\n\t"
796 "mov w6, %3\n\t"
797 "str x5, [%0]\n\t"
798 "str w6, [%0, %c4]\n"
799 :
800 : "r"(&result->value),
801 "r"(&op1->value),
802 "r"(&op2->value),
803 "n"(IS_LONG),
804 "n"(ZVAL_OFFSETOF_TYPE)
805 : "x5", "x6", "cc", "memory"
806 : overflow);
807 return;
808 overflow: ZEND_ATTRIBUTE_COLD_LABEL
809 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2));
810 #elif PHP_HAVE_BUILTIN_SSUBL_OVERFLOW && SIZEOF_LONG == SIZEOF_ZEND_LONG
811 long lresult;
812 if (UNEXPECTED(__builtin_ssubl_overflow(Z_LVAL_P(op1), Z_LVAL_P(op2), &lresult))) {
813 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2));
814 } else {
815 ZVAL_LONG(result, lresult);
816 }
817 #elif PHP_HAVE_BUILTIN_SSUBLL_OVERFLOW && SIZEOF_LONG_LONG == SIZEOF_ZEND_LONG
818 long long llresult;
819 if (UNEXPECTED(__builtin_ssubll_overflow(Z_LVAL_P(op1), Z_LVAL_P(op2), &llresult))) {
820 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2));
821 } else {
822 ZVAL_LONG(result, llresult);
823 }
824 #else
825 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
826
827 if (UNEXPECTED((Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(op2) & LONG_SIGN_MASK)
828 && (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(result) & LONG_SIGN_MASK))) {
829 ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2));
830 }
831 #endif
832 }
833
fast_div_function(zval * result,zval * op1,zval * op2)834 static zend_always_inline zend_result fast_div_function(zval *result, zval *op1, zval *op2)
835 {
836 return div_function(result, op1, op2);
837 }
838
zend_fast_equal_strings(zend_string * s1,zend_string * s2)839 static zend_always_inline bool zend_fast_equal_strings(zend_string *s1, zend_string *s2)
840 {
841 if (s1 == s2) {
842 return 1;
843 } else if (ZSTR_VAL(s1)[0] > '9' || ZSTR_VAL(s2)[0] > '9') {
844 return zend_string_equal_content(s1, s2);
845 } else {
846 return zendi_smart_streq(s1, s2);
847 }
848 }
849
fast_equal_check_function(zval * op1,zval * op2)850 static zend_always_inline bool fast_equal_check_function(zval *op1, zval *op2)
851 {
852 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
853 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
854 return Z_LVAL_P(op1) == Z_LVAL_P(op2);
855 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
856 return ((double)Z_LVAL_P(op1)) == Z_DVAL_P(op2);
857 }
858 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
859 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
860 return Z_DVAL_P(op1) == Z_DVAL_P(op2);
861 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
862 return Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2));
863 }
864 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
865 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
866 return zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
867 }
868 }
869 return zend_compare(op1, op2) == 0;
870 }
871
fast_equal_check_long(zval * op1,zval * op2)872 static zend_always_inline bool fast_equal_check_long(zval *op1, zval *op2)
873 {
874 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
875 return Z_LVAL_P(op1) == Z_LVAL_P(op2);
876 }
877 return zend_compare(op1, op2) == 0;
878 }
879
fast_equal_check_string(zval * op1,zval * op2)880 static zend_always_inline bool fast_equal_check_string(zval *op1, zval *op2)
881 {
882 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
883 return zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
884 }
885 return zend_compare(op1, op2) == 0;
886 }
887
fast_is_identical_function(zval * op1,zval * op2)888 static zend_always_inline zend_bool fast_is_identical_function(zval *op1, zval *op2)
889 {
890 if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
891 return 0;
892 } else if (Z_TYPE_P(op1) <= IS_TRUE) {
893 return 1;
894 }
895 return zend_is_identical(op1, op2);
896 }
897
fast_is_not_identical_function(zval * op1,zval * op2)898 static zend_always_inline zend_bool fast_is_not_identical_function(zval *op1, zval *op2)
899 {
900 if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
901 return 1;
902 } else if (Z_TYPE_P(op1) <= IS_TRUE) {
903 return 0;
904 }
905 return !zend_is_identical(op1, op2);
906 }
907
908 /* buf points to the END of the buffer */
zend_print_ulong_to_buf(char * buf,zend_ulong num)909 static zend_always_inline char *zend_print_ulong_to_buf(char *buf, zend_ulong num) {
910 *buf = '\0';
911 do {
912 *--buf = (char) (num % 10) + '0';
913 num /= 10;
914 } while (num > 0);
915 return buf;
916 }
917
918 /* buf points to the END of the buffer */
zend_print_long_to_buf(char * buf,zend_long num)919 static zend_always_inline char *zend_print_long_to_buf(char *buf, zend_long num) {
920 if (num < 0) {
921 char *result = zend_print_ulong_to_buf(buf, ~((zend_ulong) num) + 1);
922 *--result = '-';
923 return result;
924 } else {
925 return zend_print_ulong_to_buf(buf, num);
926 }
927 }
928
929 ZEND_API zend_string* ZEND_FASTCALL zend_long_to_str(zend_long num);
930
zend_unwrap_reference(zval * op)931 static zend_always_inline void zend_unwrap_reference(zval *op) /* {{{ */
932 {
933 if (Z_REFCOUNT_P(op) == 1) {
934 ZVAL_UNREF(op);
935 } else {
936 Z_DELREF_P(op);
937 ZVAL_COPY(op, Z_REFVAL_P(op));
938 }
939 }
940 /* }}} */
941
942
943 END_EXTERN_C()
944
945 #endif
946
